diff --git a/.gitattributes b/.gitattributes
index fdd31021f72c8..e6d31d6aa31fc 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -7,6 +7,7 @@
 *.bat text eol=crlf
 
 # These are binary so should never be modified by git.
+*.a binary
 *.png binary
 *.jpg binary
 *.dxf binary
diff --git a/.gitignore b/.gitignore
index 5e841a89c059d..50bd30e877e87 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,9 +20,10 @@
 ######################
 *.swp
 
-# Build directory
+# Build directories
 ######################
 build/
+build-*/
 
 # Test failure outputs
 ######################
diff --git a/.gitmodules b/.gitmodules
index c986704caa416..c152e9e7747fa 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -18,3 +18,21 @@
 [submodule "lib/nrfx"]
 	path = lib/nrfx
 	url = https://github.com/NordicSemiconductor/nrfx.git
+[submodule "lib/mbedtls"]
+	path = lib/mbedtls
+	url = https://github.com/ARMmbed/mbedtls.git
+[submodule "lib/asf4"]
+	path = lib/asf4
+	url = https://github.com/adafruit/asf4
+[submodule "lib/tinyusb"]
+	path = lib/tinyusb
+	url = https://github.com/hathach/tinyusb
+[submodule "lib/mynewt-nimble"]
+	path = lib/mynewt-nimble
+	url = https://github.com/apache/mynewt-nimble.git
+[submodule "lib/btstack"]
+	path = lib/btstack
+	url = https://github.com/bluekitchen/btstack.git
+[submodule "lib/nxp_driver"]
+	path = lib/nxp_driver
+	url = https://github.com/hathach/nxp_driver.git
diff --git a/.travis.yml b/.travis.yml
index 0ba9a002233fe..414fe2b59d108 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -10,150 +10,350 @@ cache:
 env:
   global:
     - MAKEOPTS="-j4"
+git:
+  submodules: false
 
 # define the successive stages
 stages:
   - name: test
 
 # define the jobs for the stages
-# order of the jobs has longest running first to optimise total time
+# approx order of the jobs has longest running first to optimise total time
 jobs:
   include:
+    # check code formatting
+    - stage: test
+      os: linux
+      dist: bionic
+      name: "code formatting"
+      before_install:
+        - sudo apt-add-repository --yes --update ppa:pybricks/ppa
+      install:
+        - sudo apt-get install uncrustify python3-pip
+        - uncrustify --version
+        - pip3 install --user black
+        - black --version
+      script:
+        - tools/codeformat.py
+        - git diff --exit-code
+
+    # unix port on OSX (first in list because the build VM takes a long time to start)
+    - stage: test
+      os: osx
+      osx_image: xcode11.3
+      name: "unix port build with clang on OSX"
+      env:
+        - PKG_CONFIG_PATH=/usr/local/opt/libffi/lib/pkgconfig
+      script:
+        - make ${MAKEOPTS} -C mpy-cross
+        - make ${MAKEOPTS} -C ports/unix submodules
+        - make ${MAKEOPTS} -C ports/unix deplibs
+        - make ${MAKEOPTS} -C ports/unix
+        # OSX has poor time resolution and the following tests do not have the correct output
+        - (cd tests && ./run-tests --exclude 'uasyncio_(basic|heaplock|lock|wait_task)')
+        # check for additional compiler errors/warnings
+        - make ${MAKEOPTS} -C ports/unix VARIANT=coverage submodules
+        - make ${MAKEOPTS} -C ports/unix VARIANT=coverage
+      after_failure:
+        - tests/run-tests --print-failures
+
     # stm32 port
     - stage: test
-      env: NAME="stm32 port build"
+      name: "stm32 port build"
       install:
         # need newer gcc version for Cortex-M7 support
         - sudo add-apt-repository -y ppa:team-gcc-arm-embedded/ppa
         - sudo apt-get update -qq || true
-        - sudo apt-get install gcc-arm-embedded
-        - sudo apt-get install libnewlib-arm-none-eabi
+        - sudo apt-get install gcc-arm-embedded libnewlib-arm-none-eabi
         - arm-none-eabi-gcc --version
       script:
         - make ${MAKEOPTS} -C mpy-cross
-        - make ${MAKEOPTS} -C ports/stm32
+        - make ${MAKEOPTS} -C ports/stm32 submodules
+        - git submodule update --init lib/btstack
+        - make ${MAKEOPTS} -C ports/stm32 BOARD=NUCLEO_F091RC
         - make ${MAKEOPTS} -C ports/stm32 BOARD=PYBV11 MICROPY_PY_WIZNET5K=5200 MICROPY_PY_CC3K=1
-        - make ${MAKEOPTS} -C ports/stm32 BOARD=STM32F769DISC
+        - make ${MAKEOPTS} -C ports/stm32 BOARD=PYBD_SF2
+        - make ${MAKEOPTS} -C ports/stm32 BOARD=PYBD_SF6 NANBOX=1 MICROPY_BLUETOOTH_NIMBLE=0 MICROPY_BLUETOOTH_BTSTACK=1
+        - make ${MAKEOPTS} -C ports/stm32 BOARD=NUCLEO_H743ZI CFLAGS_EXTRA='-DMICROPY_PY_THREAD=1'
+        - make ${MAKEOPTS} -C ports/stm32 BOARD=NUCLEO_L073RZ
         - make ${MAKEOPTS} -C ports/stm32 BOARD=STM32L476DISC
+        - make ${MAKEOPTS} -C ports/stm32 BOARD=NUCLEO_WB55
+        - make ${MAKEOPTS} -C ports/stm32/mboot BOARD=PYBD_SF6
 
     # qemu-arm port
     - stage: test
-      env: NAME="qemu-arm port build and tests"
+      dist: bionic # needed for more recent version of qemu-system-arm with mps2-an385 target
+      name: "qemu-arm port build and tests"
       install:
-        - sudo apt-get install gcc-arm-none-eabi
-        - sudo apt-get install libnewlib-arm-none-eabi
-        - sudo apt-get install qemu-system
+        - sudo apt-get install gcc-arm-none-eabi libnewlib-arm-none-eabi qemu-system
         - arm-none-eabi-gcc --version
         - qemu-system-arm --version
       script:
         - make ${MAKEOPTS} -C mpy-cross
         - make ${MAKEOPTS} -C ports/qemu-arm -f Makefile.test test
       after_failure:
-        - grep "FAIL" ports/qemu-arm/build/console.out
+        - grep --text "FAIL" ports/qemu-arm/build/console.out
 
     # unix coverage
     - stage: test
-      env: NAME="unix coverage build and tests"
+      name: "unix coverage build and tests"
       install:
+        - sudo apt-get install python3-pip
         - sudo pip install cpp-coveralls
+        - sudo pip3 install setuptools
+        - sudo pip3 install pyelftools
         - gcc --version
         - python3 --version
       script:
         - make ${MAKEOPTS} -C mpy-cross
-        - make ${MAKEOPTS} -C ports/unix deplibs
-        - make ${MAKEOPTS} -C ports/unix coverage
+        - make ${MAKEOPTS} -C ports/unix VARIANT=coverage submodules
+        - make ${MAKEOPTS} -C ports/unix VARIANT=coverage deplibs
+        - make ${MAKEOPTS} -C ports/unix VARIANT=coverage
         # run the main test suite
-        - (cd tests && MICROPY_CPYTHON3=python3 MICROPY_MICROPYTHON=../ports/unix/micropython_coverage ./run-tests)
-        - (cd tests && MICROPY_CPYTHON3=python3 MICROPY_MICROPYTHON=../ports/unix/micropython_coverage ./run-tests -d thread)
-        - (cd tests && MICROPY_CPYTHON3=python3 MICROPY_MICROPYTHON=../ports/unix/micropython_coverage ./run-tests --emit native)
-        - (cd tests && MICROPY_CPYTHON3=python3 MICROPY_MICROPYTHON=../ports/unix/micropython_coverage ./run-tests --via-mpy -d basics float micropython)
-        - (cd tests && MICROPY_CPYTHON3=python3 MICROPY_MICROPYTHON=../ports/unix/micropython_coverage ./run-tests --via-mpy --emit native -d basics float micropython)
-        # test when input script comes from stdin
-        - cat tests/basics/0prelim.py | ports/unix/micropython_coverage | grep -q 'abc'
+        - make -C ports/unix VARIANT=coverage test_full
+        - (cd tests && MICROPY_CPYTHON3=python3 MICROPY_MICROPYTHON=../ports/unix/micropython-coverage ./run-multitests.py multi_net/*.py) || travis_terminate 1
+        # test building native mpy modules
+        - make -C examples/natmod/features1 ARCH=x64
+        - make -C examples/natmod/features2 ARCH=x64
+        - make -C examples/natmod/btree ARCH=x64
+        - make -C examples/natmod/framebuf ARCH=x64
+        - make -C examples/natmod/uheapq ARCH=x64
+        - make -C examples/natmod/urandom ARCH=x64
+        - make -C examples/natmod/ure ARCH=x64
+        - make -C examples/natmod/uzlib ARCH=x64
+        # test importing .mpy generated by mpy_ld.py
+        - MICROPYPATH=examples/natmod/features2 ./ports/unix/micropython-coverage -m features2
+        - (cd tests && ./run-natmodtests.py extmod/{btree*,framebuf*,uheapq*,ure*,uzlib*}.py)
         # run coveralls coverage analysis (try to, even if some builds/tests failed)
         - (cd ports/unix && coveralls --root ../.. --build-root . --gcov $(which gcov) --gcov-options '\-o build-coverage/' --include py --include extmod)
       after_failure:
-        - (cd tests && for exp in *.exp; do testbase=$(basename $exp .exp); echo -e "\nFAILURE $testbase"; diff -u $testbase.exp $testbase.out; done)
+        - tests/run-tests --print-failures
+
+    # unix coverage 32-bit
+    - stage: test
+      name: "unix coverage 32-bit build and tests"
+      install:
+        - sudo apt-get install gcc-multilib libffi-dev:i386
+        - sudo apt-get install python3-pip
+        - sudo pip3 install setuptools
+        - sudo pip3 install pyelftools
+        - gcc --version
+        - python3 --version
+      script:
+        - make ${MAKEOPTS} -C mpy-cross
+        - make ${MAKEOPTS} -C ports/unix MICROPY_FORCE_32BIT=1 VARIANT=coverage submodules
+        - make ${MAKEOPTS} -C ports/unix MICROPY_FORCE_32BIT=1 VARIANT=coverage deplibs
+        - make ${MAKEOPTS} -C ports/unix MICROPY_FORCE_32BIT=1 VARIANT=coverage
+        # run the main test suite
+        - make -C ports/unix MICROPY_FORCE_32BIT=1 VARIANT=coverage test_full || travis_terminate 1
+        # test building native mpy modules
+        - make -C examples/natmod/features1 ARCH=x86
+        - make -C examples/natmod/features2 ARCH=x86
+        - make -C examples/natmod/btree ARCH=x86
+        - make -C examples/natmod/framebuf ARCH=x86
+        - make -C examples/natmod/uheapq ARCH=x86
+        - make -C examples/natmod/urandom ARCH=x86
+        - make -C examples/natmod/ure ARCH=x86
+        - make -C examples/natmod/uzlib ARCH=x86
+        # test importing .mpy generated by mpy_ld.py
+        - MICROPYPATH=examples/natmod/features2 ./ports/unix/micropython-coverage -m features2
+        - (cd tests && ./run-natmodtests.py --arch x86 extmod/{btree*,framebuf*,uheapq*,ure*,uzlib*}.py)
+      after_failure:
+        - tests/run-tests --print-failures
 
     # standard unix port
     - stage: test
-      env: NAME="unix port build and tests"
+      name: "unix port build and tests"
       script:
         - make ${MAKEOPTS} -C mpy-cross
+        - make ${MAKEOPTS} -C ports/unix submodules
         - make ${MAKEOPTS} -C ports/unix deplibs
         - make ${MAKEOPTS} -C ports/unix
         - make ${MAKEOPTS} -C ports/unix test
+        - (cd tests && MICROPY_CPYTHON3=python3 MICROPY_MICROPYTHON=../ports/unix/micropython ./run-perfbench.py 1000 1000)
+      after_failure:
+        - tests/run-tests --print-failures
 
-    # unix nanbox
+    # unix nanbox/float (and using Python 2 to check it can run the build scripts)
     - stage: test
-      env: NAME="unix nanbox port build and tests"
+      name: "unix nanbox/float port build and tests"
       install:
         - sudo apt-get install gcc-multilib libffi-dev:i386
       script:
-        - make ${MAKEOPTS} -C mpy-cross
-        - make ${MAKEOPTS} -C ports/unix deplibs
-        - make ${MAKEOPTS} -C ports/unix nanbox
-        - (cd tests && MICROPY_CPYTHON3=python3 MICROPY_MICROPYTHON=../ports/unix/micropython_nanbox ./run-tests)
+        - make ${MAKEOPTS} -C mpy-cross PYTHON=python2
+        - make ${MAKEOPTS} -C ports/unix VARIANT=nanbox submodules
+        - make ${MAKEOPTS} -C ports/unix PYTHON=python2 VARIANT=nanbox deplibs
+        - make ${MAKEOPTS} -C ports/unix PYTHON=python2 VARIANT=nanbox
+        - make ${MAKEOPTS} -C ports/unix PYTHON=python2 VARIANT=nanbox test_full || travis_terminate 1
+        - make ${MAKEOPTS} -C ports/unix clean
+        - make ${MAKEOPTS} -C ports/unix CFLAGS_EXTRA="-DMICROPY_FLOAT_IMPL=MICROPY_FLOAT_IMPL_FLOAT"
+        - make ${MAKEOPTS} -C ports/unix test
+      after_failure:
+        - tests/run-tests --print-failures
 
-    # unix stackless
+    # unix stackless/float with clang
     - stage: test
-      env: NAME="unix stackless port build and tests"
+      name: "unix stackless/float port build and tests with clang"
+      install:
+        - sudo apt-get install clang
+      script:
+        - make ${MAKEOPTS} -C mpy-cross CC=clang
+        - make ${MAKEOPTS} -C ports/unix submodules
+        - make ${MAKEOPTS} -C ports/unix CC=clang CFLAGS_EXTRA="-DMICROPY_STACKLESS=1 -DMICROPY_STACKLESS_STRICT=1"
+        - make ${MAKEOPTS} -C ports/unix CC=clang test || travis_terminate 1
+        - make ${MAKEOPTS} -C ports/unix clean
+        - make ${MAKEOPTS} -C ports/unix CC=clang CFLAGS_EXTRA="-DMICROPY_FLOAT_IMPL=MICROPY_FLOAT_IMPL_FLOAT"
+        - make ${MAKEOPTS} -C ports/unix CC=clang test
+      after_failure:
+        - tests/run-tests --print-failures
+
+    # unix with sys.settrace
+    - stage: test
+      name: "unix port with sys.settrace build and tests"
       script:
         - make ${MAKEOPTS} -C mpy-cross
-        - make ${MAKEOPTS} -C ports/unix deplibs
-        - make ${MAKEOPTS} -C ports/unix CFLAGS_EXTRA="-DMICROPY_STACKLESS=1 -DMICROPY_STACKLESS_STRICT=1"
-        - make ${MAKEOPTS} -C ports/unix test
+        - make ${MAKEOPTS} -C ports/unix MICROPY_PY_BTREE=0 MICROPY_PY_FFI=0 MICROPY_PY_USSL=0 CFLAGS_EXTRA="-DMICROPY_PY_SYS_SETTRACE=1" test || travis_terminate 1
+        - make ${MAKEOPTS} -C ports/unix clean
+        - make ${MAKEOPTS} -C ports/unix MICROPY_PY_BTREE=0 MICROPY_PY_FFI=0 MICROPY_PY_USSL=0 CFLAGS_EXTRA="-DMICROPY_STACKLESS=1 -DMICROPY_STACKLESS_STRICT=1 -DMICROPY_PY_SYS_SETTRACE=1" test
+      after_failure:
+        - tests/run-tests --print-failures
+
+    # minimal unix port with tests
+    - stage: test
+      name: "minimal unix port build and tests"
+      script:
+        - make ${MAKEOPTS} -C ports/unix VARIANT=minimal
+        - (cd tests && MICROPY_CPYTHON3=python3 MICROPY_MICROPYTHON=../ports/unix/micropython-minimal ./run-tests -e exception_chain -e self_type_check -e subclass_native_init -d basics)
+      after_failure:
+        - tests/run-tests --print-failures
 
     # windows port via mingw
     - stage: test
-      env: NAME="windows port build via mingw"
+      name: "windows port build via mingw"
       install:
         - sudo apt-get install gcc-mingw-w64
       script:
         - make ${MAKEOPTS} -C mpy-cross
         - make ${MAKEOPTS} -C ports/windows CROSS_COMPILE=i686-w64-mingw32-
 
+    # esp32 w/ESP-IDFv3 port
+    - stage: test
+      name: "esp32 ESP-IDFv3 port build"
+      install:
+        - sudo apt-get install python3-pip
+        - sudo pip3 install 'pyparsing<2.4'
+        - curl -L https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz | tar zxf -
+        - export PATH=$(pwd)/xtensa-esp32-elf/bin:$PATH
+        - git clone https://github.com/espressif/esp-idf.git
+        - export IDF_PATH=$(pwd)/esp-idf
+      script:
+        - make ${MAKEOPTS} -C mpy-cross
+        - git -C esp-idf checkout $(grep "ESPIDF_SUPHASH_V3 :=" ports/esp32/Makefile | cut -d " " -f 3)
+        - git -C esp-idf submodule update --init components/json/cJSON components/esp32/lib components/esptool_py/esptool components/expat/expat components/lwip/lwip components/mbedtls/mbedtls components/micro-ecc/micro-ecc components/nghttp/nghttp2 components/nimble components/bt
+        - make ${MAKEOPTS} -C ports/esp32 submodules
+        - make ${MAKEOPTS} -C ports/esp32
+
+    # esp32 w/ESP-IDFv4 port
+    - stage: test
+      name: "esp32 ESP-IDFv4 port build"
+      install:
+        - sudo apt-get install python3-pip
+        - sudo pip3 install 'pyparsing<2.4'
+        - curl -L https://dl.espressif.com/dl/xtensa-esp32-elf-gcc8_2_0-esp-2019r2-linux-amd64.tar.gz | tar zxf -
+        - export PATH=$(pwd)/xtensa-esp32-elf/bin:$PATH
+        - git clone https://github.com/espressif/esp-idf.git
+        - export IDF_PATH=$(pwd)/esp-idf
+      script:
+        - make ${MAKEOPTS} -C mpy-cross
+        - git -C esp-idf checkout $(grep "ESPIDF_SUPHASH_V4 :=" ports/esp32/Makefile | cut -d " " -f 3)
+        - git -C esp-idf submodule update --init components/bt/controller/lib components/bt/host/nimble/nimble components/esp_wifi/lib_esp32 components/esptool_py/esptool components/lwip/lwip components/mbedtls/mbedtls
+        - make ${MAKEOPTS} -C ports/esp32 submodules
+        - make ${MAKEOPTS} -C ports/esp32
+
+    # esp8266 port
+    - stage: test
+      name: "esp8266 port build"
+      install:
+        - wget https://github.com/jepler/esp-open-sdk/releases/download/2018-06-10/xtensa-lx106-elf-standalone.tar.gz
+        - zcat xtensa-lx106-elf-standalone.tar.gz | tar x
+        - export PATH=$(pwd)/xtensa-lx106-elf/bin:$PATH
+      script:
+        - make ${MAKEOPTS} -C mpy-cross
+        - make ${MAKEOPTS} -C ports/esp8266 submodules
+        - make ${MAKEOPTS} -C ports/esp8266
+        - make ${MAKEOPTS} -C ports/esp8266 BOARD=GENERIC_512K
+        - make ${MAKEOPTS} -C ports/esp8266 BOARD=GENERIC_1M
+
     # nrf port
     - stage: test
-      env: NAME="nrf port build"
+      name: "nrf port build"
       install:
         - sudo apt-get install gcc-arm-none-eabi
         - sudo apt-get install libnewlib-arm-none-eabi
         - arm-none-eabi-gcc --version
       script:
-        - make ${MAKEOPTS} -C ports/nrf
+        - make ${MAKEOPTS} -C ports/nrf submodules
+        - make ${MAKEOPTS} -C ports/nrf BOARD=pca10040
+        - make ${MAKEOPTS} -C ports/nrf BOARD=microbit
+        - make ${MAKEOPTS} -C ports/nrf BOARD=pca10056
 
-    # bare-arm and minimal ports
+    # bare-arm and minimal ports, with size-diff check
     - stage: test
-      env: NAME="bare-arm and minimal ports build"
+      name: "bare-arm and minimal ports build and size-diff check"
       install:
-        - sudo apt-get install gcc-arm-none-eabi
-        - sudo apt-get install libnewlib-arm-none-eabi
+        - sudo apt-get install gcc-multilib libffi-dev:i386 gcc-arm-none-eabi libnewlib-arm-none-eabi
+        - gcc --version
         - arm-none-eabi-gcc --version
       script:
-        - make ${MAKEOPTS} -C ports/bare-arm
-        - make ${MAKEOPTS} -C ports/minimal CROSS=1 build/firmware.bin
-        - ls -l ports/minimal/build/firmware.bin
-        - tools/check_code_size.sh
-        - mkdir -p ${HOME}/persist
-        # Save new firmware for reference, but only if building a main branch, not a pull request
-        - 'if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then cp ports/minimal/build/firmware.bin ${HOME}/persist/; fi'
+        # starts off at either the ref/pull/N/merge FETCH_HEAD, or the current branch HEAD
+        - git checkout -b pull_request # save the current location
+        - git remote add upstream https://github.com/micropython/micropython.git
+        - git fetch --depth=100 upstream
+        # build reference, save to size0
+        # ignore any errors with this build, in case master is failing
+        - git checkout `git merge-base --fork-point upstream/master pull_request`
+        - git show -s
+        - tools/metrics.py clean bm
+        - tools/metrics.py build bm | tee ~/size0 || true
+        # build PR/branch, save to size1
+        - git checkout pull_request
+        - git log upstream/master..HEAD
+        - tools/metrics.py clean bm
+        - tools/metrics.py build bm | tee ~/size1 || travis_terminate 1
+        # compute diff of the code sizes
+        - tools/metrics.py diff --error-threshold 0 ~/size0 ~/size1
 
     # cc3200 port
     - stage: test
-      env: NAME="cc3200 port build"
+      name: "cc3200 port build"
       install:
-        - sudo apt-get install gcc-arm-none-eabi
-        - sudo apt-get install libnewlib-arm-none-eabi
+        - sudo apt-get install gcc-arm-none-eabi libnewlib-arm-none-eabi
       script:
         - make ${MAKEOPTS} -C ports/cc3200 BTARGET=application BTYPE=release
         - make ${MAKEOPTS} -C ports/cc3200 BTARGET=bootloader  BTYPE=release
 
+    # samd port
+    - stage: test
+      name: "samd port build"
+      install:
+        - sudo apt-get install gcc-arm-none-eabi libnewlib-arm-none-eabi
+      script:
+        - make ${MAKEOPTS} -C ports/samd submodules
+        - make ${MAKEOPTS} -C ports/samd
+
     # teensy port
     - stage: test
-      env: NAME="teensy port build"
+      name: "teensy port build"
       install:
-        - sudo apt-get install gcc-arm-none-eabi
-        - sudo apt-get install libnewlib-arm-none-eabi
+        - sudo apt-get install gcc-arm-none-eabi libnewlib-arm-none-eabi
       script:
         - make ${MAKEOPTS} -C ports/teensy
+
+    # powerpc port
+    - stage: test
+      name: "powerpc port build"
+      install:
+        - sudo apt-get install gcc-powerpc64le-linux-gnu libc6-dev-ppc64el-cross
+      script:
+        - make ${MAKEOPTS} -C ports/powerpc UART=potato
+        - make ${MAKEOPTS} -C ports/powerpc UART=lpc_serial
diff --git a/ACKNOWLEDGEMENTS b/ACKNOWLEDGEMENTS
index 65f731b1fffed..41ed6bf24b5a0 100644
--- a/ACKNOWLEDGEMENTS
+++ b/ACKNOWLEDGEMENTS
@@ -762,7 +762,6 @@ today.  The names appear in order of pledging.
  1642 Udine
  1643 Simon Critchley
  1644 Sven Haiges, Germany
- 1645 Yi Qing Sim
  1646 "silicium" ("silicium_one", if "silicium" is busy)
  1648 Andy O'Malia, @andyomalia
  1650 RedCamelApps.com
diff --git a/CODECONVENTIONS.md b/CODECONVENTIONS.md
index 982b958313166..b18c9818ade25 100644
--- a/CODECONVENTIONS.md
+++ b/CODECONVENTIONS.md
@@ -11,7 +11,7 @@ It's also ok to drop file extensions.
 
 Besides prefix, first line of a commit message should describe a
 change clearly and to the point, and be a grammatical sentence with
-final full stop. First line should fit within 78 characters. Examples
+final full stop. First line should fit within 72 characters. Examples
 of good first line of commit messages:
 
     py/objstr: Add splitlines() method.
@@ -19,9 +19,10 @@ of good first line of commit messages:
     docs/machine: Fix typo in reset() description.
     ports: Switch to use lib/foo instead of duplicated code.
 
-After the first line, add an empty line and in following lines describe
-a change in a detail, if needed. Any change beyond 5 lines would likely
-require such detailed description.
+After the first line add an empty line and in the following lines describe
+the change in a detail, if needed, with lines fitting within 75 characters
+(with an exception for long items like URLs which cannot be broken). Any
+change beyond 5 lines would likely require such detailed description.
 
 To get good practical examples of good commits and their messages, browse
 the `git log` of the project.
@@ -47,14 +48,27 @@ address on it construes your sign-off of the following:
   a valid and active email address by which you can be contacted in the
   foreseeable future.
 
+Code auto-formatting
+====================
+
+Both C and Python code are auto-formatted using the `tools/codeformat.py`
+script.  This uses [uncrustify](https://github.com/uncrustify/uncrustify) to
+format C code and [black](https://github.com/psf/black) to format Python code.
+After making changes, and before committing, run this tool to reformat your
+changes to the correct style.  Without arguments this tool will reformat all
+source code (and may take some time to run).  Otherwise pass as arguments to
+the tool the files that changed and it will only reformat those.
+
 Python code conventions
 =======================
 
-Python code follows [PEP 8](http://legacy.python.org/dev/peps/pep-0008/).
+Python code follows [PEP 8](https://legacy.python.org/dev/peps/pep-0008/) and
+is auto-formatted using [black](https://github.com/psf/black) with a line-length
+of 99 characters.
 
 Naming conventions:
 - Module names are short and all lowercase; eg pyb, stm.
-- Class names are CamelCase, with abreviations all uppercase; eg I2C, not
+- Class names are CamelCase, with abbreviations all uppercase; eg I2C, not
   I2c.
 - Function and method names are all lowercase with words separated by
   a single underscore as necessary to improve readability; eg mem_read.
@@ -64,7 +78,12 @@ Naming conventions:
 C code conventions
 ==================
 
-When writing new C code, please adhere to the following conventions.
+C code is auto-formatted using [uncrustify](https://github.com/uncrustify/uncrustify)
+and the corresponding configuration file `tools/uncrustify.cfg`, with a few
+minor fix-ups applied by `tools/codeformat.py`.  When writing new C code please
+adhere to the existing style and use `tools/codeformat.py` to check any changes.
+The main conventions, and things not enforceable via the auto-formatter, are
+described below.
 
 White space:
 - Expand tabs to 4 spaces.
@@ -125,7 +144,7 @@ Braces, spaces, names and comments:
             foo(x + TO_ADD, some_value - 1);
         }
 
-        for (int my_counter = 0; my_counter < x; my_counter++) {
+        for (int my_counter = 0; my_counter < x; ++my_counter) {
         }
     }
 
diff --git a/CODEOFCONDUCT.md b/CODEOFCONDUCT.md
new file mode 100644
index 0000000000000..07cf87713bd86
--- /dev/null
+++ b/CODEOFCONDUCT.md
@@ -0,0 +1,53 @@
+MicroPython Code of Conduct
+===========================
+
+The MicroPython community is made up of members from around the globe with a
+diverse set of skills, personalities, and experiences.  It is through these
+differences that our community experiences great successes and continued growth.
+When you're working with members of the community, this Code of Conduct will
+help steer your interactions and keep MicroPython a positive, successful, and
+growing community.
+
+Members of the MicroPython community are open, considerate, and respectful.
+Behaviours that reinforce these values contribute to a positive environment, and
+include: acknowledging time and effort, being respectful of differing viewpoints
+and experiences, gracefully accepting constructive criticism, and using
+welcoming and inclusive language.
+
+Every member of our community has the right to have their identity respected.
+The MicroPython community is dedicated to providing a positive experience for
+everyone, regardless of age, gender identity and expression, sexual orientation,
+disability, physical appearance, body size, ethnicity, nationality, race, or
+religion (or lack thereof), education, or socio-economic status.
+
+Unacceptable behaviour includes: harassment, trolling, deliberate intimidation,
+violent threats or language directed against another person; insults, put downs,
+or jokes that are based upon stereotypes, that are exclusionary, or that hold
+others up for ridicule; unwelcome sexual attention or advances; sustained
+disruption of community discussions; publishing others' private information
+without explicit permission; and other conduct that is inappropriate for a
+professional audience including people of many different backgrounds.
+
+This code of conduct covers all online and offline presence related to the
+MicroPython project, including GitHub and the forum.  If a participant engages
+in behaviour that violates this code of conduct, the MicroPython team may take
+action as they deem appropriate, including warning the offender or expulsion
+from the community.  Community members asked to stop any inappropriate behaviour
+are expected to comply immediately.
+
+Thank you for helping make this a welcoming, friendly community for everyone.
+
+If you believe that someone is violating the code of conduct, or have any other
+concerns, please contact a member of the MicroPython team by emailing
+contact@micropython.org.
+
+License
+-------
+
+This Code of Conduct is licensed under the Creative Commons
+Attribution-ShareAlike 3.0 Unported License.
+
+Attributions
+------------
+
+Based on the Python code of conduct found at https://www.python.org/psf/conduct/
diff --git a/LICENSE b/LICENSE
index e3474e33dd81a..e6a54cf269947 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2013, 2014 Damien P. George
+Copyright (c) 2013-2019 Damien P. George
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/README.md b/README.md
index 843511a60b79e..57daebf87263b 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-[![Build Status](https://travis-ci.org/micropython/micropython.png?branch=master)](https://travis-ci.org/micropython/micropython) [![Coverage Status](https://coveralls.io/repos/micropython/micropython/badge.png?branch=master)](https://coveralls.io/r/micropython/micropython?branch=master)
+[![Build Status](https://travis-ci.com/micropython/micropython.png?branch=master)](https://travis-ci.com/micropython/micropython) [![Coverage Status](https://coveralls.io/repos/micropython/micropython/badge.png?branch=master)](https://coveralls.io/r/micropython/micropython?branch=master)
 
 The MicroPython project
 =======================
@@ -64,6 +64,17 @@ You will also need bash, gcc, and Python 3.3+ available as the command `python3`
 (if your system only has Python 2.7 then invoke make with the additional option
 `PYTHON=python2`).
 
+The MicroPython cross-compiler, mpy-cross
+-----------------------------------------
+
+Most ports require the MicroPython cross-compiler to be built first.  This
+program, called mpy-cross, is used to pre-compile Python scripts to .mpy
+files which can then be included (frozen) into the firmware/executable for
+a port.  To build mpy-cross use:
+
+    $ cd mpy-cross
+    $ make
+
 The Unix version
 ----------------
 
@@ -75,8 +86,8 @@ Alternatively, fallback implementation based on setjmp/longjmp can be used.
 
 To build (see section below for required dependencies):
 
-    $ git submodule update --init
     $ cd ports/unix
+    $ make submodules
     $ make
 
 Then to give it a try:
@@ -88,7 +99,7 @@ Use `CTRL-D` (i.e. EOF) to exit the shell.
 Learn about command-line options (in particular, how to increase heap size
 which may be needed for larger applications):
 
-    $ ./micropython --help
+    $ ./micropython -h
 
 Run complete testsuite:
 
@@ -116,13 +127,14 @@ Debian/Ubuntu/Mint derivative Linux distros, install `build-essential`
 Other dependencies can be built together with MicroPython. This may
 be required to enable extra features or capabilities, and in recent
 versions of MicroPython, these may be enabled by default. To build
-these additional dependencies, first fetch git submodules for them:
+these additional dependencies, in the port directory you're
+interested in (e.g. `ports/unix/`) first execute:
 
-    $ git submodule update --init
+    $ make submodules
 
-Use the same command to get the latest versions of dependencies, as
-they are updated from time to time. After that, in the port directory
-(e.g. `ports/unix/`), execute:
+This will fetch all the relevant git submodules (sub repositories) that
+the port needs.  Use the same command to get the latest versions of
+submodules as they are updated from time to time. After that execute:
 
     $ make deplibs
 
@@ -132,11 +144,11 @@ options (like cross-compiling), the same set of options should be passed
 to `make deplibs`. To actually enable/disable use of dependencies, edit
 `ports/unix/mpconfigport.mk` file, which has inline descriptions of the options.
 For example, to build SSL module (required for `upip` tool described above,
-and so enabled by dfeault), `MICROPY_PY_USSL` should be set to 1.
+and so enabled by default), `MICROPY_PY_USSL` should be set to 1.
 
 For some ports, building required dependences is transparent, and happens
-automatically. They still need to be fetched with the git submodule command
-above.
+automatically.  But they still need to be fetched with the `make submodules`
+command.
 
 The STM32 version
 -----------------
@@ -148,8 +160,8 @@ https://launchpad.net/gcc-arm-embedded
 
 To build:
 
-    $ git submodule update --init
     $ cd ports/stm32
+    $ make submodules
     $ make
 
 You then need to get your board into DFU mode.  On the pyboard, connect the
diff --git a/docs/README.md b/docs/README.md
index d524f4b67e4c8..1591911c34560 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -25,6 +25,21 @@ In `micropython/docs`, build the docs:
 
 You'll find the index page at `micropython/docs/build/html/index.html`.
 
+Having readthedocs.org build the documentation
+----------------------------------------------
+
+If you would like to have docs for forks/branches hosted on GitHub, GitLab or
+BitBucket an alternative to building the docs locally is to sign up for a free
+https://readthedocs.org account. The rough steps to follow are:
+1. sign-up for an account, unless you already have one
+2. in your account settings: add GitHub as a connected service (assuming
+you have forked this repo on github)
+3. in your account projects: import your forked/cloned micropython repository
+into readthedocs
+4. in the project's versions: add the branches you are developing on or
+for which you'd like readthedocs to auto-generate docs whenever you
+push a change
+
 PDF manual generation
 ---------------------
 
diff --git a/docs/conf.py b/docs/conf.py
index 61c660aa667ce..36f99cd2c441b 100755
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -74,7 +74,7 @@
 #
 # We don't follow "The short X.Y version" vs "The full version, including alpha/beta/rc tags"
 # breakdown, so use the same version identifier for both to avoid confusion.
-version = release = '1.10'
+version = release = '1.12'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -159,7 +159,7 @@
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
-html_favicon = 'favicon.ico'
+html_favicon = 'static/favicon.ico'
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
diff --git a/docs/develop/cmodules.rst b/docs/develop/cmodules.rst
index 919f518242bc9..e616adad03353 100644
--- a/docs/develop/cmodules.rst
+++ b/docs/develop/cmodules.rst
@@ -1,3 +1,5 @@
+.. _cmodules:
+
 MicroPython external C modules
 ==============================
 
@@ -17,6 +19,10 @@ more sense to keep this external to the main MicroPython repository.
 This chapter describes how to compile such external modules into the
 MicroPython executable or firmware image.
 
+An alternative approach is to use :ref:`natmod` which allows writing custom C
+code that is placed in a .mpy file, which can be imported dynamically in to
+a running MicroPython system without the need to recompile the main firmware.
+
 
 Structure of an external C module
 ---------------------------------
@@ -48,7 +54,7 @@ A MicroPython user C module is a directory with the following files:
   See below for full usage example.
 
 
-Basic Example
+Basic example
 -------------
 
 This simple module named ``example`` provides a single function
@@ -71,8 +77,6 @@ Directory::
     #include "py/runtime.h"
     #include "py/builtin.h"
 
-    #define MODULE_EXAMPLE_ENABLED (1)
-
     // This is the function which will be called from Python as example.add_ints(a, b).
     STATIC mp_obj_t example_add_ints(mp_obj_t a_obj, mp_obj_t b_obj) {
         // Extract the ints from the micropython input objects
@@ -119,6 +123,19 @@ Directory::
     # This is not actually needed in this example.
     CFLAGS_USERMOD += -I$(EXAMPLE_MOD_DIR)
 
+Finally you will need to define ``MODULE_EXAMPLE_ENABLED`` to 1. This
+can be done by adding ``CFLAGS_EXTRA=-DMODULE_EXAMPLE_ENABLED=1`` to
+the ``make`` command, or editing ``mpconfigport.h`` or
+``mpconfigboard.h`` to add
+
+.. code-block:: c
+
+    #define MODULE_EXAMPLE_ENABLED (1)
+
+Note that the exact method depends on the port as they have different
+structures. If not done correctly it will compile but importing will
+fail to find the module.
+
 
 Compiling the cmodule into MicroPython
 --------------------------------------
@@ -146,7 +163,7 @@ Building for stm32 port:
 .. code-block:: bash
 
     cd my_project/micropython/ports/stm32
-    make USER_C_MODULES=../../../modules all
+    make USER_C_MODULES=../../../modules CFLAGS_EXTRA=-DMODULE_EXAMPLE_ENABLED=1 all
 
 
 Module usage in MicroPython
diff --git a/docs/develop/index.rst b/docs/develop/index.rst
index 64dbc4661382e..f1fd0692ec9e1 100644
--- a/docs/develop/index.rst
+++ b/docs/develop/index.rst
@@ -10,3 +10,5 @@ See the `getting started guide
    :maxdepth: 1
 
    cmodules.rst
+   qstr.rst
+   natmod.rst
diff --git a/docs/develop/natmod.rst b/docs/develop/natmod.rst
new file mode 100644
index 0000000000000..dc9f82e773874
--- /dev/null
+++ b/docs/develop/natmod.rst
@@ -0,0 +1,215 @@
+.. _natmod:
+
+Native machine code in .mpy files
+=================================
+
+This section describes how to build and work with .mpy files that contain native
+machine code from a language other than Python.  This allows you to
+write code in a language like C, compile and link it into a .mpy file, and then
+import this file like a normal Python module.  This can be used for implementing
+functionality which is performance critical, or for including an existing
+library written in another language.
+
+One of the main advantages of using native .mpy files is that native machine code
+can be imported by a script dynamically, without the need to rebuild the main
+MicroPython firmware.  This is in contrast to :ref:`cmodules` which also allows
+defining custom modules in C but they must be compiled into the main firmware image.
+
+The focus here is on using C to build native modules, but in principle any
+language which can be compiled to stand-alone machine code can be put into a
+.mpy file.
+
+A native .mpy module is built using the ``mpy_ld.py`` tool, which is found in the
+``tools/`` directory of the project.  This tool takes a set of object files
+(.o files) and links them together to create a native .mpy files.
+
+Supported features and limitations
+----------------------------------
+
+A .mpy file can contain MicroPython bytecode and/or native machine code.  If it
+contains native machine code then the .mpy file has a specific architecture
+associated with it.  Current supported architectures are (these are the valid
+options for the ``ARCH`` variable, see below):
+
+* ``x86`` (32 bit)
+* ``x64`` (64 bit x86)
+* ``armv7m`` (ARM Thumb 2, eg Cortex-M3)
+* ``armv7emsp`` (ARM Thumb 2, single precision float, eg Cortex-M4F, Cortex-M7)
+* ``armv7emdp`` (ARM Thumb 2, double precision float, eg Cortex-M7)
+* ``xtensa`` (non-windowed, eg ESP8266)
+* ``xtensawin`` (windowed with window size 8, eg ESP32)
+
+When compiling and linking the native .mpy file the architecture must be chosen
+and the corresponding file can only be imported on that architecture.  For more
+details about .mpy files see :ref:`mpy_files`.
+
+Native code must be compiled as position independent code (PIC) and use a global
+offset table (GOT), although the details of this varies from architecture to
+architecture.  When importing .mpy files with native code the import machinery
+is able to do some basic relocation of the native code.  This includes
+relocating text, rodata and BSS sections.
+
+Supported features of the linker and dynamic loader are:
+
+* executable code (text)
+* read-only data (rodata), including strings and constant data (arrays, structs, etc)
+* zeroed data (BSS)
+* pointers in text to text, rodata and BSS
+* pointers in rodata to text, rodata and BSS
+
+The known limitations are:
+
+* data sections are not supported; workaround: use BSS data and initialise the
+  data values explicitly
+
+* static BSS variables are not supported; workaround: use global BSS variables
+
+So, if your C code has writable data, make sure the data is defined globally,
+without an initialiser, and only written to within functions.
+
+Linker limitation: the native module is not linked against the symbol table of the
+full MicroPython firmware.  Rather, it is linked against an explicit table of exported
+symbols found in ``mp_fun_table`` (in ``py/nativeglue.h``), that is fixed at firmware
+build time.  It is thus not possible to simply call some arbitrary HAL/OS/RTOS/system
+function, for example.
+
+New symbols can be added to the end of the table and the firmware rebuilt.
+The symbols also need to be added to ``tools/mpy_ld.py``'s ``fun_table`` dict in the
+same location.  This allows ``mpy_ld.py`` to be able to pick the new symbols up and
+provide relocations for them when the mpy is imported.  Finally, if the symbol is a
+function, a macro or stub should be added to ``py/dynruntime.h`` to make it easy to
+call the function.
+
+Defining a native module
+------------------------
+
+A native .mpy module is defined by a set of files that are used to build the .mpy.
+The filesystem layout consists of two main parts, the source files and the Makefile:
+
+* In the simplest case only a single C source file is required, which contains all
+  the code that will be compiled into the .mpy module.  This C source code must
+  include the ``py/dynruntime.h`` file to access the MicroPython dynamic API, and
+  must at least define a function called ``mpy_init``.  This function will be the
+  entry point of the module, called when the module is imported.
+
+  The module can be split into multiple C source files if desired.  Parts of the
+  module can also be implemented in Python.  All source files should be listed in
+  the Makefile, by adding them to the ``SRC`` variable (see below).  This includes
+  both C source files as well as any Python files which will be included in the
+  resulting .mpy file.
+
+* The ``Makefile`` contains the build configuration for the module and list the
+  source files used to build the .mpy module.  It should define ``MPY_DIR`` as the
+  location of the MicroPython repository (to find header files, the relevant Makefile
+  fragment, and the ``mpy_ld.py`` tool), ``MOD`` as the name of the module, ``SRC``
+  as the list of source files, optionally specify the machine architecture via ``ARCH``,
+  and then include ``py/dynruntime.mk``.
+
+Minimal example
+---------------
+
+This section provides a fully working example of a simple module named ``factorial``.
+This module provides a single function ``factorial.factorial(x)`` which computes the
+factorial of the input and returns the result.
+
+Directory layout::
+
+    factorial/
+    ├── factorial.c
+    └── Makefile
+
+The file ``factorial.c`` contains:
+
+.. code-block:: c
+
+    // Include the header file to get access to the MicroPython API
+    #include "py/dynruntime.h"
+
+    // Helper function to compute factorial
+    STATIC mp_int_t factorial_helper(mp_int_t x) {
+        if (x == 0) {
+            return 1;
+        }
+        return x * factorial_helper(x - 1);
+    }
+
+    // This is the function which will be called from Python, as factorial(x)
+    STATIC mp_obj_t factorial(mp_obj_t x_obj) {
+        // Extract the integer from the MicroPython input object
+        mp_int_t x = mp_obj_get_int(x_obj);
+        // Calculate the factorial
+        mp_int_t result = factorial_helper(x);
+        // Convert the result to a MicroPython integer object and return it
+        return mp_obj_new_int(result);
+    }
+    // Define a Python reference to the function above
+    STATIC MP_DEFINE_CONST_FUN_OBJ_1(factorial_obj, factorial);
+
+    // This is the entry point and is called when the module is imported
+    mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+        // This must be first, it sets up the globals dict and other things
+        MP_DYNRUNTIME_INIT_ENTRY
+
+        // Make the function available in the module's namespace
+        mp_store_global(MP_QSTR_factorial, MP_OBJ_FROM_PTR(&factorial_obj));
+
+        // This must be last, it restores the globals dict
+        MP_DYNRUNTIME_INIT_EXIT
+    }
+
+The file ``Makefile`` contains:
+
+.. code-block:: make
+
+    # Location of top-level MicroPython directory
+    MPY_DIR = ../../..
+
+    # Name of module
+    MOD = factorial
+
+    # Source files (.c or .py)
+    SRC = factorial.c
+
+    # Architecture to build for (x86, x64, armv7m, xtensa, xtensawin)
+    ARCH = x64
+
+    # Include to get the rules for compiling and linking the module
+    include $(MPY_DIR)/py/dynruntime.mk
+
+Compiling the module
+--------------------
+
+Be sure to select the correct ``ARCH`` for the target you are going to run on.
+Then build with::
+
+    $ make
+
+Without modifying the Makefile you can specify the target architecture via::
+
+    $ make ARCH=armv7m
+
+Module usage in MicroPython
+---------------------------
+
+Once the module is built there should be a file called ``factorial.mpy``.  Copy
+this so it is accessible on the filesystem of your MicroPython system and can be
+found in the import path.  The module con now be accessed in Python just like any
+other module, for example::
+
+    import factorial
+    print(factorial.factorial(10))
+    # should display 3628800
+
+Further examples
+----------------
+
+See ``examples/natmod/`` for further examples which show many of the available
+features of native .mpy modules.  Such features include:
+
+* using multiple C source files
+* including Python code alongside C code
+* rodata and BSS data
+* memory allocation
+* use of floating point
+* exception handling
+* including external C libraries
diff --git a/docs/develop/qstr.rst b/docs/develop/qstr.rst
new file mode 100644
index 0000000000000..1b3b9f903bc91
--- /dev/null
+++ b/docs/develop/qstr.rst
@@ -0,0 +1,112 @@
+MicroPython string interning
+============================
+
+MicroPython uses `string interning`_ to save both RAM and ROM.  This avoids
+having to store duplicate copies of the same string.  Primarily, this applies to
+identifiers in your code, as something like a function or variable name is very
+likely to appear in multiple places in the code.  In MicroPython an interned
+string is called a QSTR (uniQue STRing).
+
+A QSTR value (with type ``qstr``) is a index into a linked list of QSTR pools.
+QSTRs store their length and a hash of their contents for fast comparison during
+the de-duplication process.  All bytecode operations that work with strings use
+a QSTR argument.
+
+Compile-time QSTR generation
+----------------------------
+
+In the MicroPython C code, any strings that should be interned in the final
+firmware are written as ``MP_QSTR_Foo``.  At compile time this will evaluate to
+a ``qstr`` value that points to the index of ``"Foo"`` in the QSTR pool.
+
+A multi-step process in the ``Makefile`` makes this work.  In summary this
+process has three parts:
+
+1. Find all ``MP_QSTR_Foo`` tokens in the code.
+
+2. Generate a static QSTR pool containing all the string data (including lengths
+   and hashes).
+
+3. Replace all ``MP_QSTR_Foo`` (via the preprocessor) with their corresponding
+   index.
+
+``MP_QSTR_Foo`` tokens are searched for in two sources:
+
+1. All files referenced in ``$(SRC_QSTR)``.  This is all C code (i.e. ``py``,
+   ``extmod``, ``ports/stm32``) but not including third-party code such as
+   ``lib``.
+
+2. Additional ``$(QSTR_GLOBAL_DEPENDENCIES)`` (which includes ``mpconfig*.h``).
+
+*Note:* ``frozen_mpy.c`` (generated by mpy-tool.py) has its own QSTR generation
+and pool.
+
+Some additional strings that can't be expressed using the ``MP_QSTR_Foo`` syntax
+(e.g. they contain non-alphanumeric characters) are explicitly provided in
+``qstrdefs.h`` and ``qstrdefsport.h`` via the ``$(QSTR_DEFS)`` variable.
+
+Processing happens in the following stages:
+
+1. ``qstr.i.last`` is the concatenation of putting every single input file
+   through the C pre-processor.  This means that any conditionally disabled code
+   will be removed, and macros expanded.  This means we don't add strings to the
+   pool that won't be used in the final firmware.  Because at this stage (thanks
+   to the ``NO_QSTR`` macro added by ``QSTR_GEN_EXTRA_CFLAGS``) there is no
+   definition for ``MP_QSTR_Foo`` it passes through this stage unaffected.  This
+   file also includes comments from the preprocessor that include line number
+   information.  Note that this step only uses files that have changed, which
+   means that ``qstr.i.last`` will only contain data from files that have
+   changed since the last compile.
+2. ``qstr.split`` is an empty file created after running ``makeqstrdefs.py split``
+   on qstr.i.last. It's just used as a dependency to indicate that the step ran.
+   This script outputs one file per input C file,  ``genhdr/qstr/...file.c.qstr``,
+   which contains only the matched QSTRs. Each QSTR is printed as ``Q(Foo)``.
+   This step is necessary to combine the existing files with the new data
+   generated from the incremental update in ``qstr.i.last``.
+
+3. ``qstrdefs.collected.h`` is the output of concatenating ``genhdr/qstr/*``
+   using ``makeqstrdefs.py cat``.  This is now the full set of ``MP_QSTR_Foo``'s
+   found in the code, now formatted as ``Q(Foo)``, one-per-line, with duplicates.
+   This file is only updated if the set of qstrs has changed.  A hash of the QSTR
+   data is written to another file (``qstrdefs.collected.h.hash``) which allows
+   it to track changes across builds.
+
+4. ``qstrdefs.preprocessed.h`` adds in the QSTRs from qstrdefs*.  It
+   concatenates ``qstrdefs.collected.h`` with ``qstrdefs*.h``, then it transforms
+   each line from ``Q(Foo)`` to ``"Q(Foo)"`` so they pass through the preprocessor
+   unchanged.  Then the preprocessor is used to deal with any conditional
+   compilation in ``qstrdefs*.h``.  Then the transformation is undone back to
+   ``Q(Foo)``, and saved as ``qstrdefs.preprocessed.h``.
+
+5. ``qstrdefs.generated.h`` is the output of ``makeqstrdata.py``.  For each
+   ``Q(Foo)`` in qstrdefs.preprocessed.h (plus some extra hard-coded ones), it outputs
+   ``QDEF(MP_QSTR_Foo, (const byte*)"hash" "Foo")``.
+
+Then in the main compile, two things happen with ``qstrdefs.generated.h``:
+
+1. In qstr.h, each QDEF becomes an entry in an enum, which makes ``MP_QSTR_Foo``
+   available to code and equal to the index of that string in the QSTR table.
+
+2. In qstr.c, the actual QSTR data table is generated as elements of the
+   ``mp_qstr_const_pool->qstrs``.
+
+.. _`string interning`: https://en.wikipedia.org/wiki/String_interning
+
+Run-time QSTR generation
+------------------------
+
+Additional QSTR pools can be created at runtime so that strings can be added to
+them. For example, the code::
+
+  foo[x] = 3
+
+Will need to create a QSTR for the value of ``x`` so it can be used by the
+"load attr" bytecode.
+
+Also, when compiling Python code, identifiers and literals need to have QSTRs
+created.  Note: only literals shorter than 10 characters become QSTRs.  This is
+because a regular string on the heap always takes up a minimum of 16 bytes (one
+GC block), whereas QSTRs allow them to be packed more efficiently into the pool.
+
+QSTR pools (and the underlying "chunks" that store the string data) are allocated
+on-demand on the heap with a minimum size.
diff --git a/docs/esp32/general.rst b/docs/esp32/general.rst
index 51918d4e183ea..8137c042d9214 100644
--- a/docs/esp32/general.rst
+++ b/docs/esp32/general.rst
@@ -52,6 +52,7 @@ For your convenience, some of technical specifications are provided below:
 * I2S: 2
 * ADC: 12-bit SAR ADC up to 18 channels
 * DAC: 2 8-bit DACs
+* RMT: 8 channels allowing accurate pulse transmit/receive
 * Programming: using BootROM bootloader from UART - due to external FlashROM
   and always-available BootROM bootloader, the ESP32 is not brickable
 
diff --git a/docs/esp32/quickref.rst b/docs/esp32/quickref.rst
index 5ac8aa3b2ff92..8861ca4ac87ed 100644
--- a/docs/esp32/quickref.rst
+++ b/docs/esp32/quickref.rst
@@ -77,11 +77,12 @@ The :mod:`network` module::
     wlan.scan()             # scan for access points
     wlan.isconnected()      # check if the station is connected to an AP
     wlan.connect('essid', 'password') # connect to an AP
-    wlan.config('mac')      # get the interface's MAC adddress
+    wlan.config('mac')      # get the interface's MAC address
     wlan.ifconfig()         # get the interface's IP/netmask/gw/DNS addresses
 
     ap = network.WLAN(network.AP_IF) # create access-point interface
     ap.config(essid='ESP-AP') # set the ESSID of the access point
+    ap.config(max_clients=10) # set how many clients can connect to the network
     ap.active(True)         # activate the interface
 
 A useful function for connecting to your local WiFi network is::
@@ -128,6 +129,8 @@ with timer ID of -1::
 
 The period is in milliseconds.
 
+.. _Pins_and_GPIO:
+
 Pins and GPIO
 -------------
 
@@ -201,7 +204,7 @@ Use the :ref:`machine.ADC <machine.ADC>` class::
     adc = ADC(Pin(32))          # create ADC object on ADC pin
     adc.read()                  # read value, 0-4095 across voltage range 0.0v - 1.0v
 
-    adc.atten(ADC.ATTN_11DB)    # set 11dB input attentuation (voltage range roughly 0.0v - 3.6v)
+    adc.atten(ADC.ATTN_11DB)    # set 11dB input attenuation (voltage range roughly 0.0v - 3.6v)
     adc.width(ADC.WIDTH_9BIT)   # set 9 bit return values (returned range 0-511)
     adc.read()                  # read value using the newly configured attenuation and width
 
@@ -255,7 +258,7 @@ class::
     spi.init(baudrate=200000) # set the baudrate
 
     spi.read(10)            # read 10 bytes on MISO
-    spi.read(10, 0xff)      # read 10 bytes while outputing 0xff on MOSI
+    spi.read(10, 0xff)      # read 10 bytes while outputting 0xff on MOSI
 
     buf = bytearray(50)     # create a buffer
     spi.readinto(buf)       # read into the given buffer (reads 50 bytes in this case)
@@ -274,8 +277,13 @@ class::
 Hardware SPI bus
 ----------------
 
-There are two hardware SPI channels that allow faster (up to 80Mhz)
-transmission rates, but are only supported on a subset of pins.
+There are two hardware SPI channels that allow faster transmission
+rates (up to 80Mhz). These may be used on any IO pins that support the
+required direction and are otherwise unused (see :ref:`Pins_and_GPIO`)
+but if they are not configured to their default pins then they need to
+pass through an extra layer of GPIO multiplexing, which can impact
+their reliability at high speeds. Hardware SPI channels are limited
+to 40MHz when used on pins other than the default ones listed below.
 
 =====  ===========  ============
 \      HSPI (id=1)   VSPI (id=2)
@@ -296,14 +304,22 @@ Hardware SPI has the same methods as Software SPI above::
 I2C bus
 -------
 
-The I2C driver is implemented in software and works on all pins,
-and is accessed via the :ref:`machine.I2C <machine.I2C>` class::
+The I2C driver has both software and hardware implementations, and the two
+hardware peripherals have identifiers 0 and 1.  Any available output-capable
+pins can be used for SCL and SDA.  The driver is accessed via the
+:ref:`machine.I2C <machine.I2C>` class::
 
     from machine import Pin, I2C
 
-    # construct an I2C bus
+    # construct a software I2C bus
     i2c = I2C(scl=Pin(5), sda=Pin(4), freq=100000)
 
+    # construct a hardware I2C bus
+    i2c = I2C(0)
+    i2c = I2C(1, scl=Pin(5), sda=Pin(4), freq=400000)
+
+    i2c.scan()              # scan for slave devices
+
     i2c.readfrom(0x3a, 4)   # read 4 bytes from slave device with address 0x3a
     i2c.writeto(0x3a, '12') # write '12' to slave device with address 0x3a
 
@@ -344,12 +360,26 @@ Notes:
   To further reduce power consumption it is possible to disable the internal pullups::
 
     p1 = Pin(4, Pin.IN, Pin.PULL_HOLD)
-    
+
   After leaving deepsleep it may be necessary to un-hold the pin explicitly (e.g. if
   it is an output pin) via::
-    
+
     p1 = Pin(4, Pin.OUT, None)
 
+RMT
+---
+
+The RMT is ESP32-specific and allows generation of accurate digital pulses with
+12.5ns resolution.  See :ref:`esp32.RMT <esp32.RMT>` for details.  Usage is::
+
+    import esp32
+    from machine import Pin
+
+    r = esp32.RMT(0, pin=Pin(18), clock_div=8)
+    r   # RMT(channel=0, pin=18, source_freq=80000000, clock_div=8)
+    # The channel resolution is 100ns (1/(source_freq/clock_div)).
+    r.write_pulses((1, 20, 2, 40), start=0) # Send 0 for 100ns, 1 for 2000ns, 0 for 200ns, 1 for 4000ns
+
 OneWire driver
 --------------
 
@@ -406,7 +436,7 @@ For low-level driving of a NeoPixel::
    ``NeoPixel`` object.
 
 
-Capacitive Touch
+Capacitive touch
 ----------------
 
 Use the ``TouchPad`` class in the ``machine`` module::
diff --git a/docs/esp8266/general.rst b/docs/esp8266/general.rst
index 020e21df62d09..fbe8fe1c3cabd 100644
--- a/docs/esp8266/general.rst
+++ b/docs/esp8266/general.rst
@@ -140,7 +140,7 @@ The above may also happen after an application terminates and quits to the REPL
 for any reason including an exception. Subsequent arrival of data provokes the
 failure with the above error message repeatedly issued. So, sockets should be
 closed in any case, regardless whether an application terminates successfully
-or by an exeption, for example using try/finally::
+or by an exception, for example using try/finally::
 
     sock = socket(...)
     try:
diff --git a/docs/esp8266/quickref.rst b/docs/esp8266/quickref.rst
index 95ae55b570682..9c7db3205a7e6 100644
--- a/docs/esp8266/quickref.rst
+++ b/docs/esp8266/quickref.rst
@@ -188,7 +188,7 @@ class::
     spi.init(baudrate=200000) # set the baudrate
 
     spi.read(10)            # read 10 bytes on MISO
-    spi.read(10, 0xff)      # read 10 bytes while outputing 0xff on MOSI
+    spi.read(10, 0xff)      # read 10 bytes while outputting 0xff on MOSI
 
     buf = bytearray(50)     # create a buffer
     spi.readinto(buf)       # read into the given buffer (reads 50 bytes in this case)
@@ -243,6 +243,16 @@ See :ref:`machine.RTC <machine.RTC>` ::
     rtc.datetime((2017, 8, 23, 1, 12, 48, 0, 0)) # set a specific date and time
     rtc.datetime() # get date and time
 
+    # synchronize with ntp
+    # need to be connected to wifi
+    import ntptime
+    ntptime.settime() # set the rtc datetime from the remote server
+    rtc.datetime()    # get the date and time in UTC
+
+.. note:: Not all methods are implemented: `RTC.now()`, `RTC.irq(handler=*) <RTC.irq>`
+          (using a custom handler), `RTC.init()` and `RTC.deinit()` are
+          currently not supported.
+
 Deep-sleep mode
 ---------------
 
diff --git a/docs/esp8266/tutorial/apa102.rst b/docs/esp8266/tutorial/apa102.rst
new file mode 100644
index 0000000000000..1c775daae30ce
--- /dev/null
+++ b/docs/esp8266/tutorial/apa102.rst
@@ -0,0 +1,91 @@
+Controlling APA102 LEDs
+=======================
+
+APA102 LEDs, also known as DotStar LEDs, are individually addressable
+full-colour RGB LEDs, generally in a string formation. They differ from
+NeoPixels in that they require two pins to control - both a Clock and Data pin.
+They can operate at a much higher data and PWM frequencies than NeoPixels and
+are more suitable for persistence-of-vision effects.
+
+To create an APA102 object do the following::
+
+    >>> import machine, apa102
+    >>> strip = apa102.APA102(machine.Pin(5), machine.Pin(4), 60)
+
+This configures an 60 pixel APA102 strip with clock on GPIO5 and data on GPIO4.
+You can adjust the pin numbers and the number of pixels to suit your needs.
+
+The RGB colour data, as well as a brightness level, is sent to the APA102 in a
+certain order.  Usually this is ``(Red, Green, Blue, Brightness)``.
+If you are using one of the newer APA102C LEDs the green and blue are swapped,
+so the order is ``(Red, Blue, Green, Brightness)``.
+The APA102 has more of a square lens while the APA102C has more of a round one.
+If you are using a APA102C strip and would prefer to provide colours in RGB
+order instead of RBG, you can customise the tuple colour order like so::
+
+    >>> strip.ORDER = (0, 2, 1, 3)
+
+To set the colour of pixels use::
+
+    >>> strip[0] = (255, 255, 255, 31) # set to white, full brightness
+    >>> strip[1] = (255, 0, 0, 31) # set to red, full brightness
+    >>> strip[2] = (0, 255, 0, 15) # set to green, half brightness
+    >>> strip[3] = (0, 0, 255, 7)  # set to blue, quarter brightness
+
+Use the ``write()`` method to output the colours to the LEDs::
+
+    >>> strip.write()
+
+Demonstration::
+
+    import time
+    import machine, apa102
+
+    # 1M strip with 60 LEDs
+    strip = apa102.APA102(machine.Pin(5), machine.Pin(4), 60)
+
+    brightness = 1  # 0 is off, 1 is dim, 31 is max
+
+    # Helper for converting 0-255 offset to a colour tuple
+    def wheel(offset, brightness):
+        # The colours are a transition r - g - b - back to r
+        offset = 255 - offset
+        if offset < 85:
+            return (255 - offset * 3, 0, offset * 3, brightness)
+        if offset < 170:
+            offset -= 85
+            return (0, offset * 3, 255 - offset * 3, brightness)
+        offset -= 170
+        return (offset * 3, 255 - offset * 3, 0, brightness)
+
+    # Demo 1: RGB RGB RGB
+    red = 0xff0000
+    green = red >> 8
+    blue = red >> 16
+    for i in range(strip.n):
+        colour = red >> (i % 3) * 8
+        strip[i] = ((colour & red) >> 16, (colour & green) >> 8, (colour & blue), brightness)
+    strip.write()
+
+    # Demo 2: Show all colours of the rainbow
+    for i in range(strip.n):
+        strip[i] = wheel((i * 256 // strip.n) % 255, brightness)
+    strip.write()
+
+    # Demo 3: Fade all pixels together through rainbow colours, offset each pixel
+    for r in range(5):
+        for n in range(256):
+            for i in range(strip.n):
+                strip[i] = wheel(((i * 256 // strip.n) + n) & 255, brightness)
+            strip.write()
+        time.sleep_ms(25)
+
+    # Demo 4: Same colour, different brightness levels
+    for b in range(31,-1,-1):
+        strip[0] = (255, 153, 0, b)
+        strip.write()
+        time.sleep_ms(250)
+
+    # End: Turn off all the LEDs
+    strip.fill((0, 0, 0, 0))
+    strip.write()
diff --git a/docs/esp8266/tutorial/index.rst b/docs/esp8266/tutorial/index.rst
index 0a4b5f2a6688a..4ba211a4b2d8b 100644
--- a/docs/esp8266/tutorial/index.rst
+++ b/docs/esp8266/tutorial/index.rst
@@ -29,5 +29,6 @@ to `<https://www.python.org>`__.
    powerctrl.rst
    onewire.rst
    neopixel.rst
+   apa102.rst
    dht.rst
    nextsteps.rst
diff --git a/docs/esp8266/tutorial/network_tcp.rst b/docs/esp8266/tutorial/network_tcp.rst
index 26a2f469ce190..18916884e45fb 100644
--- a/docs/esp8266/tutorial/network_tcp.rst
+++ b/docs/esp8266/tutorial/network_tcp.rst
@@ -44,7 +44,7 @@ Now that we are connected we can download and display the data::
     ...     data = s.recv(500)
     ...     print(str(data, 'utf8'), end='')
     ...
- 
+
 When this loop executes it should start showing the animation (use ctrl-C to
 interrupt it).
 
@@ -61,6 +61,7 @@ of the request you need to specify the page to retrieve.
 Let's define a function that can download and print a URL::
 
     def http_get(url):
+        import socket
         _, _, host, path = url.split('/', 3)
         addr = socket.getaddrinfo(host, 80)[0][-1]
         s = socket.socket()
@@ -74,8 +75,7 @@ Let's define a function that can download and print a URL::
                 break
         s.close()
 
-Make sure that you import the socket module before running this function.  Then
-you can try::
+Then you can try::
 
     >>> http_get('http://micropython.org/ks/test.html')
 
@@ -118,5 +118,6 @@ that contains a table with the state of all the GPIO pins::
                 break
         rows = ['<tr><td>%s</td><td>%d</td></tr>' % (str(p), p.value()) for p in pins]
         response = html % '\n'.join(rows)
+        cl.send('HTTP/1.0 200 OK\r\nContent-type: text/html\r\n\r\n')
         cl.send(response)
         cl.close()
diff --git a/docs/index.rst b/docs/index.rst
index c0417c227cbad..f760fa12a080a 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -12,3 +12,4 @@ MicroPython documentation and references
     esp8266/quickref.rst
     esp32/quickref.rst
     wipy/quickref.rst
+    unix/quickref.rst
diff --git a/docs/library/btree.rst b/docs/library/btree.rst
index 3578acd8fd42c..a1f7a5420f15e 100644
--- a/docs/library/btree.rst
+++ b/docs/library/btree.rst
@@ -116,7 +116,7 @@ Methods
    Flush any data in cache to the underlying stream.
 
 .. method:: btree.__getitem__(key)
-            btree.get(key, default=None)
+            btree.get(key, default=None, /)
             btree.__setitem__(key, val)
             btree.__detitem__(key)
             btree.__contains__(key)
diff --git a/docs/library/esp.rst b/docs/library/esp.rst
index 867182be9945c..cb2bc7af8d538 100644
--- a/docs/library/esp.rst
+++ b/docs/library/esp.rst
@@ -31,7 +31,7 @@ Functions
 
     The system enters the set sleep mode automatically when possible.
 
-.. function:: deepsleep(time=0)
+.. function:: deepsleep(time=0, /)
 
     **Note**: ESP8266 only - use `machine.deepsleep()` on ESP32
 
diff --git a/docs/library/esp32.rst b/docs/library/esp32.rst
index c934ef0954872..f3be3692e3267 100644
--- a/docs/library/esp32.rst
+++ b/docs/library/esp32.rst
@@ -1,3 +1,5 @@
+.. currentmodule:: esp32
+
 :mod:`esp32` --- functionality specific to the ESP32
 ====================================================
 
@@ -36,9 +38,190 @@ Functions
 
     Read the raw value of the internal Hall sensor, returning an integer.
 
+.. function:: idf_heap_info(capabilities)
+
+    Returns information about the ESP-IDF heap memory regions. One of them contains
+    the MicroPython heap and the others are used by ESP-IDF, e.g., for network
+    buffers and other data. This data is useful to get a sense of how much memory
+    is available to ESP-IDF and the networking stack in particular. It may shed
+    some light on situations where ESP-IDF operations fail due to allocation failures.
+    The information returned is *not* useful to troubleshoot Python allocation failures,
+    use `micropython.mem_info()` instead.
+
+    The capabilities parameter corresponds to ESP-IDF's ``MALLOC_CAP_XXX`` values but the
+    two most useful ones are predefined as `esp32.HEAP_DATA` for data heap regions and
+    `esp32.HEAP_EXEC` for executable regions as used by the native code emitter.
+
+    The return value is a list of 4-tuples, where each 4-tuple corresponds to one heap
+    and contains: the total bytes, the free bytes, the largest free block, and
+    the minimum free seen over time.
+
+    Example after booting::
+
+        >>> import esp32; esp32.idf_heap_info(esp32.HEAP_DATA)
+        [(240, 0, 0, 0), (7288, 0, 0, 0), (16648, 4, 4, 4), (79912, 35712, 35512, 35108),
+         (15072, 15036, 15036, 15036), (113840, 0, 0, 0)]
+
+Flash partitions
+----------------
+
+This class gives access to the partitions in the device's flash memory and includes
+methods to enable over-the-air (OTA) updates.
+
+.. class:: Partition(id)
+
+    Create an object representing a partition.  *id* can be a string which is the label
+    of the partition to retrieve, or one of the constants: ``BOOT`` or ``RUNNING``.
+
+.. classmethod:: Partition.find(type=TYPE_APP, subtype=0xff, label=None)
+
+    Find a partition specified by *type*, *subtype* and *label*.  Returns a
+    (possibly empty) list of Partition objects. Note: ``subtype=0xff`` matches any subtype
+    and ``label=None`` matches any label.
+
+.. method:: Partition.info()
+
+    Returns a 6-tuple ``(type, subtype, addr, size, label, encrypted)``.
+
+.. method:: Partition.readblocks(block_num, buf)
+.. method:: Partition.readblocks(block_num, buf, offset)
+.. method:: Partition.writeblocks(block_num, buf)
+.. method:: Partition.writeblocks(block_num, buf, offset)
+.. method:: Partition.ioctl(cmd, arg)
+
+    These methods implement the simple and :ref:`extended
+    <block-device-interface>` block protocol defined by
+    :class:`uos.AbstractBlockDev`.
+
+.. method:: Partition.set_boot()
+
+    Sets the partition as the boot partition.
+
+.. method:: Partition.get_next_update()
+
+    Gets the next update partition after this one, and returns a new Partition object.
+    Typical usage is ``Partition(Partition.RUNNING).get_next_update()``
+    which returns the next partition to update given the current running one.
+
+.. classmethod:: Partition.mark_app_valid_cancel_rollback()
+
+    Signals that the current boot is considered successful.
+    Calling ``mark_app_valid_cancel_rollback`` is required on the first boot of a new
+    partition to avoid an automatic rollback at the next boot.
+    This uses the ESP-IDF "app rollback" feature with "CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE"
+    and  an ``OSError(-261)`` is raised if called on firmware that doesn't have the
+    feature enabled.
+    It is OK to call ``mark_app_valid_cancel_rollback`` on every boot and it is not
+    necessary when booting firmare that was loaded using esptool.
+
+Constants
+~~~~~~~~~
+
+.. data:: Partition.BOOT
+          Partition.RUNNING
+
+    Used in the `Partition` constructor to fetch various partitions: ``BOOT`` is the
+    partition that will be booted at the next reset and ``RUNNING`` is the currently
+    running partition.
+
+.. data:: Partition.TYPE_APP
+          Partition.TYPE_DATA
+
+    Used in `Partition.find` to specify the partition type: ``APP`` is for bootable
+    firmware partitions (typically labelled ``factory``, ``ota_0``, ``ota_1``), and
+    ``DATA`` is for other partitions, e.g. ``nvs``, ``otadata``, ``phy_init``, ``vfs``.
+
+.. data:: HEAP_DATA
+          HEAP_EXEC
+
+    Used in `idf_heap_info`.
+
+.. _esp32.RMT:
+
+RMT
+---
+
+The RMT (Remote Control) module, specific to the ESP32, was originally designed
+to send and receive infrared remote control signals. However, due to a flexible
+design and very accurate (as low as 12.5ns) pulse generation, it can also be
+used to transmit or receive many other types of digital signals::
+
+    import esp32
+    from machine import Pin
+
+    r = esp32.RMT(0, pin=Pin(18), clock_div=8)
+    r  # RMT(channel=0, pin=18, source_freq=80000000, clock_div=8)
+    # The channel resolution is 100ns (1/(source_freq/clock_div)).
+    r.write_pulses((1, 20, 2, 40), start=0)  # Send 0 for 100ns, 1 for 2000ns, 0 for 200ns, 1 for 4000ns
+
+The input to the RMT module is an 80MHz clock (in the future it may be able to
+configure the input clock but, for now, it's fixed). ``clock_div`` *divides*
+the clock input which determines the resolution of the RMT channel. The
+numbers specificed in ``write_pulses`` are multiplied by the resolution to
+define the pulses.
+
+``clock_div`` is an 8-bit divider (0-255) and each pulse can be defined by
+multiplying the resolution by a 15-bit (0-32,768) number. There are eight
+channels (0-7) and each can have a different clock divider.
+
+So, in the example above, the 80MHz clock is divided by 8. Thus the
+resolution is (1/(80Mhz/8)) 100ns. Since the ``start`` level is 0 and toggles
+with each number, the bitstream is ``0101`` with durations of [100ns, 2000ns,
+100ns, 4000ns].
+
+For more details see Espressif's `ESP-IDF RMT documentation.
+<https://docs.espressif.com/projects/esp-idf/en/latest/api-reference/peripherals/rmt.html>`_.
+
+.. Warning::
+   The current MicroPython RMT implementation lacks some features, most notably
+   receiving pulses and carrier transmit. RMT should be considered a
+   *beta feature* and the interface may change in the future.
+
+
+.. class:: RMT(channel, \*, pin=None, clock_div=8)
+
+    This class provides access to one of the eight RMT channels. *channel* is
+    required and identifies which RMT channel (0-7) will be configured. *pin*,
+    also required, configures which Pin is bound to the RMT channel. *clock_div*
+    is an 8-bit clock divider that divides the source clock (80MHz) to the RMT
+    channel allowing the resolution to be specified.
+
+.. method:: RMT.source_freq()
+
+    Returns the source clock frequency. Currently the source clock is not
+    configurable so this will always return 80MHz.
+
+.. method:: RMT.clock_div()
+
+    Return the clock divider. Note that the channel resolution is
+    ``1 / (source_freq / clock_div)``.
+
+.. method:: RMT.wait_done(timeout=0)
+
+    Returns True if `RMT.write_pulses` has completed.
+
+    If *timeout* (defined in ticks of ``source_freq / clock_div``) is specified
+    the method will wait for *timeout* or until `RMT.write_pulses` is complete,
+    returning ``False`` if the channel continues to transmit.
+
+.. Warning::
+    Avoid using ``wait_done()`` if looping is enabled.
+
+.. method:: RMT.loop(enable_loop)
+
+    Configure looping on the channel, allowing a stream of pulses to be
+    indefinitely repeated. *enable_loop* is bool, set to True to enable looping.
+
+.. method:: RMT.write_pulses(pulses, start)
+
+    Begin sending *pulses*, a list or tuple defining the stream of pulses. The
+    length of each pulse is defined by a number to be multiplied by the channel
+    resolution ``(1 / (source_freq / clock_div))``. *start* defines whether the
+    stream starts at 0 or 1.
+
 
-The Ultra-Low-Power co-processor
---------------------------------
+Ultra-Low-Power co-processor
+----------------------------
 
 .. class:: ULP()
 
diff --git a/docs/library/framebuf.rst b/docs/library/framebuf.rst
index ed4b78ab14625..0073ba708d8a3 100644
--- a/docs/library/framebuf.rst
+++ b/docs/library/framebuf.rst
@@ -1,4 +1,4 @@
-:mod:`framebuf` --- Frame buffer manipulation
+:mod:`framebuf` --- frame buffer manipulation
 =============================================
 
 .. module:: framebuf
@@ -19,7 +19,7 @@ For example::
     import framebuf
 
     # FrameBuffer needs 2 bytes for every RGB565 pixel
-    fbuf = FrameBuffer(bytearray(10 * 100 * 2), 10, 100, framebuf.RGB565)
+    fbuf = framebuf.FrameBuffer(bytearray(10 * 100 * 2), 10, 100, framebuf.RGB565)
 
     fbuf.fill(0)
     fbuf.text('MicroPython!', 0, 0, 0xffff)
@@ -28,7 +28,7 @@ For example::
 Constructors
 ------------
 
-.. class:: FrameBuffer(buffer, width, height, format, stride=width)
+.. class:: FrameBuffer(buffer, width, height, format, stride=width, /)
 
     Construct a FrameBuffer object.  The parameters are:
 
@@ -130,7 +130,7 @@ Constants
 
     Monochrome (1-bit) color format
     This defines a mapping where the bits in a byte are horizontally mapped.
-    Each byte occupies 8 horizontal pixels with bit 0 being the leftmost.
+    Each byte occupies 8 horizontal pixels with bit 7 being the leftmost.
     Subsequent bytes appear at successive horizontal locations until the
     rightmost edge is reached. Further bytes are rendered on the next row, one
     pixel lower.
@@ -139,7 +139,7 @@ Constants
 
     Monochrome (1-bit) color format
     This defines a mapping where the bits in a byte are horizontally mapped.
-    Each byte occupies 8 horizontal pixels with bit 7 being the leftmost.
+    Each byte occupies 8 horizontal pixels with bit 0 being the leftmost.
     Subsequent bytes appear at successive horizontal locations until the
     rightmost edge is reached. Further bytes are rendered on the next row, one
     pixel lower.
diff --git a/docs/library/index.rst b/docs/library/index.rst
index b464e85fa2f73..7b1636ce61b33 100644
--- a/docs/library/index.rst
+++ b/docs/library/index.rst
@@ -74,11 +74,12 @@ it will fallback to loading the built-in ``ujson`` module.
    :maxdepth: 1
 
    builtins.rst
-   array.rst
    cmath.rst
    gc.rst
    math.rst
    sys.rst
+   uarray.rst
+   uasyncio.rst
    ubinascii.rst
    ucollections.rst
    uerrno.rst
@@ -111,10 +112,24 @@ the following libraries.
    machine.rst
    micropython.rst
    network.rst
+   ubluetooth.rst
    ucryptolib.rst
    uctypes.rst
 
 
+Port-specific libraries
+-----------------------
+
+In some cases the following port/board-specific libraries have functions or
+classes similar to those in the :mod:`machine` library.  Where this occurs, the
+entry in the port specific library exposes hardware functionality unique to
+that platform.
+
+To write portable code use functions and classes from the :mod:`machine` module.
+To access platform-specific hardware use the appropriate library, e.g.
+:mod:`pyb` in the case of the Pyboard.
+
+
 Libraries specific to the pyboard
 ---------------------------------
 
@@ -136,6 +151,7 @@ The following libraries and classes are specific to the WiPy.
   :maxdepth: 2
 
   wipy.rst
+  machine.ADCWiPy.rst
   machine.TimerWiPy.rst
 
 
diff --git a/docs/library/lcd160cr.rst b/docs/library/lcd160cr.rst
index bb8e6da22ce5e..e31ed94651ca5 100644
--- a/docs/library/lcd160cr.rst
+++ b/docs/library/lcd160cr.rst
@@ -340,7 +340,7 @@ Advanced commands
 .. method:: LCD160CR.set_scroll_win_param(win, param, value)
 
     Set a single parameter of a scrolling window region:
-    
+
         - *win* is the window id, 0..8.
         - *param* is the parameter number to configure, 0..7, and corresponds
           to the parameters in the `set_scroll_win` method.
diff --git a/docs/library/machine.ADC.rst b/docs/library/machine.ADC.rst
index 4c7a04d74f07f..1404b454ae7f5 100644
--- a/docs/library/machine.ADC.rst
+++ b/docs/library/machine.ADC.rst
@@ -4,71 +4,32 @@
 class ADC -- analog to digital conversion
 =========================================
 
-Usage::
+The ADC class provides an interface to analog-to-digital convertors, and
+represents a single endpoint that can sample a continuous voltage and
+convert it to a discretised value.
+
+Example usage::
 
    import machine
 
-   adc = machine.ADC()             # create an ADC object
-   apin = adc.channel(pin='GP3')   # create an analog pin on GP3
-   val = apin()                    # read an analog value
+   adc = machine.ADC(pin)   # create an ADC object acting on a pin
+   val = adc.read_u16()     # read a raw analog value in the range 0-65535
 
 Constructors
 ------------
 
-.. class:: ADC(id=0, \*, bits=12)
-
-   Create an ADC object associated with the given pin.
-   This allows you to then read analog values on that pin.
-   For more info check the `pinout and alternate functions
-   table. <https://raw.githubusercontent.com/wipy/wipy/master/docs/PinOUT.png>`_ 
-
-   .. warning:: 
+.. class:: ADC(id)
 
-      ADC pin input range is 0-1.4V (being 1.8V the absolute maximum that it 
-      can withstand). When GP2, GP3, GP4 or GP5 are remapped to the 
-      ADC block, 1.8 V is the maximum. If these pins are used in digital mode, 
-      then the maximum allowed input is 3.6V.
+   Access the ADC associated with a source identified by *id*.  This
+   *id* may be an integer (usually specifying a channel number), a
+   :ref:`Pin <machine.Pin>` object, or other value supported by the
+   underlying machine.
 
 Methods
 -------
 
-.. method:: ADC.channel(id, \*, pin)
-
-   Create an analog pin. If only channel ID is given, the correct pin will
-   be selected. Alternatively, only the pin can be passed and the correct
-   channel will be selected. Examples::
-
-      # all of these are equivalent and enable ADC channel 1 on GP3
-      apin = adc.channel(1)
-      apin = adc.channel(pin='GP3')
-      apin = adc.channel(id=1, pin='GP3')
-
-.. method:: ADC.init()
-
-   Enable the ADC block.
-
-.. method:: ADC.deinit()
-
-   Disable the ADC block.
-
-class ADCChannel --- read analog values from internal or external sources
-=========================================================================
-
-ADC channels can be connected to internal points of the MCU or to GPIO pins.
-ADC channels are created using the ADC.channel method.
-
-.. method:: adcchannel()
-
-   Fast method to read the channel value.
-
-.. method:: adcchannel.value()
-
-   Read the channel value.
-
-.. method:: adcchannel.init()
-
-   Re-init (and effectively enable) the ADC channel.
-
-.. method:: adcchannel.deinit()
+.. method:: ADC.read_u16()
 
-   Disable the ADC channel.
+   Take an analog reading and return an integer in the range 0-65535.
+   The return value represents the raw reading taken by the ADC, scaled
+   such that the minimum value is 0 and the maximum value is 65535.
diff --git a/docs/library/machine.ADCWiPy.rst b/docs/library/machine.ADCWiPy.rst
new file mode 100644
index 0000000000000..4a4f0524c8f0b
--- /dev/null
+++ b/docs/library/machine.ADCWiPy.rst
@@ -0,0 +1,81 @@
+.. currentmodule:: machine
+.. _machine.ADCWiPy:
+
+class ADCWiPy -- analog to digital conversion
+=============================================
+
+.. note::
+
+    This class is a non-standard ADC implementation for the WiPy.
+    It is available simply as ``machine.ADC`` on the WiPy but is named in the
+    documentation below as ``machine.ADCWiPy`` to distinguish it from the
+    more general :ref:`machine.ADC <machine.ADC>` class.
+
+Usage::
+
+   import machine
+
+   adc = machine.ADC()             # create an ADC object
+   apin = adc.channel(pin='GP3')   # create an analog pin on GP3
+   val = apin()                    # read an analog value
+
+Constructors
+------------
+
+.. class:: ADCWiPy(id=0, \*, bits=12)
+
+   Create an ADC object associated with the given pin.
+   This allows you to then read analog values on that pin.
+   For more info check the `pinout and alternate functions
+   table. <https://raw.githubusercontent.com/wipy/wipy/master/docs/PinOUT.png>`_ 
+
+   .. warning:: 
+
+      ADC pin input range is 0-1.4V (being 1.8V the absolute maximum that it 
+      can withstand). When GP2, GP3, GP4 or GP5 are remapped to the 
+      ADC block, 1.8 V is the maximum. If these pins are used in digital mode, 
+      then the maximum allowed input is 3.6V.
+
+Methods
+-------
+
+.. method:: ADCWiPy.channel(id, \*, pin)
+
+   Create an analog pin. If only channel ID is given, the correct pin will
+   be selected. Alternatively, only the pin can be passed and the correct
+   channel will be selected. Examples::
+
+      # all of these are equivalent and enable ADC channel 1 on GP3
+      apin = adc.channel(1)
+      apin = adc.channel(pin='GP3')
+      apin = adc.channel(id=1, pin='GP3')
+
+.. method:: ADCWiPy.init()
+
+   Enable the ADC block.
+
+.. method:: ADCWiPy.deinit()
+
+   Disable the ADC block.
+
+class ADCChannel --- read analog values from internal or external sources
+=========================================================================
+
+ADC channels can be connected to internal points of the MCU or to GPIO pins.
+ADC channels are created using the ADC.channel method.
+
+.. method:: adcchannel()
+
+   Fast method to read the channel value.
+
+.. method:: adcchannel.value()
+
+   Read the channel value.
+
+.. method:: adcchannel.init()
+
+   Re-init (and effectively enable) the ADC channel.
+
+.. method:: adcchannel.deinit()
+
+   Disable the ADC channel.
diff --git a/docs/library/machine.I2C.rst b/docs/library/machine.I2C.rst
index 71ca9b0d3b2c8..2cbfec1ba83bf 100644
--- a/docs/library/machine.I2C.rst
+++ b/docs/library/machine.I2C.rst
@@ -89,7 +89,7 @@ These methods are available on software I2C only.
 
    Generate a STOP condition on the bus (SDA transitions to high while SCL is high).
 
-.. method:: I2C.readinto(buf, nack=True)
+.. method:: I2C.readinto(buf, nack=True, /)
 
    Reads bytes from the bus and stores them into *buf*.  The number of bytes
    read is the length of *buf*.  An ACK will be sent on the bus after
@@ -109,13 +109,13 @@ Standard bus operations
 The following methods implement the standard I2C master read and write
 operations that target a given slave device.
 
-.. method:: I2C.readfrom(addr, nbytes, stop=True)
+.. method:: I2C.readfrom(addr, nbytes, stop=True, /)
 
    Read *nbytes* from the slave specified by *addr*.
    If *stop* is true then a STOP condition is generated at the end of the transfer.
    Returns a `bytes` object with the data read.
 
-.. method:: I2C.readfrom_into(addr, buf, stop=True)
+.. method:: I2C.readfrom_into(addr, buf, stop=True, /)
 
    Read into *buf* from the slave specified by *addr*.
    The number of bytes read will be the length of *buf*.
@@ -123,7 +123,7 @@ operations that target a given slave device.
 
    The method returns ``None``.
 
-.. method:: I2C.writeto(addr, buf, stop=True)
+.. method:: I2C.writeto(addr, buf, stop=True, /)
 
    Write the bytes from *buf* to the slave specified by *addr*.  If a
    NACK is received following the write of a byte from *buf* then the
@@ -131,6 +131,20 @@ operations that target a given slave device.
    generated at the end of the transfer, even if a NACK is received.
    The function returns the number of ACKs that were received.
 
+.. method:: I2C.writevto(addr, vector, stop=True, /)
+
+   Write the bytes contained in *vector* to the slave specified by *addr*.
+   *vector* should be a tuple or list of objects with the buffer protocol.
+   The *addr* is sent once and then the bytes from each object in *vector*
+   are written out sequentially.  The objects in *vector* may be zero bytes
+   in length in which case they don't contribute to the output.
+
+   If a NACK is received following the write of a byte from one of the
+   objects in *vector* then the remaining bytes, and any remaining objects,
+   are not sent.  If *stop* is true then a STOP condition is generated at
+   the end of the transfer, even if a NACK is received.  The function
+   returns the number of ACKs that were received.
+
 Memory operations
 -----------------
 
diff --git a/docs/library/machine.Pin.rst b/docs/library/machine.Pin.rst
index 5254e163c02a3..3055491ebbba8 100644
--- a/docs/library/machine.Pin.rst
+++ b/docs/library/machine.Pin.rst
@@ -216,6 +216,7 @@ Methods
      - ``hard`` if true a hardware interrupt is used. This reduces the delay
        between the pin change and the handler being called. Hard interrupt
        handlers may not allocate memory; see :ref:`isr_rules`.
+       Not all ports support this argument.
 
    This method returns a callback object.
 
diff --git a/docs/library/machine.RTC.rst b/docs/library/machine.RTC.rst
index 95fa2b4ce6094..548ad007e0dc3 100644
--- a/docs/library/machine.RTC.rst
+++ b/docs/library/machine.RTC.rst
@@ -27,7 +27,7 @@ Methods
 .. method:: RTC.init(datetime)
 
    Initialise the RTC. Datetime is a tuple of the form:
-   
+
       ``(year, month, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]])``
 
 .. method:: RTC.now()
diff --git a/docs/library/machine.SD.rst b/docs/library/machine.SD.rst
index 9c58e73545edd..d985db231aa44 100644
--- a/docs/library/machine.SD.rst
+++ b/docs/library/machine.SD.rst
@@ -1,8 +1,8 @@
 .. currentmodule:: machine
 .. _machine.SD:
 
-class SD -- secure digital memory card
-======================================
+class SD -- secure digital memory card (cc3200 port only)
+=========================================================
 
 .. warning::
 
diff --git a/docs/library/machine.SDCard.rst b/docs/library/machine.SDCard.rst
new file mode 100644
index 0000000000000..b1cf42ec0285b
--- /dev/null
+++ b/docs/library/machine.SDCard.rst
@@ -0,0 +1,124 @@
+.. currentmodule:: machine
+.. _machine.SDCard:
+
+class SDCard -- secure digital memory card
+==========================================
+
+SD cards are one of the most common small form factor removable storage media.
+SD cards come in a variety of sizes and physical form factors. MMC cards are
+similar removable storage devices while eMMC devices are electrically similar
+storage devices designed to be embedded into other systems. All three form
+share a common protocol for communication with their host system and high-level
+support looks the same for them all. As such in MicroPython they are implemented
+in a single class called :class:`machine.SDCard` .
+
+Both SD and MMC interfaces support being accessed with a variety of bus widths.
+When being accessed with a 1-bit wide interface they can be accessed using the
+SPI protocol. Different MicroPython hardware platforms support different widths
+and pin configurations but for most platforms there is a standard configuration
+for any given hardware. In general constructing an ``SDCard`` object with without
+passing any parameters will initialise the interface to the default card slot
+for the current hardware. The arguments listed below represent the common
+arguments that might need to be set in order to use either a non-standard slot
+or a non-standard pin assignment. The exact subset of arguments supported will
+vary from platform to platform.
+
+.. class:: SDCard(slot=1, width=1, cd=None, wp=None, sck=None, miso=None, mosi=None, cs=None, freq=20000000)
+
+    This class provides access to SD or MMC storage cards using either
+    a dedicated SD/MMC interface hardware or through an SPI channel.
+    The class implements the block protocol defined by :class:`uos.AbstractBlockDev`.
+    This allows the mounting of an SD card to be as simple as::
+
+      uos.mount(machine.SDCard(), "/sd")
+
+    The constructor takes the following parameters:
+
+     - *slot* selects which of the available interfaces to use. Leaving this
+       unset will select the default interface.
+
+     - *width* selects the bus width for the SD/MMC interface.
+
+     - *cd* can be used to specify a card-detect pin.
+
+     - *wp* can be used to specify a write-protect pin.
+
+     - *sck* can be used to specify an SPI clock pin.
+
+     - *miso* can be used to specify an SPI miso pin.
+
+     - *mosi* can be used to specify an SPI mosi pin.
+
+     - *cs* can be used to specify an SPI chip select pin.
+     
+     - *freq* selects the SD/MMC interface frequency in Hz (only supported on the ESP32).
+
+Implementation-specific details
+-------------------------------
+
+Different implementations of the ``SDCard`` class on different hardware support
+varying subsets of the options above.
+
+PyBoard
+```````
+
+The standard PyBoard has just one slot. No arguments are necessary or supported.
+
+ESP32
+`````
+
+The ESP32 provides two channels of SD/MMC hardware and also supports
+access to SD Cards through either of the two SPI ports that are
+generally available to the user. As a result the *slot* argument can
+take a value between 0 and 3, inclusive. Slots 0 and 1 use the
+built-in SD/MMC hardware while slots 2 and 3 use the SPI ports. Slot 0
+supports 1, 4 or 8-bit wide access while slot 1 supports 1 or 4-bit
+access; the SPI slots only support 1-bit access.
+
+  .. note:: Slot 0 is used to communicate with on-board flash memory
+            on most ESP32 modules and so will be unavailable to the
+            user.
+
+  .. note:: Most ESP32 modules that provide an SD card slot using the
+            dedicated hardware only wire up 1 data pin, so the default
+            value for *width* is 1.
+
+The pins used by the dedicated SD/MMC hardware are fixed. The pins
+used by the SPI hardware can be reassigned.
+
+  .. note:: If any of the SPI signals are remapped then all of the SPI
+            signals will pass through a GPIO multiplexer unit which
+            can limit the performance of high frequency signals. Since
+            the normal operating speed for SD cards is 40MHz this can
+            cause problems on some cards.
+
+The default (and preferred) pin assignment are as follows:
+
+    ====== ====== ====== ====== ======
+    Slot   0      1      2      3
+    ------ ------ ------ ------ ------
+    Signal   Pin    Pin    Pin    Pin
+    ====== ====== ====== ====== ======
+    sck       6     14     18     14
+    cmd      11     15
+    cs                      5     15
+    miso                   19     12
+    mosi                   23     13
+    D0        7      2
+    D1        8      4
+    D2        9     12
+    D3       10     13
+    D4       16
+    D5       17
+    D6        5
+    D7       18
+    ====== ====== ====== ====== ======
+
+cc3200
+``````
+
+You can set the pins used for SPI access by passing a tuple as the
+*pins* argument.
+
+*Note:* The current cc3200 SD card implementation names the this class
+:class:`machine.SD` rather than :class:`machine.SDCard` .
diff --git a/docs/library/machine.TimerWiPy.rst b/docs/library/machine.TimerWiPy.rst
index abbcc28ff7ce8..904a958c69b16 100644
--- a/docs/library/machine.TimerWiPy.rst
+++ b/docs/library/machine.TimerWiPy.rst
@@ -47,9 +47,9 @@ Methods
        tim.init(Timer.ONE_SHOT, width=32)   # one shot 32-bit timer
 
    Keyword arguments:
-   
+
      - ``mode`` can be one of:
-     
+
        - ``TimerWiPy.ONE_SHOT`` - The timer runs once until the configured 
          period of the channel expires.
        - ``TimerWiPy.PERIODIC`` - The timer runs periodically at the configured 
@@ -70,7 +70,7 @@ Methods
    object is returned (or ``None`` if there is no previous channel).
 
    Otherwise, a TimerChannel object is initialized and returned.
-   
+
    The operating mode is is the one configured to the Timer object that was used to
    create the channel.
 
diff --git a/docs/library/machine.UART.rst b/docs/library/machine.UART.rst
index 5fcdc2758e0ff..70984dfb2fff1 100644
--- a/docs/library/machine.UART.rst
+++ b/docs/library/machine.UART.rst
@@ -58,6 +58,9 @@ Methods
      - *rx* specifies the RX pin to use.
      - *txbuf* specifies the length in characters of the TX buffer.
      - *rxbuf* specifies the length in characters of the RX buffer.
+     - *timeout* specifies the time to wait for the first character (in ms).
+     - *timeout_char* specifies the time to wait between characters (in ms).
+     - *invert* specifies which lines to invert.
 
    On the WiPy only the following keyword-only parameter is supported:
 
@@ -87,7 +90,8 @@ Methods
 .. method:: UART.read([nbytes])
 
    Read characters.  If ``nbytes`` is specified then read at most that many bytes,
-   otherwise read as much data as possible.
+   otherwise read as much data as possible. It may return sooner if a timeout
+   is reached. The timeout is configurable in the constructor.
 
    Return value: a bytes object containing the bytes read in.  Returns ``None``
    on timeout.
@@ -95,14 +99,16 @@ Methods
 .. method:: UART.readinto(buf[, nbytes])
 
    Read bytes into the ``buf``.  If ``nbytes`` is specified then read at most
-   that many bytes.  Otherwise, read at most ``len(buf)`` bytes.
+   that many bytes.  Otherwise, read at most ``len(buf)`` bytes. It may return sooner if a timeout
+   is reached. The timeout is configurable in the constructor.
 
    Return value: number of bytes read and stored into ``buf`` or ``None`` on
    timeout.
 
 .. method:: UART.readline()
 
-   Read a line, ending in a newline character.
+   Read a line, ending in a newline character. It may return sooner if a timeout
+   is reached. The timeout is configurable in the constructor.
 
    Return value: the line read or ``None`` on timeout.
 
diff --git a/docs/library/machine.WDT.rst b/docs/library/machine.WDT.rst
index 5ca6dce45d576..612f23ba38620 100644
--- a/docs/library/machine.WDT.rst
+++ b/docs/library/machine.WDT.rst
@@ -15,16 +15,18 @@ Example usage::
     wdt = WDT(timeout=2000)  # enable it with a timeout of 2s
     wdt.feed()
 
-Availability of this class: pyboard, WiPy.
+Availability of this class: pyboard, WiPy, esp8266, esp32.
 
 Constructors
 ------------
 
 .. class:: WDT(id=0, timeout=5000)
 
-   Create a WDT object and start it. The timeout must be given in seconds and
-   the minimum value that is accepted is 1 second. Once it is running the timeout
-   cannot be changed and the WDT cannot be stopped either.
+   Create a WDT object and start it. The timeout must be given in milliseconds.
+   Once it is running the timeout cannot be changed and the WDT cannot be stopped either.
+   
+   Notes: On the esp32 the minimum timeout is 1 second. On the esp8266 a timeout
+   cannot be specified, it is determined by the underlying system.
 
 Methods
 -------
diff --git a/docs/library/machine.rst b/docs/library/machine.rst
index a7b59577610be..b580353d6b564 100644
--- a/docs/library/machine.rst
+++ b/docs/library/machine.rst
@@ -27,6 +27,12 @@ Reset related functions
    Resets the device in a manner similar to pushing the external RESET
    button.
 
+.. function:: soft_reset()
+
+   Performs a soft reset of the interpreter, deleting all Python objects and
+   resetting the Python heap.  It tries to retain the method by which the user
+   is connected to the MicroPython REPL (eg serial, USB, Wifi).
+
 .. function:: reset_cause()
 
    Get the reset cause. See :ref:`constants <machine_constants>` for the possible return values.
@@ -105,7 +111,7 @@ Miscellaneous functions
    varies by hardware (so use substring of a full value if you expect a short
    ID). In some MicroPython ports, ID corresponds to the network MAC address.
 
-.. function:: time_pulse_us(pin, pulse_level, timeout_us=1000000)
+.. function:: time_pulse_us(pin, pulse_level, timeout_us=1000000, /)
 
    Time a pulse on the given *pin*, and return the duration of the pulse in
    microseconds.  The *pulse_level* argument should be 0 to time a low pulse
@@ -168,3 +174,4 @@ Classes
    machine.Timer.rst
    machine.WDT.rst
    machine.SD.rst
+   machine.SDCard.rst
diff --git a/docs/library/micropython.rst b/docs/library/micropython.rst
index d9f913bffdad5..ded52deb0d268 100644
--- a/docs/library/micropython.rst
+++ b/docs/library/micropython.rst
@@ -82,17 +82,26 @@ Functions
 
 .. function:: heap_lock()
 .. function:: heap_unlock()
+.. function:: heap_locked()
 
    Lock or unlock the heap.  When locked no memory allocation can occur and a
    `MemoryError` will be raised if any heap allocation is attempted.
+   `heap_locked()` returns a true value if the heap is currently locked.
 
    These functions can be nested, ie `heap_lock()` can be called multiple times
    in a row and the lock-depth will increase, and then `heap_unlock()` must be
    called the same number of times to make the heap available again.
 
+   Both `heap_unlock()` and `heap_locked()` return the current lock depth
+   (after unlocking for the former) as a non-negative integer, with 0 meaning
+   the heap is not locked.
+
    If the REPL becomes active with the heap locked then it will be forcefully
    unlocked.
 
+   Note: `heap_locked()` is not enabled on most ports by default,
+   requires `MICROPY_PY_MICROPYTHON_HEAP_LOCKED`.
+
 .. function:: kbd_intr(chr)
 
    Set the character that will raise a `KeyboardInterrupt` exception.  By
@@ -136,5 +145,5 @@ Functions
    :ref:`reference documentation <isr_rules>` under "Creation of Python
    objects".
 
-   There is a finite stack to hold the scheduled functions and `schedule()`
-   will raise a `RuntimeError` if the stack is full.
+   There is a finite queue to hold the scheduled functions and `schedule()`
+   will raise a `RuntimeError` if the queue is full.
diff --git a/docs/library/network.rst b/docs/library/network.rst
index 0c5659244c607..01e6f61369a40 100644
--- a/docs/library/network.rst
+++ b/docs/library/network.rst
@@ -68,7 +68,7 @@ parameter should be `id`.
        (password) required to access said service. There can be further
        arbitrary keyword-only parameters, depending on the networking medium
        type and/or particular device. Parameters can be used to: a)
-       specify alternative service identifer types; b) provide additional
+       specify alternative service identifier types; b) provide additional
        connection parameters. For various medium types, there are different
        sets of predefined/recommended parameters, among them:
 
diff --git a/docs/library/pyb.ADC.rst b/docs/library/pyb.ADC.rst
index a95f2d537c33f..1b16e0c2fcccb 100644
--- a/docs/library/pyb.ADC.rst
+++ b/docs/library/pyb.ADC.rst
@@ -19,7 +19,7 @@ Usage::
     val = adc.read_core_vref()          # read MCU VREF
     val = adc.read_vref()               # read MCU supply voltage
 
- 
+
 Constructors
 ------------
 
diff --git a/docs/library/pyb.Accel.rst b/docs/library/pyb.Accel.rst
index 9ade5c5c81523..d5c0ca8634598 100644
--- a/docs/library/pyb.Accel.rst
+++ b/docs/library/pyb.Accel.rst
@@ -19,7 +19,7 @@ Constructors
 .. class:: pyb.Accel()
 
    Create and return an accelerometer object.
-   
+
 Methods
 -------
 
diff --git a/docs/library/pyb.CAN.rst b/docs/library/pyb.CAN.rst
index 09b97a187c696..ba935abfd5c4e 100644
--- a/docs/library/pyb.CAN.rst
+++ b/docs/library/pyb.CAN.rst
@@ -92,7 +92,7 @@ Methods
 
    Force a software restart of the CAN controller without resetting its
    configuration.
-   
+
    If the controller enters the bus-off state then it will no longer participate
    in bus activity.  If the controller is not configured to automatically restart
    (see :meth:`~CAN.init()`) then this method can be used to trigger a restart,
diff --git a/docs/library/pyb.DAC.rst b/docs/library/pyb.DAC.rst
index c67603a710fc3..9a465b9ce25d8 100644
--- a/docs/library/pyb.DAC.rst
+++ b/docs/library/pyb.DAC.rst
@@ -93,9 +93,9 @@ Methods
 
 .. method:: DAC.triangle(freq)
 
-   Generate a triangle wave.  The value on the DAC output changes at
-   the given frequency, and the frequency of the repeating triangle wave
-   itself is 2048 times smaller.
+   Generate a triangle wave.  The value on the DAC output changes at the given
+   frequency and ramps through the full 12-bit range (up and down). Therefore
+   the frequency of the repeating triangle wave itself is 8192 times smaller.
 
 .. method:: DAC.write(value)
 
diff --git a/docs/library/pyb.ExtInt.rst b/docs/library/pyb.ExtInt.rst
index 814217cef0863..7741cc51e2381 100644
--- a/docs/library/pyb.ExtInt.rst
+++ b/docs/library/pyb.ExtInt.rst
@@ -54,7 +54,7 @@ Constructors
 .. class:: pyb.ExtInt(pin, mode, pull, callback)
 
    Create an ExtInt object:
-   
+
      - ``pin`` is the pin on which to enable the interrupt (can be a pin object or any valid pin name).
      - ``mode`` can be one of:
        - ``ExtInt.IRQ_RISING`` - trigger on a rising edge;
diff --git a/docs/library/pyb.Flash.rst b/docs/library/pyb.Flash.rst
new file mode 100644
index 0000000000000..2d2f83da1c6ad
--- /dev/null
+++ b/docs/library/pyb.Flash.rst
@@ -0,0 +1,52 @@
+.. currentmodule:: pyb
+.. _pyb.Flash:
+
+class Flash -- access to built-in flash storage
+===============================================
+
+The Flash class allows direct access to the primary flash device on the pyboard.
+
+In most cases, to store persistent data on the device, you'll want to use a
+higher-level abstraction, for example the filesystem via Python's standard file
+API, but this interface is useful to :ref:`customise the filesystem
+configuration <filesystem>` or implement a low-level storage system for your
+application.
+
+Constructors
+------------
+
+.. class:: pyb.Flash()
+
+   Create and return a block device that represents the flash device presented
+   to the USB mass storage interface.
+
+   It includes a virtual partition table at the start, and the actual flash
+   starts at block ``0x100``.
+
+   This constructor is deprecated and will be removed in a future version of MicroPython.
+
+.. class:: pyb.Flash(\*, start=-1, len=-1)
+
+   Create and return a block device that accesses the flash at the specified offset. The length defaults to the remaining size of the device.
+
+   The *start* and *len* offsets are in bytes, and must be a multiple of the block size (typically 512 for internal flash).
+
+Methods
+-------
+
+.. method:: Flash.readblocks(block_num, buf)
+.. method:: Flash.readblocks(block_num, buf, offset)
+.. method:: Flash.writeblocks(block_num, buf)
+.. method:: Flash.writeblocks(block_num, buf, offset)
+.. method:: Flash.ioctl(cmd, arg)
+
+    These methods implement the simple and :ref:`extended
+    <block-device-interface>` block protocol defined by
+    :class:`uos.AbstractBlockDev`.
+
+Hardware Note
+-------------
+
+On boards with external spiflash (e.g. Pyboard D), the MicroPython firmware will
+be configured to use that as the primary flash storage. On all other boards, the
+internal flash inside the :term:`MCU` will be used.
diff --git a/docs/library/pyb.LCD.rst b/docs/library/pyb.LCD.rst
index 5ab127edcda0e..018902ca6896a 100644
--- a/docs/library/pyb.LCD.rst
+++ b/docs/library/pyb.LCD.rst
@@ -63,13 +63,13 @@ Methods
 .. method:: LCD.fill(colour)
 
    Fill the screen with the given colour (0 or 1 for white or black).
-   
+
    This method writes to the hidden buffer.  Use ``show()`` to show the buffer.
 
 .. method:: LCD.get(x, y)
 
    Get the pixel at the position ``(x, y)``.  Returns 0 or 1.
-   
+
    This method reads from the visible buffer.
 
 .. method:: LCD.light(value)
@@ -79,7 +79,7 @@ Methods
 .. method:: LCD.pixel(x, y, colour)
 
    Set the pixel at ``(x, y)`` to the given colour (0 or 1).
-   
+
    This method writes to the hidden buffer.  Use ``show()`` to show the buffer.
 
 .. method:: LCD.show()
@@ -89,7 +89,7 @@ Methods
 .. method:: LCD.text(str, x, y, colour)
 
    Draw the given text to the position ``(x, y)`` using the given colour (0 or 1).
-   
+
    This method writes to the hidden buffer.  Use ``show()`` to show the buffer.
 
 .. method:: LCD.write(str)
diff --git a/docs/library/pyb.LED.rst b/docs/library/pyb.LED.rst
index 1ab73a69c9aa0..d3ab965e7e7c8 100644
--- a/docs/library/pyb.LED.rst
+++ b/docs/library/pyb.LED.rst
@@ -13,7 +13,7 @@ Constructors
 .. class:: pyb.LED(id)
 
    Create an LED object associated with the given LED:
-   
+
      - ``id`` is the LED number, 1-4.
 
 
diff --git a/docs/library/pyb.RTC.rst b/docs/library/pyb.RTC.rst
index 286268655e686..4c736597cf8db 100644
--- a/docs/library/pyb.RTC.rst
+++ b/docs/library/pyb.RTC.rst
@@ -28,13 +28,13 @@ Methods
 .. method:: RTC.datetime([datetimetuple])
 
    Get or set the date and time of the RTC.
-   
+
    With no arguments, this method returns an 8-tuple with the current
    date and time.  With 1 argument (being an 8-tuple) it sets the date
    and time (and ``subseconds`` is reset to 255).
-   
+
    The 8-tuple has the following format:
-   
+
        (year, month, day, weekday, hours, minutes, seconds, subseconds)
 
    ``weekday`` is 1-7 for Monday through Sunday.
diff --git a/docs/library/pyb.Timer.rst b/docs/library/pyb.Timer.rst
index 977ba8890d7de..bb7e7e52d5648 100644
--- a/docs/library/pyb.Timer.rst
+++ b/docs/library/pyb.Timer.rst
@@ -112,7 +112,7 @@ Methods
 .. method:: Timer.deinit()
 
    Deinitialises the timer.
-   
+
    Disables the callback (and the associated irq).
 
    Disables any channel callbacks (and the associated irq).
@@ -191,7 +191,7 @@ Methods
      - Read the encoder value using the timer.counter() method.
      - Only works on CH1 and CH2 (and not on CH1N or CH2N)
      - The channel number is ignored when setting the encoder mode.
-       
+
    PWM Example::
 
        timer = pyb.Timer(2, freq=1000)
diff --git a/docs/library/pyb.UART.rst b/docs/library/pyb.UART.rst
index 4359f1d9d67c0..ab7ab2fb882a4 100644
--- a/docs/library/pyb.UART.rst
+++ b/docs/library/pyb.UART.rst
@@ -69,7 +69,7 @@ Constructors
 Methods
 -------
 
-.. method:: UART.init(baudrate, bits=8, parity=None, stop=1, \*, timeout=1000, flow=0, timeout_char=0, read_buf_len=64)
+.. method:: UART.init(baudrate, bits=8, parity=None, stop=1, \*, timeout=0, flow=0, timeout_char=0, read_buf_len=64)
 
    Initialise the UART bus with the given parameters:
 
diff --git a/docs/library/pyb.USB_HID.rst b/docs/library/pyb.USB_HID.rst
index 70270443548d9..649dc3df4a605 100644
--- a/docs/library/pyb.USB_HID.rst
+++ b/docs/library/pyb.USB_HID.rst
@@ -24,11 +24,11 @@ Methods
 .. method:: USB_HID.recv(data, \*, timeout=5000)
 
    Receive data on the bus:
-   
+
      - ``data`` can be an integer, which is the number of bytes to receive,
        or a mutable buffer, which will be filled with received bytes.
      - ``timeout`` is the timeout in milliseconds to wait for the receive.
-   
+
    Return value: if ``data`` is an integer then a new buffer of the bytes received,
    otherwise the number of bytes read into ``data`` is returned.
 
diff --git a/docs/library/pyb.USB_VCP.rst b/docs/library/pyb.USB_VCP.rst
index 3bc6c749ceddd..b16924cf60b2e 100644
--- a/docs/library/pyb.USB_VCP.rst
+++ b/docs/library/pyb.USB_VCP.rst
@@ -12,14 +12,21 @@ the connected host.
 Constructors
 ------------
 
-.. class:: pyb.USB_VCP()
+.. class:: pyb.USB_VCP(id=0)
 
-   Create a new USB_VCP object.
+   Create a new USB_VCP object.  The *id* argument specifies which USB VCP port to
+   use.
 
 
 Methods
 -------
 
+.. method:: USB_VCP.init(\*, flow=-1)
+
+   Configure the USB VCP port.  If the *flow* argument is not -1 then the value sets
+   the flow control, which can be a bitwise-or of ``USB_VCP.RTS`` and ``USB_VCP.CTS``.
+   RTS is used to control read behaviour and CTS, to control write behaviour.
+
 .. method:: USB_VCP.setinterrupt(chr)
 
    Set the character which interrupts running Python code.  This is set
@@ -85,19 +92,28 @@ Methods
 .. method:: USB_VCP.recv(data, \*, timeout=5000)
 
    Receive data on the bus:
-   
+
      - ``data`` can be an integer, which is the number of bytes to receive,
        or a mutable buffer, which will be filled with received bytes.
      - ``timeout`` is the timeout in milliseconds to wait for the receive.
-   
+
    Return value: if ``data`` is an integer then a new buffer of the bytes received,
    otherwise the number of bytes read into ``data`` is returned.
 
 .. method:: USB_VCP.send(data, \*, timeout=5000)
 
    Send data over the USB VCP:
-   
+
      - ``data`` is the data to send (an integer to send, or a buffer object).
      - ``timeout`` is the timeout in milliseconds to wait for the send.
-   
+
    Return value: number of bytes sent.
+
+
+Constants
+---------
+
+.. data:: USB_VCP.RTS
+          USB_VCP.CTS
+
+   to select the flow control type.
diff --git a/docs/library/pyb.rst b/docs/library/pyb.rst
index 1e1e9ffaab58f..34103195ddd1c 100644
--- a/docs/library/pyb.rst
+++ b/docs/library/pyb.rst
@@ -20,7 +20,7 @@ Time related functions
 .. function:: millis()
 
    Returns the number of milliseconds since the board was last reset.
-   
+
    The result is always a MicroPython smallint (31-bit signed number), so
    after 2^30 milliseconds (about 12.4 days) this will start to return
    negative numbers.
@@ -32,7 +32,7 @@ Time related functions
 .. function:: micros()
 
    Returns the number of microseconds since the board was last reset.
-   
+
    The result is always a MicroPython smallint (31-bit signed number), so
    after 2^30 microseconds (about 17.8 minutes) this will start to return
    negative numbers.
@@ -44,10 +44,10 @@ Time related functions
 .. function:: elapsed_millis(start)
 
    Returns the number of milliseconds which have elapsed since ``start``.
-   
+
    This function takes care of counter wrap, and always returns a positive
    number. This means it can be used to measure periods up to about 12.4 days.
-   
+
    Example::
 
        start = pyb.millis()
@@ -57,10 +57,10 @@ Time related functions
 .. function:: elapsed_micros(start)
 
    Returns the number of microseconds which have elapsed since ``start``.
-   
+
    This function takes care of counter wrap, and always returns a positive
    number. This means it can be used to measure periods up to about 17.8 minutes.
-   
+
    Example::
 
        start = pyb.micros()
@@ -259,34 +259,45 @@ Miscellaneous functions
 
    Returns a string of 12 bytes (96 bits), which is the unique ID of the MCU.
 
-.. function:: usb_mode([modestr], vid=0xf055, pid=0x9801, hid=pyb.hid_mouse)
+.. function:: usb_mode([modestr], port=-1, vid=0xf055, pid=-1, msc=(), hid=pyb.hid_mouse, high_speed=False)
 
    If called with no arguments, return the current USB mode as a string.
 
-   If called with ``modestr`` provided, attempts to set USB mode.
-   This can only be done when called from ``boot.py`` before
-   :meth:`pyb.main()` has been called.  The following values of
-   ``modestr`` are understood:
+   If called with *modestr* provided, attempts to configure the USB mode.
+   The following values of *modestr* are understood:
 
    - ``None``: disables USB
    - ``'VCP'``: enable with VCP (Virtual COM Port) interface
    - ``'MSC'``: enable with MSC (mass storage device class) interface
    - ``'VCP+MSC'``: enable with VCP and MSC
    - ``'VCP+HID'``: enable with VCP and HID (human interface device)
+   - ``'VCP+MSC+HID'``: enabled with VCP, MSC and HID (only available on PYBD boards)
 
    For backwards compatibility, ``'CDC'`` is understood to mean
    ``'VCP'`` (and similarly for ``'CDC+MSC'`` and ``'CDC+HID'``).
 
-   The ``vid`` and ``pid`` parameters allow you to specify the VID
-   (vendor id) and PID (product id).
+   The *port* parameter should be an integer (0, 1, ...) and selects which
+   USB port to use if the board supports multiple ports.  A value of -1 uses
+   the default or automatically selected port.
+
+   The *vid* and *pid* parameters allow you to specify the VID (vendor id)
+   and PID (product id).  A *pid* value of -1 will select a PID based on the
+   value of *modestr*.
+
+   If enabling MSC mode, the *msc* parameter can be used to specify a list
+   of SCSI LUNs to expose on the mass storage interface.  For example
+   ``msc=(pyb.Flash(), pyb.SDCard())``.
 
    If enabling HID mode, you may also specify the HID details by
-   passing the ``hid`` keyword parameter.  It takes a tuple of
+   passing the *hid* keyword parameter.  It takes a tuple of
    (subclass, protocol, max packet length, polling interval, report
    descriptor).  By default it will set appropriate values for a USB
    mouse.  There is also a ``pyb.hid_keyboard`` constant, which is an
    appropriate tuple for a USB keyboard.
 
+   The *high_speed* parameter, when set to ``True``, enables USB HS mode if
+   it is supported by the hardware.
+
 Classes
 -------
 
@@ -298,6 +309,7 @@ Classes
    pyb.CAN.rst
    pyb.DAC.rst
    pyb.ExtInt.rst
+   pyb.Flash.rst
    pyb.I2C.rst
    pyb.LCD.rst
    pyb.LED.rst
diff --git a/docs/library/sys.rst b/docs/library/sys.rst
index f2d96cb8cc85d..24f9e353bb006 100644
--- a/docs/library/sys.rst
+++ b/docs/library/sys.rst
@@ -9,13 +9,26 @@
 Functions
 ---------
 
-.. function:: exit(retval=0)
+.. function:: exit(retval=0, /)
 
    Terminate current program with a given exit code. Underlyingly, this
    function raise as `SystemExit` exception. If an argument is given, its
    value given as an argument to `SystemExit`.
 
-.. function:: print_exception(exc, file=sys.stdout)
+.. function:: atexit(func)
+
+   Register *func* to be called upon termination.  *func* must be a callable
+   that takes no arguments, or ``None`` to disable the call.  The ``atexit``
+   function will return the previous value set by this function, which is
+   initially ``None``.
+
+   .. admonition:: Difference to CPython
+      :class: attention
+
+      This function is a MicroPython extension intended to provide similar
+      functionality to the :mod:`atexit` module in CPython.
+
+.. function:: print_exception(exc, file=sys.stdout, /)
 
    Print exception with a traceback to a file-like object *file* (or
    `sys.stdout` by default).
@@ -121,3 +134,9 @@ Constants
 .. data:: version_info
 
    Python language version that this implementation conforms to, as a tuple of ints.
+
+    .. admonition:: Difference to CPython
+      :class: attention
+
+      Only the first three version numbers (major, minor, micro) are supported and
+      they can be referenced only by index, not by name.
diff --git a/docs/library/array.rst b/docs/library/uarray.rst
similarity index 82%
rename from docs/library/array.rst
rename to docs/library/uarray.rst
index f837b034369b6..9fa82ff31b5c9 100644
--- a/docs/library/array.rst
+++ b/docs/library/uarray.rst
@@ -1,7 +1,7 @@
-:mod:`array` -- arrays of numeric data
-======================================
+:mod:`uarray` -- arrays of numeric data
+=======================================
 
-.. module:: array
+.. module:: uarray
    :synopsis: efficient arrays of numeric data
 
 |see_cpython_module| :mod:`python:array`.
@@ -13,7 +13,7 @@ floating-point support).
 Classes
 -------
 
-.. class:: array.array(typecode, [iterable])
+.. class:: array(typecode, [iterable])
 
     Create array with elements of given type. Initial contents of the
     array are given by *iterable*. If it is not provided, an empty
diff --git a/docs/library/uasyncio.rst b/docs/library/uasyncio.rst
new file mode 100644
index 0000000000000..0f363a076ea3b
--- /dev/null
+++ b/docs/library/uasyncio.rst
@@ -0,0 +1,297 @@
+:mod:`uasyncio` --- asynchronous I/O scheduler
+==============================================
+
+.. module:: uasyncio
+   :synopsis: asynchronous I/O scheduler for writing concurrent code
+
+|see_cpython_module|
+`asyncio <https://docs.python.org/3.8/library/asyncio.html>`_
+
+Example::
+
+    import uasyncio
+
+    async def blink(led, period_ms):
+        while True:
+            led.on()
+            await uasyncio.sleep_ms(5)
+            led.off()
+            await uasyncio.sleep_ms(period_ms)
+
+    async def main(led1, led2):
+        uasyncio.create_task(blink(led1, 700))
+        uasyncio.create_task(blink(led2, 400))
+        await uasyncio.sleep_ms(10_000)
+
+    # Running on a pyboard
+    from pyb import LED
+    uasyncio.run(main(LED(1), LED(2)))
+
+    # Running on a generic board
+    from machine import Pin
+    uasyncio.run(main(Pin(1), Pin(2)))
+
+Core functions
+--------------
+
+.. function:: create_task(coro)
+
+    Create a new task from the given coroutine and schedule it to run.
+
+    Returns the corresponding `Task` object.
+
+.. function:: run(coro)
+
+    Create a new task from the given coroutine and run it until it completes.
+
+    Returns the value returned by *coro*.
+
+.. function:: sleep(t)
+
+    Sleep for *t* seconds (can be a float).
+
+    This is a coroutine.
+
+.. function:: sleep_ms(t)
+
+    Sleep for *t* milliseconds.
+
+    This is a coroutine, and a MicroPython extension.
+
+Additional functions
+--------------------
+
+.. function:: wait_for(awaitable, timeout)
+
+    Wait for the *awaitable* to complete, but cancel it if it takes longer
+    that *timeout* seconds.  If *awaitable* is not a task then a task will be
+    created from it.
+
+    If a timeout occurs, it cancels the task and raises ``asyncio.TimeoutError``:
+    this should be trapped by the caller.
+
+    Returns the return value of *awaitable*.
+
+    This is a coroutine.
+
+.. function:: gather(\*awaitables, return_exceptions=False)
+
+    Run all *awaitables* concurrently.  Any *awaitables* that are not tasks are
+    promoted to tasks.
+
+    Returns a list of return values of all *awaitables*.
+
+    This is a coroutine.
+
+class Task
+----------
+
+.. class:: Task()
+
+    This object wraps a coroutine into a running task.  Tasks can be waited on
+    using ``await task``, which will wait for the task to complete and return
+    the return value of the task.
+
+    Tasks should not be created directly, rather use `create_task` to create them.
+
+.. method:: Task.cancel()
+
+    Cancel the task by injecting a ``CancelledError`` into it.  The task may
+    or may not ignore this exception.
+
+class Event
+-----------
+
+.. class:: Event()
+
+    Create a new event which can be used to synchronise tasks.  Events start
+    in the cleared state.
+
+.. method:: Event.is_set()
+
+    Returns ``True`` if the event is set, ``False`` otherwise.
+
+.. method:: Event.set()
+
+    Set the event.  Any tasks waiting on the event will be scheduled to run.
+
+.. method:: Event.clear()
+
+    Clear the event.
+
+.. method:: Event.wait()
+
+    Wait for the event to be set.  If the event is already set then it returns
+    immediately.
+
+    This is a coroutine.
+
+class Lock
+----------
+
+.. class:: Lock()
+
+    Create a new lock which can be used to coordinate tasks.  Locks start in
+    the unlocked state.
+
+    In addition to the methods below, locks can be used in an ``async with`` statement.
+
+.. method:: Lock.locked()
+
+    Returns ``True`` if the lock is locked, otherwise ``False``.
+
+.. method:: Lock.acquire()
+
+    Wait for the lock to be in the unlocked state and then lock it in an atomic
+    way.  Only one task can acquire the lock at any one time.
+
+    This is a coroutine.
+
+.. method:: Lock.release()
+
+    Release the lock.  If any tasks are waiting on the lock then the next one in the
+    queue is scheduled to run and the lock remains locked.  Otherwise, no tasks are
+    waiting an the lock becomes unlocked.
+
+TCP stream connections
+----------------------
+
+.. function:: open_connection(host, port)
+
+    Open a TCP connection to the given *host* and *port*.  The *host* address will be
+    resolved using `socket.getaddrinfo`, which is currently a blocking call.
+
+    Returns a pair of streams: a reader and a writer stream.
+    Will raise a socket-specific ``OSError`` if the host could not be resolved or if
+    the connection could not be made.
+
+    This is a coroutine.
+
+.. function:: start_server(callback, host, port, backlog=5)
+
+    Start a TCP server on the given *host* and *port*.  The *callback* will be
+    called with incoming, accepted connections, and be passed 2 arguments: reader
+    and writer streams for the connection.
+
+    Returns a `Server` object.
+
+    This is a coroutine.
+
+.. class:: Stream()
+    
+    This represents a TCP stream connection.  To minimise code this class implements
+    both a reader and a writer, and both ``StreamReader`` and ``StreamWriter`` alias to
+    this class.
+
+.. method:: Stream.get_extra_info(v)
+
+    Get extra information about the stream, given by *v*.  The valid values for *v* are:
+    ``peername``.
+
+.. method:: Stream.close()
+
+    Close the stream.
+
+.. method:: Stream.wait_closed()
+
+    Wait for the stream to close.
+
+    This is a coroutine.
+
+.. method:: Stream.read(n)
+
+    Read up to *n* bytes and return them.
+
+    This is a coroutine.
+
+.. method:: Stream.readline()
+
+    Read a line and return it.
+
+    This is a coroutine.
+
+.. method:: Stream.write(buf)
+
+    Accumulated *buf* to the output buffer.  The data is only flushed when
+    `Stream.drain` is called.  It is recommended to call `Stream.drain` immediately
+    after calling this function.
+
+.. method:: Stream.drain()
+
+    Drain (write) all buffered output data out to the stream.
+
+    This is a coroutine.
+
+.. class:: Server()
+
+    This represents the server class returned from `start_server`.  It can be used
+    in an ``async with`` statement to close the server upon exit.
+
+.. method:: Server.close()
+
+    Close the server.
+
+.. method:: Server.wait_closed()
+
+    Wait for the server to close.
+
+    This is a coroutine.
+
+Event Loop
+----------
+
+.. function:: get_event_loop()
+
+    Return the event loop used to schedule and run tasks.  See `Loop`.
+
+.. function:: new_event_loop()
+
+    Reset the event loop and return it.
+
+    Note: since MicroPython only has a single event loop this function just
+    resets the loop's state, it does not create a new one.
+
+.. class:: Loop()
+
+    This represents the object which schedules and runs tasks.  It cannot be
+    created, use `get_event_loop` instead.
+
+.. method:: Loop.create_task(coro)
+
+    Create a task from the given *coro* and return the new `Task` object.
+
+.. method:: Loop.run_forever()
+
+    Run the event loop until `stop()` is called.
+
+.. method:: Loop.run_until_complete(awaitable)
+
+    Run the given *awaitable* until it completes.  If *awaitable* is not a task
+    then it will be promoted to one.
+
+.. method:: Loop.stop()
+
+    Stop the event loop.
+
+.. method:: Loop.close()
+
+    Close the event loop.
+
+.. method:: Loop.set_exception_handler(handler)
+
+    Set the exception handler to call when a Task raises an exception that is not
+    caught.  The *handler* should accept two arguments: ``(loop, context)``.
+
+.. method:: Loop.get_exception_handler()
+
+    Get the current exception handler.  Returns the handler, or ``None`` if no
+    custom handler is set.
+
+.. method:: Loop.default_exception_handler(context)
+
+    The default exception handler that is called.
+
+.. method:: Loop.call_exception_handler(context)
+
+    Call the current exception handler.  The argument *context* is passed through and
+    is a dictionary containing keys: ``'message'``, ``'exception'``, ``'future'``.
diff --git a/docs/library/ubluetooth.rst b/docs/library/ubluetooth.rst
new file mode 100644
index 0000000000000..fd2efe87d913f
--- /dev/null
+++ b/docs/library/ubluetooth.rst
@@ -0,0 +1,385 @@
+:mod:`ubluetooth` --- low-level Bluetooth
+=========================================
+
+.. module:: ubluetooth
+   :synopsis: Low-level Bluetooth radio functionality
+
+This module provides an interface to a Bluetooth controller on a board.
+Currently this supports Bluetooth Low Energy (BLE) in Central, Peripheral,
+Broadcaster, and Observer roles, and a device may operate in multiple
+roles concurrently.
+
+This API is intended to match the low-level Bluetooth protocol and provide
+building-blocks for higher-level abstractions such as specific device types.
+
+.. note:: This module is still under development and its classes, functions,
+          methods and constants are subject to change.
+
+class BLE
+---------
+
+Constructor
+-----------
+
+.. class:: BLE()
+
+    Returns the singleton BLE object.
+
+Configuration
+-------------
+
+.. method:: BLE.active([active])
+
+    Optionally changes the active state of the BLE radio, and returns the
+    current state.
+
+    The radio must be made active before using any other methods on this class.
+
+.. method:: BLE.config('param')
+            BLE.config(param=value, ...)
+
+    Get or set configuration values of the BLE interface.  To get a value the
+    parameter name should be quoted as a string, and just one parameter is
+    queried at a time.  To set values use the keyword syntax, and one ore more
+    parameter can be set at a time.
+
+    Currently supported values are:
+
+    - ``'mac'``: Returns the device MAC address. If a device has a fixed address
+      (e.g. PYBD) then it will be returned. Otherwise (e.g. ESP32) a random
+      address will be generated when the BLE interface is made active.
+      Note: on some ports, accessing this value requires that the interface is
+      active (so that the MAC address can be queried from the controller).
+
+    - ``'gap_name'``: Get/set the GAP device name used by service 0x1800,
+      characteristic 0x2a00.  This can be set at any time and changed multiple
+      times.
+
+    - ``'rxbuf'``: Get/set the size in bytes of the internal buffer used to store
+      incoming events.  This buffer is global to the entire BLE driver and so
+      handles incoming data for all events, including all characteristics.
+      Increasing this allows better handling of bursty incoming data (for
+      example scan results) and the ability for a central role to receive
+      larger characteristic values.
+
+Event Handling
+--------------
+
+.. method:: BLE.irq(handler, trigger=0xffff)
+
+    Registers a callback for events from the BLE stack. The *handler* takes two
+    arguments, ``event`` (which will be one of the codes below) and ``data``
+    (which is an event-specific tuple of values).
+
+    The optional *trigger* parameter allows you to set a mask of events that
+    your program is interested in. The default is all events.
+
+    Note: the ``addr``, ``adv_data``, ``char_data``, ``notify_data``, and
+    ``uuid`` entries in the tuples are
+    references to data managed by the :mod:`ubluetooth` module (i.e. the same
+    instance will be re-used across multiple calls to the event handler). If
+    your program wants to use this data outside of the handler, then it must
+    copy them first, e.g. by using ``bytes(addr)`` or ``bluetooth.UUID(uuid)``.
+
+    An event handler showing all possible events::
+
+        def bt_irq(event, data):
+            if event == _IRQ_CENTRAL_CONNECT:
+                # A central has connected to this peripheral.
+                conn_handle, addr_type, addr = data
+            elif event == _IRQ_CENTRAL_DISCONNECT:
+                # A central has disconnected from this peripheral.
+                conn_handle, addr_type, addr = data
+            elif event == _IRQ_GATTS_WRITE:
+                # A central has written to this characteristic or descriptor.
+                conn_handle, attr_handle = data
+            elif event == _IRQ_GATTS_READ_REQUEST:
+                # A central has issued a read. Note: this is a hard IRQ.
+                # Return None to deny the read.
+                # Note: This event is not supported on ESP32.
+                conn_handle, attr_handle = data
+            elif event == _IRQ_SCAN_RESULT:
+                # A single scan result.
+                addr_type, addr, adv_type, rssi, adv_data = data
+            elif event == _IRQ_SCAN_COMPLETE:
+                # Scan duration finished or manually stopped.
+                pass
+            elif event == _IRQ_PERIPHERAL_CONNECT:
+                # A successful gap_connect().
+                conn_handle, addr_type, addr = data
+            elif event == _IRQ_PERIPHERAL_DISCONNECT:
+                # Connected peripheral has disconnected.
+                conn_handle, addr_type, addr = data
+            elif event == _IRQ_GATTC_SERVICE_RESULT:
+                # Called for each service found by gattc_discover_services().
+                conn_handle, start_handle, end_handle, uuid = data
+            elif event == _IRQ_GATTC_CHARACTERISTIC_RESULT:
+                # Called for each characteristic found by gattc_discover_services().
+                conn_handle, def_handle, value_handle, properties, uuid = data
+            elif event == _IRQ_GATTC_DESCRIPTOR_RESULT:
+                # Called for each descriptor found by gattc_discover_descriptors().
+                conn_handle, dsc_handle, uuid = data
+            elif event == _IRQ_GATTC_READ_RESULT:
+                # A gattc_read() has completed.
+                conn_handle, value_handle, char_data = data
+            elif event == _IRQ_GATTC_WRITE_STATUS:
+                # A gattc_write() has completed.
+                conn_handle, value_handle, status = data
+            elif event == _IRQ_GATTC_NOTIFY:
+                # A peripheral has sent a notify request.
+                conn_handle, value_handle, notify_data = data
+            elif event == _IRQ_GATTC_INDICATE:
+                # A peripheral has sent an indicate request.
+                conn_handle, value_handle, notify_data = data
+
+The event codes are::
+
+    from micropython import const
+    _IRQ_CENTRAL_CONNECT                 = const(1 << 0)
+    _IRQ_CENTRAL_DISCONNECT              = const(1 << 1)
+    _IRQ_GATTS_WRITE                     = const(1 << 2)
+    _IRQ_GATTS_READ_REQUEST              = const(1 << 3)
+    _IRQ_SCAN_RESULT                     = const(1 << 4)
+    _IRQ_SCAN_COMPLETE                   = const(1 << 5)
+    _IRQ_PERIPHERAL_CONNECT              = const(1 << 6)
+    _IRQ_PERIPHERAL_DISCONNECT           = const(1 << 7)
+    _IRQ_GATTC_SERVICE_RESULT            = const(1 << 8)
+    _IRQ_GATTC_CHARACTERISTIC_RESULT     = const(1 << 9)
+    _IRQ_GATTC_DESCRIPTOR_RESULT         = const(1 << 10)
+    _IRQ_GATTC_READ_RESULT               = const(1 << 11)
+    _IRQ_GATTC_WRITE_STATUS              = const(1 << 12)
+    _IRQ_GATTC_NOTIFY                    = const(1 << 13)
+    _IRQ_GATTC_INDICATE                  = const(1 << 14)
+
+In order to save space in the firmware, these constants are not included on the
+:mod:`ubluetooth` module. Add the ones that you need from the list above to your
+program.
+
+
+Broadcaster Role (Advertiser)
+-----------------------------
+
+.. method:: BLE.gap_advertise(interval_us, adv_data=None, resp_data=None, connectable=True)
+
+    Starts advertising at the specified interval (in **micro**\ seconds). This
+    interval will be rounded down to the nearest 625us. To stop advertising, set
+    *interval_us* to ``None``.
+
+    *adv_data* and *resp_data* can be any type that implements the buffer
+    protocol (e.g. ``bytes``, ``bytearray``, ``str``). *adv_data* is included
+    in all broadcasts, and *resp_data* is send in reply to an active scan.
+
+    Note: if *adv_data* (or *resp_data*) is ``None``, then the data passed
+    to the previous call to ``gap_advertise`` will be re-used. This allows a
+    broadcaster to resume advertising with just ``gap_advertise(interval_us)``.
+    To clear the advertising payload pass an empty ``bytes``, i.e. ``b''``.
+
+
+Observer Role (Scanner)
+-----------------------
+
+.. method:: BLE.gap_scan(duration_ms, [interval_us], [window_us])
+
+    Run a scan operation lasting for the specified duration (in **milli**\ seconds).
+
+    To scan indefinitely, set *duration_ms* to ``0``.
+
+    To stop scanning, set *duration_ms* to ``None``.
+
+    Use *interval_us* and *window_us* to optionally configure the duty cycle.
+    The scanner will run for *window_us* **micro**\ seconds every *interval_us*
+    **micro**\ seconds for a total of *duration_ms* **milli**\ seconds. The default
+    interval and window are 1.28 seconds and 11.25 milliseconds respectively
+    (background scanning).
+
+    For each scan result the ``_IRQ_SCAN_RESULT`` event will be raised, with event
+    data ``(addr_type, addr, adv_type, rssi, adv_data)``.  ``adv_type`` values correspond
+    to the Bluetooth Specification:
+
+        * 0x00 - ADV_IND - connectable and scannable undirected advertising
+        * 0x01 - ADV_DIRECT_IND - connectable directed advertising
+        * 0x02 - ADV_SCAN_IND - scannable undirected advertising
+        * 0x03 - ADV_NONCONN_IND - non-connectable undirected advertising
+        * 0x04 - SCAN_RSP - scan response
+
+    When scanning is stopped (either due to the duration finishing or when
+    explicitly stopped), the ``_IRQ_SCAN_COMPLETE`` event will be raised.
+
+
+Peripheral Role (GATT Server)
+-----------------------------
+
+A BLE peripheral has a set of registered services. Each service may contain
+characteristics, which each have a value. Characteristics can also contain
+descriptors, which themselves have values.
+
+These values are stored locally, and are accessed by their "value handle" which
+is generated during service registration. They can also be read from or written
+to by a remote central device. Additionally, a peripheral can "notify" a
+characteristic to a connected central via a connection handle.
+
+Characteristics and descriptors have a default maximum size of 20 bytes.
+Anything written to them by a central will be truncated to this length. However,
+any local write will increase the maximum size, so if you want to allow larger
+writes from a central to a given characteristic, use
+:meth:`gatts_write<BLE.gatts_write>` after registration. e.g.
+``gatts_write(char_handle, bytes(100))``.
+
+.. method:: BLE.gatts_register_services(services_definition)
+
+    Configures the peripheral with the specified services, replacing any
+    existing services.
+
+    *services_definition* is a list of **services**, where each **service** is a
+    two-element tuple containing a UUID and a list of **characteristics**.
+
+    Each **characteristic** is a two-or-three-element tuple containing a UUID, a
+    **flags** value, and optionally a list of *descriptors*.
+
+    Each **descriptor** is a two-element tuple containing a UUID and a **flags**
+    value.
+
+    The **flags** are a bitwise-OR combination of the
+    :data:`ubluetooth.FLAG_READ`, :data:`ubluetooth.FLAG_WRITE` and
+    :data:`ubluetooth.FLAG_NOTIFY` values defined below.
+
+    The return value is a list (one element per service) of tuples (each element
+    is a value handle). Characteristics and descriptor handles are flattened
+    into the same tuple, in the order that they are defined.
+
+    The following example registers two services (Heart Rate, and Nordic UART)::
+
+        HR_UUID = bluetooth.UUID(0x180D)
+        HR_CHAR = (bluetooth.UUID(0x2A37), bluetooth.FLAG_READ | bluetooth.FLAG_NOTIFY,)
+        HR_SERVICE = (HR_UUID, (HR_CHAR,),)
+        UART_UUID = bluetooth.UUID('6E400001-B5A3-F393-E0A9-E50E24DCCA9E')
+        UART_TX = (bluetooth.UUID('6E400003-B5A3-F393-E0A9-E50E24DCCA9E'), bluetooth.FLAG_READ | bluetooth.FLAG_NOTIFY,)
+        UART_RX = (bluetooth.UUID('6E400002-B5A3-F393-E0A9-E50E24DCCA9E'), bluetooth.FLAG_WRITE,)
+        UART_SERVICE = (UART_UUID, (UART_TX, UART_RX,),)
+        SERVICES = (HR_SERVICE, UART_SERVICE,)
+        ( (hr,), (tx, rx,), ) = bt.gatts_register_services(SERVICES)
+
+    The three value handles (``hr``, ``tx``, ``rx``) can be used with
+    :meth:`gatts_read <BLE.gatts_read>`, :meth:`gatts_write <BLE.gatts_write>`,
+    and :meth:`gatts_notify <BLE.gatts_notify>`.
+
+    **Note:** Advertising must be stopped before registering services.
+
+.. method:: BLE.gatts_read(value_handle)
+
+    Reads the local value for this handle (which has either been written by
+    :meth:`gatts_write <BLE.gatts_write>` or by a remote central).
+
+.. method:: BLE.gatts_write(value_handle, data)
+
+    Writes the local value for this handle, which can be read by a central.
+
+.. method:: BLE.gatts_notify(conn_handle, value_handle, [data])
+
+    Notifies a connected central that this value has changed and that it should
+    issue a read of the current value from this peripheral.
+
+    If *data* is specified, then the that value is sent to the central as part
+    of the notification, avoiding the need for a separate read request. Note
+    that this will not update the local value stored.
+
+.. method:: BLE.gatts_set_buffer(value_handle, len, append=False, /)
+
+    Sets the internal buffer size for a value in bytes. This will limit the
+    largest possible write that can be received. The default is 20.
+
+    Setting *append* to ``True`` will make all remote writes append to, rather
+    than replace, the current value. At most *len* bytes can be buffered in
+    this way. When you use :meth:`gatts_read <BLE.gatts_read>`, the value will
+    be cleared after reading. This feature is useful when implementing something
+    like the Nordic UART Service.
+
+
+Central Role (GATT Client)
+--------------------------
+
+.. method:: BLE.gap_connect(addr_type, addr, scan_duration_ms=2000, /)
+
+    Connect to a peripheral.
+
+    On success, the ``_IRQ_PERIPHERAL_CONNECT`` event will be raised.
+
+.. method:: BLE.gap_disconnect(conn_handle)
+
+    Disconnect the specified connection handle.
+
+    On success, the ``_IRQ_PERIPHERAL_DISCONNECT`` event will be raised.
+
+    Returns ``False`` if the connection handle wasn't connected, and ``True``
+    otherwise.
+
+.. method:: BLE.gattc_discover_services(conn_handle)
+
+    Query a connected peripheral for its services.
+
+    For each service discovered, the ``_IRQ_GATTC_SERVICE_RESULT`` event will be
+    raised.
+
+.. method:: BLE.gattc_discover_characteristics(conn_handle, start_handle, end_handle)
+
+    Query a connected peripheral for characteristics in the specified range.
+
+    For each characteristic discovered, the ``_IRQ_GATTC_CHARACTERISTIC_RESULT``
+    event will be raised.
+
+.. method:: BLE.gattc_discover_descriptors(conn_handle, start_handle, end_handle)
+
+    Query a connected peripheral for descriptors in the specified range.
+
+    For each descriptor discovered, the ``_IRQ_GATTC_DESCRIPTOR_RESULT`` event
+    will be raised.
+
+.. method:: BLE.gattc_read(conn_handle, value_handle)
+
+    Issue a remote read to a connected peripheral for the specified
+    characteristic or descriptor handle.
+
+    On success, the ``_IRQ_GATTC_READ_RESULT`` event will be raised.
+
+.. method:: BLE.gattc_write(conn_handle, value_handle, data, mode=0, /)
+
+    Issue a remote write to a connected peripheral for the specified
+    characteristic or descriptor handle.
+
+    The argument *mode* specifies the write behaviour, with the currently
+    supported values being:
+
+        * ``mode=0`` (default) is a write-without-response: the write will
+          be sent to the remote peripheral but no confirmation will be
+          returned, and no event will be raised.
+        * ``mode=1`` is a write-with-response: the remote peripheral is
+          requested to send a response/acknowledgement that it received the
+          data.
+
+    If a response is received from the remote peripheral the
+    ``_IRQ_GATTC_WRITE_STATUS`` event will be raised.
+
+
+class UUID
+----------
+
+
+Constructor
+-----------
+
+.. class:: UUID(value)
+
+    Creates a UUID instance with the specified **value**.
+
+    The **value** can be either:
+
+    - A 16-bit integer. e.g. ``0x2908``.
+    - A 128-bit UUID string. e.g. ``'6E400001-B5A3-F393-E0A9-E50E24DCCA9E'``.
+
+
+Constants
+---------
+
+.. data:: ubluetooth.FLAG_READ
+          ubluetooth.FLAG_WRITE
+          ubluetooth.FLAG_NOTIFY
diff --git a/docs/library/ucryptolib.rst b/docs/library/ucryptolib.rst
index c9e0bb71f7ae0..79471c2e90ccc 100644
--- a/docs/library/ucryptolib.rst
+++ b/docs/library/ucryptolib.rst
@@ -22,9 +22,11 @@ Classes
             * *mode* is:
 
                 * ``1`` (or ``ucryptolib.MODE_ECB`` if it exists) for Electronic Code Book (ECB).
-                * ``2`` (or ``ucryptolib.MODE_CBC`` if it exists) for Cipher Block Chaining (CBC)
+                * ``2`` (or ``ucryptolib.MODE_CBC`` if it exists) for Cipher Block Chaining (CBC).
+                * ``6`` (or ``ucryptolib.MODE_CTR`` if it exists) for Counter mode (CTR).
 
             * *IV* is an initialization vector for CBC mode.
+            * For Counter mode, *IV* is the initial value for the counter.
 
     .. method:: encrypt(in_buf, [out_buf])
 
diff --git a/docs/library/uctypes.rst b/docs/library/uctypes.rst
index dce8caecb6e09..0fdc40e4840b4 100644
--- a/docs/library/uctypes.rst
+++ b/docs/library/uctypes.rst
@@ -180,7 +180,7 @@ Following are encoding examples for various field types:
 Module contents
 ---------------
 
-.. class:: struct(addr, descriptor, layout_type=NATIVE)
+.. class:: struct(addr, descriptor, layout_type=NATIVE, /)
 
    Instantiate a "foreign data structure" object based on structure address in
    memory, descriptor (encoded as a dictionary), and layout type (see below).
@@ -200,7 +200,7 @@ Module contents
    Layout type for a native structure - with data endianness and alignment
    conforming to the ABI of the system on which MicroPython runs.
 
-.. function:: sizeof(struct, layout_type=NATIVE)
+.. function:: sizeof(struct, layout_type=NATIVE, /)
 
    Return size of data structure in bytes. The *struct* argument can be
    either a structure class or a specific instantiated structure object
diff --git a/docs/library/uhashlib.rst b/docs/library/uhashlib.rst
index 50ed658cc1039..e1eddd2b7131f 100644
--- a/docs/library/uhashlib.rst
+++ b/docs/library/uhashlib.rst
@@ -18,10 +18,10 @@ be implemented:
 * SHA1 - A previous generation algorithm. Not recommended for new usages,
   but SHA1 is a part of number of Internet standards and existing
   applications, so boards targeting network connectivity and
-  interoperatiability will try to provide this.
+  interoperability will try to provide this.
 
 * MD5 - A legacy algorithm, not considered cryptographically secure. Only
-  selected boards, targeting interoperatibility with legacy applications,
+  selected boards, targeting interoperability with legacy applications,
   will offer this.
 
 Constructors
diff --git a/docs/library/uos.rst b/docs/library/uos.rst
index c7460134b1339..c49b13a5f5bca 100644
--- a/docs/library/uos.rst
+++ b/docs/library/uos.rst
@@ -94,10 +94,10 @@ Filesystem access
         * ``f_frsize`` -- fragment size
         * ``f_blocks`` -- size of fs in f_frsize units
         * ``f_bfree`` -- number of free blocks
-        * ``f_bavail`` -- number of free blocks for unpriviliged users
+        * ``f_bavail`` -- number of free blocks for unprivileged users
         * ``f_files`` -- number of inodes
         * ``f_ffree`` -- number of free inodes
-        * ``f_favail`` -- number of free inodes for unpriviliged users
+        * ``f_favail`` -- number of free inodes for unprivileged users
         * ``f_flag`` -- mount flags
         * ``f_namemax`` -- maximum filename length
 
@@ -112,7 +112,7 @@ Filesystem access
 Terminal redirection and duplication
 ------------------------------------
 
-.. function:: dupterm(stream_object, index=0)
+.. function:: dupterm(stream_object, index=0, /)
 
    Duplicate or switch the MicroPython terminal (the REPL) on the given `stream`-like
    object. The *stream_object* argument must be a native stream object, or derive
@@ -178,14 +178,73 @@ represented by VFS classes.
 
         Build a FAT filesystem on *block_dev*.
 
+.. class:: VfsLfs1(block_dev)
+
+    Create a filesystem object that uses the `littlefs v1 filesystem format`_.
+    Storage of the littlefs filesystem is provided by *block_dev*, which must
+    support the :ref:`extended interface <block-device-interface>`.
+    Objects created by this constructor can be mounted using :func:`mount`.
+
+    See :ref:`filesystem` for more information.
+
+    .. staticmethod:: mkfs(block_dev)
+
+        Build a Lfs1 filesystem on *block_dev*.
+
+    .. note:: There are reports of littlefs v1 failing in certain situations,
+              for details see `littlefs issue 347`_.
+
+.. class:: VfsLfs2(block_dev)
+
+    Create a filesystem object that uses the `littlefs v2 filesystem format`_.
+    Storage of the littlefs filesystem is provided by *block_dev*, which must
+    support the :ref:`extended interface <block-device-interface>`.
+    Objects created by this constructor can be mounted using :func:`mount`.
+
+    See :ref:`filesystem` for more information.
+
+    .. staticmethod:: mkfs(block_dev)
+
+        Build a Lfs2 filesystem on *block_dev*.
+
+    .. note:: There are reports of littlefs v2 failing in certain situations,
+              for details see `littlefs issue 295`_.
+
+.. _littlefs v1 filesystem format: https://github.com/ARMmbed/littlefs/tree/v1
+.. _littlefs v2 filesystem format: https://github.com/ARMmbed/littlefs
+.. _littlefs issue 295: https://github.com/ARMmbed/littlefs/issues/295
+.. _littlefs issue 347: https://github.com/ARMmbed/littlefs/issues/347
+
 Block devices
 -------------
 
-A block device is an object which implements the block protocol, which is a set
-of methods described below by the :class:`AbstractBlockDev` class.  A concrete
-implementation of this class will usually allow access to the memory-like
-functionality a piece of hardware (like flash memory).  A block device can be
-used by a particular filesystem driver to store the data for its filesystem.
+A block device is an object which implements the block protocol. This enables a
+device to support MicroPython filesystems. The physical hardware is represented
+by a user defined class. The :class:`AbstractBlockDev` class is a template for
+the design of such a class: MicroPython does not actually provide that class,
+but an actual block device class must implement the methods described below.
+
+A concrete implementation of this class will usually allow access to the
+memory-like functionality of a piece of hardware (like flash memory). A block
+device can be formatted to any supported filesystem and mounted using ``uos``
+methods.
+
+See :ref:`filesystem` for example implementations of block devices using the
+two variants of the block protocol described below.
+
+.. _block-device-interface:
+
+Simple and extended interface
+.............................
+
+There are two compatible signatures for the ``readblocks`` and ``writeblocks``
+methods (see below), in order to support a variety of use cases.  A given block
+device may implement one form or the other, or both at the same time. The second
+form (with the offset parameter) is referred to as the "extended interface".
+
+Some filesystems (such as littlefs) that require more control over write
+operations, for example writing to sub-block regions without erasing, may require
+that the block device supports the extended interface.
 
 .. class:: AbstractBlockDev(...)
 
@@ -193,19 +252,41 @@ used by a particular filesystem driver to store the data for its filesystem.
     dependent on the specific block device.
 
     .. method:: readblocks(block_num, buf)
+    .. method:: readblocks(block_num, buf, offset)
 
+        The first form reads aligned, multiples of blocks.
         Starting at the block given by the index *block_num*, read blocks from
         the device into *buf* (an array of bytes).
         The number of blocks to read is given by the length of *buf*,
         which will be a multiple of the block size.
 
+        The second form allows reading at arbitrary locations within a block,
+        and arbitrary lengths.
+        Starting at block index *block_num*, and byte offset within that block
+        of *offset*, read bytes from the device into *buf* (an array of bytes).
+        The number of bytes to read is given by the length of *buf*.
+
     .. method:: writeblocks(block_num, buf)
+    .. method:: writeblocks(block_num, buf, offset)
 
+        The first form writes aligned, multiples of blocks, and requires that the
+        blocks that are written to be first erased (if necessary) by this method.
         Starting at the block given by the index *block_num*, write blocks from
         *buf* (an array of bytes) to the device.
         The number of blocks to write is given by the length of *buf*,
         which will be a multiple of the block size.
 
+        The second form allows writing at arbitrary locations within a block,
+        and arbitrary lengths.  Only the bytes being written should be changed,
+        and the caller of this method must ensure that the relevant blocks are
+        erased via a prior ``ioctl`` call.
+        Starting at block index *block_num*, and byte offset within that block
+        of *offset*, write bytes from *buf* (an array of bytes) to the device.
+        The number of bytes to write is given by the length of *buf*.
+
+        Note that implementations must never implicitly erase blocks if the offset
+        argument is specified, even if it is zero.
+
     .. method:: ioctl(op, arg)
 
         Control the block device and query its parameters.  The operation to
@@ -219,34 +300,14 @@ used by a particular filesystem driver to store the data for its filesystem.
           - 5 -- get the number of bytes in a block, should return an integer,
             or ``None`` in which case the default value of 512 is used
             (*arg* is unused)
+          - 6 -- erase a block, *arg* is the block number to erase
 
-By way of example, the following class will implement a block device that stores
-its data in RAM using a ``bytearray``::
-
-    class RAMBlockDev:
-        def __init__(self, block_size, num_blocks):
-            self.block_size = block_size
-            self.data = bytearray(block_size * num_blocks)
-
-        def readblocks(self, block_num, buf):
-            for i in range(len(buf)):
-                buf[i] = self.data[block_num * self.block_size + i]
-
-        def writeblocks(self, block_num, buf):
-            for i in range(len(buf)):
-                self.data[block_num * self.block_size + i] = buf[i]
-
-        def ioctl(self, op, arg):
-            if op == 4: # get number of blocks
-                return len(self.data) // self.block_size
-            if op == 5: # get block size
-                return self.block_size
-
-It can be used as follows::
-
-    import uos
+       As a minimum ``ioctl(4, ...)`` must be intercepted; for littlefs
+       ``ioctl(6, ...)`` must also be intercepted. The need for others is
+       hardware dependent.
 
-    bdev = RAMBlockDev(512, 50)
-    uos.VfsFat.mkfs(bdev)
-    vfs = uos.VfsFat(bdev)
-    uos.mount(vfs, '/ramdisk')
+       Unless otherwise stated ``ioctl(op, arg)`` can return ``None``.
+       Consequently an implementation can ignore unused values of ``op``. Where
+       ``op`` is intercepted, the return value for operations 4 and 5 are as
+       detailed above. Other operations should return 0 on success and non-zero
+       for failure, with the value returned being an ``OSError`` errno code.
diff --git a/docs/library/ure.rst b/docs/library/ure.rst
index ac5f02f9e81a0..ca5f35b70302c 100644
--- a/docs/library/ure.rst
+++ b/docs/library/ure.rst
@@ -124,7 +124,7 @@ Functions
    string for first position which matches regex (which still may be
    0 if regex is anchored).
 
-.. function:: sub(regex_str, replace, string, count=0, flags=0)
+.. function:: sub(regex_str, replace, string, count=0, flags=0, /)
 
    Compile *regex_str* and search for it in *string*, replacing all matches
    with *replace*, and returning the new string.
@@ -156,14 +156,14 @@ Compiled regular expression. Instances of this class are created using
 
 .. method:: regex.match(string)
             regex.search(string)
-            regex.sub(replace, string, count=0, flags=0)
+            regex.sub(replace, string, count=0, flags=0, /)
 
    Similar to the module-level functions :meth:`match`, :meth:`search`
    and :meth:`sub`.
    Using methods is (much) more efficient if the same regex is applied to
    multiple strings.
 
-.. method:: regex.split(string, max_split=-1)
+.. method:: regex.split(string, max_split=-1, /)
 
    Split a *string* using regex. If *max_split* is given, it specifies
    maximum number of splits to perform. Returns list of strings (there
diff --git a/docs/library/uselect.rst b/docs/library/uselect.rst
index e1becc60ea410..0c3bdfdfd9360 100644
--- a/docs/library/uselect.rst
+++ b/docs/library/uselect.rst
@@ -58,7 +58,7 @@ Methods
    Modify the *eventmask* for *obj*. If *obj* is not registered, `OSError`
    is raised with error of ENOENT.
 
-.. method:: poll.poll(timeout=-1)
+.. method:: poll.poll(timeout=-1, /)
 
    Wait for at least one of the registered objects to become ready or have an
    exceptional condition, with optional timeout in milliseconds (if *timeout*
@@ -81,7 +81,7 @@ Methods
 
       Tuples returned may contain more than 2 elements as described above.
 
-.. method:: poll.ipoll(timeout=-1, flags=0)
+.. method:: poll.ipoll(timeout=-1, flags=0, /)
 
    Like :meth:`poll.poll`, but instead returns an iterator which yields a
    `callee-owned tuple`. This function provides an efficient, allocation-free
diff --git a/docs/library/usocket.rst b/docs/library/usocket.rst
index 461e37b353920..e3b9d279a051e 100644
--- a/docs/library/usocket.rst
+++ b/docs/library/usocket.rst
@@ -66,7 +66,7 @@ Tuple address format for ``socket`` module:
 Functions
 ---------
 
-.. function:: socket(af=AF_INET, type=SOCK_STREAM, proto=IPPROTO_TCP)
+.. function:: socket(af=AF_INET, type=SOCK_STREAM, proto=IPPROTO_TCP, /)
 
    Create a new socket using the given address family, socket type and
    protocol number. Note that specifying *proto* in most cases is not
@@ -79,7 +79,7 @@ Functions
         # Create DGRAM UDP socket
         socket(AF_INET, SOCK_DGRAM)
 
-.. function:: getaddrinfo(host, port, af=0, type=0, proto=0, flags=0)
+.. function:: getaddrinfo(host, port, af=0, type=0, proto=0, flags=0, /)
 
    Translate the host/port argument into a sequence of 5-tuples that contain all the 
    necessary arguments for creating a socket connected to that service. Arguments
@@ -293,7 +293,7 @@ Methods
    * ``sock.setblocking(True)`` is equivalent to ``sock.settimeout(None)``
    * ``sock.setblocking(False)`` is equivalent to ``sock.settimeout(0)``
 
-.. method:: socket.makefile(mode='rb', buffering=0)
+.. method:: socket.makefile(mode='rb', buffering=0, /)
 
    Return a file object associated with the socket. The exact returned type depends on the arguments
    given to makefile(). The support is limited to binary modes only ('rb', 'wb', and 'rwb').
diff --git a/docs/library/ustruct.rst b/docs/library/ustruct.rst
index 81915d0a8d01c..357d622b2b88a 100644
--- a/docs/library/ustruct.rst
+++ b/docs/library/ustruct.rst
@@ -35,7 +35,7 @@ Functions
    Unpack from the *data* according to the format string *fmt*.
    The return value is a tuple of the unpacked values.
 
-.. function:: unpack_from(fmt, data, offset=0)
+.. function:: unpack_from(fmt, data, offset=0, /)
 
    Unpack from the *data* starting at *offset* according to the format string
    *fmt*. *offset* may be negative to count from the end of *buffer*. The return
diff --git a/docs/library/uzlib.rst b/docs/library/uzlib.rst
index 0b399f228ac4f..d40c46145ace9 100644
--- a/docs/library/uzlib.rst
+++ b/docs/library/uzlib.rst
@@ -14,7 +14,7 @@ is not yet implemented.
 Functions
 ---------
 
-.. function:: decompress(data, wbits=0, bufsize=0)
+.. function:: decompress(data, wbits=0, bufsize=0, /)
 
    Return decompressed *data* as bytes. *wbits* is DEFLATE dictionary window
    size used during compression (8-15, the dictionary size is power of 2 of
@@ -23,7 +23,7 @@ Functions
    to be raw DEFLATE stream. *bufsize* parameter is for compatibility with
    CPython and is ignored.
 
-.. class:: DecompIO(stream, wbits=0)
+.. class:: DecompIO(stream, wbits=0, /)
 
    Create a `stream` wrapper which allows transparent decompression of
    compressed data in another *stream*. This allows to process compressed
diff --git a/docs/pyboard/quickref.rst b/docs/pyboard/quickref.rst
index 5d4985f5879db..3dbd0930436f4 100644
--- a/docs/pyboard/quickref.rst
+++ b/docs/pyboard/quickref.rst
@@ -66,7 +66,7 @@ See :ref:`pyb.LED <pyb.LED>`. ::
     led.toggle()
     led.on()
     led.off()
-    
+
     # LEDs 3 and 4 support PWM intensity (0-255)
     LED(4).intensity()    # get intensity
     LED(4).intensity(128) # set intensity to half
@@ -199,16 +199,25 @@ See :ref:`pyb.SPI <pyb.SPI>`. ::
 I2C bus
 -------
 
-See :ref:`pyb.I2C <pyb.I2C>`. ::
+Hardware I2C is available on the X and Y halves of the pyboard via ``I2C('X')``
+and ``I2C('Y')``.  Alternatively pass in the integer identifier of the peripheral,
+eg ``I2C(1)``.  Software I2C is also available by explicitly specifying the
+``scl`` and ``sda`` pins instead of the bus name.  For more details see
+:ref:`machine.I2C <machine.I2C>`. ::
+
+    from machine import I2C
+
+    i2c = I2C('X', freq=400000)                 # create hardware I2c object
+    i2c = I2C(scl='X1', sda='X2', freq=100000)  # create software I2C object
+
+    i2c.scan()                          # returns list of slave addresses
+    i2c.writeto(0x42, 'hello')          # write 5 bytes to slave with address 0x42
+    i2c.readfrom(0x42, 5)               # read 5 bytes from slave
 
-    from pyb import I2C
+    i2c.readfrom_mem(0x42, 0x10, 2)     # read 2 bytes from slave 0x42, slave memory 0x10
+    i2c.writeto_mem(0x42, 0x10, 'xy')   # write 2 bytes to slave 0x42, slave memory 0x10
 
-    i2c = I2C(1, I2C.MASTER, baudrate=100000)
-    i2c.scan() # returns list of slave addresses
-    i2c.send('hello', 0x42) # send 5 bytes to slave with address 0x42
-    i2c.recv(5, 0x42) # receive 5 bytes from slave
-    i2c.mem_read(2, 0x42, 0x10) # read 2 bytes from slave 0x42, slave memory 0x10
-    i2c.mem_write('xy', 0x42, 0x10) # write 2 bytes to slave 0x42, slave memory 0x10
+Note: for legacy I2C support see :ref:`pyb.I2C <pyb.I2C>`.
 
 CAN bus (controller area network)
 ---------------------------------
diff --git a/docs/pyboard/tutorial/amp_skin.rst b/docs/pyboard/tutorial/amp_skin.rst
index 697637f9d2b31..bcb583261381c 100644
--- a/docs/pyboard/tutorial/amp_skin.rst
+++ b/docs/pyboard/tutorial/amp_skin.rst
@@ -60,7 +60,7 @@ on your pyboard (either on the flash or the SD card in the top-level directory).
 or to convert any file you have with the command::
 
     avconv -i original.wav -ar 22050 -codec pcm_u8 test.wav
-    
+
 Then you can do::
 
     >>> import wave
diff --git a/docs/pyboard/tutorial/fading_led.rst b/docs/pyboard/tutorial/fading_led.rst
index 8303c96030ddf..79648bee1ad41 100644
--- a/docs/pyboard/tutorial/fading_led.rst
+++ b/docs/pyboard/tutorial/fading_led.rst
@@ -27,10 +27,10 @@ For this tutorial, we will use the ``X1`` pin. Connect one end of the resistor t
 Code
 ----
 By examining the :ref:`pyboard_quickref`, we see that ``X1`` is connected to channel 1 of timer 5 (``TIM5 CH1``). Therefore we will first create a ``Timer`` object for timer 5, then create a ``TimerChannel`` object for channel 1::
-    
+
     from pyb import Timer
     from time import sleep
-    
+
     # timer 5 will be created with a frequency of 100 Hz
     tim = pyb.Timer(5, freq=100)
     tchannel = tim.channel(1, Timer.PWM, pin=pyb.Pin.board.X1, pulse_width=0)
@@ -47,16 +47,16 @@ To achieve the fading effect shown at the beginning of this tutorial, we want to
     # how much to change the pulse-width by each step
     wstep = 1500
     cur_width = min_width
-    
+
     while True:
       tchannel.pulse_width(cur_width)
-      
+
       # this determines how often we change the pulse-width. It is
       # analogous to frames-per-second
       sleep(0.01)
-    
+
       cur_width += wstep
-    
+
       if cur_width > max_width:
         cur_width = min_width
 
@@ -67,11 +67,11 @@ If we want to have a breathing effect, where the LED fades from dim to bright th
 
     while True:
       tchannel.pulse_width(cur_width)
-    
+
       sleep(0.01)
-    
+
       cur_width += wstep
-    
+
       if cur_width > max_width:
         cur_width = max_width
         wstep *= -1
diff --git a/docs/pyboard/tutorial/leds.rst b/docs/pyboard/tutorial/leds.rst
index 6b05f5db05042..05f3b619e398e 100644
--- a/docs/pyboard/tutorial/leds.rst
+++ b/docs/pyboard/tutorial/leds.rst
@@ -17,10 +17,10 @@ This is all very well but we would like this process to be automated. Open the f
         pyb.delay(1000)
 
 When you save, the red light on the pyboard should turn on for about a second. To run the script, do a soft reset (CTRL-D). The pyboard will then restart and you should see a green light continuously flashing on and off. Success, the first step on your path to building an army of evil robots! When you are bored of the annoying flashing light then press CTRL-C at your terminal to stop it running.
- 
+
 So what does this code do? First we need some terminology. Python is an object-oriented language, almost everything in python is a *class* and when you create an instance of a class you get an *object*. Classes have *methods* associated to them. A method (also called a member function) is used to interact with or control the object.
 
-The first line of code creates an LED object which we have then called led. When we create the object, it takes a single parameter which must be between 1 and 4, corresponding to the 4 LEDs on the board. The pyb.LED class has three important member functions that we will use: on(), off() and toggle(). The other function that we use is pyb.delay() this simply waits for a given time in miliseconds. Once we have created the LED object, the statement while True: creates an infinite loop which toggles the led between on and off and waits for 1 second.
+The first line of code creates an LED object which we have then called led. When we create the object, it takes a single parameter which must be between 1 and 4, corresponding to the 4 LEDs on the board. The pyb.LED class has three important member functions that we will use: on(), off() and toggle(). The other function that we use is pyb.delay() this simply waits for a given time in milliseconds. Once we have created the LED object, the statement while True: creates an infinite loop which toggles the led between on and off and waits for 1 second.
 
 **Exercise: Try changing the time between toggling the led and turning on a different LED.**
 
diff --git a/docs/pyboard/tutorial/repl.rst b/docs/pyboard/tutorial/repl.rst
index 3853b1578567b..973d1846a0f0e 100644
--- a/docs/pyboard/tutorial/repl.rst
+++ b/docs/pyboard/tutorial/repl.rst
@@ -41,7 +41,7 @@ Mac OS X
 Open a terminal and run::
 
     screen /dev/tty.usbmodem*
-    
+
 When you are finished and want to exit screen, type CTRL-A CTRL-\\.
 
 Linux
@@ -50,7 +50,7 @@ Linux
 Open a terminal and run::
 
     screen /dev/ttyACM0
-    
+
 You can also try ``picocom`` or ``minicom`` instead of screen.  You may have to
 use ``/dev/ttyACM1`` or a higher number for ``ttyACM``.  And, you may need to give
 yourself the correct permissions to access this devices (eg group ``uucp`` or ``dialout``,
diff --git a/docs/pyboard/tutorial/script.rst b/docs/pyboard/tutorial/script.rst
index 75dd324e3ca40..2d44bbc885055 100644
--- a/docs/pyboard/tutorial/script.rst
+++ b/docs/pyboard/tutorial/script.rst
@@ -31,7 +31,7 @@ have as to what happens next:
     We will get the serial device working in the next tutorial.
 
   - **Mac**: Your pyboard will appear on the desktop as a removable disc.
-    It will probably be called "NONAME".  Click on it to open the pyboard folder.
+    It will probably be called ``PYBFLASH``.  Click on it to open the pyboard folder.
 
   - **Linux**: Your pyboard will appear as a removable medium.  On Ubuntu
     it will mount automatically and pop-up a window with the pyboard folder.
@@ -46,17 +46,17 @@ a window (or command line) should be showing the files on the pyboard drive.
 The drive you are looking at is known as ``/flash`` by the pyboard, and should contain
 the following 4 files:
 
-* `boot.py <http://micropython.org/resources/fresh-pyboard/boot.py>`_ -- this script is executed when the pyboard boots up.  It sets
-    up various configuration options for the pyboard.
+* `boot.py <http://micropython.org/resources/fresh-pyboard/boot.py>`_ -- the various configuration options for the pyboard.
+    It is executed when the pyboard boots up.
 
-* `main.py <http://micropython.org/resources/fresh-pyboard/main.py>`_ -- this is the main script that will contain your Python program.
+* `main.py <http://micropython.org/resources/fresh-pyboard/main.py>`_ -- the Python program to be run.
     It is executed after ``boot.py``.
 
-* `README.txt <http://micropython.org/resources/fresh-pyboard/README.txt>`_ -- this contains some very basic information about getting
-    started with the pyboard.
+* `README.txt <http://micropython.org/resources/fresh-pyboard/README.txt>`_ -- basic information about getting started with the pyboard.
+    This provides pointers for new users and can be safely deleted.
 
-* `pybcdc.inf <http://micropython.org/resources/fresh-pyboard/pybcdc.inf>`_ -- this is a Windows driver file to configure the serial USB
-    device.  More about this in the next tutorial.
+* `pybcdc.inf <http://micropython.org/resources/fresh-pyboard/pybcdc.inf>`_ -- the Windows driver file to configure the serial USB device.
+    More about this in the next tutorial.
 
 Editing ``main.py``
 -------------------
diff --git a/docs/pyboard/tutorial/switch.rst b/docs/pyboard/tutorial/switch.rst
index e2a5eae884819..96bb3784e9f8c 100644
--- a/docs/pyboard/tutorial/switch.rst
+++ b/docs/pyboard/tutorial/switch.rst
@@ -1,7 +1,7 @@
 .. _pyboard_tutorial_switch:
 
-The Switch, callbacks and interrupts
-====================================
+Switches, callbacks and interrupts
+==================================
 
 The pyboard has 2 small switches, labelled USR and RST.  The RST switch
 is a hard-reset switch, and if you press it then it restarts the pyboard
diff --git a/docs/pyboard/tutorial/usb_mouse.rst b/docs/pyboard/tutorial/usb_mouse.rst
index 6f8831edb465e..8166946ecd9e1 100644
--- a/docs/pyboard/tutorial/usb_mouse.rst
+++ b/docs/pyboard/tutorial/usb_mouse.rst
@@ -39,14 +39,15 @@ Sending mouse events by hand
 
 To get the py-mouse to do anything we need to send mouse events to the PC.
 We will first do this manually using the REPL prompt.  Connect to your
-pyboard using your serial program and type the following::
+pyboard using your serial program and type the following (no need to type
+the ``#`` and text following it)::
 
     >>> hid = pyb.USB_HID()
-    >>> hid.send((0, 10, 0, 0))
+    >>> hid.send((0, 100, 0, 0)) # (button status, x-direction, y-direction, scroll)
 
-Your mouse should move 10 pixels to the right!  In the command above you
-are sending 4 pieces of information: button status, x, y and scroll.  The
-number 10 is telling the PC that the mouse moved 10 pixels in the x direction.
+Your mouse should move 100 pixels to the right!  In the command above you
+are sending 4 pieces of information: **button status**, **x-direction**, **y-direction**, and **scroll**.  The
+number 100 is telling the PC that the mouse moved 100 pixels in the x direction.
 
 Let's make the mouse oscillate left and right::
 
diff --git a/docs/reference/asm_thumb2_directives.rst b/docs/reference/asm_thumb2_directives.rst
index 95acd7781fdd1..6e3ddaa16dfd8 100644
--- a/docs/reference/asm_thumb2_directives.rst
+++ b/docs/reference/asm_thumb2_directives.rst
@@ -1,4 +1,4 @@
-Assembler Directives
+Assembler directives
 ====================
 
 Labels
diff --git a/docs/reference/asm_thumb2_float.rst b/docs/reference/asm_thumb2_float.rst
index 4acb734eeb44c..4672c4b275041 100644
--- a/docs/reference/asm_thumb2_float.rst
+++ b/docs/reference/asm_thumb2_float.rst
@@ -1,5 +1,5 @@
-Floating Point instructions
-==============================
+Floating point instructions
+===========================
 
 These instructions support the use of the ARM floating point coprocessor
 (on platforms such as the Pyboard which are equipped with one). The FPU
@@ -31,7 +31,7 @@ Arithmetic
 * vsqrt(Sd, Sm) ``Sd = sqrt(Sm)``
 
 Registers may be identical: ``vmul(S0, S0, S0)`` will execute ``S0 = S0*S0``
- 
+
 Move between ARM core and FPU registers
 ---------------------------------------
 
@@ -40,7 +40,7 @@ Move between ARM core and FPU registers
 
 The FPU has a register known as FPSCR, similar to the ARM core's APSR, which stores condition
 codes plus other data. The following instructions provide access to this.
- 
+
 * vmrs(APSR\_nzcv, FPSCR)
 
 Move the floating-point N, Z, C, and V flags to the APSR N, Z, C, and V flags.
@@ -61,7 +61,7 @@ Where ``[Rn + offset]`` denotes the memory address obtained by adding Rn to the
 is specified in bytes. Since each float value occupies a 32 bit word, when accessing arrays of
 floats the offset must always be a multiple of four bytes.
 
-Data Comparison
+Data comparison
 ---------------
 
 * vcmp(Sd, Sm)
diff --git a/docs/reference/asm_thumb2_index.rst b/docs/reference/asm_thumb2_index.rst
index f066e6acec500..ccf0201489a5e 100644
--- a/docs/reference/asm_thumb2_index.rst
+++ b/docs/reference/asm_thumb2_index.rst
@@ -1,6 +1,6 @@
 .. _asm_thumb2_index:
 
-Inline Assembler for Thumb2 architectures
+Inline assembler for Thumb2 architectures
 =========================================
 
 This document assumes some familiarity with assembly language programming and should be read after studying
@@ -25,7 +25,7 @@ This enables the effect of instructions to be demonstrated in Python. In certain
 because Python doesn't support concepts such as indirection. The pseudocode employed in such cases is
 described on the relevant page.
 
-Instruction Categories
+Instruction categories
 ----------------------
 
 The following sections details the subset of the ARM Thumb-2 instruction set supported by MicroPython.
diff --git a/docs/reference/asm_thumb2_logical_bit.rst b/docs/reference/asm_thumb2_logical_bit.rst
index 8c51feaf45f95..c57bfa8470f81 100644
--- a/docs/reference/asm_thumb2_logical_bit.rst
+++ b/docs/reference/asm_thumb2_logical_bit.rst
@@ -1,4 +1,4 @@
-Logical & Bitwise instructions
+Logical & bitwise instructions
 ==============================
 
 Document conventions
diff --git a/docs/reference/constrained.rst b/docs/reference/constrained.rst
index edac0ae681bba..9c68bab9a13e0 100644
--- a/docs/reference/constrained.rst
+++ b/docs/reference/constrained.rst
@@ -1,6 +1,6 @@
 .. _constrained:
 
-MicroPython on Microcontrollers
+MicroPython on microcontrollers
 ===============================
 
 MicroPython is designed to be capable of running on microcontrollers. These
@@ -12,7 +12,7 @@ based on a variety of architectures, the methods presented are generic: in some
 cases it will be necessary to obtain detailed information from platform specific
 documentation.
 
-Flash Memory
+Flash memory
 ------------
 
 On the Pyboard the simple way to address the limited capacity is to fit a micro
@@ -58,7 +58,7 @@ heap fragmentation. In general terms it is best to minimise the repeated
 creation and destruction of objects. The reason for this is covered in the
 section covering the `heap`_.
 
-Compilation Phase
+Compilation phase
 ~~~~~~~~~~~~~~~~~
 
 When a module is imported, MicroPython compiles the code to bytecode which is
@@ -85,7 +85,7 @@ imported in the usual way. Alternatively some or all modules may be implemented
 as frozen bytecode: on most platforms this saves even more RAM as the bytecode
 is run directly from flash rather than being stored in RAM.
 
-Execution Phase
+Execution phase
 ~~~~~~~~~~~~~~~
 
 There are a number of coding techniques for reducing RAM usage.
@@ -292,7 +292,7 @@ The Q(xxx) lines should be gone.
 
 .. _heap:
 
-The Heap
+The heap
 --------
 
 When a running program instantiates an object the necessary RAM is allocated
@@ -391,7 +391,7 @@ Symbol Meaning
 Each letter represents a single block of memory, a block being 16 bytes. So each
 line of the heap dump represents 0x400 bytes or 1KiB of RAM.
 
-Control of Garbage Collection
+Control of garbage collection
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 A GC can be demanded at any time by issuing `gc.collect()`. It is advantageous
@@ -420,7 +420,7 @@ initialisation the compiler may be starved of RAM when subsequent modules are
 imported. If modules do instantiate data on import then `gc.collect()` issued
 after the import will ameliorate the problem.
 
-String Operations
+String operations
 -----------------
 
 MicroPython handles strings in an efficient manner and understanding this can
diff --git a/docs/reference/filesystem.rst b/docs/reference/filesystem.rst
new file mode 100644
index 0000000000000..9e7e6212dc679
--- /dev/null
+++ b/docs/reference/filesystem.rst
@@ -0,0 +1,291 @@
+.. _filesystem:
+
+Working with filesystems
+========================
+
+.. contents::
+
+This tutorial describes how MicroPython provides an on-device filesystem,
+allowing standard Python file I/O methods to be used with persistent storage.
+
+MicroPython automatically creates a default configuration and auto-detects the
+primary filesystem, so this tutorial will be mostly useful if you want to modify
+the partitioning, filesystem type, or use custom block devices.
+
+The filesystem is typically backed by internal flash memory on the device, but
+can also use external flash, RAM, or a custom block device.
+
+On some ports (e.g. STM32), the filesystem may also be available over USB MSC to
+a host PC. :ref:`pyboard_py` also provides a way for the host PC to access to
+the filesystem on all ports.
+
+Note: This is mainly for use on bare-metal ports like STM32 and ESP32. On ports
+with an operating system (e.g. the Unix port) the filesystem is provided by the
+host OS.
+
+VFS
+---
+
+MicroPython implements a Unix-like Virtual File System (VFS) layer. All mounted
+filesystems are combined into a single virtual filesystem, starting at the root
+``/``. Filesystems are mounted into directories in this structure, and at
+startup the working directory is changed to where the primary filesystem is
+mounted.
+
+On STM32 / Pyboard, the internal flash is mounted at ``/flash``, and optionally
+the SDCard at ``/sd``. On ESP8266/ESP32, the primary filesystem is mounted at
+``/``.
+
+Block devices
+-------------
+
+A block device is an instance of a class that implements the
+:class:`uos.AbstractBlockDev` protocol.
+
+Built-in block devices
+~~~~~~~~~~~~~~~~~~~~~~
+
+Ports provide built-in block devices to access their primary flash.
+
+On power-on, MicroPython will attempt to detect the filesystem on the default
+flash and configure and mount it automatically. If no filesystem is found,
+MicroPython will attempt to create a FAT filesystem spanning the entire flash.
+Ports can also provide a mechanism to "factory reset" the primary flash, usually
+by some combination of button presses at power on.
+
+STM32 / Pyboard
+...............
+
+The :ref:`pyb.Flash <pyb.Flash>` class provides access to the internal flash. On some
+boards which have larger external flash (e.g. Pyboard D), it will use that
+instead. The ``start`` kwarg should always be specified, i.e.
+``pyb.Flash(start=0)``.
+
+Note: For backwards compatibility, when constructed with no arguments (i.e.
+``pyb.Flash()``), it only implements the simple block interface and reflects the
+virtual device presented to USB MSC (i.e. it includes a virtual partition table
+at the start).
+
+ESP8266
+.......
+
+The internal flash is exposed as a block device object which is created in the
+``flashbdev`` module on start up. This object is by default added as a global
+variable so it can usually be accessed simply as ``bdev``. This implements the
+extended interface.
+
+ESP32
+.....
+
+The :class:`esp32.Partition` class implements a block device for partitions
+defined for the board. Like ESP8266, there is a global variable ``bdev`` which
+points to the default partition. This implements the extended interface.
+
+Custom block devices
+~~~~~~~~~~~~~~~~~~~~
+
+The following class implements a simple block device that stores its data in
+RAM using a ``bytearray``::
+
+    class RAMBlockDev:
+        def __init__(self, block_size, num_blocks):
+            self.block_size = block_size
+            self.data = bytearray(block_size * num_blocks)
+
+        def readblocks(self, block_num, buf):
+            for i in range(len(buf)):
+                buf[i] = self.data[block_num * self.block_size + i]
+
+        def writeblocks(self, block_num, buf):
+            for i in range(len(buf)):
+                self.data[block_num * self.block_size + i] = buf[i]
+
+        def ioctl(self, op, arg):
+            if op == 4: # get number of blocks
+                return len(self.data) // self.block_size
+            if op == 5: # get block size
+                return self.block_size
+
+It can be used as follows::
+
+    import os
+
+    bdev = RAMBlockDev(512, 50)
+    os.VfsFat.mkfs(bdev)
+    os.mount(bdev, '/ramdisk')
+
+An example of a block device that supports both the simple and extended
+interface (i.e. both signatures and behaviours of the
+:meth:`uos.AbstractBlockDev.readblocks` and
+:meth:`uos.AbstractBlockDev.writeblocks` methods) is::
+
+    class RAMBlockDev:
+        def __init__(self, block_size, num_blocks):
+            self.block_size = block_size
+            self.data = bytearray(block_size * num_blocks)
+
+        def readblocks(self, block_num, buf, offset=0):
+            addr = block_num * self.block_size + offset
+            for i in range(len(buf)):
+                buf[i] = self.data[addr + i]
+
+        def writeblocks(self, block_num, buf, offset=None):
+            if offset is None:
+                # do erase, then write
+                for i in range(len(buf) // self.block_size):
+                    self.ioctl(6, block_num + i)
+                offset = 0
+            addr = block_num * self.block_size + offset
+            for i in range(len(buf)):
+                self.data[addr + i] = buf[i]
+
+        def ioctl(self, op, arg):
+            if op == 4: # block count
+                return len(self.data) // self.block_size
+            if op == 5: # block size
+                return self.block_size
+            if op == 6: # block erase
+                return 0
+
+As it supports the extended interface, it can be used with :class:`littlefs
+<uos.VfsLfs2>`::
+
+    import os
+
+    bdev = RAMBlockDev(512, 50)
+    os.VfsLfs2.mkfs(bdev)
+    os.mount(bdev, '/ramdisk')
+
+Once mounted, the filesystem (regardless of its type) can be used as it
+normally would be used from Python code, for example::
+
+    with open('/ramdisk/hello.txt', 'w') as f:
+        f.write('Hello world')
+    print(open('/ramdisk/hello.txt').read())
+
+Filesystems
+-----------
+
+MicroPython ports can provide implementations of :class:`FAT <uos.VfsFat>`,
+:class:`littlefs v1 <uos.VfsLfs1>` and :class:`littlefs v2 <uos.VfsLfs2>`.
+
+The following table shows which filesystems are included in the firmware by
+default for given port/board combinations, however they can be optionally
+enabled in a custom firmware build.
+
+====================  =====  ===========  ===========
+Board                 FAT    littlefs v1  littlefs v2
+====================  =====  ===========  ===========
+pyboard 1.0, 1.1, D   Yes    No           Yes
+Other STM32           Yes    No           No
+ESP8266 (1M)          No     No           Yes
+ESP8266 (2M+)         Yes    No           Yes
+ESP32                 Yes    No           Yes
+====================  =====  ===========  ===========
+
+FAT
+~~~
+
+The main advantage of the FAT filesystem is that it can be accessed over USB MSC
+on supported boards (e.g. STM32) without any additional drivers required on the
+host PC.
+
+However, FAT is not tolerant to power failure during writes and this can lead to
+filesystem corruption. For applications that do not require USB MSC, it is
+recommended to use littlefs instead.
+
+To format the entire flash using FAT::
+
+    # ESP8266 and ESP32
+    import os
+    os.umount('/')
+    os.VfsFat.mkfs(bdev)
+    os.mount(bdev, '/')
+
+    # STM32
+    import os, pyb
+    os.umount('/flash')
+    os.VfsFat.mkfs(pyb.Flash(start=0))
+    os.mount(pyb.Flash(start=0), '/flash')
+    os.chdir('/flash')
+
+Littlefs
+~~~~~~~~
+
+Littlefs_ is a filesystem designed for flash-based devices, and is much more
+resistant to filesystem corruption.
+
+.. note:: There are reports of littlefs v1 and v2 failing in certain
+          situations, for details see `littlefs issue 347`_  and
+          `littlefs issue 295`_.
+
+Note: It can be still be accessed over USB MSC using the `littlefs FUSE
+driver`_. Note that you must use the ``-b=4096`` option to override the block
+size.
+
+.. _littlefs FUSE driver: https://github.com/ARMmbed/littlefs-fuse/tree/master/littlefs
+.. _Littlefs: https://github.com/ARMmbed/littlefs
+.. _littlefs issue 295: https://github.com/ARMmbed/littlefs/issues/295
+.. _littlefs issue 347: https://github.com/ARMmbed/littlefs/issues/347
+
+To format the entire flash using littlefs v2::
+
+    # ESP8266 and ESP32
+    import os
+    os.umount('/')
+    os.VfsLfs2.mkfs(bdev)
+    os.mount(bdev, '/')
+
+    # STM32
+    import os, pyb
+    os.umount('/flash')
+    os.VfsLfs2.mkfs(pyb.Flash(start=0))
+    os.mount(pyb.Flash(start=0), '/flash')
+    os.chdir('/flash')
+
+Hybrid (STM32)
+~~~~~~~~~~~~~~
+
+By using the ``start`` and ``len`` kwargs to :class:`pyb.Flash`, you can create
+block devices spanning a subset of the flash device.
+
+For example, to configure the first 256kiB as FAT (and available over USB MSC),
+and the remainder as littlefs::
+
+    import os, pyb
+    os.umount('/flash')
+    p1 = pyb.Flash(start=0, len=256*1024)
+    p2 = pyb.Flash(start=256*1024)
+    os.VfsFat.mkfs(p1)
+    os.VfsLfs2.mkfs(p2)
+    os.mount(p1, '/flash')
+    os.mount(p2, '/data')
+    os.chdir('/flash')
+
+This might be useful to make your Python files, configuration and other
+rarely-modified content available over USB MSC, but allowing for frequently
+changing application data to reside on littlefs with better resilience to power
+failure, etc.
+
+The partition at offset ``0`` will be mounted automatically (and the filesystem
+type automatically detected), but you can add::
+
+    import os, pyb
+    p2 = pyb.Flash(start=256*1024)
+    os.mount(p2, '/data')
+
+to ``boot.py`` to mount the data partition.
+
+Hybrid (ESP32)
+~~~~~~~~~~~~~~
+
+On ESP32, if you build custom firmware, you can modify ``partitions.csv`` to
+define an arbitrary partition layout.
+
+At boot, the partition named "vfs" will be mounted at ``/`` by default, but any
+additional partitions can be mounted in your ``boot.py`` using::
+
+    import esp32, os
+    p = esp32.Partition.find(esp32.Partition.TYPE_DATA, label='foo')
+    os.mount(p, '/foo')
+
diff --git a/docs/reference/glossary.rst b/docs/reference/glossary.rst
index a6abc8b9da410..d63f372298f9e 100644
--- a/docs/reference/glossary.rst
+++ b/docs/reference/glossary.rst
@@ -4,152 +4,197 @@ Glossary
 .. glossary::
 
     baremetal
-        A system without a (full-fledged) OS, for example an
+        A system without a (full-fledged) operating system, for example an
         :term:`MCU`-based system. When running on a baremetal system,
-        MicroPython effectively becomes its user-facing OS with a command
-        interpreter (REPL).
+        MicroPython effectively functions like a small operating system,
+        running user programs and providing a command interpreter
+        (:term:`REPL`).
+
+    buffer protocol
+        Any Python object that can be automatically converted into bytes, such
+        as ``bytes``, ``bytearray``, ``memoryview`` and ``str`` objects, which
+        all implement the "buffer protocol".
 
     board
-        A PCB board. Oftentimes, the term is used to denote a particular
-        model of an :term:`MCU` system. Sometimes, it is used to actually
-        refer to :term:`MicroPython port` to a particular board (and then
-        may also refer to "boardless" ports like
-        :term:`Unix port <MicroPython Unix port>`).
+        Typically this refers to a printed circuit board (PCB) containing a
+        :term:`microcontroller <MCU>` and supporting components.
+        MicroPython firmware is typically provided per-board, as the firmware
+        contains both MCU-specific functionality but also board-level
+        functionality such as drivers or pin names.
+
+    bytecode
+        A compact representation of a Python program that generated by
+        compiling the Python source code. This is what the VM actually
+        executes. Bytecode is typically generated automatically at runtime and
+        is invisible to the user. Note that while :term:`CPython` and
+        MicroPython both use bytecode, the format is different. You can also
+        pre-compile source code offline using the :term:`cross-compiler`.
 
     callee-owned tuple
-        A tuple returned by some builtin function/method, containing data
-        which is valid for a limited time, usually until next call to the
-        same function (or a group of related functions). After next call,
-        data in the tuple may be changed. This leads to the following
-        restriction on the usage of callee-owned tuples - references to
-        them cannot be stored. The only valid operation is extracting
-        values from them (including making a copy). Callee-owned tuples
-        is a MicroPython-specific construct (not available in the general
-        Python language), introduced for memory allocation optimization.
-        The idea is that callee-owned tuple is allocated once and stored
-        on the callee side. Subsequent calls don't require allocation,
-        allowing to return multiple values when allocation is not possible
-        (e.g. in interrupt context) or not desirable (because allocation
-        inherently leads to memory fragmentation). Note that callee-owned
-        tuples are effectively mutable tuples, making an exception to
-        Python's rule that tuples are immutable. (It may be interesting
-        why tuples were used for such a purpose then, instead of mutable
-        lists - the reason for that is that lists are mutable from user
-        application side too, so a user could do things to a callee-owned
-        list which the callee doesn't expect and could lead to problems;
-        a tuple is protected from this.)
+        This is a MicroPython-specific construct where, for efficiency
+        reasons, some built-in functions or methods may re-use the same
+        underlying tuple object to return data. This avoids having to allocate
+        a new tuple for every call, and reduces heap fragmentation. Programs
+        should not hold references to callee-owned tuples and instead only
+        extract data from them (or make a copy).
+
+    CircuitPython
+        A variant of MicroPython developed by `Adafruit Industries
+        <https://circuitpython.org>`_.
 
     CPython
-        CPython is the reference implementation of Python programming
-        language, and the most well-known one, which most of the people
-        run. It is however one of many implementations (among which
-        Jython, IronPython, PyPy, and many more, including MicroPython).
-        As there is no formal specification of the Python language, only
-        CPython documentation, it is not always easy to draw a line
-        between Python the language and CPython its particular
-        implementation. This however leaves more freedom for other
-        implementations. For example, MicroPython does a lot of things
-        differently than CPython, while still aspiring to be a Python
-        language implementation.
+        CPython is the reference implementation of the Python programming
+        language, and the most well-known one. It is, however, one of many
+        implementations (including Jython, IronPython, PyPy, and MicroPython).
+        While MicroPython's implementation differs substantially from CPython,
+        it aims to maintain as much compatibility as possible.
+
+    cross-compiler
+        Also known as ``mpy-cross``. This tool runs on your PC and converts a
+        :term:`.py file` containing MicroPython code into a :term:`.mpy file`
+        containing MicroPython bytecode. This means it loads faster (the board
+        doesn't have to compile the code), and uses less space on flash (the
+        bytecode is more space efficient).
+
+    driver
+        A MicroPython library that implements support for a particular
+        component, such as a sensor or display.
+
+    FFI
+        Acronym for Foreign Function Interface. A mechanism used by the
+        :term:`MicroPython Unix port` to access operating system functionality.
+        This is not available on :term:`baremetal` ports.
+
+    filesystem
+        Most MicroPython ports and boards provide a filesystem stored in flash
+        that is available to user code via the standard Python file APIs such
+        as ``open()``. Some boards also make this internal filesystem
+        accessible to the host via USB mass-storage.
+
+    frozen module
+        A Python module that has been cross compiled and bundled into the
+        firmware image. This reduces RAM requirements as the code is executed
+        directly from flash.
+
+    Garbage Collector
+        A background process that runs in Python (and MicroPython) to reclaim
+        unused memory in the :term:`heap`.
 
     GPIO
-        General-purpose input/output. The simplest means to control
-        electrical signals. With GPIO, user can configure hardware
-        signal pin to be either input or output, and set or get
-        its digital signal value (logical "0" or "1"). MicroPython
-        abstracts GPIO access using :class:`machine.Pin` and :class:`machine.Signal`
+        General-purpose input/output. The simplest means to control electrical
+        signals (commonly referred to as "pins") on a microcontroller. GPIO
+        typically allows pins to be either input or output, and to set or get
+        their digital value (logical "0" or "1"). MicroPython abstracts GPIO
+        access using the :class:`machine.Pin` and :class:`machine.Signal`
         classes.
 
     GPIO port
-        A group of :term:`GPIO` pins, usually based on hardware
-        properties of these pins (e.g. controllable by the same
-        register).
+        A group of :term:`GPIO` pins, usually based on hardware properties of
+        these pins (e.g. controllable by the same register).
+
+    heap
+        A region of RAM where MicroPython stores dynamic data. It is managed
+        automatically by the :term:`Garbage Collector`. Different MCUs and
+        boards have vastly different amounts of RAM available for the heap, so
+        this will affect how complex your program can be.
 
     interned string
-        A string referenced by its (unique) identity rather than its
-        address. Interned strings are thus can be quickly compared just
-        by their identifiers, instead of comparing by content. The
-        drawbacks of interned strings are that interning operation takes
-        time (proportional to the number of existing interned strings,
-        i.e. becoming slower and slower over time) and that the space
-        used for interned strings is not reclaimable. String interning
-        is done automatically by MicroPython compiler and runtimer when
-        it's either required by the implementation (e.g. function keyword
-        arguments are represented by interned string id's) or deemed
-        beneficial (e.g. for short enough strings, which have a chance
-        to be repeated, and thus interning them would save memory on
-        copies). Most of string and I/O operations don't produce interned
-        strings due to drawbacks described above.
+        An optimisation used by MicroPython to improve the efficiency of
+        working with strings. An interned string is referenced by its (unique)
+        identity rather than its address and can therefore be quickly compared
+        just by its identifier. It also means that identical strings can be
+        de-duplicated in memory. String interning is almost always invisible to
+        the user.
 
     MCU
         Microcontroller. Microcontrollers usually have much less resources
-        than a full-fledged computing system, but smaller, cheaper and
+        than a desktop, laptop, or phone, but are smaller, cheaper and
         require much less power. MicroPython is designed to be small and
         optimized enough to run on an average modern microcontroller.
 
     micropython-lib
         MicroPython is (usually) distributed as a single executable/binary
         file with just few builtin modules. There is no extensive standard
-        library comparable with :term:`CPython`. Instead, there is a related, but
-        separate project
-        `micropython-lib <https://github.com/micropython/micropython-lib>`_
-        which provides implementations for many modules from CPython's
-        standard library. However, large subset of these modules require
-        POSIX-like environment (Linux, FreeBSD, MacOS, etc.; Windows may be
-        partially supported), and thus would work or make sense only with
-        `MicroPython Unix port`. Some subset of modules is however usable
-        for `baremetal` ports too.
-
-        Unlike monolithic :term:`CPython` stdlib, micropython-lib modules
-        are intended to be installed individually - either using manual
-        copying or using :term:`upip`.
+        library comparable with :term:`CPython`'s. Instead, there is a related,
+        but separate project `micropython-lib
+        <https://github.com/micropython/micropython-lib>`_ which provides
+        implementations for many modules from CPython's standard library.
+
+        Some of the modules are are implemented in pure Python, and are able to
+        be used on all ports. However, the majority of these modules use
+        :term:`FFI` to access operating system functionality, and as such can
+        only be used on the :term:`MicroPython Unix port` (with limited support
+        for Windows).
+
+        Unlike the :term:`CPython` stdlib, micropython-lib modules are
+        intended to be installed individually - either using manual copying or
+        using :term:`upip`.
 
     MicroPython port
-        MicroPython supports different :term:`boards <board>`, RTOSes,
-        and OSes, and can be relatively easily adapted to new systems.
-        MicroPython with support for a particular system is called a
-        "port" to that system. Different ports may have widely different
-        functionality. This documentation is intended to be a reference
-        of the generic APIs available across different ports ("MicroPython
-        core"). Note that some ports may still omit some APIs described
-        here (e.g. due to resource constraints). Any such differences,
-        and port-specific extensions beyond MicroPython core functionality,
-        would be described in the separate port-specific documentation.
+        MicroPython supports different :term:`boards <board>`, RTOSes, and
+        OSes, and can be relatively easily adapted to new systems. MicroPython
+        with support for a particular system is called a "port" to that
+        system. Different ports may have widely different functionality. This
+        documentation is intended to be a reference of the generic APIs
+        available across different ports ("MicroPython core"). Note that some
+        ports may still omit some APIs described here (e.g. due to resource
+        constraints). Any such differences, and port-specific extensions
+        beyond the MicroPython core functionality, would be described in the
+        separate port-specific documentation.
 
     MicroPython Unix port
-        Unix port is one of the major :term:`MicroPython ports <MicroPython port>`.
-        It is intended to run on POSIX-compatible operating systems, like
-        Linux, MacOS, FreeBSD, Solaris, etc. It also serves as the basis
-        of Windows port. The importance of Unix port lies in the fact
-        that while there are many different :term:`boards <board>`, so
-        two random users unlikely have the same board, almost all modern
-        OSes have some level of POSIX compatibility, so Unix port serves
-        as a kind of "common ground" to which any user can have access.
-        So, Unix port is used for initial prototyping, different kinds
-        of testing, development of machine-independent features, etc.
-        All users of MicroPython, even those which are interested only
-        in running MicroPython on :term:`MCU` systems, are recommended
-        to be familiar with Unix (or Windows) port, as it is important
-        productivity helper and a part of normal MicroPython workflow.
+        The unix port is one of the major :term:`MicroPython ports
+        <MicroPython port>`. It is intended to run on POSIX-compatible
+        operating systems, like Linux, MacOS, FreeBSD, Solaris, etc. It also
+        serves as the basis of Windows port. The Unix port is very useful for
+        quick development and testing of the MicroPython language and
+        machine-independent features. It can also function in a similar way to
+        :term:`CPython`'s ``python`` executable.
+
+    .mpy file
+        The output of the :term:`cross-compiler`. A compiled form of a
+        :term:`.py file` that contains MicroPython bytecode instead of Python
+        source code.
+
+    native
+        Usually refers to "native code", i.e. machine code for the target
+        microcontroller (such as ARM Thumb, Xtensa, x86/x64). The ``@native``
+        decorator can be applied to a MicroPython function to generate native
+        code instead of bytecode for that function, which will likely be
+        faster but use more RAM.
 
     port
-        Either :term:`MicroPython port` or :term:`GPIO port`. If not clear
-        from context, it's recommended to use full specification like one
-        of the above.
+        Usually short for :term:`MicroPython port`, but could also refer to
+        :term:`GPIO port`.
+
+    .py file
+        A file containing Python source code.
+
+    REPL
+        An acronym for "Read, Eval, Print, Loop". This is the interactive
+        Python prompt, useful for debugging or testing short snippets of code.
+        Most MicroPython boards make a REPL available over a UART, and this is
+        typically accessible on a host PC via USB.
 
     stream
-        Also known as a "file-like object". An object which provides sequential
-        read-write access to the underlying data. A stream object implements
-        a corresponding interface, which consists of methods like ``read()``,
-        ``write()``, ``readinto()``, ``seek()``, ``flush()``, ``close()``, etc.
-        A stream is an important concept in MicroPython, many I/O objects
-        implement the stream interface, and thus can be used consistently and
-        interchangeably in different contexts. For more information on
-        streams in MicroPython, see `uio` module.
+        Also known as a "file-like object". An Python object which provides
+        sequential read-write access to the underlying data. A stream object
+        implements a corresponding interface, which consists of methods like
+        ``read()``, ``write()``, ``readinto()``, ``seek()``, ``flush()``,
+        ``close()``, etc. A stream is an important concept in MicroPython;
+        many I/O objects implement the stream interface, and thus can be used
+        consistently and interchangeably in different contexts. For more
+        information on streams in MicroPython, see the `uio` module.
+
+    UART
+        Acronym for "Universal Asynchronous Receiver/Transmitter". This is a
+        peripheral that sends data over a pair of pins (TX & RX). Many boards
+        include a way to make at least one of the UARTs available to a host PC
+        as a serial port over USB.
 
     upip
-        (Literally, "micro pip"). A package manage for MicroPython, inspired
-        by :term:`CPython`'s pip, but much smaller and with reduced functionality.
-        upip runs both on :term:`Unix port <MicroPython Unix port>` and on
-        :term:`baremetal` ports (those which offer filesystem and networking
-        support).
+        (Literally, "micro pip"). A package manager for MicroPython, inspired
+        by :term:`CPython`'s pip, but much smaller and with reduced
+        functionality.
+        upip runs both on the :term:`Unix port <MicroPython Unix port>` and on
+        :term:`baremetal` ports which offer filesystem and networking support.
diff --git a/docs/reference/index.rst b/docs/reference/index.rst
index d0c7f69de9561..8cd5f03df48fc 100644
--- a/docs/reference/index.rst
+++ b/docs/reference/index.rst
@@ -1,5 +1,5 @@
-The MicroPython language
-========================
+MicroPython language and implementation
+=======================================
 
 MicroPython aims to implement the Python 3.4 standard (with selected
 features from later versions) with respect to language syntax, and most
@@ -21,8 +21,11 @@ implementation and the best practices to use them.
 
    glossary.rst
    repl.rst
+   mpyfiles.rst
    isr_rules.rst
    speed_python.rst
    constrained.rst
    packages.rst
    asm_thumb2_index.rst
+   filesystem.rst
+   pyboard.py.rst
diff --git a/docs/reference/isr_rules.rst b/docs/reference/isr_rules.rst
index dfdee048c1310..57690ac212c64 100644
--- a/docs/reference/isr_rules.rst
+++ b/docs/reference/isr_rules.rst
@@ -29,7 +29,7 @@ This summarises the points detailed below and lists the principal recommendation
 * Allocate an emergency exception buffer (see below).
 
 
-MicroPython Issues
+MicroPython issues
 ------------------
 
 The emergency exception buffer
@@ -214,7 +214,7 @@ Exceptions
 If an ISR raises an exception it will not propagate to the main loop. The interrupt will be disabled unless the
 exception is handled by the ISR code.
 
-General Issues
+General issues
 --------------
 
 This is merely a brief introduction to the subject of real time programming. Beginners should note
@@ -225,7 +225,7 @@ with an appreciation of the following issues.
 
 .. _ISR:
 
-Interrupt Handler Design
+Interrupt handler design
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
 As mentioned above, ISR's should be designed to be as simple as possible. They should always return in a short,
@@ -276,7 +276,7 @@ advanced topic beyond the scope of this tutorial.
 
 .. _Critical:
 
-Critical Sections
+Critical sections
 ~~~~~~~~~~~~~~~~~
 
 An example of a critical section of code is one which accesses more than one variable which can be affected by an ISR. If
diff --git a/docs/reference/mpyfiles.rst b/docs/reference/mpyfiles.rst
new file mode 100644
index 0000000000000..4791784ac3a2e
--- /dev/null
+++ b/docs/reference/mpyfiles.rst
@@ -0,0 +1,178 @@
+.. _mpy_files:
+
+MicroPython .mpy files
+======================
+
+MicroPython defines the concept of an .mpy file which is a binary container
+file format that holds precompiled code, and which can be imported like a
+normal .py module.  The file ``foo.mpy`` can be imported via ``import foo``,
+as long as ``foo.mpy`` can be found in the usual way by the import machinery.
+Usually, each directory listed in ``sys.path`` is searched in order.  When
+searching a particular directory ``foo.py`` is looked for first and if that
+is not found then ``foo.mpy`` is looked for, then the search continues in the
+next directory if neither is found.  As such, ``foo.py`` will take precedence
+over ``foo.mpy``.
+
+These .mpy files can contain bytecode which is usually generated from Python
+source files (.py files) via the ``mpy-cross`` program.  For some architectures
+an .mpy file can also contain native machine code, which can be generated in
+a variety of ways, most notably from C source code.
+
+Versioning and compatibility of .mpy files
+------------------------------------------
+
+A given .mpy file may or may not be compatible with a given MicroPython system.
+Compatibility is based on the following:
+
+* Version of the .mpy file: the version of the file must match the version
+  supported by the system loading it.
+
+* Bytecode features used in the .mpy file: there are two bytecode features
+  which must match between the file and the system: unicode support and
+  inline caching of map lookups in the bytecode.
+
+* Small integer bits: the .mpy file will require a minimum number of bits in
+  a small integer and the system loading it must support at least this many
+  bits.
+
+* Qstr compression window size: the .mpy file will require a minimum window
+  size for qstr decompression and the system loading it must have a window
+  greater or equal to this size.
+
+* Native architecture: if the .mpy file contains native machine code then
+  it will specify the architecture of that machine code and the system
+  loading it must support execution of that architecture's code.
+
+If a MicroPython system supports importing .mpy files then the
+``sys.implementation.mpy`` field will exist and return an integer which
+encodes the version (lower 8 bits), features and native architecture.
+
+Trying to import an .mpy file that fails one of the first four tests will
+raise ``ValueError('incompatible .mpy file')``.  Trying to import an .mpy
+file that fails the native architecture test (if it contains native machine
+code) will raise ``ValueError('incompatible .mpy arch')``.
+
+If importing an .mpy file fails then try the following:
+
+* Determine the .mpy version and flags supported by your MicroPython system
+  by executing::
+
+    import sys
+    sys_mpy = sys.implementation.mpy
+    arch = [None, 'x86', 'x64',
+        'armv6', 'armv6m', 'armv7m', 'armv7em', 'armv7emsp', 'armv7emdp',
+        'xtensa', 'xtensawin'][sys_mpy >> 10]
+    print('mpy version:', sys_mpy & 0xff)
+    print('mpy flags:', end='')
+    if arch:
+        print(' -march=' + arch, end='')
+    if sys_mpy & 0x100:
+        print(' -mcache-lookup-bc', end='')
+    if not sys_mpy & 0x200:
+        print(' -mno-unicode', end='')
+    print()
+
+* Check the validity of the .mpy file by inspecting the first two bytes of
+  the file.  The first byte should be an uppercase 'M' and the second byte
+  will be the version number, which should match the system version from above.
+  If it doesn't match then rebuild the .mpy file.
+
+* Check if the system .mpy version matches the version emitted by ``mpy-cross``
+  that was used to build the .mpy file, found by ``mpy-cross --version``.
+  If it doesn't match then recompile ``mpy-cross`` from the Git repository
+  checked out at the tag (or hash) reported by ``mpy-cross --version``.
+
+* Make sure you are using the correct ``mpy-cross`` flags, found by the code
+  above, or by inspecting the ``MPY_CROSS_FLAGS`` Makefile variable for the
+  port that you are using.
+
+The following table shows the correspondence between MicroPython release
+and .mpy version.
+
+=================== ============
+MicroPython release .mpy version
+=================== ============
+v1.12 and up        5
+v1.11               4
+v1.9.3 - v1.10      3
+v1.9 - v1.9.2       2
+v1.5.1 - v1.8.7     0
+=================== ============
+
+For completeness, the next table shows the Git commit of the main
+MicroPython repository at which the .mpy version was changed.
+
+=================== ========================================
+.mpy version change Git commit
+=================== ========================================
+4 to 5              5716c5cf65e9b2cb46c2906f40302401bdd27517
+3 to 4              9a5f92ea72754c01cc03e5efcdfe94021120531e
+2 to 3              ff93fd4f50321c6190e1659b19e64fef3045a484
+1 to 2              dd11af209d226b7d18d5148b239662e30ed60bad
+0 to 1              6a11048af1d01c78bdacddadd1b72dc7ba7c6478
+initial version 0   d8c834c95d506db979ec871417de90b7951edc30
+=================== ========================================
+
+Binary encoding of .mpy files
+-----------------------------
+
+MicroPython .mpy files are a binary container format with code objects
+stored internally in a nested hierarchy.  To keep files small while still
+providing a large range of possible values it uses the concept of a
+variably-encoded-unsigned-integer (vuint) in many places.  Similar to utf-8
+encoding, this encoding stores 7 bits per byte with the 8th bit (MSB) set
+if one or more bytes follow.  The bits of the unsigned integer are stored
+in the vuint in LSB form.
+
+The top-level of an .mpy file consists of two parts:
+
+* The header.
+
+* The raw-code for the outer scope of the module.
+  This outer scope is executed when the .mpy file is imported.
+
+The header
+~~~~~~~~~~
+
+The .mpy header is:
+
+======  ================================
+size    field
+======  ================================
+byte    value 0x4d (ASCII 'M')
+byte    .mpy version number
+byte    feature flags
+byte    number of bits in a small int
+vuint   size of qstr window
+======  ================================
+
+Raw code elements
+~~~~~~~~~~~~~~~~~
+
+A raw-code element contains code, either bytecode or native machine code.  Its
+contents are:
+
+======  ================================
+size    field
+======  ================================
+vuint   type and size
+...     code (bytecode or machine code)
+vuint   number of constant objects
+vuint   number of sub-raw-code elements
+...     constant objects
+...     sub-raw-code elements
+======  ================================
+
+The first vuint in a raw-code element encodes the type of code stored in this
+element (the two least-significant bits), and the decompressed length of the code
+(the amount of RAM to allocate for it).
+
+Following the vuint comes the code itself.  In the case of bytecode it also contains
+compressed qstr values.
+
+Following the code comes a vuint counting the number of constant objects, and
+another vuint counting the number of sub-raw-code elements.
+
+The constant objects are then stored next.
+
+Finally any sub-raw-code elements are stored, recursively.
diff --git a/docs/reference/packages.rst b/docs/reference/packages.rst
index 8be2461c2dbc0..43217493e52a4 100644
--- a/docs/reference/packages.rst
+++ b/docs/reference/packages.rst
@@ -39,7 +39,7 @@ The MicroPython distribution package format is a well-known tar.gz
 format, with some adaptations however. The Gzip compressor, used as
 an external wrapper for TAR archives, by default uses 32KB dictionary
 size, which means that to uncompress a compressed stream, 32KB of
-contguous memory needs to be allocated. This requirement may be not
+contiguous memory needs to be allocated. This requirement may be not
 satisfiable on low-memory devices, which may have total memory available
 less than that amount, and even if not, a contiguous block like that
 may be hard to allocate due to memory fragmentation. To accommodate
@@ -132,7 +132,7 @@ Installing to a directory image involves using ``-p`` switch to `upip`::
 
     micropython -m upip install -p install_dir micropython-pystone_lowmem
 
-After this command, the package content (and contents of every depenency
+After this command, the package content (and contents of every dependency
 packages) will be available in the ``install_dir/`` subdirectory. You
 would need to transfer contents of this directory (without the
 ``install_dir/`` prefix) to the device, at the suitable location, where
diff --git a/docs/reference/pyboard.py.rst b/docs/reference/pyboard.py.rst
new file mode 100644
index 0000000000000..d404c738f1d26
--- /dev/null
+++ b/docs/reference/pyboard.py.rst
@@ -0,0 +1,144 @@
+.. _pyboard_py:
+
+The pyboard.py tool
+===================
+
+This is a standalone Python tool that runs on your PC that provides a way to:
+
+* Quickly run a Python script or command on a MicroPython device. This is useful
+  while developing MicroPython programs to quickly test code without needing to
+  copy files to/from the device.
+
+* Access the filesystem on a device. This allows you to deploy your code to the
+  device (even if the board doesn't support USB MSC).
+
+Despite the name, ``pyboard.py`` works on all MicroPython ports that support the
+raw REPL (including STM32, ESP32, ESP8266, NRF).
+
+You can download the latest version from `GitHub
+<https://github.com/micropython/micropython/blob/master/tools/pyboard.py>`_. The
+only dependency is the ``pyserial`` library which can be installed from PiPy or
+your system package manager.
+
+Running ``pyboard.py --help`` gives the following output:
+
+.. code-block:: text
+
+    usage: pyboard [-h] [-d DEVICE] [-b BAUDRATE] [-u USER] [-p PASSWORD]
+                   [-c COMMAND] [-w WAIT] [--follow | --no-follow] [-f]
+                   [files [files ...]]
+
+    Run scripts on the pyboard.
+
+    positional arguments:
+      files                 input files
+
+    optional arguments:
+      -h, --help            show this help message and exit
+      -d DEVICE, --device DEVICE
+                            the serial device or the IP address of the pyboard
+      -b BAUDRATE, --baudrate BAUDRATE
+                            the baud rate of the serial device
+      -u USER, --user USER  the telnet login username
+      -p PASSWORD, --password PASSWORD
+                            the telnet login password
+      -c COMMAND, --command COMMAND
+                            program passed in as string
+      -w WAIT, --wait WAIT  seconds to wait for USB connected board to become
+                            available
+      --follow              follow the output after running the scripts
+                            [default if no scripts given]
+      -f, --filesystem      perform a filesystem action
+
+Running a command on the device
+-------------------------------
+
+This is useful for testing short snippets of code, or to script an interaction
+with the device.::
+
+    $ pyboard.py --device /dev/ttyACM0 -c 'print(1+1)'
+    2
+
+If you are often interacting with the same device, you can set the environment
+variable ``PYBOARD_DEVICE`` as an alternative to using the ``--device``
+command line option.  For example, the following is equivalent to the previous
+example::
+
+    $ export PYBOARD_DEVICE=/dev/ttyACM0
+    $ pyboard.py -c 'print(1+1)'
+
+Similarly, the ``PYBOARD_BAUDRATE`` environment variable can be used
+to set the default for the `--baudrate` option.
+
+Running a script on the device
+------------------------------
+
+If you have a script, ``app.py`` that you want to run on a device, then use::
+
+    $ pyboard.py --device /dev/ttyACM0 app.py
+
+Note that this doesn't actually copy app.py to the device's filesystem, it just
+loads the code into RAM and executes it. Any output generated by the program
+will be displayed.
+
+If the program app.py does not finish then you'll need to stop ``pyboard.py``,
+eg with Ctrl-C. The program ``app.py`` will still continue to run on the
+MicroPython device.
+
+Filesystem access
+-----------------
+
+Using the ``-f`` flag, the following filesystem operations are supported:
+
+* ``cp src [src...] dest`` Copy files to/from the device.
+* ``cat path`` Print the contents of a file on the device.
+* ``ls [path]`` List contents of a directory (defaults to current working directory).
+* ``rm path`` Remove a file.
+* ``mkdir path`` Create a directory.
+* ``rmdir path`` Remove a directory.
+
+The ``cp`` command uses a ``ssh``-like convention for referring to local and
+remote files. Any path starting with a ``:`` will be interpreted as on the
+device, otherwise it will be local. So::
+
+    $ pyboard.py --device /dev/ttyACM0 -f cp main.py :main.py
+
+will copy main.py from the current directory on the PC to a file named main.py
+on the device. The filename can be omitted, e.g.::
+
+    $ pyboard.py --device /dev/ttyACM0 -f cp main.py :
+
+is equivalent to the above.
+
+Some more examples::
+
+    # Copy main.py from the device to the local PC.
+    $ pyboard.py --device /dev/ttyACM0 -f cp :main.py main.py
+    # Same, but using . instead.
+    $ pyboard.py --device /dev/ttyACM0 -f cp :main.py .
+
+    # Copy three files to the device, keeping their names
+    # and paths (note: `lib` must exist on the device)
+    $ pyboard.py --device /dev/ttyACM0 -f cp main.py app.py lib/foo.py :
+
+    # Remove a file from the device.
+    $ pyboard.py --device /dev/ttyACM0 -f rm util.py
+
+    # Print the contents of a file on the device.
+    $ pyboard.py --device /dev/ttyACM0 -f cat boot.py
+    ...contents of boot.py...
+
+Using the pyboard library
+-------------------------
+
+You can also use ``pyboard.py`` as a library for scripting interactions with a
+MicroPython board.
+
+.. code-block:: python
+
+    import pyboard
+    pyb = pyboard.Pyboard('/dev/ttyACM0', 115200)
+    pyb.enter_raw_repl()
+    ret = pyb.exec('print(1+1)')
+    print(ret)
+    pyb.exit_raw_repl()
diff --git a/docs/reference/repl.rst b/docs/reference/repl.rst
index 0c6f04b7c5090..06ba918117f33 100644
--- a/docs/reference/repl.rst
+++ b/docs/reference/repl.rst
@@ -103,7 +103,7 @@ For example:
     KeyboardInterrupt:
     >>>
 
-Paste Mode
+Paste mode
 ----------
 
 If you want to paste some code into your terminal window, the auto-indent feature
@@ -143,7 +143,7 @@ the auto-indent feature, and changes the prompt from ``>>>`` to ``===``. For exa
 Paste Mode allows blank lines to be pasted. The pasted text is compiled as if
 it were a file. Pressing Ctrl-D exits paste mode and initiates the compilation.
 
-Soft Reset
+Soft reset
 ----------
 
 A soft reset will reset the python interpreter, but tries not to reset the
@@ -196,7 +196,7 @@ So you can use the underscore to save the result in a variable. For example:
     15
     >>>
 
-Raw Mode
+Raw mode
 --------
 
 Raw mode is not something that a person would normally use. It is intended for
diff --git a/docs/reference/speed_python.rst b/docs/reference/speed_python.rst
index c5aa80c6e1841..aa9777859242f 100644
--- a/docs/reference/speed_python.rst
+++ b/docs/reference/speed_python.rst
@@ -1,6 +1,6 @@
 .. _speed_python:
 
-Maximising MicroPython Speed
+Maximising MicroPython speed
 ============================
 
 .. contents::
@@ -40,7 +40,7 @@ the best algorithm is employed. This is a topic for textbooks rather than for a
 MicroPython guide but spectacular performance gains can sometimes be achieved
 by adopting algorithms known for their efficiency.
 
-RAM Allocation
+RAM allocation
 ~~~~~~~~~~~~~~
 
 To design efficient MicroPython code it is necessary to have an understanding of the
@@ -69,7 +69,7 @@ example, objects which support stream interface (e.g., file or UART) provide ``r
 method which allocates new buffer for read data, but also a ``readinto()`` method
 to read data into an existing buffer.
 
-Floating Point
+Floating point
 ~~~~~~~~~~~~~~
 
 Some MicroPython ports allocate floating point numbers on heap. Some other ports
@@ -165,7 +165,7 @@ by caching the object in a local variable:
 
     class foo(object):
         def __init__(self):
-            ba = bytearray(100)
+            self.ba = bytearray(100)
         def bar(self, obj_display):
             ba_ref = self.ba
             fb = obj_display.framebuffer
@@ -214,7 +214,7 @@ There are certain limitations in the current implementation of the native code e
 * Generators are not supported.
 * If ``raise`` is used an argument must be supplied.
 
-The trade-off for the improved performance (roughly twices as fast as bytecode) is an
+The trade-off for the improved performance (roughly twice as fast as bytecode) is an
 increase in compiled code size.
 
 The Viper code emitter
@@ -293,10 +293,12 @@ microseconds. The rules for casting are as follows:
 * The argument to a bool cast must be integral type (boolean or integer); when used as a return
   type the viper function will return True or False objects.
 * If the argument is a Python object and the cast is ``ptr``, ``ptr``, ``ptr16`` or ``ptr32``,
-  then the Python object must either have the buffer protocol with read-write capabilities
-  (in which case a pointer to the start of the buffer is returned) or it must be of integral
-  type (in which case the value of that integral object is returned).
- 
+  then the Python object must either have the buffer protocol (in which case a pointer to the
+  start of the buffer is returned) or it must be of integral type (in which case the value of
+  that integral object is returned).
+
+Writing to a pointer which points to a read-only object will lead to undefined behaviour.
+
 The following example illustrates the use of a ``ptr16`` cast to toggle pin X1 ``n`` times:
 
 .. code:: python
diff --git a/docs/templates/topindex.html b/docs/templates/topindex.html
index 08bf4c73e7923..ff766b0cf2ff0 100644
--- a/docs/templates/topindex.html
+++ b/docs/templates/topindex.html
@@ -1,4 +1,5 @@
-{% extends "defindex.html" %}
+{% extends "layout.html" %}
+{% set title = _('Overview') %}
 {% block body %}
 
   <h1>MicroPython documentation</h1>
diff --git a/docs/unix/quickref.rst b/docs/unix/quickref.rst
new file mode 100644
index 0000000000000..ec5312a53515b
--- /dev/null
+++ b/docs/unix/quickref.rst
@@ -0,0 +1,94 @@
+.. _unix_quickref:
+
+Quick reference for the UNIX and Windows ports
+==============================================
+
+Command line options
+--------------------
+
+Usage::
+
+    micropython [ -h ] [ -i ] [ -O<level> ] [ -v ] [ -X <option> ] [ -c <command> | -m <module> | <script> ] [ <args> ]
+
+
+Invocation options:
+
+.. option:: -c <command>
+
+   Runs the code in ``<command>``. The code can be one or more Python statements.
+
+.. option:: -m <module>
+
+   Runs the module ``<module>``. The module must be in ``sys.path``.
+
+.. option:: <script>
+
+   Runs the file ``<script>``. The script must be a valid MicroPython source
+   code file.
+
+If none of the 3 options above are given, then MicroPython is run in an
+interactive REPL mode.
+
+
+.. option:: <args>
+
+    Any additional arguments after the module or script will be passed to
+    ``sys.argv`` (not supported with the :option:`-c` option).
+
+
+General options:
+
+.. option:: -h
+
+    Prints a help message containing the command line usage and exits.
+
+.. option:: -i
+
+    Enables inspection. When this flag is set, MicroPython will enter the
+    interactive REPL mode after the command, module or script has finished.
+    This can be useful for debugging the state after an unhandled exception.
+    Also see the :envvar:`MICROPYINSPECT` environment variable.
+
+.. option:: -O | -O<level> | -OO...
+
+    Sets the optimization level. The ``O`` can be followed by a number or can
+    be repeated multiple times to indicate the level. E.g. ``-O3`` is the same
+    as ``-OOO``.
+
+.. option:: -v
+
+    Increases the verbosity level. This option can be given multiple times.
+    This option only has an effect if ``MICROPY_DEBUG_PRINTERS`` was enabled
+    when MicroPython itself was compiled.
+
+.. option:: -X <option>
+
+    Specifies additional implementation-specific options. Possible options are:
+
+    - ``-X compile-only`` compiles the command, module or script but does not
+      run it.
+    - ``-X emit={bytecode,native,viper}`` sets the default code emitter. Native
+      emitters may not be available depending on the settings when MicroPython
+      itself was compiled.
+    - ``-X heapsize=<n>[w][K|M]`` sets the heap size for the garbage collector.
+      The suffix ``w`` means words instead of bytes. ``K`` means x1024 and ``M``
+      means x1024x1024.
+
+
+
+Environment variables
+---------------------
+
+.. envvar:: MICROPYPATH
+
+    Overrides the default search path for MicroPython libraries. ``MICROPYPATH``
+    should be set to a colon (semicolon for Windows port) separated list of
+    directories. If ``MICROPYPATH`` is not defined, the search path will be
+    ``~/.micropython/lib:/usr/lib/micropython`` (``~/.micropython/lib`` for Windows port)
+    or the value of the ``MICROPY_PY_SYS_PATH_DEFAULT`` option if it was set
+    when MicroPython itself was compiled.
+
+.. envvar:: MICROPYINSPECT
+
+    Enables inspection. If ``MICROPYINSPECT`` is set to a non-empty string, it
+    has the same effect as setting the :option:`-i` command line option.
diff --git a/docs/wipy/quickref.rst b/docs/wipy/quickref.rst
index 7aa832fd2529b..a22ea45b55149 100644
--- a/docs/wipy/quickref.rst
+++ b/docs/wipy/quickref.rst
@@ -62,7 +62,7 @@ Timer ``id``'s take values from 0 to 3.::
     tim = Timer(0, mode=Timer.PERIODIC)
     tim_a = tim.channel(Timer.A, freq=1000)
     tim_a.freq(5) # 5 Hz
-    
+
     p_out = Pin('GP2', mode=Pin.OUT)
     tim_a.irq(trigger=Timer.TIMEOUT, handler=lambda t: p_out.toggle())
 
@@ -75,14 +75,14 @@ See :ref:`machine.Pin <machine.Pin>` and :ref:`machine.Timer <machine.Timer>`. :
 
     # timer 1 in PWM mode and width must be 16 buts
     tim = Timer(1, mode=Timer.PWM, width=16)
-    
+
     # enable channel A @1KHz with a 50.55% duty cycle
     tim_a = tim.channel(Timer.A, freq=1000, duty_cycle=5055)
 
 ADC (analog to digital conversion)
 ----------------------------------
 
-See :ref:`machine.ADC <machine.ADC>`. ::
+See :ref:`machine.ADCWiPy <machine.ADCWiPy>`. ::
 
     from machine import ADC
 
diff --git a/docs/wipy/tutorial/blynk.rst b/docs/wipy/tutorial/blynk.rst
index b5a2f24a472cb..b34ea17ae1cb5 100644
--- a/docs/wipy/tutorial/blynk.rst
+++ b/docs/wipy/tutorial/blynk.rst
@@ -1,19 +1,17 @@
 Getting started with Blynk and the WiPy
 ---------------------------------------
 
-Blynk is a platform with iOS and Android apps to control
-Arduino, Raspberry Pi and the likes over the Internet.
-You can easily build graphic interfaces for all your
-projects by simply dragging and dropping widgets.
+Blynk provides iOS and Android apps to control any hardware over the Internet
+or directly using Bluetooth. You can easily build graphic interfaces for all
+your projects by simply dragging and dropping widgets, right on your smartphone.
 
-There are several examples available that work out-of-the-box with
-the WiPy. Before anything else, make sure that your WiPy is running
+Before anything else, make sure that your WiPy is running
 the latest software, check :ref:`OTA How-To <wipy_firmware_upgrade>` for instructions.
 
-1. Get the `Blynk library <https://github.com/wipy/wipy/blob/master/lib/blynk/BlynkLib.py>`_ and put it in ``/flash/lib/`` via FTP.
-2. Get the `Blynk examples <https://github.com/wipy/wipy/tree/master/examples/blynk>`_, edit the network settings, and afterwards
-   upload them to ``/flash/lib/`` via FTP as well.
+1. Get the `Blynk library <https://github.com/vshymanskyy/blynk-library-python/blob/master/BlynkLib.py>`_ and put it in ``/flash/lib/`` via FTP.
+2. Get the `Blynk example for WiPy <https://github.com/vshymanskyy/blynk-library-python/blob/master/examples/hardware/PyCom_WiPy.py>`_, edit the network settings, and afterwards
+   upload it to ``/flash/`` via FTP as well.
 3. Follow the instructions on each example to setup the Blynk dashboard on your smartphone or tablet.
 4. Give it a try, for instance::
 
-   >>> execfile('01_simple.py')
+   >>> execfile('sync_virtual.py')
diff --git a/docs/wipy/tutorial/repl.rst b/docs/wipy/tutorial/repl.rst
index 8c60e2c1d134b..95b545d097830 100644
--- a/docs/wipy/tutorial/repl.rst
+++ b/docs/wipy/tutorial/repl.rst
@@ -51,7 +51,7 @@ Open a terminal and run::
 or::
 
     $ screen /dev/tty.usbmodem* 115200
-    
+
 When you are finished and want to exit ``screen``, type CTRL-A CTRL-\\. If your keyboard does not have a \\-key (i.e. you need an obscure combination for \\ like ALT-SHIFT-7) you can remap the ``quit`` command:
 
 - create ``~/.screenrc``
diff --git a/drivers/bus/qspi.h b/drivers/bus/qspi.h
index 31c9d14fca9e3..c82796fac5013 100644
--- a/drivers/bus/qspi.h
+++ b/drivers/bus/qspi.h
@@ -28,6 +28,8 @@
 
 #include "py/mphal.h"
 
+#define MP_SPI_ADDR_IS_32B(addr) (addr & 0xff000000)
+
 enum {
     MP_QSPI_IOCTL_INIT,
     MP_QSPI_IOCTL_DEINIT,
@@ -54,4 +56,19 @@ typedef struct _mp_soft_qspi_obj_t {
 
 extern const mp_qspi_proto_t mp_soft_qspi_proto;
 
+static inline uint8_t mp_spi_set_addr_buff(uint8_t *buf, uint32_t addr) {
+    if (MP_SPI_ADDR_IS_32B(addr)) {
+        buf[0] = addr >> 24;
+        buf[1] = addr >> 16;
+        buf[2] = addr >> 8;
+        buf[3] = addr;
+        return 4;
+    } else {
+        buf[0] = addr >> 16;
+        buf[1] = addr >> 8;
+        buf[2] = addr;
+        return 3;
+    }
+}
+
 #endif // MICROPY_INCLUDED_DRIVERS_BUS_QSPI_H
diff --git a/drivers/bus/softqspi.c b/drivers/bus/softqspi.c
index 10c5992466d82..71ab559768b1b 100644
--- a/drivers/bus/softqspi.c
+++ b/drivers/bus/softqspi.c
@@ -168,9 +168,10 @@ STATIC void mp_soft_qspi_write_cmd_data(void *self_in, uint8_t cmd, size_t len,
 
 STATIC void mp_soft_qspi_write_cmd_addr_data(void *self_in, uint8_t cmd, uint32_t addr, size_t len, const uint8_t *src) {
     mp_soft_qspi_obj_t *self = (mp_soft_qspi_obj_t*)self_in;
-    uint8_t cmd_buf[4] = {cmd, addr >> 16, addr >> 8, addr};
+    uint8_t cmd_buf[5] = {cmd};
+    uint8_t addr_len = mp_spi_set_addr_buff(&cmd_buf[1], addr);
     CS_LOW(self);
-    mp_soft_qspi_transfer(self, 4, cmd_buf, NULL);
+    mp_soft_qspi_transfer(self, addr_len + 1, cmd_buf, NULL);
     mp_soft_qspi_transfer(self, len, src, NULL);
     CS_HIGH(self);
 }
@@ -186,10 +187,11 @@ STATIC uint32_t mp_soft_qspi_read_cmd(void *self_in, uint8_t cmd, size_t len) {
 
 STATIC void mp_soft_qspi_read_cmd_qaddr_qdata(void *self_in, uint8_t cmd, uint32_t addr, size_t len, uint8_t *dest) {
     mp_soft_qspi_obj_t *self = (mp_soft_qspi_obj_t*)self_in;
-    uint8_t cmd_buf[7] = {cmd, addr >> 16, addr >> 8, addr};
+    uint8_t cmd_buf[7] = {cmd};
+    uint8_t addr_len = mp_spi_set_addr_buff(&cmd_buf[1], addr);
     CS_LOW(self);
     mp_soft_qspi_transfer(self, 1, cmd_buf, NULL);
-    mp_soft_qspi_qwrite(self, 6, &cmd_buf[1]); // 3 addr bytes, 1 extra byte (0), 2 dummy bytes (4 dummy cycles)
+    mp_soft_qspi_qwrite(self, addr_len + 3, &cmd_buf[1]); // 3/4 addr bytes, 1 extra byte (0), 2 dummy bytes (4 dummy cycles)
     mp_soft_qspi_qread(self, len, dest);
     CS_HIGH(self);
 }
diff --git a/drivers/cyw43/README.md b/drivers/cyw43/README.md
new file mode 100644
index 0000000000000..5af6f65580668
--- /dev/null
+++ b/drivers/cyw43/README.md
@@ -0,0 +1,17 @@
+CYW43xx WiFi SoC driver
+=======================
+
+This is a driver for the CYW43xx WiFi SoC.
+
+There are four layers to the driver:
+
+1. SDIO bus interface, provided by the host device/system.
+
+2. Low-level CYW43xx interface, managing the bus, control messages, Ethernet
+   frames and asynchronous events.  Includes download of SoC firmware.  The
+   header file `cyw43_ll.h` defines the interface to this layer.
+
+3. Mid-level CYW43xx control, to control and set WiFi parameters and manage
+   events.  See `cyw43_ctrl.c`.
+
+4. TCP/IP bindings to lwIP.  See `cyw43_lwip.c`.
diff --git a/drivers/cyw43/cyw43.h b/drivers/cyw43/cyw43.h
new file mode 100644
index 0000000000000..d7f08cb5dfeed
--- /dev/null
+++ b/drivers/cyw43/cyw43.h
@@ -0,0 +1,135 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_STM32_CYW43_H
+#define MICROPY_INCLUDED_STM32_CYW43_H
+
+#include "lwip/netif.h"
+#include "lwip/dhcp.h"
+#include "lib/netutils/dhcpserver.h"
+#include "drivers/cyw43/cyw43_ll.h"
+
+// For trace_flags
+#define CYW43_TRACE_ASYNC_EV    (0x0001)
+#define CYW43_TRACE_ETH_TX      (0x0002)
+#define CYW43_TRACE_ETH_RX      (0x0004)
+#define CYW43_TRACE_ETH_FULL    (0x0008)
+#define CYW43_TRACE_MAC         (0x0010)
+
+// Return value of cyw43_wifi_link_status
+#define CYW43_LINK_DOWN         (0)
+#define CYW43_LINK_JOIN         (1)
+#define CYW43_LINK_NOIP         (2)
+#define CYW43_LINK_UP           (3)
+#define CYW43_LINK_FAIL         (-1)
+#define CYW43_LINK_NONET        (-2)
+#define CYW43_LINK_BADAUTH      (-3)
+
+typedef struct _cyw43_t {
+    cyw43_ll_t cyw43_ll;
+
+    uint8_t itf_state;
+    uint32_t trace_flags;
+
+    // State for async events
+    volatile uint32_t wifi_scan_state;
+    uint32_t wifi_join_state;
+    void *wifi_scan_env;
+    int (*wifi_scan_cb)(void*, const cyw43_ev_scan_result_t*);
+
+    // Pending things to do
+    bool pend_disassoc;
+    bool pend_rejoin;
+    bool pend_rejoin_wpa;
+
+    // AP settings
+    uint8_t ap_channel;
+    uint8_t ap_auth;
+    uint8_t ap_ssid_len;
+    uint8_t ap_key_len;
+    uint8_t ap_ssid[32];
+    uint8_t ap_key[64];
+
+    // lwIP data
+    struct netif netif[2];
+    struct dhcp dhcp_client;
+    dhcp_server_t dhcp_server;
+} cyw43_t;
+
+extern cyw43_t cyw43_state;
+extern void (*cyw43_poll)(void);
+extern uint32_t cyw43_sleep;
+
+void cyw43_init(cyw43_t *self);
+void cyw43_deinit(cyw43_t *self);
+
+int cyw43_ioctl(cyw43_t *self, uint32_t cmd, size_t len, uint8_t *buf, uint32_t iface);
+int cyw43_send_ethernet(cyw43_t *self, int itf, size_t len, const void *buf, bool is_pbuf);
+
+int cyw43_wifi_pm(cyw43_t *self, uint32_t pm);
+int cyw43_wifi_link_status(cyw43_t *self, int itf);
+void cyw43_wifi_set_up(cyw43_t *self, int itf, bool up);
+int cyw43_wifi_get_mac(cyw43_t *self, int itf, uint8_t mac[6]);
+int cyw43_wifi_scan(cyw43_t *self, cyw43_wifi_scan_options_t *opts, void *env, int (*result_cb)(void*, const cyw43_ev_scan_result_t*));
+
+static inline bool cyw43_wifi_scan_active(cyw43_t *self) {
+    return self->wifi_scan_state == 1;
+}
+
+int cyw43_wifi_join(cyw43_t *self, size_t ssid_len, const uint8_t *ssid, size_t key_len, const uint8_t *key, uint32_t auth_type, const uint8_t *bssid, uint32_t channel);
+int cyw43_wifi_leave(cyw43_t *self, int itf);
+
+static inline void cyw43_wifi_ap_get_ssid(cyw43_t *self, size_t *len, const uint8_t **buf) {
+    *len = self->ap_ssid_len;
+    *buf = self->ap_ssid;
+}
+
+static inline void cyw43_wifi_ap_set_channel(cyw43_t *self, uint32_t channel) {
+    self->ap_channel = channel;
+}
+
+static inline void cyw43_wifi_ap_set_ssid(cyw43_t *self, size_t len, const uint8_t *buf) {
+    self->ap_ssid_len = MIN(len, sizeof(self->ap_ssid));
+    memcpy(self->ap_ssid, buf, self->ap_ssid_len);
+}
+
+static inline void cyw43_wifi_ap_set_password(cyw43_t *self, size_t len, const uint8_t *buf) {
+    self->ap_key_len = MIN(len, sizeof(self->ap_key));
+    memcpy(self->ap_key, buf, self->ap_key_len);
+}
+
+static inline void cyw43_wifi_ap_set_auth(cyw43_t *self, uint32_t auth) {
+    self->ap_auth = auth;
+}
+
+void cyw43_wifi_ap_get_stas(cyw43_t *self, int *num_stas, uint8_t *macs);
+
+void cyw43_tcpip_init(cyw43_t *self, int itf);
+void cyw43_tcpip_deinit(cyw43_t *self, int itf);
+void cyw43_tcpip_set_link_up(cyw43_t *self, int itf);
+void cyw43_tcpip_set_link_down(cyw43_t *self, int itf);
+int cyw43_tcpip_link_status(cyw43_t *self, int itf);
+
+#endif // MICROPY_INCLUDED_STM32_CYW43_H
diff --git a/drivers/cyw43/cyw43_ctrl.c b/drivers/cyw43/cyw43_ctrl.c
new file mode 100644
index 0000000000000..cc1fbecde8a4e
--- /dev/null
+++ b/drivers/cyw43/cyw43_ctrl.c
@@ -0,0 +1,591 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "py/mphal.h"
+#include "drivers/cyw43/cyw43.h"
+#include "pendsv.h"
+#include "sdio.h"
+
+#define CYW_ENTER MICROPY_PY_LWIP_ENTER
+#define CYW_EXIT MICROPY_PY_LWIP_EXIT
+
+#ifdef pyb_pin_WL_HOST_WAKE
+#define USE_SDIOIT (0)
+#else
+#define USE_SDIOIT (1)
+#endif
+
+#define CYW43_SLEEP_MAX (50)
+
+#define WIFI_JOIN_STATE_ACTIVE  (0x0001)
+#define WIFI_JOIN_STATE_FAIL    (0x0002)
+#define WIFI_JOIN_STATE_NONET   (0x0003)
+#define WIFI_JOIN_STATE_BADAUTH (0x0004)
+#define WIFI_JOIN_STATE_AUTH    (0x0200)
+#define WIFI_JOIN_STATE_LINK    (0x0400)
+#define WIFI_JOIN_STATE_KEYED   (0x0800)
+#define WIFI_JOIN_STATE_ALL     (0x0e01)
+
+cyw43_t cyw43_state;
+void (*cyw43_poll)(void);
+uint32_t cyw43_sleep;
+
+STATIC void cyw43_poll_func(void);
+STATIC void cyw43_wifi_ap_init(cyw43_t *self);
+STATIC void cyw43_wifi_ap_set_up(cyw43_t *self, bool up);
+
+static inline uint32_t cyw43_get_be16(const uint8_t *buf) {
+    return buf[0] << 8 | buf[1];
+}
+
+static inline uint32_t cyw43_get_be32(const uint8_t *buf) {
+    return buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3];
+}
+
+static inline void cyw43_delay_ms(uint32_t ms) {
+    mp_hal_delay_ms(ms);
+}
+
+/*******************************************************************************/
+// Initialisation and polling
+
+void cyw43_init(cyw43_t *self) {
+    #ifdef pyb_pin_WL_HOST_WAKE
+    mp_hal_pin_config(pyb_pin_WL_HOST_WAKE, MP_HAL_PIN_MODE_INPUT, MP_HAL_PIN_PULL_NONE, 0);
+    #endif
+    mp_hal_pin_config(pyb_pin_WL_REG_ON, MP_HAL_PIN_MODE_OUTPUT, MP_HAL_PIN_PULL_NONE, 0);
+    mp_hal_pin_low(pyb_pin_WL_REG_ON);
+    #ifdef pyb_pin_WL_RFSW_VDD
+    mp_hal_pin_config(pyb_pin_WL_RFSW_VDD, MP_HAL_PIN_MODE_OUTPUT, MP_HAL_PIN_PULL_NONE, 0); // RF-switch power
+    mp_hal_pin_low(pyb_pin_WL_RFSW_VDD);
+    #endif
+
+    cyw43_ll_init(&self->cyw43_ll, self);
+
+    self->itf_state = 0;
+    self->wifi_scan_state = 0;
+    self->wifi_join_state = 0;
+    self->pend_disassoc = false;
+    self->pend_rejoin= false;
+    self->pend_rejoin_wpa = false;
+    self->ap_channel = 3;
+    self->ap_ssid_len = 0;
+    self->ap_key_len = 0;
+
+    cyw43_poll = NULL;
+}
+
+void cyw43_deinit(cyw43_t *self) {
+    CYW_ENTER
+
+    cyw43_ll_bus_sleep(&self->cyw43_ll, true);
+    cyw43_delay_ms(2);
+    cyw43_tcpip_deinit(self, 0);
+    cyw43_tcpip_deinit(self, 1);
+
+    self->itf_state = 0;
+
+    // Disable async polling
+    SDMMC1->MASK &= ~SDMMC_MASK_SDIOITIE;
+    cyw43_poll = NULL;
+
+    #ifdef pyb_pin_WL_RFSW_VDD
+    // Turn the RF-switch off
+    mp_hal_pin_low(pyb_pin_WL_RFSW_VDD);
+    #endif
+
+    // Power down the WL chip and the SDIO bus
+    mp_hal_pin_low(pyb_pin_WL_REG_ON);
+    sdio_deinit();
+
+    CYW_EXIT
+}
+
+STATIC int cyw43_ensure_up(cyw43_t *self) {
+    if (cyw43_poll != NULL) {
+        cyw43_ll_bus_sleep(&self->cyw43_ll, false);
+        return 0;
+    }
+
+    CYW_ENTER
+
+    // Disable the netif if it was previously up
+    cyw43_tcpip_deinit(self, CYW43_ITF_STA);
+    cyw43_tcpip_deinit(self, CYW43_ITF_AP);
+    self->itf_state = 0;
+
+    // Reset and power up the WL chip
+    mp_hal_pin_low(pyb_pin_WL_REG_ON);
+    cyw43_delay_ms(20);
+    mp_hal_pin_high(pyb_pin_WL_REG_ON);
+    cyw43_delay_ms(50);
+
+    // Initialise SDIO bus
+    // IRQ priority only needs to be higher than CYW_ENTER/EXIT protection (PENDSV)
+    sdio_init(NVIC_EncodePriority(NVIC_PRIORITYGROUP_4, 14, 0));
+
+    // Initialise the low-level driver
+    uint8_t mac[6];
+    mp_hal_get_mac(MP_HAL_MAC_WLAN0, mac);
+    int ret = cyw43_ll_bus_init(&self->cyw43_ll, mac);
+
+    if (ret != 0) {
+        CYW_EXIT
+        return ret;
+    }
+
+    // Enable async events from low-level driver
+    cyw43_sleep = CYW43_SLEEP_MAX;
+    cyw43_poll = cyw43_poll_func;
+    #if USE_SDIOIT
+    SDMMC1->MASK |= SDMMC_MASK_SDIOITIE;
+    #else
+    extern void extint_set(const pin_obj_t *pin, uint32_t mode);
+    extint_set(pyb_pin_WL_HOST_WAKE, GPIO_MODE_IT_FALLING);
+    #endif
+
+    CYW_EXIT
+
+    return ret;
+}
+
+// This function must always be executed at the level where CYW_ENTER is effectively active
+STATIC void cyw43_poll_func(void) {
+    if (cyw43_poll == NULL) {
+        // Poll scheduled during deinit, just ignore it
+        return;
+    }
+
+    cyw43_t *self = &cyw43_state;
+    cyw43_ll_process_packets(&self->cyw43_ll);
+
+    if (self->pend_disassoc) {
+        self->pend_disassoc = false;
+        cyw43_ll_ioctl(&self->cyw43_ll, CYW43_IOCTL_SET_DISASSOC, 0, NULL, CYW43_ITF_STA);
+    }
+
+    if (self->pend_rejoin_wpa) {
+        self->pend_rejoin_wpa = false;
+        cyw43_ll_wifi_set_wpa_auth(&self->cyw43_ll);
+    }
+
+    if (self->pend_rejoin) {
+        self->pend_rejoin = false;
+        cyw43_ll_wifi_rejoin(&self->cyw43_ll);
+        self->wifi_join_state = WIFI_JOIN_STATE_ACTIVE;
+    }
+
+    if (cyw43_sleep == 0) {
+        cyw43_ll_bus_sleep(&self->cyw43_ll, true);
+        #if !USE_SDIOIT
+        sdio_deinit(); // save power while WLAN bus sleeps
+        #endif
+    }
+
+    #if USE_SDIOIT
+    SDMMC1->MASK |= SDMMC_MASK_SDIOITIE;
+    #endif
+}
+
+/*******************************************************************************/
+// Callback interface to low-level driver
+
+int cyw43_cb_read_host_interrupt_pin(void *cb_data) {
+    #ifdef pyb_pin_WL_HOST_WAKE
+    return mp_hal_pin_read(pyb_pin_WL_HOST_WAKE);
+    #else
+    return mp_hal_pin_read(pyb_pin_WL_SDIO_1);
+    #endif
+}
+
+void cyw43_cb_ensure_awake(void *cb_data) {
+    cyw43_sleep = CYW43_SLEEP_MAX;
+    #if !USE_SDIOIT
+    if (__HAL_RCC_SDMMC1_IS_CLK_DISABLED()) {
+        __HAL_RCC_SDMMC1_CLK_ENABLE(); // enable SDIO peripheral
+        sdio_enable_high_speed_4bit();
+    }
+    #endif
+}
+
+STATIC const char *cyw43_async_event_name_table[89] = {
+    [0 ... 88] = NULL,
+    [CYW43_EV_SET_SSID] = "SET_SSID",
+    [CYW43_EV_JOIN] = "JOIN",
+    [CYW43_EV_AUTH] = "AUTH",
+    [CYW43_EV_DEAUTH_IND] = "DEAUTH_IND",
+    [CYW43_EV_ASSOC] = "ASSOC",
+    [CYW43_EV_DISASSOC] = "DISASSOC",
+    [CYW43_EV_DISASSOC_IND] = "DISASSOC_IND",
+    [CYW43_EV_LINK] = "LINK",
+    [CYW43_EV_PSK_SUP] = "PSK_SUP",
+    [CYW43_EV_ESCAN_RESULT] = "ESCAN_RESULT",
+    [CYW43_EV_CSA_COMPLETE_IND] = "CSA_COMPLETE_IND",
+    [CYW43_EV_ASSOC_REQ_IE] = "ASSOC_REQ_IE",
+    [CYW43_EV_ASSOC_RESP_IE] = "ASSOC_RESP_IE",
+};
+
+STATIC void cyw43_dump_async_event(const cyw43_async_event_t *ev) {
+    printf("[% 8d] ASYNC(%04x,",
+        (int)mp_hal_ticks_ms(),
+        (unsigned int)ev->flags
+    );
+    if (ev->event_type < MP_ARRAY_SIZE(cyw43_async_event_name_table)
+        && cyw43_async_event_name_table[ev->event_type] != NULL) {
+        printf("%s", cyw43_async_event_name_table[ev->event_type]);
+    } else {
+        printf("%u", (unsigned int)ev->event_type);
+    }
+    printf(",%u,%u,%u)\n",
+        (unsigned int)ev->status,
+        (unsigned int)ev->reason,
+        (unsigned int)ev->interface
+    );
+}
+
+void cyw43_cb_process_async_event(void *cb_data, const cyw43_async_event_t *ev) {
+    cyw43_t *self = cb_data;
+
+    if (self->trace_flags & CYW43_TRACE_ASYNC_EV) {
+        cyw43_dump_async_event(ev);
+    }
+
+    if (ev->event_type == CYW43_EV_ESCAN_RESULT && self->wifi_scan_state == 1) {
+        // Escan result event
+        if (ev->status == 8) {
+            // Partial result
+            int ret = self->wifi_scan_cb(self->wifi_scan_env, &ev->u.scan_result);
+            if (ret != 0) {
+                // TODO need to abort scan, or just ignore any more results
+            }
+        } else if (ev->status == 0) {
+            // Scan complete
+            self->wifi_scan_state = 2;
+        }
+
+    } else if (ev->event_type == CYW43_EV_DISASSOC) {
+        cyw43_tcpip_set_link_down(self, CYW43_ITF_STA);
+        self->wifi_join_state = 0x0000;
+
+    /*
+    } else if (ev->event_type == CYW43_EV_DISASSOC_IND) {
+        if (ev->interface == CYW43_ITF_AP) {
+            // Station disassociated with our AP, let DHCP server know so it can free the IP address
+            dhcp_server_disassoc(&self->dhcp_server, buf + 24);
+        }
+    */
+
+    // WiFi join events
+    } else if (ev->event_type == CYW43_EV_PRUNE) {
+        if (ev->status == 0 && ev->reason == 8) {
+            // RSN mismatch, retry join with WPA auth
+            self->pend_rejoin = true;
+            self->pend_rejoin_wpa = true;
+            pendsv_schedule_dispatch(PENDSV_DISPATCH_CYW43, cyw43_poll_func);
+        }
+    } else if (ev->event_type == CYW43_EV_SET_SSID) {
+        if (ev->status == 0) {
+            // Success setting SSID
+        } else if (ev->status == 3 && ev->reason == 0) {
+            self->wifi_join_state = WIFI_JOIN_STATE_NONET;
+            // No matching SSID found (could be out of range, or down)
+        } else {
+            // Other failure setting SSID
+            self->wifi_join_state = WIFI_JOIN_STATE_FAIL;
+        }
+    } else if (ev->event_type == CYW43_EV_AUTH) {
+        if (ev->status == 0) {
+            self->wifi_join_state |= WIFI_JOIN_STATE_AUTH;
+        } else if (ev->status == 6) {
+            // Unsolicited auth packet, ignore it
+        } else {
+            // Cannot authenticate
+            self->wifi_join_state = WIFI_JOIN_STATE_BADAUTH;
+        }
+    } else if (ev->event_type == CYW43_EV_DEAUTH_IND) {
+        if (ev->status == 0 && ev->reason == 2) {
+            // Deauth, probably because password was wrong; disassociate
+            self->pend_disassoc = true;
+            pendsv_schedule_dispatch(PENDSV_DISPATCH_CYW43, cyw43_poll_func);
+        }
+    } else if (ev->event_type == CYW43_EV_LINK) {
+        if (ev->status == 0) {
+            if (ev->flags & 1) {
+                // Link is up
+                if (ev->interface == CYW43_ITF_STA) {
+                    self->wifi_join_state |= WIFI_JOIN_STATE_LINK;
+                } else {
+                    cyw43_tcpip_set_link_up(self, ev->interface);
+                }
+            } else {
+                // Link is down
+                cyw43_tcpip_set_link_down(self, ev->interface);
+            }
+        }
+    } else if (ev->event_type == CYW43_EV_PSK_SUP) {
+        if (ev->status == 6) { // WLC_SUP_KEYED
+            self->wifi_join_state |= WIFI_JOIN_STATE_KEYED;
+        } else if ((ev->status == 4 || ev->status == 8 || ev->status == 11) && ev->reason == 15) {
+            // Timeout waiting for key exchange M1/M3/G1
+            // Probably at edge of the cell, retry
+            self->pend_rejoin = true;
+            pendsv_schedule_dispatch(PENDSV_DISPATCH_CYW43, cyw43_poll_func);
+        } else {
+            // PSK_SUP failure
+            self->wifi_join_state = WIFI_JOIN_STATE_BADAUTH;
+        }
+    }
+
+    if (self->wifi_join_state == WIFI_JOIN_STATE_ALL) {
+        // STA connected
+        self->wifi_join_state = WIFI_JOIN_STATE_ACTIVE;
+        cyw43_tcpip_set_link_up(self, CYW43_ITF_STA);
+    }
+}
+
+/*******************************************************************************/
+// Ioctl and Ethernet interface
+
+int cyw43_ioctl(cyw43_t *self, uint32_t cmd, size_t len, uint8_t *buf, uint32_t iface) {
+    int ret = cyw43_ensure_up(self);
+    if (ret) {
+        return ret;
+    }
+
+    CYW_ENTER
+    ret = cyw43_ll_ioctl(&self->cyw43_ll, cmd, len, buf, iface);
+    CYW_EXIT
+
+    return ret;
+}
+
+int cyw43_send_ethernet(cyw43_t *self, int itf, size_t len, const void *buf, bool is_pbuf) {
+    int ret = cyw43_ensure_up(self);
+    if (ret) {
+        return ret;
+    }
+
+    CYW_ENTER
+    ret = cyw43_ll_send_ethernet(&self->cyw43_ll, itf, len, buf, is_pbuf);
+    CYW_EXIT
+
+    return ret;
+}
+
+/*******************************************************************************/
+// WiFi control
+
+STATIC int cyw43_wifi_on(cyw43_t *self, uint32_t country) {
+    int ret = cyw43_ensure_up(self);
+    if (ret) {
+        return ret;
+    }
+
+    #ifdef pyb_pin_WL_RFSW_VDD
+    // Turn the RF-switch on
+    mp_hal_pin_high(pyb_pin_WL_RFSW_VDD);
+    #endif
+
+    CYW_ENTER
+    ret = cyw43_ll_wifi_on(&self->cyw43_ll, country);
+    CYW_EXIT
+
+    return ret;
+}
+
+int cyw43_wifi_pm(cyw43_t *self, uint32_t pm_in) {
+    int ret = cyw43_ensure_up(self);
+    if (ret) {
+        return ret;
+    }
+
+    // pm_in: 0x00adbrrm
+    uint32_t pm = pm_in & 0xf;
+    uint32_t pm_sleep_ret = (pm_in >> 4) & 0xff;
+    uint32_t li_bcn = (pm_in >> 12) & 0xf;
+    uint32_t li_dtim = (pm_in >> 16) & 0xf;
+    uint32_t li_assoc = (pm_in >> 20) & 0xf;
+
+    CYW_ENTER
+    ret = cyw43_ll_wifi_pm(&self->cyw43_ll, pm, pm_sleep_ret, li_bcn, li_dtim, li_assoc);
+    CYW_EXIT
+
+    return ret;
+}
+
+int cyw43_wifi_get_mac(cyw43_t *self, int itf, uint8_t mac[6]) {
+    mp_hal_get_mac(MP_HAL_MAC_WLAN0, &mac[0]);
+    return 0;
+}
+
+#define MAKE_COUNTRY(a, b, rev) ((a) | (b) << 8 | (rev) << 16)
+
+void cyw43_wifi_set_up(cyw43_t *self, int itf, bool up) {
+    if (up) {
+        if (self->itf_state == 0) {
+            uint32_t country;
+            extern char pyb_country_code[2];
+            if (pyb_country_code[0] == '\0' || pyb_country_code[1] == '\0') {
+                country = MAKE_COUNTRY('X', 'X', 17); // default to world-wide (passive ch 12-14)
+            } else {
+                country = MAKE_COUNTRY(pyb_country_code[0], pyb_country_code[1], 0);
+            }
+            if (cyw43_wifi_on(self, country) != 0) {
+                return;
+            }
+            cyw43_wifi_pm(self, 10 << 20 | 1 << 16 | 1 << 12 | 20 << 4 | 2);
+        }
+        if (itf == CYW43_ITF_AP) {
+            cyw43_wifi_ap_init(self);
+            cyw43_wifi_ap_set_up(self, true);
+        }
+        if ((self->itf_state & (1 << itf)) == 0) {
+            CYW_ENTER
+            cyw43_tcpip_deinit(self, itf);
+            cyw43_tcpip_init(self, itf);
+            self->itf_state |= 1 << itf;
+            CYW_EXIT
+        }
+    } else {
+        if (itf == CYW43_ITF_AP) {
+            cyw43_wifi_ap_set_up(self, false);
+        }
+    }
+}
+
+int cyw43_wifi_scan(cyw43_t *self, cyw43_wifi_scan_options_t *opts, void *env, int (*result_cb)(void*, const cyw43_ev_scan_result_t*)) {
+    if (self->itf_state == 0) {
+        return -1;
+    }
+
+    cyw43_ensure_up(self);
+
+    CYW_ENTER
+
+    // Set state and callback data
+    self->wifi_scan_state = 1;
+    self->wifi_scan_env = env;
+    self->wifi_scan_cb = result_cb;
+
+    // Start the scan
+    int ret = cyw43_ll_wifi_scan(&self->cyw43_ll, opts);
+
+    CYW_EXIT
+
+    return ret;
+}
+
+int cyw43_wifi_link_status(cyw43_t *self, int itf) {
+    if (itf == CYW43_ITF_STA) {
+        int s = self->wifi_join_state & 0xf;
+        if (s == WIFI_JOIN_STATE_ACTIVE) {
+            return CYW43_LINK_JOIN;
+        } else if (s == WIFI_JOIN_STATE_FAIL) {
+            return CYW43_LINK_FAIL;
+        } else if (s == WIFI_JOIN_STATE_NONET) {
+            return CYW43_LINK_NONET;
+        } else if (s == WIFI_JOIN_STATE_BADAUTH) {
+            return CYW43_LINK_BADAUTH;
+        } else {
+            return CYW43_LINK_DOWN;
+        }
+    } else {
+        return CYW43_LINK_DOWN;
+    }
+}
+
+/*******************************************************************************/
+// WiFi STA
+
+int cyw43_wifi_join(cyw43_t *self, size_t ssid_len, const uint8_t *ssid, size_t key_len, const uint8_t *key, uint32_t auth_type, const uint8_t *bssid, uint32_t channel) {
+    int ret = cyw43_ensure_up(self);
+    if (ret) {
+        return ret;
+    }
+
+    CYW_ENTER
+
+    ret = cyw43_ll_wifi_join(&self->cyw43_ll, ssid_len, ssid, key_len, key, auth_type, bssid, channel);
+
+    if (ret == 0) {
+        // Wait for responses: EV_AUTH, EV_LINK, EV_SET_SSID, EV_PSK_SUP
+        // Will get EV_DEAUTH_IND if password is invalid
+        self->wifi_join_state = WIFI_JOIN_STATE_ACTIVE;
+
+        if (auth_type == 0) {
+            // For open security we don't need EV_PSK_SUP, so set that flag indicator now
+            self->wifi_join_state |= WIFI_JOIN_STATE_KEYED;
+        }
+    }
+
+    CYW_EXIT
+
+    return ret;
+}
+
+int cyw43_wifi_leave(cyw43_t *self, int itf) {
+    // Disassociate with SSID
+    return cyw43_ioctl(self, CYW43_IOCTL_SET_DISASSOC, 0, NULL, itf);
+}
+
+/*******************************************************************************/
+// WiFi AP
+
+STATIC void cyw43_wifi_ap_init(cyw43_t *self) {
+    int ret = cyw43_ensure_up(self);
+    if (ret) {
+        return;
+    }
+
+    CYW_ENTER
+    cyw43_ll_wifi_ap_init(&self->cyw43_ll, self->ap_ssid_len, self->ap_ssid, self->ap_auth, self->ap_key_len, self->ap_key, self->ap_channel);
+    CYW_EXIT
+}
+
+STATIC void cyw43_wifi_ap_set_up(cyw43_t *self, bool up) {
+    int ret = cyw43_ensure_up(self);
+    if (ret) {
+        return;
+    }
+
+    CYW_ENTER
+    cyw43_ll_wifi_ap_set_up(&self->cyw43_ll, up);
+    CYW_EXIT
+}
+
+void cyw43_wifi_ap_get_stas(cyw43_t *self, int *num_stas, uint8_t *macs) {
+    int ret = cyw43_ensure_up(self);
+    if (ret) {
+        return;
+    }
+
+    CYW_ENTER
+    cyw43_ll_wifi_ap_get_stas(&self->cyw43_ll, num_stas, macs);
+    CYW_EXIT
+}
diff --git a/drivers/cyw43/cyw43_ll.h b/drivers/cyw43/cyw43_ll.h
new file mode 100644
index 0000000000000..879367a2edd9e
--- /dev/null
+++ b/drivers/cyw43/cyw43_ll.h
@@ -0,0 +1,135 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_STM32_CYW43_LL_H
+#define MICROPY_INCLUDED_STM32_CYW43_LL_H
+
+// IOCTL commands
+#define CYW43_IOCTL_GET_SSID            (0x32)
+#define CYW43_IOCTL_GET_CHANNEL         (0x3a)
+#define CYW43_IOCTL_SET_DISASSOC        (0x69)
+#define CYW43_IOCTL_GET_ANTDIV          (0x7e)
+#define CYW43_IOCTL_SET_ANTDIV          (0x81)
+#define CYW43_IOCTL_SET_MONITOR         (0xd9)
+#define CYW43_IOCTL_GET_VAR             (0x20c)
+#define CYW43_IOCTL_SET_VAR             (0x20f)
+
+// Async events, event_type field
+#define CYW43_EV_SET_SSID               (0)
+#define CYW43_EV_JOIN                   (1)
+#define CYW43_EV_AUTH                   (3)
+#define CYW43_EV_DEAUTH_IND             (6)
+#define CYW43_EV_ASSOC                  (7)
+#define CYW43_EV_DISASSOC               (11)
+#define CYW43_EV_DISASSOC_IND           (12)
+#define CYW43_EV_LINK                   (16)
+#define CYW43_EV_PRUNE                  (23)
+#define CYW43_EV_PSK_SUP                (46)
+#define CYW43_EV_ESCAN_RESULT           (69)
+#define CYW43_EV_CSA_COMPLETE_IND       (80)
+#define CYW43_EV_ASSOC_REQ_IE           (87)
+#define CYW43_EV_ASSOC_RESP_IE          (88)
+
+enum {
+    CYW43_ITF_STA,
+    CYW43_ITF_AP,
+};
+
+typedef struct _cyw43_ev_scan_result_t {
+    uint32_t _0[5];
+    uint8_t bssid[6];
+    uint16_t _1[2];
+    uint8_t ssid_len;
+    uint8_t ssid[32];
+    uint32_t _2[5];
+    uint16_t channel;
+    uint16_t _3;
+    uint8_t auth_mode;
+    int16_t rssi;
+} cyw43_ev_scan_result_t;
+
+typedef struct _cyw43_async_event_t {
+    uint16_t _0;
+    uint16_t flags;
+    uint32_t event_type;
+    uint32_t status;
+    uint32_t reason;
+    uint8_t _1[30];
+    uint8_t interface;
+    uint8_t _2;
+    union {
+        cyw43_ev_scan_result_t scan_result;
+    } u;
+} cyw43_async_event_t;
+
+typedef struct _cyw43_wifi_scan_options_t {
+    uint32_t version;
+    uint16_t action;
+    uint16_t _;
+    uint32_t ssid_len; // 0 to select all
+    uint8_t ssid[32];
+    uint8_t bssid[6];
+    int8_t bss_type; // fill with 0xff to select all
+    int8_t scan_type; // 0=active, 1=passive
+    int32_t nprobes;
+    int32_t active_time;
+    int32_t passive_time;
+    int32_t home_time;
+    int32_t channel_num;
+    uint16_t channel_list[1];
+} cyw43_wifi_scan_options_t;
+
+typedef struct _cyw43_ll_t {
+    uint32_t opaque[528];
+} cyw43_ll_t;
+
+void cyw43_ll_init(cyw43_ll_t *self, void *cb_data);
+void cyw43_ll_deinit(cyw43_ll_t *self);
+
+int cyw43_ll_bus_init(cyw43_ll_t *self, const uint8_t *mac);
+void cyw43_ll_bus_sleep(cyw43_ll_t *self, bool can_sleep);
+void cyw43_ll_process_packets(cyw43_ll_t *self);
+int cyw43_ll_ioctl(cyw43_ll_t *self, uint32_t cmd, size_t len, uint8_t *buf, uint32_t iface);
+int cyw43_ll_send_ethernet(cyw43_ll_t *self, int itf, size_t len, const void *buf, bool is_pbuf);
+
+int cyw43_ll_wifi_on(cyw43_ll_t *self, uint32_t country);
+int cyw43_ll_wifi_pm(cyw43_ll_t *self, uint32_t pm, uint32_t pm_sleep_ret, uint32_t li_bcn, uint32_t li_dtim, uint32_t li_assoc);
+int cyw43_ll_wifi_scan(cyw43_ll_t *self, cyw43_wifi_scan_options_t *opts);
+
+int cyw43_ll_wifi_join(cyw43_ll_t *self, size_t ssid_len, const uint8_t *ssid, size_t key_len, const uint8_t *key, uint32_t auth_type, const uint8_t *bssid, uint32_t channel);
+void cyw43_ll_wifi_set_wpa_auth(cyw43_ll_t *self);
+void cyw43_ll_wifi_rejoin(cyw43_ll_t *self);
+
+int cyw43_ll_wifi_ap_init(cyw43_ll_t *self, size_t ssid_len, const uint8_t *ssid, uint32_t auth, size_t key_len, const uint8_t *key, uint32_t channel);
+int cyw43_ll_wifi_ap_set_up(cyw43_ll_t *self, bool up);
+int cyw43_ll_wifi_ap_get_stas(cyw43_ll_t *self, int *num_stas, uint8_t *macs);
+
+// Callbacks to be provided by mid-level interface
+int cyw43_cb_read_host_interrupt_pin(void *cb_data);
+void cyw43_cb_ensure_awake(void *cb_data);
+void cyw43_cb_process_async_event(void *cb_data, const cyw43_async_event_t *ev);
+void cyw43_cb_process_ethernet(void *cb_data, int itf, size_t len, const uint8_t *buf);
+
+#endif // MICROPY_INCLUDED_STM32_CYW43_LL_H
diff --git a/drivers/cyw43/cyw43_lwip.c b/drivers/cyw43/cyw43_lwip.c
new file mode 100644
index 0000000000000..f3ca59e3a4bf8
--- /dev/null
+++ b/drivers/cyw43/cyw43_lwip.c
@@ -0,0 +1,198 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "py/mphal.h"
+#include "lib/netutils/netutils.h"
+#include "lwip/etharp.h"
+#include "lwip/dns.h"
+#include "lwip/apps/mdns.h"
+#include "drivers/cyw43/cyw43.h"
+
+STATIC void cyw43_ethernet_trace(cyw43_t *self, struct netif *netif, size_t len, const void *data, unsigned int flags) {
+    bool is_tx = flags & NETUTILS_TRACE_IS_TX;
+    if ((is_tx && (self->trace_flags & CYW43_TRACE_ETH_TX))
+        || (!is_tx && (self->trace_flags & CYW43_TRACE_ETH_RX))) {
+        const uint8_t *buf;
+        if (len == (size_t)-1) {
+            // data is a pbuf
+            const struct pbuf *pbuf = data;
+            buf = pbuf->payload;
+            len = pbuf->len; // restricted to print only the first chunk of the pbuf
+        } else {
+            // data is actual data buffer
+            buf = data;
+        }
+
+        if (self->trace_flags & CYW43_TRACE_MAC) {
+            printf("[% 8d] ETH%cX itf=%c%c len=%u", (int)mp_hal_ticks_ms(), is_tx ? 'T' : 'R', netif->name[0], netif->name[1], len);
+            printf(" MAC type=%d subtype=%d data=", buf[0] >> 2 & 3, buf[0] >> 4);
+            for (size_t i = 0; i < len; ++i) {
+                printf(" %02x", buf[i]);
+            }
+            printf("\n");
+            return;
+        }
+
+        if (self->trace_flags & CYW43_TRACE_ETH_FULL) {
+            flags |= NETUTILS_TRACE_PAYLOAD;
+        }
+        netutils_ethernet_trace(MP_PYTHON_PRINTER, len, buf, flags);
+    }
+}
+
+STATIC err_t cyw43_netif_output(struct netif *netif, struct pbuf *p) {
+    cyw43_t *self = netif->state;
+    if (self->trace_flags != 0) {
+        cyw43_ethernet_trace(self, netif, (size_t)-1, p, NETUTILS_TRACE_IS_TX | NETUTILS_TRACE_NEWLINE);
+    }
+    int itf = netif->name[1] - '0';
+    int ret = cyw43_send_ethernet(self, itf, p->tot_len, (void*)p, true);
+    if (ret) {
+        printf("[CYW43] send_ethernet failed: %d\n", ret);
+        return ERR_IF;
+    }
+    return ERR_OK;
+}
+
+STATIC err_t cyw43_netif_init(struct netif *netif) {
+    netif->linkoutput = cyw43_netif_output;
+    netif->output = etharp_output;
+    netif->mtu = 1500;
+    netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET | NETIF_FLAG_IGMP;
+    cyw43_wifi_get_mac(netif->state, netif->name[1] - '0', netif->hwaddr);
+    netif->hwaddr_len = sizeof(netif->hwaddr);
+    return ERR_OK;
+}
+
+void cyw43_tcpip_init(cyw43_t *self, int itf) {
+    ip_addr_t ipconfig[4];
+    #if LWIP_IPV6
+    #define IP(x) ((x).u_addr.ip4)
+    #else
+    #define IP(x) (x)
+    #endif
+    if (itf == 0) {
+        // need to zero out to get isconnected() working
+        IP4_ADDR(&IP(ipconfig[0]), 0, 0, 0, 0);
+        IP4_ADDR(&IP(ipconfig[2]), 192, 168, 0, 1);
+    } else {
+        IP4_ADDR(&IP(ipconfig[0]), 192, 168, 4, 1);
+        IP4_ADDR(&IP(ipconfig[2]), 192, 168, 4, 1);
+    }
+    IP4_ADDR(&IP(ipconfig[1]), 255, 255, 255, 0);
+    IP4_ADDR(&IP(ipconfig[3]), 8, 8, 8, 8);
+    #undef IP
+
+    struct netif *n = &self->netif[itf];
+    n->name[0] = 'w';
+    n->name[1] = '0' + itf;
+    #if LWIP_IPV6
+    netif_add(n, &ipconfig[0].u_addr.ip4, &ipconfig[1].u_addr.ip4, &ipconfig[2].u_addr.ip4, self, cyw43_netif_init, ethernet_input);
+    #else
+    netif_add(n, &ipconfig[0], &ipconfig[1], &ipconfig[2], self, cyw43_netif_init, netif_input);
+    #endif
+    netif_set_hostname(n, "PYBD");
+    netif_set_default(n);
+    netif_set_up(n);
+
+    if (itf == CYW43_ITF_STA) {
+        dns_setserver(0, &ipconfig[3]);
+        dhcp_set_struct(n, &self->dhcp_client);
+        dhcp_start(n);
+    } else {
+        dhcp_server_init(&self->dhcp_server, &ipconfig[0], &ipconfig[1]);
+    }
+
+    #if LWIP_MDNS_RESPONDER
+    // TODO better to call after IP address is set
+    char mdns_hostname[9];
+    memcpy(&mdns_hostname[0], "PYBD", 4);
+    mp_hal_get_mac_ascii(MP_HAL_MAC_WLAN0, 8, 4, &mdns_hostname[4]);
+    mdns_hostname[8] = '\0';
+    mdns_resp_add_netif(n, mdns_hostname, 60);
+    #endif
+}
+
+void cyw43_tcpip_deinit(cyw43_t *self, int itf) {
+    struct netif *n = &self->netif[itf];
+    if (itf == CYW43_ITF_STA) {
+        dhcp_stop(n);
+    } else {
+        dhcp_server_deinit(&self->dhcp_server);
+    }
+    #if LWIP_MDNS_RESPONDER
+    mdns_resp_remove_netif(n);
+    #endif
+    for (struct netif *netif = netif_list; netif != NULL; netif = netif->next) {
+        if (netif == n) {
+            netif_remove(netif);
+            netif->ip_addr.addr = 0;
+            netif->flags = 0;
+        }
+    }
+}
+
+void cyw43_cb_process_ethernet(void *cb_data, int itf, size_t len, const uint8_t *buf) {
+    cyw43_t *self = cb_data;
+    struct netif *netif = &self->netif[itf];
+    if (self->trace_flags) {
+        cyw43_ethernet_trace(self, netif, len, buf, NETUTILS_TRACE_NEWLINE);
+    }
+    if (netif->flags & NETIF_FLAG_LINK_UP) {
+        struct pbuf *p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
+        if (p != NULL) {
+            pbuf_take(p, buf, len);
+            if (netif->input(p, netif) != ERR_OK) {
+                pbuf_free(p);
+            }
+        }
+    }
+}
+
+void cyw43_tcpip_set_link_up(cyw43_t *self, int itf) {
+    netif_set_link_up(&self->netif[itf]);
+}
+
+void cyw43_tcpip_set_link_down(cyw43_t *self, int itf) {
+    netif_set_link_down(&self->netif[itf]);
+}
+
+int cyw43_tcpip_link_status(cyw43_t *self, int itf) {
+    struct netif *netif = &self->netif[itf];
+    if ((netif->flags & (NETIF_FLAG_UP | NETIF_FLAG_LINK_UP))
+        == (NETIF_FLAG_UP | NETIF_FLAG_LINK_UP)) {
+        if (netif->ip_addr.addr != 0) {
+            return CYW43_LINK_UP;
+        } else {
+            return CYW43_LINK_NOIP;
+        }
+    } else {
+        return cyw43_wifi_link_status(self, itf);
+    }
+}
diff --git a/drivers/cyw43/cywbt.c b/drivers/cyw43/cywbt.c
new file mode 100644
index 0000000000000..79318f4483ba4
--- /dev/null
+++ b/drivers/cyw43/cywbt.c
@@ -0,0 +1,275 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019-2020 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "pin_static_af.h"
+#include "uart.h"
+#include "extmod/modbluetooth_hci.h"
+
+#if MICROPY_PY_NETWORK_CYW43
+
+extern const char fw_4343WA1_7_45_98_50_start;
+#define CYWBT_FW_ADDR (&fw_4343WA1_7_45_98_50_start + 749 * 512 + 29 * 256)
+
+/******************************************************************************/
+// CYW BT HCI low-level driver
+
+STATIC void cywbt_wait_cts_low(void) {
+    mp_hal_pin_config(pyb_pin_BT_CTS, MP_HAL_PIN_MODE_INPUT, MP_HAL_PIN_PULL_UP, 0);
+    for (int i = 0; i < 200; ++i) {
+        if (mp_hal_pin_read(pyb_pin_BT_CTS) == 0) {
+            break;
+        }
+        mp_hal_delay_ms(1);
+    }
+    mp_hal_pin_config_alt_static(pyb_pin_BT_CTS, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, STATIC_AF_USART6_CTS);
+}
+
+STATIC int cywbt_hci_cmd_raw(size_t len, uint8_t *buf) {
+    uart_tx_strn(&mp_bluetooth_hci_uart_obj, (void*)buf, len);
+    for (int i = 0; i < 6; ++i) {
+        while (!uart_rx_any(&mp_bluetooth_hci_uart_obj)) {
+            MICROPY_EVENT_POLL_HOOK
+        }
+        buf[i] = uart_rx_char(&mp_bluetooth_hci_uart_obj);
+    }
+
+    // expect a comand complete event (event 0x0e)
+    if (buf[0] != 0x04 || buf[1] != 0x0e) {
+        printf("unknown response: %02x %02x %02x %02x\n", buf[0], buf[1], buf[2], buf[3]);
+        return -1;
+    }
+
+    /*
+    if buf[3:6] != cmd[:3]:
+        print('response doesn\'t match cmd:', cmd, ev)
+        return b''
+        */
+
+    int sz = buf[2] - 3;
+    for (int i = 0; i < sz; ++i) {
+        while (!uart_rx_any(&mp_bluetooth_hci_uart_obj)) {
+            MICROPY_EVENT_POLL_HOOK
+        }
+        buf[i] = uart_rx_char(&mp_bluetooth_hci_uart_obj);
+    }
+
+    return 0;
+}
+
+STATIC int cywbt_hci_cmd(int ogf, int ocf, size_t param_len, const uint8_t *param_buf) {
+    uint8_t *buf = mp_bluetooth_hci_cmd_buf;
+    buf[0] = 0x01;
+    buf[1] = ocf;
+    buf[2] = ogf << 2 | ocf >> 8;
+    buf[3] = param_len;
+    if (param_len) {
+        memcpy(buf + 4, param_buf, param_len);
+    }
+    return cywbt_hci_cmd_raw(4 + param_len, buf);
+}
+
+STATIC void put_le16(uint8_t *buf, uint16_t val) {
+    buf[0] = val;
+    buf[1] = val >> 8;
+}
+
+STATIC void put_le32(uint8_t *buf, uint32_t val) {
+    buf[0] = val;
+    buf[1] = val >> 8;
+    buf[2] = val >> 16;
+    buf[3] = val >> 24;
+}
+
+STATIC int cywbt_set_baudrate(uint32_t baudrate) {
+    uint8_t buf[6];
+    put_le16(buf, 0);
+    put_le32(buf + 2, baudrate);
+    return cywbt_hci_cmd(0x3f, 0x18, 6, buf);
+}
+
+// download firmware
+STATIC int cywbt_download_firmware(const uint8_t *firmware) {
+    cywbt_hci_cmd(0x3f, 0x2e, 0, NULL);
+
+    bool last_packet = false;
+    while (!last_packet) {
+        uint8_t *buf = mp_bluetooth_hci_cmd_buf;
+        memcpy(buf + 1, firmware, 3);
+        firmware += 3;
+        last_packet = buf[1] == 0x4e;
+        if (buf[2] != 0xfc) {
+            printf("fail1 %02x\n", buf[2]);
+            break;
+        }
+        uint8_t len = buf[3];
+
+        memcpy(buf + 4, firmware, len);
+        firmware += len;
+
+        buf[0] = 1;
+        cywbt_hci_cmd_raw(4 + len, buf);
+        if (buf[0] != 0) {
+            printf("fail3 %02x\n", buf[0]);
+            break;
+        }
+    }
+
+    // RF switch must select high path during BT patch boot
+    mp_hal_pin_config(pyb_pin_WL_GPIO_1, MP_HAL_PIN_MODE_INPUT, MP_HAL_PIN_PULL_UP, 0);
+    mp_hal_delay_ms(10); // give some time for CTS to go high
+    cywbt_wait_cts_low();
+    mp_hal_pin_config(pyb_pin_WL_GPIO_1, MP_HAL_PIN_MODE_INPUT, MP_HAL_PIN_PULL_DOWN, 0); // Select chip antenna (could also select external)
+
+    mp_bluetooth_hci_uart_set_baudrate(115200);
+    cywbt_set_baudrate(3000000);
+    mp_bluetooth_hci_uart_set_baudrate(3000000);
+
+    return 0;
+}
+
+int mp_bluetooth_hci_controller_init(void) {
+    // This is called immediately after the UART is initialised during stack initialisation.
+
+    mp_hal_pin_output(pyb_pin_BT_REG_ON);
+    mp_hal_pin_low(pyb_pin_BT_REG_ON);
+    mp_hal_pin_input(pyb_pin_BT_HOST_WAKE);
+    mp_hal_pin_output(pyb_pin_BT_DEV_WAKE);
+    mp_hal_pin_low(pyb_pin_BT_DEV_WAKE);
+
+    // TODO don't select antenna if wifi is enabled
+    mp_hal_pin_config(pyb_pin_WL_GPIO_4, MP_HAL_PIN_MODE_OUTPUT, MP_HAL_PIN_PULL_NONE, 0); // RF-switch power
+    mp_hal_pin_high(pyb_pin_WL_GPIO_4); // Turn the RF-switch on
+
+    return 0;
+}
+
+int mp_bluetooth_hci_controller_activate(void) {
+    uint8_t buf[256];
+
+    mp_hal_pin_low(pyb_pin_BT_REG_ON);
+    mp_bluetooth_hci_uart_set_baudrate(115200);
+    mp_hal_delay_ms(100);
+    mp_hal_pin_high(pyb_pin_BT_REG_ON);
+    cywbt_wait_cts_low();
+
+    // Reset
+    cywbt_hci_cmd(0x03, 0x0003, 0, NULL);
+
+    // Change baudrate
+    cywbt_set_baudrate(3000000);
+    mp_bluetooth_hci_uart_set_baudrate(3000000);
+
+    cywbt_download_firmware((const uint8_t*)CYWBT_FW_ADDR);
+
+    // Reset
+    cywbt_hci_cmd(0x03, 0x0003, 0, NULL);
+
+    // Set BD_ADDR (sent as little endian)
+    uint8_t bdaddr[6];
+    mp_hal_get_mac(MP_HAL_MAC_BDADDR, bdaddr);
+    buf[0] = bdaddr[5];
+    buf[1] = bdaddr[4];
+    buf[2] = bdaddr[3];
+    buf[3] = bdaddr[2];
+    buf[4] = bdaddr[1];
+    buf[5] = bdaddr[0];
+    cywbt_hci_cmd(0x3f, 0x0001, 6, buf);
+
+    // Set local name
+    // memset(buf, 0, 248);
+    // memcpy(buf, "PYBD-BLE", 8);
+    // cywbt_hci_cmd(0x03, 0x0013, 248, buf);
+
+    // Configure sleep mode
+    cywbt_hci_cmd(0x3f, 0x27, 12, (const uint8_t*)"\x01\x02\x02\x00\x00\x00\x01\x00\x00\x00\x00\x00");
+
+    // HCI_Write_LE_Host_Support
+    cywbt_hci_cmd(3, 109, 2, (const uint8_t*)"\x01\x00");
+
+    mp_hal_pin_high(pyb_pin_BT_DEV_WAKE); // let sleep
+
+    return 0;
+}
+
+int mp_bluetooth_hci_controller_deactivate(void) {
+    mp_hal_pin_low(pyb_pin_BT_REG_ON);
+
+    return 0;
+}
+
+#ifdef pyb_pin_BT_DEV_WAKE
+STATIC uint32_t bt_sleep_ticks;
+#endif
+
+int mp_bluetooth_hci_controller_sleep_maybe(void) {
+    #ifdef pyb_pin_BT_DEV_WAKE
+    if (mp_hal_pin_read(pyb_pin_BT_DEV_WAKE) == 0) {
+        if (mp_hal_ticks_ms() - bt_sleep_ticks > 500) {
+            mp_hal_pin_high(pyb_pin_BT_DEV_WAKE); // let sleep
+        }
+    }
+    #endif
+    return 0;
+}
+
+bool mp_bluetooth_hci_controller_woken(void) {
+    #ifdef pyb_pin_BT_HOST_WAKE
+    bool host_wake = mp_hal_pin_read(pyb_pin_BT_HOST_WAKE);
+    /*
+    // this is just for info/tracing purposes
+    static bool last_host_wake = false;
+    if (host_wake != last_host_wake) {
+        printf("HOST_WAKE change %d -> %d\n", last_host_wake, host_wake);
+        last_host_wake = host_wake;
+    }
+    */
+    return host_wake;
+    #else
+    return true;
+    #endif
+}
+
+int mp_bluetooth_hci_controller_wakeup(void) {
+    #ifdef pyb_pin_BT_DEV_WAKE
+    bt_sleep_ticks = mp_hal_ticks_ms();
+
+    if (mp_hal_pin_read(pyb_pin_BT_DEV_WAKE) == 1) {
+        mp_hal_pin_low(pyb_pin_BT_DEV_WAKE); // wake up
+        // Use delay_us rather than delay_ms to prevent running the scheduler (which
+        // might result in more BLE operations).
+        mp_hal_delay_us(5000); // can't go lower than this
+    }
+    #endif
+
+    return 0;
+}
+
+#endif
diff --git a/drivers/cyw43/libcyw43.a b/drivers/cyw43/libcyw43.a
new file mode 100644
index 0000000000000..7d0ff93dcbe68
Binary files /dev/null and b/drivers/cyw43/libcyw43.a differ
diff --git a/drivers/dht/dht.c b/drivers/dht/dht.c
index 70371cc013aa2..81754ac15f43f 100644
--- a/drivers/dht/dht.c
+++ b/drivers/dht/dht.c
@@ -45,7 +45,7 @@ STATIC mp_obj_t dht_readinto(mp_obj_t pin_in, mp_obj_t buf_in) {
     mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_WRITE);
 
     if (bufinfo.len < 5) {
-        mp_raise_ValueError("buffer too small");
+        mp_raise_ValueError(MP_ERROR_TEXT("buffer too small"));
     }
 
     // issue start command
diff --git a/drivers/dht/dht.py b/drivers/dht/dht.py
index eed61df7c9c06..1163b382bbc77 100644
--- a/drivers/dht/dht.py
+++ b/drivers/dht/dht.py
@@ -6,6 +6,7 @@
 except:
     from pyb import dht_readinto
 
+
 class DHTBase:
     def __init__(self, pin):
         self.pin = pin
@@ -14,9 +15,10 @@ def __init__(self, pin):
     def measure(self):
         buf = self.buf
         dht_readinto(self.pin, buf)
-        if (buf[0] + buf[1] + buf[2] + buf[3]) & 0xff != buf[4]:
+        if (buf[0] + buf[1] + buf[2] + buf[3]) & 0xFF != buf[4]:
             raise Exception("checksum error")
 
+
 class DHT11(DHTBase):
     def humidity(self):
         return self.buf[0]
@@ -24,12 +26,13 @@ def humidity(self):
     def temperature(self):
         return self.buf[2]
 
+
 class DHT22(DHTBase):
     def humidity(self):
         return (self.buf[0] << 8 | self.buf[1]) * 0.1
 
     def temperature(self):
-        t = ((self.buf[2] & 0x7f) << 8 | self.buf[3]) * 0.1
+        t = ((self.buf[2] & 0x7F) << 8 | self.buf[3]) * 0.1
         if self.buf[2] & 0x80:
             t = -t
         return t
diff --git a/drivers/display/lcd160cr.py b/drivers/display/lcd160cr.py
index cf562a40d3de7..f792418aa2b55 100644
--- a/drivers/display/lcd160cr.py
+++ b/drivers/display/lcd160cr.py
@@ -29,16 +29,17 @@
     460800: 8,
 }
 
+
 class LCD160CR:
     def __init__(self, connect=None, *, pwr=None, i2c=None, spi=None, i2c_addr=98):
-        if connect in ('X', 'Y', 'XY', 'YX'):
+        if connect in ("X", "Y", "XY", "YX"):
             i = connect[-1]
             j = connect[0]
-            y = j + '4'
-        elif connect == 'C':
+            y = j + "4"
+        elif connect == "C":
             i = 2
             j = 2
-            y = 'A7'
+            y = "A7"
         else:
             if pwr is None or i2c is None or spi is None:
                 raise ValueError('must specify valid "connect" or all of "pwr", "i2c" and "spi"')
@@ -74,8 +75,8 @@ def __init__(self, connect=None, *, pwr=None, i2c=None, spi=None, i2c_addr=98):
 
         # set default orientation and window
         self.set_orient(PORTRAIT)
-        self._fcmd2b('<BBBBBB', 0x76, 0, 0, self.w, self.h) # viewport 'v'
-        self._fcmd2b('<BBBBBB', 0x79, 0, 0, self.w, self.h) # window 'y'
+        self._fcmd2b("<BBBBBB", 0x76, 0, 0, self.w, self.h)  # viewport 'v'
+        self._fcmd2b("<BBBBBB", 0x79, 0, 0, self.w, self.h)  # window 'y'
 
     def _send(self, cmd):
         i = self.i2c.writeto(self.i2c_addr, cmd)
@@ -135,7 +136,7 @@ def iflush(self):
 
     @staticmethod
     def rgb(r, g, b):
-        return ((b & 0xf8) << 8) | ((g & 0xfc) << 3) | (r >> 3)
+        return ((b & 0xF8) << 8) | ((g & 0xFC) << 3) | (r >> 3)
 
     @staticmethod
     def clip_line(c, w, h):
@@ -207,43 +208,43 @@ def set_power(self, on):
         sleep_ms(15)
 
     def set_orient(self, orient):
-        self._fcmd2('<BBB', 0x14, (orient & 3) + 4)
+        self._fcmd2("<BBB", 0x14, (orient & 3) + 4)
         # update width and height variables
         self.iflush()
-        self._send(b'\x02g0')
+        self._send(b"\x02g0")
         self._waitfor(4, self.buf[5])
         self.w = self.buf[5][1]
         self.h = self.buf[5][2]
 
     def set_brightness(self, value):
-        self._fcmd2('<BBB', 0x16, value)
+        self._fcmd2("<BBB", 0x16, value)
 
     def set_i2c_addr(self, addr):
         # 0x0e set i2c addr
         if addr & 3:
-            raise ValueError('must specify mod 4 aligned address')
-        self._fcmd2('<BBW', 0x0e, 0x433249 | (addr << 24))
+            raise ValueError("must specify mod 4 aligned address")
+        self._fcmd2("<BBW", 0x0E, 0x433249 | (addr << 24))
 
     def set_uart_baudrate(self, baudrate):
         try:
             baudrate = _uart_baud_table[baudrate]
         except KeyError:
-            raise ValueError('invalid baudrate')
-        self._fcmd2('<BBB', 0x18, baudrate)
+            raise ValueError("invalid baudrate")
+        self._fcmd2("<BBB", 0x18, baudrate)
 
     def set_startup_deco(self, value):
-        self._fcmd2('<BBB', 0x19, value)
+        self._fcmd2("<BBB", 0x19, value)
 
     def save_to_flash(self):
-        self._send(b'\x02fn')
+        self._send(b"\x02fn")
 
     #### PIXEL ACCESS ####
 
     def set_pixel(self, x, y, c):
-        self._fcmd2b('<BBBBH', 0x41, x, y, c)
+        self._fcmd2b("<BBBBH", 0x41, x, y, c)
 
     def get_pixel(self, x, y):
-        self._fcmd2('<BBBB', 0x61, x, y)
+        self._fcmd2("<BBBB", 0x61, x, y)
         t = 1000
         while t:
             self.i2c.readfrom_into(self.i2c_addr, self.buf1)
@@ -256,7 +257,7 @@ def get_pixel(self, x, y):
 
     def get_line(self, x, y, buf):
         l = len(buf) // 2
-        self._fcmd2b('<BBBBB', 0x10, l, x, y)
+        self._fcmd2b("<BBBBB", 0x10, l, x, y)
         l *= 2
         t = 1000
         while t:
@@ -280,42 +281,47 @@ def screen_dump(self, buf, x=0, y=0, w=None, h=None):
             # split line if more than 254 bytes needed
             buflen = (w + 1) // 2
             line = bytearray(2 * buflen + 1)
-            line2 = memoryview(line)[:2 * (w - buflen) + 1]
+            line2 = memoryview(line)[: 2 * (w - buflen) + 1]
         for i in range(min(len(buf) // (2 * w), h)):
             ix = i * w * 2
             self.get_line(x, y + i, line)
-            buf[ix:ix + len(line) - 1] = memoryview(line)[1:]
+            buf[ix : ix + len(line) - 1] = memoryview(line)[1:]
             ix += len(line) - 1
             if line2:
                 self.get_line(x + buflen, y + i, line2)
-                buf[ix:ix + len(line2) - 1] = memoryview(line2)[1:]
+                buf[ix : ix + len(line2) - 1] = memoryview(line2)[1:]
                 ix += len(line2) - 1
 
     def screen_load(self, buf):
-        l = self.w * self.h * 2+2
-        self._fcmd2b('<BBHBBB', 0x70, l, 16, self.w, self.h)
+        l = self.w * self.h * 2 + 2
+        self._fcmd2b("<BBHBBB", 0x70, l, 16, self.w, self.h)
         n = 0
         ar = memoryview(buf)
         while n < len(buf):
             if len(buf) - n >= 0x200:
-                self._send(ar[n:n + 0x200])
+                self._send(ar[n : n + 0x200])
                 n += 0x200
             else:
                 self._send(ar[n:])
                 while n < self.w * self.h * 2:
-                    self._send(b'\x00')
+                    self._send(b"\x00")
                     n += 1
 
     #### TEXT COMMANDS ####
 
     def set_pos(self, x, y):
-        self._fcmd2('<BBBB', 0x58, x, y)
+        self._fcmd2("<BBBB", 0x58, x, y)
 
     def set_text_color(self, fg, bg):
-        self._fcmd2('<BBHH', 0x63, fg, bg)
+        self._fcmd2("<BBHH", 0x63, fg, bg)
 
     def set_font(self, font, scale=0, bold=0, trans=0, scroll=0):
-        self._fcmd2('<BBBB', 0x46, (scroll << 7) | (trans << 6) | ((font & 3) << 4) | (bold & 0xf), scale & 0xff)
+        self._fcmd2(
+            "<BBBB",
+            0x46,
+            (scroll << 7) | (trans << 6) | ((font & 3) << 4) | (bold & 0xF),
+            scale & 0xFF,
+        )
 
     def write(self, s):
         # TODO: eventually check for room in LCD input queue
@@ -324,14 +330,14 @@ def write(self, s):
     #### PRIMITIVE DRAWING COMMANDS ####
 
     def set_pen(self, line, fill):
-        self._fcmd2('<BBHH', 0x50, line, fill)
+        self._fcmd2("<BBHH", 0x50, line, fill)
 
     def erase(self):
-        self._send(b'\x02\x45')
+        self._send(b"\x02\x45")
 
     def dot(self, x, y):
         if 0 <= x < self.w and 0 <= y < self.h:
-            self._fcmd2('<BBBB', 0x4b, x, y)
+            self._fcmd2("<BBBB", 0x4B, x, y)
 
     def rect(self, x, y, w, h, cmd=0x72):
         if x + w <= 0 or y + h <= 0 or x >= self.w or y >= self.h:
@@ -348,19 +354,19 @@ def rect(self, x, y, w, h, cmd=0x72):
                 y = 0
             if cmd == 0x51 or cmd == 0x72:
                 # draw interior
-                self._fcmd2b('<BBBBBB', 0x51, x, y, min(w, 255), min(h, 255))
+                self._fcmd2b("<BBBBBB", 0x51, x, y, min(w, 255), min(h, 255))
             if cmd == 0x57 or cmd == 0x72:
                 # draw outline
                 if left:
-                    self._fcmd2b('<BBBBBB', 0x57, x, y, 1, min(h, 255))
+                    self._fcmd2b("<BBBBBB", 0x57, x, y, 1, min(h, 255))
                 if top:
-                    self._fcmd2b('<BBBBBB', 0x57, x, y, min(w, 255), 1)
+                    self._fcmd2b("<BBBBBB", 0x57, x, y, min(w, 255), 1)
                 if x + w < self.w:
-                    self._fcmd2b('<BBBBBB', 0x57, x + w, y, 1, min(h, 255))
+                    self._fcmd2b("<BBBBBB", 0x57, x + w, y, 1, min(h, 255))
                 if y + h < self.h:
-                    self._fcmd2b('<BBBBBB', 0x57, x, y + h, min(w, 255), 1)
+                    self._fcmd2b("<BBBBBB", 0x57, x, y + h, min(w, 255), 1)
         else:
-            self._fcmd2b('<BBBBBB', cmd, x, y, min(w, 255), min(h, 255))
+            self._fcmd2b("<BBBBBB", cmd, x, y, min(w, 255), min(h, 255))
 
     def rect_outline(self, x, y, w, h):
         self.rect(x, y, w, h, 0x57)
@@ -375,48 +381,48 @@ def line(self, x1, y1, x2, y2):
         ar4[2] = x2
         ar4[3] = y2
         if self.clip_line(ar4, self.w, self.h):
-            self._fcmd2b('<BBBBBB', 0x4c, ar4[0], ar4[1], ar4[2], ar4[3])
+            self._fcmd2b("<BBBBBB", 0x4C, ar4[0], ar4[1], ar4[2], ar4[3])
 
     def dot_no_clip(self, x, y):
-        self._fcmd2('<BBBB', 0x4b, x, y)
+        self._fcmd2("<BBBB", 0x4B, x, y)
 
     def rect_no_clip(self, x, y, w, h):
-        self._fcmd2b('<BBBBBB', 0x72, x, y, w, h)
+        self._fcmd2b("<BBBBBB", 0x72, x, y, w, h)
 
     def rect_outline_no_clip(self, x, y, w, h):
-        self._fcmd2b('<BBBBBB', 0x57, x, y, w, h)
+        self._fcmd2b("<BBBBBB", 0x57, x, y, w, h)
 
     def rect_interior_no_clip(self, x, y, w, h):
-        self._fcmd2b('<BBBBBB', 0x51, x, y, w, h)
+        self._fcmd2b("<BBBBBB", 0x51, x, y, w, h)
 
     def line_no_clip(self, x1, y1, x2, y2):
-        self._fcmd2b('<BBBBBB', 0x4c, x1, y1, x2, y2)
+        self._fcmd2b("<BBBBBB", 0x4C, x1, y1, x2, y2)
 
     def poly_dot(self, data):
         if len(data) & 1:
-            raise ValueError('must specify even number of bytes')
-        self._fcmd2('<BBB', 0x71, len(data) // 2)
+            raise ValueError("must specify even number of bytes")
+        self._fcmd2("<BBB", 0x71, len(data) // 2)
         self._send(data)
 
     def poly_line(self, data):
         if len(data) & 1:
-            raise ValueError('must specify even number of bytes')
-        self._fcmd2('<BBB', 0x78, len(data) // 2)
+            raise ValueError("must specify even number of bytes")
+        self._fcmd2("<BBB", 0x78, len(data) // 2)
         self._send(data)
 
     #### TOUCH COMMANDS ####
 
     def touch_config(self, calib=False, save=False, irq=None):
-        self._fcmd2('<BBBB', 0x7a, (irq is not None) << 2 | save << 1 | calib, bool(irq) << 7)
+        self._fcmd2("<BBBB", 0x7A, (irq is not None) << 2 | save << 1 | calib, bool(irq) << 7)
 
     def is_touched(self):
-        self._send(b'\x02T')
+        self._send(b"\x02T")
         b = self.buf[4]
         self._waitfor(3, b)
         return b[1] >> 7 != 0
 
     def get_touch(self):
-        self._send(b'\x02T') # implicit LCD output flush
+        self._send(b"\x02T")  # implicit LCD output flush
         b = self.buf[4]
         self._waitfor(3, b)
         return b[1] >> 7, b[2], b[3]
@@ -424,11 +430,13 @@ def get_touch(self):
     #### ADVANCED COMMANDS ####
 
     def set_spi_win(self, x, y, w, h):
-        pack_into('<BBBHHHHHHHH', self.buf19, 0, 2, 0x55, 10, x, y, x + w - 1, y + h - 1, 0, 0, 0, 0xffff)
+        pack_into(
+            "<BBBHHHHHHHH", self.buf19, 0, 2, 0x55, 10, x, y, x + w - 1, y + h - 1, 0, 0, 0, 0xFFFF
+        )
         self._send(self.buf19)
 
     def fast_spi(self, flush=True):
-        self._send(b'\x02\x12')
+        self._send(b"\x02\x12")
         if flush:
             self.oflush()
         return self.spi
@@ -437,27 +445,27 @@ def show_framebuf(self, buf):
         self.fast_spi().write(buf)
 
     def set_scroll(self, on):
-        self._fcmd2('<BBB', 0x15, on)
+        self._fcmd2("<BBB", 0x15, on)
 
-    def set_scroll_win(self, win, x=-1, y=0, w=0, h=0, vec=0, pat=0, fill=0x07e0, color=0):
-        pack_into('<BBBHHHHHHHH', self.buf19, 0, 2, 0x55, win, x, y, w, h, vec, pat, fill, color)
+    def set_scroll_win(self, win, x=-1, y=0, w=0, h=0, vec=0, pat=0, fill=0x07E0, color=0):
+        pack_into("<BBBHHHHHHHH", self.buf19, 0, 2, 0x55, win, x, y, w, h, vec, pat, fill, color)
         self._send(self.buf19)
 
     def set_scroll_win_param(self, win, param, value):
-        self._fcmd2b('<BBBBH', 0x75, win, param, value)
+        self._fcmd2b("<BBBBH", 0x75, win, param, value)
 
     def set_scroll_buf(self, s):
         l = len(s)
         if l > 32:
-            raise ValueError('length must be 32 or less')
-        self._fcmd2('<BBB', 0x11, l)
+            raise ValueError("length must be 32 or less")
+        self._fcmd2("<BBB", 0x11, l)
         self._send(s)
 
     def jpeg_start(self, l):
-        if l > 0xffff:
-            raise ValueError('length must be 65535 or less')
+        if l > 0xFFFF:
+            raise ValueError("length must be 65535 or less")
         self.oflush()
-        self._fcmd2('<BBH', 0x6a, l)
+        self._fcmd2("<BBH", 0x6A, l)
 
     def jpeg_data(self, buf):
         self._send(buf)
@@ -467,8 +475,8 @@ def jpeg(self, buf):
         self.jpeg_data(buf)
 
     def feed_wdt(self):
-        self._send(b'\x02\x17')
+        self._send(b"\x02\x17")
 
     def reset(self):
-        self._send(b'\x02Y\xef\xbe\xad\xde')
+        self._send(b"\x02Y\xef\xbe\xad\xde")
         sleep_ms(15)
diff --git a/drivers/display/lcd160cr_test.py b/drivers/display/lcd160cr_test.py
index 8b7ef4555f905..883c7d3b7a1ff 100644
--- a/drivers/display/lcd160cr_test.py
+++ b/drivers/display/lcd160cr_test.py
@@ -3,11 +3,13 @@
 
 import time, math, framebuf, lcd160cr
 
+
 def get_lcd(lcd):
     if type(lcd) is str:
         lcd = lcd160cr.LCD160CR(lcd)
     return lcd
 
+
 def show_adc(lcd, adc):
     data = [adc.read_core_temp(), adc.read_core_vbat(), 3.3]
     try:
@@ -21,24 +23,26 @@ def show_adc(lcd, adc):
             lcd.set_pos(0, 100 + i * 16)
         else:
             lcd.set_font(2, trans=1)
-            lcd.set_pos(0, lcd.h-60 + i * 16)
-        lcd.write('%4s: ' % ('TEMP', 'VBAT', 'VREF')[i])
+            lcd.set_pos(0, lcd.h - 60 + i * 16)
+        lcd.write("%4s: " % ("TEMP", "VBAT", "VREF")[i])
         if i > 0:
-            s = '%6.3fV' % data[i]
+            s = "%6.3fV" % data[i]
         else:
-            s = '%5.1f°C' % data[i]
+            s = "%5.1f°C" % data[i]
         if lcd.h == 160:
             lcd.set_font(1, bold=0, scale=1)
         else:
             lcd.set_font(1, bold=0, scale=1, trans=1)
-            lcd.set_pos(45, lcd.h-60 + i * 16)
+            lcd.set_pos(45, lcd.h - 60 + i * 16)
         lcd.write(s)
 
+
 def test_features(lcd, orient=lcd160cr.PORTRAIT):
     # if we run on pyboard then use ADC and RTC features
     try:
         import pyb
-        adc = pyb.ADCAll(12, 0xf0000)
+
+        adc = pyb.ADCAll(12, 0xF0000)
         rtc = pyb.RTC()
     except:
         adc = None
@@ -53,7 +57,7 @@ def test_features(lcd, orient=lcd160cr.PORTRAIT):
     # create M-logo
     mlogo = framebuf.FrameBuffer(bytearray(17 * 17 * 2), 17, 17, framebuf.RGB565)
     mlogo.fill(0)
-    mlogo.fill_rect(1, 1, 15, 15, 0xffffff)
+    mlogo.fill_rect(1, 1, 15, 15, 0xFFFFFF)
     mlogo.vline(4, 4, 12, 0)
     mlogo.vline(8, 1, 12, 0)
     mlogo.vline(12, 4, 12, 0)
@@ -80,15 +84,18 @@ def test_features(lcd, orient=lcd160cr.PORTRAIT):
             if tx2 >= 0 and ty2 >= 0 and tx2 < w and ty2 < h:
                 tx, ty = tx2, ty2
         else:
-             tx = (tx + 1) % w
-             ty = (ty + 1) % h
+            tx = (tx + 1) % w
+            ty = (ty + 1) % h
 
         # create and show the inline framebuf
         fbuf.fill(lcd.rgb(128 + int(64 * math.cos(0.1 * i)), 128, 192))
-        fbuf.line(w // 2, h // 2,
+        fbuf.line(
+            w // 2,
+            h // 2,
             w // 2 + int(40 * math.cos(0.2 * i)),
             h // 2 + int(40 * math.sin(0.2 * i)),
-            lcd.rgb(128, 255, 64))
+            lcd.rgb(128, 255, 64),
+        )
         fbuf.hline(0, ty, w, lcd.rgb(64, 64, 64))
         fbuf.vline(tx, 0, h, lcd.rgb(64, 64, 64))
         fbuf.rect(tx - 3, ty - 3, 7, 7, lcd.rgb(64, 64, 64))
@@ -97,9 +104,12 @@ def test_features(lcd, orient=lcd160cr.PORTRAIT):
             y = h // 2 - 8 + int(32 * math.sin(0.05 * i + phase))
             fbuf.blit(mlogo, x, y)
         for j in range(-3, 3):
-            fbuf.text('MicroPython',
-                5, h // 2 + 9 * j + int(20 * math.sin(0.1 * (i + j))),
-                lcd.rgb(128 + 10 * j, 0, 128 - 10 * j))
+            fbuf.text(
+                "MicroPython",
+                5,
+                h // 2 + 9 * j + int(20 * math.sin(0.1 * (i + j))),
+                lcd.rgb(128 + 10 * j, 0, 128 - 10 * j),
+            )
         lcd.show_framebuf(fbuf)
 
         # show results from the ADC
@@ -111,7 +121,10 @@ def test_features(lcd, orient=lcd160cr.PORTRAIT):
             lcd.set_pos(2, 0)
             lcd.set_font(1)
             t = rtc.datetime()
-            lcd.write('%4d-%02d-%02d %2d:%02d:%02d.%01d' % (t[0], t[1], t[2], t[4], t[5], t[6], t[7] // 100000))
+            lcd.write(
+                "%4d-%02d-%02d %2d:%02d:%02d.%01d"
+                % (t[0], t[1], t[2], t[4], t[5], t[6], t[7] // 100000)
+            )
 
         # compute the frame rate
         t1 = time.ticks_us()
@@ -120,13 +133,14 @@ def test_features(lcd, orient=lcd160cr.PORTRAIT):
 
         # show the frame rate
         lcd.set_pos(2, 9)
-        lcd.write('%.2f fps' % (1000000 / dt))
+        lcd.write("%.2f fps" % (1000000 / dt))
+
 
 def test_mandel(lcd, orient=lcd160cr.PORTRAIT):
     # set orientation and clear screen
     lcd = get_lcd(lcd)
     lcd.set_orient(orient)
-    lcd.set_pen(0, 0xffff)
+    lcd.set_pen(0, 0xFFFF)
     lcd.erase()
 
     # function to compute Mandelbrot pixels
@@ -148,24 +162,26 @@ def in_set(c):
     spi = lcd.fast_spi()
 
     # draw the Mandelbrot set line-by-line
-    hh = ((h - 1) / 3.2)
-    ww = ((w - 1) / 2.4)
+    hh = (h - 1) / 3.2
+    ww = (w - 1) / 2.4
     for v in range(h):
         for u in range(w):
             c = in_set((v / hh - 2.3) + (u / ww - 1.2) * 1j)
             if c < 16:
                 rgb = c << 12 | c << 6
             else:
-                rgb = 0xf800 | c << 6
+                rgb = 0xF800 | c << 6
             line[2 * u] = rgb
             line[2 * u + 1] = rgb >> 8
         spi.write(line)
 
+
 def test_all(lcd, orient=lcd160cr.PORTRAIT):
     lcd = get_lcd(lcd)
     test_features(lcd, orient)
     test_mandel(lcd, orient)
 
-print('To run all tests: test_all(<lcd>)')
-print('Individual tests are: test_features, test_mandel')
+
+print("To run all tests: test_all(<lcd>)")
+print("Individual tests are: test_features, test_mandel")
 print('<lcd> argument should be a connection, eg "X", or an LCD160CR object')
diff --git a/drivers/display/ssd1306.py b/drivers/display/ssd1306.py
index 178b4911d7125..6359c85eaaa1f 100644
--- a/drivers/display/ssd1306.py
+++ b/drivers/display/ssd1306.py
@@ -5,23 +5,23 @@
 
 
 # register definitions
-SET_CONTRAST        = const(0x81)
-SET_ENTIRE_ON       = const(0xa4)
-SET_NORM_INV        = const(0xa6)
-SET_DISP            = const(0xae)
-SET_MEM_ADDR        = const(0x20)
-SET_COL_ADDR        = const(0x21)
-SET_PAGE_ADDR       = const(0x22)
+SET_CONTRAST = const(0x81)
+SET_ENTIRE_ON = const(0xA4)
+SET_NORM_INV = const(0xA6)
+SET_DISP = const(0xAE)
+SET_MEM_ADDR = const(0x20)
+SET_COL_ADDR = const(0x21)
+SET_PAGE_ADDR = const(0x22)
 SET_DISP_START_LINE = const(0x40)
-SET_SEG_REMAP       = const(0xa0)
-SET_MUX_RATIO       = const(0xa8)
-SET_COM_OUT_DIR     = const(0xc0)
-SET_DISP_OFFSET     = const(0xd3)
-SET_COM_PIN_CFG     = const(0xda)
-SET_DISP_CLK_DIV    = const(0xd5)
-SET_PRECHARGE       = const(0xd9)
-SET_VCOM_DESEL      = const(0xdb)
-SET_CHARGE_PUMP     = const(0x8d)
+SET_SEG_REMAP = const(0xA0)
+SET_MUX_RATIO = const(0xA8)
+SET_COM_OUT_DIR = const(0xC0)
+SET_DISP_OFFSET = const(0xD3)
+SET_COM_PIN_CFG = const(0xDA)
+SET_DISP_CLK_DIV = const(0xD5)
+SET_PRECHARGE = const(0xD9)
+SET_VCOM_DESEL = const(0xDB)
+SET_CHARGE_PUMP = const(0x8D)
 
 # Subclassing FrameBuffer provides support for graphics primitives
 # http://docs.micropython.org/en/latest/pyboard/library/framebuf.html
@@ -37,27 +37,37 @@ def __init__(self, width, height, external_vcc):
 
     def init_display(self):
         for cmd in (
-            SET_DISP | 0x00, # off
+            SET_DISP | 0x00,  # off
             # address setting
-            SET_MEM_ADDR, 0x00, # horizontal
+            SET_MEM_ADDR,
+            0x00,  # horizontal
             # resolution and layout
             SET_DISP_START_LINE | 0x00,
-            SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0
-            SET_MUX_RATIO, self.height - 1,
-            SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0
-            SET_DISP_OFFSET, 0x00,
-            SET_COM_PIN_CFG, 0x02 if self.height == 32 else 0x12,
+            SET_SEG_REMAP | 0x01,  # column addr 127 mapped to SEG0
+            SET_MUX_RATIO,
+            self.height - 1,
+            SET_COM_OUT_DIR | 0x08,  # scan from COM[N] to COM0
+            SET_DISP_OFFSET,
+            0x00,
+            SET_COM_PIN_CFG,
+            0x02 if self.width > 2 * self.height else 0x12,
             # timing and driving scheme
-            SET_DISP_CLK_DIV, 0x80,
-            SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,
-            SET_VCOM_DESEL, 0x30, # 0.83*Vcc
+            SET_DISP_CLK_DIV,
+            0x80,
+            SET_PRECHARGE,
+            0x22 if self.external_vcc else 0xF1,
+            SET_VCOM_DESEL,
+            0x30,  # 0.83*Vcc
             # display
-            SET_CONTRAST, 0xff, # maximum
-            SET_ENTIRE_ON, # output follows RAM contents
-            SET_NORM_INV, # not inverted
+            SET_CONTRAST,
+            0xFF,  # maximum
+            SET_ENTIRE_ON,  # output follows RAM contents
+            SET_NORM_INV,  # not inverted
             # charge pump
-            SET_CHARGE_PUMP, 0x10 if self.external_vcc else 0x14,
-            SET_DISP | 0x01): # on
+            SET_CHARGE_PUMP,
+            0x10 if self.external_vcc else 0x14,
+            SET_DISP | 0x01,
+        ):  # on
             self.write_cmd(cmd)
         self.fill(0)
         self.show()
@@ -92,24 +102,21 @@ def show(self):
 
 
 class SSD1306_I2C(SSD1306):
-    def __init__(self, width, height, i2c, addr=0x3c, external_vcc=False):
+    def __init__(self, width, height, i2c, addr=0x3C, external_vcc=False):
         self.i2c = i2c
         self.addr = addr
         self.temp = bytearray(2)
+        self.write_list = [b"\x40", None]  # Co=0, D/C#=1
         super().__init__(width, height, external_vcc)
 
     def write_cmd(self, cmd):
-        self.temp[0] = 0x80 # Co=1, D/C#=0
+        self.temp[0] = 0x80  # Co=1, D/C#=0
         self.temp[1] = cmd
         self.i2c.writeto(self.addr, self.temp)
 
     def write_data(self, buf):
-        self.temp[0] = self.addr << 1
-        self.temp[1] = 0x40 # Co=0, D/C#=1
-        self.i2c.start()
-        self.i2c.write(self.temp)
-        self.i2c.write(buf)
-        self.i2c.stop()
+        self.write_list[1] = buf
+        self.i2c.writevto(self.addr, self.write_list)
 
 
 class SSD1306_SPI(SSD1306):
@@ -123,6 +130,7 @@ def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
         self.res = res
         self.cs = cs
         import time
+
         self.res(1)
         time.sleep_ms(1)
         self.res(0)
diff --git a/drivers/memory/spiflash.c b/drivers/memory/spiflash.c
index 22775d5416fc2..e870d39f5f9cb 100644
--- a/drivers/memory/spiflash.c
+++ b/drivers/memory/spiflash.c
@@ -45,6 +45,12 @@
 #define CMD_CHIP_ERASE  (0xc7)
 #define CMD_C4READ      (0xeb)
 
+// 32 bit addressing commands
+#define CMD_WRITE_32    (0x12)
+#define CMD_READ_32     (0x13)
+#define CMD_SEC_ERASE_32 (0x21)
+#define CMD_C4READ_32   (0xec)
+
 #define WAIT_SR_TIMEOUT (1000000)
 
 #define PAGE_SIZE (256) // maximum bytes we can write in one SPI transfer
@@ -76,18 +82,26 @@ STATIC void mp_spiflash_write_cmd_data(mp_spiflash_t *self, uint8_t cmd, size_t
     }
 }
 
-STATIC void mp_spiflash_write_cmd_addr_data(mp_spiflash_t *self, uint8_t cmd, uint32_t addr, size_t len, const uint8_t *src) {
+STATIC void mp_spiflash_transfer_cmd_addr_data(mp_spiflash_t *self, uint8_t cmd, uint32_t addr, size_t len, const uint8_t *src, uint8_t *dest) {
     const mp_spiflash_config_t *c = self->config;
     if (c->bus_kind == MP_SPIFLASH_BUS_SPI) {
-        uint8_t buf[4] = {cmd, addr >> 16, addr >> 8, addr};
+        uint8_t buf[5] = {cmd, 0};
+        uint8_t buff_len = 1 + mp_spi_set_addr_buff(&buf[1], addr);
         mp_hal_pin_write(c->bus.u_spi.cs, 0);
-        c->bus.u_spi.proto->transfer(c->bus.u_spi.data, 4, buf, NULL);
-        if (len) {
+        c->bus.u_spi.proto->transfer(c->bus.u_spi.data, buff_len, buf, NULL);
+        if (len && (src != NULL)) {
             c->bus.u_spi.proto->transfer(c->bus.u_spi.data, len, src, NULL);
+        } else if (len && (dest != NULL)) {
+            c->bus.u_spi.proto->transfer(c->bus.u_spi.data, len, dest, dest);
         }
+
         mp_hal_pin_write(c->bus.u_spi.cs, 1);
     } else {
-        c->bus.u_qspi.proto->write_cmd_addr_data(c->bus.u_qspi.data, cmd, addr, len, src);
+        if (dest != NULL) {
+            c->bus.u_qspi.proto->read_cmd_qaddr_qdata(c->bus.u_qspi.data, cmd, addr, len, dest);
+        } else {
+            c->bus.u_qspi.proto->write_cmd_addr_data(c->bus.u_qspi.data, cmd, addr, len, src);
+        }
     }
 }
 
@@ -107,25 +121,19 @@ STATIC uint32_t mp_spiflash_read_cmd(mp_spiflash_t *self, uint8_t cmd, size_t le
 
 STATIC void mp_spiflash_read_data(mp_spiflash_t *self, uint32_t addr, size_t len, uint8_t *dest) {
     const mp_spiflash_config_t *c = self->config;
+    uint8_t cmd;
     if (c->bus_kind == MP_SPIFLASH_BUS_SPI) {
-        uint8_t buf[4] = {CMD_READ, addr >> 16, addr >> 8, addr};
-        mp_hal_pin_write(c->bus.u_spi.cs, 0);
-        c->bus.u_spi.proto->transfer(c->bus.u_spi.data, 4, buf, NULL);
-        c->bus.u_spi.proto->transfer(c->bus.u_spi.data, len, dest, dest);
-        mp_hal_pin_write(c->bus.u_spi.cs, 1);
+        cmd = MP_SPI_ADDR_IS_32B(addr) ? CMD_READ_32 : CMD_READ;
     } else {
-        c->bus.u_qspi.proto->read_cmd_qaddr_qdata(c->bus.u_qspi.data, CMD_C4READ, addr, len, dest);
+        cmd = MP_SPI_ADDR_IS_32B(addr) ? CMD_C4READ_32 : CMD_C4READ;
     }
+    mp_spiflash_transfer_cmd_addr_data(self, cmd, addr, len, NULL, dest);
 }
 
 STATIC void mp_spiflash_write_cmd(mp_spiflash_t *self, uint8_t cmd) {
     mp_spiflash_write_cmd_data(self, cmd, 0, 0);
 }
 
-STATIC void mp_spiflash_write_cmd_addr(mp_spiflash_t *self, uint8_t cmd, uint32_t addr) {
-    mp_spiflash_write_cmd_addr_data(self, cmd, addr, 0, NULL);
-}
-
 STATIC int mp_spiflash_wait_sr(mp_spiflash_t *self, uint8_t mask, uint8_t val, uint32_t timeout) {
     uint8_t sr;
     do {
@@ -146,6 +154,10 @@ STATIC int mp_spiflash_wait_wip0(mp_spiflash_t *self) {
     return mp_spiflash_wait_sr(self, 1, 0, WAIT_SR_TIMEOUT);
 }
 
+static inline void mp_spiflash_deepsleep_internal(mp_spiflash_t *self, int value) {
+    mp_spiflash_write_cmd(self, value ? 0xb9 : 0xab); // sleep/wake
+}
+
 void mp_spiflash_init(mp_spiflash_t *self) {
     self->flags = 0;
 
@@ -159,6 +171,9 @@ void mp_spiflash_init(mp_spiflash_t *self) {
 
     mp_spiflash_acquire_bus(self);
 
+    // Ensure SPI flash is out of sleep mode
+    mp_spiflash_deepsleep_internal(self, 0);
+
     #if defined(CHECK_DEVID)
     // Validate device id
     uint32_t devid = mp_spiflash_read_cmd(self, CMD_RD_DEVID, 3);
@@ -182,6 +197,16 @@ void mp_spiflash_init(mp_spiflash_t *self) {
     mp_spiflash_release_bus(self);
 }
 
+void mp_spiflash_deepsleep(mp_spiflash_t *self, int value) {
+    if (value) {
+        mp_spiflash_acquire_bus(self);
+    }
+    mp_spiflash_deepsleep_internal(self, value);
+    if (!value) {
+        mp_spiflash_release_bus(self);
+    }
+}
+
 STATIC int mp_spiflash_erase_block_internal(mp_spiflash_t *self, uint32_t addr) {
     // enable writes
     mp_spiflash_write_cmd(self, CMD_WREN);
@@ -193,7 +218,8 @@ STATIC int mp_spiflash_erase_block_internal(mp_spiflash_t *self, uint32_t addr)
     }
 
     // erase the sector
-    mp_spiflash_write_cmd_addr(self, CMD_SEC_ERASE, addr);
+    uint8_t cmd = MP_SPI_ADDR_IS_32B(addr) ? CMD_SEC_ERASE_32 : CMD_SEC_ERASE;
+    mp_spiflash_transfer_cmd_addr_data(self, cmd, addr, 0, NULL, NULL);
 
     // wait WIP=0
     return mp_spiflash_wait_wip0(self);
@@ -210,7 +236,8 @@ STATIC int mp_spiflash_write_page(mp_spiflash_t *self, uint32_t addr, size_t len
     }
 
     // write the page
-    mp_spiflash_write_cmd_addr_data(self, CMD_WRITE, addr, len, src);
+    uint8_t cmd = MP_SPI_ADDR_IS_32B(addr) ? CMD_WRITE_32 : CMD_WRITE;
+    mp_spiflash_transfer_cmd_addr_data(self, cmd, addr, len, src, NULL);
 
     // wait WIP=0
     return mp_spiflash_wait_wip0(self);
diff --git a/drivers/memory/spiflash.h b/drivers/memory/spiflash.h
index a5b8a1dcaebe9..96dfdeeab66bf 100644
--- a/drivers/memory/spiflash.h
+++ b/drivers/memory/spiflash.h
@@ -68,6 +68,7 @@ typedef struct _mp_spiflash_t {
 } mp_spiflash_t;
 
 void mp_spiflash_init(mp_spiflash_t *self);
+void mp_spiflash_deepsleep(mp_spiflash_t *self, int value);
 
 // These functions go direct to the SPI flash device
 int mp_spiflash_erase_block(mp_spiflash_t *self, uint32_t addr);
diff --git a/drivers/nrf24l01/nrf24l01.py b/drivers/nrf24l01/nrf24l01.py
index a95d2b5cac373..76d55312f8568 100644
--- a/drivers/nrf24l01/nrf24l01.py
+++ b/drivers/nrf24l01/nrf24l01.py
@@ -5,49 +5,50 @@
 import utime
 
 # nRF24L01+ registers
-CONFIG      = const(0x00)
-EN_RXADDR   = const(0x02)
-SETUP_AW    = const(0x03)
-SETUP_RETR  = const(0x04)
-RF_CH       = const(0x05)
-RF_SETUP    = const(0x06)
-STATUS      = const(0x07)
-RX_ADDR_P0  = const(0x0a)
-TX_ADDR     = const(0x10)
-RX_PW_P0    = const(0x11)
+CONFIG = const(0x00)
+EN_RXADDR = const(0x02)
+SETUP_AW = const(0x03)
+SETUP_RETR = const(0x04)
+RF_CH = const(0x05)
+RF_SETUP = const(0x06)
+STATUS = const(0x07)
+RX_ADDR_P0 = const(0x0A)
+TX_ADDR = const(0x10)
+RX_PW_P0 = const(0x11)
 FIFO_STATUS = const(0x17)
-DYNPD	    = const(0x1c)
+DYNPD = const(0x1C)
 
 # CONFIG register
-EN_CRC      = const(0x08) # enable CRC
-CRCO        = const(0x04) # CRC encoding scheme; 0=1 byte, 1=2 bytes
-PWR_UP      = const(0x02) # 1=power up, 0=power down
-PRIM_RX     = const(0x01) # RX/TX control; 0=PTX, 1=PRX
+EN_CRC = const(0x08)  # enable CRC
+CRCO = const(0x04)  # CRC encoding scheme; 0=1 byte, 1=2 bytes
+PWR_UP = const(0x02)  # 1=power up, 0=power down
+PRIM_RX = const(0x01)  # RX/TX control; 0=PTX, 1=PRX
 
 # RF_SETUP register
-POWER_0     = const(0x00) # -18 dBm
-POWER_1     = const(0x02) # -12 dBm
-POWER_2     = const(0x04) # -6 dBm
-POWER_3     = const(0x06) # 0 dBm
-SPEED_1M    = const(0x00)
-SPEED_2M    = const(0x08)
-SPEED_250K  = const(0x20)
+POWER_0 = const(0x00)  # -18 dBm
+POWER_1 = const(0x02)  # -12 dBm
+POWER_2 = const(0x04)  # -6 dBm
+POWER_3 = const(0x06)  # 0 dBm
+SPEED_1M = const(0x00)
+SPEED_2M = const(0x08)
+SPEED_250K = const(0x20)
 
 # STATUS register
-RX_DR       = const(0x40) # RX data ready; write 1 to clear
-TX_DS       = const(0x20) # TX data sent; write 1 to clear
-MAX_RT      = const(0x10) # max retransmits reached; write 1 to clear
+RX_DR = const(0x40)  # RX data ready; write 1 to clear
+TX_DS = const(0x20)  # TX data sent; write 1 to clear
+MAX_RT = const(0x10)  # max retransmits reached; write 1 to clear
 
 # FIFO_STATUS register
-RX_EMPTY    = const(0x01) # 1 if RX FIFO is empty
+RX_EMPTY = const(0x01)  # 1 if RX FIFO is empty
 
 # constants for instructions
-R_RX_PL_WID  = const(0x60) # read RX payload width
-R_RX_PAYLOAD = const(0x61) # read RX payload
-W_TX_PAYLOAD = const(0xa0) # write TX payload
-FLUSH_TX     = const(0xe1) # flush TX FIFO
-FLUSH_RX     = const(0xe2) # flush RX FIFO
-NOP          = const(0xff) # use to read STATUS register
+R_RX_PL_WID = const(0x60)  # read RX payload width
+R_RX_PAYLOAD = const(0x61)  # read RX payload
+W_TX_PAYLOAD = const(0xA0)  # write TX payload
+FLUSH_TX = const(0xE1)  # flush TX FIFO
+FLUSH_RX = const(0xE2)  # flush RX FIFO
+NOP = const(0xFF)  # use to read STATUS register
+
 
 class NRF24L01:
     def __init__(self, spi, cs, ce, channel=46, payload_size=16):
@@ -84,7 +85,7 @@ def __init__(self, spi, cs, ce, channel=46, payload_size=16):
         self.reg_write(SETUP_RETR, (6 << 4) | 8)
 
         # set rf power and speed
-        self.set_power_speed(POWER_3, SPEED_250K) # Best for point to point links
+        self.set_power_speed(POWER_3, SPEED_250K)  # Best for point to point links
 
         # init CRC
         self.set_crc(2)
@@ -218,7 +219,7 @@ def send(self, buf, timeout=500):
         start = utime.ticks_ms()
         result = None
         while result is None and utime.ticks_diff(utime.ticks_ms(), start) < timeout:
-            result = self.send_done() # 1 == success, 2 == fail
+            result = self.send_done()  # 1 == success, 2 == fail
         if result == 2:
             raise OSError("send failed")
 
@@ -232,18 +233,18 @@ def send_start(self, buf):
         self.spi.readinto(self.buf, W_TX_PAYLOAD)
         self.spi.write(buf)
         if len(buf) < self.payload_size:
-            self.spi.write(b'\x00' * (self.payload_size - len(buf))) # pad out data
+            self.spi.write(b"\x00" * (self.payload_size - len(buf)))  # pad out data
         self.cs(1)
 
         # enable the chip so it can send the data
         self.ce(1)
-        utime.sleep_us(15) # needs to be >10us
+        utime.sleep_us(15)  # needs to be >10us
         self.ce(0)
 
     # returns None if send still in progress, 1 for success, 2 for fail
     def send_done(self):
         if not (self.reg_read(STATUS) & (TX_DS | MAX_RT)):
-            return None # tx not finished
+            return None  # tx not finished
 
         # either finished or failed: get and clear status flags, power down
         status = self.reg_write(STATUS, RX_DR | TX_DS | MAX_RT)
diff --git a/drivers/nrf24l01/nrf24l01test.py b/drivers/nrf24l01/nrf24l01test.py
index 876b2bbfa208e..14efbffd2aba1 100644
--- a/drivers/nrf24l01/nrf24l01test.py
+++ b/drivers/nrf24l01/nrf24l01test.py
@@ -14,25 +14,28 @@
 # master may be a slow device. Value tested with Pyboard, ESP32 and ESP8266.
 _SLAVE_SEND_DELAY = const(10)
 
-if sys.platform == 'pyboard':
-    cfg = {'spi': 2, 'miso': 'Y7', 'mosi': 'Y8', 'sck': 'Y6', 'csn': 'Y5', 'ce': 'Y4'}
-elif sys.platform == 'esp8266':  # Hardware SPI
-    cfg = {'spi': 1, 'miso': 12, 'mosi': 13, 'sck': 14, 'csn': 4, 'ce': 5}
-elif sys.platform == 'esp32':  # Software SPI
-    cfg = {'spi': -1, 'miso': 32, 'mosi': 33, 'sck': 25, 'csn': 26, 'ce': 27}
+if sys.platform == "pyboard":
+    cfg = {"spi": 2, "miso": "Y7", "mosi": "Y8", "sck": "Y6", "csn": "Y5", "ce": "Y4"}
+elif sys.platform == "esp8266":  # Hardware SPI
+    cfg = {"spi": 1, "miso": 12, "mosi": 13, "sck": 14, "csn": 4, "ce": 5}
+elif sys.platform == "esp32":  # Software SPI
+    cfg = {"spi": -1, "miso": 32, "mosi": 33, "sck": 25, "csn": 26, "ce": 27}
 else:
-    raise ValueError('Unsupported platform {}'.format(sys.platform))
+    raise ValueError("Unsupported platform {}".format(sys.platform))
+
+# Addresses are in little-endian format. They correspond to big-endian
+# 0xf0f0f0f0e1, 0xf0f0f0f0d2
+pipes = (b"\xe1\xf0\xf0\xf0\xf0", b"\xd2\xf0\xf0\xf0\xf0")
 
-pipes = (b'\xf0\xf0\xf0\xf0\xe1', b'\xf0\xf0\xf0\xf0\xd2')
 
 def master():
-    csn = Pin(cfg['csn'], mode=Pin.OUT, value=1)
-    ce = Pin(cfg['ce'], mode=Pin.OUT, value=0)
-    if cfg['spi'] == -1:
-        spi = SPI(-1, sck=Pin(cfg['sck']), mosi=Pin(cfg['mosi']), miso=Pin(cfg['miso']))
+    csn = Pin(cfg["csn"], mode=Pin.OUT, value=1)
+    ce = Pin(cfg["ce"], mode=Pin.OUT, value=0)
+    if cfg["spi"] == -1:
+        spi = SPI(-1, sck=Pin(cfg["sck"]), mosi=Pin(cfg["mosi"]), miso=Pin(cfg["miso"]))
         nrf = NRF24L01(spi, csn, ce, payload_size=8)
     else:
-        nrf = NRF24L01(SPI(cfg['spi']), csn, ce, payload_size=8)
+        nrf = NRF24L01(SPI(cfg["spi"]), csn, ce, payload_size=8)
 
     nrf.open_tx_pipe(pipes[0])
     nrf.open_rx_pipe(1, pipes[1])
@@ -43,16 +46,16 @@ def master():
     num_failures = 0
     led_state = 0
 
-    print('NRF24L01 master mode, sending %d packets...' % num_needed)
+    print("NRF24L01 master mode, sending %d packets..." % num_needed)
 
     while num_successes < num_needed and num_failures < num_needed:
         # stop listening and send packet
         nrf.stop_listening()
         millis = utime.ticks_ms()
-        led_state = max(1, (led_state << 1) & 0x0f)
-        print('sending:', millis, led_state)
+        led_state = max(1, (led_state << 1) & 0x0F)
+        print("sending:", millis, led_state)
         try:
-            nrf.send(struct.pack('ii', millis, led_state))
+            nrf.send(struct.pack("ii", millis, led_state))
         except OSError:
             pass
 
@@ -67,43 +70,50 @@ def master():
                 timeout = True
 
         if timeout:
-            print('failed, response timed out')
+            print("failed, response timed out")
             num_failures += 1
 
         else:
             # recv packet
-            got_millis, = struct.unpack('i', nrf.recv())
+            (got_millis,) = struct.unpack("i", nrf.recv())
 
             # print response and round-trip delay
-            print('got response:', got_millis, '(delay', utime.ticks_diff(utime.ticks_ms(), got_millis), 'ms)')
+            print(
+                "got response:",
+                got_millis,
+                "(delay",
+                utime.ticks_diff(utime.ticks_ms(), got_millis),
+                "ms)",
+            )
             num_successes += 1
 
         # delay then loop
         utime.sleep_ms(250)
 
-    print('master finished sending; successes=%d, failures=%d' % (num_successes, num_failures))
+    print("master finished sending; successes=%d, failures=%d" % (num_successes, num_failures))
+
 
 def slave():
-    csn = Pin(cfg['csn'], mode=Pin.OUT, value=1)
-    ce = Pin(cfg['ce'], mode=Pin.OUT, value=0)
-    if cfg['spi'] == -1:
-        spi = SPI(-1, sck=Pin(cfg['sck']), mosi=Pin(cfg['mosi']), miso=Pin(cfg['miso']))
+    csn = Pin(cfg["csn"], mode=Pin.OUT, value=1)
+    ce = Pin(cfg["ce"], mode=Pin.OUT, value=0)
+    if cfg["spi"] == -1:
+        spi = SPI(-1, sck=Pin(cfg["sck"]), mosi=Pin(cfg["mosi"]), miso=Pin(cfg["miso"]))
         nrf = NRF24L01(spi, csn, ce, payload_size=8)
     else:
-        nrf = NRF24L01(SPI(cfg['spi']), csn, ce, payload_size=8)
+        nrf = NRF24L01(SPI(cfg["spi"]), csn, ce, payload_size=8)
 
     nrf.open_tx_pipe(pipes[1])
     nrf.open_rx_pipe(1, pipes[0])
     nrf.start_listening()
 
-    print('NRF24L01 slave mode, waiting for packets... (ctrl-C to stop)')
+    print("NRF24L01 slave mode, waiting for packets... (ctrl-C to stop)")
 
     while True:
         if nrf.any():
             while nrf.any():
                 buf = nrf.recv()
-                millis, led_state = struct.unpack('ii', buf)
-                print('received:', millis, led_state)
+                millis, led_state = struct.unpack("ii", buf)
+                print("received:", millis, led_state)
                 for led in leds:
                     if led_state & 1:
                         led.on()
@@ -116,23 +126,25 @@ def slave():
             utime.sleep_ms(_SLAVE_SEND_DELAY)
             nrf.stop_listening()
             try:
-                nrf.send(struct.pack('i', millis))
+                nrf.send(struct.pack("i", millis))
             except OSError:
                 pass
-            print('sent response')
+            print("sent response")
             nrf.start_listening()
 
+
 try:
     import pyb
+
     leds = [pyb.LED(i + 1) for i in range(4)]
 except:
     leds = []
 
-print('NRF24L01 test module loaded')
-print('NRF24L01 pinout for test:')
-print('    CE on', cfg['ce'])
-print('    CSN on', cfg['csn'])
-print('    SCK on', cfg['sck'])
-print('    MISO on', cfg['miso'])
-print('    MOSI on', cfg['mosi'])
-print('run nrf24l01test.slave() on slave, then nrf24l01test.master() on master')
+print("NRF24L01 test module loaded")
+print("NRF24L01 pinout for test:")
+print("    CE on", cfg["ce"])
+print("    CSN on", cfg["csn"])
+print("    SCK on", cfg["sck"])
+print("    MISO on", cfg["miso"])
+print("    MOSI on", cfg["mosi"])
+print("run nrf24l01test.slave() on slave, then nrf24l01test.master() on master")
diff --git a/drivers/onewire/ds18x20.py b/drivers/onewire/ds18x20.py
index bf0609483594a..ad2d9f52cdd00 100644
--- a/drivers/onewire/ds18x20.py
+++ b/drivers/onewire/ds18x20.py
@@ -4,8 +4,9 @@
 from micropython import const
 
 _CONVERT = const(0x44)
-_RD_SCRATCH = const(0xbe)
-_WR_SCRATCH = const(0x4e)
+_RD_SCRATCH = const(0xBE)
+_WR_SCRATCH = const(0x4E)
+
 
 class DS18X20:
     def __init__(self, onewire):
@@ -13,7 +14,7 @@ def __init__(self, onewire):
         self.buf = bytearray(9)
 
     def scan(self):
-        return [rom for rom in self.ow.scan() if rom[0] == 0x10 or rom[0] == 0x28]
+        return [rom for rom in self.ow.scan() if rom[0] in (0x10, 0x22, 0x28)]
 
     def convert_temp(self):
         self.ow.reset(True)
@@ -26,7 +27,7 @@ def read_scratch(self, rom):
         self.ow.writebyte(_RD_SCRATCH)
         self.ow.readinto(self.buf)
         if self.ow.crc8(self.buf):
-            raise Exception('CRC error')
+            raise Exception("CRC error")
         return self.buf
 
     def write_scratch(self, rom, buf):
@@ -40,12 +41,12 @@ def read_temp(self, rom):
         if rom[0] == 0x10:
             if buf[1]:
                 t = buf[0] >> 1 | 0x80
-                t = -((~t + 1) & 0xff)
+                t = -((~t + 1) & 0xFF)
             else:
                 t = buf[0] >> 1
             return t - 0.25 + (buf[7] - buf[6]) / buf[7]
         else:
             t = buf[1] << 8 | buf[0]
-            if t & 0x8000: # sign bit set
-                t = -((t ^ 0xffff) + 1)
+            if t & 0x8000:  # sign bit set
+                t = -((t ^ 0xFFFF) + 1)
             return t / 16
diff --git a/drivers/onewire/onewire.py b/drivers/onewire/onewire.py
index 3309ba0d2745f..4c6da741c74ce 100644
--- a/drivers/onewire/onewire.py
+++ b/drivers/onewire/onewire.py
@@ -1,16 +1,17 @@
 # 1-Wire driver for MicroPython
 # MIT license; Copyright (c) 2016 Damien P. George
 
-from micropython import const
 import _onewire as _ow
 
+
 class OneWireError(Exception):
     pass
 
+
 class OneWire:
-    SEARCH_ROM = const(0xf0)
-    MATCH_ROM = const(0x55)
-    SKIP_ROM = const(0xcc)
+    SEARCH_ROM = 0xF0
+    MATCH_ROM = 0x55
+    SKIP_ROM = 0xCC
 
     def __init__(self, pin):
         self.pin = pin
@@ -44,14 +45,14 @@ def write(self, buf):
 
     def select_rom(self, rom):
         self.reset()
-        self.writebyte(MATCH_ROM)
+        self.writebyte(self.MATCH_ROM)
         self.write(rom)
 
     def scan(self):
         devices = []
         diff = 65
         rom = False
-        for i in range(0xff):
+        for i in range(0xFF):
             rom, diff = self._search_rom(rom, diff)
             if rom:
                 devices += [rom]
@@ -62,7 +63,7 @@ def scan(self):
     def _search_rom(self, l_rom, diff):
         if not self.reset():
             return None, 0
-        self.writebyte(SEARCH_ROM)
+        self.writebyte(self.SEARCH_ROM)
         if not l_rom:
             l_rom = bytearray(8)
         rom = bytearray(8)
@@ -73,10 +74,10 @@ def _search_rom(self, l_rom, diff):
             for bit in range(8):
                 b = self.readbit()
                 if self.readbit():
-                    if b: # there are no devices or there is an error on the bus
+                    if b:  # there are no devices or there is an error on the bus
                         return None, 0
                 else:
-                    if not b: # collision, two devices with different bit meaning
+                    if not b:  # collision, two devices with different bit meaning
                         if diff > i or ((l_rom[byte] & (1 << bit)) and diff != i):
                             b = 1
                             next_diff = i
diff --git a/drivers/sdcard/sdcard.py b/drivers/sdcard/sdcard.py
index ffc551d9ae9b4..c991fe560892a 100644
--- a/drivers/sdcard/sdcard.py
+++ b/drivers/sdcard/sdcard.py
@@ -27,15 +27,15 @@
 _CMD_TIMEOUT = const(100)
 
 _R1_IDLE_STATE = const(1 << 0)
-#R1_ERASE_RESET = const(1 << 1)
+# R1_ERASE_RESET = const(1 << 1)
 _R1_ILLEGAL_COMMAND = const(1 << 2)
-#R1_COM_CRC_ERROR = const(1 << 3)
-#R1_ERASE_SEQUENCE_ERROR = const(1 << 4)
-#R1_ADDRESS_ERROR = const(1 << 5)
-#R1_PARAMETER_ERROR = const(1 << 6)
-_TOKEN_CMD25 = const(0xfc)
-_TOKEN_STOP_TRAN = const(0xfd)
-_TOKEN_DATA = const(0xfe)
+# R1_COM_CRC_ERROR = const(1 << 3)
+# R1_ERASE_SEQUENCE_ERROR = const(1 << 4)
+# R1_ADDRESS_ERROR = const(1 << 5)
+# R1_PARAMETER_ERROR = const(1 << 6)
+_TOKEN_CMD25 = const(0xFC)
+_TOKEN_STOP_TRAN = const(0xFD)
+_TOKEN_DATA = const(0xFE)
 
 
 class SDCard:
@@ -47,7 +47,7 @@ def __init__(self, spi, cs):
         self.dummybuf = bytearray(512)
         self.tokenbuf = bytearray(1)
         for i in range(512):
-            self.dummybuf[i] = 0xff
+            self.dummybuf[i] = 0xFF
         self.dummybuf_memoryview = memoryview(self.dummybuf)
 
         # initialise the card
@@ -72,7 +72,7 @@ def init_card(self):
 
         # clock card at least 100 cycles with cs high
         for i in range(16):
-            self.spi.write(b'\xff')
+            self.spi.write(b"\xff")
 
         # CMD0: init card; should return _R1_IDLE_STATE (allow 5 attempts)
         for _ in range(5):
@@ -82,7 +82,7 @@ def init_card(self):
             raise OSError("no SD card")
 
         # CMD8: determine card version
-        r = self.cmd(8, 0x01aa, 0x87, 4)
+        r = self.cmd(8, 0x01AA, 0x87, 4)
         if r == _R1_IDLE_STATE:
             self.init_card_v2()
         elif r == (_R1_IDLE_STATE | _R1_ILLEGAL_COMMAND):
@@ -96,15 +96,15 @@ def init_card(self):
             raise OSError("no response from SD card")
         csd = bytearray(16)
         self.readinto(csd)
-        if csd[0] & 0xc0 == 0x40: # CSD version 2.0
+        if csd[0] & 0xC0 == 0x40:  # CSD version 2.0
             self.sectors = ((csd[8] << 8 | csd[9]) + 1) * 1024
-        elif csd[0] & 0xc0 == 0x00: # CSD version 1.0 (old, <=2GB)
+        elif csd[0] & 0xC0 == 0x00:  # CSD version 1.0 (old, <=2GB)
             c_size = csd[6] & 0b11 | csd[7] << 2 | (csd[8] & 0b11000000) << 4
             c_size_mult = ((csd[9] & 0b11) << 1) | csd[10] >> 7
             self.sectors = (c_size + 1) * (2 ** (c_size_mult + 2))
         else:
             raise OSError("SD card CSD format not supported")
-        #print('sectors', self.sectors)
+        # print('sectors', self.sectors)
 
         # CMD16: set block length to 512 bytes
         if self.cmd(16, 512, 0) != 0:
@@ -118,7 +118,7 @@ def init_card_v1(self):
             self.cmd(55, 0, 0)
             if self.cmd(41, 0, 0) == 0:
                 self.cdv = 512
-                #print("[SDCard] v1 card")
+                # print("[SDCard] v1 card")
                 return
         raise OSError("timeout waiting for v1 card")
 
@@ -130,7 +130,7 @@ def init_card_v2(self):
             if self.cmd(41, 0x40000000, 0) == 0:
                 self.cmd(58, 0, 0, 4)
                 self.cdv = 1
-                #print("[SDCard] v2 card")
+                # print("[SDCard] v2 card")
                 return
         raise OSError("timeout waiting for v2 card")
 
@@ -148,47 +148,50 @@ def cmd(self, cmd, arg, crc, final=0, release=True, skip1=False):
         self.spi.write(buf)
 
         if skip1:
-            self.spi.readinto(self.tokenbuf, 0xff)
+            self.spi.readinto(self.tokenbuf, 0xFF)
 
         # wait for the response (response[7] == 0)
         for i in range(_CMD_TIMEOUT):
-            self.spi.readinto(self.tokenbuf, 0xff)
+            self.spi.readinto(self.tokenbuf, 0xFF)
             response = self.tokenbuf[0]
             if not (response & 0x80):
                 # this could be a big-endian integer that we are getting here
                 for j in range(final):
-                    self.spi.write(b'\xff')
+                    self.spi.write(b"\xff")
                 if release:
                     self.cs(1)
-                    self.spi.write(b'\xff')
+                    self.spi.write(b"\xff")
                 return response
 
         # timeout
         self.cs(1)
-        self.spi.write(b'\xff')
+        self.spi.write(b"\xff")
         return -1
 
     def readinto(self, buf):
         self.cs(0)
 
         # read until start byte (0xff)
-        while True:
-            self.spi.readinto(self.tokenbuf, 0xff)
+        for i in range(_CMD_TIMEOUT):
+            self.spi.readinto(self.tokenbuf, 0xFF)
             if self.tokenbuf[0] == _TOKEN_DATA:
                 break
+        else:
+            self.cs(1)
+            raise OSError("timeout waiting for response")
 
         # read data
         mv = self.dummybuf_memoryview
         if len(buf) != len(mv):
-            mv = mv[:len(buf)]
+            mv = mv[: len(buf)]
         self.spi.write_readinto(mv, buf)
 
         # read checksum
-        self.spi.write(b'\xff')
-        self.spi.write(b'\xff')
+        self.spi.write(b"\xff")
+        self.spi.write(b"\xff")
 
         self.cs(1)
-        self.spi.write(b'\xff')
+        self.spi.write(b"\xff")
 
     def write(self, token, buf):
         self.cs(0)
@@ -196,42 +199,42 @@ def write(self, token, buf):
         # send: start of block, data, checksum
         self.spi.read(1, token)
         self.spi.write(buf)
-        self.spi.write(b'\xff')
-        self.spi.write(b'\xff')
+        self.spi.write(b"\xff")
+        self.spi.write(b"\xff")
 
         # check the response
-        if (self.spi.read(1, 0xff)[0] & 0x1f) != 0x05:
+        if (self.spi.read(1, 0xFF)[0] & 0x1F) != 0x05:
             self.cs(1)
-            self.spi.write(b'\xff')
+            self.spi.write(b"\xff")
             return
 
         # wait for write to finish
-        while self.spi.read(1, 0xff)[0] == 0:
+        while self.spi.read(1, 0xFF)[0] == 0:
             pass
 
         self.cs(1)
-        self.spi.write(b'\xff')
+        self.spi.write(b"\xff")
 
     def write_token(self, token):
         self.cs(0)
         self.spi.read(1, token)
-        self.spi.write(b'\xff')
+        self.spi.write(b"\xff")
         # wait for write to finish
-        while self.spi.read(1, 0xff)[0] == 0x00:
+        while self.spi.read(1, 0xFF)[0] == 0x00:
             pass
 
         self.cs(1)
-        self.spi.write(b'\xff')
+        self.spi.write(b"\xff")
 
     def readblocks(self, block_num, buf):
         nblocks = len(buf) // 512
-        assert nblocks and not len(buf) % 512, 'Buffer length is invalid'
+        assert nblocks and not len(buf) % 512, "Buffer length is invalid"
         if nblocks == 1:
             # CMD17: set read address for single block
             if self.cmd(17, block_num * self.cdv, 0, release=False) != 0:
                 # release the card
                 self.cs(1)
-                raise OSError(5) # EIO
+                raise OSError(5)  # EIO
             # receive the data and release card
             self.readinto(buf)
         else:
@@ -239,7 +242,7 @@ def readblocks(self, block_num, buf):
             if self.cmd(18, block_num * self.cdv, 0, release=False) != 0:
                 # release the card
                 self.cs(1)
-                raise OSError(5) # EIO
+                raise OSError(5)  # EIO
             offset = 0
             mv = memoryview(buf)
             while nblocks:
@@ -247,23 +250,23 @@ def readblocks(self, block_num, buf):
                 self.readinto(mv[offset : offset + 512])
                 offset += 512
                 nblocks -= 1
-            if self.cmd(12, 0, 0xff, skip1=True):
-                raise OSError(5) # EIO
+            if self.cmd(12, 0, 0xFF, skip1=True):
+                raise OSError(5)  # EIO
 
     def writeblocks(self, block_num, buf):
         nblocks, err = divmod(len(buf), 512)
-        assert nblocks and not err, 'Buffer length is invalid'
+        assert nblocks and not err, "Buffer length is invalid"
         if nblocks == 1:
             # CMD24: set write address for single block
             if self.cmd(24, block_num * self.cdv, 0) != 0:
-                raise OSError(5) # EIO
+                raise OSError(5)  # EIO
 
             # send the data
             self.write(_TOKEN_DATA, buf)
         else:
             # CMD25: set write address for first block
             if self.cmd(25, block_num * self.cdv, 0) != 0:
-                raise OSError(5) # EIO
+                raise OSError(5)  # EIO
             # send the data
             offset = 0
             mv = memoryview(buf)
@@ -274,5 +277,5 @@ def writeblocks(self, block_num, buf):
             self.write_token(_TOKEN_STOP_TRAN)
 
     def ioctl(self, op, arg):
-        if op == 4: # get number of blocks
+        if op == 4:  # get number of blocks
             return self.sectors
diff --git a/drivers/sdcard/sdtest.py b/drivers/sdcard/sdtest.py
index 01fe65aa942a9..018ef7c64aa19 100644
--- a/drivers/sdcard/sdtest.py
+++ b/drivers/sdcard/sdtest.py
@@ -2,59 +2,60 @@
 # Peter hinch 30th Jan 2016
 import os, sdcard, machine
 
+
 def sdtest():
     spi = machine.SPI(1)
     spi.init()  # Ensure right baudrate
-    sd = sdcard.SDCard(spi, machine.Pin.board.X21) # Compatible with PCB
+    sd = sdcard.SDCard(spi, machine.Pin.board.X21)  # Compatible with PCB
     vfs = os.VfsFat(sd)
-    os.mount(vfs, '/fc')
-    print('Filesystem check')
-    print(os.listdir('/fc'))
+    os.mount(vfs, "/fc")
+    print("Filesystem check")
+    print(os.listdir("/fc"))
 
-    line = 'abcdefghijklmnopqrstuvwxyz\n'
-    lines = line * 200 # 5400 chars
-    short = '1234567890\n'
+    line = "abcdefghijklmnopqrstuvwxyz\n"
+    lines = line * 200  # 5400 chars
+    short = "1234567890\n"
 
-    fn = '/fc/rats.txt'
+    fn = "/fc/rats.txt"
     print()
-    print('Multiple block read/write')
-    with open(fn,'w') as f:
+    print("Multiple block read/write")
+    with open(fn, "w") as f:
         n = f.write(lines)
-        print(n, 'bytes written')
+        print(n, "bytes written")
         n = f.write(short)
-        print(n, 'bytes written')
+        print(n, "bytes written")
         n = f.write(lines)
-        print(n, 'bytes written')
+        print(n, "bytes written")
 
-    with open(fn,'r') as f:
+    with open(fn, "r") as f:
         result1 = f.read()
-        print(len(result1), 'bytes read')
+        print(len(result1), "bytes read")
 
-    fn = '/fc/rats1.txt'
+    fn = "/fc/rats1.txt"
     print()
-    print('Single block read/write')
-    with open(fn,'w') as f:
-        n = f.write(short) # one block
-        print(n, 'bytes written')
+    print("Single block read/write")
+    with open(fn, "w") as f:
+        n = f.write(short)  # one block
+        print(n, "bytes written")
 
-    with open(fn,'r') as f:
+    with open(fn, "r") as f:
         result2 = f.read()
-        print(len(result2), 'bytes read')
+        print(len(result2), "bytes read")
 
-    os.umount('/fc')
+    os.umount("/fc")
 
     print()
-    print('Verifying data read back')
+    print("Verifying data read back")
     success = True
-    if result1 == ''.join((lines, short, lines)):
-        print('Large file Pass')
+    if result1 == "".join((lines, short, lines)):
+        print("Large file Pass")
     else:
-        print('Large file Fail')
+        print("Large file Fail")
         success = False
     if result2 == short:
-        print('Small file Pass')
+        print("Small file Pass")
     else:
-        print('Small file Fail')
+        print("Small file Fail")
         success = False
     print()
-    print('Tests', 'passed' if success else 'failed')
+    print("Tests", "passed" if success else "failed")
diff --git a/drivers/wiznet5k/ethernet/w5200/w5200.c b/drivers/wiznet5k/ethernet/w5200/w5200.c
index 8c3780792eff7..a84d3c9fa7bcb 100644
--- a/drivers/wiznet5k/ethernet/w5200/w5200.c
+++ b/drivers/wiznet5k/ethernet/w5200/w5200.c
@@ -52,10 +52,19 @@
 
 #include "w5200.h"
 
+#if WIZCHIP_USE_MAX_BUFFER
+// This option is intended to be used when MACRAW mode is enabled, to allow
+// the single raw socket to use all the available buffer space.
+#define SMASK (16 * 1024 - 1) /* tx buffer mask */
+#define RMASK (16 * 1024 - 1) /* rx buffer mask */
+#define SSIZE (16 * 1024) /* max tx buffer size */
+#define RSIZE (16 * 1024) /* max rx buffer size */
+#else
 #define SMASK (0x7ff) /* tx buffer mask */
 #define RMASK (0x7ff) /* rx buffer mask */
 #define SSIZE (2048) /* max tx buffer size */
 #define RSIZE (2048) /* max rx buffer size */
+#endif
 
 #define TXBUF_BASE (0x8000)
 #define RXBUF_BASE (0xc000)
diff --git a/examples/SDdatalogger/boot.py b/examples/SDdatalogger/boot.py
index 4ac94bbaa4e44..bc42cef2e97cf 100644
--- a/examples/SDdatalogger/boot.py
+++ b/examples/SDdatalogger/boot.py
@@ -8,18 +8,18 @@
 
 import pyb
 
-pyb.LED(3).on()                 # indicate we are waiting for switch press
-pyb.delay(2000)                 # wait for user to maybe press the switch
-switch_value = pyb.Switch()()   # sample the switch at end of delay
-pyb.LED(3).off()                # indicate that we finished waiting for the switch
+pyb.LED(3).on()  # indicate we are waiting for switch press
+pyb.delay(2000)  # wait for user to maybe press the switch
+switch_value = pyb.Switch()()  # sample the switch at end of delay
+pyb.LED(3).off()  # indicate that we finished waiting for the switch
 
-pyb.LED(4).on()                 # indicate that we are selecting the mode
+pyb.LED(4).on()  # indicate that we are selecting the mode
 
 if switch_value:
-    pyb.usb_mode('VCP+MSC')
-    pyb.main('cardreader.py')           # if switch was pressed, run this
+    pyb.usb_mode("VCP+MSC")
+    pyb.main("cardreader.py")  # if switch was pressed, run this
 else:
-    pyb.usb_mode('VCP+HID')
-    pyb.main('datalogger.py')           # if switch wasn't pressed, run this
+    pyb.usb_mode("VCP+HID")
+    pyb.main("datalogger.py")  # if switch wasn't pressed, run this
 
-pyb.LED(4).off()                # indicate that we finished selecting the mode
+pyb.LED(4).off()  # indicate that we finished selecting the mode
diff --git a/examples/SDdatalogger/datalogger.py b/examples/SDdatalogger/datalogger.py
index 0690c20bb9c45..3d6f98b389272 100644
--- a/examples/SDdatalogger/datalogger.py
+++ b/examples/SDdatalogger/datalogger.py
@@ -17,17 +17,17 @@
 
     # start if switch is pressed
     if switch():
-        pyb.delay(200)                      # delay avoids detection of multiple presses
-        blue.on()                           # blue LED indicates file open
-        log = open('/sd/log.csv', 'w')       # open file on SD (SD: '/sd/', flash: '/flash/)
+        pyb.delay(200)  # delay avoids detection of multiple presses
+        blue.on()  # blue LED indicates file open
+        log = open("/sd/log.csv", "w")  # open file on SD (SD: '/sd/', flash: '/flash/)
 
         # until switch is pressed again
         while not switch():
-            t = pyb.millis()                            # get time
-            x, y, z = accel.filtered_xyz()              # get acceleration data
-            log.write('{},{},{},{}\n'.format(t,x,y,z))  # write data to file
+            t = pyb.millis()  # get time
+            x, y, z = accel.filtered_xyz()  # get acceleration data
+            log.write("{},{},{},{}\n".format(t, x, y, z))  # write data to file
 
         # end after switch is pressed again
-        log.close()                         # close file
-        blue.off()                          # blue LED indicates file closed
-        pyb.delay(200)                      # delay avoids detection of multiple presses
+        log.close()  # close file
+        blue.off()  # blue LED indicates file closed
+        pyb.delay(200)  # delay avoids detection of multiple presses
diff --git a/examples/accel_i2c.py b/examples/accel_i2c.py
index d635e3ccc1ff6..7229c228993ec 100644
--- a/examples/accel_i2c.py
+++ b/examples/accel_i2c.py
@@ -17,10 +17,10 @@
 i2c = I2C(1, baudrate=100000)
 addrs = i2c.scan()
 print("Scanning devices:", [hex(x) for x in addrs])
-if 0x4c not in addrs:
+if 0x4C not in addrs:
     print("Accelerometer is not detected")
 
-ACCEL_ADDR = 0x4c
+ACCEL_ADDR = 0x4C
 ACCEL_AXIS_X_REG = 0
 ACCEL_MODE_REG = 7
 
diff --git a/examples/accellog.py b/examples/accellog.py
index b1f289f8ad244..e8b5d101daff7 100644
--- a/examples/accellog.py
+++ b/examples/accellog.py
@@ -2,16 +2,19 @@
 
 import pyb
 
-accel = pyb.Accel()                                 # create object of accelerometer
-blue = pyb.LED(4)                                   # create object of blue LED
+accel = pyb.Accel()  # create object of accelerometer
+blue = pyb.LED(4)  # create object of blue LED
 
-log = open('/sd/log.csv', 'w')                      # open file to write data - /sd/ is the SD-card, /flash/ the internal memory
-blue.on()                                           # turn on blue LED
+# open file to write data - /sd/ is the SD-card, /flash/ the internal memory
+log = open("/sd/log.csv", "w")
 
-for i in range(100):                                # do 100 times (if the board is connected via USB, you can't write longer because the PC tries to open the filesystem which messes up your file.)
-        t = pyb.millis()                            # get time since reset
-        x, y, z = accel.filtered_xyz()              # get acceleration data
-        log.write('{},{},{},{}\n'.format(t,x,y,z))  # write data to file
+blue.on()  # turn on blue LED
 
-log.close()                                         # close file
-blue.off()                                          # turn off LED
+# do 100 times (if the board is connected via USB, you can't write longer because the PC tries to open the filesystem which messes up your file.)
+for i in range(100):
+    t = pyb.millis()  # get time since reset
+    x, y, z = accel.filtered_xyz()  # get acceleration data
+    log.write("{},{},{},{}\n".format(t, x, y, z))  # write data to file
+
+log.close()  # close file
+blue.off()  # turn off LED
diff --git a/examples/asmled.py b/examples/asmled.py
index 917d9ba03cd1d..09a06c184ade4 100644
--- a/examples/asmled.py
+++ b/examples/asmled.py
@@ -2,8 +2,8 @@
 # this version is overly verbose and uses word stores
 @micropython.asm_thumb
 def flash_led(r0):
-    movw(r1, (stm.GPIOA + stm.GPIO_BSRRL) & 0xffff)
-    movt(r1, ((stm.GPIOA + stm.GPIO_BSRRL) >> 16) & 0x7fff)
+    movw(r1, (stm.GPIOA + stm.GPIO_BSRRL) & 0xFFFF)
+    movt(r1, ((stm.GPIOA + stm.GPIO_BSRRL) >> 16) & 0x7FFF)
     movw(r2, 1 << 13)
     movt(r2, 0)
     movw(r3, 0)
@@ -17,8 +17,8 @@ def flash_led(r0):
     str(r2, [r1, 0])
 
     # delay for a bit
-    movw(r4, 5599900 & 0xffff)
-    movt(r4, (5599900 >> 16) & 0xffff)
+    movw(r4, 5599900 & 0xFFFF)
+    movt(r4, (5599900 >> 16) & 0xFFFF)
     label(delay_on)
     sub(r4, r4, 1)
     cmp(r4, 0)
@@ -28,8 +28,8 @@ def flash_led(r0):
     str(r3, [r1, 0])
 
     # delay for a bit
-    movw(r4, 5599900 & 0xffff)
-    movt(r4, (5599900 >> 16) & 0xffff)
+    movw(r4, 5599900 & 0xFFFF)
+    movt(r4, (5599900 >> 16) & 0xFFFF)
     label(delay_off)
     sub(r4, r4, 1)
     cmp(r4, 0)
@@ -41,6 +41,7 @@ def flash_led(r0):
     cmp(r0, 0)
     bgt(loop1)
 
+
 # flash LED #2 using inline assembler
 # this version uses half-word sortes, and the convenience assembler operation 'movwt'
 @micropython.asm_thumb
@@ -81,5 +82,6 @@ def flash_led_v2(r0):
     cmp(r0, 0)
     bgt(loop1)
 
+
 flash_led(5)
 flash_led_v2(5)
diff --git a/examples/asmsum.py b/examples/asmsum.py
index 07e71c7384927..f465b25afda75 100644
--- a/examples/asmsum.py
+++ b/examples/asmsum.py
@@ -22,6 +22,7 @@ def asm_sum_words(r0, r1):
 
     mov(r0, r2)
 
+
 @micropython.asm_thumb
 def asm_sum_bytes(r0, r1):
 
@@ -46,12 +47,13 @@ def asm_sum_bytes(r0, r1):
 
     mov(r0, r2)
 
+
 import array
 
-b = array.array('l', (100, 200, 300, 400))
+b = array.array("l", (100, 200, 300, 400))
 n = asm_sum_words(len(b), b)
 print(b, n)
 
-b = array.array('b', (10, 20, 30, 40, 50, 60, 70, 80))
+b = array.array("b", (10, 20, 30, 40, 50, 60, 70, 80))
 n = asm_sum_bytes(len(b), b)
 print(b, n)
diff --git a/examples/bluetooth/ble_advertising.py b/examples/bluetooth/ble_advertising.py
new file mode 100644
index 0000000000000..3fb1281f636ee
--- /dev/null
+++ b/examples/bluetooth/ble_advertising.py
@@ -0,0 +1,92 @@
+# Helpers for generating BLE advertising payloads.
+
+from micropython import const
+import struct
+import bluetooth
+
+# Advertising payloads are repeated packets of the following form:
+#   1 byte data length (N + 1)
+#   1 byte type (see constants below)
+#   N bytes type-specific data
+
+_ADV_TYPE_FLAGS = const(0x01)
+_ADV_TYPE_NAME = const(0x09)
+_ADV_TYPE_UUID16_COMPLETE = const(0x3)
+_ADV_TYPE_UUID32_COMPLETE = const(0x5)
+_ADV_TYPE_UUID128_COMPLETE = const(0x7)
+_ADV_TYPE_UUID16_MORE = const(0x2)
+_ADV_TYPE_UUID32_MORE = const(0x4)
+_ADV_TYPE_UUID128_MORE = const(0x6)
+_ADV_TYPE_APPEARANCE = const(0x19)
+
+
+# Generate a payload to be passed to gap_advertise(adv_data=...).
+def advertising_payload(limited_disc=False, br_edr=False, name=None, services=None, appearance=0):
+    payload = bytearray()
+
+    def _append(adv_type, value):
+        nonlocal payload
+        payload += struct.pack("BB", len(value) + 1, adv_type) + value
+
+    _append(
+        _ADV_TYPE_FLAGS,
+        struct.pack("B", (0x01 if limited_disc else 0x02) + (0x00 if br_edr else 0x04)),
+    )
+
+    if name:
+        _append(_ADV_TYPE_NAME, name)
+
+    if services:
+        for uuid in services:
+            b = bytes(uuid)
+            if len(b) == 2:
+                _append(_ADV_TYPE_UUID16_COMPLETE, b)
+            elif len(b) == 4:
+                _append(_ADV_TYPE_UUID32_COMPLETE, b)
+            elif len(b) == 16:
+                _append(_ADV_TYPE_UUID128_COMPLETE, b)
+
+    # See org.bluetooth.characteristic.gap.appearance.xml
+    _append(_ADV_TYPE_APPEARANCE, struct.pack("<h", appearance))
+
+    return payload
+
+
+def decode_field(payload, adv_type):
+    i = 0
+    result = []
+    while i + 1 < len(payload):
+        if payload[i + 1] == adv_type:
+            result.append(payload[i + 2 : i + payload[i] + 1])
+        i += 1 + payload[i]
+    return result
+
+
+def decode_name(payload):
+    n = decode_field(payload, _ADV_TYPE_NAME)
+    return str(n[0], "utf-8") if n else ""
+
+
+def decode_services(payload):
+    services = []
+    for u in decode_field(payload, _ADV_TYPE_UUID16_COMPLETE):
+        services.append(bluetooth.UUID(struct.unpack("<h", u)[0]))
+    for u in decode_field(payload, _ADV_TYPE_UUID32_COMPLETE):
+        services.append(bluetooth.UUID(struct.unpack("<d", u)[0]))
+    for u in decode_field(payload, _ADV_TYPE_UUID128_COMPLETE):
+        services.append(bluetooth.UUID(u))
+    return services
+
+
+def demo():
+    payload = advertising_payload(
+        name="micropython",
+        services=[bluetooth.UUID(0x181A), bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")],
+    )
+    print(payload)
+    print(decode_name(payload))
+    print(decode_services(payload))
+
+
+if __name__ == "__main__":
+    demo()
diff --git a/examples/bluetooth/ble_temperature.py b/examples/bluetooth/ble_temperature.py
new file mode 100644
index 0000000000000..01d2f7441fa17
--- /dev/null
+++ b/examples/bluetooth/ble_temperature.py
@@ -0,0 +1,86 @@
+# This example demonstrates a simple temperature sensor peripheral.
+#
+# The sensor's local value updates every second, and it will notify
+# any connected central every 10 seconds.
+
+import bluetooth
+import random
+import struct
+import time
+from ble_advertising import advertising_payload
+
+from micropython import const
+
+_IRQ_CENTRAL_CONNECT = const(1 << 0)
+_IRQ_CENTRAL_DISCONNECT = const(1 << 1)
+
+# org.bluetooth.service.environmental_sensing
+_ENV_SENSE_UUID = bluetooth.UUID(0x181A)
+# org.bluetooth.characteristic.temperature
+_TEMP_CHAR = (
+    bluetooth.UUID(0x2A6E),
+    bluetooth.FLAG_READ | bluetooth.FLAG_NOTIFY,
+)
+_ENV_SENSE_SERVICE = (
+    _ENV_SENSE_UUID,
+    (_TEMP_CHAR,),
+)
+
+# org.bluetooth.characteristic.gap.appearance.xml
+_ADV_APPEARANCE_GENERIC_THERMOMETER = const(768)
+
+
+class BLETemperature:
+    def __init__(self, ble, name="mpy-temp"):
+        self._ble = ble
+        self._ble.active(True)
+        self._ble.irq(handler=self._irq)
+        ((self._handle,),) = self._ble.gatts_register_services((_ENV_SENSE_SERVICE,))
+        self._connections = set()
+        self._payload = advertising_payload(
+            name=name, services=[_ENV_SENSE_UUID], appearance=_ADV_APPEARANCE_GENERIC_THERMOMETER
+        )
+        self._advertise()
+
+    def _irq(self, event, data):
+        # Track connections so we can send notifications.
+        if event == _IRQ_CENTRAL_CONNECT:
+            conn_handle, _, _, = data
+            self._connections.add(conn_handle)
+        elif event == _IRQ_CENTRAL_DISCONNECT:
+            conn_handle, _, _, = data
+            self._connections.remove(conn_handle)
+            # Start advertising again to allow a new connection.
+            self._advertise()
+
+    def set_temperature(self, temp_deg_c, notify=False):
+        # Data is sint16 in degrees Celsius with a resolution of 0.01 degrees Celsius.
+        # Write the local value, ready for a central to read.
+        self._ble.gatts_write(self._handle, struct.pack("<h", int(temp_deg_c * 100)))
+        if notify:
+            for conn_handle in self._connections:
+                # Notify connected centrals to issue a read.
+                self._ble.gatts_notify(conn_handle, self._handle)
+
+    def _advertise(self, interval_us=500000):
+        self._ble.gap_advertise(interval_us, adv_data=self._payload)
+
+
+def demo():
+    ble = bluetooth.BLE()
+    temp = BLETemperature(ble)
+
+    t = 25
+    i = 0
+
+    while True:
+        # Write every second, notify every 10 seconds.
+        i = (i + 1) % 10
+        temp.set_temperature(t, notify=i == 0)
+        # Random walk the temperature.
+        t += random.uniform(-0.5, 0.5)
+        time.sleep_ms(1000)
+
+
+if __name__ == "__main__":
+    demo()
diff --git a/examples/bluetooth/ble_temperature_central.py b/examples/bluetooth/ble_temperature_central.py
new file mode 100644
index 0000000000000..04fed0a299078
--- /dev/null
+++ b/examples/bluetooth/ble_temperature_central.py
@@ -0,0 +1,241 @@
+# This example finds and connects to a BLE temperature sensor (e.g. the one in ble_temperature.py).
+
+import bluetooth
+import random
+import struct
+import time
+import micropython
+
+from ble_advertising import decode_services, decode_name
+
+from micropython import const
+
+_IRQ_CENTRAL_CONNECT = const(1 << 0)
+_IRQ_CENTRAL_DISCONNECT = const(1 << 1)
+_IRQ_GATTS_WRITE = const(1 << 2)
+_IRQ_GATTS_READ_REQUEST = const(1 << 3)
+_IRQ_SCAN_RESULT = const(1 << 4)
+_IRQ_SCAN_COMPLETE = const(1 << 5)
+_IRQ_PERIPHERAL_CONNECT = const(1 << 6)
+_IRQ_PERIPHERAL_DISCONNECT = const(1 << 7)
+_IRQ_GATTC_SERVICE_RESULT = const(1 << 8)
+_IRQ_GATTC_CHARACTERISTIC_RESULT = const(1 << 9)
+_IRQ_GATTC_DESCRIPTOR_RESULT = const(1 << 10)
+_IRQ_GATTC_READ_RESULT = const(1 << 11)
+_IRQ_GATTC_WRITE_STATUS = const(1 << 12)
+_IRQ_GATTC_NOTIFY = const(1 << 13)
+_IRQ_GATTC_INDICATE = const(1 << 14)
+_IRQ_ALL = const(0xFFFF)
+
+_ADV_IND = const(0x00)
+_ADV_DIRECT_IND = const(0x01)
+_ADV_SCAN_IND = const(0x02)
+_ADV_NONCONN_IND = const(0x03)
+
+# org.bluetooth.service.environmental_sensing
+_ENV_SENSE_UUID = bluetooth.UUID(0x181A)
+# org.bluetooth.characteristic.temperature
+_TEMP_UUID = bluetooth.UUID(0x2A6E)
+_TEMP_CHAR = (
+    _TEMP_UUID,
+    bluetooth.FLAG_READ | bluetooth.FLAG_NOTIFY,
+)
+_ENV_SENSE_SERVICE = (
+    _ENV_SENSE_UUID,
+    (_TEMP_CHAR,),
+)
+
+# org.bluetooth.characteristic.gap.appearance.xml
+_ADV_APPEARANCE_GENERIC_THERMOMETER = const(768)
+
+
+class BLETemperatureCentral:
+    def __init__(self, ble):
+        self._ble = ble
+        self._ble.active(True)
+        self._ble.irq(handler=self._irq)
+
+        self._reset()
+
+    def _reset(self):
+        # Cached name and address from a successful scan.
+        self._name = None
+        self._addr_type = None
+        self._addr = None
+
+        # Cached value (if we have one)
+        self._value = None
+
+        # Callbacks for completion of various operations.
+        # These reset back to None after being invoked.
+        self._scan_callback = None
+        self._conn_callback = None
+        self._read_callback = None
+
+        # Persistent callback for when new data is notified from the device.
+        self._notify_callback = None
+
+        # Connected device.
+        self._conn_handle = None
+        self._value_handle = None
+
+    def _irq(self, event, data):
+        if event == _IRQ_SCAN_RESULT:
+            addr_type, addr, adv_type, rssi, adv_data = data
+            if adv_type in (_ADV_IND, _ADV_DIRECT_IND,) and _ENV_SENSE_UUID in decode_services(
+                adv_data
+            ):
+                # Found a potential device, remember it and stop scanning.
+                self._addr_type = addr_type
+                self._addr = bytes(
+                    addr
+                )  # Note: addr buffer is owned by caller so need to copy it.
+                self._name = decode_name(adv_data) or "?"
+                self._ble.gap_scan(None)
+
+        elif event == _IRQ_SCAN_COMPLETE:
+            if self._scan_callback:
+                if self._addr:
+                    # Found a device during the scan (and the scan was explicitly stopped).
+                    self._scan_callback(self._addr_type, self._addr, self._name)
+                    self._scan_callback = None
+                else:
+                    # Scan timed out.
+                    self._scan_callback(None, None, None)
+
+        elif event == _IRQ_PERIPHERAL_CONNECT:
+            # Connect successful.
+            conn_handle, addr_type, addr, = data
+            if addr_type == self._addr_type and addr == self._addr:
+                self._conn_handle = conn_handle
+                self._ble.gattc_discover_services(self._conn_handle)
+
+        elif event == _IRQ_PERIPHERAL_DISCONNECT:
+            # Disconnect (either initiated by us or the remote end).
+            conn_handle, _, _, = data
+            if conn_handle == self._conn_handle:
+                # If it was initiated by us, it'll already be reset.
+                self._reset()
+
+        elif event == _IRQ_GATTC_SERVICE_RESULT:
+            # Connected device returned a service.
+            conn_handle, start_handle, end_handle, uuid = data
+            if conn_handle == self._conn_handle and uuid == _ENV_SENSE_UUID:
+                self._ble.gattc_discover_characteristics(
+                    self._conn_handle, start_handle, end_handle
+                )
+
+        elif event == _IRQ_GATTC_CHARACTERISTIC_RESULT:
+            # Connected device returned a characteristic.
+            conn_handle, def_handle, value_handle, properties, uuid = data
+            if conn_handle == self._conn_handle and uuid == _TEMP_UUID:
+                self._value_handle = value_handle
+                # We've finished connecting and discovering device, fire the connect callback.
+                if self._conn_callback:
+                    self._conn_callback()
+
+        elif event == _IRQ_GATTC_READ_RESULT:
+            # A read completed successfully.
+            conn_handle, value_handle, char_data = data
+            if conn_handle == self._conn_handle and value_handle == self._value_handle:
+                self._update_value(char_data)
+                if self._read_callback:
+                    self._read_callback(self._value)
+                    self._read_callback = None
+
+        elif event == _IRQ_GATTC_NOTIFY:
+            # The ble_temperature.py demo periodically notifies its value.
+            conn_handle, value_handle, notify_data = data
+            if conn_handle == self._conn_handle and value_handle == self._value_handle:
+                self._update_value(notify_data)
+                if self._notify_callback:
+                    self._notify_callback(self._value)
+
+    # Returns true if we've successfully connected and discovered characteristics.
+    def is_connected(self):
+        return self._conn_handle is not None and self._value_handle is not None
+
+    # Find a device advertising the environmental sensor service.
+    def scan(self, callback=None):
+        self._addr_type = None
+        self._addr = None
+        self._scan_callback = callback
+        self._ble.gap_scan(2000, 30000, 30000)
+
+    # Connect to the specified device (otherwise use cached address from a scan).
+    def connect(self, addr_type=None, addr=None, callback=None):
+        self._addr_type = addr_type or self._addr_type
+        self._addr = addr or self._addr
+        self._conn_callback = callback
+        if self._addr_type is None or self._addr is None:
+            return False
+        self._ble.gap_connect(self._addr_type, self._addr)
+        return True
+
+    # Disconnect from current device.
+    def disconnect(self):
+        if not self._conn_handle:
+            return
+        self._ble.gap_disconnect(self._conn_handle)
+        self._reset()
+
+    # Issues an (asynchronous) read, will invoke callback with data.
+    def read(self, callback):
+        if not self.is_connected():
+            return
+        self._read_callback = callback
+        self._ble.gattc_read(self._conn_handle, self._value_handle)
+
+    # Sets a callback to be invoked when the device notifies us.
+    def on_notify(self, callback):
+        self._notify_callback = callback
+
+    def _update_value(self, data):
+        # Data is sint16 in degrees Celsius with a resolution of 0.01 degrees Celsius.
+        self._value = struct.unpack("<h", data)[0] / 100
+        return self._value
+
+    def value(self):
+        return self._value
+
+
+def demo():
+    ble = bluetooth.BLE()
+    central = BLETemperatureCentral(ble)
+
+    not_found = False
+
+    def on_scan(addr_type, addr, name):
+        if addr_type is not None:
+            print("Found sensor:", addr_type, addr, name)
+            central.connect()
+        else:
+            nonlocal not_found
+            not_found = True
+            print("No sensor found.")
+
+    central.scan(callback=on_scan)
+
+    # Wait for connection...
+    while not central.is_connected():
+        time.sleep_ms(100)
+        if not_found:
+            return
+
+    print("Connected")
+
+    # Explicitly issue reads, using "print" as the callback.
+    while central.is_connected():
+        central.read(callback=print)
+        time.sleep_ms(2000)
+
+    # Alternative to the above, just show the most recently notified value.
+    # while central.is_connected():
+    #     print(central.value())
+    #     time.sleep_ms(2000)
+
+    print("Disconnected")
+
+
+if __name__ == "__main__":
+    demo()
diff --git a/examples/bluetooth/ble_uart_peripheral.py b/examples/bluetooth/ble_uart_peripheral.py
new file mode 100644
index 0000000000000..c013d96ec9ef1
--- /dev/null
+++ b/examples/bluetooth/ble_uart_peripheral.py
@@ -0,0 +1,116 @@
+# This example demonstrates a peripheral implementing the Nordic UART Service (NUS).
+
+import bluetooth
+from ble_advertising import advertising_payload
+
+from micropython import const
+
+_IRQ_CENTRAL_CONNECT = const(1 << 0)
+_IRQ_CENTRAL_DISCONNECT = const(1 << 1)
+_IRQ_GATTS_WRITE = const(1 << 2)
+
+_UART_UUID = bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
+_UART_TX = (
+    bluetooth.UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E"),
+    bluetooth.FLAG_NOTIFY,
+)
+_UART_RX = (
+    bluetooth.UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E"),
+    bluetooth.FLAG_WRITE,
+)
+_UART_SERVICE = (
+    _UART_UUID,
+    (_UART_TX, _UART_RX,),
+)
+
+# org.bluetooth.characteristic.gap.appearance.xml
+_ADV_APPEARANCE_GENERIC_COMPUTER = const(128)
+
+
+class BLEUART:
+    def __init__(self, ble, name="mpy-uart", rxbuf=100):
+        self._ble = ble
+        self._ble.active(True)
+        self._ble.irq(handler=self._irq)
+        ((self._tx_handle, self._rx_handle,),) = self._ble.gatts_register_services(
+            (_UART_SERVICE,)
+        )
+        # Increase the size of the rx buffer and enable append mode.
+        self._ble.gatts_set_buffer(self._rx_handle, rxbuf, True)
+        self._connections = set()
+        self._rx_buffer = bytearray()
+        self._handler = None
+        # Optionally add services=[_UART_UUID], but this is likely to make the payload too large.
+        self._payload = advertising_payload(name=name, appearance=_ADV_APPEARANCE_GENERIC_COMPUTER)
+        self._advertise()
+
+    def irq(self, handler):
+        self._handler = handler
+
+    def _irq(self, event, data):
+        # Track connections so we can send notifications.
+        if event == _IRQ_CENTRAL_CONNECT:
+            conn_handle, _, _, = data
+            self._connections.add(conn_handle)
+        elif event == _IRQ_CENTRAL_DISCONNECT:
+            conn_handle, _, _, = data
+            if conn_handle in self._connections:
+                self._connections.remove(conn_handle)
+            # Start advertising again to allow a new connection.
+            self._advertise()
+        elif event == _IRQ_GATTS_WRITE:
+            conn_handle, value_handle, = data
+            if conn_handle in self._connections and value_handle == self._rx_handle:
+                self._rx_buffer += self._ble.gatts_read(self._rx_handle)
+                if self._handler:
+                    self._handler()
+
+    def any(self):
+        return len(self._rx_buffer)
+
+    def read(self, sz=None):
+        if not sz:
+            sz = len(self._rx_buffer)
+        result = self._rx_buffer[0:sz]
+        self._rx_buffer = self._rx_buffer[sz:]
+        return result
+
+    def write(self, data):
+        for conn_handle in self._connections:
+            self._ble.gatts_notify(conn_handle, self._tx_handle, data)
+
+    def close(self):
+        for conn_handle in self._connections:
+            self._ble.gap_disconnect(conn_handle)
+        self._connections.clear()
+
+    def _advertise(self, interval_us=500000):
+        self._ble.gap_advertise(interval_us, adv_data=self._payload)
+
+
+def demo():
+    import time
+
+    ble = bluetooth.BLE()
+    uart = BLEUART(ble)
+
+    def on_rx():
+        print("rx: ", uart.read().decode().strip())
+
+    uart.irq(handler=on_rx)
+    nums = [4, 8, 15, 16, 23, 42]
+    i = 0
+
+    try:
+        while True:
+            uart.write(str(nums[i]) + "\n")
+            i = (i + 1) % len(nums)
+            time.sleep_ms(1000)
+    except KeyboardInterrupt:
+        pass
+
+    uart.close()
+
+
+if __name__ == "__main__":
+    demo()
diff --git a/examples/bluetooth/ble_uart_repl.py b/examples/bluetooth/ble_uart_repl.py
new file mode 100644
index 0000000000000..9e8a38ff4b5e8
--- /dev/null
+++ b/examples/bluetooth/ble_uart_repl.py
@@ -0,0 +1,82 @@
+# Proof-of-concept of a REPL over BLE UART.
+#
+# Tested with the Adafruit Bluefruit app on Android.
+# Set the EoL characters to \r\n.
+
+import bluetooth
+import io
+import os
+import micropython
+import machine
+
+from ble_uart_peripheral import BLEUART
+
+_MP_STREAM_POLL = const(3)
+_MP_STREAM_POLL_RD = const(0x0001)
+
+# TODO: Remove this when STM32 gets machine.Timer.
+if hasattr(machine, "Timer"):
+    _timer = machine.Timer(-1)
+else:
+    _timer = None
+
+# Batch writes into 50ms intervals.
+def schedule_in(handler, delay_ms):
+    def _wrap(_arg):
+        handler()
+
+    if _timer:
+        _timer.init(mode=machine.Timer.ONE_SHOT, period=delay_ms, callback=_wrap)
+    else:
+        micropython.schedule(_wrap, None)
+
+
+# Simple buffering stream to support the dupterm requirements.
+class BLEUARTStream(io.IOBase):
+    def __init__(self, uart):
+        self._uart = uart
+        self._tx_buf = bytearray()
+        self._uart.irq(self._on_rx)
+
+    def _on_rx(self):
+        # Needed for ESP32.
+        if hasattr(os, "dupterm_notify"):
+            os.dupterm_notify(None)
+
+    def read(self, sz=None):
+        return self._uart.read(sz)
+
+    def readinto(self, buf):
+        avail = self._uart.read(len(buf))
+        if not avail:
+            return None
+        for i in range(len(avail)):
+            buf[i] = avail[i]
+        return len(avail)
+
+    def ioctl(self, op, arg):
+        if op == _MP_STREAM_POLL:
+            if self._uart.any():
+                return _MP_STREAM_POLL_RD
+        return 0
+
+    def _flush(self):
+        data = self._tx_buf[0:100]
+        self._tx_buf = self._tx_buf[100:]
+        self._uart.write(data)
+        if self._tx_buf:
+            schedule_in(self._flush, 50)
+
+    def write(self, buf):
+        empty = not self._tx_buf
+        self._tx_buf += buf
+        if empty:
+            schedule_in(self._flush, 50)
+
+
+def start():
+    ble = bluetooth.BLE()
+    uart = BLEUART(ble, name="mpy-repl")
+    stream = BLEUARTStream(uart)
+
+    os.dupterm(stream)
diff --git a/examples/conwaylife.py b/examples/conwaylife.py
index 323f42e850e68..44c1a507be8a3 100644
--- a/examples/conwaylife.py
+++ b/examples/conwaylife.py
@@ -1,46 +1,51 @@
-#import essential libraries
+# import essential libraries
 import pyb
 
-lcd = pyb.LCD('x')
+lcd = pyb.LCD("x")
 lcd.light(1)
 
 # do 1 iteration of Conway's Game of Life
 def conway_step():
-    for x in range(128):        # loop over x coordinates
-        for y in range(32):     # loop over y coordinates
+    for x in range(128):  # loop over x coordinates
+        for y in range(32):  # loop over y coordinates
             # count number of neighbours
-            num_neighbours = (lcd.get(x - 1, y - 1) +
-                lcd.get(x, y - 1) +
-                lcd.get(x + 1, y - 1) +
-                lcd.get(x - 1, y) +
-                lcd.get(x + 1, y) +
-                lcd.get(x + 1, y + 1) +
-                lcd.get(x, y + 1) +
-                lcd.get(x - 1, y + 1))
+            num_neighbours = (
+                lcd.get(x - 1, y - 1)
+                + lcd.get(x, y - 1)
+                + lcd.get(x + 1, y - 1)
+                + lcd.get(x - 1, y)
+                + lcd.get(x + 1, y)
+                + lcd.get(x + 1, y + 1)
+                + lcd.get(x, y + 1)
+                + lcd.get(x - 1, y + 1)
+            )
 
             # check if the centre cell is alive or not
             self = lcd.get(x, y)
 
             # apply the rules of life
             if self and not (2 <= num_neighbours <= 3):
-                lcd.pixel(x, y, 0) # not enough, or too many neighbours: cell dies
+                lcd.pixel(x, y, 0)  # not enough, or too many neighbours: cell dies
             elif not self and num_neighbours == 3:
-                lcd.pixel(x, y, 1)   # exactly 3 neighbours around an empty cell: cell is born
+                lcd.pixel(x, y, 1)  # exactly 3 neighbours around an empty cell: cell is born
+
 
 # randomise the start
 def conway_rand():
-    lcd.fill(0)                 # clear the LCD
-    for x in range(128):        # loop over x coordinates
-        for y in range(32):     # loop over y coordinates
-            lcd.pixel(x, y, pyb.rng() & 1)   # set the pixel randomly
+    lcd.fill(0)  # clear the LCD
+    for x in range(128):  # loop over x coordinates
+        for y in range(32):  # loop over y coordinates
+            lcd.pixel(x, y, pyb.rng() & 1)  # set the pixel randomly
+
 
 # loop for a certain number of frames, doing iterations of Conway's Game of Life
 def conway_go(num_frames):
     for i in range(num_frames):
-        conway_step()           # do 1 iteration
-        lcd.show()              # update the LCD
+        conway_step()  # do 1 iteration
+        lcd.show()  # update the LCD
         pyb.delay(50)
 
+
 # testing
 conway_rand()
 conway_go(100)
diff --git a/examples/embedding/Makefile.upylib b/examples/embedding/Makefile.upylib
index 6d6302050cf78..0e388332e68fa 100644
--- a/examples/embedding/Makefile.upylib
+++ b/examples/embedding/Makefile.upylib
@@ -149,13 +149,6 @@ LIB_SRC_C = $(addprefix lib/,\
 	timeutils/timeutils.c \
 	)
 
-ifeq ($(MICROPY_FATFS),1)
-LIB_SRC_C += $(addprefix lib/,\
-	fatfs/ff.c \
-	fatfs/option/ccsbcs.c \
-	)
-endif
-
 OBJ = $(PY_O)
 OBJ += $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(LIB_SRC_C:.c=.o))
diff --git a/examples/embedding/hello-embed.c b/examples/embedding/hello-embed.c
index 96596309660eb..2000b703c11c6 100644
--- a/examples/embedding/hello-embed.c
+++ b/examples/embedding/hello-embed.c
@@ -41,7 +41,7 @@ mp_obj_t execute_from_str(const char *str) {
         qstr src_name = 1/*MP_QSTR_*/;
         mp_lexer_t *lex = mp_lexer_new_from_str_len(src_name, str, strlen(str), false);
         mp_parse_tree_t pt = mp_parse(lex, MP_PARSE_FILE_INPUT);
-        mp_obj_t module_fun = mp_compile(&pt, src_name, MP_EMIT_OPT_NONE, false);
+        mp_obj_t module_fun = mp_compile(&pt, src_name, false);
         mp_call_function_0(module_fun);
         nlr_pop();
         return 0;
diff --git a/examples/embedding/mpconfigport.h b/examples/embedding/mpconfigport.h
deleted file mode 120000
index 142e5d6f4315c..0000000000000
--- a/examples/embedding/mpconfigport.h
+++ /dev/null
@@ -1 +0,0 @@
-mpconfigport_minimal.h
\ No newline at end of file
diff --git a/examples/embedding/mpconfigport.h b/examples/embedding/mpconfigport.h
new file mode 100644
index 0000000000000..89c180b2a8153
--- /dev/null
+++ b/examples/embedding/mpconfigport.h
@@ -0,0 +1 @@
+#include "mpconfigport_minimal.h"
diff --git a/examples/embedding/mpconfigport_minimal.h b/examples/embedding/mpconfigport_minimal.h
index fa52be4ad7720..b5ffd376aeb22 100644
--- a/examples/embedding/mpconfigport_minimal.h
+++ b/examples/embedding/mpconfigport_minimal.h
@@ -97,14 +97,9 @@ extern const struct _mp_obj_module_t mp_module_os;
 // Do not change anything beyond this line
 //////////////////////////////////////////
 
-// Define to 1 to use undertested inefficient GC helper implementation
-// (if more efficient arch-specific one is not available).
-#ifndef MICROPY_GCREGS_SETJMP
-    #ifdef __mips__
-        #define MICROPY_GCREGS_SETJMP (1)
-    #else
-        #define MICROPY_GCREGS_SETJMP (0)
-    #endif
+#if !(defined(MICROPY_GCREGS_SETJMP) || defined(__x86_64__) || defined(__i386__) || defined(__thumb2__) || defined(__thumb__) || defined(__arm__))
+// Fall back to setjmp() implementation for discovery of GC pointers in registers.
+#define MICROPY_GCREGS_SETJMP (1)
 #endif
 
 // type definitions for the specific machine
diff --git a/examples/hwapi/button_reaction.py b/examples/hwapi/button_reaction.py
index b72e813e4c6d2..e5a139a575f2c 100644
--- a/examples/hwapi/button_reaction.py
+++ b/examples/hwapi/button_reaction.py
@@ -4,14 +4,16 @@
 
 # machine.time_pulse_us() function demo
 
-print("""\
+print(
+    """\
 Let's play an interesting game:
 You click button as fast as you can, and I tell you how slow you are.
 Ready? Cliiiiick!
-""")
+"""
+)
 
 while 1:
-    delay = machine.time_pulse_us(BUTTON, 1, 10*1000*1000)
+    delay = machine.time_pulse_us(BUTTON, 1, 10 * 1000 * 1000)
     if delay < 0:
         print("Well, you're *really* slow")
     else:
diff --git a/examples/hwapi/hwconfig_console.py b/examples/hwapi/hwconfig_console.py
index bbcc0e816efd9..1b49d52379af8 100644
--- a/examples/hwapi/hwconfig_console.py
+++ b/examples/hwapi/hwconfig_console.py
@@ -1,7 +1,6 @@
 # This is hwconfig for "emulation" for cases when there's no real hardware.
 # It just prints information to console.
 class LEDClass:
-
     def __init__(self, id):
         self.id = "LED(%d):" % id
 
diff --git a/examples/hwapi/hwconfig_pyboard.py b/examples/hwapi/hwconfig_pyboard.py
index fb260033e567b..a74a1ae151bb8 100644
--- a/examples/hwapi/hwconfig_pyboard.py
+++ b/examples/hwapi/hwconfig_pyboard.py
@@ -1,13 +1,13 @@
 from machine import Pin, Signal
 
 # Red LED on pin LED_RED also kown as A13
-LED = Signal('LED_RED', Pin.OUT)
+LED = Signal("LED_RED", Pin.OUT)
 
 # Green LED on pin LED_GREEN also known as A14
-LED2 = Signal('LED_GREEN', Pin.OUT)
+LED2 = Signal("LED_GREEN", Pin.OUT)
 
 # Yellow LED on pin LED_YELLOW also known as A15
-LED3 = Signal('LED_YELLOW', Pin.OUT)
+LED3 = Signal("LED_YELLOW", Pin.OUT)
 
 # Blue LED on pin LED_BLUE also known as B4
-LED4 = Signal('LED_BLUE', Pin.OUT)
+LED4 = Signal("LED_BLUE", Pin.OUT)
diff --git a/examples/ledangle.py b/examples/ledangle.py
index 8c8d9e99d9570..3d47e8f72d69c 100644
--- a/examples/ledangle.py
+++ b/examples/ledangle.py
@@ -1,5 +1,6 @@
 import pyb
 
+
 def led_angle(seconds_to_run_for):
     # make LED objects
     l1 = pyb.LED(1)
diff --git a/examples/mandel.py b/examples/mandel.py
index bbb8086470220..2f3d7da235b56 100644
--- a/examples/mandel.py
+++ b/examples/mandel.py
@@ -3,13 +3,14 @@
 except:
     pass
 
+
 def mandelbrot():
     # returns True if c, complex, is in the Mandelbrot set
-    #@micropython.native
+    # @micropython.native
     def in_set(c):
         z = 0
         for i in range(40):
-            z = z*z + c
+            z = z * z + c
             if abs(z) > 60:
                 return False
         return True
@@ -21,7 +22,9 @@ def in_set(c):
                 lcd.set(u, v)
     lcd.show()
 
+
 # PC testing
 import lcd
+
 lcd = lcd.LCD(128, 32)
 mandelbrot()
diff --git a/examples/micropython.py b/examples/micropython.py
index f91da94f41e6e..5b87ba192ea06 100644
--- a/examples/micropython.py
+++ b/examples/micropython.py
@@ -2,7 +2,9 @@
 
 # Dummy function decorators
 
+
 def nodecor(x):
     return x
 
+
 bytecode = native = viper = nodecor
diff --git a/examples/natmod/.gitignore b/examples/natmod/.gitignore
new file mode 100644
index 0000000000000..4815d20f06be7
--- /dev/null
+++ b/examples/natmod/.gitignore
@@ -0,0 +1 @@
+*.mpy
diff --git a/examples/natmod/btree/Makefile b/examples/natmod/btree/Makefile
new file mode 100644
index 0000000000000..d795102b4aad8
--- /dev/null
+++ b/examples/natmod/btree/Makefile
@@ -0,0 +1,37 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module (different to built-in btree so it can coexist)
+MOD = btree_$(ARCH)
+
+# Source files (.c or .py)
+SRC = btree_c.c btree_py.py
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin)
+ARCH = x64
+
+BTREE_DIR = $(MPY_DIR)/lib/berkeley-db-1.xx
+BTREE_DEFS = -D__DBINTERFACE_PRIVATE=1 -Dmpool_error="(void)" -Dabort=abort_ "-Dvirt_fd_t=void*" $(BTREE_DEFS_EXTRA)
+CFLAGS += -I$(BTREE_DIR)/PORT/include
+CFLAGS += -Wno-old-style-definition -Wno-sign-compare -Wno-unused-parameter $(BTREE_DEFS)
+
+SRC += $(addprefix $(realpath $(BTREE_DIR))/,\
+	btree/bt_close.c \
+	btree/bt_conv.c \
+	btree/bt_delete.c \
+	btree/bt_get.c \
+	btree/bt_open.c \
+	btree/bt_overflow.c \
+	btree/bt_page.c \
+	btree/bt_put.c \
+	btree/bt_search.c \
+	btree/bt_seq.c \
+	btree/bt_split.c \
+	btree/bt_utils.c \
+	mpool/mpool.c \
+	)
+
+include $(MPY_DIR)/py/dynruntime.mk
+
+# btree needs gnu99 defined
+CFLAGS += -std=gnu99
diff --git a/examples/natmod/btree/btree_c.c b/examples/natmod/btree/btree_c.c
new file mode 100644
index 0000000000000..5e8a34ac40095
--- /dev/null
+++ b/examples/natmod/btree/btree_c.c
@@ -0,0 +1,147 @@
+#define MICROPY_PY_BTREE (1)
+
+#include "py/dynruntime.h"
+
+#include <unistd.h>
+
+#if !defined(__linux__)
+void *memcpy(void *dst, const void *src, size_t n) {
+    return mp_fun_table.memmove_(dst, src, n);
+}
+void *memset(void *s, int c, size_t n) {
+    return mp_fun_table.memset_(s, c, n);
+}
+#endif
+
+void *memmove(void *dest, const void *src, size_t n) {
+    return mp_fun_table.memmove_(dest, src, n);
+}
+
+void *malloc(size_t n) {
+    void *ptr = m_malloc(n);
+    return ptr;
+}
+void *realloc(void *ptr, size_t n) {
+    mp_printf(&mp_plat_print, "UNDEF %d\n", __LINE__);
+    return NULL;
+}
+void *calloc(size_t n, size_t m) {
+    void *ptr = m_malloc(n * m);
+    // memory already cleared by conservative GC
+    return ptr;
+}
+
+void free(void *ptr) {
+    m_free(ptr);
+}
+
+void abort_(void) {
+    nlr_raise(mp_obj_new_exception(mp_load_global(MP_QSTR_RuntimeError)));
+}
+
+int native_errno;
+#if defined(__linux__)
+int *__errno_location (void)
+#else
+int *__errno (void)
+#endif
+{
+    return &native_errno;
+}
+
+ssize_t mp_stream_posix_write(void *stream, const void *buf, size_t len) {
+    mp_obj_base_t* o = stream;
+    const mp_stream_p_t *stream_p = o->type->protocol;
+    mp_uint_t out_sz = stream_p->write(MP_OBJ_FROM_PTR(stream), buf, len, &native_errno);
+    if (out_sz == MP_STREAM_ERROR) {
+        return -1;
+    } else {
+        return out_sz;
+    }
+}
+
+ssize_t mp_stream_posix_read(void *stream, void *buf, size_t len) {
+    mp_obj_base_t* o = stream;
+    const mp_stream_p_t *stream_p = o->type->protocol;
+    mp_uint_t out_sz = stream_p->read(MP_OBJ_FROM_PTR(stream), buf, len, &native_errno);
+    if (out_sz == MP_STREAM_ERROR) {
+        return -1;
+    } else {
+        return out_sz;
+    }
+}
+
+off_t mp_stream_posix_lseek(void *stream, off_t offset, int whence) {
+    const mp_obj_base_t* o = stream;
+    const mp_stream_p_t *stream_p = o->type->protocol;
+    struct mp_stream_seek_t seek_s;
+    seek_s.offset = offset;
+    seek_s.whence = whence;
+    mp_uint_t res = stream_p->ioctl(MP_OBJ_FROM_PTR(stream), MP_STREAM_SEEK, (mp_uint_t)(uintptr_t)&seek_s, &native_errno);
+    if (res == MP_STREAM_ERROR) {
+        return -1;
+    }
+    return seek_s.offset;
+}
+
+int mp_stream_posix_fsync(void *stream) {
+    mp_obj_base_t* o = stream;
+    const mp_stream_p_t *stream_p = o->type->protocol;
+    mp_uint_t res = stream_p->ioctl(MP_OBJ_FROM_PTR(stream), MP_STREAM_FLUSH, 0, &native_errno);
+    if (res == MP_STREAM_ERROR) {
+        return -1;
+    }
+    return res;
+}
+
+mp_obj_type_t btree_type;
+
+#include "extmod/modbtree.c"
+
+mp_map_elem_t btree_locals_dict_table[8];
+STATIC MP_DEFINE_CONST_DICT(btree_locals_dict, btree_locals_dict_table);
+
+STATIC mp_obj_t btree_open(size_t n_args, const mp_obj_t *args) {
+    // Make sure we got a stream object
+    mp_get_stream_raise(args[0], MP_STREAM_OP_READ | MP_STREAM_OP_WRITE | MP_STREAM_OP_IOCTL);
+
+    BTREEINFO openinfo = {0};
+    openinfo.flags = mp_obj_get_int(args[1]);
+    openinfo.cachesize = mp_obj_get_int(args[2]);
+    openinfo.psize = mp_obj_get_int(args[3]);
+    openinfo.minkeypage = mp_obj_get_int(args[4]);
+    DB *db = __bt_open(MP_OBJ_TO_PTR(args[0]), &btree_stream_fvtable, &openinfo, 0);
+    if (db == NULL) {
+        mp_raise_OSError(native_errno);
+    }
+
+    return MP_OBJ_FROM_PTR(btree_new(db, args[0]));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(btree_open_obj, 5, 5, btree_open);
+
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    btree_type.base.type = (void*)&mp_fun_table.type_type;
+    btree_type.name = MP_QSTR_btree;
+    btree_type.print = btree_print;
+    btree_type.getiter = btree_getiter;
+    btree_type.iternext = btree_iternext;
+    btree_type.binary_op = btree_binary_op;
+    btree_type.subscr = btree_subscr;
+    btree_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_close), MP_OBJ_FROM_PTR(&btree_close_obj) };
+    btree_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_flush), MP_OBJ_FROM_PTR(&btree_flush_obj) };
+    btree_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_get), MP_OBJ_FROM_PTR(&btree_get_obj) };
+    btree_locals_dict_table[3] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_put), MP_OBJ_FROM_PTR(&btree_put_obj) };
+    btree_locals_dict_table[4] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_seq), MP_OBJ_FROM_PTR(&btree_seq_obj) };
+    btree_locals_dict_table[5] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_keys), MP_OBJ_FROM_PTR(&btree_keys_obj) };
+    btree_locals_dict_table[6] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_values), MP_OBJ_FROM_PTR(&btree_values_obj) };
+    btree_locals_dict_table[7] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_items), MP_OBJ_FROM_PTR(&btree_items_obj) };
+    btree_type.locals_dict = (void*)&btree_locals_dict;
+
+    mp_store_global(MP_QSTR__open, MP_OBJ_FROM_PTR(&btree_open_obj));
+    mp_store_global(MP_QSTR_INCL, MP_OBJ_NEW_SMALL_INT(FLAG_END_KEY_INCL));
+    mp_store_global(MP_QSTR_DESC, MP_OBJ_NEW_SMALL_INT(FLAG_DESC));
+
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/btree/btree_py.py b/examples/natmod/btree/btree_py.py
new file mode 100644
index 0000000000000..bd53c084a13be
--- /dev/null
+++ b/examples/natmod/btree/btree_py.py
@@ -0,0 +1,3 @@
+# Implemented in Python to support keyword arguments
+def open(stream, *, flags=0, cachesize=0, pagesize=0, minkeypage=0):
+    return _open(stream, flags, cachesize, pagesize, minkeypage)
diff --git a/examples/natmod/features0/Makefile b/examples/natmod/features0/Makefile
new file mode 100644
index 0000000000000..57490df90abe7
--- /dev/null
+++ b/examples/natmod/features0/Makefile
@@ -0,0 +1,14 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module
+MOD = features0
+
+# Source files (.c or .py)
+SRC = features0.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin)
+ARCH = x64
+
+# Include to get the rules for compiling and linking the module
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/features0/features0.c b/examples/natmod/features0/features0.c
new file mode 100644
index 0000000000000..1b1867a3bc935
--- /dev/null
+++ b/examples/natmod/features0/features0.c
@@ -0,0 +1,40 @@
+/* This example demonstrates the following features in a native module:
+    - defining a simple function exposed to Python
+    - defining a local, helper C function
+    - getting and creating integer objects
+*/
+
+// Include the header file to get access to the MicroPython API
+#include "py/dynruntime.h"
+
+// Helper function to compute factorial
+STATIC mp_int_t factorial_helper(mp_int_t x) {
+    if (x == 0) {
+        return 1;
+    }
+    return x * factorial_helper(x - 1);
+}
+
+// This is the function which will be called from Python, as factorial(x)
+STATIC mp_obj_t factorial(mp_obj_t x_obj) {
+    // Extract the integer from the MicroPython input object
+    mp_int_t x = mp_obj_get_int(x_obj);
+    // Calculate the factorial
+    mp_int_t result = factorial_helper(x);
+    // Convert the result to a MicroPython integer object and return it
+    return mp_obj_new_int(result);
+}
+// Define a Python reference to the function above
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(factorial_obj, factorial);
+
+// This is the entry point and is called when the module is imported
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    // This must be first, it sets up the globals dict and other things
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    // Make the function available in the module's namespace
+    mp_store_global(MP_QSTR_factorial, MP_OBJ_FROM_PTR(&factorial_obj));
+
+    // This must be last, it restores the globals dict
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/features1/Makefile b/examples/natmod/features1/Makefile
new file mode 100644
index 0000000000000..010640daf9746
--- /dev/null
+++ b/examples/natmod/features1/Makefile
@@ -0,0 +1,14 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module
+MOD = features1
+
+# Source files (.c or .py)
+SRC = features1.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin)
+ARCH = x64
+
+# Include to get the rules for compiling and linking the module
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/features1/features1.c b/examples/natmod/features1/features1.c
new file mode 100644
index 0000000000000..f865f1887cd08
--- /dev/null
+++ b/examples/natmod/features1/features1.c
@@ -0,0 +1,106 @@
+/* This example demonstrates the following features in a native module:
+    - defining simple functions exposed to Python
+    - defining local, helper C functions
+    - defining constant integers and strings exposed to Python
+    - getting and creating integer objects
+    - creating Python lists
+    - raising exceptions
+    - allocating memory
+    - BSS and constant data (rodata)
+    - relocated pointers in rodata
+*/
+
+// Include the header file to get access to the MicroPython API
+#include "py/dynruntime.h"
+
+// BSS (zero) data
+uint16_t data16[4];
+
+// Constant data (rodata)
+const uint8_t table8[] = { 0, 1, 1, 2, 3, 5, 8, 13 };
+const uint16_t table16[] = { 0x1000, 0x2000 };
+
+// Constant data pointing to BSS/constant data
+uint16_t *const table_ptr16a[] = { &data16[0], &data16[1], &data16[2], &data16[3] };
+const uint16_t *const table_ptr16b[] = { &table16[0], &table16[1] };
+
+// A simple function that adds its 2 arguments (must be integers)
+STATIC mp_obj_t add(mp_obj_t x_in, mp_obj_t y_in) {
+    mp_int_t x = mp_obj_get_int(x_in);
+    mp_int_t y = mp_obj_get_int(y_in);
+    return mp_obj_new_int(x + y);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(add_obj, add);
+
+// A local helper function (not exposed to Python)
+STATIC mp_int_t fibonacci_helper(mp_int_t x) {
+    if (x < MP_ARRAY_SIZE(table8)) {
+        return table8[x];
+    } else {
+        return fibonacci_helper(x - 1) + fibonacci_helper(x - 2);
+    }
+}
+
+// A function which computes Fibonacci numbers
+STATIC mp_obj_t fibonacci(mp_obj_t x_in) {
+    mp_int_t x = mp_obj_get_int(x_in);
+    if (x < 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("can't compute negative Fibonacci number"));
+    }
+    return mp_obj_new_int(fibonacci_helper(x));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(fibonacci_obj, fibonacci);
+
+// A function that accesses the BSS data
+STATIC mp_obj_t access(size_t n_args, const mp_obj_t *args) {
+    if (n_args == 0) {
+        // Create a list holding all items from data16
+        mp_obj_list_t *lst = MP_OBJ_TO_PTR(mp_obj_new_list(MP_ARRAY_SIZE(data16), NULL));
+        for (int i = 0; i < MP_ARRAY_SIZE(data16); ++i) {
+            lst->items[i] = mp_obj_new_int(data16[i]);
+        }
+        return MP_OBJ_FROM_PTR(lst);
+    } else if (n_args == 1) {
+        // Get one item from data16
+        mp_int_t idx = mp_obj_get_int(args[0]) & 3;
+        return mp_obj_new_int(data16[idx]);
+    } else {
+        // Set one item in data16 (via table_ptr16a)
+        mp_int_t idx = mp_obj_get_int(args[0]) & 3;
+        *table_ptr16a[idx] = mp_obj_get_int(args[1]);
+        return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(access_obj, 0, 2, access);
+
+// A function that allocates memory and creates a bytearray
+STATIC mp_obj_t make_array(void) {
+    uint16_t *ptr = m_new(uint16_t, MP_ARRAY_SIZE(table_ptr16b));
+    for (int i = 0; i < MP_ARRAY_SIZE(table_ptr16b); ++i) {
+        ptr[i] = *table_ptr16b[i];
+    }
+    return mp_obj_new_bytearray_by_ref(sizeof(uint16_t) * MP_ARRAY_SIZE(table_ptr16b), ptr);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(make_array_obj, make_array);
+
+// This is the entry point and is called when the module is imported
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    // This must be first, it sets up the globals dict and other things
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    // Messages can be printed as usualy
+    mp_printf(&mp_plat_print, "initialising module self=%p\n", self);
+
+    // Make the functions available in the module's namespace
+    mp_store_global(MP_QSTR_add, MP_OBJ_FROM_PTR(&add_obj));
+    mp_store_global(MP_QSTR_fibonacci, MP_OBJ_FROM_PTR(&fibonacci_obj));
+    mp_store_global(MP_QSTR_access, MP_OBJ_FROM_PTR(&access_obj));
+    mp_store_global(MP_QSTR_make_array, MP_OBJ_FROM_PTR(&make_array_obj));
+
+    // Add some constants to the module's namespace
+    mp_store_global(MP_QSTR_VAL, MP_OBJ_NEW_SMALL_INT(42));
+    mp_store_global(MP_QSTR_MSG, MP_OBJ_NEW_QSTR(MP_QSTR_HELLO_MICROPYTHON));
+
+    // This must be last, it restores the globals dict
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/features2/Makefile b/examples/natmod/features2/Makefile
new file mode 100644
index 0000000000000..4fd23c6879d47
--- /dev/null
+++ b/examples/natmod/features2/Makefile
@@ -0,0 +1,14 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module
+MOD = features2
+
+# Source files (.c or .py)
+SRC = main.c prod.c test.py
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin)
+ARCH = x64
+
+# Include to get the rules for compiling and linking the module
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/features2/main.c b/examples/natmod/features2/main.c
new file mode 100644
index 0000000000000..1a39700dc4b71
--- /dev/null
+++ b/examples/natmod/features2/main.c
@@ -0,0 +1,83 @@
+/* This example demonstrates the following features in a native module:
+    - using floats
+    - defining additional code in Python (see test.py)
+    - have extra C code in a separate file (see prod.c)
+*/
+
+// Include the header file to get access to the MicroPython API
+#include "py/dynruntime.h"
+
+// Include the header for auxiliary C code for this module
+#include "prod.h"
+
+// Automatically detect if this module should include double-precision code.
+// If double precision is supported by the target architecture then it can
+// be used in native module regardless of what float setting the target
+// MicroPython runtime uses (being none, float or double).
+#if defined(__i386__) || defined(__x86_64__) || (defined(__ARM_FP) && (__ARM_FP & 8))
+#define USE_DOUBLE 1
+#else
+#define USE_DOUBLE 0
+#endif
+
+// A function that uses the default float type configured for the current target
+// This default can be overridden by specifying MICROPY_FLOAT_IMPL at the make level
+STATIC mp_obj_t add(mp_obj_t x, mp_obj_t y) {
+    return mp_obj_new_float(mp_obj_get_float(x) + mp_obj_get_float(y));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(add_obj, add);
+
+// A function that explicitly uses single precision floats
+STATIC mp_obj_t add_f(mp_obj_t x, mp_obj_t y) {
+    return mp_obj_new_float_from_f(mp_obj_get_float_to_f(x) + mp_obj_get_float_to_f(y));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(add_f_obj, add_f);
+
+#if USE_DOUBLE
+// A function that explicitly uses double precision floats
+STATIC mp_obj_t add_d(mp_obj_t x, mp_obj_t y) {
+    return mp_obj_new_float_from_d(mp_obj_get_float_to_d(x) + mp_obj_get_float_to_d(y));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(add_d_obj, add_d);
+#endif
+
+// A function that computes the product of floats in an array.
+// This function uses the most general C argument interface, which is more difficult
+// to use but has access to the globals dict of the module via self->globals.
+STATIC mp_obj_t productf(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    // Check number of arguments is valid
+    mp_arg_check_num(n_args, n_kw, 1, 1, false);
+
+    // Extract buffer pointer and verify typecode
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(args[0], &bufinfo, MP_BUFFER_RW);
+    if (bufinfo.typecode != 'f') {
+        mp_raise_ValueError(MP_ERROR_TEXT("expecting float array"));
+    }
+
+    // Compute product, store result back in first element of array
+    float *ptr = bufinfo.buf;
+    float prod = prod_array(bufinfo.len / sizeof(*ptr), ptr);
+    ptr[0] = prod;
+
+    return mp_const_none;
+}
+
+// This is the entry point and is called when the module is imported
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    // This must be first, it sets up the globals dict and other things
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    // Make the functions available in the module's namespace
+    mp_store_global(MP_QSTR_add, MP_OBJ_FROM_PTR(&add_obj));
+    mp_store_global(MP_QSTR_add_f, MP_OBJ_FROM_PTR(&add_f_obj));
+    #if USE_DOUBLE
+    mp_store_global(MP_QSTR_add_d, MP_OBJ_FROM_PTR(&add_d_obj));
+    #endif
+
+    // The productf function uses the most general C argument interface
+    mp_store_global(MP_QSTR_productf, MP_DYNRUNTIME_MAKE_FUNCTION(productf));
+
+    // This must be last, it restores the globals dict
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/features2/prod.c b/examples/natmod/features2/prod.c
new file mode 100644
index 0000000000000..7791dcad1d214
--- /dev/null
+++ b/examples/natmod/features2/prod.c
@@ -0,0 +1,9 @@
+#include "prod.h"
+
+float prod_array(int n, float *ar) {
+    float ans = 1;
+    for (int i = 0; i < n; ++i) {
+        ans *= ar[i];
+    }
+    return ans;
+}
diff --git a/examples/natmod/features2/prod.h b/examples/natmod/features2/prod.h
new file mode 100644
index 0000000000000..f27dd8d0330fe
--- /dev/null
+++ b/examples/natmod/features2/prod.h
@@ -0,0 +1 @@
+float prod_array(int n, float *ar);
diff --git a/examples/natmod/features2/test.py b/examples/natmod/features2/test.py
new file mode 100644
index 0000000000000..5ac80120d7338
--- /dev/null
+++ b/examples/natmod/features2/test.py
@@ -0,0 +1,29 @@
+# This Python code will be merged with the C code in main.c
+
+import array
+
+
+def isclose(a, b):
+    return abs(a - b) < 1e-3
+
+
+def test():
+    tests = [
+        isclose(add(0.1, 0.2), 0.3),
+        isclose(add_f(0.1, 0.2), 0.3),
+    ]
+
+    ar = array.array("f", [1, 2, 3.5])
+    productf(ar)
+    tests.append(isclose(ar[0], 7))
+
+    if "add_d" in globals():
+        tests.append(isclose(add_d(0.1, 0.2), 0.3))
+
+    print(tests)
+
+    if not all(tests):
+        raise SystemExit(1)
+
+
+test()
diff --git a/examples/natmod/framebuf/Makefile b/examples/natmod/framebuf/Makefile
new file mode 100644
index 0000000000000..2e2b815975432
--- /dev/null
+++ b/examples/natmod/framebuf/Makefile
@@ -0,0 +1,13 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module (different to built-in framebuf so it can coexist)
+MOD = framebuf_$(ARCH)
+
+# Source files (.c or .py)
+SRC = framebuf.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin)
+ARCH = x64
+
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/framebuf/framebuf.c b/examples/natmod/framebuf/framebuf.c
new file mode 100644
index 0000000000000..8d488cffd685a
--- /dev/null
+++ b/examples/natmod/framebuf/framebuf.c
@@ -0,0 +1,49 @@
+#define MICROPY_PY_FRAMEBUF (1)
+
+#include "py/dynruntime.h"
+
+#if !defined(__linux__)
+void *memset(void *s, int c, size_t n) {
+    return mp_fun_table.memset_(s, c, n);
+}
+#endif
+
+mp_obj_type_t mp_type_framebuf;
+
+#include "extmod/modframebuf.c"
+
+mp_map_elem_t framebuf_locals_dict_table[10];
+STATIC MP_DEFINE_CONST_DICT(framebuf_locals_dict, framebuf_locals_dict_table);
+
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    mp_type_framebuf.base.type = (void*)&mp_type_type;
+    mp_type_framebuf.name = MP_QSTR_FrameBuffer;
+    mp_type_framebuf.make_new = framebuf_make_new;
+    mp_type_framebuf.buffer_p.get_buffer = framebuf_get_buffer;
+    framebuf_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_fill), MP_OBJ_FROM_PTR(&framebuf_fill_obj) };
+    framebuf_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_fill_rect), MP_OBJ_FROM_PTR(&framebuf_fill_rect_obj) };
+    framebuf_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_pixel), MP_OBJ_FROM_PTR(&framebuf_pixel_obj) };
+    framebuf_locals_dict_table[3] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_hline), MP_OBJ_FROM_PTR(&framebuf_hline_obj) };
+    framebuf_locals_dict_table[4] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_vline), MP_OBJ_FROM_PTR(&framebuf_vline_obj) };
+    framebuf_locals_dict_table[5] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_rect), MP_OBJ_FROM_PTR(&framebuf_rect_obj) };
+    framebuf_locals_dict_table[6] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_line), MP_OBJ_FROM_PTR(&framebuf_line_obj) };
+    framebuf_locals_dict_table[7] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_blit), MP_OBJ_FROM_PTR(&framebuf_blit_obj) };
+    framebuf_locals_dict_table[8] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_scroll), MP_OBJ_FROM_PTR(&framebuf_scroll_obj) };
+    framebuf_locals_dict_table[9] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_text), MP_OBJ_FROM_PTR(&framebuf_text_obj) };
+    mp_type_framebuf.locals_dict = (void*)&framebuf_locals_dict;
+
+    mp_store_global(MP_QSTR_FrameBuffer, MP_OBJ_FROM_PTR(&mp_type_framebuf));
+    mp_store_global(MP_QSTR_FrameBuffer1, MP_OBJ_FROM_PTR(&legacy_framebuffer1_obj));
+    mp_store_global(MP_QSTR_MVLSB, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_MVLSB));
+    mp_store_global(MP_QSTR_MONO_VLSB, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_MVLSB));
+    mp_store_global(MP_QSTR_RGB565, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_RGB565));
+    mp_store_global(MP_QSTR_GS2_HMSB, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_GS2_HMSB));
+    mp_store_global(MP_QSTR_GS4_HMSB, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_GS4_HMSB));
+    mp_store_global(MP_QSTR_GS8, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_GS8));
+    mp_store_global(MP_QSTR_MONO_HLSB, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_MHLSB));
+    mp_store_global(MP_QSTR_MONO_HMSB, MP_OBJ_NEW_SMALL_INT(FRAMEBUF_MHMSB));
+
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/uheapq/Makefile b/examples/natmod/uheapq/Makefile
new file mode 100644
index 0000000000000..55de3cc081857
--- /dev/null
+++ b/examples/natmod/uheapq/Makefile
@@ -0,0 +1,13 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module (different to built-in uheapq so it can coexist)
+MOD = uheapq_$(ARCH)
+
+# Source files (.c or .py)
+SRC = uheapq.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin)
+ARCH = x64
+
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/uheapq/uheapq.c b/examples/natmod/uheapq/uheapq.c
new file mode 100644
index 0000000000000..9da6bb4ada4b4
--- /dev/null
+++ b/examples/natmod/uheapq/uheapq.c
@@ -0,0 +1,16 @@
+#define MICROPY_PY_UHEAPQ (1)
+
+#include "py/dynruntime.h"
+
+#include "extmod/moduheapq.c"
+
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    mp_store_global(MP_QSTR___name__, MP_OBJ_NEW_QSTR(MP_QSTR_uheapq));
+    mp_store_global(MP_QSTR_heappush, MP_OBJ_FROM_PTR(&mod_uheapq_heappush_obj));
+    mp_store_global(MP_QSTR_heappop, MP_OBJ_FROM_PTR(&mod_uheapq_heappop_obj));
+    mp_store_global(MP_QSTR_heapify, MP_OBJ_FROM_PTR(&mod_uheapq_heapify_obj));
+
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/urandom/Makefile b/examples/natmod/urandom/Makefile
new file mode 100644
index 0000000000000..3f018baaf76b6
--- /dev/null
+++ b/examples/natmod/urandom/Makefile
@@ -0,0 +1,13 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module (different to built-in urandom so it can coexist)
+MOD = urandom_$(ARCH)
+
+# Source files (.c or .py)
+SRC = urandom.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin)
+ARCH = x64
+
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/urandom/urandom.c b/examples/natmod/urandom/urandom.c
new file mode 100644
index 0000000000000..e1fed6a554fce
--- /dev/null
+++ b/examples/natmod/urandom/urandom.c
@@ -0,0 +1,33 @@
+#define MICROPY_PY_URANDOM (1)
+#define MICROPY_PY_URANDOM_EXTRA_FUNCS (1)
+
+#include "py/dynruntime.h"
+
+// Dynamic native modules don't support a data section so these must go in the BSS
+uint32_t yasmarang_pad, yasmarang_n, yasmarang_d;
+uint8_t yasmarang_dat;
+
+#include "extmod/modurandom.c"
+
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    yasmarang_pad = 0xeda4baba;
+    yasmarang_n = 69;
+    yasmarang_d = 233;
+
+    mp_store_global(MP_QSTR___name__, MP_OBJ_NEW_QSTR(MP_QSTR_urandom));
+    mp_store_global(MP_QSTR_getrandbits, MP_OBJ_FROM_PTR(&mod_urandom_getrandbits_obj));
+    mp_store_global(MP_QSTR_seed, MP_OBJ_FROM_PTR(&mod_urandom_seed_obj));
+    #if MICROPY_PY_URANDOM_EXTRA_FUNCS
+    mp_store_global(MP_QSTR_randrange, MP_OBJ_FROM_PTR(&mod_urandom_randrange_obj));
+    mp_store_global(MP_QSTR_randint, MP_OBJ_FROM_PTR(&mod_urandom_randint_obj));
+    mp_store_global(MP_QSTR_choice, MP_OBJ_FROM_PTR(&mod_urandom_choice_obj));
+    #if MICROPY_PY_BUILTINS_FLOAT
+    mp_store_global(MP_QSTR_random, MP_OBJ_FROM_PTR(&mod_urandom_random_obj));
+    mp_store_global(MP_QSTR_uniform, MP_OBJ_FROM_PTR(&mod_urandom_uniform_obj));
+    #endif
+    #endif
+
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/ure/Makefile b/examples/natmod/ure/Makefile
new file mode 100644
index 0000000000000..f5254298fdd90
--- /dev/null
+++ b/examples/natmod/ure/Makefile
@@ -0,0 +1,13 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module (different to built-in ure so it can coexist)
+MOD = ure_$(ARCH)
+
+# Source files (.c or .py)
+SRC = ure.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin)
+ARCH = x64
+
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/ure/ure.c b/examples/natmod/ure/ure.c
new file mode 100644
index 0000000000000..00ca2e9eb4c71
--- /dev/null
+++ b/examples/natmod/ure/ure.c
@@ -0,0 +1,78 @@
+#define MICROPY_STACK_CHECK (1)
+#define MICROPY_PY_URE (1)
+#define MICROPY_PY_URE_MATCH_GROUPS (1)
+#define MICROPY_PY_URE_MATCH_SPAN_START_END (1)
+#define MICROPY_PY_URE_SUB (0) // requires vstr interface
+
+#include <alloca.h>
+#include "py/dynruntime.h"
+
+#define STACK_LIMIT (2048)
+
+const char *stack_top;
+
+void mp_stack_check(void) {
+    // Assumes descending stack on target
+    volatile char dummy;
+    if (stack_top - &dummy >= STACK_LIMIT) {
+        mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("maximum recursion depth exceeded"));
+    }
+}
+
+#if !defined(__linux__)
+void *memcpy(void *dst, const void *src, size_t n) {
+    return mp_fun_table.memmove_(dst, src, n);
+}
+void *memset(void *s, int c, size_t n) {
+    return mp_fun_table.memset_(s, c, n);
+}
+#endif
+
+void *memmove(void *dest, const void *src, size_t n) {
+    return mp_fun_table.memmove_(dest, src, n);
+}
+
+mp_obj_type_t match_type;
+mp_obj_type_t re_type;
+
+#include "extmod/modure.c"
+
+mp_map_elem_t match_locals_dict_table[5];
+STATIC MP_DEFINE_CONST_DICT(match_locals_dict, match_locals_dict_table);
+
+mp_map_elem_t re_locals_dict_table[3];
+STATIC MP_DEFINE_CONST_DICT(re_locals_dict, re_locals_dict_table);
+
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    char dummy;
+    stack_top = &dummy;
+
+    // Because MP_QSTR_start/end/split are static, xtensa and xtensawin will make a small data section
+    // to copy in this key/value pair if they are specified as a struct, so assign them separately.
+
+    match_type.base.type = (void*)&mp_fun_table.type_type;
+    match_type.name = MP_QSTR_match;
+    match_type.print = match_print;
+    match_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_group), MP_OBJ_FROM_PTR(&match_group_obj) };
+    match_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_groups), MP_OBJ_FROM_PTR(&match_groups_obj) };
+    match_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_span), MP_OBJ_FROM_PTR(&match_span_obj) };
+    match_locals_dict_table[3] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_start), MP_OBJ_FROM_PTR(&match_start_obj) };
+    match_locals_dict_table[4] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_end), MP_OBJ_FROM_PTR(&match_end_obj) };
+    match_type.locals_dict = (void*)&match_locals_dict;
+
+    re_type.base.type = (void*)&mp_fun_table.type_type;
+    re_type.name = MP_QSTR_ure;
+    re_type.print = re_print;
+    re_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_match), MP_OBJ_FROM_PTR(&re_match_obj) };
+    re_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_search), MP_OBJ_FROM_PTR(&re_search_obj) };
+    re_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_split), MP_OBJ_FROM_PTR(&re_split_obj) };
+    re_type.locals_dict = (void*)&re_locals_dict;
+
+    mp_store_global(MP_QSTR_compile, MP_OBJ_FROM_PTR(&mod_re_compile_obj));
+    mp_store_global(MP_QSTR_match, MP_OBJ_FROM_PTR(&mod_re_match_obj));
+    mp_store_global(MP_QSTR_search, MP_OBJ_FROM_PTR(&mod_re_search_obj));
+
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/natmod/uzlib/Makefile b/examples/natmod/uzlib/Makefile
new file mode 100644
index 0000000000000..8761caf2dd26c
--- /dev/null
+++ b/examples/natmod/uzlib/Makefile
@@ -0,0 +1,13 @@
+# Location of top-level MicroPython directory
+MPY_DIR = ../../..
+
+# Name of module (different to built-in uzlib so it can coexist)
+MOD = uzlib_$(ARCH)
+
+# Source files (.c or .py)
+SRC = uzlib.c
+
+# Architecture to build for (x86, x64, armv7m, xtensa, xtensawin)
+ARCH = x64
+
+include $(MPY_DIR)/py/dynruntime.mk
diff --git a/examples/natmod/uzlib/uzlib.c b/examples/natmod/uzlib/uzlib.c
new file mode 100644
index 0000000000000..99b3691761ea4
--- /dev/null
+++ b/examples/natmod/uzlib/uzlib.c
@@ -0,0 +1,35 @@
+#define MICROPY_PY_UZLIB (1)
+
+#include "py/dynruntime.h"
+
+#if !defined(__linux__)
+void *memset(void *s, int c, size_t n) {
+    return mp_fun_table.memset_(s, c, n);
+}
+#endif
+
+mp_obj_type_t decompio_type;
+
+#include "extmod/moduzlib.c"
+
+mp_map_elem_t decompio_locals_dict_table[3];
+STATIC MP_DEFINE_CONST_DICT(decompio_locals_dict, decompio_locals_dict_table);
+
+mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
+    MP_DYNRUNTIME_INIT_ENTRY
+
+    decompio_type.base.type = mp_fun_table.type_type;
+    decompio_type.name = MP_QSTR_DecompIO;
+    decompio_type.make_new = decompio_make_new;
+    decompio_type.protocol = &decompio_stream_p;
+    decompio_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_read), MP_OBJ_FROM_PTR(&mp_stream_read_obj) };
+    decompio_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_readinto), MP_OBJ_FROM_PTR(&mp_stream_readinto_obj) };
+    decompio_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_readline), MP_OBJ_FROM_PTR(&mp_stream_unbuffered_readline_obj) };
+    decompio_type.locals_dict = (void*)&decompio_locals_dict;
+
+    mp_store_global(MP_QSTR___name__, MP_OBJ_NEW_QSTR(MP_QSTR_uzlib));
+    mp_store_global(MP_QSTR_decompress, MP_OBJ_FROM_PTR(&mod_uzlib_decompress_obj));
+    mp_store_global(MP_QSTR_DecompIO, MP_OBJ_FROM_PTR(&decompio_type));
+
+    MP_DYNRUNTIME_INIT_EXIT
+}
diff --git a/examples/network/http_server.py b/examples/network/http_server.py
index e3a66e828388e..76be3ab8173b0 100644
--- a/examples/network/http_server.py
+++ b/examples/network/http_server.py
@@ -10,6 +10,7 @@
 Hello #%d from MicroPython!
 """
 
+
 def main(micropython_optimize=False):
     s = socket.socket()
 
diff --git a/examples/network/http_server_simplistic.py b/examples/network/http_server_simplistic.py
index 67ecb1ad7ada4..71949419e67b8 100644
--- a/examples/network/http_server_simplistic.py
+++ b/examples/network/http_server_simplistic.py
@@ -12,6 +12,7 @@
 Hello #%d from MicroPython!
 """
 
+
 def main():
     s = socket.socket()
     ai = socket.getaddrinfo("0.0.0.0", 8080)
diff --git a/examples/network/http_server_simplistic_commented.py b/examples/network/http_server_simplistic_commented.py
index b58e9eeb60eb4..da042c6c8a56e 100644
--- a/examples/network/http_server_simplistic_commented.py
+++ b/examples/network/http_server_simplistic_commented.py
@@ -20,6 +20,7 @@
 Hello #%d from MicroPython!
 """
 
+
 def main():
     s = socket.socket()
 
diff --git a/examples/network/http_server_ssl.py b/examples/network/http_server_ssl.py
index 9a69ca9d417ea..1116c71e996a9 100644
--- a/examples/network/http_server_ssl.py
+++ b/examples/network/http_server_ssl.py
@@ -1,3 +1,5 @@
+import ubinascii as binascii
+
 try:
     import usocket as socket
 except:
@@ -5,12 +7,44 @@
 import ussl as ssl
 
 
+# This self-signed key/cert pair is randomly generated and to be used for
+# testing/demonstration only.  You should always generate your own key/cert.
+key = binascii.unhexlify(
+    b"3082013b020100024100cc20643fd3d9c21a0acba4f48f61aadd675f52175a9dcf07fbef"
+    b"610a6a6ba14abb891745cd18a1d4c056580d8ff1a639460f867013c8391cdc9f2e573b0f"
+    b"872d0203010001024100bb17a54aeb3dd7ae4edec05e775ca9632cf02d29c2a089b563b0"
+    b"d05cdf95aeca507de674553f28b4eadaca82d5549a86058f9996b07768686a5b02cb240d"
+    b"d9f1022100f4a63f5549e817547dca97b5c658038e8593cb78c5aba3c4642cc4cd031d86"
+    b"8f022100d598d870ffe4a34df8de57047a50b97b71f4d23e323f527837c9edae88c79483"
+    b"02210098560c89a70385c36eb07fd7083235c4c1184e525d838aedf7128958bedfdbb102"
+    b"2051c0dab7057a8176ca966f3feb81123d4974a733df0f958525f547dfd1c271f9022044"
+    b"6c2cafad455a671a8cf398e642e1be3b18a3d3aec2e67a9478f83c964c4f1f"
+)
+cert = binascii.unhexlify(
+    b"308201d53082017f020203e8300d06092a864886f70d01010505003075310b3009060355"
+    b"0406130258583114301206035504080c0b54686550726f76696e63653110300e06035504"
+    b"070c075468654369747931133011060355040a0c0a436f6d70616e7958595a3113301106"
+    b"0355040b0c0a436f6d70616e7958595a3114301206035504030c0b546865486f73744e61"
+    b"6d65301e170d3139313231383033333935355a170d3239313231353033333935355a3075"
+    b"310b30090603550406130258583114301206035504080c0b54686550726f76696e636531"
+    b"10300e06035504070c075468654369747931133011060355040a0c0a436f6d70616e7958"
+    b"595a31133011060355040b0c0a436f6d70616e7958595a3114301206035504030c0b5468"
+    b"65486f73744e616d65305c300d06092a864886f70d0101010500034b003048024100cc20"
+    b"643fd3d9c21a0acba4f48f61aadd675f52175a9dcf07fbef610a6a6ba14abb891745cd18"
+    b"a1d4c056580d8ff1a639460f867013c8391cdc9f2e573b0f872d0203010001300d06092a"
+    b"864886f70d0101050500034100b0513fe2829e9ecbe55b6dd14c0ede7502bde5d46153c8"
+    b"e960ae3ebc247371b525caeb41bbcf34686015a44c50d226e66aef0a97a63874ca5944ef"
+    b"979b57f0b3"
+)
+
+
 CONTENT = b"""\
 HTTP/1.0 200 OK
 
 Hello #%d from MicroPython!
 """
 
+
 def main(use_stream=True):
     s = socket.socket()
 
@@ -31,7 +65,8 @@ def main(use_stream=True):
         client_addr = res[1]
         print("Client address:", client_addr)
         print("Client socket:", client_s)
-        client_s = ssl.wrap_socket(client_s, server_side=True)
+        # CPython uses key keyfile/certfile arguments, but MicroPython uses key/cert
+        client_s = ssl.wrap_socket(client_s, server_side=True, key=key, cert=cert)
         print(client_s)
         print("Request:")
         if use_stream:
diff --git a/examples/pins.py b/examples/pins.py
index aafdb48133977..3a8472e8a6849 100644
--- a/examples/pins.py
+++ b/examples/pins.py
@@ -4,6 +4,7 @@
 import pyb
 import pins_af
 
+
 def af():
     max_name_width = 0
     max_af_width = 0
@@ -13,21 +14,22 @@ def af():
             max_af_width = max(max_af_width, len(af_entry[1]))
     for pin_entry in pins_af.PINS_AF:
         pin_name = pin_entry[0]
-        print('%-*s ' % (max_name_width, pin_name),  end='')
+        print("%-*s " % (max_name_width, pin_name), end="")
         for af_entry in pin_entry[1:]:
-            print('%2d: %-*s ' % (af_entry[0], max_af_width, af_entry[1]), end='')
-        print('')
+            print("%2d: %-*s " % (af_entry[0], max_af_width, af_entry[1]), end="")
+        print("")
+
 
 def pins():
-    mode_str = { pyb.Pin.IN     : 'IN',
-                 pyb.Pin.OUT_PP : 'OUT_PP',
-                 pyb.Pin.OUT_OD : 'OUT_OD',
-                 pyb.Pin.AF_PP  : 'AF_PP',
-                 pyb.Pin.AF_OD  : 'AF_OD',
-                 pyb.Pin.ANALOG : 'ANALOG' }
-    pull_str = { pyb.Pin.PULL_NONE : '',
-                 pyb.Pin.PULL_UP   : 'PULL_UP',
-                 pyb.Pin.PULL_DOWN : 'PULL_DOWN' }
+    mode_str = {
+        pyb.Pin.IN: "IN",
+        pyb.Pin.OUT_PP: "OUT_PP",
+        pyb.Pin.OUT_OD: "OUT_OD",
+        pyb.Pin.AF_PP: "AF_PP",
+        pyb.Pin.AF_OD: "AF_OD",
+        pyb.Pin.ANALOG: "ANALOG",
+    }
+    pull_str = {pyb.Pin.PULL_NONE: "", pyb.Pin.PULL_UP: "PULL_UP", pyb.Pin.PULL_DOWN: "PULL_DOWN"}
     width = [0, 0, 0, 0]
     rows = []
     for pin_entry in pins_af.PINS_AF:
@@ -42,17 +44,17 @@ def pins():
             pin_af = pin.af()
             for af_entry in pin_entry[1:]:
                 if pin_af == af_entry[0]:
-                    af_str = '%d: %s' % (pin_af, af_entry[1])
+                    af_str = "%d: %s" % (pin_af, af_entry[1])
                     break
             else:
-                af_str = '%d' % pin_af
+                af_str = "%d" % pin_af
         else:
-            af_str = ''
+            af_str = ""
         row.append(af_str)
         for col in range(len(width)):
             width[col] = max(width[col], len(row[col]))
         rows.append(row)
     for row in rows:
         for col in range(len(width)):
-            print('%-*s ' % (width[col], row[col]), end='')
-        print('')
+            print("%-*s " % (width[col], row[col]), end="")
+        print("")
diff --git a/examples/pyb.py b/examples/pyb.py
index b303777e5a8e1..67620e793ab5d 100644
--- a/examples/pyb.py
+++ b/examples/pyb.py
@@ -1,17 +1,22 @@
 # pyboard testing functions for CPython
 import time
 
+
 def delay(n):
-    #time.sleep(float(n) / 1000)
+    # time.sleep(float(n) / 1000)
     pass
 
+
 rand_seed = 1
+
+
 def rng():
     global rand_seed
     # for these choice of numbers, see P L'Ecuyer, "Tables of linear congruential generators of different sizes and good lattice structure"
     rand_seed = (rand_seed * 653276) % 8388593
     return rand_seed
 
+
 # LCD testing object for PC
 # uses double buffering
 class LCD:
@@ -30,12 +35,12 @@ def fill(self, value):
                 self.buf1[y][x] = self.buf2[y][x] = value
 
     def show(self):
-        print('') # blank line to separate frames
+        print("")  # blank line to separate frames
         for y in range(self.height):
             for x in range(self.width):
                 self.buf1[y][x] = self.buf2[y][x]
         for y in range(self.height):
-            row = ''.join(['*' if self.buf1[y][x] else ' ' for x in range(self.width)])
+            row = "".join(["*" if self.buf1[y][x] else " " for x in range(self.width)])
             print(row)
 
     def get(self, x, y):
diff --git a/examples/switch.py b/examples/switch.py
index 0efaf226759aa..c099a35298262 100644
--- a/examples/switch.py
+++ b/examples/switch.py
@@ -24,6 +24,7 @@
 blue_led = pyb.LED(4)
 all_leds = (red_led, green_led, orange_led, blue_led)
 
+
 def run_loop(leds=all_leds):
     """
     Start the loop.
@@ -31,15 +32,16 @@ def run_loop(leds=all_leds):
     :param `leds`: Which LEDs to light up upon switch press.
     :type `leds`: sequence of LED objects
     """
-    print('Loop started.\nPress Ctrl+C to break out of the loop.')
+    print("Loop started.\nPress Ctrl+C to break out of the loop.")
     while 1:
         try:
             if switch():
                 [led.on() for led in leds]
             else:
                 [led.off() for led in leds]
-        except OSError: # VCPInterrupt # Ctrl+C in interpreter mode.
+        except OSError:  # VCPInterrupt # Ctrl+C in interpreter mode.
             break
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     run_loop()
diff --git a/examples/unix/ffi_example.py b/examples/unix/ffi_example.py
index 3c3c3d2396238..a8f02c766e4d9 100644
--- a/examples/unix/ffi_example.py
+++ b/examples/unix/ffi_example.py
@@ -24,12 +24,14 @@
 perror("perror after error")
 print()
 
+
 def cmp(pa, pb):
     a = uctypes.bytearray_at(pa, 1)
     b = uctypes.bytearray_at(pb, 1)
     print("cmp:", a, b)
     return a[0] - b[0]
 
+
 cmp_cb = ffi.callback("i", cmp, "PP")
 print("callback:", cmp_cb)
 
diff --git a/examples/unix/machine_bios.py b/examples/unix/machine_bios.py
index f62e4dbdb45e0..878f3fd8f3c58 100644
--- a/examples/unix/machine_bios.py
+++ b/examples/unix/machine_bios.py
@@ -6,4 +6,4 @@
 
 import umachine as machine
 
-print(hex(machine.mem16[0xc0000]))
+print(hex(machine.mem16[0xC0000]))
diff --git a/extmod/btstack/btstack.mk b/extmod/btstack/btstack.mk
new file mode 100644
index 0000000000000..dd96e6337943e
--- /dev/null
+++ b/extmod/btstack/btstack.mk
@@ -0,0 +1,57 @@
+# Makefile directives for BlueKitchen BTstack
+
+ifeq ($(MICROPY_BLUETOOTH_BTSTACK),1)
+
+MICROPY_BLUETOOTH_BTSTACK_USB ?= 0
+
+BTSTACK_EXTMOD_DIR = extmod/btstack
+
+EXTMOD_SRC_C += extmod/btstack/modbluetooth_btstack.c
+
+INC += -I$(TOP)/$(BTSTACK_EXTMOD_DIR)
+
+CFLAGS_MOD += -DMICROPY_BLUETOOTH_BTSTACK=1
+
+BTSTACK_DIR = $(TOP)/lib/btstack
+
+ifneq ($(wildcard $(BTSTACK_DIR)/src),)
+
+include $(BTSTACK_DIR)/src/Makefile.inc
+include $(BTSTACK_DIR)/src/ble/Makefile.inc
+
+INC += -I$(BTSTACK_DIR)/src
+INC += -I$(BTSTACK_DIR)/3rd-party/bluedroid/decoder/include
+INC += -I$(BTSTACK_DIR)/3rd-party/bluedroid/encoder/include
+INC += -I$(BTSTACK_DIR)/3rd-party/md5
+INC += -I$(BTSTACK_DIR)/3rd-party/yxml
+
+SRC_BTSTACK = \
+	$(addprefix lib/btstack/src/, $(SRC_FILES)) \
+	$(addprefix lib/btstack/src/ble/, $(filter-out %_tlv.c, $(SRC_BLE_FILES))) \
+	lib/btstack/platform/embedded/btstack_run_loop_embedded.c
+
+ifeq ($(MICROPY_BLUETOOTH_BTSTACK_USB),1)
+SRC_BTSTACK += \
+	lib/btstack/platform/libusb/hci_transport_h2_libusb.c
+
+CFLAGS  += $(shell pkg-config libusb-1.0 --cflags)
+LDFLAGS += $(shell pkg-config libusb-1.0 --libs)
+endif
+
+ifeq ($(MICROPY_BLUETOOTH_BTSTACK_ENABLE_CLASSIC),1)
+include $(BTSTACK_DIR)/src/classic/Makefile.inc
+SRC_BTSTACK += \
+	$(addprefix lib/btstack/src/classic/, $(SRC_CLASSIC_FILES))
+endif
+
+LIB_SRC_C += $(SRC_BTSTACK)
+
+# Suppress some warnings.
+BTSTACK_WARNING_CFLAGS = -Wno-old-style-definition -Wno-unused-variable -Wno-unused-parameter
+ifneq ($(CC),clang)
+BTSTACK_WARNING_CFLAGS += -Wno-format
+endif
+$(BUILD)/lib/btstack/src/%.o: CFLAGS += $(BTSTACK_WARNING_CFLAGS)
+
+endif
+endif
diff --git a/extmod/btstack/btstack_config.h b/extmod/btstack/btstack_config.h
new file mode 100644
index 0000000000000..f420f47a5bee5
--- /dev/null
+++ b/extmod/btstack/btstack_config.h
@@ -0,0 +1,47 @@
+#ifndef MICROPY_INCLUDED_EXTMOD_BTSTACK_BTSTACK_CONFIG_H
+#define MICROPY_INCLUDED_EXTMOD_BTSTACK_BTSTACK_CONFIG_H
+
+// BTstack features that can be enabled
+#define ENABLE_BLE
+#define ENABLE_LE_PERIPHERAL
+#define ENABLE_LE_CENTRAL
+// #define ENABLE_CLASSIC
+#define ENABLE_LE_DATA_CHANNELS
+// #define ENABLE_LOG_INFO
+#define ENABLE_LOG_ERROR
+
+// BTstack configuration. buffers, sizes, ...
+#define HCI_ACL_PAYLOAD_SIZE 1021
+#define MAX_NR_GATT_CLIENTS 1
+#define MAX_NR_HCI_CONNECTIONS 1
+#define MAX_NR_L2CAP_SERVICES  3
+#define MAX_NR_L2CAP_CHANNELS  3
+#define MAX_NR_RFCOMM_MULTIPLEXERS 1
+#define MAX_NR_RFCOMM_SERVICES 1
+#define MAX_NR_RFCOMM_CHANNELS 1
+#define MAX_NR_BTSTACK_LINK_KEY_DB_MEMORY_ENTRIES  2
+#define MAX_NR_BNEP_SERVICES 1
+#define MAX_NR_BNEP_CHANNELS 1
+#define MAX_NR_HFP_CONNECTIONS 1
+#define MAX_NR_WHITELIST_ENTRIES 1
+#define MAX_NR_SM_LOOKUP_ENTRIES 3
+#define MAX_NR_SERVICE_RECORD_ITEMS 1
+#define MAX_NR_AVDTP_STREAM_ENDPOINTS 1
+#define MAX_NR_AVDTP_CONNECTIONS 1
+#define MAX_NR_AVRCP_CONNECTIONS 1
+
+#define MAX_NR_LE_DEVICE_DB_ENTRIES 4
+
+// Link Key DB and LE Device DB using TLV on top of Flash Sector interface
+// #define NVM_NUM_DEVICE_DB_ENTRIES 16
+
+// We don't give btstack a malloc, so use a fixed-size ATT DB.
+#define MAX_ATT_DB_SIZE 512
+
+// BTstack HAL configuration
+#define HAVE_EMBEDDED_TIME_MS
+
+// Some USB dongles take longer to respond to HCI reset (e.g. BCM20702A).
+#define HCI_RESET_RESEND_TIMEOUT_MS 1000
+
+#endif // MICROPY_INCLUDED_EXTMOD_BTSTACK_BTSTACK_CONFIG_H
diff --git a/extmod/btstack/modbluetooth_btstack.c b/extmod/btstack/modbluetooth_btstack.c
new file mode 100644
index 0000000000000..772fe4bed1054
--- /dev/null
+++ b/extmod/btstack/modbluetooth_btstack.c
@@ -0,0 +1,700 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+#include "py/mphal.h"
+
+#if MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_BTSTACK
+
+#include "extmod/btstack/modbluetooth_btstack.h"
+#include "extmod/modbluetooth.h"
+
+#include "lib/btstack/src/btstack.h"
+
+#define DEBUG_EVENT_printf(...) //printf(__VA_ARGS__)
+
+#ifndef MICROPY_PY_BLUETOOTH_DEFAULT_GAP_NAME
+#define MICROPY_PY_BLUETOOTH_DEFAULT_GAP_NAME "MPY BTSTACK"
+#endif
+
+// How long to wait for a controller to init/deinit.
+// Some controllers can take up to 5-6 seconds in normal operation.
+STATIC const uint32_t BTSTACK_INIT_DEINIT_TIMEOUT_MS = 15000;
+
+// We need to know the attribute handle for the GAP device name (see GAP_DEVICE_NAME_UUID)
+// so it can be put into the gatts_db before registering the services, and accessed
+// efficiently when requesting an attribute in att_read_callback.  Because this is the
+// first characteristic of the first service, it always has a handle value of 3.
+STATIC const uint16_t BTSTACK_GAP_DEVICE_NAME_HANDLE = 3;
+
+volatile int mp_bluetooth_btstack_state = MP_BLUETOOTH_BTSTACK_STATE_OFF;
+
+STATIC btstack_packet_callback_registration_t hci_event_callback_registration;
+
+STATIC int btstack_error_to_errno(int err) {
+    if (err == ERROR_CODE_SUCCESS) {
+        return 0;
+    } else if (err == BTSTACK_ACL_BUFFERS_FULL) {
+        return MP_ENOMEM;
+    } else {
+        return MP_EINVAL;
+    }
+}
+
+STATIC mp_obj_bluetooth_uuid_t create_mp_uuid(uint16_t uuid16, const uint8_t *uuid128) {
+    mp_obj_bluetooth_uuid_t result;
+    if (uuid16 != 0) {
+        result.data[0] = uuid16 & 0xff;
+        result.data[1] = (uuid16 >> 8) & 0xff;
+        result.type = MP_BLUETOOTH_UUID_TYPE_16;
+    } else {
+        reverse_128(uuid128, result.data);
+        result.type = MP_BLUETOOTH_UUID_TYPE_128;
+    }
+    return result;
+}
+
+STATIC void btstack_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size) {
+    (void)channel;
+    (void)size;
+    DEBUG_EVENT_printf("btstack_packet_handler(packet_type=%u, channel=%u, packet=%p, size=%u)\n", packet_type, channel, packet, size);
+    if (packet_type != HCI_EVENT_PACKET) {
+        return;
+    }
+
+    uint8_t event_type = hci_event_packet_get_type(packet);
+    if (event_type == ATT_EVENT_CONNECTED) {
+        DEBUG_EVENT_printf("  --> att connected\n");
+    } else if (event_type == ATT_EVENT_DISCONNECTED) {
+        DEBUG_EVENT_printf("  --> att disconnected\n");
+    } else if (event_type == HCI_EVENT_LE_META) {
+        DEBUG_EVENT_printf("  --> hci le meta\n");
+        if (hci_event_le_meta_get_subevent_code(packet) == HCI_SUBEVENT_LE_CONNECTION_COMPLETE) {
+            uint16_t conn_handle = hci_subevent_le_connection_complete_get_connection_handle(packet);
+            uint8_t addr_type = hci_subevent_le_connection_complete_get_peer_address_type(packet);
+            bd_addr_t addr;
+            hci_subevent_le_connection_complete_get_peer_address(packet, addr);
+            uint16_t irq_event;
+            if (hci_subevent_le_connection_complete_get_role(packet) == 0) {
+                // Master role.
+                irq_event = MP_BLUETOOTH_IRQ_PERIPHERAL_CONNECT;
+            } else {
+                // Slave role.
+                irq_event = MP_BLUETOOTH_IRQ_CENTRAL_CONNECT;
+            }
+            mp_bluetooth_gap_on_connected_disconnected(irq_event, conn_handle, addr_type, addr);
+        }
+    } else if (event_type == BTSTACK_EVENT_STATE) {
+        uint8_t state = btstack_event_state_get_state(packet);
+        DEBUG_EVENT_printf("  --> btstack event state 0x%02x\n", state);
+        if (state == HCI_STATE_WORKING) {
+            // Signal that initialisation has completed.
+            mp_bluetooth_btstack_state = MP_BLUETOOTH_BTSTACK_STATE_ACTIVE;
+        } else if (state == HCI_STATE_OFF) {
+            // Signal that de-initialisation has completed.
+            mp_bluetooth_btstack_state = MP_BLUETOOTH_BTSTACK_STATE_OFF;
+        }
+    } else if (event_type == HCI_EVENT_TRANSPORT_PACKET_SENT) {
+        DEBUG_EVENT_printf("  --> hci transport packet set\n");
+    } else if (event_type == HCI_EVENT_COMMAND_COMPLETE) {
+        DEBUG_EVENT_printf("  --> hci command complete\n");
+    } else if (event_type == HCI_EVENT_COMMAND_STATUS) {
+        DEBUG_EVENT_printf("  --> hci command status\n");
+    } else if (event_type == HCI_EVENT_NUMBER_OF_COMPLETED_PACKETS) {
+        DEBUG_EVENT_printf("  --> hci number of completed packets\n");
+    } else if (event_type == BTSTACK_EVENT_NR_CONNECTIONS_CHANGED) {
+        DEBUG_EVENT_printf("  --> btstack # conns changed\n");
+    } else if (event_type == HCI_EVENT_VENDOR_SPECIFIC) {
+        DEBUG_EVENT_printf("  --> hci vendor specific\n");
+    } else if (event_type == GAP_EVENT_ADVERTISING_REPORT) {
+        DEBUG_EVENT_printf("  --> gap advertising report\n");
+        bd_addr_t address;
+        gap_event_advertising_report_get_address(packet, address);
+        uint8_t adv_event_type = gap_event_advertising_report_get_advertising_event_type(packet);
+        uint8_t address_type = gap_event_advertising_report_get_address_type(packet);
+        int8_t rssi = gap_event_advertising_report_get_rssi(packet);
+        uint8_t length = gap_event_advertising_report_get_data_length(packet);
+        const uint8_t *data = gap_event_advertising_report_get_data(packet);
+        mp_bluetooth_gap_on_scan_result(address_type, address, adv_event_type, rssi, data, length);
+    } else if (event_type == HCI_EVENT_DISCONNECTION_COMPLETE) {
+        DEBUG_EVENT_printf("  --> hci disconnect complete\n");
+        uint16_t conn_handle = hci_event_disconnection_complete_get_connection_handle(packet);
+        const hci_connection_t *conn = hci_connection_for_handle(conn_handle);
+        uint16_t irq_event;
+        if (conn == NULL || conn->role == 0) {
+            // Master role.
+            irq_event = MP_BLUETOOTH_IRQ_PERIPHERAL_DISCONNECT;
+        } else {
+            // Slave role.
+            irq_event = MP_BLUETOOTH_IRQ_CENTRAL_DISCONNECT;
+        }
+        uint8_t addr[6] = {0};
+        mp_bluetooth_gap_on_connected_disconnected(irq_event, conn_handle, 0xff, addr);
+    #if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+    } else if (event_type == GATT_EVENT_QUERY_COMPLETE) {
+        DEBUG_EVENT_printf("  --> gatt query complete\n");
+    } else if (event_type == GATT_EVENT_SERVICE_QUERY_RESULT) {
+        DEBUG_EVENT_printf("  --> gatt service query result\n");
+        uint16_t conn_handle = gatt_event_service_query_result_get_handle(packet);
+        gatt_client_service_t service;
+        gatt_event_service_query_result_get_service(packet, &service);
+        mp_obj_bluetooth_uuid_t service_uuid = create_mp_uuid(service.uuid16, service.uuid128);
+        mp_bluetooth_gattc_on_primary_service_result(conn_handle, service.start_group_handle, service.end_group_handle, &service_uuid);
+    } else if (event_type == GATT_EVENT_CHARACTERISTIC_QUERY_RESULT) {
+        DEBUG_EVENT_printf("  --> gatt characteristic query result\n");
+        uint16_t conn_handle = gatt_event_characteristic_query_result_get_handle(packet);
+        gatt_client_characteristic_t characteristic;
+        gatt_event_characteristic_query_result_get_characteristic(packet, &characteristic);
+        mp_obj_bluetooth_uuid_t characteristic_uuid = create_mp_uuid(characteristic.uuid16, characteristic.uuid128);
+        mp_bluetooth_gattc_on_characteristic_result(conn_handle, characteristic.start_handle, characteristic.value_handle, characteristic.properties, &characteristic_uuid);
+    } else if (event_type == GATT_EVENT_CHARACTERISTIC_DESCRIPTOR_QUERY_RESULT) {
+        DEBUG_EVENT_printf("  --> gatt descriptor query result\n");
+        uint16_t conn_handle = gatt_event_all_characteristic_descriptors_query_result_get_handle(packet);
+        gatt_client_characteristic_descriptor_t descriptor;
+        gatt_event_all_characteristic_descriptors_query_result_get_characteristic_descriptor(packet, &descriptor);
+        mp_obj_bluetooth_uuid_t descriptor_uuid = create_mp_uuid(descriptor.uuid16, descriptor.uuid128);
+        mp_bluetooth_gattc_on_descriptor_result(conn_handle, descriptor.handle, &descriptor_uuid);
+    } else if (event_type == GATT_EVENT_CHARACTERISTIC_VALUE_QUERY_RESULT) {
+        DEBUG_EVENT_printf("  --> gatt characteristic value query result\n");
+        uint16_t conn_handle = gatt_event_characteristic_value_query_result_get_handle(packet);
+        uint16_t value_handle = gatt_event_characteristic_value_query_result_get_value_handle(packet);
+        uint16_t len = gatt_event_characteristic_value_query_result_get_value_length(packet);
+        const uint8_t *data = gatt_event_characteristic_value_query_result_get_value(packet);
+        mp_uint_t atomic_state;
+        len = mp_bluetooth_gattc_on_data_available_start(MP_BLUETOOTH_IRQ_GATTC_READ_RESULT, conn_handle, value_handle, len, &atomic_state);
+        mp_bluetooth_gattc_on_data_available_chunk(data, len);
+        mp_bluetooth_gattc_on_data_available_end(atomic_state);
+    } else if (event_type == GATT_EVENT_NOTIFICATION) {
+        DEBUG_EVENT_printf("  --> gatt notification\n");
+        uint16_t conn_handle = gatt_event_notification_get_handle(packet);
+        uint16_t value_handle = gatt_event_notification_get_value_handle(packet);
+        uint16_t len = gatt_event_notification_get_value_length(packet);
+        const uint8_t *data = gatt_event_notification_get_value(packet);
+        mp_uint_t atomic_state;
+        len = mp_bluetooth_gattc_on_data_available_start(MP_BLUETOOTH_IRQ_GATTC_NOTIFY, conn_handle, value_handle, len, &atomic_state);
+        mp_bluetooth_gattc_on_data_available_chunk(data, len);
+        mp_bluetooth_gattc_on_data_available_end(atomic_state);
+    } else if (event_type == GATT_EVENT_INDICATION) {
+        DEBUG_EVENT_printf("  --> gatt indication\n");
+        uint16_t conn_handle = gatt_event_indication_get_handle(packet);
+        uint16_t value_handle = gatt_event_indication_get_value_handle(packet);
+        uint16_t len = gatt_event_indication_get_value_length(packet);
+        const uint8_t *data = gatt_event_indication_get_value(packet);
+        mp_uint_t atomic_state;
+        len = mp_bluetooth_gattc_on_data_available_start(MP_BLUETOOTH_IRQ_GATTC_INDICATE, conn_handle, value_handle, len, &atomic_state);
+        mp_bluetooth_gattc_on_data_available_chunk(data, len);
+        mp_bluetooth_gattc_on_data_available_end(atomic_state);
+    #endif
+    } else {
+        DEBUG_EVENT_printf("  --> hci event type: unknown (0x%02x)\n", event_type);
+    }
+}
+
+#if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+STATIC void btstack_packet_handler_write_with_response(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size) {
+    (void)channel;
+    (void)size;
+    DEBUG_EVENT_printf("btstack_packet_handler_write_with_response(packet_type=%u, channel=%u, packet=%p, size=%u)\n", packet_type, channel, packet, size);
+    if (packet_type != HCI_EVENT_PACKET) {
+        return;
+    }
+
+    uint8_t event_type = hci_event_packet_get_type(packet);
+    if (event_type == GATT_EVENT_QUERY_COMPLETE) {
+        DEBUG_EVENT_printf("  --> gatt query complete\n");
+        uint16_t conn_handle = gatt_event_query_complete_get_handle(packet);
+        uint8_t status = gatt_event_query_complete_get_att_status(packet);
+        // TODO there is no value_handle to pass here
+        mp_bluetooth_gattc_on_write_status(conn_handle, 0, status);
+    }
+}
+#endif
+
+STATIC btstack_timer_source_t btstack_init_deinit_timeout;
+
+STATIC void btstack_init_deinit_timeout_handler(btstack_timer_source_t *ds) {
+    (void)ds;
+
+    // Stop waiting for initialisation.
+    // This signals both the loops in mp_bluetooth_init and mp_bluetooth_deinit,
+    // as well as ports that run a polling loop.
+    mp_bluetooth_btstack_state = MP_BLUETOOTH_BTSTACK_STATE_TIMEOUT;
+}
+
+int mp_bluetooth_init(void) {
+    DEBUG_EVENT_printf("mp_bluetooth_init\n");
+
+    if (mp_bluetooth_btstack_state == MP_BLUETOOTH_BTSTACK_STATE_ACTIVE) {
+        return 0;
+    }
+
+    // Clean up if necessary.
+    mp_bluetooth_deinit();
+
+    btstack_memory_init();
+
+    MP_STATE_PORT(bluetooth_btstack_root_pointers) = m_new0(mp_bluetooth_btstack_root_pointers_t, 1);
+    mp_bluetooth_gatts_db_create(&MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db);
+
+    // Set the default GAP device name.
+    const char *gap_name = MICROPY_PY_BLUETOOTH_DEFAULT_GAP_NAME;
+    size_t gap_len = strlen(gap_name);
+    mp_bluetooth_gatts_db_create_entry(MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db, BTSTACK_GAP_DEVICE_NAME_HANDLE, gap_len);
+    mp_bluetooth_gap_set_device_name((const uint8_t *)gap_name, gap_len);
+
+    mp_bluetooth_btstack_port_init();
+    mp_bluetooth_btstack_state = MP_BLUETOOTH_BTSTACK_STATE_STARTING;
+
+    l2cap_init();
+    le_device_db_init();
+    sm_init();
+
+    // Set blank ER/IR keys to suppress BTstack warning.
+    // TODO handle this correctly.
+    sm_key_t dummy_key;
+    memset(dummy_key, 0, sizeof(dummy_key));
+    sm_set_er(dummy_key);
+    sm_set_ir(dummy_key);
+
+    #if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+    gatt_client_init();
+    #endif
+
+    // Register for HCI events.
+    hci_event_callback_registration.callback = &btstack_packet_handler;
+    hci_add_event_handler(&hci_event_callback_registration);
+
+    // Set a timeout for HCI initialisation.
+    btstack_run_loop_set_timer(&btstack_init_deinit_timeout, BTSTACK_INIT_DEINIT_TIMEOUT_MS);
+    btstack_run_loop_set_timer_handler(&btstack_init_deinit_timeout, btstack_init_deinit_timeout_handler);
+    btstack_run_loop_add_timer(&btstack_init_deinit_timeout);
+
+    // Either the HCI event will set state to ACTIVE, or the timeout will set it to TIMEOUT.
+    mp_bluetooth_btstack_port_start();
+    while (mp_bluetooth_btstack_state == MP_BLUETOOTH_BTSTACK_STATE_STARTING) {
+        MICROPY_EVENT_POLL_HOOK
+    }
+    btstack_run_loop_remove_timer(&btstack_init_deinit_timeout);
+
+    // Check for timeout.
+    if (mp_bluetooth_btstack_state != MP_BLUETOOTH_BTSTACK_STATE_ACTIVE) {
+        // Required to stop the polling loop.
+        mp_bluetooth_btstack_state = MP_BLUETOOTH_BTSTACK_STATE_OFF;
+        // Attempt a shutdown (may not do anything).
+        mp_bluetooth_btstack_port_deinit();
+
+        // Clean up.
+        MP_STATE_PORT(bluetooth_btstack_root_pointers) = NULL;
+        return MP_ETIMEDOUT;
+    }
+
+    #if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+    // Enable GATT_EVENT_NOTIFICATION/GATT_EVENT_INDICATION for all connections and handles.
+    gatt_client_listen_for_characteristic_value_updates(&MP_STATE_PORT(bluetooth_btstack_root_pointers)->notification, &btstack_packet_handler, GATT_CLIENT_ANY_CONNECTION, NULL);
+    #endif
+
+    return 0;
+}
+
+void mp_bluetooth_deinit(void) {
+    DEBUG_EVENT_printf("mp_bluetooth_deinit\n");
+
+    // Nothing to do if not initialised.
+    if (!MP_STATE_PORT(bluetooth_btstack_root_pointers)) {
+        return;
+    }
+
+    mp_bluetooth_gap_advertise_stop();
+
+    #if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+    // Remove our registration for notify/indicate.
+    gatt_client_stop_listening_for_characteristic_value_updates(&MP_STATE_PORT(bluetooth_btstack_root_pointers)->notification);
+    #endif
+
+    // Set a timer that will forcibly set the state to TIMEOUT, which will stop the loop below.
+    btstack_run_loop_set_timer(&btstack_init_deinit_timeout, BTSTACK_INIT_DEINIT_TIMEOUT_MS);
+    btstack_run_loop_add_timer(&btstack_init_deinit_timeout);
+
+    // This should result in a clean shutdown, which will set the state to OFF.
+    // On Unix this is blocking (it joins on the poll thread), on other ports the loop below will wait unil
+    // either timeout or clean shutdown.
+    mp_bluetooth_btstack_port_deinit();
+    while (mp_bluetooth_btstack_state == MP_BLUETOOTH_BTSTACK_STATE_ACTIVE) {
+        MICROPY_EVENT_POLL_HOOK
+    }
+    btstack_run_loop_remove_timer(&btstack_init_deinit_timeout);
+
+    mp_bluetooth_btstack_state = MP_BLUETOOTH_BTSTACK_STATE_OFF;
+    MP_STATE_PORT(bluetooth_btstack_root_pointers) = NULL;
+}
+
+bool mp_bluetooth_is_active(void) {
+    return mp_bluetooth_btstack_state == MP_BLUETOOTH_BTSTACK_STATE_ACTIVE;
+}
+
+void mp_bluetooth_get_device_addr(uint8_t *addr) {
+    mp_hal_get_mac(MP_HAL_MAC_BDADDR, addr);
+}
+
+size_t mp_bluetooth_gap_get_device_name(const uint8_t **buf) {
+    uint8_t *value = NULL;
+    size_t value_len = 0;
+    mp_bluetooth_gatts_db_read(MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db, BTSTACK_GAP_DEVICE_NAME_HANDLE, &value, &value_len);
+    *buf = value;
+    return value_len;
+}
+
+int mp_bluetooth_gap_set_device_name(const uint8_t *buf, size_t len) {
+    mp_bluetooth_gatts_db_write(MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db, BTSTACK_GAP_DEVICE_NAME_HANDLE, buf, len);
+    return 0;
+}
+
+int mp_bluetooth_gap_advertise_start(bool connectable, int32_t interval_us, const uint8_t *adv_data, size_t adv_data_len, const uint8_t *sr_data, size_t sr_data_len) {
+    DEBUG_EVENT_printf("mp_bluetooth_gap_advertise_start\n");
+    uint16_t adv_int_min = interval_us / 625;
+    uint16_t adv_int_max = interval_us / 625;
+    uint8_t adv_type = connectable ? 0 : 2;
+    bd_addr_t null_addr = {0};
+
+    uint8_t direct_address_type = 0;
+    uint8_t channel_map = 0x07; // Use all three broadcast channels.
+    uint8_t filter_policy = 0x00; // None.
+
+    gap_advertisements_set_params(adv_int_min, adv_int_max, adv_type, direct_address_type, null_addr, channel_map, filter_policy);
+
+    // Copy the adv_data and sr_data into a persistent buffer (which is findable via the btstack root pointers).
+    size_t total_bytes = adv_data_len + sr_data_len;
+    if (total_bytes > MP_STATE_PORT(bluetooth_btstack_root_pointers)->adv_data_alloc) {
+        // Resize if necessary.
+        MP_STATE_PORT(bluetooth_btstack_root_pointers)->adv_data = m_new(uint8_t, total_bytes);
+        MP_STATE_PORT(bluetooth_btstack_root_pointers)->adv_data_alloc = total_bytes;
+    }
+    uint8_t *data = MP_STATE_PORT(bluetooth_btstack_root_pointers)->adv_data;
+
+    if (adv_data) {
+        memcpy(data, (uint8_t *)adv_data, adv_data_len);
+        gap_advertisements_set_data(adv_data_len, data);
+        data += adv_data_len;
+    }
+    if (sr_data) {
+        memcpy(data, (uint8_t *)sr_data, sr_data_len);
+        gap_scan_response_set_data(sr_data_len, data);
+    }
+
+    gap_advertisements_enable(true);
+    return 0;
+}
+
+void mp_bluetooth_gap_advertise_stop(void) {
+    DEBUG_EVENT_printf("mp_bluetooth_gap_advertise_stop\n");
+    gap_advertisements_enable(false);
+    MP_STATE_PORT(bluetooth_btstack_root_pointers)->adv_data_alloc = 0;
+    MP_STATE_PORT(bluetooth_btstack_root_pointers)->adv_data = NULL;
+}
+
+int mp_bluetooth_gatts_register_service_begin(bool append) {
+    DEBUG_EVENT_printf("mp_bluetooth_gatts_register_service_begin\n");
+    if (!append) {
+        // This will reset the DB.
+        // Becase the DB is statically allocated, there's no problem with just re-initing it.
+        // Note this would be a memory leak if we enabled HAVE_MALLOC (there's no API to free the existing db).
+        att_db_util_init();
+
+        att_db_util_add_service_uuid16(GAP_SERVICE_UUID);
+        uint16_t handle = att_db_util_add_characteristic_uuid16(GAP_DEVICE_NAME_UUID, ATT_PROPERTY_READ | ATT_PROPERTY_DYNAMIC, ATT_SECURITY_NONE, ATT_SECURITY_NONE, NULL, 0);
+        assert(handle == BTSTACK_GAP_DEVICE_NAME_HANDLE);
+        (void)handle;
+
+        att_db_util_add_service_uuid16(0x1801);
+        att_db_util_add_characteristic_uuid16(0x2a05, ATT_PROPERTY_READ, ATT_SECURITY_NONE, ATT_SECURITY_NONE, NULL, 0);
+    }
+
+    return 0;
+}
+
+STATIC uint16_t att_read_callback(hci_con_handle_t connection_handle, uint16_t att_handle, uint16_t offset, uint8_t *buffer, uint16_t buffer_size) {
+    (void)connection_handle;
+    DEBUG_EVENT_printf("btstack: att_read_callback (handle: %u, offset: %u, buffer: %p, size: %u)\n", att_handle, offset, buffer, buffer_size);
+    mp_bluetooth_gatts_db_entry_t *entry = mp_bluetooth_gatts_db_lookup(MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db, att_handle);
+    if (!entry) {
+        DEBUG_EVENT_printf("btstack: att_read_callback handle not found\n");
+        return 0; // TODO: Find status code for not-found.
+    }
+
+    return att_read_callback_handle_blob(entry->data, entry->data_len, offset, buffer, buffer_size);
+}
+
+STATIC int att_write_callback(hci_con_handle_t connection_handle, uint16_t att_handle, uint16_t transaction_mode, uint16_t offset, uint8_t *buffer, uint16_t buffer_size) {
+    (void)offset;
+    (void)transaction_mode;
+    DEBUG_EVENT_printf("btstack: att_write_callback (handle: %u, mode: %u, offset: %u, buffer: %p, size: %u)\n", att_handle, transaction_mode, offset, buffer, buffer_size);
+    mp_bluetooth_gatts_db_entry_t *entry = mp_bluetooth_gatts_db_lookup(MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db, att_handle);
+    if (!entry) {
+        DEBUG_EVENT_printf("btstack: att_write_callback handle not found\n");
+        return 0; // TODO: Find status code for not-found.
+    }
+
+    // TODO: Use `offset` arg.
+    size_t append_offset = 0;
+    if (entry->append) {
+        append_offset = entry->data_len;
+    }
+    entry->data_len = MIN(entry->data_alloc, buffer_size + append_offset);
+    memcpy(entry->data + append_offset, buffer, entry->data_len - append_offset);
+
+    mp_bluetooth_gatts_on_write(connection_handle, att_handle);
+
+    return 0;
+}
+
+STATIC inline uint16_t get_uuid16(const mp_obj_bluetooth_uuid_t *uuid) {
+    return (uuid->data[1] << 8) | uuid->data[0];
+}
+
+int mp_bluetooth_gatts_register_service(mp_obj_bluetooth_uuid_t *service_uuid, mp_obj_bluetooth_uuid_t **characteristic_uuids, uint8_t *characteristic_flags, mp_obj_bluetooth_uuid_t **descriptor_uuids, uint8_t *descriptor_flags, uint8_t *num_descriptors, uint16_t *handles, size_t num_characteristics) {
+    DEBUG_EVENT_printf("mp_bluetooth_gatts_register_service\n");
+    // Note: btstack expects BE UUIDs (which it immediately convertes to LE).
+    // So we have to convert all our modbluetooth LE UUIDs to BE just for the att_db_util_add_* methods (using get_uuid16 above, and reverse_128 from btstackutil.h).
+
+    // TODO: btstack's att_db_util_add_* methods have no bounds checking or validation.
+    // Need some way to prevent additional services being added if we're out of space in the static buffer.
+
+    if (service_uuid->type == MP_BLUETOOTH_UUID_TYPE_16) {
+        att_db_util_add_service_uuid16(get_uuid16(service_uuid));
+    } else if (service_uuid->type == MP_BLUETOOTH_UUID_TYPE_128) {
+        uint8_t buffer[16];
+        reverse_128(service_uuid->data, buffer);
+        att_db_util_add_service_uuid128(buffer);
+    } else {
+        return MP_EINVAL;
+    }
+
+    size_t handle_index = 0;
+    size_t descriptor_index = 0;
+    static uint8_t cccb_buf[2] = {0};
+
+    for (size_t i = 0; i < num_characteristics; ++i) {
+        uint16_t props = characteristic_flags[i] | ATT_PROPERTY_DYNAMIC;
+        uint16_t read_permission = ATT_SECURITY_NONE;
+        uint16_t write_permission = ATT_SECURITY_NONE;
+        if (characteristic_uuids[i]->type == MP_BLUETOOTH_UUID_TYPE_16) {
+            handles[handle_index] = att_db_util_add_characteristic_uuid16(get_uuid16(characteristic_uuids[i]), props, read_permission, write_permission, NULL, 0);
+        } else if (characteristic_uuids[i]->type == MP_BLUETOOTH_UUID_TYPE_128) {
+            uint8_t buffer[16];
+            reverse_128(characteristic_uuids[i]->data, buffer);
+            handles[handle_index] = att_db_util_add_characteristic_uuid128(buffer, props, read_permission, write_permission, NULL, 0);
+        } else {
+            return MP_EINVAL;
+        }
+        mp_bluetooth_gatts_db_create_entry(MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db, handles[handle_index], MP_BLUETOOTH_DEFAULT_ATTR_LEN);
+        // If a NOTIFY or INDICATE characteristic is added, then we need to manage a value for the CCCB.
+        if (props & (ATT_PROPERTY_NOTIFY | ATT_PROPERTY_INDICATE)) {
+            // btstack creates the CCCB as the next handle.
+            mp_bluetooth_gatts_db_create_entry(MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db, handles[handle_index] + 1, MP_BLUETOOTH_CCCB_LEN);
+            mp_bluetooth_gatts_db_write(MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db, handles[handle_index] + 1, cccb_buf, sizeof(cccb_buf));
+        }
+        DEBUG_EVENT_printf("Registered char with handle %u\n", handles[handle_index]);
+        ++handle_index;
+
+        for (size_t j = 0; j < num_descriptors[i]; ++j) {
+            props = descriptor_flags[descriptor_index] | ATT_PROPERTY_DYNAMIC;
+            read_permission = ATT_SECURITY_NONE;
+            write_permission = ATT_SECURITY_NONE;
+
+            if (descriptor_uuids[descriptor_index]->type == MP_BLUETOOTH_UUID_TYPE_16) {
+                handles[handle_index] = att_db_util_add_descriptor_uuid16(get_uuid16(descriptor_uuids[descriptor_index]), props, read_permission, write_permission, NULL, 0);
+            } else if (descriptor_uuids[descriptor_index]->type == MP_BLUETOOTH_UUID_TYPE_128) {
+                uint8_t buffer[16];
+                reverse_128(descriptor_uuids[descriptor_index]->data, buffer);
+                handles[handle_index] = att_db_util_add_descriptor_uuid128(buffer, props, read_permission, write_permission, NULL, 0);
+            } else {
+                return MP_EINVAL;
+            }
+            mp_bluetooth_gatts_db_create_entry(MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db, handles[handle_index], MP_BLUETOOTH_DEFAULT_ATTR_LEN);
+            DEBUG_EVENT_printf("Registered desc with handle %u\n", handles[handle_index]);
+            ++descriptor_index;
+            ++handle_index;
+        }
+    }
+
+    return 0;
+}
+
+int mp_bluetooth_gatts_register_service_end(void) {
+    DEBUG_EVENT_printf("mp_bluetooth_gatts_register_service_end\n");
+    att_server_init(att_db_util_get_address(), &att_read_callback, &att_write_callback);
+    return 0;
+}
+
+int mp_bluetooth_gatts_read(uint16_t value_handle, uint8_t **value, size_t *value_len) {
+    DEBUG_EVENT_printf("mp_bluetooth_gatts_read\n");
+    return mp_bluetooth_gatts_db_read(MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db, value_handle, value, value_len);
+}
+
+int mp_bluetooth_gatts_write(uint16_t value_handle, const uint8_t *value, size_t value_len) {
+    DEBUG_EVENT_printf("mp_bluetooth_gatts_write\n");
+    return mp_bluetooth_gatts_db_write(MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db, value_handle, value, value_len);
+}
+
+int mp_bluetooth_gatts_notify(uint16_t conn_handle, uint16_t value_handle) {
+    DEBUG_EVENT_printf("mp_bluetooth_gatts_notify\n");
+    // Note: btstack doesn't appear to support sending a notification without a value, so include the stored value.
+    uint8_t *data = NULL;
+    size_t len = 0;
+    mp_bluetooth_gatts_db_read(MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db, value_handle, &data, &len);
+    return mp_bluetooth_gatts_notify_send(conn_handle, value_handle, data, &len);
+}
+
+int mp_bluetooth_gatts_notify_send(uint16_t conn_handle, uint16_t value_handle, const uint8_t *value, size_t *value_len) {
+    DEBUG_EVENT_printf("mp_bluetooth_gatts_notify_send\n");
+    // TODO: We need to use att_server_request_to_send_notification here as the stack may not be ready to send a notification.
+    int err = att_server_notify(conn_handle, value_handle, value, *value_len);
+    return btstack_error_to_errno(err);
+}
+
+int mp_bluetooth_gatts_indicate(uint16_t conn_handle, uint16_t value_handle) {
+    DEBUG_EVENT_printf("mp_bluetooth_gatts_indicate\n");
+    return btstack_error_to_errno(att_server_indicate(conn_handle, value_handle, NULL, 0));
+}
+
+int mp_bluetooth_gatts_set_buffer(uint16_t value_handle, size_t len, bool append) {
+    DEBUG_EVENT_printf("mp_bluetooth_gatts_set_buffer\n");
+    return mp_bluetooth_gatts_db_resize(MP_STATE_PORT(bluetooth_btstack_root_pointers)->gatts_db, value_handle, len, append);
+}
+
+int mp_bluetooth_gap_disconnect(uint16_t conn_handle) {
+    DEBUG_EVENT_printf("mp_bluetooth_gap_disconnect\n");
+    gap_disconnect(conn_handle);
+    return 0;
+}
+
+#if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+STATIC btstack_timer_source_t scan_duration_timeout;
+
+STATIC void hci_initialization_timeout_handler(btstack_timer_source_t *ds) {
+    (void)ds;
+    mp_bluetooth_gap_scan_stop();
+}
+
+int mp_bluetooth_gap_scan_start(int32_t duration_ms, int32_t interval_us, int32_t window_us) {
+    DEBUG_EVENT_printf("mp_bluetooth_gap_scan_start\n");
+
+    btstack_run_loop_set_timer(&scan_duration_timeout, duration_ms);
+    btstack_run_loop_set_timer_handler(&scan_duration_timeout, hci_initialization_timeout_handler);
+    btstack_run_loop_add_timer(&scan_duration_timeout);
+
+    // 0 = passive scan (we don't handle scan response).
+    gap_set_scan_parameters(0, interval_us / 625, window_us / 625);
+    gap_start_scan();
+
+    return 0;
+}
+
+int mp_bluetooth_gap_scan_stop(void) {
+    DEBUG_EVENT_printf("mp_bluetooth_gap_scan_stop\n");
+    btstack_run_loop_remove_timer(&scan_duration_timeout);
+    gap_stop_scan();
+    mp_bluetooth_gap_on_scan_complete();
+    return 0;
+}
+
+int mp_bluetooth_gap_peripheral_connect(uint8_t addr_type, const uint8_t *addr, int32_t duration_ms) {
+    DEBUG_EVENT_printf("mp_bluetooth_gap_peripheral_connect\n");
+
+    uint16_t conn_scan_interval = 60000 / 625;
+    uint16_t conn_scan_window = 30000 / 625;
+    uint16_t conn_interval_min = 10000 / 1250;
+    uint16_t conn_interval_max = 30000 / 1250;
+    uint16_t conn_latency = 4;
+    uint16_t supervision_timeout = duration_ms / 10; // default = 720
+    uint16_t min_ce_length = 10000 / 625;
+    uint16_t max_ce_length = 30000 / 625;
+
+    gap_set_connection_parameters(conn_scan_interval, conn_scan_window, conn_interval_min, conn_interval_max, conn_latency, supervision_timeout, min_ce_length, max_ce_length);
+
+    bd_addr_t btstack_addr;
+    memcpy(btstack_addr, addr, BD_ADDR_LEN);
+    return btstack_error_to_errno(gap_connect(btstack_addr, addr_type));
+}
+
+int mp_bluetooth_gattc_discover_primary_services(uint16_t conn_handle) {
+    DEBUG_EVENT_printf("mp_bluetooth_gattc_discover_primary_services\n");
+    return btstack_error_to_errno(gatt_client_discover_primary_services(&btstack_packet_handler, conn_handle));
+}
+
+int mp_bluetooth_gattc_discover_characteristics(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle) {
+    DEBUG_EVENT_printf("mp_bluetooth_gattc_discover_characteristics\n");
+
+    gatt_client_service_t service = {
+        // Only start/end handles needed for gatt_client_discover_characteristics_for_service.
+        .start_group_handle = start_handle,
+        .end_group_handle = end_handle,
+        .uuid16 = 0,
+        .uuid128 = {0},
+    };
+    return btstack_error_to_errno(gatt_client_discover_characteristics_for_service(&btstack_packet_handler, conn_handle, &service));
+}
+
+int mp_bluetooth_gattc_discover_descriptors(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle) {
+    DEBUG_EVENT_printf("mp_bluetooth_gattc_discover_descriptors\n");
+    gatt_client_characteristic_t characteristic = {
+        // Only start/end handles needed for gatt_client_discover_characteristic_descriptors.
+        .start_handle = start_handle,
+        .value_handle = 0,
+        .end_handle = end_handle,
+        .properties = 0,
+        .uuid16 = 0,
+        .uuid128 = {0},
+    };
+    return btstack_error_to_errno(gatt_client_discover_characteristic_descriptors(&btstack_packet_handler, conn_handle, &characteristic));
+}
+
+int mp_bluetooth_gattc_read(uint16_t conn_handle, uint16_t value_handle) {
+    DEBUG_EVENT_printf("mp_bluetooth_gattc_read\n");
+    return btstack_error_to_errno(gatt_client_read_value_of_characteristic_using_value_handle(&btstack_packet_handler, conn_handle, value_handle));
+}
+
+int mp_bluetooth_gattc_write(uint16_t conn_handle, uint16_t value_handle, const uint8_t *value, size_t *value_len, unsigned int mode) {
+    DEBUG_EVENT_printf("mp_bluetooth_gattc_write\n");
+
+    // TODO the below gatt_client functions do not copy the data and require it to be valid
+    // until the write is done, so there should be some kind of buffering done here.
+
+    if (mode == MP_BLUETOOTH_WRITE_MODE_NO_RESPONSE) {
+        // TODO need to call gatt_client_request_can_write_without_response_event then do
+        // the actual write on the callback from that.
+        return btstack_error_to_errno(gatt_client_write_value_of_characteristic_without_response(conn_handle, value_handle, *value_len, (uint8_t *)value));
+    }
+    if (mode == MP_BLUETOOTH_WRITE_MODE_WITH_RESPONSE) {
+        return btstack_error_to_errno(gatt_client_write_value_of_characteristic(&btstack_packet_handler_write_with_response, conn_handle, value_handle, *value_len, (uint8_t *)value));
+    }
+
+    return MP_EINVAL;
+}
+#endif // MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+
+#endif // MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_BTSTACK
diff --git a/extmod/btstack/modbluetooth_btstack.h b/extmod/btstack/modbluetooth_btstack.h
new file mode 100644
index 0000000000000..3bdb5f271e5dd
--- /dev/null
+++ b/extmod/btstack/modbluetooth_btstack.h
@@ -0,0 +1,66 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_EXTMOD_BTSTACK_MODBLUETOOTH_BTSTACK_H
+#define MICROPY_INCLUDED_EXTMOD_BTSTACK_MODBLUETOOTH_BTSTACK_H
+
+#if MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_BTSTACK
+
+#include "extmod/modbluetooth.h"
+
+#include "lib/btstack/src/btstack.h"
+
+typedef struct _mp_bluetooth_btstack_root_pointers_t {
+    // This stores both the advertising data and the scan response data, concatenated together.
+    uint8_t *adv_data;
+    // Total length of both.
+    size_t adv_data_alloc;
+
+    // Characteristic (and descriptor) value storage.
+    mp_gatts_db_t gatts_db;
+
+    #if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+    // Registration for notify/indicate events.
+    gatt_client_notification_t notification;
+    #endif
+} mp_bluetooth_btstack_root_pointers_t;
+
+enum {
+    MP_BLUETOOTH_BTSTACK_STATE_OFF,
+    MP_BLUETOOTH_BTSTACK_STATE_STARTING,
+    MP_BLUETOOTH_BTSTACK_STATE_ACTIVE,
+    MP_BLUETOOTH_BTSTACK_STATE_TIMEOUT,
+};
+
+extern volatile int mp_bluetooth_btstack_state;
+
+void mp_bluetooth_btstack_port_init(void);
+void mp_bluetooth_btstack_port_deinit(void);
+void mp_bluetooth_btstack_port_start(void);
+
+#endif // MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_BTSTACK
+
+#endif // MICROPY_INCLUDED_EXTMOD_BTSTACK_MODBLUETOOTH_BTSTACK_H
diff --git a/extmod/crypto-algorithms/sha256.c b/extmod/crypto-algorithms/sha256.c
index 276611cfd5032..24e964749b693 100644
--- a/extmod/crypto-algorithms/sha256.c
+++ b/extmod/crypto-algorithms/sha256.c
@@ -1,7 +1,8 @@
 /*********************************************************************
+* Source:     https://github.com/B-Con/crypto-algorithms
 * Filename:   sha256.c
 * Author:     Brad Conte (brad AT bradconte.com)
-* Copyright:
+* Copyright:  This code is released into the public domain.
 * Disclaimer: This code is presented "as is" without any guarantees.
 * Details:    Implementation of the SHA-256 hashing algorithm.
               SHA-256 is one of the three algorithms in the SHA2
diff --git a/extmod/crypto-algorithms/sha256.h b/extmod/crypto-algorithms/sha256.h
index caa1f81020184..9c19472ea292f 100644
--- a/extmod/crypto-algorithms/sha256.h
+++ b/extmod/crypto-algorithms/sha256.h
@@ -1,7 +1,8 @@
 /*********************************************************************
+* Source:     https://github.com/B-Con/crypto-algorithms
 * Filename:   sha256.h
 * Author:     Brad Conte (brad AT bradconte.com)
-* Copyright:
+* Copyright:  This code is released into the public domain.
 * Disclaimer: This code is presented "as is" without any guarantees.
 * Details:    Defines the API for the corresponding SHA1 implementation.
 *********************************************************************/
diff --git a/extmod/extmod.mk b/extmod/extmod.mk
new file mode 100644
index 0000000000000..e312acba86db4
--- /dev/null
+++ b/extmod/extmod.mk
@@ -0,0 +1,229 @@
+# This makefile fragment provides rules to build 3rd-party components for extmod modules
+
+################################################################################
+# VFS FAT FS
+
+OOFATFS_DIR = lib/oofatfs
+
+# this sets the config file for FatFs
+CFLAGS_MOD += -DFFCONF_H=\"$(OOFATFS_DIR)/ffconf.h\"
+
+ifeq ($(MICROPY_VFS_FAT),1)
+CFLAGS_MOD += -DMICROPY_VFS_FAT=1
+SRC_MOD += $(addprefix $(OOFATFS_DIR)/,\
+	ff.c \
+	ffunicode.c \
+	)
+endif
+
+################################################################################
+# VFS littlefs
+
+LITTLEFS_DIR = lib/littlefs
+
+ifeq ($(MICROPY_VFS_LFS1),1)
+CFLAGS_MOD += -DMICROPY_VFS_LFS1=1
+CFLAGS_MOD += -DLFS1_NO_MALLOC -DLFS1_NO_DEBUG -DLFS1_NO_WARN -DLFS1_NO_ERROR -DLFS1_NO_ASSERT
+SRC_MOD += $(addprefix $(LITTLEFS_DIR)/,\
+	lfs1.c \
+	lfs1_util.c \
+	)
+endif
+
+ifeq ($(MICROPY_VFS_LFS2),1)
+CFLAGS_MOD += -DMICROPY_VFS_LFS2=1
+CFLAGS_MOD += -DLFS2_NO_MALLOC -DLFS2_NO_DEBUG -DLFS2_NO_WARN -DLFS2_NO_ERROR -DLFS2_NO_ASSERT
+SRC_MOD += $(addprefix $(LITTLEFS_DIR)/,\
+	lfs2.c \
+	lfs2_util.c \
+	)
+endif
+
+################################################################################
+# ussl
+
+ifeq ($(MICROPY_PY_USSL),1)
+CFLAGS_MOD += -DMICROPY_PY_USSL=1
+ifeq ($(MICROPY_SSL_AXTLS),1)
+CFLAGS_MOD += -DMICROPY_SSL_AXTLS=1 -I$(TOP)/lib/axtls/ssl -I$(TOP)/lib/axtls/crypto -I$(TOP)/extmod/axtls-include
+AXTLS_DIR = lib/axtls
+$(BUILD)/$(AXTLS_DIR)/%.o: CFLAGS += -Wno-all -Wno-unused-parameter -Wno-uninitialized -Wno-sign-compare -Wno-old-style-definition -Dmp_stream_errno=errno $(AXTLS_DEFS_EXTRA)
+SRC_MOD += $(addprefix $(AXTLS_DIR)/,\
+	ssl/asn1.c \
+	ssl/loader.c \
+	ssl/tls1.c \
+	ssl/tls1_svr.c \
+	ssl/tls1_clnt.c \
+	ssl/x509.c \
+	crypto/aes.c \
+	crypto/bigint.c \
+	crypto/crypto_misc.c \
+	crypto/hmac.c \
+	crypto/md5.c \
+	crypto/rsa.c \
+	crypto/sha1.c \
+	)
+else ifeq ($(MICROPY_SSL_MBEDTLS),1)
+MBEDTLS_DIR = lib/mbedtls
+CFLAGS_MOD += -DMICROPY_SSL_MBEDTLS=1 -I$(TOP)/$(MBEDTLS_DIR)/include
+SRC_MOD += $(addprefix $(MBEDTLS_DIR)/library/,\
+	aes.c \
+	aesni.c \
+	arc4.c \
+	asn1parse.c \
+	asn1write.c \
+	base64.c \
+	bignum.c \
+	blowfish.c \
+	camellia.c \
+	ccm.c \
+	certs.c \
+	chacha20.c \
+	chachapoly.c \
+	cipher.c \
+	cipher_wrap.c \
+	cmac.c \
+	ctr_drbg.c \
+	debug.c \
+	des.c \
+	dhm.c \
+	ecdh.c \
+	ecdsa.c \
+	ecjpake.c \
+	ecp.c \
+	ecp_curves.c \
+	entropy.c \
+	entropy_poll.c \
+	error.c \
+	gcm.c \
+	havege.c \
+	hmac_drbg.c \
+	md2.c \
+	md4.c \
+	md5.c \
+	md.c \
+	md_wrap.c \
+	oid.c \
+	padlock.c \
+	pem.c \
+	pk.c \
+	pkcs11.c \
+	pkcs12.c \
+	pkcs5.c \
+	pkparse.c \
+	pk_wrap.c \
+	pkwrite.c \
+	platform.c \
+	platform_util.c \
+	poly1305.c \
+	ripemd160.c \
+	rsa.c \
+	rsa_internal.c \
+	sha1.c \
+	sha256.c \
+	sha512.c \
+	ssl_cache.c \
+	ssl_ciphersuites.c \
+	ssl_cli.c \
+	ssl_cookie.c \
+	ssl_srv.c \
+	ssl_ticket.c \
+	ssl_tls.c \
+	timing.c \
+	x509.c \
+	x509_create.c \
+	x509_crl.c \
+	x509_crt.c \
+	x509_csr.c \
+	x509write_crt.c \
+	x509write_csr.c \
+	xtea.c \
+	)
+endif
+endif
+
+################################################################################
+# lwip
+
+ifeq ($(MICROPY_PY_LWIP),1)
+# A port should add an include path where lwipopts.h can be found (eg extmod/lwip-include)
+LWIP_DIR = lib/lwip/src
+INC += -I$(TOP)/$(LWIP_DIR)/include
+CFLAGS_MOD += -DMICROPY_PY_LWIP=1
+$(BUILD)/$(LWIP_DIR)/core/ipv4/dhcp.o: CFLAGS_MOD += -Wno-address
+SRC_MOD += extmod/modlwip.c lib/netutils/netutils.c
+SRC_MOD += $(addprefix $(LWIP_DIR)/,\
+	apps/mdns/mdns.c \
+	core/def.c \
+	core/dns.c \
+	core/inet_chksum.c \
+	core/init.c \
+	core/ip.c \
+	core/mem.c \
+	core/memp.c \
+	core/netif.c \
+	core/pbuf.c \
+	core/raw.c \
+	core/stats.c \
+	core/sys.c \
+	core/tcp.c \
+	core/tcp_in.c \
+	core/tcp_out.c \
+	core/timeouts.c \
+	core/udp.c \
+	core/ipv4/autoip.c \
+	core/ipv4/dhcp.c \
+	core/ipv4/etharp.c \
+	core/ipv4/icmp.c \
+	core/ipv4/igmp.c \
+	core/ipv4/ip4_addr.c \
+	core/ipv4/ip4.c \
+	core/ipv4/ip4_frag.c \
+	core/ipv6/dhcp6.c \
+	core/ipv6/ethip6.c \
+	core/ipv6/icmp6.c \
+	core/ipv6/inet6.c \
+	core/ipv6/ip6_addr.c \
+	core/ipv6/ip6.c \
+	core/ipv6/ip6_frag.c \
+	core/ipv6/mld6.c \
+	core/ipv6/nd6.c \
+	netif/ethernet.c \
+	)
+ifeq ($(MICROPY_PY_LWIP_SLIP),1)
+CFLAGS_MOD += -DMICROPY_PY_LWIP_SLIP=1
+SRC_MOD += $(LWIP_DIR)/netif/slipif.c
+endif
+endif
+
+################################################################################
+# btree
+
+ifeq ($(MICROPY_PY_BTREE),1)
+BTREE_DIR = lib/berkeley-db-1.xx
+BTREE_DEFS = -D__DBINTERFACE_PRIVATE=1 -Dmpool_error=printf -Dabort=abort_ "-Dvirt_fd_t=void*" $(BTREE_DEFS_EXTRA)
+INC += -I$(TOP)/$(BTREE_DIR)/PORT/include
+SRC_MOD += extmod/modbtree.c
+SRC_MOD += $(addprefix $(BTREE_DIR)/,\
+	btree/bt_close.c \
+	btree/bt_conv.c \
+	btree/bt_debug.c \
+	btree/bt_delete.c \
+	btree/bt_get.c \
+	btree/bt_open.c \
+	btree/bt_overflow.c \
+	btree/bt_page.c \
+	btree/bt_put.c \
+	btree/bt_search.c \
+	btree/bt_seq.c \
+	btree/bt_split.c \
+	btree/bt_utils.c \
+	mpool/mpool.c \
+	)
+CFLAGS_MOD += -DMICROPY_PY_BTREE=1
+# we need to suppress certain warnings to get berkeley-db to compile cleanly
+# and we have separate BTREE_DEFS so the definitions don't interfere with other source code
+$(BUILD)/$(BTREE_DIR)/%.o: CFLAGS += -Wno-old-style-definition -Wno-sign-compare -Wno-unused-parameter $(BTREE_DEFS)
+$(BUILD)/extmod/modbtree.o: CFLAGS += $(BTREE_DEFS)
+endif
+
diff --git a/extmod/machine_i2c.c b/extmod/machine_i2c.c
index c1a93ab041ae8..14cba962365e1 100644
--- a/extmod/machine_i2c.c
+++ b/extmod/machine_i2c.c
@@ -180,10 +180,10 @@ STATIC int mp_hal_i2c_read_byte(machine_i2c_obj_t *self, uint8_t *val, int nack)
 }
 
 // return value:
-//  >=0 - number of acks received
+//  >=0 - success; for read it's 0, for write it's number of acks received
 //   <0 - error, with errno being the negative of the return value
-int mp_machine_soft_i2c_writeto(mp_obj_base_t *self_in, uint16_t addr, const uint8_t *src, size_t len, bool stop) {
-    machine_i2c_obj_t *self = (machine_i2c_obj_t*)self_in;
+int mp_machine_soft_i2c_transfer(mp_obj_base_t *self_in, uint16_t addr, size_t n, mp_machine_i2c_buf_t *bufs, unsigned int flags) {
+    machine_i2c_obj_t *self = (machine_i2c_obj_t *)self_in;
 
     // start the I2C transaction
     int ret = mp_hal_i2c_start(self);
@@ -192,7 +192,7 @@ int mp_machine_soft_i2c_writeto(mp_obj_base_t *self_in, uint16_t addr, const uin
     }
 
     // write the slave address
-    ret = mp_hal_i2c_write_byte(self, addr << 1);
+    ret = mp_hal_i2c_write_byte(self, (addr << 1) | (flags & MP_MACHINE_I2C_FLAG_READ));
     if (ret < 0) {
         return ret;
     } else if (ret != 0) {
@@ -201,69 +201,102 @@ int mp_machine_soft_i2c_writeto(mp_obj_base_t *self_in, uint16_t addr, const uin
         return -MP_ENODEV;
     }
 
-    // write the buffer to the I2C memory
-    int num_acks = 0;
-    while (len--) {
-        ret = mp_hal_i2c_write_byte(self, *src++);
-        if (ret < 0) {
-            return ret;
-        } else if (ret != 0) {
-            // nack received, stop sending
-            break;
+    int transfer_ret = 0;
+    for (; n--; ++bufs) {
+        size_t len = bufs->len;
+        uint8_t *buf = bufs->buf;
+        if (flags & MP_MACHINE_I2C_FLAG_READ) {
+            // read bytes from the slave into the given buffer(s)
+            while (len--) {
+                ret = mp_hal_i2c_read_byte(self, buf++, (n | len) == 0);
+                if (ret != 0) {
+                    return ret;
+                }
+            }
+        } else {
+            // write bytes from the given buffer(s) to the slave
+            while (len--) {
+                ret = mp_hal_i2c_write_byte(self, *buf++);
+                if (ret < 0) {
+                    return ret;
+                } else if (ret != 0) {
+                    // nack received, stop sending
+                    n = 0;
+                    break;
+                }
+                ++transfer_ret; // count the number of acks
+            }
         }
-        ++num_acks;
     }
 
     // finish the I2C transaction
-    if (stop) {
+    if (flags & MP_MACHINE_I2C_FLAG_STOP) {
         ret = mp_hal_i2c_stop(self);
         if (ret != 0) {
             return ret;
         }
     }
 
-    return num_acks;
+    return transfer_ret;
 }
 
-// return value:
-//    0 - success
-//   <0 - error, with errno being the negative of the return value
-int mp_machine_soft_i2c_readfrom(mp_obj_base_t *self_in, uint16_t addr, uint8_t *dest, size_t len, bool stop) {
-    machine_i2c_obj_t *self = (machine_i2c_obj_t*)self_in;
-
-    // start the I2C transaction
-    int ret = mp_hal_i2c_start(self);
-    if (ret != 0) {
-        return ret;
+/******************************************************************************/
+// Generic helper functions
+
+// For use by ports that require a single buffer of data for a read/write transfer
+int mp_machine_i2c_transfer_adaptor(mp_obj_base_t *self, uint16_t addr, size_t n, mp_machine_i2c_buf_t *bufs, unsigned int flags) {
+    size_t len;
+    uint8_t *buf;
+    if (n == 1) {
+        // Use given single buffer
+        len = bufs[0].len;
+        buf = bufs[0].buf;
+    } else {
+        // Combine buffers into a single one
+        len = 0;
+        for (size_t i = 0; i < n; ++i) {
+            len += bufs[i].len;
+        }
+        buf = m_new(uint8_t, len);
+        if (!(flags & MP_MACHINE_I2C_FLAG_READ)) {
+            len = 0;
+            for (size_t i = 0; i < n; ++i) {
+                memcpy(buf + len, bufs[i].buf, bufs[i].len);
+                len += bufs[i].len;
+            }
+        }
     }
 
-    // write the slave address
-    ret = mp_hal_i2c_write_byte(self, (addr << 1) | 1);
-    if (ret < 0) {
-        return ret;
-    } else if (ret != 0) {
-        // nack received, release the bus cleanly
-        mp_hal_i2c_stop(self);
-        return -MP_ENODEV;
-    }
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
+    int ret = i2c_p->transfer_single(self, addr, len, buf, flags);
 
-    // read the bytes from the slave
-    while (len--) {
-        ret = mp_hal_i2c_read_byte(self, dest++, len == 0);
-        if (ret != 0) {
-            return ret;
+    if (n > 1) {
+        if (flags & MP_MACHINE_I2C_FLAG_READ) {
+            // Copy data from single buffer to individual ones
+            len = 0;
+            for (size_t i = 0; i < n; ++i) {
+                memcpy(bufs[i].buf, buf + len, bufs[i].len);
+                len += bufs[i].len;
+            }
         }
+        m_del(uint8_t, buf, len);
     }
 
-    // finish the I2C transaction
-    if (stop) {
-        ret = mp_hal_i2c_stop(self);
-        if (ret != 0) {
-            return ret;
-        }
-    }
+    return ret;
+}
 
-    return 0; // success
+STATIC int mp_machine_i2c_readfrom(mp_obj_base_t *self, uint16_t addr, uint8_t *dest, size_t len, bool stop) {
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
+    mp_machine_i2c_buf_t buf = {.len = len, .buf = dest};
+    unsigned int flags = MP_MACHINE_I2C_FLAG_READ | (stop ? MP_MACHINE_I2C_FLAG_STOP : 0);
+    return i2c_p->transfer(self, addr, 1, &buf, flags);
+}
+
+STATIC int mp_machine_i2c_writeto(mp_obj_base_t *self, uint16_t addr, const uint8_t *src, size_t len, bool stop) {
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
+    mp_machine_i2c_buf_t buf = {.len = len, .buf = (uint8_t *)src};
+    unsigned int flags = stop ? MP_MACHINE_I2C_FLAG_STOP : 0;
+    return i2c_p->transfer(self, addr, 1, &buf, flags);
 }
 
 /******************************************************************************/
@@ -294,7 +327,7 @@ STATIC mp_obj_t machine_i2c_make_new(const mp_obj_type_t *type, size_t n_args, s
             extern mp_obj_t MICROPY_PY_MACHINE_I2C_MAKE_NEW(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args);
             return MICROPY_PY_MACHINE_I2C_MAKE_NEW(type, n_args, n_kw, args);
             #else
-            mp_raise_ValueError("invalid I2C peripheral");
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid I2C peripheral"));
             #endif
         }
         --n_args;
@@ -318,11 +351,10 @@ MP_DEFINE_CONST_FUN_OBJ_KW(machine_i2c_init_obj, 1, machine_i2c_obj_init);
 
 STATIC mp_obj_t machine_i2c_scan(mp_obj_t self_in) {
     mp_obj_base_t *self = MP_OBJ_TO_PTR(self_in);
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol;
     mp_obj_t list = mp_obj_new_list(0, NULL);
     // 7-bit addresses 0b0000xxx and 0b1111xxx are reserved
     for (int addr = 0x08; addr < 0x78; ++addr) {
-        int ret = i2c_p->writeto(self, addr, NULL, 0, true);
+        int ret = mp_machine_i2c_writeto(self, addr, NULL, 0, true);
         if (ret == 0) {
             mp_obj_list_append(list, MP_OBJ_NEW_SMALL_INT(addr));
         }
@@ -332,10 +364,10 @@ STATIC mp_obj_t machine_i2c_scan(mp_obj_t self_in) {
 MP_DEFINE_CONST_FUN_OBJ_1(machine_i2c_scan_obj, machine_i2c_scan);
 
 STATIC mp_obj_t machine_i2c_start(mp_obj_t self_in) {
-    mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(self_in);
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol;
+    mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(self_in);
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
     if (i2c_p->start == NULL) {
-        mp_raise_msg(&mp_type_OSError, "I2C operation not supported");
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("I2C operation not supported"));
     }
     int ret = i2c_p->start(self);
     if (ret != 0) {
@@ -346,10 +378,10 @@ STATIC mp_obj_t machine_i2c_start(mp_obj_t self_in) {
 MP_DEFINE_CONST_FUN_OBJ_1(machine_i2c_start_obj, machine_i2c_start);
 
 STATIC mp_obj_t machine_i2c_stop(mp_obj_t self_in) {
-    mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(self_in);
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol;
+    mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(self_in);
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
     if (i2c_p->stop == NULL) {
-        mp_raise_msg(&mp_type_OSError, "I2C operation not supported");
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("I2C operation not supported"));
     }
     int ret = i2c_p->stop(self);
     if (ret != 0) {
@@ -360,10 +392,10 @@ STATIC mp_obj_t machine_i2c_stop(mp_obj_t self_in) {
 MP_DEFINE_CONST_FUN_OBJ_1(machine_i2c_stop_obj, machine_i2c_stop);
 
 STATIC mp_obj_t machine_i2c_readinto(size_t n_args, const mp_obj_t *args) {
-    mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(args[0]);
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol;
+    mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(args[0]);
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
     if (i2c_p->read == NULL) {
-        mp_raise_msg(&mp_type_OSError, "I2C operation not supported");
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("I2C operation not supported"));
     }
 
     // get the buffer to read into
@@ -384,10 +416,10 @@ STATIC mp_obj_t machine_i2c_readinto(size_t n_args, const mp_obj_t *args) {
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_i2c_readinto_obj, 2, 3, machine_i2c_readinto);
 
 STATIC mp_obj_t machine_i2c_write(mp_obj_t self_in, mp_obj_t buf_in) {
-    mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(self_in);
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol;
+    mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(self_in);
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
     if (i2c_p->write == NULL) {
-        mp_raise_msg(&mp_type_OSError, "I2C operation not supported");
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("I2C operation not supported"));
     }
 
     // get the buffer to write from
@@ -406,13 +438,12 @@ STATIC mp_obj_t machine_i2c_write(mp_obj_t self_in, mp_obj_t buf_in) {
 MP_DEFINE_CONST_FUN_OBJ_2(machine_i2c_write_obj, machine_i2c_write);
 
 STATIC mp_obj_t machine_i2c_readfrom(size_t n_args, const mp_obj_t *args) {
-    mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(args[0]);
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol;
+    mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(args[0]);
     mp_int_t addr = mp_obj_get_int(args[1]);
     vstr_t vstr;
     vstr_init_len(&vstr, mp_obj_get_int(args[2]));
     bool stop = (n_args == 3) ? true : mp_obj_is_true(args[3]);
-    int ret = i2c_p->readfrom(self, addr, (uint8_t*)vstr.buf, vstr.len, stop);
+    int ret = mp_machine_i2c_readfrom(self, addr, (uint8_t *)vstr.buf, vstr.len, stop);
     if (ret < 0) {
         mp_raise_OSError(-ret);
     }
@@ -421,13 +452,12 @@ STATIC mp_obj_t machine_i2c_readfrom(size_t n_args, const mp_obj_t *args) {
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_i2c_readfrom_obj, 3, 4, machine_i2c_readfrom);
 
 STATIC mp_obj_t machine_i2c_readfrom_into(size_t n_args, const mp_obj_t *args) {
-    mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(args[0]);
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol;
+    mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(args[0]);
     mp_int_t addr = mp_obj_get_int(args[1]);
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_WRITE);
     bool stop = (n_args == 3) ? true : mp_obj_is_true(args[3]);
-    int ret = i2c_p->readfrom(self, addr, bufinfo.buf, bufinfo.len, stop);
+    int ret = mp_machine_i2c_readfrom(self, addr, bufinfo.buf, bufinfo.len, stop);
     if (ret < 0) {
         mp_raise_OSError(-ret);
     }
@@ -436,13 +466,12 @@ STATIC mp_obj_t machine_i2c_readfrom_into(size_t n_args, const mp_obj_t *args) {
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_i2c_readfrom_into_obj, 3, 4, machine_i2c_readfrom_into);
 
 STATIC mp_obj_t machine_i2c_writeto(size_t n_args, const mp_obj_t *args) {
-    mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(args[0]);
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol;
+    mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(args[0]);
     mp_int_t addr = mp_obj_get_int(args[1]);
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_READ);
     bool stop = (n_args == 3) ? true : mp_obj_is_true(args[3]);
-    int ret = i2c_p->writeto(self, addr,  bufinfo.buf, bufinfo.len, stop);
+    int ret = mp_machine_i2c_writeto(self, addr, bufinfo.buf, bufinfo.len, stop);
     if (ret < 0) {
         mp_raise_OSError(-ret);
     }
@@ -451,53 +480,87 @@ STATIC mp_obj_t machine_i2c_writeto(size_t n_args, const mp_obj_t *args) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_i2c_writeto_obj, 3, 4, machine_i2c_writeto);
 
+STATIC mp_obj_t machine_i2c_writevto(size_t n_args, const mp_obj_t *args) {
+    mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(args[0]);
+    mp_int_t addr = mp_obj_get_int(args[1]);
+
+    // Get the list of data buffer(s) to write
+    size_t nitems;
+    const mp_obj_t *items;
+    mp_obj_get_array(args[2], &nitems, (mp_obj_t **)&items);
+
+    // Get the stop argument
+    bool stop = (n_args == 3) ? true : mp_obj_is_true(args[3]);
+
+    // Extract all buffer data, skipping zero-length buffers
+    size_t alloc = nitems == 0 ? 1 : nitems;
+    size_t nbufs = 0;
+    mp_machine_i2c_buf_t *bufs = mp_local_alloc(alloc * sizeof(mp_machine_i2c_buf_t));
+    for (; nitems--; ++items) {
+        mp_buffer_info_t bufinfo;
+        mp_get_buffer_raise(*items, &bufinfo, MP_BUFFER_READ);
+        if (bufinfo.len > 0) {
+            bufs[nbufs].len = bufinfo.len;
+            bufs[nbufs++].buf = bufinfo.buf;
+        }
+    }
+
+    // Make sure there is at least one buffer, empty if needed
+    if (nbufs == 0) {
+        bufs[0].len = 0;
+        bufs[0].buf = NULL;
+        nbufs = 1;
+    }
+
+    // Do the I2C transfer
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
+    int ret = i2c_p->transfer(self, addr, nbufs, bufs, stop ? MP_MACHINE_I2C_FLAG_STOP : 0);
+    mp_local_free(bufs);
+
+    if (ret < 0) {
+        mp_raise_OSError(-ret);
+    }
+
+    // Return number of acks received
+    return MP_OBJ_NEW_SMALL_INT(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_i2c_writevto_obj, 3, 4, machine_i2c_writevto);
+
 STATIC int read_mem(mp_obj_t self_in, uint16_t addr, uint32_t memaddr, uint8_t addrsize, uint8_t *buf, size_t len) {
-    mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(self_in);
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol;
+    mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(self_in);
     uint8_t memaddr_buf[4];
     size_t memaddr_len = 0;
     for (int16_t i = addrsize - 8; i >= 0; i -= 8) {
         memaddr_buf[memaddr_len++] = memaddr >> i;
     }
-    int ret = i2c_p->writeto(self, addr, memaddr_buf, memaddr_len, false);
+    int ret = mp_machine_i2c_writeto(self, addr, memaddr_buf, memaddr_len, false);
     if (ret != memaddr_len) {
         // must generate STOP
-        i2c_p->writeto(self, addr, NULL, 0, true);
+        mp_machine_i2c_writeto(self, addr, NULL, 0, true);
         return ret;
     }
-    return i2c_p->readfrom(self, addr, buf, len, true);
+    return mp_machine_i2c_readfrom(self, addr, buf, len, true);
 }
 
-#define MAX_MEMADDR_SIZE (4)
-#define BUF_STACK_SIZE (12)
-
 STATIC int write_mem(mp_obj_t self_in, uint16_t addr, uint32_t memaddr, uint8_t addrsize, const uint8_t *buf, size_t len) {
-    mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(self_in);
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol;
-
-    // need some memory to create the buffer to send; try to use stack if possible
-    uint8_t buf2_stack[MAX_MEMADDR_SIZE + BUF_STACK_SIZE];
-    uint8_t *buf2;
-    size_t buf2_alloc = 0;
-    if (len <= BUF_STACK_SIZE) {
-        buf2 = buf2_stack;
-    } else {
-        buf2_alloc = MAX_MEMADDR_SIZE + len;
-        buf2 = m_new(uint8_t, buf2_alloc);
-    }
+    mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(self_in);
 
-    // create the buffer to send
+    // Create buffer with memory address
     size_t memaddr_len = 0;
+    uint8_t memaddr_buf[4];
     for (int16_t i = addrsize - 8; i >= 0; i -= 8) {
-        buf2[memaddr_len++] = memaddr >> i;
+        memaddr_buf[memaddr_len++] = memaddr >> i;
     }
-    memcpy(buf2 + memaddr_len, buf, len);
 
-    int ret = i2c_p->writeto(self, addr, buf2, memaddr_len + len, true);
-    if (buf2_alloc != 0) {
-        m_del(uint8_t, buf2, buf2_alloc);
-    }
-    return ret;
+    // Create partial write buffers
+    mp_machine_i2c_buf_t bufs[2] = {
+        {.len = memaddr_len, .buf = memaddr_buf},
+        {.len = len, .buf = (uint8_t *)buf},
+    };
+
+    // Do I2C transfer
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
+    return i2c_p->transfer(self, addr, 2, bufs, MP_MACHINE_I2C_FLAG_STOP);
 }
 
 STATIC const mp_arg_t machine_i2c_mem_allowed_args[] = {
@@ -519,7 +582,7 @@ STATIC mp_obj_t machine_i2c_readfrom_mem(size_t n_args, const mp_obj_t *pos_args
 
     // do the transfer
     int ret = read_mem(pos_args[0], args[ARG_addr].u_int, args[ARG_memaddr].u_int,
-        args[ARG_addrsize].u_int, (uint8_t*)vstr.buf, vstr.len);
+        args[ARG_addrsize].u_int, (uint8_t *)vstr.buf, vstr.len);
     if (ret < 0) {
         mp_raise_OSError(-ret);
     }
@@ -584,6 +647,7 @@ STATIC const mp_rom_map_elem_t machine_i2c_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_readfrom), MP_ROM_PTR(&machine_i2c_readfrom_obj) },
     { MP_ROM_QSTR(MP_QSTR_readfrom_into), MP_ROM_PTR(&machine_i2c_readfrom_into_obj) },
     { MP_ROM_QSTR(MP_QSTR_writeto), MP_ROM_PTR(&machine_i2c_writeto_obj) },
+    { MP_ROM_QSTR(MP_QSTR_writevto), MP_ROM_PTR(&machine_i2c_writevto_obj) },
 
     // memory operations
     { MP_ROM_QSTR(MP_QSTR_readfrom_mem), MP_ROM_PTR(&machine_i2c_readfrom_mem_obj) },
@@ -594,7 +658,7 @@ STATIC const mp_rom_map_elem_t machine_i2c_locals_dict_table[] = {
 MP_DEFINE_CONST_DICT(mp_machine_soft_i2c_locals_dict, machine_i2c_locals_dict_table);
 
 int mp_machine_soft_i2c_read(mp_obj_base_t *self_in, uint8_t *dest, size_t len, bool nack) {
-    machine_i2c_obj_t *self = (machine_i2c_obj_t*)self_in;
+    machine_i2c_obj_t *self = (machine_i2c_obj_t *)self_in;
     while (len--) {
         int ret = mp_hal_i2c_read_byte(self, dest++, nack && (len == 0));
         if (ret != 0) {
@@ -605,7 +669,7 @@ int mp_machine_soft_i2c_read(mp_obj_base_t *self_in, uint8_t *dest, size_t len,
 }
 
 int mp_machine_soft_i2c_write(mp_obj_base_t *self_in, const uint8_t *src, size_t len) {
-    machine_i2c_obj_t *self = (machine_i2c_obj_t*)self_in;
+    machine_i2c_obj_t *self = (machine_i2c_obj_t *)self_in;
     int num_acks = 0;
     while (len--) {
         int ret = mp_hal_i2c_write_byte(self, *src++);
@@ -621,12 +685,11 @@ int mp_machine_soft_i2c_write(mp_obj_base_t *self_in, const uint8_t *src, size_t
 }
 
 STATIC const mp_machine_i2c_p_t mp_machine_soft_i2c_p = {
-    .start = (int(*)(mp_obj_base_t*))mp_hal_i2c_start,
-    .stop = (int(*)(mp_obj_base_t*))mp_hal_i2c_stop,
+    .start = (int (*)(mp_obj_base_t *))mp_hal_i2c_start,
+    .stop = (int (*)(mp_obj_base_t *))mp_hal_i2c_stop,
     .read = mp_machine_soft_i2c_read,
     .write = mp_machine_soft_i2c_write,
-    .readfrom = mp_machine_soft_i2c_readfrom,
-    .writeto = mp_machine_soft_i2c_writeto,
+    .transfer = mp_machine_soft_i2c_transfer,
 };
 
 const mp_obj_type_t machine_i2c_type = {
@@ -634,7 +697,7 @@ const mp_obj_type_t machine_i2c_type = {
     .name = MP_QSTR_I2C,
     .make_new = machine_i2c_make_new,
     .protocol = &mp_machine_soft_i2c_p,
-    .locals_dict = (mp_obj_dict_t*)&mp_machine_soft_i2c_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&mp_machine_soft_i2c_locals_dict,
 };
 
 #endif // MICROPY_PY_MACHINE_I2C
diff --git a/extmod/machine_i2c.h b/extmod/machine_i2c.h
index f5af6656f574d..f951c1f214973 100644
--- a/extmod/machine_i2c.h
+++ b/extmod/machine_i2c.h
@@ -28,15 +28,24 @@
 
 #include "py/obj.h"
 
+#define MP_MACHINE_I2C_FLAG_READ (0x01) // if not set then it's a write
+#define MP_MACHINE_I2C_FLAG_STOP (0x02)
+
+typedef struct _mp_machine_i2c_buf_t {
+    size_t len;
+    uint8_t *buf;
+} mp_machine_i2c_buf_t;
+
 // I2C protocol
 // the first 4 methods can be NULL, meaning operation is not supported
+// transfer_single only needs to be set if transfer=mp_machine_i2c_transfer_adaptor
 typedef struct _mp_machine_i2c_p_t {
     int (*start)(mp_obj_base_t *obj);
     int (*stop)(mp_obj_base_t *obj);
     int (*read)(mp_obj_base_t *obj, uint8_t *dest, size_t len, bool nack);
     int (*write)(mp_obj_base_t *obj, const uint8_t *src, size_t len);
-    int (*readfrom)(mp_obj_base_t *obj, uint16_t addr, uint8_t *dest, size_t len, bool stop);
-    int (*writeto)(mp_obj_base_t *obj, uint16_t addr, const uint8_t *src, size_t len, bool stop);
+    int (*transfer)(mp_obj_base_t *obj, uint16_t addr, size_t n, mp_machine_i2c_buf_t *bufs, unsigned int flags);
+    int (*transfer_single)(mp_obj_base_t *obj, uint16_t addr, size_t len, uint8_t *buf, unsigned int flags);
 } mp_machine_i2c_p_t;
 
 typedef struct _mp_machine_soft_i2c_obj_t {
@@ -50,7 +59,7 @@ typedef struct _mp_machine_soft_i2c_obj_t {
 extern const mp_obj_type_t machine_i2c_type;
 extern const mp_obj_dict_t mp_machine_soft_i2c_locals_dict;
 
-int mp_machine_soft_i2c_readfrom(mp_obj_base_t *self_in, uint16_t addr, uint8_t *dest, size_t len, bool stop);
-int mp_machine_soft_i2c_writeto(mp_obj_base_t *self_in, uint16_t addr, const uint8_t *src, size_t len, bool stop);
+int mp_machine_i2c_transfer_adaptor(mp_obj_base_t *self, uint16_t addr, size_t n, mp_machine_i2c_buf_t *bufs, unsigned int flags);
+int mp_machine_soft_i2c_transfer(mp_obj_base_t *self, uint16_t addr, size_t n, mp_machine_i2c_buf_t *bufs, unsigned int flags);
 
 #endif // MICROPY_INCLUDED_EXTMOD_MACHINE_I2C_H
diff --git a/extmod/machine_mem.c b/extmod/machine_mem.c
index b9f16507c4b76..a1494bd51ad17 100644
--- a/extmod/machine_mem.c
+++ b/extmod/machine_mem.c
@@ -42,7 +42,7 @@
 STATIC uintptr_t machine_mem_get_addr(mp_obj_t addr_o, uint align) {
     uintptr_t addr = mp_obj_int_get_truncated(addr_o);
     if ((addr & (align - 1)) != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "address %08x is not aligned to %d bytes", addr, align));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("address %08x is not aligned to %d bytes"), addr, align);
     }
     return addr;
 }
@@ -71,9 +71,15 @@ STATIC mp_obj_t machine_mem_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t va
         uintptr_t addr = MICROPY_MACHINE_MEM_GET_READ_ADDR(index, self->elem_size);
         uint32_t val;
         switch (self->elem_size) {
-            case 1: val = (*(uint8_t*)addr); break;
-            case 2: val = (*(uint16_t*)addr); break;
-            default: val = (*(uint32_t*)addr); break;
+            case 1:
+                val = (*(uint8_t *)addr);
+                break;
+            case 2:
+                val = (*(uint16_t *)addr);
+                break;
+            default:
+                val = (*(uint32_t *)addr);
+                break;
         }
         return mp_obj_new_int(val);
     } else {
@@ -81,9 +87,15 @@ STATIC mp_obj_t machine_mem_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t va
         uintptr_t addr = MICROPY_MACHINE_MEM_GET_WRITE_ADDR(index, self->elem_size);
         uint32_t val = mp_obj_get_int_truncated(value);
         switch (self->elem_size) {
-            case 1: (*(uint8_t*)addr) = val; break;
-            case 2: (*(uint16_t*)addr) = val; break;
-            default: (*(uint32_t*)addr) = val; break;
+            case 1:
+                (*(uint8_t *)addr) = val;
+                break;
+            case 2:
+                (*(uint16_t *)addr) = val;
+                break;
+            default:
+                (*(uint32_t *)addr) = val;
+                break;
         }
         return mp_const_none;
     }
diff --git a/extmod/machine_pulse.c b/extmod/machine_pulse.c
index 5f837479dd61c..7178b22d791ec 100644
--- a/extmod/machine_pulse.c
+++ b/extmod/machine_pulse.c
@@ -30,7 +30,7 @@
 
 #if MICROPY_PY_MACHINE_PULSE
 
-mp_uint_t machine_time_pulse_us(mp_hal_pin_obj_t pin, int pulse_level, mp_uint_t timeout_us) {
+MP_WEAK mp_uint_t machine_time_pulse_us(mp_hal_pin_obj_t pin, int pulse_level, mp_uint_t timeout_us) {
     mp_uint_t start = mp_hal_ticks_us();
     while (mp_hal_pin_read(pin) != pulse_level) {
         if ((mp_uint_t)(mp_hal_ticks_us() - start) >= timeout_us) {
diff --git a/extmod/machine_signal.c b/extmod/machine_signal.c
index c494490b60150..f112ddc57c827 100644
--- a/extmod/machine_signal.c
+++ b/extmod/machine_signal.c
@@ -43,15 +43,15 @@ typedef struct _machine_signal_t {
 } machine_signal_t;
 
 STATIC mp_obj_t signal_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
-    mp_obj_t pin = args[0];
+    mp_obj_t pin;
     bool invert = false;
 
     #if defined(MICROPY_PY_MACHINE_PIN_MAKE_NEW)
     mp_pin_p_t *pin_p = NULL;
 
-    if (mp_obj_is_obj(pin)) {
-        mp_obj_base_t *pin_base = (mp_obj_base_t*)MP_OBJ_TO_PTR(args[0]);
-        pin_p = (mp_pin_p_t*)pin_base->type->protocol;
+    if (n_args > 0 && mp_obj_is_obj(args[0])) {
+        mp_obj_base_t *pin_base = (mp_obj_base_t *)MP_OBJ_TO_PTR(args[0]);
+        pin_p = (mp_pin_p_t *)pin_base->type->protocol;
     }
 
     if (pin_p == NULL) {
@@ -90,12 +90,12 @@ STATIC mp_obj_t signal_make_new(const mp_obj_type_t *type, size_t n_args, size_t
         pin = MICROPY_PY_MACHINE_PIN_MAKE_NEW(NULL, n_args, n_kw, pin_args);
 
         mp_local_free(pin_args);
-    }
-    else
+    } else
     #endif
     // Otherwise there should be 1 or 2 args
     {
         if (n_args == 1) {
+            pin = args[0];
             if (n_kw == 0) {
             } else if (n_kw == 1 && args[1] == MP_OBJ_NEW_QSTR(MP_QSTR_invert)) {
                 invert = mp_obj_is_true(args[2]);
@@ -179,7 +179,7 @@ const mp_obj_type_t machine_signal_type = {
     .make_new = signal_make_new,
     .call = signal_call,
     .protocol = &signal_pin_p,
-    .locals_dict = (void*)&signal_locals_dict,
+    .locals_dict = (void *)&signal_locals_dict,
 };
 
 #endif // MICROPY_PY_MACHINE
diff --git a/extmod/machine_spi.c b/extmod/machine_spi.c
index f0c4896c2e573..a7f96573a720e 100644
--- a/extmod/machine_spi.c
+++ b/extmod/machine_spi.c
@@ -52,7 +52,7 @@ mp_obj_t mp_machine_spi_make_new(const mp_obj_type_t *type, size_t n_args, size_
             extern mp_obj_t MICROPY_PY_MACHINE_SPI_MAKE_NEW(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args);
             return MICROPY_PY_MACHINE_SPI_MAKE_NEW(type, n_args, n_kw, args);
             #else
-            mp_raise_ValueError("invalid SPI peripheral");
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid SPI peripheral"));
             #endif
         }
         --n_args;
@@ -64,16 +64,16 @@ mp_obj_t mp_machine_spi_make_new(const mp_obj_type_t *type, size_t n_args, size_
 }
 
 STATIC mp_obj_t machine_spi_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
-    mp_obj_base_t *s = (mp_obj_base_t*)MP_OBJ_TO_PTR(args[0]);
-    mp_machine_spi_p_t *spi_p = (mp_machine_spi_p_t*)s->type->protocol;
+    mp_obj_base_t *s = (mp_obj_base_t *)MP_OBJ_TO_PTR(args[0]);
+    mp_machine_spi_p_t *spi_p = (mp_machine_spi_p_t *)s->type->protocol;
     spi_p->init(s, n_args - 1, args + 1, kw_args);
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_spi_init_obj, 1, machine_spi_init);
 
 STATIC mp_obj_t machine_spi_deinit(mp_obj_t self) {
-    mp_obj_base_t *s = (mp_obj_base_t*)MP_OBJ_TO_PTR(self);
-    mp_machine_spi_p_t *spi_p = (mp_machine_spi_p_t*)s->type->protocol;
+    mp_obj_base_t *s = (mp_obj_base_t *)MP_OBJ_TO_PTR(self);
+    mp_machine_spi_p_t *spi_p = (mp_machine_spi_p_t *)s->type->protocol;
     if (spi_p->deinit != NULL) {
         spi_p->deinit(s);
     }
@@ -82,8 +82,8 @@ STATIC mp_obj_t machine_spi_deinit(mp_obj_t self) {
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_spi_deinit_obj, machine_spi_deinit);
 
 STATIC void mp_machine_spi_transfer(mp_obj_t self, size_t len, const void *src, void *dest) {
-    mp_obj_base_t *s = (mp_obj_base_t*)MP_OBJ_TO_PTR(self);
-    mp_machine_spi_p_t *spi_p = (mp_machine_spi_p_t*)s->type->protocol;
+    mp_obj_base_t *s = (mp_obj_base_t *)MP_OBJ_TO_PTR(self);
+    mp_machine_spi_p_t *spi_p = (mp_machine_spi_p_t *)s->type->protocol;
     spi_p->transfer(s, len, src, dest);
 }
 
@@ -108,7 +108,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_machine_spi_readinto_obj, 2, 3, mp_machin
 STATIC mp_obj_t mp_machine_spi_write(mp_obj_t self, mp_obj_t wr_buf) {
     mp_buffer_info_t src;
     mp_get_buffer_raise(wr_buf, &src, MP_BUFFER_READ);
-    mp_machine_spi_transfer(self, src.len, (const uint8_t*)src.buf, NULL);
+    mp_machine_spi_transfer(self, src.len, (const uint8_t *)src.buf, NULL);
     return mp_const_none;
 }
 MP_DEFINE_CONST_FUN_OBJ_2(mp_machine_spi_write_obj, mp_machine_spi_write);
@@ -119,7 +119,7 @@ STATIC mp_obj_t mp_machine_spi_write_readinto(mp_obj_t self, mp_obj_t wr_buf, mp
     mp_buffer_info_t dest;
     mp_get_buffer_raise(rd_buf, &dest, MP_BUFFER_WRITE);
     if (src.len != dest.len) {
-        mp_raise_ValueError("buffers must be the same length");
+        mp_raise_ValueError(MP_ERROR_TEXT("buffers must be the same length"));
     }
     mp_machine_spi_transfer(self, src.len, src.buf, dest.buf);
     return mp_const_none;
@@ -202,15 +202,15 @@ STATIC mp_obj_t mp_machine_soft_spi_make_new(const mp_obj_type_t *type, size_t n
     self->spi.polarity = args[ARG_polarity].u_int;
     self->spi.phase = args[ARG_phase].u_int;
     if (args[ARG_bits].u_int != 8) {
-        mp_raise_ValueError("bits must be 8");
+        mp_raise_ValueError(MP_ERROR_TEXT("bits must be 8"));
     }
     if (args[ARG_firstbit].u_int != MICROPY_PY_MACHINE_SPI_MSB) {
-        mp_raise_ValueError("firstbit must be MSB");
+        mp_raise_ValueError(MP_ERROR_TEXT("firstbit must be MSB"));
     }
     if (args[ARG_sck].u_obj == MP_OBJ_NULL
         || args[ARG_mosi].u_obj == MP_OBJ_NULL
         || args[ARG_miso].u_obj == MP_OBJ_NULL) {
-        mp_raise_ValueError("must specify all of sck/mosi/miso");
+        mp_raise_ValueError(MP_ERROR_TEXT("must specify all of sck/mosi/miso"));
     }
     self->spi.sck = mp_hal_get_pin_obj(args[ARG_sck].u_obj);
     self->spi.mosi = mp_hal_get_pin_obj(args[ARG_mosi].u_obj);
@@ -223,7 +223,7 @@ STATIC mp_obj_t mp_machine_soft_spi_make_new(const mp_obj_type_t *type, size_t n
 }
 
 STATIC void mp_machine_soft_spi_init(mp_obj_base_t *self_in, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    mp_machine_soft_spi_obj_t *self = (mp_machine_soft_spi_obj_t*)self_in;
+    mp_machine_soft_spi_obj_t *self = (mp_machine_soft_spi_obj_t *)self_in;
 
     enum { ARG_baudrate, ARG_polarity, ARG_phase, ARG_sck, ARG_mosi, ARG_miso };
     static const mp_arg_t allowed_args[] = {
@@ -261,7 +261,7 @@ STATIC void mp_machine_soft_spi_init(mp_obj_base_t *self_in, size_t n_args, cons
 }
 
 STATIC void mp_machine_soft_spi_transfer(mp_obj_base_t *self_in, size_t len, const uint8_t *src, uint8_t *dest) {
-    mp_machine_soft_spi_obj_t *self = (mp_machine_soft_spi_obj_t*)self_in;
+    mp_machine_soft_spi_obj_t *self = (mp_machine_soft_spi_obj_t *)self_in;
     mp_soft_spi_transfer(&self->spi, len, src, dest);
 }
 
@@ -277,7 +277,7 @@ const mp_obj_type_t mp_machine_soft_spi_type = {
     .print = mp_machine_soft_spi_print,
     .make_new = mp_machine_spi_make_new, // delegate to master constructor
     .protocol = &mp_machine_soft_spi_p,
-    .locals_dict = (mp_obj_dict_t*)&mp_machine_spi_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&mp_machine_spi_locals_dict,
 };
 
 #endif // MICROPY_PY_MACHINE_SPI
diff --git a/extmod/misc.h b/extmod/misc.h
index dae6bec4a10fc..40b091e5f73d5 100644
--- a/extmod/misc.h
+++ b/extmod/misc.h
@@ -36,6 +36,7 @@ MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_uos_dupterm_obj);
 
 #if MICROPY_PY_OS_DUPTERM
 bool mp_uos_dupterm_is_builtin_stream(mp_const_obj_t stream);
+uintptr_t mp_uos_dupterm_poll(uintptr_t poll_flags);
 int mp_uos_dupterm_rx_chr(void);
 void mp_uos_dupterm_tx_strn(const char *str, size_t len);
 void mp_uos_deactivate(size_t dupterm_idx, const char *msg, mp_obj_t exc);
diff --git a/extmod/modbluetooth.c b/extmod/modbluetooth.c
new file mode 100644
index 0000000000000..7e6abb54909ca
--- /dev/null
+++ b/extmod/modbluetooth.c
@@ -0,0 +1,1173 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Ayke van Laethem
+ * Copyright (c) 2019 Jim Mussared
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/binary.h"
+#include "py/misc.h"
+#include "py/mperrno.h"
+#include "py/obj.h"
+#include "py/objstr.h"
+#include "py/objarray.h"
+#include "py/qstr.h"
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "extmod/modbluetooth.h"
+#include <string.h>
+
+#if MICROPY_PY_BLUETOOTH
+
+#if !MICROPY_ENABLE_SCHEDULER
+#error modbluetooth requires MICROPY_ENABLE_SCHEDULER
+#endif
+
+#define MP_BLUETOOTH_CONNECT_DEFAULT_SCAN_DURATION_MS 2000
+
+#define MICROPY_PY_BLUETOOTH_MAX_EVENT_DATA_TUPLE_LEN 5
+
+// This formula is intended to allow queuing the data of a large characteristic
+// while still leaving room for a couple of normal (small, fixed size) events.
+#define MICROPY_PY_BLUETOOTH_MAX_EVENT_DATA_BYTES_LEN(ringbuf_size) (MAX((int)((ringbuf_size) / 2), (int)(ringbuf_size) - 64))
+
+STATIC const mp_obj_type_t bluetooth_ble_type;
+STATIC const mp_obj_type_t bluetooth_uuid_type;
+
+typedef struct {
+    mp_obj_base_t base;
+    mp_obj_t irq_handler;
+    uint16_t irq_trigger;
+    bool irq_scheduled;
+    mp_obj_t irq_data_tuple;
+    uint8_t irq_data_addr_bytes[6];
+    uint16_t irq_data_data_alloc;
+    uint8_t *irq_data_data_bytes;
+    mp_obj_str_t irq_data_addr;
+    mp_obj_str_t irq_data_data;
+    mp_obj_bluetooth_uuid_t irq_data_uuid;
+    ringbuf_t ringbuf;
+} mp_obj_bluetooth_ble_t;
+
+// TODO: this seems like it could be generic?
+STATIC mp_obj_t bluetooth_handle_errno(int err) {
+    if (err != 0) {
+        mp_raise_OSError(err);
+    }
+    return mp_const_none;
+}
+
+// ----------------------------------------------------------------------------
+// UUID object
+// ----------------------------------------------------------------------------
+
+STATIC mp_obj_t bluetooth_uuid_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    (void)type;
+
+    mp_arg_check_num(n_args, n_kw, 1, 1, false);
+
+    mp_obj_bluetooth_uuid_t *self = m_new_obj(mp_obj_bluetooth_uuid_t);
+    self->base.type = &bluetooth_uuid_type;
+
+    if (mp_obj_is_int(all_args[0])) {
+        self->type = MP_BLUETOOTH_UUID_TYPE_16;
+        mp_int_t value = mp_obj_get_int(all_args[0]);
+        if (value > 65535) {
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid UUID"));
+        }
+        self->data[0] = value & 0xff;
+        self->data[1] = (value >> 8) & 0xff;
+    } else {
+        mp_buffer_info_t uuid_bufinfo = {0};
+        mp_get_buffer_raise(all_args[0], &uuid_bufinfo, MP_BUFFER_READ);
+        if (uuid_bufinfo.len == 2 || uuid_bufinfo.len == 4 || uuid_bufinfo.len == 16) {
+            // Bytes data -- infer UUID type from length and copy data.
+            self->type = uuid_bufinfo.len;
+            memcpy(self->data, uuid_bufinfo.buf, self->type);
+        } else {
+            // Assume UUID string (e.g. '6E400001-B5A3-F393-E0A9-E50E24DCCA9E')
+            self->type = MP_BLUETOOTH_UUID_TYPE_128;
+            int uuid_i = 32;
+            for (size_t i = 0; i < uuid_bufinfo.len; i++) {
+                char c = ((char *)uuid_bufinfo.buf)[i];
+                if (c == '-') {
+                    continue;
+                }
+                if (!unichar_isxdigit(c)) {
+                    mp_raise_ValueError(MP_ERROR_TEXT("invalid char in UUID"));
+                }
+                c = unichar_xdigit_value(c);
+                uuid_i--;
+                if (uuid_i < 0) {
+                    mp_raise_ValueError(MP_ERROR_TEXT("UUID too long"));
+                }
+                if (uuid_i % 2 == 0) {
+                    // lower nibble
+                    self->data[uuid_i / 2] |= c;
+                } else {
+                    // upper nibble
+                    self->data[uuid_i / 2] = c << 4;
+                }
+            }
+            if (uuid_i > 0) {
+                mp_raise_ValueError(MP_ERROR_TEXT("UUID too short"));
+            }
+        }
+    }
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC mp_obj_t bluetooth_uuid_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
+    mp_obj_bluetooth_uuid_t *self = MP_OBJ_TO_PTR(self_in);
+    switch (op) {
+        case MP_UNARY_OP_HASH: {
+            // Use the QSTR hash function.
+            return MP_OBJ_NEW_SMALL_INT(qstr_compute_hash(self->data, self->type));
+        }
+        default:
+            return MP_OBJ_NULL;      // op not supported
+    }
+}
+
+STATIC mp_obj_t bluetooth_uuid_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
+    if (!mp_obj_is_type(rhs_in, &bluetooth_uuid_type)) {
+        return MP_OBJ_NULL;
+    }
+
+    mp_obj_bluetooth_uuid_t *lhs = MP_OBJ_TO_PTR(lhs_in);
+    mp_obj_bluetooth_uuid_t *rhs = MP_OBJ_TO_PTR(rhs_in);
+    switch (op) {
+        case MP_BINARY_OP_EQUAL:
+        case MP_BINARY_OP_LESS:
+        case MP_BINARY_OP_LESS_EQUAL:
+        case MP_BINARY_OP_MORE:
+        case MP_BINARY_OP_MORE_EQUAL:
+            if (lhs->type == rhs->type) {
+                return mp_obj_new_bool(mp_seq_cmp_bytes(op, lhs->data, lhs->type, rhs->data, rhs->type));
+            } else {
+                return mp_binary_op(op, MP_OBJ_NEW_SMALL_INT(lhs->type), MP_OBJ_NEW_SMALL_INT(rhs->type));
+            }
+
+        default:
+            return MP_OBJ_NULL; // op not supported
+    }
+}
+
+STATIC void bluetooth_uuid_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    (void)kind;
+
+    mp_obj_bluetooth_uuid_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_printf(print, "UUID%u(%s", self->type * 8, self->type <= 4 ? "0x" : "'");
+    for (int i = 0; i < self->type; ++i) {
+        if (i == 4 || i == 6 || i == 8 || i == 10) {
+            mp_printf(print, "-");
+        }
+        mp_printf(print, "%02x", self->data[self->type - 1 - i]);
+    }
+    if (self->type == MP_BLUETOOTH_UUID_TYPE_128) {
+        mp_printf(print, "'");
+    }
+    mp_printf(print, ")");
+}
+
+STATIC mp_int_t bluetooth_uuid_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags) {
+    mp_obj_bluetooth_uuid_t *self = MP_OBJ_TO_PTR(self_in);
+
+    if (flags != MP_BUFFER_READ) {
+        return 1;
+    }
+
+    bufinfo->buf = self->data;
+    bufinfo->len = self->type;
+    bufinfo->typecode = 'B';
+    return 0;
+}
+
+#if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+
+STATIC void ringbuf_put_uuid(ringbuf_t *ringbuf, mp_obj_bluetooth_uuid_t *uuid) {
+    assert(ringbuf_free(ringbuf) >= (size_t)uuid->type + 1);
+    ringbuf_put(ringbuf, uuid->type);
+    for (int i = 0; i < uuid->type; ++i) {
+        ringbuf_put(ringbuf, uuid->data[i]);
+    }
+}
+
+STATIC void ringbuf_get_uuid(ringbuf_t *ringbuf, mp_obj_bluetooth_uuid_t *uuid) {
+    assert(ringbuf_avail(ringbuf) >= 1);
+    uuid->type = ringbuf_get(ringbuf);
+    assert(ringbuf_avail(ringbuf) >= uuid->type);
+    for (int i = 0; i < uuid->type; ++i) {
+        uuid->data[i] = ringbuf_get(ringbuf);
+    }
+}
+#endif // MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+
+STATIC const mp_obj_type_t bluetooth_uuid_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_UUID,
+    .make_new = bluetooth_uuid_make_new,
+    .unary_op = bluetooth_uuid_unary_op,
+    .binary_op = bluetooth_uuid_binary_op,
+    .locals_dict = NULL,
+    .print = bluetooth_uuid_print,
+    .buffer_p = { .get_buffer = bluetooth_uuid_get_buffer },
+};
+
+// ----------------------------------------------------------------------------
+// Bluetooth object: General
+// ----------------------------------------------------------------------------
+
+STATIC mp_obj_t bluetooth_ble_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    (void)type;
+    (void)n_args;
+    (void)n_kw;
+    (void)all_args;
+    if (MP_STATE_VM(bluetooth) == MP_OBJ_NULL) {
+        mp_obj_bluetooth_ble_t *o = m_new0(mp_obj_bluetooth_ble_t, 1);
+        o->base.type = &bluetooth_ble_type;
+
+        o->irq_handler = mp_const_none;
+        o->irq_trigger = 0;
+
+        // Pre-allocate the event data tuple to prevent needing to allocate in the IRQ handler.
+        o->irq_data_tuple = mp_obj_new_tuple(MICROPY_PY_BLUETOOTH_MAX_EVENT_DATA_TUPLE_LEN, NULL);
+
+        // Pre-allocated buffers for address, payload and uuid.
+        o->irq_data_addr.base.type = &mp_type_bytes;
+        o->irq_data_addr.data = o->irq_data_addr_bytes;
+        o->irq_data_data_alloc = MICROPY_PY_BLUETOOTH_MAX_EVENT_DATA_BYTES_LEN(MICROPY_PY_BLUETOOTH_RINGBUF_SIZE);
+        o->irq_data_data.base.type = &mp_type_bytes;
+        o->irq_data_data.data = m_new(uint8_t, o->irq_data_data_alloc);
+        o->irq_data_uuid.base.type = &bluetooth_uuid_type;
+
+        // Allocate the default ringbuf.
+        ringbuf_alloc(&o->ringbuf, MICROPY_PY_BLUETOOTH_RINGBUF_SIZE);
+
+        MP_STATE_VM(bluetooth) = MP_OBJ_FROM_PTR(o);
+    }
+    return MP_STATE_VM(bluetooth);
+}
+
+STATIC mp_obj_t bluetooth_ble_active(size_t n_args, const mp_obj_t *args) {
+    if (n_args == 2) {
+        // Boolean enable/disable argument supplied, set current state.
+        if (mp_obj_is_true(args[1])) {
+            int err = mp_bluetooth_init();
+            bluetooth_handle_errno(err);
+        } else {
+            mp_bluetooth_deinit();
+        }
+    }
+    // Return current state.
+    return mp_obj_new_bool(mp_bluetooth_is_active());
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bluetooth_ble_active_obj, 1, 2, bluetooth_ble_active);
+
+STATIC mp_obj_t bluetooth_ble_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
+    mp_obj_bluetooth_ble_t *self = MP_OBJ_TO_PTR(args[0]);
+
+    if (kwargs->used == 0) {
+        // Get config value
+        if (n_args != 2) {
+            mp_raise_TypeError(MP_ERROR_TEXT("must query one param"));
+        }
+
+        switch (mp_obj_str_get_qstr(args[1])) {
+            case MP_QSTR_gap_name: {
+                const uint8_t *buf;
+                size_t len = mp_bluetooth_gap_get_device_name(&buf);
+                return mp_obj_new_bytes(buf, len);
+            }
+            case MP_QSTR_mac: {
+                uint8_t addr[6];
+                mp_bluetooth_get_device_addr(addr);
+                return mp_obj_new_bytes(addr, MP_ARRAY_SIZE(addr));
+            }
+            case MP_QSTR_rxbuf:
+                return mp_obj_new_int(self->ringbuf.size);
+            default:
+                mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
+        }
+    } else {
+        // Set config value(s)
+        if (n_args != 1) {
+            mp_raise_TypeError(MP_ERROR_TEXT("can't specify pos and kw args"));
+        }
+
+        for (size_t i = 0; i < kwargs->alloc; ++i) {
+            if (MP_MAP_SLOT_IS_FILLED(kwargs, i)) {
+                mp_map_elem_t *e = &kwargs->table[i];
+                switch (mp_obj_str_get_qstr(e->key)) {
+                    case MP_QSTR_gap_name: {
+                        mp_buffer_info_t bufinfo;
+                        mp_get_buffer_raise(e->value, &bufinfo, MP_BUFFER_READ);
+                        int ret = mp_bluetooth_gap_set_device_name(bufinfo.buf, bufinfo.len);
+                        bluetooth_handle_errno(ret);
+                        break;
+                    }
+                    case MP_QSTR_rxbuf: {
+                        // Determine new buffer sizes
+                        mp_int_t ringbuf_alloc = mp_obj_get_int(e->value);
+                        if (ringbuf_alloc < 16 || ringbuf_alloc > 0xffff) {
+                            mp_raise_ValueError(NULL);
+                        }
+                        size_t irq_data_alloc = MICROPY_PY_BLUETOOTH_MAX_EVENT_DATA_BYTES_LEN(ringbuf_alloc);
+
+                        // Allocate new buffers
+                        uint8_t *ringbuf = m_new(uint8_t, ringbuf_alloc);
+                        uint8_t *irq_data = m_new(uint8_t, irq_data_alloc);
+
+                        // Get old buffer sizes and pointers
+                        uint8_t *old_ringbuf_buf = self->ringbuf.buf;
+                        size_t old_ringbuf_alloc = self->ringbuf.size;
+                        uint8_t *old_irq_data_buf = (uint8_t *)self->irq_data_data.data;
+                        size_t old_irq_data_alloc = self->irq_data_data_alloc;
+
+                        // Atomically update the ringbuf and irq data
+                        MICROPY_PY_BLUETOOTH_ENTER
+                        self->ringbuf.size = ringbuf_alloc;
+                        self->ringbuf.buf = ringbuf;
+                        self->ringbuf.iget = 0;
+                        self->ringbuf.iput = 0;
+                        self->irq_data_data_alloc = irq_data_alloc;
+                        self->irq_data_data.data = irq_data;
+                        MICROPY_PY_BLUETOOTH_EXIT
+
+                        // Free old buffers
+                        m_del(uint8_t, old_ringbuf_buf, old_ringbuf_alloc);
+                        m_del(uint8_t, old_irq_data_buf, old_irq_data_alloc);
+                        break;
+                    }
+                    default:
+                        mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
+                }
+            }
+        }
+
+        return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bluetooth_ble_config_obj, 1, bluetooth_ble_config);
+
+STATIC mp_obj_t bluetooth_ble_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_handler, ARG_trigger };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_handler, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_trigger, MP_ARG_INT, {.u_int = MP_BLUETOOTH_IRQ_ALL} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    mp_obj_t callback = args[ARG_handler].u_obj;
+    if (callback != mp_const_none && !mp_obj_is_callable(callback)) {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid callback"));
+    }
+
+    // Update the callback.
+    MICROPY_PY_BLUETOOTH_ENTER
+    mp_obj_bluetooth_ble_t *o = MP_OBJ_TO_PTR(MP_STATE_VM(bluetooth));
+    o->irq_handler = callback;
+    o->irq_trigger = args[ARG_trigger].u_int;
+    MICROPY_PY_BLUETOOTH_EXIT
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bluetooth_ble_irq_obj, 1, bluetooth_ble_irq);
+
+// ----------------------------------------------------------------------------
+// Bluetooth object: GAP
+// ----------------------------------------------------------------------------
+
+STATIC mp_obj_t bluetooth_ble_gap_advertise(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_interval_us, ARG_adv_data, ARG_resp_data, ARG_connectable };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_interval_us, MP_ARG_OBJ, {.u_obj = MP_OBJ_NEW_SMALL_INT(500000)} },
+        { MP_QSTR_adv_data, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_resp_data, MP_ARG_OBJ | MP_ARG_KW_ONLY, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_connectable, MP_ARG_OBJ | MP_ARG_KW_ONLY, {.u_rom_obj = MP_ROM_TRUE} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    if (args[ARG_interval_us].u_obj == mp_const_none) {
+        mp_bluetooth_gap_advertise_stop();
+        return mp_const_none;
+    }
+
+    mp_int_t interval_us = mp_obj_get_int(args[ARG_interval_us].u_obj);
+    bool connectable = mp_obj_is_true(args[ARG_connectable].u_obj);
+
+    mp_buffer_info_t adv_bufinfo = {0};
+    if (args[ARG_adv_data].u_obj != mp_const_none) {
+        mp_get_buffer_raise(args[ARG_adv_data].u_obj, &adv_bufinfo, MP_BUFFER_READ);
+    }
+
+    mp_buffer_info_t resp_bufinfo = {0};
+    if (args[ARG_resp_data].u_obj != mp_const_none) {
+        mp_get_buffer_raise(args[ARG_resp_data].u_obj, &resp_bufinfo, MP_BUFFER_READ);
+    }
+
+    return bluetooth_handle_errno(mp_bluetooth_gap_advertise_start(connectable, interval_us, adv_bufinfo.buf, adv_bufinfo.len, resp_bufinfo.buf, resp_bufinfo.len));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bluetooth_ble_gap_advertise_obj, 1, bluetooth_ble_gap_advertise);
+
+STATIC int bluetooth_gatts_register_service(mp_obj_t uuid_in, mp_obj_t characteristics_in, uint16_t **handles, size_t *num_handles) {
+    if (!mp_obj_is_type(uuid_in, &bluetooth_uuid_type)) {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid service UUID"));
+    }
+    mp_obj_bluetooth_uuid_t *service_uuid = MP_OBJ_TO_PTR(uuid_in);
+
+    mp_obj_t len_in = mp_obj_len(characteristics_in);
+    size_t len = mp_obj_get_int(len_in);
+    mp_obj_iter_buf_t iter_buf;
+    mp_obj_t iterable = mp_getiter(characteristics_in, &iter_buf);
+    mp_obj_t characteristic_obj;
+
+    // Lists of characteristic uuids and flags.
+    mp_obj_bluetooth_uuid_t **characteristic_uuids = m_new(mp_obj_bluetooth_uuid_t *, len);
+    uint8_t *characteristic_flags = m_new(uint8_t, len);
+
+    // Flattened list of descriptor uuids and flags. Grows (realloc) as more descriptors are encountered.
+    mp_obj_bluetooth_uuid_t **descriptor_uuids = NULL;
+    uint8_t *descriptor_flags = NULL;
+    // How many descriptors in the flattened list per characteristic.
+    uint8_t *num_descriptors = m_new(uint8_t, len);
+
+    // Inititally allocate enough room for the number of characteristics.
+    // Will be grown to accommodate descriptors as necessary.
+    *num_handles = len;
+    *handles = m_new(uint16_t, *num_handles);
+
+    // Extract out characteristic uuids & flags.
+
+    int characteristic_index = 0; // characteristic index.
+    int handle_index = 0; // handle index.
+    int descriptor_index = 0; // descriptor index.
+    while ((characteristic_obj = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
+        // (uuid, flags, (optional descriptors),)
+        size_t characteristic_len;
+        mp_obj_t *characteristic_items;
+        mp_obj_get_array(characteristic_obj, &characteristic_len, &characteristic_items);
+
+        if (characteristic_len < 2 || characteristic_len > 3) {
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid characteristic tuple"));
+        }
+        mp_obj_t uuid_obj = characteristic_items[0];
+        if (!mp_obj_is_type(uuid_obj, &bluetooth_uuid_type)) {
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid characteristic UUID"));
+        }
+
+        (*handles)[handle_index++] = 0xffff;
+
+        // Optional third element, iterable of descriptors.
+        if (characteristic_len >= 3) {
+            mp_obj_t descriptors_len_in = mp_obj_len(characteristic_items[2]);
+            num_descriptors[characteristic_index] = mp_obj_get_int(descriptors_len_in);
+
+            if (num_descriptors[characteristic_index] == 0) {
+                continue;
+            }
+
+            // Grow the flattened uuids and flags arrays with this many more descriptors.
+            descriptor_uuids = m_renew(mp_obj_bluetooth_uuid_t *, descriptor_uuids, descriptor_index, descriptor_index + num_descriptors[characteristic_index]);
+            descriptor_flags = m_renew(uint8_t, descriptor_flags, descriptor_index, descriptor_index + num_descriptors[characteristic_index]);
+
+            // Also grow the handles array.
+            *handles = m_renew(uint16_t, *handles, *num_handles, *num_handles + num_descriptors[characteristic_index]);
+
+            mp_obj_iter_buf_t iter_buf_desc;
+            mp_obj_t iterable_desc = mp_getiter(characteristic_items[2], &iter_buf_desc);
+            mp_obj_t descriptor_obj;
+
+            // Extract out descriptors for this characteristic.
+            while ((descriptor_obj = mp_iternext(iterable_desc)) != MP_OBJ_STOP_ITERATION) {
+                // (uuid, flags,)
+                mp_obj_t *descriptor_items;
+                mp_obj_get_array_fixed_n(descriptor_obj, 2, &descriptor_items);
+                mp_obj_t desc_uuid_obj = descriptor_items[0];
+                if (!mp_obj_is_type(desc_uuid_obj, &bluetooth_uuid_type)) {
+                    mp_raise_ValueError(MP_ERROR_TEXT("invalid descriptor UUID"));
+                }
+
+                descriptor_uuids[descriptor_index] = MP_OBJ_TO_PTR(desc_uuid_obj);
+                descriptor_flags[descriptor_index] = mp_obj_get_int(descriptor_items[1]);
+                ++descriptor_index;
+
+                (*handles)[handle_index++] = 0xffff;
+            }
+
+            // Reflect that we've grown the handles array.
+            *num_handles += num_descriptors[characteristic_index];
+        }
+
+        characteristic_uuids[characteristic_index] = MP_OBJ_TO_PTR(uuid_obj);
+        characteristic_flags[characteristic_index] = mp_obj_get_int(characteristic_items[1]);
+        ++characteristic_index;
+    }
+
+    // Add service.
+    return mp_bluetooth_gatts_register_service(service_uuid, characteristic_uuids, characteristic_flags, descriptor_uuids, descriptor_flags, num_descriptors, *handles, len);
+}
+
+STATIC mp_obj_t bluetooth_ble_gatts_register_services(mp_obj_t self_in, mp_obj_t services_in) {
+    (void)self_in;
+    mp_obj_t len_in = mp_obj_len(services_in);
+    size_t len = mp_obj_get_int(len_in);
+    mp_obj_iter_buf_t iter_buf;
+    mp_obj_t iterable = mp_getiter(services_in, &iter_buf);
+    mp_obj_t service_tuple_obj;
+
+    mp_obj_tuple_t *result = MP_OBJ_TO_PTR(mp_obj_new_tuple(len, NULL));
+
+    uint16_t **handles = m_new0(uint16_t *, len);
+    size_t *num_handles = m_new0(size_t, len);
+
+    // TODO: Add a `append` kwarg (defaulting to False) to make this behavior optional.
+    bool append = false;
+    int err = mp_bluetooth_gatts_register_service_begin(append);
+    if (err != 0) {
+        return bluetooth_handle_errno(err);
+    }
+
+    size_t i = 0;
+    while ((service_tuple_obj = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
+        // (uuid, chars)
+        mp_obj_t *service_items;
+        mp_obj_get_array_fixed_n(service_tuple_obj, 2, &service_items);
+        err = bluetooth_gatts_register_service(service_items[0], service_items[1], &handles[i], &num_handles[i]);
+        if (err != 0) {
+            return bluetooth_handle_errno(err);
+        }
+
+        ++i;
+    }
+
+    // On Nimble, this will actually perform the registration, making the handles valid.
+    err = mp_bluetooth_gatts_register_service_end();
+    if (err != 0) {
+        return bluetooth_handle_errno(err);
+    }
+
+    // Return tuple of tuple of value handles.
+    // TODO: Also the Generic Access service characteristics?
+    for (i = 0; i < len; ++i) {
+        mp_obj_tuple_t *service_handles = MP_OBJ_TO_PTR(mp_obj_new_tuple(num_handles[i], NULL));
+        for (size_t j = 0; j < num_handles[i]; ++j) {
+            service_handles->items[j] = MP_OBJ_NEW_SMALL_INT(handles[i][j]);
+        }
+        result->items[i] = MP_OBJ_FROM_PTR(service_handles);
+    }
+    return MP_OBJ_FROM_PTR(result);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(bluetooth_ble_gatts_register_services_obj, bluetooth_ble_gatts_register_services);
+
+#if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+STATIC mp_obj_t bluetooth_ble_gap_connect(size_t n_args, const mp_obj_t *args) {
+    uint8_t addr_type = mp_obj_get_int(args[1]);
+    mp_buffer_info_t bufinfo = {0};
+    mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_READ);
+    if (bufinfo.len != 6) {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid addr"));
+    }
+    mp_int_t scan_duration_ms = MP_BLUETOOTH_CONNECT_DEFAULT_SCAN_DURATION_MS;
+    if (n_args == 4) {
+        scan_duration_ms = mp_obj_get_int(args[3]);
+    }
+
+    int err = mp_bluetooth_gap_peripheral_connect(addr_type, bufinfo.buf, scan_duration_ms);
+    return bluetooth_handle_errno(err);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bluetooth_ble_gap_connect_obj, 3, 4, bluetooth_ble_gap_connect);
+
+STATIC mp_obj_t bluetooth_ble_gap_scan(size_t n_args, const mp_obj_t *args) {
+    // Default is indefinite scan, with the NimBLE "background scan" interval and window.
+    mp_int_t duration_ms = 0;
+    mp_int_t interval_us = 1280000;
+    mp_int_t window_us = 11250;
+    if (n_args > 1) {
+        if (args[1] == mp_const_none) {
+            // scan(None) --> stop scan.
+            return bluetooth_handle_errno(mp_bluetooth_gap_scan_stop());
+        }
+        duration_ms = mp_obj_get_int(args[1]);
+        if (n_args > 2) {
+            interval_us = mp_obj_get_int(args[2]);
+            if (n_args > 3) {
+                window_us = mp_obj_get_int(args[3]);
+            }
+        }
+    }
+    return bluetooth_handle_errno(mp_bluetooth_gap_scan_start(duration_ms, interval_us, window_us));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bluetooth_ble_gap_scan_obj, 1, 4, bluetooth_ble_gap_scan);
+#endif // MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+
+STATIC mp_obj_t bluetooth_ble_gap_disconnect(mp_obj_t self_in, mp_obj_t conn_handle_in) {
+    (void)self_in;
+    uint16_t conn_handle = mp_obj_get_int(conn_handle_in);
+    int err = mp_bluetooth_gap_disconnect(conn_handle);
+    if (err == 0) {
+        return mp_const_true;
+    } else if (err == MP_ENOTCONN) {
+        return mp_const_false;
+    } else {
+        return bluetooth_handle_errno(err);
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(bluetooth_ble_gap_disconnect_obj, bluetooth_ble_gap_disconnect);
+
+// ----------------------------------------------------------------------------
+// Bluetooth object: GATTS (Peripheral/Advertiser role)
+// ----------------------------------------------------------------------------
+
+STATIC mp_obj_t bluetooth_ble_gatts_read(mp_obj_t self_in, mp_obj_t value_handle_in) {
+    (void)self_in;
+    size_t len = 0;
+    uint8_t *buf;
+    mp_bluetooth_gatts_read(mp_obj_get_int(value_handle_in), &buf, &len);
+    return mp_obj_new_bytes(buf, len);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(bluetooth_ble_gatts_read_obj, bluetooth_ble_gatts_read);
+
+STATIC mp_obj_t bluetooth_ble_gatts_write(mp_obj_t self_in, mp_obj_t value_handle_in, mp_obj_t data) {
+    (void)self_in;
+    mp_buffer_info_t bufinfo = {0};
+    mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
+    int err = mp_bluetooth_gatts_write(mp_obj_get_int(value_handle_in), bufinfo.buf, bufinfo.len);
+    bluetooth_handle_errno(err);
+    return MP_OBJ_NEW_SMALL_INT(bufinfo.len);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(bluetooth_ble_gatts_write_obj, bluetooth_ble_gatts_write);
+
+STATIC mp_obj_t bluetooth_ble_gatts_notify(size_t n_args, const mp_obj_t *args) {
+    mp_int_t conn_handle = mp_obj_get_int(args[1]);
+    mp_int_t value_handle = mp_obj_get_int(args[2]);
+
+    if (n_args == 4) {
+        mp_buffer_info_t bufinfo = {0};
+        mp_get_buffer_raise(args[3], &bufinfo, MP_BUFFER_READ);
+        size_t len = bufinfo.len;
+        int err = mp_bluetooth_gatts_notify_send(conn_handle, value_handle, bufinfo.buf, &len);
+        bluetooth_handle_errno(err);
+        return MP_OBJ_NEW_SMALL_INT(len);
+    } else {
+        int err = mp_bluetooth_gatts_notify(conn_handle, value_handle);
+        return bluetooth_handle_errno(err);
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bluetooth_ble_gatts_notify_obj, 3, 4, bluetooth_ble_gatts_notify);
+
+STATIC mp_obj_t bluetooth_ble_gatts_set_buffer(size_t n_args, const mp_obj_t *args) {
+    mp_int_t value_handle = mp_obj_get_int(args[1]);
+    mp_int_t len = mp_obj_get_int(args[2]);
+    bool append = n_args >= 4 && mp_obj_is_true(args[3]);
+    return bluetooth_handle_errno(mp_bluetooth_gatts_set_buffer(value_handle, len, append));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bluetooth_ble_gatts_set_buffer_obj, 3, 4, bluetooth_ble_gatts_set_buffer);
+
+// ----------------------------------------------------------------------------
+// Bluetooth object: GATTC (Central/Scanner role)
+// ----------------------------------------------------------------------------
+
+#if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+
+STATIC mp_obj_t bluetooth_ble_gattc_discover_services(mp_obj_t self_in, mp_obj_t conn_handle_in) {
+    (void)self_in;
+    mp_int_t conn_handle = mp_obj_get_int(conn_handle_in);
+    return bluetooth_handle_errno(mp_bluetooth_gattc_discover_primary_services(conn_handle));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(bluetooth_ble_gattc_discover_services_obj, bluetooth_ble_gattc_discover_services);
+
+STATIC mp_obj_t bluetooth_ble_gattc_discover_characteristics(size_t n_args, const mp_obj_t *args) {
+    (void)n_args;
+    mp_int_t conn_handle = mp_obj_get_int(args[1]);
+    mp_int_t start_handle = mp_obj_get_int(args[2]);
+    mp_int_t end_handle = mp_obj_get_int(args[3]);
+    return bluetooth_handle_errno(mp_bluetooth_gattc_discover_characteristics(conn_handle, start_handle, end_handle));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bluetooth_ble_gattc_discover_characteristics_obj, 4, 4, bluetooth_ble_gattc_discover_characteristics);
+
+STATIC mp_obj_t bluetooth_ble_gattc_discover_descriptors(size_t n_args, const mp_obj_t *args) {
+    (void)n_args;
+    mp_int_t conn_handle = mp_obj_get_int(args[1]);
+    mp_int_t start_handle = mp_obj_get_int(args[2]);
+    mp_int_t end_handle = mp_obj_get_int(args[3]);
+    return bluetooth_handle_errno(mp_bluetooth_gattc_discover_descriptors(conn_handle, start_handle, end_handle));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bluetooth_ble_gattc_discover_descriptors_obj, 4, 4, bluetooth_ble_gattc_discover_descriptors);
+
+STATIC mp_obj_t bluetooth_ble_gattc_read(mp_obj_t self_in, mp_obj_t conn_handle_in, mp_obj_t value_handle_in) {
+    (void)self_in;
+    mp_int_t conn_handle = mp_obj_get_int(conn_handle_in);
+    mp_int_t value_handle = mp_obj_get_int(value_handle_in);
+    return bluetooth_handle_errno(mp_bluetooth_gattc_read(conn_handle, value_handle));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(bluetooth_ble_gattc_read_obj, bluetooth_ble_gattc_read);
+
+STATIC mp_obj_t bluetooth_ble_gattc_write(size_t n_args, const mp_obj_t *args) {
+    mp_int_t conn_handle = mp_obj_get_int(args[1]);
+    mp_int_t value_handle = mp_obj_get_int(args[2]);
+    mp_obj_t data = args[3];
+    mp_buffer_info_t bufinfo = {0};
+    mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
+    size_t len = bufinfo.len;
+    unsigned int mode = MP_BLUETOOTH_WRITE_MODE_NO_RESPONSE;
+    if (n_args == 5) {
+        mode = mp_obj_get_int(args[4]);
+    }
+    return bluetooth_handle_errno(mp_bluetooth_gattc_write(conn_handle, value_handle, bufinfo.buf, &len, mode));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(bluetooth_ble_gattc_write_obj, 4, 5, bluetooth_ble_gattc_write);
+
+#endif // MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+
+// ----------------------------------------------------------------------------
+// Bluetooth object: Definition
+// ----------------------------------------------------------------------------
+
+STATIC const mp_rom_map_elem_t bluetooth_ble_locals_dict_table[] = {
+    // General
+    { MP_ROM_QSTR(MP_QSTR_active), MP_ROM_PTR(&bluetooth_ble_active_obj) },
+    { MP_ROM_QSTR(MP_QSTR_config), MP_ROM_PTR(&bluetooth_ble_config_obj) },
+    { MP_ROM_QSTR(MP_QSTR_irq), MP_ROM_PTR(&bluetooth_ble_irq_obj) },
+    // GAP
+    { MP_ROM_QSTR(MP_QSTR_gap_advertise), MP_ROM_PTR(&bluetooth_ble_gap_advertise_obj) },
+    #if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+    { MP_ROM_QSTR(MP_QSTR_gap_connect), MP_ROM_PTR(&bluetooth_ble_gap_connect_obj) },
+    { MP_ROM_QSTR(MP_QSTR_gap_scan), MP_ROM_PTR(&bluetooth_ble_gap_scan_obj) },
+    #endif
+    { MP_ROM_QSTR(MP_QSTR_gap_disconnect), MP_ROM_PTR(&bluetooth_ble_gap_disconnect_obj) },
+    // GATT Server (i.e. peripheral/advertiser role)
+    { MP_ROM_QSTR(MP_QSTR_gatts_register_services), MP_ROM_PTR(&bluetooth_ble_gatts_register_services_obj) },
+    { MP_ROM_QSTR(MP_QSTR_gatts_read), MP_ROM_PTR(&bluetooth_ble_gatts_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_gatts_write), MP_ROM_PTR(&bluetooth_ble_gatts_write_obj) },
+    { MP_ROM_QSTR(MP_QSTR_gatts_notify), MP_ROM_PTR(&bluetooth_ble_gatts_notify_obj) },
+    { MP_ROM_QSTR(MP_QSTR_gatts_set_buffer), MP_ROM_PTR(&bluetooth_ble_gatts_set_buffer_obj) },
+    #if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+    // GATT Client (i.e. central/scanner role)
+    { MP_ROM_QSTR(MP_QSTR_gattc_discover_services), MP_ROM_PTR(&bluetooth_ble_gattc_discover_services_obj) },
+    { MP_ROM_QSTR(MP_QSTR_gattc_discover_characteristics), MP_ROM_PTR(&bluetooth_ble_gattc_discover_characteristics_obj) },
+    { MP_ROM_QSTR(MP_QSTR_gattc_discover_descriptors), MP_ROM_PTR(&bluetooth_ble_gattc_discover_descriptors_obj) },
+    { MP_ROM_QSTR(MP_QSTR_gattc_read), MP_ROM_PTR(&bluetooth_ble_gattc_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_gattc_write), MP_ROM_PTR(&bluetooth_ble_gattc_write_obj) },
+    #endif
+};
+STATIC MP_DEFINE_CONST_DICT(bluetooth_ble_locals_dict, bluetooth_ble_locals_dict_table);
+
+STATIC const mp_obj_type_t bluetooth_ble_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_BLE,
+    .make_new = bluetooth_ble_make_new,
+    .locals_dict = (void *)&bluetooth_ble_locals_dict,
+};
+
+STATIC const mp_rom_map_elem_t mp_module_bluetooth_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_ubluetooth) },
+    { MP_ROM_QSTR(MP_QSTR_BLE), MP_ROM_PTR(&bluetooth_ble_type) },
+    { MP_ROM_QSTR(MP_QSTR_UUID), MP_ROM_PTR(&bluetooth_uuid_type) },
+    { MP_ROM_QSTR(MP_QSTR_FLAG_READ), MP_ROM_INT(MP_BLUETOOTH_CHARACTERISTIC_FLAG_READ) },
+    { MP_ROM_QSTR(MP_QSTR_FLAG_WRITE), MP_ROM_INT(MP_BLUETOOTH_CHARACTERISTIC_FLAG_WRITE) },
+    { MP_ROM_QSTR(MP_QSTR_FLAG_NOTIFY), MP_ROM_INT(MP_BLUETOOTH_CHARACTERISTIC_FLAG_NOTIFY) },
+    { MP_ROM_QSTR(MP_QSTR_FLAG_WRITE_NO_RESPONSE), MP_ROM_INT(MP_BLUETOOTH_CHARACTERISTIC_FLAG_WRITE_NO_RESPONSE) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(mp_module_bluetooth_globals, mp_module_bluetooth_globals_table);
+
+const mp_obj_module_t mp_module_ubluetooth = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&mp_module_bluetooth_globals,
+};
+
+// Helpers
+
+#include <stdio.h>
+
+STATIC void ringbuf_extract(ringbuf_t *ringbuf, mp_obj_tuple_t *data_tuple, size_t n_u16, size_t n_u8, mp_obj_str_t *bytes_addr, size_t n_i8, mp_obj_bluetooth_uuid_t *uuid, mp_obj_str_t *bytes_data) {
+    assert(ringbuf_avail(ringbuf) >= n_u16 * 2 + n_u8 + (bytes_addr ? 6 : 0) + n_i8 + (uuid ? 1 : 0) + (bytes_data ? 1 : 0));
+    size_t j = 0;
+
+    for (size_t i = 0; i < n_u16; ++i) {
+        data_tuple->items[j++] = MP_OBJ_NEW_SMALL_INT(ringbuf_get16(ringbuf));
+    }
+    if (n_u8) {
+        data_tuple->items[j++] = MP_OBJ_NEW_SMALL_INT(ringbuf_get(ringbuf));
+    }
+    if (bytes_addr) {
+        bytes_addr->len = 6;
+        for (size_t i = 0; i < bytes_addr->len; ++i) {
+            // cast away const, this is actually bt->irq_addr_bytes.
+            ((uint8_t *)bytes_addr->data)[i] = ringbuf_get(ringbuf);
+        }
+        data_tuple->items[j++] = MP_OBJ_FROM_PTR(bytes_addr);
+    }
+    for (size_t i = 0; i < n_i8; ++i) {
+        // Note the int8_t got packed into the ringbuf as a uint8_t.
+        data_tuple->items[j++] = MP_OBJ_NEW_SMALL_INT((int8_t)ringbuf_get(ringbuf));
+    }
+    if (uuid) {
+        ringbuf_get_uuid(ringbuf, uuid);
+        data_tuple->items[j++] = MP_OBJ_FROM_PTR(uuid);
+    }
+    // The code that enqueues into the ringbuf should ensure that it doesn't
+    // put more than bt->irq_data_data_alloc bytes into the ringbuf, because
+    // that's what's available here in bt->irq_data_bytes.
+    if (bytes_data) {
+        bytes_data->len = ringbuf_get(ringbuf);
+        for (size_t i = 0; i < bytes_data->len; ++i) {
+            // cast away const, this is actually bt->irq_data_bytes.
+            ((uint8_t *)bytes_data->data)[i] = ringbuf_get(ringbuf);
+        }
+        data_tuple->items[j++] = MP_OBJ_FROM_PTR(bytes_data);
+    }
+
+    data_tuple->len = j;
+}
+
+STATIC mp_obj_t bluetooth_ble_invoke_irq(mp_obj_t none_in) {
+    (void)none_in;
+    // This is always executing in schedule context.
+
+    mp_obj_bluetooth_ble_t *o = MP_OBJ_TO_PTR(MP_STATE_VM(bluetooth));
+    o->irq_scheduled = false;
+
+    for (;;) {
+        MICROPY_PY_BLUETOOTH_ENTER
+
+        mp_int_t event = event = ringbuf_get16(&o->ringbuf);
+        if (event < 0) {
+            // Nothing available in ringbuf.
+            MICROPY_PY_BLUETOOTH_EXIT
+            break;
+        }
+
+        // Although we're in schedule context, this code still avoids using any allocations:
+        //  - IRQs are disabled (to protect the ringbuf), and we need to avoid triggering GC
+        //  - The user's handler might not alloc, so we shouldn't either.
+
+        mp_obj_t handler = handler = o->irq_handler;
+        mp_obj_tuple_t *data_tuple = MP_OBJ_TO_PTR(o->irq_data_tuple);
+
+        if (event == MP_BLUETOOTH_IRQ_CENTRAL_CONNECT || event == MP_BLUETOOTH_IRQ_PERIPHERAL_CONNECT || event == MP_BLUETOOTH_IRQ_CENTRAL_DISCONNECT || event == MP_BLUETOOTH_IRQ_PERIPHERAL_DISCONNECT) {
+            // conn_handle, addr_type, addr
+            ringbuf_extract(&o->ringbuf, data_tuple, 1, 1, &o->irq_data_addr, 0, NULL, NULL);
+        } else if (event == MP_BLUETOOTH_IRQ_GATTS_WRITE) {
+            // conn_handle, value_handle
+            ringbuf_extract(&o->ringbuf, data_tuple, 2, 0, NULL, 0, NULL, NULL);
+        #if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+        } else if (event == MP_BLUETOOTH_IRQ_SCAN_RESULT) {
+            // addr_type, addr, adv_type, rssi, adv_data
+            ringbuf_extract(&o->ringbuf, data_tuple, 0, 1, &o->irq_data_addr, 2, NULL, &o->irq_data_data);
+        } else if (event == MP_BLUETOOTH_IRQ_SCAN_COMPLETE) {
+            // No params required.
+            data_tuple->len = 0;
+        } else if (event == MP_BLUETOOTH_IRQ_GATTC_SERVICE_RESULT) {
+            // conn_handle, start_handle, end_handle, uuid
+            ringbuf_extract(&o->ringbuf, data_tuple, 3, 0, NULL, 0, &o->irq_data_uuid, NULL);
+        } else if (event == MP_BLUETOOTH_IRQ_GATTC_CHARACTERISTIC_RESULT) {
+            // conn_handle, def_handle, value_handle, properties, uuid
+            ringbuf_extract(&o->ringbuf, data_tuple, 3, 1, NULL, 0, &o->irq_data_uuid, NULL);
+        } else if (event == MP_BLUETOOTH_IRQ_GATTC_DESCRIPTOR_RESULT) {
+            // conn_handle, handle, uuid
+            ringbuf_extract(&o->ringbuf, data_tuple, 2, 0, NULL, 0, &o->irq_data_uuid, NULL);
+        } else if (event == MP_BLUETOOTH_IRQ_GATTC_READ_RESULT || event == MP_BLUETOOTH_IRQ_GATTC_NOTIFY || event == MP_BLUETOOTH_IRQ_GATTC_INDICATE) {
+            // conn_handle, value_handle, data
+            ringbuf_extract(&o->ringbuf, data_tuple, 2, 0, NULL, 0, NULL, &o->irq_data_data);
+        } else if (event == MP_BLUETOOTH_IRQ_GATTC_WRITE_STATUS) {
+            // conn_handle, value_handle, status
+            ringbuf_extract(&o->ringbuf, data_tuple, 3, 0, NULL, 0, NULL, NULL);
+        #endif // MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+        }
+
+        MICROPY_PY_BLUETOOTH_EXIT
+
+        mp_call_function_2(handler, MP_OBJ_NEW_SMALL_INT(event), MP_OBJ_FROM_PTR(data_tuple));
+    }
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(bluetooth_ble_invoke_irq_obj, bluetooth_ble_invoke_irq);
+
+// ----------------------------------------------------------------------------
+// Port API
+// ----------------------------------------------------------------------------
+
+// Callbacks are called in interrupt context (i.e. can't allocate), so we need to push the data
+// into the ringbuf and schedule the callback via mp_sched_schedule.
+
+STATIC bool enqueue_irq(mp_obj_bluetooth_ble_t *o, size_t len, uint16_t event) {
+    if (!o || !(o->irq_trigger & event) || o->irq_handler == mp_const_none) {
+        return false;
+    }
+
+    if (ringbuf_free(&o->ringbuf) < len + 2) {
+        // Ringbuffer doesn't have room (and is therefore non-empty).
+
+        // If this is another scan result, or the front of the ringbuffer isn't a scan result, then nothing to do.
+        if (event == MP_BLUETOOTH_IRQ_SCAN_RESULT || ringbuf_peek16(&o->ringbuf) != MP_BLUETOOTH_IRQ_SCAN_RESULT) {
+            return false;
+        }
+
+        // Front of the queue is a scan result, remove it.
+
+        // event, addr_type, addr, adv_type, rssi
+        int n = 2 + 1 + 6 + 1 + 1;
+        for (int i = 0; i < n; ++i) {
+            ringbuf_get(&o->ringbuf);
+        }
+        // adv_data
+        n = ringbuf_get(&o->ringbuf);
+        for (int i = 0; i < n; ++i) {
+            ringbuf_get(&o->ringbuf);
+        }
+    }
+
+    // Append this event, the caller will then append the arguments.
+    ringbuf_put16(&o->ringbuf, event);
+    return true;
+}
+
+// Must hold the atomic section before calling this (MICROPY_PY_BLUETOOTH_ENTER).
+STATIC void schedule_ringbuf(mp_uint_t atomic_state) {
+    mp_obj_bluetooth_ble_t *o = MP_OBJ_TO_PTR(MP_STATE_VM(bluetooth));
+    if (!o->irq_scheduled) {
+        o->irq_scheduled = true;
+        MICROPY_PY_BLUETOOTH_EXIT
+        mp_sched_schedule(MP_OBJ_FROM_PTR(&bluetooth_ble_invoke_irq_obj), mp_const_none);
+    } else {
+        MICROPY_PY_BLUETOOTH_EXIT
+    }
+}
+
+void mp_bluetooth_gap_on_connected_disconnected(uint16_t event, uint16_t conn_handle, uint8_t addr_type, const uint8_t *addr) {
+    MICROPY_PY_BLUETOOTH_ENTER
+    mp_obj_bluetooth_ble_t *o = MP_OBJ_TO_PTR(MP_STATE_VM(bluetooth));
+    if (enqueue_irq(o, 2 + 1 + 6, event)) {
+        ringbuf_put16(&o->ringbuf, conn_handle);
+        ringbuf_put(&o->ringbuf, addr_type);
+        for (int i = 0; i < 6; ++i) {
+            ringbuf_put(&o->ringbuf, addr[i]);
+        }
+    }
+    schedule_ringbuf(atomic_state);
+}
+
+void mp_bluetooth_gatts_on_write(uint16_t conn_handle, uint16_t value_handle) {
+    MICROPY_PY_BLUETOOTH_ENTER
+    mp_obj_bluetooth_ble_t *o = MP_OBJ_TO_PTR(MP_STATE_VM(bluetooth));
+    if (enqueue_irq(o, 2 + 2, MP_BLUETOOTH_IRQ_GATTS_WRITE)) {
+        ringbuf_put16(&o->ringbuf, conn_handle);
+        ringbuf_put16(&o->ringbuf, value_handle);
+    }
+    schedule_ringbuf(atomic_state);
+}
+
+#if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+void mp_bluetooth_gap_on_scan_complete(void) {
+    MICROPY_PY_BLUETOOTH_ENTER
+    mp_obj_bluetooth_ble_t *o = MP_OBJ_TO_PTR(MP_STATE_VM(bluetooth));
+    if (enqueue_irq(o, 0, MP_BLUETOOTH_IRQ_SCAN_COMPLETE)) {
+    }
+    schedule_ringbuf(atomic_state);
+}
+
+void mp_bluetooth_gap_on_scan_result(uint8_t addr_type, const uint8_t *addr, uint8_t adv_type, const int8_t rssi, const uint8_t *data, size_t data_len) {
+    MICROPY_PY_BLUETOOTH_ENTER
+    mp_obj_bluetooth_ble_t *o = MP_OBJ_TO_PTR(MP_STATE_VM(bluetooth));
+    data_len = MIN(o->irq_data_data_alloc, data_len);
+    if (enqueue_irq(o, 1 + 6 + 1 + 1 + 1 + data_len, MP_BLUETOOTH_IRQ_SCAN_RESULT)) {
+        ringbuf_put(&o->ringbuf, addr_type);
+        for (int i = 0; i < 6; ++i) {
+            ringbuf_put(&o->ringbuf, addr[i]);
+        }
+        // The adv_type will get extracted as an int8_t but that's ok because valid values are 0x00-0x04.
+        ringbuf_put(&o->ringbuf, adv_type);
+        // Note conversion of int8_t rssi to uint8_t. Must un-convert on the way out.
+        ringbuf_put(&o->ringbuf, (uint8_t)rssi);
+        ringbuf_put(&o->ringbuf, data_len);
+        for (size_t i = 0; i < data_len; ++i) {
+            ringbuf_put(&o->ringbuf, data[i]);
+        }
+    }
+    schedule_ringbuf(atomic_state);
+}
+
+void mp_bluetooth_gattc_on_primary_service_result(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle, mp_obj_bluetooth_uuid_t *service_uuid) {
+    MICROPY_PY_BLUETOOTH_ENTER
+    mp_obj_bluetooth_ble_t *o = MP_OBJ_TO_PTR(MP_STATE_VM(bluetooth));
+    if (enqueue_irq(o, 2 + 2 + 2 + 1 + service_uuid->type, MP_BLUETOOTH_IRQ_GATTC_SERVICE_RESULT)) {
+        ringbuf_put16(&o->ringbuf, conn_handle);
+        ringbuf_put16(&o->ringbuf, start_handle);
+        ringbuf_put16(&o->ringbuf, end_handle);
+        ringbuf_put_uuid(&o->ringbuf, service_uuid);
+    }
+    schedule_ringbuf(atomic_state);
+}
+
+void mp_bluetooth_gattc_on_characteristic_result(uint16_t conn_handle, uint16_t def_handle, uint16_t value_handle, uint8_t properties, mp_obj_bluetooth_uuid_t *characteristic_uuid) {
+    MICROPY_PY_BLUETOOTH_ENTER
+    mp_obj_bluetooth_ble_t *o = MP_OBJ_TO_PTR(MP_STATE_VM(bluetooth));
+    if (enqueue_irq(o, 2 + 2 + 2 + 1 + characteristic_uuid->type, MP_BLUETOOTH_IRQ_GATTC_CHARACTERISTIC_RESULT)) {
+        ringbuf_put16(&o->ringbuf, conn_handle);
+        ringbuf_put16(&o->ringbuf, def_handle);
+        ringbuf_put16(&o->ringbuf, value_handle);
+        ringbuf_put(&o->ringbuf, properties);
+        ringbuf_put_uuid(&o->ringbuf, characteristic_uuid);
+    }
+    schedule_ringbuf(atomic_state);
+}
+
+void mp_bluetooth_gattc_on_descriptor_result(uint16_t conn_handle, uint16_t handle, mp_obj_bluetooth_uuid_t *descriptor_uuid) {
+    MICROPY_PY_BLUETOOTH_ENTER
+    mp_obj_bluetooth_ble_t *o = MP_OBJ_TO_PTR(MP_STATE_VM(bluetooth));
+    if (enqueue_irq(o, 2 + 2 + 1 + descriptor_uuid->type, MP_BLUETOOTH_IRQ_GATTC_DESCRIPTOR_RESULT)) {
+        ringbuf_put16(&o->ringbuf, conn_handle);
+        ringbuf_put16(&o->ringbuf, handle);
+        ringbuf_put_uuid(&o->ringbuf, descriptor_uuid);
+    }
+    schedule_ringbuf(atomic_state);
+}
+
+size_t mp_bluetooth_gattc_on_data_available_start(uint16_t event, uint16_t conn_handle, uint16_t value_handle, size_t data_len, mp_uint_t *atomic_state_out) {
+    MICROPY_PY_BLUETOOTH_ENTER
+    *atomic_state_out = atomic_state;
+    mp_obj_bluetooth_ble_t *o = MP_OBJ_TO_PTR(MP_STATE_VM(bluetooth));
+    data_len = MIN(o->irq_data_data_alloc, data_len);
+    if (enqueue_irq(o, 2 + 2 + 1 + data_len, event)) {
+        ringbuf_put16(&o->ringbuf, conn_handle);
+        ringbuf_put16(&o->ringbuf, value_handle);
+        ringbuf_put(&o->ringbuf, data_len);
+        return data_len;
+    } else {
+        return 0;
+    }
+}
+
+void mp_bluetooth_gattc_on_data_available_chunk(const uint8_t *data, size_t data_len) {
+    mp_obj_bluetooth_ble_t *o = MP_OBJ_TO_PTR(MP_STATE_VM(bluetooth));
+    for (size_t i = 0; i < data_len; ++i) {
+        ringbuf_put(&o->ringbuf, data[i]);
+    }
+}
+
+void mp_bluetooth_gattc_on_data_available_end(mp_uint_t atomic_state) {
+    schedule_ringbuf(atomic_state);
+}
+
+void mp_bluetooth_gattc_on_write_status(uint16_t conn_handle, uint16_t value_handle, uint16_t status) {
+    MICROPY_PY_BLUETOOTH_ENTER
+    mp_obj_bluetooth_ble_t *o = MP_OBJ_TO_PTR(MP_STATE_VM(bluetooth));
+    if (enqueue_irq(o, 2 + 2 + 2, MP_BLUETOOTH_IRQ_GATTC_WRITE_STATUS)) {
+        ringbuf_put16(&o->ringbuf, conn_handle);
+        ringbuf_put16(&o->ringbuf, value_handle);
+        ringbuf_put16(&o->ringbuf, status);
+    }
+    schedule_ringbuf(atomic_state);
+}
+
+#endif // MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+
+#if MICROPY_PY_BLUETOOTH_GATTS_ON_READ_CALLBACK
+// This can only be enabled when the thread invoking this is a MicroPython thread.
+// On ESP32, for example, this is not the case.
+bool mp_bluetooth_gatts_on_read_request(uint16_t conn_handle, uint16_t value_handle) {
+    mp_obj_bluetooth_ble_t *o = MP_OBJ_TO_PTR(MP_STATE_VM(bluetooth));
+    if ((o->irq_trigger & MP_BLUETOOTH_IRQ_GATTS_READ_REQUEST) && o->irq_handler != mp_const_none) {
+        // Use pre-allocated tuple because this is a hard IRQ.
+        mp_obj_tuple_t *data = MP_OBJ_TO_PTR(o->irq_data_tuple);
+        data->items[0] = MP_OBJ_NEW_SMALL_INT(conn_handle);
+        data->items[1] = MP_OBJ_NEW_SMALL_INT(value_handle);
+        data->len = 2;
+        mp_obj_t irq_ret = mp_call_function_2_protected(o->irq_handler, MP_OBJ_NEW_SMALL_INT(MP_BLUETOOTH_IRQ_GATTS_READ_REQUEST), o->irq_data_tuple);
+        // If the IRQ handler explicitly returned false, then deny the read. Otherwise if it returns None/True, allow it.
+        return irq_ret != MP_OBJ_NULL && (irq_ret == mp_const_none || mp_obj_is_true(irq_ret));
+    } else {
+        // No IRQ handler, allow the read.
+        return true;
+    }
+}
+#endif
+
+void mp_bluetooth_gatts_db_create_entry(mp_gatts_db_t db, uint16_t handle, size_t len) {
+    mp_map_elem_t *elem = mp_map_lookup(db, MP_OBJ_NEW_SMALL_INT(handle), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);
+    mp_bluetooth_gatts_db_entry_t *entry = m_new(mp_bluetooth_gatts_db_entry_t, 1);
+    entry->data = m_new(uint8_t, len);
+    entry->data_alloc = len;
+    entry->data_len = 0;
+    entry->append = false;
+    elem->value = MP_OBJ_FROM_PTR(entry);
+}
+
+mp_bluetooth_gatts_db_entry_t *mp_bluetooth_gatts_db_lookup(mp_gatts_db_t db, uint16_t handle) {
+    mp_map_elem_t *elem = mp_map_lookup(db, MP_OBJ_NEW_SMALL_INT(handle), MP_MAP_LOOKUP);
+    if (!elem) {
+        return NULL;
+    }
+    return MP_OBJ_TO_PTR(elem->value);
+}
+
+int mp_bluetooth_gatts_db_read(mp_gatts_db_t db, uint16_t handle, uint8_t **value, size_t *value_len) {
+    mp_bluetooth_gatts_db_entry_t *entry = mp_bluetooth_gatts_db_lookup(db, handle);
+    if (!entry) {
+        return MP_EINVAL;
+    }
+
+    *value = entry->data;
+    *value_len = entry->data_len;
+    if (entry->append) {
+        entry->data_len = 0;
+    }
+
+    return 0;
+}
+
+int mp_bluetooth_gatts_db_write(mp_gatts_db_t db, uint16_t handle, const uint8_t *value, size_t value_len) {
+    mp_bluetooth_gatts_db_entry_t *entry = mp_bluetooth_gatts_db_lookup(db, handle);
+    if (!entry) {
+        return MP_EINVAL;
+    }
+
+    if (value_len > entry->data_alloc) {
+        entry->data = m_new(uint8_t, value_len);
+        entry->data_alloc = value_len;
+    }
+
+    memcpy(entry->data, value, value_len);
+    entry->data_len = value_len;
+
+    return 0;
+}
+
+int mp_bluetooth_gatts_db_resize(mp_gatts_db_t db, uint16_t handle, size_t len, bool append) {
+    mp_bluetooth_gatts_db_entry_t *entry = mp_bluetooth_gatts_db_lookup(db, handle);
+    if (!entry) {
+        return MP_EINVAL;
+    }
+    entry->data = m_renew(uint8_t, entry->data, entry->data_alloc, len);
+    entry->data_alloc = len;
+    entry->data_len = 0;
+    entry->append = append;
+    return 0;
+}
+
+#endif // MICROPY_PY_BLUETOOTH
diff --git a/extmod/modbluetooth.h b/extmod/modbluetooth.h
new file mode 100644
index 0000000000000..4e658a7a0a426
--- /dev/null
+++ b/extmod/modbluetooth.h
@@ -0,0 +1,308 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Ayke van Laethem
+ * Copyright (c) 2019 Jim Mussared
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_EXTMOD_MODBLUETOOTH_H
+#define MICROPY_INCLUDED_EXTMOD_MODBLUETOOTH_H
+
+#include <stdbool.h>
+
+#include "py/obj.h"
+#include "py/objlist.h"
+#include "py/ringbuf.h"
+
+// Port specific configuration.
+#ifndef MICROPY_PY_BLUETOOTH_RINGBUF_SIZE
+#define MICROPY_PY_BLUETOOTH_RINGBUF_SIZE (128)
+#endif
+
+#ifndef MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+#define MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE (0)
+#endif
+
+#ifndef MICROPY_PY_BLUETOOTH_GATTS_ON_READ_CALLBACK
+#define MICROPY_PY_BLUETOOTH_GATTS_ON_READ_CALLBACK (0)
+#endif
+
+// This is used to protect the ringbuffer.
+#ifndef MICROPY_PY_BLUETOOTH_ENTER
+#define MICROPY_PY_BLUETOOTH_ENTER mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
+#define MICROPY_PY_BLUETOOTH_EXIT MICROPY_END_ATOMIC_SECTION(atomic_state);
+#endif
+
+// Common constants.
+#ifndef MP_BLUETOOTH_DEFAULT_ATTR_LEN
+#define MP_BLUETOOTH_DEFAULT_ATTR_LEN (20)
+#endif
+
+#define MP_BLUETOOTH_CCCB_LEN (2)
+
+// Advertisement packet lengths
+#define MP_BLUETOOTH_GAP_ADV_MAX_LEN (32)
+
+// These match the spec values for these flags so can be passed directly to the stack.
+#define MP_BLUETOOTH_CHARACTERISTIC_FLAG_READ     (1 << 1)
+#define MP_BLUETOOTH_CHARACTERISTIC_FLAG_WRITE_NO_RESPONSE (1 << 2)
+#define MP_BLUETOOTH_CHARACTERISTIC_FLAG_WRITE    (1 << 3)
+#define MP_BLUETOOTH_CHARACTERISTIC_FLAG_NOTIFY   (1 << 4)
+
+// For mp_bluetooth_gattc_write, the mode parameter
+#define MP_BLUETOOTH_WRITE_MODE_NO_RESPONSE     (0)
+#define MP_BLUETOOTH_WRITE_MODE_WITH_RESPONSE   (1)
+
+// Type value also doubles as length.
+#define MP_BLUETOOTH_UUID_TYPE_16  (2)
+#define MP_BLUETOOTH_UUID_TYPE_32  (4)
+#define MP_BLUETOOTH_UUID_TYPE_128 (16)
+
+// Address types (for the addr_type params).
+// Ports will need to map these to their own values.
+#define MP_BLUETOOTH_ADDR_PUBLIC                        (0x00)  // Public (identity) address. (Same as NimBLE and NRF SD)
+#define MP_BLUETOOTH_ADDR_RANDOM_STATIC                 (0x01)  // Random static (identity) address. (Same as NimBLE and NRF SD)
+#define MP_BLUETOOTH_ADDR_PUBLIC_ID                     (0x02)  // (Same as NimBLE)
+#define MP_BLUETOOTH_ADDR_RANDOM_ID                     (0x03)  // (Same as NimBLE)
+#define MP_BLUETOOTH_ADDR_RANDOM_PRIVATE_RESOLVABLE     (0x12) // Random private resolvable address. (NRF SD 0x02)
+#define MP_BLUETOOTH_ADDR_RANDOM_PRIVATE_NON_RESOLVABLE (0x13) // Random private non-resolvable address. (NRF SD 0x03)
+
+// Event codes for the IRQ handler.
+// Can also be combined to pass to the trigger param to select which events you
+// are interested in.
+// Note this is currently stored in a uint16_t (in irq_trigger, and the event
+// arg to the irq handler), so one spare value remaining.
+#define MP_BLUETOOTH_IRQ_CENTRAL_CONNECT              (1 << 0)
+#define MP_BLUETOOTH_IRQ_CENTRAL_DISCONNECT           (1 << 1)
+#define MP_BLUETOOTH_IRQ_GATTS_WRITE                  (1 << 2)
+#define MP_BLUETOOTH_IRQ_GATTS_READ_REQUEST           (1 << 3)
+#define MP_BLUETOOTH_IRQ_SCAN_RESULT                  (1 << 4)
+#define MP_BLUETOOTH_IRQ_SCAN_COMPLETE                (1 << 5)
+#define MP_BLUETOOTH_IRQ_PERIPHERAL_CONNECT           (1 << 6)
+#define MP_BLUETOOTH_IRQ_PERIPHERAL_DISCONNECT        (1 << 7)
+#define MP_BLUETOOTH_IRQ_GATTC_SERVICE_RESULT         (1 << 8)
+#define MP_BLUETOOTH_IRQ_GATTC_CHARACTERISTIC_RESULT  (1 << 9)
+#define MP_BLUETOOTH_IRQ_GATTC_DESCRIPTOR_RESULT      (1 << 10)
+#define MP_BLUETOOTH_IRQ_GATTC_READ_RESULT            (1 << 11)
+#define MP_BLUETOOTH_IRQ_GATTC_WRITE_STATUS           (1 << 12)
+#define MP_BLUETOOTH_IRQ_GATTC_NOTIFY                 (1 << 13)
+#define MP_BLUETOOTH_IRQ_GATTC_INDICATE               (1 << 14)
+#define MP_BLUETOOTH_IRQ_ALL                          (0xffff)
+
+/*
+These aren't included in the module for space reasons, but can be used
+in your Python code if necessary.
+
+from micropython import const
+_IRQ_CENTRAL_CONNECT                 = const(1 << 0)
+_IRQ_CENTRAL_DISCONNECT              = const(1 << 1)
+_IRQ_GATTS_WRITE                     = const(1 << 2)
+_IRQ_GATTS_READ_REQUEST              = const(1 << 3)
+_IRQ_SCAN_RESULT                     = const(1 << 4)
+_IRQ_SCAN_COMPLETE                   = const(1 << 5)
+_IRQ_PERIPHERAL_CONNECT              = const(1 << 6)
+_IRQ_PERIPHERAL_DISCONNECT           = const(1 << 7)
+_IRQ_GATTC_SERVICE_RESULT            = const(1 << 8)
+_IRQ_GATTC_CHARACTERISTIC_RESULT     = const(1 << 9)
+_IRQ_GATTC_DESCRIPTOR_RESULT         = const(1 << 10)
+_IRQ_GATTC_READ_RESULT               = const(1 << 11)
+_IRQ_GATTC_WRITE_STATUS              = const(1 << 12)
+_IRQ_GATTC_NOTIFY                    = const(1 << 13)
+_IRQ_GATTC_INDICATE                  = const(1 << 14)
+_IRQ_ALL                             = const(0xffff)
+*/
+
+// Common UUID type.
+// Ports are expected to map this to their own internal UUID types.
+// Internally the UUID data is little-endian, but the user should only
+// ever see this if they use the buffer protocol, e.g. in order to
+// construct an advertising payload (which needs to be in LE).
+// Both the constructor and the print function work in BE.
+typedef struct {
+    mp_obj_base_t base;
+    uint8_t type;
+    uint8_t data[16];
+} mp_obj_bluetooth_uuid_t;
+
+//////////////////////////////////////////////////////////////
+// API implemented by ports (i.e. called from modbluetooth.c):
+
+// TODO: At the moment this only allows for a single `Bluetooth` instance to be created.
+// Ideally in the future we'd be able to have multiple instances or to select a specific BT driver or HCI UART.
+// So these global methods should be replaced with a struct of function pointers (like the machine.I2C implementations).
+
+// Any method returning an int returns errno on failure, otherwise zero.
+
+// Note: All methods dealing with addresses (as 6-byte uint8 pointers) are in big-endian format.
+// (i.e. the same way they would be printed on a device sticker or in a UI), so the user sees
+// addresses in a way that looks like what they'd expect.
+// This means that the lower level implementation will likely need to reorder them (e.g. Nimble
+// works in little-endian, as does BLE itself).
+
+// Enables the Bluetooth stack.
+int mp_bluetooth_init(void);
+
+// Disables the Bluetooth stack. Is a no-op when not enabled.
+void mp_bluetooth_deinit(void);
+
+// Returns true when the Bluetooth stack is active.
+bool mp_bluetooth_is_active(void);
+
+// Gets the MAC addr of this device in big-endian format.
+void mp_bluetooth_get_device_addr(uint8_t *addr);
+
+// Get or set the GAP device name that will be used by service 0x1800, characteristic 0x2a00.
+size_t mp_bluetooth_gap_get_device_name(const uint8_t **buf);
+int mp_bluetooth_gap_set_device_name(const uint8_t *buf, size_t len);
+
+// Start advertisement. Will re-start advertisement when already enabled.
+// Returns errno on failure.
+int mp_bluetooth_gap_advertise_start(bool connectable, int32_t interval_us, const uint8_t *adv_data, size_t adv_data_len, const uint8_t *sr_data, size_t sr_data_len);
+
+// Stop advertisement. No-op when already stopped.
+void mp_bluetooth_gap_advertise_stop(void);
+
+// Start adding services. Must be called before mp_bluetooth_register_service.
+int mp_bluetooth_gatts_register_service_begin(bool append);
+// Add a service with the given list of characteristics to the queue to be registered.
+// The value_handles won't be valid until after mp_bluetooth_register_service_end is called.
+int mp_bluetooth_gatts_register_service(mp_obj_bluetooth_uuid_t *service_uuid, mp_obj_bluetooth_uuid_t **characteristic_uuids, uint8_t *characteristic_flags, mp_obj_bluetooth_uuid_t **descriptor_uuids, uint8_t *descriptor_flags, uint8_t *num_descriptors, uint16_t *handles, size_t num_characteristics);
+// Register any queued services.
+int mp_bluetooth_gatts_register_service_end(void);
+
+// Read the value from the local gatts db (likely this has been written by a central).
+int mp_bluetooth_gatts_read(uint16_t value_handle, uint8_t **value, size_t *value_len);
+// Write a value to the local gatts db (ready to be queried by a central).
+int mp_bluetooth_gatts_write(uint16_t value_handle, const uint8_t *value, size_t value_len);
+// Notify the central that it should do a read.
+int mp_bluetooth_gatts_notify(uint16_t conn_handle, uint16_t value_handle);
+// Notify the central, including a data payload. (Note: does not set the gatts db value).
+int mp_bluetooth_gatts_notify_send(uint16_t conn_handle, uint16_t value_handle, const uint8_t *value, size_t *value_len);
+// Indicate the central.
+int mp_bluetooth_gatts_indicate(uint16_t conn_handle, uint16_t value_handle);
+
+// Resize and enable/disable append-mode on a value.
+// Append-mode means that remote writes will append and local reads will clear after reading.
+int mp_bluetooth_gatts_set_buffer(uint16_t value_handle, size_t len, bool append);
+
+// Disconnect from a central or peripheral.
+int mp_bluetooth_gap_disconnect(uint16_t conn_handle);
+
+#if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+// Start a discovery (scan). Set duration to zero to run continuously.
+int mp_bluetooth_gap_scan_start(int32_t duration_ms, int32_t interval_us, int32_t window_us);
+
+// Stop discovery (if currently active).
+int mp_bluetooth_gap_scan_stop(void);
+
+// Connect to a found peripheral.
+int mp_bluetooth_gap_peripheral_connect(uint8_t addr_type, const uint8_t *addr, int32_t duration_ms);
+
+// Find all primary services on the connected peripheral.
+int mp_bluetooth_gattc_discover_primary_services(uint16_t conn_handle);
+
+// Find all characteristics on the specified service on a connected peripheral.
+int mp_bluetooth_gattc_discover_characteristics(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle);
+
+// Find all descriptors on the specified characteristic on a connected peripheral.
+int mp_bluetooth_gattc_discover_descriptors(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle);
+
+// Initiate read of a value from the remote peripheral.
+int mp_bluetooth_gattc_read(uint16_t conn_handle, uint16_t value_handle);
+
+// Write the value to the remote peripheral.
+int mp_bluetooth_gattc_write(uint16_t conn_handle, uint16_t value_handle, const uint8_t *value, size_t *value_len, unsigned int mode);
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// API implemented by modbluetooth (called by port-specific implementations):
+
+// Notify modbluetooth that a connection/disconnection event has occurred.
+void mp_bluetooth_gap_on_connected_disconnected(uint16_t event, uint16_t conn_handle, uint8_t addr_type, const uint8_t *addr);
+
+// Call this when a characteristic is written to.
+void mp_bluetooth_gatts_on_write(uint16_t conn_handle, uint16_t value_handle);
+
+#if MICROPY_PY_BLUETOOTH_GATTS_ON_READ_CALLBACK
+// Call this when a characteristic is read from. Return false to deny the read.
+bool mp_bluetooth_gatts_on_read_request(uint16_t conn_handle, uint16_t value_handle);
+#endif
+
+#if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+// Notify modbluetooth that scan has finished, either timeout, manually, or by some other action (e.g. connecting).
+void mp_bluetooth_gap_on_scan_complete(void);
+
+// Notify modbluetooth of a scan result.
+void mp_bluetooth_gap_on_scan_result(uint8_t addr_type, const uint8_t *addr, uint8_t adv_type, const int8_t rssi, const uint8_t *data, size_t data_len);
+
+// Notify modbluetooth that a service was found (either by discover-all, or discover-by-uuid).
+void mp_bluetooth_gattc_on_primary_service_result(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle, mp_obj_bluetooth_uuid_t *service_uuid);
+
+// Notify modbluetooth that a characteristic was found (either by discover-all-on-service, or discover-by-uuid-on-service).
+void mp_bluetooth_gattc_on_characteristic_result(uint16_t conn_handle, uint16_t def_handle, uint16_t value_handle, uint8_t properties, mp_obj_bluetooth_uuid_t *characteristic_uuid);
+
+// Notify modbluetooth that a descriptor was found.
+void mp_bluetooth_gattc_on_descriptor_result(uint16_t conn_handle, uint16_t handle, mp_obj_bluetooth_uuid_t *descriptor_uuid);
+
+// Notify modbluetooth that a read has completed with data (or notify/indicate data available, use `event` to disambiguate).
+// Note: these functions are to be called in a group protected by MICROPY_PY_BLUETOOTH_ENTER/EXIT.
+// _start returns the number of bytes to submit to the calls to _chunk, followed by a call to _end.
+size_t mp_bluetooth_gattc_on_data_available_start(uint16_t event, uint16_t conn_handle, uint16_t value_handle, size_t data_len, mp_uint_t *atomic_state_out);
+void mp_bluetooth_gattc_on_data_available_chunk(const uint8_t *data, size_t data_len);
+void mp_bluetooth_gattc_on_data_available_end(mp_uint_t atomic_state);
+
+// Notify modbluetooth that a write has completed.
+void mp_bluetooth_gattc_on_write_status(uint16_t conn_handle, uint16_t value_handle, uint16_t status);
+#endif
+
+// For stacks that don't manage attribute value data (currently all of them), helpers
+// to store this in a map, keyed by value handle.
+
+typedef struct {
+    // Pointer to heap-allocated data.
+    uint8_t *data;
+    // Allocated size of data.
+    size_t data_alloc;
+    // Current bytes in use.
+    size_t data_len;
+    // Whether new writes append or replace existing data (default false).
+    bool append;
+} mp_bluetooth_gatts_db_entry_t;
+
+typedef mp_map_t *mp_gatts_db_t;
+
+STATIC inline void mp_bluetooth_gatts_db_create(mp_gatts_db_t *db) {
+    *db = m_new(mp_map_t, 1);
+}
+
+STATIC inline void mp_bluetooth_gatts_db_reset(mp_gatts_db_t db) {
+    mp_map_init(db, 0);
+}
+
+void mp_bluetooth_gatts_db_create_entry(mp_gatts_db_t db, uint16_t handle, size_t len);
+mp_bluetooth_gatts_db_entry_t *mp_bluetooth_gatts_db_lookup(mp_gatts_db_t db, uint16_t handle);
+int mp_bluetooth_gatts_db_read(mp_gatts_db_t db, uint16_t handle, uint8_t **value, size_t *value_len);
+int mp_bluetooth_gatts_db_write(mp_gatts_db_t db, uint16_t handle, const uint8_t *value, size_t value_len);
+int mp_bluetooth_gatts_db_resize(mp_gatts_db_t db, uint16_t handle, size_t len, bool append);
+
+#endif // MICROPY_INCLUDED_EXTMOD_MODBLUETOOTH_H
diff --git a/extmod/modbluetooth_hci.h b/extmod/modbluetooth_hci.h
new file mode 100644
index 0000000000000..d6b432d224710
--- /dev/null
+++ b/extmod/modbluetooth_hci.h
@@ -0,0 +1,56 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_EXTMOD_MODBLUETOOTH_HCI_H
+#define MICROPY_INCLUDED_EXTMOD_MODBLUETOOTH_HCI_H
+
+#include "uart.h"
+
+// Optionally can be implemented by the driver.
+int mp_bluetooth_hci_controller_init(void);
+int mp_bluetooth_hci_controller_activate(void);
+int mp_bluetooth_hci_controller_deactivate(void);
+
+// Tell the controller to go to sleep (e.g. on RX if we don't think we're expecting anything more).
+int mp_bluetooth_hci_controller_sleep_maybe(void);
+// True if the controller woke us up.
+bool mp_bluetooth_hci_controller_woken(void);
+// Wake up the controller (e.g. we're about to TX).
+int mp_bluetooth_hci_controller_wakeup(void);
+
+// Storage and bindings that need to be implemented by the port.
+// These are used by the stack bindings (e.g. nimble/hal_uart.c)
+// as well as potentially the driver (e.g. cywbt.c).
+extern uint8_t mp_bluetooth_hci_cmd_buf[4 + 256];
+extern pyb_uart_obj_t mp_bluetooth_hci_uart_obj;
+
+int mp_bluetooth_hci_uart_init(uint32_t port);
+int mp_bluetooth_hci_uart_activate(void);
+int mp_bluetooth_hci_uart_set_baudrate(uint32_t baudrate);
+int mp_bluetooth_hci_uart_readchar(void);
+int mp_bluetooth_hci_uart_write(const uint8_t *buf, size_t len);
+
+#endif // MICROPY_INCLUDED_EXTMOD_MODBLUETOOTH_HCI_H
diff --git a/extmod/modbtree.c b/extmod/modbtree.c
index a2bff06d447bd..2dd3a89b89fef 100644
--- a/extmod/modbtree.c
+++ b/extmod/modbtree.c
@@ -39,6 +39,7 @@
 
 typedef struct _mp_obj_btree_t {
     mp_obj_base_t base;
+    mp_obj_t stream; // retain a reference to prevent GC from reclaiming it
     DB *db;
     mp_obj_t start_key;
     mp_obj_t end_key;
@@ -52,20 +53,23 @@ typedef struct _mp_obj_btree_t {
     byte next_flags;
 } mp_obj_btree_t;
 
+#if !MICROPY_ENABLE_DYNRUNTIME
 STATIC const mp_obj_type_t btree_type;
+#endif
 
 #define CHECK_ERROR(res) \
-        if (res == RET_ERROR) { \
-            mp_raise_OSError(errno); \
-        }
+    if (res == RET_ERROR) { \
+        mp_raise_OSError(errno); \
+    }
 
 void __dbpanic(DB *db) {
-    printf("__dbpanic(%p)\n", db);
+    mp_printf(&mp_plat_print, "__dbpanic(%p)\n", db);
 }
 
-STATIC mp_obj_btree_t *btree_new(DB *db) {
+STATIC mp_obj_btree_t *btree_new(DB *db, mp_obj_t stream) {
     mp_obj_btree_t *o = m_new_obj(mp_obj_btree_t);
     o->base.type = &btree_type;
+    o->stream = stream;
     o->db = db;
     o->start_key = mp_const_none;
     o->end_key = mp_const_none;
@@ -95,8 +99,8 @@ STATIC mp_obj_t btree_put(size_t n_args, const mp_obj_t *args) {
     (void)n_args;
     mp_obj_btree_t *self = MP_OBJ_TO_PTR(args[0]);
     DBT key, val;
-    key.data = (void*)mp_obj_str_get_data(args[1], &key.size);
-    val.data = (void*)mp_obj_str_get_data(args[2], &val.size);
+    key.data = (void *)mp_obj_str_get_data(args[1], &key.size);
+    val.data = (void *)mp_obj_str_get_data(args[2], &val.size);
     return MP_OBJ_NEW_SMALL_INT(__bt_put(self->db, &key, &val, 0));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(btree_put_obj, 3, 4, btree_put);
@@ -104,7 +108,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(btree_put_obj, 3, 4, btree_put);
 STATIC mp_obj_t btree_get(size_t n_args, const mp_obj_t *args) {
     mp_obj_btree_t *self = MP_OBJ_TO_PTR(args[0]);
     DBT key, val;
-    key.data = (void*)mp_obj_str_get_data(args[1], &key.size);
+    key.data = (void *)mp_obj_str_get_data(args[1], &key.size);
     int res = __bt_get(self->db, &key, &val, 0);
     if (res == RET_SPECIAL) {
         if (n_args > 2) {
@@ -123,7 +127,7 @@ STATIC mp_obj_t btree_seq(size_t n_args, const mp_obj_t *args) {
     int flags = MP_OBJ_SMALL_INT_VALUE(args[1]);
     DBT key, val;
     if (n_args > 2) {
-        key.data = (void*)mp_obj_str_get_data(args[2], &key.size);
+        key.data = (void *)mp_obj_str_get_data(args[2], &key.size);
     }
 
     int res = __bt_seq(self->db, &key, &val, flags);
@@ -198,7 +202,7 @@ STATIC mp_obj_t btree_iternext(mp_obj_t self_in) {
     if (self->start_key != MP_OBJ_NULL) {
         int flags = R_FIRST;
         if (self->start_key != mp_const_none) {
-            key.data = (void*)mp_obj_str_get_data(self->start_key, &key.size);
+            key.data = (void *)mp_obj_str_get_data(self->start_key, &key.size);
             flags = R_CURSOR;
         } else if (desc) {
             flags = R_LAST;
@@ -216,7 +220,7 @@ STATIC mp_obj_t btree_iternext(mp_obj_t self_in) {
 
     if (self->end_key != mp_const_none) {
         DBT end_key;
-        end_key.data = (void*)mp_obj_str_get_data(self->end_key, &end_key.size);
+        end_key.data = (void *)mp_obj_str_get_data(self->end_key, &end_key.size);
         BTREE *t = self->db->internal;
         int cmp = t->bt_cmp(&key, &end_key);
         if (desc) {
@@ -251,28 +255,28 @@ STATIC mp_obj_t btree_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
     if (value == MP_OBJ_NULL) {
         // delete
         DBT key;
-        key.data = (void*)mp_obj_str_get_data(index, &key.size);
+        key.data = (void *)mp_obj_str_get_data(index, &key.size);
         int res = __bt_delete(self->db, &key, 0);
         if (res == RET_SPECIAL) {
-            nlr_raise(mp_obj_new_exception(&mp_type_KeyError));
+            mp_raise_type(&mp_type_KeyError);
         }
         CHECK_ERROR(res);
         return mp_const_none;
     } else if (value == MP_OBJ_SENTINEL) {
         // load
         DBT key, val;
-        key.data = (void*)mp_obj_str_get_data(index, &key.size);
+        key.data = (void *)mp_obj_str_get_data(index, &key.size);
         int res = __bt_get(self->db, &key, &val, 0);
         if (res == RET_SPECIAL) {
-            nlr_raise(mp_obj_new_exception(&mp_type_KeyError));
+            mp_raise_type(&mp_type_KeyError);
         }
         CHECK_ERROR(res);
         return mp_obj_new_bytes(val.data, val.size);
     } else {
         // store
         DBT key, val;
-        key.data = (void*)mp_obj_str_get_data(index, &key.size);
-        val.data = (void*)mp_obj_str_get_data(value, &val.size);
+        key.data = (void *)mp_obj_str_get_data(index, &key.size);
+        val.data = (void *)mp_obj_str_get_data(value, &val.size);
         int res = __bt_put(self->db, &key, &val, 0);
         CHECK_ERROR(res);
         return mp_const_none;
@@ -284,7 +288,7 @@ STATIC mp_obj_t btree_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs
     switch (op) {
         case MP_BINARY_OP_CONTAINS: {
             DBT key, val;
-            key.data = (void*)mp_obj_str_get_data(rhs_in, &key.size);
+            key.data = (void *)mp_obj_str_get_data(rhs_in, &key.size);
             int res = __bt_get(self->db, &key, &val, 0);
             CHECK_ERROR(res);
             return mp_obj_new_bool(res != RET_SPECIAL);
@@ -295,6 +299,7 @@ STATIC mp_obj_t btree_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs
     }
 }
 
+#if !MICROPY_ENABLE_DYNRUNTIME
 STATIC const mp_rom_map_elem_t btree_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&btree_close_obj) },
     { MP_ROM_QSTR(MP_QSTR_flush), MP_ROM_PTR(&btree_flush_obj) },
@@ -317,16 +322,18 @@ STATIC const mp_obj_type_t btree_type = {
     .iternext = btree_iternext,
     .binary_op = btree_binary_op,
     .subscr = btree_subscr,
-    .locals_dict = (void*)&btree_locals_dict,
+    .locals_dict = (void *)&btree_locals_dict,
 };
+#endif
 
-STATIC FILEVTABLE btree_stream_fvtable = {
+STATIC const FILEVTABLE btree_stream_fvtable = {
     mp_stream_posix_read,
     mp_stream_posix_write,
     mp_stream_posix_lseek,
     mp_stream_posix_fsync
 };
 
+#if !MICROPY_ENABLE_DYNRUNTIME
 STATIC mp_obj_t mod_btree_open(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_flags, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
@@ -345,18 +352,18 @@ STATIC mp_obj_t mod_btree_open(size_t n_args, const mp_obj_t *pos_args, mp_map_t
         mp_arg_val_t minkeypage;
     } args;
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args,
-        MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t*)&args);
+        MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t *)&args);
     BTREEINFO openinfo = {0};
     openinfo.flags = args.flags.u_int;
     openinfo.cachesize = args.cachesize.u_int;
     openinfo.psize = args.pagesize.u_int;
     openinfo.minkeypage = args.minkeypage.u_int;
 
-    DB *db = __bt_open(MP_OBJ_TO_PTR(pos_args[0]), &btree_stream_fvtable, &openinfo, /*dflags*/0);
+    DB *db = __bt_open(MP_OBJ_TO_PTR(pos_args[0]), &btree_stream_fvtable, &openinfo, /*dflags*/ 0);
     if (db == NULL) {
         mp_raise_OSError(errno);
     }
-    return MP_OBJ_FROM_PTR(btree_new(db));
+    return MP_OBJ_FROM_PTR(btree_new(db, pos_args[0]));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(mod_btree_open_obj, 1, mod_btree_open);
 
@@ -371,7 +378,8 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_btree_globals, mp_module_btree_globals_tab
 
 const mp_obj_module_t mp_module_btree = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_btree_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_btree_globals,
 };
+#endif
 
 #endif // MICROPY_PY_BTREE
diff --git a/extmod/modframebuf.c b/extmod/modframebuf.c
index a7f6ba905fbfe..2753acc2712b6 100644
--- a/extmod/modframebuf.c
+++ b/extmod/modframebuf.c
@@ -41,8 +41,12 @@ typedef struct _mp_obj_framebuf_t {
     uint8_t format;
 } mp_obj_framebuf_t;
 
-typedef void (*setpixel_t)(const mp_obj_framebuf_t*, int, int, uint32_t);
-typedef uint32_t (*getpixel_t)(const mp_obj_framebuf_t*, int, int);
+#if !MICROPY_ENABLE_DYNRUNTIME
+STATIC const mp_obj_type_t mp_type_framebuf;
+#endif
+
+typedef void (*setpixel_t)(const mp_obj_framebuf_t *, int, int, uint32_t);
+typedef uint32_t (*getpixel_t)(const mp_obj_framebuf_t *, int, int);
 typedef void (*fill_rect_t)(const mp_obj_framebuf_t *, int, int, int, int, uint32_t);
 
 typedef struct _mp_framebuf_p_t {
@@ -65,20 +69,20 @@ typedef struct _mp_framebuf_p_t {
 STATIC void mono_horiz_setpixel(const mp_obj_framebuf_t *fb, int x, int y, uint32_t col) {
     size_t index = (x + y * fb->stride) >> 3;
     int offset = fb->format == FRAMEBUF_MHMSB ? x & 0x07 : 7 - (x & 0x07);
-    ((uint8_t*)fb->buf)[index] = (((uint8_t*)fb->buf)[index] & ~(0x01 << offset)) | ((col != 0) << offset);
+    ((uint8_t *)fb->buf)[index] = (((uint8_t *)fb->buf)[index] & ~(0x01 << offset)) | ((col != 0) << offset);
 }
 
 STATIC uint32_t mono_horiz_getpixel(const mp_obj_framebuf_t *fb, int x, int y) {
     size_t index = (x + y * fb->stride) >> 3;
     int offset = fb->format == FRAMEBUF_MHMSB ? x & 0x07 : 7 - (x & 0x07);
-    return (((uint8_t*)fb->buf)[index] >> (offset)) & 0x01;
+    return (((uint8_t *)fb->buf)[index] >> (offset)) & 0x01;
 }
 
 STATIC void mono_horiz_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int w, int h, uint32_t col) {
     int reverse = fb->format == FRAMEBUF_MHMSB;
     int advance = fb->stride >> 3;
     while (w--) {
-        uint8_t *b = &((uint8_t*)fb->buf)[(x >> 3) + y * advance];
+        uint8_t *b = &((uint8_t *)fb->buf)[(x >> 3) + y * advance];
         int offset = reverse ?  x & 7 : 7 - (x & 7);
         for (int hh = h; hh; --hh) {
             *b = (*b & ~(0x01 << offset)) | ((col != 0) << offset);
@@ -93,16 +97,16 @@ STATIC void mono_horiz_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int
 STATIC void mvlsb_setpixel(const mp_obj_framebuf_t *fb, int x, int y, uint32_t col) {
     size_t index = (y >> 3) * fb->stride + x;
     uint8_t offset = y & 0x07;
-    ((uint8_t*)fb->buf)[index] = (((uint8_t*)fb->buf)[index] & ~(0x01 << offset)) | ((col != 0) << offset);
+    ((uint8_t *)fb->buf)[index] = (((uint8_t *)fb->buf)[index] & ~(0x01 << offset)) | ((col != 0) << offset);
 }
 
 STATIC uint32_t mvlsb_getpixel(const mp_obj_framebuf_t *fb, int x, int y) {
-    return (((uint8_t*)fb->buf)[(y >> 3) * fb->stride + x] >> (y & 0x07)) & 0x01;
+    return (((uint8_t *)fb->buf)[(y >> 3) * fb->stride + x] >> (y & 0x07)) & 0x01;
 }
 
 STATIC void mvlsb_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int w, int h, uint32_t col) {
     while (h--) {
-        uint8_t *b = &((uint8_t*)fb->buf)[(y >> 3) * fb->stride + x];
+        uint8_t *b = &((uint8_t *)fb->buf)[(y >> 3) * fb->stride + x];
         uint8_t offset = y & 0x07;
         for (int ww = w; ww; --ww) {
             *b = (*b & ~(0x01 << offset)) | ((col != 0) << offset);
@@ -115,15 +119,15 @@ STATIC void mvlsb_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int w, in
 // Functions for RGB565 format
 
 STATIC void rgb565_setpixel(const mp_obj_framebuf_t *fb, int x, int y, uint32_t col) {
-    ((uint16_t*)fb->buf)[x + y * fb->stride] = col;
+    ((uint16_t *)fb->buf)[x + y * fb->stride] = col;
 }
 
 STATIC uint32_t rgb565_getpixel(const mp_obj_framebuf_t *fb, int x, int y) {
-    return ((uint16_t*)fb->buf)[x + y * fb->stride];
+    return ((uint16_t *)fb->buf)[x + y * fb->stride];
 }
 
 STATIC void rgb565_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int w, int h, uint32_t col) {
-    uint16_t *b = &((uint16_t*)fb->buf)[x + y * fb->stride];
+    uint16_t *b = &((uint16_t *)fb->buf)[x + y * fb->stride];
     while (h--) {
         for (int ww = w; ww; --ww) {
             *b++ = col;
@@ -135,7 +139,7 @@ STATIC void rgb565_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int w, i
 // Functions for GS2_HMSB format
 
 STATIC void gs2_hmsb_setpixel(const mp_obj_framebuf_t *fb, int x, int y, uint32_t col) {
-    uint8_t *pixel = &((uint8_t*)fb->buf)[(x + y * fb->stride) >> 2];
+    uint8_t *pixel = &((uint8_t *)fb->buf)[(x + y * fb->stride) >> 2];
     uint8_t shift = (x & 0x3) << 1;
     uint8_t mask = 0x3 << shift;
     uint8_t color = (col & 0x3) << shift;
@@ -143,14 +147,14 @@ STATIC void gs2_hmsb_setpixel(const mp_obj_framebuf_t *fb, int x, int y, uint32_
 }
 
 STATIC uint32_t gs2_hmsb_getpixel(const mp_obj_framebuf_t *fb, int x, int y) {
-    uint8_t pixel = ((uint8_t*)fb->buf)[(x + y * fb->stride) >> 2];
+    uint8_t pixel = ((uint8_t *)fb->buf)[(x + y * fb->stride) >> 2];
     uint8_t shift = (x & 0x3) << 1;
     return (pixel >> shift) & 0x3;
 }
 
 STATIC void gs2_hmsb_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int w, int h, uint32_t col) {
-    for (int xx=x; xx < x+w; xx++) {
-        for (int yy=y; yy < y+h; yy++) {
+    for (int xx = x; xx < x + w; xx++) {
+        for (int yy = y; yy < y + h; yy++) {
             gs2_hmsb_setpixel(fb, xx, yy, col);
         }
     }
@@ -159,7 +163,7 @@ STATIC void gs2_hmsb_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int w,
 // Functions for GS4_HMSB format
 
 STATIC void gs4_hmsb_setpixel(const mp_obj_framebuf_t *fb, int x, int y, uint32_t col) {
-    uint8_t *pixel = &((uint8_t*)fb->buf)[(x + y * fb->stride) >> 1];
+    uint8_t *pixel = &((uint8_t *)fb->buf)[(x + y * fb->stride) >> 1];
 
     if (x % 2) {
         *pixel = ((uint8_t)col & 0x0f) | (*pixel & 0xf0);
@@ -170,15 +174,15 @@ STATIC void gs4_hmsb_setpixel(const mp_obj_framebuf_t *fb, int x, int y, uint32_
 
 STATIC uint32_t gs4_hmsb_getpixel(const mp_obj_framebuf_t *fb, int x, int y) {
     if (x % 2) {
-        return ((uint8_t*)fb->buf)[(x + y * fb->stride) >> 1] & 0x0f;
+        return ((uint8_t *)fb->buf)[(x + y * fb->stride) >> 1] & 0x0f;
     }
 
-    return ((uint8_t*)fb->buf)[(x + y * fb->stride) >> 1] >> 4;
+    return ((uint8_t *)fb->buf)[(x + y * fb->stride) >> 1] >> 4;
 }
 
 STATIC void gs4_hmsb_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int w, int h, uint32_t col) {
     col &= 0x0f;
-    uint8_t *pixel_pair = &((uint8_t*)fb->buf)[(x + y * fb->stride) >> 1];
+    uint8_t *pixel_pair = &((uint8_t *)fb->buf)[(x + y * fb->stride) >> 1];
     uint8_t col_shifted_left = col << 4;
     uint8_t col_pixel_pair = col_shifted_left | col;
     int pixel_count_till_next_line = (fb->stride - w) >> 1;
@@ -210,16 +214,16 @@ STATIC void gs4_hmsb_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int w,
 // Functions for GS8 format
 
 STATIC void gs8_setpixel(const mp_obj_framebuf_t *fb, int x, int y, uint32_t col) {
-    uint8_t *pixel = &((uint8_t*)fb->buf)[(x + y * fb->stride)];
+    uint8_t *pixel = &((uint8_t *)fb->buf)[(x + y * fb->stride)];
     *pixel = col & 0xff;
 }
 
 STATIC uint32_t gs8_getpixel(const mp_obj_framebuf_t *fb, int x, int y) {
-    return ((uint8_t*)fb->buf)[(x + y * fb->stride)];
+    return ((uint8_t *)fb->buf)[(x + y * fb->stride)];
 }
 
 STATIC void gs8_fill_rect(const mp_obj_framebuf_t *fb, int x, int y, int w, int h, uint32_t col) {
-    uint8_t *pixel = &((uint8_t*)fb->buf)[(x + y * fb->stride)];
+    uint8_t *pixel = &((uint8_t *)fb->buf)[(x + y * fb->stride)];
     while (h--) {
         memset(pixel, col, w);
         pixel += fb->stride;
@@ -296,7 +300,7 @@ STATIC mp_obj_t framebuf_make_new(const mp_obj_type_t *type, size_t n_args, size
         case FRAMEBUF_GS8:
             break;
         default:
-            mp_raise_ValueError("invalid format");
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid format"));
     }
 
     return MP_OBJ_FROM_PTR(o);
@@ -393,9 +397,9 @@ STATIC mp_obj_t framebuf_rect(size_t n_args, const mp_obj_t *args) {
     mp_int_t col = mp_obj_get_int(args[5]);
 
     fill_rect(self, x, y, w, 1, col);
-    fill_rect(self, x, y + h- 1, w, 1, col);
+    fill_rect(self, x, y + h - 1, w, 1, col);
     fill_rect(self, x, y, 1, h, col);
-    fill_rect(self, x + w- 1, y, 1, h, col);
+    fill_rect(self, x + w - 1, y, 1, h, col);
 
     return mp_const_none;
 }
@@ -432,9 +436,15 @@ STATIC mp_obj_t framebuf_line(size_t n_args, const mp_obj_t *args) {
     bool steep;
     if (dy > dx) {
         mp_int_t temp;
-        temp = x1; x1 = y1; y1 = temp;
-        temp = dx; dx = dy; dy = temp;
-        temp = sx; sx = sy; sy = temp;
+        temp = x1;
+        x1 = y1;
+        y1 = temp;
+        temp = dx;
+        dx = dy;
+        dy = temp;
+        temp = sx;
+        sx = sy;
+        sy = temp;
         steep = true;
     } else {
         steep = false;
@@ -469,7 +479,12 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(framebuf_line_obj, 6, 6, framebuf_lin
 
 STATIC mp_obj_t framebuf_blit(size_t n_args, const mp_obj_t *args) {
     mp_obj_framebuf_t *self = MP_OBJ_TO_PTR(args[0]);
-    mp_obj_framebuf_t *source = MP_OBJ_TO_PTR(args[1]);
+    mp_obj_t source_in = mp_obj_cast_to_native_base(args[1], MP_OBJ_FROM_PTR(&mp_type_framebuf));
+    if (source_in == MP_OBJ_NULL) {
+        mp_raise_TypeError(NULL);
+    }
+    mp_obj_framebuf_t *source = MP_OBJ_TO_PTR(source_in);
+
     mp_int_t x = mp_obj_get_int(args[2]);
     mp_int_t y = mp_obj_get_int(args[3]);
     mp_int_t key = -1;
@@ -482,7 +497,7 @@ STATIC mp_obj_t framebuf_blit(size_t n_args, const mp_obj_t *args) {
         (y >= self->height) ||
         (-x >= source->width) ||
         (-y >= source->height)
-    ) {
+        ) {
         // Out of bounds, no-op.
         return mp_const_none;
     }
@@ -556,7 +571,7 @@ STATIC mp_obj_t framebuf_text(size_t n_args, const mp_obj_t *args) {
     // loop over chars
     for (; *str; ++str) {
         // get char and make sure its in range of font
-        int chr = *(uint8_t*)str;
+        int chr = *(uint8_t *)str;
         if (chr < 32 || chr > 127) {
             chr = 127;
         }
@@ -580,6 +595,7 @@ STATIC mp_obj_t framebuf_text(size_t n_args, const mp_obj_t *args) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(framebuf_text_obj, 4, 5, framebuf_text);
 
+#if !MICROPY_ENABLE_DYNRUNTIME
 STATIC const mp_rom_map_elem_t framebuf_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_fill), MP_ROM_PTR(&framebuf_fill_obj) },
     { MP_ROM_QSTR(MP_QSTR_fill_rect), MP_ROM_PTR(&framebuf_fill_rect_obj) },
@@ -599,8 +615,9 @@ STATIC const mp_obj_type_t mp_type_framebuf = {
     .name = MP_QSTR_FrameBuffer,
     .make_new = framebuf_make_new,
     .buffer_p = { .get_buffer = framebuf_get_buffer },
-    .locals_dict = (mp_obj_dict_t*)&framebuf_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&framebuf_locals_dict,
 };
+#endif
 
 // this factory function is provided for backwards compatibility with old FrameBuffer1 class
 STATIC mp_obj_t legacy_framebuffer1(size_t n_args, const mp_obj_t *args) {
@@ -624,6 +641,7 @@ STATIC mp_obj_t legacy_framebuffer1(size_t n_args, const mp_obj_t *args) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(legacy_framebuffer1_obj, 3, 4, legacy_framebuffer1);
 
+#if !MICROPY_ENABLE_DYNRUNTIME
 STATIC const mp_rom_map_elem_t framebuf_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_framebuf) },
     { MP_ROM_QSTR(MP_QSTR_FrameBuffer), MP_ROM_PTR(&mp_type_framebuf) },
@@ -642,7 +660,8 @@ STATIC MP_DEFINE_CONST_DICT(framebuf_module_globals, framebuf_module_globals_tab
 
 const mp_obj_module_t mp_module_framebuf = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&framebuf_module_globals,
+    .globals = (mp_obj_dict_t *)&framebuf_module_globals,
 };
+#endif
 
 #endif // MICROPY_PY_FRAMEBUF
diff --git a/extmod/modlwip.c b/extmod/modlwip.c
index 7ebfa8904728c..216e81749d1c3 100644
--- a/extmod/modlwip.c
+++ b/extmod/modlwip.c
@@ -40,7 +40,7 @@
 #include "lwip/init.h"
 #include "lwip/tcp.h"
 #include "lwip/udp.h"
-//#include "lwip/raw.h"
+#include "lwip/raw.h"
 #include "lwip/dns.h"
 #include "lwip/igmp.h"
 #if LWIP_VERSION_MAJOR < 2
@@ -57,6 +57,10 @@
 #define DEBUG_printf(...) (void)0
 #endif
 
+// Timeout between closing a TCP socket and doing a tcp_abort on that
+// socket, if the connection isn't closed cleanly in that time.
+#define MICROPY_PY_LWIP_TCP_CLOSE_TIMEOUT_MS (10000)
+
 // All socket options should be globally distinct,
 // because we ignore option levels for efficiency.
 #define IP_ADD_MEMBERSHIP 0x400
@@ -99,7 +103,7 @@ void mod_lwip_register_poll(void (*poll)(void *arg), void *poll_arg);
 void mod_lwip_deregister_poll(void (*poll)(void *arg), void *poll_arg);
 
 STATIC void slip_lwip_poll(void *netif) {
-    slipif_poll((struct netif*)netif);
+    slipif_poll((struct netif *)netif);
 }
 
 STATIC const mp_obj_type_t lwip_slip_type;
@@ -140,15 +144,15 @@ STATIC mp_obj_t lwip_slip_make_new(mp_obj_t type_in, size_t n_args, size_t n_kw,
 
     ip_addr_t iplocal, ipremote;
     if (!ipaddr_aton(mp_obj_str_get_str(args[1]), &iplocal)) {
-        mp_raise_ValueError("not a valid local IP");
+        mp_raise_ValueError(MP_ERROR_TEXT("not a valid local IP"));
     }
     if (!ipaddr_aton(mp_obj_str_get_str(args[2]), &ipremote)) {
-        mp_raise_ValueError("not a valid remote IP");
+        mp_raise_ValueError(MP_ERROR_TEXT("not a valid remote IP"));
     }
 
     struct netif *n = &lwip_slip_obj.lwip_netif;
     if (netif_add(n, &iplocal, IP_ADDR_BROADCAST, &ipremote, NULL, slipif_init, ip_input) == NULL) {
-       mp_raise_ValueError("out of memory");
+        mp_raise_ValueError(MP_ERROR_TEXT("out of memory"));
     }
     netif_set_up(n);
     netif_set_default(n);
@@ -174,7 +178,7 @@ STATIC const mp_obj_type_t lwip_slip_type = {
     { &mp_type_type },
     .name = MP_QSTR_slip,
     .make_new = lwip_slip_make_new,
-    .locals_dict = (mp_obj_dict_t*)&lwip_slip_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&lwip_slip_locals_dict,
 };
 
 #endif // MICROPY_PY_LWIP_SLIP
@@ -186,7 +190,7 @@ STATIC const mp_obj_type_t lwip_slip_type = {
 // lwIP 2 changed LWIP_VERSION and it can no longer be used in macros,
 // so we define our own equivalent version that can.
 #define LWIP_VERSION_MACRO (LWIP_VERSION_MAJOR << 24 | LWIP_VERSION_MINOR << 16 \
-                            | LWIP_VERSION_REVISION << 8 | LWIP_VERSION_RC)
+        | LWIP_VERSION_REVISION << 8 | LWIP_VERSION_RC)
 
 // Extension to lwIP error codes
 #define _ERR_BADF -16
@@ -276,6 +280,7 @@ typedef struct _lwip_socket_obj_t {
     volatile union {
         struct tcp_pcb *tcp;
         struct udp_pcb *udp;
+        struct raw_pcb *raw;
     } pcb;
     volatile union {
         struct pbuf *pbuf;
@@ -303,16 +308,17 @@ typedef struct _lwip_socket_obj_t {
     #define STATE_CONNECTING 2
     #define STATE_CONNECTED 3
     #define STATE_PEER_CLOSED 4
+    #define STATE_ACTIVE_UDP 5
     // Negative value is lwIP error
     int8_t state;
 } lwip_socket_obj_t;
 
 static inline void poll_sockets(void) {
-#ifdef MICROPY_EVENT_POLL_HOOK
+    #ifdef MICROPY_EVENT_POLL_HOOK
     MICROPY_EVENT_POLL_HOOK;
-#else
+    #else
     mp_hal_delay_ms(1);
-#endif
+    #endif
 }
 
 STATIC struct tcp_pcb *volatile *lwip_socket_incoming_array(lwip_socket_obj_t *socket) {
@@ -352,9 +358,30 @@ STATIC void lwip_socket_free_incoming(lwip_socket_obj_t *socket) {
 
 static inline void exec_user_callback(lwip_socket_obj_t *socket) {
     if (socket->callback != MP_OBJ_NULL) {
-        mp_call_function_1_protected(socket->callback, MP_OBJ_FROM_PTR(socket));
+        // Schedule the user callback to execute outside the lwIP context
+        mp_sched_schedule(socket->callback, MP_OBJ_FROM_PTR(socket));
+    }
+}
+
+#if MICROPY_PY_LWIP_SOCK_RAW
+// Callback for incoming raw packets.
+#if LWIP_VERSION_MAJOR < 2
+STATIC u8_t _lwip_raw_incoming(void *arg, struct raw_pcb *pcb, struct pbuf *p, ip_addr_t *addr)
+#else
+STATIC u8_t _lwip_raw_incoming(void *arg, struct raw_pcb *pcb, struct pbuf *p, const ip_addr_t *addr)
+#endif
+{
+    lwip_socket_obj_t *socket = (lwip_socket_obj_t *)arg;
+
+    if (socket->incoming.pbuf != NULL) {
+        pbuf_free(p);
+    } else {
+        socket->incoming.pbuf = p;
+        memcpy(&socket->peer, addr, sizeof(socket->peer));
     }
+    return 1; // we ate the packet
 }
+#endif
 
 // Callback for incoming UDP packets. We simply stash the packet and the source address,
 // in case we need it for recvfrom.
@@ -364,7 +391,7 @@ STATIC void _lwip_udp_incoming(void *arg, struct udp_pcb *upcb, struct pbuf *p,
 STATIC void _lwip_udp_incoming(void *arg, struct udp_pcb *upcb, struct pbuf *p, const ip_addr_t *addr, u16_t port)
 #endif
 {
-    lwip_socket_obj_t *socket = (lwip_socket_obj_t*)arg;
+    lwip_socket_obj_t *socket = (lwip_socket_obj_t *)arg;
 
     if (socket->incoming.pbuf != NULL) {
         // That's why they call it "unreliable". No room in the inn, drop the packet.
@@ -378,7 +405,7 @@ STATIC void _lwip_udp_incoming(void *arg, struct udp_pcb *upcb, struct pbuf *p,
 
 // Callback for general tcp errors.
 STATIC void _lwip_tcp_error(void *arg, err_t err) {
-    lwip_socket_obj_t *socket = (lwip_socket_obj_t*)arg;
+    lwip_socket_obj_t *socket = (lwip_socket_obj_t *)arg;
 
     // Free any incoming buffers or connections that are stored
     lwip_socket_free_incoming(socket);
@@ -390,7 +417,7 @@ STATIC void _lwip_tcp_error(void *arg, err_t err) {
 
 // Callback for tcp connection requests. Error code err is unused. (See tcp.h)
 STATIC err_t _lwip_tcp_connected(void *arg, struct tcp_pcb *tpcb, err_t err) {
-    lwip_socket_obj_t *socket = (lwip_socket_obj_t*)arg;
+    lwip_socket_obj_t *socket = (lwip_socket_obj_t *)arg;
 
     socket->state = STATE_CONNECTED;
     return ERR_OK;
@@ -399,15 +426,15 @@ STATIC err_t _lwip_tcp_connected(void *arg, struct tcp_pcb *tpcb, err_t err) {
 // Handle errors (eg connection aborted) on TCP PCBs that have been put on the
 // accept queue but are not yet actually accepted.
 STATIC void _lwip_tcp_err_unaccepted(void *arg, err_t err) {
-    struct tcp_pcb *pcb = (struct tcp_pcb*)arg;
+    struct tcp_pcb *pcb = (struct tcp_pcb *)arg;
 
     // The ->connected entry is repurposed to store the parent socket; this is safe
     // because it's only ever used by lwIP if tcp_connect is called on the TCP PCB.
-    lwip_socket_obj_t *socket = (lwip_socket_obj_t*)pcb->connected;
+    lwip_socket_obj_t *socket = (lwip_socket_obj_t *)pcb->connected;
 
     // Array is not volatile because thiss callback is executed within the lwIP context
     uint8_t alloc = socket->incoming.connection.alloc;
-    struct tcp_pcb **tcp_array = (struct tcp_pcb**)lwip_socket_incoming_array(socket);
+    struct tcp_pcb **tcp_array = (struct tcp_pcb **)lwip_socket_incoming_array(socket);
 
     // Search for PCB on the accept queue of the parent socket
     struct tcp_pcb **shift_down = NULL;
@@ -442,18 +469,6 @@ STATIC err_t _lwip_tcp_recv_unaccepted(void *arg, struct tcp_pcb *pcb, struct pb
     return ERR_BUF;
 }
 
-// "Poll" (idle) callback to be called ASAP after accept callback
-// to execute Python callback function, as it can't be executed
-// from accept callback itself.
-STATIC err_t _lwip_tcp_accept_finished(void *arg, struct tcp_pcb *pcb)
-{
-    // The ->connected entry of the pcb holds the listening socket of the accept
-    lwip_socket_obj_t *socket = (lwip_socket_obj_t*)pcb->connected;
-    tcp_poll(pcb, NULL, 0);
-    exec_user_callback(socket);
-    return ERR_OK;
-}
-
 // Callback for incoming tcp connections.
 STATIC err_t _lwip_tcp_accept(void *arg, struct tcp_pcb *newpcb, err_t err) {
     // err can be ERR_MEM to notify us that there was no memory for an incoming connection
@@ -461,7 +476,7 @@ STATIC err_t _lwip_tcp_accept(void *arg, struct tcp_pcb *newpcb, err_t err) {
         return ERR_OK;
     }
 
-    lwip_socket_obj_t *socket = (lwip_socket_obj_t*)arg;
+    lwip_socket_obj_t *socket = (lwip_socket_obj_t *)arg;
     tcp_recv(newpcb, _lwip_tcp_recv_unaccepted);
 
     // Search for an empty slot to store the new connection
@@ -472,18 +487,15 @@ STATIC err_t _lwip_tcp_accept(void *arg, struct tcp_pcb *newpcb, err_t err) {
         if (++socket->incoming.connection.iput >= socket->incoming.connection.alloc) {
             socket->incoming.connection.iput = 0;
         }
-        if (socket->callback != MP_OBJ_NULL) {
-            // Schedule accept callback to be called when lwIP is done
-            // with processing this incoming connection on its side and
-            // is idle.
-            tcp_poll(newpcb, _lwip_tcp_accept_finished, 1);
-        }
+
+        // Schedule user accept callback
+        exec_user_callback(socket);
 
         // Set the error callback to handle the case of a dropped connection before we
         // have a chance to take it off the accept queue.
         // The ->connected entry is repurposed to store the parent socket; this is safe
         // because it's only ever used by lwIP if tcp_connect is called on the TCP PCB.
-        newpcb->connected = (void*)socket;
+        newpcb->connected = (void *)socket;
         tcp_arg(newpcb, newpcb);
         tcp_err(newpcb, _lwip_tcp_err_unaccepted);
 
@@ -496,7 +508,7 @@ STATIC err_t _lwip_tcp_accept(void *arg, struct tcp_pcb *newpcb, err_t err) {
 
 // Callback for inbound tcp packets.
 STATIC err_t _lwip_tcp_recv(void *arg, struct tcp_pcb *tcpb, struct pbuf *p, err_t err) {
-    lwip_socket_obj_t *socket = (lwip_socket_obj_t*)arg;
+    lwip_socket_obj_t *socket = (lwip_socket_obj_t *)arg;
 
     if (p == NULL) {
         // Other side has closed connection.
@@ -525,8 +537,8 @@ STATIC err_t _lwip_tcp_recv(void *arg, struct tcp_pcb *tcpb, struct pbuf *p, err
 // Functions for socket send/receive operations. Socket send/recv and friends call
 // these to do the work.
 
-// Helper function for send/sendto to handle UDP packets.
-STATIC mp_uint_t lwip_udp_send(lwip_socket_obj_t *socket, const byte *buf, mp_uint_t len, byte *ip, mp_uint_t port, int *_errno) {
+// Helper function for send/sendto to handle raw/UDP packets.
+STATIC mp_uint_t lwip_raw_udp_send(lwip_socket_obj_t *socket, const byte *buf, mp_uint_t len, byte *ip, mp_uint_t port, int *_errno) {
     if (len > 0xffff) {
         // Any packet that big is probably going to fail the pbuf_alloc anyway, but may as well try
         len = 0xffff;
@@ -546,11 +558,25 @@ STATIC mp_uint_t lwip_udp_send(lwip_socket_obj_t *socket, const byte *buf, mp_ui
 
     err_t err;
     if (ip == NULL) {
-        err = udp_send(socket->pcb.udp, p);
+        #if MICROPY_PY_LWIP_SOCK_RAW
+        if (socket->type == MOD_NETWORK_SOCK_RAW) {
+            err = raw_send(socket->pcb.raw, p);
+        } else
+        #endif
+        {
+            err = udp_send(socket->pcb.udp, p);
+        }
     } else {
         ip_addr_t dest;
         IP4_ADDR(&dest, ip[0], ip[1], ip[2], ip[3]);
-        err = udp_sendto(socket->pcb.udp, p, &dest, port);
+        #if MICROPY_PY_LWIP_SOCK_RAW
+        if (socket->type == MOD_NETWORK_SOCK_RAW) {
+            err = raw_sendto(socket->pcb.raw, p, &dest);
+        } else
+        #endif
+        {
+            err = udp_sendto(socket->pcb.udp, p, &dest, port);
+        }
     }
 
     pbuf_free(p);
@@ -568,23 +594,24 @@ STATIC mp_uint_t lwip_udp_send(lwip_socket_obj_t *socket, const byte *buf, mp_ui
     return len;
 }
 
-// Helper function for recv/recvfrom to handle UDP packets
-STATIC mp_uint_t lwip_udp_receive(lwip_socket_obj_t *socket, byte *buf, mp_uint_t len, byte *ip, mp_uint_t *port, int *_errno) {
+// Helper function for recv/recvfrom to handle raw/UDP packets
+STATIC mp_uint_t lwip_raw_udp_receive(lwip_socket_obj_t *socket, byte *buf, mp_uint_t len, byte *ip, mp_uint_t *port, int *_errno) {
 
     if (socket->incoming.pbuf == NULL) {
-        if (socket->timeout != -1) {
-            for (mp_uint_t retries = socket->timeout / 100; retries--;) {
-                mp_hal_delay_ms(100);
-                if (socket->incoming.pbuf != NULL) break;
-            }
-            if (socket->incoming.pbuf == NULL) {
+        if (socket->timeout == 0) {
+            // Non-blocking socket.
+            *_errno = MP_EAGAIN;
+            return -1;
+        }
+
+        // Wait for data to arrive on UDP socket.
+        mp_uint_t start = mp_hal_ticks_ms();
+        while (socket->incoming.pbuf == NULL) {
+            if (socket->timeout != -1 && mp_hal_ticks_ms() - start > socket->timeout) {
                 *_errno = MP_ETIMEDOUT;
                 return -1;
             }
-        } else {
-            while (socket->incoming.pbuf == NULL) {
-                poll_sockets();
-            }
+            poll_sockets();
         }
     }
 
@@ -603,25 +630,25 @@ STATIC mp_uint_t lwip_udp_receive(lwip_socket_obj_t *socket, byte *buf, mp_uint_
 
     MICROPY_PY_LWIP_EXIT
 
-    return (mp_uint_t) result;
+    return (mp_uint_t)result;
 }
 
 // For use in stream virtual methods
 #define STREAM_ERROR_CHECK(socket) \
-        if (socket->state < 0) { \
-            *_errno = error_lookup_table[-socket->state]; \
-            return MP_STREAM_ERROR; \
-        } \
-        assert(socket->pcb.tcp);
+    if (socket->state < 0) { \
+        *_errno = error_lookup_table[-socket->state]; \
+        return MP_STREAM_ERROR; \
+    } \
+    assert(socket->pcb.tcp);
 
 // Version of above for use when lock is held
 #define STREAM_ERROR_CHECK_WITH_LOCK(socket) \
-        if (socket->state < 0) { \
-            *_errno = error_lookup_table[-socket->state]; \
-            MICROPY_PY_LWIP_EXIT \
-            return MP_STREAM_ERROR; \
-        } \
-        assert(socket->pcb.tcp);
+    if (socket->state < 0) { \
+        *_errno = error_lookup_table[-socket->state]; \
+        MICROPY_PY_LWIP_EXIT \
+        return MP_STREAM_ERROR; \
+    } \
+    assert(socket->pcb.tcp);
 
 
 // Helper function for send/sendto to handle TCP packets
@@ -664,7 +691,25 @@ STATIC mp_uint_t lwip_tcp_send(lwip_socket_obj_t *socket, const byte *buf, mp_ui
 
     u16_t write_len = MIN(available, len);
 
-    err_t err = tcp_write(socket->pcb.tcp, buf, write_len, TCP_WRITE_FLAG_COPY);
+    // If tcp_write returns ERR_MEM then there's currently not enough memory to
+    // queue the write, so wait and keep trying until it succeeds (with 10s limit).
+    // Note: if the socket is non-blocking then this code will actually block until
+    // there's enough memory to do the write, but by this stage we have already
+    // committed to being able to write the data.
+    err_t err;
+    for (int i = 0; i < 200; ++i) {
+        err = tcp_write(socket->pcb.tcp, buf, write_len, TCP_WRITE_FLAG_COPY);
+        if (err != ERR_MEM) {
+            break;
+        }
+        err = tcp_output(socket->pcb.tcp);
+        if (err != ERR_OK) {
+            break;
+        }
+        MICROPY_PY_LWIP_EXIT
+        mp_hal_delay_ms(50);
+        MICROPY_PY_LWIP_REENTER
+    }
 
     // If the output buffer is getting full then send the data to the lower layers
     if (err == ERR_OK && tcp_sndbuf(socket->pcb.tcp) < TCP_SND_BUF / 4) {
@@ -729,7 +774,7 @@ STATIC mp_uint_t lwip_tcp_receive(lwip_socket_obj_t *socket, byte *buf, mp_uint_
         len = remaining;
     }
 
-    memcpy(buf, (byte*)p->payload + socket->recv_offset, len);
+    memcpy(buf, (byte *)p->payload + socket->recv_offset, len);
 
     remaining -= len;
     if (remaining == 0) {
@@ -767,9 +812,13 @@ STATIC mp_obj_t lwip_socket_make_new(const mp_obj_type_t *type, size_t n_args, s
 
     lwip_socket_obj_t *socket = m_new_obj_with_finaliser(lwip_socket_obj_t);
     socket->base.type = &lwip_socket_type;
+    socket->timeout = -1;
+    socket->recv_offset = 0;
     socket->domain = MOD_NETWORK_AF_INET;
     socket->type = MOD_NETWORK_SOCK_STREAM;
     socket->callback = MP_OBJ_NULL;
+    socket->state = STATE_NEW;
+
     if (n_args >= 1) {
         socket->domain = mp_obj_get_int(args[0]);
         if (n_args >= 2) {
@@ -787,8 +836,15 @@ STATIC mp_obj_t lwip_socket_make_new(const mp_obj_type_t *type, size_t n_args, s
             socket->pcb.udp = udp_new();
             socket->incoming.pbuf = NULL;
             break;
-        //case MOD_NETWORK_SOCK_RAW: socket->pcb.raw = raw_new(); break;
-        default: mp_raise_OSError(MP_EINVAL);
+        #if MICROPY_PY_LWIP_SOCK_RAW
+        case MOD_NETWORK_SOCK_RAW: {
+            mp_int_t proto = n_args <= 2 ? 0 : mp_obj_get_int(args[2]);
+            socket->pcb.raw = raw_new(proto);
+            break;
+        }
+        #endif
+        default:
+            mp_raise_OSError(MP_EINVAL);
     }
 
     if (socket->pcb.tcp == NULL) {
@@ -798,22 +854,28 @@ STATIC mp_obj_t lwip_socket_make_new(const mp_obj_type_t *type, size_t n_args, s
     switch (socket->type) {
         case MOD_NETWORK_SOCK_STREAM: {
             // Register the socket object as our callback argument.
-            tcp_arg(socket->pcb.tcp, (void*)socket);
+            tcp_arg(socket->pcb.tcp, (void *)socket);
             // Register our error callback.
             tcp_err(socket->pcb.tcp, _lwip_tcp_error);
             break;
         }
         case MOD_NETWORK_SOCK_DGRAM: {
+            socket->state = STATE_ACTIVE_UDP;
             // Register our receive callback now. Since UDP sockets don't require binding or connection
             // before use, there's no other good time to do it.
-            udp_recv(socket->pcb.udp, _lwip_udp_incoming, (void*)socket);
+            udp_recv(socket->pcb.udp, _lwip_udp_incoming, (void *)socket);
+            break;
+        }
+        #if MICROPY_PY_LWIP_SOCK_RAW
+        case MOD_NETWORK_SOCK_RAW: {
+            // Register our receive callback now. Since raw sockets don't require binding or connection
+            // before use, there's no other good time to do it.
+            raw_recv(socket->pcb.raw, _lwip_raw_incoming, (void *)socket);
             break;
         }
+        #endif
     }
 
-    socket->timeout = -1;
-    socket->state = STATE_NEW;
-    socket->recv_offset = 0;
     return MP_OBJ_FROM_PTR(socket);
 }
 
@@ -869,7 +931,7 @@ STATIC mp_obj_t lwip_socket_listen(mp_obj_t self_in, mp_obj_t backlog_in) {
         socket->incoming.connection.tcp.item = NULL;
     } else {
         socket->incoming.connection.alloc = backlog;
-        socket->incoming.connection.tcp.array = m_new0(struct tcp_pcb*, backlog);
+        socket->incoming.connection.tcp.array = m_new0(struct tcp_pcb *, backlog);
     }
     socket->incoming.connection.iget = 0;
     socket->incoming.connection.iput = 0;
@@ -953,7 +1015,7 @@ STATIC mp_obj_t lwip_socket_accept(mp_obj_t self_in) {
     socket2->state = STATE_CONNECTED;
     socket2->recv_offset = 0;
     socket2->callback = MP_OBJ_NULL;
-    tcp_arg(socket2->pcb.tcp, (void*)socket2);
+    tcp_arg(socket2->pcb.tcp, (void *)socket2);
     tcp_err(socket2->pcb.tcp, _lwip_tcp_error);
     tcp_recv(socket2->pcb.tcp, _lwip_tcp_recv);
 
@@ -1016,7 +1078,9 @@ STATIC mp_obj_t lwip_socket_connect(mp_obj_t self_in, mp_obj_t addr_in) {
             if (socket->timeout != -1) {
                 for (mp_uint_t retries = socket->timeout / 100; retries--;) {
                     mp_hal_delay_ms(100);
-                    if (socket->state != STATE_CONNECTING) break;
+                    if (socket->state != STATE_CONNECTING) {
+                        break;
+                    }
                 }
                 if (socket->state == STATE_CONNECTING) {
                     mp_raise_OSError(MP_EINPROGRESS);
@@ -1027,9 +1091,9 @@ STATIC mp_obj_t lwip_socket_connect(mp_obj_t self_in, mp_obj_t addr_in) {
                 }
             }
             if (socket->state == STATE_CONNECTED) {
-               err = ERR_OK;
+                err = ERR_OK;
             } else {
-               err = socket->state;
+                err = socket->state;
             }
             break;
         }
@@ -1037,6 +1101,12 @@ STATIC mp_obj_t lwip_socket_connect(mp_obj_t self_in, mp_obj_t addr_in) {
             err = udp_connect(socket->pcb.udp, &dest, port);
             break;
         }
+        #if MICROPY_PY_LWIP_SOCK_RAW
+        case MOD_NETWORK_SOCK_RAW: {
+            err = raw_connect(socket->pcb.raw, &dest);
+            break;
+        }
+        #endif
     }
 
     if (err != ERR_OK) {
@@ -1071,10 +1141,12 @@ STATIC mp_obj_t lwip_socket_send(mp_obj_t self_in, mp_obj_t buf_in) {
             ret = lwip_tcp_send(socket, bufinfo.buf, bufinfo.len, &_errno);
             break;
         }
-        case MOD_NETWORK_SOCK_DGRAM: {
-            ret = lwip_udp_send(socket, bufinfo.buf, bufinfo.len, NULL, 0, &_errno);
+        case MOD_NETWORK_SOCK_DGRAM:
+        #if MICROPY_PY_LWIP_SOCK_RAW
+        case MOD_NETWORK_SOCK_RAW:
+        #endif
+            ret = lwip_raw_udp_send(socket, bufinfo.buf, bufinfo.len, NULL, 0, &_errno);
             break;
-        }
     }
     if (ret == -1) {
         mp_raise_OSError(_errno);
@@ -1097,13 +1169,15 @@ STATIC mp_obj_t lwip_socket_recv(mp_obj_t self_in, mp_obj_t len_in) {
     mp_uint_t ret = 0;
     switch (socket->type) {
         case MOD_NETWORK_SOCK_STREAM: {
-            ret = lwip_tcp_receive(socket, (byte*)vstr.buf, len, &_errno);
+            ret = lwip_tcp_receive(socket, (byte *)vstr.buf, len, &_errno);
             break;
         }
-        case MOD_NETWORK_SOCK_DGRAM: {
-            ret = lwip_udp_receive(socket, (byte*)vstr.buf, len, NULL, NULL, &_errno);
+        case MOD_NETWORK_SOCK_DGRAM:
+        #if MICROPY_PY_LWIP_SOCK_RAW
+        case MOD_NETWORK_SOCK_RAW:
+        #endif
+            ret = lwip_raw_udp_receive(socket, (byte *)vstr.buf, len, NULL, NULL, &_errno);
             break;
-        }
     }
     if (ret == -1) {
         mp_raise_OSError(_errno);
@@ -1135,10 +1209,12 @@ STATIC mp_obj_t lwip_socket_sendto(mp_obj_t self_in, mp_obj_t data_in, mp_obj_t
             ret = lwip_tcp_send(socket, bufinfo.buf, bufinfo.len, &_errno);
             break;
         }
-        case MOD_NETWORK_SOCK_DGRAM: {
-            ret = lwip_udp_send(socket, bufinfo.buf, bufinfo.len, ip, port, &_errno);
+        case MOD_NETWORK_SOCK_DGRAM:
+        #if MICROPY_PY_LWIP_SOCK_RAW
+        case MOD_NETWORK_SOCK_RAW:
+        #endif
+            ret = lwip_raw_udp_send(socket, bufinfo.buf, bufinfo.len, ip, port, &_errno);
             break;
-        }
     }
     if (ret == -1) {
         mp_raise_OSError(_errno);
@@ -1164,14 +1240,16 @@ STATIC mp_obj_t lwip_socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in) {
     switch (socket->type) {
         case MOD_NETWORK_SOCK_STREAM: {
             memcpy(ip, &socket->peer, sizeof(socket->peer));
-            port = (mp_uint_t) socket->peer_port;
-            ret = lwip_tcp_receive(socket, (byte*)vstr.buf, len, &_errno);
+            port = (mp_uint_t)socket->peer_port;
+            ret = lwip_tcp_receive(socket, (byte *)vstr.buf, len, &_errno);
             break;
         }
-        case MOD_NETWORK_SOCK_DGRAM: {
-            ret = lwip_udp_receive(socket, (byte*)vstr.buf, len, ip, &port, &_errno);
+        case MOD_NETWORK_SOCK_DGRAM:
+        #if MICROPY_PY_LWIP_SOCK_RAW
+        case MOD_NETWORK_SOCK_RAW:
+        #endif
+            ret = lwip_raw_udp_receive(socket, (byte *)vstr.buf, len, ip, &port, &_errno);
             break;
-        }
     }
     if (ret == -1) {
         mp_raise_OSError(_errno);
@@ -1218,7 +1296,7 @@ STATIC mp_obj_t lwip_socket_sendall(mp_obj_t self_in, mp_obj_t buf_in) {
                     mp_raise_OSError(_errno);
                 }
                 bufinfo.len -= ret;
-                bufinfo.buf = (char*)bufinfo.buf + ret;
+                bufinfo.buf = (char *)bufinfo.buf + ret;
             }
             break;
         }
@@ -1238,7 +1316,7 @@ STATIC mp_obj_t lwip_socket_settimeout(mp_obj_t self_in, mp_obj_t timeout_in) {
         timeout = -1;
     } else {
         #if MICROPY_PY_BUILTINS_FLOAT
-        timeout = 1000 * mp_obj_get_float(timeout_in);
+        timeout = (mp_uint_t)(MICROPY_FLOAT_CONST(1000.0) * mp_obj_get_float(timeout_in));
         #else
         timeout = 1000 * mp_obj_get_int(timeout_in);
         #endif
@@ -1296,7 +1374,7 @@ STATIC mp_obj_t lwip_socket_setsockopt(size_t n_args, const mp_obj_t *args) {
             }
 
             // POSIX setsockopt has order: group addr, if addr, lwIP has it vice-versa
-            err_t err = igmp_joingroup((ip_addr_t*)bufinfo.buf + 1, bufinfo.buf);
+            err_t err = igmp_joingroup((ip_addr_t *)bufinfo.buf + 1, bufinfo.buf);
             if (err != ERR_OK) {
                 mp_raise_OSError(error_lookup_table[-err]);
             }
@@ -1323,7 +1401,10 @@ STATIC mp_uint_t lwip_socket_read(mp_obj_t self_in, void *buf, mp_uint_t size, i
         case MOD_NETWORK_SOCK_STREAM:
             return lwip_tcp_receive(socket, buf, size, errcode);
         case MOD_NETWORK_SOCK_DGRAM:
-            return lwip_udp_receive(socket, buf, size, NULL, NULL, errcode);
+        #if MICROPY_PY_LWIP_SOCK_RAW
+        case MOD_NETWORK_SOCK_RAW:
+        #endif
+            return lwip_raw_udp_receive(socket, buf, size, NULL, NULL, errcode);
     }
     // Unreachable
     return MP_STREAM_ERROR;
@@ -1336,12 +1417,22 @@ STATIC mp_uint_t lwip_socket_write(mp_obj_t self_in, const void *buf, mp_uint_t
         case MOD_NETWORK_SOCK_STREAM:
             return lwip_tcp_send(socket, buf, size, errcode);
         case MOD_NETWORK_SOCK_DGRAM:
-            return lwip_udp_send(socket, buf, size, NULL, 0, errcode);
+        #if MICROPY_PY_LWIP_SOCK_RAW
+        case MOD_NETWORK_SOCK_RAW:
+        #endif
+            return lwip_raw_udp_send(socket, buf, size, NULL, 0, errcode);
     }
     // Unreachable
     return MP_STREAM_ERROR;
 }
 
+STATIC err_t _lwip_tcp_close_poll(void *arg, struct tcp_pcb *pcb) {
+    // Connection has not been cleanly closed so just abort it to free up memory
+    tcp_poll(pcb, NULL, 0);
+    tcp_abort(pcb);
+    return ERR_OK;
+}
+
 STATIC mp_uint_t lwip_socket_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
     lwip_socket_obj_t *socket = MP_OBJ_TO_PTR(self_in);
     mp_uint_t ret;
@@ -1370,6 +1461,11 @@ STATIC mp_uint_t lwip_socket_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_
             if (socket->type == MOD_NETWORK_SOCK_DGRAM && socket->pcb.udp != NULL) {
                 // UDP socket is writable
                 ret |= MP_STREAM_POLL_WR;
+            #if MICROPY_PY_LWIP_SOCK_RAW
+            } else if (socket->type == MOD_NETWORK_SOCK_RAW && socket->pcb.raw != NULL) {
+                // raw socket is writable
+                ret |= MP_STREAM_POLL_WR;
+            #endif
             } else if (socket->pcb.tcp != NULL && tcp_sndbuf(socket->pcb.tcp) > 0) {
                 // TCP socket is writable
                 // Note: pcb.tcp==NULL if state<0, and in this case we can't call tcp_sndbuf
@@ -1379,7 +1475,7 @@ STATIC mp_uint_t lwip_socket_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_
 
         if (socket->state == STATE_NEW) {
             // New sockets are not connected so set HUP
-            ret |= flags & MP_STREAM_POLL_HUP;
+            ret |= MP_STREAM_POLL_HUP;
         } else if (socket->state == STATE_PEER_CLOSED) {
             // Peer-closed socket is both readable and writable: read will
             // return EOF, write - error. Without this poll will hang on a
@@ -1387,11 +1483,14 @@ STATIC mp_uint_t lwip_socket_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_
             ret |= flags & (MP_STREAM_POLL_RD | MP_STREAM_POLL_WR);
         } else if (socket->state == ERR_RST) {
             // Socket was reset by peer, a write will return an error
-            ret |= flags & (MP_STREAM_POLL_WR | MP_STREAM_POLL_HUP);
+            ret |= flags & MP_STREAM_POLL_WR;
+            ret |= MP_STREAM_POLL_HUP;
+        } else if (socket->state == _ERR_BADF) {
+            ret |= MP_STREAM_POLL_NVAL;
         } else if (socket->state < 0) {
             // Socket in some other error state, use catch-all ERR flag
             // TODO: may need to set other return flags here
-            ret |= flags & MP_STREAM_POLL_ERR;
+            ret |= MP_STREAM_POLL_ERR;
         }
 
     } else if (request == MP_STREAM_CLOSE) {
@@ -1401,20 +1500,37 @@ STATIC mp_uint_t lwip_socket_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_
         }
 
         // Deregister callback (pcb.tcp is set to NULL below so must deregister now)
+        tcp_arg(socket->pcb.tcp, NULL);
+        tcp_err(socket->pcb.tcp, NULL);
         tcp_recv(socket->pcb.tcp, NULL);
 
+        // Free any incoming buffers or connections that are stored
+        lwip_socket_free_incoming(socket);
+
         switch (socket->type) {
             case MOD_NETWORK_SOCK_STREAM: {
+                if (socket->pcb.tcp->state != LISTEN) {
+                    // Schedule a callback to abort the connection if it's not cleanly closed after
+                    // the given timeout.  The callback must be set before calling tcp_close since
+                    // the latter may free the pcb; if it doesn't then the callback will be active.
+                    tcp_poll(socket->pcb.tcp, _lwip_tcp_close_poll, MICROPY_PY_LWIP_TCP_CLOSE_TIMEOUT_MS / 500);
+                }
                 if (tcp_close(socket->pcb.tcp) != ERR_OK) {
                     DEBUG_printf("lwip_close: had to call tcp_abort()\n");
                     tcp_abort(socket->pcb.tcp);
                 }
                 break;
             }
-            case MOD_NETWORK_SOCK_DGRAM: udp_remove(socket->pcb.udp); break;
-            //case MOD_NETWORK_SOCK_RAW: raw_remove(socket->pcb.raw); break;
+            case MOD_NETWORK_SOCK_DGRAM:
+                udp_remove(socket->pcb.udp);
+                break;
+            #if MICROPY_PY_LWIP_SOCK_RAW
+            case MOD_NETWORK_SOCK_RAW:
+                raw_remove(socket->pcb.raw);
+                break;
+            #endif
         }
-        lwip_socket_free_incoming(socket);
+
         socket->pcb.tcp = NULL;
         socket->state = _ERR_BADF;
         ret = 0;
@@ -1465,7 +1581,7 @@ STATIC const mp_obj_type_t lwip_socket_type = {
     .print = lwip_socket_print,
     .make_new = lwip_socket_make_new,
     .protocol = &lwip_socket_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&lwip_socket_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&lwip_socket_locals_dict,
 };
 
 /******************************************************************************/
@@ -1485,18 +1601,18 @@ void sys_arch_unprotect(sys_prot_t state) {
 // itself a "list" but isn't; we only support a single interface.
 
 typedef struct nic_poll {
-    void (* poll)(void *arg);
+    void (*poll)(void *arg);
     void *poll_arg;
 } nic_poll_t;
 
 STATIC nic_poll_t lwip_poll_list;
 
-void mod_lwip_register_poll(void (* poll)(void *arg), void *poll_arg) {
+void mod_lwip_register_poll(void (*poll)(void *arg), void *poll_arg) {
     lwip_poll_list.poll = poll;
     lwip_poll_list.poll_arg = poll_arg;
 }
 
-void mod_lwip_deregister_poll(void (* poll)(void *arg), void *poll_arg) {
+void mod_lwip_deregister_poll(void (*poll)(void *arg), void *poll_arg) {
     lwip_poll_list.poll = NULL;
 }
 
@@ -1563,9 +1679,9 @@ STATIC mp_obj_t lwip_getaddrinfo(size_t n_args, const mp_obj_t *args) {
             }
         }
         if (!((family == 0 || family == MOD_NETWORK_AF_INET)
-            && (type == 0 || type == MOD_NETWORK_SOCK_STREAM)
-            && proto == 0
-            && flags == 0)) {
+              && (type == 0 || type == MOD_NETWORK_SOCK_STREAM)
+              && proto == 0
+              && flags == 0)) {
             mp_warning(MP_WARN_CAT(RuntimeWarning), "unsupported getaddrinfo constraints");
         }
     }
@@ -1574,7 +1690,7 @@ STATIC mp_obj_t lwip_getaddrinfo(size_t n_args, const mp_obj_t *args) {
     state.status = 0;
 
     MICROPY_PY_LWIP_ENTER
-    err_t ret = dns_gethostbyname(host, (ip_addr_t*)&state.ipaddr, lwip_getaddrinfo_cb, &state);
+    err_t ret = dns_gethostbyname(host, (ip_addr_t *)&state.ipaddr, lwip_getaddrinfo_cb, &state);
     MICROPY_PY_LWIP_EXIT
 
     switch (ret) {
@@ -1602,8 +1718,8 @@ STATIC mp_obj_t lwip_getaddrinfo(size_t n_args, const mp_obj_t *args) {
     tuple->items[1] = MP_OBJ_NEW_SMALL_INT(MOD_NETWORK_SOCK_STREAM);
     tuple->items[2] = MP_OBJ_NEW_SMALL_INT(0);
     tuple->items[3] = MP_OBJ_NEW_QSTR(MP_QSTR_);
-    tuple->items[4] = netutils_format_inet_addr((uint8_t*)&state.ipaddr, port, NETUTILS_BIG);
-    return mp_obj_new_list(1, (mp_obj_t*)&tuple);
+    tuple->items[4] = netutils_format_inet_addr((uint8_t *)&state.ipaddr, port, NETUTILS_BIG);
+    return mp_obj_new_list(1, (mp_obj_t *)&tuple);
 }
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(lwip_getaddrinfo_obj, 2, 6, lwip_getaddrinfo);
 
@@ -1625,16 +1741,18 @@ STATIC const mp_rom_map_elem_t mp_module_lwip_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_print_pcbs), MP_ROM_PTR(&lwip_print_pcbs_obj) },
     // objects
     { MP_ROM_QSTR(MP_QSTR_socket), MP_ROM_PTR(&lwip_socket_type) },
-#ifdef MICROPY_PY_LWIP_SLIP
+    #ifdef MICROPY_PY_LWIP_SLIP
     { MP_ROM_QSTR(MP_QSTR_slip), MP_ROM_PTR(&lwip_slip_type) },
-#endif
+    #endif
     // class constants
     { MP_ROM_QSTR(MP_QSTR_AF_INET), MP_ROM_INT(MOD_NETWORK_AF_INET) },
     { MP_ROM_QSTR(MP_QSTR_AF_INET6), MP_ROM_INT(MOD_NETWORK_AF_INET6) },
 
     { MP_ROM_QSTR(MP_QSTR_SOCK_STREAM), MP_ROM_INT(MOD_NETWORK_SOCK_STREAM) },
     { MP_ROM_QSTR(MP_QSTR_SOCK_DGRAM), MP_ROM_INT(MOD_NETWORK_SOCK_DGRAM) },
+    #if MICROPY_PY_LWIP_SOCK_RAW
     { MP_ROM_QSTR(MP_QSTR_SOCK_RAW), MP_ROM_INT(MOD_NETWORK_SOCK_RAW) },
+    #endif
 
     { MP_ROM_QSTR(MP_QSTR_SOL_SOCKET), MP_ROM_INT(1) },
     { MP_ROM_QSTR(MP_QSTR_SO_REUSEADDR), MP_ROM_INT(SOF_REUSEADDR) },
@@ -1647,7 +1765,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_lwip_globals, mp_module_lwip_globals_table
 
 const mp_obj_module_t mp_module_lwip = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_lwip_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_lwip_globals,
 };
 
 #endif // MICROPY_PY_LWIP
diff --git a/extmod/modonewire.c b/extmod/modonewire.c
index 7ef4c3bce8c6a..210bee366ee9d 100644
--- a/extmod/modonewire.c
+++ b/extmod/modonewire.c
@@ -126,7 +126,7 @@ STATIC mp_obj_t onewire_crc8(mp_obj_t data) {
     mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
     uint8_t crc = 0;
     for (size_t i = 0; i < bufinfo.len; ++i) {
-        uint8_t byte = ((uint8_t*)bufinfo.buf)[i];
+        uint8_t byte = ((uint8_t *)bufinfo.buf)[i];
         for (int b = 0; b < 8; ++b) {
             uint8_t fb_bit = (crc ^ byte) & 0x01;
             if (fb_bit == 0x01) {
@@ -158,5 +158,5 @@ STATIC MP_DEFINE_CONST_DICT(onewire_module_globals, onewire_module_globals_table
 
 const mp_obj_module_t mp_module_onewire = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&onewire_module_globals,
+    .globals = (mp_obj_dict_t *)&onewire_module_globals,
 };
diff --git a/extmod/moduasyncio.c b/extmod/moduasyncio.c
new file mode 100644
index 0000000000000..0b15c9e0790a5
--- /dev/null
+++ b/extmod/moduasyncio.c
@@ -0,0 +1,294 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/smallint.h"
+#include "py/pairheap.h"
+#include "py/mphal.h"
+
+#if MICROPY_PY_UASYNCIO
+
+typedef struct _mp_obj_task_t {
+    mp_pairheap_t pairheap;
+    mp_obj_t coro;
+    mp_obj_t data;
+    mp_obj_t waiting;
+
+    mp_obj_t ph_key;
+} mp_obj_task_t;
+
+typedef struct _mp_obj_task_queue_t {
+    mp_obj_base_t base;
+    mp_obj_task_t *heap;
+} mp_obj_task_queue_t;
+
+STATIC const mp_obj_type_t task_queue_type;
+STATIC const mp_obj_type_t task_type;
+
+STATIC mp_obj_t task_queue_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args);
+
+/******************************************************************************/
+// Ticks for task ordering in pairing heap
+
+STATIC mp_obj_t ticks(void) {
+    return MP_OBJ_NEW_SMALL_INT(mp_hal_ticks_ms() & (MICROPY_PY_UTIME_TICKS_PERIOD - 1));
+}
+
+STATIC mp_int_t ticks_diff(mp_obj_t t1_in, mp_obj_t t0_in) {
+    mp_uint_t t0 = MP_OBJ_SMALL_INT_VALUE(t0_in);
+    mp_uint_t t1 = MP_OBJ_SMALL_INT_VALUE(t1_in);
+    mp_int_t diff = ((t1 - t0 + MICROPY_PY_UTIME_TICKS_PERIOD / 2) & (MICROPY_PY_UTIME_TICKS_PERIOD - 1))
+        - MICROPY_PY_UTIME_TICKS_PERIOD / 2;
+    return diff;
+}
+
+STATIC int task_lt(mp_pairheap_t *n1, mp_pairheap_t *n2) {
+    mp_obj_task_t *t1 = (mp_obj_task_t *)n1;
+    mp_obj_task_t *t2 = (mp_obj_task_t *)n2;
+    return MP_OBJ_SMALL_INT_VALUE(ticks_diff(t1->ph_key, t2->ph_key)) < 0;
+}
+
+/******************************************************************************/
+// TaskQueue class
+
+STATIC mp_obj_t task_queue_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    (void)args;
+    mp_arg_check_num(n_args, n_kw, 0, 0, false);
+    mp_obj_task_queue_t *self = m_new_obj(mp_obj_task_queue_t);
+    self->base.type = type;
+    self->heap = (mp_obj_task_t *)mp_pairheap_new(task_lt);
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC mp_obj_t task_queue_peek(mp_obj_t self_in) {
+    mp_obj_task_queue_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self->heap == NULL) {
+        return mp_const_none;
+    } else {
+        return MP_OBJ_FROM_PTR(self->heap);
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(task_queue_peek_obj, task_queue_peek);
+
+STATIC mp_obj_t task_queue_push_sorted(size_t n_args, const mp_obj_t *args) {
+    mp_obj_task_queue_t *self = MP_OBJ_TO_PTR(args[0]);
+    mp_obj_task_t *task = MP_OBJ_TO_PTR(args[1]);
+    task->data = mp_const_none;
+    if (n_args == 2) {
+        task->ph_key = ticks();
+    } else {
+        assert(mp_obj_is_small_int(args[2]));
+        task->ph_key = args[2];
+    }
+    self->heap = (mp_obj_task_t *)mp_pairheap_push(task_lt, &self->heap->pairheap, &task->pairheap);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(task_queue_push_sorted_obj, 2, 3, task_queue_push_sorted);
+
+STATIC mp_obj_t task_queue_pop_head(mp_obj_t self_in) {
+    mp_obj_task_queue_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_obj_task_t *head = (mp_obj_task_t *)mp_pairheap_peek(task_lt, &self->heap->pairheap);
+    if (head == NULL) {
+        mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("empty heap"));
+    }
+    self->heap = (mp_obj_task_t *)mp_pairheap_pop(task_lt, &self->heap->pairheap);
+    return MP_OBJ_FROM_PTR(head);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(task_queue_pop_head_obj, task_queue_pop_head);
+
+STATIC mp_obj_t task_queue_remove(mp_obj_t self_in, mp_obj_t task_in) {
+    mp_obj_task_queue_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_obj_task_t *task = MP_OBJ_TO_PTR(task_in);
+    self->heap = (mp_obj_task_t *)mp_pairheap_delete(task_lt, &self->heap->pairheap, &task->pairheap);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(task_queue_remove_obj, task_queue_remove);
+
+STATIC const mp_rom_map_elem_t task_queue_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_peek), MP_ROM_PTR(&task_queue_peek_obj) },
+    { MP_ROM_QSTR(MP_QSTR_push_sorted), MP_ROM_PTR(&task_queue_push_sorted_obj) },
+    { MP_ROM_QSTR(MP_QSTR_push_head), MP_ROM_PTR(&task_queue_push_sorted_obj) },
+    { MP_ROM_QSTR(MP_QSTR_pop_head), MP_ROM_PTR(&task_queue_pop_head_obj) },
+    { MP_ROM_QSTR(MP_QSTR_remove), MP_ROM_PTR(&task_queue_remove_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(task_queue_locals_dict, task_queue_locals_dict_table);
+
+STATIC const mp_obj_type_t task_queue_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_TaskQueue,
+    .make_new = task_queue_make_new,
+    .locals_dict = (mp_obj_dict_t *)&task_queue_locals_dict,
+};
+
+/******************************************************************************/
+// Task class
+
+// This is the core uasyncio context with cur_task, _task_queue and CancelledError.
+STATIC mp_obj_t uasyncio_context = MP_OBJ_NULL;
+
+STATIC mp_obj_t task_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 1, 2, false);
+    mp_obj_task_t *self = m_new_obj(mp_obj_task_t);
+    self->pairheap.base.type = type;
+    mp_pairheap_init_node(task_lt, &self->pairheap);
+    self->coro = args[0];
+    self->data = mp_const_none;
+    self->waiting = mp_const_none;
+    self->ph_key = MP_OBJ_NEW_SMALL_INT(0);
+    if (n_args == 2) {
+        uasyncio_context = args[1];
+    }
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC mp_obj_t task_cancel(mp_obj_t self_in) {
+    mp_obj_task_t *self = MP_OBJ_TO_PTR(self_in);
+    // Check if task is already finished.
+    if (self->coro == mp_const_none) {
+        return mp_const_false;
+    }
+    // Can't cancel self (not supported yet).
+    mp_obj_t cur_task = mp_obj_dict_get(uasyncio_context, MP_OBJ_NEW_QSTR(MP_QSTR_cur_task));
+    if (self_in == cur_task) {
+        mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("can't cancel self"));
+    }
+    // If Task waits on another task then forward the cancel to the one it's waiting on.
+    while (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(mp_obj_get_type(self->data)), MP_OBJ_FROM_PTR(&task_type))) {
+        self = MP_OBJ_TO_PTR(self->data);
+    }
+
+    mp_obj_t _task_queue = mp_obj_dict_get(uasyncio_context, MP_OBJ_NEW_QSTR(MP_QSTR__task_queue));
+
+    // Reschedule Task as a cancelled task.
+    mp_obj_t dest[3];
+    mp_load_method_maybe(self->data, MP_QSTR_remove, dest);
+    if (dest[0] != MP_OBJ_NULL) {
+        // Not on the main running queue, remove the task from the queue it's on.
+        dest[2] = MP_OBJ_FROM_PTR(self);
+        mp_call_method_n_kw(1, 0, dest);
+        // _task_queue.push_head(self)
+        dest[0] = _task_queue;
+        dest[1] = MP_OBJ_FROM_PTR(self);
+        task_queue_push_sorted(2, dest);
+    } else if (ticks_diff(self->ph_key, ticks()) > 0) {
+        // On the main running queue but scheduled in the future, so bring it forward to now.
+        // _task_queue.remove(self)
+        task_queue_remove(_task_queue, MP_OBJ_FROM_PTR(self));
+        // _task_queue.push_head(self)
+        dest[0] = _task_queue;
+        dest[1] = MP_OBJ_FROM_PTR(self);
+        task_queue_push_sorted(2, dest);
+    }
+
+    self->data = mp_obj_dict_get(uasyncio_context, MP_OBJ_NEW_QSTR(MP_QSTR_CancelledError));
+
+    return mp_const_true;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(task_cancel_obj, task_cancel);
+
+STATIC void task_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
+    mp_obj_task_t *self = MP_OBJ_TO_PTR(self_in);
+    if (dest[0] == MP_OBJ_NULL) {
+        // Load
+        if (attr == MP_QSTR_coro) {
+            dest[0] = self->coro;
+        } else if (attr == MP_QSTR_data) {
+            dest[0] = self->data;
+        } else if (attr == MP_QSTR_waiting) {
+            if (self->waiting != mp_const_none) {
+                dest[0] = self->waiting;
+            }
+        } else if (attr == MP_QSTR_cancel) {
+            dest[0] = MP_OBJ_FROM_PTR(&task_cancel_obj);
+            dest[1] = self_in;
+        } else if (attr == MP_QSTR_ph_key) {
+            dest[0] = self->ph_key;
+        }
+    } else if (dest[1] != MP_OBJ_NULL) {
+        // Store
+        if (attr == MP_QSTR_coro) {
+            self->coro = dest[1];
+            dest[0] = MP_OBJ_NULL;
+        } else if (attr == MP_QSTR_data) {
+            self->data = dest[1];
+            dest[0] = MP_OBJ_NULL;
+        } else if (attr == MP_QSTR_waiting) {
+            self->waiting = dest[1];
+            dest[0] = MP_OBJ_NULL;
+        }
+    }
+}
+
+STATIC mp_obj_t task_getiter(mp_obj_t self_in, mp_obj_iter_buf_t *iter_buf) {
+    (void)iter_buf;
+    mp_obj_task_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self->waiting == mp_const_none) {
+        self->waiting = task_queue_make_new(&task_queue_type, 0, 0, NULL);
+    }
+    return self_in;
+}
+
+STATIC mp_obj_t task_iternext(mp_obj_t self_in) {
+    mp_obj_task_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self->coro == mp_const_none) {
+        // Task finished, raise return value to caller so it can continue.
+        nlr_raise(self->data);
+    } else {
+        // Put calling task on waiting queue.
+        mp_obj_t cur_task = mp_obj_dict_get(uasyncio_context, MP_OBJ_NEW_QSTR(MP_QSTR_cur_task));
+        mp_obj_t args[2] = { self->waiting, cur_task };
+        task_queue_push_sorted(2, args);
+        // Set calling task's data to this task that it waits on, to double-link it.
+        ((mp_obj_task_t *)MP_OBJ_TO_PTR(cur_task))->data = self_in;
+    }
+    return mp_const_none;
+}
+
+STATIC const mp_obj_type_t task_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Task,
+    .make_new = task_make_new,
+    .attr = task_attr,
+    .getiter = task_getiter,
+    .iternext = task_iternext,
+};
+
+/******************************************************************************/
+// C-level uasyncio module
+
+STATIC const mp_rom_map_elem_t mp_module_uasyncio_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR__uasyncio) },
+    { MP_ROM_QSTR(MP_QSTR_TaskQueue), MP_ROM_PTR(&task_queue_type) },
+    { MP_ROM_QSTR(MP_QSTR_Task), MP_ROM_PTR(&task_type) },
+};
+STATIC MP_DEFINE_CONST_DICT(mp_module_uasyncio_globals, mp_module_uasyncio_globals_table);
+
+const mp_obj_module_t mp_module_uasyncio = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&mp_module_uasyncio_globals,
+};
+
+#endif // MICROPY_PY_UASYNCIO
diff --git a/extmod/modubinascii.c b/extmod/modubinascii.c
index 8256a50cf2042..1d4c72b24b45a 100644
--- a/extmod/modubinascii.c
+++ b/extmod/modubinascii.c
@@ -30,9 +30,10 @@
 
 #include "py/runtime.h"
 #include "py/binary.h"
-#include "extmod/modubinascii.h"
 
-mp_obj_t mod_binascii_hexlify(size_t n_args, const mp_obj_t *args) {
+#if MICROPY_PY_UBINASCII
+
+STATIC mp_obj_t mod_binascii_hexlify(size_t n_args, const mp_obj_t *args) {
     // Second argument is for an extension to allow a separator to be used
     // between values.
     const char *sep = NULL;
@@ -53,7 +54,7 @@ mp_obj_t mod_binascii_hexlify(size_t n_args, const mp_obj_t *args) {
         sep = mp_obj_str_get_str(args[1]);
     }
     vstr_init_len(&vstr, out_len);
-    byte *in = bufinfo.buf, *out = (byte*)vstr.buf;
+    byte *in = bufinfo.buf, *out = (byte *)vstr.buf;
     for (mp_uint_t i = bufinfo.len; i--;) {
         byte d = (*in >> 4);
         if (d > 9) {
@@ -71,25 +72,25 @@ mp_obj_t mod_binascii_hexlify(size_t n_args, const mp_obj_t *args) {
     }
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
-MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_binascii_hexlify_obj, 1, 2, mod_binascii_hexlify);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_binascii_hexlify_obj, 1, 2, mod_binascii_hexlify);
 
-mp_obj_t mod_binascii_unhexlify(mp_obj_t data) {
+STATIC mp_obj_t mod_binascii_unhexlify(mp_obj_t data) {
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
 
     if ((bufinfo.len & 1) != 0) {
-        mp_raise_ValueError("odd-length string");
+        mp_raise_ValueError(MP_ERROR_TEXT("odd-length string"));
     }
     vstr_t vstr;
     vstr_init_len(&vstr, bufinfo.len / 2);
-    byte *in = bufinfo.buf, *out = (byte*)vstr.buf;
+    byte *in = bufinfo.buf, *out = (byte *)vstr.buf;
     byte hex_byte = 0;
     for (mp_uint_t i = bufinfo.len; i--;) {
         byte hex_ch = *in++;
         if (unichar_isxdigit(hex_ch)) {
             hex_byte += unichar_xdigit_value(hex_ch);
         } else {
-            mp_raise_ValueError("non-hex digit found");
+            mp_raise_ValueError(MP_ERROR_TEXT("non-hex digit found"));
         }
         if (i & 1) {
             hex_byte <<= 4;
@@ -100,7 +101,7 @@ mp_obj_t mod_binascii_unhexlify(mp_obj_t data) {
     }
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
-MP_DEFINE_CONST_FUN_OBJ_1(mod_binascii_unhexlify_obj, mod_binascii_unhexlify);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_binascii_unhexlify_obj, mod_binascii_unhexlify);
 
 // If ch is a character in the base64 alphabet, and is not a pad character, then
 // the corresponding integer between 0 and 63, inclusively, is returned.
@@ -121,7 +122,7 @@ static int mod_binascii_sextet(byte ch) {
     }
 }
 
-mp_obj_t mod_binascii_a2b_base64(mp_obj_t data) {
+STATIC mp_obj_t mod_binascii_a2b_base64(mp_obj_t data) {
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
     byte *in = bufinfo.buf;
@@ -157,14 +158,14 @@ mp_obj_t mod_binascii_a2b_base64(mp_obj_t data) {
     }
 
     if (nbits) {
-        mp_raise_ValueError("incorrect padding");
+        mp_raise_ValueError(MP_ERROR_TEXT("incorrect padding"));
     }
 
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
-MP_DEFINE_CONST_FUN_OBJ_1(mod_binascii_a2b_base64_obj, mod_binascii_a2b_base64);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_binascii_a2b_base64_obj, mod_binascii_a2b_base64);
 
-mp_obj_t mod_binascii_b2a_base64(mp_obj_t data) {
+STATIC mp_obj_t mod_binascii_b2a_base64(mp_obj_t data) {
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
 
@@ -172,7 +173,7 @@ mp_obj_t mod_binascii_b2a_base64(mp_obj_t data) {
     vstr_init_len(&vstr, ((bufinfo.len != 0) ? (((bufinfo.len - 1) / 3) + 1) * 4 : 0) + 1);
 
     // First pass, we convert input buffer to numeric base 64 values
-    byte *in = bufinfo.buf, *out = (byte*)vstr.buf;
+    byte *in = bufinfo.buf, *out = (byte *)vstr.buf;
     mp_uint_t i;
     for (i = bufinfo.len; i >= 3; i -= 3) {
         *out++ = (in[0] & 0xFC) >> 2;
@@ -186,8 +187,7 @@ mp_obj_t mod_binascii_b2a_base64(mp_obj_t data) {
         if (i == 2) {
             *out++ = (in[0] & 0x03) << 4 | (in[1] & 0xF0) >> 4;
             *out++ = (in[1] & 0x0F) << 2;
-        }
-        else {
+        } else {
             *out++ = (in[0] & 0x03) << 4;
             *out++ = 64;
         }
@@ -195,7 +195,7 @@ mp_obj_t mod_binascii_b2a_base64(mp_obj_t data) {
     }
 
     // Second pass, we convert number base 64 values to actual base64 ascii encoding
-    out = (byte*)vstr.buf;
+    out = (byte *)vstr.buf;
     for (mp_uint_t j = vstr.len - 1; j--;) {
         if (*out < 26) {
             *out += 'A';
@@ -204,7 +204,7 @@ mp_obj_t mod_binascii_b2a_base64(mp_obj_t data) {
         } else if (*out < 62) {
             *out += '0' - 52;
         } else if (*out == 62) {
-            *out ='+';
+            *out = '+';
         } else if (*out == 63) {
             *out = '/';
         } else {
@@ -215,23 +215,21 @@ mp_obj_t mod_binascii_b2a_base64(mp_obj_t data) {
     *out = '\n';
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
-MP_DEFINE_CONST_FUN_OBJ_1(mod_binascii_b2a_base64_obj, mod_binascii_b2a_base64);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_binascii_b2a_base64_obj, mod_binascii_b2a_base64);
 
 #if MICROPY_PY_UBINASCII_CRC32
 #include "uzlib/tinf.h"
 
-mp_obj_t mod_binascii_crc32(size_t n_args, const mp_obj_t *args) {
+STATIC mp_obj_t mod_binascii_crc32(size_t n_args, const mp_obj_t *args) {
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(args[0], &bufinfo, MP_BUFFER_READ);
     uint32_t crc = (n_args > 1) ? mp_obj_get_int_truncated(args[1]) : 0;
     crc = uzlib_crc32(bufinfo.buf, bufinfo.len, crc ^ 0xffffffff);
     return mp_obj_new_int_from_uint(crc ^ 0xffffffff);
 }
-MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_binascii_crc32_obj, 1, 2, mod_binascii_crc32);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_binascii_crc32_obj, 1, 2, mod_binascii_crc32);
 #endif
 
-#if MICROPY_PY_UBINASCII
-
 STATIC const mp_rom_map_elem_t mp_module_binascii_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_ubinascii) },
     { MP_ROM_QSTR(MP_QSTR_hexlify), MP_ROM_PTR(&mod_binascii_hexlify_obj) },
@@ -247,7 +245,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_binascii_globals, mp_module_binascii_globa
 
 const mp_obj_module_t mp_module_ubinascii = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_binascii_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_binascii_globals,
 };
 
-#endif //MICROPY_PY_UBINASCII
+#endif // MICROPY_PY_UBINASCII
diff --git a/extmod/moducryptolib.c b/extmod/moducryptolib.c
index af9eec624e98d..6c89d6d9fe81c 100644
--- a/extmod/moducryptolib.c
+++ b/extmod/moducryptolib.c
@@ -41,10 +41,17 @@
 
 // values follow PEP 272
 enum {
-    UCRYPTOLIB_MODE_MIN = 0,
-    UCRYPTOLIB_MODE_ECB,
-    UCRYPTOLIB_MODE_CBC,
-    UCRYPTOLIB_MODE_MAX,
+    UCRYPTOLIB_MODE_ECB = 1,
+    UCRYPTOLIB_MODE_CBC = 2,
+    UCRYPTOLIB_MODE_CTR = 6,
+};
+
+struct ctr_params {
+    // counter is the IV of the AES context.
+
+    size_t offset; // in encrypted_counter
+    // encrypted counter
+    uint8_t encrypted_counter[16];
 };
 
 #if MICROPY_SSL_AXTLS
@@ -75,13 +82,26 @@ struct mbedtls_aes_ctx_with_key {
 typedef struct _mp_obj_aes_t {
     mp_obj_base_t base;
     AES_CTX_IMPL ctx;
-    uint8_t block_mode: 6;
+    uint8_t block_mode : 6;
 #define AES_KEYTYPE_NONE 0
 #define AES_KEYTYPE_ENC  1
 #define AES_KEYTYPE_DEC  2
-    uint8_t key_type: 2;
+    uint8_t key_type : 2;
 } mp_obj_aes_t;
 
+static inline bool is_ctr_mode(int block_mode) {
+    #if MICROPY_PY_UCRYPTOLIB_CTR
+    return block_mode == UCRYPTOLIB_MODE_CTR;
+    #else
+    return false;
+    #endif
+}
+
+static inline struct ctr_params *ctr_params_from_aes(mp_obj_aes_t *o) {
+    // ctr_params follows aes object struct
+    return (struct ctr_params *)&o[1];
+}
+
 #if MICROPY_SSL_AXTLS
 STATIC void aes_initial_set_key_impl(AES_CTX_IMPL *ctx, const uint8_t *key, size_t keysize, const uint8_t iv[16]) {
     assert(16 == keysize || 32 == keysize);
@@ -97,7 +117,7 @@ STATIC void aes_final_set_key_impl(AES_CTX_IMPL *ctx, bool encrypt) {
 STATIC void aes_process_ecb_impl(AES_CTX_IMPL *ctx, const uint8_t in[16], uint8_t out[16], bool encrypt) {
     memcpy(out, in, 16);
     // We assume that out (vstr.buf or given output buffer) is uint32_t aligned
-    uint32_t *p = (uint32_t*)out;
+    uint32_t *p = (uint32_t *)out;
     // axTLS likes it weird and complicated with byteswaps
     for (int i = 0; i < 4; i++) {
         p[i] = MP_HTOBE32(p[i]);
@@ -119,6 +139,33 @@ STATIC void aes_process_cbc_impl(AES_CTX_IMPL *ctx, const uint8_t *in, uint8_t *
         AES_cbc_decrypt(ctx, in, out, in_len);
     }
 }
+
+#if MICROPY_PY_UCRYPTOLIB_CTR
+// axTLS doesn't have CTR support out of the box. This implements the counter part using the ECB primitive.
+STATIC void aes_process_ctr_impl(AES_CTX_IMPL *ctx, const uint8_t *in, uint8_t *out, size_t in_len, struct ctr_params *ctr_params) {
+    size_t n = ctr_params->offset;
+    uint8_t *const counter = ctx->iv;
+
+    while (in_len--) {
+        if (n == 0) {
+            aes_process_ecb_impl(ctx, counter, ctr_params->encrypted_counter, true);
+
+            // increment the 128-bit counter
+            for (int i = 15; i >= 0; --i) {
+                if (++counter[i] != 0) {
+                    break;
+                }
+            }
+        }
+
+        *out++ = *in++ ^ ctr_params->encrypted_counter[n];
+        n = (n + 1) & 0xf;
+    }
+
+    ctr_params->offset = n;
+}
+#endif
+
 #endif
 
 #if MICROPY_SSL_MBEDTLS
@@ -155,24 +202,42 @@ STATIC void aes_process_ecb_impl(AES_CTX_IMPL *ctx, const uint8_t in[16], uint8_
 STATIC void aes_process_cbc_impl(AES_CTX_IMPL *ctx, const uint8_t *in, uint8_t *out, size_t in_len, bool encrypt) {
     mbedtls_aes_crypt_cbc(&ctx->u.mbedtls_ctx, encrypt ? MBEDTLS_AES_ENCRYPT : MBEDTLS_AES_DECRYPT, in_len, ctx->iv, in, out);
 }
+
+#if MICROPY_PY_UCRYPTOLIB_CTR
+STATIC void aes_process_ctr_impl(AES_CTX_IMPL *ctx, const uint8_t *in, uint8_t *out, size_t in_len, struct ctr_params *ctr_params) {
+    mbedtls_aes_crypt_ctr(&ctx->u.mbedtls_ctx, in_len, &ctr_params->offset, ctx->iv, ctr_params->encrypted_counter, in, out);
+}
+#endif
+
 #endif
 
 STATIC mp_obj_t ucryptolib_aes_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 2, 3, false);
-    mp_obj_aes_t *o = m_new_obj(mp_obj_aes_t);
-    o->base.type = type;
 
-    o->block_mode = mp_obj_get_int(args[1]);
-    o->key_type = AES_KEYTYPE_NONE;
+    const mp_int_t block_mode = mp_obj_get_int(args[1]);
+
+    switch (block_mode) {
+        case UCRYPTOLIB_MODE_ECB:
+        case UCRYPTOLIB_MODE_CBC:
+        #if MICROPY_PY_UCRYPTOLIB_CTR
+        case UCRYPTOLIB_MODE_CTR:
+        #endif
+            break;
 
-    if (o->block_mode <= UCRYPTOLIB_MODE_MIN || o->block_mode >= UCRYPTOLIB_MODE_MAX) {
-        mp_raise_ValueError("mode");
+        default:
+            mp_raise_ValueError(MP_ERROR_TEXT("mode"));
     }
 
+    mp_obj_aes_t *o = m_new_obj_var(mp_obj_aes_t, struct ctr_params, !!is_ctr_mode(block_mode));
+    o->base.type = type;
+
+    o->block_mode = block_mode;
+    o->key_type = AES_KEYTYPE_NONE;
+
     mp_buffer_info_t keyinfo;
     mp_get_buffer_raise(args[0], &keyinfo, MP_BUFFER_READ);
     if (32 != keyinfo.len && 16 != keyinfo.len) {
-        mp_raise_ValueError("key");
+        mp_raise_ValueError(MP_ERROR_TEXT("key"));
     }
 
     mp_buffer_info_t ivinfo;
@@ -181,10 +246,14 @@ STATIC mp_obj_t ucryptolib_aes_make_new(const mp_obj_type_t *type, size_t n_args
         mp_get_buffer_raise(args[2], &ivinfo, MP_BUFFER_READ);
 
         if (16 != ivinfo.len) {
-            mp_raise_ValueError("IV");
+            mp_raise_ValueError(MP_ERROR_TEXT("IV"));
         }
-    } else if (o->block_mode == UCRYPTOLIB_MODE_CBC) {
-        mp_raise_ValueError("IV");
+    } else if (o->block_mode == UCRYPTOLIB_MODE_CBC || is_ctr_mode(o->block_mode)) {
+        mp_raise_ValueError(MP_ERROR_TEXT("IV"));
+    }
+
+    if (is_ctr_mode(block_mode)) {
+        ctr_params_from_aes(o)->offset = 0;
     }
 
     aes_initial_set_key_impl(&o->ctx, keyinfo.buf, keyinfo.len, ivinfo.buf);
@@ -204,8 +273,8 @@ STATIC mp_obj_t aes_process(size_t n_args, const mp_obj_t *args, bool encrypt) {
     mp_buffer_info_t in_bufinfo;
     mp_get_buffer_raise(in_buf, &in_bufinfo, MP_BUFFER_READ);
 
-    if (in_bufinfo.len % 16 != 0) {
-        mp_raise_ValueError("blksize % 16");
+    if (!is_ctr_mode(self->block_mode) && in_bufinfo.len % 16 != 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("blksize % 16"));
     }
 
     vstr_t vstr;
@@ -215,33 +284,47 @@ STATIC mp_obj_t aes_process(size_t n_args, const mp_obj_t *args, bool encrypt) {
     if (out_buf != MP_OBJ_NULL) {
         mp_get_buffer_raise(out_buf, &out_bufinfo, MP_BUFFER_WRITE);
         if (out_bufinfo.len < in_bufinfo.len) {
-            mp_raise_ValueError("output too small");
+            mp_raise_ValueError(MP_ERROR_TEXT("output too small"));
         }
         out_buf_ptr = out_bufinfo.buf;
     } else {
         vstr_init_len(&vstr, in_bufinfo.len);
-        out_buf_ptr = (uint8_t*)vstr.buf;
+        out_buf_ptr = (uint8_t *)vstr.buf;
     }
 
     if (AES_KEYTYPE_NONE == self->key_type) {
-        aes_final_set_key_impl(&self->ctx, encrypt);
+        // always set key for encryption if CTR mode.
+        const bool encrypt_mode = encrypt || is_ctr_mode(self->block_mode);
+        aes_final_set_key_impl(&self->ctx, encrypt_mode);
         self->key_type = encrypt ? AES_KEYTYPE_ENC : AES_KEYTYPE_DEC;
     } else {
         if ((encrypt && self->key_type == AES_KEYTYPE_DEC) ||
             (!encrypt && self->key_type == AES_KEYTYPE_ENC)) {
 
-            mp_raise_ValueError("can't encrypt & decrypt");
+            mp_raise_ValueError(MP_ERROR_TEXT("can't encrypt & decrypt"));
         }
     }
 
-    if (self->block_mode == UCRYPTOLIB_MODE_ECB) {
-        uint8_t *in = in_bufinfo.buf, *out = out_buf_ptr;
-        uint8_t *top = in + in_bufinfo.len;
-        for (; in < top; in += 16, out += 16) {
-            aes_process_ecb_impl(&self->ctx, in, out, encrypt);
+    switch (self->block_mode) {
+        case UCRYPTOLIB_MODE_ECB: {
+            uint8_t *in = in_bufinfo.buf, *out = out_buf_ptr;
+            uint8_t *top = in + in_bufinfo.len;
+            for (; in < top; in += 16, out += 16) {
+                aes_process_ecb_impl(&self->ctx, in, out, encrypt);
+            }
+            break;
         }
-    } else {
-        aes_process_cbc_impl(&self->ctx, in_bufinfo.buf, out_buf_ptr, in_bufinfo.len, encrypt);
+
+        case UCRYPTOLIB_MODE_CBC:
+            aes_process_cbc_impl(&self->ctx, in_bufinfo.buf, out_buf_ptr, in_bufinfo.len, encrypt);
+            break;
+
+        #if MICROPY_PY_UCRYPTOLIB_CTR
+        case UCRYPTOLIB_MODE_CTR:
+            aes_process_ctr_impl(&self->ctx, in_bufinfo.buf, out_buf_ptr, in_bufinfo.len,
+                ctr_params_from_aes(self));
+            break;
+        #endif
     }
 
     if (out_buf != MP_OBJ_NULL) {
@@ -270,23 +353,26 @@ STATIC const mp_obj_type_t ucryptolib_aes_type = {
     { &mp_type_type },
     .name = MP_QSTR_aes,
     .make_new = ucryptolib_aes_make_new,
-    .locals_dict = (void*)&ucryptolib_aes_locals_dict,
+    .locals_dict = (void *)&ucryptolib_aes_locals_dict,
 };
 
 STATIC const mp_rom_map_elem_t mp_module_ucryptolib_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_ucryptolib) },
     { MP_ROM_QSTR(MP_QSTR_aes), MP_ROM_PTR(&ucryptolib_aes_type) },
-#if MICROPY_PY_UCRYPTOLIB_CONSTS
+    #if MICROPY_PY_UCRYPTOLIB_CONSTS
     { MP_ROM_QSTR(MP_QSTR_MODE_ECB), MP_ROM_INT(UCRYPTOLIB_MODE_ECB) },
     { MP_ROM_QSTR(MP_QSTR_MODE_CBC), MP_ROM_INT(UCRYPTOLIB_MODE_CBC) },
-#endif
+    #if MICROPY_PY_UCRYPTOLIB_CTR
+    { MP_ROM_QSTR(MP_QSTR_MODE_CTR), MP_ROM_INT(UCRYPTOLIB_MODE_CTR) },
+    #endif
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(mp_module_ucryptolib_globals, mp_module_ucryptolib_globals_table);
 
 const mp_obj_module_t mp_module_ucryptolib = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_ucryptolib_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_ucryptolib_globals,
 };
 
-#endif //MICROPY_PY_UCRYPTOLIB
+#endif // MICROPY_PY_UCRYPTOLIB
diff --git a/extmod/moductypes.c b/extmod/moductypes.c
index 9b46371f36f3e..f7d2be1bc1487 100644
--- a/extmod/moductypes.c
+++ b/extmod/moductypes.c
@@ -117,14 +117,14 @@ typedef struct _mp_obj_uctypes_struct_t {
 } mp_obj_uctypes_struct_t;
 
 STATIC NORETURN void syntax_error(void) {
-    mp_raise_TypeError("syntax error in uctypes descriptor");
+    mp_raise_TypeError(MP_ERROR_TEXT("syntax error in uctypes descriptor"));
 }
 
 STATIC mp_obj_t uctypes_struct_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 2, 3, false);
     mp_obj_uctypes_struct_t *o = m_new_obj(mp_obj_uctypes_struct_t);
     o->base.type = type;
-    o->addr = (void*)(uintptr_t)mp_obj_int_get_truncated(args[0]);
+    o->addr = (void *)(uintptr_t)mp_obj_int_get_truncated(args[0]);
     o->desc = args[1];
     o->flags = LAYOUT_NATIVE;
     if (n_args == 3) {
@@ -138,18 +138,22 @@ STATIC void uctypes_struct_print(const mp_print_t *print, mp_obj_t self_in, mp_p
     mp_obj_uctypes_struct_t *self = MP_OBJ_TO_PTR(self_in);
     const char *typen = "unk";
     if (mp_obj_is_type(self->desc, &mp_type_dict)
-      #if MICROPY_PY_COLLECTIONS_ORDEREDDICT
+        #if MICROPY_PY_COLLECTIONS_ORDEREDDICT
         || mp_obj_is_type(self->desc, &mp_type_ordereddict)
-      #endif
-      ) {
+        #endif
+        ) {
         typen = "STRUCT";
     } else if (mp_obj_is_type(self->desc, &mp_type_tuple)) {
         mp_obj_tuple_t *t = MP_OBJ_TO_PTR(self->desc);
         mp_int_t offset = MP_OBJ_SMALL_INT_VALUE(t->items[0]);
         uint agg_type = GET_TYPE(offset, AGG_TYPE_BITS);
         switch (agg_type) {
-            case PTR: typen = "PTR"; break;
-            case ARRAY: typen = "ARRAY"; break;
+            case PTR:
+                typen = "PTR";
+                break;
+            case ARRAY:
+                typen = "ARRAY";
+                break;
         }
     } else {
         typen = "ERROR";
@@ -180,10 +184,10 @@ STATIC mp_uint_t uctypes_struct_agg_size(mp_obj_tuple_t *t, int layout_type, mp_
         case STRUCT:
             return uctypes_struct_size(t->items[1], layout_type, max_field_size);
         case PTR:
-            if (sizeof(void*) > *max_field_size) {
-                *max_field_size = sizeof(void*);
+            if (sizeof(void *) > *max_field_size) {
+                *max_field_size = sizeof(void *);
             }
-            return sizeof(void*);
+            return sizeof(void *);
         case ARRAY: {
             mp_int_t arr_sz = MP_OBJ_SMALL_INT_VALUE(t->items[1]);
             uint val_type = GET_TYPE(arr_sz, VAL_TYPE_BITS);
@@ -211,18 +215,18 @@ STATIC mp_uint_t uctypes_struct_agg_size(mp_obj_tuple_t *t, int layout_type, mp_
 
 STATIC mp_uint_t uctypes_struct_size(mp_obj_t desc_in, int layout_type, mp_uint_t *max_field_size) {
     if (!mp_obj_is_type(desc_in, &mp_type_dict)
-      #if MICROPY_PY_COLLECTIONS_ORDEREDDICT
+        #if MICROPY_PY_COLLECTIONS_ORDEREDDICT
         && !mp_obj_is_type(desc_in, &mp_type_ordereddict)
-      #endif
-      ) {
+        #endif
+        ) {
         if (mp_obj_is_type(desc_in, &mp_type_tuple)) {
-            return uctypes_struct_agg_size((mp_obj_tuple_t*)MP_OBJ_TO_PTR(desc_in), layout_type, max_field_size);
+            return uctypes_struct_agg_size((mp_obj_tuple_t *)MP_OBJ_TO_PTR(desc_in), layout_type, max_field_size);
         } else if (mp_obj_is_small_int(desc_in)) {
             // We allow sizeof on both type definitions and structures/structure fields,
             // but scalar structure field is lowered into native Python int, so all
             // type info is lost. So, we cannot say if it's scalar type description,
             // or such lowered scalar.
-            mp_raise_TypeError("Cannot unambiguously get sizeof scalar");
+            mp_raise_TypeError(MP_ERROR_TEXT("can't unambiguously get sizeof scalar"));
         }
         syntax_error();
     }
@@ -299,23 +303,23 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(uctypes_struct_sizeof_obj, 1, 2, ucty
 static inline mp_obj_t get_unaligned(uint val_type, byte *p, int big_endian) {
     char struct_type = big_endian ? '>' : '<';
     static const char type2char[16] = "BbHhIiQq------fd";
-    return mp_binary_get_val(struct_type, type2char[val_type], &p);
+    return mp_binary_get_val(struct_type, type2char[val_type], p, &p);
 }
 
 static inline void set_unaligned(uint val_type, byte *p, int big_endian, mp_obj_t val) {
     char struct_type = big_endian ? '>' : '<';
     static const char type2char[16] = "BbHhIiQq------fd";
-    mp_binary_set_val(struct_type, type2char[val_type], val, &p);
+    mp_binary_set_val(struct_type, type2char[val_type], val, p, &p);
 }
 
 static inline mp_uint_t get_aligned_basic(uint val_type, void *p) {
     switch (val_type) {
         case UINT8:
-            return *(uint8_t*)p;
+            return *(uint8_t *)p;
         case UINT16:
-            return *(uint16_t*)p;
+            return *(uint16_t *)p;
         case UINT32:
-            return *(uint32_t*)p;
+            return *(uint32_t *)p;
     }
     assert(0);
     return 0;
@@ -324,11 +328,14 @@ static inline mp_uint_t get_aligned_basic(uint val_type, void *p) {
 static inline void set_aligned_basic(uint val_type, void *p, mp_uint_t v) {
     switch (val_type) {
         case UINT8:
-            *(uint8_t*)p = (uint8_t)v; return;
+            *(uint8_t *)p = (uint8_t)v;
+            return;
         case UINT16:
-            *(uint16_t*)p = (uint16_t)v; return;
+            *(uint16_t *)p = (uint16_t)v;
+            return;
         case UINT32:
-            *(uint32_t*)p = (uint32_t)v; return;
+            *(uint32_t *)p = (uint32_t)v;
+            return;
     }
     assert(0);
 }
@@ -336,26 +343,26 @@ static inline void set_aligned_basic(uint val_type, void *p, mp_uint_t v) {
 STATIC mp_obj_t get_aligned(uint val_type, void *p, mp_int_t index) {
     switch (val_type) {
         case UINT8:
-            return MP_OBJ_NEW_SMALL_INT(((uint8_t*)p)[index]);
+            return MP_OBJ_NEW_SMALL_INT(((uint8_t *)p)[index]);
         case INT8:
-            return MP_OBJ_NEW_SMALL_INT(((int8_t*)p)[index]);
+            return MP_OBJ_NEW_SMALL_INT(((int8_t *)p)[index]);
         case UINT16:
-            return MP_OBJ_NEW_SMALL_INT(((uint16_t*)p)[index]);
+            return MP_OBJ_NEW_SMALL_INT(((uint16_t *)p)[index]);
         case INT16:
-            return MP_OBJ_NEW_SMALL_INT(((int16_t*)p)[index]);
+            return MP_OBJ_NEW_SMALL_INT(((int16_t *)p)[index]);
         case UINT32:
-            return mp_obj_new_int_from_uint(((uint32_t*)p)[index]);
+            return mp_obj_new_int_from_uint(((uint32_t *)p)[index]);
         case INT32:
-            return mp_obj_new_int(((int32_t*)p)[index]);
+            return mp_obj_new_int(((int32_t *)p)[index]);
         case UINT64:
-            return mp_obj_new_int_from_ull(((uint64_t*)p)[index]);
+            return mp_obj_new_int_from_ull(((uint64_t *)p)[index]);
         case INT64:
-            return mp_obj_new_int_from_ll(((int64_t*)p)[index]);
+            return mp_obj_new_int_from_ll(((int64_t *)p)[index]);
         #if MICROPY_PY_BUILTINS_FLOAT
         case FLOAT32:
-            return mp_obj_new_float(((float*)p)[index]);
+            return mp_obj_new_float_from_f(((float *)p)[index]);
         case FLOAT64:
-            return mp_obj_new_float(((double*)p)[index]);
+            return mp_obj_new_float_from_d(((double *)p)[index]);
         #endif
         default:
             assert(0);
@@ -366,11 +373,10 @@ STATIC mp_obj_t get_aligned(uint val_type, void *p, mp_int_t index) {
 STATIC void set_aligned(uint val_type, void *p, mp_int_t index, mp_obj_t val) {
     #if MICROPY_PY_BUILTINS_FLOAT
     if (val_type == FLOAT32 || val_type == FLOAT64) {
-        mp_float_t v = mp_obj_get_float(val);
         if (val_type == FLOAT32) {
-            ((float*)p)[index] = v;
+            ((float *)p)[index] = mp_obj_get_float_to_f(val);
         } else {
-            ((double*)p)[index] = v;
+            ((double *)p)[index] = mp_obj_get_float_to_d(val);
         }
         return;
     }
@@ -378,21 +384,27 @@ STATIC void set_aligned(uint val_type, void *p, mp_int_t index, mp_obj_t val) {
     mp_int_t v = mp_obj_get_int_truncated(val);
     switch (val_type) {
         case UINT8:
-            ((uint8_t*)p)[index] = (uint8_t)v; return;
+            ((uint8_t *)p)[index] = (uint8_t)v;
+            return;
         case INT8:
-            ((int8_t*)p)[index] = (int8_t)v; return;
+            ((int8_t *)p)[index] = (int8_t)v;
+            return;
         case UINT16:
-            ((uint16_t*)p)[index] = (uint16_t)v; return;
+            ((uint16_t *)p)[index] = (uint16_t)v;
+            return;
         case INT16:
-            ((int16_t*)p)[index] = (int16_t)v; return;
+            ((int16_t *)p)[index] = (int16_t)v;
+            return;
         case UINT32:
-            ((uint32_t*)p)[index] = (uint32_t)v; return;
+            ((uint32_t *)p)[index] = (uint32_t)v;
+            return;
         case INT32:
-            ((int32_t*)p)[index] = (int32_t)v; return;
+            ((int32_t *)p)[index] = (int32_t)v;
+            return;
         case INT64:
         case UINT64:
             if (sizeof(mp_int_t) == 8) {
-                ((uint64_t*)p)[index] = (uint64_t)v;
+                ((uint64_t *)p)[index] = (uint64_t)v;
             } else {
                 // TODO: Doesn't offer atomic store semantics, but should at least try
                 set_unaligned(val_type, p, MP_ENDIANNESS_BIG, val);
@@ -407,11 +419,11 @@ STATIC mp_obj_t uctypes_struct_attr_op(mp_obj_t self_in, qstr attr, mp_obj_t set
     mp_obj_uctypes_struct_t *self = MP_OBJ_TO_PTR(self_in);
 
     if (!mp_obj_is_type(self->desc, &mp_type_dict)
-      #if MICROPY_PY_COLLECTIONS_ORDEREDDICT
+        #if MICROPY_PY_COLLECTIONS_ORDEREDDICT
         && !mp_obj_is_type(self->desc, &mp_type_ordereddict)
-      #endif
-      ) {
-            mp_raise_TypeError("struct: no fields");
+        #endif
+        ) {
+        mp_raise_TypeError(MP_ERROR_TEXT("struct: no fields"));
     }
 
     mp_obj_t deref = mp_obj_dict_get(self->desc, MP_OBJ_NEW_QSTR(attr));
@@ -419,7 +431,7 @@ STATIC mp_obj_t uctypes_struct_attr_op(mp_obj_t self_in, qstr attr, mp_obj_t set
         mp_int_t offset = MP_OBJ_SMALL_INT_VALUE(deref);
         mp_uint_t val_type = GET_TYPE(offset, VAL_TYPE_BITS);
         offset &= VALUE_MASK(VAL_TYPE_BITS);
-//printf("scalar type=%d offset=%x\n", val_type, offset);
+// printf("scalar type=%d offset=%x\n", val_type, offset);
 
         if (val_type <= INT64 || val_type == FLOAT32 || val_type == FLOAT64) {
 //            printf("size=%d\n", GET_SCALAR_SIZE(val_type));
@@ -489,7 +501,7 @@ STATIC mp_obj_t uctypes_struct_attr_op(mp_obj_t self_in, qstr attr, mp_obj_t set
     mp_int_t offset = MP_OBJ_SMALL_INT_VALUE(sub->items[0]);
     mp_uint_t agg_type = GET_TYPE(offset, AGG_TYPE_BITS);
     offset &= VALUE_MASK(AGG_TYPE_BITS);
-//printf("agg type=%d offset=%x\n", agg_type, offset);
+// printf("agg type=%d offset=%x\n", agg_type, offset);
 
     switch (agg_type) {
         case STRUCT: {
@@ -513,7 +525,7 @@ STATIC mp_obj_t uctypes_struct_attr_op(mp_obj_t self_in, qstr attr, mp_obj_t set
             o->desc = MP_OBJ_FROM_PTR(sub);
             o->addr = self->addr + offset;
             o->flags = self->flags;
-//printf("PTR/ARR base addr=%p\n", o->addr);
+// printf("PTR/ARR base addr=%p\n", o->addr);
             return MP_OBJ_FROM_PTR(o);
         }
     }
@@ -544,7 +556,7 @@ STATIC mp_obj_t uctypes_struct_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_ob
     } else {
         // load / store
         if (!mp_obj_is_type(self->desc, &mp_type_tuple)) {
-            mp_raise_TypeError("struct: cannot index");
+            mp_raise_TypeError(MP_ERROR_TEXT("struct: can't index"));
         }
 
         mp_obj_tuple_t *t = MP_OBJ_TO_PTR(self->desc);
@@ -558,7 +570,7 @@ STATIC mp_obj_t uctypes_struct_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_ob
             uint val_type = GET_TYPE(arr_sz, VAL_TYPE_BITS);
             arr_sz &= VALUE_MASK(VAL_TYPE_BITS);
             if (index >= arr_sz) {
-                nlr_raise(mp_obj_new_exception_msg(&mp_type_IndexError, "struct: index out of range"));
+                mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("struct: index out of range"));
             }
 
             if (t->len == 2) {
@@ -593,7 +605,7 @@ STATIC mp_obj_t uctypes_struct_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_ob
             }
 
         } else if (agg_type == PTR) {
-            byte *p = *(void**)self->addr;
+            byte *p = *(void **)self->addr;
             if (mp_obj_is_small_int(t->items[1])) {
                 uint val_type = GET_TYPE(MP_OBJ_SMALL_INT_VALUE(t->items[1]), VAL_TYPE_BITS);
                 return get_aligned(val_type, p, index);
@@ -623,13 +635,14 @@ STATIC mp_obj_t uctypes_struct_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
                 mp_int_t offset = MP_OBJ_SMALL_INT_VALUE(t->items[0]);
                 uint agg_type = GET_TYPE(offset, AGG_TYPE_BITS);
                 if (agg_type == PTR) {
-                    byte *p = *(void**)self->addr;
+                    byte *p = *(void **)self->addr;
                     return mp_obj_new_int((mp_int_t)(uintptr_t)p);
                 }
             }
-            /* fallthru */
+        /* fallthru */
 
-        default: return MP_OBJ_NULL; // op not supported
+        default:
+            return MP_OBJ_NULL;      // op not supported
     }
 }
 
@@ -660,7 +673,7 @@ MP_DEFINE_CONST_FUN_OBJ_1(uctypes_struct_addressof_obj, uctypes_struct_addressof
 /// captured by reference (and thus memory pointed by bytearray may change
 /// or become invalid at later time). Use bytes_at() to capture by value.
 STATIC mp_obj_t uctypes_struct_bytearray_at(mp_obj_t ptr, mp_obj_t size) {
-    return mp_obj_new_bytearray_by_ref(mp_obj_int_get_truncated(size), (void*)(uintptr_t)mp_obj_int_get_truncated(ptr));
+    return mp_obj_new_bytearray_by_ref(mp_obj_int_get_truncated(size), (void *)(uintptr_t)mp_obj_int_get_truncated(ptr));
 }
 MP_DEFINE_CONST_FUN_OBJ_2(uctypes_struct_bytearray_at_obj, uctypes_struct_bytearray_at);
 
@@ -669,7 +682,7 @@ MP_DEFINE_CONST_FUN_OBJ_2(uctypes_struct_bytearray_at_obj, uctypes_struct_bytear
 /// captured by value, i.e. copied. Use bytearray_at() to capture by reference
 /// ("zero copy").
 STATIC mp_obj_t uctypes_struct_bytes_at(mp_obj_t ptr, mp_obj_t size) {
-    return mp_obj_new_bytes((void*)(uintptr_t)mp_obj_int_get_truncated(ptr), mp_obj_int_get_truncated(size));
+    return mp_obj_new_bytes((void *)(uintptr_t)mp_obj_int_get_truncated(ptr), mp_obj_int_get_truncated(size));
 }
 MP_DEFINE_CONST_FUN_OBJ_2(uctypes_struct_bytes_at_obj, uctypes_struct_bytes_at);
 
@@ -772,7 +785,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_uctypes_globals, mp_module_uctypes_globals
 
 const mp_obj_module_t mp_module_uctypes = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_uctypes_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_uctypes_globals,
 };
 
 #endif
diff --git a/extmod/moduhashlib.c b/extmod/moduhashlib.c
index 603cdb44a4be6..195a24334b69f 100644
--- a/extmod/moduhashlib.c
+++ b/extmod/moduhashlib.c
@@ -78,8 +78,8 @@ STATIC mp_obj_t uhashlib_sha256_make_new(const mp_obj_type_t *type, size_t n_arg
     mp_arg_check_num(n_args, n_kw, 0, 1, false);
     mp_obj_hash_t *o = m_new_obj_var(mp_obj_hash_t, char, sizeof(mbedtls_sha256_context));
     o->base.type = type;
-    mbedtls_sha256_init((mbedtls_sha256_context*)&o->state);
-    mbedtls_sha256_starts_ret((mbedtls_sha256_context*)&o->state, 0);
+    mbedtls_sha256_init((mbedtls_sha256_context *)&o->state);
+    mbedtls_sha256_starts_ret((mbedtls_sha256_context *)&o->state, 0);
     if (n_args == 1) {
         uhashlib_sha256_update(MP_OBJ_FROM_PTR(o), args[0]);
     }
@@ -90,7 +90,7 @@ STATIC mp_obj_t uhashlib_sha256_update(mp_obj_t self_in, mp_obj_t arg) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
-    mbedtls_sha256_update_ret((mbedtls_sha256_context*)&self->state, bufinfo.buf, bufinfo.len);
+    mbedtls_sha256_update_ret((mbedtls_sha256_context *)&self->state, bufinfo.buf, bufinfo.len);
     return mp_const_none;
 }
 
@@ -98,7 +98,7 @@ STATIC mp_obj_t uhashlib_sha256_digest(mp_obj_t self_in) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     vstr_t vstr;
     vstr_init_len(&vstr, 32);
-    mbedtls_sha256_finish_ret((mbedtls_sha256_context*)&self->state, (unsigned char *)vstr.buf);
+    mbedtls_sha256_finish_ret((mbedtls_sha256_context *)&self->state, (unsigned char *)vstr.buf);
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
 
@@ -110,7 +110,7 @@ STATIC mp_obj_t uhashlib_sha256_make_new(const mp_obj_type_t *type, size_t n_arg
     mp_arg_check_num(n_args, n_kw, 0, 1, false);
     mp_obj_hash_t *o = m_new_obj_var(mp_obj_hash_t, char, sizeof(CRYAL_SHA256_CTX));
     o->base.type = type;
-    sha256_init((CRYAL_SHA256_CTX*)o->state);
+    sha256_init((CRYAL_SHA256_CTX *)o->state);
     if (n_args == 1) {
         uhashlib_sha256_update(MP_OBJ_FROM_PTR(o), args[0]);
     }
@@ -121,7 +121,7 @@ STATIC mp_obj_t uhashlib_sha256_update(mp_obj_t self_in, mp_obj_t arg) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
-    sha256_update((CRYAL_SHA256_CTX*)self->state, bufinfo.buf, bufinfo.len);
+    sha256_update((CRYAL_SHA256_CTX *)self->state, bufinfo.buf, bufinfo.len);
     return mp_const_none;
 }
 
@@ -129,7 +129,7 @@ STATIC mp_obj_t uhashlib_sha256_digest(mp_obj_t self_in) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     vstr_t vstr;
     vstr_init_len(&vstr, SHA256_BLOCK_SIZE);
-    sha256_final((CRYAL_SHA256_CTX*)self->state, (byte*)vstr.buf);
+    sha256_final((CRYAL_SHA256_CTX *)self->state, (byte *)vstr.buf);
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
 #endif
@@ -148,7 +148,7 @@ STATIC const mp_obj_type_t uhashlib_sha256_type = {
     { &mp_type_type },
     .name = MP_QSTR_sha256,
     .make_new = uhashlib_sha256_make_new,
-    .locals_dict = (void*)&uhashlib_sha256_locals_dict,
+    .locals_dict = (void *)&uhashlib_sha256_locals_dict,
 };
 #endif
 
@@ -160,7 +160,7 @@ STATIC mp_obj_t uhashlib_sha1_make_new(const mp_obj_type_t *type, size_t n_args,
     mp_arg_check_num(n_args, n_kw, 0, 1, false);
     mp_obj_hash_t *o = m_new_obj_var(mp_obj_hash_t, char, sizeof(SHA1_CTX));
     o->base.type = type;
-    SHA1_Init((SHA1_CTX*)o->state);
+    SHA1_Init((SHA1_CTX *)o->state);
     if (n_args == 1) {
         uhashlib_sha1_update(MP_OBJ_FROM_PTR(o), args[0]);
     }
@@ -171,7 +171,7 @@ STATIC mp_obj_t uhashlib_sha1_update(mp_obj_t self_in, mp_obj_t arg) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
-    SHA1_Update((SHA1_CTX*)self->state, bufinfo.buf, bufinfo.len);
+    SHA1_Update((SHA1_CTX *)self->state, bufinfo.buf, bufinfo.len);
     return mp_const_none;
 }
 
@@ -179,7 +179,7 @@ STATIC mp_obj_t uhashlib_sha1_digest(mp_obj_t self_in) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     vstr_t vstr;
     vstr_init_len(&vstr, SHA1_SIZE);
-    SHA1_Final((byte*)vstr.buf, (SHA1_CTX*)self->state);
+    SHA1_Final((byte *)vstr.buf, (SHA1_CTX *)self->state);
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
 #endif
@@ -196,8 +196,8 @@ STATIC mp_obj_t uhashlib_sha1_make_new(const mp_obj_type_t *type, size_t n_args,
     mp_arg_check_num(n_args, n_kw, 0, 1, false);
     mp_obj_hash_t *o = m_new_obj_var(mp_obj_hash_t, char, sizeof(mbedtls_sha1_context));
     o->base.type = type;
-    mbedtls_sha1_init((mbedtls_sha1_context*)o->state);
-    mbedtls_sha1_starts_ret((mbedtls_sha1_context*)o->state);
+    mbedtls_sha1_init((mbedtls_sha1_context *)o->state);
+    mbedtls_sha1_starts_ret((mbedtls_sha1_context *)o->state);
     if (n_args == 1) {
         uhashlib_sha1_update(MP_OBJ_FROM_PTR(o), args[0]);
     }
@@ -208,7 +208,7 @@ STATIC mp_obj_t uhashlib_sha1_update(mp_obj_t self_in, mp_obj_t arg) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
-    mbedtls_sha1_update_ret((mbedtls_sha1_context*)self->state, bufinfo.buf, bufinfo.len);
+    mbedtls_sha1_update_ret((mbedtls_sha1_context *)self->state, bufinfo.buf, bufinfo.len);
     return mp_const_none;
 }
 
@@ -216,8 +216,8 @@ STATIC mp_obj_t uhashlib_sha1_digest(mp_obj_t self_in) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     vstr_t vstr;
     vstr_init_len(&vstr, 20);
-    mbedtls_sha1_finish_ret((mbedtls_sha1_context*)self->state, (byte*)vstr.buf);
-    mbedtls_sha1_free((mbedtls_sha1_context*)self->state);
+    mbedtls_sha1_finish_ret((mbedtls_sha1_context *)self->state, (byte *)vstr.buf);
+    mbedtls_sha1_free((mbedtls_sha1_context *)self->state);
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
 #endif
@@ -235,7 +235,7 @@ STATIC const mp_obj_type_t uhashlib_sha1_type = {
     { &mp_type_type },
     .name = MP_QSTR_sha1,
     .make_new = uhashlib_sha1_make_new,
-    .locals_dict = (void*)&uhashlib_sha1_locals_dict,
+    .locals_dict = (void *)&uhashlib_sha1_locals_dict,
 };
 #endif
 
@@ -247,7 +247,7 @@ STATIC mp_obj_t uhashlib_md5_make_new(const mp_obj_type_t *type, size_t n_args,
     mp_arg_check_num(n_args, n_kw, 0, 1, false);
     mp_obj_hash_t *o = m_new_obj_var(mp_obj_hash_t, char, sizeof(MD5_CTX));
     o->base.type = type;
-    MD5_Init((MD5_CTX*)o->state);
+    MD5_Init((MD5_CTX *)o->state);
     if (n_args == 1) {
         uhashlib_md5_update(MP_OBJ_FROM_PTR(o), args[0]);
     }
@@ -258,7 +258,7 @@ STATIC mp_obj_t uhashlib_md5_update(mp_obj_t self_in, mp_obj_t arg) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
-    MD5_Update((MD5_CTX*)self->state, bufinfo.buf, bufinfo.len);
+    MD5_Update((MD5_CTX *)self->state, bufinfo.buf, bufinfo.len);
     return mp_const_none;
 }
 
@@ -266,7 +266,7 @@ STATIC mp_obj_t uhashlib_md5_digest(mp_obj_t self_in) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     vstr_t vstr;
     vstr_init_len(&vstr, MD5_SIZE);
-    MD5_Final((byte*)vstr.buf, (MD5_CTX*)self->state);
+    MD5_Final((byte *)vstr.buf, (MD5_CTX *)self->state);
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
 #endif // MICROPY_SSL_AXTLS
@@ -283,8 +283,8 @@ STATIC mp_obj_t uhashlib_md5_make_new(const mp_obj_type_t *type, size_t n_args,
     mp_arg_check_num(n_args, n_kw, 0, 1, false);
     mp_obj_hash_t *o = m_new_obj_var(mp_obj_hash_t, char, sizeof(mbedtls_md5_context));
     o->base.type = type;
-    mbedtls_md5_init((mbedtls_md5_context*)o->state);
-    mbedtls_md5_starts_ret((mbedtls_md5_context*)o->state);
+    mbedtls_md5_init((mbedtls_md5_context *)o->state);
+    mbedtls_md5_starts_ret((mbedtls_md5_context *)o->state);
     if (n_args == 1) {
         uhashlib_md5_update(MP_OBJ_FROM_PTR(o), args[0]);
     }
@@ -295,7 +295,7 @@ STATIC mp_obj_t uhashlib_md5_update(mp_obj_t self_in, mp_obj_t arg) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
-    mbedtls_md5_update_ret((mbedtls_md5_context*)self->state, bufinfo.buf, bufinfo.len);
+    mbedtls_md5_update_ret((mbedtls_md5_context *)self->state, bufinfo.buf, bufinfo.len);
     return mp_const_none;
 }
 
@@ -303,8 +303,8 @@ STATIC mp_obj_t uhashlib_md5_digest(mp_obj_t self_in) {
     mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     vstr_t vstr;
     vstr_init_len(&vstr, 16);
-    mbedtls_md5_finish_ret((mbedtls_md5_context*)self->state, (byte*)vstr.buf);
-    mbedtls_md5_free((mbedtls_md5_context*)self->state);
+    mbedtls_md5_finish_ret((mbedtls_md5_context *)self->state, (byte *)vstr.buf);
+    mbedtls_md5_free((mbedtls_md5_context *)self->state);
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
 #endif // MICROPY_SSL_MBEDTLS
@@ -322,7 +322,7 @@ STATIC const mp_obj_type_t uhashlib_md5_type = {
     { &mp_type_type },
     .name = MP_QSTR_md5,
     .make_new = uhashlib_md5_make_new,
-    .locals_dict = (void*)&uhashlib_md5_locals_dict,
+    .locals_dict = (void *)&uhashlib_md5_locals_dict,
 };
 #endif // MICROPY_PY_UHASHLIB_MD5
 
@@ -343,7 +343,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_uhashlib_globals, mp_module_uhashlib_globa
 
 const mp_obj_module_t mp_module_uhashlib = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_uhashlib_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_uhashlib_globals,
 };
 
-#endif //MICROPY_PY_UHASHLIB
+#endif // MICROPY_PY_UHASHLIB
diff --git a/extmod/moduheapq.c b/extmod/moduheapq.c
index bdaf191e9471e..073ce516b996d 100644
--- a/extmod/moduheapq.c
+++ b/extmod/moduheapq.c
@@ -31,14 +31,14 @@
 
 // the algorithm here is modelled on CPython's heapq.py
 
-STATIC mp_obj_list_t *get_heap(mp_obj_t heap_in) {
+STATIC mp_obj_list_t *uheapq_get_heap(mp_obj_t heap_in) {
     if (!mp_obj_is_type(heap_in, &mp_type_list)) {
-        mp_raise_TypeError("heap must be a list");
+        mp_raise_TypeError(MP_ERROR_TEXT("heap must be a list"));
     }
     return MP_OBJ_TO_PTR(heap_in);
 }
 
-STATIC void heap_siftdown(mp_obj_list_t *heap, mp_uint_t start_pos, mp_uint_t pos) {
+STATIC void uheapq_heap_siftdown(mp_obj_list_t *heap, mp_uint_t start_pos, mp_uint_t pos) {
     mp_obj_t item = heap->items[pos];
     while (pos > start_pos) {
         mp_uint_t parent_pos = (pos - 1) >> 1;
@@ -53,7 +53,7 @@ STATIC void heap_siftdown(mp_obj_list_t *heap, mp_uint_t start_pos, mp_uint_t po
     heap->items[pos] = item;
 }
 
-STATIC void heap_siftup(mp_obj_list_t *heap, mp_uint_t pos) {
+STATIC void uheapq_heap_siftup(mp_obj_list_t *heap, mp_uint_t pos) {
     mp_uint_t start_pos = pos;
     mp_uint_t end_pos = heap->len;
     mp_obj_t item = heap->items[pos];
@@ -67,42 +67,43 @@ STATIC void heap_siftup(mp_obj_list_t *heap, mp_uint_t pos) {
         pos = child_pos;
     }
     heap->items[pos] = item;
-    heap_siftdown(heap, start_pos, pos);
+    uheapq_heap_siftdown(heap, start_pos, pos);
 }
 
 STATIC mp_obj_t mod_uheapq_heappush(mp_obj_t heap_in, mp_obj_t item) {
-    mp_obj_list_t *heap = get_heap(heap_in);
+    mp_obj_list_t *heap = uheapq_get_heap(heap_in);
     mp_obj_list_append(heap_in, item);
-    heap_siftdown(heap, 0, heap->len - 1);
+    uheapq_heap_siftdown(heap, 0, heap->len - 1);
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_uheapq_heappush_obj, mod_uheapq_heappush);
 
 STATIC mp_obj_t mod_uheapq_heappop(mp_obj_t heap_in) {
-    mp_obj_list_t *heap = get_heap(heap_in);
+    mp_obj_list_t *heap = uheapq_get_heap(heap_in);
     if (heap->len == 0) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_IndexError, "empty heap"));
+        mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("empty heap"));
     }
     mp_obj_t item = heap->items[0];
     heap->len -= 1;
     heap->items[0] = heap->items[heap->len];
     heap->items[heap->len] = MP_OBJ_NULL; // so we don't retain a pointer
     if (heap->len) {
-        heap_siftup(heap, 0);
+        uheapq_heap_siftup(heap, 0);
     }
     return item;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_uheapq_heappop_obj, mod_uheapq_heappop);
 
 STATIC mp_obj_t mod_uheapq_heapify(mp_obj_t heap_in) {
-    mp_obj_list_t *heap = get_heap(heap_in);
+    mp_obj_list_t *heap = uheapq_get_heap(heap_in);
     for (mp_uint_t i = heap->len / 2; i > 0;) {
-        heap_siftup(heap, --i);
+        uheapq_heap_siftup(heap, --i);
     }
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_uheapq_heapify_obj, mod_uheapq_heapify);
 
+#if !MICROPY_ENABLE_DYNRUNTIME
 STATIC const mp_rom_map_elem_t mp_module_uheapq_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_uheapq) },
     { MP_ROM_QSTR(MP_QSTR_heappush), MP_ROM_PTR(&mod_uheapq_heappush_obj) },
@@ -114,7 +115,8 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_uheapq_globals, mp_module_uheapq_globals_t
 
 const mp_obj_module_t mp_module_uheapq = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_uheapq_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_uheapq_globals,
 };
+#endif
 
-#endif //MICROPY_PY_UHEAPQ
+#endif // MICROPY_PY_UHEAPQ
diff --git a/extmod/modujson.c b/extmod/modujson.c
index 830b588fdc98f..8dff673580279 100644
--- a/extmod/modujson.c
+++ b/extmod/modujson.c
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2014-2016 Damien P. George
+ * Copyright (c) 2014-2019 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -96,11 +96,11 @@ STATIC mp_obj_t mod_ujson_load(mp_obj_t stream_obj) {
     stack.len = 0;
     stack.items = NULL;
     mp_obj_t stack_top = MP_OBJ_NULL;
-    mp_obj_type_t *stack_top_type = NULL;
+    const mp_obj_type_t *stack_top_type = NULL;
     mp_obj_t stack_key = MP_OBJ_NULL;
     S_NEXT(s);
     for (;;) {
-        cont:
+    cont:
         if (S_END(s)) {
             break;
         }
@@ -147,11 +147,21 @@ STATIC mp_obj_t mod_ujson_load(mp_obj_t stream_obj) {
                     if (c == '\\') {
                         c = S_NEXT(s);
                         switch (c) {
-                            case 'b': c = 0x08; break;
-                            case 'f': c = 0x0c; break;
-                            case 'n': c = 0x0a; break;
-                            case 'r': c = 0x0d; break;
-                            case 't': c = 0x09; break;
+                            case 'b':
+                                c = 0x08;
+                                break;
+                            case 'f':
+                                c = 0x0c;
+                                break;
+                            case 'n':
+                                c = 0x0a;
+                                break;
+                            case 'r':
+                                c = 0x0d;
+                                break;
+                            case 't':
+                                c = 0x09;
+                                break;
                             case 'u': {
                                 mp_uint_t num = 0;
                                 for (int i = 0; i < 4; i++) {
@@ -177,7 +187,16 @@ STATIC mp_obj_t mod_ujson_load(mp_obj_t stream_obj) {
                 next = mp_obj_new_str(vstr.buf, vstr.len);
                 break;
             case '-':
-            case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9': {
                 bool flt = false;
                 vstr_reset(&vstr);
                 for (;;) {
@@ -185,7 +204,7 @@ STATIC mp_obj_t mod_ujson_load(mp_obj_t stream_obj) {
                     cur = S_CUR(s);
                     if (cur == '.' || cur == 'E' || cur == 'e') {
                         flt = true;
-                    } else if (cur == '-' || unichar_isdigit(cur)) {
+                    } else if (cur == '+' || cur == '-' || unichar_isdigit(cur)) {
                         // pass
                     } else {
                         break;
@@ -259,7 +278,7 @@ STATIC mp_obj_t mod_ujson_load(mp_obj_t stream_obj) {
             }
         }
     }
-    success:
+success:
     // eat trailing whitespace
     while (unichar_isspace(S_CUR(s))) {
         S_NEXT(s);
@@ -275,15 +294,15 @@ STATIC mp_obj_t mod_ujson_load(mp_obj_t stream_obj) {
     vstr_clear(&vstr);
     return stack_top;
 
-    fail:
-    mp_raise_ValueError("syntax error in JSON");
+fail:
+    mp_raise_ValueError(MP_ERROR_TEXT("syntax error in JSON"));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_ujson_load_obj, mod_ujson_load);
 
 STATIC mp_obj_t mod_ujson_loads(mp_obj_t obj) {
-    size_t len;
-    const char *buf = mp_obj_str_get_data(obj, &len);
-    vstr_t vstr = {len, len, (char*)buf, true};
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(obj, &bufinfo, MP_BUFFER_READ);
+    vstr_t vstr = {bufinfo.len, bufinfo.len, (char *)bufinfo.buf, true};
     mp_obj_stringio_t sio = {{&mp_type_stringio}, &vstr, 0, MP_OBJ_NULL};
     return mod_ujson_load(MP_OBJ_FROM_PTR(&sio));
 }
@@ -301,7 +320,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_ujson_globals, mp_module_ujson_globals_tab
 
 const mp_obj_module_t mp_module_ujson = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_ujson_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_ujson_globals,
 };
 
-#endif //MICROPY_PY_UJSON
+#endif // MICROPY_PY_UJSON
diff --git a/extmod/modurandom.c b/extmod/modurandom.c
index 1512a3fd4a996..ab83b0f701234 100644
--- a/extmod/modurandom.c
+++ b/extmod/modurandom.c
@@ -36,18 +36,19 @@
 // http://www.literatecode.com/yasmarang
 // Public Domain
 
+#if !MICROPY_ENABLE_DYNRUNTIME
 STATIC uint32_t yasmarang_pad = 0xeda4baba, yasmarang_n = 69, yasmarang_d = 233;
 STATIC uint8_t yasmarang_dat = 0;
+#endif
 
-STATIC uint32_t yasmarang(void)
-{
-   yasmarang_pad += yasmarang_dat + yasmarang_d * yasmarang_n;
-   yasmarang_pad = (yasmarang_pad<<3) + (yasmarang_pad>>29);
-   yasmarang_n = yasmarang_pad | 2;
-   yasmarang_d ^= (yasmarang_pad<<31) + (yasmarang_pad>>1);
-   yasmarang_dat ^= (char) yasmarang_pad ^ (yasmarang_d>>8) ^ 1;
+STATIC uint32_t yasmarang(void) {
+    yasmarang_pad += yasmarang_dat + yasmarang_d * yasmarang_n;
+    yasmarang_pad = (yasmarang_pad << 3) + (yasmarang_pad >> 29);
+    yasmarang_n = yasmarang_pad | 2;
+    yasmarang_d ^= (yasmarang_pad << 31) + (yasmarang_pad >> 1);
+    yasmarang_dat ^= (char)yasmarang_pad ^ (yasmarang_d >> 8) ^ 1;
 
-   return (yasmarang_pad^(yasmarang_d<<5)^(yasmarang_pad>>18)^(yasmarang_dat<<1));
+    return yasmarang_pad ^ (yasmarang_d << 5) ^ (yasmarang_pad >> 18) ^ (yasmarang_dat << 1);
 }  /* yasmarang */
 
 // End of Yasmarang
@@ -152,7 +153,7 @@ STATIC mp_obj_t mod_urandom_choice(mp_obj_t seq) {
     if (len > 0) {
         return mp_obj_subscr(seq, mp_obj_new_int(yasmarang_randbelow(len)), MP_OBJ_SENTINEL);
     } else {
-        nlr_raise(mp_obj_new_exception(&mp_type_IndexError));
+        mp_raise_type(&mp_type_IndexError);
     }
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_urandom_choice_obj, mod_urandom_choice);
@@ -161,19 +162,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_urandom_choice_obj, mod_urandom_choice);
 
 // returns a number in the range [0..1) using Yasmarang to fill in the fraction bits
 STATIC mp_float_t yasmarang_float(void) {
-    #if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
-    typedef uint64_t mp_float_int_t;
-    #elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
-    typedef uint32_t mp_float_int_t;
-    #endif
-    union {
-        mp_float_t f;
-        #if MP_ENDIANNESS_LITTLE
-        struct { mp_float_int_t frc:MP_FLOAT_FRAC_BITS, exp:MP_FLOAT_EXP_BITS, sgn:1; } p;
-        #else
-        struct { mp_float_int_t sgn:1, exp:MP_FLOAT_EXP_BITS, frc:MP_FLOAT_FRAC_BITS; } p;
-        #endif
-    } u;
+    mp_float_union_t u;
     u.p.sgn = 0;
     u.p.exp = (1 << (MP_FLOAT_EXP_BITS - 1)) - 1;
     if (MP_FLOAT_FRAC_BITS <= 32) {
@@ -200,8 +189,20 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_urandom_uniform_obj, mod_urandom_uniform);
 
 #endif // MICROPY_PY_URANDOM_EXTRA_FUNCS
 
+#ifdef MICROPY_PY_URANDOM_SEED_INIT_FUNC
+STATIC mp_obj_t mod_urandom___init__() {
+    mod_urandom_seed(MP_OBJ_NEW_SMALL_INT(MICROPY_PY_URANDOM_SEED_INIT_FUNC));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_urandom___init___obj, mod_urandom___init__);
+#endif
+
+#if !MICROPY_ENABLE_DYNRUNTIME
 STATIC const mp_rom_map_elem_t mp_module_urandom_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_urandom) },
+    #ifdef MICROPY_PY_URANDOM_SEED_INIT_FUNC
+    { MP_ROM_QSTR(MP_QSTR___init__), MP_ROM_PTR(&mod_urandom___init___obj) },
+    #endif
     { MP_ROM_QSTR(MP_QSTR_getrandbits), MP_ROM_PTR(&mod_urandom_getrandbits_obj) },
     { MP_ROM_QSTR(MP_QSTR_seed), MP_ROM_PTR(&mod_urandom_seed_obj) },
     #if MICROPY_PY_URANDOM_EXTRA_FUNCS
@@ -219,7 +220,8 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_urandom_globals, mp_module_urandom_globals
 
 const mp_obj_module_t mp_module_urandom = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_urandom_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_urandom_globals,
 };
+#endif
 
-#endif //MICROPY_PY_URANDOM
+#endif // MICROPY_PY_URANDOM
diff --git a/extmod/modure.c b/extmod/modure.c
index 0d5330cb548e4..1847ec288075d 100644
--- a/extmod/modure.c
+++ b/extmod/modure.c
@@ -73,7 +73,7 @@ STATIC mp_obj_t match_group(mp_obj_t self_in, mp_obj_t no_in) {
         return mp_const_none;
     }
     return mp_obj_new_str_of_type(mp_obj_get_type(self->str),
-        (const byte*)start, self->caps[no * 2 + 1] - start);
+        (const byte *)start, self->caps[no * 2 + 1] - start);
 }
 MP_DEFINE_CONST_FUN_OBJ_2(match_group_obj, match_group);
 
@@ -144,6 +144,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(match_end_obj, 1, 2, match_end);
 
 #endif
 
+#if !MICROPY_ENABLE_DYNRUNTIME
 STATIC const mp_rom_map_elem_t match_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_group), MP_ROM_PTR(&match_group_obj) },
     #if MICROPY_PY_URE_MATCH_GROUPS
@@ -162,8 +163,9 @@ STATIC const mp_obj_type_t match_type = {
     { &mp_type_type },
     .name = MP_QSTR_match,
     .print = match_print,
-    .locals_dict = (void*)&match_locals_dict,
+    .locals_dict = (void *)&match_locals_dict,
 };
+#endif
 
 STATIC void re_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     (void)kind;
@@ -179,12 +181,12 @@ STATIC mp_obj_t ure_exec(bool is_anchored, uint n_args, const mp_obj_t *args) {
     subj.begin = mp_obj_str_get_data(args[1], &len);
     subj.end = subj.begin + len;
     int caps_num = (self->re.sub + 1) * 2;
-    mp_obj_match_t *match = m_new_obj_var(mp_obj_match_t, char*, caps_num);
+    mp_obj_match_t *match = m_new_obj_var(mp_obj_match_t, char *, caps_num);
     // cast is a workaround for a bug in msvc: it treats const char** as a const pointer instead of a pointer to pointer to const char
-    memset((char*)match->caps, 0, caps_num * sizeof(char*));
+    memset((char *)match->caps, 0, caps_num * sizeof(char *));
     int res = re1_5_recursiveloopprog(&self->re, &subj, match->caps, caps_num, is_anchored);
     if (res == 0) {
-        m_del_var(mp_obj_match_t, char*, caps_num, match);
+        m_del_var(mp_obj_match_t, char *, caps_num, match);
         return mp_const_none;
     }
 
@@ -219,10 +221,10 @@ STATIC mp_obj_t re_split(size_t n_args, const mp_obj_t *args) {
     }
 
     mp_obj_t retval = mp_obj_new_list(0, NULL);
-    const char **caps = mp_local_alloc(caps_num * sizeof(char*));
+    const char **caps = mp_local_alloc(caps_num * sizeof(char *));
     while (true) {
         // cast is a workaround for a bug in msvc: it treats const char** as a const pointer instead of a pointer to pointer to const char
-        memset((char**)caps, 0, caps_num * sizeof(char*));
+        memset((char **)caps, 0, caps_num * sizeof(char *));
         int res = re1_5_recursiveloopprog(&self->re, &subj, caps, caps_num, false);
 
         // if we didn't have a match, or had an empty match, it's time to stop
@@ -230,10 +232,10 @@ STATIC mp_obj_t re_split(size_t n_args, const mp_obj_t *args) {
             break;
         }
 
-        mp_obj_t s = mp_obj_new_str_of_type(str_type, (const byte*)subj.begin, caps[0] - subj.begin);
+        mp_obj_t s = mp_obj_new_str_of_type(str_type, (const byte *)subj.begin, caps[0] - subj.begin);
         mp_obj_list_append(retval, s);
         if (self->re.sub > 0) {
-            mp_raise_NotImplementedError("Splitting with sub-captures");
+            mp_raise_NotImplementedError(MP_ERROR_TEXT("splitting with sub-captures"));
         }
         subj.begin = caps[1];
         if (maxsplit > 0 && --maxsplit == 0) {
@@ -241,9 +243,9 @@ STATIC mp_obj_t re_split(size_t n_args, const mp_obj_t *args) {
         }
     }
     // cast is a workaround for a bug in msvc (see above)
-    mp_local_free((char**)caps);
+    mp_local_free((char **)caps);
 
-    mp_obj_t s = mp_obj_new_str_of_type(str_type, (const byte*)subj.begin, subj.end - subj.begin);
+    mp_obj_t s = mp_obj_new_str_of_type(str_type, (const byte *)subj.begin, subj.end - subj.begin);
     mp_obj_list_append(retval, s);
     return retval;
 }
@@ -270,14 +272,14 @@ STATIC mp_obj_t re_sub_helper(mp_obj_t self_in, size_t n_args, const mp_obj_t *a
 
     vstr_t vstr_return;
     vstr_return.buf = NULL; // We'll init the vstr after the first match
-    mp_obj_match_t *match = mp_local_alloc(sizeof(mp_obj_match_t) + caps_num * sizeof(char*));
+    mp_obj_match_t *match = mp_local_alloc(sizeof(mp_obj_match_t) + caps_num * sizeof(char *));
     match->base.type = &match_type;
     match->num_matches = caps_num / 2; // caps_num counts start and end pointers
     match->str = where;
 
     for (;;) {
         // cast is a workaround for a bug in msvc: it treats const char** as a const pointer instead of a pointer to pointer to const char
-        memset((char*)match->caps, 0, caps_num * sizeof(char*));
+        memset((char *)match->caps, 0, caps_num * sizeof(char *));
         int res = re1_5_recursiveloopprog(&self->re, &subj, match->caps, caps_num, false);
 
         // If we didn't have a match, or had an empty match, it's time to stop
@@ -294,7 +296,7 @@ STATIC mp_obj_t re_sub_helper(mp_obj_t self_in, size_t n_args, const mp_obj_t *a
         vstr_add_strn(&vstr_return, subj.begin, match->caps[0] - subj.begin);
 
         // Get replacement string
-        const char* repl = mp_obj_str_get_str((mp_obj_is_callable(replace) ? mp_call_function_1(replace, MP_OBJ_FROM_PTR(match)) : replace));
+        const char *repl = mp_obj_str_get_str((mp_obj_is_callable(replace) ? mp_call_function_1(replace, MP_OBJ_FROM_PTR(match)) : replace));
 
         // Append replacement string to result, substituting any regex groups
         while (*repl != '\0') {
@@ -363,6 +365,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(re_sub_obj, 3, 5, re_sub);
 
 #endif
 
+#if !MICROPY_ENABLE_DYNRUNTIME
 STATIC const mp_rom_map_elem_t re_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_match), MP_ROM_PTR(&re_match_obj) },
     { MP_ROM_QSTR(MP_QSTR_search), MP_ROM_PTR(&re_search_obj) },
@@ -378,10 +381,12 @@ STATIC const mp_obj_type_t re_type = {
     { &mp_type_type },
     .name = MP_QSTR_ure,
     .print = re_print,
-    .locals_dict = (void*)&re_locals_dict,
+    .locals_dict = (void *)&re_locals_dict,
 };
+#endif
 
 STATIC mp_obj_t mod_re_compile(size_t n_args, const mp_obj_t *args) {
+    (void)n_args;
     const char *re_str = mp_obj_str_get_str(args[0]);
     int size = re1_5_sizecode(re_str);
     if (size == -1) {
@@ -389,18 +394,22 @@ STATIC mp_obj_t mod_re_compile(size_t n_args, const mp_obj_t *args) {
     }
     mp_obj_re_t *o = m_new_obj_var(mp_obj_re_t, char, size);
     o->base.type = &re_type;
+    #if MICROPY_PY_URE_DEBUG
     int flags = 0;
     if (n_args > 1) {
         flags = mp_obj_get_int(args[1]);
     }
+    #endif
     int error = re1_5_compilecode(&o->re, re_str);
     if (error != 0) {
-error:
-        mp_raise_ValueError("Error in regex");
+    error:
+        mp_raise_ValueError(MP_ERROR_TEXT("error in regex"));
     }
+    #if MICROPY_PY_URE_DEBUG
     if (flags & FLAG_DEBUG) {
         re1_5_dumpcode(&o->re);
     }
+    #endif
     return MP_OBJ_FROM_PTR(o);
 }
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_re_compile_obj, 1, 2, mod_re_compile);
@@ -432,6 +441,7 @@ STATIC mp_obj_t mod_re_sub(size_t n_args, const mp_obj_t *args) {
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_re_sub_obj, 3, 5, mod_re_sub);
 #endif
 
+#if !MICROPY_ENABLE_DYNRUNTIME
 STATIC const mp_rom_map_elem_t mp_module_re_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_ure) },
     { MP_ROM_QSTR(MP_QSTR_compile), MP_ROM_PTR(&mod_re_compile_obj) },
@@ -440,23 +450,28 @@ STATIC const mp_rom_map_elem_t mp_module_re_globals_table[] = {
     #if MICROPY_PY_URE_SUB
     { MP_ROM_QSTR(MP_QSTR_sub), MP_ROM_PTR(&mod_re_sub_obj) },
     #endif
+    #if MICROPY_PY_URE_DEBUG
     { MP_ROM_QSTR(MP_QSTR_DEBUG), MP_ROM_INT(FLAG_DEBUG) },
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(mp_module_re_globals, mp_module_re_globals_table);
 
 const mp_obj_module_t mp_module_ure = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_re_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_re_globals,
 };
+#endif
 
 // Source files #include'd here to make sure they're compiled in
 // only if module is enabled by config setting.
 
 #define re1_5_fatal(x) assert(!x)
 #include "re1.5/compilecode.c"
+#if MICROPY_PY_URE_DEBUG
 #include "re1.5/dumpcode.c"
+#endif
 #include "re1.5/recursiveloop.c"
 #include "re1.5/charclass.c"
 
-#endif //MICROPY_PY_URE
+#endif // MICROPY_PY_URE
diff --git a/extmod/moduselect.c b/extmod/moduselect.c
index a65fa6df29527..80beb8e09b8aa 100644
--- a/extmod/moduselect.c
+++ b/extmod/moduselect.c
@@ -4,6 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2014 Damien P. George
+ * Copyright (c) 2015-2017 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -65,9 +66,9 @@ STATIC void poll_map_add(mp_map_t *poll_map, const mp_obj_t *obj, mp_uint_t obj_
         } else {
             // object exists; update its flags
             if (or_flags) {
-                ((poll_obj_t*)MP_OBJ_TO_PTR(elem->value))->flags |= flags;
+                ((poll_obj_t *)MP_OBJ_TO_PTR(elem->value))->flags |= flags;
             } else {
-                ((poll_obj_t*)MP_OBJ_TO_PTR(elem->value))->flags = flags;
+                ((poll_obj_t *)MP_OBJ_TO_PTR(elem->value))->flags = flags;
             }
         }
     }
@@ -124,7 +125,7 @@ STATIC mp_obj_t select_select(size_t n_args, const mp_obj_t *args) {
     if (n_args == 4) {
         if (args[3] != mp_const_none) {
             #if MICROPY_PY_BUILTINS_FLOAT
-            float timeout_f = mp_obj_get_float(args[3]);
+            float timeout_f = mp_obj_get_float_to_f(args[3]);
             if (timeout_f >= 0) {
                 timeout = (mp_uint_t)(timeout_f * 1000);
             }
@@ -160,13 +161,13 @@ STATIC mp_obj_t select_select(size_t n_args, const mp_obj_t *args) {
                 }
                 poll_obj_t *poll_obj = MP_OBJ_TO_PTR(poll_map.table[i].value);
                 if (poll_obj->flags_ret & MP_STREAM_POLL_RD) {
-                    ((mp_obj_list_t*)MP_OBJ_TO_PTR(list_array[0]))->items[rwx_len[0]++] = poll_obj->obj;
+                    ((mp_obj_list_t *)MP_OBJ_TO_PTR(list_array[0]))->items[rwx_len[0]++] = poll_obj->obj;
                 }
                 if (poll_obj->flags_ret & MP_STREAM_POLL_WR) {
-                    ((mp_obj_list_t*)MP_OBJ_TO_PTR(list_array[1]))->items[rwx_len[1]++] = poll_obj->obj;
+                    ((mp_obj_list_t *)MP_OBJ_TO_PTR(list_array[1]))->items[rwx_len[1]++] = poll_obj->obj;
                 }
                 if ((poll_obj->flags_ret & ~(MP_STREAM_POLL_RD | MP_STREAM_POLL_WR)) != 0) {
-                    ((mp_obj_list_t*)MP_OBJ_TO_PTR(list_array[2]))->items[rwx_len[2]++] = poll_obj->obj;
+                    ((mp_obj_list_t *)MP_OBJ_TO_PTR(list_array[2]))->items[rwx_len[2]++] = poll_obj->obj;
                 }
             }
             mp_map_deinit(&poll_map);
@@ -219,7 +220,7 @@ STATIC mp_obj_t poll_modify(mp_obj_t self_in, mp_obj_t obj_in, mp_obj_t eventmas
     if (elem == NULL) {
         mp_raise_OSError(MP_ENOENT);
     }
-    ((poll_obj_t*)MP_OBJ_TO_PTR(elem->value))->flags = mp_obj_get_int(eventmask_in);
+    ((poll_obj_t *)MP_OBJ_TO_PTR(elem->value))->flags = mp_obj_get_int(eventmask_in);
     return mp_const_none;
 }
 MP_DEFINE_CONST_FUN_OBJ_3(poll_modify_obj, poll_modify);
@@ -344,7 +345,7 @@ STATIC const mp_obj_type_t mp_type_poll = {
     .name = MP_QSTR_poll,
     .getiter = mp_identity_getiter,
     .iternext = poll_iternext,
-    .locals_dict = (void*)&poll_locals_dict,
+    .locals_dict = (void *)&poll_locals_dict,
 };
 
 /// \function poll()
@@ -372,7 +373,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_select_globals, mp_module_select_globals_t
 
 const mp_obj_module_t mp_module_uselect = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_select_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_select_globals,
 };
 
 #endif // MICROPY_PY_USELECT
diff --git a/extmod/modussl_axtls.c b/extmod/modussl_axtls.c
index 2dab6ff49146c..7b0e3cbcbc327 100644
--- a/extmod/modussl_axtls.c
+++ b/extmod/modussl_axtls.c
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2017 Paul Sokolovsky
+ * Copyright (c) 2015-2019 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -41,6 +41,7 @@ typedef struct _mp_obj_ssl_socket_t {
     SSL *ssl_sock;
     byte *buf;
     uint32_t bytes_left;
+    bool blocking;
 } mp_obj_ssl_socket_t;
 
 struct ssl_args {
@@ -48,22 +49,27 @@ struct ssl_args {
     mp_arg_val_t cert;
     mp_arg_val_t server_side;
     mp_arg_val_t server_hostname;
+    mp_arg_val_t do_handshake;
 };
 
 STATIC const mp_obj_type_t ussl_socket_type;
 
-STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
-#if MICROPY_PY_USSL_FINALISER
+STATIC mp_obj_ssl_socket_t *ussl_socket_new(mp_obj_t sock, struct ssl_args *args) {
+    #if MICROPY_PY_USSL_FINALISER
     mp_obj_ssl_socket_t *o = m_new_obj_with_finaliser(mp_obj_ssl_socket_t);
-#else
+    #else
     mp_obj_ssl_socket_t *o = m_new_obj(mp_obj_ssl_socket_t);
-#endif
+    #endif
     o->base.type = &ussl_socket_type;
     o->buf = NULL;
     o->bytes_left = 0;
     o->sock = sock;
+    o->blocking = true;
 
     uint32_t options = SSL_SERVER_VERIFY_LATER;
+    if (!args->do_handshake.u_bool) {
+        options |= SSL_CONNECT_IN_PARTS;
+    }
     if (args->key.u_obj != mp_const_none) {
         options |= SSL_NO_DEFAULT_KEY;
     }
@@ -73,16 +79,16 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
 
     if (args->key.u_obj != mp_const_none) {
         size_t len;
-        const byte *data = (const byte*)mp_obj_str_get_data(args->key.u_obj, &len);
+        const byte *data = (const byte *)mp_obj_str_get_data(args->key.u_obj, &len);
         int res = ssl_obj_memory_load(o->ssl_ctx, SSL_OBJ_RSA_KEY, data, len, NULL);
         if (res != SSL_OK) {
-            mp_raise_ValueError("invalid key");
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid key"));
         }
 
-        data = (const byte*)mp_obj_str_get_data(args->cert.u_obj, &len);
+        data = (const byte *)mp_obj_str_get_data(args->cert.u_obj, &len);
         res = ssl_obj_memory_load(o->ssl_ctx, SSL_OBJ_X509_CERT, data, len, NULL);
         if (res != SSL_OK) {
-            mp_raise_ValueError("invalid cert");
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid cert"));
         }
     }
 
@@ -92,22 +98,19 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
         SSL_EXTENSIONS *ext = ssl_ext_new();
 
         if (args->server_hostname.u_obj != mp_const_none) {
-            ext->host_name = (char*)mp_obj_str_get_str(args->server_hostname.u_obj);
+            ext->host_name = (char *)mp_obj_str_get_str(args->server_hostname.u_obj);
         }
 
         o->ssl_sock = ssl_client_new(o->ssl_ctx, (long)sock, NULL, 0, ext);
 
-        int res = ssl_handshake_status(o->ssl_sock);
-        // Pointer to SSL_EXTENSIONS as being passed to ssl_client_new()
-        // is saved in ssl_sock->extensions.
-        // As of axTLS 2.1.3, extensions aren't used beyond the initial
-        // handshake, and that's pretty much how it's expected to be. So
-        // we allocate them on stack and reset the pointer after handshake.
+        if (args->do_handshake.u_bool) {
+            int res = ssl_handshake_status(o->ssl_sock);
 
-        if (res != SSL_OK) {
-            printf("ssl_handshake_status: %d\n", res);
-            ssl_display_error(res);
-            mp_raise_OSError(MP_EIO);
+            if (res != SSL_OK) {
+                printf("ssl_handshake_status: %d\n", res);
+                ssl_display_error(res);
+                mp_raise_OSError(MP_EIO);
+            }
         }
 
     }
@@ -115,13 +118,13 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
     return o;
 }
 
-STATIC void socket_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+STATIC void ussl_socket_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     (void)kind;
     mp_obj_ssl_socket_t *self = MP_OBJ_TO_PTR(self_in);
     mp_printf(print, "<_SSLSocket %p>", self->ssl_sock);
 }
 
-STATIC mp_uint_t socket_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
+STATIC mp_uint_t ussl_socket_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
     mp_obj_ssl_socket_t *o = MP_OBJ_TO_PTR(o_in);
 
     if (o->ssl_sock == NULL) {
@@ -133,8 +136,18 @@ STATIC mp_uint_t socket_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errc
         mp_int_t r = ssl_read(o->ssl_sock, &o->buf);
         if (r == SSL_OK) {
             // SSL_OK from ssl_read() means "everything is ok, but there's
-            // no user data yet". So, we just keep reading.
-            continue;
+            // no user data yet". It may happen e.g. if handshake is not
+            // finished yet. The best way we can treat it is by returning
+            // EAGAIN. This may be a bit unexpected in blocking mode, but
+            // default is to perform complete handshake in constructor, so
+            // this should not happen in blocking mode. On the other hand,
+            // in nonblocking mode EAGAIN (comparing to the alternative of
+            // looping) is really preferrable.
+            if (o->blocking) {
+                continue;
+            } else {
+                goto eagain;
+            }
         }
         if (r < 0) {
             if (r == SSL_CLOSE_NOTIFY || r == SSL_ERROR_CONN_LOST) {
@@ -142,6 +155,7 @@ STATIC mp_uint_t socket_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errc
                 return 0;
             }
             if (r == SSL_EAGAIN) {
+            eagain:
                 r = MP_EAGAIN;
             }
             *errcode = r;
@@ -159,7 +173,7 @@ STATIC mp_uint_t socket_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errc
     return size;
 }
 
-STATIC mp_uint_t socket_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
+STATIC mp_uint_t ussl_socket_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
     mp_obj_ssl_socket_t *o = MP_OBJ_TO_PTR(o_in);
 
     if (o->ssl_sock == NULL) {
@@ -175,7 +189,7 @@ STATIC mp_uint_t socket_write(mp_obj_t o_in, const void *buf, mp_uint_t size, in
     return r;
 }
 
-STATIC mp_uint_t socket_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+STATIC mp_uint_t ussl_socket_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
     mp_obj_ssl_socket_t *self = MP_OBJ_TO_PTR(o_in);
     if (request == MP_STREAM_CLOSE && self->ssl_sock != NULL) {
         ssl_free(self->ssl_sock);
@@ -186,54 +200,57 @@ STATIC mp_uint_t socket_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, i
     return mp_get_stream(self->sock)->ioctl(self->sock, request, arg, errcode);
 }
 
-STATIC mp_obj_t socket_setblocking(mp_obj_t self_in, mp_obj_t flag_in) {
-    // Currently supports only blocking mode
-    (void)self_in;
-    if (!mp_obj_is_true(flag_in)) {
-        mp_raise_NotImplementedError(NULL);
-    }
-    return mp_const_none;
+STATIC mp_obj_t ussl_socket_setblocking(mp_obj_t self_in, mp_obj_t flag_in) {
+    mp_obj_ssl_socket_t *o = MP_OBJ_TO_PTR(self_in);
+    mp_obj_t sock = o->sock;
+    mp_obj_t dest[3];
+    mp_load_method(sock, MP_QSTR_setblocking, dest);
+    dest[2] = flag_in;
+    mp_obj_t res = mp_call_method_n_kw(1, 0, dest);
+    o->blocking = mp_obj_is_true(flag_in);
+    return res;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_setblocking_obj, socket_setblocking);
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(ussl_socket_setblocking_obj, ussl_socket_setblocking);
 
 STATIC const mp_rom_map_elem_t ussl_socket_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
     { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
     { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
     { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
-    { MP_ROM_QSTR(MP_QSTR_setblocking), MP_ROM_PTR(&socket_setblocking_obj) },
+    { MP_ROM_QSTR(MP_QSTR_setblocking), MP_ROM_PTR(&ussl_socket_setblocking_obj) },
     { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
-#if MICROPY_PY_USSL_FINALISER
+    #if MICROPY_PY_USSL_FINALISER
     { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
-#endif
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(ussl_socket_locals_dict, ussl_socket_locals_dict_table);
 
 STATIC const mp_stream_p_t ussl_socket_stream_p = {
-    .read = socket_read,
-    .write = socket_write,
-    .ioctl = socket_ioctl,
+    .read = ussl_socket_read,
+    .write = ussl_socket_write,
+    .ioctl = ussl_socket_ioctl,
 };
 
 STATIC const mp_obj_type_t ussl_socket_type = {
     { &mp_type_type },
     // Save on qstr's, reuse same as for module
     .name = MP_QSTR_ussl,
-    .print = socket_print,
+    .print = ussl_socket_print,
     .getiter = NULL,
     .iternext = NULL,
     .protocol = &ussl_socket_stream_p,
-    .locals_dict = (void*)&ussl_socket_locals_dict,
+    .locals_dict = (void *)&ussl_socket_locals_dict,
 };
 
 STATIC mp_obj_t mod_ssl_wrap_socket(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     // TODO: Implement more args
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_key, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
-        { MP_QSTR_cert, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_key, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_cert, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
         { MP_QSTR_server_side, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
-        { MP_QSTR_server_hostname, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_server_hostname, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_do_handshake, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = true} },
     };
 
     // TODO: Check that sock implements stream protocol
@@ -241,9 +258,9 @@ STATIC mp_obj_t mod_ssl_wrap_socket(size_t n_args, const mp_obj_t *pos_args, mp_
 
     struct ssl_args args;
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args,
-        MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t*)&args);
+        MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t *)&args);
 
-    return MP_OBJ_FROM_PTR(socket_new(sock, &args));
+    return MP_OBJ_FROM_PTR(ussl_socket_new(sock, &args));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(mod_ssl_wrap_socket_obj, 1, mod_ssl_wrap_socket);
 
@@ -256,7 +273,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_ssl_globals, mp_module_ssl_globals_table);
 
 const mp_obj_module_t mp_module_ussl = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_ssl_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_ssl_globals,
 };
 
 #endif // MICROPY_PY_USSL
diff --git a/extmod/modussl_mbedtls.c b/extmod/modussl_mbedtls.c
index 348bba4c80828..9e117c82ccf34 100644
--- a/extmod/modussl_mbedtls.c
+++ b/extmod/modussl_mbedtls.c
@@ -4,6 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2016 Linaro Ltd.
+ * Copyright (c) 2019 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -60,6 +61,7 @@ struct ssl_args {
     mp_arg_val_t cert;
     mp_arg_val_t server_side;
     mp_arg_val_t server_hostname;
+    mp_arg_val_t do_handshake;
 };
 
 STATIC const mp_obj_type_t ussl_socket_type;
@@ -73,7 +75,7 @@ STATIC void mbedtls_debug(void *ctx, int level, const char *file, int line, cons
 #endif
 
 STATIC int _mbedtls_ssl_send(void *ctx, const byte *buf, size_t len) {
-    mp_obj_t sock = *(mp_obj_t*)ctx;
+    mp_obj_t sock = *(mp_obj_t *)ctx;
 
     const mp_stream_p_t *sock_stream = mp_get_stream(sock);
     int err;
@@ -90,7 +92,7 @@ STATIC int _mbedtls_ssl_send(void *ctx, const byte *buf, size_t len) {
 }
 
 STATIC int _mbedtls_ssl_recv(void *ctx, byte *buf, size_t len) {
-    mp_obj_t sock = *(mp_obj_t*)ctx;
+    mp_obj_t sock = *(mp_obj_t *)ctx;
 
     const mp_stream_p_t *sock_stream = mp_get_stream(sock);
     int err;
@@ -111,11 +113,11 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
     // Verify the socket object has the full stream protocol
     mp_get_stream_raise(sock, MP_STREAM_OP_READ | MP_STREAM_OP_WRITE | MP_STREAM_OP_IOCTL);
 
-#if MICROPY_PY_USSL_FINALISER
+    #if MICROPY_PY_USSL_FINALISER
     mp_obj_ssl_socket_t *o = m_new_obj_with_finaliser(mp_obj_ssl_socket_t);
-#else
+    #else
     mp_obj_ssl_socket_t *o = m_new_obj(mp_obj_ssl_socket_t);
-#endif
+    #endif
     o->base.type = &ussl_socket_type;
     o->sock = sock;
 
@@ -139,9 +141,9 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
     }
 
     ret = mbedtls_ssl_config_defaults(&o->conf,
-                    args->server_side.u_bool ? MBEDTLS_SSL_IS_SERVER : MBEDTLS_SSL_IS_CLIENT,
-                    MBEDTLS_SSL_TRANSPORT_STREAM,
-                    MBEDTLS_SSL_PRESET_DEFAULT);
+        args->server_side.u_bool ? MBEDTLS_SSL_IS_SERVER : MBEDTLS_SSL_IS_CLIENT,
+        MBEDTLS_SSL_TRANSPORT_STREAM,
+        MBEDTLS_SSL_PRESET_DEFAULT);
     if (ret != 0) {
         goto cleanup;
     }
@@ -167,27 +169,37 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
 
     mbedtls_ssl_set_bio(&o->ssl, &o->sock, _mbedtls_ssl_send, _mbedtls_ssl_recv, NULL);
 
-    if (args->key.u_obj != MP_OBJ_NULL) {
+    if (args->key.u_obj != mp_const_none) {
         size_t key_len;
-        const byte *key = (const byte*)mp_obj_str_get_data(args->key.u_obj, &key_len);
+        const byte *key = (const byte *)mp_obj_str_get_data(args->key.u_obj, &key_len);
         // len should include terminating null
         ret = mbedtls_pk_parse_key(&o->pkey, key, key_len + 1, NULL, 0);
-        assert(ret == 0);
+        if (ret != 0) {
+            ret = MBEDTLS_ERR_PK_BAD_INPUT_DATA; // use general error for all key errors
+            goto cleanup;
+        }
 
         size_t cert_len;
-        const byte *cert = (const byte*)mp_obj_str_get_data(args->cert.u_obj, &cert_len);
+        const byte *cert = (const byte *)mp_obj_str_get_data(args->cert.u_obj, &cert_len);
         // len should include terminating null
         ret = mbedtls_x509_crt_parse(&o->cert, cert, cert_len + 1);
-        assert(ret == 0);
+        if (ret != 0) {
+            ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA; // use general error for all cert errors
+            goto cleanup;
+        }
 
         ret = mbedtls_ssl_conf_own_cert(&o->conf, &o->cert, &o->pkey);
-        assert(ret == 0);
+        if (ret != 0) {
+            goto cleanup;
+        }
     }
 
-    while ((ret = mbedtls_ssl_handshake(&o->ssl)) != 0) {
-        if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
-            printf("mbedtls_ssl_handshake error: -%x\n", -ret);
-            goto cleanup;
+    if (args->do_handshake.u_bool) {
+        while ((ret = mbedtls_ssl_handshake(&o->ssl)) != 0) {
+            if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
+                printf("mbedtls_ssl_handshake error: -%x\n", -ret);
+                goto cleanup;
+            }
         }
     }
 
@@ -204,6 +216,10 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
 
     if (ret == MBEDTLS_ERR_SSL_ALLOC_FAILED) {
         mp_raise_OSError(MP_ENOMEM);
+    } else if (ret == MBEDTLS_ERR_PK_BAD_INPUT_DATA) {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid key"));
+    } else if (ret == MBEDTLS_ERR_X509_BAD_INPUT_DATA) {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid cert"));
     } else {
         mp_raise_OSError(MP_EIO);
     }
@@ -214,7 +230,10 @@ STATIC mp_obj_t mod_ssl_getpeercert(mp_obj_t o_in, mp_obj_t binary_form) {
     if (!mp_obj_is_true(binary_form)) {
         mp_raise_NotImplementedError(NULL);
     }
-    const mbedtls_x509_crt* peer_cert = mbedtls_ssl_get_peer_cert(&o->ssl);
+    const mbedtls_x509_crt *peer_cert = mbedtls_ssl_get_peer_cert(&o->ssl);
+    if (peer_cert == NULL) {
+        return mp_const_none;
+    }
     return mp_obj_new_bytes(peer_cert->raw.p, peer_cert->raw.len);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_ssl_getpeercert_obj, mod_ssl_getpeercert);
@@ -238,6 +257,11 @@ STATIC mp_uint_t socket_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errc
     }
     if (ret == MBEDTLS_ERR_SSL_WANT_READ) {
         ret = MP_EWOULDBLOCK;
+    } else if (ret == MBEDTLS_ERR_SSL_WANT_WRITE) {
+        // If handshake is not finished, read attempt may end up in protocol
+        // wanting to write next handshake message. The same may happen with
+        // renegotation.
+        ret = MP_EWOULDBLOCK;
     }
     *errcode = ret;
     return MP_STREAM_ERROR;
@@ -252,6 +276,11 @@ STATIC mp_uint_t socket_write(mp_obj_t o_in, const void *buf, mp_uint_t size, in
     }
     if (ret == MBEDTLS_ERR_SSL_WANT_WRITE) {
         ret = MP_EWOULDBLOCK;
+    } else if (ret == MBEDTLS_ERR_SSL_WANT_READ) {
+        // If handshake is not finished, write attempt may end up in protocol
+        // wanting to read next handshake message. The same may happen with
+        // renegotation.
+        ret = MP_EWOULDBLOCK;
     }
     *errcode = ret;
     return MP_STREAM_ERROR;
@@ -289,9 +318,9 @@ STATIC const mp_rom_map_elem_t ussl_socket_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
     { MP_ROM_QSTR(MP_QSTR_setblocking), MP_ROM_PTR(&socket_setblocking_obj) },
     { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
-#if MICROPY_PY_USSL_FINALISER
+    #if MICROPY_PY_USSL_FINALISER
     { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
-#endif
+    #endif
     { MP_ROM_QSTR(MP_QSTR_getpeercert), MP_ROM_PTR(&mod_ssl_getpeercert_obj) },
 };
 
@@ -311,16 +340,17 @@ STATIC const mp_obj_type_t ussl_socket_type = {
     .getiter = NULL,
     .iternext = NULL,
     .protocol = &ussl_socket_stream_p,
-    .locals_dict = (void*)&ussl_socket_locals_dict,
+    .locals_dict = (void *)&ussl_socket_locals_dict,
 };
 
 STATIC mp_obj_t mod_ssl_wrap_socket(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     // TODO: Implement more args
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_key, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
-        { MP_QSTR_cert, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_key, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_cert, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
         { MP_QSTR_server_side, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
-        { MP_QSTR_server_hostname, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_server_hostname, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_do_handshake, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = true} },
     };
 
     // TODO: Check that sock implements stream protocol
@@ -328,7 +358,7 @@ STATIC mp_obj_t mod_ssl_wrap_socket(size_t n_args, const mp_obj_t *pos_args, mp_
 
     struct ssl_args args;
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args,
-        MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t*)&args);
+        MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t *)&args);
 
     return MP_OBJ_FROM_PTR(socket_new(sock, &args));
 }
@@ -343,7 +373,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_ssl_globals, mp_module_ssl_globals_table);
 
 const mp_obj_module_t mp_module_ussl = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_ssl_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_ssl_globals,
 };
 
 #endif // MICROPY_PY_USSL
diff --git a/extmod/modutimeq.c b/extmod/modutimeq.c
index 26f5a78fae00a..c7467f3bf14fc 100644
--- a/extmod/modutimeq.c
+++ b/extmod/modutimeq.c
@@ -55,7 +55,7 @@ typedef struct _mp_obj_utimeq_t {
 
 STATIC mp_uint_t utimeq_id;
 
-STATIC mp_obj_utimeq_t *get_heap(mp_obj_t heap_in) {
+STATIC mp_obj_utimeq_t *utimeq_get_heap(mp_obj_t heap_in) {
     return MP_OBJ_TO_PTR(heap_in);
 }
 
@@ -85,7 +85,7 @@ STATIC mp_obj_t utimeq_make_new(const mp_obj_type_t *type, size_t n_args, size_t
     return MP_OBJ_FROM_PTR(o);
 }
 
-STATIC void heap_siftdown(mp_obj_utimeq_t *heap, mp_uint_t start_pos, mp_uint_t pos) {
+STATIC void utimeq_heap_siftdown(mp_obj_utimeq_t *heap, mp_uint_t start_pos, mp_uint_t pos) {
     struct qentry item = heap->items[pos];
     while (pos > start_pos) {
         mp_uint_t parent_pos = (pos - 1) >> 1;
@@ -101,7 +101,7 @@ STATIC void heap_siftdown(mp_obj_utimeq_t *heap, mp_uint_t start_pos, mp_uint_t
     heap->items[pos] = item;
 }
 
-STATIC void heap_siftup(mp_obj_utimeq_t *heap, mp_uint_t pos) {
+STATIC void utimeq_heap_siftup(mp_obj_utimeq_t *heap, mp_uint_t pos) {
     mp_uint_t start_pos = pos;
     mp_uint_t end_pos = heap->len;
     struct qentry item = heap->items[pos];
@@ -118,31 +118,31 @@ STATIC void heap_siftup(mp_obj_utimeq_t *heap, mp_uint_t pos) {
         pos = child_pos;
     }
     heap->items[pos] = item;
-    heap_siftdown(heap, start_pos, pos);
+    utimeq_heap_siftdown(heap, start_pos, pos);
 }
 
 STATIC mp_obj_t mod_utimeq_heappush(size_t n_args, const mp_obj_t *args) {
     (void)n_args;
     mp_obj_t heap_in = args[0];
-    mp_obj_utimeq_t *heap = get_heap(heap_in);
+    mp_obj_utimeq_t *heap = utimeq_get_heap(heap_in);
     if (heap->len == heap->alloc) {
-        mp_raise_msg(&mp_type_IndexError, "queue overflow");
+        mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("queue overflow"));
     }
     mp_uint_t l = heap->len;
     heap->items[l].time = MP_OBJ_SMALL_INT_VALUE(args[1]);
     heap->items[l].id = utimeq_id++;
     heap->items[l].callback = args[2];
     heap->items[l].args = args[3];
-    heap_siftdown(heap, 0, heap->len);
+    utimeq_heap_siftdown(heap, 0, heap->len);
     heap->len++;
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_utimeq_heappush_obj, 4, 4, mod_utimeq_heappush);
 
 STATIC mp_obj_t mod_utimeq_heappop(mp_obj_t heap_in, mp_obj_t list_ref) {
-    mp_obj_utimeq_t *heap = get_heap(heap_in);
+    mp_obj_utimeq_t *heap = utimeq_get_heap(heap_in);
     if (heap->len == 0) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_IndexError, "empty heap"));
+        mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("empty heap"));
     }
     mp_obj_list_t *ret = MP_OBJ_TO_PTR(list_ref);
     if (!mp_obj_is_type(list_ref, &mp_type_list) || ret->len < 3) {
@@ -158,16 +158,16 @@ STATIC mp_obj_t mod_utimeq_heappop(mp_obj_t heap_in, mp_obj_t list_ref) {
     heap->items[heap->len].callback = MP_OBJ_NULL; // so we don't retain a pointer
     heap->items[heap->len].args = MP_OBJ_NULL;
     if (heap->len) {
-        heap_siftup(heap, 0);
+        utimeq_heap_siftup(heap, 0);
     }
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_utimeq_heappop_obj, mod_utimeq_heappop);
 
 STATIC mp_obj_t mod_utimeq_peektime(mp_obj_t heap_in) {
-    mp_obj_utimeq_t *heap = get_heap(heap_in);
+    mp_obj_utimeq_t *heap = utimeq_get_heap(heap_in);
     if (heap->len == 0) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_IndexError, "empty heap"));
+        mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("empty heap"));
     }
 
     struct qentry *item = &heap->items[0];
@@ -177,7 +177,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_utimeq_peektime_obj, mod_utimeq_peektime);
 
 #if DEBUG
 STATIC mp_obj_t mod_utimeq_dump(mp_obj_t heap_in) {
-    mp_obj_utimeq_t *heap = get_heap(heap_in);
+    mp_obj_utimeq_t *heap = utimeq_get_heap(heap_in);
     for (int i = 0; i < heap->len; i++) {
         printf(UINT_FMT "\t%p\t%p\n", heap->items[i].time,
             MP_OBJ_TO_PTR(heap->items[i].callback), MP_OBJ_TO_PTR(heap->items[i].args));
@@ -190,9 +190,12 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_utimeq_dump_obj, mod_utimeq_dump);
 STATIC mp_obj_t utimeq_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
     mp_obj_utimeq_t *self = MP_OBJ_TO_PTR(self_in);
     switch (op) {
-        case MP_UNARY_OP_BOOL: return mp_obj_new_bool(self->len != 0);
-        case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(self->len);
-        default: return MP_OBJ_NULL; // op not supported
+        case MP_UNARY_OP_BOOL:
+            return mp_obj_new_bool(self->len != 0);
+        case MP_UNARY_OP_LEN:
+            return MP_OBJ_NEW_SMALL_INT(self->len);
+        default:
+            return MP_OBJ_NULL;      // op not supported
     }
 }
 
@@ -212,7 +215,7 @@ STATIC const mp_obj_type_t utimeq_type = {
     .name = MP_QSTR_utimeq,
     .make_new = utimeq_make_new,
     .unary_op = utimeq_unary_op,
-    .locals_dict = (void*)&utimeq_locals_dict,
+    .locals_dict = (void *)&utimeq_locals_dict,
 };
 
 STATIC const mp_rom_map_elem_t mp_module_utimeq_globals_table[] = {
@@ -224,7 +227,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_utimeq_globals, mp_module_utimeq_globals_t
 
 const mp_obj_module_t mp_module_utimeq = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_utimeq_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_utimeq_globals,
 };
 
-#endif //MICROPY_PY_UTIMEQ
+#endif // MICROPY_PY_UTIMEQ
diff --git a/extmod/moduwebsocket.c b/extmod/moduwebsocket.c
index eb5e20c6e3073..34b520f33706a 100644
--- a/extmod/moduwebsocket.c
+++ b/extmod/moduwebsocket.c
@@ -71,11 +71,11 @@ STATIC mp_obj_t websocket_make_new(const mp_obj_type_t *type, size_t n_args, siz
     if (n_args > 1 && args[1] == mp_const_true) {
         o->opts |= BLOCKING_WRITE;
     }
-    return  MP_OBJ_FROM_PTR(o);
+    return MP_OBJ_FROM_PTR(o);
 }
 
 STATIC mp_uint_t websocket_read(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode) {
-    mp_obj_websocket_t *self =  MP_OBJ_TO_PTR(self_in);
+    mp_obj_websocket_t *self = MP_OBJ_TO_PTR(self_in);
     const mp_stream_p_t *stream_p = mp_get_stream(self->sock);
     while (1) {
         if (self->to_recv != 0) {
@@ -183,7 +183,7 @@ STATIC mp_uint_t websocket_read(mp_obj_t self_in, void *buf, mp_uint_t size, int
                 self->msg_sz -= out_sz;
                 if (self->msg_sz == 0) {
                     byte last_state;
-no_payload:
+                no_payload:
                     last_state = self->state;
                     self->state = FRAME_HEADER;
                     self->to_recv = 2;
@@ -194,13 +194,13 @@ STATIC mp_uint_t websocket_read(mp_obj_t self_in, void *buf, mp_uint_t size, int
                     if (last_state == CONTROL) {
                         byte frame_type = self->last_flags & FRAME_OPCODE_MASK;
                         if (frame_type == FRAME_CLOSE) {
-                            static char close_resp[2] = {0x88, 0};
+                            static const char close_resp[2] = {0x88, 0};
                             int err;
                             websocket_write(self_in, close_resp, sizeof(close_resp), &err);
                             return 0;
                         }
 
-                        //DEBUG_printf("Finished receiving ctrl message %x, ignoring\n", self->last_flags);
+                        // DEBUG_printf("Finished receiving ctrl message %x, ignoring\n", self->last_flags);
                         continue;
                     }
                 }
@@ -217,7 +217,7 @@ STATIC mp_uint_t websocket_read(mp_obj_t self_in, void *buf, mp_uint_t size, int
 }
 
 STATIC mp_uint_t websocket_write(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode) {
-    mp_obj_websocket_t *self =  MP_OBJ_TO_PTR(self_in);
+    mp_obj_websocket_t *self = MP_OBJ_TO_PTR(self_in);
     assert(size < 0x10000);
     byte header[4] = {0x80 | (self->opts & FRAME_OPCODE_MASK)};
     int hdr_sz;
@@ -296,7 +296,7 @@ STATIC const mp_obj_type_t websocket_type = {
     .name = MP_QSTR_websocket,
     .make_new = websocket_make_new,
     .protocol = &websocket_stream_p,
-    .locals_dict = (void*)&websocket_locals_dict,
+    .locals_dict = (void *)&websocket_locals_dict,
 };
 
 STATIC const mp_rom_map_elem_t uwebsocket_module_globals_table[] = {
@@ -308,7 +308,7 @@ STATIC MP_DEFINE_CONST_DICT(uwebsocket_module_globals, uwebsocket_module_globals
 
 const mp_obj_module_t mp_module_uwebsocket = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&uwebsocket_module_globals,
+    .globals = (mp_obj_dict_t *)&uwebsocket_module_globals,
 };
 
 #endif // MICROPY_PY_UWEBSOCKET
diff --git a/extmod/moduzlib.c b/extmod/moduzlib.c
index f8452c72b9af8..ab70d67479b4e 100644
--- a/extmod/moduzlib.c
+++ b/extmod/moduzlib.c
@@ -49,9 +49,9 @@ typedef struct _mp_obj_decompio_t {
 } mp_obj_decompio_t;
 
 STATIC int read_src_stream(TINF_DATA *data) {
-    byte *p = (void*)data;
+    byte *p = (void *)data;
     p -= offsetof(mp_obj_decompio_t, decomp);
-    mp_obj_decompio_t *self = (mp_obj_decompio_t*)p;
+    mp_obj_decompio_t *self = (mp_obj_decompio_t *)p;
 
     const mp_stream_p_t *stream = mp_get_stream(self->src_stream);
     int err;
@@ -61,7 +61,7 @@ STATIC int read_src_stream(TINF_DATA *data) {
         mp_raise_OSError(err);
     }
     if (out_sz == 0) {
-        nlr_raise(mp_obj_new_exception(&mp_type_EOFError));
+        mp_raise_type(&mp_type_EOFError);
     }
     return c;
 }
@@ -91,8 +91,8 @@ STATIC mp_obj_t decompio_make_new(const mp_obj_type_t *type, size_t n_args, size
     } else if (dict_opt >= 0) {
         dict_opt = uzlib_zlib_parse_header(&o->decomp);
         if (dict_opt < 0) {
-header_error:
-            mp_raise_ValueError("compression header");
+        header_error:
+            mp_raise_ValueError(MP_ERROR_TEXT("compression header"));
         }
         dict_sz = 1 << dict_opt;
     } else {
@@ -110,7 +110,7 @@ STATIC mp_uint_t decompio_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *er
     }
 
     o->decomp.dest = buf;
-    o->decomp.dest_limit = (byte*)buf + size;
+    o->decomp.dest_limit = (byte *)buf + size;
     int st = uzlib_uncompress_chksum(&o->decomp);
     if (st == TINF_DONE) {
         o->eof = true;
@@ -119,9 +119,10 @@ STATIC mp_uint_t decompio_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *er
         *errcode = MP_EINVAL;
         return MP_STREAM_ERROR;
     }
-    return o->decomp.dest - (byte*)buf;
+    return o->decomp.dest - (byte *)buf;
 }
 
+#if !MICROPY_ENABLE_DYNRUNTIME
 STATIC const mp_rom_map_elem_t decompio_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
     { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
@@ -129,18 +130,21 @@ STATIC const mp_rom_map_elem_t decompio_locals_dict_table[] = {
 };
 
 STATIC MP_DEFINE_CONST_DICT(decompio_locals_dict, decompio_locals_dict_table);
+#endif
 
 STATIC const mp_stream_p_t decompio_stream_p = {
     .read = decompio_read,
 };
 
+#if !MICROPY_ENABLE_DYNRUNTIME
 STATIC const mp_obj_type_t decompio_type = {
     { &mp_type_type },
     .name = MP_QSTR_DecompIO,
     .make_new = decompio_make_new,
     .protocol = &decompio_stream_p,
-    .locals_dict = (void*)&decompio_locals_dict,
+    .locals_dict = (void *)&decompio_locals_dict,
 };
+#endif
 
 STATIC mp_obj_t mod_uzlib_decompress(size_t n_args, const mp_obj_t *args) {
     mp_obj_t data = args[0];
@@ -158,7 +162,7 @@ STATIC mp_obj_t mod_uzlib_decompress(size_t n_args, const mp_obj_t *args) {
     decomp->dest_limit = dest_buf + dest_buf_size;
     DEBUG_printf("uzlib: Initial out buffer: " UINT_FMT " bytes\n", dest_buf_size);
     decomp->source = bufinfo.buf;
-    decomp->source_limit = (byte*)bufinfo.buf + bufinfo.len;
+    decomp->source_limit = (byte *)bufinfo.buf + bufinfo.len;
 
     int st;
     bool is_zlib = true;
@@ -191,16 +195,17 @@ STATIC mp_obj_t mod_uzlib_decompress(size_t n_args, const mp_obj_t *args) {
 
     mp_uint_t final_sz = decomp->dest - dest_buf;
     DEBUG_printf("uzlib: Resizing from " UINT_FMT " to final size: " UINT_FMT " bytes\n", dest_buf_size, final_sz);
-    dest_buf = (byte*)m_renew(byte, dest_buf, dest_buf_size, final_sz);
+    dest_buf = (byte *)m_renew(byte, dest_buf, dest_buf_size, final_sz);
     mp_obj_t res = mp_obj_new_bytearray_by_ref(final_sz, dest_buf);
     m_del_obj(TINF_DATA, decomp);
     return res;
 
 error:
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_ValueError, MP_OBJ_NEW_SMALL_INT(st)));
+    nlr_raise(mp_obj_new_exception_arg1(&mp_type_ValueError, MP_OBJ_NEW_SMALL_INT(st)));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_uzlib_decompress_obj, 1, 3, mod_uzlib_decompress);
 
+#if !MICROPY_ENABLE_DYNRUNTIME
 STATIC const mp_rom_map_elem_t mp_module_uzlib_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_uzlib) },
     { MP_ROM_QSTR(MP_QSTR_decompress), MP_ROM_PTR(&mod_uzlib_decompress_obj) },
@@ -211,8 +216,9 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_uzlib_globals, mp_module_uzlib_globals_tab
 
 const mp_obj_module_t mp_module_uzlib = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_uzlib_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_uzlib_globals,
 };
+#endif
 
 // Source files #include'd here to make sure they're compiled in
 // only if module is enabled by config setting.
diff --git a/extmod/modwebrepl.c b/extmod/modwebrepl.c
index c9ef77434089c..a8430bafb3c8e 100644
--- a/extmod/modwebrepl.c
+++ b/extmod/modwebrepl.c
@@ -67,10 +67,9 @@ typedef struct _mp_obj_webrepl_t {
     mp_obj_t cur_file;
 } mp_obj_webrepl_t;
 
-// These get passed to functions which aren't force-l32, so can't be const
-STATIC char passwd_prompt[] = "Password: ";
-STATIC char connected_prompt[] = "\r\nWebREPL connected\r\n>>> ";
-STATIC char denied_prompt[] = "\r\nAccess denied\r\n";
+STATIC const char passwd_prompt[] = "Password: ";
+STATIC const char connected_prompt[] = "\r\nWebREPL connected\r\n>>> ";
+STATIC const char denied_prompt[] = "\r\nAccess denied\r\n";
 
 STATIC char webrepl_passwd[10];
 
@@ -105,7 +104,7 @@ STATIC mp_obj_t webrepl_make_new(const mp_obj_type_t *type, size_t n_args, size_
     o->data_to_recv = 0;
     o->state = STATE_PASSWD;
     write_webrepl_str(args[0], SSTR(passwd_prompt));
-    return o;
+    return MP_OBJ_FROM_PTR(o);
 }
 
 STATIC void check_file_op_finished(mp_obj_webrepl_t *self) {
@@ -138,7 +137,7 @@ STATIC void handle_op(mp_obj_webrepl_t *self) {
 
     switch (self->hdr.type) {
         case GET_VER: {
-            static char ver[] = {MICROPY_VERSION_MAJOR, MICROPY_VERSION_MINOR, MICROPY_VERSION_MICRO};
+            static const char ver[] = {MICROPY_VERSION_MAJOR, MICROPY_VERSION_MINOR, MICROPY_VERSION_MICRO};
             write_webrepl(self->sock, ver, sizeof(ver));
             self->hdr_to_recv = sizeof(struct webrepl_file);
             return;
@@ -156,7 +155,7 @@ STATIC void handle_op(mp_obj_webrepl_t *self) {
         open_args[1] = MP_OBJ_NEW_QSTR(MP_QSTR_wb);
     }
 
-    self->cur_file = mp_builtin_open(2, open_args, (mp_map_t*)&mp_const_empty_map);
+    self->cur_file = mp_builtin_open(2, open_args, (mp_map_t *)&mp_const_empty_map);
 
     #if 0
     struct mp_stream_seek_t seek = { .offset = self->hdr.offset, .whence = 0 };
@@ -188,16 +187,16 @@ STATIC mp_uint_t webrepl_read(mp_obj_t self_in, void *buf, mp_uint_t size, int *
 STATIC mp_uint_t _webrepl_read(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode) {
     // We know that os.dupterm always calls with size = 1
     assert(size == 1);
-    mp_obj_webrepl_t *self = self_in;
+    mp_obj_webrepl_t *self = MP_OBJ_TO_PTR(self_in);
     const mp_stream_p_t *sock_stream = mp_get_stream(self->sock);
     mp_uint_t out_sz = sock_stream->read(self->sock, buf, size, errcode);
-    //DEBUG_printf("webrepl: Read %d initial bytes from websocket\n", out_sz);
+    // DEBUG_printf("webrepl: Read %d initial bytes from websocket\n", out_sz);
     if (out_sz == 0 || out_sz == MP_STREAM_ERROR) {
         return out_sz;
     }
 
     if (self->state == STATE_PASSWD) {
-        char c = *(char*)buf;
+        char c = *(char *)buf;
         if (c == '\r' || c == '\n') {
             self->hdr.fname[self->data_to_recv] = 0;
             DEBUG_printf("webrepl: entered password: %s\n", self->hdr.fname);
@@ -225,8 +224,8 @@ STATIC mp_uint_t _webrepl_read(mp_obj_t self_in, void *buf, mp_uint_t size, int
     DEBUG_printf("webrepl: received bin data, hdr_to_recv: %d, data_to_recv=%d\n", self->hdr_to_recv, self->data_to_recv);
 
     if (self->hdr_to_recv != 0) {
-        char *p = (char*)&self->hdr + sizeof(self->hdr) - self->hdr_to_recv;
-        *p++ = *(char*)buf;
+        char *p = (char *)&self->hdr + sizeof(self->hdr) - self->hdr_to_recv;
+        *p++ = *(char *)buf;
         if (--self->hdr_to_recv != 0) {
             mp_uint_t hdr_sz = sock_stream->read(self->sock, p, self->hdr_to_recv, errcode);
             if (hdr_sz == MP_STREAM_ERROR) {
@@ -246,8 +245,12 @@ STATIC mp_uint_t _webrepl_read(mp_obj_t self_in, void *buf, mp_uint_t size, int
     }
 
     if (self->data_to_recv != 0) {
-        static byte filebuf[512];
-        filebuf[0] = *(byte*)buf;
+        // Ports that don't have much available stack can make this filebuf static
+        #if MICROPY_PY_WEBREPL_STATIC_FILEBUF
+        static
+        #endif
+        byte filebuf[512];
+        filebuf[0] = *(byte *)buf;
         mp_uint_t buf_sz = 1;
         if (--self->data_to_recv != 0) {
             size_t to_read = MIN(sizeof(filebuf) - 1, self->data_to_recv);
@@ -291,7 +294,7 @@ STATIC mp_uint_t _webrepl_read(mp_obj_t self_in, void *buf, mp_uint_t size, int
 }
 
 STATIC mp_uint_t webrepl_write(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode) {
-    mp_obj_webrepl_t *self = self_in;
+    mp_obj_webrepl_t *self = MP_OBJ_TO_PTR(self_in);
     if (self->state == STATE_PASSWD) {
         // Don't forward output until passwd is entered
         return size;
@@ -345,7 +348,7 @@ STATIC const mp_obj_type_t webrepl_type = {
     .name = MP_QSTR__webrepl,
     .make_new = webrepl_make_new,
     .protocol = &webrepl_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&webrepl_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&webrepl_locals_dict,
 };
 
 STATIC const mp_rom_map_elem_t webrepl_module_globals_table[] = {
@@ -358,7 +361,7 @@ STATIC MP_DEFINE_CONST_DICT(webrepl_module_globals, webrepl_module_globals_table
 
 const mp_obj_module_t mp_module_webrepl = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&webrepl_module_globals,
+    .globals = (mp_obj_dict_t *)&webrepl_module_globals,
 };
 
 #endif // MICROPY_PY_WEBREPL
diff --git a/extmod/network_cyw43.c b/extmod/network_cyw43.c
new file mode 100644
index 0000000000000..adbe427b1dffc
--- /dev/null
+++ b/extmod/network_cyw43.c
@@ -0,0 +1,460 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include "py/runtime.h"
+#include "py/objstr.h"
+#include "py/mphal.h"
+
+#if MICROPY_PY_NETWORK_CYW43
+
+#include "lwip/netif.h"
+#include "drivers/cyw43/cyw43.h"
+#include "extmod/network_cyw43.h"
+#include "modnetwork.h"
+
+typedef struct _network_cyw43_obj_t {
+    mp_obj_base_t base;
+    cyw43_t *cyw;
+    int itf;
+} network_cyw43_obj_t;
+
+STATIC const network_cyw43_obj_t network_cyw43_wl0 = { { &mp_network_cyw43_type }, &cyw43_state, 0 };
+STATIC const network_cyw43_obj_t network_cyw43_wl1 = { { &mp_network_cyw43_type }, &cyw43_state, 1 };
+
+STATIC void network_cyw43_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    network_cyw43_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    struct netif *netif = &self->cyw->netif[self->itf];
+    int status = cyw43_tcpip_link_status(self->cyw, self->itf);
+    const char *status_str;
+    if (status == CYW43_LINK_DOWN) {
+        status_str = "down";
+    } else if (status == CYW43_LINK_JOIN || status == CYW43_LINK_NOIP) {
+        status_str = "join";
+    } else if (status == CYW43_LINK_UP) {
+        status_str = "up";
+    } else if (status == CYW43_LINK_NONET) {
+        status_str = "nonet";
+    } else if (status == CYW43_LINK_BADAUTH) {
+        status_str = "badauth";
+    } else {
+        status_str = "fail";
+    }
+    mp_printf(print, "<CYW43 %s %s %u.%u.%u.%u>",
+        self->itf == 0 ? "STA" : "AP",
+        status_str,
+        netif->ip_addr.addr & 0xff,
+        netif->ip_addr.addr >> 8 & 0xff,
+        netif->ip_addr.addr >> 16 & 0xff,
+        netif->ip_addr.addr >> 24
+        );
+}
+
+STATIC mp_obj_t network_cyw43_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 0, 1, false);
+    if (n_args == 0 || mp_obj_get_int(args[0]) == 0) {
+        return MP_OBJ_FROM_PTR(&network_cyw43_wl0);
+    } else {
+        return MP_OBJ_FROM_PTR(&network_cyw43_wl1);
+    }
+}
+
+STATIC mp_obj_t network_cyw43_send_ethernet(mp_obj_t self_in, mp_obj_t buf_in) {
+    network_cyw43_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_buffer_info_t buf;
+    mp_get_buffer_raise(buf_in, &buf, MP_BUFFER_READ);
+    int ret = cyw43_send_ethernet(self->cyw, self->itf, buf.len, buf.buf, false);
+    if (ret) {
+        mp_raise_OSError(-ret);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(network_cyw43_send_ethernet_obj, network_cyw43_send_ethernet);
+
+STATIC mp_obj_t network_cyw43_ioctl(mp_obj_t self_in, mp_obj_t cmd_in, mp_obj_t buf_in) {
+    network_cyw43_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_buffer_info_t buf;
+    mp_get_buffer_raise(buf_in, &buf, MP_BUFFER_READ | MP_BUFFER_WRITE);
+    cyw43_ioctl(self->cyw, mp_obj_get_int(cmd_in), buf.len, buf.buf, self->itf);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(network_cyw43_ioctl_obj, network_cyw43_ioctl);
+
+/*******************************************************************************/
+// network API
+
+STATIC mp_obj_t network_cyw43_deinit(mp_obj_t self_in) {
+    network_cyw43_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    cyw43_deinit(self->cyw);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(network_cyw43_deinit_obj, network_cyw43_deinit);
+
+STATIC mp_obj_t network_cyw43_active(size_t n_args, const mp_obj_t *args) {
+    network_cyw43_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    if (n_args == 1) {
+        return mp_obj_new_bool(cyw43_tcpip_link_status(self->cyw, self->itf));
+    } else {
+        cyw43_wifi_set_up(self->cyw, self->itf, mp_obj_is_true(args[1]));
+        return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(network_cyw43_active_obj, 1, 2, network_cyw43_active);
+
+STATIC int network_cyw43_scan_cb(void *env, const cyw43_ev_scan_result_t *res) {
+    mp_obj_t list = MP_OBJ_FROM_PTR(env);
+
+    // Search for existing BSSID to remove duplicates
+    bool found = false;
+    size_t len;
+    mp_obj_t *items;
+    mp_obj_get_array(list, &len, &items);
+    for (size_t i = 0; i < len; ++i) {
+        mp_obj_tuple_t *t = MP_OBJ_TO_PTR(items[i]);
+        if (memcmp(res->bssid, ((mp_obj_str_t *)MP_OBJ_TO_PTR(t->items[1]))->data, sizeof(res->bssid)) == 0) {
+            if (res->rssi > MP_OBJ_SMALL_INT_VALUE(t->items[3])) {
+                t->items[3] = MP_OBJ_NEW_SMALL_INT(res->rssi);
+            }
+            t->items[5] = MP_OBJ_NEW_SMALL_INT(MP_OBJ_SMALL_INT_VALUE(t->items[5]) + 1);
+            found = true;
+            break;
+        }
+    }
+
+    // Add to list of results if wanted
+    if (!found) {
+        mp_obj_t tuple[6] = {
+            mp_obj_new_bytes(res->ssid, res->ssid_len),
+            mp_obj_new_bytes(res->bssid, sizeof(res->bssid)),
+            MP_OBJ_NEW_SMALL_INT(res->channel),
+            MP_OBJ_NEW_SMALL_INT(res->rssi),
+            MP_OBJ_NEW_SMALL_INT(res->auth_mode),
+            // mp_const_false, // hidden
+            MP_OBJ_NEW_SMALL_INT(1), // N
+        };
+        mp_obj_list_append(list, mp_obj_new_tuple(6, tuple));
+    }
+
+    return 0; // continue scan
+}
+
+STATIC mp_obj_t network_cyw43_scan(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_passive, ARG_essid, ARG_bssid };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_passive, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
+        { MP_QSTR_essid, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_bssid, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+    };
+
+    network_cyw43_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    cyw43_wifi_scan_options_t opts;
+    opts.scan_type = args[ARG_passive].u_bool ? 1 : 0;
+    if (args[ARG_essid].u_obj == mp_const_none) {
+        opts.ssid_len = 0;
+    } else {
+        mp_buffer_info_t ssid;
+        mp_get_buffer_raise(args[ARG_essid].u_obj, &ssid, MP_BUFFER_READ);
+        opts.ssid_len = MIN(ssid.len, sizeof(opts.ssid));
+        memcpy(opts.ssid, ssid.buf, opts.ssid_len);
+    }
+    if (args[ARG_bssid].u_obj == mp_const_none) {
+        memset(opts.bssid, 0xff, sizeof(opts.bssid));
+    } else {
+        mp_buffer_info_t bssid;
+        mp_get_buffer_raise(args[ARG_bssid].u_obj, &bssid, MP_BUFFER_READ);
+        memcpy(opts.bssid, bssid.buf, sizeof(opts.bssid));
+    }
+
+    mp_obj_t res = mp_obj_new_list(0, NULL);
+    int scan_res = cyw43_wifi_scan(self->cyw, &opts, MP_OBJ_TO_PTR(res), network_cyw43_scan_cb);
+
+    if (scan_res < 0) {
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("STA must be active"));
+    }
+
+    // Wait for scan to finish, with a 10s timeout
+    uint32_t start = mp_hal_ticks_ms();
+    while (cyw43_wifi_scan_active(self->cyw) && mp_hal_ticks_ms() - start < 10000) {
+        MICROPY_EVENT_POLL_HOOK
+    }
+
+    return res;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(network_cyw43_scan_obj, 1, network_cyw43_scan);
+
+STATIC mp_obj_t network_cyw43_connect(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_essid, ARG_key, ARG_auth, ARG_bssid, ARG_channel };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_essid, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_key, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_auth, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+        { MP_QSTR_bssid, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_channel, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+    };
+
+    network_cyw43_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    mp_buffer_info_t ssid;
+    mp_get_buffer_raise(args[ARG_essid].u_obj, &ssid, MP_BUFFER_READ);
+    mp_buffer_info_t key;
+    key.buf = NULL;
+    if (args[ARG_key].u_obj != mp_const_none) {
+        mp_get_buffer_raise(args[ARG_key].u_obj, &key, MP_BUFFER_READ);
+    }
+    mp_buffer_info_t bssid;
+    bssid.buf = NULL;
+    if (args[ARG_bssid].u_obj != mp_const_none) {
+        mp_get_buffer_raise(args[ARG_bssid].u_obj, &bssid, MP_BUFFER_READ);
+        if (bssid.len != 6) {
+            mp_raise_ValueError(NULL);
+        }
+    }
+    int ret = cyw43_wifi_join(self->cyw, ssid.len, ssid.buf, key.len, key.buf, args[ARG_auth].u_int, bssid.buf, args[ARG_channel].u_int);
+    if (ret != 0) {
+        mp_raise_OSError(ret);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(network_cyw43_connect_obj, 1, network_cyw43_connect);
+
+STATIC mp_obj_t network_cyw43_disconnect(mp_obj_t self_in) {
+    network_cyw43_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    cyw43_wifi_leave(self->cyw, self->itf);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(network_cyw43_disconnect_obj, network_cyw43_disconnect);
+
+STATIC mp_obj_t network_cyw43_isconnected(mp_obj_t self_in) {
+    network_cyw43_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    return mp_obj_new_bool(cyw43_tcpip_link_status(self->cyw, self->itf) == 3);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(network_cyw43_isconnected_obj, network_cyw43_isconnected);
+
+STATIC mp_obj_t network_cyw43_ifconfig(size_t n_args, const mp_obj_t *args) {
+    network_cyw43_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    return mod_network_nic_ifconfig(&self->cyw->netif[self->itf], n_args - 1, args + 1);
+}
+MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(network_cyw43_ifconfig_obj, 1, 2, network_cyw43_ifconfig);
+
+STATIC mp_obj_t network_cyw43_status(size_t n_args, const mp_obj_t *args) {
+    network_cyw43_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    (void)self;
+
+    if (n_args == 1) {
+        // no arguments: return link status
+        return MP_OBJ_NEW_SMALL_INT(cyw43_tcpip_link_status(self->cyw, self->itf));
+    }
+
+    // one argument: return status based on query parameter
+    switch (mp_obj_str_get_qstr(args[1])) {
+        case MP_QSTR_stations: {
+            // return list of connected stations
+            if (self->itf != CYW43_ITF_AP) {
+                mp_raise_ValueError(MP_ERROR_TEXT("AP required"));
+            }
+            int num_stas;
+            uint8_t macs[32 * 6];
+            cyw43_wifi_ap_get_stas(self->cyw, &num_stas, macs);
+            mp_obj_t list = mp_obj_new_list(num_stas, NULL);
+            for (int i = 0; i < num_stas; ++i) {
+                mp_obj_t tuple[1] = {
+                    mp_obj_new_bytes(&macs[i * 6], 6),
+                };
+                ((mp_obj_list_t *)MP_OBJ_TO_PTR(list))->items[i] = mp_obj_new_tuple(1, tuple);
+            }
+            return list;
+        }
+    }
+
+    mp_raise_ValueError(MP_ERROR_TEXT("unknown status param"));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(network_cyw43_status_obj, 1, 2, network_cyw43_status);
+
+static inline uint32_t nw_get_le32(const uint8_t *buf) {
+    return buf[0] | buf[1] << 8 | buf[2] << 16 | buf[3] << 24;
+}
+
+static inline void nw_put_le32(uint8_t *buf, uint32_t x) {
+    buf[0] = x;
+    buf[1] = x >> 8;
+    buf[2] = x >> 16;
+    buf[3] = x >> 24;
+}
+
+STATIC mp_obj_t network_cyw43_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
+    network_cyw43_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+
+    if (kwargs->used == 0) {
+        // Get config value
+        if (n_args != 2) {
+            mp_raise_TypeError(MP_ERROR_TEXT("must query one param"));
+        }
+
+        switch (mp_obj_str_get_qstr(args[1])) {
+            case MP_QSTR_antenna: {
+                uint8_t buf[4];
+                cyw43_ioctl(self->cyw, CYW43_IOCTL_GET_ANTDIV, 4, buf, self->itf);
+                return MP_OBJ_NEW_SMALL_INT(nw_get_le32(buf));
+            }
+            case MP_QSTR_channel: {
+                uint8_t buf[4];
+                cyw43_ioctl(self->cyw, CYW43_IOCTL_GET_CHANNEL, 4, buf, self->itf);
+                return MP_OBJ_NEW_SMALL_INT(nw_get_le32(buf));
+            }
+            case MP_QSTR_essid: {
+                if (self->itf == CYW43_ITF_STA) {
+                    uint8_t buf[36];
+                    cyw43_ioctl(self->cyw, CYW43_IOCTL_GET_SSID, 36, buf, self->itf);
+                    return mp_obj_new_str((const char *)buf + 4, nw_get_le32(buf));
+                } else {
+                    size_t len;
+                    const uint8_t *buf;
+                    cyw43_wifi_ap_get_ssid(self->cyw, &len, &buf);
+                    return mp_obj_new_str((const char *)buf, len);
+                }
+            }
+            case MP_QSTR_mac: {
+                uint8_t buf[6];
+                cyw43_wifi_get_mac(self->cyw, self->itf, buf);
+                return mp_obj_new_bytes(buf, 6);
+            }
+            case MP_QSTR_txpower: {
+                uint8_t buf[13];
+                memcpy(buf, "qtxpower\x00\x00\x00\x00\x00", 13);
+                cyw43_ioctl(self->cyw, CYW43_IOCTL_GET_VAR, 13, buf, self->itf);
+                return MP_OBJ_NEW_SMALL_INT(nw_get_le32(buf) / 4);
+            }
+            default:
+                mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
+        }
+    } else {
+        // Set config value(s)
+        if (n_args != 1) {
+            mp_raise_TypeError(MP_ERROR_TEXT("can't specify pos and kw args"));
+        }
+
+        for (size_t i = 0; i < kwargs->alloc; ++i) {
+            if (MP_MAP_SLOT_IS_FILLED(kwargs, i)) {
+                mp_map_elem_t *e = &kwargs->table[i];
+                switch (mp_obj_str_get_qstr(e->key)) {
+                    case MP_QSTR_antenna: {
+                        uint8_t buf[4];
+                        nw_put_le32(buf, mp_obj_get_int(e->value));
+                        cyw43_ioctl(self->cyw, CYW43_IOCTL_SET_ANTDIV, 4, buf, self->itf);
+                        break;
+                    }
+                    case MP_QSTR_channel: {
+                        cyw43_wifi_ap_set_channel(self->cyw, mp_obj_get_int(e->value));
+                        break;
+                    }
+                    case MP_QSTR_essid: {
+                        size_t len;
+                        const char *str = mp_obj_str_get_data(e->value, &len);
+                        cyw43_wifi_ap_set_ssid(self->cyw, len, (const uint8_t *)str);
+                        break;
+                    }
+                    case MP_QSTR_monitor: {
+                        mp_int_t value = mp_obj_get_int(e->value);
+                        uint8_t buf[9 + 4];
+                        memcpy(buf, "allmulti\x00", 9);
+                        nw_put_le32(buf + 9, value);
+                        cyw43_ioctl(self->cyw, CYW43_IOCTL_SET_VAR, 9 + 4, buf, self->itf);
+                        nw_put_le32(buf, value);
+                        cyw43_ioctl(self->cyw, CYW43_IOCTL_SET_MONITOR, 4, buf, self->itf);
+                        if (value) {
+                            self->cyw->trace_flags |= CYW43_TRACE_MAC;
+                        } else {
+                            self->cyw->trace_flags &= ~CYW43_TRACE_MAC;
+                        }
+                        break;
+                    }
+                    case MP_QSTR_password: {
+                        size_t len;
+                        const char *str = mp_obj_str_get_data(e->value, &len);
+                        cyw43_wifi_ap_set_password(self->cyw, len, (const uint8_t *)str);
+                        break;
+                    }
+                    case MP_QSTR_pm: {
+                        cyw43_wifi_pm(self->cyw, mp_obj_get_int(e->value));
+                        break;
+                    }
+                    case MP_QSTR_trace: {
+                        self->cyw->trace_flags = mp_obj_get_int(e->value);
+                        break;
+                    }
+                    case MP_QSTR_txpower: {
+                        mp_int_t dbm = mp_obj_get_int(e->value);
+                        uint8_t buf[9 + 4];
+                        memcpy(buf, "qtxpower\x00", 9);
+                        nw_put_le32(buf + 9, dbm * 4);
+                        cyw43_ioctl(self->cyw, CYW43_IOCTL_SET_VAR, 9 + 4, buf, self->itf);
+                        break;
+                    }
+                    default:
+                        mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
+                }
+            }
+        }
+
+        return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(network_cyw43_config_obj, 1, network_cyw43_config);
+
+/*******************************************************************************/
+// class bindings
+
+STATIC const mp_rom_map_elem_t network_cyw43_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_send_ethernet), MP_ROM_PTR(&network_cyw43_send_ethernet_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ioctl), MP_ROM_PTR(&network_cyw43_ioctl_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&network_cyw43_deinit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_active), MP_ROM_PTR(&network_cyw43_active_obj) },
+    { MP_ROM_QSTR(MP_QSTR_scan), MP_ROM_PTR(&network_cyw43_scan_obj) },
+    { MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&network_cyw43_connect_obj) },
+    { MP_ROM_QSTR(MP_QSTR_disconnect), MP_ROM_PTR(&network_cyw43_disconnect_obj) },
+    { MP_ROM_QSTR(MP_QSTR_isconnected), MP_ROM_PTR(&network_cyw43_isconnected_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ifconfig), MP_ROM_PTR(&network_cyw43_ifconfig_obj) },
+    { MP_ROM_QSTR(MP_QSTR_status), MP_ROM_PTR(&network_cyw43_status_obj) },
+    { MP_ROM_QSTR(MP_QSTR_config), MP_ROM_PTR(&network_cyw43_config_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(network_cyw43_locals_dict, network_cyw43_locals_dict_table);
+
+const mp_obj_type_t mp_network_cyw43_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_CYW43,
+    .print = network_cyw43_print,
+    .make_new = network_cyw43_make_new,
+    .locals_dict = (mp_obj_dict_t *)&network_cyw43_locals_dict,
+};
+
+#endif // MICROPY_PY_NETWORK_CYW43
diff --git a/extmod/network_cyw43.h b/extmod/network_cyw43.h
new file mode 100644
index 0000000000000..4228bf6e8f91a
--- /dev/null
+++ b/extmod/network_cyw43.h
@@ -0,0 +1,31 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_EXTMOD_NETWORK_CYW43_H
+#define MICROPY_INCLUDED_EXTMOD_NETWORK_CYW43_H
+
+extern const mp_obj_type_t mp_network_cyw43_type;
+
+#endif // MICROPY_INCLUDED_EXTMOD_NETWORK_CYW43_H
diff --git a/extmod/nimble/bsp/bsp.h b/extmod/nimble/bsp/bsp.h
new file mode 100644
index 0000000000000..8b1a393741c96
--- /dev/null
+++ b/extmod/nimble/bsp/bsp.h
@@ -0,0 +1 @@
+// empty
diff --git a/extmod/nimble/hal/hal_gpio.h b/extmod/nimble/hal/hal_gpio.h
new file mode 100644
index 0000000000000..8b1a393741c96
--- /dev/null
+++ b/extmod/nimble/hal/hal_gpio.h
@@ -0,0 +1 @@
+// empty
diff --git a/extmod/nimble/hal/hal_uart.c b/extmod/nimble/hal/hal_uart.c
new file mode 100644
index 0000000000000..fba82b830438a
--- /dev/null
+++ b/extmod/nimble/hal/hal_uart.c
@@ -0,0 +1,85 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "pin_static_af.h"
+#include "nimble/ble.h"
+#include "extmod/nimble/hal/hal_uart.h"
+#include "extmod/modbluetooth_hci.h"
+#include "extmod/nimble/nimble/nimble_hci_uart.h"
+
+#if MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_NIMBLE
+
+static hal_uart_tx_cb_t hal_uart_tx_cb;
+static void *hal_uart_tx_arg;
+static hal_uart_rx_cb_t hal_uart_rx_cb;
+static void *hal_uart_rx_arg;
+
+int hal_uart_init_cbs(uint32_t port, hal_uart_tx_cb_t tx_cb, void *tx_arg, hal_uart_rx_cb_t rx_cb, void *rx_arg) {
+    hal_uart_tx_cb = tx_cb;
+    hal_uart_tx_arg = tx_arg;
+    hal_uart_rx_cb = rx_cb;
+    hal_uart_rx_arg = rx_arg;
+    return 0; // success
+}
+
+int hal_uart_config(uint32_t port, uint32_t baudrate, uint32_t bits, uint32_t stop, uint32_t parity, uint32_t flow) {
+    mp_bluetooth_hci_uart_init(port);
+    mp_bluetooth_hci_uart_set_baudrate(baudrate);
+    return mp_bluetooth_hci_uart_activate();
+}
+
+void hal_uart_start_tx(uint32_t port) {
+    size_t len = 0;
+    for (;;) {
+        int data = hal_uart_tx_cb(hal_uart_tx_arg);
+        if (data == -1) {
+            break;
+        }
+        mp_bluetooth_hci_cmd_buf[len++] = data;
+    }
+
+    #if 0
+    printf("[% 8d] BTUTX: %02x", mp_hal_ticks_ms(), hci_cmd_buf[0]);
+    for (int i = 1; i < len; ++i) {
+        printf(":%02x", hci_cmd_buf[i]);
+    }
+    printf("\n");
+    #endif
+
+    mp_bluetooth_nimble_hci_uart_tx_strn((void*)mp_bluetooth_hci_cmd_buf, len);
+}
+
+int hal_uart_close(uint32_t port) {
+    return 0; // success
+}
+
+void mp_bluetooth_nimble_hci_uart_process(void) {
+    mp_bluetooth_nimble_hci_uart_rx(hal_uart_rx_cb, hal_uart_rx_arg);
+}
+
+#endif // MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_NIMBLE
diff --git a/extmod/nimble/hal/hal_uart.h b/extmod/nimble/hal/hal_uart.h
new file mode 100644
index 0000000000000..0ef04bc81e026
--- /dev/null
+++ b/extmod/nimble/hal/hal_uart.h
@@ -0,0 +1,19 @@
+#ifndef MICROPY_INCLUDED_EXTMOD_NIMBLE_HAL_HAL_UART_H
+#define MICROPY_INCLUDED_EXTMOD_NIMBLE_HAL_HAL_UART_H
+
+#include <stdint.h>
+
+#define SYSINIT_PANIC_ASSERT_MSG(cond, msg)
+
+#define HAL_UART_PARITY_NONE (0)
+
+typedef int (*hal_uart_tx_cb_t)(void *arg);
+typedef int (*hal_uart_rx_cb_t)(void *arg, uint8_t data);
+
+// Called by NimBLE, implemented in hal_uart.c.
+int hal_uart_init_cbs(uint32_t port, hal_uart_tx_cb_t tx_cb, void *tx_arg, hal_uart_rx_cb_t rx_cb, void *rx_arg);
+int hal_uart_config(uint32_t port, uint32_t baud, uint32_t bits, uint32_t stop, uint32_t parity, uint32_t flow);
+void hal_uart_start_tx(uint32_t port);
+int hal_uart_close(uint32_t port);
+
+#endif // MICROPY_INCLUDED_EXTMOD_NIMBLE_HAL_HAL_UART_H
diff --git a/extmod/nimble/modbluetooth_nimble.c b/extmod/nimble/modbluetooth_nimble.c
new file mode 100644
index 0000000000000..e2e95aa74eb6b
--- /dev/null
+++ b/extmod/nimble/modbluetooth_nimble.c
@@ -0,0 +1,866 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ * Copyright (c) 2019 Jim Mussared
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+#include "py/mphal.h"
+
+#if MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_NIMBLE
+
+#include "extmod/nimble/modbluetooth_nimble.h"
+#include "extmod/modbluetooth.h"
+
+#include "host/ble_hs.h"
+#include "host/util/util.h"
+#include "nimble/ble.h"
+#include "nimble/nimble_port.h"
+#include "services/gap/ble_svc_gap.h"
+
+#ifndef MICROPY_PY_BLUETOOTH_DEFAULT_GAP_NAME
+#define MICROPY_PY_BLUETOOTH_DEFAULT_GAP_NAME "MPY NIMBLE"
+#endif
+
+#define DEBUG_EVENT_printf(...) //printf(__VA_ARGS__)
+
+#define ERRNO_BLUETOOTH_NOT_ACTIVE MP_ENODEV
+
+// Any BLE_HS_xxx code not in this table will default to MP_EIO.
+STATIC int8_t ble_hs_err_to_errno_table[] = {
+    [BLE_HS_EAGAIN] = MP_EAGAIN,
+    [BLE_HS_EALREADY] = MP_EALREADY,
+    [BLE_HS_EINVAL] = MP_EINVAL,
+    [BLE_HS_ENOENT] = MP_ENOENT,
+    [BLE_HS_ENOMEM] = MP_ENOMEM,
+    [BLE_HS_ENOTCONN] = MP_ENOTCONN,
+    [BLE_HS_ENOTSUP] = MP_EOPNOTSUPP,
+    [BLE_HS_ETIMEOUT] = MP_ETIMEDOUT,
+    [BLE_HS_EDONE] = MP_EIO,               // TODO: Maybe should be MP_EISCONN (connect uses this for "already connected").
+    [BLE_HS_EBUSY] = MP_EBUSY,
+};
+
+STATIC int ble_hs_err_to_errno(int err) {
+    if (!err) {
+        return 0;
+    }
+    if (0 <= err && err < MP_ARRAY_SIZE(ble_hs_err_to_errno_table) && ble_hs_err_to_errno_table[err]) {
+        return ble_hs_err_to_errno_table[err];
+    } else {
+        return MP_EIO;
+    }
+}
+
+// Note: modbluetooth UUIDs store their data in LE.
+STATIC ble_uuid_t *create_nimble_uuid(const mp_obj_bluetooth_uuid_t *uuid) {
+    if (uuid->type == MP_BLUETOOTH_UUID_TYPE_16) {
+        ble_uuid16_t *result = m_new(ble_uuid16_t, 1);
+        result->u.type = BLE_UUID_TYPE_16;
+        result->value = (uuid->data[1] << 8) | uuid->data[0];
+        return (ble_uuid_t *)result;
+    } else if (uuid->type == MP_BLUETOOTH_UUID_TYPE_32) {
+        ble_uuid32_t *result = m_new(ble_uuid32_t, 1);
+        result->u.type = BLE_UUID_TYPE_32;
+        result->value = (uuid->data[1] << 24) | (uuid->data[1] << 16) | (uuid->data[1] << 8) | uuid->data[0];
+        return (ble_uuid_t *)result;
+    } else if (uuid->type == MP_BLUETOOTH_UUID_TYPE_128) {
+        ble_uuid128_t *result = m_new(ble_uuid128_t, 1);
+        result->u.type = BLE_UUID_TYPE_128;
+        memcpy(result->value, uuid->data, 16);
+        return (ble_uuid_t *)result;
+    } else {
+        return NULL;
+    }
+}
+
+#if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+
+STATIC mp_obj_bluetooth_uuid_t create_mp_uuid(const ble_uuid_any_t *uuid) {
+    mp_obj_bluetooth_uuid_t result;
+    switch (uuid->u.type) {
+        case BLE_UUID_TYPE_16:
+            result.type = MP_BLUETOOTH_UUID_TYPE_16;
+            result.data[0] = uuid->u16.value & 0xff;
+            result.data[1] = (uuid->u16.value >> 8) & 0xff;
+            break;
+        case BLE_UUID_TYPE_32:
+            result.type = MP_BLUETOOTH_UUID_TYPE_32;
+            result.data[0] = uuid->u32.value & 0xff;
+            result.data[1] = (uuid->u32.value >> 8) & 0xff;
+            result.data[2] = (uuid->u32.value >> 16) & 0xff;
+            result.data[3] = (uuid->u32.value >> 24) & 0xff;
+            break;
+        case BLE_UUID_TYPE_128:
+            result.type = MP_BLUETOOTH_UUID_TYPE_128;
+            memcpy(result.data, uuid->u128.value, 16);
+            break;
+        default:
+            assert(false);
+    }
+    return result;
+}
+
+// modbluetooth (and the layers above it) work in BE for addresses, Nimble works in LE.
+STATIC void reverse_addr_byte_order(uint8_t *addr_out, const uint8_t *addr_in) {
+    for (int i = 0; i < 6; ++i) {
+        addr_out[i] = addr_in[5 - i];
+    }
+}
+
+STATIC ble_addr_t create_nimble_addr(uint8_t addr_type, const uint8_t *addr) {
+    ble_addr_t addr_nimble;
+    addr_nimble.type = addr_type;
+    // Incoming addr is from modbluetooth (BE), so copy and convert to LE for Nimble.
+    reverse_addr_byte_order(addr_nimble.val, addr);
+    return addr_nimble;
+}
+
+#endif // MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+
+volatile int mp_bluetooth_nimble_ble_state = MP_BLUETOOTH_NIMBLE_BLE_STATE_OFF;
+
+STATIC void reset_cb(int reason) {
+    (void)reason;
+}
+
+STATIC void sync_cb(void) {
+    int rc;
+    ble_addr_t addr;
+
+    rc = ble_hs_util_ensure_addr(0); // prefer public address
+    if (rc != 0) {
+        // https://mynewt.apache.org/latest/tutorials/ble/eddystone.html#configure-the-nimble-stack-with-an-address
+        #if MICROPY_PY_BLUETOOTH_RANDOM_ADDR
+        rc = ble_hs_id_gen_rnd(1, &addr);
+        assert(rc == 0);
+        rc = ble_hs_id_set_rnd(addr.val);
+        assert(rc == 0);
+        #else
+        uint8_t addr_be[6];
+        mp_hal_get_mac(MP_HAL_MAC_BDADDR, addr_be);
+        reverse_addr_byte_order(addr.val, addr_be);
+        // ble_hs_id_set_pub(addr.val);
+        rc = ble_hs_id_set_rnd(addr.val);
+        assert(rc == 0);
+        #endif
+
+        rc = ble_hs_util_ensure_addr(0); // prefer public address
+        assert(rc == 0);
+    }
+
+    if (MP_BLUETOOTH_DEFAULT_ATTR_LEN > 20) {
+        rc = ble_att_set_preferred_mtu(MP_BLUETOOTH_DEFAULT_ATTR_LEN + 3);
+        assert(rc == 0);
+    }
+
+    ble_svc_gap_device_name_set(MICROPY_PY_BLUETOOTH_DEFAULT_GAP_NAME);
+
+    mp_bluetooth_nimble_ble_state = MP_BLUETOOTH_NIMBLE_BLE_STATE_ACTIVE;
+}
+
+STATIC void gatts_register_cb(struct ble_gatt_register_ctxt *ctxt, void *arg) {
+    if (!mp_bluetooth_is_active()) {
+        return;
+    }
+    switch (ctxt->op) {
+        case BLE_GATT_REGISTER_OP_SVC:
+            // Called when a service is successfully registered.
+            DEBUG_EVENT_printf("gatts_register_cb: svc uuid=%p handle=%d\n", &ctxt->svc.svc_def->uuid, ctxt->svc.handle);
+            break;
+
+        case BLE_GATT_REGISTER_OP_CHR:
+            // Called when a characteristic is successfully registered.
+            DEBUG_EVENT_printf("gatts_register_cb: chr uuid=%p def_handle=%d val_handle=%d\n", &ctxt->chr.chr_def->uuid, ctxt->chr.def_handle, ctxt->chr.val_handle);
+
+            // Note: We will get this event for the default GAP Service, meaning that we allocate storage for the
+            // "device name" and "appearance" characteristics, even though we never see the reads for them.
+            // TODO: Possibly check if the service UUID is 0x1801 and ignore?
+
+            // Allocate the gatts_db storage for this characteristic.
+            // Although this function is a callback, it's called synchronously from ble_hs_sched_start/ble_gatts_start, so safe to allocate.
+            mp_bluetooth_gatts_db_create_entry(MP_STATE_PORT(bluetooth_nimble_root_pointers)->gatts_db, ctxt->chr.val_handle, MP_BLUETOOTH_DEFAULT_ATTR_LEN);
+            break;
+
+        case BLE_GATT_REGISTER_OP_DSC:
+            // Called when a descriptor is successfully registered.
+            // Note: This is event is not called for the CCCD.
+            DEBUG_EVENT_printf("gatts_register_cb: dsc uuid=%p handle=%d\n", &ctxt->dsc.dsc_def->uuid, ctxt->dsc.handle);
+
+            // See above, safe to alloc.
+            mp_bluetooth_gatts_db_create_entry(MP_STATE_PORT(bluetooth_nimble_root_pointers)->gatts_db, ctxt->dsc.handle, MP_BLUETOOTH_DEFAULT_ATTR_LEN);
+
+            // Unlike characteristics, we have to manually provide a way to get the handle back to the register method.
+            *((uint16_t *)ctxt->dsc.dsc_def->arg) = ctxt->dsc.handle;
+            break;
+
+        default:
+            DEBUG_EVENT_printf("gatts_register_cb: unknown op %d\n", ctxt->op);
+            break;
+    }
+}
+
+STATIC int gap_event_cb(struct ble_gap_event *event, void *arg) {
+    DEBUG_EVENT_printf("gap_event_cb: type=%d\n", event->type);
+    if (!mp_bluetooth_is_active()) {
+        return 0;
+    }
+    struct ble_gap_conn_desc desc;
+    uint8_t addr[6] = {0};
+
+    switch (event->type) {
+        case BLE_GAP_EVENT_CONNECT:
+            if (event->connect.status == 0) {
+                // Connection established.
+                ble_gap_conn_find(event->connect.conn_handle, &desc);
+                reverse_addr_byte_order(addr, desc.peer_id_addr.val);
+                mp_bluetooth_gap_on_connected_disconnected(MP_BLUETOOTH_IRQ_CENTRAL_CONNECT, event->connect.conn_handle, desc.peer_id_addr.type, addr);
+            } else {
+                // Connection failed.
+                mp_bluetooth_gap_on_connected_disconnected(MP_BLUETOOTH_IRQ_CENTRAL_DISCONNECT, event->connect.conn_handle, 0xff, addr);
+            }
+            break;
+
+        case BLE_GAP_EVENT_DISCONNECT:
+            // Disconnect.
+            reverse_addr_byte_order(addr, event->disconnect.conn.peer_id_addr.val);
+            mp_bluetooth_gap_on_connected_disconnected(MP_BLUETOOTH_IRQ_CENTRAL_DISCONNECT, event->disconnect.conn.conn_handle, event->disconnect.conn.peer_id_addr.type, addr);
+            break;
+    }
+
+    return 0;
+}
+
+int mp_bluetooth_init(void) {
+    DEBUG_EVENT_printf("mp_bluetooth_init\n");
+    // Clean up if necessary.
+    mp_bluetooth_deinit();
+
+    ble_hs_cfg.reset_cb = reset_cb;
+    ble_hs_cfg.sync_cb = sync_cb;
+    ble_hs_cfg.gatts_register_cb = gatts_register_cb;
+    ble_hs_cfg.store_status_cb = ble_store_util_status_rr;
+
+    MP_STATE_PORT(bluetooth_nimble_root_pointers) = m_new0(mp_bluetooth_nimble_root_pointers_t, 1);
+    mp_bluetooth_gatts_db_create(&MP_STATE_PORT(bluetooth_nimble_root_pointers)->gatts_db);
+
+    mp_bluetooth_nimble_ble_state = MP_BLUETOOTH_NIMBLE_BLE_STATE_STARTING;
+
+    mp_bluetooth_nimble_port_preinit();
+    nimble_port_init();
+    mp_bluetooth_nimble_port_postinit();
+
+    // By default, just register the default gap service.
+    ble_svc_gap_init();
+
+    mp_bluetooth_nimble_port_start();
+
+    // Wait for sync callback
+    while (mp_bluetooth_nimble_ble_state != MP_BLUETOOTH_NIMBLE_BLE_STATE_ACTIVE) {
+        MICROPY_EVENT_POLL_HOOK
+    }
+    DEBUG_EVENT_printf("mp_bluetooth_init: ready\n");
+
+    return 0;
+}
+
+// Called when the host stop procedure has completed.
+STATIC void ble_hs_shutdown_stop_cb(int status, void *arg) {
+    mp_bluetooth_nimble_ble_state = MP_BLUETOOTH_NIMBLE_BLE_STATE_OFF;
+}
+
+STATIC struct ble_hs_stop_listener ble_hs_shutdown_stop_listener;
+
+void mp_bluetooth_deinit(void) {
+    DEBUG_EVENT_printf("mp_bluetooth_deinit\n");
+    if (mp_bluetooth_nimble_ble_state == MP_BLUETOOTH_NIMBLE_BLE_STATE_OFF) {
+        return;
+    }
+
+    mp_bluetooth_gap_advertise_stop();
+    #if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+    mp_bluetooth_gap_scan_stop();
+    #endif
+
+    mp_bluetooth_nimble_ble_state = MP_BLUETOOTH_NIMBLE_BLE_STATE_STOPPING;
+
+    ble_hs_stop(&ble_hs_shutdown_stop_listener, ble_hs_shutdown_stop_cb, NULL);
+
+    while (mp_bluetooth_nimble_ble_state != MP_BLUETOOTH_NIMBLE_BLE_STATE_OFF) {
+        MICROPY_EVENT_POLL_HOOK
+    }
+
+    mp_bluetooth_nimble_port_deinit();
+
+    MP_STATE_PORT(bluetooth_nimble_root_pointers) = NULL;
+    DEBUG_EVENT_printf("mp_bluetooth_deinit: shut down\n");
+}
+
+bool mp_bluetooth_is_active(void) {
+    return mp_bluetooth_nimble_ble_state == MP_BLUETOOTH_NIMBLE_BLE_STATE_ACTIVE;
+}
+
+void mp_bluetooth_get_device_addr(uint8_t *addr) {
+    #if MICROPY_PY_BLUETOOTH_RANDOM_ADDR
+    uint8_t addr_le[6];
+    int rc = ble_hs_id_copy_addr(BLE_ADDR_RANDOM, addr_le, NULL);
+    if (rc != 0) {
+        // Even with MICROPY_PY_BLUETOOTH_RANDOM_ADDR enabled the public address may
+        // be used instead, in which case there is no random address.
+        ble_hs_id_copy_addr(BLE_ADDR_PUBLIC, addr_le, NULL);
+    }
+    reverse_addr_byte_order(addr, addr_le);
+    #else
+    mp_hal_get_mac(MP_HAL_MAC_BDADDR, addr);
+    #endif
+}
+
+size_t mp_bluetooth_gap_get_device_name(const uint8_t **buf) {
+    const char *name = ble_svc_gap_device_name();
+    *buf = (const uint8_t *)name;
+    return strlen(name);
+}
+
+int mp_bluetooth_gap_set_device_name(const uint8_t *buf, size_t len) {
+    char tmp_buf[MYNEWT_VAL(BLE_SVC_GAP_DEVICE_NAME_MAX_LENGTH) + 1];
+    if (len + 1 > sizeof(tmp_buf)) {
+        return MP_EINVAL;
+    }
+    memcpy(tmp_buf, buf, len);
+    tmp_buf[len] = '\0';
+    return ble_hs_err_to_errno(ble_svc_gap_device_name_set(tmp_buf));
+}
+
+int mp_bluetooth_gap_advertise_start(bool connectable, int32_t interval_us, const uint8_t *adv_data, size_t adv_data_len, const uint8_t *sr_data, size_t sr_data_len) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+
+    mp_bluetooth_gap_advertise_stop();
+
+    int ret;
+    if (adv_data) {
+        ret = ble_gap_adv_set_data(adv_data, adv_data_len);
+        if (ret != 0) {
+            return ble_hs_err_to_errno(ret);
+        }
+    }
+
+    if (sr_data) {
+        ret = ble_gap_adv_rsp_set_data(sr_data, sr_data_len);
+        if (ret != 0) {
+            return ble_hs_err_to_errno(ret);
+        }
+    }
+
+    struct ble_gap_adv_params adv_params = {
+        .conn_mode = connectable ? BLE_GAP_CONN_MODE_UND : BLE_GAP_CONN_MODE_NON,
+        .disc_mode = BLE_GAP_DISC_MODE_GEN,
+        .itvl_min = interval_us / BLE_HCI_ADV_ITVL, // convert to 625us units.
+        .itvl_max = interval_us / BLE_HCI_ADV_ITVL,
+        .channel_map = 7, // all 3 channels.
+    };
+
+    ret = ble_gap_adv_start(BLE_OWN_ADDR_PUBLIC, NULL, BLE_HS_FOREVER, &adv_params, gap_event_cb, NULL);
+    if (ret == 0) {
+        return 0;
+    }
+    ret = ble_gap_adv_start(BLE_OWN_ADDR_RPA_PUBLIC_DEFAULT, NULL, BLE_HS_FOREVER, &adv_params, gap_event_cb, NULL);
+    if (ret == 0) {
+        return 0;
+    }
+    ret = ble_gap_adv_start(BLE_OWN_ADDR_RPA_RANDOM_DEFAULT, NULL, BLE_HS_FOREVER, &adv_params, gap_event_cb, NULL);
+    if (ret == 0) {
+        return 0;
+    }
+    ret = ble_gap_adv_start(BLE_OWN_ADDR_RANDOM, NULL, BLE_HS_FOREVER, &adv_params, gap_event_cb, NULL);
+    if (ret == 0) {
+        return 0;
+    }
+    DEBUG_EVENT_printf("ble_gap_adv_start: %d\n", ret);
+
+    return ble_hs_err_to_errno(ret);
+}
+
+void mp_bluetooth_gap_advertise_stop(void) {
+    if (ble_gap_adv_active()) {
+        ble_gap_adv_stop();
+    }
+}
+
+static int characteristic_access_cb(uint16_t conn_handle, uint16_t value_handle, struct ble_gatt_access_ctxt *ctxt, void *arg) {
+    DEBUG_EVENT_printf("characteristic_access_cb: conn_handle=%u value_handle=%u op=%u\n", conn_handle, value_handle, ctxt->op);
+    if (!mp_bluetooth_is_active()) {
+        return 0;
+    }
+    mp_bluetooth_gatts_db_entry_t *entry;
+    switch (ctxt->op) {
+        case BLE_GATT_ACCESS_OP_READ_CHR:
+        case BLE_GATT_ACCESS_OP_READ_DSC:
+            #if MICROPY_PY_BLUETOOTH_GATTS_ON_READ_CALLBACK
+            // Allow Python code to override (by using gatts_write), or deny (by returning false) the read.
+            if (!mp_bluetooth_gatts_on_read_request(conn_handle, value_handle)) {
+                return BLE_ATT_ERR_READ_NOT_PERMITTED;
+            }
+            #endif
+
+            entry = mp_bluetooth_gatts_db_lookup(MP_STATE_PORT(bluetooth_nimble_root_pointers)->gatts_db, value_handle);
+            if (!entry) {
+                return BLE_ATT_ERR_ATTR_NOT_FOUND;
+            }
+
+            os_mbuf_append(ctxt->om, entry->data, entry->data_len);
+
+            return 0;
+        case BLE_GATT_ACCESS_OP_WRITE_CHR:
+        case BLE_GATT_ACCESS_OP_WRITE_DSC:
+            entry = mp_bluetooth_gatts_db_lookup(MP_STATE_PORT(bluetooth_nimble_root_pointers)->gatts_db, value_handle);
+            if (!entry) {
+                return BLE_ATT_ERR_ATTR_NOT_FOUND;
+            }
+
+            size_t offset = 0;
+            if (entry->append) {
+                offset = entry->data_len;
+            }
+            entry->data_len = MIN(entry->data_alloc, OS_MBUF_PKTLEN(ctxt->om) + offset);
+            os_mbuf_copydata(ctxt->om, 0, entry->data_len - offset, entry->data + offset);
+
+            mp_bluetooth_gatts_on_write(conn_handle, value_handle);
+
+            return 0;
+    }
+    return BLE_ATT_ERR_UNLIKELY;
+}
+
+int mp_bluetooth_gatts_register_service_begin(bool append) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    int ret = ble_gatts_reset();
+    if (ret != 0) {
+        return ble_hs_err_to_errno(ret);
+    }
+
+    // Reset the gatt characteristic value db.
+    mp_bluetooth_gatts_db_reset(MP_STATE_PORT(bluetooth_nimble_root_pointers)->gatts_db);
+
+    // By default, just register the default gap service.
+    ble_svc_gap_init();
+
+    if (!append) {
+        // Unref any previous service definitions.
+        for (int i = 0; i < MP_STATE_PORT(bluetooth_nimble_root_pointers)->n_services; ++i) {
+            MP_STATE_PORT(bluetooth_nimble_root_pointers)->services[i] = NULL;
+        }
+        MP_STATE_PORT(bluetooth_nimble_root_pointers)->n_services = 0;
+    }
+
+    return 0;
+}
+
+int mp_bluetooth_gatts_register_service_end() {
+    int ret = ble_gatts_start();
+    if (ret != 0) {
+        return ble_hs_err_to_errno(ret);
+    }
+
+    return 0;
+}
+
+int mp_bluetooth_gatts_register_service(mp_obj_bluetooth_uuid_t *service_uuid, mp_obj_bluetooth_uuid_t **characteristic_uuids, uint8_t *characteristic_flags, mp_obj_bluetooth_uuid_t **descriptor_uuids, uint8_t *descriptor_flags, uint8_t *num_descriptors, uint16_t *handles, size_t num_characteristics) {
+    if (MP_STATE_PORT(bluetooth_nimble_root_pointers)->n_services == MP_BLUETOOTH_NIMBLE_MAX_SERVICES) {
+        return MP_E2BIG;
+    }
+    size_t handle_index = 0;
+    size_t descriptor_index = 0;
+
+    struct ble_gatt_chr_def *characteristics = m_new(struct ble_gatt_chr_def, num_characteristics + 1);
+    for (size_t i = 0; i < num_characteristics; ++i) {
+        characteristics[i].uuid = create_nimble_uuid(characteristic_uuids[i]);
+        characteristics[i].access_cb = characteristic_access_cb;
+        characteristics[i].arg = NULL;
+        characteristics[i].flags = characteristic_flags[i];
+        characteristics[i].min_key_size = 0;
+        characteristics[i].val_handle = &handles[handle_index];
+        ++handle_index;
+
+        if (num_descriptors[i] == 0) {
+            characteristics[i].descriptors = NULL;
+        } else {
+            struct ble_gatt_dsc_def *descriptors = m_new(struct ble_gatt_dsc_def, num_descriptors[i] + 1);
+
+            for (size_t j = 0; j < num_descriptors[i]; ++j) {
+                descriptors[j].uuid = create_nimble_uuid(descriptor_uuids[descriptor_index]);
+                descriptors[j].access_cb = characteristic_access_cb;
+                descriptors[j].att_flags = descriptor_flags[descriptor_index];
+                descriptors[j].min_key_size = 0;
+                // Unlike characteristic, Nimble doesn't provide an automatic way to remember the handle, so use the arg.
+                descriptors[j].arg = &handles[handle_index];
+                ++descriptor_index;
+                ++handle_index;
+            }
+            descriptors[num_descriptors[i]].uuid = NULL; // no more descriptors
+
+            characteristics[i].descriptors = descriptors;
+        }
+    }
+    characteristics[num_characteristics].uuid = NULL; // no more characteristics
+
+    struct ble_gatt_svc_def *service = m_new(struct ble_gatt_svc_def, 2);
+    service[0].type = BLE_GATT_SVC_TYPE_PRIMARY;
+    service[0].uuid = create_nimble_uuid(service_uuid);
+    service[0].includes = NULL;
+    service[0].characteristics = characteristics;
+    service[1].type = 0; // no more services
+
+    MP_STATE_PORT(bluetooth_nimble_root_pointers)->services[MP_STATE_PORT(bluetooth_nimble_root_pointers)->n_services++] = service;
+
+    // Note: advertising must be stopped for gatts registration to work
+
+    int ret = ble_gatts_count_cfg(service);
+    if (ret != 0) {
+        return ble_hs_err_to_errno(ret);
+    }
+
+    ret = ble_gatts_add_svcs(service);
+    if (ret != 0) {
+        return ble_hs_err_to_errno(ret);
+    }
+
+    return 0;
+}
+
+int mp_bluetooth_gap_disconnect(uint16_t conn_handle) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    return ble_hs_err_to_errno(ble_gap_terminate(conn_handle, BLE_ERR_REM_USER_CONN_TERM));
+}
+
+int mp_bluetooth_gatts_read(uint16_t value_handle, uint8_t **value, size_t *value_len) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    return mp_bluetooth_gatts_db_read(MP_STATE_PORT(bluetooth_nimble_root_pointers)->gatts_db, value_handle, value, value_len);
+}
+
+int mp_bluetooth_gatts_write(uint16_t value_handle, const uint8_t *value, size_t value_len) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    return mp_bluetooth_gatts_db_write(MP_STATE_PORT(bluetooth_nimble_root_pointers)->gatts_db, value_handle, value, value_len);
+}
+
+// TODO: Could use ble_gatts_chr_updated to send to all subscribed centrals.
+
+int mp_bluetooth_gatts_notify(uint16_t conn_handle, uint16_t value_handle) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    // Confusingly, notify/notify_custom/indicate are "gattc" function (even though they're used by peripherals (i.e. gatt servers)).
+    // See https://www.mail-archive.com/dev@mynewt.apache.org/msg01293.html
+    return ble_hs_err_to_errno(ble_gattc_notify(conn_handle, value_handle));
+}
+
+int mp_bluetooth_gatts_notify_send(uint16_t conn_handle, uint16_t value_handle, const uint8_t *value, size_t *value_len) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    struct os_mbuf *om = ble_hs_mbuf_from_flat(value, *value_len);
+    if (om == NULL) {
+        return -1;
+    }
+    // TODO: check that notify_custom takes ownership of om, if not os_mbuf_free_chain(om).
+    return ble_hs_err_to_errno(ble_gattc_notify_custom(conn_handle, value_handle, om));
+}
+
+int mp_bluetooth_gatts_indicate(uint16_t conn_handle, uint16_t value_handle) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    return ble_hs_err_to_errno(ble_gattc_indicate(conn_handle, value_handle));
+}
+
+int mp_bluetooth_gatts_set_buffer(uint16_t value_handle, size_t len, bool append) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    return mp_bluetooth_gatts_db_resize(MP_STATE_PORT(bluetooth_nimble_root_pointers)->gatts_db, value_handle, len, append);
+}
+
+#if MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+
+STATIC void gattc_on_data_available(uint16_t event, uint16_t conn_handle, uint16_t value_handle, const struct os_mbuf *om) {
+    size_t len = OS_MBUF_PKTLEN(om);
+    mp_uint_t atomic_state;
+    len = mp_bluetooth_gattc_on_data_available_start(event, conn_handle, value_handle, len, &atomic_state);
+    while (len > 0 && om != NULL) {
+        size_t n = MIN(om->om_len, len);
+        mp_bluetooth_gattc_on_data_available_chunk(OS_MBUF_DATA(om, const uint8_t *), n);
+        len -= n;
+        om = SLIST_NEXT(om, om_next);
+    }
+    mp_bluetooth_gattc_on_data_available_end(atomic_state);
+}
+
+STATIC int gap_scan_cb(struct ble_gap_event *event, void *arg) {
+    DEBUG_EVENT_printf("gap_scan_cb: event=%d type=%d\n", event->type, event->type == BLE_GAP_EVENT_DISC ? event->disc.event_type : -1);
+    if (!mp_bluetooth_is_active()) {
+        return 0;
+    }
+
+    if (event->type == BLE_GAP_EVENT_DISC_COMPLETE) {
+        mp_bluetooth_gap_on_scan_complete();
+        return 0;
+    }
+
+    if (event->type != BLE_GAP_EVENT_DISC) {
+        return 0;
+    }
+
+    uint8_t addr[6];
+    reverse_addr_byte_order(addr, event->disc.addr.val);
+    mp_bluetooth_gap_on_scan_result(event->disc.addr.type, addr, event->disc.event_type, event->disc.rssi, event->disc.data, event->disc.length_data);
+
+    return 0;
+}
+
+int mp_bluetooth_gap_scan_start(int32_t duration_ms, int32_t interval_us, int32_t window_us) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    if (duration_ms == 0) {
+        duration_ms = BLE_HS_FOREVER;
+    }
+    struct ble_gap_disc_params discover_params = {
+        .itvl = MAX(BLE_HCI_SCAN_ITVL_MIN, MIN(BLE_HCI_SCAN_ITVL_MAX, interval_us / BLE_HCI_SCAN_ITVL)),
+        .window = MAX(BLE_HCI_SCAN_WINDOW_MIN, MIN(BLE_HCI_SCAN_WINDOW_MAX, window_us / BLE_HCI_SCAN_ITVL)),
+        .filter_policy = BLE_HCI_CONN_FILT_NO_WL,
+        .limited = 0,
+        .passive = 1,  // TODO: Handle BLE_HCI_ADV_RPT_EVTYPE_SCAN_RSP in gap_scan_cb above.
+        .filter_duplicates = 0,
+    };
+    int err = ble_gap_disc(BLE_OWN_ADDR_PUBLIC, duration_ms, &discover_params, gap_scan_cb, NULL);
+    return ble_hs_err_to_errno(err);
+}
+
+int mp_bluetooth_gap_scan_stop(void) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    if (!ble_gap_disc_active()) {
+        return 0;
+    }
+    int err = ble_gap_disc_cancel();
+    if (err == 0) {
+        mp_bluetooth_gap_on_scan_complete();
+        return 0;
+    }
+    return ble_hs_err_to_errno(err);
+}
+
+// Central role: GAP events for a connected peripheral.
+STATIC int peripheral_gap_event_cb(struct ble_gap_event *event, void *arg) {
+    DEBUG_EVENT_printf("peripheral_gap_event_cb: event=%d\n", event->type);
+    if (!mp_bluetooth_is_active()) {
+        return 0;
+    }
+    struct ble_gap_conn_desc desc;
+    uint8_t addr[6] = {0};
+
+    switch (event->type) {
+        case BLE_GAP_EVENT_CONNECT:
+            if (event->connect.status == 0) {
+                // Connection established.
+                ble_gap_conn_find(event->connect.conn_handle, &desc);
+                reverse_addr_byte_order(addr, desc.peer_id_addr.val);
+                mp_bluetooth_gap_on_connected_disconnected(MP_BLUETOOTH_IRQ_PERIPHERAL_CONNECT, event->connect.conn_handle, desc.peer_id_addr.type, addr);
+            } else {
+                // Connection failed.
+                mp_bluetooth_gap_on_connected_disconnected(MP_BLUETOOTH_IRQ_PERIPHERAL_DISCONNECT, event->connect.conn_handle, 0xff, addr);
+            }
+            break;
+
+        case BLE_GAP_EVENT_DISCONNECT:
+            // Disconnect.
+            reverse_addr_byte_order(addr, event->disconnect.conn.peer_id_addr.val);
+            mp_bluetooth_gap_on_connected_disconnected(MP_BLUETOOTH_IRQ_PERIPHERAL_DISCONNECT, event->disconnect.conn.conn_handle, event->disconnect.conn.peer_id_addr.type, addr);
+
+            break;
+
+        case BLE_GAP_EVENT_NOTIFY_RX: {
+            uint16_t ev = event->notify_rx.indication == 0 ? MP_BLUETOOTH_IRQ_GATTC_NOTIFY : MP_BLUETOOTH_IRQ_GATTC_INDICATE;
+            gattc_on_data_available(ev, event->notify_rx.conn_handle, event->notify_rx.attr_handle, event->notify_rx.om);
+            break;
+        }
+
+        case BLE_GAP_EVENT_CONN_UPDATE:
+            // TODO
+            break;
+
+        case BLE_GAP_EVENT_CONN_UPDATE_REQ:
+            // TODO
+            break;
+
+        default:
+            break;
+    }
+    return 0;
+}
+
+int mp_bluetooth_gap_peripheral_connect(uint8_t addr_type, const uint8_t *addr, int32_t duration_ms) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    if (ble_gap_disc_active()) {
+        mp_bluetooth_gap_scan_stop();
+    }
+
+    // TODO: This is the same as ble_gap_conn_params_dflt (i.e. passing NULL).
+    STATIC const struct ble_gap_conn_params params = {
+        .scan_itvl = 0x0010,
+        .scan_window = 0x0010,
+        .itvl_min = BLE_GAP_INITIAL_CONN_ITVL_MIN,
+        .itvl_max = BLE_GAP_INITIAL_CONN_ITVL_MAX,
+        .latency = BLE_GAP_INITIAL_CONN_LATENCY,
+        .supervision_timeout = BLE_GAP_INITIAL_SUPERVISION_TIMEOUT,
+        .min_ce_len = BLE_GAP_INITIAL_CONN_MIN_CE_LEN,
+        .max_ce_len = BLE_GAP_INITIAL_CONN_MAX_CE_LEN,
+    };
+
+    ble_addr_t addr_nimble = create_nimble_addr(addr_type, addr);
+    int err = ble_gap_connect(BLE_OWN_ADDR_PUBLIC, &addr_nimble, duration_ms, &params, &peripheral_gap_event_cb, NULL);
+    return ble_hs_err_to_errno(err);
+}
+
+STATIC int peripheral_discover_service_cb(uint16_t conn_handle, const struct ble_gatt_error *error, const struct ble_gatt_svc *service, void *arg) {
+    DEBUG_EVENT_printf("peripheral_discover_service_cb: conn_handle=%d status=%d start_handle=%d\n", conn_handle, error->status, service ? service->start_handle : -1);
+    if (!mp_bluetooth_is_active()) {
+        return 0;
+    }
+    if (error->status == 0) {
+        mp_obj_bluetooth_uuid_t service_uuid = create_mp_uuid(&service->uuid);
+        mp_bluetooth_gattc_on_primary_service_result(conn_handle, service->start_handle, service->end_handle, &service_uuid);
+    }
+    return 0;
+}
+
+int mp_bluetooth_gattc_discover_primary_services(uint16_t conn_handle) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    int err = ble_gattc_disc_all_svcs(conn_handle, &peripheral_discover_service_cb, NULL);
+    return ble_hs_err_to_errno(err);
+}
+
+STATIC int ble_gatt_characteristic_cb(uint16_t conn_handle, const struct ble_gatt_error *error, const struct ble_gatt_chr *characteristic, void *arg) {
+    DEBUG_EVENT_printf("ble_gatt_characteristic_cb: conn_handle=%d status=%d def_handle=%d val_handle=%d\n", conn_handle, error->status, characteristic ? characteristic->def_handle : -1, characteristic ? characteristic->val_handle : -1);
+    if (!mp_bluetooth_is_active()) {
+        return 0;
+    }
+    if (error->status == 0) {
+        mp_obj_bluetooth_uuid_t characteristic_uuid = create_mp_uuid(&characteristic->uuid);
+        mp_bluetooth_gattc_on_characteristic_result(conn_handle, characteristic->def_handle, characteristic->val_handle, characteristic->properties, &characteristic_uuid);
+    }
+    return 0;
+}
+
+int mp_bluetooth_gattc_discover_characteristics(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    int err = ble_gattc_disc_all_chrs(conn_handle, start_handle, end_handle, &ble_gatt_characteristic_cb, NULL);
+    return ble_hs_err_to_errno(err);
+}
+
+STATIC int ble_gatt_descriptor_cb(uint16_t conn_handle, const struct ble_gatt_error *error, uint16_t characteristic_val_handle, const struct ble_gatt_dsc *descriptor, void *arg) {
+    DEBUG_EVENT_printf("ble_gatt_descriptor_cb: conn_handle=%d status=%d chr_handle=%d dsc_handle=%d\n", conn_handle, error->status, characteristic_val_handle, descriptor ? descriptor->handle : -1);
+    if (!mp_bluetooth_is_active()) {
+        return 0;
+    }
+    if (error->status == 0) {
+        mp_obj_bluetooth_uuid_t descriptor_uuid = create_mp_uuid(&descriptor->uuid);
+        mp_bluetooth_gattc_on_descriptor_result(conn_handle, descriptor->handle, &descriptor_uuid);
+    }
+    return 0;
+}
+
+int mp_bluetooth_gattc_discover_descriptors(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    int err = ble_gattc_disc_all_dscs(conn_handle, start_handle, end_handle, &ble_gatt_descriptor_cb, NULL);
+    return ble_hs_err_to_errno(err);
+}
+
+STATIC int ble_gatt_attr_read_cb(uint16_t conn_handle, const struct ble_gatt_error *error, struct ble_gatt_attr *attr, void *arg) {
+    DEBUG_EVENT_printf("ble_gatt_attr_read_cb: conn_handle=%d status=%d handle=%d\n", conn_handle, error->status, attr ? attr->handle : -1);
+    if (!mp_bluetooth_is_active()) {
+        return 0;
+    }
+    // TODO: Maybe send NULL if error->status non-zero.
+    if (error->status == 0) {
+        gattc_on_data_available(MP_BLUETOOTH_IRQ_GATTC_READ_RESULT, conn_handle, attr->handle, attr->om);
+    }
+    return 0;
+}
+
+// Initiate read of a value from the remote peripheral.
+int mp_bluetooth_gattc_read(uint16_t conn_handle, uint16_t value_handle) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    int err = ble_gattc_read(conn_handle, value_handle, &ble_gatt_attr_read_cb, NULL);
+    return ble_hs_err_to_errno(err);
+}
+
+STATIC int ble_gatt_attr_write_cb(uint16_t conn_handle, const struct ble_gatt_error *error, struct ble_gatt_attr *attr, void *arg) {
+    DEBUG_EVENT_printf("ble_gatt_attr_write_cb: conn_handle=%d status=%d handle=%d\n", conn_handle, error->status, attr ? attr->handle : -1);
+    if (!mp_bluetooth_is_active()) {
+        return 0;
+    }
+    mp_bluetooth_gattc_on_write_status(conn_handle, attr->handle, error->status);
+    return 0;
+}
+
+// Write the value to the remote peripheral.
+int mp_bluetooth_gattc_write(uint16_t conn_handle, uint16_t value_handle, const uint8_t *value, size_t *value_len, unsigned int mode) {
+    if (!mp_bluetooth_is_active()) {
+        return ERRNO_BLUETOOTH_NOT_ACTIVE;
+    }
+    int err;
+    if (mode == MP_BLUETOOTH_WRITE_MODE_NO_RESPONSE) {
+        err = ble_gattc_write_no_rsp_flat(conn_handle, value_handle, value, *value_len);
+    } else if (mode == MP_BLUETOOTH_WRITE_MODE_WITH_RESPONSE) {
+        err = ble_gattc_write_flat(conn_handle, value_handle, value, *value_len, &ble_gatt_attr_write_cb, NULL);
+    } else {
+        err = BLE_HS_EINVAL;
+    }
+    return ble_hs_err_to_errno(err);
+}
+
+#endif // MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE
+
+#endif // MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_NIMBLE
diff --git a/extmod/nimble/modbluetooth_nimble.h b/extmod/nimble/modbluetooth_nimble.h
new file mode 100644
index 0000000000000..f44e1d69dca52
--- /dev/null
+++ b/extmod/nimble/modbluetooth_nimble.h
@@ -0,0 +1,57 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Jim Mussared
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_EXTMOD_NIMBLE_MODBLUETOOTH_NIMBLE_H
+#define MICROPY_INCLUDED_EXTMOD_NIMBLE_MODBLUETOOTH_NIMBLE_H
+
+#include "extmod/modbluetooth.h"
+
+#define MP_BLUETOOTH_NIMBLE_MAX_SERVICES (8)
+
+typedef struct _mp_bluetooth_nimble_root_pointers_t {
+    // Characteristic (and descriptor) value storage.
+    mp_gatts_db_t gatts_db;
+
+    // Pending service definitions.
+    size_t n_services;
+    struct ble_gatt_svc_def *services[MP_BLUETOOTH_NIMBLE_MAX_SERVICES];
+} mp_bluetooth_nimble_root_pointers_t;
+
+enum {
+    MP_BLUETOOTH_NIMBLE_BLE_STATE_OFF,
+    MP_BLUETOOTH_NIMBLE_BLE_STATE_STARTING,
+    MP_BLUETOOTH_NIMBLE_BLE_STATE_ACTIVE,
+    MP_BLUETOOTH_NIMBLE_BLE_STATE_STOPPING,
+};
+
+extern volatile int mp_bluetooth_nimble_ble_state;
+
+void mp_bluetooth_nimble_port_preinit(void);
+void mp_bluetooth_nimble_port_postinit(void);
+void mp_bluetooth_nimble_port_deinit(void);
+void mp_bluetooth_nimble_port_start(void);
+
+#endif // MICROPY_INCLUDED_EXTMOD_NIMBLE_MODBLUETOOTH_NIMBLE_H
diff --git a/extmod/nimble/nimble.mk b/extmod/nimble/nimble.mk
new file mode 100644
index 0000000000000..4e1642c98a998
--- /dev/null
+++ b/extmod/nimble/nimble.mk
@@ -0,0 +1,105 @@
+# Makefile directives for Apache Mynewt NimBLE component
+
+ifeq ($(MICROPY_BLUETOOTH_NIMBLE),1)
+
+EXTMOD_SRC_C += extmod/nimble/modbluetooth_nimble.c
+
+CFLAGS_MOD += -DMICROPY_BLUETOOTH_NIMBLE=1
+
+NIMBLE_EXTMOD_DIR = extmod/nimble
+
+# Use NimBLE from the submodule in lib/mynewt-nimble by default,
+# allowing a port to use their own system version (e.g. ESP32).
+MICROPY_BLUETOOTH_NIMBLE_BINDINGS_ONLY ?= 0
+
+ifeq ($(MICROPY_BLUETOOTH_NIMBLE_BINDINGS_ONLY),0)
+
+NIMBLE_LIB_DIR = lib/mynewt-nimble
+
+LIB_SRC_C += $(addprefix $(NIMBLE_LIB_DIR)/, \
+	$(addprefix ext/tinycrypt/src/, \
+		aes_encrypt.c \
+		cmac_mode.c \
+		ecc.c \
+		ecc_dh.c \
+		utils.c \
+		) \
+	nimble/host/services/gap/src/ble_svc_gap.c \
+	nimble/host/services/gatt/src/ble_svc_gatt.c \
+	$(addprefix nimble/host/src/, \
+		ble_att.c \
+		ble_att_clt.c \
+		ble_att_cmd.c \
+		ble_att_svr.c \
+		ble_eddystone.c \
+		ble_gap.c \
+		ble_gattc.c \
+		ble_gatts.c \
+		ble_hs_adv.c \
+		ble_hs_atomic.c \
+		ble_hs.c \
+		ble_hs_cfg.c \
+		ble_hs_conn.c \
+		ble_hs_flow.c \
+		ble_hs_hci.c \
+		ble_hs_hci_cmd.c \
+		ble_hs_hci_evt.c \
+		ble_hs_hci_util.c \
+		ble_hs_id.c \
+		ble_hs_log.c \
+		ble_hs_mbuf.c \
+		ble_hs_misc.c \
+		ble_hs_mqueue.c \
+		ble_hs_pvcy.c \
+		ble_hs_startup.c \
+		ble_hs_stop.c \
+		ble_ibeacon.c \
+		ble_l2cap.c \
+		ble_l2cap_coc.c \
+		ble_l2cap_sig.c \
+		ble_l2cap_sig_cmd.c \
+		ble_monitor.c \
+		ble_sm_alg.c \
+		ble_sm.c \
+		ble_sm_cmd.c \
+		ble_sm_lgcy.c \
+		ble_sm_sc.c \
+		ble_store.c \
+		ble_store_util.c \
+		ble_uuid.c \
+		) \
+	nimble/host/store/ram/src/ble_store_ram.c \
+	nimble/host/util/src/addr.c \
+	nimble/transport/uart/src/ble_hci_uart.c \
+	$(addprefix porting/nimble/src/, \
+		endian.c \
+		mem.c \
+		nimble_port.c \
+		os_mbuf.c \
+		os_mempool.c \
+		os_msys_init.c \
+		) \
+	)
+
+EXTMOD_SRC_C += $(addprefix $(NIMBLE_EXTMOD_DIR)/, \
+	nimble/npl_os.c \
+	hal/hal_uart.c \
+	)
+
+INC += -I$(TOP)/$(NIMBLE_EXTMOD_DIR)
+INC += -I$(TOP)/$(NIMBLE_LIB_DIR)
+INC += -I$(TOP)/$(NIMBLE_LIB_DIR)/ext/tinycrypt/include
+INC += -I$(TOP)/$(NIMBLE_LIB_DIR)/nimble/host/include
+INC += -I$(TOP)/$(NIMBLE_LIB_DIR)/nimble/host/services/gap/include
+INC += -I$(TOP)/$(NIMBLE_LIB_DIR)/nimble/host/services/gatt/include
+INC += -I$(TOP)/$(NIMBLE_LIB_DIR)/nimble/host/store/ram/include
+INC += -I$(TOP)/$(NIMBLE_LIB_DIR)/nimble/host/util/include
+INC += -I$(TOP)/$(NIMBLE_LIB_DIR)/nimble/include
+INC += -I$(TOP)/$(NIMBLE_LIB_DIR)/nimble/transport/uart/include
+INC += -I$(TOP)/$(NIMBLE_LIB_DIR)/porting/nimble/include
+
+$(BUILD)/$(NIMBLE_LIB_DIR)/%.o: CFLAGS += -Wno-maybe-uninitialized -Wno-pointer-arith -Wno-unused-but-set-variable -Wno-format
+
+endif
+
+endif
diff --git a/extmod/nimble/nimble/nimble_hci_uart.h b/extmod/nimble/nimble/nimble_hci_uart.h
new file mode 100644
index 0000000000000..646a12dac1460
--- /dev/null
+++ b/extmod/nimble/nimble/nimble_hci_uart.h
@@ -0,0 +1,40 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_EXTMOD_NIMBLE_NIMBLE_NIMBLE_HCI_UART_H
+#define MICROPY_INCLUDED_EXTMOD_NIMBLE_NIMBLE_NIMBLE_HCI_UART_H
+
+// Extensions to extmod/modbluetooth_hci.h specific to NimBLE.
+
+#include "extmod/nimble/hal/hal_uart.h"
+
+// Helpers called from ports.
+void mp_bluetooth_nimble_hci_uart_process(void);
+
+// Must be provided by the port.
+void mp_bluetooth_nimble_hci_uart_rx(hal_uart_rx_cb_t rx_cb, void *rx_arg);
+void mp_bluetooth_nimble_hci_uart_tx_strn(const char *str, uint len);
+
+#endif // MICROPY_INCLUDED_EXTMOD_NIMBLE_NIMBLE_NIMBLE_HCI_UART_H
diff --git a/extmod/modubinascii.h b/extmod/nimble/nimble/nimble_npl_os.h
similarity index 57%
rename from extmod/modubinascii.h
rename to extmod/nimble/nimble/nimble_npl_os.h
index fb3169267820e..3d886fedb58fd 100644
--- a/extmod/modubinascii.h
+++ b/extmod/nimble/nimble/nimble_npl_os.h
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2014 Paul Sokolovsky
+ * Copyright (c) 2018-2019 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -23,19 +23,44 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-#ifndef MICROPY_INCLUDED_EXTMOD_MODUBINASCII_H
-#define MICROPY_INCLUDED_EXTMOD_MODUBINASCII_H
-
-extern mp_obj_t mod_binascii_hexlify(size_t n_args, const mp_obj_t *args);
-extern mp_obj_t mod_binascii_unhexlify(mp_obj_t data);
-extern mp_obj_t mod_binascii_a2b_base64(mp_obj_t data);
-extern mp_obj_t mod_binascii_b2a_base64(mp_obj_t data);
-extern mp_obj_t mod_binascii_crc32(size_t n_args, const mp_obj_t *args);
-
-MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mod_binascii_hexlify_obj);
-MP_DECLARE_CONST_FUN_OBJ_1(mod_binascii_unhexlify_obj);
-MP_DECLARE_CONST_FUN_OBJ_1(mod_binascii_a2b_base64_obj);
-MP_DECLARE_CONST_FUN_OBJ_1(mod_binascii_b2a_base64_obj);
-MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mod_binascii_crc32_obj);
-
-#endif // MICROPY_INCLUDED_EXTMOD_MODUBINASCII_H
+
+#ifndef MICROPY_INCLUDED_STM32_NIMBLE_NIMBLE_NPL_OS_H
+#define MICROPY_INCLUDED_STM32_NIMBLE_NIMBLE_NPL_OS_H
+
+#include <stdint.h>
+
+#define BLE_NPL_OS_ALIGNMENT (4)
+#define BLE_NPL_TIME_FOREVER (0xffffffff)
+
+typedef uint32_t ble_npl_time_t;
+typedef int32_t ble_npl_stime_t;
+
+struct ble_npl_event {
+    ble_npl_event_fn *fn;
+    void *arg;
+    struct ble_npl_event *prev;
+    struct ble_npl_event *next;
+};
+
+struct ble_npl_eventq {
+    struct ble_npl_event *head;
+    struct ble_npl_eventq *nextq;
+};
+
+struct ble_npl_callout {
+    bool active;
+    uint32_t ticks;
+    struct ble_npl_eventq *evq;
+    struct ble_npl_event ev;
+    struct ble_npl_callout *nextc;
+};
+
+struct ble_npl_mutex {
+    volatile uint8_t locked;
+};
+
+struct ble_npl_sem {
+    volatile uint16_t count;
+};
+
+#endif // MICROPY_INCLUDED_STM32_NIMBLE_NIMBLE_NPL_OS_H
diff --git a/extmod/nimble/nimble/npl_os.c b/extmod/nimble/nimble/npl_os.c
new file mode 100644
index 0000000000000..620dcb0aec13c
--- /dev/null
+++ b/extmod/nimble/nimble/npl_os.c
@@ -0,0 +1,391 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdio.h>
+#include "py/mphal.h"
+#include "py/runtime.h"
+#include "nimble/ble.h"
+#include "nimble/nimble_npl.h"
+#include "nimble/nimble_hci_uart.h"
+
+#define DEBUG_OS_printf(...) //printf(__VA_ARGS__)
+#define DEBUG_MALLOC_printf(...) //printf(__VA_ARGS__)
+#define DEBUG_EVENT_printf(...) //printf(__VA_ARGS__)
+#define DEBUG_MUTEX_printf(...) //printf(__VA_ARGS__)
+#define DEBUG_SEM_printf(...) //printf(__VA_ARGS__)
+#define DEBUG_CALLOUT_printf(...) //printf(__VA_ARGS__)
+#define DEBUG_TIME_printf(...) //printf(__VA_ARGS__)
+#define DEBUG_CRIT_printf(...) //printf(__VA_ARGS__)
+
+bool ble_npl_os_started(void) {
+    DEBUG_OS_printf("ble_npl_os_started\n");
+    return true;
+}
+
+void *ble_npl_get_current_task_id(void) {
+    DEBUG_OS_printf("ble_npl_get_current_task_id\n");
+    return NULL;
+}
+
+/******************************************************************************/
+// malloc
+
+// Maintain a linked list of heap memory that we've passed to Nimble,
+// discoverable via the bluetooth_nimble_memory root pointer.
+
+// MP_STATE_PORT(bluetooth_nimble_memory) is a pointer to [next, prev, data...].
+
+// TODO: This is duplicated from mbedtls. Perhaps make this a generic feature?
+void *m_malloc_bluetooth(size_t size) {
+    void **ptr = m_malloc0(size + 2 * sizeof(uintptr_t));
+    if (MP_STATE_PORT(bluetooth_nimble_memory) != NULL) {
+        MP_STATE_PORT(bluetooth_nimble_memory)[0] = ptr;
+    }
+    ptr[0] = NULL;
+    ptr[1] = MP_STATE_PORT(bluetooth_nimble_memory);
+    MP_STATE_PORT(bluetooth_nimble_memory) = ptr;
+    return &ptr[2];
+}
+
+void m_free_bluetooth(void *ptr_in) {
+    void **ptr = &((void**)ptr_in)[-2];
+    if (ptr[1] != NULL) {
+        ((void**)ptr[1])[0] = ptr[0];
+    }
+    if (ptr[0] != NULL) {
+        ((void**)ptr[0])[1] = ptr[1];
+    } else {
+        MP_STATE_PORT(bluetooth_nimble_memory) = ptr[1];
+    }
+    m_free(ptr);
+}
+
+// Check if a nimble ptr is tracked.
+// If it isn't, that means that it's from a previous soft-reset cycle.
+STATIC bool is_valid_nimble_malloc(void *ptr) {
+    DEBUG_MALLOC_printf("NIMBLE is_valid_nimble_malloc(%p)\n", ptr);
+    void** search = MP_STATE_PORT(bluetooth_nimble_memory);
+    while (search) {
+        if (&search[2] == ptr) {
+            return true;
+        }
+
+        search = (void**)search[1];
+    }
+    return false;
+}
+
+void *nimble_malloc(size_t size) {
+    DEBUG_MALLOC_printf("NIMBLE malloc(%u)\n", (uint)size);
+    void* ptr = m_malloc_bluetooth(size);
+    DEBUG_MALLOC_printf("  --> %p\n", ptr);
+    return ptr;
+}
+
+// Only free if it's still a valid pointer.
+void nimble_free(void *ptr) {
+    DEBUG_MALLOC_printf("NIMBLE free(%p)\n", ptr);
+    if (ptr && is_valid_nimble_malloc(ptr)) {
+        m_free_bluetooth(ptr);
+    }
+}
+
+// Only realloc if it's still a valid pointer. Otherwise just malloc.
+void *nimble_realloc(void *ptr, size_t size) {
+    // This is only used by ble_gatts.c to grow the queue of pending services to be registered.
+    DEBUG_MALLOC_printf("NIMBLE realloc(%p, %u)\n", ptr, (uint)size);
+    void *ptr2 = nimble_malloc(size);
+    if (ptr && is_valid_nimble_malloc(ptr)) {
+        // If it's a realloc and we still have the old data, then copy it.
+        // This will happen as we add services.
+        memcpy(ptr2, ptr, size);
+        m_free_bluetooth(ptr);
+    }
+    return ptr2;
+}
+
+/******************************************************************************/
+// EVENTQ
+
+struct ble_npl_eventq *global_eventq = NULL;
+
+void os_eventq_run_all(void) {
+    for (struct ble_npl_eventq *evq = global_eventq; evq != NULL; evq = evq->nextq) {
+        while (evq->head != NULL) {
+            struct ble_npl_event *ev = evq->head;
+            evq->head = ev->next;
+            if (ev->next) {
+                ev->next->prev = NULL;
+                ev->next = NULL;
+            }
+            ev->prev = NULL;
+            DEBUG_EVENT_printf("event_run(%p)\n", ev);
+            ev->fn(ev);
+            DEBUG_EVENT_printf("event_run(%p) done\n", ev);
+        }
+    }
+}
+
+void ble_npl_eventq_init(struct ble_npl_eventq *evq) {
+    DEBUG_EVENT_printf("ble_npl_eventq_init(%p)\n", evq);
+    evq->head = NULL;
+    struct ble_npl_eventq **evq2;
+    for (evq2 = &global_eventq; *evq2 != NULL; evq2 = &(*evq2)->nextq) {
+    }
+    *evq2 = evq;
+    evq->nextq = NULL;
+}
+
+void ble_npl_eventq_put(struct ble_npl_eventq *evq, struct ble_npl_event *ev) {
+    DEBUG_EVENT_printf("ble_npl_eventq_put(%p, %p (%p, %p))\n", evq, ev, ev->fn, ev->arg);
+    ev->next = NULL;
+    if (evq->head == NULL) {
+        evq->head = ev;
+        ev->prev = NULL;
+    } else {
+        struct ble_npl_event *ev2 = evq->head;
+        while (true) {
+            if (ev2 == ev) {
+                DEBUG_EVENT_printf("  --> already in queue\n");
+                return;
+            }
+            if (ev2->next == NULL) {
+                break;
+            }
+            DEBUG_EVENT_printf("  --> %p\n", ev2->next);
+            ev2 = ev2->next;
+        }
+        ev2->next = ev;
+        ev->prev = ev2;
+    }
+}
+
+void ble_npl_event_init(struct ble_npl_event *ev, ble_npl_event_fn *fn, void *arg) {
+    DEBUG_EVENT_printf("ble_npl_event_init(%p, %p, %p)\n", ev, fn, arg);
+    ev->fn = fn;
+    ev->arg = arg;
+    ev->next = NULL;
+}
+
+void *ble_npl_event_get_arg(struct ble_npl_event *ev) {
+    DEBUG_EVENT_printf("ble_npl_event_get_arg(%p) -> %p\n", ev, ev->arg);
+    return ev->arg;
+}
+
+void ble_npl_event_set_arg(struct ble_npl_event *ev, void *arg) {
+    DEBUG_EVENT_printf("ble_npl_event_set_arg(%p, %p)\n", ev, arg);
+    ev->arg = arg;
+}
+
+/******************************************************************************/
+// MUTEX
+
+ble_npl_error_t ble_npl_mutex_init(struct ble_npl_mutex *mu) {
+    DEBUG_MUTEX_printf("ble_npl_mutex_init(%p)\n", mu);
+    mu->locked = 0;
+    return BLE_NPL_OK;
+}
+
+ble_npl_error_t ble_npl_mutex_pend(struct ble_npl_mutex *mu, ble_npl_time_t timeout) {
+    DEBUG_MUTEX_printf("ble_npl_mutex_pend(%p, %u) locked=%u\n", mu, (uint)timeout, (uint)mu->locked);
+    mu->locked = 1;
+    return BLE_NPL_OK;
+}
+
+ble_npl_error_t ble_npl_mutex_release(struct ble_npl_mutex *mu) {
+    DEBUG_MUTEX_printf("ble_npl_mutex_release(%p) locked=%u\n", mu, (uint)mu->locked);
+    mu->locked = 0;
+    return BLE_NPL_OK;
+}
+
+/******************************************************************************/
+// SEM
+
+ble_npl_error_t ble_npl_sem_init(struct ble_npl_sem *sem, uint16_t tokens) {
+    DEBUG_SEM_printf("ble_npl_sem_init(%p, %u)\n", sem, (uint)tokens);
+    sem->count = tokens;
+    return BLE_NPL_OK;
+}
+
+ble_npl_error_t ble_npl_sem_pend(struct ble_npl_sem *sem, ble_npl_time_t timeout) {
+    DEBUG_SEM_printf("ble_npl_sem_pend(%p, %u) count=%u\n", sem, (uint)timeout, (uint)sem->count);
+    if (sem->count == 0) {
+        uint32_t t0 = mp_hal_ticks_ms();
+        while (sem->count == 0 && mp_hal_ticks_ms() - t0 < timeout) {
+            // This function may be called at thread-level, so execute
+            // mp_bluetooth_nimble_hci_uart_process at raised priority.
+            MICROPY_PY_BLUETOOTH_ENTER
+            mp_bluetooth_nimble_hci_uart_process();
+            MICROPY_PY_BLUETOOTH_EXIT
+            if (sem->count != 0) {
+                break;
+            }
+            __WFI();
+        }
+        if (sem->count == 0) {
+            printf("timeout\n");
+            return BLE_NPL_TIMEOUT;
+        }
+        DEBUG_SEM_printf("got response in %u ms\n", (int)(mp_hal_ticks_ms() - t0));
+    }
+    sem->count -= 1;
+    return BLE_NPL_OK;
+}
+
+ble_npl_error_t ble_npl_sem_release(struct ble_npl_sem *sem) {
+    DEBUG_SEM_printf("ble_npl_sem_release(%p)\n", sem);
+    sem->count += 1;
+    return BLE_NPL_OK;
+}
+
+uint16_t ble_npl_sem_get_count(struct ble_npl_sem *sem) {
+    DEBUG_SEM_printf("ble_npl_sem_get_count(%p)\n", sem);
+    return sem->count;
+}
+
+/******************************************************************************/
+// CALLOUT
+
+static struct ble_npl_callout *global_callout = NULL;
+
+void os_callout_process(void) {
+    uint32_t tnow = mp_hal_ticks_ms();
+    for (struct ble_npl_callout *c = global_callout; c != NULL; c = c->nextc) {
+        if (!c->active) {
+            continue;
+        }
+        if ((int32_t)(tnow - c->ticks) >= 0) {
+            DEBUG_CALLOUT_printf("callout_run(%p) tnow=%u ticks=%u evq=%p\n", c, (uint)tnow, (uint)c->ticks, c->evq);
+            c->active = false;
+            if (c->evq) {
+                ble_npl_eventq_put(c->evq, &c->ev);
+            } else {
+                c->ev.fn(&c->ev);
+            }
+            DEBUG_CALLOUT_printf("callout_run(%p) done\n", c);
+        }
+    }
+}
+
+void ble_npl_callout_init(struct ble_npl_callout *c, struct ble_npl_eventq *evq, ble_npl_event_fn *ev_cb, void *ev_arg) {
+    DEBUG_CALLOUT_printf("ble_npl_callout_init(%p, %p, %p, %p)\n", c, evq, ev_cb, ev_arg);
+    c->active = false;
+    c->ticks = 0;
+    c->evq = evq;
+    ble_npl_event_init(&c->ev, ev_cb, ev_arg);
+
+    struct ble_npl_callout **c2;
+    for (c2 = &global_callout; *c2 != NULL; c2 = &(*c2)->nextc) {
+        if (c == *c2) {
+            // callout already in linked list so don't link it in again
+            return;
+        }
+    }
+    *c2 = c;
+    c->nextc = NULL;
+}
+
+ble_npl_error_t ble_npl_callout_reset(struct ble_npl_callout *c, ble_npl_time_t ticks) {
+    DEBUG_CALLOUT_printf("ble_npl_callout_reset(%p, %u) tnow=%u\n", c, (uint)ticks, (uint)mp_hal_ticks_ms());
+    c->active = true;
+    c->ticks = ble_npl_time_get() + ticks;
+    return BLE_NPL_OK;
+}
+
+void ble_npl_callout_stop(struct ble_npl_callout *c) {
+    DEBUG_CALLOUT_printf("ble_npl_callout_stop(%p)\n", c);
+    c->active = false;
+}
+
+bool ble_npl_callout_is_active(struct ble_npl_callout *c) {
+    DEBUG_CALLOUT_printf("ble_npl_callout_is_active(%p)\n", c);
+    return c->active;
+}
+
+ble_npl_time_t ble_npl_callout_get_ticks(struct ble_npl_callout *c) {
+    DEBUG_CALLOUT_printf("ble_npl_callout_get_ticks(%p)\n", c);
+    return c->ticks;
+}
+
+ble_npl_time_t ble_npl_callout_remaining_ticks(struct ble_npl_callout *c, ble_npl_time_t now) {
+    DEBUG_CALLOUT_printf("ble_npl_callout_remaining_ticks(%p, %u)\n", c, (uint)now);
+    if (c->ticks > now) {
+        return c->ticks - now;
+    } else {
+        return 0;
+    }
+}
+
+void *ble_npl_callout_get_arg(struct ble_npl_callout *c) {
+    DEBUG_CALLOUT_printf("ble_npl_callout_get_arg(%p)\n", c);
+    return ble_npl_event_get_arg(&c->ev);
+}
+
+void ble_npl_callout_set_arg(struct ble_npl_callout *c, void *arg) {
+    DEBUG_CALLOUT_printf("ble_npl_callout_set_arg(%p, %p)\n", c, arg);
+    ble_npl_event_set_arg(&c->ev, arg);
+}
+
+/******************************************************************************/
+// TIME
+
+uint32_t ble_npl_time_get(void) {
+    DEBUG_TIME_printf("ble_npl_time_get -> %u\n", (uint)mp_hal_ticks_ms());
+    return mp_hal_ticks_ms();
+}
+
+ble_npl_error_t ble_npl_time_ms_to_ticks(uint32_t ms, ble_npl_time_t *out_ticks) {
+    DEBUG_TIME_printf("ble_npl_time_ms_to_ticks(%u)\n", (uint)ms);
+    *out_ticks = ms;
+    return BLE_NPL_OK;
+}
+
+ble_npl_time_t ble_npl_time_ms_to_ticks32(uint32_t ms) {
+    DEBUG_TIME_printf("ble_npl_time_ms_to_ticks32(%u)\n", (uint)ms);
+    return ms;
+}
+
+uint32_t ble_npl_time_ticks_to_ms32(ble_npl_time_t ticks) {
+    DEBUG_TIME_printf("ble_npl_time_ticks_to_ms32(%u)\n", (uint)ticks);
+    return ticks;
+}
+
+void ble_npl_time_delay(ble_npl_time_t ticks) {
+    mp_hal_delay_ms(ticks + 1);
+}
+
+/******************************************************************************/
+// CRITICAL
+
+uint32_t ble_npl_hw_enter_critical(void) {
+    DEBUG_CRIT_printf("ble_npl_hw_enter_critical()\n");
+    return raise_irq_pri(15);
+}
+
+void ble_npl_hw_exit_critical(uint32_t ctx) {
+    DEBUG_CRIT_printf("ble_npl_hw_exit_critical(%u)\n", (uint)ctx);
+    restore_irq_pri(ctx);
+}
diff --git a/extmod/nimble/syscfg/syscfg.h b/extmod/nimble/syscfg/syscfg.h
new file mode 100644
index 0000000000000..6ac420f35e550
--- /dev/null
+++ b/extmod/nimble/syscfg/syscfg.h
@@ -0,0 +1,164 @@
+#ifndef MICROPY_INCLUDED_EXTMOD_NIMBLE_SYSCFG_H
+#define MICROPY_INCLUDED_EXTMOD_NIMBLE_SYSCFG_H
+
+#include "py/mphal.h"
+#include "uart.h"
+
+void *nimble_malloc(size_t size);
+void nimble_free(void *ptr);
+void *nimble_realloc(void *ptr, size_t size);
+
+#define malloc(size) nimble_malloc(size)
+#define free(ptr) nimble_free(ptr)
+#define realloc(ptr, size) nimble_realloc(ptr, size)
+
+int nimble_sprintf(char *str, const char *fmt, ...);
+#define sprintf(str, fmt, ...) nimble_sprintf(str, fmt, __VA_ARGS__)
+
+#define MYNEWT_VAL(x) MYNEWT_VAL_ ## x
+
+#define MYNEWT_VAL_LOG_LEVEL (255)
+
+/*** compiler/arm-none-eabi-m4 */
+#define MYNEWT_VAL_HARDFLOAT (1)
+
+/*** kernel/os */
+#define MYNEWT_VAL_FLOAT_USER (0)
+#define MYNEWT_VAL_MSYS_1_BLOCK_COUNT (12)
+#define MYNEWT_VAL_MSYS_1_BLOCK_SIZE (292)
+#define MYNEWT_VAL_MSYS_2_BLOCK_COUNT (0)
+#define MYNEWT_VAL_MSYS_2_BLOCK_SIZE (0)
+#define MYNEWT_VAL_OS_CPUTIME_FREQ (1000000)
+#define MYNEWT_VAL_OS_CPUTIME_TIMER_NUM (0)
+#define MYNEWT_VAL_OS_CTX_SW_STACK_CHECK (0)
+#define MYNEWT_VAL_OS_CTX_SW_STACK_GUARD (4)
+#define MYNEWT_VAL_OS_MAIN_STACK_SIZE (1024)
+#define MYNEWT_VAL_OS_MAIN_TASK_PRIO (127)
+#define MYNEWT_VAL_OS_MEMPOOL_CHECK (0)
+#define MYNEWT_VAL_OS_MEMPOOL_POISON (0)
+
+/*** nimble */
+#define MYNEWT_VAL_BLE_EXT_ADV (0)
+#define MYNEWT_VAL_BLE_EXT_ADV_MAX_SIZE (31)
+#define MYNEWT_VAL_BLE_MAX_CONNECTIONS (4)
+#define MYNEWT_VAL_BLE_MULTI_ADV_INSTANCES (0)
+#define MYNEWT_VAL_BLE_ROLE_BROADCASTER (1)
+#define MYNEWT_VAL_BLE_ROLE_CENTRAL (1)
+#define MYNEWT_VAL_BLE_ROLE_OBSERVER (1)
+#define MYNEWT_VAL_BLE_ROLE_PERIPHERAL (1)
+#define MYNEWT_VAL_BLE_WHITELIST (1)
+
+/*** nimble/host */
+#define MYNEWT_VAL_BLE_ATT_PREFERRED_MTU (256)
+#define MYNEWT_VAL_BLE_ATT_SVR_FIND_INFO (1)
+#define MYNEWT_VAL_BLE_ATT_SVR_FIND_TYPE (1)
+#define MYNEWT_VAL_BLE_ATT_SVR_INDICATE (1)
+#define MYNEWT_VAL_BLE_ATT_SVR_MAX_PREP_ENTRIES (64)
+#define MYNEWT_VAL_BLE_ATT_SVR_NOTIFY (1)
+#define MYNEWT_VAL_BLE_ATT_SVR_QUEUED_WRITE (1)
+#define MYNEWT_VAL_BLE_ATT_SVR_QUEUED_WRITE_TMO (30000)
+#define MYNEWT_VAL_BLE_ATT_SVR_READ (1)
+#define MYNEWT_VAL_BLE_ATT_SVR_READ_BLOB (1)
+#define MYNEWT_VAL_BLE_ATT_SVR_READ_GROUP_TYPE (1)
+#define MYNEWT_VAL_BLE_ATT_SVR_READ_MULT (1)
+#define MYNEWT_VAL_BLE_ATT_SVR_READ_TYPE (1)
+#define MYNEWT_VAL_BLE_ATT_SVR_SIGNED_WRITE (1)
+#define MYNEWT_VAL_BLE_ATT_SVR_WRITE (1)
+#define MYNEWT_VAL_BLE_ATT_SVR_WRITE_NO_RSP (1)
+#define MYNEWT_VAL_BLE_GAP_MAX_PENDING_CONN_PARAM_UPDATE (1)
+#define MYNEWT_VAL_BLE_GATT_DISC_ALL_CHRS (MYNEWT_VAL_BLE_ROLE_CENTRAL)
+#define MYNEWT_VAL_BLE_GATT_DISC_ALL_DSCS (MYNEWT_VAL_BLE_ROLE_CENTRAL)
+#define MYNEWT_VAL_BLE_GATT_DISC_ALL_SVCS (MYNEWT_VAL_BLE_ROLE_CENTRAL)
+#define MYNEWT_VAL_BLE_GATT_DISC_CHR_UUID (MYNEWT_VAL_BLE_ROLE_CENTRAL)
+#define MYNEWT_VAL_BLE_GATT_DISC_SVC_UUID (MYNEWT_VAL_BLE_ROLE_CENTRAL)
+#define MYNEWT_VAL_BLE_GATT_FIND_INC_SVCS (MYNEWT_VAL_BLE_ROLE_CENTRAL)
+#define MYNEWT_VAL_BLE_GATT_INDICATE (1)
+#define MYNEWT_VAL_BLE_GATT_MAX_PROCS (4)
+#define MYNEWT_VAL_BLE_GATT_NOTIFY (1)
+#define MYNEWT_VAL_BLE_GATT_READ (MYNEWT_VAL_BLE_ROLE_CENTRAL)
+#define MYNEWT_VAL_BLE_GATT_READ_LONG (MYNEWT_VAL_BLE_ROLE_CENTRAL)
+#define MYNEWT_VAL_BLE_GATT_READ_MAX_ATTRS (8)
+#define MYNEWT_VAL_BLE_GATT_READ_MULT (MYNEWT_VAL_BLE_ROLE_CENTRAL)
+#define MYNEWT_VAL_BLE_GATT_READ_UUID (MYNEWT_VAL_BLE_ROLE_CENTRAL)
+#define MYNEWT_VAL_BLE_GATT_RESUME_RATE (1000)
+#define MYNEWT_VAL_BLE_GATT_SIGNED_WRITE (MYNEWT_VAL_BLE_ROLE_CENTRAL)
+#define MYNEWT_VAL_BLE_GATT_WRITE (MYNEWT_VAL_BLE_ROLE_CENTRAL)
+#define MYNEWT_VAL_BLE_GATT_WRITE_LONG (MYNEWT_VAL_BLE_ROLE_CENTRAL)
+#define MYNEWT_VAL_BLE_GATT_WRITE_MAX_ATTRS (4)
+#define MYNEWT_VAL_BLE_GATT_WRITE_NO_RSP (MYNEWT_VAL_BLE_ROLE_CENTRAL)
+#define MYNEWT_VAL_BLE_GATT_WRITE_RELIABLE (MYNEWT_VAL_BLE_ROLE_CENTRAL)
+#define MYNEWT_VAL_BLE_HOST (1)
+#define MYNEWT_VAL_BLE_HS_DEBUG (0)
+#define MYNEWT_VAL_BLE_HS_FLOW_CTRL (0)
+#define MYNEWT_VAL_BLE_HS_FLOW_CTRL_ITVL (1000)
+#define MYNEWT_VAL_BLE_HS_FLOW_CTRL_THRESH (2)
+#define MYNEWT_VAL_BLE_HS_FLOW_CTRL_TX_ON_DISCONNECT (0)
+#define MYNEWT_VAL_BLE_HS_PHONY_HCI_ACKS (0)
+#define MYNEWT_VAL_BLE_HS_REQUIRE_OS (1)
+#define MYNEWT_VAL_BLE_HS_STOP_ON_SHUTDOWN_TIMEOUT (2000)
+#define MYNEWT_VAL_BLE_L2CAP_COC_MAX_NUM (0)
+#define MYNEWT_VAL_BLE_L2CAP_JOIN_RX_FRAGS (1)
+#define MYNEWT_VAL_BLE_L2CAP_MAX_CHANS (3*MYNEWT_VAL_BLE_MAX_CONNECTIONS)
+#define MYNEWT_VAL_BLE_L2CAP_RX_FRAG_TIMEOUT (30000)
+#define MYNEWT_VAL_BLE_L2CAP_SIG_MAX_PROCS (1)
+#define MYNEWT_VAL_BLE_MONITOR_CONSOLE_BUFFER_SIZE (128)
+#define MYNEWT_VAL_BLE_MONITOR_RTT (0)
+#define MYNEWT_VAL_BLE_MONITOR_RTT_BUFFERED (1)
+#define MYNEWT_VAL_BLE_MONITOR_RTT_BUFFER_NAME ("monitor")
+#define MYNEWT_VAL_BLE_MONITOR_RTT_BUFFER_SIZE (256)
+#define MYNEWT_VAL_BLE_MONITOR_UART (0)
+#define MYNEWT_VAL_BLE_MONITOR_UART_BAUDRATE (1000000)
+#define MYNEWT_VAL_BLE_MONITOR_UART_BUFFER_SIZE (64)
+#define MYNEWT_VAL_BLE_MONITOR_UART_DEV ("uart0")
+#define MYNEWT_VAL_BLE_RPA_TIMEOUT (300)
+#define MYNEWT_VAL_BLE_SM_BONDING (0)
+#define MYNEWT_VAL_BLE_SM_IO_CAP (BLE_HS_IO_NO_INPUT_OUTPUT)
+#define MYNEWT_VAL_BLE_SM_KEYPRESS (0)
+#define MYNEWT_VAL_BLE_SM_LEGACY (1)
+#define MYNEWT_VAL_BLE_SM_MAX_PROCS (1)
+#define MYNEWT_VAL_BLE_SM_MITM (0)
+#define MYNEWT_VAL_BLE_SM_OOB_DATA_FLAG (0)
+#define MYNEWT_VAL_BLE_SM_OUR_KEY_DIST (0)
+#define MYNEWT_VAL_BLE_SM_SC (1)
+#define MYNEWT_VAL_BLE_SM_THEIR_KEY_DIST (0)
+#define MYNEWT_VAL_BLE_STORE_MAX_BONDS (3)
+#define MYNEWT_VAL_BLE_STORE_MAX_CCCDS (8)
+
+/*** nimble/host/services/gap */
+#define MYNEWT_VAL_BLE_SVC_GAP_APPEARANCE (0)
+#define MYNEWT_VAL_BLE_SVC_GAP_APPEARANCE_WRITE_PERM (-1)
+#define MYNEWT_VAL_BLE_SVC_GAP_CENTRAL_ADDRESS_RESOLUTION (-1)
+#define MYNEWT_VAL_BLE_SVC_GAP_DEVICE_NAME ("pybd")
+#define MYNEWT_VAL_BLE_SVC_GAP_DEVICE_NAME_MAX_LENGTH (31)
+#define MYNEWT_VAL_BLE_SVC_GAP_DEVICE_NAME_WRITE_PERM (-1)
+#define MYNEWT_VAL_BLE_SVC_GAP_PPCP_MAX_CONN_INTERVAL (0)
+#define MYNEWT_VAL_BLE_SVC_GAP_PPCP_MIN_CONN_INTERVAL (0)
+#define MYNEWT_VAL_BLE_SVC_GAP_PPCP_SLAVE_LATENCY (0)
+#define MYNEWT_VAL_BLE_SVC_GAP_PPCP_SUPERVISION_TMO (0)
+
+/* Overridden by targets/porting-nimble (defined by nimble/transport) */
+#define MYNEWT_VAL_BLE_HCI_TRANSPORT_NIMBLE_BUILTIN (0)
+#define MYNEWT_VAL_BLE_HCI_TRANSPORT_RAM (0)
+#define MYNEWT_VAL_BLE_HCI_TRANSPORT_SOCKET (0)
+#define MYNEWT_VAL_BLE_HCI_TRANSPORT_UART (1)
+
+/*** nimble/transport/uart */
+#define MYNEWT_VAL_BLE_ACL_BUF_COUNT (12)
+#define MYNEWT_VAL_BLE_ACL_BUF_SIZE (255)
+#define MYNEWT_VAL_BLE_HCI_ACL_OUT_COUNT (12)
+#define MYNEWT_VAL_BLE_HCI_EVT_BUF_SIZE (70)
+#define MYNEWT_VAL_BLE_HCI_EVT_HI_BUF_COUNT (8)
+#define MYNEWT_VAL_BLE_HCI_EVT_LO_BUF_COUNT (8)
+
+/* Overridden by targets/porting-nimble (defined by nimble/transport/uart) */
+#define MYNEWT_VAL_BLE_HCI_UART_BAUD (MICROPY_HW_BLE_UART_BAUDRATE)
+#define MYNEWT_VAL_BLE_HCI_UART_DATA_BITS (8)
+#define MYNEWT_VAL_BLE_HCI_UART_FLOW_CTRL (1)
+#define MYNEWT_VAL_BLE_HCI_UART_PARITY (HAL_UART_PARITY_NONE)
+#define MYNEWT_VAL_BLE_HCI_UART_PORT (MICROPY_HW_BLE_UART_ID)
+#define MYNEWT_VAL_BLE_HCI_UART_STOP_BITS (1)
+
+/* Required for code that uses BLE_HS_LOG */
+#define MYNEWT_VAL_NEWT_FEATURE_LOGCFG (1)
+
+#endif // MICROPY_INCLUDED_EXTMOD_NIMBLE_SYSCFG_H
diff --git a/extmod/re1.5/compilecode.c b/extmod/re1.5/compilecode.c
index a685a508a04b3..3f54b3993fd36 100644
--- a/extmod/re1.5/compilecode.c
+++ b/extmod/re1.5/compilecode.c
@@ -53,6 +53,9 @@ static const char *_compilecode(const char *re, ByteProg *prog, int sizecode)
             PC++; // Skip # of pair byte
             prog->len++;
             for (cnt = 0; *re != ']'; re++, cnt++) {
+                if (*re == '\\') {
+                    ++re;
+                }
                 if (!*re) return NULL;
                 EMIT(PC++, *re);
                 if (re[1] == '-' && re[2] != ']') {
diff --git a/extmod/uasyncio/__init__.py b/extmod/uasyncio/__init__.py
new file mode 100644
index 0000000000000..da8b58061e6ca
--- /dev/null
+++ b/extmod/uasyncio/__init__.py
@@ -0,0 +1,28 @@
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019 Damien P. George
+
+from .core import *
+
+__version__ = (3, 0, 0)
+
+_attrs = {
+    "wait_for": "funcs",
+    "gather": "funcs",
+    "Event": "event",
+    "Lock": "lock",
+    "open_connection": "stream",
+    "start_server": "stream",
+    "StreamReader": "stream",
+    "StreamWriter": "stream",
+}
+
+# Lazy loader, effectively does:
+#   global attr
+#   from .mod import attr
+def __getattr__(attr):
+    mod = _attrs.get(attr, None)
+    if mod is None:
+        raise AttributeError(attr)
+    value = getattr(__import__(mod, None, None, True, 1), attr)
+    globals()[attr] = value
+    return value
diff --git a/extmod/uasyncio/core.py b/extmod/uasyncio/core.py
new file mode 100644
index 0000000000000..689487d36a6fd
--- /dev/null
+++ b/extmod/uasyncio/core.py
@@ -0,0 +1,277 @@
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019 Damien P. George
+
+from time import ticks_ms as ticks, ticks_diff, ticks_add
+import sys, select
+
+# Import TaskQueue and Task, preferring built-in C code over Python code
+try:
+    from _uasyncio import TaskQueue, Task
+except:
+    from .task import TaskQueue, Task
+
+
+################################################################################
+# Exceptions
+
+
+class CancelledError(BaseException):
+    pass
+
+
+class TimeoutError(Exception):
+    pass
+
+
+# Used when calling Loop.call_exception_handler
+_exc_context = {"message": "Task exception wasn't retrieved", "exception": None, "future": None}
+
+
+################################################################################
+# Sleep functions
+
+# "Yield" once, then raise StopIteration
+class SingletonGenerator:
+    def __init__(self):
+        self.state = None
+        self.exc = StopIteration()
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.state is not None:
+            _task_queue.push_sorted(cur_task, self.state)
+            self.state = None
+            return None
+        else:
+            self.exc.__traceback__ = None
+            raise self.exc
+
+
+# Pause task execution for the given time (integer in milliseconds, uPy extension)
+# Use a SingletonGenerator to do it without allocating on the heap
+def sleep_ms(t, sgen=SingletonGenerator()):
+    assert sgen.state is None
+    sgen.state = ticks_add(ticks(), t)
+    return sgen
+
+
+# Pause task execution for the given time (in seconds)
+def sleep(t):
+    return sleep_ms(int(t * 1000))
+
+
+################################################################################
+# Queue and poller for stream IO
+
+
+class IOQueue:
+    def __init__(self):
+        self.poller = select.poll()
+        self.map = {}  # maps id(stream) to [task_waiting_read, task_waiting_write, stream]
+
+    def _enqueue(self, s, idx):
+        if id(s) not in self.map:
+            entry = [None, None, s]
+            entry[idx] = cur_task
+            self.map[id(s)] = entry
+            self.poller.register(s, select.POLLIN if idx == 0 else select.POLLOUT)
+        else:
+            sm = self.map[id(s)]
+            assert sm[idx] is None
+            assert sm[1 - idx] is not None
+            sm[idx] = cur_task
+            self.poller.modify(s, select.POLLIN | select.POLLOUT)
+        # Link task to this IOQueue so it can be removed if needed
+        cur_task.data = self
+
+    def _dequeue(self, s):
+        del self.map[id(s)]
+        self.poller.unregister(s)
+
+    def queue_read(self, s):
+        self._enqueue(s, 0)
+
+    def queue_write(self, s):
+        self._enqueue(s, 1)
+
+    def remove(self, task):
+        while True:
+            del_s = None
+            for k in self.map:  # Iterate without allocating on the heap
+                q0, q1, s = self.map[k]
+                if q0 is task or q1 is task:
+                    del_s = s
+                    break
+            if del_s is not None:
+                self._dequeue(s)
+            else:
+                break
+
+    def wait_io_event(self, dt):
+        for s, ev in self.poller.ipoll(dt):
+            sm = self.map[id(s)]
+            # print('poll', s, sm, ev)
+            if ev & ~select.POLLOUT and sm[0] is not None:
+                # POLLIN or error
+                _task_queue.push_head(sm[0])
+                sm[0] = None
+            if ev & ~select.POLLIN and sm[1] is not None:
+                # POLLOUT or error
+                _task_queue.push_head(sm[1])
+                sm[1] = None
+            if sm[0] is None and sm[1] is None:
+                self._dequeue(s)
+            elif sm[0] is None:
+                self.poller.modify(s, select.POLLOUT)
+            else:
+                self.poller.modify(s, select.POLLIN)
+
+
+################################################################################
+# Main run loop
+
+# Ensure the awaitable is a task
+def _promote_to_task(aw):
+    return aw if isinstance(aw, Task) else create_task(aw)
+
+
+# Create and schedule a new task from a coroutine
+def create_task(coro):
+    if not hasattr(coro, "send"):
+        raise TypeError("coroutine expected")
+    t = Task(coro, globals())
+    _task_queue.push_head(t)
+    return t
+
+
+# Keep scheduling tasks until there are none left to schedule
+def run_until_complete(main_task=None):
+    global cur_task
+    excs_all = (CancelledError, Exception)  # To prevent heap allocation in loop
+    excs_stop = (CancelledError, StopIteration)  # To prevent heap allocation in loop
+    while True:
+        # Wait until the head of _task_queue is ready to run
+        dt = 1
+        while dt > 0:
+            dt = -1
+            t = _task_queue.peek()
+            if t:
+                # A task waiting on _task_queue; "ph_key" is time to schedule task at
+                dt = max(0, ticks_diff(t.ph_key, ticks()))
+            elif not _io_queue.map:
+                # No tasks can be woken so finished running
+                return
+            # print('(poll {})'.format(dt), len(_io_queue.map))
+            _io_queue.wait_io_event(dt)
+
+        # Get next task to run and continue it
+        t = _task_queue.pop_head()
+        cur_task = t
+        try:
+            # Continue running the coroutine, it's responsible for rescheduling itself
+            exc = t.data
+            if not exc:
+                t.coro.send(None)
+            else:
+                t.data = None
+                t.coro.throw(exc)
+        except excs_all as er:
+            # Check the task is not on any event queue
+            assert t.data is None
+            # This task is done, check if it's the main task and then loop should stop
+            if t is main_task:
+                if isinstance(er, StopIteration):
+                    return er.value
+                raise er
+            # Save return value of coro to pass up to caller
+            t.data = er
+            # Schedule any other tasks waiting on the completion of this task
+            waiting = False
+            if hasattr(t, "waiting"):
+                while t.waiting.peek():
+                    _task_queue.push_head(t.waiting.pop_head())
+                    waiting = True
+                t.waiting = None  # Free waiting queue head
+            # Print out exception for detached tasks
+            if not waiting and not isinstance(er, excs_stop):
+                _exc_context["exception"] = er
+                _exc_context["future"] = t
+                Loop.call_exception_handler(_exc_context)
+            # Indicate task is done
+            t.coro = None
+
+
+# Create a new task from a coroutine and run it until it finishes
+def run(coro):
+    return run_until_complete(create_task(coro))
+
+
+################################################################################
+# Event loop wrapper
+
+
+async def _stopper():
+    pass
+
+
+_stop_task = None
+
+
+class Loop:
+    _exc_handler = None
+
+    def create_task(coro):
+        return create_task(coro)
+
+    def run_forever():
+        global _stop_task
+        _stop_task = Task(_stopper(), globals())
+        run_until_complete(_stop_task)
+        # TODO should keep running until .stop() is called, even if there're no tasks left
+
+    def run_until_complete(aw):
+        return run_until_complete(_promote_to_task(aw))
+
+    def stop():
+        global _stop_task
+        if _stop_task is not None:
+            _task_queue.push_head(_stop_task)
+            # If stop() is called again, do nothing
+            _stop_task = None
+
+    def close():
+        pass
+
+    def set_exception_handler(handler):
+        Loop._exc_handler = handler
+
+    def get_exception_handler():
+        return Loop._exc_handler
+
+    def default_exception_handler(loop, context):
+        print(context["message"])
+        print("future:", context["future"], "coro=", context["future"].coro)
+        sys.print_exception(context["exception"])
+
+    def call_exception_handler(context):
+        (Loop._exc_handler or Loop.default_exception_handler)(Loop, context)
+
+
+# The runq_len and waitq_len arguments are for legacy uasyncio compatibility
+def get_event_loop(runq_len=0, waitq_len=0):
+    return Loop
+
+
+def new_event_loop():
+    global _task_queue, _io_queue
+    # TaskQueue of Task instances
+    _task_queue = TaskQueue()
+    # Task queue and poller for stream IO
+    _io_queue = IOQueue()
+    return Loop
+
+
+# Initialise default event loop
+new_event_loop()
diff --git a/extmod/uasyncio/event.py b/extmod/uasyncio/event.py
new file mode 100644
index 0000000000000..31cb00e055deb
--- /dev/null
+++ b/extmod/uasyncio/event.py
@@ -0,0 +1,31 @@
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019-2020 Damien P. George
+
+from . import core
+
+# Event class for primitive events that can be waited on, set, and cleared
+class Event:
+    def __init__(self):
+        self.state = False  # False=unset; True=set
+        self.waiting = core.TaskQueue()  # Queue of Tasks waiting on completion of this event
+
+    def is_set(self):
+        return self.state
+
+    def set(self):
+        # Event becomes set, schedule any tasks waiting on it
+        while self.waiting.peek():
+            core._task_queue.push_head(self.waiting.pop_head())
+        self.state = True
+
+    def clear(self):
+        self.state = False
+
+    async def wait(self):
+        if not self.state:
+            # Event not set, put the calling task on the event's waiting queue
+            self.waiting.push_head(core.cur_task)
+            # Set calling task's data to the event's queue so it can be removed if needed
+            core.cur_task.data = self.waiting
+            yield
+        return True
diff --git a/extmod/uasyncio/funcs.py b/extmod/uasyncio/funcs.py
new file mode 100644
index 0000000000000..7a4bddf25695a
--- /dev/null
+++ b/extmod/uasyncio/funcs.py
@@ -0,0 +1,50 @@
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019-2020 Damien P. George
+
+from . import core
+
+
+async def wait_for(aw, timeout):
+    aw = core._promote_to_task(aw)
+    if timeout is None:
+        return await aw
+
+    def cancel(aw, timeout):
+        await core.sleep(timeout)
+        aw.cancel()
+
+    cancel_task = core.create_task(cancel(aw, timeout))
+    try:
+        ret = await aw
+    except core.CancelledError:
+        # Ignore CancelledError from aw, it's probably due to timeout
+        pass
+    finally:
+        # Cancel the "cancel" task if it's still active (optimisation instead of cancel_task.cancel())
+        if cancel_task.coro is not None:
+            core._task_queue.remove(cancel_task)
+    if cancel_task.coro is None:
+        # Cancel task ran to completion, ie there was a timeout
+        raise core.TimeoutError
+    return ret
+
+
+async def gather(*aws, return_exceptions=False):
+    ts = [core._promote_to_task(aw) for aw in aws]
+    for i in range(len(ts)):
+        try:
+            # TODO handle cancel of gather itself
+            # if ts[i].coro:
+            #    iter(ts[i]).waiting.push_head(cur_task)
+            #    try:
+            #        yield
+            #    except CancelledError as er:
+            #        # cancel all waiting tasks
+            #        raise er
+            ts[i] = await ts[i]
+        except Exception as er:
+            if return_exceptions:
+                ts[i] = er
+            else:
+                raise er
+    return ts
diff --git a/extmod/uasyncio/lock.py b/extmod/uasyncio/lock.py
new file mode 100644
index 0000000000000..bddca295b6af0
--- /dev/null
+++ b/extmod/uasyncio/lock.py
@@ -0,0 +1,53 @@
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019-2020 Damien P. George
+
+from . import core
+
+# Lock class for primitive mutex capability
+class Lock:
+    def __init__(self):
+        # The state can take the following values:
+        # - 0: unlocked
+        # - 1: locked
+        # - <Task>: unlocked but this task has been scheduled to acquire the lock next
+        self.state = 0
+        # Queue of Tasks waiting to acquire this Lock
+        self.waiting = core.TaskQueue()
+
+    def locked(self):
+        return self.state == 1
+
+    def release(self):
+        if self.state != 1:
+            raise RuntimeError("Lock not acquired")
+        if self.waiting.peek():
+            # Task(s) waiting on lock, schedule next Task
+            self.state = self.waiting.pop_head()
+            core._task_queue.push_head(self.state)
+        else:
+            # No Task waiting so unlock
+            self.state = 0
+
+    async def acquire(self):
+        if self.state != 0:
+            # Lock unavailable, put the calling Task on the waiting queue
+            self.waiting.push_head(core.cur_task)
+            # Set calling task's data to the lock's queue so it can be removed if needed
+            core.cur_task.data = self.waiting
+            try:
+                yield
+            except core.CancelledError as er:
+                if self.state == core.cur_task:
+                    # Cancelled while pending on resume, schedule next waiting Task
+                    self.state = 1
+                    self.release()
+                raise er
+        # Lock available, set it as locked
+        self.state = 1
+        return True
+
+    async def __aenter__(self):
+        return await self.acquire()
+
+    async def __aexit__(self, exc_type, exc, tb):
+        return self.release()
diff --git a/extmod/uasyncio/manifest.py b/extmod/uasyncio/manifest.py
new file mode 100644
index 0000000000000..f5fa27bfcaa35
--- /dev/null
+++ b/extmod/uasyncio/manifest.py
@@ -0,0 +1,13 @@
+# This list of frozen files doesn't include task.py because that's provided by the C module.
+freeze(
+    "..",
+    (
+        "uasyncio/__init__.py",
+        "uasyncio/core.py",
+        "uasyncio/event.py",
+        "uasyncio/funcs.py",
+        "uasyncio/lock.py",
+        "uasyncio/stream.py",
+    ),
+    opt=3,
+)
diff --git a/extmod/uasyncio/stream.py b/extmod/uasyncio/stream.py
new file mode 100644
index 0000000000000..2a1efd1a17bfc
--- /dev/null
+++ b/extmod/uasyncio/stream.py
@@ -0,0 +1,146 @@
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019-2020 Damien P. George
+
+from . import core
+
+
+class Stream:
+    def __init__(self, s, e={}):
+        self.s = s
+        self.e = e
+        self.out_buf = b""
+
+    def get_extra_info(self, v):
+        return self.e[v]
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.close()
+
+    def close(self):
+        pass
+
+    async def wait_closed(self):
+        # TODO yield?
+        self.s.close()
+
+    async def read(self, n):
+        yield core._io_queue.queue_read(self.s)
+        return self.s.read(n)
+
+    async def readline(self):
+        l = b""
+        while True:
+            yield core._io_queue.queue_read(self.s)
+            l2 = self.s.readline()  # may do multiple reads but won't block
+            l += l2
+            if not l2 or l[-1] == 10:  # \n (check l in case l2 is str)
+                return l
+
+    def write(self, buf):
+        self.out_buf += buf
+
+    async def drain(self):
+        mv = memoryview(self.out_buf)
+        off = 0
+        while off < len(mv):
+            yield core._io_queue.queue_write(self.s)
+            ret = self.s.write(mv[off:])
+            if ret is not None:
+                off += ret
+        self.out_buf = b""
+
+
+# Stream can be used for both reading and writing to save code size
+StreamReader = Stream
+StreamWriter = Stream
+
+
+# Create a TCP stream connection to a remote host
+async def open_connection(host, port):
+    from uerrno import EINPROGRESS
+    import usocket as socket
+
+    ai = socket.getaddrinfo(host, port)[0]  # TODO this is blocking!
+    s = socket.socket()
+    s.setblocking(False)
+    ss = Stream(s)
+    try:
+        s.connect(ai[-1])
+    except OSError as er:
+        if er.args[0] != EINPROGRESS:
+            raise er
+    yield core._io_queue.queue_write(s)
+    return ss, ss
+
+
+# Class representing a TCP stream server, can be closed and used in "async with"
+class Server:
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        self.close()
+        await self.wait_closed()
+
+    def close(self):
+        self.task.cancel()
+
+    async def wait_closed(self):
+        await self.task
+
+    async def _serve(self, cb, host, port, backlog):
+        import usocket as socket
+
+        ai = socket.getaddrinfo(host, port)[0]  # TODO this is blocking!
+        s = socket.socket()
+        s.setblocking(False)
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        s.bind(ai[-1])
+        s.listen(backlog)
+        self.task = core.cur_task
+        # Accept incoming connections
+        while True:
+            try:
+                yield core._io_queue.queue_read(s)
+            except core.CancelledError:
+                # Shutdown server
+                s.close()
+                return
+            try:
+                s2, addr = s.accept()
+            except:
+                # Ignore a failed accept
+                continue
+            s2.setblocking(False)
+            s2s = Stream(s2, {"peername": addr})
+            core.create_task(cb(s2s, s2s))
+
+
+# Helper function to start a TCP stream server, running as a new task
+# TODO could use an accept-callback on socket read activity instead of creating a task
+async def start_server(cb, host, port, backlog=5):
+    s = Server()
+    core.create_task(s._serve(cb, host, port, backlog))
+    return s
+
+
+################################################################################
+# Legacy uasyncio compatibility
+
+
+async def stream_awrite(self, buf, off=0, sz=-1):
+    if off != 0 or sz != -1:
+        buf = memoryview(buf)
+        if sz == -1:
+            sz = len(buf)
+        buf = buf[off : off + sz]
+    self.write(buf)
+    await self.drain()
+
+
+Stream.aclose = Stream.wait_closed
+Stream.awrite = stream_awrite
+Stream.awritestr = stream_awrite  # TODO explicitly convert to bytes?
diff --git a/extmod/uasyncio/task.py b/extmod/uasyncio/task.py
new file mode 100644
index 0000000000000..1788cf0ed0486
--- /dev/null
+++ b/extmod/uasyncio/task.py
@@ -0,0 +1,168 @@
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019-2020 Damien P. George
+
+# This file contains the core TaskQueue based on a pairing heap, and the core Task class.
+# They can optionally be replaced by C implementations.
+
+from . import core
+
+
+# pairing-heap meld of 2 heaps; O(1)
+def ph_meld(h1, h2):
+    if h1 is None:
+        return h2
+    if h2 is None:
+        return h1
+    lt = core.ticks_diff(h1.ph_key, h2.ph_key) < 0
+    if lt:
+        if h1.ph_child is None:
+            h1.ph_child = h2
+        else:
+            h1.ph_child_last.ph_next = h2
+        h1.ph_child_last = h2
+        h2.ph_next = None
+        h2.ph_rightmost_parent = h1
+        return h1
+    else:
+        h1.ph_next = h2.ph_child
+        h2.ph_child = h1
+        if h1.ph_next is None:
+            h2.ph_child_last = h1
+            h1.ph_rightmost_parent = h2
+        return h2
+
+
+# pairing-heap pairing operation; amortised O(log N)
+def ph_pairing(child):
+    heap = None
+    while child is not None:
+        n1 = child
+        child = child.ph_next
+        n1.ph_next = None
+        if child is not None:
+            n2 = child
+            child = child.ph_next
+            n2.ph_next = None
+            n1 = ph_meld(n1, n2)
+        heap = ph_meld(heap, n1)
+    return heap
+
+
+# pairing-heap delete of a node; stable, amortised O(log N)
+def ph_delete(heap, node):
+    if node is heap:
+        child = heap.ph_child
+        node.ph_child = None
+        return ph_pairing(child)
+    # Find parent of node
+    parent = node
+    while parent.ph_next is not None:
+        parent = parent.ph_next
+    parent = parent.ph_rightmost_parent
+    # Replace node with pairing of its children
+    if node is parent.ph_child and node.ph_child is None:
+        parent.ph_child = node.ph_next
+        node.ph_next = None
+        return heap
+    elif node is parent.ph_child:
+        child = node.ph_child
+        next = node.ph_next
+        node.ph_child = None
+        node.ph_next = None
+        node = ph_pairing(child)
+        parent.ph_child = node
+    else:
+        n = parent.ph_child
+        while node is not n.ph_next:
+            n = n.ph_next
+        child = node.ph_child
+        next = node.ph_next
+        node.ph_child = None
+        node.ph_next = None
+        node = ph_pairing(child)
+        if node is None:
+            node = n
+        else:
+            n.ph_next = node
+    node.ph_next = next
+    if next is None:
+        node.ph_rightmost_parent = parent
+        parent.ph_child_last = node
+    return heap
+
+
+# TaskQueue class based on the above pairing-heap functions.
+class TaskQueue:
+    def __init__(self):
+        self.heap = None
+
+    def peek(self):
+        return self.heap
+
+    def push_sorted(self, v, key):
+        v.data = None
+        v.ph_key = key
+        v.ph_child = None
+        v.ph_next = None
+        self.heap = ph_meld(v, self.heap)
+
+    def push_head(self, v):
+        self.push_sorted(v, core.ticks())
+
+    def pop_head(self):
+        v = self.heap
+        self.heap = ph_pairing(self.heap.ph_child)
+        return v
+
+    def remove(self, v):
+        self.heap = ph_delete(self.heap, v)
+
+
+# Task class representing a coroutine, can be waited on and cancelled.
+class Task:
+    def __init__(self, coro, globals=None):
+        self.coro = coro  # Coroutine of this Task
+        self.data = None  # General data for queue it is waiting on
+        self.ph_key = 0  # Pairing heap
+        self.ph_child = None  # Paring heap
+        self.ph_child_last = None  # Paring heap
+        self.ph_next = None  # Paring heap
+        self.ph_rightmost_parent = None  # Paring heap
+
+    def __iter__(self):
+        if not hasattr(self, "waiting"):
+            # Lazily allocated head of linked list of Tasks waiting on completion of this task.
+            self.waiting = TaskQueue()
+        return self
+
+    def __next__(self):
+        if not self.coro:
+            # Task finished, raise return value to caller so it can continue.
+            raise self.data
+        else:
+            # Put calling task on waiting queue.
+            self.waiting.push_head(core.cur_task)
+            # Set calling task's data to this task that it waits on, to double-link it.
+            core.cur_task.data = self
+
+    def cancel(self):
+        # Check if task is already finished.
+        if self.coro is None:
+            return False
+        # Can't cancel self (not supported yet).
+        if self is core.cur_task:
+            raise RuntimeError("can't cancel self")
+        # If Task waits on another task then forward the cancel to the one it's waiting on.
+        while isinstance(self.data, Task):
+            self = self.data
+        # Reschedule Task as a cancelled task.
+        if hasattr(self.data, "remove"):
+            # Not on the main running queue, remove the task from the queue it's on.
+            self.data.remove(self)
+            core._task_queue.push_head(self)
+        elif core.ticks_diff(self.ph_key, core.ticks()) > 0:
+            # On the main running queue but scheduled in the future, so bring it forward to now.
+            core._task_queue.remove(self)
+            core._task_queue.push_head(self)
+        self.data = core.CancelledError
+        return True
diff --git a/extmod/uos_dupterm.c b/extmod/uos_dupterm.c
index 42cb21444b010..ad706d5246f35 100644
--- a/extmod/uos_dupterm.c
+++ b/extmod/uos_dupterm.c
@@ -4,7 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2016 Paul Sokolovsky
- * Copyright (c) 2017 Damien P. George
+ * Copyright (c) 2017-2019 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -53,6 +53,45 @@ void mp_uos_deactivate(size_t dupterm_idx, const char *msg, mp_obj_t exc) {
     }
 }
 
+uintptr_t mp_uos_dupterm_poll(uintptr_t poll_flags) {
+    uintptr_t poll_flags_out = 0;
+
+    for (size_t idx = 0; idx < MICROPY_PY_OS_DUPTERM; ++idx) {
+        mp_obj_t s = MP_STATE_VM(dupterm_objs[idx]);
+        if (s == MP_OBJ_NULL) {
+            continue;
+        }
+
+        int errcode = 0;
+        mp_uint_t ret = 0;
+        const mp_stream_p_t *stream_p = mp_get_stream(s);
+        #if MICROPY_PY_UOS_DUPTERM_BUILTIN_STREAM
+        if (mp_uos_dupterm_is_builtin_stream(s)) {
+            ret = stream_p->ioctl(s, MP_STREAM_POLL, poll_flags, &errcode);
+        } else
+        #endif
+        {
+            nlr_buf_t nlr;
+            if (nlr_push(&nlr) == 0) {
+                ret = stream_p->ioctl(s, MP_STREAM_POLL, poll_flags, &errcode);
+                nlr_pop();
+            } else {
+                // Ignore error with ioctl
+            }
+        }
+
+        if (ret != MP_STREAM_ERROR) {
+            poll_flags_out |= ret;
+            if (poll_flags_out == poll_flags) {
+                // Finish early if all requested flags are set
+                break;
+            }
+        }
+    }
+
+    return poll_flags_out;
+}
+
 int mp_uos_dupterm_rx_chr(void) {
     for (size_t idx = 0; idx < MICROPY_PY_OS_DUPTERM; ++idx) {
         if (MP_STATE_VM(dupterm_objs[idx]) == MP_OBJ_NULL) {
@@ -67,9 +106,9 @@ int mp_uos_dupterm_rx_chr(void) {
             mp_uint_t out_sz = stream_p->read(MP_STATE_VM(dupterm_objs[idx]), buf, 1, &errcode);
             if (errcode == 0 && out_sz != 0) {
                 return buf[0];
-             } else {
+            } else {
                 continue;
-             }
+            }
         }
         #endif
 
@@ -140,7 +179,7 @@ STATIC mp_obj_t mp_uos_dupterm(size_t n_args, const mp_obj_t *args) {
     }
 
     if (idx < 0 || idx >= MICROPY_PY_OS_DUPTERM) {
-        mp_raise_ValueError("invalid dupterm index");
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid dupterm index"));
     }
 
     mp_obj_t previous_obj = MP_STATE_VM(dupterm_objs[idx]);
diff --git a/extmod/utime_mphal.c b/extmod/utime_mphal.c
index 0fe3a3ba1d725..6aff2cac725c2 100644
--- a/extmod/utime_mphal.c
+++ b/extmod/utime_mphal.c
@@ -86,7 +86,7 @@ STATIC mp_obj_t time_ticks_diff(mp_obj_t end_in, mp_obj_t start_in) {
     // Optimized formula avoiding if conditions. We adjust difference "forward",
     // wrap it around and adjust back.
     mp_int_t diff = ((end - start + MICROPY_PY_UTIME_TICKS_PERIOD / 2) & (MICROPY_PY_UTIME_TICKS_PERIOD - 1))
-                   - MICROPY_PY_UTIME_TICKS_PERIOD / 2;
+        - MICROPY_PY_UTIME_TICKS_PERIOD / 2;
     return MP_OBJ_NEW_SMALL_INT(diff);
 }
 MP_DEFINE_CONST_FUN_OBJ_2(mp_utime_ticks_diff_obj, time_ticks_diff);
diff --git a/extmod/uzlib/tinflate.c b/extmod/uzlib/tinflate.c
index b93bc1fa36007..045952c7553a3 100644
--- a/extmod/uzlib/tinflate.c
+++ b/extmod/uzlib/tinflate.c
@@ -464,7 +464,7 @@ static int tinf_inflate_block_data(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt)
             }
         } else {
             /* catch trying to point before the start of dest buffer */
-            if (offs > d->dest - d->destStart) {
+            if (offs > (unsigned int)(d->dest - d->destStart)) {
                 return TINF_DATA_ERROR;
             }
             d->lzOff = -offs;
diff --git a/extmod/vfs.c b/extmod/vfs.c
index f99be3098b30b..d1291068ad8d6 100644
--- a/extmod/vfs.c
+++ b/extmod/vfs.c
@@ -38,6 +38,10 @@
 #include "extmod/vfs_fat.h"
 #endif
 
+#if MICROPY_VFS_LFS1 || MICROPY_VFS_LFS2
+#include "extmod/vfs_lfs.h"
+#endif
+
 #if MICROPY_VFS_POSIX
 #include "extmod/vfs_posix.h"
 #endif
@@ -99,7 +103,7 @@ STATIC mp_vfs_mount_t *lookup_path(mp_obj_t path_in, mp_obj_t *path_out) {
     mp_vfs_mount_t *vfs = mp_vfs_lookup_path(path, &p_out);
     if (vfs != MP_VFS_NONE && vfs != MP_VFS_ROOT) {
         *path_out = mp_obj_new_str_of_type(mp_obj_get_type(path_in),
-            (const byte*)p_out, strlen(p_out));
+            (const byte *)p_out, strlen(p_out));
     }
     return vfs;
 }
@@ -156,11 +160,49 @@ mp_import_stat_t mp_vfs_import_stat(const char *path) {
     }
 }
 
+STATIC mp_obj_t mp_vfs_autodetect(mp_obj_t bdev_obj) {
+    #if MICROPY_VFS_LFS1 || MICROPY_VFS_LFS2
+    nlr_buf_t nlr;
+    if (nlr_push(&nlr) == 0) {
+        mp_obj_t vfs = MP_OBJ_NULL;
+        mp_vfs_blockdev_t blockdev;
+        mp_vfs_blockdev_init(&blockdev, bdev_obj);
+        uint8_t buf[44];
+        mp_vfs_blockdev_read_ext(&blockdev, 0, 8, sizeof(buf), buf);
+        #if MICROPY_VFS_LFS1
+        if (memcmp(&buf[32], "littlefs", 8) == 0) {
+            // LFS1
+            vfs = mp_type_vfs_lfs1.make_new(&mp_type_vfs_lfs1, 1, 0, &bdev_obj);
+            nlr_pop();
+            return vfs;
+        }
+        #endif
+        #if MICROPY_VFS_LFS2
+        if (memcmp(&buf[0], "littlefs", 8) == 0) {
+            // LFS2
+            vfs = mp_type_vfs_lfs2.make_new(&mp_type_vfs_lfs2, 1, 0, &bdev_obj);
+            nlr_pop();
+            return vfs;
+        }
+        #endif
+        nlr_pop();
+    } else {
+        // Ignore exception (eg block device doesn't support extended readblocks)
+    }
+    #endif
+
+    #if MICROPY_VFS_FAT
+    return mp_fat_vfs_type.make_new(&mp_fat_vfs_type, 1, 0, &bdev_obj);
+    #endif
+
+    return bdev_obj;
+}
+
 mp_obj_t mp_vfs_mount(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     enum { ARG_readonly, ARG_mkfs };
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_readonly, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_false_obj)} },
-        { MP_QSTR_mkfs, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_false_obj)} },
+        { MP_QSTR_readonly, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_FALSE} },
+        { MP_QSTR_mkfs, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_FALSE} },
     };
 
     // parse args
@@ -178,10 +220,7 @@ mp_obj_t mp_vfs_mount(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args
     if (dest[0] == MP_OBJ_NULL) {
         // Input object has no mount method, assume it's a block device and try to
         // auto-detect the filesystem and create the corresponding VFS entity.
-        // (At the moment we only support FAT filesystems.)
-        #if MICROPY_VFS_FAT
-        vfs_obj = mp_fat_vfs_type.make_new(&mp_fat_vfs_type, 1, 0, &vfs_obj);
-        #endif
+        vfs_obj = mp_vfs_autodetect(vfs_obj);
     }
 
     // create new object
@@ -192,7 +231,7 @@ mp_obj_t mp_vfs_mount(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args
     vfs->next = NULL;
 
     // call the underlying object to do any mounting operation
-    mp_vfs_proxy_call(vfs, MP_QSTR_mount, 2, (mp_obj_t*)&args);
+    mp_vfs_proxy_call(vfs, MP_QSTR_mount, 2, (mp_obj_t *)&args);
 
     // check that the destination mount point is unused
     const char *path_out;
@@ -258,10 +297,10 @@ MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_umount_obj, mp_vfs_umount);
 mp_obj_t mp_vfs_open(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     enum { ARG_file, ARG_mode, ARG_encoding };
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_file, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_file, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_NONE} },
         { MP_QSTR_mode, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_QSTR(MP_QSTR_r)} },
         { MP_QSTR_buffering, MP_ARG_INT, {.u_int = -1} },
-        { MP_QSTR_encoding, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_encoding, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
     };
 
     // parse args
@@ -276,14 +315,13 @@ mp_obj_t mp_vfs_open(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args)
     #endif
 
     mp_vfs_mount_t *vfs = lookup_path(args[ARG_file].u_obj, &args[ARG_file].u_obj);
-    return mp_vfs_proxy_call(vfs, MP_QSTR_open, 2, (mp_obj_t*)&args);
+    return mp_vfs_proxy_call(vfs, MP_QSTR_open, 2, (mp_obj_t *)&args);
 }
 MP_DEFINE_CONST_FUN_OBJ_KW(mp_vfs_open_obj, 0, mp_vfs_open);
 
 mp_obj_t mp_vfs_chdir(mp_obj_t path_in) {
     mp_obj_t path_out;
     mp_vfs_mount_t *vfs = lookup_path(path_in, &path_out);
-    MP_STATE_VM(vfs_cur) = vfs;
     if (vfs == MP_VFS_ROOT) {
         // If we change to the root dir and a VFS is mounted at the root then
         // we must change that VFS's current dir to the root dir so that any
@@ -295,9 +333,11 @@ mp_obj_t mp_vfs_chdir(mp_obj_t path_in) {
                 break;
             }
         }
+        vfs = MP_VFS_ROOT;
     } else {
         mp_vfs_proxy_call(vfs, MP_QSTR_chdir, 1, &path_out);
     }
+    MP_STATE_VM(vfs_cur) = vfs;
     return mp_const_none;
 }
 MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_chdir_obj, mp_vfs_chdir);
@@ -356,7 +396,7 @@ STATIC mp_obj_t mp_vfs_ilistdir_it_iternext(mp_obj_t self_in) {
             mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
             t->items[0] = mp_obj_new_str_of_type(
                 self->is_str ? &mp_type_str : &mp_type_bytes,
-                (const byte*)vfs->str + 1, vfs->len - 1);
+                (const byte *)vfs->str + 1, vfs->len - 1);
             t->items[1] = MP_OBJ_NEW_SMALL_INT(MP_S_IFDIR);
             t->items[2] = MP_OBJ_NEW_SMALL_INT(0); // no inode number
             return MP_OBJ_FROM_PTR(t);
@@ -485,4 +525,25 @@ mp_obj_t mp_vfs_statvfs(mp_obj_t path_in) {
 }
 MP_DEFINE_CONST_FUN_OBJ_1(mp_vfs_statvfs_obj, mp_vfs_statvfs);
 
+// This is a C-level helper function for ports to use if needed.
+int mp_vfs_mount_and_chdir_protected(mp_obj_t bdev, mp_obj_t mount_point) {
+    nlr_buf_t nlr;
+    mp_int_t ret = -MP_EIO;
+    if (nlr_push(&nlr) == 0) {
+        mp_obj_t args[] = { bdev, mount_point };
+        mp_vfs_mount(2, args, (mp_map_t *)&mp_const_empty_map);
+        mp_vfs_chdir(mount_point);
+        ret = 0; // success
+        nlr_pop();
+    } else {
+        mp_obj_base_t *exc = nlr.ret_val;
+        if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(exc->type), MP_OBJ_FROM_PTR(&mp_type_OSError))) {
+            mp_obj_t v = mp_obj_exception_get_value(MP_OBJ_FROM_PTR(exc));
+            mp_obj_get_int_maybe(v, &ret); // get errno value
+            ret = -ret;
+        }
+    }
+    return ret;
+}
+
 #endif // MICROPY_VFS
diff --git a/extmod/vfs.h b/extmod/vfs.h
index 730dea043113a..23f2eac8932b4 100644
--- a/extmod/vfs.h
+++ b/extmod/vfs.h
@@ -31,25 +31,47 @@
 
 // return values of mp_vfs_lookup_path
 // ROOT is 0 so that the default current directory is the root directory
-#define MP_VFS_NONE ((mp_vfs_mount_t*)1)
-#define MP_VFS_ROOT ((mp_vfs_mount_t*)0)
+#define MP_VFS_NONE ((mp_vfs_mount_t *)1)
+#define MP_VFS_ROOT ((mp_vfs_mount_t *)0)
 
 // MicroPython's port-standardized versions of stat constants
 #define MP_S_IFDIR (0x4000)
 #define MP_S_IFREG (0x8000)
 
+// these are the values for mp_vfs_blockdev_t.flags
+#define MP_BLOCKDEV_FLAG_NATIVE         (0x0001) // readblocks[2]/writeblocks[2] contain native func
+#define MP_BLOCKDEV_FLAG_FREE_OBJ       (0x0002) // fs_user_mount_t obj should be freed on umount
+#define MP_BLOCKDEV_FLAG_HAVE_IOCTL     (0x0004) // new protocol with ioctl
+#define MP_BLOCKDEV_FLAG_NO_FILESYSTEM  (0x0008) // the block device has no filesystem on it
+
 // constants for block protocol ioctl
-#define BP_IOCTL_INIT           (1)
-#define BP_IOCTL_DEINIT         (2)
-#define BP_IOCTL_SYNC           (3)
-#define BP_IOCTL_SEC_COUNT      (4)
-#define BP_IOCTL_SEC_SIZE       (5)
+#define MP_BLOCKDEV_IOCTL_INIT          (1)
+#define MP_BLOCKDEV_IOCTL_DEINIT        (2)
+#define MP_BLOCKDEV_IOCTL_SYNC          (3)
+#define MP_BLOCKDEV_IOCTL_BLOCK_COUNT   (4)
+#define MP_BLOCKDEV_IOCTL_BLOCK_SIZE    (5)
+#define MP_BLOCKDEV_IOCTL_BLOCK_ERASE   (6)
 
 // At the moment the VFS protocol just has import_stat, but could be extended to other methods
 typedef struct _mp_vfs_proto_t {
     mp_import_stat_t (*import_stat)(void *self, const char *path);
 } mp_vfs_proto_t;
 
+typedef struct _mp_vfs_blockdev_t {
+    uint16_t flags;
+    size_t block_size;
+    mp_obj_t readblocks[5];
+    mp_obj_t writeblocks[5];
+    // new protocol uses just ioctl, old uses sync (optional) and count
+    union {
+        mp_obj_t ioctl[4];
+        struct {
+            mp_obj_t sync[2];
+            mp_obj_t count[2];
+        } old;
+    } u;
+} mp_vfs_blockdev_t;
+
 typedef struct _mp_vfs_mount_t {
     const char *str; // mount point with leading /
     size_t len;
@@ -57,6 +79,13 @@ typedef struct _mp_vfs_mount_t {
     struct _mp_vfs_mount_t *next;
 } mp_vfs_mount_t;
 
+void mp_vfs_blockdev_init(mp_vfs_blockdev_t *self, mp_obj_t bdev);
+int mp_vfs_blockdev_read(mp_vfs_blockdev_t *self, size_t block_num, size_t num_blocks, uint8_t *buf);
+int mp_vfs_blockdev_read_ext(mp_vfs_blockdev_t *self, size_t block_num, size_t block_off, size_t len, uint8_t *buf);
+int mp_vfs_blockdev_write(mp_vfs_blockdev_t *self, size_t block_num, size_t num_blocks, const uint8_t *buf);
+int mp_vfs_blockdev_write_ext(mp_vfs_blockdev_t *self, size_t block_num, size_t block_off, size_t len, const uint8_t *buf);
+mp_obj_t mp_vfs_blockdev_ioctl(mp_vfs_blockdev_t *self, uintptr_t cmd, uintptr_t arg);
+
 mp_vfs_mount_t *mp_vfs_lookup_path(const char *path, const char **path_out);
 mp_import_stat_t mp_vfs_import_stat(const char *path);
 mp_obj_t mp_vfs_mount(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
@@ -73,6 +102,8 @@ mp_obj_t mp_vfs_rmdir(mp_obj_t path_in);
 mp_obj_t mp_vfs_stat(mp_obj_t path_in);
 mp_obj_t mp_vfs_statvfs(mp_obj_t path_in);
 
+int mp_vfs_mount_and_chdir_protected(mp_obj_t bdev, mp_obj_t mount_point);
+
 MP_DECLARE_CONST_FUN_OBJ_KW(mp_vfs_mount_obj);
 MP_DECLARE_CONST_FUN_OBJ_1(mp_vfs_umount_obj);
 MP_DECLARE_CONST_FUN_OBJ_KW(mp_vfs_open_obj);
diff --git a/extmod/vfs_blockdev.c b/extmod/vfs_blockdev.c
new file mode 100644
index 0000000000000..57c83b42899a6
--- /dev/null
+++ b/extmod/vfs_blockdev.c
@@ -0,0 +1,143 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/binary.h"
+#include "py/objarray.h"
+#include "py/mperrno.h"
+#include "extmod/vfs.h"
+
+#if MICROPY_VFS
+
+void mp_vfs_blockdev_init(mp_vfs_blockdev_t *self, mp_obj_t bdev) {
+    mp_load_method(bdev, MP_QSTR_readblocks, self->readblocks);
+    mp_load_method_maybe(bdev, MP_QSTR_writeblocks, self->writeblocks);
+    mp_load_method_maybe(bdev, MP_QSTR_ioctl, self->u.ioctl);
+    if (self->u.ioctl[0] != MP_OBJ_NULL) {
+        // Device supports new block protocol, so indicate it
+        self->flags |= MP_BLOCKDEV_FLAG_HAVE_IOCTL;
+    } else {
+        // No ioctl method, so assume the device uses the old block protocol
+        mp_load_method_maybe(bdev, MP_QSTR_sync, self->u.old.sync);
+        mp_load_method(bdev, MP_QSTR_count, self->u.old.count);
+    }
+}
+
+int mp_vfs_blockdev_read(mp_vfs_blockdev_t *self, size_t block_num, size_t num_blocks, uint8_t *buf) {
+    if (self->flags & MP_BLOCKDEV_FLAG_NATIVE) {
+        mp_uint_t (*f)(uint8_t *, uint32_t, uint32_t) = (void *)(uintptr_t)self->readblocks[2];
+        return f(buf, block_num, num_blocks);
+    } else {
+        mp_obj_array_t ar = {{&mp_type_bytearray}, BYTEARRAY_TYPECODE, 0, num_blocks *self->block_size, buf};
+        self->readblocks[2] = MP_OBJ_NEW_SMALL_INT(block_num);
+        self->readblocks[3] = MP_OBJ_FROM_PTR(&ar);
+        mp_call_method_n_kw(2, 0, self->readblocks);
+        // TODO handle error return
+        return 0;
+    }
+}
+
+int mp_vfs_blockdev_read_ext(mp_vfs_blockdev_t *self, size_t block_num, size_t block_off, size_t len, uint8_t *buf) {
+    mp_obj_array_t ar = {{&mp_type_bytearray}, BYTEARRAY_TYPECODE, 0, len, buf};
+    self->readblocks[2] = MP_OBJ_NEW_SMALL_INT(block_num);
+    self->readblocks[3] = MP_OBJ_FROM_PTR(&ar);
+    self->readblocks[4] = MP_OBJ_NEW_SMALL_INT(block_off);
+    mp_obj_t ret = mp_call_method_n_kw(3, 0, self->readblocks);
+    if (ret == mp_const_none) {
+        return 0;
+    } else {
+        return MP_OBJ_SMALL_INT_VALUE(ret);
+    }
+}
+
+int mp_vfs_blockdev_write(mp_vfs_blockdev_t *self, size_t block_num, size_t num_blocks, const uint8_t *buf) {
+    if (self->writeblocks[0] == MP_OBJ_NULL) {
+        // read-only block device
+        return -MP_EROFS;
+    }
+
+    if (self->flags & MP_BLOCKDEV_FLAG_NATIVE) {
+        mp_uint_t (*f)(const uint8_t *, uint32_t, uint32_t) = (void *)(uintptr_t)self->writeblocks[2];
+        return f(buf, block_num, num_blocks);
+    } else {
+        mp_obj_array_t ar = {{&mp_type_bytearray}, BYTEARRAY_TYPECODE, 0, num_blocks *self->block_size, (void *)buf};
+        self->writeblocks[2] = MP_OBJ_NEW_SMALL_INT(block_num);
+        self->writeblocks[3] = MP_OBJ_FROM_PTR(&ar);
+        mp_call_method_n_kw(2, 0, self->writeblocks);
+        // TODO handle error return
+        return 0;
+    }
+}
+
+int mp_vfs_blockdev_write_ext(mp_vfs_blockdev_t *self, size_t block_num, size_t block_off, size_t len, const uint8_t *buf) {
+    if (self->writeblocks[0] == MP_OBJ_NULL) {
+        // read-only block device
+        return -MP_EROFS;
+    }
+
+    mp_obj_array_t ar = {{&mp_type_bytearray}, BYTEARRAY_TYPECODE, 0, len, (void *)buf};
+    self->writeblocks[2] = MP_OBJ_NEW_SMALL_INT(block_num);
+    self->writeblocks[3] = MP_OBJ_FROM_PTR(&ar);
+    self->writeblocks[4] = MP_OBJ_NEW_SMALL_INT(block_off);
+    mp_obj_t ret = mp_call_method_n_kw(3, 0, self->writeblocks);
+    if (ret == mp_const_none) {
+        return 0;
+    } else {
+        return MP_OBJ_SMALL_INT_VALUE(ret);
+    }
+}
+
+mp_obj_t mp_vfs_blockdev_ioctl(mp_vfs_blockdev_t *self, uintptr_t cmd, uintptr_t arg) {
+    if (self->flags & MP_BLOCKDEV_FLAG_HAVE_IOCTL) {
+        // New protocol with ioctl
+        self->u.ioctl[2] = MP_OBJ_NEW_SMALL_INT(cmd);
+        self->u.ioctl[3] = MP_OBJ_NEW_SMALL_INT(arg);
+        return mp_call_method_n_kw(2, 0, self->u.ioctl);
+    } else {
+        // Old protocol with sync and count
+        switch (cmd) {
+            case MP_BLOCKDEV_IOCTL_SYNC:
+                if (self->u.old.sync[0] != MP_OBJ_NULL) {
+                    mp_call_method_n_kw(0, 0, self->u.old.sync);
+                }
+                break;
+
+            case MP_BLOCKDEV_IOCTL_BLOCK_COUNT:
+                return mp_call_method_n_kw(0, 0, self->u.old.count);
+
+            case MP_BLOCKDEV_IOCTL_BLOCK_SIZE:
+                // Old protocol has fixed sector size of 512 bytes
+                break;
+
+            case MP_BLOCKDEV_IOCTL_INIT:
+                // Old protocol doesn't have init
+                break;
+        }
+        return mp_const_none;
+    }
+}
+
+#endif // MICROPY_VFS
diff --git a/extmod/vfs_fat.c b/extmod/vfs_fat.c
index ec7aaed388c69..e7af4057b7433 100644
--- a/extmod/vfs_fat.c
+++ b/extmod/vfs_fat.c
@@ -68,27 +68,18 @@ STATIC mp_obj_t fat_vfs_make_new(const mp_obj_type_t *type, size_t n_args, size_
     // create new object
     fs_user_mount_t *vfs = m_new_obj(fs_user_mount_t);
     vfs->base.type = type;
-    vfs->flags = FSUSER_FREE_OBJ;
     vfs->fatfs.drv = vfs;
 
-    // load block protocol methods
-    mp_load_method(args[0], MP_QSTR_readblocks, vfs->readblocks);
-    mp_load_method_maybe(args[0], MP_QSTR_writeblocks, vfs->writeblocks);
-    mp_load_method_maybe(args[0], MP_QSTR_ioctl, vfs->u.ioctl);
-    if (vfs->u.ioctl[0] != MP_OBJ_NULL) {
-        // device supports new block protocol, so indicate it
-        vfs->flags |= FSUSER_HAVE_IOCTL;
-    } else {
-        // no ioctl method, so assume the device uses the old block protocol
-        mp_load_method_maybe(args[0], MP_QSTR_sync, vfs->u.old.sync);
-        mp_load_method(args[0], MP_QSTR_count, vfs->u.old.count);
-    }
+    // Initialise underlying block device
+    vfs->blockdev.flags = MP_BLOCKDEV_FLAG_FREE_OBJ;
+    vfs->blockdev.block_size = FF_MIN_SS; // default, will be populated by call to MP_BLOCKDEV_IOCTL_BLOCK_SIZE
+    mp_vfs_blockdev_init(&vfs->blockdev, args[0]);
 
     // mount the block device so the VFS methods can be used
     FRESULT res = f_mount(&vfs->fatfs);
     if (res == FR_NO_FILESYSTEM) {
         // don't error out if no filesystem, to let mkfs()/mount() create one if wanted
-        vfs->flags |= FSUSER_NO_FILESYSTEM;
+        vfs->blockdev.flags |= MP_BLOCKDEV_FLAG_NO_FILESYSTEM;
     } else if (res != FR_OK) {
         mp_raise_OSError(fresult_to_errno_table[res]);
     }
@@ -151,7 +142,7 @@ STATIC mp_obj_t mp_vfs_fat_ilistdir_it_iternext(mp_obj_t self_in) {
         if (self->is_str) {
             t->items[0] = mp_obj_new_str(fn, strlen(fn));
         } else {
-            t->items[0] = mp_obj_new_bytes((const byte*)fn, strlen(fn));
+            t->items[0] = mp_obj_new_bytes((const byte *)fn, strlen(fn));
         }
         if (fno.fattrib & AM_DIR) {
             // dir
@@ -327,7 +318,7 @@ STATIC mp_obj_t fat_vfs_stat(mp_obj_t vfs_in, mp_obj_t path_in) {
         (fno.ftime >> 11) & 0x1f,
         (fno.ftime >> 5) & 0x3f,
         2 * (fno.ftime & 0x1f)
-    );
+        );
     t->items[0] = MP_OBJ_NEW_SMALL_INT(mode); // st_mode
     t->items[1] = MP_OBJ_NEW_SMALL_INT(0); // st_ino
     t->items[2] = MP_OBJ_NEW_SMALL_INT(0); // st_dev
@@ -380,11 +371,11 @@ STATIC mp_obj_t vfs_fat_mount(mp_obj_t self_in, mp_obj_t readonly, mp_obj_t mkfs
     //  1. readonly=True keyword argument
     //  2. nonexistent writeblocks method (then writeblocks[0] == MP_OBJ_NULL already)
     if (mp_obj_is_true(readonly)) {
-        self->writeblocks[0] = MP_OBJ_NULL;
+        self->blockdev.writeblocks[0] = MP_OBJ_NULL;
     }
 
     // check if we need to make the filesystem
-    FRESULT res = (self->flags & FSUSER_NO_FILESYSTEM) ? FR_NO_FILESYSTEM : FR_OK;
+    FRESULT res = (self->blockdev.flags & MP_BLOCKDEV_FLAG_NO_FILESYSTEM) ? FR_NO_FILESYSTEM : FR_OK;
     if (res == FR_NO_FILESYSTEM && mp_obj_is_true(mkfs)) {
         uint8_t working_buf[FF_MAX_SS];
         res = f_mkfs(&self->fatfs, FM_FAT | FM_SFD, 0, working_buf, sizeof(working_buf));
@@ -392,7 +383,7 @@ STATIC mp_obj_t vfs_fat_mount(mp_obj_t self_in, mp_obj_t readonly, mp_obj_t mkfs
     if (res != FR_OK) {
         mp_raise_OSError(fresult_to_errno_table[res]);
     }
-    self->flags &= ~FSUSER_NO_FILESYSTEM;
+    self->blockdev.flags &= ~MP_BLOCKDEV_FLAG_NO_FILESYSTEM;
 
     return mp_const_none;
 }
@@ -434,7 +425,7 @@ const mp_obj_type_t mp_fat_vfs_type = {
     .name = MP_QSTR_VfsFat,
     .make_new = fat_vfs_make_new,
     .protocol = &fat_vfs_proto,
-    .locals_dict = (mp_obj_dict_t*)&fat_vfs_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&fat_vfs_locals_dict,
 
 };
 
diff --git a/extmod/vfs_fat.h b/extmod/vfs_fat.h
index ba2915386fdb4..83685b5027b32 100644
--- a/extmod/vfs_fat.h
+++ b/extmod/vfs_fat.h
@@ -26,30 +26,13 @@
 #ifndef MICROPY_INCLUDED_EXTMOD_VFS_FAT_H
 #define MICROPY_INCLUDED_EXTMOD_VFS_FAT_H
 
-#include "py/lexer.h"
 #include "py/obj.h"
 #include "lib/oofatfs/ff.h"
 #include "extmod/vfs.h"
 
-// these are the values for fs_user_mount_t.flags
-#define FSUSER_NATIVE       (0x0001) // readblocks[2]/writeblocks[2] contain native func
-#define FSUSER_FREE_OBJ     (0x0002) // fs_user_mount_t obj should be freed on umount
-#define FSUSER_HAVE_IOCTL   (0x0004) // new protocol with ioctl
-#define FSUSER_NO_FILESYSTEM (0x0008) // the block device has no filesystem on it
-
 typedef struct _fs_user_mount_t {
     mp_obj_base_t base;
-    uint16_t flags;
-    mp_obj_t readblocks[4];
-    mp_obj_t writeblocks[4];
-    // new protocol uses just ioctl, old uses sync (optional) and count
-    union {
-        mp_obj_t ioctl[4];
-        struct {
-            mp_obj_t sync[2];
-            mp_obj_t count[2];
-        } old;
-    } u;
+    mp_vfs_blockdev_t blockdev;
     FATFS fatfs;
 } fs_user_mount_t;
 
diff --git a/extmod/vfs_fat_diskio.c b/extmod/vfs_fat_diskio.c
index e80d6124115f4..ae1bef57d5e07 100644
--- a/extmod/vfs_fat_diskio.c
+++ b/extmod/vfs_fat_diskio.c
@@ -38,19 +38,14 @@
 #include "py/runtime.h"
 #include "py/binary.h"
 #include "py/objarray.h"
+#include "py/mperrno.h"
 #include "lib/oofatfs/ff.h"
 #include "lib/oofatfs/diskio.h"
 #include "extmod/vfs_fat.h"
 
-#if FF_MAX_SS == FF_MIN_SS
-#define SECSIZE(fs) (FF_MIN_SS)
-#else
-#define SECSIZE(fs) ((fs)->ssize)
-#endif
-
 typedef void *bdev_t;
 STATIC fs_user_mount_t *disk_get_device(void *bdev) {
-    return (fs_user_mount_t*)bdev;
+    return (fs_user_mount_t *)bdev;
 }
 
 /*-----------------------------------------------------------------------*/
@@ -62,27 +57,15 @@ DRESULT disk_read (
     BYTE *buff,        /* Data buffer to store read data */
     DWORD sector,    /* Sector address (LBA) */
     UINT count        /* Number of sectors to read (1..128) */
-)
-{
+    ) {
     fs_user_mount_t *vfs = disk_get_device(pdrv);
     if (vfs == NULL) {
         return RES_PARERR;
     }
 
-    if (vfs->flags & FSUSER_NATIVE) {
-        mp_uint_t (*f)(uint8_t*, uint32_t, uint32_t) = (void*)(uintptr_t)vfs->readblocks[2];
-        if (f(buff, sector, count) != 0) {
-            return RES_ERROR;
-        }
-    } else {
-        mp_obj_array_t ar = {{&mp_type_bytearray}, BYTEARRAY_TYPECODE, 0, count * SECSIZE(&vfs->fatfs), buff};
-        vfs->readblocks[2] = MP_OBJ_NEW_SMALL_INT(sector);
-        vfs->readblocks[3] = MP_OBJ_FROM_PTR(&ar);
-        mp_call_method_n_kw(2, 0, vfs->readblocks);
-        // TODO handle error return
-    }
+    int ret = mp_vfs_blockdev_read(&vfs->blockdev, sector, count, buff);
 
-    return RES_OK;
+    return ret == 0 ? RES_OK : RES_ERROR;
 }
 
 /*-----------------------------------------------------------------------*/
@@ -94,32 +77,20 @@ DRESULT disk_write (
     const BYTE *buff,    /* Data to be written */
     DWORD sector,        /* Sector address (LBA) */
     UINT count            /* Number of sectors to write (1..128) */
-)
-{
+    ) {
     fs_user_mount_t *vfs = disk_get_device(pdrv);
     if (vfs == NULL) {
         return RES_PARERR;
     }
 
-    if (vfs->writeblocks[0] == MP_OBJ_NULL) {
+    int ret = mp_vfs_blockdev_write(&vfs->blockdev, sector, count, buff);
+
+    if (ret == -MP_EROFS) {
         // read-only block device
         return RES_WRPRT;
     }
 
-    if (vfs->flags & FSUSER_NATIVE) {
-        mp_uint_t (*f)(const uint8_t*, uint32_t, uint32_t) = (void*)(uintptr_t)vfs->writeblocks[2];
-        if (f(buff, sector, count) != 0) {
-            return RES_ERROR;
-        }
-    } else {
-        mp_obj_array_t ar = {{&mp_type_bytearray}, BYTEARRAY_TYPECODE, 0, count * SECSIZE(&vfs->fatfs), (void*)buff};
-        vfs->writeblocks[2] = MP_OBJ_NEW_SMALL_INT(sector);
-        vfs->writeblocks[3] = MP_OBJ_FROM_PTR(&ar);
-        mp_call_method_n_kw(2, 0, vfs->writeblocks);
-        // TODO handle error return
-    }
-
-    return RES_OK;
+    return ret == 0 ? RES_OK : RES_ERROR;
 }
 
 
@@ -131,50 +102,23 @@ DRESULT disk_ioctl (
     bdev_t pdrv,      /* Physical drive nmuber (0..) */
     BYTE cmd,        /* Control code */
     void *buff        /* Buffer to send/receive control data */
-)
-{
+    ) {
     fs_user_mount_t *vfs = disk_get_device(pdrv);
     if (vfs == NULL) {
         return RES_PARERR;
     }
 
     // First part: call the relevant method of the underlying block device
+    static const uint8_t op_map[8] = {
+        [CTRL_SYNC] = MP_BLOCKDEV_IOCTL_SYNC,
+        [GET_SECTOR_COUNT] = MP_BLOCKDEV_IOCTL_BLOCK_COUNT,
+        [GET_SECTOR_SIZE] = MP_BLOCKDEV_IOCTL_BLOCK_SIZE,
+        [IOCTL_INIT] = MP_BLOCKDEV_IOCTL_INIT,
+    };
+    uint8_t bp_op = op_map[cmd & 7];
     mp_obj_t ret = mp_const_none;
-    if (vfs->flags & FSUSER_HAVE_IOCTL) {
-        // new protocol with ioctl
-        static const uint8_t op_map[8] = {
-            [CTRL_SYNC] = BP_IOCTL_SYNC,
-            [GET_SECTOR_COUNT] = BP_IOCTL_SEC_COUNT,
-            [GET_SECTOR_SIZE] = BP_IOCTL_SEC_SIZE,
-            [IOCTL_INIT] = BP_IOCTL_INIT,
-        };
-        uint8_t bp_op = op_map[cmd & 7];
-        if (bp_op != 0) {
-            vfs->u.ioctl[2] = MP_OBJ_NEW_SMALL_INT(bp_op);
-            vfs->u.ioctl[3] = MP_OBJ_NEW_SMALL_INT(0); // unused
-            ret = mp_call_method_n_kw(2, 0, vfs->u.ioctl);
-        }
-    } else {
-        // old protocol with sync and count
-        switch (cmd) {
-            case CTRL_SYNC:
-                if (vfs->u.old.sync[0] != MP_OBJ_NULL) {
-                    mp_call_method_n_kw(0, 0, vfs->u.old.sync);
-                }
-                break;
-
-            case GET_SECTOR_COUNT:
-                ret = mp_call_method_n_kw(0, 0, vfs->u.old.count);
-                break;
-
-            case GET_SECTOR_SIZE:
-                // old protocol has fixed sector size of 512 bytes
-                break;
-
-            case IOCTL_INIT:
-                // old protocol doesn't have init
-                break;
-        }
+    if (bp_op != 0) {
+        ret = mp_vfs_blockdev_ioctl(&vfs->blockdev, bp_op, 0);
     }
 
     // Second part: convert the result for return
@@ -183,26 +127,24 @@ DRESULT disk_ioctl (
             return RES_OK;
 
         case GET_SECTOR_COUNT: {
-            *((DWORD*)buff) = mp_obj_get_int(ret);
+            *((DWORD *)buff) = mp_obj_get_int(ret);
             return RES_OK;
         }
 
         case GET_SECTOR_SIZE: {
             if (ret == mp_const_none) {
                 // Default sector size
-                *((WORD*)buff) = 512;
+                *((WORD *)buff) = 512;
             } else {
-                *((WORD*)buff) = mp_obj_get_int(ret);
+                *((WORD *)buff) = mp_obj_get_int(ret);
             }
-            #if FF_MAX_SS != FF_MIN_SS
             // need to store ssize because we use it in disk_read/disk_write
-            vfs->fatfs.ssize = *((WORD*)buff);
-            #endif
+            vfs->blockdev.block_size = *((WORD *)buff);
             return RES_OK;
         }
 
         case GET_BLOCK_SIZE:
-            *((DWORD*)buff) = 1; // erase block size in units of sector size
+            *((DWORD *)buff) = 1; // erase block size in units of sector size
             return RES_OK;
 
         case IOCTL_INIT:
@@ -211,12 +153,12 @@ DRESULT disk_ioctl (
             if (ret != mp_const_none && MP_OBJ_SMALL_INT_VALUE(ret) != 0) {
                 // error initialising
                 stat = STA_NOINIT;
-            } else if (vfs->writeblocks[0] == MP_OBJ_NULL) {
+            } else if (vfs->blockdev.writeblocks[0] == MP_OBJ_NULL) {
                 stat = STA_PROTECT;
             } else {
                 stat = 0;
             }
-            *((DSTATUS*)buff) = stat;
+            *((DSTATUS *)buff) = stat;
             return RES_OK;
         }
 
diff --git a/extmod/vfs_fat_file.c b/extmod/vfs_fat_file.c
index f7b9331b82e0a..537101d00f406 100644
--- a/extmod/vfs_fat_file.c
+++ b/extmod/vfs_fat_file.c
@@ -107,7 +107,7 @@ STATIC mp_uint_t file_obj_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg,
     pyb_file_obj_t *self = MP_OBJ_TO_PTR(o_in);
 
     if (request == MP_STREAM_SEEK) {
-        struct mp_stream_seek_t *s = (struct mp_stream_seek_t*)(uintptr_t)arg;
+        struct mp_stream_seek_t *s = (struct mp_stream_seek_t *)(uintptr_t)arg;
 
         switch (s->whence) {
             case 0: // SEEK_SET
@@ -154,9 +154,9 @@ STATIC mp_uint_t file_obj_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg,
 // Note: encoding is ignored for now; it's also not a valid kwarg for CPython's FileIO,
 // but by adding it here we can use one single mp_arg_t array for open() and FileIO's constructor
 STATIC const mp_arg_t file_open_args[] = {
-    { MP_QSTR_file, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+    { MP_QSTR_file, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_NONE} },
     { MP_QSTR_mode, MP_ARG_OBJ, {.u_obj = MP_OBJ_NEW_QSTR(MP_QSTR_r)} },
-    { MP_QSTR_encoding, MP_ARG_OBJ | MP_ARG_KW_ONLY, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+    { MP_QSTR_encoding, MP_ARG_OBJ | MP_ARG_KW_ONLY, {.u_rom_obj = MP_ROM_NONE} },
 };
 #define FILE_OPEN_NUM_ARGS MP_ARRAY_SIZE(file_open_args)
 
@@ -219,7 +219,7 @@ STATIC mp_obj_t file_obj_make_new(const mp_obj_type_t *type, size_t n_args, size
 
 // TODO gc hook to close the file if not already closed
 
-STATIC const mp_rom_map_elem_t rawfile_locals_dict_table[] = {
+STATIC const mp_rom_map_elem_t vfs_fat_rawfile_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
     { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
     { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
@@ -234,10 +234,10 @@ STATIC const mp_rom_map_elem_t rawfile_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&file_obj___exit___obj) },
 };
 
-STATIC MP_DEFINE_CONST_DICT(rawfile_locals_dict, rawfile_locals_dict_table);
+STATIC MP_DEFINE_CONST_DICT(vfs_fat_rawfile_locals_dict, vfs_fat_rawfile_locals_dict_table);
 
 #if MICROPY_PY_IO_FILEIO
-STATIC const mp_stream_p_t fileio_stream_p = {
+STATIC const mp_stream_p_t vfs_fat_fileio_stream_p = {
     .read = file_obj_read,
     .write = file_obj_write,
     .ioctl = file_obj_ioctl,
@@ -250,12 +250,12 @@ const mp_obj_type_t mp_type_vfs_fat_fileio = {
     .make_new = file_obj_make_new,
     .getiter = mp_identity_getiter,
     .iternext = mp_stream_unbuffered_iter,
-    .protocol = &fileio_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&rawfile_locals_dict,
+    .protocol = &vfs_fat_fileio_stream_p,
+    .locals_dict = (mp_obj_dict_t *)&vfs_fat_rawfile_locals_dict,
 };
 #endif
 
-STATIC const mp_stream_p_t textio_stream_p = {
+STATIC const mp_stream_p_t vfs_fat_textio_stream_p = {
     .read = file_obj_read,
     .write = file_obj_write,
     .ioctl = file_obj_ioctl,
@@ -269,8 +269,8 @@ const mp_obj_type_t mp_type_vfs_fat_textio = {
     .make_new = file_obj_make_new,
     .getiter = mp_identity_getiter,
     .iternext = mp_stream_unbuffered_iter,
-    .protocol = &textio_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&rawfile_locals_dict,
+    .protocol = &vfs_fat_textio_stream_p,
+    .locals_dict = (mp_obj_dict_t *)&vfs_fat_rawfile_locals_dict,
 };
 
 // Factory function for I/O stream classes
diff --git a/extmod/vfs_lfs.c b/extmod/vfs_lfs.c
new file mode 100644
index 0000000000000..90a1996f9ce4a
--- /dev/null
+++ b/extmod/vfs_lfs.c
@@ -0,0 +1,125 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "extmod/vfs.h"
+#include "extmod/vfs_lfs.h"
+
+#if MICROPY_VFS && (MICROPY_VFS_LFS1 || MICROPY_VFS_LFS2)
+
+enum { LFS_MAKE_ARG_bdev, LFS_MAKE_ARG_readsize, LFS_MAKE_ARG_progsize, LFS_MAKE_ARG_lookahead };
+
+static const mp_arg_t lfs_make_allowed_args[] = {
+    { MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
+    { MP_QSTR_readsize, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 32} },
+    { MP_QSTR_progsize, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 32} },
+    { MP_QSTR_lookahead, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 32} },
+};
+
+#if MICROPY_VFS_LFS1
+
+#include "lib/littlefs/lfs1.h"
+
+#define LFS_BUILD_VERSION (1)
+#define LFSx_MACRO(s) LFS1##s
+#define LFSx_API(s) lfs1_##s
+#define MP_VFS_LFSx(s) mp_vfs_lfs1_##s
+#define MP_OBJ_VFS_LFSx mp_obj_vfs_lfs1_t
+#define MP_OBJ_VFS_LFSx_FILE mp_obj_vfs_lfs1_file_t
+#define MP_TYPE_VFS_LFSx mp_type_vfs_lfs1
+#define MP_TYPE_VFS_LFSx_(s) mp_type_vfs_lfs1##s
+
+typedef struct _mp_obj_vfs_lfs1_t {
+    mp_obj_base_t base;
+    mp_vfs_blockdev_t blockdev;
+    vstr_t cur_dir;
+    struct lfs1_config config;
+    lfs1_t lfs;
+} mp_obj_vfs_lfs1_t;
+
+typedef struct _mp_obj_vfs_lfs1_file_t {
+    mp_obj_base_t base;
+    mp_obj_vfs_lfs1_t *vfs;
+    lfs1_file_t file;
+    struct lfs1_file_config cfg;
+    uint8_t file_buffer[0];
+} mp_obj_vfs_lfs1_file_t;
+
+const char *mp_vfs_lfs1_make_path(mp_obj_vfs_lfs1_t *self, mp_obj_t path_in);
+mp_obj_t mp_vfs_lfs1_file_open(mp_obj_t self_in, mp_obj_t path_in, mp_obj_t mode_in);
+
+#include "extmod/vfs_lfsx.c"
+#include "extmod/vfs_lfsx_file.c"
+
+#undef LFS_BUILD_VERSION
+#undef LFSx_MACRO
+#undef LFSx_API
+#undef MP_VFS_LFSx
+#undef MP_OBJ_VFS_LFSx
+#undef MP_OBJ_VFS_LFSx_FILE
+#undef MP_TYPE_VFS_LFSx
+#undef MP_TYPE_VFS_LFSx_
+
+#endif // MICROPY_VFS_LFS1
+
+#if MICROPY_VFS_LFS2
+
+#include "lib/littlefs/lfs2.h"
+
+#define LFS_BUILD_VERSION (2)
+#define LFSx_MACRO(s) LFS2##s
+#define LFSx_API(s) lfs2_##s
+#define MP_VFS_LFSx(s) mp_vfs_lfs2_##s
+#define MP_OBJ_VFS_LFSx mp_obj_vfs_lfs2_t
+#define MP_OBJ_VFS_LFSx_FILE mp_obj_vfs_lfs2_file_t
+#define MP_TYPE_VFS_LFSx mp_type_vfs_lfs2
+#define MP_TYPE_VFS_LFSx_(s) mp_type_vfs_lfs2##s
+
+typedef struct _mp_obj_vfs_lfs2_t {
+    mp_obj_base_t base;
+    mp_vfs_blockdev_t blockdev;
+    vstr_t cur_dir;
+    struct lfs2_config config;
+    lfs2_t lfs;
+} mp_obj_vfs_lfs2_t;
+
+typedef struct _mp_obj_vfs_lfs2_file_t {
+    mp_obj_base_t base;
+    mp_obj_vfs_lfs2_t *vfs;
+    lfs2_file_t file;
+    struct lfs2_file_config cfg;
+    uint8_t file_buffer[0];
+} mp_obj_vfs_lfs2_file_t;
+
+const char *mp_vfs_lfs2_make_path(mp_obj_vfs_lfs2_t *self, mp_obj_t path_in);
+mp_obj_t mp_vfs_lfs2_file_open(mp_obj_t self_in, mp_obj_t path_in, mp_obj_t mode_in);
+
+#include "extmod/vfs_lfsx.c"
+#include "extmod/vfs_lfsx_file.c"
+
+#endif // MICROPY_VFS_LFS2
+
+#endif // MICROPY_VFS && (MICROPY_VFS_LFS1 || MICROPY_VFS_LFS2)
diff --git a/ports/unix/fdfile.h b/extmod/vfs_lfs.h
similarity index 72%
rename from ports/unix/fdfile.h
rename to extmod/vfs_lfs.h
index 69a9b6be414db..1fdf792f1b3bc 100644
--- a/ports/unix/fdfile.h
+++ b/extmod/vfs_lfs.h
@@ -3,8 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
- * Copyright (c) 2016 Paul Sokolovsky
+ * Copyright (c) 2019 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,17 +23,17 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-#ifndef MICROPY_INCLUDED_UNIX_FDFILE_H
-#define MICROPY_INCLUDED_UNIX_FDFILE_H
+#ifndef MICROPY_INCLUDED_EXTMOD_VFS_LFS_H
+#define MICROPY_INCLUDED_EXTMOD_VFS_LFS_H
 
 #include "py/obj.h"
 
-typedef struct _mp_obj_fdfile_t {
-    mp_obj_base_t base;
-    int fd;
-} mp_obj_fdfile_t;
+extern const mp_obj_type_t mp_type_vfs_lfs1;
+extern const mp_obj_type_t mp_type_vfs_lfs1_fileio;
+extern const mp_obj_type_t mp_type_vfs_lfs1_textio;
 
-extern const mp_obj_type_t mp_type_fileio;
-extern const mp_obj_type_t mp_type_textio;
+extern const mp_obj_type_t mp_type_vfs_lfs2;
+extern const mp_obj_type_t mp_type_vfs_lfs2_fileio;
+extern const mp_obj_type_t mp_type_vfs_lfs2_textio;
 
-#endif // MICROPY_INCLUDED_UNIX_FDFILE_H
+#endif // MICROPY_INCLUDED_EXTMOD_VFS_LFS_H
diff --git a/extmod/vfs_lfsx.c b/extmod/vfs_lfsx.c
new file mode 100644
index 0000000000000..c6240967822aa
--- /dev/null
+++ b/extmod/vfs_lfsx.c
@@ -0,0 +1,471 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "py/runtime.h"
+#include "py/stream.h"
+#include "py/binary.h"
+#include "py/objarray.h"
+#include "py/objstr.h"
+#include "py/mperrno.h"
+#include "extmod/vfs.h"
+
+STATIC int MP_VFS_LFSx(dev_ioctl)(const struct LFSx_API (config) * c, int cmd, int arg, bool must_return_int) {
+    mp_obj_t ret = mp_vfs_blockdev_ioctl(c->context, cmd, arg);
+    int ret_i = 0;
+    if (must_return_int || ret != mp_const_none) {
+        ret_i = mp_obj_get_int(ret);
+    }
+    return ret_i;
+}
+
+STATIC int MP_VFS_LFSx(dev_read)(const struct LFSx_API (config) * c, LFSx_API(block_t) block, LFSx_API(off_t) off, void *buffer, LFSx_API(size_t) size) {
+    return mp_vfs_blockdev_read_ext(c->context, block, off, size, buffer);
+}
+
+STATIC int MP_VFS_LFSx(dev_prog)(const struct LFSx_API (config) * c, LFSx_API(block_t) block, LFSx_API(off_t) off, const void *buffer, LFSx_API(size_t) size) {
+    return mp_vfs_blockdev_write_ext(c->context, block, off, size, buffer);
+}
+
+STATIC int MP_VFS_LFSx(dev_erase)(const struct LFSx_API (config) * c, LFSx_API(block_t) block) {
+    return MP_VFS_LFSx(dev_ioctl)(c, MP_BLOCKDEV_IOCTL_BLOCK_ERASE, block, true);
+}
+
+STATIC int MP_VFS_LFSx(dev_sync)(const struct LFSx_API (config) * c) {
+    return MP_VFS_LFSx(dev_ioctl)(c, MP_BLOCKDEV_IOCTL_SYNC, 0, false);
+}
+
+STATIC void MP_VFS_LFSx(init_config)(MP_OBJ_VFS_LFSx * self, mp_obj_t bdev, size_t read_size, size_t prog_size, size_t lookahead) {
+    self->blockdev.flags = MP_BLOCKDEV_FLAG_FREE_OBJ;
+    mp_vfs_blockdev_init(&self->blockdev, bdev);
+
+    struct LFSx_API (config) * config = &self->config;
+    memset(config, 0, sizeof(*config));
+
+    config->context = &self->blockdev;
+
+    config->read = MP_VFS_LFSx(dev_read);
+    config->prog = MP_VFS_LFSx(dev_prog);
+    config->erase = MP_VFS_LFSx(dev_erase);
+    config->sync = MP_VFS_LFSx(dev_sync);
+
+    MP_VFS_LFSx(dev_ioctl)(config, MP_BLOCKDEV_IOCTL_INIT, 1, false); // initialise block device
+    int bs = MP_VFS_LFSx(dev_ioctl)(config, MP_BLOCKDEV_IOCTL_BLOCK_SIZE, 0, true); // get block size
+    int bc = MP_VFS_LFSx(dev_ioctl)(config, MP_BLOCKDEV_IOCTL_BLOCK_COUNT, 0, true); // get block count
+    self->blockdev.block_size = bs;
+
+    config->read_size = read_size;
+    config->prog_size = prog_size;
+    config->block_size = bs;
+    config->block_count = bc;
+
+    #if LFS_BUILD_VERSION == 1
+    config->lookahead = lookahead;
+    config->read_buffer = m_new(uint8_t, config->read_size);
+    config->prog_buffer = m_new(uint8_t, config->prog_size);
+    config->lookahead_buffer = m_new(uint8_t, config->lookahead / 8);
+    #else
+    config->block_cycles = 100;
+    config->cache_size = 4 * MAX(read_size, prog_size);
+    config->lookahead_size = lookahead;
+    config->read_buffer = m_new(uint8_t, config->cache_size);
+    config->prog_buffer = m_new(uint8_t, config->cache_size);
+    config->lookahead_buffer = m_new(uint8_t, config->lookahead_size);
+    #endif
+}
+
+const char *MP_VFS_LFSx(make_path)(MP_OBJ_VFS_LFSx * self, mp_obj_t path_in) {
+    const char *path = mp_obj_str_get_str(path_in);
+    if (path[0] != '/') {
+        size_t l = vstr_len(&self->cur_dir);
+        if (l > 0) {
+            vstr_add_str(&self->cur_dir, path);
+            path = vstr_null_terminated_str(&self->cur_dir);
+            self->cur_dir.len = l;
+        }
+    }
+    return path;
+}
+
+STATIC mp_obj_t MP_VFS_LFSx(make_new)(const mp_obj_type_t * type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    mp_arg_val_t args[MP_ARRAY_SIZE(lfs_make_allowed_args)];
+    mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(lfs_make_allowed_args), lfs_make_allowed_args, args);
+
+    MP_OBJ_VFS_LFSx *self = m_new0(MP_OBJ_VFS_LFSx, 1);
+    self->base.type = type;
+    vstr_init(&self->cur_dir, 16);
+    vstr_add_byte(&self->cur_dir, '/');
+    MP_VFS_LFSx(init_config)(self, args[LFS_MAKE_ARG_bdev].u_obj,
+        args[LFS_MAKE_ARG_readsize].u_int, args[LFS_MAKE_ARG_progsize].u_int, args[LFS_MAKE_ARG_lookahead].u_int);
+    int ret = LFSx_API(mount)(&self->lfs, &self->config);
+    if (ret < 0) {
+        mp_raise_OSError(-ret);
+    }
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC mp_obj_t MP_VFS_LFSx(mkfs)(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    mp_arg_val_t args[MP_ARRAY_SIZE(lfs_make_allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(lfs_make_allowed_args), lfs_make_allowed_args, args);
+
+    MP_OBJ_VFS_LFSx self;
+    MP_VFS_LFSx(init_config)(&self, args[LFS_MAKE_ARG_bdev].u_obj,
+        args[LFS_MAKE_ARG_readsize].u_int, args[LFS_MAKE_ARG_progsize].u_int, args[LFS_MAKE_ARG_lookahead].u_int);
+    int ret = LFSx_API(format)(&self.lfs, &self.config);
+    if (ret < 0) {
+        mp_raise_OSError(-ret);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(MP_VFS_LFSx(mkfs_fun_obj), 0, MP_VFS_LFSx(mkfs));
+STATIC MP_DEFINE_CONST_STATICMETHOD_OBJ(MP_VFS_LFSx(mkfs_obj), MP_ROM_PTR(&MP_VFS_LFSx(mkfs_fun_obj)));
+
+// Implementation of mp_vfs_lfs_file_open is provided in vfs_lfsx_file.c
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(MP_VFS_LFSx(open_obj), MP_VFS_LFSx(file_open));
+
+typedef struct MP_VFS_LFSx (_ilistdir_it_t) {
+    mp_obj_base_t base;
+    mp_fun_1_t iternext;
+    bool is_str;
+    MP_OBJ_VFS_LFSx *vfs;
+    LFSx_API(dir_t) dir;
+} MP_VFS_LFSx(ilistdir_it_t);
+
+STATIC mp_obj_t MP_VFS_LFSx(ilistdir_it_iternext)(mp_obj_t self_in) {
+    MP_VFS_LFSx(ilistdir_it_t) * self = MP_OBJ_TO_PTR(self_in);
+
+    struct LFSx_API (info) info;
+    for (;;) {
+        int ret = LFSx_API(dir_read)(&self->vfs->lfs, &self->dir, &info);
+        if (ret == 0) {
+            LFSx_API(dir_close)(&self->vfs->lfs, &self->dir);
+            return MP_OBJ_STOP_ITERATION;
+        }
+        if (!(info.name[0] == '.' && (info.name[1] == '\0'
+                                      || (info.name[1] == '.' && info.name[2] == '\0')))) {
+            break;
+        }
+    }
+
+    // make 4-tuple with info about this entry
+    mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(4, NULL));
+    if (self->is_str) {
+        t->items[0] = mp_obj_new_str(info.name, strlen(info.name));
+    } else {
+        t->items[0] = mp_obj_new_bytes((const byte *)info.name, strlen(info.name));
+    }
+    t->items[1] = MP_OBJ_NEW_SMALL_INT(info.type == LFSx_MACRO(_TYPE_REG) ? MP_S_IFREG : MP_S_IFDIR);
+    t->items[2] = MP_OBJ_NEW_SMALL_INT(0); // no inode number
+    t->items[3] = MP_OBJ_NEW_SMALL_INT(info.size);
+
+    return MP_OBJ_FROM_PTR(t);
+}
+
+STATIC mp_obj_t MP_VFS_LFSx(ilistdir_func)(size_t n_args, const mp_obj_t *args) {
+    MP_OBJ_VFS_LFSx *self = MP_OBJ_TO_PTR(args[0]);
+    bool is_str_type = true;
+    const char *path;
+    if (n_args == 2) {
+        if (mp_obj_get_type(args[1]) == &mp_type_bytes) {
+            is_str_type = false;
+        }
+        path = MP_VFS_LFSx(make_path)(self, args[1]);
+    } else {
+        path = vstr_null_terminated_str(&self->cur_dir);
+    }
+
+    MP_VFS_LFSx(ilistdir_it_t) * iter = m_new_obj(MP_VFS_LFSx(ilistdir_it_t));
+    iter->base.type = &mp_type_polymorph_iter;
+    iter->iternext = MP_VFS_LFSx(ilistdir_it_iternext);
+    iter->is_str = is_str_type;
+    iter->vfs = self;
+    int ret = LFSx_API(dir_open)(&self->lfs, &iter->dir, path);
+    if (ret < 0) {
+        mp_raise_OSError(-ret);
+    }
+    return MP_OBJ_FROM_PTR(iter);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(MP_VFS_LFSx(ilistdir_obj), 1, 2, MP_VFS_LFSx(ilistdir_func));
+
+STATIC mp_obj_t MP_VFS_LFSx(remove)(mp_obj_t self_in, mp_obj_t path_in) {
+    MP_OBJ_VFS_LFSx *self = MP_OBJ_TO_PTR(self_in);
+    const char *path = MP_VFS_LFSx(make_path)(self, path_in);
+    int ret = LFSx_API(remove)(&self->lfs, path);
+    if (ret < 0) {
+        mp_raise_OSError(-ret);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(MP_VFS_LFSx(remove_obj), MP_VFS_LFSx(remove));
+
+STATIC mp_obj_t MP_VFS_LFSx(rmdir)(mp_obj_t self_in, mp_obj_t path_in) {
+    MP_OBJ_VFS_LFSx *self = MP_OBJ_TO_PTR(self_in);
+    const char *path = MP_VFS_LFSx(make_path)(self, path_in);
+    int ret = LFSx_API(remove)(&self->lfs, path);
+    if (ret < 0) {
+        mp_raise_OSError(-ret);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(MP_VFS_LFSx(rmdir_obj), MP_VFS_LFSx(rmdir));
+
+STATIC mp_obj_t MP_VFS_LFSx(rename)(mp_obj_t self_in, mp_obj_t path_old_in, mp_obj_t path_new_in) {
+    MP_OBJ_VFS_LFSx *self = MP_OBJ_TO_PTR(self_in);
+    const char *path_old = MP_VFS_LFSx(make_path)(self, path_old_in);
+    const char *path = mp_obj_str_get_str(path_new_in);
+    vstr_t path_new;
+    vstr_init(&path_new, vstr_len(&self->cur_dir));
+    if (path[0] != '/') {
+        vstr_add_strn(&path_new, vstr_str(&self->cur_dir), vstr_len(&self->cur_dir));
+    }
+    vstr_add_str(&path_new, path);
+    int ret = LFSx_API(rename)(&self->lfs, path_old, vstr_null_terminated_str(&path_new));
+    vstr_clear(&path_new);
+    if (ret < 0) {
+        mp_raise_OSError(-ret);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(MP_VFS_LFSx(rename_obj), MP_VFS_LFSx(rename));
+
+STATIC mp_obj_t MP_VFS_LFSx(mkdir)(mp_obj_t self_in, mp_obj_t path_o) {
+    MP_OBJ_VFS_LFSx *self = MP_OBJ_TO_PTR(self_in);
+    const char *path = MP_VFS_LFSx(make_path)(self, path_o);
+    int ret = LFSx_API(mkdir)(&self->lfs, path);
+    if (ret < 0) {
+        mp_raise_OSError(-ret);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(MP_VFS_LFSx(mkdir_obj), MP_VFS_LFSx(mkdir));
+
+STATIC mp_obj_t MP_VFS_LFSx(chdir)(mp_obj_t self_in, mp_obj_t path_in) {
+    MP_OBJ_VFS_LFSx *self = MP_OBJ_TO_PTR(self_in);
+
+    // Check path exists
+    const char *path = MP_VFS_LFSx(make_path)(self, path_in);
+    if (path[1] != '\0') {
+        // Not at root, check it exists
+        struct LFSx_API (info) info;
+        int ret = LFSx_API(stat)(&self->lfs, path, &info);
+        if (ret < 0 || info.type != LFSx_MACRO(_TYPE_DIR)) {
+            mp_raise_OSError(-MP_ENOENT);
+        }
+    }
+
+    // Update cur_dir with new path
+    if (path == vstr_str(&self->cur_dir)) {
+        self->cur_dir.len = strlen(path);
+    } else {
+        vstr_reset(&self->cur_dir);
+        vstr_add_str(&self->cur_dir, path);
+    }
+
+    // If not at root add trailing / to make it easy to build paths
+    // and then normalise the path
+    if (vstr_len(&self->cur_dir) != 1) {
+        vstr_add_byte(&self->cur_dir, '/');
+
+        #define CWD_LEN (vstr_len(&self->cur_dir))
+        size_t to = 1;
+        size_t from = 1;
+        char *cwd = vstr_str(&self->cur_dir);
+        while (from < CWD_LEN) {
+            for (; cwd[from] == '/' && from < CWD_LEN; ++from) {
+                // Scan for the start
+            }
+            if (from > to) {
+                // Found excessive slash chars, squeeze them out
+                vstr_cut_out_bytes(&self->cur_dir, to, from - to);
+                from = to;
+            }
+            for (; cwd[from] != '/' && from < CWD_LEN; ++from) {
+                // Scan for the next /
+            }
+            if ((from - to) == 1 && cwd[to] == '.') {
+                // './', ignore
+                vstr_cut_out_bytes(&self->cur_dir, to, ++from - to);
+                from = to;
+            } else if ((from - to) == 2 && cwd[to] == '.' && cwd[to + 1] == '.') {
+                // '../', skip back
+                if (to > 1) {
+                    // Only skip back if not at the tip
+                    for (--to; to > 1 && cwd[to - 1] != '/'; --to) {
+                        // Skip back
+                    }
+                }
+                vstr_cut_out_bytes(&self->cur_dir, to, ++from - to);
+                from = to;
+            } else {
+                // Normal element, keep it and just move the offset
+                to = ++from;
+            }
+        }
+    }
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(MP_VFS_LFSx(chdir_obj), MP_VFS_LFSx(chdir));
+
+STATIC mp_obj_t MP_VFS_LFSx(getcwd)(mp_obj_t self_in) {
+    MP_OBJ_VFS_LFSx *self = MP_OBJ_TO_PTR(self_in);
+    if (vstr_len(&self->cur_dir) == 1) {
+        return MP_OBJ_NEW_QSTR(MP_QSTR__slash_);
+    } else {
+        // don't include trailing /
+        return mp_obj_new_str(self->cur_dir.buf, self->cur_dir.len - 1);
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(MP_VFS_LFSx(getcwd_obj), MP_VFS_LFSx(getcwd));
+
+STATIC mp_obj_t MP_VFS_LFSx(stat)(mp_obj_t self_in, mp_obj_t path_in) {
+    MP_OBJ_VFS_LFSx *self = MP_OBJ_TO_PTR(self_in);
+    const char *path = MP_VFS_LFSx(make_path)(self, path_in);
+    struct LFSx_API (info) info;
+    int ret = LFSx_API(stat)(&self->lfs, path, &info);
+    if (ret < 0) {
+        mp_raise_OSError(-ret);
+    }
+
+    mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
+    t->items[0] = MP_OBJ_NEW_SMALL_INT(info.type == LFSx_MACRO(_TYPE_REG) ? MP_S_IFREG : MP_S_IFDIR); // st_mode
+    t->items[1] = MP_OBJ_NEW_SMALL_INT(0); // st_ino
+    t->items[2] = MP_OBJ_NEW_SMALL_INT(0); // st_dev
+    t->items[3] = MP_OBJ_NEW_SMALL_INT(0); // st_nlink
+    t->items[4] = MP_OBJ_NEW_SMALL_INT(0); // st_uid
+    t->items[5] = MP_OBJ_NEW_SMALL_INT(0); // st_gid
+    t->items[6] = mp_obj_new_int_from_uint(info.size); // st_size
+    t->items[7] = MP_OBJ_NEW_SMALL_INT(0); // st_atime
+    t->items[8] = MP_OBJ_NEW_SMALL_INT(0); // st_mtime
+    t->items[9] = MP_OBJ_NEW_SMALL_INT(0); // st_ctime
+
+    return MP_OBJ_FROM_PTR(t);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(MP_VFS_LFSx(stat_obj), MP_VFS_LFSx(stat));
+
+STATIC int LFSx_API(traverse_cb)(void *data, LFSx_API(block_t) bl) {
+    (void)bl;
+    uint32_t *n = (uint32_t *)data;
+    *n += 1;
+    return LFSx_MACRO(_ERR_OK);
+}
+
+STATIC mp_obj_t MP_VFS_LFSx(statvfs)(mp_obj_t self_in, mp_obj_t path_in) {
+    (void)path_in;
+    MP_OBJ_VFS_LFSx *self = MP_OBJ_TO_PTR(self_in);
+    uint32_t n_used_blocks = 0;
+    #if LFS_BUILD_VERSION == 1
+    int ret = LFSx_API(traverse)(&self->lfs, LFSx_API(traverse_cb), &n_used_blocks);
+    #else
+    int ret = LFSx_API(fs_traverse)(&self->lfs, LFSx_API(traverse_cb), &n_used_blocks);
+    #endif
+    if (ret < 0) {
+        mp_raise_OSError(-ret);
+    }
+
+    mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
+    t->items[0] = MP_OBJ_NEW_SMALL_INT(self->lfs.cfg->block_size); // f_bsize
+    t->items[1] = t->items[0]; // f_frsize
+    t->items[2] = MP_OBJ_NEW_SMALL_INT(self->lfs.cfg->block_count); // f_blocks
+    t->items[3] = MP_OBJ_NEW_SMALL_INT(self->lfs.cfg->block_count - n_used_blocks); // f_bfree
+    t->items[4] = t->items[3]; // f_bavail
+    t->items[5] = MP_OBJ_NEW_SMALL_INT(0); // f_files
+    t->items[6] = MP_OBJ_NEW_SMALL_INT(0); // f_ffree
+    t->items[7] = MP_OBJ_NEW_SMALL_INT(0); // f_favail
+    t->items[8] = MP_OBJ_NEW_SMALL_INT(0); // f_flags
+    t->items[9] = MP_OBJ_NEW_SMALL_INT(LFSx_MACRO(_NAME_MAX)); // f_namemax
+
+    return MP_OBJ_FROM_PTR(t);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(MP_VFS_LFSx(statvfs_obj), MP_VFS_LFSx(statvfs));
+
+STATIC mp_obj_t MP_VFS_LFSx(mount)(mp_obj_t self_in, mp_obj_t readonly, mp_obj_t mkfs) {
+    (void)self_in;
+    (void)readonly;
+    (void)mkfs;
+    // already called LFSx_API(mount) in MP_VFS_LFSx(make_new)
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(MP_VFS_LFSx(mount_obj), MP_VFS_LFSx(mount));
+
+STATIC mp_obj_t MP_VFS_LFSx(umount)(mp_obj_t self_in) {
+    MP_OBJ_VFS_LFSx *self = MP_OBJ_TO_PTR(self_in);
+    // LFS unmount never fails
+    LFSx_API(unmount)(&self->lfs);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(MP_VFS_LFSx(umount_obj), MP_VFS_LFSx(umount));
+
+STATIC const mp_rom_map_elem_t MP_VFS_LFSx(locals_dict_table)[] = {
+    { MP_ROM_QSTR(MP_QSTR_mkfs), MP_ROM_PTR(&MP_VFS_LFSx(mkfs_obj)) },
+    { MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&MP_VFS_LFSx(open_obj)) },
+    { MP_ROM_QSTR(MP_QSTR_ilistdir), MP_ROM_PTR(&MP_VFS_LFSx(ilistdir_obj)) },
+    { MP_ROM_QSTR(MP_QSTR_mkdir), MP_ROM_PTR(&MP_VFS_LFSx(mkdir_obj)) },
+    { MP_ROM_QSTR(MP_QSTR_rmdir), MP_ROM_PTR(&MP_VFS_LFSx(rmdir_obj)) },
+    { MP_ROM_QSTR(MP_QSTR_chdir), MP_ROM_PTR(&MP_VFS_LFSx(chdir_obj)) },
+    { MP_ROM_QSTR(MP_QSTR_getcwd), MP_ROM_PTR(&MP_VFS_LFSx(getcwd_obj)) },
+    { MP_ROM_QSTR(MP_QSTR_remove), MP_ROM_PTR(&MP_VFS_LFSx(remove_obj)) },
+    { MP_ROM_QSTR(MP_QSTR_rename), MP_ROM_PTR(&MP_VFS_LFSx(rename_obj)) },
+    { MP_ROM_QSTR(MP_QSTR_stat), MP_ROM_PTR(&MP_VFS_LFSx(stat_obj)) },
+    { MP_ROM_QSTR(MP_QSTR_statvfs), MP_ROM_PTR(&MP_VFS_LFSx(statvfs_obj)) },
+    { MP_ROM_QSTR(MP_QSTR_mount), MP_ROM_PTR(&MP_VFS_LFSx(mount_obj)) },
+    { MP_ROM_QSTR(MP_QSTR_umount), MP_ROM_PTR(&MP_VFS_LFSx(umount_obj)) },
+};
+STATIC MP_DEFINE_CONST_DICT(MP_VFS_LFSx(locals_dict), MP_VFS_LFSx(locals_dict_table));
+
+STATIC mp_import_stat_t MP_VFS_LFSx(import_stat)(void *self_in, const char *path) {
+    MP_OBJ_VFS_LFSx *self = self_in;
+    struct LFSx_API (info) info;
+    mp_obj_str_t path_obj = { { &mp_type_str }, 0, 0, (const byte *)path };
+    path = MP_VFS_LFSx(make_path)(self, &path_obj);
+    int ret = LFSx_API(stat)(&self->lfs, path, &info);
+    if (ret == 0) {
+        if (info.type == LFSx_MACRO(_TYPE_REG)) {
+            return MP_IMPORT_STAT_FILE;
+        } else {
+            return MP_IMPORT_STAT_DIR;
+        }
+    }
+    return MP_IMPORT_STAT_NO_EXIST;
+}
+
+STATIC const mp_vfs_proto_t MP_VFS_LFSx(proto) = {
+    .import_stat = MP_VFS_LFSx(import_stat),
+};
+
+const mp_obj_type_t MP_TYPE_VFS_LFSx = {
+    { &mp_type_type },
+    #if LFS_BUILD_VERSION == 1
+    .name = MP_QSTR_VfsLfs1,
+    #else
+    .name = MP_QSTR_VfsLfs2,
+    #endif
+    .make_new = MP_VFS_LFSx(make_new),
+    .protocol = &MP_VFS_LFSx(proto),
+    .locals_dict = (mp_obj_dict_t *)&MP_VFS_LFSx(locals_dict),
+};
diff --git a/extmod/vfs_lfsx_file.c b/extmod/vfs_lfsx_file.c
new file mode 100644
index 0000000000000..f74b41837d32d
--- /dev/null
+++ b/extmod/vfs_lfsx_file.c
@@ -0,0 +1,236 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "py/runtime.h"
+#include "py/stream.h"
+#include "py/mperrno.h"
+#include "extmod/vfs.h"
+
+STATIC void MP_VFS_LFSx(check_open)(MP_OBJ_VFS_LFSx_FILE * self) {
+    if (self->vfs == NULL) {
+        mp_raise_ValueError(NULL);
+    }
+}
+
+STATIC void MP_VFS_LFSx(file_print)(const mp_print_t * print, mp_obj_t self_in, mp_print_kind_t kind) {
+    (void)self_in;
+    (void)kind;
+    mp_printf(print, "<io.%s>", mp_obj_get_type_str(self_in));
+}
+
+mp_obj_t MP_VFS_LFSx(file_open)(mp_obj_t self_in, mp_obj_t path_in, mp_obj_t mode_in) {
+    MP_OBJ_VFS_LFSx *self = MP_OBJ_TO_PTR(self_in);
+
+    int flags = 0;
+    const mp_obj_type_t *type = &MP_TYPE_VFS_LFSx_(_textio);
+    const char *mode_str = mp_obj_str_get_str(mode_in);
+    for (; *mode_str; ++mode_str) {
+        int new_flags = 0;
+        switch (*mode_str) {
+            case 'r':
+                new_flags = LFSx_MACRO(_O_RDONLY);
+                break;
+            case 'w':
+                new_flags = LFSx_MACRO(_O_WRONLY) | LFSx_MACRO(_O_CREAT) | LFSx_MACRO(_O_TRUNC);
+                break;
+            case 'x':
+                new_flags = LFSx_MACRO(_O_WRONLY) | LFSx_MACRO(_O_CREAT) | LFSx_MACRO(_O_EXCL);
+                break;
+            case 'a':
+                new_flags = LFSx_MACRO(_O_WRONLY) | LFSx_MACRO(_O_CREAT) | LFSx_MACRO(_O_APPEND);
+                break;
+            case '+':
+                flags |= LFSx_MACRO(_O_RDWR);
+                break;
+            #if MICROPY_PY_IO_FILEIO
+            case 'b':
+                type = &MP_TYPE_VFS_LFSx_(_fileio);
+                break;
+            #endif
+            case 't':
+                type = &MP_TYPE_VFS_LFSx_(_textio);
+                break;
+        }
+        if (new_flags) {
+            if (flags) {
+                mp_raise_ValueError(NULL);
+            }
+            flags = new_flags;
+        }
+    }
+    if (flags == 0) {
+        flags = LFSx_MACRO(_O_RDONLY);
+    }
+
+    #if LFS_BUILD_VERSION == 1
+    MP_OBJ_VFS_LFSx_FILE *o = m_new_obj_var_with_finaliser(MP_OBJ_VFS_LFSx_FILE, uint8_t, self->lfs.cfg->prog_size);
+    #else
+    MP_OBJ_VFS_LFSx_FILE *o = m_new_obj_var_with_finaliser(MP_OBJ_VFS_LFSx_FILE, uint8_t, self->lfs.cfg->cache_size);
+    #endif
+    o->base.type = type;
+    o->vfs = self;
+    #if !MICROPY_GC_CONSERVATIVE_CLEAR
+    memset(&o->file, 0, sizeof(o->file));
+    memset(&o->cfg, 0, sizeof(o->cfg));
+    #endif
+    o->cfg.buffer = &o->file_buffer[0];
+
+    const char *path = MP_VFS_LFSx(make_path)(self, path_in);
+    int ret = LFSx_API(file_opencfg)(&self->lfs, &o->file, path, flags, &o->cfg);
+    if (ret < 0) {
+        o->vfs = NULL;
+        mp_raise_OSError(-ret);
+    }
+
+    return MP_OBJ_FROM_PTR(o);
+}
+
+STATIC mp_obj_t MP_VFS_LFSx(file___exit__)(size_t n_args, const mp_obj_t *args) {
+    (void)n_args;
+    return mp_stream_close(args[0]);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(MP_VFS_LFSx(file___exit___obj), 4, 4, MP_VFS_LFSx(file___exit__));
+
+STATIC mp_uint_t MP_VFS_LFSx(file_read)(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode) {
+    MP_OBJ_VFS_LFSx_FILE *self = MP_OBJ_TO_PTR(self_in);
+    MP_VFS_LFSx(check_open)(self);
+    LFSx_API(ssize_t) sz = LFSx_API(file_read)(&self->vfs->lfs, &self->file, buf, size);
+    if (sz < 0) {
+        *errcode = -sz;
+        return MP_STREAM_ERROR;
+    }
+    return sz;
+}
+
+STATIC mp_uint_t MP_VFS_LFSx(file_write)(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode) {
+    MP_OBJ_VFS_LFSx_FILE *self = MP_OBJ_TO_PTR(self_in);
+    MP_VFS_LFSx(check_open)(self);
+    LFSx_API(ssize_t) sz = LFSx_API(file_write)(&self->vfs->lfs, &self->file, buf, size);
+    if (sz < 0) {
+        *errcode = -sz;
+        return MP_STREAM_ERROR;
+    }
+    return sz;
+}
+
+STATIC mp_uint_t MP_VFS_LFSx(file_ioctl)(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    MP_OBJ_VFS_LFSx_FILE *self = MP_OBJ_TO_PTR(self_in);
+
+    if (request != MP_STREAM_CLOSE) {
+        MP_VFS_LFSx(check_open)(self);
+    }
+
+    if (request == MP_STREAM_SEEK) {
+        struct mp_stream_seek_t *s = (struct mp_stream_seek_t *)(uintptr_t)arg;
+        int res = LFSx_API(file_seek)(&self->vfs->lfs, &self->file, s->offset, s->whence);
+        if (res < 0) {
+            *errcode = -res;
+            return MP_STREAM_ERROR;
+        }
+        res = LFSx_API(file_tell)(&self->vfs->lfs, &self->file);
+        if (res < 0) {
+            *errcode = -res;
+            return MP_STREAM_ERROR;
+        }
+        s->offset = res;
+        return 0;
+    } else if (request == MP_STREAM_FLUSH) {
+        int res = LFSx_API(file_sync)(&self->vfs->lfs, &self->file);
+        if (res < 0) {
+            *errcode = -res;
+            return MP_STREAM_ERROR;
+        }
+        return 0;
+    } else if (request == MP_STREAM_CLOSE) {
+        if (self->vfs == NULL) {
+            return 0;
+        }
+        int res = LFSx_API(file_close)(&self->vfs->lfs, &self->file);
+        self->vfs = NULL; // indicate a closed file
+        if (res < 0) {
+            *errcode = -res;
+            return MP_STREAM_ERROR;
+        }
+        return 0;
+    } else {
+        *errcode = MP_EINVAL;
+        return MP_STREAM_ERROR;
+    }
+}
+
+STATIC const mp_rom_map_elem_t MP_VFS_LFSx(file_locals_dict_table)[] = {
+    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readlines), MP_ROM_PTR(&mp_stream_unbuffered_readlines_obj) },
+    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
+    { MP_ROM_QSTR(MP_QSTR_flush), MP_ROM_PTR(&mp_stream_flush_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR_seek), MP_ROM_PTR(&mp_stream_seek_obj) },
+    { MP_ROM_QSTR(MP_QSTR_tell), MP_ROM_PTR(&mp_stream_tell_obj) },
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
+    { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&mp_identity_obj) },
+    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&MP_VFS_LFSx(file___exit___obj)) },
+};
+STATIC MP_DEFINE_CONST_DICT(MP_VFS_LFSx(file_locals_dict), MP_VFS_LFSx(file_locals_dict_table));
+
+#if MICROPY_PY_IO_FILEIO
+STATIC const mp_stream_p_t MP_VFS_LFSx(fileio_stream_p) = {
+    .read = MP_VFS_LFSx(file_read),
+    .write = MP_VFS_LFSx(file_write),
+    .ioctl = MP_VFS_LFSx(file_ioctl),
+};
+
+const mp_obj_type_t MP_TYPE_VFS_LFSx_(_fileio) = {
+    { &mp_type_type },
+    .name = MP_QSTR_FileIO,
+    .print = MP_VFS_LFSx(file_print),
+    .getiter = mp_identity_getiter,
+    .iternext = mp_stream_unbuffered_iter,
+    .protocol = &MP_VFS_LFSx(fileio_stream_p),
+    .locals_dict = (mp_obj_dict_t *)&MP_VFS_LFSx(file_locals_dict),
+};
+#endif
+
+STATIC const mp_stream_p_t MP_VFS_LFSx(textio_stream_p) = {
+    .read = MP_VFS_LFSx(file_read),
+    .write = MP_VFS_LFSx(file_write),
+    .ioctl = MP_VFS_LFSx(file_ioctl),
+    .is_text = true,
+};
+
+const mp_obj_type_t MP_TYPE_VFS_LFSx_(_textio) = {
+    { &mp_type_type },
+    .name = MP_QSTR_TextIOWrapper,
+    .print = MP_VFS_LFSx(file_print),
+    .getiter = mp_identity_getiter,
+    .iternext = mp_stream_unbuffered_iter,
+    .protocol = &MP_VFS_LFSx(textio_stream_p),
+    .locals_dict = (mp_obj_dict_t *)&MP_VFS_LFSx(file_locals_dict),
+};
diff --git a/extmod/vfs_posix.c b/extmod/vfs_posix.c
index 4ef761956c9de..f14f56e81ec82 100644
--- a/extmod/vfs_posix.c
+++ b/extmod/vfs_posix.c
@@ -26,11 +26,14 @@
 
 #include "py/runtime.h"
 #include "py/mperrno.h"
+#include "py/mphal.h"
+#include "py/mpthread.h"
 #include "extmod/vfs.h"
 #include "extmod/vfs_posix.h"
 
 #if MICROPY_VFS_POSIX
 
+#include <stdio.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <dirent.h>
@@ -62,7 +65,7 @@ STATIC mp_obj_t vfs_posix_get_path_obj(mp_obj_vfs_posix_t *self, mp_obj_t path)
     }
 }
 
-STATIC mp_obj_t vfs_posix_fun1_helper(mp_obj_t self_in, mp_obj_t path_in, int (*f)(const char*)) {
+STATIC mp_obj_t vfs_posix_fun1_helper(mp_obj_t self_in, mp_obj_t path_in, int (*f)(const char *)) {
     mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
     int ret = f(vfs_posix_get_path_str(self, path_in));
     if (ret != 0) {
@@ -169,12 +172,15 @@ STATIC mp_obj_t vfs_posix_ilistdir_it_iternext(mp_obj_t self_in) {
     }
 
     for (;;) {
+        MP_THREAD_GIL_EXIT();
         struct dirent *dirent = readdir(self->dir);
         if (dirent == NULL) {
             closedir(self->dir);
+            MP_THREAD_GIL_ENTER();
             self->dir = NULL;
             return MP_OBJ_STOP_ITERATION;
         }
+        MP_THREAD_GIL_ENTER();
         const char *fn = dirent->d_name;
 
         if (fn[0] == '.' && (fn[1] == 0 || fn[1] == '.')) {
@@ -188,7 +194,7 @@ STATIC mp_obj_t vfs_posix_ilistdir_it_iternext(mp_obj_t self_in) {
         if (self->is_str) {
             t->items[0] = mp_obj_new_str(fn, strlen(fn));
         } else {
-            t->items[0] = mp_obj_new_bytes((const byte*)fn, strlen(fn));
+            t->items[0] = mp_obj_new_bytes((const byte *)fn, strlen(fn));
         }
 
         #ifdef _DIRENT_HAVE_D_TYPE
@@ -228,7 +234,9 @@ STATIC mp_obj_t vfs_posix_ilistdir(mp_obj_t self_in, mp_obj_t path_in) {
     if (path[0] == '\0') {
         path = ".";
     }
+    MP_THREAD_GIL_EXIT();
     iter->dir = opendir(path);
+    MP_THREAD_GIL_ENTER();
     if (iter->dir == NULL) {
         mp_raise_OSError(errno);
     }
@@ -244,7 +252,10 @@ typedef struct _mp_obj_listdir_t {
 
 STATIC mp_obj_t vfs_posix_mkdir(mp_obj_t self_in, mp_obj_t path_in) {
     mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
-    int ret = mkdir(vfs_posix_get_path_str(self, path_in), 0777);
+    const char *path = vfs_posix_get_path_str(self, path_in);
+    MP_THREAD_GIL_EXIT();
+    int ret = mkdir(path, 0777);
+    MP_THREAD_GIL_ENTER();
     if (ret != 0) {
         mp_raise_OSError(errno);
     }
@@ -261,7 +272,9 @@ STATIC mp_obj_t vfs_posix_rename(mp_obj_t self_in, mp_obj_t old_path_in, mp_obj_
     mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
     const char *old_path = vfs_posix_get_path_str(self, old_path_in);
     const char *new_path = vfs_posix_get_path_str(self, new_path_in);
+    MP_THREAD_GIL_EXIT();
     int ret = rename(old_path, new_path);
+    MP_THREAD_GIL_ENTER();
     if (ret != 0) {
         mp_raise_OSError(errno);
     }
@@ -277,10 +290,9 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(vfs_posix_rmdir_obj, vfs_posix_rmdir);
 STATIC mp_obj_t vfs_posix_stat(mp_obj_t self_in, mp_obj_t path_in) {
     mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
     struct stat sb;
-    int ret = stat(vfs_posix_get_path_str(self, path_in), &sb);
-    if (ret != 0) {
-        mp_raise_OSError(errno);
-    }
+    const char *path = vfs_posix_get_path_str(self, path_in);
+    int ret;
+    MP_HAL_RETRY_SYSCALL(ret, stat(path, &sb), mp_raise_OSError(err));
     mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
     t->items[0] = MP_OBJ_NEW_SMALL_INT(sb.st_mode);
     t->items[1] = MP_OBJ_NEW_SMALL_INT(sb.st_ino);
@@ -320,10 +332,8 @@ STATIC mp_obj_t vfs_posix_statvfs(mp_obj_t self_in, mp_obj_t path_in) {
     mp_obj_vfs_posix_t *self = MP_OBJ_TO_PTR(self_in);
     STRUCT_STATVFS sb;
     const char *path = vfs_posix_get_path_str(self, path_in);
-    int ret = STATVFS(path, &sb);
-    if (ret != 0) {
-        mp_raise_OSError(errno);
-    }
+    int ret;
+    MP_HAL_RETRY_SYSCALL(ret, STATVFS(path, &sb), mp_raise_OSError(err));
     mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
     t->items[0] = MP_OBJ_NEW_SMALL_INT(sb.f_bsize);
     t->items[1] = MP_OBJ_NEW_SMALL_INT(sb.f_frsize);
@@ -365,7 +375,7 @@ const mp_obj_type_t mp_type_vfs_posix = {
     .name = MP_QSTR_VfsPosix,
     .make_new = vfs_posix_make_new,
     .protocol = &vfs_posix_proto,
-    .locals_dict = (mp_obj_dict_t*)&vfs_posix_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&vfs_posix_locals_dict,
 };
 
 #endif // MICROPY_VFS_POSIX
diff --git a/extmod/vfs_posix_file.c b/extmod/vfs_posix_file.c
index 44cb85dcc7613..264764b4ee29d 100644
--- a/extmod/vfs_posix_file.c
+++ b/extmod/vfs_posix_file.c
@@ -24,13 +24,16 @@
  * THE SOFTWARE.
  */
 
+#include "py/mphal.h"
+#include "py/mpthread.h"
 #include "py/runtime.h"
 #include "py/stream.h"
 #include "extmod/vfs_posix.h"
 
-#if MICROPY_VFS_POSIX
+#if MICROPY_VFS_POSIX || MICROPY_VFS_POSIX_FILE
 
 #include <fcntl.h>
+#include <unistd.h>
 
 #ifdef _WIN32
 #define fsync _commit
@@ -44,7 +47,7 @@ typedef struct _mp_obj_vfs_posix_file_t {
 #ifdef MICROPY_CPYTHON_COMPAT
 STATIC void check_fd_is_open(const mp_obj_vfs_posix_file_t *o) {
     if (o->fd < 0) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "I/O operation on closed file"));
+        mp_raise_ValueError(MP_ERROR_TEXT("I/O operation on closed file"));
     }
 }
 #else
@@ -78,7 +81,7 @@ mp_obj_t mp_vfs_posix_file_open(const mp_obj_type_t *type, mp_obj_t file_in, mp_
             case '+':
                 mode_rw = O_RDWR;
                 break;
-            #if MICROPY_PY_IO_FILEIO
+                #if MICROPY_PY_IO_FILEIO
             // If we don't have io.FileIO, then files are in text mode implicitly
             case 'b':
                 type = &mp_type_vfs_posix_fileio;
@@ -86,7 +89,7 @@ mp_obj_t mp_vfs_posix_file_open(const mp_obj_type_t *type, mp_obj_t file_in, mp_
             case 't':
                 type = &mp_type_vfs_posix_textio;
                 break;
-            #endif
+                #endif
         }
     }
 
@@ -100,17 +103,15 @@ mp_obj_t mp_vfs_posix_file_open(const mp_obj_type_t *type, mp_obj_t file_in, mp_
     }
 
     const char *fname = mp_obj_str_get_str(fid);
-    int fd = open(fname, mode_x | mode_rw, 0644);
-    if (fd == -1) {
-        mp_raise_OSError(errno);
-    }
+    int fd;
+    MP_HAL_RETRY_SYSCALL(fd, open(fname, mode_x | mode_rw, 0644), mp_raise_OSError(err));
     o->fd = fd;
     return MP_OBJ_FROM_PTR(o);
 }
 
 STATIC mp_obj_t vfs_posix_file_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_file, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_file, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_NONE} },
         { MP_QSTR_mode, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_QSTR(MP_QSTR_r)} },
     };
 
@@ -135,12 +136,12 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(vfs_posix_file___exit___obj, 4, 4, vf
 STATIC mp_uint_t vfs_posix_file_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
     mp_obj_vfs_posix_file_t *o = MP_OBJ_TO_PTR(o_in);
     check_fd_is_open(o);
-    mp_int_t r = read(o->fd, buf, size);
-    if (r == -1) {
-        *errcode = errno;
+    ssize_t r;
+    MP_HAL_RETRY_SYSCALL(r, read(o->fd, buf, size), {
+        *errcode = err;
         return MP_STREAM_ERROR;
-    }
-    return r;
+    });
+    return (mp_uint_t)r;
 }
 
 STATIC mp_uint_t vfs_posix_file_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
@@ -152,35 +153,38 @@ STATIC mp_uint_t vfs_posix_file_write(mp_obj_t o_in, const void *buf, mp_uint_t
         return size;
     }
     #endif
-    mp_int_t r = write(o->fd, buf, size);
-    while (r == -1 && errno == EINTR) {
-        if (MP_STATE_VM(mp_pending_exception) != MP_OBJ_NULL) {
-            mp_obj_t obj = MP_STATE_VM(mp_pending_exception);
-            MP_STATE_VM(mp_pending_exception) = MP_OBJ_NULL;
-            nlr_raise(obj);
-        }
-        r = write(o->fd, buf, size);
-    }
-    if (r == -1) {
-        *errcode = errno;
+    ssize_t r;
+    MP_HAL_RETRY_SYSCALL(r, write(o->fd, buf, size), {
+        *errcode = err;
         return MP_STREAM_ERROR;
-    }
-    return r;
+    });
+    return (mp_uint_t)r;
 }
 
 STATIC mp_uint_t vfs_posix_file_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
     mp_obj_vfs_posix_file_t *o = MP_OBJ_TO_PTR(o_in);
     check_fd_is_open(o);
     switch (request) {
-        case MP_STREAM_FLUSH:
-            if (fsync(o->fd) < 0) {
-                *errcode = errno;
+        case MP_STREAM_FLUSH: {
+            int ret;
+            MP_HAL_RETRY_SYSCALL(ret, fsync(o->fd), {
+                if (err == EINVAL
+                    && (o->fd == STDIN_FILENO || o->fd == STDOUT_FILENO || o->fd == STDERR_FILENO)) {
+                    // fsync(stdin/stdout/stderr) may fail with EINVAL, but don't propagate that
+                    // error out.  Because data is not buffered by us, and stdin/out/err.flush()
+                    // should just be a no-op.
+                    return 0;
+                }
+                *errcode = err;
                 return MP_STREAM_ERROR;
-            }
+            });
             return 0;
+        }
         case MP_STREAM_SEEK: {
-            struct mp_stream_seek_t *s = (struct mp_stream_seek_t*)arg;
+            struct mp_stream_seek_t *s = (struct mp_stream_seek_t *)arg;
+            MP_THREAD_GIL_EXIT();
             off_t off = lseek(o->fd, s->offset, s->whence);
+            MP_THREAD_GIL_ENTER();
             if (off == (off_t)-1) {
                 *errcode = errno;
                 return MP_STREAM_ERROR;
@@ -189,18 +193,22 @@ STATIC mp_uint_t vfs_posix_file_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_
             return 0;
         }
         case MP_STREAM_CLOSE:
+            MP_THREAD_GIL_EXIT();
             close(o->fd);
+            MP_THREAD_GIL_ENTER();
             #ifdef MICROPY_CPYTHON_COMPAT
             o->fd = -1;
             #endif
             return 0;
+        case MP_STREAM_GET_FILENO:
+            return o->fd;
         default:
             *errcode = EINVAL;
             return MP_STREAM_ERROR;
     }
 }
 
-STATIC const mp_rom_map_elem_t rawfile_locals_dict_table[] = {
+STATIC const mp_rom_map_elem_t vfs_posix_rawfile_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_fileno), MP_ROM_PTR(&vfs_posix_file_fileno_obj) },
     { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
     { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
@@ -215,10 +223,10 @@ STATIC const mp_rom_map_elem_t rawfile_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&vfs_posix_file___exit___obj) },
 };
 
-STATIC MP_DEFINE_CONST_DICT(rawfile_locals_dict, rawfile_locals_dict_table);
+STATIC MP_DEFINE_CONST_DICT(vfs_posix_rawfile_locals_dict, vfs_posix_rawfile_locals_dict_table);
 
 #if MICROPY_PY_IO_FILEIO
-STATIC const mp_stream_p_t fileio_stream_p = {
+STATIC const mp_stream_p_t vfs_posix_fileio_stream_p = {
     .read = vfs_posix_file_read,
     .write = vfs_posix_file_write,
     .ioctl = vfs_posix_file_ioctl,
@@ -231,12 +239,12 @@ const mp_obj_type_t mp_type_vfs_posix_fileio = {
     .make_new = vfs_posix_file_make_new,
     .getiter = mp_identity_getiter,
     .iternext = mp_stream_unbuffered_iter,
-    .protocol = &fileio_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&rawfile_locals_dict,
+    .protocol = &vfs_posix_fileio_stream_p,
+    .locals_dict = (mp_obj_dict_t *)&vfs_posix_rawfile_locals_dict,
 };
 #endif
 
-STATIC const mp_stream_p_t textio_stream_p = {
+STATIC const mp_stream_p_t vfs_posix_textio_stream_p = {
     .read = vfs_posix_file_read,
     .write = vfs_posix_file_write,
     .ioctl = vfs_posix_file_ioctl,
@@ -250,12 +258,12 @@ const mp_obj_type_t mp_type_vfs_posix_textio = {
     .make_new = vfs_posix_file_make_new,
     .getiter = mp_identity_getiter,
     .iternext = mp_stream_unbuffered_iter,
-    .protocol = &textio_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&rawfile_locals_dict,
+    .protocol = &vfs_posix_textio_stream_p,
+    .locals_dict = (mp_obj_dict_t *)&vfs_posix_rawfile_locals_dict,
 };
 
-const mp_obj_vfs_posix_file_t mp_sys_stdin_obj  = {{&mp_type_textio}, STDIN_FILENO};
+const mp_obj_vfs_posix_file_t mp_sys_stdin_obj = {{&mp_type_textio}, STDIN_FILENO};
 const mp_obj_vfs_posix_file_t mp_sys_stdout_obj = {{&mp_type_textio}, STDOUT_FILENO};
 const mp_obj_vfs_posix_file_t mp_sys_stderr_obj = {{&mp_type_textio}, STDERR_FILENO};
 
-#endif // MICROPY_VFS_POSIX
+#endif // MICROPY_VFS_POSIX || MICROPY_VFS_POSIX_FILE
diff --git a/extmod/vfs_reader.c b/extmod/vfs_reader.c
index e1ee45a3c7439..db13ce3c33141 100644
--- a/extmod/vfs_reader.c
+++ b/extmod/vfs_reader.c
@@ -42,7 +42,7 @@ typedef struct _mp_reader_vfs_t {
 } mp_reader_vfs_t;
 
 STATIC mp_uint_t mp_reader_vfs_readbyte(void *data) {
-    mp_reader_vfs_t *reader = (mp_reader_vfs_t*)data;
+    mp_reader_vfs_t *reader = (mp_reader_vfs_t *)data;
     if (reader->pos >= reader->len) {
         if (reader->len < sizeof(reader->buf)) {
             return MP_READER_EOF;
@@ -64,7 +64,7 @@ STATIC mp_uint_t mp_reader_vfs_readbyte(void *data) {
 }
 
 STATIC void mp_reader_vfs_close(void *data) {
-    mp_reader_vfs_t *reader = (mp_reader_vfs_t*)data;
+    mp_reader_vfs_t *reader = (mp_reader_vfs_t *)data;
     mp_stream_close(reader->file);
     m_del_obj(mp_reader_vfs_t, reader);
 }
@@ -72,7 +72,7 @@ STATIC void mp_reader_vfs_close(void *data) {
 void mp_reader_new_file(mp_reader_t *reader, const char *filename) {
     mp_reader_vfs_t *rf = m_new_obj(mp_reader_vfs_t);
     mp_obj_t arg = mp_obj_new_str(filename, strlen(filename));
-    rf->file = mp_vfs_open(1, &arg, (mp_map_t*)&mp_const_empty_map);
+    rf->file = mp_vfs_open(1, &arg, (mp_map_t *)&mp_const_empty_map);
     int errcode;
     rf->len = mp_stream_rw(rf->file, rf->buf, sizeof(rf->buf), &errcode, MP_STREAM_RW_READ | MP_STREAM_RW_ONCE);
     if (errcode != 0) {
diff --git a/extmod/virtpin.c b/extmod/virtpin.c
index dbfa21d669a72..71a11232d4339 100644
--- a/extmod/virtpin.c
+++ b/extmod/virtpin.c
@@ -27,13 +27,13 @@
 #include "extmod/virtpin.h"
 
 int mp_virtual_pin_read(mp_obj_t pin) {
-    mp_obj_base_t* s = (mp_obj_base_t*)MP_OBJ_TO_PTR(pin);
-    mp_pin_p_t *pin_p = (mp_pin_p_t*)s->type->protocol;
+    mp_obj_base_t *s = (mp_obj_base_t *)MP_OBJ_TO_PTR(pin);
+    mp_pin_p_t *pin_p = (mp_pin_p_t *)s->type->protocol;
     return pin_p->ioctl(pin, MP_PIN_READ, 0, NULL);
 }
 
 void mp_virtual_pin_write(mp_obj_t pin, int value) {
-    mp_obj_base_t* s = (mp_obj_base_t*)MP_OBJ_TO_PTR(pin);
-    mp_pin_p_t *pin_p = (mp_pin_p_t*)s->type->protocol;
+    mp_obj_base_t *s = (mp_obj_base_t *)MP_OBJ_TO_PTR(pin);
+    mp_pin_p_t *pin_p = (mp_pin_p_t *)s->type->protocol;
     pin_p->ioctl(pin, MP_PIN_WRITE, value, NULL);
 }
diff --git a/extmod/webrepl/manifest.py b/extmod/webrepl/manifest.py
new file mode 100644
index 0000000000000..6ce7d85466c06
--- /dev/null
+++ b/extmod/webrepl/manifest.py
@@ -0,0 +1 @@
+freeze(".", ("webrepl.py", "webrepl_setup.py", "websocket_helper.py",))
diff --git a/ports/esp8266/modules/webrepl.py b/extmod/webrepl/webrepl.py
similarity index 92%
rename from ports/esp8266/modules/webrepl.py
rename to extmod/webrepl/webrepl.py
index bbf8bdb320efe..8ddf56143f3ae 100644
--- a/ports/esp8266/modules/webrepl.py
+++ b/extmod/webrepl/webrepl.py
@@ -9,6 +9,7 @@
 listen_s = None
 client_s = None
 
+
 def setup_conn(port, accept_handler):
     global listen_s
     listen_s = socket.socket()
@@ -43,8 +44,9 @@ def accept_conn(listen_sock):
     ws = uwebsocket.websocket(cl, True)
     ws = _webrepl._webrepl(ws)
     cl.setblocking(False)
-    # notify REPL on socket incoming data
-    cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify)
+    # notify REPL on socket incoming data (ESP32/ESP8266-only)
+    if hasattr(uos, "dupterm_notify"):
+        cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify)
     uos.dupterm(ws)
 
 
@@ -62,6 +64,7 @@ def start(port=8266, password=None):
     if password is None:
         try:
             import webrepl_cfg
+
             _webrepl.password(webrepl_cfg.PASS)
             setup_conn(port, accept_conn)
             print("Started webrepl in normal mode")
diff --git a/ports/esp8266/modules/webrepl_setup.py b/extmod/webrepl/webrepl_setup.py
similarity index 94%
rename from ports/esp8266/modules/webrepl_setup.py
rename to extmod/webrepl/webrepl_setup.py
index 129313a21c9cb..ffc9c77fc0deb 100644
--- a/ports/esp8266/modules/webrepl_setup.py
+++ b/extmod/webrepl/webrepl_setup.py
@@ -1,20 +1,24 @@
 import sys
-#import uos as os
+
+# import uos as os
 import os
 import machine
 
 RC = "./boot.py"
 CONFIG = "./webrepl_cfg.py"
 
+
 def input_choice(prompt, choices):
     while 1:
         resp = input(prompt)
         if resp in choices:
             return resp
 
+
 def getpass(prompt):
     return input(prompt)
 
+
 def input_pass():
     while 1:
         passwd1 = getpass("New password (4-9 chars): ")
@@ -77,7 +81,9 @@ def main():
 
     if resp == "E":
         if exists(CONFIG):
-            resp2 = input_choice("Would you like to change WebREPL password? (y/n) ", ("y", "n", ""))
+            resp2 = input_choice(
+                "Would you like to change WebREPL password? (y/n) ", ("y", "n", "")
+            )
         else:
             print("To enable WebREPL, you must set password for it")
             resp2 = "y"
@@ -87,7 +93,6 @@ def main():
             with open(CONFIG, "w") as f:
                 f.write("PASS = %r\n" % passwd)
 
-
     if resp not in ("D", "E") or (resp == "D" and not status) or (resp == "E" and status):
         print("No further action required")
         sys.exit()
@@ -99,4 +104,5 @@ def main():
     if resp == "y":
         machine.reset()
 
+
 main()
diff --git a/ports/esp8266/modules/websocket_helper.py b/extmod/webrepl/websocket_helper.py
similarity index 86%
rename from ports/esp8266/modules/websocket_helper.py
rename to extmod/webrepl/websocket_helper.py
index 9c06db50235a5..5ca80534eb33f 100644
--- a/ports/esp8266/modules/websocket_helper.py
+++ b/extmod/webrepl/websocket_helper.py
@@ -1,4 +1,5 @@
 import sys
+
 try:
     import ubinascii as binascii
 except:
@@ -10,10 +11,11 @@
 
 DEBUG = 0
 
+
 def server_handshake(sock):
     clr = sock.makefile("rwb", 0)
     l = clr.readline()
-    #sys.stdout.write(repr(l))
+    # sys.stdout.write(repr(l))
 
     webkey = None
 
@@ -23,11 +25,11 @@ def server_handshake(sock):
             raise OSError("EOF in headers")
         if l == b"\r\n":
             break
-    #    sys.stdout.write(l)
+        #    sys.stdout.write(l)
         h, v = [x.strip() for x in l.split(b":", 1)]
         if DEBUG:
             print((h, v))
-        if h == b'Sec-WebSocket-Key':
+        if h == b"Sec-WebSocket-Key":
             webkey = v
 
     if not webkey:
@@ -43,11 +45,13 @@ def server_handshake(sock):
     if DEBUG:
         print("respkey:", respkey)
 
-    sock.send(b"""\
+    sock.send(
+        b"""\
 HTTP/1.1 101 Switching Protocols\r
 Upgrade: websocket\r
 Connection: Upgrade\r
-Sec-WebSocket-Accept: """)
+Sec-WebSocket-Accept: """
+    )
     sock.send(respkey)
     sock.send("\r\n\r\n")
 
@@ -57,18 +61,22 @@ def server_handshake(sock):
 # servers.
 def client_handshake(sock):
     cl = sock.makefile("rwb", 0)
-    cl.write(b"""\
+    cl.write(
+        b"""\
 GET / HTTP/1.1\r
 Host: echo.websocket.org\r
 Connection: Upgrade\r
 Upgrade: websocket\r
 Sec-WebSocket-Key: foo\r
 \r
-""")
+"""
+    )
     l = cl.readline()
-#    print(l)
+    #    print(l)
     while 1:
         l = cl.readline()
         if l == b"\r\n":
             break
+
+
 #        sys.stdout.write(l)
diff --git a/lib/asf4 b/lib/asf4
new file mode 160000
index 0000000000000..d270f79aa16dd
--- /dev/null
+++ b/lib/asf4
@@ -0,0 +1 @@
+Subproject commit d270f79aa16dd8fd4ae3b6c14544283dcb992e9c
diff --git a/lib/btstack b/lib/btstack
new file mode 160000
index 0000000000000..c8b9823f68c6a
--- /dev/null
+++ b/lib/btstack
@@ -0,0 +1 @@
+Subproject commit c8b9823f68c6af0fa52e2c4e009aba4dbf257232
diff --git a/lib/cmsis/inc/cmsis_armcc.h b/lib/cmsis/inc/cmsis_armcc.h
index 74c49c67defb6..174d744033029 100644
--- a/lib/cmsis/inc/cmsis_armcc.h
+++ b/lib/cmsis/inc/cmsis_armcc.h
@@ -1,43 +1,108 @@
 /**************************************************************************//**
  * @file     cmsis_armcc.h
- * @brief    CMSIS Cortex-M Core Function/Instruction Header File
- * @version  V4.30
- * @date     20. October 2015
+ * @brief    CMSIS compiler ARMCC (Arm Compiler 5) header file
+ * @version  V5.0.5
+ * @date     14. December 2018
  ******************************************************************************/
-/* Copyright (c) 2009 - 2015 ARM LIMITED
-
-   All rights reserved.
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-   - Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in the
-     documentation and/or other materials provided with the distribution.
-   - Neither the name of ARM nor the names of its contributors may be used
-     to endorse or promote products derived from this software without
-     specific prior written permission.
-   *
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
-   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-   POSSIBILITY OF SUCH DAMAGE.
-   ---------------------------------------------------------------------------*/
-
+/*
+ * Copyright (c) 2009-2018 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #ifndef __CMSIS_ARMCC_H
 #define __CMSIS_ARMCC_H
 
 
 #if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 400677)
-  #error "Please use ARM Compiler Toolchain V4.0.677 or later!"
+  #error "Please use Arm Compiler Toolchain V4.0.677 or later!"
+#endif
+
+/* CMSIS compiler control architecture macros */
+#if ((defined (__TARGET_ARCH_6_M  ) && (__TARGET_ARCH_6_M   == 1)) || \
+     (defined (__TARGET_ARCH_6S_M ) && (__TARGET_ARCH_6S_M  == 1))   )
+  #define __ARM_ARCH_6M__           1
+#endif
+
+#if (defined (__TARGET_ARCH_7_M ) && (__TARGET_ARCH_7_M  == 1))
+  #define __ARM_ARCH_7M__           1
+#endif
+
+#if (defined (__TARGET_ARCH_7E_M) && (__TARGET_ARCH_7E_M == 1))
+  #define __ARM_ARCH_7EM__          1
+#endif
+
+  /* __ARM_ARCH_8M_BASE__  not applicable */
+  /* __ARM_ARCH_8M_MAIN__  not applicable */
+
+/* CMSIS compiler control DSP macros */
+#if ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     )
+  #define __ARM_FEATURE_DSP         1
+#endif
+
+/* CMSIS compiler specific defines */
+#ifndef   __ASM
+  #define __ASM                                  __asm
+#endif
+#ifndef   __INLINE
+  #define __INLINE                               __inline
+#endif
+#ifndef   __STATIC_INLINE
+  #define __STATIC_INLINE                        static __inline
+#endif
+#ifndef   __STATIC_FORCEINLINE                 
+  #define __STATIC_FORCEINLINE                   static __forceinline
+#endif           
+#ifndef   __NO_RETURN
+  #define __NO_RETURN                            __declspec(noreturn)
+#endif
+#ifndef   __USED
+  #define __USED                                 __attribute__((used))
+#endif
+#ifndef   __WEAK
+  #define __WEAK                                 __attribute__((weak))
+#endif
+#ifndef   __PACKED
+  #define __PACKED                               __attribute__((packed))
+#endif
+#ifndef   __PACKED_STRUCT
+  #define __PACKED_STRUCT                        __packed struct
+#endif
+#ifndef   __PACKED_UNION
+  #define __PACKED_UNION                         __packed union
+#endif
+#ifndef   __UNALIGNED_UINT32        /* deprecated */
+  #define __UNALIGNED_UINT32(x)                  (*((__packed uint32_t *)(x)))
+#endif
+#ifndef   __UNALIGNED_UINT16_WRITE
+  #define __UNALIGNED_UINT16_WRITE(addr, val)    ((*((__packed uint16_t *)(addr))) = (val))
+#endif
+#ifndef   __UNALIGNED_UINT16_READ
+  #define __UNALIGNED_UINT16_READ(addr)          (*((const __packed uint16_t *)(addr)))
+#endif
+#ifndef   __UNALIGNED_UINT32_WRITE
+  #define __UNALIGNED_UINT32_WRITE(addr, val)    ((*((__packed uint32_t *)(addr))) = (val))
+#endif
+#ifndef   __UNALIGNED_UINT32_READ
+  #define __UNALIGNED_UINT32_READ(addr)          (*((const __packed uint32_t *)(addr)))
+#endif
+#ifndef   __ALIGNED
+  #define __ALIGNED(x)                           __attribute__((aligned(x)))
+#endif
+#ifndef   __RESTRICT
+  #define __RESTRICT                             __restrict
 #endif
 
 /* ###########################  Core Function Access  ########################### */
@@ -46,7 +111,19 @@
   @{
  */
 
+/**
+  \brief   Enable IRQ Interrupts
+  \details Enables IRQ interrupts by clearing the I-bit in the CPSR.
+           Can only be executed in Privileged modes.
+ */
 /* intrinsic void __enable_irq();     */
+
+
+/**
+  \brief   Disable IRQ Interrupts
+  \details Disables IRQ interrupts by setting the I-bit in the CPSR.
+           Can only be executed in Privileged modes.
+ */
 /* intrinsic void __disable_irq();    */
 
 /**
@@ -181,7 +258,8 @@ __STATIC_INLINE void __set_PRIMASK(uint32_t priMask)
 }
 
 
-#if       (__CORTEX_M >= 0x03U) || (__CORTEX_SC >= 300U)
+#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
+     (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     )
 
 /**
   \brief   Enable FIQ
@@ -256,13 +334,12 @@ __STATIC_INLINE uint32_t __get_FAULTMASK(void)
 __STATIC_INLINE void __set_FAULTMASK(uint32_t faultMask)
 {
   register uint32_t __regFaultMask       __ASM("faultmask");
-  __regFaultMask = (faultMask & (uint32_t)1);
+  __regFaultMask = (faultMask & (uint32_t)1U);
 }
 
-#endif /* (__CORTEX_M >= 0x03U) || (__CORTEX_SC >= 300U) */
-
+#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
+           (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     ) */
 
-#if       (__CORTEX_M == 0x04U) || (__CORTEX_M == 0x07U)
 
 /**
   \brief   Get FPSCR
@@ -271,7 +348,8 @@ __STATIC_INLINE void __set_FAULTMASK(uint32_t faultMask)
  */
 __STATIC_INLINE uint32_t __get_FPSCR(void)
 {
-#if (__FPU_PRESENT == 1U) && (__FPU_USED == 1U)
+#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
+     (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )
   register uint32_t __regfpscr         __ASM("fpscr");
   return(__regfpscr);
 #else
@@ -287,15 +365,15 @@ __STATIC_INLINE uint32_t __get_FPSCR(void)
  */
 __STATIC_INLINE void __set_FPSCR(uint32_t fpscr)
 {
-#if (__FPU_PRESENT == 1U) && (__FPU_USED == 1U)
+#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
+     (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )
   register uint32_t __regfpscr         __ASM("fpscr");
   __regfpscr = (fpscr);
+#else
+  (void)fpscr;
 #endif
 }
 
-#endif /* (__CORTEX_M == 0x04U) || (__CORTEX_M == 0x07U) */
-
-
 
 /*@} end of CMSIS_Core_RegAccFunctions */
 
@@ -369,9 +447,10 @@ __STATIC_INLINE void __set_FPSCR(uint32_t fpscr)
                    __schedule_barrier();\
                 } while (0U)
 
+                  
 /**
   \brief   Reverse byte order (32 bit)
-  \details Reverses the byte order in integer value.
+  \details Reverses the byte order in unsigned integer value. For example, 0x12345678 becomes 0x78563412.
   \param [in]    value  Value to reverse
   \return               Reversed value
  */
@@ -380,7 +459,7 @@ __STATIC_INLINE void __set_FPSCR(uint32_t fpscr)
 
 /**
   \brief   Reverse byte order (16 bit)
-  \details Reverses the byte order in two unsigned short values.
+  \details Reverses the byte order within each halfword of a word. For example, 0x12345678 becomes 0x34127856.
   \param [in]    value  Value to reverse
   \return               Reversed value
  */
@@ -392,14 +471,15 @@ __attribute__((section(".rev16_text"))) __STATIC_INLINE __ASM uint32_t __REV16(u
 }
 #endif
 
+
 /**
-  \brief   Reverse byte order in signed short value
-  \details Reverses the byte order in a signed short value with sign extension to integer.
+  \brief   Reverse byte order (16 bit)
+  \details Reverses the byte order in a 16-bit value and returns the signed 16-bit result. For example, 0x0080 becomes 0x8000.
   \param [in]    value  Value to reverse
   \return               Reversed value
  */
 #ifndef __NO_EMBEDDED_ASM
-__attribute__((section(".revsh_text"))) __STATIC_INLINE __ASM int32_t __REVSH(int32_t value)
+__attribute__((section(".revsh_text"))) __STATIC_INLINE __ASM int16_t __REVSH(int16_t value)
 {
   revsh r0, r0
   bx lr
@@ -410,8 +490,8 @@ __attribute__((section(".revsh_text"))) __STATIC_INLINE __ASM int32_t __REVSH(in
 /**
   \brief   Rotate Right in unsigned value (32 bit)
   \details Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits.
-  \param [in]    value  Value to rotate
-  \param [in]    value  Number of Bits to rotate
+  \param [in]    op1  Value to rotate
+  \param [in]    op2  Number of Bits to rotate
   \return               Rotated value
  */
 #define __ROR                             __ror
@@ -433,23 +513,24 @@ __attribute__((section(".revsh_text"))) __STATIC_INLINE __ASM int32_t __REVSH(in
   \param [in]    value  Value to reverse
   \return               Reversed value
  */
-#if       (__CORTEX_M >= 0x03U) || (__CORTEX_SC >= 300U)
+#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
+     (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     )
   #define __RBIT                          __rbit
 #else
 __attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t value)
 {
   uint32_t result;
-  int32_t s = 4 /*sizeof(v)*/ * 8 - 1; /* extra shift needed at end */
+  uint32_t s = (4U /*sizeof(v)*/ * 8U) - 1U; /* extra shift needed at end */
 
   result = value;                      /* r will be reversed bits of v; first get LSB of v */
-  for (value >>= 1U; value; value >>= 1U)
+  for (value >>= 1U; value != 0U; value >>= 1U)
   {
     result <<= 1U;
     result |= value & 1U;
     s--;
   }
   result <<= s;                        /* shift when v's highest bits are zero */
-  return(result);
+  return result;
 }
 #endif
 
@@ -463,7 +544,8 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t value)
 #define __CLZ                             __clz
 
 
-#if       (__CORTEX_M >= 0x03U) || (__CORTEX_SC >= 300U)
+#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
+     (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     )
 
 /**
   \brief   LDR Exclusive (8 bit)
@@ -645,7 +727,60 @@ __attribute__((section(".rrx_text"))) __STATIC_INLINE __ASM uint32_t __RRX(uint3
  */
 #define __STRT(value, ptr)                __strt(value, ptr)
 
-#endif /* (__CORTEX_M >= 0x03U) || (__CORTEX_SC >= 300U) */
+#else  /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
+           (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     ) */
+
+/**
+  \brief   Signed Saturate
+  \details Saturates a signed value.
+  \param [in]  value  Value to be saturated
+  \param [in]    sat  Bit position to saturate to (1..32)
+  \return             Saturated value
+ */
+__attribute__((always_inline)) __STATIC_INLINE int32_t __SSAT(int32_t val, uint32_t sat)
+{
+  if ((sat >= 1U) && (sat <= 32U))
+  {
+    const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U);
+    const int32_t min = -1 - max ;
+    if (val > max)
+    {
+      return max;
+    }
+    else if (val < min)
+    {
+      return min;
+    }
+  }
+  return val;
+}
+
+/**
+  \brief   Unsigned Saturate
+  \details Saturates an unsigned value.
+  \param [in]  value  Value to be saturated
+  \param [in]    sat  Bit position to saturate to (0..31)
+  \return             Saturated value
+ */
+__attribute__((always_inline)) __STATIC_INLINE uint32_t __USAT(int32_t val, uint32_t sat)
+{
+  if (sat <= 31U)
+  {
+    const uint32_t max = ((1U << sat) - 1U);
+    if (val > (int32_t)max)
+    {
+      return max;
+    }
+    else if (val < 0)
+    {
+      return 0U;
+    }
+  }
+  return (uint32_t)val;
+}
+
+#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__  == 1)) || \
+           (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     ) */
 
 /*@}*/ /* end of group CMSIS_Core_InstructionInterface */
 
@@ -656,7 +791,7 @@ __attribute__((section(".rrx_text"))) __STATIC_INLINE __ASM uint32_t __RRX(uint3
   @{
 */
 
-#if (__CORTEX_M >= 0x04U)  /* only for Cortex-M4 and above */
+#if ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     )
 
 #define __SADD8                           __sadd8
 #define __QADD8                           __qadd8
@@ -727,7 +862,7 @@ __attribute__((section(".rrx_text"))) __STATIC_INLINE __ASM uint32_t __RRX(uint3
 #define __SMMLA(ARG1,ARG2,ARG3)          ( (int32_t)((((int64_t)(ARG1) * (ARG2)) + \
                                                       ((int64_t)(ARG3) << 32U)     ) >> 32U))
 
-#endif /* (__CORTEX_M >= 0x04) */
+#endif /* ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1))     ) */
 /*@} end of group CMSIS_SIMD_intrinsics */
 
 
diff --git a/lib/cmsis/inc/cmsis_armclang.h b/lib/cmsis/inc/cmsis_armclang.h
new file mode 100644
index 0000000000000..6a8867d57417e
--- /dev/null
+++ b/lib/cmsis/inc/cmsis_armclang.h
@@ -0,0 +1,1420 @@
+/**************************************************************************//**
+ * @file     cmsis_armclang.h
+ * @brief    CMSIS compiler armclang (Arm Compiler 6) header file
+ * @version  V5.1.0
+ * @date     14. March 2019
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2019 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*lint -esym(9058, IRQn)*/ /* disable MISRA 2012 Rule 2.4 for IRQn */
+
+#ifndef __CMSIS_ARMCLANG_H
+#define __CMSIS_ARMCLANG_H
+
+#pragma clang system_header   /* treat file as system include file */
+
+#ifndef __ARM_COMPAT_H
+#include <arm_compat.h>    /* Compatibility header for Arm Compiler 5 intrinsics */
+#endif
+
+/* CMSIS compiler specific defines */
+#ifndef   __ASM
+  #define __ASM                                  __asm
+#endif
+#ifndef   __INLINE
+  #define __INLINE                               __inline
+#endif
+#ifndef   __STATIC_INLINE
+  #define __STATIC_INLINE                        static __inline
+#endif
+#ifndef   __STATIC_FORCEINLINE
+  #define __STATIC_FORCEINLINE                   __attribute__((always_inline)) static __inline
+#endif
+#ifndef   __NO_RETURN
+  #define __NO_RETURN                            __attribute__((__noreturn__))
+#endif
+#ifndef   __USED
+  #define __USED                                 __attribute__((used))
+#endif
+#ifndef   __WEAK
+  #define __WEAK                                 __attribute__((weak))
+#endif
+#ifndef   __PACKED
+  #define __PACKED                               __attribute__((packed, aligned(1)))
+#endif
+#ifndef   __PACKED_STRUCT
+  #define __PACKED_STRUCT                        struct __attribute__((packed, aligned(1)))
+#endif
+#ifndef   __PACKED_UNION
+  #define __PACKED_UNION                         union __attribute__((packed, aligned(1)))
+#endif
+#ifndef   __UNALIGNED_UINT32        /* deprecated */
+  #pragma clang diagnostic push
+  #pragma clang diagnostic ignored "-Wpacked"
+/*lint -esym(9058, T_UINT32)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT32 */
+  struct __attribute__((packed)) T_UINT32 { uint32_t v; };
+  #pragma clang diagnostic pop
+  #define __UNALIGNED_UINT32(x)                  (((struct T_UINT32 *)(x))->v)
+#endif
+#ifndef   __UNALIGNED_UINT16_WRITE
+  #pragma clang diagnostic push
+  #pragma clang diagnostic ignored "-Wpacked"
+/*lint -esym(9058, T_UINT16_WRITE)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT16_WRITE */
+  __PACKED_STRUCT T_UINT16_WRITE { uint16_t v; };
+  #pragma clang diagnostic pop
+  #define __UNALIGNED_UINT16_WRITE(addr, val)    (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val))
+#endif
+#ifndef   __UNALIGNED_UINT16_READ
+  #pragma clang diagnostic push
+  #pragma clang diagnostic ignored "-Wpacked"
+/*lint -esym(9058, T_UINT16_READ)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT16_READ */
+  __PACKED_STRUCT T_UINT16_READ { uint16_t v; };
+  #pragma clang diagnostic pop
+  #define __UNALIGNED_UINT16_READ(addr)          (((const struct T_UINT16_READ *)(const void *)(addr))->v)
+#endif
+#ifndef   __UNALIGNED_UINT32_WRITE
+  #pragma clang diagnostic push
+  #pragma clang diagnostic ignored "-Wpacked"
+/*lint -esym(9058, T_UINT32_WRITE)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT32_WRITE */
+  __PACKED_STRUCT T_UINT32_WRITE { uint32_t v; };
+  #pragma clang diagnostic pop
+  #define __UNALIGNED_UINT32_WRITE(addr, val)    (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val))
+#endif
+#ifndef   __UNALIGNED_UINT32_READ
+  #pragma clang diagnostic push
+  #pragma clang diagnostic ignored "-Wpacked"
+/*lint -esym(9058, T_UINT32_READ)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT32_READ */
+  __PACKED_STRUCT T_UINT32_READ { uint32_t v; };
+  #pragma clang diagnostic pop
+  #define __UNALIGNED_UINT32_READ(addr)          (((const struct T_UINT32_READ *)(const void *)(addr))->v)
+#endif
+#ifndef   __ALIGNED
+  #define __ALIGNED(x)                           __attribute__((aligned(x)))
+#endif
+#ifndef   __RESTRICT
+  #define __RESTRICT                             __restrict
+#endif
+
+
+/* ###########################  Core Function Access  ########################### */
+/** \ingroup  CMSIS_Core_FunctionInterface
+    \defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions
+  @{
+ */
+
+/**
+  \brief   Enable IRQ Interrupts
+  \details Enables IRQ interrupts by clearing the I-bit in the CPSR.
+           Can only be executed in Privileged modes.
+ */
+/* intrinsic void __enable_irq();  see arm_compat.h */
+
+
+/**
+  \brief   Disable IRQ Interrupts
+  \details Disables IRQ interrupts by setting the I-bit in the CPSR.
+           Can only be executed in Privileged modes.
+ */
+/* intrinsic void __disable_irq();  see arm_compat.h */
+
+
+/**
+  \brief   Get Control Register
+  \details Returns the content of the Control Register.
+  \return               Control Register value
+ */
+__STATIC_FORCEINLINE uint32_t __get_CONTROL(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, control" : "=r" (result) );
+  return(result);
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Control Register (non-secure)
+  \details Returns the content of the non-secure Control Register when in secure mode.
+  \return               non-secure Control Register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_CONTROL_NS(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, control_ns" : "=r" (result) );
+  return(result);
+}
+#endif
+
+
+/**
+  \brief   Set Control Register
+  \details Writes the given value to the Control Register.
+  \param [in]    control  Control Register value to set
+ */
+__STATIC_FORCEINLINE void __set_CONTROL(uint32_t control)
+{
+  __ASM volatile ("MSR control, %0" : : "r" (control) : "memory");
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Set Control Register (non-secure)
+  \details Writes the given value to the non-secure Control Register when in secure state.
+  \param [in]    control  Control Register value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_CONTROL_NS(uint32_t control)
+{
+  __ASM volatile ("MSR control_ns, %0" : : "r" (control) : "memory");
+}
+#endif
+
+
+/**
+  \brief   Get IPSR Register
+  \details Returns the content of the IPSR Register.
+  \return               IPSR Register value
+ */
+__STATIC_FORCEINLINE uint32_t __get_IPSR(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, ipsr" : "=r" (result) );
+  return(result);
+}
+
+
+/**
+  \brief   Get APSR Register
+  \details Returns the content of the APSR Register.
+  \return               APSR Register value
+ */
+__STATIC_FORCEINLINE uint32_t __get_APSR(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, apsr" : "=r" (result) );
+  return(result);
+}
+
+
+/**
+  \brief   Get xPSR Register
+  \details Returns the content of the xPSR Register.
+  \return               xPSR Register value
+ */
+__STATIC_FORCEINLINE uint32_t __get_xPSR(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, xpsr" : "=r" (result) );
+  return(result);
+}
+
+
+/**
+  \brief   Get Process Stack Pointer
+  \details Returns the current value of the Process Stack Pointer (PSP).
+  \return               PSP Register value
+ */
+__STATIC_FORCEINLINE uint32_t __get_PSP(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, psp"  : "=r" (result) );
+  return(result);
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Process Stack Pointer (non-secure)
+  \details Returns the current value of the non-secure Process Stack Pointer (PSP) when in secure state.
+  \return               PSP Register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_PSP_NS(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, psp_ns"  : "=r" (result) );
+  return(result);
+}
+#endif
+
+
+/**
+  \brief   Set Process Stack Pointer
+  \details Assigns the given value to the Process Stack Pointer (PSP).
+  \param [in]    topOfProcStack  Process Stack Pointer value to set
+ */
+__STATIC_FORCEINLINE void __set_PSP(uint32_t topOfProcStack)
+{
+  __ASM volatile ("MSR psp, %0" : : "r" (topOfProcStack) : );
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Set Process Stack Pointer (non-secure)
+  \details Assigns the given value to the non-secure Process Stack Pointer (PSP) when in secure state.
+  \param [in]    topOfProcStack  Process Stack Pointer value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_PSP_NS(uint32_t topOfProcStack)
+{
+  __ASM volatile ("MSR psp_ns, %0" : : "r" (topOfProcStack) : );
+}
+#endif
+
+
+/**
+  \brief   Get Main Stack Pointer
+  \details Returns the current value of the Main Stack Pointer (MSP).
+  \return               MSP Register value
+ */
+__STATIC_FORCEINLINE uint32_t __get_MSP(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, msp" : "=r" (result) );
+  return(result);
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Main Stack Pointer (non-secure)
+  \details Returns the current value of the non-secure Main Stack Pointer (MSP) when in secure state.
+  \return               MSP Register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_MSP_NS(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, msp_ns" : "=r" (result) );
+  return(result);
+}
+#endif
+
+
+/**
+  \brief   Set Main Stack Pointer
+  \details Assigns the given value to the Main Stack Pointer (MSP).
+  \param [in]    topOfMainStack  Main Stack Pointer value to set
+ */
+__STATIC_FORCEINLINE void __set_MSP(uint32_t topOfMainStack)
+{
+  __ASM volatile ("MSR msp, %0" : : "r" (topOfMainStack) : );
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Set Main Stack Pointer (non-secure)
+  \details Assigns the given value to the non-secure Main Stack Pointer (MSP) when in secure state.
+  \param [in]    topOfMainStack  Main Stack Pointer value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_MSP_NS(uint32_t topOfMainStack)
+{
+  __ASM volatile ("MSR msp_ns, %0" : : "r" (topOfMainStack) : );
+}
+#endif
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Stack Pointer (non-secure)
+  \details Returns the current value of the non-secure Stack Pointer (SP) when in secure state.
+  \return               SP Register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_SP_NS(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, sp_ns" : "=r" (result) );
+  return(result);
+}
+
+
+/**
+  \brief   Set Stack Pointer (non-secure)
+  \details Assigns the given value to the non-secure Stack Pointer (SP) when in secure state.
+  \param [in]    topOfStack  Stack Pointer value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_SP_NS(uint32_t topOfStack)
+{
+  __ASM volatile ("MSR sp_ns, %0" : : "r" (topOfStack) : );
+}
+#endif
+
+
+/**
+  \brief   Get Priority Mask
+  \details Returns the current state of the priority mask bit from the Priority Mask Register.
+  \return               Priority Mask value
+ */
+__STATIC_FORCEINLINE uint32_t __get_PRIMASK(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, primask" : "=r" (result) );
+  return(result);
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Priority Mask (non-secure)
+  \details Returns the current state of the non-secure priority mask bit from the Priority Mask Register when in secure state.
+  \return               Priority Mask value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_PRIMASK_NS(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, primask_ns" : "=r" (result) );
+  return(result);
+}
+#endif
+
+
+/**
+  \brief   Set Priority Mask
+  \details Assigns the given value to the Priority Mask Register.
+  \param [in]    priMask  Priority Mask
+ */
+__STATIC_FORCEINLINE void __set_PRIMASK(uint32_t priMask)
+{
+  __ASM volatile ("MSR primask, %0" : : "r" (priMask) : "memory");
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Set Priority Mask (non-secure)
+  \details Assigns the given value to the non-secure Priority Mask Register when in secure state.
+  \param [in]    priMask  Priority Mask
+ */
+__STATIC_FORCEINLINE void __TZ_set_PRIMASK_NS(uint32_t priMask)
+{
+  __ASM volatile ("MSR primask_ns, %0" : : "r" (priMask) : "memory");
+}
+#endif
+
+
+#if ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+     (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+     (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    )
+/**
+  \brief   Enable FIQ
+  \details Enables FIQ interrupts by clearing the F-bit in the CPSR.
+           Can only be executed in Privileged modes.
+ */
+#define __enable_fault_irq                __enable_fiq   /* see arm_compat.h */
+
+
+/**
+  \brief   Disable FIQ
+  \details Disables FIQ interrupts by setting the F-bit in the CPSR.
+           Can only be executed in Privileged modes.
+ */
+#define __disable_fault_irq               __disable_fiq   /* see arm_compat.h */
+
+
+/**
+  \brief   Get Base Priority
+  \details Returns the current value of the Base Priority register.
+  \return               Base Priority register value
+ */
+__STATIC_FORCEINLINE uint32_t __get_BASEPRI(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, basepri" : "=r" (result) );
+  return(result);
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Base Priority (non-secure)
+  \details Returns the current value of the non-secure Base Priority register when in secure state.
+  \return               Base Priority register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_BASEPRI_NS(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, basepri_ns" : "=r" (result) );
+  return(result);
+}
+#endif
+
+
+/**
+  \brief   Set Base Priority
+  \details Assigns the given value to the Base Priority register.
+  \param [in]    basePri  Base Priority value to set
+ */
+__STATIC_FORCEINLINE void __set_BASEPRI(uint32_t basePri)
+{
+  __ASM volatile ("MSR basepri, %0" : : "r" (basePri) : "memory");
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Set Base Priority (non-secure)
+  \details Assigns the given value to the non-secure Base Priority register when in secure state.
+  \param [in]    basePri  Base Priority value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_BASEPRI_NS(uint32_t basePri)
+{
+  __ASM volatile ("MSR basepri_ns, %0" : : "r" (basePri) : "memory");
+}
+#endif
+
+
+/**
+  \brief   Set Base Priority with condition
+  \details Assigns the given value to the Base Priority register only if BASEPRI masking is disabled,
+           or the new value increases the BASEPRI priority level.
+  \param [in]    basePri  Base Priority value to set
+ */
+__STATIC_FORCEINLINE void __set_BASEPRI_MAX(uint32_t basePri)
+{
+  __ASM volatile ("MSR basepri_max, %0" : : "r" (basePri) : "memory");
+}
+
+
+/**
+  \brief   Get Fault Mask
+  \details Returns the current value of the Fault Mask register.
+  \return               Fault Mask register value
+ */
+__STATIC_FORCEINLINE uint32_t __get_FAULTMASK(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, faultmask" : "=r" (result) );
+  return(result);
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Fault Mask (non-secure)
+  \details Returns the current value of the non-secure Fault Mask register when in secure state.
+  \return               Fault Mask register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_FAULTMASK_NS(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, faultmask_ns" : "=r" (result) );
+  return(result);
+}
+#endif
+
+
+/**
+  \brief   Set Fault Mask
+  \details Assigns the given value to the Fault Mask register.
+  \param [in]    faultMask  Fault Mask value to set
+ */
+__STATIC_FORCEINLINE void __set_FAULTMASK(uint32_t faultMask)
+{
+  __ASM volatile ("MSR faultmask, %0" : : "r" (faultMask) : "memory");
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Set Fault Mask (non-secure)
+  \details Assigns the given value to the non-secure Fault Mask register when in secure state.
+  \param [in]    faultMask  Fault Mask value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_FAULTMASK_NS(uint32_t faultMask)
+{
+  __ASM volatile ("MSR faultmask_ns, %0" : : "r" (faultMask) : "memory");
+}
+#endif
+
+#endif /* ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+           (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+           (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    ) */
+
+
+#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+     (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    )
+
+/**
+  \brief   Get Process Stack Pointer Limit
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence zero is returned always in non-secure
+  mode.
+  
+  \details Returns the current value of the Process Stack Pointer Limit (PSPLIM).
+  \return               PSPLIM Register value
+ */
+__STATIC_FORCEINLINE uint32_t __get_PSPLIM(void)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+    (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+    // without main extensions, the non-secure PSPLIM is RAZ/WI
+  return 0U;
+#else
+  uint32_t result;
+  __ASM volatile ("MRS %0, psplim"  : "=r" (result) );
+  return result;
+#endif
+}
+
+#if (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Process Stack Pointer Limit (non-secure)
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence zero is returned always in non-secure
+  mode.
+
+  \details Returns the current value of the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state.
+  \return               PSPLIM Register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_PSPLIM_NS(void)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)))
+  // without main extensions, the non-secure PSPLIM is RAZ/WI
+  return 0U;
+#else
+  uint32_t result;
+  __ASM volatile ("MRS %0, psplim_ns"  : "=r" (result) );
+  return result;
+#endif
+}
+#endif
+
+
+/**
+  \brief   Set Process Stack Pointer Limit
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence the write is silently ignored in non-secure
+  mode.
+  
+  \details Assigns the given value to the Process Stack Pointer Limit (PSPLIM).
+  \param [in]    ProcStackPtrLimit  Process Stack Pointer Limit value to set
+ */
+__STATIC_FORCEINLINE void __set_PSPLIM(uint32_t ProcStackPtrLimit)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+    (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+  // without main extensions, the non-secure PSPLIM is RAZ/WI
+  (void)ProcStackPtrLimit;
+#else
+  __ASM volatile ("MSR psplim, %0" : : "r" (ProcStackPtrLimit));
+#endif
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE  ) && (__ARM_FEATURE_CMSE   == 3))
+/**
+  \brief   Set Process Stack Pointer (non-secure)
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence the write is silently ignored in non-secure
+  mode.
+
+  \details Assigns the given value to the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state.
+  \param [in]    ProcStackPtrLimit  Process Stack Pointer Limit value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_PSPLIM_NS(uint32_t ProcStackPtrLimit)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)))
+  // without main extensions, the non-secure PSPLIM is RAZ/WI
+  (void)ProcStackPtrLimit;
+#else
+  __ASM volatile ("MSR psplim_ns, %0\n" : : "r" (ProcStackPtrLimit));
+#endif
+}
+#endif
+
+
+/**
+  \brief   Get Main Stack Pointer Limit
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence zero is returned always.
+
+  \details Returns the current value of the Main Stack Pointer Limit (MSPLIM).
+  \return               MSPLIM Register value
+ */
+__STATIC_FORCEINLINE uint32_t __get_MSPLIM(void)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+    (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+  // without main extensions, the non-secure MSPLIM is RAZ/WI
+  return 0U;
+#else
+  uint32_t result;
+  __ASM volatile ("MRS %0, msplim" : "=r" (result) );
+  return result;
+#endif
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE  ) && (__ARM_FEATURE_CMSE   == 3))
+/**
+  \brief   Get Main Stack Pointer Limit (non-secure)
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence zero is returned always.
+
+  \details Returns the current value of the non-secure Main Stack Pointer Limit(MSPLIM) when in secure state.
+  \return               MSPLIM Register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_MSPLIM_NS(void)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)))
+  // without main extensions, the non-secure MSPLIM is RAZ/WI
+  return 0U;
+#else
+  uint32_t result;
+  __ASM volatile ("MRS %0, msplim_ns" : "=r" (result) );
+  return result;
+#endif
+}
+#endif
+
+
+/**
+  \brief   Set Main Stack Pointer Limit
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence the write is silently ignored.
+
+  \details Assigns the given value to the Main Stack Pointer Limit (MSPLIM).
+  \param [in]    MainStackPtrLimit  Main Stack Pointer Limit value to set
+ */
+__STATIC_FORCEINLINE void __set_MSPLIM(uint32_t MainStackPtrLimit)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+    (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+  // without main extensions, the non-secure MSPLIM is RAZ/WI
+  (void)MainStackPtrLimit;
+#else
+  __ASM volatile ("MSR msplim, %0" : : "r" (MainStackPtrLimit));
+#endif
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE  ) && (__ARM_FEATURE_CMSE   == 3))
+/**
+  \brief   Set Main Stack Pointer Limit (non-secure)
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence the write is silently ignored.
+
+  \details Assigns the given value to the non-secure Main Stack Pointer Limit (MSPLIM) when in secure state.
+  \param [in]    MainStackPtrLimit  Main Stack Pointer value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_MSPLIM_NS(uint32_t MainStackPtrLimit)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)))
+  // without main extensions, the non-secure MSPLIM is RAZ/WI
+  (void)MainStackPtrLimit;
+#else
+  __ASM volatile ("MSR msplim_ns, %0" : : "r" (MainStackPtrLimit));
+#endif
+}
+#endif
+
+#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+           (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    ) */
+
+/**
+  \brief   Get FPSCR
+  \details Returns the current value of the Floating Point Status/Control register.
+  \return               Floating Point Status/Control register value
+ */
+#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
+     (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )
+#define __get_FPSCR      (uint32_t)__builtin_arm_get_fpscr
+#else
+#define __get_FPSCR()      ((uint32_t)0U)
+#endif
+
+/**
+  \brief   Set FPSCR
+  \details Assigns the given value to the Floating Point Status/Control register.
+  \param [in]    fpscr  Floating Point Status/Control value to set
+ */
+#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
+     (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )
+#define __set_FPSCR      __builtin_arm_set_fpscr
+#else
+#define __set_FPSCR(x)      ((void)(x))
+#endif
+
+
+/*@} end of CMSIS_Core_RegAccFunctions */
+
+
+/* ##########################  Core Instruction Access  ######################### */
+/** \defgroup CMSIS_Core_InstructionInterface CMSIS Core Instruction Interface
+  Access to dedicated instructions
+  @{
+*/
+
+/* Define macros for porting to both thumb1 and thumb2.
+ * For thumb1, use low register (r0-r7), specified by constraint "l"
+ * Otherwise, use general registers, specified by constraint "r" */
+#if defined (__thumb__) && !defined (__thumb2__)
+#define __CMSIS_GCC_OUT_REG(r) "=l" (r)
+#define __CMSIS_GCC_RW_REG(r) "+l" (r)
+#define __CMSIS_GCC_USE_REG(r) "l" (r)
+#else
+#define __CMSIS_GCC_OUT_REG(r) "=r" (r)
+#define __CMSIS_GCC_RW_REG(r) "+r" (r)
+#define __CMSIS_GCC_USE_REG(r) "r" (r)
+#endif
+
+/**
+  \brief   No Operation
+  \details No Operation does nothing. This instruction can be used for code alignment purposes.
+ */
+#define __NOP          __builtin_arm_nop
+
+/**
+  \brief   Wait For Interrupt
+  \details Wait For Interrupt is a hint instruction that suspends execution until one of a number of events occurs.
+ */
+#define __WFI          __builtin_arm_wfi
+
+
+/**
+  \brief   Wait For Event
+  \details Wait For Event is a hint instruction that permits the processor to enter
+           a low-power state until one of a number of events occurs.
+ */
+#define __WFE          __builtin_arm_wfe
+
+
+/**
+  \brief   Send Event
+  \details Send Event is a hint instruction. It causes an event to be signaled to the CPU.
+ */
+#define __SEV          __builtin_arm_sev
+
+
+/**
+  \brief   Instruction Synchronization Barrier
+  \details Instruction Synchronization Barrier flushes the pipeline in the processor,
+           so that all instructions following the ISB are fetched from cache or memory,
+           after the instruction has been completed.
+ */
+#define __ISB()        __builtin_arm_isb(0xF)
+
+/**
+  \brief   Data Synchronization Barrier
+  \details Acts as a special kind of Data Memory Barrier.
+           It completes when all explicit memory accesses before this instruction complete.
+ */
+#define __DSB()        __builtin_arm_dsb(0xF)
+
+
+/**
+  \brief   Data Memory Barrier
+  \details Ensures the apparent order of the explicit memory operations before
+           and after the instruction, without ensuring their completion.
+ */
+#define __DMB()        __builtin_arm_dmb(0xF)
+
+
+/**
+  \brief   Reverse byte order (32 bit)
+  \details Reverses the byte order in unsigned integer value. For example, 0x12345678 becomes 0x78563412.
+  \param [in]    value  Value to reverse
+  \return               Reversed value
+ */
+#define __REV(value)   __builtin_bswap32(value)
+
+
+/**
+  \brief   Reverse byte order (16 bit)
+  \details Reverses the byte order within each halfword of a word. For example, 0x12345678 becomes 0x34127856.
+  \param [in]    value  Value to reverse
+  \return               Reversed value
+ */
+#define __REV16(value) __ROR(__REV(value), 16)
+
+
+/**
+  \brief   Reverse byte order (16 bit)
+  \details Reverses the byte order in a 16-bit value and returns the signed 16-bit result. For example, 0x0080 becomes 0x8000.
+  \param [in]    value  Value to reverse
+  \return               Reversed value
+ */
+#define __REVSH(value) (int16_t)__builtin_bswap16(value)
+
+
+/**
+  \brief   Rotate Right in unsigned value (32 bit)
+  \details Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits.
+  \param [in]    op1  Value to rotate
+  \param [in]    op2  Number of Bits to rotate
+  \return               Rotated value
+ */
+__STATIC_FORCEINLINE uint32_t __ROR(uint32_t op1, uint32_t op2)
+{
+  op2 %= 32U;
+  if (op2 == 0U)
+  {
+    return op1;
+  }
+  return (op1 >> op2) | (op1 << (32U - op2));
+}
+
+
+/**
+  \brief   Breakpoint
+  \details Causes the processor to enter Debug state.
+           Debug tools can use this to investigate system state when the instruction at a particular address is reached.
+  \param [in]    value  is ignored by the processor.
+                 If required, a debugger can use it to store additional information about the breakpoint.
+ */
+#define __BKPT(value)     __ASM volatile ("bkpt "#value)
+
+
+/**
+  \brief   Reverse bit order of value
+  \details Reverses the bit order of the given value.
+  \param [in]    value  Value to reverse
+  \return               Reversed value
+ */
+#define __RBIT            __builtin_arm_rbit
+
+/**
+  \brief   Count leading zeros
+  \details Counts the number of leading zeros of a data value.
+  \param [in]  value  Value to count the leading zeros
+  \return             number of leading zeros in value
+ */
+__STATIC_FORCEINLINE uint8_t __CLZ(uint32_t value)
+{
+  /* Even though __builtin_clz produces a CLZ instruction on ARM, formally
+     __builtin_clz(0) is undefined behaviour, so handle this case specially.
+     This guarantees ARM-compatible results if happening to compile on a non-ARM
+     target, and ensures the compiler doesn't decide to activate any
+     optimisations using the logic "value was passed to __builtin_clz, so it
+     is non-zero".
+     ARM Compiler 6.10 and possibly earlier will optimise this test away, leaving a
+     single CLZ instruction.
+   */
+  if (value == 0U)
+  {
+    return 32U;
+  }
+  return __builtin_clz(value);
+}
+
+
+#if ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+     (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+     (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+     (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    )
+/**
+  \brief   LDR Exclusive (8 bit)
+  \details Executes a exclusive LDR instruction for 8 bit value.
+  \param [in]    ptr  Pointer to data
+  \return             value of type uint8_t at (*ptr)
+ */
+#define __LDREXB        (uint8_t)__builtin_arm_ldrex
+
+
+/**
+  \brief   LDR Exclusive (16 bit)
+  \details Executes a exclusive LDR instruction for 16 bit values.
+  \param [in]    ptr  Pointer to data
+  \return        value of type uint16_t at (*ptr)
+ */
+#define __LDREXH        (uint16_t)__builtin_arm_ldrex
+
+
+/**
+  \brief   LDR Exclusive (32 bit)
+  \details Executes a exclusive LDR instruction for 32 bit values.
+  \param [in]    ptr  Pointer to data
+  \return        value of type uint32_t at (*ptr)
+ */
+#define __LDREXW        (uint32_t)__builtin_arm_ldrex
+
+
+/**
+  \brief   STR Exclusive (8 bit)
+  \details Executes a exclusive STR instruction for 8 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+  \return          0  Function succeeded
+  \return          1  Function failed
+ */
+#define __STREXB        (uint32_t)__builtin_arm_strex
+
+
+/**
+  \brief   STR Exclusive (16 bit)
+  \details Executes a exclusive STR instruction for 16 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+  \return          0  Function succeeded
+  \return          1  Function failed
+ */
+#define __STREXH        (uint32_t)__builtin_arm_strex
+
+
+/**
+  \brief   STR Exclusive (32 bit)
+  \details Executes a exclusive STR instruction for 32 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+  \return          0  Function succeeded
+  \return          1  Function failed
+ */
+#define __STREXW        (uint32_t)__builtin_arm_strex
+
+
+/**
+  \brief   Remove the exclusive lock
+  \details Removes the exclusive lock which is created by LDREX.
+ */
+#define __CLREX             __builtin_arm_clrex
+
+#endif /* ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+           (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+           (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+           (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    ) */
+
+
+#if ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+     (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+     (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    )
+
+/**
+  \brief   Signed Saturate
+  \details Saturates a signed value.
+  \param [in]  value  Value to be saturated
+  \param [in]    sat  Bit position to saturate to (1..32)
+  \return             Saturated value
+ */
+#define __SSAT             __builtin_arm_ssat
+
+
+/**
+  \brief   Unsigned Saturate
+  \details Saturates an unsigned value.
+  \param [in]  value  Value to be saturated
+  \param [in]    sat  Bit position to saturate to (0..31)
+  \return             Saturated value
+ */
+#define __USAT             __builtin_arm_usat
+
+
+/**
+  \brief   Rotate Right with Extend (32 bit)
+  \details Moves each bit of a bitstring right by one bit.
+           The carry input is shifted in at the left end of the bitstring.
+  \param [in]    value  Value to rotate
+  \return               Rotated value
+ */
+__STATIC_FORCEINLINE uint32_t __RRX(uint32_t value)
+{
+  uint32_t result;
+
+  __ASM volatile ("rrx %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) );
+  return(result);
+}
+
+
+/**
+  \brief   LDRT Unprivileged (8 bit)
+  \details Executes a Unprivileged LDRT instruction for 8 bit value.
+  \param [in]    ptr  Pointer to data
+  \return             value of type uint8_t at (*ptr)
+ */
+__STATIC_FORCEINLINE uint8_t __LDRBT(volatile uint8_t *ptr)
+{
+  uint32_t result;
+
+  __ASM volatile ("ldrbt %0, %1" : "=r" (result) : "Q" (*ptr) );
+  return ((uint8_t) result);    /* Add explicit type cast here */
+}
+
+
+/**
+  \brief   LDRT Unprivileged (16 bit)
+  \details Executes a Unprivileged LDRT instruction for 16 bit values.
+  \param [in]    ptr  Pointer to data
+  \return        value of type uint16_t at (*ptr)
+ */
+__STATIC_FORCEINLINE uint16_t __LDRHT(volatile uint16_t *ptr)
+{
+  uint32_t result;
+
+  __ASM volatile ("ldrht %0, %1" : "=r" (result) : "Q" (*ptr) );
+  return ((uint16_t) result);    /* Add explicit type cast here */
+}
+
+
+/**
+  \brief   LDRT Unprivileged (32 bit)
+  \details Executes a Unprivileged LDRT instruction for 32 bit values.
+  \param [in]    ptr  Pointer to data
+  \return        value of type uint32_t at (*ptr)
+ */
+__STATIC_FORCEINLINE uint32_t __LDRT(volatile uint32_t *ptr)
+{
+  uint32_t result;
+
+  __ASM volatile ("ldrt %0, %1" : "=r" (result) : "Q" (*ptr) );
+  return(result);
+}
+
+
+/**
+  \brief   STRT Unprivileged (8 bit)
+  \details Executes a Unprivileged STRT instruction for 8 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+ */
+__STATIC_FORCEINLINE void __STRBT(uint8_t value, volatile uint8_t *ptr)
+{
+  __ASM volatile ("strbt %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
+}
+
+
+/**
+  \brief   STRT Unprivileged (16 bit)
+  \details Executes a Unprivileged STRT instruction for 16 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+ */
+__STATIC_FORCEINLINE void __STRHT(uint16_t value, volatile uint16_t *ptr)
+{
+  __ASM volatile ("strht %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
+}
+
+
+/**
+  \brief   STRT Unprivileged (32 bit)
+  \details Executes a Unprivileged STRT instruction for 32 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+ */
+__STATIC_FORCEINLINE void __STRT(uint32_t value, volatile uint32_t *ptr)
+{
+  __ASM volatile ("strt %1, %0" : "=Q" (*ptr) : "r" (value) );
+}
+
+#else  /* ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+           (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+           (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    ) */
+
+/**
+  \brief   Signed Saturate
+  \details Saturates a signed value.
+  \param [in]  value  Value to be saturated
+  \param [in]    sat  Bit position to saturate to (1..32)
+  \return             Saturated value
+ */
+__STATIC_FORCEINLINE int32_t __SSAT(int32_t val, uint32_t sat)
+{
+  if ((sat >= 1U) && (sat <= 32U))
+  {
+    const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U);
+    const int32_t min = -1 - max ;
+    if (val > max)
+    {
+      return max;
+    }
+    else if (val < min)
+    {
+      return min;
+    }
+  }
+  return val;
+}
+
+/**
+  \brief   Unsigned Saturate
+  \details Saturates an unsigned value.
+  \param [in]  value  Value to be saturated
+  \param [in]    sat  Bit position to saturate to (0..31)
+  \return             Saturated value
+ */
+__STATIC_FORCEINLINE uint32_t __USAT(int32_t val, uint32_t sat)
+{
+  if (sat <= 31U)
+  {
+    const uint32_t max = ((1U << sat) - 1U);
+    if (val > (int32_t)max)
+    {
+      return max;
+    }
+    else if (val < 0)
+    {
+      return 0U;
+    }
+  }
+  return (uint32_t)val;
+}
+
+#endif /* ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+           (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+           (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    ) */
+
+
+#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+     (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    )
+/**
+  \brief   Load-Acquire (8 bit)
+  \details Executes a LDAB instruction for 8 bit value.
+  \param [in]    ptr  Pointer to data
+  \return             value of type uint8_t at (*ptr)
+ */
+__STATIC_FORCEINLINE uint8_t __LDAB(volatile uint8_t *ptr)
+{
+  uint32_t result;
+
+  __ASM volatile ("ldab %0, %1" : "=r" (result) : "Q" (*ptr) );
+  return ((uint8_t) result);
+}
+
+
+/**
+  \brief   Load-Acquire (16 bit)
+  \details Executes a LDAH instruction for 16 bit values.
+  \param [in]    ptr  Pointer to data
+  \return        value of type uint16_t at (*ptr)
+ */
+__STATIC_FORCEINLINE uint16_t __LDAH(volatile uint16_t *ptr)
+{
+  uint32_t result;
+
+  __ASM volatile ("ldah %0, %1" : "=r" (result) : "Q" (*ptr) );
+  return ((uint16_t) result);
+}
+
+
+/**
+  \brief   Load-Acquire (32 bit)
+  \details Executes a LDA instruction for 32 bit values.
+  \param [in]    ptr  Pointer to data
+  \return        value of type uint32_t at (*ptr)
+ */
+__STATIC_FORCEINLINE uint32_t __LDA(volatile uint32_t *ptr)
+{
+  uint32_t result;
+
+  __ASM volatile ("lda %0, %1" : "=r" (result) : "Q" (*ptr) );
+  return(result);
+}
+
+
+/**
+  \brief   Store-Release (8 bit)
+  \details Executes a STLB instruction for 8 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+ */
+__STATIC_FORCEINLINE void __STLB(uint8_t value, volatile uint8_t *ptr)
+{
+  __ASM volatile ("stlb %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
+}
+
+
+/**
+  \brief   Store-Release (16 bit)
+  \details Executes a STLH instruction for 16 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+ */
+__STATIC_FORCEINLINE void __STLH(uint16_t value, volatile uint16_t *ptr)
+{
+  __ASM volatile ("stlh %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
+}
+
+
+/**
+  \brief   Store-Release (32 bit)
+  \details Executes a STL instruction for 32 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+ */
+__STATIC_FORCEINLINE void __STL(uint32_t value, volatile uint32_t *ptr)
+{
+  __ASM volatile ("stl %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
+}
+
+
+/**
+  \brief   Load-Acquire Exclusive (8 bit)
+  \details Executes a LDAB exclusive instruction for 8 bit value.
+  \param [in]    ptr  Pointer to data
+  \return             value of type uint8_t at (*ptr)
+ */
+#define     __LDAEXB                 (uint8_t)__builtin_arm_ldaex
+
+
+/**
+  \brief   Load-Acquire Exclusive (16 bit)
+  \details Executes a LDAH exclusive instruction for 16 bit values.
+  \param [in]    ptr  Pointer to data
+  \return        value of type uint16_t at (*ptr)
+ */
+#define     __LDAEXH                 (uint16_t)__builtin_arm_ldaex
+
+
+/**
+  \brief   Load-Acquire Exclusive (32 bit)
+  \details Executes a LDA exclusive instruction for 32 bit values.
+  \param [in]    ptr  Pointer to data
+  \return        value of type uint32_t at (*ptr)
+ */
+#define     __LDAEX                  (uint32_t)__builtin_arm_ldaex
+
+
+/**
+  \brief   Store-Release Exclusive (8 bit)
+  \details Executes a STLB exclusive instruction for 8 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+  \return          0  Function succeeded
+  \return          1  Function failed
+ */
+#define     __STLEXB                 (uint32_t)__builtin_arm_stlex
+
+
+/**
+  \brief   Store-Release Exclusive (16 bit)
+  \details Executes a STLH exclusive instruction for 16 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+  \return          0  Function succeeded
+  \return          1  Function failed
+ */
+#define     __STLEXH                 (uint32_t)__builtin_arm_stlex
+
+
+/**
+  \brief   Store-Release Exclusive (32 bit)
+  \details Executes a STL exclusive instruction for 32 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+  \return          0  Function succeeded
+  \return          1  Function failed
+ */
+#define     __STLEX                  (uint32_t)__builtin_arm_stlex
+
+#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+           (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    ) */
+
+/*@}*/ /* end of group CMSIS_Core_InstructionInterface */
+
+
+/* ###################  Compiler specific Intrinsics  ########################### */
+/** \defgroup CMSIS_SIMD_intrinsics CMSIS SIMD Intrinsics
+  Access to dedicated SIMD instructions
+  @{
+*/
+
+#if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1))
+
+#define     __SADD8                 __builtin_arm_sadd8
+#define     __QADD8                 __builtin_arm_qadd8
+#define     __SHADD8                __builtin_arm_shadd8
+#define     __UADD8                 __builtin_arm_uadd8
+#define     __UQADD8                __builtin_arm_uqadd8
+#define     __UHADD8                __builtin_arm_uhadd8
+#define     __SSUB8                 __builtin_arm_ssub8
+#define     __QSUB8                 __builtin_arm_qsub8
+#define     __SHSUB8                __builtin_arm_shsub8
+#define     __USUB8                 __builtin_arm_usub8
+#define     __UQSUB8                __builtin_arm_uqsub8
+#define     __UHSUB8                __builtin_arm_uhsub8
+#define     __SADD16                __builtin_arm_sadd16
+#define     __QADD16                __builtin_arm_qadd16
+#define     __SHADD16               __builtin_arm_shadd16
+#define     __UADD16                __builtin_arm_uadd16
+#define     __UQADD16               __builtin_arm_uqadd16
+#define     __UHADD16               __builtin_arm_uhadd16
+#define     __SSUB16                __builtin_arm_ssub16
+#define     __QSUB16                __builtin_arm_qsub16
+#define     __SHSUB16               __builtin_arm_shsub16
+#define     __USUB16                __builtin_arm_usub16
+#define     __UQSUB16               __builtin_arm_uqsub16
+#define     __UHSUB16               __builtin_arm_uhsub16
+#define     __SASX                  __builtin_arm_sasx
+#define     __QASX                  __builtin_arm_qasx
+#define     __SHASX                 __builtin_arm_shasx
+#define     __UASX                  __builtin_arm_uasx
+#define     __UQASX                 __builtin_arm_uqasx
+#define     __UHASX                 __builtin_arm_uhasx
+#define     __SSAX                  __builtin_arm_ssax
+#define     __QSAX                  __builtin_arm_qsax
+#define     __SHSAX                 __builtin_arm_shsax
+#define     __USAX                  __builtin_arm_usax
+#define     __UQSAX                 __builtin_arm_uqsax
+#define     __UHSAX                 __builtin_arm_uhsax
+#define     __USAD8                 __builtin_arm_usad8
+#define     __USADA8                __builtin_arm_usada8
+#define     __SSAT16                __builtin_arm_ssat16
+#define     __USAT16                __builtin_arm_usat16
+#define     __UXTB16                __builtin_arm_uxtb16
+#define     __UXTAB16               __builtin_arm_uxtab16
+#define     __SXTB16                __builtin_arm_sxtb16
+#define     __SXTAB16               __builtin_arm_sxtab16
+#define     __SMUAD                 __builtin_arm_smuad
+#define     __SMUADX                __builtin_arm_smuadx
+#define     __SMLAD                 __builtin_arm_smlad
+#define     __SMLADX                __builtin_arm_smladx
+#define     __SMLALD                __builtin_arm_smlald
+#define     __SMLALDX               __builtin_arm_smlaldx
+#define     __SMUSD                 __builtin_arm_smusd
+#define     __SMUSDX                __builtin_arm_smusdx
+#define     __SMLSD                 __builtin_arm_smlsd
+#define     __SMLSDX                __builtin_arm_smlsdx
+#define     __SMLSLD                __builtin_arm_smlsld
+#define     __SMLSLDX               __builtin_arm_smlsldx
+#define     __SEL                   __builtin_arm_sel
+#define     __QADD                  __builtin_arm_qadd
+#define     __QSUB                  __builtin_arm_qsub
+
+#define __PKHBT(ARG1,ARG2,ARG3)          ( ((((uint32_t)(ARG1))          ) & 0x0000FFFFUL) |  \
+                                           ((((uint32_t)(ARG2)) << (ARG3)) & 0xFFFF0000UL)  )
+
+#define __PKHTB(ARG1,ARG2,ARG3)          ( ((((uint32_t)(ARG1))          ) & 0xFFFF0000UL) |  \
+                                           ((((uint32_t)(ARG2)) >> (ARG3)) & 0x0000FFFFUL)  )
+
+__STATIC_FORCEINLINE int32_t __SMMLA (int32_t op1, int32_t op2, int32_t op3)
+{
+  int32_t result;
+
+  __ASM volatile ("smmla %0, %1, %2, %3" : "=r" (result): "r"  (op1), "r" (op2), "r" (op3) );
+  return(result);
+}
+
+#endif /* (__ARM_FEATURE_DSP == 1) */
+/*@} end of group CMSIS_SIMD_intrinsics */
+
+
+#endif /* __CMSIS_ARMCLANG_H */
diff --git a/lib/cmsis/inc/cmsis_armcc_V6.h b/lib/cmsis/inc/cmsis_armclang_ltm.h
similarity index 56%
rename from lib/cmsis/inc/cmsis_armcc_V6.h
rename to lib/cmsis/inc/cmsis_armclang_ltm.h
index cd13240ce3602..e4002a3fc4c93 100644
--- a/lib/cmsis/inc/cmsis_armcc_V6.h
+++ b/lib/cmsis/inc/cmsis_armclang_ltm.h
@@ -1,39 +1,115 @@
 /**************************************************************************//**
- * @file     cmsis_armcc_V6.h
- * @brief    CMSIS Cortex-M Core Function/Instruction Header File
- * @version  V4.30
- * @date     20. October 2015
+ * @file     cmsis_armclang_ltm.h
+ * @brief    CMSIS compiler armclang (Arm Compiler 6) header file
+ * @version  V1.0.1
+ * @date     19. March 2019
  ******************************************************************************/
-/* Copyright (c) 2009 - 2015 ARM LIMITED
-
-   All rights reserved.
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-   - Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in the
-     documentation and/or other materials provided with the distribution.
-   - Neither the name of ARM nor the names of its contributors may be used
-     to endorse or promote products derived from this software without
-     specific prior written permission.
-   *
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
-   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-   POSSIBILITY OF SUCH DAMAGE.
-   ---------------------------------------------------------------------------*/
-
-
-#ifndef __CMSIS_ARMCC_V6_H
-#define __CMSIS_ARMCC_V6_H
+/*
+ * Copyright (c) 2018-2019 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*lint -esym(9058, IRQn)*/ /* disable MISRA 2012 Rule 2.4 for IRQn */
+
+#ifndef __CMSIS_ARMCLANG_H
+#define __CMSIS_ARMCLANG_H
+
+#pragma clang system_header   /* treat file as system include file */
+
+#ifndef __ARM_COMPAT_H
+#include <arm_compat.h>    /* Compatibility header for Arm Compiler 5 intrinsics */
+#endif
+
+/* CMSIS compiler specific defines */
+#ifndef   __ASM
+  #define __ASM                                  __asm
+#endif
+#ifndef   __INLINE
+  #define __INLINE                               __inline
+#endif
+#ifndef   __STATIC_INLINE
+  #define __STATIC_INLINE                        static __inline
+#endif
+#ifndef   __STATIC_FORCEINLINE
+  #define __STATIC_FORCEINLINE                   __attribute__((always_inline)) static __inline
+#endif
+#ifndef   __NO_RETURN
+  #define __NO_RETURN                            __attribute__((__noreturn__))
+#endif
+#ifndef   __USED
+  #define __USED                                 __attribute__((used))
+#endif
+#ifndef   __WEAK
+  #define __WEAK                                 __attribute__((weak))
+#endif
+#ifndef   __PACKED
+  #define __PACKED                               __attribute__((packed, aligned(1)))
+#endif
+#ifndef   __PACKED_STRUCT
+  #define __PACKED_STRUCT                        struct __attribute__((packed, aligned(1)))
+#endif
+#ifndef   __PACKED_UNION
+  #define __PACKED_UNION                         union __attribute__((packed, aligned(1)))
+#endif
+#ifndef   __UNALIGNED_UINT32        /* deprecated */
+  #pragma clang diagnostic push
+  #pragma clang diagnostic ignored "-Wpacked"
+/*lint -esym(9058, T_UINT32)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT32 */
+  struct __attribute__((packed)) T_UINT32 { uint32_t v; };
+  #pragma clang diagnostic pop
+  #define __UNALIGNED_UINT32(x)                  (((struct T_UINT32 *)(x))->v)
+#endif
+#ifndef   __UNALIGNED_UINT16_WRITE
+  #pragma clang diagnostic push
+  #pragma clang diagnostic ignored "-Wpacked"
+/*lint -esym(9058, T_UINT16_WRITE)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT16_WRITE */
+  __PACKED_STRUCT T_UINT16_WRITE { uint16_t v; };
+  #pragma clang diagnostic pop
+  #define __UNALIGNED_UINT16_WRITE(addr, val)    (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val))
+#endif
+#ifndef   __UNALIGNED_UINT16_READ
+  #pragma clang diagnostic push
+  #pragma clang diagnostic ignored "-Wpacked"
+/*lint -esym(9058, T_UINT16_READ)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT16_READ */
+  __PACKED_STRUCT T_UINT16_READ { uint16_t v; };
+  #pragma clang diagnostic pop
+  #define __UNALIGNED_UINT16_READ(addr)          (((const struct T_UINT16_READ *)(const void *)(addr))->v)
+#endif
+#ifndef   __UNALIGNED_UINT32_WRITE
+  #pragma clang diagnostic push
+  #pragma clang diagnostic ignored "-Wpacked"
+/*lint -esym(9058, T_UINT32_WRITE)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT32_WRITE */
+  __PACKED_STRUCT T_UINT32_WRITE { uint32_t v; };
+  #pragma clang diagnostic pop
+  #define __UNALIGNED_UINT32_WRITE(addr, val)    (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val))
+#endif
+#ifndef   __UNALIGNED_UINT32_READ
+  #pragma clang diagnostic push
+  #pragma clang diagnostic ignored "-Wpacked"
+/*lint -esym(9058, T_UINT32_READ)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT32_READ */
+  __PACKED_STRUCT T_UINT32_READ { uint32_t v; };
+  #pragma clang diagnostic pop
+  #define __UNALIGNED_UINT32_READ(addr)          (((const struct T_UINT32_READ *)(const void *)(addr))->v)
+#endif
+#ifndef   __ALIGNED
+  #define __ALIGNED(x)                           __attribute__((aligned(x)))
+#endif
+#ifndef   __RESTRICT
+  #define __RESTRICT                             __restrict
+#endif
 
 
 /* ###########################  Core Function Access  ########################### */
@@ -47,10 +123,7 @@
   \details Enables IRQ interrupts by clearing the I-bit in the CPSR.
            Can only be executed in Privileged modes.
  */
-__attribute__((always_inline)) __STATIC_INLINE void __enable_irq(void)
-{
-  __ASM volatile ("cpsie i" : : : "memory");
-}
+/* intrinsic void __enable_irq();  see arm_compat.h */
 
 
 /**
@@ -58,10 +131,7 @@ __attribute__((always_inline)) __STATIC_INLINE void __enable_irq(void)
   \details Disables IRQ interrupts by setting the I-bit in the CPSR.
            Can only be executed in Privileged modes.
  */
-__attribute__((always_inline)) __STATIC_INLINE void __disable_irq(void)
-{
-  __ASM volatile ("cpsid i" : : : "memory");
-}
+/* intrinsic void __disable_irq();  see arm_compat.h */
 
 
 /**
@@ -69,7 +139,7 @@ __attribute__((always_inline)) __STATIC_INLINE void __disable_irq(void)
   \details Returns the content of the Control Register.
   \return               Control Register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __get_CONTROL(void)
+__STATIC_FORCEINLINE uint32_t __get_CONTROL(void)
 {
   uint32_t result;
 
@@ -78,13 +148,13 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_CONTROL(void)
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
 /**
   \brief   Get Control Register (non-secure)
   \details Returns the content of the non-secure Control Register when in secure mode.
   \return               non-secure Control Register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_CONTROL_NS(void)
+__STATIC_FORCEINLINE uint32_t __TZ_get_CONTROL_NS(void)
 {
   uint32_t result;
 
@@ -99,19 +169,19 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_CONTROL_NS(void
   \details Writes the given value to the Control Register.
   \param [in]    control  Control Register value to set
  */
-__attribute__((always_inline)) __STATIC_INLINE void __set_CONTROL(uint32_t control)
+__STATIC_FORCEINLINE void __set_CONTROL(uint32_t control)
 {
   __ASM volatile ("MSR control, %0" : : "r" (control) : "memory");
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
 /**
   \brief   Set Control Register (non-secure)
   \details Writes the given value to the non-secure Control Register when in secure state.
   \param [in]    control  Control Register value to set
  */
-__attribute__((always_inline)) __STATIC_INLINE void __TZ_set_CONTROL_NS(uint32_t control)
+__STATIC_FORCEINLINE void __TZ_set_CONTROL_NS(uint32_t control)
 {
   __ASM volatile ("MSR control_ns, %0" : : "r" (control) : "memory");
 }
@@ -123,7 +193,7 @@ __attribute__((always_inline)) __STATIC_INLINE void __TZ_set_CONTROL_NS(uint32_t
   \details Returns the content of the IPSR Register.
   \return               IPSR Register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __get_IPSR(void)
+__STATIC_FORCEINLINE uint32_t __get_IPSR(void)
 {
   uint32_t result;
 
@@ -132,28 +202,12 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_IPSR(void)
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
-/**
-  \brief   Get IPSR Register (non-secure)
-  \details Returns the content of the non-secure IPSR Register when in secure state.
-  \return               IPSR Register value
- */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_IPSR_NS(void)
-{
-  uint32_t result;
-
-  __ASM volatile ("MRS %0, ipsr_ns" : "=r" (result) );
-  return(result);
-}
-#endif
-
-
 /**
   \brief   Get APSR Register
   \details Returns the content of the APSR Register.
   \return               APSR Register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __get_APSR(void)
+__STATIC_FORCEINLINE uint32_t __get_APSR(void)
 {
   uint32_t result;
 
@@ -162,28 +216,12 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_APSR(void)
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
-/**
-  \brief   Get APSR Register (non-secure)
-  \details Returns the content of the non-secure APSR Register when in secure state.
-  \return               APSR Register value
- */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_APSR_NS(void)
-{
-  uint32_t result;
-
-  __ASM volatile ("MRS %0, apsr_ns" : "=r" (result) );
-  return(result);
-}
-#endif
-
-
 /**
   \brief   Get xPSR Register
   \details Returns the content of the xPSR Register.
   \return               xPSR Register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __get_xPSR(void)
+__STATIC_FORCEINLINE uint32_t __get_xPSR(void)
 {
   uint32_t result;
 
@@ -192,45 +230,29 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_xPSR(void)
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
-/**
-  \brief   Get xPSR Register (non-secure)
-  \details Returns the content of the non-secure xPSR Register when in secure state.
-  \return               xPSR Register value
- */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_xPSR_NS(void)
-{
-  uint32_t result;
-
-  __ASM volatile ("MRS %0, xpsr_ns" : "=r" (result) );
-  return(result);
-}
-#endif
-
-
 /**
   \brief   Get Process Stack Pointer
   \details Returns the current value of the Process Stack Pointer (PSP).
   \return               PSP Register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __get_PSP(void)
+__STATIC_FORCEINLINE uint32_t __get_PSP(void)
 {
-  register uint32_t result;
+  uint32_t result;
 
   __ASM volatile ("MRS %0, psp"  : "=r" (result) );
   return(result);
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
 /**
   \brief   Get Process Stack Pointer (non-secure)
   \details Returns the current value of the non-secure Process Stack Pointer (PSP) when in secure state.
   \return               PSP Register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_PSP_NS(void)
+__STATIC_FORCEINLINE uint32_t __TZ_get_PSP_NS(void)
 {
-  register uint32_t result;
+  uint32_t result;
 
   __ASM volatile ("MRS %0, psp_ns"  : "=r" (result) );
   return(result);
@@ -243,21 +265,21 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_PSP_NS(void)
   \details Assigns the given value to the Process Stack Pointer (PSP).
   \param [in]    topOfProcStack  Process Stack Pointer value to set
  */
-__attribute__((always_inline)) __STATIC_INLINE void __set_PSP(uint32_t topOfProcStack)
+__STATIC_FORCEINLINE void __set_PSP(uint32_t topOfProcStack)
 {
-  __ASM volatile ("MSR psp, %0" : : "r" (topOfProcStack) : "sp");
+  __ASM volatile ("MSR psp, %0" : : "r" (topOfProcStack) : );
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
 /**
   \brief   Set Process Stack Pointer (non-secure)
   \details Assigns the given value to the non-secure Process Stack Pointer (PSP) when in secure state.
   \param [in]    topOfProcStack  Process Stack Pointer value to set
  */
-__attribute__((always_inline)) __STATIC_INLINE void __TZ_set_PSP_NS(uint32_t topOfProcStack)
+__STATIC_FORCEINLINE void __TZ_set_PSP_NS(uint32_t topOfProcStack)
 {
-  __ASM volatile ("MSR psp_ns, %0" : : "r" (topOfProcStack) : "sp");
+  __ASM volatile ("MSR psp_ns, %0" : : "r" (topOfProcStack) : );
 }
 #endif
 
@@ -267,24 +289,24 @@ __attribute__((always_inline)) __STATIC_INLINE void __TZ_set_PSP_NS(uint32_t top
   \details Returns the current value of the Main Stack Pointer (MSP).
   \return               MSP Register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __get_MSP(void)
+__STATIC_FORCEINLINE uint32_t __get_MSP(void)
 {
-  register uint32_t result;
+  uint32_t result;
 
   __ASM volatile ("MRS %0, msp" : "=r" (result) );
   return(result);
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
 /**
   \brief   Get Main Stack Pointer (non-secure)
   \details Returns the current value of the non-secure Main Stack Pointer (MSP) when in secure state.
   \return               MSP Register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_MSP_NS(void)
+__STATIC_FORCEINLINE uint32_t __TZ_get_MSP_NS(void)
 {
-  register uint32_t result;
+  uint32_t result;
 
   __ASM volatile ("MRS %0, msp_ns" : "=r" (result) );
   return(result);
@@ -297,21 +319,48 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_MSP_NS(void)
   \details Assigns the given value to the Main Stack Pointer (MSP).
   \param [in]    topOfMainStack  Main Stack Pointer value to set
  */
-__attribute__((always_inline)) __STATIC_INLINE void __set_MSP(uint32_t topOfMainStack)
+__STATIC_FORCEINLINE void __set_MSP(uint32_t topOfMainStack)
 {
-  __ASM volatile ("MSR msp, %0" : : "r" (topOfMainStack) : "sp");
+  __ASM volatile ("MSR msp, %0" : : "r" (topOfMainStack) : );
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
 /**
   \brief   Set Main Stack Pointer (non-secure)
   \details Assigns the given value to the non-secure Main Stack Pointer (MSP) when in secure state.
   \param [in]    topOfMainStack  Main Stack Pointer value to set
  */
-__attribute__((always_inline)) __STATIC_INLINE void __TZ_set_MSP_NS(uint32_t topOfMainStack)
+__STATIC_FORCEINLINE void __TZ_set_MSP_NS(uint32_t topOfMainStack)
+{
+  __ASM volatile ("MSR msp_ns, %0" : : "r" (topOfMainStack) : );
+}
+#endif
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Stack Pointer (non-secure)
+  \details Returns the current value of the non-secure Stack Pointer (SP) when in secure state.
+  \return               SP Register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_SP_NS(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, sp_ns" : "=r" (result) );
+  return(result);
+}
+
+
+/**
+  \brief   Set Stack Pointer (non-secure)
+  \details Assigns the given value to the non-secure Stack Pointer (SP) when in secure state.
+  \param [in]    topOfStack  Stack Pointer value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_SP_NS(uint32_t topOfStack)
 {
-  __ASM volatile ("MSR msp_ns, %0" : : "r" (topOfMainStack) : "sp");
+  __ASM volatile ("MSR sp_ns, %0" : : "r" (topOfStack) : );
 }
 #endif
 
@@ -321,7 +370,7 @@ __attribute__((always_inline)) __STATIC_INLINE void __TZ_set_MSP_NS(uint32_t top
   \details Returns the current state of the priority mask bit from the Priority Mask Register.
   \return               Priority Mask value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __get_PRIMASK(void)
+__STATIC_FORCEINLINE uint32_t __get_PRIMASK(void)
 {
   uint32_t result;
 
@@ -330,13 +379,13 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_PRIMASK(void)
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
 /**
   \brief   Get Priority Mask (non-secure)
   \details Returns the current state of the non-secure priority mask bit from the Priority Mask Register when in secure state.
   \return               Priority Mask value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_PRIMASK_NS(void)
+__STATIC_FORCEINLINE uint32_t __TZ_get_PRIMASK_NS(void)
 {
   uint32_t result;
 
@@ -351,36 +400,34 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_PRIMASK_NS(void
   \details Assigns the given value to the Priority Mask Register.
   \param [in]    priMask  Priority Mask
  */
-__attribute__((always_inline)) __STATIC_INLINE void __set_PRIMASK(uint32_t priMask)
+__STATIC_FORCEINLINE void __set_PRIMASK(uint32_t priMask)
 {
   __ASM volatile ("MSR primask, %0" : : "r" (priMask) : "memory");
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
 /**
   \brief   Set Priority Mask (non-secure)
   \details Assigns the given value to the non-secure Priority Mask Register when in secure state.
   \param [in]    priMask  Priority Mask
  */
-__attribute__((always_inline)) __STATIC_INLINE void __TZ_set_PRIMASK_NS(uint32_t priMask)
+__STATIC_FORCEINLINE void __TZ_set_PRIMASK_NS(uint32_t priMask)
 {
   __ASM volatile ("MSR primask_ns, %0" : : "r" (priMask) : "memory");
 }
 #endif
 
 
-#if ((__ARM_ARCH_7M__ == 1U) || (__ARM_ARCH_7EM__ == 1U) || (__ARM_ARCH_8M__ == 1U))  /* ToDo:  ARMCC_V6: check if this is ok for cortex >=3 */
-
+#if ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+     (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+     (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    )
 /**
   \brief   Enable FIQ
   \details Enables FIQ interrupts by clearing the F-bit in the CPSR.
            Can only be executed in Privileged modes.
  */
-__attribute__((always_inline)) __STATIC_INLINE void __enable_fault_irq(void)
-{
-  __ASM volatile ("cpsie f" : : : "memory");
-}
+#define __enable_fault_irq                __enable_fiq   /* see arm_compat.h */
 
 
 /**
@@ -388,10 +435,7 @@ __attribute__((always_inline)) __STATIC_INLINE void __enable_fault_irq(void)
   \details Disables FIQ interrupts by setting the F-bit in the CPSR.
            Can only be executed in Privileged modes.
  */
-__attribute__((always_inline)) __STATIC_INLINE void __disable_fault_irq(void)
-{
-  __ASM volatile ("cpsid f" : : : "memory");
-}
+#define __disable_fault_irq               __disable_fiq   /* see arm_compat.h */
 
 
 /**
@@ -399,7 +443,7 @@ __attribute__((always_inline)) __STATIC_INLINE void __disable_fault_irq(void)
   \details Returns the current value of the Base Priority register.
   \return               Base Priority register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __get_BASEPRI(void)
+__STATIC_FORCEINLINE uint32_t __get_BASEPRI(void)
 {
   uint32_t result;
 
@@ -408,13 +452,13 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_BASEPRI(void)
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
 /**
   \brief   Get Base Priority (non-secure)
   \details Returns the current value of the non-secure Base Priority register when in secure state.
   \return               Base Priority register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_BASEPRI_NS(void)
+__STATIC_FORCEINLINE uint32_t __TZ_get_BASEPRI_NS(void)
 {
   uint32_t result;
 
@@ -429,21 +473,21 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_BASEPRI_NS(void
   \details Assigns the given value to the Base Priority register.
   \param [in]    basePri  Base Priority value to set
  */
-__attribute__((always_inline)) __STATIC_INLINE void __set_BASEPRI(uint32_t value)
+__STATIC_FORCEINLINE void __set_BASEPRI(uint32_t basePri)
 {
-  __ASM volatile ("MSR basepri, %0" : : "r" (value) : "memory");
+  __ASM volatile ("MSR basepri, %0" : : "r" (basePri) : "memory");
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
 /**
   \brief   Set Base Priority (non-secure)
   \details Assigns the given value to the non-secure Base Priority register when in secure state.
   \param [in]    basePri  Base Priority value to set
  */
-__attribute__((always_inline)) __STATIC_INLINE void __TZ_set_BASEPRI_NS(uint32_t value)
+__STATIC_FORCEINLINE void __TZ_set_BASEPRI_NS(uint32_t basePri)
 {
-  __ASM volatile ("MSR basepri_ns, %0" : : "r" (value) : "memory");
+  __ASM volatile ("MSR basepri_ns, %0" : : "r" (basePri) : "memory");
 }
 #endif
 
@@ -454,32 +498,18 @@ __attribute__((always_inline)) __STATIC_INLINE void __TZ_set_BASEPRI_NS(uint32_t
            or the new value increases the BASEPRI priority level.
   \param [in]    basePri  Base Priority value to set
  */
-__attribute__((always_inline)) __STATIC_INLINE void __set_BASEPRI_MAX(uint32_t value)
+__STATIC_FORCEINLINE void __set_BASEPRI_MAX(uint32_t basePri)
 {
-  __ASM volatile ("MSR basepri_max, %0" : : "r" (value) : "memory");
+  __ASM volatile ("MSR basepri_max, %0" : : "r" (basePri) : "memory");
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
-/**
-  \brief   Set Base Priority with condition (non_secure)
-  \details Assigns the given value to the non-secure Base Priority register when in secure state only if BASEPRI masking is disabled,
-	       or the new value increases the BASEPRI priority level.
-  \param [in]    basePri  Base Priority value to set
- */
-__attribute__((always_inline)) __STATIC_INLINE void __TZ_set_BASEPRI_MAX_NS(uint32_t value)
-{
-  __ASM volatile ("MSR basepri_max_ns, %0" : : "r" (value) : "memory");
-}
-#endif
-
-
 /**
   \brief   Get Fault Mask
   \details Returns the current value of the Fault Mask register.
   \return               Fault Mask register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __get_FAULTMASK(void)
+__STATIC_FORCEINLINE uint32_t __get_FAULTMASK(void)
 {
   uint32_t result;
 
@@ -488,13 +518,13 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __get_FAULTMASK(void)
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
 /**
   \brief   Get Fault Mask (non-secure)
   \details Returns the current value of the non-secure Fault Mask register when in secure state.
   \return               Fault Mask register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_FAULTMASK_NS(void)
+__STATIC_FORCEINLINE uint32_t __TZ_get_FAULTMASK_NS(void)
 {
   uint32_t result;
 
@@ -509,223 +539,233 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_FAULTMASK_NS(vo
   \details Assigns the given value to the Fault Mask register.
   \param [in]    faultMask  Fault Mask value to set
  */
-__attribute__((always_inline)) __STATIC_INLINE void __set_FAULTMASK(uint32_t faultMask)
+__STATIC_FORCEINLINE void __set_FAULTMASK(uint32_t faultMask)
 {
   __ASM volatile ("MSR faultmask, %0" : : "r" (faultMask) : "memory");
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U)
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
 /**
   \brief   Set Fault Mask (non-secure)
   \details Assigns the given value to the non-secure Fault Mask register when in secure state.
   \param [in]    faultMask  Fault Mask value to set
  */
-__attribute__((always_inline)) __STATIC_INLINE void __TZ_set_FAULTMASK_NS(uint32_t faultMask)
+__STATIC_FORCEINLINE void __TZ_set_FAULTMASK_NS(uint32_t faultMask)
 {
   __ASM volatile ("MSR faultmask_ns, %0" : : "r" (faultMask) : "memory");
 }
 #endif
 
+#endif /* ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+           (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+           (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    ) */
 
-#endif /* ((__ARM_ARCH_7M__ == 1U) || (__ARM_ARCH_8M__ == 1U)) */
 
-
-#if (__ARM_ARCH_8M__ == 1U)
+#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+     (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    )
 
 /**
   \brief   Get Process Stack Pointer Limit
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence zero is returned always in non-secure
+  mode.
+  
   \details Returns the current value of the Process Stack Pointer Limit (PSPLIM).
   \return               PSPLIM Register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __get_PSPLIM(void)
+__STATIC_FORCEINLINE uint32_t __get_PSPLIM(void)
 {
-  register uint32_t result;
-
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+    (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+    // without main extensions, the non-secure PSPLIM is RAZ/WI
+  return 0U;
+#else
+  uint32_t result;
   __ASM volatile ("MRS %0, psplim"  : "=r" (result) );
-  return(result);
+  return result;
+#endif
 }
 
-
-#if  (__ARM_FEATURE_CMSE == 3U) && (__ARM_ARCH_PROFILE == 'M')     /* ToDo:  ARMCC_V6: check predefined macro for mainline */
+#if (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3))
 /**
   \brief   Get Process Stack Pointer Limit (non-secure)
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence zero is returned always in non-secure
+  mode.
+
   \details Returns the current value of the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state.
   \return               PSPLIM Register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_PSPLIM_NS(void)
+__STATIC_FORCEINLINE uint32_t __TZ_get_PSPLIM_NS(void)
 {
-  register uint32_t result;
-
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)))
+  // without main extensions, the non-secure PSPLIM is RAZ/WI
+  return 0U;
+#else
+  uint32_t result;
   __ASM volatile ("MRS %0, psplim_ns"  : "=r" (result) );
-  return(result);
+  return result;
+#endif
 }
 #endif
 
 
 /**
   \brief   Set Process Stack Pointer Limit
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence the write is silently ignored in non-secure
+  mode.
+  
   \details Assigns the given value to the Process Stack Pointer Limit (PSPLIM).
   \param [in]    ProcStackPtrLimit  Process Stack Pointer Limit value to set
  */
-__attribute__((always_inline)) __STATIC_INLINE void __set_PSPLIM(uint32_t ProcStackPtrLimit)
+__STATIC_FORCEINLINE void __set_PSPLIM(uint32_t ProcStackPtrLimit)
 {
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+    (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+  // without main extensions, the non-secure PSPLIM is RAZ/WI
+  (void)ProcStackPtrLimit;
+#else
   __ASM volatile ("MSR psplim, %0" : : "r" (ProcStackPtrLimit));
+#endif
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U) && (__ARM_ARCH_PROFILE == 'M')     /* ToDo:  ARMCC_V6: check predefined macro for mainline */
+#if (defined (__ARM_FEATURE_CMSE  ) && (__ARM_FEATURE_CMSE   == 3))
 /**
   \brief   Set Process Stack Pointer (non-secure)
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence the write is silently ignored in non-secure
+  mode.
+
   \details Assigns the given value to the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state.
   \param [in]    ProcStackPtrLimit  Process Stack Pointer Limit value to set
  */
-__attribute__((always_inline)) __STATIC_INLINE void __TZ_set_PSPLIM_NS(uint32_t ProcStackPtrLimit)
+__STATIC_FORCEINLINE void __TZ_set_PSPLIM_NS(uint32_t ProcStackPtrLimit)
 {
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)))
+  // without main extensions, the non-secure PSPLIM is RAZ/WI
+  (void)ProcStackPtrLimit;
+#else
   __ASM volatile ("MSR psplim_ns, %0\n" : : "r" (ProcStackPtrLimit));
+#endif
 }
 #endif
 
 
 /**
   \brief   Get Main Stack Pointer Limit
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence zero is returned always.
+
   \details Returns the current value of the Main Stack Pointer Limit (MSPLIM).
   \return               MSPLIM Register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __get_MSPLIM(void)
+__STATIC_FORCEINLINE uint32_t __get_MSPLIM(void)
 {
-  register uint32_t result;
-
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+    (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+  // without main extensions, the non-secure MSPLIM is RAZ/WI
+  return 0U;
+#else
+  uint32_t result;
   __ASM volatile ("MRS %0, msplim" : "=r" (result) );
-
-  return(result);
+  return result;
+#endif
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U) && (__ARM_ARCH_PROFILE == 'M')     /* ToDo:  ARMCC_V6: check predefined macro for mainline */
+#if (defined (__ARM_FEATURE_CMSE  ) && (__ARM_FEATURE_CMSE   == 3))
 /**
   \brief   Get Main Stack Pointer Limit (non-secure)
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence zero is returned always.
+
   \details Returns the current value of the non-secure Main Stack Pointer Limit(MSPLIM) when in secure state.
   \return               MSPLIM Register value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_MSPLIM_NS(void)
+__STATIC_FORCEINLINE uint32_t __TZ_get_MSPLIM_NS(void)
 {
-  register uint32_t result;
-
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)))
+  // without main extensions, the non-secure MSPLIM is RAZ/WI
+  return 0U;
+#else
+  uint32_t result;
   __ASM volatile ("MRS %0, msplim_ns" : "=r" (result) );
-  return(result);
+  return result;
+#endif
 }
 #endif
 
 
 /**
   \brief   Set Main Stack Pointer Limit
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence the write is silently ignored.
+
   \details Assigns the given value to the Main Stack Pointer Limit (MSPLIM).
   \param [in]    MainStackPtrLimit  Main Stack Pointer Limit value to set
  */
-__attribute__((always_inline)) __STATIC_INLINE void __set_MSPLIM(uint32_t MainStackPtrLimit)
+__STATIC_FORCEINLINE void __set_MSPLIM(uint32_t MainStackPtrLimit)
 {
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+    (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+  // without main extensions, the non-secure MSPLIM is RAZ/WI
+  (void)MainStackPtrLimit;
+#else
   __ASM volatile ("MSR msplim, %0" : : "r" (MainStackPtrLimit));
+#endif
 }
 
 
-#if  (__ARM_FEATURE_CMSE == 3U) && (__ARM_ARCH_PROFILE == 'M')     /* ToDo:  ARMCC_V6: check predefined macro for mainline */
+#if (defined (__ARM_FEATURE_CMSE  ) && (__ARM_FEATURE_CMSE   == 3))
 /**
   \brief   Set Main Stack Pointer Limit (non-secure)
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence the write is silently ignored.
+
   \details Assigns the given value to the non-secure Main Stack Pointer Limit (MSPLIM) when in secure state.
   \param [in]    MainStackPtrLimit  Main Stack Pointer value to set
  */
-__attribute__((always_inline)) __STATIC_INLINE void __TZ_set_MSPLIM_NS(uint32_t MainStackPtrLimit)
+__STATIC_FORCEINLINE void __TZ_set_MSPLIM_NS(uint32_t MainStackPtrLimit)
 {
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)))
+  // without main extensions, the non-secure MSPLIM is RAZ/WI
+  (void)MainStackPtrLimit;
+#else
   __ASM volatile ("MSR msplim_ns, %0" : : "r" (MainStackPtrLimit));
+#endif
 }
 #endif
 
-#endif /* (__ARM_ARCH_8M__ == 1U) */
-
-
-#if ((__ARM_ARCH_7EM__ == 1U) || (__ARM_ARCH_8M__ == 1U))  /* ToDo:  ARMCC_V6: check if this is ok for cortex >=4 */
+#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+           (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    ) */
 
 /**
   \brief   Get FPSCR
-  \details eturns the current value of the Floating Point Status/Control register.
+  \details Returns the current value of the Floating Point Status/Control register.
   \return               Floating Point Status/Control register value
  */
-#define __get_FPSCR      __builtin_arm_get_fpscr
-#if 0
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __get_FPSCR(void)
-{
-#if (__FPU_PRESENT == 1U) && (__FPU_USED == 1U)
-  uint32_t result;
-
-  __ASM volatile ("");                                 /* Empty asm statement works as a scheduling barrier */
-  __ASM volatile ("VMRS %0, fpscr" : "=r" (result) );
-  __ASM volatile ("");
-  return(result);
+#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
+     (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )
+#define __get_FPSCR      (uint32_t)__builtin_arm_get_fpscr
 #else
-   return(0);
-#endif
-}
+#define __get_FPSCR()      ((uint32_t)0U)
 #endif
 
-#if  (__ARM_FEATURE_CMSE == 3U)
-/**
-  \brief   Get FPSCR (non-secure)
-  \details Returns the current value of the non-secure Floating Point Status/Control register when in secure state.
-  \return               Floating Point Status/Control register value
- */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __TZ_get_FPSCR_NS(void)
-{
-#if (__FPU_PRESENT == 1U) && (__FPU_USED == 1U)
-  uint32_t result;
-
-  __ASM volatile ("");                                 /* Empty asm statement works as a scheduling barrier */
-  __ASM volatile ("VMRS %0, fpscr_ns" : "=r" (result) );
-  __ASM volatile ("");
-  return(result);
-#else
-   return(0);
-#endif
-}
-#endif
-
-
 /**
   \brief   Set FPSCR
   \details Assigns the given value to the Floating Point Status/Control register.
   \param [in]    fpscr  Floating Point Status/Control value to set
  */
+#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
+     (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )
 #define __set_FPSCR      __builtin_arm_set_fpscr
-#if 0
-__attribute__((always_inline)) __STATIC_INLINE void __set_FPSCR(uint32_t fpscr)
-{
-#if (__FPU_PRESENT == 1U) && (__FPU_USED == 1U)
-  __ASM volatile ("");                                 /* Empty asm statement works as a scheduling barrier */
-  __ASM volatile ("VMSR fpscr, %0" : : "r" (fpscr) : "vfpcc");
-  __ASM volatile ("");
-#endif
-}
-#endif
-
-#if  (__ARM_FEATURE_CMSE == 3U)
-/**
-  \brief   Set FPSCR (non-secure)
-  \details Assigns the given value to the non-secure Floating Point Status/Control register when in secure state.
-  \param [in]    fpscr  Floating Point Status/Control value to set
- */
-__attribute__((always_inline)) __STATIC_INLINE void __TZ_set_FPSCR_NS(uint32_t fpscr)
-{
-#if (__FPU_PRESENT == 1U) && (__FPU_USED == 1U)
-  __ASM volatile ("");                                 /* Empty asm statement works as a scheduling barrier */
-  __ASM volatile ("VMSR fpscr_ns, %0" : : "r" (fpscr) : "vfpcc");
-  __ASM volatile ("");
-#endif
-}
+#else
+#define __set_FPSCR(x)      ((void)(x))
 #endif
 
-#endif /* ((__ARM_ARCH_7EM__ == 1U) || (__ARM_ARCH_8M__ == 1U)) */
-
-
 
 /*@} end of CMSIS_Core_RegAccFunctions */
 
@@ -781,14 +821,14 @@ __attribute__((always_inline)) __STATIC_INLINE void __TZ_set_FPSCR_NS(uint32_t f
            so that all instructions following the ISB are fetched from cache or memory,
            after the instruction has been completed.
  */
-#define __ISB()        __builtin_arm_isb(0xF);
+#define __ISB()        __builtin_arm_isb(0xF)
 
 /**
   \brief   Data Synchronization Barrier
   \details Acts as a special kind of Data Memory Barrier.
            It completes when all explicit memory accesses before this instruction complete.
  */
-#define __DSB()        __builtin_arm_dsb(0xF);
+#define __DSB()        __builtin_arm_dsb(0xF)
 
 
 /**
@@ -796,50 +836,34 @@ __attribute__((always_inline)) __STATIC_INLINE void __TZ_set_FPSCR_NS(uint32_t f
   \details Ensures the apparent order of the explicit memory operations before
            and after the instruction, without ensuring their completion.
  */
-#define __DMB()        __builtin_arm_dmb(0xF);
+#define __DMB()        __builtin_arm_dmb(0xF)
 
 
 /**
   \brief   Reverse byte order (32 bit)
-  \details Reverses the byte order in integer value.
+  \details Reverses the byte order in unsigned integer value. For example, 0x12345678 becomes 0x78563412.
   \param [in]    value  Value to reverse
   \return               Reversed value
  */
-#define __REV          __builtin_bswap32
+#define __REV(value)   __builtin_bswap32(value)
 
 
 /**
   \brief   Reverse byte order (16 bit)
-  \details Reverses the byte order in two unsigned short values.
+  \details Reverses the byte order within each halfword of a word. For example, 0x12345678 becomes 0x34127856.
   \param [in]    value  Value to reverse
   \return               Reversed value
  */
-#define __REV16          __builtin_bswap16                           /* ToDo:  ARMCC_V6: check if __builtin_bswap16 could be used */
-#if 0
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __REV16(uint32_t value)
-{
-  uint32_t result;
-
-  __ASM volatile ("rev16 %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) );
-  return(result);
-}
-#endif
+#define __REV16(value) __ROR(__REV(value), 16)
 
 
 /**
-  \brief   Reverse byte order in signed short value
-  \details Reverses the byte order in a signed short value with sign extension to integer.
+  \brief   Reverse byte order (16 bit)
+  \details Reverses the byte order in a 16-bit value and returns the signed 16-bit result. For example, 0x0080 becomes 0x8000.
   \param [in]    value  Value to reverse
   \return               Reversed value
  */
-                                                          /* ToDo:  ARMCC_V6: check if __builtin_bswap16 could be used */
-__attribute__((always_inline)) __STATIC_INLINE int32_t __REVSH(int32_t value)
-{
-  int32_t result;
-
-  __ASM volatile ("revsh %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) );
-  return(result);
-}
+#define __REVSH(value) (int16_t)__builtin_bswap16(value)
 
 
 /**
@@ -849,8 +873,13 @@ __attribute__((always_inline)) __STATIC_INLINE int32_t __REVSH(int32_t value)
   \param [in]    op2  Number of Bits to rotate
   \return               Rotated value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __ROR(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __ROR(uint32_t op1, uint32_t op2)
 {
+  op2 %= 32U;
+  if (op2 == 0U)
+  {
+    return op1;
+  }
   return (op1 >> op2) | (op1 << (32U - op2));
 }
 
@@ -858,11 +887,11 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __ROR(uint32_t op1, uint
 /**
   \brief   Breakpoint
   \details Causes the processor to enter Debug state.
-            Debug tools can use this to investigate system state when the instruction at a particular address is reached.
-    \param [in]    value  is ignored by the processor.
-                   If required, a debugger can use it to store additional information about the breakpoint.
+           Debug tools can use this to investigate system state when the instruction at a particular address is reached.
+  \param [in]    value  is ignored by the processor.
+                 If required, a debugger can use it to store additional information about the breakpoint.
  */
-#define __BKPT(value)                       __ASM volatile ("bkpt "#value)
+#define __BKPT(value)     __ASM volatile ("bkpt "#value)
 
 
 /**
@@ -871,28 +900,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __ROR(uint32_t op1, uint
   \param [in]    value  Value to reverse
   \return               Reversed value
  */
-                                                          /* ToDo:  ARMCC_V6: check if __builtin_arm_rbit is supported */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t value)
-{
-  uint32_t result;
-
-#if ((__ARM_ARCH_7M__ == 1U) || (__ARM_ARCH_7EM__ == 1U) || (__ARM_ARCH_8M__ == 1U))  /* ToDo:  ARMCC_V6: check if this is ok for cortex >=3 */
-   __ASM volatile ("rbit %0, %1" : "=r" (result) : "r" (value) );
-#else
-  int32_t s = 4 /*sizeof(v)*/ * 8 - 1; /* extra shift needed at end */
-
-  result = value;                      /* r will be reversed bits of v; first get LSB of v */
-  for (value >>= 1U; value; value >>= 1U)
-  {
-    result <<= 1U;
-    result |= value & 1U;
-    s--;
-  }
-  result <<= s;                        /* shift when v's highest bits are zero */
-#endif
-  return(result);
-}
-
+#define __RBIT            __builtin_arm_rbit
 
 /**
   \brief   Count leading zeros
@@ -900,11 +908,29 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t value)
   \param [in]  value  Value to count the leading zeros
   \return             number of leading zeros in value
  */
-#define __CLZ             __builtin_clz
-
+__STATIC_FORCEINLINE uint8_t __CLZ(uint32_t value)
+{
+  /* Even though __builtin_clz produces a CLZ instruction on ARM, formally
+     __builtin_clz(0) is undefined behaviour, so handle this case specially.
+     This guarantees ARM-compatible results if happening to compile on a non-ARM
+     target, and ensures the compiler doesn't decide to activate any
+     optimisations using the logic "value was passed to __builtin_clz, so it
+     is non-zero".
+     ARM Compiler 6.10 and possibly earlier will optimise this test away, leaving a
+     single CLZ instruction.
+   */
+  if (value == 0U)
+  {
+    return 32U;
+  }
+  return __builtin_clz(value);
+}
 
-#if ((__ARM_ARCH_7M__ == 1U) || (__ARM_ARCH_7EM__ == 1U) || (__ARM_ARCH_8M__ == 1U))  /* ToDo:  ARMCC_V6: check if this is ok for cortex >=3 */
 
+#if ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+     (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+     (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+     (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    )
 /**
   \brief   LDR Exclusive (8 bit)
   \details Executes a exclusive LDR instruction for 8 bit value.
@@ -971,6 +997,15 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t value)
  */
 #define __CLREX             __builtin_arm_clrex
 
+#endif /* ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+           (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+           (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+           (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    ) */
+
+
+#if ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+     (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+     (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    )
 
 /**
   \brief   Signed Saturate
@@ -979,13 +1014,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t value)
   \param [in]    sat  Bit position to saturate to (1..32)
   \return             Saturated value
  */
-/*#define __SSAT             __builtin_arm_ssat*/
-#define __SSAT(ARG1,ARG2) \
-({                          \
-  int32_t __RES, __ARG1 = (ARG1); \
-  __ASM ("ssat %0, %1, %2" : "=r" (__RES) :  "I" (ARG2), "r" (__ARG1) ); \
-  __RES; \
- })
+#define __SSAT             __builtin_arm_ssat
 
 
 /**
@@ -996,14 +1025,6 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t value)
   \return             Saturated value
  */
 #define __USAT             __builtin_arm_usat
-#if 0
-#define __USAT(ARG1,ARG2) \
-({                          \
-  uint32_t __RES, __ARG1 = (ARG1); \
-  __ASM ("usat %0, %1, %2" : "=r" (__RES) :  "I" (ARG2), "r" (__ARG1) ); \
-  __RES; \
- })
-#endif
 
 
 /**
@@ -1013,7 +1034,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t value)
   \param [in]    value  Value to rotate
   \return               Rotated value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __RRX(uint32_t value)
+__STATIC_FORCEINLINE uint32_t __RRX(uint32_t value)
 {
   uint32_t result;
 
@@ -1028,12 +1049,12 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __RRX(uint32_t value)
   \param [in]    ptr  Pointer to data
   \return             value of type uint8_t at (*ptr)
  */
-__attribute__((always_inline)) __STATIC_INLINE uint8_t __LDRBT(volatile uint8_t *ptr)
+__STATIC_FORCEINLINE uint8_t __LDRBT(volatile uint8_t *ptr)
 {
-    uint32_t result;
+  uint32_t result;
 
-   __ASM volatile ("ldrbt %0, %1" : "=r" (result) : "Q" (*ptr) );
-   return ((uint8_t) result);    /* Add explicit type cast here */
+  __ASM volatile ("ldrbt %0, %1" : "=r" (result) : "Q" (*ptr) );
+  return ((uint8_t) result);    /* Add explicit type cast here */
 }
 
 
@@ -1043,12 +1064,12 @@ __attribute__((always_inline)) __STATIC_INLINE uint8_t __LDRBT(volatile uint8_t
   \param [in]    ptr  Pointer to data
   \return        value of type uint16_t at (*ptr)
  */
-__attribute__((always_inline)) __STATIC_INLINE uint16_t __LDRHT(volatile uint16_t *ptr)
+__STATIC_FORCEINLINE uint16_t __LDRHT(volatile uint16_t *ptr)
 {
-    uint32_t result;
+  uint32_t result;
 
-   __ASM volatile ("ldrht %0, %1" : "=r" (result) : "Q" (*ptr) );
-   return ((uint16_t) result);    /* Add explicit type cast here */
+  __ASM volatile ("ldrht %0, %1" : "=r" (result) : "Q" (*ptr) );
+  return ((uint16_t) result);    /* Add explicit type cast here */
 }
 
 
@@ -1058,12 +1079,12 @@ __attribute__((always_inline)) __STATIC_INLINE uint16_t __LDRHT(volatile uint16_
   \param [in]    ptr  Pointer to data
   \return        value of type uint32_t at (*ptr)
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __LDRT(volatile uint32_t *ptr)
+__STATIC_FORCEINLINE uint32_t __LDRT(volatile uint32_t *ptr)
 {
-    uint32_t result;
+  uint32_t result;
 
-   __ASM volatile ("ldrt %0, %1" : "=r" (result) : "Q" (*ptr) );
-   return(result);
+  __ASM volatile ("ldrt %0, %1" : "=r" (result) : "Q" (*ptr) );
+  return(result);
 }
 
 
@@ -1073,9 +1094,9 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __LDRT(volatile uint32_t
   \param [in]  value  Value to store
   \param [in]    ptr  Pointer to location
  */
-__attribute__((always_inline)) __STATIC_INLINE void __STRBT(uint8_t value, volatile uint8_t *ptr)
+__STATIC_FORCEINLINE void __STRBT(uint8_t value, volatile uint8_t *ptr)
 {
-   __ASM volatile ("strbt %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
+  __ASM volatile ("strbt %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
 }
 
 
@@ -1085,9 +1106,9 @@ __attribute__((always_inline)) __STATIC_INLINE void __STRBT(uint8_t value, volat
   \param [in]  value  Value to store
   \param [in]    ptr  Pointer to location
  */
-__attribute__((always_inline)) __STATIC_INLINE void __STRHT(uint16_t value, volatile uint16_t *ptr)
+__STATIC_FORCEINLINE void __STRHT(uint16_t value, volatile uint16_t *ptr)
 {
-   __ASM volatile ("strht %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
+  __ASM volatile ("strht %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
 }
 
 
@@ -1097,28 +1118,83 @@ __attribute__((always_inline)) __STATIC_INLINE void __STRHT(uint16_t value, vola
   \param [in]  value  Value to store
   \param [in]    ptr  Pointer to location
  */
-__attribute__((always_inline)) __STATIC_INLINE void __STRT(uint32_t value, volatile uint32_t *ptr)
+__STATIC_FORCEINLINE void __STRT(uint32_t value, volatile uint32_t *ptr)
+{
+  __ASM volatile ("strt %1, %0" : "=Q" (*ptr) : "r" (value) );
+}
+
+#else  /* ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+           (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+           (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    ) */
+
+/**
+  \brief   Signed Saturate
+  \details Saturates a signed value.
+  \param [in]  value  Value to be saturated
+  \param [in]    sat  Bit position to saturate to (1..32)
+  \return             Saturated value
+ */
+__STATIC_FORCEINLINE int32_t __SSAT(int32_t val, uint32_t sat)
 {
-   __ASM volatile ("strt %1, %0" : "=Q" (*ptr) : "r" (value) );
+  if ((sat >= 1U) && (sat <= 32U))
+  {
+    const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U);
+    const int32_t min = -1 - max ;
+    if (val > max)
+    {
+      return max;
+    }
+    else if (val < min)
+    {
+      return min;
+    }
+  }
+  return val;
 }
 
-#endif /* ((__ARM_ARCH_7M__ == 1U) || (__ARM_ARCH_7EM__ == 1U) || (__ARM_ARCH_8M__ == 1U)) */
+/**
+  \brief   Unsigned Saturate
+  \details Saturates an unsigned value.
+  \param [in]  value  Value to be saturated
+  \param [in]    sat  Bit position to saturate to (0..31)
+  \return             Saturated value
+ */
+__STATIC_FORCEINLINE uint32_t __USAT(int32_t val, uint32_t sat)
+{
+  if (sat <= 31U)
+  {
+    const uint32_t max = ((1U << sat) - 1U);
+    if (val > (int32_t)max)
+    {
+      return max;
+    }
+    else if (val < 0)
+    {
+      return 0U;
+    }
+  }
+  return (uint32_t)val;
+}
 
+#endif /* ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+           (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+           (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    ) */
 
-#if (__ARM_ARCH_8M__ == 1U)
 
+#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+     (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    )
 /**
   \brief   Load-Acquire (8 bit)
   \details Executes a LDAB instruction for 8 bit value.
   \param [in]    ptr  Pointer to data
   \return             value of type uint8_t at (*ptr)
  */
-__attribute__((always_inline)) __STATIC_INLINE uint8_t __LDAB(volatile uint8_t *ptr)
+__STATIC_FORCEINLINE uint8_t __LDAB(volatile uint8_t *ptr)
 {
-    uint32_t result;
+  uint32_t result;
 
-   __ASM volatile ("ldab %0, %1" : "=r" (result) : "Q" (*ptr) );
-   return ((uint8_t) result);
+  __ASM volatile ("ldab %0, %1" : "=r" (result) : "Q" (*ptr) );
+  return ((uint8_t) result);
 }
 
 
@@ -1128,12 +1204,12 @@ __attribute__((always_inline)) __STATIC_INLINE uint8_t __LDAB(volatile uint8_t *
   \param [in]    ptr  Pointer to data
   \return        value of type uint16_t at (*ptr)
  */
-__attribute__((always_inline)) __STATIC_INLINE uint16_t __LDAH(volatile uint16_t *ptr)
+__STATIC_FORCEINLINE uint16_t __LDAH(volatile uint16_t *ptr)
 {
-    uint32_t result;
+  uint32_t result;
 
-   __ASM volatile ("ldah %0, %1" : "=r" (result) : "Q" (*ptr) );
-   return ((uint16_t) result);
+  __ASM volatile ("ldah %0, %1" : "=r" (result) : "Q" (*ptr) );
+  return ((uint16_t) result);
 }
 
 
@@ -1143,12 +1219,12 @@ __attribute__((always_inline)) __STATIC_INLINE uint16_t __LDAH(volatile uint16_t
   \param [in]    ptr  Pointer to data
   \return        value of type uint32_t at (*ptr)
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __LDA(volatile uint32_t *ptr)
+__STATIC_FORCEINLINE uint32_t __LDA(volatile uint32_t *ptr)
 {
-    uint32_t result;
+  uint32_t result;
 
-   __ASM volatile ("lda %0, %1" : "=r" (result) : "Q" (*ptr) );
-   return(result);
+  __ASM volatile ("lda %0, %1" : "=r" (result) : "Q" (*ptr) );
+  return(result);
 }
 
 
@@ -1158,9 +1234,9 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __LDA(volatile uint32_t
   \param [in]  value  Value to store
   \param [in]    ptr  Pointer to location
  */
-__attribute__((always_inline)) __STATIC_INLINE void __STLB(uint8_t value, volatile uint8_t *ptr)
+__STATIC_FORCEINLINE void __STLB(uint8_t value, volatile uint8_t *ptr)
 {
-   __ASM volatile ("stlb %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
+  __ASM volatile ("stlb %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
 }
 
 
@@ -1170,9 +1246,9 @@ __attribute__((always_inline)) __STATIC_INLINE void __STLB(uint8_t value, volati
   \param [in]  value  Value to store
   \param [in]    ptr  Pointer to location
  */
-__attribute__((always_inline)) __STATIC_INLINE void __STLH(uint16_t value, volatile uint16_t *ptr)
+__STATIC_FORCEINLINE void __STLH(uint16_t value, volatile uint16_t *ptr)
 {
-   __ASM volatile ("stlh %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
+  __ASM volatile ("stlh %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
 }
 
 
@@ -1182,9 +1258,9 @@ __attribute__((always_inline)) __STATIC_INLINE void __STLH(uint16_t value, volat
   \param [in]  value  Value to store
   \param [in]    ptr  Pointer to location
  */
-__attribute__((always_inline)) __STATIC_INLINE void __STL(uint32_t value, volatile uint32_t *ptr)
+__STATIC_FORCEINLINE void __STL(uint32_t value, volatile uint32_t *ptr)
 {
-   __ASM volatile ("stl %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
+  __ASM volatile ("stl %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
 }
 
 
@@ -1247,7 +1323,8 @@ __attribute__((always_inline)) __STATIC_INLINE void __STL(uint32_t value, volati
  */
 #define     __STLEX                  (uint32_t)__builtin_arm_stlex
 
-#endif /* (__ARM_ARCH_8M__ == 1U) */
+#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+           (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    ) */
 
 /*@}*/ /* end of group CMSIS_Core_InstructionInterface */
 
@@ -1258,9 +1335,9 @@ __attribute__((always_inline)) __STATIC_INLINE void __STL(uint32_t value, volati
   @{
 */
 
-#if (__ARM_FEATURE_DSP == 1U)        /* ToDo:  ARMCC_V6: This should be ARCH >= ARMv7-M + SIMD */
+#if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1))
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SADD8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SADD8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1268,7 +1345,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SADD8(uint32_t op1, ui
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __QADD8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __QADD8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1276,7 +1353,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __QADD8(uint32_t op1, ui
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SHADD8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SHADD8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1284,7 +1361,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SHADD8(uint32_t op1, u
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UADD8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UADD8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1292,7 +1369,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UADD8(uint32_t op1, ui
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UQADD8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UQADD8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1300,7 +1377,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UQADD8(uint32_t op1, u
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UHADD8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UHADD8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1309,7 +1386,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UHADD8(uint32_t op1, u
 }
 
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SSUB8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SSUB8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1317,7 +1394,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SSUB8(uint32_t op1, ui
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __QSUB8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __QSUB8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1325,7 +1402,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __QSUB8(uint32_t op1, ui
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SHSUB8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SHSUB8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1333,7 +1410,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SHSUB8(uint32_t op1, u
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __USUB8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __USUB8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1341,7 +1418,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __USUB8(uint32_t op1, ui
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UQSUB8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UQSUB8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1349,7 +1426,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UQSUB8(uint32_t op1, u
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UHSUB8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UHSUB8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1358,7 +1435,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UHSUB8(uint32_t op1, u
 }
 
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SADD16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SADD16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1366,7 +1443,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SADD16(uint32_t op1, u
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __QADD16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __QADD16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1374,7 +1451,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __QADD16(uint32_t op1, u
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SHADD16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SHADD16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1382,7 +1459,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SHADD16(uint32_t op1,
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UADD16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UADD16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1390,7 +1467,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UADD16(uint32_t op1, u
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UQADD16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UQADD16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1398,7 +1475,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UQADD16(uint32_t op1,
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UHADD16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UHADD16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1406,7 +1483,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UHADD16(uint32_t op1,
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SSUB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SSUB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1414,7 +1491,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SSUB16(uint32_t op1, u
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __QSUB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __QSUB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1422,7 +1499,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __QSUB16(uint32_t op1, u
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SHSUB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SHSUB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1430,7 +1507,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SHSUB16(uint32_t op1,
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __USUB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __USUB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1438,7 +1515,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __USUB16(uint32_t op1, u
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UQSUB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UQSUB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1446,7 +1523,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UQSUB16(uint32_t op1,
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UHSUB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UHSUB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1454,7 +1531,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UHSUB16(uint32_t op1,
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SASX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SASX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1462,7 +1539,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SASX(uint32_t op1, uin
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __QASX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __QASX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1470,7 +1547,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __QASX(uint32_t op1, uin
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SHASX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SHASX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1478,7 +1555,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SHASX(uint32_t op1, ui
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UASX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UASX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1486,7 +1563,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UASX(uint32_t op1, uin
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UQASX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UQASX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1494,7 +1571,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UQASX(uint32_t op1, ui
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UHASX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UHASX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1502,7 +1579,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UHASX(uint32_t op1, ui
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SSAX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SSAX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1510,7 +1587,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SSAX(uint32_t op1, uin
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __QSAX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __QSAX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1518,7 +1595,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __QSAX(uint32_t op1, uin
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SHSAX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SHSAX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1526,7 +1603,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SHSAX(uint32_t op1, ui
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __USAX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __USAX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1534,7 +1611,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __USAX(uint32_t op1, uin
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UQSAX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UQSAX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1542,7 +1619,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UQSAX(uint32_t op1, ui
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UHSAX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UHSAX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1550,7 +1627,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UHSAX(uint32_t op1, ui
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __USAD8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __USAD8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1558,7 +1635,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __USAD8(uint32_t op1, ui
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __USADA8(uint32_t op1, uint32_t op2, uint32_t op3)
+__STATIC_FORCEINLINE uint32_t __USADA8(uint32_t op1, uint32_t op2, uint32_t op3)
 {
   uint32_t result;
 
@@ -1568,7 +1645,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __USADA8(uint32_t op1, u
 
 #define __SSAT16(ARG1,ARG2) \
 ({                          \
-  uint32_t __RES, __ARG1 = (ARG1); \
+  int32_t __RES, __ARG1 = (ARG1); \
   __ASM ("ssat16 %0, %1, %2" : "=r" (__RES) :  "I" (ARG2), "r" (__ARG1) ); \
   __RES; \
  })
@@ -1580,7 +1657,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __USADA8(uint32_t op1, u
   __RES; \
  })
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UXTB16(uint32_t op1)
+__STATIC_FORCEINLINE uint32_t __UXTB16(uint32_t op1)
 {
   uint32_t result;
 
@@ -1588,7 +1665,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UXTB16(uint32_t op1)
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __UXTAB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UXTAB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1596,7 +1673,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __UXTAB16(uint32_t op1,
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SXTB16(uint32_t op1)
+__STATIC_FORCEINLINE uint32_t __SXTB16(uint32_t op1)
 {
   uint32_t result;
 
@@ -1604,7 +1681,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SXTB16(uint32_t op1)
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SXTAB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SXTAB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1612,7 +1689,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SXTAB16(uint32_t op1,
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SMUAD  (uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SMUAD  (uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1620,7 +1697,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMUAD  (uint32_t op1,
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SMUADX (uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SMUADX (uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1628,7 +1705,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMUADX (uint32_t op1,
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SMLAD (uint32_t op1, uint32_t op2, uint32_t op3)
+__STATIC_FORCEINLINE uint32_t __SMLAD (uint32_t op1, uint32_t op2, uint32_t op3)
 {
   uint32_t result;
 
@@ -1636,7 +1713,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMLAD (uint32_t op1, u
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SMLADX (uint32_t op1, uint32_t op2, uint32_t op3)
+__STATIC_FORCEINLINE uint32_t __SMLADX (uint32_t op1, uint32_t op2, uint32_t op3)
 {
   uint32_t result;
 
@@ -1644,7 +1721,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMLADX (uint32_t op1,
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint64_t __SMLALD (uint32_t op1, uint32_t op2, uint64_t acc)
+__STATIC_FORCEINLINE uint64_t __SMLALD (uint32_t op1, uint32_t op2, uint64_t acc)
 {
   union llreg_u{
     uint32_t w32[2];
@@ -1661,7 +1738,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint64_t __SMLALD (uint32_t op1,
   return(llr.w64);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint64_t __SMLALDX (uint32_t op1, uint32_t op2, uint64_t acc)
+__STATIC_FORCEINLINE uint64_t __SMLALDX (uint32_t op1, uint32_t op2, uint64_t acc)
 {
   union llreg_u{
     uint32_t w32[2];
@@ -1678,7 +1755,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint64_t __SMLALDX (uint32_t op1,
   return(llr.w64);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SMUSD  (uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SMUSD  (uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1686,7 +1763,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMUSD  (uint32_t op1,
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SMUSDX (uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SMUSDX (uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1694,7 +1771,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMUSDX (uint32_t op1,
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SMLSD (uint32_t op1, uint32_t op2, uint32_t op3)
+__STATIC_FORCEINLINE uint32_t __SMLSD (uint32_t op1, uint32_t op2, uint32_t op3)
 {
   uint32_t result;
 
@@ -1702,7 +1779,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMLSD (uint32_t op1, u
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SMLSDX (uint32_t op1, uint32_t op2, uint32_t op3)
+__STATIC_FORCEINLINE uint32_t __SMLSDX (uint32_t op1, uint32_t op2, uint32_t op3)
 {
   uint32_t result;
 
@@ -1710,7 +1787,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SMLSDX (uint32_t op1,
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint64_t __SMLSLD (uint32_t op1, uint32_t op2, uint64_t acc)
+__STATIC_FORCEINLINE uint64_t __SMLSLD (uint32_t op1, uint32_t op2, uint64_t acc)
 {
   union llreg_u{
     uint32_t w32[2];
@@ -1727,7 +1804,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint64_t __SMLSLD (uint32_t op1,
   return(llr.w64);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint64_t __SMLSLDX (uint32_t op1, uint32_t op2, uint64_t acc)
+__STATIC_FORCEINLINE uint64_t __SMLSLDX (uint32_t op1, uint32_t op2, uint64_t acc)
 {
   union llreg_u{
     uint32_t w32[2];
@@ -1744,7 +1821,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint64_t __SMLSLDX (uint32_t op1,
   return(llr.w64);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SEL  (uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SEL  (uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1752,7 +1829,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __SEL  (uint32_t op1, ui
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE  int32_t __QADD( int32_t op1,  int32_t op2)
+__STATIC_FORCEINLINE  int32_t __QADD( int32_t op1,  int32_t op2)
 {
   int32_t result;
 
@@ -1760,7 +1837,7 @@ __attribute__((always_inline)) __STATIC_INLINE  int32_t __QADD( int32_t op1,  in
   return(result);
 }
 
-__attribute__((always_inline)) __STATIC_INLINE  int32_t __QSUB( int32_t op1,  int32_t op2)
+__STATIC_FORCEINLINE  int32_t __QSUB( int32_t op1,  int32_t op2)
 {
   int32_t result;
 
@@ -1768,33 +1845,22 @@ __attribute__((always_inline)) __STATIC_INLINE  int32_t __QSUB( int32_t op1,  in
   return(result);
 }
 
-#define __PKHBT(ARG1,ARG2,ARG3) \
-({                          \
-  uint32_t __RES, __ARG1 = (ARG1), __ARG2 = (ARG2); \
-  __ASM ("pkhbt %0, %1, %2, lsl %3" : "=r" (__RES) :  "r" (__ARG1), "r" (__ARG2), "I" (ARG3)  ); \
-  __RES; \
- })
+#define __PKHBT(ARG1,ARG2,ARG3)          ( ((((uint32_t)(ARG1))          ) & 0x0000FFFFUL) |  \
+                                           ((((uint32_t)(ARG2)) << (ARG3)) & 0xFFFF0000UL)  )
 
-#define __PKHTB(ARG1,ARG2,ARG3) \
-({                          \
-  uint32_t __RES, __ARG1 = (ARG1), __ARG2 = (ARG2); \
-  if (ARG3 == 0) \
-    __ASM ("pkhtb %0, %1, %2" : "=r" (__RES) :  "r" (__ARG1), "r" (__ARG2)  ); \
-  else \
-    __ASM ("pkhtb %0, %1, %2, asr %3" : "=r" (__RES) :  "r" (__ARG1), "r" (__ARG2), "I" (ARG3)  ); \
-  __RES; \
- })
+#define __PKHTB(ARG1,ARG2,ARG3)          ( ((((uint32_t)(ARG1))          ) & 0xFFFF0000UL) |  \
+                                           ((((uint32_t)(ARG2)) >> (ARG3)) & 0x0000FFFFUL)  )
 
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __SMMLA (int32_t op1, int32_t op2, int32_t op3)
+__STATIC_FORCEINLINE int32_t __SMMLA (int32_t op1, int32_t op2, int32_t op3)
 {
- int32_t result;
+  int32_t result;
 
- __ASM volatile ("smmla %0, %1, %2, %3" : "=r" (result): "r"  (op1), "r" (op2), "r" (op3) );
- return(result);
+  __ASM volatile ("smmla %0, %1, %2, %3" : "=r" (result): "r"  (op1), "r" (op2), "r" (op3) );
+  return(result);
 }
 
-#endif /* (__ARM_FEATURE_DSP == 1U) */
+#endif /* (__ARM_FEATURE_DSP == 1) */
 /*@} end of group CMSIS_SIMD_intrinsics */
 
 
-#endif /* __CMSIS_ARMCC_V6_H */
+#endif /* __CMSIS_ARMCLANG_H */
diff --git a/lib/cmsis/inc/cmsis_compiler.h b/lib/cmsis/inc/cmsis_compiler.h
new file mode 100644
index 0000000000000..fdb1a971c6a8c
--- /dev/null
+++ b/lib/cmsis/inc/cmsis_compiler.h
@@ -0,0 +1,271 @@
+/**************************************************************************//**
+ * @file     cmsis_compiler.h
+ * @brief    CMSIS compiler generic header file
+ * @version  V5.1.0
+ * @date     09. October 2018
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2018 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __CMSIS_COMPILER_H
+#define __CMSIS_COMPILER_H
+
+#include <stdint.h>
+
+/*
+ * Arm Compiler 4/5
+ */
+#if   defined ( __CC_ARM )
+  #include "cmsis_armcc.h"
+
+
+/*
+ * Arm Compiler 6.6 LTM (armclang)
+ */
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) && (__ARMCC_VERSION < 6100100)
+  #include "cmsis_armclang_ltm.h"
+
+  /*
+ * Arm Compiler above 6.10.1 (armclang)
+ */
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6100100)
+  #include "cmsis_armclang.h"
+
+
+/*
+ * GNU Compiler
+ */
+#elif defined ( __GNUC__ )
+  #include "cmsis_gcc.h"
+
+
+/*
+ * IAR Compiler
+ */
+#elif defined ( __ICCARM__ )
+  #include <cmsis_iccarm.h>
+
+
+/*
+ * TI Arm Compiler
+ */
+#elif defined ( __TI_ARM__ )
+  #include <cmsis_ccs.h>
+
+  #ifndef   __ASM
+    #define __ASM                                  __asm
+  #endif
+  #ifndef   __INLINE
+    #define __INLINE                               inline
+  #endif
+  #ifndef   __STATIC_INLINE
+    #define __STATIC_INLINE                        static inline
+  #endif
+  #ifndef   __STATIC_FORCEINLINE
+    #define __STATIC_FORCEINLINE                   __STATIC_INLINE
+  #endif
+  #ifndef   __NO_RETURN
+    #define __NO_RETURN                            __attribute__((noreturn))
+  #endif
+  #ifndef   __USED
+    #define __USED                                 __attribute__((used))
+  #endif
+  #ifndef   __WEAK
+    #define __WEAK                                 __attribute__((weak))
+  #endif
+  #ifndef   __PACKED
+    #define __PACKED                               __attribute__((packed))
+  #endif
+  #ifndef   __PACKED_STRUCT
+    #define __PACKED_STRUCT                        struct __attribute__((packed))
+  #endif
+  #ifndef   __PACKED_UNION
+    #define __PACKED_UNION                         union __attribute__((packed))
+  #endif
+  #ifndef   __UNALIGNED_UINT32        /* deprecated */
+    struct __attribute__((packed)) T_UINT32 { uint32_t v; };
+    #define __UNALIGNED_UINT32(x)                  (((struct T_UINT32 *)(x))->v)
+  #endif
+  #ifndef   __UNALIGNED_UINT16_WRITE
+    __PACKED_STRUCT T_UINT16_WRITE { uint16_t v; };
+    #define __UNALIGNED_UINT16_WRITE(addr, val)    (void)((((struct T_UINT16_WRITE *)(void*)(addr))->v) = (val))
+  #endif
+  #ifndef   __UNALIGNED_UINT16_READ
+    __PACKED_STRUCT T_UINT16_READ { uint16_t v; };
+    #define __UNALIGNED_UINT16_READ(addr)          (((const struct T_UINT16_READ *)(const void *)(addr))->v)
+  #endif
+  #ifndef   __UNALIGNED_UINT32_WRITE
+    __PACKED_STRUCT T_UINT32_WRITE { uint32_t v; };
+    #define __UNALIGNED_UINT32_WRITE(addr, val)    (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val))
+  #endif
+  #ifndef   __UNALIGNED_UINT32_READ
+    __PACKED_STRUCT T_UINT32_READ { uint32_t v; };
+    #define __UNALIGNED_UINT32_READ(addr)          (((const struct T_UINT32_READ *)(const void *)(addr))->v)
+  #endif
+  #ifndef   __ALIGNED
+    #define __ALIGNED(x)                           __attribute__((aligned(x)))
+  #endif
+  #ifndef   __RESTRICT
+    #define __RESTRICT                             __restrict
+  #endif
+
+
+/*
+ * TASKING Compiler
+ */
+#elif defined ( __TASKING__ )
+  /*
+   * The CMSIS functions have been implemented as intrinsics in the compiler.
+   * Please use "carm -?i" to get an up to date list of all intrinsics,
+   * Including the CMSIS ones.
+   */
+
+  #ifndef   __ASM
+    #define __ASM                                  __asm
+  #endif
+  #ifndef   __INLINE
+    #define __INLINE                               inline
+  #endif
+  #ifndef   __STATIC_INLINE
+    #define __STATIC_INLINE                        static inline
+  #endif
+  #ifndef   __STATIC_FORCEINLINE
+    #define __STATIC_FORCEINLINE                   __STATIC_INLINE
+  #endif
+  #ifndef   __NO_RETURN
+    #define __NO_RETURN                            __attribute__((noreturn))
+  #endif
+  #ifndef   __USED
+    #define __USED                                 __attribute__((used))
+  #endif
+  #ifndef   __WEAK
+    #define __WEAK                                 __attribute__((weak))
+  #endif
+  #ifndef   __PACKED
+    #define __PACKED                               __packed__
+  #endif
+  #ifndef   __PACKED_STRUCT
+    #define __PACKED_STRUCT                        struct __packed__
+  #endif
+  #ifndef   __PACKED_UNION
+    #define __PACKED_UNION                         union __packed__
+  #endif
+  #ifndef   __UNALIGNED_UINT32        /* deprecated */
+    struct __packed__ T_UINT32 { uint32_t v; };
+    #define __UNALIGNED_UINT32(x)                  (((struct T_UINT32 *)(x))->v)
+  #endif
+  #ifndef   __UNALIGNED_UINT16_WRITE
+    __PACKED_STRUCT T_UINT16_WRITE { uint16_t v; };
+    #define __UNALIGNED_UINT16_WRITE(addr, val)    (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val))
+  #endif
+  #ifndef   __UNALIGNED_UINT16_READ
+    __PACKED_STRUCT T_UINT16_READ { uint16_t v; };
+    #define __UNALIGNED_UINT16_READ(addr)          (((const struct T_UINT16_READ *)(const void *)(addr))->v)
+  #endif
+  #ifndef   __UNALIGNED_UINT32_WRITE
+    __PACKED_STRUCT T_UINT32_WRITE { uint32_t v; };
+    #define __UNALIGNED_UINT32_WRITE(addr, val)    (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val))
+  #endif
+  #ifndef   __UNALIGNED_UINT32_READ
+    __PACKED_STRUCT T_UINT32_READ { uint32_t v; };
+    #define __UNALIGNED_UINT32_READ(addr)          (((const struct T_UINT32_READ *)(const void *)(addr))->v)
+  #endif
+  #ifndef   __ALIGNED
+    #define __ALIGNED(x)              __align(x)
+  #endif
+  #ifndef   __RESTRICT
+    #warning No compiler specific solution for __RESTRICT. __RESTRICT is ignored.
+    #define __RESTRICT
+  #endif
+
+
+/*
+ * COSMIC Compiler
+ */
+#elif defined ( __CSMC__ )
+   #include <cmsis_csm.h>
+
+ #ifndef   __ASM
+    #define __ASM                                  _asm
+  #endif
+  #ifndef   __INLINE
+    #define __INLINE                               inline
+  #endif
+  #ifndef   __STATIC_INLINE
+    #define __STATIC_INLINE                        static inline
+  #endif
+  #ifndef   __STATIC_FORCEINLINE
+    #define __STATIC_FORCEINLINE                   __STATIC_INLINE
+  #endif
+  #ifndef   __NO_RETURN
+    // NO RETURN is automatically detected hence no warning here
+    #define __NO_RETURN
+  #endif
+  #ifndef   __USED
+    #warning No compiler specific solution for __USED. __USED is ignored.
+    #define __USED
+  #endif
+  #ifndef   __WEAK
+    #define __WEAK                                 __weak
+  #endif
+  #ifndef   __PACKED
+    #define __PACKED                               @packed
+  #endif
+  #ifndef   __PACKED_STRUCT
+    #define __PACKED_STRUCT                        @packed struct
+  #endif
+  #ifndef   __PACKED_UNION
+    #define __PACKED_UNION                         @packed union
+  #endif
+  #ifndef   __UNALIGNED_UINT32        /* deprecated */
+    @packed struct T_UINT32 { uint32_t v; };
+    #define __UNALIGNED_UINT32(x)                  (((struct T_UINT32 *)(x))->v)
+  #endif
+  #ifndef   __UNALIGNED_UINT16_WRITE
+    __PACKED_STRUCT T_UINT16_WRITE { uint16_t v; };
+    #define __UNALIGNED_UINT16_WRITE(addr, val)    (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val))
+  #endif
+  #ifndef   __UNALIGNED_UINT16_READ
+    __PACKED_STRUCT T_UINT16_READ { uint16_t v; };
+    #define __UNALIGNED_UINT16_READ(addr)          (((const struct T_UINT16_READ *)(const void *)(addr))->v)
+  #endif
+  #ifndef   __UNALIGNED_UINT32_WRITE
+    __PACKED_STRUCT T_UINT32_WRITE { uint32_t v; };
+    #define __UNALIGNED_UINT32_WRITE(addr, val)    (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val))
+  #endif
+  #ifndef   __UNALIGNED_UINT32_READ
+    __PACKED_STRUCT T_UINT32_READ { uint32_t v; };
+    #define __UNALIGNED_UINT32_READ(addr)          (((const struct T_UINT32_READ *)(const void *)(addr))->v)
+  #endif
+  #ifndef   __ALIGNED
+    #warning No compiler specific solution for __ALIGNED. __ALIGNED is ignored.
+    #define __ALIGNED(x)
+  #endif
+  #ifndef   __RESTRICT
+    #warning No compiler specific solution for __RESTRICT. __RESTRICT is ignored.
+    #define __RESTRICT
+  #endif
+
+
+#else
+  #error Unknown compiler.
+#endif
+
+
+#endif /* __CMSIS_COMPILER_H */
+
diff --git a/lib/cmsis/inc/cmsis_gcc.h b/lib/cmsis/inc/cmsis_gcc.h
index bb89fbba9e400..d86b0a2d5a6d3 100644
--- a/lib/cmsis/inc/cmsis_gcc.h
+++ b/lib/cmsis/inc/cmsis_gcc.h
@@ -1,46 +1,117 @@
 /**************************************************************************//**
  * @file     cmsis_gcc.h
- * @brief    CMSIS Cortex-M Core Function/Instruction Header File
- * @version  V4.30
- * @date     20. October 2015
+ * @brief    CMSIS compiler GCC header file
+ * @version  V5.1.0
+ * @date     20. December 2018
  ******************************************************************************/
-/* Copyright (c) 2009 - 2015 ARM LIMITED
-
-   All rights reserved.
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-   - Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in the
-     documentation and/or other materials provided with the distribution.
-   - Neither the name of ARM nor the names of its contributors may be used
-     to endorse or promote products derived from this software without
-     specific prior written permission.
-   *
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
-   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-   POSSIBILITY OF SUCH DAMAGE.
-   ---------------------------------------------------------------------------*/
-
+/*
+ * Copyright (c) 2009-2018 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #ifndef __CMSIS_GCC_H
 #define __CMSIS_GCC_H
 
 /* ignore some GCC warnings */
-#if defined ( __GNUC__ )
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wsign-conversion"
 #pragma GCC diagnostic ignored "-Wconversion"
 #pragma GCC diagnostic ignored "-Wunused-parameter"
+
+/* Fallback for __has_builtin */
+#ifndef __has_builtin
+  #define __has_builtin(x) (0)
+#endif
+
+/* CMSIS compiler specific defines */
+#ifndef   __ASM
+  #define __ASM                                  __asm
+#endif
+#ifndef   __INLINE
+  #define __INLINE                               inline
+#endif
+#ifndef   __STATIC_INLINE
+  #define __STATIC_INLINE                        static inline
+#endif
+#ifndef   __STATIC_FORCEINLINE                 
+  #define __STATIC_FORCEINLINE                   __attribute__((always_inline)) static inline
+#endif                                           
+#ifndef   __NO_RETURN
+  #define __NO_RETURN                            __attribute__((__noreturn__))
+#endif
+#ifndef   __USED
+  #define __USED                                 __attribute__((used))
+#endif
+#ifndef   __WEAK
+  #define __WEAK                                 __attribute__((weak))
+#endif
+#ifndef   __PACKED
+  #define __PACKED                               __attribute__((packed, aligned(1)))
+#endif
+#ifndef   __PACKED_STRUCT
+  #define __PACKED_STRUCT                        struct __attribute__((packed, aligned(1)))
+#endif
+#ifndef   __PACKED_UNION
+  #define __PACKED_UNION                         union __attribute__((packed, aligned(1)))
+#endif
+#ifndef   __UNALIGNED_UINT32        /* deprecated */
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wpacked"
+  #pragma GCC diagnostic ignored "-Wattributes"
+  struct __attribute__((packed)) T_UINT32 { uint32_t v; };
+  #pragma GCC diagnostic pop
+  #define __UNALIGNED_UINT32(x)                  (((struct T_UINT32 *)(x))->v)
+#endif
+#ifndef   __UNALIGNED_UINT16_WRITE
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wpacked"
+  #pragma GCC diagnostic ignored "-Wattributes"
+  __PACKED_STRUCT T_UINT16_WRITE { uint16_t v; };
+  #pragma GCC diagnostic pop
+  #define __UNALIGNED_UINT16_WRITE(addr, val)    (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val))
+#endif
+#ifndef   __UNALIGNED_UINT16_READ
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wpacked"
+  #pragma GCC diagnostic ignored "-Wattributes"
+  __PACKED_STRUCT T_UINT16_READ { uint16_t v; };
+  #pragma GCC diagnostic pop
+  #define __UNALIGNED_UINT16_READ(addr)          (((const struct T_UINT16_READ *)(const void *)(addr))->v)
+#endif
+#ifndef   __UNALIGNED_UINT32_WRITE
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wpacked"
+  #pragma GCC diagnostic ignored "-Wattributes"
+  __PACKED_STRUCT T_UINT32_WRITE { uint32_t v; };
+  #pragma GCC diagnostic pop
+  #define __UNALIGNED_UINT32_WRITE(addr, val)    (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val))
+#endif
+#ifndef   __UNALIGNED_UINT32_READ
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wpacked"
+  #pragma GCC diagnostic ignored "-Wattributes"
+  __PACKED_STRUCT T_UINT32_READ { uint32_t v; };
+  #pragma GCC diagnostic pop
+  #define __UNALIGNED_UINT32_READ(addr)          (((const struct T_UINT32_READ *)(const void *)(addr))->v)
+#endif
+#ifndef   __ALIGNED
+  #define __ALIGNED(x)                           __attribute__((aligned(x)))
+#endif
+#ifndef   __RESTRICT
+  #define __RESTRICT                             __restrict
 #endif
 
 
@@ -55,7 +126,7 @@
   \details Enables IRQ interrupts by clearing the I-bit in the CPSR.
            Can only be executed in Privileged modes.
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE void __enable_irq(void)
+__STATIC_FORCEINLINE void __enable_irq(void)
 {
   __ASM volatile ("cpsie i" : : : "memory");
 }
@@ -64,9 +135,9 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE void __enable_irq(void)
 /**
   \brief   Disable IRQ Interrupts
   \details Disables IRQ interrupts by setting the I-bit in the CPSR.
-  Can only be executed in Privileged modes.
+           Can only be executed in Privileged modes.
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE void __disable_irq(void)
+__STATIC_FORCEINLINE void __disable_irq(void)
 {
   __ASM volatile ("cpsid i" : : : "memory");
 }
@@ -77,7 +148,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE void __disable_irq(void)
   \details Returns the content of the Control Register.
   \return               Control Register value
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_CONTROL(void)
+__STATIC_FORCEINLINE uint32_t __get_CONTROL(void)
 {
   uint32_t result;
 
@@ -86,23 +157,52 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_CONTROL(void)
 }
 
 
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Control Register (non-secure)
+  \details Returns the content of the non-secure Control Register when in secure mode.
+  \return               non-secure Control Register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_CONTROL_NS(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, control_ns" : "=r" (result) );
+  return(result);
+}
+#endif
+
+
 /**
   \brief   Set Control Register
   \details Writes the given value to the Control Register.
   \param [in]    control  Control Register value to set
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_CONTROL(uint32_t control)
+__STATIC_FORCEINLINE void __set_CONTROL(uint32_t control)
 {
   __ASM volatile ("MSR control, %0" : : "r" (control) : "memory");
 }
 
 
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Set Control Register (non-secure)
+  \details Writes the given value to the non-secure Control Register when in secure state.
+  \param [in]    control  Control Register value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_CONTROL_NS(uint32_t control)
+{
+  __ASM volatile ("MSR control_ns, %0" : : "r" (control) : "memory");
+}
+#endif
+
+
 /**
   \brief   Get IPSR Register
   \details Returns the content of the IPSR Register.
   \return               IPSR Register value
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_IPSR(void)
+__STATIC_FORCEINLINE uint32_t __get_IPSR(void)
 {
   uint32_t result;
 
@@ -116,7 +216,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_IPSR(void)
   \details Returns the content of the APSR Register.
   \return               APSR Register value
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_APSR(void)
+__STATIC_FORCEINLINE uint32_t __get_APSR(void)
 {
   uint32_t result;
 
@@ -128,10 +228,9 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_APSR(void)
 /**
   \brief   Get xPSR Register
   \details Returns the content of the xPSR Register.
-
-    \return               xPSR Register value
+  \return               xPSR Register value
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_xPSR(void)
+__STATIC_FORCEINLINE uint32_t __get_xPSR(void)
 {
   uint32_t result;
 
@@ -145,24 +244,53 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_xPSR(void)
   \details Returns the current value of the Process Stack Pointer (PSP).
   \return               PSP Register value
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_PSP(void)
+__STATIC_FORCEINLINE uint32_t __get_PSP(void)
 {
-  register uint32_t result;
+  uint32_t result;
 
-  __ASM volatile ("MRS %0, psp\n"  : "=r" (result) );
+  __ASM volatile ("MRS %0, psp"  : "=r" (result) );
   return(result);
 }
 
 
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Process Stack Pointer (non-secure)
+  \details Returns the current value of the non-secure Process Stack Pointer (PSP) when in secure state.
+  \return               PSP Register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_PSP_NS(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, psp_ns"  : "=r" (result) );
+  return(result);
+}
+#endif
+
+
 /**
   \brief   Set Process Stack Pointer
   \details Assigns the given value to the Process Stack Pointer (PSP).
   \param [in]    topOfProcStack  Process Stack Pointer value to set
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_PSP(uint32_t topOfProcStack)
+__STATIC_FORCEINLINE void __set_PSP(uint32_t topOfProcStack)
+{
+  __ASM volatile ("MSR psp, %0" : : "r" (topOfProcStack) : );
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Set Process Stack Pointer (non-secure)
+  \details Assigns the given value to the non-secure Process Stack Pointer (PSP) when in secure state.
+  \param [in]    topOfProcStack  Process Stack Pointer value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_PSP_NS(uint32_t topOfProcStack)
 {
-  __ASM volatile ("MSR psp, %0\n" : : "r" (topOfProcStack) : "sp");
+  __ASM volatile ("MSR psp_ns, %0" : : "r" (topOfProcStack) : );
 }
+#endif
 
 
 /**
@@ -170,25 +298,80 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE void __set_PSP(uint32_t topOf
   \details Returns the current value of the Main Stack Pointer (MSP).
   \return               MSP Register value
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_MSP(void)
+__STATIC_FORCEINLINE uint32_t __get_MSP(void)
 {
-  register uint32_t result;
+  uint32_t result;
 
-  __ASM volatile ("MRS %0, msp\n" : "=r" (result) );
+  __ASM volatile ("MRS %0, msp" : "=r" (result) );
   return(result);
 }
 
 
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Main Stack Pointer (non-secure)
+  \details Returns the current value of the non-secure Main Stack Pointer (MSP) when in secure state.
+  \return               MSP Register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_MSP_NS(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, msp_ns" : "=r" (result) );
+  return(result);
+}
+#endif
+
+
 /**
   \brief   Set Main Stack Pointer
   \details Assigns the given value to the Main Stack Pointer (MSP).
+  \param [in]    topOfMainStack  Main Stack Pointer value to set
+ */
+__STATIC_FORCEINLINE void __set_MSP(uint32_t topOfMainStack)
+{
+  __ASM volatile ("MSR msp, %0" : : "r" (topOfMainStack) : );
+}
+
 
-    \param [in]    topOfMainStack  Main Stack Pointer value to set
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Set Main Stack Pointer (non-secure)
+  \details Assigns the given value to the non-secure Main Stack Pointer (MSP) when in secure state.
+  \param [in]    topOfMainStack  Main Stack Pointer value to set
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_MSP(uint32_t topOfMainStack)
+__STATIC_FORCEINLINE void __TZ_set_MSP_NS(uint32_t topOfMainStack)
 {
-  __ASM volatile ("MSR msp, %0\n" : : "r" (topOfMainStack) : "sp");
+  __ASM volatile ("MSR msp_ns, %0" : : "r" (topOfMainStack) : );
 }
+#endif
+
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Stack Pointer (non-secure)
+  \details Returns the current value of the non-secure Stack Pointer (SP) when in secure state.
+  \return               SP Register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_SP_NS(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, sp_ns" : "=r" (result) );
+  return(result);
+}
+
+
+/**
+  \brief   Set Stack Pointer (non-secure)
+  \details Assigns the given value to the non-secure Stack Pointer (SP) when in secure state.
+  \param [in]    topOfStack  Stack Pointer value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_SP_NS(uint32_t topOfStack)
+{
+  __ASM volatile ("MSR sp_ns, %0" : : "r" (topOfStack) : );
+}
+#endif
 
 
 /**
@@ -196,34 +379,64 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE void __set_MSP(uint32_t topOf
   \details Returns the current state of the priority mask bit from the Priority Mask Register.
   \return               Priority Mask value
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_PRIMASK(void)
+__STATIC_FORCEINLINE uint32_t __get_PRIMASK(void)
 {
   uint32_t result;
 
-  __ASM volatile ("MRS %0, primask" : "=r" (result) );
+  __ASM volatile ("MRS %0, primask" : "=r" (result) :: "memory");
   return(result);
 }
 
 
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Priority Mask (non-secure)
+  \details Returns the current state of the non-secure priority mask bit from the Priority Mask Register when in secure state.
+  \return               Priority Mask value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_PRIMASK_NS(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, primask_ns" : "=r" (result) :: "memory");
+  return(result);
+}
+#endif
+
+
 /**
   \brief   Set Priority Mask
   \details Assigns the given value to the Priority Mask Register.
   \param [in]    priMask  Priority Mask
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_PRIMASK(uint32_t priMask)
+__STATIC_FORCEINLINE void __set_PRIMASK(uint32_t priMask)
 {
   __ASM volatile ("MSR primask, %0" : : "r" (priMask) : "memory");
 }
 
 
-#if       (__CORTEX_M >= 0x03U)
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Set Priority Mask (non-secure)
+  \details Assigns the given value to the non-secure Priority Mask Register when in secure state.
+  \param [in]    priMask  Priority Mask
+ */
+__STATIC_FORCEINLINE void __TZ_set_PRIMASK_NS(uint32_t priMask)
+{
+  __ASM volatile ("MSR primask_ns, %0" : : "r" (priMask) : "memory");
+}
+#endif
+
 
+#if ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+     (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+     (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    )
 /**
   \brief   Enable FIQ
   \details Enables FIQ interrupts by clearing the F-bit in the CPSR.
            Can only be executed in Privileged modes.
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE void __enable_fault_irq(void)
+__STATIC_FORCEINLINE void __enable_fault_irq(void)
 {
   __ASM volatile ("cpsie f" : : : "memory");
 }
@@ -234,7 +447,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE void __enable_fault_irq(void)
   \details Disables FIQ interrupts by setting the F-bit in the CPSR.
            Can only be executed in Privileged modes.
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE void __disable_fault_irq(void)
+__STATIC_FORCEINLINE void __disable_fault_irq(void)
 {
   __ASM volatile ("cpsid f" : : : "memory");
 }
@@ -245,7 +458,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE void __disable_fault_irq(void
   \details Returns the current value of the Base Priority register.
   \return               Base Priority register value
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_BASEPRI(void)
+__STATIC_FORCEINLINE uint32_t __get_BASEPRI(void)
 {
   uint32_t result;
 
@@ -254,26 +467,55 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_BASEPRI(void)
 }
 
 
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Base Priority (non-secure)
+  \details Returns the current value of the non-secure Base Priority register when in secure state.
+  \return               Base Priority register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_BASEPRI_NS(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, basepri_ns" : "=r" (result) );
+  return(result);
+}
+#endif
+
+
 /**
   \brief   Set Base Priority
   \details Assigns the given value to the Base Priority register.
   \param [in]    basePri  Base Priority value to set
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_BASEPRI(uint32_t value)
+__STATIC_FORCEINLINE void __set_BASEPRI(uint32_t basePri)
 {
-  __ASM volatile ("MSR basepri, %0" : : "r" (value) : "memory");
+  __ASM volatile ("MSR basepri, %0" : : "r" (basePri) : "memory");
 }
 
 
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Set Base Priority (non-secure)
+  \details Assigns the given value to the non-secure Base Priority register when in secure state.
+  \param [in]    basePri  Base Priority value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_BASEPRI_NS(uint32_t basePri)
+{
+  __ASM volatile ("MSR basepri_ns, %0" : : "r" (basePri) : "memory");
+}
+#endif
+
+
 /**
   \brief   Set Base Priority with condition
   \details Assigns the given value to the Base Priority register only if BASEPRI masking is disabled,
            or the new value increases the BASEPRI priority level.
   \param [in]    basePri  Base Priority value to set
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_BASEPRI_MAX(uint32_t value)
+__STATIC_FORCEINLINE void __set_BASEPRI_MAX(uint32_t basePri)
 {
-  __ASM volatile ("MSR basepri_max, %0" : : "r" (value) : "memory");
+  __ASM volatile ("MSR basepri_max, %0" : : "r" (basePri) : "memory");
 }
 
 
@@ -282,7 +524,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE void __set_BASEPRI_MAX(uint32
   \details Returns the current value of the Fault Mask register.
   \return               Fault Mask register value
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_FAULTMASK(void)
+__STATIC_FORCEINLINE uint32_t __get_FAULTMASK(void)
 {
   uint32_t result;
 
@@ -291,38 +533,253 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_FAULTMASK(void
 }
 
 
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Fault Mask (non-secure)
+  \details Returns the current value of the non-secure Fault Mask register when in secure state.
+  \return               Fault Mask register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_FAULTMASK_NS(void)
+{
+  uint32_t result;
+
+  __ASM volatile ("MRS %0, faultmask_ns" : "=r" (result) );
+  return(result);
+}
+#endif
+
+
 /**
   \brief   Set Fault Mask
   \details Assigns the given value to the Fault Mask register.
   \param [in]    faultMask  Fault Mask value to set
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_FAULTMASK(uint32_t faultMask)
+__STATIC_FORCEINLINE void __set_FAULTMASK(uint32_t faultMask)
 {
   __ASM volatile ("MSR faultmask, %0" : : "r" (faultMask) : "memory");
 }
 
-#endif /* (__CORTEX_M >= 0x03U) */
+
+#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Set Fault Mask (non-secure)
+  \details Assigns the given value to the non-secure Fault Mask register when in secure state.
+  \param [in]    faultMask  Fault Mask value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_FAULTMASK_NS(uint32_t faultMask)
+{
+  __ASM volatile ("MSR faultmask_ns, %0" : : "r" (faultMask) : "memory");
+}
+#endif
+
+#endif /* ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+           (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+           (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    ) */
 
 
-#if       (__CORTEX_M == 0x04U) || (__CORTEX_M == 0x07U)
+#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+     (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    )
+
+/**
+  \brief   Get Process Stack Pointer Limit
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence zero is returned always in non-secure
+  mode.
+  
+  \details Returns the current value of the Process Stack Pointer Limit (PSPLIM).
+  \return               PSPLIM Register value
+ */
+__STATIC_FORCEINLINE uint32_t __get_PSPLIM(void)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+    (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+    // without main extensions, the non-secure PSPLIM is RAZ/WI
+  return 0U;
+#else
+  uint32_t result;
+  __ASM volatile ("MRS %0, psplim"  : "=r" (result) );
+  return result;
+#endif
+}
+
+#if (defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3))
+/**
+  \brief   Get Process Stack Pointer Limit (non-secure)
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence zero is returned always.
+
+  \details Returns the current value of the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state.
+  \return               PSPLIM Register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_PSPLIM_NS(void)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)))
+  // without main extensions, the non-secure PSPLIM is RAZ/WI
+  return 0U;
+#else
+  uint32_t result;
+  __ASM volatile ("MRS %0, psplim_ns"  : "=r" (result) );
+  return result;
+#endif
+}
+#endif
+
+
+/**
+  \brief   Set Process Stack Pointer Limit
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence the write is silently ignored in non-secure
+  mode.
+  
+  \details Assigns the given value to the Process Stack Pointer Limit (PSPLIM).
+  \param [in]    ProcStackPtrLimit  Process Stack Pointer Limit value to set
+ */
+__STATIC_FORCEINLINE void __set_PSPLIM(uint32_t ProcStackPtrLimit)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+    (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+  // without main extensions, the non-secure PSPLIM is RAZ/WI
+  (void)ProcStackPtrLimit;
+#else
+  __ASM volatile ("MSR psplim, %0" : : "r" (ProcStackPtrLimit));
+#endif
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE  ) && (__ARM_FEATURE_CMSE   == 3))
+/**
+  \brief   Set Process Stack Pointer (non-secure)
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence the write is silently ignored.
+
+  \details Assigns the given value to the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state.
+  \param [in]    ProcStackPtrLimit  Process Stack Pointer Limit value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_PSPLIM_NS(uint32_t ProcStackPtrLimit)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)))
+  // without main extensions, the non-secure PSPLIM is RAZ/WI
+  (void)ProcStackPtrLimit;
+#else
+  __ASM volatile ("MSR psplim_ns, %0\n" : : "r" (ProcStackPtrLimit));
+#endif
+}
+#endif
+
+
+/**
+  \brief   Get Main Stack Pointer Limit
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence zero is returned always in non-secure
+  mode.
+
+  \details Returns the current value of the Main Stack Pointer Limit (MSPLIM).
+  \return               MSPLIM Register value
+ */
+__STATIC_FORCEINLINE uint32_t __get_MSPLIM(void)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+    (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+  // without main extensions, the non-secure MSPLIM is RAZ/WI
+  return 0U;
+#else
+  uint32_t result;
+  __ASM volatile ("MRS %0, msplim" : "=r" (result) );
+  return result;
+#endif
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE  ) && (__ARM_FEATURE_CMSE   == 3))
+/**
+  \brief   Get Main Stack Pointer Limit (non-secure)
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence zero is returned always.
+
+  \details Returns the current value of the non-secure Main Stack Pointer Limit(MSPLIM) when in secure state.
+  \return               MSPLIM Register value
+ */
+__STATIC_FORCEINLINE uint32_t __TZ_get_MSPLIM_NS(void)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)))
+  // without main extensions, the non-secure MSPLIM is RAZ/WI
+  return 0U;
+#else
+  uint32_t result;
+  __ASM volatile ("MRS %0, msplim_ns" : "=r" (result) );
+  return result;
+#endif
+}
+#endif
+
+
+/**
+  \brief   Set Main Stack Pointer Limit
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence the write is silently ignored in non-secure
+  mode.
+
+  \details Assigns the given value to the Main Stack Pointer Limit (MSPLIM).
+  \param [in]    MainStackPtrLimit  Main Stack Pointer Limit value to set
+ */
+__STATIC_FORCEINLINE void __set_MSPLIM(uint32_t MainStackPtrLimit)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+    (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+  // without main extensions, the non-secure MSPLIM is RAZ/WI
+  (void)MainStackPtrLimit;
+#else
+  __ASM volatile ("MSR msplim, %0" : : "r" (MainStackPtrLimit));
+#endif
+}
+
+
+#if (defined (__ARM_FEATURE_CMSE  ) && (__ARM_FEATURE_CMSE   == 3))
+/**
+  \brief   Set Main Stack Pointer Limit (non-secure)
+  Devices without ARMv8-M Main Extensions (i.e. Cortex-M23) lack the non-secure
+  Stack Pointer Limit register hence the write is silently ignored.
+
+  \details Assigns the given value to the non-secure Main Stack Pointer Limit (MSPLIM) when in secure state.
+  \param [in]    MainStackPtrLimit  Main Stack Pointer value to set
+ */
+__STATIC_FORCEINLINE void __TZ_set_MSPLIM_NS(uint32_t MainStackPtrLimit)
+{
+#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)))
+  // without main extensions, the non-secure MSPLIM is RAZ/WI
+  (void)MainStackPtrLimit;
+#else
+  __ASM volatile ("MSR msplim_ns, %0" : : "r" (MainStackPtrLimit));
+#endif
+}
+#endif
+
+#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+           (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    ) */
+
 
 /**
   \brief   Get FPSCR
   \details Returns the current value of the Floating Point Status/Control register.
   \return               Floating Point Status/Control register value
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_FPSCR(void)
-{
-#if (__FPU_PRESENT == 1U) && (__FPU_USED == 1U)
+__STATIC_FORCEINLINE uint32_t __get_FPSCR(void)
+{
+#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
+     (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )
+#if __has_builtin(__builtin_arm_get_fpscr) 
+// Re-enable using built-in when GCC has been fixed
+// || (__GNUC__ > 7) || (__GNUC__ == 7 && __GNUC_MINOR__ >= 2)
+  /* see https://gcc.gnu.org/ml/gcc-patches/2017-04/msg00443.html */
+  return __builtin_arm_get_fpscr();
+#else
   uint32_t result;
 
-  /* Empty asm statement works as a scheduling barrier */
-  __ASM volatile ("");
   __ASM volatile ("VMRS %0, fpscr" : "=r" (result) );
-  __ASM volatile ("");
   return(result);
+#endif
 #else
-   return(0);
+  return(0U);
 #endif
 }
 
@@ -332,19 +789,23 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __get_FPSCR(void)
   \details Assigns the given value to the Floating Point Status/Control register.
   \param [in]    fpscr  Floating Point Status/Control value to set
  */
-__attribute__( ( always_inline ) ) __STATIC_INLINE void __set_FPSCR(uint32_t fpscr)
-{
-#if (__FPU_PRESENT == 1U) && (__FPU_USED == 1U)
-  /* Empty asm statement works as a scheduling barrier */
-  __ASM volatile ("");
-  __ASM volatile ("VMSR fpscr, %0" : : "r" (fpscr) : "vfpcc");
-  __ASM volatile ("");
+__STATIC_FORCEINLINE void __set_FPSCR(uint32_t fpscr)
+{
+#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
+     (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )
+#if __has_builtin(__builtin_arm_set_fpscr)
+// Re-enable using built-in when GCC has been fixed
+// || (__GNUC__ > 7) || (__GNUC__ == 7 && __GNUC_MINOR__ >= 2)
+  /* see https://gcc.gnu.org/ml/gcc-patches/2017-04/msg00443.html */
+  __builtin_arm_set_fpscr(fpscr);
+#else
+  __ASM volatile ("VMSR fpscr, %0" : : "r" (fpscr) : "vfpcc", "memory");
+#endif
+#else
+  (void)fpscr;
 #endif
 }
 
-#endif /* (__CORTEX_M == 0x04U) || (__CORTEX_M == 0x07U) */
-
-
 
 /*@} end of CMSIS_Core_RegAccFunctions */
 
@@ -360,9 +821,11 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE void __set_FPSCR(uint32_t fps
  * Otherwise, use general registers, specified by constraint "r" */
 #if defined (__thumb__) && !defined (__thumb2__)
 #define __CMSIS_GCC_OUT_REG(r) "=l" (r)
+#define __CMSIS_GCC_RW_REG(r) "+l" (r)
 #define __CMSIS_GCC_USE_REG(r) "l" (r)
 #else
 #define __CMSIS_GCC_OUT_REG(r) "=r" (r)
+#define __CMSIS_GCC_RW_REG(r) "+r" (r)
 #define __CMSIS_GCC_USE_REG(r) "r" (r)
 #endif
 
@@ -370,41 +833,28 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE void __set_FPSCR(uint32_t fps
   \brief   No Operation
   \details No Operation does nothing. This instruction can be used for code alignment purposes.
  */
-__attribute__((always_inline)) __STATIC_INLINE void __NOP(void)
-{
-  __ASM volatile ("nop");
-}
-
+#define __NOP()                             __ASM volatile ("nop")
 
 /**
   \brief   Wait For Interrupt
   \details Wait For Interrupt is a hint instruction that suspends execution until one of a number of events occurs.
  */
-__attribute__((always_inline)) __STATIC_INLINE void __WFI(void)
-{
-  __ASM volatile ("wfi");
-}
+#define __WFI()                             __ASM volatile ("wfi")
 
 
 /**
   \brief   Wait For Event
   \details Wait For Event is a hint instruction that permits the processor to enter
-    a low-power state until one of a number of events occurs.
+           a low-power state until one of a number of events occurs.
  */
-__attribute__((always_inline)) __STATIC_INLINE void __WFE(void)
-{
-  __ASM volatile ("wfe");
-}
+#define __WFE()                             __ASM volatile ("wfe")
 
 
 /**
   \brief   Send Event
   \details Send Event is a hint instruction. It causes an event to be signaled to the CPU.
  */
-__attribute__((always_inline)) __STATIC_INLINE void __SEV(void)
-{
-  __ASM volatile ("sev");
-}
+#define __SEV()                             __ASM volatile ("sev")
 
 
 /**
@@ -413,7 +863,7 @@ __attribute__((always_inline)) __STATIC_INLINE void __SEV(void)
            so that all instructions following the ISB are fetched from cache or memory,
            after the instruction has been completed.
  */
-__attribute__((always_inline)) __STATIC_INLINE void __ISB(void)
+__STATIC_FORCEINLINE void __ISB(void)
 {
   __ASM volatile ("isb 0xF":::"memory");
 }
@@ -424,7 +874,7 @@ __attribute__((always_inline)) __STATIC_INLINE void __ISB(void)
   \details Acts as a special kind of Data Memory Barrier.
            It completes when all explicit memory accesses before this instruction complete.
  */
-__attribute__((always_inline)) __STATIC_INLINE void __DSB(void)
+__STATIC_FORCEINLINE void __DSB(void)
 {
   __ASM volatile ("dsb 0xF":::"memory");
 }
@@ -435,7 +885,7 @@ __attribute__((always_inline)) __STATIC_INLINE void __DSB(void)
   \details Ensures the apparent order of the explicit memory operations before
            and after the instruction, without ensuring their completion.
  */
-__attribute__((always_inline)) __STATIC_INLINE void __DMB(void)
+__STATIC_FORCEINLINE void __DMB(void)
 {
   __ASM volatile ("dmb 0xF":::"memory");
 }
@@ -443,11 +893,11 @@ __attribute__((always_inline)) __STATIC_INLINE void __DMB(void)
 
 /**
   \brief   Reverse byte order (32 bit)
-  \details Reverses the byte order in integer value.
+  \details Reverses the byte order in unsigned integer value. For example, 0x12345678 becomes 0x78563412.
   \param [in]    value  Value to reverse
   \return               Reversed value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __REV(uint32_t value)
+__STATIC_FORCEINLINE uint32_t __REV(uint32_t value)
 {
 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
   return __builtin_bswap32(value);
@@ -455,41 +905,41 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __REV(uint32_t value)
   uint32_t result;
 
   __ASM volatile ("rev %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) );
-  return(result);
+  return result;
 #endif
 }
 
 
 /**
   \brief   Reverse byte order (16 bit)
-  \details Reverses the byte order in two unsigned short values.
+  \details Reverses the byte order within each halfword of a word. For example, 0x12345678 becomes 0x34127856.
   \param [in]    value  Value to reverse
   \return               Reversed value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __REV16(uint32_t value)
+__STATIC_FORCEINLINE uint32_t __REV16(uint32_t value)
 {
   uint32_t result;
 
   __ASM volatile ("rev16 %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) );
-  return(result);
+  return result;
 }
 
 
 /**
-  \brief   Reverse byte order in signed short value
-  \details Reverses the byte order in a signed short value with sign extension to integer.
+  \brief   Reverse byte order (16 bit)
+  \details Reverses the byte order in a 16-bit value and returns the signed 16-bit result. For example, 0x0080 becomes 0x8000.
   \param [in]    value  Value to reverse
   \return               Reversed value
  */
-__attribute__((always_inline)) __STATIC_INLINE int32_t __REVSH(int32_t value)
+__STATIC_FORCEINLINE int16_t __REVSH(int16_t value)
 {
 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
-  return (short)__builtin_bswap16(value);
+  return (int16_t)__builtin_bswap16(value);
 #else
-  int32_t result;
+  int16_t result;
 
   __ASM volatile ("revsh %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) );
-  return(result);
+  return result;
 #endif
 }
 
@@ -497,12 +947,17 @@ __attribute__((always_inline)) __STATIC_INLINE int32_t __REVSH(int32_t value)
 /**
   \brief   Rotate Right in unsigned value (32 bit)
   \details Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits.
-  \param [in]    value  Value to rotate
-  \param [in]    value  Number of Bits to rotate
+  \param [in]    op1  Value to rotate
+  \param [in]    op2  Number of Bits to rotate
   \return               Rotated value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __ROR(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __ROR(uint32_t op1, uint32_t op2)
 {
+  op2 %= 32U;
+  if (op2 == 0U)
+  {
+    return op1;
+  }
   return (op1 >> op2) | (op1 << (32U - op2));
 }
 
@@ -523,17 +978,19 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __ROR(uint32_t op1, uint
   \param [in]    value  Value to reverse
   \return               Reversed value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t value)
+__STATIC_FORCEINLINE uint32_t __RBIT(uint32_t value)
 {
   uint32_t result;
 
-#if       (__CORTEX_M >= 0x03U) || (__CORTEX_SC >= 300U)
+#if ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+     (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+     (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    )
    __ASM volatile ("rbit %0, %1" : "=r" (result) : "r" (value) );
 #else
-  int32_t s = 4 /*sizeof(v)*/ * 8 - 1; /* extra shift needed at end */
+  uint32_t s = (4U /*sizeof(v)*/ * 8U) - 1U; /* extra shift needed at end */
 
   result = value;                      /* r will be reversed bits of v; first get LSB of v */
-  for (value >>= 1U; value; value >>= 1U)
+  for (value >>= 1U; value != 0U; value >>= 1U)
   {
     result <<= 1U;
     result |= value & 1U;
@@ -541,7 +998,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t value)
   }
   result <<= s;                        /* shift when v's highest bits are zero */
 #endif
-  return(result);
+  return result;
 }
 
 
@@ -551,18 +1008,36 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t value)
   \param [in]  value  Value to count the leading zeros
   \return             number of leading zeros in value
  */
-#define __CLZ             __builtin_clz
-
+__STATIC_FORCEINLINE uint8_t __CLZ(uint32_t value)
+{
+  /* Even though __builtin_clz produces a CLZ instruction on ARM, formally
+     __builtin_clz(0) is undefined behaviour, so handle this case specially.
+     This guarantees ARM-compatible results if happening to compile on a non-ARM
+     target, and ensures the compiler doesn't decide to activate any
+     optimisations using the logic "value was passed to __builtin_clz, so it
+     is non-zero".
+     ARM GCC 7.3 and possibly earlier will optimise this test away, leaving a
+     single CLZ instruction.
+   */
+  if (value == 0U)
+  {
+    return 32U;
+  }
+  return __builtin_clz(value);
+}
 
-#if       (__CORTEX_M >= 0x03U) || (__CORTEX_SC >= 300U)
 
+#if ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+     (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+     (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+     (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    )
 /**
   \brief   LDR Exclusive (8 bit)
   \details Executes a exclusive LDR instruction for 8 bit value.
   \param [in]    ptr  Pointer to data
   \return             value of type uint8_t at (*ptr)
  */
-__attribute__((always_inline)) __STATIC_INLINE uint8_t __LDREXB(volatile uint8_t *addr)
+__STATIC_FORCEINLINE uint8_t __LDREXB(volatile uint8_t *addr)
 {
     uint32_t result;
 
@@ -584,7 +1059,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint8_t __LDREXB(volatile uint8_t
   \param [in]    ptr  Pointer to data
   \return        value of type uint16_t at (*ptr)
  */
-__attribute__((always_inline)) __STATIC_INLINE uint16_t __LDREXH(volatile uint16_t *addr)
+__STATIC_FORCEINLINE uint16_t __LDREXH(volatile uint16_t *addr)
 {
     uint32_t result;
 
@@ -606,7 +1081,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint16_t __LDREXH(volatile uint16
   \param [in]    ptr  Pointer to data
   \return        value of type uint32_t at (*ptr)
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __LDREXW(volatile uint32_t *addr)
+__STATIC_FORCEINLINE uint32_t __LDREXW(volatile uint32_t *addr)
 {
     uint32_t result;
 
@@ -623,7 +1098,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __LDREXW(volatile uint32
   \return          0  Function succeeded
   \return          1  Function failed
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __STREXB(uint8_t value, volatile uint8_t *addr)
+__STATIC_FORCEINLINE uint32_t __STREXB(uint8_t value, volatile uint8_t *addr)
 {
    uint32_t result;
 
@@ -640,7 +1115,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __STREXB(uint8_t value,
   \return          0  Function succeeded
   \return          1  Function failed
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __STREXH(uint16_t value, volatile uint16_t *addr)
+__STATIC_FORCEINLINE uint32_t __STREXH(uint16_t value, volatile uint16_t *addr)
 {
    uint32_t result;
 
@@ -657,7 +1132,7 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __STREXH(uint16_t value,
   \return          0  Function succeeded
   \return          1  Function failed
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __STREXW(uint32_t value, volatile uint32_t *addr)
+__STATIC_FORCEINLINE uint32_t __STREXW(uint32_t value, volatile uint32_t *addr)
 {
    uint32_t result;
 
@@ -670,22 +1145,31 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __STREXW(uint32_t value,
   \brief   Remove the exclusive lock
   \details Removes the exclusive lock which is created by LDREX.
  */
-__attribute__((always_inline)) __STATIC_INLINE void __CLREX(void)
+__STATIC_FORCEINLINE void __CLREX(void)
 {
   __ASM volatile ("clrex" ::: "memory");
 }
 
+#endif /* ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+           (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+           (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+           (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    ) */
+
 
+#if ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+     (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+     (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    )
 /**
   \brief   Signed Saturate
   \details Saturates a signed value.
-  \param [in]  value  Value to be saturated
-  \param [in]    sat  Bit position to saturate to (1..32)
+  \param [in]  ARG1  Value to be saturated
+  \param [in]  ARG2  Bit position to saturate to (1..32)
   \return             Saturated value
  */
 #define __SSAT(ARG1,ARG2) \
+__extension__ \
 ({                          \
-  uint32_t __RES, __ARG1 = (ARG1); \
+  int32_t __RES, __ARG1 = (ARG1); \
   __ASM ("ssat %0, %1, %2" : "=r" (__RES) :  "I" (ARG2), "r" (__ARG1) ); \
   __RES; \
  })
@@ -694,11 +1178,12 @@ __attribute__((always_inline)) __STATIC_INLINE void __CLREX(void)
 /**
   \brief   Unsigned Saturate
   \details Saturates an unsigned value.
-  \param [in]  value  Value to be saturated
-  \param [in]    sat  Bit position to saturate to (0..31)
+  \param [in]  ARG1  Value to be saturated
+  \param [in]  ARG2  Bit position to saturate to (0..31)
   \return             Saturated value
  */
 #define __USAT(ARG1,ARG2) \
+ __extension__ \
 ({                          \
   uint32_t __RES, __ARG1 = (ARG1); \
   __ASM ("usat %0, %1, %2" : "=r" (__RES) :  "I" (ARG2), "r" (__ARG1) ); \
@@ -713,7 +1198,7 @@ __attribute__((always_inline)) __STATIC_INLINE void __CLREX(void)
   \param [in]    value  Value to rotate
   \return               Rotated value
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __RRX(uint32_t value)
+__STATIC_FORCEINLINE uint32_t __RRX(uint32_t value)
 {
   uint32_t result;
 
@@ -728,17 +1213,17 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __RRX(uint32_t value)
   \param [in]    ptr  Pointer to data
   \return             value of type uint8_t at (*ptr)
  */
-__attribute__((always_inline)) __STATIC_INLINE uint8_t __LDRBT(volatile uint8_t *addr)
+__STATIC_FORCEINLINE uint8_t __LDRBT(volatile uint8_t *ptr)
 {
     uint32_t result;
 
 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
-   __ASM volatile ("ldrbt %0, %1" : "=r" (result) : "Q" (*addr) );
+   __ASM volatile ("ldrbt %0, %1" : "=r" (result) : "Q" (*ptr) );
 #else
     /* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not
        accepted by assembler. So has to use following less efficient pattern.
     */
-   __ASM volatile ("ldrbt %0, [%1]" : "=r" (result) : "r" (addr) : "memory" );
+   __ASM volatile ("ldrbt %0, [%1]" : "=r" (result) : "r" (ptr) : "memory" );
 #endif
    return ((uint8_t) result);    /* Add explicit type cast here */
 }
@@ -750,17 +1235,17 @@ __attribute__((always_inline)) __STATIC_INLINE uint8_t __LDRBT(volatile uint8_t
   \param [in]    ptr  Pointer to data
   \return        value of type uint16_t at (*ptr)
  */
-__attribute__((always_inline)) __STATIC_INLINE uint16_t __LDRHT(volatile uint16_t *addr)
+__STATIC_FORCEINLINE uint16_t __LDRHT(volatile uint16_t *ptr)
 {
     uint32_t result;
 
 #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
-   __ASM volatile ("ldrht %0, %1" : "=r" (result) : "Q" (*addr) );
+   __ASM volatile ("ldrht %0, %1" : "=r" (result) : "Q" (*ptr) );
 #else
     /* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not
        accepted by assembler. So has to use following less efficient pattern.
     */
-   __ASM volatile ("ldrht %0, [%1]" : "=r" (result) : "r" (addr) : "memory" );
+   __ASM volatile ("ldrht %0, [%1]" : "=r" (result) : "r" (ptr) : "memory" );
 #endif
    return ((uint16_t) result);    /* Add explicit type cast here */
 }
@@ -772,11 +1257,11 @@ __attribute__((always_inline)) __STATIC_INLINE uint16_t __LDRHT(volatile uint16_
   \param [in]    ptr  Pointer to data
   \return        value of type uint32_t at (*ptr)
  */
-__attribute__((always_inline)) __STATIC_INLINE uint32_t __LDRT(volatile uint32_t *addr)
+__STATIC_FORCEINLINE uint32_t __LDRT(volatile uint32_t *ptr)
 {
     uint32_t result;
 
-   __ASM volatile ("ldrt %0, %1" : "=r" (result) : "Q" (*addr) );
+   __ASM volatile ("ldrt %0, %1" : "=r" (result) : "Q" (*ptr) );
    return(result);
 }
 
@@ -787,9 +1272,9 @@ __attribute__((always_inline)) __STATIC_INLINE uint32_t __LDRT(volatile uint32_t
   \param [in]  value  Value to store
   \param [in]    ptr  Pointer to location
  */
-__attribute__((always_inline)) __STATIC_INLINE void __STRBT(uint8_t value, volatile uint8_t *addr)
+__STATIC_FORCEINLINE void __STRBT(uint8_t value, volatile uint8_t *ptr)
 {
-   __ASM volatile ("strbt %1, %0" : "=Q" (*addr) : "r" ((uint32_t)value) );
+   __ASM volatile ("strbt %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
 }
 
 
@@ -799,9 +1284,9 @@ __attribute__((always_inline)) __STATIC_INLINE void __STRBT(uint8_t value, volat
   \param [in]  value  Value to store
   \param [in]    ptr  Pointer to location
  */
-__attribute__((always_inline)) __STATIC_INLINE void __STRHT(uint16_t value, volatile uint16_t *addr)
+__STATIC_FORCEINLINE void __STRHT(uint16_t value, volatile uint16_t *ptr)
 {
-   __ASM volatile ("strht %1, %0" : "=Q" (*addr) : "r" ((uint32_t)value) );
+   __ASM volatile ("strht %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
 }
 
 
@@ -811,12 +1296,249 @@ __attribute__((always_inline)) __STATIC_INLINE void __STRHT(uint16_t value, vola
   \param [in]  value  Value to store
   \param [in]    ptr  Pointer to location
  */
-__attribute__((always_inline)) __STATIC_INLINE void __STRT(uint32_t value, volatile uint32_t *addr)
+__STATIC_FORCEINLINE void __STRT(uint32_t value, volatile uint32_t *ptr)
+{
+   __ASM volatile ("strt %1, %0" : "=Q" (*ptr) : "r" (value) );
+}
+
+#else  /* ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+           (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+           (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    ) */
+
+/**
+  \brief   Signed Saturate
+  \details Saturates a signed value.
+  \param [in]  value  Value to be saturated
+  \param [in]    sat  Bit position to saturate to (1..32)
+  \return             Saturated value
+ */
+__STATIC_FORCEINLINE int32_t __SSAT(int32_t val, uint32_t sat)
+{
+  if ((sat >= 1U) && (sat <= 32U))
+  {
+    const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U);
+    const int32_t min = -1 - max ;
+    if (val > max)
+    {
+      return max;
+    }
+    else if (val < min)
+    {
+      return min;
+    }
+  }
+  return val;
+}
+
+/**
+  \brief   Unsigned Saturate
+  \details Saturates an unsigned value.
+  \param [in]  value  Value to be saturated
+  \param [in]    sat  Bit position to saturate to (0..31)
+  \return             Saturated value
+ */
+__STATIC_FORCEINLINE uint32_t __USAT(int32_t val, uint32_t sat)
+{
+  if (sat <= 31U)
+  {
+    const uint32_t max = ((1U << sat) - 1U);
+    if (val > (int32_t)max)
+    {
+      return max;
+    }
+    else if (val < 0)
+    {
+      return 0U;
+    }
+  }
+  return (uint32_t)val;
+}
+
+#endif /* ((defined (__ARM_ARCH_7M__      ) && (__ARM_ARCH_7M__      == 1)) || \
+           (defined (__ARM_ARCH_7EM__     ) && (__ARM_ARCH_7EM__     == 1)) || \
+           (defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1))    ) */
+
+
+#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+     (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    )
+/**
+  \brief   Load-Acquire (8 bit)
+  \details Executes a LDAB instruction for 8 bit value.
+  \param [in]    ptr  Pointer to data
+  \return             value of type uint8_t at (*ptr)
+ */
+__STATIC_FORCEINLINE uint8_t __LDAB(volatile uint8_t *ptr)
+{
+    uint32_t result;
+
+   __ASM volatile ("ldab %0, %1" : "=r" (result) : "Q" (*ptr) );
+   return ((uint8_t) result);
+}
+
+
+/**
+  \brief   Load-Acquire (16 bit)
+  \details Executes a LDAH instruction for 16 bit values.
+  \param [in]    ptr  Pointer to data
+  \return        value of type uint16_t at (*ptr)
+ */
+__STATIC_FORCEINLINE uint16_t __LDAH(volatile uint16_t *ptr)
+{
+    uint32_t result;
+
+   __ASM volatile ("ldah %0, %1" : "=r" (result) : "Q" (*ptr) );
+   return ((uint16_t) result);
+}
+
+
+/**
+  \brief   Load-Acquire (32 bit)
+  \details Executes a LDA instruction for 32 bit values.
+  \param [in]    ptr  Pointer to data
+  \return        value of type uint32_t at (*ptr)
+ */
+__STATIC_FORCEINLINE uint32_t __LDA(volatile uint32_t *ptr)
+{
+    uint32_t result;
+
+   __ASM volatile ("lda %0, %1" : "=r" (result) : "Q" (*ptr) );
+   return(result);
+}
+
+
+/**
+  \brief   Store-Release (8 bit)
+  \details Executes a STLB instruction for 8 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+ */
+__STATIC_FORCEINLINE void __STLB(uint8_t value, volatile uint8_t *ptr)
 {
-   __ASM volatile ("strt %1, %0" : "=Q" (*addr) : "r" (value) );
+   __ASM volatile ("stlb %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
 }
 
-#endif /* (__CORTEX_M >= 0x03U) || (__CORTEX_SC >= 300U) */
+
+/**
+  \brief   Store-Release (16 bit)
+  \details Executes a STLH instruction for 16 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+ */
+__STATIC_FORCEINLINE void __STLH(uint16_t value, volatile uint16_t *ptr)
+{
+   __ASM volatile ("stlh %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
+}
+
+
+/**
+  \brief   Store-Release (32 bit)
+  \details Executes a STL instruction for 32 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+ */
+__STATIC_FORCEINLINE void __STL(uint32_t value, volatile uint32_t *ptr)
+{
+   __ASM volatile ("stl %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
+}
+
+
+/**
+  \brief   Load-Acquire Exclusive (8 bit)
+  \details Executes a LDAB exclusive instruction for 8 bit value.
+  \param [in]    ptr  Pointer to data
+  \return             value of type uint8_t at (*ptr)
+ */
+__STATIC_FORCEINLINE uint8_t __LDAEXB(volatile uint8_t *ptr)
+{
+    uint32_t result;
+
+   __ASM volatile ("ldaexb %0, %1" : "=r" (result) : "Q" (*ptr) );
+   return ((uint8_t) result);
+}
+
+
+/**
+  \brief   Load-Acquire Exclusive (16 bit)
+  \details Executes a LDAH exclusive instruction for 16 bit values.
+  \param [in]    ptr  Pointer to data
+  \return        value of type uint16_t at (*ptr)
+ */
+__STATIC_FORCEINLINE uint16_t __LDAEXH(volatile uint16_t *ptr)
+{
+    uint32_t result;
+
+   __ASM volatile ("ldaexh %0, %1" : "=r" (result) : "Q" (*ptr) );
+   return ((uint16_t) result);
+}
+
+
+/**
+  \brief   Load-Acquire Exclusive (32 bit)
+  \details Executes a LDA exclusive instruction for 32 bit values.
+  \param [in]    ptr  Pointer to data
+  \return        value of type uint32_t at (*ptr)
+ */
+__STATIC_FORCEINLINE uint32_t __LDAEX(volatile uint32_t *ptr)
+{
+    uint32_t result;
+
+   __ASM volatile ("ldaex %0, %1" : "=r" (result) : "Q" (*ptr) );
+   return(result);
+}
+
+
+/**
+  \brief   Store-Release Exclusive (8 bit)
+  \details Executes a STLB exclusive instruction for 8 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+  \return          0  Function succeeded
+  \return          1  Function failed
+ */
+__STATIC_FORCEINLINE uint32_t __STLEXB(uint8_t value, volatile uint8_t *ptr)
+{
+   uint32_t result;
+
+   __ASM volatile ("stlexb %0, %2, %1" : "=&r" (result), "=Q" (*ptr) : "r" ((uint32_t)value) );
+   return(result);
+}
+
+
+/**
+  \brief   Store-Release Exclusive (16 bit)
+  \details Executes a STLH exclusive instruction for 16 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+  \return          0  Function succeeded
+  \return          1  Function failed
+ */
+__STATIC_FORCEINLINE uint32_t __STLEXH(uint16_t value, volatile uint16_t *ptr)
+{
+   uint32_t result;
+
+   __ASM volatile ("stlexh %0, %2, %1" : "=&r" (result), "=Q" (*ptr) : "r" ((uint32_t)value) );
+   return(result);
+}
+
+
+/**
+  \brief   Store-Release Exclusive (32 bit)
+  \details Executes a STL exclusive instruction for 32 bit values.
+  \param [in]  value  Value to store
+  \param [in]    ptr  Pointer to location
+  \return          0  Function succeeded
+  \return          1  Function failed
+ */
+__STATIC_FORCEINLINE uint32_t __STLEX(uint32_t value, volatile uint32_t *ptr)
+{
+   uint32_t result;
+
+   __ASM volatile ("stlex %0, %2, %1" : "=&r" (result), "=Q" (*ptr) : "r" ((uint32_t)value) );
+   return(result);
+}
+
+#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+           (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    ) */
 
 /*@}*/ /* end of group CMSIS_Core_InstructionInterface */
 
@@ -827,9 +1549,9 @@ __attribute__((always_inline)) __STATIC_INLINE void __STRT(uint32_t value, volat
   @{
 */
 
-#if (__CORTEX_M >= 0x04U)  /* only for Cortex-M4 and above */
+#if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1))
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SADD8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SADD8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -837,7 +1559,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SADD8(uint32_t op1
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QADD8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __QADD8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -845,7 +1567,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QADD8(uint32_t op1
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHADD8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SHADD8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -853,7 +1575,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHADD8(uint32_t op
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UADD8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UADD8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -861,7 +1583,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UADD8(uint32_t op1
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQADD8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UQADD8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -869,7 +1591,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQADD8(uint32_t op
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHADD8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UHADD8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -878,7 +1600,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHADD8(uint32_t op
 }
 
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SSUB8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SSUB8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -886,7 +1608,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SSUB8(uint32_t op1
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QSUB8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __QSUB8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -894,7 +1616,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QSUB8(uint32_t op1
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHSUB8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SHSUB8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -902,7 +1624,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHSUB8(uint32_t op
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __USUB8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __USUB8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -910,7 +1632,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __USUB8(uint32_t op1
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQSUB8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UQSUB8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -918,7 +1640,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQSUB8(uint32_t op
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHSUB8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UHSUB8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -927,7 +1649,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHSUB8(uint32_t op
 }
 
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SADD16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SADD16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -935,7 +1657,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SADD16(uint32_t op
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QADD16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __QADD16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -943,7 +1665,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QADD16(uint32_t op
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHADD16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SHADD16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -951,7 +1673,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHADD16(uint32_t o
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UADD16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UADD16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -959,7 +1681,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UADD16(uint32_t op
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQADD16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UQADD16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -967,7 +1689,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQADD16(uint32_t o
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHADD16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UHADD16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -975,7 +1697,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHADD16(uint32_t o
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SSUB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SSUB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -983,7 +1705,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SSUB16(uint32_t op
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QSUB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __QSUB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -991,7 +1713,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QSUB16(uint32_t op
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHSUB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SHSUB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -999,7 +1721,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHSUB16(uint32_t o
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __USUB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __USUB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1007,7 +1729,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __USUB16(uint32_t op
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQSUB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UQSUB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1015,7 +1737,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQSUB16(uint32_t o
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHSUB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UHSUB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1023,7 +1745,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHSUB16(uint32_t o
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SASX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SASX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1031,7 +1753,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SASX(uint32_t op1,
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QASX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __QASX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1039,7 +1761,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QASX(uint32_t op1,
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHASX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SHASX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1047,7 +1769,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHASX(uint32_t op1
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UASX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UASX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1055,7 +1777,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UASX(uint32_t op1,
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQASX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UQASX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1063,7 +1785,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQASX(uint32_t op1
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHASX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UHASX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1071,7 +1793,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHASX(uint32_t op1
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SSAX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SSAX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1079,7 +1801,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SSAX(uint32_t op1,
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QSAX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __QSAX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1087,7 +1809,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __QSAX(uint32_t op1,
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHSAX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SHSAX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1095,7 +1817,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SHSAX(uint32_t op1
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __USAX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __USAX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1103,7 +1825,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __USAX(uint32_t op1,
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQSAX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UQSAX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1111,7 +1833,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UQSAX(uint32_t op1
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHSAX(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UHSAX(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1119,7 +1841,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UHSAX(uint32_t op1
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __USAD8(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __USAD8(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1127,7 +1849,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __USAD8(uint32_t op1
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __USADA8(uint32_t op1, uint32_t op2, uint32_t op3)
+__STATIC_FORCEINLINE uint32_t __USADA8(uint32_t op1, uint32_t op2, uint32_t op3)
 {
   uint32_t result;
 
@@ -1149,7 +1871,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __USADA8(uint32_t op
   __RES; \
  })
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UXTB16(uint32_t op1)
+__STATIC_FORCEINLINE uint32_t __UXTB16(uint32_t op1)
 {
   uint32_t result;
 
@@ -1157,7 +1879,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UXTB16(uint32_t op
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UXTAB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __UXTAB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1165,7 +1887,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __UXTAB16(uint32_t o
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SXTB16(uint32_t op1)
+__STATIC_FORCEINLINE uint32_t __SXTB16(uint32_t op1)
 {
   uint32_t result;
 
@@ -1173,7 +1895,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SXTB16(uint32_t op
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SXTAB16(uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SXTAB16(uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1181,7 +1903,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SXTAB16(uint32_t o
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMUAD  (uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SMUAD  (uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1189,7 +1911,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMUAD  (uint32_t o
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMUADX (uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SMUADX (uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1197,7 +1919,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMUADX (uint32_t o
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMLAD (uint32_t op1, uint32_t op2, uint32_t op3)
+__STATIC_FORCEINLINE uint32_t __SMLAD (uint32_t op1, uint32_t op2, uint32_t op3)
 {
   uint32_t result;
 
@@ -1205,7 +1927,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMLAD (uint32_t op
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMLADX (uint32_t op1, uint32_t op2, uint32_t op3)
+__STATIC_FORCEINLINE uint32_t __SMLADX (uint32_t op1, uint32_t op2, uint32_t op3)
 {
   uint32_t result;
 
@@ -1213,7 +1935,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMLADX (uint32_t o
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint64_t __SMLALD (uint32_t op1, uint32_t op2, uint64_t acc)
+__STATIC_FORCEINLINE uint64_t __SMLALD (uint32_t op1, uint32_t op2, uint64_t acc)
 {
   union llreg_u{
     uint32_t w32[2];
@@ -1230,7 +1952,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint64_t __SMLALD (uint32_t o
   return(llr.w64);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint64_t __SMLALDX (uint32_t op1, uint32_t op2, uint64_t acc)
+__STATIC_FORCEINLINE uint64_t __SMLALDX (uint32_t op1, uint32_t op2, uint64_t acc)
 {
   union llreg_u{
     uint32_t w32[2];
@@ -1247,7 +1969,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint64_t __SMLALDX (uint32_t
   return(llr.w64);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMUSD  (uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SMUSD  (uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1255,7 +1977,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMUSD  (uint32_t o
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMUSDX (uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SMUSDX (uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1263,7 +1985,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMUSDX (uint32_t o
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMLSD (uint32_t op1, uint32_t op2, uint32_t op3)
+__STATIC_FORCEINLINE uint32_t __SMLSD (uint32_t op1, uint32_t op2, uint32_t op3)
 {
   uint32_t result;
 
@@ -1271,7 +1993,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMLSD (uint32_t op
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMLSDX (uint32_t op1, uint32_t op2, uint32_t op3)
+__STATIC_FORCEINLINE uint32_t __SMLSDX (uint32_t op1, uint32_t op2, uint32_t op3)
 {
   uint32_t result;
 
@@ -1279,7 +2001,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMLSDX (uint32_t o
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint64_t __SMLSLD (uint32_t op1, uint32_t op2, uint64_t acc)
+__STATIC_FORCEINLINE uint64_t __SMLSLD (uint32_t op1, uint32_t op2, uint64_t acc)
 {
   union llreg_u{
     uint32_t w32[2];
@@ -1296,7 +2018,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint64_t __SMLSLD (uint32_t o
   return(llr.w64);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint64_t __SMLSLDX (uint32_t op1, uint32_t op2, uint64_t acc)
+__STATIC_FORCEINLINE uint64_t __SMLSLDX (uint32_t op1, uint32_t op2, uint64_t acc)
 {
   union llreg_u{
     uint32_t w32[2];
@@ -1313,7 +2035,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint64_t __SMLSLDX (uint32_t
   return(llr.w64);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SEL  (uint32_t op1, uint32_t op2)
+__STATIC_FORCEINLINE uint32_t __SEL  (uint32_t op1, uint32_t op2)
 {
   uint32_t result;
 
@@ -1321,7 +2043,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SEL  (uint32_t op1
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE  int32_t __QADD( int32_t op1,  int32_t op2)
+__STATIC_FORCEINLINE  int32_t __QADD( int32_t op1,  int32_t op2)
 {
   int32_t result;
 
@@ -1329,7 +2051,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE  int32_t __QADD( int32_t op1,
   return(result);
 }
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE  int32_t __QSUB( int32_t op1,  int32_t op2)
+__STATIC_FORCEINLINE  int32_t __QSUB( int32_t op1,  int32_t op2)
 {
   int32_t result;
 
@@ -1337,6 +2059,7 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE  int32_t __QSUB( int32_t op1,
   return(result);
 }
 
+#if 0
 #define __PKHBT(ARG1,ARG2,ARG3) \
 ({                          \
   uint32_t __RES, __ARG1 = (ARG1), __ARG2 = (ARG2); \
@@ -1353,8 +2076,15 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE  int32_t __QSUB( int32_t op1,
     __ASM ("pkhtb %0, %1, %2, asr %3" : "=r" (__RES) :  "r" (__ARG1), "r" (__ARG2), "I" (ARG3)  ); \
   __RES; \
  })
+#endif
 
-__attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMMLA (int32_t op1, int32_t op2, int32_t op3)
+#define __PKHBT(ARG1,ARG2,ARG3)          ( ((((uint32_t)(ARG1))          ) & 0x0000FFFFUL) |  \
+                                           ((((uint32_t)(ARG2)) << (ARG3)) & 0xFFFF0000UL)  )
+
+#define __PKHTB(ARG1,ARG2,ARG3)          ( ((((uint32_t)(ARG1))          ) & 0xFFFF0000UL) |  \
+                                           ((((uint32_t)(ARG2)) >> (ARG3)) & 0x0000FFFFUL)  )
+
+__STATIC_FORCEINLINE int32_t __SMMLA (int32_t op1, int32_t op2, int32_t op3)
 {
  int32_t result;
 
@@ -1362,12 +2092,10 @@ __attribute__( ( always_inline ) ) __STATIC_INLINE uint32_t __SMMLA (int32_t op1
  return(result);
 }
 
-#endif /* (__CORTEX_M >= 0x04) */
+#endif /* (__ARM_FEATURE_DSP == 1) */
 /*@} end of group CMSIS_SIMD_intrinsics */
 
 
-#if defined ( __GNUC__ )
 #pragma GCC diagnostic pop
-#endif
 
 #endif /* __CMSIS_GCC_H */
diff --git a/lib/cmsis/inc/cmsis_iccarm.h b/lib/cmsis/inc/cmsis_iccarm.h
new file mode 100644
index 0000000000000..20b50ce380d6c
--- /dev/null
+++ b/lib/cmsis/inc/cmsis_iccarm.h
@@ -0,0 +1,940 @@
+/**************************************************************************//**
+ * @file     cmsis_iccarm.h
+ * @brief    CMSIS compiler ICCARM (IAR Compiler for Arm) header file
+ * @version  V5.0.8
+ * @date     04. September 2018
+ ******************************************************************************/
+
+//------------------------------------------------------------------------------
+//
+// Copyright (c) 2017-2018 IAR Systems
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//------------------------------------------------------------------------------
+
+
+#ifndef __CMSIS_ICCARM_H__
+#define __CMSIS_ICCARM_H__
+
+#ifndef __ICCARM__
+  #error This file should only be compiled by ICCARM
+#endif
+
+#pragma system_include
+
+#define __IAR_FT _Pragma("inline=forced") __intrinsic
+
+#if (__VER__ >= 8000000)
+  #define __ICCARM_V8 1
+#else
+  #define __ICCARM_V8 0
+#endif
+
+#ifndef __ALIGNED
+  #if __ICCARM_V8
+    #define __ALIGNED(x) __attribute__((aligned(x)))
+  #elif (__VER__ >= 7080000)
+    /* Needs IAR language extensions */
+    #define __ALIGNED(x) __attribute__((aligned(x)))
+  #else
+    #warning No compiler specific solution for __ALIGNED.__ALIGNED is ignored.
+    #define __ALIGNED(x)
+  #endif
+#endif
+
+
+/* Define compiler macros for CPU architecture, used in CMSIS 5.
+ */
+#if __ARM_ARCH_6M__ || __ARM_ARCH_7M__ || __ARM_ARCH_7EM__ || __ARM_ARCH_8M_BASE__ || __ARM_ARCH_8M_MAIN__
+/* Macros already defined */
+#else
+  #if defined(__ARM8M_MAINLINE__) || defined(__ARM8EM_MAINLINE__)
+    #define __ARM_ARCH_8M_MAIN__ 1
+  #elif defined(__ARM8M_BASELINE__)
+    #define __ARM_ARCH_8M_BASE__ 1
+  #elif defined(__ARM_ARCH_PROFILE) && __ARM_ARCH_PROFILE == 'M'
+    #if __ARM_ARCH == 6
+      #define __ARM_ARCH_6M__ 1
+    #elif __ARM_ARCH == 7
+      #if __ARM_FEATURE_DSP
+        #define __ARM_ARCH_7EM__ 1
+      #else
+        #define __ARM_ARCH_7M__ 1
+      #endif
+    #endif /* __ARM_ARCH */
+  #endif /* __ARM_ARCH_PROFILE == 'M' */
+#endif
+
+/* Alternativ core deduction for older ICCARM's */
+#if !defined(__ARM_ARCH_6M__) && !defined(__ARM_ARCH_7M__) && !defined(__ARM_ARCH_7EM__) && \
+    !defined(__ARM_ARCH_8M_BASE__) && !defined(__ARM_ARCH_8M_MAIN__)
+  #if defined(__ARM6M__) && (__CORE__ == __ARM6M__)
+    #define __ARM_ARCH_6M__ 1
+  #elif defined(__ARM7M__) && (__CORE__ == __ARM7M__)
+    #define __ARM_ARCH_7M__ 1
+  #elif defined(__ARM7EM__) && (__CORE__ == __ARM7EM__)
+    #define __ARM_ARCH_7EM__  1
+  #elif defined(__ARM8M_BASELINE__) && (__CORE == __ARM8M_BASELINE__)
+    #define __ARM_ARCH_8M_BASE__ 1
+  #elif defined(__ARM8M_MAINLINE__) && (__CORE == __ARM8M_MAINLINE__)
+    #define __ARM_ARCH_8M_MAIN__ 1
+  #elif defined(__ARM8EM_MAINLINE__) && (__CORE == __ARM8EM_MAINLINE__)
+    #define __ARM_ARCH_8M_MAIN__ 1
+  #else
+    #error "Unknown target."
+  #endif
+#endif
+
+
+
+#if defined(__ARM_ARCH_6M__) && __ARM_ARCH_6M__==1
+  #define __IAR_M0_FAMILY  1
+#elif defined(__ARM_ARCH_8M_BASE__) && __ARM_ARCH_8M_BASE__==1
+  #define __IAR_M0_FAMILY  1
+#else
+  #define __IAR_M0_FAMILY  0
+#endif
+
+
+#ifndef __ASM
+  #define __ASM __asm
+#endif
+
+#ifndef __INLINE
+  #define __INLINE inline
+#endif
+
+#ifndef   __NO_RETURN
+  #if __ICCARM_V8
+    #define __NO_RETURN __attribute__((__noreturn__))
+  #else
+    #define __NO_RETURN _Pragma("object_attribute=__noreturn")
+  #endif
+#endif
+
+#ifndef   __PACKED
+  #if __ICCARM_V8
+    #define __PACKED __attribute__((packed, aligned(1)))
+  #else
+    /* Needs IAR language extensions */
+    #define __PACKED __packed
+  #endif
+#endif
+
+#ifndef   __PACKED_STRUCT
+  #if __ICCARM_V8
+    #define __PACKED_STRUCT struct __attribute__((packed, aligned(1)))
+  #else
+    /* Needs IAR language extensions */
+    #define __PACKED_STRUCT __packed struct
+  #endif
+#endif
+
+#ifndef   __PACKED_UNION
+  #if __ICCARM_V8
+    #define __PACKED_UNION union __attribute__((packed, aligned(1)))
+  #else
+    /* Needs IAR language extensions */
+    #define __PACKED_UNION __packed union
+  #endif
+#endif
+
+#ifndef   __RESTRICT
+  #if __ICCARM_V8
+    #define __RESTRICT            __restrict
+  #else
+    /* Needs IAR language extensions */
+    #define __RESTRICT            restrict
+  #endif
+#endif
+
+#ifndef   __STATIC_INLINE
+  #define __STATIC_INLINE       static inline
+#endif
+
+#ifndef   __FORCEINLINE
+  #define __FORCEINLINE         _Pragma("inline=forced")
+#endif
+
+#ifndef   __STATIC_FORCEINLINE
+  #define __STATIC_FORCEINLINE  __FORCEINLINE __STATIC_INLINE
+#endif
+
+#ifndef __UNALIGNED_UINT16_READ
+#pragma language=save
+#pragma language=extended
+__IAR_FT uint16_t __iar_uint16_read(void const *ptr)
+{
+  return *(__packed uint16_t*)(ptr);
+}
+#pragma language=restore
+#define __UNALIGNED_UINT16_READ(PTR) __iar_uint16_read(PTR)
+#endif
+
+
+#ifndef __UNALIGNED_UINT16_WRITE
+#pragma language=save
+#pragma language=extended
+__IAR_FT void __iar_uint16_write(void const *ptr, uint16_t val)
+{
+  *(__packed uint16_t*)(ptr) = val;;
+}
+#pragma language=restore
+#define __UNALIGNED_UINT16_WRITE(PTR,VAL) __iar_uint16_write(PTR,VAL)
+#endif
+
+#ifndef __UNALIGNED_UINT32_READ
+#pragma language=save
+#pragma language=extended
+__IAR_FT uint32_t __iar_uint32_read(void const *ptr)
+{
+  return *(__packed uint32_t*)(ptr);
+}
+#pragma language=restore
+#define __UNALIGNED_UINT32_READ(PTR) __iar_uint32_read(PTR)
+#endif
+
+#ifndef __UNALIGNED_UINT32_WRITE
+#pragma language=save
+#pragma language=extended
+__IAR_FT void __iar_uint32_write(void const *ptr, uint32_t val)
+{
+  *(__packed uint32_t*)(ptr) = val;;
+}
+#pragma language=restore
+#define __UNALIGNED_UINT32_WRITE(PTR,VAL) __iar_uint32_write(PTR,VAL)
+#endif
+
+#ifndef __UNALIGNED_UINT32   /* deprecated */
+#pragma language=save
+#pragma language=extended
+__packed struct  __iar_u32 { uint32_t v; };
+#pragma language=restore
+#define __UNALIGNED_UINT32(PTR) (((struct __iar_u32 *)(PTR))->v)
+#endif
+
+#ifndef   __USED
+  #if __ICCARM_V8
+    #define __USED __attribute__((used))
+  #else
+    #define __USED _Pragma("__root")
+  #endif
+#endif
+
+#ifndef   __WEAK
+  #if __ICCARM_V8
+    #define __WEAK __attribute__((weak))
+  #else
+    #define __WEAK _Pragma("__weak")
+  #endif
+#endif
+
+
+#ifndef __ICCARM_INTRINSICS_VERSION__
+  #define __ICCARM_INTRINSICS_VERSION__  0
+#endif
+
+#if __ICCARM_INTRINSICS_VERSION__ == 2
+
+  #if defined(__CLZ)
+    #undef __CLZ
+  #endif
+  #if defined(__REVSH)
+    #undef __REVSH
+  #endif
+  #if defined(__RBIT)
+    #undef __RBIT
+  #endif
+  #if defined(__SSAT)
+    #undef __SSAT
+  #endif
+  #if defined(__USAT)
+    #undef __USAT
+  #endif
+
+  #include "iccarm_builtin.h"
+
+  #define __disable_fault_irq __iar_builtin_disable_fiq
+  #define __disable_irq       __iar_builtin_disable_interrupt
+  #define __enable_fault_irq  __iar_builtin_enable_fiq
+  #define __enable_irq        __iar_builtin_enable_interrupt
+  #define __arm_rsr           __iar_builtin_rsr
+  #define __arm_wsr           __iar_builtin_wsr
+
+
+  #define __get_APSR()                (__arm_rsr("APSR"))
+  #define __get_BASEPRI()             (__arm_rsr("BASEPRI"))
+  #define __get_CONTROL()             (__arm_rsr("CONTROL"))
+  #define __get_FAULTMASK()           (__arm_rsr("FAULTMASK"))
+
+  #if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
+       (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     )
+    #define __get_FPSCR()             (__arm_rsr("FPSCR"))
+    #define __set_FPSCR(VALUE)        (__arm_wsr("FPSCR", (VALUE)))
+  #else
+    #define __get_FPSCR()             ( 0 )
+    #define __set_FPSCR(VALUE)        ((void)VALUE)
+  #endif
+
+  #define __get_IPSR()                (__arm_rsr("IPSR"))
+  #define __get_MSP()                 (__arm_rsr("MSP"))
+  #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+       (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+    // without main extensions, the non-secure MSPLIM is RAZ/WI
+    #define __get_MSPLIM()            (0U)
+  #else
+    #define __get_MSPLIM()            (__arm_rsr("MSPLIM"))
+  #endif
+  #define __get_PRIMASK()             (__arm_rsr("PRIMASK"))
+  #define __get_PSP()                 (__arm_rsr("PSP"))
+
+  #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+       (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+    // without main extensions, the non-secure PSPLIM is RAZ/WI
+    #define __get_PSPLIM()            (0U)
+  #else
+    #define __get_PSPLIM()            (__arm_rsr("PSPLIM"))
+  #endif
+
+  #define __get_xPSR()                (__arm_rsr("xPSR"))
+
+  #define __set_BASEPRI(VALUE)        (__arm_wsr("BASEPRI", (VALUE)))
+  #define __set_BASEPRI_MAX(VALUE)    (__arm_wsr("BASEPRI_MAX", (VALUE)))
+  #define __set_CONTROL(VALUE)        (__arm_wsr("CONTROL", (VALUE)))
+  #define __set_FAULTMASK(VALUE)      (__arm_wsr("FAULTMASK", (VALUE)))
+  #define __set_MSP(VALUE)            (__arm_wsr("MSP", (VALUE)))
+
+  #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+       (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+    // without main extensions, the non-secure MSPLIM is RAZ/WI
+    #define __set_MSPLIM(VALUE)       ((void)(VALUE))
+  #else
+    #define __set_MSPLIM(VALUE)       (__arm_wsr("MSPLIM", (VALUE)))
+  #endif
+  #define __set_PRIMASK(VALUE)        (__arm_wsr("PRIMASK", (VALUE)))
+  #define __set_PSP(VALUE)            (__arm_wsr("PSP", (VALUE)))
+  #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+       (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+    // without main extensions, the non-secure PSPLIM is RAZ/WI
+    #define __set_PSPLIM(VALUE)       ((void)(VALUE))
+  #else
+    #define __set_PSPLIM(VALUE)       (__arm_wsr("PSPLIM", (VALUE)))
+  #endif
+
+  #define __TZ_get_CONTROL_NS()       (__arm_rsr("CONTROL_NS"))
+  #define __TZ_set_CONTROL_NS(VALUE)  (__arm_wsr("CONTROL_NS", (VALUE)))
+  #define __TZ_get_PSP_NS()           (__arm_rsr("PSP_NS"))
+  #define __TZ_set_PSP_NS(VALUE)      (__arm_wsr("PSP_NS", (VALUE)))
+  #define __TZ_get_MSP_NS()           (__arm_rsr("MSP_NS"))
+  #define __TZ_set_MSP_NS(VALUE)      (__arm_wsr("MSP_NS", (VALUE)))
+  #define __TZ_get_SP_NS()            (__arm_rsr("SP_NS"))
+  #define __TZ_set_SP_NS(VALUE)       (__arm_wsr("SP_NS", (VALUE)))
+  #define __TZ_get_PRIMASK_NS()       (__arm_rsr("PRIMASK_NS"))
+  #define __TZ_set_PRIMASK_NS(VALUE)  (__arm_wsr("PRIMASK_NS", (VALUE)))
+  #define __TZ_get_BASEPRI_NS()       (__arm_rsr("BASEPRI_NS"))
+  #define __TZ_set_BASEPRI_NS(VALUE)  (__arm_wsr("BASEPRI_NS", (VALUE)))
+  #define __TZ_get_FAULTMASK_NS()     (__arm_rsr("FAULTMASK_NS"))
+  #define __TZ_set_FAULTMASK_NS(VALUE)(__arm_wsr("FAULTMASK_NS", (VALUE)))
+
+  #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+       (!defined (__ARM_FEATURE_CMSE) || (__ARM_FEATURE_CMSE < 3)))
+    // without main extensions, the non-secure PSPLIM is RAZ/WI
+    #define __TZ_get_PSPLIM_NS()      (0U)
+    #define __TZ_set_PSPLIM_NS(VALUE) ((void)(VALUE))
+  #else
+    #define __TZ_get_PSPLIM_NS()      (__arm_rsr("PSPLIM_NS"))
+    #define __TZ_set_PSPLIM_NS(VALUE) (__arm_wsr("PSPLIM_NS", (VALUE)))
+  #endif
+
+  #define __TZ_get_MSPLIM_NS()        (__arm_rsr("MSPLIM_NS"))
+  #define __TZ_set_MSPLIM_NS(VALUE)   (__arm_wsr("MSPLIM_NS", (VALUE)))
+
+  #define __NOP     __iar_builtin_no_operation
+
+  #define __CLZ     __iar_builtin_CLZ
+  #define __CLREX   __iar_builtin_CLREX
+
+  #define __DMB     __iar_builtin_DMB
+  #define __DSB     __iar_builtin_DSB
+  #define __ISB     __iar_builtin_ISB
+
+  #define __LDREXB  __iar_builtin_LDREXB
+  #define __LDREXH  __iar_builtin_LDREXH
+  #define __LDREXW  __iar_builtin_LDREX
+
+  #define __RBIT    __iar_builtin_RBIT
+  #define __REV     __iar_builtin_REV
+  #define __REV16   __iar_builtin_REV16
+
+  __IAR_FT int16_t __REVSH(int16_t val)
+  {
+    return (int16_t) __iar_builtin_REVSH(val);
+  }
+
+  #define __ROR     __iar_builtin_ROR
+  #define __RRX     __iar_builtin_RRX
+
+  #define __SEV     __iar_builtin_SEV
+
+  #if !__IAR_M0_FAMILY
+    #define __SSAT    __iar_builtin_SSAT
+  #endif
+
+  #define __STREXB  __iar_builtin_STREXB
+  #define __STREXH  __iar_builtin_STREXH
+  #define __STREXW  __iar_builtin_STREX
+
+  #if !__IAR_M0_FAMILY
+    #define __USAT    __iar_builtin_USAT
+  #endif
+
+  #define __WFE     __iar_builtin_WFE
+  #define __WFI     __iar_builtin_WFI
+
+  #if __ARM_MEDIA__
+    #define __SADD8   __iar_builtin_SADD8
+    #define __QADD8   __iar_builtin_QADD8
+    #define __SHADD8  __iar_builtin_SHADD8
+    #define __UADD8   __iar_builtin_UADD8
+    #define __UQADD8  __iar_builtin_UQADD8
+    #define __UHADD8  __iar_builtin_UHADD8
+    #define __SSUB8   __iar_builtin_SSUB8
+    #define __QSUB8   __iar_builtin_QSUB8
+    #define __SHSUB8  __iar_builtin_SHSUB8
+    #define __USUB8   __iar_builtin_USUB8
+    #define __UQSUB8  __iar_builtin_UQSUB8
+    #define __UHSUB8  __iar_builtin_UHSUB8
+    #define __SADD16  __iar_builtin_SADD16
+    #define __QADD16  __iar_builtin_QADD16
+    #define __SHADD16 __iar_builtin_SHADD16
+    #define __UADD16  __iar_builtin_UADD16
+    #define __UQADD16 __iar_builtin_UQADD16
+    #define __UHADD16 __iar_builtin_UHADD16
+    #define __SSUB16  __iar_builtin_SSUB16
+    #define __QSUB16  __iar_builtin_QSUB16
+    #define __SHSUB16 __iar_builtin_SHSUB16
+    #define __USUB16  __iar_builtin_USUB16
+    #define __UQSUB16 __iar_builtin_UQSUB16
+    #define __UHSUB16 __iar_builtin_UHSUB16
+    #define __SASX    __iar_builtin_SASX
+    #define __QASX    __iar_builtin_QASX
+    #define __SHASX   __iar_builtin_SHASX
+    #define __UASX    __iar_builtin_UASX
+    #define __UQASX   __iar_builtin_UQASX
+    #define __UHASX   __iar_builtin_UHASX
+    #define __SSAX    __iar_builtin_SSAX
+    #define __QSAX    __iar_builtin_QSAX
+    #define __SHSAX   __iar_builtin_SHSAX
+    #define __USAX    __iar_builtin_USAX
+    #define __UQSAX   __iar_builtin_UQSAX
+    #define __UHSAX   __iar_builtin_UHSAX
+    #define __USAD8   __iar_builtin_USAD8
+    #define __USADA8  __iar_builtin_USADA8
+    #define __SSAT16  __iar_builtin_SSAT16
+    #define __USAT16  __iar_builtin_USAT16
+    #define __UXTB16  __iar_builtin_UXTB16
+    #define __UXTAB16 __iar_builtin_UXTAB16
+    #define __SXTB16  __iar_builtin_SXTB16
+    #define __SXTAB16 __iar_builtin_SXTAB16
+    #define __SMUAD   __iar_builtin_SMUAD
+    #define __SMUADX  __iar_builtin_SMUADX
+    #define __SMMLA   __iar_builtin_SMMLA
+    #define __SMLAD   __iar_builtin_SMLAD
+    #define __SMLADX  __iar_builtin_SMLADX
+    #define __SMLALD  __iar_builtin_SMLALD
+    #define __SMLALDX __iar_builtin_SMLALDX
+    #define __SMUSD   __iar_builtin_SMUSD
+    #define __SMUSDX  __iar_builtin_SMUSDX
+    #define __SMLSD   __iar_builtin_SMLSD
+    #define __SMLSDX  __iar_builtin_SMLSDX
+    #define __SMLSLD  __iar_builtin_SMLSLD
+    #define __SMLSLDX __iar_builtin_SMLSLDX
+    #define __SEL     __iar_builtin_SEL
+    #define __QADD    __iar_builtin_QADD
+    #define __QSUB    __iar_builtin_QSUB
+    #define __PKHBT   __iar_builtin_PKHBT
+    #define __PKHTB   __iar_builtin_PKHTB
+  #endif
+
+#else /* __ICCARM_INTRINSICS_VERSION__ == 2 */
+
+  #if __IAR_M0_FAMILY
+   /* Avoid clash between intrinsics.h and arm_math.h when compiling for Cortex-M0. */
+    #define __CLZ  __cmsis_iar_clz_not_active
+    #define __SSAT __cmsis_iar_ssat_not_active
+    #define __USAT __cmsis_iar_usat_not_active
+    #define __RBIT __cmsis_iar_rbit_not_active
+    #define __get_APSR  __cmsis_iar_get_APSR_not_active
+  #endif
+
+
+  #if (!((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
+         (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     ))
+    #define __get_FPSCR __cmsis_iar_get_FPSR_not_active
+    #define __set_FPSCR __cmsis_iar_set_FPSR_not_active
+  #endif
+
+  #ifdef __INTRINSICS_INCLUDED
+  #error intrinsics.h is already included previously!
+  #endif
+
+  #include <intrinsics.h>
+
+  #if __IAR_M0_FAMILY
+   /* Avoid clash between intrinsics.h and arm_math.h when compiling for Cortex-M0. */
+    #undef __CLZ
+    #undef __SSAT
+    #undef __USAT
+    #undef __RBIT
+    #undef __get_APSR
+
+    __STATIC_INLINE uint8_t __CLZ(uint32_t data)
+    {
+      if (data == 0U) { return 32U; }
+
+      uint32_t count = 0U;
+      uint32_t mask = 0x80000000U;
+
+      while ((data & mask) == 0U)
+      {
+        count += 1U;
+        mask = mask >> 1U;
+      }
+      return count;
+    }
+
+    __STATIC_INLINE uint32_t __RBIT(uint32_t v)
+    {
+      uint8_t sc = 31U;
+      uint32_t r = v;
+      for (v >>= 1U; v; v >>= 1U)
+      {
+        r <<= 1U;
+        r |= v & 1U;
+        sc--;
+      }
+      return (r << sc);
+    }
+
+    __STATIC_INLINE  uint32_t __get_APSR(void)
+    {
+      uint32_t res;
+      __asm("MRS      %0,APSR" : "=r" (res));
+      return res;
+    }
+
+  #endif
+
+  #if (!((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
+         (defined (__FPU_USED   ) && (__FPU_USED    == 1U))     ))
+    #undef __get_FPSCR
+    #undef __set_FPSCR
+    #define __get_FPSCR()       (0)
+    #define __set_FPSCR(VALUE)  ((void)VALUE)
+  #endif
+
+  #pragma diag_suppress=Pe940
+  #pragma diag_suppress=Pe177
+
+  #define __enable_irq    __enable_interrupt
+  #define __disable_irq   __disable_interrupt
+  #define __NOP           __no_operation
+
+  #define __get_xPSR      __get_PSR
+
+  #if (!defined(__ARM_ARCH_6M__) || __ARM_ARCH_6M__==0)
+
+    __IAR_FT uint32_t __LDREXW(uint32_t volatile *ptr)
+    {
+      return __LDREX((unsigned long *)ptr);
+    }
+
+    __IAR_FT uint32_t __STREXW(uint32_t value, uint32_t volatile *ptr)
+    {
+      return __STREX(value, (unsigned long *)ptr);
+    }
+  #endif
+
+
+  /* __CORTEX_M is defined in core_cm0.h, core_cm3.h and core_cm4.h. */
+  #if (__CORTEX_M >= 0x03)
+
+    __IAR_FT uint32_t __RRX(uint32_t value)
+    {
+      uint32_t result;
+      __ASM("RRX      %0, %1" : "=r"(result) : "r" (value) : "cc");
+      return(result);
+    }
+
+    __IAR_FT void __set_BASEPRI_MAX(uint32_t value)
+    {
+      __asm volatile("MSR      BASEPRI_MAX,%0"::"r" (value));
+    }
+
+
+    #define __enable_fault_irq  __enable_fiq
+    #define __disable_fault_irq __disable_fiq
+
+
+  #endif /* (__CORTEX_M >= 0x03) */
+
+  __IAR_FT uint32_t __ROR(uint32_t op1, uint32_t op2)
+  {
+    return (op1 >> op2) | (op1 << ((sizeof(op1)*8)-op2));
+  }
+
+  #if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+       (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    )
+
+   __IAR_FT uint32_t __get_MSPLIM(void)
+    {
+      uint32_t res;
+    #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+         (!defined (__ARM_FEATURE_CMSE  ) || (__ARM_FEATURE_CMSE   < 3)))
+      // without main extensions, the non-secure MSPLIM is RAZ/WI
+      res = 0U;
+    #else
+      __asm volatile("MRS      %0,MSPLIM" : "=r" (res));
+    #endif
+      return res;
+    }
+
+    __IAR_FT void   __set_MSPLIM(uint32_t value)
+    {
+    #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+         (!defined (__ARM_FEATURE_CMSE  ) || (__ARM_FEATURE_CMSE   < 3)))
+      // without main extensions, the non-secure MSPLIM is RAZ/WI
+      (void)value;
+    #else
+      __asm volatile("MSR      MSPLIM,%0" :: "r" (value));
+    #endif
+    }
+
+    __IAR_FT uint32_t __get_PSPLIM(void)
+    {
+      uint32_t res;
+    #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+         (!defined (__ARM_FEATURE_CMSE  ) || (__ARM_FEATURE_CMSE   < 3)))
+      // without main extensions, the non-secure PSPLIM is RAZ/WI
+      res = 0U;
+    #else
+      __asm volatile("MRS      %0,PSPLIM" : "=r" (res));
+    #endif
+      return res;
+    }
+
+    __IAR_FT void   __set_PSPLIM(uint32_t value)
+    {
+    #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+         (!defined (__ARM_FEATURE_CMSE  ) || (__ARM_FEATURE_CMSE   < 3)))
+      // without main extensions, the non-secure PSPLIM is RAZ/WI
+      (void)value;
+    #else
+      __asm volatile("MSR      PSPLIM,%0" :: "r" (value));
+    #endif
+    }
+
+    __IAR_FT uint32_t __TZ_get_CONTROL_NS(void)
+    {
+      uint32_t res;
+      __asm volatile("MRS      %0,CONTROL_NS" : "=r" (res));
+      return res;
+    }
+
+    __IAR_FT void   __TZ_set_CONTROL_NS(uint32_t value)
+    {
+      __asm volatile("MSR      CONTROL_NS,%0" :: "r" (value));
+    }
+
+    __IAR_FT uint32_t   __TZ_get_PSP_NS(void)
+    {
+      uint32_t res;
+      __asm volatile("MRS      %0,PSP_NS" : "=r" (res));
+      return res;
+    }
+
+    __IAR_FT void   __TZ_set_PSP_NS(uint32_t value)
+    {
+      __asm volatile("MSR      PSP_NS,%0" :: "r" (value));
+    }
+
+    __IAR_FT uint32_t   __TZ_get_MSP_NS(void)
+    {
+      uint32_t res;
+      __asm volatile("MRS      %0,MSP_NS" : "=r" (res));
+      return res;
+    }
+
+    __IAR_FT void   __TZ_set_MSP_NS(uint32_t value)
+    {
+      __asm volatile("MSR      MSP_NS,%0" :: "r" (value));
+    }
+
+    __IAR_FT uint32_t   __TZ_get_SP_NS(void)
+    {
+      uint32_t res;
+      __asm volatile("MRS      %0,SP_NS" : "=r" (res));
+      return res;
+    }
+    __IAR_FT void   __TZ_set_SP_NS(uint32_t value)
+    {
+      __asm volatile("MSR      SP_NS,%0" :: "r" (value));
+    }
+
+    __IAR_FT uint32_t   __TZ_get_PRIMASK_NS(void)
+    {
+      uint32_t res;
+      __asm volatile("MRS      %0,PRIMASK_NS" : "=r" (res));
+      return res;
+    }
+
+    __IAR_FT void   __TZ_set_PRIMASK_NS(uint32_t value)
+    {
+      __asm volatile("MSR      PRIMASK_NS,%0" :: "r" (value));
+    }
+
+    __IAR_FT uint32_t   __TZ_get_BASEPRI_NS(void)
+    {
+      uint32_t res;
+      __asm volatile("MRS      %0,BASEPRI_NS" : "=r" (res));
+      return res;
+    }
+
+    __IAR_FT void   __TZ_set_BASEPRI_NS(uint32_t value)
+    {
+      __asm volatile("MSR      BASEPRI_NS,%0" :: "r" (value));
+    }
+
+    __IAR_FT uint32_t   __TZ_get_FAULTMASK_NS(void)
+    {
+      uint32_t res;
+      __asm volatile("MRS      %0,FAULTMASK_NS" : "=r" (res));
+      return res;
+    }
+
+    __IAR_FT void   __TZ_set_FAULTMASK_NS(uint32_t value)
+    {
+      __asm volatile("MSR      FAULTMASK_NS,%0" :: "r" (value));
+    }
+
+    __IAR_FT uint32_t   __TZ_get_PSPLIM_NS(void)
+    {
+      uint32_t res;
+    #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+         (!defined (__ARM_FEATURE_CMSE  ) || (__ARM_FEATURE_CMSE   < 3)))
+      // without main extensions, the non-secure PSPLIM is RAZ/WI
+      res = 0U;
+    #else
+      __asm volatile("MRS      %0,PSPLIM_NS" : "=r" (res));
+    #endif
+      return res;
+    }
+
+    __IAR_FT void   __TZ_set_PSPLIM_NS(uint32_t value)
+    {
+    #if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
+         (!defined (__ARM_FEATURE_CMSE  ) || (__ARM_FEATURE_CMSE   < 3)))
+      // without main extensions, the non-secure PSPLIM is RAZ/WI
+      (void)value;
+    #else
+      __asm volatile("MSR      PSPLIM_NS,%0" :: "r" (value));
+    #endif
+    }
+
+    __IAR_FT uint32_t   __TZ_get_MSPLIM_NS(void)
+    {
+      uint32_t res;
+      __asm volatile("MRS      %0,MSPLIM_NS" : "=r" (res));
+      return res;
+    }
+
+    __IAR_FT void   __TZ_set_MSPLIM_NS(uint32_t value)
+    {
+      __asm volatile("MSR      MSPLIM_NS,%0" :: "r" (value));
+    }
+
+  #endif /* __ARM_ARCH_8M_MAIN__ or __ARM_ARCH_8M_BASE__ */
+
+#endif   /* __ICCARM_INTRINSICS_VERSION__ == 2 */
+
+#define __BKPT(value)    __asm volatile ("BKPT     %0" : : "i"(value))
+
+#if __IAR_M0_FAMILY
+  __STATIC_INLINE int32_t __SSAT(int32_t val, uint32_t sat)
+  {
+    if ((sat >= 1U) && (sat <= 32U))
+    {
+      const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U);
+      const int32_t min = -1 - max ;
+      if (val > max)
+      {
+        return max;
+      }
+      else if (val < min)
+      {
+        return min;
+      }
+    }
+    return val;
+  }
+
+  __STATIC_INLINE uint32_t __USAT(int32_t val, uint32_t sat)
+  {
+    if (sat <= 31U)
+    {
+      const uint32_t max = ((1U << sat) - 1U);
+      if (val > (int32_t)max)
+      {
+        return max;
+      }
+      else if (val < 0)
+      {
+        return 0U;
+      }
+    }
+    return (uint32_t)val;
+  }
+#endif
+
+#if (__CORTEX_M >= 0x03)   /* __CORTEX_M is defined in core_cm0.h, core_cm3.h and core_cm4.h. */
+
+  __IAR_FT uint8_t __LDRBT(volatile uint8_t *addr)
+  {
+    uint32_t res;
+    __ASM("LDRBT %0, [%1]" : "=r" (res) : "r" (addr) : "memory");
+    return ((uint8_t)res);
+  }
+
+  __IAR_FT uint16_t __LDRHT(volatile uint16_t *addr)
+  {
+    uint32_t res;
+    __ASM("LDRHT %0, [%1]" : "=r" (res) : "r" (addr) : "memory");
+    return ((uint16_t)res);
+  }
+
+  __IAR_FT uint32_t __LDRT(volatile uint32_t *addr)
+  {
+    uint32_t res;
+    __ASM("LDRT %0, [%1]" : "=r" (res) : "r" (addr) : "memory");
+    return res;
+  }
+
+  __IAR_FT void __STRBT(uint8_t value, volatile uint8_t *addr)
+  {
+    __ASM("STRBT %1, [%0]" : : "r" (addr), "r" ((uint32_t)value) : "memory");
+  }
+
+  __IAR_FT void __STRHT(uint16_t value, volatile uint16_t *addr)
+  {
+    __ASM("STRHT %1, [%0]" : : "r" (addr), "r" ((uint32_t)value) : "memory");
+  }
+
+  __IAR_FT void __STRT(uint32_t value, volatile uint32_t *addr)
+  {
+    __ASM("STRT %1, [%0]" : : "r" (addr), "r" (value) : "memory");
+  }
+
+#endif /* (__CORTEX_M >= 0x03) */
+
+#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
+     (defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1))    )
+
+
+  __IAR_FT uint8_t __LDAB(volatile uint8_t *ptr)
+  {
+    uint32_t res;
+    __ASM volatile ("LDAB %0, [%1]" : "=r" (res) : "r" (ptr) : "memory");
+    return ((uint8_t)res);
+  }
+
+  __IAR_FT uint16_t __LDAH(volatile uint16_t *ptr)
+  {
+    uint32_t res;
+    __ASM volatile ("LDAH %0, [%1]" : "=r" (res) : "r" (ptr) : "memory");
+    return ((uint16_t)res);
+  }
+
+  __IAR_FT uint32_t __LDA(volatile uint32_t *ptr)
+  {
+    uint32_t res;
+    __ASM volatile ("LDA %0, [%1]" : "=r" (res) : "r" (ptr) : "memory");
+    return res;
+  }
+
+  __IAR_FT void __STLB(uint8_t value, volatile uint8_t *ptr)
+  {
+    __ASM volatile ("STLB %1, [%0]" :: "r" (ptr), "r" (value) : "memory");
+  }
+
+  __IAR_FT void __STLH(uint16_t value, volatile uint16_t *ptr)
+  {
+    __ASM volatile ("STLH %1, [%0]" :: "r" (ptr), "r" (value) : "memory");
+  }
+
+  __IAR_FT void __STL(uint32_t value, volatile uint32_t *ptr)
+  {
+    __ASM volatile ("STL %1, [%0]" :: "r" (ptr), "r" (value) : "memory");
+  }
+
+  __IAR_FT uint8_t __LDAEXB(volatile uint8_t *ptr)
+  {
+    uint32_t res;
+    __ASM volatile ("LDAEXB %0, [%1]" : "=r" (res) : "r" (ptr) : "memory");
+    return ((uint8_t)res);
+  }
+
+  __IAR_FT uint16_t __LDAEXH(volatile uint16_t *ptr)
+  {
+    uint32_t res;
+    __ASM volatile ("LDAEXH %0, [%1]" : "=r" (res) : "r" (ptr) : "memory");
+    return ((uint16_t)res);
+  }
+
+  __IAR_FT uint32_t __LDAEX(volatile uint32_t *ptr)
+  {
+    uint32_t res;
+    __ASM volatile ("LDAEX %0, [%1]" : "=r" (res) : "r" (ptr) : "memory");
+    return res;
+  }
+
+  __IAR_FT uint32_t __STLEXB(uint8_t value, volatile uint8_t *ptr)
+  {
+    uint32_t res;
+    __ASM volatile ("STLEXB %0, %2, [%1]" : "=r" (res) : "r" (ptr), "r" (value) : "memory");
+    return res;
+  }
+
+  __IAR_FT uint32_t __STLEXH(uint16_t value, volatile uint16_t *ptr)
+  {
+    uint32_t res;
+    __ASM volatile ("STLEXH %0, %2, [%1]" : "=r" (res) : "r" (ptr), "r" (value) : "memory");
+    return res;
+  }
+
+  __IAR_FT uint32_t __STLEX(uint32_t value, volatile uint32_t *ptr)
+  {
+    uint32_t res;
+    __ASM volatile ("STLEX %0, %2, [%1]" : "=r" (res) : "r" (ptr), "r" (value) : "memory");
+    return res;
+  }
+
+#endif /* __ARM_ARCH_8M_MAIN__ or __ARM_ARCH_8M_BASE__ */
+
+#undef __IAR_FT
+#undef __IAR_M0_FAMILY
+#undef __ICCARM_V8
+
+#pragma diag_default=Pe940
+#pragma diag_default=Pe177
+
+#endif /* __CMSIS_ICCARM_H__ */
diff --git a/lib/cmsis/inc/cmsis_version.h b/lib/cmsis/inc/cmsis_version.h
new file mode 100644
index 0000000000000..660f612aa31fe
--- /dev/null
+++ b/lib/cmsis/inc/cmsis_version.h
@@ -0,0 +1,39 @@
+/**************************************************************************//**
+ * @file     cmsis_version.h
+ * @brief    CMSIS Core(M) Version definitions
+ * @version  V5.0.2
+ * @date     19. April 2017
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2017 ARM Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if   defined ( __ICCARM__ )
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
+  #pragma clang system_header   /* treat file as system include file */
+#endif
+
+#ifndef __CMSIS_VERSION_H
+#define __CMSIS_VERSION_H
+
+/*  CMSIS Version definitions */
+#define __CM_CMSIS_VERSION_MAIN  ( 5U)                                      /*!< [31:16] CMSIS Core(M) main version */
+#define __CM_CMSIS_VERSION_SUB   ( 1U)                                      /*!< [15:0]  CMSIS Core(M) sub version */
+#define __CM_CMSIS_VERSION       ((__CM_CMSIS_VERSION_MAIN << 16U) | \
+                                   __CM_CMSIS_VERSION_SUB           )       /*!< CMSIS Core(M) version number */
+#endif
diff --git a/lib/cmsis/inc/core_armv81mml.h b/lib/cmsis/inc/core_armv81mml.h
new file mode 100644
index 0000000000000..db6d9f23638b6
--- /dev/null
+++ b/lib/cmsis/inc/core_armv81mml.h
@@ -0,0 +1,2967 @@
+/**************************************************************************//**
+ * @file     core_armv81mml.h
+ * @brief    CMSIS Armv8.1-M Mainline Core Peripheral Access Layer Header File
+ * @version  V1.0.0
+ * @date     15. March 2019
+ ******************************************************************************/
+/*
+ * Copyright (c) 2018-2019 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if   defined ( __ICCARM__ )
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
+  #pragma clang system_header   /* treat file as system include file */
+#endif
+
+#ifndef __CORE_ARMV81MML_H_GENERIC
+#define __CORE_ARMV81MML_H_GENERIC
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/**
+  \page CMSIS_MISRA_Exceptions  MISRA-C:2004 Compliance Exceptions
+  CMSIS violates the following MISRA-C:2004 rules:
+
+   \li Required Rule 8.5, object/function definition in header file.<br>
+     Function definitions in header files are used to allow 'inlining'.
+
+   \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.<br>
+     Unions are used for effective representation of core registers.
+
+   \li Advisory Rule 19.7, Function-like macro defined.<br>
+     Function-like macros are used to allow more efficient code.
+ */
+
+
+/*******************************************************************************
+ *                 CMSIS definitions
+ ******************************************************************************/
+/**
+  \ingroup Cortex_ARMV81MML
+  @{
+ */
+
+#include "cmsis_version.h"
+ 
+#define __ARM_ARCH_8M_MAIN__    1  // patching for now
+/*  CMSIS ARMV81MML definitions */
+#define __ARMv81MML_CMSIS_VERSION_MAIN  (__CM_CMSIS_VERSION_MAIN)                   /*!< \deprecated [31:16] CMSIS HAL main version */
+#define __ARMv81MML_CMSIS_VERSION_SUB   (__CM_CMSIS_VERSION_SUB)                    /*!< \deprecated [15:0]  CMSIS HAL sub version */
+#define __ARMv81MML_CMSIS_VERSION       ((__ARMv81MML_CMSIS_VERSION_MAIN << 16U) | \
+                                         __ARMv81MML_CMSIS_VERSION_SUB           )  /*!< \deprecated CMSIS HAL version number */
+
+#define __CORTEX_M                     (81U)                                       /*!< Cortex-M Core */
+
+/** __FPU_USED indicates whether an FPU is used or not.
+    For this, __FPU_PRESENT has to be checked prior to making use of FPU specific registers and functions.
+*/
+#if defined ( __CC_ARM )
+  #if defined __TARGET_FPU_VFP
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+  #if defined(__ARM_FEATURE_DSP)
+    #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U    
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+  
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #if defined __ARM_FP
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+  #if defined(__ARM_FEATURE_DSP)
+    #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U    
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+
+#elif defined ( __GNUC__ )
+  #if defined (__VFP_FP__) && !defined(__SOFTFP__)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+  
+  #if defined(__ARM_FEATURE_DSP)
+    #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U    
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+  
+#elif defined ( __ICCARM__ )
+  #if defined __ARMVFP__
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+  #if defined(__ARM_FEATURE_DSP)
+    #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U    
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+  
+#elif defined ( __TI_ARM__ )
+  #if defined __TI_VFP_SUPPORT__
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+#elif defined ( __TASKING__ )
+  #if defined __FPU_VFP__
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+#elif defined ( __CSMC__ )
+  #if ( __CSMC__ & 0x400U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+#endif
+
+#include "cmsis_compiler.h"               /* CMSIS compiler specific defines */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CORE_ARMV81MML_H_GENERIC */
+
+#ifndef __CMSIS_GENERIC
+
+#ifndef __CORE_ARMV81MML_H_DEPENDANT
+#define __CORE_ARMV81MML_H_DEPENDANT
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/* check device defines and use defaults */
+#if defined __CHECK_DEVICE_DEFINES
+  #ifndef __ARMv81MML_REV
+    #define __ARMv81MML_REV               0x0000U
+    #warning "__ARMv81MML_REV not defined in device header file; using default!"
+  #endif
+
+  #ifndef __FPU_PRESENT
+    #define __FPU_PRESENT             0U
+    #warning "__FPU_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __MPU_PRESENT
+    #define __MPU_PRESENT             0U
+    #warning "__MPU_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __SAUREGION_PRESENT
+    #define __SAUREGION_PRESENT       0U
+    #warning "__SAUREGION_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __DSP_PRESENT
+    #define __DSP_PRESENT             0U
+    #warning "__DSP_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __NVIC_PRIO_BITS
+    #define __NVIC_PRIO_BITS          3U
+    #warning "__NVIC_PRIO_BITS not defined in device header file; using default!"
+  #endif
+
+  #ifndef __Vendor_SysTickConfig
+    #define __Vendor_SysTickConfig    0U
+    #warning "__Vendor_SysTickConfig not defined in device header file; using default!"
+  #endif
+#endif
+
+/* IO definitions (access restrictions to peripheral registers) */
+/**
+    \defgroup CMSIS_glob_defs CMSIS Global Defines
+
+    <strong>IO Type Qualifiers</strong> are used
+    \li to specify the access to peripheral variables.
+    \li for automatic generation of peripheral register debug information.
+*/
+#ifdef __cplusplus
+  #define   __I     volatile             /*!< Defines 'read only' permissions */
+#else
+  #define   __I     volatile const       /*!< Defines 'read only' permissions */
+#endif
+#define     __O     volatile             /*!< Defines 'write only' permissions */
+#define     __IO    volatile             /*!< Defines 'read / write' permissions */
+
+/* following defines should be used for structure members */
+#define     __IM     volatile const      /*! Defines 'read only' structure member permissions */
+#define     __OM     volatile            /*! Defines 'write only' structure member permissions */
+#define     __IOM    volatile            /*! Defines 'read / write' structure member permissions */
+
+/*@} end of group ARMv81MML */
+
+
+
+/*******************************************************************************
+ *                 Register Abstraction
+  Core Register contain:
+  - Core Register
+  - Core NVIC Register
+  - Core SCB Register
+  - Core SysTick Register
+  - Core Debug Register
+  - Core MPU Register
+  - Core SAU Register
+  - Core FPU Register
+ ******************************************************************************/
+/**
+  \defgroup CMSIS_core_register Defines and Type Definitions
+  \brief Type definitions and defines for Cortex-M processor based devices.
+*/
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_CORE  Status and Control Registers
+  \brief      Core Register type definitions.
+  @{
+ */
+
+/**
+  \brief  Union type to access the Application Program Status Register (APSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t _reserved0:16;              /*!< bit:  0..15  Reserved */
+    uint32_t GE:4;                       /*!< bit: 16..19  Greater than or Equal flags */
+    uint32_t _reserved1:7;               /*!< bit: 20..26  Reserved */
+    uint32_t Q:1;                        /*!< bit:     27  Saturation condition flag */
+    uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
+    uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
+    uint32_t Z:1;                        /*!< bit:     30  Zero condition code flag */
+    uint32_t N:1;                        /*!< bit:     31  Negative condition code flag */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} APSR_Type;
+
+/* APSR Register Definitions */
+#define APSR_N_Pos                         31U                                            /*!< APSR: N Position */
+#define APSR_N_Msk                         (1UL << APSR_N_Pos)                            /*!< APSR: N Mask */
+
+#define APSR_Z_Pos                         30U                                            /*!< APSR: Z Position */
+#define APSR_Z_Msk                         (1UL << APSR_Z_Pos)                            /*!< APSR: Z Mask */
+
+#define APSR_C_Pos                         29U                                            /*!< APSR: C Position */
+#define APSR_C_Msk                         (1UL << APSR_C_Pos)                            /*!< APSR: C Mask */
+
+#define APSR_V_Pos                         28U                                            /*!< APSR: V Position */
+#define APSR_V_Msk                         (1UL << APSR_V_Pos)                            /*!< APSR: V Mask */
+
+#define APSR_Q_Pos                         27U                                            /*!< APSR: Q Position */
+#define APSR_Q_Msk                         (1UL << APSR_Q_Pos)                            /*!< APSR: Q Mask */
+
+#define APSR_GE_Pos                        16U                                            /*!< APSR: GE Position */
+#define APSR_GE_Msk                        (0xFUL << APSR_GE_Pos)                         /*!< APSR: GE Mask */
+
+
+/**
+  \brief  Union type to access the Interrupt Program Status Register (IPSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
+    uint32_t _reserved0:23;              /*!< bit:  9..31  Reserved */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} IPSR_Type;
+
+/* IPSR Register Definitions */
+#define IPSR_ISR_Pos                        0U                                            /*!< IPSR: ISR Position */
+#define IPSR_ISR_Msk                       (0x1FFUL /*<< IPSR_ISR_Pos*/)                  /*!< IPSR: ISR Mask */
+
+
+/**
+  \brief  Union type to access the Special-Purpose Program Status Registers (xPSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
+    uint32_t _reserved0:7;               /*!< bit:  9..15  Reserved */
+    uint32_t GE:4;                       /*!< bit: 16..19  Greater than or Equal flags */
+    uint32_t _reserved1:4;               /*!< bit: 20..23  Reserved */
+    uint32_t T:1;                        /*!< bit:     24  Thumb bit        (read 0) */
+    uint32_t IT:2;                       /*!< bit: 25..26  saved IT state   (read 0) */
+    uint32_t Q:1;                        /*!< bit:     27  Saturation condition flag */
+    uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
+    uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
+    uint32_t Z:1;                        /*!< bit:     30  Zero condition code flag */
+    uint32_t N:1;                        /*!< bit:     31  Negative condition code flag */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} xPSR_Type;
+
+/* xPSR Register Definitions */
+#define xPSR_N_Pos                         31U                                            /*!< xPSR: N Position */
+#define xPSR_N_Msk                         (1UL << xPSR_N_Pos)                            /*!< xPSR: N Mask */
+
+#define xPSR_Z_Pos                         30U                                            /*!< xPSR: Z Position */
+#define xPSR_Z_Msk                         (1UL << xPSR_Z_Pos)                            /*!< xPSR: Z Mask */
+
+#define xPSR_C_Pos                         29U                                            /*!< xPSR: C Position */
+#define xPSR_C_Msk                         (1UL << xPSR_C_Pos)                            /*!< xPSR: C Mask */
+
+#define xPSR_V_Pos                         28U                                            /*!< xPSR: V Position */
+#define xPSR_V_Msk                         (1UL << xPSR_V_Pos)                            /*!< xPSR: V Mask */
+
+#define xPSR_Q_Pos                         27U                                            /*!< xPSR: Q Position */
+#define xPSR_Q_Msk                         (1UL << xPSR_Q_Pos)                            /*!< xPSR: Q Mask */
+
+#define xPSR_IT_Pos                        25U                                            /*!< xPSR: IT Position */
+#define xPSR_IT_Msk                        (3UL << xPSR_IT_Pos)                           /*!< xPSR: IT Mask */
+
+#define xPSR_T_Pos                         24U                                            /*!< xPSR: T Position */
+#define xPSR_T_Msk                         (1UL << xPSR_T_Pos)                            /*!< xPSR: T Mask */
+
+#define xPSR_GE_Pos                        16U                                            /*!< xPSR: GE Position */
+#define xPSR_GE_Msk                        (0xFUL << xPSR_GE_Pos)                         /*!< xPSR: GE Mask */
+
+#define xPSR_ISR_Pos                        0U                                            /*!< xPSR: ISR Position */
+#define xPSR_ISR_Msk                       (0x1FFUL /*<< xPSR_ISR_Pos*/)                  /*!< xPSR: ISR Mask */
+
+
+/**
+  \brief  Union type to access the Control Registers (CONTROL).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t nPRIV:1;                    /*!< bit:      0  Execution privilege in Thread mode */
+    uint32_t SPSEL:1;                    /*!< bit:      1  Stack-pointer select */
+    uint32_t FPCA:1;                     /*!< bit:      2  Floating-point context active */
+    uint32_t SFPA:1;                     /*!< bit:      3  Secure floating-point active */
+    uint32_t _reserved1:28;              /*!< bit:  4..31  Reserved */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} CONTROL_Type;
+
+/* CONTROL Register Definitions */
+#define CONTROL_SFPA_Pos                    3U                                            /*!< CONTROL: SFPA Position */
+#define CONTROL_SFPA_Msk                   (1UL << CONTROL_SFPA_Pos)                      /*!< CONTROL: SFPA Mask */
+
+#define CONTROL_FPCA_Pos                    2U                                            /*!< CONTROL: FPCA Position */
+#define CONTROL_FPCA_Msk                   (1UL << CONTROL_FPCA_Pos)                      /*!< CONTROL: FPCA Mask */
+
+#define CONTROL_SPSEL_Pos                   1U                                            /*!< CONTROL: SPSEL Position */
+#define CONTROL_SPSEL_Msk                  (1UL << CONTROL_SPSEL_Pos)                     /*!< CONTROL: SPSEL Mask */
+
+#define CONTROL_nPRIV_Pos                   0U                                            /*!< CONTROL: nPRIV Position */
+#define CONTROL_nPRIV_Msk                  (1UL /*<< CONTROL_nPRIV_Pos*/)                 /*!< CONTROL: nPRIV Mask */
+
+/*@} end of group CMSIS_CORE */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_NVIC  Nested Vectored Interrupt Controller (NVIC)
+  \brief      Type definitions for the NVIC Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Nested Vectored Interrupt Controller (NVIC).
+ */
+typedef struct
+{
+  __IOM uint32_t ISER[16U];              /*!< Offset: 0x000 (R/W)  Interrupt Set Enable Register */
+        uint32_t RESERVED0[16U];
+  __IOM uint32_t ICER[16U];              /*!< Offset: 0x080 (R/W)  Interrupt Clear Enable Register */
+        uint32_t RSERVED1[16U];
+  __IOM uint32_t ISPR[16U];              /*!< Offset: 0x100 (R/W)  Interrupt Set Pending Register */
+        uint32_t RESERVED2[16U];
+  __IOM uint32_t ICPR[16U];              /*!< Offset: 0x180 (R/W)  Interrupt Clear Pending Register */
+        uint32_t RESERVED3[16U];
+  __IOM uint32_t IABR[16U];              /*!< Offset: 0x200 (R/W)  Interrupt Active bit Register */
+        uint32_t RESERVED4[16U];
+  __IOM uint32_t ITNS[16U];              /*!< Offset: 0x280 (R/W)  Interrupt Non-Secure State Register */
+        uint32_t RESERVED5[16U];
+  __IOM uint8_t  IPR[496U];              /*!< Offset: 0x300 (R/W)  Interrupt Priority Register (8Bit wide) */
+        uint32_t RESERVED6[580U];
+  __OM  uint32_t STIR;                   /*!< Offset: 0xE00 ( /W)  Software Trigger Interrupt Register */
+}  NVIC_Type;
+
+/* Software Triggered Interrupt Register Definitions */
+#define NVIC_STIR_INTID_Pos                 0U                                         /*!< STIR: INTLINESNUM Position */
+#define NVIC_STIR_INTID_Msk                (0x1FFUL /*<< NVIC_STIR_INTID_Pos*/)        /*!< STIR: INTLINESNUM Mask */
+
+/*@} end of group CMSIS_NVIC */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SCB     System Control Block (SCB)
+  \brief    Type definitions for the System Control Block Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Control Block (SCB).
+ */
+typedef struct
+{
+  __IM  uint32_t CPUID;                  /*!< Offset: 0x000 (R/ )  CPUID Base Register */
+  __IOM uint32_t ICSR;                   /*!< Offset: 0x004 (R/W)  Interrupt Control and State Register */
+  __IOM uint32_t VTOR;                   /*!< Offset: 0x008 (R/W)  Vector Table Offset Register */
+  __IOM uint32_t AIRCR;                  /*!< Offset: 0x00C (R/W)  Application Interrupt and Reset Control Register */
+  __IOM uint32_t SCR;                    /*!< Offset: 0x010 (R/W)  System Control Register */
+  __IOM uint32_t CCR;                    /*!< Offset: 0x014 (R/W)  Configuration Control Register */
+  __IOM uint8_t  SHPR[12U];              /*!< Offset: 0x018 (R/W)  System Handlers Priority Registers (4-7, 8-11, 12-15) */
+  __IOM uint32_t SHCSR;                  /*!< Offset: 0x024 (R/W)  System Handler Control and State Register */
+  __IOM uint32_t CFSR;                   /*!< Offset: 0x028 (R/W)  Configurable Fault Status Register */
+  __IOM uint32_t HFSR;                   /*!< Offset: 0x02C (R/W)  HardFault Status Register */
+  __IOM uint32_t DFSR;                   /*!< Offset: 0x030 (R/W)  Debug Fault Status Register */
+  __IOM uint32_t MMFAR;                  /*!< Offset: 0x034 (R/W)  MemManage Fault Address Register */
+  __IOM uint32_t BFAR;                   /*!< Offset: 0x038 (R/W)  BusFault Address Register */
+  __IOM uint32_t AFSR;                   /*!< Offset: 0x03C (R/W)  Auxiliary Fault Status Register */
+  __IM  uint32_t ID_PFR[2U];             /*!< Offset: 0x040 (R/ )  Processor Feature Register */
+  __IM  uint32_t ID_DFR;                 /*!< Offset: 0x048 (R/ )  Debug Feature Register */
+  __IM  uint32_t ID_ADR;                 /*!< Offset: 0x04C (R/ )  Auxiliary Feature Register */
+  __IM  uint32_t ID_MMFR[4U];            /*!< Offset: 0x050 (R/ )  Memory Model Feature Register */
+  __IM  uint32_t ID_ISAR[6U];            /*!< Offset: 0x060 (R/ )  Instruction Set Attributes Register */
+  __IM  uint32_t CLIDR;                  /*!< Offset: 0x078 (R/ )  Cache Level ID register */
+  __IM  uint32_t CTR;                    /*!< Offset: 0x07C (R/ )  Cache Type register */
+  __IM  uint32_t CCSIDR;                 /*!< Offset: 0x080 (R/ )  Cache Size ID Register */
+  __IOM uint32_t CSSELR;                 /*!< Offset: 0x084 (R/W)  Cache Size Selection Register */
+  __IOM uint32_t CPACR;                  /*!< Offset: 0x088 (R/W)  Coprocessor Access Control Register */
+  __IOM uint32_t NSACR;                  /*!< Offset: 0x08C (R/W)  Non-Secure Access Control Register */
+        uint32_t RESERVED3[92U];
+  __OM  uint32_t STIR;                   /*!< Offset: 0x200 ( /W)  Software Triggered Interrupt Register */
+        uint32_t RESERVED4[15U];
+  __IM  uint32_t MVFR0;                  /*!< Offset: 0x240 (R/ )  Media and VFP Feature Register 0 */
+  __IM  uint32_t MVFR1;                  /*!< Offset: 0x244 (R/ )  Media and VFP Feature Register 1 */
+  __IM  uint32_t MVFR2;                  /*!< Offset: 0x248 (R/ )  Media and VFP Feature Register 2 */
+        uint32_t RESERVED5[1U];
+  __OM  uint32_t ICIALLU;                /*!< Offset: 0x250 ( /W)  I-Cache Invalidate All to PoU */
+        uint32_t RESERVED6[1U];
+  __OM  uint32_t ICIMVAU;                /*!< Offset: 0x258 ( /W)  I-Cache Invalidate by MVA to PoU */
+  __OM  uint32_t DCIMVAC;                /*!< Offset: 0x25C ( /W)  D-Cache Invalidate by MVA to PoC */
+  __OM  uint32_t DCISW;                  /*!< Offset: 0x260 ( /W)  D-Cache Invalidate by Set-way */
+  __OM  uint32_t DCCMVAU;                /*!< Offset: 0x264 ( /W)  D-Cache Clean by MVA to PoU */
+  __OM  uint32_t DCCMVAC;                /*!< Offset: 0x268 ( /W)  D-Cache Clean by MVA to PoC */
+  __OM  uint32_t DCCSW;                  /*!< Offset: 0x26C ( /W)  D-Cache Clean by Set-way */
+  __OM  uint32_t DCCIMVAC;               /*!< Offset: 0x270 ( /W)  D-Cache Clean and Invalidate by MVA to PoC */
+  __OM  uint32_t DCCISW;                 /*!< Offset: 0x274 ( /W)  D-Cache Clean and Invalidate by Set-way */
+        uint32_t RESERVED7[6U];
+  __IOM uint32_t ITCMCR;                 /*!< Offset: 0x290 (R/W)  Instruction Tightly-Coupled Memory Control Register */
+  __IOM uint32_t DTCMCR;                 /*!< Offset: 0x294 (R/W)  Data Tightly-Coupled Memory Control Registers */
+  __IOM uint32_t AHBPCR;                 /*!< Offset: 0x298 (R/W)  AHBP Control Register */
+  __IOM uint32_t CACR;                   /*!< Offset: 0x29C (R/W)  L1 Cache Control Register */
+  __IOM uint32_t AHBSCR;                 /*!< Offset: 0x2A0 (R/W)  AHB Slave Control Register */
+        uint32_t RESERVED8[1U];
+  __IOM uint32_t ABFSR;                  /*!< Offset: 0x2A8 (R/W)  Auxiliary Bus Fault Status Register */
+} SCB_Type;
+
+/* SCB CPUID Register Definitions */
+#define SCB_CPUID_IMPLEMENTER_Pos          24U                                            /*!< SCB CPUID: IMPLEMENTER Position */
+#define SCB_CPUID_IMPLEMENTER_Msk          (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos)          /*!< SCB CPUID: IMPLEMENTER Mask */
+
+#define SCB_CPUID_VARIANT_Pos              20U                                            /*!< SCB CPUID: VARIANT Position */
+#define SCB_CPUID_VARIANT_Msk              (0xFUL << SCB_CPUID_VARIANT_Pos)               /*!< SCB CPUID: VARIANT Mask */
+
+#define SCB_CPUID_ARCHITECTURE_Pos         16U                                            /*!< SCB CPUID: ARCHITECTURE Position */
+#define SCB_CPUID_ARCHITECTURE_Msk         (0xFUL << SCB_CPUID_ARCHITECTURE_Pos)          /*!< SCB CPUID: ARCHITECTURE Mask */
+
+#define SCB_CPUID_PARTNO_Pos                4U                                            /*!< SCB CPUID: PARTNO Position */
+#define SCB_CPUID_PARTNO_Msk               (0xFFFUL << SCB_CPUID_PARTNO_Pos)              /*!< SCB CPUID: PARTNO Mask */
+
+#define SCB_CPUID_REVISION_Pos              0U                                            /*!< SCB CPUID: REVISION Position */
+#define SCB_CPUID_REVISION_Msk             (0xFUL /*<< SCB_CPUID_REVISION_Pos*/)          /*!< SCB CPUID: REVISION Mask */
+
+/* SCB Interrupt Control State Register Definitions */
+#define SCB_ICSR_PENDNMISET_Pos            31U                                            /*!< SCB ICSR: PENDNMISET Position */
+#define SCB_ICSR_PENDNMISET_Msk            (1UL << SCB_ICSR_PENDNMISET_Pos)               /*!< SCB ICSR: PENDNMISET Mask */
+
+#define SCB_ICSR_NMIPENDSET_Pos            SCB_ICSR_PENDNMISET_Pos                        /*!< SCB ICSR: NMIPENDSET Position, backward compatibility */
+#define SCB_ICSR_NMIPENDSET_Msk            SCB_ICSR_PENDNMISET_Msk                        /*!< SCB ICSR: NMIPENDSET Mask, backward compatibility */
+
+#define SCB_ICSR_PENDNMICLR_Pos            30U                                            /*!< SCB ICSR: PENDNMICLR Position */
+#define SCB_ICSR_PENDNMICLR_Msk            (1UL << SCB_ICSR_PENDNMICLR_Pos)               /*!< SCB ICSR: PENDNMICLR Mask */
+
+#define SCB_ICSR_PENDSVSET_Pos             28U                                            /*!< SCB ICSR: PENDSVSET Position */
+#define SCB_ICSR_PENDSVSET_Msk             (1UL << SCB_ICSR_PENDSVSET_Pos)                /*!< SCB ICSR: PENDSVSET Mask */
+
+#define SCB_ICSR_PENDSVCLR_Pos             27U                                            /*!< SCB ICSR: PENDSVCLR Position */
+#define SCB_ICSR_PENDSVCLR_Msk             (1UL << SCB_ICSR_PENDSVCLR_Pos)                /*!< SCB ICSR: PENDSVCLR Mask */
+
+#define SCB_ICSR_PENDSTSET_Pos             26U                                            /*!< SCB ICSR: PENDSTSET Position */
+#define SCB_ICSR_PENDSTSET_Msk             (1UL << SCB_ICSR_PENDSTSET_Pos)                /*!< SCB ICSR: PENDSTSET Mask */
+
+#define SCB_ICSR_PENDSTCLR_Pos             25U                                            /*!< SCB ICSR: PENDSTCLR Position */
+#define SCB_ICSR_PENDSTCLR_Msk             (1UL << SCB_ICSR_PENDSTCLR_Pos)                /*!< SCB ICSR: PENDSTCLR Mask */
+
+#define SCB_ICSR_STTNS_Pos                 24U                                            /*!< SCB ICSR: STTNS Position (Security Extension) */
+#define SCB_ICSR_STTNS_Msk                 (1UL << SCB_ICSR_STTNS_Pos)                    /*!< SCB ICSR: STTNS Mask (Security Extension) */
+
+#define SCB_ICSR_ISRPREEMPT_Pos            23U                                            /*!< SCB ICSR: ISRPREEMPT Position */
+#define SCB_ICSR_ISRPREEMPT_Msk            (1UL << SCB_ICSR_ISRPREEMPT_Pos)               /*!< SCB ICSR: ISRPREEMPT Mask */
+
+#define SCB_ICSR_ISRPENDING_Pos            22U                                            /*!< SCB ICSR: ISRPENDING Position */
+#define SCB_ICSR_ISRPENDING_Msk            (1UL << SCB_ICSR_ISRPENDING_Pos)               /*!< SCB ICSR: ISRPENDING Mask */
+
+#define SCB_ICSR_VECTPENDING_Pos           12U                                            /*!< SCB ICSR: VECTPENDING Position */
+#define SCB_ICSR_VECTPENDING_Msk           (0x1FFUL << SCB_ICSR_VECTPENDING_Pos)          /*!< SCB ICSR: VECTPENDING Mask */
+
+#define SCB_ICSR_RETTOBASE_Pos             11U                                            /*!< SCB ICSR: RETTOBASE Position */
+#define SCB_ICSR_RETTOBASE_Msk             (1UL << SCB_ICSR_RETTOBASE_Pos)                /*!< SCB ICSR: RETTOBASE Mask */
+
+#define SCB_ICSR_VECTACTIVE_Pos             0U                                            /*!< SCB ICSR: VECTACTIVE Position */
+#define SCB_ICSR_VECTACTIVE_Msk            (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/)       /*!< SCB ICSR: VECTACTIVE Mask */
+
+/* SCB Vector Table Offset Register Definitions */
+#define SCB_VTOR_TBLOFF_Pos                 7U                                            /*!< SCB VTOR: TBLOFF Position */
+#define SCB_VTOR_TBLOFF_Msk                (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos)           /*!< SCB VTOR: TBLOFF Mask */
+
+/* SCB Application Interrupt and Reset Control Register Definitions */
+#define SCB_AIRCR_VECTKEY_Pos              16U                                            /*!< SCB AIRCR: VECTKEY Position */
+#define SCB_AIRCR_VECTKEY_Msk              (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos)            /*!< SCB AIRCR: VECTKEY Mask */
+
+#define SCB_AIRCR_VECTKEYSTAT_Pos          16U                                            /*!< SCB AIRCR: VECTKEYSTAT Position */
+#define SCB_AIRCR_VECTKEYSTAT_Msk          (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos)        /*!< SCB AIRCR: VECTKEYSTAT Mask */
+
+#define SCB_AIRCR_ENDIANESS_Pos            15U                                            /*!< SCB AIRCR: ENDIANESS Position */
+#define SCB_AIRCR_ENDIANESS_Msk            (1UL << SCB_AIRCR_ENDIANESS_Pos)               /*!< SCB AIRCR: ENDIANESS Mask */
+
+#define SCB_AIRCR_PRIS_Pos                 14U                                            /*!< SCB AIRCR: PRIS Position */
+#define SCB_AIRCR_PRIS_Msk                 (1UL << SCB_AIRCR_PRIS_Pos)                    /*!< SCB AIRCR: PRIS Mask */
+
+#define SCB_AIRCR_BFHFNMINS_Pos            13U                                            /*!< SCB AIRCR: BFHFNMINS Position */
+#define SCB_AIRCR_BFHFNMINS_Msk            (1UL << SCB_AIRCR_BFHFNMINS_Pos)               /*!< SCB AIRCR: BFHFNMINS Mask */
+
+#define SCB_AIRCR_PRIGROUP_Pos              8U                                            /*!< SCB AIRCR: PRIGROUP Position */
+#define SCB_AIRCR_PRIGROUP_Msk             (7UL << SCB_AIRCR_PRIGROUP_Pos)                /*!< SCB AIRCR: PRIGROUP Mask */
+
+#define SCB_AIRCR_SYSRESETREQS_Pos          3U                                            /*!< SCB AIRCR: SYSRESETREQS Position */
+#define SCB_AIRCR_SYSRESETREQS_Msk         (1UL << SCB_AIRCR_SYSRESETREQS_Pos)            /*!< SCB AIRCR: SYSRESETREQS Mask */
+
+#define SCB_AIRCR_SYSRESETREQ_Pos           2U                                            /*!< SCB AIRCR: SYSRESETREQ Position */
+#define SCB_AIRCR_SYSRESETREQ_Msk          (1UL << SCB_AIRCR_SYSRESETREQ_Pos)             /*!< SCB AIRCR: SYSRESETREQ Mask */
+
+#define SCB_AIRCR_VECTCLRACTIVE_Pos         1U                                            /*!< SCB AIRCR: VECTCLRACTIVE Position */
+#define SCB_AIRCR_VECTCLRACTIVE_Msk        (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos)           /*!< SCB AIRCR: VECTCLRACTIVE Mask */
+
+/* SCB System Control Register Definitions */
+#define SCB_SCR_SEVONPEND_Pos               4U                                            /*!< SCB SCR: SEVONPEND Position */
+#define SCB_SCR_SEVONPEND_Msk              (1UL << SCB_SCR_SEVONPEND_Pos)                 /*!< SCB SCR: SEVONPEND Mask */
+
+#define SCB_SCR_SLEEPDEEPS_Pos              3U                                            /*!< SCB SCR: SLEEPDEEPS Position */
+#define SCB_SCR_SLEEPDEEPS_Msk             (1UL << SCB_SCR_SLEEPDEEPS_Pos)                /*!< SCB SCR: SLEEPDEEPS Mask */
+
+#define SCB_SCR_SLEEPDEEP_Pos               2U                                            /*!< SCB SCR: SLEEPDEEP Position */
+#define SCB_SCR_SLEEPDEEP_Msk              (1UL << SCB_SCR_SLEEPDEEP_Pos)                 /*!< SCB SCR: SLEEPDEEP Mask */
+
+#define SCB_SCR_SLEEPONEXIT_Pos             1U                                            /*!< SCB SCR: SLEEPONEXIT Position */
+#define SCB_SCR_SLEEPONEXIT_Msk            (1UL << SCB_SCR_SLEEPONEXIT_Pos)               /*!< SCB SCR: SLEEPONEXIT Mask */
+
+/* SCB Configuration Control Register Definitions */
+#define SCB_CCR_BP_Pos                     18U                                            /*!< SCB CCR: BP Position */
+#define SCB_CCR_BP_Msk                     (1UL << SCB_CCR_BP_Pos)                        /*!< SCB CCR: BP Mask */
+
+#define SCB_CCR_IC_Pos                     17U                                            /*!< SCB CCR: IC Position */
+#define SCB_CCR_IC_Msk                     (1UL << SCB_CCR_IC_Pos)                        /*!< SCB CCR: IC Mask */
+
+#define SCB_CCR_DC_Pos                     16U                                            /*!< SCB CCR: DC Position */
+#define SCB_CCR_DC_Msk                     (1UL << SCB_CCR_DC_Pos)                        /*!< SCB CCR: DC Mask */
+
+#define SCB_CCR_STKOFHFNMIGN_Pos           10U                                            /*!< SCB CCR: STKOFHFNMIGN Position */
+#define SCB_CCR_STKOFHFNMIGN_Msk           (1UL << SCB_CCR_STKOFHFNMIGN_Pos)              /*!< SCB CCR: STKOFHFNMIGN Mask */
+
+#define SCB_CCR_BFHFNMIGN_Pos               8U                                            /*!< SCB CCR: BFHFNMIGN Position */
+#define SCB_CCR_BFHFNMIGN_Msk              (1UL << SCB_CCR_BFHFNMIGN_Pos)                 /*!< SCB CCR: BFHFNMIGN Mask */
+
+#define SCB_CCR_DIV_0_TRP_Pos               4U                                            /*!< SCB CCR: DIV_0_TRP Position */
+#define SCB_CCR_DIV_0_TRP_Msk              (1UL << SCB_CCR_DIV_0_TRP_Pos)                 /*!< SCB CCR: DIV_0_TRP Mask */
+
+#define SCB_CCR_UNALIGN_TRP_Pos             3U                                            /*!< SCB CCR: UNALIGN_TRP Position */
+#define SCB_CCR_UNALIGN_TRP_Msk            (1UL << SCB_CCR_UNALIGN_TRP_Pos)               /*!< SCB CCR: UNALIGN_TRP Mask */
+
+#define SCB_CCR_USERSETMPEND_Pos            1U                                            /*!< SCB CCR: USERSETMPEND Position */
+#define SCB_CCR_USERSETMPEND_Msk           (1UL << SCB_CCR_USERSETMPEND_Pos)              /*!< SCB CCR: USERSETMPEND Mask */
+
+/* SCB System Handler Control and State Register Definitions */
+#define SCB_SHCSR_HARDFAULTPENDED_Pos      21U                                            /*!< SCB SHCSR: HARDFAULTPENDED Position */
+#define SCB_SHCSR_HARDFAULTPENDED_Msk      (1UL << SCB_SHCSR_HARDFAULTPENDED_Pos)         /*!< SCB SHCSR: HARDFAULTPENDED Mask */
+
+#define SCB_SHCSR_SECUREFAULTPENDED_Pos    20U                                            /*!< SCB SHCSR: SECUREFAULTPENDED Position */
+#define SCB_SHCSR_SECUREFAULTPENDED_Msk    (1UL << SCB_SHCSR_SECUREFAULTPENDED_Pos)       /*!< SCB SHCSR: SECUREFAULTPENDED Mask */
+
+#define SCB_SHCSR_SECUREFAULTENA_Pos       19U                                            /*!< SCB SHCSR: SECUREFAULTENA Position */
+#define SCB_SHCSR_SECUREFAULTENA_Msk       (1UL << SCB_SHCSR_SECUREFAULTENA_Pos)          /*!< SCB SHCSR: SECUREFAULTENA Mask */
+
+#define SCB_SHCSR_USGFAULTENA_Pos          18U                                            /*!< SCB SHCSR: USGFAULTENA Position */
+#define SCB_SHCSR_USGFAULTENA_Msk          (1UL << SCB_SHCSR_USGFAULTENA_Pos)             /*!< SCB SHCSR: USGFAULTENA Mask */
+
+#define SCB_SHCSR_BUSFAULTENA_Pos          17U                                            /*!< SCB SHCSR: BUSFAULTENA Position */
+#define SCB_SHCSR_BUSFAULTENA_Msk          (1UL << SCB_SHCSR_BUSFAULTENA_Pos)             /*!< SCB SHCSR: BUSFAULTENA Mask */
+
+#define SCB_SHCSR_MEMFAULTENA_Pos          16U                                            /*!< SCB SHCSR: MEMFAULTENA Position */
+#define SCB_SHCSR_MEMFAULTENA_Msk          (1UL << SCB_SHCSR_MEMFAULTENA_Pos)             /*!< SCB SHCSR: MEMFAULTENA Mask */
+
+#define SCB_SHCSR_SVCALLPENDED_Pos         15U                                            /*!< SCB SHCSR: SVCALLPENDED Position */
+#define SCB_SHCSR_SVCALLPENDED_Msk         (1UL << SCB_SHCSR_SVCALLPENDED_Pos)            /*!< SCB SHCSR: SVCALLPENDED Mask */
+
+#define SCB_SHCSR_BUSFAULTPENDED_Pos       14U                                            /*!< SCB SHCSR: BUSFAULTPENDED Position */
+#define SCB_SHCSR_BUSFAULTPENDED_Msk       (1UL << SCB_SHCSR_BUSFAULTPENDED_Pos)          /*!< SCB SHCSR: BUSFAULTPENDED Mask */
+
+#define SCB_SHCSR_MEMFAULTPENDED_Pos       13U                                            /*!< SCB SHCSR: MEMFAULTPENDED Position */
+#define SCB_SHCSR_MEMFAULTPENDED_Msk       (1UL << SCB_SHCSR_MEMFAULTPENDED_Pos)          /*!< SCB SHCSR: MEMFAULTPENDED Mask */
+
+#define SCB_SHCSR_USGFAULTPENDED_Pos       12U                                            /*!< SCB SHCSR: USGFAULTPENDED Position */
+#define SCB_SHCSR_USGFAULTPENDED_Msk       (1UL << SCB_SHCSR_USGFAULTPENDED_Pos)          /*!< SCB SHCSR: USGFAULTPENDED Mask */
+
+#define SCB_SHCSR_SYSTICKACT_Pos           11U                                            /*!< SCB SHCSR: SYSTICKACT Position */
+#define SCB_SHCSR_SYSTICKACT_Msk           (1UL << SCB_SHCSR_SYSTICKACT_Pos)              /*!< SCB SHCSR: SYSTICKACT Mask */
+
+#define SCB_SHCSR_PENDSVACT_Pos            10U                                            /*!< SCB SHCSR: PENDSVACT Position */
+#define SCB_SHCSR_PENDSVACT_Msk            (1UL << SCB_SHCSR_PENDSVACT_Pos)               /*!< SCB SHCSR: PENDSVACT Mask */
+
+#define SCB_SHCSR_MONITORACT_Pos            8U                                            /*!< SCB SHCSR: MONITORACT Position */
+#define SCB_SHCSR_MONITORACT_Msk           (1UL << SCB_SHCSR_MONITORACT_Pos)              /*!< SCB SHCSR: MONITORACT Mask */
+
+#define SCB_SHCSR_SVCALLACT_Pos             7U                                            /*!< SCB SHCSR: SVCALLACT Position */
+#define SCB_SHCSR_SVCALLACT_Msk            (1UL << SCB_SHCSR_SVCALLACT_Pos)               /*!< SCB SHCSR: SVCALLACT Mask */
+
+#define SCB_SHCSR_NMIACT_Pos                5U                                            /*!< SCB SHCSR: NMIACT Position */
+#define SCB_SHCSR_NMIACT_Msk               (1UL << SCB_SHCSR_NMIACT_Pos)                  /*!< SCB SHCSR: NMIACT Mask */
+
+#define SCB_SHCSR_SECUREFAULTACT_Pos        4U                                            /*!< SCB SHCSR: SECUREFAULTACT Position */
+#define SCB_SHCSR_SECUREFAULTACT_Msk       (1UL << SCB_SHCSR_SECUREFAULTACT_Pos)          /*!< SCB SHCSR: SECUREFAULTACT Mask */
+
+#define SCB_SHCSR_USGFAULTACT_Pos           3U                                            /*!< SCB SHCSR: USGFAULTACT Position */
+#define SCB_SHCSR_USGFAULTACT_Msk          (1UL << SCB_SHCSR_USGFAULTACT_Pos)             /*!< SCB SHCSR: USGFAULTACT Mask */
+
+#define SCB_SHCSR_HARDFAULTACT_Pos          2U                                            /*!< SCB SHCSR: HARDFAULTACT Position */
+#define SCB_SHCSR_HARDFAULTACT_Msk         (1UL << SCB_SHCSR_HARDFAULTACT_Pos)            /*!< SCB SHCSR: HARDFAULTACT Mask */
+
+#define SCB_SHCSR_BUSFAULTACT_Pos           1U                                            /*!< SCB SHCSR: BUSFAULTACT Position */
+#define SCB_SHCSR_BUSFAULTACT_Msk          (1UL << SCB_SHCSR_BUSFAULTACT_Pos)             /*!< SCB SHCSR: BUSFAULTACT Mask */
+
+#define SCB_SHCSR_MEMFAULTACT_Pos           0U                                            /*!< SCB SHCSR: MEMFAULTACT Position */
+#define SCB_SHCSR_MEMFAULTACT_Msk          (1UL /*<< SCB_SHCSR_MEMFAULTACT_Pos*/)         /*!< SCB SHCSR: MEMFAULTACT Mask */
+
+/* SCB Configurable Fault Status Register Definitions */
+#define SCB_CFSR_USGFAULTSR_Pos            16U                                            /*!< SCB CFSR: Usage Fault Status Register Position */
+#define SCB_CFSR_USGFAULTSR_Msk            (0xFFFFUL << SCB_CFSR_USGFAULTSR_Pos)          /*!< SCB CFSR: Usage Fault Status Register Mask */
+
+#define SCB_CFSR_BUSFAULTSR_Pos             8U                                            /*!< SCB CFSR: Bus Fault Status Register Position */
+#define SCB_CFSR_BUSFAULTSR_Msk            (0xFFUL << SCB_CFSR_BUSFAULTSR_Pos)            /*!< SCB CFSR: Bus Fault Status Register Mask */
+
+#define SCB_CFSR_MEMFAULTSR_Pos             0U                                            /*!< SCB CFSR: Memory Manage Fault Status Register Position */
+#define SCB_CFSR_MEMFAULTSR_Msk            (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/)        /*!< SCB CFSR: Memory Manage Fault Status Register Mask */
+
+/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_MMARVALID_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 7U)               /*!< SCB CFSR (MMFSR): MMARVALID Position */
+#define SCB_CFSR_MMARVALID_Msk             (1UL << SCB_CFSR_MMARVALID_Pos)                /*!< SCB CFSR (MMFSR): MMARVALID Mask */
+
+#define SCB_CFSR_MLSPERR_Pos               (SCB_SHCSR_MEMFAULTACT_Pos + 5U)               /*!< SCB CFSR (MMFSR): MLSPERR Position */
+#define SCB_CFSR_MLSPERR_Msk               (1UL << SCB_CFSR_MLSPERR_Pos)                  /*!< SCB CFSR (MMFSR): MLSPERR Mask */
+
+#define SCB_CFSR_MSTKERR_Pos               (SCB_SHCSR_MEMFAULTACT_Pos + 4U)               /*!< SCB CFSR (MMFSR): MSTKERR Position */
+#define SCB_CFSR_MSTKERR_Msk               (1UL << SCB_CFSR_MSTKERR_Pos)                  /*!< SCB CFSR (MMFSR): MSTKERR Mask */
+
+#define SCB_CFSR_MUNSTKERR_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 3U)               /*!< SCB CFSR (MMFSR): MUNSTKERR Position */
+#define SCB_CFSR_MUNSTKERR_Msk             (1UL << SCB_CFSR_MUNSTKERR_Pos)                /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */
+
+#define SCB_CFSR_DACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 1U)               /*!< SCB CFSR (MMFSR): DACCVIOL Position */
+#define SCB_CFSR_DACCVIOL_Msk              (1UL << SCB_CFSR_DACCVIOL_Pos)                 /*!< SCB CFSR (MMFSR): DACCVIOL Mask */
+
+#define SCB_CFSR_IACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 0U)               /*!< SCB CFSR (MMFSR): IACCVIOL Position */
+#define SCB_CFSR_IACCVIOL_Msk              (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/)             /*!< SCB CFSR (MMFSR): IACCVIOL Mask */
+
+/* BusFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_BFARVALID_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 7U)                  /*!< SCB CFSR (BFSR): BFARVALID Position */
+#define SCB_CFSR_BFARVALID_Msk            (1UL << SCB_CFSR_BFARVALID_Pos)                 /*!< SCB CFSR (BFSR): BFARVALID Mask */
+
+#define SCB_CFSR_LSPERR_Pos               (SCB_CFSR_BUSFAULTSR_Pos + 5U)                  /*!< SCB CFSR (BFSR): LSPERR Position */
+#define SCB_CFSR_LSPERR_Msk               (1UL << SCB_CFSR_LSPERR_Pos)                    /*!< SCB CFSR (BFSR): LSPERR Mask */
+
+#define SCB_CFSR_STKERR_Pos               (SCB_CFSR_BUSFAULTSR_Pos + 4U)                  /*!< SCB CFSR (BFSR): STKERR Position */
+#define SCB_CFSR_STKERR_Msk               (1UL << SCB_CFSR_STKERR_Pos)                    /*!< SCB CFSR (BFSR): STKERR Mask */
+
+#define SCB_CFSR_UNSTKERR_Pos             (SCB_CFSR_BUSFAULTSR_Pos + 3U)                  /*!< SCB CFSR (BFSR): UNSTKERR Position */
+#define SCB_CFSR_UNSTKERR_Msk             (1UL << SCB_CFSR_UNSTKERR_Pos)                  /*!< SCB CFSR (BFSR): UNSTKERR Mask */
+
+#define SCB_CFSR_IMPRECISERR_Pos          (SCB_CFSR_BUSFAULTSR_Pos + 2U)                  /*!< SCB CFSR (BFSR): IMPRECISERR Position */
+#define SCB_CFSR_IMPRECISERR_Msk          (1UL << SCB_CFSR_IMPRECISERR_Pos)               /*!< SCB CFSR (BFSR): IMPRECISERR Mask */
+
+#define SCB_CFSR_PRECISERR_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 1U)                  /*!< SCB CFSR (BFSR): PRECISERR Position */
+#define SCB_CFSR_PRECISERR_Msk            (1UL << SCB_CFSR_PRECISERR_Pos)                 /*!< SCB CFSR (BFSR): PRECISERR Mask */
+
+#define SCB_CFSR_IBUSERR_Pos              (SCB_CFSR_BUSFAULTSR_Pos + 0U)                  /*!< SCB CFSR (BFSR): IBUSERR Position */
+#define SCB_CFSR_IBUSERR_Msk              (1UL << SCB_CFSR_IBUSERR_Pos)                   /*!< SCB CFSR (BFSR): IBUSERR Mask */
+
+/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_DIVBYZERO_Pos            (SCB_CFSR_USGFAULTSR_Pos + 9U)                  /*!< SCB CFSR (UFSR): DIVBYZERO Position */
+#define SCB_CFSR_DIVBYZERO_Msk            (1UL << SCB_CFSR_DIVBYZERO_Pos)                 /*!< SCB CFSR (UFSR): DIVBYZERO Mask */
+
+#define SCB_CFSR_UNALIGNED_Pos            (SCB_CFSR_USGFAULTSR_Pos + 8U)                  /*!< SCB CFSR (UFSR): UNALIGNED Position */
+#define SCB_CFSR_UNALIGNED_Msk            (1UL << SCB_CFSR_UNALIGNED_Pos)                 /*!< SCB CFSR (UFSR): UNALIGNED Mask */
+
+#define SCB_CFSR_STKOF_Pos                (SCB_CFSR_USGFAULTSR_Pos + 4U)                  /*!< SCB CFSR (UFSR): STKOF Position */
+#define SCB_CFSR_STKOF_Msk                (1UL << SCB_CFSR_STKOF_Pos)                     /*!< SCB CFSR (UFSR): STKOF Mask */
+
+#define SCB_CFSR_NOCP_Pos                 (SCB_CFSR_USGFAULTSR_Pos + 3U)                  /*!< SCB CFSR (UFSR): NOCP Position */
+#define SCB_CFSR_NOCP_Msk                 (1UL << SCB_CFSR_NOCP_Pos)                      /*!< SCB CFSR (UFSR): NOCP Mask */
+
+#define SCB_CFSR_INVPC_Pos                (SCB_CFSR_USGFAULTSR_Pos + 2U)                  /*!< SCB CFSR (UFSR): INVPC Position */
+#define SCB_CFSR_INVPC_Msk                (1UL << SCB_CFSR_INVPC_Pos)                     /*!< SCB CFSR (UFSR): INVPC Mask */
+
+#define SCB_CFSR_INVSTATE_Pos             (SCB_CFSR_USGFAULTSR_Pos + 1U)                  /*!< SCB CFSR (UFSR): INVSTATE Position */
+#define SCB_CFSR_INVSTATE_Msk             (1UL << SCB_CFSR_INVSTATE_Pos)                  /*!< SCB CFSR (UFSR): INVSTATE Mask */
+
+#define SCB_CFSR_UNDEFINSTR_Pos           (SCB_CFSR_USGFAULTSR_Pos + 0U)                  /*!< SCB CFSR (UFSR): UNDEFINSTR Position */
+#define SCB_CFSR_UNDEFINSTR_Msk           (1UL << SCB_CFSR_UNDEFINSTR_Pos)                /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */
+
+/* SCB Hard Fault Status Register Definitions */
+#define SCB_HFSR_DEBUGEVT_Pos              31U                                            /*!< SCB HFSR: DEBUGEVT Position */
+#define SCB_HFSR_DEBUGEVT_Msk              (1UL << SCB_HFSR_DEBUGEVT_Pos)                 /*!< SCB HFSR: DEBUGEVT Mask */
+
+#define SCB_HFSR_FORCED_Pos                30U                                            /*!< SCB HFSR: FORCED Position */
+#define SCB_HFSR_FORCED_Msk                (1UL << SCB_HFSR_FORCED_Pos)                   /*!< SCB HFSR: FORCED Mask */
+
+#define SCB_HFSR_VECTTBL_Pos                1U                                            /*!< SCB HFSR: VECTTBL Position */
+#define SCB_HFSR_VECTTBL_Msk               (1UL << SCB_HFSR_VECTTBL_Pos)                  /*!< SCB HFSR: VECTTBL Mask */
+
+/* SCB Debug Fault Status Register Definitions */
+#define SCB_DFSR_EXTERNAL_Pos               4U                                            /*!< SCB DFSR: EXTERNAL Position */
+#define SCB_DFSR_EXTERNAL_Msk              (1UL << SCB_DFSR_EXTERNAL_Pos)                 /*!< SCB DFSR: EXTERNAL Mask */
+
+#define SCB_DFSR_VCATCH_Pos                 3U                                            /*!< SCB DFSR: VCATCH Position */
+#define SCB_DFSR_VCATCH_Msk                (1UL << SCB_DFSR_VCATCH_Pos)                   /*!< SCB DFSR: VCATCH Mask */
+
+#define SCB_DFSR_DWTTRAP_Pos                2U                                            /*!< SCB DFSR: DWTTRAP Position */
+#define SCB_DFSR_DWTTRAP_Msk               (1UL << SCB_DFSR_DWTTRAP_Pos)                  /*!< SCB DFSR: DWTTRAP Mask */
+
+#define SCB_DFSR_BKPT_Pos                   1U                                            /*!< SCB DFSR: BKPT Position */
+#define SCB_DFSR_BKPT_Msk                  (1UL << SCB_DFSR_BKPT_Pos)                     /*!< SCB DFSR: BKPT Mask */
+
+#define SCB_DFSR_HALTED_Pos                 0U                                            /*!< SCB DFSR: HALTED Position */
+#define SCB_DFSR_HALTED_Msk                (1UL /*<< SCB_DFSR_HALTED_Pos*/)               /*!< SCB DFSR: HALTED Mask */
+
+/* SCB Non-Secure Access Control Register Definitions */
+#define SCB_NSACR_CP11_Pos                 11U                                            /*!< SCB NSACR: CP11 Position */
+#define SCB_NSACR_CP11_Msk                 (1UL << SCB_NSACR_CP11_Pos)                    /*!< SCB NSACR: CP11 Mask */
+
+#define SCB_NSACR_CP10_Pos                 10U                                            /*!< SCB NSACR: CP10 Position */
+#define SCB_NSACR_CP10_Msk                 (1UL << SCB_NSACR_CP10_Pos)                    /*!< SCB NSACR: CP10 Mask */
+
+#define SCB_NSACR_CPn_Pos                   0U                                            /*!< SCB NSACR: CPn Position */
+#define SCB_NSACR_CPn_Msk                  (1UL /*<< SCB_NSACR_CPn_Pos*/)                 /*!< SCB NSACR: CPn Mask */
+
+/* SCB Cache Level ID Register Definitions */
+#define SCB_CLIDR_LOUU_Pos                 27U                                            /*!< SCB CLIDR: LoUU Position */
+#define SCB_CLIDR_LOUU_Msk                 (7UL << SCB_CLIDR_LOUU_Pos)                    /*!< SCB CLIDR: LoUU Mask */
+
+#define SCB_CLIDR_LOC_Pos                  24U                                            /*!< SCB CLIDR: LoC Position */
+#define SCB_CLIDR_LOC_Msk                  (7UL << SCB_CLIDR_LOC_Pos)                     /*!< SCB CLIDR: LoC Mask */
+
+/* SCB Cache Type Register Definitions */
+#define SCB_CTR_FORMAT_Pos                 29U                                            /*!< SCB CTR: Format Position */
+#define SCB_CTR_FORMAT_Msk                 (7UL << SCB_CTR_FORMAT_Pos)                    /*!< SCB CTR: Format Mask */
+
+#define SCB_CTR_CWG_Pos                    24U                                            /*!< SCB CTR: CWG Position */
+#define SCB_CTR_CWG_Msk                    (0xFUL << SCB_CTR_CWG_Pos)                     /*!< SCB CTR: CWG Mask */
+
+#define SCB_CTR_ERG_Pos                    20U                                            /*!< SCB CTR: ERG Position */
+#define SCB_CTR_ERG_Msk                    (0xFUL << SCB_CTR_ERG_Pos)                     /*!< SCB CTR: ERG Mask */
+
+#define SCB_CTR_DMINLINE_Pos               16U                                            /*!< SCB CTR: DminLine Position */
+#define SCB_CTR_DMINLINE_Msk               (0xFUL << SCB_CTR_DMINLINE_Pos)                /*!< SCB CTR: DminLine Mask */
+
+#define SCB_CTR_IMINLINE_Pos                0U                                            /*!< SCB CTR: ImInLine Position */
+#define SCB_CTR_IMINLINE_Msk               (0xFUL /*<< SCB_CTR_IMINLINE_Pos*/)            /*!< SCB CTR: ImInLine Mask */
+
+/* SCB Cache Size ID Register Definitions */
+#define SCB_CCSIDR_WT_Pos                  31U                                            /*!< SCB CCSIDR: WT Position */
+#define SCB_CCSIDR_WT_Msk                  (1UL << SCB_CCSIDR_WT_Pos)                     /*!< SCB CCSIDR: WT Mask */
+
+#define SCB_CCSIDR_WB_Pos                  30U                                            /*!< SCB CCSIDR: WB Position */
+#define SCB_CCSIDR_WB_Msk                  (1UL << SCB_CCSIDR_WB_Pos)                     /*!< SCB CCSIDR: WB Mask */
+
+#define SCB_CCSIDR_RA_Pos                  29U                                            /*!< SCB CCSIDR: RA Position */
+#define SCB_CCSIDR_RA_Msk                  (1UL << SCB_CCSIDR_RA_Pos)                     /*!< SCB CCSIDR: RA Mask */
+
+#define SCB_CCSIDR_WA_Pos                  28U                                            /*!< SCB CCSIDR: WA Position */
+#define SCB_CCSIDR_WA_Msk                  (1UL << SCB_CCSIDR_WA_Pos)                     /*!< SCB CCSIDR: WA Mask */
+
+#define SCB_CCSIDR_NUMSETS_Pos             13U                                            /*!< SCB CCSIDR: NumSets Position */
+#define SCB_CCSIDR_NUMSETS_Msk             (0x7FFFUL << SCB_CCSIDR_NUMSETS_Pos)           /*!< SCB CCSIDR: NumSets Mask */
+
+#define SCB_CCSIDR_ASSOCIATIVITY_Pos        3U                                            /*!< SCB CCSIDR: Associativity Position */
+#define SCB_CCSIDR_ASSOCIATIVITY_Msk       (0x3FFUL << SCB_CCSIDR_ASSOCIATIVITY_Pos)      /*!< SCB CCSIDR: Associativity Mask */
+
+#define SCB_CCSIDR_LINESIZE_Pos             0U                                            /*!< SCB CCSIDR: LineSize Position */
+#define SCB_CCSIDR_LINESIZE_Msk            (7UL /*<< SCB_CCSIDR_LINESIZE_Pos*/)           /*!< SCB CCSIDR: LineSize Mask */
+
+/* SCB Cache Size Selection Register Definitions */
+#define SCB_CSSELR_LEVEL_Pos                1U                                            /*!< SCB CSSELR: Level Position */
+#define SCB_CSSELR_LEVEL_Msk               (7UL << SCB_CSSELR_LEVEL_Pos)                  /*!< SCB CSSELR: Level Mask */
+
+#define SCB_CSSELR_IND_Pos                  0U                                            /*!< SCB CSSELR: InD Position */
+#define SCB_CSSELR_IND_Msk                 (1UL /*<< SCB_CSSELR_IND_Pos*/)                /*!< SCB CSSELR: InD Mask */
+
+/* SCB Software Triggered Interrupt Register Definitions */
+#define SCB_STIR_INTID_Pos                  0U                                            /*!< SCB STIR: INTID Position */
+#define SCB_STIR_INTID_Msk                 (0x1FFUL /*<< SCB_STIR_INTID_Pos*/)            /*!< SCB STIR: INTID Mask */
+
+/* SCB D-Cache Invalidate by Set-way Register Definitions */
+#define SCB_DCISW_WAY_Pos                  30U                                            /*!< SCB DCISW: Way Position */
+#define SCB_DCISW_WAY_Msk                  (3UL << SCB_DCISW_WAY_Pos)                     /*!< SCB DCISW: Way Mask */
+
+#define SCB_DCISW_SET_Pos                   5U                                            /*!< SCB DCISW: Set Position */
+#define SCB_DCISW_SET_Msk                  (0x1FFUL << SCB_DCISW_SET_Pos)                 /*!< SCB DCISW: Set Mask */
+
+/* SCB D-Cache Clean by Set-way Register Definitions */
+#define SCB_DCCSW_WAY_Pos                  30U                                            /*!< SCB DCCSW: Way Position */
+#define SCB_DCCSW_WAY_Msk                  (3UL << SCB_DCCSW_WAY_Pos)                     /*!< SCB DCCSW: Way Mask */
+
+#define SCB_DCCSW_SET_Pos                   5U                                            /*!< SCB DCCSW: Set Position */
+#define SCB_DCCSW_SET_Msk                  (0x1FFUL << SCB_DCCSW_SET_Pos)                 /*!< SCB DCCSW: Set Mask */
+
+/* SCB D-Cache Clean and Invalidate by Set-way Register Definitions */
+#define SCB_DCCISW_WAY_Pos                 30U                                            /*!< SCB DCCISW: Way Position */
+#define SCB_DCCISW_WAY_Msk                 (3UL << SCB_DCCISW_WAY_Pos)                    /*!< SCB DCCISW: Way Mask */
+
+#define SCB_DCCISW_SET_Pos                  5U                                            /*!< SCB DCCISW: Set Position */
+#define SCB_DCCISW_SET_Msk                 (0x1FFUL << SCB_DCCISW_SET_Pos)                /*!< SCB DCCISW: Set Mask */
+
+/* Instruction Tightly-Coupled Memory Control Register Definitions */
+#define SCB_ITCMCR_SZ_Pos                   3U                                            /*!< SCB ITCMCR: SZ Position */
+#define SCB_ITCMCR_SZ_Msk                  (0xFUL << SCB_ITCMCR_SZ_Pos)                   /*!< SCB ITCMCR: SZ Mask */
+
+#define SCB_ITCMCR_RETEN_Pos                2U                                            /*!< SCB ITCMCR: RETEN Position */
+#define SCB_ITCMCR_RETEN_Msk               (1UL << SCB_ITCMCR_RETEN_Pos)                  /*!< SCB ITCMCR: RETEN Mask */
+
+#define SCB_ITCMCR_RMW_Pos                  1U                                            /*!< SCB ITCMCR: RMW Position */
+#define SCB_ITCMCR_RMW_Msk                 (1UL << SCB_ITCMCR_RMW_Pos)                    /*!< SCB ITCMCR: RMW Mask */
+
+#define SCB_ITCMCR_EN_Pos                   0U                                            /*!< SCB ITCMCR: EN Position */
+#define SCB_ITCMCR_EN_Msk                  (1UL /*<< SCB_ITCMCR_EN_Pos*/)                 /*!< SCB ITCMCR: EN Mask */
+
+/* Data Tightly-Coupled Memory Control Register Definitions */
+#define SCB_DTCMCR_SZ_Pos                   3U                                            /*!< SCB DTCMCR: SZ Position */
+#define SCB_DTCMCR_SZ_Msk                  (0xFUL << SCB_DTCMCR_SZ_Pos)                   /*!< SCB DTCMCR: SZ Mask */
+
+#define SCB_DTCMCR_RETEN_Pos                2U                                            /*!< SCB DTCMCR: RETEN Position */
+#define SCB_DTCMCR_RETEN_Msk               (1UL << SCB_DTCMCR_RETEN_Pos)                   /*!< SCB DTCMCR: RETEN Mask */
+
+#define SCB_DTCMCR_RMW_Pos                  1U                                            /*!< SCB DTCMCR: RMW Position */
+#define SCB_DTCMCR_RMW_Msk                 (1UL << SCB_DTCMCR_RMW_Pos)                    /*!< SCB DTCMCR: RMW Mask */
+
+#define SCB_DTCMCR_EN_Pos                   0U                                            /*!< SCB DTCMCR: EN Position */
+#define SCB_DTCMCR_EN_Msk                  (1UL /*<< SCB_DTCMCR_EN_Pos*/)                 /*!< SCB DTCMCR: EN Mask */
+
+/* AHBP Control Register Definitions */
+#define SCB_AHBPCR_SZ_Pos                   1U                                            /*!< SCB AHBPCR: SZ Position */
+#define SCB_AHBPCR_SZ_Msk                  (7UL << SCB_AHBPCR_SZ_Pos)                     /*!< SCB AHBPCR: SZ Mask */
+
+#define SCB_AHBPCR_EN_Pos                   0U                                            /*!< SCB AHBPCR: EN Position */
+#define SCB_AHBPCR_EN_Msk                  (1UL /*<< SCB_AHBPCR_EN_Pos*/)                 /*!< SCB AHBPCR: EN Mask */
+
+/* L1 Cache Control Register Definitions */
+#define SCB_CACR_FORCEWT_Pos                2U                                            /*!< SCB CACR: FORCEWT Position */
+#define SCB_CACR_FORCEWT_Msk               (1UL << SCB_CACR_FORCEWT_Pos)                  /*!< SCB CACR: FORCEWT Mask */
+
+#define SCB_CACR_ECCEN_Pos                  1U                                            /*!< SCB CACR: ECCEN Position */
+#define SCB_CACR_ECCEN_Msk                 (1UL << SCB_CACR_ECCEN_Pos)                    /*!< SCB CACR: ECCEN Mask */
+
+#define SCB_CACR_SIWT_Pos                   0U                                            /*!< SCB CACR: SIWT Position */
+#define SCB_CACR_SIWT_Msk                  (1UL /*<< SCB_CACR_SIWT_Pos*/)                 /*!< SCB CACR: SIWT Mask */
+
+/* AHBS Control Register Definitions */
+#define SCB_AHBSCR_INITCOUNT_Pos           11U                                            /*!< SCB AHBSCR: INITCOUNT Position */
+#define SCB_AHBSCR_INITCOUNT_Msk           (0x1FUL << SCB_AHBPCR_INITCOUNT_Pos)           /*!< SCB AHBSCR: INITCOUNT Mask */
+
+#define SCB_AHBSCR_TPRI_Pos                 2U                                            /*!< SCB AHBSCR: TPRI Position */
+#define SCB_AHBSCR_TPRI_Msk                (0x1FFUL << SCB_AHBPCR_TPRI_Pos)               /*!< SCB AHBSCR: TPRI Mask */
+
+#define SCB_AHBSCR_CTL_Pos                  0U                                            /*!< SCB AHBSCR: CTL Position*/
+#define SCB_AHBSCR_CTL_Msk                 (3UL /*<< SCB_AHBPCR_CTL_Pos*/)                /*!< SCB AHBSCR: CTL Mask */
+
+/* Auxiliary Bus Fault Status Register Definitions */
+#define SCB_ABFSR_AXIMTYPE_Pos              8U                                            /*!< SCB ABFSR: AXIMTYPE Position*/
+#define SCB_ABFSR_AXIMTYPE_Msk             (3UL << SCB_ABFSR_AXIMTYPE_Pos)                /*!< SCB ABFSR: AXIMTYPE Mask */
+
+#define SCB_ABFSR_EPPB_Pos                  4U                                            /*!< SCB ABFSR: EPPB Position*/
+#define SCB_ABFSR_EPPB_Msk                 (1UL << SCB_ABFSR_EPPB_Pos)                    /*!< SCB ABFSR: EPPB Mask */
+
+#define SCB_ABFSR_AXIM_Pos                  3U                                            /*!< SCB ABFSR: AXIM Position*/
+#define SCB_ABFSR_AXIM_Msk                 (1UL << SCB_ABFSR_AXIM_Pos)                    /*!< SCB ABFSR: AXIM Mask */
+
+#define SCB_ABFSR_AHBP_Pos                  2U                                            /*!< SCB ABFSR: AHBP Position*/
+#define SCB_ABFSR_AHBP_Msk                 (1UL << SCB_ABFSR_AHBP_Pos)                    /*!< SCB ABFSR: AHBP Mask */
+
+#define SCB_ABFSR_DTCM_Pos                  1U                                            /*!< SCB ABFSR: DTCM Position*/
+#define SCB_ABFSR_DTCM_Msk                 (1UL << SCB_ABFSR_DTCM_Pos)                    /*!< SCB ABFSR: DTCM Mask */
+
+#define SCB_ABFSR_ITCM_Pos                  0U                                            /*!< SCB ABFSR: ITCM Position*/
+#define SCB_ABFSR_ITCM_Msk                 (1UL /*<< SCB_ABFSR_ITCM_Pos*/)                /*!< SCB ABFSR: ITCM Mask */
+
+/*@} end of group CMSIS_SCB */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB)
+  \brief    Type definitions for the System Control and ID Register not in the SCB
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Control and ID Register not in the SCB.
+ */
+typedef struct
+{
+        uint32_t RESERVED0[1U];
+  __IM  uint32_t ICTR;                   /*!< Offset: 0x004 (R/ )  Interrupt Controller Type Register */
+  __IOM uint32_t ACTLR;                  /*!< Offset: 0x008 (R/W)  Auxiliary Control Register */
+  __IOM uint32_t CPPWR;                  /*!< Offset: 0x00C (R/W)  Coprocessor Power Control  Register */
+} SCnSCB_Type;
+
+/* Interrupt Controller Type Register Definitions */
+#define SCnSCB_ICTR_INTLINESNUM_Pos         0U                                         /*!< ICTR: INTLINESNUM Position */
+#define SCnSCB_ICTR_INTLINESNUM_Msk        (0xFUL /*<< SCnSCB_ICTR_INTLINESNUM_Pos*/)  /*!< ICTR: INTLINESNUM Mask */
+
+/*@} end of group CMSIS_SCnotSCB */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SysTick     System Tick Timer (SysTick)
+  \brief    Type definitions for the System Timer Registers.
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Timer (SysTick).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  SysTick Control and Status Register */
+  __IOM uint32_t LOAD;                   /*!< Offset: 0x004 (R/W)  SysTick Reload Value Register */
+  __IOM uint32_t VAL;                    /*!< Offset: 0x008 (R/W)  SysTick Current Value Register */
+  __IM  uint32_t CALIB;                  /*!< Offset: 0x00C (R/ )  SysTick Calibration Register */
+} SysTick_Type;
+
+/* SysTick Control / Status Register Definitions */
+#define SysTick_CTRL_COUNTFLAG_Pos         16U                                            /*!< SysTick CTRL: COUNTFLAG Position */
+#define SysTick_CTRL_COUNTFLAG_Msk         (1UL << SysTick_CTRL_COUNTFLAG_Pos)            /*!< SysTick CTRL: COUNTFLAG Mask */
+
+#define SysTick_CTRL_CLKSOURCE_Pos          2U                                            /*!< SysTick CTRL: CLKSOURCE Position */
+#define SysTick_CTRL_CLKSOURCE_Msk         (1UL << SysTick_CTRL_CLKSOURCE_Pos)            /*!< SysTick CTRL: CLKSOURCE Mask */
+
+#define SysTick_CTRL_TICKINT_Pos            1U                                            /*!< SysTick CTRL: TICKINT Position */
+#define SysTick_CTRL_TICKINT_Msk           (1UL << SysTick_CTRL_TICKINT_Pos)              /*!< SysTick CTRL: TICKINT Mask */
+
+#define SysTick_CTRL_ENABLE_Pos             0U                                            /*!< SysTick CTRL: ENABLE Position */
+#define SysTick_CTRL_ENABLE_Msk            (1UL /*<< SysTick_CTRL_ENABLE_Pos*/)           /*!< SysTick CTRL: ENABLE Mask */
+
+/* SysTick Reload Register Definitions */
+#define SysTick_LOAD_RELOAD_Pos             0U                                            /*!< SysTick LOAD: RELOAD Position */
+#define SysTick_LOAD_RELOAD_Msk            (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/)    /*!< SysTick LOAD: RELOAD Mask */
+
+/* SysTick Current Register Definitions */
+#define SysTick_VAL_CURRENT_Pos             0U                                            /*!< SysTick VAL: CURRENT Position */
+#define SysTick_VAL_CURRENT_Msk            (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/)    /*!< SysTick VAL: CURRENT Mask */
+
+/* SysTick Calibration Register Definitions */
+#define SysTick_CALIB_NOREF_Pos            31U                                            /*!< SysTick CALIB: NOREF Position */
+#define SysTick_CALIB_NOREF_Msk            (1UL << SysTick_CALIB_NOREF_Pos)               /*!< SysTick CALIB: NOREF Mask */
+
+#define SysTick_CALIB_SKEW_Pos             30U                                            /*!< SysTick CALIB: SKEW Position */
+#define SysTick_CALIB_SKEW_Msk             (1UL << SysTick_CALIB_SKEW_Pos)                /*!< SysTick CALIB: SKEW Mask */
+
+#define SysTick_CALIB_TENMS_Pos             0U                                            /*!< SysTick CALIB: TENMS Position */
+#define SysTick_CALIB_TENMS_Msk            (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/)    /*!< SysTick CALIB: TENMS Mask */
+
+/*@} end of group CMSIS_SysTick */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_ITM     Instrumentation Trace Macrocell (ITM)
+  \brief    Type definitions for the Instrumentation Trace Macrocell (ITM)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Instrumentation Trace Macrocell Register (ITM).
+ */
+typedef struct
+{
+  __OM  union
+  {
+    __OM  uint8_t    u8;                 /*!< Offset: 0x000 ( /W)  ITM Stimulus Port 8-bit */
+    __OM  uint16_t   u16;                /*!< Offset: 0x000 ( /W)  ITM Stimulus Port 16-bit */
+    __OM  uint32_t   u32;                /*!< Offset: 0x000 ( /W)  ITM Stimulus Port 32-bit */
+  }  PORT [32U];                         /*!< Offset: 0x000 ( /W)  ITM Stimulus Port Registers */
+        uint32_t RESERVED0[864U];
+  __IOM uint32_t TER;                    /*!< Offset: 0xE00 (R/W)  ITM Trace Enable Register */
+        uint32_t RESERVED1[15U];
+  __IOM uint32_t TPR;                    /*!< Offset: 0xE40 (R/W)  ITM Trace Privilege Register */
+        uint32_t RESERVED2[15U];
+  __IOM uint32_t TCR;                    /*!< Offset: 0xE80 (R/W)  ITM Trace Control Register */
+        uint32_t RESERVED3[29U];
+  __OM  uint32_t IWR;                    /*!< Offset: 0xEF8 ( /W)  ITM Integration Write Register */
+  __IM  uint32_t IRR;                    /*!< Offset: 0xEFC (R/ )  ITM Integration Read Register */
+  __IOM uint32_t IMCR;                   /*!< Offset: 0xF00 (R/W)  ITM Integration Mode Control Register */
+        uint32_t RESERVED4[43U];
+  __OM  uint32_t LAR;                    /*!< Offset: 0xFB0 ( /W)  ITM Lock Access Register */
+  __IM  uint32_t LSR;                    /*!< Offset: 0xFB4 (R/ )  ITM Lock Status Register */
+        uint32_t RESERVED5[1U];
+  __IM  uint32_t DEVARCH;                /*!< Offset: 0xFBC (R/ )  ITM Device Architecture Register */
+        uint32_t RESERVED6[4U];
+  __IM  uint32_t PID4;                   /*!< Offset: 0xFD0 (R/ )  ITM Peripheral Identification Register #4 */
+  __IM  uint32_t PID5;                   /*!< Offset: 0xFD4 (R/ )  ITM Peripheral Identification Register #5 */
+  __IM  uint32_t PID6;                   /*!< Offset: 0xFD8 (R/ )  ITM Peripheral Identification Register #6 */
+  __IM  uint32_t PID7;                   /*!< Offset: 0xFDC (R/ )  ITM Peripheral Identification Register #7 */
+  __IM  uint32_t PID0;                   /*!< Offset: 0xFE0 (R/ )  ITM Peripheral Identification Register #0 */
+  __IM  uint32_t PID1;                   /*!< Offset: 0xFE4 (R/ )  ITM Peripheral Identification Register #1 */
+  __IM  uint32_t PID2;                   /*!< Offset: 0xFE8 (R/ )  ITM Peripheral Identification Register #2 */
+  __IM  uint32_t PID3;                   /*!< Offset: 0xFEC (R/ )  ITM Peripheral Identification Register #3 */
+  __IM  uint32_t CID0;                   /*!< Offset: 0xFF0 (R/ )  ITM Component  Identification Register #0 */
+  __IM  uint32_t CID1;                   /*!< Offset: 0xFF4 (R/ )  ITM Component  Identification Register #1 */
+  __IM  uint32_t CID2;                   /*!< Offset: 0xFF8 (R/ )  ITM Component  Identification Register #2 */
+  __IM  uint32_t CID3;                   /*!< Offset: 0xFFC (R/ )  ITM Component  Identification Register #3 */
+} ITM_Type;
+
+/* ITM Stimulus Port Register Definitions */
+#define ITM_STIM_DISABLED_Pos               1U                                            /*!< ITM STIM: DISABLED Position */
+#define ITM_STIM_DISABLED_Msk              (0x1UL << ITM_STIM_DISABLED_Pos)               /*!< ITM STIM: DISABLED Mask */
+
+#define ITM_STIM_FIFOREADY_Pos              0U                                            /*!< ITM STIM: FIFOREADY Position */
+#define ITM_STIM_FIFOREADY_Msk             (0x1UL /*<< ITM_STIM_FIFOREADY_Pos*/)          /*!< ITM STIM: FIFOREADY Mask */
+
+/* ITM Trace Privilege Register Definitions */
+#define ITM_TPR_PRIVMASK_Pos                0U                                            /*!< ITM TPR: PRIVMASK Position */
+#define ITM_TPR_PRIVMASK_Msk               (0xFUL /*<< ITM_TPR_PRIVMASK_Pos*/)            /*!< ITM TPR: PRIVMASK Mask */
+
+/* ITM Trace Control Register Definitions */
+#define ITM_TCR_BUSY_Pos                   23U                                            /*!< ITM TCR: BUSY Position */
+#define ITM_TCR_BUSY_Msk                   (1UL << ITM_TCR_BUSY_Pos)                      /*!< ITM TCR: BUSY Mask */
+
+#define ITM_TCR_TRACEBUSID_Pos             16U                                            /*!< ITM TCR: ATBID Position */
+#define ITM_TCR_TRACEBUSID_Msk             (0x7FUL << ITM_TCR_TRACEBUSID_Pos)             /*!< ITM TCR: ATBID Mask */
+
+#define ITM_TCR_GTSFREQ_Pos                10U                                            /*!< ITM TCR: Global timestamp frequency Position */
+#define ITM_TCR_GTSFREQ_Msk                (3UL << ITM_TCR_GTSFREQ_Pos)                   /*!< ITM TCR: Global timestamp frequency Mask */
+
+#define ITM_TCR_TSPRESCALE_Pos              8U                                            /*!< ITM TCR: TSPRESCALE Position */
+#define ITM_TCR_TSPRESCALE_Msk             (3UL << ITM_TCR_TSPRESCALE_Pos)                /*!< ITM TCR: TSPRESCALE Mask */
+
+#define ITM_TCR_STALLENA_Pos                5U                                            /*!< ITM TCR: STALLENA Position */
+#define ITM_TCR_STALLENA_Msk               (1UL << ITM_TCR_STALLENA_Pos)                  /*!< ITM TCR: STALLENA Mask */
+
+#define ITM_TCR_SWOENA_Pos                  4U                                            /*!< ITM TCR: SWOENA Position */
+#define ITM_TCR_SWOENA_Msk                 (1UL << ITM_TCR_SWOENA_Pos)                    /*!< ITM TCR: SWOENA Mask */
+
+#define ITM_TCR_DWTENA_Pos                  3U                                            /*!< ITM TCR: DWTENA Position */
+#define ITM_TCR_DWTENA_Msk                 (1UL << ITM_TCR_DWTENA_Pos)                    /*!< ITM TCR: DWTENA Mask */
+
+#define ITM_TCR_SYNCENA_Pos                 2U                                            /*!< ITM TCR: SYNCENA Position */
+#define ITM_TCR_SYNCENA_Msk                (1UL << ITM_TCR_SYNCENA_Pos)                   /*!< ITM TCR: SYNCENA Mask */
+
+#define ITM_TCR_TSENA_Pos                   1U                                            /*!< ITM TCR: TSENA Position */
+#define ITM_TCR_TSENA_Msk                  (1UL << ITM_TCR_TSENA_Pos)                     /*!< ITM TCR: TSENA Mask */
+
+#define ITM_TCR_ITMENA_Pos                  0U                                            /*!< ITM TCR: ITM Enable bit Position */
+#define ITM_TCR_ITMENA_Msk                 (1UL /*<< ITM_TCR_ITMENA_Pos*/)                /*!< ITM TCR: ITM Enable bit Mask */
+
+/* ITM Integration Write Register Definitions */
+#define ITM_IWR_ATVALIDM_Pos                0U                                            /*!< ITM IWR: ATVALIDM Position */
+#define ITM_IWR_ATVALIDM_Msk               (1UL /*<< ITM_IWR_ATVALIDM_Pos*/)              /*!< ITM IWR: ATVALIDM Mask */
+
+/* ITM Integration Read Register Definitions */
+#define ITM_IRR_ATREADYM_Pos                0U                                            /*!< ITM IRR: ATREADYM Position */
+#define ITM_IRR_ATREADYM_Msk               (1UL /*<< ITM_IRR_ATREADYM_Pos*/)              /*!< ITM IRR: ATREADYM Mask */
+
+/* ITM Integration Mode Control Register Definitions */
+#define ITM_IMCR_INTEGRATION_Pos            0U                                            /*!< ITM IMCR: INTEGRATION Position */
+#define ITM_IMCR_INTEGRATION_Msk           (1UL /*<< ITM_IMCR_INTEGRATION_Pos*/)          /*!< ITM IMCR: INTEGRATION Mask */
+
+/* ITM Lock Status Register Definitions */
+#define ITM_LSR_ByteAcc_Pos                 2U                                            /*!< ITM LSR: ByteAcc Position */
+#define ITM_LSR_ByteAcc_Msk                (1UL << ITM_LSR_ByteAcc_Pos)                   /*!< ITM LSR: ByteAcc Mask */
+
+#define ITM_LSR_Access_Pos                  1U                                            /*!< ITM LSR: Access Position */
+#define ITM_LSR_Access_Msk                 (1UL << ITM_LSR_Access_Pos)                    /*!< ITM LSR: Access Mask */
+
+#define ITM_LSR_Present_Pos                 0U                                            /*!< ITM LSR: Present Position */
+#define ITM_LSR_Present_Msk                (1UL /*<< ITM_LSR_Present_Pos*/)               /*!< ITM LSR: Present Mask */
+
+/*@}*/ /* end of group CMSIS_ITM */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_DWT     Data Watchpoint and Trace (DWT)
+  \brief    Type definitions for the Data Watchpoint and Trace (DWT)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Data Watchpoint and Trace Register (DWT).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  Control Register */
+  __IOM uint32_t CYCCNT;                 /*!< Offset: 0x004 (R/W)  Cycle Count Register */
+  __IOM uint32_t CPICNT;                 /*!< Offset: 0x008 (R/W)  CPI Count Register */
+  __IOM uint32_t EXCCNT;                 /*!< Offset: 0x00C (R/W)  Exception Overhead Count Register */
+  __IOM uint32_t SLEEPCNT;               /*!< Offset: 0x010 (R/W)  Sleep Count Register */
+  __IOM uint32_t LSUCNT;                 /*!< Offset: 0x014 (R/W)  LSU Count Register */
+  __IOM uint32_t FOLDCNT;                /*!< Offset: 0x018 (R/W)  Folded-instruction Count Register */
+  __IM  uint32_t PCSR;                   /*!< Offset: 0x01C (R/ )  Program Counter Sample Register */
+  __IOM uint32_t COMP0;                  /*!< Offset: 0x020 (R/W)  Comparator Register 0 */
+        uint32_t RESERVED1[1U];
+  __IOM uint32_t FUNCTION0;              /*!< Offset: 0x028 (R/W)  Function Register 0 */
+        uint32_t RESERVED2[1U];
+  __IOM uint32_t COMP1;                  /*!< Offset: 0x030 (R/W)  Comparator Register 1 */
+        uint32_t RESERVED3[1U];
+  __IOM uint32_t FUNCTION1;              /*!< Offset: 0x038 (R/W)  Function Register 1 */
+        uint32_t RESERVED4[1U];
+  __IOM uint32_t COMP2;                  /*!< Offset: 0x040 (R/W)  Comparator Register 2 */
+        uint32_t RESERVED5[1U];
+  __IOM uint32_t FUNCTION2;              /*!< Offset: 0x048 (R/W)  Function Register 2 */
+        uint32_t RESERVED6[1U];
+  __IOM uint32_t COMP3;                  /*!< Offset: 0x050 (R/W)  Comparator Register 3 */
+        uint32_t RESERVED7[1U];
+  __IOM uint32_t FUNCTION3;              /*!< Offset: 0x058 (R/W)  Function Register 3 */
+        uint32_t RESERVED8[1U];
+  __IOM uint32_t COMP4;                  /*!< Offset: 0x060 (R/W)  Comparator Register 4 */
+        uint32_t RESERVED9[1U];
+  __IOM uint32_t FUNCTION4;              /*!< Offset: 0x068 (R/W)  Function Register 4 */
+        uint32_t RESERVED10[1U];
+  __IOM uint32_t COMP5;                  /*!< Offset: 0x070 (R/W)  Comparator Register 5 */
+        uint32_t RESERVED11[1U];
+  __IOM uint32_t FUNCTION5;              /*!< Offset: 0x078 (R/W)  Function Register 5 */
+        uint32_t RESERVED12[1U];
+  __IOM uint32_t COMP6;                  /*!< Offset: 0x080 (R/W)  Comparator Register 6 */
+        uint32_t RESERVED13[1U];
+  __IOM uint32_t FUNCTION6;              /*!< Offset: 0x088 (R/W)  Function Register 6 */
+        uint32_t RESERVED14[1U];
+  __IOM uint32_t COMP7;                  /*!< Offset: 0x090 (R/W)  Comparator Register 7 */
+        uint32_t RESERVED15[1U];
+  __IOM uint32_t FUNCTION7;              /*!< Offset: 0x098 (R/W)  Function Register 7 */
+        uint32_t RESERVED16[1U];
+  __IOM uint32_t COMP8;                  /*!< Offset: 0x0A0 (R/W)  Comparator Register 8 */
+        uint32_t RESERVED17[1U];
+  __IOM uint32_t FUNCTION8;              /*!< Offset: 0x0A8 (R/W)  Function Register 8 */
+        uint32_t RESERVED18[1U];
+  __IOM uint32_t COMP9;                  /*!< Offset: 0x0B0 (R/W)  Comparator Register 9 */
+        uint32_t RESERVED19[1U];
+  __IOM uint32_t FUNCTION9;              /*!< Offset: 0x0B8 (R/W)  Function Register 9 */
+        uint32_t RESERVED20[1U];
+  __IOM uint32_t COMP10;                 /*!< Offset: 0x0C0 (R/W)  Comparator Register 10 */
+        uint32_t RESERVED21[1U];
+  __IOM uint32_t FUNCTION10;             /*!< Offset: 0x0C8 (R/W)  Function Register 10 */
+        uint32_t RESERVED22[1U];
+  __IOM uint32_t COMP11;                 /*!< Offset: 0x0D0 (R/W)  Comparator Register 11 */
+        uint32_t RESERVED23[1U];
+  __IOM uint32_t FUNCTION11;             /*!< Offset: 0x0D8 (R/W)  Function Register 11 */
+        uint32_t RESERVED24[1U];
+  __IOM uint32_t COMP12;                 /*!< Offset: 0x0E0 (R/W)  Comparator Register 12 */
+        uint32_t RESERVED25[1U];
+  __IOM uint32_t FUNCTION12;             /*!< Offset: 0x0E8 (R/W)  Function Register 12 */
+        uint32_t RESERVED26[1U];
+  __IOM uint32_t COMP13;                 /*!< Offset: 0x0F0 (R/W)  Comparator Register 13 */
+        uint32_t RESERVED27[1U];
+  __IOM uint32_t FUNCTION13;             /*!< Offset: 0x0F8 (R/W)  Function Register 13 */
+        uint32_t RESERVED28[1U];
+  __IOM uint32_t COMP14;                 /*!< Offset: 0x100 (R/W)  Comparator Register 14 */
+        uint32_t RESERVED29[1U];
+  __IOM uint32_t FUNCTION14;             /*!< Offset: 0x108 (R/W)  Function Register 14 */
+        uint32_t RESERVED30[1U];
+  __IOM uint32_t COMP15;                 /*!< Offset: 0x110 (R/W)  Comparator Register 15 */
+        uint32_t RESERVED31[1U];
+  __IOM uint32_t FUNCTION15;             /*!< Offset: 0x118 (R/W)  Function Register 15 */
+        uint32_t RESERVED32[934U];
+  __IM  uint32_t LSR;                    /*!< Offset: 0xFB4 (R  )  Lock Status Register */
+        uint32_t RESERVED33[1U];
+  __IM  uint32_t DEVARCH;                /*!< Offset: 0xFBC (R/ )  Device Architecture Register */
+} DWT_Type;
+
+/* DWT Control Register Definitions */
+#define DWT_CTRL_NUMCOMP_Pos               28U                                         /*!< DWT CTRL: NUMCOMP Position */
+#define DWT_CTRL_NUMCOMP_Msk               (0xFUL << DWT_CTRL_NUMCOMP_Pos)             /*!< DWT CTRL: NUMCOMP Mask */
+
+#define DWT_CTRL_NOTRCPKT_Pos              27U                                         /*!< DWT CTRL: NOTRCPKT Position */
+#define DWT_CTRL_NOTRCPKT_Msk              (0x1UL << DWT_CTRL_NOTRCPKT_Pos)            /*!< DWT CTRL: NOTRCPKT Mask */
+
+#define DWT_CTRL_NOEXTTRIG_Pos             26U                                         /*!< DWT CTRL: NOEXTTRIG Position */
+#define DWT_CTRL_NOEXTTRIG_Msk             (0x1UL << DWT_CTRL_NOEXTTRIG_Pos)           /*!< DWT CTRL: NOEXTTRIG Mask */
+
+#define DWT_CTRL_NOCYCCNT_Pos              25U                                         /*!< DWT CTRL: NOCYCCNT Position */
+#define DWT_CTRL_NOCYCCNT_Msk              (0x1UL << DWT_CTRL_NOCYCCNT_Pos)            /*!< DWT CTRL: NOCYCCNT Mask */
+
+#define DWT_CTRL_NOPRFCNT_Pos              24U                                         /*!< DWT CTRL: NOPRFCNT Position */
+#define DWT_CTRL_NOPRFCNT_Msk              (0x1UL << DWT_CTRL_NOPRFCNT_Pos)            /*!< DWT CTRL: NOPRFCNT Mask */
+
+#define DWT_CTRL_CYCDISS_Pos               23U                                         /*!< DWT CTRL: CYCDISS Position */
+#define DWT_CTRL_CYCDISS_Msk               (0x1UL << DWT_CTRL_CYCDISS_Pos)             /*!< DWT CTRL: CYCDISS Mask */
+
+#define DWT_CTRL_CYCEVTENA_Pos             22U                                         /*!< DWT CTRL: CYCEVTENA Position */
+#define DWT_CTRL_CYCEVTENA_Msk             (0x1UL << DWT_CTRL_CYCEVTENA_Pos)           /*!< DWT CTRL: CYCEVTENA Mask */
+
+#define DWT_CTRL_FOLDEVTENA_Pos            21U                                         /*!< DWT CTRL: FOLDEVTENA Position */
+#define DWT_CTRL_FOLDEVTENA_Msk            (0x1UL << DWT_CTRL_FOLDEVTENA_Pos)          /*!< DWT CTRL: FOLDEVTENA Mask */
+
+#define DWT_CTRL_LSUEVTENA_Pos             20U                                         /*!< DWT CTRL: LSUEVTENA Position */
+#define DWT_CTRL_LSUEVTENA_Msk             (0x1UL << DWT_CTRL_LSUEVTENA_Pos)           /*!< DWT CTRL: LSUEVTENA Mask */
+
+#define DWT_CTRL_SLEEPEVTENA_Pos           19U                                         /*!< DWT CTRL: SLEEPEVTENA Position */
+#define DWT_CTRL_SLEEPEVTENA_Msk           (0x1UL << DWT_CTRL_SLEEPEVTENA_Pos)         /*!< DWT CTRL: SLEEPEVTENA Mask */
+
+#define DWT_CTRL_EXCEVTENA_Pos             18U                                         /*!< DWT CTRL: EXCEVTENA Position */
+#define DWT_CTRL_EXCEVTENA_Msk             (0x1UL << DWT_CTRL_EXCEVTENA_Pos)           /*!< DWT CTRL: EXCEVTENA Mask */
+
+#define DWT_CTRL_CPIEVTENA_Pos             17U                                         /*!< DWT CTRL: CPIEVTENA Position */
+#define DWT_CTRL_CPIEVTENA_Msk             (0x1UL << DWT_CTRL_CPIEVTENA_Pos)           /*!< DWT CTRL: CPIEVTENA Mask */
+
+#define DWT_CTRL_EXCTRCENA_Pos             16U                                         /*!< DWT CTRL: EXCTRCENA Position */
+#define DWT_CTRL_EXCTRCENA_Msk             (0x1UL << DWT_CTRL_EXCTRCENA_Pos)           /*!< DWT CTRL: EXCTRCENA Mask */
+
+#define DWT_CTRL_PCSAMPLENA_Pos            12U                                         /*!< DWT CTRL: PCSAMPLENA Position */
+#define DWT_CTRL_PCSAMPLENA_Msk            (0x1UL << DWT_CTRL_PCSAMPLENA_Pos)          /*!< DWT CTRL: PCSAMPLENA Mask */
+
+#define DWT_CTRL_SYNCTAP_Pos               10U                                         /*!< DWT CTRL: SYNCTAP Position */
+#define DWT_CTRL_SYNCTAP_Msk               (0x3UL << DWT_CTRL_SYNCTAP_Pos)             /*!< DWT CTRL: SYNCTAP Mask */
+
+#define DWT_CTRL_CYCTAP_Pos                 9U                                         /*!< DWT CTRL: CYCTAP Position */
+#define DWT_CTRL_CYCTAP_Msk                (0x1UL << DWT_CTRL_CYCTAP_Pos)              /*!< DWT CTRL: CYCTAP Mask */
+
+#define DWT_CTRL_POSTINIT_Pos               5U                                         /*!< DWT CTRL: POSTINIT Position */
+#define DWT_CTRL_POSTINIT_Msk              (0xFUL << DWT_CTRL_POSTINIT_Pos)            /*!< DWT CTRL: POSTINIT Mask */
+
+#define DWT_CTRL_POSTPRESET_Pos             1U                                         /*!< DWT CTRL: POSTPRESET Position */
+#define DWT_CTRL_POSTPRESET_Msk            (0xFUL << DWT_CTRL_POSTPRESET_Pos)          /*!< DWT CTRL: POSTPRESET Mask */
+
+#define DWT_CTRL_CYCCNTENA_Pos              0U                                         /*!< DWT CTRL: CYCCNTENA Position */
+#define DWT_CTRL_CYCCNTENA_Msk             (0x1UL /*<< DWT_CTRL_CYCCNTENA_Pos*/)       /*!< DWT CTRL: CYCCNTENA Mask */
+
+/* DWT CPI Count Register Definitions */
+#define DWT_CPICNT_CPICNT_Pos               0U                                         /*!< DWT CPICNT: CPICNT Position */
+#define DWT_CPICNT_CPICNT_Msk              (0xFFUL /*<< DWT_CPICNT_CPICNT_Pos*/)       /*!< DWT CPICNT: CPICNT Mask */
+
+/* DWT Exception Overhead Count Register Definitions */
+#define DWT_EXCCNT_EXCCNT_Pos               0U                                         /*!< DWT EXCCNT: EXCCNT Position */
+#define DWT_EXCCNT_EXCCNT_Msk              (0xFFUL /*<< DWT_EXCCNT_EXCCNT_Pos*/)       /*!< DWT EXCCNT: EXCCNT Mask */
+
+/* DWT Sleep Count Register Definitions */
+#define DWT_SLEEPCNT_SLEEPCNT_Pos           0U                                         /*!< DWT SLEEPCNT: SLEEPCNT Position */
+#define DWT_SLEEPCNT_SLEEPCNT_Msk          (0xFFUL /*<< DWT_SLEEPCNT_SLEEPCNT_Pos*/)   /*!< DWT SLEEPCNT: SLEEPCNT Mask */
+
+/* DWT LSU Count Register Definitions */
+#define DWT_LSUCNT_LSUCNT_Pos               0U                                         /*!< DWT LSUCNT: LSUCNT Position */
+#define DWT_LSUCNT_LSUCNT_Msk              (0xFFUL /*<< DWT_LSUCNT_LSUCNT_Pos*/)       /*!< DWT LSUCNT: LSUCNT Mask */
+
+/* DWT Folded-instruction Count Register Definitions */
+#define DWT_FOLDCNT_FOLDCNT_Pos             0U                                         /*!< DWT FOLDCNT: FOLDCNT Position */
+#define DWT_FOLDCNT_FOLDCNT_Msk            (0xFFUL /*<< DWT_FOLDCNT_FOLDCNT_Pos*/)     /*!< DWT FOLDCNT: FOLDCNT Mask */
+
+/* DWT Comparator Function Register Definitions */
+#define DWT_FUNCTION_ID_Pos                27U                                         /*!< DWT FUNCTION: ID Position */
+#define DWT_FUNCTION_ID_Msk                (0x1FUL << DWT_FUNCTION_ID_Pos)             /*!< DWT FUNCTION: ID Mask */
+
+#define DWT_FUNCTION_MATCHED_Pos           24U                                         /*!< DWT FUNCTION: MATCHED Position */
+#define DWT_FUNCTION_MATCHED_Msk           (0x1UL << DWT_FUNCTION_MATCHED_Pos)         /*!< DWT FUNCTION: MATCHED Mask */
+
+#define DWT_FUNCTION_DATAVSIZE_Pos         10U                                         /*!< DWT FUNCTION: DATAVSIZE Position */
+#define DWT_FUNCTION_DATAVSIZE_Msk         (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos)       /*!< DWT FUNCTION: DATAVSIZE Mask */
+
+#define DWT_FUNCTION_ACTION_Pos             4U                                         /*!< DWT FUNCTION: ACTION Position */
+#define DWT_FUNCTION_ACTION_Msk            (0x1UL << DWT_FUNCTION_ACTION_Pos)          /*!< DWT FUNCTION: ACTION Mask */
+
+#define DWT_FUNCTION_MATCH_Pos              0U                                         /*!< DWT FUNCTION: MATCH Position */
+#define DWT_FUNCTION_MATCH_Msk             (0xFUL /*<< DWT_FUNCTION_MATCH_Pos*/)       /*!< DWT FUNCTION: MATCH Mask */
+
+/*@}*/ /* end of group CMSIS_DWT */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_TPI     Trace Port Interface (TPI)
+  \brief    Type definitions for the Trace Port Interface (TPI)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Trace Port Interface Register (TPI).
+ */
+typedef struct
+{
+  __IM  uint32_t SSPSR;                  /*!< Offset: 0x000 (R/ )  Supported Parallel Port Sizes Register */
+  __IOM uint32_t CSPSR;                  /*!< Offset: 0x004 (R/W)  Current Parallel Port Sizes Register */
+        uint32_t RESERVED0[2U];
+  __IOM uint32_t ACPR;                   /*!< Offset: 0x010 (R/W)  Asynchronous Clock Prescaler Register */
+        uint32_t RESERVED1[55U];
+  __IOM uint32_t SPPR;                   /*!< Offset: 0x0F0 (R/W)  Selected Pin Protocol Register */
+        uint32_t RESERVED2[131U];
+  __IM  uint32_t FFSR;                   /*!< Offset: 0x300 (R/ )  Formatter and Flush Status Register */
+  __IOM uint32_t FFCR;                   /*!< Offset: 0x304 (R/W)  Formatter and Flush Control Register */
+  __IM  uint32_t FSCR;                   /*!< Offset: 0x308 (R/ )  Formatter Synchronization Counter Register */
+        uint32_t RESERVED3[759U];
+  __IM  uint32_t TRIGGER;                /*!< Offset: 0xEE8 (R/ )  TRIGGER */
+  __IM  uint32_t FIFO0;                  /*!< Offset: 0xEEC (R/ )  Integration ETM Data */
+  __IM  uint32_t ITATBCTR2;              /*!< Offset: 0xEF0 (R/ )  ITATBCTR2 */
+        uint32_t RESERVED4[1U];
+  __IM  uint32_t ITATBCTR0;              /*!< Offset: 0xEF8 (R/ )  ITATBCTR0 */
+  __IM  uint32_t FIFO1;                  /*!< Offset: 0xEFC (R/ )  Integration ITM Data */
+  __IOM uint32_t ITCTRL;                 /*!< Offset: 0xF00 (R/W)  Integration Mode Control */
+        uint32_t RESERVED5[39U];
+  __IOM uint32_t CLAIMSET;               /*!< Offset: 0xFA0 (R/W)  Claim tag set */
+  __IOM uint32_t CLAIMCLR;               /*!< Offset: 0xFA4 (R/W)  Claim tag clear */
+        uint32_t RESERVED7[8U];
+  __IM  uint32_t DEVID;                  /*!< Offset: 0xFC8 (R/ )  TPIU_DEVID */
+  __IM  uint32_t DEVTYPE;                /*!< Offset: 0xFCC (R/ )  TPIU_DEVTYPE */
+} TPI_Type;
+
+/* TPI Asynchronous Clock Prescaler Register Definitions */
+#define TPI_ACPR_PRESCALER_Pos              0U                                         /*!< TPI ACPR: PRESCALER Position */
+#define TPI_ACPR_PRESCALER_Msk             (0x1FFFUL /*<< TPI_ACPR_PRESCALER_Pos*/)    /*!< TPI ACPR: PRESCALER Mask */
+
+/* TPI Selected Pin Protocol Register Definitions */
+#define TPI_SPPR_TXMODE_Pos                 0U                                         /*!< TPI SPPR: TXMODE Position */
+#define TPI_SPPR_TXMODE_Msk                (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/)          /*!< TPI SPPR: TXMODE Mask */
+
+/* TPI Formatter and Flush Status Register Definitions */
+#define TPI_FFSR_FtNonStop_Pos              3U                                         /*!< TPI FFSR: FtNonStop Position */
+#define TPI_FFSR_FtNonStop_Msk             (0x1UL << TPI_FFSR_FtNonStop_Pos)           /*!< TPI FFSR: FtNonStop Mask */
+
+#define TPI_FFSR_TCPresent_Pos              2U                                         /*!< TPI FFSR: TCPresent Position */
+#define TPI_FFSR_TCPresent_Msk             (0x1UL << TPI_FFSR_TCPresent_Pos)           /*!< TPI FFSR: TCPresent Mask */
+
+#define TPI_FFSR_FtStopped_Pos              1U                                         /*!< TPI FFSR: FtStopped Position */
+#define TPI_FFSR_FtStopped_Msk             (0x1UL << TPI_FFSR_FtStopped_Pos)           /*!< TPI FFSR: FtStopped Mask */
+
+#define TPI_FFSR_FlInProg_Pos               0U                                         /*!< TPI FFSR: FlInProg Position */
+#define TPI_FFSR_FlInProg_Msk              (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/)        /*!< TPI FFSR: FlInProg Mask */
+
+/* TPI Formatter and Flush Control Register Definitions */
+#define TPI_FFCR_TrigIn_Pos                 8U                                         /*!< TPI FFCR: TrigIn Position */
+#define TPI_FFCR_TrigIn_Msk                (0x1UL << TPI_FFCR_TrigIn_Pos)              /*!< TPI FFCR: TrigIn Mask */
+
+#define TPI_FFCR_EnFCont_Pos                1U                                         /*!< TPI FFCR: EnFCont Position */
+#define TPI_FFCR_EnFCont_Msk               (0x1UL << TPI_FFCR_EnFCont_Pos)             /*!< TPI FFCR: EnFCont Mask */
+
+/* TPI TRIGGER Register Definitions */
+#define TPI_TRIGGER_TRIGGER_Pos             0U                                         /*!< TPI TRIGGER: TRIGGER Position */
+#define TPI_TRIGGER_TRIGGER_Msk            (0x1UL /*<< TPI_TRIGGER_TRIGGER_Pos*/)      /*!< TPI TRIGGER: TRIGGER Mask */
+
+/* TPI Integration ETM Data Register Definitions (FIFO0) */
+#define TPI_FIFO0_ITM_ATVALID_Pos          29U                                         /*!< TPI FIFO0: ITM_ATVALID Position */
+#define TPI_FIFO0_ITM_ATVALID_Msk          (0x3UL << TPI_FIFO0_ITM_ATVALID_Pos)        /*!< TPI FIFO0: ITM_ATVALID Mask */
+
+#define TPI_FIFO0_ITM_bytecount_Pos        27U                                         /*!< TPI FIFO0: ITM_bytecount Position */
+#define TPI_FIFO0_ITM_bytecount_Msk        (0x3UL << TPI_FIFO0_ITM_bytecount_Pos)      /*!< TPI FIFO0: ITM_bytecount Mask */
+
+#define TPI_FIFO0_ETM_ATVALID_Pos          26U                                         /*!< TPI FIFO0: ETM_ATVALID Position */
+#define TPI_FIFO0_ETM_ATVALID_Msk          (0x3UL << TPI_FIFO0_ETM_ATVALID_Pos)        /*!< TPI FIFO0: ETM_ATVALID Mask */
+
+#define TPI_FIFO0_ETM_bytecount_Pos        24U                                         /*!< TPI FIFO0: ETM_bytecount Position */
+#define TPI_FIFO0_ETM_bytecount_Msk        (0x3UL << TPI_FIFO0_ETM_bytecount_Pos)      /*!< TPI FIFO0: ETM_bytecount Mask */
+
+#define TPI_FIFO0_ETM2_Pos                 16U                                         /*!< TPI FIFO0: ETM2 Position */
+#define TPI_FIFO0_ETM2_Msk                 (0xFFUL << TPI_FIFO0_ETM2_Pos)              /*!< TPI FIFO0: ETM2 Mask */
+
+#define TPI_FIFO0_ETM1_Pos                  8U                                         /*!< TPI FIFO0: ETM1 Position */
+#define TPI_FIFO0_ETM1_Msk                 (0xFFUL << TPI_FIFO0_ETM1_Pos)              /*!< TPI FIFO0: ETM1 Mask */
+
+#define TPI_FIFO0_ETM0_Pos                  0U                                         /*!< TPI FIFO0: ETM0 Position */
+#define TPI_FIFO0_ETM0_Msk                 (0xFFUL /*<< TPI_FIFO0_ETM0_Pos*/)          /*!< TPI FIFO0: ETM0 Mask */
+
+/* TPI ITATBCTR2 Register Definitions */
+#define TPI_ITATBCTR2_ATREADY_Pos           0U                                         /*!< TPI ITATBCTR2: ATREADY Position */
+#define TPI_ITATBCTR2_ATREADY_Msk          (0x1UL /*<< TPI_ITATBCTR2_ATREADY_Pos*/)    /*!< TPI ITATBCTR2: ATREADY Mask */
+
+/* TPI Integration ITM Data Register Definitions (FIFO1) */
+#define TPI_FIFO1_ITM_ATVALID_Pos          29U                                         /*!< TPI FIFO1: ITM_ATVALID Position */
+#define TPI_FIFO1_ITM_ATVALID_Msk          (0x3UL << TPI_FIFO1_ITM_ATVALID_Pos)        /*!< TPI FIFO1: ITM_ATVALID Mask */
+
+#define TPI_FIFO1_ITM_bytecount_Pos        27U                                         /*!< TPI FIFO1: ITM_bytecount Position */
+#define TPI_FIFO1_ITM_bytecount_Msk        (0x3UL << TPI_FIFO1_ITM_bytecount_Pos)      /*!< TPI FIFO1: ITM_bytecount Mask */
+
+#define TPI_FIFO1_ETM_ATVALID_Pos          26U                                         /*!< TPI FIFO1: ETM_ATVALID Position */
+#define TPI_FIFO1_ETM_ATVALID_Msk          (0x3UL << TPI_FIFO1_ETM_ATVALID_Pos)        /*!< TPI FIFO1: ETM_ATVALID Mask */
+
+#define TPI_FIFO1_ETM_bytecount_Pos        24U                                         /*!< TPI FIFO1: ETM_bytecount Position */
+#define TPI_FIFO1_ETM_bytecount_Msk        (0x3UL << TPI_FIFO1_ETM_bytecount_Pos)      /*!< TPI FIFO1: ETM_bytecount Mask */
+
+#define TPI_FIFO1_ITM2_Pos                 16U                                         /*!< TPI FIFO1: ITM2 Position */
+#define TPI_FIFO1_ITM2_Msk                 (0xFFUL << TPI_FIFO1_ITM2_Pos)              /*!< TPI FIFO1: ITM2 Mask */
+
+#define TPI_FIFO1_ITM1_Pos                  8U                                         /*!< TPI FIFO1: ITM1 Position */
+#define TPI_FIFO1_ITM1_Msk                 (0xFFUL << TPI_FIFO1_ITM1_Pos)              /*!< TPI FIFO1: ITM1 Mask */
+
+#define TPI_FIFO1_ITM0_Pos                  0U                                         /*!< TPI FIFO1: ITM0 Position */
+#define TPI_FIFO1_ITM0_Msk                 (0xFFUL /*<< TPI_FIFO1_ITM0_Pos*/)          /*!< TPI FIFO1: ITM0 Mask */
+
+/* TPI ITATBCTR0 Register Definitions */
+#define TPI_ITATBCTR0_ATREADY_Pos           0U                                         /*!< TPI ITATBCTR0: ATREADY Position */
+#define TPI_ITATBCTR0_ATREADY_Msk          (0x1UL /*<< TPI_ITATBCTR0_ATREADY_Pos*/)    /*!< TPI ITATBCTR0: ATREADY Mask */
+
+/* TPI Integration Mode Control Register Definitions */
+#define TPI_ITCTRL_Mode_Pos                 0U                                         /*!< TPI ITCTRL: Mode Position */
+#define TPI_ITCTRL_Mode_Msk                (0x1UL /*<< TPI_ITCTRL_Mode_Pos*/)          /*!< TPI ITCTRL: Mode Mask */
+
+/* TPI DEVID Register Definitions */
+#define TPI_DEVID_NRZVALID_Pos             11U                                         /*!< TPI DEVID: NRZVALID Position */
+#define TPI_DEVID_NRZVALID_Msk             (0x1UL << TPI_DEVID_NRZVALID_Pos)           /*!< TPI DEVID: NRZVALID Mask */
+
+#define TPI_DEVID_MANCVALID_Pos            10U                                         /*!< TPI DEVID: MANCVALID Position */
+#define TPI_DEVID_MANCVALID_Msk            (0x1UL << TPI_DEVID_MANCVALID_Pos)          /*!< TPI DEVID: MANCVALID Mask */
+
+#define TPI_DEVID_PTINVALID_Pos             9U                                         /*!< TPI DEVID: PTINVALID Position */
+#define TPI_DEVID_PTINVALID_Msk            (0x1UL << TPI_DEVID_PTINVALID_Pos)          /*!< TPI DEVID: PTINVALID Mask */
+
+#define TPI_DEVID_MinBufSz_Pos              6U                                         /*!< TPI DEVID: MinBufSz Position */
+#define TPI_DEVID_MinBufSz_Msk             (0x7UL << TPI_DEVID_MinBufSz_Pos)           /*!< TPI DEVID: MinBufSz Mask */
+
+#define TPI_DEVID_AsynClkIn_Pos             5U                                         /*!< TPI DEVID: AsynClkIn Position */
+#define TPI_DEVID_AsynClkIn_Msk            (0x1UL << TPI_DEVID_AsynClkIn_Pos)          /*!< TPI DEVID: AsynClkIn Mask */
+
+#define TPI_DEVID_NrTraceInput_Pos          0U                                         /*!< TPI DEVID: NrTraceInput Position */
+#define TPI_DEVID_NrTraceInput_Msk         (0x1FUL /*<< TPI_DEVID_NrTraceInput_Pos*/)  /*!< TPI DEVID: NrTraceInput Mask */
+
+/* TPI DEVTYPE Register Definitions */
+#define TPI_DEVTYPE_MajorType_Pos           4U                                         /*!< TPI DEVTYPE: MajorType Position */
+#define TPI_DEVTYPE_MajorType_Msk          (0xFUL << TPI_DEVTYPE_MajorType_Pos)        /*!< TPI DEVTYPE: MajorType Mask */
+
+#define TPI_DEVTYPE_SubType_Pos             0U                                         /*!< TPI DEVTYPE: SubType Position */
+#define TPI_DEVTYPE_SubType_Msk            (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/)      /*!< TPI DEVTYPE: SubType Mask */
+
+/*@}*/ /* end of group CMSIS_TPI */
+
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_MPU     Memory Protection Unit (MPU)
+  \brief    Type definitions for the Memory Protection Unit (MPU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Memory Protection Unit (MPU).
+ */
+typedef struct
+{
+  __IM  uint32_t TYPE;                   /*!< Offset: 0x000 (R/ )  MPU Type Register */
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x004 (R/W)  MPU Control Register */
+  __IOM uint32_t RNR;                    /*!< Offset: 0x008 (R/W)  MPU Region Number Register */
+  __IOM uint32_t RBAR;                   /*!< Offset: 0x00C (R/W)  MPU Region Base Address Register */
+  __IOM uint32_t RLAR;                   /*!< Offset: 0x010 (R/W)  MPU Region Limit Address Register */
+  __IOM uint32_t RBAR_A1;                /*!< Offset: 0x014 (R/W)  MPU Region Base Address Register Alias 1 */
+  __IOM uint32_t RLAR_A1;                /*!< Offset: 0x018 (R/W)  MPU Region Limit Address Register Alias 1 */
+  __IOM uint32_t RBAR_A2;                /*!< Offset: 0x01C (R/W)  MPU Region Base Address Register Alias 2 */
+  __IOM uint32_t RLAR_A2;                /*!< Offset: 0x020 (R/W)  MPU Region Limit Address Register Alias 2 */
+  __IOM uint32_t RBAR_A3;                /*!< Offset: 0x024 (R/W)  MPU Region Base Address Register Alias 3 */
+  __IOM uint32_t RLAR_A3;                /*!< Offset: 0x028 (R/W)  MPU Region Limit Address Register Alias 3 */
+        uint32_t RESERVED0[1];
+  union {
+  __IOM uint32_t MAIR[2];
+  struct {
+  __IOM uint32_t MAIR0;                  /*!< Offset: 0x030 (R/W)  MPU Memory Attribute Indirection Register 0 */
+  __IOM uint32_t MAIR1;                  /*!< Offset: 0x034 (R/W)  MPU Memory Attribute Indirection Register 1 */
+  };
+  };
+} MPU_Type;
+
+#define MPU_TYPE_RALIASES                  4U
+
+/* MPU Type Register Definitions */
+#define MPU_TYPE_IREGION_Pos               16U                                            /*!< MPU TYPE: IREGION Position */
+#define MPU_TYPE_IREGION_Msk               (0xFFUL << MPU_TYPE_IREGION_Pos)               /*!< MPU TYPE: IREGION Mask */
+
+#define MPU_TYPE_DREGION_Pos                8U                                            /*!< MPU TYPE: DREGION Position */
+#define MPU_TYPE_DREGION_Msk               (0xFFUL << MPU_TYPE_DREGION_Pos)               /*!< MPU TYPE: DREGION Mask */
+
+#define MPU_TYPE_SEPARATE_Pos               0U                                            /*!< MPU TYPE: SEPARATE Position */
+#define MPU_TYPE_SEPARATE_Msk              (1UL /*<< MPU_TYPE_SEPARATE_Pos*/)             /*!< MPU TYPE: SEPARATE Mask */
+
+/* MPU Control Register Definitions */
+#define MPU_CTRL_PRIVDEFENA_Pos             2U                                            /*!< MPU CTRL: PRIVDEFENA Position */
+#define MPU_CTRL_PRIVDEFENA_Msk            (1UL << MPU_CTRL_PRIVDEFENA_Pos)               /*!< MPU CTRL: PRIVDEFENA Mask */
+
+#define MPU_CTRL_HFNMIENA_Pos               1U                                            /*!< MPU CTRL: HFNMIENA Position */
+#define MPU_CTRL_HFNMIENA_Msk              (1UL << MPU_CTRL_HFNMIENA_Pos)                 /*!< MPU CTRL: HFNMIENA Mask */
+
+#define MPU_CTRL_ENABLE_Pos                 0U                                            /*!< MPU CTRL: ENABLE Position */
+#define MPU_CTRL_ENABLE_Msk                (1UL /*<< MPU_CTRL_ENABLE_Pos*/)               /*!< MPU CTRL: ENABLE Mask */
+
+/* MPU Region Number Register Definitions */
+#define MPU_RNR_REGION_Pos                  0U                                            /*!< MPU RNR: REGION Position */
+#define MPU_RNR_REGION_Msk                 (0xFFUL /*<< MPU_RNR_REGION_Pos*/)             /*!< MPU RNR: REGION Mask */
+
+/* MPU Region Base Address Register Definitions */
+#define MPU_RBAR_ADDR_Pos                   5U                                            /*!< MPU RBAR: ADDR Position */
+#define MPU_RBAR_ADDR_Msk                  (0x7FFFFFFUL << MPU_RBAR_ADDR_Pos)             /*!< MPU RBAR: ADDR Mask */
+
+#define MPU_RBAR_SH_Pos                     3U                                            /*!< MPU RBAR: SH Position */
+#define MPU_RBAR_SH_Msk                    (0x3UL << MPU_RBAR_SH_Pos)                     /*!< MPU RBAR: SH Mask */
+
+#define MPU_RBAR_AP_Pos                     1U                                            /*!< MPU RBAR: AP Position */
+#define MPU_RBAR_AP_Msk                    (0x3UL << MPU_RBAR_AP_Pos)                     /*!< MPU RBAR: AP Mask */
+
+#define MPU_RBAR_XN_Pos                     0U                                            /*!< MPU RBAR: XN Position */
+#define MPU_RBAR_XN_Msk                    (01UL /*<< MPU_RBAR_XN_Pos*/)                  /*!< MPU RBAR: XN Mask */
+
+/* MPU Region Limit Address Register Definitions */
+#define MPU_RLAR_LIMIT_Pos                  5U                                            /*!< MPU RLAR: LIMIT Position */
+#define MPU_RLAR_LIMIT_Msk                 (0x7FFFFFFUL << MPU_RLAR_LIMIT_Pos)            /*!< MPU RLAR: LIMIT Mask */
+
+#define MPU_RLAR_PXN_Pos                    4U                                            /*!< MPU RLAR: PXN Position */
+#define MPU_RLAR_PXN_Msk                   (0x1UL << MPU_RLAR_PXN_Pos)                    /*!< MPU RLAR: PXN Mask */
+
+#define MPU_RLAR_AttrIndx_Pos               1U                                            /*!< MPU RLAR: AttrIndx Position */
+#define MPU_RLAR_AttrIndx_Msk              (0x7UL << MPU_RLAR_AttrIndx_Pos)               /*!< MPU RLAR: AttrIndx Mask */
+
+#define MPU_RLAR_EN_Pos                     0U                                            /*!< MPU RLAR: Region enable bit Position */
+#define MPU_RLAR_EN_Msk                    (1UL /*<< MPU_RLAR_EN_Pos*/)                   /*!< MPU RLAR: Region enable bit Disable Mask */
+
+/* MPU Memory Attribute Indirection Register 0 Definitions */
+#define MPU_MAIR0_Attr3_Pos                24U                                            /*!< MPU MAIR0: Attr3 Position */
+#define MPU_MAIR0_Attr3_Msk                (0xFFUL << MPU_MAIR0_Attr3_Pos)                /*!< MPU MAIR0: Attr3 Mask */
+
+#define MPU_MAIR0_Attr2_Pos                16U                                            /*!< MPU MAIR0: Attr2 Position */
+#define MPU_MAIR0_Attr2_Msk                (0xFFUL << MPU_MAIR0_Attr2_Pos)                /*!< MPU MAIR0: Attr2 Mask */
+
+#define MPU_MAIR0_Attr1_Pos                 8U                                            /*!< MPU MAIR0: Attr1 Position */
+#define MPU_MAIR0_Attr1_Msk                (0xFFUL << MPU_MAIR0_Attr1_Pos)                /*!< MPU MAIR0: Attr1 Mask */
+
+#define MPU_MAIR0_Attr0_Pos                 0U                                            /*!< MPU MAIR0: Attr0 Position */
+#define MPU_MAIR0_Attr0_Msk                (0xFFUL /*<< MPU_MAIR0_Attr0_Pos*/)            /*!< MPU MAIR0: Attr0 Mask */
+
+/* MPU Memory Attribute Indirection Register 1 Definitions */
+#define MPU_MAIR1_Attr7_Pos                24U                                            /*!< MPU MAIR1: Attr7 Position */
+#define MPU_MAIR1_Attr7_Msk                (0xFFUL << MPU_MAIR1_Attr7_Pos)                /*!< MPU MAIR1: Attr7 Mask */
+
+#define MPU_MAIR1_Attr6_Pos                16U                                            /*!< MPU MAIR1: Attr6 Position */
+#define MPU_MAIR1_Attr6_Msk                (0xFFUL << MPU_MAIR1_Attr6_Pos)                /*!< MPU MAIR1: Attr6 Mask */
+
+#define MPU_MAIR1_Attr5_Pos                 8U                                            /*!< MPU MAIR1: Attr5 Position */
+#define MPU_MAIR1_Attr5_Msk                (0xFFUL << MPU_MAIR1_Attr5_Pos)                /*!< MPU MAIR1: Attr5 Mask */
+
+#define MPU_MAIR1_Attr4_Pos                 0U                                            /*!< MPU MAIR1: Attr4 Position */
+#define MPU_MAIR1_Attr4_Msk                (0xFFUL /*<< MPU_MAIR1_Attr4_Pos*/)            /*!< MPU MAIR1: Attr4 Mask */
+
+/*@} end of group CMSIS_MPU */
+#endif
+
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SAU     Security Attribution Unit (SAU)
+  \brief    Type definitions for the Security Attribution Unit (SAU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Security Attribution Unit (SAU).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  SAU Control Register */
+  __IM  uint32_t TYPE;                   /*!< Offset: 0x004 (R/ )  SAU Type Register */
+#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U)
+  __IOM uint32_t RNR;                    /*!< Offset: 0x008 (R/W)  SAU Region Number Register */
+  __IOM uint32_t RBAR;                   /*!< Offset: 0x00C (R/W)  SAU Region Base Address Register */
+  __IOM uint32_t RLAR;                   /*!< Offset: 0x010 (R/W)  SAU Region Limit Address Register */
+#else
+        uint32_t RESERVED0[3];
+#endif
+  __IOM uint32_t SFSR;                   /*!< Offset: 0x014 (R/W)  Secure Fault Status Register */
+  __IOM uint32_t SFAR;                   /*!< Offset: 0x018 (R/W)  Secure Fault Address Register */
+} SAU_Type;
+
+/* SAU Control Register Definitions */
+#define SAU_CTRL_ALLNS_Pos                  1U                                            /*!< SAU CTRL: ALLNS Position */
+#define SAU_CTRL_ALLNS_Msk                 (1UL << SAU_CTRL_ALLNS_Pos)                    /*!< SAU CTRL: ALLNS Mask */
+
+#define SAU_CTRL_ENABLE_Pos                 0U                                            /*!< SAU CTRL: ENABLE Position */
+#define SAU_CTRL_ENABLE_Msk                (1UL /*<< SAU_CTRL_ENABLE_Pos*/)               /*!< SAU CTRL: ENABLE Mask */
+
+/* SAU Type Register Definitions */
+#define SAU_TYPE_SREGION_Pos                0U                                            /*!< SAU TYPE: SREGION Position */
+#define SAU_TYPE_SREGION_Msk               (0xFFUL /*<< SAU_TYPE_SREGION_Pos*/)           /*!< SAU TYPE: SREGION Mask */
+
+#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U)
+/* SAU Region Number Register Definitions */
+#define SAU_RNR_REGION_Pos                  0U                                            /*!< SAU RNR: REGION Position */
+#define SAU_RNR_REGION_Msk                 (0xFFUL /*<< SAU_RNR_REGION_Pos*/)             /*!< SAU RNR: REGION Mask */
+
+/* SAU Region Base Address Register Definitions */
+#define SAU_RBAR_BADDR_Pos                  5U                                            /*!< SAU RBAR: BADDR Position */
+#define SAU_RBAR_BADDR_Msk                 (0x7FFFFFFUL << SAU_RBAR_BADDR_Pos)            /*!< SAU RBAR: BADDR Mask */
+
+/* SAU Region Limit Address Register Definitions */
+#define SAU_RLAR_LADDR_Pos                  5U                                            /*!< SAU RLAR: LADDR Position */
+#define SAU_RLAR_LADDR_Msk                 (0x7FFFFFFUL << SAU_RLAR_LADDR_Pos)            /*!< SAU RLAR: LADDR Mask */
+
+#define SAU_RLAR_NSC_Pos                    1U                                            /*!< SAU RLAR: NSC Position */
+#define SAU_RLAR_NSC_Msk                   (1UL << SAU_RLAR_NSC_Pos)                      /*!< SAU RLAR: NSC Mask */
+
+#define SAU_RLAR_ENABLE_Pos                 0U                                            /*!< SAU RLAR: ENABLE Position */
+#define SAU_RLAR_ENABLE_Msk                (1UL /*<< SAU_RLAR_ENABLE_Pos*/)               /*!< SAU RLAR: ENABLE Mask */
+
+#endif /* defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) */
+
+/* Secure Fault Status Register Definitions */
+#define SAU_SFSR_LSERR_Pos                  7U                                            /*!< SAU SFSR: LSERR Position */
+#define SAU_SFSR_LSERR_Msk                 (1UL << SAU_SFSR_LSERR_Pos)                    /*!< SAU SFSR: LSERR Mask */
+
+#define SAU_SFSR_SFARVALID_Pos              6U                                            /*!< SAU SFSR: SFARVALID Position */
+#define SAU_SFSR_SFARVALID_Msk             (1UL << SAU_SFSR_SFARVALID_Pos)                /*!< SAU SFSR: SFARVALID Mask */
+
+#define SAU_SFSR_LSPERR_Pos                 5U                                            /*!< SAU SFSR: LSPERR Position */
+#define SAU_SFSR_LSPERR_Msk                (1UL << SAU_SFSR_LSPERR_Pos)                   /*!< SAU SFSR: LSPERR Mask */
+
+#define SAU_SFSR_INVTRAN_Pos                4U                                            /*!< SAU SFSR: INVTRAN Position */
+#define SAU_SFSR_INVTRAN_Msk               (1UL << SAU_SFSR_INVTRAN_Pos)                  /*!< SAU SFSR: INVTRAN Mask */
+
+#define SAU_SFSR_AUVIOL_Pos                 3U                                            /*!< SAU SFSR: AUVIOL Position */
+#define SAU_SFSR_AUVIOL_Msk                (1UL << SAU_SFSR_AUVIOL_Pos)                   /*!< SAU SFSR: AUVIOL Mask */
+
+#define SAU_SFSR_INVER_Pos                  2U                                            /*!< SAU SFSR: INVER Position */
+#define SAU_SFSR_INVER_Msk                 (1UL << SAU_SFSR_INVER_Pos)                    /*!< SAU SFSR: INVER Mask */
+
+#define SAU_SFSR_INVIS_Pos                  1U                                            /*!< SAU SFSR: INVIS Position */
+#define SAU_SFSR_INVIS_Msk                 (1UL << SAU_SFSR_INVIS_Pos)                    /*!< SAU SFSR: INVIS Mask */
+
+#define SAU_SFSR_INVEP_Pos                  0U                                            /*!< SAU SFSR: INVEP Position */
+#define SAU_SFSR_INVEP_Msk                 (1UL /*<< SAU_SFSR_INVEP_Pos*/)                /*!< SAU SFSR: INVEP Mask */
+
+/*@} end of group CMSIS_SAU */
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_FPU     Floating Point Unit (FPU)
+  \brief    Type definitions for the Floating Point Unit (FPU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Floating Point Unit (FPU).
+ */
+typedef struct
+{
+        uint32_t RESERVED0[1U];
+  __IOM uint32_t FPCCR;                  /*!< Offset: 0x004 (R/W)  Floating-Point Context Control Register */
+  __IOM uint32_t FPCAR;                  /*!< Offset: 0x008 (R/W)  Floating-Point Context Address Register */
+  __IOM uint32_t FPDSCR;                 /*!< Offset: 0x00C (R/W)  Floating-Point Default Status Control Register */
+  __IM  uint32_t MVFR0;                  /*!< Offset: 0x010 (R/ )  Media and FP Feature Register 0 */
+  __IM  uint32_t MVFR1;                  /*!< Offset: 0x014 (R/ )  Media and FP Feature Register 1 */
+} FPU_Type;
+
+/* Floating-Point Context Control Register Definitions */
+#define FPU_FPCCR_ASPEN_Pos                31U                                            /*!< FPCCR: ASPEN bit Position */
+#define FPU_FPCCR_ASPEN_Msk                (1UL << FPU_FPCCR_ASPEN_Pos)                   /*!< FPCCR: ASPEN bit Mask */
+
+#define FPU_FPCCR_LSPEN_Pos                30U                                            /*!< FPCCR: LSPEN Position */
+#define FPU_FPCCR_LSPEN_Msk                (1UL << FPU_FPCCR_LSPEN_Pos)                   /*!< FPCCR: LSPEN bit Mask */
+
+#define FPU_FPCCR_LSPENS_Pos               29U                                            /*!< FPCCR: LSPENS Position */
+#define FPU_FPCCR_LSPENS_Msk               (1UL << FPU_FPCCR_LSPENS_Pos)                  /*!< FPCCR: LSPENS bit Mask */
+
+#define FPU_FPCCR_CLRONRET_Pos             28U                                            /*!< FPCCR: CLRONRET Position */
+#define FPU_FPCCR_CLRONRET_Msk             (1UL << FPU_FPCCR_CLRONRET_Pos)                /*!< FPCCR: CLRONRET bit Mask */
+
+#define FPU_FPCCR_CLRONRETS_Pos            27U                                            /*!< FPCCR: CLRONRETS Position */
+#define FPU_FPCCR_CLRONRETS_Msk            (1UL << FPU_FPCCR_CLRONRETS_Pos)               /*!< FPCCR: CLRONRETS bit Mask */
+
+#define FPU_FPCCR_TS_Pos                   26U                                            /*!< FPCCR: TS Position */
+#define FPU_FPCCR_TS_Msk                   (1UL << FPU_FPCCR_TS_Pos)                      /*!< FPCCR: TS bit Mask */
+
+#define FPU_FPCCR_UFRDY_Pos                10U                                            /*!< FPCCR: UFRDY Position */
+#define FPU_FPCCR_UFRDY_Msk                (1UL << FPU_FPCCR_UFRDY_Pos)                   /*!< FPCCR: UFRDY bit Mask */
+
+#define FPU_FPCCR_SPLIMVIOL_Pos             9U                                            /*!< FPCCR: SPLIMVIOL Position */
+#define FPU_FPCCR_SPLIMVIOL_Msk            (1UL << FPU_FPCCR_SPLIMVIOL_Pos)               /*!< FPCCR: SPLIMVIOL bit Mask */
+
+#define FPU_FPCCR_MONRDY_Pos                8U                                            /*!< FPCCR: MONRDY Position */
+#define FPU_FPCCR_MONRDY_Msk               (1UL << FPU_FPCCR_MONRDY_Pos)                  /*!< FPCCR: MONRDY bit Mask */
+
+#define FPU_FPCCR_SFRDY_Pos                 7U                                            /*!< FPCCR: SFRDY Position */
+#define FPU_FPCCR_SFRDY_Msk                (1UL << FPU_FPCCR_SFRDY_Pos)                   /*!< FPCCR: SFRDY bit Mask */
+
+#define FPU_FPCCR_BFRDY_Pos                 6U                                            /*!< FPCCR: BFRDY Position */
+#define FPU_FPCCR_BFRDY_Msk                (1UL << FPU_FPCCR_BFRDY_Pos)                   /*!< FPCCR: BFRDY bit Mask */
+
+#define FPU_FPCCR_MMRDY_Pos                 5U                                            /*!< FPCCR: MMRDY Position */
+#define FPU_FPCCR_MMRDY_Msk                (1UL << FPU_FPCCR_MMRDY_Pos)                   /*!< FPCCR: MMRDY bit Mask */
+
+#define FPU_FPCCR_HFRDY_Pos                 4U                                            /*!< FPCCR: HFRDY Position */
+#define FPU_FPCCR_HFRDY_Msk                (1UL << FPU_FPCCR_HFRDY_Pos)                   /*!< FPCCR: HFRDY bit Mask */
+
+#define FPU_FPCCR_THREAD_Pos                3U                                            /*!< FPCCR: processor mode bit Position */
+#define FPU_FPCCR_THREAD_Msk               (1UL << FPU_FPCCR_THREAD_Pos)                  /*!< FPCCR: processor mode active bit Mask */
+
+#define FPU_FPCCR_S_Pos                     2U                                            /*!< FPCCR: Security status of the FP context bit Position */
+#define FPU_FPCCR_S_Msk                    (1UL << FPU_FPCCR_S_Pos)                       /*!< FPCCR: Security status of the FP context bit Mask */
+
+#define FPU_FPCCR_USER_Pos                  1U                                            /*!< FPCCR: privilege level bit Position */
+#define FPU_FPCCR_USER_Msk                 (1UL << FPU_FPCCR_USER_Pos)                    /*!< FPCCR: privilege level bit Mask */
+
+#define FPU_FPCCR_LSPACT_Pos                0U                                            /*!< FPCCR: Lazy state preservation active bit Position */
+#define FPU_FPCCR_LSPACT_Msk               (1UL /*<< FPU_FPCCR_LSPACT_Pos*/)              /*!< FPCCR: Lazy state preservation active bit Mask */
+
+/* Floating-Point Context Address Register Definitions */
+#define FPU_FPCAR_ADDRESS_Pos               3U                                            /*!< FPCAR: ADDRESS bit Position */
+#define FPU_FPCAR_ADDRESS_Msk              (0x1FFFFFFFUL << FPU_FPCAR_ADDRESS_Pos)        /*!< FPCAR: ADDRESS bit Mask */
+
+/* Floating-Point Default Status Control Register Definitions */
+#define FPU_FPDSCR_AHP_Pos                 26U                                            /*!< FPDSCR: AHP bit Position */
+#define FPU_FPDSCR_AHP_Msk                 (1UL << FPU_FPDSCR_AHP_Pos)                    /*!< FPDSCR: AHP bit Mask */
+
+#define FPU_FPDSCR_DN_Pos                  25U                                            /*!< FPDSCR: DN bit Position */
+#define FPU_FPDSCR_DN_Msk                  (1UL << FPU_FPDSCR_DN_Pos)                     /*!< FPDSCR: DN bit Mask */
+
+#define FPU_FPDSCR_FZ_Pos                  24U                                            /*!< FPDSCR: FZ bit Position */
+#define FPU_FPDSCR_FZ_Msk                  (1UL << FPU_FPDSCR_FZ_Pos)                     /*!< FPDSCR: FZ bit Mask */
+
+#define FPU_FPDSCR_RMode_Pos               22U                                            /*!< FPDSCR: RMode bit Position */
+#define FPU_FPDSCR_RMode_Msk               (3UL << FPU_FPDSCR_RMode_Pos)                  /*!< FPDSCR: RMode bit Mask */
+
+/* Media and FP Feature Register 0 Definitions */
+#define FPU_MVFR0_FP_rounding_modes_Pos    28U                                            /*!< MVFR0: FP rounding modes bits Position */
+#define FPU_MVFR0_FP_rounding_modes_Msk    (0xFUL << FPU_MVFR0_FP_rounding_modes_Pos)     /*!< MVFR0: FP rounding modes bits Mask */
+
+#define FPU_MVFR0_Short_vectors_Pos        24U                                            /*!< MVFR0: Short vectors bits Position */
+#define FPU_MVFR0_Short_vectors_Msk        (0xFUL << FPU_MVFR0_Short_vectors_Pos)         /*!< MVFR0: Short vectors bits Mask */
+
+#define FPU_MVFR0_Square_root_Pos          20U                                            /*!< MVFR0: Square root bits Position */
+#define FPU_MVFR0_Square_root_Msk          (0xFUL << FPU_MVFR0_Square_root_Pos)           /*!< MVFR0: Square root bits Mask */
+
+#define FPU_MVFR0_Divide_Pos               16U                                            /*!< MVFR0: Divide bits Position */
+#define FPU_MVFR0_Divide_Msk               (0xFUL << FPU_MVFR0_Divide_Pos)                /*!< MVFR0: Divide bits Mask */
+
+#define FPU_MVFR0_FP_excep_trapping_Pos    12U                                            /*!< MVFR0: FP exception trapping bits Position */
+#define FPU_MVFR0_FP_excep_trapping_Msk    (0xFUL << FPU_MVFR0_FP_excep_trapping_Pos)     /*!< MVFR0: FP exception trapping bits Mask */
+
+#define FPU_MVFR0_Double_precision_Pos      8U                                            /*!< MVFR0: Double-precision bits Position */
+#define FPU_MVFR0_Double_precision_Msk     (0xFUL << FPU_MVFR0_Double_precision_Pos)      /*!< MVFR0: Double-precision bits Mask */
+
+#define FPU_MVFR0_Single_precision_Pos      4U                                            /*!< MVFR0: Single-precision bits Position */
+#define FPU_MVFR0_Single_precision_Msk     (0xFUL << FPU_MVFR0_Single_precision_Pos)      /*!< MVFR0: Single-precision bits Mask */
+
+#define FPU_MVFR0_A_SIMD_registers_Pos      0U                                            /*!< MVFR0: A_SIMD registers bits Position */
+#define FPU_MVFR0_A_SIMD_registers_Msk     (0xFUL /*<< FPU_MVFR0_A_SIMD_registers_Pos*/)  /*!< MVFR0: A_SIMD registers bits Mask */
+
+/* Media and FP Feature Register 1 Definitions */
+#define FPU_MVFR1_FP_fused_MAC_Pos         28U                                            /*!< MVFR1: FP fused MAC bits Position */
+#define FPU_MVFR1_FP_fused_MAC_Msk         (0xFUL << FPU_MVFR1_FP_fused_MAC_Pos)          /*!< MVFR1: FP fused MAC bits Mask */
+
+#define FPU_MVFR1_FP_HPFP_Pos              24U                                            /*!< MVFR1: FP HPFP bits Position */
+#define FPU_MVFR1_FP_HPFP_Msk              (0xFUL << FPU_MVFR1_FP_HPFP_Pos)               /*!< MVFR1: FP HPFP bits Mask */
+
+#define FPU_MVFR1_D_NaN_mode_Pos            4U                                            /*!< MVFR1: D_NaN mode bits Position */
+#define FPU_MVFR1_D_NaN_mode_Msk           (0xFUL << FPU_MVFR1_D_NaN_mode_Pos)            /*!< MVFR1: D_NaN mode bits Mask */
+
+#define FPU_MVFR1_FtZ_mode_Pos              0U                                            /*!< MVFR1: FtZ mode bits Position */
+#define FPU_MVFR1_FtZ_mode_Msk             (0xFUL /*<< FPU_MVFR1_FtZ_mode_Pos*/)          /*!< MVFR1: FtZ mode bits Mask */
+
+/*@} end of group CMSIS_FPU */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_CoreDebug       Core Debug Registers (CoreDebug)
+  \brief    Type definitions for the Core Debug Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Core Debug Register (CoreDebug).
+ */
+typedef struct
+{
+  __IOM uint32_t DHCSR;                  /*!< Offset: 0x000 (R/W)  Debug Halting Control and Status Register */
+  __OM  uint32_t DCRSR;                  /*!< Offset: 0x004 ( /W)  Debug Core Register Selector Register */
+  __IOM uint32_t DCRDR;                  /*!< Offset: 0x008 (R/W)  Debug Core Register Data Register */
+  __IOM uint32_t DEMCR;                  /*!< Offset: 0x00C (R/W)  Debug Exception and Monitor Control Register */
+        uint32_t RESERVED4[1U];
+  __IOM uint32_t DAUTHCTRL;              /*!< Offset: 0x014 (R/W)  Debug Authentication Control Register */
+  __IOM uint32_t DSCSR;                  /*!< Offset: 0x018 (R/W)  Debug Security Control and Status Register */
+} CoreDebug_Type;
+
+/* Debug Halting Control and Status Register Definitions */
+#define CoreDebug_DHCSR_DBGKEY_Pos         16U                                            /*!< CoreDebug DHCSR: DBGKEY Position */
+#define CoreDebug_DHCSR_DBGKEY_Msk         (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos)       /*!< CoreDebug DHCSR: DBGKEY Mask */
+
+#define CoreDebug_DHCSR_S_RESTART_ST_Pos   26U                                            /*!< CoreDebug DHCSR: S_RESTART_ST Position */
+#define CoreDebug_DHCSR_S_RESTART_ST_Msk   (1UL << CoreDebug_DHCSR_S_RESTART_ST_Pos)      /*!< CoreDebug DHCSR: S_RESTART_ST Mask */
+
+#define CoreDebug_DHCSR_S_RESET_ST_Pos     25U                                            /*!< CoreDebug DHCSR: S_RESET_ST Position */
+#define CoreDebug_DHCSR_S_RESET_ST_Msk     (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos)        /*!< CoreDebug DHCSR: S_RESET_ST Mask */
+
+#define CoreDebug_DHCSR_S_RETIRE_ST_Pos    24U                                            /*!< CoreDebug DHCSR: S_RETIRE_ST Position */
+#define CoreDebug_DHCSR_S_RETIRE_ST_Msk    (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos)       /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */
+
+#define CoreDebug_DHCSR_S_LOCKUP_Pos       19U                                            /*!< CoreDebug DHCSR: S_LOCKUP Position */
+#define CoreDebug_DHCSR_S_LOCKUP_Msk       (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos)          /*!< CoreDebug DHCSR: S_LOCKUP Mask */
+
+#define CoreDebug_DHCSR_S_SLEEP_Pos        18U                                            /*!< CoreDebug DHCSR: S_SLEEP Position */
+#define CoreDebug_DHCSR_S_SLEEP_Msk        (1UL << CoreDebug_DHCSR_S_SLEEP_Pos)           /*!< CoreDebug DHCSR: S_SLEEP Mask */
+
+#define CoreDebug_DHCSR_S_HALT_Pos         17U                                            /*!< CoreDebug DHCSR: S_HALT Position */
+#define CoreDebug_DHCSR_S_HALT_Msk         (1UL << CoreDebug_DHCSR_S_HALT_Pos)            /*!< CoreDebug DHCSR: S_HALT Mask */
+
+#define CoreDebug_DHCSR_S_REGRDY_Pos       16U                                            /*!< CoreDebug DHCSR: S_REGRDY Position */
+#define CoreDebug_DHCSR_S_REGRDY_Msk       (1UL << CoreDebug_DHCSR_S_REGRDY_Pos)          /*!< CoreDebug DHCSR: S_REGRDY Mask */
+
+#define CoreDebug_DHCSR_C_SNAPSTALL_Pos     5U                                            /*!< CoreDebug DHCSR: C_SNAPSTALL Position */
+#define CoreDebug_DHCSR_C_SNAPSTALL_Msk    (1UL << CoreDebug_DHCSR_C_SNAPSTALL_Pos)       /*!< CoreDebug DHCSR: C_SNAPSTALL Mask */
+
+#define CoreDebug_DHCSR_C_MASKINTS_Pos      3U                                            /*!< CoreDebug DHCSR: C_MASKINTS Position */
+#define CoreDebug_DHCSR_C_MASKINTS_Msk     (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos)        /*!< CoreDebug DHCSR: C_MASKINTS Mask */
+
+#define CoreDebug_DHCSR_C_STEP_Pos          2U                                            /*!< CoreDebug DHCSR: C_STEP Position */
+#define CoreDebug_DHCSR_C_STEP_Msk         (1UL << CoreDebug_DHCSR_C_STEP_Pos)            /*!< CoreDebug DHCSR: C_STEP Mask */
+
+#define CoreDebug_DHCSR_C_HALT_Pos          1U                                            /*!< CoreDebug DHCSR: C_HALT Position */
+#define CoreDebug_DHCSR_C_HALT_Msk         (1UL << CoreDebug_DHCSR_C_HALT_Pos)            /*!< CoreDebug DHCSR: C_HALT Mask */
+
+#define CoreDebug_DHCSR_C_DEBUGEN_Pos       0U                                            /*!< CoreDebug DHCSR: C_DEBUGEN Position */
+#define CoreDebug_DHCSR_C_DEBUGEN_Msk      (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/)     /*!< CoreDebug DHCSR: C_DEBUGEN Mask */
+
+/* Debug Core Register Selector Register Definitions */
+#define CoreDebug_DCRSR_REGWnR_Pos         16U                                            /*!< CoreDebug DCRSR: REGWnR Position */
+#define CoreDebug_DCRSR_REGWnR_Msk         (1UL << CoreDebug_DCRSR_REGWnR_Pos)            /*!< CoreDebug DCRSR: REGWnR Mask */
+
+#define CoreDebug_DCRSR_REGSEL_Pos          0U                                            /*!< CoreDebug DCRSR: REGSEL Position */
+#define CoreDebug_DCRSR_REGSEL_Msk         (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/)     /*!< CoreDebug DCRSR: REGSEL Mask */
+
+/* Debug Exception and Monitor Control Register Definitions */
+#define CoreDebug_DEMCR_TRCENA_Pos         24U                                            /*!< CoreDebug DEMCR: TRCENA Position */
+#define CoreDebug_DEMCR_TRCENA_Msk         (1UL << CoreDebug_DEMCR_TRCENA_Pos)            /*!< CoreDebug DEMCR: TRCENA Mask */
+
+#define CoreDebug_DEMCR_MON_REQ_Pos        19U                                            /*!< CoreDebug DEMCR: MON_REQ Position */
+#define CoreDebug_DEMCR_MON_REQ_Msk        (1UL << CoreDebug_DEMCR_MON_REQ_Pos)           /*!< CoreDebug DEMCR: MON_REQ Mask */
+
+#define CoreDebug_DEMCR_MON_STEP_Pos       18U                                            /*!< CoreDebug DEMCR: MON_STEP Position */
+#define CoreDebug_DEMCR_MON_STEP_Msk       (1UL << CoreDebug_DEMCR_MON_STEP_Pos)          /*!< CoreDebug DEMCR: MON_STEP Mask */
+
+#define CoreDebug_DEMCR_MON_PEND_Pos       17U                                            /*!< CoreDebug DEMCR: MON_PEND Position */
+#define CoreDebug_DEMCR_MON_PEND_Msk       (1UL << CoreDebug_DEMCR_MON_PEND_Pos)          /*!< CoreDebug DEMCR: MON_PEND Mask */
+
+#define CoreDebug_DEMCR_MON_EN_Pos         16U                                            /*!< CoreDebug DEMCR: MON_EN Position */
+#define CoreDebug_DEMCR_MON_EN_Msk         (1UL << CoreDebug_DEMCR_MON_EN_Pos)            /*!< CoreDebug DEMCR: MON_EN Mask */
+
+#define CoreDebug_DEMCR_VC_HARDERR_Pos     10U                                            /*!< CoreDebug DEMCR: VC_HARDERR Position */
+#define CoreDebug_DEMCR_VC_HARDERR_Msk     (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos)        /*!< CoreDebug DEMCR: VC_HARDERR Mask */
+
+#define CoreDebug_DEMCR_VC_INTERR_Pos       9U                                            /*!< CoreDebug DEMCR: VC_INTERR Position */
+#define CoreDebug_DEMCR_VC_INTERR_Msk      (1UL << CoreDebug_DEMCR_VC_INTERR_Pos)         /*!< CoreDebug DEMCR: VC_INTERR Mask */
+
+#define CoreDebug_DEMCR_VC_BUSERR_Pos       8U                                            /*!< CoreDebug DEMCR: VC_BUSERR Position */
+#define CoreDebug_DEMCR_VC_BUSERR_Msk      (1UL << CoreDebug_DEMCR_VC_BUSERR_Pos)         /*!< CoreDebug DEMCR: VC_BUSERR Mask */
+
+#define CoreDebug_DEMCR_VC_STATERR_Pos      7U                                            /*!< CoreDebug DEMCR: VC_STATERR Position */
+#define CoreDebug_DEMCR_VC_STATERR_Msk     (1UL << CoreDebug_DEMCR_VC_STATERR_Pos)        /*!< CoreDebug DEMCR: VC_STATERR Mask */
+
+#define CoreDebug_DEMCR_VC_CHKERR_Pos       6U                                            /*!< CoreDebug DEMCR: VC_CHKERR Position */
+#define CoreDebug_DEMCR_VC_CHKERR_Msk      (1UL << CoreDebug_DEMCR_VC_CHKERR_Pos)         /*!< CoreDebug DEMCR: VC_CHKERR Mask */
+
+#define CoreDebug_DEMCR_VC_NOCPERR_Pos      5U                                            /*!< CoreDebug DEMCR: VC_NOCPERR Position */
+#define CoreDebug_DEMCR_VC_NOCPERR_Msk     (1UL << CoreDebug_DEMCR_VC_NOCPERR_Pos)        /*!< CoreDebug DEMCR: VC_NOCPERR Mask */
+
+#define CoreDebug_DEMCR_VC_MMERR_Pos        4U                                            /*!< CoreDebug DEMCR: VC_MMERR Position */
+#define CoreDebug_DEMCR_VC_MMERR_Msk       (1UL << CoreDebug_DEMCR_VC_MMERR_Pos)          /*!< CoreDebug DEMCR: VC_MMERR Mask */
+
+#define CoreDebug_DEMCR_VC_CORERESET_Pos    0U                                            /*!< CoreDebug DEMCR: VC_CORERESET Position */
+#define CoreDebug_DEMCR_VC_CORERESET_Msk   (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/)  /*!< CoreDebug DEMCR: VC_CORERESET Mask */
+
+/* Debug Authentication Control Register Definitions */
+#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos  3U                                            /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Position */
+#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos)    /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Mask */
+
+#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos  2U                                            /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Position */
+#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Msk (1UL << CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos)    /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Mask */
+
+#define CoreDebug_DAUTHCTRL_INTSPIDEN_Pos   1U                                            /*!< CoreDebug DAUTHCTRL: INTSPIDEN Position */
+#define CoreDebug_DAUTHCTRL_INTSPIDEN_Msk  (1UL << CoreDebug_DAUTHCTRL_INTSPIDEN_Pos)     /*!< CoreDebug DAUTHCTRL: INTSPIDEN Mask */
+
+#define CoreDebug_DAUTHCTRL_SPIDENSEL_Pos   0U                                            /*!< CoreDebug DAUTHCTRL: SPIDENSEL Position */
+#define CoreDebug_DAUTHCTRL_SPIDENSEL_Msk  (1UL /*<< CoreDebug_DAUTHCTRL_SPIDENSEL_Pos*/) /*!< CoreDebug DAUTHCTRL: SPIDENSEL Mask */
+
+/* Debug Security Control and Status Register Definitions */
+#define CoreDebug_DSCSR_CDS_Pos            16U                                            /*!< CoreDebug DSCSR: CDS Position */
+#define CoreDebug_DSCSR_CDS_Msk            (1UL << CoreDebug_DSCSR_CDS_Pos)               /*!< CoreDebug DSCSR: CDS Mask */
+
+#define CoreDebug_DSCSR_SBRSEL_Pos          1U                                            /*!< CoreDebug DSCSR: SBRSEL Position */
+#define CoreDebug_DSCSR_SBRSEL_Msk         (1UL << CoreDebug_DSCSR_SBRSEL_Pos)            /*!< CoreDebug DSCSR: SBRSEL Mask */
+
+#define CoreDebug_DSCSR_SBRSELEN_Pos        0U                                            /*!< CoreDebug DSCSR: SBRSELEN Position */
+#define CoreDebug_DSCSR_SBRSELEN_Msk       (1UL /*<< CoreDebug_DSCSR_SBRSELEN_Pos*/)      /*!< CoreDebug DSCSR: SBRSELEN Mask */
+
+/*@} end of group CMSIS_CoreDebug */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_core_bitfield     Core register bit field macros
+  \brief      Macros for use with bit field definitions (xxx_Pos, xxx_Msk).
+  @{
+ */
+
+/**
+  \brief   Mask and shift a bit field value for use in a register bit range.
+  \param[in] field  Name of the register bit field.
+  \param[in] value  Value of the bit field. This parameter is interpreted as an uint32_t type.
+  \return           Masked and shifted value.
+*/
+#define _VAL2FLD(field, value)    (((uint32_t)(value) << field ## _Pos) & field ## _Msk)
+
+/**
+  \brief     Mask and shift a register value to extract a bit filed value.
+  \param[in] field  Name of the register bit field.
+  \param[in] value  Value of register. This parameter is interpreted as an uint32_t type.
+  \return           Masked and shifted bit field value.
+*/
+#define _FLD2VAL(field, value)    (((uint32_t)(value) & field ## _Msk) >> field ## _Pos)
+
+/*@} end of group CMSIS_core_bitfield */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_core_base     Core Definitions
+  \brief      Definitions for base addresses, unions, and structures.
+  @{
+ */
+
+/* Memory mapping of Core Hardware */
+  #define SCS_BASE            (0xE000E000UL)                             /*!< System Control Space Base Address */
+  #define ITM_BASE            (0xE0000000UL)                             /*!< ITM Base Address */
+  #define DWT_BASE            (0xE0001000UL)                             /*!< DWT Base Address */
+  #define TPI_BASE            (0xE0040000UL)                             /*!< TPI Base Address */
+  #define CoreDebug_BASE      (0xE000EDF0UL)                             /*!< Core Debug Base Address */
+  #define SysTick_BASE        (SCS_BASE +  0x0010UL)                     /*!< SysTick Base Address */
+  #define NVIC_BASE           (SCS_BASE +  0x0100UL)                     /*!< NVIC Base Address */
+  #define SCB_BASE            (SCS_BASE +  0x0D00UL)                     /*!< System Control Block Base Address */
+
+  #define SCnSCB              ((SCnSCB_Type    *)     SCS_BASE         ) /*!< System control Register not in SCB */
+  #define SCB                 ((SCB_Type       *)     SCB_BASE         ) /*!< SCB configuration struct */
+  #define SysTick             ((SysTick_Type   *)     SysTick_BASE     ) /*!< SysTick configuration struct */
+  #define NVIC                ((NVIC_Type      *)     NVIC_BASE        ) /*!< NVIC configuration struct */
+  #define ITM                 ((ITM_Type       *)     ITM_BASE         ) /*!< ITM configuration struct */
+  #define DWT                 ((DWT_Type       *)     DWT_BASE         ) /*!< DWT configuration struct */
+  #define TPI                 ((TPI_Type       *)     TPI_BASE         ) /*!< TPI configuration struct */
+  #define CoreDebug           ((CoreDebug_Type *)     CoreDebug_BASE   ) /*!< Core Debug configuration struct */
+
+  #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+    #define MPU_BASE          (SCS_BASE +  0x0D90UL)                     /*!< Memory Protection Unit */
+    #define MPU               ((MPU_Type       *)     MPU_BASE         ) /*!< Memory Protection Unit */
+  #endif
+
+  #if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+    #define SAU_BASE          (SCS_BASE +  0x0DD0UL)                     /*!< Security Attribution Unit */
+    #define SAU               ((SAU_Type       *)     SAU_BASE         ) /*!< Security Attribution Unit */
+  #endif
+
+  #define FPU_BASE            (SCS_BASE +  0x0F30UL)                     /*!< Floating Point Unit */
+  #define FPU                 ((FPU_Type       *)     FPU_BASE         ) /*!< Floating Point Unit */
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+  #define SCS_BASE_NS         (0xE002E000UL)                             /*!< System Control Space Base Address (non-secure address space) */
+  #define CoreDebug_BASE_NS   (0xE002EDF0UL)                             /*!< Core Debug Base Address           (non-secure address space) */
+  #define SysTick_BASE_NS     (SCS_BASE_NS +  0x0010UL)                  /*!< SysTick Base Address              (non-secure address space) */
+  #define NVIC_BASE_NS        (SCS_BASE_NS +  0x0100UL)                  /*!< NVIC Base Address                 (non-secure address space) */
+  #define SCB_BASE_NS         (SCS_BASE_NS +  0x0D00UL)                  /*!< System Control Block Base Address (non-secure address space) */
+
+  #define SCnSCB_NS           ((SCnSCB_Type    *)     SCS_BASE_NS      ) /*!< System control Register not in SCB(non-secure address space) */
+  #define SCB_NS              ((SCB_Type       *)     SCB_BASE_NS      ) /*!< SCB configuration struct          (non-secure address space) */
+  #define SysTick_NS          ((SysTick_Type   *)     SysTick_BASE_NS  ) /*!< SysTick configuration struct      (non-secure address space) */
+  #define NVIC_NS             ((NVIC_Type      *)     NVIC_BASE_NS     ) /*!< NVIC configuration struct         (non-secure address space) */
+  #define CoreDebug_NS        ((CoreDebug_Type *)     CoreDebug_BASE_NS) /*!< Core Debug configuration struct   (non-secure address space) */
+
+  #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+    #define MPU_BASE_NS       (SCS_BASE_NS +  0x0D90UL)                  /*!< Memory Protection Unit            (non-secure address space) */
+    #define MPU_NS            ((MPU_Type       *)     MPU_BASE_NS      ) /*!< Memory Protection Unit            (non-secure address space) */
+  #endif
+
+  #define FPU_BASE_NS         (SCS_BASE_NS +  0x0F30UL)                  /*!< Floating Point Unit               (non-secure address space) */
+  #define FPU_NS              ((FPU_Type       *)     FPU_BASE_NS      ) /*!< Floating Point Unit               (non-secure address space) */
+
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+/*@} */
+
+
+
+/*******************************************************************************
+ *                Hardware Abstraction Layer
+  Core Function Interface contains:
+  - Core NVIC Functions
+  - Core SysTick Functions
+  - Core Debug Functions
+  - Core Register Access Functions
+ ******************************************************************************/
+/**
+  \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference
+*/
+
+
+
+/* ##########################   NVIC functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_NVICFunctions NVIC Functions
+  \brief    Functions that manage interrupts and exceptions via the NVIC.
+  @{
+ */
+
+#ifdef CMSIS_NVIC_VIRTUAL
+  #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
+    #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
+  #endif
+  #include CMSIS_NVIC_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetPriorityGrouping    __NVIC_SetPriorityGrouping
+  #define NVIC_GetPriorityGrouping    __NVIC_GetPriorityGrouping
+  #define NVIC_EnableIRQ              __NVIC_EnableIRQ
+  #define NVIC_GetEnableIRQ           __NVIC_GetEnableIRQ
+  #define NVIC_DisableIRQ             __NVIC_DisableIRQ
+  #define NVIC_GetPendingIRQ          __NVIC_GetPendingIRQ
+  #define NVIC_SetPendingIRQ          __NVIC_SetPendingIRQ
+  #define NVIC_ClearPendingIRQ        __NVIC_ClearPendingIRQ
+  #define NVIC_GetActive              __NVIC_GetActive
+  #define NVIC_SetPriority            __NVIC_SetPriority
+  #define NVIC_GetPriority            __NVIC_GetPriority
+  #define NVIC_SystemReset            __NVIC_SystemReset
+#endif /* CMSIS_NVIC_VIRTUAL */
+
+#ifdef CMSIS_VECTAB_VIRTUAL
+  #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+    #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h"
+  #endif
+  #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetVector              __NVIC_SetVector
+  #define NVIC_GetVector              __NVIC_GetVector
+#endif  /* (CMSIS_VECTAB_VIRTUAL) */
+
+#define NVIC_USER_IRQ_OFFSET          16
+
+
+
+/**
+  \brief   Set Priority Grouping
+  \details Sets the priority grouping field using the required unlock sequence.
+           The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field.
+           Only values from 0..7 are used.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]      PriorityGroup  Priority grouping field.
+ */
+__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
+{
+  uint32_t reg_value;
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);             /* only values 0..7 are used          */
+
+  reg_value  =  SCB->AIRCR;                                                   /* read old register configuration    */
+  reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change               */
+  reg_value  =  (reg_value                                   |
+                ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
+                (PriorityGroupTmp << 8U)                      );              /* Insert write key and priorty group */
+  SCB->AIRCR =  reg_value;
+}
+
+
+/**
+  \brief   Get Priority Grouping
+  \details Reads the priority grouping field from the NVIC Interrupt Controller.
+  \return                Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field).
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void)
+{
+  return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos));
+}
+
+
+/**
+  \brief   Enable Interrupt
+  \details Enables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Enable status
+  \details Returns a device specific interrupt enable status from the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt
+  \details Disables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
+  }
+}
+
+
+/**
+  \brief   Get Pending Interrupt
+  \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not pending.
+  \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Pending Interrupt
+  \details Sets the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Clear Pending Interrupt
+  \details Clears the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Active Interrupt
+  \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not active.
+  \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   Get Interrupt Target State
+  \details Reads the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+  \return             1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_GetTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Interrupt Target State
+  \details Sets the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+                      1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_SetTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] |=  ((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)));
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Clear Interrupt Target State
+  \details Clears the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+                      1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_ClearTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] &= ~((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)));
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+
+/**
+  \brief   Set Interrupt Priority
+  \details Sets the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]      IRQn  Interrupt number.
+  \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every processor exception.
+ */
+__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->IPR[((uint32_t)IRQn)]               = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+  else
+  {
+    SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Priority
+  \details Reads the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn  Interrupt number.
+  \return             Interrupt Priority.
+                      Value is aligned automatically to the implemented priority bits of the microcontroller.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn)
+{
+
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return(((uint32_t)NVIC->IPR[((uint32_t)IRQn)]               >> (8U - __NVIC_PRIO_BITS)));
+  }
+  else
+  {
+    return(((uint32_t)SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
+  }
+}
+
+
+/**
+  \brief   Encode Priority
+  \details Encodes the priority for an interrupt with the given priority group,
+           preemptive priority value, and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]     PriorityGroup  Used priority group.
+  \param [in]   PreemptPriority  Preemptive priority value (starting from 0).
+  \param [in]       SubPriority  Subpriority value (starting from 0).
+  \return                        Encoded priority. Value can be used in the function \ref NVIC_SetPriority().
+ */
+__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  return (
+           ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) |
+           ((SubPriority     & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL)))
+         );
+}
+
+
+/**
+  \brief   Decode Priority
+  \details Decodes an interrupt priority value with a given priority group to
+           preemptive priority value and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set.
+  \param [in]         Priority   Priority value, which can be retrieved with the function \ref NVIC_GetPriority().
+  \param [in]     PriorityGroup  Used priority group.
+  \param [out] pPreemptPriority  Preemptive priority value (starting from 0).
+  \param [out]     pSubPriority  Subpriority value (starting from 0).
+ */
+__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL);
+  *pSubPriority     = (Priority                   ) & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL);
+}
+
+
+/**
+  \brief   Set Interrupt Vector
+  \details Sets an interrupt vector in SRAM based interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+           VTOR must been relocated to SRAM before.
+  \param [in]   IRQn      Interrupt number
+  \param [in]   vector    Address of interrupt handler function
+ */
+__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
+{
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+  vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector;
+}
+
+
+/**
+  \brief   Get Interrupt Vector
+  \details Reads an interrupt vector from interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn      Interrupt number.
+  \return                 Address of interrupt handler function
+ */
+__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn)
+{
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+  return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET];
+}
+
+
+/**
+  \brief   System Reset
+  \details Initiates a system reset request to reset the MCU.
+ */
+__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void)
+{
+  __DSB();                                                          /* Ensure all outstanding memory accesses included
+                                                                       buffered write are completed before reset */
+  SCB->AIRCR  = (uint32_t)((0x5FAUL << SCB_AIRCR_VECTKEY_Pos)    |
+                           (SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) |
+                            SCB_AIRCR_SYSRESETREQ_Msk    );         /* Keep priority group unchanged */
+  __DSB();                                                          /* Ensure completion of memory access */
+
+  for(;;)                                                           /* wait until reset */
+  {
+    __NOP();
+  }
+}
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   Set Priority Grouping (non-secure)
+  \details Sets the non-secure priority grouping field when in secure state using the required unlock sequence.
+           The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field.
+           Only values from 0..7 are used.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]      PriorityGroup  Priority grouping field.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPriorityGrouping_NS(uint32_t PriorityGroup)
+{
+  uint32_t reg_value;
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);             /* only values 0..7 are used          */
+
+  reg_value  =  SCB_NS->AIRCR;                                                   /* read old register configuration    */
+  reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk));             /* clear bits to change               */
+  reg_value  =  (reg_value                                   |
+                ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
+                (PriorityGroupTmp << 8U)                      );              /* Insert write key and priorty group */
+  SCB_NS->AIRCR =  reg_value;
+}
+
+
+/**
+  \brief   Get Priority Grouping (non-secure)
+  \details Reads the priority grouping field from the non-secure NVIC when in secure state.
+  \return                Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field).
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPriorityGrouping_NS(void)
+{
+  return ((uint32_t)((SCB_NS->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos));
+}
+
+
+/**
+  \brief   Enable Interrupt (non-secure)
+  \details Enables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_EnableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Enable status (non-secure)
+  \details Returns a device specific interrupt enable status from the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetEnableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt (non-secure)
+  \details Disables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_DisableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Pending Interrupt (non-secure)
+  \details Reads the NVIC pending register in the non-secure NVIC when in secure state and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not pending.
+  \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Pending Interrupt (non-secure)
+  \details Sets the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Clear Pending Interrupt (non-secure)
+  \details Clears the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_ClearPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Active Interrupt (non-secure)
+  \details Reads the active register in non-secure NVIC when in secure state and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not active.
+  \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetActive_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Interrupt Priority (non-secure)
+  \details Sets the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]      IRQn  Interrupt number.
+  \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every non-secure processor exception.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPriority_NS(IRQn_Type IRQn, uint32_t priority)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->IPR[((uint32_t)IRQn)]               = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+  else
+  {
+    SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Priority (non-secure)
+  \details Reads the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn  Interrupt number.
+  \return             Interrupt Priority. Value is aligned automatically to the implemented priority bits of the microcontroller.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPriority_NS(IRQn_Type IRQn)
+{
+
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return(((uint32_t)NVIC_NS->IPR[((uint32_t)IRQn)]               >> (8U - __NVIC_PRIO_BITS)));
+  }
+  else
+  {
+    return(((uint32_t)SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
+  }
+}
+#endif /*  defined (__ARM_FEATURE_CMSE) &&(__ARM_FEATURE_CMSE == 3U) */
+
+/*@} end of CMSIS_Core_NVICFunctions */
+
+/* ##########################  MPU functions  #################################### */
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+
+#include "mpu_armv8.h"
+
+#endif
+
+/* ##########################  FPU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_FpuFunctions FPU Functions
+  \brief    Function that provides FPU type.
+  @{
+ */
+
+/**
+  \brief   get FPU type
+  \details returns the FPU type
+  \returns
+   - \b  0: No FPU
+   - \b  1: Single precision FPU
+   - \b  2: Double + Single precision FPU
+ */
+__STATIC_INLINE uint32_t SCB_GetFPUType(void)
+{
+  uint32_t mvfr0;
+
+  mvfr0 = FPU->MVFR0;
+  if      ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x220U)
+  {
+    return 2U;           /* Double + Single precision FPU */
+  }
+  else if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x020U)
+  {
+    return 1U;           /* Single precision FPU */
+  }
+  else
+  {
+    return 0U;           /* No FPU */
+  }
+}
+
+
+/*@} end of CMSIS_Core_FpuFunctions */
+
+
+
+/* ##########################   SAU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_SAUFunctions SAU Functions
+  \brief    Functions that configure the SAU.
+  @{
+ */
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+
+/**
+  \brief   Enable SAU
+  \details Enables the Security Attribution Unit (SAU).
+ */
+__STATIC_INLINE void TZ_SAU_Enable(void)
+{
+    SAU->CTRL |=  (SAU_CTRL_ENABLE_Msk);
+}
+
+
+
+/**
+  \brief   Disable SAU
+  \details Disables the Security Attribution Unit (SAU).
+ */
+__STATIC_INLINE void TZ_SAU_Disable(void)
+{
+    SAU->CTRL &= ~(SAU_CTRL_ENABLE_Msk);
+}
+
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+/*@} end of CMSIS_Core_SAUFunctions */
+
+
+
+
+/* ##################################    SysTick function  ############################################ */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_SysTickFunctions SysTick Functions
+  \brief    Functions that configure the System.
+  @{
+ */
+
+#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
+
+/**
+  \brief   System Tick Configuration
+  \details Initializes the System Timer and its interrupt, and starts the System Tick Timer.
+           Counter is in free running mode to generate periodic interrupts.
+  \param [in]  ticks  Number of ticks between two interrupts.
+  \return          0  Function succeeded.
+  \return          1  Function failed.
+  \note    When the variable <b>__Vendor_SysTickConfig</b> is set to 1, then the
+           function <b>SysTick_Config</b> is not included. In this case, the file <b><i>device</i>.h</b>
+           must contain a vendor-specific implementation of this function.
+ */
+__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
+{
+  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
+  {
+    return (1UL);                                                   /* Reload value impossible */
+  }
+
+  SysTick->LOAD  = (uint32_t)(ticks - 1UL);                         /* set reload register */
+  NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
+  SysTick->VAL   = 0UL;                                             /* Load the SysTick Counter Value */
+  SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
+                   SysTick_CTRL_TICKINT_Msk   |
+                   SysTick_CTRL_ENABLE_Msk;                         /* Enable SysTick IRQ and SysTick Timer */
+  return (0UL);                                                     /* Function successful */
+}
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   System Tick Configuration (non-secure)
+  \details Initializes the non-secure System Timer and its interrupt when in secure state, and starts the System Tick Timer.
+           Counter is in free running mode to generate periodic interrupts.
+  \param [in]  ticks  Number of ticks between two interrupts.
+  \return          0  Function succeeded.
+  \return          1  Function failed.
+  \note    When the variable <b>__Vendor_SysTickConfig</b> is set to 1, then the
+           function <b>TZ_SysTick_Config_NS</b> is not included. In this case, the file <b><i>device</i>.h</b>
+           must contain a vendor-specific implementation of this function.
+
+ */
+__STATIC_INLINE uint32_t TZ_SysTick_Config_NS(uint32_t ticks)
+{
+  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
+  {
+    return (1UL);                                                         /* Reload value impossible */
+  }
+
+  SysTick_NS->LOAD  = (uint32_t)(ticks - 1UL);                            /* set reload register */
+  TZ_NVIC_SetPriority_NS (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
+  SysTick_NS->VAL   = 0UL;                                                /* Load the SysTick Counter Value */
+  SysTick_NS->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
+                      SysTick_CTRL_TICKINT_Msk   |
+                      SysTick_CTRL_ENABLE_Msk;                            /* Enable SysTick IRQ and SysTick Timer */
+  return (0UL);                                                           /* Function successful */
+}
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+#endif
+
+/*@} end of CMSIS_Core_SysTickFunctions */
+
+
+
+/* ##################################### Debug In/Output function ########################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_core_DebugFunctions ITM Functions
+  \brief    Functions that access the ITM debug interface.
+  @{
+ */
+
+extern volatile int32_t ITM_RxBuffer;                              /*!< External variable to receive characters. */
+#define                 ITM_RXBUFFER_EMPTY  ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */
+
+
+/**
+  \brief   ITM Send Character
+  \details Transmits a character via the ITM channel 0, and
+           \li Just returns when no debugger is connected that has booked the output.
+           \li Is blocking when a debugger is connected, but the previous character sent has not been transmitted.
+  \param [in]     ch  Character to transmit.
+  \returns            Character to transmit.
+ */
+__STATIC_INLINE uint32_t ITM_SendChar (uint32_t ch)
+{
+  if (((ITM->TCR & ITM_TCR_ITMENA_Msk) != 0UL) &&      /* ITM enabled */
+      ((ITM->TER & 1UL               ) != 0UL)   )     /* ITM Port #0 enabled */
+  {
+    while (ITM->PORT[0U].u32 == 0UL)
+    {
+      __NOP();
+    }
+    ITM->PORT[0U].u8 = (uint8_t)ch;
+  }
+  return (ch);
+}
+
+
+/**
+  \brief   ITM Receive Character
+  \details Inputs a character via the external variable \ref ITM_RxBuffer.
+  \return             Received character.
+  \return         -1  No character pending.
+ */
+__STATIC_INLINE int32_t ITM_ReceiveChar (void)
+{
+  int32_t ch = -1;                           /* no character available */
+
+  if (ITM_RxBuffer != ITM_RXBUFFER_EMPTY)
+  {
+    ch = ITM_RxBuffer;
+    ITM_RxBuffer = ITM_RXBUFFER_EMPTY;       /* ready for next character */
+  }
+
+  return (ch);
+}
+
+
+/**
+  \brief   ITM Check Character
+  \details Checks whether a character is pending for reading in the variable \ref ITM_RxBuffer.
+  \return          0  No character available.
+  \return          1  Character available.
+ */
+__STATIC_INLINE int32_t ITM_CheckChar (void)
+{
+
+  if (ITM_RxBuffer == ITM_RXBUFFER_EMPTY)
+  {
+    return (0);                              /* no character available */
+  }
+  else
+  {
+    return (1);                              /*    character available */
+  }
+}
+
+/*@} end of CMSIS_core_DebugFunctions */
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CORE_ARMV81MML_H_DEPENDANT */
+
+#endif /* __CMSIS_GENERIC */
diff --git a/lib/cmsis/inc/core_armv8mbl.h b/lib/cmsis/inc/core_armv8mbl.h
new file mode 100644
index 0000000000000..57d9f663fd3ed
--- /dev/null
+++ b/lib/cmsis/inc/core_armv8mbl.h
@@ -0,0 +1,1918 @@
+/**************************************************************************//**
+ * @file     core_armv8mbl.h
+ * @brief    CMSIS Armv8-M Baseline Core Peripheral Access Layer Header File
+ * @version  V5.0.8
+ * @date     12. November 2018
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2018 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if   defined ( __ICCARM__ )
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
+  #pragma clang system_header   /* treat file as system include file */
+#endif
+
+#ifndef __CORE_ARMV8MBL_H_GENERIC
+#define __CORE_ARMV8MBL_H_GENERIC
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/**
+  \page CMSIS_MISRA_Exceptions  MISRA-C:2004 Compliance Exceptions
+  CMSIS violates the following MISRA-C:2004 rules:
+
+   \li Required Rule 8.5, object/function definition in header file.<br>
+     Function definitions in header files are used to allow 'inlining'.
+
+   \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.<br>
+     Unions are used for effective representation of core registers.
+
+   \li Advisory Rule 19.7, Function-like macro defined.<br>
+     Function-like macros are used to allow more efficient code.
+ */
+
+
+/*******************************************************************************
+ *                 CMSIS definitions
+ ******************************************************************************/
+/**
+  \ingroup Cortex_ARMv8MBL
+  @{
+ */
+
+#include "cmsis_version.h"
+
+/*  CMSIS definitions */
+#define __ARMv8MBL_CMSIS_VERSION_MAIN  (__CM_CMSIS_VERSION_MAIN)                   /*!< \deprecated [31:16] CMSIS HAL main version */
+#define __ARMv8MBL_CMSIS_VERSION_SUB   (__CM_CMSIS_VERSION_SUB)                    /*!< \deprecated [15:0]  CMSIS HAL sub version */
+#define __ARMv8MBL_CMSIS_VERSION       ((__ARMv8MBL_CMSIS_VERSION_MAIN << 16U) | \
+                                         __ARMv8MBL_CMSIS_VERSION_SUB           )  /*!< \deprecated CMSIS HAL version number */
+
+#define __CORTEX_M                     ( 2U)                                            /*!< Cortex-M Core */
+
+/** __FPU_USED indicates whether an FPU is used or not.
+    This core does not support an FPU at all
+*/
+#define __FPU_USED       0U
+
+#if defined ( __CC_ARM )
+  #if defined __TARGET_FPU_VFP
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #if defined __ARM_FP
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined ( __GNUC__ )
+  #if defined (__VFP_FP__) && !defined(__SOFTFP__)
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined ( __ICCARM__ )
+  #if defined __ARMVFP__
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined ( __TI_ARM__ )
+  #if defined __TI_VFP_SUPPORT__
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined ( __TASKING__ )
+  #if defined __FPU_VFP__
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined ( __CSMC__ )
+  #if ( __CSMC__ & 0x400U)
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#endif
+
+#include "cmsis_compiler.h"               /* CMSIS compiler specific defines */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CORE_ARMV8MBL_H_GENERIC */
+
+#ifndef __CMSIS_GENERIC
+
+#ifndef __CORE_ARMV8MBL_H_DEPENDANT
+#define __CORE_ARMV8MBL_H_DEPENDANT
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/* check device defines and use defaults */
+#if defined __CHECK_DEVICE_DEFINES
+  #ifndef __ARMv8MBL_REV
+    #define __ARMv8MBL_REV               0x0000U
+    #warning "__ARMv8MBL_REV not defined in device header file; using default!"
+  #endif
+
+  #ifndef __FPU_PRESENT
+    #define __FPU_PRESENT             0U
+    #warning "__FPU_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __MPU_PRESENT
+    #define __MPU_PRESENT             0U
+    #warning "__MPU_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __SAUREGION_PRESENT
+    #define __SAUREGION_PRESENT       0U
+    #warning "__SAUREGION_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __VTOR_PRESENT
+    #define __VTOR_PRESENT            0U
+    #warning "__VTOR_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __NVIC_PRIO_BITS
+    #define __NVIC_PRIO_BITS          2U
+    #warning "__NVIC_PRIO_BITS not defined in device header file; using default!"
+  #endif
+
+  #ifndef __Vendor_SysTickConfig
+    #define __Vendor_SysTickConfig    0U
+    #warning "__Vendor_SysTickConfig not defined in device header file; using default!"
+  #endif
+
+  #ifndef __ETM_PRESENT
+    #define __ETM_PRESENT             0U
+    #warning "__ETM_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __MTB_PRESENT
+    #define __MTB_PRESENT             0U
+    #warning "__MTB_PRESENT not defined in device header file; using default!"
+  #endif
+
+#endif
+
+/* IO definitions (access restrictions to peripheral registers) */
+/**
+    \defgroup CMSIS_glob_defs CMSIS Global Defines
+
+    <strong>IO Type Qualifiers</strong> are used
+    \li to specify the access to peripheral variables.
+    \li for automatic generation of peripheral register debug information.
+*/
+#ifdef __cplusplus
+  #define   __I     volatile             /*!< Defines 'read only' permissions */
+#else
+  #define   __I     volatile const       /*!< Defines 'read only' permissions */
+#endif
+#define     __O     volatile             /*!< Defines 'write only' permissions */
+#define     __IO    volatile             /*!< Defines 'read / write' permissions */
+
+/* following defines should be used for structure members */
+#define     __IM     volatile const      /*! Defines 'read only' structure member permissions */
+#define     __OM     volatile            /*! Defines 'write only' structure member permissions */
+#define     __IOM    volatile            /*! Defines 'read / write' structure member permissions */
+
+/*@} end of group ARMv8MBL */
+
+
+
+/*******************************************************************************
+ *                 Register Abstraction
+  Core Register contain:
+  - Core Register
+  - Core NVIC Register
+  - Core SCB Register
+  - Core SysTick Register
+  - Core Debug Register
+  - Core MPU Register
+  - Core SAU Register
+ ******************************************************************************/
+/**
+  \defgroup CMSIS_core_register Defines and Type Definitions
+  \brief Type definitions and defines for Cortex-M processor based devices.
+*/
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_CORE  Status and Control Registers
+  \brief      Core Register type definitions.
+  @{
+ */
+
+/**
+  \brief  Union type to access the Application Program Status Register (APSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t _reserved0:28;              /*!< bit:  0..27  Reserved */
+    uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
+    uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
+    uint32_t Z:1;                        /*!< bit:     30  Zero condition code flag */
+    uint32_t N:1;                        /*!< bit:     31  Negative condition code flag */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} APSR_Type;
+
+/* APSR Register Definitions */
+#define APSR_N_Pos                         31U                                            /*!< APSR: N Position */
+#define APSR_N_Msk                         (1UL << APSR_N_Pos)                            /*!< APSR: N Mask */
+
+#define APSR_Z_Pos                         30U                                            /*!< APSR: Z Position */
+#define APSR_Z_Msk                         (1UL << APSR_Z_Pos)                            /*!< APSR: Z Mask */
+
+#define APSR_C_Pos                         29U                                            /*!< APSR: C Position */
+#define APSR_C_Msk                         (1UL << APSR_C_Pos)                            /*!< APSR: C Mask */
+
+#define APSR_V_Pos                         28U                                            /*!< APSR: V Position */
+#define APSR_V_Msk                         (1UL << APSR_V_Pos)                            /*!< APSR: V Mask */
+
+
+/**
+  \brief  Union type to access the Interrupt Program Status Register (IPSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
+    uint32_t _reserved0:23;              /*!< bit:  9..31  Reserved */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} IPSR_Type;
+
+/* IPSR Register Definitions */
+#define IPSR_ISR_Pos                        0U                                            /*!< IPSR: ISR Position */
+#define IPSR_ISR_Msk                       (0x1FFUL /*<< IPSR_ISR_Pos*/)                  /*!< IPSR: ISR Mask */
+
+
+/**
+  \brief  Union type to access the Special-Purpose Program Status Registers (xPSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
+    uint32_t _reserved0:15;              /*!< bit:  9..23  Reserved */
+    uint32_t T:1;                        /*!< bit:     24  Thumb bit        (read 0) */
+    uint32_t _reserved1:3;               /*!< bit: 25..27  Reserved */
+    uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
+    uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
+    uint32_t Z:1;                        /*!< bit:     30  Zero condition code flag */
+    uint32_t N:1;                        /*!< bit:     31  Negative condition code flag */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} xPSR_Type;
+
+/* xPSR Register Definitions */
+#define xPSR_N_Pos                         31U                                            /*!< xPSR: N Position */
+#define xPSR_N_Msk                         (1UL << xPSR_N_Pos)                            /*!< xPSR: N Mask */
+
+#define xPSR_Z_Pos                         30U                                            /*!< xPSR: Z Position */
+#define xPSR_Z_Msk                         (1UL << xPSR_Z_Pos)                            /*!< xPSR: Z Mask */
+
+#define xPSR_C_Pos                         29U                                            /*!< xPSR: C Position */
+#define xPSR_C_Msk                         (1UL << xPSR_C_Pos)                            /*!< xPSR: C Mask */
+
+#define xPSR_V_Pos                         28U                                            /*!< xPSR: V Position */
+#define xPSR_V_Msk                         (1UL << xPSR_V_Pos)                            /*!< xPSR: V Mask */
+
+#define xPSR_T_Pos                         24U                                            /*!< xPSR: T Position */
+#define xPSR_T_Msk                         (1UL << xPSR_T_Pos)                            /*!< xPSR: T Mask */
+
+#define xPSR_ISR_Pos                        0U                                            /*!< xPSR: ISR Position */
+#define xPSR_ISR_Msk                       (0x1FFUL /*<< xPSR_ISR_Pos*/)                  /*!< xPSR: ISR Mask */
+
+
+/**
+  \brief  Union type to access the Control Registers (CONTROL).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t nPRIV:1;                    /*!< bit:      0  Execution privilege in Thread mode */
+    uint32_t SPSEL:1;                    /*!< bit:      1  Stack-pointer select */
+    uint32_t _reserved1:30;              /*!< bit:  2..31  Reserved */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} CONTROL_Type;
+
+/* CONTROL Register Definitions */
+#define CONTROL_SPSEL_Pos                   1U                                            /*!< CONTROL: SPSEL Position */
+#define CONTROL_SPSEL_Msk                  (1UL << CONTROL_SPSEL_Pos)                     /*!< CONTROL: SPSEL Mask */
+
+#define CONTROL_nPRIV_Pos                   0U                                            /*!< CONTROL: nPRIV Position */
+#define CONTROL_nPRIV_Msk                  (1UL /*<< CONTROL_nPRIV_Pos*/)                 /*!< CONTROL: nPRIV Mask */
+
+/*@} end of group CMSIS_CORE */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_NVIC  Nested Vectored Interrupt Controller (NVIC)
+  \brief      Type definitions for the NVIC Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Nested Vectored Interrupt Controller (NVIC).
+ */
+typedef struct
+{
+  __IOM uint32_t ISER[16U];              /*!< Offset: 0x000 (R/W)  Interrupt Set Enable Register */
+        uint32_t RESERVED0[16U];
+  __IOM uint32_t ICER[16U];              /*!< Offset: 0x080 (R/W)  Interrupt Clear Enable Register */
+        uint32_t RSERVED1[16U];
+  __IOM uint32_t ISPR[16U];              /*!< Offset: 0x100 (R/W)  Interrupt Set Pending Register */
+        uint32_t RESERVED2[16U];
+  __IOM uint32_t ICPR[16U];              /*!< Offset: 0x180 (R/W)  Interrupt Clear Pending Register */
+        uint32_t RESERVED3[16U];
+  __IOM uint32_t IABR[16U];              /*!< Offset: 0x200 (R/W)  Interrupt Active bit Register */
+        uint32_t RESERVED4[16U];
+  __IOM uint32_t ITNS[16U];              /*!< Offset: 0x280 (R/W)  Interrupt Non-Secure State Register */
+        uint32_t RESERVED5[16U];
+  __IOM uint32_t IPR[124U];              /*!< Offset: 0x300 (R/W)  Interrupt Priority Register */
+}  NVIC_Type;
+
+/*@} end of group CMSIS_NVIC */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SCB     System Control Block (SCB)
+  \brief    Type definitions for the System Control Block Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Control Block (SCB).
+ */
+typedef struct
+{
+  __IM  uint32_t CPUID;                  /*!< Offset: 0x000 (R/ )  CPUID Base Register */
+  __IOM uint32_t ICSR;                   /*!< Offset: 0x004 (R/W)  Interrupt Control and State Register */
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  __IOM uint32_t VTOR;                   /*!< Offset: 0x008 (R/W)  Vector Table Offset Register */
+#else
+        uint32_t RESERVED0;
+#endif
+  __IOM uint32_t AIRCR;                  /*!< Offset: 0x00C (R/W)  Application Interrupt and Reset Control Register */
+  __IOM uint32_t SCR;                    /*!< Offset: 0x010 (R/W)  System Control Register */
+  __IOM uint32_t CCR;                    /*!< Offset: 0x014 (R/W)  Configuration Control Register */
+        uint32_t RESERVED1;
+  __IOM uint32_t SHPR[2U];               /*!< Offset: 0x01C (R/W)  System Handlers Priority Registers. [0] is RESERVED */
+  __IOM uint32_t SHCSR;                  /*!< Offset: 0x024 (R/W)  System Handler Control and State Register */
+} SCB_Type;
+
+/* SCB CPUID Register Definitions */
+#define SCB_CPUID_IMPLEMENTER_Pos          24U                                            /*!< SCB CPUID: IMPLEMENTER Position */
+#define SCB_CPUID_IMPLEMENTER_Msk          (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos)          /*!< SCB CPUID: IMPLEMENTER Mask */
+
+#define SCB_CPUID_VARIANT_Pos              20U                                            /*!< SCB CPUID: VARIANT Position */
+#define SCB_CPUID_VARIANT_Msk              (0xFUL << SCB_CPUID_VARIANT_Pos)               /*!< SCB CPUID: VARIANT Mask */
+
+#define SCB_CPUID_ARCHITECTURE_Pos         16U                                            /*!< SCB CPUID: ARCHITECTURE Position */
+#define SCB_CPUID_ARCHITECTURE_Msk         (0xFUL << SCB_CPUID_ARCHITECTURE_Pos)          /*!< SCB CPUID: ARCHITECTURE Mask */
+
+#define SCB_CPUID_PARTNO_Pos                4U                                            /*!< SCB CPUID: PARTNO Position */
+#define SCB_CPUID_PARTNO_Msk               (0xFFFUL << SCB_CPUID_PARTNO_Pos)              /*!< SCB CPUID: PARTNO Mask */
+
+#define SCB_CPUID_REVISION_Pos              0U                                            /*!< SCB CPUID: REVISION Position */
+#define SCB_CPUID_REVISION_Msk             (0xFUL /*<< SCB_CPUID_REVISION_Pos*/)          /*!< SCB CPUID: REVISION Mask */
+
+/* SCB Interrupt Control State Register Definitions */
+#define SCB_ICSR_PENDNMISET_Pos            31U                                            /*!< SCB ICSR: PENDNMISET Position */
+#define SCB_ICSR_PENDNMISET_Msk            (1UL << SCB_ICSR_PENDNMISET_Pos)               /*!< SCB ICSR: PENDNMISET Mask */
+
+#define SCB_ICSR_NMIPENDSET_Pos            SCB_ICSR_PENDNMISET_Pos                        /*!< SCB ICSR: NMIPENDSET Position, backward compatibility */
+#define SCB_ICSR_NMIPENDSET_Msk            SCB_ICSR_PENDNMISET_Msk                        /*!< SCB ICSR: NMIPENDSET Mask, backward compatibility */
+
+#define SCB_ICSR_PENDNMICLR_Pos            30U                                            /*!< SCB ICSR: PENDNMICLR Position */
+#define SCB_ICSR_PENDNMICLR_Msk            (1UL << SCB_ICSR_PENDNMICLR_Pos)               /*!< SCB ICSR: PENDNMICLR Mask */
+
+#define SCB_ICSR_PENDSVSET_Pos             28U                                            /*!< SCB ICSR: PENDSVSET Position */
+#define SCB_ICSR_PENDSVSET_Msk             (1UL << SCB_ICSR_PENDSVSET_Pos)                /*!< SCB ICSR: PENDSVSET Mask */
+
+#define SCB_ICSR_PENDSVCLR_Pos             27U                                            /*!< SCB ICSR: PENDSVCLR Position */
+#define SCB_ICSR_PENDSVCLR_Msk             (1UL << SCB_ICSR_PENDSVCLR_Pos)                /*!< SCB ICSR: PENDSVCLR Mask */
+
+#define SCB_ICSR_PENDSTSET_Pos             26U                                            /*!< SCB ICSR: PENDSTSET Position */
+#define SCB_ICSR_PENDSTSET_Msk             (1UL << SCB_ICSR_PENDSTSET_Pos)                /*!< SCB ICSR: PENDSTSET Mask */
+
+#define SCB_ICSR_PENDSTCLR_Pos             25U                                            /*!< SCB ICSR: PENDSTCLR Position */
+#define SCB_ICSR_PENDSTCLR_Msk             (1UL << SCB_ICSR_PENDSTCLR_Pos)                /*!< SCB ICSR: PENDSTCLR Mask */
+
+#define SCB_ICSR_STTNS_Pos                 24U                                            /*!< SCB ICSR: STTNS Position (Security Extension) */
+#define SCB_ICSR_STTNS_Msk                 (1UL << SCB_ICSR_STTNS_Pos)                    /*!< SCB ICSR: STTNS Mask (Security Extension) */
+
+#define SCB_ICSR_ISRPREEMPT_Pos            23U                                            /*!< SCB ICSR: ISRPREEMPT Position */
+#define SCB_ICSR_ISRPREEMPT_Msk            (1UL << SCB_ICSR_ISRPREEMPT_Pos)               /*!< SCB ICSR: ISRPREEMPT Mask */
+
+#define SCB_ICSR_ISRPENDING_Pos            22U                                            /*!< SCB ICSR: ISRPENDING Position */
+#define SCB_ICSR_ISRPENDING_Msk            (1UL << SCB_ICSR_ISRPENDING_Pos)               /*!< SCB ICSR: ISRPENDING Mask */
+
+#define SCB_ICSR_VECTPENDING_Pos           12U                                            /*!< SCB ICSR: VECTPENDING Position */
+#define SCB_ICSR_VECTPENDING_Msk           (0x1FFUL << SCB_ICSR_VECTPENDING_Pos)          /*!< SCB ICSR: VECTPENDING Mask */
+
+#define SCB_ICSR_RETTOBASE_Pos             11U                                            /*!< SCB ICSR: RETTOBASE Position */
+#define SCB_ICSR_RETTOBASE_Msk             (1UL << SCB_ICSR_RETTOBASE_Pos)                /*!< SCB ICSR: RETTOBASE Mask */
+
+#define SCB_ICSR_VECTACTIVE_Pos             0U                                            /*!< SCB ICSR: VECTACTIVE Position */
+#define SCB_ICSR_VECTACTIVE_Msk            (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/)       /*!< SCB ICSR: VECTACTIVE Mask */
+
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+/* SCB Vector Table Offset Register Definitions */
+#define SCB_VTOR_TBLOFF_Pos                 7U                                            /*!< SCB VTOR: TBLOFF Position */
+#define SCB_VTOR_TBLOFF_Msk                (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos)           /*!< SCB VTOR: TBLOFF Mask */
+#endif
+
+/* SCB Application Interrupt and Reset Control Register Definitions */
+#define SCB_AIRCR_VECTKEY_Pos              16U                                            /*!< SCB AIRCR: VECTKEY Position */
+#define SCB_AIRCR_VECTKEY_Msk              (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos)            /*!< SCB AIRCR: VECTKEY Mask */
+
+#define SCB_AIRCR_VECTKEYSTAT_Pos          16U                                            /*!< SCB AIRCR: VECTKEYSTAT Position */
+#define SCB_AIRCR_VECTKEYSTAT_Msk          (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos)        /*!< SCB AIRCR: VECTKEYSTAT Mask */
+
+#define SCB_AIRCR_ENDIANESS_Pos            15U                                            /*!< SCB AIRCR: ENDIANESS Position */
+#define SCB_AIRCR_ENDIANESS_Msk            (1UL << SCB_AIRCR_ENDIANESS_Pos)               /*!< SCB AIRCR: ENDIANESS Mask */
+
+#define SCB_AIRCR_PRIS_Pos                 14U                                            /*!< SCB AIRCR: PRIS Position */
+#define SCB_AIRCR_PRIS_Msk                 (1UL << SCB_AIRCR_PRIS_Pos)                    /*!< SCB AIRCR: PRIS Mask */
+
+#define SCB_AIRCR_BFHFNMINS_Pos            13U                                            /*!< SCB AIRCR: BFHFNMINS Position */
+#define SCB_AIRCR_BFHFNMINS_Msk            (1UL << SCB_AIRCR_BFHFNMINS_Pos)               /*!< SCB AIRCR: BFHFNMINS Mask */
+
+#define SCB_AIRCR_SYSRESETREQS_Pos          3U                                            /*!< SCB AIRCR: SYSRESETREQS Position */
+#define SCB_AIRCR_SYSRESETREQS_Msk         (1UL << SCB_AIRCR_SYSRESETREQS_Pos)            /*!< SCB AIRCR: SYSRESETREQS Mask */
+
+#define SCB_AIRCR_SYSRESETREQ_Pos           2U                                            /*!< SCB AIRCR: SYSRESETREQ Position */
+#define SCB_AIRCR_SYSRESETREQ_Msk          (1UL << SCB_AIRCR_SYSRESETREQ_Pos)             /*!< SCB AIRCR: SYSRESETREQ Mask */
+
+#define SCB_AIRCR_VECTCLRACTIVE_Pos         1U                                            /*!< SCB AIRCR: VECTCLRACTIVE Position */
+#define SCB_AIRCR_VECTCLRACTIVE_Msk        (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos)           /*!< SCB AIRCR: VECTCLRACTIVE Mask */
+
+/* SCB System Control Register Definitions */
+#define SCB_SCR_SEVONPEND_Pos               4U                                            /*!< SCB SCR: SEVONPEND Position */
+#define SCB_SCR_SEVONPEND_Msk              (1UL << SCB_SCR_SEVONPEND_Pos)                 /*!< SCB SCR: SEVONPEND Mask */
+
+#define SCB_SCR_SLEEPDEEPS_Pos              3U                                            /*!< SCB SCR: SLEEPDEEPS Position */
+#define SCB_SCR_SLEEPDEEPS_Msk             (1UL << SCB_SCR_SLEEPDEEPS_Pos)                /*!< SCB SCR: SLEEPDEEPS Mask */
+
+#define SCB_SCR_SLEEPDEEP_Pos               2U                                            /*!< SCB SCR: SLEEPDEEP Position */
+#define SCB_SCR_SLEEPDEEP_Msk              (1UL << SCB_SCR_SLEEPDEEP_Pos)                 /*!< SCB SCR: SLEEPDEEP Mask */
+
+#define SCB_SCR_SLEEPONEXIT_Pos             1U                                            /*!< SCB SCR: SLEEPONEXIT Position */
+#define SCB_SCR_SLEEPONEXIT_Msk            (1UL << SCB_SCR_SLEEPONEXIT_Pos)               /*!< SCB SCR: SLEEPONEXIT Mask */
+
+/* SCB Configuration Control Register Definitions */
+#define SCB_CCR_BP_Pos                     18U                                            /*!< SCB CCR: BP Position */
+#define SCB_CCR_BP_Msk                     (1UL << SCB_CCR_BP_Pos)                        /*!< SCB CCR: BP Mask */
+
+#define SCB_CCR_IC_Pos                     17U                                            /*!< SCB CCR: IC Position */
+#define SCB_CCR_IC_Msk                     (1UL << SCB_CCR_IC_Pos)                        /*!< SCB CCR: IC Mask */
+
+#define SCB_CCR_DC_Pos                     16U                                            /*!< SCB CCR: DC Position */
+#define SCB_CCR_DC_Msk                     (1UL << SCB_CCR_DC_Pos)                        /*!< SCB CCR: DC Mask */
+
+#define SCB_CCR_STKOFHFNMIGN_Pos           10U                                            /*!< SCB CCR: STKOFHFNMIGN Position */
+#define SCB_CCR_STKOFHFNMIGN_Msk           (1UL << SCB_CCR_STKOFHFNMIGN_Pos)              /*!< SCB CCR: STKOFHFNMIGN Mask */
+
+#define SCB_CCR_BFHFNMIGN_Pos               8U                                            /*!< SCB CCR: BFHFNMIGN Position */
+#define SCB_CCR_BFHFNMIGN_Msk              (1UL << SCB_CCR_BFHFNMIGN_Pos)                 /*!< SCB CCR: BFHFNMIGN Mask */
+
+#define SCB_CCR_DIV_0_TRP_Pos               4U                                            /*!< SCB CCR: DIV_0_TRP Position */
+#define SCB_CCR_DIV_0_TRP_Msk              (1UL << SCB_CCR_DIV_0_TRP_Pos)                 /*!< SCB CCR: DIV_0_TRP Mask */
+
+#define SCB_CCR_UNALIGN_TRP_Pos             3U                                            /*!< SCB CCR: UNALIGN_TRP Position */
+#define SCB_CCR_UNALIGN_TRP_Msk            (1UL << SCB_CCR_UNALIGN_TRP_Pos)               /*!< SCB CCR: UNALIGN_TRP Mask */
+
+#define SCB_CCR_USERSETMPEND_Pos            1U                                            /*!< SCB CCR: USERSETMPEND Position */
+#define SCB_CCR_USERSETMPEND_Msk           (1UL << SCB_CCR_USERSETMPEND_Pos)              /*!< SCB CCR: USERSETMPEND Mask */
+
+/* SCB System Handler Control and State Register Definitions */
+#define SCB_SHCSR_HARDFAULTPENDED_Pos      21U                                            /*!< SCB SHCSR: HARDFAULTPENDED Position */
+#define SCB_SHCSR_HARDFAULTPENDED_Msk      (1UL << SCB_SHCSR_HARDFAULTPENDED_Pos)         /*!< SCB SHCSR: HARDFAULTPENDED Mask */
+
+#define SCB_SHCSR_SVCALLPENDED_Pos         15U                                            /*!< SCB SHCSR: SVCALLPENDED Position */
+#define SCB_SHCSR_SVCALLPENDED_Msk         (1UL << SCB_SHCSR_SVCALLPENDED_Pos)            /*!< SCB SHCSR: SVCALLPENDED Mask */
+
+#define SCB_SHCSR_SYSTICKACT_Pos           11U                                            /*!< SCB SHCSR: SYSTICKACT Position */
+#define SCB_SHCSR_SYSTICKACT_Msk           (1UL << SCB_SHCSR_SYSTICKACT_Pos)              /*!< SCB SHCSR: SYSTICKACT Mask */
+
+#define SCB_SHCSR_PENDSVACT_Pos            10U                                            /*!< SCB SHCSR: PENDSVACT Position */
+#define SCB_SHCSR_PENDSVACT_Msk            (1UL << SCB_SHCSR_PENDSVACT_Pos)               /*!< SCB SHCSR: PENDSVACT Mask */
+
+#define SCB_SHCSR_SVCALLACT_Pos             7U                                            /*!< SCB SHCSR: SVCALLACT Position */
+#define SCB_SHCSR_SVCALLACT_Msk            (1UL << SCB_SHCSR_SVCALLACT_Pos)               /*!< SCB SHCSR: SVCALLACT Mask */
+
+#define SCB_SHCSR_NMIACT_Pos                5U                                            /*!< SCB SHCSR: NMIACT Position */
+#define SCB_SHCSR_NMIACT_Msk               (1UL << SCB_SHCSR_NMIACT_Pos)                  /*!< SCB SHCSR: NMIACT Mask */
+
+#define SCB_SHCSR_HARDFAULTACT_Pos          2U                                            /*!< SCB SHCSR: HARDFAULTACT Position */
+#define SCB_SHCSR_HARDFAULTACT_Msk         (1UL << SCB_SHCSR_HARDFAULTACT_Pos)            /*!< SCB SHCSR: HARDFAULTACT Mask */
+
+/*@} end of group CMSIS_SCB */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SysTick     System Tick Timer (SysTick)
+  \brief    Type definitions for the System Timer Registers.
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Timer (SysTick).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  SysTick Control and Status Register */
+  __IOM uint32_t LOAD;                   /*!< Offset: 0x004 (R/W)  SysTick Reload Value Register */
+  __IOM uint32_t VAL;                    /*!< Offset: 0x008 (R/W)  SysTick Current Value Register */
+  __IM  uint32_t CALIB;                  /*!< Offset: 0x00C (R/ )  SysTick Calibration Register */
+} SysTick_Type;
+
+/* SysTick Control / Status Register Definitions */
+#define SysTick_CTRL_COUNTFLAG_Pos         16U                                            /*!< SysTick CTRL: COUNTFLAG Position */
+#define SysTick_CTRL_COUNTFLAG_Msk         (1UL << SysTick_CTRL_COUNTFLAG_Pos)            /*!< SysTick CTRL: COUNTFLAG Mask */
+
+#define SysTick_CTRL_CLKSOURCE_Pos          2U                                            /*!< SysTick CTRL: CLKSOURCE Position */
+#define SysTick_CTRL_CLKSOURCE_Msk         (1UL << SysTick_CTRL_CLKSOURCE_Pos)            /*!< SysTick CTRL: CLKSOURCE Mask */
+
+#define SysTick_CTRL_TICKINT_Pos            1U                                            /*!< SysTick CTRL: TICKINT Position */
+#define SysTick_CTRL_TICKINT_Msk           (1UL << SysTick_CTRL_TICKINT_Pos)              /*!< SysTick CTRL: TICKINT Mask */
+
+#define SysTick_CTRL_ENABLE_Pos             0U                                            /*!< SysTick CTRL: ENABLE Position */
+#define SysTick_CTRL_ENABLE_Msk            (1UL /*<< SysTick_CTRL_ENABLE_Pos*/)           /*!< SysTick CTRL: ENABLE Mask */
+
+/* SysTick Reload Register Definitions */
+#define SysTick_LOAD_RELOAD_Pos             0U                                            /*!< SysTick LOAD: RELOAD Position */
+#define SysTick_LOAD_RELOAD_Msk            (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/)    /*!< SysTick LOAD: RELOAD Mask */
+
+/* SysTick Current Register Definitions */
+#define SysTick_VAL_CURRENT_Pos             0U                                            /*!< SysTick VAL: CURRENT Position */
+#define SysTick_VAL_CURRENT_Msk            (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/)    /*!< SysTick VAL: CURRENT Mask */
+
+/* SysTick Calibration Register Definitions */
+#define SysTick_CALIB_NOREF_Pos            31U                                            /*!< SysTick CALIB: NOREF Position */
+#define SysTick_CALIB_NOREF_Msk            (1UL << SysTick_CALIB_NOREF_Pos)               /*!< SysTick CALIB: NOREF Mask */
+
+#define SysTick_CALIB_SKEW_Pos             30U                                            /*!< SysTick CALIB: SKEW Position */
+#define SysTick_CALIB_SKEW_Msk             (1UL << SysTick_CALIB_SKEW_Pos)                /*!< SysTick CALIB: SKEW Mask */
+
+#define SysTick_CALIB_TENMS_Pos             0U                                            /*!< SysTick CALIB: TENMS Position */
+#define SysTick_CALIB_TENMS_Msk            (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/)    /*!< SysTick CALIB: TENMS Mask */
+
+/*@} end of group CMSIS_SysTick */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_DWT     Data Watchpoint and Trace (DWT)
+  \brief    Type definitions for the Data Watchpoint and Trace (DWT)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Data Watchpoint and Trace Register (DWT).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  Control Register */
+        uint32_t RESERVED0[6U];
+  __IM  uint32_t PCSR;                   /*!< Offset: 0x01C (R/ )  Program Counter Sample Register */
+  __IOM uint32_t COMP0;                  /*!< Offset: 0x020 (R/W)  Comparator Register 0 */
+        uint32_t RESERVED1[1U];
+  __IOM uint32_t FUNCTION0;              /*!< Offset: 0x028 (R/W)  Function Register 0 */
+        uint32_t RESERVED2[1U];
+  __IOM uint32_t COMP1;                  /*!< Offset: 0x030 (R/W)  Comparator Register 1 */
+        uint32_t RESERVED3[1U];
+  __IOM uint32_t FUNCTION1;              /*!< Offset: 0x038 (R/W)  Function Register 1 */
+        uint32_t RESERVED4[1U];
+  __IOM uint32_t COMP2;                  /*!< Offset: 0x040 (R/W)  Comparator Register 2 */
+        uint32_t RESERVED5[1U];
+  __IOM uint32_t FUNCTION2;              /*!< Offset: 0x048 (R/W)  Function Register 2 */
+        uint32_t RESERVED6[1U];
+  __IOM uint32_t COMP3;                  /*!< Offset: 0x050 (R/W)  Comparator Register 3 */
+        uint32_t RESERVED7[1U];
+  __IOM uint32_t FUNCTION3;              /*!< Offset: 0x058 (R/W)  Function Register 3 */
+        uint32_t RESERVED8[1U];
+  __IOM uint32_t COMP4;                  /*!< Offset: 0x060 (R/W)  Comparator Register 4 */
+        uint32_t RESERVED9[1U];
+  __IOM uint32_t FUNCTION4;              /*!< Offset: 0x068 (R/W)  Function Register 4 */
+        uint32_t RESERVED10[1U];
+  __IOM uint32_t COMP5;                  /*!< Offset: 0x070 (R/W)  Comparator Register 5 */
+        uint32_t RESERVED11[1U];
+  __IOM uint32_t FUNCTION5;              /*!< Offset: 0x078 (R/W)  Function Register 5 */
+        uint32_t RESERVED12[1U];
+  __IOM uint32_t COMP6;                  /*!< Offset: 0x080 (R/W)  Comparator Register 6 */
+        uint32_t RESERVED13[1U];
+  __IOM uint32_t FUNCTION6;              /*!< Offset: 0x088 (R/W)  Function Register 6 */
+        uint32_t RESERVED14[1U];
+  __IOM uint32_t COMP7;                  /*!< Offset: 0x090 (R/W)  Comparator Register 7 */
+        uint32_t RESERVED15[1U];
+  __IOM uint32_t FUNCTION7;              /*!< Offset: 0x098 (R/W)  Function Register 7 */
+        uint32_t RESERVED16[1U];
+  __IOM uint32_t COMP8;                  /*!< Offset: 0x0A0 (R/W)  Comparator Register 8 */
+        uint32_t RESERVED17[1U];
+  __IOM uint32_t FUNCTION8;              /*!< Offset: 0x0A8 (R/W)  Function Register 8 */
+        uint32_t RESERVED18[1U];
+  __IOM uint32_t COMP9;                  /*!< Offset: 0x0B0 (R/W)  Comparator Register 9 */
+        uint32_t RESERVED19[1U];
+  __IOM uint32_t FUNCTION9;              /*!< Offset: 0x0B8 (R/W)  Function Register 9 */
+        uint32_t RESERVED20[1U];
+  __IOM uint32_t COMP10;                 /*!< Offset: 0x0C0 (R/W)  Comparator Register 10 */
+        uint32_t RESERVED21[1U];
+  __IOM uint32_t FUNCTION10;             /*!< Offset: 0x0C8 (R/W)  Function Register 10 */
+        uint32_t RESERVED22[1U];
+  __IOM uint32_t COMP11;                 /*!< Offset: 0x0D0 (R/W)  Comparator Register 11 */
+        uint32_t RESERVED23[1U];
+  __IOM uint32_t FUNCTION11;             /*!< Offset: 0x0D8 (R/W)  Function Register 11 */
+        uint32_t RESERVED24[1U];
+  __IOM uint32_t COMP12;                 /*!< Offset: 0x0E0 (R/W)  Comparator Register 12 */
+        uint32_t RESERVED25[1U];
+  __IOM uint32_t FUNCTION12;             /*!< Offset: 0x0E8 (R/W)  Function Register 12 */
+        uint32_t RESERVED26[1U];
+  __IOM uint32_t COMP13;                 /*!< Offset: 0x0F0 (R/W)  Comparator Register 13 */
+        uint32_t RESERVED27[1U];
+  __IOM uint32_t FUNCTION13;             /*!< Offset: 0x0F8 (R/W)  Function Register 13 */
+        uint32_t RESERVED28[1U];
+  __IOM uint32_t COMP14;                 /*!< Offset: 0x100 (R/W)  Comparator Register 14 */
+        uint32_t RESERVED29[1U];
+  __IOM uint32_t FUNCTION14;             /*!< Offset: 0x108 (R/W)  Function Register 14 */
+        uint32_t RESERVED30[1U];
+  __IOM uint32_t COMP15;                 /*!< Offset: 0x110 (R/W)  Comparator Register 15 */
+        uint32_t RESERVED31[1U];
+  __IOM uint32_t FUNCTION15;             /*!< Offset: 0x118 (R/W)  Function Register 15 */
+} DWT_Type;
+
+/* DWT Control Register Definitions */
+#define DWT_CTRL_NUMCOMP_Pos               28U                                         /*!< DWT CTRL: NUMCOMP Position */
+#define DWT_CTRL_NUMCOMP_Msk               (0xFUL << DWT_CTRL_NUMCOMP_Pos)             /*!< DWT CTRL: NUMCOMP Mask */
+
+#define DWT_CTRL_NOTRCPKT_Pos              27U                                         /*!< DWT CTRL: NOTRCPKT Position */
+#define DWT_CTRL_NOTRCPKT_Msk              (0x1UL << DWT_CTRL_NOTRCPKT_Pos)            /*!< DWT CTRL: NOTRCPKT Mask */
+
+#define DWT_CTRL_NOEXTTRIG_Pos             26U                                         /*!< DWT CTRL: NOEXTTRIG Position */
+#define DWT_CTRL_NOEXTTRIG_Msk             (0x1UL << DWT_CTRL_NOEXTTRIG_Pos)           /*!< DWT CTRL: NOEXTTRIG Mask */
+
+#define DWT_CTRL_NOCYCCNT_Pos              25U                                         /*!< DWT CTRL: NOCYCCNT Position */
+#define DWT_CTRL_NOCYCCNT_Msk              (0x1UL << DWT_CTRL_NOCYCCNT_Pos)            /*!< DWT CTRL: NOCYCCNT Mask */
+
+#define DWT_CTRL_NOPRFCNT_Pos              24U                                         /*!< DWT CTRL: NOPRFCNT Position */
+#define DWT_CTRL_NOPRFCNT_Msk              (0x1UL << DWT_CTRL_NOPRFCNT_Pos)            /*!< DWT CTRL: NOPRFCNT Mask */
+
+/* DWT Comparator Function Register Definitions */
+#define DWT_FUNCTION_ID_Pos                27U                                         /*!< DWT FUNCTION: ID Position */
+#define DWT_FUNCTION_ID_Msk                (0x1FUL << DWT_FUNCTION_ID_Pos)             /*!< DWT FUNCTION: ID Mask */
+
+#define DWT_FUNCTION_MATCHED_Pos           24U                                         /*!< DWT FUNCTION: MATCHED Position */
+#define DWT_FUNCTION_MATCHED_Msk           (0x1UL << DWT_FUNCTION_MATCHED_Pos)         /*!< DWT FUNCTION: MATCHED Mask */
+
+#define DWT_FUNCTION_DATAVSIZE_Pos         10U                                         /*!< DWT FUNCTION: DATAVSIZE Position */
+#define DWT_FUNCTION_DATAVSIZE_Msk         (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos)       /*!< DWT FUNCTION: DATAVSIZE Mask */
+
+#define DWT_FUNCTION_ACTION_Pos             4U                                         /*!< DWT FUNCTION: ACTION Position */
+#define DWT_FUNCTION_ACTION_Msk            (0x3UL << DWT_FUNCTION_ACTION_Pos)          /*!< DWT FUNCTION: ACTION Mask */
+
+#define DWT_FUNCTION_MATCH_Pos              0U                                         /*!< DWT FUNCTION: MATCH Position */
+#define DWT_FUNCTION_MATCH_Msk             (0xFUL /*<< DWT_FUNCTION_MATCH_Pos*/)       /*!< DWT FUNCTION: MATCH Mask */
+
+/*@}*/ /* end of group CMSIS_DWT */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_TPI     Trace Port Interface (TPI)
+  \brief    Type definitions for the Trace Port Interface (TPI)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Trace Port Interface Register (TPI).
+ */
+typedef struct
+{
+  __IM  uint32_t SSPSR;                  /*!< Offset: 0x000 (R/ )  Supported Parallel Port Sizes Register */
+  __IOM uint32_t CSPSR;                  /*!< Offset: 0x004 (R/W)  Current Parallel Port Sizes Register */
+        uint32_t RESERVED0[2U];
+  __IOM uint32_t ACPR;                   /*!< Offset: 0x010 (R/W)  Asynchronous Clock Prescaler Register */
+        uint32_t RESERVED1[55U];
+  __IOM uint32_t SPPR;                   /*!< Offset: 0x0F0 (R/W)  Selected Pin Protocol Register */
+        uint32_t RESERVED2[131U];
+  __IM  uint32_t FFSR;                   /*!< Offset: 0x300 (R/ )  Formatter and Flush Status Register */
+  __IOM uint32_t FFCR;                   /*!< Offset: 0x304 (R/W)  Formatter and Flush Control Register */
+  __IOM uint32_t PSCR;                   /*!< Offset: 0x308 (R/W)  Periodic Synchronization Control Register */
+        uint32_t RESERVED3[809U];
+  __OM  uint32_t LAR;                    /*!< Offset: 0xFB0 ( /W)  Software Lock Access Register */
+  __IM  uint32_t LSR;                    /*!< Offset: 0xFB4 (R/ )  Software Lock Status Register */
+        uint32_t RESERVED4[4U];
+  __IM  uint32_t TYPE;                   /*!< Offset: 0xFC8 (R/ )  Device Identifier Register */
+  __IM  uint32_t DEVTYPE;                /*!< Offset: 0xFCC (R/ )  Device Type Register */
+} TPI_Type;
+
+/* TPI Asynchronous Clock Prescaler Register Definitions */
+#define TPI_ACPR_SWOSCALER_Pos              0U                                         /*!< TPI ACPR: SWOSCALER Position */
+#define TPI_ACPR_SWOSCALER_Msk             (0xFFFFUL /*<< TPI_ACPR_SWOSCALER_Pos*/)    /*!< TPI ACPR: SWOSCALER Mask */
+
+/* TPI Selected Pin Protocol Register Definitions */
+#define TPI_SPPR_TXMODE_Pos                 0U                                         /*!< TPI SPPR: TXMODE Position */
+#define TPI_SPPR_TXMODE_Msk                (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/)          /*!< TPI SPPR: TXMODE Mask */
+
+/* TPI Formatter and Flush Status Register Definitions */
+#define TPI_FFSR_FtNonStop_Pos              3U                                         /*!< TPI FFSR: FtNonStop Position */
+#define TPI_FFSR_FtNonStop_Msk             (0x1UL << TPI_FFSR_FtNonStop_Pos)           /*!< TPI FFSR: FtNonStop Mask */
+
+#define TPI_FFSR_TCPresent_Pos              2U                                         /*!< TPI FFSR: TCPresent Position */
+#define TPI_FFSR_TCPresent_Msk             (0x1UL << TPI_FFSR_TCPresent_Pos)           /*!< TPI FFSR: TCPresent Mask */
+
+#define TPI_FFSR_FtStopped_Pos              1U                                         /*!< TPI FFSR: FtStopped Position */
+#define TPI_FFSR_FtStopped_Msk             (0x1UL << TPI_FFSR_FtStopped_Pos)           /*!< TPI FFSR: FtStopped Mask */
+
+#define TPI_FFSR_FlInProg_Pos               0U                                         /*!< TPI FFSR: FlInProg Position */
+#define TPI_FFSR_FlInProg_Msk              (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/)        /*!< TPI FFSR: FlInProg Mask */
+
+/* TPI Formatter and Flush Control Register Definitions */
+#define TPI_FFCR_TrigIn_Pos                 8U                                         /*!< TPI FFCR: TrigIn Position */
+#define TPI_FFCR_TrigIn_Msk                (0x1UL << TPI_FFCR_TrigIn_Pos)              /*!< TPI FFCR: TrigIn Mask */
+
+#define TPI_FFCR_FOnMan_Pos                 6U                                         /*!< TPI FFCR: FOnMan Position */
+#define TPI_FFCR_FOnMan_Msk                (0x1UL << TPI_FFCR_FOnMan_Pos)              /*!< TPI FFCR: FOnMan Mask */
+
+#define TPI_FFCR_EnFCont_Pos                1U                                         /*!< TPI FFCR: EnFCont Position */
+#define TPI_FFCR_EnFCont_Msk               (0x1UL << TPI_FFCR_EnFCont_Pos)             /*!< TPI FFCR: EnFCont Mask */
+
+/* TPI Periodic Synchronization Control Register Definitions */
+#define TPI_PSCR_PSCount_Pos                0U                                         /*!< TPI PSCR: PSCount Position */
+#define TPI_PSCR_PSCount_Msk               (0x1FUL /*<< TPI_PSCR_PSCount_Pos*/)        /*!< TPI PSCR: TPSCount Mask */
+
+/* TPI Software Lock Status Register Definitions */
+#define TPI_LSR_nTT_Pos                     1U                                         /*!< TPI LSR: Not thirty-two bit. Position */
+#define TPI_LSR_nTT_Msk                    (0x1UL << TPI_LSR_nTT_Pos)                  /*!< TPI LSR: Not thirty-two bit. Mask */
+
+#define TPI_LSR_SLK_Pos                     1U                                         /*!< TPI LSR: Software Lock status Position */
+#define TPI_LSR_SLK_Msk                    (0x1UL << TPI_LSR_SLK_Pos)                  /*!< TPI LSR: Software Lock status Mask */
+
+#define TPI_LSR_SLI_Pos                     0U                                         /*!< TPI LSR: Software Lock implemented Position */
+#define TPI_LSR_SLI_Msk                    (0x1UL /*<< TPI_LSR_SLI_Pos*/)              /*!< TPI LSR: Software Lock implemented Mask */
+
+/* TPI DEVID Register Definitions */
+#define TPI_DEVID_NRZVALID_Pos             11U                                         /*!< TPI DEVID: NRZVALID Position */
+#define TPI_DEVID_NRZVALID_Msk             (0x1UL << TPI_DEVID_NRZVALID_Pos)           /*!< TPI DEVID: NRZVALID Mask */
+
+#define TPI_DEVID_MANCVALID_Pos            10U                                         /*!< TPI DEVID: MANCVALID Position */
+#define TPI_DEVID_MANCVALID_Msk            (0x1UL << TPI_DEVID_MANCVALID_Pos)          /*!< TPI DEVID: MANCVALID Mask */
+
+#define TPI_DEVID_PTINVALID_Pos             9U                                         /*!< TPI DEVID: PTINVALID Position */
+#define TPI_DEVID_PTINVALID_Msk            (0x1UL << TPI_DEVID_PTINVALID_Pos)          /*!< TPI DEVID: PTINVALID Mask */
+
+#define TPI_DEVID_FIFOSZ_Pos                6U                                         /*!< TPI DEVID: FIFO depth Position */
+#define TPI_DEVID_FIFOSZ_Msk               (0x7UL << TPI_DEVID_FIFOSZ_Pos)             /*!< TPI DEVID: FIFO depth Mask */
+
+/* TPI DEVTYPE Register Definitions */
+#define TPI_DEVTYPE_SubType_Pos             4U                                         /*!< TPI DEVTYPE: SubType Position */
+#define TPI_DEVTYPE_SubType_Msk            (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/)      /*!< TPI DEVTYPE: SubType Mask */
+
+#define TPI_DEVTYPE_MajorType_Pos           0U                                         /*!< TPI DEVTYPE: MajorType Position */
+#define TPI_DEVTYPE_MajorType_Msk          (0xFUL << TPI_DEVTYPE_MajorType_Pos)        /*!< TPI DEVTYPE: MajorType Mask */
+
+/*@}*/ /* end of group CMSIS_TPI */
+
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_MPU     Memory Protection Unit (MPU)
+  \brief    Type definitions for the Memory Protection Unit (MPU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Memory Protection Unit (MPU).
+ */
+typedef struct
+{
+  __IM  uint32_t TYPE;                   /*!< Offset: 0x000 (R/ )  MPU Type Register */
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x004 (R/W)  MPU Control Register */
+  __IOM uint32_t RNR;                    /*!< Offset: 0x008 (R/W)  MPU Region Number Register */
+  __IOM uint32_t RBAR;                   /*!< Offset: 0x00C (R/W)  MPU Region Base Address Register */
+  __IOM uint32_t RLAR;                   /*!< Offset: 0x010 (R/W)  MPU Region Limit Address Register */
+        uint32_t RESERVED0[7U];
+  union {
+  __IOM uint32_t MAIR[2];
+  struct {
+  __IOM uint32_t MAIR0;                  /*!< Offset: 0x030 (R/W)  MPU Memory Attribute Indirection Register 0 */
+  __IOM uint32_t MAIR1;                  /*!< Offset: 0x034 (R/W)  MPU Memory Attribute Indirection Register 1 */
+  };
+  };
+} MPU_Type;
+
+#define MPU_TYPE_RALIASES                  1U
+
+/* MPU Type Register Definitions */
+#define MPU_TYPE_IREGION_Pos               16U                                            /*!< MPU TYPE: IREGION Position */
+#define MPU_TYPE_IREGION_Msk               (0xFFUL << MPU_TYPE_IREGION_Pos)               /*!< MPU TYPE: IREGION Mask */
+
+#define MPU_TYPE_DREGION_Pos                8U                                            /*!< MPU TYPE: DREGION Position */
+#define MPU_TYPE_DREGION_Msk               (0xFFUL << MPU_TYPE_DREGION_Pos)               /*!< MPU TYPE: DREGION Mask */
+
+#define MPU_TYPE_SEPARATE_Pos               0U                                            /*!< MPU TYPE: SEPARATE Position */
+#define MPU_TYPE_SEPARATE_Msk              (1UL /*<< MPU_TYPE_SEPARATE_Pos*/)             /*!< MPU TYPE: SEPARATE Mask */
+
+/* MPU Control Register Definitions */
+#define MPU_CTRL_PRIVDEFENA_Pos             2U                                            /*!< MPU CTRL: PRIVDEFENA Position */
+#define MPU_CTRL_PRIVDEFENA_Msk            (1UL << MPU_CTRL_PRIVDEFENA_Pos)               /*!< MPU CTRL: PRIVDEFENA Mask */
+
+#define MPU_CTRL_HFNMIENA_Pos               1U                                            /*!< MPU CTRL: HFNMIENA Position */
+#define MPU_CTRL_HFNMIENA_Msk              (1UL << MPU_CTRL_HFNMIENA_Pos)                 /*!< MPU CTRL: HFNMIENA Mask */
+
+#define MPU_CTRL_ENABLE_Pos                 0U                                            /*!< MPU CTRL: ENABLE Position */
+#define MPU_CTRL_ENABLE_Msk                (1UL /*<< MPU_CTRL_ENABLE_Pos*/)               /*!< MPU CTRL: ENABLE Mask */
+
+/* MPU Region Number Register Definitions */
+#define MPU_RNR_REGION_Pos                  0U                                            /*!< MPU RNR: REGION Position */
+#define MPU_RNR_REGION_Msk                 (0xFFUL /*<< MPU_RNR_REGION_Pos*/)             /*!< MPU RNR: REGION Mask */
+
+/* MPU Region Base Address Register Definitions */
+#define MPU_RBAR_BASE_Pos                   5U                                            /*!< MPU RBAR: BASE Position */
+#define MPU_RBAR_BASE_Msk                  (0x7FFFFFFUL << MPU_RBAR_BASE_Pos)             /*!< MPU RBAR: BASE Mask */
+
+#define MPU_RBAR_SH_Pos                     3U                                            /*!< MPU RBAR: SH Position */
+#define MPU_RBAR_SH_Msk                    (0x3UL << MPU_RBAR_SH_Pos)                     /*!< MPU RBAR: SH Mask */
+
+#define MPU_RBAR_AP_Pos                     1U                                            /*!< MPU RBAR: AP Position */
+#define MPU_RBAR_AP_Msk                    (0x3UL << MPU_RBAR_AP_Pos)                     /*!< MPU RBAR: AP Mask */
+
+#define MPU_RBAR_XN_Pos                     0U                                            /*!< MPU RBAR: XN Position */
+#define MPU_RBAR_XN_Msk                    (01UL /*<< MPU_RBAR_XN_Pos*/)                  /*!< MPU RBAR: XN Mask */
+
+/* MPU Region Limit Address Register Definitions */
+#define MPU_RLAR_LIMIT_Pos                  5U                                            /*!< MPU RLAR: LIMIT Position */
+#define MPU_RLAR_LIMIT_Msk                 (0x7FFFFFFUL << MPU_RLAR_LIMIT_Pos)            /*!< MPU RLAR: LIMIT Mask */
+
+#define MPU_RLAR_AttrIndx_Pos               1U                                            /*!< MPU RLAR: AttrIndx Position */
+#define MPU_RLAR_AttrIndx_Msk              (0x7UL << MPU_RLAR_AttrIndx_Pos)               /*!< MPU RLAR: AttrIndx Mask */
+
+#define MPU_RLAR_EN_Pos                     0U                                            /*!< MPU RLAR: EN Position */
+#define MPU_RLAR_EN_Msk                    (1UL /*<< MPU_RLAR_EN_Pos*/)                   /*!< MPU RLAR: EN Mask */
+
+/* MPU Memory Attribute Indirection Register 0 Definitions */
+#define MPU_MAIR0_Attr3_Pos                24U                                            /*!< MPU MAIR0: Attr3 Position */
+#define MPU_MAIR0_Attr3_Msk                (0xFFUL << MPU_MAIR0_Attr3_Pos)                /*!< MPU MAIR0: Attr3 Mask */
+
+#define MPU_MAIR0_Attr2_Pos                16U                                            /*!< MPU MAIR0: Attr2 Position */
+#define MPU_MAIR0_Attr2_Msk                (0xFFUL << MPU_MAIR0_Attr2_Pos)                /*!< MPU MAIR0: Attr2 Mask */
+
+#define MPU_MAIR0_Attr1_Pos                 8U                                            /*!< MPU MAIR0: Attr1 Position */
+#define MPU_MAIR0_Attr1_Msk                (0xFFUL << MPU_MAIR0_Attr1_Pos)                /*!< MPU MAIR0: Attr1 Mask */
+
+#define MPU_MAIR0_Attr0_Pos                 0U                                            /*!< MPU MAIR0: Attr0 Position */
+#define MPU_MAIR0_Attr0_Msk                (0xFFUL /*<< MPU_MAIR0_Attr0_Pos*/)            /*!< MPU MAIR0: Attr0 Mask */
+
+/* MPU Memory Attribute Indirection Register 1 Definitions */
+#define MPU_MAIR1_Attr7_Pos                24U                                            /*!< MPU MAIR1: Attr7 Position */
+#define MPU_MAIR1_Attr7_Msk                (0xFFUL << MPU_MAIR1_Attr7_Pos)                /*!< MPU MAIR1: Attr7 Mask */
+
+#define MPU_MAIR1_Attr6_Pos                16U                                            /*!< MPU MAIR1: Attr6 Position */
+#define MPU_MAIR1_Attr6_Msk                (0xFFUL << MPU_MAIR1_Attr6_Pos)                /*!< MPU MAIR1: Attr6 Mask */
+
+#define MPU_MAIR1_Attr5_Pos                 8U                                            /*!< MPU MAIR1: Attr5 Position */
+#define MPU_MAIR1_Attr5_Msk                (0xFFUL << MPU_MAIR1_Attr5_Pos)                /*!< MPU MAIR1: Attr5 Mask */
+
+#define MPU_MAIR1_Attr4_Pos                 0U                                            /*!< MPU MAIR1: Attr4 Position */
+#define MPU_MAIR1_Attr4_Msk                (0xFFUL /*<< MPU_MAIR1_Attr4_Pos*/)            /*!< MPU MAIR1: Attr4 Mask */
+
+/*@} end of group CMSIS_MPU */
+#endif
+
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SAU     Security Attribution Unit (SAU)
+  \brief    Type definitions for the Security Attribution Unit (SAU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Security Attribution Unit (SAU).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  SAU Control Register */
+  __IM  uint32_t TYPE;                   /*!< Offset: 0x004 (R/ )  SAU Type Register */
+#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U)
+  __IOM uint32_t RNR;                    /*!< Offset: 0x008 (R/W)  SAU Region Number Register */
+  __IOM uint32_t RBAR;                   /*!< Offset: 0x00C (R/W)  SAU Region Base Address Register */
+  __IOM uint32_t RLAR;                   /*!< Offset: 0x010 (R/W)  SAU Region Limit Address Register */
+#endif
+} SAU_Type;
+
+/* SAU Control Register Definitions */
+#define SAU_CTRL_ALLNS_Pos                  1U                                            /*!< SAU CTRL: ALLNS Position */
+#define SAU_CTRL_ALLNS_Msk                 (1UL << SAU_CTRL_ALLNS_Pos)                    /*!< SAU CTRL: ALLNS Mask */
+
+#define SAU_CTRL_ENABLE_Pos                 0U                                            /*!< SAU CTRL: ENABLE Position */
+#define SAU_CTRL_ENABLE_Msk                (1UL /*<< SAU_CTRL_ENABLE_Pos*/)               /*!< SAU CTRL: ENABLE Mask */
+
+/* SAU Type Register Definitions */
+#define SAU_TYPE_SREGION_Pos                0U                                            /*!< SAU TYPE: SREGION Position */
+#define SAU_TYPE_SREGION_Msk               (0xFFUL /*<< SAU_TYPE_SREGION_Pos*/)           /*!< SAU TYPE: SREGION Mask */
+
+#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U)
+/* SAU Region Number Register Definitions */
+#define SAU_RNR_REGION_Pos                  0U                                            /*!< SAU RNR: REGION Position */
+#define SAU_RNR_REGION_Msk                 (0xFFUL /*<< SAU_RNR_REGION_Pos*/)             /*!< SAU RNR: REGION Mask */
+
+/* SAU Region Base Address Register Definitions */
+#define SAU_RBAR_BADDR_Pos                  5U                                            /*!< SAU RBAR: BADDR Position */
+#define SAU_RBAR_BADDR_Msk                 (0x7FFFFFFUL << SAU_RBAR_BADDR_Pos)            /*!< SAU RBAR: BADDR Mask */
+
+/* SAU Region Limit Address Register Definitions */
+#define SAU_RLAR_LADDR_Pos                  5U                                            /*!< SAU RLAR: LADDR Position */
+#define SAU_RLAR_LADDR_Msk                 (0x7FFFFFFUL << SAU_RLAR_LADDR_Pos)            /*!< SAU RLAR: LADDR Mask */
+
+#define SAU_RLAR_NSC_Pos                    1U                                            /*!< SAU RLAR: NSC Position */
+#define SAU_RLAR_NSC_Msk                   (1UL << SAU_RLAR_NSC_Pos)                      /*!< SAU RLAR: NSC Mask */
+
+#define SAU_RLAR_ENABLE_Pos                 0U                                            /*!< SAU RLAR: ENABLE Position */
+#define SAU_RLAR_ENABLE_Msk                (1UL /*<< SAU_RLAR_ENABLE_Pos*/)               /*!< SAU RLAR: ENABLE Mask */
+
+#endif /* defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) */
+
+/*@} end of group CMSIS_SAU */
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_CoreDebug       Core Debug Registers (CoreDebug)
+  \brief    Type definitions for the Core Debug Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Core Debug Register (CoreDebug).
+ */
+typedef struct
+{
+  __IOM uint32_t DHCSR;                  /*!< Offset: 0x000 (R/W)  Debug Halting Control and Status Register */
+  __OM  uint32_t DCRSR;                  /*!< Offset: 0x004 ( /W)  Debug Core Register Selector Register */
+  __IOM uint32_t DCRDR;                  /*!< Offset: 0x008 (R/W)  Debug Core Register Data Register */
+  __IOM uint32_t DEMCR;                  /*!< Offset: 0x00C (R/W)  Debug Exception and Monitor Control Register */
+        uint32_t RESERVED4[1U];
+  __IOM uint32_t DAUTHCTRL;              /*!< Offset: 0x014 (R/W)  Debug Authentication Control Register */
+  __IOM uint32_t DSCSR;                  /*!< Offset: 0x018 (R/W)  Debug Security Control and Status Register */
+} CoreDebug_Type;
+
+/* Debug Halting Control and Status Register Definitions */
+#define CoreDebug_DHCSR_DBGKEY_Pos         16U                                            /*!< CoreDebug DHCSR: DBGKEY Position */
+#define CoreDebug_DHCSR_DBGKEY_Msk         (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos)       /*!< CoreDebug DHCSR: DBGKEY Mask */
+
+#define CoreDebug_DHCSR_S_RESTART_ST_Pos   26U                                            /*!< CoreDebug DHCSR: S_RESTART_ST Position */
+#define CoreDebug_DHCSR_S_RESTART_ST_Msk   (1UL << CoreDebug_DHCSR_S_RESTART_ST_Pos)      /*!< CoreDebug DHCSR: S_RESTART_ST Mask */
+
+#define CoreDebug_DHCSR_S_RESET_ST_Pos     25U                                            /*!< CoreDebug DHCSR: S_RESET_ST Position */
+#define CoreDebug_DHCSR_S_RESET_ST_Msk     (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos)        /*!< CoreDebug DHCSR: S_RESET_ST Mask */
+
+#define CoreDebug_DHCSR_S_RETIRE_ST_Pos    24U                                            /*!< CoreDebug DHCSR: S_RETIRE_ST Position */
+#define CoreDebug_DHCSR_S_RETIRE_ST_Msk    (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos)       /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */
+
+#define CoreDebug_DHCSR_S_LOCKUP_Pos       19U                                            /*!< CoreDebug DHCSR: S_LOCKUP Position */
+#define CoreDebug_DHCSR_S_LOCKUP_Msk       (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos)          /*!< CoreDebug DHCSR: S_LOCKUP Mask */
+
+#define CoreDebug_DHCSR_S_SLEEP_Pos        18U                                            /*!< CoreDebug DHCSR: S_SLEEP Position */
+#define CoreDebug_DHCSR_S_SLEEP_Msk        (1UL << CoreDebug_DHCSR_S_SLEEP_Pos)           /*!< CoreDebug DHCSR: S_SLEEP Mask */
+
+#define CoreDebug_DHCSR_S_HALT_Pos         17U                                            /*!< CoreDebug DHCSR: S_HALT Position */
+#define CoreDebug_DHCSR_S_HALT_Msk         (1UL << CoreDebug_DHCSR_S_HALT_Pos)            /*!< CoreDebug DHCSR: S_HALT Mask */
+
+#define CoreDebug_DHCSR_S_REGRDY_Pos       16U                                            /*!< CoreDebug DHCSR: S_REGRDY Position */
+#define CoreDebug_DHCSR_S_REGRDY_Msk       (1UL << CoreDebug_DHCSR_S_REGRDY_Pos)          /*!< CoreDebug DHCSR: S_REGRDY Mask */
+
+#define CoreDebug_DHCSR_C_MASKINTS_Pos      3U                                            /*!< CoreDebug DHCSR: C_MASKINTS Position */
+#define CoreDebug_DHCSR_C_MASKINTS_Msk     (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos)        /*!< CoreDebug DHCSR: C_MASKINTS Mask */
+
+#define CoreDebug_DHCSR_C_STEP_Pos          2U                                            /*!< CoreDebug DHCSR: C_STEP Position */
+#define CoreDebug_DHCSR_C_STEP_Msk         (1UL << CoreDebug_DHCSR_C_STEP_Pos)            /*!< CoreDebug DHCSR: C_STEP Mask */
+
+#define CoreDebug_DHCSR_C_HALT_Pos          1U                                            /*!< CoreDebug DHCSR: C_HALT Position */
+#define CoreDebug_DHCSR_C_HALT_Msk         (1UL << CoreDebug_DHCSR_C_HALT_Pos)            /*!< CoreDebug DHCSR: C_HALT Mask */
+
+#define CoreDebug_DHCSR_C_DEBUGEN_Pos       0U                                            /*!< CoreDebug DHCSR: C_DEBUGEN Position */
+#define CoreDebug_DHCSR_C_DEBUGEN_Msk      (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/)     /*!< CoreDebug DHCSR: C_DEBUGEN Mask */
+
+/* Debug Core Register Selector Register Definitions */
+#define CoreDebug_DCRSR_REGWnR_Pos         16U                                            /*!< CoreDebug DCRSR: REGWnR Position */
+#define CoreDebug_DCRSR_REGWnR_Msk         (1UL << CoreDebug_DCRSR_REGWnR_Pos)            /*!< CoreDebug DCRSR: REGWnR Mask */
+
+#define CoreDebug_DCRSR_REGSEL_Pos          0U                                            /*!< CoreDebug DCRSR: REGSEL Position */
+#define CoreDebug_DCRSR_REGSEL_Msk         (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/)     /*!< CoreDebug DCRSR: REGSEL Mask */
+
+/* Debug Exception and Monitor Control Register */
+#define CoreDebug_DEMCR_DWTENA_Pos         24U                                            /*!< CoreDebug DEMCR: DWTENA Position */
+#define CoreDebug_DEMCR_DWTENA_Msk         (1UL << CoreDebug_DEMCR_DWTENA_Pos)            /*!< CoreDebug DEMCR: DWTENA Mask */
+
+#define CoreDebug_DEMCR_VC_HARDERR_Pos     10U                                            /*!< CoreDebug DEMCR: VC_HARDERR Position */
+#define CoreDebug_DEMCR_VC_HARDERR_Msk     (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos)        /*!< CoreDebug DEMCR: VC_HARDERR Mask */
+
+#define CoreDebug_DEMCR_VC_CORERESET_Pos    0U                                            /*!< CoreDebug DEMCR: VC_CORERESET Position */
+#define CoreDebug_DEMCR_VC_CORERESET_Msk   (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/)  /*!< CoreDebug DEMCR: VC_CORERESET Mask */
+
+/* Debug Authentication Control Register Definitions */
+#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos  3U                                            /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Position */
+#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos)    /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Mask */
+
+#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos  2U                                            /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Position */
+#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Msk (1UL << CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos)    /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Mask */
+
+#define CoreDebug_DAUTHCTRL_INTSPIDEN_Pos   1U                                            /*!< CoreDebug DAUTHCTRL: INTSPIDEN Position */
+#define CoreDebug_DAUTHCTRL_INTSPIDEN_Msk  (1UL << CoreDebug_DAUTHCTRL_INTSPIDEN_Pos)     /*!< CoreDebug DAUTHCTRL: INTSPIDEN Mask */
+
+#define CoreDebug_DAUTHCTRL_SPIDENSEL_Pos   0U                                            /*!< CoreDebug DAUTHCTRL: SPIDENSEL Position */
+#define CoreDebug_DAUTHCTRL_SPIDENSEL_Msk  (1UL /*<< CoreDebug_DAUTHCTRL_SPIDENSEL_Pos*/) /*!< CoreDebug DAUTHCTRL: SPIDENSEL Mask */
+
+/* Debug Security Control and Status Register Definitions */
+#define CoreDebug_DSCSR_CDS_Pos            16U                                            /*!< CoreDebug DSCSR: CDS Position */
+#define CoreDebug_DSCSR_CDS_Msk            (1UL << CoreDebug_DSCSR_CDS_Pos)               /*!< CoreDebug DSCSR: CDS Mask */
+
+#define CoreDebug_DSCSR_SBRSEL_Pos          1U                                            /*!< CoreDebug DSCSR: SBRSEL Position */
+#define CoreDebug_DSCSR_SBRSEL_Msk         (1UL << CoreDebug_DSCSR_SBRSEL_Pos)            /*!< CoreDebug DSCSR: SBRSEL Mask */
+
+#define CoreDebug_DSCSR_SBRSELEN_Pos        0U                                            /*!< CoreDebug DSCSR: SBRSELEN Position */
+#define CoreDebug_DSCSR_SBRSELEN_Msk       (1UL /*<< CoreDebug_DSCSR_SBRSELEN_Pos*/)      /*!< CoreDebug DSCSR: SBRSELEN Mask */
+
+/*@} end of group CMSIS_CoreDebug */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_core_bitfield     Core register bit field macros
+  \brief      Macros for use with bit field definitions (xxx_Pos, xxx_Msk).
+  @{
+ */
+
+/**
+  \brief   Mask and shift a bit field value for use in a register bit range.
+  \param[in] field  Name of the register bit field.
+  \param[in] value  Value of the bit field. This parameter is interpreted as an uint32_t type.
+  \return           Masked and shifted value.
+*/
+#define _VAL2FLD(field, value)    (((uint32_t)(value) << field ## _Pos) & field ## _Msk)
+
+/**
+  \brief     Mask and shift a register value to extract a bit filed value.
+  \param[in] field  Name of the register bit field.
+  \param[in] value  Value of register. This parameter is interpreted as an uint32_t type.
+  \return           Masked and shifted bit field value.
+*/
+#define _FLD2VAL(field, value)    (((uint32_t)(value) & field ## _Msk) >> field ## _Pos)
+
+/*@} end of group CMSIS_core_bitfield */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_core_base     Core Definitions
+  \brief      Definitions for base addresses, unions, and structures.
+  @{
+ */
+
+/* Memory mapping of Core Hardware */
+  #define SCS_BASE            (0xE000E000UL)                             /*!< System Control Space Base Address */
+  #define DWT_BASE            (0xE0001000UL)                             /*!< DWT Base Address */
+  #define TPI_BASE            (0xE0040000UL)                             /*!< TPI Base Address */
+  #define CoreDebug_BASE      (0xE000EDF0UL)                             /*!< Core Debug Base Address */
+  #define SysTick_BASE        (SCS_BASE +  0x0010UL)                     /*!< SysTick Base Address */
+  #define NVIC_BASE           (SCS_BASE +  0x0100UL)                     /*!< NVIC Base Address */
+  #define SCB_BASE            (SCS_BASE +  0x0D00UL)                     /*!< System Control Block Base Address */
+
+
+  #define SCB                 ((SCB_Type       *)     SCB_BASE         ) /*!< SCB configuration struct */
+  #define SysTick             ((SysTick_Type   *)     SysTick_BASE     ) /*!< SysTick configuration struct */
+  #define NVIC                ((NVIC_Type      *)     NVIC_BASE        ) /*!< NVIC configuration struct */
+  #define DWT                 ((DWT_Type       *)     DWT_BASE         ) /*!< DWT configuration struct */
+  #define TPI                 ((TPI_Type       *)     TPI_BASE         ) /*!< TPI configuration struct */
+  #define CoreDebug           ((CoreDebug_Type *)     CoreDebug_BASE   ) /*!< Core Debug configuration struct */
+
+  #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+    #define MPU_BASE          (SCS_BASE +  0x0D90UL)                     /*!< Memory Protection Unit */
+    #define MPU               ((MPU_Type       *)     MPU_BASE         ) /*!< Memory Protection Unit */
+  #endif
+
+  #if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+    #define SAU_BASE          (SCS_BASE +  0x0DD0UL)                     /*!< Security Attribution Unit */
+    #define SAU               ((SAU_Type       *)     SAU_BASE         ) /*!< Security Attribution Unit */
+  #endif
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+  #define SCS_BASE_NS         (0xE002E000UL)                             /*!< System Control Space Base Address (non-secure address space) */
+  #define CoreDebug_BASE_NS   (0xE002EDF0UL)                             /*!< Core Debug Base Address           (non-secure address space) */
+  #define SysTick_BASE_NS     (SCS_BASE_NS +  0x0010UL)                  /*!< SysTick Base Address              (non-secure address space) */
+  #define NVIC_BASE_NS        (SCS_BASE_NS +  0x0100UL)                  /*!< NVIC Base Address                 (non-secure address space) */
+  #define SCB_BASE_NS         (SCS_BASE_NS +  0x0D00UL)                  /*!< System Control Block Base Address (non-secure address space) */
+
+  #define SCB_NS              ((SCB_Type       *)     SCB_BASE_NS      ) /*!< SCB configuration struct          (non-secure address space) */
+  #define SysTick_NS          ((SysTick_Type   *)     SysTick_BASE_NS  ) /*!< SysTick configuration struct      (non-secure address space) */
+  #define NVIC_NS             ((NVIC_Type      *)     NVIC_BASE_NS     ) /*!< NVIC configuration struct         (non-secure address space) */
+  #define CoreDebug_NS        ((CoreDebug_Type *)     CoreDebug_BASE_NS) /*!< Core Debug configuration struct   (non-secure address space) */
+
+  #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+    #define MPU_BASE_NS       (SCS_BASE_NS +  0x0D90UL)                  /*!< Memory Protection Unit            (non-secure address space) */
+    #define MPU_NS            ((MPU_Type       *)     MPU_BASE_NS      ) /*!< Memory Protection Unit            (non-secure address space) */
+  #endif
+
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+/*@} */
+
+
+
+/*******************************************************************************
+ *                Hardware Abstraction Layer
+  Core Function Interface contains:
+  - Core NVIC Functions
+  - Core SysTick Functions
+  - Core Register Access Functions
+ ******************************************************************************/
+/**
+  \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference
+*/
+
+
+
+/* ##########################   NVIC functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_NVICFunctions NVIC Functions
+  \brief    Functions that manage interrupts and exceptions via the NVIC.
+  @{
+ */
+
+#ifdef CMSIS_NVIC_VIRTUAL
+  #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
+    #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
+  #endif
+  #include CMSIS_NVIC_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetPriorityGrouping    __NVIC_SetPriorityGrouping
+  #define NVIC_GetPriorityGrouping    __NVIC_GetPriorityGrouping
+  #define NVIC_EnableIRQ              __NVIC_EnableIRQ
+  #define NVIC_GetEnableIRQ           __NVIC_GetEnableIRQ
+  #define NVIC_DisableIRQ             __NVIC_DisableIRQ
+  #define NVIC_GetPendingIRQ          __NVIC_GetPendingIRQ
+  #define NVIC_SetPendingIRQ          __NVIC_SetPendingIRQ
+  #define NVIC_ClearPendingIRQ        __NVIC_ClearPendingIRQ
+  #define NVIC_GetActive              __NVIC_GetActive
+  #define NVIC_SetPriority            __NVIC_SetPriority
+  #define NVIC_GetPriority            __NVIC_GetPriority
+  #define NVIC_SystemReset            __NVIC_SystemReset
+#endif /* CMSIS_NVIC_VIRTUAL */
+
+#ifdef CMSIS_VECTAB_VIRTUAL
+  #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+    #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h"
+  #endif
+  #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetVector              __NVIC_SetVector
+  #define NVIC_GetVector              __NVIC_GetVector
+#endif  /* (CMSIS_VECTAB_VIRTUAL) */
+
+#define NVIC_USER_IRQ_OFFSET          16
+
+
+/* Special LR values for Secure/Non-Secure call handling and exception handling                                               */
+
+/* Function Return Payload (from ARMv8-M Architecture Reference Manual) LR value on entry from Secure BLXNS                   */
+#define FNC_RETURN                 (0xFEFFFFFFUL)     /* bit [0] ignored when processing a branch                             */
+
+/* The following EXC_RETURN mask values are used to evaluate the LR on exception entry */
+#define EXC_RETURN_PREFIX          (0xFF000000UL)     /* bits [31:24] set to indicate an EXC_RETURN value                     */
+#define EXC_RETURN_S               (0x00000040UL)     /* bit [6] stack used to push registers: 0=Non-secure 1=Secure          */
+#define EXC_RETURN_DCRS            (0x00000020UL)     /* bit [5] stacking rules for called registers: 0=skipped 1=saved       */
+#define EXC_RETURN_FTYPE           (0x00000010UL)     /* bit [4] allocate stack for floating-point context: 0=done 1=skipped  */
+#define EXC_RETURN_MODE            (0x00000008UL)     /* bit [3] processor mode for return: 0=Handler mode 1=Thread mode      */
+#define EXC_RETURN_SPSEL           (0x00000004UL)     /* bit [2] stack pointer used to restore context: 0=MSP 1=PSP           */
+#define EXC_RETURN_ES              (0x00000001UL)     /* bit [0] security state exception was taken to: 0=Non-secure 1=Secure */
+
+/* Integrity Signature (from ARMv8-M Architecture Reference Manual) for exception context stacking                            */
+#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)  /* Value for processors with floating-point extension:                  */
+#define EXC_INTEGRITY_SIGNATURE     (0xFEFA125AUL)     /* bit [0] SFTC must match LR bit[4] EXC_RETURN_FTYPE                   */
+#else
+#define EXC_INTEGRITY_SIGNATURE     (0xFEFA125BUL)     /* Value for processors without floating-point extension                */
+#endif
+
+
+/* Interrupt Priorities are WORD accessible only under Armv6-M                  */
+/* The following MACROS handle generation of the register offset and byte masks */
+#define _BIT_SHIFT(IRQn)         (  ((((uint32_t)(int32_t)(IRQn))         )      &  0x03UL) * 8UL)
+#define _SHP_IDX(IRQn)           ( (((((uint32_t)(int32_t)(IRQn)) & 0x0FUL)-8UL) >>    2UL)      )
+#define _IP_IDX(IRQn)            (   (((uint32_t)(int32_t)(IRQn))                >>    2UL)      )
+
+#define __NVIC_SetPriorityGrouping(X) (void)(X)
+#define __NVIC_GetPriorityGrouping()  (0U)
+
+/**
+  \brief   Enable Interrupt
+  \details Enables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Enable status
+  \details Returns a device specific interrupt enable status from the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt
+  \details Disables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
+  }
+}
+
+
+/**
+  \brief   Get Pending Interrupt
+  \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not pending.
+  \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Pending Interrupt
+  \details Sets the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Clear Pending Interrupt
+  \details Clears the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Active Interrupt
+  \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not active.
+  \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   Get Interrupt Target State
+  \details Reads the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+  \return             1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_GetTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Interrupt Target State
+  \details Sets the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+                      1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_SetTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] |=  ((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)));
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Clear Interrupt Target State
+  \details Clears the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+                      1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_ClearTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] &= ~((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)));
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+
+/**
+  \brief   Set Interrupt Priority
+  \details Sets the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]      IRQn  Interrupt number.
+  \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every processor exception.
+ */
+__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->IPR[_IP_IDX(IRQn)]  = ((uint32_t)(NVIC->IPR[_IP_IDX(IRQn)]  & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+       (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
+  }
+  else
+  {
+    SCB->SHPR[_SHP_IDX(IRQn)] = ((uint32_t)(SCB->SHPR[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+       (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Priority
+  \details Reads the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn  Interrupt number.
+  \return             Interrupt Priority.
+                      Value is aligned automatically to the implemented priority bits of the microcontroller.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn)
+{
+
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->IPR[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+  }
+  else
+  {
+    return((uint32_t)(((SCB->SHPR[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+  }
+}
+
+
+/**
+  \brief   Encode Priority
+  \details Encodes the priority for an interrupt with the given priority group,
+           preemptive priority value, and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]     PriorityGroup  Used priority group.
+  \param [in]   PreemptPriority  Preemptive priority value (starting from 0).
+  \param [in]       SubPriority  Subpriority value (starting from 0).
+  \return                        Encoded priority. Value can be used in the function \ref NVIC_SetPriority().
+ */
+__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  return (
+           ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) |
+           ((SubPriority     & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL)))
+         );
+}
+
+
+/**
+  \brief   Decode Priority
+  \details Decodes an interrupt priority value with a given priority group to
+           preemptive priority value and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set.
+  \param [in]         Priority   Priority value, which can be retrieved with the function \ref NVIC_GetPriority().
+  \param [in]     PriorityGroup  Used priority group.
+  \param [out] pPreemptPriority  Preemptive priority value (starting from 0).
+  \param [out]     pSubPriority  Subpriority value (starting from 0).
+ */
+__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL);
+  *pSubPriority     = (Priority                   ) & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL);
+}
+
+
+/**
+  \brief   Set Interrupt Vector
+  \details Sets an interrupt vector in SRAM based interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+           VTOR must been relocated to SRAM before.
+           If VTOR is not present address 0 must be mapped to SRAM.
+  \param [in]   IRQn      Interrupt number
+  \param [in]   vector    Address of interrupt handler function
+ */
+__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
+{
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+#else
+  uint32_t *vectors = (uint32_t *)0x0U;
+#endif
+  vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector;
+}
+
+
+/**
+  \brief   Get Interrupt Vector
+  \details Reads an interrupt vector from interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn      Interrupt number.
+  \return                 Address of interrupt handler function
+ */
+__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn)
+{
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+#else
+  uint32_t *vectors = (uint32_t *)0x0U;
+#endif
+  return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET];
+}
+
+
+/**
+  \brief   System Reset
+  \details Initiates a system reset request to reset the MCU.
+ */
+__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void)
+{
+  __DSB();                                                          /* Ensure all outstanding memory accesses included
+                                                                       buffered write are completed before reset */
+  SCB->AIRCR  = ((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
+                 SCB_AIRCR_SYSRESETREQ_Msk);
+  __DSB();                                                          /* Ensure completion of memory access */
+
+  for(;;)                                                           /* wait until reset */
+  {
+    __NOP();
+  }
+}
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   Enable Interrupt (non-secure)
+  \details Enables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_EnableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Enable status (non-secure)
+  \details Returns a device specific interrupt enable status from the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetEnableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt (non-secure)
+  \details Disables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_DisableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Pending Interrupt (non-secure)
+  \details Reads the NVIC pending register in the non-secure NVIC when in secure state and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not pending.
+  \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Pending Interrupt (non-secure)
+  \details Sets the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Clear Pending Interrupt (non-secure)
+  \details Clears the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_ClearPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Active Interrupt (non-secure)
+  \details Reads the active register in non-secure NVIC when in secure state and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not active.
+  \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetActive_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Interrupt Priority (non-secure)
+  \details Sets the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]      IRQn  Interrupt number.
+  \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every non-secure processor exception.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPriority_NS(IRQn_Type IRQn, uint32_t priority)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->IPR[_IP_IDX(IRQn)]  = ((uint32_t)(NVIC_NS->IPR[_IP_IDX(IRQn)]  & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+       (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
+  }
+  else
+  {
+    SCB_NS->SHPR[_SHP_IDX(IRQn)] = ((uint32_t)(SCB_NS->SHPR[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+       (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Priority (non-secure)
+  \details Reads the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn  Interrupt number.
+  \return             Interrupt Priority. Value is aligned automatically to the implemented priority bits of the microcontroller.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPriority_NS(IRQn_Type IRQn)
+{
+
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->IPR[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+  }
+  else
+  {
+    return((uint32_t)(((SCB_NS->SHPR[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+  }
+}
+#endif /*  defined (__ARM_FEATURE_CMSE) &&(__ARM_FEATURE_CMSE == 3U) */
+
+/*@} end of CMSIS_Core_NVICFunctions */
+
+/* ##########################  MPU functions  #################################### */
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+
+#include "mpu_armv8.h"
+
+#endif
+
+/* ##########################  FPU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_FpuFunctions FPU Functions
+  \brief    Function that provides FPU type.
+  @{
+ */
+
+/**
+  \brief   get FPU type
+  \details returns the FPU type
+  \returns
+   - \b  0: No FPU
+   - \b  1: Single precision FPU
+   - \b  2: Double + Single precision FPU
+ */
+__STATIC_INLINE uint32_t SCB_GetFPUType(void)
+{
+    return 0U;           /* No FPU */
+}
+
+
+/*@} end of CMSIS_Core_FpuFunctions */
+
+
+
+/* ##########################   SAU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_SAUFunctions SAU Functions
+  \brief    Functions that configure the SAU.
+  @{
+ */
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+
+/**
+  \brief   Enable SAU
+  \details Enables the Security Attribution Unit (SAU).
+ */
+__STATIC_INLINE void TZ_SAU_Enable(void)
+{
+    SAU->CTRL |=  (SAU_CTRL_ENABLE_Msk);
+}
+
+
+
+/**
+  \brief   Disable SAU
+  \details Disables the Security Attribution Unit (SAU).
+ */
+__STATIC_INLINE void TZ_SAU_Disable(void)
+{
+    SAU->CTRL &= ~(SAU_CTRL_ENABLE_Msk);
+}
+
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+/*@} end of CMSIS_Core_SAUFunctions */
+
+
+
+
+/* ##################################    SysTick function  ############################################ */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_SysTickFunctions SysTick Functions
+  \brief    Functions that configure the System.
+  @{
+ */
+
+#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
+
+/**
+  \brief   System Tick Configuration
+  \details Initializes the System Timer and its interrupt, and starts the System Tick Timer.
+           Counter is in free running mode to generate periodic interrupts.
+  \param [in]  ticks  Number of ticks between two interrupts.
+  \return          0  Function succeeded.
+  \return          1  Function failed.
+  \note    When the variable <b>__Vendor_SysTickConfig</b> is set to 1, then the
+           function <b>SysTick_Config</b> is not included. In this case, the file <b><i>device</i>.h</b>
+           must contain a vendor-specific implementation of this function.
+ */
+__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
+{
+  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
+  {
+    return (1UL);                                                   /* Reload value impossible */
+  }
+
+  SysTick->LOAD  = (uint32_t)(ticks - 1UL);                         /* set reload register */
+  NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
+  SysTick->VAL   = 0UL;                                             /* Load the SysTick Counter Value */
+  SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
+                   SysTick_CTRL_TICKINT_Msk   |
+                   SysTick_CTRL_ENABLE_Msk;                         /* Enable SysTick IRQ and SysTick Timer */
+  return (0UL);                                                     /* Function successful */
+}
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   System Tick Configuration (non-secure)
+  \details Initializes the non-secure System Timer and its interrupt when in secure state, and starts the System Tick Timer.
+           Counter is in free running mode to generate periodic interrupts.
+  \param [in]  ticks  Number of ticks between two interrupts.
+  \return          0  Function succeeded.
+  \return          1  Function failed.
+  \note    When the variable <b>__Vendor_SysTickConfig</b> is set to 1, then the
+           function <b>TZ_SysTick_Config_NS</b> is not included. In this case, the file <b><i>device</i>.h</b>
+           must contain a vendor-specific implementation of this function.
+
+ */
+__STATIC_INLINE uint32_t TZ_SysTick_Config_NS(uint32_t ticks)
+{
+  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
+  {
+    return (1UL);                                                         /* Reload value impossible */
+  }
+
+  SysTick_NS->LOAD  = (uint32_t)(ticks - 1UL);                            /* set reload register */
+  TZ_NVIC_SetPriority_NS (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
+  SysTick_NS->VAL   = 0UL;                                                /* Load the SysTick Counter Value */
+  SysTick_NS->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
+                      SysTick_CTRL_TICKINT_Msk   |
+                      SysTick_CTRL_ENABLE_Msk;                            /* Enable SysTick IRQ and SysTick Timer */
+  return (0UL);                                                           /* Function successful */
+}
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+#endif
+
+/*@} end of CMSIS_Core_SysTickFunctions */
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CORE_ARMV8MBL_H_DEPENDANT */
+
+#endif /* __CMSIS_GENERIC */
diff --git a/lib/cmsis/inc/core_armv8mml.h b/lib/cmsis/inc/core_armv8mml.h
new file mode 100644
index 0000000000000..30aab58722fc8
--- /dev/null
+++ b/lib/cmsis/inc/core_armv8mml.h
@@ -0,0 +1,2832 @@
+/**************************************************************************//**
+ * @file     core_armv8mml.h
+ * @brief    CMSIS Armv8-M Mainline Core Peripheral Access Layer Header File
+ * @version  V5.1.0
+ * @date     12. September 2018
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2018 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if   defined ( __ICCARM__ )
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
+  #pragma clang system_header   /* treat file as system include file */
+#endif
+
+#ifndef __CORE_ARMV8MML_H_GENERIC
+#define __CORE_ARMV8MML_H_GENERIC
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/**
+  \page CMSIS_MISRA_Exceptions  MISRA-C:2004 Compliance Exceptions
+  CMSIS violates the following MISRA-C:2004 rules:
+
+   \li Required Rule 8.5, object/function definition in header file.<br>
+     Function definitions in header files are used to allow 'inlining'.
+
+   \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.<br>
+     Unions are used for effective representation of core registers.
+
+   \li Advisory Rule 19.7, Function-like macro defined.<br>
+     Function-like macros are used to allow more efficient code.
+ */
+
+
+/*******************************************************************************
+ *                 CMSIS definitions
+ ******************************************************************************/
+/**
+  \ingroup Cortex_ARMv8MML
+  @{
+ */
+
+#include "cmsis_version.h"
+
+/*  CMSIS Armv8MML definitions */
+#define __ARMv8MML_CMSIS_VERSION_MAIN  (__CM_CMSIS_VERSION_MAIN)                   /*!< \deprecated [31:16] CMSIS HAL main version */
+#define __ARMv8MML_CMSIS_VERSION_SUB   (__CM_CMSIS_VERSION_SUB)                    /*!< \deprecated [15:0]  CMSIS HAL sub version */
+#define __ARMv8MML_CMSIS_VERSION       ((__ARMv8MML_CMSIS_VERSION_MAIN << 16U) | \
+                                         __ARMv8MML_CMSIS_VERSION_SUB           )  /*!< \deprecated CMSIS HAL version number */
+
+#define __CORTEX_M                     (81U)                                       /*!< Cortex-M Core */
+
+/** __FPU_USED indicates whether an FPU is used or not.
+    For this, __FPU_PRESENT has to be checked prior to making use of FPU specific registers and functions.
+*/
+#if defined ( __CC_ARM )
+  #if defined __TARGET_FPU_VFP
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+  #if defined(__ARM_FEATURE_DSP)
+    #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #if defined __ARM_FP
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+  #if defined(__ARM_FEATURE_DSP)
+    #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+
+#elif defined ( __GNUC__ )
+  #if defined (__VFP_FP__) && !defined(__SOFTFP__)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+  #if defined(__ARM_FEATURE_DSP)
+    #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+
+#elif defined ( __ICCARM__ )
+  #if defined __ARMVFP__
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+  #if defined(__ARM_FEATURE_DSP)
+    #if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+
+#elif defined ( __TI_ARM__ )
+  #if defined __TI_VFP_SUPPORT__
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+#elif defined ( __TASKING__ )
+  #if defined __FPU_VFP__
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+#elif defined ( __CSMC__ )
+  #if ( __CSMC__ & 0x400U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+#endif
+
+#include "cmsis_compiler.h"               /* CMSIS compiler specific defines */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CORE_ARMV8MML_H_GENERIC */
+
+#ifndef __CMSIS_GENERIC
+
+#ifndef __CORE_ARMV8MML_H_DEPENDANT
+#define __CORE_ARMV8MML_H_DEPENDANT
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/* check device defines and use defaults */
+#if defined __CHECK_DEVICE_DEFINES
+  #ifndef __ARMv8MML_REV
+    #define __ARMv8MML_REV               0x0000U
+    #warning "__ARMv8MML_REV not defined in device header file; using default!"
+  #endif
+
+  #ifndef __FPU_PRESENT
+    #define __FPU_PRESENT             0U
+    #warning "__FPU_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __MPU_PRESENT
+    #define __MPU_PRESENT             0U
+    #warning "__MPU_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __SAUREGION_PRESENT
+    #define __SAUREGION_PRESENT       0U
+    #warning "__SAUREGION_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __DSP_PRESENT
+    #define __DSP_PRESENT             0U
+    #warning "__DSP_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __NVIC_PRIO_BITS
+    #define __NVIC_PRIO_BITS          3U
+    #warning "__NVIC_PRIO_BITS not defined in device header file; using default!"
+  #endif
+
+  #ifndef __Vendor_SysTickConfig
+    #define __Vendor_SysTickConfig    0U
+    #warning "__Vendor_SysTickConfig not defined in device header file; using default!"
+  #endif
+#endif
+
+/* IO definitions (access restrictions to peripheral registers) */
+/**
+    \defgroup CMSIS_glob_defs CMSIS Global Defines
+
+    <strong>IO Type Qualifiers</strong> are used
+    \li to specify the access to peripheral variables.
+    \li for automatic generation of peripheral register debug information.
+*/
+#ifdef __cplusplus
+  #define   __I     volatile             /*!< Defines 'read only' permissions */
+#else
+  #define   __I     volatile const       /*!< Defines 'read only' permissions */
+#endif
+#define     __O     volatile             /*!< Defines 'write only' permissions */
+#define     __IO    volatile             /*!< Defines 'read / write' permissions */
+
+/* following defines should be used for structure members */
+#define     __IM     volatile const      /*! Defines 'read only' structure member permissions */
+#define     __OM     volatile            /*! Defines 'write only' structure member permissions */
+#define     __IOM    volatile            /*! Defines 'read / write' structure member permissions */
+
+/*@} end of group ARMv8MML */
+
+
+
+/*******************************************************************************
+ *                 Register Abstraction
+  Core Register contain:
+  - Core Register
+  - Core NVIC Register
+  - Core SCB Register
+  - Core SysTick Register
+  - Core Debug Register
+  - Core MPU Register
+  - Core SAU Register
+  - Core FPU Register
+ ******************************************************************************/
+/**
+  \defgroup CMSIS_core_register Defines and Type Definitions
+  \brief Type definitions and defines for Cortex-M processor based devices.
+*/
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_CORE  Status and Control Registers
+  \brief      Core Register type definitions.
+  @{
+ */
+
+/**
+  \brief  Union type to access the Application Program Status Register (APSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t _reserved0:16;              /*!< bit:  0..15  Reserved */
+    uint32_t GE:4;                       /*!< bit: 16..19  Greater than or Equal flags */
+    uint32_t _reserved1:7;               /*!< bit: 20..26  Reserved */
+    uint32_t Q:1;                        /*!< bit:     27  Saturation condition flag */
+    uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
+    uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
+    uint32_t Z:1;                        /*!< bit:     30  Zero condition code flag */
+    uint32_t N:1;                        /*!< bit:     31  Negative condition code flag */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} APSR_Type;
+
+/* APSR Register Definitions */
+#define APSR_N_Pos                         31U                                            /*!< APSR: N Position */
+#define APSR_N_Msk                         (1UL << APSR_N_Pos)                            /*!< APSR: N Mask */
+
+#define APSR_Z_Pos                         30U                                            /*!< APSR: Z Position */
+#define APSR_Z_Msk                         (1UL << APSR_Z_Pos)                            /*!< APSR: Z Mask */
+
+#define APSR_C_Pos                         29U                                            /*!< APSR: C Position */
+#define APSR_C_Msk                         (1UL << APSR_C_Pos)                            /*!< APSR: C Mask */
+
+#define APSR_V_Pos                         28U                                            /*!< APSR: V Position */
+#define APSR_V_Msk                         (1UL << APSR_V_Pos)                            /*!< APSR: V Mask */
+
+#define APSR_Q_Pos                         27U                                            /*!< APSR: Q Position */
+#define APSR_Q_Msk                         (1UL << APSR_Q_Pos)                            /*!< APSR: Q Mask */
+
+#define APSR_GE_Pos                        16U                                            /*!< APSR: GE Position */
+#define APSR_GE_Msk                        (0xFUL << APSR_GE_Pos)                         /*!< APSR: GE Mask */
+
+
+/**
+  \brief  Union type to access the Interrupt Program Status Register (IPSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
+    uint32_t _reserved0:23;              /*!< bit:  9..31  Reserved */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} IPSR_Type;
+
+/* IPSR Register Definitions */
+#define IPSR_ISR_Pos                        0U                                            /*!< IPSR: ISR Position */
+#define IPSR_ISR_Msk                       (0x1FFUL /*<< IPSR_ISR_Pos*/)                  /*!< IPSR: ISR Mask */
+
+
+/**
+  \brief  Union type to access the Special-Purpose Program Status Registers (xPSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
+    uint32_t _reserved0:7;               /*!< bit:  9..15  Reserved */
+    uint32_t GE:4;                       /*!< bit: 16..19  Greater than or Equal flags */
+    uint32_t _reserved1:4;               /*!< bit: 20..23  Reserved */
+    uint32_t T:1;                        /*!< bit:     24  Thumb bit        (read 0) */
+    uint32_t IT:2;                       /*!< bit: 25..26  saved IT state   (read 0) */
+    uint32_t Q:1;                        /*!< bit:     27  Saturation condition flag */
+    uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
+    uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
+    uint32_t Z:1;                        /*!< bit:     30  Zero condition code flag */
+    uint32_t N:1;                        /*!< bit:     31  Negative condition code flag */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} xPSR_Type;
+
+/* xPSR Register Definitions */
+#define xPSR_N_Pos                         31U                                            /*!< xPSR: N Position */
+#define xPSR_N_Msk                         (1UL << xPSR_N_Pos)                            /*!< xPSR: N Mask */
+
+#define xPSR_Z_Pos                         30U                                            /*!< xPSR: Z Position */
+#define xPSR_Z_Msk                         (1UL << xPSR_Z_Pos)                            /*!< xPSR: Z Mask */
+
+#define xPSR_C_Pos                         29U                                            /*!< xPSR: C Position */
+#define xPSR_C_Msk                         (1UL << xPSR_C_Pos)                            /*!< xPSR: C Mask */
+
+#define xPSR_V_Pos                         28U                                            /*!< xPSR: V Position */
+#define xPSR_V_Msk                         (1UL << xPSR_V_Pos)                            /*!< xPSR: V Mask */
+
+#define xPSR_Q_Pos                         27U                                            /*!< xPSR: Q Position */
+#define xPSR_Q_Msk                         (1UL << xPSR_Q_Pos)                            /*!< xPSR: Q Mask */
+
+#define xPSR_IT_Pos                        25U                                            /*!< xPSR: IT Position */
+#define xPSR_IT_Msk                        (3UL << xPSR_IT_Pos)                           /*!< xPSR: IT Mask */
+
+#define xPSR_T_Pos                         24U                                            /*!< xPSR: T Position */
+#define xPSR_T_Msk                         (1UL << xPSR_T_Pos)                            /*!< xPSR: T Mask */
+
+#define xPSR_GE_Pos                        16U                                            /*!< xPSR: GE Position */
+#define xPSR_GE_Msk                        (0xFUL << xPSR_GE_Pos)                         /*!< xPSR: GE Mask */
+
+#define xPSR_ISR_Pos                        0U                                            /*!< xPSR: ISR Position */
+#define xPSR_ISR_Msk                       (0x1FFUL /*<< xPSR_ISR_Pos*/)                  /*!< xPSR: ISR Mask */
+
+
+/**
+  \brief  Union type to access the Control Registers (CONTROL).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t nPRIV:1;                    /*!< bit:      0  Execution privilege in Thread mode */
+    uint32_t SPSEL:1;                    /*!< bit:      1  Stack-pointer select */
+    uint32_t FPCA:1;                     /*!< bit:      2  Floating-point context active */
+    uint32_t SFPA:1;                     /*!< bit:      3  Secure floating-point active */
+    uint32_t _reserved1:28;              /*!< bit:  4..31  Reserved */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} CONTROL_Type;
+
+/* CONTROL Register Definitions */
+#define CONTROL_SFPA_Pos                    3U                                            /*!< CONTROL: SFPA Position */
+#define CONTROL_SFPA_Msk                   (1UL << CONTROL_SFPA_Pos)                      /*!< CONTROL: SFPA Mask */
+
+#define CONTROL_FPCA_Pos                    2U                                            /*!< CONTROL: FPCA Position */
+#define CONTROL_FPCA_Msk                   (1UL << CONTROL_FPCA_Pos)                      /*!< CONTROL: FPCA Mask */
+
+#define CONTROL_SPSEL_Pos                   1U                                            /*!< CONTROL: SPSEL Position */
+#define CONTROL_SPSEL_Msk                  (1UL << CONTROL_SPSEL_Pos)                     /*!< CONTROL: SPSEL Mask */
+
+#define CONTROL_nPRIV_Pos                   0U                                            /*!< CONTROL: nPRIV Position */
+#define CONTROL_nPRIV_Msk                  (1UL /*<< CONTROL_nPRIV_Pos*/)                 /*!< CONTROL: nPRIV Mask */
+
+/*@} end of group CMSIS_CORE */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_NVIC  Nested Vectored Interrupt Controller (NVIC)
+  \brief      Type definitions for the NVIC Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Nested Vectored Interrupt Controller (NVIC).
+ */
+typedef struct
+{
+  __IOM uint32_t ISER[16U];              /*!< Offset: 0x000 (R/W)  Interrupt Set Enable Register */
+        uint32_t RESERVED0[16U];
+  __IOM uint32_t ICER[16U];              /*!< Offset: 0x080 (R/W)  Interrupt Clear Enable Register */
+        uint32_t RSERVED1[16U];
+  __IOM uint32_t ISPR[16U];              /*!< Offset: 0x100 (R/W)  Interrupt Set Pending Register */
+        uint32_t RESERVED2[16U];
+  __IOM uint32_t ICPR[16U];              /*!< Offset: 0x180 (R/W)  Interrupt Clear Pending Register */
+        uint32_t RESERVED3[16U];
+  __IOM uint32_t IABR[16U];              /*!< Offset: 0x200 (R/W)  Interrupt Active bit Register */
+        uint32_t RESERVED4[16U];
+  __IOM uint32_t ITNS[16U];              /*!< Offset: 0x280 (R/W)  Interrupt Non-Secure State Register */
+        uint32_t RESERVED5[16U];
+  __IOM uint8_t  IPR[496U];              /*!< Offset: 0x300 (R/W)  Interrupt Priority Register (8Bit wide) */
+        uint32_t RESERVED6[580U];
+  __OM  uint32_t STIR;                   /*!< Offset: 0xE00 ( /W)  Software Trigger Interrupt Register */
+}  NVIC_Type;
+
+/* Software Triggered Interrupt Register Definitions */
+#define NVIC_STIR_INTID_Pos                 0U                                         /*!< STIR: INTLINESNUM Position */
+#define NVIC_STIR_INTID_Msk                (0x1FFUL /*<< NVIC_STIR_INTID_Pos*/)        /*!< STIR: INTLINESNUM Mask */
+
+/*@} end of group CMSIS_NVIC */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SCB     System Control Block (SCB)
+  \brief    Type definitions for the System Control Block Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Control Block (SCB).
+ */
+typedef struct
+{
+  __IM  uint32_t CPUID;                  /*!< Offset: 0x000 (R/ )  CPUID Base Register */
+  __IOM uint32_t ICSR;                   /*!< Offset: 0x004 (R/W)  Interrupt Control and State Register */
+  __IOM uint32_t VTOR;                   /*!< Offset: 0x008 (R/W)  Vector Table Offset Register */
+  __IOM uint32_t AIRCR;                  /*!< Offset: 0x00C (R/W)  Application Interrupt and Reset Control Register */
+  __IOM uint32_t SCR;                    /*!< Offset: 0x010 (R/W)  System Control Register */
+  __IOM uint32_t CCR;                    /*!< Offset: 0x014 (R/W)  Configuration Control Register */
+  __IOM uint8_t  SHPR[12U];              /*!< Offset: 0x018 (R/W)  System Handlers Priority Registers (4-7, 8-11, 12-15) */
+  __IOM uint32_t SHCSR;                  /*!< Offset: 0x024 (R/W)  System Handler Control and State Register */
+  __IOM uint32_t CFSR;                   /*!< Offset: 0x028 (R/W)  Configurable Fault Status Register */
+  __IOM uint32_t HFSR;                   /*!< Offset: 0x02C (R/W)  HardFault Status Register */
+  __IOM uint32_t DFSR;                   /*!< Offset: 0x030 (R/W)  Debug Fault Status Register */
+  __IOM uint32_t MMFAR;                  /*!< Offset: 0x034 (R/W)  MemManage Fault Address Register */
+  __IOM uint32_t BFAR;                   /*!< Offset: 0x038 (R/W)  BusFault Address Register */
+  __IOM uint32_t AFSR;                   /*!< Offset: 0x03C (R/W)  Auxiliary Fault Status Register */
+  __IM  uint32_t ID_PFR[2U];             /*!< Offset: 0x040 (R/ )  Processor Feature Register */
+  __IM  uint32_t ID_DFR;                 /*!< Offset: 0x048 (R/ )  Debug Feature Register */
+  __IM  uint32_t ID_ADR;                 /*!< Offset: 0x04C (R/ )  Auxiliary Feature Register */
+  __IM  uint32_t ID_MMFR[4U];            /*!< Offset: 0x050 (R/ )  Memory Model Feature Register */
+  __IM  uint32_t ID_ISAR[6U];            /*!< Offset: 0x060 (R/ )  Instruction Set Attributes Register */
+  __IM  uint32_t CLIDR;                  /*!< Offset: 0x078 (R/ )  Cache Level ID register */
+  __IM  uint32_t CTR;                    /*!< Offset: 0x07C (R/ )  Cache Type register */
+  __IM  uint32_t CCSIDR;                 /*!< Offset: 0x080 (R/ )  Cache Size ID Register */
+  __IOM uint32_t CSSELR;                 /*!< Offset: 0x084 (R/W)  Cache Size Selection Register */
+  __IOM uint32_t CPACR;                  /*!< Offset: 0x088 (R/W)  Coprocessor Access Control Register */
+  __IOM uint32_t NSACR;                  /*!< Offset: 0x08C (R/W)  Non-Secure Access Control Register */
+        uint32_t RESERVED3[92U];
+  __OM  uint32_t STIR;                   /*!< Offset: 0x200 ( /W)  Software Triggered Interrupt Register */
+        uint32_t RESERVED4[15U];
+  __IM  uint32_t MVFR0;                  /*!< Offset: 0x240 (R/ )  Media and VFP Feature Register 0 */
+  __IM  uint32_t MVFR1;                  /*!< Offset: 0x244 (R/ )  Media and VFP Feature Register 1 */
+  __IM  uint32_t MVFR2;                  /*!< Offset: 0x248 (R/ )  Media and VFP Feature Register 2 */
+        uint32_t RESERVED5[1U];
+  __OM  uint32_t ICIALLU;                /*!< Offset: 0x250 ( /W)  I-Cache Invalidate All to PoU */
+        uint32_t RESERVED6[1U];
+  __OM  uint32_t ICIMVAU;                /*!< Offset: 0x258 ( /W)  I-Cache Invalidate by MVA to PoU */
+  __OM  uint32_t DCIMVAC;                /*!< Offset: 0x25C ( /W)  D-Cache Invalidate by MVA to PoC */
+  __OM  uint32_t DCISW;                  /*!< Offset: 0x260 ( /W)  D-Cache Invalidate by Set-way */
+  __OM  uint32_t DCCMVAU;                /*!< Offset: 0x264 ( /W)  D-Cache Clean by MVA to PoU */
+  __OM  uint32_t DCCMVAC;                /*!< Offset: 0x268 ( /W)  D-Cache Clean by MVA to PoC */
+  __OM  uint32_t DCCSW;                  /*!< Offset: 0x26C ( /W)  D-Cache Clean by Set-way */
+  __OM  uint32_t DCCIMVAC;               /*!< Offset: 0x270 ( /W)  D-Cache Clean and Invalidate by MVA to PoC */
+  __OM  uint32_t DCCISW;                 /*!< Offset: 0x274 ( /W)  D-Cache Clean and Invalidate by Set-way */
+} SCB_Type;
+
+/* SCB CPUID Register Definitions */
+#define SCB_CPUID_IMPLEMENTER_Pos          24U                                            /*!< SCB CPUID: IMPLEMENTER Position */
+#define SCB_CPUID_IMPLEMENTER_Msk          (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos)          /*!< SCB CPUID: IMPLEMENTER Mask */
+
+#define SCB_CPUID_VARIANT_Pos              20U                                            /*!< SCB CPUID: VARIANT Position */
+#define SCB_CPUID_VARIANT_Msk              (0xFUL << SCB_CPUID_VARIANT_Pos)               /*!< SCB CPUID: VARIANT Mask */
+
+#define SCB_CPUID_ARCHITECTURE_Pos         16U                                            /*!< SCB CPUID: ARCHITECTURE Position */
+#define SCB_CPUID_ARCHITECTURE_Msk         (0xFUL << SCB_CPUID_ARCHITECTURE_Pos)          /*!< SCB CPUID: ARCHITECTURE Mask */
+
+#define SCB_CPUID_PARTNO_Pos                4U                                            /*!< SCB CPUID: PARTNO Position */
+#define SCB_CPUID_PARTNO_Msk               (0xFFFUL << SCB_CPUID_PARTNO_Pos)              /*!< SCB CPUID: PARTNO Mask */
+
+#define SCB_CPUID_REVISION_Pos              0U                                            /*!< SCB CPUID: REVISION Position */
+#define SCB_CPUID_REVISION_Msk             (0xFUL /*<< SCB_CPUID_REVISION_Pos*/)          /*!< SCB CPUID: REVISION Mask */
+
+/* SCB Interrupt Control State Register Definitions */
+#define SCB_ICSR_PENDNMISET_Pos            31U                                            /*!< SCB ICSR: PENDNMISET Position */
+#define SCB_ICSR_PENDNMISET_Msk            (1UL << SCB_ICSR_PENDNMISET_Pos)               /*!< SCB ICSR: PENDNMISET Mask */
+
+#define SCB_ICSR_NMIPENDSET_Pos            SCB_ICSR_PENDNMISET_Pos                        /*!< SCB ICSR: NMIPENDSET Position, backward compatibility */
+#define SCB_ICSR_NMIPENDSET_Msk            SCB_ICSR_PENDNMISET_Msk                        /*!< SCB ICSR: NMIPENDSET Mask, backward compatibility */
+
+#define SCB_ICSR_PENDNMICLR_Pos            30U                                            /*!< SCB ICSR: PENDNMICLR Position */
+#define SCB_ICSR_PENDNMICLR_Msk            (1UL << SCB_ICSR_PENDNMICLR_Pos)               /*!< SCB ICSR: PENDNMICLR Mask */
+
+#define SCB_ICSR_PENDSVSET_Pos             28U                                            /*!< SCB ICSR: PENDSVSET Position */
+#define SCB_ICSR_PENDSVSET_Msk             (1UL << SCB_ICSR_PENDSVSET_Pos)                /*!< SCB ICSR: PENDSVSET Mask */
+
+#define SCB_ICSR_PENDSVCLR_Pos             27U                                            /*!< SCB ICSR: PENDSVCLR Position */
+#define SCB_ICSR_PENDSVCLR_Msk             (1UL << SCB_ICSR_PENDSVCLR_Pos)                /*!< SCB ICSR: PENDSVCLR Mask */
+
+#define SCB_ICSR_PENDSTSET_Pos             26U                                            /*!< SCB ICSR: PENDSTSET Position */
+#define SCB_ICSR_PENDSTSET_Msk             (1UL << SCB_ICSR_PENDSTSET_Pos)                /*!< SCB ICSR: PENDSTSET Mask */
+
+#define SCB_ICSR_PENDSTCLR_Pos             25U                                            /*!< SCB ICSR: PENDSTCLR Position */
+#define SCB_ICSR_PENDSTCLR_Msk             (1UL << SCB_ICSR_PENDSTCLR_Pos)                /*!< SCB ICSR: PENDSTCLR Mask */
+
+#define SCB_ICSR_STTNS_Pos                 24U                                            /*!< SCB ICSR: STTNS Position (Security Extension) */
+#define SCB_ICSR_STTNS_Msk                 (1UL << SCB_ICSR_STTNS_Pos)                    /*!< SCB ICSR: STTNS Mask (Security Extension) */
+
+#define SCB_ICSR_ISRPREEMPT_Pos            23U                                            /*!< SCB ICSR: ISRPREEMPT Position */
+#define SCB_ICSR_ISRPREEMPT_Msk            (1UL << SCB_ICSR_ISRPREEMPT_Pos)               /*!< SCB ICSR: ISRPREEMPT Mask */
+
+#define SCB_ICSR_ISRPENDING_Pos            22U                                            /*!< SCB ICSR: ISRPENDING Position */
+#define SCB_ICSR_ISRPENDING_Msk            (1UL << SCB_ICSR_ISRPENDING_Pos)               /*!< SCB ICSR: ISRPENDING Mask */
+
+#define SCB_ICSR_VECTPENDING_Pos           12U                                            /*!< SCB ICSR: VECTPENDING Position */
+#define SCB_ICSR_VECTPENDING_Msk           (0x1FFUL << SCB_ICSR_VECTPENDING_Pos)          /*!< SCB ICSR: VECTPENDING Mask */
+
+#define SCB_ICSR_RETTOBASE_Pos             11U                                            /*!< SCB ICSR: RETTOBASE Position */
+#define SCB_ICSR_RETTOBASE_Msk             (1UL << SCB_ICSR_RETTOBASE_Pos)                /*!< SCB ICSR: RETTOBASE Mask */
+
+#define SCB_ICSR_VECTACTIVE_Pos             0U                                            /*!< SCB ICSR: VECTACTIVE Position */
+#define SCB_ICSR_VECTACTIVE_Msk            (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/)       /*!< SCB ICSR: VECTACTIVE Mask */
+
+/* SCB Vector Table Offset Register Definitions */
+#define SCB_VTOR_TBLOFF_Pos                 7U                                            /*!< SCB VTOR: TBLOFF Position */
+#define SCB_VTOR_TBLOFF_Msk                (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos)           /*!< SCB VTOR: TBLOFF Mask */
+
+/* SCB Application Interrupt and Reset Control Register Definitions */
+#define SCB_AIRCR_VECTKEY_Pos              16U                                            /*!< SCB AIRCR: VECTKEY Position */
+#define SCB_AIRCR_VECTKEY_Msk              (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos)            /*!< SCB AIRCR: VECTKEY Mask */
+
+#define SCB_AIRCR_VECTKEYSTAT_Pos          16U                                            /*!< SCB AIRCR: VECTKEYSTAT Position */
+#define SCB_AIRCR_VECTKEYSTAT_Msk          (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos)        /*!< SCB AIRCR: VECTKEYSTAT Mask */
+
+#define SCB_AIRCR_ENDIANESS_Pos            15U                                            /*!< SCB AIRCR: ENDIANESS Position */
+#define SCB_AIRCR_ENDIANESS_Msk            (1UL << SCB_AIRCR_ENDIANESS_Pos)               /*!< SCB AIRCR: ENDIANESS Mask */
+
+#define SCB_AIRCR_PRIS_Pos                 14U                                            /*!< SCB AIRCR: PRIS Position */
+#define SCB_AIRCR_PRIS_Msk                 (1UL << SCB_AIRCR_PRIS_Pos)                    /*!< SCB AIRCR: PRIS Mask */
+
+#define SCB_AIRCR_BFHFNMINS_Pos            13U                                            /*!< SCB AIRCR: BFHFNMINS Position */
+#define SCB_AIRCR_BFHFNMINS_Msk            (1UL << SCB_AIRCR_BFHFNMINS_Pos)               /*!< SCB AIRCR: BFHFNMINS Mask */
+
+#define SCB_AIRCR_PRIGROUP_Pos              8U                                            /*!< SCB AIRCR: PRIGROUP Position */
+#define SCB_AIRCR_PRIGROUP_Msk             (7UL << SCB_AIRCR_PRIGROUP_Pos)                /*!< SCB AIRCR: PRIGROUP Mask */
+
+#define SCB_AIRCR_SYSRESETREQS_Pos          3U                                            /*!< SCB AIRCR: SYSRESETREQS Position */
+#define SCB_AIRCR_SYSRESETREQS_Msk         (1UL << SCB_AIRCR_SYSRESETREQS_Pos)            /*!< SCB AIRCR: SYSRESETREQS Mask */
+
+#define SCB_AIRCR_SYSRESETREQ_Pos           2U                                            /*!< SCB AIRCR: SYSRESETREQ Position */
+#define SCB_AIRCR_SYSRESETREQ_Msk          (1UL << SCB_AIRCR_SYSRESETREQ_Pos)             /*!< SCB AIRCR: SYSRESETREQ Mask */
+
+#define SCB_AIRCR_VECTCLRACTIVE_Pos         1U                                            /*!< SCB AIRCR: VECTCLRACTIVE Position */
+#define SCB_AIRCR_VECTCLRACTIVE_Msk        (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos)           /*!< SCB AIRCR: VECTCLRACTIVE Mask */
+
+/* SCB System Control Register Definitions */
+#define SCB_SCR_SEVONPEND_Pos               4U                                            /*!< SCB SCR: SEVONPEND Position */
+#define SCB_SCR_SEVONPEND_Msk              (1UL << SCB_SCR_SEVONPEND_Pos)                 /*!< SCB SCR: SEVONPEND Mask */
+
+#define SCB_SCR_SLEEPDEEPS_Pos              3U                                            /*!< SCB SCR: SLEEPDEEPS Position */
+#define SCB_SCR_SLEEPDEEPS_Msk             (1UL << SCB_SCR_SLEEPDEEPS_Pos)                /*!< SCB SCR: SLEEPDEEPS Mask */
+
+#define SCB_SCR_SLEEPDEEP_Pos               2U                                            /*!< SCB SCR: SLEEPDEEP Position */
+#define SCB_SCR_SLEEPDEEP_Msk              (1UL << SCB_SCR_SLEEPDEEP_Pos)                 /*!< SCB SCR: SLEEPDEEP Mask */
+
+#define SCB_SCR_SLEEPONEXIT_Pos             1U                                            /*!< SCB SCR: SLEEPONEXIT Position */
+#define SCB_SCR_SLEEPONEXIT_Msk            (1UL << SCB_SCR_SLEEPONEXIT_Pos)               /*!< SCB SCR: SLEEPONEXIT Mask */
+
+/* SCB Configuration Control Register Definitions */
+#define SCB_CCR_BP_Pos                     18U                                            /*!< SCB CCR: BP Position */
+#define SCB_CCR_BP_Msk                     (1UL << SCB_CCR_BP_Pos)                        /*!< SCB CCR: BP Mask */
+
+#define SCB_CCR_IC_Pos                     17U                                            /*!< SCB CCR: IC Position */
+#define SCB_CCR_IC_Msk                     (1UL << SCB_CCR_IC_Pos)                        /*!< SCB CCR: IC Mask */
+
+#define SCB_CCR_DC_Pos                     16U                                            /*!< SCB CCR: DC Position */
+#define SCB_CCR_DC_Msk                     (1UL << SCB_CCR_DC_Pos)                        /*!< SCB CCR: DC Mask */
+
+#define SCB_CCR_STKOFHFNMIGN_Pos           10U                                            /*!< SCB CCR: STKOFHFNMIGN Position */
+#define SCB_CCR_STKOFHFNMIGN_Msk           (1UL << SCB_CCR_STKOFHFNMIGN_Pos)              /*!< SCB CCR: STKOFHFNMIGN Mask */
+
+#define SCB_CCR_BFHFNMIGN_Pos               8U                                            /*!< SCB CCR: BFHFNMIGN Position */
+#define SCB_CCR_BFHFNMIGN_Msk              (1UL << SCB_CCR_BFHFNMIGN_Pos)                 /*!< SCB CCR: BFHFNMIGN Mask */
+
+#define SCB_CCR_DIV_0_TRP_Pos               4U                                            /*!< SCB CCR: DIV_0_TRP Position */
+#define SCB_CCR_DIV_0_TRP_Msk              (1UL << SCB_CCR_DIV_0_TRP_Pos)                 /*!< SCB CCR: DIV_0_TRP Mask */
+
+#define SCB_CCR_UNALIGN_TRP_Pos             3U                                            /*!< SCB CCR: UNALIGN_TRP Position */
+#define SCB_CCR_UNALIGN_TRP_Msk            (1UL << SCB_CCR_UNALIGN_TRP_Pos)               /*!< SCB CCR: UNALIGN_TRP Mask */
+
+#define SCB_CCR_USERSETMPEND_Pos            1U                                            /*!< SCB CCR: USERSETMPEND Position */
+#define SCB_CCR_USERSETMPEND_Msk           (1UL << SCB_CCR_USERSETMPEND_Pos)              /*!< SCB CCR: USERSETMPEND Mask */
+
+/* SCB System Handler Control and State Register Definitions */
+#define SCB_SHCSR_HARDFAULTPENDED_Pos      21U                                            /*!< SCB SHCSR: HARDFAULTPENDED Position */
+#define SCB_SHCSR_HARDFAULTPENDED_Msk      (1UL << SCB_SHCSR_HARDFAULTPENDED_Pos)         /*!< SCB SHCSR: HARDFAULTPENDED Mask */
+
+#define SCB_SHCSR_SECUREFAULTPENDED_Pos    20U                                            /*!< SCB SHCSR: SECUREFAULTPENDED Position */
+#define SCB_SHCSR_SECUREFAULTPENDED_Msk    (1UL << SCB_SHCSR_SECUREFAULTPENDED_Pos)       /*!< SCB SHCSR: SECUREFAULTPENDED Mask */
+
+#define SCB_SHCSR_SECUREFAULTENA_Pos       19U                                            /*!< SCB SHCSR: SECUREFAULTENA Position */
+#define SCB_SHCSR_SECUREFAULTENA_Msk       (1UL << SCB_SHCSR_SECUREFAULTENA_Pos)          /*!< SCB SHCSR: SECUREFAULTENA Mask */
+
+#define SCB_SHCSR_USGFAULTENA_Pos          18U                                            /*!< SCB SHCSR: USGFAULTENA Position */
+#define SCB_SHCSR_USGFAULTENA_Msk          (1UL << SCB_SHCSR_USGFAULTENA_Pos)             /*!< SCB SHCSR: USGFAULTENA Mask */
+
+#define SCB_SHCSR_BUSFAULTENA_Pos          17U                                            /*!< SCB SHCSR: BUSFAULTENA Position */
+#define SCB_SHCSR_BUSFAULTENA_Msk          (1UL << SCB_SHCSR_BUSFAULTENA_Pos)             /*!< SCB SHCSR: BUSFAULTENA Mask */
+
+#define SCB_SHCSR_MEMFAULTENA_Pos          16U                                            /*!< SCB SHCSR: MEMFAULTENA Position */
+#define SCB_SHCSR_MEMFAULTENA_Msk          (1UL << SCB_SHCSR_MEMFAULTENA_Pos)             /*!< SCB SHCSR: MEMFAULTENA Mask */
+
+#define SCB_SHCSR_SVCALLPENDED_Pos         15U                                            /*!< SCB SHCSR: SVCALLPENDED Position */
+#define SCB_SHCSR_SVCALLPENDED_Msk         (1UL << SCB_SHCSR_SVCALLPENDED_Pos)            /*!< SCB SHCSR: SVCALLPENDED Mask */
+
+#define SCB_SHCSR_BUSFAULTPENDED_Pos       14U                                            /*!< SCB SHCSR: BUSFAULTPENDED Position */
+#define SCB_SHCSR_BUSFAULTPENDED_Msk       (1UL << SCB_SHCSR_BUSFAULTPENDED_Pos)          /*!< SCB SHCSR: BUSFAULTPENDED Mask */
+
+#define SCB_SHCSR_MEMFAULTPENDED_Pos       13U                                            /*!< SCB SHCSR: MEMFAULTPENDED Position */
+#define SCB_SHCSR_MEMFAULTPENDED_Msk       (1UL << SCB_SHCSR_MEMFAULTPENDED_Pos)          /*!< SCB SHCSR: MEMFAULTPENDED Mask */
+
+#define SCB_SHCSR_USGFAULTPENDED_Pos       12U                                            /*!< SCB SHCSR: USGFAULTPENDED Position */
+#define SCB_SHCSR_USGFAULTPENDED_Msk       (1UL << SCB_SHCSR_USGFAULTPENDED_Pos)          /*!< SCB SHCSR: USGFAULTPENDED Mask */
+
+#define SCB_SHCSR_SYSTICKACT_Pos           11U                                            /*!< SCB SHCSR: SYSTICKACT Position */
+#define SCB_SHCSR_SYSTICKACT_Msk           (1UL << SCB_SHCSR_SYSTICKACT_Pos)              /*!< SCB SHCSR: SYSTICKACT Mask */
+
+#define SCB_SHCSR_PENDSVACT_Pos            10U                                            /*!< SCB SHCSR: PENDSVACT Position */
+#define SCB_SHCSR_PENDSVACT_Msk            (1UL << SCB_SHCSR_PENDSVACT_Pos)               /*!< SCB SHCSR: PENDSVACT Mask */
+
+#define SCB_SHCSR_MONITORACT_Pos            8U                                            /*!< SCB SHCSR: MONITORACT Position */
+#define SCB_SHCSR_MONITORACT_Msk           (1UL << SCB_SHCSR_MONITORACT_Pos)              /*!< SCB SHCSR: MONITORACT Mask */
+
+#define SCB_SHCSR_SVCALLACT_Pos             7U                                            /*!< SCB SHCSR: SVCALLACT Position */
+#define SCB_SHCSR_SVCALLACT_Msk            (1UL << SCB_SHCSR_SVCALLACT_Pos)               /*!< SCB SHCSR: SVCALLACT Mask */
+
+#define SCB_SHCSR_NMIACT_Pos                5U                                            /*!< SCB SHCSR: NMIACT Position */
+#define SCB_SHCSR_NMIACT_Msk               (1UL << SCB_SHCSR_NMIACT_Pos)                  /*!< SCB SHCSR: NMIACT Mask */
+
+#define SCB_SHCSR_SECUREFAULTACT_Pos        4U                                            /*!< SCB SHCSR: SECUREFAULTACT Position */
+#define SCB_SHCSR_SECUREFAULTACT_Msk       (1UL << SCB_SHCSR_SECUREFAULTACT_Pos)          /*!< SCB SHCSR: SECUREFAULTACT Mask */
+
+#define SCB_SHCSR_USGFAULTACT_Pos           3U                                            /*!< SCB SHCSR: USGFAULTACT Position */
+#define SCB_SHCSR_USGFAULTACT_Msk          (1UL << SCB_SHCSR_USGFAULTACT_Pos)             /*!< SCB SHCSR: USGFAULTACT Mask */
+
+#define SCB_SHCSR_HARDFAULTACT_Pos          2U                                            /*!< SCB SHCSR: HARDFAULTACT Position */
+#define SCB_SHCSR_HARDFAULTACT_Msk         (1UL << SCB_SHCSR_HARDFAULTACT_Pos)            /*!< SCB SHCSR: HARDFAULTACT Mask */
+
+#define SCB_SHCSR_BUSFAULTACT_Pos           1U                                            /*!< SCB SHCSR: BUSFAULTACT Position */
+#define SCB_SHCSR_BUSFAULTACT_Msk          (1UL << SCB_SHCSR_BUSFAULTACT_Pos)             /*!< SCB SHCSR: BUSFAULTACT Mask */
+
+#define SCB_SHCSR_MEMFAULTACT_Pos           0U                                            /*!< SCB SHCSR: MEMFAULTACT Position */
+#define SCB_SHCSR_MEMFAULTACT_Msk          (1UL /*<< SCB_SHCSR_MEMFAULTACT_Pos*/)         /*!< SCB SHCSR: MEMFAULTACT Mask */
+
+/* SCB Configurable Fault Status Register Definitions */
+#define SCB_CFSR_USGFAULTSR_Pos            16U                                            /*!< SCB CFSR: Usage Fault Status Register Position */
+#define SCB_CFSR_USGFAULTSR_Msk            (0xFFFFUL << SCB_CFSR_USGFAULTSR_Pos)          /*!< SCB CFSR: Usage Fault Status Register Mask */
+
+#define SCB_CFSR_BUSFAULTSR_Pos             8U                                            /*!< SCB CFSR: Bus Fault Status Register Position */
+#define SCB_CFSR_BUSFAULTSR_Msk            (0xFFUL << SCB_CFSR_BUSFAULTSR_Pos)            /*!< SCB CFSR: Bus Fault Status Register Mask */
+
+#define SCB_CFSR_MEMFAULTSR_Pos             0U                                            /*!< SCB CFSR: Memory Manage Fault Status Register Position */
+#define SCB_CFSR_MEMFAULTSR_Msk            (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/)        /*!< SCB CFSR: Memory Manage Fault Status Register Mask */
+
+/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_MMARVALID_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 7U)               /*!< SCB CFSR (MMFSR): MMARVALID Position */
+#define SCB_CFSR_MMARVALID_Msk             (1UL << SCB_CFSR_MMARVALID_Pos)                /*!< SCB CFSR (MMFSR): MMARVALID Mask */
+
+#define SCB_CFSR_MLSPERR_Pos               (SCB_SHCSR_MEMFAULTACT_Pos + 5U)               /*!< SCB CFSR (MMFSR): MLSPERR Position */
+#define SCB_CFSR_MLSPERR_Msk               (1UL << SCB_CFSR_MLSPERR_Pos)                  /*!< SCB CFSR (MMFSR): MLSPERR Mask */
+
+#define SCB_CFSR_MSTKERR_Pos               (SCB_SHCSR_MEMFAULTACT_Pos + 4U)               /*!< SCB CFSR (MMFSR): MSTKERR Position */
+#define SCB_CFSR_MSTKERR_Msk               (1UL << SCB_CFSR_MSTKERR_Pos)                  /*!< SCB CFSR (MMFSR): MSTKERR Mask */
+
+#define SCB_CFSR_MUNSTKERR_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 3U)               /*!< SCB CFSR (MMFSR): MUNSTKERR Position */
+#define SCB_CFSR_MUNSTKERR_Msk             (1UL << SCB_CFSR_MUNSTKERR_Pos)                /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */
+
+#define SCB_CFSR_DACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 1U)               /*!< SCB CFSR (MMFSR): DACCVIOL Position */
+#define SCB_CFSR_DACCVIOL_Msk              (1UL << SCB_CFSR_DACCVIOL_Pos)                 /*!< SCB CFSR (MMFSR): DACCVIOL Mask */
+
+#define SCB_CFSR_IACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 0U)               /*!< SCB CFSR (MMFSR): IACCVIOL Position */
+#define SCB_CFSR_IACCVIOL_Msk              (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/)             /*!< SCB CFSR (MMFSR): IACCVIOL Mask */
+
+/* BusFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_BFARVALID_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 7U)                  /*!< SCB CFSR (BFSR): BFARVALID Position */
+#define SCB_CFSR_BFARVALID_Msk            (1UL << SCB_CFSR_BFARVALID_Pos)                 /*!< SCB CFSR (BFSR): BFARVALID Mask */
+
+#define SCB_CFSR_LSPERR_Pos               (SCB_CFSR_BUSFAULTSR_Pos + 5U)                  /*!< SCB CFSR (BFSR): LSPERR Position */
+#define SCB_CFSR_LSPERR_Msk               (1UL << SCB_CFSR_LSPERR_Pos)                    /*!< SCB CFSR (BFSR): LSPERR Mask */
+
+#define SCB_CFSR_STKERR_Pos               (SCB_CFSR_BUSFAULTSR_Pos + 4U)                  /*!< SCB CFSR (BFSR): STKERR Position */
+#define SCB_CFSR_STKERR_Msk               (1UL << SCB_CFSR_STKERR_Pos)                    /*!< SCB CFSR (BFSR): STKERR Mask */
+
+#define SCB_CFSR_UNSTKERR_Pos             (SCB_CFSR_BUSFAULTSR_Pos + 3U)                  /*!< SCB CFSR (BFSR): UNSTKERR Position */
+#define SCB_CFSR_UNSTKERR_Msk             (1UL << SCB_CFSR_UNSTKERR_Pos)                  /*!< SCB CFSR (BFSR): UNSTKERR Mask */
+
+#define SCB_CFSR_IMPRECISERR_Pos          (SCB_CFSR_BUSFAULTSR_Pos + 2U)                  /*!< SCB CFSR (BFSR): IMPRECISERR Position */
+#define SCB_CFSR_IMPRECISERR_Msk          (1UL << SCB_CFSR_IMPRECISERR_Pos)               /*!< SCB CFSR (BFSR): IMPRECISERR Mask */
+
+#define SCB_CFSR_PRECISERR_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 1U)                  /*!< SCB CFSR (BFSR): PRECISERR Position */
+#define SCB_CFSR_PRECISERR_Msk            (1UL << SCB_CFSR_PRECISERR_Pos)                 /*!< SCB CFSR (BFSR): PRECISERR Mask */
+
+#define SCB_CFSR_IBUSERR_Pos              (SCB_CFSR_BUSFAULTSR_Pos + 0U)                  /*!< SCB CFSR (BFSR): IBUSERR Position */
+#define SCB_CFSR_IBUSERR_Msk              (1UL << SCB_CFSR_IBUSERR_Pos)                   /*!< SCB CFSR (BFSR): IBUSERR Mask */
+
+/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_DIVBYZERO_Pos            (SCB_CFSR_USGFAULTSR_Pos + 9U)                  /*!< SCB CFSR (UFSR): DIVBYZERO Position */
+#define SCB_CFSR_DIVBYZERO_Msk            (1UL << SCB_CFSR_DIVBYZERO_Pos)                 /*!< SCB CFSR (UFSR): DIVBYZERO Mask */
+
+#define SCB_CFSR_UNALIGNED_Pos            (SCB_CFSR_USGFAULTSR_Pos + 8U)                  /*!< SCB CFSR (UFSR): UNALIGNED Position */
+#define SCB_CFSR_UNALIGNED_Msk            (1UL << SCB_CFSR_UNALIGNED_Pos)                 /*!< SCB CFSR (UFSR): UNALIGNED Mask */
+
+#define SCB_CFSR_STKOF_Pos                (SCB_CFSR_USGFAULTSR_Pos + 4U)                  /*!< SCB CFSR (UFSR): STKOF Position */
+#define SCB_CFSR_STKOF_Msk                (1UL << SCB_CFSR_STKOF_Pos)                     /*!< SCB CFSR (UFSR): STKOF Mask */
+
+#define SCB_CFSR_NOCP_Pos                 (SCB_CFSR_USGFAULTSR_Pos + 3U)                  /*!< SCB CFSR (UFSR): NOCP Position */
+#define SCB_CFSR_NOCP_Msk                 (1UL << SCB_CFSR_NOCP_Pos)                      /*!< SCB CFSR (UFSR): NOCP Mask */
+
+#define SCB_CFSR_INVPC_Pos                (SCB_CFSR_USGFAULTSR_Pos + 2U)                  /*!< SCB CFSR (UFSR): INVPC Position */
+#define SCB_CFSR_INVPC_Msk                (1UL << SCB_CFSR_INVPC_Pos)                     /*!< SCB CFSR (UFSR): INVPC Mask */
+
+#define SCB_CFSR_INVSTATE_Pos             (SCB_CFSR_USGFAULTSR_Pos + 1U)                  /*!< SCB CFSR (UFSR): INVSTATE Position */
+#define SCB_CFSR_INVSTATE_Msk             (1UL << SCB_CFSR_INVSTATE_Pos)                  /*!< SCB CFSR (UFSR): INVSTATE Mask */
+
+#define SCB_CFSR_UNDEFINSTR_Pos           (SCB_CFSR_USGFAULTSR_Pos + 0U)                  /*!< SCB CFSR (UFSR): UNDEFINSTR Position */
+#define SCB_CFSR_UNDEFINSTR_Msk           (1UL << SCB_CFSR_UNDEFINSTR_Pos)                /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */
+
+/* SCB Hard Fault Status Register Definitions */
+#define SCB_HFSR_DEBUGEVT_Pos              31U                                            /*!< SCB HFSR: DEBUGEVT Position */
+#define SCB_HFSR_DEBUGEVT_Msk              (1UL << SCB_HFSR_DEBUGEVT_Pos)                 /*!< SCB HFSR: DEBUGEVT Mask */
+
+#define SCB_HFSR_FORCED_Pos                30U                                            /*!< SCB HFSR: FORCED Position */
+#define SCB_HFSR_FORCED_Msk                (1UL << SCB_HFSR_FORCED_Pos)                   /*!< SCB HFSR: FORCED Mask */
+
+#define SCB_HFSR_VECTTBL_Pos                1U                                            /*!< SCB HFSR: VECTTBL Position */
+#define SCB_HFSR_VECTTBL_Msk               (1UL << SCB_HFSR_VECTTBL_Pos)                  /*!< SCB HFSR: VECTTBL Mask */
+
+/* SCB Debug Fault Status Register Definitions */
+#define SCB_DFSR_EXTERNAL_Pos               4U                                            /*!< SCB DFSR: EXTERNAL Position */
+#define SCB_DFSR_EXTERNAL_Msk              (1UL << SCB_DFSR_EXTERNAL_Pos)                 /*!< SCB DFSR: EXTERNAL Mask */
+
+#define SCB_DFSR_VCATCH_Pos                 3U                                            /*!< SCB DFSR: VCATCH Position */
+#define SCB_DFSR_VCATCH_Msk                (1UL << SCB_DFSR_VCATCH_Pos)                   /*!< SCB DFSR: VCATCH Mask */
+
+#define SCB_DFSR_DWTTRAP_Pos                2U                                            /*!< SCB DFSR: DWTTRAP Position */
+#define SCB_DFSR_DWTTRAP_Msk               (1UL << SCB_DFSR_DWTTRAP_Pos)                  /*!< SCB DFSR: DWTTRAP Mask */
+
+#define SCB_DFSR_BKPT_Pos                   1U                                            /*!< SCB DFSR: BKPT Position */
+#define SCB_DFSR_BKPT_Msk                  (1UL << SCB_DFSR_BKPT_Pos)                     /*!< SCB DFSR: BKPT Mask */
+
+#define SCB_DFSR_HALTED_Pos                 0U                                            /*!< SCB DFSR: HALTED Position */
+#define SCB_DFSR_HALTED_Msk                (1UL /*<< SCB_DFSR_HALTED_Pos*/)               /*!< SCB DFSR: HALTED Mask */
+
+/* SCB Non-Secure Access Control Register Definitions */
+#define SCB_NSACR_CP11_Pos                 11U                                            /*!< SCB NSACR: CP11 Position */
+#define SCB_NSACR_CP11_Msk                 (1UL << SCB_NSACR_CP11_Pos)                    /*!< SCB NSACR: CP11 Mask */
+
+#define SCB_NSACR_CP10_Pos                 10U                                            /*!< SCB NSACR: CP10 Position */
+#define SCB_NSACR_CP10_Msk                 (1UL << SCB_NSACR_CP10_Pos)                    /*!< SCB NSACR: CP10 Mask */
+
+#define SCB_NSACR_CPn_Pos                   0U                                            /*!< SCB NSACR: CPn Position */
+#define SCB_NSACR_CPn_Msk                  (1UL /*<< SCB_NSACR_CPn_Pos*/)                 /*!< SCB NSACR: CPn Mask */
+
+/* SCB Cache Level ID Register Definitions */
+#define SCB_CLIDR_LOUU_Pos                 27U                                            /*!< SCB CLIDR: LoUU Position */
+#define SCB_CLIDR_LOUU_Msk                 (7UL << SCB_CLIDR_LOUU_Pos)                    /*!< SCB CLIDR: LoUU Mask */
+
+#define SCB_CLIDR_LOC_Pos                  24U                                            /*!< SCB CLIDR: LoC Position */
+#define SCB_CLIDR_LOC_Msk                  (7UL << SCB_CLIDR_LOC_Pos)                     /*!< SCB CLIDR: LoC Mask */
+
+/* SCB Cache Type Register Definitions */
+#define SCB_CTR_FORMAT_Pos                 29U                                            /*!< SCB CTR: Format Position */
+#define SCB_CTR_FORMAT_Msk                 (7UL << SCB_CTR_FORMAT_Pos)                    /*!< SCB CTR: Format Mask */
+
+#define SCB_CTR_CWG_Pos                    24U                                            /*!< SCB CTR: CWG Position */
+#define SCB_CTR_CWG_Msk                    (0xFUL << SCB_CTR_CWG_Pos)                     /*!< SCB CTR: CWG Mask */
+
+#define SCB_CTR_ERG_Pos                    20U                                            /*!< SCB CTR: ERG Position */
+#define SCB_CTR_ERG_Msk                    (0xFUL << SCB_CTR_ERG_Pos)                     /*!< SCB CTR: ERG Mask */
+
+#define SCB_CTR_DMINLINE_Pos               16U                                            /*!< SCB CTR: DminLine Position */
+#define SCB_CTR_DMINLINE_Msk               (0xFUL << SCB_CTR_DMINLINE_Pos)                /*!< SCB CTR: DminLine Mask */
+
+#define SCB_CTR_IMINLINE_Pos                0U                                            /*!< SCB CTR: ImInLine Position */
+#define SCB_CTR_IMINLINE_Msk               (0xFUL /*<< SCB_CTR_IMINLINE_Pos*/)            /*!< SCB CTR: ImInLine Mask */
+
+/* SCB Cache Size ID Register Definitions */
+#define SCB_CCSIDR_WT_Pos                  31U                                            /*!< SCB CCSIDR: WT Position */
+#define SCB_CCSIDR_WT_Msk                  (1UL << SCB_CCSIDR_WT_Pos)                     /*!< SCB CCSIDR: WT Mask */
+
+#define SCB_CCSIDR_WB_Pos                  30U                                            /*!< SCB CCSIDR: WB Position */
+#define SCB_CCSIDR_WB_Msk                  (1UL << SCB_CCSIDR_WB_Pos)                     /*!< SCB CCSIDR: WB Mask */
+
+#define SCB_CCSIDR_RA_Pos                  29U                                            /*!< SCB CCSIDR: RA Position */
+#define SCB_CCSIDR_RA_Msk                  (1UL << SCB_CCSIDR_RA_Pos)                     /*!< SCB CCSIDR: RA Mask */
+
+#define SCB_CCSIDR_WA_Pos                  28U                                            /*!< SCB CCSIDR: WA Position */
+#define SCB_CCSIDR_WA_Msk                  (1UL << SCB_CCSIDR_WA_Pos)                     /*!< SCB CCSIDR: WA Mask */
+
+#define SCB_CCSIDR_NUMSETS_Pos             13U                                            /*!< SCB CCSIDR: NumSets Position */
+#define SCB_CCSIDR_NUMSETS_Msk             (0x7FFFUL << SCB_CCSIDR_NUMSETS_Pos)           /*!< SCB CCSIDR: NumSets Mask */
+
+#define SCB_CCSIDR_ASSOCIATIVITY_Pos        3U                                            /*!< SCB CCSIDR: Associativity Position */
+#define SCB_CCSIDR_ASSOCIATIVITY_Msk       (0x3FFUL << SCB_CCSIDR_ASSOCIATIVITY_Pos)      /*!< SCB CCSIDR: Associativity Mask */
+
+#define SCB_CCSIDR_LINESIZE_Pos             0U                                            /*!< SCB CCSIDR: LineSize Position */
+#define SCB_CCSIDR_LINESIZE_Msk            (7UL /*<< SCB_CCSIDR_LINESIZE_Pos*/)           /*!< SCB CCSIDR: LineSize Mask */
+
+/* SCB Cache Size Selection Register Definitions */
+#define SCB_CSSELR_LEVEL_Pos                1U                                            /*!< SCB CSSELR: Level Position */
+#define SCB_CSSELR_LEVEL_Msk               (7UL << SCB_CSSELR_LEVEL_Pos)                  /*!< SCB CSSELR: Level Mask */
+
+#define SCB_CSSELR_IND_Pos                  0U                                            /*!< SCB CSSELR: InD Position */
+#define SCB_CSSELR_IND_Msk                 (1UL /*<< SCB_CSSELR_IND_Pos*/)                /*!< SCB CSSELR: InD Mask */
+
+/* SCB Software Triggered Interrupt Register Definitions */
+#define SCB_STIR_INTID_Pos                  0U                                            /*!< SCB STIR: INTID Position */
+#define SCB_STIR_INTID_Msk                 (0x1FFUL /*<< SCB_STIR_INTID_Pos*/)            /*!< SCB STIR: INTID Mask */
+
+/* SCB D-Cache Invalidate by Set-way Register Definitions */
+#define SCB_DCISW_WAY_Pos                  30U                                            /*!< SCB DCISW: Way Position */
+#define SCB_DCISW_WAY_Msk                  (3UL << SCB_DCISW_WAY_Pos)                     /*!< SCB DCISW: Way Mask */
+
+#define SCB_DCISW_SET_Pos                   5U                                            /*!< SCB DCISW: Set Position */
+#define SCB_DCISW_SET_Msk                  (0x1FFUL << SCB_DCISW_SET_Pos)                 /*!< SCB DCISW: Set Mask */
+
+/* SCB D-Cache Clean by Set-way Register Definitions */
+#define SCB_DCCSW_WAY_Pos                  30U                                            /*!< SCB DCCSW: Way Position */
+#define SCB_DCCSW_WAY_Msk                  (3UL << SCB_DCCSW_WAY_Pos)                     /*!< SCB DCCSW: Way Mask */
+
+#define SCB_DCCSW_SET_Pos                   5U                                            /*!< SCB DCCSW: Set Position */
+#define SCB_DCCSW_SET_Msk                  (0x1FFUL << SCB_DCCSW_SET_Pos)                 /*!< SCB DCCSW: Set Mask */
+
+/* SCB D-Cache Clean and Invalidate by Set-way Register Definitions */
+#define SCB_DCCISW_WAY_Pos                 30U                                            /*!< SCB DCCISW: Way Position */
+#define SCB_DCCISW_WAY_Msk                 (3UL << SCB_DCCISW_WAY_Pos)                    /*!< SCB DCCISW: Way Mask */
+
+#define SCB_DCCISW_SET_Pos                  5U                                            /*!< SCB DCCISW: Set Position */
+#define SCB_DCCISW_SET_Msk                 (0x1FFUL << SCB_DCCISW_SET_Pos)                /*!< SCB DCCISW: Set Mask */
+
+/*@} end of group CMSIS_SCB */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB)
+  \brief    Type definitions for the System Control and ID Register not in the SCB
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Control and ID Register not in the SCB.
+ */
+typedef struct
+{
+        uint32_t RESERVED0[1U];
+  __IM  uint32_t ICTR;                   /*!< Offset: 0x004 (R/ )  Interrupt Controller Type Register */
+  __IOM uint32_t ACTLR;                  /*!< Offset: 0x008 (R/W)  Auxiliary Control Register */
+  __IOM uint32_t CPPWR;                  /*!< Offset: 0x00C (R/W)  Coprocessor Power Control  Register */
+} SCnSCB_Type;
+
+/* Interrupt Controller Type Register Definitions */
+#define SCnSCB_ICTR_INTLINESNUM_Pos         0U                                         /*!< ICTR: INTLINESNUM Position */
+#define SCnSCB_ICTR_INTLINESNUM_Msk        (0xFUL /*<< SCnSCB_ICTR_INTLINESNUM_Pos*/)  /*!< ICTR: INTLINESNUM Mask */
+
+/*@} end of group CMSIS_SCnotSCB */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SysTick     System Tick Timer (SysTick)
+  \brief    Type definitions for the System Timer Registers.
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Timer (SysTick).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  SysTick Control and Status Register */
+  __IOM uint32_t LOAD;                   /*!< Offset: 0x004 (R/W)  SysTick Reload Value Register */
+  __IOM uint32_t VAL;                    /*!< Offset: 0x008 (R/W)  SysTick Current Value Register */
+  __IM  uint32_t CALIB;                  /*!< Offset: 0x00C (R/ )  SysTick Calibration Register */
+} SysTick_Type;
+
+/* SysTick Control / Status Register Definitions */
+#define SysTick_CTRL_COUNTFLAG_Pos         16U                                            /*!< SysTick CTRL: COUNTFLAG Position */
+#define SysTick_CTRL_COUNTFLAG_Msk         (1UL << SysTick_CTRL_COUNTFLAG_Pos)            /*!< SysTick CTRL: COUNTFLAG Mask */
+
+#define SysTick_CTRL_CLKSOURCE_Pos          2U                                            /*!< SysTick CTRL: CLKSOURCE Position */
+#define SysTick_CTRL_CLKSOURCE_Msk         (1UL << SysTick_CTRL_CLKSOURCE_Pos)            /*!< SysTick CTRL: CLKSOURCE Mask */
+
+#define SysTick_CTRL_TICKINT_Pos            1U                                            /*!< SysTick CTRL: TICKINT Position */
+#define SysTick_CTRL_TICKINT_Msk           (1UL << SysTick_CTRL_TICKINT_Pos)              /*!< SysTick CTRL: TICKINT Mask */
+
+#define SysTick_CTRL_ENABLE_Pos             0U                                            /*!< SysTick CTRL: ENABLE Position */
+#define SysTick_CTRL_ENABLE_Msk            (1UL /*<< SysTick_CTRL_ENABLE_Pos*/)           /*!< SysTick CTRL: ENABLE Mask */
+
+/* SysTick Reload Register Definitions */
+#define SysTick_LOAD_RELOAD_Pos             0U                                            /*!< SysTick LOAD: RELOAD Position */
+#define SysTick_LOAD_RELOAD_Msk            (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/)    /*!< SysTick LOAD: RELOAD Mask */
+
+/* SysTick Current Register Definitions */
+#define SysTick_VAL_CURRENT_Pos             0U                                            /*!< SysTick VAL: CURRENT Position */
+#define SysTick_VAL_CURRENT_Msk            (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/)    /*!< SysTick VAL: CURRENT Mask */
+
+/* SysTick Calibration Register Definitions */
+#define SysTick_CALIB_NOREF_Pos            31U                                            /*!< SysTick CALIB: NOREF Position */
+#define SysTick_CALIB_NOREF_Msk            (1UL << SysTick_CALIB_NOREF_Pos)               /*!< SysTick CALIB: NOREF Mask */
+
+#define SysTick_CALIB_SKEW_Pos             30U                                            /*!< SysTick CALIB: SKEW Position */
+#define SysTick_CALIB_SKEW_Msk             (1UL << SysTick_CALIB_SKEW_Pos)                /*!< SysTick CALIB: SKEW Mask */
+
+#define SysTick_CALIB_TENMS_Pos             0U                                            /*!< SysTick CALIB: TENMS Position */
+#define SysTick_CALIB_TENMS_Msk            (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/)    /*!< SysTick CALIB: TENMS Mask */
+
+/*@} end of group CMSIS_SysTick */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_ITM     Instrumentation Trace Macrocell (ITM)
+  \brief    Type definitions for the Instrumentation Trace Macrocell (ITM)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Instrumentation Trace Macrocell Register (ITM).
+ */
+typedef struct
+{
+  __OM  union
+  {
+    __OM  uint8_t    u8;                 /*!< Offset: 0x000 ( /W)  ITM Stimulus Port 8-bit */
+    __OM  uint16_t   u16;                /*!< Offset: 0x000 ( /W)  ITM Stimulus Port 16-bit */
+    __OM  uint32_t   u32;                /*!< Offset: 0x000 ( /W)  ITM Stimulus Port 32-bit */
+  }  PORT [32U];                         /*!< Offset: 0x000 ( /W)  ITM Stimulus Port Registers */
+        uint32_t RESERVED0[864U];
+  __IOM uint32_t TER;                    /*!< Offset: 0xE00 (R/W)  ITM Trace Enable Register */
+        uint32_t RESERVED1[15U];
+  __IOM uint32_t TPR;                    /*!< Offset: 0xE40 (R/W)  ITM Trace Privilege Register */
+        uint32_t RESERVED2[15U];
+  __IOM uint32_t TCR;                    /*!< Offset: 0xE80 (R/W)  ITM Trace Control Register */
+        uint32_t RESERVED3[32U];
+        uint32_t RESERVED4[43U];
+  __OM  uint32_t LAR;                    /*!< Offset: 0xFB0 ( /W)  ITM Lock Access Register */
+  __IM  uint32_t LSR;                    /*!< Offset: 0xFB4 (R/ )  ITM Lock Status Register */
+        uint32_t RESERVED5[1U];
+  __IM  uint32_t DEVARCH;                /*!< Offset: 0xFBC (R/ )  ITM Device Architecture Register */
+        uint32_t RESERVED6[4U];
+  __IM  uint32_t PID4;                   /*!< Offset: 0xFD0 (R/ )  ITM Peripheral Identification Register #4 */
+  __IM  uint32_t PID5;                   /*!< Offset: 0xFD4 (R/ )  ITM Peripheral Identification Register #5 */
+  __IM  uint32_t PID6;                   /*!< Offset: 0xFD8 (R/ )  ITM Peripheral Identification Register #6 */
+  __IM  uint32_t PID7;                   /*!< Offset: 0xFDC (R/ )  ITM Peripheral Identification Register #7 */
+  __IM  uint32_t PID0;                   /*!< Offset: 0xFE0 (R/ )  ITM Peripheral Identification Register #0 */
+  __IM  uint32_t PID1;                   /*!< Offset: 0xFE4 (R/ )  ITM Peripheral Identification Register #1 */
+  __IM  uint32_t PID2;                   /*!< Offset: 0xFE8 (R/ )  ITM Peripheral Identification Register #2 */
+  __IM  uint32_t PID3;                   /*!< Offset: 0xFEC (R/ )  ITM Peripheral Identification Register #3 */
+  __IM  uint32_t CID0;                   /*!< Offset: 0xFF0 (R/ )  ITM Component  Identification Register #0 */
+  __IM  uint32_t CID1;                   /*!< Offset: 0xFF4 (R/ )  ITM Component  Identification Register #1 */
+  __IM  uint32_t CID2;                   /*!< Offset: 0xFF8 (R/ )  ITM Component  Identification Register #2 */
+  __IM  uint32_t CID3;                   /*!< Offset: 0xFFC (R/ )  ITM Component  Identification Register #3 */
+} ITM_Type;
+
+/* ITM Stimulus Port Register Definitions */
+#define ITM_STIM_DISABLED_Pos               1U                                            /*!< ITM STIM: DISABLED Position */
+#define ITM_STIM_DISABLED_Msk              (0x1UL << ITM_STIM_DISABLED_Pos)               /*!< ITM STIM: DISABLED Mask */
+
+#define ITM_STIM_FIFOREADY_Pos              0U                                            /*!< ITM STIM: FIFOREADY Position */
+#define ITM_STIM_FIFOREADY_Msk             (0x1UL /*<< ITM_STIM_FIFOREADY_Pos*/)          /*!< ITM STIM: FIFOREADY Mask */
+
+/* ITM Trace Privilege Register Definitions */
+#define ITM_TPR_PRIVMASK_Pos                0U                                            /*!< ITM TPR: PRIVMASK Position */
+#define ITM_TPR_PRIVMASK_Msk               (0xFUL /*<< ITM_TPR_PRIVMASK_Pos*/)            /*!< ITM TPR: PRIVMASK Mask */
+
+/* ITM Trace Control Register Definitions */
+#define ITM_TCR_BUSY_Pos                   23U                                            /*!< ITM TCR: BUSY Position */
+#define ITM_TCR_BUSY_Msk                   (1UL << ITM_TCR_BUSY_Pos)                      /*!< ITM TCR: BUSY Mask */
+
+#define ITM_TCR_TRACEBUSID_Pos             16U                                            /*!< ITM TCR: ATBID Position */
+#define ITM_TCR_TRACEBUSID_Msk             (0x7FUL << ITM_TCR_TRACEBUSID_Pos)             /*!< ITM TCR: ATBID Mask */
+
+#define ITM_TCR_GTSFREQ_Pos                10U                                            /*!< ITM TCR: Global timestamp frequency Position */
+#define ITM_TCR_GTSFREQ_Msk                (3UL << ITM_TCR_GTSFREQ_Pos)                   /*!< ITM TCR: Global timestamp frequency Mask */
+
+#define ITM_TCR_TSPRESCALE_Pos              8U                                            /*!< ITM TCR: TSPRESCALE Position */
+#define ITM_TCR_TSPRESCALE_Msk             (3UL << ITM_TCR_TSPRESCALE_Pos)                /*!< ITM TCR: TSPRESCALE Mask */
+
+#define ITM_TCR_STALLENA_Pos                5U                                            /*!< ITM TCR: STALLENA Position */
+#define ITM_TCR_STALLENA_Msk               (1UL << ITM_TCR_STALLENA_Pos)                  /*!< ITM TCR: STALLENA Mask */
+
+#define ITM_TCR_SWOENA_Pos                  4U                                            /*!< ITM TCR: SWOENA Position */
+#define ITM_TCR_SWOENA_Msk                 (1UL << ITM_TCR_SWOENA_Pos)                    /*!< ITM TCR: SWOENA Mask */
+
+#define ITM_TCR_DWTENA_Pos                  3U                                            /*!< ITM TCR: DWTENA Position */
+#define ITM_TCR_DWTENA_Msk                 (1UL << ITM_TCR_DWTENA_Pos)                    /*!< ITM TCR: DWTENA Mask */
+
+#define ITM_TCR_SYNCENA_Pos                 2U                                            /*!< ITM TCR: SYNCENA Position */
+#define ITM_TCR_SYNCENA_Msk                (1UL << ITM_TCR_SYNCENA_Pos)                   /*!< ITM TCR: SYNCENA Mask */
+
+#define ITM_TCR_TSENA_Pos                   1U                                            /*!< ITM TCR: TSENA Position */
+#define ITM_TCR_TSENA_Msk                  (1UL << ITM_TCR_TSENA_Pos)                     /*!< ITM TCR: TSENA Mask */
+
+#define ITM_TCR_ITMENA_Pos                  0U                                            /*!< ITM TCR: ITM Enable bit Position */
+#define ITM_TCR_ITMENA_Msk                 (1UL /*<< ITM_TCR_ITMENA_Pos*/)                /*!< ITM TCR: ITM Enable bit Mask */
+
+/* ITM Lock Status Register Definitions */
+#define ITM_LSR_ByteAcc_Pos                 2U                                            /*!< ITM LSR: ByteAcc Position */
+#define ITM_LSR_ByteAcc_Msk                (1UL << ITM_LSR_ByteAcc_Pos)                   /*!< ITM LSR: ByteAcc Mask */
+
+#define ITM_LSR_Access_Pos                  1U                                            /*!< ITM LSR: Access Position */
+#define ITM_LSR_Access_Msk                 (1UL << ITM_LSR_Access_Pos)                    /*!< ITM LSR: Access Mask */
+
+#define ITM_LSR_Present_Pos                 0U                                            /*!< ITM LSR: Present Position */
+#define ITM_LSR_Present_Msk                (1UL /*<< ITM_LSR_Present_Pos*/)               /*!< ITM LSR: Present Mask */
+
+/*@}*/ /* end of group CMSIS_ITM */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_DWT     Data Watchpoint and Trace (DWT)
+  \brief    Type definitions for the Data Watchpoint and Trace (DWT)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Data Watchpoint and Trace Register (DWT).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  Control Register */
+  __IOM uint32_t CYCCNT;                 /*!< Offset: 0x004 (R/W)  Cycle Count Register */
+  __IOM uint32_t CPICNT;                 /*!< Offset: 0x008 (R/W)  CPI Count Register */
+  __IOM uint32_t EXCCNT;                 /*!< Offset: 0x00C (R/W)  Exception Overhead Count Register */
+  __IOM uint32_t SLEEPCNT;               /*!< Offset: 0x010 (R/W)  Sleep Count Register */
+  __IOM uint32_t LSUCNT;                 /*!< Offset: 0x014 (R/W)  LSU Count Register */
+  __IOM uint32_t FOLDCNT;                /*!< Offset: 0x018 (R/W)  Folded-instruction Count Register */
+  __IM  uint32_t PCSR;                   /*!< Offset: 0x01C (R/ )  Program Counter Sample Register */
+  __IOM uint32_t COMP0;                  /*!< Offset: 0x020 (R/W)  Comparator Register 0 */
+        uint32_t RESERVED1[1U];
+  __IOM uint32_t FUNCTION0;              /*!< Offset: 0x028 (R/W)  Function Register 0 */
+        uint32_t RESERVED2[1U];
+  __IOM uint32_t COMP1;                  /*!< Offset: 0x030 (R/W)  Comparator Register 1 */
+        uint32_t RESERVED3[1U];
+  __IOM uint32_t FUNCTION1;              /*!< Offset: 0x038 (R/W)  Function Register 1 */
+        uint32_t RESERVED4[1U];
+  __IOM uint32_t COMP2;                  /*!< Offset: 0x040 (R/W)  Comparator Register 2 */
+        uint32_t RESERVED5[1U];
+  __IOM uint32_t FUNCTION2;              /*!< Offset: 0x048 (R/W)  Function Register 2 */
+        uint32_t RESERVED6[1U];
+  __IOM uint32_t COMP3;                  /*!< Offset: 0x050 (R/W)  Comparator Register 3 */
+        uint32_t RESERVED7[1U];
+  __IOM uint32_t FUNCTION3;              /*!< Offset: 0x058 (R/W)  Function Register 3 */
+        uint32_t RESERVED8[1U];
+  __IOM uint32_t COMP4;                  /*!< Offset: 0x060 (R/W)  Comparator Register 4 */
+        uint32_t RESERVED9[1U];
+  __IOM uint32_t FUNCTION4;              /*!< Offset: 0x068 (R/W)  Function Register 4 */
+        uint32_t RESERVED10[1U];
+  __IOM uint32_t COMP5;                  /*!< Offset: 0x070 (R/W)  Comparator Register 5 */
+        uint32_t RESERVED11[1U];
+  __IOM uint32_t FUNCTION5;              /*!< Offset: 0x078 (R/W)  Function Register 5 */
+        uint32_t RESERVED12[1U];
+  __IOM uint32_t COMP6;                  /*!< Offset: 0x080 (R/W)  Comparator Register 6 */
+        uint32_t RESERVED13[1U];
+  __IOM uint32_t FUNCTION6;              /*!< Offset: 0x088 (R/W)  Function Register 6 */
+        uint32_t RESERVED14[1U];
+  __IOM uint32_t COMP7;                  /*!< Offset: 0x090 (R/W)  Comparator Register 7 */
+        uint32_t RESERVED15[1U];
+  __IOM uint32_t FUNCTION7;              /*!< Offset: 0x098 (R/W)  Function Register 7 */
+        uint32_t RESERVED16[1U];
+  __IOM uint32_t COMP8;                  /*!< Offset: 0x0A0 (R/W)  Comparator Register 8 */
+        uint32_t RESERVED17[1U];
+  __IOM uint32_t FUNCTION8;              /*!< Offset: 0x0A8 (R/W)  Function Register 8 */
+        uint32_t RESERVED18[1U];
+  __IOM uint32_t COMP9;                  /*!< Offset: 0x0B0 (R/W)  Comparator Register 9 */
+        uint32_t RESERVED19[1U];
+  __IOM uint32_t FUNCTION9;              /*!< Offset: 0x0B8 (R/W)  Function Register 9 */
+        uint32_t RESERVED20[1U];
+  __IOM uint32_t COMP10;                 /*!< Offset: 0x0C0 (R/W)  Comparator Register 10 */
+        uint32_t RESERVED21[1U];
+  __IOM uint32_t FUNCTION10;             /*!< Offset: 0x0C8 (R/W)  Function Register 10 */
+        uint32_t RESERVED22[1U];
+  __IOM uint32_t COMP11;                 /*!< Offset: 0x0D0 (R/W)  Comparator Register 11 */
+        uint32_t RESERVED23[1U];
+  __IOM uint32_t FUNCTION11;             /*!< Offset: 0x0D8 (R/W)  Function Register 11 */
+        uint32_t RESERVED24[1U];
+  __IOM uint32_t COMP12;                 /*!< Offset: 0x0E0 (R/W)  Comparator Register 12 */
+        uint32_t RESERVED25[1U];
+  __IOM uint32_t FUNCTION12;             /*!< Offset: 0x0E8 (R/W)  Function Register 12 */
+        uint32_t RESERVED26[1U];
+  __IOM uint32_t COMP13;                 /*!< Offset: 0x0F0 (R/W)  Comparator Register 13 */
+        uint32_t RESERVED27[1U];
+  __IOM uint32_t FUNCTION13;             /*!< Offset: 0x0F8 (R/W)  Function Register 13 */
+        uint32_t RESERVED28[1U];
+  __IOM uint32_t COMP14;                 /*!< Offset: 0x100 (R/W)  Comparator Register 14 */
+        uint32_t RESERVED29[1U];
+  __IOM uint32_t FUNCTION14;             /*!< Offset: 0x108 (R/W)  Function Register 14 */
+        uint32_t RESERVED30[1U];
+  __IOM uint32_t COMP15;                 /*!< Offset: 0x110 (R/W)  Comparator Register 15 */
+        uint32_t RESERVED31[1U];
+  __IOM uint32_t FUNCTION15;             /*!< Offset: 0x118 (R/W)  Function Register 15 */
+        uint32_t RESERVED32[934U];
+  __IM  uint32_t LSR;                    /*!< Offset: 0xFB4 (R  )  Lock Status Register */
+        uint32_t RESERVED33[1U];
+  __IM  uint32_t DEVARCH;                /*!< Offset: 0xFBC (R/ )  Device Architecture Register */
+} DWT_Type;
+
+/* DWT Control Register Definitions */
+#define DWT_CTRL_NUMCOMP_Pos               28U                                         /*!< DWT CTRL: NUMCOMP Position */
+#define DWT_CTRL_NUMCOMP_Msk               (0xFUL << DWT_CTRL_NUMCOMP_Pos)             /*!< DWT CTRL: NUMCOMP Mask */
+
+#define DWT_CTRL_NOTRCPKT_Pos              27U                                         /*!< DWT CTRL: NOTRCPKT Position */
+#define DWT_CTRL_NOTRCPKT_Msk              (0x1UL << DWT_CTRL_NOTRCPKT_Pos)            /*!< DWT CTRL: NOTRCPKT Mask */
+
+#define DWT_CTRL_NOEXTTRIG_Pos             26U                                         /*!< DWT CTRL: NOEXTTRIG Position */
+#define DWT_CTRL_NOEXTTRIG_Msk             (0x1UL << DWT_CTRL_NOEXTTRIG_Pos)           /*!< DWT CTRL: NOEXTTRIG Mask */
+
+#define DWT_CTRL_NOCYCCNT_Pos              25U                                         /*!< DWT CTRL: NOCYCCNT Position */
+#define DWT_CTRL_NOCYCCNT_Msk              (0x1UL << DWT_CTRL_NOCYCCNT_Pos)            /*!< DWT CTRL: NOCYCCNT Mask */
+
+#define DWT_CTRL_NOPRFCNT_Pos              24U                                         /*!< DWT CTRL: NOPRFCNT Position */
+#define DWT_CTRL_NOPRFCNT_Msk              (0x1UL << DWT_CTRL_NOPRFCNT_Pos)            /*!< DWT CTRL: NOPRFCNT Mask */
+
+#define DWT_CTRL_CYCDISS_Pos               23U                                         /*!< DWT CTRL: CYCDISS Position */
+#define DWT_CTRL_CYCDISS_Msk               (0x1UL << DWT_CTRL_CYCDISS_Pos)             /*!< DWT CTRL: CYCDISS Mask */
+
+#define DWT_CTRL_CYCEVTENA_Pos             22U                                         /*!< DWT CTRL: CYCEVTENA Position */
+#define DWT_CTRL_CYCEVTENA_Msk             (0x1UL << DWT_CTRL_CYCEVTENA_Pos)           /*!< DWT CTRL: CYCEVTENA Mask */
+
+#define DWT_CTRL_FOLDEVTENA_Pos            21U                                         /*!< DWT CTRL: FOLDEVTENA Position */
+#define DWT_CTRL_FOLDEVTENA_Msk            (0x1UL << DWT_CTRL_FOLDEVTENA_Pos)          /*!< DWT CTRL: FOLDEVTENA Mask */
+
+#define DWT_CTRL_LSUEVTENA_Pos             20U                                         /*!< DWT CTRL: LSUEVTENA Position */
+#define DWT_CTRL_LSUEVTENA_Msk             (0x1UL << DWT_CTRL_LSUEVTENA_Pos)           /*!< DWT CTRL: LSUEVTENA Mask */
+
+#define DWT_CTRL_SLEEPEVTENA_Pos           19U                                         /*!< DWT CTRL: SLEEPEVTENA Position */
+#define DWT_CTRL_SLEEPEVTENA_Msk           (0x1UL << DWT_CTRL_SLEEPEVTENA_Pos)         /*!< DWT CTRL: SLEEPEVTENA Mask */
+
+#define DWT_CTRL_EXCEVTENA_Pos             18U                                         /*!< DWT CTRL: EXCEVTENA Position */
+#define DWT_CTRL_EXCEVTENA_Msk             (0x1UL << DWT_CTRL_EXCEVTENA_Pos)           /*!< DWT CTRL: EXCEVTENA Mask */
+
+#define DWT_CTRL_CPIEVTENA_Pos             17U                                         /*!< DWT CTRL: CPIEVTENA Position */
+#define DWT_CTRL_CPIEVTENA_Msk             (0x1UL << DWT_CTRL_CPIEVTENA_Pos)           /*!< DWT CTRL: CPIEVTENA Mask */
+
+#define DWT_CTRL_EXCTRCENA_Pos             16U                                         /*!< DWT CTRL: EXCTRCENA Position */
+#define DWT_CTRL_EXCTRCENA_Msk             (0x1UL << DWT_CTRL_EXCTRCENA_Pos)           /*!< DWT CTRL: EXCTRCENA Mask */
+
+#define DWT_CTRL_PCSAMPLENA_Pos            12U                                         /*!< DWT CTRL: PCSAMPLENA Position */
+#define DWT_CTRL_PCSAMPLENA_Msk            (0x1UL << DWT_CTRL_PCSAMPLENA_Pos)          /*!< DWT CTRL: PCSAMPLENA Mask */
+
+#define DWT_CTRL_SYNCTAP_Pos               10U                                         /*!< DWT CTRL: SYNCTAP Position */
+#define DWT_CTRL_SYNCTAP_Msk               (0x3UL << DWT_CTRL_SYNCTAP_Pos)             /*!< DWT CTRL: SYNCTAP Mask */
+
+#define DWT_CTRL_CYCTAP_Pos                 9U                                         /*!< DWT CTRL: CYCTAP Position */
+#define DWT_CTRL_CYCTAP_Msk                (0x1UL << DWT_CTRL_CYCTAP_Pos)              /*!< DWT CTRL: CYCTAP Mask */
+
+#define DWT_CTRL_POSTINIT_Pos               5U                                         /*!< DWT CTRL: POSTINIT Position */
+#define DWT_CTRL_POSTINIT_Msk              (0xFUL << DWT_CTRL_POSTINIT_Pos)            /*!< DWT CTRL: POSTINIT Mask */
+
+#define DWT_CTRL_POSTPRESET_Pos             1U                                         /*!< DWT CTRL: POSTPRESET Position */
+#define DWT_CTRL_POSTPRESET_Msk            (0xFUL << DWT_CTRL_POSTPRESET_Pos)          /*!< DWT CTRL: POSTPRESET Mask */
+
+#define DWT_CTRL_CYCCNTENA_Pos              0U                                         /*!< DWT CTRL: CYCCNTENA Position */
+#define DWT_CTRL_CYCCNTENA_Msk             (0x1UL /*<< DWT_CTRL_CYCCNTENA_Pos*/)       /*!< DWT CTRL: CYCCNTENA Mask */
+
+/* DWT CPI Count Register Definitions */
+#define DWT_CPICNT_CPICNT_Pos               0U                                         /*!< DWT CPICNT: CPICNT Position */
+#define DWT_CPICNT_CPICNT_Msk              (0xFFUL /*<< DWT_CPICNT_CPICNT_Pos*/)       /*!< DWT CPICNT: CPICNT Mask */
+
+/* DWT Exception Overhead Count Register Definitions */
+#define DWT_EXCCNT_EXCCNT_Pos               0U                                         /*!< DWT EXCCNT: EXCCNT Position */
+#define DWT_EXCCNT_EXCCNT_Msk              (0xFFUL /*<< DWT_EXCCNT_EXCCNT_Pos*/)       /*!< DWT EXCCNT: EXCCNT Mask */
+
+/* DWT Sleep Count Register Definitions */
+#define DWT_SLEEPCNT_SLEEPCNT_Pos           0U                                         /*!< DWT SLEEPCNT: SLEEPCNT Position */
+#define DWT_SLEEPCNT_SLEEPCNT_Msk          (0xFFUL /*<< DWT_SLEEPCNT_SLEEPCNT_Pos*/)   /*!< DWT SLEEPCNT: SLEEPCNT Mask */
+
+/* DWT LSU Count Register Definitions */
+#define DWT_LSUCNT_LSUCNT_Pos               0U                                         /*!< DWT LSUCNT: LSUCNT Position */
+#define DWT_LSUCNT_LSUCNT_Msk              (0xFFUL /*<< DWT_LSUCNT_LSUCNT_Pos*/)       /*!< DWT LSUCNT: LSUCNT Mask */
+
+/* DWT Folded-instruction Count Register Definitions */
+#define DWT_FOLDCNT_FOLDCNT_Pos             0U                                         /*!< DWT FOLDCNT: FOLDCNT Position */
+#define DWT_FOLDCNT_FOLDCNT_Msk            (0xFFUL /*<< DWT_FOLDCNT_FOLDCNT_Pos*/)     /*!< DWT FOLDCNT: FOLDCNT Mask */
+
+/* DWT Comparator Function Register Definitions */
+#define DWT_FUNCTION_ID_Pos                27U                                         /*!< DWT FUNCTION: ID Position */
+#define DWT_FUNCTION_ID_Msk                (0x1FUL << DWT_FUNCTION_ID_Pos)             /*!< DWT FUNCTION: ID Mask */
+
+#define DWT_FUNCTION_MATCHED_Pos           24U                                         /*!< DWT FUNCTION: MATCHED Position */
+#define DWT_FUNCTION_MATCHED_Msk           (0x1UL << DWT_FUNCTION_MATCHED_Pos)         /*!< DWT FUNCTION: MATCHED Mask */
+
+#define DWT_FUNCTION_DATAVSIZE_Pos         10U                                         /*!< DWT FUNCTION: DATAVSIZE Position */
+#define DWT_FUNCTION_DATAVSIZE_Msk         (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos)       /*!< DWT FUNCTION: DATAVSIZE Mask */
+
+#define DWT_FUNCTION_ACTION_Pos             4U                                         /*!< DWT FUNCTION: ACTION Position */
+#define DWT_FUNCTION_ACTION_Msk            (0x1UL << DWT_FUNCTION_ACTION_Pos)          /*!< DWT FUNCTION: ACTION Mask */
+
+#define DWT_FUNCTION_MATCH_Pos              0U                                         /*!< DWT FUNCTION: MATCH Position */
+#define DWT_FUNCTION_MATCH_Msk             (0xFUL /*<< DWT_FUNCTION_MATCH_Pos*/)       /*!< DWT FUNCTION: MATCH Mask */
+
+/*@}*/ /* end of group CMSIS_DWT */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_TPI     Trace Port Interface (TPI)
+  \brief    Type definitions for the Trace Port Interface (TPI)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Trace Port Interface Register (TPI).
+ */
+typedef struct
+{
+  __IM  uint32_t SSPSR;                  /*!< Offset: 0x000 (R/ )  Supported Parallel Port Sizes Register */
+  __IOM uint32_t CSPSR;                  /*!< Offset: 0x004 (R/W)  Current Parallel Port Sizes Register */
+        uint32_t RESERVED0[2U];
+  __IOM uint32_t ACPR;                   /*!< Offset: 0x010 (R/W)  Asynchronous Clock Prescaler Register */
+        uint32_t RESERVED1[55U];
+  __IOM uint32_t SPPR;                   /*!< Offset: 0x0F0 (R/W)  Selected Pin Protocol Register */
+        uint32_t RESERVED2[131U];
+  __IM  uint32_t FFSR;                   /*!< Offset: 0x300 (R/ )  Formatter and Flush Status Register */
+  __IOM uint32_t FFCR;                   /*!< Offset: 0x304 (R/W)  Formatter and Flush Control Register */
+  __IOM uint32_t PSCR;                   /*!< Offset: 0x308 (R/W)  Periodic Synchronization Control Register */
+        uint32_t RESERVED3[809U];
+  __OM  uint32_t LAR;                    /*!< Offset: 0xFB0 ( /W)  Software Lock Access Register */
+  __IM  uint32_t LSR;                    /*!< Offset: 0xFB4 (R/ )  Software Lock Status Register */
+        uint32_t RESERVED4[4U];
+  __IM  uint32_t TYPE;                   /*!< Offset: 0xFC8 (R/ )  Device Identifier Register */
+  __IM  uint32_t DEVTYPE;                /*!< Offset: 0xFCC (R/ )  Device Type Register */
+} TPI_Type;
+
+/* TPI Asynchronous Clock Prescaler Register Definitions */
+#define TPI_ACPR_SWOSCALER_Pos              0U                                         /*!< TPI ACPR: SWOSCALER Position */
+#define TPI_ACPR_SWOSCALER_Msk             (0xFFFFUL /*<< TPI_ACPR_SWOSCALER_Pos*/)    /*!< TPI ACPR: SWOSCALER Mask */
+
+/* TPI Selected Pin Protocol Register Definitions */
+#define TPI_SPPR_TXMODE_Pos                 0U                                         /*!< TPI SPPR: TXMODE Position */
+#define TPI_SPPR_TXMODE_Msk                (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/)          /*!< TPI SPPR: TXMODE Mask */
+
+/* TPI Formatter and Flush Status Register Definitions */
+#define TPI_FFSR_FtNonStop_Pos              3U                                         /*!< TPI FFSR: FtNonStop Position */
+#define TPI_FFSR_FtNonStop_Msk             (0x1UL << TPI_FFSR_FtNonStop_Pos)           /*!< TPI FFSR: FtNonStop Mask */
+
+#define TPI_FFSR_TCPresent_Pos              2U                                         /*!< TPI FFSR: TCPresent Position */
+#define TPI_FFSR_TCPresent_Msk             (0x1UL << TPI_FFSR_TCPresent_Pos)           /*!< TPI FFSR: TCPresent Mask */
+
+#define TPI_FFSR_FtStopped_Pos              1U                                         /*!< TPI FFSR: FtStopped Position */
+#define TPI_FFSR_FtStopped_Msk             (0x1UL << TPI_FFSR_FtStopped_Pos)           /*!< TPI FFSR: FtStopped Mask */
+
+#define TPI_FFSR_FlInProg_Pos               0U                                         /*!< TPI FFSR: FlInProg Position */
+#define TPI_FFSR_FlInProg_Msk              (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/)        /*!< TPI FFSR: FlInProg Mask */
+
+/* TPI Formatter and Flush Control Register Definitions */
+#define TPI_FFCR_TrigIn_Pos                 8U                                         /*!< TPI FFCR: TrigIn Position */
+#define TPI_FFCR_TrigIn_Msk                (0x1UL << TPI_FFCR_TrigIn_Pos)              /*!< TPI FFCR: TrigIn Mask */
+
+#define TPI_FFCR_FOnMan_Pos                 6U                                         /*!< TPI FFCR: FOnMan Position */
+#define TPI_FFCR_FOnMan_Msk                (0x1UL << TPI_FFCR_FOnMan_Pos)              /*!< TPI FFCR: FOnMan Mask */
+
+#define TPI_FFCR_EnFCont_Pos                1U                                         /*!< TPI FFCR: EnFCont Position */
+#define TPI_FFCR_EnFCont_Msk               (0x1UL << TPI_FFCR_EnFCont_Pos)             /*!< TPI FFCR: EnFCont Mask */
+
+/* TPI Periodic Synchronization Control Register Definitions */
+#define TPI_PSCR_PSCount_Pos                0U                                         /*!< TPI PSCR: PSCount Position */
+#define TPI_PSCR_PSCount_Msk               (0x1FUL /*<< TPI_PSCR_PSCount_Pos*/)        /*!< TPI PSCR: TPSCount Mask */
+
+/* TPI Software Lock Status Register Definitions */
+#define TPI_LSR_nTT_Pos                     1U                                         /*!< TPI LSR: Not thirty-two bit. Position */
+#define TPI_LSR_nTT_Msk                    (0x1UL << TPI_LSR_nTT_Pos)                  /*!< TPI LSR: Not thirty-two bit. Mask */
+
+#define TPI_LSR_SLK_Pos                     1U                                         /*!< TPI LSR: Software Lock status Position */
+#define TPI_LSR_SLK_Msk                    (0x1UL << TPI_LSR_SLK_Pos)                  /*!< TPI LSR: Software Lock status Mask */
+
+#define TPI_LSR_SLI_Pos                     0U                                         /*!< TPI LSR: Software Lock implemented Position */
+#define TPI_LSR_SLI_Msk                    (0x1UL /*<< TPI_LSR_SLI_Pos*/)              /*!< TPI LSR: Software Lock implemented Mask */
+
+/* TPI DEVID Register Definitions */
+#define TPI_DEVID_NRZVALID_Pos             11U                                         /*!< TPI DEVID: NRZVALID Position */
+#define TPI_DEVID_NRZVALID_Msk             (0x1UL << TPI_DEVID_NRZVALID_Pos)           /*!< TPI DEVID: NRZVALID Mask */
+
+#define TPI_DEVID_MANCVALID_Pos            10U                                         /*!< TPI DEVID: MANCVALID Position */
+#define TPI_DEVID_MANCVALID_Msk            (0x1UL << TPI_DEVID_MANCVALID_Pos)          /*!< TPI DEVID: MANCVALID Mask */
+
+#define TPI_DEVID_PTINVALID_Pos             9U                                         /*!< TPI DEVID: PTINVALID Position */
+#define TPI_DEVID_PTINVALID_Msk            (0x1UL << TPI_DEVID_PTINVALID_Pos)          /*!< TPI DEVID: PTINVALID Mask */
+
+#define TPI_DEVID_FIFOSZ_Pos                6U                                         /*!< TPI DEVID: FIFO depth Position */
+#define TPI_DEVID_FIFOSZ_Msk               (0x7UL << TPI_DEVID_FIFOSZ_Pos)             /*!< TPI DEVID: FIFO depth Mask */
+
+/* TPI DEVTYPE Register Definitions */
+#define TPI_DEVTYPE_SubType_Pos             4U                                         /*!< TPI DEVTYPE: SubType Position */
+#define TPI_DEVTYPE_SubType_Msk            (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/)      /*!< TPI DEVTYPE: SubType Mask */
+
+#define TPI_DEVTYPE_MajorType_Pos           0U                                         /*!< TPI DEVTYPE: MajorType Position */
+#define TPI_DEVTYPE_MajorType_Msk          (0xFUL << TPI_DEVTYPE_MajorType_Pos)        /*!< TPI DEVTYPE: MajorType Mask */
+
+/*@}*/ /* end of group CMSIS_TPI */
+
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_MPU     Memory Protection Unit (MPU)
+  \brief    Type definitions for the Memory Protection Unit (MPU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Memory Protection Unit (MPU).
+ */
+typedef struct
+{
+  __IM  uint32_t TYPE;                   /*!< Offset: 0x000 (R/ )  MPU Type Register */
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x004 (R/W)  MPU Control Register */
+  __IOM uint32_t RNR;                    /*!< Offset: 0x008 (R/W)  MPU Region Number Register */
+  __IOM uint32_t RBAR;                   /*!< Offset: 0x00C (R/W)  MPU Region Base Address Register */
+  __IOM uint32_t RLAR;                   /*!< Offset: 0x010 (R/W)  MPU Region Limit Address Register */
+  __IOM uint32_t RBAR_A1;                /*!< Offset: 0x014 (R/W)  MPU Region Base Address Register Alias 1 */
+  __IOM uint32_t RLAR_A1;                /*!< Offset: 0x018 (R/W)  MPU Region Limit Address Register Alias 1 */
+  __IOM uint32_t RBAR_A2;                /*!< Offset: 0x01C (R/W)  MPU Region Base Address Register Alias 2 */
+  __IOM uint32_t RLAR_A2;                /*!< Offset: 0x020 (R/W)  MPU Region Limit Address Register Alias 2 */
+  __IOM uint32_t RBAR_A3;                /*!< Offset: 0x024 (R/W)  MPU Region Base Address Register Alias 3 */
+  __IOM uint32_t RLAR_A3;                /*!< Offset: 0x028 (R/W)  MPU Region Limit Address Register Alias 3 */
+        uint32_t RESERVED0[1];
+  union {
+  __IOM uint32_t MAIR[2];
+  struct {
+  __IOM uint32_t MAIR0;                  /*!< Offset: 0x030 (R/W)  MPU Memory Attribute Indirection Register 0 */
+  __IOM uint32_t MAIR1;                  /*!< Offset: 0x034 (R/W)  MPU Memory Attribute Indirection Register 1 */
+  };
+  };
+} MPU_Type;
+
+#define MPU_TYPE_RALIASES                  4U
+
+/* MPU Type Register Definitions */
+#define MPU_TYPE_IREGION_Pos               16U                                            /*!< MPU TYPE: IREGION Position */
+#define MPU_TYPE_IREGION_Msk               (0xFFUL << MPU_TYPE_IREGION_Pos)               /*!< MPU TYPE: IREGION Mask */
+
+#define MPU_TYPE_DREGION_Pos                8U                                            /*!< MPU TYPE: DREGION Position */
+#define MPU_TYPE_DREGION_Msk               (0xFFUL << MPU_TYPE_DREGION_Pos)               /*!< MPU TYPE: DREGION Mask */
+
+#define MPU_TYPE_SEPARATE_Pos               0U                                            /*!< MPU TYPE: SEPARATE Position */
+#define MPU_TYPE_SEPARATE_Msk              (1UL /*<< MPU_TYPE_SEPARATE_Pos*/)             /*!< MPU TYPE: SEPARATE Mask */
+
+/* MPU Control Register Definitions */
+#define MPU_CTRL_PRIVDEFENA_Pos             2U                                            /*!< MPU CTRL: PRIVDEFENA Position */
+#define MPU_CTRL_PRIVDEFENA_Msk            (1UL << MPU_CTRL_PRIVDEFENA_Pos)               /*!< MPU CTRL: PRIVDEFENA Mask */
+
+#define MPU_CTRL_HFNMIENA_Pos               1U                                            /*!< MPU CTRL: HFNMIENA Position */
+#define MPU_CTRL_HFNMIENA_Msk              (1UL << MPU_CTRL_HFNMIENA_Pos)                 /*!< MPU CTRL: HFNMIENA Mask */
+
+#define MPU_CTRL_ENABLE_Pos                 0U                                            /*!< MPU CTRL: ENABLE Position */
+#define MPU_CTRL_ENABLE_Msk                (1UL /*<< MPU_CTRL_ENABLE_Pos*/)               /*!< MPU CTRL: ENABLE Mask */
+
+/* MPU Region Number Register Definitions */
+#define MPU_RNR_REGION_Pos                  0U                                            /*!< MPU RNR: REGION Position */
+#define MPU_RNR_REGION_Msk                 (0xFFUL /*<< MPU_RNR_REGION_Pos*/)             /*!< MPU RNR: REGION Mask */
+
+/* MPU Region Base Address Register Definitions */
+#define MPU_RBAR_BASE_Pos                   5U                                            /*!< MPU RBAR: BASE Position */
+#define MPU_RBAR_BASE_Msk                  (0x7FFFFFFUL << MPU_RBAR_BASE_Pos)             /*!< MPU RBAR: BASE Mask */
+
+#define MPU_RBAR_SH_Pos                     3U                                            /*!< MPU RBAR: SH Position */
+#define MPU_RBAR_SH_Msk                    (0x3UL << MPU_RBAR_SH_Pos)                     /*!< MPU RBAR: SH Mask */
+
+#define MPU_RBAR_AP_Pos                     1U                                            /*!< MPU RBAR: AP Position */
+#define MPU_RBAR_AP_Msk                    (0x3UL << MPU_RBAR_AP_Pos)                     /*!< MPU RBAR: AP Mask */
+
+#define MPU_RBAR_XN_Pos                     0U                                            /*!< MPU RBAR: XN Position */
+#define MPU_RBAR_XN_Msk                    (01UL /*<< MPU_RBAR_XN_Pos*/)                  /*!< MPU RBAR: XN Mask */
+
+/* MPU Region Limit Address Register Definitions */
+#define MPU_RLAR_LIMIT_Pos                  5U                                            /*!< MPU RLAR: LIMIT Position */
+#define MPU_RLAR_LIMIT_Msk                 (0x7FFFFFFUL << MPU_RLAR_LIMIT_Pos)            /*!< MPU RLAR: LIMIT Mask */
+
+#define MPU_RLAR_AttrIndx_Pos               1U                                            /*!< MPU RLAR: AttrIndx Position */
+#define MPU_RLAR_AttrIndx_Msk              (0x7UL << MPU_RLAR_AttrIndx_Pos)               /*!< MPU RLAR: AttrIndx Mask */
+
+#define MPU_RLAR_EN_Pos                     0U                                            /*!< MPU RLAR: Region enable bit Position */
+#define MPU_RLAR_EN_Msk                    (1UL /*<< MPU_RLAR_EN_Pos*/)                   /*!< MPU RLAR: Region enable bit Disable Mask */
+
+/* MPU Memory Attribute Indirection Register 0 Definitions */
+#define MPU_MAIR0_Attr3_Pos                24U                                            /*!< MPU MAIR0: Attr3 Position */
+#define MPU_MAIR0_Attr3_Msk                (0xFFUL << MPU_MAIR0_Attr3_Pos)                /*!< MPU MAIR0: Attr3 Mask */
+
+#define MPU_MAIR0_Attr2_Pos                16U                                            /*!< MPU MAIR0: Attr2 Position */
+#define MPU_MAIR0_Attr2_Msk                (0xFFUL << MPU_MAIR0_Attr2_Pos)                /*!< MPU MAIR0: Attr2 Mask */
+
+#define MPU_MAIR0_Attr1_Pos                 8U                                            /*!< MPU MAIR0: Attr1 Position */
+#define MPU_MAIR0_Attr1_Msk                (0xFFUL << MPU_MAIR0_Attr1_Pos)                /*!< MPU MAIR0: Attr1 Mask */
+
+#define MPU_MAIR0_Attr0_Pos                 0U                                            /*!< MPU MAIR0: Attr0 Position */
+#define MPU_MAIR0_Attr0_Msk                (0xFFUL /*<< MPU_MAIR0_Attr0_Pos*/)            /*!< MPU MAIR0: Attr0 Mask */
+
+/* MPU Memory Attribute Indirection Register 1 Definitions */
+#define MPU_MAIR1_Attr7_Pos                24U                                            /*!< MPU MAIR1: Attr7 Position */
+#define MPU_MAIR1_Attr7_Msk                (0xFFUL << MPU_MAIR1_Attr7_Pos)                /*!< MPU MAIR1: Attr7 Mask */
+
+#define MPU_MAIR1_Attr6_Pos                16U                                            /*!< MPU MAIR1: Attr6 Position */
+#define MPU_MAIR1_Attr6_Msk                (0xFFUL << MPU_MAIR1_Attr6_Pos)                /*!< MPU MAIR1: Attr6 Mask */
+
+#define MPU_MAIR1_Attr5_Pos                 8U                                            /*!< MPU MAIR1: Attr5 Position */
+#define MPU_MAIR1_Attr5_Msk                (0xFFUL << MPU_MAIR1_Attr5_Pos)                /*!< MPU MAIR1: Attr5 Mask */
+
+#define MPU_MAIR1_Attr4_Pos                 0U                                            /*!< MPU MAIR1: Attr4 Position */
+#define MPU_MAIR1_Attr4_Msk                (0xFFUL /*<< MPU_MAIR1_Attr4_Pos*/)            /*!< MPU MAIR1: Attr4 Mask */
+
+/*@} end of group CMSIS_MPU */
+#endif
+
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SAU     Security Attribution Unit (SAU)
+  \brief    Type definitions for the Security Attribution Unit (SAU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Security Attribution Unit (SAU).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  SAU Control Register */
+  __IM  uint32_t TYPE;                   /*!< Offset: 0x004 (R/ )  SAU Type Register */
+#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U)
+  __IOM uint32_t RNR;                    /*!< Offset: 0x008 (R/W)  SAU Region Number Register */
+  __IOM uint32_t RBAR;                   /*!< Offset: 0x00C (R/W)  SAU Region Base Address Register */
+  __IOM uint32_t RLAR;                   /*!< Offset: 0x010 (R/W)  SAU Region Limit Address Register */
+#else
+        uint32_t RESERVED0[3];
+#endif
+  __IOM uint32_t SFSR;                   /*!< Offset: 0x014 (R/W)  Secure Fault Status Register */
+  __IOM uint32_t SFAR;                   /*!< Offset: 0x018 (R/W)  Secure Fault Address Register */
+} SAU_Type;
+
+/* SAU Control Register Definitions */
+#define SAU_CTRL_ALLNS_Pos                  1U                                            /*!< SAU CTRL: ALLNS Position */
+#define SAU_CTRL_ALLNS_Msk                 (1UL << SAU_CTRL_ALLNS_Pos)                    /*!< SAU CTRL: ALLNS Mask */
+
+#define SAU_CTRL_ENABLE_Pos                 0U                                            /*!< SAU CTRL: ENABLE Position */
+#define SAU_CTRL_ENABLE_Msk                (1UL /*<< SAU_CTRL_ENABLE_Pos*/)               /*!< SAU CTRL: ENABLE Mask */
+
+/* SAU Type Register Definitions */
+#define SAU_TYPE_SREGION_Pos                0U                                            /*!< SAU TYPE: SREGION Position */
+#define SAU_TYPE_SREGION_Msk               (0xFFUL /*<< SAU_TYPE_SREGION_Pos*/)           /*!< SAU TYPE: SREGION Mask */
+
+#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U)
+/* SAU Region Number Register Definitions */
+#define SAU_RNR_REGION_Pos                  0U                                            /*!< SAU RNR: REGION Position */
+#define SAU_RNR_REGION_Msk                 (0xFFUL /*<< SAU_RNR_REGION_Pos*/)             /*!< SAU RNR: REGION Mask */
+
+/* SAU Region Base Address Register Definitions */
+#define SAU_RBAR_BADDR_Pos                  5U                                            /*!< SAU RBAR: BADDR Position */
+#define SAU_RBAR_BADDR_Msk                 (0x7FFFFFFUL << SAU_RBAR_BADDR_Pos)            /*!< SAU RBAR: BADDR Mask */
+
+/* SAU Region Limit Address Register Definitions */
+#define SAU_RLAR_LADDR_Pos                  5U                                            /*!< SAU RLAR: LADDR Position */
+#define SAU_RLAR_LADDR_Msk                 (0x7FFFFFFUL << SAU_RLAR_LADDR_Pos)            /*!< SAU RLAR: LADDR Mask */
+
+#define SAU_RLAR_NSC_Pos                    1U                                            /*!< SAU RLAR: NSC Position */
+#define SAU_RLAR_NSC_Msk                   (1UL << SAU_RLAR_NSC_Pos)                      /*!< SAU RLAR: NSC Mask */
+
+#define SAU_RLAR_ENABLE_Pos                 0U                                            /*!< SAU RLAR: ENABLE Position */
+#define SAU_RLAR_ENABLE_Msk                (1UL /*<< SAU_RLAR_ENABLE_Pos*/)               /*!< SAU RLAR: ENABLE Mask */
+
+#endif /* defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) */
+
+/* Secure Fault Status Register Definitions */
+#define SAU_SFSR_LSERR_Pos                  7U                                            /*!< SAU SFSR: LSERR Position */
+#define SAU_SFSR_LSERR_Msk                 (1UL << SAU_SFSR_LSERR_Pos)                    /*!< SAU SFSR: LSERR Mask */
+
+#define SAU_SFSR_SFARVALID_Pos              6U                                            /*!< SAU SFSR: SFARVALID Position */
+#define SAU_SFSR_SFARVALID_Msk             (1UL << SAU_SFSR_SFARVALID_Pos)                /*!< SAU SFSR: SFARVALID Mask */
+
+#define SAU_SFSR_LSPERR_Pos                 5U                                            /*!< SAU SFSR: LSPERR Position */
+#define SAU_SFSR_LSPERR_Msk                (1UL << SAU_SFSR_LSPERR_Pos)                   /*!< SAU SFSR: LSPERR Mask */
+
+#define SAU_SFSR_INVTRAN_Pos                4U                                            /*!< SAU SFSR: INVTRAN Position */
+#define SAU_SFSR_INVTRAN_Msk               (1UL << SAU_SFSR_INVTRAN_Pos)                  /*!< SAU SFSR: INVTRAN Mask */
+
+#define SAU_SFSR_AUVIOL_Pos                 3U                                            /*!< SAU SFSR: AUVIOL Position */
+#define SAU_SFSR_AUVIOL_Msk                (1UL << SAU_SFSR_AUVIOL_Pos)                   /*!< SAU SFSR: AUVIOL Mask */
+
+#define SAU_SFSR_INVER_Pos                  2U                                            /*!< SAU SFSR: INVER Position */
+#define SAU_SFSR_INVER_Msk                 (1UL << SAU_SFSR_INVER_Pos)                    /*!< SAU SFSR: INVER Mask */
+
+#define SAU_SFSR_INVIS_Pos                  1U                                            /*!< SAU SFSR: INVIS Position */
+#define SAU_SFSR_INVIS_Msk                 (1UL << SAU_SFSR_INVIS_Pos)                    /*!< SAU SFSR: INVIS Mask */
+
+#define SAU_SFSR_INVEP_Pos                  0U                                            /*!< SAU SFSR: INVEP Position */
+#define SAU_SFSR_INVEP_Msk                 (1UL /*<< SAU_SFSR_INVEP_Pos*/)                /*!< SAU SFSR: INVEP Mask */
+
+/*@} end of group CMSIS_SAU */
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_FPU     Floating Point Unit (FPU)
+  \brief    Type definitions for the Floating Point Unit (FPU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Floating Point Unit (FPU).
+ */
+typedef struct
+{
+        uint32_t RESERVED0[1U];
+  __IOM uint32_t FPCCR;                  /*!< Offset: 0x004 (R/W)  Floating-Point Context Control Register */
+  __IOM uint32_t FPCAR;                  /*!< Offset: 0x008 (R/W)  Floating-Point Context Address Register */
+  __IOM uint32_t FPDSCR;                 /*!< Offset: 0x00C (R/W)  Floating-Point Default Status Control Register */
+  __IM  uint32_t MVFR0;                  /*!< Offset: 0x010 (R/ )  Media and FP Feature Register 0 */
+  __IM  uint32_t MVFR1;                  /*!< Offset: 0x014 (R/ )  Media and FP Feature Register 1 */
+} FPU_Type;
+
+/* Floating-Point Context Control Register Definitions */
+#define FPU_FPCCR_ASPEN_Pos                31U                                            /*!< FPCCR: ASPEN bit Position */
+#define FPU_FPCCR_ASPEN_Msk                (1UL << FPU_FPCCR_ASPEN_Pos)                   /*!< FPCCR: ASPEN bit Mask */
+
+#define FPU_FPCCR_LSPEN_Pos                30U                                            /*!< FPCCR: LSPEN Position */
+#define FPU_FPCCR_LSPEN_Msk                (1UL << FPU_FPCCR_LSPEN_Pos)                   /*!< FPCCR: LSPEN bit Mask */
+
+#define FPU_FPCCR_LSPENS_Pos               29U                                            /*!< FPCCR: LSPENS Position */
+#define FPU_FPCCR_LSPENS_Msk               (1UL << FPU_FPCCR_LSPENS_Pos)                  /*!< FPCCR: LSPENS bit Mask */
+
+#define FPU_FPCCR_CLRONRET_Pos             28U                                            /*!< FPCCR: CLRONRET Position */
+#define FPU_FPCCR_CLRONRET_Msk             (1UL << FPU_FPCCR_CLRONRET_Pos)                /*!< FPCCR: CLRONRET bit Mask */
+
+#define FPU_FPCCR_CLRONRETS_Pos            27U                                            /*!< FPCCR: CLRONRETS Position */
+#define FPU_FPCCR_CLRONRETS_Msk            (1UL << FPU_FPCCR_CLRONRETS_Pos)               /*!< FPCCR: CLRONRETS bit Mask */
+
+#define FPU_FPCCR_TS_Pos                   26U                                            /*!< FPCCR: TS Position */
+#define FPU_FPCCR_TS_Msk                   (1UL << FPU_FPCCR_TS_Pos)                      /*!< FPCCR: TS bit Mask */
+
+#define FPU_FPCCR_UFRDY_Pos                10U                                            /*!< FPCCR: UFRDY Position */
+#define FPU_FPCCR_UFRDY_Msk                (1UL << FPU_FPCCR_UFRDY_Pos)                   /*!< FPCCR: UFRDY bit Mask */
+
+#define FPU_FPCCR_SPLIMVIOL_Pos             9U                                            /*!< FPCCR: SPLIMVIOL Position */
+#define FPU_FPCCR_SPLIMVIOL_Msk            (1UL << FPU_FPCCR_SPLIMVIOL_Pos)               /*!< FPCCR: SPLIMVIOL bit Mask */
+
+#define FPU_FPCCR_MONRDY_Pos                8U                                            /*!< FPCCR: MONRDY Position */
+#define FPU_FPCCR_MONRDY_Msk               (1UL << FPU_FPCCR_MONRDY_Pos)                  /*!< FPCCR: MONRDY bit Mask */
+
+#define FPU_FPCCR_SFRDY_Pos                 7U                                            /*!< FPCCR: SFRDY Position */
+#define FPU_FPCCR_SFRDY_Msk                (1UL << FPU_FPCCR_SFRDY_Pos)                   /*!< FPCCR: SFRDY bit Mask */
+
+#define FPU_FPCCR_BFRDY_Pos                 6U                                            /*!< FPCCR: BFRDY Position */
+#define FPU_FPCCR_BFRDY_Msk                (1UL << FPU_FPCCR_BFRDY_Pos)                   /*!< FPCCR: BFRDY bit Mask */
+
+#define FPU_FPCCR_MMRDY_Pos                 5U                                            /*!< FPCCR: MMRDY Position */
+#define FPU_FPCCR_MMRDY_Msk                (1UL << FPU_FPCCR_MMRDY_Pos)                   /*!< FPCCR: MMRDY bit Mask */
+
+#define FPU_FPCCR_HFRDY_Pos                 4U                                            /*!< FPCCR: HFRDY Position */
+#define FPU_FPCCR_HFRDY_Msk                (1UL << FPU_FPCCR_HFRDY_Pos)                   /*!< FPCCR: HFRDY bit Mask */
+
+#define FPU_FPCCR_THREAD_Pos                3U                                            /*!< FPCCR: processor mode bit Position */
+#define FPU_FPCCR_THREAD_Msk               (1UL << FPU_FPCCR_THREAD_Pos)                  /*!< FPCCR: processor mode active bit Mask */
+
+#define FPU_FPCCR_S_Pos                     2U                                            /*!< FPCCR: Security status of the FP context bit Position */
+#define FPU_FPCCR_S_Msk                    (1UL << FPU_FPCCR_S_Pos)                       /*!< FPCCR: Security status of the FP context bit Mask */
+
+#define FPU_FPCCR_USER_Pos                  1U                                            /*!< FPCCR: privilege level bit Position */
+#define FPU_FPCCR_USER_Msk                 (1UL << FPU_FPCCR_USER_Pos)                    /*!< FPCCR: privilege level bit Mask */
+
+#define FPU_FPCCR_LSPACT_Pos                0U                                            /*!< FPCCR: Lazy state preservation active bit Position */
+#define FPU_FPCCR_LSPACT_Msk               (1UL /*<< FPU_FPCCR_LSPACT_Pos*/)              /*!< FPCCR: Lazy state preservation active bit Mask */
+
+/* Floating-Point Context Address Register Definitions */
+#define FPU_FPCAR_ADDRESS_Pos               3U                                            /*!< FPCAR: ADDRESS bit Position */
+#define FPU_FPCAR_ADDRESS_Msk              (0x1FFFFFFFUL << FPU_FPCAR_ADDRESS_Pos)        /*!< FPCAR: ADDRESS bit Mask */
+
+/* Floating-Point Default Status Control Register Definitions */
+#define FPU_FPDSCR_AHP_Pos                 26U                                            /*!< FPDSCR: AHP bit Position */
+#define FPU_FPDSCR_AHP_Msk                 (1UL << FPU_FPDSCR_AHP_Pos)                    /*!< FPDSCR: AHP bit Mask */
+
+#define FPU_FPDSCR_DN_Pos                  25U                                            /*!< FPDSCR: DN bit Position */
+#define FPU_FPDSCR_DN_Msk                  (1UL << FPU_FPDSCR_DN_Pos)                     /*!< FPDSCR: DN bit Mask */
+
+#define FPU_FPDSCR_FZ_Pos                  24U                                            /*!< FPDSCR: FZ bit Position */
+#define FPU_FPDSCR_FZ_Msk                  (1UL << FPU_FPDSCR_FZ_Pos)                     /*!< FPDSCR: FZ bit Mask */
+
+#define FPU_FPDSCR_RMode_Pos               22U                                            /*!< FPDSCR: RMode bit Position */
+#define FPU_FPDSCR_RMode_Msk               (3UL << FPU_FPDSCR_RMode_Pos)                  /*!< FPDSCR: RMode bit Mask */
+
+/* Media and FP Feature Register 0 Definitions */
+#define FPU_MVFR0_FP_rounding_modes_Pos    28U                                            /*!< MVFR0: FP rounding modes bits Position */
+#define FPU_MVFR0_FP_rounding_modes_Msk    (0xFUL << FPU_MVFR0_FP_rounding_modes_Pos)     /*!< MVFR0: FP rounding modes bits Mask */
+
+#define FPU_MVFR0_Short_vectors_Pos        24U                                            /*!< MVFR0: Short vectors bits Position */
+#define FPU_MVFR0_Short_vectors_Msk        (0xFUL << FPU_MVFR0_Short_vectors_Pos)         /*!< MVFR0: Short vectors bits Mask */
+
+#define FPU_MVFR0_Square_root_Pos          20U                                            /*!< MVFR0: Square root bits Position */
+#define FPU_MVFR0_Square_root_Msk          (0xFUL << FPU_MVFR0_Square_root_Pos)           /*!< MVFR0: Square root bits Mask */
+
+#define FPU_MVFR0_Divide_Pos               16U                                            /*!< MVFR0: Divide bits Position */
+#define FPU_MVFR0_Divide_Msk               (0xFUL << FPU_MVFR0_Divide_Pos)                /*!< MVFR0: Divide bits Mask */
+
+#define FPU_MVFR0_FP_excep_trapping_Pos    12U                                            /*!< MVFR0: FP exception trapping bits Position */
+#define FPU_MVFR0_FP_excep_trapping_Msk    (0xFUL << FPU_MVFR0_FP_excep_trapping_Pos)     /*!< MVFR0: FP exception trapping bits Mask */
+
+#define FPU_MVFR0_Double_precision_Pos      8U                                            /*!< MVFR0: Double-precision bits Position */
+#define FPU_MVFR0_Double_precision_Msk     (0xFUL << FPU_MVFR0_Double_precision_Pos)      /*!< MVFR0: Double-precision bits Mask */
+
+#define FPU_MVFR0_Single_precision_Pos      4U                                            /*!< MVFR0: Single-precision bits Position */
+#define FPU_MVFR0_Single_precision_Msk     (0xFUL << FPU_MVFR0_Single_precision_Pos)      /*!< MVFR0: Single-precision bits Mask */
+
+#define FPU_MVFR0_A_SIMD_registers_Pos      0U                                            /*!< MVFR0: A_SIMD registers bits Position */
+#define FPU_MVFR0_A_SIMD_registers_Msk     (0xFUL /*<< FPU_MVFR0_A_SIMD_registers_Pos*/)  /*!< MVFR0: A_SIMD registers bits Mask */
+
+/* Media and FP Feature Register 1 Definitions */
+#define FPU_MVFR1_FP_fused_MAC_Pos         28U                                            /*!< MVFR1: FP fused MAC bits Position */
+#define FPU_MVFR1_FP_fused_MAC_Msk         (0xFUL << FPU_MVFR1_FP_fused_MAC_Pos)          /*!< MVFR1: FP fused MAC bits Mask */
+
+#define FPU_MVFR1_FP_HPFP_Pos              24U                                            /*!< MVFR1: FP HPFP bits Position */
+#define FPU_MVFR1_FP_HPFP_Msk              (0xFUL << FPU_MVFR1_FP_HPFP_Pos)               /*!< MVFR1: FP HPFP bits Mask */
+
+#define FPU_MVFR1_D_NaN_mode_Pos            4U                                            /*!< MVFR1: D_NaN mode bits Position */
+#define FPU_MVFR1_D_NaN_mode_Msk           (0xFUL << FPU_MVFR1_D_NaN_mode_Pos)            /*!< MVFR1: D_NaN mode bits Mask */
+
+#define FPU_MVFR1_FtZ_mode_Pos              0U                                            /*!< MVFR1: FtZ mode bits Position */
+#define FPU_MVFR1_FtZ_mode_Msk             (0xFUL /*<< FPU_MVFR1_FtZ_mode_Pos*/)          /*!< MVFR1: FtZ mode bits Mask */
+
+/*@} end of group CMSIS_FPU */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_CoreDebug       Core Debug Registers (CoreDebug)
+  \brief    Type definitions for the Core Debug Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Core Debug Register (CoreDebug).
+ */
+typedef struct
+{
+  __IOM uint32_t DHCSR;                  /*!< Offset: 0x000 (R/W)  Debug Halting Control and Status Register */
+  __OM  uint32_t DCRSR;                  /*!< Offset: 0x004 ( /W)  Debug Core Register Selector Register */
+  __IOM uint32_t DCRDR;                  /*!< Offset: 0x008 (R/W)  Debug Core Register Data Register */
+  __IOM uint32_t DEMCR;                  /*!< Offset: 0x00C (R/W)  Debug Exception and Monitor Control Register */
+        uint32_t RESERVED4[1U];
+  __IOM uint32_t DAUTHCTRL;              /*!< Offset: 0x014 (R/W)  Debug Authentication Control Register */
+  __IOM uint32_t DSCSR;                  /*!< Offset: 0x018 (R/W)  Debug Security Control and Status Register */
+} CoreDebug_Type;
+
+/* Debug Halting Control and Status Register Definitions */
+#define CoreDebug_DHCSR_DBGKEY_Pos         16U                                            /*!< CoreDebug DHCSR: DBGKEY Position */
+#define CoreDebug_DHCSR_DBGKEY_Msk         (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos)       /*!< CoreDebug DHCSR: DBGKEY Mask */
+
+#define CoreDebug_DHCSR_S_RESTART_ST_Pos   26U                                            /*!< CoreDebug DHCSR: S_RESTART_ST Position */
+#define CoreDebug_DHCSR_S_RESTART_ST_Msk   (1UL << CoreDebug_DHCSR_S_RESTART_ST_Pos)      /*!< CoreDebug DHCSR: S_RESTART_ST Mask */
+
+#define CoreDebug_DHCSR_S_RESET_ST_Pos     25U                                            /*!< CoreDebug DHCSR: S_RESET_ST Position */
+#define CoreDebug_DHCSR_S_RESET_ST_Msk     (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos)        /*!< CoreDebug DHCSR: S_RESET_ST Mask */
+
+#define CoreDebug_DHCSR_S_RETIRE_ST_Pos    24U                                            /*!< CoreDebug DHCSR: S_RETIRE_ST Position */
+#define CoreDebug_DHCSR_S_RETIRE_ST_Msk    (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos)       /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */
+
+#define CoreDebug_DHCSR_S_LOCKUP_Pos       19U                                            /*!< CoreDebug DHCSR: S_LOCKUP Position */
+#define CoreDebug_DHCSR_S_LOCKUP_Msk       (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos)          /*!< CoreDebug DHCSR: S_LOCKUP Mask */
+
+#define CoreDebug_DHCSR_S_SLEEP_Pos        18U                                            /*!< CoreDebug DHCSR: S_SLEEP Position */
+#define CoreDebug_DHCSR_S_SLEEP_Msk        (1UL << CoreDebug_DHCSR_S_SLEEP_Pos)           /*!< CoreDebug DHCSR: S_SLEEP Mask */
+
+#define CoreDebug_DHCSR_S_HALT_Pos         17U                                            /*!< CoreDebug DHCSR: S_HALT Position */
+#define CoreDebug_DHCSR_S_HALT_Msk         (1UL << CoreDebug_DHCSR_S_HALT_Pos)            /*!< CoreDebug DHCSR: S_HALT Mask */
+
+#define CoreDebug_DHCSR_S_REGRDY_Pos       16U                                            /*!< CoreDebug DHCSR: S_REGRDY Position */
+#define CoreDebug_DHCSR_S_REGRDY_Msk       (1UL << CoreDebug_DHCSR_S_REGRDY_Pos)          /*!< CoreDebug DHCSR: S_REGRDY Mask */
+
+#define CoreDebug_DHCSR_C_SNAPSTALL_Pos     5U                                            /*!< CoreDebug DHCSR: C_SNAPSTALL Position */
+#define CoreDebug_DHCSR_C_SNAPSTALL_Msk    (1UL << CoreDebug_DHCSR_C_SNAPSTALL_Pos)       /*!< CoreDebug DHCSR: C_SNAPSTALL Mask */
+
+#define CoreDebug_DHCSR_C_MASKINTS_Pos      3U                                            /*!< CoreDebug DHCSR: C_MASKINTS Position */
+#define CoreDebug_DHCSR_C_MASKINTS_Msk     (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos)        /*!< CoreDebug DHCSR: C_MASKINTS Mask */
+
+#define CoreDebug_DHCSR_C_STEP_Pos          2U                                            /*!< CoreDebug DHCSR: C_STEP Position */
+#define CoreDebug_DHCSR_C_STEP_Msk         (1UL << CoreDebug_DHCSR_C_STEP_Pos)            /*!< CoreDebug DHCSR: C_STEP Mask */
+
+#define CoreDebug_DHCSR_C_HALT_Pos          1U                                            /*!< CoreDebug DHCSR: C_HALT Position */
+#define CoreDebug_DHCSR_C_HALT_Msk         (1UL << CoreDebug_DHCSR_C_HALT_Pos)            /*!< CoreDebug DHCSR: C_HALT Mask */
+
+#define CoreDebug_DHCSR_C_DEBUGEN_Pos       0U                                            /*!< CoreDebug DHCSR: C_DEBUGEN Position */
+#define CoreDebug_DHCSR_C_DEBUGEN_Msk      (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/)     /*!< CoreDebug DHCSR: C_DEBUGEN Mask */
+
+/* Debug Core Register Selector Register Definitions */
+#define CoreDebug_DCRSR_REGWnR_Pos         16U                                            /*!< CoreDebug DCRSR: REGWnR Position */
+#define CoreDebug_DCRSR_REGWnR_Msk         (1UL << CoreDebug_DCRSR_REGWnR_Pos)            /*!< CoreDebug DCRSR: REGWnR Mask */
+
+#define CoreDebug_DCRSR_REGSEL_Pos          0U                                            /*!< CoreDebug DCRSR: REGSEL Position */
+#define CoreDebug_DCRSR_REGSEL_Msk         (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/)     /*!< CoreDebug DCRSR: REGSEL Mask */
+
+/* Debug Exception and Monitor Control Register Definitions */
+#define CoreDebug_DEMCR_TRCENA_Pos         24U                                            /*!< CoreDebug DEMCR: TRCENA Position */
+#define CoreDebug_DEMCR_TRCENA_Msk         (1UL << CoreDebug_DEMCR_TRCENA_Pos)            /*!< CoreDebug DEMCR: TRCENA Mask */
+
+#define CoreDebug_DEMCR_MON_REQ_Pos        19U                                            /*!< CoreDebug DEMCR: MON_REQ Position */
+#define CoreDebug_DEMCR_MON_REQ_Msk        (1UL << CoreDebug_DEMCR_MON_REQ_Pos)           /*!< CoreDebug DEMCR: MON_REQ Mask */
+
+#define CoreDebug_DEMCR_MON_STEP_Pos       18U                                            /*!< CoreDebug DEMCR: MON_STEP Position */
+#define CoreDebug_DEMCR_MON_STEP_Msk       (1UL << CoreDebug_DEMCR_MON_STEP_Pos)          /*!< CoreDebug DEMCR: MON_STEP Mask */
+
+#define CoreDebug_DEMCR_MON_PEND_Pos       17U                                            /*!< CoreDebug DEMCR: MON_PEND Position */
+#define CoreDebug_DEMCR_MON_PEND_Msk       (1UL << CoreDebug_DEMCR_MON_PEND_Pos)          /*!< CoreDebug DEMCR: MON_PEND Mask */
+
+#define CoreDebug_DEMCR_MON_EN_Pos         16U                                            /*!< CoreDebug DEMCR: MON_EN Position */
+#define CoreDebug_DEMCR_MON_EN_Msk         (1UL << CoreDebug_DEMCR_MON_EN_Pos)            /*!< CoreDebug DEMCR: MON_EN Mask */
+
+#define CoreDebug_DEMCR_VC_HARDERR_Pos     10U                                            /*!< CoreDebug DEMCR: VC_HARDERR Position */
+#define CoreDebug_DEMCR_VC_HARDERR_Msk     (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos)        /*!< CoreDebug DEMCR: VC_HARDERR Mask */
+
+#define CoreDebug_DEMCR_VC_INTERR_Pos       9U                                            /*!< CoreDebug DEMCR: VC_INTERR Position */
+#define CoreDebug_DEMCR_VC_INTERR_Msk      (1UL << CoreDebug_DEMCR_VC_INTERR_Pos)         /*!< CoreDebug DEMCR: VC_INTERR Mask */
+
+#define CoreDebug_DEMCR_VC_BUSERR_Pos       8U                                            /*!< CoreDebug DEMCR: VC_BUSERR Position */
+#define CoreDebug_DEMCR_VC_BUSERR_Msk      (1UL << CoreDebug_DEMCR_VC_BUSERR_Pos)         /*!< CoreDebug DEMCR: VC_BUSERR Mask */
+
+#define CoreDebug_DEMCR_VC_STATERR_Pos      7U                                            /*!< CoreDebug DEMCR: VC_STATERR Position */
+#define CoreDebug_DEMCR_VC_STATERR_Msk     (1UL << CoreDebug_DEMCR_VC_STATERR_Pos)        /*!< CoreDebug DEMCR: VC_STATERR Mask */
+
+#define CoreDebug_DEMCR_VC_CHKERR_Pos       6U                                            /*!< CoreDebug DEMCR: VC_CHKERR Position */
+#define CoreDebug_DEMCR_VC_CHKERR_Msk      (1UL << CoreDebug_DEMCR_VC_CHKERR_Pos)         /*!< CoreDebug DEMCR: VC_CHKERR Mask */
+
+#define CoreDebug_DEMCR_VC_NOCPERR_Pos      5U                                            /*!< CoreDebug DEMCR: VC_NOCPERR Position */
+#define CoreDebug_DEMCR_VC_NOCPERR_Msk     (1UL << CoreDebug_DEMCR_VC_NOCPERR_Pos)        /*!< CoreDebug DEMCR: VC_NOCPERR Mask */
+
+#define CoreDebug_DEMCR_VC_MMERR_Pos        4U                                            /*!< CoreDebug DEMCR: VC_MMERR Position */
+#define CoreDebug_DEMCR_VC_MMERR_Msk       (1UL << CoreDebug_DEMCR_VC_MMERR_Pos)          /*!< CoreDebug DEMCR: VC_MMERR Mask */
+
+#define CoreDebug_DEMCR_VC_CORERESET_Pos    0U                                            /*!< CoreDebug DEMCR: VC_CORERESET Position */
+#define CoreDebug_DEMCR_VC_CORERESET_Msk   (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/)  /*!< CoreDebug DEMCR: VC_CORERESET Mask */
+
+/* Debug Authentication Control Register Definitions */
+#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos  3U                                            /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Position */
+#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos)    /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Mask */
+
+#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos  2U                                            /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Position */
+#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Msk (1UL << CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos)    /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Mask */
+
+#define CoreDebug_DAUTHCTRL_INTSPIDEN_Pos   1U                                            /*!< CoreDebug DAUTHCTRL: INTSPIDEN Position */
+#define CoreDebug_DAUTHCTRL_INTSPIDEN_Msk  (1UL << CoreDebug_DAUTHCTRL_INTSPIDEN_Pos)     /*!< CoreDebug DAUTHCTRL: INTSPIDEN Mask */
+
+#define CoreDebug_DAUTHCTRL_SPIDENSEL_Pos   0U                                            /*!< CoreDebug DAUTHCTRL: SPIDENSEL Position */
+#define CoreDebug_DAUTHCTRL_SPIDENSEL_Msk  (1UL /*<< CoreDebug_DAUTHCTRL_SPIDENSEL_Pos*/) /*!< CoreDebug DAUTHCTRL: SPIDENSEL Mask */
+
+/* Debug Security Control and Status Register Definitions */
+#define CoreDebug_DSCSR_CDS_Pos            16U                                            /*!< CoreDebug DSCSR: CDS Position */
+#define CoreDebug_DSCSR_CDS_Msk            (1UL << CoreDebug_DSCSR_CDS_Pos)               /*!< CoreDebug DSCSR: CDS Mask */
+
+#define CoreDebug_DSCSR_SBRSEL_Pos          1U                                            /*!< CoreDebug DSCSR: SBRSEL Position */
+#define CoreDebug_DSCSR_SBRSEL_Msk         (1UL << CoreDebug_DSCSR_SBRSEL_Pos)            /*!< CoreDebug DSCSR: SBRSEL Mask */
+
+#define CoreDebug_DSCSR_SBRSELEN_Pos        0U                                            /*!< CoreDebug DSCSR: SBRSELEN Position */
+#define CoreDebug_DSCSR_SBRSELEN_Msk       (1UL /*<< CoreDebug_DSCSR_SBRSELEN_Pos*/)      /*!< CoreDebug DSCSR: SBRSELEN Mask */
+
+/*@} end of group CMSIS_CoreDebug */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_core_bitfield     Core register bit field macros
+  \brief      Macros for use with bit field definitions (xxx_Pos, xxx_Msk).
+  @{
+ */
+
+/**
+  \brief   Mask and shift a bit field value for use in a register bit range.
+  \param[in] field  Name of the register bit field.
+  \param[in] value  Value of the bit field. This parameter is interpreted as an uint32_t type.
+  \return           Masked and shifted value.
+*/
+#define _VAL2FLD(field, value)    (((uint32_t)(value) << field ## _Pos) & field ## _Msk)
+
+/**
+  \brief     Mask and shift a register value to extract a bit filed value.
+  \param[in] field  Name of the register bit field.
+  \param[in] value  Value of register. This parameter is interpreted as an uint32_t type.
+  \return           Masked and shifted bit field value.
+*/
+#define _FLD2VAL(field, value)    (((uint32_t)(value) & field ## _Msk) >> field ## _Pos)
+
+/*@} end of group CMSIS_core_bitfield */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_core_base     Core Definitions
+  \brief      Definitions for base addresses, unions, and structures.
+  @{
+ */
+
+/* Memory mapping of Core Hardware */
+  #define SCS_BASE            (0xE000E000UL)                             /*!< System Control Space Base Address */
+  #define ITM_BASE            (0xE0000000UL)                             /*!< ITM Base Address */
+  #define DWT_BASE            (0xE0001000UL)                             /*!< DWT Base Address */
+  #define TPI_BASE            (0xE0040000UL)                             /*!< TPI Base Address */
+  #define CoreDebug_BASE      (0xE000EDF0UL)                             /*!< Core Debug Base Address */
+  #define SysTick_BASE        (SCS_BASE +  0x0010UL)                     /*!< SysTick Base Address */
+  #define NVIC_BASE           (SCS_BASE +  0x0100UL)                     /*!< NVIC Base Address */
+  #define SCB_BASE            (SCS_BASE +  0x0D00UL)                     /*!< System Control Block Base Address */
+
+  #define SCnSCB              ((SCnSCB_Type    *)     SCS_BASE         ) /*!< System control Register not in SCB */
+  #define SCB                 ((SCB_Type       *)     SCB_BASE         ) /*!< SCB configuration struct */
+  #define SysTick             ((SysTick_Type   *)     SysTick_BASE     ) /*!< SysTick configuration struct */
+  #define NVIC                ((NVIC_Type      *)     NVIC_BASE        ) /*!< NVIC configuration struct */
+  #define ITM                 ((ITM_Type       *)     ITM_BASE         ) /*!< ITM configuration struct */
+  #define DWT                 ((DWT_Type       *)     DWT_BASE         ) /*!< DWT configuration struct */
+  #define TPI                 ((TPI_Type       *)     TPI_BASE         ) /*!< TPI configuration struct */
+  #define CoreDebug           ((CoreDebug_Type *)     CoreDebug_BASE   ) /*!< Core Debug configuration struct */
+
+  #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+    #define MPU_BASE          (SCS_BASE +  0x0D90UL)                     /*!< Memory Protection Unit */
+    #define MPU               ((MPU_Type       *)     MPU_BASE         ) /*!< Memory Protection Unit */
+  #endif
+
+  #if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+    #define SAU_BASE          (SCS_BASE +  0x0DD0UL)                     /*!< Security Attribution Unit */
+    #define SAU               ((SAU_Type       *)     SAU_BASE         ) /*!< Security Attribution Unit */
+  #endif
+
+  #define FPU_BASE            (SCS_BASE +  0x0F30UL)                     /*!< Floating Point Unit */
+  #define FPU                 ((FPU_Type       *)     FPU_BASE         ) /*!< Floating Point Unit */
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+  #define SCS_BASE_NS         (0xE002E000UL)                             /*!< System Control Space Base Address (non-secure address space) */
+  #define CoreDebug_BASE_NS   (0xE002EDF0UL)                             /*!< Core Debug Base Address           (non-secure address space) */
+  #define SysTick_BASE_NS     (SCS_BASE_NS +  0x0010UL)                  /*!< SysTick Base Address              (non-secure address space) */
+  #define NVIC_BASE_NS        (SCS_BASE_NS +  0x0100UL)                  /*!< NVIC Base Address                 (non-secure address space) */
+  #define SCB_BASE_NS         (SCS_BASE_NS +  0x0D00UL)                  /*!< System Control Block Base Address (non-secure address space) */
+
+  #define SCnSCB_NS           ((SCnSCB_Type    *)     SCS_BASE_NS      ) /*!< System control Register not in SCB(non-secure address space) */
+  #define SCB_NS              ((SCB_Type       *)     SCB_BASE_NS      ) /*!< SCB configuration struct          (non-secure address space) */
+  #define SysTick_NS          ((SysTick_Type   *)     SysTick_BASE_NS  ) /*!< SysTick configuration struct      (non-secure address space) */
+  #define NVIC_NS             ((NVIC_Type      *)     NVIC_BASE_NS     ) /*!< NVIC configuration struct         (non-secure address space) */
+  #define CoreDebug_NS        ((CoreDebug_Type *)     CoreDebug_BASE_NS) /*!< Core Debug configuration struct   (non-secure address space) */
+
+  #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+    #define MPU_BASE_NS       (SCS_BASE_NS +  0x0D90UL)                  /*!< Memory Protection Unit            (non-secure address space) */
+    #define MPU_NS            ((MPU_Type       *)     MPU_BASE_NS      ) /*!< Memory Protection Unit            (non-secure address space) */
+  #endif
+
+  #define FPU_BASE_NS         (SCS_BASE_NS +  0x0F30UL)                  /*!< Floating Point Unit               (non-secure address space) */
+  #define FPU_NS              ((FPU_Type       *)     FPU_BASE_NS      ) /*!< Floating Point Unit               (non-secure address space) */
+
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+/*@} */
+
+
+
+/*******************************************************************************
+ *                Hardware Abstraction Layer
+  Core Function Interface contains:
+  - Core NVIC Functions
+  - Core SysTick Functions
+  - Core Debug Functions
+  - Core Register Access Functions
+ ******************************************************************************/
+/**
+  \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference
+*/
+
+
+
+/* ##########################   NVIC functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_NVICFunctions NVIC Functions
+  \brief    Functions that manage interrupts and exceptions via the NVIC.
+  @{
+ */
+
+#ifdef CMSIS_NVIC_VIRTUAL
+  #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
+    #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
+  #endif
+  #include CMSIS_NVIC_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetPriorityGrouping    __NVIC_SetPriorityGrouping
+  #define NVIC_GetPriorityGrouping    __NVIC_GetPriorityGrouping
+  #define NVIC_EnableIRQ              __NVIC_EnableIRQ
+  #define NVIC_GetEnableIRQ           __NVIC_GetEnableIRQ
+  #define NVIC_DisableIRQ             __NVIC_DisableIRQ
+  #define NVIC_GetPendingIRQ          __NVIC_GetPendingIRQ
+  #define NVIC_SetPendingIRQ          __NVIC_SetPendingIRQ
+  #define NVIC_ClearPendingIRQ        __NVIC_ClearPendingIRQ
+  #define NVIC_GetActive              __NVIC_GetActive
+  #define NVIC_SetPriority            __NVIC_SetPriority
+  #define NVIC_GetPriority            __NVIC_GetPriority
+  #define NVIC_SystemReset            __NVIC_SystemReset
+#endif /* CMSIS_NVIC_VIRTUAL */
+
+#ifdef CMSIS_VECTAB_VIRTUAL
+  #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+    #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h"
+  #endif
+  #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetVector              __NVIC_SetVector
+  #define NVIC_GetVector              __NVIC_GetVector
+#endif  /* (CMSIS_VECTAB_VIRTUAL) */
+
+#define NVIC_USER_IRQ_OFFSET          16
+
+
+/* Special LR values for Secure/Non-Secure call handling and exception handling                                               */
+
+/* Function Return Payload (from ARMv8-M Architecture Reference Manual) LR value on entry from Secure BLXNS                   */
+#define FNC_RETURN                 (0xFEFFFFFFUL)     /* bit [0] ignored when processing a branch                             */
+
+/* The following EXC_RETURN mask values are used to evaluate the LR on exception entry */
+#define EXC_RETURN_PREFIX          (0xFF000000UL)     /* bits [31:24] set to indicate an EXC_RETURN value                     */
+#define EXC_RETURN_S               (0x00000040UL)     /* bit [6] stack used to push registers: 0=Non-secure 1=Secure          */
+#define EXC_RETURN_DCRS            (0x00000020UL)     /* bit [5] stacking rules for called registers: 0=skipped 1=saved       */
+#define EXC_RETURN_FTYPE           (0x00000010UL)     /* bit [4] allocate stack for floating-point context: 0=done 1=skipped  */
+#define EXC_RETURN_MODE            (0x00000008UL)     /* bit [3] processor mode for return: 0=Handler mode 1=Thread mode      */
+#define EXC_RETURN_SPSEL           (0x00000004UL)     /* bit [2] stack pointer used to restore context: 0=MSP 1=PSP           */
+#define EXC_RETURN_ES              (0x00000001UL)     /* bit [0] security state exception was taken to: 0=Non-secure 1=Secure */
+
+/* Integrity Signature (from ARMv8-M Architecture Reference Manual) for exception context stacking                            */
+#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)  /* Value for processors with floating-point extension:                  */
+#define EXC_INTEGRITY_SIGNATURE     (0xFEFA125AUL)     /* bit [0] SFTC must match LR bit[4] EXC_RETURN_FTYPE                   */
+#else
+#define EXC_INTEGRITY_SIGNATURE     (0xFEFA125BUL)     /* Value for processors without floating-point extension                */
+#endif
+
+
+/**
+  \brief   Set Priority Grouping
+  \details Sets the priority grouping field using the required unlock sequence.
+           The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field.
+           Only values from 0..7 are used.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]      PriorityGroup  Priority grouping field.
+ */
+__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
+{
+  uint32_t reg_value;
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);             /* only values 0..7 are used          */
+
+  reg_value  =  SCB->AIRCR;                                                   /* read old register configuration    */
+  reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change               */
+  reg_value  =  (reg_value                                   |
+                ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
+                (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos)  );              /* Insert write key and priority group */
+  SCB->AIRCR =  reg_value;
+}
+
+
+/**
+  \brief   Get Priority Grouping
+  \details Reads the priority grouping field from the NVIC Interrupt Controller.
+  \return                Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field).
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void)
+{
+  return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos));
+}
+
+
+/**
+  \brief   Enable Interrupt
+  \details Enables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Enable status
+  \details Returns a device specific interrupt enable status from the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt
+  \details Disables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
+  }
+}
+
+
+/**
+  \brief   Get Pending Interrupt
+  \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not pending.
+  \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Pending Interrupt
+  \details Sets the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Clear Pending Interrupt
+  \details Clears the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Active Interrupt
+  \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not active.
+  \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   Get Interrupt Target State
+  \details Reads the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+  \return             1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_GetTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Interrupt Target State
+  \details Sets the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+                      1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_SetTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] |=  ((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)));
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Clear Interrupt Target State
+  \details Clears the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+                      1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_ClearTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] &= ~((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)));
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+
+/**
+  \brief   Set Interrupt Priority
+  \details Sets the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]      IRQn  Interrupt number.
+  \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every processor exception.
+ */
+__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->IPR[((uint32_t)IRQn)]               = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+  else
+  {
+    SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Priority
+  \details Reads the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn  Interrupt number.
+  \return             Interrupt Priority.
+                      Value is aligned automatically to the implemented priority bits of the microcontroller.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn)
+{
+
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return(((uint32_t)NVIC->IPR[((uint32_t)IRQn)]               >> (8U - __NVIC_PRIO_BITS)));
+  }
+  else
+  {
+    return(((uint32_t)SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
+  }
+}
+
+
+/**
+  \brief   Encode Priority
+  \details Encodes the priority for an interrupt with the given priority group,
+           preemptive priority value, and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]     PriorityGroup  Used priority group.
+  \param [in]   PreemptPriority  Preemptive priority value (starting from 0).
+  \param [in]       SubPriority  Subpriority value (starting from 0).
+  \return                        Encoded priority. Value can be used in the function \ref NVIC_SetPriority().
+ */
+__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  return (
+           ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) |
+           ((SubPriority     & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL)))
+         );
+}
+
+
+/**
+  \brief   Decode Priority
+  \details Decodes an interrupt priority value with a given priority group to
+           preemptive priority value and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set.
+  \param [in]         Priority   Priority value, which can be retrieved with the function \ref NVIC_GetPriority().
+  \param [in]     PriorityGroup  Used priority group.
+  \param [out] pPreemptPriority  Preemptive priority value (starting from 0).
+  \param [out]     pSubPriority  Subpriority value (starting from 0).
+ */
+__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL);
+  *pSubPriority     = (Priority                   ) & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL);
+}
+
+
+/**
+  \brief   Set Interrupt Vector
+  \details Sets an interrupt vector in SRAM based interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+           VTOR must been relocated to SRAM before.
+  \param [in]   IRQn      Interrupt number
+  \param [in]   vector    Address of interrupt handler function
+ */
+__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
+{
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+  vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector;
+}
+
+
+/**
+  \brief   Get Interrupt Vector
+  \details Reads an interrupt vector from interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn      Interrupt number.
+  \return                 Address of interrupt handler function
+ */
+__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn)
+{
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+  return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET];
+}
+
+
+/**
+  \brief   System Reset
+  \details Initiates a system reset request to reset the MCU.
+ */
+__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void)
+{
+  __DSB();                                                          /* Ensure all outstanding memory accesses included
+                                                                       buffered write are completed before reset */
+  SCB->AIRCR  = (uint32_t)((0x5FAUL << SCB_AIRCR_VECTKEY_Pos)    |
+                           (SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) |
+                            SCB_AIRCR_SYSRESETREQ_Msk    );         /* Keep priority group unchanged */
+  __DSB();                                                          /* Ensure completion of memory access */
+
+  for(;;)                                                           /* wait until reset */
+  {
+    __NOP();
+  }
+}
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   Set Priority Grouping (non-secure)
+  \details Sets the non-secure priority grouping field when in secure state using the required unlock sequence.
+           The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field.
+           Only values from 0..7 are used.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]      PriorityGroup  Priority grouping field.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPriorityGrouping_NS(uint32_t PriorityGroup)
+{
+  uint32_t reg_value;
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);             /* only values 0..7 are used          */
+
+  reg_value  =  SCB_NS->AIRCR;                                                   /* read old register configuration    */
+  reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk));             /* clear bits to change               */
+  reg_value  =  (reg_value                                   |
+                ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
+                (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos)                      );              /* Insert write key and priority group */
+  SCB_NS->AIRCR =  reg_value;
+}
+
+
+/**
+  \brief   Get Priority Grouping (non-secure)
+  \details Reads the priority grouping field from the non-secure NVIC when in secure state.
+  \return                Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field).
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPriorityGrouping_NS(void)
+{
+  return ((uint32_t)((SCB_NS->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos));
+}
+
+
+/**
+  \brief   Enable Interrupt (non-secure)
+  \details Enables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_EnableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Enable status (non-secure)
+  \details Returns a device specific interrupt enable status from the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetEnableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt (non-secure)
+  \details Disables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_DisableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Pending Interrupt (non-secure)
+  \details Reads the NVIC pending register in the non-secure NVIC when in secure state and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not pending.
+  \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Pending Interrupt (non-secure)
+  \details Sets the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Clear Pending Interrupt (non-secure)
+  \details Clears the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_ClearPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Active Interrupt (non-secure)
+  \details Reads the active register in non-secure NVIC when in secure state and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not active.
+  \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetActive_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Interrupt Priority (non-secure)
+  \details Sets the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]      IRQn  Interrupt number.
+  \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every non-secure processor exception.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPriority_NS(IRQn_Type IRQn, uint32_t priority)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->IPR[((uint32_t)IRQn)]               = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+  else
+  {
+    SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Priority (non-secure)
+  \details Reads the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn  Interrupt number.
+  \return             Interrupt Priority. Value is aligned automatically to the implemented priority bits of the microcontroller.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPriority_NS(IRQn_Type IRQn)
+{
+
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return(((uint32_t)NVIC_NS->IPR[((uint32_t)IRQn)]               >> (8U - __NVIC_PRIO_BITS)));
+  }
+  else
+  {
+    return(((uint32_t)SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
+  }
+}
+#endif /*  defined (__ARM_FEATURE_CMSE) &&(__ARM_FEATURE_CMSE == 3U) */
+
+/*@} end of CMSIS_Core_NVICFunctions */
+
+/* ##########################  MPU functions  #################################### */
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+
+#include "mpu_armv8.h"
+
+#endif
+
+/* ##########################  FPU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_FpuFunctions FPU Functions
+  \brief    Function that provides FPU type.
+  @{
+ */
+
+/**
+  \brief   get FPU type
+  \details returns the FPU type
+  \returns
+   - \b  0: No FPU
+   - \b  1: Single precision FPU
+   - \b  2: Double + Single precision FPU
+ */
+__STATIC_INLINE uint32_t SCB_GetFPUType(void)
+{
+  uint32_t mvfr0;
+
+  mvfr0 = FPU->MVFR0;
+  if      ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x220U)
+  {
+    return 2U;           /* Double + Single precision FPU */
+  }
+  else if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x020U)
+  {
+    return 1U;           /* Single precision FPU */
+  }
+  else
+  {
+    return 0U;           /* No FPU */
+  }
+}
+
+
+/*@} end of CMSIS_Core_FpuFunctions */
+
+
+
+/* ##########################   SAU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_SAUFunctions SAU Functions
+  \brief    Functions that configure the SAU.
+  @{
+ */
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+
+/**
+  \brief   Enable SAU
+  \details Enables the Security Attribution Unit (SAU).
+ */
+__STATIC_INLINE void TZ_SAU_Enable(void)
+{
+    SAU->CTRL |=  (SAU_CTRL_ENABLE_Msk);
+}
+
+
+
+/**
+  \brief   Disable SAU
+  \details Disables the Security Attribution Unit (SAU).
+ */
+__STATIC_INLINE void TZ_SAU_Disable(void)
+{
+    SAU->CTRL &= ~(SAU_CTRL_ENABLE_Msk);
+}
+
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+/*@} end of CMSIS_Core_SAUFunctions */
+
+
+
+
+/* ##################################    SysTick function  ############################################ */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_SysTickFunctions SysTick Functions
+  \brief    Functions that configure the System.
+  @{
+ */
+
+#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
+
+/**
+  \brief   System Tick Configuration
+  \details Initializes the System Timer and its interrupt, and starts the System Tick Timer.
+           Counter is in free running mode to generate periodic interrupts.
+  \param [in]  ticks  Number of ticks between two interrupts.
+  \return          0  Function succeeded.
+  \return          1  Function failed.
+  \note    When the variable <b>__Vendor_SysTickConfig</b> is set to 1, then the
+           function <b>SysTick_Config</b> is not included. In this case, the file <b><i>device</i>.h</b>
+           must contain a vendor-specific implementation of this function.
+ */
+__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
+{
+  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
+  {
+    return (1UL);                                                   /* Reload value impossible */
+  }
+
+  SysTick->LOAD  = (uint32_t)(ticks - 1UL);                         /* set reload register */
+  NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
+  SysTick->VAL   = 0UL;                                             /* Load the SysTick Counter Value */
+  SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
+                   SysTick_CTRL_TICKINT_Msk   |
+                   SysTick_CTRL_ENABLE_Msk;                         /* Enable SysTick IRQ and SysTick Timer */
+  return (0UL);                                                     /* Function successful */
+}
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   System Tick Configuration (non-secure)
+  \details Initializes the non-secure System Timer and its interrupt when in secure state, and starts the System Tick Timer.
+           Counter is in free running mode to generate periodic interrupts.
+  \param [in]  ticks  Number of ticks between two interrupts.
+  \return          0  Function succeeded.
+  \return          1  Function failed.
+  \note    When the variable <b>__Vendor_SysTickConfig</b> is set to 1, then the
+           function <b>TZ_SysTick_Config_NS</b> is not included. In this case, the file <b><i>device</i>.h</b>
+           must contain a vendor-specific implementation of this function.
+
+ */
+__STATIC_INLINE uint32_t TZ_SysTick_Config_NS(uint32_t ticks)
+{
+  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
+  {
+    return (1UL);                                                         /* Reload value impossible */
+  }
+
+  SysTick_NS->LOAD  = (uint32_t)(ticks - 1UL);                            /* set reload register */
+  TZ_NVIC_SetPriority_NS (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
+  SysTick_NS->VAL   = 0UL;                                                /* Load the SysTick Counter Value */
+  SysTick_NS->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
+                      SysTick_CTRL_TICKINT_Msk   |
+                      SysTick_CTRL_ENABLE_Msk;                            /* Enable SysTick IRQ and SysTick Timer */
+  return (0UL);                                                           /* Function successful */
+}
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+#endif
+
+/*@} end of CMSIS_Core_SysTickFunctions */
+
+
+
+/* ##################################### Debug In/Output function ########################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_core_DebugFunctions ITM Functions
+  \brief    Functions that access the ITM debug interface.
+  @{
+ */
+
+extern volatile int32_t ITM_RxBuffer;                              /*!< External variable to receive characters. */
+#define                 ITM_RXBUFFER_EMPTY  ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */
+
+
+/**
+  \brief   ITM Send Character
+  \details Transmits a character via the ITM channel 0, and
+           \li Just returns when no debugger is connected that has booked the output.
+           \li Is blocking when a debugger is connected, but the previous character sent has not been transmitted.
+  \param [in]     ch  Character to transmit.
+  \returns            Character to transmit.
+ */
+__STATIC_INLINE uint32_t ITM_SendChar (uint32_t ch)
+{
+  if (((ITM->TCR & ITM_TCR_ITMENA_Msk) != 0UL) &&      /* ITM enabled */
+      ((ITM->TER & 1UL               ) != 0UL)   )     /* ITM Port #0 enabled */
+  {
+    while (ITM->PORT[0U].u32 == 0UL)
+    {
+      __NOP();
+    }
+    ITM->PORT[0U].u8 = (uint8_t)ch;
+  }
+  return (ch);
+}
+
+
+/**
+  \brief   ITM Receive Character
+  \details Inputs a character via the external variable \ref ITM_RxBuffer.
+  \return             Received character.
+  \return         -1  No character pending.
+ */
+__STATIC_INLINE int32_t ITM_ReceiveChar (void)
+{
+  int32_t ch = -1;                           /* no character available */
+
+  if (ITM_RxBuffer != ITM_RXBUFFER_EMPTY)
+  {
+    ch = ITM_RxBuffer;
+    ITM_RxBuffer = ITM_RXBUFFER_EMPTY;       /* ready for next character */
+  }
+
+  return (ch);
+}
+
+
+/**
+  \brief   ITM Check Character
+  \details Checks whether a character is pending for reading in the variable \ref ITM_RxBuffer.
+  \return          0  No character available.
+  \return          1  Character available.
+ */
+__STATIC_INLINE int32_t ITM_CheckChar (void)
+{
+
+  if (ITM_RxBuffer == ITM_RXBUFFER_EMPTY)
+  {
+    return (0);                              /* no character available */
+  }
+  else
+  {
+    return (1);                              /*    character available */
+  }
+}
+
+/*@} end of CMSIS_core_DebugFunctions */
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CORE_ARMV8MML_H_DEPENDANT */
+
+#endif /* __CMSIS_GENERIC */
diff --git a/lib/cmsis/inc/core_cm0.h b/lib/cmsis/inc/core_cm0.h
index 711dad5517027..fcf27578ccf59 100644
--- a/lib/cmsis/inc/core_cm0.h
+++ b/lib/cmsis/inc/core_cm0.h
@@ -1,40 +1,30 @@
 /**************************************************************************//**
  * @file     core_cm0.h
  * @brief    CMSIS Cortex-M0 Core Peripheral Access Layer Header File
- * @version  V4.30
- * @date     20. October 2015
+ * @version  V5.0.6
+ * @date     13. March 2019
  ******************************************************************************/
-/* Copyright (c) 2009 - 2015 ARM LIMITED
-
-   All rights reserved.
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-   - Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in the
-     documentation and/or other materials provided with the distribution.
-   - Neither the name of ARM nor the names of its contributors may be used
-     to endorse or promote products derived from this software without
-     specific prior written permission.
-   *
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
-   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-   POSSIBILITY OF SUCH DAMAGE.
-   ---------------------------------------------------------------------------*/
-
+/*
+ * Copyright (c) 2009-2019 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #if   defined ( __ICCARM__ )
- #pragma system_include         /* treat file as system include file for MISRA check */
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
   #pragma clang system_header   /* treat file as system include file */
 #endif
 
@@ -70,53 +60,15 @@
   @{
  */
 
+#include "cmsis_version.h"
+ 
 /*  CMSIS CM0 definitions */
-#define __CM0_CMSIS_VERSION_MAIN  (0x04U)                                      /*!< [31:16] CMSIS HAL main version */
-#define __CM0_CMSIS_VERSION_SUB   (0x1EU)                                      /*!< [15:0]  CMSIS HAL sub version */
+#define __CM0_CMSIS_VERSION_MAIN  (__CM_CMSIS_VERSION_MAIN)              /*!< \deprecated [31:16] CMSIS HAL main version */
+#define __CM0_CMSIS_VERSION_SUB   (__CM_CMSIS_VERSION_SUB)               /*!< \deprecated [15:0]  CMSIS HAL sub version */
 #define __CM0_CMSIS_VERSION       ((__CM0_CMSIS_VERSION_MAIN << 16U) | \
-                                    __CM0_CMSIS_VERSION_SUB           )        /*!< CMSIS HAL version number */
-
-#define __CORTEX_M                (0x00U)                                      /*!< Cortex-M Core */
-
-
-#if   defined ( __CC_ARM )
-  #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler */
-  #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler */
-  #define __STATIC_INLINE  static __inline
-
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler */
-  #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler */
-  #define __STATIC_INLINE  static __inline
-
-#elif defined ( __GNUC__ )
-  #define __ASM            __asm                                      /*!< asm keyword for GNU Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for GNU Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __ICCARM__ )
-  #define __ASM            __asm                                      /*!< asm keyword for IAR Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for IAR Compiler. Only available in High optimization mode! */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __TMS470__ )
-  #define __ASM            __asm                                      /*!< asm keyword for TI CCS Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __TASKING__ )
-  #define __ASM            __asm                                      /*!< asm keyword for TASKING Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for TASKING Compiler */
-  #define __STATIC_INLINE  static inline
+                                    __CM0_CMSIS_VERSION_SUB           )  /*!< \deprecated CMSIS HAL version number */
 
-#elif defined ( __CSMC__ )
-  #define __packed
-  #define __ASM            _asm                                      /*!< asm keyword for COSMIC Compiler */
-  #define __INLINE         inline                                    /*!< inline keyword for COSMIC Compiler. Use -pc99 on compile line */
-  #define __STATIC_INLINE  static inline
-
-#else
-  #error Unknown compiler
-#endif
+#define __CORTEX_M                (0U)                                   /*!< Cortex-M Core */
 
 /** __FPU_USED indicates whether an FPU is used or not.
     This core does not support an FPU at all
@@ -128,8 +80,8 @@
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #if defined __ARM_PCS_VFP
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #if defined __ARM_FP
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
@@ -143,7 +95,7 @@
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
-#elif defined ( __TMS470__ )
+#elif defined ( __TI_ARM__ )
   #if defined __TI_VFP_SUPPORT__
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
@@ -160,8 +112,8 @@
 
 #endif
 
-#include "core_cmInstr.h"                /* Core Instruction Access */
-#include "core_cmFunc.h"                 /* Core Function Access */
+#include "cmsis_compiler.h"               /* CMSIS compiler specific defines */
+
 
 #ifdef __cplusplus
 }
@@ -364,7 +316,7 @@ typedef struct
   __IOM uint32_t ISER[1U];               /*!< Offset: 0x000 (R/W)  Interrupt Set Enable Register */
         uint32_t RESERVED0[31U];
   __IOM uint32_t ICER[1U];               /*!< Offset: 0x080 (R/W)  Interrupt Clear Enable Register */
-        uint32_t RSERVED1[31U];
+        uint32_t RESERVED1[31U];
   __IOM uint32_t ISPR[1U];               /*!< Offset: 0x100 (R/W)  Interrupt Set Pending Register */
         uint32_t RESERVED2[31U];
   __IOM uint32_t ICPR[1U];               /*!< Offset: 0x180 (R/W)  Interrupt Clear Pending Register */
@@ -555,18 +507,18 @@ typedef struct
 /**
   \brief   Mask and shift a bit field value for use in a register bit range.
   \param[in] field  Name of the register bit field.
-  \param[in] value  Value of the bit field.
+  \param[in] value  Value of the bit field. This parameter is interpreted as an uint32_t type.
   \return           Masked and shifted value.
 */
-#define _VAL2FLD(field, value)    ((value << field ## _Pos) & field ## _Msk)
+#define _VAL2FLD(field, value)    (((uint32_t)(value) << field ## _Pos) & field ## _Msk)
 
 /**
   \brief     Mask and shift a register value to extract a bit filed value.
   \param[in] field  Name of the register bit field.
-  \param[in] value  Value of register.
+  \param[in] value  Value of register. This parameter is interpreted as an uint32_t type.
   \return           Masked and shifted bit field value.
 */
-#define _FLD2VAL(field, value)    ((value & field ## _Msk) >> field ## _Pos)
+#define _FLD2VAL(field, value)    (((uint32_t)(value) & field ## _Msk) >> field ## _Pos)
 
 /*@} end of group CMSIS_core_bitfield */
 
@@ -578,7 +530,7 @@ typedef struct
   @{
  */
 
-/* Memory mapping of Cortex-M0 Hardware */
+/* Memory mapping of Core Hardware */
 #define SCS_BASE            (0xE000E000UL)                            /*!< System Control Space Base Address */
 #define SysTick_BASE        (SCS_BASE +  0x0010UL)                    /*!< SysTick Base Address */
 #define NVIC_BASE           (SCS_BASE +  0x0100UL)                    /*!< NVIC Base Address */
@@ -614,87 +566,177 @@ typedef struct
   @{
  */
 
-/* Interrupt Priorities are WORD accessible only under ARMv6M                   */
+#ifdef CMSIS_NVIC_VIRTUAL
+  #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
+    #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
+  #endif
+  #include CMSIS_NVIC_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetPriorityGrouping    __NVIC_SetPriorityGrouping
+  #define NVIC_GetPriorityGrouping    __NVIC_GetPriorityGrouping
+  #define NVIC_EnableIRQ              __NVIC_EnableIRQ
+  #define NVIC_GetEnableIRQ           __NVIC_GetEnableIRQ
+  #define NVIC_DisableIRQ             __NVIC_DisableIRQ
+  #define NVIC_GetPendingIRQ          __NVIC_GetPendingIRQ
+  #define NVIC_SetPendingIRQ          __NVIC_SetPendingIRQ
+  #define NVIC_ClearPendingIRQ        __NVIC_ClearPendingIRQ
+/*#define NVIC_GetActive              __NVIC_GetActive             not available for Cortex-M0 */
+  #define NVIC_SetPriority            __NVIC_SetPriority
+  #define NVIC_GetPriority            __NVIC_GetPriority
+  #define NVIC_SystemReset            __NVIC_SystemReset
+#endif /* CMSIS_NVIC_VIRTUAL */
+
+#ifdef CMSIS_VECTAB_VIRTUAL
+  #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+    #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h"
+  #endif
+  #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetVector              __NVIC_SetVector
+  #define NVIC_GetVector              __NVIC_GetVector
+#endif  /* (CMSIS_VECTAB_VIRTUAL) */
+
+#define NVIC_USER_IRQ_OFFSET          16
+
+
+/* The following EXC_RETURN values are saved the LR on exception entry */
+#define EXC_RETURN_HANDLER         (0xFFFFFFF1UL)     /* return to Handler mode, uses MSP after return                               */
+#define EXC_RETURN_THREAD_MSP      (0xFFFFFFF9UL)     /* return to Thread mode, uses MSP after return                                */
+#define EXC_RETURN_THREAD_PSP      (0xFFFFFFFDUL)     /* return to Thread mode, uses PSP after return                                */
+
+
+/* Interrupt Priorities are WORD accessible only under Armv6-M                  */
 /* The following MACROS handle generation of the register offset and byte masks */
 #define _BIT_SHIFT(IRQn)         (  ((((uint32_t)(int32_t)(IRQn))         )      &  0x03UL) * 8UL)
 #define _SHP_IDX(IRQn)           ( (((((uint32_t)(int32_t)(IRQn)) & 0x0FUL)-8UL) >>    2UL)      )
 #define _IP_IDX(IRQn)            (   (((uint32_t)(int32_t)(IRQn))                >>    2UL)      )
 
+#define __NVIC_SetPriorityGrouping(X) (void)(X)
+#define __NVIC_GetPriorityGrouping()  (0U)
 
 /**
-  \brief   Enable External Interrupt
-  \details Enables a device-specific interrupt in the NVIC interrupt controller.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \brief   Enable Interrupt
+  \details Enables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
 {
-  NVIC->ISER[0U] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
-  \brief   Disable External Interrupt
-  \details Disables a device-specific interrupt in the NVIC interrupt controller.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \brief   Get Interrupt Enable status
+  \details Returns a device specific interrupt enable status from the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn)
 {
-  NVIC->ICER[0U] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISER[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt
+  \details Disables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
+  }
 }
 
 
 /**
   \brief   Get Pending Interrupt
-  \details Reads the pending register in the NVIC and returns the pending bit for the specified interrupt.
-  \param [in]      IRQn  Interrupt number.
+  \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
   \return             0  Interrupt status is not pending.
   \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE uint32_t NVIC_GetPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn)
 {
-  return((uint32_t)(((NVIC->ISPR[0U] & (1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISPR[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
 }
 
 
 /**
   \brief   Set Pending Interrupt
-  \details Sets the pending bit of an external interrupt.
-  \param [in]      IRQn  Interrupt number. Value cannot be negative.
+  \details Sets the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_SetPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn)
 {
-  NVIC->ISPR[0U] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
   \brief   Clear Pending Interrupt
-  \details Clears the pending bit of an external interrupt.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \details Clears the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_ClearPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn)
 {
-  NVIC->ICPR[0U] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
   \brief   Set Interrupt Priority
-  \details Sets the priority of an interrupt.
-  \note    The priority cannot be set for every core interrupt.
+  \details Sets the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
   \param [in]      IRQn  Interrupt number.
   \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every processor exception.
  */
-__STATIC_INLINE void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
+__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
 {
-  if ((int32_t)(IRQn) < 0)
+  if ((int32_t)(IRQn) >= 0)
   {
-    SCB->SHP[_SHP_IDX(IRQn)] = ((uint32_t)(SCB->SHP[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+    NVIC->IP[_IP_IDX(IRQn)]  = ((uint32_t)(NVIC->IP[_IP_IDX(IRQn)]  & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
        (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
   }
   else
   {
-    NVIC->IP[_IP_IDX(IRQn)]  = ((uint32_t)(NVIC->IP[_IP_IDX(IRQn)]  & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+    SCB->SHP[_SHP_IDX(IRQn)] = ((uint32_t)(SCB->SHP[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
        (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
   }
 }
@@ -702,32 +744,116 @@ __STATIC_INLINE void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
 
 /**
   \brief   Get Interrupt Priority
-  \details Reads the priority of an interrupt.
-           The interrupt number can be positive to specify an external (device specific) interrupt,
-           or negative to specify an internal (core) interrupt.
+  \details Reads the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
   \param [in]   IRQn  Interrupt number.
   \return             Interrupt Priority.
                       Value is aligned automatically to the implemented priority bits of the microcontroller.
  */
-__STATIC_INLINE uint32_t NVIC_GetPriority(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn)
 {
 
-  if ((int32_t)(IRQn) < 0)
+  if ((int32_t)(IRQn) >= 0)
   {
-    return((uint32_t)(((SCB->SHP[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+    return((uint32_t)(((NVIC->IP[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
   }
   else
   {
-    return((uint32_t)(((NVIC->IP[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+    return((uint32_t)(((SCB->SHP[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
   }
 }
 
 
+/**
+  \brief   Encode Priority
+  \details Encodes the priority for an interrupt with the given priority group,
+           preemptive priority value, and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]     PriorityGroup  Used priority group.
+  \param [in]   PreemptPriority  Preemptive priority value (starting from 0).
+  \param [in]       SubPriority  Subpriority value (starting from 0).
+  \return                        Encoded priority. Value can be used in the function \ref NVIC_SetPriority().
+ */
+__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  return (
+           ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) |
+           ((SubPriority     & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL)))
+         );
+}
+
+
+/**
+  \brief   Decode Priority
+  \details Decodes an interrupt priority value with a given priority group to
+           preemptive priority value and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set.
+  \param [in]         Priority   Priority value, which can be retrieved with the function \ref NVIC_GetPriority().
+  \param [in]     PriorityGroup  Used priority group.
+  \param [out] pPreemptPriority  Preemptive priority value (starting from 0).
+  \param [out]     pSubPriority  Subpriority value (starting from 0).
+ */
+__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL);
+  *pSubPriority     = (Priority                   ) & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL);
+}
+
+
+
+/**
+  \brief   Set Interrupt Vector
+  \details Sets an interrupt vector in SRAM based interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+           Address 0 must be mapped to SRAM.
+  \param [in]   IRQn      Interrupt number
+  \param [in]   vector    Address of interrupt handler function
+ */
+__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
+{
+  uint32_t vectors = 0x0U;
+  (* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)) = vector;
+}
+
+
+/**
+  \brief   Get Interrupt Vector
+  \details Reads an interrupt vector from interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn      Interrupt number.
+  \return                 Address of interrupt handler function
+ */
+__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn)
+{
+  uint32_t vectors = 0x0U;
+  return (uint32_t)(* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4));
+}
+
+
 /**
   \brief   System Reset
   \details Initiates a system reset request to reset the MCU.
  */
-__STATIC_INLINE void NVIC_SystemReset(void)
+__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void)
 {
   __DSB();                                                          /* Ensure all outstanding memory accesses included
                                                                        buffered write are completed before reset */
@@ -744,6 +870,31 @@ __STATIC_INLINE void NVIC_SystemReset(void)
 /*@} end of CMSIS_Core_NVICFunctions */
 
 
+/* ##########################  FPU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_FpuFunctions FPU Functions
+  \brief    Function that provides FPU type.
+  @{
+ */
+
+/**
+  \brief   get FPU type
+  \details returns the FPU type
+  \returns
+   - \b  0: No FPU
+   - \b  1: Single precision FPU
+   - \b  2: Double + Single precision FPU
+ */
+__STATIC_INLINE uint32_t SCB_GetFPUType(void)
+{
+    return 0U;           /* No FPU */
+}
+
+
+/*@} end of CMSIS_Core_FpuFunctions */
+
+
 
 /* ##################################    SysTick function  ############################################ */
 /**
@@ -753,7 +904,7 @@ __STATIC_INLINE void NVIC_SystemReset(void)
   @{
  */
 
-#if (__Vendor_SysTickConfig == 0U)
+#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
 
 /**
   \brief   System Tick Configuration
diff --git a/lib/cmsis/inc/core_cm0plus.h b/lib/cmsis/inc/core_cm0plus.h
index b04aa3905323c..65ea443095f08 100644
--- a/lib/cmsis/inc/core_cm0plus.h
+++ b/lib/cmsis/inc/core_cm0plus.h
@@ -1,40 +1,30 @@
 /**************************************************************************//**
  * @file     core_cm0plus.h
  * @brief    CMSIS Cortex-M0+ Core Peripheral Access Layer Header File
- * @version  V4.30
- * @date     20. October 2015
+ * @version  V5.0.7
+ * @date     13. March 2019
  ******************************************************************************/
-/* Copyright (c) 2009 - 2015 ARM LIMITED
-
-   All rights reserved.
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-   - Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in the
-     documentation and/or other materials provided with the distribution.
-   - Neither the name of ARM nor the names of its contributors may be used
-     to endorse or promote products derived from this software without
-     specific prior written permission.
-   *
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
-   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-   POSSIBILITY OF SUCH DAMAGE.
-   ---------------------------------------------------------------------------*/
-
+/*
+ * Copyright (c) 2009-2018 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #if   defined ( __ICCARM__ )
- #pragma system_include         /* treat file as system include file for MISRA check */
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
   #pragma clang system_header   /* treat file as system include file */
 #endif
 
@@ -70,53 +60,15 @@
   @{
  */
 
+#include "cmsis_version.h"
+ 
 /*  CMSIS CM0+ definitions */
-#define __CM0PLUS_CMSIS_VERSION_MAIN (0x04U)                                   /*!< [31:16] CMSIS HAL main version */
-#define __CM0PLUS_CMSIS_VERSION_SUB  (0x1EU)                                   /*!< [15:0]  CMSIS HAL sub version */
+#define __CM0PLUS_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN)                  /*!< \deprecated [31:16] CMSIS HAL main version */
+#define __CM0PLUS_CMSIS_VERSION_SUB  (__CM_CMSIS_VERSION_SUB)                   /*!< \deprecated [15:0]  CMSIS HAL sub version */
 #define __CM0PLUS_CMSIS_VERSION      ((__CM0PLUS_CMSIS_VERSION_MAIN << 16U) | \
-                                       __CM0PLUS_CMSIS_VERSION_SUB           ) /*!< CMSIS HAL version number */
-
-#define __CORTEX_M                (0x00U)                                      /*!< Cortex-M Core */
-
-
-#if   defined ( __CC_ARM )
-  #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler */
-  #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler */
-  #define __STATIC_INLINE  static __inline
-
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler */
-  #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler */
-  #define __STATIC_INLINE  static __inline
-
-#elif defined ( __GNUC__ )
-  #define __ASM            __asm                                      /*!< asm keyword for GNU Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for GNU Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __ICCARM__ )
-  #define __ASM            __asm                                      /*!< asm keyword for IAR Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for IAR Compiler. Only available in High optimization mode! */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __TMS470__ )
-  #define __ASM            __asm                                      /*!< asm keyword for TI CCS Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __TASKING__ )
-  #define __ASM            __asm                                      /*!< asm keyword for TASKING Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for TASKING Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __CSMC__ )
-  #define __packed
-  #define __ASM            _asm                                      /*!< asm keyword for COSMIC Compiler */
-  #define __INLINE         inline                                    /*!< inline keyword for COSMIC Compiler. Use -pc99 on compile line */
-  #define __STATIC_INLINE  static inline
+                                       __CM0PLUS_CMSIS_VERSION_SUB           )  /*!< \deprecated CMSIS HAL version number */
 
-#else
-  #error Unknown compiler
-#endif
+#define __CORTEX_M                   (0U)                                       /*!< Cortex-M Core */
 
 /** __FPU_USED indicates whether an FPU is used or not.
     This core does not support an FPU at all
@@ -128,8 +80,8 @@
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #if defined __ARM_PCS_VFP
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #if defined __ARM_FP
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
@@ -143,7 +95,7 @@
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
-#elif defined ( __TMS470__ )
+#elif defined ( __TI_ARM__ )
   #if defined __TI_VFP_SUPPORT__
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
@@ -160,8 +112,8 @@
 
 #endif
 
-#include "core_cmInstr.h"                /* Core Instruction Access */
-#include "core_cmFunc.h"                 /* Core Function Access */
+#include "cmsis_compiler.h"               /* CMSIS compiler specific defines */
+
 
 #ifdef __cplusplus
 }
@@ -378,7 +330,7 @@ typedef struct
   __IOM uint32_t ISER[1U];               /*!< Offset: 0x000 (R/W)  Interrupt Set Enable Register */
         uint32_t RESERVED0[31U];
   __IOM uint32_t ICER[1U];               /*!< Offset: 0x080 (R/W)  Interrupt Clear Enable Register */
-        uint32_t RSERVED1[31U];
+        uint32_t RESERVED1[31U];
   __IOM uint32_t ISPR[1U];               /*!< Offset: 0x100 (R/W)  Interrupt Set Pending Register */
         uint32_t RESERVED2[31U];
   __IOM uint32_t ICPR[1U];               /*!< Offset: 0x180 (R/W)  Interrupt Clear Pending Register */
@@ -404,7 +356,7 @@ typedef struct
 {
   __IM  uint32_t CPUID;                  /*!< Offset: 0x000 (R/ )  CPUID Base Register */
   __IOM uint32_t ICSR;                   /*!< Offset: 0x004 (R/W)  Interrupt Control and State Register */
-#if (__VTOR_PRESENT == 1U)
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
   __IOM uint32_t VTOR;                   /*!< Offset: 0x008 (R/W)  Vector Table Offset Register */
 #else
         uint32_t RESERVED0;
@@ -461,7 +413,7 @@ typedef struct
 #define SCB_ICSR_VECTACTIVE_Pos             0U                                            /*!< SCB ICSR: VECTACTIVE Position */
 #define SCB_ICSR_VECTACTIVE_Msk            (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/)       /*!< SCB ICSR: VECTACTIVE Mask */
 
-#if (__VTOR_PRESENT == 1U)
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
 /* SCB Interrupt Control State Register Definitions */
 #define SCB_VTOR_TBLOFF_Pos                 8U                                            /*!< SCB VTOR: TBLOFF Position */
 #define SCB_VTOR_TBLOFF_Msk                (0xFFFFFFUL << SCB_VTOR_TBLOFF_Pos)            /*!< SCB VTOR: TBLOFF Mask */
@@ -558,7 +510,7 @@ typedef struct
 
 /*@} end of group CMSIS_SysTick */
 
-#if (__MPU_PRESENT == 1U)
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
 /**
   \ingroup  CMSIS_core_register
   \defgroup CMSIS_MPU     Memory Protection Unit (MPU)
@@ -578,6 +530,8 @@ typedef struct
   __IOM uint32_t RASR;                   /*!< Offset: 0x010 (R/W)  MPU Region Attribute and Size Register */
 } MPU_Type;
 
+#define MPU_TYPE_RALIASES                  1U
+
 /* MPU Type Register Definitions */
 #define MPU_TYPE_IREGION_Pos               16U                                            /*!< MPU TYPE: IREGION Position */
 #define MPU_TYPE_IREGION_Msk               (0xFFUL << MPU_TYPE_IREGION_Pos)               /*!< MPU TYPE: IREGION Mask */
@@ -667,18 +621,18 @@ typedef struct
 /**
   \brief   Mask and shift a bit field value for use in a register bit range.
   \param[in] field  Name of the register bit field.
-  \param[in] value  Value of the bit field.
+  \param[in] value  Value of the bit field. This parameter is interpreted as an uint32_t type.
   \return           Masked and shifted value.
 */
-#define _VAL2FLD(field, value)    ((value << field ## _Pos) & field ## _Msk)
+#define _VAL2FLD(field, value)    (((uint32_t)(value) << field ## _Pos) & field ## _Msk)
 
 /**
   \brief     Mask and shift a register value to extract a bit filed value.
   \param[in] field  Name of the register bit field.
-  \param[in] value  Value of register.
+  \param[in] value  Value of register. This parameter is interpreted as an uint32_t type.
   \return           Masked and shifted bit field value.
 */
-#define _FLD2VAL(field, value)    ((value & field ## _Msk) >> field ## _Pos)
+#define _FLD2VAL(field, value)    (((uint32_t)(value) & field ## _Msk) >> field ## _Pos)
 
 /*@} end of group CMSIS_core_bitfield */
 
@@ -690,7 +644,7 @@ typedef struct
   @{
  */
 
-/* Memory mapping of Cortex-M0+ Hardware */
+/* Memory mapping of Core Hardware */
 #define SCS_BASE            (0xE000E000UL)                            /*!< System Control Space Base Address */
 #define SysTick_BASE        (SCS_BASE +  0x0010UL)                    /*!< SysTick Base Address */
 #define NVIC_BASE           (SCS_BASE +  0x0100UL)                    /*!< NVIC Base Address */
@@ -700,7 +654,7 @@ typedef struct
 #define SysTick             ((SysTick_Type   *)     SysTick_BASE  )   /*!< SysTick configuration struct */
 #define NVIC                ((NVIC_Type      *)     NVIC_BASE     )   /*!< NVIC configuration struct */
 
-#if (__MPU_PRESENT == 1U)
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
   #define MPU_BASE          (SCS_BASE +  0x0D90UL)                    /*!< Memory Protection Unit */
   #define MPU               ((MPU_Type       *)     MPU_BASE      )   /*!< Memory Protection Unit */
 #endif
@@ -730,87 +684,177 @@ typedef struct
   @{
  */
 
-/* Interrupt Priorities are WORD accessible only under ARMv6M                   */
+#ifdef CMSIS_NVIC_VIRTUAL
+  #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
+    #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
+  #endif
+  #include CMSIS_NVIC_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetPriorityGrouping    __NVIC_SetPriorityGrouping
+  #define NVIC_GetPriorityGrouping    __NVIC_GetPriorityGrouping
+  #define NVIC_EnableIRQ              __NVIC_EnableIRQ
+  #define NVIC_GetEnableIRQ           __NVIC_GetEnableIRQ
+  #define NVIC_DisableIRQ             __NVIC_DisableIRQ
+  #define NVIC_GetPendingIRQ          __NVIC_GetPendingIRQ
+  #define NVIC_SetPendingIRQ          __NVIC_SetPendingIRQ
+  #define NVIC_ClearPendingIRQ        __NVIC_ClearPendingIRQ
+/*#define NVIC_GetActive              __NVIC_GetActive             not available for Cortex-M0+ */
+  #define NVIC_SetPriority            __NVIC_SetPriority
+  #define NVIC_GetPriority            __NVIC_GetPriority
+  #define NVIC_SystemReset            __NVIC_SystemReset
+#endif /* CMSIS_NVIC_VIRTUAL */
+
+#ifdef CMSIS_VECTAB_VIRTUAL
+  #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+    #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h"
+  #endif
+  #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetVector              __NVIC_SetVector
+  #define NVIC_GetVector              __NVIC_GetVector
+#endif  /* (CMSIS_VECTAB_VIRTUAL) */
+
+#define NVIC_USER_IRQ_OFFSET          16
+
+
+/* The following EXC_RETURN values are saved the LR on exception entry */
+#define EXC_RETURN_HANDLER         (0xFFFFFFF1UL)     /* return to Handler mode, uses MSP after return                               */
+#define EXC_RETURN_THREAD_MSP      (0xFFFFFFF9UL)     /* return to Thread mode, uses MSP after return                                */
+#define EXC_RETURN_THREAD_PSP      (0xFFFFFFFDUL)     /* return to Thread mode, uses PSP after return                                */
+
+
+/* Interrupt Priorities are WORD accessible only under Armv6-M                  */
 /* The following MACROS handle generation of the register offset and byte masks */
 #define _BIT_SHIFT(IRQn)         (  ((((uint32_t)(int32_t)(IRQn))         )      &  0x03UL) * 8UL)
 #define _SHP_IDX(IRQn)           ( (((((uint32_t)(int32_t)(IRQn)) & 0x0FUL)-8UL) >>    2UL)      )
 #define _IP_IDX(IRQn)            (   (((uint32_t)(int32_t)(IRQn))                >>    2UL)      )
 
+#define __NVIC_SetPriorityGrouping(X) (void)(X)
+#define __NVIC_GetPriorityGrouping()  (0U)
 
 /**
-  \brief   Enable External Interrupt
-  \details Enables a device-specific interrupt in the NVIC interrupt controller.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \brief   Enable Interrupt
+  \details Enables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
 {
-  NVIC->ISER[0U] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
-  \brief   Disable External Interrupt
-  \details Disables a device-specific interrupt in the NVIC interrupt controller.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \brief   Get Interrupt Enable status
+  \details Returns a device specific interrupt enable status from the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn)
 {
-  NVIC->ICER[0U] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISER[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt
+  \details Disables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
+  }
 }
 
 
 /**
   \brief   Get Pending Interrupt
-  \details Reads the pending register in the NVIC and returns the pending bit for the specified interrupt.
-  \param [in]      IRQn  Interrupt number.
+  \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
   \return             0  Interrupt status is not pending.
   \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE uint32_t NVIC_GetPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn)
 {
-  return((uint32_t)(((NVIC->ISPR[0U] & (1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISPR[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
 }
 
 
 /**
   \brief   Set Pending Interrupt
-  \details Sets the pending bit of an external interrupt.
-  \param [in]      IRQn  Interrupt number. Value cannot be negative.
+  \details Sets the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_SetPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn)
 {
-  NVIC->ISPR[0U] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
   \brief   Clear Pending Interrupt
-  \details Clears the pending bit of an external interrupt.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \details Clears the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_ClearPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn)
 {
-  NVIC->ICPR[0U] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
   \brief   Set Interrupt Priority
-  \details Sets the priority of an interrupt.
-  \note    The priority cannot be set for every core interrupt.
+  \details Sets the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
   \param [in]      IRQn  Interrupt number.
   \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every processor exception.
  */
-__STATIC_INLINE void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
+__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
 {
-  if ((int32_t)(IRQn) < 0)
+  if ((int32_t)(IRQn) >= 0)
   {
-    SCB->SHP[_SHP_IDX(IRQn)] = ((uint32_t)(SCB->SHP[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+    NVIC->IP[_IP_IDX(IRQn)]  = ((uint32_t)(NVIC->IP[_IP_IDX(IRQn)]  & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
        (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
   }
   else
   {
-    NVIC->IP[_IP_IDX(IRQn)]  = ((uint32_t)(NVIC->IP[_IP_IDX(IRQn)]  & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+    SCB->SHP[_SHP_IDX(IRQn)] = ((uint32_t)(SCB->SHP[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
        (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
   }
 }
@@ -818,32 +862,124 @@ __STATIC_INLINE void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
 
 /**
   \brief   Get Interrupt Priority
-  \details Reads the priority of an interrupt.
-           The interrupt number can be positive to specify an external (device specific) interrupt,
-           or negative to specify an internal (core) interrupt.
+  \details Reads the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
   \param [in]   IRQn  Interrupt number.
   \return             Interrupt Priority.
                       Value is aligned automatically to the implemented priority bits of the microcontroller.
  */
-__STATIC_INLINE uint32_t NVIC_GetPriority(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn)
 {
 
-  if ((int32_t)(IRQn) < 0)
+  if ((int32_t)(IRQn) >= 0)
   {
-    return((uint32_t)(((SCB->SHP[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+    return((uint32_t)(((NVIC->IP[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
   }
   else
   {
-    return((uint32_t)(((NVIC->IP[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+    return((uint32_t)(((SCB->SHP[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
   }
 }
 
 
+/**
+  \brief   Encode Priority
+  \details Encodes the priority for an interrupt with the given priority group,
+           preemptive priority value, and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]     PriorityGroup  Used priority group.
+  \param [in]   PreemptPriority  Preemptive priority value (starting from 0).
+  \param [in]       SubPriority  Subpriority value (starting from 0).
+  \return                        Encoded priority. Value can be used in the function \ref NVIC_SetPriority().
+ */
+__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  return (
+           ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) |
+           ((SubPriority     & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL)))
+         );
+}
+
+
+/**
+  \brief   Decode Priority
+  \details Decodes an interrupt priority value with a given priority group to
+           preemptive priority value and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set.
+  \param [in]         Priority   Priority value, which can be retrieved with the function \ref NVIC_GetPriority().
+  \param [in]     PriorityGroup  Used priority group.
+  \param [out] pPreemptPriority  Preemptive priority value (starting from 0).
+  \param [out]     pSubPriority  Subpriority value (starting from 0).
+ */
+__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL);
+  *pSubPriority     = (Priority                   ) & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL);
+}
+
+
+/**
+  \brief   Set Interrupt Vector
+  \details Sets an interrupt vector in SRAM based interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+           VTOR must been relocated to SRAM before.
+           If VTOR is not present address 0 must be mapped to SRAM.
+  \param [in]   IRQn      Interrupt number
+  \param [in]   vector    Address of interrupt handler function
+ */
+__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
+{
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  uint32_t vectors = SCB->VTOR;
+#else
+  uint32_t vectors = 0x0U;
+#endif
+  (* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)) = vector;
+}
+
+
+/**
+  \brief   Get Interrupt Vector
+  \details Reads an interrupt vector from interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn      Interrupt number.
+  \return                 Address of interrupt handler function
+ */
+__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn)
+{
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  uint32_t vectors = SCB->VTOR;
+#else
+  uint32_t vectors = 0x0U;
+#endif
+  return (uint32_t)(* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4));
+}
+
+
 /**
   \brief   System Reset
   \details Initiates a system reset request to reset the MCU.
  */
-__STATIC_INLINE void NVIC_SystemReset(void)
+__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void)
 {
   __DSB();                                                          /* Ensure all outstanding memory accesses included
                                                                        buffered write are completed before reset */
@@ -859,6 +995,38 @@ __STATIC_INLINE void NVIC_SystemReset(void)
 
 /*@} end of CMSIS_Core_NVICFunctions */
 
+/* ##########################  MPU functions  #################################### */
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+
+#include "mpu_armv7.h"
+
+#endif
+
+/* ##########################  FPU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_FpuFunctions FPU Functions
+  \brief    Function that provides FPU type.
+  @{
+ */
+
+/**
+  \brief   get FPU type
+  \details returns the FPU type
+  \returns
+   - \b  0: No FPU
+   - \b  1: Single precision FPU
+   - \b  2: Double + Single precision FPU
+ */
+__STATIC_INLINE uint32_t SCB_GetFPUType(void)
+{
+    return 0U;           /* No FPU */
+}
+
+
+/*@} end of CMSIS_Core_FpuFunctions */
+
 
 
 /* ##################################    SysTick function  ############################################ */
@@ -869,7 +1037,7 @@ __STATIC_INLINE void NVIC_SystemReset(void)
   @{
  */
 
-#if (__Vendor_SysTickConfig == 0U)
+#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
 
 /**
   \brief   System Tick Configuration
diff --git a/lib/cmsis/inc/core_cm1.h b/lib/cmsis/inc/core_cm1.h
new file mode 100644
index 0000000000000..72c515cb092e0
--- /dev/null
+++ b/lib/cmsis/inc/core_cm1.h
@@ -0,0 +1,976 @@
+/**************************************************************************//**
+ * @file     core_cm1.h
+ * @brief    CMSIS Cortex-M1 Core Peripheral Access Layer Header File
+ * @version  V1.0.1
+ * @date     12. November 2018
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2018 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if   defined ( __ICCARM__ )
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
+  #pragma clang system_header   /* treat file as system include file */
+#endif
+
+#ifndef __CORE_CM1_H_GENERIC
+#define __CORE_CM1_H_GENERIC
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/**
+  \page CMSIS_MISRA_Exceptions  MISRA-C:2004 Compliance Exceptions
+  CMSIS violates the following MISRA-C:2004 rules:
+
+   \li Required Rule 8.5, object/function definition in header file.<br>
+     Function definitions in header files are used to allow 'inlining'.
+
+   \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.<br>
+     Unions are used for effective representation of core registers.
+
+   \li Advisory Rule 19.7, Function-like macro defined.<br>
+     Function-like macros are used to allow more efficient code.
+ */
+
+
+/*******************************************************************************
+ *                 CMSIS definitions
+ ******************************************************************************/
+/**
+  \ingroup Cortex_M1
+  @{
+ */
+
+#include "cmsis_version.h"
+ 
+/*  CMSIS CM1 definitions */
+#define __CM1_CMSIS_VERSION_MAIN  (__CM_CMSIS_VERSION_MAIN)              /*!< \deprecated [31:16] CMSIS HAL main version */
+#define __CM1_CMSIS_VERSION_SUB   (__CM_CMSIS_VERSION_SUB)               /*!< \deprecated [15:0]  CMSIS HAL sub version */
+#define __CM1_CMSIS_VERSION       ((__CM1_CMSIS_VERSION_MAIN << 16U) | \
+                                    __CM1_CMSIS_VERSION_SUB           )  /*!< \deprecated CMSIS HAL version number */
+
+#define __CORTEX_M                (1U)                                   /*!< Cortex-M Core */
+
+/** __FPU_USED indicates whether an FPU is used or not.
+    This core does not support an FPU at all
+*/
+#define __FPU_USED       0U
+
+#if defined ( __CC_ARM )
+  #if defined __TARGET_FPU_VFP
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #if defined __ARM_FP
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined ( __GNUC__ )
+  #if defined (__VFP_FP__) && !defined(__SOFTFP__)
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined ( __ICCARM__ )
+  #if defined __ARMVFP__
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined ( __TI_ARM__ )
+  #if defined __TI_VFP_SUPPORT__
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined ( __TASKING__ )
+  #if defined __FPU_VFP__
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined ( __CSMC__ )
+  #if ( __CSMC__ & 0x400U)
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#endif
+
+#include "cmsis_compiler.h"               /* CMSIS compiler specific defines */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CORE_CM1_H_GENERIC */
+
+#ifndef __CMSIS_GENERIC
+
+#ifndef __CORE_CM1_H_DEPENDANT
+#define __CORE_CM1_H_DEPENDANT
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/* check device defines and use defaults */
+#if defined __CHECK_DEVICE_DEFINES
+  #ifndef __CM1_REV
+    #define __CM1_REV               0x0100U
+    #warning "__CM1_REV not defined in device header file; using default!"
+  #endif
+
+  #ifndef __NVIC_PRIO_BITS
+    #define __NVIC_PRIO_BITS          2U
+    #warning "__NVIC_PRIO_BITS not defined in device header file; using default!"
+  #endif
+
+  #ifndef __Vendor_SysTickConfig
+    #define __Vendor_SysTickConfig    0U
+    #warning "__Vendor_SysTickConfig not defined in device header file; using default!"
+  #endif
+#endif
+
+/* IO definitions (access restrictions to peripheral registers) */
+/**
+    \defgroup CMSIS_glob_defs CMSIS Global Defines
+
+    <strong>IO Type Qualifiers</strong> are used
+    \li to specify the access to peripheral variables.
+    \li for automatic generation of peripheral register debug information.
+*/
+#ifdef __cplusplus
+  #define   __I     volatile             /*!< Defines 'read only' permissions */
+#else
+  #define   __I     volatile const       /*!< Defines 'read only' permissions */
+#endif
+#define     __O     volatile             /*!< Defines 'write only' permissions */
+#define     __IO    volatile             /*!< Defines 'read / write' permissions */
+
+/* following defines should be used for structure members */
+#define     __IM     volatile const      /*! Defines 'read only' structure member permissions */
+#define     __OM     volatile            /*! Defines 'write only' structure member permissions */
+#define     __IOM    volatile            /*! Defines 'read / write' structure member permissions */
+
+/*@} end of group Cortex_M1 */
+
+
+
+/*******************************************************************************
+ *                 Register Abstraction
+  Core Register contain:
+  - Core Register
+  - Core NVIC Register
+  - Core SCB Register
+  - Core SysTick Register
+ ******************************************************************************/
+/**
+  \defgroup CMSIS_core_register Defines and Type Definitions
+  \brief Type definitions and defines for Cortex-M processor based devices.
+*/
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_CORE  Status and Control Registers
+  \brief      Core Register type definitions.
+  @{
+ */
+
+/**
+  \brief  Union type to access the Application Program Status Register (APSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t _reserved0:28;              /*!< bit:  0..27  Reserved */
+    uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
+    uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
+    uint32_t Z:1;                        /*!< bit:     30  Zero condition code flag */
+    uint32_t N:1;                        /*!< bit:     31  Negative condition code flag */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} APSR_Type;
+
+/* APSR Register Definitions */
+#define APSR_N_Pos                         31U                                            /*!< APSR: N Position */
+#define APSR_N_Msk                         (1UL << APSR_N_Pos)                            /*!< APSR: N Mask */
+
+#define APSR_Z_Pos                         30U                                            /*!< APSR: Z Position */
+#define APSR_Z_Msk                         (1UL << APSR_Z_Pos)                            /*!< APSR: Z Mask */
+
+#define APSR_C_Pos                         29U                                            /*!< APSR: C Position */
+#define APSR_C_Msk                         (1UL << APSR_C_Pos)                            /*!< APSR: C Mask */
+
+#define APSR_V_Pos                         28U                                            /*!< APSR: V Position */
+#define APSR_V_Msk                         (1UL << APSR_V_Pos)                            /*!< APSR: V Mask */
+
+
+/**
+  \brief  Union type to access the Interrupt Program Status Register (IPSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
+    uint32_t _reserved0:23;              /*!< bit:  9..31  Reserved */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} IPSR_Type;
+
+/* IPSR Register Definitions */
+#define IPSR_ISR_Pos                        0U                                            /*!< IPSR: ISR Position */
+#define IPSR_ISR_Msk                       (0x1FFUL /*<< IPSR_ISR_Pos*/)                  /*!< IPSR: ISR Mask */
+
+
+/**
+  \brief  Union type to access the Special-Purpose Program Status Registers (xPSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
+    uint32_t _reserved0:15;              /*!< bit:  9..23  Reserved */
+    uint32_t T:1;                        /*!< bit:     24  Thumb bit        (read 0) */
+    uint32_t _reserved1:3;               /*!< bit: 25..27  Reserved */
+    uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
+    uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
+    uint32_t Z:1;                        /*!< bit:     30  Zero condition code flag */
+    uint32_t N:1;                        /*!< bit:     31  Negative condition code flag */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} xPSR_Type;
+
+/* xPSR Register Definitions */
+#define xPSR_N_Pos                         31U                                            /*!< xPSR: N Position */
+#define xPSR_N_Msk                         (1UL << xPSR_N_Pos)                            /*!< xPSR: N Mask */
+
+#define xPSR_Z_Pos                         30U                                            /*!< xPSR: Z Position */
+#define xPSR_Z_Msk                         (1UL << xPSR_Z_Pos)                            /*!< xPSR: Z Mask */
+
+#define xPSR_C_Pos                         29U                                            /*!< xPSR: C Position */
+#define xPSR_C_Msk                         (1UL << xPSR_C_Pos)                            /*!< xPSR: C Mask */
+
+#define xPSR_V_Pos                         28U                                            /*!< xPSR: V Position */
+#define xPSR_V_Msk                         (1UL << xPSR_V_Pos)                            /*!< xPSR: V Mask */
+
+#define xPSR_T_Pos                         24U                                            /*!< xPSR: T Position */
+#define xPSR_T_Msk                         (1UL << xPSR_T_Pos)                            /*!< xPSR: T Mask */
+
+#define xPSR_ISR_Pos                        0U                                            /*!< xPSR: ISR Position */
+#define xPSR_ISR_Msk                       (0x1FFUL /*<< xPSR_ISR_Pos*/)                  /*!< xPSR: ISR Mask */
+
+
+/**
+  \brief  Union type to access the Control Registers (CONTROL).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t _reserved0:1;               /*!< bit:      0  Reserved */
+    uint32_t SPSEL:1;                    /*!< bit:      1  Stack to be used */
+    uint32_t _reserved1:30;              /*!< bit:  2..31  Reserved */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} CONTROL_Type;
+
+/* CONTROL Register Definitions */
+#define CONTROL_SPSEL_Pos                   1U                                            /*!< CONTROL: SPSEL Position */
+#define CONTROL_SPSEL_Msk                  (1UL << CONTROL_SPSEL_Pos)                     /*!< CONTROL: SPSEL Mask */
+
+/*@} end of group CMSIS_CORE */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_NVIC  Nested Vectored Interrupt Controller (NVIC)
+  \brief      Type definitions for the NVIC Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Nested Vectored Interrupt Controller (NVIC).
+ */
+typedef struct
+{
+  __IOM uint32_t ISER[1U];               /*!< Offset: 0x000 (R/W)  Interrupt Set Enable Register */
+        uint32_t RESERVED0[31U];
+  __IOM uint32_t ICER[1U];               /*!< Offset: 0x080 (R/W)  Interrupt Clear Enable Register */
+        uint32_t RSERVED1[31U];
+  __IOM uint32_t ISPR[1U];               /*!< Offset: 0x100 (R/W)  Interrupt Set Pending Register */
+        uint32_t RESERVED2[31U];
+  __IOM uint32_t ICPR[1U];               /*!< Offset: 0x180 (R/W)  Interrupt Clear Pending Register */
+        uint32_t RESERVED3[31U];
+        uint32_t RESERVED4[64U];
+  __IOM uint32_t IP[8U];                 /*!< Offset: 0x300 (R/W)  Interrupt Priority Register */
+}  NVIC_Type;
+
+/*@} end of group CMSIS_NVIC */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SCB     System Control Block (SCB)
+  \brief    Type definitions for the System Control Block Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Control Block (SCB).
+ */
+typedef struct
+{
+  __IM  uint32_t CPUID;                  /*!< Offset: 0x000 (R/ )  CPUID Base Register */
+  __IOM uint32_t ICSR;                   /*!< Offset: 0x004 (R/W)  Interrupt Control and State Register */
+        uint32_t RESERVED0;
+  __IOM uint32_t AIRCR;                  /*!< Offset: 0x00C (R/W)  Application Interrupt and Reset Control Register */
+  __IOM uint32_t SCR;                    /*!< Offset: 0x010 (R/W)  System Control Register */
+  __IOM uint32_t CCR;                    /*!< Offset: 0x014 (R/W)  Configuration Control Register */
+        uint32_t RESERVED1;
+  __IOM uint32_t SHP[2U];                /*!< Offset: 0x01C (R/W)  System Handlers Priority Registers. [0] is RESERVED */
+  __IOM uint32_t SHCSR;                  /*!< Offset: 0x024 (R/W)  System Handler Control and State Register */
+} SCB_Type;
+
+/* SCB CPUID Register Definitions */
+#define SCB_CPUID_IMPLEMENTER_Pos          24U                                            /*!< SCB CPUID: IMPLEMENTER Position */
+#define SCB_CPUID_IMPLEMENTER_Msk          (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos)          /*!< SCB CPUID: IMPLEMENTER Mask */
+
+#define SCB_CPUID_VARIANT_Pos              20U                                            /*!< SCB CPUID: VARIANT Position */
+#define SCB_CPUID_VARIANT_Msk              (0xFUL << SCB_CPUID_VARIANT_Pos)               /*!< SCB CPUID: VARIANT Mask */
+
+#define SCB_CPUID_ARCHITECTURE_Pos         16U                                            /*!< SCB CPUID: ARCHITECTURE Position */
+#define SCB_CPUID_ARCHITECTURE_Msk         (0xFUL << SCB_CPUID_ARCHITECTURE_Pos)          /*!< SCB CPUID: ARCHITECTURE Mask */
+
+#define SCB_CPUID_PARTNO_Pos                4U                                            /*!< SCB CPUID: PARTNO Position */
+#define SCB_CPUID_PARTNO_Msk               (0xFFFUL << SCB_CPUID_PARTNO_Pos)              /*!< SCB CPUID: PARTNO Mask */
+
+#define SCB_CPUID_REVISION_Pos              0U                                            /*!< SCB CPUID: REVISION Position */
+#define SCB_CPUID_REVISION_Msk             (0xFUL /*<< SCB_CPUID_REVISION_Pos*/)          /*!< SCB CPUID: REVISION Mask */
+
+/* SCB Interrupt Control State Register Definitions */
+#define SCB_ICSR_NMIPENDSET_Pos            31U                                            /*!< SCB ICSR: NMIPENDSET Position */
+#define SCB_ICSR_NMIPENDSET_Msk            (1UL << SCB_ICSR_NMIPENDSET_Pos)               /*!< SCB ICSR: NMIPENDSET Mask */
+
+#define SCB_ICSR_PENDSVSET_Pos             28U                                            /*!< SCB ICSR: PENDSVSET Position */
+#define SCB_ICSR_PENDSVSET_Msk             (1UL << SCB_ICSR_PENDSVSET_Pos)                /*!< SCB ICSR: PENDSVSET Mask */
+
+#define SCB_ICSR_PENDSVCLR_Pos             27U                                            /*!< SCB ICSR: PENDSVCLR Position */
+#define SCB_ICSR_PENDSVCLR_Msk             (1UL << SCB_ICSR_PENDSVCLR_Pos)                /*!< SCB ICSR: PENDSVCLR Mask */
+
+#define SCB_ICSR_PENDSTSET_Pos             26U                                            /*!< SCB ICSR: PENDSTSET Position */
+#define SCB_ICSR_PENDSTSET_Msk             (1UL << SCB_ICSR_PENDSTSET_Pos)                /*!< SCB ICSR: PENDSTSET Mask */
+
+#define SCB_ICSR_PENDSTCLR_Pos             25U                                            /*!< SCB ICSR: PENDSTCLR Position */
+#define SCB_ICSR_PENDSTCLR_Msk             (1UL << SCB_ICSR_PENDSTCLR_Pos)                /*!< SCB ICSR: PENDSTCLR Mask */
+
+#define SCB_ICSR_ISRPREEMPT_Pos            23U                                            /*!< SCB ICSR: ISRPREEMPT Position */
+#define SCB_ICSR_ISRPREEMPT_Msk            (1UL << SCB_ICSR_ISRPREEMPT_Pos)               /*!< SCB ICSR: ISRPREEMPT Mask */
+
+#define SCB_ICSR_ISRPENDING_Pos            22U                                            /*!< SCB ICSR: ISRPENDING Position */
+#define SCB_ICSR_ISRPENDING_Msk            (1UL << SCB_ICSR_ISRPENDING_Pos)               /*!< SCB ICSR: ISRPENDING Mask */
+
+#define SCB_ICSR_VECTPENDING_Pos           12U                                            /*!< SCB ICSR: VECTPENDING Position */
+#define SCB_ICSR_VECTPENDING_Msk           (0x1FFUL << SCB_ICSR_VECTPENDING_Pos)          /*!< SCB ICSR: VECTPENDING Mask */
+
+#define SCB_ICSR_VECTACTIVE_Pos             0U                                            /*!< SCB ICSR: VECTACTIVE Position */
+#define SCB_ICSR_VECTACTIVE_Msk            (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/)       /*!< SCB ICSR: VECTACTIVE Mask */
+
+/* SCB Application Interrupt and Reset Control Register Definitions */
+#define SCB_AIRCR_VECTKEY_Pos              16U                                            /*!< SCB AIRCR: VECTKEY Position */
+#define SCB_AIRCR_VECTKEY_Msk              (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos)            /*!< SCB AIRCR: VECTKEY Mask */
+
+#define SCB_AIRCR_VECTKEYSTAT_Pos          16U                                            /*!< SCB AIRCR: VECTKEYSTAT Position */
+#define SCB_AIRCR_VECTKEYSTAT_Msk          (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos)        /*!< SCB AIRCR: VECTKEYSTAT Mask */
+
+#define SCB_AIRCR_ENDIANESS_Pos            15U                                            /*!< SCB AIRCR: ENDIANESS Position */
+#define SCB_AIRCR_ENDIANESS_Msk            (1UL << SCB_AIRCR_ENDIANESS_Pos)               /*!< SCB AIRCR: ENDIANESS Mask */
+
+#define SCB_AIRCR_SYSRESETREQ_Pos           2U                                            /*!< SCB AIRCR: SYSRESETREQ Position */
+#define SCB_AIRCR_SYSRESETREQ_Msk          (1UL << SCB_AIRCR_SYSRESETREQ_Pos)             /*!< SCB AIRCR: SYSRESETREQ Mask */
+
+#define SCB_AIRCR_VECTCLRACTIVE_Pos         1U                                            /*!< SCB AIRCR: VECTCLRACTIVE Position */
+#define SCB_AIRCR_VECTCLRACTIVE_Msk        (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos)           /*!< SCB AIRCR: VECTCLRACTIVE Mask */
+
+/* SCB System Control Register Definitions */
+#define SCB_SCR_SEVONPEND_Pos               4U                                            /*!< SCB SCR: SEVONPEND Position */
+#define SCB_SCR_SEVONPEND_Msk              (1UL << SCB_SCR_SEVONPEND_Pos)                 /*!< SCB SCR: SEVONPEND Mask */
+
+#define SCB_SCR_SLEEPDEEP_Pos               2U                                            /*!< SCB SCR: SLEEPDEEP Position */
+#define SCB_SCR_SLEEPDEEP_Msk              (1UL << SCB_SCR_SLEEPDEEP_Pos)                 /*!< SCB SCR: SLEEPDEEP Mask */
+
+#define SCB_SCR_SLEEPONEXIT_Pos             1U                                            /*!< SCB SCR: SLEEPONEXIT Position */
+#define SCB_SCR_SLEEPONEXIT_Msk            (1UL << SCB_SCR_SLEEPONEXIT_Pos)               /*!< SCB SCR: SLEEPONEXIT Mask */
+
+/* SCB Configuration Control Register Definitions */
+#define SCB_CCR_STKALIGN_Pos                9U                                            /*!< SCB CCR: STKALIGN Position */
+#define SCB_CCR_STKALIGN_Msk               (1UL << SCB_CCR_STKALIGN_Pos)                  /*!< SCB CCR: STKALIGN Mask */
+
+#define SCB_CCR_UNALIGN_TRP_Pos             3U                                            /*!< SCB CCR: UNALIGN_TRP Position */
+#define SCB_CCR_UNALIGN_TRP_Msk            (1UL << SCB_CCR_UNALIGN_TRP_Pos)               /*!< SCB CCR: UNALIGN_TRP Mask */
+
+/* SCB System Handler Control and State Register Definitions */
+#define SCB_SHCSR_SVCALLPENDED_Pos         15U                                            /*!< SCB SHCSR: SVCALLPENDED Position */
+#define SCB_SHCSR_SVCALLPENDED_Msk         (1UL << SCB_SHCSR_SVCALLPENDED_Pos)            /*!< SCB SHCSR: SVCALLPENDED Mask */
+
+/*@} end of group CMSIS_SCB */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB)
+  \brief    Type definitions for the System Control and ID Register not in the SCB
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Control and ID Register not in the SCB.
+ */
+typedef struct
+{
+        uint32_t RESERVED0[2U];
+  __IOM uint32_t ACTLR;                  /*!< Offset: 0x008 (R/W)  Auxiliary Control Register */
+} SCnSCB_Type;
+
+/* Auxiliary Control Register Definitions */
+#define SCnSCB_ACTLR_ITCMUAEN_Pos            4U                                        /*!< ACTLR: Instruction TCM Upper Alias Enable Position */
+#define SCnSCB_ACTLR_ITCMUAEN_Msk           (1UL << SCnSCB_ACTLR_ITCMUAEN_Pos)         /*!< ACTLR: Instruction TCM Upper Alias Enable Mask */
+
+#define SCnSCB_ACTLR_ITCMLAEN_Pos            3U                                        /*!< ACTLR: Instruction TCM Lower Alias Enable Position */
+#define SCnSCB_ACTLR_ITCMLAEN_Msk           (1UL << SCnSCB_ACTLR_ITCMLAEN_Pos)         /*!< ACTLR: Instruction TCM Lower Alias Enable Mask */
+
+/*@} end of group CMSIS_SCnotSCB */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SysTick     System Tick Timer (SysTick)
+  \brief    Type definitions for the System Timer Registers.
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Timer (SysTick).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  SysTick Control and Status Register */
+  __IOM uint32_t LOAD;                   /*!< Offset: 0x004 (R/W)  SysTick Reload Value Register */
+  __IOM uint32_t VAL;                    /*!< Offset: 0x008 (R/W)  SysTick Current Value Register */
+  __IM  uint32_t CALIB;                  /*!< Offset: 0x00C (R/ )  SysTick Calibration Register */
+} SysTick_Type;
+
+/* SysTick Control / Status Register Definitions */
+#define SysTick_CTRL_COUNTFLAG_Pos         16U                                            /*!< SysTick CTRL: COUNTFLAG Position */
+#define SysTick_CTRL_COUNTFLAG_Msk         (1UL << SysTick_CTRL_COUNTFLAG_Pos)            /*!< SysTick CTRL: COUNTFLAG Mask */
+
+#define SysTick_CTRL_CLKSOURCE_Pos          2U                                            /*!< SysTick CTRL: CLKSOURCE Position */
+#define SysTick_CTRL_CLKSOURCE_Msk         (1UL << SysTick_CTRL_CLKSOURCE_Pos)            /*!< SysTick CTRL: CLKSOURCE Mask */
+
+#define SysTick_CTRL_TICKINT_Pos            1U                                            /*!< SysTick CTRL: TICKINT Position */
+#define SysTick_CTRL_TICKINT_Msk           (1UL << SysTick_CTRL_TICKINT_Pos)              /*!< SysTick CTRL: TICKINT Mask */
+
+#define SysTick_CTRL_ENABLE_Pos             0U                                            /*!< SysTick CTRL: ENABLE Position */
+#define SysTick_CTRL_ENABLE_Msk            (1UL /*<< SysTick_CTRL_ENABLE_Pos*/)           /*!< SysTick CTRL: ENABLE Mask */
+
+/* SysTick Reload Register Definitions */
+#define SysTick_LOAD_RELOAD_Pos             0U                                            /*!< SysTick LOAD: RELOAD Position */
+#define SysTick_LOAD_RELOAD_Msk            (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/)    /*!< SysTick LOAD: RELOAD Mask */
+
+/* SysTick Current Register Definitions */
+#define SysTick_VAL_CURRENT_Pos             0U                                            /*!< SysTick VAL: CURRENT Position */
+#define SysTick_VAL_CURRENT_Msk            (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/)    /*!< SysTick VAL: CURRENT Mask */
+
+/* SysTick Calibration Register Definitions */
+#define SysTick_CALIB_NOREF_Pos            31U                                            /*!< SysTick CALIB: NOREF Position */
+#define SysTick_CALIB_NOREF_Msk            (1UL << SysTick_CALIB_NOREF_Pos)               /*!< SysTick CALIB: NOREF Mask */
+
+#define SysTick_CALIB_SKEW_Pos             30U                                            /*!< SysTick CALIB: SKEW Position */
+#define SysTick_CALIB_SKEW_Msk             (1UL << SysTick_CALIB_SKEW_Pos)                /*!< SysTick CALIB: SKEW Mask */
+
+#define SysTick_CALIB_TENMS_Pos             0U                                            /*!< SysTick CALIB: TENMS Position */
+#define SysTick_CALIB_TENMS_Msk            (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/)    /*!< SysTick CALIB: TENMS Mask */
+
+/*@} end of group CMSIS_SysTick */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_CoreDebug       Core Debug Registers (CoreDebug)
+  \brief    Cortex-M1 Core Debug Registers (DCB registers, SHCSR, and DFSR) are only accessible over DAP and not via processor.
+            Therefore they are not covered by the Cortex-M1 header file.
+  @{
+ */
+/*@} end of group CMSIS_CoreDebug */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_core_bitfield     Core register bit field macros
+  \brief      Macros for use with bit field definitions (xxx_Pos, xxx_Msk).
+  @{
+ */
+
+/**
+  \brief   Mask and shift a bit field value for use in a register bit range.
+  \param[in] field  Name of the register bit field.
+  \param[in] value  Value of the bit field. This parameter is interpreted as an uint32_t type.
+  \return           Masked and shifted value.
+*/
+#define _VAL2FLD(field, value)    (((uint32_t)(value) << field ## _Pos) & field ## _Msk)
+
+/**
+  \brief     Mask and shift a register value to extract a bit filed value.
+  \param[in] field  Name of the register bit field.
+  \param[in] value  Value of register. This parameter is interpreted as an uint32_t type.
+  \return           Masked and shifted bit field value.
+*/
+#define _FLD2VAL(field, value)    (((uint32_t)(value) & field ## _Msk) >> field ## _Pos)
+
+/*@} end of group CMSIS_core_bitfield */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_core_base     Core Definitions
+  \brief      Definitions for base addresses, unions, and structures.
+  @{
+ */
+
+/* Memory mapping of Core Hardware */
+#define SCS_BASE            (0xE000E000UL)                            /*!< System Control Space Base Address */
+#define SysTick_BASE        (SCS_BASE +  0x0010UL)                    /*!< SysTick Base Address */
+#define NVIC_BASE           (SCS_BASE +  0x0100UL)                    /*!< NVIC Base Address */
+#define SCB_BASE            (SCS_BASE +  0x0D00UL)                    /*!< System Control Block Base Address */
+
+#define SCnSCB              ((SCnSCB_Type    *)     SCS_BASE      )   /*!< System control Register not in SCB */
+#define SCB                 ((SCB_Type       *)     SCB_BASE      )   /*!< SCB configuration struct */
+#define SysTick             ((SysTick_Type   *)     SysTick_BASE  )   /*!< SysTick configuration struct */
+#define NVIC                ((NVIC_Type      *)     NVIC_BASE     )   /*!< NVIC configuration struct */
+
+
+/*@} */
+
+
+
+/*******************************************************************************
+ *                Hardware Abstraction Layer
+  Core Function Interface contains:
+  - Core NVIC Functions
+  - Core SysTick Functions
+  - Core Register Access Functions
+ ******************************************************************************/
+/**
+  \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference
+*/
+
+
+
+/* ##########################   NVIC functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_NVICFunctions NVIC Functions
+  \brief    Functions that manage interrupts and exceptions via the NVIC.
+  @{
+ */
+
+#ifdef CMSIS_NVIC_VIRTUAL
+  #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
+    #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
+  #endif
+  #include CMSIS_NVIC_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetPriorityGrouping    __NVIC_SetPriorityGrouping
+  #define NVIC_GetPriorityGrouping    __NVIC_GetPriorityGrouping
+  #define NVIC_EnableIRQ              __NVIC_EnableIRQ
+  #define NVIC_GetEnableIRQ           __NVIC_GetEnableIRQ
+  #define NVIC_DisableIRQ             __NVIC_DisableIRQ
+  #define NVIC_GetPendingIRQ          __NVIC_GetPendingIRQ
+  #define NVIC_SetPendingIRQ          __NVIC_SetPendingIRQ
+  #define NVIC_ClearPendingIRQ        __NVIC_ClearPendingIRQ
+/*#define NVIC_GetActive              __NVIC_GetActive             not available for Cortex-M1 */
+  #define NVIC_SetPriority            __NVIC_SetPriority
+  #define NVIC_GetPriority            __NVIC_GetPriority
+  #define NVIC_SystemReset            __NVIC_SystemReset
+#endif /* CMSIS_NVIC_VIRTUAL */
+
+#ifdef CMSIS_VECTAB_VIRTUAL
+  #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+    #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h"
+  #endif
+  #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetVector              __NVIC_SetVector
+  #define NVIC_GetVector              __NVIC_GetVector
+#endif  /* (CMSIS_VECTAB_VIRTUAL) */
+
+#define NVIC_USER_IRQ_OFFSET          16
+
+
+/* The following EXC_RETURN values are saved the LR on exception entry */
+#define EXC_RETURN_HANDLER         (0xFFFFFFF1UL)     /* return to Handler mode, uses MSP after return                               */
+#define EXC_RETURN_THREAD_MSP      (0xFFFFFFF9UL)     /* return to Thread mode, uses MSP after return                                */
+#define EXC_RETURN_THREAD_PSP      (0xFFFFFFFDUL)     /* return to Thread mode, uses PSP after return                                */
+
+
+/* Interrupt Priorities are WORD accessible only under Armv6-M                  */
+/* The following MACROS handle generation of the register offset and byte masks */
+#define _BIT_SHIFT(IRQn)         (  ((((uint32_t)(int32_t)(IRQn))         )      &  0x03UL) * 8UL)
+#define _SHP_IDX(IRQn)           ( (((((uint32_t)(int32_t)(IRQn)) & 0x0FUL)-8UL) >>    2UL)      )
+#define _IP_IDX(IRQn)            (   (((uint32_t)(int32_t)(IRQn))                >>    2UL)      )
+
+#define __NVIC_SetPriorityGrouping(X) (void)(X)
+#define __NVIC_GetPriorityGrouping()  (0U)
+
+/**
+  \brief   Enable Interrupt
+  \details Enables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Enable status
+  \details Returns a device specific interrupt enable status from the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISER[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt
+  \details Disables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
+  }
+}
+
+
+/**
+  \brief   Get Pending Interrupt
+  \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not pending.
+  \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISPR[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Pending Interrupt
+  \details Sets the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Clear Pending Interrupt
+  \details Clears the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Set Interrupt Priority
+  \details Sets the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]      IRQn  Interrupt number.
+  \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every processor exception.
+ */
+__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->IP[_IP_IDX(IRQn)]  = ((uint32_t)(NVIC->IP[_IP_IDX(IRQn)]  & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+       (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
+  }
+  else
+  {
+    SCB->SHP[_SHP_IDX(IRQn)] = ((uint32_t)(SCB->SHP[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+       (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Priority
+  \details Reads the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn  Interrupt number.
+  \return             Interrupt Priority.
+                      Value is aligned automatically to the implemented priority bits of the microcontroller.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn)
+{
+
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->IP[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+  }
+  else
+  {
+    return((uint32_t)(((SCB->SHP[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+  }
+}
+
+
+/**
+  \brief   Encode Priority
+  \details Encodes the priority for an interrupt with the given priority group,
+           preemptive priority value, and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]     PriorityGroup  Used priority group.
+  \param [in]   PreemptPriority  Preemptive priority value (starting from 0).
+  \param [in]       SubPriority  Subpriority value (starting from 0).
+  \return                        Encoded priority. Value can be used in the function \ref NVIC_SetPriority().
+ */
+__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  return (
+           ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) |
+           ((SubPriority     & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL)))
+         );
+}
+
+
+/**
+  \brief   Decode Priority
+  \details Decodes an interrupt priority value with a given priority group to
+           preemptive priority value and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set.
+  \param [in]         Priority   Priority value, which can be retrieved with the function \ref NVIC_GetPriority().
+  \param [in]     PriorityGroup  Used priority group.
+  \param [out] pPreemptPriority  Preemptive priority value (starting from 0).
+  \param [out]     pSubPriority  Subpriority value (starting from 0).
+ */
+__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL);
+  *pSubPriority     = (Priority                   ) & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL);
+}
+
+
+
+/**
+  \brief   Set Interrupt Vector
+  \details Sets an interrupt vector in SRAM based interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+           Address 0 must be mapped to SRAM.
+  \param [in]   IRQn      Interrupt number
+  \param [in]   vector    Address of interrupt handler function
+ */
+__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
+{
+  uint32_t *vectors = (uint32_t *)0x0U;
+  vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector;
+}
+
+
+/**
+  \brief   Get Interrupt Vector
+  \details Reads an interrupt vector from interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn      Interrupt number.
+  \return                 Address of interrupt handler function
+ */
+__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn)
+{
+  uint32_t *vectors = (uint32_t *)0x0U;
+  return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET];
+}
+
+
+/**
+  \brief   System Reset
+  \details Initiates a system reset request to reset the MCU.
+ */
+__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void)
+{
+  __DSB();                                                          /* Ensure all outstanding memory accesses included
+                                                                       buffered write are completed before reset */
+  SCB->AIRCR  = ((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
+                 SCB_AIRCR_SYSRESETREQ_Msk);
+  __DSB();                                                          /* Ensure completion of memory access */
+
+  for(;;)                                                           /* wait until reset */
+  {
+    __NOP();
+  }
+}
+
+/*@} end of CMSIS_Core_NVICFunctions */
+
+
+/* ##########################  FPU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_FpuFunctions FPU Functions
+  \brief    Function that provides FPU type.
+  @{
+ */
+
+/**
+  \brief   get FPU type
+  \details returns the FPU type
+  \returns
+   - \b  0: No FPU
+   - \b  1: Single precision FPU
+   - \b  2: Double + Single precision FPU
+ */
+__STATIC_INLINE uint32_t SCB_GetFPUType(void)
+{
+    return 0U;           /* No FPU */
+}
+
+
+/*@} end of CMSIS_Core_FpuFunctions */
+
+
+
+/* ##################################    SysTick function  ############################################ */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_SysTickFunctions SysTick Functions
+  \brief    Functions that configure the System.
+  @{
+ */
+
+#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
+
+/**
+  \brief   System Tick Configuration
+  \details Initializes the System Timer and its interrupt, and starts the System Tick Timer.
+           Counter is in free running mode to generate periodic interrupts.
+  \param [in]  ticks  Number of ticks between two interrupts.
+  \return          0  Function succeeded.
+  \return          1  Function failed.
+  \note    When the variable <b>__Vendor_SysTickConfig</b> is set to 1, then the
+           function <b>SysTick_Config</b> is not included. In this case, the file <b><i>device</i>.h</b>
+           must contain a vendor-specific implementation of this function.
+ */
+__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
+{
+  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
+  {
+    return (1UL);                                                   /* Reload value impossible */
+  }
+
+  SysTick->LOAD  = (uint32_t)(ticks - 1UL);                         /* set reload register */
+  NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
+  SysTick->VAL   = 0UL;                                             /* Load the SysTick Counter Value */
+  SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
+                   SysTick_CTRL_TICKINT_Msk   |
+                   SysTick_CTRL_ENABLE_Msk;                         /* Enable SysTick IRQ and SysTick Timer */
+  return (0UL);                                                     /* Function successful */
+}
+
+#endif
+
+/*@} end of CMSIS_Core_SysTickFunctions */
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CORE_CM1_H_DEPENDANT */
+
+#endif /* __CMSIS_GENERIC */
diff --git a/lib/cmsis/inc/core_cm23.h b/lib/cmsis/inc/core_cm23.h
new file mode 100644
index 0000000000000..26fe163a0e82c
--- /dev/null
+++ b/lib/cmsis/inc/core_cm23.h
@@ -0,0 +1,1993 @@
+/**************************************************************************//**
+ * @file     core_cm23.h
+ * @brief    CMSIS Cortex-M23 Core Peripheral Access Layer Header File
+ * @version  V5.0.8
+ * @date     12. November 2018
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2018 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if   defined ( __ICCARM__ )
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
+  #pragma clang system_header   /* treat file as system include file */
+#endif
+
+#ifndef __CORE_CM23_H_GENERIC
+#define __CORE_CM23_H_GENERIC
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/**
+  \page CMSIS_MISRA_Exceptions  MISRA-C:2004 Compliance Exceptions
+  CMSIS violates the following MISRA-C:2004 rules:
+
+   \li Required Rule 8.5, object/function definition in header file.<br>
+     Function definitions in header files are used to allow 'inlining'.
+
+   \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.<br>
+     Unions are used for effective representation of core registers.
+
+   \li Advisory Rule 19.7, Function-like macro defined.<br>
+     Function-like macros are used to allow more efficient code.
+ */
+
+
+/*******************************************************************************
+ *                 CMSIS definitions
+ ******************************************************************************/
+/**
+  \ingroup Cortex_M23
+  @{
+ */
+
+#include "cmsis_version.h"
+
+/*  CMSIS definitions */
+#define __CM23_CMSIS_VERSION_MAIN  (__CM_CMSIS_VERSION_MAIN)                   /*!< \deprecated [31:16] CMSIS HAL main version */
+#define __CM23_CMSIS_VERSION_SUB   (__CM_CMSIS_VERSION_SUB)                    /*!< \deprecated [15:0]  CMSIS HAL sub version */
+#define __CM23_CMSIS_VERSION       ((__CM23_CMSIS_VERSION_MAIN << 16U) | \
+                                     __CM23_CMSIS_VERSION_SUB           )      /*!< \deprecated CMSIS HAL version number */
+
+#define __CORTEX_M                 (23U)                                       /*!< Cortex-M Core */
+
+/** __FPU_USED indicates whether an FPU is used or not.
+    This core does not support an FPU at all
+*/
+#define __FPU_USED       0U
+
+#if defined ( __CC_ARM )
+  #if defined __TARGET_FPU_VFP
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #if defined __ARM_FP
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined ( __GNUC__ )
+  #if defined (__VFP_FP__) && !defined(__SOFTFP__)
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined ( __ICCARM__ )
+  #if defined __ARMVFP__
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined ( __TI_ARM__ )
+  #if defined __TI_VFP_SUPPORT__
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined ( __TASKING__ )
+  #if defined __FPU_VFP__
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#elif defined ( __CSMC__ )
+  #if ( __CSMC__ & 0x400U)
+    #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+  #endif
+
+#endif
+
+#include "cmsis_compiler.h"               /* CMSIS compiler specific defines */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CORE_CM23_H_GENERIC */
+
+#ifndef __CMSIS_GENERIC
+
+#ifndef __CORE_CM23_H_DEPENDANT
+#define __CORE_CM23_H_DEPENDANT
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/* check device defines and use defaults */
+#if defined __CHECK_DEVICE_DEFINES
+  #ifndef __CM23_REV
+    #define __CM23_REV                0x0000U
+    #warning "__CM23_REV not defined in device header file; using default!"
+  #endif
+
+  #ifndef __FPU_PRESENT
+    #define __FPU_PRESENT             0U
+    #warning "__FPU_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __MPU_PRESENT
+    #define __MPU_PRESENT             0U
+    #warning "__MPU_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __SAUREGION_PRESENT
+    #define __SAUREGION_PRESENT       0U
+    #warning "__SAUREGION_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __VTOR_PRESENT
+    #define __VTOR_PRESENT            0U
+    #warning "__VTOR_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __NVIC_PRIO_BITS
+    #define __NVIC_PRIO_BITS          2U
+    #warning "__NVIC_PRIO_BITS not defined in device header file; using default!"
+  #endif
+
+  #ifndef __Vendor_SysTickConfig
+    #define __Vendor_SysTickConfig    0U
+    #warning "__Vendor_SysTickConfig not defined in device header file; using default!"
+  #endif
+
+  #ifndef __ETM_PRESENT
+    #define __ETM_PRESENT             0U
+    #warning "__ETM_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __MTB_PRESENT
+    #define __MTB_PRESENT             0U
+    #warning "__MTB_PRESENT not defined in device header file; using default!"
+  #endif
+
+#endif
+
+/* IO definitions (access restrictions to peripheral registers) */
+/**
+    \defgroup CMSIS_glob_defs CMSIS Global Defines
+
+    <strong>IO Type Qualifiers</strong> are used
+    \li to specify the access to peripheral variables.
+    \li for automatic generation of peripheral register debug information.
+*/
+#ifdef __cplusplus
+  #define   __I     volatile             /*!< Defines 'read only' permissions */
+#else
+  #define   __I     volatile const       /*!< Defines 'read only' permissions */
+#endif
+#define     __O     volatile             /*!< Defines 'write only' permissions */
+#define     __IO    volatile             /*!< Defines 'read / write' permissions */
+
+/* following defines should be used for structure members */
+#define     __IM     volatile const      /*! Defines 'read only' structure member permissions */
+#define     __OM     volatile            /*! Defines 'write only' structure member permissions */
+#define     __IOM    volatile            /*! Defines 'read / write' structure member permissions */
+
+/*@} end of group Cortex_M23 */
+
+
+
+/*******************************************************************************
+ *                 Register Abstraction
+  Core Register contain:
+  - Core Register
+  - Core NVIC Register
+  - Core SCB Register
+  - Core SysTick Register
+  - Core Debug Register
+  - Core MPU Register
+  - Core SAU Register
+ ******************************************************************************/
+/**
+  \defgroup CMSIS_core_register Defines and Type Definitions
+  \brief Type definitions and defines for Cortex-M processor based devices.
+*/
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_CORE  Status and Control Registers
+  \brief      Core Register type definitions.
+  @{
+ */
+
+/**
+  \brief  Union type to access the Application Program Status Register (APSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t _reserved0:28;              /*!< bit:  0..27  Reserved */
+    uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
+    uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
+    uint32_t Z:1;                        /*!< bit:     30  Zero condition code flag */
+    uint32_t N:1;                        /*!< bit:     31  Negative condition code flag */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} APSR_Type;
+
+/* APSR Register Definitions */
+#define APSR_N_Pos                         31U                                            /*!< APSR: N Position */
+#define APSR_N_Msk                         (1UL << APSR_N_Pos)                            /*!< APSR: N Mask */
+
+#define APSR_Z_Pos                         30U                                            /*!< APSR: Z Position */
+#define APSR_Z_Msk                         (1UL << APSR_Z_Pos)                            /*!< APSR: Z Mask */
+
+#define APSR_C_Pos                         29U                                            /*!< APSR: C Position */
+#define APSR_C_Msk                         (1UL << APSR_C_Pos)                            /*!< APSR: C Mask */
+
+#define APSR_V_Pos                         28U                                            /*!< APSR: V Position */
+#define APSR_V_Msk                         (1UL << APSR_V_Pos)                            /*!< APSR: V Mask */
+
+
+/**
+  \brief  Union type to access the Interrupt Program Status Register (IPSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
+    uint32_t _reserved0:23;              /*!< bit:  9..31  Reserved */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} IPSR_Type;
+
+/* IPSR Register Definitions */
+#define IPSR_ISR_Pos                        0U                                            /*!< IPSR: ISR Position */
+#define IPSR_ISR_Msk                       (0x1FFUL /*<< IPSR_ISR_Pos*/)                  /*!< IPSR: ISR Mask */
+
+
+/**
+  \brief  Union type to access the Special-Purpose Program Status Registers (xPSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
+    uint32_t _reserved0:15;              /*!< bit:  9..23  Reserved */
+    uint32_t T:1;                        /*!< bit:     24  Thumb bit        (read 0) */
+    uint32_t _reserved1:3;               /*!< bit: 25..27  Reserved */
+    uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
+    uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
+    uint32_t Z:1;                        /*!< bit:     30  Zero condition code flag */
+    uint32_t N:1;                        /*!< bit:     31  Negative condition code flag */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} xPSR_Type;
+
+/* xPSR Register Definitions */
+#define xPSR_N_Pos                         31U                                            /*!< xPSR: N Position */
+#define xPSR_N_Msk                         (1UL << xPSR_N_Pos)                            /*!< xPSR: N Mask */
+
+#define xPSR_Z_Pos                         30U                                            /*!< xPSR: Z Position */
+#define xPSR_Z_Msk                         (1UL << xPSR_Z_Pos)                            /*!< xPSR: Z Mask */
+
+#define xPSR_C_Pos                         29U                                            /*!< xPSR: C Position */
+#define xPSR_C_Msk                         (1UL << xPSR_C_Pos)                            /*!< xPSR: C Mask */
+
+#define xPSR_V_Pos                         28U                                            /*!< xPSR: V Position */
+#define xPSR_V_Msk                         (1UL << xPSR_V_Pos)                            /*!< xPSR: V Mask */
+
+#define xPSR_T_Pos                         24U                                            /*!< xPSR: T Position */
+#define xPSR_T_Msk                         (1UL << xPSR_T_Pos)                            /*!< xPSR: T Mask */
+
+#define xPSR_ISR_Pos                        0U                                            /*!< xPSR: ISR Position */
+#define xPSR_ISR_Msk                       (0x1FFUL /*<< xPSR_ISR_Pos*/)                  /*!< xPSR: ISR Mask */
+
+
+/**
+  \brief  Union type to access the Control Registers (CONTROL).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t nPRIV:1;                    /*!< bit:      0  Execution privilege in Thread mode */
+    uint32_t SPSEL:1;                    /*!< bit:      1  Stack-pointer select */
+    uint32_t _reserved1:30;              /*!< bit:  2..31  Reserved */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} CONTROL_Type;
+
+/* CONTROL Register Definitions */
+#define CONTROL_SPSEL_Pos                   1U                                            /*!< CONTROL: SPSEL Position */
+#define CONTROL_SPSEL_Msk                  (1UL << CONTROL_SPSEL_Pos)                     /*!< CONTROL: SPSEL Mask */
+
+#define CONTROL_nPRIV_Pos                   0U                                            /*!< CONTROL: nPRIV Position */
+#define CONTROL_nPRIV_Msk                  (1UL /*<< CONTROL_nPRIV_Pos*/)                 /*!< CONTROL: nPRIV Mask */
+
+/*@} end of group CMSIS_CORE */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_NVIC  Nested Vectored Interrupt Controller (NVIC)
+  \brief      Type definitions for the NVIC Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Nested Vectored Interrupt Controller (NVIC).
+ */
+typedef struct
+{
+  __IOM uint32_t ISER[16U];              /*!< Offset: 0x000 (R/W)  Interrupt Set Enable Register */
+        uint32_t RESERVED0[16U];
+  __IOM uint32_t ICER[16U];              /*!< Offset: 0x080 (R/W)  Interrupt Clear Enable Register */
+        uint32_t RSERVED1[16U];
+  __IOM uint32_t ISPR[16U];              /*!< Offset: 0x100 (R/W)  Interrupt Set Pending Register */
+        uint32_t RESERVED2[16U];
+  __IOM uint32_t ICPR[16U];              /*!< Offset: 0x180 (R/W)  Interrupt Clear Pending Register */
+        uint32_t RESERVED3[16U];
+  __IOM uint32_t IABR[16U];              /*!< Offset: 0x200 (R/W)  Interrupt Active bit Register */
+        uint32_t RESERVED4[16U];
+  __IOM uint32_t ITNS[16U];              /*!< Offset: 0x280 (R/W)  Interrupt Non-Secure State Register */
+        uint32_t RESERVED5[16U];
+  __IOM uint32_t IPR[124U];              /*!< Offset: 0x300 (R/W)  Interrupt Priority Register */
+}  NVIC_Type;
+
+/*@} end of group CMSIS_NVIC */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SCB     System Control Block (SCB)
+  \brief    Type definitions for the System Control Block Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Control Block (SCB).
+ */
+typedef struct
+{
+  __IM  uint32_t CPUID;                  /*!< Offset: 0x000 (R/ )  CPUID Base Register */
+  __IOM uint32_t ICSR;                   /*!< Offset: 0x004 (R/W)  Interrupt Control and State Register */
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  __IOM uint32_t VTOR;                   /*!< Offset: 0x008 (R/W)  Vector Table Offset Register */
+#else
+        uint32_t RESERVED0;
+#endif
+  __IOM uint32_t AIRCR;                  /*!< Offset: 0x00C (R/W)  Application Interrupt and Reset Control Register */
+  __IOM uint32_t SCR;                    /*!< Offset: 0x010 (R/W)  System Control Register */
+  __IOM uint32_t CCR;                    /*!< Offset: 0x014 (R/W)  Configuration Control Register */
+        uint32_t RESERVED1;
+  __IOM uint32_t SHPR[2U];               /*!< Offset: 0x01C (R/W)  System Handlers Priority Registers. [0] is RESERVED */
+  __IOM uint32_t SHCSR;                  /*!< Offset: 0x024 (R/W)  System Handler Control and State Register */
+} SCB_Type;
+
+/* SCB CPUID Register Definitions */
+#define SCB_CPUID_IMPLEMENTER_Pos          24U                                            /*!< SCB CPUID: IMPLEMENTER Position */
+#define SCB_CPUID_IMPLEMENTER_Msk          (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos)          /*!< SCB CPUID: IMPLEMENTER Mask */
+
+#define SCB_CPUID_VARIANT_Pos              20U                                            /*!< SCB CPUID: VARIANT Position */
+#define SCB_CPUID_VARIANT_Msk              (0xFUL << SCB_CPUID_VARIANT_Pos)               /*!< SCB CPUID: VARIANT Mask */
+
+#define SCB_CPUID_ARCHITECTURE_Pos         16U                                            /*!< SCB CPUID: ARCHITECTURE Position */
+#define SCB_CPUID_ARCHITECTURE_Msk         (0xFUL << SCB_CPUID_ARCHITECTURE_Pos)          /*!< SCB CPUID: ARCHITECTURE Mask */
+
+#define SCB_CPUID_PARTNO_Pos                4U                                            /*!< SCB CPUID: PARTNO Position */
+#define SCB_CPUID_PARTNO_Msk               (0xFFFUL << SCB_CPUID_PARTNO_Pos)              /*!< SCB CPUID: PARTNO Mask */
+
+#define SCB_CPUID_REVISION_Pos              0U                                            /*!< SCB CPUID: REVISION Position */
+#define SCB_CPUID_REVISION_Msk             (0xFUL /*<< SCB_CPUID_REVISION_Pos*/)          /*!< SCB CPUID: REVISION Mask */
+
+/* SCB Interrupt Control State Register Definitions */
+#define SCB_ICSR_PENDNMISET_Pos            31U                                            /*!< SCB ICSR: PENDNMISET Position */
+#define SCB_ICSR_PENDNMISET_Msk            (1UL << SCB_ICSR_PENDNMISET_Pos)               /*!< SCB ICSR: PENDNMISET Mask */
+
+#define SCB_ICSR_NMIPENDSET_Pos            SCB_ICSR_PENDNMISET_Pos                        /*!< SCB ICSR: NMIPENDSET Position, backward compatibility */
+#define SCB_ICSR_NMIPENDSET_Msk            SCB_ICSR_PENDNMISET_Msk                        /*!< SCB ICSR: NMIPENDSET Mask, backward compatibility */
+
+#define SCB_ICSR_PENDNMICLR_Pos            30U                                            /*!< SCB ICSR: PENDNMICLR Position */
+#define SCB_ICSR_PENDNMICLR_Msk            (1UL << SCB_ICSR_PENDNMICLR_Pos)               /*!< SCB ICSR: PENDNMICLR Mask */
+
+#define SCB_ICSR_PENDSVSET_Pos             28U                                            /*!< SCB ICSR: PENDSVSET Position */
+#define SCB_ICSR_PENDSVSET_Msk             (1UL << SCB_ICSR_PENDSVSET_Pos)                /*!< SCB ICSR: PENDSVSET Mask */
+
+#define SCB_ICSR_PENDSVCLR_Pos             27U                                            /*!< SCB ICSR: PENDSVCLR Position */
+#define SCB_ICSR_PENDSVCLR_Msk             (1UL << SCB_ICSR_PENDSVCLR_Pos)                /*!< SCB ICSR: PENDSVCLR Mask */
+
+#define SCB_ICSR_PENDSTSET_Pos             26U                                            /*!< SCB ICSR: PENDSTSET Position */
+#define SCB_ICSR_PENDSTSET_Msk             (1UL << SCB_ICSR_PENDSTSET_Pos)                /*!< SCB ICSR: PENDSTSET Mask */
+
+#define SCB_ICSR_PENDSTCLR_Pos             25U                                            /*!< SCB ICSR: PENDSTCLR Position */
+#define SCB_ICSR_PENDSTCLR_Msk             (1UL << SCB_ICSR_PENDSTCLR_Pos)                /*!< SCB ICSR: PENDSTCLR Mask */
+
+#define SCB_ICSR_STTNS_Pos                 24U                                            /*!< SCB ICSR: STTNS Position (Security Extension) */
+#define SCB_ICSR_STTNS_Msk                 (1UL << SCB_ICSR_STTNS_Pos)                    /*!< SCB ICSR: STTNS Mask (Security Extension) */
+
+#define SCB_ICSR_ISRPREEMPT_Pos            23U                                            /*!< SCB ICSR: ISRPREEMPT Position */
+#define SCB_ICSR_ISRPREEMPT_Msk            (1UL << SCB_ICSR_ISRPREEMPT_Pos)               /*!< SCB ICSR: ISRPREEMPT Mask */
+
+#define SCB_ICSR_ISRPENDING_Pos            22U                                            /*!< SCB ICSR: ISRPENDING Position */
+#define SCB_ICSR_ISRPENDING_Msk            (1UL << SCB_ICSR_ISRPENDING_Pos)               /*!< SCB ICSR: ISRPENDING Mask */
+
+#define SCB_ICSR_VECTPENDING_Pos           12U                                            /*!< SCB ICSR: VECTPENDING Position */
+#define SCB_ICSR_VECTPENDING_Msk           (0x1FFUL << SCB_ICSR_VECTPENDING_Pos)          /*!< SCB ICSR: VECTPENDING Mask */
+
+#define SCB_ICSR_RETTOBASE_Pos             11U                                            /*!< SCB ICSR: RETTOBASE Position */
+#define SCB_ICSR_RETTOBASE_Msk             (1UL << SCB_ICSR_RETTOBASE_Pos)                /*!< SCB ICSR: RETTOBASE Mask */
+
+#define SCB_ICSR_VECTACTIVE_Pos             0U                                            /*!< SCB ICSR: VECTACTIVE Position */
+#define SCB_ICSR_VECTACTIVE_Msk            (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/)       /*!< SCB ICSR: VECTACTIVE Mask */
+
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+/* SCB Vector Table Offset Register Definitions */
+#define SCB_VTOR_TBLOFF_Pos                 7U                                            /*!< SCB VTOR: TBLOFF Position */
+#define SCB_VTOR_TBLOFF_Msk                (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos)           /*!< SCB VTOR: TBLOFF Mask */
+#endif
+
+/* SCB Application Interrupt and Reset Control Register Definitions */
+#define SCB_AIRCR_VECTKEY_Pos              16U                                            /*!< SCB AIRCR: VECTKEY Position */
+#define SCB_AIRCR_VECTKEY_Msk              (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos)            /*!< SCB AIRCR: VECTKEY Mask */
+
+#define SCB_AIRCR_VECTKEYSTAT_Pos          16U                                            /*!< SCB AIRCR: VECTKEYSTAT Position */
+#define SCB_AIRCR_VECTKEYSTAT_Msk          (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos)        /*!< SCB AIRCR: VECTKEYSTAT Mask */
+
+#define SCB_AIRCR_ENDIANESS_Pos            15U                                            /*!< SCB AIRCR: ENDIANESS Position */
+#define SCB_AIRCR_ENDIANESS_Msk            (1UL << SCB_AIRCR_ENDIANESS_Pos)               /*!< SCB AIRCR: ENDIANESS Mask */
+
+#define SCB_AIRCR_PRIS_Pos                 14U                                            /*!< SCB AIRCR: PRIS Position */
+#define SCB_AIRCR_PRIS_Msk                 (1UL << SCB_AIRCR_PRIS_Pos)                    /*!< SCB AIRCR: PRIS Mask */
+
+#define SCB_AIRCR_BFHFNMINS_Pos            13U                                            /*!< SCB AIRCR: BFHFNMINS Position */
+#define SCB_AIRCR_BFHFNMINS_Msk            (1UL << SCB_AIRCR_BFHFNMINS_Pos)               /*!< SCB AIRCR: BFHFNMINS Mask */
+
+#define SCB_AIRCR_SYSRESETREQS_Pos          3U                                            /*!< SCB AIRCR: SYSRESETREQS Position */
+#define SCB_AIRCR_SYSRESETREQS_Msk         (1UL << SCB_AIRCR_SYSRESETREQS_Pos)            /*!< SCB AIRCR: SYSRESETREQS Mask */
+
+#define SCB_AIRCR_SYSRESETREQ_Pos           2U                                            /*!< SCB AIRCR: SYSRESETREQ Position */
+#define SCB_AIRCR_SYSRESETREQ_Msk          (1UL << SCB_AIRCR_SYSRESETREQ_Pos)             /*!< SCB AIRCR: SYSRESETREQ Mask */
+
+#define SCB_AIRCR_VECTCLRACTIVE_Pos         1U                                            /*!< SCB AIRCR: VECTCLRACTIVE Position */
+#define SCB_AIRCR_VECTCLRACTIVE_Msk        (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos)           /*!< SCB AIRCR: VECTCLRACTIVE Mask */
+
+/* SCB System Control Register Definitions */
+#define SCB_SCR_SEVONPEND_Pos               4U                                            /*!< SCB SCR: SEVONPEND Position */
+#define SCB_SCR_SEVONPEND_Msk              (1UL << SCB_SCR_SEVONPEND_Pos)                 /*!< SCB SCR: SEVONPEND Mask */
+
+#define SCB_SCR_SLEEPDEEPS_Pos              3U                                            /*!< SCB SCR: SLEEPDEEPS Position */
+#define SCB_SCR_SLEEPDEEPS_Msk             (1UL << SCB_SCR_SLEEPDEEPS_Pos)                /*!< SCB SCR: SLEEPDEEPS Mask */
+
+#define SCB_SCR_SLEEPDEEP_Pos               2U                                            /*!< SCB SCR: SLEEPDEEP Position */
+#define SCB_SCR_SLEEPDEEP_Msk              (1UL << SCB_SCR_SLEEPDEEP_Pos)                 /*!< SCB SCR: SLEEPDEEP Mask */
+
+#define SCB_SCR_SLEEPONEXIT_Pos             1U                                            /*!< SCB SCR: SLEEPONEXIT Position */
+#define SCB_SCR_SLEEPONEXIT_Msk            (1UL << SCB_SCR_SLEEPONEXIT_Pos)               /*!< SCB SCR: SLEEPONEXIT Mask */
+
+/* SCB Configuration Control Register Definitions */
+#define SCB_CCR_BP_Pos                     18U                                            /*!< SCB CCR: BP Position */
+#define SCB_CCR_BP_Msk                     (1UL << SCB_CCR_BP_Pos)                        /*!< SCB CCR: BP Mask */
+
+#define SCB_CCR_IC_Pos                     17U                                            /*!< SCB CCR: IC Position */
+#define SCB_CCR_IC_Msk                     (1UL << SCB_CCR_IC_Pos)                        /*!< SCB CCR: IC Mask */
+
+#define SCB_CCR_DC_Pos                     16U                                            /*!< SCB CCR: DC Position */
+#define SCB_CCR_DC_Msk                     (1UL << SCB_CCR_DC_Pos)                        /*!< SCB CCR: DC Mask */
+
+#define SCB_CCR_STKOFHFNMIGN_Pos           10U                                            /*!< SCB CCR: STKOFHFNMIGN Position */
+#define SCB_CCR_STKOFHFNMIGN_Msk           (1UL << SCB_CCR_STKOFHFNMIGN_Pos)              /*!< SCB CCR: STKOFHFNMIGN Mask */
+
+#define SCB_CCR_BFHFNMIGN_Pos               8U                                            /*!< SCB CCR: BFHFNMIGN Position */
+#define SCB_CCR_BFHFNMIGN_Msk              (1UL << SCB_CCR_BFHFNMIGN_Pos)                 /*!< SCB CCR: BFHFNMIGN Mask */
+
+#define SCB_CCR_DIV_0_TRP_Pos               4U                                            /*!< SCB CCR: DIV_0_TRP Position */
+#define SCB_CCR_DIV_0_TRP_Msk              (1UL << SCB_CCR_DIV_0_TRP_Pos)                 /*!< SCB CCR: DIV_0_TRP Mask */
+
+#define SCB_CCR_UNALIGN_TRP_Pos             3U                                            /*!< SCB CCR: UNALIGN_TRP Position */
+#define SCB_CCR_UNALIGN_TRP_Msk            (1UL << SCB_CCR_UNALIGN_TRP_Pos)               /*!< SCB CCR: UNALIGN_TRP Mask */
+
+#define SCB_CCR_USERSETMPEND_Pos            1U                                            /*!< SCB CCR: USERSETMPEND Position */
+#define SCB_CCR_USERSETMPEND_Msk           (1UL << SCB_CCR_USERSETMPEND_Pos)              /*!< SCB CCR: USERSETMPEND Mask */
+
+/* SCB System Handler Control and State Register Definitions */
+#define SCB_SHCSR_HARDFAULTPENDED_Pos      21U                                            /*!< SCB SHCSR: HARDFAULTPENDED Position */
+#define SCB_SHCSR_HARDFAULTPENDED_Msk      (1UL << SCB_SHCSR_HARDFAULTPENDED_Pos)         /*!< SCB SHCSR: HARDFAULTPENDED Mask */
+
+#define SCB_SHCSR_SVCALLPENDED_Pos         15U                                            /*!< SCB SHCSR: SVCALLPENDED Position */
+#define SCB_SHCSR_SVCALLPENDED_Msk         (1UL << SCB_SHCSR_SVCALLPENDED_Pos)            /*!< SCB SHCSR: SVCALLPENDED Mask */
+
+#define SCB_SHCSR_SYSTICKACT_Pos           11U                                            /*!< SCB SHCSR: SYSTICKACT Position */
+#define SCB_SHCSR_SYSTICKACT_Msk           (1UL << SCB_SHCSR_SYSTICKACT_Pos)              /*!< SCB SHCSR: SYSTICKACT Mask */
+
+#define SCB_SHCSR_PENDSVACT_Pos            10U                                            /*!< SCB SHCSR: PENDSVACT Position */
+#define SCB_SHCSR_PENDSVACT_Msk            (1UL << SCB_SHCSR_PENDSVACT_Pos)               /*!< SCB SHCSR: PENDSVACT Mask */
+
+#define SCB_SHCSR_SVCALLACT_Pos             7U                                            /*!< SCB SHCSR: SVCALLACT Position */
+#define SCB_SHCSR_SVCALLACT_Msk            (1UL << SCB_SHCSR_SVCALLACT_Pos)               /*!< SCB SHCSR: SVCALLACT Mask */
+
+#define SCB_SHCSR_NMIACT_Pos                5U                                            /*!< SCB SHCSR: NMIACT Position */
+#define SCB_SHCSR_NMIACT_Msk               (1UL << SCB_SHCSR_NMIACT_Pos)                  /*!< SCB SHCSR: NMIACT Mask */
+
+#define SCB_SHCSR_HARDFAULTACT_Pos          2U                                            /*!< SCB SHCSR: HARDFAULTACT Position */
+#define SCB_SHCSR_HARDFAULTACT_Msk         (1UL << SCB_SHCSR_HARDFAULTACT_Pos)            /*!< SCB SHCSR: HARDFAULTACT Mask */
+
+/*@} end of group CMSIS_SCB */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SysTick     System Tick Timer (SysTick)
+  \brief    Type definitions for the System Timer Registers.
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Timer (SysTick).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  SysTick Control and Status Register */
+  __IOM uint32_t LOAD;                   /*!< Offset: 0x004 (R/W)  SysTick Reload Value Register */
+  __IOM uint32_t VAL;                    /*!< Offset: 0x008 (R/W)  SysTick Current Value Register */
+  __IM  uint32_t CALIB;                  /*!< Offset: 0x00C (R/ )  SysTick Calibration Register */
+} SysTick_Type;
+
+/* SysTick Control / Status Register Definitions */
+#define SysTick_CTRL_COUNTFLAG_Pos         16U                                            /*!< SysTick CTRL: COUNTFLAG Position */
+#define SysTick_CTRL_COUNTFLAG_Msk         (1UL << SysTick_CTRL_COUNTFLAG_Pos)            /*!< SysTick CTRL: COUNTFLAG Mask */
+
+#define SysTick_CTRL_CLKSOURCE_Pos          2U                                            /*!< SysTick CTRL: CLKSOURCE Position */
+#define SysTick_CTRL_CLKSOURCE_Msk         (1UL << SysTick_CTRL_CLKSOURCE_Pos)            /*!< SysTick CTRL: CLKSOURCE Mask */
+
+#define SysTick_CTRL_TICKINT_Pos            1U                                            /*!< SysTick CTRL: TICKINT Position */
+#define SysTick_CTRL_TICKINT_Msk           (1UL << SysTick_CTRL_TICKINT_Pos)              /*!< SysTick CTRL: TICKINT Mask */
+
+#define SysTick_CTRL_ENABLE_Pos             0U                                            /*!< SysTick CTRL: ENABLE Position */
+#define SysTick_CTRL_ENABLE_Msk            (1UL /*<< SysTick_CTRL_ENABLE_Pos*/)           /*!< SysTick CTRL: ENABLE Mask */
+
+/* SysTick Reload Register Definitions */
+#define SysTick_LOAD_RELOAD_Pos             0U                                            /*!< SysTick LOAD: RELOAD Position */
+#define SysTick_LOAD_RELOAD_Msk            (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/)    /*!< SysTick LOAD: RELOAD Mask */
+
+/* SysTick Current Register Definitions */
+#define SysTick_VAL_CURRENT_Pos             0U                                            /*!< SysTick VAL: CURRENT Position */
+#define SysTick_VAL_CURRENT_Msk            (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/)    /*!< SysTick VAL: CURRENT Mask */
+
+/* SysTick Calibration Register Definitions */
+#define SysTick_CALIB_NOREF_Pos            31U                                            /*!< SysTick CALIB: NOREF Position */
+#define SysTick_CALIB_NOREF_Msk            (1UL << SysTick_CALIB_NOREF_Pos)               /*!< SysTick CALIB: NOREF Mask */
+
+#define SysTick_CALIB_SKEW_Pos             30U                                            /*!< SysTick CALIB: SKEW Position */
+#define SysTick_CALIB_SKEW_Msk             (1UL << SysTick_CALIB_SKEW_Pos)                /*!< SysTick CALIB: SKEW Mask */
+
+#define SysTick_CALIB_TENMS_Pos             0U                                            /*!< SysTick CALIB: TENMS Position */
+#define SysTick_CALIB_TENMS_Msk            (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/)    /*!< SysTick CALIB: TENMS Mask */
+
+/*@} end of group CMSIS_SysTick */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_DWT     Data Watchpoint and Trace (DWT)
+  \brief    Type definitions for the Data Watchpoint and Trace (DWT)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Data Watchpoint and Trace Register (DWT).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  Control Register */
+        uint32_t RESERVED0[6U];
+  __IM  uint32_t PCSR;                   /*!< Offset: 0x01C (R/ )  Program Counter Sample Register */
+  __IOM uint32_t COMP0;                  /*!< Offset: 0x020 (R/W)  Comparator Register 0 */
+        uint32_t RESERVED1[1U];
+  __IOM uint32_t FUNCTION0;              /*!< Offset: 0x028 (R/W)  Function Register 0 */
+        uint32_t RESERVED2[1U];
+  __IOM uint32_t COMP1;                  /*!< Offset: 0x030 (R/W)  Comparator Register 1 */
+        uint32_t RESERVED3[1U];
+  __IOM uint32_t FUNCTION1;              /*!< Offset: 0x038 (R/W)  Function Register 1 */
+        uint32_t RESERVED4[1U];
+  __IOM uint32_t COMP2;                  /*!< Offset: 0x040 (R/W)  Comparator Register 2 */
+        uint32_t RESERVED5[1U];
+  __IOM uint32_t FUNCTION2;              /*!< Offset: 0x048 (R/W)  Function Register 2 */
+        uint32_t RESERVED6[1U];
+  __IOM uint32_t COMP3;                  /*!< Offset: 0x050 (R/W)  Comparator Register 3 */
+        uint32_t RESERVED7[1U];
+  __IOM uint32_t FUNCTION3;              /*!< Offset: 0x058 (R/W)  Function Register 3 */
+        uint32_t RESERVED8[1U];
+  __IOM uint32_t COMP4;                  /*!< Offset: 0x060 (R/W)  Comparator Register 4 */
+        uint32_t RESERVED9[1U];
+  __IOM uint32_t FUNCTION4;              /*!< Offset: 0x068 (R/W)  Function Register 4 */
+        uint32_t RESERVED10[1U];
+  __IOM uint32_t COMP5;                  /*!< Offset: 0x070 (R/W)  Comparator Register 5 */
+        uint32_t RESERVED11[1U];
+  __IOM uint32_t FUNCTION5;              /*!< Offset: 0x078 (R/W)  Function Register 5 */
+        uint32_t RESERVED12[1U];
+  __IOM uint32_t COMP6;                  /*!< Offset: 0x080 (R/W)  Comparator Register 6 */
+        uint32_t RESERVED13[1U];
+  __IOM uint32_t FUNCTION6;              /*!< Offset: 0x088 (R/W)  Function Register 6 */
+        uint32_t RESERVED14[1U];
+  __IOM uint32_t COMP7;                  /*!< Offset: 0x090 (R/W)  Comparator Register 7 */
+        uint32_t RESERVED15[1U];
+  __IOM uint32_t FUNCTION7;              /*!< Offset: 0x098 (R/W)  Function Register 7 */
+        uint32_t RESERVED16[1U];
+  __IOM uint32_t COMP8;                  /*!< Offset: 0x0A0 (R/W)  Comparator Register 8 */
+        uint32_t RESERVED17[1U];
+  __IOM uint32_t FUNCTION8;              /*!< Offset: 0x0A8 (R/W)  Function Register 8 */
+        uint32_t RESERVED18[1U];
+  __IOM uint32_t COMP9;                  /*!< Offset: 0x0B0 (R/W)  Comparator Register 9 */
+        uint32_t RESERVED19[1U];
+  __IOM uint32_t FUNCTION9;              /*!< Offset: 0x0B8 (R/W)  Function Register 9 */
+        uint32_t RESERVED20[1U];
+  __IOM uint32_t COMP10;                 /*!< Offset: 0x0C0 (R/W)  Comparator Register 10 */
+        uint32_t RESERVED21[1U];
+  __IOM uint32_t FUNCTION10;             /*!< Offset: 0x0C8 (R/W)  Function Register 10 */
+        uint32_t RESERVED22[1U];
+  __IOM uint32_t COMP11;                 /*!< Offset: 0x0D0 (R/W)  Comparator Register 11 */
+        uint32_t RESERVED23[1U];
+  __IOM uint32_t FUNCTION11;             /*!< Offset: 0x0D8 (R/W)  Function Register 11 */
+        uint32_t RESERVED24[1U];
+  __IOM uint32_t COMP12;                 /*!< Offset: 0x0E0 (R/W)  Comparator Register 12 */
+        uint32_t RESERVED25[1U];
+  __IOM uint32_t FUNCTION12;             /*!< Offset: 0x0E8 (R/W)  Function Register 12 */
+        uint32_t RESERVED26[1U];
+  __IOM uint32_t COMP13;                 /*!< Offset: 0x0F0 (R/W)  Comparator Register 13 */
+        uint32_t RESERVED27[1U];
+  __IOM uint32_t FUNCTION13;             /*!< Offset: 0x0F8 (R/W)  Function Register 13 */
+        uint32_t RESERVED28[1U];
+  __IOM uint32_t COMP14;                 /*!< Offset: 0x100 (R/W)  Comparator Register 14 */
+        uint32_t RESERVED29[1U];
+  __IOM uint32_t FUNCTION14;             /*!< Offset: 0x108 (R/W)  Function Register 14 */
+        uint32_t RESERVED30[1U];
+  __IOM uint32_t COMP15;                 /*!< Offset: 0x110 (R/W)  Comparator Register 15 */
+        uint32_t RESERVED31[1U];
+  __IOM uint32_t FUNCTION15;             /*!< Offset: 0x118 (R/W)  Function Register 15 */
+} DWT_Type;
+
+/* DWT Control Register Definitions */
+#define DWT_CTRL_NUMCOMP_Pos               28U                                         /*!< DWT CTRL: NUMCOMP Position */
+#define DWT_CTRL_NUMCOMP_Msk               (0xFUL << DWT_CTRL_NUMCOMP_Pos)             /*!< DWT CTRL: NUMCOMP Mask */
+
+#define DWT_CTRL_NOTRCPKT_Pos              27U                                         /*!< DWT CTRL: NOTRCPKT Position */
+#define DWT_CTRL_NOTRCPKT_Msk              (0x1UL << DWT_CTRL_NOTRCPKT_Pos)            /*!< DWT CTRL: NOTRCPKT Mask */
+
+#define DWT_CTRL_NOEXTTRIG_Pos             26U                                         /*!< DWT CTRL: NOEXTTRIG Position */
+#define DWT_CTRL_NOEXTTRIG_Msk             (0x1UL << DWT_CTRL_NOEXTTRIG_Pos)           /*!< DWT CTRL: NOEXTTRIG Mask */
+
+#define DWT_CTRL_NOCYCCNT_Pos              25U                                         /*!< DWT CTRL: NOCYCCNT Position */
+#define DWT_CTRL_NOCYCCNT_Msk              (0x1UL << DWT_CTRL_NOCYCCNT_Pos)            /*!< DWT CTRL: NOCYCCNT Mask */
+
+#define DWT_CTRL_NOPRFCNT_Pos              24U                                         /*!< DWT CTRL: NOPRFCNT Position */
+#define DWT_CTRL_NOPRFCNT_Msk              (0x1UL << DWT_CTRL_NOPRFCNT_Pos)            /*!< DWT CTRL: NOPRFCNT Mask */
+
+/* DWT Comparator Function Register Definitions */
+#define DWT_FUNCTION_ID_Pos                27U                                         /*!< DWT FUNCTION: ID Position */
+#define DWT_FUNCTION_ID_Msk                (0x1FUL << DWT_FUNCTION_ID_Pos)             /*!< DWT FUNCTION: ID Mask */
+
+#define DWT_FUNCTION_MATCHED_Pos           24U                                         /*!< DWT FUNCTION: MATCHED Position */
+#define DWT_FUNCTION_MATCHED_Msk           (0x1UL << DWT_FUNCTION_MATCHED_Pos)         /*!< DWT FUNCTION: MATCHED Mask */
+
+#define DWT_FUNCTION_DATAVSIZE_Pos         10U                                         /*!< DWT FUNCTION: DATAVSIZE Position */
+#define DWT_FUNCTION_DATAVSIZE_Msk         (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos)       /*!< DWT FUNCTION: DATAVSIZE Mask */
+
+#define DWT_FUNCTION_ACTION_Pos             4U                                         /*!< DWT FUNCTION: ACTION Position */
+#define DWT_FUNCTION_ACTION_Msk            (0x3UL << DWT_FUNCTION_ACTION_Pos)          /*!< DWT FUNCTION: ACTION Mask */
+
+#define DWT_FUNCTION_MATCH_Pos              0U                                         /*!< DWT FUNCTION: MATCH Position */
+#define DWT_FUNCTION_MATCH_Msk             (0xFUL /*<< DWT_FUNCTION_MATCH_Pos*/)       /*!< DWT FUNCTION: MATCH Mask */
+
+/*@}*/ /* end of group CMSIS_DWT */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_TPI     Trace Port Interface (TPI)
+  \brief    Type definitions for the Trace Port Interface (TPI)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Trace Port Interface Register (TPI).
+ */
+typedef struct
+{
+  __IM  uint32_t SSPSR;                  /*!< Offset: 0x000 (R/ )  Supported Parallel Port Size Register */
+  __IOM uint32_t CSPSR;                  /*!< Offset: 0x004 (R/W)  Current Parallel Port Size Register */
+        uint32_t RESERVED0[2U];
+  __IOM uint32_t ACPR;                   /*!< Offset: 0x010 (R/W)  Asynchronous Clock Prescaler Register */
+        uint32_t RESERVED1[55U];
+  __IOM uint32_t SPPR;                   /*!< Offset: 0x0F0 (R/W)  Selected Pin Protocol Register */
+        uint32_t RESERVED2[131U];
+  __IM  uint32_t FFSR;                   /*!< Offset: 0x300 (R/ )  Formatter and Flush Status Register */
+  __IOM uint32_t FFCR;                   /*!< Offset: 0x304 (R/W)  Formatter and Flush Control Register */
+  __IOM uint32_t PSCR;                   /*!< Offset: 0x308 (R/W)  Periodic Synchronization Control Register */
+        uint32_t RESERVED3[759U];
+  __IM  uint32_t TRIGGER;                /*!< Offset: 0xEE8 (R/ )  TRIGGER Register */
+  __IM  uint32_t ITFTTD0;                /*!< Offset: 0xEEC (R/ )  Integration Test FIFO Test Data 0 Register */
+  __IOM uint32_t ITATBCTR2;              /*!< Offset: 0xEF0 (R/W)  Integration Test ATB Control Register 2 */
+        uint32_t RESERVED4[1U];
+  __IM  uint32_t ITATBCTR0;              /*!< Offset: 0xEF8 (R/ )  Integration Test ATB Control Register 0 */
+  __IM  uint32_t ITFTTD1;                /*!< Offset: 0xEFC (R/ )  Integration Test FIFO Test Data 1 Register */
+  __IOM uint32_t ITCTRL;                 /*!< Offset: 0xF00 (R/W)  Integration Mode Control */
+        uint32_t RESERVED5[39U];
+  __IOM uint32_t CLAIMSET;               /*!< Offset: 0xFA0 (R/W)  Claim tag set */
+  __IOM uint32_t CLAIMCLR;               /*!< Offset: 0xFA4 (R/W)  Claim tag clear */
+        uint32_t RESERVED7[8U];
+  __IM  uint32_t DEVID;                  /*!< Offset: 0xFC8 (R/ )  Device Configuration Register */
+  __IM  uint32_t DEVTYPE;                /*!< Offset: 0xFCC (R/ )  Device Type Identifier Register */
+} TPI_Type;
+
+/* TPI Asynchronous Clock Prescaler Register Definitions */
+#define TPI_ACPR_PRESCALER_Pos              0U                                         /*!< TPI ACPR: PRESCALER Position */
+#define TPI_ACPR_PRESCALER_Msk             (0x1FFFUL /*<< TPI_ACPR_PRESCALER_Pos*/)    /*!< TPI ACPR: PRESCALER Mask */
+
+/* TPI Selected Pin Protocol Register Definitions */
+#define TPI_SPPR_TXMODE_Pos                 0U                                         /*!< TPI SPPR: TXMODE Position */
+#define TPI_SPPR_TXMODE_Msk                (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/)          /*!< TPI SPPR: TXMODE Mask */
+
+/* TPI Formatter and Flush Status Register Definitions */
+#define TPI_FFSR_FtNonStop_Pos              3U                                         /*!< TPI FFSR: FtNonStop Position */
+#define TPI_FFSR_FtNonStop_Msk             (0x1UL << TPI_FFSR_FtNonStop_Pos)           /*!< TPI FFSR: FtNonStop Mask */
+
+#define TPI_FFSR_TCPresent_Pos              2U                                         /*!< TPI FFSR: TCPresent Position */
+#define TPI_FFSR_TCPresent_Msk             (0x1UL << TPI_FFSR_TCPresent_Pos)           /*!< TPI FFSR: TCPresent Mask */
+
+#define TPI_FFSR_FtStopped_Pos              1U                                         /*!< TPI FFSR: FtStopped Position */
+#define TPI_FFSR_FtStopped_Msk             (0x1UL << TPI_FFSR_FtStopped_Pos)           /*!< TPI FFSR: FtStopped Mask */
+
+#define TPI_FFSR_FlInProg_Pos               0U                                         /*!< TPI FFSR: FlInProg Position */
+#define TPI_FFSR_FlInProg_Msk              (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/)        /*!< TPI FFSR: FlInProg Mask */
+
+/* TPI Formatter and Flush Control Register Definitions */
+#define TPI_FFCR_TrigIn_Pos                 8U                                         /*!< TPI FFCR: TrigIn Position */
+#define TPI_FFCR_TrigIn_Msk                (0x1UL << TPI_FFCR_TrigIn_Pos)              /*!< TPI FFCR: TrigIn Mask */
+
+#define TPI_FFCR_FOnMan_Pos                 6U                                         /*!< TPI FFCR: FOnMan Position */
+#define TPI_FFCR_FOnMan_Msk                (0x1UL << TPI_FFCR_FOnMan_Pos)              /*!< TPI FFCR: FOnMan Mask */
+
+#define TPI_FFCR_EnFCont_Pos                1U                                         /*!< TPI FFCR: EnFCont Position */
+#define TPI_FFCR_EnFCont_Msk               (0x1UL << TPI_FFCR_EnFCont_Pos)             /*!< TPI FFCR: EnFCont Mask */
+
+/* TPI TRIGGER Register Definitions */
+#define TPI_TRIGGER_TRIGGER_Pos             0U                                         /*!< TPI TRIGGER: TRIGGER Position */
+#define TPI_TRIGGER_TRIGGER_Msk            (0x1UL /*<< TPI_TRIGGER_TRIGGER_Pos*/)      /*!< TPI TRIGGER: TRIGGER Mask */
+
+/* TPI Integration Test FIFO Test Data 0 Register Definitions */
+#define TPI_ITFTTD0_ATB_IF2_ATVALID_Pos    29U                                         /*!< TPI ITFTTD0: ATB Interface 2 ATVALIDPosition */
+#define TPI_ITFTTD0_ATB_IF2_ATVALID_Msk    (0x3UL << TPI_ITFTTD0_ATB_IF2_ATVALID_Pos)  /*!< TPI ITFTTD0: ATB Interface 2 ATVALID Mask */
+
+#define TPI_ITFTTD0_ATB_IF2_bytecount_Pos  27U                                         /*!< TPI ITFTTD0: ATB Interface 2 byte count Position */
+#define TPI_ITFTTD0_ATB_IF2_bytecount_Msk  (0x3UL << TPI_ITFTTD0_ATB_IF2_bytecount_Pos) /*!< TPI ITFTTD0: ATB Interface 2 byte count Mask */
+
+#define TPI_ITFTTD0_ATB_IF1_ATVALID_Pos    26U                                         /*!< TPI ITFTTD0: ATB Interface 1 ATVALID Position */
+#define TPI_ITFTTD0_ATB_IF1_ATVALID_Msk    (0x3UL << TPI_ITFTTD0_ATB_IF1_ATVALID_Pos)  /*!< TPI ITFTTD0: ATB Interface 1 ATVALID Mask */
+
+#define TPI_ITFTTD0_ATB_IF1_bytecount_Pos  24U                                         /*!< TPI ITFTTD0: ATB Interface 1 byte count Position */
+#define TPI_ITFTTD0_ATB_IF1_bytecount_Msk  (0x3UL << TPI_ITFTTD0_ATB_IF1_bytecount_Pos) /*!< TPI ITFTTD0: ATB Interface 1 byte countt Mask */
+
+#define TPI_ITFTTD0_ATB_IF1_data2_Pos      16U                                         /*!< TPI ITFTTD0: ATB Interface 1 data2 Position */
+#define TPI_ITFTTD0_ATB_IF1_data2_Msk      (0xFFUL << TPI_ITFTTD0_ATB_IF1_data1_Pos)   /*!< TPI ITFTTD0: ATB Interface 1 data2 Mask */
+
+#define TPI_ITFTTD0_ATB_IF1_data1_Pos       8U                                         /*!< TPI ITFTTD0: ATB Interface 1 data1 Position */
+#define TPI_ITFTTD0_ATB_IF1_data1_Msk      (0xFFUL << TPI_ITFTTD0_ATB_IF1_data1_Pos)   /*!< TPI ITFTTD0: ATB Interface 1 data1 Mask */
+
+#define TPI_ITFTTD0_ATB_IF1_data0_Pos       0U                                          /*!< TPI ITFTTD0: ATB Interface 1 data0 Position */
+#define TPI_ITFTTD0_ATB_IF1_data0_Msk      (0xFFUL /*<< TPI_ITFTTD0_ATB_IF1_data0_Pos*/) /*!< TPI ITFTTD0: ATB Interface 1 data0 Mask */
+
+/* TPI Integration Test ATB Control Register 2 Register Definitions */
+#define TPI_ITATBCTR2_AFVALID2S_Pos         1U                                         /*!< TPI ITATBCTR2: AFVALID2S Position */
+#define TPI_ITATBCTR2_AFVALID2S_Msk        (0x1UL << TPI_ITATBCTR2_AFVALID2S_Pos)      /*!< TPI ITATBCTR2: AFVALID2SS Mask */
+
+#define TPI_ITATBCTR2_AFVALID1S_Pos         1U                                         /*!< TPI ITATBCTR2: AFVALID1S Position */
+#define TPI_ITATBCTR2_AFVALID1S_Msk        (0x1UL << TPI_ITATBCTR2_AFVALID1S_Pos)      /*!< TPI ITATBCTR2: AFVALID1SS Mask */
+
+#define TPI_ITATBCTR2_ATREADY2S_Pos         0U                                         /*!< TPI ITATBCTR2: ATREADY2S Position */
+#define TPI_ITATBCTR2_ATREADY2S_Msk        (0x1UL /*<< TPI_ITATBCTR2_ATREADY2S_Pos*/)  /*!< TPI ITATBCTR2: ATREADY2S Mask */
+
+#define TPI_ITATBCTR2_ATREADY1S_Pos         0U                                         /*!< TPI ITATBCTR2: ATREADY1S Position */
+#define TPI_ITATBCTR2_ATREADY1S_Msk        (0x1UL /*<< TPI_ITATBCTR2_ATREADY1S_Pos*/)  /*!< TPI ITATBCTR2: ATREADY1S Mask */
+
+/* TPI Integration Test FIFO Test Data 1 Register Definitions */
+#define TPI_ITFTTD1_ATB_IF2_ATVALID_Pos    29U                                         /*!< TPI ITFTTD1: ATB Interface 2 ATVALID Position */
+#define TPI_ITFTTD1_ATB_IF2_ATVALID_Msk    (0x3UL << TPI_ITFTTD1_ATB_IF2_ATVALID_Pos)  /*!< TPI ITFTTD1: ATB Interface 2 ATVALID Mask */
+
+#define TPI_ITFTTD1_ATB_IF2_bytecount_Pos  27U                                         /*!< TPI ITFTTD1: ATB Interface 2 byte count Position */
+#define TPI_ITFTTD1_ATB_IF2_bytecount_Msk  (0x3UL << TPI_ITFTTD1_ATB_IF2_bytecount_Pos) /*!< TPI ITFTTD1: ATB Interface 2 byte count Mask */
+
+#define TPI_ITFTTD1_ATB_IF1_ATVALID_Pos    26U                                         /*!< TPI ITFTTD1: ATB Interface 1 ATVALID Position */
+#define TPI_ITFTTD1_ATB_IF1_ATVALID_Msk    (0x3UL << TPI_ITFTTD1_ATB_IF1_ATVALID_Pos)  /*!< TPI ITFTTD1: ATB Interface 1 ATVALID Mask */
+
+#define TPI_ITFTTD1_ATB_IF1_bytecount_Pos  24U                                         /*!< TPI ITFTTD1: ATB Interface 1 byte count Position */
+#define TPI_ITFTTD1_ATB_IF1_bytecount_Msk  (0x3UL << TPI_ITFTTD1_ATB_IF1_bytecount_Pos) /*!< TPI ITFTTD1: ATB Interface 1 byte countt Mask */
+
+#define TPI_ITFTTD1_ATB_IF2_data2_Pos      16U                                         /*!< TPI ITFTTD1: ATB Interface 2 data2 Position */
+#define TPI_ITFTTD1_ATB_IF2_data2_Msk      (0xFFUL << TPI_ITFTTD1_ATB_IF2_data1_Pos)   /*!< TPI ITFTTD1: ATB Interface 2 data2 Mask */
+
+#define TPI_ITFTTD1_ATB_IF2_data1_Pos       8U                                         /*!< TPI ITFTTD1: ATB Interface 2 data1 Position */
+#define TPI_ITFTTD1_ATB_IF2_data1_Msk      (0xFFUL << TPI_ITFTTD1_ATB_IF2_data1_Pos)   /*!< TPI ITFTTD1: ATB Interface 2 data1 Mask */
+
+#define TPI_ITFTTD1_ATB_IF2_data0_Pos       0U                                          /*!< TPI ITFTTD1: ATB Interface 2 data0 Position */
+#define TPI_ITFTTD1_ATB_IF2_data0_Msk      (0xFFUL /*<< TPI_ITFTTD1_ATB_IF2_data0_Pos*/) /*!< TPI ITFTTD1: ATB Interface 2 data0 Mask */
+
+/* TPI Integration Test ATB Control Register 0 Definitions */
+#define TPI_ITATBCTR0_AFVALID2S_Pos         1U                                         /*!< TPI ITATBCTR0: AFVALID2S Position */
+#define TPI_ITATBCTR0_AFVALID2S_Msk        (0x1UL << TPI_ITATBCTR0_AFVALID2S_Pos)      /*!< TPI ITATBCTR0: AFVALID2SS Mask */
+
+#define TPI_ITATBCTR0_AFVALID1S_Pos         1U                                         /*!< TPI ITATBCTR0: AFVALID1S Position */
+#define TPI_ITATBCTR0_AFVALID1S_Msk        (0x1UL << TPI_ITATBCTR0_AFVALID1S_Pos)      /*!< TPI ITATBCTR0: AFVALID1SS Mask */
+
+#define TPI_ITATBCTR0_ATREADY2S_Pos         0U                                         /*!< TPI ITATBCTR0: ATREADY2S Position */
+#define TPI_ITATBCTR0_ATREADY2S_Msk        (0x1UL /*<< TPI_ITATBCTR0_ATREADY2S_Pos*/)  /*!< TPI ITATBCTR0: ATREADY2S Mask */
+
+#define TPI_ITATBCTR0_ATREADY1S_Pos         0U                                         /*!< TPI ITATBCTR0: ATREADY1S Position */
+#define TPI_ITATBCTR0_ATREADY1S_Msk        (0x1UL /*<< TPI_ITATBCTR0_ATREADY1S_Pos*/)  /*!< TPI ITATBCTR0: ATREADY1S Mask */
+
+/* TPI Integration Mode Control Register Definitions */
+#define TPI_ITCTRL_Mode_Pos                 0U                                         /*!< TPI ITCTRL: Mode Position */
+#define TPI_ITCTRL_Mode_Msk                (0x3UL /*<< TPI_ITCTRL_Mode_Pos*/)          /*!< TPI ITCTRL: Mode Mask */
+
+/* TPI DEVID Register Definitions */
+#define TPI_DEVID_NRZVALID_Pos             11U                                         /*!< TPI DEVID: NRZVALID Position */
+#define TPI_DEVID_NRZVALID_Msk             (0x1UL << TPI_DEVID_NRZVALID_Pos)           /*!< TPI DEVID: NRZVALID Mask */
+
+#define TPI_DEVID_MANCVALID_Pos            10U                                         /*!< TPI DEVID: MANCVALID Position */
+#define TPI_DEVID_MANCVALID_Msk            (0x1UL << TPI_DEVID_MANCVALID_Pos)          /*!< TPI DEVID: MANCVALID Mask */
+
+#define TPI_DEVID_PTINVALID_Pos             9U                                         /*!< TPI DEVID: PTINVALID Position */
+#define TPI_DEVID_PTINVALID_Msk            (0x1UL << TPI_DEVID_PTINVALID_Pos)          /*!< TPI DEVID: PTINVALID Mask */
+
+#define TPI_DEVID_FIFOSZ_Pos                6U                                         /*!< TPI DEVID: FIFOSZ Position */
+#define TPI_DEVID_FIFOSZ_Msk               (0x7UL << TPI_DEVID_FIFOSZ_Pos)             /*!< TPI DEVID: FIFOSZ Mask */
+
+#define TPI_DEVID_NrTraceInput_Pos          0U                                         /*!< TPI DEVID: NrTraceInput Position */
+#define TPI_DEVID_NrTraceInput_Msk         (0x3FUL /*<< TPI_DEVID_NrTraceInput_Pos*/)  /*!< TPI DEVID: NrTraceInput Mask */
+
+/* TPI DEVTYPE Register Definitions */
+#define TPI_DEVTYPE_SubType_Pos             4U                                         /*!< TPI DEVTYPE: SubType Position */
+#define TPI_DEVTYPE_SubType_Msk            (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/)      /*!< TPI DEVTYPE: SubType Mask */
+
+#define TPI_DEVTYPE_MajorType_Pos           0U                                         /*!< TPI DEVTYPE: MajorType Position */
+#define TPI_DEVTYPE_MajorType_Msk          (0xFUL << TPI_DEVTYPE_MajorType_Pos)        /*!< TPI DEVTYPE: MajorType Mask */
+
+/*@}*/ /* end of group CMSIS_TPI */
+
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_MPU     Memory Protection Unit (MPU)
+  \brief    Type definitions for the Memory Protection Unit (MPU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Memory Protection Unit (MPU).
+ */
+typedef struct
+{
+  __IM  uint32_t TYPE;                   /*!< Offset: 0x000 (R/ )  MPU Type Register */
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x004 (R/W)  MPU Control Register */
+  __IOM uint32_t RNR;                    /*!< Offset: 0x008 (R/W)  MPU Region Number Register */
+  __IOM uint32_t RBAR;                   /*!< Offset: 0x00C (R/W)  MPU Region Base Address Register */
+  __IOM uint32_t RLAR;                   /*!< Offset: 0x010 (R/W)  MPU Region Limit Address Register */
+        uint32_t RESERVED0[7U];
+  union {
+  __IOM uint32_t MAIR[2];
+  struct {
+  __IOM uint32_t MAIR0;                  /*!< Offset: 0x030 (R/W)  MPU Memory Attribute Indirection Register 0 */
+  __IOM uint32_t MAIR1;                  /*!< Offset: 0x034 (R/W)  MPU Memory Attribute Indirection Register 1 */
+  };
+  };
+} MPU_Type;
+
+#define MPU_TYPE_RALIASES                  1U
+
+/* MPU Type Register Definitions */
+#define MPU_TYPE_IREGION_Pos               16U                                            /*!< MPU TYPE: IREGION Position */
+#define MPU_TYPE_IREGION_Msk               (0xFFUL << MPU_TYPE_IREGION_Pos)               /*!< MPU TYPE: IREGION Mask */
+
+#define MPU_TYPE_DREGION_Pos                8U                                            /*!< MPU TYPE: DREGION Position */
+#define MPU_TYPE_DREGION_Msk               (0xFFUL << MPU_TYPE_DREGION_Pos)               /*!< MPU TYPE: DREGION Mask */
+
+#define MPU_TYPE_SEPARATE_Pos               0U                                            /*!< MPU TYPE: SEPARATE Position */
+#define MPU_TYPE_SEPARATE_Msk              (1UL /*<< MPU_TYPE_SEPARATE_Pos*/)             /*!< MPU TYPE: SEPARATE Mask */
+
+/* MPU Control Register Definitions */
+#define MPU_CTRL_PRIVDEFENA_Pos             2U                                            /*!< MPU CTRL: PRIVDEFENA Position */
+#define MPU_CTRL_PRIVDEFENA_Msk            (1UL << MPU_CTRL_PRIVDEFENA_Pos)               /*!< MPU CTRL: PRIVDEFENA Mask */
+
+#define MPU_CTRL_HFNMIENA_Pos               1U                                            /*!< MPU CTRL: HFNMIENA Position */
+#define MPU_CTRL_HFNMIENA_Msk              (1UL << MPU_CTRL_HFNMIENA_Pos)                 /*!< MPU CTRL: HFNMIENA Mask */
+
+#define MPU_CTRL_ENABLE_Pos                 0U                                            /*!< MPU CTRL: ENABLE Position */
+#define MPU_CTRL_ENABLE_Msk                (1UL /*<< MPU_CTRL_ENABLE_Pos*/)               /*!< MPU CTRL: ENABLE Mask */
+
+/* MPU Region Number Register Definitions */
+#define MPU_RNR_REGION_Pos                  0U                                            /*!< MPU RNR: REGION Position */
+#define MPU_RNR_REGION_Msk                 (0xFFUL /*<< MPU_RNR_REGION_Pos*/)             /*!< MPU RNR: REGION Mask */
+
+/* MPU Region Base Address Register Definitions */
+#define MPU_RBAR_BASE_Pos                   5U                                            /*!< MPU RBAR: BASE Position */
+#define MPU_RBAR_BASE_Msk                  (0x7FFFFFFUL << MPU_RBAR_BASE_Pos)             /*!< MPU RBAR: BASE Mask */
+
+#define MPU_RBAR_SH_Pos                     3U                                            /*!< MPU RBAR: SH Position */
+#define MPU_RBAR_SH_Msk                    (0x3UL << MPU_RBAR_SH_Pos)                     /*!< MPU RBAR: SH Mask */
+
+#define MPU_RBAR_AP_Pos                     1U                                            /*!< MPU RBAR: AP Position */
+#define MPU_RBAR_AP_Msk                    (0x3UL << MPU_RBAR_AP_Pos)                     /*!< MPU RBAR: AP Mask */
+
+#define MPU_RBAR_XN_Pos                     0U                                            /*!< MPU RBAR: XN Position */
+#define MPU_RBAR_XN_Msk                    (01UL /*<< MPU_RBAR_XN_Pos*/)                  /*!< MPU RBAR: XN Mask */
+
+/* MPU Region Limit Address Register Definitions */
+#define MPU_RLAR_LIMIT_Pos                  5U                                            /*!< MPU RLAR: LIMIT Position */
+#define MPU_RLAR_LIMIT_Msk                 (0x7FFFFFFUL << MPU_RLAR_LIMIT_Pos)            /*!< MPU RLAR: LIMIT Mask */
+
+#define MPU_RLAR_AttrIndx_Pos               1U                                            /*!< MPU RLAR: AttrIndx Position */
+#define MPU_RLAR_AttrIndx_Msk              (0x7UL << MPU_RLAR_AttrIndx_Pos)               /*!< MPU RLAR: AttrIndx Mask */
+
+#define MPU_RLAR_EN_Pos                     0U                                            /*!< MPU RLAR: EN Position */
+#define MPU_RLAR_EN_Msk                    (1UL /*<< MPU_RLAR_EN_Pos*/)                   /*!< MPU RLAR: EN Mask */
+
+/* MPU Memory Attribute Indirection Register 0 Definitions */
+#define MPU_MAIR0_Attr3_Pos                24U                                            /*!< MPU MAIR0: Attr3 Position */
+#define MPU_MAIR0_Attr3_Msk                (0xFFUL << MPU_MAIR0_Attr3_Pos)                /*!< MPU MAIR0: Attr3 Mask */
+
+#define MPU_MAIR0_Attr2_Pos                16U                                            /*!< MPU MAIR0: Attr2 Position */
+#define MPU_MAIR0_Attr2_Msk                (0xFFUL << MPU_MAIR0_Attr2_Pos)                /*!< MPU MAIR0: Attr2 Mask */
+
+#define MPU_MAIR0_Attr1_Pos                 8U                                            /*!< MPU MAIR0: Attr1 Position */
+#define MPU_MAIR0_Attr1_Msk                (0xFFUL << MPU_MAIR0_Attr1_Pos)                /*!< MPU MAIR0: Attr1 Mask */
+
+#define MPU_MAIR0_Attr0_Pos                 0U                                            /*!< MPU MAIR0: Attr0 Position */
+#define MPU_MAIR0_Attr0_Msk                (0xFFUL /*<< MPU_MAIR0_Attr0_Pos*/)            /*!< MPU MAIR0: Attr0 Mask */
+
+/* MPU Memory Attribute Indirection Register 1 Definitions */
+#define MPU_MAIR1_Attr7_Pos                24U                                            /*!< MPU MAIR1: Attr7 Position */
+#define MPU_MAIR1_Attr7_Msk                (0xFFUL << MPU_MAIR1_Attr7_Pos)                /*!< MPU MAIR1: Attr7 Mask */
+
+#define MPU_MAIR1_Attr6_Pos                16U                                            /*!< MPU MAIR1: Attr6 Position */
+#define MPU_MAIR1_Attr6_Msk                (0xFFUL << MPU_MAIR1_Attr6_Pos)                /*!< MPU MAIR1: Attr6 Mask */
+
+#define MPU_MAIR1_Attr5_Pos                 8U                                            /*!< MPU MAIR1: Attr5 Position */
+#define MPU_MAIR1_Attr5_Msk                (0xFFUL << MPU_MAIR1_Attr5_Pos)                /*!< MPU MAIR1: Attr5 Mask */
+
+#define MPU_MAIR1_Attr4_Pos                 0U                                            /*!< MPU MAIR1: Attr4 Position */
+#define MPU_MAIR1_Attr4_Msk                (0xFFUL /*<< MPU_MAIR1_Attr4_Pos*/)            /*!< MPU MAIR1: Attr4 Mask */
+
+/*@} end of group CMSIS_MPU */
+#endif
+
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SAU     Security Attribution Unit (SAU)
+  \brief    Type definitions for the Security Attribution Unit (SAU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Security Attribution Unit (SAU).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  SAU Control Register */
+  __IM  uint32_t TYPE;                   /*!< Offset: 0x004 (R/ )  SAU Type Register */
+#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U)
+  __IOM uint32_t RNR;                    /*!< Offset: 0x008 (R/W)  SAU Region Number Register */
+  __IOM uint32_t RBAR;                   /*!< Offset: 0x00C (R/W)  SAU Region Base Address Register */
+  __IOM uint32_t RLAR;                   /*!< Offset: 0x010 (R/W)  SAU Region Limit Address Register */
+#endif
+} SAU_Type;
+
+/* SAU Control Register Definitions */
+#define SAU_CTRL_ALLNS_Pos                  1U                                            /*!< SAU CTRL: ALLNS Position */
+#define SAU_CTRL_ALLNS_Msk                 (1UL << SAU_CTRL_ALLNS_Pos)                    /*!< SAU CTRL: ALLNS Mask */
+
+#define SAU_CTRL_ENABLE_Pos                 0U                                            /*!< SAU CTRL: ENABLE Position */
+#define SAU_CTRL_ENABLE_Msk                (1UL /*<< SAU_CTRL_ENABLE_Pos*/)               /*!< SAU CTRL: ENABLE Mask */
+
+/* SAU Type Register Definitions */
+#define SAU_TYPE_SREGION_Pos                0U                                            /*!< SAU TYPE: SREGION Position */
+#define SAU_TYPE_SREGION_Msk               (0xFFUL /*<< SAU_TYPE_SREGION_Pos*/)           /*!< SAU TYPE: SREGION Mask */
+
+#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U)
+/* SAU Region Number Register Definitions */
+#define SAU_RNR_REGION_Pos                  0U                                            /*!< SAU RNR: REGION Position */
+#define SAU_RNR_REGION_Msk                 (0xFFUL /*<< SAU_RNR_REGION_Pos*/)             /*!< SAU RNR: REGION Mask */
+
+/* SAU Region Base Address Register Definitions */
+#define SAU_RBAR_BADDR_Pos                  5U                                            /*!< SAU RBAR: BADDR Position */
+#define SAU_RBAR_BADDR_Msk                 (0x7FFFFFFUL << SAU_RBAR_BADDR_Pos)            /*!< SAU RBAR: BADDR Mask */
+
+/* SAU Region Limit Address Register Definitions */
+#define SAU_RLAR_LADDR_Pos                  5U                                            /*!< SAU RLAR: LADDR Position */
+#define SAU_RLAR_LADDR_Msk                 (0x7FFFFFFUL << SAU_RLAR_LADDR_Pos)            /*!< SAU RLAR: LADDR Mask */
+
+#define SAU_RLAR_NSC_Pos                    1U                                            /*!< SAU RLAR: NSC Position */
+#define SAU_RLAR_NSC_Msk                   (1UL << SAU_RLAR_NSC_Pos)                      /*!< SAU RLAR: NSC Mask */
+
+#define SAU_RLAR_ENABLE_Pos                 0U                                            /*!< SAU RLAR: ENABLE Position */
+#define SAU_RLAR_ENABLE_Msk                (1UL /*<< SAU_RLAR_ENABLE_Pos*/)               /*!< SAU RLAR: ENABLE Mask */
+
+#endif /* defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) */
+
+/*@} end of group CMSIS_SAU */
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_CoreDebug       Core Debug Registers (CoreDebug)
+  \brief    Type definitions for the Core Debug Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Core Debug Register (CoreDebug).
+ */
+typedef struct
+{
+  __IOM uint32_t DHCSR;                  /*!< Offset: 0x000 (R/W)  Debug Halting Control and Status Register */
+  __OM  uint32_t DCRSR;                  /*!< Offset: 0x004 ( /W)  Debug Core Register Selector Register */
+  __IOM uint32_t DCRDR;                  /*!< Offset: 0x008 (R/W)  Debug Core Register Data Register */
+  __IOM uint32_t DEMCR;                  /*!< Offset: 0x00C (R/W)  Debug Exception and Monitor Control Register */
+        uint32_t RESERVED4[1U];
+  __IOM uint32_t DAUTHCTRL;              /*!< Offset: 0x014 (R/W)  Debug Authentication Control Register */
+  __IOM uint32_t DSCSR;                  /*!< Offset: 0x018 (R/W)  Debug Security Control and Status Register */
+} CoreDebug_Type;
+
+/* Debug Halting Control and Status Register Definitions */
+#define CoreDebug_DHCSR_DBGKEY_Pos         16U                                            /*!< CoreDebug DHCSR: DBGKEY Position */
+#define CoreDebug_DHCSR_DBGKEY_Msk         (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos)       /*!< CoreDebug DHCSR: DBGKEY Mask */
+
+#define CoreDebug_DHCSR_S_RESTART_ST_Pos   26U                                            /*!< CoreDebug DHCSR: S_RESTART_ST Position */
+#define CoreDebug_DHCSR_S_RESTART_ST_Msk   (1UL << CoreDebug_DHCSR_S_RESTART_ST_Pos)      /*!< CoreDebug DHCSR: S_RESTART_ST Mask */
+
+#define CoreDebug_DHCSR_S_RESET_ST_Pos     25U                                            /*!< CoreDebug DHCSR: S_RESET_ST Position */
+#define CoreDebug_DHCSR_S_RESET_ST_Msk     (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos)        /*!< CoreDebug DHCSR: S_RESET_ST Mask */
+
+#define CoreDebug_DHCSR_S_RETIRE_ST_Pos    24U                                            /*!< CoreDebug DHCSR: S_RETIRE_ST Position */
+#define CoreDebug_DHCSR_S_RETIRE_ST_Msk    (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos)       /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */
+
+#define CoreDebug_DHCSR_S_LOCKUP_Pos       19U                                            /*!< CoreDebug DHCSR: S_LOCKUP Position */
+#define CoreDebug_DHCSR_S_LOCKUP_Msk       (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos)          /*!< CoreDebug DHCSR: S_LOCKUP Mask */
+
+#define CoreDebug_DHCSR_S_SLEEP_Pos        18U                                            /*!< CoreDebug DHCSR: S_SLEEP Position */
+#define CoreDebug_DHCSR_S_SLEEP_Msk        (1UL << CoreDebug_DHCSR_S_SLEEP_Pos)           /*!< CoreDebug DHCSR: S_SLEEP Mask */
+
+#define CoreDebug_DHCSR_S_HALT_Pos         17U                                            /*!< CoreDebug DHCSR: S_HALT Position */
+#define CoreDebug_DHCSR_S_HALT_Msk         (1UL << CoreDebug_DHCSR_S_HALT_Pos)            /*!< CoreDebug DHCSR: S_HALT Mask */
+
+#define CoreDebug_DHCSR_S_REGRDY_Pos       16U                                            /*!< CoreDebug DHCSR: S_REGRDY Position */
+#define CoreDebug_DHCSR_S_REGRDY_Msk       (1UL << CoreDebug_DHCSR_S_REGRDY_Pos)          /*!< CoreDebug DHCSR: S_REGRDY Mask */
+
+#define CoreDebug_DHCSR_C_MASKINTS_Pos      3U                                            /*!< CoreDebug DHCSR: C_MASKINTS Position */
+#define CoreDebug_DHCSR_C_MASKINTS_Msk     (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos)        /*!< CoreDebug DHCSR: C_MASKINTS Mask */
+
+#define CoreDebug_DHCSR_C_STEP_Pos          2U                                            /*!< CoreDebug DHCSR: C_STEP Position */
+#define CoreDebug_DHCSR_C_STEP_Msk         (1UL << CoreDebug_DHCSR_C_STEP_Pos)            /*!< CoreDebug DHCSR: C_STEP Mask */
+
+#define CoreDebug_DHCSR_C_HALT_Pos          1U                                            /*!< CoreDebug DHCSR: C_HALT Position */
+#define CoreDebug_DHCSR_C_HALT_Msk         (1UL << CoreDebug_DHCSR_C_HALT_Pos)            /*!< CoreDebug DHCSR: C_HALT Mask */
+
+#define CoreDebug_DHCSR_C_DEBUGEN_Pos       0U                                            /*!< CoreDebug DHCSR: C_DEBUGEN Position */
+#define CoreDebug_DHCSR_C_DEBUGEN_Msk      (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/)     /*!< CoreDebug DHCSR: C_DEBUGEN Mask */
+
+/* Debug Core Register Selector Register Definitions */
+#define CoreDebug_DCRSR_REGWnR_Pos         16U                                            /*!< CoreDebug DCRSR: REGWnR Position */
+#define CoreDebug_DCRSR_REGWnR_Msk         (1UL << CoreDebug_DCRSR_REGWnR_Pos)            /*!< CoreDebug DCRSR: REGWnR Mask */
+
+#define CoreDebug_DCRSR_REGSEL_Pos          0U                                            /*!< CoreDebug DCRSR: REGSEL Position */
+#define CoreDebug_DCRSR_REGSEL_Msk         (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/)     /*!< CoreDebug DCRSR: REGSEL Mask */
+
+/* Debug Exception and Monitor Control Register */
+#define CoreDebug_DEMCR_DWTENA_Pos         24U                                            /*!< CoreDebug DEMCR: DWTENA Position */
+#define CoreDebug_DEMCR_DWTENA_Msk         (1UL << CoreDebug_DEMCR_DWTENA_Pos)            /*!< CoreDebug DEMCR: DWTENA Mask */
+
+#define CoreDebug_DEMCR_VC_HARDERR_Pos     10U                                            /*!< CoreDebug DEMCR: VC_HARDERR Position */
+#define CoreDebug_DEMCR_VC_HARDERR_Msk     (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos)        /*!< CoreDebug DEMCR: VC_HARDERR Mask */
+
+#define CoreDebug_DEMCR_VC_CORERESET_Pos    0U                                            /*!< CoreDebug DEMCR: VC_CORERESET Position */
+#define CoreDebug_DEMCR_VC_CORERESET_Msk   (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/)  /*!< CoreDebug DEMCR: VC_CORERESET Mask */
+
+/* Debug Authentication Control Register Definitions */
+#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos  3U                                            /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Position */
+#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos)    /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Mask */
+
+#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos  2U                                            /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Position */
+#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Msk (1UL << CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos)    /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Mask */
+
+#define CoreDebug_DAUTHCTRL_INTSPIDEN_Pos   1U                                            /*!< CoreDebug DAUTHCTRL: INTSPIDEN Position */
+#define CoreDebug_DAUTHCTRL_INTSPIDEN_Msk  (1UL << CoreDebug_DAUTHCTRL_INTSPIDEN_Pos)     /*!< CoreDebug DAUTHCTRL: INTSPIDEN Mask */
+
+#define CoreDebug_DAUTHCTRL_SPIDENSEL_Pos   0U                                            /*!< CoreDebug DAUTHCTRL: SPIDENSEL Position */
+#define CoreDebug_DAUTHCTRL_SPIDENSEL_Msk  (1UL /*<< CoreDebug_DAUTHCTRL_SPIDENSEL_Pos*/) /*!< CoreDebug DAUTHCTRL: SPIDENSEL Mask */
+
+/* Debug Security Control and Status Register Definitions */
+#define CoreDebug_DSCSR_CDS_Pos            16U                                            /*!< CoreDebug DSCSR: CDS Position */
+#define CoreDebug_DSCSR_CDS_Msk            (1UL << CoreDebug_DSCSR_CDS_Pos)               /*!< CoreDebug DSCSR: CDS Mask */
+
+#define CoreDebug_DSCSR_SBRSEL_Pos          1U                                            /*!< CoreDebug DSCSR: SBRSEL Position */
+#define CoreDebug_DSCSR_SBRSEL_Msk         (1UL << CoreDebug_DSCSR_SBRSEL_Pos)            /*!< CoreDebug DSCSR: SBRSEL Mask */
+
+#define CoreDebug_DSCSR_SBRSELEN_Pos        0U                                            /*!< CoreDebug DSCSR: SBRSELEN Position */
+#define CoreDebug_DSCSR_SBRSELEN_Msk       (1UL /*<< CoreDebug_DSCSR_SBRSELEN_Pos*/)      /*!< CoreDebug DSCSR: SBRSELEN Mask */
+
+/*@} end of group CMSIS_CoreDebug */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_core_bitfield     Core register bit field macros
+  \brief      Macros for use with bit field definitions (xxx_Pos, xxx_Msk).
+  @{
+ */
+
+/**
+  \brief   Mask and shift a bit field value for use in a register bit range.
+  \param[in] field  Name of the register bit field.
+  \param[in] value  Value of the bit field. This parameter is interpreted as an uint32_t type.
+  \return           Masked and shifted value.
+*/
+#define _VAL2FLD(field, value)    (((uint32_t)(value) << field ## _Pos) & field ## _Msk)
+
+/**
+  \brief     Mask and shift a register value to extract a bit filed value.
+  \param[in] field  Name of the register bit field.
+  \param[in] value  Value of register. This parameter is interpreted as an uint32_t type.
+  \return           Masked and shifted bit field value.
+*/
+#define _FLD2VAL(field, value)    (((uint32_t)(value) & field ## _Msk) >> field ## _Pos)
+
+/*@} end of group CMSIS_core_bitfield */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_core_base     Core Definitions
+  \brief      Definitions for base addresses, unions, and structures.
+  @{
+ */
+
+/* Memory mapping of Core Hardware */
+  #define SCS_BASE            (0xE000E000UL)                             /*!< System Control Space Base Address */
+  #define DWT_BASE            (0xE0001000UL)                             /*!< DWT Base Address */
+  #define TPI_BASE            (0xE0040000UL)                             /*!< TPI Base Address */
+  #define CoreDebug_BASE      (0xE000EDF0UL)                             /*!< Core Debug Base Address */
+  #define SysTick_BASE        (SCS_BASE +  0x0010UL)                     /*!< SysTick Base Address */
+  #define NVIC_BASE           (SCS_BASE +  0x0100UL)                     /*!< NVIC Base Address */
+  #define SCB_BASE            (SCS_BASE +  0x0D00UL)                     /*!< System Control Block Base Address */
+
+
+  #define SCB                 ((SCB_Type       *)     SCB_BASE         ) /*!< SCB configuration struct */
+  #define SysTick             ((SysTick_Type   *)     SysTick_BASE     ) /*!< SysTick configuration struct */
+  #define NVIC                ((NVIC_Type      *)     NVIC_BASE        ) /*!< NVIC configuration struct */
+  #define DWT                 ((DWT_Type       *)     DWT_BASE         ) /*!< DWT configuration struct */
+  #define TPI                 ((TPI_Type       *)     TPI_BASE         ) /*!< TPI configuration struct */
+  #define CoreDebug           ((CoreDebug_Type *)     CoreDebug_BASE   ) /*!< Core Debug configuration struct */
+
+  #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+    #define MPU_BASE          (SCS_BASE +  0x0D90UL)                     /*!< Memory Protection Unit */
+    #define MPU               ((MPU_Type       *)     MPU_BASE         ) /*!< Memory Protection Unit */
+  #endif
+
+  #if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+    #define SAU_BASE          (SCS_BASE +  0x0DD0UL)                     /*!< Security Attribution Unit */
+    #define SAU               ((SAU_Type       *)     SAU_BASE         ) /*!< Security Attribution Unit */
+  #endif
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+  #define SCS_BASE_NS         (0xE002E000UL)                             /*!< System Control Space Base Address (non-secure address space) */
+  #define CoreDebug_BASE_NS   (0xE002EDF0UL)                             /*!< Core Debug Base Address           (non-secure address space) */
+  #define SysTick_BASE_NS     (SCS_BASE_NS +  0x0010UL)                  /*!< SysTick Base Address              (non-secure address space) */
+  #define NVIC_BASE_NS        (SCS_BASE_NS +  0x0100UL)                  /*!< NVIC Base Address                 (non-secure address space) */
+  #define SCB_BASE_NS         (SCS_BASE_NS +  0x0D00UL)                  /*!< System Control Block Base Address (non-secure address space) */
+
+  #define SCB_NS              ((SCB_Type       *)     SCB_BASE_NS      ) /*!< SCB configuration struct          (non-secure address space) */
+  #define SysTick_NS          ((SysTick_Type   *)     SysTick_BASE_NS  ) /*!< SysTick configuration struct      (non-secure address space) */
+  #define NVIC_NS             ((NVIC_Type      *)     NVIC_BASE_NS     ) /*!< NVIC configuration struct         (non-secure address space) */
+  #define CoreDebug_NS        ((CoreDebug_Type *)     CoreDebug_BASE_NS) /*!< Core Debug configuration struct   (non-secure address space) */
+
+  #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+    #define MPU_BASE_NS       (SCS_BASE_NS +  0x0D90UL)                  /*!< Memory Protection Unit            (non-secure address space) */
+    #define MPU_NS            ((MPU_Type       *)     MPU_BASE_NS      ) /*!< Memory Protection Unit            (non-secure address space) */
+  #endif
+
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+/*@} */
+
+
+
+/*******************************************************************************
+ *                Hardware Abstraction Layer
+  Core Function Interface contains:
+  - Core NVIC Functions
+  - Core SysTick Functions
+  - Core Register Access Functions
+ ******************************************************************************/
+/**
+  \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference
+*/
+
+
+
+/* ##########################   NVIC functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_NVICFunctions NVIC Functions
+  \brief    Functions that manage interrupts and exceptions via the NVIC.
+  @{
+ */
+
+#ifdef CMSIS_NVIC_VIRTUAL
+  #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
+    #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
+  #endif
+  #include CMSIS_NVIC_VIRTUAL_HEADER_FILE
+#else
+/*#define NVIC_SetPriorityGrouping    __NVIC_SetPriorityGrouping   not available for Cortex-M23 */
+/*#define NVIC_GetPriorityGrouping    __NVIC_GetPriorityGrouping   not available for Cortex-M23 */
+  #define NVIC_EnableIRQ              __NVIC_EnableIRQ
+  #define NVIC_GetEnableIRQ           __NVIC_GetEnableIRQ
+  #define NVIC_DisableIRQ             __NVIC_DisableIRQ
+  #define NVIC_GetPendingIRQ          __NVIC_GetPendingIRQ
+  #define NVIC_SetPendingIRQ          __NVIC_SetPendingIRQ
+  #define NVIC_ClearPendingIRQ        __NVIC_ClearPendingIRQ
+  #define NVIC_GetActive              __NVIC_GetActive
+  #define NVIC_SetPriority            __NVIC_SetPriority
+  #define NVIC_GetPriority            __NVIC_GetPriority
+  #define NVIC_SystemReset            __NVIC_SystemReset
+#endif /* CMSIS_NVIC_VIRTUAL */
+
+#ifdef CMSIS_VECTAB_VIRTUAL
+  #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+    #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h"
+  #endif
+  #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetVector              __NVIC_SetVector
+  #define NVIC_GetVector              __NVIC_GetVector
+#endif  /* (CMSIS_VECTAB_VIRTUAL) */
+
+#define NVIC_USER_IRQ_OFFSET          16
+
+
+/* Special LR values for Secure/Non-Secure call handling and exception handling                                               */
+
+/* Function Return Payload (from ARMv8-M Architecture Reference Manual) LR value on entry from Secure BLXNS                   */ 
+#define FNC_RETURN                 (0xFEFFFFFFUL)     /* bit [0] ignored when processing a branch                             */
+
+/* The following EXC_RETURN mask values are used to evaluate the LR on exception entry */
+#define EXC_RETURN_PREFIX          (0xFF000000UL)     /* bits [31:24] set to indicate an EXC_RETURN value                     */
+#define EXC_RETURN_S               (0x00000040UL)     /* bit [6] stack used to push registers: 0=Non-secure 1=Secure          */
+#define EXC_RETURN_DCRS            (0x00000020UL)     /* bit [5] stacking rules for called registers: 0=skipped 1=saved       */
+#define EXC_RETURN_FTYPE           (0x00000010UL)     /* bit [4] allocate stack for floating-point context: 0=done 1=skipped  */
+#define EXC_RETURN_MODE            (0x00000008UL)     /* bit [3] processor mode for return: 0=Handler mode 1=Thread mode      */
+#define EXC_RETURN_SPSEL           (0x00000004UL)     /* bit [2] stack pointer used to restore context: 0=MSP 1=PSP           */
+#define EXC_RETURN_ES              (0x00000001UL)     /* bit [0] security state exception was taken to: 0=Non-secure 1=Secure */
+
+/* Integrity Signature (from ARMv8-M Architecture Reference Manual) for exception context stacking                            */
+#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)  /* Value for processors with floating-point extension:                  */
+#define EXC_INTEGRITY_SIGNATURE     (0xFEFA125AUL)     /* bit [0] SFTC must match LR bit[4] EXC_RETURN_FTYPE                   */
+#else 
+#define EXC_INTEGRITY_SIGNATURE     (0xFEFA125BUL)     /* Value for processors without floating-point extension                */
+#endif
+
+	
+/* Interrupt Priorities are WORD accessible only under Armv6-M                  */
+/* The following MACROS handle generation of the register offset and byte masks */
+#define _BIT_SHIFT(IRQn)         (  ((((uint32_t)(int32_t)(IRQn))         )      &  0x03UL) * 8UL)
+#define _SHP_IDX(IRQn)           ( (((((uint32_t)(int32_t)(IRQn)) & 0x0FUL)-8UL) >>    2UL)      )
+#define _IP_IDX(IRQn)            (   (((uint32_t)(int32_t)(IRQn))                >>    2UL)      )
+
+#define __NVIC_SetPriorityGrouping(X) (void)(X)
+#define __NVIC_GetPriorityGrouping()  (0U)
+
+/**
+  \brief   Enable Interrupt
+  \details Enables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Enable status
+  \details Returns a device specific interrupt enable status from the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt
+  \details Disables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
+  }
+}
+
+
+/**
+  \brief   Get Pending Interrupt
+  \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not pending.
+  \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Pending Interrupt
+  \details Sets the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Clear Pending Interrupt
+  \details Clears the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Active Interrupt
+  \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not active.
+  \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   Get Interrupt Target State
+  \details Reads the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+  \return             1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_GetTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Interrupt Target State
+  \details Sets the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+                      1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_SetTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] |=  ((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)));
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Clear Interrupt Target State
+  \details Clears the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+                      1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_ClearTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] &= ~((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)));
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+
+/**
+  \brief   Set Interrupt Priority
+  \details Sets the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]      IRQn  Interrupt number.
+  \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every processor exception.
+ */
+__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->IPR[_IP_IDX(IRQn)]  = ((uint32_t)(NVIC->IPR[_IP_IDX(IRQn)]  & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+       (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
+  }
+  else
+  {
+    SCB->SHPR[_SHP_IDX(IRQn)] = ((uint32_t)(SCB->SHPR[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+       (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Priority
+  \details Reads the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn  Interrupt number.
+  \return             Interrupt Priority.
+                      Value is aligned automatically to the implemented priority bits of the microcontroller.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn)
+{
+
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->IPR[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+  }
+  else
+  {
+    return((uint32_t)(((SCB->SHPR[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+  }
+}
+
+
+/**
+  \brief   Encode Priority
+  \details Encodes the priority for an interrupt with the given priority group,
+           preemptive priority value, and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]     PriorityGroup  Used priority group.
+  \param [in]   PreemptPriority  Preemptive priority value (starting from 0).
+  \param [in]       SubPriority  Subpriority value (starting from 0).
+  \return                        Encoded priority. Value can be used in the function \ref NVIC_SetPriority().
+ */
+__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  return (
+           ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) |
+           ((SubPriority     & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL)))
+         );
+}
+
+
+/**
+  \brief   Decode Priority
+  \details Decodes an interrupt priority value with a given priority group to
+           preemptive priority value and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set.
+  \param [in]         Priority   Priority value, which can be retrieved with the function \ref NVIC_GetPriority().
+  \param [in]     PriorityGroup  Used priority group.
+  \param [out] pPreemptPriority  Preemptive priority value (starting from 0).
+  \param [out]     pSubPriority  Subpriority value (starting from 0).
+ */
+__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL);
+  *pSubPriority     = (Priority                   ) & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL);
+}
+
+
+/**
+  \brief   Set Interrupt Vector
+  \details Sets an interrupt vector in SRAM based interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+           VTOR must been relocated to SRAM before.
+           If VTOR is not present address 0 must be mapped to SRAM.
+  \param [in]   IRQn      Interrupt number
+  \param [in]   vector    Address of interrupt handler function
+ */
+__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
+{
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+#else
+  uint32_t *vectors = (uint32_t *)0x0U;
+#endif
+  vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector;
+}
+
+
+/**
+  \brief   Get Interrupt Vector
+  \details Reads an interrupt vector from interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn      Interrupt number.
+  \return                 Address of interrupt handler function
+ */
+__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn)
+{
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+#else
+  uint32_t *vectors = (uint32_t *)0x0U;
+#endif
+  return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET];
+}
+
+
+/**
+  \brief   System Reset
+  \details Initiates a system reset request to reset the MCU.
+ */
+__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void)
+{
+  __DSB();                                                          /* Ensure all outstanding memory accesses included
+                                                                       buffered write are completed before reset */
+  SCB->AIRCR  = ((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
+                 SCB_AIRCR_SYSRESETREQ_Msk);
+  __DSB();                                                          /* Ensure completion of memory access */
+
+  for(;;)                                                           /* wait until reset */
+  {
+    __NOP();
+  }
+}
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   Enable Interrupt (non-secure)
+  \details Enables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_EnableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Enable status (non-secure)
+  \details Returns a device specific interrupt enable status from the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetEnableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt (non-secure)
+  \details Disables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_DisableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Pending Interrupt (non-secure)
+  \details Reads the NVIC pending register in the non-secure NVIC when in secure state and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not pending.
+  \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Pending Interrupt (non-secure)
+  \details Sets the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Clear Pending Interrupt (non-secure)
+  \details Clears the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_ClearPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Active Interrupt (non-secure)
+  \details Reads the active register in non-secure NVIC when in secure state and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not active.
+  \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetActive_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Interrupt Priority (non-secure)
+  \details Sets the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]      IRQn  Interrupt number.
+  \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every non-secure processor exception.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPriority_NS(IRQn_Type IRQn, uint32_t priority)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->IPR[_IP_IDX(IRQn)]  = ((uint32_t)(NVIC_NS->IPR[_IP_IDX(IRQn)]  & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+       (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
+  }
+  else
+  {
+    SCB_NS->SHPR[_SHP_IDX(IRQn)] = ((uint32_t)(SCB_NS->SHPR[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+       (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Priority (non-secure)
+  \details Reads the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn  Interrupt number.
+  \return             Interrupt Priority. Value is aligned automatically to the implemented priority bits of the microcontroller.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPriority_NS(IRQn_Type IRQn)
+{
+
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->IPR[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+  }
+  else
+  {
+    return((uint32_t)(((SCB_NS->SHPR[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+  }
+}
+#endif /*  defined (__ARM_FEATURE_CMSE) &&(__ARM_FEATURE_CMSE == 3U) */
+
+/*@} end of CMSIS_Core_NVICFunctions */
+
+/* ##########################  MPU functions  #################################### */
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+
+#include "mpu_armv8.h"
+
+#endif
+
+/* ##########################  FPU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_FpuFunctions FPU Functions
+  \brief    Function that provides FPU type.
+  @{
+ */
+
+/**
+  \brief   get FPU type
+  \details returns the FPU type
+  \returns
+   - \b  0: No FPU
+   - \b  1: Single precision FPU
+   - \b  2: Double + Single precision FPU
+ */
+__STATIC_INLINE uint32_t SCB_GetFPUType(void)
+{
+    return 0U;           /* No FPU */
+}
+
+
+/*@} end of CMSIS_Core_FpuFunctions */
+
+
+
+/* ##########################   SAU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_SAUFunctions SAU Functions
+  \brief    Functions that configure the SAU.
+  @{
+ */
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+
+/**
+  \brief   Enable SAU
+  \details Enables the Security Attribution Unit (SAU).
+ */
+__STATIC_INLINE void TZ_SAU_Enable(void)
+{
+    SAU->CTRL |=  (SAU_CTRL_ENABLE_Msk);
+}
+
+
+
+/**
+  \brief   Disable SAU
+  \details Disables the Security Attribution Unit (SAU).
+ */
+__STATIC_INLINE void TZ_SAU_Disable(void)
+{
+    SAU->CTRL &= ~(SAU_CTRL_ENABLE_Msk);
+}
+
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+/*@} end of CMSIS_Core_SAUFunctions */
+
+
+
+
+/* ##################################    SysTick function  ############################################ */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_SysTickFunctions SysTick Functions
+  \brief    Functions that configure the System.
+  @{
+ */
+
+#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
+
+/**
+  \brief   System Tick Configuration
+  \details Initializes the System Timer and its interrupt, and starts the System Tick Timer.
+           Counter is in free running mode to generate periodic interrupts.
+  \param [in]  ticks  Number of ticks between two interrupts.
+  \return          0  Function succeeded.
+  \return          1  Function failed.
+  \note    When the variable <b>__Vendor_SysTickConfig</b> is set to 1, then the
+           function <b>SysTick_Config</b> is not included. In this case, the file <b><i>device</i>.h</b>
+           must contain a vendor-specific implementation of this function.
+ */
+__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
+{
+  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
+  {
+    return (1UL);                                                   /* Reload value impossible */
+  }
+
+  SysTick->LOAD  = (uint32_t)(ticks - 1UL);                         /* set reload register */
+  NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
+  SysTick->VAL   = 0UL;                                             /* Load the SysTick Counter Value */
+  SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
+                   SysTick_CTRL_TICKINT_Msk   |
+                   SysTick_CTRL_ENABLE_Msk;                         /* Enable SysTick IRQ and SysTick Timer */
+  return (0UL);                                                     /* Function successful */
+}
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   System Tick Configuration (non-secure)
+  \details Initializes the non-secure System Timer and its interrupt when in secure state, and starts the System Tick Timer.
+           Counter is in free running mode to generate periodic interrupts.
+  \param [in]  ticks  Number of ticks between two interrupts.
+  \return          0  Function succeeded.
+  \return          1  Function failed.
+  \note    When the variable <b>__Vendor_SysTickConfig</b> is set to 1, then the
+           function <b>TZ_SysTick_Config_NS</b> is not included. In this case, the file <b><i>device</i>.h</b>
+           must contain a vendor-specific implementation of this function.
+
+ */
+__STATIC_INLINE uint32_t TZ_SysTick_Config_NS(uint32_t ticks)
+{
+  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
+  {
+    return (1UL);                                                         /* Reload value impossible */
+  }
+
+  SysTick_NS->LOAD  = (uint32_t)(ticks - 1UL);                            /* set reload register */
+  TZ_NVIC_SetPriority_NS (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
+  SysTick_NS->VAL   = 0UL;                                                /* Load the SysTick Counter Value */
+  SysTick_NS->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
+                      SysTick_CTRL_TICKINT_Msk   |
+                      SysTick_CTRL_ENABLE_Msk;                            /* Enable SysTick IRQ and SysTick Timer */
+  return (0UL);                                                           /* Function successful */
+}
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+#endif
+
+/*@} end of CMSIS_Core_SysTickFunctions */
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CORE_CM23_H_DEPENDANT */
+
+#endif /* __CMSIS_GENERIC */
diff --git a/lib/cmsis/inc/core_cm3.h b/lib/cmsis/inc/core_cm3.h
index b4ac4c7b05a79..ea5405088c3ef 100644
--- a/lib/cmsis/inc/core_cm3.h
+++ b/lib/cmsis/inc/core_cm3.h
@@ -1,40 +1,30 @@
 /**************************************************************************//**
  * @file     core_cm3.h
  * @brief    CMSIS Cortex-M3 Core Peripheral Access Layer Header File
- * @version  V4.30
- * @date     20. October 2015
+ * @version  V5.1.0
+ * @date     13. March 2019
  ******************************************************************************/
-/* Copyright (c) 2009 - 2015 ARM LIMITED
-
-   All rights reserved.
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-   - Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in the
-     documentation and/or other materials provided with the distribution.
-   - Neither the name of ARM nor the names of its contributors may be used
-     to endorse or promote products derived from this software without
-     specific prior written permission.
-   *
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
-   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-   POSSIBILITY OF SUCH DAMAGE.
-   ---------------------------------------------------------------------------*/
-
+/*
+ * Copyright (c) 2009-2019 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #if   defined ( __ICCARM__ )
- #pragma system_include         /* treat file as system include file for MISRA check */
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
   #pragma clang system_header   /* treat file as system include file */
 #endif
 
@@ -70,53 +60,15 @@
   @{
  */
 
+#include "cmsis_version.h"
+
 /*  CMSIS CM3 definitions */
-#define __CM3_CMSIS_VERSION_MAIN  (0x04U)                                      /*!< [31:16] CMSIS HAL main version */
-#define __CM3_CMSIS_VERSION_SUB   (0x1EU)                                      /*!< [15:0]  CMSIS HAL sub version */
+#define __CM3_CMSIS_VERSION_MAIN  (__CM_CMSIS_VERSION_MAIN)              /*!< \deprecated [31:16] CMSIS HAL main version */
+#define __CM3_CMSIS_VERSION_SUB   (__CM_CMSIS_VERSION_SUB)               /*!< \deprecated [15:0]  CMSIS HAL sub version */
 #define __CM3_CMSIS_VERSION       ((__CM3_CMSIS_VERSION_MAIN << 16U) | \
-                                    __CM3_CMSIS_VERSION_SUB           )        /*!< CMSIS HAL version number */
-
-#define __CORTEX_M                (0x03U)                                      /*!< Cortex-M Core */
-
-
-#if   defined ( __CC_ARM )
-  #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler */
-  #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler */
-  #define __STATIC_INLINE  static __inline
-
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler */
-  #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler */
-  #define __STATIC_INLINE  static __inline
-
-#elif defined ( __GNUC__ )
-  #define __ASM            __asm                                      /*!< asm keyword for GNU Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for GNU Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __ICCARM__ )
-  #define __ASM            __asm                                      /*!< asm keyword for IAR Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for IAR Compiler. Only available in High optimization mode! */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __TMS470__ )
-  #define __ASM            __asm                                      /*!< asm keyword for TI CCS Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __TASKING__ )
-  #define __ASM            __asm                                      /*!< asm keyword for TASKING Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for TASKING Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __CSMC__ )
-  #define __packed
-  #define __ASM            _asm                                      /*!< asm keyword for COSMIC Compiler */
-  #define __INLINE         inline                                    /*!< inline keyword for COSMIC Compiler. Use -pc99 on compile line */
-  #define __STATIC_INLINE  static inline
+                                    __CM3_CMSIS_VERSION_SUB           )  /*!< \deprecated CMSIS HAL version number */
 
-#else
-  #error Unknown compiler
-#endif
+#define __CORTEX_M                (3U)                                   /*!< Cortex-M Core */
 
 /** __FPU_USED indicates whether an FPU is used or not.
     This core does not support an FPU at all
@@ -128,8 +80,8 @@
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #if defined __ARM_PCS_VFP
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #if defined __ARM_FP
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
@@ -143,7 +95,7 @@
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
-#elif defined ( __TMS470__ )
+#elif defined ( __TI_ARM__ )
   #if defined __TI_VFP_SUPPORT__
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
@@ -160,8 +112,8 @@
 
 #endif
 
-#include "core_cmInstr.h"                /* Core Instruction Access */
-#include "core_cmFunc.h"                 /* Core Function Access */
+#include "cmsis_compiler.h"               /* CMSIS compiler specific defines */
+
 
 #ifdef __cplusplus
 }
@@ -191,7 +143,7 @@
   #endif
 
   #ifndef __NVIC_PRIO_BITS
-    #define __NVIC_PRIO_BITS          4U
+    #define __NVIC_PRIO_BITS          3U
     #warning "__NVIC_PRIO_BITS not defined in device header file; using default!"
   #endif
 
@@ -308,9 +260,11 @@ typedef union
   struct
   {
     uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
-    uint32_t _reserved0:15;              /*!< bit:  9..23  Reserved */
-    uint32_t T:1;                        /*!< bit:     24  Thumb bit        (read 0) */
-    uint32_t IT:2;                       /*!< bit: 25..26  saved IT state   (read 0) */
+    uint32_t _reserved0:1;               /*!< bit:      9  Reserved */
+    uint32_t ICI_IT_1:6;                 /*!< bit: 10..15  ICI/IT part 1 */
+    uint32_t _reserved1:8;               /*!< bit: 16..23  Reserved */
+    uint32_t T:1;                        /*!< bit:     24  Thumb bit */
+    uint32_t ICI_IT_2:2;                 /*!< bit: 25..26  ICI/IT part 2 */
     uint32_t Q:1;                        /*!< bit:     27  Saturation condition flag */
     uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
     uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
@@ -336,12 +290,15 @@ typedef union
 #define xPSR_Q_Pos                         27U                                            /*!< xPSR: Q Position */
 #define xPSR_Q_Msk                         (1UL << xPSR_Q_Pos)                            /*!< xPSR: Q Mask */
 
-#define xPSR_IT_Pos                        25U                                            /*!< xPSR: IT Position */
-#define xPSR_IT_Msk                        (3UL << xPSR_IT_Pos)                           /*!< xPSR: IT Mask */
+#define xPSR_ICI_IT_2_Pos                  25U                                            /*!< xPSR: ICI/IT part 2 Position */
+#define xPSR_ICI_IT_2_Msk                  (3UL << xPSR_ICI_IT_2_Pos)                     /*!< xPSR: ICI/IT part 2 Mask */
 
 #define xPSR_T_Pos                         24U                                            /*!< xPSR: T Position */
 #define xPSR_T_Msk                         (1UL << xPSR_T_Pos)                            /*!< xPSR: T Mask */
 
+#define xPSR_ICI_IT_1_Pos                  10U                                            /*!< xPSR: ICI/IT part 1 Position */
+#define xPSR_ICI_IT_1_Msk                  (0x3FUL << xPSR_ICI_IT_1_Pos)                  /*!< xPSR: ICI/IT part 1 Mask */
+
 #define xPSR_ISR_Pos                        0U                                            /*!< xPSR: ISR Position */
 #define xPSR_ISR_Msk                       (0x1FFUL /*<< xPSR_ISR_Pos*/)                  /*!< xPSR: ISR Mask */
 
@@ -385,7 +342,7 @@ typedef struct
   __IOM uint32_t ISER[8U];               /*!< Offset: 0x000 (R/W)  Interrupt Set Enable Register */
         uint32_t RESERVED0[24U];
   __IOM uint32_t ICER[8U];               /*!< Offset: 0x080 (R/W)  Interrupt Clear Enable Register */
-        uint32_t RSERVED1[24U];
+        uint32_t RESERVED1[24U];
   __IOM uint32_t ISPR[8U];               /*!< Offset: 0x100 (R/W)  Interrupt Set Pending Register */
         uint32_t RESERVED2[24U];
   __IOM uint32_t ICPR[8U];               /*!< Offset: 0x180 (R/W)  Interrupt Clear Pending Register */
@@ -487,7 +444,7 @@ typedef struct
 #define SCB_ICSR_VECTACTIVE_Msk            (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/)       /*!< SCB ICSR: VECTACTIVE Mask */
 
 /* SCB Vector Table Offset Register Definitions */
-#if (__CM3_REV < 0x0201U)                   /* core r2p1 */
+#if defined (__CM3_REV) && (__CM3_REV < 0x0201U)                   /* core r2p1 */
 #define SCB_VTOR_TBLBASE_Pos               29U                                            /*!< SCB VTOR: TBLBASE Position */
 #define SCB_VTOR_TBLBASE_Msk               (1UL << SCB_VTOR_TBLBASE_Pos)                  /*!< SCB VTOR: TBLBASE Mask */
 
@@ -602,6 +559,60 @@ typedef struct
 #define SCB_CFSR_MEMFAULTSR_Pos             0U                                            /*!< SCB CFSR: Memory Manage Fault Status Register Position */
 #define SCB_CFSR_MEMFAULTSR_Msk            (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/)        /*!< SCB CFSR: Memory Manage Fault Status Register Mask */
 
+/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_MMARVALID_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 7U)               /*!< SCB CFSR (MMFSR): MMARVALID Position */
+#define SCB_CFSR_MMARVALID_Msk             (1UL << SCB_CFSR_MMARVALID_Pos)                /*!< SCB CFSR (MMFSR): MMARVALID Mask */
+
+#define SCB_CFSR_MSTKERR_Pos               (SCB_SHCSR_MEMFAULTACT_Pos + 4U)               /*!< SCB CFSR (MMFSR): MSTKERR Position */
+#define SCB_CFSR_MSTKERR_Msk               (1UL << SCB_CFSR_MSTKERR_Pos)                  /*!< SCB CFSR (MMFSR): MSTKERR Mask */
+
+#define SCB_CFSR_MUNSTKERR_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 3U)               /*!< SCB CFSR (MMFSR): MUNSTKERR Position */
+#define SCB_CFSR_MUNSTKERR_Msk             (1UL << SCB_CFSR_MUNSTKERR_Pos)                /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */
+
+#define SCB_CFSR_DACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 1U)               /*!< SCB CFSR (MMFSR): DACCVIOL Position */
+#define SCB_CFSR_DACCVIOL_Msk              (1UL << SCB_CFSR_DACCVIOL_Pos)                 /*!< SCB CFSR (MMFSR): DACCVIOL Mask */
+
+#define SCB_CFSR_IACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 0U)               /*!< SCB CFSR (MMFSR): IACCVIOL Position */
+#define SCB_CFSR_IACCVIOL_Msk              (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/)             /*!< SCB CFSR (MMFSR): IACCVIOL Mask */
+
+/* BusFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_BFARVALID_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 7U)                  /*!< SCB CFSR (BFSR): BFARVALID Position */
+#define SCB_CFSR_BFARVALID_Msk            (1UL << SCB_CFSR_BFARVALID_Pos)                 /*!< SCB CFSR (BFSR): BFARVALID Mask */
+
+#define SCB_CFSR_STKERR_Pos               (SCB_CFSR_BUSFAULTSR_Pos + 4U)                  /*!< SCB CFSR (BFSR): STKERR Position */
+#define SCB_CFSR_STKERR_Msk               (1UL << SCB_CFSR_STKERR_Pos)                    /*!< SCB CFSR (BFSR): STKERR Mask */
+
+#define SCB_CFSR_UNSTKERR_Pos             (SCB_CFSR_BUSFAULTSR_Pos + 3U)                  /*!< SCB CFSR (BFSR): UNSTKERR Position */
+#define SCB_CFSR_UNSTKERR_Msk             (1UL << SCB_CFSR_UNSTKERR_Pos)                  /*!< SCB CFSR (BFSR): UNSTKERR Mask */
+
+#define SCB_CFSR_IMPRECISERR_Pos          (SCB_CFSR_BUSFAULTSR_Pos + 2U)                  /*!< SCB CFSR (BFSR): IMPRECISERR Position */
+#define SCB_CFSR_IMPRECISERR_Msk          (1UL << SCB_CFSR_IMPRECISERR_Pos)               /*!< SCB CFSR (BFSR): IMPRECISERR Mask */
+
+#define SCB_CFSR_PRECISERR_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 1U)                  /*!< SCB CFSR (BFSR): PRECISERR Position */
+#define SCB_CFSR_PRECISERR_Msk            (1UL << SCB_CFSR_PRECISERR_Pos)                 /*!< SCB CFSR (BFSR): PRECISERR Mask */
+
+#define SCB_CFSR_IBUSERR_Pos              (SCB_CFSR_BUSFAULTSR_Pos + 0U)                  /*!< SCB CFSR (BFSR): IBUSERR Position */
+#define SCB_CFSR_IBUSERR_Msk              (1UL << SCB_CFSR_IBUSERR_Pos)                   /*!< SCB CFSR (BFSR): IBUSERR Mask */
+
+/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_DIVBYZERO_Pos            (SCB_CFSR_USGFAULTSR_Pos + 9U)                  /*!< SCB CFSR (UFSR): DIVBYZERO Position */
+#define SCB_CFSR_DIVBYZERO_Msk            (1UL << SCB_CFSR_DIVBYZERO_Pos)                 /*!< SCB CFSR (UFSR): DIVBYZERO Mask */
+
+#define SCB_CFSR_UNALIGNED_Pos            (SCB_CFSR_USGFAULTSR_Pos + 8U)                  /*!< SCB CFSR (UFSR): UNALIGNED Position */
+#define SCB_CFSR_UNALIGNED_Msk            (1UL << SCB_CFSR_UNALIGNED_Pos)                 /*!< SCB CFSR (UFSR): UNALIGNED Mask */
+
+#define SCB_CFSR_NOCP_Pos                 (SCB_CFSR_USGFAULTSR_Pos + 3U)                  /*!< SCB CFSR (UFSR): NOCP Position */
+#define SCB_CFSR_NOCP_Msk                 (1UL << SCB_CFSR_NOCP_Pos)                      /*!< SCB CFSR (UFSR): NOCP Mask */
+
+#define SCB_CFSR_INVPC_Pos                (SCB_CFSR_USGFAULTSR_Pos + 2U)                  /*!< SCB CFSR (UFSR): INVPC Position */
+#define SCB_CFSR_INVPC_Msk                (1UL << SCB_CFSR_INVPC_Pos)                     /*!< SCB CFSR (UFSR): INVPC Mask */
+
+#define SCB_CFSR_INVSTATE_Pos             (SCB_CFSR_USGFAULTSR_Pos + 1U)                  /*!< SCB CFSR (UFSR): INVSTATE Position */
+#define SCB_CFSR_INVSTATE_Msk             (1UL << SCB_CFSR_INVSTATE_Pos)                  /*!< SCB CFSR (UFSR): INVSTATE Mask */
+
+#define SCB_CFSR_UNDEFINSTR_Pos           (SCB_CFSR_USGFAULTSR_Pos + 0U)                  /*!< SCB CFSR (UFSR): UNDEFINSTR Position */
+#define SCB_CFSR_UNDEFINSTR_Msk           (1UL << SCB_CFSR_UNDEFINSTR_Pos)                /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */
+
 /* SCB Hard Fault Status Register Definitions */
 #define SCB_HFSR_DEBUGEVT_Pos              31U                                            /*!< SCB HFSR: DEBUGEVT Position */
 #define SCB_HFSR_DEBUGEVT_Msk              (1UL << SCB_HFSR_DEBUGEVT_Pos)                 /*!< SCB HFSR: DEBUGEVT Mask */
@@ -645,7 +656,7 @@ typedef struct
 {
         uint32_t RESERVED0[1U];
   __IM  uint32_t ICTR;                   /*!< Offset: 0x004 (R/ )  Interrupt Controller Type Register */
-#if ((defined __CM3_REV) && (__CM3_REV >= 0x200U))
+#if defined (__CM3_REV) && (__CM3_REV >= 0x200U)
   __IOM uint32_t ACTLR;                  /*!< Offset: 0x008 (R/W)  Auxiliary Control Register */
 #else
         uint32_t RESERVED1[1U];
@@ -657,6 +668,12 @@ typedef struct
 #define SCnSCB_ICTR_INTLINESNUM_Msk        (0xFUL /*<< SCnSCB_ICTR_INTLINESNUM_Pos*/)  /*!< ICTR: INTLINESNUM Mask */
 
 /* Auxiliary Control Register Definitions */
+#if defined (__CM3_REV) && (__CM3_REV >= 0x200U)
+#define SCnSCB_ACTLR_DISOOFP_Pos            9U                                         /*!< ACTLR: DISOOFP Position */
+#define SCnSCB_ACTLR_DISOOFP_Msk           (1UL << SCnSCB_ACTLR_DISOOFP_Pos)           /*!< ACTLR: DISOOFP Mask */
+
+#define SCnSCB_ACTLR_DISFPCA_Pos            8U                                         /*!< ACTLR: DISFPCA Position */
+#define SCnSCB_ACTLR_DISFPCA_Msk           (1UL << SCnSCB_ACTLR_DISFPCA_Pos)           /*!< ACTLR: DISFPCA Mask */
 
 #define SCnSCB_ACTLR_DISFOLD_Pos            2U                                         /*!< ACTLR: DISFOLD Position */
 #define SCnSCB_ACTLR_DISFOLD_Msk           (1UL << SCnSCB_ACTLR_DISFOLD_Pos)           /*!< ACTLR: DISFOLD Mask */
@@ -666,6 +683,7 @@ typedef struct
 
 #define SCnSCB_ACTLR_DISMCYCINT_Pos         0U                                         /*!< ACTLR: DISMCYCINT Position */
 #define SCnSCB_ACTLR_DISMCYCINT_Msk        (1UL /*<< SCnSCB_ACTLR_DISMCYCINT_Pos*/)    /*!< ACTLR: DISMCYCINT Mask */
+#endif
 
 /*@} end of group CMSIS_SCnotSCB */
 
@@ -746,10 +764,7 @@ typedef struct
   __IOM uint32_t TPR;                    /*!< Offset: 0xE40 (R/W)  ITM Trace Privilege Register */
         uint32_t RESERVED2[15U];
   __IOM uint32_t TCR;                    /*!< Offset: 0xE80 (R/W)  ITM Trace Control Register */
-        uint32_t RESERVED3[29U];
-  __OM  uint32_t IWR;                    /*!< Offset: 0xEF8 ( /W)  ITM Integration Write Register */
-  __IM  uint32_t IRR;                    /*!< Offset: 0xEFC (R/ )  ITM Integration Read Register */
-  __IOM uint32_t IMCR;                   /*!< Offset: 0xF00 (R/W)  ITM Integration Mode Control Register */
+        uint32_t RESERVED3[32U];
         uint32_t RESERVED4[43U];
   __OM  uint32_t LAR;                    /*!< Offset: 0xFB0 ( /W)  ITM Lock Access Register */
   __IM  uint32_t LSR;                    /*!< Offset: 0xFB4 (R/ )  ITM Lock Status Register */
@@ -770,7 +785,7 @@ typedef struct
 
 /* ITM Trace Privilege Register Definitions */
 #define ITM_TPR_PRIVMASK_Pos                0U                                            /*!< ITM TPR: PRIVMASK Position */
-#define ITM_TPR_PRIVMASK_Msk               (0xFUL /*<< ITM_TPR_PRIVMASK_Pos*/)            /*!< ITM TPR: PRIVMASK Mask */
+#define ITM_TPR_PRIVMASK_Msk               (0xFFFFFFFFUL /*<< ITM_TPR_PRIVMASK_Pos*/)     /*!< ITM TPR: PRIVMASK Mask */
 
 /* ITM Trace Control Register Definitions */
 #define ITM_TCR_BUSY_Pos                   23U                                            /*!< ITM TCR: BUSY Position */
@@ -800,18 +815,6 @@ typedef struct
 #define ITM_TCR_ITMENA_Pos                  0U                                            /*!< ITM TCR: ITM Enable bit Position */
 #define ITM_TCR_ITMENA_Msk                 (1UL /*<< ITM_TCR_ITMENA_Pos*/)                /*!< ITM TCR: ITM Enable bit Mask */
 
-/* ITM Integration Write Register Definitions */
-#define ITM_IWR_ATVALIDM_Pos                0U                                            /*!< ITM IWR: ATVALIDM Position */
-#define ITM_IWR_ATVALIDM_Msk               (1UL /*<< ITM_IWR_ATVALIDM_Pos*/)              /*!< ITM IWR: ATVALIDM Mask */
-
-/* ITM Integration Read Register Definitions */
-#define ITM_IRR_ATREADYM_Pos                0U                                            /*!< ITM IRR: ATREADYM Position */
-#define ITM_IRR_ATREADYM_Msk               (1UL /*<< ITM_IRR_ATREADYM_Pos*/)              /*!< ITM IRR: ATREADYM Mask */
-
-/* ITM Integration Mode Control Register Definitions */
-#define ITM_IMCR_INTEGRATION_Pos            0U                                            /*!< ITM IMCR: INTEGRATION Position */
-#define ITM_IMCR_INTEGRATION_Msk           (1UL /*<< ITM_IMCR_INTEGRATION_Pos*/)          /*!< ITM IMCR: INTEGRATION Mask */
-
 /* ITM Lock Status Register Definitions */
 #define ITM_LSR_ByteAcc_Pos                 2U                                            /*!< ITM LSR: ByteAcc Position */
 #define ITM_LSR_ByteAcc_Msk                (1UL << ITM_LSR_ByteAcc_Pos)                   /*!< ITM LSR: ByteAcc Mask */
@@ -984,7 +987,7 @@ typedef struct
  */
 typedef struct
 {
-  __IOM uint32_t SSPSR;                  /*!< Offset: 0x000 (R/ )  Supported Parallel Port Size Register */
+  __IM  uint32_t SSPSR;                  /*!< Offset: 0x000 (R/ )  Supported Parallel Port Size Register */
   __IOM uint32_t CSPSR;                  /*!< Offset: 0x004 (R/W)  Current Parallel Port Size Register */
         uint32_t RESERVED0[2U];
   __IOM uint32_t ACPR;                   /*!< Offset: 0x010 (R/W)  Asynchronous Clock Prescaler Register */
@@ -995,7 +998,7 @@ typedef struct
   __IOM uint32_t FFCR;                   /*!< Offset: 0x304 (R/W)  Formatter and Flush Control Register */
   __IM  uint32_t FSCR;                   /*!< Offset: 0x308 (R/ )  Formatter Synchronization Counter Register */
         uint32_t RESERVED3[759U];
-  __IM  uint32_t TRIGGER;                /*!< Offset: 0xEE8 (R/ )  TRIGGER */
+  __IM  uint32_t TRIGGER;                /*!< Offset: 0xEE8 (R/ )  TRIGGER Register */
   __IM  uint32_t FIFO0;                  /*!< Offset: 0xEEC (R/ )  Integration ETM Data */
   __IM  uint32_t ITATBCTR2;              /*!< Offset: 0xEF0 (R/ )  ITATBCTR2 */
         uint32_t RESERVED4[1U];
@@ -1044,13 +1047,13 @@ typedef struct
 
 /* TPI Integration ETM Data Register Definitions (FIFO0) */
 #define TPI_FIFO0_ITM_ATVALID_Pos          29U                                         /*!< TPI FIFO0: ITM_ATVALID Position */
-#define TPI_FIFO0_ITM_ATVALID_Msk          (0x3UL << TPI_FIFO0_ITM_ATVALID_Pos)        /*!< TPI FIFO0: ITM_ATVALID Mask */
+#define TPI_FIFO0_ITM_ATVALID_Msk          (0x1UL << TPI_FIFO0_ITM_ATVALID_Pos)        /*!< TPI FIFO0: ITM_ATVALID Mask */
 
 #define TPI_FIFO0_ITM_bytecount_Pos        27U                                         /*!< TPI FIFO0: ITM_bytecount Position */
 #define TPI_FIFO0_ITM_bytecount_Msk        (0x3UL << TPI_FIFO0_ITM_bytecount_Pos)      /*!< TPI FIFO0: ITM_bytecount Mask */
 
 #define TPI_FIFO0_ETM_ATVALID_Pos          26U                                         /*!< TPI FIFO0: ETM_ATVALID Position */
-#define TPI_FIFO0_ETM_ATVALID_Msk          (0x3UL << TPI_FIFO0_ETM_ATVALID_Pos)        /*!< TPI FIFO0: ETM_ATVALID Mask */
+#define TPI_FIFO0_ETM_ATVALID_Msk          (0x1UL << TPI_FIFO0_ETM_ATVALID_Pos)        /*!< TPI FIFO0: ETM_ATVALID Mask */
 
 #define TPI_FIFO0_ETM_bytecount_Pos        24U                                         /*!< TPI FIFO0: ETM_bytecount Position */
 #define TPI_FIFO0_ETM_bytecount_Msk        (0x3UL << TPI_FIFO0_ETM_bytecount_Pos)      /*!< TPI FIFO0: ETM_bytecount Mask */
@@ -1065,18 +1068,21 @@ typedef struct
 #define TPI_FIFO0_ETM0_Msk                 (0xFFUL /*<< TPI_FIFO0_ETM0_Pos*/)          /*!< TPI FIFO0: ETM0 Mask */
 
 /* TPI ITATBCTR2 Register Definitions */
-#define TPI_ITATBCTR2_ATREADY_Pos           0U                                         /*!< TPI ITATBCTR2: ATREADY Position */
-#define TPI_ITATBCTR2_ATREADY_Msk          (0x1UL /*<< TPI_ITATBCTR2_ATREADY_Pos*/)    /*!< TPI ITATBCTR2: ATREADY Mask */
+#define TPI_ITATBCTR2_ATREADY2_Pos          0U                                         /*!< TPI ITATBCTR2: ATREADY2 Position */
+#define TPI_ITATBCTR2_ATREADY2_Msk         (0x1UL /*<< TPI_ITATBCTR2_ATREADY2_Pos*/)   /*!< TPI ITATBCTR2: ATREADY2 Mask */
+
+#define TPI_ITATBCTR2_ATREADY1_Pos          0U                                         /*!< TPI ITATBCTR2: ATREADY1 Position */
+#define TPI_ITATBCTR2_ATREADY1_Msk         (0x1UL /*<< TPI_ITATBCTR2_ATREADY1_Pos*/)   /*!< TPI ITATBCTR2: ATREADY1 Mask */
 
 /* TPI Integration ITM Data Register Definitions (FIFO1) */
 #define TPI_FIFO1_ITM_ATVALID_Pos          29U                                         /*!< TPI FIFO1: ITM_ATVALID Position */
-#define TPI_FIFO1_ITM_ATVALID_Msk          (0x3UL << TPI_FIFO1_ITM_ATVALID_Pos)        /*!< TPI FIFO1: ITM_ATVALID Mask */
+#define TPI_FIFO1_ITM_ATVALID_Msk          (0x1UL << TPI_FIFO1_ITM_ATVALID_Pos)        /*!< TPI FIFO1: ITM_ATVALID Mask */
 
 #define TPI_FIFO1_ITM_bytecount_Pos        27U                                         /*!< TPI FIFO1: ITM_bytecount Position */
 #define TPI_FIFO1_ITM_bytecount_Msk        (0x3UL << TPI_FIFO1_ITM_bytecount_Pos)      /*!< TPI FIFO1: ITM_bytecount Mask */
 
 #define TPI_FIFO1_ETM_ATVALID_Pos          26U                                         /*!< TPI FIFO1: ETM_ATVALID Position */
-#define TPI_FIFO1_ETM_ATVALID_Msk          (0x3UL << TPI_FIFO1_ETM_ATVALID_Pos)        /*!< TPI FIFO1: ETM_ATVALID Mask */
+#define TPI_FIFO1_ETM_ATVALID_Msk          (0x1UL << TPI_FIFO1_ETM_ATVALID_Pos)        /*!< TPI FIFO1: ETM_ATVALID Mask */
 
 #define TPI_FIFO1_ETM_bytecount_Pos        24U                                         /*!< TPI FIFO1: ETM_bytecount Position */
 #define TPI_FIFO1_ETM_bytecount_Msk        (0x3UL << TPI_FIFO1_ETM_bytecount_Pos)      /*!< TPI FIFO1: ETM_bytecount Mask */
@@ -1091,12 +1097,15 @@ typedef struct
 #define TPI_FIFO1_ITM0_Msk                 (0xFFUL /*<< TPI_FIFO1_ITM0_Pos*/)          /*!< TPI FIFO1: ITM0 Mask */
 
 /* TPI ITATBCTR0 Register Definitions */
-#define TPI_ITATBCTR0_ATREADY_Pos           0U                                         /*!< TPI ITATBCTR0: ATREADY Position */
-#define TPI_ITATBCTR0_ATREADY_Msk          (0x1UL /*<< TPI_ITATBCTR0_ATREADY_Pos*/)    /*!< TPI ITATBCTR0: ATREADY Mask */
+#define TPI_ITATBCTR0_ATREADY2_Pos          0U                                         /*!< TPI ITATBCTR0: ATREADY2 Position */
+#define TPI_ITATBCTR0_ATREADY2_Msk         (0x1UL /*<< TPI_ITATBCTR0_ATREADY2_Pos*/)   /*!< TPI ITATBCTR0: ATREADY2 Mask */
+
+#define TPI_ITATBCTR0_ATREADY1_Pos          0U                                         /*!< TPI ITATBCTR0: ATREADY1 Position */
+#define TPI_ITATBCTR0_ATREADY1_Msk         (0x1UL /*<< TPI_ITATBCTR0_ATREADY1_Pos*/)   /*!< TPI ITATBCTR0: ATREADY1 Mask */
 
 /* TPI Integration Mode Control Register Definitions */
 #define TPI_ITCTRL_Mode_Pos                 0U                                         /*!< TPI ITCTRL: Mode Position */
-#define TPI_ITCTRL_Mode_Msk                (0x1UL /*<< TPI_ITCTRL_Mode_Pos*/)          /*!< TPI ITCTRL: Mode Mask */
+#define TPI_ITCTRL_Mode_Msk                (0x3UL /*<< TPI_ITCTRL_Mode_Pos*/)          /*!< TPI ITCTRL: Mode Mask */
 
 /* TPI DEVID Register Definitions */
 #define TPI_DEVID_NRZVALID_Pos             11U                                         /*!< TPI DEVID: NRZVALID Position */
@@ -1118,16 +1127,16 @@ typedef struct
 #define TPI_DEVID_NrTraceInput_Msk         (0x1FUL /*<< TPI_DEVID_NrTraceInput_Pos*/)  /*!< TPI DEVID: NrTraceInput Mask */
 
 /* TPI DEVTYPE Register Definitions */
-#define TPI_DEVTYPE_MajorType_Pos           4U                                         /*!< TPI DEVTYPE: MajorType Position */
-#define TPI_DEVTYPE_MajorType_Msk          (0xFUL << TPI_DEVTYPE_MajorType_Pos)        /*!< TPI DEVTYPE: MajorType Mask */
-
-#define TPI_DEVTYPE_SubType_Pos             0U                                         /*!< TPI DEVTYPE: SubType Position */
+#define TPI_DEVTYPE_SubType_Pos             4U                                         /*!< TPI DEVTYPE: SubType Position */
 #define TPI_DEVTYPE_SubType_Msk            (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/)      /*!< TPI DEVTYPE: SubType Mask */
 
+#define TPI_DEVTYPE_MajorType_Pos           0U                                         /*!< TPI DEVTYPE: MajorType Position */
+#define TPI_DEVTYPE_MajorType_Msk          (0xFUL << TPI_DEVTYPE_MajorType_Pos)        /*!< TPI DEVTYPE: MajorType Mask */
+
 /*@}*/ /* end of group CMSIS_TPI */
 
 
-#if (__MPU_PRESENT == 1U)
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
 /**
   \ingroup  CMSIS_core_register
   \defgroup CMSIS_MPU     Memory Protection Unit (MPU)
@@ -1153,6 +1162,8 @@ typedef struct
   __IOM uint32_t RASR_A3;                /*!< Offset: 0x028 (R/W)  MPU Alias 3 Region Attribute and Size Register */
 } MPU_Type;
 
+#define MPU_TYPE_RALIASES                  4U
+
 /* MPU Type Register Definitions */
 #define MPU_TYPE_IREGION_Pos               16U                                            /*!< MPU TYPE: IREGION Position */
 #define MPU_TYPE_IREGION_Msk               (0xFFUL << MPU_TYPE_IREGION_Pos)               /*!< MPU TYPE: IREGION Mask */
@@ -1337,18 +1348,18 @@ typedef struct
 /**
   \brief   Mask and shift a bit field value for use in a register bit range.
   \param[in] field  Name of the register bit field.
-  \param[in] value  Value of the bit field.
+  \param[in] value  Value of the bit field. This parameter is interpreted as an uint32_t type.
   \return           Masked and shifted value.
 */
-#define _VAL2FLD(field, value)    ((value << field ## _Pos) & field ## _Msk)
+#define _VAL2FLD(field, value)    (((uint32_t)(value) << field ## _Pos) & field ## _Msk)
 
 /**
   \brief     Mask and shift a register value to extract a bit filed value.
   \param[in] field  Name of the register bit field.
-  \param[in] value  Value of register.
+  \param[in] value  Value of register. This parameter is interpreted as an uint32_t type.
   \return           Masked and shifted bit field value.
 */
-#define _FLD2VAL(field, value)    ((value & field ## _Msk) >> field ## _Pos)
+#define _FLD2VAL(field, value)    (((uint32_t)(value) & field ## _Msk) >> field ## _Pos)
 
 /*@} end of group CMSIS_core_bitfield */
 
@@ -1360,7 +1371,7 @@ typedef struct
   @{
  */
 
-/* Memory mapping of Cortex-M3 Hardware */
+/* Memory mapping of Core Hardware */
 #define SCS_BASE            (0xE000E000UL)                            /*!< System Control Space Base Address */
 #define ITM_BASE            (0xE0000000UL)                            /*!< ITM Base Address */
 #define DWT_BASE            (0xE0001000UL)                            /*!< DWT Base Address */
@@ -1379,7 +1390,7 @@ typedef struct
 #define TPI                 ((TPI_Type       *)     TPI_BASE      )   /*!< TPI configuration struct */
 #define CoreDebug           ((CoreDebug_Type *)     CoreDebug_BASE)   /*!< Core Debug configuration struct */
 
-#if (__MPU_PRESENT == 1U)
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
   #define MPU_BASE          (SCS_BASE +  0x0D90UL)                    /*!< Memory Protection Unit */
   #define MPU               ((MPU_Type       *)     MPU_BASE      )   /*!< Memory Protection Unit */
 #endif
@@ -1410,6 +1421,45 @@ typedef struct
   @{
  */
 
+#ifdef CMSIS_NVIC_VIRTUAL
+  #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
+    #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
+  #endif
+  #include CMSIS_NVIC_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetPriorityGrouping    __NVIC_SetPriorityGrouping
+  #define NVIC_GetPriorityGrouping    __NVIC_GetPriorityGrouping
+  #define NVIC_EnableIRQ              __NVIC_EnableIRQ
+  #define NVIC_GetEnableIRQ           __NVIC_GetEnableIRQ
+  #define NVIC_DisableIRQ             __NVIC_DisableIRQ
+  #define NVIC_GetPendingIRQ          __NVIC_GetPendingIRQ
+  #define NVIC_SetPendingIRQ          __NVIC_SetPendingIRQ
+  #define NVIC_ClearPendingIRQ        __NVIC_ClearPendingIRQ
+  #define NVIC_GetActive              __NVIC_GetActive
+  #define NVIC_SetPriority            __NVIC_SetPriority
+  #define NVIC_GetPriority            __NVIC_GetPriority
+  #define NVIC_SystemReset            __NVIC_SystemReset
+#endif /* CMSIS_NVIC_VIRTUAL */
+
+#ifdef CMSIS_VECTAB_VIRTUAL
+  #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+   #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h"
+  #endif
+  #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetVector              __NVIC_SetVector
+  #define NVIC_GetVector              __NVIC_GetVector
+#endif  /* (CMSIS_VECTAB_VIRTUAL) */
+
+#define NVIC_USER_IRQ_OFFSET          16
+
+
+/* The following EXC_RETURN values are saved the LR on exception entry */
+#define EXC_RETURN_HANDLER         (0xFFFFFFF1UL)     /* return to Handler mode, uses MSP after return                               */
+#define EXC_RETURN_THREAD_MSP      (0xFFFFFFF9UL)     /* return to Thread mode, uses MSP after return                                */
+#define EXC_RETURN_THREAD_PSP      (0xFFFFFFFDUL)     /* return to Thread mode, uses PSP after return                                */
+
+
 /**
   \brief   Set Priority Grouping
   \details Sets the priority grouping field using the required unlock sequence.
@@ -1419,7 +1469,7 @@ typedef struct
            priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
   \param [in]      PriorityGroup  Priority grouping field.
  */
-__STATIC_INLINE void NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
+__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
 {
   uint32_t reg_value;
   uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);             /* only values 0..7 are used          */
@@ -1428,7 +1478,7 @@ __STATIC_INLINE void NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
   reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change               */
   reg_value  =  (reg_value                                   |
                 ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
-                (PriorityGroupTmp << 8U)                      );              /* Insert write key and priorty group */
+                (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos) );               /* Insert write key and priority group */
   SCB->AIRCR =  reg_value;
 }
 
@@ -1438,121 +1488,178 @@ __STATIC_INLINE void NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
   \details Reads the priority grouping field from the NVIC Interrupt Controller.
   \return                Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field).
  */
-__STATIC_INLINE uint32_t NVIC_GetPriorityGrouping(void)
+__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void)
 {
   return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos));
 }
 
 
 /**
-  \brief   Enable External Interrupt
-  \details Enables a device-specific interrupt in the NVIC interrupt controller.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \brief   Enable Interrupt
+  \details Enables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
 {
-  NVIC->ISER[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
-  \brief   Disable External Interrupt
-  \details Disables a device-specific interrupt in the NVIC interrupt controller.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \brief   Get Interrupt Enable status
+  \details Returns a device specific interrupt enable status from the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn)
 {
-  NVIC->ICER[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt
+  \details Disables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
+  }
 }
 
 
 /**
   \brief   Get Pending Interrupt
-  \details Reads the pending register in the NVIC and returns the pending bit for the specified interrupt.
-  \param [in]      IRQn  Interrupt number.
+  \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
   \return             0  Interrupt status is not pending.
   \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE uint32_t NVIC_GetPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn)
 {
-  return((uint32_t)(((NVIC->ISPR[(((uint32_t)(int32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
 }
 
 
 /**
   \brief   Set Pending Interrupt
-  \details Sets the pending bit of an external interrupt.
-  \param [in]      IRQn  Interrupt number. Value cannot be negative.
+  \details Sets the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_SetPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn)
 {
-  NVIC->ISPR[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
   \brief   Clear Pending Interrupt
-  \details Clears the pending bit of an external interrupt.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \details Clears the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_ClearPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn)
 {
-  NVIC->ICPR[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
   \brief   Get Active Interrupt
-  \details Reads the active register in NVIC and returns the active bit.
-  \param [in]      IRQn  Interrupt number.
+  \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
   \return             0  Interrupt status is not active.
   \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE uint32_t NVIC_GetActive(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn)
 {
-  return((uint32_t)(((NVIC->IABR[(((uint32_t)(int32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
 }
 
 
 /**
   \brief   Set Interrupt Priority
-  \details Sets the priority of an interrupt.
-  \note    The priority cannot be set for every core interrupt.
+  \details Sets the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
   \param [in]      IRQn  Interrupt number.
   \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every processor exception.
  */
-__STATIC_INLINE void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
+__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
 {
-  if ((int32_t)(IRQn) < 0)
+  if ((int32_t)(IRQn) >= 0)
   {
-    SCB->SHP[(((uint32_t)(int32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+    NVIC->IP[((uint32_t)IRQn)]               = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
   }
   else
   {
-    NVIC->IP[((uint32_t)(int32_t)IRQn)]               = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+    SCB->SHP[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
   }
 }
 
 
 /**
   \brief   Get Interrupt Priority
-  \details Reads the priority of an interrupt.
-           The interrupt number can be positive to specify an external (device specific) interrupt,
-           or negative to specify an internal (core) interrupt.
+  \details Reads the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
   \param [in]   IRQn  Interrupt number.
   \return             Interrupt Priority.
                       Value is aligned automatically to the implemented priority bits of the microcontroller.
  */
-__STATIC_INLINE uint32_t NVIC_GetPriority(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn)
 {
 
-  if ((int32_t)(IRQn) < 0)
+  if ((int32_t)(IRQn) >= 0)
   {
-    return(((uint32_t)SCB->SHP[(((uint32_t)(int32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
+    return(((uint32_t)NVIC->IP[((uint32_t)IRQn)]               >> (8U - __NVIC_PRIO_BITS)));
   }
   else
   {
-    return(((uint32_t)NVIC->IP[((uint32_t)(int32_t)IRQn)]               >> (8U - __NVIC_PRIO_BITS)));
+    return(((uint32_t)SCB->SHP[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
   }
 }
 
@@ -1609,11 +1716,42 @@ __STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGr
 }
 
 
+/**
+  \brief   Set Interrupt Vector
+  \details Sets an interrupt vector in SRAM based interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+           VTOR must been relocated to SRAM before.
+  \param [in]   IRQn      Interrupt number
+  \param [in]   vector    Address of interrupt handler function
+ */
+__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
+{
+  uint32_t vectors = (uint32_t )SCB->VTOR;
+  (* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)) = vector;
+}
+
+
+/**
+  \brief   Get Interrupt Vector
+  \details Reads an interrupt vector from interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn      Interrupt number.
+  \return                 Address of interrupt handler function
+ */
+__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn)
+{
+  uint32_t vectors = (uint32_t )SCB->VTOR;
+  return (uint32_t)(* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4));
+}
+
+
 /**
   \brief   System Reset
   \details Initiates a system reset request to reset the MCU.
  */
-__STATIC_INLINE void NVIC_SystemReset(void)
+__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void)
 {
   __DSB();                                                          /* Ensure all outstanding memory accesses included
                                                                        buffered write are completed before reset */
@@ -1630,6 +1768,39 @@ __STATIC_INLINE void NVIC_SystemReset(void)
 
 /*@} end of CMSIS_Core_NVICFunctions */
 
+/* ##########################  MPU functions  #################################### */
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+
+#include "mpu_armv7.h"
+
+#endif
+
+
+/* ##########################  FPU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_FpuFunctions FPU Functions
+  \brief    Function that provides FPU type.
+  @{
+ */
+
+/**
+  \brief   get FPU type
+  \details returns the FPU type
+  \returns
+   - \b  0: No FPU
+   - \b  1: Single precision FPU
+   - \b  2: Double + Single precision FPU
+ */
+__STATIC_INLINE uint32_t SCB_GetFPUType(void)
+{
+    return 0U;           /* No FPU */
+}
+
+
+/*@} end of CMSIS_Core_FpuFunctions */
+
 
 
 /* ##################################    SysTick function  ############################################ */
@@ -1640,7 +1811,7 @@ __STATIC_INLINE void NVIC_SystemReset(void)
   @{
  */
 
-#if (__Vendor_SysTickConfig == 0U)
+#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
 
 /**
   \brief   System Tick Configuration
@@ -1683,8 +1854,8 @@ __STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
   @{
  */
 
-extern volatile int32_t ITM_RxBuffer;                    /*!< External variable to receive characters. */
-#define                 ITM_RXBUFFER_EMPTY   0x5AA55AA5U /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */
+extern volatile int32_t ITM_RxBuffer;                              /*!< External variable to receive characters. */
+#define                 ITM_RXBUFFER_EMPTY  ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */
 
 
 /**
diff --git a/lib/cmsis/inc/core_cm33.h b/lib/cmsis/inc/core_cm33.h
new file mode 100644
index 0000000000000..d5d97a96f2d6b
--- /dev/null
+++ b/lib/cmsis/inc/core_cm33.h
@@ -0,0 +1,2907 @@
+/**************************************************************************//**
+ * @file     core_cm33.h
+ * @brief    CMSIS Cortex-M33 Core Peripheral Access Layer Header File
+ * @version  V5.1.0
+ * @date     12. November 2018
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2018 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if   defined ( __ICCARM__ )
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
+  #pragma clang system_header   /* treat file as system include file */
+#endif
+
+#ifndef __CORE_CM33_H_GENERIC
+#define __CORE_CM33_H_GENERIC
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/**
+  \page CMSIS_MISRA_Exceptions  MISRA-C:2004 Compliance Exceptions
+  CMSIS violates the following MISRA-C:2004 rules:
+
+   \li Required Rule 8.5, object/function definition in header file.<br>
+     Function definitions in header files are used to allow 'inlining'.
+
+   \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.<br>
+     Unions are used for effective representation of core registers.
+
+   \li Advisory Rule 19.7, Function-like macro defined.<br>
+     Function-like macros are used to allow more efficient code.
+ */
+
+
+/*******************************************************************************
+ *                 CMSIS definitions
+ ******************************************************************************/
+/**
+  \ingroup Cortex_M33
+  @{
+ */
+
+#include "cmsis_version.h"
+
+/*  CMSIS CM33 definitions */
+#define __CM33_CMSIS_VERSION_MAIN  (__CM_CMSIS_VERSION_MAIN)                   /*!< \deprecated [31:16] CMSIS HAL main version */
+#define __CM33_CMSIS_VERSION_SUB   (__CM_CMSIS_VERSION_SUB)                    /*!< \deprecated [15:0]  CMSIS HAL sub version */
+#define __CM33_CMSIS_VERSION       ((__CM33_CMSIS_VERSION_MAIN << 16U) | \
+                                     __CM33_CMSIS_VERSION_SUB           )      /*!< \deprecated CMSIS HAL version number */
+
+#define __CORTEX_M                 (33U)                                       /*!< Cortex-M Core */
+
+/** __FPU_USED indicates whether an FPU is used or not.
+    For this, __FPU_PRESENT has to be checked prior to making use of FPU specific registers and functions.
+*/
+#if defined ( __CC_ARM )
+  #if defined (__TARGET_FPU_VFP)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+  #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U)
+    #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #if defined (__ARM_FP)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+  #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U)
+    #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+
+#elif defined ( __GNUC__ )
+  #if defined (__VFP_FP__) && !defined(__SOFTFP__)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+  #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U)
+    #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+
+#elif defined ( __ICCARM__ )
+  #if defined (__ARMVFP__)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+  #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U)
+    #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+
+#elif defined ( __TI_ARM__ )
+  #if defined (__TI_VFP_SUPPORT__)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+#elif defined ( __TASKING__ )
+  #if defined (__FPU_VFP__)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+#elif defined ( __CSMC__ )
+  #if ( __CSMC__ & 0x400U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+#endif
+
+#include "cmsis_compiler.h"               /* CMSIS compiler specific defines */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CORE_CM33_H_GENERIC */
+
+#ifndef __CMSIS_GENERIC
+
+#ifndef __CORE_CM33_H_DEPENDANT
+#define __CORE_CM33_H_DEPENDANT
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/* check device defines and use defaults */
+#if defined __CHECK_DEVICE_DEFINES
+  #ifndef __CM33_REV
+    #define __CM33_REV                0x0000U
+    #warning "__CM33_REV not defined in device header file; using default!"
+  #endif
+
+  #ifndef __FPU_PRESENT
+    #define __FPU_PRESENT             0U
+    #warning "__FPU_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __MPU_PRESENT
+    #define __MPU_PRESENT             0U
+    #warning "__MPU_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __SAUREGION_PRESENT
+    #define __SAUREGION_PRESENT       0U
+    #warning "__SAUREGION_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __DSP_PRESENT
+    #define __DSP_PRESENT             0U
+    #warning "__DSP_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __NVIC_PRIO_BITS
+    #define __NVIC_PRIO_BITS          3U
+    #warning "__NVIC_PRIO_BITS not defined in device header file; using default!"
+  #endif
+
+  #ifndef __Vendor_SysTickConfig
+    #define __Vendor_SysTickConfig    0U
+    #warning "__Vendor_SysTickConfig not defined in device header file; using default!"
+  #endif
+#endif
+
+/* IO definitions (access restrictions to peripheral registers) */
+/**
+    \defgroup CMSIS_glob_defs CMSIS Global Defines
+
+    <strong>IO Type Qualifiers</strong> are used
+    \li to specify the access to peripheral variables.
+    \li for automatic generation of peripheral register debug information.
+*/
+#ifdef __cplusplus
+  #define   __I     volatile             /*!< Defines 'read only' permissions */
+#else
+  #define   __I     volatile const       /*!< Defines 'read only' permissions */
+#endif
+#define     __O     volatile             /*!< Defines 'write only' permissions */
+#define     __IO    volatile             /*!< Defines 'read / write' permissions */
+
+/* following defines should be used for structure members */
+#define     __IM     volatile const      /*! Defines 'read only' structure member permissions */
+#define     __OM     volatile            /*! Defines 'write only' structure member permissions */
+#define     __IOM    volatile            /*! Defines 'read / write' structure member permissions */
+
+/*@} end of group Cortex_M33 */
+
+
+
+/*******************************************************************************
+ *                 Register Abstraction
+  Core Register contain:
+  - Core Register
+  - Core NVIC Register
+  - Core SCB Register
+  - Core SysTick Register
+  - Core Debug Register
+  - Core MPU Register
+  - Core SAU Register
+  - Core FPU Register
+ ******************************************************************************/
+/**
+  \defgroup CMSIS_core_register Defines and Type Definitions
+  \brief Type definitions and defines for Cortex-M processor based devices.
+*/
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_CORE  Status and Control Registers
+  \brief      Core Register type definitions.
+  @{
+ */
+
+/**
+  \brief  Union type to access the Application Program Status Register (APSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t _reserved0:16;              /*!< bit:  0..15  Reserved */
+    uint32_t GE:4;                       /*!< bit: 16..19  Greater than or Equal flags */
+    uint32_t _reserved1:7;               /*!< bit: 20..26  Reserved */
+    uint32_t Q:1;                        /*!< bit:     27  Saturation condition flag */
+    uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
+    uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
+    uint32_t Z:1;                        /*!< bit:     30  Zero condition code flag */
+    uint32_t N:1;                        /*!< bit:     31  Negative condition code flag */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} APSR_Type;
+
+/* APSR Register Definitions */
+#define APSR_N_Pos                         31U                                            /*!< APSR: N Position */
+#define APSR_N_Msk                         (1UL << APSR_N_Pos)                            /*!< APSR: N Mask */
+
+#define APSR_Z_Pos                         30U                                            /*!< APSR: Z Position */
+#define APSR_Z_Msk                         (1UL << APSR_Z_Pos)                            /*!< APSR: Z Mask */
+
+#define APSR_C_Pos                         29U                                            /*!< APSR: C Position */
+#define APSR_C_Msk                         (1UL << APSR_C_Pos)                            /*!< APSR: C Mask */
+
+#define APSR_V_Pos                         28U                                            /*!< APSR: V Position */
+#define APSR_V_Msk                         (1UL << APSR_V_Pos)                            /*!< APSR: V Mask */
+
+#define APSR_Q_Pos                         27U                                            /*!< APSR: Q Position */
+#define APSR_Q_Msk                         (1UL << APSR_Q_Pos)                            /*!< APSR: Q Mask */
+
+#define APSR_GE_Pos                        16U                                            /*!< APSR: GE Position */
+#define APSR_GE_Msk                        (0xFUL << APSR_GE_Pos)                         /*!< APSR: GE Mask */
+
+
+/**
+  \brief  Union type to access the Interrupt Program Status Register (IPSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
+    uint32_t _reserved0:23;              /*!< bit:  9..31  Reserved */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} IPSR_Type;
+
+/* IPSR Register Definitions */
+#define IPSR_ISR_Pos                        0U                                            /*!< IPSR: ISR Position */
+#define IPSR_ISR_Msk                       (0x1FFUL /*<< IPSR_ISR_Pos*/)                  /*!< IPSR: ISR Mask */
+
+
+/**
+  \brief  Union type to access the Special-Purpose Program Status Registers (xPSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
+    uint32_t _reserved0:7;               /*!< bit:  9..15  Reserved */
+    uint32_t GE:4;                       /*!< bit: 16..19  Greater than or Equal flags */
+    uint32_t _reserved1:4;               /*!< bit: 20..23  Reserved */
+    uint32_t T:1;                        /*!< bit:     24  Thumb bit        (read 0) */
+    uint32_t IT:2;                       /*!< bit: 25..26  saved IT state   (read 0) */
+    uint32_t Q:1;                        /*!< bit:     27  Saturation condition flag */
+    uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
+    uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
+    uint32_t Z:1;                        /*!< bit:     30  Zero condition code flag */
+    uint32_t N:1;                        /*!< bit:     31  Negative condition code flag */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} xPSR_Type;
+
+/* xPSR Register Definitions */
+#define xPSR_N_Pos                         31U                                            /*!< xPSR: N Position */
+#define xPSR_N_Msk                         (1UL << xPSR_N_Pos)                            /*!< xPSR: N Mask */
+
+#define xPSR_Z_Pos                         30U                                            /*!< xPSR: Z Position */
+#define xPSR_Z_Msk                         (1UL << xPSR_Z_Pos)                            /*!< xPSR: Z Mask */
+
+#define xPSR_C_Pos                         29U                                            /*!< xPSR: C Position */
+#define xPSR_C_Msk                         (1UL << xPSR_C_Pos)                            /*!< xPSR: C Mask */
+
+#define xPSR_V_Pos                         28U                                            /*!< xPSR: V Position */
+#define xPSR_V_Msk                         (1UL << xPSR_V_Pos)                            /*!< xPSR: V Mask */
+
+#define xPSR_Q_Pos                         27U                                            /*!< xPSR: Q Position */
+#define xPSR_Q_Msk                         (1UL << xPSR_Q_Pos)                            /*!< xPSR: Q Mask */
+
+#define xPSR_IT_Pos                        25U                                            /*!< xPSR: IT Position */
+#define xPSR_IT_Msk                        (3UL << xPSR_IT_Pos)                           /*!< xPSR: IT Mask */
+
+#define xPSR_T_Pos                         24U                                            /*!< xPSR: T Position */
+#define xPSR_T_Msk                         (1UL << xPSR_T_Pos)                            /*!< xPSR: T Mask */
+
+#define xPSR_GE_Pos                        16U                                            /*!< xPSR: GE Position */
+#define xPSR_GE_Msk                        (0xFUL << xPSR_GE_Pos)                         /*!< xPSR: GE Mask */
+
+#define xPSR_ISR_Pos                        0U                                            /*!< xPSR: ISR Position */
+#define xPSR_ISR_Msk                       (0x1FFUL /*<< xPSR_ISR_Pos*/)                  /*!< xPSR: ISR Mask */
+
+
+/**
+  \brief  Union type to access the Control Registers (CONTROL).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t nPRIV:1;                    /*!< bit:      0  Execution privilege in Thread mode */
+    uint32_t SPSEL:1;                    /*!< bit:      1  Stack-pointer select */
+    uint32_t FPCA:1;                     /*!< bit:      2  Floating-point context active */
+    uint32_t SFPA:1;                     /*!< bit:      3  Secure floating-point active */
+    uint32_t _reserved1:28;              /*!< bit:  4..31  Reserved */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} CONTROL_Type;
+
+/* CONTROL Register Definitions */
+#define CONTROL_SFPA_Pos                    3U                                            /*!< CONTROL: SFPA Position */
+#define CONTROL_SFPA_Msk                   (1UL << CONTROL_SFPA_Pos)                      /*!< CONTROL: SFPA Mask */
+
+#define CONTROL_FPCA_Pos                    2U                                            /*!< CONTROL: FPCA Position */
+#define CONTROL_FPCA_Msk                   (1UL << CONTROL_FPCA_Pos)                      /*!< CONTROL: FPCA Mask */
+
+#define CONTROL_SPSEL_Pos                   1U                                            /*!< CONTROL: SPSEL Position */
+#define CONTROL_SPSEL_Msk                  (1UL << CONTROL_SPSEL_Pos)                     /*!< CONTROL: SPSEL Mask */
+
+#define CONTROL_nPRIV_Pos                   0U                                            /*!< CONTROL: nPRIV Position */
+#define CONTROL_nPRIV_Msk                  (1UL /*<< CONTROL_nPRIV_Pos*/)                 /*!< CONTROL: nPRIV Mask */
+
+/*@} end of group CMSIS_CORE */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_NVIC  Nested Vectored Interrupt Controller (NVIC)
+  \brief      Type definitions for the NVIC Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Nested Vectored Interrupt Controller (NVIC).
+ */
+typedef struct
+{
+  __IOM uint32_t ISER[16U];              /*!< Offset: 0x000 (R/W)  Interrupt Set Enable Register */
+        uint32_t RESERVED0[16U];
+  __IOM uint32_t ICER[16U];              /*!< Offset: 0x080 (R/W)  Interrupt Clear Enable Register */
+        uint32_t RSERVED1[16U];
+  __IOM uint32_t ISPR[16U];              /*!< Offset: 0x100 (R/W)  Interrupt Set Pending Register */
+        uint32_t RESERVED2[16U];
+  __IOM uint32_t ICPR[16U];              /*!< Offset: 0x180 (R/W)  Interrupt Clear Pending Register */
+        uint32_t RESERVED3[16U];
+  __IOM uint32_t IABR[16U];              /*!< Offset: 0x200 (R/W)  Interrupt Active bit Register */
+        uint32_t RESERVED4[16U];
+  __IOM uint32_t ITNS[16U];              /*!< Offset: 0x280 (R/W)  Interrupt Non-Secure State Register */
+        uint32_t RESERVED5[16U];
+  __IOM uint8_t  IPR[496U];              /*!< Offset: 0x300 (R/W)  Interrupt Priority Register (8Bit wide) */
+        uint32_t RESERVED6[580U];
+  __OM  uint32_t STIR;                   /*!< Offset: 0xE00 ( /W)  Software Trigger Interrupt Register */
+}  NVIC_Type;
+
+/* Software Triggered Interrupt Register Definitions */
+#define NVIC_STIR_INTID_Pos                 0U                                         /*!< STIR: INTLINESNUM Position */
+#define NVIC_STIR_INTID_Msk                (0x1FFUL /*<< NVIC_STIR_INTID_Pos*/)        /*!< STIR: INTLINESNUM Mask */
+
+/*@} end of group CMSIS_NVIC */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SCB     System Control Block (SCB)
+  \brief    Type definitions for the System Control Block Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Control Block (SCB).
+ */
+typedef struct
+{
+  __IM  uint32_t CPUID;                  /*!< Offset: 0x000 (R/ )  CPUID Base Register */
+  __IOM uint32_t ICSR;                   /*!< Offset: 0x004 (R/W)  Interrupt Control and State Register */
+  __IOM uint32_t VTOR;                   /*!< Offset: 0x008 (R/W)  Vector Table Offset Register */
+  __IOM uint32_t AIRCR;                  /*!< Offset: 0x00C (R/W)  Application Interrupt and Reset Control Register */
+  __IOM uint32_t SCR;                    /*!< Offset: 0x010 (R/W)  System Control Register */
+  __IOM uint32_t CCR;                    /*!< Offset: 0x014 (R/W)  Configuration Control Register */
+  __IOM uint8_t  SHPR[12U];              /*!< Offset: 0x018 (R/W)  System Handlers Priority Registers (4-7, 8-11, 12-15) */
+  __IOM uint32_t SHCSR;                  /*!< Offset: 0x024 (R/W)  System Handler Control and State Register */
+  __IOM uint32_t CFSR;                   /*!< Offset: 0x028 (R/W)  Configurable Fault Status Register */
+  __IOM uint32_t HFSR;                   /*!< Offset: 0x02C (R/W)  HardFault Status Register */
+  __IOM uint32_t DFSR;                   /*!< Offset: 0x030 (R/W)  Debug Fault Status Register */
+  __IOM uint32_t MMFAR;                  /*!< Offset: 0x034 (R/W)  MemManage Fault Address Register */
+  __IOM uint32_t BFAR;                   /*!< Offset: 0x038 (R/W)  BusFault Address Register */
+  __IOM uint32_t AFSR;                   /*!< Offset: 0x03C (R/W)  Auxiliary Fault Status Register */
+  __IM  uint32_t ID_PFR[2U];             /*!< Offset: 0x040 (R/ )  Processor Feature Register */
+  __IM  uint32_t ID_DFR;                 /*!< Offset: 0x048 (R/ )  Debug Feature Register */
+  __IM  uint32_t ID_ADR;                 /*!< Offset: 0x04C (R/ )  Auxiliary Feature Register */
+  __IM  uint32_t ID_MMFR[4U];            /*!< Offset: 0x050 (R/ )  Memory Model Feature Register */
+  __IM  uint32_t ID_ISAR[6U];            /*!< Offset: 0x060 (R/ )  Instruction Set Attributes Register */
+  __IM  uint32_t CLIDR;                  /*!< Offset: 0x078 (R/ )  Cache Level ID register */
+  __IM  uint32_t CTR;                    /*!< Offset: 0x07C (R/ )  Cache Type register */
+  __IM  uint32_t CCSIDR;                 /*!< Offset: 0x080 (R/ )  Cache Size ID Register */
+  __IOM uint32_t CSSELR;                 /*!< Offset: 0x084 (R/W)  Cache Size Selection Register */
+  __IOM uint32_t CPACR;                  /*!< Offset: 0x088 (R/W)  Coprocessor Access Control Register */
+  __IOM uint32_t NSACR;                  /*!< Offset: 0x08C (R/W)  Non-Secure Access Control Register */
+        uint32_t RESERVED3[92U];
+  __OM  uint32_t STIR;                   /*!< Offset: 0x200 ( /W)  Software Triggered Interrupt Register */
+        uint32_t RESERVED4[15U];
+  __IM  uint32_t MVFR0;                  /*!< Offset: 0x240 (R/ )  Media and VFP Feature Register 0 */
+  __IM  uint32_t MVFR1;                  /*!< Offset: 0x244 (R/ )  Media and VFP Feature Register 1 */
+  __IM  uint32_t MVFR2;                  /*!< Offset: 0x248 (R/ )  Media and VFP Feature Register 2 */
+        uint32_t RESERVED5[1U];
+  __OM  uint32_t ICIALLU;                /*!< Offset: 0x250 ( /W)  I-Cache Invalidate All to PoU */
+        uint32_t RESERVED6[1U];
+  __OM  uint32_t ICIMVAU;                /*!< Offset: 0x258 ( /W)  I-Cache Invalidate by MVA to PoU */
+  __OM  uint32_t DCIMVAC;                /*!< Offset: 0x25C ( /W)  D-Cache Invalidate by MVA to PoC */
+  __OM  uint32_t DCISW;                  /*!< Offset: 0x260 ( /W)  D-Cache Invalidate by Set-way */
+  __OM  uint32_t DCCMVAU;                /*!< Offset: 0x264 ( /W)  D-Cache Clean by MVA to PoU */
+  __OM  uint32_t DCCMVAC;                /*!< Offset: 0x268 ( /W)  D-Cache Clean by MVA to PoC */
+  __OM  uint32_t DCCSW;                  /*!< Offset: 0x26C ( /W)  D-Cache Clean by Set-way */
+  __OM  uint32_t DCCIMVAC;               /*!< Offset: 0x270 ( /W)  D-Cache Clean and Invalidate by MVA to PoC */
+  __OM  uint32_t DCCISW;                 /*!< Offset: 0x274 ( /W)  D-Cache Clean and Invalidate by Set-way */
+} SCB_Type;
+
+/* SCB CPUID Register Definitions */
+#define SCB_CPUID_IMPLEMENTER_Pos          24U                                            /*!< SCB CPUID: IMPLEMENTER Position */
+#define SCB_CPUID_IMPLEMENTER_Msk          (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos)          /*!< SCB CPUID: IMPLEMENTER Mask */
+
+#define SCB_CPUID_VARIANT_Pos              20U                                            /*!< SCB CPUID: VARIANT Position */
+#define SCB_CPUID_VARIANT_Msk              (0xFUL << SCB_CPUID_VARIANT_Pos)               /*!< SCB CPUID: VARIANT Mask */
+
+#define SCB_CPUID_ARCHITECTURE_Pos         16U                                            /*!< SCB CPUID: ARCHITECTURE Position */
+#define SCB_CPUID_ARCHITECTURE_Msk         (0xFUL << SCB_CPUID_ARCHITECTURE_Pos)          /*!< SCB CPUID: ARCHITECTURE Mask */
+
+#define SCB_CPUID_PARTNO_Pos                4U                                            /*!< SCB CPUID: PARTNO Position */
+#define SCB_CPUID_PARTNO_Msk               (0xFFFUL << SCB_CPUID_PARTNO_Pos)              /*!< SCB CPUID: PARTNO Mask */
+
+#define SCB_CPUID_REVISION_Pos              0U                                            /*!< SCB CPUID: REVISION Position */
+#define SCB_CPUID_REVISION_Msk             (0xFUL /*<< SCB_CPUID_REVISION_Pos*/)          /*!< SCB CPUID: REVISION Mask */
+
+/* SCB Interrupt Control State Register Definitions */
+#define SCB_ICSR_PENDNMISET_Pos            31U                                            /*!< SCB ICSR: PENDNMISET Position */
+#define SCB_ICSR_PENDNMISET_Msk            (1UL << SCB_ICSR_PENDNMISET_Pos)               /*!< SCB ICSR: PENDNMISET Mask */
+
+#define SCB_ICSR_NMIPENDSET_Pos            SCB_ICSR_PENDNMISET_Pos                        /*!< SCB ICSR: NMIPENDSET Position, backward compatibility */
+#define SCB_ICSR_NMIPENDSET_Msk            SCB_ICSR_PENDNMISET_Msk                        /*!< SCB ICSR: NMIPENDSET Mask, backward compatibility */
+
+#define SCB_ICSR_PENDNMICLR_Pos            30U                                            /*!< SCB ICSR: PENDNMICLR Position */
+#define SCB_ICSR_PENDNMICLR_Msk            (1UL << SCB_ICSR_PENDNMICLR_Pos)               /*!< SCB ICSR: PENDNMICLR Mask */
+
+#define SCB_ICSR_PENDSVSET_Pos             28U                                            /*!< SCB ICSR: PENDSVSET Position */
+#define SCB_ICSR_PENDSVSET_Msk             (1UL << SCB_ICSR_PENDSVSET_Pos)                /*!< SCB ICSR: PENDSVSET Mask */
+
+#define SCB_ICSR_PENDSVCLR_Pos             27U                                            /*!< SCB ICSR: PENDSVCLR Position */
+#define SCB_ICSR_PENDSVCLR_Msk             (1UL << SCB_ICSR_PENDSVCLR_Pos)                /*!< SCB ICSR: PENDSVCLR Mask */
+
+#define SCB_ICSR_PENDSTSET_Pos             26U                                            /*!< SCB ICSR: PENDSTSET Position */
+#define SCB_ICSR_PENDSTSET_Msk             (1UL << SCB_ICSR_PENDSTSET_Pos)                /*!< SCB ICSR: PENDSTSET Mask */
+
+#define SCB_ICSR_PENDSTCLR_Pos             25U                                            /*!< SCB ICSR: PENDSTCLR Position */
+#define SCB_ICSR_PENDSTCLR_Msk             (1UL << SCB_ICSR_PENDSTCLR_Pos)                /*!< SCB ICSR: PENDSTCLR Mask */
+
+#define SCB_ICSR_STTNS_Pos                 24U                                            /*!< SCB ICSR: STTNS Position (Security Extension) */
+#define SCB_ICSR_STTNS_Msk                 (1UL << SCB_ICSR_STTNS_Pos)                    /*!< SCB ICSR: STTNS Mask (Security Extension) */
+
+#define SCB_ICSR_ISRPREEMPT_Pos            23U                                            /*!< SCB ICSR: ISRPREEMPT Position */
+#define SCB_ICSR_ISRPREEMPT_Msk            (1UL << SCB_ICSR_ISRPREEMPT_Pos)               /*!< SCB ICSR: ISRPREEMPT Mask */
+
+#define SCB_ICSR_ISRPENDING_Pos            22U                                            /*!< SCB ICSR: ISRPENDING Position */
+#define SCB_ICSR_ISRPENDING_Msk            (1UL << SCB_ICSR_ISRPENDING_Pos)               /*!< SCB ICSR: ISRPENDING Mask */
+
+#define SCB_ICSR_VECTPENDING_Pos           12U                                            /*!< SCB ICSR: VECTPENDING Position */
+#define SCB_ICSR_VECTPENDING_Msk           (0x1FFUL << SCB_ICSR_VECTPENDING_Pos)          /*!< SCB ICSR: VECTPENDING Mask */
+
+#define SCB_ICSR_RETTOBASE_Pos             11U                                            /*!< SCB ICSR: RETTOBASE Position */
+#define SCB_ICSR_RETTOBASE_Msk             (1UL << SCB_ICSR_RETTOBASE_Pos)                /*!< SCB ICSR: RETTOBASE Mask */
+
+#define SCB_ICSR_VECTACTIVE_Pos             0U                                            /*!< SCB ICSR: VECTACTIVE Position */
+#define SCB_ICSR_VECTACTIVE_Msk            (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/)       /*!< SCB ICSR: VECTACTIVE Mask */
+
+/* SCB Vector Table Offset Register Definitions */
+#define SCB_VTOR_TBLOFF_Pos                 7U                                            /*!< SCB VTOR: TBLOFF Position */
+#define SCB_VTOR_TBLOFF_Msk                (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos)           /*!< SCB VTOR: TBLOFF Mask */
+
+/* SCB Application Interrupt and Reset Control Register Definitions */
+#define SCB_AIRCR_VECTKEY_Pos              16U                                            /*!< SCB AIRCR: VECTKEY Position */
+#define SCB_AIRCR_VECTKEY_Msk              (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos)            /*!< SCB AIRCR: VECTKEY Mask */
+
+#define SCB_AIRCR_VECTKEYSTAT_Pos          16U                                            /*!< SCB AIRCR: VECTKEYSTAT Position */
+#define SCB_AIRCR_VECTKEYSTAT_Msk          (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos)        /*!< SCB AIRCR: VECTKEYSTAT Mask */
+
+#define SCB_AIRCR_ENDIANESS_Pos            15U                                            /*!< SCB AIRCR: ENDIANESS Position */
+#define SCB_AIRCR_ENDIANESS_Msk            (1UL << SCB_AIRCR_ENDIANESS_Pos)               /*!< SCB AIRCR: ENDIANESS Mask */
+
+#define SCB_AIRCR_PRIS_Pos                 14U                                            /*!< SCB AIRCR: PRIS Position */
+#define SCB_AIRCR_PRIS_Msk                 (1UL << SCB_AIRCR_PRIS_Pos)                    /*!< SCB AIRCR: PRIS Mask */
+
+#define SCB_AIRCR_BFHFNMINS_Pos            13U                                            /*!< SCB AIRCR: BFHFNMINS Position */
+#define SCB_AIRCR_BFHFNMINS_Msk            (1UL << SCB_AIRCR_BFHFNMINS_Pos)               /*!< SCB AIRCR: BFHFNMINS Mask */
+
+#define SCB_AIRCR_PRIGROUP_Pos              8U                                            /*!< SCB AIRCR: PRIGROUP Position */
+#define SCB_AIRCR_PRIGROUP_Msk             (7UL << SCB_AIRCR_PRIGROUP_Pos)                /*!< SCB AIRCR: PRIGROUP Mask */
+
+#define SCB_AIRCR_SYSRESETREQS_Pos          3U                                            /*!< SCB AIRCR: SYSRESETREQS Position */
+#define SCB_AIRCR_SYSRESETREQS_Msk         (1UL << SCB_AIRCR_SYSRESETREQS_Pos)            /*!< SCB AIRCR: SYSRESETREQS Mask */
+
+#define SCB_AIRCR_SYSRESETREQ_Pos           2U                                            /*!< SCB AIRCR: SYSRESETREQ Position */
+#define SCB_AIRCR_SYSRESETREQ_Msk          (1UL << SCB_AIRCR_SYSRESETREQ_Pos)             /*!< SCB AIRCR: SYSRESETREQ Mask */
+
+#define SCB_AIRCR_VECTCLRACTIVE_Pos         1U                                            /*!< SCB AIRCR: VECTCLRACTIVE Position */
+#define SCB_AIRCR_VECTCLRACTIVE_Msk        (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos)           /*!< SCB AIRCR: VECTCLRACTIVE Mask */
+
+/* SCB System Control Register Definitions */
+#define SCB_SCR_SEVONPEND_Pos               4U                                            /*!< SCB SCR: SEVONPEND Position */
+#define SCB_SCR_SEVONPEND_Msk              (1UL << SCB_SCR_SEVONPEND_Pos)                 /*!< SCB SCR: SEVONPEND Mask */
+
+#define SCB_SCR_SLEEPDEEPS_Pos              3U                                            /*!< SCB SCR: SLEEPDEEPS Position */
+#define SCB_SCR_SLEEPDEEPS_Msk             (1UL << SCB_SCR_SLEEPDEEPS_Pos)                /*!< SCB SCR: SLEEPDEEPS Mask */
+
+#define SCB_SCR_SLEEPDEEP_Pos               2U                                            /*!< SCB SCR: SLEEPDEEP Position */
+#define SCB_SCR_SLEEPDEEP_Msk              (1UL << SCB_SCR_SLEEPDEEP_Pos)                 /*!< SCB SCR: SLEEPDEEP Mask */
+
+#define SCB_SCR_SLEEPONEXIT_Pos             1U                                            /*!< SCB SCR: SLEEPONEXIT Position */
+#define SCB_SCR_SLEEPONEXIT_Msk            (1UL << SCB_SCR_SLEEPONEXIT_Pos)               /*!< SCB SCR: SLEEPONEXIT Mask */
+
+/* SCB Configuration Control Register Definitions */
+#define SCB_CCR_BP_Pos                     18U                                            /*!< SCB CCR: BP Position */
+#define SCB_CCR_BP_Msk                     (1UL << SCB_CCR_BP_Pos)                        /*!< SCB CCR: BP Mask */
+
+#define SCB_CCR_IC_Pos                     17U                                            /*!< SCB CCR: IC Position */
+#define SCB_CCR_IC_Msk                     (1UL << SCB_CCR_IC_Pos)                        /*!< SCB CCR: IC Mask */
+
+#define SCB_CCR_DC_Pos                     16U                                            /*!< SCB CCR: DC Position */
+#define SCB_CCR_DC_Msk                     (1UL << SCB_CCR_DC_Pos)                        /*!< SCB CCR: DC Mask */
+
+#define SCB_CCR_STKOFHFNMIGN_Pos           10U                                            /*!< SCB CCR: STKOFHFNMIGN Position */
+#define SCB_CCR_STKOFHFNMIGN_Msk           (1UL << SCB_CCR_STKOFHFNMIGN_Pos)              /*!< SCB CCR: STKOFHFNMIGN Mask */
+
+#define SCB_CCR_BFHFNMIGN_Pos               8U                                            /*!< SCB CCR: BFHFNMIGN Position */
+#define SCB_CCR_BFHFNMIGN_Msk              (1UL << SCB_CCR_BFHFNMIGN_Pos)                 /*!< SCB CCR: BFHFNMIGN Mask */
+
+#define SCB_CCR_DIV_0_TRP_Pos               4U                                            /*!< SCB CCR: DIV_0_TRP Position */
+#define SCB_CCR_DIV_0_TRP_Msk              (1UL << SCB_CCR_DIV_0_TRP_Pos)                 /*!< SCB CCR: DIV_0_TRP Mask */
+
+#define SCB_CCR_UNALIGN_TRP_Pos             3U                                            /*!< SCB CCR: UNALIGN_TRP Position */
+#define SCB_CCR_UNALIGN_TRP_Msk            (1UL << SCB_CCR_UNALIGN_TRP_Pos)               /*!< SCB CCR: UNALIGN_TRP Mask */
+
+#define SCB_CCR_USERSETMPEND_Pos            1U                                            /*!< SCB CCR: USERSETMPEND Position */
+#define SCB_CCR_USERSETMPEND_Msk           (1UL << SCB_CCR_USERSETMPEND_Pos)              /*!< SCB CCR: USERSETMPEND Mask */
+
+/* SCB System Handler Control and State Register Definitions */
+#define SCB_SHCSR_HARDFAULTPENDED_Pos      21U                                            /*!< SCB SHCSR: HARDFAULTPENDED Position */
+#define SCB_SHCSR_HARDFAULTPENDED_Msk      (1UL << SCB_SHCSR_HARDFAULTPENDED_Pos)         /*!< SCB SHCSR: HARDFAULTPENDED Mask */
+
+#define SCB_SHCSR_SECUREFAULTPENDED_Pos    20U                                            /*!< SCB SHCSR: SECUREFAULTPENDED Position */
+#define SCB_SHCSR_SECUREFAULTPENDED_Msk    (1UL << SCB_SHCSR_SECUREFAULTPENDED_Pos)       /*!< SCB SHCSR: SECUREFAULTPENDED Mask */
+
+#define SCB_SHCSR_SECUREFAULTENA_Pos       19U                                            /*!< SCB SHCSR: SECUREFAULTENA Position */
+#define SCB_SHCSR_SECUREFAULTENA_Msk       (1UL << SCB_SHCSR_SECUREFAULTENA_Pos)          /*!< SCB SHCSR: SECUREFAULTENA Mask */
+
+#define SCB_SHCSR_USGFAULTENA_Pos          18U                                            /*!< SCB SHCSR: USGFAULTENA Position */
+#define SCB_SHCSR_USGFAULTENA_Msk          (1UL << SCB_SHCSR_USGFAULTENA_Pos)             /*!< SCB SHCSR: USGFAULTENA Mask */
+
+#define SCB_SHCSR_BUSFAULTENA_Pos          17U                                            /*!< SCB SHCSR: BUSFAULTENA Position */
+#define SCB_SHCSR_BUSFAULTENA_Msk          (1UL << SCB_SHCSR_BUSFAULTENA_Pos)             /*!< SCB SHCSR: BUSFAULTENA Mask */
+
+#define SCB_SHCSR_MEMFAULTENA_Pos          16U                                            /*!< SCB SHCSR: MEMFAULTENA Position */
+#define SCB_SHCSR_MEMFAULTENA_Msk          (1UL << SCB_SHCSR_MEMFAULTENA_Pos)             /*!< SCB SHCSR: MEMFAULTENA Mask */
+
+#define SCB_SHCSR_SVCALLPENDED_Pos         15U                                            /*!< SCB SHCSR: SVCALLPENDED Position */
+#define SCB_SHCSR_SVCALLPENDED_Msk         (1UL << SCB_SHCSR_SVCALLPENDED_Pos)            /*!< SCB SHCSR: SVCALLPENDED Mask */
+
+#define SCB_SHCSR_BUSFAULTPENDED_Pos       14U                                            /*!< SCB SHCSR: BUSFAULTPENDED Position */
+#define SCB_SHCSR_BUSFAULTPENDED_Msk       (1UL << SCB_SHCSR_BUSFAULTPENDED_Pos)          /*!< SCB SHCSR: BUSFAULTPENDED Mask */
+
+#define SCB_SHCSR_MEMFAULTPENDED_Pos       13U                                            /*!< SCB SHCSR: MEMFAULTPENDED Position */
+#define SCB_SHCSR_MEMFAULTPENDED_Msk       (1UL << SCB_SHCSR_MEMFAULTPENDED_Pos)          /*!< SCB SHCSR: MEMFAULTPENDED Mask */
+
+#define SCB_SHCSR_USGFAULTPENDED_Pos       12U                                            /*!< SCB SHCSR: USGFAULTPENDED Position */
+#define SCB_SHCSR_USGFAULTPENDED_Msk       (1UL << SCB_SHCSR_USGFAULTPENDED_Pos)          /*!< SCB SHCSR: USGFAULTPENDED Mask */
+
+#define SCB_SHCSR_SYSTICKACT_Pos           11U                                            /*!< SCB SHCSR: SYSTICKACT Position */
+#define SCB_SHCSR_SYSTICKACT_Msk           (1UL << SCB_SHCSR_SYSTICKACT_Pos)              /*!< SCB SHCSR: SYSTICKACT Mask */
+
+#define SCB_SHCSR_PENDSVACT_Pos            10U                                            /*!< SCB SHCSR: PENDSVACT Position */
+#define SCB_SHCSR_PENDSVACT_Msk            (1UL << SCB_SHCSR_PENDSVACT_Pos)               /*!< SCB SHCSR: PENDSVACT Mask */
+
+#define SCB_SHCSR_MONITORACT_Pos            8U                                            /*!< SCB SHCSR: MONITORACT Position */
+#define SCB_SHCSR_MONITORACT_Msk           (1UL << SCB_SHCSR_MONITORACT_Pos)              /*!< SCB SHCSR: MONITORACT Mask */
+
+#define SCB_SHCSR_SVCALLACT_Pos             7U                                            /*!< SCB SHCSR: SVCALLACT Position */
+#define SCB_SHCSR_SVCALLACT_Msk            (1UL << SCB_SHCSR_SVCALLACT_Pos)               /*!< SCB SHCSR: SVCALLACT Mask */
+
+#define SCB_SHCSR_NMIACT_Pos                5U                                            /*!< SCB SHCSR: NMIACT Position */
+#define SCB_SHCSR_NMIACT_Msk               (1UL << SCB_SHCSR_NMIACT_Pos)                  /*!< SCB SHCSR: NMIACT Mask */
+
+#define SCB_SHCSR_SECUREFAULTACT_Pos        4U                                            /*!< SCB SHCSR: SECUREFAULTACT Position */
+#define SCB_SHCSR_SECUREFAULTACT_Msk       (1UL << SCB_SHCSR_SECUREFAULTACT_Pos)          /*!< SCB SHCSR: SECUREFAULTACT Mask */
+
+#define SCB_SHCSR_USGFAULTACT_Pos           3U                                            /*!< SCB SHCSR: USGFAULTACT Position */
+#define SCB_SHCSR_USGFAULTACT_Msk          (1UL << SCB_SHCSR_USGFAULTACT_Pos)             /*!< SCB SHCSR: USGFAULTACT Mask */
+
+#define SCB_SHCSR_HARDFAULTACT_Pos          2U                                            /*!< SCB SHCSR: HARDFAULTACT Position */
+#define SCB_SHCSR_HARDFAULTACT_Msk         (1UL << SCB_SHCSR_HARDFAULTACT_Pos)            /*!< SCB SHCSR: HARDFAULTACT Mask */
+
+#define SCB_SHCSR_BUSFAULTACT_Pos           1U                                            /*!< SCB SHCSR: BUSFAULTACT Position */
+#define SCB_SHCSR_BUSFAULTACT_Msk          (1UL << SCB_SHCSR_BUSFAULTACT_Pos)             /*!< SCB SHCSR: BUSFAULTACT Mask */
+
+#define SCB_SHCSR_MEMFAULTACT_Pos           0U                                            /*!< SCB SHCSR: MEMFAULTACT Position */
+#define SCB_SHCSR_MEMFAULTACT_Msk          (1UL /*<< SCB_SHCSR_MEMFAULTACT_Pos*/)         /*!< SCB SHCSR: MEMFAULTACT Mask */
+
+/* SCB Configurable Fault Status Register Definitions */
+#define SCB_CFSR_USGFAULTSR_Pos            16U                                            /*!< SCB CFSR: Usage Fault Status Register Position */
+#define SCB_CFSR_USGFAULTSR_Msk            (0xFFFFUL << SCB_CFSR_USGFAULTSR_Pos)          /*!< SCB CFSR: Usage Fault Status Register Mask */
+
+#define SCB_CFSR_BUSFAULTSR_Pos             8U                                            /*!< SCB CFSR: Bus Fault Status Register Position */
+#define SCB_CFSR_BUSFAULTSR_Msk            (0xFFUL << SCB_CFSR_BUSFAULTSR_Pos)            /*!< SCB CFSR: Bus Fault Status Register Mask */
+
+#define SCB_CFSR_MEMFAULTSR_Pos             0U                                            /*!< SCB CFSR: Memory Manage Fault Status Register Position */
+#define SCB_CFSR_MEMFAULTSR_Msk            (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/)        /*!< SCB CFSR: Memory Manage Fault Status Register Mask */
+
+/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_MMARVALID_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 7U)               /*!< SCB CFSR (MMFSR): MMARVALID Position */
+#define SCB_CFSR_MMARVALID_Msk             (1UL << SCB_CFSR_MMARVALID_Pos)                /*!< SCB CFSR (MMFSR): MMARVALID Mask */
+
+#define SCB_CFSR_MLSPERR_Pos               (SCB_SHCSR_MEMFAULTACT_Pos + 5U)               /*!< SCB CFSR (MMFSR): MLSPERR Position */
+#define SCB_CFSR_MLSPERR_Msk               (1UL << SCB_CFSR_MLSPERR_Pos)                  /*!< SCB CFSR (MMFSR): MLSPERR Mask */
+
+#define SCB_CFSR_MSTKERR_Pos               (SCB_SHCSR_MEMFAULTACT_Pos + 4U)               /*!< SCB CFSR (MMFSR): MSTKERR Position */
+#define SCB_CFSR_MSTKERR_Msk               (1UL << SCB_CFSR_MSTKERR_Pos)                  /*!< SCB CFSR (MMFSR): MSTKERR Mask */
+
+#define SCB_CFSR_MUNSTKERR_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 3U)               /*!< SCB CFSR (MMFSR): MUNSTKERR Position */
+#define SCB_CFSR_MUNSTKERR_Msk             (1UL << SCB_CFSR_MUNSTKERR_Pos)                /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */
+
+#define SCB_CFSR_DACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 1U)               /*!< SCB CFSR (MMFSR): DACCVIOL Position */
+#define SCB_CFSR_DACCVIOL_Msk              (1UL << SCB_CFSR_DACCVIOL_Pos)                 /*!< SCB CFSR (MMFSR): DACCVIOL Mask */
+
+#define SCB_CFSR_IACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 0U)               /*!< SCB CFSR (MMFSR): IACCVIOL Position */
+#define SCB_CFSR_IACCVIOL_Msk              (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/)             /*!< SCB CFSR (MMFSR): IACCVIOL Mask */
+
+/* BusFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_BFARVALID_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 7U)                  /*!< SCB CFSR (BFSR): BFARVALID Position */
+#define SCB_CFSR_BFARVALID_Msk            (1UL << SCB_CFSR_BFARVALID_Pos)                 /*!< SCB CFSR (BFSR): BFARVALID Mask */
+
+#define SCB_CFSR_LSPERR_Pos               (SCB_CFSR_BUSFAULTSR_Pos + 5U)                  /*!< SCB CFSR (BFSR): LSPERR Position */
+#define SCB_CFSR_LSPERR_Msk               (1UL << SCB_CFSR_LSPERR_Pos)                    /*!< SCB CFSR (BFSR): LSPERR Mask */
+
+#define SCB_CFSR_STKERR_Pos               (SCB_CFSR_BUSFAULTSR_Pos + 4U)                  /*!< SCB CFSR (BFSR): STKERR Position */
+#define SCB_CFSR_STKERR_Msk               (1UL << SCB_CFSR_STKERR_Pos)                    /*!< SCB CFSR (BFSR): STKERR Mask */
+
+#define SCB_CFSR_UNSTKERR_Pos             (SCB_CFSR_BUSFAULTSR_Pos + 3U)                  /*!< SCB CFSR (BFSR): UNSTKERR Position */
+#define SCB_CFSR_UNSTKERR_Msk             (1UL << SCB_CFSR_UNSTKERR_Pos)                  /*!< SCB CFSR (BFSR): UNSTKERR Mask */
+
+#define SCB_CFSR_IMPRECISERR_Pos          (SCB_CFSR_BUSFAULTSR_Pos + 2U)                  /*!< SCB CFSR (BFSR): IMPRECISERR Position */
+#define SCB_CFSR_IMPRECISERR_Msk          (1UL << SCB_CFSR_IMPRECISERR_Pos)               /*!< SCB CFSR (BFSR): IMPRECISERR Mask */
+
+#define SCB_CFSR_PRECISERR_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 1U)                  /*!< SCB CFSR (BFSR): PRECISERR Position */
+#define SCB_CFSR_PRECISERR_Msk            (1UL << SCB_CFSR_PRECISERR_Pos)                 /*!< SCB CFSR (BFSR): PRECISERR Mask */
+
+#define SCB_CFSR_IBUSERR_Pos              (SCB_CFSR_BUSFAULTSR_Pos + 0U)                  /*!< SCB CFSR (BFSR): IBUSERR Position */
+#define SCB_CFSR_IBUSERR_Msk              (1UL << SCB_CFSR_IBUSERR_Pos)                   /*!< SCB CFSR (BFSR): IBUSERR Mask */
+
+/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_DIVBYZERO_Pos            (SCB_CFSR_USGFAULTSR_Pos + 9U)                  /*!< SCB CFSR (UFSR): DIVBYZERO Position */
+#define SCB_CFSR_DIVBYZERO_Msk            (1UL << SCB_CFSR_DIVBYZERO_Pos)                 /*!< SCB CFSR (UFSR): DIVBYZERO Mask */
+
+#define SCB_CFSR_UNALIGNED_Pos            (SCB_CFSR_USGFAULTSR_Pos + 8U)                  /*!< SCB CFSR (UFSR): UNALIGNED Position */
+#define SCB_CFSR_UNALIGNED_Msk            (1UL << SCB_CFSR_UNALIGNED_Pos)                 /*!< SCB CFSR (UFSR): UNALIGNED Mask */
+
+#define SCB_CFSR_STKOF_Pos                (SCB_CFSR_USGFAULTSR_Pos + 4U)                  /*!< SCB CFSR (UFSR): STKOF Position */
+#define SCB_CFSR_STKOF_Msk                (1UL << SCB_CFSR_STKOF_Pos)                     /*!< SCB CFSR (UFSR): STKOF Mask */
+
+#define SCB_CFSR_NOCP_Pos                 (SCB_CFSR_USGFAULTSR_Pos + 3U)                  /*!< SCB CFSR (UFSR): NOCP Position */
+#define SCB_CFSR_NOCP_Msk                 (1UL << SCB_CFSR_NOCP_Pos)                      /*!< SCB CFSR (UFSR): NOCP Mask */
+
+#define SCB_CFSR_INVPC_Pos                (SCB_CFSR_USGFAULTSR_Pos + 2U)                  /*!< SCB CFSR (UFSR): INVPC Position */
+#define SCB_CFSR_INVPC_Msk                (1UL << SCB_CFSR_INVPC_Pos)                     /*!< SCB CFSR (UFSR): INVPC Mask */
+
+#define SCB_CFSR_INVSTATE_Pos             (SCB_CFSR_USGFAULTSR_Pos + 1U)                  /*!< SCB CFSR (UFSR): INVSTATE Position */
+#define SCB_CFSR_INVSTATE_Msk             (1UL << SCB_CFSR_INVSTATE_Pos)                  /*!< SCB CFSR (UFSR): INVSTATE Mask */
+
+#define SCB_CFSR_UNDEFINSTR_Pos           (SCB_CFSR_USGFAULTSR_Pos + 0U)                  /*!< SCB CFSR (UFSR): UNDEFINSTR Position */
+#define SCB_CFSR_UNDEFINSTR_Msk           (1UL << SCB_CFSR_UNDEFINSTR_Pos)                /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */
+
+/* SCB Hard Fault Status Register Definitions */
+#define SCB_HFSR_DEBUGEVT_Pos              31U                                            /*!< SCB HFSR: DEBUGEVT Position */
+#define SCB_HFSR_DEBUGEVT_Msk              (1UL << SCB_HFSR_DEBUGEVT_Pos)                 /*!< SCB HFSR: DEBUGEVT Mask */
+
+#define SCB_HFSR_FORCED_Pos                30U                                            /*!< SCB HFSR: FORCED Position */
+#define SCB_HFSR_FORCED_Msk                (1UL << SCB_HFSR_FORCED_Pos)                   /*!< SCB HFSR: FORCED Mask */
+
+#define SCB_HFSR_VECTTBL_Pos                1U                                            /*!< SCB HFSR: VECTTBL Position */
+#define SCB_HFSR_VECTTBL_Msk               (1UL << SCB_HFSR_VECTTBL_Pos)                  /*!< SCB HFSR: VECTTBL Mask */
+
+/* SCB Debug Fault Status Register Definitions */
+#define SCB_DFSR_EXTERNAL_Pos               4U                                            /*!< SCB DFSR: EXTERNAL Position */
+#define SCB_DFSR_EXTERNAL_Msk              (1UL << SCB_DFSR_EXTERNAL_Pos)                 /*!< SCB DFSR: EXTERNAL Mask */
+
+#define SCB_DFSR_VCATCH_Pos                 3U                                            /*!< SCB DFSR: VCATCH Position */
+#define SCB_DFSR_VCATCH_Msk                (1UL << SCB_DFSR_VCATCH_Pos)                   /*!< SCB DFSR: VCATCH Mask */
+
+#define SCB_DFSR_DWTTRAP_Pos                2U                                            /*!< SCB DFSR: DWTTRAP Position */
+#define SCB_DFSR_DWTTRAP_Msk               (1UL << SCB_DFSR_DWTTRAP_Pos)                  /*!< SCB DFSR: DWTTRAP Mask */
+
+#define SCB_DFSR_BKPT_Pos                   1U                                            /*!< SCB DFSR: BKPT Position */
+#define SCB_DFSR_BKPT_Msk                  (1UL << SCB_DFSR_BKPT_Pos)                     /*!< SCB DFSR: BKPT Mask */
+
+#define SCB_DFSR_HALTED_Pos                 0U                                            /*!< SCB DFSR: HALTED Position */
+#define SCB_DFSR_HALTED_Msk                (1UL /*<< SCB_DFSR_HALTED_Pos*/)               /*!< SCB DFSR: HALTED Mask */
+
+/* SCB Non-Secure Access Control Register Definitions */
+#define SCB_NSACR_CP11_Pos                 11U                                            /*!< SCB NSACR: CP11 Position */
+#define SCB_NSACR_CP11_Msk                 (1UL << SCB_NSACR_CP11_Pos)                    /*!< SCB NSACR: CP11 Mask */
+
+#define SCB_NSACR_CP10_Pos                 10U                                            /*!< SCB NSACR: CP10 Position */
+#define SCB_NSACR_CP10_Msk                 (1UL << SCB_NSACR_CP10_Pos)                    /*!< SCB NSACR: CP10 Mask */
+
+#define SCB_NSACR_CPn_Pos                   0U                                            /*!< SCB NSACR: CPn Position */
+#define SCB_NSACR_CPn_Msk                  (1UL /*<< SCB_NSACR_CPn_Pos*/)                 /*!< SCB NSACR: CPn Mask */
+
+/* SCB Cache Level ID Register Definitions */
+#define SCB_CLIDR_LOUU_Pos                 27U                                            /*!< SCB CLIDR: LoUU Position */
+#define SCB_CLIDR_LOUU_Msk                 (7UL << SCB_CLIDR_LOUU_Pos)                    /*!< SCB CLIDR: LoUU Mask */
+
+#define SCB_CLIDR_LOC_Pos                  24U                                            /*!< SCB CLIDR: LoC Position */
+#define SCB_CLIDR_LOC_Msk                  (7UL << SCB_CLIDR_LOC_Pos)                     /*!< SCB CLIDR: LoC Mask */
+
+/* SCB Cache Type Register Definitions */
+#define SCB_CTR_FORMAT_Pos                 29U                                            /*!< SCB CTR: Format Position */
+#define SCB_CTR_FORMAT_Msk                 (7UL << SCB_CTR_FORMAT_Pos)                    /*!< SCB CTR: Format Mask */
+
+#define SCB_CTR_CWG_Pos                    24U                                            /*!< SCB CTR: CWG Position */
+#define SCB_CTR_CWG_Msk                    (0xFUL << SCB_CTR_CWG_Pos)                     /*!< SCB CTR: CWG Mask */
+
+#define SCB_CTR_ERG_Pos                    20U                                            /*!< SCB CTR: ERG Position */
+#define SCB_CTR_ERG_Msk                    (0xFUL << SCB_CTR_ERG_Pos)                     /*!< SCB CTR: ERG Mask */
+
+#define SCB_CTR_DMINLINE_Pos               16U                                            /*!< SCB CTR: DminLine Position */
+#define SCB_CTR_DMINLINE_Msk               (0xFUL << SCB_CTR_DMINLINE_Pos)                /*!< SCB CTR: DminLine Mask */
+
+#define SCB_CTR_IMINLINE_Pos                0U                                            /*!< SCB CTR: ImInLine Position */
+#define SCB_CTR_IMINLINE_Msk               (0xFUL /*<< SCB_CTR_IMINLINE_Pos*/)            /*!< SCB CTR: ImInLine Mask */
+
+/* SCB Cache Size ID Register Definitions */
+#define SCB_CCSIDR_WT_Pos                  31U                                            /*!< SCB CCSIDR: WT Position */
+#define SCB_CCSIDR_WT_Msk                  (1UL << SCB_CCSIDR_WT_Pos)                     /*!< SCB CCSIDR: WT Mask */
+
+#define SCB_CCSIDR_WB_Pos                  30U                                            /*!< SCB CCSIDR: WB Position */
+#define SCB_CCSIDR_WB_Msk                  (1UL << SCB_CCSIDR_WB_Pos)                     /*!< SCB CCSIDR: WB Mask */
+
+#define SCB_CCSIDR_RA_Pos                  29U                                            /*!< SCB CCSIDR: RA Position */
+#define SCB_CCSIDR_RA_Msk                  (1UL << SCB_CCSIDR_RA_Pos)                     /*!< SCB CCSIDR: RA Mask */
+
+#define SCB_CCSIDR_WA_Pos                  28U                                            /*!< SCB CCSIDR: WA Position */
+#define SCB_CCSIDR_WA_Msk                  (1UL << SCB_CCSIDR_WA_Pos)                     /*!< SCB CCSIDR: WA Mask */
+
+#define SCB_CCSIDR_NUMSETS_Pos             13U                                            /*!< SCB CCSIDR: NumSets Position */
+#define SCB_CCSIDR_NUMSETS_Msk             (0x7FFFUL << SCB_CCSIDR_NUMSETS_Pos)           /*!< SCB CCSIDR: NumSets Mask */
+
+#define SCB_CCSIDR_ASSOCIATIVITY_Pos        3U                                            /*!< SCB CCSIDR: Associativity Position */
+#define SCB_CCSIDR_ASSOCIATIVITY_Msk       (0x3FFUL << SCB_CCSIDR_ASSOCIATIVITY_Pos)      /*!< SCB CCSIDR: Associativity Mask */
+
+#define SCB_CCSIDR_LINESIZE_Pos             0U                                            /*!< SCB CCSIDR: LineSize Position */
+#define SCB_CCSIDR_LINESIZE_Msk            (7UL /*<< SCB_CCSIDR_LINESIZE_Pos*/)           /*!< SCB CCSIDR: LineSize Mask */
+
+/* SCB Cache Size Selection Register Definitions */
+#define SCB_CSSELR_LEVEL_Pos                1U                                            /*!< SCB CSSELR: Level Position */
+#define SCB_CSSELR_LEVEL_Msk               (7UL << SCB_CSSELR_LEVEL_Pos)                  /*!< SCB CSSELR: Level Mask */
+
+#define SCB_CSSELR_IND_Pos                  0U                                            /*!< SCB CSSELR: InD Position */
+#define SCB_CSSELR_IND_Msk                 (1UL /*<< SCB_CSSELR_IND_Pos*/)                /*!< SCB CSSELR: InD Mask */
+
+/* SCB Software Triggered Interrupt Register Definitions */
+#define SCB_STIR_INTID_Pos                  0U                                            /*!< SCB STIR: INTID Position */
+#define SCB_STIR_INTID_Msk                 (0x1FFUL /*<< SCB_STIR_INTID_Pos*/)            /*!< SCB STIR: INTID Mask */
+
+/* SCB D-Cache Invalidate by Set-way Register Definitions */
+#define SCB_DCISW_WAY_Pos                  30U                                            /*!< SCB DCISW: Way Position */
+#define SCB_DCISW_WAY_Msk                  (3UL << SCB_DCISW_WAY_Pos)                     /*!< SCB DCISW: Way Mask */
+
+#define SCB_DCISW_SET_Pos                   5U                                            /*!< SCB DCISW: Set Position */
+#define SCB_DCISW_SET_Msk                  (0x1FFUL << SCB_DCISW_SET_Pos)                 /*!< SCB DCISW: Set Mask */
+
+/* SCB D-Cache Clean by Set-way Register Definitions */
+#define SCB_DCCSW_WAY_Pos                  30U                                            /*!< SCB DCCSW: Way Position */
+#define SCB_DCCSW_WAY_Msk                  (3UL << SCB_DCCSW_WAY_Pos)                     /*!< SCB DCCSW: Way Mask */
+
+#define SCB_DCCSW_SET_Pos                   5U                                            /*!< SCB DCCSW: Set Position */
+#define SCB_DCCSW_SET_Msk                  (0x1FFUL << SCB_DCCSW_SET_Pos)                 /*!< SCB DCCSW: Set Mask */
+
+/* SCB D-Cache Clean and Invalidate by Set-way Register Definitions */
+#define SCB_DCCISW_WAY_Pos                 30U                                            /*!< SCB DCCISW: Way Position */
+#define SCB_DCCISW_WAY_Msk                 (3UL << SCB_DCCISW_WAY_Pos)                    /*!< SCB DCCISW: Way Mask */
+
+#define SCB_DCCISW_SET_Pos                  5U                                            /*!< SCB DCCISW: Set Position */
+#define SCB_DCCISW_SET_Msk                 (0x1FFUL << SCB_DCCISW_SET_Pos)                /*!< SCB DCCISW: Set Mask */
+
+/*@} end of group CMSIS_SCB */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB)
+  \brief    Type definitions for the System Control and ID Register not in the SCB
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Control and ID Register not in the SCB.
+ */
+typedef struct
+{
+        uint32_t RESERVED0[1U];
+  __IM  uint32_t ICTR;                   /*!< Offset: 0x004 (R/ )  Interrupt Controller Type Register */
+  __IOM uint32_t ACTLR;                  /*!< Offset: 0x008 (R/W)  Auxiliary Control Register */
+  __IOM uint32_t CPPWR;                  /*!< Offset: 0x00C (R/W)  Coprocessor Power Control  Register */
+} SCnSCB_Type;
+
+/* Interrupt Controller Type Register Definitions */
+#define SCnSCB_ICTR_INTLINESNUM_Pos         0U                                         /*!< ICTR: INTLINESNUM Position */
+#define SCnSCB_ICTR_INTLINESNUM_Msk        (0xFUL /*<< SCnSCB_ICTR_INTLINESNUM_Pos*/)  /*!< ICTR: INTLINESNUM Mask */
+
+/*@} end of group CMSIS_SCnotSCB */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SysTick     System Tick Timer (SysTick)
+  \brief    Type definitions for the System Timer Registers.
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Timer (SysTick).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  SysTick Control and Status Register */
+  __IOM uint32_t LOAD;                   /*!< Offset: 0x004 (R/W)  SysTick Reload Value Register */
+  __IOM uint32_t VAL;                    /*!< Offset: 0x008 (R/W)  SysTick Current Value Register */
+  __IM  uint32_t CALIB;                  /*!< Offset: 0x00C (R/ )  SysTick Calibration Register */
+} SysTick_Type;
+
+/* SysTick Control / Status Register Definitions */
+#define SysTick_CTRL_COUNTFLAG_Pos         16U                                            /*!< SysTick CTRL: COUNTFLAG Position */
+#define SysTick_CTRL_COUNTFLAG_Msk         (1UL << SysTick_CTRL_COUNTFLAG_Pos)            /*!< SysTick CTRL: COUNTFLAG Mask */
+
+#define SysTick_CTRL_CLKSOURCE_Pos          2U                                            /*!< SysTick CTRL: CLKSOURCE Position */
+#define SysTick_CTRL_CLKSOURCE_Msk         (1UL << SysTick_CTRL_CLKSOURCE_Pos)            /*!< SysTick CTRL: CLKSOURCE Mask */
+
+#define SysTick_CTRL_TICKINT_Pos            1U                                            /*!< SysTick CTRL: TICKINT Position */
+#define SysTick_CTRL_TICKINT_Msk           (1UL << SysTick_CTRL_TICKINT_Pos)              /*!< SysTick CTRL: TICKINT Mask */
+
+#define SysTick_CTRL_ENABLE_Pos             0U                                            /*!< SysTick CTRL: ENABLE Position */
+#define SysTick_CTRL_ENABLE_Msk            (1UL /*<< SysTick_CTRL_ENABLE_Pos*/)           /*!< SysTick CTRL: ENABLE Mask */
+
+/* SysTick Reload Register Definitions */
+#define SysTick_LOAD_RELOAD_Pos             0U                                            /*!< SysTick LOAD: RELOAD Position */
+#define SysTick_LOAD_RELOAD_Msk            (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/)    /*!< SysTick LOAD: RELOAD Mask */
+
+/* SysTick Current Register Definitions */
+#define SysTick_VAL_CURRENT_Pos             0U                                            /*!< SysTick VAL: CURRENT Position */
+#define SysTick_VAL_CURRENT_Msk            (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/)    /*!< SysTick VAL: CURRENT Mask */
+
+/* SysTick Calibration Register Definitions */
+#define SysTick_CALIB_NOREF_Pos            31U                                            /*!< SysTick CALIB: NOREF Position */
+#define SysTick_CALIB_NOREF_Msk            (1UL << SysTick_CALIB_NOREF_Pos)               /*!< SysTick CALIB: NOREF Mask */
+
+#define SysTick_CALIB_SKEW_Pos             30U                                            /*!< SysTick CALIB: SKEW Position */
+#define SysTick_CALIB_SKEW_Msk             (1UL << SysTick_CALIB_SKEW_Pos)                /*!< SysTick CALIB: SKEW Mask */
+
+#define SysTick_CALIB_TENMS_Pos             0U                                            /*!< SysTick CALIB: TENMS Position */
+#define SysTick_CALIB_TENMS_Msk            (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/)    /*!< SysTick CALIB: TENMS Mask */
+
+/*@} end of group CMSIS_SysTick */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_ITM     Instrumentation Trace Macrocell (ITM)
+  \brief    Type definitions for the Instrumentation Trace Macrocell (ITM)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Instrumentation Trace Macrocell Register (ITM).
+ */
+typedef struct
+{
+  __OM  union
+  {
+    __OM  uint8_t    u8;                 /*!< Offset: 0x000 ( /W)  ITM Stimulus Port 8-bit */
+    __OM  uint16_t   u16;                /*!< Offset: 0x000 ( /W)  ITM Stimulus Port 16-bit */
+    __OM  uint32_t   u32;                /*!< Offset: 0x000 ( /W)  ITM Stimulus Port 32-bit */
+  }  PORT [32U];                         /*!< Offset: 0x000 ( /W)  ITM Stimulus Port Registers */
+        uint32_t RESERVED0[864U];
+  __IOM uint32_t TER;                    /*!< Offset: 0xE00 (R/W)  ITM Trace Enable Register */
+        uint32_t RESERVED1[15U];
+  __IOM uint32_t TPR;                    /*!< Offset: 0xE40 (R/W)  ITM Trace Privilege Register */
+        uint32_t RESERVED2[15U];
+  __IOM uint32_t TCR;                    /*!< Offset: 0xE80 (R/W)  ITM Trace Control Register */
+        uint32_t RESERVED3[32U];
+        uint32_t RESERVED4[43U];
+  __OM  uint32_t LAR;                    /*!< Offset: 0xFB0 ( /W)  ITM Lock Access Register */
+  __IM  uint32_t LSR;                    /*!< Offset: 0xFB4 (R/ )  ITM Lock Status Register */
+        uint32_t RESERVED5[1U];
+  __IM  uint32_t DEVARCH;                /*!< Offset: 0xFBC (R/ )  ITM Device Architecture Register */
+        uint32_t RESERVED6[4U];
+  __IM  uint32_t PID4;                   /*!< Offset: 0xFD0 (R/ )  ITM Peripheral Identification Register #4 */
+  __IM  uint32_t PID5;                   /*!< Offset: 0xFD4 (R/ )  ITM Peripheral Identification Register #5 */
+  __IM  uint32_t PID6;                   /*!< Offset: 0xFD8 (R/ )  ITM Peripheral Identification Register #6 */
+  __IM  uint32_t PID7;                   /*!< Offset: 0xFDC (R/ )  ITM Peripheral Identification Register #7 */
+  __IM  uint32_t PID0;                   /*!< Offset: 0xFE0 (R/ )  ITM Peripheral Identification Register #0 */
+  __IM  uint32_t PID1;                   /*!< Offset: 0xFE4 (R/ )  ITM Peripheral Identification Register #1 */
+  __IM  uint32_t PID2;                   /*!< Offset: 0xFE8 (R/ )  ITM Peripheral Identification Register #2 */
+  __IM  uint32_t PID3;                   /*!< Offset: 0xFEC (R/ )  ITM Peripheral Identification Register #3 */
+  __IM  uint32_t CID0;                   /*!< Offset: 0xFF0 (R/ )  ITM Component  Identification Register #0 */
+  __IM  uint32_t CID1;                   /*!< Offset: 0xFF4 (R/ )  ITM Component  Identification Register #1 */
+  __IM  uint32_t CID2;                   /*!< Offset: 0xFF8 (R/ )  ITM Component  Identification Register #2 */
+  __IM  uint32_t CID3;                   /*!< Offset: 0xFFC (R/ )  ITM Component  Identification Register #3 */
+} ITM_Type;
+
+/* ITM Stimulus Port Register Definitions */
+#define ITM_STIM_DISABLED_Pos               1U                                            /*!< ITM STIM: DISABLED Position */
+#define ITM_STIM_DISABLED_Msk              (0x1UL << ITM_STIM_DISABLED_Pos)               /*!< ITM STIM: DISABLED Mask */
+
+#define ITM_STIM_FIFOREADY_Pos              0U                                            /*!< ITM STIM: FIFOREADY Position */
+#define ITM_STIM_FIFOREADY_Msk             (0x1UL /*<< ITM_STIM_FIFOREADY_Pos*/)          /*!< ITM STIM: FIFOREADY Mask */
+
+/* ITM Trace Privilege Register Definitions */
+#define ITM_TPR_PRIVMASK_Pos                0U                                            /*!< ITM TPR: PRIVMASK Position */
+#define ITM_TPR_PRIVMASK_Msk               (0xFFFFFFFFUL /*<< ITM_TPR_PRIVMASK_Pos*/)     /*!< ITM TPR: PRIVMASK Mask */
+
+/* ITM Trace Control Register Definitions */
+#define ITM_TCR_BUSY_Pos                   23U                                            /*!< ITM TCR: BUSY Position */
+#define ITM_TCR_BUSY_Msk                   (1UL << ITM_TCR_BUSY_Pos)                      /*!< ITM TCR: BUSY Mask */
+
+#define ITM_TCR_TRACEBUSID_Pos             16U                                            /*!< ITM TCR: ATBID Position */
+#define ITM_TCR_TRACEBUSID_Msk             (0x7FUL << ITM_TCR_TRACEBUSID_Pos)             /*!< ITM TCR: ATBID Mask */
+
+#define ITM_TCR_GTSFREQ_Pos                10U                                            /*!< ITM TCR: Global timestamp frequency Position */
+#define ITM_TCR_GTSFREQ_Msk                (3UL << ITM_TCR_GTSFREQ_Pos)                   /*!< ITM TCR: Global timestamp frequency Mask */
+
+#define ITM_TCR_TSPRESCALE_Pos              8U                                            /*!< ITM TCR: TSPRESCALE Position */
+#define ITM_TCR_TSPRESCALE_Msk             (3UL << ITM_TCR_TSPRESCALE_Pos)                /*!< ITM TCR: TSPRESCALE Mask */
+
+#define ITM_TCR_STALLENA_Pos                5U                                            /*!< ITM TCR: STALLENA Position */
+#define ITM_TCR_STALLENA_Msk               (1UL << ITM_TCR_STALLENA_Pos)                  /*!< ITM TCR: STALLENA Mask */
+
+#define ITM_TCR_SWOENA_Pos                  4U                                            /*!< ITM TCR: SWOENA Position */
+#define ITM_TCR_SWOENA_Msk                 (1UL << ITM_TCR_SWOENA_Pos)                    /*!< ITM TCR: SWOENA Mask */
+
+#define ITM_TCR_DWTENA_Pos                  3U                                            /*!< ITM TCR: DWTENA Position */
+#define ITM_TCR_DWTENA_Msk                 (1UL << ITM_TCR_DWTENA_Pos)                    /*!< ITM TCR: DWTENA Mask */
+
+#define ITM_TCR_SYNCENA_Pos                 2U                                            /*!< ITM TCR: SYNCENA Position */
+#define ITM_TCR_SYNCENA_Msk                (1UL << ITM_TCR_SYNCENA_Pos)                   /*!< ITM TCR: SYNCENA Mask */
+
+#define ITM_TCR_TSENA_Pos                   1U                                            /*!< ITM TCR: TSENA Position */
+#define ITM_TCR_TSENA_Msk                  (1UL << ITM_TCR_TSENA_Pos)                     /*!< ITM TCR: TSENA Mask */
+
+#define ITM_TCR_ITMENA_Pos                  0U                                            /*!< ITM TCR: ITM Enable bit Position */
+#define ITM_TCR_ITMENA_Msk                 (1UL /*<< ITM_TCR_ITMENA_Pos*/)                /*!< ITM TCR: ITM Enable bit Mask */
+
+/* ITM Lock Status Register Definitions */
+#define ITM_LSR_ByteAcc_Pos                 2U                                            /*!< ITM LSR: ByteAcc Position */
+#define ITM_LSR_ByteAcc_Msk                (1UL << ITM_LSR_ByteAcc_Pos)                   /*!< ITM LSR: ByteAcc Mask */
+
+#define ITM_LSR_Access_Pos                  1U                                            /*!< ITM LSR: Access Position */
+#define ITM_LSR_Access_Msk                 (1UL << ITM_LSR_Access_Pos)                    /*!< ITM LSR: Access Mask */
+
+#define ITM_LSR_Present_Pos                 0U                                            /*!< ITM LSR: Present Position */
+#define ITM_LSR_Present_Msk                (1UL /*<< ITM_LSR_Present_Pos*/)               /*!< ITM LSR: Present Mask */
+
+/*@}*/ /* end of group CMSIS_ITM */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_DWT     Data Watchpoint and Trace (DWT)
+  \brief    Type definitions for the Data Watchpoint and Trace (DWT)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Data Watchpoint and Trace Register (DWT).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  Control Register */
+  __IOM uint32_t CYCCNT;                 /*!< Offset: 0x004 (R/W)  Cycle Count Register */
+  __IOM uint32_t CPICNT;                 /*!< Offset: 0x008 (R/W)  CPI Count Register */
+  __IOM uint32_t EXCCNT;                 /*!< Offset: 0x00C (R/W)  Exception Overhead Count Register */
+  __IOM uint32_t SLEEPCNT;               /*!< Offset: 0x010 (R/W)  Sleep Count Register */
+  __IOM uint32_t LSUCNT;                 /*!< Offset: 0x014 (R/W)  LSU Count Register */
+  __IOM uint32_t FOLDCNT;                /*!< Offset: 0x018 (R/W)  Folded-instruction Count Register */
+  __IM  uint32_t PCSR;                   /*!< Offset: 0x01C (R/ )  Program Counter Sample Register */
+  __IOM uint32_t COMP0;                  /*!< Offset: 0x020 (R/W)  Comparator Register 0 */
+        uint32_t RESERVED1[1U];
+  __IOM uint32_t FUNCTION0;              /*!< Offset: 0x028 (R/W)  Function Register 0 */
+        uint32_t RESERVED2[1U];
+  __IOM uint32_t COMP1;                  /*!< Offset: 0x030 (R/W)  Comparator Register 1 */
+        uint32_t RESERVED3[1U];
+  __IOM uint32_t FUNCTION1;              /*!< Offset: 0x038 (R/W)  Function Register 1 */
+        uint32_t RESERVED4[1U];
+  __IOM uint32_t COMP2;                  /*!< Offset: 0x040 (R/W)  Comparator Register 2 */
+        uint32_t RESERVED5[1U];
+  __IOM uint32_t FUNCTION2;              /*!< Offset: 0x048 (R/W)  Function Register 2 */
+        uint32_t RESERVED6[1U];
+  __IOM uint32_t COMP3;                  /*!< Offset: 0x050 (R/W)  Comparator Register 3 */
+        uint32_t RESERVED7[1U];
+  __IOM uint32_t FUNCTION3;              /*!< Offset: 0x058 (R/W)  Function Register 3 */
+        uint32_t RESERVED8[1U];
+  __IOM uint32_t COMP4;                  /*!< Offset: 0x060 (R/W)  Comparator Register 4 */
+        uint32_t RESERVED9[1U];
+  __IOM uint32_t FUNCTION4;              /*!< Offset: 0x068 (R/W)  Function Register 4 */
+        uint32_t RESERVED10[1U];
+  __IOM uint32_t COMP5;                  /*!< Offset: 0x070 (R/W)  Comparator Register 5 */
+        uint32_t RESERVED11[1U];
+  __IOM uint32_t FUNCTION5;              /*!< Offset: 0x078 (R/W)  Function Register 5 */
+        uint32_t RESERVED12[1U];
+  __IOM uint32_t COMP6;                  /*!< Offset: 0x080 (R/W)  Comparator Register 6 */
+        uint32_t RESERVED13[1U];
+  __IOM uint32_t FUNCTION6;              /*!< Offset: 0x088 (R/W)  Function Register 6 */
+        uint32_t RESERVED14[1U];
+  __IOM uint32_t COMP7;                  /*!< Offset: 0x090 (R/W)  Comparator Register 7 */
+        uint32_t RESERVED15[1U];
+  __IOM uint32_t FUNCTION7;              /*!< Offset: 0x098 (R/W)  Function Register 7 */
+        uint32_t RESERVED16[1U];
+  __IOM uint32_t COMP8;                  /*!< Offset: 0x0A0 (R/W)  Comparator Register 8 */
+        uint32_t RESERVED17[1U];
+  __IOM uint32_t FUNCTION8;              /*!< Offset: 0x0A8 (R/W)  Function Register 8 */
+        uint32_t RESERVED18[1U];
+  __IOM uint32_t COMP9;                  /*!< Offset: 0x0B0 (R/W)  Comparator Register 9 */
+        uint32_t RESERVED19[1U];
+  __IOM uint32_t FUNCTION9;              /*!< Offset: 0x0B8 (R/W)  Function Register 9 */
+        uint32_t RESERVED20[1U];
+  __IOM uint32_t COMP10;                 /*!< Offset: 0x0C0 (R/W)  Comparator Register 10 */
+        uint32_t RESERVED21[1U];
+  __IOM uint32_t FUNCTION10;             /*!< Offset: 0x0C8 (R/W)  Function Register 10 */
+        uint32_t RESERVED22[1U];
+  __IOM uint32_t COMP11;                 /*!< Offset: 0x0D0 (R/W)  Comparator Register 11 */
+        uint32_t RESERVED23[1U];
+  __IOM uint32_t FUNCTION11;             /*!< Offset: 0x0D8 (R/W)  Function Register 11 */
+        uint32_t RESERVED24[1U];
+  __IOM uint32_t COMP12;                 /*!< Offset: 0x0E0 (R/W)  Comparator Register 12 */
+        uint32_t RESERVED25[1U];
+  __IOM uint32_t FUNCTION12;             /*!< Offset: 0x0E8 (R/W)  Function Register 12 */
+        uint32_t RESERVED26[1U];
+  __IOM uint32_t COMP13;                 /*!< Offset: 0x0F0 (R/W)  Comparator Register 13 */
+        uint32_t RESERVED27[1U];
+  __IOM uint32_t FUNCTION13;             /*!< Offset: 0x0F8 (R/W)  Function Register 13 */
+        uint32_t RESERVED28[1U];
+  __IOM uint32_t COMP14;                 /*!< Offset: 0x100 (R/W)  Comparator Register 14 */
+        uint32_t RESERVED29[1U];
+  __IOM uint32_t FUNCTION14;             /*!< Offset: 0x108 (R/W)  Function Register 14 */
+        uint32_t RESERVED30[1U];
+  __IOM uint32_t COMP15;                 /*!< Offset: 0x110 (R/W)  Comparator Register 15 */
+        uint32_t RESERVED31[1U];
+  __IOM uint32_t FUNCTION15;             /*!< Offset: 0x118 (R/W)  Function Register 15 */
+        uint32_t RESERVED32[934U];
+  __IM  uint32_t LSR;                    /*!< Offset: 0xFB4 (R  )  Lock Status Register */
+        uint32_t RESERVED33[1U];
+  __IM  uint32_t DEVARCH;                /*!< Offset: 0xFBC (R/ )  Device Architecture Register */
+} DWT_Type;
+
+/* DWT Control Register Definitions */
+#define DWT_CTRL_NUMCOMP_Pos               28U                                         /*!< DWT CTRL: NUMCOMP Position */
+#define DWT_CTRL_NUMCOMP_Msk               (0xFUL << DWT_CTRL_NUMCOMP_Pos)             /*!< DWT CTRL: NUMCOMP Mask */
+
+#define DWT_CTRL_NOTRCPKT_Pos              27U                                         /*!< DWT CTRL: NOTRCPKT Position */
+#define DWT_CTRL_NOTRCPKT_Msk              (0x1UL << DWT_CTRL_NOTRCPKT_Pos)            /*!< DWT CTRL: NOTRCPKT Mask */
+
+#define DWT_CTRL_NOEXTTRIG_Pos             26U                                         /*!< DWT CTRL: NOEXTTRIG Position */
+#define DWT_CTRL_NOEXTTRIG_Msk             (0x1UL << DWT_CTRL_NOEXTTRIG_Pos)           /*!< DWT CTRL: NOEXTTRIG Mask */
+
+#define DWT_CTRL_NOCYCCNT_Pos              25U                                         /*!< DWT CTRL: NOCYCCNT Position */
+#define DWT_CTRL_NOCYCCNT_Msk              (0x1UL << DWT_CTRL_NOCYCCNT_Pos)            /*!< DWT CTRL: NOCYCCNT Mask */
+
+#define DWT_CTRL_NOPRFCNT_Pos              24U                                         /*!< DWT CTRL: NOPRFCNT Position */
+#define DWT_CTRL_NOPRFCNT_Msk              (0x1UL << DWT_CTRL_NOPRFCNT_Pos)            /*!< DWT CTRL: NOPRFCNT Mask */
+
+#define DWT_CTRL_CYCDISS_Pos               23U                                         /*!< DWT CTRL: CYCDISS Position */
+#define DWT_CTRL_CYCDISS_Msk               (0x1UL << DWT_CTRL_CYCDISS_Pos)             /*!< DWT CTRL: CYCDISS Mask */
+
+#define DWT_CTRL_CYCEVTENA_Pos             22U                                         /*!< DWT CTRL: CYCEVTENA Position */
+#define DWT_CTRL_CYCEVTENA_Msk             (0x1UL << DWT_CTRL_CYCEVTENA_Pos)           /*!< DWT CTRL: CYCEVTENA Mask */
+
+#define DWT_CTRL_FOLDEVTENA_Pos            21U                                         /*!< DWT CTRL: FOLDEVTENA Position */
+#define DWT_CTRL_FOLDEVTENA_Msk            (0x1UL << DWT_CTRL_FOLDEVTENA_Pos)          /*!< DWT CTRL: FOLDEVTENA Mask */
+
+#define DWT_CTRL_LSUEVTENA_Pos             20U                                         /*!< DWT CTRL: LSUEVTENA Position */
+#define DWT_CTRL_LSUEVTENA_Msk             (0x1UL << DWT_CTRL_LSUEVTENA_Pos)           /*!< DWT CTRL: LSUEVTENA Mask */
+
+#define DWT_CTRL_SLEEPEVTENA_Pos           19U                                         /*!< DWT CTRL: SLEEPEVTENA Position */
+#define DWT_CTRL_SLEEPEVTENA_Msk           (0x1UL << DWT_CTRL_SLEEPEVTENA_Pos)         /*!< DWT CTRL: SLEEPEVTENA Mask */
+
+#define DWT_CTRL_EXCEVTENA_Pos             18U                                         /*!< DWT CTRL: EXCEVTENA Position */
+#define DWT_CTRL_EXCEVTENA_Msk             (0x1UL << DWT_CTRL_EXCEVTENA_Pos)           /*!< DWT CTRL: EXCEVTENA Mask */
+
+#define DWT_CTRL_CPIEVTENA_Pos             17U                                         /*!< DWT CTRL: CPIEVTENA Position */
+#define DWT_CTRL_CPIEVTENA_Msk             (0x1UL << DWT_CTRL_CPIEVTENA_Pos)           /*!< DWT CTRL: CPIEVTENA Mask */
+
+#define DWT_CTRL_EXCTRCENA_Pos             16U                                         /*!< DWT CTRL: EXCTRCENA Position */
+#define DWT_CTRL_EXCTRCENA_Msk             (0x1UL << DWT_CTRL_EXCTRCENA_Pos)           /*!< DWT CTRL: EXCTRCENA Mask */
+
+#define DWT_CTRL_PCSAMPLENA_Pos            12U                                         /*!< DWT CTRL: PCSAMPLENA Position */
+#define DWT_CTRL_PCSAMPLENA_Msk            (0x1UL << DWT_CTRL_PCSAMPLENA_Pos)          /*!< DWT CTRL: PCSAMPLENA Mask */
+
+#define DWT_CTRL_SYNCTAP_Pos               10U                                         /*!< DWT CTRL: SYNCTAP Position */
+#define DWT_CTRL_SYNCTAP_Msk               (0x3UL << DWT_CTRL_SYNCTAP_Pos)             /*!< DWT CTRL: SYNCTAP Mask */
+
+#define DWT_CTRL_CYCTAP_Pos                 9U                                         /*!< DWT CTRL: CYCTAP Position */
+#define DWT_CTRL_CYCTAP_Msk                (0x1UL << DWT_CTRL_CYCTAP_Pos)              /*!< DWT CTRL: CYCTAP Mask */
+
+#define DWT_CTRL_POSTINIT_Pos               5U                                         /*!< DWT CTRL: POSTINIT Position */
+#define DWT_CTRL_POSTINIT_Msk              (0xFUL << DWT_CTRL_POSTINIT_Pos)            /*!< DWT CTRL: POSTINIT Mask */
+
+#define DWT_CTRL_POSTPRESET_Pos             1U                                         /*!< DWT CTRL: POSTPRESET Position */
+#define DWT_CTRL_POSTPRESET_Msk            (0xFUL << DWT_CTRL_POSTPRESET_Pos)          /*!< DWT CTRL: POSTPRESET Mask */
+
+#define DWT_CTRL_CYCCNTENA_Pos              0U                                         /*!< DWT CTRL: CYCCNTENA Position */
+#define DWT_CTRL_CYCCNTENA_Msk             (0x1UL /*<< DWT_CTRL_CYCCNTENA_Pos*/)       /*!< DWT CTRL: CYCCNTENA Mask */
+
+/* DWT CPI Count Register Definitions */
+#define DWT_CPICNT_CPICNT_Pos               0U                                         /*!< DWT CPICNT: CPICNT Position */
+#define DWT_CPICNT_CPICNT_Msk              (0xFFUL /*<< DWT_CPICNT_CPICNT_Pos*/)       /*!< DWT CPICNT: CPICNT Mask */
+
+/* DWT Exception Overhead Count Register Definitions */
+#define DWT_EXCCNT_EXCCNT_Pos               0U                                         /*!< DWT EXCCNT: EXCCNT Position */
+#define DWT_EXCCNT_EXCCNT_Msk              (0xFFUL /*<< DWT_EXCCNT_EXCCNT_Pos*/)       /*!< DWT EXCCNT: EXCCNT Mask */
+
+/* DWT Sleep Count Register Definitions */
+#define DWT_SLEEPCNT_SLEEPCNT_Pos           0U                                         /*!< DWT SLEEPCNT: SLEEPCNT Position */
+#define DWT_SLEEPCNT_SLEEPCNT_Msk          (0xFFUL /*<< DWT_SLEEPCNT_SLEEPCNT_Pos*/)   /*!< DWT SLEEPCNT: SLEEPCNT Mask */
+
+/* DWT LSU Count Register Definitions */
+#define DWT_LSUCNT_LSUCNT_Pos               0U                                         /*!< DWT LSUCNT: LSUCNT Position */
+#define DWT_LSUCNT_LSUCNT_Msk              (0xFFUL /*<< DWT_LSUCNT_LSUCNT_Pos*/)       /*!< DWT LSUCNT: LSUCNT Mask */
+
+/* DWT Folded-instruction Count Register Definitions */
+#define DWT_FOLDCNT_FOLDCNT_Pos             0U                                         /*!< DWT FOLDCNT: FOLDCNT Position */
+#define DWT_FOLDCNT_FOLDCNT_Msk            (0xFFUL /*<< DWT_FOLDCNT_FOLDCNT_Pos*/)     /*!< DWT FOLDCNT: FOLDCNT Mask */
+
+/* DWT Comparator Function Register Definitions */
+#define DWT_FUNCTION_ID_Pos                27U                                         /*!< DWT FUNCTION: ID Position */
+#define DWT_FUNCTION_ID_Msk                (0x1FUL << DWT_FUNCTION_ID_Pos)             /*!< DWT FUNCTION: ID Mask */
+
+#define DWT_FUNCTION_MATCHED_Pos           24U                                         /*!< DWT FUNCTION: MATCHED Position */
+#define DWT_FUNCTION_MATCHED_Msk           (0x1UL << DWT_FUNCTION_MATCHED_Pos)         /*!< DWT FUNCTION: MATCHED Mask */
+
+#define DWT_FUNCTION_DATAVSIZE_Pos         10U                                         /*!< DWT FUNCTION: DATAVSIZE Position */
+#define DWT_FUNCTION_DATAVSIZE_Msk         (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos)       /*!< DWT FUNCTION: DATAVSIZE Mask */
+
+#define DWT_FUNCTION_ACTION_Pos             4U                                         /*!< DWT FUNCTION: ACTION Position */
+#define DWT_FUNCTION_ACTION_Msk            (0x1UL << DWT_FUNCTION_ACTION_Pos)          /*!< DWT FUNCTION: ACTION Mask */
+
+#define DWT_FUNCTION_MATCH_Pos              0U                                         /*!< DWT FUNCTION: MATCH Position */
+#define DWT_FUNCTION_MATCH_Msk             (0xFUL /*<< DWT_FUNCTION_MATCH_Pos*/)       /*!< DWT FUNCTION: MATCH Mask */
+
+/*@}*/ /* end of group CMSIS_DWT */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_TPI     Trace Port Interface (TPI)
+  \brief    Type definitions for the Trace Port Interface (TPI)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Trace Port Interface Register (TPI).
+ */
+typedef struct
+{
+  __IM  uint32_t SSPSR;                  /*!< Offset: 0x000 (R/ )  Supported Parallel Port Size Register */
+  __IOM uint32_t CSPSR;                  /*!< Offset: 0x004 (R/W)  Current Parallel Port Size Register */
+        uint32_t RESERVED0[2U];
+  __IOM uint32_t ACPR;                   /*!< Offset: 0x010 (R/W)  Asynchronous Clock Prescaler Register */
+        uint32_t RESERVED1[55U];
+  __IOM uint32_t SPPR;                   /*!< Offset: 0x0F0 (R/W)  Selected Pin Protocol Register */
+        uint32_t RESERVED2[131U];
+  __IM  uint32_t FFSR;                   /*!< Offset: 0x300 (R/ )  Formatter and Flush Status Register */
+  __IOM uint32_t FFCR;                   /*!< Offset: 0x304 (R/W)  Formatter and Flush Control Register */
+  __IOM uint32_t PSCR;                   /*!< Offset: 0x308 (R/W)  Periodic Synchronization Control Register */
+        uint32_t RESERVED3[759U];
+  __IM  uint32_t TRIGGER;                /*!< Offset: 0xEE8 (R/ )  TRIGGER Register */
+  __IM  uint32_t ITFTTD0;                /*!< Offset: 0xEEC (R/ )  Integration Test FIFO Test Data 0 Register */
+  __IOM uint32_t ITATBCTR2;              /*!< Offset: 0xEF0 (R/W)  Integration Test ATB Control Register 2 */
+        uint32_t RESERVED4[1U];
+  __IM  uint32_t ITATBCTR0;              /*!< Offset: 0xEF8 (R/ )  Integration Test ATB Control Register 0 */
+  __IM  uint32_t ITFTTD1;                /*!< Offset: 0xEFC (R/ )  Integration Test FIFO Test Data 1 Register */
+  __IOM uint32_t ITCTRL;                 /*!< Offset: 0xF00 (R/W)  Integration Mode Control */
+        uint32_t RESERVED5[39U];
+  __IOM uint32_t CLAIMSET;               /*!< Offset: 0xFA0 (R/W)  Claim tag set */
+  __IOM uint32_t CLAIMCLR;               /*!< Offset: 0xFA4 (R/W)  Claim tag clear */
+        uint32_t RESERVED7[8U];
+  __IM  uint32_t DEVID;                  /*!< Offset: 0xFC8 (R/ )  Device Configuration Register */
+  __IM  uint32_t DEVTYPE;                /*!< Offset: 0xFCC (R/ )  Device Type Identifier Register */
+} TPI_Type;
+
+/* TPI Asynchronous Clock Prescaler Register Definitions */
+#define TPI_ACPR_PRESCALER_Pos              0U                                         /*!< TPI ACPR: PRESCALER Position */
+#define TPI_ACPR_PRESCALER_Msk             (0x1FFFUL /*<< TPI_ACPR_PRESCALER_Pos*/)    /*!< TPI ACPR: PRESCALER Mask */
+
+/* TPI Selected Pin Protocol Register Definitions */
+#define TPI_SPPR_TXMODE_Pos                 0U                                         /*!< TPI SPPR: TXMODE Position */
+#define TPI_SPPR_TXMODE_Msk                (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/)          /*!< TPI SPPR: TXMODE Mask */
+
+/* TPI Formatter and Flush Status Register Definitions */
+#define TPI_FFSR_FtNonStop_Pos              3U                                         /*!< TPI FFSR: FtNonStop Position */
+#define TPI_FFSR_FtNonStop_Msk             (0x1UL << TPI_FFSR_FtNonStop_Pos)           /*!< TPI FFSR: FtNonStop Mask */
+
+#define TPI_FFSR_TCPresent_Pos              2U                                         /*!< TPI FFSR: TCPresent Position */
+#define TPI_FFSR_TCPresent_Msk             (0x1UL << TPI_FFSR_TCPresent_Pos)           /*!< TPI FFSR: TCPresent Mask */
+
+#define TPI_FFSR_FtStopped_Pos              1U                                         /*!< TPI FFSR: FtStopped Position */
+#define TPI_FFSR_FtStopped_Msk             (0x1UL << TPI_FFSR_FtStopped_Pos)           /*!< TPI FFSR: FtStopped Mask */
+
+#define TPI_FFSR_FlInProg_Pos               0U                                         /*!< TPI FFSR: FlInProg Position */
+#define TPI_FFSR_FlInProg_Msk              (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/)        /*!< TPI FFSR: FlInProg Mask */
+
+/* TPI Formatter and Flush Control Register Definitions */
+#define TPI_FFCR_TrigIn_Pos                 8U                                         /*!< TPI FFCR: TrigIn Position */
+#define TPI_FFCR_TrigIn_Msk                (0x1UL << TPI_FFCR_TrigIn_Pos)              /*!< TPI FFCR: TrigIn Mask */
+
+#define TPI_FFCR_FOnMan_Pos                 6U                                         /*!< TPI FFCR: FOnMan Position */
+#define TPI_FFCR_FOnMan_Msk                (0x1UL << TPI_FFCR_FOnMan_Pos)              /*!< TPI FFCR: FOnMan Mask */
+
+#define TPI_FFCR_EnFCont_Pos                1U                                         /*!< TPI FFCR: EnFCont Position */
+#define TPI_FFCR_EnFCont_Msk               (0x1UL << TPI_FFCR_EnFCont_Pos)             /*!< TPI FFCR: EnFCont Mask */
+
+/* TPI TRIGGER Register Definitions */
+#define TPI_TRIGGER_TRIGGER_Pos             0U                                         /*!< TPI TRIGGER: TRIGGER Position */
+#define TPI_TRIGGER_TRIGGER_Msk            (0x1UL /*<< TPI_TRIGGER_TRIGGER_Pos*/)      /*!< TPI TRIGGER: TRIGGER Mask */
+
+/* TPI Integration Test FIFO Test Data 0 Register Definitions */
+#define TPI_ITFTTD0_ATB_IF2_ATVALID_Pos    29U                                         /*!< TPI ITFTTD0: ATB Interface 2 ATVALIDPosition */
+#define TPI_ITFTTD0_ATB_IF2_ATVALID_Msk    (0x3UL << TPI_ITFTTD0_ATB_IF2_ATVALID_Pos)  /*!< TPI ITFTTD0: ATB Interface 2 ATVALID Mask */
+
+#define TPI_ITFTTD0_ATB_IF2_bytecount_Pos  27U                                         /*!< TPI ITFTTD0: ATB Interface 2 byte count Position */
+#define TPI_ITFTTD0_ATB_IF2_bytecount_Msk  (0x3UL << TPI_ITFTTD0_ATB_IF2_bytecount_Pos) /*!< TPI ITFTTD0: ATB Interface 2 byte count Mask */
+
+#define TPI_ITFTTD0_ATB_IF1_ATVALID_Pos    26U                                         /*!< TPI ITFTTD0: ATB Interface 1 ATVALID Position */
+#define TPI_ITFTTD0_ATB_IF1_ATVALID_Msk    (0x3UL << TPI_ITFTTD0_ATB_IF1_ATVALID_Pos)  /*!< TPI ITFTTD0: ATB Interface 1 ATVALID Mask */
+
+#define TPI_ITFTTD0_ATB_IF1_bytecount_Pos  24U                                         /*!< TPI ITFTTD0: ATB Interface 1 byte count Position */
+#define TPI_ITFTTD0_ATB_IF1_bytecount_Msk  (0x3UL << TPI_ITFTTD0_ATB_IF1_bytecount_Pos) /*!< TPI ITFTTD0: ATB Interface 1 byte countt Mask */
+
+#define TPI_ITFTTD0_ATB_IF1_data2_Pos      16U                                         /*!< TPI ITFTTD0: ATB Interface 1 data2 Position */
+#define TPI_ITFTTD0_ATB_IF1_data2_Msk      (0xFFUL << TPI_ITFTTD0_ATB_IF1_data1_Pos)   /*!< TPI ITFTTD0: ATB Interface 1 data2 Mask */
+
+#define TPI_ITFTTD0_ATB_IF1_data1_Pos       8U                                         /*!< TPI ITFTTD0: ATB Interface 1 data1 Position */
+#define TPI_ITFTTD0_ATB_IF1_data1_Msk      (0xFFUL << TPI_ITFTTD0_ATB_IF1_data1_Pos)   /*!< TPI ITFTTD0: ATB Interface 1 data1 Mask */
+
+#define TPI_ITFTTD0_ATB_IF1_data0_Pos       0U                                          /*!< TPI ITFTTD0: ATB Interface 1 data0 Position */
+#define TPI_ITFTTD0_ATB_IF1_data0_Msk      (0xFFUL /*<< TPI_ITFTTD0_ATB_IF1_data0_Pos*/) /*!< TPI ITFTTD0: ATB Interface 1 data0 Mask */
+
+/* TPI Integration Test ATB Control Register 2 Register Definitions */
+#define TPI_ITATBCTR2_AFVALID2S_Pos         1U                                         /*!< TPI ITATBCTR2: AFVALID2S Position */
+#define TPI_ITATBCTR2_AFVALID2S_Msk        (0x1UL << TPI_ITATBCTR2_AFVALID2S_Pos)      /*!< TPI ITATBCTR2: AFVALID2SS Mask */
+
+#define TPI_ITATBCTR2_AFVALID1S_Pos         1U                                         /*!< TPI ITATBCTR2: AFVALID1S Position */
+#define TPI_ITATBCTR2_AFVALID1S_Msk        (0x1UL << TPI_ITATBCTR2_AFVALID1S_Pos)      /*!< TPI ITATBCTR2: AFVALID1SS Mask */
+
+#define TPI_ITATBCTR2_ATREADY2S_Pos         0U                                         /*!< TPI ITATBCTR2: ATREADY2S Position */
+#define TPI_ITATBCTR2_ATREADY2S_Msk        (0x1UL /*<< TPI_ITATBCTR2_ATREADY2S_Pos*/)  /*!< TPI ITATBCTR2: ATREADY2S Mask */
+
+#define TPI_ITATBCTR2_ATREADY1S_Pos         0U                                         /*!< TPI ITATBCTR2: ATREADY1S Position */
+#define TPI_ITATBCTR2_ATREADY1S_Msk        (0x1UL /*<< TPI_ITATBCTR2_ATREADY1S_Pos*/)  /*!< TPI ITATBCTR2: ATREADY1S Mask */
+
+/* TPI Integration Test FIFO Test Data 1 Register Definitions */
+#define TPI_ITFTTD1_ATB_IF2_ATVALID_Pos    29U                                         /*!< TPI ITFTTD1: ATB Interface 2 ATVALID Position */
+#define TPI_ITFTTD1_ATB_IF2_ATVALID_Msk    (0x3UL << TPI_ITFTTD1_ATB_IF2_ATVALID_Pos)  /*!< TPI ITFTTD1: ATB Interface 2 ATVALID Mask */
+
+#define TPI_ITFTTD1_ATB_IF2_bytecount_Pos  27U                                         /*!< TPI ITFTTD1: ATB Interface 2 byte count Position */
+#define TPI_ITFTTD1_ATB_IF2_bytecount_Msk  (0x3UL << TPI_ITFTTD1_ATB_IF2_bytecount_Pos) /*!< TPI ITFTTD1: ATB Interface 2 byte count Mask */
+
+#define TPI_ITFTTD1_ATB_IF1_ATVALID_Pos    26U                                         /*!< TPI ITFTTD1: ATB Interface 1 ATVALID Position */
+#define TPI_ITFTTD1_ATB_IF1_ATVALID_Msk    (0x3UL << TPI_ITFTTD1_ATB_IF1_ATVALID_Pos)  /*!< TPI ITFTTD1: ATB Interface 1 ATVALID Mask */
+
+#define TPI_ITFTTD1_ATB_IF1_bytecount_Pos  24U                                         /*!< TPI ITFTTD1: ATB Interface 1 byte count Position */
+#define TPI_ITFTTD1_ATB_IF1_bytecount_Msk  (0x3UL << TPI_ITFTTD1_ATB_IF1_bytecount_Pos) /*!< TPI ITFTTD1: ATB Interface 1 byte countt Mask */
+
+#define TPI_ITFTTD1_ATB_IF2_data2_Pos      16U                                         /*!< TPI ITFTTD1: ATB Interface 2 data2 Position */
+#define TPI_ITFTTD1_ATB_IF2_data2_Msk      (0xFFUL << TPI_ITFTTD1_ATB_IF2_data1_Pos)   /*!< TPI ITFTTD1: ATB Interface 2 data2 Mask */
+
+#define TPI_ITFTTD1_ATB_IF2_data1_Pos       8U                                         /*!< TPI ITFTTD1: ATB Interface 2 data1 Position */
+#define TPI_ITFTTD1_ATB_IF2_data1_Msk      (0xFFUL << TPI_ITFTTD1_ATB_IF2_data1_Pos)   /*!< TPI ITFTTD1: ATB Interface 2 data1 Mask */
+
+#define TPI_ITFTTD1_ATB_IF2_data0_Pos       0U                                          /*!< TPI ITFTTD1: ATB Interface 2 data0 Position */
+#define TPI_ITFTTD1_ATB_IF2_data0_Msk      (0xFFUL /*<< TPI_ITFTTD1_ATB_IF2_data0_Pos*/) /*!< TPI ITFTTD1: ATB Interface 2 data0 Mask */
+
+/* TPI Integration Test ATB Control Register 0 Definitions */
+#define TPI_ITATBCTR0_AFVALID2S_Pos         1U                                         /*!< TPI ITATBCTR0: AFVALID2S Position */
+#define TPI_ITATBCTR0_AFVALID2S_Msk        (0x1UL << TPI_ITATBCTR0_AFVALID2S_Pos)      /*!< TPI ITATBCTR0: AFVALID2SS Mask */
+
+#define TPI_ITATBCTR0_AFVALID1S_Pos         1U                                         /*!< TPI ITATBCTR0: AFVALID1S Position */
+#define TPI_ITATBCTR0_AFVALID1S_Msk        (0x1UL << TPI_ITATBCTR0_AFVALID1S_Pos)      /*!< TPI ITATBCTR0: AFVALID1SS Mask */
+
+#define TPI_ITATBCTR0_ATREADY2S_Pos         0U                                         /*!< TPI ITATBCTR0: ATREADY2S Position */
+#define TPI_ITATBCTR0_ATREADY2S_Msk        (0x1UL /*<< TPI_ITATBCTR0_ATREADY2S_Pos*/)  /*!< TPI ITATBCTR0: ATREADY2S Mask */
+
+#define TPI_ITATBCTR0_ATREADY1S_Pos         0U                                         /*!< TPI ITATBCTR0: ATREADY1S Position */
+#define TPI_ITATBCTR0_ATREADY1S_Msk        (0x1UL /*<< TPI_ITATBCTR0_ATREADY1S_Pos*/)  /*!< TPI ITATBCTR0: ATREADY1S Mask */
+
+/* TPI Integration Mode Control Register Definitions */
+#define TPI_ITCTRL_Mode_Pos                 0U                                         /*!< TPI ITCTRL: Mode Position */
+#define TPI_ITCTRL_Mode_Msk                (0x3UL /*<< TPI_ITCTRL_Mode_Pos*/)          /*!< TPI ITCTRL: Mode Mask */
+
+/* TPI DEVID Register Definitions */
+#define TPI_DEVID_NRZVALID_Pos             11U                                         /*!< TPI DEVID: NRZVALID Position */
+#define TPI_DEVID_NRZVALID_Msk             (0x1UL << TPI_DEVID_NRZVALID_Pos)           /*!< TPI DEVID: NRZVALID Mask */
+
+#define TPI_DEVID_MANCVALID_Pos            10U                                         /*!< TPI DEVID: MANCVALID Position */
+#define TPI_DEVID_MANCVALID_Msk            (0x1UL << TPI_DEVID_MANCVALID_Pos)          /*!< TPI DEVID: MANCVALID Mask */
+
+#define TPI_DEVID_PTINVALID_Pos             9U                                         /*!< TPI DEVID: PTINVALID Position */
+#define TPI_DEVID_PTINVALID_Msk            (0x1UL << TPI_DEVID_PTINVALID_Pos)          /*!< TPI DEVID: PTINVALID Mask */
+
+#define TPI_DEVID_FIFOSZ_Pos                6U                                         /*!< TPI DEVID: FIFOSZ Position */
+#define TPI_DEVID_FIFOSZ_Msk               (0x7UL << TPI_DEVID_FIFOSZ_Pos)             /*!< TPI DEVID: FIFOSZ Mask */
+
+#define TPI_DEVID_NrTraceInput_Pos          0U                                         /*!< TPI DEVID: NrTraceInput Position */
+#define TPI_DEVID_NrTraceInput_Msk         (0x3FUL /*<< TPI_DEVID_NrTraceInput_Pos*/)  /*!< TPI DEVID: NrTraceInput Mask */
+
+/* TPI DEVTYPE Register Definitions */
+#define TPI_DEVTYPE_SubType_Pos             4U                                         /*!< TPI DEVTYPE: SubType Position */
+#define TPI_DEVTYPE_SubType_Msk            (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/)      /*!< TPI DEVTYPE: SubType Mask */
+
+#define TPI_DEVTYPE_MajorType_Pos           0U                                         /*!< TPI DEVTYPE: MajorType Position */
+#define TPI_DEVTYPE_MajorType_Msk          (0xFUL << TPI_DEVTYPE_MajorType_Pos)        /*!< TPI DEVTYPE: MajorType Mask */
+
+/*@}*/ /* end of group CMSIS_TPI */
+
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_MPU     Memory Protection Unit (MPU)
+  \brief    Type definitions for the Memory Protection Unit (MPU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Memory Protection Unit (MPU).
+ */
+typedef struct
+{
+  __IM  uint32_t TYPE;                   /*!< Offset: 0x000 (R/ )  MPU Type Register */
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x004 (R/W)  MPU Control Register */
+  __IOM uint32_t RNR;                    /*!< Offset: 0x008 (R/W)  MPU Region Number Register */
+  __IOM uint32_t RBAR;                   /*!< Offset: 0x00C (R/W)  MPU Region Base Address Register */
+  __IOM uint32_t RLAR;                   /*!< Offset: 0x010 (R/W)  MPU Region Limit Address Register */
+  __IOM uint32_t RBAR_A1;                /*!< Offset: 0x014 (R/W)  MPU Region Base Address Register Alias 1 */
+  __IOM uint32_t RLAR_A1;                /*!< Offset: 0x018 (R/W)  MPU Region Limit Address Register Alias 1 */
+  __IOM uint32_t RBAR_A2;                /*!< Offset: 0x01C (R/W)  MPU Region Base Address Register Alias 2 */
+  __IOM uint32_t RLAR_A2;                /*!< Offset: 0x020 (R/W)  MPU Region Limit Address Register Alias 2 */
+  __IOM uint32_t RBAR_A3;                /*!< Offset: 0x024 (R/W)  MPU Region Base Address Register Alias 3 */
+  __IOM uint32_t RLAR_A3;                /*!< Offset: 0x028 (R/W)  MPU Region Limit Address Register Alias 3 */
+        uint32_t RESERVED0[1];
+  union {
+  __IOM uint32_t MAIR[2];
+  struct {
+  __IOM uint32_t MAIR0;                  /*!< Offset: 0x030 (R/W)  MPU Memory Attribute Indirection Register 0 */
+  __IOM uint32_t MAIR1;                  /*!< Offset: 0x034 (R/W)  MPU Memory Attribute Indirection Register 1 */
+  };
+  };
+} MPU_Type;
+
+#define MPU_TYPE_RALIASES                  4U
+
+/* MPU Type Register Definitions */
+#define MPU_TYPE_IREGION_Pos               16U                                            /*!< MPU TYPE: IREGION Position */
+#define MPU_TYPE_IREGION_Msk               (0xFFUL << MPU_TYPE_IREGION_Pos)               /*!< MPU TYPE: IREGION Mask */
+
+#define MPU_TYPE_DREGION_Pos                8U                                            /*!< MPU TYPE: DREGION Position */
+#define MPU_TYPE_DREGION_Msk               (0xFFUL << MPU_TYPE_DREGION_Pos)               /*!< MPU TYPE: DREGION Mask */
+
+#define MPU_TYPE_SEPARATE_Pos               0U                                            /*!< MPU TYPE: SEPARATE Position */
+#define MPU_TYPE_SEPARATE_Msk              (1UL /*<< MPU_TYPE_SEPARATE_Pos*/)             /*!< MPU TYPE: SEPARATE Mask */
+
+/* MPU Control Register Definitions */
+#define MPU_CTRL_PRIVDEFENA_Pos             2U                                            /*!< MPU CTRL: PRIVDEFENA Position */
+#define MPU_CTRL_PRIVDEFENA_Msk            (1UL << MPU_CTRL_PRIVDEFENA_Pos)               /*!< MPU CTRL: PRIVDEFENA Mask */
+
+#define MPU_CTRL_HFNMIENA_Pos               1U                                            /*!< MPU CTRL: HFNMIENA Position */
+#define MPU_CTRL_HFNMIENA_Msk              (1UL << MPU_CTRL_HFNMIENA_Pos)                 /*!< MPU CTRL: HFNMIENA Mask */
+
+#define MPU_CTRL_ENABLE_Pos                 0U                                            /*!< MPU CTRL: ENABLE Position */
+#define MPU_CTRL_ENABLE_Msk                (1UL /*<< MPU_CTRL_ENABLE_Pos*/)               /*!< MPU CTRL: ENABLE Mask */
+
+/* MPU Region Number Register Definitions */
+#define MPU_RNR_REGION_Pos                  0U                                            /*!< MPU RNR: REGION Position */
+#define MPU_RNR_REGION_Msk                 (0xFFUL /*<< MPU_RNR_REGION_Pos*/)             /*!< MPU RNR: REGION Mask */
+
+/* MPU Region Base Address Register Definitions */
+#define MPU_RBAR_BASE_Pos                   5U                                            /*!< MPU RBAR: BASE Position */
+#define MPU_RBAR_BASE_Msk                  (0x7FFFFFFUL << MPU_RBAR_BASE_Pos)             /*!< MPU RBAR: BASE Mask */
+
+#define MPU_RBAR_SH_Pos                     3U                                            /*!< MPU RBAR: SH Position */
+#define MPU_RBAR_SH_Msk                    (0x3UL << MPU_RBAR_SH_Pos)                     /*!< MPU RBAR: SH Mask */
+
+#define MPU_RBAR_AP_Pos                     1U                                            /*!< MPU RBAR: AP Position */
+#define MPU_RBAR_AP_Msk                    (0x3UL << MPU_RBAR_AP_Pos)                     /*!< MPU RBAR: AP Mask */
+
+#define MPU_RBAR_XN_Pos                     0U                                            /*!< MPU RBAR: XN Position */
+#define MPU_RBAR_XN_Msk                    (01UL /*<< MPU_RBAR_XN_Pos*/)                  /*!< MPU RBAR: XN Mask */
+
+/* MPU Region Limit Address Register Definitions */
+#define MPU_RLAR_LIMIT_Pos                  5U                                            /*!< MPU RLAR: LIMIT Position */
+#define MPU_RLAR_LIMIT_Msk                 (0x7FFFFFFUL << MPU_RLAR_LIMIT_Pos)            /*!< MPU RLAR: LIMIT Mask */
+
+#define MPU_RLAR_AttrIndx_Pos               1U                                            /*!< MPU RLAR: AttrIndx Position */
+#define MPU_RLAR_AttrIndx_Msk              (0x7UL << MPU_RLAR_AttrIndx_Pos)               /*!< MPU RLAR: AttrIndx Mask */
+
+#define MPU_RLAR_EN_Pos                     0U                                            /*!< MPU RLAR: Region enable bit Position */
+#define MPU_RLAR_EN_Msk                    (1UL /*<< MPU_RLAR_EN_Pos*/)                   /*!< MPU RLAR: Region enable bit Disable Mask */
+
+/* MPU Memory Attribute Indirection Register 0 Definitions */
+#define MPU_MAIR0_Attr3_Pos                24U                                            /*!< MPU MAIR0: Attr3 Position */
+#define MPU_MAIR0_Attr3_Msk                (0xFFUL << MPU_MAIR0_Attr3_Pos)                /*!< MPU MAIR0: Attr3 Mask */
+
+#define MPU_MAIR0_Attr2_Pos                16U                                            /*!< MPU MAIR0: Attr2 Position */
+#define MPU_MAIR0_Attr2_Msk                (0xFFUL << MPU_MAIR0_Attr2_Pos)                /*!< MPU MAIR0: Attr2 Mask */
+
+#define MPU_MAIR0_Attr1_Pos                 8U                                            /*!< MPU MAIR0: Attr1 Position */
+#define MPU_MAIR0_Attr1_Msk                (0xFFUL << MPU_MAIR0_Attr1_Pos)                /*!< MPU MAIR0: Attr1 Mask */
+
+#define MPU_MAIR0_Attr0_Pos                 0U                                            /*!< MPU MAIR0: Attr0 Position */
+#define MPU_MAIR0_Attr0_Msk                (0xFFUL /*<< MPU_MAIR0_Attr0_Pos*/)            /*!< MPU MAIR0: Attr0 Mask */
+
+/* MPU Memory Attribute Indirection Register 1 Definitions */
+#define MPU_MAIR1_Attr7_Pos                24U                                            /*!< MPU MAIR1: Attr7 Position */
+#define MPU_MAIR1_Attr7_Msk                (0xFFUL << MPU_MAIR1_Attr7_Pos)                /*!< MPU MAIR1: Attr7 Mask */
+
+#define MPU_MAIR1_Attr6_Pos                16U                                            /*!< MPU MAIR1: Attr6 Position */
+#define MPU_MAIR1_Attr6_Msk                (0xFFUL << MPU_MAIR1_Attr6_Pos)                /*!< MPU MAIR1: Attr6 Mask */
+
+#define MPU_MAIR1_Attr5_Pos                 8U                                            /*!< MPU MAIR1: Attr5 Position */
+#define MPU_MAIR1_Attr5_Msk                (0xFFUL << MPU_MAIR1_Attr5_Pos)                /*!< MPU MAIR1: Attr5 Mask */
+
+#define MPU_MAIR1_Attr4_Pos                 0U                                            /*!< MPU MAIR1: Attr4 Position */
+#define MPU_MAIR1_Attr4_Msk                (0xFFUL /*<< MPU_MAIR1_Attr4_Pos*/)            /*!< MPU MAIR1: Attr4 Mask */
+
+/*@} end of group CMSIS_MPU */
+#endif
+
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SAU     Security Attribution Unit (SAU)
+  \brief    Type definitions for the Security Attribution Unit (SAU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Security Attribution Unit (SAU).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  SAU Control Register */
+  __IM  uint32_t TYPE;                   /*!< Offset: 0x004 (R/ )  SAU Type Register */
+#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U)
+  __IOM uint32_t RNR;                    /*!< Offset: 0x008 (R/W)  SAU Region Number Register */
+  __IOM uint32_t RBAR;                   /*!< Offset: 0x00C (R/W)  SAU Region Base Address Register */
+  __IOM uint32_t RLAR;                   /*!< Offset: 0x010 (R/W)  SAU Region Limit Address Register */
+#else
+        uint32_t RESERVED0[3];
+#endif
+  __IOM uint32_t SFSR;                   /*!< Offset: 0x014 (R/W)  Secure Fault Status Register */
+  __IOM uint32_t SFAR;                   /*!< Offset: 0x018 (R/W)  Secure Fault Address Register */
+} SAU_Type;
+
+/* SAU Control Register Definitions */
+#define SAU_CTRL_ALLNS_Pos                  1U                                            /*!< SAU CTRL: ALLNS Position */
+#define SAU_CTRL_ALLNS_Msk                 (1UL << SAU_CTRL_ALLNS_Pos)                    /*!< SAU CTRL: ALLNS Mask */
+
+#define SAU_CTRL_ENABLE_Pos                 0U                                            /*!< SAU CTRL: ENABLE Position */
+#define SAU_CTRL_ENABLE_Msk                (1UL /*<< SAU_CTRL_ENABLE_Pos*/)               /*!< SAU CTRL: ENABLE Mask */
+
+/* SAU Type Register Definitions */
+#define SAU_TYPE_SREGION_Pos                0U                                            /*!< SAU TYPE: SREGION Position */
+#define SAU_TYPE_SREGION_Msk               (0xFFUL /*<< SAU_TYPE_SREGION_Pos*/)           /*!< SAU TYPE: SREGION Mask */
+
+#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U)
+/* SAU Region Number Register Definitions */
+#define SAU_RNR_REGION_Pos                  0U                                            /*!< SAU RNR: REGION Position */
+#define SAU_RNR_REGION_Msk                 (0xFFUL /*<< SAU_RNR_REGION_Pos*/)             /*!< SAU RNR: REGION Mask */
+
+/* SAU Region Base Address Register Definitions */
+#define SAU_RBAR_BADDR_Pos                  5U                                            /*!< SAU RBAR: BADDR Position */
+#define SAU_RBAR_BADDR_Msk                 (0x7FFFFFFUL << SAU_RBAR_BADDR_Pos)            /*!< SAU RBAR: BADDR Mask */
+
+/* SAU Region Limit Address Register Definitions */
+#define SAU_RLAR_LADDR_Pos                  5U                                            /*!< SAU RLAR: LADDR Position */
+#define SAU_RLAR_LADDR_Msk                 (0x7FFFFFFUL << SAU_RLAR_LADDR_Pos)            /*!< SAU RLAR: LADDR Mask */
+
+#define SAU_RLAR_NSC_Pos                    1U                                            /*!< SAU RLAR: NSC Position */
+#define SAU_RLAR_NSC_Msk                   (1UL << SAU_RLAR_NSC_Pos)                      /*!< SAU RLAR: NSC Mask */
+
+#define SAU_RLAR_ENABLE_Pos                 0U                                            /*!< SAU RLAR: ENABLE Position */
+#define SAU_RLAR_ENABLE_Msk                (1UL /*<< SAU_RLAR_ENABLE_Pos*/)               /*!< SAU RLAR: ENABLE Mask */
+
+#endif /* defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) */
+
+/* Secure Fault Status Register Definitions */
+#define SAU_SFSR_LSERR_Pos                  7U                                            /*!< SAU SFSR: LSERR Position */
+#define SAU_SFSR_LSERR_Msk                 (1UL << SAU_SFSR_LSERR_Pos)                    /*!< SAU SFSR: LSERR Mask */
+
+#define SAU_SFSR_SFARVALID_Pos              6U                                            /*!< SAU SFSR: SFARVALID Position */
+#define SAU_SFSR_SFARVALID_Msk             (1UL << SAU_SFSR_SFARVALID_Pos)                /*!< SAU SFSR: SFARVALID Mask */
+
+#define SAU_SFSR_LSPERR_Pos                 5U                                            /*!< SAU SFSR: LSPERR Position */
+#define SAU_SFSR_LSPERR_Msk                (1UL << SAU_SFSR_LSPERR_Pos)                   /*!< SAU SFSR: LSPERR Mask */
+
+#define SAU_SFSR_INVTRAN_Pos                4U                                            /*!< SAU SFSR: INVTRAN Position */
+#define SAU_SFSR_INVTRAN_Msk               (1UL << SAU_SFSR_INVTRAN_Pos)                  /*!< SAU SFSR: INVTRAN Mask */
+
+#define SAU_SFSR_AUVIOL_Pos                 3U                                            /*!< SAU SFSR: AUVIOL Position */
+#define SAU_SFSR_AUVIOL_Msk                (1UL << SAU_SFSR_AUVIOL_Pos)                   /*!< SAU SFSR: AUVIOL Mask */
+
+#define SAU_SFSR_INVER_Pos                  2U                                            /*!< SAU SFSR: INVER Position */
+#define SAU_SFSR_INVER_Msk                 (1UL << SAU_SFSR_INVER_Pos)                    /*!< SAU SFSR: INVER Mask */
+
+#define SAU_SFSR_INVIS_Pos                  1U                                            /*!< SAU SFSR: INVIS Position */
+#define SAU_SFSR_INVIS_Msk                 (1UL << SAU_SFSR_INVIS_Pos)                    /*!< SAU SFSR: INVIS Mask */
+
+#define SAU_SFSR_INVEP_Pos                  0U                                            /*!< SAU SFSR: INVEP Position */
+#define SAU_SFSR_INVEP_Msk                 (1UL /*<< SAU_SFSR_INVEP_Pos*/)                /*!< SAU SFSR: INVEP Mask */
+
+/*@} end of group CMSIS_SAU */
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_FPU     Floating Point Unit (FPU)
+  \brief    Type definitions for the Floating Point Unit (FPU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Floating Point Unit (FPU).
+ */
+typedef struct
+{
+        uint32_t RESERVED0[1U];
+  __IOM uint32_t FPCCR;                  /*!< Offset: 0x004 (R/W)  Floating-Point Context Control Register */
+  __IOM uint32_t FPCAR;                  /*!< Offset: 0x008 (R/W)  Floating-Point Context Address Register */
+  __IOM uint32_t FPDSCR;                 /*!< Offset: 0x00C (R/W)  Floating-Point Default Status Control Register */
+  __IM  uint32_t MVFR0;                  /*!< Offset: 0x010 (R/ )  Media and FP Feature Register 0 */
+  __IM  uint32_t MVFR1;                  /*!< Offset: 0x014 (R/ )  Media and FP Feature Register 1 */
+} FPU_Type;
+
+/* Floating-Point Context Control Register Definitions */
+#define FPU_FPCCR_ASPEN_Pos                31U                                            /*!< FPCCR: ASPEN bit Position */
+#define FPU_FPCCR_ASPEN_Msk                (1UL << FPU_FPCCR_ASPEN_Pos)                   /*!< FPCCR: ASPEN bit Mask */
+
+#define FPU_FPCCR_LSPEN_Pos                30U                                            /*!< FPCCR: LSPEN Position */
+#define FPU_FPCCR_LSPEN_Msk                (1UL << FPU_FPCCR_LSPEN_Pos)                   /*!< FPCCR: LSPEN bit Mask */
+
+#define FPU_FPCCR_LSPENS_Pos               29U                                            /*!< FPCCR: LSPENS Position */
+#define FPU_FPCCR_LSPENS_Msk               (1UL << FPU_FPCCR_LSPENS_Pos)                  /*!< FPCCR: LSPENS bit Mask */
+
+#define FPU_FPCCR_CLRONRET_Pos             28U                                            /*!< FPCCR: CLRONRET Position */
+#define FPU_FPCCR_CLRONRET_Msk             (1UL << FPU_FPCCR_CLRONRET_Pos)                /*!< FPCCR: CLRONRET bit Mask */
+
+#define FPU_FPCCR_CLRONRETS_Pos            27U                                            /*!< FPCCR: CLRONRETS Position */
+#define FPU_FPCCR_CLRONRETS_Msk            (1UL << FPU_FPCCR_CLRONRETS_Pos)               /*!< FPCCR: CLRONRETS bit Mask */
+
+#define FPU_FPCCR_TS_Pos                   26U                                            /*!< FPCCR: TS Position */
+#define FPU_FPCCR_TS_Msk                   (1UL << FPU_FPCCR_TS_Pos)                      /*!< FPCCR: TS bit Mask */
+
+#define FPU_FPCCR_UFRDY_Pos                10U                                            /*!< FPCCR: UFRDY Position */
+#define FPU_FPCCR_UFRDY_Msk                (1UL << FPU_FPCCR_UFRDY_Pos)                   /*!< FPCCR: UFRDY bit Mask */
+
+#define FPU_FPCCR_SPLIMVIOL_Pos             9U                                            /*!< FPCCR: SPLIMVIOL Position */
+#define FPU_FPCCR_SPLIMVIOL_Msk            (1UL << FPU_FPCCR_SPLIMVIOL_Pos)               /*!< FPCCR: SPLIMVIOL bit Mask */
+
+#define FPU_FPCCR_MONRDY_Pos                8U                                            /*!< FPCCR: MONRDY Position */
+#define FPU_FPCCR_MONRDY_Msk               (1UL << FPU_FPCCR_MONRDY_Pos)                  /*!< FPCCR: MONRDY bit Mask */
+
+#define FPU_FPCCR_SFRDY_Pos                 7U                                            /*!< FPCCR: SFRDY Position */
+#define FPU_FPCCR_SFRDY_Msk                (1UL << FPU_FPCCR_SFRDY_Pos)                   /*!< FPCCR: SFRDY bit Mask */
+
+#define FPU_FPCCR_BFRDY_Pos                 6U                                            /*!< FPCCR: BFRDY Position */
+#define FPU_FPCCR_BFRDY_Msk                (1UL << FPU_FPCCR_BFRDY_Pos)                   /*!< FPCCR: BFRDY bit Mask */
+
+#define FPU_FPCCR_MMRDY_Pos                 5U                                            /*!< FPCCR: MMRDY Position */
+#define FPU_FPCCR_MMRDY_Msk                (1UL << FPU_FPCCR_MMRDY_Pos)                   /*!< FPCCR: MMRDY bit Mask */
+
+#define FPU_FPCCR_HFRDY_Pos                 4U                                            /*!< FPCCR: HFRDY Position */
+#define FPU_FPCCR_HFRDY_Msk                (1UL << FPU_FPCCR_HFRDY_Pos)                   /*!< FPCCR: HFRDY bit Mask */
+
+#define FPU_FPCCR_THREAD_Pos                3U                                            /*!< FPCCR: processor mode bit Position */
+#define FPU_FPCCR_THREAD_Msk               (1UL << FPU_FPCCR_THREAD_Pos)                  /*!< FPCCR: processor mode active bit Mask */
+
+#define FPU_FPCCR_S_Pos                     2U                                            /*!< FPCCR: Security status of the FP context bit Position */
+#define FPU_FPCCR_S_Msk                    (1UL << FPU_FPCCR_S_Pos)                       /*!< FPCCR: Security status of the FP context bit Mask */
+
+#define FPU_FPCCR_USER_Pos                  1U                                            /*!< FPCCR: privilege level bit Position */
+#define FPU_FPCCR_USER_Msk                 (1UL << FPU_FPCCR_USER_Pos)                    /*!< FPCCR: privilege level bit Mask */
+
+#define FPU_FPCCR_LSPACT_Pos                0U                                            /*!< FPCCR: Lazy state preservation active bit Position */
+#define FPU_FPCCR_LSPACT_Msk               (1UL /*<< FPU_FPCCR_LSPACT_Pos*/)              /*!< FPCCR: Lazy state preservation active bit Mask */
+
+/* Floating-Point Context Address Register Definitions */
+#define FPU_FPCAR_ADDRESS_Pos               3U                                            /*!< FPCAR: ADDRESS bit Position */
+#define FPU_FPCAR_ADDRESS_Msk              (0x1FFFFFFFUL << FPU_FPCAR_ADDRESS_Pos)        /*!< FPCAR: ADDRESS bit Mask */
+
+/* Floating-Point Default Status Control Register Definitions */
+#define FPU_FPDSCR_AHP_Pos                 26U                                            /*!< FPDSCR: AHP bit Position */
+#define FPU_FPDSCR_AHP_Msk                 (1UL << FPU_FPDSCR_AHP_Pos)                    /*!< FPDSCR: AHP bit Mask */
+
+#define FPU_FPDSCR_DN_Pos                  25U                                            /*!< FPDSCR: DN bit Position */
+#define FPU_FPDSCR_DN_Msk                  (1UL << FPU_FPDSCR_DN_Pos)                     /*!< FPDSCR: DN bit Mask */
+
+#define FPU_FPDSCR_FZ_Pos                  24U                                            /*!< FPDSCR: FZ bit Position */
+#define FPU_FPDSCR_FZ_Msk                  (1UL << FPU_FPDSCR_FZ_Pos)                     /*!< FPDSCR: FZ bit Mask */
+
+#define FPU_FPDSCR_RMode_Pos               22U                                            /*!< FPDSCR: RMode bit Position */
+#define FPU_FPDSCR_RMode_Msk               (3UL << FPU_FPDSCR_RMode_Pos)                  /*!< FPDSCR: RMode bit Mask */
+
+/* Media and FP Feature Register 0 Definitions */
+#define FPU_MVFR0_FP_rounding_modes_Pos    28U                                            /*!< MVFR0: FP rounding modes bits Position */
+#define FPU_MVFR0_FP_rounding_modes_Msk    (0xFUL << FPU_MVFR0_FP_rounding_modes_Pos)     /*!< MVFR0: FP rounding modes bits Mask */
+
+#define FPU_MVFR0_Short_vectors_Pos        24U                                            /*!< MVFR0: Short vectors bits Position */
+#define FPU_MVFR0_Short_vectors_Msk        (0xFUL << FPU_MVFR0_Short_vectors_Pos)         /*!< MVFR0: Short vectors bits Mask */
+
+#define FPU_MVFR0_Square_root_Pos          20U                                            /*!< MVFR0: Square root bits Position */
+#define FPU_MVFR0_Square_root_Msk          (0xFUL << FPU_MVFR0_Square_root_Pos)           /*!< MVFR0: Square root bits Mask */
+
+#define FPU_MVFR0_Divide_Pos               16U                                            /*!< MVFR0: Divide bits Position */
+#define FPU_MVFR0_Divide_Msk               (0xFUL << FPU_MVFR0_Divide_Pos)                /*!< MVFR0: Divide bits Mask */
+
+#define FPU_MVFR0_FP_excep_trapping_Pos    12U                                            /*!< MVFR0: FP exception trapping bits Position */
+#define FPU_MVFR0_FP_excep_trapping_Msk    (0xFUL << FPU_MVFR0_FP_excep_trapping_Pos)     /*!< MVFR0: FP exception trapping bits Mask */
+
+#define FPU_MVFR0_Double_precision_Pos      8U                                            /*!< MVFR0: Double-precision bits Position */
+#define FPU_MVFR0_Double_precision_Msk     (0xFUL << FPU_MVFR0_Double_precision_Pos)      /*!< MVFR0: Double-precision bits Mask */
+
+#define FPU_MVFR0_Single_precision_Pos      4U                                            /*!< MVFR0: Single-precision bits Position */
+#define FPU_MVFR0_Single_precision_Msk     (0xFUL << FPU_MVFR0_Single_precision_Pos)      /*!< MVFR0: Single-precision bits Mask */
+
+#define FPU_MVFR0_A_SIMD_registers_Pos      0U                                            /*!< MVFR0: A_SIMD registers bits Position */
+#define FPU_MVFR0_A_SIMD_registers_Msk     (0xFUL /*<< FPU_MVFR0_A_SIMD_registers_Pos*/)  /*!< MVFR0: A_SIMD registers bits Mask */
+
+/* Media and FP Feature Register 1 Definitions */
+#define FPU_MVFR1_FP_fused_MAC_Pos         28U                                            /*!< MVFR1: FP fused MAC bits Position */
+#define FPU_MVFR1_FP_fused_MAC_Msk         (0xFUL << FPU_MVFR1_FP_fused_MAC_Pos)          /*!< MVFR1: FP fused MAC bits Mask */
+
+#define FPU_MVFR1_FP_HPFP_Pos              24U                                            /*!< MVFR1: FP HPFP bits Position */
+#define FPU_MVFR1_FP_HPFP_Msk              (0xFUL << FPU_MVFR1_FP_HPFP_Pos)               /*!< MVFR1: FP HPFP bits Mask */
+
+#define FPU_MVFR1_D_NaN_mode_Pos            4U                                            /*!< MVFR1: D_NaN mode bits Position */
+#define FPU_MVFR1_D_NaN_mode_Msk           (0xFUL << FPU_MVFR1_D_NaN_mode_Pos)            /*!< MVFR1: D_NaN mode bits Mask */
+
+#define FPU_MVFR1_FtZ_mode_Pos              0U                                            /*!< MVFR1: FtZ mode bits Position */
+#define FPU_MVFR1_FtZ_mode_Msk             (0xFUL /*<< FPU_MVFR1_FtZ_mode_Pos*/)          /*!< MVFR1: FtZ mode bits Mask */
+
+/*@} end of group CMSIS_FPU */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_CoreDebug       Core Debug Registers (CoreDebug)
+  \brief    Type definitions for the Core Debug Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Core Debug Register (CoreDebug).
+ */
+typedef struct
+{
+  __IOM uint32_t DHCSR;                  /*!< Offset: 0x000 (R/W)  Debug Halting Control and Status Register */
+  __OM  uint32_t DCRSR;                  /*!< Offset: 0x004 ( /W)  Debug Core Register Selector Register */
+  __IOM uint32_t DCRDR;                  /*!< Offset: 0x008 (R/W)  Debug Core Register Data Register */
+  __IOM uint32_t DEMCR;                  /*!< Offset: 0x00C (R/W)  Debug Exception and Monitor Control Register */
+        uint32_t RESERVED4[1U];
+  __IOM uint32_t DAUTHCTRL;              /*!< Offset: 0x014 (R/W)  Debug Authentication Control Register */
+  __IOM uint32_t DSCSR;                  /*!< Offset: 0x018 (R/W)  Debug Security Control and Status Register */
+} CoreDebug_Type;
+
+/* Debug Halting Control and Status Register Definitions */
+#define CoreDebug_DHCSR_DBGKEY_Pos         16U                                            /*!< CoreDebug DHCSR: DBGKEY Position */
+#define CoreDebug_DHCSR_DBGKEY_Msk         (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos)       /*!< CoreDebug DHCSR: DBGKEY Mask */
+
+#define CoreDebug_DHCSR_S_RESTART_ST_Pos   26U                                            /*!< CoreDebug DHCSR: S_RESTART_ST Position */
+#define CoreDebug_DHCSR_S_RESTART_ST_Msk   (1UL << CoreDebug_DHCSR_S_RESTART_ST_Pos)      /*!< CoreDebug DHCSR: S_RESTART_ST Mask */
+
+#define CoreDebug_DHCSR_S_RESET_ST_Pos     25U                                            /*!< CoreDebug DHCSR: S_RESET_ST Position */
+#define CoreDebug_DHCSR_S_RESET_ST_Msk     (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos)        /*!< CoreDebug DHCSR: S_RESET_ST Mask */
+
+#define CoreDebug_DHCSR_S_RETIRE_ST_Pos    24U                                            /*!< CoreDebug DHCSR: S_RETIRE_ST Position */
+#define CoreDebug_DHCSR_S_RETIRE_ST_Msk    (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos)       /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */
+
+#define CoreDebug_DHCSR_S_LOCKUP_Pos       19U                                            /*!< CoreDebug DHCSR: S_LOCKUP Position */
+#define CoreDebug_DHCSR_S_LOCKUP_Msk       (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos)          /*!< CoreDebug DHCSR: S_LOCKUP Mask */
+
+#define CoreDebug_DHCSR_S_SLEEP_Pos        18U                                            /*!< CoreDebug DHCSR: S_SLEEP Position */
+#define CoreDebug_DHCSR_S_SLEEP_Msk        (1UL << CoreDebug_DHCSR_S_SLEEP_Pos)           /*!< CoreDebug DHCSR: S_SLEEP Mask */
+
+#define CoreDebug_DHCSR_S_HALT_Pos         17U                                            /*!< CoreDebug DHCSR: S_HALT Position */
+#define CoreDebug_DHCSR_S_HALT_Msk         (1UL << CoreDebug_DHCSR_S_HALT_Pos)            /*!< CoreDebug DHCSR: S_HALT Mask */
+
+#define CoreDebug_DHCSR_S_REGRDY_Pos       16U                                            /*!< CoreDebug DHCSR: S_REGRDY Position */
+#define CoreDebug_DHCSR_S_REGRDY_Msk       (1UL << CoreDebug_DHCSR_S_REGRDY_Pos)          /*!< CoreDebug DHCSR: S_REGRDY Mask */
+
+#define CoreDebug_DHCSR_C_SNAPSTALL_Pos     5U                                            /*!< CoreDebug DHCSR: C_SNAPSTALL Position */
+#define CoreDebug_DHCSR_C_SNAPSTALL_Msk    (1UL << CoreDebug_DHCSR_C_SNAPSTALL_Pos)       /*!< CoreDebug DHCSR: C_SNAPSTALL Mask */
+
+#define CoreDebug_DHCSR_C_MASKINTS_Pos      3U                                            /*!< CoreDebug DHCSR: C_MASKINTS Position */
+#define CoreDebug_DHCSR_C_MASKINTS_Msk     (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos)        /*!< CoreDebug DHCSR: C_MASKINTS Mask */
+
+#define CoreDebug_DHCSR_C_STEP_Pos          2U                                            /*!< CoreDebug DHCSR: C_STEP Position */
+#define CoreDebug_DHCSR_C_STEP_Msk         (1UL << CoreDebug_DHCSR_C_STEP_Pos)            /*!< CoreDebug DHCSR: C_STEP Mask */
+
+#define CoreDebug_DHCSR_C_HALT_Pos          1U                                            /*!< CoreDebug DHCSR: C_HALT Position */
+#define CoreDebug_DHCSR_C_HALT_Msk         (1UL << CoreDebug_DHCSR_C_HALT_Pos)            /*!< CoreDebug DHCSR: C_HALT Mask */
+
+#define CoreDebug_DHCSR_C_DEBUGEN_Pos       0U                                            /*!< CoreDebug DHCSR: C_DEBUGEN Position */
+#define CoreDebug_DHCSR_C_DEBUGEN_Msk      (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/)     /*!< CoreDebug DHCSR: C_DEBUGEN Mask */
+
+/* Debug Core Register Selector Register Definitions */
+#define CoreDebug_DCRSR_REGWnR_Pos         16U                                            /*!< CoreDebug DCRSR: REGWnR Position */
+#define CoreDebug_DCRSR_REGWnR_Msk         (1UL << CoreDebug_DCRSR_REGWnR_Pos)            /*!< CoreDebug DCRSR: REGWnR Mask */
+
+#define CoreDebug_DCRSR_REGSEL_Pos          0U                                            /*!< CoreDebug DCRSR: REGSEL Position */
+#define CoreDebug_DCRSR_REGSEL_Msk         (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/)     /*!< CoreDebug DCRSR: REGSEL Mask */
+
+/* Debug Exception and Monitor Control Register Definitions */
+#define CoreDebug_DEMCR_TRCENA_Pos         24U                                            /*!< CoreDebug DEMCR: TRCENA Position */
+#define CoreDebug_DEMCR_TRCENA_Msk         (1UL << CoreDebug_DEMCR_TRCENA_Pos)            /*!< CoreDebug DEMCR: TRCENA Mask */
+
+#define CoreDebug_DEMCR_MON_REQ_Pos        19U                                            /*!< CoreDebug DEMCR: MON_REQ Position */
+#define CoreDebug_DEMCR_MON_REQ_Msk        (1UL << CoreDebug_DEMCR_MON_REQ_Pos)           /*!< CoreDebug DEMCR: MON_REQ Mask */
+
+#define CoreDebug_DEMCR_MON_STEP_Pos       18U                                            /*!< CoreDebug DEMCR: MON_STEP Position */
+#define CoreDebug_DEMCR_MON_STEP_Msk       (1UL << CoreDebug_DEMCR_MON_STEP_Pos)          /*!< CoreDebug DEMCR: MON_STEP Mask */
+
+#define CoreDebug_DEMCR_MON_PEND_Pos       17U                                            /*!< CoreDebug DEMCR: MON_PEND Position */
+#define CoreDebug_DEMCR_MON_PEND_Msk       (1UL << CoreDebug_DEMCR_MON_PEND_Pos)          /*!< CoreDebug DEMCR: MON_PEND Mask */
+
+#define CoreDebug_DEMCR_MON_EN_Pos         16U                                            /*!< CoreDebug DEMCR: MON_EN Position */
+#define CoreDebug_DEMCR_MON_EN_Msk         (1UL << CoreDebug_DEMCR_MON_EN_Pos)            /*!< CoreDebug DEMCR: MON_EN Mask */
+
+#define CoreDebug_DEMCR_VC_HARDERR_Pos     10U                                            /*!< CoreDebug DEMCR: VC_HARDERR Position */
+#define CoreDebug_DEMCR_VC_HARDERR_Msk     (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos)        /*!< CoreDebug DEMCR: VC_HARDERR Mask */
+
+#define CoreDebug_DEMCR_VC_INTERR_Pos       9U                                            /*!< CoreDebug DEMCR: VC_INTERR Position */
+#define CoreDebug_DEMCR_VC_INTERR_Msk      (1UL << CoreDebug_DEMCR_VC_INTERR_Pos)         /*!< CoreDebug DEMCR: VC_INTERR Mask */
+
+#define CoreDebug_DEMCR_VC_BUSERR_Pos       8U                                            /*!< CoreDebug DEMCR: VC_BUSERR Position */
+#define CoreDebug_DEMCR_VC_BUSERR_Msk      (1UL << CoreDebug_DEMCR_VC_BUSERR_Pos)         /*!< CoreDebug DEMCR: VC_BUSERR Mask */
+
+#define CoreDebug_DEMCR_VC_STATERR_Pos      7U                                            /*!< CoreDebug DEMCR: VC_STATERR Position */
+#define CoreDebug_DEMCR_VC_STATERR_Msk     (1UL << CoreDebug_DEMCR_VC_STATERR_Pos)        /*!< CoreDebug DEMCR: VC_STATERR Mask */
+
+#define CoreDebug_DEMCR_VC_CHKERR_Pos       6U                                            /*!< CoreDebug DEMCR: VC_CHKERR Position */
+#define CoreDebug_DEMCR_VC_CHKERR_Msk      (1UL << CoreDebug_DEMCR_VC_CHKERR_Pos)         /*!< CoreDebug DEMCR: VC_CHKERR Mask */
+
+#define CoreDebug_DEMCR_VC_NOCPERR_Pos      5U                                            /*!< CoreDebug DEMCR: VC_NOCPERR Position */
+#define CoreDebug_DEMCR_VC_NOCPERR_Msk     (1UL << CoreDebug_DEMCR_VC_NOCPERR_Pos)        /*!< CoreDebug DEMCR: VC_NOCPERR Mask */
+
+#define CoreDebug_DEMCR_VC_MMERR_Pos        4U                                            /*!< CoreDebug DEMCR: VC_MMERR Position */
+#define CoreDebug_DEMCR_VC_MMERR_Msk       (1UL << CoreDebug_DEMCR_VC_MMERR_Pos)          /*!< CoreDebug DEMCR: VC_MMERR Mask */
+
+#define CoreDebug_DEMCR_VC_CORERESET_Pos    0U                                            /*!< CoreDebug DEMCR: VC_CORERESET Position */
+#define CoreDebug_DEMCR_VC_CORERESET_Msk   (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/)  /*!< CoreDebug DEMCR: VC_CORERESET Mask */
+
+/* Debug Authentication Control Register Definitions */
+#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos  3U                                            /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Position */
+#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos)    /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Mask */
+
+#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos  2U                                            /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Position */
+#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Msk (1UL << CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos)    /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Mask */
+
+#define CoreDebug_DAUTHCTRL_INTSPIDEN_Pos   1U                                            /*!< CoreDebug DAUTHCTRL: INTSPIDEN Position */
+#define CoreDebug_DAUTHCTRL_INTSPIDEN_Msk  (1UL << CoreDebug_DAUTHCTRL_INTSPIDEN_Pos)     /*!< CoreDebug DAUTHCTRL: INTSPIDEN Mask */
+
+#define CoreDebug_DAUTHCTRL_SPIDENSEL_Pos   0U                                            /*!< CoreDebug DAUTHCTRL: SPIDENSEL Position */
+#define CoreDebug_DAUTHCTRL_SPIDENSEL_Msk  (1UL /*<< CoreDebug_DAUTHCTRL_SPIDENSEL_Pos*/) /*!< CoreDebug DAUTHCTRL: SPIDENSEL Mask */
+
+/* Debug Security Control and Status Register Definitions */
+#define CoreDebug_DSCSR_CDS_Pos            16U                                            /*!< CoreDebug DSCSR: CDS Position */
+#define CoreDebug_DSCSR_CDS_Msk            (1UL << CoreDebug_DSCSR_CDS_Pos)               /*!< CoreDebug DSCSR: CDS Mask */
+
+#define CoreDebug_DSCSR_SBRSEL_Pos          1U                                            /*!< CoreDebug DSCSR: SBRSEL Position */
+#define CoreDebug_DSCSR_SBRSEL_Msk         (1UL << CoreDebug_DSCSR_SBRSEL_Pos)            /*!< CoreDebug DSCSR: SBRSEL Mask */
+
+#define CoreDebug_DSCSR_SBRSELEN_Pos        0U                                            /*!< CoreDebug DSCSR: SBRSELEN Position */
+#define CoreDebug_DSCSR_SBRSELEN_Msk       (1UL /*<< CoreDebug_DSCSR_SBRSELEN_Pos*/)      /*!< CoreDebug DSCSR: SBRSELEN Mask */
+
+/*@} end of group CMSIS_CoreDebug */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_core_bitfield     Core register bit field macros
+  \brief      Macros for use with bit field definitions (xxx_Pos, xxx_Msk).
+  @{
+ */
+
+/**
+  \brief   Mask and shift a bit field value for use in a register bit range.
+  \param[in] field  Name of the register bit field.
+  \param[in] value  Value of the bit field. This parameter is interpreted as an uint32_t type.
+  \return           Masked and shifted value.
+*/
+#define _VAL2FLD(field, value)    (((uint32_t)(value) << field ## _Pos) & field ## _Msk)
+
+/**
+  \brief     Mask and shift a register value to extract a bit filed value.
+  \param[in] field  Name of the register bit field.
+  \param[in] value  Value of register. This parameter is interpreted as an uint32_t type.
+  \return           Masked and shifted bit field value.
+*/
+#define _FLD2VAL(field, value)    (((uint32_t)(value) & field ## _Msk) >> field ## _Pos)
+
+/*@} end of group CMSIS_core_bitfield */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_core_base     Core Definitions
+  \brief      Definitions for base addresses, unions, and structures.
+  @{
+ */
+
+/* Memory mapping of Core Hardware */
+  #define SCS_BASE            (0xE000E000UL)                             /*!< System Control Space Base Address */
+  #define ITM_BASE            (0xE0000000UL)                             /*!< ITM Base Address */
+  #define DWT_BASE            (0xE0001000UL)                             /*!< DWT Base Address */
+  #define TPI_BASE            (0xE0040000UL)                             /*!< TPI Base Address */
+  #define CoreDebug_BASE      (0xE000EDF0UL)                             /*!< Core Debug Base Address */
+  #define SysTick_BASE        (SCS_BASE +  0x0010UL)                     /*!< SysTick Base Address */
+  #define NVIC_BASE           (SCS_BASE +  0x0100UL)                     /*!< NVIC Base Address */
+  #define SCB_BASE            (SCS_BASE +  0x0D00UL)                     /*!< System Control Block Base Address */
+
+  #define SCnSCB              ((SCnSCB_Type    *)     SCS_BASE         ) /*!< System control Register not in SCB */
+  #define SCB                 ((SCB_Type       *)     SCB_BASE         ) /*!< SCB configuration struct */
+  #define SysTick             ((SysTick_Type   *)     SysTick_BASE     ) /*!< SysTick configuration struct */
+  #define NVIC                ((NVIC_Type      *)     NVIC_BASE        ) /*!< NVIC configuration struct */
+  #define ITM                 ((ITM_Type       *)     ITM_BASE         ) /*!< ITM configuration struct */
+  #define DWT                 ((DWT_Type       *)     DWT_BASE         ) /*!< DWT configuration struct */
+  #define TPI                 ((TPI_Type       *)     TPI_BASE         ) /*!< TPI configuration struct */
+  #define CoreDebug           ((CoreDebug_Type *)     CoreDebug_BASE   ) /*!< Core Debug configuration struct */
+
+  #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+    #define MPU_BASE          (SCS_BASE +  0x0D90UL)                     /*!< Memory Protection Unit */
+    #define MPU               ((MPU_Type       *)     MPU_BASE         ) /*!< Memory Protection Unit */
+  #endif
+
+  #if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+    #define SAU_BASE          (SCS_BASE +  0x0DD0UL)                     /*!< Security Attribution Unit */
+    #define SAU               ((SAU_Type       *)     SAU_BASE         ) /*!< Security Attribution Unit */
+  #endif
+
+  #define FPU_BASE            (SCS_BASE +  0x0F30UL)                     /*!< Floating Point Unit */
+  #define FPU                 ((FPU_Type       *)     FPU_BASE         ) /*!< Floating Point Unit */
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+  #define SCS_BASE_NS         (0xE002E000UL)                             /*!< System Control Space Base Address (non-secure address space) */
+  #define CoreDebug_BASE_NS   (0xE002EDF0UL)                             /*!< Core Debug Base Address           (non-secure address space) */
+  #define SysTick_BASE_NS     (SCS_BASE_NS +  0x0010UL)                  /*!< SysTick Base Address              (non-secure address space) */
+  #define NVIC_BASE_NS        (SCS_BASE_NS +  0x0100UL)                  /*!< NVIC Base Address                 (non-secure address space) */
+  #define SCB_BASE_NS         (SCS_BASE_NS +  0x0D00UL)                  /*!< System Control Block Base Address (non-secure address space) */
+
+  #define SCnSCB_NS           ((SCnSCB_Type    *)     SCS_BASE_NS      ) /*!< System control Register not in SCB(non-secure address space) */
+  #define SCB_NS              ((SCB_Type       *)     SCB_BASE_NS      ) /*!< SCB configuration struct          (non-secure address space) */
+  #define SysTick_NS          ((SysTick_Type   *)     SysTick_BASE_NS  ) /*!< SysTick configuration struct      (non-secure address space) */
+  #define NVIC_NS             ((NVIC_Type      *)     NVIC_BASE_NS     ) /*!< NVIC configuration struct         (non-secure address space) */
+  #define CoreDebug_NS        ((CoreDebug_Type *)     CoreDebug_BASE_NS) /*!< Core Debug configuration struct   (non-secure address space) */
+
+  #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+    #define MPU_BASE_NS       (SCS_BASE_NS +  0x0D90UL)                  /*!< Memory Protection Unit            (non-secure address space) */
+    #define MPU_NS            ((MPU_Type       *)     MPU_BASE_NS      ) /*!< Memory Protection Unit            (non-secure address space) */
+  #endif
+
+  #define FPU_BASE_NS         (SCS_BASE_NS +  0x0F30UL)                  /*!< Floating Point Unit               (non-secure address space) */
+  #define FPU_NS              ((FPU_Type       *)     FPU_BASE_NS      ) /*!< Floating Point Unit               (non-secure address space) */
+
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+/*@} */
+
+
+
+/*******************************************************************************
+ *                Hardware Abstraction Layer
+  Core Function Interface contains:
+  - Core NVIC Functions
+  - Core SysTick Functions
+  - Core Debug Functions
+  - Core Register Access Functions
+ ******************************************************************************/
+/**
+  \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference
+*/
+
+
+
+/* ##########################   NVIC functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_NVICFunctions NVIC Functions
+  \brief    Functions that manage interrupts and exceptions via the NVIC.
+  @{
+ */
+
+#ifdef CMSIS_NVIC_VIRTUAL
+  #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
+    #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
+  #endif
+  #include CMSIS_NVIC_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetPriorityGrouping    __NVIC_SetPriorityGrouping
+  #define NVIC_GetPriorityGrouping    __NVIC_GetPriorityGrouping
+  #define NVIC_EnableIRQ              __NVIC_EnableIRQ
+  #define NVIC_GetEnableIRQ           __NVIC_GetEnableIRQ
+  #define NVIC_DisableIRQ             __NVIC_DisableIRQ
+  #define NVIC_GetPendingIRQ          __NVIC_GetPendingIRQ
+  #define NVIC_SetPendingIRQ          __NVIC_SetPendingIRQ
+  #define NVIC_ClearPendingIRQ        __NVIC_ClearPendingIRQ
+  #define NVIC_GetActive              __NVIC_GetActive
+  #define NVIC_SetPriority            __NVIC_SetPriority
+  #define NVIC_GetPriority            __NVIC_GetPriority
+  #define NVIC_SystemReset            __NVIC_SystemReset
+#endif /* CMSIS_NVIC_VIRTUAL */
+
+#ifdef CMSIS_VECTAB_VIRTUAL
+  #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+    #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h"
+  #endif
+  #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetVector              __NVIC_SetVector
+  #define NVIC_GetVector              __NVIC_GetVector
+#endif  /* (CMSIS_VECTAB_VIRTUAL) */
+
+#define NVIC_USER_IRQ_OFFSET          16
+
+
+/* Special LR values for Secure/Non-Secure call handling and exception handling                                               */
+
+/* Function Return Payload (from ARMv8-M Architecture Reference Manual) LR value on entry from Secure BLXNS                   */ 
+#define FNC_RETURN                 (0xFEFFFFFFUL)     /* bit [0] ignored when processing a branch                             */
+
+/* The following EXC_RETURN mask values are used to evaluate the LR on exception entry */
+#define EXC_RETURN_PREFIX          (0xFF000000UL)     /* bits [31:24] set to indicate an EXC_RETURN value                     */
+#define EXC_RETURN_S               (0x00000040UL)     /* bit [6] stack used to push registers: 0=Non-secure 1=Secure          */
+#define EXC_RETURN_DCRS            (0x00000020UL)     /* bit [5] stacking rules for called registers: 0=skipped 1=saved       */
+#define EXC_RETURN_FTYPE           (0x00000010UL)     /* bit [4] allocate stack for floating-point context: 0=done 1=skipped  */
+#define EXC_RETURN_MODE            (0x00000008UL)     /* bit [3] processor mode for return: 0=Handler mode 1=Thread mode      */
+#define EXC_RETURN_SPSEL           (0x00000004UL)     /* bit [2] stack pointer used to restore context: 0=MSP 1=PSP           */
+#define EXC_RETURN_ES              (0x00000001UL)     /* bit [0] security state exception was taken to: 0=Non-secure 1=Secure */
+
+/* Integrity Signature (from ARMv8-M Architecture Reference Manual) for exception context stacking                            */
+#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)  /* Value for processors with floating-point extension:                  */
+#define EXC_INTEGRITY_SIGNATURE     (0xFEFA125AUL)     /* bit [0] SFTC must match LR bit[4] EXC_RETURN_FTYPE                   */
+#else 
+#define EXC_INTEGRITY_SIGNATURE     (0xFEFA125BUL)     /* Value for processors without floating-point extension                */
+#endif
+
+
+/**
+  \brief   Set Priority Grouping
+  \details Sets the priority grouping field using the required unlock sequence.
+           The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field.
+           Only values from 0..7 are used.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]      PriorityGroup  Priority grouping field.
+ */
+__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
+{
+  uint32_t reg_value;
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);             /* only values 0..7 are used          */
+
+  reg_value  =  SCB->AIRCR;                                                   /* read old register configuration    */
+  reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change               */
+  reg_value  =  (reg_value                                   |
+                ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
+                (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos)  );              /* Insert write key and priority group */
+  SCB->AIRCR =  reg_value;
+}
+
+
+/**
+  \brief   Get Priority Grouping
+  \details Reads the priority grouping field from the NVIC Interrupt Controller.
+  \return                Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field).
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void)
+{
+  return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos));
+}
+
+
+/**
+  \brief   Enable Interrupt
+  \details Enables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Enable status
+  \details Returns a device specific interrupt enable status from the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt
+  \details Disables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
+  }
+}
+
+
+/**
+  \brief   Get Pending Interrupt
+  \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not pending.
+  \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Pending Interrupt
+  \details Sets the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Clear Pending Interrupt
+  \details Clears the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Active Interrupt
+  \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not active.
+  \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   Get Interrupt Target State
+  \details Reads the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+  \return             1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_GetTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Interrupt Target State
+  \details Sets the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+                      1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_SetTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] |=  ((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)));
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Clear Interrupt Target State
+  \details Clears the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+                      1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_ClearTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] &= ~((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)));
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+
+/**
+  \brief   Set Interrupt Priority
+  \details Sets the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]      IRQn  Interrupt number.
+  \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every processor exception.
+ */
+__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->IPR[((uint32_t)IRQn)]               = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+  else
+  {
+    SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Priority
+  \details Reads the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn  Interrupt number.
+  \return             Interrupt Priority.
+                      Value is aligned automatically to the implemented priority bits of the microcontroller.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn)
+{
+
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return(((uint32_t)NVIC->IPR[((uint32_t)IRQn)]               >> (8U - __NVIC_PRIO_BITS)));
+  }
+  else
+  {
+    return(((uint32_t)SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
+  }
+}
+
+
+/**
+  \brief   Encode Priority
+  \details Encodes the priority for an interrupt with the given priority group,
+           preemptive priority value, and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]     PriorityGroup  Used priority group.
+  \param [in]   PreemptPriority  Preemptive priority value (starting from 0).
+  \param [in]       SubPriority  Subpriority value (starting from 0).
+  \return                        Encoded priority. Value can be used in the function \ref NVIC_SetPriority().
+ */
+__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  return (
+           ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) |
+           ((SubPriority     & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL)))
+         );
+}
+
+
+/**
+  \brief   Decode Priority
+  \details Decodes an interrupt priority value with a given priority group to
+           preemptive priority value and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set.
+  \param [in]         Priority   Priority value, which can be retrieved with the function \ref NVIC_GetPriority().
+  \param [in]     PriorityGroup  Used priority group.
+  \param [out] pPreemptPriority  Preemptive priority value (starting from 0).
+  \param [out]     pSubPriority  Subpriority value (starting from 0).
+ */
+__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL);
+  *pSubPriority     = (Priority                   ) & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL);
+}
+
+
+/**
+  \brief   Set Interrupt Vector
+  \details Sets an interrupt vector in SRAM based interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+           VTOR must been relocated to SRAM before.
+  \param [in]   IRQn      Interrupt number
+  \param [in]   vector    Address of interrupt handler function
+ */
+__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
+{
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+  vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector;
+}
+
+
+/**
+  \brief   Get Interrupt Vector
+  \details Reads an interrupt vector from interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn      Interrupt number.
+  \return                 Address of interrupt handler function
+ */
+__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn)
+{
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+  return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET];
+}
+
+
+/**
+  \brief   System Reset
+  \details Initiates a system reset request to reset the MCU.
+ */
+__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void)
+{
+  __DSB();                                                          /* Ensure all outstanding memory accesses included
+                                                                       buffered write are completed before reset */
+  SCB->AIRCR  = (uint32_t)((0x5FAUL << SCB_AIRCR_VECTKEY_Pos)    |
+                           (SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) |
+                            SCB_AIRCR_SYSRESETREQ_Msk    );         /* Keep priority group unchanged */
+  __DSB();                                                          /* Ensure completion of memory access */
+
+  for(;;)                                                           /* wait until reset */
+  {
+    __NOP();
+  }
+}
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   Set Priority Grouping (non-secure)
+  \details Sets the non-secure priority grouping field when in secure state using the required unlock sequence.
+           The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field.
+           Only values from 0..7 are used.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]      PriorityGroup  Priority grouping field.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPriorityGrouping_NS(uint32_t PriorityGroup)
+{
+  uint32_t reg_value;
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);             /* only values 0..7 are used          */
+
+  reg_value  =  SCB_NS->AIRCR;                                                /* read old register configuration    */
+  reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change               */
+  reg_value  =  (reg_value                                   |
+                ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
+                (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos)  );              /* Insert write key and priority group */
+  SCB_NS->AIRCR =  reg_value;
+}
+
+
+/**
+  \brief   Get Priority Grouping (non-secure)
+  \details Reads the priority grouping field from the non-secure NVIC when in secure state.
+  \return                Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field).
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPriorityGrouping_NS(void)
+{
+  return ((uint32_t)((SCB_NS->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos));
+}
+
+
+/**
+  \brief   Enable Interrupt (non-secure)
+  \details Enables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_EnableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Enable status (non-secure)
+  \details Returns a device specific interrupt enable status from the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetEnableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt (non-secure)
+  \details Disables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_DisableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Pending Interrupt (non-secure)
+  \details Reads the NVIC pending register in the non-secure NVIC when in secure state and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not pending.
+  \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Pending Interrupt (non-secure)
+  \details Sets the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Clear Pending Interrupt (non-secure)
+  \details Clears the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_ClearPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Active Interrupt (non-secure)
+  \details Reads the active register in non-secure NVIC when in secure state and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not active.
+  \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetActive_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Interrupt Priority (non-secure)
+  \details Sets the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]      IRQn  Interrupt number.
+  \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every non-secure processor exception.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPriority_NS(IRQn_Type IRQn, uint32_t priority)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->IPR[((uint32_t)IRQn)]               = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+  else
+  {
+    SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Priority (non-secure)
+  \details Reads the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn  Interrupt number.
+  \return             Interrupt Priority. Value is aligned automatically to the implemented priority bits of the microcontroller.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPriority_NS(IRQn_Type IRQn)
+{
+
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return(((uint32_t)NVIC_NS->IPR[((uint32_t)IRQn)]               >> (8U - __NVIC_PRIO_BITS)));
+  }
+  else
+  {
+    return(((uint32_t)SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
+  }
+}
+#endif /*  defined (__ARM_FEATURE_CMSE) &&(__ARM_FEATURE_CMSE == 3U) */
+
+/*@} end of CMSIS_Core_NVICFunctions */
+
+/* ##########################  MPU functions  #################################### */
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+
+#include "mpu_armv8.h"
+
+#endif
+
+/* ##########################  FPU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_FpuFunctions FPU Functions
+  \brief    Function that provides FPU type.
+  @{
+ */
+
+/**
+  \brief   get FPU type
+  \details returns the FPU type
+  \returns
+   - \b  0: No FPU
+   - \b  1: Single precision FPU
+   - \b  2: Double + Single precision FPU
+ */
+__STATIC_INLINE uint32_t SCB_GetFPUType(void)
+{
+  uint32_t mvfr0;
+
+  mvfr0 = FPU->MVFR0;
+  if      ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x220U)
+  {
+    return 2U;           /* Double + Single precision FPU */
+  }
+  else if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x020U)
+  {
+    return 1U;           /* Single precision FPU */
+  }
+  else
+  {
+    return 0U;           /* No FPU */
+  }
+}
+
+
+/*@} end of CMSIS_Core_FpuFunctions */
+
+
+
+/* ##########################   SAU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_SAUFunctions SAU Functions
+  \brief    Functions that configure the SAU.
+  @{
+ */
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+
+/**
+  \brief   Enable SAU
+  \details Enables the Security Attribution Unit (SAU).
+ */
+__STATIC_INLINE void TZ_SAU_Enable(void)
+{
+    SAU->CTRL |=  (SAU_CTRL_ENABLE_Msk);
+}
+
+
+
+/**
+  \brief   Disable SAU
+  \details Disables the Security Attribution Unit (SAU).
+ */
+__STATIC_INLINE void TZ_SAU_Disable(void)
+{
+    SAU->CTRL &= ~(SAU_CTRL_ENABLE_Msk);
+}
+
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+/*@} end of CMSIS_Core_SAUFunctions */
+
+
+
+
+/* ##################################    SysTick function  ############################################ */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_SysTickFunctions SysTick Functions
+  \brief    Functions that configure the System.
+  @{
+ */
+
+#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
+
+/**
+  \brief   System Tick Configuration
+  \details Initializes the System Timer and its interrupt, and starts the System Tick Timer.
+           Counter is in free running mode to generate periodic interrupts.
+  \param [in]  ticks  Number of ticks between two interrupts.
+  \return          0  Function succeeded.
+  \return          1  Function failed.
+  \note    When the variable <b>__Vendor_SysTickConfig</b> is set to 1, then the
+           function <b>SysTick_Config</b> is not included. In this case, the file <b><i>device</i>.h</b>
+           must contain a vendor-specific implementation of this function.
+ */
+__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
+{
+  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
+  {
+    return (1UL);                                                   /* Reload value impossible */
+  }
+
+  SysTick->LOAD  = (uint32_t)(ticks - 1UL);                         /* set reload register */
+  NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
+  SysTick->VAL   = 0UL;                                             /* Load the SysTick Counter Value */
+  SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
+                   SysTick_CTRL_TICKINT_Msk   |
+                   SysTick_CTRL_ENABLE_Msk;                         /* Enable SysTick IRQ and SysTick Timer */
+  return (0UL);                                                     /* Function successful */
+}
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   System Tick Configuration (non-secure)
+  \details Initializes the non-secure System Timer and its interrupt when in secure state, and starts the System Tick Timer.
+           Counter is in free running mode to generate periodic interrupts.
+  \param [in]  ticks  Number of ticks between two interrupts.
+  \return          0  Function succeeded.
+  \return          1  Function failed.
+  \note    When the variable <b>__Vendor_SysTickConfig</b> is set to 1, then the
+           function <b>TZ_SysTick_Config_NS</b> is not included. In this case, the file <b><i>device</i>.h</b>
+           must contain a vendor-specific implementation of this function.
+
+ */
+__STATIC_INLINE uint32_t TZ_SysTick_Config_NS(uint32_t ticks)
+{
+  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
+  {
+    return (1UL);                                                         /* Reload value impossible */
+  }
+
+  SysTick_NS->LOAD  = (uint32_t)(ticks - 1UL);                            /* set reload register */
+  TZ_NVIC_SetPriority_NS (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
+  SysTick_NS->VAL   = 0UL;                                                /* Load the SysTick Counter Value */
+  SysTick_NS->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
+                      SysTick_CTRL_TICKINT_Msk   |
+                      SysTick_CTRL_ENABLE_Msk;                            /* Enable SysTick IRQ and SysTick Timer */
+  return (0UL);                                                           /* Function successful */
+}
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+#endif
+
+/*@} end of CMSIS_Core_SysTickFunctions */
+
+
+
+/* ##################################### Debug In/Output function ########################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_core_DebugFunctions ITM Functions
+  \brief    Functions that access the ITM debug interface.
+  @{
+ */
+
+extern volatile int32_t ITM_RxBuffer;                              /*!< External variable to receive characters. */
+#define                 ITM_RXBUFFER_EMPTY  ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */
+
+
+/**
+  \brief   ITM Send Character
+  \details Transmits a character via the ITM channel 0, and
+           \li Just returns when no debugger is connected that has booked the output.
+           \li Is blocking when a debugger is connected, but the previous character sent has not been transmitted.
+  \param [in]     ch  Character to transmit.
+  \returns            Character to transmit.
+ */
+__STATIC_INLINE uint32_t ITM_SendChar (uint32_t ch)
+{
+  if (((ITM->TCR & ITM_TCR_ITMENA_Msk) != 0UL) &&      /* ITM enabled */
+      ((ITM->TER & 1UL               ) != 0UL)   )     /* ITM Port #0 enabled */
+  {
+    while (ITM->PORT[0U].u32 == 0UL)
+    {
+      __NOP();
+    }
+    ITM->PORT[0U].u8 = (uint8_t)ch;
+  }
+  return (ch);
+}
+
+
+/**
+  \brief   ITM Receive Character
+  \details Inputs a character via the external variable \ref ITM_RxBuffer.
+  \return             Received character.
+  \return         -1  No character pending.
+ */
+__STATIC_INLINE int32_t ITM_ReceiveChar (void)
+{
+  int32_t ch = -1;                           /* no character available */
+
+  if (ITM_RxBuffer != ITM_RXBUFFER_EMPTY)
+  {
+    ch = ITM_RxBuffer;
+    ITM_RxBuffer = ITM_RXBUFFER_EMPTY;       /* ready for next character */
+  }
+
+  return (ch);
+}
+
+
+/**
+  \brief   ITM Check Character
+  \details Checks whether a character is pending for reading in the variable \ref ITM_RxBuffer.
+  \return          0  No character available.
+  \return          1  Character available.
+ */
+__STATIC_INLINE int32_t ITM_CheckChar (void)
+{
+
+  if (ITM_RxBuffer == ITM_RXBUFFER_EMPTY)
+  {
+    return (0);                              /* no character available */
+  }
+  else
+  {
+    return (1);                              /*    character available */
+  }
+}
+
+/*@} end of CMSIS_core_DebugFunctions */
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CORE_CM33_H_DEPENDANT */
+
+#endif /* __CMSIS_GENERIC */
diff --git a/lib/cmsis/inc/core_cm35p.h b/lib/cmsis/inc/core_cm35p.h
new file mode 100644
index 0000000000000..c00e54ca7a984
--- /dev/null
+++ b/lib/cmsis/inc/core_cm35p.h
@@ -0,0 +1,2907 @@
+/**************************************************************************//**
+ * @file     core_cm35p.h
+ * @brief    CMSIS Cortex-M35P Core Peripheral Access Layer Header File
+ * @version  V1.0.0
+ * @date     12. November 2018
+ ******************************************************************************/
+/*
+ * Copyright (c) 2018 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if   defined ( __ICCARM__ )
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
+  #pragma clang system_header   /* treat file as system include file */
+#endif
+
+#ifndef __CORE_CM35P_H_GENERIC
+#define __CORE_CM35P_H_GENERIC
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/**
+  \page CMSIS_MISRA_Exceptions  MISRA-C:2004 Compliance Exceptions
+  CMSIS violates the following MISRA-C:2004 rules:
+
+   \li Required Rule 8.5, object/function definition in header file.<br>
+     Function definitions in header files are used to allow 'inlining'.
+
+   \li Required Rule 18.4, declaration of union type or object of union type: '{...}'.<br>
+     Unions are used for effective representation of core registers.
+
+   \li Advisory Rule 19.7, Function-like macro defined.<br>
+     Function-like macros are used to allow more efficient code.
+ */
+
+
+/*******************************************************************************
+ *                 CMSIS definitions
+ ******************************************************************************/
+/**
+  \ingroup Cortex_M35P
+  @{
+ */
+
+#include "cmsis_version.h"
+
+/*  CMSIS CM35P definitions */
+#define __CM35P_CMSIS_VERSION_MAIN  (__CM_CMSIS_VERSION_MAIN)                  /*!< \deprecated [31:16] CMSIS HAL main version */
+#define __CM35P_CMSIS_VERSION_SUB   (__CM_CMSIS_VERSION_SUB)                   /*!< \deprecated [15:0]  CMSIS HAL sub version */
+#define __CM35P_CMSIS_VERSION       ((__CM35P_CMSIS_VERSION_MAIN << 16U) | \
+                                      __CM35P_CMSIS_VERSION_SUB           )    /*!< \deprecated CMSIS HAL version number */
+
+#define __CORTEX_M                 (35U)                                       /*!< Cortex-M Core */
+
+/** __FPU_USED indicates whether an FPU is used or not.
+    For this, __FPU_PRESENT has to be checked prior to making use of FPU specific registers and functions.
+*/
+#if defined ( __CC_ARM )
+  #if defined (__TARGET_FPU_VFP)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+  #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U)
+    #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #if defined (__ARM_FP)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+  #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U)
+    #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+
+#elif defined ( __GNUC__ )
+  #if defined (__VFP_FP__) && !defined(__SOFTFP__)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+  #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U)
+    #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+
+#elif defined ( __ICCARM__ )
+  #if defined (__ARMVFP__)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+  #if defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1U)
+    #if defined (__DSP_PRESENT) && (__DSP_PRESENT == 1U)
+      #define __DSP_USED       1U
+    #else
+      #error "Compiler generates DSP (SIMD) instructions for a devices without DSP extensions (check __DSP_PRESENT)"
+      #define __DSP_USED         0U
+    #endif
+  #else
+    #define __DSP_USED         0U
+  #endif
+
+#elif defined ( __TI_ARM__ )
+  #if defined (__TI_VFP_SUPPORT__)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+#elif defined ( __TASKING__ )
+  #if defined (__FPU_VFP__)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+#elif defined ( __CSMC__ )
+  #if ( __CSMC__ & 0x400U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
+      #define __FPU_USED       1U
+    #else
+      #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
+      #define __FPU_USED       0U
+    #endif
+  #else
+    #define __FPU_USED         0U
+  #endif
+
+#endif
+
+#include "cmsis_compiler.h"               /* CMSIS compiler specific defines */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CORE_CM35P_H_GENERIC */
+
+#ifndef __CMSIS_GENERIC
+
+#ifndef __CORE_CM35P_H_DEPENDANT
+#define __CORE_CM35P_H_DEPENDANT
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+/* check device defines and use defaults */
+#if defined __CHECK_DEVICE_DEFINES
+  #ifndef __CM35P_REV
+    #define __CM35P_REV               0x0000U
+    #warning "__CM35P_REV not defined in device header file; using default!"
+  #endif
+
+  #ifndef __FPU_PRESENT
+    #define __FPU_PRESENT             0U
+    #warning "__FPU_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __MPU_PRESENT
+    #define __MPU_PRESENT             0U
+    #warning "__MPU_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __SAUREGION_PRESENT
+    #define __SAUREGION_PRESENT       0U
+    #warning "__SAUREGION_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __DSP_PRESENT
+    #define __DSP_PRESENT             0U
+    #warning "__DSP_PRESENT not defined in device header file; using default!"
+  #endif
+
+  #ifndef __NVIC_PRIO_BITS
+    #define __NVIC_PRIO_BITS          3U
+    #warning "__NVIC_PRIO_BITS not defined in device header file; using default!"
+  #endif
+
+  #ifndef __Vendor_SysTickConfig
+    #define __Vendor_SysTickConfig    0U
+    #warning "__Vendor_SysTickConfig not defined in device header file; using default!"
+  #endif
+#endif
+
+/* IO definitions (access restrictions to peripheral registers) */
+/**
+    \defgroup CMSIS_glob_defs CMSIS Global Defines
+
+    <strong>IO Type Qualifiers</strong> are used
+    \li to specify the access to peripheral variables.
+    \li for automatic generation of peripheral register debug information.
+*/
+#ifdef __cplusplus
+  #define   __I     volatile             /*!< Defines 'read only' permissions */
+#else
+  #define   __I     volatile const       /*!< Defines 'read only' permissions */
+#endif
+#define     __O     volatile             /*!< Defines 'write only' permissions */
+#define     __IO    volatile             /*!< Defines 'read / write' permissions */
+
+/* following defines should be used for structure members */
+#define     __IM     volatile const      /*! Defines 'read only' structure member permissions */
+#define     __OM     volatile            /*! Defines 'write only' structure member permissions */
+#define     __IOM    volatile            /*! Defines 'read / write' structure member permissions */
+
+/*@} end of group Cortex_M35P */
+
+
+
+/*******************************************************************************
+ *                 Register Abstraction
+  Core Register contain:
+  - Core Register
+  - Core NVIC Register
+  - Core SCB Register
+  - Core SysTick Register
+  - Core Debug Register
+  - Core MPU Register
+  - Core SAU Register
+  - Core FPU Register
+ ******************************************************************************/
+/**
+  \defgroup CMSIS_core_register Defines and Type Definitions
+  \brief Type definitions and defines for Cortex-M processor based devices.
+*/
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_CORE  Status and Control Registers
+  \brief      Core Register type definitions.
+  @{
+ */
+
+/**
+  \brief  Union type to access the Application Program Status Register (APSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t _reserved0:16;              /*!< bit:  0..15  Reserved */
+    uint32_t GE:4;                       /*!< bit: 16..19  Greater than or Equal flags */
+    uint32_t _reserved1:7;               /*!< bit: 20..26  Reserved */
+    uint32_t Q:1;                        /*!< bit:     27  Saturation condition flag */
+    uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
+    uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
+    uint32_t Z:1;                        /*!< bit:     30  Zero condition code flag */
+    uint32_t N:1;                        /*!< bit:     31  Negative condition code flag */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} APSR_Type;
+
+/* APSR Register Definitions */
+#define APSR_N_Pos                         31U                                            /*!< APSR: N Position */
+#define APSR_N_Msk                         (1UL << APSR_N_Pos)                            /*!< APSR: N Mask */
+
+#define APSR_Z_Pos                         30U                                            /*!< APSR: Z Position */
+#define APSR_Z_Msk                         (1UL << APSR_Z_Pos)                            /*!< APSR: Z Mask */
+
+#define APSR_C_Pos                         29U                                            /*!< APSR: C Position */
+#define APSR_C_Msk                         (1UL << APSR_C_Pos)                            /*!< APSR: C Mask */
+
+#define APSR_V_Pos                         28U                                            /*!< APSR: V Position */
+#define APSR_V_Msk                         (1UL << APSR_V_Pos)                            /*!< APSR: V Mask */
+
+#define APSR_Q_Pos                         27U                                            /*!< APSR: Q Position */
+#define APSR_Q_Msk                         (1UL << APSR_Q_Pos)                            /*!< APSR: Q Mask */
+
+#define APSR_GE_Pos                        16U                                            /*!< APSR: GE Position */
+#define APSR_GE_Msk                        (0xFUL << APSR_GE_Pos)                         /*!< APSR: GE Mask */
+
+
+/**
+  \brief  Union type to access the Interrupt Program Status Register (IPSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
+    uint32_t _reserved0:23;              /*!< bit:  9..31  Reserved */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} IPSR_Type;
+
+/* IPSR Register Definitions */
+#define IPSR_ISR_Pos                        0U                                            /*!< IPSR: ISR Position */
+#define IPSR_ISR_Msk                       (0x1FFUL /*<< IPSR_ISR_Pos*/)                  /*!< IPSR: ISR Mask */
+
+
+/**
+  \brief  Union type to access the Special-Purpose Program Status Registers (xPSR).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
+    uint32_t _reserved0:7;               /*!< bit:  9..15  Reserved */
+    uint32_t GE:4;                       /*!< bit: 16..19  Greater than or Equal flags */
+    uint32_t _reserved1:4;               /*!< bit: 20..23  Reserved */
+    uint32_t T:1;                        /*!< bit:     24  Thumb bit        (read 0) */
+    uint32_t IT:2;                       /*!< bit: 25..26  saved IT state   (read 0) */
+    uint32_t Q:1;                        /*!< bit:     27  Saturation condition flag */
+    uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
+    uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
+    uint32_t Z:1;                        /*!< bit:     30  Zero condition code flag */
+    uint32_t N:1;                        /*!< bit:     31  Negative condition code flag */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} xPSR_Type;
+
+/* xPSR Register Definitions */
+#define xPSR_N_Pos                         31U                                            /*!< xPSR: N Position */
+#define xPSR_N_Msk                         (1UL << xPSR_N_Pos)                            /*!< xPSR: N Mask */
+
+#define xPSR_Z_Pos                         30U                                            /*!< xPSR: Z Position */
+#define xPSR_Z_Msk                         (1UL << xPSR_Z_Pos)                            /*!< xPSR: Z Mask */
+
+#define xPSR_C_Pos                         29U                                            /*!< xPSR: C Position */
+#define xPSR_C_Msk                         (1UL << xPSR_C_Pos)                            /*!< xPSR: C Mask */
+
+#define xPSR_V_Pos                         28U                                            /*!< xPSR: V Position */
+#define xPSR_V_Msk                         (1UL << xPSR_V_Pos)                            /*!< xPSR: V Mask */
+
+#define xPSR_Q_Pos                         27U                                            /*!< xPSR: Q Position */
+#define xPSR_Q_Msk                         (1UL << xPSR_Q_Pos)                            /*!< xPSR: Q Mask */
+
+#define xPSR_IT_Pos                        25U                                            /*!< xPSR: IT Position */
+#define xPSR_IT_Msk                        (3UL << xPSR_IT_Pos)                           /*!< xPSR: IT Mask */
+
+#define xPSR_T_Pos                         24U                                            /*!< xPSR: T Position */
+#define xPSR_T_Msk                         (1UL << xPSR_T_Pos)                            /*!< xPSR: T Mask */
+
+#define xPSR_GE_Pos                        16U                                            /*!< xPSR: GE Position */
+#define xPSR_GE_Msk                        (0xFUL << xPSR_GE_Pos)                         /*!< xPSR: GE Mask */
+
+#define xPSR_ISR_Pos                        0U                                            /*!< xPSR: ISR Position */
+#define xPSR_ISR_Msk                       (0x1FFUL /*<< xPSR_ISR_Pos*/)                  /*!< xPSR: ISR Mask */
+
+
+/**
+  \brief  Union type to access the Control Registers (CONTROL).
+ */
+typedef union
+{
+  struct
+  {
+    uint32_t nPRIV:1;                    /*!< bit:      0  Execution privilege in Thread mode */
+    uint32_t SPSEL:1;                    /*!< bit:      1  Stack-pointer select */
+    uint32_t FPCA:1;                     /*!< bit:      2  Floating-point context active */
+    uint32_t SFPA:1;                     /*!< bit:      3  Secure floating-point active */
+    uint32_t _reserved1:28;              /*!< bit:  4..31  Reserved */
+  } b;                                   /*!< Structure used for bit  access */
+  uint32_t w;                            /*!< Type      used for word access */
+} CONTROL_Type;
+
+/* CONTROL Register Definitions */
+#define CONTROL_SFPA_Pos                    3U                                            /*!< CONTROL: SFPA Position */
+#define CONTROL_SFPA_Msk                   (1UL << CONTROL_SFPA_Pos)                      /*!< CONTROL: SFPA Mask */
+
+#define CONTROL_FPCA_Pos                    2U                                            /*!< CONTROL: FPCA Position */
+#define CONTROL_FPCA_Msk                   (1UL << CONTROL_FPCA_Pos)                      /*!< CONTROL: FPCA Mask */
+
+#define CONTROL_SPSEL_Pos                   1U                                            /*!< CONTROL: SPSEL Position */
+#define CONTROL_SPSEL_Msk                  (1UL << CONTROL_SPSEL_Pos)                     /*!< CONTROL: SPSEL Mask */
+
+#define CONTROL_nPRIV_Pos                   0U                                            /*!< CONTROL: nPRIV Position */
+#define CONTROL_nPRIV_Msk                  (1UL /*<< CONTROL_nPRIV_Pos*/)                 /*!< CONTROL: nPRIV Mask */
+
+/*@} end of group CMSIS_CORE */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_NVIC  Nested Vectored Interrupt Controller (NVIC)
+  \brief      Type definitions for the NVIC Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Nested Vectored Interrupt Controller (NVIC).
+ */
+typedef struct
+{
+  __IOM uint32_t ISER[16U];              /*!< Offset: 0x000 (R/W)  Interrupt Set Enable Register */
+        uint32_t RESERVED0[16U];
+  __IOM uint32_t ICER[16U];              /*!< Offset: 0x080 (R/W)  Interrupt Clear Enable Register */
+        uint32_t RSERVED1[16U];
+  __IOM uint32_t ISPR[16U];              /*!< Offset: 0x100 (R/W)  Interrupt Set Pending Register */
+        uint32_t RESERVED2[16U];
+  __IOM uint32_t ICPR[16U];              /*!< Offset: 0x180 (R/W)  Interrupt Clear Pending Register */
+        uint32_t RESERVED3[16U];
+  __IOM uint32_t IABR[16U];              /*!< Offset: 0x200 (R/W)  Interrupt Active bit Register */
+        uint32_t RESERVED4[16U];
+  __IOM uint32_t ITNS[16U];              /*!< Offset: 0x280 (R/W)  Interrupt Non-Secure State Register */
+        uint32_t RESERVED5[16U];
+  __IOM uint8_t  IPR[496U];              /*!< Offset: 0x300 (R/W)  Interrupt Priority Register (8Bit wide) */
+        uint32_t RESERVED6[580U];
+  __OM  uint32_t STIR;                   /*!< Offset: 0xE00 ( /W)  Software Trigger Interrupt Register */
+}  NVIC_Type;
+
+/* Software Triggered Interrupt Register Definitions */
+#define NVIC_STIR_INTID_Pos                 0U                                         /*!< STIR: INTLINESNUM Position */
+#define NVIC_STIR_INTID_Msk                (0x1FFUL /*<< NVIC_STIR_INTID_Pos*/)        /*!< STIR: INTLINESNUM Mask */
+
+/*@} end of group CMSIS_NVIC */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SCB     System Control Block (SCB)
+  \brief    Type definitions for the System Control Block Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Control Block (SCB).
+ */
+typedef struct
+{
+  __IM  uint32_t CPUID;                  /*!< Offset: 0x000 (R/ )  CPUID Base Register */
+  __IOM uint32_t ICSR;                   /*!< Offset: 0x004 (R/W)  Interrupt Control and State Register */
+  __IOM uint32_t VTOR;                   /*!< Offset: 0x008 (R/W)  Vector Table Offset Register */
+  __IOM uint32_t AIRCR;                  /*!< Offset: 0x00C (R/W)  Application Interrupt and Reset Control Register */
+  __IOM uint32_t SCR;                    /*!< Offset: 0x010 (R/W)  System Control Register */
+  __IOM uint32_t CCR;                    /*!< Offset: 0x014 (R/W)  Configuration Control Register */
+  __IOM uint8_t  SHPR[12U];              /*!< Offset: 0x018 (R/W)  System Handlers Priority Registers (4-7, 8-11, 12-15) */
+  __IOM uint32_t SHCSR;                  /*!< Offset: 0x024 (R/W)  System Handler Control and State Register */
+  __IOM uint32_t CFSR;                   /*!< Offset: 0x028 (R/W)  Configurable Fault Status Register */
+  __IOM uint32_t HFSR;                   /*!< Offset: 0x02C (R/W)  HardFault Status Register */
+  __IOM uint32_t DFSR;                   /*!< Offset: 0x030 (R/W)  Debug Fault Status Register */
+  __IOM uint32_t MMFAR;                  /*!< Offset: 0x034 (R/W)  MemManage Fault Address Register */
+  __IOM uint32_t BFAR;                   /*!< Offset: 0x038 (R/W)  BusFault Address Register */
+  __IOM uint32_t AFSR;                   /*!< Offset: 0x03C (R/W)  Auxiliary Fault Status Register */
+  __IM  uint32_t ID_PFR[2U];             /*!< Offset: 0x040 (R/ )  Processor Feature Register */
+  __IM  uint32_t ID_DFR;                 /*!< Offset: 0x048 (R/ )  Debug Feature Register */
+  __IM  uint32_t ID_ADR;                 /*!< Offset: 0x04C (R/ )  Auxiliary Feature Register */
+  __IM  uint32_t ID_MMFR[4U];            /*!< Offset: 0x050 (R/ )  Memory Model Feature Register */
+  __IM  uint32_t ID_ISAR[6U];            /*!< Offset: 0x060 (R/ )  Instruction Set Attributes Register */
+  __IM  uint32_t CLIDR;                  /*!< Offset: 0x078 (R/ )  Cache Level ID register */
+  __IM  uint32_t CTR;                    /*!< Offset: 0x07C (R/ )  Cache Type register */
+  __IM  uint32_t CCSIDR;                 /*!< Offset: 0x080 (R/ )  Cache Size ID Register */
+  __IOM uint32_t CSSELR;                 /*!< Offset: 0x084 (R/W)  Cache Size Selection Register */
+  __IOM uint32_t CPACR;                  /*!< Offset: 0x088 (R/W)  Coprocessor Access Control Register */
+  __IOM uint32_t NSACR;                  /*!< Offset: 0x08C (R/W)  Non-Secure Access Control Register */
+        uint32_t RESERVED3[92U];
+  __OM  uint32_t STIR;                   /*!< Offset: 0x200 ( /W)  Software Triggered Interrupt Register */
+        uint32_t RESERVED4[15U];
+  __IM  uint32_t MVFR0;                  /*!< Offset: 0x240 (R/ )  Media and VFP Feature Register 0 */
+  __IM  uint32_t MVFR1;                  /*!< Offset: 0x244 (R/ )  Media and VFP Feature Register 1 */
+  __IM  uint32_t MVFR2;                  /*!< Offset: 0x248 (R/ )  Media and VFP Feature Register 2 */
+        uint32_t RESERVED5[1U];
+  __OM  uint32_t ICIALLU;                /*!< Offset: 0x250 ( /W)  I-Cache Invalidate All to PoU */
+        uint32_t RESERVED6[1U];
+  __OM  uint32_t ICIMVAU;                /*!< Offset: 0x258 ( /W)  I-Cache Invalidate by MVA to PoU */
+  __OM  uint32_t DCIMVAC;                /*!< Offset: 0x25C ( /W)  D-Cache Invalidate by MVA to PoC */
+  __OM  uint32_t DCISW;                  /*!< Offset: 0x260 ( /W)  D-Cache Invalidate by Set-way */
+  __OM  uint32_t DCCMVAU;                /*!< Offset: 0x264 ( /W)  D-Cache Clean by MVA to PoU */
+  __OM  uint32_t DCCMVAC;                /*!< Offset: 0x268 ( /W)  D-Cache Clean by MVA to PoC */
+  __OM  uint32_t DCCSW;                  /*!< Offset: 0x26C ( /W)  D-Cache Clean by Set-way */
+  __OM  uint32_t DCCIMVAC;               /*!< Offset: 0x270 ( /W)  D-Cache Clean and Invalidate by MVA to PoC */
+  __OM  uint32_t DCCISW;                 /*!< Offset: 0x274 ( /W)  D-Cache Clean and Invalidate by Set-way */
+} SCB_Type;
+
+/* SCB CPUID Register Definitions */
+#define SCB_CPUID_IMPLEMENTER_Pos          24U                                            /*!< SCB CPUID: IMPLEMENTER Position */
+#define SCB_CPUID_IMPLEMENTER_Msk          (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos)          /*!< SCB CPUID: IMPLEMENTER Mask */
+
+#define SCB_CPUID_VARIANT_Pos              20U                                            /*!< SCB CPUID: VARIANT Position */
+#define SCB_CPUID_VARIANT_Msk              (0xFUL << SCB_CPUID_VARIANT_Pos)               /*!< SCB CPUID: VARIANT Mask */
+
+#define SCB_CPUID_ARCHITECTURE_Pos         16U                                            /*!< SCB CPUID: ARCHITECTURE Position */
+#define SCB_CPUID_ARCHITECTURE_Msk         (0xFUL << SCB_CPUID_ARCHITECTURE_Pos)          /*!< SCB CPUID: ARCHITECTURE Mask */
+
+#define SCB_CPUID_PARTNO_Pos                4U                                            /*!< SCB CPUID: PARTNO Position */
+#define SCB_CPUID_PARTNO_Msk               (0xFFFUL << SCB_CPUID_PARTNO_Pos)              /*!< SCB CPUID: PARTNO Mask */
+
+#define SCB_CPUID_REVISION_Pos              0U                                            /*!< SCB CPUID: REVISION Position */
+#define SCB_CPUID_REVISION_Msk             (0xFUL /*<< SCB_CPUID_REVISION_Pos*/)          /*!< SCB CPUID: REVISION Mask */
+
+/* SCB Interrupt Control State Register Definitions */
+#define SCB_ICSR_PENDNMISET_Pos            31U                                            /*!< SCB ICSR: PENDNMISET Position */
+#define SCB_ICSR_PENDNMISET_Msk            (1UL << SCB_ICSR_PENDNMISET_Pos)               /*!< SCB ICSR: PENDNMISET Mask */
+
+#define SCB_ICSR_NMIPENDSET_Pos            SCB_ICSR_PENDNMISET_Pos                        /*!< SCB ICSR: NMIPENDSET Position, backward compatibility */
+#define SCB_ICSR_NMIPENDSET_Msk            SCB_ICSR_PENDNMISET_Msk                        /*!< SCB ICSR: NMIPENDSET Mask, backward compatibility */
+
+#define SCB_ICSR_PENDNMICLR_Pos            30U                                            /*!< SCB ICSR: PENDNMICLR Position */
+#define SCB_ICSR_PENDNMICLR_Msk            (1UL << SCB_ICSR_PENDNMICLR_Pos)               /*!< SCB ICSR: PENDNMICLR Mask */
+
+#define SCB_ICSR_PENDSVSET_Pos             28U                                            /*!< SCB ICSR: PENDSVSET Position */
+#define SCB_ICSR_PENDSVSET_Msk             (1UL << SCB_ICSR_PENDSVSET_Pos)                /*!< SCB ICSR: PENDSVSET Mask */
+
+#define SCB_ICSR_PENDSVCLR_Pos             27U                                            /*!< SCB ICSR: PENDSVCLR Position */
+#define SCB_ICSR_PENDSVCLR_Msk             (1UL << SCB_ICSR_PENDSVCLR_Pos)                /*!< SCB ICSR: PENDSVCLR Mask */
+
+#define SCB_ICSR_PENDSTSET_Pos             26U                                            /*!< SCB ICSR: PENDSTSET Position */
+#define SCB_ICSR_PENDSTSET_Msk             (1UL << SCB_ICSR_PENDSTSET_Pos)                /*!< SCB ICSR: PENDSTSET Mask */
+
+#define SCB_ICSR_PENDSTCLR_Pos             25U                                            /*!< SCB ICSR: PENDSTCLR Position */
+#define SCB_ICSR_PENDSTCLR_Msk             (1UL << SCB_ICSR_PENDSTCLR_Pos)                /*!< SCB ICSR: PENDSTCLR Mask */
+
+#define SCB_ICSR_STTNS_Pos                 24U                                            /*!< SCB ICSR: STTNS Position (Security Extension) */
+#define SCB_ICSR_STTNS_Msk                 (1UL << SCB_ICSR_STTNS_Pos)                    /*!< SCB ICSR: STTNS Mask (Security Extension) */
+
+#define SCB_ICSR_ISRPREEMPT_Pos            23U                                            /*!< SCB ICSR: ISRPREEMPT Position */
+#define SCB_ICSR_ISRPREEMPT_Msk            (1UL << SCB_ICSR_ISRPREEMPT_Pos)               /*!< SCB ICSR: ISRPREEMPT Mask */
+
+#define SCB_ICSR_ISRPENDING_Pos            22U                                            /*!< SCB ICSR: ISRPENDING Position */
+#define SCB_ICSR_ISRPENDING_Msk            (1UL << SCB_ICSR_ISRPENDING_Pos)               /*!< SCB ICSR: ISRPENDING Mask */
+
+#define SCB_ICSR_VECTPENDING_Pos           12U                                            /*!< SCB ICSR: VECTPENDING Position */
+#define SCB_ICSR_VECTPENDING_Msk           (0x1FFUL << SCB_ICSR_VECTPENDING_Pos)          /*!< SCB ICSR: VECTPENDING Mask */
+
+#define SCB_ICSR_RETTOBASE_Pos             11U                                            /*!< SCB ICSR: RETTOBASE Position */
+#define SCB_ICSR_RETTOBASE_Msk             (1UL << SCB_ICSR_RETTOBASE_Pos)                /*!< SCB ICSR: RETTOBASE Mask */
+
+#define SCB_ICSR_VECTACTIVE_Pos             0U                                            /*!< SCB ICSR: VECTACTIVE Position */
+#define SCB_ICSR_VECTACTIVE_Msk            (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/)       /*!< SCB ICSR: VECTACTIVE Mask */
+
+/* SCB Vector Table Offset Register Definitions */
+#define SCB_VTOR_TBLOFF_Pos                 7U                                            /*!< SCB VTOR: TBLOFF Position */
+#define SCB_VTOR_TBLOFF_Msk                (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos)           /*!< SCB VTOR: TBLOFF Mask */
+
+/* SCB Application Interrupt and Reset Control Register Definitions */
+#define SCB_AIRCR_VECTKEY_Pos              16U                                            /*!< SCB AIRCR: VECTKEY Position */
+#define SCB_AIRCR_VECTKEY_Msk              (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos)            /*!< SCB AIRCR: VECTKEY Mask */
+
+#define SCB_AIRCR_VECTKEYSTAT_Pos          16U                                            /*!< SCB AIRCR: VECTKEYSTAT Position */
+#define SCB_AIRCR_VECTKEYSTAT_Msk          (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos)        /*!< SCB AIRCR: VECTKEYSTAT Mask */
+
+#define SCB_AIRCR_ENDIANESS_Pos            15U                                            /*!< SCB AIRCR: ENDIANESS Position */
+#define SCB_AIRCR_ENDIANESS_Msk            (1UL << SCB_AIRCR_ENDIANESS_Pos)               /*!< SCB AIRCR: ENDIANESS Mask */
+
+#define SCB_AIRCR_PRIS_Pos                 14U                                            /*!< SCB AIRCR: PRIS Position */
+#define SCB_AIRCR_PRIS_Msk                 (1UL << SCB_AIRCR_PRIS_Pos)                    /*!< SCB AIRCR: PRIS Mask */
+
+#define SCB_AIRCR_BFHFNMINS_Pos            13U                                            /*!< SCB AIRCR: BFHFNMINS Position */
+#define SCB_AIRCR_BFHFNMINS_Msk            (1UL << SCB_AIRCR_BFHFNMINS_Pos)               /*!< SCB AIRCR: BFHFNMINS Mask */
+
+#define SCB_AIRCR_PRIGROUP_Pos              8U                                            /*!< SCB AIRCR: PRIGROUP Position */
+#define SCB_AIRCR_PRIGROUP_Msk             (7UL << SCB_AIRCR_PRIGROUP_Pos)                /*!< SCB AIRCR: PRIGROUP Mask */
+
+#define SCB_AIRCR_SYSRESETREQS_Pos          3U                                            /*!< SCB AIRCR: SYSRESETREQS Position */
+#define SCB_AIRCR_SYSRESETREQS_Msk         (1UL << SCB_AIRCR_SYSRESETREQS_Pos)            /*!< SCB AIRCR: SYSRESETREQS Mask */
+
+#define SCB_AIRCR_SYSRESETREQ_Pos           2U                                            /*!< SCB AIRCR: SYSRESETREQ Position */
+#define SCB_AIRCR_SYSRESETREQ_Msk          (1UL << SCB_AIRCR_SYSRESETREQ_Pos)             /*!< SCB AIRCR: SYSRESETREQ Mask */
+
+#define SCB_AIRCR_VECTCLRACTIVE_Pos         1U                                            /*!< SCB AIRCR: VECTCLRACTIVE Position */
+#define SCB_AIRCR_VECTCLRACTIVE_Msk        (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos)           /*!< SCB AIRCR: VECTCLRACTIVE Mask */
+
+/* SCB System Control Register Definitions */
+#define SCB_SCR_SEVONPEND_Pos               4U                                            /*!< SCB SCR: SEVONPEND Position */
+#define SCB_SCR_SEVONPEND_Msk              (1UL << SCB_SCR_SEVONPEND_Pos)                 /*!< SCB SCR: SEVONPEND Mask */
+
+#define SCB_SCR_SLEEPDEEPS_Pos              3U                                            /*!< SCB SCR: SLEEPDEEPS Position */
+#define SCB_SCR_SLEEPDEEPS_Msk             (1UL << SCB_SCR_SLEEPDEEPS_Pos)                /*!< SCB SCR: SLEEPDEEPS Mask */
+
+#define SCB_SCR_SLEEPDEEP_Pos               2U                                            /*!< SCB SCR: SLEEPDEEP Position */
+#define SCB_SCR_SLEEPDEEP_Msk              (1UL << SCB_SCR_SLEEPDEEP_Pos)                 /*!< SCB SCR: SLEEPDEEP Mask */
+
+#define SCB_SCR_SLEEPONEXIT_Pos             1U                                            /*!< SCB SCR: SLEEPONEXIT Position */
+#define SCB_SCR_SLEEPONEXIT_Msk            (1UL << SCB_SCR_SLEEPONEXIT_Pos)               /*!< SCB SCR: SLEEPONEXIT Mask */
+
+/* SCB Configuration Control Register Definitions */
+#define SCB_CCR_BP_Pos                     18U                                            /*!< SCB CCR: BP Position */
+#define SCB_CCR_BP_Msk                     (1UL << SCB_CCR_BP_Pos)                        /*!< SCB CCR: BP Mask */
+
+#define SCB_CCR_IC_Pos                     17U                                            /*!< SCB CCR: IC Position */
+#define SCB_CCR_IC_Msk                     (1UL << SCB_CCR_IC_Pos)                        /*!< SCB CCR: IC Mask */
+
+#define SCB_CCR_DC_Pos                     16U                                            /*!< SCB CCR: DC Position */
+#define SCB_CCR_DC_Msk                     (1UL << SCB_CCR_DC_Pos)                        /*!< SCB CCR: DC Mask */
+
+#define SCB_CCR_STKOFHFNMIGN_Pos           10U                                            /*!< SCB CCR: STKOFHFNMIGN Position */
+#define SCB_CCR_STKOFHFNMIGN_Msk           (1UL << SCB_CCR_STKOFHFNMIGN_Pos)              /*!< SCB CCR: STKOFHFNMIGN Mask */
+
+#define SCB_CCR_BFHFNMIGN_Pos               8U                                            /*!< SCB CCR: BFHFNMIGN Position */
+#define SCB_CCR_BFHFNMIGN_Msk              (1UL << SCB_CCR_BFHFNMIGN_Pos)                 /*!< SCB CCR: BFHFNMIGN Mask */
+
+#define SCB_CCR_DIV_0_TRP_Pos               4U                                            /*!< SCB CCR: DIV_0_TRP Position */
+#define SCB_CCR_DIV_0_TRP_Msk              (1UL << SCB_CCR_DIV_0_TRP_Pos)                 /*!< SCB CCR: DIV_0_TRP Mask */
+
+#define SCB_CCR_UNALIGN_TRP_Pos             3U                                            /*!< SCB CCR: UNALIGN_TRP Position */
+#define SCB_CCR_UNALIGN_TRP_Msk            (1UL << SCB_CCR_UNALIGN_TRP_Pos)               /*!< SCB CCR: UNALIGN_TRP Mask */
+
+#define SCB_CCR_USERSETMPEND_Pos            1U                                            /*!< SCB CCR: USERSETMPEND Position */
+#define SCB_CCR_USERSETMPEND_Msk           (1UL << SCB_CCR_USERSETMPEND_Pos)              /*!< SCB CCR: USERSETMPEND Mask */
+
+/* SCB System Handler Control and State Register Definitions */
+#define SCB_SHCSR_HARDFAULTPENDED_Pos      21U                                            /*!< SCB SHCSR: HARDFAULTPENDED Position */
+#define SCB_SHCSR_HARDFAULTPENDED_Msk      (1UL << SCB_SHCSR_HARDFAULTPENDED_Pos)         /*!< SCB SHCSR: HARDFAULTPENDED Mask */
+
+#define SCB_SHCSR_SECUREFAULTPENDED_Pos    20U                                            /*!< SCB SHCSR: SECUREFAULTPENDED Position */
+#define SCB_SHCSR_SECUREFAULTPENDED_Msk    (1UL << SCB_SHCSR_SECUREFAULTPENDED_Pos)       /*!< SCB SHCSR: SECUREFAULTPENDED Mask */
+
+#define SCB_SHCSR_SECUREFAULTENA_Pos       19U                                            /*!< SCB SHCSR: SECUREFAULTENA Position */
+#define SCB_SHCSR_SECUREFAULTENA_Msk       (1UL << SCB_SHCSR_SECUREFAULTENA_Pos)          /*!< SCB SHCSR: SECUREFAULTENA Mask */
+
+#define SCB_SHCSR_USGFAULTENA_Pos          18U                                            /*!< SCB SHCSR: USGFAULTENA Position */
+#define SCB_SHCSR_USGFAULTENA_Msk          (1UL << SCB_SHCSR_USGFAULTENA_Pos)             /*!< SCB SHCSR: USGFAULTENA Mask */
+
+#define SCB_SHCSR_BUSFAULTENA_Pos          17U                                            /*!< SCB SHCSR: BUSFAULTENA Position */
+#define SCB_SHCSR_BUSFAULTENA_Msk          (1UL << SCB_SHCSR_BUSFAULTENA_Pos)             /*!< SCB SHCSR: BUSFAULTENA Mask */
+
+#define SCB_SHCSR_MEMFAULTENA_Pos          16U                                            /*!< SCB SHCSR: MEMFAULTENA Position */
+#define SCB_SHCSR_MEMFAULTENA_Msk          (1UL << SCB_SHCSR_MEMFAULTENA_Pos)             /*!< SCB SHCSR: MEMFAULTENA Mask */
+
+#define SCB_SHCSR_SVCALLPENDED_Pos         15U                                            /*!< SCB SHCSR: SVCALLPENDED Position */
+#define SCB_SHCSR_SVCALLPENDED_Msk         (1UL << SCB_SHCSR_SVCALLPENDED_Pos)            /*!< SCB SHCSR: SVCALLPENDED Mask */
+
+#define SCB_SHCSR_BUSFAULTPENDED_Pos       14U                                            /*!< SCB SHCSR: BUSFAULTPENDED Position */
+#define SCB_SHCSR_BUSFAULTPENDED_Msk       (1UL << SCB_SHCSR_BUSFAULTPENDED_Pos)          /*!< SCB SHCSR: BUSFAULTPENDED Mask */
+
+#define SCB_SHCSR_MEMFAULTPENDED_Pos       13U                                            /*!< SCB SHCSR: MEMFAULTPENDED Position */
+#define SCB_SHCSR_MEMFAULTPENDED_Msk       (1UL << SCB_SHCSR_MEMFAULTPENDED_Pos)          /*!< SCB SHCSR: MEMFAULTPENDED Mask */
+
+#define SCB_SHCSR_USGFAULTPENDED_Pos       12U                                            /*!< SCB SHCSR: USGFAULTPENDED Position */
+#define SCB_SHCSR_USGFAULTPENDED_Msk       (1UL << SCB_SHCSR_USGFAULTPENDED_Pos)          /*!< SCB SHCSR: USGFAULTPENDED Mask */
+
+#define SCB_SHCSR_SYSTICKACT_Pos           11U                                            /*!< SCB SHCSR: SYSTICKACT Position */
+#define SCB_SHCSR_SYSTICKACT_Msk           (1UL << SCB_SHCSR_SYSTICKACT_Pos)              /*!< SCB SHCSR: SYSTICKACT Mask */
+
+#define SCB_SHCSR_PENDSVACT_Pos            10U                                            /*!< SCB SHCSR: PENDSVACT Position */
+#define SCB_SHCSR_PENDSVACT_Msk            (1UL << SCB_SHCSR_PENDSVACT_Pos)               /*!< SCB SHCSR: PENDSVACT Mask */
+
+#define SCB_SHCSR_MONITORACT_Pos            8U                                            /*!< SCB SHCSR: MONITORACT Position */
+#define SCB_SHCSR_MONITORACT_Msk           (1UL << SCB_SHCSR_MONITORACT_Pos)              /*!< SCB SHCSR: MONITORACT Mask */
+
+#define SCB_SHCSR_SVCALLACT_Pos             7U                                            /*!< SCB SHCSR: SVCALLACT Position */
+#define SCB_SHCSR_SVCALLACT_Msk            (1UL << SCB_SHCSR_SVCALLACT_Pos)               /*!< SCB SHCSR: SVCALLACT Mask */
+
+#define SCB_SHCSR_NMIACT_Pos                5U                                            /*!< SCB SHCSR: NMIACT Position */
+#define SCB_SHCSR_NMIACT_Msk               (1UL << SCB_SHCSR_NMIACT_Pos)                  /*!< SCB SHCSR: NMIACT Mask */
+
+#define SCB_SHCSR_SECUREFAULTACT_Pos        4U                                            /*!< SCB SHCSR: SECUREFAULTACT Position */
+#define SCB_SHCSR_SECUREFAULTACT_Msk       (1UL << SCB_SHCSR_SECUREFAULTACT_Pos)          /*!< SCB SHCSR: SECUREFAULTACT Mask */
+
+#define SCB_SHCSR_USGFAULTACT_Pos           3U                                            /*!< SCB SHCSR: USGFAULTACT Position */
+#define SCB_SHCSR_USGFAULTACT_Msk          (1UL << SCB_SHCSR_USGFAULTACT_Pos)             /*!< SCB SHCSR: USGFAULTACT Mask */
+
+#define SCB_SHCSR_HARDFAULTACT_Pos          2U                                            /*!< SCB SHCSR: HARDFAULTACT Position */
+#define SCB_SHCSR_HARDFAULTACT_Msk         (1UL << SCB_SHCSR_HARDFAULTACT_Pos)            /*!< SCB SHCSR: HARDFAULTACT Mask */
+
+#define SCB_SHCSR_BUSFAULTACT_Pos           1U                                            /*!< SCB SHCSR: BUSFAULTACT Position */
+#define SCB_SHCSR_BUSFAULTACT_Msk          (1UL << SCB_SHCSR_BUSFAULTACT_Pos)             /*!< SCB SHCSR: BUSFAULTACT Mask */
+
+#define SCB_SHCSR_MEMFAULTACT_Pos           0U                                            /*!< SCB SHCSR: MEMFAULTACT Position */
+#define SCB_SHCSR_MEMFAULTACT_Msk          (1UL /*<< SCB_SHCSR_MEMFAULTACT_Pos*/)         /*!< SCB SHCSR: MEMFAULTACT Mask */
+
+/* SCB Configurable Fault Status Register Definitions */
+#define SCB_CFSR_USGFAULTSR_Pos            16U                                            /*!< SCB CFSR: Usage Fault Status Register Position */
+#define SCB_CFSR_USGFAULTSR_Msk            (0xFFFFUL << SCB_CFSR_USGFAULTSR_Pos)          /*!< SCB CFSR: Usage Fault Status Register Mask */
+
+#define SCB_CFSR_BUSFAULTSR_Pos             8U                                            /*!< SCB CFSR: Bus Fault Status Register Position */
+#define SCB_CFSR_BUSFAULTSR_Msk            (0xFFUL << SCB_CFSR_BUSFAULTSR_Pos)            /*!< SCB CFSR: Bus Fault Status Register Mask */
+
+#define SCB_CFSR_MEMFAULTSR_Pos             0U                                            /*!< SCB CFSR: Memory Manage Fault Status Register Position */
+#define SCB_CFSR_MEMFAULTSR_Msk            (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/)        /*!< SCB CFSR: Memory Manage Fault Status Register Mask */
+
+/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_MMARVALID_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 7U)               /*!< SCB CFSR (MMFSR): MMARVALID Position */
+#define SCB_CFSR_MMARVALID_Msk             (1UL << SCB_CFSR_MMARVALID_Pos)                /*!< SCB CFSR (MMFSR): MMARVALID Mask */
+
+#define SCB_CFSR_MLSPERR_Pos               (SCB_SHCSR_MEMFAULTACT_Pos + 5U)               /*!< SCB CFSR (MMFSR): MLSPERR Position */
+#define SCB_CFSR_MLSPERR_Msk               (1UL << SCB_CFSR_MLSPERR_Pos)                  /*!< SCB CFSR (MMFSR): MLSPERR Mask */
+
+#define SCB_CFSR_MSTKERR_Pos               (SCB_SHCSR_MEMFAULTACT_Pos + 4U)               /*!< SCB CFSR (MMFSR): MSTKERR Position */
+#define SCB_CFSR_MSTKERR_Msk               (1UL << SCB_CFSR_MSTKERR_Pos)                  /*!< SCB CFSR (MMFSR): MSTKERR Mask */
+
+#define SCB_CFSR_MUNSTKERR_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 3U)               /*!< SCB CFSR (MMFSR): MUNSTKERR Position */
+#define SCB_CFSR_MUNSTKERR_Msk             (1UL << SCB_CFSR_MUNSTKERR_Pos)                /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */
+
+#define SCB_CFSR_DACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 1U)               /*!< SCB CFSR (MMFSR): DACCVIOL Position */
+#define SCB_CFSR_DACCVIOL_Msk              (1UL << SCB_CFSR_DACCVIOL_Pos)                 /*!< SCB CFSR (MMFSR): DACCVIOL Mask */
+
+#define SCB_CFSR_IACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 0U)               /*!< SCB CFSR (MMFSR): IACCVIOL Position */
+#define SCB_CFSR_IACCVIOL_Msk              (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/)             /*!< SCB CFSR (MMFSR): IACCVIOL Mask */
+
+/* BusFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_BFARVALID_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 7U)                  /*!< SCB CFSR (BFSR): BFARVALID Position */
+#define SCB_CFSR_BFARVALID_Msk            (1UL << SCB_CFSR_BFARVALID_Pos)                 /*!< SCB CFSR (BFSR): BFARVALID Mask */
+
+#define SCB_CFSR_LSPERR_Pos               (SCB_CFSR_BUSFAULTSR_Pos + 5U)                  /*!< SCB CFSR (BFSR): LSPERR Position */
+#define SCB_CFSR_LSPERR_Msk               (1UL << SCB_CFSR_LSPERR_Pos)                    /*!< SCB CFSR (BFSR): LSPERR Mask */
+
+#define SCB_CFSR_STKERR_Pos               (SCB_CFSR_BUSFAULTSR_Pos + 4U)                  /*!< SCB CFSR (BFSR): STKERR Position */
+#define SCB_CFSR_STKERR_Msk               (1UL << SCB_CFSR_STKERR_Pos)                    /*!< SCB CFSR (BFSR): STKERR Mask */
+
+#define SCB_CFSR_UNSTKERR_Pos             (SCB_CFSR_BUSFAULTSR_Pos + 3U)                  /*!< SCB CFSR (BFSR): UNSTKERR Position */
+#define SCB_CFSR_UNSTKERR_Msk             (1UL << SCB_CFSR_UNSTKERR_Pos)                  /*!< SCB CFSR (BFSR): UNSTKERR Mask */
+
+#define SCB_CFSR_IMPRECISERR_Pos          (SCB_CFSR_BUSFAULTSR_Pos + 2U)                  /*!< SCB CFSR (BFSR): IMPRECISERR Position */
+#define SCB_CFSR_IMPRECISERR_Msk          (1UL << SCB_CFSR_IMPRECISERR_Pos)               /*!< SCB CFSR (BFSR): IMPRECISERR Mask */
+
+#define SCB_CFSR_PRECISERR_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 1U)                  /*!< SCB CFSR (BFSR): PRECISERR Position */
+#define SCB_CFSR_PRECISERR_Msk            (1UL << SCB_CFSR_PRECISERR_Pos)                 /*!< SCB CFSR (BFSR): PRECISERR Mask */
+
+#define SCB_CFSR_IBUSERR_Pos              (SCB_CFSR_BUSFAULTSR_Pos + 0U)                  /*!< SCB CFSR (BFSR): IBUSERR Position */
+#define SCB_CFSR_IBUSERR_Msk              (1UL << SCB_CFSR_IBUSERR_Pos)                   /*!< SCB CFSR (BFSR): IBUSERR Mask */
+
+/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_DIVBYZERO_Pos            (SCB_CFSR_USGFAULTSR_Pos + 9U)                  /*!< SCB CFSR (UFSR): DIVBYZERO Position */
+#define SCB_CFSR_DIVBYZERO_Msk            (1UL << SCB_CFSR_DIVBYZERO_Pos)                 /*!< SCB CFSR (UFSR): DIVBYZERO Mask */
+
+#define SCB_CFSR_UNALIGNED_Pos            (SCB_CFSR_USGFAULTSR_Pos + 8U)                  /*!< SCB CFSR (UFSR): UNALIGNED Position */
+#define SCB_CFSR_UNALIGNED_Msk            (1UL << SCB_CFSR_UNALIGNED_Pos)                 /*!< SCB CFSR (UFSR): UNALIGNED Mask */
+
+#define SCB_CFSR_STKOF_Pos                (SCB_CFSR_USGFAULTSR_Pos + 4U)                  /*!< SCB CFSR (UFSR): STKOF Position */
+#define SCB_CFSR_STKOF_Msk                (1UL << SCB_CFSR_STKOF_Pos)                     /*!< SCB CFSR (UFSR): STKOF Mask */
+
+#define SCB_CFSR_NOCP_Pos                 (SCB_CFSR_USGFAULTSR_Pos + 3U)                  /*!< SCB CFSR (UFSR): NOCP Position */
+#define SCB_CFSR_NOCP_Msk                 (1UL << SCB_CFSR_NOCP_Pos)                      /*!< SCB CFSR (UFSR): NOCP Mask */
+
+#define SCB_CFSR_INVPC_Pos                (SCB_CFSR_USGFAULTSR_Pos + 2U)                  /*!< SCB CFSR (UFSR): INVPC Position */
+#define SCB_CFSR_INVPC_Msk                (1UL << SCB_CFSR_INVPC_Pos)                     /*!< SCB CFSR (UFSR): INVPC Mask */
+
+#define SCB_CFSR_INVSTATE_Pos             (SCB_CFSR_USGFAULTSR_Pos + 1U)                  /*!< SCB CFSR (UFSR): INVSTATE Position */
+#define SCB_CFSR_INVSTATE_Msk             (1UL << SCB_CFSR_INVSTATE_Pos)                  /*!< SCB CFSR (UFSR): INVSTATE Mask */
+
+#define SCB_CFSR_UNDEFINSTR_Pos           (SCB_CFSR_USGFAULTSR_Pos + 0U)                  /*!< SCB CFSR (UFSR): UNDEFINSTR Position */
+#define SCB_CFSR_UNDEFINSTR_Msk           (1UL << SCB_CFSR_UNDEFINSTR_Pos)                /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */
+
+/* SCB Hard Fault Status Register Definitions */
+#define SCB_HFSR_DEBUGEVT_Pos              31U                                            /*!< SCB HFSR: DEBUGEVT Position */
+#define SCB_HFSR_DEBUGEVT_Msk              (1UL << SCB_HFSR_DEBUGEVT_Pos)                 /*!< SCB HFSR: DEBUGEVT Mask */
+
+#define SCB_HFSR_FORCED_Pos                30U                                            /*!< SCB HFSR: FORCED Position */
+#define SCB_HFSR_FORCED_Msk                (1UL << SCB_HFSR_FORCED_Pos)                   /*!< SCB HFSR: FORCED Mask */
+
+#define SCB_HFSR_VECTTBL_Pos                1U                                            /*!< SCB HFSR: VECTTBL Position */
+#define SCB_HFSR_VECTTBL_Msk               (1UL << SCB_HFSR_VECTTBL_Pos)                  /*!< SCB HFSR: VECTTBL Mask */
+
+/* SCB Debug Fault Status Register Definitions */
+#define SCB_DFSR_EXTERNAL_Pos               4U                                            /*!< SCB DFSR: EXTERNAL Position */
+#define SCB_DFSR_EXTERNAL_Msk              (1UL << SCB_DFSR_EXTERNAL_Pos)                 /*!< SCB DFSR: EXTERNAL Mask */
+
+#define SCB_DFSR_VCATCH_Pos                 3U                                            /*!< SCB DFSR: VCATCH Position */
+#define SCB_DFSR_VCATCH_Msk                (1UL << SCB_DFSR_VCATCH_Pos)                   /*!< SCB DFSR: VCATCH Mask */
+
+#define SCB_DFSR_DWTTRAP_Pos                2U                                            /*!< SCB DFSR: DWTTRAP Position */
+#define SCB_DFSR_DWTTRAP_Msk               (1UL << SCB_DFSR_DWTTRAP_Pos)                  /*!< SCB DFSR: DWTTRAP Mask */
+
+#define SCB_DFSR_BKPT_Pos                   1U                                            /*!< SCB DFSR: BKPT Position */
+#define SCB_DFSR_BKPT_Msk                  (1UL << SCB_DFSR_BKPT_Pos)                     /*!< SCB DFSR: BKPT Mask */
+
+#define SCB_DFSR_HALTED_Pos                 0U                                            /*!< SCB DFSR: HALTED Position */
+#define SCB_DFSR_HALTED_Msk                (1UL /*<< SCB_DFSR_HALTED_Pos*/)               /*!< SCB DFSR: HALTED Mask */
+
+/* SCB Non-Secure Access Control Register Definitions */
+#define SCB_NSACR_CP11_Pos                 11U                                            /*!< SCB NSACR: CP11 Position */
+#define SCB_NSACR_CP11_Msk                 (1UL << SCB_NSACR_CP11_Pos)                    /*!< SCB NSACR: CP11 Mask */
+
+#define SCB_NSACR_CP10_Pos                 10U                                            /*!< SCB NSACR: CP10 Position */
+#define SCB_NSACR_CP10_Msk                 (1UL << SCB_NSACR_CP10_Pos)                    /*!< SCB NSACR: CP10 Mask */
+
+#define SCB_NSACR_CPn_Pos                   0U                                            /*!< SCB NSACR: CPn Position */
+#define SCB_NSACR_CPn_Msk                  (1UL /*<< SCB_NSACR_CPn_Pos*/)                 /*!< SCB NSACR: CPn Mask */
+
+/* SCB Cache Level ID Register Definitions */
+#define SCB_CLIDR_LOUU_Pos                 27U                                            /*!< SCB CLIDR: LoUU Position */
+#define SCB_CLIDR_LOUU_Msk                 (7UL << SCB_CLIDR_LOUU_Pos)                    /*!< SCB CLIDR: LoUU Mask */
+
+#define SCB_CLIDR_LOC_Pos                  24U                                            /*!< SCB CLIDR: LoC Position */
+#define SCB_CLIDR_LOC_Msk                  (7UL << SCB_CLIDR_LOC_Pos)                     /*!< SCB CLIDR: LoC Mask */
+
+/* SCB Cache Type Register Definitions */
+#define SCB_CTR_FORMAT_Pos                 29U                                            /*!< SCB CTR: Format Position */
+#define SCB_CTR_FORMAT_Msk                 (7UL << SCB_CTR_FORMAT_Pos)                    /*!< SCB CTR: Format Mask */
+
+#define SCB_CTR_CWG_Pos                    24U                                            /*!< SCB CTR: CWG Position */
+#define SCB_CTR_CWG_Msk                    (0xFUL << SCB_CTR_CWG_Pos)                     /*!< SCB CTR: CWG Mask */
+
+#define SCB_CTR_ERG_Pos                    20U                                            /*!< SCB CTR: ERG Position */
+#define SCB_CTR_ERG_Msk                    (0xFUL << SCB_CTR_ERG_Pos)                     /*!< SCB CTR: ERG Mask */
+
+#define SCB_CTR_DMINLINE_Pos               16U                                            /*!< SCB CTR: DminLine Position */
+#define SCB_CTR_DMINLINE_Msk               (0xFUL << SCB_CTR_DMINLINE_Pos)                /*!< SCB CTR: DminLine Mask */
+
+#define SCB_CTR_IMINLINE_Pos                0U                                            /*!< SCB CTR: ImInLine Position */
+#define SCB_CTR_IMINLINE_Msk               (0xFUL /*<< SCB_CTR_IMINLINE_Pos*/)            /*!< SCB CTR: ImInLine Mask */
+
+/* SCB Cache Size ID Register Definitions */
+#define SCB_CCSIDR_WT_Pos                  31U                                            /*!< SCB CCSIDR: WT Position */
+#define SCB_CCSIDR_WT_Msk                  (1UL << SCB_CCSIDR_WT_Pos)                     /*!< SCB CCSIDR: WT Mask */
+
+#define SCB_CCSIDR_WB_Pos                  30U                                            /*!< SCB CCSIDR: WB Position */
+#define SCB_CCSIDR_WB_Msk                  (1UL << SCB_CCSIDR_WB_Pos)                     /*!< SCB CCSIDR: WB Mask */
+
+#define SCB_CCSIDR_RA_Pos                  29U                                            /*!< SCB CCSIDR: RA Position */
+#define SCB_CCSIDR_RA_Msk                  (1UL << SCB_CCSIDR_RA_Pos)                     /*!< SCB CCSIDR: RA Mask */
+
+#define SCB_CCSIDR_WA_Pos                  28U                                            /*!< SCB CCSIDR: WA Position */
+#define SCB_CCSIDR_WA_Msk                  (1UL << SCB_CCSIDR_WA_Pos)                     /*!< SCB CCSIDR: WA Mask */
+
+#define SCB_CCSIDR_NUMSETS_Pos             13U                                            /*!< SCB CCSIDR: NumSets Position */
+#define SCB_CCSIDR_NUMSETS_Msk             (0x7FFFUL << SCB_CCSIDR_NUMSETS_Pos)           /*!< SCB CCSIDR: NumSets Mask */
+
+#define SCB_CCSIDR_ASSOCIATIVITY_Pos        3U                                            /*!< SCB CCSIDR: Associativity Position */
+#define SCB_CCSIDR_ASSOCIATIVITY_Msk       (0x3FFUL << SCB_CCSIDR_ASSOCIATIVITY_Pos)      /*!< SCB CCSIDR: Associativity Mask */
+
+#define SCB_CCSIDR_LINESIZE_Pos             0U                                            /*!< SCB CCSIDR: LineSize Position */
+#define SCB_CCSIDR_LINESIZE_Msk            (7UL /*<< SCB_CCSIDR_LINESIZE_Pos*/)           /*!< SCB CCSIDR: LineSize Mask */
+
+/* SCB Cache Size Selection Register Definitions */
+#define SCB_CSSELR_LEVEL_Pos                1U                                            /*!< SCB CSSELR: Level Position */
+#define SCB_CSSELR_LEVEL_Msk               (7UL << SCB_CSSELR_LEVEL_Pos)                  /*!< SCB CSSELR: Level Mask */
+
+#define SCB_CSSELR_IND_Pos                  0U                                            /*!< SCB CSSELR: InD Position */
+#define SCB_CSSELR_IND_Msk                 (1UL /*<< SCB_CSSELR_IND_Pos*/)                /*!< SCB CSSELR: InD Mask */
+
+/* SCB Software Triggered Interrupt Register Definitions */
+#define SCB_STIR_INTID_Pos                  0U                                            /*!< SCB STIR: INTID Position */
+#define SCB_STIR_INTID_Msk                 (0x1FFUL /*<< SCB_STIR_INTID_Pos*/)            /*!< SCB STIR: INTID Mask */
+
+/* SCB D-Cache Invalidate by Set-way Register Definitions */
+#define SCB_DCISW_WAY_Pos                  30U                                            /*!< SCB DCISW: Way Position */
+#define SCB_DCISW_WAY_Msk                  (3UL << SCB_DCISW_WAY_Pos)                     /*!< SCB DCISW: Way Mask */
+
+#define SCB_DCISW_SET_Pos                   5U                                            /*!< SCB DCISW: Set Position */
+#define SCB_DCISW_SET_Msk                  (0x1FFUL << SCB_DCISW_SET_Pos)                 /*!< SCB DCISW: Set Mask */
+
+/* SCB D-Cache Clean by Set-way Register Definitions */
+#define SCB_DCCSW_WAY_Pos                  30U                                            /*!< SCB DCCSW: Way Position */
+#define SCB_DCCSW_WAY_Msk                  (3UL << SCB_DCCSW_WAY_Pos)                     /*!< SCB DCCSW: Way Mask */
+
+#define SCB_DCCSW_SET_Pos                   5U                                            /*!< SCB DCCSW: Set Position */
+#define SCB_DCCSW_SET_Msk                  (0x1FFUL << SCB_DCCSW_SET_Pos)                 /*!< SCB DCCSW: Set Mask */
+
+/* SCB D-Cache Clean and Invalidate by Set-way Register Definitions */
+#define SCB_DCCISW_WAY_Pos                 30U                                            /*!< SCB DCCISW: Way Position */
+#define SCB_DCCISW_WAY_Msk                 (3UL << SCB_DCCISW_WAY_Pos)                    /*!< SCB DCCISW: Way Mask */
+
+#define SCB_DCCISW_SET_Pos                  5U                                            /*!< SCB DCCISW: Set Position */
+#define SCB_DCCISW_SET_Msk                 (0x1FFUL << SCB_DCCISW_SET_Pos)                /*!< SCB DCCISW: Set Mask */
+
+/*@} end of group CMSIS_SCB */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB)
+  \brief    Type definitions for the System Control and ID Register not in the SCB
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Control and ID Register not in the SCB.
+ */
+typedef struct
+{
+        uint32_t RESERVED0[1U];
+  __IM  uint32_t ICTR;                   /*!< Offset: 0x004 (R/ )  Interrupt Controller Type Register */
+  __IOM uint32_t ACTLR;                  /*!< Offset: 0x008 (R/W)  Auxiliary Control Register */
+  __IOM uint32_t CPPWR;                  /*!< Offset: 0x00C (R/W)  Coprocessor Power Control  Register */
+} SCnSCB_Type;
+
+/* Interrupt Controller Type Register Definitions */
+#define SCnSCB_ICTR_INTLINESNUM_Pos         0U                                         /*!< ICTR: INTLINESNUM Position */
+#define SCnSCB_ICTR_INTLINESNUM_Msk        (0xFUL /*<< SCnSCB_ICTR_INTLINESNUM_Pos*/)  /*!< ICTR: INTLINESNUM Mask */
+
+/*@} end of group CMSIS_SCnotSCB */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SysTick     System Tick Timer (SysTick)
+  \brief    Type definitions for the System Timer Registers.
+  @{
+ */
+
+/**
+  \brief  Structure type to access the System Timer (SysTick).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  SysTick Control and Status Register */
+  __IOM uint32_t LOAD;                   /*!< Offset: 0x004 (R/W)  SysTick Reload Value Register */
+  __IOM uint32_t VAL;                    /*!< Offset: 0x008 (R/W)  SysTick Current Value Register */
+  __IM  uint32_t CALIB;                  /*!< Offset: 0x00C (R/ )  SysTick Calibration Register */
+} SysTick_Type;
+
+/* SysTick Control / Status Register Definitions */
+#define SysTick_CTRL_COUNTFLAG_Pos         16U                                            /*!< SysTick CTRL: COUNTFLAG Position */
+#define SysTick_CTRL_COUNTFLAG_Msk         (1UL << SysTick_CTRL_COUNTFLAG_Pos)            /*!< SysTick CTRL: COUNTFLAG Mask */
+
+#define SysTick_CTRL_CLKSOURCE_Pos          2U                                            /*!< SysTick CTRL: CLKSOURCE Position */
+#define SysTick_CTRL_CLKSOURCE_Msk         (1UL << SysTick_CTRL_CLKSOURCE_Pos)            /*!< SysTick CTRL: CLKSOURCE Mask */
+
+#define SysTick_CTRL_TICKINT_Pos            1U                                            /*!< SysTick CTRL: TICKINT Position */
+#define SysTick_CTRL_TICKINT_Msk           (1UL << SysTick_CTRL_TICKINT_Pos)              /*!< SysTick CTRL: TICKINT Mask */
+
+#define SysTick_CTRL_ENABLE_Pos             0U                                            /*!< SysTick CTRL: ENABLE Position */
+#define SysTick_CTRL_ENABLE_Msk            (1UL /*<< SysTick_CTRL_ENABLE_Pos*/)           /*!< SysTick CTRL: ENABLE Mask */
+
+/* SysTick Reload Register Definitions */
+#define SysTick_LOAD_RELOAD_Pos             0U                                            /*!< SysTick LOAD: RELOAD Position */
+#define SysTick_LOAD_RELOAD_Msk            (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/)    /*!< SysTick LOAD: RELOAD Mask */
+
+/* SysTick Current Register Definitions */
+#define SysTick_VAL_CURRENT_Pos             0U                                            /*!< SysTick VAL: CURRENT Position */
+#define SysTick_VAL_CURRENT_Msk            (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/)    /*!< SysTick VAL: CURRENT Mask */
+
+/* SysTick Calibration Register Definitions */
+#define SysTick_CALIB_NOREF_Pos            31U                                            /*!< SysTick CALIB: NOREF Position */
+#define SysTick_CALIB_NOREF_Msk            (1UL << SysTick_CALIB_NOREF_Pos)               /*!< SysTick CALIB: NOREF Mask */
+
+#define SysTick_CALIB_SKEW_Pos             30U                                            /*!< SysTick CALIB: SKEW Position */
+#define SysTick_CALIB_SKEW_Msk             (1UL << SysTick_CALIB_SKEW_Pos)                /*!< SysTick CALIB: SKEW Mask */
+
+#define SysTick_CALIB_TENMS_Pos             0U                                            /*!< SysTick CALIB: TENMS Position */
+#define SysTick_CALIB_TENMS_Msk            (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/)    /*!< SysTick CALIB: TENMS Mask */
+
+/*@} end of group CMSIS_SysTick */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_ITM     Instrumentation Trace Macrocell (ITM)
+  \brief    Type definitions for the Instrumentation Trace Macrocell (ITM)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Instrumentation Trace Macrocell Register (ITM).
+ */
+typedef struct
+{
+  __OM  union
+  {
+    __OM  uint8_t    u8;                 /*!< Offset: 0x000 ( /W)  ITM Stimulus Port 8-bit */
+    __OM  uint16_t   u16;                /*!< Offset: 0x000 ( /W)  ITM Stimulus Port 16-bit */
+    __OM  uint32_t   u32;                /*!< Offset: 0x000 ( /W)  ITM Stimulus Port 32-bit */
+  }  PORT [32U];                         /*!< Offset: 0x000 ( /W)  ITM Stimulus Port Registers */
+        uint32_t RESERVED0[864U];
+  __IOM uint32_t TER;                    /*!< Offset: 0xE00 (R/W)  ITM Trace Enable Register */
+        uint32_t RESERVED1[15U];
+  __IOM uint32_t TPR;                    /*!< Offset: 0xE40 (R/W)  ITM Trace Privilege Register */
+        uint32_t RESERVED2[15U];
+  __IOM uint32_t TCR;                    /*!< Offset: 0xE80 (R/W)  ITM Trace Control Register */
+        uint32_t RESERVED3[32U];
+        uint32_t RESERVED4[43U];
+  __OM  uint32_t LAR;                    /*!< Offset: 0xFB0 ( /W)  ITM Lock Access Register */
+  __IM  uint32_t LSR;                    /*!< Offset: 0xFB4 (R/ )  ITM Lock Status Register */
+        uint32_t RESERVED5[1U];
+  __IM  uint32_t DEVARCH;                /*!< Offset: 0xFBC (R/ )  ITM Device Architecture Register */
+        uint32_t RESERVED6[4U];
+  __IM  uint32_t PID4;                   /*!< Offset: 0xFD0 (R/ )  ITM Peripheral Identification Register #4 */
+  __IM  uint32_t PID5;                   /*!< Offset: 0xFD4 (R/ )  ITM Peripheral Identification Register #5 */
+  __IM  uint32_t PID6;                   /*!< Offset: 0xFD8 (R/ )  ITM Peripheral Identification Register #6 */
+  __IM  uint32_t PID7;                   /*!< Offset: 0xFDC (R/ )  ITM Peripheral Identification Register #7 */
+  __IM  uint32_t PID0;                   /*!< Offset: 0xFE0 (R/ )  ITM Peripheral Identification Register #0 */
+  __IM  uint32_t PID1;                   /*!< Offset: 0xFE4 (R/ )  ITM Peripheral Identification Register #1 */
+  __IM  uint32_t PID2;                   /*!< Offset: 0xFE8 (R/ )  ITM Peripheral Identification Register #2 */
+  __IM  uint32_t PID3;                   /*!< Offset: 0xFEC (R/ )  ITM Peripheral Identification Register #3 */
+  __IM  uint32_t CID0;                   /*!< Offset: 0xFF0 (R/ )  ITM Component  Identification Register #0 */
+  __IM  uint32_t CID1;                   /*!< Offset: 0xFF4 (R/ )  ITM Component  Identification Register #1 */
+  __IM  uint32_t CID2;                   /*!< Offset: 0xFF8 (R/ )  ITM Component  Identification Register #2 */
+  __IM  uint32_t CID3;                   /*!< Offset: 0xFFC (R/ )  ITM Component  Identification Register #3 */
+} ITM_Type;
+
+/* ITM Stimulus Port Register Definitions */
+#define ITM_STIM_DISABLED_Pos               1U                                            /*!< ITM STIM: DISABLED Position */
+#define ITM_STIM_DISABLED_Msk              (0x1UL << ITM_STIM_DISABLED_Pos)               /*!< ITM STIM: DISABLED Mask */
+
+#define ITM_STIM_FIFOREADY_Pos              0U                                            /*!< ITM STIM: FIFOREADY Position */
+#define ITM_STIM_FIFOREADY_Msk             (0x1UL /*<< ITM_STIM_FIFOREADY_Pos*/)          /*!< ITM STIM: FIFOREADY Mask */
+
+/* ITM Trace Privilege Register Definitions */
+#define ITM_TPR_PRIVMASK_Pos                0U                                            /*!< ITM TPR: PRIVMASK Position */
+#define ITM_TPR_PRIVMASK_Msk               (0xFFFFFFFFUL /*<< ITM_TPR_PRIVMASK_Pos*/)     /*!< ITM TPR: PRIVMASK Mask */
+
+/* ITM Trace Control Register Definitions */
+#define ITM_TCR_BUSY_Pos                   23U                                            /*!< ITM TCR: BUSY Position */
+#define ITM_TCR_BUSY_Msk                   (1UL << ITM_TCR_BUSY_Pos)                      /*!< ITM TCR: BUSY Mask */
+
+#define ITM_TCR_TRACEBUSID_Pos             16U                                            /*!< ITM TCR: ATBID Position */
+#define ITM_TCR_TRACEBUSID_Msk             (0x7FUL << ITM_TCR_TRACEBUSID_Pos)             /*!< ITM TCR: ATBID Mask */
+
+#define ITM_TCR_GTSFREQ_Pos                10U                                            /*!< ITM TCR: Global timestamp frequency Position */
+#define ITM_TCR_GTSFREQ_Msk                (3UL << ITM_TCR_GTSFREQ_Pos)                   /*!< ITM TCR: Global timestamp frequency Mask */
+
+#define ITM_TCR_TSPRESCALE_Pos              8U                                            /*!< ITM TCR: TSPRESCALE Position */
+#define ITM_TCR_TSPRESCALE_Msk             (3UL << ITM_TCR_TSPRESCALE_Pos)                /*!< ITM TCR: TSPRESCALE Mask */
+
+#define ITM_TCR_STALLENA_Pos                5U                                            /*!< ITM TCR: STALLENA Position */
+#define ITM_TCR_STALLENA_Msk               (1UL << ITM_TCR_STALLENA_Pos)                  /*!< ITM TCR: STALLENA Mask */
+
+#define ITM_TCR_SWOENA_Pos                  4U                                            /*!< ITM TCR: SWOENA Position */
+#define ITM_TCR_SWOENA_Msk                 (1UL << ITM_TCR_SWOENA_Pos)                    /*!< ITM TCR: SWOENA Mask */
+
+#define ITM_TCR_DWTENA_Pos                  3U                                            /*!< ITM TCR: DWTENA Position */
+#define ITM_TCR_DWTENA_Msk                 (1UL << ITM_TCR_DWTENA_Pos)                    /*!< ITM TCR: DWTENA Mask */
+
+#define ITM_TCR_SYNCENA_Pos                 2U                                            /*!< ITM TCR: SYNCENA Position */
+#define ITM_TCR_SYNCENA_Msk                (1UL << ITM_TCR_SYNCENA_Pos)                   /*!< ITM TCR: SYNCENA Mask */
+
+#define ITM_TCR_TSENA_Pos                   1U                                            /*!< ITM TCR: TSENA Position */
+#define ITM_TCR_TSENA_Msk                  (1UL << ITM_TCR_TSENA_Pos)                     /*!< ITM TCR: TSENA Mask */
+
+#define ITM_TCR_ITMENA_Pos                  0U                                            /*!< ITM TCR: ITM Enable bit Position */
+#define ITM_TCR_ITMENA_Msk                 (1UL /*<< ITM_TCR_ITMENA_Pos*/)                /*!< ITM TCR: ITM Enable bit Mask */
+
+/* ITM Lock Status Register Definitions */
+#define ITM_LSR_ByteAcc_Pos                 2U                                            /*!< ITM LSR: ByteAcc Position */
+#define ITM_LSR_ByteAcc_Msk                (1UL << ITM_LSR_ByteAcc_Pos)                   /*!< ITM LSR: ByteAcc Mask */
+
+#define ITM_LSR_Access_Pos                  1U                                            /*!< ITM LSR: Access Position */
+#define ITM_LSR_Access_Msk                 (1UL << ITM_LSR_Access_Pos)                    /*!< ITM LSR: Access Mask */
+
+#define ITM_LSR_Present_Pos                 0U                                            /*!< ITM LSR: Present Position */
+#define ITM_LSR_Present_Msk                (1UL /*<< ITM_LSR_Present_Pos*/)               /*!< ITM LSR: Present Mask */
+
+/*@}*/ /* end of group CMSIS_ITM */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_DWT     Data Watchpoint and Trace (DWT)
+  \brief    Type definitions for the Data Watchpoint and Trace (DWT)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Data Watchpoint and Trace Register (DWT).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  Control Register */
+  __IOM uint32_t CYCCNT;                 /*!< Offset: 0x004 (R/W)  Cycle Count Register */
+  __IOM uint32_t CPICNT;                 /*!< Offset: 0x008 (R/W)  CPI Count Register */
+  __IOM uint32_t EXCCNT;                 /*!< Offset: 0x00C (R/W)  Exception Overhead Count Register */
+  __IOM uint32_t SLEEPCNT;               /*!< Offset: 0x010 (R/W)  Sleep Count Register */
+  __IOM uint32_t LSUCNT;                 /*!< Offset: 0x014 (R/W)  LSU Count Register */
+  __IOM uint32_t FOLDCNT;                /*!< Offset: 0x018 (R/W)  Folded-instruction Count Register */
+  __IM  uint32_t PCSR;                   /*!< Offset: 0x01C (R/ )  Program Counter Sample Register */
+  __IOM uint32_t COMP0;                  /*!< Offset: 0x020 (R/W)  Comparator Register 0 */
+        uint32_t RESERVED1[1U];
+  __IOM uint32_t FUNCTION0;              /*!< Offset: 0x028 (R/W)  Function Register 0 */
+        uint32_t RESERVED2[1U];
+  __IOM uint32_t COMP1;                  /*!< Offset: 0x030 (R/W)  Comparator Register 1 */
+        uint32_t RESERVED3[1U];
+  __IOM uint32_t FUNCTION1;              /*!< Offset: 0x038 (R/W)  Function Register 1 */
+        uint32_t RESERVED4[1U];
+  __IOM uint32_t COMP2;                  /*!< Offset: 0x040 (R/W)  Comparator Register 2 */
+        uint32_t RESERVED5[1U];
+  __IOM uint32_t FUNCTION2;              /*!< Offset: 0x048 (R/W)  Function Register 2 */
+        uint32_t RESERVED6[1U];
+  __IOM uint32_t COMP3;                  /*!< Offset: 0x050 (R/W)  Comparator Register 3 */
+        uint32_t RESERVED7[1U];
+  __IOM uint32_t FUNCTION3;              /*!< Offset: 0x058 (R/W)  Function Register 3 */
+        uint32_t RESERVED8[1U];
+  __IOM uint32_t COMP4;                  /*!< Offset: 0x060 (R/W)  Comparator Register 4 */
+        uint32_t RESERVED9[1U];
+  __IOM uint32_t FUNCTION4;              /*!< Offset: 0x068 (R/W)  Function Register 4 */
+        uint32_t RESERVED10[1U];
+  __IOM uint32_t COMP5;                  /*!< Offset: 0x070 (R/W)  Comparator Register 5 */
+        uint32_t RESERVED11[1U];
+  __IOM uint32_t FUNCTION5;              /*!< Offset: 0x078 (R/W)  Function Register 5 */
+        uint32_t RESERVED12[1U];
+  __IOM uint32_t COMP6;                  /*!< Offset: 0x080 (R/W)  Comparator Register 6 */
+        uint32_t RESERVED13[1U];
+  __IOM uint32_t FUNCTION6;              /*!< Offset: 0x088 (R/W)  Function Register 6 */
+        uint32_t RESERVED14[1U];
+  __IOM uint32_t COMP7;                  /*!< Offset: 0x090 (R/W)  Comparator Register 7 */
+        uint32_t RESERVED15[1U];
+  __IOM uint32_t FUNCTION7;              /*!< Offset: 0x098 (R/W)  Function Register 7 */
+        uint32_t RESERVED16[1U];
+  __IOM uint32_t COMP8;                  /*!< Offset: 0x0A0 (R/W)  Comparator Register 8 */
+        uint32_t RESERVED17[1U];
+  __IOM uint32_t FUNCTION8;              /*!< Offset: 0x0A8 (R/W)  Function Register 8 */
+        uint32_t RESERVED18[1U];
+  __IOM uint32_t COMP9;                  /*!< Offset: 0x0B0 (R/W)  Comparator Register 9 */
+        uint32_t RESERVED19[1U];
+  __IOM uint32_t FUNCTION9;              /*!< Offset: 0x0B8 (R/W)  Function Register 9 */
+        uint32_t RESERVED20[1U];
+  __IOM uint32_t COMP10;                 /*!< Offset: 0x0C0 (R/W)  Comparator Register 10 */
+        uint32_t RESERVED21[1U];
+  __IOM uint32_t FUNCTION10;             /*!< Offset: 0x0C8 (R/W)  Function Register 10 */
+        uint32_t RESERVED22[1U];
+  __IOM uint32_t COMP11;                 /*!< Offset: 0x0D0 (R/W)  Comparator Register 11 */
+        uint32_t RESERVED23[1U];
+  __IOM uint32_t FUNCTION11;             /*!< Offset: 0x0D8 (R/W)  Function Register 11 */
+        uint32_t RESERVED24[1U];
+  __IOM uint32_t COMP12;                 /*!< Offset: 0x0E0 (R/W)  Comparator Register 12 */
+        uint32_t RESERVED25[1U];
+  __IOM uint32_t FUNCTION12;             /*!< Offset: 0x0E8 (R/W)  Function Register 12 */
+        uint32_t RESERVED26[1U];
+  __IOM uint32_t COMP13;                 /*!< Offset: 0x0F0 (R/W)  Comparator Register 13 */
+        uint32_t RESERVED27[1U];
+  __IOM uint32_t FUNCTION13;             /*!< Offset: 0x0F8 (R/W)  Function Register 13 */
+        uint32_t RESERVED28[1U];
+  __IOM uint32_t COMP14;                 /*!< Offset: 0x100 (R/W)  Comparator Register 14 */
+        uint32_t RESERVED29[1U];
+  __IOM uint32_t FUNCTION14;             /*!< Offset: 0x108 (R/W)  Function Register 14 */
+        uint32_t RESERVED30[1U];
+  __IOM uint32_t COMP15;                 /*!< Offset: 0x110 (R/W)  Comparator Register 15 */
+        uint32_t RESERVED31[1U];
+  __IOM uint32_t FUNCTION15;             /*!< Offset: 0x118 (R/W)  Function Register 15 */
+        uint32_t RESERVED32[934U];
+  __IM  uint32_t LSR;                    /*!< Offset: 0xFB4 (R  )  Lock Status Register */
+        uint32_t RESERVED33[1U];
+  __IM  uint32_t DEVARCH;                /*!< Offset: 0xFBC (R/ )  Device Architecture Register */
+} DWT_Type;
+
+/* DWT Control Register Definitions */
+#define DWT_CTRL_NUMCOMP_Pos               28U                                         /*!< DWT CTRL: NUMCOMP Position */
+#define DWT_CTRL_NUMCOMP_Msk               (0xFUL << DWT_CTRL_NUMCOMP_Pos)             /*!< DWT CTRL: NUMCOMP Mask */
+
+#define DWT_CTRL_NOTRCPKT_Pos              27U                                         /*!< DWT CTRL: NOTRCPKT Position */
+#define DWT_CTRL_NOTRCPKT_Msk              (0x1UL << DWT_CTRL_NOTRCPKT_Pos)            /*!< DWT CTRL: NOTRCPKT Mask */
+
+#define DWT_CTRL_NOEXTTRIG_Pos             26U                                         /*!< DWT CTRL: NOEXTTRIG Position */
+#define DWT_CTRL_NOEXTTRIG_Msk             (0x1UL << DWT_CTRL_NOEXTTRIG_Pos)           /*!< DWT CTRL: NOEXTTRIG Mask */
+
+#define DWT_CTRL_NOCYCCNT_Pos              25U                                         /*!< DWT CTRL: NOCYCCNT Position */
+#define DWT_CTRL_NOCYCCNT_Msk              (0x1UL << DWT_CTRL_NOCYCCNT_Pos)            /*!< DWT CTRL: NOCYCCNT Mask */
+
+#define DWT_CTRL_NOPRFCNT_Pos              24U                                         /*!< DWT CTRL: NOPRFCNT Position */
+#define DWT_CTRL_NOPRFCNT_Msk              (0x1UL << DWT_CTRL_NOPRFCNT_Pos)            /*!< DWT CTRL: NOPRFCNT Mask */
+
+#define DWT_CTRL_CYCDISS_Pos               23U                                         /*!< DWT CTRL: CYCDISS Position */
+#define DWT_CTRL_CYCDISS_Msk               (0x1UL << DWT_CTRL_CYCDISS_Pos)             /*!< DWT CTRL: CYCDISS Mask */
+
+#define DWT_CTRL_CYCEVTENA_Pos             22U                                         /*!< DWT CTRL: CYCEVTENA Position */
+#define DWT_CTRL_CYCEVTENA_Msk             (0x1UL << DWT_CTRL_CYCEVTENA_Pos)           /*!< DWT CTRL: CYCEVTENA Mask */
+
+#define DWT_CTRL_FOLDEVTENA_Pos            21U                                         /*!< DWT CTRL: FOLDEVTENA Position */
+#define DWT_CTRL_FOLDEVTENA_Msk            (0x1UL << DWT_CTRL_FOLDEVTENA_Pos)          /*!< DWT CTRL: FOLDEVTENA Mask */
+
+#define DWT_CTRL_LSUEVTENA_Pos             20U                                         /*!< DWT CTRL: LSUEVTENA Position */
+#define DWT_CTRL_LSUEVTENA_Msk             (0x1UL << DWT_CTRL_LSUEVTENA_Pos)           /*!< DWT CTRL: LSUEVTENA Mask */
+
+#define DWT_CTRL_SLEEPEVTENA_Pos           19U                                         /*!< DWT CTRL: SLEEPEVTENA Position */
+#define DWT_CTRL_SLEEPEVTENA_Msk           (0x1UL << DWT_CTRL_SLEEPEVTENA_Pos)         /*!< DWT CTRL: SLEEPEVTENA Mask */
+
+#define DWT_CTRL_EXCEVTENA_Pos             18U                                         /*!< DWT CTRL: EXCEVTENA Position */
+#define DWT_CTRL_EXCEVTENA_Msk             (0x1UL << DWT_CTRL_EXCEVTENA_Pos)           /*!< DWT CTRL: EXCEVTENA Mask */
+
+#define DWT_CTRL_CPIEVTENA_Pos             17U                                         /*!< DWT CTRL: CPIEVTENA Position */
+#define DWT_CTRL_CPIEVTENA_Msk             (0x1UL << DWT_CTRL_CPIEVTENA_Pos)           /*!< DWT CTRL: CPIEVTENA Mask */
+
+#define DWT_CTRL_EXCTRCENA_Pos             16U                                         /*!< DWT CTRL: EXCTRCENA Position */
+#define DWT_CTRL_EXCTRCENA_Msk             (0x1UL << DWT_CTRL_EXCTRCENA_Pos)           /*!< DWT CTRL: EXCTRCENA Mask */
+
+#define DWT_CTRL_PCSAMPLENA_Pos            12U                                         /*!< DWT CTRL: PCSAMPLENA Position */
+#define DWT_CTRL_PCSAMPLENA_Msk            (0x1UL << DWT_CTRL_PCSAMPLENA_Pos)          /*!< DWT CTRL: PCSAMPLENA Mask */
+
+#define DWT_CTRL_SYNCTAP_Pos               10U                                         /*!< DWT CTRL: SYNCTAP Position */
+#define DWT_CTRL_SYNCTAP_Msk               (0x3UL << DWT_CTRL_SYNCTAP_Pos)             /*!< DWT CTRL: SYNCTAP Mask */
+
+#define DWT_CTRL_CYCTAP_Pos                 9U                                         /*!< DWT CTRL: CYCTAP Position */
+#define DWT_CTRL_CYCTAP_Msk                (0x1UL << DWT_CTRL_CYCTAP_Pos)              /*!< DWT CTRL: CYCTAP Mask */
+
+#define DWT_CTRL_POSTINIT_Pos               5U                                         /*!< DWT CTRL: POSTINIT Position */
+#define DWT_CTRL_POSTINIT_Msk              (0xFUL << DWT_CTRL_POSTINIT_Pos)            /*!< DWT CTRL: POSTINIT Mask */
+
+#define DWT_CTRL_POSTPRESET_Pos             1U                                         /*!< DWT CTRL: POSTPRESET Position */
+#define DWT_CTRL_POSTPRESET_Msk            (0xFUL << DWT_CTRL_POSTPRESET_Pos)          /*!< DWT CTRL: POSTPRESET Mask */
+
+#define DWT_CTRL_CYCCNTENA_Pos              0U                                         /*!< DWT CTRL: CYCCNTENA Position */
+#define DWT_CTRL_CYCCNTENA_Msk             (0x1UL /*<< DWT_CTRL_CYCCNTENA_Pos*/)       /*!< DWT CTRL: CYCCNTENA Mask */
+
+/* DWT CPI Count Register Definitions */
+#define DWT_CPICNT_CPICNT_Pos               0U                                         /*!< DWT CPICNT: CPICNT Position */
+#define DWT_CPICNT_CPICNT_Msk              (0xFFUL /*<< DWT_CPICNT_CPICNT_Pos*/)       /*!< DWT CPICNT: CPICNT Mask */
+
+/* DWT Exception Overhead Count Register Definitions */
+#define DWT_EXCCNT_EXCCNT_Pos               0U                                         /*!< DWT EXCCNT: EXCCNT Position */
+#define DWT_EXCCNT_EXCCNT_Msk              (0xFFUL /*<< DWT_EXCCNT_EXCCNT_Pos*/)       /*!< DWT EXCCNT: EXCCNT Mask */
+
+/* DWT Sleep Count Register Definitions */
+#define DWT_SLEEPCNT_SLEEPCNT_Pos           0U                                         /*!< DWT SLEEPCNT: SLEEPCNT Position */
+#define DWT_SLEEPCNT_SLEEPCNT_Msk          (0xFFUL /*<< DWT_SLEEPCNT_SLEEPCNT_Pos*/)   /*!< DWT SLEEPCNT: SLEEPCNT Mask */
+
+/* DWT LSU Count Register Definitions */
+#define DWT_LSUCNT_LSUCNT_Pos               0U                                         /*!< DWT LSUCNT: LSUCNT Position */
+#define DWT_LSUCNT_LSUCNT_Msk              (0xFFUL /*<< DWT_LSUCNT_LSUCNT_Pos*/)       /*!< DWT LSUCNT: LSUCNT Mask */
+
+/* DWT Folded-instruction Count Register Definitions */
+#define DWT_FOLDCNT_FOLDCNT_Pos             0U                                         /*!< DWT FOLDCNT: FOLDCNT Position */
+#define DWT_FOLDCNT_FOLDCNT_Msk            (0xFFUL /*<< DWT_FOLDCNT_FOLDCNT_Pos*/)     /*!< DWT FOLDCNT: FOLDCNT Mask */
+
+/* DWT Comparator Function Register Definitions */
+#define DWT_FUNCTION_ID_Pos                27U                                         /*!< DWT FUNCTION: ID Position */
+#define DWT_FUNCTION_ID_Msk                (0x1FUL << DWT_FUNCTION_ID_Pos)             /*!< DWT FUNCTION: ID Mask */
+
+#define DWT_FUNCTION_MATCHED_Pos           24U                                         /*!< DWT FUNCTION: MATCHED Position */
+#define DWT_FUNCTION_MATCHED_Msk           (0x1UL << DWT_FUNCTION_MATCHED_Pos)         /*!< DWT FUNCTION: MATCHED Mask */
+
+#define DWT_FUNCTION_DATAVSIZE_Pos         10U                                         /*!< DWT FUNCTION: DATAVSIZE Position */
+#define DWT_FUNCTION_DATAVSIZE_Msk         (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos)       /*!< DWT FUNCTION: DATAVSIZE Mask */
+
+#define DWT_FUNCTION_ACTION_Pos             4U                                         /*!< DWT FUNCTION: ACTION Position */
+#define DWT_FUNCTION_ACTION_Msk            (0x1UL << DWT_FUNCTION_ACTION_Pos)          /*!< DWT FUNCTION: ACTION Mask */
+
+#define DWT_FUNCTION_MATCH_Pos              0U                                         /*!< DWT FUNCTION: MATCH Position */
+#define DWT_FUNCTION_MATCH_Msk             (0xFUL /*<< DWT_FUNCTION_MATCH_Pos*/)       /*!< DWT FUNCTION: MATCH Mask */
+
+/*@}*/ /* end of group CMSIS_DWT */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_TPI     Trace Port Interface (TPI)
+  \brief    Type definitions for the Trace Port Interface (TPI)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Trace Port Interface Register (TPI).
+ */
+typedef struct
+{
+  __IM  uint32_t SSPSR;                  /*!< Offset: 0x000 (R/ )  Supported Parallel Port Size Register */
+  __IOM uint32_t CSPSR;                  /*!< Offset: 0x004 (R/W)  Current Parallel Port Size Register */
+        uint32_t RESERVED0[2U];
+  __IOM uint32_t ACPR;                   /*!< Offset: 0x010 (R/W)  Asynchronous Clock Prescaler Register */
+        uint32_t RESERVED1[55U];
+  __IOM uint32_t SPPR;                   /*!< Offset: 0x0F0 (R/W)  Selected Pin Protocol Register */
+        uint32_t RESERVED2[131U];
+  __IM  uint32_t FFSR;                   /*!< Offset: 0x300 (R/ )  Formatter and Flush Status Register */
+  __IOM uint32_t FFCR;                   /*!< Offset: 0x304 (R/W)  Formatter and Flush Control Register */
+  __IOM uint32_t PSCR;                   /*!< Offset: 0x308 (R/W)  Periodic Synchronization Control Register */
+        uint32_t RESERVED3[759U];
+  __IM  uint32_t TRIGGER;                /*!< Offset: 0xEE8 (R/ )  TRIGGER Register */
+  __IM  uint32_t ITFTTD0;                /*!< Offset: 0xEEC (R/ )  Integration Test FIFO Test Data 0 Register */
+  __IOM uint32_t ITATBCTR2;              /*!< Offset: 0xEF0 (R/W)  Integration Test ATB Control Register 2 */
+        uint32_t RESERVED4[1U];
+  __IM  uint32_t ITATBCTR0;              /*!< Offset: 0xEF8 (R/ )  Integration Test ATB Control Register 0 */
+  __IM  uint32_t ITFTTD1;                /*!< Offset: 0xEFC (R/ )  Integration Test FIFO Test Data 1 Register */
+  __IOM uint32_t ITCTRL;                 /*!< Offset: 0xF00 (R/W)  Integration Mode Control */
+        uint32_t RESERVED5[39U];
+  __IOM uint32_t CLAIMSET;               /*!< Offset: 0xFA0 (R/W)  Claim tag set */
+  __IOM uint32_t CLAIMCLR;               /*!< Offset: 0xFA4 (R/W)  Claim tag clear */
+        uint32_t RESERVED7[8U];
+  __IM  uint32_t DEVID;                  /*!< Offset: 0xFC8 (R/ )  Device Configuration Register */
+  __IM  uint32_t DEVTYPE;                /*!< Offset: 0xFCC (R/ )  Device Type Identifier Register */
+} TPI_Type;
+
+/* TPI Asynchronous Clock Prescaler Register Definitions */
+#define TPI_ACPR_PRESCALER_Pos              0U                                         /*!< TPI ACPR: PRESCALER Position */
+#define TPI_ACPR_PRESCALER_Msk             (0x1FFFUL /*<< TPI_ACPR_PRESCALER_Pos*/)    /*!< TPI ACPR: PRESCALER Mask */
+
+/* TPI Selected Pin Protocol Register Definitions */
+#define TPI_SPPR_TXMODE_Pos                 0U                                         /*!< TPI SPPR: TXMODE Position */
+#define TPI_SPPR_TXMODE_Msk                (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/)          /*!< TPI SPPR: TXMODE Mask */
+
+/* TPI Formatter and Flush Status Register Definitions */
+#define TPI_FFSR_FtNonStop_Pos              3U                                         /*!< TPI FFSR: FtNonStop Position */
+#define TPI_FFSR_FtNonStop_Msk             (0x1UL << TPI_FFSR_FtNonStop_Pos)           /*!< TPI FFSR: FtNonStop Mask */
+
+#define TPI_FFSR_TCPresent_Pos              2U                                         /*!< TPI FFSR: TCPresent Position */
+#define TPI_FFSR_TCPresent_Msk             (0x1UL << TPI_FFSR_TCPresent_Pos)           /*!< TPI FFSR: TCPresent Mask */
+
+#define TPI_FFSR_FtStopped_Pos              1U                                         /*!< TPI FFSR: FtStopped Position */
+#define TPI_FFSR_FtStopped_Msk             (0x1UL << TPI_FFSR_FtStopped_Pos)           /*!< TPI FFSR: FtStopped Mask */
+
+#define TPI_FFSR_FlInProg_Pos               0U                                         /*!< TPI FFSR: FlInProg Position */
+#define TPI_FFSR_FlInProg_Msk              (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/)        /*!< TPI FFSR: FlInProg Mask */
+
+/* TPI Formatter and Flush Control Register Definitions */
+#define TPI_FFCR_TrigIn_Pos                 8U                                         /*!< TPI FFCR: TrigIn Position */
+#define TPI_FFCR_TrigIn_Msk                (0x1UL << TPI_FFCR_TrigIn_Pos)              /*!< TPI FFCR: TrigIn Mask */
+
+#define TPI_FFCR_FOnMan_Pos                 6U                                         /*!< TPI FFCR: FOnMan Position */
+#define TPI_FFCR_FOnMan_Msk                (0x1UL << TPI_FFCR_FOnMan_Pos)              /*!< TPI FFCR: FOnMan Mask */
+
+#define TPI_FFCR_EnFCont_Pos                1U                                         /*!< TPI FFCR: EnFCont Position */
+#define TPI_FFCR_EnFCont_Msk               (0x1UL << TPI_FFCR_EnFCont_Pos)             /*!< TPI FFCR: EnFCont Mask */
+
+/* TPI TRIGGER Register Definitions */
+#define TPI_TRIGGER_TRIGGER_Pos             0U                                         /*!< TPI TRIGGER: TRIGGER Position */
+#define TPI_TRIGGER_TRIGGER_Msk            (0x1UL /*<< TPI_TRIGGER_TRIGGER_Pos*/)      /*!< TPI TRIGGER: TRIGGER Mask */
+
+/* TPI Integration Test FIFO Test Data 0 Register Definitions */
+#define TPI_ITFTTD0_ATB_IF2_ATVALID_Pos    29U                                         /*!< TPI ITFTTD0: ATB Interface 2 ATVALIDPosition */
+#define TPI_ITFTTD0_ATB_IF2_ATVALID_Msk    (0x3UL << TPI_ITFTTD0_ATB_IF2_ATVALID_Pos)  /*!< TPI ITFTTD0: ATB Interface 2 ATVALID Mask */
+
+#define TPI_ITFTTD0_ATB_IF2_bytecount_Pos  27U                                         /*!< TPI ITFTTD0: ATB Interface 2 byte count Position */
+#define TPI_ITFTTD0_ATB_IF2_bytecount_Msk  (0x3UL << TPI_ITFTTD0_ATB_IF2_bytecount_Pos) /*!< TPI ITFTTD0: ATB Interface 2 byte count Mask */
+
+#define TPI_ITFTTD0_ATB_IF1_ATVALID_Pos    26U                                         /*!< TPI ITFTTD0: ATB Interface 1 ATVALID Position */
+#define TPI_ITFTTD0_ATB_IF1_ATVALID_Msk    (0x3UL << TPI_ITFTTD0_ATB_IF1_ATVALID_Pos)  /*!< TPI ITFTTD0: ATB Interface 1 ATVALID Mask */
+
+#define TPI_ITFTTD0_ATB_IF1_bytecount_Pos  24U                                         /*!< TPI ITFTTD0: ATB Interface 1 byte count Position */
+#define TPI_ITFTTD0_ATB_IF1_bytecount_Msk  (0x3UL << TPI_ITFTTD0_ATB_IF1_bytecount_Pos) /*!< TPI ITFTTD0: ATB Interface 1 byte countt Mask */
+
+#define TPI_ITFTTD0_ATB_IF1_data2_Pos      16U                                         /*!< TPI ITFTTD0: ATB Interface 1 data2 Position */
+#define TPI_ITFTTD0_ATB_IF1_data2_Msk      (0xFFUL << TPI_ITFTTD0_ATB_IF1_data1_Pos)   /*!< TPI ITFTTD0: ATB Interface 1 data2 Mask */
+
+#define TPI_ITFTTD0_ATB_IF1_data1_Pos       8U                                         /*!< TPI ITFTTD0: ATB Interface 1 data1 Position */
+#define TPI_ITFTTD0_ATB_IF1_data1_Msk      (0xFFUL << TPI_ITFTTD0_ATB_IF1_data1_Pos)   /*!< TPI ITFTTD0: ATB Interface 1 data1 Mask */
+
+#define TPI_ITFTTD0_ATB_IF1_data0_Pos       0U                                          /*!< TPI ITFTTD0: ATB Interface 1 data0 Position */
+#define TPI_ITFTTD0_ATB_IF1_data0_Msk      (0xFFUL /*<< TPI_ITFTTD0_ATB_IF1_data0_Pos*/) /*!< TPI ITFTTD0: ATB Interface 1 data0 Mask */
+
+/* TPI Integration Test ATB Control Register 2 Register Definitions */
+#define TPI_ITATBCTR2_AFVALID2S_Pos         1U                                         /*!< TPI ITATBCTR2: AFVALID2S Position */
+#define TPI_ITATBCTR2_AFVALID2S_Msk        (0x1UL << TPI_ITATBCTR2_AFVALID2S_Pos)      /*!< TPI ITATBCTR2: AFVALID2SS Mask */
+
+#define TPI_ITATBCTR2_AFVALID1S_Pos         1U                                         /*!< TPI ITATBCTR2: AFVALID1S Position */
+#define TPI_ITATBCTR2_AFVALID1S_Msk        (0x1UL << TPI_ITATBCTR2_AFVALID1S_Pos)      /*!< TPI ITATBCTR2: AFVALID1SS Mask */
+
+#define TPI_ITATBCTR2_ATREADY2S_Pos         0U                                         /*!< TPI ITATBCTR2: ATREADY2S Position */
+#define TPI_ITATBCTR2_ATREADY2S_Msk        (0x1UL /*<< TPI_ITATBCTR2_ATREADY2S_Pos*/)  /*!< TPI ITATBCTR2: ATREADY2S Mask */
+
+#define TPI_ITATBCTR2_ATREADY1S_Pos         0U                                         /*!< TPI ITATBCTR2: ATREADY1S Position */
+#define TPI_ITATBCTR2_ATREADY1S_Msk        (0x1UL /*<< TPI_ITATBCTR2_ATREADY1S_Pos*/)  /*!< TPI ITATBCTR2: ATREADY1S Mask */
+
+/* TPI Integration Test FIFO Test Data 1 Register Definitions */
+#define TPI_ITFTTD1_ATB_IF2_ATVALID_Pos    29U                                         /*!< TPI ITFTTD1: ATB Interface 2 ATVALID Position */
+#define TPI_ITFTTD1_ATB_IF2_ATVALID_Msk    (0x3UL << TPI_ITFTTD1_ATB_IF2_ATVALID_Pos)  /*!< TPI ITFTTD1: ATB Interface 2 ATVALID Mask */
+
+#define TPI_ITFTTD1_ATB_IF2_bytecount_Pos  27U                                         /*!< TPI ITFTTD1: ATB Interface 2 byte count Position */
+#define TPI_ITFTTD1_ATB_IF2_bytecount_Msk  (0x3UL << TPI_ITFTTD1_ATB_IF2_bytecount_Pos) /*!< TPI ITFTTD1: ATB Interface 2 byte count Mask */
+
+#define TPI_ITFTTD1_ATB_IF1_ATVALID_Pos    26U                                         /*!< TPI ITFTTD1: ATB Interface 1 ATVALID Position */
+#define TPI_ITFTTD1_ATB_IF1_ATVALID_Msk    (0x3UL << TPI_ITFTTD1_ATB_IF1_ATVALID_Pos)  /*!< TPI ITFTTD1: ATB Interface 1 ATVALID Mask */
+
+#define TPI_ITFTTD1_ATB_IF1_bytecount_Pos  24U                                         /*!< TPI ITFTTD1: ATB Interface 1 byte count Position */
+#define TPI_ITFTTD1_ATB_IF1_bytecount_Msk  (0x3UL << TPI_ITFTTD1_ATB_IF1_bytecount_Pos) /*!< TPI ITFTTD1: ATB Interface 1 byte countt Mask */
+
+#define TPI_ITFTTD1_ATB_IF2_data2_Pos      16U                                         /*!< TPI ITFTTD1: ATB Interface 2 data2 Position */
+#define TPI_ITFTTD1_ATB_IF2_data2_Msk      (0xFFUL << TPI_ITFTTD1_ATB_IF2_data1_Pos)   /*!< TPI ITFTTD1: ATB Interface 2 data2 Mask */
+
+#define TPI_ITFTTD1_ATB_IF2_data1_Pos       8U                                         /*!< TPI ITFTTD1: ATB Interface 2 data1 Position */
+#define TPI_ITFTTD1_ATB_IF2_data1_Msk      (0xFFUL << TPI_ITFTTD1_ATB_IF2_data1_Pos)   /*!< TPI ITFTTD1: ATB Interface 2 data1 Mask */
+
+#define TPI_ITFTTD1_ATB_IF2_data0_Pos       0U                                          /*!< TPI ITFTTD1: ATB Interface 2 data0 Position */
+#define TPI_ITFTTD1_ATB_IF2_data0_Msk      (0xFFUL /*<< TPI_ITFTTD1_ATB_IF2_data0_Pos*/) /*!< TPI ITFTTD1: ATB Interface 2 data0 Mask */
+
+/* TPI Integration Test ATB Control Register 0 Definitions */
+#define TPI_ITATBCTR0_AFVALID2S_Pos         1U                                         /*!< TPI ITATBCTR0: AFVALID2S Position */
+#define TPI_ITATBCTR0_AFVALID2S_Msk        (0x1UL << TPI_ITATBCTR0_AFVALID2S_Pos)      /*!< TPI ITATBCTR0: AFVALID2SS Mask */
+
+#define TPI_ITATBCTR0_AFVALID1S_Pos         1U                                         /*!< TPI ITATBCTR0: AFVALID1S Position */
+#define TPI_ITATBCTR0_AFVALID1S_Msk        (0x1UL << TPI_ITATBCTR0_AFVALID1S_Pos)      /*!< TPI ITATBCTR0: AFVALID1SS Mask */
+
+#define TPI_ITATBCTR0_ATREADY2S_Pos         0U                                         /*!< TPI ITATBCTR0: ATREADY2S Position */
+#define TPI_ITATBCTR0_ATREADY2S_Msk        (0x1UL /*<< TPI_ITATBCTR0_ATREADY2S_Pos*/)  /*!< TPI ITATBCTR0: ATREADY2S Mask */
+
+#define TPI_ITATBCTR0_ATREADY1S_Pos         0U                                         /*!< TPI ITATBCTR0: ATREADY1S Position */
+#define TPI_ITATBCTR0_ATREADY1S_Msk        (0x1UL /*<< TPI_ITATBCTR0_ATREADY1S_Pos*/)  /*!< TPI ITATBCTR0: ATREADY1S Mask */
+
+/* TPI Integration Mode Control Register Definitions */
+#define TPI_ITCTRL_Mode_Pos                 0U                                         /*!< TPI ITCTRL: Mode Position */
+#define TPI_ITCTRL_Mode_Msk                (0x3UL /*<< TPI_ITCTRL_Mode_Pos*/)          /*!< TPI ITCTRL: Mode Mask */
+
+/* TPI DEVID Register Definitions */
+#define TPI_DEVID_NRZVALID_Pos             11U                                         /*!< TPI DEVID: NRZVALID Position */
+#define TPI_DEVID_NRZVALID_Msk             (0x1UL << TPI_DEVID_NRZVALID_Pos)           /*!< TPI DEVID: NRZVALID Mask */
+
+#define TPI_DEVID_MANCVALID_Pos            10U                                         /*!< TPI DEVID: MANCVALID Position */
+#define TPI_DEVID_MANCVALID_Msk            (0x1UL << TPI_DEVID_MANCVALID_Pos)          /*!< TPI DEVID: MANCVALID Mask */
+
+#define TPI_DEVID_PTINVALID_Pos             9U                                         /*!< TPI DEVID: PTINVALID Position */
+#define TPI_DEVID_PTINVALID_Msk            (0x1UL << TPI_DEVID_PTINVALID_Pos)          /*!< TPI DEVID: PTINVALID Mask */
+
+#define TPI_DEVID_FIFOSZ_Pos                6U                                         /*!< TPI DEVID: FIFOSZ Position */
+#define TPI_DEVID_FIFOSZ_Msk               (0x7UL << TPI_DEVID_FIFOSZ_Pos)             /*!< TPI DEVID: FIFOSZ Mask */
+
+#define TPI_DEVID_NrTraceInput_Pos          0U                                         /*!< TPI DEVID: NrTraceInput Position */
+#define TPI_DEVID_NrTraceInput_Msk         (0x3FUL /*<< TPI_DEVID_NrTraceInput_Pos*/)  /*!< TPI DEVID: NrTraceInput Mask */
+
+/* TPI DEVTYPE Register Definitions */
+#define TPI_DEVTYPE_SubType_Pos             4U                                         /*!< TPI DEVTYPE: SubType Position */
+#define TPI_DEVTYPE_SubType_Msk            (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/)      /*!< TPI DEVTYPE: SubType Mask */
+
+#define TPI_DEVTYPE_MajorType_Pos           0U                                         /*!< TPI DEVTYPE: MajorType Position */
+#define TPI_DEVTYPE_MajorType_Msk          (0xFUL << TPI_DEVTYPE_MajorType_Pos)        /*!< TPI DEVTYPE: MajorType Mask */
+
+/*@}*/ /* end of group CMSIS_TPI */
+
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_MPU     Memory Protection Unit (MPU)
+  \brief    Type definitions for the Memory Protection Unit (MPU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Memory Protection Unit (MPU).
+ */
+typedef struct
+{
+  __IM  uint32_t TYPE;                   /*!< Offset: 0x000 (R/ )  MPU Type Register */
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x004 (R/W)  MPU Control Register */
+  __IOM uint32_t RNR;                    /*!< Offset: 0x008 (R/W)  MPU Region Number Register */
+  __IOM uint32_t RBAR;                   /*!< Offset: 0x00C (R/W)  MPU Region Base Address Register */
+  __IOM uint32_t RLAR;                   /*!< Offset: 0x010 (R/W)  MPU Region Limit Address Register */
+  __IOM uint32_t RBAR_A1;                /*!< Offset: 0x014 (R/W)  MPU Region Base Address Register Alias 1 */
+  __IOM uint32_t RLAR_A1;                /*!< Offset: 0x018 (R/W)  MPU Region Limit Address Register Alias 1 */
+  __IOM uint32_t RBAR_A2;                /*!< Offset: 0x01C (R/W)  MPU Region Base Address Register Alias 2 */
+  __IOM uint32_t RLAR_A2;                /*!< Offset: 0x020 (R/W)  MPU Region Limit Address Register Alias 2 */
+  __IOM uint32_t RBAR_A3;                /*!< Offset: 0x024 (R/W)  MPU Region Base Address Register Alias 3 */
+  __IOM uint32_t RLAR_A3;                /*!< Offset: 0x028 (R/W)  MPU Region Limit Address Register Alias 3 */
+        uint32_t RESERVED0[1];
+  union {
+  __IOM uint32_t MAIR[2];
+  struct {
+  __IOM uint32_t MAIR0;                  /*!< Offset: 0x030 (R/W)  MPU Memory Attribute Indirection Register 0 */
+  __IOM uint32_t MAIR1;                  /*!< Offset: 0x034 (R/W)  MPU Memory Attribute Indirection Register 1 */
+  };
+  };
+} MPU_Type;
+
+#define MPU_TYPE_RALIASES                  4U
+
+/* MPU Type Register Definitions */
+#define MPU_TYPE_IREGION_Pos               16U                                            /*!< MPU TYPE: IREGION Position */
+#define MPU_TYPE_IREGION_Msk               (0xFFUL << MPU_TYPE_IREGION_Pos)               /*!< MPU TYPE: IREGION Mask */
+
+#define MPU_TYPE_DREGION_Pos                8U                                            /*!< MPU TYPE: DREGION Position */
+#define MPU_TYPE_DREGION_Msk               (0xFFUL << MPU_TYPE_DREGION_Pos)               /*!< MPU TYPE: DREGION Mask */
+
+#define MPU_TYPE_SEPARATE_Pos               0U                                            /*!< MPU TYPE: SEPARATE Position */
+#define MPU_TYPE_SEPARATE_Msk              (1UL /*<< MPU_TYPE_SEPARATE_Pos*/)             /*!< MPU TYPE: SEPARATE Mask */
+
+/* MPU Control Register Definitions */
+#define MPU_CTRL_PRIVDEFENA_Pos             2U                                            /*!< MPU CTRL: PRIVDEFENA Position */
+#define MPU_CTRL_PRIVDEFENA_Msk            (1UL << MPU_CTRL_PRIVDEFENA_Pos)               /*!< MPU CTRL: PRIVDEFENA Mask */
+
+#define MPU_CTRL_HFNMIENA_Pos               1U                                            /*!< MPU CTRL: HFNMIENA Position */
+#define MPU_CTRL_HFNMIENA_Msk              (1UL << MPU_CTRL_HFNMIENA_Pos)                 /*!< MPU CTRL: HFNMIENA Mask */
+
+#define MPU_CTRL_ENABLE_Pos                 0U                                            /*!< MPU CTRL: ENABLE Position */
+#define MPU_CTRL_ENABLE_Msk                (1UL /*<< MPU_CTRL_ENABLE_Pos*/)               /*!< MPU CTRL: ENABLE Mask */
+
+/* MPU Region Number Register Definitions */
+#define MPU_RNR_REGION_Pos                  0U                                            /*!< MPU RNR: REGION Position */
+#define MPU_RNR_REGION_Msk                 (0xFFUL /*<< MPU_RNR_REGION_Pos*/)             /*!< MPU RNR: REGION Mask */
+
+/* MPU Region Base Address Register Definitions */
+#define MPU_RBAR_BASE_Pos                   5U                                            /*!< MPU RBAR: BASE Position */
+#define MPU_RBAR_BASE_Msk                  (0x7FFFFFFUL << MPU_RBAR_BASE_Pos)             /*!< MPU RBAR: BASE Mask */
+
+#define MPU_RBAR_SH_Pos                     3U                                            /*!< MPU RBAR: SH Position */
+#define MPU_RBAR_SH_Msk                    (0x3UL << MPU_RBAR_SH_Pos)                     /*!< MPU RBAR: SH Mask */
+
+#define MPU_RBAR_AP_Pos                     1U                                            /*!< MPU RBAR: AP Position */
+#define MPU_RBAR_AP_Msk                    (0x3UL << MPU_RBAR_AP_Pos)                     /*!< MPU RBAR: AP Mask */
+
+#define MPU_RBAR_XN_Pos                     0U                                            /*!< MPU RBAR: XN Position */
+#define MPU_RBAR_XN_Msk                    (01UL /*<< MPU_RBAR_XN_Pos*/)                  /*!< MPU RBAR: XN Mask */
+
+/* MPU Region Limit Address Register Definitions */
+#define MPU_RLAR_LIMIT_Pos                  5U                                            /*!< MPU RLAR: LIMIT Position */
+#define MPU_RLAR_LIMIT_Msk                 (0x7FFFFFFUL << MPU_RLAR_LIMIT_Pos)            /*!< MPU RLAR: LIMIT Mask */
+
+#define MPU_RLAR_AttrIndx_Pos               1U                                            /*!< MPU RLAR: AttrIndx Position */
+#define MPU_RLAR_AttrIndx_Msk              (0x7UL << MPU_RLAR_AttrIndx_Pos)               /*!< MPU RLAR: AttrIndx Mask */
+
+#define MPU_RLAR_EN_Pos                     0U                                            /*!< MPU RLAR: Region enable bit Position */
+#define MPU_RLAR_EN_Msk                    (1UL /*<< MPU_RLAR_EN_Pos*/)                   /*!< MPU RLAR: Region enable bit Disable Mask */
+
+/* MPU Memory Attribute Indirection Register 0 Definitions */
+#define MPU_MAIR0_Attr3_Pos                24U                                            /*!< MPU MAIR0: Attr3 Position */
+#define MPU_MAIR0_Attr3_Msk                (0xFFUL << MPU_MAIR0_Attr3_Pos)                /*!< MPU MAIR0: Attr3 Mask */
+
+#define MPU_MAIR0_Attr2_Pos                16U                                            /*!< MPU MAIR0: Attr2 Position */
+#define MPU_MAIR0_Attr2_Msk                (0xFFUL << MPU_MAIR0_Attr2_Pos)                /*!< MPU MAIR0: Attr2 Mask */
+
+#define MPU_MAIR0_Attr1_Pos                 8U                                            /*!< MPU MAIR0: Attr1 Position */
+#define MPU_MAIR0_Attr1_Msk                (0xFFUL << MPU_MAIR0_Attr1_Pos)                /*!< MPU MAIR0: Attr1 Mask */
+
+#define MPU_MAIR0_Attr0_Pos                 0U                                            /*!< MPU MAIR0: Attr0 Position */
+#define MPU_MAIR0_Attr0_Msk                (0xFFUL /*<< MPU_MAIR0_Attr0_Pos*/)            /*!< MPU MAIR0: Attr0 Mask */
+
+/* MPU Memory Attribute Indirection Register 1 Definitions */
+#define MPU_MAIR1_Attr7_Pos                24U                                            /*!< MPU MAIR1: Attr7 Position */
+#define MPU_MAIR1_Attr7_Msk                (0xFFUL << MPU_MAIR1_Attr7_Pos)                /*!< MPU MAIR1: Attr7 Mask */
+
+#define MPU_MAIR1_Attr6_Pos                16U                                            /*!< MPU MAIR1: Attr6 Position */
+#define MPU_MAIR1_Attr6_Msk                (0xFFUL << MPU_MAIR1_Attr6_Pos)                /*!< MPU MAIR1: Attr6 Mask */
+
+#define MPU_MAIR1_Attr5_Pos                 8U                                            /*!< MPU MAIR1: Attr5 Position */
+#define MPU_MAIR1_Attr5_Msk                (0xFFUL << MPU_MAIR1_Attr5_Pos)                /*!< MPU MAIR1: Attr5 Mask */
+
+#define MPU_MAIR1_Attr4_Pos                 0U                                            /*!< MPU MAIR1: Attr4 Position */
+#define MPU_MAIR1_Attr4_Msk                (0xFFUL /*<< MPU_MAIR1_Attr4_Pos*/)            /*!< MPU MAIR1: Attr4 Mask */
+
+/*@} end of group CMSIS_MPU */
+#endif
+
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_SAU     Security Attribution Unit (SAU)
+  \brief    Type definitions for the Security Attribution Unit (SAU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Security Attribution Unit (SAU).
+ */
+typedef struct
+{
+  __IOM uint32_t CTRL;                   /*!< Offset: 0x000 (R/W)  SAU Control Register */
+  __IM  uint32_t TYPE;                   /*!< Offset: 0x004 (R/ )  SAU Type Register */
+#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U)
+  __IOM uint32_t RNR;                    /*!< Offset: 0x008 (R/W)  SAU Region Number Register */
+  __IOM uint32_t RBAR;                   /*!< Offset: 0x00C (R/W)  SAU Region Base Address Register */
+  __IOM uint32_t RLAR;                   /*!< Offset: 0x010 (R/W)  SAU Region Limit Address Register */
+#else
+        uint32_t RESERVED0[3];
+#endif
+  __IOM uint32_t SFSR;                   /*!< Offset: 0x014 (R/W)  Secure Fault Status Register */
+  __IOM uint32_t SFAR;                   /*!< Offset: 0x018 (R/W)  Secure Fault Address Register */
+} SAU_Type;
+
+/* SAU Control Register Definitions */
+#define SAU_CTRL_ALLNS_Pos                  1U                                            /*!< SAU CTRL: ALLNS Position */
+#define SAU_CTRL_ALLNS_Msk                 (1UL << SAU_CTRL_ALLNS_Pos)                    /*!< SAU CTRL: ALLNS Mask */
+
+#define SAU_CTRL_ENABLE_Pos                 0U                                            /*!< SAU CTRL: ENABLE Position */
+#define SAU_CTRL_ENABLE_Msk                (1UL /*<< SAU_CTRL_ENABLE_Pos*/)               /*!< SAU CTRL: ENABLE Mask */
+
+/* SAU Type Register Definitions */
+#define SAU_TYPE_SREGION_Pos                0U                                            /*!< SAU TYPE: SREGION Position */
+#define SAU_TYPE_SREGION_Msk               (0xFFUL /*<< SAU_TYPE_SREGION_Pos*/)           /*!< SAU TYPE: SREGION Mask */
+
+#if defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U)
+/* SAU Region Number Register Definitions */
+#define SAU_RNR_REGION_Pos                  0U                                            /*!< SAU RNR: REGION Position */
+#define SAU_RNR_REGION_Msk                 (0xFFUL /*<< SAU_RNR_REGION_Pos*/)             /*!< SAU RNR: REGION Mask */
+
+/* SAU Region Base Address Register Definitions */
+#define SAU_RBAR_BADDR_Pos                  5U                                            /*!< SAU RBAR: BADDR Position */
+#define SAU_RBAR_BADDR_Msk                 (0x7FFFFFFUL << SAU_RBAR_BADDR_Pos)            /*!< SAU RBAR: BADDR Mask */
+
+/* SAU Region Limit Address Register Definitions */
+#define SAU_RLAR_LADDR_Pos                  5U                                            /*!< SAU RLAR: LADDR Position */
+#define SAU_RLAR_LADDR_Msk                 (0x7FFFFFFUL << SAU_RLAR_LADDR_Pos)            /*!< SAU RLAR: LADDR Mask */
+
+#define SAU_RLAR_NSC_Pos                    1U                                            /*!< SAU RLAR: NSC Position */
+#define SAU_RLAR_NSC_Msk                   (1UL << SAU_RLAR_NSC_Pos)                      /*!< SAU RLAR: NSC Mask */
+
+#define SAU_RLAR_ENABLE_Pos                 0U                                            /*!< SAU RLAR: ENABLE Position */
+#define SAU_RLAR_ENABLE_Msk                (1UL /*<< SAU_RLAR_ENABLE_Pos*/)               /*!< SAU RLAR: ENABLE Mask */
+
+#endif /* defined (__SAUREGION_PRESENT) && (__SAUREGION_PRESENT == 1U) */
+
+/* Secure Fault Status Register Definitions */
+#define SAU_SFSR_LSERR_Pos                  7U                                            /*!< SAU SFSR: LSERR Position */
+#define SAU_SFSR_LSERR_Msk                 (1UL << SAU_SFSR_LSERR_Pos)                    /*!< SAU SFSR: LSERR Mask */
+
+#define SAU_SFSR_SFARVALID_Pos              6U                                            /*!< SAU SFSR: SFARVALID Position */
+#define SAU_SFSR_SFARVALID_Msk             (1UL << SAU_SFSR_SFARVALID_Pos)                /*!< SAU SFSR: SFARVALID Mask */
+
+#define SAU_SFSR_LSPERR_Pos                 5U                                            /*!< SAU SFSR: LSPERR Position */
+#define SAU_SFSR_LSPERR_Msk                (1UL << SAU_SFSR_LSPERR_Pos)                   /*!< SAU SFSR: LSPERR Mask */
+
+#define SAU_SFSR_INVTRAN_Pos                4U                                            /*!< SAU SFSR: INVTRAN Position */
+#define SAU_SFSR_INVTRAN_Msk               (1UL << SAU_SFSR_INVTRAN_Pos)                  /*!< SAU SFSR: INVTRAN Mask */
+
+#define SAU_SFSR_AUVIOL_Pos                 3U                                            /*!< SAU SFSR: AUVIOL Position */
+#define SAU_SFSR_AUVIOL_Msk                (1UL << SAU_SFSR_AUVIOL_Pos)                   /*!< SAU SFSR: AUVIOL Mask */
+
+#define SAU_SFSR_INVER_Pos                  2U                                            /*!< SAU SFSR: INVER Position */
+#define SAU_SFSR_INVER_Msk                 (1UL << SAU_SFSR_INVER_Pos)                    /*!< SAU SFSR: INVER Mask */
+
+#define SAU_SFSR_INVIS_Pos                  1U                                            /*!< SAU SFSR: INVIS Position */
+#define SAU_SFSR_INVIS_Msk                 (1UL << SAU_SFSR_INVIS_Pos)                    /*!< SAU SFSR: INVIS Mask */
+
+#define SAU_SFSR_INVEP_Pos                  0U                                            /*!< SAU SFSR: INVEP Position */
+#define SAU_SFSR_INVEP_Msk                 (1UL /*<< SAU_SFSR_INVEP_Pos*/)                /*!< SAU SFSR: INVEP Mask */
+
+/*@} end of group CMSIS_SAU */
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_FPU     Floating Point Unit (FPU)
+  \brief    Type definitions for the Floating Point Unit (FPU)
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Floating Point Unit (FPU).
+ */
+typedef struct
+{
+        uint32_t RESERVED0[1U];
+  __IOM uint32_t FPCCR;                  /*!< Offset: 0x004 (R/W)  Floating-Point Context Control Register */
+  __IOM uint32_t FPCAR;                  /*!< Offset: 0x008 (R/W)  Floating-Point Context Address Register */
+  __IOM uint32_t FPDSCR;                 /*!< Offset: 0x00C (R/W)  Floating-Point Default Status Control Register */
+  __IM  uint32_t MVFR0;                  /*!< Offset: 0x010 (R/ )  Media and FP Feature Register 0 */
+  __IM  uint32_t MVFR1;                  /*!< Offset: 0x014 (R/ )  Media and FP Feature Register 1 */
+} FPU_Type;
+
+/* Floating-Point Context Control Register Definitions */
+#define FPU_FPCCR_ASPEN_Pos                31U                                            /*!< FPCCR: ASPEN bit Position */
+#define FPU_FPCCR_ASPEN_Msk                (1UL << FPU_FPCCR_ASPEN_Pos)                   /*!< FPCCR: ASPEN bit Mask */
+
+#define FPU_FPCCR_LSPEN_Pos                30U                                            /*!< FPCCR: LSPEN Position */
+#define FPU_FPCCR_LSPEN_Msk                (1UL << FPU_FPCCR_LSPEN_Pos)                   /*!< FPCCR: LSPEN bit Mask */
+
+#define FPU_FPCCR_LSPENS_Pos               29U                                            /*!< FPCCR: LSPENS Position */
+#define FPU_FPCCR_LSPENS_Msk               (1UL << FPU_FPCCR_LSPENS_Pos)                  /*!< FPCCR: LSPENS bit Mask */
+
+#define FPU_FPCCR_CLRONRET_Pos             28U                                            /*!< FPCCR: CLRONRET Position */
+#define FPU_FPCCR_CLRONRET_Msk             (1UL << FPU_FPCCR_CLRONRET_Pos)                /*!< FPCCR: CLRONRET bit Mask */
+
+#define FPU_FPCCR_CLRONRETS_Pos            27U                                            /*!< FPCCR: CLRONRETS Position */
+#define FPU_FPCCR_CLRONRETS_Msk            (1UL << FPU_FPCCR_CLRONRETS_Pos)               /*!< FPCCR: CLRONRETS bit Mask */
+
+#define FPU_FPCCR_TS_Pos                   26U                                            /*!< FPCCR: TS Position */
+#define FPU_FPCCR_TS_Msk                   (1UL << FPU_FPCCR_TS_Pos)                      /*!< FPCCR: TS bit Mask */
+
+#define FPU_FPCCR_UFRDY_Pos                10U                                            /*!< FPCCR: UFRDY Position */
+#define FPU_FPCCR_UFRDY_Msk                (1UL << FPU_FPCCR_UFRDY_Pos)                   /*!< FPCCR: UFRDY bit Mask */
+
+#define FPU_FPCCR_SPLIMVIOL_Pos             9U                                            /*!< FPCCR: SPLIMVIOL Position */
+#define FPU_FPCCR_SPLIMVIOL_Msk            (1UL << FPU_FPCCR_SPLIMVIOL_Pos)               /*!< FPCCR: SPLIMVIOL bit Mask */
+
+#define FPU_FPCCR_MONRDY_Pos                8U                                            /*!< FPCCR: MONRDY Position */
+#define FPU_FPCCR_MONRDY_Msk               (1UL << FPU_FPCCR_MONRDY_Pos)                  /*!< FPCCR: MONRDY bit Mask */
+
+#define FPU_FPCCR_SFRDY_Pos                 7U                                            /*!< FPCCR: SFRDY Position */
+#define FPU_FPCCR_SFRDY_Msk                (1UL << FPU_FPCCR_SFRDY_Pos)                   /*!< FPCCR: SFRDY bit Mask */
+
+#define FPU_FPCCR_BFRDY_Pos                 6U                                            /*!< FPCCR: BFRDY Position */
+#define FPU_FPCCR_BFRDY_Msk                (1UL << FPU_FPCCR_BFRDY_Pos)                   /*!< FPCCR: BFRDY bit Mask */
+
+#define FPU_FPCCR_MMRDY_Pos                 5U                                            /*!< FPCCR: MMRDY Position */
+#define FPU_FPCCR_MMRDY_Msk                (1UL << FPU_FPCCR_MMRDY_Pos)                   /*!< FPCCR: MMRDY bit Mask */
+
+#define FPU_FPCCR_HFRDY_Pos                 4U                                            /*!< FPCCR: HFRDY Position */
+#define FPU_FPCCR_HFRDY_Msk                (1UL << FPU_FPCCR_HFRDY_Pos)                   /*!< FPCCR: HFRDY bit Mask */
+
+#define FPU_FPCCR_THREAD_Pos                3U                                            /*!< FPCCR: processor mode bit Position */
+#define FPU_FPCCR_THREAD_Msk               (1UL << FPU_FPCCR_THREAD_Pos)                  /*!< FPCCR: processor mode active bit Mask */
+
+#define FPU_FPCCR_S_Pos                     2U                                            /*!< FPCCR: Security status of the FP context bit Position */
+#define FPU_FPCCR_S_Msk                    (1UL << FPU_FPCCR_S_Pos)                       /*!< FPCCR: Security status of the FP context bit Mask */
+
+#define FPU_FPCCR_USER_Pos                  1U                                            /*!< FPCCR: privilege level bit Position */
+#define FPU_FPCCR_USER_Msk                 (1UL << FPU_FPCCR_USER_Pos)                    /*!< FPCCR: privilege level bit Mask */
+
+#define FPU_FPCCR_LSPACT_Pos                0U                                            /*!< FPCCR: Lazy state preservation active bit Position */
+#define FPU_FPCCR_LSPACT_Msk               (1UL /*<< FPU_FPCCR_LSPACT_Pos*/)              /*!< FPCCR: Lazy state preservation active bit Mask */
+
+/* Floating-Point Context Address Register Definitions */
+#define FPU_FPCAR_ADDRESS_Pos               3U                                            /*!< FPCAR: ADDRESS bit Position */
+#define FPU_FPCAR_ADDRESS_Msk              (0x1FFFFFFFUL << FPU_FPCAR_ADDRESS_Pos)        /*!< FPCAR: ADDRESS bit Mask */
+
+/* Floating-Point Default Status Control Register Definitions */
+#define FPU_FPDSCR_AHP_Pos                 26U                                            /*!< FPDSCR: AHP bit Position */
+#define FPU_FPDSCR_AHP_Msk                 (1UL << FPU_FPDSCR_AHP_Pos)                    /*!< FPDSCR: AHP bit Mask */
+
+#define FPU_FPDSCR_DN_Pos                  25U                                            /*!< FPDSCR: DN bit Position */
+#define FPU_FPDSCR_DN_Msk                  (1UL << FPU_FPDSCR_DN_Pos)                     /*!< FPDSCR: DN bit Mask */
+
+#define FPU_FPDSCR_FZ_Pos                  24U                                            /*!< FPDSCR: FZ bit Position */
+#define FPU_FPDSCR_FZ_Msk                  (1UL << FPU_FPDSCR_FZ_Pos)                     /*!< FPDSCR: FZ bit Mask */
+
+#define FPU_FPDSCR_RMode_Pos               22U                                            /*!< FPDSCR: RMode bit Position */
+#define FPU_FPDSCR_RMode_Msk               (3UL << FPU_FPDSCR_RMode_Pos)                  /*!< FPDSCR: RMode bit Mask */
+
+/* Media and FP Feature Register 0 Definitions */
+#define FPU_MVFR0_FP_rounding_modes_Pos    28U                                            /*!< MVFR0: FP rounding modes bits Position */
+#define FPU_MVFR0_FP_rounding_modes_Msk    (0xFUL << FPU_MVFR0_FP_rounding_modes_Pos)     /*!< MVFR0: FP rounding modes bits Mask */
+
+#define FPU_MVFR0_Short_vectors_Pos        24U                                            /*!< MVFR0: Short vectors bits Position */
+#define FPU_MVFR0_Short_vectors_Msk        (0xFUL << FPU_MVFR0_Short_vectors_Pos)         /*!< MVFR0: Short vectors bits Mask */
+
+#define FPU_MVFR0_Square_root_Pos          20U                                            /*!< MVFR0: Square root bits Position */
+#define FPU_MVFR0_Square_root_Msk          (0xFUL << FPU_MVFR0_Square_root_Pos)           /*!< MVFR0: Square root bits Mask */
+
+#define FPU_MVFR0_Divide_Pos               16U                                            /*!< MVFR0: Divide bits Position */
+#define FPU_MVFR0_Divide_Msk               (0xFUL << FPU_MVFR0_Divide_Pos)                /*!< MVFR0: Divide bits Mask */
+
+#define FPU_MVFR0_FP_excep_trapping_Pos    12U                                            /*!< MVFR0: FP exception trapping bits Position */
+#define FPU_MVFR0_FP_excep_trapping_Msk    (0xFUL << FPU_MVFR0_FP_excep_trapping_Pos)     /*!< MVFR0: FP exception trapping bits Mask */
+
+#define FPU_MVFR0_Double_precision_Pos      8U                                            /*!< MVFR0: Double-precision bits Position */
+#define FPU_MVFR0_Double_precision_Msk     (0xFUL << FPU_MVFR0_Double_precision_Pos)      /*!< MVFR0: Double-precision bits Mask */
+
+#define FPU_MVFR0_Single_precision_Pos      4U                                            /*!< MVFR0: Single-precision bits Position */
+#define FPU_MVFR0_Single_precision_Msk     (0xFUL << FPU_MVFR0_Single_precision_Pos)      /*!< MVFR0: Single-precision bits Mask */
+
+#define FPU_MVFR0_A_SIMD_registers_Pos      0U                                            /*!< MVFR0: A_SIMD registers bits Position */
+#define FPU_MVFR0_A_SIMD_registers_Msk     (0xFUL /*<< FPU_MVFR0_A_SIMD_registers_Pos*/)  /*!< MVFR0: A_SIMD registers bits Mask */
+
+/* Media and FP Feature Register 1 Definitions */
+#define FPU_MVFR1_FP_fused_MAC_Pos         28U                                            /*!< MVFR1: FP fused MAC bits Position */
+#define FPU_MVFR1_FP_fused_MAC_Msk         (0xFUL << FPU_MVFR1_FP_fused_MAC_Pos)          /*!< MVFR1: FP fused MAC bits Mask */
+
+#define FPU_MVFR1_FP_HPFP_Pos              24U                                            /*!< MVFR1: FP HPFP bits Position */
+#define FPU_MVFR1_FP_HPFP_Msk              (0xFUL << FPU_MVFR1_FP_HPFP_Pos)               /*!< MVFR1: FP HPFP bits Mask */
+
+#define FPU_MVFR1_D_NaN_mode_Pos            4U                                            /*!< MVFR1: D_NaN mode bits Position */
+#define FPU_MVFR1_D_NaN_mode_Msk           (0xFUL << FPU_MVFR1_D_NaN_mode_Pos)            /*!< MVFR1: D_NaN mode bits Mask */
+
+#define FPU_MVFR1_FtZ_mode_Pos              0U                                            /*!< MVFR1: FtZ mode bits Position */
+#define FPU_MVFR1_FtZ_mode_Msk             (0xFUL /*<< FPU_MVFR1_FtZ_mode_Pos*/)          /*!< MVFR1: FtZ mode bits Mask */
+
+/*@} end of group CMSIS_FPU */
+
+
+/**
+  \ingroup  CMSIS_core_register
+  \defgroup CMSIS_CoreDebug       Core Debug Registers (CoreDebug)
+  \brief    Type definitions for the Core Debug Registers
+  @{
+ */
+
+/**
+  \brief  Structure type to access the Core Debug Register (CoreDebug).
+ */
+typedef struct
+{
+  __IOM uint32_t DHCSR;                  /*!< Offset: 0x000 (R/W)  Debug Halting Control and Status Register */
+  __OM  uint32_t DCRSR;                  /*!< Offset: 0x004 ( /W)  Debug Core Register Selector Register */
+  __IOM uint32_t DCRDR;                  /*!< Offset: 0x008 (R/W)  Debug Core Register Data Register */
+  __IOM uint32_t DEMCR;                  /*!< Offset: 0x00C (R/W)  Debug Exception and Monitor Control Register */
+        uint32_t RESERVED4[1U];
+  __IOM uint32_t DAUTHCTRL;              /*!< Offset: 0x014 (R/W)  Debug Authentication Control Register */
+  __IOM uint32_t DSCSR;                  /*!< Offset: 0x018 (R/W)  Debug Security Control and Status Register */
+} CoreDebug_Type;
+
+/* Debug Halting Control and Status Register Definitions */
+#define CoreDebug_DHCSR_DBGKEY_Pos         16U                                            /*!< CoreDebug DHCSR: DBGKEY Position */
+#define CoreDebug_DHCSR_DBGKEY_Msk         (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos)       /*!< CoreDebug DHCSR: DBGKEY Mask */
+
+#define CoreDebug_DHCSR_S_RESTART_ST_Pos   26U                                            /*!< CoreDebug DHCSR: S_RESTART_ST Position */
+#define CoreDebug_DHCSR_S_RESTART_ST_Msk   (1UL << CoreDebug_DHCSR_S_RESTART_ST_Pos)      /*!< CoreDebug DHCSR: S_RESTART_ST Mask */
+
+#define CoreDebug_DHCSR_S_RESET_ST_Pos     25U                                            /*!< CoreDebug DHCSR: S_RESET_ST Position */
+#define CoreDebug_DHCSR_S_RESET_ST_Msk     (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos)        /*!< CoreDebug DHCSR: S_RESET_ST Mask */
+
+#define CoreDebug_DHCSR_S_RETIRE_ST_Pos    24U                                            /*!< CoreDebug DHCSR: S_RETIRE_ST Position */
+#define CoreDebug_DHCSR_S_RETIRE_ST_Msk    (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos)       /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */
+
+#define CoreDebug_DHCSR_S_LOCKUP_Pos       19U                                            /*!< CoreDebug DHCSR: S_LOCKUP Position */
+#define CoreDebug_DHCSR_S_LOCKUP_Msk       (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos)          /*!< CoreDebug DHCSR: S_LOCKUP Mask */
+
+#define CoreDebug_DHCSR_S_SLEEP_Pos        18U                                            /*!< CoreDebug DHCSR: S_SLEEP Position */
+#define CoreDebug_DHCSR_S_SLEEP_Msk        (1UL << CoreDebug_DHCSR_S_SLEEP_Pos)           /*!< CoreDebug DHCSR: S_SLEEP Mask */
+
+#define CoreDebug_DHCSR_S_HALT_Pos         17U                                            /*!< CoreDebug DHCSR: S_HALT Position */
+#define CoreDebug_DHCSR_S_HALT_Msk         (1UL << CoreDebug_DHCSR_S_HALT_Pos)            /*!< CoreDebug DHCSR: S_HALT Mask */
+
+#define CoreDebug_DHCSR_S_REGRDY_Pos       16U                                            /*!< CoreDebug DHCSR: S_REGRDY Position */
+#define CoreDebug_DHCSR_S_REGRDY_Msk       (1UL << CoreDebug_DHCSR_S_REGRDY_Pos)          /*!< CoreDebug DHCSR: S_REGRDY Mask */
+
+#define CoreDebug_DHCSR_C_SNAPSTALL_Pos     5U                                            /*!< CoreDebug DHCSR: C_SNAPSTALL Position */
+#define CoreDebug_DHCSR_C_SNAPSTALL_Msk    (1UL << CoreDebug_DHCSR_C_SNAPSTALL_Pos)       /*!< CoreDebug DHCSR: C_SNAPSTALL Mask */
+
+#define CoreDebug_DHCSR_C_MASKINTS_Pos      3U                                            /*!< CoreDebug DHCSR: C_MASKINTS Position */
+#define CoreDebug_DHCSR_C_MASKINTS_Msk     (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos)        /*!< CoreDebug DHCSR: C_MASKINTS Mask */
+
+#define CoreDebug_DHCSR_C_STEP_Pos          2U                                            /*!< CoreDebug DHCSR: C_STEP Position */
+#define CoreDebug_DHCSR_C_STEP_Msk         (1UL << CoreDebug_DHCSR_C_STEP_Pos)            /*!< CoreDebug DHCSR: C_STEP Mask */
+
+#define CoreDebug_DHCSR_C_HALT_Pos          1U                                            /*!< CoreDebug DHCSR: C_HALT Position */
+#define CoreDebug_DHCSR_C_HALT_Msk         (1UL << CoreDebug_DHCSR_C_HALT_Pos)            /*!< CoreDebug DHCSR: C_HALT Mask */
+
+#define CoreDebug_DHCSR_C_DEBUGEN_Pos       0U                                            /*!< CoreDebug DHCSR: C_DEBUGEN Position */
+#define CoreDebug_DHCSR_C_DEBUGEN_Msk      (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/)     /*!< CoreDebug DHCSR: C_DEBUGEN Mask */
+
+/* Debug Core Register Selector Register Definitions */
+#define CoreDebug_DCRSR_REGWnR_Pos         16U                                            /*!< CoreDebug DCRSR: REGWnR Position */
+#define CoreDebug_DCRSR_REGWnR_Msk         (1UL << CoreDebug_DCRSR_REGWnR_Pos)            /*!< CoreDebug DCRSR: REGWnR Mask */
+
+#define CoreDebug_DCRSR_REGSEL_Pos          0U                                            /*!< CoreDebug DCRSR: REGSEL Position */
+#define CoreDebug_DCRSR_REGSEL_Msk         (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/)     /*!< CoreDebug DCRSR: REGSEL Mask */
+
+/* Debug Exception and Monitor Control Register Definitions */
+#define CoreDebug_DEMCR_TRCENA_Pos         24U                                            /*!< CoreDebug DEMCR: TRCENA Position */
+#define CoreDebug_DEMCR_TRCENA_Msk         (1UL << CoreDebug_DEMCR_TRCENA_Pos)            /*!< CoreDebug DEMCR: TRCENA Mask */
+
+#define CoreDebug_DEMCR_MON_REQ_Pos        19U                                            /*!< CoreDebug DEMCR: MON_REQ Position */
+#define CoreDebug_DEMCR_MON_REQ_Msk        (1UL << CoreDebug_DEMCR_MON_REQ_Pos)           /*!< CoreDebug DEMCR: MON_REQ Mask */
+
+#define CoreDebug_DEMCR_MON_STEP_Pos       18U                                            /*!< CoreDebug DEMCR: MON_STEP Position */
+#define CoreDebug_DEMCR_MON_STEP_Msk       (1UL << CoreDebug_DEMCR_MON_STEP_Pos)          /*!< CoreDebug DEMCR: MON_STEP Mask */
+
+#define CoreDebug_DEMCR_MON_PEND_Pos       17U                                            /*!< CoreDebug DEMCR: MON_PEND Position */
+#define CoreDebug_DEMCR_MON_PEND_Msk       (1UL << CoreDebug_DEMCR_MON_PEND_Pos)          /*!< CoreDebug DEMCR: MON_PEND Mask */
+
+#define CoreDebug_DEMCR_MON_EN_Pos         16U                                            /*!< CoreDebug DEMCR: MON_EN Position */
+#define CoreDebug_DEMCR_MON_EN_Msk         (1UL << CoreDebug_DEMCR_MON_EN_Pos)            /*!< CoreDebug DEMCR: MON_EN Mask */
+
+#define CoreDebug_DEMCR_VC_HARDERR_Pos     10U                                            /*!< CoreDebug DEMCR: VC_HARDERR Position */
+#define CoreDebug_DEMCR_VC_HARDERR_Msk     (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos)        /*!< CoreDebug DEMCR: VC_HARDERR Mask */
+
+#define CoreDebug_DEMCR_VC_INTERR_Pos       9U                                            /*!< CoreDebug DEMCR: VC_INTERR Position */
+#define CoreDebug_DEMCR_VC_INTERR_Msk      (1UL << CoreDebug_DEMCR_VC_INTERR_Pos)         /*!< CoreDebug DEMCR: VC_INTERR Mask */
+
+#define CoreDebug_DEMCR_VC_BUSERR_Pos       8U                                            /*!< CoreDebug DEMCR: VC_BUSERR Position */
+#define CoreDebug_DEMCR_VC_BUSERR_Msk      (1UL << CoreDebug_DEMCR_VC_BUSERR_Pos)         /*!< CoreDebug DEMCR: VC_BUSERR Mask */
+
+#define CoreDebug_DEMCR_VC_STATERR_Pos      7U                                            /*!< CoreDebug DEMCR: VC_STATERR Position */
+#define CoreDebug_DEMCR_VC_STATERR_Msk     (1UL << CoreDebug_DEMCR_VC_STATERR_Pos)        /*!< CoreDebug DEMCR: VC_STATERR Mask */
+
+#define CoreDebug_DEMCR_VC_CHKERR_Pos       6U                                            /*!< CoreDebug DEMCR: VC_CHKERR Position */
+#define CoreDebug_DEMCR_VC_CHKERR_Msk      (1UL << CoreDebug_DEMCR_VC_CHKERR_Pos)         /*!< CoreDebug DEMCR: VC_CHKERR Mask */
+
+#define CoreDebug_DEMCR_VC_NOCPERR_Pos      5U                                            /*!< CoreDebug DEMCR: VC_NOCPERR Position */
+#define CoreDebug_DEMCR_VC_NOCPERR_Msk     (1UL << CoreDebug_DEMCR_VC_NOCPERR_Pos)        /*!< CoreDebug DEMCR: VC_NOCPERR Mask */
+
+#define CoreDebug_DEMCR_VC_MMERR_Pos        4U                                            /*!< CoreDebug DEMCR: VC_MMERR Position */
+#define CoreDebug_DEMCR_VC_MMERR_Msk       (1UL << CoreDebug_DEMCR_VC_MMERR_Pos)          /*!< CoreDebug DEMCR: VC_MMERR Mask */
+
+#define CoreDebug_DEMCR_VC_CORERESET_Pos    0U                                            /*!< CoreDebug DEMCR: VC_CORERESET Position */
+#define CoreDebug_DEMCR_VC_CORERESET_Msk   (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/)  /*!< CoreDebug DEMCR: VC_CORERESET Mask */
+
+/* Debug Authentication Control Register Definitions */
+#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos  3U                                            /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Position */
+#define CoreDebug_DAUTHCTRL_INTSPNIDEN_Msk (1UL << CoreDebug_DAUTHCTRL_INTSPNIDEN_Pos)    /*!< CoreDebug DAUTHCTRL: INTSPNIDEN, Mask */
+
+#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos  2U                                            /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Position */
+#define CoreDebug_DAUTHCTRL_SPNIDENSEL_Msk (1UL << CoreDebug_DAUTHCTRL_SPNIDENSEL_Pos)    /*!< CoreDebug DAUTHCTRL: SPNIDENSEL Mask */
+
+#define CoreDebug_DAUTHCTRL_INTSPIDEN_Pos   1U                                            /*!< CoreDebug DAUTHCTRL: INTSPIDEN Position */
+#define CoreDebug_DAUTHCTRL_INTSPIDEN_Msk  (1UL << CoreDebug_DAUTHCTRL_INTSPIDEN_Pos)     /*!< CoreDebug DAUTHCTRL: INTSPIDEN Mask */
+
+#define CoreDebug_DAUTHCTRL_SPIDENSEL_Pos   0U                                            /*!< CoreDebug DAUTHCTRL: SPIDENSEL Position */
+#define CoreDebug_DAUTHCTRL_SPIDENSEL_Msk  (1UL /*<< CoreDebug_DAUTHCTRL_SPIDENSEL_Pos*/) /*!< CoreDebug DAUTHCTRL: SPIDENSEL Mask */
+
+/* Debug Security Control and Status Register Definitions */
+#define CoreDebug_DSCSR_CDS_Pos            16U                                            /*!< CoreDebug DSCSR: CDS Position */
+#define CoreDebug_DSCSR_CDS_Msk            (1UL << CoreDebug_DSCSR_CDS_Pos)               /*!< CoreDebug DSCSR: CDS Mask */
+
+#define CoreDebug_DSCSR_SBRSEL_Pos          1U                                            /*!< CoreDebug DSCSR: SBRSEL Position */
+#define CoreDebug_DSCSR_SBRSEL_Msk         (1UL << CoreDebug_DSCSR_SBRSEL_Pos)            /*!< CoreDebug DSCSR: SBRSEL Mask */
+
+#define CoreDebug_DSCSR_SBRSELEN_Pos        0U                                            /*!< CoreDebug DSCSR: SBRSELEN Position */
+#define CoreDebug_DSCSR_SBRSELEN_Msk       (1UL /*<< CoreDebug_DSCSR_SBRSELEN_Pos*/)      /*!< CoreDebug DSCSR: SBRSELEN Mask */
+
+/*@} end of group CMSIS_CoreDebug */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_core_bitfield     Core register bit field macros
+  \brief      Macros for use with bit field definitions (xxx_Pos, xxx_Msk).
+  @{
+ */
+
+/**
+  \brief   Mask and shift a bit field value for use in a register bit range.
+  \param[in] field  Name of the register bit field.
+  \param[in] value  Value of the bit field. This parameter is interpreted as an uint32_t type.
+  \return           Masked and shifted value.
+*/
+#define _VAL2FLD(field, value)    (((uint32_t)(value) << field ## _Pos) & field ## _Msk)
+
+/**
+  \brief     Mask and shift a register value to extract a bit filed value.
+  \param[in] field  Name of the register bit field.
+  \param[in] value  Value of register. This parameter is interpreted as an uint32_t type.
+  \return           Masked and shifted bit field value.
+*/
+#define _FLD2VAL(field, value)    (((uint32_t)(value) & field ## _Msk) >> field ## _Pos)
+
+/*@} end of group CMSIS_core_bitfield */
+
+
+/**
+  \ingroup    CMSIS_core_register
+  \defgroup   CMSIS_core_base     Core Definitions
+  \brief      Definitions for base addresses, unions, and structures.
+  @{
+ */
+
+/* Memory mapping of Core Hardware */
+  #define SCS_BASE            (0xE000E000UL)                             /*!< System Control Space Base Address */
+  #define ITM_BASE            (0xE0000000UL)                             /*!< ITM Base Address */
+  #define DWT_BASE            (0xE0001000UL)                             /*!< DWT Base Address */
+  #define TPI_BASE            (0xE0040000UL)                             /*!< TPI Base Address */
+  #define CoreDebug_BASE      (0xE000EDF0UL)                             /*!< Core Debug Base Address */
+  #define SysTick_BASE        (SCS_BASE +  0x0010UL)                     /*!< SysTick Base Address */
+  #define NVIC_BASE           (SCS_BASE +  0x0100UL)                     /*!< NVIC Base Address */
+  #define SCB_BASE            (SCS_BASE +  0x0D00UL)                     /*!< System Control Block Base Address */
+
+  #define SCnSCB              ((SCnSCB_Type    *)     SCS_BASE         ) /*!< System control Register not in SCB */
+  #define SCB                 ((SCB_Type       *)     SCB_BASE         ) /*!< SCB configuration struct */
+  #define SysTick             ((SysTick_Type   *)     SysTick_BASE     ) /*!< SysTick configuration struct */
+  #define NVIC                ((NVIC_Type      *)     NVIC_BASE        ) /*!< NVIC configuration struct */
+  #define ITM                 ((ITM_Type       *)     ITM_BASE         ) /*!< ITM configuration struct */
+  #define DWT                 ((DWT_Type       *)     DWT_BASE         ) /*!< DWT configuration struct */
+  #define TPI                 ((TPI_Type       *)     TPI_BASE         ) /*!< TPI configuration struct */
+  #define CoreDebug           ((CoreDebug_Type *)     CoreDebug_BASE   ) /*!< Core Debug configuration struct */
+
+  #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+    #define MPU_BASE          (SCS_BASE +  0x0D90UL)                     /*!< Memory Protection Unit */
+    #define MPU               ((MPU_Type       *)     MPU_BASE         ) /*!< Memory Protection Unit */
+  #endif
+
+  #if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+    #define SAU_BASE          (SCS_BASE +  0x0DD0UL)                     /*!< Security Attribution Unit */
+    #define SAU               ((SAU_Type       *)     SAU_BASE         ) /*!< Security Attribution Unit */
+  #endif
+
+  #define FPU_BASE            (SCS_BASE +  0x0F30UL)                     /*!< Floating Point Unit */
+  #define FPU                 ((FPU_Type       *)     FPU_BASE         ) /*!< Floating Point Unit */
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+  #define SCS_BASE_NS         (0xE002E000UL)                             /*!< System Control Space Base Address (non-secure address space) */
+  #define CoreDebug_BASE_NS   (0xE002EDF0UL)                             /*!< Core Debug Base Address           (non-secure address space) */
+  #define SysTick_BASE_NS     (SCS_BASE_NS +  0x0010UL)                  /*!< SysTick Base Address              (non-secure address space) */
+  #define NVIC_BASE_NS        (SCS_BASE_NS +  0x0100UL)                  /*!< NVIC Base Address                 (non-secure address space) */
+  #define SCB_BASE_NS         (SCS_BASE_NS +  0x0D00UL)                  /*!< System Control Block Base Address (non-secure address space) */
+
+  #define SCnSCB_NS           ((SCnSCB_Type    *)     SCS_BASE_NS      ) /*!< System control Register not in SCB(non-secure address space) */
+  #define SCB_NS              ((SCB_Type       *)     SCB_BASE_NS      ) /*!< SCB configuration struct          (non-secure address space) */
+  #define SysTick_NS          ((SysTick_Type   *)     SysTick_BASE_NS  ) /*!< SysTick configuration struct      (non-secure address space) */
+  #define NVIC_NS             ((NVIC_Type      *)     NVIC_BASE_NS     ) /*!< NVIC configuration struct         (non-secure address space) */
+  #define CoreDebug_NS        ((CoreDebug_Type *)     CoreDebug_BASE_NS) /*!< Core Debug configuration struct   (non-secure address space) */
+
+  #if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+    #define MPU_BASE_NS       (SCS_BASE_NS +  0x0D90UL)                  /*!< Memory Protection Unit            (non-secure address space) */
+    #define MPU_NS            ((MPU_Type       *)     MPU_BASE_NS      ) /*!< Memory Protection Unit            (non-secure address space) */
+  #endif
+
+  #define FPU_BASE_NS         (SCS_BASE_NS +  0x0F30UL)                  /*!< Floating Point Unit               (non-secure address space) */
+  #define FPU_NS              ((FPU_Type       *)     FPU_BASE_NS      ) /*!< Floating Point Unit               (non-secure address space) */
+
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+/*@} */
+
+
+
+/*******************************************************************************
+ *                Hardware Abstraction Layer
+  Core Function Interface contains:
+  - Core NVIC Functions
+  - Core SysTick Functions
+  - Core Debug Functions
+  - Core Register Access Functions
+ ******************************************************************************/
+/**
+  \defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference
+*/
+
+
+
+/* ##########################   NVIC functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_NVICFunctions NVIC Functions
+  \brief    Functions that manage interrupts and exceptions via the NVIC.
+  @{
+ */
+
+#ifdef CMSIS_NVIC_VIRTUAL
+  #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
+    #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
+  #endif
+  #include CMSIS_NVIC_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetPriorityGrouping    __NVIC_SetPriorityGrouping
+  #define NVIC_GetPriorityGrouping    __NVIC_GetPriorityGrouping
+  #define NVIC_EnableIRQ              __NVIC_EnableIRQ
+  #define NVIC_GetEnableIRQ           __NVIC_GetEnableIRQ
+  #define NVIC_DisableIRQ             __NVIC_DisableIRQ
+  #define NVIC_GetPendingIRQ          __NVIC_GetPendingIRQ
+  #define NVIC_SetPendingIRQ          __NVIC_SetPendingIRQ
+  #define NVIC_ClearPendingIRQ        __NVIC_ClearPendingIRQ
+  #define NVIC_GetActive              __NVIC_GetActive
+  #define NVIC_SetPriority            __NVIC_SetPriority
+  #define NVIC_GetPriority            __NVIC_GetPriority
+  #define NVIC_SystemReset            __NVIC_SystemReset
+#endif /* CMSIS_NVIC_VIRTUAL */
+
+#ifdef CMSIS_VECTAB_VIRTUAL
+  #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+    #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h"
+  #endif
+  #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetVector              __NVIC_SetVector
+  #define NVIC_GetVector              __NVIC_GetVector
+#endif  /* (CMSIS_VECTAB_VIRTUAL) */
+
+#define NVIC_USER_IRQ_OFFSET          16
+
+
+/* Special LR values for Secure/Non-Secure call handling and exception handling                                               */
+
+/* Function Return Payload (from ARMv8-M Architecture Reference Manual) LR value on entry from Secure BLXNS                   */ 
+#define FNC_RETURN                 (0xFEFFFFFFUL)     /* bit [0] ignored when processing a branch                             */
+
+/* The following EXC_RETURN mask values are used to evaluate the LR on exception entry */
+#define EXC_RETURN_PREFIX          (0xFF000000UL)     /* bits [31:24] set to indicate an EXC_RETURN value                     */
+#define EXC_RETURN_S               (0x00000040UL)     /* bit [6] stack used to push registers: 0=Non-secure 1=Secure          */
+#define EXC_RETURN_DCRS            (0x00000020UL)     /* bit [5] stacking rules for called registers: 0=skipped 1=saved       */
+#define EXC_RETURN_FTYPE           (0x00000010UL)     /* bit [4] allocate stack for floating-point context: 0=done 1=skipped  */
+#define EXC_RETURN_MODE            (0x00000008UL)     /* bit [3] processor mode for return: 0=Handler mode 1=Thread mode      */
+#define EXC_RETURN_SPSEL           (0x00000004UL)     /* bit [2] stack pointer used to restore context: 0=MSP 1=PSP           */
+#define EXC_RETURN_ES              (0x00000001UL)     /* bit [0] security state exception was taken to: 0=Non-secure 1=Secure */
+
+/* Integrity Signature (from ARMv8-M Architecture Reference Manual) for exception context stacking                            */
+#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)  /* Value for processors with floating-point extension:                  */
+#define EXC_INTEGRITY_SIGNATURE     (0xFEFA125AUL)     /* bit [0] SFTC must match LR bit[4] EXC_RETURN_FTYPE                   */
+#else 
+#define EXC_INTEGRITY_SIGNATURE     (0xFEFA125BUL)     /* Value for processors without floating-point extension                */
+#endif
+
+
+/**
+  \brief   Set Priority Grouping
+  \details Sets the priority grouping field using the required unlock sequence.
+           The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field.
+           Only values from 0..7 are used.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]      PriorityGroup  Priority grouping field.
+ */
+__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
+{
+  uint32_t reg_value;
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);             /* only values 0..7 are used          */
+
+  reg_value  =  SCB->AIRCR;                                                   /* read old register configuration    */
+  reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change               */
+  reg_value  =  (reg_value                                   |
+                ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
+                (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos)  );              /* Insert write key and priority group */
+  SCB->AIRCR =  reg_value;
+}
+
+
+/**
+  \brief   Get Priority Grouping
+  \details Reads the priority grouping field from the NVIC Interrupt Controller.
+  \return                Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field).
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void)
+{
+  return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos));
+}
+
+
+/**
+  \brief   Enable Interrupt
+  \details Enables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Enable status
+  \details Returns a device specific interrupt enable status from the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt
+  \details Disables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
+  }
+}
+
+
+/**
+  \brief   Get Pending Interrupt
+  \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not pending.
+  \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Pending Interrupt
+  \details Sets the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Clear Pending Interrupt
+  \details Clears the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Active Interrupt
+  \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not active.
+  \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   Get Interrupt Target State
+  \details Reads the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+  \return             1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_GetTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Interrupt Target State
+  \details Sets the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+                      1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_SetTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] |=  ((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)));
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Clear Interrupt Target State
+  \details Clears the interrupt target field in the NVIC and returns the interrupt target bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  if interrupt is assigned to Secure
+                      1  if interrupt is assigned to Non Secure
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t NVIC_ClearTargetState(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] &= ~((uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)));
+    return((uint32_t)(((NVIC->ITNS[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+
+/**
+  \brief   Set Interrupt Priority
+  \details Sets the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]      IRQn  Interrupt number.
+  \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every processor exception.
+ */
+__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->IPR[((uint32_t)IRQn)]               = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+  else
+  {
+    SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Priority
+  \details Reads the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn  Interrupt number.
+  \return             Interrupt Priority.
+                      Value is aligned automatically to the implemented priority bits of the microcontroller.
+ */
+__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn)
+{
+
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return(((uint32_t)NVIC->IPR[((uint32_t)IRQn)]               >> (8U - __NVIC_PRIO_BITS)));
+  }
+  else
+  {
+    return(((uint32_t)SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
+  }
+}
+
+
+/**
+  \brief   Encode Priority
+  \details Encodes the priority for an interrupt with the given priority group,
+           preemptive priority value, and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]     PriorityGroup  Used priority group.
+  \param [in]   PreemptPriority  Preemptive priority value (starting from 0).
+  \param [in]       SubPriority  Subpriority value (starting from 0).
+  \return                        Encoded priority. Value can be used in the function \ref NVIC_SetPriority().
+ */
+__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  return (
+           ((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) |
+           ((SubPriority     & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL)))
+         );
+}
+
+
+/**
+  \brief   Decode Priority
+  \details Decodes an interrupt priority value with a given priority group to
+           preemptive priority value and subpriority value.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set.
+  \param [in]         Priority   Priority value, which can be retrieved with the function \ref NVIC_GetPriority().
+  \param [in]     PriorityGroup  Used priority group.
+  \param [out] pPreemptPriority  Preemptive priority value (starting from 0).
+  \param [out]     pSubPriority  Subpriority value (starting from 0).
+ */
+__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority)
+{
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);   /* only values 0..7 are used          */
+  uint32_t PreemptPriorityBits;
+  uint32_t SubPriorityBits;
+
+  PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
+  SubPriorityBits     = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
+
+  *pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL);
+  *pSubPriority     = (Priority                   ) & (uint32_t)((1UL << (SubPriorityBits    )) - 1UL);
+}
+
+
+/**
+  \brief   Set Interrupt Vector
+  \details Sets an interrupt vector in SRAM based interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+           VTOR must been relocated to SRAM before.
+  \param [in]   IRQn      Interrupt number
+  \param [in]   vector    Address of interrupt handler function
+ */
+__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
+{
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+  vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector;
+}
+
+
+/**
+  \brief   Get Interrupt Vector
+  \details Reads an interrupt vector from interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn      Interrupt number.
+  \return                 Address of interrupt handler function
+ */
+__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn)
+{
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+  return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET];
+}
+
+
+/**
+  \brief   System Reset
+  \details Initiates a system reset request to reset the MCU.
+ */
+__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void)
+{
+  __DSB();                                                          /* Ensure all outstanding memory accesses included
+                                                                       buffered write are completed before reset */
+  SCB->AIRCR  = (uint32_t)((0x5FAUL << SCB_AIRCR_VECTKEY_Pos)    |
+                           (SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) |
+                            SCB_AIRCR_SYSRESETREQ_Msk    );         /* Keep priority group unchanged */
+  __DSB();                                                          /* Ensure completion of memory access */
+
+  for(;;)                                                           /* wait until reset */
+  {
+    __NOP();
+  }
+}
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   Set Priority Grouping (non-secure)
+  \details Sets the non-secure priority grouping field when in secure state using the required unlock sequence.
+           The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field.
+           Only values from 0..7 are used.
+           In case of a conflict between priority grouping and available
+           priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
+  \param [in]      PriorityGroup  Priority grouping field.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPriorityGrouping_NS(uint32_t PriorityGroup)
+{
+  uint32_t reg_value;
+  uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);             /* only values 0..7 are used          */
+
+  reg_value  =  SCB_NS->AIRCR;                                                /* read old register configuration    */
+  reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change               */
+  reg_value  =  (reg_value                                   |
+                ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
+                (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos)  );              /* Insert write key and priority group */
+  SCB_NS->AIRCR =  reg_value;
+}
+
+
+/**
+  \brief   Get Priority Grouping (non-secure)
+  \details Reads the priority grouping field from the non-secure NVIC when in secure state.
+  \return                Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field).
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPriorityGrouping_NS(void)
+{
+  return ((uint32_t)((SCB_NS->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos));
+}
+
+
+/**
+  \brief   Enable Interrupt (non-secure)
+  \details Enables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_EnableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Enable status (non-secure)
+  \details Returns a device specific interrupt enable status from the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetEnableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt (non-secure)
+  \details Disables a device specific interrupt in the non-secure NVIC interrupt controller when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_DisableIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Pending Interrupt (non-secure)
+  \details Reads the NVIC pending register in the non-secure NVIC when in secure state and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not pending.
+  \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Pending Interrupt (non-secure)
+  \details Sets the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Clear Pending Interrupt (non-secure)
+  \details Clears the pending bit of a device specific interrupt in the non-secure NVIC pending register when in secure state.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void TZ_NVIC_ClearPendingIRQ_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
+}
+
+
+/**
+  \brief   Get Active Interrupt (non-secure)
+  \details Reads the active register in non-secure NVIC when in secure state and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt status is not active.
+  \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetActive_NS(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC_NS->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Set Interrupt Priority (non-secure)
+  \details Sets the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]      IRQn  Interrupt number.
+  \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every non-secure processor exception.
+ */
+__STATIC_INLINE void TZ_NVIC_SetPriority_NS(IRQn_Type IRQn, uint32_t priority)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC_NS->IPR[((uint32_t)IRQn)]               = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+  else
+  {
+    SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+  }
+}
+
+
+/**
+  \brief   Get Interrupt Priority (non-secure)
+  \details Reads the priority of a non-secure device specific interrupt or a non-secure processor exception when in secure state.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn  Interrupt number.
+  \return             Interrupt Priority. Value is aligned automatically to the implemented priority bits of the microcontroller.
+ */
+__STATIC_INLINE uint32_t TZ_NVIC_GetPriority_NS(IRQn_Type IRQn)
+{
+
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return(((uint32_t)NVIC_NS->IPR[((uint32_t)IRQn)]               >> (8U - __NVIC_PRIO_BITS)));
+  }
+  else
+  {
+    return(((uint32_t)SCB_NS->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
+  }
+}
+#endif /*  defined (__ARM_FEATURE_CMSE) &&(__ARM_FEATURE_CMSE == 3U) */
+
+/*@} end of CMSIS_Core_NVICFunctions */
+
+/* ##########################  MPU functions  #################################### */
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+
+#include "mpu_armv8.h"
+
+#endif
+
+/* ##########################  FPU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_FpuFunctions FPU Functions
+  \brief    Function that provides FPU type.
+  @{
+ */
+
+/**
+  \brief   get FPU type
+  \details returns the FPU type
+  \returns
+   - \b  0: No FPU
+   - \b  1: Single precision FPU
+   - \b  2: Double + Single precision FPU
+ */
+__STATIC_INLINE uint32_t SCB_GetFPUType(void)
+{
+  uint32_t mvfr0;
+
+  mvfr0 = FPU->MVFR0;
+  if      ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x220U)
+  {
+    return 2U;           /* Double + Single precision FPU */
+  }
+  else if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x020U)
+  {
+    return 1U;           /* Single precision FPU */
+  }
+  else
+  {
+    return 0U;           /* No FPU */
+  }
+}
+
+
+/*@} end of CMSIS_Core_FpuFunctions */
+
+
+
+/* ##########################   SAU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_SAUFunctions SAU Functions
+  \brief    Functions that configure the SAU.
+  @{
+ */
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+
+/**
+  \brief   Enable SAU
+  \details Enables the Security Attribution Unit (SAU).
+ */
+__STATIC_INLINE void TZ_SAU_Enable(void)
+{
+    SAU->CTRL |=  (SAU_CTRL_ENABLE_Msk);
+}
+
+
+
+/**
+  \brief   Disable SAU
+  \details Disables the Security Attribution Unit (SAU).
+ */
+__STATIC_INLINE void TZ_SAU_Disable(void)
+{
+    SAU->CTRL &= ~(SAU_CTRL_ENABLE_Msk);
+}
+
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+/*@} end of CMSIS_Core_SAUFunctions */
+
+
+
+
+/* ##################################    SysTick function  ############################################ */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_SysTickFunctions SysTick Functions
+  \brief    Functions that configure the System.
+  @{
+ */
+
+#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
+
+/**
+  \brief   System Tick Configuration
+  \details Initializes the System Timer and its interrupt, and starts the System Tick Timer.
+           Counter is in free running mode to generate periodic interrupts.
+  \param [in]  ticks  Number of ticks between two interrupts.
+  \return          0  Function succeeded.
+  \return          1  Function failed.
+  \note    When the variable <b>__Vendor_SysTickConfig</b> is set to 1, then the
+           function <b>SysTick_Config</b> is not included. In this case, the file <b><i>device</i>.h</b>
+           must contain a vendor-specific implementation of this function.
+ */
+__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
+{
+  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
+  {
+    return (1UL);                                                   /* Reload value impossible */
+  }
+
+  SysTick->LOAD  = (uint32_t)(ticks - 1UL);                         /* set reload register */
+  NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
+  SysTick->VAL   = 0UL;                                             /* Load the SysTick Counter Value */
+  SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
+                   SysTick_CTRL_TICKINT_Msk   |
+                   SysTick_CTRL_ENABLE_Msk;                         /* Enable SysTick IRQ and SysTick Timer */
+  return (0UL);                                                     /* Function successful */
+}
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+/**
+  \brief   System Tick Configuration (non-secure)
+  \details Initializes the non-secure System Timer and its interrupt when in secure state, and starts the System Tick Timer.
+           Counter is in free running mode to generate periodic interrupts.
+  \param [in]  ticks  Number of ticks between two interrupts.
+  \return          0  Function succeeded.
+  \return          1  Function failed.
+  \note    When the variable <b>__Vendor_SysTickConfig</b> is set to 1, then the
+           function <b>TZ_SysTick_Config_NS</b> is not included. In this case, the file <b><i>device</i>.h</b>
+           must contain a vendor-specific implementation of this function.
+
+ */
+__STATIC_INLINE uint32_t TZ_SysTick_Config_NS(uint32_t ticks)
+{
+  if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
+  {
+    return (1UL);                                                         /* Reload value impossible */
+  }
+
+  SysTick_NS->LOAD  = (uint32_t)(ticks - 1UL);                            /* set reload register */
+  TZ_NVIC_SetPriority_NS (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
+  SysTick_NS->VAL   = 0UL;                                                /* Load the SysTick Counter Value */
+  SysTick_NS->CTRL  = SysTick_CTRL_CLKSOURCE_Msk |
+                      SysTick_CTRL_TICKINT_Msk   |
+                      SysTick_CTRL_ENABLE_Msk;                            /* Enable SysTick IRQ and SysTick Timer */
+  return (0UL);                                                           /* Function successful */
+}
+#endif /* defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U) */
+
+#endif
+
+/*@} end of CMSIS_Core_SysTickFunctions */
+
+
+
+/* ##################################### Debug In/Output function ########################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_core_DebugFunctions ITM Functions
+  \brief    Functions that access the ITM debug interface.
+  @{
+ */
+
+extern volatile int32_t ITM_RxBuffer;                              /*!< External variable to receive characters. */
+#define                 ITM_RXBUFFER_EMPTY  ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */
+
+
+/**
+  \brief   ITM Send Character
+  \details Transmits a character via the ITM channel 0, and
+           \li Just returns when no debugger is connected that has booked the output.
+           \li Is blocking when a debugger is connected, but the previous character sent has not been transmitted.
+  \param [in]     ch  Character to transmit.
+  \returns            Character to transmit.
+ */
+__STATIC_INLINE uint32_t ITM_SendChar (uint32_t ch)
+{
+  if (((ITM->TCR & ITM_TCR_ITMENA_Msk) != 0UL) &&      /* ITM enabled */
+      ((ITM->TER & 1UL               ) != 0UL)   )     /* ITM Port #0 enabled */
+  {
+    while (ITM->PORT[0U].u32 == 0UL)
+    {
+      __NOP();
+    }
+    ITM->PORT[0U].u8 = (uint8_t)ch;
+  }
+  return (ch);
+}
+
+
+/**
+  \brief   ITM Receive Character
+  \details Inputs a character via the external variable \ref ITM_RxBuffer.
+  \return             Received character.
+  \return         -1  No character pending.
+ */
+__STATIC_INLINE int32_t ITM_ReceiveChar (void)
+{
+  int32_t ch = -1;                           /* no character available */
+
+  if (ITM_RxBuffer != ITM_RXBUFFER_EMPTY)
+  {
+    ch = ITM_RxBuffer;
+    ITM_RxBuffer = ITM_RXBUFFER_EMPTY;       /* ready for next character */
+  }
+
+  return (ch);
+}
+
+
+/**
+  \brief   ITM Check Character
+  \details Checks whether a character is pending for reading in the variable \ref ITM_RxBuffer.
+  \return          0  No character available.
+  \return          1  Character available.
+ */
+__STATIC_INLINE int32_t ITM_CheckChar (void)
+{
+
+  if (ITM_RxBuffer == ITM_RXBUFFER_EMPTY)
+  {
+    return (0);                              /* no character available */
+  }
+  else
+  {
+    return (1);                              /*    character available */
+  }
+}
+
+/*@} end of CMSIS_core_DebugFunctions */
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CORE_CM35P_H_DEPENDANT */
+
+#endif /* __CMSIS_GENERIC */
diff --git a/lib/cmsis/inc/core_cm4.h b/lib/cmsis/inc/core_cm4.h
index dc840ebf22213..f205b333f321c 100644
--- a/lib/cmsis/inc/core_cm4.h
+++ b/lib/cmsis/inc/core_cm4.h
@@ -1,40 +1,30 @@
 /**************************************************************************//**
  * @file     core_cm4.h
  * @brief    CMSIS Cortex-M4 Core Peripheral Access Layer Header File
- * @version  V4.30
- * @date     20. October 2015
+ * @version  V5.1.0
+ * @date     13. March 2019
  ******************************************************************************/
-/* Copyright (c) 2009 - 2015 ARM LIMITED
-
-   All rights reserved.
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-   - Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in the
-     documentation and/or other materials provided with the distribution.
-   - Neither the name of ARM nor the names of its contributors may be used
-     to endorse or promote products derived from this software without
-     specific prior written permission.
-   *
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
-   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-   POSSIBILITY OF SUCH DAMAGE.
-   ---------------------------------------------------------------------------*/
-
+/*
+ * Copyright (c) 2009-2019 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #if   defined ( __ICCARM__ )
- #pragma system_include         /* treat file as system include file for MISRA check */
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
   #pragma clang system_header   /* treat file as system include file */
 #endif
 
@@ -70,60 +60,22 @@
   @{
  */
 
-/*  CMSIS CM4 definitions */
-#define __CM4_CMSIS_VERSION_MAIN  (0x04U)                                      /*!< [31:16] CMSIS HAL main version */
-#define __CM4_CMSIS_VERSION_SUB   (0x1EU)                                      /*!< [15:0]  CMSIS HAL sub version */
-#define __CM4_CMSIS_VERSION       ((__CM4_CMSIS_VERSION_MAIN << 16U) | \
-                                    __CM4_CMSIS_VERSION_SUB           )        /*!< CMSIS HAL version number */
-
-#define __CORTEX_M                (0x04U)                                      /*!< Cortex-M Core */
-
-
-#if   defined ( __CC_ARM )
-  #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler */
-  #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler */
-  #define __STATIC_INLINE  static __inline
-
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler */
-  #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler */
-  #define __STATIC_INLINE  static __inline
-
-#elif defined ( __GNUC__ )
-  #define __ASM            __asm                                      /*!< asm keyword for GNU Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for GNU Compiler */
-  #define __STATIC_INLINE  static inline
+#include "cmsis_version.h"
 
-#elif defined ( __ICCARM__ )
-  #define __ASM            __asm                                      /*!< asm keyword for IAR Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for IAR Compiler. Only available in High optimization mode! */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __TMS470__ )
-  #define __ASM            __asm                                      /*!< asm keyword for TI CCS Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __TASKING__ )
-  #define __ASM            __asm                                      /*!< asm keyword for TASKING Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for TASKING Compiler */
-  #define __STATIC_INLINE  static inline
+/* CMSIS CM4 definitions */
+#define __CM4_CMSIS_VERSION_MAIN  (__CM_CMSIS_VERSION_MAIN)              /*!< \deprecated [31:16] CMSIS HAL main version */
+#define __CM4_CMSIS_VERSION_SUB   (__CM_CMSIS_VERSION_SUB)               /*!< \deprecated [15:0]  CMSIS HAL sub version */
+#define __CM4_CMSIS_VERSION       ((__CM4_CMSIS_VERSION_MAIN << 16U) | \
+                                    __CM4_CMSIS_VERSION_SUB           )  /*!< \deprecated CMSIS HAL version number */
 
-#elif defined ( __CSMC__ )
-  #define __packed
-  #define __ASM            _asm                                      /*!< asm keyword for COSMIC Compiler */
-  #define __INLINE         inline                                    /*!< inline keyword for COSMIC Compiler. Use -pc99 on compile line */
-  #define __STATIC_INLINE  static inline
-
-#else
-  #error Unknown compiler
-#endif
+#define __CORTEX_M                (4U)                                   /*!< Cortex-M Core */
 
 /** __FPU_USED indicates whether an FPU is used or not.
     For this, __FPU_PRESENT has to be checked prior to making use of FPU specific registers and functions.
 */
 #if defined ( __CC_ARM )
   #if defined __TARGET_FPU_VFP
-    #if (__FPU_PRESENT == 1U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
       #define __FPU_USED       1U
     #else
       #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
@@ -133,9 +85,9 @@
     #define __FPU_USED         0U
   #endif
 
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #if defined __ARM_PCS_VFP
-    #if (__FPU_PRESENT == 1)
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #if defined __ARM_FP
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
       #define __FPU_USED       1U
     #else
       #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
@@ -147,7 +99,7 @@
 
 #elif defined ( __GNUC__ )
   #if defined (__VFP_FP__) && !defined(__SOFTFP__)
-    #if (__FPU_PRESENT == 1U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
       #define __FPU_USED       1U
     #else
       #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
@@ -159,7 +111,7 @@
 
 #elif defined ( __ICCARM__ )
   #if defined __ARMVFP__
-    #if (__FPU_PRESENT == 1U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
       #define __FPU_USED       1U
     #else
       #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
@@ -169,9 +121,9 @@
     #define __FPU_USED         0U
   #endif
 
-#elif defined ( __TMS470__ )
+#elif defined ( __TI_ARM__ )
   #if defined __TI_VFP_SUPPORT__
-    #if (__FPU_PRESENT == 1U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
       #define __FPU_USED       1U
     #else
       #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
@@ -183,7 +135,7 @@
 
 #elif defined ( __TASKING__ )
   #if defined __FPU_VFP__
-    #if (__FPU_PRESENT == 1U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
       #define __FPU_USED       1U
     #else
       #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
@@ -195,7 +147,7 @@
 
 #elif defined ( __CSMC__ )
   #if ( __CSMC__ & 0x400U)
-    #if (__FPU_PRESENT == 1U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
       #define __FPU_USED       1U
     #else
       #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
@@ -207,9 +159,8 @@
 
 #endif
 
-#include "core_cmInstr.h"                /* Core Instruction Access */
-#include "core_cmFunc.h"                 /* Core Function Access */
-#include "core_cmSimd.h"                 /* Compiler specific SIMD Intrinsics */
+#include "cmsis_compiler.h"               /* CMSIS compiler specific defines */
+
 
 #ifdef __cplusplus
 }
@@ -244,7 +195,7 @@
   #endif
 
   #ifndef __NVIC_PRIO_BITS
-    #define __NVIC_PRIO_BITS          4U
+    #define __NVIC_PRIO_BITS          3U
     #warning "__NVIC_PRIO_BITS not defined in device header file; using default!"
   #endif
 
@@ -367,11 +318,12 @@ typedef union
   struct
   {
     uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
-    uint32_t _reserved0:7;               /*!< bit:  9..15  Reserved */
+    uint32_t _reserved0:1;               /*!< bit:      9  Reserved */
+    uint32_t ICI_IT_1:6;                 /*!< bit: 10..15  ICI/IT part 1 */
     uint32_t GE:4;                       /*!< bit: 16..19  Greater than or Equal flags */
     uint32_t _reserved1:4;               /*!< bit: 20..23  Reserved */
-    uint32_t T:1;                        /*!< bit:     24  Thumb bit        (read 0) */
-    uint32_t IT:2;                       /*!< bit: 25..26  saved IT state   (read 0) */
+    uint32_t T:1;                        /*!< bit:     24  Thumb bit */
+    uint32_t ICI_IT_2:2;                 /*!< bit: 25..26  ICI/IT part 2 */
     uint32_t Q:1;                        /*!< bit:     27  Saturation condition flag */
     uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
     uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
@@ -397,8 +349,8 @@ typedef union
 #define xPSR_Q_Pos                         27U                                            /*!< xPSR: Q Position */
 #define xPSR_Q_Msk                         (1UL << xPSR_Q_Pos)                            /*!< xPSR: Q Mask */
 
-#define xPSR_IT_Pos                        25U                                            /*!< xPSR: IT Position */
-#define xPSR_IT_Msk                        (3UL << xPSR_IT_Pos)                           /*!< xPSR: IT Mask */
+#define xPSR_ICI_IT_2_Pos                  25U                                            /*!< xPSR: ICI/IT part 2 Position */
+#define xPSR_ICI_IT_2_Msk                  (3UL << xPSR_ICI_IT_2_Pos)                     /*!< xPSR: ICI/IT part 2 Mask */
 
 #define xPSR_T_Pos                         24U                                            /*!< xPSR: T Position */
 #define xPSR_T_Msk                         (1UL << xPSR_T_Pos)                            /*!< xPSR: T Mask */
@@ -406,6 +358,9 @@ typedef union
 #define xPSR_GE_Pos                        16U                                            /*!< xPSR: GE Position */
 #define xPSR_GE_Msk                        (0xFUL << xPSR_GE_Pos)                         /*!< xPSR: GE Mask */
 
+#define xPSR_ICI_IT_1_Pos                  10U                                            /*!< xPSR: ICI/IT part 1 Position */
+#define xPSR_ICI_IT_1_Msk                  (0x3FUL << xPSR_ICI_IT_1_Pos)                  /*!< xPSR: ICI/IT part 1 Mask */
+
 #define xPSR_ISR_Pos                        0U                                            /*!< xPSR: ISR Position */
 #define xPSR_ISR_Msk                       (0x1FFUL /*<< xPSR_ISR_Pos*/)                  /*!< xPSR: ISR Mask */
 
@@ -453,7 +408,7 @@ typedef struct
   __IOM uint32_t ISER[8U];               /*!< Offset: 0x000 (R/W)  Interrupt Set Enable Register */
         uint32_t RESERVED0[24U];
   __IOM uint32_t ICER[8U];               /*!< Offset: 0x080 (R/W)  Interrupt Clear Enable Register */
-        uint32_t RSERVED1[24U];
+        uint32_t RESERVED1[24U];
   __IOM uint32_t ISPR[8U];               /*!< Offset: 0x100 (R/W)  Interrupt Set Pending Register */
         uint32_t RESERVED2[24U];
   __IOM uint32_t ICPR[8U];               /*!< Offset: 0x180 (R/W)  Interrupt Clear Pending Register */
@@ -662,6 +617,66 @@ typedef struct
 #define SCB_CFSR_MEMFAULTSR_Pos             0U                                            /*!< SCB CFSR: Memory Manage Fault Status Register Position */
 #define SCB_CFSR_MEMFAULTSR_Msk            (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/)        /*!< SCB CFSR: Memory Manage Fault Status Register Mask */
 
+/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_MMARVALID_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 7U)               /*!< SCB CFSR (MMFSR): MMARVALID Position */
+#define SCB_CFSR_MMARVALID_Msk             (1UL << SCB_CFSR_MMARVALID_Pos)                /*!< SCB CFSR (MMFSR): MMARVALID Mask */
+
+#define SCB_CFSR_MLSPERR_Pos               (SCB_SHCSR_MEMFAULTACT_Pos + 5U)               /*!< SCB CFSR (MMFSR): MLSPERR Position */
+#define SCB_CFSR_MLSPERR_Msk               (1UL << SCB_CFSR_MLSPERR_Pos)                  /*!< SCB CFSR (MMFSR): MLSPERR Mask */
+
+#define SCB_CFSR_MSTKERR_Pos               (SCB_SHCSR_MEMFAULTACT_Pos + 4U)               /*!< SCB CFSR (MMFSR): MSTKERR Position */
+#define SCB_CFSR_MSTKERR_Msk               (1UL << SCB_CFSR_MSTKERR_Pos)                  /*!< SCB CFSR (MMFSR): MSTKERR Mask */
+
+#define SCB_CFSR_MUNSTKERR_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 3U)               /*!< SCB CFSR (MMFSR): MUNSTKERR Position */
+#define SCB_CFSR_MUNSTKERR_Msk             (1UL << SCB_CFSR_MUNSTKERR_Pos)                /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */
+
+#define SCB_CFSR_DACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 1U)               /*!< SCB CFSR (MMFSR): DACCVIOL Position */
+#define SCB_CFSR_DACCVIOL_Msk              (1UL << SCB_CFSR_DACCVIOL_Pos)                 /*!< SCB CFSR (MMFSR): DACCVIOL Mask */
+
+#define SCB_CFSR_IACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 0U)               /*!< SCB CFSR (MMFSR): IACCVIOL Position */
+#define SCB_CFSR_IACCVIOL_Msk              (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/)             /*!< SCB CFSR (MMFSR): IACCVIOL Mask */
+
+/* BusFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_BFARVALID_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 7U)                  /*!< SCB CFSR (BFSR): BFARVALID Position */
+#define SCB_CFSR_BFARVALID_Msk            (1UL << SCB_CFSR_BFARVALID_Pos)                 /*!< SCB CFSR (BFSR): BFARVALID Mask */
+
+#define SCB_CFSR_LSPERR_Pos               (SCB_CFSR_BUSFAULTSR_Pos + 5U)                  /*!< SCB CFSR (BFSR): LSPERR Position */
+#define SCB_CFSR_LSPERR_Msk               (1UL << SCB_CFSR_LSPERR_Pos)                    /*!< SCB CFSR (BFSR): LSPERR Mask */
+
+#define SCB_CFSR_STKERR_Pos               (SCB_CFSR_BUSFAULTSR_Pos + 4U)                  /*!< SCB CFSR (BFSR): STKERR Position */
+#define SCB_CFSR_STKERR_Msk               (1UL << SCB_CFSR_STKERR_Pos)                    /*!< SCB CFSR (BFSR): STKERR Mask */
+
+#define SCB_CFSR_UNSTKERR_Pos             (SCB_CFSR_BUSFAULTSR_Pos + 3U)                  /*!< SCB CFSR (BFSR): UNSTKERR Position */
+#define SCB_CFSR_UNSTKERR_Msk             (1UL << SCB_CFSR_UNSTKERR_Pos)                  /*!< SCB CFSR (BFSR): UNSTKERR Mask */
+
+#define SCB_CFSR_IMPRECISERR_Pos          (SCB_CFSR_BUSFAULTSR_Pos + 2U)                  /*!< SCB CFSR (BFSR): IMPRECISERR Position */
+#define SCB_CFSR_IMPRECISERR_Msk          (1UL << SCB_CFSR_IMPRECISERR_Pos)               /*!< SCB CFSR (BFSR): IMPRECISERR Mask */
+
+#define SCB_CFSR_PRECISERR_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 1U)                  /*!< SCB CFSR (BFSR): PRECISERR Position */
+#define SCB_CFSR_PRECISERR_Msk            (1UL << SCB_CFSR_PRECISERR_Pos)                 /*!< SCB CFSR (BFSR): PRECISERR Mask */
+
+#define SCB_CFSR_IBUSERR_Pos              (SCB_CFSR_BUSFAULTSR_Pos + 0U)                  /*!< SCB CFSR (BFSR): IBUSERR Position */
+#define SCB_CFSR_IBUSERR_Msk              (1UL << SCB_CFSR_IBUSERR_Pos)                   /*!< SCB CFSR (BFSR): IBUSERR Mask */
+
+/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_DIVBYZERO_Pos            (SCB_CFSR_USGFAULTSR_Pos + 9U)                  /*!< SCB CFSR (UFSR): DIVBYZERO Position */
+#define SCB_CFSR_DIVBYZERO_Msk            (1UL << SCB_CFSR_DIVBYZERO_Pos)                 /*!< SCB CFSR (UFSR): DIVBYZERO Mask */
+
+#define SCB_CFSR_UNALIGNED_Pos            (SCB_CFSR_USGFAULTSR_Pos + 8U)                  /*!< SCB CFSR (UFSR): UNALIGNED Position */
+#define SCB_CFSR_UNALIGNED_Msk            (1UL << SCB_CFSR_UNALIGNED_Pos)                 /*!< SCB CFSR (UFSR): UNALIGNED Mask */
+
+#define SCB_CFSR_NOCP_Pos                 (SCB_CFSR_USGFAULTSR_Pos + 3U)                  /*!< SCB CFSR (UFSR): NOCP Position */
+#define SCB_CFSR_NOCP_Msk                 (1UL << SCB_CFSR_NOCP_Pos)                      /*!< SCB CFSR (UFSR): NOCP Mask */
+
+#define SCB_CFSR_INVPC_Pos                (SCB_CFSR_USGFAULTSR_Pos + 2U)                  /*!< SCB CFSR (UFSR): INVPC Position */
+#define SCB_CFSR_INVPC_Msk                (1UL << SCB_CFSR_INVPC_Pos)                     /*!< SCB CFSR (UFSR): INVPC Mask */
+
+#define SCB_CFSR_INVSTATE_Pos             (SCB_CFSR_USGFAULTSR_Pos + 1U)                  /*!< SCB CFSR (UFSR): INVSTATE Position */
+#define SCB_CFSR_INVSTATE_Msk             (1UL << SCB_CFSR_INVSTATE_Pos)                  /*!< SCB CFSR (UFSR): INVSTATE Mask */
+
+#define SCB_CFSR_UNDEFINSTR_Pos           (SCB_CFSR_USGFAULTSR_Pos + 0U)                  /*!< SCB CFSR (UFSR): UNDEFINSTR Position */
+#define SCB_CFSR_UNDEFINSTR_Msk           (1UL << SCB_CFSR_UNDEFINSTR_Pos)                /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */
+
 /* SCB Hard Fault Status Register Definitions */
 #define SCB_HFSR_DEBUGEVT_Pos              31U                                            /*!< SCB HFSR: DEBUGEVT Position */
 #define SCB_HFSR_DEBUGEVT_Msk              (1UL << SCB_HFSR_DEBUGEVT_Pos)                 /*!< SCB HFSR: DEBUGEVT Mask */
@@ -807,10 +822,7 @@ typedef struct
   __IOM uint32_t TPR;                    /*!< Offset: 0xE40 (R/W)  ITM Trace Privilege Register */
         uint32_t RESERVED2[15U];
   __IOM uint32_t TCR;                    /*!< Offset: 0xE80 (R/W)  ITM Trace Control Register */
-        uint32_t RESERVED3[29U];
-  __OM  uint32_t IWR;                    /*!< Offset: 0xEF8 ( /W)  ITM Integration Write Register */
-  __IM  uint32_t IRR;                    /*!< Offset: 0xEFC (R/ )  ITM Integration Read Register */
-  __IOM uint32_t IMCR;                   /*!< Offset: 0xF00 (R/W)  ITM Integration Mode Control Register */
+        uint32_t RESERVED3[32U];
         uint32_t RESERVED4[43U];
   __OM  uint32_t LAR;                    /*!< Offset: 0xFB0 ( /W)  ITM Lock Access Register */
   __IM  uint32_t LSR;                    /*!< Offset: 0xFB4 (R/ )  ITM Lock Status Register */
@@ -831,7 +843,7 @@ typedef struct
 
 /* ITM Trace Privilege Register Definitions */
 #define ITM_TPR_PRIVMASK_Pos                0U                                            /*!< ITM TPR: PRIVMASK Position */
-#define ITM_TPR_PRIVMASK_Msk               (0xFUL /*<< ITM_TPR_PRIVMASK_Pos*/)            /*!< ITM TPR: PRIVMASK Mask */
+#define ITM_TPR_PRIVMASK_Msk               (0xFFFFFFFFUL /*<< ITM_TPR_PRIVMASK_Pos*/)     /*!< ITM TPR: PRIVMASK Mask */
 
 /* ITM Trace Control Register Definitions */
 #define ITM_TCR_BUSY_Pos                   23U                                            /*!< ITM TCR: BUSY Position */
@@ -861,18 +873,6 @@ typedef struct
 #define ITM_TCR_ITMENA_Pos                  0U                                            /*!< ITM TCR: ITM Enable bit Position */
 #define ITM_TCR_ITMENA_Msk                 (1UL /*<< ITM_TCR_ITMENA_Pos*/)                /*!< ITM TCR: ITM Enable bit Mask */
 
-/* ITM Integration Write Register Definitions */
-#define ITM_IWR_ATVALIDM_Pos                0U                                            /*!< ITM IWR: ATVALIDM Position */
-#define ITM_IWR_ATVALIDM_Msk               (1UL /*<< ITM_IWR_ATVALIDM_Pos*/)              /*!< ITM IWR: ATVALIDM Mask */
-
-/* ITM Integration Read Register Definitions */
-#define ITM_IRR_ATREADYM_Pos                0U                                            /*!< ITM IRR: ATREADYM Position */
-#define ITM_IRR_ATREADYM_Msk               (1UL /*<< ITM_IRR_ATREADYM_Pos*/)              /*!< ITM IRR: ATREADYM Mask */
-
-/* ITM Integration Mode Control Register Definitions */
-#define ITM_IMCR_INTEGRATION_Pos            0U                                            /*!< ITM IMCR: INTEGRATION Position */
-#define ITM_IMCR_INTEGRATION_Msk           (1UL /*<< ITM_IMCR_INTEGRATION_Pos*/)          /*!< ITM IMCR: INTEGRATION Mask */
-
 /* ITM Lock Status Register Definitions */
 #define ITM_LSR_ByteAcc_Pos                 2U                                            /*!< ITM LSR: ByteAcc Position */
 #define ITM_LSR_ByteAcc_Msk                (1UL << ITM_LSR_ByteAcc_Pos)                   /*!< ITM LSR: ByteAcc Mask */
@@ -1045,7 +1045,7 @@ typedef struct
  */
 typedef struct
 {
-  __IOM uint32_t SSPSR;                  /*!< Offset: 0x000 (R/ )  Supported Parallel Port Size Register */
+  __IM  uint32_t SSPSR;                  /*!< Offset: 0x000 (R/ )  Supported Parallel Port Size Register */
   __IOM uint32_t CSPSR;                  /*!< Offset: 0x004 (R/W)  Current Parallel Port Size Register */
         uint32_t RESERVED0[2U];
   __IOM uint32_t ACPR;                   /*!< Offset: 0x010 (R/W)  Asynchronous Clock Prescaler Register */
@@ -1056,7 +1056,7 @@ typedef struct
   __IOM uint32_t FFCR;                   /*!< Offset: 0x304 (R/W)  Formatter and Flush Control Register */
   __IM  uint32_t FSCR;                   /*!< Offset: 0x308 (R/ )  Formatter Synchronization Counter Register */
         uint32_t RESERVED3[759U];
-  __IM  uint32_t TRIGGER;                /*!< Offset: 0xEE8 (R/ )  TRIGGER */
+  __IM  uint32_t TRIGGER;                /*!< Offset: 0xEE8 (R/ )  TRIGGER Register */
   __IM  uint32_t FIFO0;                  /*!< Offset: 0xEEC (R/ )  Integration ETM Data */
   __IM  uint32_t ITATBCTR2;              /*!< Offset: 0xEF0 (R/ )  ITATBCTR2 */
         uint32_t RESERVED4[1U];
@@ -1105,13 +1105,13 @@ typedef struct
 
 /* TPI Integration ETM Data Register Definitions (FIFO0) */
 #define TPI_FIFO0_ITM_ATVALID_Pos          29U                                         /*!< TPI FIFO0: ITM_ATVALID Position */
-#define TPI_FIFO0_ITM_ATVALID_Msk          (0x3UL << TPI_FIFO0_ITM_ATVALID_Pos)        /*!< TPI FIFO0: ITM_ATVALID Mask */
+#define TPI_FIFO0_ITM_ATVALID_Msk          (0x1UL << TPI_FIFO0_ITM_ATVALID_Pos)        /*!< TPI FIFO0: ITM_ATVALID Mask */
 
 #define TPI_FIFO0_ITM_bytecount_Pos        27U                                         /*!< TPI FIFO0: ITM_bytecount Position */
 #define TPI_FIFO0_ITM_bytecount_Msk        (0x3UL << TPI_FIFO0_ITM_bytecount_Pos)      /*!< TPI FIFO0: ITM_bytecount Mask */
 
 #define TPI_FIFO0_ETM_ATVALID_Pos          26U                                         /*!< TPI FIFO0: ETM_ATVALID Position */
-#define TPI_FIFO0_ETM_ATVALID_Msk          (0x3UL << TPI_FIFO0_ETM_ATVALID_Pos)        /*!< TPI FIFO0: ETM_ATVALID Mask */
+#define TPI_FIFO0_ETM_ATVALID_Msk          (0x1UL << TPI_FIFO0_ETM_ATVALID_Pos)        /*!< TPI FIFO0: ETM_ATVALID Mask */
 
 #define TPI_FIFO0_ETM_bytecount_Pos        24U                                         /*!< TPI FIFO0: ETM_bytecount Position */
 #define TPI_FIFO0_ETM_bytecount_Msk        (0x3UL << TPI_FIFO0_ETM_bytecount_Pos)      /*!< TPI FIFO0: ETM_bytecount Mask */
@@ -1126,18 +1126,21 @@ typedef struct
 #define TPI_FIFO0_ETM0_Msk                 (0xFFUL /*<< TPI_FIFO0_ETM0_Pos*/)          /*!< TPI FIFO0: ETM0 Mask */
 
 /* TPI ITATBCTR2 Register Definitions */
-#define TPI_ITATBCTR2_ATREADY_Pos           0U                                         /*!< TPI ITATBCTR2: ATREADY Position */
-#define TPI_ITATBCTR2_ATREADY_Msk          (0x1UL /*<< TPI_ITATBCTR2_ATREADY_Pos*/)    /*!< TPI ITATBCTR2: ATREADY Mask */
+#define TPI_ITATBCTR2_ATREADY2_Pos          0U                                         /*!< TPI ITATBCTR2: ATREADY2 Position */
+#define TPI_ITATBCTR2_ATREADY2_Msk         (0x1UL /*<< TPI_ITATBCTR2_ATREADY2_Pos*/)   /*!< TPI ITATBCTR2: ATREADY2 Mask */
+
+#define TPI_ITATBCTR2_ATREADY1_Pos          0U                                         /*!< TPI ITATBCTR2: ATREADY1 Position */
+#define TPI_ITATBCTR2_ATREADY1_Msk         (0x1UL /*<< TPI_ITATBCTR2_ATREADY1_Pos*/)   /*!< TPI ITATBCTR2: ATREADY1 Mask */
 
 /* TPI Integration ITM Data Register Definitions (FIFO1) */
 #define TPI_FIFO1_ITM_ATVALID_Pos          29U                                         /*!< TPI FIFO1: ITM_ATVALID Position */
-#define TPI_FIFO1_ITM_ATVALID_Msk          (0x3UL << TPI_FIFO1_ITM_ATVALID_Pos)        /*!< TPI FIFO1: ITM_ATVALID Mask */
+#define TPI_FIFO1_ITM_ATVALID_Msk          (0x1UL << TPI_FIFO1_ITM_ATVALID_Pos)        /*!< TPI FIFO1: ITM_ATVALID Mask */
 
 #define TPI_FIFO1_ITM_bytecount_Pos        27U                                         /*!< TPI FIFO1: ITM_bytecount Position */
 #define TPI_FIFO1_ITM_bytecount_Msk        (0x3UL << TPI_FIFO1_ITM_bytecount_Pos)      /*!< TPI FIFO1: ITM_bytecount Mask */
 
 #define TPI_FIFO1_ETM_ATVALID_Pos          26U                                         /*!< TPI FIFO1: ETM_ATVALID Position */
-#define TPI_FIFO1_ETM_ATVALID_Msk          (0x3UL << TPI_FIFO1_ETM_ATVALID_Pos)        /*!< TPI FIFO1: ETM_ATVALID Mask */
+#define TPI_FIFO1_ETM_ATVALID_Msk          (0x1UL << TPI_FIFO1_ETM_ATVALID_Pos)        /*!< TPI FIFO1: ETM_ATVALID Mask */
 
 #define TPI_FIFO1_ETM_bytecount_Pos        24U                                         /*!< TPI FIFO1: ETM_bytecount Position */
 #define TPI_FIFO1_ETM_bytecount_Msk        (0x3UL << TPI_FIFO1_ETM_bytecount_Pos)      /*!< TPI FIFO1: ETM_bytecount Mask */
@@ -1152,12 +1155,15 @@ typedef struct
 #define TPI_FIFO1_ITM0_Msk                 (0xFFUL /*<< TPI_FIFO1_ITM0_Pos*/)          /*!< TPI FIFO1: ITM0 Mask */
 
 /* TPI ITATBCTR0 Register Definitions */
-#define TPI_ITATBCTR0_ATREADY_Pos           0U                                         /*!< TPI ITATBCTR0: ATREADY Position */
-#define TPI_ITATBCTR0_ATREADY_Msk          (0x1UL /*<< TPI_ITATBCTR0_ATREADY_Pos*/)    /*!< TPI ITATBCTR0: ATREADY Mask */
+#define TPI_ITATBCTR0_ATREADY2_Pos          0U                                         /*!< TPI ITATBCTR0: ATREADY2 Position */
+#define TPI_ITATBCTR0_ATREADY2_Msk         (0x1UL /*<< TPI_ITATBCTR0_ATREADY2_Pos*/)   /*!< TPI ITATBCTR0: ATREADY2 Mask */
+
+#define TPI_ITATBCTR0_ATREADY1_Pos          0U                                         /*!< TPI ITATBCTR0: ATREADY1 Position */
+#define TPI_ITATBCTR0_ATREADY1_Msk         (0x1UL /*<< TPI_ITATBCTR0_ATREADY1_Pos*/)   /*!< TPI ITATBCTR0: ATREADY1 Mask */
 
 /* TPI Integration Mode Control Register Definitions */
 #define TPI_ITCTRL_Mode_Pos                 0U                                         /*!< TPI ITCTRL: Mode Position */
-#define TPI_ITCTRL_Mode_Msk                (0x1UL /*<< TPI_ITCTRL_Mode_Pos*/)          /*!< TPI ITCTRL: Mode Mask */
+#define TPI_ITCTRL_Mode_Msk                (0x3UL /*<< TPI_ITCTRL_Mode_Pos*/)          /*!< TPI ITCTRL: Mode Mask */
 
 /* TPI DEVID Register Definitions */
 #define TPI_DEVID_NRZVALID_Pos             11U                                         /*!< TPI DEVID: NRZVALID Position */
@@ -1179,16 +1185,16 @@ typedef struct
 #define TPI_DEVID_NrTraceInput_Msk         (0x1FUL /*<< TPI_DEVID_NrTraceInput_Pos*/)  /*!< TPI DEVID: NrTraceInput Mask */
 
 /* TPI DEVTYPE Register Definitions */
-#define TPI_DEVTYPE_MajorType_Pos           4U                                         /*!< TPI DEVTYPE: MajorType Position */
-#define TPI_DEVTYPE_MajorType_Msk          (0xFUL << TPI_DEVTYPE_MajorType_Pos)        /*!< TPI DEVTYPE: MajorType Mask */
-
-#define TPI_DEVTYPE_SubType_Pos             0U                                         /*!< TPI DEVTYPE: SubType Position */
+#define TPI_DEVTYPE_SubType_Pos             4U                                         /*!< TPI DEVTYPE: SubType Position */
 #define TPI_DEVTYPE_SubType_Msk            (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/)      /*!< TPI DEVTYPE: SubType Mask */
 
+#define TPI_DEVTYPE_MajorType_Pos           0U                                         /*!< TPI DEVTYPE: MajorType Position */
+#define TPI_DEVTYPE_MajorType_Msk          (0xFUL << TPI_DEVTYPE_MajorType_Pos)        /*!< TPI DEVTYPE: MajorType Mask */
+
 /*@}*/ /* end of group CMSIS_TPI */
 
 
-#if (__MPU_PRESENT == 1U)
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
 /**
   \ingroup  CMSIS_core_register
   \defgroup CMSIS_MPU     Memory Protection Unit (MPU)
@@ -1214,6 +1220,8 @@ typedef struct
   __IOM uint32_t RASR_A3;                /*!< Offset: 0x028 (R/W)  MPU Alias 3 Region Attribute and Size Register */
 } MPU_Type;
 
+#define MPU_TYPE_RALIASES                  4U
+
 /* MPU Type Register Definitions */
 #define MPU_TYPE_IREGION_Pos               16U                                            /*!< MPU TYPE: IREGION Position */
 #define MPU_TYPE_IREGION_Msk               (0xFFUL << MPU_TYPE_IREGION_Pos)               /*!< MPU TYPE: IREGION Mask */
@@ -1280,10 +1288,9 @@ typedef struct
 #define MPU_RASR_ENABLE_Msk                (1UL /*<< MPU_RASR_ENABLE_Pos*/)               /*!< MPU RASR: Region enable bit Disable Mask */
 
 /*@} end of group CMSIS_MPU */
-#endif
+#endif /* defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) */
 
 
-#if (__FPU_PRESENT == 1U)
 /**
   \ingroup  CMSIS_core_register
   \defgroup CMSIS_FPU     Floating Point Unit (FPU)
@@ -1302,6 +1309,7 @@ typedef struct
   __IOM uint32_t FPDSCR;                 /*!< Offset: 0x00C (R/W)  Floating-Point Default Status Control Register */
   __IM  uint32_t MVFR0;                  /*!< Offset: 0x010 (R/ )  Media and FP Feature Register 0 */
   __IM  uint32_t MVFR1;                  /*!< Offset: 0x014 (R/ )  Media and FP Feature Register 1 */
+  __IM  uint32_t MVFR2;                  /*!< Offset: 0x018 (R/ )  Media and FP Feature Register 2 */
 } FPU_Type;
 
 /* Floating-Point Context Control Register Definitions */
@@ -1387,8 +1395,12 @@ typedef struct
 #define FPU_MVFR1_FtZ_mode_Pos              0U                                            /*!< MVFR1: FtZ mode bits Position */
 #define FPU_MVFR1_FtZ_mode_Msk             (0xFUL /*<< FPU_MVFR1_FtZ_mode_Pos*/)          /*!< MVFR1: FtZ mode bits Mask */
 
+/* Media and FP Feature Register 2 Definitions */
+
+#define FPU_MVFR2_VFP_Misc_Pos              4U                                            /*!< MVFR2: VFP Misc bits Position */
+#define FPU_MVFR2_VFP_Misc_Msk             (0xFUL << FPU_MVFR2_VFP_Misc_Pos)              /*!< MVFR2: VFP Misc bits Mask */
+
 /*@} end of group CMSIS_FPU */
-#endif
 
 
 /**
@@ -1506,18 +1518,18 @@ typedef struct
 /**
   \brief   Mask and shift a bit field value for use in a register bit range.
   \param[in] field  Name of the register bit field.
-  \param[in] value  Value of the bit field.
+  \param[in] value  Value of the bit field. This parameter is interpreted as an uint32_t type.
   \return           Masked and shifted value.
 */
-#define _VAL2FLD(field, value)    ((value << field ## _Pos) & field ## _Msk)
+#define _VAL2FLD(field, value)    (((uint32_t)(value) << field ## _Pos) & field ## _Msk)
 
 /**
   \brief     Mask and shift a register value to extract a bit filed value.
   \param[in] field  Name of the register bit field.
-  \param[in] value  Value of register.
+  \param[in] value  Value of register. This parameter is interpreted as an uint32_t type.
   \return           Masked and shifted bit field value.
 */
-#define _FLD2VAL(field, value)    ((value & field ## _Msk) >> field ## _Pos)
+#define _FLD2VAL(field, value)    (((uint32_t)(value) & field ## _Msk) >> field ## _Pos)
 
 /*@} end of group CMSIS_core_bitfield */
 
@@ -1529,7 +1541,7 @@ typedef struct
   @{
  */
 
-/* Memory mapping of Cortex-M4 Hardware */
+/* Memory mapping of Core Hardware */
 #define SCS_BASE            (0xE000E000UL)                            /*!< System Control Space Base Address */
 #define ITM_BASE            (0xE0000000UL)                            /*!< ITM Base Address */
 #define DWT_BASE            (0xE0001000UL)                            /*!< DWT Base Address */
@@ -1548,15 +1560,13 @@ typedef struct
 #define TPI                 ((TPI_Type       *)     TPI_BASE      )   /*!< TPI configuration struct */
 #define CoreDebug           ((CoreDebug_Type *)     CoreDebug_BASE)   /*!< Core Debug configuration struct */
 
-#if (__MPU_PRESENT == 1U)
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
   #define MPU_BASE          (SCS_BASE +  0x0D90UL)                    /*!< Memory Protection Unit */
   #define MPU               ((MPU_Type       *)     MPU_BASE      )   /*!< Memory Protection Unit */
 #endif
 
-#if (__FPU_PRESENT == 1U)
-  #define FPU_BASE          (SCS_BASE +  0x0F30UL)                    /*!< Floating Point Unit */
-  #define FPU               ((FPU_Type       *)     FPU_BASE      )   /*!< Floating Point Unit */
-#endif
+#define FPU_BASE            (SCS_BASE +  0x0F30UL)                    /*!< Floating Point Unit */
+#define FPU                 ((FPU_Type       *)     FPU_BASE      )   /*!< Floating Point Unit */
 
 /*@} */
 
@@ -1584,6 +1594,48 @@ typedef struct
   @{
  */
 
+#ifdef CMSIS_NVIC_VIRTUAL
+  #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
+    #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
+  #endif
+  #include CMSIS_NVIC_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetPriorityGrouping    __NVIC_SetPriorityGrouping
+  #define NVIC_GetPriorityGrouping    __NVIC_GetPriorityGrouping
+  #define NVIC_EnableIRQ              __NVIC_EnableIRQ
+  #define NVIC_GetEnableIRQ           __NVIC_GetEnableIRQ
+  #define NVIC_DisableIRQ             __NVIC_DisableIRQ
+  #define NVIC_GetPendingIRQ          __NVIC_GetPendingIRQ
+  #define NVIC_SetPendingIRQ          __NVIC_SetPendingIRQ
+  #define NVIC_ClearPendingIRQ        __NVIC_ClearPendingIRQ
+  #define NVIC_GetActive              __NVIC_GetActive
+  #define NVIC_SetPriority            __NVIC_SetPriority
+  #define NVIC_GetPriority            __NVIC_GetPriority
+  #define NVIC_SystemReset            __NVIC_SystemReset
+#endif /* CMSIS_NVIC_VIRTUAL */
+
+#ifdef CMSIS_VECTAB_VIRTUAL
+  #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+    #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h"
+  #endif
+  #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetVector              __NVIC_SetVector
+  #define NVIC_GetVector              __NVIC_GetVector
+#endif  /* (CMSIS_VECTAB_VIRTUAL) */
+
+#define NVIC_USER_IRQ_OFFSET          16
+
+
+/* The following EXC_RETURN values are saved the LR on exception entry */
+#define EXC_RETURN_HANDLER         (0xFFFFFFF1UL)     /* return to Handler mode, uses MSP after return                               */
+#define EXC_RETURN_THREAD_MSP      (0xFFFFFFF9UL)     /* return to Thread mode, uses MSP after return                                */
+#define EXC_RETURN_THREAD_PSP      (0xFFFFFFFDUL)     /* return to Thread mode, uses PSP after return                                */
+#define EXC_RETURN_HANDLER_FPU     (0xFFFFFFE1UL)     /* return to Handler mode, uses MSP after return, restore floating-point state */
+#define EXC_RETURN_THREAD_MSP_FPU  (0xFFFFFFE9UL)     /* return to Thread mode, uses MSP after return, restore floating-point state  */
+#define EXC_RETURN_THREAD_PSP_FPU  (0xFFFFFFEDUL)     /* return to Thread mode, uses PSP after return, restore floating-point state  */
+
+
 /**
   \brief   Set Priority Grouping
   \details Sets the priority grouping field using the required unlock sequence.
@@ -1593,7 +1645,7 @@ typedef struct
            priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
   \param [in]      PriorityGroup  Priority grouping field.
  */
-__STATIC_INLINE void NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
+__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
 {
   uint32_t reg_value;
   uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);             /* only values 0..7 are used          */
@@ -1602,7 +1654,7 @@ __STATIC_INLINE void NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
   reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change               */
   reg_value  =  (reg_value                                   |
                 ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
-                (PriorityGroupTmp << 8U)                      );              /* Insert write key and priorty group */
+                (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos)  );              /* Insert write key and priority group */
   SCB->AIRCR =  reg_value;
 }
 
@@ -1612,121 +1664,178 @@ __STATIC_INLINE void NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
   \details Reads the priority grouping field from the NVIC Interrupt Controller.
   \return                Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field).
  */
-__STATIC_INLINE uint32_t NVIC_GetPriorityGrouping(void)
+__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void)
 {
   return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos));
 }
 
 
 /**
-  \brief   Enable External Interrupt
-  \details Enables a device-specific interrupt in the NVIC interrupt controller.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \brief   Enable Interrupt
+  \details Enables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
 {
-  NVIC->ISER[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
-  \brief   Disable External Interrupt
-  \details Disables a device-specific interrupt in the NVIC interrupt controller.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \brief   Get Interrupt Enable status
+  \details Returns a device specific interrupt enable status from the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn)
 {
-  NVIC->ICER[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt
+  \details Disables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
+  }
 }
 
 
 /**
   \brief   Get Pending Interrupt
-  \details Reads the pending register in the NVIC and returns the pending bit for the specified interrupt.
-  \param [in]      IRQn  Interrupt number.
+  \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
   \return             0  Interrupt status is not pending.
   \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE uint32_t NVIC_GetPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn)
 {
-  return((uint32_t)(((NVIC->ISPR[(((uint32_t)(int32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
 }
 
 
 /**
   \brief   Set Pending Interrupt
-  \details Sets the pending bit of an external interrupt.
-  \param [in]      IRQn  Interrupt number. Value cannot be negative.
+  \details Sets the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_SetPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn)
 {
-  NVIC->ISPR[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
   \brief   Clear Pending Interrupt
-  \details Clears the pending bit of an external interrupt.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \details Clears the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_ClearPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn)
 {
-  NVIC->ICPR[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
   \brief   Get Active Interrupt
-  \details Reads the active register in NVIC and returns the active bit.
-  \param [in]      IRQn  Interrupt number.
+  \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
   \return             0  Interrupt status is not active.
   \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE uint32_t NVIC_GetActive(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn)
 {
-  return((uint32_t)(((NVIC->IABR[(((uint32_t)(int32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
 }
 
 
 /**
   \brief   Set Interrupt Priority
-  \details Sets the priority of an interrupt.
-  \note    The priority cannot be set for every core interrupt.
+  \details Sets the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
   \param [in]      IRQn  Interrupt number.
   \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every processor exception.
  */
-__STATIC_INLINE void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
+__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
 {
-  if ((int32_t)(IRQn) < 0)
+  if ((int32_t)(IRQn) >= 0)
   {
-    SCB->SHP[(((uint32_t)(int32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+    NVIC->IP[((uint32_t)IRQn)]               = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
   }
   else
   {
-    NVIC->IP[((uint32_t)(int32_t)IRQn)]               = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+    SCB->SHP[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
   }
 }
 
 
 /**
   \brief   Get Interrupt Priority
-  \details Reads the priority of an interrupt.
-           The interrupt number can be positive to specify an external (device specific) interrupt,
-           or negative to specify an internal (core) interrupt.
+  \details Reads the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
   \param [in]   IRQn  Interrupt number.
   \return             Interrupt Priority.
                       Value is aligned automatically to the implemented priority bits of the microcontroller.
  */
-__STATIC_INLINE uint32_t NVIC_GetPriority(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn)
 {
 
-  if ((int32_t)(IRQn) < 0)
+  if ((int32_t)(IRQn) >= 0)
   {
-    return(((uint32_t)SCB->SHP[(((uint32_t)(int32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
+    return(((uint32_t)NVIC->IP[((uint32_t)IRQn)]               >> (8U - __NVIC_PRIO_BITS)));
   }
   else
   {
-    return(((uint32_t)NVIC->IP[((uint32_t)(int32_t)IRQn)]               >> (8U - __NVIC_PRIO_BITS)));
+    return(((uint32_t)SCB->SHP[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
   }
 }
 
@@ -1783,11 +1892,42 @@ __STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGr
 }
 
 
+/**
+  \brief   Set Interrupt Vector
+  \details Sets an interrupt vector in SRAM based interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+           VTOR must been relocated to SRAM before.
+  \param [in]   IRQn      Interrupt number
+  \param [in]   vector    Address of interrupt handler function
+ */
+__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
+{
+  uint32_t vectors = (uint32_t )SCB->VTOR;
+  (* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)) = vector;
+}
+
+
+/**
+  \brief   Get Interrupt Vector
+  \details Reads an interrupt vector from interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn      Interrupt number.
+  \return                 Address of interrupt handler function
+ */
+__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn)
+{
+  uint32_t vectors = (uint32_t )SCB->VTOR;
+  return (uint32_t)(* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4));
+}
+
+
 /**
   \brief   System Reset
   \details Initiates a system reset request to reset the MCU.
  */
-__STATIC_INLINE void NVIC_SystemReset(void)
+__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void)
 {
   __DSB();                                                          /* Ensure all outstanding memory accesses included
                                                                        buffered write are completed before reset */
@@ -1805,6 +1945,50 @@ __STATIC_INLINE void NVIC_SystemReset(void)
 /*@} end of CMSIS_Core_NVICFunctions */
 
 
+/* ##########################  MPU functions  #################################### */
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+
+#include "mpu_armv7.h"
+
+#endif
+
+
+/* ##########################  FPU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_FpuFunctions FPU Functions
+  \brief    Function that provides FPU type.
+  @{
+ */
+
+/**
+  \brief   get FPU type
+  \details returns the FPU type
+  \returns
+   - \b  0: No FPU
+   - \b  1: Single precision FPU
+   - \b  2: Double + Single precision FPU
+ */
+__STATIC_INLINE uint32_t SCB_GetFPUType(void)
+{
+  uint32_t mvfr0;
+
+  mvfr0 = FPU->MVFR0;
+  if      ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x020U)
+  {
+    return 1U;           /* Single precision FPU */
+  }
+  else
+  {
+    return 0U;           /* No FPU */
+  }
+}
+
+
+/*@} end of CMSIS_Core_FpuFunctions */
+
+
 
 /* ##################################    SysTick function  ############################################ */
 /**
@@ -1814,7 +1998,7 @@ __STATIC_INLINE void NVIC_SystemReset(void)
   @{
  */
 
-#if (__Vendor_SysTickConfig == 0U)
+#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
 
 /**
   \brief   System Tick Configuration
@@ -1857,8 +2041,8 @@ __STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
   @{
  */
 
-extern volatile int32_t ITM_RxBuffer;                    /*!< External variable to receive characters. */
-#define                 ITM_RXBUFFER_EMPTY   0x5AA55AA5U /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */
+extern volatile int32_t ITM_RxBuffer;                              /*!< External variable to receive characters. */
+#define                 ITM_RXBUFFER_EMPTY  ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */
 
 
 /**
diff --git a/lib/cmsis/inc/core_cm7.h b/lib/cmsis/inc/core_cm7.h
index 3b7530ad505b5..41f9afb64daff 100644
--- a/lib/cmsis/inc/core_cm7.h
+++ b/lib/cmsis/inc/core_cm7.h
@@ -1,40 +1,30 @@
 /**************************************************************************//**
  * @file     core_cm7.h
  * @brief    CMSIS Cortex-M7 Core Peripheral Access Layer Header File
- * @version  V4.30
- * @date     20. October 2015
+ * @version  V5.1.0
+ * @date     13. March 2019
  ******************************************************************************/
-/* Copyright (c) 2009 - 2015 ARM LIMITED
-
-   All rights reserved.
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-   - Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in the
-     documentation and/or other materials provided with the distribution.
-   - Neither the name of ARM nor the names of its contributors may be used
-     to endorse or promote products derived from this software without
-     specific prior written permission.
-   *
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
-   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-   POSSIBILITY OF SUCH DAMAGE.
-   ---------------------------------------------------------------------------*/
-
+/*
+ * Copyright (c) 2009-2019 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #if   defined ( __ICCARM__ )
- #pragma system_include         /* treat file as system include file for MISRA check */
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
   #pragma clang system_header   /* treat file as system include file */
 #endif
 
@@ -70,60 +60,22 @@
   @{
  */
 
-/*  CMSIS CM7 definitions */
-#define __CM7_CMSIS_VERSION_MAIN  (0x04U)                                      /*!< [31:16] CMSIS HAL main version */
-#define __CM7_CMSIS_VERSION_SUB   (0x1EU)                                      /*!< [15:0]  CMSIS HAL sub version */
-#define __CM7_CMSIS_VERSION       ((__CM7_CMSIS_VERSION_MAIN << 16U) | \
-                                    __CM7_CMSIS_VERSION_SUB           )        /*!< CMSIS HAL version number */
-
-#define __CORTEX_M                (0x07U)                                      /*!< Cortex-M Core */
-
+#include "cmsis_version.h"
 
-#if   defined ( __CC_ARM )
-  #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler */
-  #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler */
-  #define __STATIC_INLINE  static __inline
-
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler */
-  #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler */
-  #define __STATIC_INLINE  static __inline
-
-#elif defined ( __GNUC__ )
-  #define __ASM            __asm                                      /*!< asm keyword for GNU Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for GNU Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __ICCARM__ )
-  #define __ASM            __asm                                      /*!< asm keyword for IAR Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for IAR Compiler. Only available in High optimization mode! */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __TMS470__ )
-  #define __ASM            __asm                                      /*!< asm keyword for TI CCS Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __TASKING__ )
-  #define __ASM            __asm                                      /*!< asm keyword for TASKING Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for TASKING Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __CSMC__ )
-  #define __packed
-  #define __ASM            _asm                                      /*!< asm keyword for COSMIC Compiler */
-  #define __INLINE         inline                                    /*!< inline keyword for COSMIC Compiler. Use -pc99 on compile line */
-  #define __STATIC_INLINE  static inline
+/* CMSIS CM7 definitions */
+#define __CM7_CMSIS_VERSION_MAIN  (__CM_CMSIS_VERSION_MAIN)                  /*!< \deprecated [31:16] CMSIS HAL main version */
+#define __CM7_CMSIS_VERSION_SUB   ( __CM_CMSIS_VERSION_SUB)                  /*!< \deprecated [15:0]  CMSIS HAL sub version */
+#define __CM7_CMSIS_VERSION       ((__CM7_CMSIS_VERSION_MAIN << 16U) | \
+                                    __CM7_CMSIS_VERSION_SUB           )      /*!< \deprecated CMSIS HAL version number */
 
-#else
-  #error Unknown compiler
-#endif
+#define __CORTEX_M                (7U)                                       /*!< Cortex-M Core */
 
 /** __FPU_USED indicates whether an FPU is used or not.
     For this, __FPU_PRESENT has to be checked prior to making use of FPU specific registers and functions.
 */
 #if defined ( __CC_ARM )
   #if defined __TARGET_FPU_VFP
-    #if (__FPU_PRESENT == 1U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
       #define __FPU_USED       1U
     #else
       #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
@@ -133,9 +85,9 @@
     #define __FPU_USED         0U
   #endif
 
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #if defined __ARM_PCS_VFP
-    #if (__FPU_PRESENT == 1)
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #if defined __ARM_FP
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
       #define __FPU_USED       1U
     #else
       #warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
@@ -147,7 +99,7 @@
 
 #elif defined ( __GNUC__ )
   #if defined (__VFP_FP__) && !defined(__SOFTFP__)
-    #if (__FPU_PRESENT == 1U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
       #define __FPU_USED       1U
     #else
       #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
@@ -159,7 +111,7 @@
 
 #elif defined ( __ICCARM__ )
   #if defined __ARMVFP__
-    #if (__FPU_PRESENT == 1U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
       #define __FPU_USED       1U
     #else
       #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
@@ -169,9 +121,9 @@
     #define __FPU_USED         0U
   #endif
 
-#elif defined ( __TMS470__ )
+#elif defined ( __TI_ARM__ )
   #if defined __TI_VFP_SUPPORT__
-    #if (__FPU_PRESENT == 1U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
       #define __FPU_USED       1U
     #else
       #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
@@ -183,7 +135,7 @@
 
 #elif defined ( __TASKING__ )
   #if defined __FPU_VFP__
-    #if (__FPU_PRESENT == 1U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
       #define __FPU_USED       1U
     #else
       #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
@@ -195,7 +147,7 @@
 
 #elif defined ( __CSMC__ )
   #if ( __CSMC__ & 0x400U)
-    #if (__FPU_PRESENT == 1U)
+    #if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
       #define __FPU_USED       1U
     #else
       #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
@@ -207,9 +159,8 @@
 
 #endif
 
-#include "core_cmInstr.h"                /* Core Instruction Access */
-#include "core_cmFunc.h"                 /* Core Function Access */
-#include "core_cmSimd.h"                 /* Compiler specific SIMD Intrinsics */
+#include "cmsis_compiler.h"               /* CMSIS compiler specific defines */
+
 
 #ifdef __cplusplus
 }
@@ -382,11 +333,12 @@ typedef union
   struct
   {
     uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
-    uint32_t _reserved0:7;               /*!< bit:  9..15  Reserved */
+    uint32_t _reserved0:1;               /*!< bit:      9  Reserved */
+    uint32_t ICI_IT_1:6;                 /*!< bit: 10..15  ICI/IT part 1 */
     uint32_t GE:4;                       /*!< bit: 16..19  Greater than or Equal flags */
     uint32_t _reserved1:4;               /*!< bit: 20..23  Reserved */
-    uint32_t T:1;                        /*!< bit:     24  Thumb bit        (read 0) */
-    uint32_t IT:2;                       /*!< bit: 25..26  saved IT state   (read 0) */
+    uint32_t T:1;                        /*!< bit:     24  Thumb bit */
+    uint32_t ICI_IT_2:2;                 /*!< bit: 25..26  ICI/IT part 2 */
     uint32_t Q:1;                        /*!< bit:     27  Saturation condition flag */
     uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
     uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
@@ -412,8 +364,8 @@ typedef union
 #define xPSR_Q_Pos                         27U                                            /*!< xPSR: Q Position */
 #define xPSR_Q_Msk                         (1UL << xPSR_Q_Pos)                            /*!< xPSR: Q Mask */
 
-#define xPSR_IT_Pos                        25U                                            /*!< xPSR: IT Position */
-#define xPSR_IT_Msk                        (3UL << xPSR_IT_Pos)                           /*!< xPSR: IT Mask */
+#define xPSR_ICI_IT_2_Pos                  25U                                            /*!< xPSR: ICI/IT part 2 Position */
+#define xPSR_ICI_IT_2_Msk                  (3UL << xPSR_ICI_IT_2_Pos)                     /*!< xPSR: ICI/IT part 2 Mask */
 
 #define xPSR_T_Pos                         24U                                            /*!< xPSR: T Position */
 #define xPSR_T_Msk                         (1UL << xPSR_T_Pos)                            /*!< xPSR: T Mask */
@@ -421,6 +373,9 @@ typedef union
 #define xPSR_GE_Pos                        16U                                            /*!< xPSR: GE Position */
 #define xPSR_GE_Msk                        (0xFUL << xPSR_GE_Pos)                         /*!< xPSR: GE Mask */
 
+#define xPSR_ICI_IT_1_Pos                  10U                                            /*!< xPSR: ICI/IT part 1 Position */
+#define xPSR_ICI_IT_1_Msk                  (0x3FUL << xPSR_ICI_IT_1_Pos)                  /*!< xPSR: ICI/IT part 1 Mask */
+
 #define xPSR_ISR_Pos                        0U                                            /*!< xPSR: ISR Position */
 #define xPSR_ISR_Msk                       (0x1FFUL /*<< xPSR_ISR_Pos*/)                  /*!< xPSR: ISR Mask */
 
@@ -468,7 +423,7 @@ typedef struct
   __IOM uint32_t ISER[8U];               /*!< Offset: 0x000 (R/W)  Interrupt Set Enable Register */
         uint32_t RESERVED0[24U];
   __IOM uint32_t ICER[8U];               /*!< Offset: 0x080 (R/W)  Interrupt Clear Enable Register */
-        uint32_t RSERVED1[24U];
+        uint32_t RESERVED1[24U];
   __IOM uint32_t ISPR[8U];               /*!< Offset: 0x100 (R/W)  Interrupt Set Pending Register */
         uint32_t RESERVED2[24U];
   __IOM uint32_t ICPR[8U];               /*!< Offset: 0x180 (R/W)  Interrupt Clear Pending Register */
@@ -529,7 +484,7 @@ typedef struct
         uint32_t RESERVED4[15U];
   __IM  uint32_t MVFR0;                  /*!< Offset: 0x240 (R/ )  Media and VFP Feature Register 0 */
   __IM  uint32_t MVFR1;                  /*!< Offset: 0x244 (R/ )  Media and VFP Feature Register 1 */
-  __IM  uint32_t MVFR2;                  /*!< Offset: 0x248 (R/ )  Media and VFP Feature Register 1 */
+  __IM  uint32_t MVFR2;                  /*!< Offset: 0x248 (R/ )  Media and VFP Feature Register 2 */
         uint32_t RESERVED5[1U];
   __OM  uint32_t ICIALLU;                /*!< Offset: 0x250 ( /W)  I-Cache Invalidate All to PoU */
         uint32_t RESERVED6[1U];
@@ -715,6 +670,66 @@ typedef struct
 #define SCB_CFSR_MEMFAULTSR_Pos             0U                                            /*!< SCB CFSR: Memory Manage Fault Status Register Position */
 #define SCB_CFSR_MEMFAULTSR_Msk            (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/)        /*!< SCB CFSR: Memory Manage Fault Status Register Mask */
 
+/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_MMARVALID_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 7U)               /*!< SCB CFSR (MMFSR): MMARVALID Position */
+#define SCB_CFSR_MMARVALID_Msk             (1UL << SCB_CFSR_MMARVALID_Pos)                /*!< SCB CFSR (MMFSR): MMARVALID Mask */
+
+#define SCB_CFSR_MLSPERR_Pos               (SCB_SHCSR_MEMFAULTACT_Pos + 5U)               /*!< SCB CFSR (MMFSR): MLSPERR Position */
+#define SCB_CFSR_MLSPERR_Msk               (1UL << SCB_CFSR_MLSPERR_Pos)                  /*!< SCB CFSR (MMFSR): MLSPERR Mask */
+
+#define SCB_CFSR_MSTKERR_Pos               (SCB_SHCSR_MEMFAULTACT_Pos + 4U)               /*!< SCB CFSR (MMFSR): MSTKERR Position */
+#define SCB_CFSR_MSTKERR_Msk               (1UL << SCB_CFSR_MSTKERR_Pos)                  /*!< SCB CFSR (MMFSR): MSTKERR Mask */
+
+#define SCB_CFSR_MUNSTKERR_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 3U)               /*!< SCB CFSR (MMFSR): MUNSTKERR Position */
+#define SCB_CFSR_MUNSTKERR_Msk             (1UL << SCB_CFSR_MUNSTKERR_Pos)                /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */
+
+#define SCB_CFSR_DACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 1U)               /*!< SCB CFSR (MMFSR): DACCVIOL Position */
+#define SCB_CFSR_DACCVIOL_Msk              (1UL << SCB_CFSR_DACCVIOL_Pos)                 /*!< SCB CFSR (MMFSR): DACCVIOL Mask */
+
+#define SCB_CFSR_IACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 0U)               /*!< SCB CFSR (MMFSR): IACCVIOL Position */
+#define SCB_CFSR_IACCVIOL_Msk              (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/)             /*!< SCB CFSR (MMFSR): IACCVIOL Mask */
+
+/* BusFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_BFARVALID_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 7U)                  /*!< SCB CFSR (BFSR): BFARVALID Position */
+#define SCB_CFSR_BFARVALID_Msk            (1UL << SCB_CFSR_BFARVALID_Pos)                 /*!< SCB CFSR (BFSR): BFARVALID Mask */
+
+#define SCB_CFSR_LSPERR_Pos               (SCB_CFSR_BUSFAULTSR_Pos + 5U)                  /*!< SCB CFSR (BFSR): LSPERR Position */
+#define SCB_CFSR_LSPERR_Msk               (1UL << SCB_CFSR_LSPERR_Pos)                    /*!< SCB CFSR (BFSR): LSPERR Mask */
+
+#define SCB_CFSR_STKERR_Pos               (SCB_CFSR_BUSFAULTSR_Pos + 4U)                  /*!< SCB CFSR (BFSR): STKERR Position */
+#define SCB_CFSR_STKERR_Msk               (1UL << SCB_CFSR_STKERR_Pos)                    /*!< SCB CFSR (BFSR): STKERR Mask */
+
+#define SCB_CFSR_UNSTKERR_Pos             (SCB_CFSR_BUSFAULTSR_Pos + 3U)                  /*!< SCB CFSR (BFSR): UNSTKERR Position */
+#define SCB_CFSR_UNSTKERR_Msk             (1UL << SCB_CFSR_UNSTKERR_Pos)                  /*!< SCB CFSR (BFSR): UNSTKERR Mask */
+
+#define SCB_CFSR_IMPRECISERR_Pos          (SCB_CFSR_BUSFAULTSR_Pos + 2U)                  /*!< SCB CFSR (BFSR): IMPRECISERR Position */
+#define SCB_CFSR_IMPRECISERR_Msk          (1UL << SCB_CFSR_IMPRECISERR_Pos)               /*!< SCB CFSR (BFSR): IMPRECISERR Mask */
+
+#define SCB_CFSR_PRECISERR_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 1U)                  /*!< SCB CFSR (BFSR): PRECISERR Position */
+#define SCB_CFSR_PRECISERR_Msk            (1UL << SCB_CFSR_PRECISERR_Pos)                 /*!< SCB CFSR (BFSR): PRECISERR Mask */
+
+#define SCB_CFSR_IBUSERR_Pos              (SCB_CFSR_BUSFAULTSR_Pos + 0U)                  /*!< SCB CFSR (BFSR): IBUSERR Position */
+#define SCB_CFSR_IBUSERR_Msk              (1UL << SCB_CFSR_IBUSERR_Pos)                   /*!< SCB CFSR (BFSR): IBUSERR Mask */
+
+/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_DIVBYZERO_Pos            (SCB_CFSR_USGFAULTSR_Pos + 9U)                  /*!< SCB CFSR (UFSR): DIVBYZERO Position */
+#define SCB_CFSR_DIVBYZERO_Msk            (1UL << SCB_CFSR_DIVBYZERO_Pos)                 /*!< SCB CFSR (UFSR): DIVBYZERO Mask */
+
+#define SCB_CFSR_UNALIGNED_Pos            (SCB_CFSR_USGFAULTSR_Pos + 8U)                  /*!< SCB CFSR (UFSR): UNALIGNED Position */
+#define SCB_CFSR_UNALIGNED_Msk            (1UL << SCB_CFSR_UNALIGNED_Pos)                 /*!< SCB CFSR (UFSR): UNALIGNED Mask */
+
+#define SCB_CFSR_NOCP_Pos                 (SCB_CFSR_USGFAULTSR_Pos + 3U)                  /*!< SCB CFSR (UFSR): NOCP Position */
+#define SCB_CFSR_NOCP_Msk                 (1UL << SCB_CFSR_NOCP_Pos)                      /*!< SCB CFSR (UFSR): NOCP Mask */
+
+#define SCB_CFSR_INVPC_Pos                (SCB_CFSR_USGFAULTSR_Pos + 2U)                  /*!< SCB CFSR (UFSR): INVPC Position */
+#define SCB_CFSR_INVPC_Msk                (1UL << SCB_CFSR_INVPC_Pos)                     /*!< SCB CFSR (UFSR): INVPC Mask */
+
+#define SCB_CFSR_INVSTATE_Pos             (SCB_CFSR_USGFAULTSR_Pos + 1U)                  /*!< SCB CFSR (UFSR): INVSTATE Position */
+#define SCB_CFSR_INVSTATE_Msk             (1UL << SCB_CFSR_INVSTATE_Pos)                  /*!< SCB CFSR (UFSR): INVSTATE Mask */
+
+#define SCB_CFSR_UNDEFINSTR_Pos           (SCB_CFSR_USGFAULTSR_Pos + 0U)                  /*!< SCB CFSR (UFSR): UNDEFINSTR Position */
+#define SCB_CFSR_UNDEFINSTR_Msk           (1UL << SCB_CFSR_UNDEFINSTR_Pos)                /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */
+
 /* SCB Hard Fault Status Register Definitions */
 #define SCB_HFSR_DEBUGEVT_Pos              31U                                            /*!< SCB HFSR: DEBUGEVT Position */
 #define SCB_HFSR_DEBUGEVT_Msk              (1UL << SCB_HFSR_DEBUGEVT_Pos)                 /*!< SCB HFSR: DEBUGEVT Mask */
@@ -915,6 +930,24 @@ typedef struct
 #define SCnSCB_ICTR_INTLINESNUM_Msk        (0xFUL /*<< SCnSCB_ICTR_INTLINESNUM_Pos*/)  /*!< ICTR: INTLINESNUM Mask */
 
 /* Auxiliary Control Register Definitions */
+#define SCnSCB_ACTLR_DISDYNADD_Pos         26U                                         /*!< ACTLR: DISDYNADD Position */
+#define SCnSCB_ACTLR_DISDYNADD_Msk         (1UL << SCnSCB_ACTLR_DISDYNADD_Pos)         /*!< ACTLR: DISDYNADD Mask */
+
+#define SCnSCB_ACTLR_DISISSCH1_Pos         21U                                         /*!< ACTLR: DISISSCH1 Position */
+#define SCnSCB_ACTLR_DISISSCH1_Msk         (0x1FUL << SCnSCB_ACTLR_DISISSCH1_Pos)      /*!< ACTLR: DISISSCH1 Mask */
+
+#define SCnSCB_ACTLR_DISDI_Pos             16U                                         /*!< ACTLR: DISDI Position */
+#define SCnSCB_ACTLR_DISDI_Msk             (0x1FUL << SCnSCB_ACTLR_DISDI_Pos)          /*!< ACTLR: DISDI Mask */
+
+#define SCnSCB_ACTLR_DISCRITAXIRUR_Pos     15U                                         /*!< ACTLR: DISCRITAXIRUR Position */
+#define SCnSCB_ACTLR_DISCRITAXIRUR_Msk     (1UL << SCnSCB_ACTLR_DISCRITAXIRUR_Pos)     /*!< ACTLR: DISCRITAXIRUR Mask */
+
+#define SCnSCB_ACTLR_DISBTACALLOC_Pos      14U                                         /*!< ACTLR: DISBTACALLOC Position */
+#define SCnSCB_ACTLR_DISBTACALLOC_Msk      (1UL << SCnSCB_ACTLR_DISBTACALLOC_Pos)      /*!< ACTLR: DISBTACALLOC Mask */
+
+#define SCnSCB_ACTLR_DISBTACREAD_Pos       13U                                         /*!< ACTLR: DISBTACREAD Position */
+#define SCnSCB_ACTLR_DISBTACREAD_Msk       (1UL << SCnSCB_ACTLR_DISBTACREAD_Pos)       /*!< ACTLR: DISBTACREAD Mask */
+
 #define SCnSCB_ACTLR_DISITMATBFLUSH_Pos    12U                                         /*!< ACTLR: DISITMATBFLUSH Position */
 #define SCnSCB_ACTLR_DISITMATBFLUSH_Msk    (1UL << SCnSCB_ACTLR_DISITMATBFLUSH_Pos)    /*!< ACTLR: DISITMATBFLUSH Mask */
 
@@ -1009,10 +1042,7 @@ typedef struct
   __IOM uint32_t TPR;                    /*!< Offset: 0xE40 (R/W)  ITM Trace Privilege Register */
         uint32_t RESERVED2[15U];
   __IOM uint32_t TCR;                    /*!< Offset: 0xE80 (R/W)  ITM Trace Control Register */
-        uint32_t RESERVED3[29U];
-  __OM  uint32_t IWR;                    /*!< Offset: 0xEF8 ( /W)  ITM Integration Write Register */
-  __IM  uint32_t IRR;                    /*!< Offset: 0xEFC (R/ )  ITM Integration Read Register */
-  __IOM uint32_t IMCR;                   /*!< Offset: 0xF00 (R/W)  ITM Integration Mode Control Register */
+        uint32_t RESERVED3[32U];
         uint32_t RESERVED4[43U];
   __OM  uint32_t LAR;                    /*!< Offset: 0xFB0 ( /W)  ITM Lock Access Register */
   __IM  uint32_t LSR;                    /*!< Offset: 0xFB4 (R/ )  ITM Lock Status Register */
@@ -1033,7 +1063,7 @@ typedef struct
 
 /* ITM Trace Privilege Register Definitions */
 #define ITM_TPR_PRIVMASK_Pos                0U                                            /*!< ITM TPR: PRIVMASK Position */
-#define ITM_TPR_PRIVMASK_Msk               (0xFUL /*<< ITM_TPR_PRIVMASK_Pos*/)            /*!< ITM TPR: PRIVMASK Mask */
+#define ITM_TPR_PRIVMASK_Msk               (0xFFFFFFFFUL /*<< ITM_TPR_PRIVMASK_Pos*/)     /*!< ITM TPR: PRIVMASK Mask */
 
 /* ITM Trace Control Register Definitions */
 #define ITM_TCR_BUSY_Pos                   23U                                            /*!< ITM TCR: BUSY Position */
@@ -1063,18 +1093,6 @@ typedef struct
 #define ITM_TCR_ITMENA_Pos                  0U                                            /*!< ITM TCR: ITM Enable bit Position */
 #define ITM_TCR_ITMENA_Msk                 (1UL /*<< ITM_TCR_ITMENA_Pos*/)                /*!< ITM TCR: ITM Enable bit Mask */
 
-/* ITM Integration Write Register Definitions */
-#define ITM_IWR_ATVALIDM_Pos                0U                                            /*!< ITM IWR: ATVALIDM Position */
-#define ITM_IWR_ATVALIDM_Msk               (1UL /*<< ITM_IWR_ATVALIDM_Pos*/)              /*!< ITM IWR: ATVALIDM Mask */
-
-/* ITM Integration Read Register Definitions */
-#define ITM_IRR_ATREADYM_Pos                0U                                            /*!< ITM IRR: ATREADYM Position */
-#define ITM_IRR_ATREADYM_Msk               (1UL /*<< ITM_IRR_ATREADYM_Pos*/)              /*!< ITM IRR: ATREADYM Mask */
-
-/* ITM Integration Mode Control Register Definitions */
-#define ITM_IMCR_INTEGRATION_Pos            0U                                            /*!< ITM IMCR: INTEGRATION Position */
-#define ITM_IMCR_INTEGRATION_Msk           (1UL /*<< ITM_IMCR_INTEGRATION_Pos*/)          /*!< ITM IMCR: INTEGRATION Mask */
-
 /* ITM Lock Status Register Definitions */
 #define ITM_LSR_ByteAcc_Pos                 2U                                            /*!< ITM LSR: ByteAcc Position */
 #define ITM_LSR_ByteAcc_Msk                (1UL << ITM_LSR_ByteAcc_Pos)                   /*!< ITM LSR: ByteAcc Mask */
@@ -1250,7 +1268,7 @@ typedef struct
  */
 typedef struct
 {
-  __IOM uint32_t SSPSR;                  /*!< Offset: 0x000 (R/ )  Supported Parallel Port Size Register */
+  __IM  uint32_t SSPSR;                  /*!< Offset: 0x000 (R/ )  Supported Parallel Port Size Register */
   __IOM uint32_t CSPSR;                  /*!< Offset: 0x004 (R/W)  Current Parallel Port Size Register */
         uint32_t RESERVED0[2U];
   __IOM uint32_t ACPR;                   /*!< Offset: 0x010 (R/W)  Asynchronous Clock Prescaler Register */
@@ -1261,7 +1279,7 @@ typedef struct
   __IOM uint32_t FFCR;                   /*!< Offset: 0x304 (R/W)  Formatter and Flush Control Register */
   __IM  uint32_t FSCR;                   /*!< Offset: 0x308 (R/ )  Formatter Synchronization Counter Register */
         uint32_t RESERVED3[759U];
-  __IM  uint32_t TRIGGER;                /*!< Offset: 0xEE8 (R/ )  TRIGGER */
+  __IM  uint32_t TRIGGER;                /*!< Offset: 0xEE8 (R/ )  TRIGGER Register */
   __IM  uint32_t FIFO0;                  /*!< Offset: 0xEEC (R/ )  Integration ETM Data */
   __IM  uint32_t ITATBCTR2;              /*!< Offset: 0xEF0 (R/ )  ITATBCTR2 */
         uint32_t RESERVED4[1U];
@@ -1310,13 +1328,13 @@ typedef struct
 
 /* TPI Integration ETM Data Register Definitions (FIFO0) */
 #define TPI_FIFO0_ITM_ATVALID_Pos          29U                                         /*!< TPI FIFO0: ITM_ATVALID Position */
-#define TPI_FIFO0_ITM_ATVALID_Msk          (0x3UL << TPI_FIFO0_ITM_ATVALID_Pos)        /*!< TPI FIFO0: ITM_ATVALID Mask */
+#define TPI_FIFO0_ITM_ATVALID_Msk          (0x1UL << TPI_FIFO0_ITM_ATVALID_Pos)        /*!< TPI FIFO0: ITM_ATVALID Mask */
 
 #define TPI_FIFO0_ITM_bytecount_Pos        27U                                         /*!< TPI FIFO0: ITM_bytecount Position */
 #define TPI_FIFO0_ITM_bytecount_Msk        (0x3UL << TPI_FIFO0_ITM_bytecount_Pos)      /*!< TPI FIFO0: ITM_bytecount Mask */
 
 #define TPI_FIFO0_ETM_ATVALID_Pos          26U                                         /*!< TPI FIFO0: ETM_ATVALID Position */
-#define TPI_FIFO0_ETM_ATVALID_Msk          (0x3UL << TPI_FIFO0_ETM_ATVALID_Pos)        /*!< TPI FIFO0: ETM_ATVALID Mask */
+#define TPI_FIFO0_ETM_ATVALID_Msk          (0x1UL << TPI_FIFO0_ETM_ATVALID_Pos)        /*!< TPI FIFO0: ETM_ATVALID Mask */
 
 #define TPI_FIFO0_ETM_bytecount_Pos        24U                                         /*!< TPI FIFO0: ETM_bytecount Position */
 #define TPI_FIFO0_ETM_bytecount_Msk        (0x3UL << TPI_FIFO0_ETM_bytecount_Pos)      /*!< TPI FIFO0: ETM_bytecount Mask */
@@ -1331,18 +1349,21 @@ typedef struct
 #define TPI_FIFO0_ETM0_Msk                 (0xFFUL /*<< TPI_FIFO0_ETM0_Pos*/)          /*!< TPI FIFO0: ETM0 Mask */
 
 /* TPI ITATBCTR2 Register Definitions */
-#define TPI_ITATBCTR2_ATREADY_Pos           0U                                         /*!< TPI ITATBCTR2: ATREADY Position */
-#define TPI_ITATBCTR2_ATREADY_Msk          (0x1UL /*<< TPI_ITATBCTR2_ATREADY_Pos*/)    /*!< TPI ITATBCTR2: ATREADY Mask */
+#define TPI_ITATBCTR2_ATREADY2_Pos          0U                                         /*!< TPI ITATBCTR2: ATREADY2 Position */
+#define TPI_ITATBCTR2_ATREADY2_Msk         (0x1UL /*<< TPI_ITATBCTR2_ATREADY2_Pos*/)   /*!< TPI ITATBCTR2: ATREADY2 Mask */
+
+#define TPI_ITATBCTR2_ATREADY1_Pos          0U                                         /*!< TPI ITATBCTR2: ATREADY1 Position */
+#define TPI_ITATBCTR2_ATREADY1_Msk         (0x1UL /*<< TPI_ITATBCTR2_ATREADY1_Pos*/)   /*!< TPI ITATBCTR2: ATREADY1 Mask */
 
 /* TPI Integration ITM Data Register Definitions (FIFO1) */
 #define TPI_FIFO1_ITM_ATVALID_Pos          29U                                         /*!< TPI FIFO1: ITM_ATVALID Position */
-#define TPI_FIFO1_ITM_ATVALID_Msk          (0x3UL << TPI_FIFO1_ITM_ATVALID_Pos)        /*!< TPI FIFO1: ITM_ATVALID Mask */
+#define TPI_FIFO1_ITM_ATVALID_Msk          (0x1UL << TPI_FIFO1_ITM_ATVALID_Pos)        /*!< TPI FIFO1: ITM_ATVALID Mask */
 
 #define TPI_FIFO1_ITM_bytecount_Pos        27U                                         /*!< TPI FIFO1: ITM_bytecount Position */
 #define TPI_FIFO1_ITM_bytecount_Msk        (0x3UL << TPI_FIFO1_ITM_bytecount_Pos)      /*!< TPI FIFO1: ITM_bytecount Mask */
 
 #define TPI_FIFO1_ETM_ATVALID_Pos          26U                                         /*!< TPI FIFO1: ETM_ATVALID Position */
-#define TPI_FIFO1_ETM_ATVALID_Msk          (0x3UL << TPI_FIFO1_ETM_ATVALID_Pos)        /*!< TPI FIFO1: ETM_ATVALID Mask */
+#define TPI_FIFO1_ETM_ATVALID_Msk          (0x1UL << TPI_FIFO1_ETM_ATVALID_Pos)        /*!< TPI FIFO1: ETM_ATVALID Mask */
 
 #define TPI_FIFO1_ETM_bytecount_Pos        24U                                         /*!< TPI FIFO1: ETM_bytecount Position */
 #define TPI_FIFO1_ETM_bytecount_Msk        (0x3UL << TPI_FIFO1_ETM_bytecount_Pos)      /*!< TPI FIFO1: ETM_bytecount Mask */
@@ -1357,12 +1378,15 @@ typedef struct
 #define TPI_FIFO1_ITM0_Msk                 (0xFFUL /*<< TPI_FIFO1_ITM0_Pos*/)          /*!< TPI FIFO1: ITM0 Mask */
 
 /* TPI ITATBCTR0 Register Definitions */
-#define TPI_ITATBCTR0_ATREADY_Pos           0U                                         /*!< TPI ITATBCTR0: ATREADY Position */
-#define TPI_ITATBCTR0_ATREADY_Msk          (0x1UL /*<< TPI_ITATBCTR0_ATREADY_Pos*/)    /*!< TPI ITATBCTR0: ATREADY Mask */
+#define TPI_ITATBCTR0_ATREADY2_Pos          0U                                         /*!< TPI ITATBCTR0: ATREADY2 Position */
+#define TPI_ITATBCTR0_ATREADY2_Msk         (0x1UL /*<< TPI_ITATBCTR0_ATREADY2_Pos*/)   /*!< TPI ITATBCTR0: ATREADY2 Mask */
+
+#define TPI_ITATBCTR0_ATREADY1_Pos          0U                                         /*!< TPI ITATBCTR0: ATREADY1 Position */
+#define TPI_ITATBCTR0_ATREADY1_Msk         (0x1UL /*<< TPI_ITATBCTR0_ATREADY1_Pos*/)   /*!< TPI ITATBCTR0: ATREADY1 Mask */
 
 /* TPI Integration Mode Control Register Definitions */
 #define TPI_ITCTRL_Mode_Pos                 0U                                         /*!< TPI ITCTRL: Mode Position */
-#define TPI_ITCTRL_Mode_Msk                (0x1UL /*<< TPI_ITCTRL_Mode_Pos*/)          /*!< TPI ITCTRL: Mode Mask */
+#define TPI_ITCTRL_Mode_Msk                (0x3UL /*<< TPI_ITCTRL_Mode_Pos*/)          /*!< TPI ITCTRL: Mode Mask */
 
 /* TPI DEVID Register Definitions */
 #define TPI_DEVID_NRZVALID_Pos             11U                                         /*!< TPI DEVID: NRZVALID Position */
@@ -1384,16 +1408,16 @@ typedef struct
 #define TPI_DEVID_NrTraceInput_Msk         (0x1FUL /*<< TPI_DEVID_NrTraceInput_Pos*/)  /*!< TPI DEVID: NrTraceInput Mask */
 
 /* TPI DEVTYPE Register Definitions */
-#define TPI_DEVTYPE_MajorType_Pos           4U                                         /*!< TPI DEVTYPE: MajorType Position */
-#define TPI_DEVTYPE_MajorType_Msk          (0xFUL << TPI_DEVTYPE_MajorType_Pos)        /*!< TPI DEVTYPE: MajorType Mask */
-
-#define TPI_DEVTYPE_SubType_Pos             0U                                         /*!< TPI DEVTYPE: SubType Position */
+#define TPI_DEVTYPE_SubType_Pos             4U                                         /*!< TPI DEVTYPE: SubType Position */
 #define TPI_DEVTYPE_SubType_Msk            (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/)      /*!< TPI DEVTYPE: SubType Mask */
 
+#define TPI_DEVTYPE_MajorType_Pos           0U                                         /*!< TPI DEVTYPE: MajorType Position */
+#define TPI_DEVTYPE_MajorType_Msk          (0xFUL << TPI_DEVTYPE_MajorType_Pos)        /*!< TPI DEVTYPE: MajorType Mask */
+
 /*@}*/ /* end of group CMSIS_TPI */
 
 
-#if (__MPU_PRESENT == 1U)
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
 /**
   \ingroup  CMSIS_core_register
   \defgroup CMSIS_MPU     Memory Protection Unit (MPU)
@@ -1419,6 +1443,8 @@ typedef struct
   __IOM uint32_t RASR_A3;                /*!< Offset: 0x028 (R/W)  MPU Alias 3 Region Attribute and Size Register */
 } MPU_Type;
 
+#define MPU_TYPE_RALIASES                  4U
+
 /* MPU Type Register Definitions */
 #define MPU_TYPE_IREGION_Pos               16U                                            /*!< MPU TYPE: IREGION Position */
 #define MPU_TYPE_IREGION_Msk               (0xFFUL << MPU_TYPE_IREGION_Pos)               /*!< MPU TYPE: IREGION Mask */
@@ -1485,10 +1511,9 @@ typedef struct
 #define MPU_RASR_ENABLE_Msk                (1UL /*<< MPU_RASR_ENABLE_Pos*/)               /*!< MPU RASR: Region enable bit Disable Mask */
 
 /*@} end of group CMSIS_MPU */
-#endif
+#endif /* defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) */
 
 
-#if (__FPU_PRESENT == 1U)
 /**
   \ingroup  CMSIS_core_register
   \defgroup CMSIS_FPU     Floating Point Unit (FPU)
@@ -1595,8 +1620,10 @@ typedef struct
 
 /* Media and FP Feature Register 2 Definitions */
 
+#define FPU_MVFR2_VFP_Misc_Pos              4U                                            /*!< MVFR2: VFP Misc bits Position */
+#define FPU_MVFR2_VFP_Misc_Msk             (0xFUL << FPU_MVFR2_VFP_Misc_Pos)              /*!< MVFR2: VFP Misc bits Mask */
+
 /*@} end of group CMSIS_FPU */
-#endif
 
 
 /**
@@ -1714,18 +1741,18 @@ typedef struct
 /**
   \brief   Mask and shift a bit field value for use in a register bit range.
   \param[in] field  Name of the register bit field.
-  \param[in] value  Value of the bit field.
+  \param[in] value  Value of the bit field. This parameter is interpreted as an uint32_t type.
   \return           Masked and shifted value.
 */
-#define _VAL2FLD(field, value)    ((value << field ## _Pos) & field ## _Msk)
+#define _VAL2FLD(field, value)    (((uint32_t)(value) << field ## _Pos) & field ## _Msk)
 
 /**
   \brief     Mask and shift a register value to extract a bit filed value.
   \param[in] field  Name of the register bit field.
-  \param[in] value  Value of register.
+  \param[in] value  Value of register. This parameter is interpreted as an uint32_t type.
   \return           Masked and shifted bit field value.
 */
-#define _FLD2VAL(field, value)    ((value & field ## _Msk) >> field ## _Pos)
+#define _FLD2VAL(field, value)    (((uint32_t)(value) & field ## _Msk) >> field ## _Pos)
 
 /*@} end of group CMSIS_core_bitfield */
 
@@ -1737,7 +1764,7 @@ typedef struct
   @{
  */
 
-/* Memory mapping of Cortex-M4 Hardware */
+/* Memory mapping of Core Hardware */
 #define SCS_BASE            (0xE000E000UL)                            /*!< System Control Space Base Address */
 #define ITM_BASE            (0xE0000000UL)                            /*!< ITM Base Address */
 #define DWT_BASE            (0xE0001000UL)                            /*!< DWT Base Address */
@@ -1756,15 +1783,13 @@ typedef struct
 #define TPI                 ((TPI_Type       *)     TPI_BASE      )   /*!< TPI configuration struct */
 #define CoreDebug           ((CoreDebug_Type *)     CoreDebug_BASE)   /*!< Core Debug configuration struct */
 
-#if (__MPU_PRESENT == 1U)
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
   #define MPU_BASE          (SCS_BASE +  0x0D90UL)                    /*!< Memory Protection Unit */
   #define MPU               ((MPU_Type       *)     MPU_BASE      )   /*!< Memory Protection Unit */
 #endif
 
-#if (__FPU_PRESENT == 1U)
-  #define FPU_BASE          (SCS_BASE +  0x0F30UL)                    /*!< Floating Point Unit */
-  #define FPU               ((FPU_Type       *)     FPU_BASE      )   /*!< Floating Point Unit */
-#endif
+#define FPU_BASE            (SCS_BASE +  0x0F30UL)                    /*!< Floating Point Unit */
+#define FPU                 ((FPU_Type       *)     FPU_BASE      )   /*!< Floating Point Unit */
 
 /*@} */
 
@@ -1792,6 +1817,48 @@ typedef struct
   @{
  */
 
+#ifdef CMSIS_NVIC_VIRTUAL
+  #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
+    #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
+  #endif
+  #include CMSIS_NVIC_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetPriorityGrouping    __NVIC_SetPriorityGrouping
+  #define NVIC_GetPriorityGrouping    __NVIC_GetPriorityGrouping
+  #define NVIC_EnableIRQ              __NVIC_EnableIRQ
+  #define NVIC_GetEnableIRQ           __NVIC_GetEnableIRQ
+  #define NVIC_DisableIRQ             __NVIC_DisableIRQ
+  #define NVIC_GetPendingIRQ          __NVIC_GetPendingIRQ
+  #define NVIC_SetPendingIRQ          __NVIC_SetPendingIRQ
+  #define NVIC_ClearPendingIRQ        __NVIC_ClearPendingIRQ
+  #define NVIC_GetActive              __NVIC_GetActive
+  #define NVIC_SetPriority            __NVIC_SetPriority
+  #define NVIC_GetPriority            __NVIC_GetPriority
+  #define NVIC_SystemReset            __NVIC_SystemReset
+#endif /* CMSIS_NVIC_VIRTUAL */
+
+#ifdef CMSIS_VECTAB_VIRTUAL
+  #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+    #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h"
+  #endif
+  #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetVector              __NVIC_SetVector
+  #define NVIC_GetVector              __NVIC_GetVector
+#endif  /* (CMSIS_VECTAB_VIRTUAL) */
+
+#define NVIC_USER_IRQ_OFFSET          16
+
+
+/* The following EXC_RETURN values are saved the LR on exception entry */
+#define EXC_RETURN_HANDLER         (0xFFFFFFF1UL)     /* return to Handler mode, uses MSP after return                               */
+#define EXC_RETURN_THREAD_MSP      (0xFFFFFFF9UL)     /* return to Thread mode, uses MSP after return                                */
+#define EXC_RETURN_THREAD_PSP      (0xFFFFFFFDUL)     /* return to Thread mode, uses PSP after return                                */
+#define EXC_RETURN_HANDLER_FPU     (0xFFFFFFE1UL)     /* return to Handler mode, uses MSP after return, restore floating-point state */
+#define EXC_RETURN_THREAD_MSP_FPU  (0xFFFFFFE9UL)     /* return to Thread mode, uses MSP after return, restore floating-point state  */
+#define EXC_RETURN_THREAD_PSP_FPU  (0xFFFFFFEDUL)     /* return to Thread mode, uses PSP after return, restore floating-point state  */
+
+
 /**
   \brief   Set Priority Grouping
   \details Sets the priority grouping field using the required unlock sequence.
@@ -1801,7 +1868,7 @@ typedef struct
            priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
   \param [in]      PriorityGroup  Priority grouping field.
  */
-__STATIC_INLINE void NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
+__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
 {
   uint32_t reg_value;
   uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);             /* only values 0..7 are used          */
@@ -1810,7 +1877,7 @@ __STATIC_INLINE void NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
   reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change               */
   reg_value  =  (reg_value                                   |
                 ((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
-                (PriorityGroupTmp << 8U)                      );              /* Insert write key and priorty group */
+                (PriorityGroupTmp << SCB_AIRCR_PRIGROUP_Pos)  );              /* Insert write key and priority group */
   SCB->AIRCR =  reg_value;
 }
 
@@ -1820,121 +1887,178 @@ __STATIC_INLINE void NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
   \details Reads the priority grouping field from the NVIC Interrupt Controller.
   \return                Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field).
  */
-__STATIC_INLINE uint32_t NVIC_GetPriorityGrouping(void)
+__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void)
 {
   return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos));
 }
 
 
 /**
-  \brief   Enable External Interrupt
-  \details Enables a device-specific interrupt in the NVIC interrupt controller.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \brief   Enable Interrupt
+  \details Enables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
 {
-  NVIC->ISER[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
-  \brief   Disable External Interrupt
-  \details Disables a device-specific interrupt in the NVIC interrupt controller.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \brief   Get Interrupt Enable status
+  \details Returns a device specific interrupt enable status from the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn)
 {
-  NVIC->ICER[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt
+  \details Disables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
+  }
 }
 
 
 /**
   \brief   Get Pending Interrupt
-  \details Reads the pending register in the NVIC and returns the pending bit for the specified interrupt.
-  \param [in]      IRQn  Interrupt number.
+  \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
   \return             0  Interrupt status is not pending.
   \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE uint32_t NVIC_GetPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn)
 {
-  return((uint32_t)(((NVIC->ISPR[(((uint32_t)(int32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
 }
 
 
 /**
   \brief   Set Pending Interrupt
-  \details Sets the pending bit of an external interrupt.
-  \param [in]      IRQn  Interrupt number. Value cannot be negative.
+  \details Sets the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_SetPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn)
 {
-  NVIC->ISPR[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
   \brief   Clear Pending Interrupt
-  \details Clears the pending bit of an external interrupt.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \details Clears the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_ClearPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn)
 {
-  NVIC->ICPR[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
   \brief   Get Active Interrupt
-  \details Reads the active register in NVIC and returns the active bit.
-  \param [in]      IRQn  Interrupt number.
+  \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
   \return             0  Interrupt status is not active.
   \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE uint32_t NVIC_GetActive(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn)
 {
-  return((uint32_t)(((NVIC->IABR[(((uint32_t)(int32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
 }
 
 
 /**
   \brief   Set Interrupt Priority
-  \details Sets the priority of an interrupt.
-  \note    The priority cannot be set for every core interrupt.
+  \details Sets the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
   \param [in]      IRQn  Interrupt number.
   \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every processor exception.
  */
-__STATIC_INLINE void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
+__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
 {
-  if ((int32_t)(IRQn) < 0)
+  if ((int32_t)(IRQn) >= 0)
   {
-    SCB->SHPR[(((uint32_t)(int32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+    NVIC->IP[((uint32_t)IRQn)]                = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
   }
   else
   {
-    NVIC->IP[((uint32_t)(int32_t)IRQn)]                = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+    SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
   }
 }
 
 
 /**
   \brief   Get Interrupt Priority
-  \details Reads the priority of an interrupt.
-           The interrupt number can be positive to specify an external (device specific) interrupt,
-           or negative to specify an internal (core) interrupt.
+  \details Reads the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
   \param [in]   IRQn  Interrupt number.
   \return             Interrupt Priority.
                       Value is aligned automatically to the implemented priority bits of the microcontroller.
  */
-__STATIC_INLINE uint32_t NVIC_GetPriority(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn)
 {
 
-  if ((int32_t)(IRQn) < 0)
+  if ((int32_t)(IRQn) >= 0)
   {
-    return(((uint32_t)SCB->SHPR[(((uint32_t)(int32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
+    return(((uint32_t)NVIC->IP[((uint32_t)IRQn)]                >> (8U - __NVIC_PRIO_BITS)));
   }
   else
   {
-    return(((uint32_t)NVIC->IP[((uint32_t)(int32_t)IRQn)]                >> (8U - __NVIC_PRIO_BITS)));
+    return(((uint32_t)SCB->SHPR[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
   }
 }
 
@@ -1991,11 +2115,42 @@ __STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGr
 }
 
 
+/**
+  \brief   Set Interrupt Vector
+  \details Sets an interrupt vector in SRAM based interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+           VTOR must been relocated to SRAM before.
+  \param [in]   IRQn      Interrupt number
+  \param [in]   vector    Address of interrupt handler function
+ */
+__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
+{
+  uint32_t vectors = (uint32_t )SCB->VTOR;
+  (* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4)) = vector;
+}
+
+
+/**
+  \brief   Get Interrupt Vector
+  \details Reads an interrupt vector from interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn      Interrupt number.
+  \return                 Address of interrupt handler function
+ */
+__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn)
+{
+  uint32_t vectors = (uint32_t )SCB->VTOR;
+  return (uint32_t)(* (int *) (vectors + ((int32_t)IRQn + NVIC_USER_IRQ_OFFSET) * 4));
+}
+
+
 /**
   \brief   System Reset
   \details Initiates a system reset request to reset the MCU.
  */
-__STATIC_INLINE void NVIC_SystemReset(void)
+__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void)
 {
   __DSB();                                                          /* Ensure all outstanding memory accesses included
                                                                        buffered write are completed before reset */
@@ -2013,6 +2168,15 @@ __STATIC_INLINE void NVIC_SystemReset(void)
 /*@} end of CMSIS_Core_NVICFunctions */
 
 
+/* ##########################  MPU functions  #################################### */
+
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
+
+#include "mpu_armv7.h"
+
+#endif
+
+
 /* ##########################  FPU functions  #################################### */
 /**
   \ingroup  CMSIS_Core_FunctionInterface
@@ -2034,21 +2198,20 @@ __STATIC_INLINE uint32_t SCB_GetFPUType(void)
   uint32_t mvfr0;
 
   mvfr0 = SCB->MVFR0;
-  if        ((mvfr0 & 0x00000FF0UL) == 0x220UL)
+  if      ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x220U)
   {
-    return 2UL;           /* Double + Single precision FPU */
+    return 2U;           /* Double + Single precision FPU */
   }
-  else if ((mvfr0 & 0x00000FF0UL) == 0x020UL)
+  else if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x020U)
   {
-    return 1UL;           /* Single precision FPU */
+    return 1U;           /* Single precision FPU */
   }
   else
   {
-    return 0UL;           /* No FPU */
+    return 0U;           /* No FPU */
   }
 }
 
-
 /*@} end of CMSIS_Core_FpuFunctions */
 
 
@@ -2065,17 +2228,22 @@ __STATIC_INLINE uint32_t SCB_GetFPUType(void)
 #define CCSIDR_WAYS(x)         (((x) & SCB_CCSIDR_ASSOCIATIVITY_Msk) >> SCB_CCSIDR_ASSOCIATIVITY_Pos)
 #define CCSIDR_SETS(x)         (((x) & SCB_CCSIDR_NUMSETS_Msk      ) >> SCB_CCSIDR_NUMSETS_Pos      )
 
+#define __SCB_DCACHE_LINE_SIZE  32U /*!< Cortex-M7 cache line size is fixed to 32 bytes (8 words). See also register SCB_CCSIDR */
 
 /**
   \brief   Enable I-Cache
   \details Turns on I-Cache
   */
-__STATIC_INLINE void SCB_EnableICache (void)
+__STATIC_FORCEINLINE void SCB_EnableICache (void)
 {
-  #if (__ICACHE_PRESENT == 1U)
+  #if defined (__ICACHE_PRESENT) && (__ICACHE_PRESENT == 1U)
+    if (SCB->CCR & SCB_CCR_IC_Msk) return;  /* return if ICache is already enabled */
+
     __DSB();
     __ISB();
     SCB->ICIALLU = 0UL;                     /* invalidate I-Cache */
+    __DSB();
+    __ISB();
     SCB->CCR |=  (uint32_t)SCB_CCR_IC_Msk;  /* enable I-Cache */
     __DSB();
     __ISB();
@@ -2087,9 +2255,9 @@ __STATIC_INLINE void SCB_EnableICache (void)
   \brief   Disable I-Cache
   \details Turns off I-Cache
   */
-__STATIC_INLINE void SCB_DisableICache (void)
+__STATIC_FORCEINLINE void SCB_DisableICache (void)
 {
-  #if (__ICACHE_PRESENT == 1U)
+  #if defined (__ICACHE_PRESENT) && (__ICACHE_PRESENT == 1U)
     __DSB();
     __ISB();
     SCB->CCR &= ~(uint32_t)SCB_CCR_IC_Msk;  /* disable I-Cache */
@@ -2104,9 +2272,9 @@ __STATIC_INLINE void SCB_DisableICache (void)
   \brief   Invalidate I-Cache
   \details Invalidates I-Cache
   */
-__STATIC_INLINE void SCB_InvalidateICache (void)
+__STATIC_FORCEINLINE void SCB_InvalidateICache (void)
 {
-  #if (__ICACHE_PRESENT == 1U)
+  #if defined (__ICACHE_PRESENT) && (__ICACHE_PRESENT == 1U)
     __DSB();
     __ISB();
     SCB->ICIALLU = 0UL;
@@ -2120,14 +2288,16 @@ __STATIC_INLINE void SCB_InvalidateICache (void)
   \brief   Enable D-Cache
   \details Turns on D-Cache
   */
-__STATIC_INLINE void SCB_EnableDCache (void)
+__STATIC_FORCEINLINE void SCB_EnableDCache (void)
 {
-  #if (__DCACHE_PRESENT == 1U)
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
     uint32_t ccsidr;
     uint32_t sets;
     uint32_t ways;
 
-    SCB->CSSELR = (0U << 1U) | 0U;          /* Level 1 data cache */
+    if (SCB->CCR & SCB_CCR_DC_Msk) return;  /* return if DCache is already enabled */
+
+    SCB->CSSELR = 0U;                       /* select Level 1 data cache */
     __DSB();
 
     ccsidr = SCB->CCSIDR;
@@ -2142,8 +2312,8 @@ __STATIC_INLINE void SCB_EnableDCache (void)
         #if defined ( __CC_ARM )
           __schedule_barrier();
         #endif
-      } while (ways--);
-    } while(sets--);
+      } while (ways-- != 0U);
+    } while(sets-- != 0U);
     __DSB();
 
     SCB->CCR |=  (uint32_t)SCB_CCR_DC_Msk;  /* enable D-Cache */
@@ -2158,19 +2328,20 @@ __STATIC_INLINE void SCB_EnableDCache (void)
   \brief   Disable D-Cache
   \details Turns off D-Cache
   */
-__STATIC_INLINE void SCB_DisableDCache (void)
+__STATIC_FORCEINLINE void SCB_DisableDCache (void)
 {
-  #if (__DCACHE_PRESENT == 1U)
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
     uint32_t ccsidr;
     uint32_t sets;
     uint32_t ways;
 
-    SCB->CSSELR = (0U << 1U) | 0U;          /* Level 1 data cache */
+    SCB->CSSELR = 0U;                       /* select Level 1 data cache */
     __DSB();
 
-    ccsidr = SCB->CCSIDR;
-
     SCB->CCR &= ~(uint32_t)SCB_CCR_DC_Msk;  /* disable D-Cache */
+    __DSB();
+
+    ccsidr = SCB->CCSIDR;
 
                                             /* clean & invalidate D-Cache */
     sets = (uint32_t)(CCSIDR_SETS(ccsidr));
@@ -2182,8 +2353,8 @@ __STATIC_INLINE void SCB_DisableDCache (void)
         #if defined ( __CC_ARM )
           __schedule_barrier();
         #endif
-      } while (ways--);
-    } while(sets--);
+      } while (ways-- != 0U);
+    } while(sets-- != 0U);
 
     __DSB();
     __ISB();
@@ -2195,14 +2366,14 @@ __STATIC_INLINE void SCB_DisableDCache (void)
   \brief   Invalidate D-Cache
   \details Invalidates D-Cache
   */
-__STATIC_INLINE void SCB_InvalidateDCache (void)
+__STATIC_FORCEINLINE void SCB_InvalidateDCache (void)
 {
-  #if (__DCACHE_PRESENT == 1U)
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
     uint32_t ccsidr;
     uint32_t sets;
     uint32_t ways;
 
-    SCB->CSSELR = (0U << 1U) | 0U;          /* Level 1 data cache */
+    SCB->CSSELR = 0U;                       /* select Level 1 data cache */
     __DSB();
 
     ccsidr = SCB->CCSIDR;
@@ -2217,8 +2388,8 @@ __STATIC_INLINE void SCB_InvalidateDCache (void)
         #if defined ( __CC_ARM )
           __schedule_barrier();
         #endif
-      } while (ways--);
-    } while(sets--);
+      } while (ways-- != 0U);
+    } while(sets-- != 0U);
 
     __DSB();
     __ISB();
@@ -2230,14 +2401,14 @@ __STATIC_INLINE void SCB_InvalidateDCache (void)
   \brief   Clean D-Cache
   \details Cleans D-Cache
   */
-__STATIC_INLINE void SCB_CleanDCache (void)
+__STATIC_FORCEINLINE void SCB_CleanDCache (void)
 {
-  #if (__DCACHE_PRESENT == 1U)
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
     uint32_t ccsidr;
     uint32_t sets;
     uint32_t ways;
 
-    SCB->CSSELR = (0U << 1U) | 0U;          /* Level 1 data cache */
+    SCB->CSSELR = 0U;                       /* select Level 1 data cache */
     __DSB();
 
     ccsidr = SCB->CCSIDR;
@@ -2252,8 +2423,8 @@ __STATIC_INLINE void SCB_CleanDCache (void)
         #if defined ( __CC_ARM )
           __schedule_barrier();
         #endif
-      } while (ways--);
-    } while(sets--);
+      } while (ways-- != 0U);
+    } while(sets-- != 0U);
 
     __DSB();
     __ISB();
@@ -2265,14 +2436,14 @@ __STATIC_INLINE void SCB_CleanDCache (void)
   \brief   Clean & Invalidate D-Cache
   \details Cleans and Invalidates D-Cache
   */
-__STATIC_INLINE void SCB_CleanInvalidateDCache (void)
+__STATIC_FORCEINLINE void SCB_CleanInvalidateDCache (void)
 {
-  #if (__DCACHE_PRESENT == 1U)
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
     uint32_t ccsidr;
     uint32_t sets;
     uint32_t ways;
 
-    SCB->CSSELR = (0U << 1U) | 0U;          /* Level 1 data cache */
+    SCB->CSSELR = 0U;                       /* select Level 1 data cache */
     __DSB();
 
     ccsidr = SCB->CCSIDR;
@@ -2287,8 +2458,8 @@ __STATIC_INLINE void SCB_CleanInvalidateDCache (void)
         #if defined ( __CC_ARM )
           __schedule_barrier();
         #endif
-      } while (ways--);
-    } while(sets--);
+      } while (ways-- != 0U);
+    } while(sets-- != 0U);
 
     __DSB();
     __ISB();
@@ -2298,27 +2469,30 @@ __STATIC_INLINE void SCB_CleanInvalidateDCache (void)
 
 /**
   \brief   D-Cache Invalidate by address
-  \details Invalidates D-Cache for the given address
-  \param[in]   addr    address (aligned to 32-byte boundary)
+  \details Invalidates D-Cache for the given address.
+           D-Cache is invalidated starting from a 32 byte aligned address in 32 byte granularity.
+           D-Cache memory blocks which are part of given address + given size are invalidated.
+  \param[in]   addr    address
   \param[in]   dsize   size of memory block (in number of bytes)
 */
-__STATIC_INLINE void SCB_InvalidateDCache_by_Addr (uint32_t *addr, int32_t dsize)
+__STATIC_FORCEINLINE void SCB_InvalidateDCache_by_Addr (void *addr, int32_t dsize)
 {
-  #if (__DCACHE_PRESENT == 1U)
-     int32_t op_size = dsize;
-    uint32_t op_addr = (uint32_t)addr;
-     int32_t linesize = 32U;                /* in Cortex-M7 size of cache line is fixed to 8 words (32 bytes) */
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
+    if ( dsize > 0 ) { 
+       int32_t op_size = dsize + (((uint32_t)addr) & (__SCB_DCACHE_LINE_SIZE - 1U));
+      uint32_t op_addr = (uint32_t)addr /* & ~(__SCB_DCACHE_LINE_SIZE - 1U) */;
+    
+      __DSB();
 
-    __DSB();
+      do {
+        SCB->DCIMVAC = op_addr;             /* register accepts only 32byte aligned values, only bits 31..5 are valid */
+        op_addr += __SCB_DCACHE_LINE_SIZE;
+        op_size -= __SCB_DCACHE_LINE_SIZE;
+      } while ( op_size > 0 );
 
-    while (op_size > 0) {
-      SCB->DCIMVAC = op_addr;
-      op_addr += linesize;
-      op_size -= linesize;
+      __DSB();
+      __ISB();
     }
-
-    __DSB();
-    __ISB();
   #endif
 }
 
@@ -2326,26 +2500,29 @@ __STATIC_INLINE void SCB_InvalidateDCache_by_Addr (uint32_t *addr, int32_t dsize
 /**
   \brief   D-Cache Clean by address
   \details Cleans D-Cache for the given address
-  \param[in]   addr    address (aligned to 32-byte boundary)
+           D-Cache is cleaned starting from a 32 byte aligned address in 32 byte granularity.
+           D-Cache memory blocks which are part of given address + given size are cleaned.
+  \param[in]   addr    address
   \param[in]   dsize   size of memory block (in number of bytes)
 */
-__STATIC_INLINE void SCB_CleanDCache_by_Addr (uint32_t *addr, int32_t dsize)
+__STATIC_FORCEINLINE void SCB_CleanDCache_by_Addr (uint32_t *addr, int32_t dsize)
 {
-  #if (__DCACHE_PRESENT == 1)
-     int32_t op_size = dsize;
-    uint32_t op_addr = (uint32_t) addr;
-     int32_t linesize = 32U;                /* in Cortex-M7 size of cache line is fixed to 8 words (32 bytes) */
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
+    if ( dsize > 0 ) { 
+       int32_t op_size = dsize + (((uint32_t)addr) & (__SCB_DCACHE_LINE_SIZE - 1U));
+      uint32_t op_addr = (uint32_t)addr /* & ~(__SCB_DCACHE_LINE_SIZE - 1U) */;
+    
+      __DSB();
 
-    __DSB();
+      do {
+        SCB->DCCMVAC = op_addr;             /* register accepts only 32byte aligned values, only bits 31..5 are valid */
+        op_addr += __SCB_DCACHE_LINE_SIZE;
+        op_size -= __SCB_DCACHE_LINE_SIZE;
+      } while ( op_size > 0 );
 
-    while (op_size > 0) {
-      SCB->DCCMVAC = op_addr;
-      op_addr += linesize;
-      op_size -= linesize;
+      __DSB();
+      __ISB();
     }
-
-    __DSB();
-    __ISB();
   #endif
 }
 
@@ -2353,30 +2530,32 @@ __STATIC_INLINE void SCB_CleanDCache_by_Addr (uint32_t *addr, int32_t dsize)
 /**
   \brief   D-Cache Clean and Invalidate by address
   \details Cleans and invalidates D_Cache for the given address
+           D-Cache is cleaned and invalidated starting from a 32 byte aligned address in 32 byte granularity.
+           D-Cache memory blocks which are part of given address + given size are cleaned and invalidated.
   \param[in]   addr    address (aligned to 32-byte boundary)
   \param[in]   dsize   size of memory block (in number of bytes)
 */
-__STATIC_INLINE void SCB_CleanInvalidateDCache_by_Addr (uint32_t *addr, int32_t dsize)
+__STATIC_FORCEINLINE void SCB_CleanInvalidateDCache_by_Addr (uint32_t *addr, int32_t dsize)
 {
-  #if (__DCACHE_PRESENT == 1U)
-     int32_t op_size = dsize;
-    uint32_t op_addr = (uint32_t) addr;
-     int32_t linesize = 32U;                /* in Cortex-M7 size of cache line is fixed to 8 words (32 bytes) */
+  #if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
+    if ( dsize > 0 ) { 
+       int32_t op_size = dsize + (((uint32_t)addr) & (__SCB_DCACHE_LINE_SIZE - 1U));
+      uint32_t op_addr = (uint32_t)addr /* & ~(__SCB_DCACHE_LINE_SIZE - 1U) */;
+    
+      __DSB();
 
-    __DSB();
+      do {
+        SCB->DCCIMVAC = op_addr;            /* register accepts only 32byte aligned values, only bits 31..5 are valid */
+        op_addr +=          __SCB_DCACHE_LINE_SIZE;
+        op_size -=          __SCB_DCACHE_LINE_SIZE;
+      } while ( op_size > 0 );
 
-    while (op_size > 0) {
-      SCB->DCCIMVAC = op_addr;
-      op_addr += linesize;
-      op_size -= linesize;
+      __DSB();
+      __ISB();
     }
-
-    __DSB();
-    __ISB();
   #endif
 }
 
-
 /*@} end of CMSIS_Core_CacheFunctions */
 
 
@@ -2389,7 +2568,7 @@ __STATIC_INLINE void SCB_CleanInvalidateDCache_by_Addr (uint32_t *addr, int32_t
   @{
  */
 
-#if (__Vendor_SysTickConfig == 0U)
+#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
 
 /**
   \brief   System Tick Configuration
@@ -2432,8 +2611,8 @@ __STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
   @{
  */
 
-extern volatile int32_t ITM_RxBuffer;                    /*!< External variable to receive characters. */
-#define                 ITM_RXBUFFER_EMPTY   0x5AA55AA5U /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */
+extern volatile int32_t ITM_RxBuffer;                              /*!< External variable to receive characters. */
+#define                 ITM_RXBUFFER_EMPTY  ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */
 
 
 /**
diff --git a/lib/cmsis/inc/core_cmFunc.h b/lib/cmsis/inc/core_cmFunc.h
deleted file mode 100644
index 652a48af07a93..0000000000000
--- a/lib/cmsis/inc/core_cmFunc.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/**************************************************************************//**
- * @file     core_cmFunc.h
- * @brief    CMSIS Cortex-M Core Function Access Header File
- * @version  V4.30
- * @date     20. October 2015
- ******************************************************************************/
-/* Copyright (c) 2009 - 2015 ARM LIMITED
-
-   All rights reserved.
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-   - Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in the
-     documentation and/or other materials provided with the distribution.
-   - Neither the name of ARM nor the names of its contributors may be used
-     to endorse or promote products derived from this software without
-     specific prior written permission.
-   *
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
-   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-   POSSIBILITY OF SUCH DAMAGE.
-   ---------------------------------------------------------------------------*/
-
-
-#if   defined ( __ICCARM__ )
- #pragma system_include         /* treat file as system include file for MISRA check */
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #pragma clang system_header   /* treat file as system include file */
-#endif
-
-#ifndef __CORE_CMFUNC_H
-#define __CORE_CMFUNC_H
-
-
-/* ###########################  Core Function Access  ########################### */
-/** \ingroup  CMSIS_Core_FunctionInterface
-    \defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions
-  @{
-*/
-
-/*------------------ RealView Compiler -----------------*/
-#if   defined ( __CC_ARM )
-  #include "cmsis_armcc.h"
-
-/*------------------ ARM Compiler V6 -------------------*/
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #include "cmsis_armcc_V6.h"
-
-/*------------------ GNU Compiler ----------------------*/
-#elif defined ( __GNUC__ )
-  #include "cmsis_gcc.h"
-
-/*------------------ ICC Compiler ----------------------*/
-#elif defined ( __ICCARM__ )
-  #include <cmsis_iar.h>
-
-/*------------------ TI CCS Compiler -------------------*/
-#elif defined ( __TMS470__ )
-  #include <cmsis_ccs.h>
-
-/*------------------ TASKING Compiler ------------------*/
-#elif defined ( __TASKING__ )
-  /*
-   * The CMSIS functions have been implemented as intrinsics in the compiler.
-   * Please use "carm -?i" to get an up to date list of all intrinsics,
-   * Including the CMSIS ones.
-   */
-
-/*------------------ COSMIC Compiler -------------------*/
-#elif defined ( __CSMC__ )
-  #include <cmsis_csm.h>
-
-#endif
-
-/*@} end of CMSIS_Core_RegAccFunctions */
-
-#endif /* __CORE_CMFUNC_H */
diff --git a/lib/cmsis/inc/core_cmInstr.h b/lib/cmsis/inc/core_cmInstr.h
deleted file mode 100644
index f474b0e6f362c..0000000000000
--- a/lib/cmsis/inc/core_cmInstr.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/**************************************************************************//**
- * @file     core_cmInstr.h
- * @brief    CMSIS Cortex-M Core Instruction Access Header File
- * @version  V4.30
- * @date     20. October 2015
- ******************************************************************************/
-/* Copyright (c) 2009 - 2015 ARM LIMITED
-
-   All rights reserved.
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-   - Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in the
-     documentation and/or other materials provided with the distribution.
-   - Neither the name of ARM nor the names of its contributors may be used
-     to endorse or promote products derived from this software without
-     specific prior written permission.
-   *
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
-   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-   POSSIBILITY OF SUCH DAMAGE.
-   ---------------------------------------------------------------------------*/
-
-
-#if   defined ( __ICCARM__ )
- #pragma system_include         /* treat file as system include file for MISRA check */
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #pragma clang system_header   /* treat file as system include file */
-#endif
-
-#ifndef __CORE_CMINSTR_H
-#define __CORE_CMINSTR_H
-
-
-/* ##########################  Core Instruction Access  ######################### */
-/** \defgroup CMSIS_Core_InstructionInterface CMSIS Core Instruction Interface
-  Access to dedicated instructions
-  @{
-*/
-
-/*------------------ RealView Compiler -----------------*/
-#if   defined ( __CC_ARM )
-  #include "cmsis_armcc.h"
-
-/*------------------ ARM Compiler V6 -------------------*/
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #include "cmsis_armcc_V6.h"
-
-/*------------------ GNU Compiler ----------------------*/
-#elif defined ( __GNUC__ )
-  #include "cmsis_gcc.h"
-
-/*------------------ ICC Compiler ----------------------*/
-#elif defined ( __ICCARM__ )
-  #include <cmsis_iar.h>
-
-/*------------------ TI CCS Compiler -------------------*/
-#elif defined ( __TMS470__ )
-  #include <cmsis_ccs.h>
-
-/*------------------ TASKING Compiler ------------------*/
-#elif defined ( __TASKING__ )
-  /*
-   * The CMSIS functions have been implemented as intrinsics in the compiler.
-   * Please use "carm -?i" to get an up to date list of all intrinsics,
-   * Including the CMSIS ones.
-   */
-
-/*------------------ COSMIC Compiler -------------------*/
-#elif defined ( __CSMC__ )
-  #include <cmsis_csm.h>
-
-#endif
-
-/*@}*/ /* end of group CMSIS_Core_InstructionInterface */
-
-#endif /* __CORE_CMINSTR_H */
diff --git a/lib/cmsis/inc/core_cmSimd.h b/lib/cmsis/inc/core_cmSimd.h
deleted file mode 100644
index 66bf5c2a725b6..0000000000000
--- a/lib/cmsis/inc/core_cmSimd.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/**************************************************************************//**
- * @file     core_cmSimd.h
- * @brief    CMSIS Cortex-M SIMD Header File
- * @version  V4.30
- * @date     20. October 2015
- ******************************************************************************/
-/* Copyright (c) 2009 - 2015 ARM LIMITED
-
-   All rights reserved.
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-   - Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in the
-     documentation and/or other materials provided with the distribution.
-   - Neither the name of ARM nor the names of its contributors may be used
-     to endorse or promote products derived from this software without
-     specific prior written permission.
-   *
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
-   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-   POSSIBILITY OF SUCH DAMAGE.
-   ---------------------------------------------------------------------------*/
-
-
-#if   defined ( __ICCARM__ )
- #pragma system_include         /* treat file as system include file for MISRA check */
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #pragma clang system_header   /* treat file as system include file */
-#endif
-
-#ifndef __CORE_CMSIMD_H
-#define __CORE_CMSIMD_H
-
-#ifdef __cplusplus
- extern "C" {
-#endif
-
-
-/* ###################  Compiler specific Intrinsics  ########################### */
-/** \defgroup CMSIS_SIMD_intrinsics CMSIS SIMD Intrinsics
-  Access to dedicated SIMD instructions
-  @{
-*/
-
-/*------------------ RealView Compiler -----------------*/
-#if   defined ( __CC_ARM )
-  #include "cmsis_armcc.h"
-
-/*------------------ ARM Compiler V6 -------------------*/
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #include "cmsis_armcc_V6.h"
-
-/*------------------ GNU Compiler ----------------------*/
-#elif defined ( __GNUC__ )
-  #include "cmsis_gcc.h"
-
-/*------------------ ICC Compiler ----------------------*/
-#elif defined ( __ICCARM__ )
-  #include <cmsis_iar.h>
-
-/*------------------ TI CCS Compiler -------------------*/
-#elif defined ( __TMS470__ )
-  #include <cmsis_ccs.h>
-
-/*------------------ TASKING Compiler ------------------*/
-#elif defined ( __TASKING__ )
-  /*
-   * The CMSIS functions have been implemented as intrinsics in the compiler.
-   * Please use "carm -?i" to get an up to date list of all intrinsics,
-   * Including the CMSIS ones.
-   */
-
-/*------------------ COSMIC Compiler -------------------*/
-#elif defined ( __CSMC__ )
-  #include <cmsis_csm.h>
-
-#endif
-
-/*@} end of group CMSIS_SIMD_intrinsics */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __CORE_CMSIMD_H */
diff --git a/lib/cmsis/inc/core_sc000.h b/lib/cmsis/inc/core_sc000.h
index 514dbd81b9f77..389535a7cf2c1 100644
--- a/lib/cmsis/inc/core_sc000.h
+++ b/lib/cmsis/inc/core_sc000.h
@@ -1,40 +1,30 @@
 /**************************************************************************//**
  * @file     core_sc000.h
  * @brief    CMSIS SC000 Core Peripheral Access Layer Header File
- * @version  V4.30
- * @date     20. October 2015
+ * @version  V5.0.6
+ * @date     12. November 2018
  ******************************************************************************/
-/* Copyright (c) 2009 - 2015 ARM LIMITED
-
-   All rights reserved.
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-   - Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in the
-     documentation and/or other materials provided with the distribution.
-   - Neither the name of ARM nor the names of its contributors may be used
-     to endorse or promote products derived from this software without
-     specific prior written permission.
-   *
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
-   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-   POSSIBILITY OF SUCH DAMAGE.
-   ---------------------------------------------------------------------------*/
-
+/*
+ * Copyright (c) 2009-2018 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #if   defined ( __ICCARM__ )
- #pragma system_include         /* treat file as system include file for MISRA check */
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
   #pragma clang system_header   /* treat file as system include file */
 #endif
 
@@ -70,53 +60,15 @@
   @{
  */
 
+#include "cmsis_version.h"
+
 /*  CMSIS SC000 definitions */
-#define __SC000_CMSIS_VERSION_MAIN  (0x04U)                                    /*!< [31:16] CMSIS HAL main version */
-#define __SC000_CMSIS_VERSION_SUB   (0x1EU)                                    /*!< [15:0]  CMSIS HAL sub version */
+#define __SC000_CMSIS_VERSION_MAIN  (__CM_CMSIS_VERSION_MAIN)                /*!< \deprecated [31:16] CMSIS HAL main version */
+#define __SC000_CMSIS_VERSION_SUB   (__CM_CMSIS_VERSION_SUB)                 /*!< \deprecated [15:0]  CMSIS HAL sub version */
 #define __SC000_CMSIS_VERSION       ((__SC000_CMSIS_VERSION_MAIN << 16U) | \
-                                      __SC000_CMSIS_VERSION_SUB           )    /*!< CMSIS HAL version number */
-
-#define __CORTEX_SC                 (000U)                                     /*!< Cortex secure core */
-
-
-#if   defined ( __CC_ARM )
-  #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler */
-  #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler */
-  #define __STATIC_INLINE  static __inline
-
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler */
-  #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler */
-  #define __STATIC_INLINE  static __inline
-
-#elif defined ( __GNUC__ )
-  #define __ASM            __asm                                      /*!< asm keyword for GNU Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for GNU Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __ICCARM__ )
-  #define __ASM            __asm                                      /*!< asm keyword for IAR Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for IAR Compiler. Only available in High optimization mode! */
-  #define __STATIC_INLINE  static inline
+                                      __SC000_CMSIS_VERSION_SUB           )  /*!< \deprecated CMSIS HAL version number */
 
-#elif defined ( __TMS470__ )
-  #define __ASM            __asm                                      /*!< asm keyword for TI CCS Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __TASKING__ )
-  #define __ASM            __asm                                      /*!< asm keyword for TASKING Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for TASKING Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __CSMC__ )
-  #define __packed
-  #define __ASM            _asm                                      /*!< asm keyword for COSMIC Compiler */
-  #define __INLINE         inline                                    /*!< inline keyword for COSMIC Compiler. Use -pc99 on compile line */
-  #define __STATIC_INLINE  static inline
-
-#else
-  #error Unknown compiler
-#endif
+#define __CORTEX_SC                 (000U)                                   /*!< Cortex secure core */
 
 /** __FPU_USED indicates whether an FPU is used or not.
     This core does not support an FPU at all
@@ -128,8 +80,8 @@
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #if defined __ARM_PCS_VFP
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #if defined __ARM_FP
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
@@ -143,7 +95,7 @@
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
-#elif defined ( __TMS470__ )
+#elif defined ( __TI_ARM__ )
   #if defined __TI_VFP_SUPPORT__
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
@@ -160,8 +112,8 @@
 
 #endif
 
-#include "core_cmInstr.h"                /* Core Instruction Access */
-#include "core_cmFunc.h"                 /* Core Function Access */
+#include "cmsis_compiler.h"               /* CMSIS compiler specific defines */
+
 
 #ifdef __cplusplus
 }
@@ -569,7 +521,7 @@ typedef struct
 
 /*@} end of group CMSIS_SysTick */
 
-#if (__MPU_PRESENT == 1U)
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
 /**
   \ingroup  CMSIS_core_register
   \defgroup CMSIS_MPU     Memory Protection Unit (MPU)
@@ -678,18 +630,18 @@ typedef struct
 /**
   \brief   Mask and shift a bit field value for use in a register bit range.
   \param[in] field  Name of the register bit field.
-  \param[in] value  Value of the bit field.
+  \param[in] value  Value of the bit field. This parameter is interpreted as an uint32_t type.
   \return           Masked and shifted value.
 */
-#define _VAL2FLD(field, value)    ((value << field ## _Pos) & field ## _Msk)
+#define _VAL2FLD(field, value)    (((uint32_t)(value) << field ## _Pos) & field ## _Msk)
 
 /**
   \brief     Mask and shift a register value to extract a bit filed value.
   \param[in] field  Name of the register bit field.
-  \param[in] value  Value of register.
+  \param[in] value  Value of register. This parameter is interpreted as an uint32_t type.
   \return           Masked and shifted bit field value.
 */
-#define _FLD2VAL(field, value)    ((value & field ## _Msk) >> field ## _Pos)
+#define _FLD2VAL(field, value)    (((uint32_t)(value) & field ## _Msk) >> field ## _Pos)
 
 /*@} end of group CMSIS_core_bitfield */
 
@@ -701,7 +653,7 @@ typedef struct
   @{
  */
 
-/* Memory mapping of SC000 Hardware */
+/* Memory mapping of Core Hardware */
 #define SCS_BASE            (0xE000E000UL)                            /*!< System Control Space Base Address */
 #define SysTick_BASE        (SCS_BASE +  0x0010UL)                    /*!< SysTick Base Address */
 #define NVIC_BASE           (SCS_BASE +  0x0100UL)                    /*!< NVIC Base Address */
@@ -712,7 +664,7 @@ typedef struct
 #define SysTick             ((SysTick_Type   *)     SysTick_BASE  )   /*!< SysTick configuration struct */
 #define NVIC                ((NVIC_Type      *)     NVIC_BASE     )   /*!< NVIC configuration struct */
 
-#if (__MPU_PRESENT == 1U)
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
   #define MPU_BASE          (SCS_BASE +  0x0D90UL)                    /*!< Memory Protection Unit */
   #define MPU               ((MPU_Type       *)     MPU_BASE      )   /*!< Memory Protection Unit */
 #endif
@@ -742,7 +694,46 @@ typedef struct
   @{
  */
 
-/* Interrupt Priorities are WORD accessible only under ARMv6M                   */
+#ifdef CMSIS_NVIC_VIRTUAL
+  #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
+    #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
+  #endif
+  #include CMSIS_NVIC_VIRTUAL_HEADER_FILE
+#else
+/*#define NVIC_SetPriorityGrouping    __NVIC_SetPriorityGrouping   not available for SC000 */
+/*#define NVIC_GetPriorityGrouping    __NVIC_GetPriorityGrouping   not available for SC000 */
+  #define NVIC_EnableIRQ              __NVIC_EnableIRQ
+  #define NVIC_GetEnableIRQ           __NVIC_GetEnableIRQ
+  #define NVIC_DisableIRQ             __NVIC_DisableIRQ
+  #define NVIC_GetPendingIRQ          __NVIC_GetPendingIRQ
+  #define NVIC_SetPendingIRQ          __NVIC_SetPendingIRQ
+  #define NVIC_ClearPendingIRQ        __NVIC_ClearPendingIRQ
+/*#define NVIC_GetActive              __NVIC_GetActive             not available for SC000 */
+  #define NVIC_SetPriority            __NVIC_SetPriority
+  #define NVIC_GetPriority            __NVIC_GetPriority
+  #define NVIC_SystemReset            __NVIC_SystemReset
+#endif /* CMSIS_NVIC_VIRTUAL */
+
+#ifdef CMSIS_VECTAB_VIRTUAL
+  #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+    #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h"
+  #endif
+  #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetVector              __NVIC_SetVector
+  #define NVIC_GetVector              __NVIC_GetVector
+#endif  /* (CMSIS_VECTAB_VIRTUAL) */
+
+#define NVIC_USER_IRQ_OFFSET          16
+
+
+/* The following EXC_RETURN values are saved the LR on exception entry */
+#define EXC_RETURN_HANDLER         (0xFFFFFFF1UL)     /* return to Handler mode, uses MSP after return                               */
+#define EXC_RETURN_THREAD_MSP      (0xFFFFFFF9UL)     /* return to Thread mode, uses MSP after return                                */
+#define EXC_RETURN_THREAD_PSP      (0xFFFFFFFDUL)     /* return to Thread mode, uses PSP after return                                */
+
+
+/* Interrupt Priorities are WORD accessible only under Armv6-M                  */
 /* The following MACROS handle generation of the register offset and byte masks */
 #define _BIT_SHIFT(IRQn)         (  ((((uint32_t)(int32_t)(IRQn))         )      &  0x03UL) * 8UL)
 #define _SHP_IDX(IRQn)           ( (((((uint32_t)(int32_t)(IRQn)) & 0x0FUL)-8UL) >>    2UL)      )
@@ -750,79 +741,128 @@ typedef struct
 
 
 /**
-  \brief   Enable External Interrupt
-  \details Enables a device-specific interrupt in the NVIC interrupt controller.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \brief   Enable Interrupt
+  \details Enables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
 {
-  NVIC->ISER[0U] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
-  \brief   Disable External Interrupt
-  \details Disables a device-specific interrupt in the NVIC interrupt controller.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \brief   Get Interrupt Enable status
+  \details Returns a device specific interrupt enable status from the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn)
 {
-  NVIC->ICER[0U] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISER[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt
+  \details Disables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
+  }
 }
 
 
 /**
   \brief   Get Pending Interrupt
-  \details Reads the pending register in the NVIC and returns the pending bit for the specified interrupt.
-  \param [in]      IRQn  Interrupt number.
+  \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
   \return             0  Interrupt status is not pending.
   \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE uint32_t NVIC_GetPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn)
 {
-  return((uint32_t)(((NVIC->ISPR[0U] & (1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISPR[0U] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
 }
 
 
 /**
   \brief   Set Pending Interrupt
-  \details Sets the pending bit of an external interrupt.
-  \param [in]      IRQn  Interrupt number. Value cannot be negative.
+  \details Sets the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_SetPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn)
 {
-  NVIC->ISPR[0U] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
   \brief   Clear Pending Interrupt
-  \details Clears the pending bit of an external interrupt.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \details Clears the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_ClearPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn)
 {
-  NVIC->ICPR[0U] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICPR[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
   \brief   Set Interrupt Priority
-  \details Sets the priority of an interrupt.
-  \note    The priority cannot be set for every core interrupt.
+  \details Sets the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
   \param [in]      IRQn  Interrupt number.
   \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every processor exception.
  */
-__STATIC_INLINE void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
+__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
 {
-  if ((int32_t)(IRQn) < 0)
+  if ((int32_t)(IRQn) >= 0)
   {
-    SCB->SHP[_SHP_IDX(IRQn)] = ((uint32_t)(SCB->SHP[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+    NVIC->IP[_IP_IDX(IRQn)]  = ((uint32_t)(NVIC->IP[_IP_IDX(IRQn)]  & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
        (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
   }
   else
   {
-    NVIC->IP[_IP_IDX(IRQn)]  = ((uint32_t)(NVIC->IP[_IP_IDX(IRQn)]  & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
+    SCB->SHP[_SHP_IDX(IRQn)] = ((uint32_t)(SCB->SHP[_SHP_IDX(IRQn)] & ~(0xFFUL << _BIT_SHIFT(IRQn))) |
        (((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL) << _BIT_SHIFT(IRQn)));
   }
 }
@@ -830,32 +870,63 @@ __STATIC_INLINE void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
 
 /**
   \brief   Get Interrupt Priority
-  \details Reads the priority of an interrupt.
-           The interrupt number can be positive to specify an external (device specific) interrupt,
-           or negative to specify an internal (core) interrupt.
+  \details Reads the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
   \param [in]   IRQn  Interrupt number.
   \return             Interrupt Priority.
                       Value is aligned automatically to the implemented priority bits of the microcontroller.
  */
-__STATIC_INLINE uint32_t NVIC_GetPriority(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn)
 {
 
-  if ((int32_t)(IRQn) < 0)
+  if ((int32_t)(IRQn) >= 0)
   {
-    return((uint32_t)(((SCB->SHP[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+    return((uint32_t)(((NVIC->IP[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
   }
   else
   {
-    return((uint32_t)(((NVIC->IP[ _IP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
+    return((uint32_t)(((SCB->SHP[_SHP_IDX(IRQn)] >> _BIT_SHIFT(IRQn) ) & (uint32_t)0xFFUL) >> (8U - __NVIC_PRIO_BITS)));
   }
 }
 
 
+/**
+  \brief   Set Interrupt Vector
+  \details Sets an interrupt vector in SRAM based interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+           VTOR must been relocated to SRAM before.
+  \param [in]   IRQn      Interrupt number
+  \param [in]   vector    Address of interrupt handler function
+ */
+__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
+{
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+  vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector;
+}
+
+
+/**
+  \brief   Get Interrupt Vector
+  \details Reads an interrupt vector from interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn      Interrupt number.
+  \return                 Address of interrupt handler function
+ */
+__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn)
+{
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+  return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET];
+}
+
+
 /**
   \brief   System Reset
   \details Initiates a system reset request to reset the MCU.
  */
-__STATIC_INLINE void NVIC_SystemReset(void)
+__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void)
 {
   __DSB();                                                          /* Ensure all outstanding memory accesses included
                                                                        buffered write are completed before reset */
@@ -872,6 +943,31 @@ __STATIC_INLINE void NVIC_SystemReset(void)
 /*@} end of CMSIS_Core_NVICFunctions */
 
 
+/* ##########################  FPU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_FpuFunctions FPU Functions
+  \brief    Function that provides FPU type.
+  @{
+ */
+
+/**
+  \brief   get FPU type
+  \details returns the FPU type
+  \returns
+   - \b  0: No FPU
+   - \b  1: Single precision FPU
+   - \b  2: Double + Single precision FPU
+ */
+__STATIC_INLINE uint32_t SCB_GetFPUType(void)
+{
+    return 0U;           /* No FPU */
+}
+
+
+/*@} end of CMSIS_Core_FpuFunctions */
+
+
 
 /* ##################################    SysTick function  ############################################ */
 /**
@@ -881,7 +977,7 @@ __STATIC_INLINE void NVIC_SystemReset(void)
   @{
  */
 
-#if (__Vendor_SysTickConfig == 0U)
+#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
 
 /**
   \brief   System Tick Configuration
diff --git a/lib/cmsis/inc/core_sc300.h b/lib/cmsis/inc/core_sc300.h
index 8bd18aa318a98..5478ea74a5cfb 100644
--- a/lib/cmsis/inc/core_sc300.h
+++ b/lib/cmsis/inc/core_sc300.h
@@ -1,40 +1,30 @@
 /**************************************************************************//**
  * @file     core_sc300.h
  * @brief    CMSIS SC300 Core Peripheral Access Layer Header File
- * @version  V4.30
- * @date     20. October 2015
+ * @version  V5.0.7
+ * @date     12. November 2018
  ******************************************************************************/
-/* Copyright (c) 2009 - 2015 ARM LIMITED
-
-   All rights reserved.
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-   - Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in the
-     documentation and/or other materials provided with the distribution.
-   - Neither the name of ARM nor the names of its contributors may be used
-     to endorse or promote products derived from this software without
-     specific prior written permission.
-   *
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
-   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-   POSSIBILITY OF SUCH DAMAGE.
-   ---------------------------------------------------------------------------*/
-
+/*
+ * Copyright (c) 2009-2018 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #if   defined ( __ICCARM__ )
- #pragma system_include         /* treat file as system include file for MISRA check */
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
   #pragma clang system_header   /* treat file as system include file */
 #endif
 
@@ -70,53 +60,15 @@
   @{
  */
 
+#include "cmsis_version.h"
+
 /*  CMSIS SC300 definitions */
-#define __SC300_CMSIS_VERSION_MAIN  (0x04U)                                    /*!< [31:16] CMSIS HAL main version */
-#define __SC300_CMSIS_VERSION_SUB   (0x1EU)                                    /*!< [15:0]  CMSIS HAL sub version */
+#define __SC300_CMSIS_VERSION_MAIN  (__CM_CMSIS_VERSION_MAIN)                /*!< \deprecated [31:16] CMSIS HAL main version */
+#define __SC300_CMSIS_VERSION_SUB   (__CM_CMSIS_VERSION_SUB)                 /*!< \deprecated [15:0]  CMSIS HAL sub version */
 #define __SC300_CMSIS_VERSION       ((__SC300_CMSIS_VERSION_MAIN << 16U) | \
-                                      __SC300_CMSIS_VERSION_SUB           )    /*!< CMSIS HAL version number */
-
-#define __CORTEX_SC                 (300U)                                     /*!< Cortex secure core */
-
-
-#if   defined ( __CC_ARM )
-  #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler */
-  #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler */
-  #define __STATIC_INLINE  static __inline
-
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler */
-  #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler */
-  #define __STATIC_INLINE  static __inline
-
-#elif defined ( __GNUC__ )
-  #define __ASM            __asm                                      /*!< asm keyword for GNU Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for GNU Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __ICCARM__ )
-  #define __ASM            __asm                                      /*!< asm keyword for IAR Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for IAR Compiler. Only available in High optimization mode! */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __TMS470__ )
-  #define __ASM            __asm                                      /*!< asm keyword for TI CCS Compiler */
-  #define __STATIC_INLINE  static inline
-
-#elif defined ( __TASKING__ )
-  #define __ASM            __asm                                      /*!< asm keyword for TASKING Compiler */
-  #define __INLINE         inline                                     /*!< inline keyword for TASKING Compiler */
-  #define __STATIC_INLINE  static inline
+                                      __SC300_CMSIS_VERSION_SUB           )  /*!< \deprecated CMSIS HAL version number */
 
-#elif defined ( __CSMC__ )
-  #define __packed
-  #define __ASM            _asm                                      /*!< asm keyword for COSMIC Compiler */
-  #define __INLINE         inline                                    /*!< inline keyword for COSMIC Compiler. Use -pc99 on compile line */
-  #define __STATIC_INLINE  static inline
-
-#else
-  #error Unknown compiler
-#endif
+#define __CORTEX_SC                 (300U)                                   /*!< Cortex secure core */
 
 /** __FPU_USED indicates whether an FPU is used or not.
     This core does not support an FPU at all
@@ -128,8 +80,8 @@
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
-#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #if defined __ARM_PCS_VFP
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #if defined __ARM_FP
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
@@ -143,7 +95,7 @@
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
 
-#elif defined ( __TMS470__ )
+#elif defined ( __TI_ARM__ )
   #if defined __TI_VFP_SUPPORT__
     #error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
   #endif
@@ -160,8 +112,8 @@
 
 #endif
 
-#include "core_cmInstr.h"                /* Core Instruction Access */
-#include "core_cmFunc.h"                 /* Core Function Access */
+#include "cmsis_compiler.h"               /* CMSIS compiler specific defines */
+
 
 #ifdef __cplusplus
 }
@@ -191,7 +143,7 @@
   #endif
 
   #ifndef __NVIC_PRIO_BITS
-    #define __NVIC_PRIO_BITS          4U
+    #define __NVIC_PRIO_BITS          3U
     #warning "__NVIC_PRIO_BITS not defined in device header file; using default!"
   #endif
 
@@ -308,9 +260,11 @@ typedef union
   struct
   {
     uint32_t ISR:9;                      /*!< bit:  0.. 8  Exception number */
-    uint32_t _reserved0:15;              /*!< bit:  9..23  Reserved */
-    uint32_t T:1;                        /*!< bit:     24  Thumb bit        (read 0) */
-    uint32_t IT:2;                       /*!< bit: 25..26  saved IT state   (read 0) */
+    uint32_t _reserved0:1;               /*!< bit:      9  Reserved */
+    uint32_t ICI_IT_1:6;                 /*!< bit: 10..15  ICI/IT part 1 */
+    uint32_t _reserved1:8;               /*!< bit: 16..23  Reserved */
+    uint32_t T:1;                        /*!< bit:     24  Thumb bit */
+    uint32_t ICI_IT_2:2;                 /*!< bit: 25..26  ICI/IT part 2 */
     uint32_t Q:1;                        /*!< bit:     27  Saturation condition flag */
     uint32_t V:1;                        /*!< bit:     28  Overflow condition code flag */
     uint32_t C:1;                        /*!< bit:     29  Carry condition code flag */
@@ -336,12 +290,15 @@ typedef union
 #define xPSR_Q_Pos                         27U                                            /*!< xPSR: Q Position */
 #define xPSR_Q_Msk                         (1UL << xPSR_Q_Pos)                            /*!< xPSR: Q Mask */
 
-#define xPSR_IT_Pos                        25U                                            /*!< xPSR: IT Position */
-#define xPSR_IT_Msk                        (3UL << xPSR_IT_Pos)                           /*!< xPSR: IT Mask */
+#define xPSR_ICI_IT_2_Pos                  25U                                            /*!< xPSR: ICI/IT part 2 Position */
+#define xPSR_ICI_IT_2_Msk                  (3UL << xPSR_ICI_IT_2_Pos)                     /*!< xPSR: ICI/IT part 2 Mask */
 
 #define xPSR_T_Pos                         24U                                            /*!< xPSR: T Position */
 #define xPSR_T_Msk                         (1UL << xPSR_T_Pos)                            /*!< xPSR: T Mask */
 
+#define xPSR_ICI_IT_1_Pos                  10U                                            /*!< xPSR: ICI/IT part 1 Position */
+#define xPSR_ICI_IT_1_Msk                  (0x3FUL << xPSR_ICI_IT_1_Pos)                  /*!< xPSR: ICI/IT part 1 Mask */
+
 #define xPSR_ISR_Pos                        0U                                            /*!< xPSR: ISR Position */
 #define xPSR_ISR_Msk                       (0x1FFUL /*<< xPSR_ISR_Pos*/)                  /*!< xPSR: ISR Mask */
 
@@ -599,6 +556,60 @@ typedef struct
 #define SCB_CFSR_MEMFAULTSR_Pos             0U                                            /*!< SCB CFSR: Memory Manage Fault Status Register Position */
 #define SCB_CFSR_MEMFAULTSR_Msk            (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/)        /*!< SCB CFSR: Memory Manage Fault Status Register Mask */
 
+/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_MMARVALID_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 7U)               /*!< SCB CFSR (MMFSR): MMARVALID Position */
+#define SCB_CFSR_MMARVALID_Msk             (1UL << SCB_CFSR_MMARVALID_Pos)                /*!< SCB CFSR (MMFSR): MMARVALID Mask */
+
+#define SCB_CFSR_MSTKERR_Pos               (SCB_SHCSR_MEMFAULTACT_Pos + 4U)               /*!< SCB CFSR (MMFSR): MSTKERR Position */
+#define SCB_CFSR_MSTKERR_Msk               (1UL << SCB_CFSR_MSTKERR_Pos)                  /*!< SCB CFSR (MMFSR): MSTKERR Mask */
+
+#define SCB_CFSR_MUNSTKERR_Pos             (SCB_SHCSR_MEMFAULTACT_Pos + 3U)               /*!< SCB CFSR (MMFSR): MUNSTKERR Position */
+#define SCB_CFSR_MUNSTKERR_Msk             (1UL << SCB_CFSR_MUNSTKERR_Pos)                /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */
+
+#define SCB_CFSR_DACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 1U)               /*!< SCB CFSR (MMFSR): DACCVIOL Position */
+#define SCB_CFSR_DACCVIOL_Msk              (1UL << SCB_CFSR_DACCVIOL_Pos)                 /*!< SCB CFSR (MMFSR): DACCVIOL Mask */
+
+#define SCB_CFSR_IACCVIOL_Pos              (SCB_SHCSR_MEMFAULTACT_Pos + 0U)               /*!< SCB CFSR (MMFSR): IACCVIOL Position */
+#define SCB_CFSR_IACCVIOL_Msk              (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/)             /*!< SCB CFSR (MMFSR): IACCVIOL Mask */
+
+/* BusFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_BFARVALID_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 7U)                  /*!< SCB CFSR (BFSR): BFARVALID Position */
+#define SCB_CFSR_BFARVALID_Msk            (1UL << SCB_CFSR_BFARVALID_Pos)                 /*!< SCB CFSR (BFSR): BFARVALID Mask */
+
+#define SCB_CFSR_STKERR_Pos               (SCB_CFSR_BUSFAULTSR_Pos + 4U)                  /*!< SCB CFSR (BFSR): STKERR Position */
+#define SCB_CFSR_STKERR_Msk               (1UL << SCB_CFSR_STKERR_Pos)                    /*!< SCB CFSR (BFSR): STKERR Mask */
+
+#define SCB_CFSR_UNSTKERR_Pos             (SCB_CFSR_BUSFAULTSR_Pos + 3U)                  /*!< SCB CFSR (BFSR): UNSTKERR Position */
+#define SCB_CFSR_UNSTKERR_Msk             (1UL << SCB_CFSR_UNSTKERR_Pos)                  /*!< SCB CFSR (BFSR): UNSTKERR Mask */
+
+#define SCB_CFSR_IMPRECISERR_Pos          (SCB_CFSR_BUSFAULTSR_Pos + 2U)                  /*!< SCB CFSR (BFSR): IMPRECISERR Position */
+#define SCB_CFSR_IMPRECISERR_Msk          (1UL << SCB_CFSR_IMPRECISERR_Pos)               /*!< SCB CFSR (BFSR): IMPRECISERR Mask */
+
+#define SCB_CFSR_PRECISERR_Pos            (SCB_CFSR_BUSFAULTSR_Pos + 1U)                  /*!< SCB CFSR (BFSR): PRECISERR Position */
+#define SCB_CFSR_PRECISERR_Msk            (1UL << SCB_CFSR_PRECISERR_Pos)                 /*!< SCB CFSR (BFSR): PRECISERR Mask */
+
+#define SCB_CFSR_IBUSERR_Pos              (SCB_CFSR_BUSFAULTSR_Pos + 0U)                  /*!< SCB CFSR (BFSR): IBUSERR Position */
+#define SCB_CFSR_IBUSERR_Msk              (1UL << SCB_CFSR_IBUSERR_Pos)                   /*!< SCB CFSR (BFSR): IBUSERR Mask */
+
+/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */
+#define SCB_CFSR_DIVBYZERO_Pos            (SCB_CFSR_USGFAULTSR_Pos + 9U)                  /*!< SCB CFSR (UFSR): DIVBYZERO Position */
+#define SCB_CFSR_DIVBYZERO_Msk            (1UL << SCB_CFSR_DIVBYZERO_Pos)                 /*!< SCB CFSR (UFSR): DIVBYZERO Mask */
+
+#define SCB_CFSR_UNALIGNED_Pos            (SCB_CFSR_USGFAULTSR_Pos + 8U)                  /*!< SCB CFSR (UFSR): UNALIGNED Position */
+#define SCB_CFSR_UNALIGNED_Msk            (1UL << SCB_CFSR_UNALIGNED_Pos)                 /*!< SCB CFSR (UFSR): UNALIGNED Mask */
+
+#define SCB_CFSR_NOCP_Pos                 (SCB_CFSR_USGFAULTSR_Pos + 3U)                  /*!< SCB CFSR (UFSR): NOCP Position */
+#define SCB_CFSR_NOCP_Msk                 (1UL << SCB_CFSR_NOCP_Pos)                      /*!< SCB CFSR (UFSR): NOCP Mask */
+
+#define SCB_CFSR_INVPC_Pos                (SCB_CFSR_USGFAULTSR_Pos + 2U)                  /*!< SCB CFSR (UFSR): INVPC Position */
+#define SCB_CFSR_INVPC_Msk                (1UL << SCB_CFSR_INVPC_Pos)                     /*!< SCB CFSR (UFSR): INVPC Mask */
+
+#define SCB_CFSR_INVSTATE_Pos             (SCB_CFSR_USGFAULTSR_Pos + 1U)                  /*!< SCB CFSR (UFSR): INVSTATE Position */
+#define SCB_CFSR_INVSTATE_Msk             (1UL << SCB_CFSR_INVSTATE_Pos)                  /*!< SCB CFSR (UFSR): INVSTATE Mask */
+
+#define SCB_CFSR_UNDEFINSTR_Pos           (SCB_CFSR_USGFAULTSR_Pos + 0U)                  /*!< SCB CFSR (UFSR): UNDEFINSTR Position */
+#define SCB_CFSR_UNDEFINSTR_Msk           (1UL << SCB_CFSR_UNDEFINSTR_Pos)                /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */
+
 /* SCB Hard Fault Status Register Definitions */
 #define SCB_HFSR_DEBUGEVT_Pos              31U                                            /*!< SCB HFSR: DEBUGEVT Position */
 #define SCB_HFSR_DEBUGEVT_Msk              (1UL << SCB_HFSR_DEBUGEVT_Pos)                 /*!< SCB HFSR: DEBUGEVT Mask */
@@ -966,7 +977,7 @@ typedef struct
  */
 typedef struct
 {
-  __IOM uint32_t SSPSR;                  /*!< Offset: 0x000 (R/ )  Supported Parallel Port Size Register */
+  __IM  uint32_t SSPSR;                  /*!< Offset: 0x000 (R/ )  Supported Parallel Port Size Register */
   __IOM uint32_t CSPSR;                  /*!< Offset: 0x004 (R/W)  Current Parallel Port Size Register */
         uint32_t RESERVED0[2U];
   __IOM uint32_t ACPR;                   /*!< Offset: 0x010 (R/W)  Asynchronous Clock Prescaler Register */
@@ -977,7 +988,7 @@ typedef struct
   __IOM uint32_t FFCR;                   /*!< Offset: 0x304 (R/W)  Formatter and Flush Control Register */
   __IM  uint32_t FSCR;                   /*!< Offset: 0x308 (R/ )  Formatter Synchronization Counter Register */
         uint32_t RESERVED3[759U];
-  __IM  uint32_t TRIGGER;                /*!< Offset: 0xEE8 (R/ )  TRIGGER */
+  __IM  uint32_t TRIGGER;                /*!< Offset: 0xEE8 (R/ )  TRIGGER Register */
   __IM  uint32_t FIFO0;                  /*!< Offset: 0xEEC (R/ )  Integration ETM Data */
   __IM  uint32_t ITATBCTR2;              /*!< Offset: 0xEF0 (R/ )  ITATBCTR2 */
         uint32_t RESERVED4[1U];
@@ -1047,8 +1058,11 @@ typedef struct
 #define TPI_FIFO0_ETM0_Msk                 (0xFFUL /*<< TPI_FIFO0_ETM0_Pos*/)          /*!< TPI FIFO0: ETM0 Mask */
 
 /* TPI ITATBCTR2 Register Definitions */
-#define TPI_ITATBCTR2_ATREADY_Pos           0U                                         /*!< TPI ITATBCTR2: ATREADY Position */
-#define TPI_ITATBCTR2_ATREADY_Msk          (0x1UL /*<< TPI_ITATBCTR2_ATREADY_Pos*/)    /*!< TPI ITATBCTR2: ATREADY Mask */
+#define TPI_ITATBCTR2_ATREADY2_Pos          0U                                         /*!< TPI ITATBCTR2: ATREADY2 Position */
+#define TPI_ITATBCTR2_ATREADY2_Msk         (0x1UL /*<< TPI_ITATBCTR2_ATREADY2_Pos*/)   /*!< TPI ITATBCTR2: ATREADY2 Mask */
+
+#define TPI_ITATBCTR2_ATREADY1_Pos          0U                                         /*!< TPI ITATBCTR2: ATREADY1 Position */
+#define TPI_ITATBCTR2_ATREADY1_Msk         (0x1UL /*<< TPI_ITATBCTR2_ATREADY1_Pos*/)   /*!< TPI ITATBCTR2: ATREADY1 Mask */
 
 /* TPI Integration ITM Data Register Definitions (FIFO1) */
 #define TPI_FIFO1_ITM_ATVALID_Pos          29U                                         /*!< TPI FIFO1: ITM_ATVALID Position */
@@ -1073,12 +1087,15 @@ typedef struct
 #define TPI_FIFO1_ITM0_Msk                 (0xFFUL /*<< TPI_FIFO1_ITM0_Pos*/)          /*!< TPI FIFO1: ITM0 Mask */
 
 /* TPI ITATBCTR0 Register Definitions */
-#define TPI_ITATBCTR0_ATREADY_Pos           0U                                         /*!< TPI ITATBCTR0: ATREADY Position */
-#define TPI_ITATBCTR0_ATREADY_Msk          (0x1UL /*<< TPI_ITATBCTR0_ATREADY_Pos*/)    /*!< TPI ITATBCTR0: ATREADY Mask */
+#define TPI_ITATBCTR0_ATREADY2_Pos          0U                                         /*!< TPI ITATBCTR0: ATREADY2 Position */
+#define TPI_ITATBCTR0_ATREADY2_Msk         (0x1UL /*<< TPI_ITATBCTR0_ATREADY2_Pos*/)   /*!< TPI ITATBCTR0: ATREADY2 Mask */
+
+#define TPI_ITATBCTR0_ATREADY1_Pos          0U                                         /*!< TPI ITATBCTR0: ATREADY1 Position */
+#define TPI_ITATBCTR0_ATREADY1_Msk         (0x1UL /*<< TPI_ITATBCTR0_ATREADY1_Pos*/)   /*!< TPI ITATBCTR0: ATREADY1 Mask */
 
 /* TPI Integration Mode Control Register Definitions */
 #define TPI_ITCTRL_Mode_Pos                 0U                                         /*!< TPI ITCTRL: Mode Position */
-#define TPI_ITCTRL_Mode_Msk                (0x1UL /*<< TPI_ITCTRL_Mode_Pos*/)          /*!< TPI ITCTRL: Mode Mask */
+#define TPI_ITCTRL_Mode_Msk                (0x3UL /*<< TPI_ITCTRL_Mode_Pos*/)          /*!< TPI ITCTRL: Mode Mask */
 
 /* TPI DEVID Register Definitions */
 #define TPI_DEVID_NRZVALID_Pos             11U                                         /*!< TPI DEVID: NRZVALID Position */
@@ -1100,16 +1117,16 @@ typedef struct
 #define TPI_DEVID_NrTraceInput_Msk         (0x1FUL /*<< TPI_DEVID_NrTraceInput_Pos*/)  /*!< TPI DEVID: NrTraceInput Mask */
 
 /* TPI DEVTYPE Register Definitions */
-#define TPI_DEVTYPE_MajorType_Pos           4U                                         /*!< TPI DEVTYPE: MajorType Position */
-#define TPI_DEVTYPE_MajorType_Msk          (0xFUL << TPI_DEVTYPE_MajorType_Pos)        /*!< TPI DEVTYPE: MajorType Mask */
-
-#define TPI_DEVTYPE_SubType_Pos             0U                                         /*!< TPI DEVTYPE: SubType Position */
+#define TPI_DEVTYPE_SubType_Pos             4U                                         /*!< TPI DEVTYPE: SubType Position */
 #define TPI_DEVTYPE_SubType_Msk            (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/)      /*!< TPI DEVTYPE: SubType Mask */
 
+#define TPI_DEVTYPE_MajorType_Pos           0U                                         /*!< TPI DEVTYPE: MajorType Position */
+#define TPI_DEVTYPE_MajorType_Msk          (0xFUL << TPI_DEVTYPE_MajorType_Pos)        /*!< TPI DEVTYPE: MajorType Mask */
+
 /*@}*/ /* end of group CMSIS_TPI */
 
 
-#if (__MPU_PRESENT == 1U)
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
 /**
   \ingroup  CMSIS_core_register
   \defgroup CMSIS_MPU     Memory Protection Unit (MPU)
@@ -1319,18 +1336,18 @@ typedef struct
 /**
   \brief   Mask and shift a bit field value for use in a register bit range.
   \param[in] field  Name of the register bit field.
-  \param[in] value  Value of the bit field.
+  \param[in] value  Value of the bit field. This parameter is interpreted as an uint32_t type.
   \return           Masked and shifted value.
 */
-#define _VAL2FLD(field, value)    ((value << field ## _Pos) & field ## _Msk)
+#define _VAL2FLD(field, value)    (((uint32_t)(value) << field ## _Pos) & field ## _Msk)
 
 /**
   \brief     Mask and shift a register value to extract a bit filed value.
   \param[in] field  Name of the register bit field.
-  \param[in] value  Value of register.
+  \param[in] value  Value of register. This parameter is interpreted as an uint32_t type.
   \return           Masked and shifted bit field value.
 */
-#define _FLD2VAL(field, value)    ((value & field ## _Msk) >> field ## _Pos)
+#define _FLD2VAL(field, value)    (((uint32_t)(value) & field ## _Msk) >> field ## _Pos)
 
 /*@} end of group CMSIS_core_bitfield */
 
@@ -1342,7 +1359,7 @@ typedef struct
   @{
  */
 
-/* Memory mapping of Cortex-M3 Hardware */
+/* Memory mapping of Core Hardware */
 #define SCS_BASE            (0xE000E000UL)                            /*!< System Control Space Base Address */
 #define ITM_BASE            (0xE0000000UL)                            /*!< ITM Base Address */
 #define DWT_BASE            (0xE0001000UL)                            /*!< DWT Base Address */
@@ -1361,7 +1378,7 @@ typedef struct
 #define TPI                 ((TPI_Type       *)     TPI_BASE      )   /*!< TPI configuration struct */
 #define CoreDebug           ((CoreDebug_Type *)     CoreDebug_BASE)   /*!< Core Debug configuration struct */
 
-#if (__MPU_PRESENT == 1U)
+#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
   #define MPU_BASE          (SCS_BASE +  0x0D90UL)                    /*!< Memory Protection Unit */
   #define MPU               ((MPU_Type       *)     MPU_BASE      )   /*!< Memory Protection Unit */
 #endif
@@ -1392,6 +1409,46 @@ typedef struct
   @{
  */
 
+#ifdef CMSIS_NVIC_VIRTUAL
+  #ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
+    #define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
+  #endif
+  #include CMSIS_NVIC_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetPriorityGrouping    __NVIC_SetPriorityGrouping
+  #define NVIC_GetPriorityGrouping    __NVIC_GetPriorityGrouping
+  #define NVIC_EnableIRQ              __NVIC_EnableIRQ
+  #define NVIC_GetEnableIRQ           __NVIC_GetEnableIRQ
+  #define NVIC_DisableIRQ             __NVIC_DisableIRQ
+  #define NVIC_GetPendingIRQ          __NVIC_GetPendingIRQ
+  #define NVIC_SetPendingIRQ          __NVIC_SetPendingIRQ
+  #define NVIC_ClearPendingIRQ        __NVIC_ClearPendingIRQ
+  #define NVIC_GetActive              __NVIC_GetActive
+  #define NVIC_SetPriority            __NVIC_SetPriority
+  #define NVIC_GetPriority            __NVIC_GetPriority
+  #define NVIC_SystemReset            __NVIC_SystemReset
+#endif /* CMSIS_NVIC_VIRTUAL */
+
+#ifdef CMSIS_VECTAB_VIRTUAL
+  #ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+    #define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h"
+  #endif
+  #include CMSIS_VECTAB_VIRTUAL_HEADER_FILE
+#else
+  #define NVIC_SetVector              __NVIC_SetVector
+  #define NVIC_GetVector              __NVIC_GetVector
+#endif  /* (CMSIS_VECTAB_VIRTUAL) */
+
+#define NVIC_USER_IRQ_OFFSET          16
+
+
+/* The following EXC_RETURN values are saved the LR on exception entry */
+#define EXC_RETURN_HANDLER         (0xFFFFFFF1UL)     /* return to Handler mode, uses MSP after return                               */
+#define EXC_RETURN_THREAD_MSP      (0xFFFFFFF9UL)     /* return to Thread mode, uses MSP after return                                */
+#define EXC_RETURN_THREAD_PSP      (0xFFFFFFFDUL)     /* return to Thread mode, uses PSP after return                                */
+
+
+
 /**
   \brief   Set Priority Grouping
   \details Sets the priority grouping field using the required unlock sequence.
@@ -1401,7 +1458,7 @@ typedef struct
            priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
   \param [in]      PriorityGroup  Priority grouping field.
  */
-__STATIC_INLINE void NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
+__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
 {
   uint32_t reg_value;
   uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL);             /* only values 0..7 are used          */
@@ -1420,121 +1477,178 @@ __STATIC_INLINE void NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
   \details Reads the priority grouping field from the NVIC Interrupt Controller.
   \return                Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field).
  */
-__STATIC_INLINE uint32_t NVIC_GetPriorityGrouping(void)
+__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void)
 {
   return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos));
 }
 
 
 /**
-  \brief   Enable External Interrupt
-  \details Enables a device-specific interrupt in the NVIC interrupt controller.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \brief   Enable Interrupt
+  \details Enables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
 {
-  NVIC->ISER[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
-  \brief   Disable External Interrupt
-  \details Disables a device-specific interrupt in the NVIC interrupt controller.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \brief   Get Interrupt Enable status
+  \details Returns a device specific interrupt enable status from the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \return             0  Interrupt is not enabled.
+  \return             1  Interrupt is enabled.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn)
 {
-  NVIC->ICER[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISER[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
+}
+
+
+/**
+  \brief   Disable Interrupt
+  \details Disables a device specific interrupt in the NVIC interrupt controller.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
+ */
+__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn)
+{
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICER[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+    __DSB();
+    __ISB();
+  }
 }
 
 
 /**
   \brief   Get Pending Interrupt
-  \details Reads the pending register in the NVIC and returns the pending bit for the specified interrupt.
-  \param [in]      IRQn  Interrupt number.
+  \details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
   \return             0  Interrupt status is not pending.
   \return             1  Interrupt status is pending.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE uint32_t NVIC_GetPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn)
 {
-  return((uint32_t)(((NVIC->ISPR[(((uint32_t)(int32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
 }
 
 
 /**
   \brief   Set Pending Interrupt
-  \details Sets the pending bit of an external interrupt.
-  \param [in]      IRQn  Interrupt number. Value cannot be negative.
+  \details Sets the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_SetPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn)
 {
-  NVIC->ISPR[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ISPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
   \brief   Clear Pending Interrupt
-  \details Clears the pending bit of an external interrupt.
-  \param [in]      IRQn  External interrupt number. Value cannot be negative.
+  \details Clears the pending bit of a device specific interrupt in the NVIC pending register.
+  \param [in]      IRQn  Device specific interrupt number.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE void NVIC_ClearPendingIRQ(IRQn_Type IRQn)
+__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn)
 {
-  NVIC->ICPR[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    NVIC->ICPR[(((uint32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
+  }
 }
 
 
 /**
   \brief   Get Active Interrupt
-  \details Reads the active register in NVIC and returns the active bit.
-  \param [in]      IRQn  Interrupt number.
+  \details Reads the active register in the NVIC and returns the active bit for the device specific interrupt.
+  \param [in]      IRQn  Device specific interrupt number.
   \return             0  Interrupt status is not active.
   \return             1  Interrupt status is active.
+  \note    IRQn must not be negative.
  */
-__STATIC_INLINE uint32_t NVIC_GetActive(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn)
 {
-  return((uint32_t)(((NVIC->IABR[(((uint32_t)(int32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  if ((int32_t)(IRQn) >= 0)
+  {
+    return((uint32_t)(((NVIC->IABR[(((uint32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
+  }
+  else
+  {
+    return(0U);
+  }
 }
 
 
 /**
   \brief   Set Interrupt Priority
-  \details Sets the priority of an interrupt.
-  \note    The priority cannot be set for every core interrupt.
+  \details Sets the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
   \param [in]      IRQn  Interrupt number.
   \param [in]  priority  Priority to set.
+  \note    The priority cannot be set for every processor exception.
  */
-__STATIC_INLINE void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
+__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
 {
-  if ((int32_t)(IRQn) < 0)
+  if ((int32_t)(IRQn) >= 0)
   {
-    SCB->SHP[(((uint32_t)(int32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+    NVIC->IP[((uint32_t)IRQn)]               = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
   }
   else
   {
-    NVIC->IP[((uint32_t)(int32_t)IRQn)]               = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
+    SCB->SHP[(((uint32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
   }
 }
 
 
 /**
   \brief   Get Interrupt Priority
-  \details Reads the priority of an interrupt.
-           The interrupt number can be positive to specify an external (device specific) interrupt,
-           or negative to specify an internal (core) interrupt.
+  \details Reads the priority of a device specific interrupt or a processor exception.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
   \param [in]   IRQn  Interrupt number.
   \return             Interrupt Priority.
                       Value is aligned automatically to the implemented priority bits of the microcontroller.
  */
-__STATIC_INLINE uint32_t NVIC_GetPriority(IRQn_Type IRQn)
+__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn)
 {
 
-  if ((int32_t)(IRQn) < 0)
+  if ((int32_t)(IRQn) >= 0)
   {
-    return(((uint32_t)SCB->SHP[(((uint32_t)(int32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
+    return(((uint32_t)NVIC->IP[((uint32_t)IRQn)]               >> (8U - __NVIC_PRIO_BITS)));
   }
   else
   {
-    return(((uint32_t)NVIC->IP[((uint32_t)(int32_t)IRQn)]               >> (8U - __NVIC_PRIO_BITS)));
+    return(((uint32_t)SCB->SHP[(((uint32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
   }
 }
 
@@ -1591,11 +1705,42 @@ __STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGr
 }
 
 
+/**
+  \brief   Set Interrupt Vector
+  \details Sets an interrupt vector in SRAM based interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+           VTOR must been relocated to SRAM before.
+  \param [in]   IRQn      Interrupt number
+  \param [in]   vector    Address of interrupt handler function
+ */
+__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
+{
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+  vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector;
+}
+
+
+/**
+  \brief   Get Interrupt Vector
+  \details Reads an interrupt vector from interrupt vector table.
+           The interrupt number can be positive to specify a device specific interrupt,
+           or negative to specify a processor exception.
+  \param [in]   IRQn      Interrupt number.
+  \return                 Address of interrupt handler function
+ */
+__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn)
+{
+  uint32_t *vectors = (uint32_t *)SCB->VTOR;
+  return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET];
+}
+
+
 /**
   \brief   System Reset
   \details Initiates a system reset request to reset the MCU.
  */
-__STATIC_INLINE void NVIC_SystemReset(void)
+__NO_RETURN __STATIC_INLINE void __NVIC_SystemReset(void)
 {
   __DSB();                                                          /* Ensure all outstanding memory accesses included
                                                                        buffered write are completed before reset */
@@ -1613,6 +1758,31 @@ __STATIC_INLINE void NVIC_SystemReset(void)
 /*@} end of CMSIS_Core_NVICFunctions */
 
 
+/* ##########################  FPU functions  #################################### */
+/**
+  \ingroup  CMSIS_Core_FunctionInterface
+  \defgroup CMSIS_Core_FpuFunctions FPU Functions
+  \brief    Function that provides FPU type.
+  @{
+ */
+
+/**
+  \brief   get FPU type
+  \details returns the FPU type
+  \returns
+   - \b  0: No FPU
+   - \b  1: Single precision FPU
+   - \b  2: Double + Single precision FPU
+ */
+__STATIC_INLINE uint32_t SCB_GetFPUType(void)
+{
+    return 0U;           /* No FPU */
+}
+
+
+/*@} end of CMSIS_Core_FpuFunctions */
+
+
 
 /* ##################################    SysTick function  ############################################ */
 /**
@@ -1622,7 +1792,7 @@ __STATIC_INLINE void NVIC_SystemReset(void)
   @{
  */
 
-#if (__Vendor_SysTickConfig == 0U)
+#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
 
 /**
   \brief   System Tick Configuration
@@ -1665,8 +1835,8 @@ __STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
   @{
  */
 
-extern volatile int32_t ITM_RxBuffer;                    /*!< External variable to receive characters. */
-#define                 ITM_RXBUFFER_EMPTY   0x5AA55AA5U /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */
+extern volatile int32_t ITM_RxBuffer;                              /*!< External variable to receive characters. */
+#define                 ITM_RXBUFFER_EMPTY  ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */
 
 
 /**
diff --git a/lib/cmsis/inc/mpu_armv7.h b/lib/cmsis/inc/mpu_armv7.h
new file mode 100644
index 0000000000000..66ef59b4a0bff
--- /dev/null
+++ b/lib/cmsis/inc/mpu_armv7.h
@@ -0,0 +1,272 @@
+/******************************************************************************
+ * @file     mpu_armv7.h
+ * @brief    CMSIS MPU API for Armv7-M MPU
+ * @version  V5.1.0
+ * @date     08. March 2019
+ ******************************************************************************/
+/*
+ * Copyright (c) 2017-2019 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+#if   defined ( __ICCARM__ )
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
+  #pragma clang system_header    /* treat file as system include file */
+#endif
+ 
+#ifndef ARM_MPU_ARMV7_H
+#define ARM_MPU_ARMV7_H
+
+#define ARM_MPU_REGION_SIZE_32B      ((uint8_t)0x04U) ///!< MPU Region Size 32 Bytes
+#define ARM_MPU_REGION_SIZE_64B      ((uint8_t)0x05U) ///!< MPU Region Size 64 Bytes
+#define ARM_MPU_REGION_SIZE_128B     ((uint8_t)0x06U) ///!< MPU Region Size 128 Bytes
+#define ARM_MPU_REGION_SIZE_256B     ((uint8_t)0x07U) ///!< MPU Region Size 256 Bytes
+#define ARM_MPU_REGION_SIZE_512B     ((uint8_t)0x08U) ///!< MPU Region Size 512 Bytes
+#define ARM_MPU_REGION_SIZE_1KB      ((uint8_t)0x09U) ///!< MPU Region Size 1 KByte
+#define ARM_MPU_REGION_SIZE_2KB      ((uint8_t)0x0AU) ///!< MPU Region Size 2 KBytes
+#define ARM_MPU_REGION_SIZE_4KB      ((uint8_t)0x0BU) ///!< MPU Region Size 4 KBytes
+#define ARM_MPU_REGION_SIZE_8KB      ((uint8_t)0x0CU) ///!< MPU Region Size 8 KBytes
+#define ARM_MPU_REGION_SIZE_16KB     ((uint8_t)0x0DU) ///!< MPU Region Size 16 KBytes
+#define ARM_MPU_REGION_SIZE_32KB     ((uint8_t)0x0EU) ///!< MPU Region Size 32 KBytes
+#define ARM_MPU_REGION_SIZE_64KB     ((uint8_t)0x0FU) ///!< MPU Region Size 64 KBytes
+#define ARM_MPU_REGION_SIZE_128KB    ((uint8_t)0x10U) ///!< MPU Region Size 128 KBytes
+#define ARM_MPU_REGION_SIZE_256KB    ((uint8_t)0x11U) ///!< MPU Region Size 256 KBytes
+#define ARM_MPU_REGION_SIZE_512KB    ((uint8_t)0x12U) ///!< MPU Region Size 512 KBytes
+#define ARM_MPU_REGION_SIZE_1MB      ((uint8_t)0x13U) ///!< MPU Region Size 1 MByte
+#define ARM_MPU_REGION_SIZE_2MB      ((uint8_t)0x14U) ///!< MPU Region Size 2 MBytes
+#define ARM_MPU_REGION_SIZE_4MB      ((uint8_t)0x15U) ///!< MPU Region Size 4 MBytes
+#define ARM_MPU_REGION_SIZE_8MB      ((uint8_t)0x16U) ///!< MPU Region Size 8 MBytes
+#define ARM_MPU_REGION_SIZE_16MB     ((uint8_t)0x17U) ///!< MPU Region Size 16 MBytes
+#define ARM_MPU_REGION_SIZE_32MB     ((uint8_t)0x18U) ///!< MPU Region Size 32 MBytes
+#define ARM_MPU_REGION_SIZE_64MB     ((uint8_t)0x19U) ///!< MPU Region Size 64 MBytes
+#define ARM_MPU_REGION_SIZE_128MB    ((uint8_t)0x1AU) ///!< MPU Region Size 128 MBytes
+#define ARM_MPU_REGION_SIZE_256MB    ((uint8_t)0x1BU) ///!< MPU Region Size 256 MBytes
+#define ARM_MPU_REGION_SIZE_512MB    ((uint8_t)0x1CU) ///!< MPU Region Size 512 MBytes
+#define ARM_MPU_REGION_SIZE_1GB      ((uint8_t)0x1DU) ///!< MPU Region Size 1 GByte
+#define ARM_MPU_REGION_SIZE_2GB      ((uint8_t)0x1EU) ///!< MPU Region Size 2 GBytes
+#define ARM_MPU_REGION_SIZE_4GB      ((uint8_t)0x1FU) ///!< MPU Region Size 4 GBytes
+
+#define ARM_MPU_AP_NONE 0U ///!< MPU Access Permission no access
+#define ARM_MPU_AP_PRIV 1U ///!< MPU Access Permission privileged access only
+#define ARM_MPU_AP_URO  2U ///!< MPU Access Permission unprivileged access read-only
+#define ARM_MPU_AP_FULL 3U ///!< MPU Access Permission full access
+#define ARM_MPU_AP_PRO  5U ///!< MPU Access Permission privileged access read-only
+#define ARM_MPU_AP_RO   6U ///!< MPU Access Permission read-only access
+
+/** MPU Region Base Address Register Value
+*
+* \param Region The region to be configured, number 0 to 15.
+* \param BaseAddress The base address for the region.
+*/
+#define ARM_MPU_RBAR(Region, BaseAddress) \
+  (((BaseAddress) & MPU_RBAR_ADDR_Msk) |  \
+   ((Region) & MPU_RBAR_REGION_Msk)    |  \
+   (MPU_RBAR_VALID_Msk))
+
+/**
+* MPU Memory Access Attributes
+* 
+* \param TypeExtField      Type extension field, allows you to configure memory access type, for example strongly ordered, peripheral.
+* \param IsShareable       Region is shareable between multiple bus masters.
+* \param IsCacheable       Region is cacheable, i.e. its value may be kept in cache.
+* \param IsBufferable      Region is bufferable, i.e. using write-back caching. Cacheable but non-bufferable regions use write-through policy.
+*/  
+#define ARM_MPU_ACCESS_(TypeExtField, IsShareable, IsCacheable, IsBufferable)   \
+  ((((TypeExtField) << MPU_RASR_TEX_Pos) & MPU_RASR_TEX_Msk)                  | \
+   (((IsShareable)  << MPU_RASR_S_Pos)   & MPU_RASR_S_Msk)                    | \
+   (((IsCacheable)  << MPU_RASR_C_Pos)   & MPU_RASR_C_Msk)                    | \
+   (((IsBufferable) << MPU_RASR_B_Pos)   & MPU_RASR_B_Msk))
+
+/**
+* MPU Region Attribute and Size Register Value
+* 
+* \param DisableExec       Instruction access disable bit, 1= disable instruction fetches.
+* \param AccessPermission  Data access permissions, allows you to configure read/write access for User and Privileged mode.
+* \param AccessAttributes  Memory access attribution, see \ref ARM_MPU_ACCESS_.
+* \param SubRegionDisable  Sub-region disable field.
+* \param Size              Region size of the region to be configured, for example 4K, 8K.
+*/
+#define ARM_MPU_RASR_EX(DisableExec, AccessPermission, AccessAttributes, SubRegionDisable, Size)    \
+  ((((DisableExec)      << MPU_RASR_XN_Pos)   & MPU_RASR_XN_Msk)                                  | \
+   (((AccessPermission) << MPU_RASR_AP_Pos)   & MPU_RASR_AP_Msk)                                  | \
+   (((AccessAttributes) & (MPU_RASR_TEX_Msk | MPU_RASR_S_Msk | MPU_RASR_C_Msk | MPU_RASR_B_Msk))) | \
+   (((SubRegionDisable) << MPU_RASR_SRD_Pos)  & MPU_RASR_SRD_Msk)                                 | \
+   (((Size)             << MPU_RASR_SIZE_Pos) & MPU_RASR_SIZE_Msk)                                | \
+   (((MPU_RASR_ENABLE_Msk))))
+
+/**
+* MPU Region Attribute and Size Register Value
+* 
+* \param DisableExec       Instruction access disable bit, 1= disable instruction fetches.
+* \param AccessPermission  Data access permissions, allows you to configure read/write access for User and Privileged mode.
+* \param TypeExtField      Type extension field, allows you to configure memory access type, for example strongly ordered, peripheral.
+* \param IsShareable       Region is shareable between multiple bus masters.
+* \param IsCacheable       Region is cacheable, i.e. its value may be kept in cache.
+* \param IsBufferable      Region is bufferable, i.e. using write-back caching. Cacheable but non-bufferable regions use write-through policy.
+* \param SubRegionDisable  Sub-region disable field.
+* \param Size              Region size of the region to be configured, for example 4K, 8K.
+*/                         
+#define ARM_MPU_RASR(DisableExec, AccessPermission, TypeExtField, IsShareable, IsCacheable, IsBufferable, SubRegionDisable, Size) \
+  ARM_MPU_RASR_EX(DisableExec, AccessPermission, ARM_MPU_ACCESS_(TypeExtField, IsShareable, IsCacheable, IsBufferable), SubRegionDisable, Size)
+
+/**
+* MPU Memory Access Attribute for strongly ordered memory.
+*  - TEX: 000b
+*  - Shareable
+*  - Non-cacheable
+*  - Non-bufferable
+*/ 
+#define ARM_MPU_ACCESS_ORDERED ARM_MPU_ACCESS_(0U, 1U, 0U, 0U)
+
+/**
+* MPU Memory Access Attribute for device memory.
+*  - TEX: 000b (if shareable) or 010b (if non-shareable)
+*  - Shareable or non-shareable
+*  - Non-cacheable
+*  - Bufferable (if shareable) or non-bufferable (if non-shareable)
+*
+* \param IsShareable Configures the device memory as shareable or non-shareable.
+*/ 
+#define ARM_MPU_ACCESS_DEVICE(IsShareable) ((IsShareable) ? ARM_MPU_ACCESS_(0U, 1U, 0U, 1U) : ARM_MPU_ACCESS_(2U, 0U, 0U, 0U))
+
+/**
+* MPU Memory Access Attribute for normal memory.
+*  - TEX: 1BBb (reflecting outer cacheability rules)
+*  - Shareable or non-shareable
+*  - Cacheable or non-cacheable (reflecting inner cacheability rules)
+*  - Bufferable or non-bufferable (reflecting inner cacheability rules)
+*
+* \param OuterCp Configures the outer cache policy.
+* \param InnerCp Configures the inner cache policy.
+* \param IsShareable Configures the memory as shareable or non-shareable.
+*/ 
+#define ARM_MPU_ACCESS_NORMAL(OuterCp, InnerCp, IsShareable) ARM_MPU_ACCESS_((4U | (OuterCp)), IsShareable, ((InnerCp) & 2U), ((InnerCp) & 1U))
+
+/**
+* MPU Memory Access Attribute non-cacheable policy.
+*/
+#define ARM_MPU_CACHEP_NOCACHE 0U
+
+/**
+* MPU Memory Access Attribute write-back, write and read allocate policy.
+*/
+#define ARM_MPU_CACHEP_WB_WRA 1U
+
+/**
+* MPU Memory Access Attribute write-through, no write allocate policy.
+*/
+#define ARM_MPU_CACHEP_WT_NWA 2U
+
+/**
+* MPU Memory Access Attribute write-back, no write allocate policy.
+*/
+#define ARM_MPU_CACHEP_WB_NWA 3U
+
+
+/**
+* Struct for a single MPU Region
+*/
+typedef struct {
+  uint32_t RBAR; //!< The region base address register value (RBAR)
+  uint32_t RASR; //!< The region attribute and size register value (RASR) \ref MPU_RASR
+} ARM_MPU_Region_t;
+    
+/** Enable the MPU.
+* \param MPU_Control Default access permissions for unconfigured regions.
+*/
+__STATIC_INLINE void ARM_MPU_Enable(uint32_t MPU_Control)
+{
+  MPU->CTRL = MPU_Control | MPU_CTRL_ENABLE_Msk;
+#ifdef SCB_SHCSR_MEMFAULTENA_Msk
+  SCB->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk;
+#endif
+  __DSB();
+  __ISB();
+}
+
+/** Disable the MPU.
+*/
+__STATIC_INLINE void ARM_MPU_Disable(void)
+{
+  __DMB();
+#ifdef SCB_SHCSR_MEMFAULTENA_Msk
+  SCB->SHCSR &= ~SCB_SHCSR_MEMFAULTENA_Msk;
+#endif
+  MPU->CTRL  &= ~MPU_CTRL_ENABLE_Msk;
+}
+
+/** Clear and disable the given MPU region.
+* \param rnr Region number to be cleared.
+*/
+__STATIC_INLINE void ARM_MPU_ClrRegion(uint32_t rnr)
+{
+  MPU->RNR = rnr;
+  MPU->RASR = 0U;
+}
+
+/** Configure an MPU region.
+* \param rbar Value for RBAR register.
+* \param rsar Value for RSAR register.
+*/   
+__STATIC_INLINE void ARM_MPU_SetRegion(uint32_t rbar, uint32_t rasr)
+{
+  MPU->RBAR = rbar;
+  MPU->RASR = rasr;
+}
+
+/** Configure the given MPU region.
+* \param rnr Region number to be configured.
+* \param rbar Value for RBAR register.
+* \param rsar Value for RSAR register.
+*/   
+__STATIC_INLINE void ARM_MPU_SetRegionEx(uint32_t rnr, uint32_t rbar, uint32_t rasr)
+{
+  MPU->RNR = rnr;
+  MPU->RBAR = rbar;
+  MPU->RASR = rasr;
+}
+
+/** Memcopy with strictly ordered memory access, e.g. for register targets.
+* \param dst Destination data is copied to.
+* \param src Source data is copied from.
+* \param len Amount of data words to be copied.
+*/
+__STATIC_INLINE void ARM_MPU_OrderedMemcpy(volatile uint32_t* dst, const uint32_t* __RESTRICT src, uint32_t len)
+{
+  uint32_t i;
+  for (i = 0U; i < len; ++i) 
+  {
+    dst[i] = src[i];
+  }
+}
+
+/** Load the given number of MPU regions from a table.
+* \param table Pointer to the MPU configuration table.
+* \param cnt Amount of regions to be configured.
+*/
+__STATIC_INLINE void ARM_MPU_Load(ARM_MPU_Region_t const* table, uint32_t cnt) 
+{
+  const uint32_t rowWordSize = sizeof(ARM_MPU_Region_t)/4U;
+  while (cnt > MPU_TYPE_RALIASES) {
+    ARM_MPU_OrderedMemcpy(&(MPU->RBAR), &(table->RBAR), MPU_TYPE_RALIASES*rowWordSize);
+    table += MPU_TYPE_RALIASES;
+    cnt -= MPU_TYPE_RALIASES;
+  }
+  ARM_MPU_OrderedMemcpy(&(MPU->RBAR), &(table->RBAR), cnt*rowWordSize);
+}
+
+#endif
diff --git a/lib/cmsis/inc/mpu_armv8.h b/lib/cmsis/inc/mpu_armv8.h
new file mode 100644
index 0000000000000..0041d4dc6ff53
--- /dev/null
+++ b/lib/cmsis/inc/mpu_armv8.h
@@ -0,0 +1,346 @@
+/******************************************************************************
+ * @file     mpu_armv8.h
+ * @brief    CMSIS MPU API for Armv8-M and Armv8.1-M MPU
+ * @version  V5.1.0
+ * @date     08. March 2019
+ ******************************************************************************/
+/*
+ * Copyright (c) 2017-2019 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if   defined ( __ICCARM__ )
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
+  #pragma clang system_header    /* treat file as system include file */
+#endif
+
+#ifndef ARM_MPU_ARMV8_H
+#define ARM_MPU_ARMV8_H
+
+/** \brief Attribute for device memory (outer only) */
+#define ARM_MPU_ATTR_DEVICE                           ( 0U )
+
+/** \brief Attribute for non-cacheable, normal memory */
+#define ARM_MPU_ATTR_NON_CACHEABLE                    ( 4U )
+
+/** \brief Attribute for normal memory (outer and inner)
+* \param NT Non-Transient: Set to 1 for non-transient data.
+* \param WB Write-Back: Set to 1 to use write-back update policy.
+* \param RA Read Allocation: Set to 1 to use cache allocation on read miss.
+* \param WA Write Allocation: Set to 1 to use cache allocation on write miss.
+*/
+#define ARM_MPU_ATTR_MEMORY_(NT, WB, RA, WA) \
+  (((NT & 1U) << 3U) | ((WB & 1U) << 2U) | ((RA & 1U) << 1U) | (WA & 1U))
+
+/** \brief Device memory type non Gathering, non Re-ordering, non Early Write Acknowledgement */
+#define ARM_MPU_ATTR_DEVICE_nGnRnE (0U)
+
+/** \brief Device memory type non Gathering, non Re-ordering, Early Write Acknowledgement */
+#define ARM_MPU_ATTR_DEVICE_nGnRE  (1U)
+
+/** \brief Device memory type non Gathering, Re-ordering, Early Write Acknowledgement */
+#define ARM_MPU_ATTR_DEVICE_nGRE   (2U)
+
+/** \brief Device memory type Gathering, Re-ordering, Early Write Acknowledgement */
+#define ARM_MPU_ATTR_DEVICE_GRE    (3U)
+
+/** \brief Memory Attribute
+* \param O Outer memory attributes
+* \param I O == ARM_MPU_ATTR_DEVICE: Device memory attributes, else: Inner memory attributes
+*/
+#define ARM_MPU_ATTR(O, I) (((O & 0xFU) << 4U) | (((O & 0xFU) != 0U) ? (I & 0xFU) : ((I & 0x3U) << 2U)))
+
+/** \brief Normal memory non-shareable  */
+#define ARM_MPU_SH_NON   (0U)
+
+/** \brief Normal memory outer shareable  */
+#define ARM_MPU_SH_OUTER (2U)
+
+/** \brief Normal memory inner shareable  */
+#define ARM_MPU_SH_INNER (3U)
+
+/** \brief Memory access permissions
+* \param RO Read-Only: Set to 1 for read-only memory.
+* \param NP Non-Privileged: Set to 1 for non-privileged memory.
+*/
+#define ARM_MPU_AP_(RO, NP) (((RO & 1U) << 1U) | (NP & 1U))
+
+/** \brief Region Base Address Register value
+* \param BASE The base address bits [31:5] of a memory region. The value is zero extended. Effective address gets 32 byte aligned.
+* \param SH Defines the Shareability domain for this memory region.
+* \param RO Read-Only: Set to 1 for a read-only memory region.
+* \param NP Non-Privileged: Set to 1 for a non-privileged memory region.
+* \oaram XN eXecute Never: Set to 1 for a non-executable memory region.
+*/
+#define ARM_MPU_RBAR(BASE, SH, RO, NP, XN) \
+  ((BASE & MPU_RBAR_BASE_Msk) | \
+  ((SH << MPU_RBAR_SH_Pos) & MPU_RBAR_SH_Msk) | \
+  ((ARM_MPU_AP_(RO, NP) << MPU_RBAR_AP_Pos) & MPU_RBAR_AP_Msk) | \
+  ((XN << MPU_RBAR_XN_Pos) & MPU_RBAR_XN_Msk))
+
+/** \brief Region Limit Address Register value
+* \param LIMIT The limit address bits [31:5] for this memory region. The value is one extended.
+* \param IDX The attribute index to be associated with this memory region.
+*/
+#define ARM_MPU_RLAR(LIMIT, IDX) \
+  ((LIMIT & MPU_RLAR_LIMIT_Msk) | \
+  ((IDX << MPU_RLAR_AttrIndx_Pos) & MPU_RLAR_AttrIndx_Msk) | \
+  (MPU_RLAR_EN_Msk))
+
+#if defined(MPU_RLAR_PXN_Pos)
+  
+/** \brief Region Limit Address Register with PXN value
+* \param LIMIT The limit address bits [31:5] for this memory region. The value is one extended.
+* \param PXN Privileged execute never. Defines whether code can be executed from this privileged region.
+* \param IDX The attribute index to be associated with this memory region.
+*/
+#define ARM_MPU_RLAR_PXN(LIMIT, PXN, IDX) \
+  ((LIMIT & MPU_RLAR_LIMIT_Msk) | \
+  ((PXN << MPU_RLAR_PXN_Pos) & MPU_RLAR_PXN_Msk) | \
+  ((IDX << MPU_RLAR_AttrIndx_Pos) & MPU_RLAR_AttrIndx_Msk) | \
+  (MPU_RLAR_EN_Msk))
+  
+#endif
+
+/**
+* Struct for a single MPU Region
+*/
+typedef struct {
+  uint32_t RBAR;                   /*!< Region Base Address Register value */
+  uint32_t RLAR;                   /*!< Region Limit Address Register value */
+} ARM_MPU_Region_t;
+    
+/** Enable the MPU.
+* \param MPU_Control Default access permissions for unconfigured regions.
+*/
+__STATIC_INLINE void ARM_MPU_Enable(uint32_t MPU_Control)
+{
+  MPU->CTRL = MPU_Control | MPU_CTRL_ENABLE_Msk;
+#ifdef SCB_SHCSR_MEMFAULTENA_Msk
+  SCB->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk;
+#endif
+  __DSB();
+  __ISB();
+}
+
+/** Disable the MPU.
+*/
+__STATIC_INLINE void ARM_MPU_Disable(void)
+{
+  __DMB();
+#ifdef SCB_SHCSR_MEMFAULTENA_Msk
+  SCB->SHCSR &= ~SCB_SHCSR_MEMFAULTENA_Msk;
+#endif
+  MPU->CTRL  &= ~MPU_CTRL_ENABLE_Msk;
+}
+
+#ifdef MPU_NS
+/** Enable the Non-secure MPU.
+* \param MPU_Control Default access permissions for unconfigured regions.
+*/
+__STATIC_INLINE void ARM_MPU_Enable_NS(uint32_t MPU_Control)
+{
+  MPU_NS->CTRL = MPU_Control | MPU_CTRL_ENABLE_Msk;
+#ifdef SCB_SHCSR_MEMFAULTENA_Msk
+  SCB_NS->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk;
+#endif
+  __DSB();
+  __ISB();
+}
+
+/** Disable the Non-secure MPU.
+*/
+__STATIC_INLINE void ARM_MPU_Disable_NS(void)
+{
+  __DMB();
+#ifdef SCB_SHCSR_MEMFAULTENA_Msk
+  SCB_NS->SHCSR &= ~SCB_SHCSR_MEMFAULTENA_Msk;
+#endif
+  MPU_NS->CTRL  &= ~MPU_CTRL_ENABLE_Msk;
+}
+#endif
+
+/** Set the memory attribute encoding to the given MPU.
+* \param mpu Pointer to the MPU to be configured.
+* \param idx The attribute index to be set [0-7]
+* \param attr The attribute value to be set.
+*/
+__STATIC_INLINE void ARM_MPU_SetMemAttrEx(MPU_Type* mpu, uint8_t idx, uint8_t attr)
+{
+  const uint8_t reg = idx / 4U;
+  const uint32_t pos = ((idx % 4U) * 8U);
+  const uint32_t mask = 0xFFU << pos;
+  
+  if (reg >= (sizeof(mpu->MAIR) / sizeof(mpu->MAIR[0]))) {
+    return; // invalid index
+  }
+  
+  mpu->MAIR[reg] = ((mpu->MAIR[reg] & ~mask) | ((attr << pos) & mask));
+}
+
+/** Set the memory attribute encoding.
+* \param idx The attribute index to be set [0-7]
+* \param attr The attribute value to be set.
+*/
+__STATIC_INLINE void ARM_MPU_SetMemAttr(uint8_t idx, uint8_t attr)
+{
+  ARM_MPU_SetMemAttrEx(MPU, idx, attr);
+}
+
+#ifdef MPU_NS
+/** Set the memory attribute encoding to the Non-secure MPU.
+* \param idx The attribute index to be set [0-7]
+* \param attr The attribute value to be set.
+*/
+__STATIC_INLINE void ARM_MPU_SetMemAttr_NS(uint8_t idx, uint8_t attr)
+{
+  ARM_MPU_SetMemAttrEx(MPU_NS, idx, attr);
+}
+#endif
+
+/** Clear and disable the given MPU region of the given MPU.
+* \param mpu Pointer to MPU to be used.
+* \param rnr Region number to be cleared.
+*/
+__STATIC_INLINE void ARM_MPU_ClrRegionEx(MPU_Type* mpu, uint32_t rnr)
+{
+  mpu->RNR = rnr;
+  mpu->RLAR = 0U;
+}
+
+/** Clear and disable the given MPU region.
+* \param rnr Region number to be cleared.
+*/
+__STATIC_INLINE void ARM_MPU_ClrRegion(uint32_t rnr)
+{
+  ARM_MPU_ClrRegionEx(MPU, rnr);
+}
+
+#ifdef MPU_NS
+/** Clear and disable the given Non-secure MPU region.
+* \param rnr Region number to be cleared.
+*/
+__STATIC_INLINE void ARM_MPU_ClrRegion_NS(uint32_t rnr)
+{  
+  ARM_MPU_ClrRegionEx(MPU_NS, rnr);
+}
+#endif
+
+/** Configure the given MPU region of the given MPU.
+* \param mpu Pointer to MPU to be used.
+* \param rnr Region number to be configured.
+* \param rbar Value for RBAR register.
+* \param rlar Value for RLAR register.
+*/   
+__STATIC_INLINE void ARM_MPU_SetRegionEx(MPU_Type* mpu, uint32_t rnr, uint32_t rbar, uint32_t rlar)
+{
+  mpu->RNR = rnr;
+  mpu->RBAR = rbar;
+  mpu->RLAR = rlar;
+}
+
+/** Configure the given MPU region.
+* \param rnr Region number to be configured.
+* \param rbar Value for RBAR register.
+* \param rlar Value for RLAR register.
+*/   
+__STATIC_INLINE void ARM_MPU_SetRegion(uint32_t rnr, uint32_t rbar, uint32_t rlar)
+{
+  ARM_MPU_SetRegionEx(MPU, rnr, rbar, rlar);
+}
+
+#ifdef MPU_NS
+/** Configure the given Non-secure MPU region.
+* \param rnr Region number to be configured.
+* \param rbar Value for RBAR register.
+* \param rlar Value for RLAR register.
+*/   
+__STATIC_INLINE void ARM_MPU_SetRegion_NS(uint32_t rnr, uint32_t rbar, uint32_t rlar)
+{
+  ARM_MPU_SetRegionEx(MPU_NS, rnr, rbar, rlar);  
+}
+#endif
+
+/** Memcopy with strictly ordered memory access, e.g. for register targets.
+* \param dst Destination data is copied to.
+* \param src Source data is copied from.
+* \param len Amount of data words to be copied.
+*/
+__STATIC_INLINE void ARM_MPU_OrderedMemcpy(volatile uint32_t* dst, const uint32_t* __RESTRICT src, uint32_t len)
+{
+  uint32_t i;
+  for (i = 0U; i < len; ++i) 
+  {
+    dst[i] = src[i];
+  }
+}
+
+/** Load the given number of MPU regions from a table to the given MPU.
+* \param mpu Pointer to the MPU registers to be used.
+* \param rnr First region number to be configured.
+* \param table Pointer to the MPU configuration table.
+* \param cnt Amount of regions to be configured.
+*/
+__STATIC_INLINE void ARM_MPU_LoadEx(MPU_Type* mpu, uint32_t rnr, ARM_MPU_Region_t const* table, uint32_t cnt) 
+{
+  const uint32_t rowWordSize = sizeof(ARM_MPU_Region_t)/4U;
+  if (cnt == 1U) {
+    mpu->RNR = rnr;
+    ARM_MPU_OrderedMemcpy(&(mpu->RBAR), &(table->RBAR), rowWordSize);
+  } else {
+    uint32_t rnrBase   = rnr & ~(MPU_TYPE_RALIASES-1U);
+    uint32_t rnrOffset = rnr % MPU_TYPE_RALIASES;
+    
+    mpu->RNR = rnrBase;
+    while ((rnrOffset + cnt) > MPU_TYPE_RALIASES) {
+      uint32_t c = MPU_TYPE_RALIASES - rnrOffset;
+      ARM_MPU_OrderedMemcpy(&(mpu->RBAR)+(rnrOffset*2U), &(table->RBAR), c*rowWordSize);
+      table += c;
+      cnt -= c;
+      rnrOffset = 0U;
+      rnrBase += MPU_TYPE_RALIASES;
+      mpu->RNR = rnrBase;
+    }
+    
+    ARM_MPU_OrderedMemcpy(&(mpu->RBAR)+(rnrOffset*2U), &(table->RBAR), cnt*rowWordSize);
+  }
+}
+
+/** Load the given number of MPU regions from a table.
+* \param rnr First region number to be configured.
+* \param table Pointer to the MPU configuration table.
+* \param cnt Amount of regions to be configured.
+*/
+__STATIC_INLINE void ARM_MPU_Load(uint32_t rnr, ARM_MPU_Region_t const* table, uint32_t cnt) 
+{
+  ARM_MPU_LoadEx(MPU, rnr, table, cnt);
+}
+
+#ifdef MPU_NS
+/** Load the given number of MPU regions from a table to the Non-secure MPU.
+* \param rnr First region number to be configured.
+* \param table Pointer to the MPU configuration table.
+* \param cnt Amount of regions to be configured.
+*/
+__STATIC_INLINE void ARM_MPU_Load_NS(uint32_t rnr, ARM_MPU_Region_t const* table, uint32_t cnt) 
+{
+  ARM_MPU_LoadEx(MPU_NS, rnr, table, cnt);
+}
+#endif
+
+#endif
+
diff --git a/lib/cmsis/inc/tz_context.h b/lib/cmsis/inc/tz_context.h
new file mode 100644
index 0000000000000..0d09749f3a506
--- /dev/null
+++ b/lib/cmsis/inc/tz_context.h
@@ -0,0 +1,70 @@
+/******************************************************************************
+ * @file     tz_context.h
+ * @brief    Context Management for Armv8-M TrustZone
+ * @version  V1.0.1
+ * @date     10. January 2018
+ ******************************************************************************/
+/*
+ * Copyright (c) 2017-2018 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if   defined ( __ICCARM__ )
+  #pragma system_include         /* treat file as system include file for MISRA check */
+#elif defined (__clang__)
+  #pragma clang system_header   /* treat file as system include file */
+#endif
+
+#ifndef TZ_CONTEXT_H
+#define TZ_CONTEXT_H
+ 
+#include <stdint.h>
+ 
+#ifndef TZ_MODULEID_T
+#define TZ_MODULEID_T
+/// \details Data type that identifies secure software modules called by a process.
+typedef uint32_t TZ_ModuleId_t;
+#endif
+ 
+/// \details TZ Memory ID identifies an allocated memory slot.
+typedef uint32_t TZ_MemoryId_t;
+  
+/// Initialize secure context memory system
+/// \return execution status (1: success, 0: error)
+uint32_t TZ_InitContextSystem_S (void);
+ 
+/// Allocate context memory for calling secure software modules in TrustZone
+/// \param[in]  module   identifies software modules called from non-secure mode
+/// \return value != 0 id TrustZone memory slot identifier
+/// \return value 0    no memory available or internal error
+TZ_MemoryId_t TZ_AllocModuleContext_S (TZ_ModuleId_t module);
+ 
+/// Free context memory that was previously allocated with \ref TZ_AllocModuleContext_S
+/// \param[in]  id  TrustZone memory slot identifier
+/// \return execution status (1: success, 0: error)
+uint32_t TZ_FreeModuleContext_S (TZ_MemoryId_t id);
+ 
+/// Load secure context (called on RTOS thread context switch)
+/// \param[in]  id  TrustZone memory slot identifier
+/// \return execution status (1: success, 0: error)
+uint32_t TZ_LoadContext_S (TZ_MemoryId_t id);
+ 
+/// Store secure context (called on RTOS thread context switch)
+/// \param[in]  id  TrustZone memory slot identifier
+/// \return execution status (1: success, 0: error)
+uint32_t TZ_StoreContext_S (TZ_MemoryId_t id);
+ 
+#endif  // TZ_CONTEXT_H
diff --git a/lib/embed/__errno.c b/lib/embed/__errno.c
new file mode 100644
index 0000000000000..86417a02dd045
--- /dev/null
+++ b/lib/embed/__errno.c
@@ -0,0 +1,13 @@
+// This file provides a version of __errno() for embedded systems that do not have one.
+// This function is needed for expressions of the form: &errno
+
+static int embed_errno;
+
+#if defined(__linux__)
+int *__errno_location(void)
+#else
+int *__errno(void)
+#endif
+{
+    return &embed_errno;
+}
diff --git a/lib/embed/abort_.c b/lib/embed/abort_.c
index 2fba0de4eafb8..3051eae81e0ce 100644
--- a/lib/embed/abort_.c
+++ b/lib/embed/abort_.c
@@ -3,5 +3,5 @@
 NORETURN void abort_(void);
 
 NORETURN void abort_(void) {
-    mp_raise_msg(&mp_type_RuntimeError, "abort() called");
+    mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("abort() called"));
 }
diff --git a/lib/libc/string0.c b/lib/libc/string0.c
index c2f2abd0f95cc..8c86bf65f7b40 100644
--- a/lib/libc/string0.c
+++ b/lib/libc/string0.c
@@ -217,3 +217,19 @@ char *strstr(const char *haystack, const char *needle)
             return (char *) haystack;
     return 0;
 }
+
+size_t strspn(const char *s, const char *accept) {
+    const char *ss = s;
+    while (*s && strchr(accept, *s) != NULL) {
+        ++s;
+    }
+    return s - ss;
+}
+
+size_t strcspn(const char *s, const char *reject) {
+    const char *ss = s;
+    while (*s && strchr(reject, *s) == NULL) {
+        ++s;
+    }
+    return s - ss;
+}
diff --git a/lib/libm/asinfacosf.c b/lib/libm/asinfacosf.c
index 07ecad3f3fdcc..22dbb3d22871a 100644
--- a/lib/libm/asinfacosf.c
+++ b/lib/libm/asinfacosf.c
@@ -23,15 +23,15 @@
 
 // dpgeorge: pio2 was double in original implementation of asinf
 static const float
-pio2_hi = 1.5707962513e+00, /* 0x3fc90fda */
-pio2_lo = 7.5497894159e-08; /* 0x33a22168 */
+pio2_hi = 1.5707962513e+00f, /* 0x3fc90fda */
+pio2_lo = 7.5497894159e-08f; /* 0x33a22168 */
 
 static const float
 /* coefficients for R(x^2) */
-pS0 =  1.6666586697e-01,
-pS1 = -4.2743422091e-02,
-pS2 = -8.6563630030e-03,
-qS1 = -7.0662963390e-01;
+pS0 =  1.6666586697e-01f,
+pS1 = -4.2743422091e-02f,
+pS2 = -8.6563630030e-03f,
+qS1 = -7.0662963390e-01f;
 
 static float R(float z)
 {
diff --git a/lib/libm/atan2f.c b/lib/libm/atan2f.c
index 03d000c9e18a7..dcbaf821b5a5a 100644
--- a/lib/libm/atan2f.c
+++ b/lib/libm/atan2f.c
@@ -22,8 +22,8 @@
 #include "libm.h"
 
 static const float
-pi     = 3.1415927410e+00, /* 0x40490fdb */
-pi_lo  = -8.7422776573e-08; /* 0xb3bbbd2e */
+pi     = 3.1415927410e+00f, /* 0x40490fdb */
+pi_lo  = -8.7422776573e-08f; /* 0xb3bbbd2e */
 
 float atan2f(float y, float x)
 {
diff --git a/lib/libm/atanf.c b/lib/libm/atanf.c
index 053fc1b6d60f0..40bc363c2924b 100644
--- a/lib/libm/atanf.c
+++ b/lib/libm/atanf.c
@@ -23,25 +23,25 @@
 #include "libm.h"
 
 static const float atanhi[] = {
-  4.6364760399e-01, /* atan(0.5)hi 0x3eed6338 */
-  7.8539812565e-01, /* atan(1.0)hi 0x3f490fda */
-  9.8279368877e-01, /* atan(1.5)hi 0x3f7b985e */
-  1.5707962513e+00, /* atan(inf)hi 0x3fc90fda */
+  4.6364760399e-01f, /* atan(0.5)hi 0x3eed6338 */
+  7.8539812565e-01f, /* atan(1.0)hi 0x3f490fda */
+  9.8279368877e-01f, /* atan(1.5)hi 0x3f7b985e */
+  1.5707962513e+00f, /* atan(inf)hi 0x3fc90fda */
 };
 
 static const float atanlo[] = {
-  5.0121582440e-09, /* atan(0.5)lo 0x31ac3769 */
-  3.7748947079e-08, /* atan(1.0)lo 0x33222168 */
-  3.4473217170e-08, /* atan(1.5)lo 0x33140fb4 */
-  7.5497894159e-08, /* atan(inf)lo 0x33a22168 */
+  5.0121582440e-09f, /* atan(0.5)lo 0x31ac3769 */
+  3.7748947079e-08f, /* atan(1.0)lo 0x33222168 */
+  3.4473217170e-08f, /* atan(1.5)lo 0x33140fb4 */
+  7.5497894159e-08f, /* atan(inf)lo 0x33a22168 */
 };
 
 static const float aT[] = {
-  3.3333328366e-01,
- -1.9999158382e-01,
-  1.4253635705e-01,
- -1.0648017377e-01,
-  6.1687607318e-02,
+  3.3333328366e-01f,
+ -1.9999158382e-01f,
+  1.4253635705e-01f,
+ -1.0648017377e-01f,
+  6.1687607318e-02f,
 };
 
 float atanf(float x)
diff --git a/lib/libm/ef_rem_pio2.c b/lib/libm/ef_rem_pio2.c
index ca55243fb4fdb..8111ca197f0e4 100644
--- a/lib/libm/ef_rem_pio2.c
+++ b/lib/libm/ef_rem_pio2.c
@@ -93,16 +93,16 @@ static const float
 #else
 static float 
 #endif
-zero =  0.0000000000e+00, /* 0x00000000 */
-half =  5.0000000000e-01, /* 0x3f000000 */
-two8 =  2.5600000000e+02, /* 0x43800000 */
-invpio2 =  6.3661980629e-01, /* 0x3f22f984 */
-pio2_1  =  1.5707855225e+00, /* 0x3fc90f80 */
-pio2_1t =  1.0804334124e-05, /* 0x37354443 */
-pio2_2  =  1.0804273188e-05, /* 0x37354400 */
-pio2_2t =  6.0770999344e-11, /* 0x2e85a308 */
-pio2_3  =  6.0770943833e-11, /* 0x2e85a300 */
-pio2_3t =  6.1232342629e-17; /* 0x248d3132 */
+zero =  0.0000000000e+00f, /* 0x00000000 */
+half =  5.0000000000e-01f, /* 0x3f000000 */
+two8 =  2.5600000000e+02f, /* 0x43800000 */
+invpio2 =  6.3661980629e-01f, /* 0x3f22f984 */
+pio2_1  =  1.5707855225e+00f, /* 0x3fc90f80 */
+pio2_1t =  1.0804334124e-05f, /* 0x37354443 */
+pio2_2  =  1.0804273188e-05f, /* 0x37354400 */
+pio2_2t =  6.0770999344e-11f, /* 0x2e85a308 */
+pio2_3  =  6.0770943833e-11f, /* 0x2e85a300 */
+pio2_3t =  6.1232342629e-17f; /* 0x248d3132 */
 
 #ifdef __STDC__
 	__int32_t __ieee754_rem_pio2f(float x, float *y)
diff --git a/lib/libm/ef_sqrt.c b/lib/libm/ef_sqrt.c
index 87484d0bf08ab..7f46ef6387d4f 100644
--- a/lib/libm/ef_sqrt.c
+++ b/lib/libm/ef_sqrt.c
@@ -25,9 +25,9 @@
 #include "fdlibm.h"
 
 #ifdef __STDC__
-static	const float	one	= 1.0, tiny=1.0e-30;
+static	const float	one	= 1.0f, tiny=1.0e-30f;
 #else
-static	float	one	= 1.0, tiny=1.0e-30;
+static	float	one	= 1.0f, tiny=1.0e-30f;
 #endif
 
 // sqrtf is exactly __ieee754_sqrtf when _IEEE_LIBM defined
diff --git a/lib/libm/erf_lgamma.c b/lib/libm/erf_lgamma.c
index 877816a0c213d..1a33f470356fa 100644
--- a/lib/libm/erf_lgamma.c
+++ b/lib/libm/erf_lgamma.c
@@ -32,77 +32,77 @@ static const float
 #else
 static float 
 #endif
-two23=  8.3886080000e+06, /* 0x4b000000 */
-half=  5.0000000000e-01, /* 0x3f000000 */
-one =  1.0000000000e+00, /* 0x3f800000 */
-pi  =  3.1415927410e+00, /* 0x40490fdb */
-a0  =  7.7215664089e-02, /* 0x3d9e233f */
-a1  =  3.2246702909e-01, /* 0x3ea51a66 */
-a2  =  6.7352302372e-02, /* 0x3d89f001 */
-a3  =  2.0580807701e-02, /* 0x3ca89915 */
-a4  =  7.3855509982e-03, /* 0x3bf2027e */
-a5  =  2.8905137442e-03, /* 0x3b3d6ec6 */
-a6  =  1.1927076848e-03, /* 0x3a9c54a1 */
-a7  =  5.1006977446e-04, /* 0x3a05b634 */
-a8  =  2.2086278477e-04, /* 0x39679767 */
-a9  =  1.0801156895e-04, /* 0x38e28445 */
-a10 =  2.5214456400e-05, /* 0x37d383a2 */
-a11 =  4.4864096708e-05, /* 0x383c2c75 */
-tc  =  1.4616321325e+00, /* 0x3fbb16c3 */
-tf  = -1.2148628384e-01, /* 0xbdf8cdcd */
+two23=  8.3886080000e+06f, /* 0x4b000000 */
+half=  5.0000000000e-01f, /* 0x3f000000 */
+one =  1.0000000000e+00f, /* 0x3f800000 */
+pi  =  3.1415927410e+00f, /* 0x40490fdb */
+a0  =  7.7215664089e-02f, /* 0x3d9e233f */
+a1  =  3.2246702909e-01f, /* 0x3ea51a66 */
+a2  =  6.7352302372e-02f, /* 0x3d89f001 */
+a3  =  2.0580807701e-02f, /* 0x3ca89915 */
+a4  =  7.3855509982e-03f, /* 0x3bf2027e */
+a5  =  2.8905137442e-03f, /* 0x3b3d6ec6 */
+a6  =  1.1927076848e-03f, /* 0x3a9c54a1 */
+a7  =  5.1006977446e-04f, /* 0x3a05b634 */
+a8  =  2.2086278477e-04f, /* 0x39679767 */
+a9  =  1.0801156895e-04f, /* 0x38e28445 */
+a10 =  2.5214456400e-05f, /* 0x37d383a2 */
+a11 =  4.4864096708e-05f, /* 0x383c2c75 */
+tc  =  1.4616321325e+00f, /* 0x3fbb16c3 */
+tf  = -1.2148628384e-01f, /* 0xbdf8cdcd */
 /* tt = -(tail of tf) */
-tt  =  6.6971006518e-09, /* 0x31e61c52 */
-t0  =  4.8383611441e-01, /* 0x3ef7b95e */
-t1  = -1.4758771658e-01, /* 0xbe17213c */
-t2  =  6.4624942839e-02, /* 0x3d845a15 */
-t3  = -3.2788541168e-02, /* 0xbd064d47 */
-t4  =  1.7970675603e-02, /* 0x3c93373d */
-t5  = -1.0314224288e-02, /* 0xbc28fcfe */
-t6  =  6.1005386524e-03, /* 0x3bc7e707 */
-t7  = -3.6845202558e-03, /* 0xbb7177fe */
-t8  =  2.2596477065e-03, /* 0x3b141699 */
-t9  = -1.4034647029e-03, /* 0xbab7f476 */
-t10 =  8.8108185446e-04, /* 0x3a66f867 */
-t11 = -5.3859531181e-04, /* 0xba0d3085 */
-t12 =  3.1563205994e-04, /* 0x39a57b6b */
-t13 = -3.1275415677e-04, /* 0xb9a3f927 */
-t14 =  3.3552918467e-04, /* 0x39afe9f7 */
-u0  = -7.7215664089e-02, /* 0xbd9e233f */
-u1  =  6.3282704353e-01, /* 0x3f2200f4 */
-u2  =  1.4549225569e+00, /* 0x3fba3ae7 */
-u3  =  9.7771751881e-01, /* 0x3f7a4bb2 */
-u4  =  2.2896373272e-01, /* 0x3e6a7578 */
-u5  =  1.3381091878e-02, /* 0x3c5b3c5e */
-v1  =  2.4559779167e+00, /* 0x401d2ebe */
-v2  =  2.1284897327e+00, /* 0x4008392d */
-v3  =  7.6928514242e-01, /* 0x3f44efdf */
-v4  =  1.0422264785e-01, /* 0x3dd572af */
-v5  =  3.2170924824e-03, /* 0x3b52d5db */
-s0  = -7.7215664089e-02, /* 0xbd9e233f */
-s1  =  2.1498242021e-01, /* 0x3e5c245a */
-s2  =  3.2577878237e-01, /* 0x3ea6cc7a */
-s3  =  1.4635047317e-01, /* 0x3e15dce6 */
-s4  =  2.6642270386e-02, /* 0x3cda40e4 */
-s5  =  1.8402845599e-03, /* 0x3af135b4 */
-s6  =  3.1947532989e-05, /* 0x3805ff67 */
-r1  =  1.3920053244e+00, /* 0x3fb22d3b */
-r2  =  7.2193557024e-01, /* 0x3f38d0c5 */
-r3  =  1.7193385959e-01, /* 0x3e300f6e */
-r4  =  1.8645919859e-02, /* 0x3c98bf54 */
-r5  =  7.7794247773e-04, /* 0x3a4beed6 */
-r6  =  7.3266842264e-06, /* 0x36f5d7bd */
-w0  =  4.1893854737e-01, /* 0x3ed67f1d */
-w1  =  8.3333335817e-02, /* 0x3daaaaab */
-w2  = -2.7777778450e-03, /* 0xbb360b61 */
-w3  =  7.9365057172e-04, /* 0x3a500cfd */
-w4  = -5.9518753551e-04, /* 0xba1c065c */
-w5  =  8.3633989561e-04, /* 0x3a5b3dd2 */
-w6  = -1.6309292987e-03; /* 0xbad5c4e8 */
+tt  =  6.6971006518e-09f, /* 0x31e61c52 */
+t0  =  4.8383611441e-01f, /* 0x3ef7b95e */
+t1  = -1.4758771658e-01f, /* 0xbe17213c */
+t2  =  6.4624942839e-02f, /* 0x3d845a15 */
+t3  = -3.2788541168e-02f, /* 0xbd064d47 */
+t4  =  1.7970675603e-02f, /* 0x3c93373d */
+t5  = -1.0314224288e-02f, /* 0xbc28fcfe */
+t6  =  6.1005386524e-03f, /* 0x3bc7e707 */
+t7  = -3.6845202558e-03f, /* 0xbb7177fe */
+t8  =  2.2596477065e-03f, /* 0x3b141699 */
+t9  = -1.4034647029e-03f, /* 0xbab7f476 */
+t10 =  8.8108185446e-04f, /* 0x3a66f867 */
+t11 = -5.3859531181e-04f, /* 0xba0d3085 */
+t12 =  3.1563205994e-04f, /* 0x39a57b6b */
+t13 = -3.1275415677e-04f, /* 0xb9a3f927 */
+t14 =  3.3552918467e-04f, /* 0x39afe9f7 */
+u0  = -7.7215664089e-02f, /* 0xbd9e233f */
+u1  =  6.3282704353e-01f, /* 0x3f2200f4 */
+u2  =  1.4549225569e+00f, /* 0x3fba3ae7 */
+u3  =  9.7771751881e-01f, /* 0x3f7a4bb2 */
+u4  =  2.2896373272e-01f, /* 0x3e6a7578 */
+u5  =  1.3381091878e-02f, /* 0x3c5b3c5e */
+v1  =  2.4559779167e+00f, /* 0x401d2ebe */
+v2  =  2.1284897327e+00f, /* 0x4008392d */
+v3  =  7.6928514242e-01f, /* 0x3f44efdf */
+v4  =  1.0422264785e-01f, /* 0x3dd572af */
+v5  =  3.2170924824e-03f, /* 0x3b52d5db */
+s0  = -7.7215664089e-02f, /* 0xbd9e233f */
+s1  =  2.1498242021e-01f, /* 0x3e5c245a */
+s2  =  3.2577878237e-01f, /* 0x3ea6cc7a */
+s3  =  1.4635047317e-01f, /* 0x3e15dce6 */
+s4  =  2.6642270386e-02f, /* 0x3cda40e4 */
+s5  =  1.8402845599e-03f, /* 0x3af135b4 */
+s6  =  3.1947532989e-05f, /* 0x3805ff67 */
+r1  =  1.3920053244e+00f, /* 0x3fb22d3b */
+r2  =  7.2193557024e-01f, /* 0x3f38d0c5 */
+r3  =  1.7193385959e-01f, /* 0x3e300f6e */
+r4  =  1.8645919859e-02f, /* 0x3c98bf54 */
+r5  =  7.7794247773e-04f, /* 0x3a4beed6 */
+r6  =  7.3266842264e-06f, /* 0x36f5d7bd */
+w0  =  4.1893854737e-01f, /* 0x3ed67f1d */
+w1  =  8.3333335817e-02f, /* 0x3daaaaab */
+w2  = -2.7777778450e-03f, /* 0xbb360b61 */
+w3  =  7.9365057172e-04f, /* 0x3a500cfd */
+w4  = -5.9518753551e-04f, /* 0xba1c065c */
+w5  =  8.3633989561e-04f, /* 0x3a5b3dd2 */
+w6  = -1.6309292987e-03f; /* 0xbad5c4e8 */
 
 #ifdef __STDC__
-static const float zero=  0.0000000000e+00;
+static const float zero=  0.0000000000e+00f;
 #else
-static float zero=  0.0000000000e+00;
+static float zero=  0.0000000000e+00f;
 #endif
 
 #ifdef __STDC__
diff --git a/lib/libm/kf_cos.c b/lib/libm/kf_cos.c
index 691f9842fd87a..58ffc65861be7 100644
--- a/lib/libm/kf_cos.c
+++ b/lib/libm/kf_cos.c
@@ -29,13 +29,13 @@ static const float
 #else
 static float 
 #endif
-one =  1.0000000000e+00, /* 0x3f800000 */
-C1  =  4.1666667908e-02, /* 0x3d2aaaab */
-C2  = -1.3888889225e-03, /* 0xbab60b61 */
-C3  =  2.4801587642e-05, /* 0x37d00d01 */
-C4  = -2.7557314297e-07, /* 0xb493f27c */
-C5  =  2.0875723372e-09, /* 0x310f74f6 */
-C6  = -1.1359647598e-11; /* 0xad47d74e */
+one =  1.0000000000e+00f, /* 0x3f800000 */
+C1  =  4.1666667908e-02f, /* 0x3d2aaaab */
+C2  = -1.3888889225e-03f, /* 0xbab60b61 */
+C3  =  2.4801587642e-05f, /* 0x37d00d01 */
+C4  = -2.7557314297e-07f, /* 0xb493f27c */
+C5  =  2.0875723372e-09f, /* 0x310f74f6 */
+C6  = -1.1359647598e-11f; /* 0xad47d74e */
 
 #ifdef __STDC__
 	float __kernel_cosf(float x, float y)
diff --git a/lib/libm/kf_rem_pio2.c b/lib/libm/kf_rem_pio2.c
index c7e9479571ea8..6bd4d287e6905 100644
--- a/lib/libm/kf_rem_pio2.c
+++ b/lib/libm/kf_rem_pio2.c
@@ -38,17 +38,17 @@ static const float PIo2[] = {
 #else
 static float PIo2[] = {
 #endif
-  1.5703125000e+00, /* 0x3fc90000 */
-  4.5776367188e-04, /* 0x39f00000 */
-  2.5987625122e-05, /* 0x37da0000 */
-  7.5437128544e-08, /* 0x33a20000 */
-  6.0026650317e-11, /* 0x2e840000 */
-  7.3896444519e-13, /* 0x2b500000 */
-  5.3845816694e-15, /* 0x27c20000 */
-  5.6378512969e-18, /* 0x22d00000 */
-  8.3009228831e-20, /* 0x1fc40000 */
-  3.2756352257e-22, /* 0x1bc60000 */
-  6.3331015649e-25, /* 0x17440000 */
+  1.5703125000e+00f, /* 0x3fc90000 */
+  4.5776367188e-04f, /* 0x39f00000 */
+  2.5987625122e-05f, /* 0x37da0000 */
+  7.5437128544e-08f, /* 0x33a20000 */
+  6.0026650317e-11f, /* 0x2e840000 */
+  7.3896444519e-13f, /* 0x2b500000 */
+  5.3845816694e-15f, /* 0x27c20000 */
+  5.6378512969e-18f, /* 0x22d00000 */
+  8.3009228831e-20f, /* 0x1fc40000 */
+  3.2756352257e-22f, /* 0x1bc60000 */
+  6.3331015649e-25f, /* 0x17440000 */
 };
 
 #ifdef __STDC__
@@ -56,10 +56,10 @@ static const float
 #else
 static float			
 #endif
-zero   = 0.0,
-one    = 1.0,
-two8   =  2.5600000000e+02, /* 0x43800000 */
-twon8  =  3.9062500000e-03; /* 0x3b800000 */
+zero   = 0.0f,
+one    = 1.0f,
+two8   =  2.5600000000e+02f, /* 0x43800000 */
+twon8  =  3.9062500000e-03f; /* 0x3b800000 */
 
 #ifdef __STDC__
 	int __kernel_rem_pio2f(float *x, float *y, int e0, int nx, int prec, const __int32_t *ipio2) 
diff --git a/lib/libm/kf_sin.c b/lib/libm/kf_sin.c
index 07ea993446082..5fb86fbe82264 100644
--- a/lib/libm/kf_sin.c
+++ b/lib/libm/kf_sin.c
@@ -29,13 +29,13 @@ static const float
 #else
 static float 
 #endif
-half =  5.0000000000e-01,/* 0x3f000000 */
-S1  = -1.6666667163e-01, /* 0xbe2aaaab */
-S2  =  8.3333337680e-03, /* 0x3c088889 */
-S3  = -1.9841270114e-04, /* 0xb9500d01 */
-S4  =  2.7557314297e-06, /* 0x3638ef1b */
-S5  = -2.5050759689e-08, /* 0xb2d72f34 */
-S6  =  1.5896910177e-10; /* 0x2f2ec9d3 */
+half =  5.0000000000e-01f,/* 0x3f000000 */
+S1  = -1.6666667163e-01f, /* 0xbe2aaaab */
+S2  =  8.3333337680e-03f, /* 0x3c088889 */
+S3  = -1.9841270114e-04f, /* 0xb9500d01 */
+S4  =  2.7557314297e-06f, /* 0x3638ef1b */
+S5  = -2.5050759689e-08f, /* 0xb2d72f34 */
+S6  =  1.5896910177e-10f; /* 0x2f2ec9d3 */
 
 #ifdef __STDC__
 	float __kernel_sinf(float x, float y, int iy)
diff --git a/lib/libm/kf_tan.c b/lib/libm/kf_tan.c
index 6da9bd8171242..a9c89933945c5 100644
--- a/lib/libm/kf_tan.c
+++ b/lib/libm/kf_tan.c
@@ -28,23 +28,23 @@ static const float
 #else
 static float 
 #endif
-one   =  1.0000000000e+00, /* 0x3f800000 */
-pio4  =  7.8539812565e-01, /* 0x3f490fda */
-pio4lo=  3.7748947079e-08, /* 0x33222168 */
+one   =  1.0000000000e+00f, /* 0x3f800000 */
+pio4  =  7.8539812565e-01f, /* 0x3f490fda */
+pio4lo=  3.7748947079e-08f, /* 0x33222168 */
 T[] =  {
-  3.3333334327e-01, /* 0x3eaaaaab */
-  1.3333334029e-01, /* 0x3e088889 */
-  5.3968254477e-02, /* 0x3d5d0dd1 */
-  2.1869488060e-02, /* 0x3cb327a4 */
-  8.8632395491e-03, /* 0x3c11371f */
-  3.5920790397e-03, /* 0x3b6b6916 */
-  1.4562094584e-03, /* 0x3abede48 */
-  5.8804126456e-04, /* 0x3a1a26c8 */
-  2.4646313977e-04, /* 0x398137b9 */
-  7.8179444245e-05, /* 0x38a3f445 */
-  7.1407252108e-05, /* 0x3895c07a */
- -1.8558637748e-05, /* 0xb79bae5f */
-  2.5907305826e-05, /* 0x37d95384 */
+  3.3333334327e-01f, /* 0x3eaaaaab */
+  1.3333334029e-01f, /* 0x3e088889 */
+  5.3968254477e-02f, /* 0x3d5d0dd1 */
+  2.1869488060e-02f, /* 0x3cb327a4 */
+  8.8632395491e-03f, /* 0x3c11371f */
+  3.5920790397e-03f, /* 0x3b6b6916 */
+  1.4562094584e-03f, /* 0x3abede48 */
+  5.8804126456e-04f, /* 0x3a1a26c8 */
+  2.4646313977e-04f, /* 0x398137b9 */
+  7.8179444245e-05f, /* 0x38a3f445 */
+  7.1407252108e-05f, /* 0x3895c07a */
+ -1.8558637748e-05f, /* 0xb79bae5f */
+  2.5907305826e-05f, /* 0x37d95384 */
 };
 
 #ifdef __STDC__
diff --git a/lib/libm/log1pf.c b/lib/libm/log1pf.c
index 0d32b0a2fe143..9585f5b801f5b 100644
--- a/lib/libm/log1pf.c
+++ b/lib/libm/log1pf.c
@@ -19,13 +19,13 @@
 #include "libm.h"
 
 static const float
-ln2_hi = 6.9313812256e-01, /* 0x3f317180 */
-ln2_lo = 9.0580006145e-06, /* 0x3717f7d1 */
+ln2_hi = 6.9313812256e-01f, /* 0x3f317180 */
+ln2_lo = 9.0580006145e-06f, /* 0x3717f7d1 */
 /* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). */
-Lg1 = 0xaaaaaa.0p-24, /* 0.66666662693 */
-Lg2 = 0xccce13.0p-25, /* 0.40000972152 */
-Lg3 = 0x91e9ee.0p-25, /* 0.28498786688 */
-Lg4 = 0xf89e26.0p-26; /* 0.24279078841 */
+Lg1 = 0xaaaaaa.0p-24f, /* 0.66666662693 */
+Lg2 = 0xccce13.0p-25f, /* 0.40000972152 */
+Lg3 = 0x91e9ee.0p-25f, /* 0.28498786688 */
+Lg4 = 0xf89e26.0p-26f; /* 0.24279078841 */
 
 float log1pf(float x)
 {
diff --git a/lib/libm/math.c b/lib/libm/math.c
index c23b9f8d36f6a..3dfd925655576 100644
--- a/lib/libm/math.c
+++ b/lib/libm/math.c
@@ -53,7 +53,7 @@ float copysignf(float x, float y) {
 }
 #endif
 
-static const float _M_LN10 = 2.30258509299404; // 0x40135d8e
+static const float _M_LN10 = 2.30258509299404f; // 0x40135d8e
 float log10f(float x) { return logf(x) / (float)_M_LN10; }
 
 float tanhf(float x) {
@@ -139,34 +139,34 @@ float scalbnf(float x, int n)
  */
 
 static const float
-bp[]   = {1.0, 1.5,},
-dp_h[] = { 0.0, 5.84960938e-01,}, /* 0x3f15c000 */
-dp_l[] = { 0.0, 1.56322085e-06,}, /* 0x35d1cfdc */
-two24  =  16777216.0,  /* 0x4b800000 */
-huge   =  1.0e30,
-tiny   =  1.0e-30,
+bp[]   = {1.0f, 1.5f,},
+dp_h[] = { 0.0f, 5.84960938e-01f,}, /* 0x3f15c000 */
+dp_l[] = { 0.0f, 1.56322085e-06f,}, /* 0x35d1cfdc */
+two24  =  16777216.0f,  /* 0x4b800000 */
+huge   =  1.0e30f,
+tiny   =  1.0e-30f,
 /* poly coefs for (3/2)*(log(x)-2s-2/3*s**3 */
-L1 =  6.0000002384e-01, /* 0x3f19999a */
-L2 =  4.2857143283e-01, /* 0x3edb6db7 */
-L3 =  3.3333334327e-01, /* 0x3eaaaaab */
-L4 =  2.7272811532e-01, /* 0x3e8ba305 */
-L5 =  2.3066075146e-01, /* 0x3e6c3255 */
-L6 =  2.0697501302e-01, /* 0x3e53f142 */
-P1 =  1.6666667163e-01, /* 0x3e2aaaab */
-P2 = -2.7777778450e-03, /* 0xbb360b61 */
-P3 =  6.6137559770e-05, /* 0x388ab355 */
-P4 = -1.6533901999e-06, /* 0xb5ddea0e */
-P5 =  4.1381369442e-08, /* 0x3331bb4c */
-lg2     =  6.9314718246e-01, /* 0x3f317218 */
-lg2_h   =  6.93145752e-01,   /* 0x3f317200 */
-lg2_l   =  1.42860654e-06,   /* 0x35bfbe8c */
-ovt     =  4.2995665694e-08, /* -(128-log2(ovfl+.5ulp)) */
-cp      =  9.6179670095e-01, /* 0x3f76384f =2/(3ln2) */
-cp_h    =  9.6191406250e-01, /* 0x3f764000 =12b cp */
-cp_l    = -1.1736857402e-04, /* 0xb8f623c6 =tail of cp_h */
-ivln2   =  1.4426950216e+00, /* 0x3fb8aa3b =1/ln2 */
-ivln2_h =  1.4426879883e+00, /* 0x3fb8aa00 =16b 1/ln2*/
-ivln2_l =  7.0526075433e-06; /* 0x36eca570 =1/ln2 tail*/
+L1 =  6.0000002384e-01f, /* 0x3f19999a */
+L2 =  4.2857143283e-01f, /* 0x3edb6db7 */
+L3 =  3.3333334327e-01f, /* 0x3eaaaaab */
+L4 =  2.7272811532e-01f, /* 0x3e8ba305 */
+L5 =  2.3066075146e-01f, /* 0x3e6c3255 */
+L6 =  2.0697501302e-01f, /* 0x3e53f142 */
+P1 =  1.6666667163e-01f, /* 0x3e2aaaab */
+P2 = -2.7777778450e-03f, /* 0xbb360b61 */
+P3 =  6.6137559770e-05f, /* 0x388ab355 */
+P4 = -1.6533901999e-06f, /* 0xb5ddea0e */
+P5 =  4.1381369442e-08f, /* 0x3331bb4c */
+lg2     =  6.9314718246e-01f, /* 0x3f317218 */
+lg2_h   =  6.93145752e-01f,   /* 0x3f317200 */
+lg2_l   =  1.42860654e-06f,   /* 0x35bfbe8c */
+ovt     =  4.2995665694e-08f, /* -(128-log2(ovfl+.5ulp)) */
+cp      =  9.6179670095e-01f, /* 0x3f76384f =2/(3ln2) */
+cp_h    =  9.6191406250e-01f, /* 0x3f764000 =12b cp */
+cp_l    = -1.1736857402e-04f, /* 0xb8f623c6 =tail of cp_h */
+ivln2   =  1.4426950216e+00f, /* 0x3fb8aa3b =1/ln2 */
+ivln2_h =  1.4426879883e+00f, /* 0x3fb8aa00 =16b 1/ln2*/
+ivln2_l =  7.0526075433e-06f; /* 0x36eca570 =1/ln2 tail*/
 
 float powf(float x, float y)
 {
@@ -403,7 +403,7 @@ float powf(float x, float y)
  */
 
 static const float
-half[2] = {0.5,-0.5},
+half[2] = {0.5f,-0.5f},
 ln2hi   = 6.9314575195e-1f,  /* 0x3f317200 */
 ln2lo   = 1.4286067653e-6f,  /* 0x35bfbe8e */
 invln2  = 1.4426950216e+0f,  /* 0x3fb8aa3b */
@@ -442,7 +442,7 @@ float expf(float x)
 	/* argument reduction */
 	if (hx > 0x3eb17218) {  /* if |x| > 0.5 ln2 */
 		if (hx > 0x3f851592)  /* if |x| > 1.5 ln2 */
-			k = invln2*x + half[sign];
+			k = (int)(invln2*x + half[sign]);
 		else
 			k = 1 - sign - sign;
 		hi = x - k*ln2hi;  /* k*ln2hi is exact here */
@@ -489,17 +489,17 @@ float expf(float x)
  */
 
 static const float
-o_threshold = 8.8721679688e+01, /* 0x42b17180 */
-ln2_hi      = 6.9313812256e-01, /* 0x3f317180 */
-ln2_lo      = 9.0580006145e-06, /* 0x3717f7d1 */
+o_threshold = 8.8721679688e+01f, /* 0x42b17180 */
+ln2_hi      = 6.9313812256e-01f, /* 0x3f317180 */
+ln2_lo      = 9.0580006145e-06f, /* 0x3717f7d1 */
 //invln2      = 1.4426950216e+00, /* 0x3fb8aa3b */
 /*
  * Domain [-0.34568, 0.34568], range ~[-6.694e-10, 6.696e-10]:
  * |6 / x * (1 + 2 * (1 / (exp(x) - 1) - 1 / x)) - q(x)| < 2**-30.04
  * Scaled coefficients: Qn_here = 2**n * Qn_for_q (see s_expm1.c):
  */
-Q1 = -3.3333212137e-2, /* -0x888868.0p-28 */
-Q2 =  1.5807170421e-3; /*  0xcf3010.0p-33 */
+Q1 = -3.3333212137e-2f, /* -0x888868.0p-28 */
+Q2 =  1.5807170421e-3f; /*  0xcf3010.0p-33 */
 
 float expm1f(float x)
 {
@@ -533,7 +533,7 @@ float expm1f(float x)
 				k = -1;
 			}
 		} else {
-			k  = invln2*x + (sign ? -0.5f : 0.5f);
+			k  = (int)(invln2*x + (sign ? -0.5f : 0.5f));
 			t  = k;
 			hi = x - t*ln2_hi;      /* t*ln2_hi is exact here */
 			lo = t*ln2_lo;
diff --git a/lib/libm/sf_erf.c b/lib/libm/sf_erf.c
index 3f0172c6e966a..85af35afd722c 100644
--- a/lib/libm/sf_erf.c
+++ b/lib/libm/sf_erf.c
@@ -35,79 +35,79 @@ static const float
 #else
 static float
 #endif
-tiny	    = 1e-30,
-half=  5.0000000000e-01, /* 0x3F000000 */
-one =  1.0000000000e+00, /* 0x3F800000 */
-two =  2.0000000000e+00, /* 0x40000000 */
+tiny	    = 1e-30f,
+half=  5.0000000000e-01f, /* 0x3F000000 */
+one =  1.0000000000e+00f, /* 0x3F800000 */
+two =  2.0000000000e+00f, /* 0x40000000 */
 	/* c = (subfloat)0.84506291151 */
-erx =  8.4506291151e-01, /* 0x3f58560b */
+erx =  8.4506291151e-01f, /* 0x3f58560b */
 /*
  * Coefficients for approximation to  erf on [0,0.84375]
  */
-efx =  1.2837916613e-01, /* 0x3e0375d4 */
-efx8=  1.0270333290e+00, /* 0x3f8375d4 */
-pp0  =  1.2837916613e-01, /* 0x3e0375d4 */
-pp1  = -3.2504209876e-01, /* 0xbea66beb */
-pp2  = -2.8481749818e-02, /* 0xbce9528f */
-pp3  = -5.7702702470e-03, /* 0xbbbd1489 */
-pp4  = -2.3763017452e-05, /* 0xb7c756b1 */
-qq1  =  3.9791721106e-01, /* 0x3ecbbbce */
-qq2  =  6.5022252500e-02, /* 0x3d852a63 */
-qq3  =  5.0813062117e-03, /* 0x3ba68116 */
-qq4  =  1.3249473704e-04, /* 0x390aee49 */
-qq5  = -3.9602282413e-06, /* 0xb684e21a */
+efx =  1.2837916613e-01f, /* 0x3e0375d4 */
+efx8=  1.0270333290e+00f, /* 0x3f8375d4 */
+pp0  =  1.2837916613e-01f, /* 0x3e0375d4 */
+pp1  = -3.2504209876e-01f, /* 0xbea66beb */
+pp2  = -2.8481749818e-02f, /* 0xbce9528f */
+pp3  = -5.7702702470e-03f, /* 0xbbbd1489 */
+pp4  = -2.3763017452e-05f, /* 0xb7c756b1 */
+qq1  =  3.9791721106e-01f, /* 0x3ecbbbce */
+qq2  =  6.5022252500e-02f, /* 0x3d852a63 */
+qq3  =  5.0813062117e-03f, /* 0x3ba68116 */
+qq4  =  1.3249473704e-04f, /* 0x390aee49 */
+qq5  = -3.9602282413e-06f, /* 0xb684e21a */
 /*
  * Coefficients for approximation to  erf  in [0.84375,1.25] 
  */
-pa0  = -2.3621185683e-03, /* 0xbb1acdc6 */
-pa1  =  4.1485610604e-01, /* 0x3ed46805 */
-pa2  = -3.7220788002e-01, /* 0xbebe9208 */
-pa3  =  3.1834661961e-01, /* 0x3ea2fe54 */
-pa4  = -1.1089469492e-01, /* 0xbde31cc2 */
-pa5  =  3.5478305072e-02, /* 0x3d1151b3 */
-pa6  = -2.1663755178e-03, /* 0xbb0df9c0 */
-qa1  =  1.0642088205e-01, /* 0x3dd9f331 */
-qa2  =  5.4039794207e-01, /* 0x3f0a5785 */
-qa3  =  7.1828655899e-02, /* 0x3d931ae7 */
-qa4  =  1.2617121637e-01, /* 0x3e013307 */
-qa5  =  1.3637083583e-02, /* 0x3c5f6e13 */
-qa6  =  1.1984500103e-02, /* 0x3c445aa3 */
+pa0  = -2.3621185683e-03f, /* 0xbb1acdc6 */
+pa1  =  4.1485610604e-01f, /* 0x3ed46805 */
+pa2  = -3.7220788002e-01f, /* 0xbebe9208 */
+pa3  =  3.1834661961e-01f, /* 0x3ea2fe54 */
+pa4  = -1.1089469492e-01f, /* 0xbde31cc2 */
+pa5  =  3.5478305072e-02f, /* 0x3d1151b3 */
+pa6  = -2.1663755178e-03f, /* 0xbb0df9c0 */
+qa1  =  1.0642088205e-01f, /* 0x3dd9f331 */
+qa2  =  5.4039794207e-01f, /* 0x3f0a5785 */
+qa3  =  7.1828655899e-02f, /* 0x3d931ae7 */
+qa4  =  1.2617121637e-01f, /* 0x3e013307 */
+qa5  =  1.3637083583e-02f, /* 0x3c5f6e13 */
+qa6  =  1.1984500103e-02f, /* 0x3c445aa3 */
 /*
  * Coefficients for approximation to  erfc in [1.25,1/0.35]
  */
-ra0  = -9.8649440333e-03, /* 0xbc21a093 */
-ra1  = -6.9385856390e-01, /* 0xbf31a0b7 */
-ra2  = -1.0558626175e+01, /* 0xc128f022 */
-ra3  = -6.2375331879e+01, /* 0xc2798057 */
-ra4  = -1.6239666748e+02, /* 0xc322658c */
-ra5  = -1.8460508728e+02, /* 0xc3389ae7 */
-ra6  = -8.1287437439e+01, /* 0xc2a2932b */
-ra7  = -9.8143291473e+00, /* 0xc11d077e */
-sa1  =  1.9651271820e+01, /* 0x419d35ce */
-sa2  =  1.3765776062e+02, /* 0x4309a863 */
-sa3  =  4.3456588745e+02, /* 0x43d9486f */
-sa4  =  6.4538726807e+02, /* 0x442158c9 */
-sa5  =  4.2900814819e+02, /* 0x43d6810b */
-sa6  =  1.0863500214e+02, /* 0x42d9451f */
-sa7  =  6.5702495575e+00, /* 0x40d23f7c */
-sa8  = -6.0424413532e-02, /* 0xbd777f97 */
+ra0  = -9.8649440333e-03f, /* 0xbc21a093 */
+ra1  = -6.9385856390e-01f, /* 0xbf31a0b7 */
+ra2  = -1.0558626175e+01f, /* 0xc128f022 */
+ra3  = -6.2375331879e+01f, /* 0xc2798057 */
+ra4  = -1.6239666748e+02f, /* 0xc322658c */
+ra5  = -1.8460508728e+02f, /* 0xc3389ae7 */
+ra6  = -8.1287437439e+01f, /* 0xc2a2932b */
+ra7  = -9.8143291473e+00f, /* 0xc11d077e */
+sa1  =  1.9651271820e+01f, /* 0x419d35ce */
+sa2  =  1.3765776062e+02f, /* 0x4309a863 */
+sa3  =  4.3456588745e+02f, /* 0x43d9486f */
+sa4  =  6.4538726807e+02f, /* 0x442158c9 */
+sa5  =  4.2900814819e+02f, /* 0x43d6810b */
+sa6  =  1.0863500214e+02f, /* 0x42d9451f */
+sa7  =  6.5702495575e+00f, /* 0x40d23f7c */
+sa8  = -6.0424413532e-02f, /* 0xbd777f97 */
 /*
  * Coefficients for approximation to  erfc in [1/.35,28]
  */
-rb0  = -9.8649431020e-03, /* 0xbc21a092 */
-rb1  = -7.9928326607e-01, /* 0xbf4c9dd4 */
-rb2  = -1.7757955551e+01, /* 0xc18e104b */
-rb3  = -1.6063638306e+02, /* 0xc320a2ea */
-rb4  = -6.3756646729e+02, /* 0xc41f6441 */
-rb5  = -1.0250950928e+03, /* 0xc480230b */
-rb6  = -4.8351919556e+02, /* 0xc3f1c275 */
-sb1  =  3.0338060379e+01, /* 0x41f2b459 */
-sb2  =  3.2579251099e+02, /* 0x43a2e571 */
-sb3  =  1.5367296143e+03, /* 0x44c01759 */
-sb4  =  3.1998581543e+03, /* 0x4547fdbb */
-sb5  =  2.5530502930e+03, /* 0x451f90ce */
-sb6  =  4.7452853394e+02, /* 0x43ed43a7 */
-sb7  = -2.2440952301e+01; /* 0xc1b38712 */
+rb0  = -9.8649431020e-03f, /* 0xbc21a092 */
+rb1  = -7.9928326607e-01f, /* 0xbf4c9dd4 */
+rb2  = -1.7757955551e+01f, /* 0xc18e104b */
+rb3  = -1.6063638306e+02f, /* 0xc320a2ea */
+rb4  = -6.3756646729e+02f, /* 0xc41f6441 */
+rb5  = -1.0250950928e+03f, /* 0xc480230b */
+rb6  = -4.8351919556e+02f, /* 0xc3f1c275 */
+sb1  =  3.0338060379e+01f, /* 0x41f2b459 */
+sb2  =  3.2579251099e+02f, /* 0x43a2e571 */
+sb3  =  1.5367296143e+03f, /* 0x44c01759 */
+sb4  =  3.1998581543e+03f, /* 0x4547fdbb */
+sb5  =  2.5530502930e+03f, /* 0x451f90ce */
+sb6  =  4.7452853394e+02f, /* 0x43ed43a7 */
+sb7  = -2.2440952301e+01f; /* 0xc1b38712 */
 
 #ifdef __STDC__
 	float erff(float x) 
diff --git a/lib/libm/sf_frexp.c b/lib/libm/sf_frexp.c
index df50fb773796f..378f21fb2f4fb 100644
--- a/lib/libm/sf_frexp.c
+++ b/lib/libm/sf_frexp.c
@@ -29,7 +29,7 @@ static const float
 #else
 static float
 #endif
-two25 =  3.3554432000e+07; /* 0x4c000000 */
+two25 =  3.3554432000e+07f; /* 0x4c000000 */
 
 #ifdef __STDC__
 	float frexpf(float x, int *eptr)
diff --git a/lib/libm/sf_ldexp.c b/lib/libm/sf_ldexp.c
index 37968d475ae99..31dd9b3d8d0ae 100644
--- a/lib/libm/sf_ldexp.c
+++ b/lib/libm/sf_ldexp.c
@@ -23,7 +23,6 @@
  */
 
 #include "fdlibm.h"
-//#include <errno.h>
 
 #ifdef __STDC__
 	float ldexpf(float value, int exp)
diff --git a/lib/libm/sf_modf.c b/lib/libm/sf_modf.c
index 410db2a373848..7c1b81399d6d6 100644
--- a/lib/libm/sf_modf.c
+++ b/lib/libm/sf_modf.c
@@ -25,9 +25,9 @@
 #include "fdlibm.h"
 
 #ifdef __STDC__
-static const float one = 1.0;
+static const float one = 1.0f;
 #else
-static float one = 1.0;
+static float one = 1.0f;
 #endif
 
 #ifdef __STDC__
diff --git a/lib/libm/wf_lgamma.c b/lib/libm/wf_lgamma.c
index d86ede790bd91..834a4de482223 100644
--- a/lib/libm/wf_lgamma.c
+++ b/lib/libm/wf_lgamma.c
@@ -25,8 +25,6 @@
 
 #include "fdlibm.h"
 #define _IEEE_LIBM 1
-//#include <reent.h>
-//#include <errno.h>
 
 #ifdef __STDC__
 	float lgammaf(float x)
diff --git a/lib/libm_dbl/nearbyint.c b/lib/libm_dbl/nearbyint.c
index 6e9b0c1f78210..c3a0b88afee73 100644
--- a/lib/libm_dbl/nearbyint.c
+++ b/lib/libm_dbl/nearbyint.c
@@ -1,4 +1,3 @@
-//#include <fenv.h>
 #include <math.h>
 
 /* nearbyint is the same as rint, but it must not raise the inexact exception */
diff --git a/lib/libm_dbl/thumb_vfp_sqrt.c b/lib/libm_dbl/thumb_vfp_sqrt.c
new file mode 100644
index 0000000000000..dd37a07b053c5
--- /dev/null
+++ b/lib/libm_dbl/thumb_vfp_sqrt.c
@@ -0,0 +1,10 @@
+// an implementation of sqrt for Thumb using hardware double-precision VFP instructions
+
+double sqrt(double x) {
+    double ret;
+    asm volatile (
+            "vsqrt.f64  %P0, %P1\n"
+            : "=w" (ret)
+            : "w"  (x));
+    return ret;
+}
diff --git a/lib/littlefs/README.md b/lib/littlefs/README.md
new file mode 100644
index 0000000000000..1f0aacbf9840f
--- /dev/null
+++ b/lib/littlefs/README.md
@@ -0,0 +1,19 @@
+littlefs library
+================
+
+The upstream source for the files in this directory is
+https://github.com/ARMmbed/littlefs
+
+To generate the separate files with lfs1 and lfs2 prefixes run the following
+commands in the top-level directory of the littlefs repository (replace the
+version tags with the latest/desired ones, and set `$MPY_DIR`):
+
+    git checkout v1.7.2
+    python2 ./scripts/prefix.py lfs1
+    cp lfs1*.[ch] $MPY_DIR/lib/littlefs
+    git reset --hard HEAD
+
+    git checkout v2.1.3
+    python2 ./scripts/prefix.py lfs2
+    cp lfs2*.[ch] $MPY_DIR/lib/littlefs
+    git reset --hard HEAD
diff --git a/lib/littlefs/lfs1.c b/lib/littlefs/lfs1.c
new file mode 100644
index 0000000000000..6a3fd670012cc
--- /dev/null
+++ b/lib/littlefs/lfs1.c
@@ -0,0 +1,2583 @@
+/*
+ * The little filesystem
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#include "lfs1.h"
+#include "lfs1_util.h"
+
+#include <inttypes.h>
+
+
+/// Caching block device operations ///
+static int lfs1_cache_read(lfs1_t *lfs1, lfs1_cache_t *rcache,
+        const lfs1_cache_t *pcache, lfs1_block_t block,
+        lfs1_off_t off, void *buffer, lfs1_size_t size) {
+    uint8_t *data = buffer;
+    LFS1_ASSERT(block < lfs1->cfg->block_count);
+
+    while (size > 0) {
+        if (pcache && block == pcache->block && off >= pcache->off &&
+                off < pcache->off + lfs1->cfg->prog_size) {
+            // is already in pcache?
+            lfs1_size_t diff = lfs1_min(size,
+                    lfs1->cfg->prog_size - (off-pcache->off));
+            memcpy(data, &pcache->buffer[off-pcache->off], diff);
+
+            data += diff;
+            off += diff;
+            size -= diff;
+            continue;
+        }
+
+        if (block == rcache->block && off >= rcache->off &&
+                off < rcache->off + lfs1->cfg->read_size) {
+            // is already in rcache?
+            lfs1_size_t diff = lfs1_min(size,
+                    lfs1->cfg->read_size - (off-rcache->off));
+            memcpy(data, &rcache->buffer[off-rcache->off], diff);
+
+            data += diff;
+            off += diff;
+            size -= diff;
+            continue;
+        }
+
+        if (off % lfs1->cfg->read_size == 0 && size >= lfs1->cfg->read_size) {
+            // bypass cache?
+            lfs1_size_t diff = size - (size % lfs1->cfg->read_size);
+            int err = lfs1->cfg->read(lfs1->cfg, block, off, data, diff);
+            if (err) {
+                return err;
+            }
+
+            data += diff;
+            off += diff;
+            size -= diff;
+            continue;
+        }
+
+        // load to cache, first condition can no longer fail
+        rcache->block = block;
+        rcache->off = off - (off % lfs1->cfg->read_size);
+        int err = lfs1->cfg->read(lfs1->cfg, rcache->block,
+                rcache->off, rcache->buffer, lfs1->cfg->read_size);
+        if (err) {
+            return err;
+        }
+    }
+
+    return 0;
+}
+
+static int lfs1_cache_cmp(lfs1_t *lfs1, lfs1_cache_t *rcache,
+        const lfs1_cache_t *pcache, lfs1_block_t block,
+        lfs1_off_t off, const void *buffer, lfs1_size_t size) {
+    const uint8_t *data = buffer;
+
+    for (lfs1_off_t i = 0; i < size; i++) {
+        uint8_t c;
+        int err = lfs1_cache_read(lfs1, rcache, pcache,
+                block, off+i, &c, 1);
+        if (err) {
+            return err;
+        }
+
+        if (c != data[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static int lfs1_cache_crc(lfs1_t *lfs1, lfs1_cache_t *rcache,
+        const lfs1_cache_t *pcache, lfs1_block_t block,
+        lfs1_off_t off, lfs1_size_t size, uint32_t *crc) {
+    for (lfs1_off_t i = 0; i < size; i++) {
+        uint8_t c;
+        int err = lfs1_cache_read(lfs1, rcache, pcache,
+                block, off+i, &c, 1);
+        if (err) {
+            return err;
+        }
+
+        lfs1_crc(crc, &c, 1);
+    }
+
+    return 0;
+}
+
+static inline void lfs1_cache_drop(lfs1_t *lfs1, lfs1_cache_t *rcache) {
+    // do not zero, cheaper if cache is readonly or only going to be
+    // written with identical data (during relocates)
+    (void)lfs1;
+    rcache->block = 0xffffffff;
+}
+
+static inline void lfs1_cache_zero(lfs1_t *lfs1, lfs1_cache_t *pcache) {
+    // zero to avoid information leak
+    memset(pcache->buffer, 0xff, lfs1->cfg->prog_size);
+    pcache->block = 0xffffffff;
+}
+
+static int lfs1_cache_flush(lfs1_t *lfs1,
+        lfs1_cache_t *pcache, lfs1_cache_t *rcache) {
+    if (pcache->block != 0xffffffff) {
+        int err = lfs1->cfg->prog(lfs1->cfg, pcache->block,
+                pcache->off, pcache->buffer, lfs1->cfg->prog_size);
+        if (err) {
+            return err;
+        }
+
+        if (rcache) {
+            int res = lfs1_cache_cmp(lfs1, rcache, NULL, pcache->block,
+                    pcache->off, pcache->buffer, lfs1->cfg->prog_size);
+            if (res < 0) {
+                return res;
+            }
+
+            if (!res) {
+                return LFS1_ERR_CORRUPT;
+            }
+        }
+
+        lfs1_cache_zero(lfs1, pcache);
+    }
+
+    return 0;
+}
+
+static int lfs1_cache_prog(lfs1_t *lfs1, lfs1_cache_t *pcache,
+        lfs1_cache_t *rcache, lfs1_block_t block,
+        lfs1_off_t off, const void *buffer, lfs1_size_t size) {
+    const uint8_t *data = buffer;
+    LFS1_ASSERT(block < lfs1->cfg->block_count);
+
+    while (size > 0) {
+        if (block == pcache->block && off >= pcache->off &&
+                off < pcache->off + lfs1->cfg->prog_size) {
+            // is already in pcache?
+            lfs1_size_t diff = lfs1_min(size,
+                    lfs1->cfg->prog_size - (off-pcache->off));
+            memcpy(&pcache->buffer[off-pcache->off], data, diff);
+
+            data += diff;
+            off += diff;
+            size -= diff;
+
+            if (off % lfs1->cfg->prog_size == 0) {
+                // eagerly flush out pcache if we fill up
+                int err = lfs1_cache_flush(lfs1, pcache, rcache);
+                if (err) {
+                    return err;
+                }
+            }
+
+            continue;
+        }
+
+        // pcache must have been flushed, either by programming and
+        // entire block or manually flushing the pcache
+        LFS1_ASSERT(pcache->block == 0xffffffff);
+
+        if (off % lfs1->cfg->prog_size == 0 &&
+                size >= lfs1->cfg->prog_size) {
+            // bypass pcache?
+            lfs1_size_t diff = size - (size % lfs1->cfg->prog_size);
+            int err = lfs1->cfg->prog(lfs1->cfg, block, off, data, diff);
+            if (err) {
+                return err;
+            }
+
+            if (rcache) {
+                int res = lfs1_cache_cmp(lfs1, rcache, NULL,
+                        block, off, data, diff);
+                if (res < 0) {
+                    return res;
+                }
+
+                if (!res) {
+                    return LFS1_ERR_CORRUPT;
+                }
+            }
+
+            data += diff;
+            off += diff;
+            size -= diff;
+            continue;
+        }
+
+        // prepare pcache, first condition can no longer fail
+        pcache->block = block;
+        pcache->off = off - (off % lfs1->cfg->prog_size);
+    }
+
+    return 0;
+}
+
+
+/// General lfs1 block device operations ///
+static int lfs1_bd_read(lfs1_t *lfs1, lfs1_block_t block,
+        lfs1_off_t off, void *buffer, lfs1_size_t size) {
+    // if we ever do more than writes to alternating pairs,
+    // this may need to consider pcache
+    return lfs1_cache_read(lfs1, &lfs1->rcache, NULL,
+            block, off, buffer, size);
+}
+
+static int lfs1_bd_prog(lfs1_t *lfs1, lfs1_block_t block,
+        lfs1_off_t off, const void *buffer, lfs1_size_t size) {
+    return lfs1_cache_prog(lfs1, &lfs1->pcache, NULL,
+            block, off, buffer, size);
+}
+
+static int lfs1_bd_cmp(lfs1_t *lfs1, lfs1_block_t block,
+        lfs1_off_t off, const void *buffer, lfs1_size_t size) {
+    return lfs1_cache_cmp(lfs1, &lfs1->rcache, NULL, block, off, buffer, size);
+}
+
+static int lfs1_bd_crc(lfs1_t *lfs1, lfs1_block_t block,
+        lfs1_off_t off, lfs1_size_t size, uint32_t *crc) {
+    return lfs1_cache_crc(lfs1, &lfs1->rcache, NULL, block, off, size, crc);
+}
+
+static int lfs1_bd_erase(lfs1_t *lfs1, lfs1_block_t block) {
+    return lfs1->cfg->erase(lfs1->cfg, block);
+}
+
+static int lfs1_bd_sync(lfs1_t *lfs1) {
+    lfs1_cache_drop(lfs1, &lfs1->rcache);
+
+    int err = lfs1_cache_flush(lfs1, &lfs1->pcache, NULL);
+    if (err) {
+        return err;
+    }
+
+    return lfs1->cfg->sync(lfs1->cfg);
+}
+
+
+/// Internal operations predeclared here ///
+int lfs1_traverse(lfs1_t *lfs1, int (*cb)(void*, lfs1_block_t), void *data);
+static int lfs1_pred(lfs1_t *lfs1, const lfs1_block_t dir[2], lfs1_dir_t *pdir);
+static int lfs1_parent(lfs1_t *lfs1, const lfs1_block_t dir[2],
+        lfs1_dir_t *parent, lfs1_entry_t *entry);
+static int lfs1_moved(lfs1_t *lfs1, const void *e);
+static int lfs1_relocate(lfs1_t *lfs1,
+        const lfs1_block_t oldpair[2], const lfs1_block_t newpair[2]);
+int lfs1_deorphan(lfs1_t *lfs1);
+
+
+/// Block allocator ///
+static int lfs1_alloc_lookahead(void *p, lfs1_block_t block) {
+    lfs1_t *lfs1 = p;
+
+    lfs1_block_t off = ((block - lfs1->free.off)
+            + lfs1->cfg->block_count) % lfs1->cfg->block_count;
+
+    if (off < lfs1->free.size) {
+        lfs1->free.buffer[off / 32] |= 1U << (off % 32);
+    }
+
+    return 0;
+}
+
+static int lfs1_alloc(lfs1_t *lfs1, lfs1_block_t *block) {
+    while (true) {
+        while (lfs1->free.i != lfs1->free.size) {
+            lfs1_block_t off = lfs1->free.i;
+            lfs1->free.i += 1;
+            lfs1->free.ack -= 1;
+
+            if (!(lfs1->free.buffer[off / 32] & (1U << (off % 32)))) {
+                // found a free block
+                *block = (lfs1->free.off + off) % lfs1->cfg->block_count;
+
+                // eagerly find next off so an alloc ack can
+                // discredit old lookahead blocks
+                while (lfs1->free.i != lfs1->free.size &&
+                        (lfs1->free.buffer[lfs1->free.i / 32]
+                            & (1U << (lfs1->free.i % 32)))) {
+                    lfs1->free.i += 1;
+                    lfs1->free.ack -= 1;
+                }
+
+                return 0;
+            }
+        }
+
+        // check if we have looked at all blocks since last ack
+        if (lfs1->free.ack == 0) {
+            LFS1_WARN("No more free space %" PRIu32,
+                    lfs1->free.i + lfs1->free.off);
+            return LFS1_ERR_NOSPC;
+        }
+
+        lfs1->free.off = (lfs1->free.off + lfs1->free.size)
+                % lfs1->cfg->block_count;
+        lfs1->free.size = lfs1_min(lfs1->cfg->lookahead, lfs1->free.ack);
+        lfs1->free.i = 0;
+
+        // find mask of free blocks from tree
+        memset(lfs1->free.buffer, 0, lfs1->cfg->lookahead/8);
+        int err = lfs1_traverse(lfs1, lfs1_alloc_lookahead, lfs1);
+        if (err) {
+            return err;
+        }
+    }
+}
+
+static void lfs1_alloc_ack(lfs1_t *lfs1) {
+    lfs1->free.ack = lfs1->cfg->block_count;
+}
+
+
+/// Endian swapping functions ///
+static void lfs1_dir_fromle32(struct lfs1_disk_dir *d) {
+    d->rev     = lfs1_fromle32(d->rev);
+    d->size    = lfs1_fromle32(d->size);
+    d->tail[0] = lfs1_fromle32(d->tail[0]);
+    d->tail[1] = lfs1_fromle32(d->tail[1]);
+}
+
+static void lfs1_dir_tole32(struct lfs1_disk_dir *d) {
+    d->rev     = lfs1_tole32(d->rev);
+    d->size    = lfs1_tole32(d->size);
+    d->tail[0] = lfs1_tole32(d->tail[0]);
+    d->tail[1] = lfs1_tole32(d->tail[1]);
+}
+
+static void lfs1_entry_fromle32(struct lfs1_disk_entry *d) {
+    d->u.dir[0] = lfs1_fromle32(d->u.dir[0]);
+    d->u.dir[1] = lfs1_fromle32(d->u.dir[1]);
+}
+
+static void lfs1_entry_tole32(struct lfs1_disk_entry *d) {
+    d->u.dir[0] = lfs1_tole32(d->u.dir[0]);
+    d->u.dir[1] = lfs1_tole32(d->u.dir[1]);
+}
+
+static void lfs1_superblock_fromle32(struct lfs1_disk_superblock *d) {
+    d->root[0]     = lfs1_fromle32(d->root[0]);
+    d->root[1]     = lfs1_fromle32(d->root[1]);
+    d->block_size  = lfs1_fromle32(d->block_size);
+    d->block_count = lfs1_fromle32(d->block_count);
+    d->version     = lfs1_fromle32(d->version);
+}
+
+static void lfs1_superblock_tole32(struct lfs1_disk_superblock *d) {
+    d->root[0]     = lfs1_tole32(d->root[0]);
+    d->root[1]     = lfs1_tole32(d->root[1]);
+    d->block_size  = lfs1_tole32(d->block_size);
+    d->block_count = lfs1_tole32(d->block_count);
+    d->version     = lfs1_tole32(d->version);
+}
+
+
+/// Metadata pair and directory operations ///
+static inline void lfs1_pairswap(lfs1_block_t pair[2]) {
+    lfs1_block_t t = pair[0];
+    pair[0] = pair[1];
+    pair[1] = t;
+}
+
+static inline bool lfs1_pairisnull(const lfs1_block_t pair[2]) {
+    return pair[0] == 0xffffffff || pair[1] == 0xffffffff;
+}
+
+static inline int lfs1_paircmp(
+        const lfs1_block_t paira[2],
+        const lfs1_block_t pairb[2]) {
+    return !(paira[0] == pairb[0] || paira[1] == pairb[1] ||
+             paira[0] == pairb[1] || paira[1] == pairb[0]);
+}
+
+static inline bool lfs1_pairsync(
+        const lfs1_block_t paira[2],
+        const lfs1_block_t pairb[2]) {
+    return (paira[0] == pairb[0] && paira[1] == pairb[1]) ||
+           (paira[0] == pairb[1] && paira[1] == pairb[0]);
+}
+
+static inline lfs1_size_t lfs1_entry_size(const lfs1_entry_t *entry) {
+    return 4 + entry->d.elen + entry->d.alen + entry->d.nlen;
+}
+
+static int lfs1_dir_alloc(lfs1_t *lfs1, lfs1_dir_t *dir) {
+    // allocate pair of dir blocks
+    for (int i = 0; i < 2; i++) {
+        int err = lfs1_alloc(lfs1, &dir->pair[i]);
+        if (err) {
+            return err;
+        }
+    }
+
+    // rather than clobbering one of the blocks we just pretend
+    // the revision may be valid
+    int err = lfs1_bd_read(lfs1, dir->pair[0], 0, &dir->d.rev, 4);
+    if (err && err != LFS1_ERR_CORRUPT) {
+        return err;
+    }
+
+    if (err != LFS1_ERR_CORRUPT) {
+        dir->d.rev = lfs1_fromle32(dir->d.rev);
+    }
+
+    // set defaults
+    dir->d.rev += 1;
+    dir->d.size = sizeof(dir->d)+4;
+    dir->d.tail[0] = 0xffffffff;
+    dir->d.tail[1] = 0xffffffff;
+    dir->off = sizeof(dir->d);
+
+    // don't write out yet, let caller take care of that
+    return 0;
+}
+
+static int lfs1_dir_fetch(lfs1_t *lfs1,
+        lfs1_dir_t *dir, const lfs1_block_t pair[2]) {
+    // copy out pair, otherwise may be aliasing dir
+    const lfs1_block_t tpair[2] = {pair[0], pair[1]};
+    bool valid = false;
+
+    // check both blocks for the most recent revision
+    for (int i = 0; i < 2; i++) {
+        struct lfs1_disk_dir test;
+        int err = lfs1_bd_read(lfs1, tpair[i], 0, &test, sizeof(test));
+        lfs1_dir_fromle32(&test);
+        if (err) {
+            if (err == LFS1_ERR_CORRUPT) {
+                continue;
+            }
+            return err;
+        }
+
+        if (valid && lfs1_scmp(test.rev, dir->d.rev) < 0) {
+            continue;
+        }
+
+        if ((0x7fffffff & test.size) < sizeof(test)+4 ||
+            (0x7fffffff & test.size) > lfs1->cfg->block_size) {
+            continue;
+        }
+
+        uint32_t crc = 0xffffffff;
+        lfs1_dir_tole32(&test);
+        lfs1_crc(&crc, &test, sizeof(test));
+        lfs1_dir_fromle32(&test);
+        err = lfs1_bd_crc(lfs1, tpair[i], sizeof(test),
+                (0x7fffffff & test.size) - sizeof(test), &crc);
+        if (err) {
+            if (err == LFS1_ERR_CORRUPT) {
+                continue;
+            }
+            return err;
+        }
+
+        if (crc != 0) {
+            continue;
+        }
+
+        valid = true;
+
+        // setup dir in case it's valid
+        dir->pair[0] = tpair[(i+0) % 2];
+        dir->pair[1] = tpair[(i+1) % 2];
+        dir->off = sizeof(dir->d);
+        dir->d = test;
+    }
+
+    if (!valid) {
+        LFS1_ERROR("Corrupted dir pair at %" PRIu32 " %" PRIu32 ,
+                tpair[0], tpair[1]);
+        return LFS1_ERR_CORRUPT;
+    }
+
+    return 0;
+}
+
+struct lfs1_region {
+    lfs1_off_t oldoff;
+    lfs1_size_t oldlen;
+    const void *newdata;
+    lfs1_size_t newlen;
+};
+
+static int lfs1_dir_commit(lfs1_t *lfs1, lfs1_dir_t *dir,
+        const struct lfs1_region *regions, int count) {
+    // increment revision count
+    dir->d.rev += 1;
+
+    // keep pairs in order such that pair[0] is most recent
+    lfs1_pairswap(dir->pair);
+    for (int i = 0; i < count; i++) {
+        dir->d.size += regions[i].newlen - regions[i].oldlen;
+    }
+
+    const lfs1_block_t oldpair[2] = {dir->pair[0], dir->pair[1]};
+    bool relocated = false;
+
+    while (true) {
+        if (true) {
+            int err = lfs1_bd_erase(lfs1, dir->pair[0]);
+            if (err) {
+                if (err == LFS1_ERR_CORRUPT) {
+                    goto relocate;
+                }
+                return err;
+            }
+
+            uint32_t crc = 0xffffffff;
+            lfs1_dir_tole32(&dir->d);
+            lfs1_crc(&crc, &dir->d, sizeof(dir->d));
+            err = lfs1_bd_prog(lfs1, dir->pair[0], 0, &dir->d, sizeof(dir->d));
+            lfs1_dir_fromle32(&dir->d);
+            if (err) {
+                if (err == LFS1_ERR_CORRUPT) {
+                    goto relocate;
+                }
+                return err;
+            }
+
+            int i = 0;
+            lfs1_off_t oldoff = sizeof(dir->d);
+            lfs1_off_t newoff = sizeof(dir->d);
+            while (newoff < (0x7fffffff & dir->d.size)-4) {
+                if (i < count && regions[i].oldoff == oldoff) {
+                    lfs1_crc(&crc, regions[i].newdata, regions[i].newlen);
+                    err = lfs1_bd_prog(lfs1, dir->pair[0],
+                            newoff, regions[i].newdata, regions[i].newlen);
+                    if (err) {
+                        if (err == LFS1_ERR_CORRUPT) {
+                            goto relocate;
+                        }
+                        return err;
+                    }
+
+                    oldoff += regions[i].oldlen;
+                    newoff += regions[i].newlen;
+                    i += 1;
+                } else {
+                    uint8_t data;
+                    err = lfs1_bd_read(lfs1, oldpair[1], oldoff, &data, 1);
+                    if (err) {
+                        return err;
+                    }
+
+                    lfs1_crc(&crc, &data, 1);
+                    err = lfs1_bd_prog(lfs1, dir->pair[0], newoff, &data, 1);
+                    if (err) {
+                        if (err == LFS1_ERR_CORRUPT) {
+                            goto relocate;
+                        }
+                        return err;
+                    }
+
+                    oldoff += 1;
+                    newoff += 1;
+                }
+            }
+
+            crc = lfs1_tole32(crc);
+            err = lfs1_bd_prog(lfs1, dir->pair[0], newoff, &crc, 4);
+            crc = lfs1_fromle32(crc);
+            if (err) {
+                if (err == LFS1_ERR_CORRUPT) {
+                    goto relocate;
+                }
+                return err;
+            }
+
+            err = lfs1_bd_sync(lfs1);
+            if (err) {
+                if (err == LFS1_ERR_CORRUPT) {
+                    goto relocate;
+                }
+                return err;
+            }
+
+            // successful commit, check checksum to make sure
+            uint32_t ncrc = 0xffffffff;
+            err = lfs1_bd_crc(lfs1, dir->pair[0], 0,
+                    (0x7fffffff & dir->d.size)-4, &ncrc);
+            if (err) {
+                return err;
+            }
+
+            if (ncrc != crc) {
+                goto relocate;
+            }
+        }
+
+        break;
+relocate:
+        //commit was corrupted
+        LFS1_DEBUG("Bad block at %" PRIu32, dir->pair[0]);
+
+        // drop caches and prepare to relocate block
+        relocated = true;
+        lfs1_cache_drop(lfs1, &lfs1->pcache);
+
+        // can't relocate superblock, filesystem is now frozen
+        if (lfs1_paircmp(oldpair, (const lfs1_block_t[2]){0, 1}) == 0) {
+            LFS1_WARN("Superblock %" PRIu32 " has become unwritable",
+                    oldpair[0]);
+            return LFS1_ERR_CORRUPT;
+        }
+
+        // relocate half of pair
+        int err = lfs1_alloc(lfs1, &dir->pair[0]);
+        if (err) {
+            return err;
+        }
+    }
+
+    if (relocated) {
+        // update references if we relocated
+        LFS1_DEBUG("Relocating %" PRIu32 " %" PRIu32 " to %" PRIu32 " %" PRIu32,
+                oldpair[0], oldpair[1], dir->pair[0], dir->pair[1]);
+        int err = lfs1_relocate(lfs1, oldpair, dir->pair);
+        if (err) {
+            return err;
+        }
+    }
+
+    // shift over any directories that are affected
+    for (lfs1_dir_t *d = lfs1->dirs; d; d = d->next) {
+        if (lfs1_paircmp(d->pair, dir->pair) == 0) {
+            d->pair[0] = dir->pair[0];
+            d->pair[1] = dir->pair[1];
+        }
+    }
+
+    return 0;
+}
+
+static int lfs1_dir_update(lfs1_t *lfs1, lfs1_dir_t *dir,
+        lfs1_entry_t *entry, const void *data) {
+    lfs1_entry_tole32(&entry->d);
+    int err = lfs1_dir_commit(lfs1, dir, (struct lfs1_region[]){
+            {entry->off, sizeof(entry->d), &entry->d, sizeof(entry->d)},
+            {entry->off+sizeof(entry->d), entry->d.nlen, data, entry->d.nlen}
+        }, data ? 2 : 1);
+    lfs1_entry_fromle32(&entry->d);
+    return err;
+}
+
+static int lfs1_dir_append(lfs1_t *lfs1, lfs1_dir_t *dir,
+        lfs1_entry_t *entry, const void *data) {
+    // check if we fit, if top bit is set we do not and move on
+    while (true) {
+        if (dir->d.size + lfs1_entry_size(entry) <= lfs1->cfg->block_size) {
+            entry->off = dir->d.size - 4;
+
+            lfs1_entry_tole32(&entry->d);
+            int err = lfs1_dir_commit(lfs1, dir, (struct lfs1_region[]){
+                    {entry->off, 0, &entry->d, sizeof(entry->d)},
+                    {entry->off, 0, data, entry->d.nlen}
+                }, 2);
+            lfs1_entry_fromle32(&entry->d);
+            return err;
+        }
+
+        // we need to allocate a new dir block
+        if (!(0x80000000 & dir->d.size)) {
+            lfs1_dir_t olddir = *dir;
+            int err = lfs1_dir_alloc(lfs1, dir);
+            if (err) {
+                return err;
+            }
+
+            dir->d.tail[0] = olddir.d.tail[0];
+            dir->d.tail[1] = olddir.d.tail[1];
+            entry->off = dir->d.size - 4;
+            lfs1_entry_tole32(&entry->d);
+            err = lfs1_dir_commit(lfs1, dir, (struct lfs1_region[]){
+                    {entry->off, 0, &entry->d, sizeof(entry->d)},
+                    {entry->off, 0, data, entry->d.nlen}
+                }, 2);
+            lfs1_entry_fromle32(&entry->d);
+            if (err) {
+                return err;
+            }
+
+            olddir.d.size |= 0x80000000;
+            olddir.d.tail[0] = dir->pair[0];
+            olddir.d.tail[1] = dir->pair[1];
+            return lfs1_dir_commit(lfs1, &olddir, NULL, 0);
+        }
+
+        int err = lfs1_dir_fetch(lfs1, dir, dir->d.tail);
+        if (err) {
+            return err;
+        }
+    }
+}
+
+static int lfs1_dir_remove(lfs1_t *lfs1, lfs1_dir_t *dir, lfs1_entry_t *entry) {
+    // check if we should just drop the directory block
+    if ((dir->d.size & 0x7fffffff) == sizeof(dir->d)+4
+            + lfs1_entry_size(entry)) {
+        lfs1_dir_t pdir;
+        int res = lfs1_pred(lfs1, dir->pair, &pdir);
+        if (res < 0) {
+            return res;
+        }
+
+        if (pdir.d.size & 0x80000000) {
+            pdir.d.size &= dir->d.size | 0x7fffffff;
+            pdir.d.tail[0] = dir->d.tail[0];
+            pdir.d.tail[1] = dir->d.tail[1];
+            return lfs1_dir_commit(lfs1, &pdir, NULL, 0);
+        }
+    }
+
+    // shift out the entry
+    int err = lfs1_dir_commit(lfs1, dir, (struct lfs1_region[]){
+            {entry->off, lfs1_entry_size(entry), NULL, 0},
+        }, 1);
+    if (err) {
+        return err;
+    }
+
+    // shift over any files/directories that are affected
+    for (lfs1_file_t *f = lfs1->files; f; f = f->next) {
+        if (lfs1_paircmp(f->pair, dir->pair) == 0) {
+            if (f->poff == entry->off) {
+                f->pair[0] = 0xffffffff;
+                f->pair[1] = 0xffffffff;
+            } else if (f->poff > entry->off) {
+                f->poff -= lfs1_entry_size(entry);
+            }
+        }
+    }
+
+    for (lfs1_dir_t *d = lfs1->dirs; d; d = d->next) {
+        if (lfs1_paircmp(d->pair, dir->pair) == 0) {
+            if (d->off > entry->off) {
+                d->off -= lfs1_entry_size(entry);
+                d->pos -= lfs1_entry_size(entry);
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int lfs1_dir_next(lfs1_t *lfs1, lfs1_dir_t *dir, lfs1_entry_t *entry) {
+    while (dir->off + sizeof(entry->d) > (0x7fffffff & dir->d.size)-4) {
+        if (!(0x80000000 & dir->d.size)) {
+            entry->off = dir->off;
+            return LFS1_ERR_NOENT;
+        }
+
+        int err = lfs1_dir_fetch(lfs1, dir, dir->d.tail);
+        if (err) {
+            return err;
+        }
+
+        dir->off = sizeof(dir->d);
+        dir->pos += sizeof(dir->d) + 4;
+    }
+
+    int err = lfs1_bd_read(lfs1, dir->pair[0], dir->off,
+            &entry->d, sizeof(entry->d));
+    lfs1_entry_fromle32(&entry->d);
+    if (err) {
+        return err;
+    }
+
+    entry->off = dir->off;
+    dir->off += lfs1_entry_size(entry);
+    dir->pos += lfs1_entry_size(entry);
+    return 0;
+}
+
+static int lfs1_dir_find(lfs1_t *lfs1, lfs1_dir_t *dir,
+        lfs1_entry_t *entry, const char **path) {
+    const char *pathname = *path;
+    size_t pathlen;
+    entry->d.type = LFS1_TYPE_DIR;
+    entry->d.elen = sizeof(entry->d) - 4;
+    entry->d.alen = 0;
+    entry->d.nlen = 0;
+    entry->d.u.dir[0] = lfs1->root[0];
+    entry->d.u.dir[1] = lfs1->root[1];
+
+    while (true) {
+nextname:
+        // skip slashes
+        pathname += strspn(pathname, "/");
+        pathlen = strcspn(pathname, "/");
+
+        // skip '.' and root '..'
+        if ((pathlen == 1 && memcmp(pathname, ".", 1) == 0) ||
+            (pathlen == 2 && memcmp(pathname, "..", 2) == 0)) {
+            pathname += pathlen;
+            goto nextname;
+        }
+
+        // skip if matched by '..' in name
+        const char *suffix = pathname + pathlen;
+        size_t sufflen;
+        int depth = 1;
+        while (true) {
+            suffix += strspn(suffix, "/");
+            sufflen = strcspn(suffix, "/");
+            if (sufflen == 0) {
+                break;
+            }
+
+            if (sufflen == 2 && memcmp(suffix, "..", 2) == 0) {
+                depth -= 1;
+                if (depth == 0) {
+                    pathname = suffix + sufflen;
+                    goto nextname;
+                }
+            } else {
+                depth += 1;
+            }
+
+            suffix += sufflen;
+        }
+
+        // found path
+        if (pathname[0] == '\0') {
+            return 0;
+        }
+
+        // update what we've found
+        *path = pathname;
+
+        // continue on if we hit a directory
+        if (entry->d.type != LFS1_TYPE_DIR) {
+            return LFS1_ERR_NOTDIR;
+        }
+
+        int err = lfs1_dir_fetch(lfs1, dir, entry->d.u.dir);
+        if (err) {
+            return err;
+        }
+
+        // find entry matching name
+        while (true) {
+            err = lfs1_dir_next(lfs1, dir, entry);
+            if (err) {
+                return err;
+            }
+
+            if (((0x7f & entry->d.type) != LFS1_TYPE_REG &&
+                 (0x7f & entry->d.type) != LFS1_TYPE_DIR) ||
+                entry->d.nlen != pathlen) {
+                continue;
+            }
+
+            int res = lfs1_bd_cmp(lfs1, dir->pair[0],
+                    entry->off + 4+entry->d.elen+entry->d.alen,
+                    pathname, pathlen);
+            if (res < 0) {
+                return res;
+            }
+
+            // found match
+            if (res) {
+                break;
+            }
+        }
+
+        // check that entry has not been moved
+        if (!lfs1->moving && entry->d.type & 0x80) {
+            int moved = lfs1_moved(lfs1, &entry->d.u);
+            if (moved < 0 || moved) {
+                return (moved < 0) ? moved : LFS1_ERR_NOENT;
+            }
+
+            entry->d.type &= ~0x80;
+        }
+
+        // to next name
+        pathname += pathlen;
+    }
+}
+
+
+/// Top level directory operations ///
+int lfs1_mkdir(lfs1_t *lfs1, const char *path) {
+    // deorphan if we haven't yet, needed at most once after poweron
+    if (!lfs1->deorphaned) {
+        int err = lfs1_deorphan(lfs1);
+        if (err) {
+            return err;
+        }
+    }
+
+    // fetch parent directory
+    lfs1_dir_t cwd;
+    lfs1_entry_t entry;
+    int err = lfs1_dir_find(lfs1, &cwd, &entry, &path);
+    if (err != LFS1_ERR_NOENT || strchr(path, '/') != NULL) {
+        return err ? err : LFS1_ERR_EXIST;
+    }
+
+    // build up new directory
+    lfs1_alloc_ack(lfs1);
+
+    lfs1_dir_t dir;
+    err = lfs1_dir_alloc(lfs1, &dir);
+    if (err) {
+        return err;
+    }
+    dir.d.tail[0] = cwd.d.tail[0];
+    dir.d.tail[1] = cwd.d.tail[1];
+
+    err = lfs1_dir_commit(lfs1, &dir, NULL, 0);
+    if (err) {
+        return err;
+    }
+
+    entry.d.type = LFS1_TYPE_DIR;
+    entry.d.elen = sizeof(entry.d) - 4;
+    entry.d.alen = 0;
+    entry.d.nlen = strlen(path);
+    entry.d.u.dir[0] = dir.pair[0];
+    entry.d.u.dir[1] = dir.pair[1];
+
+    cwd.d.tail[0] = dir.pair[0];
+    cwd.d.tail[1] = dir.pair[1];
+
+    err = lfs1_dir_append(lfs1, &cwd, &entry, path);
+    if (err) {
+        return err;
+    }
+
+    lfs1_alloc_ack(lfs1);
+    return 0;
+}
+
+int lfs1_dir_open(lfs1_t *lfs1, lfs1_dir_t *dir, const char *path) {
+    dir->pair[0] = lfs1->root[0];
+    dir->pair[1] = lfs1->root[1];
+
+    lfs1_entry_t entry;
+    int err = lfs1_dir_find(lfs1, dir, &entry, &path);
+    if (err) {
+        return err;
+    } else if (entry.d.type != LFS1_TYPE_DIR) {
+        return LFS1_ERR_NOTDIR;
+    }
+
+    err = lfs1_dir_fetch(lfs1, dir, entry.d.u.dir);
+    if (err) {
+        return err;
+    }
+
+    // setup head dir
+    // special offset for '.' and '..'
+    dir->head[0] = dir->pair[0];
+    dir->head[1] = dir->pair[1];
+    dir->pos = sizeof(dir->d) - 2;
+    dir->off = sizeof(dir->d);
+
+    // add to list of directories
+    dir->next = lfs1->dirs;
+    lfs1->dirs = dir;
+
+    return 0;
+}
+
+int lfs1_dir_close(lfs1_t *lfs1, lfs1_dir_t *dir) {
+    // remove from list of directories
+    for (lfs1_dir_t **p = &lfs1->dirs; *p; p = &(*p)->next) {
+        if (*p == dir) {
+            *p = dir->next;
+            break;
+        }
+    }
+
+    return 0;
+}
+
+int lfs1_dir_read(lfs1_t *lfs1, lfs1_dir_t *dir, struct lfs1_info *info) {
+    memset(info, 0, sizeof(*info));
+
+    // special offset for '.' and '..'
+    if (dir->pos == sizeof(dir->d) - 2) {
+        info->type = LFS1_TYPE_DIR;
+        strcpy(info->name, ".");
+        dir->pos += 1;
+        return 1;
+    } else if (dir->pos == sizeof(dir->d) - 1) {
+        info->type = LFS1_TYPE_DIR;
+        strcpy(info->name, "..");
+        dir->pos += 1;
+        return 1;
+    }
+
+    lfs1_entry_t entry;
+    while (true) {
+        int err = lfs1_dir_next(lfs1, dir, &entry);
+        if (err) {
+            return (err == LFS1_ERR_NOENT) ? 0 : err;
+        }
+
+        if ((0x7f & entry.d.type) != LFS1_TYPE_REG &&
+            (0x7f & entry.d.type) != LFS1_TYPE_DIR) {
+            continue;
+        }
+
+        // check that entry has not been moved
+        if (entry.d.type & 0x80) {
+            int moved = lfs1_moved(lfs1, &entry.d.u);
+            if (moved < 0) {
+                return moved;
+            }
+
+            if (moved) {
+                continue;
+            }
+
+            entry.d.type &= ~0x80;
+        }
+
+        break;
+    }
+
+    info->type = entry.d.type;
+    if (info->type == LFS1_TYPE_REG) {
+        info->size = entry.d.u.file.size;
+    }
+
+    int err = lfs1_bd_read(lfs1, dir->pair[0],
+            entry.off + 4+entry.d.elen+entry.d.alen,
+            info->name, entry.d.nlen);
+    if (err) {
+        return err;
+    }
+
+    return 1;
+}
+
+int lfs1_dir_seek(lfs1_t *lfs1, lfs1_dir_t *dir, lfs1_off_t off) {
+    // simply walk from head dir
+    int err = lfs1_dir_rewind(lfs1, dir);
+    if (err) {
+        return err;
+    }
+    dir->pos = off;
+
+    while (off > (0x7fffffff & dir->d.size)) {
+        off -= 0x7fffffff & dir->d.size;
+        if (!(0x80000000 & dir->d.size)) {
+            return LFS1_ERR_INVAL;
+        }
+
+        err = lfs1_dir_fetch(lfs1, dir, dir->d.tail);
+        if (err) {
+            return err;
+        }
+    }
+
+    dir->off = off;
+    return 0;
+}
+
+lfs1_soff_t lfs1_dir_tell(lfs1_t *lfs1, lfs1_dir_t *dir) {
+    (void)lfs1;
+    return dir->pos;
+}
+
+int lfs1_dir_rewind(lfs1_t *lfs1, lfs1_dir_t *dir) {
+    // reload the head dir
+    int err = lfs1_dir_fetch(lfs1, dir, dir->head);
+    if (err) {
+        return err;
+    }
+
+    dir->pair[0] = dir->head[0];
+    dir->pair[1] = dir->head[1];
+    dir->pos = sizeof(dir->d) - 2;
+    dir->off = sizeof(dir->d);
+    return 0;
+}
+
+
+/// File index list operations ///
+static int lfs1_ctz_index(lfs1_t *lfs1, lfs1_off_t *off) {
+    lfs1_off_t size = *off;
+    lfs1_off_t b = lfs1->cfg->block_size - 2*4;
+    lfs1_off_t i = size / b;
+    if (i == 0) {
+        return 0;
+    }
+
+    i = (size - 4*(lfs1_popc(i-1)+2)) / b;
+    *off = size - b*i - 4*lfs1_popc(i);
+    return i;
+}
+
+static int lfs1_ctz_find(lfs1_t *lfs1,
+        lfs1_cache_t *rcache, const lfs1_cache_t *pcache,
+        lfs1_block_t head, lfs1_size_t size,
+        lfs1_size_t pos, lfs1_block_t *block, lfs1_off_t *off) {
+    if (size == 0) {
+        *block = 0xffffffff;
+        *off = 0;
+        return 0;
+    }
+
+    lfs1_off_t current = lfs1_ctz_index(lfs1, &(lfs1_off_t){size-1});
+    lfs1_off_t target = lfs1_ctz_index(lfs1, &pos);
+
+    while (current > target) {
+        lfs1_size_t skip = lfs1_min(
+                lfs1_npw2(current-target+1) - 1,
+                lfs1_ctz(current));
+
+        int err = lfs1_cache_read(lfs1, rcache, pcache, head, 4*skip, &head, 4);
+        head = lfs1_fromle32(head);
+        if (err) {
+            return err;
+        }
+
+        LFS1_ASSERT(head >= 2 && head <= lfs1->cfg->block_count);
+        current -= 1 << skip;
+    }
+
+    *block = head;
+    *off = pos;
+    return 0;
+}
+
+static int lfs1_ctz_extend(lfs1_t *lfs1,
+        lfs1_cache_t *rcache, lfs1_cache_t *pcache,
+        lfs1_block_t head, lfs1_size_t size,
+        lfs1_block_t *block, lfs1_off_t *off) {
+    while (true) {
+        // go ahead and grab a block
+        lfs1_block_t nblock;
+        int err = lfs1_alloc(lfs1, &nblock);
+        if (err) {
+            return err;
+        }
+        LFS1_ASSERT(nblock >= 2 && nblock <= lfs1->cfg->block_count);
+
+        if (true) {
+            err = lfs1_bd_erase(lfs1, nblock);
+            if (err) {
+                if (err == LFS1_ERR_CORRUPT) {
+                    goto relocate;
+                }
+                return err;
+            }
+
+            if (size == 0) {
+                *block = nblock;
+                *off = 0;
+                return 0;
+            }
+
+            size -= 1;
+            lfs1_off_t index = lfs1_ctz_index(lfs1, &size);
+            size += 1;
+
+            // just copy out the last block if it is incomplete
+            if (size != lfs1->cfg->block_size) {
+                for (lfs1_off_t i = 0; i < size; i++) {
+                    uint8_t data;
+                    err = lfs1_cache_read(lfs1, rcache, NULL,
+                            head, i, &data, 1);
+                    if (err) {
+                        return err;
+                    }
+
+                    err = lfs1_cache_prog(lfs1, pcache, rcache,
+                            nblock, i, &data, 1);
+                    if (err) {
+                        if (err == LFS1_ERR_CORRUPT) {
+                            goto relocate;
+                        }
+                        return err;
+                    }
+                }
+
+                *block = nblock;
+                *off = size;
+                return 0;
+            }
+
+            // append block
+            index += 1;
+            lfs1_size_t skips = lfs1_ctz(index) + 1;
+
+            for (lfs1_off_t i = 0; i < skips; i++) {
+                head = lfs1_tole32(head);
+                err = lfs1_cache_prog(lfs1, pcache, rcache,
+                        nblock, 4*i, &head, 4);
+                head = lfs1_fromle32(head);
+                if (err) {
+                    if (err == LFS1_ERR_CORRUPT) {
+                        goto relocate;
+                    }
+                    return err;
+                }
+
+                if (i != skips-1) {
+                    err = lfs1_cache_read(lfs1, rcache, NULL,
+                            head, 4*i, &head, 4);
+                    head = lfs1_fromle32(head);
+                    if (err) {
+                        return err;
+                    }
+                }
+
+                LFS1_ASSERT(head >= 2 && head <= lfs1->cfg->block_count);
+            }
+
+            *block = nblock;
+            *off = 4*skips;
+            return 0;
+        }
+
+relocate:
+        LFS1_DEBUG("Bad block at %" PRIu32, nblock);
+
+        // just clear cache and try a new block
+        lfs1_cache_drop(lfs1, &lfs1->pcache);
+    }
+}
+
+static int lfs1_ctz_traverse(lfs1_t *lfs1,
+        lfs1_cache_t *rcache, const lfs1_cache_t *pcache,
+        lfs1_block_t head, lfs1_size_t size,
+        int (*cb)(void*, lfs1_block_t), void *data) {
+    if (size == 0) {
+        return 0;
+    }
+
+    lfs1_off_t index = lfs1_ctz_index(lfs1, &(lfs1_off_t){size-1});
+
+    while (true) {
+        int err = cb(data, head);
+        if (err) {
+            return err;
+        }
+
+        if (index == 0) {
+            return 0;
+        }
+
+        lfs1_block_t heads[2];
+        int count = 2 - (index & 1);
+        err = lfs1_cache_read(lfs1, rcache, pcache, head, 0, &heads, count*4);
+        heads[0] = lfs1_fromle32(heads[0]);
+        heads[1] = lfs1_fromle32(heads[1]);
+        if (err) {
+            return err;
+        }
+
+        for (int i = 0; i < count-1; i++) {
+            err = cb(data, heads[i]);
+            if (err) {
+                return err;
+            }
+        }
+
+        head = heads[count-1];
+        index -= count;
+    }
+}
+
+
+/// Top level file operations ///
+int lfs1_file_opencfg(lfs1_t *lfs1, lfs1_file_t *file,
+        const char *path, int flags,
+        const struct lfs1_file_config *cfg) {
+    // deorphan if we haven't yet, needed at most once after poweron
+    if ((flags & 3) != LFS1_O_RDONLY && !lfs1->deorphaned) {
+        int err = lfs1_deorphan(lfs1);
+        if (err) {
+            return err;
+        }
+    }
+
+    // allocate entry for file if it doesn't exist
+    lfs1_dir_t cwd;
+    lfs1_entry_t entry;
+    int err = lfs1_dir_find(lfs1, &cwd, &entry, &path);
+    if (err && (err != LFS1_ERR_NOENT || strchr(path, '/') != NULL)) {
+        return err;
+    }
+
+    if (err == LFS1_ERR_NOENT) {
+        if (!(flags & LFS1_O_CREAT)) {
+            return LFS1_ERR_NOENT;
+        }
+
+        // create entry to remember name
+        entry.d.type = LFS1_TYPE_REG;
+        entry.d.elen = sizeof(entry.d) - 4;
+        entry.d.alen = 0;
+        entry.d.nlen = strlen(path);
+        entry.d.u.file.head = 0xffffffff;
+        entry.d.u.file.size = 0;
+        err = lfs1_dir_append(lfs1, &cwd, &entry, path);
+        if (err) {
+            return err;
+        }
+    } else if (entry.d.type == LFS1_TYPE_DIR) {
+        return LFS1_ERR_ISDIR;
+    } else if (flags & LFS1_O_EXCL) {
+        return LFS1_ERR_EXIST;
+    }
+
+    // setup file struct
+    file->cfg = cfg;
+    file->pair[0] = cwd.pair[0];
+    file->pair[1] = cwd.pair[1];
+    file->poff = entry.off;
+    file->head = entry.d.u.file.head;
+    file->size = entry.d.u.file.size;
+    file->flags = flags;
+    file->pos = 0;
+
+    if (flags & LFS1_O_TRUNC) {
+        if (file->size != 0) {
+            file->flags |= LFS1_F_DIRTY;
+        }
+        file->head = 0xffffffff;
+        file->size = 0;
+    }
+
+    // allocate buffer if needed
+    file->cache.block = 0xffffffff;
+    if (file->cfg && file->cfg->buffer) {
+        file->cache.buffer = file->cfg->buffer;
+    } else if (lfs1->cfg->file_buffer) {
+        if (lfs1->files) {
+            // already in use
+            return LFS1_ERR_NOMEM;
+        }
+        file->cache.buffer = lfs1->cfg->file_buffer;
+    } else if ((file->flags & 3) == LFS1_O_RDONLY) {
+        file->cache.buffer = lfs1_malloc(lfs1->cfg->read_size);
+        if (!file->cache.buffer) {
+            return LFS1_ERR_NOMEM;
+        }
+    } else {
+        file->cache.buffer = lfs1_malloc(lfs1->cfg->prog_size);
+        if (!file->cache.buffer) {
+            return LFS1_ERR_NOMEM;
+        }
+    }
+
+    // zero to avoid information leak
+    lfs1_cache_drop(lfs1, &file->cache);
+    if ((file->flags & 3) != LFS1_O_RDONLY) {
+        lfs1_cache_zero(lfs1, &file->cache);
+    }
+
+    // add to list of files
+    file->next = lfs1->files;
+    lfs1->files = file;
+
+    return 0;
+}
+
+int lfs1_file_open(lfs1_t *lfs1, lfs1_file_t *file,
+        const char *path, int flags) {
+    return lfs1_file_opencfg(lfs1, file, path, flags, NULL);
+}
+
+int lfs1_file_close(lfs1_t *lfs1, lfs1_file_t *file) {
+    int err = lfs1_file_sync(lfs1, file);
+
+    // remove from list of files
+    for (lfs1_file_t **p = &lfs1->files; *p; p = &(*p)->next) {
+        if (*p == file) {
+            *p = file->next;
+            break;
+        }
+    }
+
+    // clean up memory
+    if (!(file->cfg && file->cfg->buffer) && !lfs1->cfg->file_buffer) {
+        lfs1_free(file->cache.buffer);
+    }
+
+    return err;
+}
+
+static int lfs1_file_relocate(lfs1_t *lfs1, lfs1_file_t *file) {
+relocate:
+    LFS1_DEBUG("Bad block at %" PRIu32, file->block);
+
+    // just relocate what exists into new block
+    lfs1_block_t nblock;
+    int err = lfs1_alloc(lfs1, &nblock);
+    if (err) {
+        return err;
+    }
+
+    err = lfs1_bd_erase(lfs1, nblock);
+    if (err) {
+        if (err == LFS1_ERR_CORRUPT) {
+            goto relocate;
+        }
+        return err;
+    }
+
+    // either read from dirty cache or disk
+    for (lfs1_off_t i = 0; i < file->off; i++) {
+        uint8_t data;
+        err = lfs1_cache_read(lfs1, &lfs1->rcache, &file->cache,
+                file->block, i, &data, 1);
+        if (err) {
+            return err;
+        }
+
+        err = lfs1_cache_prog(lfs1, &lfs1->pcache, &lfs1->rcache,
+                nblock, i, &data, 1);
+        if (err) {
+            if (err == LFS1_ERR_CORRUPT) {
+                goto relocate;
+            }
+            return err;
+        }
+    }
+
+    // copy over new state of file
+    memcpy(file->cache.buffer, lfs1->pcache.buffer, lfs1->cfg->prog_size);
+    file->cache.block = lfs1->pcache.block;
+    file->cache.off = lfs1->pcache.off;
+    lfs1_cache_zero(lfs1, &lfs1->pcache);
+
+    file->block = nblock;
+    return 0;
+}
+
+static int lfs1_file_flush(lfs1_t *lfs1, lfs1_file_t *file) {
+    if (file->flags & LFS1_F_READING) {
+        // just drop read cache
+        lfs1_cache_drop(lfs1, &file->cache);
+        file->flags &= ~LFS1_F_READING;
+    }
+
+    if (file->flags & LFS1_F_WRITING) {
+        lfs1_off_t pos = file->pos;
+
+        // copy over anything after current branch
+        lfs1_file_t orig = {
+            .head = file->head,
+            .size = file->size,
+            .flags = LFS1_O_RDONLY,
+            .pos = file->pos,
+            .cache = lfs1->rcache,
+        };
+        lfs1_cache_drop(lfs1, &lfs1->rcache);
+
+        while (file->pos < file->size) {
+            // copy over a byte at a time, leave it up to caching
+            // to make this efficient
+            uint8_t data;
+            lfs1_ssize_t res = lfs1_file_read(lfs1, &orig, &data, 1);
+            if (res < 0) {
+                return res;
+            }
+
+            res = lfs1_file_write(lfs1, file, &data, 1);
+            if (res < 0) {
+                return res;
+            }
+
+            // keep our reference to the rcache in sync
+            if (lfs1->rcache.block != 0xffffffff) {
+                lfs1_cache_drop(lfs1, &orig.cache);
+                lfs1_cache_drop(lfs1, &lfs1->rcache);
+            }
+        }
+
+        // write out what we have
+        while (true) {
+            int err = lfs1_cache_flush(lfs1, &file->cache, &lfs1->rcache);
+            if (err) {
+                if (err == LFS1_ERR_CORRUPT) {
+                    goto relocate;
+                }
+                return err;
+            }
+
+            break;
+relocate:
+            err = lfs1_file_relocate(lfs1, file);
+            if (err) {
+                return err;
+            }
+        }
+
+        // actual file updates
+        file->head = file->block;
+        file->size = file->pos;
+        file->flags &= ~LFS1_F_WRITING;
+        file->flags |= LFS1_F_DIRTY;
+
+        file->pos = pos;
+    }
+
+    return 0;
+}
+
+int lfs1_file_sync(lfs1_t *lfs1, lfs1_file_t *file) {
+    int err = lfs1_file_flush(lfs1, file);
+    if (err) {
+        return err;
+    }
+
+    if ((file->flags & LFS1_F_DIRTY) &&
+            !(file->flags & LFS1_F_ERRED) &&
+            !lfs1_pairisnull(file->pair)) {
+        // update dir entry
+        lfs1_dir_t cwd;
+        err = lfs1_dir_fetch(lfs1, &cwd, file->pair);
+        if (err) {
+            return err;
+        }
+
+        lfs1_entry_t entry = {.off = file->poff};
+        err = lfs1_bd_read(lfs1, cwd.pair[0], entry.off,
+                &entry.d, sizeof(entry.d));
+        lfs1_entry_fromle32(&entry.d);
+        if (err) {
+            return err;
+        }
+
+        LFS1_ASSERT(entry.d.type == LFS1_TYPE_REG);
+        entry.d.u.file.head = file->head;
+        entry.d.u.file.size = file->size;
+
+        err = lfs1_dir_update(lfs1, &cwd, &entry, NULL);
+        if (err) {
+            return err;
+        }
+
+        file->flags &= ~LFS1_F_DIRTY;
+    }
+
+    return 0;
+}
+
+lfs1_ssize_t lfs1_file_read(lfs1_t *lfs1, lfs1_file_t *file,
+        void *buffer, lfs1_size_t size) {
+    uint8_t *data = buffer;
+    lfs1_size_t nsize = size;
+
+    if ((file->flags & 3) == LFS1_O_WRONLY) {
+        return LFS1_ERR_BADF;
+    }
+
+    if (file->flags & LFS1_F_WRITING) {
+        // flush out any writes
+        int err = lfs1_file_flush(lfs1, file);
+        if (err) {
+            return err;
+        }
+    }
+
+    if (file->pos >= file->size) {
+        // eof if past end
+        return 0;
+    }
+
+    size = lfs1_min(size, file->size - file->pos);
+    nsize = size;
+
+    while (nsize > 0) {
+        // check if we need a new block
+        if (!(file->flags & LFS1_F_READING) ||
+                file->off == lfs1->cfg->block_size) {
+            int err = lfs1_ctz_find(lfs1, &file->cache, NULL,
+                    file->head, file->size,
+                    file->pos, &file->block, &file->off);
+            if (err) {
+                return err;
+            }
+
+            file->flags |= LFS1_F_READING;
+        }
+
+        // read as much as we can in current block
+        lfs1_size_t diff = lfs1_min(nsize, lfs1->cfg->block_size - file->off);
+        int err = lfs1_cache_read(lfs1, &file->cache, NULL,
+                file->block, file->off, data, diff);
+        if (err) {
+            return err;
+        }
+
+        file->pos += diff;
+        file->off += diff;
+        data += diff;
+        nsize -= diff;
+    }
+
+    return size;
+}
+
+lfs1_ssize_t lfs1_file_write(lfs1_t *lfs1, lfs1_file_t *file,
+        const void *buffer, lfs1_size_t size) {
+    const uint8_t *data = buffer;
+    lfs1_size_t nsize = size;
+
+    if ((file->flags & 3) == LFS1_O_RDONLY) {
+        return LFS1_ERR_BADF;
+    }
+
+    if (file->flags & LFS1_F_READING) {
+        // drop any reads
+        int err = lfs1_file_flush(lfs1, file);
+        if (err) {
+            return err;
+        }
+    }
+
+    if ((file->flags & LFS1_O_APPEND) && file->pos < file->size) {
+        file->pos = file->size;
+    }
+
+    if (file->pos + size > LFS1_FILE_MAX) {
+        // larger than file limit?
+        return LFS1_ERR_FBIG;
+    }
+
+    if (!(file->flags & LFS1_F_WRITING) && file->pos > file->size) {
+        // fill with zeros
+        lfs1_off_t pos = file->pos;
+        file->pos = file->size;
+
+        while (file->pos < pos) {
+            lfs1_ssize_t res = lfs1_file_write(lfs1, file, &(uint8_t){0}, 1);
+            if (res < 0) {
+                return res;
+            }
+        }
+    }
+
+    while (nsize > 0) {
+        // check if we need a new block
+        if (!(file->flags & LFS1_F_WRITING) ||
+                file->off == lfs1->cfg->block_size) {
+            if (!(file->flags & LFS1_F_WRITING) && file->pos > 0) {
+                // find out which block we're extending from
+                int err = lfs1_ctz_find(lfs1, &file->cache, NULL,
+                        file->head, file->size,
+                        file->pos-1, &file->block, &file->off);
+                if (err) {
+                    file->flags |= LFS1_F_ERRED;
+                    return err;
+                }
+
+                // mark cache as dirty since we may have read data into it
+                lfs1_cache_zero(lfs1, &file->cache);
+            }
+
+            // extend file with new blocks
+            lfs1_alloc_ack(lfs1);
+            int err = lfs1_ctz_extend(lfs1, &lfs1->rcache, &file->cache,
+                    file->block, file->pos,
+                    &file->block, &file->off);
+            if (err) {
+                file->flags |= LFS1_F_ERRED;
+                return err;
+            }
+
+            file->flags |= LFS1_F_WRITING;
+        }
+
+        // program as much as we can in current block
+        lfs1_size_t diff = lfs1_min(nsize, lfs1->cfg->block_size - file->off);
+        while (true) {
+            int err = lfs1_cache_prog(lfs1, &file->cache, &lfs1->rcache,
+                    file->block, file->off, data, diff);
+            if (err) {
+                if (err == LFS1_ERR_CORRUPT) {
+                    goto relocate;
+                }
+                file->flags |= LFS1_F_ERRED;
+                return err;
+            }
+
+            break;
+relocate:
+            err = lfs1_file_relocate(lfs1, file);
+            if (err) {
+                file->flags |= LFS1_F_ERRED;
+                return err;
+            }
+        }
+
+        file->pos += diff;
+        file->off += diff;
+        data += diff;
+        nsize -= diff;
+
+        lfs1_alloc_ack(lfs1);
+    }
+
+    file->flags &= ~LFS1_F_ERRED;
+    return size;
+}
+
+lfs1_soff_t lfs1_file_seek(lfs1_t *lfs1, lfs1_file_t *file,
+        lfs1_soff_t off, int whence) {
+    // write out everything beforehand, may be noop if rdonly
+    int err = lfs1_file_flush(lfs1, file);
+    if (err) {
+        return err;
+    }
+
+    // find new pos
+    lfs1_soff_t npos = file->pos;
+    if (whence == LFS1_SEEK_SET) {
+        npos = off;
+    } else if (whence == LFS1_SEEK_CUR) {
+        npos = file->pos + off;
+    } else if (whence == LFS1_SEEK_END) {
+        npos = file->size + off;
+    }
+
+    if (npos < 0 || npos > LFS1_FILE_MAX) {
+        // file position out of range
+        return LFS1_ERR_INVAL;
+    }
+
+    // update pos
+    file->pos = npos;
+    return npos;
+}
+
+int lfs1_file_truncate(lfs1_t *lfs1, lfs1_file_t *file, lfs1_off_t size) {
+    if ((file->flags & 3) == LFS1_O_RDONLY) {
+        return LFS1_ERR_BADF;
+    }
+
+    lfs1_off_t oldsize = lfs1_file_size(lfs1, file);
+    if (size < oldsize) {
+        // need to flush since directly changing metadata
+        int err = lfs1_file_flush(lfs1, file);
+        if (err) {
+            return err;
+        }
+
+        // lookup new head in ctz skip list
+        err = lfs1_ctz_find(lfs1, &file->cache, NULL,
+                file->head, file->size,
+                size, &file->head, &(lfs1_off_t){0});
+        if (err) {
+            return err;
+        }
+
+        file->size = size;
+        file->flags |= LFS1_F_DIRTY;
+    } else if (size > oldsize) {
+        lfs1_off_t pos = file->pos;
+
+        // flush+seek if not already at end
+        if (file->pos != oldsize) {
+            int err = lfs1_file_seek(lfs1, file, 0, LFS1_SEEK_END);
+            if (err < 0) {
+                return err;
+            }
+        }
+
+        // fill with zeros
+        while (file->pos < size) {
+            lfs1_ssize_t res = lfs1_file_write(lfs1, file, &(uint8_t){0}, 1);
+            if (res < 0) {
+                return res;
+            }
+        }
+
+        // restore pos
+        int err = lfs1_file_seek(lfs1, file, pos, LFS1_SEEK_SET);
+        if (err < 0) {
+            return err;
+        }
+    }
+
+    return 0;
+}
+
+lfs1_soff_t lfs1_file_tell(lfs1_t *lfs1, lfs1_file_t *file) {
+    (void)lfs1;
+    return file->pos;
+}
+
+int lfs1_file_rewind(lfs1_t *lfs1, lfs1_file_t *file) {
+    lfs1_soff_t res = lfs1_file_seek(lfs1, file, 0, LFS1_SEEK_SET);
+    if (res < 0) {
+        return res;
+    }
+
+    return 0;
+}
+
+lfs1_soff_t lfs1_file_size(lfs1_t *lfs1, lfs1_file_t *file) {
+    (void)lfs1;
+    if (file->flags & LFS1_F_WRITING) {
+        return lfs1_max(file->pos, file->size);
+    } else {
+        return file->size;
+    }
+}
+
+
+/// General fs operations ///
+int lfs1_stat(lfs1_t *lfs1, const char *path, struct lfs1_info *info) {
+    lfs1_dir_t cwd;
+    lfs1_entry_t entry;
+    int err = lfs1_dir_find(lfs1, &cwd, &entry, &path);
+    if (err) {
+        return err;
+    }
+
+    memset(info, 0, sizeof(*info));
+    info->type = entry.d.type;
+    if (info->type == LFS1_TYPE_REG) {
+        info->size = entry.d.u.file.size;
+    }
+
+    if (lfs1_paircmp(entry.d.u.dir, lfs1->root) == 0) {
+        strcpy(info->name, "/");
+    } else {
+        err = lfs1_bd_read(lfs1, cwd.pair[0],
+                entry.off + 4+entry.d.elen+entry.d.alen,
+                info->name, entry.d.nlen);
+        if (err) {
+            return err;
+        }
+    }
+
+    return 0;
+}
+
+int lfs1_remove(lfs1_t *lfs1, const char *path) {
+    // deorphan if we haven't yet, needed at most once after poweron
+    if (!lfs1->deorphaned) {
+        int err = lfs1_deorphan(lfs1);
+        if (err) {
+            return err;
+        }
+    }
+
+    lfs1_dir_t cwd;
+    lfs1_entry_t entry;
+    int err = lfs1_dir_find(lfs1, &cwd, &entry, &path);
+    if (err) {
+        return err;
+    }
+
+    lfs1_dir_t dir;
+    if (entry.d.type == LFS1_TYPE_DIR) {
+        // must be empty before removal, checking size
+        // without masking top bit checks for any case where
+        // dir is not empty
+        err = lfs1_dir_fetch(lfs1, &dir, entry.d.u.dir);
+        if (err) {
+            return err;
+        } else if (dir.d.size != sizeof(dir.d)+4) {
+            return LFS1_ERR_NOTEMPTY;
+        }
+    }
+
+    // remove the entry
+    err = lfs1_dir_remove(lfs1, &cwd, &entry);
+    if (err) {
+        return err;
+    }
+
+    // if we were a directory, find pred, replace tail
+    if (entry.d.type == LFS1_TYPE_DIR) {
+        int res = lfs1_pred(lfs1, dir.pair, &cwd);
+        if (res < 0) {
+            return res;
+        }
+
+        LFS1_ASSERT(res); // must have pred
+        cwd.d.tail[0] = dir.d.tail[0];
+        cwd.d.tail[1] = dir.d.tail[1];
+
+        err = lfs1_dir_commit(lfs1, &cwd, NULL, 0);
+        if (err) {
+            return err;
+        }
+    }
+
+    return 0;
+}
+
+int lfs1_rename(lfs1_t *lfs1, const char *oldpath, const char *newpath) {
+    // deorphan if we haven't yet, needed at most once after poweron
+    if (!lfs1->deorphaned) {
+        int err = lfs1_deorphan(lfs1);
+        if (err) {
+            return err;
+        }
+    }
+
+    // find old entry
+    lfs1_dir_t oldcwd;
+    lfs1_entry_t oldentry;
+    int err = lfs1_dir_find(lfs1, &oldcwd, &oldentry, &(const char *){oldpath});
+    if (err) {
+        return err;
+    }
+
+    // mark as moving
+    oldentry.d.type |= 0x80;
+    err = lfs1_dir_update(lfs1, &oldcwd, &oldentry, NULL);
+    if (err) {
+        return err;
+    }
+
+    // allocate new entry
+    lfs1_dir_t newcwd;
+    lfs1_entry_t preventry;
+    err = lfs1_dir_find(lfs1, &newcwd, &preventry, &newpath);
+    if (err && (err != LFS1_ERR_NOENT || strchr(newpath, '/') != NULL)) {
+        return err;
+    }
+
+    // must have same type
+    bool prevexists = (err != LFS1_ERR_NOENT);
+    if (prevexists && preventry.d.type != (0x7f & oldentry.d.type)) {
+        return LFS1_ERR_ISDIR;
+    }
+
+    lfs1_dir_t dir;
+    if (prevexists && preventry.d.type == LFS1_TYPE_DIR) {
+        // must be empty before removal, checking size
+        // without masking top bit checks for any case where
+        // dir is not empty
+        err = lfs1_dir_fetch(lfs1, &dir, preventry.d.u.dir);
+        if (err) {
+            return err;
+        } else if (dir.d.size != sizeof(dir.d)+4) {
+            return LFS1_ERR_NOTEMPTY;
+        }
+    }
+
+    // move to new location
+    lfs1_entry_t newentry = preventry;
+    newentry.d = oldentry.d;
+    newentry.d.type &= ~0x80;
+    newentry.d.nlen = strlen(newpath);
+
+    if (prevexists) {
+        err = lfs1_dir_update(lfs1, &newcwd, &newentry, newpath);
+        if (err) {
+            return err;
+        }
+    } else {
+        err = lfs1_dir_append(lfs1, &newcwd, &newentry, newpath);
+        if (err) {
+            return err;
+        }
+    }
+
+    // fetch old pair again in case dir block changed
+    lfs1->moving = true;
+    err = lfs1_dir_find(lfs1, &oldcwd, &oldentry, &oldpath);
+    if (err) {
+        return err;
+    }
+    lfs1->moving = false;
+
+    // remove old entry
+    err = lfs1_dir_remove(lfs1, &oldcwd, &oldentry);
+    if (err) {
+        return err;
+    }
+
+    // if we were a directory, find pred, replace tail
+    if (prevexists && preventry.d.type == LFS1_TYPE_DIR) {
+        int res = lfs1_pred(lfs1, dir.pair, &newcwd);
+        if (res < 0) {
+            return res;
+        }
+
+        LFS1_ASSERT(res); // must have pred
+        newcwd.d.tail[0] = dir.d.tail[0];
+        newcwd.d.tail[1] = dir.d.tail[1];
+
+        err = lfs1_dir_commit(lfs1, &newcwd, NULL, 0);
+        if (err) {
+            return err;
+        }
+    }
+
+    return 0;
+}
+
+
+/// Filesystem operations ///
+static void lfs1_deinit(lfs1_t *lfs1) {
+    // free allocated memory
+    if (!lfs1->cfg->read_buffer) {
+        lfs1_free(lfs1->rcache.buffer);
+    }
+
+    if (!lfs1->cfg->prog_buffer) {
+        lfs1_free(lfs1->pcache.buffer);
+    }
+
+    if (!lfs1->cfg->lookahead_buffer) {
+        lfs1_free(lfs1->free.buffer);
+    }
+}
+
+static int lfs1_init(lfs1_t *lfs1, const struct lfs1_config *cfg) {
+    lfs1->cfg = cfg;
+
+    // setup read cache
+    if (lfs1->cfg->read_buffer) {
+        lfs1->rcache.buffer = lfs1->cfg->read_buffer;
+    } else {
+        lfs1->rcache.buffer = lfs1_malloc(lfs1->cfg->read_size);
+        if (!lfs1->rcache.buffer) {
+            goto cleanup;
+        }
+    }
+
+    // setup program cache
+    if (lfs1->cfg->prog_buffer) {
+        lfs1->pcache.buffer = lfs1->cfg->prog_buffer;
+    } else {
+        lfs1->pcache.buffer = lfs1_malloc(lfs1->cfg->prog_size);
+        if (!lfs1->pcache.buffer) {
+            goto cleanup;
+        }
+    }
+
+    // zero to avoid information leaks
+    lfs1_cache_zero(lfs1, &lfs1->pcache);
+    lfs1_cache_drop(lfs1, &lfs1->rcache);
+
+    // setup lookahead, round down to nearest 32-bits
+    LFS1_ASSERT(lfs1->cfg->lookahead % 32 == 0);
+    LFS1_ASSERT(lfs1->cfg->lookahead > 0);
+    if (lfs1->cfg->lookahead_buffer) {
+        lfs1->free.buffer = lfs1->cfg->lookahead_buffer;
+    } else {
+        lfs1->free.buffer = lfs1_malloc(lfs1->cfg->lookahead/8);
+        if (!lfs1->free.buffer) {
+            goto cleanup;
+        }
+    }
+
+    // check that program and read sizes are multiples of the block size
+    LFS1_ASSERT(lfs1->cfg->prog_size % lfs1->cfg->read_size == 0);
+    LFS1_ASSERT(lfs1->cfg->block_size % lfs1->cfg->prog_size == 0);
+
+    // check that the block size is large enough to fit ctz pointers
+    LFS1_ASSERT(4*lfs1_npw2(0xffffffff / (lfs1->cfg->block_size-2*4))
+            <= lfs1->cfg->block_size);
+
+    // setup default state
+    lfs1->root[0] = 0xffffffff;
+    lfs1->root[1] = 0xffffffff;
+    lfs1->files = NULL;
+    lfs1->dirs = NULL;
+    lfs1->deorphaned = false;
+    lfs1->moving = false;
+
+    return 0;
+
+cleanup:
+    lfs1_deinit(lfs1);
+    return LFS1_ERR_NOMEM;
+}
+
+int lfs1_format(lfs1_t *lfs1, const struct lfs1_config *cfg) {
+    int err = 0;
+    if (true) {
+        err = lfs1_init(lfs1, cfg);
+        if (err) {
+            return err;
+        }
+
+        // create free lookahead
+        memset(lfs1->free.buffer, 0, lfs1->cfg->lookahead/8);
+        lfs1->free.off = 0;
+        lfs1->free.size = lfs1_min(lfs1->cfg->lookahead, lfs1->cfg->block_count);
+        lfs1->free.i = 0;
+        lfs1_alloc_ack(lfs1);
+
+        // create superblock dir
+        lfs1_dir_t superdir;
+        err = lfs1_dir_alloc(lfs1, &superdir);
+        if (err) {
+            goto cleanup;
+        }
+
+        // write root directory
+        lfs1_dir_t root;
+        err = lfs1_dir_alloc(lfs1, &root);
+        if (err) {
+            goto cleanup;
+        }
+
+        err = lfs1_dir_commit(lfs1, &root, NULL, 0);
+        if (err) {
+            goto cleanup;
+        }
+
+        lfs1->root[0] = root.pair[0];
+        lfs1->root[1] = root.pair[1];
+
+        // write superblocks
+        lfs1_superblock_t superblock = {
+            .off = sizeof(superdir.d),
+            .d.type = LFS1_TYPE_SUPERBLOCK,
+            .d.elen = sizeof(superblock.d) - sizeof(superblock.d.magic) - 4,
+            .d.nlen = sizeof(superblock.d.magic),
+            .d.version = LFS1_DISK_VERSION,
+            .d.magic = {"littlefs"},
+            .d.block_size  = lfs1->cfg->block_size,
+            .d.block_count = lfs1->cfg->block_count,
+            .d.root = {lfs1->root[0], lfs1->root[1]},
+        };
+        superdir.d.tail[0] = root.pair[0];
+        superdir.d.tail[1] = root.pair[1];
+        superdir.d.size = sizeof(superdir.d) + sizeof(superblock.d) + 4;
+
+        // write both pairs to be safe
+        lfs1_superblock_tole32(&superblock.d);
+        bool valid = false;
+        for (int i = 0; i < 2; i++) {
+            err = lfs1_dir_commit(lfs1, &superdir, (struct lfs1_region[]){
+                    {sizeof(superdir.d), sizeof(superblock.d),
+                     &superblock.d, sizeof(superblock.d)}
+                }, 1);
+            if (err && err != LFS1_ERR_CORRUPT) {
+                goto cleanup;
+            }
+
+            valid = valid || !err;
+        }
+
+        if (!valid) {
+            err = LFS1_ERR_CORRUPT;
+            goto cleanup;
+        }
+
+        // sanity check that fetch works
+        err = lfs1_dir_fetch(lfs1, &superdir, (const lfs1_block_t[2]){0, 1});
+        if (err) {
+            goto cleanup;
+        }
+
+        lfs1_alloc_ack(lfs1);
+    }
+
+cleanup:
+    lfs1_deinit(lfs1);
+    return err;
+}
+
+int lfs1_mount(lfs1_t *lfs1, const struct lfs1_config *cfg) {
+    int err = 0;
+    if (true) {
+        err = lfs1_init(lfs1, cfg);
+        if (err) {
+            return err;
+        }
+
+        // setup free lookahead
+        lfs1->free.off = 0;
+        lfs1->free.size = 0;
+        lfs1->free.i = 0;
+        lfs1_alloc_ack(lfs1);
+
+        // load superblock
+        lfs1_dir_t dir;
+        lfs1_superblock_t superblock;
+        err = lfs1_dir_fetch(lfs1, &dir, (const lfs1_block_t[2]){0, 1});
+        if (err && err != LFS1_ERR_CORRUPT) {
+            goto cleanup;
+        }
+
+        if (!err) {
+            err = lfs1_bd_read(lfs1, dir.pair[0], sizeof(dir.d),
+                    &superblock.d, sizeof(superblock.d));
+            lfs1_superblock_fromle32(&superblock.d);
+            if (err) {
+                goto cleanup;
+            }
+
+            lfs1->root[0] = superblock.d.root[0];
+            lfs1->root[1] = superblock.d.root[1];
+        }
+
+        if (err || memcmp(superblock.d.magic, "littlefs", 8) != 0) {
+            LFS1_ERROR("Invalid superblock at %d %d", 0, 1);
+            err = LFS1_ERR_CORRUPT;
+            goto cleanup;
+        }
+
+        uint16_t major_version = (0xffff & (superblock.d.version >> 16));
+        uint16_t minor_version = (0xffff & (superblock.d.version >>  0));
+        if ((major_version != LFS1_DISK_VERSION_MAJOR ||
+             minor_version > LFS1_DISK_VERSION_MINOR)) {
+            LFS1_ERROR("Invalid version %d.%d", major_version, minor_version);
+            err = LFS1_ERR_INVAL;
+            goto cleanup;
+        }
+
+        return 0;
+    }
+
+cleanup:
+
+    lfs1_deinit(lfs1);
+    return err;
+}
+
+int lfs1_unmount(lfs1_t *lfs1) {
+    lfs1_deinit(lfs1);
+    return 0;
+}
+
+
+/// Littlefs specific operations ///
+int lfs1_traverse(lfs1_t *lfs1, int (*cb)(void*, lfs1_block_t), void *data) {
+    if (lfs1_pairisnull(lfs1->root)) {
+        return 0;
+    }
+
+    // iterate over metadata pairs
+    lfs1_dir_t dir;
+    lfs1_entry_t entry;
+    lfs1_block_t cwd[2] = {0, 1};
+
+    while (true) {
+        for (int i = 0; i < 2; i++) {
+            int err = cb(data, cwd[i]);
+            if (err) {
+                return err;
+            }
+        }
+
+        int err = lfs1_dir_fetch(lfs1, &dir, cwd);
+        if (err) {
+            return err;
+        }
+
+        // iterate over contents
+        while (dir.off + sizeof(entry.d) <= (0x7fffffff & dir.d.size)-4) {
+            err = lfs1_bd_read(lfs1, dir.pair[0], dir.off,
+                    &entry.d, sizeof(entry.d));
+            lfs1_entry_fromle32(&entry.d);
+            if (err) {
+                return err;
+            }
+
+            dir.off += lfs1_entry_size(&entry);
+            if ((0x70 & entry.d.type) == (0x70 & LFS1_TYPE_REG)) {
+                err = lfs1_ctz_traverse(lfs1, &lfs1->rcache, NULL,
+                        entry.d.u.file.head, entry.d.u.file.size, cb, data);
+                if (err) {
+                    return err;
+                }
+            }
+        }
+
+        cwd[0] = dir.d.tail[0];
+        cwd[1] = dir.d.tail[1];
+
+        if (lfs1_pairisnull(cwd)) {
+            break;
+        }
+    }
+
+    // iterate over any open files
+    for (lfs1_file_t *f = lfs1->files; f; f = f->next) {
+        if (f->flags & LFS1_F_DIRTY) {
+            int err = lfs1_ctz_traverse(lfs1, &lfs1->rcache, &f->cache,
+                    f->head, f->size, cb, data);
+            if (err) {
+                return err;
+            }
+        }
+
+        if (f->flags & LFS1_F_WRITING) {
+            int err = lfs1_ctz_traverse(lfs1, &lfs1->rcache, &f->cache,
+                    f->block, f->pos, cb, data);
+            if (err) {
+                return err;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int lfs1_pred(lfs1_t *lfs1, const lfs1_block_t dir[2], lfs1_dir_t *pdir) {
+    if (lfs1_pairisnull(lfs1->root)) {
+        return 0;
+    }
+
+    // iterate over all directory directory entries
+    int err = lfs1_dir_fetch(lfs1, pdir, (const lfs1_block_t[2]){0, 1});
+    if (err) {
+        return err;
+    }
+
+    while (!lfs1_pairisnull(pdir->d.tail)) {
+        if (lfs1_paircmp(pdir->d.tail, dir) == 0) {
+            return true;
+        }
+
+        err = lfs1_dir_fetch(lfs1, pdir, pdir->d.tail);
+        if (err) {
+            return err;
+        }
+    }
+
+    return false;
+}
+
+static int lfs1_parent(lfs1_t *lfs1, const lfs1_block_t dir[2],
+        lfs1_dir_t *parent, lfs1_entry_t *entry) {
+    if (lfs1_pairisnull(lfs1->root)) {
+        return 0;
+    }
+
+    parent->d.tail[0] = 0;
+    parent->d.tail[1] = 1;
+
+    // iterate over all directory directory entries
+    while (!lfs1_pairisnull(parent->d.tail)) {
+        int err = lfs1_dir_fetch(lfs1, parent, parent->d.tail);
+        if (err) {
+            return err;
+        }
+
+        while (true) {
+            err = lfs1_dir_next(lfs1, parent, entry);
+            if (err && err != LFS1_ERR_NOENT) {
+                return err;
+            }
+
+            if (err == LFS1_ERR_NOENT) {
+                break;
+            }
+
+            if (((0x70 & entry->d.type) == (0x70 & LFS1_TYPE_DIR)) &&
+                 lfs1_paircmp(entry->d.u.dir, dir) == 0) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+static int lfs1_moved(lfs1_t *lfs1, const void *e) {
+    if (lfs1_pairisnull(lfs1->root)) {
+        return 0;
+    }
+
+    // skip superblock
+    lfs1_dir_t cwd;
+    int err = lfs1_dir_fetch(lfs1, &cwd, (const lfs1_block_t[2]){0, 1});
+    if (err) {
+        return err;
+    }
+
+    // iterate over all directory directory entries
+    lfs1_entry_t entry;
+    while (!lfs1_pairisnull(cwd.d.tail)) {
+        err = lfs1_dir_fetch(lfs1, &cwd, cwd.d.tail);
+        if (err) {
+            return err;
+        }
+
+        while (true) {
+            err = lfs1_dir_next(lfs1, &cwd, &entry);
+            if (err && err != LFS1_ERR_NOENT) {
+                return err;
+            }
+
+            if (err == LFS1_ERR_NOENT) {
+                break;
+            }
+
+            if (!(0x80 & entry.d.type) &&
+                 memcmp(&entry.d.u, e, sizeof(entry.d.u)) == 0) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+static int lfs1_relocate(lfs1_t *lfs1,
+        const lfs1_block_t oldpair[2], const lfs1_block_t newpair[2]) {
+    // find parent
+    lfs1_dir_t parent;
+    lfs1_entry_t entry;
+    int res = lfs1_parent(lfs1, oldpair, &parent, &entry);
+    if (res < 0) {
+        return res;
+    }
+
+    if (res) {
+        // update disk, this creates a desync
+        entry.d.u.dir[0] = newpair[0];
+        entry.d.u.dir[1] = newpair[1];
+
+        int err = lfs1_dir_update(lfs1, &parent, &entry, NULL);
+        if (err) {
+            return err;
+        }
+
+        // update internal root
+        if (lfs1_paircmp(oldpair, lfs1->root) == 0) {
+            LFS1_DEBUG("Relocating root %" PRIu32 " %" PRIu32,
+                    newpair[0], newpair[1]);
+            lfs1->root[0] = newpair[0];
+            lfs1->root[1] = newpair[1];
+        }
+
+        // clean up bad block, which should now be a desync
+        return lfs1_deorphan(lfs1);
+    }
+
+    // find pred
+    res = lfs1_pred(lfs1, oldpair, &parent);
+    if (res < 0) {
+        return res;
+    }
+
+    if (res) {
+        // just replace bad pair, no desync can occur
+        parent.d.tail[0] = newpair[0];
+        parent.d.tail[1] = newpair[1];
+
+        return lfs1_dir_commit(lfs1, &parent, NULL, 0);
+    }
+
+    // couldn't find dir, must be new
+    return 0;
+}
+
+int lfs1_deorphan(lfs1_t *lfs1) {
+    lfs1->deorphaned = true;
+
+    if (lfs1_pairisnull(lfs1->root)) {
+        return 0;
+    }
+
+    lfs1_dir_t pdir = {.d.size = 0x80000000};
+    lfs1_dir_t cwd = {.d.tail[0] = 0, .d.tail[1] = 1};
+
+    // iterate over all directory directory entries
+    for (lfs1_size_t i = 0; i < lfs1->cfg->block_count; i++) {
+        if (lfs1_pairisnull(cwd.d.tail)) {
+            return 0;
+        }
+
+        int err = lfs1_dir_fetch(lfs1, &cwd, cwd.d.tail);
+        if (err) {
+            return err;
+        }
+
+        // check head blocks for orphans
+        if (!(0x80000000 & pdir.d.size)) {
+            // check if we have a parent
+            lfs1_dir_t parent;
+            lfs1_entry_t entry;
+            int res = lfs1_parent(lfs1, pdir.d.tail, &parent, &entry);
+            if (res < 0) {
+                return res;
+            }
+
+            if (!res) {
+                // we are an orphan
+                LFS1_DEBUG("Found orphan %" PRIu32 " %" PRIu32,
+                        pdir.d.tail[0], pdir.d.tail[1]);
+
+                pdir.d.tail[0] = cwd.d.tail[0];
+                pdir.d.tail[1] = cwd.d.tail[1];
+
+                err = lfs1_dir_commit(lfs1, &pdir, NULL, 0);
+                if (err) {
+                    return err;
+                }
+
+                return 0;
+            }
+
+            if (!lfs1_pairsync(entry.d.u.dir, pdir.d.tail)) {
+                // we have desynced
+                LFS1_DEBUG("Found desync %" PRIu32 " %" PRIu32,
+                        entry.d.u.dir[0], entry.d.u.dir[1]);
+
+                pdir.d.tail[0] = entry.d.u.dir[0];
+                pdir.d.tail[1] = entry.d.u.dir[1];
+
+                err = lfs1_dir_commit(lfs1, &pdir, NULL, 0);
+                if (err) {
+                    return err;
+                }
+
+                return 0;
+            }
+        }
+
+        // check entries for moves
+        lfs1_entry_t entry;
+        while (true) {
+            err = lfs1_dir_next(lfs1, &cwd, &entry);
+            if (err && err != LFS1_ERR_NOENT) {
+                return err;
+            }
+
+            if (err == LFS1_ERR_NOENT) {
+                break;
+            }
+
+            // found moved entry
+            if (entry.d.type & 0x80) {
+                int moved = lfs1_moved(lfs1, &entry.d.u);
+                if (moved < 0) {
+                    return moved;
+                }
+
+                if (moved) {
+                    LFS1_DEBUG("Found move %" PRIu32 " %" PRIu32,
+                            entry.d.u.dir[0], entry.d.u.dir[1]);
+                    err = lfs1_dir_remove(lfs1, &cwd, &entry);
+                    if (err) {
+                        return err;
+                    }
+                } else {
+                    LFS1_DEBUG("Found partial move %" PRIu32 " %" PRIu32,
+                            entry.d.u.dir[0], entry.d.u.dir[1]);
+                    entry.d.type &= ~0x80;
+                    err = lfs1_dir_update(lfs1, &cwd, &entry, NULL);
+                    if (err) {
+                        return err;
+                    }
+                }
+            }
+        }
+
+        memcpy(&pdir, &cwd, sizeof(pdir));
+    }
+
+    // If we reached here, we have more directory pairs than blocks in the
+    // filesystem... So something must be horribly wrong
+    return LFS1_ERR_CORRUPT;
+}
diff --git a/lib/littlefs/lfs1.h b/lib/littlefs/lfs1.h
new file mode 100644
index 0000000000000..355c145d08722
--- /dev/null
+++ b/lib/littlefs/lfs1.h
@@ -0,0 +1,501 @@
+/*
+ * The little filesystem
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#ifndef LFS1_H
+#define LFS1_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+/// Version info ///
+
+// Software library version
+// Major (top-nibble), incremented on backwards incompatible changes
+// Minor (bottom-nibble), incremented on feature additions
+#define LFS1_VERSION 0x00010007
+#define LFS1_VERSION_MAJOR (0xffff & (LFS1_VERSION >> 16))
+#define LFS1_VERSION_MINOR (0xffff & (LFS1_VERSION >>  0))
+
+// Version of On-disk data structures
+// Major (top-nibble), incremented on backwards incompatible changes
+// Minor (bottom-nibble), incremented on feature additions
+#define LFS1_DISK_VERSION 0x00010001
+#define LFS1_DISK_VERSION_MAJOR (0xffff & (LFS1_DISK_VERSION >> 16))
+#define LFS1_DISK_VERSION_MINOR (0xffff & (LFS1_DISK_VERSION >>  0))
+
+
+/// Definitions ///
+
+// Type definitions
+typedef uint32_t lfs1_size_t;
+typedef uint32_t lfs1_off_t;
+
+typedef int32_t  lfs1_ssize_t;
+typedef int32_t  lfs1_soff_t;
+
+typedef uint32_t lfs1_block_t;
+
+// Max name size in bytes
+#ifndef LFS1_NAME_MAX
+#define LFS1_NAME_MAX 255
+#endif
+
+// Max file size in bytes
+#ifndef LFS1_FILE_MAX
+#define LFS1_FILE_MAX 2147483647
+#endif
+
+// Possible error codes, these are negative to allow
+// valid positive return values
+enum lfs1_error {
+    LFS1_ERR_OK       = 0,    // No error
+    LFS1_ERR_IO       = -5,   // Error during device operation
+    LFS1_ERR_CORRUPT  = -52,  // Corrupted
+    LFS1_ERR_NOENT    = -2,   // No directory entry
+    LFS1_ERR_EXIST    = -17,  // Entry already exists
+    LFS1_ERR_NOTDIR   = -20,  // Entry is not a dir
+    LFS1_ERR_ISDIR    = -21,  // Entry is a dir
+    LFS1_ERR_NOTEMPTY = -39,  // Dir is not empty
+    LFS1_ERR_BADF     = -9,   // Bad file number
+    LFS1_ERR_FBIG     = -27,  // File too large
+    LFS1_ERR_INVAL    = -22,  // Invalid parameter
+    LFS1_ERR_NOSPC    = -28,  // No space left on device
+    LFS1_ERR_NOMEM    = -12,  // No more memory available
+};
+
+// File types
+enum lfs1_type {
+    LFS1_TYPE_REG        = 0x11,
+    LFS1_TYPE_DIR        = 0x22,
+    LFS1_TYPE_SUPERBLOCK = 0x2e,
+};
+
+// File open flags
+enum lfs1_open_flags {
+    // open flags
+    LFS1_O_RDONLY = 1,        // Open a file as read only
+    LFS1_O_WRONLY = 2,        // Open a file as write only
+    LFS1_O_RDWR   = 3,        // Open a file as read and write
+    LFS1_O_CREAT  = 0x0100,   // Create a file if it does not exist
+    LFS1_O_EXCL   = 0x0200,   // Fail if a file already exists
+    LFS1_O_TRUNC  = 0x0400,   // Truncate the existing file to zero size
+    LFS1_O_APPEND = 0x0800,   // Move to end of file on every write
+
+    // internally used flags
+    LFS1_F_DIRTY   = 0x10000, // File does not match storage
+    LFS1_F_WRITING = 0x20000, // File has been written since last flush
+    LFS1_F_READING = 0x40000, // File has been read since last flush
+    LFS1_F_ERRED   = 0x80000, // An error occured during write
+};
+
+// File seek flags
+enum lfs1_whence_flags {
+    LFS1_SEEK_SET = 0,   // Seek relative to an absolute position
+    LFS1_SEEK_CUR = 1,   // Seek relative to the current file position
+    LFS1_SEEK_END = 2,   // Seek relative to the end of the file
+};
+
+
+// Configuration provided during initialization of the littlefs
+struct lfs1_config {
+    // Opaque user provided context that can be used to pass
+    // information to the block device operations
+    void *context;
+
+    // Read a region in a block. Negative error codes are propogated
+    // to the user.
+    int (*read)(const struct lfs1_config *c, lfs1_block_t block,
+            lfs1_off_t off, void *buffer, lfs1_size_t size);
+
+    // Program a region in a block. The block must have previously
+    // been erased. Negative error codes are propogated to the user.
+    // May return LFS1_ERR_CORRUPT if the block should be considered bad.
+    int (*prog)(const struct lfs1_config *c, lfs1_block_t block,
+            lfs1_off_t off, const void *buffer, lfs1_size_t size);
+
+    // Erase a block. A block must be erased before being programmed.
+    // The state of an erased block is undefined. Negative error codes
+    // are propogated to the user.
+    // May return LFS1_ERR_CORRUPT if the block should be considered bad.
+    int (*erase)(const struct lfs1_config *c, lfs1_block_t block);
+
+    // Sync the state of the underlying block device. Negative error codes
+    // are propogated to the user.
+    int (*sync)(const struct lfs1_config *c);
+
+    // Minimum size of a block read. This determines the size of read buffers.
+    // This may be larger than the physical read size to improve performance
+    // by caching more of the block device.
+    lfs1_size_t read_size;
+
+    // Minimum size of a block program. This determines the size of program
+    // buffers. This may be larger than the physical program size to improve
+    // performance by caching more of the block device.
+    // Must be a multiple of the read size.
+    lfs1_size_t prog_size;
+
+    // Size of an erasable block. This does not impact ram consumption and
+    // may be larger than the physical erase size. However, this should be
+    // kept small as each file currently takes up an entire block.
+    // Must be a multiple of the program size.
+    lfs1_size_t block_size;
+
+    // Number of erasable blocks on the device.
+    lfs1_size_t block_count;
+
+    // Number of blocks to lookahead during block allocation. A larger
+    // lookahead reduces the number of passes required to allocate a block.
+    // The lookahead buffer requires only 1 bit per block so it can be quite
+    // large with little ram impact. Should be a multiple of 32.
+    lfs1_size_t lookahead;
+
+    // Optional, statically allocated read buffer. Must be read sized.
+    void *read_buffer;
+
+    // Optional, statically allocated program buffer. Must be program sized.
+    void *prog_buffer;
+
+    // Optional, statically allocated lookahead buffer. Must be 1 bit per
+    // lookahead block.
+    void *lookahead_buffer;
+
+    // Optional, statically allocated buffer for files. Must be program sized.
+    // If enabled, only one file may be opened at a time.
+    void *file_buffer;
+};
+
+// Optional configuration provided during lfs1_file_opencfg
+struct lfs1_file_config {
+    // Optional, statically allocated buffer for files. Must be program sized.
+    // If NULL, malloc will be used by default.
+    void *buffer;
+};
+
+// File info structure
+struct lfs1_info {
+    // Type of the file, either LFS1_TYPE_REG or LFS1_TYPE_DIR
+    uint8_t type;
+
+    // Size of the file, only valid for REG files
+    lfs1_size_t size;
+
+    // Name of the file stored as a null-terminated string
+    char name[LFS1_NAME_MAX+1];
+};
+
+
+/// littlefs data structures ///
+typedef struct lfs1_entry {
+    lfs1_off_t off;
+
+    struct lfs1_disk_entry {
+        uint8_t type;
+        uint8_t elen;
+        uint8_t alen;
+        uint8_t nlen;
+        union {
+            struct {
+                lfs1_block_t head;
+                lfs1_size_t size;
+            } file;
+            lfs1_block_t dir[2];
+        } u;
+    } d;
+} lfs1_entry_t;
+
+typedef struct lfs1_cache {
+    lfs1_block_t block;
+    lfs1_off_t off;
+    uint8_t *buffer;
+} lfs1_cache_t;
+
+typedef struct lfs1_file {
+    struct lfs1_file *next;
+    lfs1_block_t pair[2];
+    lfs1_off_t poff;
+
+    lfs1_block_t head;
+    lfs1_size_t size;
+
+    const struct lfs1_file_config *cfg;
+    uint32_t flags;
+    lfs1_off_t pos;
+    lfs1_block_t block;
+    lfs1_off_t off;
+    lfs1_cache_t cache;
+} lfs1_file_t;
+
+typedef struct lfs1_dir {
+    struct lfs1_dir *next;
+    lfs1_block_t pair[2];
+    lfs1_off_t off;
+
+    lfs1_block_t head[2];
+    lfs1_off_t pos;
+
+    struct lfs1_disk_dir {
+        uint32_t rev;
+        lfs1_size_t size;
+        lfs1_block_t tail[2];
+    } d;
+} lfs1_dir_t;
+
+typedef struct lfs1_superblock {
+    lfs1_off_t off;
+
+    struct lfs1_disk_superblock {
+        uint8_t type;
+        uint8_t elen;
+        uint8_t alen;
+        uint8_t nlen;
+        lfs1_block_t root[2];
+        uint32_t block_size;
+        uint32_t block_count;
+        uint32_t version;
+        char magic[8];
+    } d;
+} lfs1_superblock_t;
+
+typedef struct lfs1_free {
+    lfs1_block_t off;
+    lfs1_block_t size;
+    lfs1_block_t i;
+    lfs1_block_t ack;
+    uint32_t *buffer;
+} lfs1_free_t;
+
+// The littlefs type
+typedef struct lfs1 {
+    const struct lfs1_config *cfg;
+
+    lfs1_block_t root[2];
+    lfs1_file_t *files;
+    lfs1_dir_t *dirs;
+
+    lfs1_cache_t rcache;
+    lfs1_cache_t pcache;
+
+    lfs1_free_t free;
+    bool deorphaned;
+    bool moving;
+} lfs1_t;
+
+
+/// Filesystem functions ///
+
+// Format a block device with the littlefs
+//
+// Requires a littlefs object and config struct. This clobbers the littlefs
+// object, and does not leave the filesystem mounted. The config struct must
+// be zeroed for defaults and backwards compatibility.
+//
+// Returns a negative error code on failure.
+int lfs1_format(lfs1_t *lfs1, const struct lfs1_config *config);
+
+// Mounts a littlefs
+//
+// Requires a littlefs object and config struct. Multiple filesystems
+// may be mounted simultaneously with multiple littlefs objects. Both
+// lfs1 and config must be allocated while mounted. The config struct must
+// be zeroed for defaults and backwards compatibility.
+//
+// Returns a negative error code on failure.
+int lfs1_mount(lfs1_t *lfs1, const struct lfs1_config *config);
+
+// Unmounts a littlefs
+//
+// Does nothing besides releasing any allocated resources.
+// Returns a negative error code on failure.
+int lfs1_unmount(lfs1_t *lfs1);
+
+/// General operations ///
+
+// Removes a file or directory
+//
+// If removing a directory, the directory must be empty.
+// Returns a negative error code on failure.
+int lfs1_remove(lfs1_t *lfs1, const char *path);
+
+// Rename or move a file or directory
+//
+// If the destination exists, it must match the source in type.
+// If the destination is a directory, the directory must be empty.
+//
+// Returns a negative error code on failure.
+int lfs1_rename(lfs1_t *lfs1, const char *oldpath, const char *newpath);
+
+// Find info about a file or directory
+//
+// Fills out the info structure, based on the specified file or directory.
+// Returns a negative error code on failure.
+int lfs1_stat(lfs1_t *lfs1, const char *path, struct lfs1_info *info);
+
+
+/// File operations ///
+
+// Open a file
+//
+// The mode that the file is opened in is determined by the flags, which
+// are values from the enum lfs1_open_flags that are bitwise-ored together.
+//
+// Returns a negative error code on failure.
+int lfs1_file_open(lfs1_t *lfs1, lfs1_file_t *file,
+        const char *path, int flags);
+
+// Open a file with extra configuration
+//
+// The mode that the file is opened in is determined by the flags, which
+// are values from the enum lfs1_open_flags that are bitwise-ored together.
+//
+// The config struct provides additional config options per file as described
+// above. The config struct must be allocated while the file is open, and the
+// config struct must be zeroed for defaults and backwards compatibility.
+//
+// Returns a negative error code on failure.
+int lfs1_file_opencfg(lfs1_t *lfs1, lfs1_file_t *file,
+        const char *path, int flags,
+        const struct lfs1_file_config *config);
+
+// Close a file
+//
+// Any pending writes are written out to storage as though
+// sync had been called and releases any allocated resources.
+//
+// Returns a negative error code on failure.
+int lfs1_file_close(lfs1_t *lfs1, lfs1_file_t *file);
+
+// Synchronize a file on storage
+//
+// Any pending writes are written out to storage.
+// Returns a negative error code on failure.
+int lfs1_file_sync(lfs1_t *lfs1, lfs1_file_t *file);
+
+// Read data from file
+//
+// Takes a buffer and size indicating where to store the read data.
+// Returns the number of bytes read, or a negative error code on failure.
+lfs1_ssize_t lfs1_file_read(lfs1_t *lfs1, lfs1_file_t *file,
+        void *buffer, lfs1_size_t size);
+
+// Write data to file
+//
+// Takes a buffer and size indicating the data to write. The file will not
+// actually be updated on the storage until either sync or close is called.
+//
+// Returns the number of bytes written, or a negative error code on failure.
+lfs1_ssize_t lfs1_file_write(lfs1_t *lfs1, lfs1_file_t *file,
+        const void *buffer, lfs1_size_t size);
+
+// Change the position of the file
+//
+// The change in position is determined by the offset and whence flag.
+// Returns the old position of the file, or a negative error code on failure.
+lfs1_soff_t lfs1_file_seek(lfs1_t *lfs1, lfs1_file_t *file,
+        lfs1_soff_t off, int whence);
+
+// Truncates the size of the file to the specified size
+//
+// Returns a negative error code on failure.
+int lfs1_file_truncate(lfs1_t *lfs1, lfs1_file_t *file, lfs1_off_t size);
+
+// Return the position of the file
+//
+// Equivalent to lfs1_file_seek(lfs1, file, 0, LFS1_SEEK_CUR)
+// Returns the position of the file, or a negative error code on failure.
+lfs1_soff_t lfs1_file_tell(lfs1_t *lfs1, lfs1_file_t *file);
+
+// Change the position of the file to the beginning of the file
+//
+// Equivalent to lfs1_file_seek(lfs1, file, 0, LFS1_SEEK_CUR)
+// Returns a negative error code on failure.
+int lfs1_file_rewind(lfs1_t *lfs1, lfs1_file_t *file);
+
+// Return the size of the file
+//
+// Similar to lfs1_file_seek(lfs1, file, 0, LFS1_SEEK_END)
+// Returns the size of the file, or a negative error code on failure.
+lfs1_soff_t lfs1_file_size(lfs1_t *lfs1, lfs1_file_t *file);
+
+
+/// Directory operations ///
+
+// Create a directory
+//
+// Returns a negative error code on failure.
+int lfs1_mkdir(lfs1_t *lfs1, const char *path);
+
+// Open a directory
+//
+// Once open a directory can be used with read to iterate over files.
+// Returns a negative error code on failure.
+int lfs1_dir_open(lfs1_t *lfs1, lfs1_dir_t *dir, const char *path);
+
+// Close a directory
+//
+// Releases any allocated resources.
+// Returns a negative error code on failure.
+int lfs1_dir_close(lfs1_t *lfs1, lfs1_dir_t *dir);
+
+// Read an entry in the directory
+//
+// Fills out the info structure, based on the specified file or directory.
+// Returns a negative error code on failure.
+int lfs1_dir_read(lfs1_t *lfs1, lfs1_dir_t *dir, struct lfs1_info *info);
+
+// Change the position of the directory
+//
+// The new off must be a value previous returned from tell and specifies
+// an absolute offset in the directory seek.
+//
+// Returns a negative error code on failure.
+int lfs1_dir_seek(lfs1_t *lfs1, lfs1_dir_t *dir, lfs1_off_t off);
+
+// Return the position of the directory
+//
+// The returned offset is only meant to be consumed by seek and may not make
+// sense, but does indicate the current position in the directory iteration.
+//
+// Returns the position of the directory, or a negative error code on failure.
+lfs1_soff_t lfs1_dir_tell(lfs1_t *lfs1, lfs1_dir_t *dir);
+
+// Change the position of the directory to the beginning of the directory
+//
+// Returns a negative error code on failure.
+int lfs1_dir_rewind(lfs1_t *lfs1, lfs1_dir_t *dir);
+
+
+/// Miscellaneous littlefs specific operations ///
+
+// Traverse through all blocks in use by the filesystem
+//
+// The provided callback will be called with each block address that is
+// currently in use by the filesystem. This can be used to determine which
+// blocks are in use or how much of the storage is available.
+//
+// Returns a negative error code on failure.
+int lfs1_traverse(lfs1_t *lfs1, int (*cb)(void*, lfs1_block_t), void *data);
+
+// Prunes any recoverable errors that may have occured in the filesystem
+//
+// Not needed to be called by user unless an operation is interrupted
+// but the filesystem is still mounted. This is already called on first
+// allocation.
+//
+// Returns a negative error code on failure.
+int lfs1_deorphan(lfs1_t *lfs1);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif
diff --git a/lib/littlefs/lfs1_util.c b/lib/littlefs/lfs1_util.c
new file mode 100644
index 0000000000000..3832a5ddb35a6
--- /dev/null
+++ b/lib/littlefs/lfs1_util.c
@@ -0,0 +1,31 @@
+/*
+ * lfs1 util functions
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#include "lfs1_util.h"
+
+// Only compile if user does not provide custom config
+#ifndef LFS1_CONFIG
+
+
+// Software CRC implementation with small lookup table
+void lfs1_crc(uint32_t *restrict crc, const void *buffer, size_t size) {
+    static const uint32_t rtable[16] = {
+        0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
+        0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
+        0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
+        0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c,
+    };
+
+    const uint8_t *data = buffer;
+
+    for (size_t i = 0; i < size; i++) {
+        *crc = (*crc >> 4) ^ rtable[(*crc ^ (data[i] >> 0)) & 0xf];
+        *crc = (*crc >> 4) ^ rtable[(*crc ^ (data[i] >> 4)) & 0xf];
+    }
+}
+
+
+#endif
diff --git a/lib/littlefs/lfs1_util.h b/lib/littlefs/lfs1_util.h
new file mode 100644
index 0000000000000..b33b6a7adcff2
--- /dev/null
+++ b/lib/littlefs/lfs1_util.h
@@ -0,0 +1,186 @@
+/*
+ * lfs1 utility functions
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#ifndef LFS1_UTIL_H
+#define LFS1_UTIL_H
+
+// Users can override lfs1_util.h with their own configuration by defining
+// LFS1_CONFIG as a header file to include (-DLFS1_CONFIG=lfs1_config.h).
+//
+// If LFS1_CONFIG is used, none of the default utils will be emitted and must be
+// provided by the config file. To start I would suggest copying lfs1_util.h and
+// modifying as needed.
+#ifdef LFS1_CONFIG
+#define LFS1_STRINGIZE(x) LFS1_STRINGIZE2(x)
+#define LFS1_STRINGIZE2(x) #x
+#include LFS1_STRINGIZE(LFS1_CONFIG)
+#else
+
+// System includes
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+#ifndef LFS1_NO_MALLOC
+#include <stdlib.h>
+#endif
+#ifndef LFS1_NO_ASSERT
+#include <assert.h>
+#endif
+#if !defined(LFS1_NO_DEBUG) || !defined(LFS1_NO_WARN) || !defined(LFS1_NO_ERROR)
+#include <stdio.h>
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+// Macros, may be replaced by system specific wrappers. Arguments to these
+// macros must not have side-effects as the macros can be removed for a smaller
+// code footprint
+
+// Logging functions
+#ifndef LFS1_NO_DEBUG
+#define LFS1_DEBUG(fmt, ...) \
+    printf("lfs1 debug:%d: " fmt "\n", __LINE__, __VA_ARGS__)
+#else
+#define LFS1_DEBUG(fmt, ...)
+#endif
+
+#ifndef LFS1_NO_WARN
+#define LFS1_WARN(fmt, ...) \
+    printf("lfs1 warn:%d: " fmt "\n", __LINE__, __VA_ARGS__)
+#else
+#define LFS1_WARN(fmt, ...)
+#endif
+
+#ifndef LFS1_NO_ERROR
+#define LFS1_ERROR(fmt, ...) \
+    printf("lfs1 error:%d: " fmt "\n", __LINE__, __VA_ARGS__)
+#else
+#define LFS1_ERROR(fmt, ...)
+#endif
+
+// Runtime assertions
+#ifndef LFS1_NO_ASSERT
+#define LFS1_ASSERT(test) assert(test)
+#else
+#define LFS1_ASSERT(test)
+#endif
+
+
+// Builtin functions, these may be replaced by more efficient
+// toolchain-specific implementations. LFS1_NO_INTRINSICS falls back to a more
+// expensive basic C implementation for debugging purposes
+
+// Min/max functions for unsigned 32-bit numbers
+static inline uint32_t lfs1_max(uint32_t a, uint32_t b) {
+    return (a > b) ? a : b;
+}
+
+static inline uint32_t lfs1_min(uint32_t a, uint32_t b) {
+    return (a < b) ? a : b;
+}
+
+// Find the next smallest power of 2 less than or equal to a
+static inline uint32_t lfs1_npw2(uint32_t a) {
+#if !defined(LFS1_NO_INTRINSICS) && (defined(__GNUC__) || defined(__CC_ARM))
+    return 32 - __builtin_clz(a-1);
+#else
+    uint32_t r = 0;
+    uint32_t s;
+    a -= 1;
+    s = (a > 0xffff) << 4; a >>= s; r |= s;
+    s = (a > 0xff  ) << 3; a >>= s; r |= s;
+    s = (a > 0xf   ) << 2; a >>= s; r |= s;
+    s = (a > 0x3   ) << 1; a >>= s; r |= s;
+    return (r | (a >> 1)) + 1;
+#endif
+}
+
+// Count the number of trailing binary zeros in a
+// lfs1_ctz(0) may be undefined
+static inline uint32_t lfs1_ctz(uint32_t a) {
+#if !defined(LFS1_NO_INTRINSICS) && defined(__GNUC__)
+    return __builtin_ctz(a);
+#else
+    return lfs1_npw2((a & -a) + 1) - 1;
+#endif
+}
+
+// Count the number of binary ones in a
+static inline uint32_t lfs1_popc(uint32_t a) {
+#if !defined(LFS1_NO_INTRINSICS) && (defined(__GNUC__) || defined(__CC_ARM))
+    return __builtin_popcount(a);
+#else
+    a = a - ((a >> 1) & 0x55555555);
+    a = (a & 0x33333333) + ((a >> 2) & 0x33333333);
+    return (((a + (a >> 4)) & 0xf0f0f0f) * 0x1010101) >> 24;
+#endif
+}
+
+// Find the sequence comparison of a and b, this is the distance
+// between a and b ignoring overflow
+static inline int lfs1_scmp(uint32_t a, uint32_t b) {
+    return (int)(unsigned)(a - b);
+}
+
+// Convert from 32-bit little-endian to native order
+static inline uint32_t lfs1_fromle32(uint32_t a) {
+#if !defined(LFS1_NO_INTRINSICS) && ( \
+    (defined(  BYTE_ORDER  ) &&   BYTE_ORDER   ==   ORDER_LITTLE_ENDIAN  ) || \
+    (defined(__BYTE_ORDER  ) && __BYTE_ORDER   == __ORDER_LITTLE_ENDIAN  ) || \
+    (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
+    return a;
+#elif !defined(LFS1_NO_INTRINSICS) && ( \
+    (defined(  BYTE_ORDER  ) &&   BYTE_ORDER   ==   ORDER_BIG_ENDIAN  ) || \
+    (defined(__BYTE_ORDER  ) && __BYTE_ORDER   == __ORDER_BIG_ENDIAN  ) || \
+    (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
+    return __builtin_bswap32(a);
+#else
+    return (((uint8_t*)&a)[0] <<  0) |
+           (((uint8_t*)&a)[1] <<  8) |
+           (((uint8_t*)&a)[2] << 16) |
+           (((uint8_t*)&a)[3] << 24);
+#endif
+}
+
+// Convert to 32-bit little-endian from native order
+static inline uint32_t lfs1_tole32(uint32_t a) {
+    return lfs1_fromle32(a);
+}
+
+// Calculate CRC-32 with polynomial = 0x04c11db7
+void lfs1_crc(uint32_t *crc, const void *buffer, size_t size);
+
+// Allocate memory, only used if buffers are not provided to littlefs
+static inline void *lfs1_malloc(size_t size) {
+#ifndef LFS1_NO_MALLOC
+    return malloc(size);
+#else
+    (void)size;
+    return NULL;
+#endif
+}
+
+// Deallocate memory, only used if buffers are not provided to littlefs
+static inline void lfs1_free(void *p) {
+#ifndef LFS1_NO_MALLOC
+    free(p);
+#else
+    (void)p;
+#endif
+}
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif
+#endif
diff --git a/lib/littlefs/lfs2.c b/lib/littlefs/lfs2.c
new file mode 100644
index 0000000000000..6bae806ceb41c
--- /dev/null
+++ b/lib/littlefs/lfs2.c
@@ -0,0 +1,4913 @@
+/*
+ * The little filesystem
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#include "lfs2.h"
+#include "lfs2_util.h"
+
+#define LFS2_BLOCK_NULL ((lfs2_block_t)-1)
+#define LFS2_BLOCK_INLINE ((lfs2_block_t)-2)
+
+/// Caching block device operations ///
+static inline void lfs2_cache_drop(lfs2_t *lfs2, lfs2_cache_t *rcache) {
+    // do not zero, cheaper if cache is readonly or only going to be
+    // written with identical data (during relocates)
+    (void)lfs2;
+    rcache->block = LFS2_BLOCK_NULL;
+}
+
+static inline void lfs2_cache_zero(lfs2_t *lfs2, lfs2_cache_t *pcache) {
+    // zero to avoid information leak
+    memset(pcache->buffer, 0xff, lfs2->cfg->cache_size);
+    pcache->block = LFS2_BLOCK_NULL;
+}
+
+static int lfs2_bd_read(lfs2_t *lfs2,
+        const lfs2_cache_t *pcache, lfs2_cache_t *rcache, lfs2_size_t hint,
+        lfs2_block_t block, lfs2_off_t off,
+        void *buffer, lfs2_size_t size) {
+    uint8_t *data = buffer;
+    if (block >= lfs2->cfg->block_count ||
+            off+size > lfs2->cfg->block_size) {
+        return LFS2_ERR_CORRUPT;
+    }
+
+    while (size > 0) {
+        lfs2_size_t diff = size;
+
+        if (pcache && block == pcache->block &&
+                off < pcache->off + pcache->size) {
+            if (off >= pcache->off) {
+                // is already in pcache?
+                diff = lfs2_min(diff, pcache->size - (off-pcache->off));
+                memcpy(data, &pcache->buffer[off-pcache->off], diff);
+
+                data += diff;
+                off += diff;
+                size -= diff;
+                continue;
+            }
+
+            // pcache takes priority
+            diff = lfs2_min(diff, pcache->off-off);
+        }
+
+        if (block == rcache->block &&
+                off < rcache->off + rcache->size) {
+            if (off >= rcache->off) {
+                // is already in rcache?
+                diff = lfs2_min(diff, rcache->size - (off-rcache->off));
+                memcpy(data, &rcache->buffer[off-rcache->off], diff);
+
+                data += diff;
+                off += diff;
+                size -= diff;
+                continue;
+            }
+
+            // rcache takes priority
+            diff = lfs2_min(diff, rcache->off-off);
+        }
+
+        if (size >= hint && off % lfs2->cfg->read_size == 0 &&
+                size >= lfs2->cfg->read_size) {
+            // bypass cache?
+            diff = lfs2_aligndown(diff, lfs2->cfg->read_size);
+            int err = lfs2->cfg->read(lfs2->cfg, block, off, data, diff);
+            if (err) {
+                return err;
+            }
+
+            data += diff;
+            off += diff;
+            size -= diff;
+            continue;
+        }
+
+        // load to cache, first condition can no longer fail
+        LFS2_ASSERT(block < lfs2->cfg->block_count);
+        rcache->block = block;
+        rcache->off = lfs2_aligndown(off, lfs2->cfg->read_size);
+        rcache->size = lfs2_min(
+                lfs2_min(
+                    lfs2_alignup(off+hint, lfs2->cfg->read_size),
+                    lfs2->cfg->block_size)
+                - rcache->off,
+                lfs2->cfg->cache_size);
+        int err = lfs2->cfg->read(lfs2->cfg, rcache->block,
+                rcache->off, rcache->buffer, rcache->size);
+        LFS2_ASSERT(err <= 0);
+        if (err) {
+            return err;
+        }
+    }
+
+    return 0;
+}
+
+enum {
+    LFS2_CMP_EQ = 0,
+    LFS2_CMP_LT = 1,
+    LFS2_CMP_GT = 2,
+};
+
+static int lfs2_bd_cmp(lfs2_t *lfs2,
+        const lfs2_cache_t *pcache, lfs2_cache_t *rcache, lfs2_size_t hint,
+        lfs2_block_t block, lfs2_off_t off,
+        const void *buffer, lfs2_size_t size) {
+    const uint8_t *data = buffer;
+
+    for (lfs2_off_t i = 0; i < size; i++) {
+        uint8_t dat;
+        int err = lfs2_bd_read(lfs2,
+                pcache, rcache, hint-i,
+                block, off+i, &dat, 1);
+        if (err) {
+            return err;
+        }
+
+        if (dat != data[i]) {
+            return (dat < data[i]) ? LFS2_CMP_LT : LFS2_CMP_GT;
+        }
+    }
+
+    return LFS2_CMP_EQ;
+}
+
+static int lfs2_bd_flush(lfs2_t *lfs2,
+        lfs2_cache_t *pcache, lfs2_cache_t *rcache, bool validate) {
+    if (pcache->block != LFS2_BLOCK_NULL && pcache->block != LFS2_BLOCK_INLINE) {
+        LFS2_ASSERT(pcache->block < lfs2->cfg->block_count);
+        lfs2_size_t diff = lfs2_alignup(pcache->size, lfs2->cfg->prog_size);
+        int err = lfs2->cfg->prog(lfs2->cfg, pcache->block,
+                pcache->off, pcache->buffer, diff);
+        LFS2_ASSERT(err <= 0);
+        if (err) {
+            return err;
+        }
+
+        if (validate) {
+            // check data on disk
+            lfs2_cache_drop(lfs2, rcache);
+            int res = lfs2_bd_cmp(lfs2,
+                    NULL, rcache, diff,
+                    pcache->block, pcache->off, pcache->buffer, diff);
+            if (res < 0) {
+                return res;
+            }
+
+            if (res != LFS2_CMP_EQ) {
+                return LFS2_ERR_CORRUPT;
+            }
+        }
+
+        lfs2_cache_zero(lfs2, pcache);
+    }
+
+    return 0;
+}
+
+static int lfs2_bd_sync(lfs2_t *lfs2,
+        lfs2_cache_t *pcache, lfs2_cache_t *rcache, bool validate) {
+    lfs2_cache_drop(lfs2, rcache);
+
+    int err = lfs2_bd_flush(lfs2, pcache, rcache, validate);
+    if (err) {
+        return err;
+    }
+
+    err = lfs2->cfg->sync(lfs2->cfg);
+    LFS2_ASSERT(err <= 0);
+    return err;
+}
+
+static int lfs2_bd_prog(lfs2_t *lfs2,
+        lfs2_cache_t *pcache, lfs2_cache_t *rcache, bool validate,
+        lfs2_block_t block, lfs2_off_t off,
+        const void *buffer, lfs2_size_t size) {
+    const uint8_t *data = buffer;
+    LFS2_ASSERT(block == LFS2_BLOCK_INLINE || block < lfs2->cfg->block_count);
+    LFS2_ASSERT(off + size <= lfs2->cfg->block_size);
+
+    while (size > 0) {
+        if (block == pcache->block &&
+                off >= pcache->off &&
+                off < pcache->off + lfs2->cfg->cache_size) {
+            // already fits in pcache?
+            lfs2_size_t diff = lfs2_min(size,
+                    lfs2->cfg->cache_size - (off-pcache->off));
+            memcpy(&pcache->buffer[off-pcache->off], data, diff);
+
+            data += diff;
+            off += diff;
+            size -= diff;
+
+            pcache->size = lfs2_max(pcache->size, off - pcache->off);
+            if (pcache->size == lfs2->cfg->cache_size) {
+                // eagerly flush out pcache if we fill up
+                int err = lfs2_bd_flush(lfs2, pcache, rcache, validate);
+                if (err) {
+                    return err;
+                }
+            }
+
+            continue;
+        }
+
+        // pcache must have been flushed, either by programming and
+        // entire block or manually flushing the pcache
+        LFS2_ASSERT(pcache->block == LFS2_BLOCK_NULL);
+
+        // prepare pcache, first condition can no longer fail
+        pcache->block = block;
+        pcache->off = lfs2_aligndown(off, lfs2->cfg->prog_size);
+        pcache->size = 0;
+    }
+
+    return 0;
+}
+
+static int lfs2_bd_erase(lfs2_t *lfs2, lfs2_block_t block) {
+    LFS2_ASSERT(block < lfs2->cfg->block_count);
+    int err = lfs2->cfg->erase(lfs2->cfg, block);
+    LFS2_ASSERT(err <= 0);
+    return err;
+}
+
+
+/// Small type-level utilities ///
+// operations on block pairs
+static inline void lfs2_pair_swap(lfs2_block_t pair[2]) {
+    lfs2_block_t t = pair[0];
+    pair[0] = pair[1];
+    pair[1] = t;
+}
+
+static inline bool lfs2_pair_isnull(const lfs2_block_t pair[2]) {
+    return pair[0] == LFS2_BLOCK_NULL || pair[1] == LFS2_BLOCK_NULL;
+}
+
+static inline int lfs2_pair_cmp(
+        const lfs2_block_t paira[2],
+        const lfs2_block_t pairb[2]) {
+    return !(paira[0] == pairb[0] || paira[1] == pairb[1] ||
+             paira[0] == pairb[1] || paira[1] == pairb[0]);
+}
+
+static inline bool lfs2_pair_sync(
+        const lfs2_block_t paira[2],
+        const lfs2_block_t pairb[2]) {
+    return (paira[0] == pairb[0] && paira[1] == pairb[1]) ||
+           (paira[0] == pairb[1] && paira[1] == pairb[0]);
+}
+
+static inline void lfs2_pair_fromle32(lfs2_block_t pair[2]) {
+    pair[0] = lfs2_fromle32(pair[0]);
+    pair[1] = lfs2_fromle32(pair[1]);
+}
+
+static inline void lfs2_pair_tole32(lfs2_block_t pair[2]) {
+    pair[0] = lfs2_tole32(pair[0]);
+    pair[1] = lfs2_tole32(pair[1]);
+}
+
+// operations on 32-bit entry tags
+typedef uint32_t lfs2_tag_t;
+typedef int32_t lfs2_stag_t;
+
+#define LFS2_MKTAG(type, id, size) \
+    (((lfs2_tag_t)(type) << 20) | ((lfs2_tag_t)(id) << 10) | (lfs2_tag_t)(size))
+
+#define LFS2_MKTAG_IF(cond, type, id, size) \
+    ((cond) ? LFS2_MKTAG(type, id, size) : LFS2_MKTAG(LFS2_FROM_NOOP, 0, 0))
+
+#define LFS2_MKTAG_IF_ELSE(cond, type1, id1, size1, type2, id2, size2) \
+    ((cond) ? LFS2_MKTAG(type1, id1, size1) : LFS2_MKTAG(type2, id2, size2))
+
+static inline bool lfs2_tag_isvalid(lfs2_tag_t tag) {
+    return !(tag & 0x80000000);
+}
+
+static inline bool lfs2_tag_isdelete(lfs2_tag_t tag) {
+    return ((int32_t)(tag << 22) >> 22) == -1;
+}
+
+static inline uint16_t lfs2_tag_type1(lfs2_tag_t tag) {
+    return (tag & 0x70000000) >> 20;
+}
+
+static inline uint16_t lfs2_tag_type3(lfs2_tag_t tag) {
+    return (tag & 0x7ff00000) >> 20;
+}
+
+static inline uint8_t lfs2_tag_chunk(lfs2_tag_t tag) {
+    return (tag & 0x0ff00000) >> 20;
+}
+
+static inline int8_t lfs2_tag_splice(lfs2_tag_t tag) {
+    return (int8_t)lfs2_tag_chunk(tag);
+}
+
+static inline uint16_t lfs2_tag_id(lfs2_tag_t tag) {
+    return (tag & 0x000ffc00) >> 10;
+}
+
+static inline lfs2_size_t lfs2_tag_size(lfs2_tag_t tag) {
+    return tag & 0x000003ff;
+}
+
+static inline lfs2_size_t lfs2_tag_dsize(lfs2_tag_t tag) {
+    return sizeof(tag) + lfs2_tag_size(tag + lfs2_tag_isdelete(tag));
+}
+
+// operations on attributes in attribute lists
+struct lfs2_mattr {
+    lfs2_tag_t tag;
+    const void *buffer;
+};
+
+struct lfs2_diskoff {
+    lfs2_block_t block;
+    lfs2_off_t off;
+};
+
+#define LFS2_MKATTRS(...) \
+    (struct lfs2_mattr[]){__VA_ARGS__}, \
+    sizeof((struct lfs2_mattr[]){__VA_ARGS__}) / sizeof(struct lfs2_mattr)
+
+// operations on global state
+static inline void lfs2_gstate_xor(lfs2_gstate_t *a, const lfs2_gstate_t *b) {
+    for (int i = 0; i < 3; i++) {
+        ((uint32_t*)a)[i] ^= ((const uint32_t*)b)[i];
+    }
+}
+
+static inline bool lfs2_gstate_iszero(const lfs2_gstate_t *a) {
+    for (int i = 0; i < 3; i++) {
+        if (((uint32_t*)a)[i] != 0) {
+            return false;
+        }
+    }
+    return true;
+}
+
+static inline bool lfs2_gstate_hasorphans(const lfs2_gstate_t *a) {
+    return lfs2_tag_size(a->tag);
+}
+
+static inline uint8_t lfs2_gstate_getorphans(const lfs2_gstate_t *a) {
+    return lfs2_tag_size(a->tag);
+}
+
+static inline bool lfs2_gstate_hasmove(const lfs2_gstate_t *a) {
+    return lfs2_tag_type1(a->tag);
+}
+
+static inline bool lfs2_gstate_hasmovehere(const lfs2_gstate_t *a,
+        const lfs2_block_t *pair) {
+    return lfs2_tag_type1(a->tag) && lfs2_pair_cmp(a->pair, pair) == 0;
+}
+
+static inline void lfs2_gstate_fromle32(lfs2_gstate_t *a) {
+    a->tag     = lfs2_fromle32(a->tag);
+    a->pair[0] = lfs2_fromle32(a->pair[0]);
+    a->pair[1] = lfs2_fromle32(a->pair[1]);
+}
+
+static inline void lfs2_gstate_tole32(lfs2_gstate_t *a) {
+    a->tag     = lfs2_tole32(a->tag);
+    a->pair[0] = lfs2_tole32(a->pair[0]);
+    a->pair[1] = lfs2_tole32(a->pair[1]);
+}
+
+// other endianness operations
+static void lfs2_ctz_fromle32(struct lfs2_ctz *ctz) {
+    ctz->head = lfs2_fromle32(ctz->head);
+    ctz->size = lfs2_fromle32(ctz->size);
+}
+
+static void lfs2_ctz_tole32(struct lfs2_ctz *ctz) {
+    ctz->head = lfs2_tole32(ctz->head);
+    ctz->size = lfs2_tole32(ctz->size);
+}
+
+static inline void lfs2_superblock_fromle32(lfs2_superblock_t *superblock) {
+    superblock->version     = lfs2_fromle32(superblock->version);
+    superblock->block_size  = lfs2_fromle32(superblock->block_size);
+    superblock->block_count = lfs2_fromle32(superblock->block_count);
+    superblock->name_max    = lfs2_fromle32(superblock->name_max);
+    superblock->file_max    = lfs2_fromle32(superblock->file_max);
+    superblock->attr_max    = lfs2_fromle32(superblock->attr_max);
+}
+
+static inline void lfs2_superblock_tole32(lfs2_superblock_t *superblock) {
+    superblock->version     = lfs2_tole32(superblock->version);
+    superblock->block_size  = lfs2_tole32(superblock->block_size);
+    superblock->block_count = lfs2_tole32(superblock->block_count);
+    superblock->name_max    = lfs2_tole32(superblock->name_max);
+    superblock->file_max    = lfs2_tole32(superblock->file_max);
+    superblock->attr_max    = lfs2_tole32(superblock->attr_max);
+}
+
+
+/// Internal operations predeclared here ///
+static int lfs2_dir_commit(lfs2_t *lfs2, lfs2_mdir_t *dir,
+        const struct lfs2_mattr *attrs, int attrcount);
+static int lfs2_dir_compact(lfs2_t *lfs2,
+        lfs2_mdir_t *dir, const struct lfs2_mattr *attrs, int attrcount,
+        lfs2_mdir_t *source, uint16_t begin, uint16_t end);
+static int lfs2_file_outline(lfs2_t *lfs2, lfs2_file_t *file);
+static int lfs2_file_flush(lfs2_t *lfs2, lfs2_file_t *file);
+static void lfs2_fs_preporphans(lfs2_t *lfs2, int8_t orphans);
+static void lfs2_fs_prepmove(lfs2_t *lfs2,
+        uint16_t id, const lfs2_block_t pair[2]);
+static int lfs2_fs_pred(lfs2_t *lfs2, const lfs2_block_t dir[2],
+        lfs2_mdir_t *pdir);
+static lfs2_stag_t lfs2_fs_parent(lfs2_t *lfs2, const lfs2_block_t dir[2],
+        lfs2_mdir_t *parent);
+static int lfs2_fs_relocate(lfs2_t *lfs2,
+        const lfs2_block_t oldpair[2], lfs2_block_t newpair[2]);
+int lfs2_fs_traverseraw(lfs2_t *lfs2,
+        int (*cb)(void *data, lfs2_block_t block), void *data,
+        bool includeorphans);
+static int lfs2_fs_forceconsistency(lfs2_t *lfs2);
+static int lfs2_deinit(lfs2_t *lfs2);
+#ifdef LFS2_MIGRATE
+static int lfs21_traverse(lfs2_t *lfs2,
+        int (*cb)(void*, lfs2_block_t), void *data);
+#endif
+
+/// Block allocator ///
+static int lfs2_alloc_lookahead(void *p, lfs2_block_t block) {
+    lfs2_t *lfs2 = (lfs2_t*)p;
+    lfs2_block_t off = ((block - lfs2->free.off)
+            + lfs2->cfg->block_count) % lfs2->cfg->block_count;
+
+    if (off < lfs2->free.size) {
+        lfs2->free.buffer[off / 32] |= 1U << (off % 32);
+    }
+
+    return 0;
+}
+
+static void lfs2_alloc_ack(lfs2_t *lfs2) {
+    lfs2->free.ack = lfs2->cfg->block_count;
+}
+
+// Invalidate the lookahead buffer. This is done during mounting and
+// failed traversals
+static void lfs2_alloc_reset(lfs2_t *lfs2) {
+    lfs2->free.off = lfs2->seed % lfs2->cfg->block_size;
+    lfs2->free.size = 0;
+    lfs2->free.i = 0;
+    lfs2_alloc_ack(lfs2);
+}
+
+static int lfs2_alloc(lfs2_t *lfs2, lfs2_block_t *block) {
+    while (true) {
+        while (lfs2->free.i != lfs2->free.size) {
+            lfs2_block_t off = lfs2->free.i;
+            lfs2->free.i += 1;
+            lfs2->free.ack -= 1;
+
+            if (!(lfs2->free.buffer[off / 32] & (1U << (off % 32)))) {
+                // found a free block
+                *block = (lfs2->free.off + off) % lfs2->cfg->block_count;
+
+                // eagerly find next off so an alloc ack can
+                // discredit old lookahead blocks
+                while (lfs2->free.i != lfs2->free.size &&
+                        (lfs2->free.buffer[lfs2->free.i / 32]
+                            & (1U << (lfs2->free.i % 32)))) {
+                    lfs2->free.i += 1;
+                    lfs2->free.ack -= 1;
+                }
+
+                return 0;
+            }
+        }
+
+        // check if we have looked at all blocks since last ack
+        if (lfs2->free.ack == 0) {
+            LFS2_ERROR("No more free space %"PRIu32,
+                    lfs2->free.i + lfs2->free.off);
+            return LFS2_ERR_NOSPC;
+        }
+
+        lfs2->free.off = (lfs2->free.off + lfs2->free.size)
+                % lfs2->cfg->block_count;
+        lfs2->free.size = lfs2_min(8*lfs2->cfg->lookahead_size, lfs2->free.ack);
+        lfs2->free.i = 0;
+
+        // find mask of free blocks from tree
+        memset(lfs2->free.buffer, 0, lfs2->cfg->lookahead_size);
+        int err = lfs2_fs_traverseraw(lfs2, lfs2_alloc_lookahead, lfs2, true);
+        if (err) {
+            lfs2_alloc_reset(lfs2);
+            return err;
+        }
+    }
+}
+
+/// Metadata pair and directory operations ///
+static lfs2_stag_t lfs2_dir_getslice(lfs2_t *lfs2, const lfs2_mdir_t *dir,
+        lfs2_tag_t gmask, lfs2_tag_t gtag,
+        lfs2_off_t goff, void *gbuffer, lfs2_size_t gsize) {
+    lfs2_off_t off = dir->off;
+    lfs2_tag_t ntag = dir->etag;
+    lfs2_stag_t gdiff = 0;
+
+    if (lfs2_gstate_hasmovehere(&lfs2->gdisk, dir->pair) &&
+            lfs2_tag_id(gmask) != 0 &&
+            lfs2_tag_id(lfs2->gdisk.tag) <= lfs2_tag_id(gtag)) {
+        // synthetic moves
+        gdiff -= LFS2_MKTAG(0, 1, 0);
+    }
+
+    // iterate over dir block backwards (for faster lookups)
+    while (off >= sizeof(lfs2_tag_t) + lfs2_tag_dsize(ntag)) {
+        off -= lfs2_tag_dsize(ntag);
+        lfs2_tag_t tag = ntag;
+        int err = lfs2_bd_read(lfs2,
+                NULL, &lfs2->rcache, sizeof(ntag),
+                dir->pair[0], off, &ntag, sizeof(ntag));
+        if (err) {
+            return err;
+        }
+
+        ntag = (lfs2_frombe32(ntag) ^ tag) & 0x7fffffff;
+
+        if (lfs2_tag_id(gmask) != 0 &&
+                lfs2_tag_type1(tag) == LFS2_TYPE_SPLICE &&
+                lfs2_tag_id(tag) <= lfs2_tag_id(gtag - gdiff)) {
+            if (tag == (LFS2_MKTAG(LFS2_TYPE_CREATE, 0, 0) |
+                    (LFS2_MKTAG(0, 0x3ff, 0) & (gtag - gdiff)))) {
+                // found where we were created
+                return LFS2_ERR_NOENT;
+            }
+
+            // move around splices
+            gdiff += LFS2_MKTAG(0, lfs2_tag_splice(tag), 0);
+        }
+
+        if ((gmask & tag) == (gmask & (gtag - gdiff))) {
+            if (lfs2_tag_isdelete(tag)) {
+                return LFS2_ERR_NOENT;
+            }
+
+            lfs2_size_t diff = lfs2_min(lfs2_tag_size(tag), gsize);
+            err = lfs2_bd_read(lfs2,
+                    NULL, &lfs2->rcache, diff,
+                    dir->pair[0], off+sizeof(tag)+goff, gbuffer, diff);
+            if (err) {
+                return err;
+            }
+
+            memset((uint8_t*)gbuffer + diff, 0, gsize - diff);
+
+            return tag + gdiff;
+        }
+    }
+
+    return LFS2_ERR_NOENT;
+}
+
+static lfs2_stag_t lfs2_dir_get(lfs2_t *lfs2, const lfs2_mdir_t *dir,
+        lfs2_tag_t gmask, lfs2_tag_t gtag, void *buffer) {
+    return lfs2_dir_getslice(lfs2, dir,
+            gmask, gtag,
+            0, buffer, lfs2_tag_size(gtag));
+}
+
+static int lfs2_dir_getread(lfs2_t *lfs2, const lfs2_mdir_t *dir,
+        const lfs2_cache_t *pcache, lfs2_cache_t *rcache, lfs2_size_t hint,
+        lfs2_tag_t gmask, lfs2_tag_t gtag,
+        lfs2_off_t off, void *buffer, lfs2_size_t size) {
+    uint8_t *data = buffer;
+    if (off+size > lfs2->cfg->block_size) {
+        return LFS2_ERR_CORRUPT;
+    }
+
+    while (size > 0) {
+        lfs2_size_t diff = size;
+
+        if (pcache && pcache->block == LFS2_BLOCK_INLINE &&
+                off < pcache->off + pcache->size) {
+            if (off >= pcache->off) {
+                // is already in pcache?
+                diff = lfs2_min(diff, pcache->size - (off-pcache->off));
+                memcpy(data, &pcache->buffer[off-pcache->off], diff);
+
+                data += diff;
+                off += diff;
+                size -= diff;
+                continue;
+            }
+
+            // pcache takes priority
+            diff = lfs2_min(diff, pcache->off-off);
+        }
+
+        if (rcache->block == LFS2_BLOCK_INLINE &&
+                off < rcache->off + rcache->size) {
+            if (off >= rcache->off) {
+                // is already in rcache?
+                diff = lfs2_min(diff, rcache->size - (off-rcache->off));
+                memcpy(data, &rcache->buffer[off-rcache->off], diff);
+
+                data += diff;
+                off += diff;
+                size -= diff;
+                continue;
+            }
+
+            // rcache takes priority
+            diff = lfs2_min(diff, rcache->off-off);
+        }
+
+        // load to cache, first condition can no longer fail
+        rcache->block = LFS2_BLOCK_INLINE;
+        rcache->off = lfs2_aligndown(off, lfs2->cfg->read_size);
+        rcache->size = lfs2_min(lfs2_alignup(off+hint, lfs2->cfg->read_size),
+                lfs2->cfg->cache_size);
+        int err = lfs2_dir_getslice(lfs2, dir, gmask, gtag,
+                rcache->off, rcache->buffer, rcache->size);
+        if (err < 0) {
+            return err;
+        }
+    }
+
+    return 0;
+}
+
+static int lfs2_dir_traverse_filter(void *p,
+        lfs2_tag_t tag, const void *buffer) {
+    lfs2_tag_t *filtertag = p;
+    (void)buffer;
+
+    // which mask depends on unique bit in tag structure
+    uint32_t mask = (tag & LFS2_MKTAG(0x100, 0, 0))
+            ? LFS2_MKTAG(0x7ff, 0x3ff, 0)
+            : LFS2_MKTAG(0x700, 0x3ff, 0);
+
+    // check for redundancy
+    if ((mask & tag) == (mask & *filtertag) ||
+            lfs2_tag_isdelete(*filtertag) ||
+            (LFS2_MKTAG(0x7ff, 0x3ff, 0) & tag) == (
+                LFS2_MKTAG(LFS2_TYPE_DELETE, 0, 0) |
+                    (LFS2_MKTAG(0, 0x3ff, 0) & *filtertag))) {
+        return true;
+    }
+
+    // check if we need to adjust for created/deleted tags
+    if (lfs2_tag_type1(tag) == LFS2_TYPE_SPLICE &&
+            lfs2_tag_id(tag) <= lfs2_tag_id(*filtertag)) {
+        *filtertag += LFS2_MKTAG(0, lfs2_tag_splice(tag), 0);
+    }
+
+    return false;
+}
+
+static int lfs2_dir_traverse(lfs2_t *lfs2,
+        const lfs2_mdir_t *dir, lfs2_off_t off, lfs2_tag_t ptag,
+        const struct lfs2_mattr *attrs, int attrcount,
+        lfs2_tag_t tmask, lfs2_tag_t ttag,
+        uint16_t begin, uint16_t end, int16_t diff,
+        int (*cb)(void *data, lfs2_tag_t tag, const void *buffer), void *data) {
+    // iterate over directory and attrs
+    while (true) {
+        lfs2_tag_t tag;
+        const void *buffer;
+        struct lfs2_diskoff disk;
+        if (off+lfs2_tag_dsize(ptag) < dir->off) {
+            off += lfs2_tag_dsize(ptag);
+            int err = lfs2_bd_read(lfs2,
+                    NULL, &lfs2->rcache, sizeof(tag),
+                    dir->pair[0], off, &tag, sizeof(tag));
+            if (err) {
+                return err;
+            }
+
+            tag = (lfs2_frombe32(tag) ^ ptag) | 0x80000000;
+            disk.block = dir->pair[0];
+            disk.off = off+sizeof(lfs2_tag_t);
+            buffer = &disk;
+            ptag = tag;
+        } else if (attrcount > 0) {
+            tag = attrs[0].tag;
+            buffer = attrs[0].buffer;
+            attrs += 1;
+            attrcount -= 1;
+        } else {
+            return 0;
+        }
+
+        lfs2_tag_t mask = LFS2_MKTAG(0x7ff, 0, 0);
+        if ((mask & tmask & tag) != (mask & tmask & ttag)) {
+            continue;
+        }
+
+        // do we need to filter? inlining the filtering logic here allows
+        // for some minor optimizations
+        if (lfs2_tag_id(tmask) != 0) {
+            // scan for duplicates and update tag based on creates/deletes
+            int filter = lfs2_dir_traverse(lfs2,
+                    dir, off, ptag, attrs, attrcount,
+                    0, 0, 0, 0, 0,
+                    lfs2_dir_traverse_filter, &tag);
+            if (filter < 0) {
+                return filter;
+            }
+
+            if (filter) {
+                continue;
+            }
+
+            // in filter range?
+            if (!(lfs2_tag_id(tag) >= begin && lfs2_tag_id(tag) < end)) {
+                continue;
+            }
+        }
+
+        // handle special cases for mcu-side operations
+        if (lfs2_tag_type3(tag) == LFS2_FROM_NOOP) {
+            // do nothing
+        } else if (lfs2_tag_type3(tag) == LFS2_FROM_MOVE) {
+            uint16_t fromid = lfs2_tag_size(tag);
+            uint16_t toid = lfs2_tag_id(tag);
+            int err = lfs2_dir_traverse(lfs2,
+                    buffer, 0, 0xffffffff, NULL, 0,
+                    LFS2_MKTAG(0x600, 0x3ff, 0),
+                    LFS2_MKTAG(LFS2_TYPE_STRUCT, 0, 0),
+                    fromid, fromid+1, toid-fromid+diff,
+                    cb, data);
+            if (err) {
+                return err;
+            }
+        } else if (lfs2_tag_type3(tag) == LFS2_FROM_USERATTRS) {
+            for (unsigned i = 0; i < lfs2_tag_size(tag); i++) {
+                const struct lfs2_attr *a = buffer;
+                int err = cb(data, LFS2_MKTAG(LFS2_TYPE_USERATTR + a[i].type,
+                        lfs2_tag_id(tag) + diff, a[i].size), a[i].buffer);
+                if (err) {
+                    return err;
+                }
+            }
+        } else {
+            int err = cb(data, tag + LFS2_MKTAG(0, diff, 0), buffer);
+            if (err) {
+                return err;
+            }
+        }
+    }
+}
+
+static lfs2_stag_t lfs2_dir_fetchmatch(lfs2_t *lfs2,
+        lfs2_mdir_t *dir, const lfs2_block_t pair[2],
+        lfs2_tag_t fmask, lfs2_tag_t ftag, uint16_t *id,
+        int (*cb)(void *data, lfs2_tag_t tag, const void *buffer), void *data) {
+    // we can find tag very efficiently during a fetch, since we're already
+    // scanning the entire directory
+    lfs2_stag_t besttag = -1;
+
+    // if either block address is invalid we return LFS2_ERR_CORRUPT here,
+    // otherwise later writes to the pair could fail
+    if (pair[0] >= lfs2->cfg->block_count || pair[1] >= lfs2->cfg->block_count) {
+        return LFS2_ERR_CORRUPT;
+    }
+
+    // find the block with the most recent revision
+    uint32_t revs[2] = {0, 0};
+    int r = 0;
+    for (int i = 0; i < 2; i++) {
+        int err = lfs2_bd_read(lfs2,
+                NULL, &lfs2->rcache, sizeof(revs[i]),
+                pair[i], 0, &revs[i], sizeof(revs[i]));
+        revs[i] = lfs2_fromle32(revs[i]);
+        if (err && err != LFS2_ERR_CORRUPT) {
+            return err;
+        }
+
+        if (err != LFS2_ERR_CORRUPT &&
+                lfs2_scmp(revs[i], revs[(i+1)%2]) > 0) {
+            r = i;
+        }
+    }
+
+    dir->pair[0] = pair[(r+0)%2];
+    dir->pair[1] = pair[(r+1)%2];
+    dir->rev = revs[(r+0)%2];
+    dir->off = 0; // nonzero = found some commits
+
+    // now scan tags to fetch the actual dir and find possible match
+    for (int i = 0; i < 2; i++) {
+        lfs2_off_t off = 0;
+        lfs2_tag_t ptag = 0xffffffff;
+
+        uint16_t tempcount = 0;
+        lfs2_block_t temptail[2] = {LFS2_BLOCK_NULL, LFS2_BLOCK_NULL};
+        bool tempsplit = false;
+        lfs2_stag_t tempbesttag = besttag;
+
+        dir->rev = lfs2_tole32(dir->rev);
+        uint32_t crc = lfs2_crc(0xffffffff, &dir->rev, sizeof(dir->rev));
+        dir->rev = lfs2_fromle32(dir->rev);
+
+        while (true) {
+            // extract next tag
+            lfs2_tag_t tag;
+            off += lfs2_tag_dsize(ptag);
+            int err = lfs2_bd_read(lfs2,
+                    NULL, &lfs2->rcache, lfs2->cfg->block_size,
+                    dir->pair[0], off, &tag, sizeof(tag));
+            if (err) {
+                if (err == LFS2_ERR_CORRUPT) {
+                    // can't continue?
+                    dir->erased = false;
+                    break;
+                }
+                return err;
+            }
+
+            crc = lfs2_crc(crc, &tag, sizeof(tag));
+            tag = lfs2_frombe32(tag) ^ ptag;
+
+            // next commit not yet programmed or we're not in valid range
+            if (!lfs2_tag_isvalid(tag)) {
+                dir->erased = (lfs2_tag_type1(ptag) == LFS2_TYPE_CRC &&
+                        dir->off % lfs2->cfg->prog_size == 0);
+                break;
+            } else if (off + lfs2_tag_dsize(tag) > lfs2->cfg->block_size) {
+                dir->erased = false;
+                break;
+            }
+
+            ptag = tag;
+
+            if (lfs2_tag_type1(tag) == LFS2_TYPE_CRC) {
+                // check the crc attr
+                uint32_t dcrc;
+                err = lfs2_bd_read(lfs2,
+                        NULL, &lfs2->rcache, lfs2->cfg->block_size,
+                        dir->pair[0], off+sizeof(tag), &dcrc, sizeof(dcrc));
+                if (err) {
+                    if (err == LFS2_ERR_CORRUPT) {
+                        dir->erased = false;
+                        break;
+                    }
+                    return err;
+                }
+                dcrc = lfs2_fromle32(dcrc);
+
+                if (crc != dcrc) {
+                    dir->erased = false;
+                    break;
+                }
+
+                // reset the next bit if we need to
+                ptag ^= (lfs2_tag_t)(lfs2_tag_chunk(tag) & 1U) << 31;
+
+                // toss our crc into the filesystem seed for
+                // pseudorandom numbers
+                lfs2->seed ^= crc;
+
+                // update with what's found so far
+                besttag = tempbesttag;
+                dir->off = off + lfs2_tag_dsize(tag);
+                dir->etag = ptag;
+                dir->count = tempcount;
+                dir->tail[0] = temptail[0];
+                dir->tail[1] = temptail[1];
+                dir->split = tempsplit;
+
+                // reset crc
+                crc = 0xffffffff;
+                continue;
+            }
+
+            // crc the entry first, hopefully leaving it in the cache
+            for (lfs2_off_t j = sizeof(tag); j < lfs2_tag_dsize(tag); j++) {
+                uint8_t dat;
+                err = lfs2_bd_read(lfs2,
+                        NULL, &lfs2->rcache, lfs2->cfg->block_size,
+                        dir->pair[0], off+j, &dat, 1);
+                if (err) {
+                    if (err == LFS2_ERR_CORRUPT) {
+                        dir->erased = false;
+                        break;
+                    }
+                    return err;
+                }
+
+                crc = lfs2_crc(crc, &dat, 1);
+            }
+
+            // directory modification tags?
+            if (lfs2_tag_type1(tag) == LFS2_TYPE_NAME) {
+                // increase count of files if necessary
+                if (lfs2_tag_id(tag) >= tempcount) {
+                    tempcount = lfs2_tag_id(tag) + 1;
+                }
+            } else if (lfs2_tag_type1(tag) == LFS2_TYPE_SPLICE) {
+                tempcount += lfs2_tag_splice(tag);
+
+                if (tag == (LFS2_MKTAG(LFS2_TYPE_DELETE, 0, 0) |
+                        (LFS2_MKTAG(0, 0x3ff, 0) & tempbesttag))) {
+                    tempbesttag |= 0x80000000;
+                } else if (tempbesttag != -1 &&
+                        lfs2_tag_id(tag) <= lfs2_tag_id(tempbesttag)) {
+                    tempbesttag += LFS2_MKTAG(0, lfs2_tag_splice(tag), 0);
+                }
+            } else if (lfs2_tag_type1(tag) == LFS2_TYPE_TAIL) {
+                tempsplit = (lfs2_tag_chunk(tag) & 1);
+
+                err = lfs2_bd_read(lfs2,
+                        NULL, &lfs2->rcache, lfs2->cfg->block_size,
+                        dir->pair[0], off+sizeof(tag), &temptail, 8);
+                if (err) {
+                    if (err == LFS2_ERR_CORRUPT) {
+                        dir->erased = false;
+                        break;
+                    }
+                }
+                lfs2_pair_fromle32(temptail);
+            }
+
+            // found a match for our fetcher?
+            if ((fmask & tag) == (fmask & ftag)) {
+                int res = cb(data, tag, &(struct lfs2_diskoff){
+                        dir->pair[0], off+sizeof(tag)});
+                if (res < 0) {
+                    if (res == LFS2_ERR_CORRUPT) {
+                        dir->erased = false;
+                        break;
+                    }
+                    return res;
+                }
+
+                if (res == LFS2_CMP_EQ) {
+                    // found a match
+                    tempbesttag = tag;
+                } else if ((LFS2_MKTAG(0x7ff, 0x3ff, 0) & tag) ==
+                        (LFS2_MKTAG(0x7ff, 0x3ff, 0) & tempbesttag)) {
+                    // found an identical tag, but contents didn't match
+                    // this must mean that our besttag has been overwritten
+                    tempbesttag = -1;
+                } else if (res == LFS2_CMP_GT &&
+                        lfs2_tag_id(tag) <= lfs2_tag_id(tempbesttag)) {
+                    // found a greater match, keep track to keep things sorted
+                    tempbesttag = tag | 0x80000000;
+                }
+            }
+        }
+
+        // consider what we have good enough
+        if (dir->off > 0) {
+            // synthetic move
+            if (lfs2_gstate_hasmovehere(&lfs2->gdisk, dir->pair)) {
+                if (lfs2_tag_id(lfs2->gdisk.tag) == lfs2_tag_id(besttag)) {
+                    besttag |= 0x80000000;
+                } else if (besttag != -1 &&
+                        lfs2_tag_id(lfs2->gdisk.tag) < lfs2_tag_id(besttag)) {
+                    besttag -= LFS2_MKTAG(0, 1, 0);
+                }
+            }
+
+            // found tag? or found best id?
+            if (id) {
+                *id = lfs2_min(lfs2_tag_id(besttag), dir->count);
+            }
+
+            if (lfs2_tag_isvalid(besttag)) {
+                return besttag;
+            } else if (lfs2_tag_id(besttag) < dir->count) {
+                return LFS2_ERR_NOENT;
+            } else {
+                return 0;
+            }
+        }
+
+        // failed, try the other block?
+        lfs2_pair_swap(dir->pair);
+        dir->rev = revs[(r+1)%2];
+    }
+
+    LFS2_ERROR("Corrupted dir pair at {0x%"PRIx32", 0x%"PRIx32"}",
+            dir->pair[0], dir->pair[1]);
+    return LFS2_ERR_CORRUPT;
+}
+
+static int lfs2_dir_fetch(lfs2_t *lfs2,
+        lfs2_mdir_t *dir, const lfs2_block_t pair[2]) {
+    // note, mask=-1, tag=-1 can never match a tag since this
+    // pattern has the invalid bit set
+    return (int)lfs2_dir_fetchmatch(lfs2, dir, pair,
+            (lfs2_tag_t)-1, (lfs2_tag_t)-1, NULL, NULL, NULL);
+}
+
+static int lfs2_dir_getgstate(lfs2_t *lfs2, const lfs2_mdir_t *dir,
+        lfs2_gstate_t *gstate) {
+    lfs2_gstate_t temp;
+    lfs2_stag_t res = lfs2_dir_get(lfs2, dir, LFS2_MKTAG(0x7ff, 0, 0),
+            LFS2_MKTAG(LFS2_TYPE_MOVESTATE, 0, sizeof(temp)), &temp);
+    if (res < 0 && res != LFS2_ERR_NOENT) {
+        return res;
+    }
+
+    if (res != LFS2_ERR_NOENT) {
+        // xor together to find resulting gstate
+        lfs2_gstate_fromle32(&temp);
+        lfs2_gstate_xor(gstate, &temp);
+    }
+
+    return 0;
+}
+
+static int lfs2_dir_getinfo(lfs2_t *lfs2, lfs2_mdir_t *dir,
+        uint16_t id, struct lfs2_info *info) {
+    if (id == 0x3ff) {
+        // special case for root
+        strcpy(info->name, "/");
+        info->type = LFS2_TYPE_DIR;
+        return 0;
+    }
+
+    lfs2_stag_t tag = lfs2_dir_get(lfs2, dir, LFS2_MKTAG(0x780, 0x3ff, 0),
+            LFS2_MKTAG(LFS2_TYPE_NAME, id, lfs2->name_max+1), info->name);
+    if (tag < 0) {
+        return (int)tag;
+    }
+
+    info->type = lfs2_tag_type3(tag);
+
+    struct lfs2_ctz ctz;
+    tag = lfs2_dir_get(lfs2, dir, LFS2_MKTAG(0x700, 0x3ff, 0),
+            LFS2_MKTAG(LFS2_TYPE_STRUCT, id, sizeof(ctz)), &ctz);
+    if (tag < 0) {
+        return (int)tag;
+    }
+    lfs2_ctz_fromle32(&ctz);
+
+    if (lfs2_tag_type3(tag) == LFS2_TYPE_CTZSTRUCT) {
+        info->size = ctz.size;
+    } else if (lfs2_tag_type3(tag) == LFS2_TYPE_INLINESTRUCT) {
+        info->size = lfs2_tag_size(tag);
+    }
+
+    return 0;
+}
+
+struct lfs2_dir_find_match {
+    lfs2_t *lfs2;
+    const void *name;
+    lfs2_size_t size;
+};
+
+static int lfs2_dir_find_match(void *data,
+        lfs2_tag_t tag, const void *buffer) {
+    struct lfs2_dir_find_match *name = data;
+    lfs2_t *lfs2 = name->lfs2;
+    const struct lfs2_diskoff *disk = buffer;
+
+    // compare with disk
+    lfs2_size_t diff = lfs2_min(name->size, lfs2_tag_size(tag));
+    int res = lfs2_bd_cmp(lfs2,
+            NULL, &lfs2->rcache, diff,
+            disk->block, disk->off, name->name, diff);
+    if (res != LFS2_CMP_EQ) {
+        return res;
+    }
+
+    // only equal if our size is still the same
+    if (name->size != lfs2_tag_size(tag)) {
+        return (name->size < lfs2_tag_size(tag)) ? LFS2_CMP_LT : LFS2_CMP_GT;
+    }
+
+    // found a match!
+    return LFS2_CMP_EQ;
+}
+
+static lfs2_stag_t lfs2_dir_find(lfs2_t *lfs2, lfs2_mdir_t *dir,
+        const char **path, uint16_t *id) {
+    // we reduce path to a single name if we can find it
+    const char *name = *path;
+    if (id) {
+        *id = 0x3ff;
+    }
+
+    // default to root dir
+    lfs2_stag_t tag = LFS2_MKTAG(LFS2_TYPE_DIR, 0x3ff, 0);
+    dir->tail[0] = lfs2->root[0];
+    dir->tail[1] = lfs2->root[1];
+
+    while (true) {
+nextname:
+        // skip slashes
+        name += strspn(name, "/");
+        lfs2_size_t namelen = strcspn(name, "/");
+
+        // skip '.' and root '..'
+        if ((namelen == 1 && memcmp(name, ".", 1) == 0) ||
+            (namelen == 2 && memcmp(name, "..", 2) == 0)) {
+            name += namelen;
+            goto nextname;
+        }
+
+        // skip if matched by '..' in name
+        const char *suffix = name + namelen;
+        lfs2_size_t sufflen;
+        int depth = 1;
+        while (true) {
+            suffix += strspn(suffix, "/");
+            sufflen = strcspn(suffix, "/");
+            if (sufflen == 0) {
+                break;
+            }
+
+            if (sufflen == 2 && memcmp(suffix, "..", 2) == 0) {
+                depth -= 1;
+                if (depth == 0) {
+                    name = suffix + sufflen;
+                    goto nextname;
+                }
+            } else {
+                depth += 1;
+            }
+
+            suffix += sufflen;
+        }
+
+        // found path
+        if (name[0] == '\0') {
+            return tag;
+        }
+
+        // update what we've found so far
+        *path = name;
+
+        // only continue if we hit a directory
+        if (lfs2_tag_type3(tag) != LFS2_TYPE_DIR) {
+            return LFS2_ERR_NOTDIR;
+        }
+
+        // grab the entry data
+        if (lfs2_tag_id(tag) != 0x3ff) {
+            lfs2_stag_t res = lfs2_dir_get(lfs2, dir, LFS2_MKTAG(0x700, 0x3ff, 0),
+                    LFS2_MKTAG(LFS2_TYPE_STRUCT, lfs2_tag_id(tag), 8), dir->tail);
+            if (res < 0) {
+                return res;
+            }
+            lfs2_pair_fromle32(dir->tail);
+        }
+
+        // find entry matching name
+        while (true) {
+            tag = lfs2_dir_fetchmatch(lfs2, dir, dir->tail,
+                    LFS2_MKTAG(0x780, 0, 0),
+                    LFS2_MKTAG(LFS2_TYPE_NAME, 0, namelen),
+                     // are we last name?
+                    (strchr(name, '/') == NULL) ? id : NULL,
+                    lfs2_dir_find_match, &(struct lfs2_dir_find_match){
+                        lfs2, name, namelen});
+            if (tag < 0) {
+                return tag;
+            }
+
+            if (tag) {
+                break;
+            }
+
+            if (!dir->split) {
+                return LFS2_ERR_NOENT;
+            }
+        }
+
+        // to next name
+        name += namelen;
+    }
+}
+
+// commit logic
+struct lfs2_commit {
+    lfs2_block_t block;
+    lfs2_off_t off;
+    lfs2_tag_t ptag;
+    uint32_t crc;
+
+    lfs2_off_t begin;
+    lfs2_off_t end;
+};
+
+static int lfs2_dir_commitprog(lfs2_t *lfs2, struct lfs2_commit *commit,
+        const void *buffer, lfs2_size_t size) {
+    int err = lfs2_bd_prog(lfs2,
+            &lfs2->pcache, &lfs2->rcache, false,
+            commit->block, commit->off ,
+            (const uint8_t*)buffer, size);
+    if (err) {
+        return err;
+    }
+
+    commit->crc = lfs2_crc(commit->crc, buffer, size);
+    commit->off += size;
+    return 0;
+}
+
+static int lfs2_dir_commitattr(lfs2_t *lfs2, struct lfs2_commit *commit,
+        lfs2_tag_t tag, const void *buffer) {
+    // check if we fit
+    lfs2_size_t dsize = lfs2_tag_dsize(tag);
+    if (commit->off + dsize > commit->end) {
+        return LFS2_ERR_NOSPC;
+    }
+
+    // write out tag
+    lfs2_tag_t ntag = lfs2_tobe32((tag & 0x7fffffff) ^ commit->ptag);
+    int err = lfs2_dir_commitprog(lfs2, commit, &ntag, sizeof(ntag));
+    if (err) {
+        return err;
+    }
+
+    if (!(tag & 0x80000000)) {
+        // from memory
+        err = lfs2_dir_commitprog(lfs2, commit, buffer, dsize-sizeof(tag));
+        if (err) {
+            return err;
+        }
+    } else {
+        // from disk
+        const struct lfs2_diskoff *disk = buffer;
+        for (lfs2_off_t i = 0; i < dsize-sizeof(tag); i++) {
+            // rely on caching to make this efficient
+            uint8_t dat;
+            err = lfs2_bd_read(lfs2,
+                    NULL, &lfs2->rcache, dsize-sizeof(tag)-i,
+                    disk->block, disk->off+i, &dat, 1);
+            if (err) {
+                return err;
+            }
+
+            err = lfs2_dir_commitprog(lfs2, commit, &dat, 1);
+            if (err) {
+                return err;
+            }
+        }
+    }
+
+    commit->ptag = tag & 0x7fffffff;
+    return 0;
+}
+
+static int lfs2_dir_commitcrc(lfs2_t *lfs2, struct lfs2_commit *commit) {
+    const lfs2_off_t off1 = commit->off;
+    const uint32_t crc1 = commit->crc;
+    // align to program units
+    const lfs2_off_t end = lfs2_alignup(off1 + 2*sizeof(uint32_t),
+            lfs2->cfg->prog_size);
+
+    // create crc tags to fill up remainder of commit, note that
+    // padding is not crced, which lets fetches skip padding but
+    // makes committing a bit more complicated
+    while (commit->off < end) {
+        lfs2_off_t off = commit->off + sizeof(lfs2_tag_t);
+        lfs2_off_t noff = lfs2_min(end - off, 0x3fe) + off;
+        if (noff < end) {
+            noff = lfs2_min(noff, end - 2*sizeof(uint32_t));
+        }
+
+        // read erased state from next program unit
+        lfs2_tag_t tag = 0xffffffff;
+        int err = lfs2_bd_read(lfs2,
+                NULL, &lfs2->rcache, sizeof(tag),
+                commit->block, noff, &tag, sizeof(tag));
+        if (err && err != LFS2_ERR_CORRUPT) {
+            return err;
+        }
+
+        // build crc tag
+        bool reset = ~lfs2_frombe32(tag) >> 31;
+        tag = LFS2_MKTAG(LFS2_TYPE_CRC + reset, 0x3ff, noff - off);
+
+        // write out crc
+        uint32_t footer[2];
+        footer[0] = lfs2_tobe32(tag ^ commit->ptag);
+        commit->crc = lfs2_crc(commit->crc, &footer[0], sizeof(footer[0]));
+        footer[1] = lfs2_tole32(commit->crc);
+        err = lfs2_bd_prog(lfs2,
+                &lfs2->pcache, &lfs2->rcache, false,
+                commit->block, commit->off, &footer, sizeof(footer));
+        if (err) {
+            return err;
+        }
+
+        commit->off += sizeof(tag)+lfs2_tag_size(tag);
+        commit->ptag = tag ^ ((lfs2_tag_t)reset << 31);
+        commit->crc = 0xffffffff; // reset crc for next "commit"
+    }
+
+    // flush buffers
+    int err = lfs2_bd_sync(lfs2, &lfs2->pcache, &lfs2->rcache, false);
+    if (err) {
+        return err;
+    }
+
+    // successful commit, check checksums to make sure
+    lfs2_off_t off = commit->begin;
+    lfs2_off_t noff = off1 + sizeof(uint32_t);
+    while (off < end) {
+        uint32_t crc = 0xffffffff;
+        for (lfs2_off_t i = off; i < noff+sizeof(uint32_t); i++) {
+            // check against written crc, may catch blocks that
+            // become readonly and match our commit size exactly
+            if (i == off1 && crc != crc1) {
+                return LFS2_ERR_CORRUPT;
+            }
+
+            // leave it up to caching to make this efficient
+            uint8_t dat;
+            err = lfs2_bd_read(lfs2,
+                    NULL, &lfs2->rcache, noff+sizeof(uint32_t)-i,
+                    commit->block, i, &dat, 1);
+            if (err) {
+                return err;
+            }
+
+            crc = lfs2_crc(crc, &dat, 1);
+        }
+
+        // detected write error?
+        if (crc != 0) {
+            return LFS2_ERR_CORRUPT;
+        }
+
+        // skip padding
+        off = lfs2_min(end - noff, 0x3fe) + noff;
+        if (off < end) {
+            off = lfs2_min(off, end - 2*sizeof(uint32_t));
+        }
+        noff = off + sizeof(uint32_t);
+    }
+
+    return 0;
+}
+
+static int lfs2_dir_alloc(lfs2_t *lfs2, lfs2_mdir_t *dir) {
+    // allocate pair of dir blocks (backwards, so we write block 1 first)
+    for (int i = 0; i < 2; i++) {
+        int err = lfs2_alloc(lfs2, &dir->pair[(i+1)%2]);
+        if (err) {
+            return err;
+        }
+    }
+
+    // zero for reproducability in case initial block is unreadable
+    dir->rev = 0;
+
+    // rather than clobbering one of the blocks we just pretend
+    // the revision may be valid
+    int err = lfs2_bd_read(lfs2,
+            NULL, &lfs2->rcache, sizeof(dir->rev),
+            dir->pair[0], 0, &dir->rev, sizeof(dir->rev));
+    dir->rev = lfs2_fromle32(dir->rev);
+    if (err && err != LFS2_ERR_CORRUPT) {
+        return err;
+    }
+
+    // make sure we don't immediately evict
+    dir->rev += dir->rev & 1;
+
+    // set defaults
+    dir->off = sizeof(dir->rev);
+    dir->etag = 0xffffffff;
+    dir->count = 0;
+    dir->tail[0] = LFS2_BLOCK_NULL;
+    dir->tail[1] = LFS2_BLOCK_NULL;
+    dir->erased = false;
+    dir->split = false;
+
+    // don't write out yet, let caller take care of that
+    return 0;
+}
+
+static int lfs2_dir_drop(lfs2_t *lfs2, lfs2_mdir_t *dir, lfs2_mdir_t *tail) {
+    // steal state
+    int err = lfs2_dir_getgstate(lfs2, tail, &lfs2->gdelta);
+    if (err) {
+        return err;
+    }
+
+    // steal tail
+    lfs2_pair_tole32(tail->tail);
+    err = lfs2_dir_commit(lfs2, dir, LFS2_MKATTRS(
+            {LFS2_MKTAG(LFS2_TYPE_TAIL + tail->split, 0x3ff, 8), tail->tail}));
+    lfs2_pair_fromle32(tail->tail);
+    if (err) {
+        return err;
+    }
+
+    return 0;
+}
+
+static int lfs2_dir_split(lfs2_t *lfs2,
+        lfs2_mdir_t *dir, const struct lfs2_mattr *attrs, int attrcount,
+        lfs2_mdir_t *source, uint16_t split, uint16_t end) {
+    // create tail directory
+    lfs2_alloc_ack(lfs2);
+    lfs2_mdir_t tail;
+    int err = lfs2_dir_alloc(lfs2, &tail);
+    if (err) {
+        return err;
+    }
+
+    tail.split = dir->split;
+    tail.tail[0] = dir->tail[0];
+    tail.tail[1] = dir->tail[1];
+
+    err = lfs2_dir_compact(lfs2, &tail, attrs, attrcount, source, split, end);
+    if (err) {
+        return err;
+    }
+
+    dir->tail[0] = tail.pair[0];
+    dir->tail[1] = tail.pair[1];
+    dir->split = true;
+
+    // update root if needed
+    if (lfs2_pair_cmp(dir->pair, lfs2->root) == 0 && split == 0) {
+        lfs2->root[0] = tail.pair[0];
+        lfs2->root[1] = tail.pair[1];
+    }
+
+    return 0;
+}
+
+static int lfs2_dir_commit_size(void *p, lfs2_tag_t tag, const void *buffer) {
+    lfs2_size_t *size = p;
+    (void)buffer;
+
+    *size += lfs2_tag_dsize(tag);
+    return 0;
+}
+
+struct lfs2_dir_commit_commit {
+    lfs2_t *lfs2;
+    struct lfs2_commit *commit;
+};
+
+static int lfs2_dir_commit_commit(void *p, lfs2_tag_t tag, const void *buffer) {
+    struct lfs2_dir_commit_commit *commit = p;
+    return lfs2_dir_commitattr(commit->lfs2, commit->commit, tag, buffer);
+}
+
+static int lfs2_dir_compact(lfs2_t *lfs2,
+        lfs2_mdir_t *dir, const struct lfs2_mattr *attrs, int attrcount,
+        lfs2_mdir_t *source, uint16_t begin, uint16_t end) {
+    // save some state in case block is bad
+    const lfs2_block_t oldpair[2] = {dir->pair[0], dir->pair[1]};
+    bool relocated = false;
+    bool tired = false;
+
+    // should we split?
+    while (end - begin > 1) {
+        // find size
+        lfs2_size_t size = 0;
+        int err = lfs2_dir_traverse(lfs2,
+                source, 0, 0xffffffff, attrs, attrcount,
+                LFS2_MKTAG(0x400, 0x3ff, 0),
+                LFS2_MKTAG(LFS2_TYPE_NAME, 0, 0),
+                begin, end, -begin,
+                lfs2_dir_commit_size, &size);
+        if (err) {
+            return err;
+        }
+
+        // space is complicated, we need room for tail, crc, gstate,
+        // cleanup delete, and we cap at half a block to give room
+        // for metadata updates.
+        if (end - begin < 0xff &&
+                size <= lfs2_min(lfs2->cfg->block_size - 36,
+                    lfs2_alignup(lfs2->cfg->block_size/2,
+                        lfs2->cfg->prog_size))) {
+            break;
+        }
+
+        // can't fit, need to split, we should really be finding the
+        // largest size that fits with a small binary search, but right now
+        // it's not worth the code size
+        uint16_t split = (end - begin) / 2;
+        err = lfs2_dir_split(lfs2, dir, attrs, attrcount,
+                source, begin+split, end);
+        if (err) {
+            // if we fail to split, we may be able to overcompact, unless
+            // we're too big for even the full block, in which case our
+            // only option is to error
+            if (err == LFS2_ERR_NOSPC && size <= lfs2->cfg->block_size - 36) {
+                break;
+            }
+            return err;
+        }
+
+        end = begin + split;
+    }
+
+    // increment revision count
+    dir->rev += 1;
+    // If our revision count == n * block_cycles, we should force a relocation,
+    // this is how littlefs wear-levels at the metadata-pair level. Note that we
+    // actually use (block_cycles+1)|1, this is to avoid two corner cases:
+    // 1. block_cycles = 1, which would prevent relocations from terminating
+    // 2. block_cycles = 2n, which, due to aliasing, would only ever relocate
+    //    one metadata block in the pair, effectively making this useless
+    if (lfs2->cfg->block_cycles > 0 &&
+            (dir->rev % ((lfs2->cfg->block_cycles+1)|1) == 0)) {
+        if (lfs2_pair_cmp(dir->pair, (const lfs2_block_t[2]){0, 1}) == 0) {
+            // oh no! we're writing too much to the superblock,
+            // should we expand?
+            lfs2_ssize_t res = lfs2_fs_size(lfs2);
+            if (res < 0) {
+                return res;
+            }
+
+            // do we have extra space? littlefs can't reclaim this space
+            // by itself, so expand cautiously
+            if ((lfs2_size_t)res < lfs2->cfg->block_count/2) {
+                LFS2_DEBUG("Expanding superblock at rev %"PRIu32, dir->rev);
+                int err = lfs2_dir_split(lfs2, dir, attrs, attrcount,
+                        source, begin, end);
+                if (err && err != LFS2_ERR_NOSPC) {
+                    return err;
+                }
+
+                // welp, we tried, if we ran out of space there's not much
+                // we can do, we'll error later if we've become frozen
+                if (!err) {
+                    end = begin;
+                }
+            }
+#ifdef LFS2_MIGRATE
+        } else if (lfs2->lfs21) {
+            // do not proactively relocate blocks during migrations, this
+            // can cause a number of failure states such: clobbering the
+            // v1 superblock if we relocate root, and invalidating directory
+            // pointers if we relocate the head of a directory. On top of
+            // this, relocations increase the overall complexity of
+            // lfs2_migration, which is already a delicate operation.
+#endif
+        } else {
+            // we're writing too much, time to relocate
+            tired = true;
+            goto relocate;
+        }
+    }
+
+    // begin loop to commit compaction to blocks until a compact sticks
+    while (true) {
+        {
+            // setup commit state
+            struct lfs2_commit commit = {
+                .block = dir->pair[1],
+                .off = 0,
+                .ptag = 0xffffffff,
+                .crc = 0xffffffff,
+
+                .begin = 0,
+                .end = lfs2->cfg->block_size - 8,
+            };
+
+            // erase block to write to
+            int err = lfs2_bd_erase(lfs2, dir->pair[1]);
+            if (err) {
+                if (err == LFS2_ERR_CORRUPT) {
+                    goto relocate;
+                }
+                return err;
+            }
+
+            // write out header
+            dir->rev = lfs2_tole32(dir->rev);
+            err = lfs2_dir_commitprog(lfs2, &commit,
+                    &dir->rev, sizeof(dir->rev));
+            dir->rev = lfs2_fromle32(dir->rev);
+            if (err) {
+                if (err == LFS2_ERR_CORRUPT) {
+                    goto relocate;
+                }
+                return err;
+            }
+
+            // traverse the directory, this time writing out all unique tags
+            err = lfs2_dir_traverse(lfs2,
+                    source, 0, 0xffffffff, attrs, attrcount,
+                    LFS2_MKTAG(0x400, 0x3ff, 0),
+                    LFS2_MKTAG(LFS2_TYPE_NAME, 0, 0),
+                    begin, end, -begin,
+                    lfs2_dir_commit_commit, &(struct lfs2_dir_commit_commit){
+                        lfs2, &commit});
+            if (err) {
+                if (err == LFS2_ERR_CORRUPT) {
+                    goto relocate;
+                }
+                return err;
+            }
+
+            // commit tail, which may be new after last size check
+            if (!lfs2_pair_isnull(dir->tail)) {
+                lfs2_pair_tole32(dir->tail);
+                err = lfs2_dir_commitattr(lfs2, &commit,
+                        LFS2_MKTAG(LFS2_TYPE_TAIL + dir->split, 0x3ff, 8),
+                        dir->tail);
+                lfs2_pair_fromle32(dir->tail);
+                if (err) {
+                    if (err == LFS2_ERR_CORRUPT) {
+                        goto relocate;
+                    }
+                    return err;
+                }
+            }
+
+            // bring over gstate?
+            lfs2_gstate_t delta = {0};
+            if (!relocated) {
+                lfs2_gstate_xor(&delta, &lfs2->gdisk);
+                lfs2_gstate_xor(&delta, &lfs2->gstate);
+            }
+            lfs2_gstate_xor(&delta, &lfs2->gdelta);
+            delta.tag &= ~LFS2_MKTAG(0, 0, 0x3ff);
+
+            err = lfs2_dir_getgstate(lfs2, dir, &delta);
+            if (err) {
+                return err;
+            }
+
+            if (!lfs2_gstate_iszero(&delta)) {
+                lfs2_gstate_tole32(&delta);
+                err = lfs2_dir_commitattr(lfs2, &commit,
+                        LFS2_MKTAG(LFS2_TYPE_MOVESTATE, 0x3ff,
+                            sizeof(delta)), &delta);
+                if (err) {
+                    if (err == LFS2_ERR_CORRUPT) {
+                        goto relocate;
+                    }
+                    return err;
+                }
+            }
+
+            // complete commit with crc
+            err = lfs2_dir_commitcrc(lfs2, &commit);
+            if (err) {
+                if (err == LFS2_ERR_CORRUPT) {
+                    goto relocate;
+                }
+                return err;
+            }
+
+            // successful compaction, swap dir pair to indicate most recent
+            LFS2_ASSERT(commit.off % lfs2->cfg->prog_size == 0);
+            lfs2_pair_swap(dir->pair);
+            dir->count = end - begin;
+            dir->off = commit.off;
+            dir->etag = commit.ptag;
+            // update gstate
+            lfs2->gdelta = (lfs2_gstate_t){0};
+            if (!relocated) {
+                lfs2->gdisk = lfs2->gstate;
+            }
+        }
+        break;
+
+relocate:
+        // commit was corrupted, drop caches and prepare to relocate block
+        relocated = true;
+        lfs2_cache_drop(lfs2, &lfs2->pcache);
+        if (!tired) {
+            LFS2_DEBUG("Bad block at 0x%"PRIx32, dir->pair[1]);
+        }
+
+        // can't relocate superblock, filesystem is now frozen
+        if (lfs2_pair_cmp(dir->pair, (const lfs2_block_t[2]){0, 1}) == 0) {
+            LFS2_WARN("Superblock 0x%"PRIx32" has become unwritable",
+                    dir->pair[1]);
+            return LFS2_ERR_NOSPC;
+        }
+
+        // relocate half of pair
+        int err = lfs2_alloc(lfs2, &dir->pair[1]);
+        if (err && (err != LFS2_ERR_NOSPC || !tired)) {
+            return err;
+        }
+
+        tired = false;
+        continue;
+    }
+
+    if (relocated) {
+        // update references if we relocated
+        LFS2_DEBUG("Relocating {0x%"PRIx32", 0x%"PRIx32"} "
+                    "-> {0x%"PRIx32", 0x%"PRIx32"}",
+                oldpair[0], oldpair[1], dir->pair[0], dir->pair[1]);
+        int err = lfs2_fs_relocate(lfs2, oldpair, dir->pair);
+        if (err) {
+            return err;
+        }
+    }
+
+    return 0;
+}
+
+static int lfs2_dir_commit(lfs2_t *lfs2, lfs2_mdir_t *dir,
+        const struct lfs2_mattr *attrs, int attrcount) {
+    // check for any inline files that aren't RAM backed and
+    // forcefully evict them, needed for filesystem consistency
+    for (lfs2_file_t *f = (lfs2_file_t*)lfs2->mlist; f; f = f->next) {
+        if (dir != &f->m && lfs2_pair_cmp(f->m.pair, dir->pair) == 0 &&
+                f->type == LFS2_TYPE_REG && (f->flags & LFS2_F_INLINE) &&
+                f->ctz.size > lfs2->cfg->cache_size) {
+            int err = lfs2_file_outline(lfs2, f);
+            if (err) {
+                return err;
+            }
+
+            err = lfs2_file_flush(lfs2, f);
+            if (err) {
+                return err;
+            }
+        }
+    }
+
+    // calculate changes to the directory
+    lfs2_mdir_t olddir = *dir;
+    bool hasdelete = false;
+    for (int i = 0; i < attrcount; i++) {
+        if (lfs2_tag_type3(attrs[i].tag) == LFS2_TYPE_CREATE) {
+            dir->count += 1;
+        } else if (lfs2_tag_type3(attrs[i].tag) == LFS2_TYPE_DELETE) {
+            LFS2_ASSERT(dir->count > 0);
+            dir->count -= 1;
+            hasdelete = true;
+        } else if (lfs2_tag_type1(attrs[i].tag) == LFS2_TYPE_TAIL) {
+            dir->tail[0] = ((lfs2_block_t*)attrs[i].buffer)[0];
+            dir->tail[1] = ((lfs2_block_t*)attrs[i].buffer)[1];
+            dir->split = (lfs2_tag_chunk(attrs[i].tag) & 1);
+            lfs2_pair_fromle32(dir->tail);
+        }
+    }
+
+    // should we actually drop the directory block?
+    if (hasdelete && dir->count == 0) {
+        lfs2_mdir_t pdir;
+        int err = lfs2_fs_pred(lfs2, dir->pair, &pdir);
+        if (err && err != LFS2_ERR_NOENT) {
+            *dir = olddir;
+            return err;
+        }
+
+        if (err != LFS2_ERR_NOENT && pdir.split) {
+            err = lfs2_dir_drop(lfs2, &pdir, dir);
+            if (err) {
+                *dir = olddir;
+                return err;
+            }
+        }
+    }
+
+    if (dir->erased || dir->count >= 0xff) {
+        // try to commit
+        struct lfs2_commit commit = {
+            .block = dir->pair[0],
+            .off = dir->off,
+            .ptag = dir->etag,
+            .crc = 0xffffffff,
+
+            .begin = dir->off,
+            .end = lfs2->cfg->block_size - 8,
+        };
+
+        // traverse attrs that need to be written out
+        lfs2_pair_tole32(dir->tail);
+        int err = lfs2_dir_traverse(lfs2,
+                dir, dir->off, dir->etag, attrs, attrcount,
+                0, 0, 0, 0, 0,
+                lfs2_dir_commit_commit, &(struct lfs2_dir_commit_commit){
+                    lfs2, &commit});
+        lfs2_pair_fromle32(dir->tail);
+        if (err) {
+            if (err == LFS2_ERR_NOSPC || err == LFS2_ERR_CORRUPT) {
+                goto compact;
+            }
+            *dir = olddir;
+            return err;
+        }
+
+        // commit any global diffs if we have any
+        lfs2_gstate_t delta = {0};
+        lfs2_gstate_xor(&delta, &lfs2->gstate);
+        lfs2_gstate_xor(&delta, &lfs2->gdisk);
+        lfs2_gstate_xor(&delta, &lfs2->gdelta);
+        delta.tag &= ~LFS2_MKTAG(0, 0, 0x3ff);
+        if (!lfs2_gstate_iszero(&delta)) {
+            err = lfs2_dir_getgstate(lfs2, dir, &delta);
+            if (err) {
+                *dir = olddir;
+                return err;
+            }
+
+            lfs2_gstate_tole32(&delta);
+            err = lfs2_dir_commitattr(lfs2, &commit,
+                    LFS2_MKTAG(LFS2_TYPE_MOVESTATE, 0x3ff,
+                        sizeof(delta)), &delta);
+            if (err) {
+                if (err == LFS2_ERR_NOSPC || err == LFS2_ERR_CORRUPT) {
+                    goto compact;
+                }
+                *dir = olddir;
+                return err;
+            }
+        }
+
+        // finalize commit with the crc
+        err = lfs2_dir_commitcrc(lfs2, &commit);
+        if (err) {
+            if (err == LFS2_ERR_NOSPC || err == LFS2_ERR_CORRUPT) {
+                goto compact;
+            }
+            *dir = olddir;
+            return err;
+        }
+
+        // successful commit, update dir
+        LFS2_ASSERT(commit.off % lfs2->cfg->prog_size == 0);
+        dir->off = commit.off;
+        dir->etag = commit.ptag;
+        // and update gstate
+        lfs2->gdisk = lfs2->gstate;
+        lfs2->gdelta = (lfs2_gstate_t){0};
+    } else {
+compact:
+        // fall back to compaction
+        lfs2_cache_drop(lfs2, &lfs2->pcache);
+
+        int err = lfs2_dir_compact(lfs2, dir, attrs, attrcount,
+                dir, 0, dir->count);
+        if (err) {
+            *dir = olddir;
+            return err;
+        }
+    }
+
+    // this complicated bit of logic is for fixing up any active
+    // metadata-pairs that we may have affected
+    //
+    // note we have to make two passes since the mdir passed to
+    // lfs2_dir_commit could also be in this list, and even then
+    // we need to copy the pair so they don't get clobbered if we refetch
+    // our mdir.
+    for (struct lfs2_mlist *d = lfs2->mlist; d; d = d->next) {
+        if (&d->m != dir && lfs2_pair_cmp(d->m.pair, olddir.pair) == 0) {
+            d->m = *dir;
+            for (int i = 0; i < attrcount; i++) {
+                if (lfs2_tag_type3(attrs[i].tag) == LFS2_TYPE_DELETE &&
+                        d->id == lfs2_tag_id(attrs[i].tag)) {
+                    d->m.pair[0] = LFS2_BLOCK_NULL;
+                    d->m.pair[1] = LFS2_BLOCK_NULL;
+                } else if (lfs2_tag_type3(attrs[i].tag) == LFS2_TYPE_DELETE &&
+                        d->id > lfs2_tag_id(attrs[i].tag)) {
+                    d->id -= 1;
+                    if (d->type == LFS2_TYPE_DIR) {
+                        ((lfs2_dir_t*)d)->pos -= 1;
+                    }
+                } else if (lfs2_tag_type3(attrs[i].tag) == LFS2_TYPE_CREATE &&
+                        d->id >= lfs2_tag_id(attrs[i].tag)) {
+                    d->id += 1;
+                    if (d->type == LFS2_TYPE_DIR) {
+                        ((lfs2_dir_t*)d)->pos += 1;
+                    }
+                }
+            }
+        }
+    }
+
+    for (struct lfs2_mlist *d = lfs2->mlist; d; d = d->next) {
+        if (lfs2_pair_cmp(d->m.pair, olddir.pair) == 0) {
+            while (d->id >= d->m.count && d->m.split) {
+                // we split and id is on tail now
+                d->id -= d->m.count;
+                int err = lfs2_dir_fetch(lfs2, &d->m, d->m.tail);
+                if (err) {
+                    return err;
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+
+/// Top level directory operations ///
+int lfs2_mkdir(lfs2_t *lfs2, const char *path) {
+    LFS2_TRACE("lfs2_mkdir(%p, \"%s\")", (void*)lfs2, path);
+    // deorphan if we haven't yet, needed at most once after poweron
+    int err = lfs2_fs_forceconsistency(lfs2);
+    if (err) {
+        LFS2_TRACE("lfs2_mkdir -> %d", err);
+        return err;
+    }
+
+    struct lfs2_mlist cwd;
+    cwd.next = lfs2->mlist;
+    uint16_t id;
+    err = lfs2_dir_find(lfs2, &cwd.m, &path, &id);
+    if (!(err == LFS2_ERR_NOENT && id != 0x3ff)) {
+        LFS2_TRACE("lfs2_mkdir -> %d", (err < 0) ? err : LFS2_ERR_EXIST);
+        return (err < 0) ? err : LFS2_ERR_EXIST;
+    }
+
+    // check that name fits
+    lfs2_size_t nlen = strlen(path);
+    if (nlen > lfs2->name_max) {
+        LFS2_TRACE("lfs2_mkdir -> %d", LFS2_ERR_NAMETOOLONG);
+        return LFS2_ERR_NAMETOOLONG;
+    }
+
+    // build up new directory
+    lfs2_alloc_ack(lfs2);
+    lfs2_mdir_t dir;
+    err = lfs2_dir_alloc(lfs2, &dir);
+    if (err) {
+        LFS2_TRACE("lfs2_mkdir -> %d", err);
+        return err;
+    }
+
+    // find end of list
+    lfs2_mdir_t pred = cwd.m;
+    while (pred.split) {
+        err = lfs2_dir_fetch(lfs2, &pred, pred.tail);
+        if (err) {
+            LFS2_TRACE("lfs2_mkdir -> %d", err);
+            return err;
+        }
+    }
+
+    // setup dir
+    lfs2_pair_tole32(pred.tail);
+    err = lfs2_dir_commit(lfs2, &dir, LFS2_MKATTRS(
+            {LFS2_MKTAG(LFS2_TYPE_SOFTTAIL, 0x3ff, 8), pred.tail}));
+    lfs2_pair_fromle32(pred.tail);
+    if (err) {
+        LFS2_TRACE("lfs2_mkdir -> %d", err);
+        return err;
+    }
+
+    // current block end of list?
+    if (cwd.m.split) {
+        // update tails, this creates a desync
+        lfs2_fs_preporphans(lfs2, +1);
+
+        // it's possible our predecessor has to be relocated, and if
+        // our parent is our predecessor's predecessor, this could have
+        // caused our parent to go out of date, fortunately we can hook
+        // ourselves into littlefs to catch this
+        cwd.type = 0;
+        cwd.id = 0;
+        lfs2->mlist = &cwd;
+
+        lfs2_pair_tole32(dir.pair);
+        err = lfs2_dir_commit(lfs2, &pred, LFS2_MKATTRS(
+                {LFS2_MKTAG(LFS2_TYPE_SOFTTAIL, 0x3ff, 8), dir.pair}));
+        lfs2_pair_fromle32(dir.pair);
+        if (err) {
+            lfs2->mlist = cwd.next;
+            LFS2_TRACE("lfs2_mkdir -> %d", err);
+            return err;
+        }
+
+        lfs2->mlist = cwd.next;
+        lfs2_fs_preporphans(lfs2, -1);
+    }
+
+    // now insert into our parent block
+    lfs2_pair_tole32(dir.pair);
+    err = lfs2_dir_commit(lfs2, &cwd.m, LFS2_MKATTRS(
+            {LFS2_MKTAG(LFS2_TYPE_CREATE, id, 0), NULL},
+            {LFS2_MKTAG(LFS2_TYPE_DIR, id, nlen), path},
+            {LFS2_MKTAG(LFS2_TYPE_DIRSTRUCT, id, 8), dir.pair},
+            {LFS2_MKTAG_IF(!cwd.m.split,
+                LFS2_TYPE_SOFTTAIL, 0x3ff, 8), dir.pair}));
+    lfs2_pair_fromle32(dir.pair);
+    if (err) {
+        LFS2_TRACE("lfs2_mkdir -> %d", err);
+        return err;
+    }
+
+    LFS2_TRACE("lfs2_mkdir -> %d", 0);
+    return 0;
+}
+
+int lfs2_dir_open(lfs2_t *lfs2, lfs2_dir_t *dir, const char *path) {
+    LFS2_TRACE("lfs2_dir_open(%p, %p, \"%s\")", (void*)lfs2, (void*)dir, path);
+    lfs2_stag_t tag = lfs2_dir_find(lfs2, &dir->m, &path, NULL);
+    if (tag < 0) {
+        LFS2_TRACE("lfs2_dir_open -> %"PRId32, tag);
+        return tag;
+    }
+
+    if (lfs2_tag_type3(tag) != LFS2_TYPE_DIR) {
+        LFS2_TRACE("lfs2_dir_open -> %d", LFS2_ERR_NOTDIR);
+        return LFS2_ERR_NOTDIR;
+    }
+
+    lfs2_block_t pair[2];
+    if (lfs2_tag_id(tag) == 0x3ff) {
+        // handle root dir separately
+        pair[0] = lfs2->root[0];
+        pair[1] = lfs2->root[1];
+    } else {
+        // get dir pair from parent
+        lfs2_stag_t res = lfs2_dir_get(lfs2, &dir->m, LFS2_MKTAG(0x700, 0x3ff, 0),
+                LFS2_MKTAG(LFS2_TYPE_STRUCT, lfs2_tag_id(tag), 8), pair);
+        if (res < 0) {
+            LFS2_TRACE("lfs2_dir_open -> %"PRId32, res);
+            return res;
+        }
+        lfs2_pair_fromle32(pair);
+    }
+
+    // fetch first pair
+    int err = lfs2_dir_fetch(lfs2, &dir->m, pair);
+    if (err) {
+        LFS2_TRACE("lfs2_dir_open -> %d", err);
+        return err;
+    }
+
+    // setup entry
+    dir->head[0] = dir->m.pair[0];
+    dir->head[1] = dir->m.pair[1];
+    dir->id = 0;
+    dir->pos = 0;
+
+    // add to list of mdirs
+    dir->type = LFS2_TYPE_DIR;
+    dir->next = (lfs2_dir_t*)lfs2->mlist;
+    lfs2->mlist = (struct lfs2_mlist*)dir;
+
+    LFS2_TRACE("lfs2_dir_open -> %d", 0);
+    return 0;
+}
+
+int lfs2_dir_close(lfs2_t *lfs2, lfs2_dir_t *dir) {
+    LFS2_TRACE("lfs2_dir_close(%p, %p)", (void*)lfs2, (void*)dir);
+    // remove from list of mdirs
+    for (struct lfs2_mlist **p = &lfs2->mlist; *p; p = &(*p)->next) {
+        if (*p == (struct lfs2_mlist*)dir) {
+            *p = (*p)->next;
+            break;
+        }
+    }
+
+    LFS2_TRACE("lfs2_dir_close -> %d", 0);
+    return 0;
+}
+
+int lfs2_dir_read(lfs2_t *lfs2, lfs2_dir_t *dir, struct lfs2_info *info) {
+    LFS2_TRACE("lfs2_dir_read(%p, %p, %p)",
+            (void*)lfs2, (void*)dir, (void*)info);
+    memset(info, 0, sizeof(*info));
+
+    // special offset for '.' and '..'
+    if (dir->pos == 0) {
+        info->type = LFS2_TYPE_DIR;
+        strcpy(info->name, ".");
+        dir->pos += 1;
+        LFS2_TRACE("lfs2_dir_read -> %d", true);
+        return true;
+    } else if (dir->pos == 1) {
+        info->type = LFS2_TYPE_DIR;
+        strcpy(info->name, "..");
+        dir->pos += 1;
+        LFS2_TRACE("lfs2_dir_read -> %d", true);
+        return true;
+    }
+
+    while (true) {
+        if (dir->id == dir->m.count) {
+            if (!dir->m.split) {
+                LFS2_TRACE("lfs2_dir_read -> %d", false);
+                return false;
+            }
+
+            int err = lfs2_dir_fetch(lfs2, &dir->m, dir->m.tail);
+            if (err) {
+                LFS2_TRACE("lfs2_dir_read -> %d", err);
+                return err;
+            }
+
+            dir->id = 0;
+        }
+
+        int err = lfs2_dir_getinfo(lfs2, &dir->m, dir->id, info);
+        if (err && err != LFS2_ERR_NOENT) {
+            LFS2_TRACE("lfs2_dir_read -> %d", err);
+            return err;
+        }
+
+        dir->id += 1;
+        if (err != LFS2_ERR_NOENT) {
+            break;
+        }
+    }
+
+    dir->pos += 1;
+    LFS2_TRACE("lfs2_dir_read -> %d", true);
+    return true;
+}
+
+int lfs2_dir_seek(lfs2_t *lfs2, lfs2_dir_t *dir, lfs2_off_t off) {
+    LFS2_TRACE("lfs2_dir_seek(%p, %p, %"PRIu32")",
+            (void*)lfs2, (void*)dir, off);
+    // simply walk from head dir
+    int err = lfs2_dir_rewind(lfs2, dir);
+    if (err) {
+        LFS2_TRACE("lfs2_dir_seek -> %d", err);
+        return err;
+    }
+
+    // first two for ./..
+    dir->pos = lfs2_min(2, off);
+    off -= dir->pos;
+
+    // skip superblock entry
+    dir->id = (off > 0 && lfs2_pair_cmp(dir->head, lfs2->root) == 0);
+
+    while (off > 0) {
+        int diff = lfs2_min(dir->m.count - dir->id, off);
+        dir->id += diff;
+        dir->pos += diff;
+        off -= diff;
+
+        if (dir->id == dir->m.count) {
+            if (!dir->m.split) {
+                LFS2_TRACE("lfs2_dir_seek -> %d", LFS2_ERR_INVAL);
+                return LFS2_ERR_INVAL;
+            }
+
+            err = lfs2_dir_fetch(lfs2, &dir->m, dir->m.tail);
+            if (err) {
+                LFS2_TRACE("lfs2_dir_seek -> %d", err);
+                return err;
+            }
+
+            dir->id = 0;
+        }
+    }
+
+    LFS2_TRACE("lfs2_dir_seek -> %d", 0);
+    return 0;
+}
+
+lfs2_soff_t lfs2_dir_tell(lfs2_t *lfs2, lfs2_dir_t *dir) {
+    LFS2_TRACE("lfs2_dir_tell(%p, %p)", (void*)lfs2, (void*)dir);
+    (void)lfs2;
+    LFS2_TRACE("lfs2_dir_tell -> %"PRId32, dir->pos);
+    return dir->pos;
+}
+
+int lfs2_dir_rewind(lfs2_t *lfs2, lfs2_dir_t *dir) {
+    LFS2_TRACE("lfs2_dir_rewind(%p, %p)", (void*)lfs2, (void*)dir);
+    // reload the head dir
+    int err = lfs2_dir_fetch(lfs2, &dir->m, dir->head);
+    if (err) {
+        LFS2_TRACE("lfs2_dir_rewind -> %d", err);
+        return err;
+    }
+
+    dir->id = 0;
+    dir->pos = 0;
+    LFS2_TRACE("lfs2_dir_rewind -> %d", 0);
+    return 0;
+}
+
+
+/// File index list operations ///
+static int lfs2_ctz_index(lfs2_t *lfs2, lfs2_off_t *off) {
+    lfs2_off_t size = *off;
+    lfs2_off_t b = lfs2->cfg->block_size - 2*4;
+    lfs2_off_t i = size / b;
+    if (i == 0) {
+        return 0;
+    }
+
+    i = (size - 4*(lfs2_popc(i-1)+2)) / b;
+    *off = size - b*i - 4*lfs2_popc(i);
+    return i;
+}
+
+static int lfs2_ctz_find(lfs2_t *lfs2,
+        const lfs2_cache_t *pcache, lfs2_cache_t *rcache,
+        lfs2_block_t head, lfs2_size_t size,
+        lfs2_size_t pos, lfs2_block_t *block, lfs2_off_t *off) {
+    if (size == 0) {
+        *block = LFS2_BLOCK_NULL;
+        *off = 0;
+        return 0;
+    }
+
+    lfs2_off_t current = lfs2_ctz_index(lfs2, &(lfs2_off_t){size-1});
+    lfs2_off_t target = lfs2_ctz_index(lfs2, &pos);
+
+    while (current > target) {
+        lfs2_size_t skip = lfs2_min(
+                lfs2_npw2(current-target+1) - 1,
+                lfs2_ctz(current));
+
+        int err = lfs2_bd_read(lfs2,
+                pcache, rcache, sizeof(head),
+                head, 4*skip, &head, sizeof(head));
+        head = lfs2_fromle32(head);
+        if (err) {
+            return err;
+        }
+
+        current -= 1 << skip;
+    }
+
+    *block = head;
+    *off = pos;
+    return 0;
+}
+
+static int lfs2_ctz_extend(lfs2_t *lfs2,
+        lfs2_cache_t *pcache, lfs2_cache_t *rcache,
+        lfs2_block_t head, lfs2_size_t size,
+        lfs2_block_t *block, lfs2_off_t *off) {
+    while (true) {
+        // go ahead and grab a block
+        lfs2_block_t nblock;
+        int err = lfs2_alloc(lfs2, &nblock);
+        if (err) {
+            return err;
+        }
+
+        {
+            err = lfs2_bd_erase(lfs2, nblock);
+            if (err) {
+                if (err == LFS2_ERR_CORRUPT) {
+                    goto relocate;
+                }
+                return err;
+            }
+
+            if (size == 0) {
+                *block = nblock;
+                *off = 0;
+                return 0;
+            }
+
+            lfs2_size_t noff = size - 1;
+            lfs2_off_t index = lfs2_ctz_index(lfs2, &noff);
+            noff = noff + 1;
+
+            // just copy out the last block if it is incomplete
+            if (noff != lfs2->cfg->block_size) {
+                for (lfs2_off_t i = 0; i < noff; i++) {
+                    uint8_t data;
+                    err = lfs2_bd_read(lfs2,
+                            NULL, rcache, noff-i,
+                            head, i, &data, 1);
+                    if (err) {
+                        return err;
+                    }
+
+                    err = lfs2_bd_prog(lfs2,
+                            pcache, rcache, true,
+                            nblock, i, &data, 1);
+                    if (err) {
+                        if (err == LFS2_ERR_CORRUPT) {
+                            goto relocate;
+                        }
+                        return err;
+                    }
+                }
+
+                *block = nblock;
+                *off = noff;
+                return 0;
+            }
+
+            // append block
+            index += 1;
+            lfs2_size_t skips = lfs2_ctz(index) + 1;
+            lfs2_block_t nhead = head;
+            for (lfs2_off_t i = 0; i < skips; i++) {
+                nhead = lfs2_tole32(nhead);
+                err = lfs2_bd_prog(lfs2, pcache, rcache, true,
+                        nblock, 4*i, &nhead, 4);
+                nhead = lfs2_fromle32(nhead);
+                if (err) {
+                    if (err == LFS2_ERR_CORRUPT) {
+                        goto relocate;
+                    }
+                    return err;
+                }
+
+                if (i != skips-1) {
+                    err = lfs2_bd_read(lfs2,
+                            NULL, rcache, sizeof(nhead),
+                            nhead, 4*i, &nhead, sizeof(nhead));
+                    nhead = lfs2_fromle32(nhead);
+                    if (err) {
+                        return err;
+                    }
+                }
+            }
+
+            *block = nblock;
+            *off = 4*skips;
+            return 0;
+        }
+
+relocate:
+        LFS2_DEBUG("Bad block at 0x%"PRIx32, nblock);
+
+        // just clear cache and try a new block
+        lfs2_cache_drop(lfs2, pcache);
+    }
+}
+
+static int lfs2_ctz_traverse(lfs2_t *lfs2,
+        const lfs2_cache_t *pcache, lfs2_cache_t *rcache,
+        lfs2_block_t head, lfs2_size_t size,
+        int (*cb)(void*, lfs2_block_t), void *data) {
+    if (size == 0) {
+        return 0;
+    }
+
+    lfs2_off_t index = lfs2_ctz_index(lfs2, &(lfs2_off_t){size-1});
+
+    while (true) {
+        int err = cb(data, head);
+        if (err) {
+            return err;
+        }
+
+        if (index == 0) {
+            return 0;
+        }
+
+        lfs2_block_t heads[2];
+        int count = 2 - (index & 1);
+        err = lfs2_bd_read(lfs2,
+                pcache, rcache, count*sizeof(head),
+                head, 0, &heads, count*sizeof(head));
+        heads[0] = lfs2_fromle32(heads[0]);
+        heads[1] = lfs2_fromle32(heads[1]);
+        if (err) {
+            return err;
+        }
+
+        for (int i = 0; i < count-1; i++) {
+            err = cb(data, heads[i]);
+            if (err) {
+                return err;
+            }
+        }
+
+        head = heads[count-1];
+        index -= count;
+    }
+}
+
+
+/// Top level file operations ///
+int lfs2_file_opencfg(lfs2_t *lfs2, lfs2_file_t *file,
+        const char *path, int flags,
+        const struct lfs2_file_config *cfg) {
+    LFS2_TRACE("lfs2_file_opencfg(%p, %p, \"%s\", %x, %p {"
+                 ".buffer=%p, .attrs=%p, .attr_count=%"PRIu32"})",
+            (void*)lfs2, (void*)file, path, flags,
+            (void*)cfg, cfg->buffer, (void*)cfg->attrs, cfg->attr_count);
+
+    // deorphan if we haven't yet, needed at most once after poweron
+    if ((flags & 3) != LFS2_O_RDONLY) {
+        int err = lfs2_fs_forceconsistency(lfs2);
+        if (err) {
+            LFS2_TRACE("lfs2_file_opencfg -> %d", err);
+            return err;
+        }
+    }
+
+    // setup simple file details
+    int err;
+    file->cfg = cfg;
+    file->flags = flags | LFS2_F_OPENED;
+    file->pos = 0;
+    file->off = 0;
+    file->cache.buffer = NULL;
+
+    // allocate entry for file if it doesn't exist
+    lfs2_stag_t tag = lfs2_dir_find(lfs2, &file->m, &path, &file->id);
+    if (tag < 0 && !(tag == LFS2_ERR_NOENT && file->id != 0x3ff)) {
+        err = tag;
+        goto cleanup;
+    }
+
+    // get id, add to list of mdirs to catch update changes
+    file->type = LFS2_TYPE_REG;
+    file->next = (lfs2_file_t*)lfs2->mlist;
+    lfs2->mlist = (struct lfs2_mlist*)file;
+
+    if (tag == LFS2_ERR_NOENT) {
+        if (!(flags & LFS2_O_CREAT)) {
+            err = LFS2_ERR_NOENT;
+            goto cleanup;
+        }
+
+        // check that name fits
+        lfs2_size_t nlen = strlen(path);
+        if (nlen > lfs2->name_max) {
+            err = LFS2_ERR_NAMETOOLONG;
+            goto cleanup;
+        }
+
+        // get next slot and create entry to remember name
+        err = lfs2_dir_commit(lfs2, &file->m, LFS2_MKATTRS(
+                {LFS2_MKTAG(LFS2_TYPE_CREATE, file->id, 0)},
+                {LFS2_MKTAG(LFS2_TYPE_REG, file->id, nlen), path},
+                {LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, file->id, 0)}));
+        if (err) {
+            err = LFS2_ERR_NAMETOOLONG;
+            goto cleanup;
+        }
+
+        tag = LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, 0, 0);
+    } else if (flags & LFS2_O_EXCL) {
+        err = LFS2_ERR_EXIST;
+        goto cleanup;
+    } else if (lfs2_tag_type3(tag) != LFS2_TYPE_REG) {
+        err = LFS2_ERR_ISDIR;
+        goto cleanup;
+    } else if (flags & LFS2_O_TRUNC) {
+        // truncate if requested
+        tag = LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, file->id, 0);
+        file->flags |= LFS2_F_DIRTY;
+    } else {
+        // try to load what's on disk, if it's inlined we'll fix it later
+        tag = lfs2_dir_get(lfs2, &file->m, LFS2_MKTAG(0x700, 0x3ff, 0),
+                LFS2_MKTAG(LFS2_TYPE_STRUCT, file->id, 8), &file->ctz);
+        if (tag < 0) {
+            err = tag;
+            goto cleanup;
+        }
+        lfs2_ctz_fromle32(&file->ctz);
+    }
+
+    // fetch attrs
+    for (unsigned i = 0; i < file->cfg->attr_count; i++) {
+        if ((file->flags & 3) != LFS2_O_WRONLY) {
+            lfs2_stag_t res = lfs2_dir_get(lfs2, &file->m,
+                    LFS2_MKTAG(0x7ff, 0x3ff, 0),
+                    LFS2_MKTAG(LFS2_TYPE_USERATTR + file->cfg->attrs[i].type,
+                        file->id, file->cfg->attrs[i].size),
+                        file->cfg->attrs[i].buffer);
+            if (res < 0 && res != LFS2_ERR_NOENT) {
+                err = res;
+                goto cleanup;
+            }
+        }
+
+        if ((file->flags & 3) != LFS2_O_RDONLY) {
+            if (file->cfg->attrs[i].size > lfs2->attr_max) {
+                err = LFS2_ERR_NOSPC;
+                goto cleanup;
+            }
+
+            file->flags |= LFS2_F_DIRTY;
+        }
+    }
+
+    // allocate buffer if needed
+    if (file->cfg->buffer) {
+        file->cache.buffer = file->cfg->buffer;
+    } else {
+        file->cache.buffer = lfs2_malloc(lfs2->cfg->cache_size);
+        if (!file->cache.buffer) {
+            err = LFS2_ERR_NOMEM;
+            goto cleanup;
+        }
+    }
+
+    // zero to avoid information leak
+    lfs2_cache_zero(lfs2, &file->cache);
+
+    if (lfs2_tag_type3(tag) == LFS2_TYPE_INLINESTRUCT) {
+        // load inline files
+        file->ctz.head = LFS2_BLOCK_INLINE;
+        file->ctz.size = lfs2_tag_size(tag);
+        file->flags |= LFS2_F_INLINE;
+        file->cache.block = file->ctz.head;
+        file->cache.off = 0;
+        file->cache.size = lfs2->cfg->cache_size;
+
+        // don't always read (may be new/trunc file)
+        if (file->ctz.size > 0) {
+            lfs2_stag_t res = lfs2_dir_get(lfs2, &file->m,
+                    LFS2_MKTAG(0x700, 0x3ff, 0),
+                    LFS2_MKTAG(LFS2_TYPE_STRUCT, file->id,
+                        lfs2_min(file->cache.size, 0x3fe)),
+                    file->cache.buffer);
+            if (res < 0) {
+                err = res;
+                goto cleanup;
+            }
+        }
+    }
+
+    LFS2_TRACE("lfs2_file_opencfg -> %d", 0);
+    return 0;
+
+cleanup:
+    // clean up lingering resources
+    file->flags |= LFS2_F_ERRED;
+    lfs2_file_close(lfs2, file);
+    LFS2_TRACE("lfs2_file_opencfg -> %d", err);
+    return err;
+}
+
+int lfs2_file_open(lfs2_t *lfs2, lfs2_file_t *file,
+        const char *path, int flags) {
+    LFS2_TRACE("lfs2_file_open(%p, %p, \"%s\", %x)",
+            (void*)lfs2, (void*)file, path, flags);
+    static const struct lfs2_file_config defaults = {0};
+    int err = lfs2_file_opencfg(lfs2, file, path, flags, &defaults);
+    LFS2_TRACE("lfs2_file_open -> %d", err);
+    return err;
+}
+
+int lfs2_file_close(lfs2_t *lfs2, lfs2_file_t *file) {
+    LFS2_TRACE("lfs2_file_close(%p, %p)", (void*)lfs2, (void*)file);
+    LFS2_ASSERT(file->flags & LFS2_F_OPENED);
+
+    int err = lfs2_file_sync(lfs2, file);
+
+    // remove from list of mdirs
+    for (struct lfs2_mlist **p = &lfs2->mlist; *p; p = &(*p)->next) {
+        if (*p == (struct lfs2_mlist*)file) {
+            *p = (*p)->next;
+            break;
+        }
+    }
+
+    // clean up memory
+    if (!file->cfg->buffer) {
+        lfs2_free(file->cache.buffer);
+    }
+
+    file->flags &= ~LFS2_F_OPENED;
+    LFS2_TRACE("lfs2_file_close -> %d", err);
+    return err;
+}
+
+static int lfs2_file_relocate(lfs2_t *lfs2, lfs2_file_t *file) {
+    LFS2_ASSERT(file->flags & LFS2_F_OPENED);
+
+    while (true) {
+        // just relocate what exists into new block
+        lfs2_block_t nblock;
+        int err = lfs2_alloc(lfs2, &nblock);
+        if (err) {
+            return err;
+        }
+
+        err = lfs2_bd_erase(lfs2, nblock);
+        if (err) {
+            if (err == LFS2_ERR_CORRUPT) {
+                goto relocate;
+            }
+            return err;
+        }
+
+        // either read from dirty cache or disk
+        for (lfs2_off_t i = 0; i < file->off; i++) {
+            uint8_t data;
+            if (file->flags & LFS2_F_INLINE) {
+                err = lfs2_dir_getread(lfs2, &file->m,
+                        // note we evict inline files before they can be dirty
+                        NULL, &file->cache, file->off-i,
+                        LFS2_MKTAG(0xfff, 0x1ff, 0),
+                        LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, file->id, 0),
+                        i, &data, 1);
+                if (err) {
+                    return err;
+                }
+            } else {
+                err = lfs2_bd_read(lfs2,
+                        &file->cache, &lfs2->rcache, file->off-i,
+                        file->block, i, &data, 1);
+                if (err) {
+                    return err;
+                }
+            }
+
+            err = lfs2_bd_prog(lfs2,
+                    &lfs2->pcache, &lfs2->rcache, true,
+                    nblock, i, &data, 1);
+            if (err) {
+                if (err == LFS2_ERR_CORRUPT) {
+                    goto relocate;
+                }
+                return err;
+            }
+        }
+
+        // copy over new state of file
+        memcpy(file->cache.buffer, lfs2->pcache.buffer, lfs2->cfg->cache_size);
+        file->cache.block = lfs2->pcache.block;
+        file->cache.off = lfs2->pcache.off;
+        file->cache.size = lfs2->pcache.size;
+        lfs2_cache_zero(lfs2, &lfs2->pcache);
+
+        file->block = nblock;
+        file->flags |= LFS2_F_WRITING;
+        return 0;
+
+relocate:
+        LFS2_DEBUG("Bad block at 0x%"PRIx32, nblock);
+
+        // just clear cache and try a new block
+        lfs2_cache_drop(lfs2, &lfs2->pcache);
+    }
+}
+
+static int lfs2_file_outline(lfs2_t *lfs2, lfs2_file_t *file) {
+    file->off = file->pos;
+    lfs2_alloc_ack(lfs2);
+    int err = lfs2_file_relocate(lfs2, file);
+    if (err) {
+        return err;
+    }
+
+    file->flags &= ~LFS2_F_INLINE;
+    return 0;
+}
+
+static int lfs2_file_flush(lfs2_t *lfs2, lfs2_file_t *file) {
+    LFS2_ASSERT(file->flags & LFS2_F_OPENED);
+
+    if (file->flags & LFS2_F_READING) {
+        if (!(file->flags & LFS2_F_INLINE)) {
+            lfs2_cache_drop(lfs2, &file->cache);
+        }
+        file->flags &= ~LFS2_F_READING;
+    }
+
+    if (file->flags & LFS2_F_WRITING) {
+        lfs2_off_t pos = file->pos;
+
+        if (!(file->flags & LFS2_F_INLINE)) {
+            // copy over anything after current branch
+            lfs2_file_t orig = {
+                .ctz.head = file->ctz.head,
+                .ctz.size = file->ctz.size,
+                .flags = LFS2_O_RDONLY | LFS2_F_OPENED,
+                .pos = file->pos,
+                .cache = lfs2->rcache,
+            };
+            lfs2_cache_drop(lfs2, &lfs2->rcache);
+
+            while (file->pos < file->ctz.size) {
+                // copy over a byte at a time, leave it up to caching
+                // to make this efficient
+                uint8_t data;
+                lfs2_ssize_t res = lfs2_file_read(lfs2, &orig, &data, 1);
+                if (res < 0) {
+                    return res;
+                }
+
+                res = lfs2_file_write(lfs2, file, &data, 1);
+                if (res < 0) {
+                    return res;
+                }
+
+                // keep our reference to the rcache in sync
+                if (lfs2->rcache.block != LFS2_BLOCK_NULL) {
+                    lfs2_cache_drop(lfs2, &orig.cache);
+                    lfs2_cache_drop(lfs2, &lfs2->rcache);
+                }
+            }
+
+            // write out what we have
+            while (true) {
+                int err = lfs2_bd_flush(lfs2, &file->cache, &lfs2->rcache, true);
+                if (err) {
+                    if (err == LFS2_ERR_CORRUPT) {
+                        goto relocate;
+                    }
+                    return err;
+                }
+
+                break;
+
+relocate:
+                LFS2_DEBUG("Bad block at 0x%"PRIx32, file->block);
+                err = lfs2_file_relocate(lfs2, file);
+                if (err) {
+                    return err;
+                }
+            }
+        } else {
+            file->pos = lfs2_max(file->pos, file->ctz.size);
+        }
+
+        // actual file updates
+        file->ctz.head = file->block;
+        file->ctz.size = file->pos;
+        file->flags &= ~LFS2_F_WRITING;
+        file->flags |= LFS2_F_DIRTY;
+
+        file->pos = pos;
+    }
+
+    return 0;
+}
+
+int lfs2_file_sync(lfs2_t *lfs2, lfs2_file_t *file) {
+    LFS2_TRACE("lfs2_file_sync(%p, %p)", (void*)lfs2, (void*)file);
+    LFS2_ASSERT(file->flags & LFS2_F_OPENED);
+
+    if (file->flags & LFS2_F_ERRED) {
+        // it's not safe to do anything if our file errored
+        LFS2_TRACE("lfs2_file_sync -> %d", 0);
+        return 0;
+    }
+
+    int err = lfs2_file_flush(lfs2, file);
+    if (err) {
+        file->flags |= LFS2_F_ERRED;
+        LFS2_TRACE("lfs2_file_sync -> %d", err);
+        return err;
+    }
+
+    if ((file->flags & LFS2_F_DIRTY) &&
+            !lfs2_pair_isnull(file->m.pair)) {
+        // update dir entry
+        uint16_t type;
+        const void *buffer;
+        lfs2_size_t size;
+        struct lfs2_ctz ctz;
+        if (file->flags & LFS2_F_INLINE) {
+            // inline the whole file
+            type = LFS2_TYPE_INLINESTRUCT;
+            buffer = file->cache.buffer;
+            size = file->ctz.size;
+        } else {
+            // update the ctz reference
+            type = LFS2_TYPE_CTZSTRUCT;
+            // copy ctz so alloc will work during a relocate
+            ctz = file->ctz;
+            lfs2_ctz_tole32(&ctz);
+            buffer = &ctz;
+            size = sizeof(ctz);
+        }
+
+        // commit file data and attributes
+        err = lfs2_dir_commit(lfs2, &file->m, LFS2_MKATTRS(
+                {LFS2_MKTAG(type, file->id, size), buffer},
+                {LFS2_MKTAG(LFS2_FROM_USERATTRS, file->id,
+                    file->cfg->attr_count), file->cfg->attrs}));
+        if (err) {
+            file->flags |= LFS2_F_ERRED;
+            LFS2_TRACE("lfs2_file_sync -> %d", err);
+            return err;
+        }
+
+        file->flags &= ~LFS2_F_DIRTY;
+    }
+
+    LFS2_TRACE("lfs2_file_sync -> %d", 0);
+    return 0;
+}
+
+lfs2_ssize_t lfs2_file_read(lfs2_t *lfs2, lfs2_file_t *file,
+        void *buffer, lfs2_size_t size) {
+    LFS2_TRACE("lfs2_file_read(%p, %p, %p, %"PRIu32")",
+            (void*)lfs2, (void*)file, buffer, size);
+    LFS2_ASSERT(file->flags & LFS2_F_OPENED);
+    LFS2_ASSERT((file->flags & 3) != LFS2_O_WRONLY);
+
+    uint8_t *data = buffer;
+    lfs2_size_t nsize = size;
+
+    if (file->flags & LFS2_F_WRITING) {
+        // flush out any writes
+        int err = lfs2_file_flush(lfs2, file);
+        if (err) {
+            LFS2_TRACE("lfs2_file_read -> %d", err);
+            return err;
+        }
+    }
+
+    if (file->pos >= file->ctz.size) {
+        // eof if past end
+        LFS2_TRACE("lfs2_file_read -> %d", 0);
+        return 0;
+    }
+
+    size = lfs2_min(size, file->ctz.size - file->pos);
+    nsize = size;
+
+    while (nsize > 0) {
+        // check if we need a new block
+        if (!(file->flags & LFS2_F_READING) ||
+                file->off == lfs2->cfg->block_size) {
+            if (!(file->flags & LFS2_F_INLINE)) {
+                int err = lfs2_ctz_find(lfs2, NULL, &file->cache,
+                        file->ctz.head, file->ctz.size,
+                        file->pos, &file->block, &file->off);
+                if (err) {
+                    LFS2_TRACE("lfs2_file_read -> %d", err);
+                    return err;
+                }
+            } else {
+                file->block = LFS2_BLOCK_INLINE;
+                file->off = file->pos;
+            }
+
+            file->flags |= LFS2_F_READING;
+        }
+
+        // read as much as we can in current block
+        lfs2_size_t diff = lfs2_min(nsize, lfs2->cfg->block_size - file->off);
+        if (file->flags & LFS2_F_INLINE) {
+            int err = lfs2_dir_getread(lfs2, &file->m,
+                    NULL, &file->cache, lfs2->cfg->block_size,
+                    LFS2_MKTAG(0xfff, 0x1ff, 0),
+                    LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, file->id, 0),
+                    file->off, data, diff);
+            if (err) {
+                LFS2_TRACE("lfs2_file_read -> %d", err);
+                return err;
+            }
+        } else {
+            int err = lfs2_bd_read(lfs2,
+                    NULL, &file->cache, lfs2->cfg->block_size,
+                    file->block, file->off, data, diff);
+            if (err) {
+                LFS2_TRACE("lfs2_file_read -> %d", err);
+                return err;
+            }
+        }
+
+        file->pos += diff;
+        file->off += diff;
+        data += diff;
+        nsize -= diff;
+    }
+
+    LFS2_TRACE("lfs2_file_read -> %"PRId32, size);
+    return size;
+}
+
+lfs2_ssize_t lfs2_file_write(lfs2_t *lfs2, lfs2_file_t *file,
+        const void *buffer, lfs2_size_t size) {
+    LFS2_TRACE("lfs2_file_write(%p, %p, %p, %"PRIu32")",
+            (void*)lfs2, (void*)file, buffer, size);
+    LFS2_ASSERT(file->flags & LFS2_F_OPENED);
+    LFS2_ASSERT((file->flags & 3) != LFS2_O_RDONLY);
+
+    const uint8_t *data = buffer;
+    lfs2_size_t nsize = size;
+
+    if (file->flags & LFS2_F_READING) {
+        // drop any reads
+        int err = lfs2_file_flush(lfs2, file);
+        if (err) {
+            LFS2_TRACE("lfs2_file_write -> %d", err);
+            return err;
+        }
+    }
+
+    if ((file->flags & LFS2_O_APPEND) && file->pos < file->ctz.size) {
+        file->pos = file->ctz.size;
+    }
+
+    if (file->pos + size > lfs2->file_max) {
+        // Larger than file limit?
+        LFS2_TRACE("lfs2_file_write -> %d", LFS2_ERR_FBIG);
+        return LFS2_ERR_FBIG;
+    }
+
+    if (!(file->flags & LFS2_F_WRITING) && file->pos > file->ctz.size) {
+        // fill with zeros
+        lfs2_off_t pos = file->pos;
+        file->pos = file->ctz.size;
+
+        while (file->pos < pos) {
+            lfs2_ssize_t res = lfs2_file_write(lfs2, file, &(uint8_t){0}, 1);
+            if (res < 0) {
+                LFS2_TRACE("lfs2_file_write -> %"PRId32, res);
+                return res;
+            }
+        }
+    }
+
+    if ((file->flags & LFS2_F_INLINE) &&
+            lfs2_max(file->pos+nsize, file->ctz.size) >
+            lfs2_min(0x3fe, lfs2_min(
+                lfs2->cfg->cache_size, lfs2->cfg->block_size/8))) {
+        // inline file doesn't fit anymore
+        int err = lfs2_file_outline(lfs2, file);
+        if (err) {
+            file->flags |= LFS2_F_ERRED;
+            LFS2_TRACE("lfs2_file_write -> %d", err);
+            return err;
+        }
+    }
+
+    while (nsize > 0) {
+        // check if we need a new block
+        if (!(file->flags & LFS2_F_WRITING) ||
+                file->off == lfs2->cfg->block_size) {
+            if (!(file->flags & LFS2_F_INLINE)) {
+                if (!(file->flags & LFS2_F_WRITING) && file->pos > 0) {
+                    // find out which block we're extending from
+                    int err = lfs2_ctz_find(lfs2, NULL, &file->cache,
+                            file->ctz.head, file->ctz.size,
+                            file->pos-1, &file->block, &file->off);
+                    if (err) {
+                        file->flags |= LFS2_F_ERRED;
+                        LFS2_TRACE("lfs2_file_write -> %d", err);
+                        return err;
+                    }
+
+                    // mark cache as dirty since we may have read data into it
+                    lfs2_cache_zero(lfs2, &file->cache);
+                }
+
+                // extend file with new blocks
+                lfs2_alloc_ack(lfs2);
+                int err = lfs2_ctz_extend(lfs2, &file->cache, &lfs2->rcache,
+                        file->block, file->pos,
+                        &file->block, &file->off);
+                if (err) {
+                    file->flags |= LFS2_F_ERRED;
+                    LFS2_TRACE("lfs2_file_write -> %d", err);
+                    return err;
+                }
+            } else {
+                file->block = LFS2_BLOCK_INLINE;
+                file->off = file->pos;
+            }
+
+            file->flags |= LFS2_F_WRITING;
+        }
+
+        // program as much as we can in current block
+        lfs2_size_t diff = lfs2_min(nsize, lfs2->cfg->block_size - file->off);
+        while (true) {
+            int err = lfs2_bd_prog(lfs2, &file->cache, &lfs2->rcache, true,
+                    file->block, file->off, data, diff);
+            if (err) {
+                if (err == LFS2_ERR_CORRUPT) {
+                    goto relocate;
+                }
+                file->flags |= LFS2_F_ERRED;
+                LFS2_TRACE("lfs2_file_write -> %d", err);
+                return err;
+            }
+
+            break;
+relocate:
+            err = lfs2_file_relocate(lfs2, file);
+            if (err) {
+                file->flags |= LFS2_F_ERRED;
+                LFS2_TRACE("lfs2_file_write -> %d", err);
+                return err;
+            }
+        }
+
+        file->pos += diff;
+        file->off += diff;
+        data += diff;
+        nsize -= diff;
+
+        lfs2_alloc_ack(lfs2);
+    }
+
+    file->flags &= ~LFS2_F_ERRED;
+    LFS2_TRACE("lfs2_file_write -> %"PRId32, size);
+    return size;
+}
+
+lfs2_soff_t lfs2_file_seek(lfs2_t *lfs2, lfs2_file_t *file,
+        lfs2_soff_t off, int whence) {
+    LFS2_TRACE("lfs2_file_seek(%p, %p, %"PRId32", %d)",
+            (void*)lfs2, (void*)file, off, whence);
+    LFS2_ASSERT(file->flags & LFS2_F_OPENED);
+
+    // write out everything beforehand, may be noop if rdonly
+    int err = lfs2_file_flush(lfs2, file);
+    if (err) {
+        LFS2_TRACE("lfs2_file_seek -> %d", err);
+        return err;
+    }
+
+    // find new pos
+    lfs2_off_t npos = file->pos;
+    if (whence == LFS2_SEEK_SET) {
+        npos = off;
+    } else if (whence == LFS2_SEEK_CUR) {
+        npos = file->pos + off;
+    } else if (whence == LFS2_SEEK_END) {
+        npos = file->ctz.size + off;
+    }
+
+    if (npos > lfs2->file_max) {
+        // file position out of range
+        LFS2_TRACE("lfs2_file_seek -> %d", LFS2_ERR_INVAL);
+        return LFS2_ERR_INVAL;
+    }
+
+    // update pos
+    file->pos = npos;
+    LFS2_TRACE("lfs2_file_seek -> %"PRId32, npos);
+    return npos;
+}
+
+int lfs2_file_truncate(lfs2_t *lfs2, lfs2_file_t *file, lfs2_off_t size) {
+    LFS2_TRACE("lfs2_file_truncate(%p, %p, %"PRIu32")",
+            (void*)lfs2, (void*)file, size);
+    LFS2_ASSERT(file->flags & LFS2_F_OPENED);
+    LFS2_ASSERT((file->flags & 3) != LFS2_O_RDONLY);
+
+    if (size > LFS2_FILE_MAX) {
+        LFS2_TRACE("lfs2_file_truncate -> %d", LFS2_ERR_INVAL);
+        return LFS2_ERR_INVAL;
+    }
+
+    lfs2_off_t pos = file->pos;
+    lfs2_off_t oldsize = lfs2_file_size(lfs2, file);
+    if (size < oldsize) {
+        // need to flush since directly changing metadata
+        int err = lfs2_file_flush(lfs2, file);
+        if (err) {
+            LFS2_TRACE("lfs2_file_truncate -> %d", err);
+            return err;
+        }
+
+        // lookup new head in ctz skip list
+        err = lfs2_ctz_find(lfs2, NULL, &file->cache,
+                file->ctz.head, file->ctz.size,
+                size, &file->block, &file->off);
+        if (err) {
+            LFS2_TRACE("lfs2_file_truncate -> %d", err);
+            return err;
+        }
+
+        file->ctz.head = file->block;
+        file->ctz.size = size;
+        file->flags |= LFS2_F_DIRTY | LFS2_F_READING;
+    } else if (size > oldsize) {
+        // flush+seek if not already at end
+        if (file->pos != oldsize) {
+            lfs2_soff_t res = lfs2_file_seek(lfs2, file, 0, LFS2_SEEK_END);
+            if (res < 0) {
+                LFS2_TRACE("lfs2_file_truncate -> %"PRId32, res);
+                return (int)res;
+            }
+        }
+
+        // fill with zeros
+        while (file->pos < size) {
+            lfs2_ssize_t res = lfs2_file_write(lfs2, file, &(uint8_t){0}, 1);
+            if (res < 0) {
+                LFS2_TRACE("lfs2_file_truncate -> %"PRId32, res);
+                return (int)res;
+            }
+        }
+    }
+
+    // restore pos
+    lfs2_soff_t res = lfs2_file_seek(lfs2, file, pos, LFS2_SEEK_SET);
+    if (res < 0) {
+      LFS2_TRACE("lfs2_file_truncate -> %"PRId32, res);
+      return (int)res;
+    }
+
+    LFS2_TRACE("lfs2_file_truncate -> %d", 0);
+    return 0;
+}
+
+lfs2_soff_t lfs2_file_tell(lfs2_t *lfs2, lfs2_file_t *file) {
+    LFS2_TRACE("lfs2_file_tell(%p, %p)", (void*)lfs2, (void*)file);
+    LFS2_ASSERT(file->flags & LFS2_F_OPENED);
+    (void)lfs2;
+    LFS2_TRACE("lfs2_file_tell -> %"PRId32, file->pos);
+    return file->pos;
+}
+
+int lfs2_file_rewind(lfs2_t *lfs2, lfs2_file_t *file) {
+    LFS2_TRACE("lfs2_file_rewind(%p, %p)", (void*)lfs2, (void*)file);
+    lfs2_soff_t res = lfs2_file_seek(lfs2, file, 0, LFS2_SEEK_SET);
+    if (res < 0) {
+        LFS2_TRACE("lfs2_file_rewind -> %"PRId32, res);
+        return (int)res;
+    }
+
+    LFS2_TRACE("lfs2_file_rewind -> %d", 0);
+    return 0;
+}
+
+lfs2_soff_t lfs2_file_size(lfs2_t *lfs2, lfs2_file_t *file) {
+    LFS2_TRACE("lfs2_file_size(%p, %p)", (void*)lfs2, (void*)file);
+    LFS2_ASSERT(file->flags & LFS2_F_OPENED);
+    (void)lfs2;
+    if (file->flags & LFS2_F_WRITING) {
+        LFS2_TRACE("lfs2_file_size -> %"PRId32,
+                lfs2_max(file->pos, file->ctz.size));
+        return lfs2_max(file->pos, file->ctz.size);
+    } else {
+        LFS2_TRACE("lfs2_file_size -> %"PRId32, file->ctz.size);
+        return file->ctz.size;
+    }
+}
+
+
+/// General fs operations ///
+int lfs2_stat(lfs2_t *lfs2, const char *path, struct lfs2_info *info) {
+    LFS2_TRACE("lfs2_stat(%p, \"%s\", %p)", (void*)lfs2, path, (void*)info);
+    lfs2_mdir_t cwd;
+    lfs2_stag_t tag = lfs2_dir_find(lfs2, &cwd, &path, NULL);
+    if (tag < 0) {
+        LFS2_TRACE("lfs2_stat -> %"PRId32, tag);
+        return (int)tag;
+    }
+
+    int err = lfs2_dir_getinfo(lfs2, &cwd, lfs2_tag_id(tag), info);
+    LFS2_TRACE("lfs2_stat -> %d", err);
+    return err;
+}
+
+int lfs2_remove(lfs2_t *lfs2, const char *path) {
+    LFS2_TRACE("lfs2_remove(%p, \"%s\")", (void*)lfs2, path);
+    // deorphan if we haven't yet, needed at most once after poweron
+    int err = lfs2_fs_forceconsistency(lfs2);
+    if (err) {
+        LFS2_TRACE("lfs2_remove -> %d", err);
+        return err;
+    }
+
+    lfs2_mdir_t cwd;
+    lfs2_stag_t tag = lfs2_dir_find(lfs2, &cwd, &path, NULL);
+    if (tag < 0 || lfs2_tag_id(tag) == 0x3ff) {
+        LFS2_TRACE("lfs2_remove -> %"PRId32, (tag < 0) ? tag : LFS2_ERR_INVAL);
+        return (tag < 0) ? (int)tag : LFS2_ERR_INVAL;
+    }
+
+    struct lfs2_mlist dir;
+    dir.next = lfs2->mlist;
+    if (lfs2_tag_type3(tag) == LFS2_TYPE_DIR) {
+        // must be empty before removal
+        lfs2_block_t pair[2];
+        lfs2_stag_t res = lfs2_dir_get(lfs2, &cwd, LFS2_MKTAG(0x700, 0x3ff, 0),
+                LFS2_MKTAG(LFS2_TYPE_STRUCT, lfs2_tag_id(tag), 8), pair);
+        if (res < 0) {
+            LFS2_TRACE("lfs2_remove -> %"PRId32, res);
+            return (int)res;
+        }
+        lfs2_pair_fromle32(pair);
+
+        err = lfs2_dir_fetch(lfs2, &dir.m, pair);
+        if (err) {
+            LFS2_TRACE("lfs2_remove -> %d", err);
+            return err;
+        }
+
+        if (dir.m.count > 0 || dir.m.split) {
+            LFS2_TRACE("lfs2_remove -> %d", LFS2_ERR_NOTEMPTY);
+            return LFS2_ERR_NOTEMPTY;
+        }
+
+        // mark fs as orphaned
+        lfs2_fs_preporphans(lfs2, +1);
+
+        // I know it's crazy but yes, dir can be changed by our parent's
+        // commit (if predecessor is child)
+        dir.type = 0;
+        dir.id = 0;
+        lfs2->mlist = &dir;
+    }
+
+    // delete the entry
+    err = lfs2_dir_commit(lfs2, &cwd, LFS2_MKATTRS(
+            {LFS2_MKTAG(LFS2_TYPE_DELETE, lfs2_tag_id(tag), 0)}));
+    if (err) {
+        lfs2->mlist = dir.next;
+        LFS2_TRACE("lfs2_remove -> %d", err);
+        return err;
+    }
+
+    lfs2->mlist = dir.next;
+    if (lfs2_tag_type3(tag) == LFS2_TYPE_DIR) {
+        // fix orphan
+        lfs2_fs_preporphans(lfs2, -1);
+
+        err = lfs2_fs_pred(lfs2, dir.m.pair, &cwd);
+        if (err) {
+            LFS2_TRACE("lfs2_remove -> %d", err);
+            return err;
+        }
+
+        err = lfs2_dir_drop(lfs2, &cwd, &dir.m);
+        if (err) {
+            LFS2_TRACE("lfs2_remove -> %d", err);
+            return err;
+        }
+    }
+
+    LFS2_TRACE("lfs2_remove -> %d", 0);
+    return 0;
+}
+
+int lfs2_rename(lfs2_t *lfs2, const char *oldpath, const char *newpath) {
+    LFS2_TRACE("lfs2_rename(%p, \"%s\", \"%s\")", (void*)lfs2, oldpath, newpath);
+
+    // deorphan if we haven't yet, needed at most once after poweron
+    int err = lfs2_fs_forceconsistency(lfs2);
+    if (err) {
+        LFS2_TRACE("lfs2_rename -> %d", err);
+        return err;
+    }
+
+    // find old entry
+    lfs2_mdir_t oldcwd;
+    lfs2_stag_t oldtag = lfs2_dir_find(lfs2, &oldcwd, &oldpath, NULL);
+    if (oldtag < 0 || lfs2_tag_id(oldtag) == 0x3ff) {
+        LFS2_TRACE("lfs2_rename -> %"PRId32,
+                (oldtag < 0) ? oldtag : LFS2_ERR_INVAL);
+        return (oldtag < 0) ? (int)oldtag : LFS2_ERR_INVAL;
+    }
+
+    // find new entry
+    lfs2_mdir_t newcwd;
+    uint16_t newid;
+    lfs2_stag_t prevtag = lfs2_dir_find(lfs2, &newcwd, &newpath, &newid);
+    if ((prevtag < 0 || lfs2_tag_id(prevtag) == 0x3ff) &&
+            !(prevtag == LFS2_ERR_NOENT && newid != 0x3ff)) {
+        LFS2_TRACE("lfs2_rename -> %"PRId32,
+            (prevtag < 0) ? prevtag : LFS2_ERR_INVAL);
+        return (prevtag < 0) ? (int)prevtag : LFS2_ERR_INVAL;
+    }
+
+    // if we're in the same pair there's a few special cases...
+    bool samepair = (lfs2_pair_cmp(oldcwd.pair, newcwd.pair) == 0);
+    uint16_t newoldid = lfs2_tag_id(oldtag);
+
+    struct lfs2_mlist prevdir;
+    prevdir.next = lfs2->mlist;
+    if (prevtag == LFS2_ERR_NOENT) {
+        // check that name fits
+        lfs2_size_t nlen = strlen(newpath);
+        if (nlen > lfs2->name_max) {
+            LFS2_TRACE("lfs2_rename -> %d", LFS2_ERR_NAMETOOLONG);
+            return LFS2_ERR_NAMETOOLONG;
+        }
+
+        // there is a small chance we are being renamed in the same
+        // directory/ to an id less than our old id, the global update
+        // to handle this is a bit messy
+        if (samepair && newid <= newoldid) {
+            newoldid += 1;
+        }
+    } else if (lfs2_tag_type3(prevtag) != lfs2_tag_type3(oldtag)) {
+        LFS2_TRACE("lfs2_rename -> %d", LFS2_ERR_ISDIR);
+        return LFS2_ERR_ISDIR;
+    } else if (samepair && newid == newoldid) {
+        // we're renaming to ourselves??
+        LFS2_TRACE("lfs2_rename -> %d", 0);
+        return 0;
+    } else if (lfs2_tag_type3(prevtag) == LFS2_TYPE_DIR) {
+        // must be empty before removal
+        lfs2_block_t prevpair[2];
+        lfs2_stag_t res = lfs2_dir_get(lfs2, &newcwd, LFS2_MKTAG(0x700, 0x3ff, 0),
+                LFS2_MKTAG(LFS2_TYPE_STRUCT, newid, 8), prevpair);
+        if (res < 0) {
+            LFS2_TRACE("lfs2_rename -> %"PRId32, res);
+            return (int)res;
+        }
+        lfs2_pair_fromle32(prevpair);
+
+        // must be empty before removal
+        err = lfs2_dir_fetch(lfs2, &prevdir.m, prevpair);
+        if (err) {
+            LFS2_TRACE("lfs2_rename -> %d", err);
+            return err;
+        }
+
+        if (prevdir.m.count > 0 || prevdir.m.split) {
+            LFS2_TRACE("lfs2_rename -> %d", LFS2_ERR_NOTEMPTY);
+            return LFS2_ERR_NOTEMPTY;
+        }
+
+        // mark fs as orphaned
+        lfs2_fs_preporphans(lfs2, +1);
+
+        // I know it's crazy but yes, dir can be changed by our parent's
+        // commit (if predecessor is child)
+        prevdir.type = 0;
+        prevdir.id = 0;
+        lfs2->mlist = &prevdir;
+    }
+
+    if (!samepair) {
+        lfs2_fs_prepmove(lfs2, newoldid, oldcwd.pair);
+    }
+
+    // move over all attributes
+    err = lfs2_dir_commit(lfs2, &newcwd, LFS2_MKATTRS(
+            {LFS2_MKTAG_IF(prevtag != LFS2_ERR_NOENT,
+                LFS2_TYPE_DELETE, newid, 0)},
+            {LFS2_MKTAG(LFS2_TYPE_CREATE, newid, 0)},
+            {LFS2_MKTAG(lfs2_tag_type3(oldtag), newid, strlen(newpath)), newpath},
+            {LFS2_MKTAG(LFS2_FROM_MOVE, newid, lfs2_tag_id(oldtag)), &oldcwd},
+            {LFS2_MKTAG_IF(samepair,
+                LFS2_TYPE_DELETE, newoldid, 0)}));
+    if (err) {
+        lfs2->mlist = prevdir.next;
+        LFS2_TRACE("lfs2_rename -> %d", err);
+        return err;
+    }
+
+    // let commit clean up after move (if we're different! otherwise move
+    // logic already fixed it for us)
+    if (!samepair && lfs2_gstate_hasmove(&lfs2->gstate)) {
+        // prep gstate and delete move id
+        lfs2_fs_prepmove(lfs2, 0x3ff, NULL);
+        err = lfs2_dir_commit(lfs2, &oldcwd, LFS2_MKATTRS(
+                {LFS2_MKTAG(LFS2_TYPE_DELETE, lfs2_tag_id(oldtag), 0)}));
+        if (err) {
+            lfs2->mlist = prevdir.next;
+            LFS2_TRACE("lfs2_rename -> %d", err);
+            return err;
+        }
+    }
+
+    lfs2->mlist = prevdir.next;
+    if (prevtag != LFS2_ERR_NOENT && lfs2_tag_type3(prevtag) == LFS2_TYPE_DIR) {
+        // fix orphan
+        lfs2_fs_preporphans(lfs2, -1);
+
+        err = lfs2_fs_pred(lfs2, prevdir.m.pair, &newcwd);
+        if (err) {
+            LFS2_TRACE("lfs2_rename -> %d", err);
+            return err;
+        }
+
+        err = lfs2_dir_drop(lfs2, &newcwd, &prevdir.m);
+        if (err) {
+            LFS2_TRACE("lfs2_rename -> %d", err);
+            return err;
+        }
+    }
+
+    LFS2_TRACE("lfs2_rename -> %d", 0);
+    return 0;
+}
+
+lfs2_ssize_t lfs2_getattr(lfs2_t *lfs2, const char *path,
+        uint8_t type, void *buffer, lfs2_size_t size) {
+    LFS2_TRACE("lfs2_getattr(%p, \"%s\", %"PRIu8", %p, %"PRIu32")",
+            (void*)lfs2, path, type, buffer, size);
+    lfs2_mdir_t cwd;
+    lfs2_stag_t tag = lfs2_dir_find(lfs2, &cwd, &path, NULL);
+    if (tag < 0) {
+        LFS2_TRACE("lfs2_getattr -> %"PRId32, tag);
+        return tag;
+    }
+
+    uint16_t id = lfs2_tag_id(tag);
+    if (id == 0x3ff) {
+        // special case for root
+        id = 0;
+        int err = lfs2_dir_fetch(lfs2, &cwd, lfs2->root);
+        if (err) {
+            LFS2_TRACE("lfs2_getattr -> %d", err);
+            return err;
+        }
+    }
+
+    tag = lfs2_dir_get(lfs2, &cwd, LFS2_MKTAG(0x7ff, 0x3ff, 0),
+            LFS2_MKTAG(LFS2_TYPE_USERATTR + type,
+                id, lfs2_min(size, lfs2->attr_max)),
+            buffer);
+    if (tag < 0) {
+        if (tag == LFS2_ERR_NOENT) {
+            LFS2_TRACE("lfs2_getattr -> %d", LFS2_ERR_NOATTR);
+            return LFS2_ERR_NOATTR;
+        }
+
+        LFS2_TRACE("lfs2_getattr -> %"PRId32, tag);
+        return tag;
+    }
+
+    size = lfs2_tag_size(tag);
+    LFS2_TRACE("lfs2_getattr -> %"PRId32, size);
+    return size;
+}
+
+static int lfs2_commitattr(lfs2_t *lfs2, const char *path,
+        uint8_t type, const void *buffer, lfs2_size_t size) {
+    lfs2_mdir_t cwd;
+    lfs2_stag_t tag = lfs2_dir_find(lfs2, &cwd, &path, NULL);
+    if (tag < 0) {
+        return tag;
+    }
+
+    uint16_t id = lfs2_tag_id(tag);
+    if (id == 0x3ff) {
+        // special case for root
+        id = 0;
+        int err = lfs2_dir_fetch(lfs2, &cwd, lfs2->root);
+        if (err) {
+            return err;
+        }
+    }
+
+    return lfs2_dir_commit(lfs2, &cwd, LFS2_MKATTRS(
+            {LFS2_MKTAG(LFS2_TYPE_USERATTR + type, id, size), buffer}));
+}
+
+int lfs2_setattr(lfs2_t *lfs2, const char *path,
+        uint8_t type, const void *buffer, lfs2_size_t size) {
+    LFS2_TRACE("lfs2_setattr(%p, \"%s\", %"PRIu8", %p, %"PRIu32")",
+            (void*)lfs2, path, type, buffer, size);
+    if (size > lfs2->attr_max) {
+        LFS2_TRACE("lfs2_setattr -> %d", LFS2_ERR_NOSPC);
+        return LFS2_ERR_NOSPC;
+    }
+
+    int err = lfs2_commitattr(lfs2, path, type, buffer, size);
+    LFS2_TRACE("lfs2_setattr -> %d", err);
+    return err;
+}
+
+int lfs2_removeattr(lfs2_t *lfs2, const char *path, uint8_t type) {
+    LFS2_TRACE("lfs2_removeattr(%p, \"%s\", %"PRIu8")", (void*)lfs2, path, type);
+    int err = lfs2_commitattr(lfs2, path, type, NULL, 0x3ff);
+    LFS2_TRACE("lfs2_removeattr -> %d", err);
+    return err;
+}
+
+
+/// Filesystem operations ///
+static int lfs2_init(lfs2_t *lfs2, const struct lfs2_config *cfg) {
+    lfs2->cfg = cfg;
+    int err = 0;
+
+    // validate that the lfs2-cfg sizes were initiated properly before
+    // performing any arithmetic logics with them
+    LFS2_ASSERT(lfs2->cfg->read_size != 0);
+    LFS2_ASSERT(lfs2->cfg->prog_size != 0);
+    LFS2_ASSERT(lfs2->cfg->cache_size != 0);
+
+    // check that block size is a multiple of cache size is a multiple
+    // of prog and read sizes
+    LFS2_ASSERT(lfs2->cfg->cache_size % lfs2->cfg->read_size == 0);
+    LFS2_ASSERT(lfs2->cfg->cache_size % lfs2->cfg->prog_size == 0);
+    LFS2_ASSERT(lfs2->cfg->block_size % lfs2->cfg->cache_size == 0);
+
+    // check that the block size is large enough to fit ctz pointers
+    LFS2_ASSERT(4*lfs2_npw2(0xffffffff / (lfs2->cfg->block_size-2*4))
+            <= lfs2->cfg->block_size);
+
+    // block_cycles = 0 is no longer supported.
+    //
+    // block_cycles is the number of erase cycles before littlefs evicts
+    // metadata logs as a part of wear leveling. Suggested values are in the
+    // range of 100-1000, or set block_cycles to -1 to disable block-level
+    // wear-leveling.
+    LFS2_ASSERT(lfs2->cfg->block_cycles != 0);
+
+
+    // setup read cache
+    if (lfs2->cfg->read_buffer) {
+        lfs2->rcache.buffer = lfs2->cfg->read_buffer;
+    } else {
+        lfs2->rcache.buffer = lfs2_malloc(lfs2->cfg->cache_size);
+        if (!lfs2->rcache.buffer) {
+            err = LFS2_ERR_NOMEM;
+            goto cleanup;
+        }
+    }
+
+    // setup program cache
+    if (lfs2->cfg->prog_buffer) {
+        lfs2->pcache.buffer = lfs2->cfg->prog_buffer;
+    } else {
+        lfs2->pcache.buffer = lfs2_malloc(lfs2->cfg->cache_size);
+        if (!lfs2->pcache.buffer) {
+            err = LFS2_ERR_NOMEM;
+            goto cleanup;
+        }
+    }
+
+    // zero to avoid information leaks
+    lfs2_cache_zero(lfs2, &lfs2->rcache);
+    lfs2_cache_zero(lfs2, &lfs2->pcache);
+
+    // setup lookahead, must be multiple of 64-bits, 32-bit aligned
+    LFS2_ASSERT(lfs2->cfg->lookahead_size > 0);
+    LFS2_ASSERT(lfs2->cfg->lookahead_size % 8 == 0 &&
+            (uintptr_t)lfs2->cfg->lookahead_buffer % 4 == 0);
+    if (lfs2->cfg->lookahead_buffer) {
+        lfs2->free.buffer = lfs2->cfg->lookahead_buffer;
+    } else {
+        lfs2->free.buffer = lfs2_malloc(lfs2->cfg->lookahead_size);
+        if (!lfs2->free.buffer) {
+            err = LFS2_ERR_NOMEM;
+            goto cleanup;
+        }
+    }
+
+    // check that the size limits are sane
+    LFS2_ASSERT(lfs2->cfg->name_max <= LFS2_NAME_MAX);
+    lfs2->name_max = lfs2->cfg->name_max;
+    if (!lfs2->name_max) {
+        lfs2->name_max = LFS2_NAME_MAX;
+    }
+
+    LFS2_ASSERT(lfs2->cfg->file_max <= LFS2_FILE_MAX);
+    lfs2->file_max = lfs2->cfg->file_max;
+    if (!lfs2->file_max) {
+        lfs2->file_max = LFS2_FILE_MAX;
+    }
+
+    LFS2_ASSERT(lfs2->cfg->attr_max <= LFS2_ATTR_MAX);
+    lfs2->attr_max = lfs2->cfg->attr_max;
+    if (!lfs2->attr_max) {
+        lfs2->attr_max = LFS2_ATTR_MAX;
+    }
+
+    // setup default state
+    lfs2->root[0] = LFS2_BLOCK_NULL;
+    lfs2->root[1] = LFS2_BLOCK_NULL;
+    lfs2->mlist = NULL;
+    lfs2->seed = 0;
+    lfs2->gdisk = (lfs2_gstate_t){0};
+    lfs2->gstate = (lfs2_gstate_t){0};
+    lfs2->gdelta = (lfs2_gstate_t){0};
+#ifdef LFS2_MIGRATE
+    lfs2->lfs21 = NULL;
+#endif
+
+    return 0;
+
+cleanup:
+    lfs2_deinit(lfs2);
+    return err;
+}
+
+static int lfs2_deinit(lfs2_t *lfs2) {
+    // free allocated memory
+    if (!lfs2->cfg->read_buffer) {
+        lfs2_free(lfs2->rcache.buffer);
+    }
+
+    if (!lfs2->cfg->prog_buffer) {
+        lfs2_free(lfs2->pcache.buffer);
+    }
+
+    if (!lfs2->cfg->lookahead_buffer) {
+        lfs2_free(lfs2->free.buffer);
+    }
+
+    return 0;
+}
+
+int lfs2_format(lfs2_t *lfs2, const struct lfs2_config *cfg) {
+    LFS2_TRACE("lfs2_format(%p, %p {.context=%p, "
+                ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
+                ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
+                ".block_size=%"PRIu32", .block_count=%"PRIu32", "
+                ".block_cycles=%"PRIu32", .cache_size=%"PRIu32", "
+                ".lookahead_size=%"PRIu32", .read_buffer=%p, "
+                ".prog_buffer=%p, .lookahead_buffer=%p, "
+                ".name_max=%"PRIu32", .file_max=%"PRIu32", "
+                ".attr_max=%"PRIu32"})",
+            (void*)lfs2, (void*)cfg, cfg->context,
+            (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
+            (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
+            cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
+            cfg->block_cycles, cfg->cache_size, cfg->lookahead_size,
+            cfg->read_buffer, cfg->prog_buffer, cfg->lookahead_buffer,
+            cfg->name_max, cfg->file_max, cfg->attr_max);
+    int err = 0;
+    {
+        err = lfs2_init(lfs2, cfg);
+        if (err) {
+            LFS2_TRACE("lfs2_format -> %d", err);
+            return err;
+        }
+
+        // create free lookahead
+        memset(lfs2->free.buffer, 0, lfs2->cfg->lookahead_size);
+        lfs2->free.off = 0;
+        lfs2->free.size = lfs2_min(8*lfs2->cfg->lookahead_size,
+                lfs2->cfg->block_count);
+        lfs2->free.i = 0;
+        lfs2_alloc_ack(lfs2);
+
+        // create root dir
+        lfs2_mdir_t root;
+        err = lfs2_dir_alloc(lfs2, &root);
+        if (err) {
+            goto cleanup;
+        }
+
+        // write one superblock
+        lfs2_superblock_t superblock = {
+            .version     = LFS2_DISK_VERSION,
+            .block_size  = lfs2->cfg->block_size,
+            .block_count = lfs2->cfg->block_count,
+            .name_max    = lfs2->name_max,
+            .file_max    = lfs2->file_max,
+            .attr_max    = lfs2->attr_max,
+        };
+
+        lfs2_superblock_tole32(&superblock);
+        err = lfs2_dir_commit(lfs2, &root, LFS2_MKATTRS(
+                {LFS2_MKTAG(LFS2_TYPE_CREATE, 0, 0)},
+                {LFS2_MKTAG(LFS2_TYPE_SUPERBLOCK, 0, 8), "littlefs"},
+                {LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, 0, sizeof(superblock)),
+                    &superblock}));
+        if (err) {
+            goto cleanup;
+        }
+
+        // sanity check that fetch works
+        err = lfs2_dir_fetch(lfs2, &root, (const lfs2_block_t[2]){0, 1});
+        if (err) {
+            goto cleanup;
+        }
+
+        // force compaction to prevent accidentally mounting any
+        // older version of littlefs that may live on disk
+        root.erased = false;
+        err = lfs2_dir_commit(lfs2, &root, NULL, 0);
+        if (err) {
+            goto cleanup;
+        }
+    }
+
+cleanup:
+    lfs2_deinit(lfs2);
+    LFS2_TRACE("lfs2_format -> %d", err);
+    return err;
+}
+
+int lfs2_mount(lfs2_t *lfs2, const struct lfs2_config *cfg) {
+    LFS2_TRACE("lfs2_mount(%p, %p {.context=%p, "
+                ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
+                ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
+                ".block_size=%"PRIu32", .block_count=%"PRIu32", "
+                ".block_cycles=%"PRIu32", .cache_size=%"PRIu32", "
+                ".lookahead_size=%"PRIu32", .read_buffer=%p, "
+                ".prog_buffer=%p, .lookahead_buffer=%p, "
+                ".name_max=%"PRIu32", .file_max=%"PRIu32", "
+                ".attr_max=%"PRIu32"})",
+            (void*)lfs2, (void*)cfg, cfg->context,
+            (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
+            (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
+            cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
+            cfg->block_cycles, cfg->cache_size, cfg->lookahead_size,
+            cfg->read_buffer, cfg->prog_buffer, cfg->lookahead_buffer,
+            cfg->name_max, cfg->file_max, cfg->attr_max);
+    int err = lfs2_init(lfs2, cfg);
+    if (err) {
+        LFS2_TRACE("lfs2_mount -> %d", err);
+        return err;
+    }
+
+    // scan directory blocks for superblock and any global updates
+    lfs2_mdir_t dir = {.tail = {0, 1}};
+    lfs2_block_t cycle = 0;
+    while (!lfs2_pair_isnull(dir.tail)) {
+        if (cycle >= lfs2->cfg->block_count/2) {
+            // loop detected
+            err = LFS2_ERR_CORRUPT;
+            goto cleanup;
+        }
+        cycle += 1;
+
+        // fetch next block in tail list
+        lfs2_stag_t tag = lfs2_dir_fetchmatch(lfs2, &dir, dir.tail,
+                LFS2_MKTAG(0x7ff, 0x3ff, 0),
+                LFS2_MKTAG(LFS2_TYPE_SUPERBLOCK, 0, 8),
+                NULL,
+                lfs2_dir_find_match, &(struct lfs2_dir_find_match){
+                    lfs2, "littlefs", 8});
+        if (tag < 0) {
+            err = tag;
+            goto cleanup;
+        }
+
+        // has superblock?
+        if (tag && !lfs2_tag_isdelete(tag)) {
+            // update root
+            lfs2->root[0] = dir.pair[0];
+            lfs2->root[1] = dir.pair[1];
+
+            // grab superblock
+            lfs2_superblock_t superblock;
+            tag = lfs2_dir_get(lfs2, &dir, LFS2_MKTAG(0x7ff, 0x3ff, 0),
+                    LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, 0, sizeof(superblock)),
+                    &superblock);
+            if (tag < 0) {
+                err = tag;
+                goto cleanup;
+            }
+            lfs2_superblock_fromle32(&superblock);
+
+            // check version
+            uint16_t major_version = (0xffff & (superblock.version >> 16));
+            uint16_t minor_version = (0xffff & (superblock.version >>  0));
+            if ((major_version != LFS2_DISK_VERSION_MAJOR ||
+                 minor_version > LFS2_DISK_VERSION_MINOR)) {
+                LFS2_ERROR("Invalid version v%"PRIu16".%"PRIu16,
+                        major_version, minor_version);
+                err = LFS2_ERR_INVAL;
+                goto cleanup;
+            }
+
+            // check superblock configuration
+            if (superblock.name_max) {
+                if (superblock.name_max > lfs2->name_max) {
+                    LFS2_ERROR("Unsupported name_max (%"PRIu32" > %"PRIu32")",
+                            superblock.name_max, lfs2->name_max);
+                    err = LFS2_ERR_INVAL;
+                    goto cleanup;
+                }
+
+                lfs2->name_max = superblock.name_max;
+            }
+
+            if (superblock.file_max) {
+                if (superblock.file_max > lfs2->file_max) {
+                    LFS2_ERROR("Unsupported file_max (%"PRIu32" > %"PRIu32")",
+                            superblock.file_max, lfs2->file_max);
+                    err = LFS2_ERR_INVAL;
+                    goto cleanup;
+                }
+
+                lfs2->file_max = superblock.file_max;
+            }
+
+            if (superblock.attr_max) {
+                if (superblock.attr_max > lfs2->attr_max) {
+                    LFS2_ERROR("Unsupported attr_max (%"PRIu32" > %"PRIu32")",
+                            superblock.attr_max, lfs2->attr_max);
+                    err = LFS2_ERR_INVAL;
+                    goto cleanup;
+                }
+
+                lfs2->attr_max = superblock.attr_max;
+            }
+        }
+
+        // has gstate?
+        err = lfs2_dir_getgstate(lfs2, &dir, &lfs2->gstate);
+        if (err) {
+            goto cleanup;
+        }
+    }
+
+    // found superblock?
+    if (lfs2_pair_isnull(lfs2->root)) {
+        err = LFS2_ERR_INVAL;
+        goto cleanup;
+    }
+
+    // update littlefs with gstate
+    if (!lfs2_gstate_iszero(&lfs2->gstate)) {
+        LFS2_DEBUG("Found pending gstate 0x%08"PRIx32"%08"PRIx32"%08"PRIx32,
+                lfs2->gstate.tag,
+                lfs2->gstate.pair[0],
+                lfs2->gstate.pair[1]);
+    }
+    lfs2->gstate.tag += !lfs2_tag_isvalid(lfs2->gstate.tag);
+    lfs2->gdisk = lfs2->gstate;
+
+    // setup free lookahead
+    lfs2_alloc_reset(lfs2);
+
+    LFS2_TRACE("lfs2_mount -> %d", 0);
+    return 0;
+
+cleanup:
+    lfs2_unmount(lfs2);
+    LFS2_TRACE("lfs2_mount -> %d", err);
+    return err;
+}
+
+int lfs2_unmount(lfs2_t *lfs2) {
+    LFS2_TRACE("lfs2_unmount(%p)", (void*)lfs2);
+    int err = lfs2_deinit(lfs2);
+    LFS2_TRACE("lfs2_unmount -> %d", err);
+    return err;
+}
+
+
+/// Filesystem filesystem operations ///
+int lfs2_fs_traverseraw(lfs2_t *lfs2,
+        int (*cb)(void *data, lfs2_block_t block), void *data,
+        bool includeorphans) {
+    // iterate over metadata pairs
+    lfs2_mdir_t dir = {.tail = {0, 1}};
+
+#ifdef LFS2_MIGRATE
+    // also consider v1 blocks during migration
+    if (lfs2->lfs21) {
+        int err = lfs21_traverse(lfs2, cb, data);
+        if (err) {
+            return err;
+        }
+
+        dir.tail[0] = lfs2->root[0];
+        dir.tail[1] = lfs2->root[1];
+    }
+#endif
+
+    lfs2_block_t cycle = 0;
+    while (!lfs2_pair_isnull(dir.tail)) {
+        if (cycle >= lfs2->cfg->block_count/2) {
+            // loop detected
+            return LFS2_ERR_CORRUPT;
+        }
+        cycle += 1;
+
+        for (int i = 0; i < 2; i++) {
+            int err = cb(data, dir.tail[i]);
+            if (err) {
+                return err;
+            }
+        }
+
+        // iterate through ids in directory
+        int err = lfs2_dir_fetch(lfs2, &dir, dir.tail);
+        if (err) {
+            return err;
+        }
+
+        for (uint16_t id = 0; id < dir.count; id++) {
+            struct lfs2_ctz ctz;
+            lfs2_stag_t tag = lfs2_dir_get(lfs2, &dir, LFS2_MKTAG(0x700, 0x3ff, 0),
+                    LFS2_MKTAG(LFS2_TYPE_STRUCT, id, sizeof(ctz)), &ctz);
+            if (tag < 0) {
+                if (tag == LFS2_ERR_NOENT) {
+                    continue;
+                }
+                return tag;
+            }
+            lfs2_ctz_fromle32(&ctz);
+
+            if (lfs2_tag_type3(tag) == LFS2_TYPE_CTZSTRUCT) {
+                err = lfs2_ctz_traverse(lfs2, NULL, &lfs2->rcache,
+                        ctz.head, ctz.size, cb, data);
+                if (err) {
+                    return err;
+                }
+            } else if (includeorphans && 
+                    lfs2_tag_type3(tag) == LFS2_TYPE_DIRSTRUCT) {
+                for (int i = 0; i < 2; i++) {
+                    err = cb(data, (&ctz.head)[i]);
+                    if (err) {
+                        return err;
+                    }
+                }
+            }
+        }
+    }
+
+    // iterate over any open files
+    for (lfs2_file_t *f = (lfs2_file_t*)lfs2->mlist; f; f = f->next) {
+        if (f->type != LFS2_TYPE_REG) {
+            continue;
+        }
+
+        if ((f->flags & LFS2_F_DIRTY) && !(f->flags & LFS2_F_INLINE)) {
+            int err = lfs2_ctz_traverse(lfs2, &f->cache, &lfs2->rcache,
+                    f->ctz.head, f->ctz.size, cb, data);
+            if (err) {
+                return err;
+            }
+        }
+
+        if ((f->flags & LFS2_F_WRITING) && !(f->flags & LFS2_F_INLINE)) {
+            int err = lfs2_ctz_traverse(lfs2, &f->cache, &lfs2->rcache,
+                    f->block, f->pos, cb, data);
+            if (err) {
+                return err;
+            }
+        }
+    }
+
+    return 0;
+}
+
+int lfs2_fs_traverse(lfs2_t *lfs2,
+        int (*cb)(void *data, lfs2_block_t block), void *data) {
+    LFS2_TRACE("lfs2_fs_traverse(%p, %p, %p)",
+            (void*)lfs2, (void*)(uintptr_t)cb, data);
+    int err = lfs2_fs_traverseraw(lfs2, cb, data, true);
+    LFS2_TRACE("lfs2_fs_traverse -> %d", 0);
+    return err;
+}
+
+static int lfs2_fs_pred(lfs2_t *lfs2,
+        const lfs2_block_t pair[2], lfs2_mdir_t *pdir) {
+    // iterate over all directory directory entries
+    pdir->tail[0] = 0;
+    pdir->tail[1] = 1;
+    lfs2_block_t cycle = 0;
+    while (!lfs2_pair_isnull(pdir->tail)) {
+        if (cycle >= lfs2->cfg->block_count/2) {
+            // loop detected
+            return LFS2_ERR_CORRUPT;
+        }
+        cycle += 1;
+
+        if (lfs2_pair_cmp(pdir->tail, pair) == 0) {
+            return 0;
+        }
+
+        int err = lfs2_dir_fetch(lfs2, pdir, pdir->tail);
+        if (err) {
+            return err;
+        }
+    }
+
+    return LFS2_ERR_NOENT;
+}
+
+struct lfs2_fs_parent_match {
+    lfs2_t *lfs2;
+    const lfs2_block_t pair[2];
+};
+
+static int lfs2_fs_parent_match(void *data,
+        lfs2_tag_t tag, const void *buffer) {
+    struct lfs2_fs_parent_match *find = data;
+    lfs2_t *lfs2 = find->lfs2;
+    const struct lfs2_diskoff *disk = buffer;
+    (void)tag;
+
+    lfs2_block_t child[2];
+    int err = lfs2_bd_read(lfs2,
+            &lfs2->pcache, &lfs2->rcache, lfs2->cfg->block_size,
+            disk->block, disk->off, &child, sizeof(child));
+    if (err) {
+        return err;
+    }
+
+    lfs2_pair_fromle32(child);
+    return (lfs2_pair_cmp(child, find->pair) == 0) ? LFS2_CMP_EQ : LFS2_CMP_LT;
+}
+
+static lfs2_stag_t lfs2_fs_parent(lfs2_t *lfs2, const lfs2_block_t pair[2],
+        lfs2_mdir_t *parent) {
+    // use fetchmatch with callback to find pairs
+    parent->tail[0] = 0;
+    parent->tail[1] = 1;
+    lfs2_block_t cycle = 0;
+    while (!lfs2_pair_isnull(parent->tail)) {
+        if (cycle >= lfs2->cfg->block_count/2) {
+            // loop detected
+            return LFS2_ERR_CORRUPT;
+        }
+        cycle += 1;
+
+        lfs2_stag_t tag = lfs2_dir_fetchmatch(lfs2, parent, parent->tail,
+                LFS2_MKTAG(0x7ff, 0, 0x3ff),
+                LFS2_MKTAG(LFS2_TYPE_DIRSTRUCT, 0, 8),
+                NULL,
+                lfs2_fs_parent_match, &(struct lfs2_fs_parent_match){
+                    lfs2, {pair[0], pair[1]}});
+        if (tag && tag != LFS2_ERR_NOENT) {
+            return tag;
+        }
+    }
+
+    return LFS2_ERR_NOENT;
+}
+
+static int lfs2_fs_relocate(lfs2_t *lfs2,
+        const lfs2_block_t oldpair[2], lfs2_block_t newpair[2]) {
+    // update internal root
+    if (lfs2_pair_cmp(oldpair, lfs2->root) == 0) {
+        lfs2->root[0] = newpair[0];
+        lfs2->root[1] = newpair[1];
+    }
+
+    // update internally tracked dirs
+    for (struct lfs2_mlist *d = lfs2->mlist; d; d = d->next) {
+        if (lfs2_pair_cmp(oldpair, d->m.pair) == 0) {
+            d->m.pair[0] = newpair[0];
+            d->m.pair[1] = newpair[1];
+        }
+
+        if (d->type == LFS2_TYPE_DIR &&
+                lfs2_pair_cmp(oldpair, ((lfs2_dir_t*)d)->head) == 0) {
+            ((lfs2_dir_t*)d)->head[0] = newpair[0];
+            ((lfs2_dir_t*)d)->head[1] = newpair[1];
+        }
+    }
+
+    // find parent
+    lfs2_mdir_t parent;
+    lfs2_stag_t tag = lfs2_fs_parent(lfs2, oldpair, &parent);
+    if (tag < 0 && tag != LFS2_ERR_NOENT) {
+        return tag;
+    }
+
+    if (tag != LFS2_ERR_NOENT) {
+        // update disk, this creates a desync
+        lfs2_fs_preporphans(lfs2, +1);
+
+        // fix pending move in this pair? this looks like an optimization but
+        // is in fact _required_ since relocating may outdate the move.
+        uint16_t moveid = 0x3ff;
+        if (lfs2_gstate_hasmovehere(&lfs2->gstate, parent.pair)) {
+            moveid = lfs2_tag_id(lfs2->gstate.tag);
+            LFS2_DEBUG("Fixing move while relocating "
+                    "{0x%"PRIx32", 0x%"PRIx32"} 0x%"PRIx16"\n",
+                    parent.pair[0], parent.pair[1], moveid);
+            lfs2_fs_prepmove(lfs2, 0x3ff, NULL);
+            if (moveid < lfs2_tag_id(tag)) {
+                tag -= LFS2_MKTAG(0, 1, 0);
+            }
+        }
+
+        lfs2_pair_tole32(newpair);
+        int err = lfs2_dir_commit(lfs2, &parent, LFS2_MKATTRS(
+                {LFS2_MKTAG_IF(moveid != 0x3ff,
+                    LFS2_TYPE_DELETE, moveid, 0)},
+                {tag, newpair}));
+        lfs2_pair_fromle32(newpair);
+        if (err) {
+            return err;
+        }
+
+        // next step, clean up orphans
+        lfs2_fs_preporphans(lfs2, -1);
+    }
+
+    // find pred
+    int err = lfs2_fs_pred(lfs2, oldpair, &parent);
+    if (err && err != LFS2_ERR_NOENT) {
+        return err;
+    }
+
+    // if we can't find dir, it must be new
+    if (err != LFS2_ERR_NOENT) {
+        // fix pending move in this pair? this looks like an optimization but
+        // is in fact _required_ since relocating may outdate the move.
+        uint16_t moveid = 0x3ff;
+        if (lfs2_gstate_hasmovehere(&lfs2->gstate, parent.pair)) {
+            moveid = lfs2_tag_id(lfs2->gstate.tag);
+            LFS2_DEBUG("Fixing move while relocating "
+                    "{0x%"PRIx32", 0x%"PRIx32"} 0x%"PRIx16"\n",
+                    parent.pair[0], parent.pair[1], moveid);
+            lfs2_fs_prepmove(lfs2, 0x3ff, NULL);
+        }
+
+        // replace bad pair, either we clean up desync, or no desync occured
+        lfs2_pair_tole32(newpair);
+        err = lfs2_dir_commit(lfs2, &parent, LFS2_MKATTRS(
+                {LFS2_MKTAG_IF(moveid != 0x3ff,
+                    LFS2_TYPE_DELETE, moveid, 0)},
+                {LFS2_MKTAG(LFS2_TYPE_TAIL + parent.split, 0x3ff, 8), newpair}));
+        lfs2_pair_fromle32(newpair);
+        if (err) {
+            return err;
+        }
+    }
+
+    return 0;
+}
+
+static void lfs2_fs_preporphans(lfs2_t *lfs2, int8_t orphans) {
+    LFS2_ASSERT(lfs2_tag_size(lfs2->gstate.tag) > 0 || orphans >= 0);
+    lfs2->gstate.tag += orphans;
+    lfs2->gstate.tag = ((lfs2->gstate.tag & ~LFS2_MKTAG(0x800, 0, 0)) |
+            ((uint32_t)lfs2_gstate_hasorphans(&lfs2->gstate) << 31));
+}
+
+static void lfs2_fs_prepmove(lfs2_t *lfs2,
+        uint16_t id, const lfs2_block_t pair[2]) {
+    lfs2->gstate.tag = ((lfs2->gstate.tag & ~LFS2_MKTAG(0x7ff, 0x3ff, 0)) |
+            ((id != 0x3ff) ? LFS2_MKTAG(LFS2_TYPE_DELETE, id, 0) : 0));
+    lfs2->gstate.pair[0] = (id != 0x3ff) ? pair[0] : 0;
+    lfs2->gstate.pair[1] = (id != 0x3ff) ? pair[1] : 0;
+}
+
+static int lfs2_fs_demove(lfs2_t *lfs2) {
+    if (!lfs2_gstate_hasmove(&lfs2->gdisk)) {
+        return 0;
+    }
+
+    // Fix bad moves
+    LFS2_DEBUG("Fixing move {0x%"PRIx32", 0x%"PRIx32"} 0x%"PRIx16,
+            lfs2->gdisk.pair[0],
+            lfs2->gdisk.pair[1],
+            lfs2_tag_id(lfs2->gdisk.tag));
+
+    // fetch and delete the moved entry
+    lfs2_mdir_t movedir;
+    int err = lfs2_dir_fetch(lfs2, &movedir, lfs2->gdisk.pair);
+    if (err) {
+        return err;
+    }
+
+    // prep gstate and delete move id
+    uint16_t moveid = lfs2_tag_id(lfs2->gdisk.tag);
+    lfs2_fs_prepmove(lfs2, 0x3ff, NULL);
+    err = lfs2_dir_commit(lfs2, &movedir, LFS2_MKATTRS(
+            {LFS2_MKTAG(LFS2_TYPE_DELETE, moveid, 0)}));
+    if (err) {
+        return err;
+    }
+
+    return 0;
+}
+
+static int lfs2_fs_deorphan(lfs2_t *lfs2) {
+    if (!lfs2_gstate_hasorphans(&lfs2->gstate)) {
+        return 0;
+    }
+
+    // Fix any orphans
+    lfs2_mdir_t pdir = {.split = true, .tail = {0, 1}};
+    lfs2_mdir_t dir;
+
+    // iterate over all directory directory entries
+    while (!lfs2_pair_isnull(pdir.tail)) {
+        int err = lfs2_dir_fetch(lfs2, &dir, pdir.tail);
+        if (err) {
+            return err;
+        }
+
+        // check head blocks for orphans
+        if (!pdir.split) {
+            // check if we have a parent
+            lfs2_mdir_t parent;
+            lfs2_stag_t tag = lfs2_fs_parent(lfs2, pdir.tail, &parent);
+            if (tag < 0 && tag != LFS2_ERR_NOENT) {
+                return tag;
+            }
+
+            if (tag == LFS2_ERR_NOENT) {
+                // we are an orphan
+                LFS2_DEBUG("Fixing orphan {0x%"PRIx32", 0x%"PRIx32"}",
+                        pdir.tail[0], pdir.tail[1]);
+
+                err = lfs2_dir_drop(lfs2, &pdir, &dir);
+                if (err) {
+                    return err;
+                }
+
+                // refetch tail
+                continue;
+            }
+
+            lfs2_block_t pair[2];
+            lfs2_stag_t res = lfs2_dir_get(lfs2, &parent,
+                    LFS2_MKTAG(0x7ff, 0x3ff, 0), tag, pair);
+            if (res < 0) {
+                return res;
+            }
+            lfs2_pair_fromle32(pair);
+
+            if (!lfs2_pair_sync(pair, pdir.tail)) {
+                // we have desynced
+                LFS2_DEBUG("Fixing half-orphan {0x%"PRIx32", 0x%"PRIx32"} "
+                            "-> {0x%"PRIx32", 0x%"PRIx32"}",
+                        pdir.tail[0], pdir.tail[1], pair[0], pair[1]);
+
+                lfs2_pair_tole32(pair);
+                err = lfs2_dir_commit(lfs2, &pdir, LFS2_MKATTRS(
+                        {LFS2_MKTAG(LFS2_TYPE_SOFTTAIL, 0x3ff, 8), pair}));
+                lfs2_pair_fromle32(pair);
+                if (err) {
+                    return err;
+                }
+
+                // refetch tail
+                continue;
+            }
+        }
+
+        pdir = dir;
+    }
+
+    // mark orphans as fixed
+    lfs2_fs_preporphans(lfs2, -lfs2_gstate_getorphans(&lfs2->gstate));
+    return 0;
+}
+
+static int lfs2_fs_forceconsistency(lfs2_t *lfs2) {
+    int err = lfs2_fs_demove(lfs2);
+    if (err) {
+        return err;
+    }
+
+    err = lfs2_fs_deorphan(lfs2);
+    if (err) {
+        return err;
+    }
+
+    return 0;
+}
+
+static int lfs2_fs_size_count(void *p, lfs2_block_t block) {
+    (void)block;
+    lfs2_size_t *size = p;
+    *size += 1;
+    return 0;
+}
+
+lfs2_ssize_t lfs2_fs_size(lfs2_t *lfs2) {
+    LFS2_TRACE("lfs2_fs_size(%p)", (void*)lfs2);
+    lfs2_size_t size = 0;
+    int err = lfs2_fs_traverseraw(lfs2, lfs2_fs_size_count, &size, false);
+    if (err) {
+        LFS2_TRACE("lfs2_fs_size -> %d", err);
+        return err;
+    }
+
+    LFS2_TRACE("lfs2_fs_size -> %d", err);
+    return size;
+}
+
+#ifdef LFS2_MIGRATE
+////// Migration from littelfs v1 below this //////
+
+/// Version info ///
+
+// Software library version
+// Major (top-nibble), incremented on backwards incompatible changes
+// Minor (bottom-nibble), incremented on feature additions
+#define LFS21_VERSION 0x00010007
+#define LFS21_VERSION_MAJOR (0xffff & (LFS21_VERSION >> 16))
+#define LFS21_VERSION_MINOR (0xffff & (LFS21_VERSION >>  0))
+
+// Version of On-disk data structures
+// Major (top-nibble), incremented on backwards incompatible changes
+// Minor (bottom-nibble), incremented on feature additions
+#define LFS21_DISK_VERSION 0x00010001
+#define LFS21_DISK_VERSION_MAJOR (0xffff & (LFS21_DISK_VERSION >> 16))
+#define LFS21_DISK_VERSION_MINOR (0xffff & (LFS21_DISK_VERSION >>  0))
+
+
+/// v1 Definitions ///
+
+// File types
+enum lfs21_type {
+    LFS21_TYPE_REG        = 0x11,
+    LFS21_TYPE_DIR        = 0x22,
+    LFS21_TYPE_SUPERBLOCK = 0x2e,
+};
+
+typedef struct lfs21 {
+    lfs2_block_t root[2];
+} lfs21_t;
+
+typedef struct lfs21_entry {
+    lfs2_off_t off;
+
+    struct lfs21_disk_entry {
+        uint8_t type;
+        uint8_t elen;
+        uint8_t alen;
+        uint8_t nlen;
+        union {
+            struct {
+                lfs2_block_t head;
+                lfs2_size_t size;
+            } file;
+            lfs2_block_t dir[2];
+        } u;
+    } d;
+} lfs21_entry_t;
+
+typedef struct lfs21_dir {
+    struct lfs21_dir *next;
+    lfs2_block_t pair[2];
+    lfs2_off_t off;
+
+    lfs2_block_t head[2];
+    lfs2_off_t pos;
+
+    struct lfs21_disk_dir {
+        uint32_t rev;
+        lfs2_size_t size;
+        lfs2_block_t tail[2];
+    } d;
+} lfs21_dir_t;
+
+typedef struct lfs21_superblock {
+    lfs2_off_t off;
+
+    struct lfs21_disk_superblock {
+        uint8_t type;
+        uint8_t elen;
+        uint8_t alen;
+        uint8_t nlen;
+        lfs2_block_t root[2];
+        uint32_t block_size;
+        uint32_t block_count;
+        uint32_t version;
+        char magic[8];
+    } d;
+} lfs21_superblock_t;
+
+
+/// Low-level wrappers v1->v2 ///
+static void lfs21_crc(uint32_t *crc, const void *buffer, size_t size) {
+    *crc = lfs2_crc(*crc, buffer, size);
+}
+
+static int lfs21_bd_read(lfs2_t *lfs2, lfs2_block_t block,
+        lfs2_off_t off, void *buffer, lfs2_size_t size) {
+    // if we ever do more than writes to alternating pairs,
+    // this may need to consider pcache
+    return lfs2_bd_read(lfs2, &lfs2->pcache, &lfs2->rcache, size,
+            block, off, buffer, size);
+}
+
+static int lfs21_bd_crc(lfs2_t *lfs2, lfs2_block_t block,
+        lfs2_off_t off, lfs2_size_t size, uint32_t *crc) {
+    for (lfs2_off_t i = 0; i < size; i++) {
+        uint8_t c;
+        int err = lfs21_bd_read(lfs2, block, off+i, &c, 1);
+        if (err) {
+            return err;
+        }
+
+        lfs21_crc(crc, &c, 1);
+    }
+
+    return 0;
+}
+
+
+/// Endian swapping functions ///
+static void lfs21_dir_fromle32(struct lfs21_disk_dir *d) {
+    d->rev     = lfs2_fromle32(d->rev);
+    d->size    = lfs2_fromle32(d->size);
+    d->tail[0] = lfs2_fromle32(d->tail[0]);
+    d->tail[1] = lfs2_fromle32(d->tail[1]);
+}
+
+static void lfs21_dir_tole32(struct lfs21_disk_dir *d) {
+    d->rev     = lfs2_tole32(d->rev);
+    d->size    = lfs2_tole32(d->size);
+    d->tail[0] = lfs2_tole32(d->tail[0]);
+    d->tail[1] = lfs2_tole32(d->tail[1]);
+}
+
+static void lfs21_entry_fromle32(struct lfs21_disk_entry *d) {
+    d->u.dir[0] = lfs2_fromle32(d->u.dir[0]);
+    d->u.dir[1] = lfs2_fromle32(d->u.dir[1]);
+}
+
+static void lfs21_entry_tole32(struct lfs21_disk_entry *d) {
+    d->u.dir[0] = lfs2_tole32(d->u.dir[0]);
+    d->u.dir[1] = lfs2_tole32(d->u.dir[1]);
+}
+
+static void lfs21_superblock_fromle32(struct lfs21_disk_superblock *d) {
+    d->root[0]     = lfs2_fromle32(d->root[0]);
+    d->root[1]     = lfs2_fromle32(d->root[1]);
+    d->block_size  = lfs2_fromle32(d->block_size);
+    d->block_count = lfs2_fromle32(d->block_count);
+    d->version     = lfs2_fromle32(d->version);
+}
+
+
+///// Metadata pair and directory operations ///
+static inline lfs2_size_t lfs21_entry_size(const lfs21_entry_t *entry) {
+    return 4 + entry->d.elen + entry->d.alen + entry->d.nlen;
+}
+
+static int lfs21_dir_fetch(lfs2_t *lfs2,
+        lfs21_dir_t *dir, const lfs2_block_t pair[2]) {
+    // copy out pair, otherwise may be aliasing dir
+    const lfs2_block_t tpair[2] = {pair[0], pair[1]};
+    bool valid = false;
+
+    // check both blocks for the most recent revision
+    for (int i = 0; i < 2; i++) {
+        struct lfs21_disk_dir test;
+        int err = lfs21_bd_read(lfs2, tpair[i], 0, &test, sizeof(test));
+        lfs21_dir_fromle32(&test);
+        if (err) {
+            if (err == LFS2_ERR_CORRUPT) {
+                continue;
+            }
+            return err;
+        }
+
+        if (valid && lfs2_scmp(test.rev, dir->d.rev) < 0) {
+            continue;
+        }
+
+        if ((0x7fffffff & test.size) < sizeof(test)+4 ||
+            (0x7fffffff & test.size) > lfs2->cfg->block_size) {
+            continue;
+        }
+
+        uint32_t crc = 0xffffffff;
+        lfs21_dir_tole32(&test);
+        lfs21_crc(&crc, &test, sizeof(test));
+        lfs21_dir_fromle32(&test);
+        err = lfs21_bd_crc(lfs2, tpair[i], sizeof(test),
+                (0x7fffffff & test.size) - sizeof(test), &crc);
+        if (err) {
+            if (err == LFS2_ERR_CORRUPT) {
+                continue;
+            }
+            return err;
+        }
+
+        if (crc != 0) {
+            continue;
+        }
+
+        valid = true;
+
+        // setup dir in case it's valid
+        dir->pair[0] = tpair[(i+0) % 2];
+        dir->pair[1] = tpair[(i+1) % 2];
+        dir->off = sizeof(dir->d);
+        dir->d = test;
+    }
+
+    if (!valid) {
+        LFS2_ERROR("Corrupted dir pair at {0x%"PRIx32", 0x%"PRIx32"}",
+                tpair[0], tpair[1]);
+        return LFS2_ERR_CORRUPT;
+    }
+
+    return 0;
+}
+
+static int lfs21_dir_next(lfs2_t *lfs2, lfs21_dir_t *dir, lfs21_entry_t *entry) {
+    while (dir->off + sizeof(entry->d) > (0x7fffffff & dir->d.size)-4) {
+        if (!(0x80000000 & dir->d.size)) {
+            entry->off = dir->off;
+            return LFS2_ERR_NOENT;
+        }
+
+        int err = lfs21_dir_fetch(lfs2, dir, dir->d.tail);
+        if (err) {
+            return err;
+        }
+
+        dir->off = sizeof(dir->d);
+        dir->pos += sizeof(dir->d) + 4;
+    }
+
+    int err = lfs21_bd_read(lfs2, dir->pair[0], dir->off,
+            &entry->d, sizeof(entry->d));
+    lfs21_entry_fromle32(&entry->d);
+    if (err) {
+        return err;
+    }
+
+    entry->off = dir->off;
+    dir->off += lfs21_entry_size(entry);
+    dir->pos += lfs21_entry_size(entry);
+    return 0;
+}
+
+/// littlefs v1 specific operations ///
+int lfs21_traverse(lfs2_t *lfs2, int (*cb)(void*, lfs2_block_t), void *data) {
+    if (lfs2_pair_isnull(lfs2->lfs21->root)) {
+        return 0;
+    }
+
+    // iterate over metadata pairs
+    lfs21_dir_t dir;
+    lfs21_entry_t entry;
+    lfs2_block_t cwd[2] = {0, 1};
+
+    while (true) {
+        for (int i = 0; i < 2; i++) {
+            int err = cb(data, cwd[i]);
+            if (err) {
+                return err;
+            }
+        }
+
+        int err = lfs21_dir_fetch(lfs2, &dir, cwd);
+        if (err) {
+            return err;
+        }
+
+        // iterate over contents
+        while (dir.off + sizeof(entry.d) <= (0x7fffffff & dir.d.size)-4) {
+            err = lfs21_bd_read(lfs2, dir.pair[0], dir.off,
+                    &entry.d, sizeof(entry.d));
+            lfs21_entry_fromle32(&entry.d);
+            if (err) {
+                return err;
+            }
+
+            dir.off += lfs21_entry_size(&entry);
+            if ((0x70 & entry.d.type) == (0x70 & LFS21_TYPE_REG)) {
+                err = lfs2_ctz_traverse(lfs2, NULL, &lfs2->rcache,
+                        entry.d.u.file.head, entry.d.u.file.size, cb, data);
+                if (err) {
+                    return err;
+                }
+            }
+        }
+
+        // we also need to check if we contain a threaded v2 directory
+        lfs2_mdir_t dir2 = {.split=true, .tail={cwd[0], cwd[1]}};
+        while (dir2.split) {
+            err = lfs2_dir_fetch(lfs2, &dir2, dir2.tail);
+            if (err) {
+                break;
+            }
+
+            for (int i = 0; i < 2; i++) {
+                err = cb(data, dir2.pair[i]);
+                if (err) {
+                    return err;
+                }
+            }
+        }
+
+        cwd[0] = dir.d.tail[0];
+        cwd[1] = dir.d.tail[1];
+
+        if (lfs2_pair_isnull(cwd)) {
+            break;
+        }
+    }
+
+    return 0;
+}
+
+static int lfs21_moved(lfs2_t *lfs2, const void *e) {
+    if (lfs2_pair_isnull(lfs2->lfs21->root)) {
+        return 0;
+    }
+
+    // skip superblock
+    lfs21_dir_t cwd;
+    int err = lfs21_dir_fetch(lfs2, &cwd, (const lfs2_block_t[2]){0, 1});
+    if (err) {
+        return err;
+    }
+
+    // iterate over all directory directory entries
+    lfs21_entry_t entry;
+    while (!lfs2_pair_isnull(cwd.d.tail)) {
+        err = lfs21_dir_fetch(lfs2, &cwd, cwd.d.tail);
+        if (err) {
+            return err;
+        }
+
+        while (true) {
+            err = lfs21_dir_next(lfs2, &cwd, &entry);
+            if (err && err != LFS2_ERR_NOENT) {
+                return err;
+            }
+
+            if (err == LFS2_ERR_NOENT) {
+                break;
+            }
+
+            if (!(0x80 & entry.d.type) &&
+                 memcmp(&entry.d.u, e, sizeof(entry.d.u)) == 0) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+/// Filesystem operations ///
+static int lfs21_mount(lfs2_t *lfs2, struct lfs21 *lfs21,
+        const struct lfs2_config *cfg) {
+    int err = 0;
+    {
+        err = lfs2_init(lfs2, cfg);
+        if (err) {
+            return err;
+        }
+
+        lfs2->lfs21 = lfs21;
+        lfs2->lfs21->root[0] = LFS2_BLOCK_NULL;
+        lfs2->lfs21->root[1] = LFS2_BLOCK_NULL;
+
+        // setup free lookahead
+        lfs2->free.off = 0;
+        lfs2->free.size = 0;
+        lfs2->free.i = 0;
+        lfs2_alloc_ack(lfs2);
+
+        // load superblock
+        lfs21_dir_t dir;
+        lfs21_superblock_t superblock;
+        err = lfs21_dir_fetch(lfs2, &dir, (const lfs2_block_t[2]){0, 1});
+        if (err && err != LFS2_ERR_CORRUPT) {
+            goto cleanup;
+        }
+
+        if (!err) {
+            err = lfs21_bd_read(lfs2, dir.pair[0], sizeof(dir.d),
+                    &superblock.d, sizeof(superblock.d));
+            lfs21_superblock_fromle32(&superblock.d);
+            if (err) {
+                goto cleanup;
+            }
+
+            lfs2->lfs21->root[0] = superblock.d.root[0];
+            lfs2->lfs21->root[1] = superblock.d.root[1];
+        }
+
+        if (err || memcmp(superblock.d.magic, "littlefs", 8) != 0) {
+            LFS2_ERROR("Invalid superblock at {0x%"PRIx32", 0x%"PRIx32"}",
+                    0, 1);
+            err = LFS2_ERR_CORRUPT;
+            goto cleanup;
+        }
+
+        uint16_t major_version = (0xffff & (superblock.d.version >> 16));
+        uint16_t minor_version = (0xffff & (superblock.d.version >>  0));
+        if ((major_version != LFS21_DISK_VERSION_MAJOR ||
+             minor_version > LFS21_DISK_VERSION_MINOR)) {
+            LFS2_ERROR("Invalid version v%d.%d", major_version, minor_version);
+            err = LFS2_ERR_INVAL;
+            goto cleanup;
+        }
+
+        return 0;
+    }
+
+cleanup:
+    lfs2_deinit(lfs2);
+    return err;
+}
+
+static int lfs21_unmount(lfs2_t *lfs2) {
+    return lfs2_deinit(lfs2);
+}
+
+/// v1 migration ///
+int lfs2_migrate(lfs2_t *lfs2, const struct lfs2_config *cfg) {
+    LFS2_TRACE("lfs2_migrate(%p, %p {.context=%p, "
+                ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
+                ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
+                ".block_size=%"PRIu32", .block_count=%"PRIu32", "
+                ".block_cycles=%"PRIu32", .cache_size=%"PRIu32", "
+                ".lookahead_size=%"PRIu32", .read_buffer=%p, "
+                ".prog_buffer=%p, .lookahead_buffer=%p, "
+                ".name_max=%"PRIu32", .file_max=%"PRIu32", "
+                ".attr_max=%"PRIu32"})",
+            (void*)lfs2, (void*)cfg, cfg->context,
+            (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
+            (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
+            cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
+            cfg->block_cycles, cfg->cache_size, cfg->lookahead_size,
+            cfg->read_buffer, cfg->prog_buffer, cfg->lookahead_buffer,
+            cfg->name_max, cfg->file_max, cfg->attr_max);
+    struct lfs21 lfs21;
+    int err = lfs21_mount(lfs2, &lfs21, cfg);
+    if (err) {
+        LFS2_TRACE("lfs2_migrate -> %d", err);
+        return err;
+    }
+
+    {
+        // iterate through each directory, copying over entries
+        // into new directory
+        lfs21_dir_t dir1;
+        lfs2_mdir_t dir2;
+        dir1.d.tail[0] = lfs2->lfs21->root[0];
+        dir1.d.tail[1] = lfs2->lfs21->root[1];
+        while (!lfs2_pair_isnull(dir1.d.tail)) {
+            // iterate old dir
+            err = lfs21_dir_fetch(lfs2, &dir1, dir1.d.tail);
+            if (err) {
+                goto cleanup;
+            }
+
+            // create new dir and bind as temporary pretend root
+            err = lfs2_dir_alloc(lfs2, &dir2);
+            if (err) {
+                goto cleanup;
+            }
+
+            dir2.rev = dir1.d.rev;
+            dir1.head[0] = dir1.pair[0];
+            dir1.head[1] = dir1.pair[1];
+            lfs2->root[0] = dir2.pair[0];
+            lfs2->root[1] = dir2.pair[1];
+
+            err = lfs2_dir_commit(lfs2, &dir2, NULL, 0);
+            if (err) {
+                goto cleanup;
+            }
+
+            while (true) {
+                lfs21_entry_t entry1;
+                err = lfs21_dir_next(lfs2, &dir1, &entry1);
+                if (err && err != LFS2_ERR_NOENT) {
+                    goto cleanup;
+                }
+
+                if (err == LFS2_ERR_NOENT) {
+                    break;
+                }
+
+                // check that entry has not been moved
+                if (entry1.d.type & 0x80) {
+                    int moved = lfs21_moved(lfs2, &entry1.d.u);
+                    if (moved < 0) {
+                        err = moved;
+                        goto cleanup;
+                    }
+
+                    if (moved) {
+                        continue;
+                    }
+
+                    entry1.d.type &= ~0x80;
+                }
+
+                // also fetch name
+                char name[LFS2_NAME_MAX+1];
+                memset(name, 0, sizeof(name));
+                err = lfs21_bd_read(lfs2, dir1.pair[0],
+                        entry1.off + 4+entry1.d.elen+entry1.d.alen,
+                        name, entry1.d.nlen);
+                if (err) {
+                    goto cleanup;
+                }
+
+                bool isdir = (entry1.d.type == LFS21_TYPE_DIR);
+
+                // create entry in new dir
+                err = lfs2_dir_fetch(lfs2, &dir2, lfs2->root);
+                if (err) {
+                    goto cleanup;
+                }
+
+                uint16_t id;
+                err = lfs2_dir_find(lfs2, &dir2, &(const char*){name}, &id);
+                if (!(err == LFS2_ERR_NOENT && id != 0x3ff)) {
+                    err = (err < 0) ? err : LFS2_ERR_EXIST;
+                    goto cleanup;
+                }
+
+                lfs21_entry_tole32(&entry1.d);
+                err = lfs2_dir_commit(lfs2, &dir2, LFS2_MKATTRS(
+                        {LFS2_MKTAG(LFS2_TYPE_CREATE, id, 0)},
+                        {LFS2_MKTAG_IF_ELSE(isdir,
+                            LFS2_TYPE_DIR, id, entry1.d.nlen,
+                            LFS2_TYPE_REG, id, entry1.d.nlen),
+                                name},
+                        {LFS2_MKTAG_IF_ELSE(isdir,
+                            LFS2_TYPE_DIRSTRUCT, id, sizeof(entry1.d.u),
+                            LFS2_TYPE_CTZSTRUCT, id, sizeof(entry1.d.u)),
+                                &entry1.d.u}));
+                lfs21_entry_fromle32(&entry1.d);
+                if (err) {
+                    goto cleanup;
+                }
+            }
+
+            if (!lfs2_pair_isnull(dir1.d.tail)) {
+                // find last block and update tail to thread into fs
+                err = lfs2_dir_fetch(lfs2, &dir2, lfs2->root);
+                if (err) {
+                    goto cleanup;
+                }
+
+                while (dir2.split) {
+                    err = lfs2_dir_fetch(lfs2, &dir2, dir2.tail);
+                    if (err) {
+                        goto cleanup;
+                    }
+                }
+
+                lfs2_pair_tole32(dir2.pair);
+                err = lfs2_dir_commit(lfs2, &dir2, LFS2_MKATTRS(
+                        {LFS2_MKTAG(LFS2_TYPE_SOFTTAIL, 0x3ff, 8), dir1.d.tail}));
+                lfs2_pair_fromle32(dir2.pair);
+                if (err) {
+                    goto cleanup;
+                }
+            }
+
+            // Copy over first block to thread into fs. Unfortunately
+            // if this fails there is not much we can do.
+            LFS2_DEBUG("Migrating {0x%"PRIx32", 0x%"PRIx32"} "
+                        "-> {0x%"PRIx32", 0x%"PRIx32"}",
+                    lfs2->root[0], lfs2->root[1], dir1.head[0], dir1.head[1]);
+
+            err = lfs2_bd_erase(lfs2, dir1.head[1]);
+            if (err) {
+                goto cleanup;
+            }
+
+            err = lfs2_dir_fetch(lfs2, &dir2, lfs2->root);
+            if (err) {
+                goto cleanup;
+            }
+
+            for (lfs2_off_t i = 0; i < dir2.off; i++) {
+                uint8_t dat;
+                err = lfs2_bd_read(lfs2,
+                        NULL, &lfs2->rcache, dir2.off,
+                        dir2.pair[0], i, &dat, 1);
+                if (err) {
+                    goto cleanup;
+                }
+
+                err = lfs2_bd_prog(lfs2,
+                        &lfs2->pcache, &lfs2->rcache, true,
+                        dir1.head[1], i, &dat, 1);
+                if (err) {
+                    goto cleanup;
+                }
+            }
+
+            err = lfs2_bd_flush(lfs2, &lfs2->pcache, &lfs2->rcache, true);
+            if (err) {
+                goto cleanup;
+            }
+        }
+
+        // Create new superblock. This marks a successful migration!
+        err = lfs21_dir_fetch(lfs2, &dir1, (const lfs2_block_t[2]){0, 1});
+        if (err) {
+            goto cleanup;
+        }
+
+        dir2.pair[0] = dir1.pair[0];
+        dir2.pair[1] = dir1.pair[1];
+        dir2.rev = dir1.d.rev;
+        dir2.off = sizeof(dir2.rev);
+        dir2.etag = 0xffffffff;
+        dir2.count = 0;
+        dir2.tail[0] = lfs2->lfs21->root[0];
+        dir2.tail[1] = lfs2->lfs21->root[1];
+        dir2.erased = false;
+        dir2.split = true;
+
+        lfs2_superblock_t superblock = {
+            .version     = LFS2_DISK_VERSION,
+            .block_size  = lfs2->cfg->block_size,
+            .block_count = lfs2->cfg->block_count,
+            .name_max    = lfs2->name_max,
+            .file_max    = lfs2->file_max,
+            .attr_max    = lfs2->attr_max,
+        };
+
+        lfs2_superblock_tole32(&superblock);
+        err = lfs2_dir_commit(lfs2, &dir2, LFS2_MKATTRS(
+                {LFS2_MKTAG(LFS2_TYPE_CREATE, 0, 0)},
+                {LFS2_MKTAG(LFS2_TYPE_SUPERBLOCK, 0, 8), "littlefs"},
+                {LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, 0, sizeof(superblock)),
+                    &superblock}));
+        if (err) {
+            goto cleanup;
+        }
+
+        // sanity check that fetch works
+        err = lfs2_dir_fetch(lfs2, &dir2, (const lfs2_block_t[2]){0, 1});
+        if (err) {
+            goto cleanup;
+        }
+
+        // force compaction to prevent accidentally mounting v1
+        dir2.erased = false;
+        err = lfs2_dir_commit(lfs2, &dir2, NULL, 0);
+        if (err) {
+            goto cleanup;
+        }
+    }
+
+cleanup:
+    lfs21_unmount(lfs2);
+    LFS2_TRACE("lfs2_migrate -> %d", err);
+    return err;
+}
+
+#endif
diff --git a/lib/littlefs/lfs2.h b/lib/littlefs/lfs2.h
new file mode 100644
index 0000000000000..c89af79cabddd
--- /dev/null
+++ b/lib/littlefs/lfs2.h
@@ -0,0 +1,655 @@
+/*
+ * The little filesystem
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#ifndef LFS2_H
+#define LFS2_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+/// Version info ///
+
+// Software library version
+// Major (top-nibble), incremented on backwards incompatible changes
+// Minor (bottom-nibble), incremented on feature additions
+#define LFS2_VERSION 0x00020002
+#define LFS2_VERSION_MAJOR (0xffff & (LFS2_VERSION >> 16))
+#define LFS2_VERSION_MINOR (0xffff & (LFS2_VERSION >>  0))
+
+// Version of On-disk data structures
+// Major (top-nibble), incremented on backwards incompatible changes
+// Minor (bottom-nibble), incremented on feature additions
+#define LFS2_DISK_VERSION 0x00020000
+#define LFS2_DISK_VERSION_MAJOR (0xffff & (LFS2_DISK_VERSION >> 16))
+#define LFS2_DISK_VERSION_MINOR (0xffff & (LFS2_DISK_VERSION >>  0))
+
+
+/// Definitions ///
+
+// Type definitions
+typedef uint32_t lfs2_size_t;
+typedef uint32_t lfs2_off_t;
+
+typedef int32_t  lfs2_ssize_t;
+typedef int32_t  lfs2_soff_t;
+
+typedef uint32_t lfs2_block_t;
+
+// Maximum name size in bytes, may be redefined to reduce the size of the
+// info struct. Limited to <= 1022. Stored in superblock and must be
+// respected by other littlefs drivers.
+#ifndef LFS2_NAME_MAX
+#define LFS2_NAME_MAX 255
+#endif
+
+// Maximum size of a file in bytes, may be redefined to limit to support other
+// drivers. Limited on disk to <= 4294967296. However, above 2147483647 the
+// functions lfs2_file_seek, lfs2_file_size, and lfs2_file_tell will return
+// incorrect values due to using signed integers. Stored in superblock and
+// must be respected by other littlefs drivers.
+#ifndef LFS2_FILE_MAX
+#define LFS2_FILE_MAX 2147483647
+#endif
+
+// Maximum size of custom attributes in bytes, may be redefined, but there is
+// no real benefit to using a smaller LFS2_ATTR_MAX. Limited to <= 1022.
+#ifndef LFS2_ATTR_MAX
+#define LFS2_ATTR_MAX 1022
+#endif
+
+// Possible error codes, these are negative to allow
+// valid positive return values
+enum lfs2_error {
+    LFS2_ERR_OK          = 0,    // No error
+    LFS2_ERR_IO          = -5,   // Error during device operation
+    LFS2_ERR_CORRUPT     = -84,  // Corrupted
+    LFS2_ERR_NOENT       = -2,   // No directory entry
+    LFS2_ERR_EXIST       = -17,  // Entry already exists
+    LFS2_ERR_NOTDIR      = -20,  // Entry is not a dir
+    LFS2_ERR_ISDIR       = -21,  // Entry is a dir
+    LFS2_ERR_NOTEMPTY    = -39,  // Dir is not empty
+    LFS2_ERR_BADF        = -9,   // Bad file number
+    LFS2_ERR_FBIG        = -27,  // File too large
+    LFS2_ERR_INVAL       = -22,  // Invalid parameter
+    LFS2_ERR_NOSPC       = -28,  // No space left on device
+    LFS2_ERR_NOMEM       = -12,  // No more memory available
+    LFS2_ERR_NOATTR      = -61,  // No data/attr available
+    LFS2_ERR_NAMETOOLONG = -36,  // File name too long
+};
+
+// File types
+enum lfs2_type {
+    // file types
+    LFS2_TYPE_REG            = 0x001,
+    LFS2_TYPE_DIR            = 0x002,
+
+    // internally used types
+    LFS2_TYPE_SPLICE         = 0x400,
+    LFS2_TYPE_NAME           = 0x000,
+    LFS2_TYPE_STRUCT         = 0x200,
+    LFS2_TYPE_USERATTR       = 0x300,
+    LFS2_TYPE_FROM           = 0x100,
+    LFS2_TYPE_TAIL           = 0x600,
+    LFS2_TYPE_GLOBALS        = 0x700,
+    LFS2_TYPE_CRC            = 0x500,
+
+    // internally used type specializations
+    LFS2_TYPE_CREATE         = 0x401,
+    LFS2_TYPE_DELETE         = 0x4ff,
+    LFS2_TYPE_SUPERBLOCK     = 0x0ff,
+    LFS2_TYPE_DIRSTRUCT      = 0x200,
+    LFS2_TYPE_CTZSTRUCT      = 0x202,
+    LFS2_TYPE_INLINESTRUCT   = 0x201,
+    LFS2_TYPE_SOFTTAIL       = 0x600,
+    LFS2_TYPE_HARDTAIL       = 0x601,
+    LFS2_TYPE_MOVESTATE      = 0x7ff,
+
+    // internal chip sources
+    LFS2_FROM_NOOP           = 0x000,
+    LFS2_FROM_MOVE           = 0x101,
+    LFS2_FROM_USERATTRS      = 0x102,
+};
+
+// File open flags
+enum lfs2_open_flags {
+    // open flags
+    LFS2_O_RDONLY = 1,         // Open a file as read only
+    LFS2_O_WRONLY = 2,         // Open a file as write only
+    LFS2_O_RDWR   = 3,         // Open a file as read and write
+    LFS2_O_CREAT  = 0x0100,    // Create a file if it does not exist
+    LFS2_O_EXCL   = 0x0200,    // Fail if a file already exists
+    LFS2_O_TRUNC  = 0x0400,    // Truncate the existing file to zero size
+    LFS2_O_APPEND = 0x0800,    // Move to end of file on every write
+
+    // internally used flags
+    LFS2_F_DIRTY   = 0x010000, // File does not match storage
+    LFS2_F_WRITING = 0x020000, // File has been written since last flush
+    LFS2_F_READING = 0x040000, // File has been read since last flush
+    LFS2_F_ERRED   = 0x080000, // An error occured during write
+    LFS2_F_INLINE  = 0x100000, // Currently inlined in directory entry
+    LFS2_F_OPENED  = 0x200000, // File has been opened
+};
+
+// File seek flags
+enum lfs2_whence_flags {
+    LFS2_SEEK_SET = 0,   // Seek relative to an absolute position
+    LFS2_SEEK_CUR = 1,   // Seek relative to the current file position
+    LFS2_SEEK_END = 2,   // Seek relative to the end of the file
+};
+
+
+// Configuration provided during initialization of the littlefs
+struct lfs2_config {
+    // Opaque user provided context that can be used to pass
+    // information to the block device operations
+    void *context;
+
+    // Read a region in a block. Negative error codes are propogated
+    // to the user.
+    int (*read)(const struct lfs2_config *c, lfs2_block_t block,
+            lfs2_off_t off, void *buffer, lfs2_size_t size);
+
+    // Program a region in a block. The block must have previously
+    // been erased. Negative error codes are propogated to the user.
+    // May return LFS2_ERR_CORRUPT if the block should be considered bad.
+    int (*prog)(const struct lfs2_config *c, lfs2_block_t block,
+            lfs2_off_t off, const void *buffer, lfs2_size_t size);
+
+    // Erase a block. A block must be erased before being programmed.
+    // The state of an erased block is undefined. Negative error codes
+    // are propogated to the user.
+    // May return LFS2_ERR_CORRUPT if the block should be considered bad.
+    int (*erase)(const struct lfs2_config *c, lfs2_block_t block);
+
+    // Sync the state of the underlying block device. Negative error codes
+    // are propogated to the user.
+    int (*sync)(const struct lfs2_config *c);
+
+    // Minimum size of a block read. All read operations will be a
+    // multiple of this value.
+    lfs2_size_t read_size;
+
+    // Minimum size of a block program. All program operations will be a
+    // multiple of this value.
+    lfs2_size_t prog_size;
+
+    // Size of an erasable block. This does not impact ram consumption and
+    // may be larger than the physical erase size. However, non-inlined files
+    // take up at minimum one block. Must be a multiple of the read
+    // and program sizes.
+    lfs2_size_t block_size;
+
+    // Number of erasable blocks on the device.
+    lfs2_size_t block_count;
+
+    // Number of erase cycles before littlefs evicts metadata logs and moves 
+    // the metadata to another block. Suggested values are in the
+    // range 100-1000, with large values having better performance at the cost
+    // of less consistent wear distribution.
+    //
+    // Set to -1 to disable block-level wear-leveling.
+    int32_t block_cycles;
+
+    // Size of block caches. Each cache buffers a portion of a block in RAM.
+    // The littlefs needs a read cache, a program cache, and one additional
+    // cache per file. Larger caches can improve performance by storing more
+    // data and reducing the number of disk accesses. Must be a multiple of
+    // the read and program sizes, and a factor of the block size.
+    lfs2_size_t cache_size;
+
+    // Size of the lookahead buffer in bytes. A larger lookahead buffer
+    // increases the number of blocks found during an allocation pass. The
+    // lookahead buffer is stored as a compact bitmap, so each byte of RAM
+    // can track 8 blocks. Must be a multiple of 8.
+    lfs2_size_t lookahead_size;
+
+    // Optional statically allocated read buffer. Must be cache_size.
+    // By default lfs2_malloc is used to allocate this buffer.
+    void *read_buffer;
+
+    // Optional statically allocated program buffer. Must be cache_size.
+    // By default lfs2_malloc is used to allocate this buffer.
+    void *prog_buffer;
+
+    // Optional statically allocated lookahead buffer. Must be lookahead_size
+    // and aligned to a 32-bit boundary. By default lfs2_malloc is used to
+    // allocate this buffer.
+    void *lookahead_buffer;
+
+    // Optional upper limit on length of file names in bytes. No downside for
+    // larger names except the size of the info struct which is controlled by
+    // the LFS2_NAME_MAX define. Defaults to LFS2_NAME_MAX when zero. Stored in
+    // superblock and must be respected by other littlefs drivers.
+    lfs2_size_t name_max;
+
+    // Optional upper limit on files in bytes. No downside for larger files
+    // but must be <= LFS2_FILE_MAX. Defaults to LFS2_FILE_MAX when zero. Stored
+    // in superblock and must be respected by other littlefs drivers.
+    lfs2_size_t file_max;
+
+    // Optional upper limit on custom attributes in bytes. No downside for
+    // larger attributes size but must be <= LFS2_ATTR_MAX. Defaults to
+    // LFS2_ATTR_MAX when zero.
+    lfs2_size_t attr_max;
+};
+
+// File info structure
+struct lfs2_info {
+    // Type of the file, either LFS2_TYPE_REG or LFS2_TYPE_DIR
+    uint8_t type;
+
+    // Size of the file, only valid for REG files. Limited to 32-bits.
+    lfs2_size_t size;
+
+    // Name of the file stored as a null-terminated string. Limited to
+    // LFS2_NAME_MAX+1, which can be changed by redefining LFS2_NAME_MAX to
+    // reduce RAM. LFS2_NAME_MAX is stored in superblock and must be
+    // respected by other littlefs drivers.
+    char name[LFS2_NAME_MAX+1];
+};
+
+// Custom attribute structure, used to describe custom attributes
+// committed atomically during file writes.
+struct lfs2_attr {
+    // 8-bit type of attribute, provided by user and used to
+    // identify the attribute
+    uint8_t type;
+
+    // Pointer to buffer containing the attribute
+    void *buffer;
+
+    // Size of attribute in bytes, limited to LFS2_ATTR_MAX
+    lfs2_size_t size;
+};
+
+// Optional configuration provided during lfs2_file_opencfg
+struct lfs2_file_config {
+    // Optional statically allocated file buffer. Must be cache_size.
+    // By default lfs2_malloc is used to allocate this buffer.
+    void *buffer;
+
+    // Optional list of custom attributes related to the file. If the file
+    // is opened with read access, these attributes will be read from disk
+    // during the open call. If the file is opened with write access, the
+    // attributes will be written to disk every file sync or close. This
+    // write occurs atomically with update to the file's contents.
+    //
+    // Custom attributes are uniquely identified by an 8-bit type and limited
+    // to LFS2_ATTR_MAX bytes. When read, if the stored attribute is smaller
+    // than the buffer, it will be padded with zeros. If the stored attribute
+    // is larger, then it will be silently truncated. If the attribute is not
+    // found, it will be created implicitly.
+    struct lfs2_attr *attrs;
+
+    // Number of custom attributes in the list
+    lfs2_size_t attr_count;
+};
+
+
+/// internal littlefs data structures ///
+typedef struct lfs2_cache {
+    lfs2_block_t block;
+    lfs2_off_t off;
+    lfs2_size_t size;
+    uint8_t *buffer;
+} lfs2_cache_t;
+
+typedef struct lfs2_mdir {
+    lfs2_block_t pair[2];
+    uint32_t rev;
+    lfs2_off_t off;
+    uint32_t etag;
+    uint16_t count;
+    bool erased;
+    bool split;
+    lfs2_block_t tail[2];
+} lfs2_mdir_t;
+
+// littlefs directory type
+typedef struct lfs2_dir {
+    struct lfs2_dir *next;
+    uint16_t id;
+    uint8_t type;
+    lfs2_mdir_t m;
+
+    lfs2_off_t pos;
+    lfs2_block_t head[2];
+} lfs2_dir_t;
+
+// littlefs file type
+typedef struct lfs2_file {
+    struct lfs2_file *next;
+    uint16_t id;
+    uint8_t type;
+    lfs2_mdir_t m;
+
+    struct lfs2_ctz {
+        lfs2_block_t head;
+        lfs2_size_t size;
+    } ctz;
+
+    uint32_t flags;
+    lfs2_off_t pos;
+    lfs2_block_t block;
+    lfs2_off_t off;
+    lfs2_cache_t cache;
+
+    const struct lfs2_file_config *cfg;
+} lfs2_file_t;
+
+typedef struct lfs2_superblock {
+    uint32_t version;
+    lfs2_size_t block_size;
+    lfs2_size_t block_count;
+    lfs2_size_t name_max;
+    lfs2_size_t file_max;
+    lfs2_size_t attr_max;
+} lfs2_superblock_t;
+
+typedef struct lfs2_gstate {
+    uint32_t tag;
+    lfs2_block_t pair[2];
+} lfs2_gstate_t;
+
+// The littlefs filesystem type
+typedef struct lfs2 {
+    lfs2_cache_t rcache;
+    lfs2_cache_t pcache;
+
+    lfs2_block_t root[2];
+    struct lfs2_mlist {
+        struct lfs2_mlist *next;
+        uint16_t id;
+        uint8_t type;
+        lfs2_mdir_t m;
+    } *mlist;
+    uint32_t seed;
+
+    lfs2_gstate_t gstate;
+    lfs2_gstate_t gdisk;
+    lfs2_gstate_t gdelta;
+
+    struct lfs2_free {
+        lfs2_block_t off;
+        lfs2_block_t size;
+        lfs2_block_t i;
+        lfs2_block_t ack;
+        uint32_t *buffer;
+    } free;
+
+    const struct lfs2_config *cfg;
+    lfs2_size_t name_max;
+    lfs2_size_t file_max;
+    lfs2_size_t attr_max;
+
+#ifdef LFS2_MIGRATE
+    struct lfs21 *lfs21;
+#endif
+} lfs2_t;
+
+
+/// Filesystem functions ///
+
+// Format a block device with the littlefs
+//
+// Requires a littlefs object and config struct. This clobbers the littlefs
+// object, and does not leave the filesystem mounted. The config struct must
+// be zeroed for defaults and backwards compatibility.
+//
+// Returns a negative error code on failure.
+int lfs2_format(lfs2_t *lfs2, const struct lfs2_config *config);
+
+// Mounts a littlefs
+//
+// Requires a littlefs object and config struct. Multiple filesystems
+// may be mounted simultaneously with multiple littlefs objects. Both
+// lfs2 and config must be allocated while mounted. The config struct must
+// be zeroed for defaults and backwards compatibility.
+//
+// Returns a negative error code on failure.
+int lfs2_mount(lfs2_t *lfs2, const struct lfs2_config *config);
+
+// Unmounts a littlefs
+//
+// Does nothing besides releasing any allocated resources.
+// Returns a negative error code on failure.
+int lfs2_unmount(lfs2_t *lfs2);
+
+/// General operations ///
+
+// Removes a file or directory
+//
+// If removing a directory, the directory must be empty.
+// Returns a negative error code on failure.
+int lfs2_remove(lfs2_t *lfs2, const char *path);
+
+// Rename or move a file or directory
+//
+// If the destination exists, it must match the source in type.
+// If the destination is a directory, the directory must be empty.
+//
+// Returns a negative error code on failure.
+int lfs2_rename(lfs2_t *lfs2, const char *oldpath, const char *newpath);
+
+// Find info about a file or directory
+//
+// Fills out the info structure, based on the specified file or directory.
+// Returns a negative error code on failure.
+int lfs2_stat(lfs2_t *lfs2, const char *path, struct lfs2_info *info);
+
+// Get a custom attribute
+//
+// Custom attributes are uniquely identified by an 8-bit type and limited
+// to LFS2_ATTR_MAX bytes. When read, if the stored attribute is smaller than
+// the buffer, it will be padded with zeros. If the stored attribute is larger,
+// then it will be silently truncated. If no attribute is found, the error
+// LFS2_ERR_NOATTR is returned and the buffer is filled with zeros.
+//
+// Returns the size of the attribute, or a negative error code on failure.
+// Note, the returned size is the size of the attribute on disk, irrespective
+// of the size of the buffer. This can be used to dynamically allocate a buffer
+// or check for existance.
+lfs2_ssize_t lfs2_getattr(lfs2_t *lfs2, const char *path,
+        uint8_t type, void *buffer, lfs2_size_t size);
+
+// Set custom attributes
+//
+// Custom attributes are uniquely identified by an 8-bit type and limited
+// to LFS2_ATTR_MAX bytes. If an attribute is not found, it will be
+// implicitly created.
+//
+// Returns a negative error code on failure.
+int lfs2_setattr(lfs2_t *lfs2, const char *path,
+        uint8_t type, const void *buffer, lfs2_size_t size);
+
+// Removes a custom attribute
+//
+// If an attribute is not found, nothing happens.
+//
+// Returns a negative error code on failure.
+int lfs2_removeattr(lfs2_t *lfs2, const char *path, uint8_t type);
+
+
+/// File operations ///
+
+// Open a file
+//
+// The mode that the file is opened in is determined by the flags, which
+// are values from the enum lfs2_open_flags that are bitwise-ored together.
+//
+// Returns a negative error code on failure.
+int lfs2_file_open(lfs2_t *lfs2, lfs2_file_t *file,
+        const char *path, int flags);
+
+// Open a file with extra configuration
+//
+// The mode that the file is opened in is determined by the flags, which
+// are values from the enum lfs2_open_flags that are bitwise-ored together.
+//
+// The config struct provides additional config options per file as described
+// above. The config struct must be allocated while the file is open, and the
+// config struct must be zeroed for defaults and backwards compatibility.
+//
+// Returns a negative error code on failure.
+int lfs2_file_opencfg(lfs2_t *lfs2, lfs2_file_t *file,
+        const char *path, int flags,
+        const struct lfs2_file_config *config);
+
+// Close a file
+//
+// Any pending writes are written out to storage as though
+// sync had been called and releases any allocated resources.
+//
+// Returns a negative error code on failure.
+int lfs2_file_close(lfs2_t *lfs2, lfs2_file_t *file);
+
+// Synchronize a file on storage
+//
+// Any pending writes are written out to storage.
+// Returns a negative error code on failure.
+int lfs2_file_sync(lfs2_t *lfs2, lfs2_file_t *file);
+
+// Read data from file
+//
+// Takes a buffer and size indicating where to store the read data.
+// Returns the number of bytes read, or a negative error code on failure.
+lfs2_ssize_t lfs2_file_read(lfs2_t *lfs2, lfs2_file_t *file,
+        void *buffer, lfs2_size_t size);
+
+// Write data to file
+//
+// Takes a buffer and size indicating the data to write. The file will not
+// actually be updated on the storage until either sync or close is called.
+//
+// Returns the number of bytes written, or a negative error code on failure.
+lfs2_ssize_t lfs2_file_write(lfs2_t *lfs2, lfs2_file_t *file,
+        const void *buffer, lfs2_size_t size);
+
+// Change the position of the file
+//
+// The change in position is determined by the offset and whence flag.
+// Returns the new position of the file, or a negative error code on failure.
+lfs2_soff_t lfs2_file_seek(lfs2_t *lfs2, lfs2_file_t *file,
+        lfs2_soff_t off, int whence);
+
+// Truncates the size of the file to the specified size
+//
+// Returns a negative error code on failure.
+int lfs2_file_truncate(lfs2_t *lfs2, lfs2_file_t *file, lfs2_off_t size);
+
+// Return the position of the file
+//
+// Equivalent to lfs2_file_seek(lfs2, file, 0, LFS2_SEEK_CUR)
+// Returns the position of the file, or a negative error code on failure.
+lfs2_soff_t lfs2_file_tell(lfs2_t *lfs2, lfs2_file_t *file);
+
+// Change the position of the file to the beginning of the file
+//
+// Equivalent to lfs2_file_seek(lfs2, file, 0, LFS2_SEEK_SET)
+// Returns a negative error code on failure.
+int lfs2_file_rewind(lfs2_t *lfs2, lfs2_file_t *file);
+
+// Return the size of the file
+//
+// Similar to lfs2_file_seek(lfs2, file, 0, LFS2_SEEK_END)
+// Returns the size of the file, or a negative error code on failure.
+lfs2_soff_t lfs2_file_size(lfs2_t *lfs2, lfs2_file_t *file);
+
+
+/// Directory operations ///
+
+// Create a directory
+//
+// Returns a negative error code on failure.
+int lfs2_mkdir(lfs2_t *lfs2, const char *path);
+
+// Open a directory
+//
+// Once open a directory can be used with read to iterate over files.
+// Returns a negative error code on failure.
+int lfs2_dir_open(lfs2_t *lfs2, lfs2_dir_t *dir, const char *path);
+
+// Close a directory
+//
+// Releases any allocated resources.
+// Returns a negative error code on failure.
+int lfs2_dir_close(lfs2_t *lfs2, lfs2_dir_t *dir);
+
+// Read an entry in the directory
+//
+// Fills out the info structure, based on the specified file or directory.
+// Returns a positive value on success, 0 at the end of directory,
+// or a negative error code on failure.
+int lfs2_dir_read(lfs2_t *lfs2, lfs2_dir_t *dir, struct lfs2_info *info);
+
+// Change the position of the directory
+//
+// The new off must be a value previous returned from tell and specifies
+// an absolute offset in the directory seek.
+//
+// Returns a negative error code on failure.
+int lfs2_dir_seek(lfs2_t *lfs2, lfs2_dir_t *dir, lfs2_off_t off);
+
+// Return the position of the directory
+//
+// The returned offset is only meant to be consumed by seek and may not make
+// sense, but does indicate the current position in the directory iteration.
+//
+// Returns the position of the directory, or a negative error code on failure.
+lfs2_soff_t lfs2_dir_tell(lfs2_t *lfs2, lfs2_dir_t *dir);
+
+// Change the position of the directory to the beginning of the directory
+//
+// Returns a negative error code on failure.
+int lfs2_dir_rewind(lfs2_t *lfs2, lfs2_dir_t *dir);
+
+
+/// Filesystem-level filesystem operations
+
+// Finds the current size of the filesystem
+//
+// Note: Result is best effort. If files share COW structures, the returned
+// size may be larger than the filesystem actually is.
+//
+// Returns the number of allocated blocks, or a negative error code on failure.
+lfs2_ssize_t lfs2_fs_size(lfs2_t *lfs2);
+
+// Traverse through all blocks in use by the filesystem
+//
+// The provided callback will be called with each block address that is
+// currently in use by the filesystem. This can be used to determine which
+// blocks are in use or how much of the storage is available.
+//
+// Returns a negative error code on failure.
+int lfs2_fs_traverse(lfs2_t *lfs2, int (*cb)(void*, lfs2_block_t), void *data);
+
+#ifdef LFS2_MIGRATE
+// Attempts to migrate a previous version of littlefs
+//
+// Behaves similarly to the lfs2_format function. Attempts to mount
+// the previous version of littlefs and update the filesystem so it can be
+// mounted with the current version of littlefs.
+//
+// Requires a littlefs object and config struct. This clobbers the littlefs
+// object, and does not leave the filesystem mounted. The config struct must
+// be zeroed for defaults and backwards compatibility.
+//
+// Returns a negative error code on failure.
+int lfs2_migrate(lfs2_t *lfs2, const struct lfs2_config *cfg);
+#endif
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif
diff --git a/lib/littlefs/lfs2_util.c b/lib/littlefs/lfs2_util.c
new file mode 100644
index 0000000000000..083a99c36cf1e
--- /dev/null
+++ b/lib/littlefs/lfs2_util.c
@@ -0,0 +1,33 @@
+/*
+ * lfs2 util functions
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#include "lfs2_util.h"
+
+// Only compile if user does not provide custom config
+#ifndef LFS2_CONFIG
+
+
+// Software CRC implementation with small lookup table
+uint32_t lfs2_crc(uint32_t crc, const void *buffer, size_t size) {
+    static const uint32_t rtable[16] = {
+        0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
+        0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
+        0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
+        0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c,
+    };
+
+    const uint8_t *data = buffer;
+
+    for (size_t i = 0; i < size; i++) {
+        crc = (crc >> 4) ^ rtable[(crc ^ (data[i] >> 0)) & 0xf];
+        crc = (crc >> 4) ^ rtable[(crc ^ (data[i] >> 4)) & 0xf];
+    }
+
+    return crc;
+}
+
+
+#endif
diff --git a/lib/littlefs/lfs2_util.h b/lib/littlefs/lfs2_util.h
new file mode 100644
index 0000000000000..70bca717c93ce
--- /dev/null
+++ b/lib/littlefs/lfs2_util.h
@@ -0,0 +1,234 @@
+/*
+ * lfs2 utility functions
+ *
+ * Copyright (c) 2017, Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#ifndef LFS2_UTIL_H
+#define LFS2_UTIL_H
+
+// Users can override lfs2_util.h with their own configuration by defining
+// LFS2_CONFIG as a header file to include (-DLFS2_CONFIG=lfs2_config.h).
+//
+// If LFS2_CONFIG is used, none of the default utils will be emitted and must be
+// provided by the config file. To start, I would suggest copying lfs2_util.h
+// and modifying as needed.
+#ifdef LFS2_CONFIG
+#define LFS2_STRINGIZE(x) LFS2_STRINGIZE2(x)
+#define LFS2_STRINGIZE2(x) #x
+#include LFS2_STRINGIZE(LFS2_CONFIG)
+#else
+
+// System includes
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <inttypes.h>
+
+#ifndef LFS2_NO_MALLOC
+#include <stdlib.h>
+#endif
+#ifndef LFS2_NO_ASSERT
+#include <assert.h>
+#endif
+#if !defined(LFS2_NO_DEBUG) || \
+        !defined(LFS2_NO_WARN) || \
+        !defined(LFS2_NO_ERROR) || \
+        defined(LFS2_YES_TRACE)
+#include <stdio.h>
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+// Macros, may be replaced by system specific wrappers. Arguments to these
+// macros must not have side-effects as the macros can be removed for a smaller
+// code footprint
+
+// Logging functions
+#ifdef LFS2_YES_TRACE
+#define LFS2_TRACE_(fmt, ...) \
+    printf("%s:%d:trace: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__)
+#define LFS2_TRACE(...) LFS2_TRACE_(__VA_ARGS__, "")
+#else
+#define LFS2_TRACE(...)
+#endif
+
+#ifndef LFS2_NO_DEBUG
+#define LFS2_DEBUG_(fmt, ...) \
+    printf("%s:%d:debug: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__)
+#define LFS2_DEBUG(...) LFS2_DEBUG_(__VA_ARGS__, "")
+#else
+#define LFS2_DEBUG(...)
+#endif
+
+#ifndef LFS2_NO_WARN
+#define LFS2_WARN_(fmt, ...) \
+    printf("%s:%d:warn: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__)
+#define LFS2_WARN(...) LFS2_WARN_(__VA_ARGS__, "")
+#else
+#define LFS2_WARN(...)
+#endif
+
+#ifndef LFS2_NO_ERROR
+#define LFS2_ERROR_(fmt, ...) \
+    printf("%s:%d:error: " fmt "%s\n", __FILE__, __LINE__, __VA_ARGS__)
+#define LFS2_ERROR(...) LFS2_ERROR_(__VA_ARGS__, "")
+#else
+#define LFS2_ERROR(...)
+#endif
+
+// Runtime assertions
+#ifndef LFS2_NO_ASSERT
+#define LFS2_ASSERT(test) assert(test)
+#else
+#define LFS2_ASSERT(test)
+#endif
+
+
+// Builtin functions, these may be replaced by more efficient
+// toolchain-specific implementations. LFS2_NO_INTRINSICS falls back to a more
+// expensive basic C implementation for debugging purposes
+
+// Min/max functions for unsigned 32-bit numbers
+static inline uint32_t lfs2_max(uint32_t a, uint32_t b) {
+    return (a > b) ? a : b;
+}
+
+static inline uint32_t lfs2_min(uint32_t a, uint32_t b) {
+    return (a < b) ? a : b;
+}
+
+// Align to nearest multiple of a size
+static inline uint32_t lfs2_aligndown(uint32_t a, uint32_t alignment) {
+    return a - (a % alignment);
+}
+
+static inline uint32_t lfs2_alignup(uint32_t a, uint32_t alignment) {
+    return lfs2_aligndown(a + alignment-1, alignment);
+}
+
+// Find the smallest power of 2 greater than or equal to a
+static inline uint32_t lfs2_npw2(uint32_t a) {
+#if !defined(LFS2_NO_INTRINSICS) && (defined(__GNUC__) || defined(__CC_ARM))
+    return 32 - __builtin_clz(a-1);
+#else
+    uint32_t r = 0;
+    uint32_t s;
+    a -= 1;
+    s = (a > 0xffff) << 4; a >>= s; r |= s;
+    s = (a > 0xff  ) << 3; a >>= s; r |= s;
+    s = (a > 0xf   ) << 2; a >>= s; r |= s;
+    s = (a > 0x3   ) << 1; a >>= s; r |= s;
+    return (r | (a >> 1)) + 1;
+#endif
+}
+
+// Count the number of trailing binary zeros in a
+// lfs2_ctz(0) may be undefined
+static inline uint32_t lfs2_ctz(uint32_t a) {
+#if !defined(LFS2_NO_INTRINSICS) && defined(__GNUC__)
+    return __builtin_ctz(a);
+#else
+    return lfs2_npw2((a & -a) + 1) - 1;
+#endif
+}
+
+// Count the number of binary ones in a
+static inline uint32_t lfs2_popc(uint32_t a) {
+#if !defined(LFS2_NO_INTRINSICS) && (defined(__GNUC__) || defined(__CC_ARM))
+    return __builtin_popcount(a);
+#else
+    a = a - ((a >> 1) & 0x55555555);
+    a = (a & 0x33333333) + ((a >> 2) & 0x33333333);
+    return (((a + (a >> 4)) & 0xf0f0f0f) * 0x1010101) >> 24;
+#endif
+}
+
+// Find the sequence comparison of a and b, this is the distance
+// between a and b ignoring overflow
+static inline int lfs2_scmp(uint32_t a, uint32_t b) {
+    return (int)(unsigned)(a - b);
+}
+
+// Convert between 32-bit little-endian and native order
+static inline uint32_t lfs2_fromle32(uint32_t a) {
+#if !defined(LFS2_NO_INTRINSICS) && ( \
+    (defined(  BYTE_ORDER  ) && defined(  ORDER_LITTLE_ENDIAN  ) &&   BYTE_ORDER   ==   ORDER_LITTLE_ENDIAN  ) || \
+    (defined(__BYTE_ORDER  ) && defined(__ORDER_LITTLE_ENDIAN  ) && __BYTE_ORDER   == __ORDER_LITTLE_ENDIAN  ) || \
+    (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
+    return a;
+#elif !defined(LFS2_NO_INTRINSICS) && ( \
+    (defined(  BYTE_ORDER  ) && defined(  ORDER_BIG_ENDIAN  ) &&   BYTE_ORDER   ==   ORDER_BIG_ENDIAN  ) || \
+    (defined(__BYTE_ORDER  ) && defined(__ORDER_BIG_ENDIAN  ) && __BYTE_ORDER   == __ORDER_BIG_ENDIAN  ) || \
+    (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
+    return __builtin_bswap32(a);
+#else
+    return (((uint8_t*)&a)[0] <<  0) |
+           (((uint8_t*)&a)[1] <<  8) |
+           (((uint8_t*)&a)[2] << 16) |
+           (((uint8_t*)&a)[3] << 24);
+#endif
+}
+
+static inline uint32_t lfs2_tole32(uint32_t a) {
+    return lfs2_fromle32(a);
+}
+
+// Convert between 32-bit big-endian and native order
+static inline uint32_t lfs2_frombe32(uint32_t a) {
+#if !defined(LFS2_NO_INTRINSICS) && ( \
+    (defined(  BYTE_ORDER  ) && defined(  ORDER_LITTLE_ENDIAN  ) &&   BYTE_ORDER   ==   ORDER_LITTLE_ENDIAN  ) || \
+    (defined(__BYTE_ORDER  ) && defined(__ORDER_LITTLE_ENDIAN  ) && __BYTE_ORDER   == __ORDER_LITTLE_ENDIAN  ) || \
+    (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
+    return __builtin_bswap32(a);
+#elif !defined(LFS2_NO_INTRINSICS) && ( \
+    (defined(  BYTE_ORDER  ) && defined(  ORDER_BIG_ENDIAN  ) &&   BYTE_ORDER   ==   ORDER_BIG_ENDIAN  ) || \
+    (defined(__BYTE_ORDER  ) && defined(__ORDER_BIG_ENDIAN  ) && __BYTE_ORDER   == __ORDER_BIG_ENDIAN  ) || \
+    (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
+    return a;
+#else
+    return (((uint8_t*)&a)[0] << 24) |
+           (((uint8_t*)&a)[1] << 16) |
+           (((uint8_t*)&a)[2] <<  8) |
+           (((uint8_t*)&a)[3] <<  0);
+#endif
+}
+
+static inline uint32_t lfs2_tobe32(uint32_t a) {
+    return lfs2_frombe32(a);
+}
+
+// Calculate CRC-32 with polynomial = 0x04c11db7
+uint32_t lfs2_crc(uint32_t crc, const void *buffer, size_t size);
+
+// Allocate memory, only used if buffers are not provided to littlefs
+// Note, memory must be 64-bit aligned
+static inline void *lfs2_malloc(size_t size) {
+#ifndef LFS2_NO_MALLOC
+    return malloc(size);
+#else
+    (void)size;
+    return NULL;
+#endif
+}
+
+// Deallocate memory, only used if buffers are not provided to littlefs
+static inline void lfs2_free(void *p) {
+#ifndef LFS2_NO_MALLOC
+    free(p);
+#else
+    (void)p;
+#endif
+}
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif
+#endif
diff --git a/lib/lwip b/lib/lwip
index 92f23d6ca0971..159e31b689577 160000
--- a/lib/lwip
+++ b/lib/lwip
@@ -1 +1 @@
-Subproject commit 92f23d6ca0971a32f2085b9480e738d34174417b
+Subproject commit 159e31b689577dbf69cf0683bbaffbd71fa5ee10
diff --git a/lib/mbedtls b/lib/mbedtls
new file mode 160000
index 0000000000000..3f8d78411a26e
--- /dev/null
+++ b/lib/mbedtls
@@ -0,0 +1 @@
+Subproject commit 3f8d78411a26e833db18d9fbde0e2f0baeda87f0
diff --git a/lib/mp-readline/readline.c b/lib/mp-readline/readline.c
index 9d254d8cfebe7..296c8aa4ab543 100644
--- a/lib/mp-readline/readline.c
+++ b/lib/mp-readline/readline.c
@@ -74,6 +74,7 @@ STATIC void mp_hal_move_cursor_back(uint pos) {
         // snprintf needs space for the terminating null character
         int n = snprintf(&vt100_command[0], sizeof(vt100_command), "\x1b[%u", pos);
         if (n > 0) {
+            assert((unsigned)n < sizeof(vt100_command));
             vt100_command[n] = 'D'; // replace null char
             mp_hal_stdout_tx_strn(vt100_command, n + 1);
         }
@@ -98,6 +99,35 @@ typedef struct _readline_t {
 
 STATIC readline_t rl;
 
+#if MICROPY_REPL_EMACS_WORDS_MOVE
+STATIC size_t cursor_count_word(int forward) {
+    const char *line_buf = vstr_str(rl.line);
+    size_t pos = rl.cursor_pos;
+    bool in_word = false;
+
+    for (;;) {
+        // if moving backwards and we've reached 0... break
+        if (!forward && pos == 0) {
+            break;
+        }
+        // or if moving forwards and we've reached to the end of line... break
+        else if (forward && pos == vstr_len(rl.line)) {
+            break;
+        }
+
+        if (unichar_isalnum(line_buf[pos + (forward - 1)])) {
+            in_word = true;
+        } else if (in_word) {
+            break;
+        }
+
+        pos += forward ? forward : -1;
+    }
+
+    return forward ? pos - rl.cursor_pos : rl.cursor_pos - pos;
+}
+#endif
+
 int readline_process_char(int c) {
     size_t last_line_len = rl.line->len;
     int redraw_step_back = 0;
@@ -148,6 +178,10 @@ int readline_process_char(int c) {
             redraw_step_back = rl.cursor_pos - rl.orig_line_len;
             redraw_from_cursor = true;
         #endif
+        #if MICROPY_REPL_EMACS_EXTRA_WORDS_MOVE
+        } else if (c == CHAR_CTRL_W) {
+            goto backward_kill_word;
+        #endif
         } else if (c == '\r') {
             // newline
             mp_hal_stdout_tx_str("\r\n");
@@ -221,9 +255,40 @@ int readline_process_char(int c) {
             case 'O':
                 rl.escape_seq = ESEQ_ESC_O;
                 break;
+            #if MICROPY_REPL_EMACS_WORDS_MOVE
+            case 'b':
+#if MICROPY_REPL_EMACS_EXTRA_WORDS_MOVE
+backward_word:
+#endif
+                redraw_step_back = cursor_count_word(0);
+                rl.escape_seq = ESEQ_NONE;
+                break;
+            case 'f':
+#if MICROPY_REPL_EMACS_EXTRA_WORDS_MOVE
+forward_word:
+#endif
+                redraw_step_forward = cursor_count_word(1);
+                rl.escape_seq = ESEQ_NONE;
+                break;
+            case 'd':
+                vstr_cut_out_bytes(rl.line, rl.cursor_pos, cursor_count_word(1));
+                redraw_from_cursor = true;
+                rl.escape_seq = ESEQ_NONE;
+                break;
+            case 127:
+#if MICROPY_REPL_EMACS_EXTRA_WORDS_MOVE
+backward_kill_word:
+#endif
+                redraw_step_back = cursor_count_word(0);
+                vstr_cut_out_bytes(rl.line, rl.cursor_pos - redraw_step_back, redraw_step_back);
+                redraw_from_cursor = true;
+                rl.escape_seq = ESEQ_NONE;
+                break;
+            #endif
             default:
                 DEBUG_printf("(ESC %d)", c);
                 rl.escape_seq = ESEQ_NONE;
+                break;
         }
     } else if (rl.escape_seq == ESEQ_ESC_BRACKET) {
         if ('0' <= c && c <= '9') {
@@ -311,6 +376,24 @@ int readline_process_char(int c) {
             } else {
                 DEBUG_printf("(ESC [ %c %d)", rl.escape_seq_buf[0], c);
             }
+        #if MICROPY_REPL_EMACS_EXTRA_WORDS_MOVE
+        } else if (c == ';' && rl.escape_seq_buf[0] == '1') {
+            // ';' is used to separate parameters. so first parameter was '1',
+            // that's used for sequences like ctrl+left, which we will try to parse.
+            // escape_seq state is reset back to ESEQ_ESC_BRACKET, as if we've just received
+            // the opening bracket, because more parameters are to come.
+            // we don't track the parameters themselves to keep low on logic and code size. that
+            // might be required in the future if more complex sequences are added.
+            rl.escape_seq = ESEQ_ESC_BRACKET;
+            // goto away from the state-machine, as rl.escape_seq will be overridden.
+            goto redraw;
+        } else if (rl.escape_seq_buf[0] == '5' && c == 'C') {
+            // ctrl+right
+            goto forward_word;
+        } else if (rl.escape_seq_buf[0] == '5' && c == 'D') {
+            // ctrl+left
+            goto backward_word;
+        #endif
         } else {
             DEBUG_printf("(ESC [ %c %d)", rl.escape_seq_buf[0], c);
         }
@@ -329,6 +412,10 @@ int readline_process_char(int c) {
         rl.escape_seq = ESEQ_NONE;
     }
 
+#if MICROPY_REPL_EMACS_EXTRA_WORDS_MOVE
+redraw:
+#endif
+
     // redraw command prompt, efficiently
     if (redraw_step_back > 0) {
         mp_hal_move_cursor_back(redraw_step_back);
diff --git a/lib/mp-readline/readline.h b/lib/mp-readline/readline.h
index 00aa9622a8023..a19e1209ab716 100644
--- a/lib/mp-readline/readline.h
+++ b/lib/mp-readline/readline.h
@@ -36,6 +36,7 @@
 #define CHAR_CTRL_N (14)
 #define CHAR_CTRL_P (16)
 #define CHAR_CTRL_U (21)
+#define CHAR_CTRL_W (23)
 
 void readline_init0(void);
 int readline(vstr_t *line, const char *prompt);
diff --git a/lib/mynewt-nimble b/lib/mynewt-nimble
new file mode 160000
index 0000000000000..97ce3eacaaa79
--- /dev/null
+++ b/lib/mynewt-nimble
@@ -0,0 +1 @@
+Subproject commit 97ce3eacaaa79e8ed6cf71717149ced4f5328ee7
diff --git a/lib/netutils/dhcpserver.c b/lib/netutils/dhcpserver.c
new file mode 100644
index 0000000000000..7f97ee6e462ce
--- /dev/null
+++ b/lib/netutils/dhcpserver.c
@@ -0,0 +1,304 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// For DHCP specs see:
+//  https://www.ietf.org/rfc/rfc2131.txt
+//  https://tools.ietf.org/html/rfc2132 -- DHCP Options and BOOTP Vendor Extensions
+
+#include <stdio.h>
+#include <string.h>
+#include "py/mperrno.h"
+#include "py/mphal.h"
+
+#if MICROPY_PY_LWIP
+
+#include "lib/netutils/dhcpserver.h"
+#include "lwip/udp.h"
+
+#define DHCPDISCOVER    (1)
+#define DHCPOFFER       (2)
+#define DHCPREQUEST     (3)
+#define DHCPDECLINE     (4)
+#define DHCPACK         (5)
+#define DHCPNACK        (6)
+#define DHCPRELEASE     (7)
+#define DHCPINFORM      (8)
+
+#define DHCP_OPT_PAD                (0)
+#define DHCP_OPT_SUBNET_MASK        (1)
+#define DHCP_OPT_ROUTER             (3)
+#define DHCP_OPT_DNS                (6)
+#define DHCP_OPT_HOST_NAME          (12)
+#define DHCP_OPT_REQUESTED_IP       (50)
+#define DHCP_OPT_IP_LEASE_TIME      (51)
+#define DHCP_OPT_MSG_TYPE           (53)
+#define DHCP_OPT_SERVER_ID          (54)
+#define DHCP_OPT_PARAM_REQUEST_LIST (55)
+#define DHCP_OPT_MAX_MSG_SIZE       (57)
+#define DHCP_OPT_VENDOR_CLASS_ID    (60)
+#define DHCP_OPT_CLIENT_ID          (61)
+#define DHCP_OPT_END                (255)
+
+#define PORT_DHCP_SERVER (67)
+#define PORT_DHCP_CLIENT (68)
+
+#define DEFAULT_DNS MAKE_IP4(8, 8, 8, 8)
+#define DEFAULT_LEASE_TIME_S (24 * 60 * 60) // in seconds
+
+#define MAC_LEN (6)
+#define MAKE_IP4(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d))
+
+typedef struct {
+    uint8_t op; // message opcode
+    uint8_t htype; // hardware address type
+    uint8_t hlen; // hardware address length
+    uint8_t hops;
+    uint32_t xid; // transaction id, chosen by client
+    uint16_t secs; // client seconds elapsed
+    uint16_t flags;
+    uint8_t ciaddr[4]; // client IP address
+    uint8_t yiaddr[4]; // your IP address
+    uint8_t siaddr[4]; // next server IP address
+    uint8_t giaddr[4]; // relay agent IP address
+    uint8_t chaddr[16]; // client hardware address
+    uint8_t sname[64]; // server host name
+    uint8_t file[128]; // boot file name
+    uint8_t options[312]; // optional parameters, variable, starts with magic
+} dhcp_msg_t;
+
+static int dhcp_socket_new_dgram(struct udp_pcb **udp, void *cb_data, udp_recv_fn cb_udp_recv) {
+    // family is AF_INET
+    // type is SOCK_DGRAM
+
+    *udp = udp_new();
+    if (*udp == NULL) {
+        return -MP_ENOMEM;
+    }
+
+    // Register callback
+    udp_recv(*udp, cb_udp_recv, (void *)cb_data);
+
+    return 0; // success
+}
+
+static void dhcp_socket_free(struct udp_pcb **udp) {
+    if (*udp != NULL) {
+        udp_remove(*udp);
+        *udp = NULL;
+    }
+}
+
+static int dhcp_socket_bind(struct udp_pcb **udp, uint32_t ip, uint16_t port) {
+    ip_addr_t addr;
+    IP4_ADDR(&addr, ip >> 24 & 0xff, ip >> 16 & 0xff, ip >> 8 & 0xff, ip & 0xff);
+    // TODO convert lwIP errors to errno
+    return udp_bind(*udp, &addr, port);
+}
+
+static int dhcp_socket_sendto(struct udp_pcb **udp, const void *buf, size_t len, uint32_t ip, uint16_t port) {
+    if (len > 0xffff) {
+        len = 0xffff;
+    }
+
+    struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM);
+    if (p == NULL) {
+        return -MP_ENOMEM;
+    }
+
+    memcpy(p->payload, buf, len);
+
+    ip_addr_t dest;
+    IP4_ADDR(&dest, ip >> 24 & 0xff, ip >> 16 & 0xff, ip >> 8 & 0xff, ip & 0xff);
+    err_t err = udp_sendto(*udp, p, &dest, port);
+
+    pbuf_free(p);
+
+    if (err != ERR_OK) {
+        return err;
+    }
+
+    return len;
+}
+
+static uint8_t *opt_find(uint8_t *opt, uint8_t cmd) {
+    for (int i = 0; i < 308 && opt[i] != DHCP_OPT_END;) {
+        if (opt[i] == cmd) {
+            return &opt[i];
+        }
+        i += 2 + opt[i + 1];
+    }
+    return NULL;
+}
+
+static void opt_write_n(uint8_t **opt, uint8_t cmd, size_t n, void *data) {
+    uint8_t *o = *opt;
+    *o++ = cmd;
+    *o++ = n;
+    memcpy(o, data, n);
+    *opt = o + n;
+}
+
+static void opt_write_u8(uint8_t **opt, uint8_t cmd, uint8_t val) {
+    uint8_t *o = *opt;
+    *o++ = cmd;
+    *o++ = 1;
+    *o++ = val;
+    *opt = o;
+}
+
+static void opt_write_u32(uint8_t **opt, uint8_t cmd, uint32_t val) {
+    uint8_t *o = *opt;
+    *o++ = cmd;
+    *o++ = 4;
+    *o++ = val >> 24;
+    *o++ = val >> 16;
+    *o++ = val >> 8;
+    *o++ = val;
+    *opt = o;
+}
+
+static void dhcp_server_process(void *arg, struct udp_pcb *upcb, struct pbuf *p, const ip_addr_t *src_addr, u16_t src_port) {
+    dhcp_server_t *d = arg;
+    (void)upcb;
+    (void)src_addr;
+    (void)src_port;
+
+    // This is around 548 bytes
+    dhcp_msg_t dhcp_msg;
+
+    #define DHCP_MIN_SIZE (240 + 3)
+    if (p->tot_len < DHCP_MIN_SIZE) {
+        goto ignore_request;
+    }
+
+    size_t len = pbuf_copy_partial(p, &dhcp_msg, sizeof(dhcp_msg), 0);
+    if (len < DHCP_MIN_SIZE) {
+        goto ignore_request;
+    }
+
+    dhcp_msg.op = DHCPOFFER;
+    memcpy(&dhcp_msg.yiaddr, &d->ip.addr, 4);
+
+    uint8_t *opt = (uint8_t *)&dhcp_msg.options;
+    opt += 4; // assume magic cookie: 99, 130, 83, 99
+
+    switch (opt[2]) {
+        case DHCPDISCOVER: {
+            int yi = DHCPS_MAX_IP;
+            for (int i = 0; i < DHCPS_MAX_IP; ++i) {
+                if (memcmp(d->lease[i].mac, dhcp_msg.chaddr, MAC_LEN) == 0) {
+                    // MAC match, use this IP address
+                    yi = i;
+                    break;
+                }
+                if (yi == DHCPS_MAX_IP) {
+                    // Look for a free IP address
+                    if (memcmp(d->lease[i].mac, "\x00\x00\x00\x00\x00\x00", MAC_LEN) == 0) {
+                        // IP available
+                        yi = i;
+                    }
+                    uint32_t expiry = d->lease[i].expiry << 16 | 0xffff;
+                    if ((int32_t)(expiry - mp_hal_ticks_ms()) < 0) {
+                        // IP expired, reuse it
+                        memset(d->lease[i].mac, 0, MAC_LEN);
+                        yi = i;
+                    }
+                }
+            }
+            if (yi == DHCPS_MAX_IP) {
+                // No more IP addresses left
+                goto ignore_request;
+            }
+            dhcp_msg.yiaddr[3] = DHCPS_BASE_IP + yi;
+            opt_write_u8(&opt, DHCP_OPT_MSG_TYPE, DHCPOFFER);
+            break;
+        }
+
+        case DHCPREQUEST: {
+            uint8_t *o = opt_find(opt, DHCP_OPT_REQUESTED_IP);
+            if (o == NULL) {
+                // Should be NACK
+                goto ignore_request;
+            }
+            if (memcmp(o + 2, &d->ip.addr, 3) != 0) {
+                // Should be NACK
+                goto ignore_request;
+            }
+            uint8_t yi = o[5] - DHCPS_BASE_IP;
+            if (yi >= DHCPS_MAX_IP) {
+                // Should be NACK
+                goto ignore_request;
+            }
+            if (memcmp(d->lease[yi].mac, dhcp_msg.chaddr, MAC_LEN) == 0) {
+                // MAC match, ok to use this IP address
+            } else if (memcmp(d->lease[yi].mac, "\x00\x00\x00\x00\x00\x00", MAC_LEN) == 0) {
+                // IP unused, ok to use this IP address
+                memcpy(d->lease[yi].mac, dhcp_msg.chaddr, MAC_LEN);
+            } else {
+                // IP already in use
+                // Should be NACK
+                goto ignore_request;
+            }
+            d->lease[yi].expiry = (mp_hal_ticks_ms() + DEFAULT_LEASE_TIME_S * 1000) >> 16;
+            dhcp_msg.yiaddr[3] = DHCPS_BASE_IP + yi;
+            opt_write_u8(&opt, DHCP_OPT_MSG_TYPE, DHCPACK);
+            printf("DHCPS: client connected: MAC=%02x:%02x:%02x:%02x:%02x:%02x IP=%u.%u.%u.%u\n",
+                dhcp_msg.chaddr[0], dhcp_msg.chaddr[1], dhcp_msg.chaddr[2], dhcp_msg.chaddr[3], dhcp_msg.chaddr[4], dhcp_msg.chaddr[5],
+                dhcp_msg.yiaddr[0], dhcp_msg.yiaddr[1], dhcp_msg.yiaddr[2], dhcp_msg.yiaddr[3]);
+            break;
+        }
+
+        default:
+            goto ignore_request;
+    }
+
+    opt_write_n(&opt, DHCP_OPT_SERVER_ID, 4, &d->ip.addr);
+    opt_write_n(&opt, DHCP_OPT_SUBNET_MASK, 4, &d->nm.addr);
+    opt_write_n(&opt, DHCP_OPT_ROUTER, 4, &d->ip.addr); // aka gateway; can have mulitple addresses
+    opt_write_u32(&opt, DHCP_OPT_DNS, DEFAULT_DNS); // can have mulitple addresses
+    opt_write_u32(&opt, DHCP_OPT_IP_LEASE_TIME, DEFAULT_LEASE_TIME_S);
+    *opt++ = DHCP_OPT_END;
+    dhcp_socket_sendto(&d->udp, &dhcp_msg, opt - (uint8_t *)&dhcp_msg, 0xffffffff, PORT_DHCP_CLIENT);
+
+ignore_request:
+    pbuf_free(p);
+}
+
+void dhcp_server_init(dhcp_server_t *d, ip_addr_t *ip, ip_addr_t *nm) {
+    ip_addr_copy(d->ip, *ip);
+    ip_addr_copy(d->nm, *nm);
+    memset(d->lease, 0, sizeof(d->lease));
+    if (dhcp_socket_new_dgram(&d->udp, d, dhcp_server_process) != 0) {
+        return;
+    }
+    dhcp_socket_bind(&d->udp, 0, PORT_DHCP_SERVER);
+}
+
+void dhcp_server_deinit(dhcp_server_t *d) {
+    dhcp_socket_free(&d->udp);
+}
+
+#endif // MICROPY_PY_LWIP
diff --git a/lib/netutils/dhcpserver.h b/lib/netutils/dhcpserver.h
new file mode 100644
index 0000000000000..2349d2ea427f4
--- /dev/null
+++ b/lib/netutils/dhcpserver.h
@@ -0,0 +1,49 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_LIB_NETUTILS_DHCPSERVER_H
+#define MICROPY_INCLUDED_LIB_NETUTILS_DHCPSERVER_H
+
+#include "lwip/ip_addr.h"
+
+#define DHCPS_BASE_IP (16)
+#define DHCPS_MAX_IP (8)
+
+typedef struct _dhcp_server_lease_t {
+    uint8_t mac[6];
+    uint16_t expiry;
+} dhcp_server_lease_t;
+
+typedef struct _dhcp_server_t {
+    ip_addr_t ip;
+    ip_addr_t nm;
+    dhcp_server_lease_t lease[DHCPS_MAX_IP];
+    struct udp_pcb *udp;
+} dhcp_server_t;
+
+void dhcp_server_init(dhcp_server_t *d, ip_addr_t *ip, ip_addr_t *nm);
+void dhcp_server_deinit(dhcp_server_t *d);
+
+#endif // MICROPY_INCLUDED_LIB_NETUTILS_DHCPSERVER_H
diff --git a/lib/netutils/netutils.c b/lib/netutils/netutils.c
index 073f46b1993ed..40fbd5bca353d 100644
--- a/lib/netutils/netutils.c
+++ b/lib/netutils/netutils.c
@@ -64,7 +64,7 @@ void netutils_parse_ipv4_addr(mp_obj_t addr_in, uint8_t *out_ip, netutils_endian
     }
     const char *s = addr_str;
     const char *s_top = addr_str + addr_len;
-    for (mp_uint_t i = 3 ; ; i--) {
+    for (mp_uint_t i = 3; ; i--) {
         mp_uint_t val = 0;
         for (; s < s_top && *s != '.'; s++) {
             val = val * 10 + *s - '0';
@@ -79,7 +79,7 @@ void netutils_parse_ipv4_addr(mp_obj_t addr_in, uint8_t *out_ip, netutils_endian
         } else if (i > 0 && s < s_top && *s == '.') {
             s++;
         } else {
-            mp_raise_ValueError("invalid arguments");
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid arguments"));
         }
     }
 }
diff --git a/lib/netutils/trace.c b/lib/netutils/trace.c
index 7c79713b32532..1610966c2dac1 100644
--- a/lib/netutils/trace.c
+++ b/lib/netutils/trace.c
@@ -44,10 +44,14 @@ static void dump_hex_bytes(const mp_print_t *print, size_t len, const uint8_t *b
 static const char *ethertype_str(uint16_t type) {
     // A value between 0x0000 - 0x05dc (inclusive) indicates a length, not type
     switch (type) {
-        case 0x0800: return "IPv4";
-        case 0x0806: return "ARP";
-        case 0x86dd: return "IPv6";
-        default: return NULL;
+        case 0x0800:
+            return "IPv4";
+        case 0x0806:
+            return "ARP";
+        case 0x86dd:
+            return "IPv6";
+        default:
+            return NULL;
     }
 }
 
@@ -113,14 +117,30 @@ void netutils_ethernet_trace(const mp_print_t *print, size_t len, const uint8_t
                     buf += n;
                     mp_printf(print, " opts:");
                     switch (buf[6]) {
-                        case 1: mp_printf(print, " DISCOVER"); break;
-                        case 2: mp_printf(print, " OFFER"); break;
-                        case 3: mp_printf(print, " REQUEST"); break;
-                        case 4: mp_printf(print, " DECLINE"); break;
-                        case 5: mp_printf(print, " ACK"); break;
-                        case 6: mp_printf(print, " NACK"); break;
-                        case 7: mp_printf(print, " RELEASE"); break;
-                        case 8: mp_printf(print, " INFORM"); break;
+                        case 1:
+                            mp_printf(print, " DISCOVER");
+                            break;
+                        case 2:
+                            mp_printf(print, " OFFER");
+                            break;
+                        case 3:
+                            mp_printf(print, " REQUEST");
+                            break;
+                        case 4:
+                            mp_printf(print, " DECLINE");
+                            break;
+                        case 5:
+                            mp_printf(print, " ACK");
+                            break;
+                        case 6:
+                            mp_printf(print, " NACK");
+                            break;
+                        case 7:
+                            mp_printf(print, " RELEASE");
+                            break;
+                        case 8:
+                            mp_printf(print, " INFORM");
+                            break;
                     }
                 }
             } else {
diff --git a/lib/nrfx b/lib/nrfx
index d4ebe15f58de1..7a4c9d946cf18 160000
--- a/lib/nrfx
+++ b/lib/nrfx
@@ -1 +1 @@
-Subproject commit d4ebe15f58de1442e3eed93b40d13930e7785903
+Subproject commit 7a4c9d946cf1801771fc180acdbf7b878f270093
diff --git a/lib/nxp_driver b/lib/nxp_driver
new file mode 160000
index 0000000000000..b618cb1d521cc
--- /dev/null
+++ b/lib/nxp_driver
@@ -0,0 +1 @@
+Subproject commit b618cb1d521cc9e133bdcd0fca154dee2d925dfe
diff --git a/lib/stm32lib b/lib/stm32lib
index a5e93de184798..668d7a9e54aea 160000
--- a/lib/stm32lib
+++ b/lib/stm32lib
@@ -1 +1 @@
-Subproject commit a5e93de18479879dd129cf6272cfd75e0c794bd4
+Subproject commit 668d7a9e54aea98f8fe8a858eac1d3daa80fa824
diff --git a/lib/timeutils/timeutils.c b/lib/timeutils/timeutils.c
index eb3dc80d4b525..fc8b5e7fc824f 100644
--- a/lib/timeutils/timeutils.c
+++ b/lib/timeutils/timeutils.c
@@ -36,11 +36,11 @@
 
 #define LEAPOCH ((31 + 29) * 86400)
 
-#define DAYS_PER_400Y (365*400 + 97)
-#define DAYS_PER_100Y (365*100 + 24)
-#define DAYS_PER_4Y   (365*4   + 1)
+#define DAYS_PER_400Y (365 * 400 + 97)
+#define DAYS_PER_100Y (365 * 100 + 24)
+#define DAYS_PER_4Y   (365 * 4 + 1)
 
-STATIC const uint16_t days_since_jan1[]= { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
+STATIC const uint16_t days_since_jan1[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
 
 bool timeutils_is_leap_year(mp_uint_t year) {
     return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
diff --git a/lib/timeutils/timeutils.h b/lib/timeutils/timeutils.h
index 9b1abeb8f3d36..cb7a72123a119 100644
--- a/lib/timeutils/timeutils.h
+++ b/lib/timeutils/timeutils.h
@@ -28,14 +28,14 @@
 #define MICROPY_INCLUDED_LIB_TIMEUTILS_TIMEUTILS_H
 
 typedef struct _timeutils_struct_time_t {
-    uint16_t    tm_year;    // i.e. 2014
-    uint8_t     tm_mon;     // 1..12
-    uint8_t     tm_mday;    // 1..31
-    uint8_t     tm_hour;    // 0..23
-    uint8_t     tm_min;     // 0..59
-    uint8_t     tm_sec;     // 0..59
-    uint8_t     tm_wday;    // 0..6  0 = Monday
-    uint16_t    tm_yday;    // 1..366
+    uint16_t tm_year;       // i.e. 2014
+    uint8_t tm_mon;         // 1..12
+    uint8_t tm_mday;        // 1..31
+    uint8_t tm_hour;        // 0..23
+    uint8_t tm_min;         // 0..59
+    uint8_t tm_sec;         // 0..59
+    uint8_t tm_wday;        // 0..6  0 = Monday
+    uint16_t tm_yday;       // 1..366
 } timeutils_struct_time_t;
 
 bool timeutils_is_leap_year(mp_uint_t year);
diff --git a/lib/tinytest/tinytest.c b/lib/tinytest/tinytest.c
index 01772f3f8ef6e..1ef957d31bdb4 100644
--- a/lib/tinytest/tinytest.c
+++ b/lib/tinytest/tinytest.c
@@ -234,9 +234,8 @@ testcase_run_one(const struct testgroup_t *group,
 		return SKIP;
 	}
 
-	printf("# starting %s%s\n", group->prefix, testcase->name);
 	if (opt_verbosity>0 && !opt_forked) {
-		//printf("%s%s: ", group->prefix, testcase->name);
+		printf("%s%s: ", group->prefix, testcase->name);
 	} else {
 		if (opt_verbosity==0) printf(".");
 		cur_test_prefix = group->prefix;
@@ -253,7 +252,6 @@ testcase_run_one(const struct testgroup_t *group,
 		outcome = testcase_run_bare_(testcase);
 	}
 
-	printf("%s%s: ", group->prefix, testcase->name);
 	if (outcome == OK) {
 		++n_ok;
 		if (opt_verbosity>0 && !opt_forked)
@@ -265,8 +263,7 @@ testcase_run_one(const struct testgroup_t *group,
 	} else {
 		++n_bad;
 		if (!opt_forked)
-			//printf("\n  [%s FAILED]\n", testcase->name);
-			puts("FAILED");
+			printf("\n  [%s FAILED]\n", testcase->name);
 	}
 
 	if (opt_forked) {
diff --git a/lib/tinyusb b/lib/tinyusb
new file mode 160000
index 0000000000000..a6b916ba85bef
--- /dev/null
+++ b/lib/tinyusb
@@ -0,0 +1 @@
+Subproject commit a6b916ba85bef6aad50f1652532b02984dfe2484
diff --git a/lib/upytesthelper/upytesthelper.c b/lib/upytesthelper/upytesthelper.c
index d28c5b9cc0490..326172be658c0 100644
--- a/lib/upytesthelper/upytesthelper.c
+++ b/lib/upytesthelper/upytesthelper.c
@@ -101,7 +101,7 @@ void upytest_execute_test(const char *src) {
         mp_lexer_t *lex = mp_lexer_new_from_str_len(MP_QSTR__lt_stdin_gt_, src, strlen(src), 0);
         qstr source_name = lex->source_name;
         mp_parse_tree_t parse_tree = mp_parse(lex, MP_PARSE_FILE_INPUT);
-        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, MP_EMIT_OPT_NONE, false);
+        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, false);
         mp_call_function_0(module_fun);
         nlr_pop();
     } else {
diff --git a/lib/utils/gchelper.h b/lib/utils/gchelper.h
index 7149b6a72ef91..4b6ead6ba650f 100644
--- a/lib/utils/gchelper.h
+++ b/lib/utils/gchelper.h
@@ -28,7 +28,21 @@
 
 #include <stdint.h>
 
-uintptr_t gc_helper_get_sp(void);
-uintptr_t gc_helper_get_regs_and_sp(uintptr_t *regs);
+#if MICROPY_GCREGS_SETJMP
+#include <setjmp.h>
+typedef jmp_buf gc_helper_regs_t;
+#else
+
+#if defined(__x86_64__)
+typedef uintptr_t gc_helper_regs_t[6];
+#elif defined(__i386__)
+typedef uintptr_t gc_helper_regs_t[4];
+#elif defined(__thumb2__) || defined(__thumb__) || defined(__arm__)
+typedef uintptr_t gc_helper_regs_t[10];
+#endif
+
+#endif
+
+void gc_helper_collect_regs_and_stack(void);
 
 #endif // MICROPY_INCLUDED_LIB_UTILS_GCHELPER_H
diff --git a/lib/utils/gchelper_generic.c b/lib/utils/gchelper_generic.c
new file mode 100644
index 0000000000000..9750e8b0c837a
--- /dev/null
+++ b/lib/utils/gchelper_generic.c
@@ -0,0 +1,156 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013, 2014 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdio.h>
+
+#include "py/mpstate.h"
+#include "py/gc.h"
+#include "lib/utils/gchelper.h"
+
+#if MICROPY_ENABLE_GC
+
+// Even if we have specific support for an architecture, it is
+// possible to force use of setjmp-based implementation.
+#if !MICROPY_GCREGS_SETJMP
+
+// We capture here callee-save registers, i.e. ones which may contain
+// interesting values held there by our callers. It doesn't make sense
+// to capture caller-saved registers, because they, well, put on the
+// stack already by the caller.
+#if defined(__x86_64__)
+
+STATIC void gc_helper_get_regs(gc_helper_regs_t arr) {
+    register long rbx asm ("rbx");
+    register long rbp asm ("rbp");
+    register long r12 asm ("r12");
+    register long r13 asm ("r13");
+    register long r14 asm ("r14");
+    register long r15 asm ("r15");
+    #ifdef __clang__
+    // TODO:
+    // This is dirty workaround for Clang. It tries to get around
+    // uncompliant (wrt to GCC) behavior of handling register variables.
+    // Application of this patch here is random, and done only to unbreak
+    // MacOS build. Better, cross-arch ways to deal with Clang issues should
+    // be found.
+    asm ("" : "=r" (rbx));
+    asm ("" : "=r" (rbp));
+    asm ("" : "=r" (r12));
+    asm ("" : "=r" (r13));
+    asm ("" : "=r" (r14));
+    asm ("" : "=r" (r15));
+    #endif
+    arr[0] = rbx;
+    arr[1] = rbp;
+    arr[2] = r12;
+    arr[3] = r13;
+    arr[4] = r14;
+    arr[5] = r15;
+}
+
+#elif defined(__i386__)
+
+STATIC void gc_helper_get_regs(gc_helper_regs_t arr) {
+    register long ebx asm ("ebx");
+    register long esi asm ("esi");
+    register long edi asm ("edi");
+    register long ebp asm ("ebp");
+    #ifdef __clang__
+    // TODO:
+    // This is dirty workaround for Clang. It tries to get around
+    // uncompliant (wrt to GCC) behavior of handling register variables.
+    // Application of this patch here is random, and done only to unbreak
+    // MacOS build. Better, cross-arch ways to deal with Clang issues should
+    // be found.
+    asm ("" : "=r" (ebx));
+    asm ("" : "=r" (esi));
+    asm ("" : "=r" (edi));
+    asm ("" : "=r" (ebp));
+    #endif
+    arr[0] = ebx;
+    arr[1] = esi;
+    arr[2] = edi;
+    arr[3] = ebp;
+}
+
+#elif defined(__thumb2__) || defined(__thumb__) || defined(__arm__)
+
+// Fallback implementation, prefer gchelper_m0.s or gchelper_m3.s
+
+STATIC void gc_helper_get_regs(gc_helper_regs_t arr) {
+    register long r4 asm ("r4");
+    register long r5 asm ("r5");
+    register long r6 asm ("r6");
+    register long r7 asm ("r7");
+    register long r8 asm ("r8");
+    register long r9 asm ("r9");
+    register long r10 asm ("r10");
+    register long r11 asm ("r11");
+    register long r12 asm ("r12");
+    register long r13 asm ("r13");
+    arr[0] = r4;
+    arr[1] = r5;
+    arr[2] = r6;
+    arr[3] = r7;
+    arr[4] = r8;
+    arr[5] = r9;
+    arr[6] = r10;
+    arr[7] = r11;
+    arr[8] = r12;
+    arr[9] = r13;
+}
+
+#else
+
+#error "Architecture not supported for gc_helper_get_regs. Set MICROPY_GCREGS_SETJMP to use the fallback implementation."
+
+#endif
+
+#else // !MICROPY_GCREGS_SETJMP
+
+// Even if we have specific support for an architecture, it is
+// possible to force use of setjmp-based implementation.
+
+STATIC void gc_helper_get_regs(gc_helper_regs_t arr) {
+    setjmp(arr);
+}
+
+#endif // MICROPY_GCREGS_SETJMP
+
+// Explicitly mark this as noinline to make sure the regs variable
+// is effectively at the top of the stack: otherwise, in builds where
+// LTO is enabled and a lot of inlining takes place we risk a stack
+// layout where regs is lower on the stack than pointers which have
+// just been allocated but not yet marked, and get incorrectly sweeped.
+MP_NOINLINE void gc_helper_collect_regs_and_stack(void) {
+    gc_helper_regs_t regs;
+    gc_helper_get_regs(regs);
+    // GC stack (and regs because we captured them)
+    void **regs_ptr = (void **)(void *)&regs;
+    gc_collect_root(regs_ptr, ((uintptr_t)MP_STATE_THREAD(stack_top) - (uintptr_t)&regs) / sizeof(uintptr_t));
+}
+
+#endif // MICROPY_ENABLE_GC
diff --git a/lib/utils/gchelper_m3.s b/lib/utils/gchelper_m3.s
index 3aac0dedfd04b..5220fa088360a 100644
--- a/lib/utils/gchelper_m3.s
+++ b/lib/utils/gchelper_m3.s
@@ -31,18 +31,6 @@
     .section .text
     .align  2
 
-    .global gc_helper_get_sp
-    .type gc_helper_get_sp, %function
-
-@ uint gc_helper_get_sp(void)
-gc_helper_get_sp:
-    @ return the sp
-    mov     r0, sp
-    bx      lr
-
-    .size gc_helper_get_sp, .-gc_helper_get_sp
-
-
     .global gc_helper_get_regs_and_sp
     .type gc_helper_get_regs_and_sp, %function
 
diff --git a/ports/cc3200/misc/mpexception.h b/lib/utils/gchelper_native.c
similarity index 68%
rename from ports/cc3200/misc/mpexception.h
rename to lib/utils/gchelper_native.c
index e84a1edb21a59..6bf386b5192b8 100644
--- a/ports/cc3200/misc/mpexception.h
+++ b/lib/utils/gchelper_native.c
@@ -4,7 +4,6 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2013, 2014 Damien P. George
- * Copyright (c) 2015 Daniel Campora
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,11 +23,25 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-#ifndef MICROPY_INCLUDED_CC3200_MISC_MPEXCEPTION_H
-#define MICROPY_INCLUDED_CC3200_MISC_MPEXCEPTION_H
 
-extern const char mpexception_value_invalid_arguments[];
-extern const char mpexception_num_type_invalid_arguments[];
-extern const char mpexception_uncaught[];
+#include <stdio.h>
 
-#endif // MICROPY_INCLUDED_CC3200_MISC_MPEXCEPTION_H
+#include "py/mpstate.h"
+#include "py/gc.h"
+#include "lib/utils/gchelper.h"
+
+#if MICROPY_ENABLE_GC
+
+// provided by gchelper_*.s
+uintptr_t gc_helper_get_regs_and_sp(uintptr_t *regs);
+
+MP_NOINLINE void gc_helper_collect_regs_and_stack(void) {
+    // get the registers and the sp
+    gc_helper_regs_t regs;
+    uintptr_t sp = gc_helper_get_regs_and_sp(regs);
+
+    // trace the stack, including the registers (since they live on the stack in this function)
+    gc_collect_root((void **)sp, ((uint32_t)MP_STATE_THREAD(stack_top) - sp) / sizeof(uint32_t));
+}
+
+#endif
diff --git a/lib/utils/interrupt_char.c b/lib/utils/interrupt_char.c
index fca0f95b5bf4a..7014ae6a8fc44 100644
--- a/lib/utils/interrupt_char.c
+++ b/lib/utils/interrupt_char.c
@@ -29,22 +29,10 @@
 
 #if MICROPY_KBD_EXCEPTION
 
-int mp_interrupt_char;
+int mp_interrupt_char = -1;
 
 void mp_hal_set_interrupt_char(int c) {
-    if (c != -1) {
-        mp_obj_exception_clear_traceback(MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_kbd_exception)));
-    }
     mp_interrupt_char = c;
 }
 
-void mp_keyboard_interrupt(void) {
-    MP_STATE_VM(mp_pending_exception) = MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_kbd_exception));
-    #if MICROPY_ENABLE_SCHEDULER
-    if (MP_STATE_VM(sched_state) == MP_SCHED_IDLE) {
-        MP_STATE_VM(sched_state) = MP_SCHED_PENDING;
-    }
-    #endif
-}
-
 #endif
diff --git a/lib/utils/interrupt_char.h b/lib/utils/interrupt_char.h
index ca50d4d567602..cb086ead9287e 100644
--- a/lib/utils/interrupt_char.h
+++ b/lib/utils/interrupt_char.h
@@ -28,6 +28,5 @@
 
 extern int mp_interrupt_char;
 void mp_hal_set_interrupt_char(int c);
-void mp_keyboard_interrupt(void);
 
 #endif // MICROPY_INCLUDED_LIB_UTILS_INTERRUPT_CHAR_H
diff --git a/lib/utils/mpirq.c b/lib/utils/mpirq.c
index d54c15482fd07..8de13b0b6a3c8 100644
--- a/lib/utils/mpirq.c
+++ b/lib/utils/mpirq.c
@@ -36,7 +36,7 @@
  ******************************************************************************/
 
 const mp_arg_t mp_irq_init_args[] = {
-    { MP_QSTR_handler, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+    { MP_QSTR_handler, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
     { MP_QSTR_trigger, MP_ARG_INT, {.u_int = 0} },
     { MP_QSTR_hard, MP_ARG_BOOL, {.u_bool = false} },
 };
@@ -52,7 +52,7 @@ const mp_arg_t mp_irq_init_args[] = {
 mp_irq_obj_t *mp_irq_new(const mp_irq_methods_t *methods, mp_obj_t parent) {
     mp_irq_obj_t *self = m_new0(mp_irq_obj_t, 1);
     self->base.type = &mp_irq_type;
-    self->methods = (mp_irq_methods_t*)methods;
+    self->methods = (mp_irq_methods_t *)methods;
     self->parent = parent;
     self->handler = mp_const_none;
     self->ishard = false;
@@ -62,8 +62,10 @@ mp_irq_obj_t *mp_irq_new(const mp_irq_methods_t *methods, mp_obj_t parent) {
 void mp_irq_handler(mp_irq_obj_t *self) {
     if (self->handler != mp_const_none) {
         if (self->ishard) {
-            // When executing code within a handler we must lock the GC to prevent
-            // any memory allocations.
+            // When executing code within a handler we must lock the scheduler to
+            // prevent any scheduled callbacks from running, and lock the GC to
+            // prevent any memory allocations.
+            mp_sched_lock();
             gc_lock();
             nlr_buf_t nlr;
             if (nlr_push(&nlr) == 0) {
@@ -77,6 +79,7 @@ void mp_irq_handler(mp_irq_obj_t *self) {
                 mp_obj_print_exception(&mp_plat_print, MP_OBJ_FROM_PTR(nlr.ret_val));
             }
             gc_unlock();
+            mp_sched_unlock();
         } else {
             // Schedule call to user function
             mp_sched_schedule(self->handler, self->parent);
@@ -120,5 +123,5 @@ const mp_obj_type_t mp_irq_type = {
     { &mp_type_type },
     .name = MP_QSTR_irq,
     .call = mp_irq_call,
-    .locals_dict = (mp_obj_dict_t*)&mp_irq_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&mp_irq_locals_dict,
 };
diff --git a/lib/utils/printf.c b/lib/utils/printf.c
index 0c21fc4c0af17..6266ab66d3cdc 100644
--- a/lib/utils/printf.c
+++ b/lib/utils/printf.c
@@ -130,4 +130,4 @@ int snprintf(char *str, size_t size, const char *fmt, ...) {
     return ret;
 }
 
-#endif //MICROPY_USE_INTERNAL_PRINTF
+#endif // MICROPY_USE_INTERNAL_PRINTF
diff --git a/lib/utils/pyexec.c b/lib/utils/pyexec.c
index f4e6856e506fa..ec20daff4b23d 100644
--- a/lib/utils/pyexec.c
+++ b/lib/utils/pyexec.c
@@ -45,7 +45,10 @@
 
 pyexec_mode_kind_t pyexec_mode_kind = PYEXEC_MODE_FRIENDLY_REPL;
 int pyexec_system_exit = 0;
+
+#if MICROPY_REPL_INFO
 STATIC bool repl_display_debugging_info = 0;
+#endif
 
 #define EXEC_FLAG_PRINT_EOF (1)
 #define EXEC_FLAG_ALLOW_DEBUGGING (2)
@@ -61,7 +64,9 @@ STATIC bool repl_display_debugging_info = 0;
 // EXEC_FLAG_IS_REPL is used for REPL inputs (flag passed on to mp_compile)
 STATIC int parse_compile_execute(const void *source, mp_parse_input_kind_t input_kind, int exec_flags) {
     int ret = 0;
+    #if MICROPY_REPL_INFO
     uint32_t start = 0;
+    #endif
 
     // by default a SystemExit exception returns 0
     pyexec_system_exit = 0;
@@ -84,12 +89,12 @@ STATIC int parse_compile_execute(const void *source, mp_parse_input_kind_t input
             } else if (exec_flags & EXEC_FLAG_SOURCE_IS_FILENAME) {
                 lex = mp_lexer_new_from_file(source);
             } else {
-                lex = (mp_lexer_t*)source;
+                lex = (mp_lexer_t *)source;
             }
             // source is a lexer, parse and compile the script
             qstr source_name = lex->source_name;
             mp_parse_tree_t parse_tree = mp_parse(lex, input_kind);
-            module_fun = mp_compile(&parse_tree, source_name, MP_EMIT_OPT_NONE, exec_flags & EXEC_FLAG_IS_REPL);
+            module_fun = mp_compile(&parse_tree, source_name, exec_flags & EXEC_FLAG_IS_REPL);
             #else
             mp_raise_msg(&mp_type_RuntimeError, "script compilation not supported");
             #endif
@@ -97,9 +102,12 @@ STATIC int parse_compile_execute(const void *source, mp_parse_input_kind_t input
 
         // execute code
         mp_hal_set_interrupt_char(CHAR_CTRL_C); // allow ctrl-C to interrupt us
+        #if MICROPY_REPL_INFO
         start = mp_hal_ticks_ms();
+        #endif
         mp_call_function_0(module_fun);
         mp_hal_set_interrupt_char(-1); // disable interrupt
+        mp_handle_pending(true); // handle any pending exceptions (and any callbacks)
         nlr_pop();
         ret = 1;
         if (exec_flags & EXEC_FLAG_PRINT_EOF) {
@@ -107,14 +115,14 @@ STATIC int parse_compile_execute(const void *source, mp_parse_input_kind_t input
         }
     } else {
         // uncaught exception
-        // FIXME it could be that an interrupt happens just before we disable it here
         mp_hal_set_interrupt_char(-1); // disable interrupt
+        mp_handle_pending(false); // clear any pending exceptions (and run any callbacks)
         // print EOF after normal output
         if (exec_flags & EXEC_FLAG_PRINT_EOF) {
             mp_hal_stdout_tx_strn("\x04", 1);
         }
         // check for SystemExit
-        if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(((mp_obj_base_t*)nlr.ret_val)->type), MP_OBJ_FROM_PTR(&mp_type_SystemExit))) {
+        if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(((mp_obj_base_t *)nlr.ret_val)->type), MP_OBJ_FROM_PTR(&mp_type_SystemExit))) {
             // at the moment, the value of SystemExit is unused
             ret = pyexec_system_exit;
         } else {
@@ -123,6 +131,7 @@ STATIC int parse_compile_execute(const void *source, mp_parse_input_kind_t input
         }
     }
 
+    #if MICROPY_REPL_INFO
     // display debugging info if wanted
     if ((exec_flags & EXEC_FLAG_ALLOW_DEBUGGING) && repl_display_debugging_info) {
         mp_uint_t ticks = mp_hal_ticks_ms() - start; // TODO implement a function that does this properly
@@ -132,8 +141,8 @@ STATIC int parse_compile_execute(const void *source, mp_parse_input_kind_t input
             size_t n_pool, n_qstr, n_str_data_bytes, n_total_bytes;
             qstr_pool_info(&n_pool, &n_qstr, &n_str_data_bytes, &n_total_bytes);
             printf("qstr:\n  n_pool=%u\n  n_qstr=%u\n  "
-                   "n_str_data_bytes=%u\n  n_total_bytes=%u\n",
-                   (unsigned)n_pool, (unsigned)n_qstr, (unsigned)n_str_data_bytes, (unsigned)n_total_bytes);
+                "n_str_data_bytes=%u\n  n_total_bytes=%u\n",
+                (unsigned)n_pool, (unsigned)n_qstr, (unsigned)n_str_data_bytes, (unsigned)n_total_bytes);
         }
 
         #if MICROPY_ENABLE_GC
@@ -142,6 +151,7 @@ STATIC int parse_compile_execute(const void *source, mp_parse_input_kind_t input
         gc_dump_info();
         #endif
     }
+    #endif
 
     if (exec_flags & EXEC_FLAG_PRINT_EOF) {
         mp_hal_stdout_tx_strn("\x04", 1);
@@ -158,7 +168,7 @@ typedef struct _repl_t {
     // but it was moved to MP_STATE_VM(repl_line) as containing
     // root pointer. Still keep structure in case more state
     // will be added later.
-    //vstr_t line;
+    // vstr_t line;
     bool cont_line;
     bool paste_mode;
 } repl_t;
@@ -306,10 +316,10 @@ STATIC int pyexec_friendly_repl_process_char(int c) {
     } else {
 
         if (ret == CHAR_CTRL_C) {
-           // cancel everything
-           mp_hal_stdout_tx_str("\r\n");
-           repl.cont_line = false;
-           goto input_restart;
+            // cancel everything
+            mp_hal_stdout_tx_str("\r\n");
+            repl.cont_line = false;
+            goto input_restart;
         } else if (ret == CHAR_CTRL_D) {
             // stop entering compound statement
             goto exec;
@@ -325,13 +335,13 @@ STATIC int pyexec_friendly_repl_process_char(int c) {
             return 0;
         }
 
-exec: ;
+    exec:;
         int ret = parse_compile_execute(MP_STATE_VM(repl_line), MP_PARSE_SINGLE_INPUT, EXEC_FLAG_ALLOW_DEBUGGING | EXEC_FLAG_IS_REPL | EXEC_FLAG_SOURCE_IS_VSTR);
         if (ret & PYEXEC_FORCED_EXIT) {
             return ret;
         }
 
-input_restart:
+    input_restart:
         vstr_reset(MP_STATE_VM(repl_line));
         repl.cont_line = false;
         repl.paste_mode = false;
@@ -409,11 +419,11 @@ int pyexec_friendly_repl(void) {
     vstr_t line;
     vstr_init(&line, 32);
 
-#if defined(USE_HOST_MODE) && MICROPY_HW_HAS_LCD
+    #if defined(USE_HOST_MODE) && MICROPY_HW_HAS_LCD
     // in host mode, we enable the LCD for the repl
     mp_obj_t lcd_o = mp_call_function_0(mp_load_name(qstr_from_str("LCD")));
     mp_call_function_1(mp_load_attr(lcd_o, qstr_from_str("light")), mp_const_true);
-#endif
+    #endif
 
 friendly_repl_reset:
     mp_hal_stdout_tx_str("MicroPython " MICROPY_GIT_TAG " on " MICROPY_BUILD_DATE "; " MICROPY_HW_BOARD_NAME " with " MICROPY_HW_MCU_NAME "\r\n");
@@ -541,6 +551,18 @@ int pyexec_file(const char *filename) {
     return parse_compile_execute(filename, MP_PARSE_FILE_INPUT, EXEC_FLAG_SOURCE_IS_FILENAME);
 }
 
+int pyexec_file_if_exists(const char *filename) {
+    #if MICROPY_MODULE_FROZEN
+    if (mp_frozen_stat(filename) == MP_IMPORT_STAT_FILE) {
+        return pyexec_frozen_module(filename);
+    }
+    #endif
+    if (mp_import_stat(filename) != MP_IMPORT_STAT_FILE) {
+        return 1; // success (no file is the same as an empty file executing without fail)
+    }
+    return pyexec_file(filename);
+}
+
 #if MICROPY_MODULE_FROZEN
 int pyexec_frozen_module(const char *name) {
     void *frozen_data;
@@ -564,9 +586,10 @@ int pyexec_frozen_module(const char *name) {
 }
 #endif
 
+#if MICROPY_REPL_INFO
 mp_obj_t pyb_set_repl_info(mp_obj_t o_value) {
     repl_display_debugging_info = mp_obj_get_int(o_value);
     return mp_const_none;
 }
-
 MP_DEFINE_CONST_FUN_OBJ_1(pyb_set_repl_info_obj, pyb_set_repl_info);
+#endif
diff --git a/lib/utils/pyexec.h b/lib/utils/pyexec.h
index a0d0b52b16146..f69c5ce9a884e 100644
--- a/lib/utils/pyexec.h
+++ b/lib/utils/pyexec.h
@@ -29,8 +29,8 @@
 #include "py/obj.h"
 
 typedef enum {
-    PYEXEC_MODE_RAW_REPL,
     PYEXEC_MODE_FRIENDLY_REPL,
+    PYEXEC_MODE_RAW_REPL,
 } pyexec_mode_kind_t;
 
 extern pyexec_mode_kind_t pyexec_mode_kind;
@@ -46,12 +46,15 @@ extern int pyexec_system_exit;
 int pyexec_raw_repl(void);
 int pyexec_friendly_repl(void);
 int pyexec_file(const char *filename);
+int pyexec_file_if_exists(const char *filename);
 int pyexec_frozen_module(const char *name);
 void pyexec_event_repl_init(void);
 int pyexec_event_repl_process_char(int c);
 extern uint8_t pyexec_repl_active;
-mp_obj_t pyb_set_repl_info(mp_obj_t o_value);
 
+#if MICROPY_REPL_INFO
+mp_obj_t pyb_set_repl_info(mp_obj_t o_value);
 MP_DECLARE_CONST_FUN_OBJ_1(pyb_set_repl_info_obj);
+#endif
 
 #endif // MICROPY_INCLUDED_LIB_UTILS_PYEXEC_H
diff --git a/lib/utils/sys_stdio_mphal.c b/lib/utils/sys_stdio_mphal.c
index 234db0829bf60..e72facb981d9c 100644
--- a/lib/utils/sys_stdio_mphal.c
+++ b/lib/utils/sys_stdio_mphal.c
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013-2017 Damien P. George
+ * Copyright (c) 2013-2019 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -65,7 +65,7 @@ STATIC mp_uint_t stdio_read(mp_obj_t self_in, void *buf, mp_uint_t size, int *er
             if (c == '\r') {
                 c = '\n';
             }
-            ((byte*)buf)[i] = c;
+            ((byte *)buf)[i] = c;
         }
         return size;
     } else {
@@ -85,6 +85,16 @@ STATIC mp_uint_t stdio_write(mp_obj_t self_in, const void *buf, mp_uint_t size,
     }
 }
 
+STATIC mp_uint_t stdio_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    (void)self_in;
+    if (request == MP_STREAM_POLL) {
+        return mp_hal_stdio_poll(arg);
+    } else {
+        *errcode = MP_EINVAL;
+        return MP_STREAM_ERROR;
+    }
+}
+
 STATIC mp_obj_t stdio_obj___exit__(size_t n_args, const mp_obj_t *args) {
     return mp_const_none;
 }
@@ -93,9 +103,9 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(stdio_obj___exit___obj, 4, 4, stdio_o
 // TODO gc hook to close the file if not already closed
 
 STATIC const mp_rom_map_elem_t stdio_locals_dict_table[] = {
-#if MICROPY_PY_SYS_STDIO_BUFFER
+    #if MICROPY_PY_SYS_STDIO_BUFFER
     { MP_ROM_QSTR(MP_QSTR_buffer), MP_ROM_PTR(&stdio_buffer_obj) },
-#endif
+    #endif
     { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
     { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
     { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj)},
@@ -112,6 +122,7 @@ STATIC MP_DEFINE_CONST_DICT(stdio_locals_dict, stdio_locals_dict_table);
 STATIC const mp_stream_p_t stdio_obj_stream_p = {
     .read = stdio_read,
     .write = stdio_write,
+    .ioctl = stdio_ioctl,
     .is_text = true,
 };
 
@@ -123,7 +134,7 @@ STATIC const mp_obj_type_t stdio_obj_type = {
     .getiter = mp_identity_getiter,
     .iternext = mp_stream_unbuffered_iter,
     .protocol = &stdio_obj_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&stdio_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&stdio_locals_dict,
 };
 
 const sys_stdio_obj_t mp_sys_stdin_obj = {{&stdio_obj_type}, .fd = STDIO_FD_IN};
@@ -133,7 +144,7 @@ const sys_stdio_obj_t mp_sys_stderr_obj = {{&stdio_obj_type}, .fd = STDIO_FD_ERR
 #if MICROPY_PY_SYS_STDIO_BUFFER
 STATIC mp_uint_t stdio_buffer_read(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode) {
     for (uint i = 0; i < size; i++) {
-        ((byte*)buf)[i] = mp_hal_stdin_rx_chr();
+        ((byte *)buf)[i] = mp_hal_stdin_rx_chr();
     }
     return size;
 }
@@ -146,6 +157,7 @@ STATIC mp_uint_t stdio_buffer_write(mp_obj_t self_in, const void *buf, mp_uint_t
 STATIC const mp_stream_p_t stdio_buffer_obj_stream_p = {
     .read = stdio_buffer_read,
     .write = stdio_buffer_write,
+    .ioctl = stdio_ioctl,
     .is_text = false,
 };
 
@@ -156,7 +168,7 @@ STATIC const mp_obj_type_t stdio_buffer_obj_type = {
     .getiter = mp_identity_getiter,
     .iternext = mp_stream_unbuffered_iter,
     .protocol = &stdio_buffer_obj_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&stdio_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&stdio_locals_dict,
 };
 
 STATIC const sys_stdio_obj_t stdio_buffer_obj = {{&stdio_buffer_obj_type}, .fd = 0}; // fd unused
diff --git a/mpy-cross/Makefile b/mpy-cross/Makefile
index 4ff96fc80c007..f80ee761b7bcf 100644
--- a/mpy-cross/Makefile
+++ b/mpy-cross/Makefile
@@ -1,20 +1,3 @@
-# The following is a temporary hack to forefully undefine vars that might have
-# be defined by a calling Makefile (from recursive make).
-# TODO: Find a better way to be able to call this Makefile recursively.
-ifneq ($(findstring undefine,$(.FEATURES)),)
-override undefine COPT
-override undefine CFLAGS_EXTRA
-override undefine LDFLAGS_EXTRA
-override undefine MICROPY_FORCE_32BIT
-override undefine CROSS_COMPILE
-override undefine FROZEN_DIR
-override undefine FROZEN_MPY_DIR
-override undefine USER_C_MODULES
-override undefine SRC_MOD
-override undefine BUILD
-override undefine PROG
-endif
-
 include ../py/mkenv.mk
 
 # define main target
@@ -65,6 +48,7 @@ LDFLAGS = $(LDFLAGS_MOD) $(LDFLAGS_ARCH) -lm $(LDFLAGS_EXTRA)
 SRC_C = \
 	main.c \
 	gccollect.c \
+	lib/utils/gchelper_generic.c \
 
 # Add fmode when compiling with mingw gcc
 COMPILER_TARGET := $(shell $(CC) -dumpmachine)
diff --git a/mpy-cross/README.md b/mpy-cross/README.md
index e35b28b6969ec..bf743a903163d 100644
--- a/mpy-cross/README.md
+++ b/mpy-cross/README.md
@@ -22,4 +22,10 @@ the unix port of MicroPython requires the following:
 
     $ ./mpy-cross -mcache-lookup-bc foo.py
 
+If the Python code contains `@native` or `@viper` annotations, then you must
+specify `-march` to match the target architecture.
+
 Run `./mpy-cross -h` to get a full list of options.
+
+The optimisation level is 0 by default. Optimisation levels are detailed in
+https://docs.micropython.org/en/latest/library/micropython.html#micropython.opt_level
diff --git a/mpy-cross/gccollect.c b/mpy-cross/gccollect.c
index 9e4b59d9ef6d7..120f1a225249c 100644
--- a/mpy-cross/gccollect.c
+++ b/mpy-cross/gccollect.c
@@ -29,121 +29,14 @@
 #include "py/mpstate.h"
 #include "py/gc.h"
 
-#if MICROPY_ENABLE_GC
-
-// Even if we have specific support for an architecture, it is
-// possible to force use of setjmp-based implementation.
-#if !MICROPY_GCREGS_SETJMP
-
-// We capture here callee-save registers, i.e. ones which may contain
-// interesting values held there by our callers. It doesn't make sense
-// to capture caller-saved registers, because they, well, put on the
-// stack already by the caller.
-#if defined(__x86_64__)
-typedef mp_uint_t regs_t[6];
-
-STATIC void gc_helper_get_regs(regs_t arr) {
-    register long rbx asm ("rbx");
-    register long rbp asm ("rbp");
-    register long r12 asm ("r12");
-    register long r13 asm ("r13");
-    register long r14 asm ("r14");
-    register long r15 asm ("r15");
-#ifdef __clang__
-    // TODO:
-    // This is dirty workaround for Clang. It tries to get around
-    // uncompliant (wrt to GCC) behavior of handling register variables.
-    // Application of this patch here is random, and done only to unbreak
-    // MacOS build. Better, cross-arch ways to deal with Clang issues should
-    // be found.
-    asm("" : "=r"(rbx));
-    asm("" : "=r"(rbp));
-    asm("" : "=r"(r12));
-    asm("" : "=r"(r13));
-    asm("" : "=r"(r14));
-    asm("" : "=r"(r15));
-#endif
-    arr[0] = rbx;
-    arr[1] = rbp;
-    arr[2] = r12;
-    arr[3] = r13;
-    arr[4] = r14;
-    arr[5] = r15;
-}
-
-#elif defined(__i386__)
-
-typedef mp_uint_t regs_t[4];
-
-STATIC void gc_helper_get_regs(regs_t arr) {
-    register long ebx asm ("ebx");
-    register long esi asm ("esi");
-    register long edi asm ("edi");
-    register long ebp asm ("ebp");
-    arr[0] = ebx;
-    arr[1] = esi;
-    arr[2] = edi;
-    arr[3] = ebp;
-}
-
-#elif defined(__thumb2__) || defined(__thumb__) || defined(__arm__)
-
-typedef mp_uint_t regs_t[10];
+#include "lib/utils/gchelper.h"
 
-STATIC void gc_helper_get_regs(regs_t arr) {
-    register long r4 asm ("r4");
-    register long r5 asm ("r5");
-    register long r6 asm ("r6");
-    register long r7 asm ("r7");
-    register long r8 asm ("r8");
-    register long r9 asm ("r9");
-    register long r10 asm ("r10");
-    register long r11 asm ("r11");
-    register long r12 asm ("r12");
-    register long r13 asm ("r13");
-    arr[0] = r4;
-    arr[1] = r5;
-    arr[2] = r6;
-    arr[3] = r7;
-    arr[4] = r8;
-    arr[5] = r9;
-    arr[6] = r10;
-    arr[7] = r11;
-    arr[8] = r12;
-    arr[9] = r13;
-}
-
-#else
-
-// If we don't have architecture-specific optimized support,
-// just fall back to setjmp-based implementation.
-#undef MICROPY_GCREGS_SETJMP
-#define MICROPY_GCREGS_SETJMP (1)
-
-#endif // Arch-specific selection
-#endif // !MICROPY_GCREGS_SETJMP
-
-// If MICROPY_GCREGS_SETJMP was requested explicitly, or if
-// we enabled it as a fallback above.
-#if MICROPY_GCREGS_SETJMP
-#include <setjmp.h>
-
-typedef jmp_buf regs_t;
-
-STATIC void gc_helper_get_regs(regs_t arr) {
-    setjmp(arr);
-}
-
-#endif // MICROPY_GCREGS_SETJMP
+#if MICROPY_ENABLE_GC
 
 void gc_collect(void) {
     gc_collect_start();
-    regs_t regs;
-    gc_helper_get_regs(regs);
-    // GC stack (and regs because we captured them)
-    void **regs_ptr = (void**)(void*)&regs;
-    gc_collect_root(regs_ptr, ((mp_uint_t)MP_STATE_THREAD(stack_top) - (mp_uint_t)&regs) / sizeof(mp_uint_t));
+    gc_helper_collect_regs_and_stack();
     gc_collect_end();
 }
 
-#endif //MICROPY_ENABLE_GC
+#endif // MICROPY_ENABLE_GC
diff --git a/mpy-cross/main.c b/mpy-cross/main.c
index 6e5af2739bc40..a403c0504dd76 100644
--- a/mpy-cross/main.c
+++ b/mpy-cross/main.c
@@ -34,6 +34,7 @@
 #include "py/runtime.h"
 #include "py/gc.h"
 #include "py/stackctrl.h"
+#include "genhdr/mpversion.h"
 #ifdef _WIN32
 #include "ports/windows/fmode.h"
 #endif
@@ -44,9 +45,9 @@ mp_uint_t mp_verbose_flag = 0;
 
 // Heap size of GC heap (if enabled)
 // Make it larger on a 64 bit machine, because pointers are larger.
-long heap_size = 1024*1024 * (sizeof(mp_uint_t) / 4);
+long heap_size = 1024 * 1024 * (sizeof(mp_uint_t) / 4);
 
-STATIC void stderr_print_strn(void *env, const char *str, mp_uint_t len) {
+STATIC void stderr_print_strn(void *env, const char *str, size_t len) {
     (void)env;
     ssize_t dummy = write(STDERR_FILENO, str, len);
     (void)dummy;
@@ -71,7 +72,7 @@ STATIC int compile_and_save(const char *file, const char *output_file, const cha
         #endif
 
         mp_parse_tree_t parse_tree = mp_parse(lex, MP_PARSE_FILE_INPUT);
-        mp_raw_code_t *rc = mp_compile_to_raw_code(&parse_tree, source_name, emit_opt, false);
+        mp_raw_code_t *rc = mp_compile_to_raw_code(&parse_tree, source_name, false);
 
         vstr_t vstr;
         vstr_init(&vstr, 16);
@@ -96,29 +97,34 @@ STATIC int compile_and_save(const char *file, const char *output_file, const cha
 
 STATIC int usage(char **argv) {
     printf(
-"usage: %s [<opts>] [-X <implopt>] <input filename>\n"
-"Options:\n"
-"-o : output file for compiled bytecode (defaults to input with .mpy extension)\n"
-"-s : source filename to embed in the compiled bytecode (defaults to input file)\n"
-"-v : verbose (trace various operations); can be multiple\n"
-"-O[N] : apply bytecode optimizations of level N\n"
-"\n"
-"Target specific options:\n"
-"-msmall-int-bits=number : set the maximum bits used to encode a small-int\n"
-"-mno-unicode : don't support unicode in compiled strings\n"
-"-mcache-lookup-bc : cache map lookups in the bytecode\n"
-"-march=<arch> : set architecture for native emitter; x86, x64, armv6, armv7m, xtensa\n"
-"\n"
-"Implementation specific options:\n", argv[0]
-);
+        "usage: %s [<opts>] [-X <implopt>] <input filename>\n"
+        "Options:\n"
+        "--version : show version information\n"
+        "-o : output file for compiled bytecode (defaults to input with .mpy extension)\n"
+        "-s : source filename to embed in the compiled bytecode (defaults to input file)\n"
+        "-v : verbose (trace various operations); can be multiple\n"
+        "-O[N] : apply bytecode optimizations of level N\n"
+        "\n"
+        "Target specific options:\n"
+        "-msmall-int-bits=number : set the maximum bits used to encode a small-int\n"
+        "-mno-unicode : don't support unicode in compiled strings\n"
+        "-mcache-lookup-bc : cache map lookups in the bytecode\n"
+        "-march=<arch> : set architecture for native emitter; x86, x64, armv6, armv7m, armv7em, armv7emsp, armv7emdp, xtensa, xtensawin\n"
+        "\n"
+        "Implementation specific options:\n", argv[0]
+        );
     int impl_opts_cnt = 0;
     printf(
-"  emit={bytecode,native,viper} -- set the default code emitter\n"
-);
+        #if MICROPY_EMIT_NATIVE
+        "  emit={bytecode,native,viper} -- set the default code emitter\n"
+        #else
+        "  emit=bytecode -- set the default code emitter\n"
+        #endif
+        );
     impl_opts_cnt++;
     printf(
-"  heapsize=<n> -- set the heap size for the GC (default %ld)\n"
-, heap_size);
+        "  heapsize=<n> -- set the heap size for the GC (default %ld)\n"
+        , heap_size);
     impl_opts_cnt++;
 
     if (impl_opts_cnt == 0) {
@@ -138,10 +144,12 @@ STATIC void pre_process_options(int argc, char **argv) {
                 }
                 if (strcmp(argv[a + 1], "emit=bytecode") == 0) {
                     emit_opt = MP_EMIT_OPT_BYTECODE;
+                #if MICROPY_EMIT_NATIVE
                 } else if (strcmp(argv[a + 1], "emit=native") == 0) {
                     emit_opt = MP_EMIT_OPT_NATIVE_PYTHON;
                 } else if (strcmp(argv[a + 1], "emit=viper") == 0) {
                     emit_opt = MP_EMIT_OPT_VIPER;
+                #endif
                 } else if (strncmp(argv[a + 1], "heapsize=", sizeof("heapsize=") - 1) == 0) {
                     char *end;
                     heap_size = strtol(argv[a + 1] + sizeof("heapsize=") - 1, &end, 0);
@@ -182,22 +190,35 @@ MP_NOINLINE int main_(int argc, char **argv) {
     gc_init(heap, heap + heap_size);
 
     mp_init();
-#ifdef _WIN32
+    #ifdef _WIN32
     set_fmode_binary();
-#endif
+    #endif
     mp_obj_list_init(mp_sys_path, 0);
     mp_obj_list_init(mp_sys_argv, 0);
 
+    #if MICROPY_EMIT_NATIVE
+    // Set default emitter options
+    MP_STATE_VM(default_emit_opt) = emit_opt;
+    #else
+    (void)emit_opt;
+    #endif
+
     // set default compiler configuration
     mp_dynamic_compiler.small_int_bits = 31;
     mp_dynamic_compiler.opt_cache_map_lookup_in_bytecode = 0;
     mp_dynamic_compiler.py_builtins_str_unicode = 1;
     #if defined(__i386__)
     mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_X86;
+    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_X86;
     #elif defined(__x86_64__)
     mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_X64;
+    mp_dynamic_compiler.nlr_buf_num_regs = MAX(MICROPY_NLR_NUM_REGS_X64, MICROPY_NLR_NUM_REGS_X64_WIN);
+    #elif defined(__arm__) && !defined(__thumb2__)
+    mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_ARMV6;
+    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_ARM_THUMB_FP;
     #else
     mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_NONE;
+    mp_dynamic_compiler.nlr_buf_num_regs = 0;
     #endif
 
     const char *input_file = NULL;
@@ -209,6 +230,10 @@ MP_NOINLINE int main_(int argc, char **argv) {
         if (argv[a][0] == '-') {
             if (strcmp(argv[a], "-X") == 0) {
                 a += 1;
+            } else if (strcmp(argv[a], "--version") == 0) {
+                printf("MicroPython " MICROPY_GIT_TAG " on " MICROPY_BUILD_DATE
+                    "; mpy-cross emitting mpy v" MP_STRINGIFY(MPY_VERSION) "\n");
+                return 0;
             } else if (strcmp(argv[a], "-v") == 0) {
                 mp_verbose_flag++;
             } else if (strncmp(argv[a], "-O", 2) == 0) {
@@ -216,7 +241,8 @@ MP_NOINLINE int main_(int argc, char **argv) {
                     MP_STATE_VM(mp_optimise_value) = argv[a][2] & 0xf;
                 } else {
                     MP_STATE_VM(mp_optimise_value) = 0;
-                    for (char *p = argv[a] + 1; *p && *p == 'O'; p++, MP_STATE_VM(mp_optimise_value)++);
+                    for (char *p = argv[a] + 1; *p && *p == 'O'; p++, MP_STATE_VM(mp_optimise_value)++) {;
+                    }
                 }
             } else if (strcmp(argv[a], "-o") == 0) {
                 if (a + 1 >= argc) {
@@ -250,14 +276,31 @@ MP_NOINLINE int main_(int argc, char **argv) {
                 const char *arch = argv[a] + sizeof("-march=") - 1;
                 if (strcmp(arch, "x86") == 0) {
                     mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_X86;
+                    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_X86;
                 } else if (strcmp(arch, "x64") == 0) {
                     mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_X64;
+                    mp_dynamic_compiler.nlr_buf_num_regs = MAX(MICROPY_NLR_NUM_REGS_X64, MICROPY_NLR_NUM_REGS_X64_WIN);
                 } else if (strcmp(arch, "armv6") == 0) {
                     mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_ARMV6;
+                    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_ARM_THUMB_FP;
                 } else if (strcmp(arch, "armv7m") == 0) {
                     mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_ARMV7M;
+                    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_ARM_THUMB_FP;
+                } else if (strcmp(arch, "armv7em") == 0) {
+                    mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_ARMV7EM;
+                    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_ARM_THUMB_FP;
+                } else if (strcmp(arch, "armv7emsp") == 0) {
+                    mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_ARMV7EMSP;
+                    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_ARM_THUMB_FP;
+                } else if (strcmp(arch, "armv7emdp") == 0) {
+                    mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_ARMV7EMDP;
+                    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_ARM_THUMB_FP;
                 } else if (strcmp(arch, "xtensa") == 0) {
                     mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_XTENSA;
+                    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_XTENSA;
+                } else if (strcmp(arch, "xtensawin") == 0) {
+                    mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_XTENSAWIN;
+                    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_XTENSAWIN;
                 } else {
                     return usage(argv);
                 }
@@ -302,6 +345,6 @@ uint mp_import_stat(const char *path) {
 }
 
 void nlr_jump_fail(void *val) {
-    printf("FATAL: uncaught NLR %p\n", val);
+    fprintf(stderr, "FATAL: uncaught NLR %p\n", val);
     exit(1);
 }
diff --git a/mpy-cross/mpconfigport.h b/mpy-cross/mpconfigport.h
index 6aa013a134332..21d3e12ed43d7 100644
--- a/mpy-cross/mpconfigport.h
+++ b/mpy-cross/mpconfigport.h
@@ -39,6 +39,7 @@
 #define MICROPY_EMIT_ARM            (1)
 #define MICROPY_EMIT_XTENSA         (1)
 #define MICROPY_EMIT_INLINE_XTENSA  (1)
+#define MICROPY_EMIT_XTENSAWIN      (1)
 
 #define MICROPY_DYNAMIC_COMPILER    (1)
 #define MICROPY_COMP_CONST_FOLDING  (1)
@@ -67,14 +68,9 @@
 
 #define MICROPY_PY_BUILTINS_STR_UNICODE (1)
 
-// Define to 1 to use undertested inefficient GC helper implementation
-// (if more efficient arch-specific one is not available).
-#ifndef MICROPY_GCREGS_SETJMP
-    #ifdef __mips__
-        #define MICROPY_GCREGS_SETJMP (1)
-    #else
-        #define MICROPY_GCREGS_SETJMP (0)
-    #endif
+#if !(defined(MICROPY_GCREGS_SETJMP) || defined(__x86_64__) || defined(__i386__) || defined(__thumb2__) || defined(__thumb__) || defined(__arm__))
+// Fall back to setjmp() implementation for discovery of GC pointers in registers.
+#define MICROPY_GCREGS_SETJMP (1)
 #endif
 
 #define MICROPY_PY___FILE__         (0)
@@ -92,10 +88,13 @@
 #ifdef __LP64__
 typedef long mp_int_t; // must be pointer size
 typedef unsigned long mp_uint_t; // must be pointer size
-#elif defined ( __MINGW32__ ) && defined( _WIN64 )
+#elif defined(__MINGW32__) && defined(_WIN64)
 #include <stdint.h>
 typedef __int64 mp_int_t;
 typedef unsigned __int64 mp_uint_t;
+#elif defined(_MSC_VER) && defined(_WIN64)
+typedef __int64 mp_int_t;
+typedef unsigned __int64 mp_uint_t;
 #else
 // These are definitions for machines where sizeof(int) == sizeof(void*),
 // regardless for actual size.
@@ -112,17 +111,47 @@ typedef long mp_off_t;
 
 #define MP_PLAT_PRINT_STRN(str, len) (void)0
 
-#ifndef MP_NOINLINE
-#define MP_NOINLINE __attribute__((noinline))
-#endif
-
 // We need to provide a declaration/definition of alloca()
 #ifdef __FreeBSD__
 #include <stdlib.h>
-#elif defined( _WIN32 )
+#elif defined(_WIN32)
 #include <malloc.h>
 #else
 #include <alloca.h>
 #endif
 
 #include <stdint.h>
+
+// MSVC specifics - see windows/mpconfigport.h for explanation
+#ifdef _MSC_VER
+
+#define MP_ENDIANNESS_LITTLE        (1)
+#define NORETURN                    __declspec(noreturn)
+#define MP_NOINLINE                 __declspec(noinline)
+#define MP_LIKELY(x)                (x)
+#define MP_UNLIKELY(x)              (x)
+#define MICROPY_PORT_CONSTANTS      { "dummy", 0 }
+#ifdef _WIN64
+#define MP_SSIZE_MAX                _I64_MAX
+#else
+#define MP_SSIZE_MAX                _I32_MAX
+#endif
+#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)(p)) // Avoid compiler warning about different const qualifiers
+#define restrict
+#define inline                      __inline
+#define alignof(t)                  __alignof(t)
+#undef MICROPY_ALLOC_PATH_MAX
+#define MICROPY_ALLOC_PATH_MAX      260
+#define PATH_MAX                    MICROPY_ALLOC_PATH_MAX
+#define S_ISREG(m)                  (((m) & S_IFMT) == S_IFREG)
+#define S_ISDIR(m)                  (((m) & S_IFMT) == S_IFDIR)
+#ifdef _WIN64
+#define SSIZE_MAX                   _I64_MAX
+typedef __int64 ssize_t;
+#else
+#define SSIZE_MAX                   _I32_MAX
+typedef int ssize_t;
+#endif
+typedef mp_off_t off_t;
+
+#endif
diff --git a/mpy-cross/mpy-cross.vcxproj b/mpy-cross/mpy-cross.vcxproj
new file mode 100644
index 0000000000000..74a366712a204
--- /dev/null
+++ b/mpy-cross/mpy-cross.vcxproj
@@ -0,0 +1,106 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{740F3A30-3B6C-4B59-9C50-AE4D5A4A9D12}</ProjectGuid>
+    <RootNamespace>mpy-cross</RootNamespace>
+    <PyBuildingMpyCross>True</PyBuildingMpyCross>
+    <PyBuildDir>$(MSBuildThisFileDirectory)build\</PyBuildDir>
+    <PyIncDirs>$(MSBuildThisFileDirectory)</PyIncDirs>
+    <PyTargetDir>$(MSBuildThisFileDirectory)</PyTargetDir>
+    <PyMsvcDir>$(MSBuildThisFileDirectory)..\ports\windows\msvc\</PyMsvcDir>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="$(PyMsvcDir)common.props" />
+    <Import Project="$(PyMsvcDir)debug.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="$(PyMsvcDir)common.props" />
+    <Import Project="$(PyMsvcDir)release.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="$(PyMsvcDir)common.props" />
+    <Import Project="$(PyMsvcDir)debug.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="$(PyMsvcDir)common.props" />
+    <Import Project="$(PyMsvcDir)release.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros">
+    <CustomPropsFile Condition="'$(CustomPropsFile)'==''">msvc/user.props</CustomPropsFile>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile />
+    <Link />
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile />
+    <Link />
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile />
+    <Link />
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile />
+    <Link />
+  </ItemDefinitionGroup>
+  <Import Project="$(PyMsvcDir)sources.props" />
+  <ItemGroup>
+    <ClCompile Include="@(PyCoreSource)" />
+    <ClCompile Include="$(PyBaseDir)lib/utils/gchelper_generic.c" >
+      <PreprocessorDefinitions>MICROPY_GCREGS_SETJMP</PreprocessorDefinitions>
+    </ClCompile>
+    <ClCompile Include="$(PyBaseDir)mpy-cross\gccollect.c"/>
+    <ClCompile Include="$(PyBaseDir)mpy-cross\main.c"/>
+    <ClCompile Include="$(PyBaseDir)ports\windows\fmode.c" />
+  </ItemGroup>
+  <Import Project="$(PyMsvcDir)genhdr.targets" />
+  <Import Project="$(CustomPropsFile)" Condition="exists('$(CustomPropsFile)')" />
+  <Target Name="GenHeaders" BeforeTargets="BuildGenerateSources" DependsOnTargets="GenerateHeaders">
+  </Target>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/ports/bare-arm/Makefile b/ports/bare-arm/Makefile
index a515db80e0aa2..72d5f1a277269 100644
--- a/ports/bare-arm/Makefile
+++ b/ports/bare-arm/Makefile
@@ -3,10 +3,13 @@ include ../../py/mkenv.mk
 # qstr definitions (must come before including py.mk)
 QSTR_DEFS = qstrdefsport.h
 
+# MicroPython feature configurations
+MICROPY_ROM_TEXT_COMPRESSION ?= 1
+
 # include py core make definitions
 include $(TOP)/py/py.mk
 
-CROSS_COMPILE = arm-none-eabi-
+CROSS_COMPILE ?= arm-none-eabi-
 
 INC += -I.
 INC += -I$(TOP)
@@ -14,6 +17,7 @@ INC += -I$(BUILD)
 
 CFLAGS_CORTEX_M4 = -mthumb -mtune=cortex-m4 -mabi=aapcs-linux -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -fsingle-precision-constant -Wdouble-promotion
 CFLAGS = $(INC) -Wall -Werror -std=c99 -nostdlib $(CFLAGS_CORTEX_M4) $(COPT)
+CSUPEROPT = -Os # save some code space
 
 #Debugging/Optimization
 ifeq ($(DEBUG), 1)
diff --git a/ports/bare-arm/main.c b/ports/bare-arm/main.c
index b96fb47ace61a..df66c04effd7d 100644
--- a/ports/bare-arm/main.c
+++ b/ports/bare-arm/main.c
@@ -13,7 +13,7 @@ void do_str(const char *src, mp_parse_input_kind_t input_kind) {
         mp_lexer_t *lex = mp_lexer_new_from_str_len(MP_QSTR__lt_stdin_gt_, src, strlen(src), 0);
         qstr source_name = lex->source_name;
         mp_parse_tree_t parse_tree = mp_parse(lex, input_kind);
-        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, MP_EMIT_OPT_NONE, true);
+        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, true);
         mp_call_function_0(module_fun);
         nlr_pop();
     } else {
@@ -44,11 +44,15 @@ mp_obj_t mp_builtin_open(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs)
 MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
 
 void nlr_jump_fail(void *val) {
-    while (1);
+    while (1) {
+        ;
+    }
 }
 
 void NORETURN __fatal_error(const char *msg) {
-    while (1);
+    while (1) {
+        ;
+    }
 }
 
 #ifndef NDEBUG
@@ -71,26 +75,63 @@ int _fstat() {return 0;}
 int _isatty() {return 0;}
 */
 
-void *malloc(size_t n) {return NULL;}
-void *calloc(size_t nmemb, size_t size) {return NULL;}
-void *realloc(void *ptr, size_t size) {return NULL;}
-void free(void *p) {}
-int printf(const char *m, ...) {return 0;}
-void *memcpy(void *dest, const void *src, size_t n) {return NULL;}
-int memcmp(const void *s1, const void *s2, size_t n) {return 0;}
-void *memmove(void *dest, const void *src, size_t n) {return NULL;}
-void *memset(void *s, int c, size_t n) {return NULL;}
-int strcmp(const char *s1, const char* s2) {return 0;}
-int strncmp(const char *s1, const char* s2, size_t n) {return 0;}
-size_t strlen(const char *s) {return 0;}
-char *strcat(char *dest, const char *src) {return NULL;}
-char *strchr(const char *dest, int c) {return NULL;}
+void *malloc(size_t n) {
+    return NULL;
+}
+void *calloc(size_t nmemb, size_t size) {
+    return NULL;
+}
+void *realloc(void *ptr, size_t size) {
+    return NULL;
+}
+void free(void *p) {
+}
+int printf(const char *m, ...) {
+    return 0;
+}
+void *memcpy(void *dest, const void *src, size_t n) {
+    return NULL;
+}
+int memcmp(const void *s1, const void *s2, size_t n) {
+    return 0;
+}
+void *memmove(void *dest, const void *src, size_t n) {
+    return NULL;
+}
+void *memset(void *s, int c, size_t n) {
+    return NULL;
+}
+int strcmp(const char *s1, const char *s2) {
+    return 0;
+}
+int strncmp(const char *s1, const char *s2, size_t n) {
+    return 0;
+}
+size_t strlen(const char *s) {
+    return 0;
+}
+char *strcat(char *dest, const char *src) {
+    return NULL;
+}
+char *strchr(const char *dest, int c) {
+    return NULL;
+}
 #include <stdarg.h>
-int vprintf(const char *format, va_list ap) {return 0;}
-int vsnprintf(char *str,  size_t  size,  const  char  *format, va_list ap) {return 0;}
+int vprintf(const char *format, va_list ap) {
+    return 0;
+}
+int vsnprintf(char *str,  size_t size,  const char *format, va_list ap) {
+    return 0;
+}
 
 #undef putchar
-int putchar(int c) {return 0;}
-int puts(const char *s) {return 0;}
+int putchar(int c) {
+    return 0;
+}
+int puts(const char *s) {
+    return 0;
+}
 
-void _start(void) {main(0, NULL);}
+void _start(void) {
+    main(0, NULL);
+}
diff --git a/ports/bare-arm/mpconfigport.h b/ports/bare-arm/mpconfigport.h
index 395659a8bdece..4567676580324 100644
--- a/ports/bare-arm/mpconfigport.h
+++ b/ports/bare-arm/mpconfigport.h
@@ -43,13 +43,14 @@
 #define MICROPY_PY_STRUCT           (0)
 #define MICROPY_PY_SYS              (0)
 #define MICROPY_CPYTHON_COMPAT      (0)
+#define MICROPY_MODULE_GETATTR      (0)
 #define MICROPY_LONGINT_IMPL        (MICROPY_LONGINT_IMPL_NONE)
 #define MICROPY_FLOAT_IMPL          (MICROPY_FLOAT_IMPL_NONE)
 #define MICROPY_USE_INTERNAL_PRINTF (0)
 
 // type definitions for the specific machine
 
-#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void*)((mp_uint_t)(p) | 1))
+#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)((mp_uint_t)(p) | 1))
 
 #define UINT_FMT "%lu"
 #define INT_FMT "%ld"
diff --git a/ports/bare-arm/qstrdefsport.h b/ports/bare-arm/qstrdefsport.h
index 3ba897069bf73..00d3e2ae3c555 100644
--- a/ports/bare-arm/qstrdefsport.h
+++ b/ports/bare-arm/qstrdefsport.h
@@ -1 +1,2 @@
 // qstrs specific to this port
+// *FORMAT-OFF*
diff --git a/ports/cc3200/Makefile b/ports/cc3200/Makefile
index 81531b1084a2c..560fc8e96def5 100644
--- a/ports/cc3200/Makefile
+++ b/ports/cc3200/Makefile
@@ -33,6 +33,10 @@ FLASH_SIZE_LAUNCHXL = 1M
 ifeq ($(BTARGET), application)
 # qstr definitions (must come before including py.mk)
 QSTR_DEFS = qstrdefsport.h $(BUILD)/pins_qstr.h
+
+# MicroPython feature configurations
+MICROPY_ROM_TEXT_COMPRESSION ?= 1
+
 # include MicroPython make definitions
 include $(TOP)/py/py.mk
 include application.mk
diff --git a/ports/cc3200/application.mk b/ports/cc3200/application.mk
index 468fa134f9738..b216ca16dd873 100644
--- a/ports/cc3200/application.mk
+++ b/ports/cc3200/application.mk
@@ -73,13 +73,11 @@ APP_MISC_SRC_C = $(addprefix misc/,\
 	help.c \
 	mpirq.c \
 	mperror.c \
-	mpexception.c \
 	)
 
 APP_MODS_SRC_C = $(addprefix mods/,\
 	modmachine.c \
 	modnetwork.c \
-	modubinascii.c \
 	moduos.c \
 	modusocket.c \
 	modussl.c \
@@ -113,12 +111,12 @@ APP_CC3100_SRC_C = $(addprefix drivers/cc3100/src/,\
 APP_SL_SRC_C = $(addprefix simplelink/,\
 	oslib/osi_freertos.c \
 	cc_pal.c \
-	) 
+	)
 
 APP_TELNET_SRC_C = $(addprefix telnet/,\
 	telnet.c \
 	)
-	
+
 APP_UTIL_SRC_C = $(addprefix util/,\
 	cryptohash.c \
 	fifo.c \
@@ -126,18 +124,19 @@ APP_UTIL_SRC_C = $(addprefix util/,\
 	random.c \
 	socketfifo.c \
 	)
-	
+
 APP_UTIL_SRC_S = $(addprefix util/,\
+	cortex_m3_get_sp.s \
 	sleeprestore.s \
 	)
-	
+
 APP_MAIN_SRC_C = \
 	main.c \
 	mptask.c \
 	mpthreadport.c \
 	serverstask.c \
 	fatfs_port.c \
-	
+
 APP_LIB_SRC_C = $(addprefix lib/,\
 	oofatfs/ff.c \
 	oofatfs/ffunicode.c \
@@ -145,11 +144,12 @@ APP_LIB_SRC_C = $(addprefix lib/,\
 	mp-readline/readline.c \
 	netutils/netutils.c \
 	timeutils/timeutils.c \
+	utils/gchelper_native.c \
 	utils/pyexec.c \
 	utils/interrupt_char.c \
 	utils/sys_stdio_mphal.c \
 	)
-	
+
 APP_STM_SRC_C = $(addprefix ports/stm32/,\
 	bufhelper.c \
 	irq.c \
diff --git a/ports/cc3200/boards/make-pins.py b/ports/cc3200/boards/make-pins.py
index 30db4ac9ec75c..a204561cfbc32 100644
--- a/ports/cc3200/boards/make-pins.py
+++ b/ports/cc3200/boards/make-pins.py
@@ -8,20 +8,22 @@
 import csv
 
 
-SUPPORTED_AFS = { 'UART': ('TX', 'RX', 'RTS', 'CTS'),
-                  'SPI': ('CLK', 'MOSI', 'MISO', 'CS0'),
-                  #'I2S': ('CLK', 'FS', 'DAT0', 'DAT1'),
-                  'I2C': ('SDA', 'SCL'),
-                  'TIM': ('PWM'),
-                  'SD': ('CLK', 'CMD', 'DAT0'),
-                  'ADC': ('CH0', 'CH1', 'CH2', 'CH3')
-                }
+SUPPORTED_AFS = {
+    "UART": ("TX", "RX", "RTS", "CTS"),
+    "SPI": ("CLK", "MOSI", "MISO", "CS0"),
+    #'I2S': ('CLK', 'FS', 'DAT0', 'DAT1'),
+    "I2C": ("SDA", "SCL"),
+    "TIM": ("PWM"),
+    "SD": ("CLK", "CMD", "DAT0"),
+    "ADC": ("CH0", "CH1", "CH2", "CH3"),
+}
+
 
 def parse_port_pin(name_str):
     """Parses a string and returns a (port, gpio_bit) tuple."""
     if len(name_str) < 3:
         raise ValueError("Expecting pin name to be at least 3 characters")
-    if name_str[:2] != 'GP':
+    if name_str[:2] != "GP":
         raise ValueError("Expecting pin name to start with GP")
     if not name_str[2:].isdigit():
         raise ValueError("Expecting numeric GPIO number")
@@ -32,6 +34,7 @@ def parse_port_pin(name_str):
 
 class AF:
     """Holds the description of an alternate function"""
+
     def __init__(self, name, idx, fn, unit, type):
         self.name = name
         self.idx = idx
@@ -42,11 +45,16 @@ def __init__(self, name, idx, fn, unit, type):
         self.type = type
 
     def print(self):
-        print ('    AF({:16s}, {:4d}, {:8s}, {:4d}, {:8s}),    // {}'.format(self.name, self.idx, self.fn, self.unit, self.type, self.name))
+        print(
+            "    AF({:16s}, {:4d}, {:8s}, {:4d}, {:8s}),    // {}".format(
+                self.name, self.idx, self.fn, self.unit, self.type, self.name
+            )
+        )
 
 
 class Pin:
     """Holds the information associated with a pin."""
+
     def __init__(self, name, port, gpio_bit, pin_num):
         self.name = name
         self.port = port
@@ -59,25 +67,37 @@ def add_af(self, af):
         self.afs.append(af)
 
     def print(self):
-        print('// {}'.format(self.name))
+        print("// {}".format(self.name))
         if len(self.afs):
-            print('const pin_af_t pin_{}_af[] = {{'.format(self.name))
+            print("const pin_af_t pin_{}_af[] = {{".format(self.name))
             for af in self.afs:
                 af.print()
-            print('};')
-            print('pin_obj_t pin_{:4s} = PIN({:6s}, {:1d}, {:3d}, {:2d}, pin_{}_af, {});\n'.format(
-                   self.name, self.name, self.port, self.gpio_bit, self.pin_num, self.name, len(self.afs)))
+            print("};")
+            print(
+                "pin_obj_t pin_{:4s} = PIN({:6s}, {:1d}, {:3d}, {:2d}, pin_{}_af, {});\n".format(
+                    self.name,
+                    self.name,
+                    self.port,
+                    self.gpio_bit,
+                    self.pin_num,
+                    self.name,
+                    len(self.afs),
+                )
+            )
         else:
-            print('pin_obj_t pin_{:4s} = PIN({:6s}, {:1d}, {:3d}, {:2d}, NULL, 0);\n'.format(
-                   self.name, self.name, self.port, self.gpio_bit, self.pin_num))
+            print(
+                "pin_obj_t pin_{:4s} = PIN({:6s}, {:1d}, {:3d}, {:2d}, NULL, 0);\n".format(
+                    self.name, self.name, self.port, self.gpio_bit, self.pin_num
+                )
+            )
 
     def print_header(self, hdr_file):
-        hdr_file.write('extern pin_obj_t pin_{:s};\n'.format(self.name))
+        hdr_file.write("extern pin_obj_t pin_{:s};\n".format(self.name))
 
 
 class Pins:
     def __init__(self):
-        self.board_pins = []   # list of pin objects
+        self.board_pins = []  # list of pin objects
 
     def find_pin(self, port, gpio_bit):
         for pin in self.board_pins:
@@ -95,7 +115,7 @@ def find_pin_by_name(self, name):
                 return pin
 
     def parse_af_file(self, filename, pin_col, pinname_col, af_start_col):
-        with open(filename, 'r') as csvfile:
+        with open(filename, "r") as csvfile:
             rows = csv.reader(csvfile)
             for row in rows:
                 try:
@@ -103,16 +123,18 @@ def parse_af_file(self, filename, pin_col, pinname_col, af_start_col):
                 except:
                     continue
                 if not row[pin_col].isdigit():
-                    raise ValueError("Invalid pin number {:s} in row {:s}".format(row[pin_col]), row)
+                    raise ValueError(
+                        "Invalid pin number {:s} in row {:s}".format(row[pin_col]), row
+                    )
                 # Pin numbers must start from 0 when used with the TI API
-                pin_num = int(row[pin_col]) - 1;        
+                pin_num = int(row[pin_col]) - 1
                 pin = Pin(row[pinname_col], port_num, gpio_bit, pin_num)
                 self.board_pins.append(pin)
                 af_idx = 0
                 for af in row[af_start_col:]:
-                    af_splitted = af.split('_')
-                    fn_name = af_splitted[0].rstrip('0123456789')
-                    if  fn_name in SUPPORTED_AFS:
+                    af_splitted = af.split("_")
+                    fn_name = af_splitted[0].rstrip("0123456789")
+                    if fn_name in SUPPORTED_AFS:
                         type_name = af_splitted[1]
                         if type_name in SUPPORTED_AFS[fn_name]:
                             unit_idx = af_splitted[0][-1]
@@ -120,7 +142,7 @@ def parse_af_file(self, filename, pin_col, pinname_col, af_start_col):
                     af_idx += 1
 
     def parse_board_file(self, filename, cpu_pin_col):
-        with open(filename, 'r') as csvfile:
+        with open(filename, "r") as csvfile:
             rows = csv.reader(csvfile)
             for row in rows:
                 # Pin numbers must start from 0 when used with the TI API
@@ -132,29 +154,39 @@ def parse_board_file(self, filename, cpu_pin_col):
                     pin.board_pin = True
 
     def print_named(self, label, pins):
-        print('')
-        print('STATIC const mp_rom_map_elem_t pin_{:s}_pins_locals_dict_table[] = {{'.format(label))
+        print("")
+        print(
+            "STATIC const mp_rom_map_elem_t pin_{:s}_pins_locals_dict_table[] = {{".format(label)
+        )
         for pin in pins:
             if pin.board_pin:
-                print('    {{ MP_ROM_QSTR(MP_QSTR_{:6s}), MP_ROM_PTR(&pin_{:6s}) }},'.format(pin.name, pin.name))
-        print('};')
-        print('MP_DEFINE_CONST_DICT(pin_{:s}_pins_locals_dict, pin_{:s}_pins_locals_dict_table);'.format(label, label));
+                print(
+                    "    {{ MP_ROM_QSTR(MP_QSTR_{:6s}), MP_ROM_PTR(&pin_{:6s}) }},".format(
+                        pin.name, pin.name
+                    )
+                )
+        print("};")
+        print(
+            "MP_DEFINE_CONST_DICT(pin_{:s}_pins_locals_dict, pin_{:s}_pins_locals_dict_table);".format(
+                label, label
+            )
+        )
 
     def print(self):
         for pin in self.board_pins:
             if pin.board_pin:
                 pin.print()
-        self.print_named('board', self.board_pins)
-        print('')
+        self.print_named("board", self.board_pins)
+        print("")
 
     def print_header(self, hdr_filename):
-        with open(hdr_filename, 'wt') as hdr_file:
+        with open(hdr_filename, "wt") as hdr_file:
             for pin in self.board_pins:
                 if pin.board_pin:
                     pin.print_header(hdr_file)
 
     def print_qstr(self, qstr_filename):
-        with open(qstr_filename, 'wt') as qstr_file:
+        with open(qstr_filename, "wt") as qstr_file:
             pin_qstr_set = set([])
             af_qstr_set = set([])
             for pin in self.board_pins:
@@ -162,67 +194,69 @@ def print_qstr(self, qstr_filename):
                     pin_qstr_set |= set([pin.name])
                     for af in pin.afs:
                         af_qstr_set |= set([af.name])
-            print('// Board pins', file=qstr_file)
+            print("// Board pins", file=qstr_file)
             for qstr in sorted(pin_qstr_set):
-                print('Q({})'.format(qstr), file=qstr_file)
-            print('\n// Pin AFs', file=qstr_file)
+                print("Q({})".format(qstr), file=qstr_file)
+            print("\n// Pin AFs", file=qstr_file)
             for qstr in sorted(af_qstr_set):
-                print('Q({})'.format(qstr), file=qstr_file)
+                print("Q({})".format(qstr), file=qstr_file)
 
 
 def main():
     parser = argparse.ArgumentParser(
         prog="make-pins.py",
         usage="%(prog)s [options] [command]",
-        description="Generate board specific pin file"
+        description="Generate board specific pin file",
     )
     parser.add_argument(
-        "-a", "--af",
+        "-a",
+        "--af",
         dest="af_filename",
         help="Specifies the alternate function file for the chip",
-        default="cc3200_af.csv"
+        default="cc3200_af.csv",
     )
     parser.add_argument(
-        "-b", "--board",
-        dest="board_filename",
-        help="Specifies the board file",
+        "-b", "--board", dest="board_filename", help="Specifies the board file",
     )
     parser.add_argument(
-        "-p", "--prefix",
+        "-p",
+        "--prefix",
         dest="prefix_filename",
         help="Specifies beginning portion of generated pins file",
-        default="cc3200_prefix.c"
+        default="cc3200_prefix.c",
     )
     parser.add_argument(
-        "-q", "--qstr",
+        "-q",
+        "--qstr",
         dest="qstr_filename",
         help="Specifies name of generated qstr header file",
-        default="build/pins_qstr.h"
+        default="build/pins_qstr.h",
     )
     parser.add_argument(
-        "-r", "--hdr",
+        "-r",
+        "--hdr",
         dest="hdr_filename",
         help="Specifies name of generated pin header file",
-        default="build/pins.h"
+        default="build/pins.h",
     )
     args = parser.parse_args(sys.argv[1:])
 
     pins = Pins()
 
-    print('// This file was automatically generated by make-pins.py')
-    print('//')
+    print("// This file was automatically generated by make-pins.py")
+    print("//")
     if args.af_filename:
-        print('// --af {:s}'.format(args.af_filename))
+        print("// --af {:s}".format(args.af_filename))
         pins.parse_af_file(args.af_filename, 0, 1, 3)
 
     if args.board_filename:
-        print('// --board {:s}'.format(args.board_filename))
+        print("// --board {:s}".format(args.board_filename))
         pins.parse_board_file(args.board_filename, 1)
 
     if args.prefix_filename:
-        print('// --prefix {:s}'.format(args.prefix_filename))
-        print('')
-        with open(args.prefix_filename, 'r') as prefix_file:
+        print("// --prefix {:s}".format(args.prefix_filename))
+        print("")
+        with open(args.prefix_filename, "r") as prefix_file:
             print(prefix_file.read())
     pins.print()
     pins.print_qstr(args.qstr_filename)
diff --git a/ports/cc3200/fatfs_port.c b/ports/cc3200/fatfs_port.c
index 6cfc17c3d84dd..993684d8c693c 100644
--- a/ports/cc3200/fatfs_port.c
+++ b/ports/cc3200/fatfs_port.c
@@ -68,7 +68,7 @@ DWORD get_fattime(void) {
     timeutils_struct_time_t tm;
     timeutils_seconds_since_2000_to_struct_time(pyb_rtc_get_seconds(), &tm);
 
-    return ((tm.tm_year - 1980) << 25) | ((tm.tm_mon) << 21)  |
-            ((tm.tm_mday) << 16)       | ((tm.tm_hour) << 11) |
-            ((tm.tm_min) << 5)         | (tm.tm_sec >> 1);
+    return ((tm.tm_year - 1980) << 25) | ((tm.tm_mon) << 21) |
+           ((tm.tm_mday) << 16) | ((tm.tm_hour) << 11) |
+           ((tm.tm_min) << 5) | (tm.tm_sec >> 1);
 }
diff --git a/ports/cc3200/hal/cc3200_hal.c b/ports/cc3200/hal/cc3200_hal.c
index 526874f33b8f9..bdb7d33d4a242 100644
--- a/ports/cc3200/hal/cc3200_hal.c
+++ b/ports/cc3200/hal/cc3200_hal.c
@@ -45,7 +45,6 @@
 #include "systick.h"
 #include "prcm.h"
 #include "pin.h"
-#include "mpexception.h"
 #include "telnet.h"
 #include "pybuart.h"
 #include "utils.h"
diff --git a/ports/cc3200/hal/cc3200_hal.h b/ports/cc3200/hal/cc3200_hal.h
index 71e245eeb1c5d..3d0d632d519b4 100644
--- a/ports/cc3200/hal/cc3200_hal.h
+++ b/ports/cc3200/hal/cc3200_hal.h
@@ -64,5 +64,6 @@ extern void HAL_SystemDeInit (void);
 extern void HAL_IncrementTick(void);
 extern void mp_hal_set_interrupt_char (int c);
 
+#define mp_hal_stdio_poll(poll_flags) (0) // not implemented
 #define mp_hal_delay_us(usec) UtilsDelay(UTILS_DELAY_US_TO_COUNT(usec))
 #define mp_hal_ticks_cpu() (SysTickPeriodGet() - SysTickValueGet())
diff --git a/ports/cc3200/main.c b/ports/cc3200/main.c
index e2299e14604da..b9f67194b6fc0 100644
--- a/ports/cc3200/main.c
+++ b/ports/cc3200/main.c
@@ -58,7 +58,7 @@ static StackType_t uxIdleTaskStack[configMINIMAL_STACK_SIZE] __attribute__ ((sec
  DECLARE PUBLIC DATA
  ******************************************************************************/
 #ifdef DEBUG
-OsiTaskHandle   mpTaskHandle;
+OsiTaskHandle mpTaskHandle;
 #endif
 
 // This is the FreeRTOS heap, defined here so we can put it in a special segment
@@ -78,30 +78,31 @@ int main (void) {
     // Initialize the clocks and the interrupt system
     HAL_SystemInit();
 
-#if MICROPY_HW_ANTENNA_DIVERSITY
+    #if MICROPY_HW_ANTENNA_DIVERSITY
     // configure the antenna selection pins
     antenna_init0();
-#endif
+    #endif
 
     // Init the watchdog
     pybwdt_init0();
 
-#ifndef DEBUG
+    #ifndef DEBUG
     OsiTaskHandle mpTaskHandle;
-#endif
+    #endif
     mpTaskHandle = xTaskCreateStatic(TASK_MicroPython, "MicroPy",
         MICROPY_TASK_STACK_LEN, NULL, MICROPY_TASK_PRIORITY, mpTaskStack, &mpTaskTCB);
     ASSERT(mpTaskHandle != NULL);
 
     osi_start();
 
-    for ( ; ; );
+    for ( ; ;) {;
+    }
 }
 
 // We need this when configSUPPORT_STATIC_ALLOCATION is enabled
-void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer,
-                                    StackType_t **ppxIdleTaskStackBuffer,
-                                    uint32_t *pulIdleTaskStackSize ) {
+void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer,
+    StackType_t **ppxIdleTaskStackBuffer,
+    uint32_t *pulIdleTaskStackSize) {
     *ppxIdleTaskTCBBuffer = &xIdleTaskTCB;
     *ppxIdleTaskStackBuffer = uxIdleTaskStack;
     *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
diff --git a/ports/cc3200/misc/mpirq.c b/ports/cc3200/misc/mpirq.c
index d54e7465b15cf..a4144def5a724 100644
--- a/ports/cc3200/misc/mpirq.c
+++ b/ports/cc3200/misc/mpirq.c
@@ -33,7 +33,6 @@
 #include "inc/hw_types.h"
 #include "interrupt.h"
 #include "pybsleep.h"
-#include "mpexception.h"
 #include "mperror.h"
 #include "mpirq.h"
 
@@ -112,7 +111,7 @@ void mp_irq_remove (const mp_obj_t parent) {
 
 uint mp_irq_translate_priority (uint priority) {
     if (priority < 1 || priority > MP_ARRAY_SIZE(mp_irq_priorities)) {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
     return mp_irq_priorities[priority - 1];
 }
diff --git a/ports/cc3200/mods/modmachine.c b/ports/cc3200/mods/modmachine.c
index 9e49e23436c21..f70b399c07ebd 100644
--- a/ports/cc3200/mods/modmachine.c
+++ b/ports/cc3200/mods/modmachine.c
@@ -47,7 +47,6 @@
 #include "FreeRTOS.h"
 #include "portable.h"
 #include "task.h"
-#include "mpexception.h"
 #include "random.h"
 #include "pybadc.h"
 #include "pybi2c.h"
@@ -125,7 +124,7 @@ STATIC mp_obj_t machine_main(mp_obj_t main) {
     if (mp_obj_is_str(main)) {
         MP_STATE_PORT(machine_config_main) = main;
     } else {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
     return mp_const_none;
 }
diff --git a/ports/cc3200/mods/modnetwork.c b/ports/cc3200/mods/modnetwork.c
index 37dffe731f11d..e8a70e0a84dad 100644
--- a/ports/cc3200/mods/modnetwork.c
+++ b/ports/cc3200/mods/modnetwork.c
@@ -29,7 +29,6 @@
 #include "py/mperrno.h"
 #include "py/mphal.h"
 #include "modnetwork.h"
-#include "mpexception.h"
 #include "serverstask.h"
 #include "simplelink.h"
 
diff --git a/ports/cc3200/mods/moduhashlib.c b/ports/cc3200/mods/moduhashlib.c
index 96f51492734f5..fc11569b7f988 100644
--- a/ports/cc3200/mods/moduhashlib.c
+++ b/ports/cc3200/mods/moduhashlib.c
@@ -41,7 +41,6 @@
 #include "prcm.h"
 #include "shamd5.h"
 #include "cryptohash.h"
-#include "mpexception.h"
 
 
 /******************************************************************************
diff --git a/ports/cc3200/mods/moduos.c b/ports/cc3200/mods/moduos.c
index 4c9d4a87a78ae..53521fe66cfc9 100644
--- a/ports/cc3200/mods/moduos.c
+++ b/ports/cc3200/mods/moduos.c
@@ -40,7 +40,6 @@
 #include "extmod/vfs.h"
 #include "extmod/vfs_fat.h"
 #include "random.h"
-#include "mpexception.h"
 #include "version.h"
 #include "pybsd.h"
 #include "pybuart.h"
diff --git a/ports/cc3200/mods/modusocket.c b/ports/cc3200/mods/modusocket.c
index 286b1fb02bfb2..5dac0a0102387 100644
--- a/ports/cc3200/mods/modusocket.c
+++ b/ports/cc3200/mods/modusocket.c
@@ -38,7 +38,6 @@
 #include "lib/netutils/netutils.h"
 #include "modnetwork.h"
 #include "modusocket.h"
-#include "mpexception.h"
 
 /******************************************************************************/
 // The following set of macros and functions provide a glue between the CC3100
diff --git a/ports/cc3200/mods/modussl.c b/ports/cc3200/mods/modussl.c
index 9a9dc95a453da..09a1a3185700c 100644
--- a/ports/cc3200/mods/modussl.c
+++ b/ports/cc3200/mods/modussl.c
@@ -33,7 +33,6 @@
 #include "py/runtime.h"
 #include "modnetwork.h"
 #include "modusocket.h"
-#include "mpexception.h"
 
 /******************************************************************************
  DEFINE CONSTANTS
@@ -133,7 +132,7 @@ STATIC mp_obj_t mod_ssl_wrap_socket(size_t n_args, const mp_obj_t *pos_args, mp_
     mp_raise_OSError(_errno);
 
 arg_error:
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(mod_ssl_wrap_socket_obj, 0, mod_ssl_wrap_socket);
 
diff --git a/ports/cc3200/mods/modutime.c b/ports/cc3200/mods/modutime.c
index 13750f96b5c85..a729d62f9cbb2 100644
--- a/ports/cc3200/mods/modutime.c
+++ b/ports/cc3200/mods/modutime.c
@@ -42,7 +42,6 @@
 #include "prcm.h"
 #include "systick.h"
 #include "pybrtc.h"
-#include "mpexception.h"
 #include "utils.h"
 
 /// \module time - time related functions
@@ -109,7 +108,7 @@ STATIC mp_obj_t time_mktime(mp_obj_t tuple) {
 
     // localtime generates a tuple of len 8. CPython uses 9, so we accept both.
     if (len < 8 || len > 9) {
-        mp_raise_TypeError(mpexception_num_type_invalid_arguments);
+        mp_raise_TypeError(MP_ERROR_TEXT("invalid argument(s) num/type"));
     }
 
     return mp_obj_new_int_from_uint(timeutils_mktime(mp_obj_get_int(elem[0]), mp_obj_get_int(elem[1]), mp_obj_get_int(elem[2]),
diff --git a/ports/cc3200/mods/modwlan.c b/ports/cc3200/mods/modwlan.c
index d6f7638c70000..7aa8f0e2c4494 100644
--- a/ports/cc3200/mods/modwlan.c
+++ b/ports/cc3200/mods/modwlan.c
@@ -45,7 +45,6 @@
 #if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
 #include "serverstask.h"
 #endif
-#include "mpexception.h"
 #include "mpirq.h"
 #include "pybsleep.h"
 #include "antenna.h"
@@ -589,7 +588,7 @@ STATIC void wlan_reset (void) {
 
 STATIC void wlan_validate_mode (uint mode) {
     if (mode != ROLE_STA && mode != ROLE_AP) {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
 }
 
@@ -600,7 +599,7 @@ STATIC void wlan_set_mode (uint mode) {
 
 STATIC void wlan_validate_ssid_len (uint32_t len) {
     if (len > MODWLAN_SSID_LEN_MAX) {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
 }
 
@@ -633,7 +632,7 @@ STATIC void wlan_validate_security (uint8_t auth, const char *key, uint8_t len)
     return;
 
 invalid_args:
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 
 STATIC void wlan_set_security (uint8_t auth, const char *key, uint8_t len) {
@@ -656,7 +655,7 @@ STATIC void wlan_set_security (uint8_t auth, const char *key, uint8_t len) {
 
 STATIC void wlan_validate_channel (uint8_t channel) {
     if (channel < 1 || channel > 11) {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
 }
 
@@ -668,7 +667,7 @@ STATIC void wlan_set_channel (uint8_t channel) {
 #if MICROPY_HW_ANTENNA_DIVERSITY
 STATIC void wlan_validate_antenna (uint8_t antenna) {
     if (antenna != ANTENNA_TYPE_INTERNAL && antenna != ANTENNA_TYPE_EXTERNAL) {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
 }
 
@@ -964,7 +963,7 @@ STATIC mp_obj_t wlan_connect(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
     if (status == MODWLAN_ERROR_TIMEOUT) {
         mp_raise_OSError(MP_ETIMEDOUT);
     } else if (status == MODWLAN_ERROR_INVALID_PARAMS) {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
     return mp_const_none;
 }
@@ -1040,7 +1039,7 @@ STATIC mp_obj_t wlan_ifconfig(size_t n_args, const mp_obj_t *pos_args, mp_map_t
             // check for the correct string
             const char *mode = mp_obj_str_get_str(args[1].u_obj);
             if (strcmp("dhcp", mode)) {
-                mp_raise_ValueError(mpexception_value_invalid_arguments);
+                mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
             }
 
             // only if we are not in AP mode
@@ -1154,7 +1153,7 @@ STATIC mp_obj_t wlan_mac(size_t n_args, const mp_obj_t *args) {
         mp_buffer_info_t bufinfo;
         mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ);
         if (bufinfo.len != 6) {
-            mp_raise_ValueError(mpexception_value_invalid_arguments);
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
         }
         memcpy(self->mac, bufinfo.buf, SL_MAC_ADDR_LEN);
         sl_NetCfgSet(SL_MAC_ADDRESS_SET, 1, SL_MAC_ADDR_LEN, (_u8 *)self->mac);
@@ -1190,7 +1189,7 @@ STATIC mp_obj_t wlan_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_a
     return _irq;
 
 invalid_args:
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(wlan_irq_obj, 1, wlan_irq);
 
@@ -1219,7 +1218,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_KW(wlan_irq_obj, 1, wlan_irq);
 //
 //        // the call to sl_NetAppSet corrupts the input string URN=args[1], so we copy into a local buffer
 //        if (len > MAX_DEVICE_URN_LEN) {
-//            mp_raise_ValueError(mpexception_value_invalid_arguments);
+//            mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 //        }
 //        strcpy(urn, p);
 //
diff --git a/ports/cc3200/mods/pybadc.c b/ports/cc3200/mods/pybadc.c
index c73b8c149aad5..fbdd393cd2ecc 100644
--- a/ports/cc3200/mods/pybadc.c
+++ b/ports/cc3200/mods/pybadc.c
@@ -47,7 +47,6 @@
 #include "pybpin.h"
 #include "pybsleep.h"
 #include "pins.h"
-#include "mpexception.h"
 
 
 /******************************************************************************
@@ -153,7 +152,7 @@ STATIC mp_obj_t adc_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_
 
     // check the number of bits
     if (args[1].u_int != 12) {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
 
     // setup the object
@@ -172,7 +171,7 @@ STATIC mp_obj_t adc_init(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_a
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), &pyb_adc_init_args[1], args);
     // check the number of bits
     if (args[0].u_int != 12) {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
     pyb_adc_init(pos_args[0]);
     return mp_const_none;
@@ -205,11 +204,11 @@ STATIC mp_obj_t adc_channel(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
     if (args[0].u_obj != MP_OBJ_NULL) {
         ch_id = mp_obj_get_int(args[0].u_obj);
         if (ch_id >= PYB_ADC_NUM_CHANNELS) {
-            mp_raise_ValueError(mpexception_value_invalid_arguments);
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
         } else if (args[1].u_obj != mp_const_none) {
             uint pin_ch_id = pin_find_peripheral_type (args[1].u_obj, PIN_FN_ADC, 0);
             if (ch_id != pin_ch_id) {
-                mp_raise_ValueError(mpexception_value_invalid_arguments);
+                mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
             }
         }
     } else {
diff --git a/ports/cc3200/mods/pybflash.c b/ports/cc3200/mods/pybflash.c
index 51f4cb5172784..9d534608becce 100644
--- a/ports/cc3200/mods/pybflash.c
+++ b/ports/cc3200/mods/pybflash.c
@@ -24,9 +24,6 @@
  * THE SOFTWARE.
  */
 
-//#include <stdint.h>
-//#include <string.h>
-
 #include "py/runtime.h"
 #include "lib/oofatfs/ff.h"
 #include "lib/oofatfs/diskio.h"
@@ -69,11 +66,11 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_flash_writeblocks_obj, pyb_flash_writeblock
 STATIC mp_obj_t pyb_flash_ioctl(mp_obj_t self, mp_obj_t cmd_in, mp_obj_t arg_in) {
     mp_int_t cmd = mp_obj_get_int(cmd_in);
     switch (cmd) {
-        case BP_IOCTL_INIT: return MP_OBJ_NEW_SMALL_INT(sflash_disk_init() != RES_OK);
-        case BP_IOCTL_DEINIT: sflash_disk_flush(); return MP_OBJ_NEW_SMALL_INT(0);
-        case BP_IOCTL_SYNC: sflash_disk_flush(); return MP_OBJ_NEW_SMALL_INT(0);
-        case BP_IOCTL_SEC_COUNT: return MP_OBJ_NEW_SMALL_INT(SFLASH_SECTOR_COUNT);
-        case BP_IOCTL_SEC_SIZE: return MP_OBJ_NEW_SMALL_INT(SFLASH_SECTOR_SIZE);
+        case MP_BLOCKDEV_IOCTL_INIT: return MP_OBJ_NEW_SMALL_INT(sflash_disk_init() != RES_OK);
+        case MP_BLOCKDEV_IOCTL_DEINIT: sflash_disk_flush(); return MP_OBJ_NEW_SMALL_INT(0);
+        case MP_BLOCKDEV_IOCTL_SYNC: sflash_disk_flush(); return MP_OBJ_NEW_SMALL_INT(0);
+        case MP_BLOCKDEV_IOCTL_BLOCK_COUNT: return MP_OBJ_NEW_SMALL_INT(SFLASH_SECTOR_COUNT);
+        case MP_BLOCKDEV_IOCTL_BLOCK_SIZE: return MP_OBJ_NEW_SMALL_INT(SFLASH_SECTOR_SIZE);
         default: return mp_const_none;
     }
 }
@@ -96,14 +93,14 @@ const mp_obj_type_t pyb_flash_type = {
 
 void pyb_flash_init_vfs(fs_user_mount_t *vfs) {
     vfs->base.type = &mp_fat_vfs_type;
-    vfs->flags |= FSUSER_NATIVE | FSUSER_HAVE_IOCTL;
+    vfs->blockdev.flags |= MP_BLOCKDEV_FLAG_NATIVE | MP_BLOCKDEV_FLAG_HAVE_IOCTL;
     vfs->fatfs.drv = vfs;
-    vfs->readblocks[0] = (mp_obj_t)&pyb_flash_readblocks_obj;
-    vfs->readblocks[1] = (mp_obj_t)&pyb_flash_obj;
-    vfs->readblocks[2] = (mp_obj_t)sflash_disk_read; // native version
-    vfs->writeblocks[0] = (mp_obj_t)&pyb_flash_writeblocks_obj;
-    vfs->writeblocks[1] = (mp_obj_t)&pyb_flash_obj;
-    vfs->writeblocks[2] = (mp_obj_t)sflash_disk_write; // native version
-    vfs->u.ioctl[0] = (mp_obj_t)&pyb_flash_ioctl_obj;
-    vfs->u.ioctl[1] = (mp_obj_t)&pyb_flash_obj;
+    vfs->blockdev.readblocks[0] = (mp_obj_t)&pyb_flash_readblocks_obj;
+    vfs->blockdev.readblocks[1] = (mp_obj_t)&pyb_flash_obj;
+    vfs->blockdev.readblocks[2] = (mp_obj_t)sflash_disk_read; // native version
+    vfs->blockdev.writeblocks[0] = (mp_obj_t)&pyb_flash_writeblocks_obj;
+    vfs->blockdev.writeblocks[1] = (mp_obj_t)&pyb_flash_obj;
+    vfs->blockdev.writeblocks[2] = (mp_obj_t)sflash_disk_write; // native version
+    vfs->blockdev.u.ioctl[0] = (mp_obj_t)&pyb_flash_ioctl_obj;
+    vfs->blockdev.u.ioctl[1] = (mp_obj_t)&pyb_flash_obj;
 }
diff --git a/ports/cc3200/mods/pybi2c.c b/ports/cc3200/mods/pybi2c.c
index d08627fa4986e..5310176091a96 100644
--- a/ports/cc3200/mods/pybi2c.c
+++ b/ports/cc3200/mods/pybi2c.c
@@ -41,7 +41,6 @@
 #include "prcm.h"
 #include "i2c.h"
 #include "pybi2c.h"
-#include "mpexception.h"
 #include "pybsleep.h"
 #include "utils.h"
 #include "pybpin.h"
diff --git a/ports/cc3200/mods/pybpin.c b/ports/cc3200/mods/pybpin.c
index 3872f70c5f6b2..fd2f032e8d7ce 100644
--- a/ports/cc3200/mods/pybpin.c
+++ b/ports/cc3200/mods/pybpin.c
@@ -44,7 +44,6 @@
 #include "mpirq.h"
 #include "pins.h"
 #include "pybsleep.h"
-#include "mpexception.h"
 #include "mperror.h"
 
 
@@ -142,7 +141,7 @@ pin_obj_t *pin_find(mp_obj_t user_obj) {
         return pin_obj;
     }
 
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 
 void pin_config (pin_obj_t *self, int af, uint mode, uint pull, int value, uint strength) {
@@ -182,7 +181,7 @@ uint8_t pin_find_peripheral_unit (const mp_obj_t pin, uint8_t fn, uint8_t type)
             return pin_o->af_list[i].unit;
         }
     }
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 
 uint8_t pin_find_peripheral_type (const mp_obj_t pin, uint8_t fn, uint8_t unit) {
@@ -192,13 +191,13 @@ uint8_t pin_find_peripheral_type (const mp_obj_t pin, uint8_t fn, uint8_t unit)
             return pin_o->af_list[i].type;
         }
     }
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 
 int8_t pin_find_af_index (const pin_obj_t* pin, uint8_t fn, uint8_t unit, uint8_t type) {
     int8_t af = pin_obj_find_af(pin, fn, unit, type);
     if (af < 0) {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
     return af;
 }
@@ -423,18 +422,18 @@ STATIC void pin_extint_register(pin_obj_t *self, uint32_t intmode, uint32_t prio
 STATIC void pin_validate_mode (uint mode) {
     if (mode != GPIO_DIR_MODE_IN && mode != GPIO_DIR_MODE_OUT && mode != PIN_TYPE_OD &&
         mode != GPIO_DIR_MODE_ALT && mode != GPIO_DIR_MODE_ALT_OD) {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
 }
 STATIC void pin_validate_pull (uint pull) {
     if (pull != PIN_TYPE_STD && pull != PIN_TYPE_STD_PU && pull != PIN_TYPE_STD_PD) {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
 }
 
 STATIC void pin_validate_drive(uint strength) {
     if (strength != PIN_STRENGTH_2MA && strength != PIN_STRENGTH_4MA && strength != PIN_STRENGTH_6MA) {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
 }
 
@@ -447,7 +446,7 @@ STATIC void pin_validate_af(const pin_obj_t* pin, int8_t idx, uint8_t *fn, uint8
             return;
         }
     }
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 
 STATIC uint8_t pin_get_value (const pin_obj_t* self) {
@@ -588,7 +587,7 @@ STATIC mp_obj_t pin_obj_init_helper(pin_obj_t *self, size_t n_args, const mp_obj
     return mp_const_none;
 
 invalid_args:
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 
 STATIC void pin_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
@@ -895,7 +894,7 @@ STATIC mp_obj_t pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_ar
     return _irq;
 
 invalid_args:
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pin_irq_obj, 1, pin_irq);
 
diff --git a/ports/cc3200/mods/pybrtc.c b/ports/cc3200/mods/pybrtc.c
index a8e001efb492e..f0704eecdaa92 100644
--- a/ports/cc3200/mods/pybrtc.c
+++ b/ports/cc3200/mods/pybrtc.c
@@ -41,7 +41,6 @@
 #include "simplelink.h"
 #include "modnetwork.h"
 #include "modwlan.h"
-#include "mpexception.h"
 
 /// \moduleref pyb
 /// \class RTC - real time clock
@@ -201,7 +200,7 @@ STATIC uint pyb_rtc_datetime_s_us(const mp_obj_t datetime, uint32_t *seconds) {
 
     // verify the tuple
     if (len < 3 || len > 8) {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
 
     tm.tm_year = mp_obj_get_int(items[0]);
@@ -370,7 +369,7 @@ STATIC mp_obj_t pyb_rtc_alarm(size_t n_args, const mp_obj_t *pos_args, mp_map_t
     if (mp_obj_is_type(args[1].u_obj, &mp_type_tuple)) { // datetime tuple given
         // repeat cannot be used with a datetime tuple
         if (repeat) {
-            mp_raise_ValueError(mpexception_value_invalid_arguments);
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
         }
         f_mseconds = pyb_rtc_datetime_s_us (args[1].u_obj, &f_seconds) / 1000;
     } else { // then it must be an integer
@@ -452,7 +451,7 @@ STATIC mp_obj_t pyb_rtc_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
     return _irq;
 
 invalid_args:
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_rtc_irq_obj, 1, pyb_rtc_irq);
 
diff --git a/ports/cc3200/mods/pybsd.c b/ports/cc3200/mods/pybsd.c
index c47d4e94516b4..817127634d898 100644
--- a/ports/cc3200/mods/pybsd.c
+++ b/ports/cc3200/mods/pybsd.c
@@ -42,7 +42,6 @@
 #include "sdhost.h"
 #include "sd_diskio.h"
 #include "pybsd.h"
-#include "mpexception.h"
 #include "pybsleep.h"
 #include "pybpin.h"
 #include "pins.h"
@@ -184,16 +183,16 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_sd_writeblocks_obj, pyb_sd_writeblocks);
 STATIC mp_obj_t pyb_sd_ioctl(mp_obj_t self, mp_obj_t cmd_in, mp_obj_t arg_in) {
     mp_int_t cmd = mp_obj_get_int(cmd_in);
     switch (cmd) {
-        case BP_IOCTL_INIT:
-        case BP_IOCTL_DEINIT:
-        case BP_IOCTL_SYNC:
+        case MP_BLOCKDEV_IOCTL_INIT:
+        case MP_BLOCKDEV_IOCTL_DEINIT:
+        case MP_BLOCKDEV_IOCTL_SYNC:
             // nothing to do
             return MP_OBJ_NEW_SMALL_INT(0); // success
 
-        case BP_IOCTL_SEC_COUNT:
+        case MP_BLOCKDEV_IOCTL_BLOCK_COUNT:
             return MP_OBJ_NEW_SMALL_INT(sd_disk_info.ulNofBlock * (sd_disk_info.ulBlockSize / 512));
 
-        case BP_IOCTL_SEC_SIZE:
+        case MP_BLOCKDEV_IOCTL_BLOCK_SIZE:
             return MP_OBJ_NEW_SMALL_INT(SD_SECTOR_SIZE);
 
         default: // unknown command
diff --git a/ports/cc3200/mods/pybsleep.c b/ports/cc3200/mods/pybsleep.c
index b5990e9267c0c..da2eeff80fa24 100644
--- a/ports/cc3200/mods/pybsleep.c
+++ b/ports/cc3200/mods/pybsleep.c
@@ -49,7 +49,6 @@
 #include "modwlan.h"
 #include "osi.h"
 #include "debug.h"
-#include "mpexception.h"
 #include "mperror.h"
 #include "sleeprestore.h"
 #include "serverstask.h"
@@ -477,7 +476,7 @@ void pyb_sleep_suspend_exit (void) {
     MAP_IntPendSet(INT_PRCM);
 
     // force an exception to go back to the point where suspend mode was entered
-    nlr_raise(mp_obj_new_exception(&mp_type_SystemExit));
+    mp_raise_type(&mp_type_SystemExit);
 }
 
 STATIC void PRCMInterruptHandler (void) {
diff --git a/ports/cc3200/mods/pybspi.c b/ports/cc3200/mods/pybspi.c
index 27591e4f4c6b9..61b1a6bd11eeb 100644
--- a/ports/cc3200/mods/pybspi.c
+++ b/ports/cc3200/mods/pybspi.c
@@ -40,7 +40,6 @@
 #include "prcm.h"
 #include "spi.h"
 #include "pybspi.h"
-#include "mpexception.h"
 #include "pybsleep.h"
 #include "pybpin.h"
 #include "pins.h"
@@ -213,7 +212,7 @@ STATIC mp_obj_t pyb_spi_init_helper(pyb_spi_obj_t *self, const mp_arg_val_t *arg
     return mp_const_none;
 
 invalid_args:
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 
 static const mp_arg_t pyb_spi_init_args[] = {
@@ -351,7 +350,7 @@ STATIC mp_obj_t pyb_spi_write_readinto (mp_obj_t self, mp_obj_t writebuf, mp_obj
         // get the read buffer
         mp_get_buffer_raise(readbuf, &bufinfo_read, MP_BUFFER_WRITE);
         if (bufinfo_read.len != bufinfo_write.len) {
-            mp_raise_ValueError(mpexception_value_invalid_arguments);
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
         }
     }
 
diff --git a/ports/cc3200/mods/pybtimer.c b/ports/cc3200/mods/pybtimer.c
index ea795b848098e..b5cf594d74e82 100644
--- a/ports/cc3200/mods/pybtimer.c
+++ b/ports/cc3200/mods/pybtimer.c
@@ -47,7 +47,6 @@
 #include "pins.h"
 #include "mpirq.h"
 #include "pybsleep.h"
-#include "mpexception.h"
 
 
 /// \moduleref pyb
@@ -221,7 +220,7 @@ STATIC uint32_t compute_prescaler_period_and_match_value(pyb_timer_channel_obj_t
     return prescaler;
 
 error:
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 
 STATIC void timer_init (pyb_timer_obj_t *tim) {
@@ -317,7 +316,7 @@ STATIC mp_obj_t pyb_timer_init_helper(pyb_timer_obj_t *tim, size_t n_args, const
     return mp_const_none;
 
 error:
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 
 STATIC mp_obj_t pyb_timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
@@ -438,7 +437,7 @@ STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *pos_args, mp_ma
     return ch;
 
 error:
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_timer_channel_obj, 2, pyb_timer_channel);
 
@@ -558,7 +557,7 @@ STATIC mp_obj_t pyb_timer_channel_freq(size_t n_args, const mp_obj_t *args) {
         // set
         int32_t _frequency = mp_obj_get_int(args[1]);
         if (_frequency <= 0) {
-            mp_raise_ValueError(mpexception_value_invalid_arguments);
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
         }
         ch->frequency = _frequency;
         ch->period = 1000000 / _frequency;
@@ -577,7 +576,7 @@ STATIC mp_obj_t pyb_timer_channel_period(size_t n_args, const mp_obj_t *args) {
         // set
         int32_t _period = mp_obj_get_int(args[1]);
         if (_period <= 0) {
-            mp_raise_ValueError(mpexception_value_invalid_arguments);
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
         }
         ch->period = _period;
         ch->frequency = 1000000 / _period;
@@ -710,7 +709,7 @@ STATIC mp_obj_t pyb_timer_channel_irq(size_t n_args, const mp_obj_t *pos_args, m
     return _irq;
 
 invalid_args:
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_timer_channel_irq_obj, 1, pyb_timer_channel_irq);
 
diff --git a/ports/cc3200/mods/pybuart.c b/ports/cc3200/mods/pybuart.c
index 35c0de9f958bd..98adf1c39816f 100644
--- a/ports/cc3200/mods/pybuart.c
+++ b/ports/cc3200/mods/pybuart.c
@@ -45,7 +45,6 @@
 #include "pybuart.h"
 #include "mpirq.h"
 #include "pybsleep.h"
-#include "mpexception.h"
 #include "osi.h"
 #include "utils.h"
 #include "pin.h"
@@ -431,7 +430,7 @@ STATIC mp_obj_t pyb_uart_init_helper(pyb_uart_obj_t *self, const mp_arg_val_t *a
     return mp_const_none;
 
 error:
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 
 STATIC const mp_arg_t pyb_uart_init_args[] = {
@@ -555,7 +554,7 @@ STATIC mp_obj_t pyb_uart_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
     return uart_irq_new (self, trigger, priority, args[2].u_obj);
 
 invalid_args:
-    mp_raise_ValueError(mpexception_value_invalid_arguments);
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_uart_irq_obj, 1, pyb_uart_irq);
 
diff --git a/ports/cc3200/mods/pybwdt.c b/ports/cc3200/mods/pybwdt.c
index 4a9fafc4a9945..8db096d6b5fcb 100644
--- a/ports/cc3200/mods/pybwdt.c
+++ b/ports/cc3200/mods/pybwdt.c
@@ -40,7 +40,6 @@
 #include "prcm.h"
 #include "utils.h"
 #include "pybwdt.h"
-#include "mpexception.h"
 #include "mperror.h"
 
 
@@ -105,7 +104,7 @@ STATIC mp_obj_t pyb_wdt_make_new(const mp_obj_type_t *type, size_t n_args, size_
     }
     uint timeout_ms = args[1].u_int;
     if (timeout_ms < PYBWDT_MIN_TIMEOUT_MS) {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
     if (pyb_wdt_obj.running) {
         mp_raise_OSError(MP_EPERM);
diff --git a/ports/cc3200/mpconfigport.h b/ports/cc3200/mpconfigport.h
index e7894dd023c84..6fdb278d864b1 100644
--- a/ports/cc3200/mpconfigport.h
+++ b/ports/cc3200/mpconfigport.h
@@ -110,7 +110,7 @@
 #define MICROPY_PY_UERRNO_ERRORCODE                 (0)
 #define MICROPY_PY_THREAD                           (1)
 #define MICROPY_PY_THREAD_GIL                       (1)
-#define MICROPY_PY_UBINASCII                        (0)
+#define MICROPY_PY_UBINASCII                        (1)
 #define MICROPY_PY_UCTYPES                          (0)
 #define MICROPY_PY_UZLIB                            (0)
 #define MICROPY_PY_UJSON                            (1)
@@ -169,19 +169,6 @@ extern const struct _mp_obj_module_t mp_module_ussl;
     { MP_ROM_QSTR(MP_QSTR_ubinascii),   MP_ROM_PTR(&mp_module_ubinascii) }, \
     { MP_ROM_QSTR(MP_QSTR_ussl),        MP_ROM_PTR(&mp_module_ussl) },      \
 
-#define MICROPY_PORT_BUILTIN_MODULE_WEAK_LINKS \
-    { MP_ROM_QSTR(MP_QSTR_errno),       MP_ROM_PTR(&mp_module_uerrno) },    \
-    { MP_ROM_QSTR(MP_QSTR_struct),      MP_ROM_PTR(&mp_module_ustruct) },   \
-    { MP_ROM_QSTR(MP_QSTR_re),          MP_ROM_PTR(&mp_module_ure) },       \
-    { MP_ROM_QSTR(MP_QSTR_json),        MP_ROM_PTR(&mp_module_ujson) },     \
-    { MP_ROM_QSTR(MP_QSTR_os),          MP_ROM_PTR(&mp_module_uos) },       \
-    { MP_ROM_QSTR(MP_QSTR_time),        MP_ROM_PTR(&mp_module_utime) },     \
-    { MP_ROM_QSTR(MP_QSTR_select),      MP_ROM_PTR(&mp_module_uselect) },   \
-    { MP_ROM_QSTR(MP_QSTR_socket),      MP_ROM_PTR(&mp_module_usocket) },   \
-    { MP_ROM_QSTR(MP_QSTR_binascii),    MP_ROM_PTR(&mp_module_ubinascii) }, \
-    { MP_ROM_QSTR(MP_QSTR_ssl),         MP_ROM_PTR(&mp_module_ussl) },      \
-    { MP_ROM_QSTR(MP_QSTR_machine),     MP_ROM_PTR(&machine_module) },      \
-
 // extra constants
 #define MICROPY_PORT_CONSTANTS \
     { MP_ROM_QSTR(MP_QSTR_umachine),     MP_ROM_PTR(&machine_module) },      \
@@ -200,15 +187,15 @@ extern const struct _mp_obj_module_t mp_module_ussl;
 
 
 // type definitions for the specific machine
-#define MICROPY_MAKE_POINTER_CALLABLE(p)            ((void*)((mp_uint_t)(p) | 1))
+#define MICROPY_MAKE_POINTER_CALLABLE(p)            ((void *)((mp_uint_t)(p) | 1))
 #define MP_SSIZE_MAX                                (0x7FFFFFFF)
 
 #define UINT_FMT                                    "%u"
 #define INT_FMT                                     "%d"
 
-typedef int32_t         mp_int_t;                   // must be pointer size
-typedef unsigned int    mp_uint_t;                  // must be pointer size
-typedef long            mp_off_t;
+typedef int32_t mp_int_t;                           // must be pointer size
+typedef unsigned int mp_uint_t;                     // must be pointer size
+typedef long mp_off_t;
 
 #define MP_PLAT_PRINT_STRN(str, len) mp_hal_stdout_tx_strn_cooked(str, len)
 
diff --git a/ports/cc3200/mptask.c b/ports/cc3200/mptask.c
index 9d75f4678eb11..f06a502776087 100644
--- a/ports/cc3200/mptask.c
+++ b/ports/cc3200/mptask.c
@@ -81,16 +81,16 @@
 /******************************************************************************
  DECLARE PRIVATE FUNCTIONS
  ******************************************************************************/
-STATIC void mptask_pre_init (void);
-STATIC void mptask_init_sflash_filesystem (void);
-STATIC void mptask_enter_ap_mode (void);
-STATIC void mptask_create_main_py (void);
+STATIC void mptask_pre_init(void);
+STATIC void mptask_init_sflash_filesystem(void);
+STATIC void mptask_enter_ap_mode(void);
+STATIC void mptask_create_main_py(void);
 
 /******************************************************************************
  DECLARE PUBLIC DATA
  ******************************************************************************/
 #ifdef DEBUG
-OsiTaskHandle   svTaskHandle;
+OsiTaskHandle svTaskHandle;
 #endif
 
 /******************************************************************************
@@ -100,27 +100,29 @@ static fs_user_mount_t *sflash_vfs_fat;
 
 static const char fresh_main_py[] = "# main.py -- put your code here!\r\n";
 static const char fresh_boot_py[] = "# boot.py -- run on boot-up\r\n"
-                                    "# can run arbitrary Python, but best to keep it minimal\r\n"
+    "# can run arbitrary Python, but best to keep it minimal\r\n"
                                     #if MICROPY_STDIO_UART
-                                    "import os, machine\r\n"
-                                    "os.dupterm(machine.UART(0, " MP_STRINGIFY(MICROPY_STDIO_UART_BAUD) "))\r\n"
+    "import os, machine\r\n"
+    "os.dupterm(machine.UART(0, " MP_STRINGIFY(MICROPY_STDIO_UART_BAUD) "))\r\n"
                                     #endif
-                                    ;
+;
 
 /******************************************************************************
  DECLARE PUBLIC FUNCTIONS
  ******************************************************************************/
 
+uintptr_t cortex_m3_get_sp(void);
+
 void TASK_MicroPython (void *pvParameters) {
     // get the top of the stack to initialize the garbage collector
-    uint32_t sp = gc_helper_get_sp();
+    uint32_t sp = cortex_m3_get_sp();
 
     bool safeboot = false;
     mptask_pre_init();
 
-#ifndef DEBUG
+    #ifndef DEBUG
     safeboot = PRCMGetSpecialBit(PRCM_SAFE_BOOT_BIT);
-#endif
+    #endif
 
 soft_reset:
 
@@ -130,7 +132,7 @@ void TASK_MicroPython (void *pvParameters) {
     #endif
 
     // initialise the stack pointer for the main thread (must be done after mp_thread_init)
-    mp_stack_set_top((void*)sp);
+    mp_stack_set_top((void *)sp);
 
     // GC init
     gc_init(&_boot, &_eheap);
@@ -158,8 +160,7 @@ void TASK_MicroPython (void *pvParameters) {
             // when waking up from hibernate we just want
             // to enable simplelink and leave it as is
             wlan_first_start();
-        }
-        else {
+        } else {
             // only if not comming out of hibernate or a soft reset
             mptask_enter_ap_mode();
         }
@@ -180,7 +181,7 @@ void TASK_MicroPython (void *pvParameters) {
 
     if (!safeboot) {
         // run boot.py
-        int ret = pyexec_file("boot.py");
+        int ret = pyexec_file_if_exists("boot.py");
         if (ret & PYEXEC_FORCED_EXIT) {
             goto soft_reset_exit;
         }
@@ -205,7 +206,7 @@ void TASK_MicroPython (void *pvParameters) {
             } else {
                 main_py = mp_obj_str_get_str(MP_STATE_PORT(machine_config_main));
             }
-            int ret = pyexec_file(main_py);
+            int ret = pyexec_file_if_exists(main_py);
             if (ret & PYEXEC_FORCED_EXIT) {
                 goto soft_reset_exit;
             }
@@ -218,7 +219,7 @@ void TASK_MicroPython (void *pvParameters) {
 
     // main script is finished, so now go into REPL mode.
     // the REPL mode can change, or it can request a soft reset.
-    for ( ; ; ) {
+    for ( ; ;) {
         if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
             if (pyexec_raw_repl() != 0) {
                 break;
@@ -284,11 +285,11 @@ STATIC void mptask_pre_init (void) {
     // this one allocates memory for the socket semaphore
     modusocket_pre_init();
 
-    //CRYPTOHASH_Init();
+    // CRYPTOHASH_Init();
 
-#ifndef DEBUG
+    #ifndef DEBUG
     OsiTaskHandle svTaskHandle;
-#endif
+    #endif
     svTaskHandle = xTaskCreateStatic(TASK_Servers, "Servers",
         SERVERS_STACK_LEN, NULL, SERVERS_PRIORITY, svTaskStack, &svTaskTCB);
     ASSERT(svTaskHandle != NULL);
@@ -300,7 +301,7 @@ STATIC void mptask_init_sflash_filesystem (void) {
     // Initialise the local flash filesystem.
     // init the vfs object
     fs_user_mount_t *vfs_fat = sflash_vfs_fat;
-    vfs_fat->flags = 0;
+    vfs_fat->blockdev.flags = 0;
     pyb_flash_init_vfs(vfs_fat);
 
     // Create it if needed, and mount in on /flash.
@@ -382,8 +383,8 @@ STATIC void mptask_enter_ap_mode (void) {
     bool add_mac = !PRCMGetSpecialBit(PRCM_FIRST_BOOT_BIT);
     // enable simplelink in ap mode (use the MAC address to make the ssid unique)
     wlan_sl_init (ROLE_AP, MICROPY_PORT_WLAN_AP_SSID, strlen(MICROPY_PORT_WLAN_AP_SSID),
-                  MICROPY_PORT_WLAN_AP_SECURITY, MICROPY_PORT_WLAN_AP_KEY, strlen(MICROPY_PORT_WLAN_AP_KEY),
-                  MICROPY_PORT_WLAN_AP_CHANNEL, ANTENNA_TYPE_INTERNAL, add_mac);
+        MICROPY_PORT_WLAN_AP_SECURITY, MICROPY_PORT_WLAN_AP_KEY, strlen(MICROPY_PORT_WLAN_AP_KEY),
+        MICROPY_PORT_WLAN_AP_CHANNEL, ANTENNA_TYPE_INTERNAL, add_mac);
 }
 
 STATIC void mptask_create_main_py (void) {
diff --git a/ports/cc3200/mptask.h b/ports/cc3200/mptask.h
index a1c3eb2cbf45c..2c9d6c4cf2f12 100644
--- a/ports/cc3200/mptask.h
+++ b/ports/cc3200/mptask.h
@@ -41,6 +41,6 @@ extern StackType_t mpTaskStack[];
 /******************************************************************************
  DECLARE PUBLIC FUNCTIONS
  ******************************************************************************/
-extern void TASK_MicroPython (void *pvParameters);
+extern void TASK_MicroPython(void *pvParameters);
 
 #endif // MICROPY_INCLUDED_CC3200_MPTASK_H
diff --git a/ports/cc3200/mpthreadport.c b/ports/cc3200/mpthreadport.c
index 9dbc518e06dcc..d35dab2d158c0 100644
--- a/ports/cc3200/mpthreadport.c
+++ b/ports/cc3200/mpthreadport.c
@@ -68,7 +68,7 @@ void mp_thread_init(void) {
 void mp_thread_gc_others(void) {
     mp_thread_mutex_lock(&thread_mutex, 1);
     for (thread_t *th = thread; th != NULL; th = th->next) {
-        gc_collect_root((void**)&th, 1);
+        gc_collect_root((void **)&th, 1);
         gc_collect_root(&th->arg, 1); // probably not needed
         if (th->id == xTaskGetCurrentTaskHandle()) {
             continue;
@@ -85,7 +85,7 @@ mp_state_thread_t *mp_thread_get_state(void) {
     return pvTaskGetThreadLocalStoragePointer(NULL, 0);
 }
 
-void mp_thread_set_state(void *state) {
+void mp_thread_set_state(mp_state_thread_t *state) {
     vTaskSetThreadLocalStoragePointer(NULL, 0, state);
 }
 
@@ -100,7 +100,7 @@ void mp_thread_start(void) {
     mp_thread_mutex_unlock(&thread_mutex);
 }
 
-STATIC void *(*ext_thread_entry)(void*) = NULL;
+STATIC void *(*ext_thread_entry)(void *) = NULL;
 
 STATIC void freertos_entry(void *arg) {
     if (ext_thread_entry) {
@@ -111,7 +111,7 @@ STATIC void freertos_entry(void *arg) {
     }
 }
 
-void mp_thread_create(void *(*entry)(void*), void *arg, size_t *stack_size) {
+void mp_thread_create(void *(*entry)(void *), void *arg, size_t *stack_size) {
     // store thread entry function into a global variable so we can access it
     ext_thread_entry = entry;
 
@@ -129,10 +129,10 @@ void mp_thread_create(void *(*entry)(void*), void *arg, size_t *stack_size) {
     mp_thread_mutex_lock(&thread_mutex, 1);
 
     // create thread
-    TaskHandle_t id = xTaskCreateStatic(freertos_entry, "Thread", *stack_size / sizeof(void*), arg, 2, stack, tcb);
+    TaskHandle_t id = xTaskCreateStatic(freertos_entry, "Thread", *stack_size / sizeof(void *), arg, 2, stack, tcb);
     if (id == NULL) {
         mp_thread_mutex_unlock(&thread_mutex);
-        mp_raise_msg(&mp_type_OSError, "can't create thread");
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't create thread"));
     }
 
     // add thread to linked list of all threads
diff --git a/ports/cc3200/qstrdefsport.h b/ports/cc3200/qstrdefsport.h
index d5f22d70a8fca..3f613266d289a 100644
--- a/ports/cc3200/qstrdefsport.h
+++ b/ports/cc3200/qstrdefsport.h
@@ -25,6 +25,8 @@
  * THE SOFTWARE.
  */
 
+// *FORMAT-OFF*
+
 // for machine module
 Q(/)
 // entries for sys.path
diff --git a/ports/cc3200/serverstask.c b/ports/cc3200/serverstask.c
index 100b8d33b0e1e..517a7a2281bdb 100644
--- a/ports/cc3200/serverstask.c
+++ b/ports/cc3200/serverstask.c
@@ -38,7 +38,6 @@
 #include "ftp.h"
 #include "pybwdt.h"
 #include "modusocket.h"
-#include "mpexception.h"
 #include "modnetwork.h"
 #include "modwlan.h"
 
@@ -88,7 +87,7 @@ void TASK_Servers (void *pvParameters) {
     telnet_init();
     ftp_init();
 
-    for ( ;; ) {
+    for ( ;;) {
 
         if (servers_data.do_enable) {
             // enable network services
@@ -97,16 +96,14 @@ void TASK_Servers (void *pvParameters) {
             // now set/clear the flags
             servers_data.enabled = true;
             servers_data.do_enable = false;
-        }
-        else if (servers_data.do_disable) {
+        } else if (servers_data.do_disable) {
             // disable network services
             telnet_disable();
             ftp_disable();
             // now clear the flags
             servers_data.do_disable = false;
             servers_data.enabled = false;
-        }
-        else if (servers_data.do_reset) {
+        } else if (servers_data.do_reset) {
             // resetting the servers is needed to prevent half-open sockets
             servers_data.do_reset = false;
             if (servers_data.enabled) {
@@ -120,8 +117,7 @@ void TASK_Servers (void *pvParameters) {
 
         if (cycle) {
             telnet_run();
-        }
-        else {
+        } else {
             ftp_run();
         }
 
@@ -187,7 +183,7 @@ void servers_close_socket (int16_t *sd) {
 
 void servers_set_login (char *user, char *pass) {
     if (strlen(user) > SERVERS_USER_PASS_LEN_MAX || strlen(pass) > SERVERS_USER_PASS_LEN_MAX) {
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
     memcpy(servers_user, user, SERVERS_USER_PASS_LEN_MAX);
     memcpy(servers_pass, pass, SERVERS_USER_PASS_LEN_MAX);
@@ -196,7 +192,7 @@ void servers_set_login (char *user, char *pass) {
 void servers_set_timeout (uint32_t timeout) {
     if (timeout < SERVERS_MIN_TIMEOUT_MS) {
         // timeout is too low
-        mp_raise_ValueError(mpexception_value_invalid_arguments);
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid argument(s) value"));
     }
     servers_data.timeout = timeout;
 }
diff --git a/ports/cc3200/serverstask.h b/ports/cc3200/serverstask.h
index c4533d717490f..612899d7f1b88 100644
--- a/ports/cc3200/serverstask.h
+++ b/ports/cc3200/serverstask.h
@@ -60,16 +60,16 @@ extern char servers_pass[];
 /******************************************************************************
  DECLARE PUBLIC FUNCTIONS
  ******************************************************************************/
-extern void TASK_Servers (void *pvParameters);
-extern void servers_start (void);
-extern void servers_stop (void);
-extern void servers_reset (void);
-extern void servers_wlan_cycle_power (void);
-extern bool servers_are_enabled (void);
-extern void servers_close_socket (int16_t *sd);
-extern void servers_set_login (char *user, char *pass);
-extern void server_sleep_sockets (void);
-extern void servers_set_timeout (uint32_t timeout);
-extern uint32_t servers_get_timeout (void);
+extern void TASK_Servers(void *pvParameters);
+extern void servers_start(void);
+extern void servers_stop(void);
+extern void servers_reset(void);
+extern void servers_wlan_cycle_power(void);
+extern bool servers_are_enabled(void);
+extern void servers_close_socket(int16_t *sd);
+extern void servers_set_login(char *user, char *pass);
+extern void server_sleep_sockets(void);
+extern void servers_set_timeout(uint32_t timeout);
+extern uint32_t servers_get_timeout(void);
 
 #endif // MICROPY_INCLUDED_CC3200_SERVERSTASK_H
diff --git a/ports/cc3200/telnet/telnet.c b/ports/cc3200/telnet/telnet.c
index dbb77cd6d762f..401e8a8cc9323 100644
--- a/ports/cc3200/telnet/telnet.c
+++ b/ports/cc3200/telnet/telnet.c
@@ -26,8 +26,7 @@
 
 #include <stdint.h>
 
-#include "py/mpconfig.h"
-#include "py/obj.h"
+#include "py/runtime.h"
 #include "py/mphal.h"
 #include "lib/utils/interrupt_char.h"
 #include "telnet.h"
@@ -36,7 +35,6 @@
 #include "modwlan.h"
 #include "modusocket.h"
 #include "debug.h"
-#include "mpexception.h"
 #include "serverstask.h"
 #include "genhdr/mpversion.h"
 #include "irq.h"
diff --git a/ports/cc3200/tools/smoke.py b/ports/cc3200/tools/smoke.py
index 3ade11cf87dd3..4ccc700c6cd76 100644
--- a/ports/cc3200/tools/smoke.py
+++ b/ports/cc3200/tools/smoke.py
@@ -12,55 +12,58 @@
 pin_map = [23, 24, 11, 12, 13, 14, 15, 16, 17, 22, 28, 10, 9, 8, 7, 6, 30, 31, 3, 0, 4, 5]
 test_bytes = os.urandom(1024)
 
-def test_pin_read (pull):
+
+def test_pin_read(pull):
     # enable the pull resistor on all pins, then read the value
     for p in pin_map:
-        pin = Pin('GP' + str(p), mode=Pin.IN, pull=pull)
+        pin = Pin("GP" + str(p), mode=Pin.IN, pull=pull)
         # read the pin value
         print(pin())
 
-def test_pin_shorts (pull):
+
+def test_pin_shorts(pull):
     if pull == Pin.PULL_UP:
         pull_inverted = Pin.PULL_DOWN
     else:
         pull_inverted = Pin.PULL_UP
     # enable all pulls of the specified type
     for p in pin_map:
-        pin = Pin('GP' + str(p), mode=Pin.IN, pull=pull_inverted)
+        pin = Pin("GP" + str(p), mode=Pin.IN, pull=pull_inverted)
     # then change the pull one pin at a time and read its value
     i = 0
     while i < len(pin_map):
-        pin = Pin('GP' + str(pin_map[i]), mode=Pin.IN, pull=pull)
-        Pin('GP' + str(pin_map[i - 1]), mode=Pin.IN, pull=pull_inverted)
+        pin = Pin("GP" + str(pin_map[i]), mode=Pin.IN, pull=pull)
+        Pin("GP" + str(pin_map[i - 1]), mode=Pin.IN, pull=pull_inverted)
         i += 1
         # read the pin value
         print(pin())
 
+
 test_pin_read(Pin.PULL_UP)
 test_pin_read(Pin.PULL_DOWN)
 test_pin_shorts(Pin.PULL_UP)
 test_pin_shorts(Pin.PULL_DOWN)
 
 # create a test directory
-os.mkdir('/flash/test')
-os.chdir('/flash/test')
+os.mkdir("/flash/test")
+os.chdir("/flash/test")
 print(os.getcwd())
 # create a new file
-f = open('test.txt', 'w')
+f = open("test.txt", "w")
 n_w = f.write(test_bytes)
 print(n_w == len(test_bytes))
 f.close()
-f = open('test.txt', 'r')
-r = bytes(f.read(), 'ascii')
+f = open("test.txt", "r")
+r = bytes(f.read(), "ascii")
 # check that we can write and read it correctly
 print(r == test_bytes)
 f.close()
-os.remove('test.txt')
-os.chdir('..')
-os.rmdir('test')
+os.remove("test.txt")
+os.chdir("..")
+os.rmdir("test")
 
 ls = os.listdir()
-print('test' not in ls)
+print("test" not in ls)
 print(ls)
 
 # test the real time clock
@@ -72,5 +75,4 @@ def test_pin_shorts (pull):
 time.sleep_ms(1000)
 time2 = rtc.now()
 print(time2[5] - time1[5] == 1)
-print(time2[6] - time1[6] < 5000) # microseconds
-
+print(time2[6] - time1[6] < 5000)  # microseconds
diff --git a/ports/cc3200/tools/uniflash.py b/ports/cc3200/tools/uniflash.py
index 21da46a56f263..0ce9d0703a799 100644
--- a/ports/cc3200/tools/uniflash.py
+++ b/ports/cc3200/tools/uniflash.py
@@ -19,7 +19,7 @@
 
 
 def print_exception(e):
-    print ('Exception: {}, on line {}'.format(e, sys.exc_info()[-1].tb_lineno))
+    print("Exception: {}, on line {}".format(e, sys.exc_info()[-1].tb_lineno))
 
 
 def execute(command):
@@ -29,7 +29,7 @@ def execute(command):
     # Poll process for new output until finished
     while True:
         nextline = process.stdout.readline()
-        if nextline == '' and process.poll() != None:
+        if nextline == "" and process.poll() != None:
             break
         sys.stdout.write(nextline)
         sys.stdout.flush()
@@ -43,25 +43,58 @@ def execute(command):
     else:
         raise ProcessException(command, exitCode, output)
 
+
 def main():
-    cmd_parser = argparse.ArgumentParser(description='Flash the WiPy and optionally run a small test on it.')
-    cmd_parser.add_argument('-u', '--uniflash', default=None, help='the path to the uniflash cli executable')
-    cmd_parser.add_argument('-c', '--config', default=None, help='the path to the uniflash config file')
-    cmd_parser.add_argument('-p', '--port', default=8, help='the com serial port')
-    cmd_parser.add_argument('-s', '--servicepack', default=None, help='the path to the servicepack file')
+    cmd_parser = argparse.ArgumentParser(
+        description="Flash the WiPy and optionally run a small test on it."
+    )
+    cmd_parser.add_argument(
+        "-u", "--uniflash", default=None, help="the path to the uniflash cli executable"
+    )
+    cmd_parser.add_argument(
+        "-c", "--config", default=None, help="the path to the uniflash config file"
+    )
+    cmd_parser.add_argument("-p", "--port", default=8, help="the com serial port")
+    cmd_parser.add_argument(
+        "-s", "--servicepack", default=None, help="the path to the servicepack file"
+    )
     args = cmd_parser.parse_args()
 
     output = ""
-    com_port = 'com=' + str(args.port)
-    servicepack_path = 'spPath=' + args.servicepack
+    com_port = "com=" + str(args.port)
+    servicepack_path = "spPath=" + args.servicepack
 
     try:
         if args.uniflash == None or args.config == None:
-            raise ValueError('uniflash path and config path are mandatory')
+            raise ValueError("uniflash path and config path are mandatory")
         if args.servicepack == None:
-            output += execute([args.uniflash, '-config', args.config, '-setOptions', com_port, '-operations', 'format', 'program'])
+            output += execute(
+                [
+                    args.uniflash,
+                    "-config",
+                    args.config,
+                    "-setOptions",
+                    com_port,
+                    "-operations",
+                    "format",
+                    "program",
+                ]
+            )
         else:
-            output += execute([args.uniflash, '-config', args.config, '-setOptions', com_port, servicepack_path, '-operations', 'format', 'servicePackUpdate', 'program'])
+            output += execute(
+                [
+                    args.uniflash,
+                    "-config",
+                    args.config,
+                    "-setOptions",
+                    com_port,
+                    servicepack_path,
+                    "-operations",
+                    "format",
+                    "servicePackUpdate",
+                    "program",
+                ]
+            )
     except Exception as e:
         print_exception(e)
         output = ""
@@ -77,5 +110,6 @@ def main():
             print("======================================")
             sys.exit(1)
 
+
 if __name__ == "__main__":
     main()
diff --git a/ports/cc3200/tools/update-wipy.py b/ports/cc3200/tools/update-wipy.py
index 2d5fe57c2f2ca..e0e1266f7a376 100644
--- a/ports/cc3200/tools/update-wipy.py
+++ b/ports/cc3200/tools/update-wipy.py
@@ -23,12 +23,12 @@
 
 
 def print_exception(e):
-    print ('Exception: {}, on line {}'.format(e, sys.exc_info()[-1].tb_lineno))
+    print("Exception: {}, on line {}".format(e, sys.exc_info()[-1].tb_lineno))
 
 
 def ftp_directory_exists(ftpobj, directory_name):
     filelist = []
-    ftpobj.retrlines('LIST',filelist.append)
+    ftpobj.retrlines("LIST", filelist.append)
     for f in filelist:
         if f.split()[-1] == directory_name:
             return True
@@ -37,34 +37,34 @@ def ftp_directory_exists(ftpobj, directory_name):
 
 def transfer_file(args):
     with FTP(args.ip, timeout=20) as ftp:
-        print ('FTP connection established')
+        print("FTP connection established")
 
-        if '230' in ftp.login(args.user, args.password):
-            print ('Login successful')
+        if "230" in ftp.login(args.user, args.password):
+            print("Login successful")
 
-            if '250' in ftp.cwd('/flash'):
-                if not ftp_directory_exists(ftp, 'sys'):
-                    print ('/flash/sys directory does not exist')
-                    if not '550' in ftp.mkd('sys'):
-                        print ('/flash/sys directory created')
+            if "250" in ftp.cwd("/flash"):
+                if not ftp_directory_exists(ftp, "sys"):
+                    print("/flash/sys directory does not exist")
+                    if not "550" in ftp.mkd("sys"):
+                        print("/flash/sys directory created")
                     else:
-                        print ('Error: cannot create /flash/sys directory')
+                        print("Error: cannot create /flash/sys directory")
                         return False
-                if '250' in ftp.cwd('sys'):
-                    print ("Entered '/flash/sys' directory")
+                if "250" in ftp.cwd("sys"):
+                    print("Entered '/flash/sys' directory")
                     with open(args.file, "rb") as fwfile:
-                        print ('Firmware image found, initiating transfer...')
-                        if '226' in ftp.storbinary("STOR " + 'mcuimg.bin', fwfile, 512):
-                            print ('File transfer complete')
+                        print("Firmware image found, initiating transfer...")
+                        if "226" in ftp.storbinary("STOR " + "mcuimg.bin", fwfile, 512):
+                            print("File transfer complete")
                             return True
                         else:
-                            print ('Error: file transfer failed')
+                            print("Error: file transfer failed")
                 else:
-                    print ('Error: cannot enter /flash/sys directory')
+                    print("Error: cannot enter /flash/sys directory")
             else:
-                print ('Error: cannot enter /flash directory')
+                print("Error: cannot enter /flash directory")
         else:
-            print ('Error: ftp login failed')
+            print("Error: ftp login failed")
 
     return False
 
@@ -76,20 +76,24 @@ def reset_board(args):
         tn = Telnet(args.ip, timeout=5)
         print("Connected via Telnet, trying to login now")
 
-        if b'Login as:' in tn.read_until(b"Login as:", timeout=5):
-            tn.write(bytes(args.user, 'ascii') + b"\r\n")
+        if b"Login as:" in tn.read_until(b"Login as:", timeout=5):
+            tn.write(bytes(args.user, "ascii") + b"\r\n")
 
-            if b'Password:' in tn.read_until(b"Password:", timeout=5):
+            if b"Password:" in tn.read_until(b"Password:", timeout=5):
                 # needed because of internal implementation details of the WiPy's telnet server
                 time.sleep(0.2)
-                tn.write(bytes(args.password, 'ascii') + b"\r\n")
+                tn.write(bytes(args.password, "ascii") + b"\r\n")
 
-                if b'Type "help()" for more information.' in tn.read_until(b'Type "help()" for more information.', timeout=5):
+                if b'Type "help()" for more information.' in tn.read_until(
+                    b'Type "help()" for more information.', timeout=5
+                ):
                     print("Telnet login succeeded")
-                    tn.write(b'\r\x03\x03') # ctrl-C twice: interrupt any running program
+                    tn.write(b"\r\x03\x03")  # ctrl-C twice: interrupt any running program
                     time.sleep(1)
-                    tn.write(b'\r\x02') # ctrl-B: enter friendly REPL
-                    if b'Type "help()" for more information.' in tn.read_until(b'Type "help()" for more information.', timeout=5):
+                    tn.write(b"\r\x02")  # ctrl-B: enter friendly REPL
+                    if b'Type "help()" for more information.' in tn.read_until(
+                        b'Type "help()" for more information.', timeout=5
+                    ):
                         tn.write(b"import machine\r\n")
                         tn.write(b"machine.reset()\r\n")
                         time.sleep(2)
@@ -112,9 +116,9 @@ def reset_board(args):
 
 def verify_update(args):
     success = False
-    firmware_tag = ''
+    firmware_tag = ""
 
-    def find_tag (tag):
+    def find_tag(tag):
         if tag in firmware_tag:
             print("Verification passed")
             return True
@@ -135,21 +139,26 @@ def find_tag (tag):
                 print("Timeout while connecting via telnet, retrying...")
                 retries += 1
             else:
-                print('Error: Telnet connection timed out!')
+                print("Error: Telnet connection timed out!")
                 return False
 
     try:
-        firmware_tag = tn.read_until (b'with CC3200')
-        tag_file_path = args.file.rstrip('mcuimg.bin') + 'genhdr/mpversion.h'
-        
+        firmware_tag = tn.read_until(b"with CC3200")
+        tag_file_path = args.file.rstrip("mcuimg.bin") + "genhdr/mpversion.h"
+
         if args.tag is not None:
-            success = find_tag(bytes(args.tag, 'ascii'))
+            success = find_tag(bytes(args.tag, "ascii"))
         else:
             with open(tag_file_path) as tag_file:
                 for line in tag_file:
-                    bline = bytes(line, 'ascii')
-                    if b'MICROPY_GIT_HASH' in bline:
-                        bline = bline.lstrip(b'#define MICROPY_GIT_HASH ').replace(b'"', b'').replace(b'\r', b'').replace(b'\n', b'')
+                    bline = bytes(line, "ascii")
+                    if b"MICROPY_GIT_HASH" in bline:
+                        bline = (
+                            bline.lstrip(b"#define MICROPY_GIT_HASH ")
+                            .replace(b'"', b"")
+                            .replace(b"\r", b"")
+                            .replace(b"\n", b"")
+                        )
                         success = find_tag(bline)
                         break
 
@@ -164,24 +173,28 @@ def find_tag (tag):
 
 
 def main():
-    cmd_parser = argparse.ArgumentParser(description='Update the WiPy firmware with the specified image file')
-    cmd_parser.add_argument('-f', '--file', default=None, help='the path of the firmware file')
-    cmd_parser.add_argument('-u', '--user', default='micro', help='the username')
-    cmd_parser.add_argument('-p', '--password', default='python', help='the login password')
-    cmd_parser.add_argument('--ip', default='192.168.1.1', help='the ip address of the WiPy')
-    cmd_parser.add_argument('--verify', action='store_true', help='verify that the update succeeded')
-    cmd_parser.add_argument('-t', '--tag', default=None, help='git tag of the firmware image')
+    cmd_parser = argparse.ArgumentParser(
+        description="Update the WiPy firmware with the specified image file"
+    )
+    cmd_parser.add_argument("-f", "--file", default=None, help="the path of the firmware file")
+    cmd_parser.add_argument("-u", "--user", default="micro", help="the username")
+    cmd_parser.add_argument("-p", "--password", default="python", help="the login password")
+    cmd_parser.add_argument("--ip", default="192.168.1.1", help="the ip address of the WiPy")
+    cmd_parser.add_argument(
+        "--verify", action="store_true", help="verify that the update succeeded"
+    )
+    cmd_parser.add_argument("-t", "--tag", default=None, help="git tag of the firmware image")
     args = cmd_parser.parse_args()
 
     result = 1
 
     try:
         if args.file is None:
-            raise ValueError('the image file path must be specified')
+            raise ValueError("the image file path must be specified")
         if transfer_file(args):
             if reset_board(args):
                 if args.verify:
-                    print ('Waiting for the WiFi connection to come up again...')
+                    print("Waiting for the WiFi connection to come up again...")
                     # this time is to allow the system's wireless network card to
                     # connect to the WiPy again.
                     time.sleep(5)
diff --git a/ports/cc3200/util/cortex_m3_get_sp.s b/ports/cc3200/util/cortex_m3_get_sp.s
new file mode 100644
index 0000000000000..b7e78f1d3becd
--- /dev/null
+++ b/ports/cc3200/util/cortex_m3_get_sp.s
@@ -0,0 +1,43 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2014 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+    .syntax unified
+    .cpu cortex-m3
+    .thumb
+
+    .section .text
+    .align  2
+
+    .global cortex_m3_get_sp
+    .type cortex_m3_get_sp, %function
+
+@ uint cortex_m3_get_sp(void)
+cortex_m3_get_sp:
+    @ return the sp
+    mov     r0, sp
+    bx      lr
+
+    .size cortex_m3_get_sp, .-cortex_m3_get_sp
diff --git a/ports/cc3200/util/gccollect.c b/ports/cc3200/util/gccollect.c
index 65b2f1605a884..eac0c86b0268d 100644
--- a/ports/cc3200/util/gccollect.c
+++ b/ports/cc3200/util/gccollect.c
@@ -41,12 +41,8 @@ void gc_collect(void) {
     // start the GC
     gc_collect_start();
 
-    // get the registers and the sp
-    mp_uint_t regs[10];
-    mp_uint_t sp = gc_helper_get_regs_and_sp(regs);
-
-    // trace the stack, including the registers (since they live on the stack in this function)
-    gc_collect_root((void**)sp, ((mp_uint_t)MP_STATE_THREAD(stack_top) - sp) / sizeof(uint32_t));
+    // trace the stack and the registers
+    gc_helper_collect_regs_and_stack();
 
     // trace root pointers from any threads
     #if MICROPY_PY_THREAD
diff --git a/ports/cc3200/version.h b/ports/cc3200/version.h
index fccb95c5211b8..81a69999ec86f 100644
--- a/ports/cc3200/version.h
+++ b/ports/cc3200/version.h
@@ -1,31 +1,31 @@
-/*
- * This file is part of the MicroPython project, http://micropython.org/
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2015 Daniel Campora
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-#ifndef MICROPY_INCLUDED_CC3200_VERSION_H
-#define MICROPY_INCLUDED_CC3200_VERSION_H
-
-#define WIPY_SW_VERSION_NUMBER                              "1.2.0"
-
-#endif // MICROPY_INCLUDED_CC3200_VERSION_H
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Daniel Campora
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_CC3200_VERSION_H
+#define MICROPY_INCLUDED_CC3200_VERSION_H
+
+#define WIPY_SW_VERSION_NUMBER                              "1.2.0"
+
+#endif // MICROPY_INCLUDED_CC3200_VERSION_H
diff --git a/ports/esp32/Makefile b/ports/esp32/Makefile
index ea90c9f3f5a9d..bd89e8b0c5610 100644
--- a/ports/esp32/Makefile
+++ b/ports/esp32/Makefile
@@ -1,19 +1,47 @@
+# Select the board to build for: if not given on the command line,
+# then default to GENERIC.
+BOARD ?= GENERIC
+
+# If the build directory is not given, make it reflect the board name.
+BUILD ?= build-$(BOARD)
+
+BOARD_DIR ?= boards/$(BOARD)
+ifeq ($(wildcard $(BOARD_DIR)/.),)
+$(error Invalid BOARD specified: $(BOARD_DIR))
+endif
+
 include ../../py/mkenv.mk
 
+# Optional (not currently used for ESP32)
+-include mpconfigport.mk
+
+ifneq ($(SDKCONFIG),)
+$(error Use the BOARD variable instead of SDKCONFIG)
+endif
+
+# Expected to set SDKCONFIG
+include $(BOARD_DIR)/mpconfigboard.mk
+
 # qstr definitions (must come before including py.mk)
 QSTR_DEFS = qstrdefsport.h
+QSTR_GLOBAL_DEPENDENCIES = $(BOARD_DIR)/mpconfigboard.h
+QSTR_GLOBAL_REQUIREMENTS = $(SDKCONFIG_H)
 
+# MicroPython feature configurations
+MICROPY_ROM_TEXT_COMPRESSION ?= 1
 MICROPY_PY_USSL = 0
 MICROPY_SSL_AXTLS = 0
-MICROPY_FATFS = 1
 MICROPY_PY_BTREE = 1
+MICROPY_VFS_FAT = 1
+MICROPY_VFS_LFS2 = 1
 
-#FROZEN_DIR = scripts
-FROZEN_MPY_DIR = modules
+FROZEN_MANIFEST ?= boards/manifest.py
 
 # include py core make definitions
 include $(TOP)/py/py.mk
 
+GIT_SUBMODULES = lib/berkeley-db-1.xx
+
 PORT ?= /dev/ttyUSB0
 BAUD ?= 460800
 FLASH_MODE ?= dio
@@ -22,12 +50,18 @@ FLASH_SIZE ?= 4MB
 CROSS_COMPILE ?= xtensa-esp32-elf-
 OBJDUMP = $(CROSS_COMPILE)objdump
 
-# SDKCONFIG should be overridden to get a different configuration
-SDKCONFIG ?= boards/sdkconfig
+SDKCONFIG_COMBINED = $(BUILD)/sdkconfig.combined
 SDKCONFIG_H = $(BUILD)/sdkconfig.h
 
-# the git hash of the currently supported ESP IDF version
-ESPIDF_SUPHASH := 5c88c5996dbde6208e3bec05abc21ff6cd822d26
+# The git hash of the currently supported ESP IDF version.
+# These correspond to v3.3.2 and v4.0.
+ESPIDF_SUPHASH_V3 := 9e70825d1e1cbf7988cf36981774300066580ea7
+ESPIDF_SUPHASH_V4 := 463a9d8b7f9af8205222b80707f9bdbba7c530e1
+
+define print_supported_git_hash
+$(info Supported git hash (v3.3): $(ESPIDF_SUPHASH_V3))
+$(info Supported git hash (v4.0) (experimental): $(ESPIDF_SUPHASH_V4))
+endef
 
 # paths to ESP IDF and its components
 ifeq ($(ESPIDF),)
@@ -36,10 +70,11 @@ ESPIDF = $(IDF_PATH)
 else
 $(info The ESPIDF variable has not been set, please set it to the root of the esp-idf repository.)
 $(info See README.md for installation instructions.)
-$(info Supported git hash: $(ESPIDF_SUPHASH))
+dummy := $(call print_supported_git_hash)
 $(error ESPIDF not set)
 endif
 endif
+
 ESPCOMP = $(ESPIDF)/components
 ESPTOOL ?= $(ESPCOMP)/esptool_py/esptool/esptool.py
 ESPCOMP_KCONFIGS = $(shell find $(ESPCOMP) -name Kconfig)
@@ -47,18 +82,52 @@ ESPCOMP_KCONFIGS_PROJBUILD = $(shell find $(ESPCOMP) -name Kconfig.projbuild)
 
 # verify the ESP IDF version
 ESPIDF_CURHASH := $(shell git -C $(ESPIDF) show -s --pretty=format:'%H')
-ifneq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH))
+
+ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V3))
+$(info Building with ESP IDF v3)
+else ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V4))
+$(info Building with ESP IDF v4)
+
+PYPARSING_VERSION = $(shell python3 -c 'import pyparsing; print(pyparsing.__version__)')
+ifneq ($(PYPARSING_VERSION),2.3.1)
+$(info ** ERROR **)
+$(info EDP IDF requires pyparsing version less than 2.4)
+$(info You will need to set up a Python virtual environment with pyparsing 2.3.1)
+$(info Please see README.md for more information)
+$(error Incorrect pyparsing version)
+endif
+else
 $(info ** WARNING **)
 $(info The git hash of ESP IDF does not match the supported version)
 $(info The build may complete and the firmware may work but it is not guaranteed)
 $(info ESP IDF path:       $(ESPIDF))
 $(info Current git hash:   $(ESPIDF_CURHASH))
-$(info Supported git hash: $(ESPIDF_SUPHASH))
+dummy := $(call print_supported_git_hash)
 endif
 
 # pretty format of ESP IDF version, used internally by the IDF
 IDF_VER := $(shell git -C $(ESPIDF) describe)
 
+ifeq ($(shell which $(CC) 2> /dev/null),)
+$(info ** ERROR **)
+$(info Cannot find C compiler $(CC))
+$(info Add the xtensa toolchain to your PATH. See README.md)
+$(error C compiler missing)
+endif
+
+# Support BLE by default.
+# Can be explicitly disabled on the command line or board config.
+MICROPY_PY_BLUETOOTH ?= 1
+ifeq ($(MICROPY_PY_BLUETOOTH),1)
+SDKCONFIG += boards/sdkconfig.ble
+
+# Use NimBLE on ESP32.
+MICROPY_BLUETOOTH_NIMBLE ?= 1
+# Use Nimble bindings, but ESP32 IDF provides the Nimble library.
+MICROPY_BLUETOOTH_NIMBLE_BINDINGS_ONLY = 1
+include $(TOP)/extmod/nimble/nimble.mk
+endif
+
 # include sdkconfig to get needed configuration values
 include $(SDKCONFIG)
 
@@ -74,22 +143,17 @@ INC += -I$(BUILD)
 
 INC_ESPCOMP += -I$(ESPCOMP)/bootloader_support/include
 INC_ESPCOMP += -I$(ESPCOMP)/bootloader_support/include_bootloader
+INC_ESPCOMP += -I$(ESPCOMP)/console
 INC_ESPCOMP += -I$(ESPCOMP)/driver/include
 INC_ESPCOMP += -I$(ESPCOMP)/driver/include/driver
-INC_ESPCOMP += -I$(ESPCOMP)/nghttp/port/include
-INC_ESPCOMP += -I$(ESPCOMP)/nghttp/nghttp2/lib/includes
+INC_ESPCOMP += -I$(ESPCOMP)/efuse/include
+INC_ESPCOMP += -I$(ESPCOMP)/efuse/esp32/include
 INC_ESPCOMP += -I$(ESPCOMP)/esp32/include
+INC_ESPCOMP += -I$(ESPCOMP)/espcoredump/include
 INC_ESPCOMP += -I$(ESPCOMP)/soc/include
 INC_ESPCOMP += -I$(ESPCOMP)/soc/esp32/include
-INC_ESPCOMP += -I$(ESPCOMP)/ethernet/include
-INC_ESPCOMP += -I$(ESPCOMP)/expat/expat/expat/lib
-INC_ESPCOMP += -I$(ESPCOMP)/expat/port/include
 INC_ESPCOMP += -I$(ESPCOMP)/heap/include
-INC_ESPCOMP += -I$(ESPCOMP)/json/include
-INC_ESPCOMP += -I$(ESPCOMP)/json/port/include
 INC_ESPCOMP += -I$(ESPCOMP)/log/include
-INC_ESPCOMP += -I$(ESPCOMP)/newlib/platform_include
-INC_ESPCOMP += -I$(ESPCOMP)/newlib/include
 INC_ESPCOMP += -I$(ESPCOMP)/nvs_flash/include
 INC_ESPCOMP += -I$(ESPCOMP)/freertos/include
 INC_ESPCOMP += -I$(ESPCOMP)/esp_ringbuf/include
@@ -98,19 +162,96 @@ INC_ESPCOMP += -I$(ESPCOMP)/tcpip_adapter/include
 INC_ESPCOMP += -I$(ESPCOMP)/lwip/lwip/src/include
 INC_ESPCOMP += -I$(ESPCOMP)/lwip/port/esp32/include
 INC_ESPCOMP += -I$(ESPCOMP)/lwip/include/apps
+INC_ESPCOMP += -I$(ESPCOMP)/lwip/include/apps/sntp
 INC_ESPCOMP += -I$(ESPCOMP)/mbedtls/mbedtls/include
 INC_ESPCOMP += -I$(ESPCOMP)/mbedtls/port/include
+INC_ESPCOMP += -I$(ESPCOMP)/mdns/include
+INC_ESPCOMP += -I$(ESPCOMP)/mdns/private_include
 INC_ESPCOMP += -I$(ESPCOMP)/spi_flash/include
 INC_ESPCOMP += -I$(ESPCOMP)/ulp/include
 INC_ESPCOMP += -I$(ESPCOMP)/vfs/include
 INC_ESPCOMP += -I$(ESPCOMP)/xtensa-debug-module/include
 INC_ESPCOMP += -I$(ESPCOMP)/wpa_supplicant/include
 INC_ESPCOMP += -I$(ESPCOMP)/wpa_supplicant/port/include
-INC_ESPCOMP += -I$(ESPCOMP)/ethernet/include
 INC_ESPCOMP += -I$(ESPCOMP)/app_trace/include
 INC_ESPCOMP += -I$(ESPCOMP)/app_update/include
 INC_ESPCOMP += -I$(ESPCOMP)/pthread/include
 INC_ESPCOMP += -I$(ESPCOMP)/smartconfig_ack/include
+INC_ESPCOMP += -I$(ESPCOMP)/sdmmc/include
+
+ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V4))
+INC_ESPCOMP += -I$(ESPCOMP)/esp_common/include
+INC_ESPCOMP += -I$(ESPCOMP)/esp_eth/include
+INC_ESPCOMP += -I$(ESPCOMP)/esp_event/private_include
+INC_ESPCOMP += -I$(ESPCOMP)/esp_rom/include
+INC_ESPCOMP += -I$(ESPCOMP)/esp_wifi/include
+INC_ESPCOMP += -I$(ESPCOMP)/esp_wifi/esp32/include
+INC_ESPCOMP += -I$(ESPCOMP)/lwip/include/apps/sntp
+INC_ESPCOMP += -I$(ESPCOMP)/spi_flash/private_include
+INC_ESPCOMP += -I$(ESPCOMP)/wpa_supplicant/include/esp_supplicant
+INC_ESPCOMP += -I$(ESPCOMP)/xtensa/include
+INC_ESPCOMP += -I$(ESPCOMP)/xtensa/esp32/include
+ifeq ($(CONFIG_BT_NIMBLE_ENABLED),y)
+INC_ESPCOMP += -I$(ESPCOMP)/bt/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/common/osi/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/common/btc/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/common/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/nimble/porting/nimble/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/port/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/nimble/nimble/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/nimble/nimble/host/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/nimble/nimble/host/services/ans/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/nimble/nimble/host/services/bas/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/nimble/nimble/host/services/gap/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/nimble/nimble/host/services/gatt/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/nimble/nimble/host/services/ias/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/nimble/nimble/host/services/lls/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/nimble/nimble/host/services/tps/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/nimble/nimble/host/util/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/nimble/nimble/host/store/ram/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/nimble/nimble/host/store/config/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/nimble/porting/npl/freertos/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/nimble/ext/tinycrypt/include
+INC_ESPCOMP += -I$(ESPCOMP)/bt/host/nimble/esp-hci/include
+endif
+else
+INC_ESPCOMP += -I$(ESPCOMP)/ethernet/include
+INC_ESPCOMP += -I$(ESPCOMP)/expat/expat/expat/lib
+INC_ESPCOMP += -I$(ESPCOMP)/expat/port/include
+INC_ESPCOMP += -I$(ESPCOMP)/json/include
+INC_ESPCOMP += -I$(ESPCOMP)/json/port/include
+INC_ESPCOMP += -I$(ESPCOMP)/micro-ecc/micro-ecc
+INC_ESPCOMP += -I$(ESPCOMP)/nghttp/port/include
+INC_ESPCOMP += -I$(ESPCOMP)/nghttp/nghttp2/lib/includes
+ifeq ($(CONFIG_NIMBLE_ENABLED),y)
+INC_ESPCOMP += -I$(ESPCOMP)/bt/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/nimble/porting/nimble/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/port/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/nimble/nimble/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/nimble/nimble/host/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/nimble/nimble/host/services/ans/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/nimble/nimble/host/services/bas/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/nimble/nimble/host/services/gap/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/nimble/nimble/host/services/gatt/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/nimble/nimble/host/services/ias/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/nimble/nimble/host/services/lls/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/nimble/nimble/host/services/tps/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/nimble/nimble/host/util/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/nimble/nimble/host/store/ram/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/nimble/nimble/host/store/config/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/nimble/porting/npl/freertos/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/nimble/ext/tinycrypt/include
+INC_ESPCOMP += -I$(ESPCOMP)/nimble/esp-hci/include
+endif
+endif
+
+INC_NEWLIB += -I$(ESPCOMP)/newlib/platform_include
+INC_NEWLIB += -I$(ESPCOMP)/newlib/include
+
+ifeq ($(MICROPY_PY_BLUETOOTH),1)
+CFLAGS_MOD += -DMICROPY_PY_BLUETOOTH=1
+CFLAGS_MOD += -DMICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE=1
+endif
 
 # these flags are common to C and C++ compilation
 CFLAGS_COMMON = -Os -ffunction-sections -fdata-sections -fstrict-volatile-bitfields \
@@ -120,9 +261,14 @@ CFLAGS_COMMON = -Os -ffunction-sections -fdata-sections -fstrict-volatile-bitfie
 	-DESP_PLATFORM
 
 CFLAGS_BASE = -std=gnu99 $(CFLAGS_COMMON) -DMBEDTLS_CONFIG_FILE='"mbedtls/esp_config.h"' -DHAVE_CONFIG_H
-CFLAGS = $(CFLAGS_BASE) $(INC) $(INC_ESPCOMP)
+CFLAGS = $(CFLAGS_BASE) $(INC) $(INC_ESPCOMP) $(INC_NEWLIB)
 CFLAGS += -DIDF_VER=\"$(IDF_VER)\"
-CFLAGS += $(CFLAGS_MOD)
+CFLAGS += $(CFLAGS_MOD) $(CFLAGS_EXTRA)
+CFLAGS += -I$(BOARD_DIR)
+
+ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V4))
+CFLAGS += -DMICROPY_ESP_IDF_4=1
+endif
 
 # this is what ESPIDF uses for c++ compilation
 CXXFLAGS = -std=gnu++11 $(CFLAGS_COMMON) $(INC) $(INC_ESPCOMP)
@@ -132,8 +278,9 @@ LDFLAGS += --gc-sections -static -EL
 LDFLAGS += -u call_user_start_cpu0 -u uxTopUsedPriority -u ld_include_panic_highint_hdl
 LDFLAGS += -u __cxa_guard_dummy # so that implementation of static guards is taken from cxx_guards.o instead of libstdc++.a
 LDFLAGS += -L$(ESPCOMP)/esp32/ld
+LDFLAGS += -L$(ESPCOMP)/esp_rom/esp32/ld
 LDFLAGS += -T $(BUILD)/esp32_out.ld
-LDFLAGS += -T $(BUILD)/esp32.common.ld
+LDFLAGS += -T $(BUILD)/esp32.project.ld
 LDFLAGS += -T esp32.rom.ld
 LDFLAGS += -T esp32.rom.libgcc.ld
 LDFLAGS += -T esp32.peripherals.ld
@@ -151,12 +298,22 @@ COPT += -Os -DNDEBUG
 #LDFLAGS += --gc-sections
 endif
 
-# Enable SPIRAM support if CONFIG_SPIRAM_SUPPORT=y in sdkconfig
-ifeq ($(CONFIG_SPIRAM_SUPPORT),y)
+# Options for mpy-cross
+MPY_CROSS_FLAGS += -march=xtensawin
+
+# Enable SPIRAM support if CONFIG_ESP32_SPIRAM_SUPPORT=y in sdkconfig
+ifeq ($(CONFIG_ESP32_SPIRAM_SUPPORT),y)
 CFLAGS_COMMON += -mfix-esp32-psram-cache-issue
 LIBC_LIBM = $(ESPCOMP)/newlib/lib/libc-psram-workaround.a $(ESPCOMP)/newlib/lib/libm-psram-workaround.a
 else
+# Additional newlib symbols that can only be used with spiram disabled.
+ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V4))
+LDFLAGS += -T esp32.rom.newlib-funcs.ld
+LDFLAGS += -T esp32.rom.newlib-locale.ld
+LDFLAGS += -T esp32.rom.newlib-data.ld
+else
 LDFLAGS += -T esp32.rom.spiram_incompatible_fns.ld
+endif
 LIBC_LIBM = $(ESPCOMP)/newlib/lib/libc.a $(ESPCOMP)/newlib/lib/libm.a
 endif
 
@@ -177,14 +334,18 @@ SRC_C = \
 	machine_touchpad.c \
 	machine_adc.c \
 	machine_dac.c \
+	machine_i2c.c \
 	machine_pwm.c \
 	machine_uart.c \
 	modmachine.c \
 	modnetwork.c \
 	network_lan.c \
 	network_ppp.c \
+	nimble.c \
 	modsocket.c \
 	modesp.c \
+	esp32_partition.c \
+	esp32_rmt.c \
 	esp32_ulp.c \
 	modesp32.c \
 	espneopixel.c \
@@ -192,9 +353,11 @@ SRC_C = \
 	machine_wdt.c \
 	mpthreadport.c \
 	machine_rtc.c \
+	machine_sdcard.c \
+	$(wildcard $(BOARD_DIR)/*.c) \
 	$(SRC_MOD)
 
-EXTMOD_SRC_C = $(addprefix extmod/,\
+EXTMOD_SRC_C += $(addprefix extmod/,\
 	modonewire.c \
 	)
 
@@ -207,12 +370,6 @@ LIB_SRC_C = $(addprefix lib/,\
 	utils/sys_stdio_mphal.c \
 	)
 
-ifeq ($(MICROPY_FATFS), 1)
-LIB_SRC_C += \
-	lib/oofatfs/ff.c \
-	lib/oofatfs/ffunicode.c
-endif
-
 DRIVERS_SRC_C = $(addprefix drivers/,\
 	bus/softspi.c \
 	dht/dht.c \
@@ -225,6 +382,9 @@ OBJ_MP += $(addprefix $(BUILD)/, $(EXTMOD_SRC_C:.c=.o))
 OBJ_MP += $(addprefix $(BUILD)/, $(LIB_SRC_C:.c=.o))
 OBJ_MP += $(addprefix $(BUILD)/, $(DRIVERS_SRC_C:.c=.o))
 
+# Only enable this for the MicroPython source: ignore warnings from esp-idf.
+$(OBJ_MP): CFLAGS += -Wdouble-promotion -Wfloat-conversion
+
 # List of sources for qstr extraction
 SRC_QSTR += $(SRC_C) $(EXTMOD_SRC_C) $(LIB_SRC_C) $(DRIVERS_SRC_C)
 # Append any auto-generated sources that are needed by sources listed in SRC_QSTR
@@ -233,7 +393,11 @@ SRC_QSTR_AUTO_DEPS +=
 ################################################################################
 # Generate sdkconfig.h from sdkconfig
 
-$(SDKCONFIG_H): $(SDKCONFIG)
+$(SDKCONFIG_COMBINED): $(SDKCONFIG)
+	$(Q)$(MKDIR) -p $(dir $@)
+	$(Q)$(CAT) $^ > $@
+
+$(SDKCONFIG_H): $(SDKCONFIG_COMBINED)
 	$(ECHO) "GEN $@"
 	$(Q)$(MKDIR) -p $(dir $@)
 	$(Q)$(PYTHON) $(ESPIDF)/tools/kconfig_new/confgen.py \
@@ -243,508 +407,217 @@ $(SDKCONFIG_H): $(SDKCONFIG)
 		--env "IDF_TARGET=esp32" \
 		--env "IDF_CMAKE=n" \
 		--env "COMPONENT_KCONFIGS=$(ESPCOMP_KCONFIGS)" \
-		--env "COMPONENT_KCONFIGS_PROJBUILD=$(ESPCOMP_KCONFIGS_PROJBUILD)"
+		--env "COMPONENT_KCONFIGS_PROJBUILD=$(ESPCOMP_KCONFIGS_PROJBUILD)" \
+		--env "IDF_PATH=$(ESPIDF)"
 	$(Q)touch $@
 
-$(HEADER_BUILD)/qstrdefs.generated.h: $(SDKCONFIG_H)
+$(HEADER_BUILD)/qstrdefs.generated.h: $(SDKCONFIG_H) $(BOARD_DIR)/mpconfigboard.h
 
 ################################################################################
 # List of object files from the ESP32 IDF components
 
-ESPIDF_DRIVER_O = $(addprefix $(ESPCOMP)/driver/,\
-	uart.o \
-	periph_ctrl.o \
-	ledc.o \
-	gpio.o \
-	timer.o \
-	spi_master.o \
-	spi_common.o \
-	rtc_module.o \
-	)
+ESPIDF_BOOTLOADER_SUPPORT_O = $(patsubst %.c,%.o,\
+	$(filter-out $(ESPCOMP)/bootloader_support/src/bootloader_init.c,\
+		$(wildcard $(ESPCOMP)/bootloader_support/src/*.c) \
+		$(wildcard $(ESPCOMP)/bootloader_support/src/idf/*.c) \
+		))
 
-$(BUILD)/$(ESPCOMP)/esp32/dport_access.o: CFLAGS += -Wno-array-bounds
-ESPIDF_ESP32_O = $(addprefix $(ESPCOMP)/esp32/,\
-	brownout.o \
-	cache_sram_mmu.o \
-	coexist.o \
-	dbg_stubs.o \
-	dport_panic_highint_hdl.o \
-	esp_err_to_name.o \
-	esp_himem.o \
-	panic.o \
-	pm_trace.o \
-	reset_reason.o \
-	restore.o \
-	stack_check.o \
-	esp_timer.o \
-	esp_timer_esp32.o \
-	ets_timer_legacy.o \
-	event_default_handlers.o \
-	fast_crypto_ops.o \
-	task_wdt.o \
-	cache_err_int.o \
-	clk.o \
-	core_dump.o \
-	cpu_start.o \
-	gdbstub.o \
-	crosscore_int.o \
-	ipc.o \
-	int_wdt.o \
-	event_loop.o \
-	hwcrypto/sha.o \
-	hwcrypto/aes.o \
-	lib_printf.o \
-	freertos_hooks.o \
-	system_api.o \
-	hw_random.o \
-	phy_init.o \
-	pm_esp32.o \
-	pm_locks.o \
-	intr_alloc.o \
-	dport_access.o \
-	wifi_init.o \
-	wifi_os_adapter.o \
-	sleep_modes.o \
-	spiram.o \
-	spiram_psram.o \
-	)
+ESPIDF_DRIVER_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/driver/*.c))
 
-ESPIDF_ESP_RINGBUF_O = $(addprefix $(ESPCOMP)/esp_ringbuf/,\
-	ringbuf.o \
+ESPIDF_EFUSE_O = $(patsubst %.c,%.o,\
+	$(wildcard $(ESPCOMP)/efuse/esp32/*.c)\
+	$(wildcard $(ESPCOMP)/efuse/src/*.c)\
 	)
 
-ESPIDF_HEAP_O = $(addprefix $(ESPCOMP)/heap/,\
-	heap_caps.o \
-	heap_caps_init.o \
-	multi_heap.o \
-	)
+$(BUILD)/$(ESPCOMP)/esp32/dport_access.o: CFLAGS += -Wno-array-bounds
+ESPIDF_ESP32_O = \
+	$(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/esp32/*.c)) \
+	$(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/esp32/hwcrypto/*.c)) \
+	$(patsubst %.S,%.o,$(wildcard $(ESPCOMP)/esp32/*.S)) \
 
-ESPIDF_SOC_O = $(addprefix $(ESPCOMP)/soc/,\
-	esp32/cpu_util.o \
-	esp32/gpio_periph.o \
-	esp32/rtc_clk.o \
-	esp32/rtc_init.o \
-	esp32/rtc_periph.o \
-	esp32/rtc_pm.o \
-	esp32/rtc_sleep.o \
-	esp32/rtc_time.o \
-	esp32/rtc_wdt.o \
-	esp32/soc_memory_layout.o \
-	esp32/spi_periph.o \
-	src/memory_layout_utils.o \
-	)
+ESPIDF_ESP_RINGBUF_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/esp_ringbuf/*.c))
 
-ESPIDF_CXX_O = $(addprefix $(ESPCOMP)/cxx/,\
-	cxx_guards.o \
-	)
+ESPIDF_HEAP_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/heap/*.c))
 
-ESPIDF_ETHERNET_O = $(addprefix $(ESPCOMP)/ethernet/,\
-	emac_dev.o \
-	emac_main.o \
-	eth_phy/phy_tlk110.o \
-	eth_phy/phy_lan8720.o \
-	eth_phy/phy_common.o \
+ESPIDF_SOC_O = $(patsubst %.c,%.o,\
+	$(wildcard $(ESPCOMP)/soc/esp32/*.c) \
+	$(wildcard $(ESPCOMP)/soc/src/*.c) \
+	$(wildcard $(ESPCOMP)/soc/src/hal/*.c) \
 	)
 
-$(BUILD)/$(ESPCOMP)/expat/%.o: CFLAGS += -DHAVE_EXPAT_CONFIG_H -DHAVE_GETRANDOM
-ESPIDF_EXPAT_O = $(addprefix $(ESPCOMP)/expat/,\
-	expat/expat/lib/xmltok_ns.o \
-	expat/expat/lib/xmltok.o \
-	expat/expat/lib/xmlparse.o \
-	expat/expat/lib/xmlrole.o \
-	expat/expat/lib/xmltok_impl.o \
-	)
+$(BUILD)/$(ESPCOMP)/cxx/cxx_guards.o: CXXFLAGS += -Wno-error=sign-compare
+ESPIDF_CXX_O = $(patsubst %.cpp,%.o,$(wildcard $(ESPCOMP)/cxx/*.cpp))
 
-ESPIDF_PTHREAD_O = $(addprefix $(ESPCOMP)/pthread/,\
-	pthread.o \
-	pthread_local_storage.o \
-	)
+ESPIDF_PTHREAD_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/pthread/*.c))
 
 # Assembler .S files need only basic flags, and in particular should not have
 # -Os because that generates subtly different code.
 # We also need custom CFLAGS for .c files because FreeRTOS has headers with
 # generic names (eg queue.h) which can clash with other files in the port.
+ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V4))
+CFLAGS_ASM = -I$(BUILD) -I$(ESPCOMP)/esp32/include -I$(ESPCOMP)/soc/esp32/include -I$(ESPCOMP)/freertos/include/freertos -I. -I$(ESPCOMP)/xtensa/include -I$(ESPCOMP)/xtensa/esp32/include -I$(ESPCOMP)/esp_common/include
+else
 CFLAGS_ASM = -I$(BUILD) -I$(ESPCOMP)/esp32/include -I$(ESPCOMP)/soc/esp32/include -I$(ESPCOMP)/freertos/include/freertos -I.
+endif
 $(BUILD)/$(ESPCOMP)/freertos/portasm.o: CFLAGS = $(CFLAGS_ASM)
 $(BUILD)/$(ESPCOMP)/freertos/xtensa_context.o: CFLAGS = $(CFLAGS_ASM)
 $(BUILD)/$(ESPCOMP)/freertos/xtensa_intr_asm.o: CFLAGS = $(CFLAGS_ASM)
 $(BUILD)/$(ESPCOMP)/freertos/xtensa_vectors.o: CFLAGS = $(CFLAGS_ASM)
 $(BUILD)/$(ESPCOMP)/freertos/xtensa_vector_defaults.o: CFLAGS = $(CFLAGS_ASM)
-$(BUILD)/$(ESPCOMP)/freertos/%.o: CFLAGS = $(CFLAGS_BASE) -I. -I$(BUILD) $(INC_ESPCOMP) -I$(ESPCOMP)/freertos/include/freertos -D_ESP_FREERTOS_INTERNAL
-ESPIDF_FREERTOS_O = $(addprefix $(ESPCOMP)/freertos/,\
-	croutine.o \
-	event_groups.o \
-	FreeRTOS-openocd.o \
-	list.o \
-	portasm.o \
-	port.o \
-	queue.o \
-	tasks.o \
-	timers.o \
-	xtensa_context.o \
-	xtensa_init.o \
-	xtensa_intr_asm.o \
-	xtensa_intr.o \
-	xtensa_overlay_os_hook.o \
-	xtensa_vector_defaults.o \
-	xtensa_vectors.o \
-	)
+$(BUILD)/$(ESPCOMP)/freertos/%.o: CFLAGS = $(CFLAGS_BASE) -I. -I$(BUILD) $(INC_ESPCOMP) $(INC_NEWLIB) -I$(ESPCOMP)/freertos/include/freertos -D_ESP_FREERTOS_INTERNAL
+ESPIDF_FREERTOS_O = \
+	$(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/freertos/*.c)) \
+	$(patsubst %.S,%.o,$(wildcard $(ESPCOMP)/freertos/*.S)) \
 
-ESPIDF_VFS_O = $(addprefix $(ESPCOMP)/vfs/,\
-	vfs_uart.o \
-	vfs.o \
-	)
+ESPIDF_VFS_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/vfs/*.c))
 
-ESPIDF_JSON_O = $(addprefix $(ESPCOMP)/json/cJSON/,\
-	cJSON.o \
-	cJSON_Utils.o \
-	)
+ESPIDF_LOG_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/log/*.c))
 
-ESPIDF_LOG_O = $(addprefix $(ESPCOMP)/log/,\
-	log.o \
-	)
+ESPIDF_XTENSA_DEBUG_MODULE_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/xtensa-debug-module/*.c))
 
-ESPIDF_XTENSA_DEBUG_MODULE_O = $(addprefix $(ESPCOMP)/xtensa-debug-module/,\
-	eri.o \
-	trax.o \
-	)
+ESPIDF_TCPIP_ADAPTER_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/tcpip_adapter/*.c))
 
-ESPIDF_TCPIP_ADAPTER_O = $(addprefix $(ESPCOMP)/tcpip_adapter/,\
-	tcpip_adapter_lwip.o \
-	)
+ESPIDF_APP_TRACE_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/app_trace/*.c))
 
-ESPIDF_APP_TRACE_O = $(addprefix $(ESPCOMP)/app_trace/,\
-	app_trace.o \
-	)
+ESPIDF_APP_UPDATE_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/app_update/*.c))
 
-ESPIDF_APP_UPDATE_O = $(addprefix $(ESPCOMP)/app_update/,\
-	esp_app_desc.o \
-	esp_ota_ops.o \
-	)
+ESPIDF_NEWLIB_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/newlib/*.c))
 
-ESPIDF_NEWLIB_O = $(addprefix $(ESPCOMP)/newlib/,\
-	time.o \
-	select.o \
-	syscalls.o \
-	syscall_table.o \
-	reent_init.o \
-	locks.o \
-	)
+$(BUILD)/$(ESPCOMP)/nvs_flash/src/nvs_api.o: CXXFLAGS += -Wno-error=sign-compare
+ESPIDF_NVS_FLASH_O = $(patsubst %.cpp,%.o,$(wildcard $(ESPCOMP)/nvs_flash/src/*.cpp))
 
-ESPIDF_NGHTTP_O = $(addprefix $(ESPCOMP)/nghttp/,\
-	nghttp2/lib/nghttp2_http.o \
-	nghttp2/lib/nghttp2_version.o \
-	nghttp2/lib/nghttp2_mem.o \
-	nghttp2/lib/nghttp2_hd_huffman.o \
-	nghttp2/lib/nghttp2_rcbuf.o \
-	nghttp2/lib/nghttp2_callbacks.o \
-	nghttp2/lib/nghttp2_session.o \
-	nghttp2/lib/nghttp2_stream.o \
-	nghttp2/lib/nghttp2_hd.o \
-	nghttp2/lib/nghttp2_priority_spec.o \
-	nghttp2/lib/nghttp2_buf.o \
-	nghttp2/lib/nghttp2_option.o \
-	nghttp2/lib/nghttp2_npn.o \
-	nghttp2/lib/nghttp2_helper.o \
-	nghttp2/lib/nghttp2_frame.o \
-	nghttp2/lib/nghttp2_outbound_item.o \
-	nghttp2/lib/nghttp2_hd_huffman_data.o \
-	nghttp2/lib/nghttp2_pq.o \
-	nghttp2/lib/nghttp2_queue.o \
-	nghttp2/lib/nghttp2_submit.o \
-	nghttp2/lib/nghttp2_map.o \
-	port/http_parser.o \
-	)
+ESPIDF_SMARTCONFIG_ACK_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/smartconfig_ack/*.c))
 
-ESPIDF_NVS_FLASH_O = $(addprefix $(ESPCOMP)/nvs_flash/,\
-	src/nvs_ops.o \
-	src/nvs_types.o \
-	src/nvs_page.o \
-	src/nvs_item_hash_list.o \
-	src/nvs_pagemanager.o \
-	src/nvs_storage.o \
-	src/nvs_api.o \
-	)
+ESPIDF_SPI_FLASH_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/spi_flash/*.c))
 
-ESPIDF_OPENSSL_O = $(addprefix $(ESPCOMP)/openssl/,\
-	)
+ESPIDF_ULP_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/ulp/*.c))
 
-ESPIDF_SMARTCONFIG_ACK_O = $(addprefix $(ESPCOMP)/smartconfig_ack/,\
-	smartconfig_ack.o \
+$(BUILD)/$(ESPCOMP)/lwip/%.o: CFLAGS += -Wno-address -Wno-unused-variable -Wno-unused-but-set-variable
+ESPIDF_LWIP_O = $(patsubst %.c,%.o,\
+	$(wildcard $(ESPCOMP)/lwip/apps/dhcpserver/*.c) \
+	$(wildcard $(ESPCOMP)/lwip/lwip/src/api/*.c) \
+	$(wildcard $(ESPCOMP)/lwip/lwip/src/apps/sntp/*.c) \
+	$(wildcard $(ESPCOMP)/lwip/lwip/src/core/*.c) \
+	$(wildcard $(ESPCOMP)/lwip/lwip/src/core/*/*.c) \
+	$(wildcard $(ESPCOMP)/lwip/lwip/src/netif/*.c) \
+	$(wildcard $(ESPCOMP)/lwip/lwip/src/netif/*/*.c) \
+	$(wildcard $(ESPCOMP)/lwip/lwip/src/netif/*/*/*.c) \
+	$(wildcard $(ESPCOMP)/lwip/port/esp32/*.c) \
+	$(wildcard $(ESPCOMP)/lwip/port/esp32/*/*.c) \
 	)
 
-ESPIDF_SPI_FLASH_O = $(addprefix $(ESPCOMP)/spi_flash/,\
-	flash_mmap.o \
-	partition.o \
-	spi_flash_rom_patch.o \
-	cache_utils.o \
-	flash_ops.o \
+ESPIDF_MBEDTLS_O = $(patsubst %.c,%.o,\
+	$(wildcard $(ESPCOMP)/mbedtls/mbedtls/library/*.c) \
+	$(wildcard $(ESPCOMP)/mbedtls/port/*.c) \
+	$(wildcard $(ESPCOMP)/mbedtls/port/esp32/*.c) \
 	)
 
-ESPIDF_ULP_O = $(addprefix $(ESPCOMP)/ulp/,\
-	ulp.o \
-	)
+ESPIDF_MDNS_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/mdns/*.c))
 
-$(BUILD)/$(ESPCOMP)/lwip/%.o: CFLAGS += -Wno-address -Wno-unused-variable -Wno-unused-but-set-variable
-ESPIDF_LWIP_O = $(addprefix $(ESPCOMP)/lwip/,\
-	apps/dhcpserver/dhcpserver.o \
-	lwip/src/api/netbuf.o \
-	lwip/src/api/api_lib.o \
-	lwip/src/api/netifapi.o \
-	lwip/src/api/tcpip.o \
-	lwip/src/api/netdb.o \
-	lwip/src/api/err.o \
-	lwip/src/api/api_msg.o \
-	lwip/src/api/sockets.o \
-	lwip/src/apps/sntp/sntp.o \
-	lwip/src/core/ipv4/dhcp.o \
-	lwip/src/core/ipv4/etharp.o \
-	lwip/src/core/ipv4/ip4_addr.o \
-	lwip/src/core/ipv4/igmp.o \
-	lwip/src/core/ipv4/ip4.o \
-	lwip/src/core/ipv4/autoip.o \
-	lwip/src/core/ipv4/icmp.o \
-	lwip/src/core/ipv6/ip6_frag.o \
-	lwip/src/core/ipv6/dhcp6.o \
-	lwip/src/core/ipv6/inet6.o \
-	lwip/src/core/ipv6/ip6_addr.o \
-	lwip/src/core/ipv6/ip6.o \
-	lwip/src/core/ipv6/nd6.o \
-	lwip/src/core/ipv6/mld6.o \
-	lwip/src/core/ipv6/ethip6.o \
-	lwip/src/core/ipv6/icmp6.o \
-	lwip/src/core/mem.o \
-	lwip/src/core/init.o \
-	lwip/src/core/memp.o \
-	lwip/src/core/sys.o \
-	lwip/src/core/tcp_in.o \
-	lwip/src/core/timeouts.o \
-	lwip/src/core/dns.o \
-	lwip/src/core/ip.o \
-	lwip/src/core/pbuf.o \
-	lwip/src/core/raw.o \
-	lwip/src/core/tcp.o \
-	lwip/src/core/def.o \
-	lwip/src/core/netif.o \
-	lwip/src/core/stats.o \
-	lwip/src/core/inet_chksum.o \
-	lwip/src/core/udp.o \
-	lwip/src/core/tcp_out.o \
-	lwip/src/netif/slipif.o \
-	lwip/src/netif/ethernet.o \
-	lwip/src/netif/lowpan6.o \
-	lwip/src/netif/ethernetif.o \
-	lwip/src/netif/ppp/auth.o \
-	lwip/src/netif/ppp/chap-md5.o \
-	lwip/src/netif/ppp/chap-new.o \
-	lwip/src/netif/ppp/fsm.o \
-	lwip/src/netif/ppp/ipcp.o \
-	lwip/src/netif/ppp/ipv6cp.o \
-	lwip/src/netif/ppp/lcp.o \
-	lwip/src/netif/ppp/magic.o \
-	lwip/src/netif/ppp/polarssl/md5.o \
-	lwip/src/netif/ppp/ppp.o \
-	lwip/src/netif/ppp/pppapi.o \
-	lwip/src/netif/ppp/pppos.o \
-	lwip/src/netif/ppp/upap.o \
-	lwip/src/netif/ppp/utils.o \
-	lwip/src/netif/ppp/vj.o \
-	port/esp32/freertos/sys_arch.o \
-	port/esp32/netif/ethernetif.o \
-	port/esp32/netif/wlanif.o \
-	port/esp32/vfs_lwip.o \
+ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V4))
+$(BUILD)/$(ESPCOMP)/wpa_supplicant/%.o: CFLAGS += -DESP_SUPPLICANT -DIEEE8021X_EAPOL -DEAP_PEER_METHOD -DEAP_TLS -DEAP_TTLS -DEAP_PEAP -DEAP_MSCHAPv2 -DUSE_WPA2_TASK -DCONFIG_WPS2 -DCONFIG_WPS_PIN -DUSE_WPS_TASK -DESPRESSIF_USE -DESP32_WORKAROUND -DCONFIG_ECC -D__ets__ -Wno-strict-aliasing -I$(ESPCOMP)/wpa_supplicant/src -Wno-implicit-function-declaration
+else
+$(BUILD)/$(ESPCOMP)/wpa_supplicant/%.o: CFLAGS += -DEMBEDDED_SUPP -DIEEE8021X_EAPOL -DEAP_PEER_METHOD -DEAP_MSCHAPv2 -DEAP_TTLS -DEAP_TLS -DEAP_PEAP -DUSE_WPA2_TASK -DCONFIG_WPS2 -DCONFIG_WPS_PIN -DUSE_WPS_TASK -DESPRESSIF_USE -DESP32_WORKAROUND -DALLOW_EVEN_MOD -D__ets__ -Wno-strict-aliasing
+endif
+ESPIDF_WPA_SUPPLICANT_O = $(patsubst %.c,%.o,\
+	$(wildcard $(ESPCOMP)/wpa_supplicant/port/*.c) \
+	$(wildcard $(ESPCOMP)/wpa_supplicant/src/*/*.c) \
+	)
+
+ESPIDF_SDMMC_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/sdmmc/*.c))
+
+ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V4))
+ESPIDF_ESP_COMMON_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/esp_common/src/*.c))
+
+ESPIDF_ESP_EVENT_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/esp_event/*.c))
+
+ESPIDF_ESP_WIFI_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/esp_wifi/src/*.c))
+
+ifeq ($(CONFIG_BT_NIMBLE_ENABLED),y)
+ESPIDF_BT_NIMBLE_O = $(patsubst %.c,%.o,\
+	$(wildcard $(ESPCOMP)/bt/controller/*.c) \
+	$(wildcard $(ESPCOMP)/bt/common/btc/core/*.c) \
+	$(wildcard $(ESPCOMP)/bt/common/osi/*.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/esp-hci/src/*.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/ext/tinycrypt/src/*.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/nimble/host/services/ans/src/*.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/nimble/host/services/bas/src/*.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/nimble/host/services/gap/src/*.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/nimble/host/services/gatt/src/*.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/nimble/host/services/ias/src/*.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/nimble/host/services/lls/src/*.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/nimble/host/services/tps/src/*.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/nimble/host/src/*.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/nimble/host/store/config/src/ble_store_config.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/nimble/host/store/config/src/ble_store_nvs.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/nimble/host/store/ram/src/*.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/nimble/host/util/src/*.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/nimble/src/*.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/porting/nimble/src/*.c) \
+	$(wildcard $(ESPCOMP)/bt/host/nimble/nimble/porting/npl/freertos/src/*.c) \
 	)
+endif
 
-ESPIDF_MBEDTLS_O = $(addprefix $(ESPCOMP)/mbedtls/,\
-	mbedtls/library/entropy.o \
-	mbedtls/library/pkcs12.o \
-	mbedtls/library/ccm.o \
-	mbedtls/library/pk.o \
-	mbedtls/library/sha1.o \
-	mbedtls/library/x509_csr.o \
-	mbedtls/library/ssl_cli.o \
-	mbedtls/library/ecp.o \
-	mbedtls/library/blowfish.o \
-	mbedtls/library/x509.o \
-	mbedtls/library/ecp_curves.o \
-	mbedtls/library/error.o \
-	mbedtls/library/ssl_ticket.o \
-	mbedtls/library/entropy_poll.o \
-	mbedtls/library/cipher.o \
-	mbedtls/library/version_features.o \
-	mbedtls/library/ripemd160.o \
-	mbedtls/library/rsa.o \
-	mbedtls/library/rsa_internal.o \
-	mbedtls/library/md.o \
-	mbedtls/library/md_wrap.o \
-	mbedtls/library/sha256.o \
-	mbedtls/library/dhm.o \
-	mbedtls/library/ssl_cache.o \
-	mbedtls/library/pkwrite.o \
-	mbedtls/library/base64.o \
-	mbedtls/library/asn1parse.o \
-	mbedtls/library/ssl_tls.o \
-	mbedtls/library/hmac_drbg.o \
-	mbedtls/library/pem.o \
-	mbedtls/library/version.o \
-	mbedtls/library/gcm.o \
-	mbedtls/library/memory_buffer_alloc.o \
-	mbedtls/library/md2.o \
-	mbedtls/library/ecdsa.o \
-	mbedtls/library/ssl_srv.o \
-	mbedtls/library/x509_crt.o \
-	mbedtls/library/ecdh.o \
-	mbedtls/library/asn1write.o \
-	mbedtls/library/md4.o \
-	mbedtls/library/debug.o \
-	mbedtls/library/x509_create.o \
-	mbedtls/library/ecjpake.o \
-	mbedtls/library/oid.o \
-	mbedtls/library/md5.o \
-	mbedtls/library/ssl_ciphersuites.o \
-	mbedtls/library/sha512.o \
-	mbedtls/library/xtea.o \
-	mbedtls/library/aes.o \
-	mbedtls/library/cipher_wrap.o \
-	mbedtls/library/arc4.o \
-	mbedtls/library/bignum.o \
-	mbedtls/library/pkparse.o \
-	mbedtls/library/padlock.o \
-	mbedtls/library/threading.o \
-	mbedtls/library/x509_crl.o \
-	mbedtls/library/pkcs11.o \
-	mbedtls/library/aesni.o \
-	mbedtls/library/timing.o \
-	mbedtls/library/certs.o \
-	mbedtls/library/pkcs5.o \
-	mbedtls/library/ssl_cookie.o \
-	mbedtls/library/camellia.o \
-	mbedtls/library/havege.o \
-	mbedtls/library/des.o \
-	mbedtls/library/x509write_csr.o \
-	mbedtls/library/platform.o \
-	mbedtls/library/platform_util.o \
-	mbedtls/library/ctr_drbg.o \
-	mbedtls/library/x509write_crt.o \
-	mbedtls/library/pk_wrap.o \
-	port/esp_bignum.o \
-	port/esp_hardware.o \
-	port/esp_mem.o \
-	port/esp_sha1.o \
-	port/esp_sha256.o \
-	port/esp_sha512.o \
-	)
+$(BUILD)/$(ESPCOMP)/esp_eth/src/esp_eth_mac_dm9051.o: CFLAGS += -fno-strict-aliasing
+ESPIDF_ESP_ETH_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/esp_eth/src/*.c))
 
-$(BUILD)/$(ESPCOMP)/wpa_supplicant/%.o: CFLAGS += -DEMBEDDED_SUPP -DIEEE8021X_EAPOL -DEAP_PEER_METHOD -DEAP_MSCHAPv2 -DEAP_TTLS -DEAP_TLS -DEAP_PEAP -DUSE_WPA2_TASK -DCONFIG_WPS2 -DCONFIG_WPS_PIN -DUSE_WPS_TASK -DESPRESSIF_USE -DESP32_WORKAROUND -D__ets__ -Wno-strict-aliasing
-ESPIDF_WPA_SUPPLICANT_O = $(addprefix $(ESPCOMP)/wpa_supplicant/,\
-	src/crypto/aes-internal-enc.o \
-	src/crypto/sha256-internal.o \
-	src/crypto/md5-internal.o \
-	src/crypto/aes-internal.o \
-	src/crypto/sha1.o \
-	src/crypto/aes-internal-dec.o \
-	src/crypto/aes-unwrap.o \
-	src/crypto/crypto_internal-rsa.o \
-	src/crypto/dh_groups.o \
-	src/crypto/crypto_internal.o \
-	src/crypto/aes-wrap.o \
-	src/crypto/sha1-internal.o \
-	src/crypto/dh_group5.o \
-	src/crypto/sha256.o \
-	src/crypto/rc4.o \
-	src/crypto/md5.o \
-	src/crypto/aes-cbc.o \
-	src/crypto/sha1-pbkdf2.o \
-	src/crypto/bignum.o \
-	src/crypto/crypto_internal-modexp.o \
-	src/crypto/crypto_internal-cipher.o \
-	src/fast_crypto/fast_aes-unwrap.o \
-	src/fast_crypto/fast_aes-wrap.o \
-	src/fast_crypto/fast_sha256.o \
-	src/fast_crypto/fast_sha256-internal.o \
-	port/os_xtensa.o \
+ESPIDF_XTENSA_O = $(patsubst %.c,%.o,\
+    $(wildcard $(ESPCOMP)/xtensa/*.c) \
+    $(wildcard $(ESPCOMP)/xtensa/esp32/*.c) \
+    )
+else
+ESPIDF_JSON_O = $(patsubst %.c,%.o,$(wildcard $(ESPCOMP)/json/cJSON/cJSON*.c))
+
+ESPIDF_ETHERNET_O = $(patsubst %.c,%.o,\
+    $(wildcard $(ESPCOMP)/ethernet/*.c) \
+    $(wildcard $(ESPCOMP)/ethernet/eth_phy/*.c) \
+    )
+
+ifeq ($(CONFIG_NIMBLE_ENABLED),y)
+ESPIDF_BT_NIMBLE_O = $(patsubst %.c,%.o,\
+	$(wildcard $(ESPCOMP)/bt/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/esp-hci/src/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/ext/tinycrypt/src/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/nimble/host/services/ans/src/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/nimble/host/services/bas/src/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/nimble/host/services/gap/src/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/nimble/host/services/gatt/src/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/nimble/host/services/ias/src/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/nimble/host/services/lls/src/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/nimble/host/services/tps/src/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/nimble/host/src/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/nimble/host/store/config/src/ble_store_config.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/nimble/host/store/config/src/ble_store_nvs.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/nimble/host/store/ram/src/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/nimble/host/util/src/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/nimble/src/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/porting/nimble/src/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/nimble/porting/npl/freertos/src/*.c) \
+	$(wildcard $(ESPCOMP)/nimble/port/src/*.c) \
 	)
+endif
+endif
 
 OBJ_ESPIDF =
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_NEWLIB_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_DRIVER_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_ESP32_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_ESP_RINGBUF_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_HEAP_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_SOC_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_CXX_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_ETHERNET_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_EXPAT_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_PTHREAD_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_FREERTOS_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_VFS_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_JSON_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_LOG_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_LWIP_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_MBEDTLS_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_XTENSA_DEBUG_MODULE_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_TCPIP_ADAPTER_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_APP_TRACE_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_APP_UPDATE_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_NGHTTP_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_NVS_FLASH_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_OPENSSL_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_SMARTCONFIG_ACK_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_SPI_FLASH_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_ULP_O))
-OBJ_ESPIDF += $(addprefix $(BUILD)/, $(ESPIDF_WPA_SUPPLICANT_O))
-
-$(OBJ_ESPIDF): $(SDKCONFIG_H)
-
 LIB_ESPIDF =
-LIB_ESPIDF += driver
-LIB_ESPIDF += esp32
-LIB_ESPIDF += esp_ringbuf
-LIB_ESPIDF += heap
-LIB_ESPIDF += soc
-LIB_ESPIDF += cxx
-LIB_ESPIDF += ethernet
-LIB_ESPIDF += expat
-LIB_ESPIDF += pthread
-LIB_ESPIDF += freertos
-LIB_ESPIDF += vfs
-LIB_ESPIDF += json
-LIB_ESPIDF += log
-LIB_ESPIDF += xtensa-debug-module
-LIB_ESPIDF += tcpip_adapter
-LIB_ESPIDF += app_trace
-LIB_ESPIDF += app_update
-LIB_ESPIDF += newlib
-LIB_ESPIDF += nghttp
-LIB_ESPIDF += nvs_flash
-LIB_ESPIDF += smartconfig_ack
-LIB_ESPIDF += spi_flash
-LIB_ESPIDF += ulp
-LIB_ESPIDF += lwip
-LIB_ESPIDF += mbedtls
-LIB_ESPIDF += wpa_supplicant
-
 BUILD_ESPIDF_LIB = $(BUILD)/esp-idf
 
-OBJ_ESPIDF_DIRS = $(sort $(dir $(OBJ_ESPIDF))) $(BUILD_ESPIDF_LIB) $(addprefix $(BUILD_ESPIDF_LIB)/,$(LIB_ESPIDF))
-$(OBJ_ESPIDF): | $(OBJ_ESPIDF_DIRS)
-$(OBJ_ESPIDF_DIRS):
-	$(MKDIR) -p $@
-
 define gen_espidf_lib_rule
+OBJ_ESPIDF += $(addprefix $$(BUILD)/,$(2))
+LIB_ESPIDF += $(1)
 $(BUILD_ESPIDF_LIB)/$(1)/lib$(1).a: $(addprefix $$(BUILD)/,$(2))
 	$(ECHO) "AR $$@"
 	$(Q)$(AR) cru $$@ $$^
 endef
 
+$(eval $(call gen_espidf_lib_rule,bootloader_support,$(ESPIDF_BOOTLOADER_SUPPORT_O)))
 $(eval $(call gen_espidf_lib_rule,driver,$(ESPIDF_DRIVER_O)))
+$(eval $(call gen_espidf_lib_rule,efuse,$(ESPIDF_EFUSE_O)))
 $(eval $(call gen_espidf_lib_rule,esp32,$(ESPIDF_ESP32_O)))
 $(eval $(call gen_espidf_lib_rule,esp_ringbuf,$(ESPIDF_ESP_RINGBUF_O)))
 $(eval $(call gen_espidf_lib_rule,heap,$(ESPIDF_HEAP_O)))
 $(eval $(call gen_espidf_lib_rule,soc,$(ESPIDF_SOC_O)))
 $(eval $(call gen_espidf_lib_rule,cxx,$(ESPIDF_CXX_O)))
-$(eval $(call gen_espidf_lib_rule,ethernet,$(ESPIDF_ETHERNET_O)))
-$(eval $(call gen_espidf_lib_rule,expat,$(ESPIDF_EXPAT_O)))
 $(eval $(call gen_espidf_lib_rule,pthread,$(ESPIDF_PTHREAD_O)))
 $(eval $(call gen_espidf_lib_rule,freertos,$(ESPIDF_FREERTOS_O)))
 $(eval $(call gen_espidf_lib_rule,vfs,$(ESPIDF_VFS_O)))
@@ -755,21 +628,69 @@ $(eval $(call gen_espidf_lib_rule,tcpip_adapter,$(ESPIDF_TCPIP_ADAPTER_O)))
 $(eval $(call gen_espidf_lib_rule,app_trace,$(ESPIDF_APP_TRACE_O)))
 $(eval $(call gen_espidf_lib_rule,app_update,$(ESPIDF_APP_UPDATE_O)))
 $(eval $(call gen_espidf_lib_rule,newlib,$(ESPIDF_NEWLIB_O)))
-$(eval $(call gen_espidf_lib_rule,nghttp,$(ESPIDF_NGHTTP_O)))
 $(eval $(call gen_espidf_lib_rule,nvs_flash,$(ESPIDF_NVS_FLASH_O)))
 $(eval $(call gen_espidf_lib_rule,smartconfig_ack,$(ESPIDF_SMARTCONFIG_ACK_O)))
 $(eval $(call gen_espidf_lib_rule,spi_flash,$(ESPIDF_SPI_FLASH_O)))
 $(eval $(call gen_espidf_lib_rule,ulp,$(ESPIDF_ULP_O)))
 $(eval $(call gen_espidf_lib_rule,lwip,$(ESPIDF_LWIP_O)))
 $(eval $(call gen_espidf_lib_rule,mbedtls,$(ESPIDF_MBEDTLS_O)))
+$(eval $(call gen_espidf_lib_rule,mdns,$(ESPIDF_MDNS_O)))
 $(eval $(call gen_espidf_lib_rule,wpa_supplicant,$(ESPIDF_WPA_SUPPLICANT_O)))
+$(eval $(call gen_espidf_lib_rule,sdmmc,$(ESPIDF_SDMMC_O)))
+$(eval $(call gen_espidf_lib_rule,bt_nimble,$(ESPIDF_BT_NIMBLE_O)))
+
+ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V4))
+$(eval $(call gen_espidf_lib_rule,esp_common,$(ESPIDF_ESP_COMMON_O)))
+$(eval $(call gen_espidf_lib_rule,esp_event,$(ESPIDF_ESP_EVENT_O)))
+$(eval $(call gen_espidf_lib_rule,esp_wifi,$(ESPIDF_ESP_WIFI_O)))
+$(eval $(call gen_espidf_lib_rule,esp_eth,$(ESPIDF_ESP_ETH_O)))
+$(eval $(call gen_espidf_lib_rule,xtensa,$(ESPIDF_XTENSA_O)))
+else
+$(eval $(call gen_espidf_lib_rule,ethernet,$(ESPIDF_ETHERNET_O)))
+endif
 
+# Create all destination build dirs before compiling IDF source
+OBJ_ESPIDF_DIRS = $(sort $(dir $(OBJ_ESPIDF))) $(BUILD_ESPIDF_LIB) $(addprefix $(BUILD_ESPIDF_LIB)/,$(LIB_ESPIDF))
+$(OBJ_ESPIDF): | $(OBJ_ESPIDF_DIRS)
+$(OBJ_ESPIDF_DIRS):
+	$(MKDIR) -p $@
+
+# Make all IDF object files depend on sdkconfig
+$(OBJ_ESPIDF): $(SDKCONFIG_H)
+
+# Add all IDF components to the set of libraries
 LIB = $(foreach lib,$(LIB_ESPIDF),$(BUILD_ESPIDF_LIB)/$(lib)/lib$(lib).a)
 
 ################################################################################
 # ESP IDF ldgen
 
 LDGEN_FRAGMENTS = $(shell find $(ESPCOMP) -name "*.lf")
+
+ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V4))
+
+LDGEN_LIBRARIES=$(foreach lib,$(LIB_ESPIDF),$(BUILD_ESPIDF_LIB)/$(lib)/lib$(lib).a)
+
+$(BUILD_ESPIDF_LIB)/ldgen_libraries: $(LDGEN_LIBRARIES) $(ESPIDF)/make/ldgen.mk
+	printf "$(foreach library,$(LDGEN_LIBRARIES),$(library)\n)" > $(BUILD_ESPIDF_LIB)/ldgen_libraries
+
+$(BUILD)/esp32.project.ld: $(ESPCOMP)/esp32/ld/esp32.project.ld.in $(LDGEN_FRAGMENTS) $(SDKCONFIG_COMBINED) $(BUILD_ESPIDF_LIB)/ldgen_libraries
+	$(ECHO) "GEN $@"
+	$(Q)$(PYTHON) $(ESPIDF)/tools/ldgen/ldgen.py \
+		--input $< \
+		--output $@ \
+		--config $(SDKCONFIG_COMBINED) \
+		--kconfig $(ESPIDF)/Kconfig \
+		--fragments $(LDGEN_FRAGMENTS) \
+		--libraries-file $(BUILD_ESPIDF_LIB)/ldgen_libraries \
+		--env "IDF_TARGET=esp32" \
+		--env "IDF_CMAKE=n" \
+		--env "COMPONENT_KCONFIGS=$(ESPCOMP_KCONFIGS)" \
+		--env "COMPONENT_KCONFIGS_PROJBUILD=$(ESPCOMP_KCONFIGS_PROJBUILD)" \
+		--env "IDF_PATH=$(ESPIDF)" \
+		--objdump $(OBJDUMP)
+
+else
+
 LDGEN_SECTIONS_INFO = $(foreach lib,$(LIB_ESPIDF),$(BUILD_ESPIDF_LIB)/$(lib)/lib$(lib).a.sections_info)
 LDGEN_SECTION_INFOS = $(BUILD_ESPIDF_LIB)/ldgen.section_infos
 
@@ -784,19 +705,22 @@ $(eval $(foreach lib,$(LIB_ESPIDF),$(eval $(call gen_sections_info_rule,$(BUILD_
 $(LDGEN_SECTION_INFOS): $(LDGEN_SECTIONS_INFO) $(ESPIDF)/make/ldgen.mk
 	$(Q)printf "$(foreach info,$(LDGEN_SECTIONS_INFO),$(info)\n)" > $@
 
-$(BUILD)/esp32.common.ld: $(ESPCOMP)/esp32/ld/esp32.common.ld.in $(LDGEN_FRAGMENTS) $(SDKCONFIG) $(LDGEN_SECTION_INFOS)
+$(BUILD)/esp32.project.ld: $(ESPCOMP)/esp32/ld/esp32.project.ld.in $(LDGEN_FRAGMENTS) $(SDKCONFIG_COMBINED) $(LDGEN_SECTION_INFOS)
 	$(ECHO) "GEN $@"
 	$(Q)$(PYTHON) $(ESPIDF)/tools/ldgen/ldgen.py \
 		--input $< \
 		--output $@ \
-		--config $(SDKCONFIG) \
+		--config $(SDKCONFIG_COMBINED) \
 		--kconfig $(ESPIDF)/Kconfig \
 		--fragments $(LDGEN_FRAGMENTS) \
 		--sections $(LDGEN_SECTION_INFOS) \
 		--env "IDF_TARGET=esp32" \
 		--env "IDF_CMAKE=n" \
 		--env "COMPONENT_KCONFIGS=$(ESPCOMP_KCONFIGS)" \
-		--env "COMPONENT_KCONFIGS_PROJBUILD=$(ESPCOMP_KCONFIGS_PROJBUILD)"
+		--env "COMPONENT_KCONFIGS_PROJBUILD=$(ESPCOMP_KCONFIGS_PROJBUILD)" \
+		--env "IDF_PATH=$(ESPIDF)"
+
+endif
 
 ################################################################################
 # Main targets
@@ -827,12 +751,20 @@ OBJ = $(OBJ_MP)
 
 APP_LD_ARGS =
 APP_LD_ARGS += $(LDFLAGS_MOD)
+APP_LD_ARGS += $(addprefix -T,$(LD_FILES))
 APP_LD_ARGS += --start-group
 APP_LD_ARGS += -L$(dir $(LIBGCC_FILE_NAME)) -lgcc
 APP_LD_ARGS += -L$(dir $(LIBSTDCXX_FILE_NAME)) -lstdc++
 APP_LD_ARGS += $(LIBC_LIBM)
+ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V4))
+APP_LD_ARGS += -L$(ESPCOMP)/xtensa/esp32 -lhal
+APP_LD_ARGS += -L$(ESPCOMP)/bt/controller/lib -lbtdm_app
+APP_LD_ARGS += -L$(ESPCOMP)/esp_wifi/lib_esp32 -lcore -lmesh -lnet80211 -lphy -lrtc -lpp -lsmartconfig -lcoexist
+else
 APP_LD_ARGS += $(ESPCOMP)/esp32/libhal.a
+APP_LD_ARGS += -L$(ESPCOMP)/bt/lib -lbtdm_app
 APP_LD_ARGS += -L$(ESPCOMP)/esp32/lib -lcore -lmesh -lnet80211 -lphy -lrtc -lpp -lwpa -lsmartconfig -lcoexist -lwps -lwpa2
+endif
 APP_LD_ARGS += $(OBJ)
 APP_LD_ARGS += $(LIB)
 APP_LD_ARGS += --end-group
@@ -844,7 +776,7 @@ $(BUILD)/application.bin: $(BUILD)/application.elf
 	$(ECHO) "Create $@"
 	$(Q)$(ESPTOOL) --chip esp32 elf2image --flash_mode $(FLASH_MODE) --flash_freq $(FLASH_FREQ) --flash_size $(FLASH_SIZE) $<
 
-$(BUILD)/application.elf: $(OBJ) $(LIB) $(BUILD)/esp32_out.ld $(BUILD)/esp32.common.ld
+$(BUILD)/application.elf: $(OBJ) $(LIB) $(BUILD)/esp32_out.ld $(BUILD)/esp32.project.ld
 	$(ECHO) "LINK $@"
 	$(Q)$(LD) $(LDFLAGS) -o $@ $(APP_LD_ARGS)
 	$(Q)$(SIZE) $@
@@ -871,7 +803,14 @@ $(BUILD)/%.o: %.cpp
 BOOTLOADER_LIB_DIR = $(BUILD)/bootloader
 BOOTLOADER_LIB_ALL =
 
-$(BUILD)/bootloader/$(ESPCOMP)/%.o: CFLAGS += -DBOOTLOADER_BUILD=1 -I$(ESPCOMP)/bootloader_support/include_priv -I$(ESPCOMP)/bootloader_support/include -I$(ESPCOMP)/micro-ecc/micro-ecc -I$(ESPCOMP)/esp32 -Wno-error=format
+ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V4))
+$(BUILD)/bootloader/$(ESPCOMP)/%.o: CFLAGS += -DBOOTLOADER_BUILD=1 -I$(ESPCOMP)/bootloader_support/include_priv -I$(ESPCOMP)/bootloader_support/include -I$(ESPCOMP)/efuse/include -I$(ESPCOMP)/esp_rom/include -Wno-error=format \
+	-I$(ESPCOMP)/esp_common/include \
+	-I$(ESPCOMP)/xtensa/include \
+	-I$(ESPCOMP)/xtensa/esp32/include
+else
+$(BUILD)/bootloader/$(ESPCOMP)/%.o: CFLAGS += -DBOOTLOADER_BUILD=1 -I$(ESPCOMP)/bootloader_support/include_priv -I$(ESPCOMP)/bootloader_support/include -I$(ESPCOMP)/micro-ecc/micro-ecc -I$(ESPCOMP)/efuse/include -I$(ESPCOMP)/esp32 -Wno-error=format
+endif
 
 # libbootloader_support.a
 BOOTLOADER_LIB_ALL += bootloader_support
@@ -879,18 +818,30 @@ BOOTLOADER_LIB_BOOTLOADER_SUPPORT_OBJ = $(addprefix $(BUILD)/bootloader/$(ESPCOM
 	bootloader_support/src/bootloader_clock.o \
 	bootloader_support/src/bootloader_common.o \
 	bootloader_support/src/bootloader_flash.o \
+	bootloader_support/src/bootloader_flash_config.o \
 	bootloader_support/src/bootloader_init.o \
 	bootloader_support/src/bootloader_random.o \
-	bootloader_support/src/bootloader_sha.o \
 	bootloader_support/src/bootloader_utility.o \
-	bootloader_support/src/efuse.o \
 	bootloader_support/src/flash_qio_mode.o \
-	bootloader_support/src/secure_boot_signatures.o \
-	bootloader_support/src/secure_boot.o \
 	bootloader_support/src/esp_image_format.o \
 	bootloader_support/src/flash_encrypt.o \
 	bootloader_support/src/flash_partitions.o \
 	)
+
+ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V4))
+BOOTLOADER_LIB_BOOTLOADER_SUPPORT_OBJ += $(addprefix $(BUILD)/bootloader/$(ESPCOMP)/,\
+	bootloader_support/src/esp32/bootloader_sha.o \
+	bootloader_support/src/bootloader_flash_config.o \
+	bootloader_support/src/esp32/secure_boot.o \
+	)
+else
+BOOTLOADER_LIB_BOOTLOADER_SUPPORT_OBJ += $(addprefix $(BUILD)/bootloader/$(ESPCOMP)/,\
+	bootloader_support/src/bootloader_sha.o \
+	bootloader_support/src/secure_boot_signatures.o \
+	bootloader_support/src/secure_boot.o \
+	)
+endif
+
 $(BOOTLOADER_LIB_DIR)/libbootloader_support.a: $(BOOTLOADER_LIB_BOOTLOADER_SUPPORT_OBJ)
 	$(ECHO) "AR $@"
 	$(Q)$(AR) cr $@ $^
@@ -913,6 +864,7 @@ $(BOOTLOADER_LIB_DIR)/libspi_flash.a: $(BOOTLOADER_LIB_SPI_FLASH_OBJ)
 	$(ECHO) "AR $@"
 	$(Q)$(AR) cr $@ $^
 
+ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V3))
 # libmicro-ecc.a
 BOOTLOADER_LIB_ALL += micro-ecc
 BOOTLOADER_LIB_MICRO_ECC_OBJ = $(addprefix $(BUILD)/bootloader/$(ESPCOMP)/,\
@@ -921,6 +873,7 @@ BOOTLOADER_LIB_MICRO_ECC_OBJ = $(addprefix $(BUILD)/bootloader/$(ESPCOMP)/,\
 $(BOOTLOADER_LIB_DIR)/libmicro-ecc.a: $(BOOTLOADER_LIB_MICRO_ECC_OBJ)
 	$(ECHO) "AR $@"
 	$(Q)$(AR) cr $@ $^
+endif
 
 # libsoc.a
 $(BUILD)/bootloader/$(ESPCOMP)/soc/esp32/rtc_clk.o: CFLAGS += -fno-jump-tables -fno-tree-switch-conversion
@@ -970,7 +923,11 @@ BOOTLOADER_LIBS =
 BOOTLOADER_LIBS += -Wl,--start-group
 BOOTLOADER_LIBS += $(BOOTLOADER_OBJ)
 BOOTLOADER_LIBS += -L$(BUILD)/bootloader $(addprefix -l,$(BOOTLOADER_LIB_ALL))
+ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V4))
+BOOTLOADER_LIBS += -L$(ESPCOMP)/esp_wifi/lib_esp32 -lrtc
+else
 BOOTLOADER_LIBS += -L$(ESPCOMP)/esp32/lib -lrtc
+endif
 BOOTLOADER_LIBS += -L$(dir $(LIBGCC_FILE_NAME)) -lgcc
 BOOTLOADER_LIBS += -Wl,--end-group
 
@@ -985,8 +942,13 @@ BOOTLOADER_LDFLAGS += -Wl,-EL
 BOOTLOADER_LDFLAGS += -Wl,-Map=$(@:.elf=.map) -Wl,--cref
 BOOTLOADER_LDFLAGS += -T $(ESPCOMP)/bootloader/subproject/main/esp32.bootloader.ld
 BOOTLOADER_LDFLAGS += -T $(ESPCOMP)/bootloader/subproject/main/esp32.bootloader.rom.ld
+ifeq ($(ESPIDF_CURHASH),$(ESPIDF_SUPHASH_V4))
+BOOTLOADER_LDFLAGS += -T $(ESPCOMP)/esp_rom/esp32/ld/esp32.rom.ld
+BOOTLOADER_LDFLAGS += -T $(ESPCOMP)/esp_rom/esp32/ld/esp32.rom.newlib-funcs.ld
+else
 BOOTLOADER_LDFLAGS += -T $(ESPCOMP)/esp32/ld/esp32.rom.ld
 BOOTLOADER_LDFLAGS += -T $(ESPCOMP)/esp32/ld/esp32.rom.spiram_incompatible_fns.ld
+endif
 BOOTLOADER_LDFLAGS += -T $(ESPCOMP)/esp32/ld/esp32.peripherals.ld
 
 BOOTLOADER_OBJ_DIRS = $(sort $(dir $(BOOTLOADER_OBJ_ALL)))
@@ -1009,7 +971,9 @@ $(BUILD)/bootloader.elf: $(BOOTLOADER_OBJ) $(addprefix $(BOOTLOADER_LIB_DIR)/lib
 # Declarations to build the partitions
 
 PYTHON2 ?= python2
-PART_SRC = partitions.csv
+
+# Can be overriden by mkconfigboard.mk.
+PART_SRC ?= partitions.csv
 
 $(BUILD)/partitions.bin: $(PART_SRC)
 	$(ECHO) "Create $@"
diff --git a/ports/esp32/README.md b/ports/esp32/README.md
index 0e6531db820cf..54fb41cf6f390 100644
--- a/ports/esp32/README.md
+++ b/ports/esp32/README.md
@@ -26,82 +26,169 @@ There are two main components that are needed to build the firmware:
   different to the compiler used by the ESP8266)
 - the Espressif IDF (IoT development framework, aka SDK)
 
-The ESP-IDF changes quickly and MicroPython only supports a certain version. The
-git hash of this version can be found by running `make` without a configured
-`ESPIDF`. Then you can fetch only the given esp-idf using the following command:
-
-    $ git clone https://github.com/espressif/esp-idf.git
-    $ git checkout <Current supported ESP-IDF commit hash>
-    $ git submodule update --init --recursive
-
-The binary toolchain (binutils, gcc, etc.) can be installed using the following
-guides:
-
-  * [Linux installation](https://esp-idf.readthedocs.io/en/latest/get-started/linux-setup.html)
-  * [MacOS installation](https://esp-idf.readthedocs.io/en/latest/get-started/macos-setup.html)
-  * [Windows installation](https://esp-idf.readthedocs.io/en/latest/get-started/windows-setup.html)
-
-If you are on a Windows machine then the
-[Windows Subsystem for Linux](https://msdn.microsoft.com/en-au/commandline/wsl/install_guide)
-is the most efficient way to install the ESP32 toolchain and build the project.
-If you use WSL then follow the
-[Linux guidelines](https://esp-idf.readthedocs.io/en/latest/get-started/linux-setup.html)
-for the ESP-IDF instead of the Windows ones.
-
-The Espressif ESP-IDF instructions above only install pyserial for Python 2,
-so if you're running Python 3 or a non-system Python you'll also need to
-install `pyserial` (or `esptool`) so that the Makefile can flash the board
-and set parameters:
+If you are on a Windows machine then the [Windows Subsystem for
+Linux](https://msdn.microsoft.com/en-au/commandline/wsl/install_guide) is the
+most efficient way to install the ESP32 toolchain and build the project. If
+you use WSL then follow the Linux instructions rather than the Windows
+instructions.
+
+The ESP-IDF changes quickly and MicroPython only supports certain versions.
+The git hash of these versions (one for 3.x, one for 4.x) can be found by
+running `make` without a configured `ESPIDF`. Then you can fetch the
+required IDF using the following command:
+
+```bash
+$ cd ports/esp32
+$ make ESPIDF=  # This will print the supported hashes, copy the one you want.
+$ export ESPIDF=$HOME/src/github.com/espressif/esp-idf  # Or any path you like.
+$ mkdir -p $ESPIDF
+$ cd $ESPIDF
+$ git clone https://github.com/espressif/esp-idf.git $ESPIDF
+$ git checkout <Current supported ESP-IDF commit hash>
+$ git submodule update --init --recursive
+```
+
+Note: The ESP IDF v4.x support is currently experimental. It does not
+currently support PPP or wired Ethernet.
+
+Python dependencies
+===================
+
+You will also need other dependencies from the IDF, see
+`$ESPIDF/requirements.txt`, but at a minimum you need `pyserial>=3.0` and
+`pyparsing>=2.0.3,<2.4.0`.
+
+You can use Python 2 or Python 3. If you need to override the system default
+add (for example) `PYTHON=python3` to any of the `make` commands below.
+
+It is recommended to use a Python virtual environment. Even if your system
+package manager already provides these libraries, the IDF v4.x is currently
+incompatible with pyparsing 2.4 and higher.
+
+For example, to set up a Python virtual environment from scratch:
+
+```bash
+$ cd ports/esp32
+$ python3 -m venv build-venv
+$ source build-venv/bin/activate
+$ pip install --upgrade pip
+$ pip install -r path/to/esp-idf/requirements.txt
+```
+
+To re-enter this virtual environment in future sessions, you only need to
+source the `activate` script, i.e.:
+
+```bash
+$ cd ports/esp32
+$ source build-venv/bin/activate
+```
+
+Then, to install the toolchain (which includes the GCC compiler, linker, binutils,
+etc), there are two options:
+
+1. Using the IDF scripts to install the toolchain (IDF 4.x only)
+================================================================
+
+Follow the steps at the [Espressif Getting Started guide](https://docs.espressif.com/projects/esp-idf/en/v4.0/get-started/index.html#step-3-set-up-the-tools).
+
+This will guide you through using the `install.sh` (or `install.bat`) script
+to download the toolchain and add it to your `PATH`. The steps are summarised
+below:
+
+After you've cloned and checked out the IDF to the correct version (see
+above), run the `install.sh` script:
+
+```bash
+$ cd $ESPIDF
+$ ./install.sh    # (or install.bat on Windows)
+```
+
+Then in the `ports/esp32` directory, source the `export.sh` script to set the
+`PATH`.
+
 ```bash
-$ pip install pyserial
+$ cd micropython/ports/esp32
+$ source $ESPIDF/export.sh   # (or path\to\esp-idf\export.bat on Windows)
+$ # Run make etc, see below.
 ```
 
-Once everything is set up you should have a functioning toolchain with
-prefix xtensa-esp32-elf- (or otherwise if you configured it differently)
-as well as a copy of the ESP-IDF repository. You will need to update your `PATH`
-environment variable to include the ESP32 toolchain. For example, you can issue
-the following commands on (at least) Linux:
+The `install.sh` step only needs to be done once. You will need to source
+`export.sh` for every new session.
+
+Note: If you get an error about `--no-site-packages`, then modify
+`$ESPIDF/tools/idf_tools.py` and make the same change as [this
+commit](https://github.com/espressif/esp-idf/commit/7a18f02acd7005f7c56e62175a8d1968a1a9019d).
+
+2. or, Downloading pre-built toolchain manually (IDF 3.x and 4.x)
+=============================================================
+
+Note: while this works with 4.x, if you're using the 4.x IDF, it's much
+simpler to use the guide above, which will also get a more recent version of
+the toolchain.
+
+You can follow the 3.x guide at:
+
+  * [Linux installation](https://docs.espressif.com/projects/esp-idf/en/v3.3.2/get-started/linux-setup.html)
+  * [MacOS installation](https://docs.espressif.com/projects/esp-idf/en/v3.3.2/get-started/macos-setup.html)
+  * [Windows installation](https://docs.espressif.com/projects/esp-idf/en/v3.3.2/get-started/windows-setup.html)
+
+You will need to update your `PATH` environment variable to include the ESP32
+toolchain. For example, you can issue the following commands on (at least)
+Linux:
 
     $ export PATH=$PATH:$HOME/esp/crosstool-NG/builds/xtensa-esp32-elf/bin
 
-You can put this command in your `.profile` or `.bash_login`.
+You can put this command in your `.profile` or `.bash_login`, or do it manually.
+
+Configuring the MicroPython build
+---------------------------------
 
 You then need to set the `ESPIDF` environment/makefile variable to point to
-the root of the ESP-IDF repository.  You can set the variable in your PATH,
-or at the command line when calling make, or in your own custom `makefile`.
-The last option is recommended as it allows you to easily configure other
-variables for the build.  In that case, create a new file in the esp32
-directory called `makefile` and add the following lines to that file:
-```
-ESPIDF = <path to root of esp-idf repository>
-#PORT = /dev/ttyUSB0
-#FLASH_MODE = qio
-#FLASH_SIZE = 4MB
-#CROSS_COMPILE = xtensa-esp32-elf-
-#SDKCONFIG = boards/sdkconfig.spiram
+the root of the ESP-IDF repository. The recommended way to do this is to have
+a custom `makefile` in `ports/esp32` which sets any additional variables, then
+includes the main `Makefile`. Note that GNU Make will preferentially run
+`GNUmakefile`, then `makefile`, then `Makefile`, which is what allows this to
+work. On case-insensitive filesystems, you'll need to use `GNUmakefile` rather
+than `makefile`.
+
+Create a new file in the esp32 directory called `makefile` (or `GNUmakefile`)
+and add the following lines to that file:
+
+```
+ESPIDF ?= <path to root of esp-idf repository>
+BOARD ?= GENERIC
+#PORT ?= /dev/ttyUSB0
+#FLASH_MODE ?= qio
+#FLASH_SIZE ?= 4MB
+#CROSS_COMPILE ?= xtensa-esp32-elf-
 
 include Makefile
 ```
+
 Be sure to enter the correct path to your local copy of the IDF repository
-(and use `$(HOME)`, not tilde, to reference your home directory).
-If your filesystem is case-insensitive then you'll need to use `GNUmakefile`
-instead of `makefile`.
+(and use `$(HOME)`, not tilde (`~`), to reference your home directory).
+
 If the Xtensa cross-compiler is not in your path you can use the
-`CROSS_COMPILE` variable to set its location.  Other options of interest
-are `PORT` for the serial port of your esp32 module, and `FLASH_MODE`
-(which may need to be `dio` for some modules)
-and `FLASH_SIZE`.  See the Makefile for further information.
-
-The default ESP IDF configuration settings are provided in the file
-`boards/sdkconfig`, and this file is specified in the build by the make
-variable `SDKCONFIG`.  To use a custom configuration either set `SDKCONFIG`
-in your custom `makefile` (or `GNUmakefile`) or set this variable on the
-command line:
+`CROSS_COMPILE` variable to set its location.  Other options of interest are
+`PORT` for the serial port of your ESP32 module, and `FLASH_MODE` (which may
+need to be `dio` for some modules) and `FLASH_SIZE`.  See the Makefile for
+further information.
+
+The default ESP IDF configuration settings are provided by the `GENERIC`
+board definition in the directory `boards/GENERIC`. For a custom configuration
+you can define your own board directory.
+
+Any of these variables can also be set on the make command line, e.g. to set
+the `BOARD` variable, use:
+
 ```bash
-$ make SDKCONFIG=sdkconfig.myboard
+$ make BOARD=TINYPICO
 ```
-The file `boards/sdkconfig.spiram` is provided for ESP32 modules that have
-external SPIRAM.
+
+Note the use of `?=` in the `makefile` which allows them to be overridden on
+the command line. There is also a `GENERIC_SPIRAM` board for for ESP32
+modules that have external SPIRAM, but prefer to use a specific board target
+(or define your own as necessary).
 
 Building the firmware
 ---------------------
@@ -109,23 +196,20 @@ Building the firmware
 The MicroPython cross-compiler must be built to pre-compile some of the
 built-in scripts to bytecode.  This can be done by (from the root of
 this repository):
-```bash
-$ make -C mpy-cross
-```
 
-The ESP32 port has a dependency on Berkeley DB, which is an external
-dependency (git submodule). You'll need to have git initialize that
-module using the commands:
 ```bash
-$ git submodule init lib/berkeley-db-1.xx
-$ git submodule update
+$ cd mpy-cross
+$ make mpy-cross
 ```
 
 Then to build MicroPython for the ESP32 run:
+
 ```bash
 $ cd ports/esp32
+$ make submodules
 $ make
 ```
+
 This will produce binary firmware images in the `build/` subdirectory
 (three of them: bootloader.bin, partitions.bin and application.bin).
 
@@ -136,8 +220,10 @@ flash settings are set in the `Makefile`, and can be overridden in your
 local `makefile`; see above for more details.
 
 You will also need to have user permissions to access the /dev/ttyUSB0 device.
-On Linux, you can enable this by adding your user to the `dialout` group,
-and rebooting or logging out and in again.
+On Linux, you can enable this by adding your user to the `dialout` group, and
+rebooting or logging out and in again. (Note: on some distributions this may
+be the `uucp` group, run `ls -la /dev/ttyUSB0` to check.)
+
 ```bash
 $ sudo adduser <username> dialout
 ```
@@ -145,27 +231,37 @@ $ sudo adduser <username> dialout
 If you are installing MicroPython to your module for the first time, or
 after installing any other firmware, you should first erase the flash
 completely:
+
 ```bash
 $ make erase
 ```
 
 To flash the MicroPython firmware to your ESP32 use:
+
 ```bash
 $ make deploy
 ```
-This will use the `esptool.py` script (provided by ESP-IDF) to download the
-binary images.
 
-Getting a Python prompt
------------------------
+This will use the `esptool.py` script (provided by ESP-IDF) to flash the
+binary images to the device.
+
+Getting a Python prompt on the device
+-------------------------------------
 
 You can get a prompt via the serial port, via UART0, which is the same UART
 that is used for programming the firmware.  The baudrate for the REPL is
 115200 and you can use a command such as:
+
 ```bash
 $ picocom -b 115200 /dev/ttyUSB0
 ```
 
+or
+
+```bash
+$ miniterm.py /dev/ttyUSB0 115200
+```
+
 Configuring the WiFi and using the board
 ----------------------------------------
 
diff --git a/ports/esp32/boards/GENERIC/mpconfigboard.h b/ports/esp32/boards/GENERIC/mpconfigboard.h
new file mode 100644
index 0000000000000..644807f78e601
--- /dev/null
+++ b/ports/esp32/boards/GENERIC/mpconfigboard.h
@@ -0,0 +1,2 @@
+#define MICROPY_HW_BOARD_NAME "ESP32 module"
+#define MICROPY_HW_MCU_NAME "ESP32"
diff --git a/ports/esp32/boards/GENERIC/mpconfigboard.mk b/ports/esp32/boards/GENERIC/mpconfigboard.mk
new file mode 100644
index 0000000000000..fc49d2a8c256c
--- /dev/null
+++ b/ports/esp32/boards/GENERIC/mpconfigboard.mk
@@ -0,0 +1 @@
+SDKCONFIG += boards/sdkconfig.base
diff --git a/ports/esp32/boards/GENERIC_D2WD/mpconfigboard.h b/ports/esp32/boards/GENERIC_D2WD/mpconfigboard.h
new file mode 100644
index 0000000000000..8923d46fd1569
--- /dev/null
+++ b/ports/esp32/boards/GENERIC_D2WD/mpconfigboard.h
@@ -0,0 +1,2 @@
+#define MICROPY_HW_BOARD_NAME "Generic ESP32-D2WD module"
+#define MICROPY_HW_MCU_NAME "ESP32-D2WD"
diff --git a/ports/esp32/boards/GENERIC_D2WD/mpconfigboard.mk b/ports/esp32/boards/GENERIC_D2WD/mpconfigboard.mk
new file mode 100644
index 0000000000000..65de5dcd08e55
--- /dev/null
+++ b/ports/esp32/boards/GENERIC_D2WD/mpconfigboard.mk
@@ -0,0 +1,5 @@
+SDKCONFIG += boards/sdkconfig.base
+PART_SRC = partitions-2MiB.csv
+FLASH_SIZE = 2MB
+FLASH_MODE = dio
+FLASH_FREQ = 40m
diff --git a/ports/esp32/boards/GENERIC_OTA/mpconfigboard.h b/ports/esp32/boards/GENERIC_OTA/mpconfigboard.h
new file mode 100644
index 0000000000000..ff39c4b2b7da8
--- /dev/null
+++ b/ports/esp32/boards/GENERIC_OTA/mpconfigboard.h
@@ -0,0 +1,2 @@
+#define MICROPY_HW_BOARD_NAME "4MB/OTA module"
+#define MICROPY_HW_MCU_NAME "ESP32"
diff --git a/ports/esp32/boards/GENERIC_OTA/mpconfigboard.mk b/ports/esp32/boards/GENERIC_OTA/mpconfigboard.mk
new file mode 100644
index 0000000000000..db6492cac2b84
--- /dev/null
+++ b/ports/esp32/boards/GENERIC_OTA/mpconfigboard.mk
@@ -0,0 +1,4 @@
+SDKCONFIG += boards/sdkconfig.base
+SDKCONFIG += boards/GENERIC_OTA/sdkconfig.board
+
+PART_SRC = partitions-ota.csv
diff --git a/ports/esp32/boards/GENERIC_OTA/sdkconfig.board b/ports/esp32/boards/GENERIC_OTA/sdkconfig.board
new file mode 100644
index 0000000000000..b0ed171d811a5
--- /dev/null
+++ b/ports/esp32/boards/GENERIC_OTA/sdkconfig.board
@@ -0,0 +1,4 @@
+CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=y
+
+# ESP-IDF v3:
+CONFIG_APP_ROLLBACK_ENABLE=y
diff --git a/ports/esp32/boards/GENERIC_SPIRAM/mpconfigboard.h b/ports/esp32/boards/GENERIC_SPIRAM/mpconfigboard.h
new file mode 100644
index 0000000000000..a5982e47e5c32
--- /dev/null
+++ b/ports/esp32/boards/GENERIC_SPIRAM/mpconfigboard.h
@@ -0,0 +1,2 @@
+#define MICROPY_HW_BOARD_NAME "ESP32 module (spiram)"
+#define MICROPY_HW_MCU_NAME "ESP32"
diff --git a/ports/esp32/boards/GENERIC_SPIRAM/mpconfigboard.mk b/ports/esp32/boards/GENERIC_SPIRAM/mpconfigboard.mk
new file mode 100644
index 0000000000000..59aa75f8571b9
--- /dev/null
+++ b/ports/esp32/boards/GENERIC_SPIRAM/mpconfigboard.mk
@@ -0,0 +1,2 @@
+SDKCONFIG += boards/sdkconfig.base
+SDKCONFIG += boards/sdkconfig.spiram
diff --git a/ports/esp32/boards/TINYPICO/manifest.py b/ports/esp32/boards/TINYPICO/manifest.py
new file mode 100644
index 0000000000000..7ae2ed15d9169
--- /dev/null
+++ b/ports/esp32/boards/TINYPICO/manifest.py
@@ -0,0 +1,2 @@
+include("$(PORT_DIR)/boards/manifest.py")
+freeze("modules")
diff --git a/ports/esp32/boards/TINYPICO/modules/dotstar.py b/ports/esp32/boards/TINYPICO/modules/dotstar.py
new file mode 100644
index 0000000000000..c362eb11de4bd
--- /dev/null
+++ b/ports/esp32/boards/TINYPICO/modules/dotstar.py
@@ -0,0 +1,227 @@
+# DotStar strip driver for MicroPython
+#
+# The MIT License (MIT)
+#
+# Copyright (c) 2016 Damien P. George (original Neopixel object)
+# Copyright (c) 2017 Ladyada
+# Copyright (c) 2017 Scott Shawcroft for Adafruit Industries
+# Copyright (c) 2019 Matt Trentini (porting back to MicroPython)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+START_HEADER_SIZE = 4
+LED_START = 0b11100000  # Three "1" bits, followed by 5 brightness bits
+
+# Pixel color order constants
+RGB = (0, 1, 2)
+RBG = (0, 2, 1)
+GRB = (1, 0, 2)
+GBR = (1, 2, 0)
+BRG = (2, 0, 1)
+BGR = (2, 1, 0)
+
+
+class DotStar:
+    """
+    A sequence of dotstars.
+
+    :param SPI spi: The SPI object to write output to.
+    :param int n: The number of dotstars in the chain
+    :param float brightness: Brightness of the pixels between 0.0 and 1.0
+    :param bool auto_write: True if the dotstars should immediately change when
+        set. If False, `show` must be called explicitly.
+    :param tuple pixel_order: Set the pixel order on the strip - different
+         strips implement this differently. If you send red, and it looks blue
+         or green on the strip, modify this! It should be one of the values above
+
+
+    Example for TinyPICO:
+
+    .. code-block:: python
+
+        from dotstar import DotStar
+        from machine import Pin, SPI
+
+        spi = SPI(sck=Pin(12), mosi=Pin(13), miso=Pin(18)) # Configure SPI - note: miso is unused
+        dotstar = DotStar(spi, 1)
+        dotstar[0] = (128, 0, 0) # Red
+    """
+
+    def __init__(self, spi, n, *, brightness=1.0, auto_write=True, pixel_order=BGR):
+        self._spi = spi
+        self._n = n
+        # Supply one extra clock cycle for each two pixels in the strip.
+        self.end_header_size = n // 16
+        if n % 16 != 0:
+            self.end_header_size += 1
+        self._buf = bytearray(n * 4 + START_HEADER_SIZE + self.end_header_size)
+        self.end_header_index = len(self._buf) - self.end_header_size
+        self.pixel_order = pixel_order
+        # Four empty bytes to start.
+        for i in range(START_HEADER_SIZE):
+            self._buf[i] = 0x00
+        # Mark the beginnings of each pixel.
+        for i in range(START_HEADER_SIZE, self.end_header_index, 4):
+            self._buf[i] = 0xFF
+        # 0xff bytes at the end.
+        for i in range(self.end_header_index, len(self._buf)):
+            self._buf[i] = 0xFF
+        self._brightness = 1.0
+        # Set auto_write to False temporarily so brightness setter does _not_
+        # call show() while in __init__.
+        self.auto_write = False
+        self.brightness = brightness
+        self.auto_write = auto_write
+
+    def deinit(self):
+        """Blank out the DotStars and release the resources."""
+        self.auto_write = False
+        for i in range(START_HEADER_SIZE, self.end_header_index):
+            if i % 4 != 0:
+                self._buf[i] = 0
+        self.show()
+        if self._spi:
+            self._spi.deinit()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exception_type, exception_value, traceback):
+        self.deinit()
+
+    def __repr__(self):
+        return "[" + ", ".join([str(x) for x in self]) + "]"
+
+    def _set_item(self, index, value):
+        """
+        value can be one of three things:
+                a (r,g,b) list/tuple
+                a (r,g,b, brightness) list/tuple
+                a single, longer int that contains RGB values, like 0xFFFFFF
+            brightness, if specified should be a float 0-1
+
+        Set a pixel value. You can set per-pixel brightness here, if it's not passed it
+        will use the max value for pixel brightness value, which is a good default.
+
+        Important notes about the per-pixel brightness - it's accomplished by
+        PWMing the entire output of the LED, and that PWM is at a much
+        slower clock than the rest of the LEDs. This can cause problems in
+        Persistence of Vision Applications
+        """
+
+        offset = index * 4 + START_HEADER_SIZE
+        rgb = value
+        if isinstance(value, int):
+            rgb = (value >> 16, (value >> 8) & 0xFF, value & 0xFF)
+
+        if len(rgb) == 4:
+            brightness = value[3]
+            # Ignore value[3] below.
+        else:
+            brightness = 1
+
+        # LED startframe is three "1" bits, followed by 5 brightness bits
+        # then 8 bits for each of R, G, and B. The order of those 3 are configurable and
+        # vary based on hardware
+        # same as math.ceil(brightness * 31) & 0b00011111
+        # Idea from https://www.codeproject.com/Tips/700780/Fast-floor-ceiling-functions
+        brightness_byte = 32 - int(32 - brightness * 31) & 0b00011111
+        self._buf[offset] = brightness_byte | LED_START
+        self._buf[offset + 1] = rgb[self.pixel_order[0]]
+        self._buf[offset + 2] = rgb[self.pixel_order[1]]
+        self._buf[offset + 3] = rgb[self.pixel_order[2]]
+
+    def __setitem__(self, index, val):
+        if isinstance(index, slice):
+            start, stop, step = index.indices(self._n)
+            length = stop - start
+            if step != 0:
+                # same as math.ceil(length / step)
+                # Idea from https://fizzbuzzer.com/implement-a-ceil-function/
+                length = (length + step - 1) // step
+            if len(val) != length:
+                raise ValueError("Slice and input sequence size do not match.")
+            for val_i, in_i in enumerate(range(start, stop, step)):
+                self._set_item(in_i, val[val_i])
+        else:
+            self._set_item(index, val)
+
+        if self.auto_write:
+            self.show()
+
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            out = []
+            for in_i in range(*index.indices(self._n)):
+                out.append(
+                    tuple(self._buf[in_i * 4 + (3 - i) + START_HEADER_SIZE] for i in range(3))
+                )
+            return out
+        if index < 0:
+            index += len(self)
+        if index >= self._n or index < 0:
+            raise IndexError
+        offset = index * 4
+        return tuple(self._buf[offset + (3 - i) + START_HEADER_SIZE] for i in range(3))
+
+    def __len__(self):
+        return self._n
+
+    @property
+    def brightness(self):
+        """Overall brightness of the pixel"""
+        return self._brightness
+
+    @brightness.setter
+    def brightness(self, brightness):
+        self._brightness = min(max(brightness, 0.0), 1.0)
+        if self.auto_write:
+            self.show()
+
+    def fill(self, color):
+        """Colors all pixels the given ***color***."""
+        auto_write = self.auto_write
+        self.auto_write = False
+        for i in range(self._n):
+            self[i] = color
+        if auto_write:
+            self.show()
+        self.auto_write = auto_write
+
+    def show(self):
+        """Shows the new colors on the pixels themselves if they haven't already
+        been autowritten.
+
+        The colors may or may not be showing after this function returns because
+        it may be done asynchronously."""
+        # Create a second output buffer if we need to compute brightness
+        buf = self._buf
+        if self.brightness < 1.0:
+            buf = bytearray(self._buf)
+            # Four empty bytes to start.
+            for i in range(START_HEADER_SIZE):
+                buf[i] = 0x00
+            for i in range(START_HEADER_SIZE, self.end_header_index):
+                buf[i] = self._buf[i] if i % 4 == 0 else int(self._buf[i] * self._brightness)
+            # Four 0xff bytes at the end.
+            for i in range(self.end_header_index, len(buf)):
+                buf[i] = 0xFF
+
+        if self._spi:
+            self._spi.write(buf)
diff --git a/ports/esp32/boards/TINYPICO/modules/tinypico.py b/ports/esp32/boards/TINYPICO/modules/tinypico.py
new file mode 100644
index 0000000000000..846e07960a3f2
--- /dev/null
+++ b/ports/esp32/boards/TINYPICO/modules/tinypico.py
@@ -0,0 +1,122 @@
+# TinyPICO MicroPython Helper Library
+# 2019 Seon Rozenblum, Matt Trentini
+#
+# Project home:
+#   https://github.com/TinyPICO
+#
+# 2019-Mar-12 - v0.1 - Initial implementation
+# 2019-May-20 - v1.0 - Initial Release
+# 2019-Oct-23 - v1.1 - Removed temp sensor code, prep for frozen modules
+
+# Import required libraries
+from micropython import const
+from machine import Pin, SPI, ADC
+import machine, time, esp32
+
+# TinyPICO Hardware Pin Assignments
+
+# Battery
+BAT_VOLTAGE = const(35)
+BAT_CHARGE = const(34)
+
+# APA102 Dotstar pins for production boards
+DOTSTAR_CLK = const(12)
+DOTSTAR_DATA = const(2)
+DOTSTAR_PWR = const(13)
+
+# SPI
+SPI_MOSI = const(23)
+SPI_CLK = const(18)
+SPI_MISO = const(19)
+
+# I2C
+I2C_SDA = const(21)
+I2C_SCL = const(22)
+
+# DAC
+DAC1 = const(25)
+DAC2 = const(26)
+
+# Helper functions
+
+# Get a *rough* estimate of the current battery voltage
+# If the battery is not present, the charge IC will still report it's trying to charge at X voltage
+# so it will still show a voltage.
+def get_battery_voltage():
+    """
+    Returns the current battery voltage. If no battery is connected, returns 3.7V
+    This is an approximation only, but useful to detect of the charge state of the battery is getting low.
+    """
+    adc = ADC(Pin(BAT_VOLTAGE))  # Assign the ADC pin to read
+    measuredvbat = adc.read()  # Read the value
+    measuredvbat /= 4095  # divide by 4095 as we are using the default ADC voltage range of 0-1V
+    measuredvbat *= 3.7  # Multiply by 3.7V, our reference voltage
+    return measuredvbat
+
+
+# Return the current charge state of the battery - we need to read the value multiple times
+# to eliminate false negatives due to the charge IC not knowing the difference between no battery
+# and a full battery not charging - This is why the charge LED flashes
+def get_battery_charging():
+    """
+    Returns the current battery charging state.
+    This can trigger false positives as the charge IC can't tell the difference between a full battery or no battery connected.
+    """
+    measuredVal = 0  # start our reading at 0
+    io = Pin(BAT_CHARGE, Pin.IN)  # Assign the pin to read
+
+    for y in range(
+        0, 10
+    ):  # loop through 10 times adding the read values together to ensure no false positives
+        measuredVal += io.value()
+
+    return measuredVal == 0  # return True if the value is 0
+
+
+# Power to the on-board Dotstar is controlled by a PNP transistor, so low is ON and high is OFF
+# We also need to set the Dotstar clock and data pins to be inputs to prevent power leakage when power is off
+# This might be improved at a future date
+# The reason we have power control for the Dotstar is that it has a quiescent current of around 1mA, so we
+# need to be able to cut power to it to minimise power consumption during deep sleep or with general battery powered use
+# to minimise unneeded battery drain
+def set_dotstar_power(state):
+    """Set the power for the on-board Dostar to allow no current draw when not needed."""
+    # Set the power pin to the inverse of state
+    if state:
+        Pin(DOTSTAR_PWR, Pin.OUT, None)  # Break the PULL_HOLD on the pin
+        Pin(DOTSTAR_PWR).value(False)  # Set the pin to LOW to enable the Transistor
+    else:
+        Pin(13, Pin.IN, Pin.PULL_HOLD)  # Set PULL_HOLD on the pin to allow the 3V3 pull-up to work
+
+    Pin(
+        DOTSTAR_CLK, Pin.OUT if state else Pin.IN
+    )  # If power is on, set CLK to be output, otherwise input
+    Pin(
+        DOTSTAR_DATA, Pin.OUT if state else Pin.IN
+    )  # If power is on, set DATA to be output, otherwise input
+
+    # A small delay to let the IO change state
+    time.sleep(0.035)
+
+
+# Dotstar rainbow colour wheel
+def dotstar_color_wheel(wheel_pos):
+    """Color wheel to allow for cycling through the rainbow of RGB colors."""
+    wheel_pos = wheel_pos % 255
+
+    if wheel_pos < 85:
+        return 255 - wheel_pos * 3, 0, wheel_pos * 3
+    elif wheel_pos < 170:
+        wheel_pos -= 85
+        return 0, wheel_pos * 3, 255 - wheel_pos * 3
+    else:
+        wheel_pos -= 170
+        return wheel_pos * 3, 255 - wheel_pos * 3, 0
+
+
+# Go into deep sleep but shut down the APA first to save power
+# Use this if you want lowest deep  sleep current
+def go_deepsleep(t):
+    """Deep sleep helper that also powers down the on-board Dotstar."""
+    set_dotstar_power(False)
+    machine.deepsleep(t)
diff --git a/ports/esp32/boards/TINYPICO/mpconfigboard.h b/ports/esp32/boards/TINYPICO/mpconfigboard.h
new file mode 100644
index 0000000000000..e63f43ed25a2f
--- /dev/null
+++ b/ports/esp32/boards/TINYPICO/mpconfigboard.h
@@ -0,0 +1,2 @@
+#define MICROPY_HW_BOARD_NAME "TinyPICO"
+#define MICROPY_HW_MCU_NAME "ESP32-PICO-D4"
diff --git a/ports/esp32/boards/TINYPICO/mpconfigboard.mk b/ports/esp32/boards/TINYPICO/mpconfigboard.mk
new file mode 100644
index 0000000000000..5c96ec45a79e6
--- /dev/null
+++ b/ports/esp32/boards/TINYPICO/mpconfigboard.mk
@@ -0,0 +1,8 @@
+FLASH_FREQ = 80m
+
+SDKCONFIG += boards/sdkconfig.base
+SDKCONFIG += boards/sdkconfig.240mhz
+SDKCONFIG += boards/sdkconfig.spiram
+SDKCONFIG += boards/TINYPICO/sdkconfig.board
+
+FROZEN_MANIFEST ?= $(BOARD_DIR)/manifest.py
diff --git a/ports/esp32/boards/TINYPICO/sdkconfig.board b/ports/esp32/boards/TINYPICO/sdkconfig.board
new file mode 100644
index 0000000000000..dc2c23f674e84
--- /dev/null
+++ b/ports/esp32/boards/TINYPICO/sdkconfig.board
@@ -0,0 +1,4 @@
+CONFIG_FLASHMODE_QIO=y
+CONFIG_ESPTOOLPY_FLASHFREQ_80M=y
+CONFIG_SPIRAM_SPEED_80M=y
+CONFIG_ESP32_REV_MIN_1=y
diff --git a/ports/esp32/boards/manifest.py b/ports/esp32/boards/manifest.py
new file mode 100644
index 0000000000000..b463c131faa0d
--- /dev/null
+++ b/ports/esp32/boards/manifest.py
@@ -0,0 +1,7 @@
+freeze("$(PORT_DIR)/modules")
+freeze("$(MPY_DIR)/tools", ("upip.py", "upip_utarfile.py"))
+freeze("$(MPY_DIR)/ports/esp8266/modules", "ntptime.py")
+freeze("$(MPY_DIR)/drivers/dht", "dht.py")
+freeze("$(MPY_DIR)/drivers/onewire")
+include("$(MPY_DIR)/extmod/uasyncio/manifest.py")
+include("$(MPY_DIR)/extmod/webrepl/manifest.py")
diff --git a/ports/esp32/boards/manifest_release.py b/ports/esp32/boards/manifest_release.py
new file mode 100644
index 0000000000000..b5c7cd111b109
--- /dev/null
+++ b/ports/esp32/boards/manifest_release.py
@@ -0,0 +1,6 @@
+include("manifest.py")
+
+freeze("$(MPY_LIB_DIR)/upysh", "upysh.py")
+freeze("$(MPY_LIB_DIR)/urequests", "urequests.py")
+freeze("$(MPY_LIB_DIR)/umqtt.simple", "umqtt/simple.py")
+freeze("$(MPY_LIB_DIR)/umqtt.robust", "umqtt/robust.py")
diff --git a/ports/esp32/boards/sdkconfig.240mhz b/ports/esp32/boards/sdkconfig.240mhz
new file mode 100644
index 0000000000000..e36884009d1ed
--- /dev/null
+++ b/ports/esp32/boards/sdkconfig.240mhz
@@ -0,0 +1,5 @@
+# MicroPython on ESP32, ESP IDF configuration with 240MHz CPU
+CONFIG_ESP32_DEFAULT_CPU_FREQ_80=
+CONFIG_ESP32_DEFAULT_CPU_FREQ_160=
+CONFIG_ESP32_DEFAULT_CPU_FREQ_240=y
+CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ=240
diff --git a/ports/esp32/boards/sdkconfig b/ports/esp32/boards/sdkconfig.base
similarity index 52%
rename from ports/esp32/boards/sdkconfig
rename to ports/esp32/boards/sdkconfig.base
index 7bd731a66b6c5..f44ec4e173e9b 100644
--- a/ports/esp32/boards/sdkconfig
+++ b/ports/esp32/boards/sdkconfig.base
@@ -2,18 +2,18 @@
 # The following options override the defaults
 
 CONFIG_IDF_TARGET="esp32"
+CONFIG_IDF_FIRMWARE_CHIP_ID=0x0000
 
 # Application manager
 CONFIG_APP_EXCLUDE_PROJECT_VER_VAR=y
 CONFIG_APP_EXCLUDE_PROJECT_NAME_VAR=y
 
 # Bootloader config
-CONFIG_LOG_BOOTLOADER_LEVEL_WARN=y
+CONFIG_BOOTLOADER_LOG_LEVEL_WARN=y
 
 # ESP32-specific
-CONFIG_ESP32_DEFAULT_CPU_FREQ_240=y
-CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0=n
-CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU1=n
+CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0=n
+CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1=n
 CONFIG_ESP32_XTAL_FREQ_AUTO=y
 
 # Power Management
@@ -21,10 +21,28 @@ CONFIG_PM_ENABLE=y
 
 # FreeRTOS
 CONFIG_FREERTOS_THREAD_LOCAL_STORAGE_POINTERS=2
-CONFIG_SUPPORT_STATIC_ALLOCATION=y
-CONFIG_ENABLE_STATIC_TASK_CLEAN_UP_HOOK=y
+CONFIG_FREERTOS_SUPPORT_STATIC_ALLOCATION=y
+CONFIG_FREERTOS_ENABLE_STATIC_TASK_CLEAN_UP=y
 
 # UDP
+CONFIG_LWIP_PPP_SUPPORT=y
+CONFIG_LWIP_PPP_PAP_SUPPORT=y
+CONFIG_LWIP_PPP_CHAP_SUPPORT=y
+
+# SSL
+# Use 4kiB output buffer instead of default 16kiB (because IDF heap is fragmented in 4.0)
+CONFIG_MBEDTLS_ASYMMETRIC_CONTENT_LEN=y
+
+# ULP coprocessor support
+CONFIG_ESP32_ULP_COPROC_ENABLED=y
+
+# v3.3-only (renamed in 4.0)
+CONFIG_LOG_BOOTLOADER_LEVEL_WARN=y
+CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0=n
+CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU1=n
+CONFIG_SUPPORT_STATIC_ALLOCATION=y
+CONFIG_ENABLE_STATIC_TASK_CLEAN_UP_HOOK=y
 CONFIG_PPP_SUPPORT=y
 CONFIG_PPP_PAP_SUPPORT=y
 CONFIG_PPP_CHAP_SUPPORT=y
+CONFIG_ULP_COPROC_ENABLED=y
diff --git a/ports/esp32/boards/sdkconfig.ble b/ports/esp32/boards/sdkconfig.ble
new file mode 100644
index 0000000000000..cdbb621a63112
--- /dev/null
+++ b/ports/esp32/boards/sdkconfig.ble
@@ -0,0 +1,24 @@
+# Note this requires building with IDF 4.x
+CONFIG_BT_ENABLED=y
+CONFIG_BTDM_CTRL_MODE_BLE_ONLY=y
+CONFIG_BTDM_CTRL_MODE_BR_EDR_ONLY=
+CONFIG_BTDM_CTRL_MODE_BTDM=
+
+CONFIG_BT_NIMBLE_ENABLED=y
+
+CONFIG_BT_NIMBLE_MAX_CONNECTIONS=4
+
+# Pin to the same core as MP.
+CONFIG_BT_NIMBLE_PINNED_TO_CORE_0=n
+CONFIG_BT_NIMBLE_PINNED_TO_CORE_1=y
+CONFIG_BT_NIMBLE_PINNED_TO_CORE=1
+
+# v3.3-only (renamed in 4.0)
+CONFIG_BTDM_CONTROLLER_MODE_BLE_ONLY=y
+CONFIG_BTDM_CONTROLLER_MODE_BR_EDR_ONLY=
+CONFIG_BTDM_CONTROLLER_MODE_BTDM=
+CONFIG_BLUEDROID_ENABLED=n
+CONFIG_NIMBLE_ENABLED=y
+CONFIG_NIMBLE_MAX_CONNECTIONS=4
+CONFIG_NIMBLE_PINNED_TO_CORE_0=n
+CONFIG_NIMBLE_PINNED_TO_CORE_1=y
diff --git a/ports/esp32/boards/sdkconfig.spiram b/ports/esp32/boards/sdkconfig.spiram
index 1467f3171b23e..db1a83af8c432 100644
--- a/ports/esp32/boards/sdkconfig.spiram
+++ b/ports/esp32/boards/sdkconfig.spiram
@@ -1,33 +1,9 @@
 # MicroPython on ESP32, ESP IDF configuration with SPIRAM support
-# The following options override the defaults
 
-CONFIG_IDF_TARGET="esp32"
-
-# Application manager
-CONFIG_APP_EXCLUDE_PROJECT_VER_VAR=y
-CONFIG_APP_EXCLUDE_PROJECT_NAME_VAR=y
-
-# Bootloader config
-CONFIG_LOG_BOOTLOADER_LEVEL_WARN=y
-
-# ESP32-specific
-CONFIG_ESP32_DEFAULT_CPU_FREQ_240=y
-CONFIG_SPIRAM_SUPPORT=y
+CONFIG_ESP32_SPIRAM_SUPPORT=y
+CONFIG_SPIRAM_CACHE_WORKAROUND=y
 CONFIG_SPIRAM_IGNORE_NOTFOUND=y
 CONFIG_SPIRAM_USE_MEMMAP=y
-CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0=n
-CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU1=n
-CONFIG_ESP32_XTAL_FREQ_AUTO=y
 
-# Power Management
-CONFIG_PM_ENABLE=y
-
-# FreeRTOS
-CONFIG_FREERTOS_THREAD_LOCAL_STORAGE_POINTERS=2
-CONFIG_SUPPORT_STATIC_ALLOCATION=y
-CONFIG_ENABLE_STATIC_TASK_CLEAN_UP_HOOK=y
-
-# UDP
-CONFIG_PPP_SUPPORT=y
-CONFIG_PPP_PAP_SUPPORT=y
-CONFIG_PPP_CHAP_SUPPORT=y
+# v3.3-only (renamed in 4.0)
+CONFIG_SPIRAM_SUPPORT=y
diff --git a/ports/esp32/esp32_partition.c b/ports/esp32/esp32_partition.c
new file mode 100644
index 0000000000000..dc2bdd7120ed3
--- /dev/null
+++ b/ports/esp32/esp32_partition.c
@@ -0,0 +1,246 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <string.h>
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+#include "extmod/vfs.h"
+#include "mphalport.h"
+#include "modesp32.h"
+#include "esp_ota_ops.h"
+
+// esp_partition_read and esp_partition_write can operate on arbitrary bytes
+// but esp_partition_erase_range operates on 4k blocks.  But to make a partition
+// implement the standard block protocol all operations are done on 4k blocks.
+#define BLOCK_SIZE_BYTES (4096)
+
+enum {
+    ESP32_PARTITION_BOOT,
+    ESP32_PARTITION_RUNNING,
+};
+
+typedef struct _esp32_partition_obj_t {
+    mp_obj_base_t base;
+    const esp_partition_t *part;
+} esp32_partition_obj_t;
+
+STATIC esp32_partition_obj_t *esp32_partition_new(const esp_partition_t *part) {
+    if (part == NULL) {
+        mp_raise_OSError(MP_ENOENT);
+    }
+    esp32_partition_obj_t *self = m_new_obj(esp32_partition_obj_t);
+    self->base.type = &esp32_partition_type;
+    self->part = part;
+    return self;
+}
+
+STATIC void esp32_partition_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    esp32_partition_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_printf(print, "<Partition type=%u, subtype=%u, address=%u, size=%u, label=%s, encrypted=%u>",
+        self->part->type, self->part->subtype,
+        self->part->address, self->part->size,
+        &self->part->label[0], self->part->encrypted
+        );
+}
+
+STATIC mp_obj_t esp32_partition_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    // Check args
+    mp_arg_check_num(n_args, n_kw, 1, 1, false);
+
+    // Get requested partition
+    const esp_partition_t *part;
+    if (mp_obj_is_int(all_args[0])) {
+        // Integer given, get that particular partition
+        switch (mp_obj_get_int(all_args[0])) {
+            case ESP32_PARTITION_BOOT:
+                part = esp_ota_get_boot_partition();
+                break;
+            case ESP32_PARTITION_RUNNING:
+                part = esp_ota_get_running_partition();
+                break;
+            default:
+                mp_raise_ValueError(NULL);
+        }
+    } else {
+        // String given, search for partition with that label
+        const char *label = mp_obj_str_get_str(all_args[0]);
+        part = esp_partition_find_first(ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_ANY, label);
+        if (part == NULL) {
+            part = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_ANY, label);
+        }
+    }
+
+    // Return new object
+    return MP_OBJ_FROM_PTR(esp32_partition_new(part));
+}
+
+STATIC mp_obj_t esp32_partition_find(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    // Parse args
+    enum { ARG_type, ARG_subtype, ARG_label };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_type, MP_ARG_INT, {.u_int = ESP_PARTITION_TYPE_APP} },
+        { MP_QSTR_subtype, MP_ARG_INT, {.u_int = ESP_PARTITION_SUBTYPE_ANY} },
+        { MP_QSTR_label, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // Get optional label string
+    const char *label = NULL;
+    if (args[ARG_label].u_obj != mp_const_none) {
+        label = mp_obj_str_get_str(args[ARG_label].u_obj);
+    }
+
+    // Build list of matching partitions
+    mp_obj_t list = mp_obj_new_list(0, NULL);
+    esp_partition_iterator_t iter = esp_partition_find(args[ARG_type].u_int, args[ARG_subtype].u_int, label);
+    while (iter != NULL) {
+        mp_obj_list_append(list, MP_OBJ_FROM_PTR(esp32_partition_new(esp_partition_get(iter))));
+        iter = esp_partition_next(iter);
+    }
+    esp_partition_iterator_release(iter);
+
+    return list;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp32_partition_find_fun_obj, 0, esp32_partition_find);
+STATIC MP_DEFINE_CONST_STATICMETHOD_OBJ(esp32_partition_find_obj, MP_ROM_PTR(&esp32_partition_find_fun_obj));
+
+STATIC mp_obj_t esp32_partition_info(mp_obj_t self_in) {
+    esp32_partition_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_obj_t tuple[] = {
+        MP_OBJ_NEW_SMALL_INT(self->part->type),
+        MP_OBJ_NEW_SMALL_INT(self->part->subtype),
+        mp_obj_new_int_from_uint(self->part->address),
+        mp_obj_new_int_from_uint(self->part->size),
+        mp_obj_new_str(&self->part->label[0], strlen(&self->part->label[0])),
+        mp_obj_new_bool(self->part->encrypted),
+    };
+    return mp_obj_new_tuple(6, tuple);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp32_partition_info_obj, esp32_partition_info);
+
+STATIC mp_obj_t esp32_partition_readblocks(size_t n_args, const mp_obj_t *args) {
+    esp32_partition_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    uint32_t offset = mp_obj_get_int(args[1]) * BLOCK_SIZE_BYTES;
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_WRITE);
+    if (n_args == 4) {
+        offset += mp_obj_get_int(args[3]);
+    }
+    check_esp_err(esp_partition_read(self->part, offset, bufinfo.buf, bufinfo.len));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp32_partition_readblocks_obj, 3, 4, esp32_partition_readblocks);
+
+STATIC mp_obj_t esp32_partition_writeblocks(size_t n_args, const mp_obj_t *args) {
+    esp32_partition_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    uint32_t offset = mp_obj_get_int(args[1]) * BLOCK_SIZE_BYTES;
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_READ);
+    if (n_args == 3) {
+        check_esp_err(esp_partition_erase_range(self->part, offset, bufinfo.len));
+    } else {
+        offset += mp_obj_get_int(args[3]);
+    }
+    check_esp_err(esp_partition_write(self->part, offset, bufinfo.buf, bufinfo.len));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp32_partition_writeblocks_obj, 3, 4, esp32_partition_writeblocks);
+
+STATIC mp_obj_t esp32_partition_ioctl(mp_obj_t self_in, mp_obj_t cmd_in, mp_obj_t arg_in) {
+    esp32_partition_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_int_t cmd = mp_obj_get_int(cmd_in);
+    switch (cmd) {
+        case MP_BLOCKDEV_IOCTL_INIT:
+            return MP_OBJ_NEW_SMALL_INT(0);
+        case MP_BLOCKDEV_IOCTL_DEINIT:
+            return MP_OBJ_NEW_SMALL_INT(0);
+        case MP_BLOCKDEV_IOCTL_SYNC:
+            return MP_OBJ_NEW_SMALL_INT(0);
+        case MP_BLOCKDEV_IOCTL_BLOCK_COUNT:
+            return MP_OBJ_NEW_SMALL_INT(self->part->size / BLOCK_SIZE_BYTES);
+        case MP_BLOCKDEV_IOCTL_BLOCK_SIZE:
+            return MP_OBJ_NEW_SMALL_INT(BLOCK_SIZE_BYTES);
+        case MP_BLOCKDEV_IOCTL_BLOCK_ERASE: {
+            uint32_t offset = mp_obj_get_int(arg_in) * BLOCK_SIZE_BYTES;
+            check_esp_err(esp_partition_erase_range(self->part, offset, BLOCK_SIZE_BYTES));
+            return MP_OBJ_NEW_SMALL_INT(0);
+        }
+        default:
+            return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(esp32_partition_ioctl_obj, esp32_partition_ioctl);
+
+STATIC mp_obj_t esp32_partition_set_boot(mp_obj_t self_in) {
+    esp32_partition_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    check_esp_err(esp_ota_set_boot_partition(self->part));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp32_partition_set_boot_obj, esp32_partition_set_boot);
+
+STATIC mp_obj_t esp32_partition_get_next_update(mp_obj_t self_in) {
+    esp32_partition_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    return MP_OBJ_FROM_PTR(esp32_partition_new(esp_ota_get_next_update_partition(self->part)));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp32_partition_get_next_update_obj, esp32_partition_get_next_update);
+
+STATIC mp_obj_t esp32_partition_mark_app_valid_cancel_rollback(mp_obj_t cls_in) {
+    check_esp_err(esp_ota_mark_app_valid_cancel_rollback());
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp32_partition_mark_app_valid_cancel_rollback_fun_obj,
+    esp32_partition_mark_app_valid_cancel_rollback);
+STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(esp32_partition_mark_app_valid_cancel_rollback_obj,
+    MP_ROM_PTR(&esp32_partition_mark_app_valid_cancel_rollback_fun_obj));
+
+STATIC const mp_rom_map_elem_t esp32_partition_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_find), MP_ROM_PTR(&esp32_partition_find_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_info), MP_ROM_PTR(&esp32_partition_info_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readblocks), MP_ROM_PTR(&esp32_partition_readblocks_obj) },
+    { MP_ROM_QSTR(MP_QSTR_writeblocks), MP_ROM_PTR(&esp32_partition_writeblocks_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ioctl), MP_ROM_PTR(&esp32_partition_ioctl_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_set_boot), MP_ROM_PTR(&esp32_partition_set_boot_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mark_app_valid_cancel_rollback), MP_ROM_PTR(&esp32_partition_mark_app_valid_cancel_rollback_obj) },
+    { MP_ROM_QSTR(MP_QSTR_get_next_update), MP_ROM_PTR(&esp32_partition_get_next_update_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_BOOT), MP_ROM_INT(ESP32_PARTITION_BOOT) },
+    { MP_ROM_QSTR(MP_QSTR_RUNNING), MP_ROM_INT(ESP32_PARTITION_RUNNING) },
+    { MP_ROM_QSTR(MP_QSTR_TYPE_APP), MP_ROM_INT(ESP_PARTITION_TYPE_APP) },
+    { MP_ROM_QSTR(MP_QSTR_TYPE_DATA), MP_ROM_INT(ESP_PARTITION_TYPE_DATA) },
+};
+STATIC MP_DEFINE_CONST_DICT(esp32_partition_locals_dict, esp32_partition_locals_dict_table);
+
+const mp_obj_type_t esp32_partition_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Partition,
+    .print = esp32_partition_print,
+    .make_new = esp32_partition_make_new,
+    .locals_dict = (mp_obj_dict_t *)&esp32_partition_locals_dict,
+};
diff --git a/ports/esp32/esp32_rmt.c b/ports/esp32/esp32_rmt.c
new file mode 100644
index 0000000000000..25b7b3808981c
--- /dev/null
+++ b/ports/esp32/esp32_rmt.c
@@ -0,0 +1,226 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 "Matt Trentini" <matt.trentini@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "modmachine.h"
+#include "mphalport.h"
+#include "driver/rmt.h"
+
+// This exposes the ESP32's RMT module to MicroPython. RMT is provided by the Espressif ESP-IDF:
+//
+//    https://docs.espressif.com/projects/esp-idf/en/latest/api-reference/peripherals/rmt.html
+//
+// With some examples provided:
+//
+//    https://github.com/espressif/arduino-esp32/tree/master/libraries/ESP32/examples/RMT
+//
+// RMT allows accurate (down to 12.5ns resolution) transmit - and receive - of pulse signals.
+// Originally designed to generate infrared remote control signals, the module is very
+// flexible and quite easy-to-use.
+//
+// This current MicroPython implementation lacks some major features, notably receive pulses
+// and carrier output.
+
+// Forward declaration
+extern const mp_obj_type_t esp32_rmt_type;
+
+typedef struct _esp32_rmt_obj_t {
+    mp_obj_base_t base;
+    uint8_t channel_id;
+    gpio_num_t pin;
+    uint8_t clock_div;
+    mp_uint_t num_items;
+    rmt_item32_t *items;
+} esp32_rmt_obj_t;
+
+STATIC mp_obj_t esp32_rmt_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_id,        MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = -1} },
+        { MP_QSTR_pin,       MP_ARG_REQUIRED | MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_clock_div,                   MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 8} }, // 100ns resolution
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    mp_uint_t channel_id = args[0].u_int;
+    gpio_num_t pin_id = machine_pin_get_id(args[1].u_obj);
+    mp_uint_t clock_div = args[2].u_int;
+
+    if (clock_div < 1 || clock_div > 255) {
+        mp_raise_ValueError(MP_ERROR_TEXT("clock_div must be between 1 and 255"));
+    }
+
+    esp32_rmt_obj_t *self = m_new_obj_with_finaliser(esp32_rmt_obj_t);
+    self->base.type = &esp32_rmt_type;
+    self->channel_id = channel_id;
+    self->pin = pin_id;
+    self->clock_div = clock_div;
+
+    rmt_config_t config;
+    config.rmt_mode = RMT_MODE_TX;
+    config.channel = (rmt_channel_t)self->channel_id;
+    config.gpio_num = self->pin;
+    config.mem_block_num = 1;
+    config.tx_config.loop_en = 0;
+
+    config.tx_config.carrier_en = 0;
+    config.tx_config.idle_output_en = 1;
+    config.tx_config.idle_level = 0;
+    config.tx_config.carrier_duty_percent = 0;
+    config.tx_config.carrier_freq_hz = 0;
+    config.tx_config.carrier_level = 1;
+
+    config.clk_div = self->clock_div;
+
+    check_esp_err(rmt_config(&config));
+    check_esp_err(rmt_driver_install(config.channel, 0, 0));
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC void esp32_rmt_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    esp32_rmt_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self->pin != -1) {
+        mp_printf(print, "RMT(channel=%u, pin=%u, source_freq=%u, clock_div=%u)",
+            self->channel_id, self->pin, APB_CLK_FREQ, self->clock_div);
+    } else {
+        mp_printf(print, "RMT()");
+    }
+}
+
+STATIC mp_obj_t esp32_rmt_deinit(mp_obj_t self_in) {
+    // fixme: check for valid channel. Return exception if error occurs.
+    esp32_rmt_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self->pin != -1) { // Check if channel has already been deinitialised.
+        rmt_driver_uninstall(self->channel_id);
+        self->pin = -1; // -1 to indicate RMT is unused
+        m_free(self->items);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp32_rmt_deinit_obj, esp32_rmt_deinit);
+
+// Return the source frequency.
+// Currently only the APB clock (80MHz) can be used but it is possible other
+// clock sources will added in the future.
+STATIC mp_obj_t esp32_rmt_source_freq(mp_obj_t self_in) {
+    return mp_obj_new_int(APB_CLK_FREQ);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp32_rmt_source_freq_obj, esp32_rmt_source_freq);
+
+// Return the clock divider.
+STATIC mp_obj_t esp32_rmt_clock_div(mp_obj_t self_in) {
+    esp32_rmt_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    return mp_obj_new_int(self->clock_div);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp32_rmt_clock_div_obj, esp32_rmt_clock_div);
+
+// Query whether the channel has finished sending pulses. Takes an optional
+// timeout (in ticks of the 80MHz clock), returning true if the pulse stream has
+// completed or false if they are still transmitting (or timeout is reached).
+STATIC mp_obj_t esp32_rmt_wait_done(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_self,    MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+    };
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    esp32_rmt_obj_t *self = MP_OBJ_TO_PTR(args[0].u_obj);
+
+    esp_err_t err = rmt_wait_tx_done(self->channel_id, args[1].u_int);
+    return err == ESP_OK ? mp_const_true : mp_const_false;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp32_rmt_wait_done_obj, 1, esp32_rmt_wait_done);
+
+STATIC mp_obj_t esp32_rmt_loop(mp_obj_t self_in, mp_obj_t loop) {
+    esp32_rmt_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    check_esp_err(rmt_set_tx_loop_mode(self->channel_id, mp_obj_get_int(loop)));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(esp32_rmt_loop_obj, esp32_rmt_loop);
+
+STATIC mp_obj_t esp32_rmt_write_pulses(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_self,   MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_pulses, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_start,  MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} },
+    };
+
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    esp32_rmt_obj_t *self = MP_OBJ_TO_PTR(args[0].u_obj);
+    mp_obj_t pulses = args[1].u_obj;
+    mp_uint_t start = args[2].u_int;
+
+    if (start < 0 || start > 1) {
+        mp_raise_ValueError(MP_ERROR_TEXT("start must be 0 or 1"));
+    }
+
+    size_t pulses_length = 0;
+    mp_obj_t *pulses_ptr = NULL;
+    mp_obj_get_array(pulses, &pulses_length, &pulses_ptr);
+
+    mp_uint_t num_items = (pulses_length / 2) + (pulses_length % 2);
+    if (num_items > self->num_items) {
+        self->items = (rmt_item32_t *)m_realloc(self->items, num_items * sizeof(rmt_item32_t *));
+        self->num_items = num_items;
+    }
+
+    for (mp_uint_t item_index = 0; item_index < num_items; item_index++) {
+        mp_uint_t pulse_index = item_index * 2;
+        self->items[item_index].duration0 = mp_obj_get_int(pulses_ptr[pulse_index++]);
+        self->items[item_index].level0 = start++; // Note that start _could_ wrap.
+        if (pulse_index < pulses_length) {
+            self->items[item_index].duration1 = mp_obj_get_int(pulses_ptr[pulse_index]);
+            self->items[item_index].level1 = start++;
+        }
+    }
+    check_esp_err(rmt_write_items(self->channel_id, self->items, num_items, false /* non-blocking */));
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp32_rmt_write_pulses_obj, 2, esp32_rmt_write_pulses);
+
+STATIC const mp_rom_map_elem_t esp32_rmt_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&esp32_rmt_deinit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&esp32_rmt_deinit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_source_freq), MP_ROM_PTR(&esp32_rmt_source_freq_obj) },
+    { MP_ROM_QSTR(MP_QSTR_clock_div), MP_ROM_PTR(&esp32_rmt_clock_div_obj) },
+    { MP_ROM_QSTR(MP_QSTR_wait_done), MP_ROM_PTR(&esp32_rmt_wait_done_obj) },
+    { MP_ROM_QSTR(MP_QSTR_loop), MP_ROM_PTR(&esp32_rmt_loop_obj) },
+    { MP_ROM_QSTR(MP_QSTR_write_pulses), MP_ROM_PTR(&esp32_rmt_write_pulses_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(esp32_rmt_locals_dict, esp32_rmt_locals_dict_table);
+
+const mp_obj_type_t esp32_rmt_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_RMT,
+    .print = esp32_rmt_print,
+    .make_new = esp32_rmt_make_new,
+    .locals_dict = (mp_obj_dict_t *)&esp32_rmt_locals_dict,
+};
diff --git a/ports/esp32/esp32_ulp.c b/ports/esp32/esp32_ulp.c
index 3772639f4416a..4e9d768146301 100644
--- a/ports/esp32/esp32_ulp.c
+++ b/ports/esp32/esp32_ulp.c
@@ -51,7 +51,7 @@ STATIC mp_obj_t esp32_ulp_set_wakeup_period(mp_obj_t self_in, mp_obj_t period_in
     mp_uint_t period_us = mp_obj_get_int(period_us_in);
     int _errno = ulp_set_wakeup_period(period_index, period_us);
     if (_errno != ESP_OK) {
-	    mp_raise_OSError(_errno);
+        mp_raise_OSError(_errno);
     }
     return mp_const_none;
 }
@@ -63,9 +63,9 @@ STATIC mp_obj_t esp32_ulp_load_binary(mp_obj_t self_in, mp_obj_t load_addr_in, m
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(program_binary_in, &bufinfo, MP_BUFFER_READ);
 
-    int _errno = ulp_load_binary(load_addr, bufinfo.buf, bufinfo.len/sizeof(uint32_t));
+    int _errno = ulp_load_binary(load_addr, bufinfo.buf, bufinfo.len / sizeof(uint32_t));
     if (_errno != ESP_OK) {
-	    mp_raise_OSError(_errno);
+        mp_raise_OSError(_errno);
     }
     return mp_const_none;
 }
@@ -73,9 +73,9 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_3(esp32_ulp_load_binary_obj, esp32_ulp_load_binar
 
 STATIC mp_obj_t esp32_ulp_run(mp_obj_t self_in, mp_obj_t entry_point_in) {
     mp_uint_t entry_point = mp_obj_get_int(entry_point_in);
-    int _errno = ulp_run(entry_point/sizeof(uint32_t));
+    int _errno = ulp_run(entry_point / sizeof(uint32_t));
     if (_errno != ESP_OK) {
-	    mp_raise_OSError(_errno);
+        mp_raise_OSError(_errno);
     }
     return mp_const_none;
 }
@@ -85,7 +85,11 @@ STATIC const mp_rom_map_elem_t esp32_ulp_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_set_wakeup_period), MP_ROM_PTR(&esp32_ulp_set_wakeup_period_obj) },
     { MP_ROM_QSTR(MP_QSTR_load_binary), MP_ROM_PTR(&esp32_ulp_load_binary_obj) },
     { MP_ROM_QSTR(MP_QSTR_run), MP_ROM_PTR(&esp32_ulp_run_obj) },
+    #if !MICROPY_ESP_IDF_4
     { MP_ROM_QSTR(MP_QSTR_RESERVE_MEM), MP_ROM_INT(CONFIG_ULP_COPROC_RESERVE_MEM) },
+    #else
+    { MP_ROM_QSTR(MP_QSTR_RESERVE_MEM), MP_ROM_INT(CONFIG_ESP32_ULP_COPROC_RESERVE_MEM) },
+    #endif
 };
 STATIC MP_DEFINE_CONST_DICT(esp32_ulp_locals_dict, esp32_ulp_locals_dict_table);
 
diff --git a/ports/esp32/espneopixel.c b/ports/esp32/espneopixel.c
index 829c8b1c80a19..bcdf38873be00 100644
--- a/ports/esp32/espneopixel.c
+++ b/ports/esp32/espneopixel.c
@@ -13,41 +13,51 @@ void IRAM_ATTR esp_neopixel_write(uint8_t pin, uint8_t *pixels, uint32_t numByte
     uint8_t *p, *end, pix, mask;
     uint32_t t, time0, time1, period, c, startTime, pinMask;
 
-    pinMask   = 1 << pin;
-    p         =  pixels;
-    end       =  p + numBytes;
-    pix       = *p++;
-    mask      = 0x80;
+    pinMask = 1 << pin;
+    p = pixels;
+    end = p + numBytes;
+    pix = *p++;
+    mask = 0x80;
     startTime = 0;
 
-    uint32_t fcpu = ets_get_cpu_frequency() * 1000000;
+    uint32_t fcpu = ets_get_cpu_frequency();
 
     if (timing == 1) {
         // 800 KHz
-        time0 = (fcpu * 0.35) / 1000000; // 0.35us
-        time1 = (fcpu * 0.8) / 1000000; // 0.8us
-        period = (fcpu * 1.25) / 1000000; // 1.25us per bit
+        time0 = (fcpu * 350) / 1000; // 0.35us
+        time1 = (fcpu * 800) / 1000; // 0.8us
+        period = (fcpu * 1250) / 1000; // 1.25us per bit
     } else {
         // 400 KHz
-        time0 = (fcpu * 0.5) / 1000000; // 0.35us
-        time1 = (fcpu * 1.2) / 1000000; // 0.8us
-        period = (fcpu * 2.5) / 1000000; // 1.25us per bit
+        time0 = (fcpu * 500) / 1000; // 0.5us
+        time1 = (fcpu * 1200) / 1000; // 1.2us
+        period = (fcpu * 2500) / 1000; // 2.5us per bit
     }
 
     uint32_t irq_state = mp_hal_quiet_timing_enter();
     for (t = time0;; t = time0) {
-        if (pix & mask) t = time1;                                  // Bit high duration
-        while (((c = mp_hal_ticks_cpu()) - startTime) < period);    // Wait for bit start
+        if (pix & mask) {
+            t = time1;                                              // Bit high duration
+        }
+        while (((c = mp_hal_ticks_cpu()) - startTime) < period) {
+            ;                                                       // Wait for bit start
+        }
         GPIO_REG_WRITE(GPIO_OUT_W1TS_REG, pinMask);                 // Set high
         startTime = c;                                              // Save start time
-        while (((c = mp_hal_ticks_cpu()) - startTime) < t);         // Wait high duration
+        while (((c = mp_hal_ticks_cpu()) - startTime) < t) {
+            ;                                                       // Wait high duration
+        }
         GPIO_REG_WRITE(GPIO_OUT_W1TC_REG, pinMask);                 // Set low
         if (!(mask >>= 1)) {                                        // Next bit/byte
-            if(p >= end) break;
-            pix  = *p++;
+            if (p >= end) {
+                break;
+            }
+            pix = *p++;
             mask = 0x80;
         }
     }
-    while ((mp_hal_ticks_cpu() - startTime) < period); // Wait for last bit
+    while ((mp_hal_ticks_cpu() - startTime) < period) {
+        ;                                              // Wait for last bit
+    }
     mp_hal_quiet_timing_exit(irq_state);
 }
diff --git a/ports/esp32/esponewire.c b/ports/esp32/esponewire.c
deleted file mode 100644
index 781616cbe4a7a..0000000000000
--- a/ports/esp32/esponewire.c
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * This file is part of the MicroPython project, http://micropython.org/
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2015-2017 Damien P. George
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "py/mphal.h"
-#include "esp8266/esponewire.h"
-
-#define TIMING_RESET1 (0)
-#define TIMING_RESET2 (1)
-#define TIMING_RESET3 (2)
-#define TIMING_READ1 (3)
-#define TIMING_READ2 (4)
-#define TIMING_READ3 (5)
-#define TIMING_WRITE1 (6)
-#define TIMING_WRITE2 (7)
-#define TIMING_WRITE3 (8)
-
-uint16_t esp_onewire_timings[9] = {480, 40, 420, 5, 5, 40, 10, 50, 10};
-
-#define DELAY_US mp_hal_delay_us_fast
-
-int esp_onewire_reset(mp_hal_pin_obj_t pin) {
-    mp_hal_pin_write(pin, 0);
-    DELAY_US(esp_onewire_timings[TIMING_RESET1]);
-    uint32_t i = MICROPY_BEGIN_ATOMIC_SECTION();
-    mp_hal_pin_write(pin, 1);
-    DELAY_US(esp_onewire_timings[TIMING_RESET2]);
-    int status = !mp_hal_pin_read(pin);
-    MICROPY_END_ATOMIC_SECTION(i);
-    DELAY_US(esp_onewire_timings[TIMING_RESET3]);
-    return status;
-}
-
-int esp_onewire_readbit(mp_hal_pin_obj_t pin) {
-    mp_hal_pin_write(pin, 1);
-    uint32_t i = MICROPY_BEGIN_ATOMIC_SECTION();
-    mp_hal_pin_write(pin, 0);
-    DELAY_US(esp_onewire_timings[TIMING_READ1]);
-    mp_hal_pin_write(pin, 1);
-    DELAY_US(esp_onewire_timings[TIMING_READ2]);
-    int value = mp_hal_pin_read(pin);
-    MICROPY_END_ATOMIC_SECTION(i);
-    DELAY_US(esp_onewire_timings[TIMING_READ3]);
-    return value;
-}
-
-void esp_onewire_writebit(mp_hal_pin_obj_t pin, int value) {
-    uint32_t i = MICROPY_BEGIN_ATOMIC_SECTION();
-    mp_hal_pin_write(pin, 0);
-    DELAY_US(esp_onewire_timings[TIMING_WRITE1]);
-    if (value) {
-        mp_hal_pin_write(pin, 1);
-    }
-    DELAY_US(esp_onewire_timings[TIMING_WRITE2]);
-    mp_hal_pin_write(pin, 1);
-    DELAY_US(esp_onewire_timings[TIMING_WRITE3]);
-    MICROPY_END_ATOMIC_SECTION(i);
-}
diff --git a/ports/esp32/fatfs_port.c b/ports/esp32/fatfs_port.c
index 880324ed82dec..779ba1c88accc 100644
--- a/ports/esp32/fatfs_port.c
+++ b/ports/esp32/fatfs_port.c
@@ -36,6 +36,6 @@ DWORD get_fattime(void) {
     timeutils_struct_time_t tm;
     timeutils_seconds_since_2000_to_struct_time(tv.tv_sec, &tm);
 
-    return (((DWORD)(tm.tm_year - 1980) << 25) | ((DWORD)tm.tm_mon << 21) | ((DWORD)tm.tm_mday << 16) |
-           ((DWORD)tm.tm_hour << 11) | ((DWORD)tm.tm_min << 5) | ((DWORD)tm.tm_sec >> 1));
+    return ((DWORD)(tm.tm_year - 1980) << 25) | ((DWORD)tm.tm_mon << 21) | ((DWORD)tm.tm_mday << 16) |
+           ((DWORD)tm.tm_hour << 11) | ((DWORD)tm.tm_min << 5) | ((DWORD)tm.tm_sec >> 1);
 }
diff --git a/ports/esp32/gccollect.c b/ports/esp32/gccollect.c
index 9843cef0083c9..7d5da57e7685e 100644
--- a/ports/esp32/gccollect.c
+++ b/ports/esp32/gccollect.c
@@ -49,7 +49,7 @@ static void gc_collect_inner(int level) {
     if (level == XCHAL_NUM_AREGS / 8) {
         // get the sp
         volatile uint32_t sp = (uint32_t)get_sp();
-        gc_collect_root((void**)sp, ((mp_uint_t)MP_STATE_THREAD(stack_top) - sp) / sizeof(uint32_t));
+        gc_collect_root((void **)sp, ((mp_uint_t)MP_STATE_THREAD(stack_top) - sp) / sizeof(uint32_t));
         return;
     }
 
diff --git a/ports/esp32/help.c b/ports/esp32/help.c
index 95d115c563bc4..2336d97f84416 100644
--- a/ports/esp32/help.c
+++ b/ports/esp32/help.c
@@ -29,37 +29,37 @@
 #include "py/builtin.h"
 
 const char esp32_help_text[] =
-"Welcome to MicroPython on the ESP32!\n"
-"\n"
-"For generic online docs please visit http://docs.micropython.org/\n"
-"\n"
-"For access to the hardware use the 'machine' module:\n"
-"\n"
-"import machine\n"
-"pin12 = machine.Pin(12, machine.Pin.OUT)\n"
-"pin12.value(1)\n"
-"pin13 = machine.Pin(13, machine.Pin.IN, machine.Pin.PULL_UP)\n"
-"print(pin13.value())\n"
-"i2c = machine.I2C(scl=machine.Pin(21), sda=machine.Pin(22))\n"
-"i2c.scan()\n"
-"i2c.writeto(addr, b'1234')\n"
-"i2c.readfrom(addr, 4)\n"
-"\n"
-"Basic WiFi configuration:\n"
-"\n"
-"import network\n"
-"sta_if = network.WLAN(network.STA_IF); sta_if.active(True)\n"
-"sta_if.scan()                             # Scan for available access points\n"
-"sta_if.connect(\"<AP_name>\", \"<password>\") # Connect to an AP\n"
-"sta_if.isconnected()                      # Check for successful connection\n"
-"\n"
-"Control commands:\n"
-"  CTRL-A        -- on a blank line, enter raw REPL mode\n"
-"  CTRL-B        -- on a blank line, enter normal REPL mode\n"
-"  CTRL-C        -- interrupt a running program\n"
-"  CTRL-D        -- on a blank line, do a soft reset of the board\n"
-"  CTRL-E        -- on a blank line, enter paste mode\n"
-"\n"
-"For further help on a specific object, type help(obj)\n"
-"For a list of available modules, type help('modules')\n"
+    "Welcome to MicroPython on the ESP32!\n"
+    "\n"
+    "For generic online docs please visit http://docs.micropython.org/\n"
+    "\n"
+    "For access to the hardware use the 'machine' module:\n"
+    "\n"
+    "import machine\n"
+    "pin12 = machine.Pin(12, machine.Pin.OUT)\n"
+    "pin12.value(1)\n"
+    "pin13 = machine.Pin(13, machine.Pin.IN, machine.Pin.PULL_UP)\n"
+    "print(pin13.value())\n"
+    "i2c = machine.I2C(scl=machine.Pin(21), sda=machine.Pin(22))\n"
+    "i2c.scan()\n"
+    "i2c.writeto(addr, b'1234')\n"
+    "i2c.readfrom(addr, 4)\n"
+    "\n"
+    "Basic WiFi configuration:\n"
+    "\n"
+    "import network\n"
+    "sta_if = network.WLAN(network.STA_IF); sta_if.active(True)\n"
+    "sta_if.scan()                             # Scan for available access points\n"
+    "sta_if.connect(\"<AP_name>\", \"<password>\") # Connect to an AP\n"
+    "sta_if.isconnected()                      # Check for successful connection\n"
+    "\n"
+    "Control commands:\n"
+    "  CTRL-A        -- on a blank line, enter raw REPL mode\n"
+    "  CTRL-B        -- on a blank line, enter normal REPL mode\n"
+    "  CTRL-C        -- interrupt a running program\n"
+    "  CTRL-D        -- on a blank line, do a soft reset of the board\n"
+    "  CTRL-E        -- on a blank line, enter paste mode\n"
+    "\n"
+    "For further help on a specific object, type help(obj)\n"
+    "For a list of available modules, type help('modules')\n"
 ;
diff --git a/ports/esp32/machine_adc.c b/ports/esp32/machine_adc.c
index d62f362e96b34..811a208e6d54f 100644
--- a/ports/esp32/machine_adc.c
+++ b/ports/esp32/machine_adc.c
@@ -53,12 +53,15 @@ STATIC const madc_obj_t madc_obj[] = {
     {{&machine_adc_type}, GPIO_NUM_35, ADC1_CHANNEL_7},
 };
 
+STATIC uint8_t adc_bit_width;
+
 STATIC mp_obj_t madc_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw,
-        const mp_obj_t *args) {
+    const mp_obj_t *args) {
 
     static int initialized = 0;
     if (!initialized) {
         adc1_config_width(ADC_WIDTH_12Bit);
+        adc_bit_width = 12;
         initialized = 1;
     }
 
@@ -66,12 +69,19 @@ STATIC mp_obj_t madc_make_new(const mp_obj_type_t *type, size_t n_args, size_t n
     gpio_num_t pin_id = machine_pin_get_id(args[0]);
     const madc_obj_t *self = NULL;
     for (int i = 0; i < MP_ARRAY_SIZE(madc_obj); i++) {
-        if (pin_id == madc_obj[i].gpio_id) { self = &madc_obj[i]; break; }
+        if (pin_id == madc_obj[i].gpio_id) {
+            self = &madc_obj[i];
+            break;
+        }
+    }
+    if (!self) {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid Pin for ADC"));
     }
-    if (!self) mp_raise_ValueError("invalid Pin for ADC");
     esp_err_t err = adc1_config_channel_atten(self->adc1_id, ADC_ATTEN_0db);
-    if (err == ESP_OK) return MP_OBJ_FROM_PTR(self);
-    mp_raise_ValueError("Parameter Error");
+    if (err == ESP_OK) {
+        return MP_OBJ_FROM_PTR(self);
+    }
+    mp_raise_ValueError(MP_ERROR_TEXT("parameter error"));
 }
 
 STATIC void madc_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
@@ -79,10 +89,23 @@ STATIC void madc_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_
     mp_printf(print, "ADC(Pin(%u))", self->gpio_id);
 }
 
+// read_u16()
+STATIC mp_obj_t madc_read_u16(mp_obj_t self_in) {
+    madc_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    uint32_t raw = adc1_get_raw(self->adc1_id);
+    // Scale raw reading to 16 bit value using a Taylor expansion (for 8 <= bits <= 16)
+    uint32_t u16 = raw << (16 - adc_bit_width) | raw >> (2 * adc_bit_width - 16);
+    return MP_OBJ_NEW_SMALL_INT(u16);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(madc_read_u16_obj, madc_read_u16);
+
+// Legacy method
 STATIC mp_obj_t madc_read(mp_obj_t self_in) {
     madc_obj_t *self = self_in;
     int val = adc1_get_raw(self->adc1_id);
-    if (val == -1) mp_raise_ValueError("Parameter Error");
+    if (val == -1) {
+        mp_raise_ValueError(MP_ERROR_TEXT("parameter error"));
+    }
     return MP_OBJ_NEW_SMALL_INT(val);
 }
 MP_DEFINE_CONST_FUN_OBJ_1(madc_read_obj, madc_read);
@@ -91,21 +114,43 @@ STATIC mp_obj_t madc_atten(mp_obj_t self_in, mp_obj_t atten_in) {
     madc_obj_t *self = self_in;
     adc_atten_t atten = mp_obj_get_int(atten_in);
     esp_err_t err = adc1_config_channel_atten(self->adc1_id, atten);
-    if (err == ESP_OK) return mp_const_none;
-    mp_raise_ValueError("Parameter Error");
+    if (err == ESP_OK) {
+        return mp_const_none;
+    }
+    mp_raise_ValueError(MP_ERROR_TEXT("parameter error"));
 }
 MP_DEFINE_CONST_FUN_OBJ_2(madc_atten_obj, madc_atten);
 
 STATIC mp_obj_t madc_width(mp_obj_t cls_in, mp_obj_t width_in) {
     adc_bits_width_t width = mp_obj_get_int(width_in);
     esp_err_t err = adc1_config_width(width);
-    if (err == ESP_OK) return mp_const_none;
-    mp_raise_ValueError("Parameter Error");
+    if (err != ESP_OK) {
+        mp_raise_ValueError(MP_ERROR_TEXT("parameter error"));
+    }
+    switch (width) {
+        case ADC_WIDTH_9Bit:
+            adc_bit_width = 9;
+            break;
+        case ADC_WIDTH_10Bit:
+            adc_bit_width = 10;
+            break;
+        case ADC_WIDTH_11Bit:
+            adc_bit_width = 11;
+            break;
+        case ADC_WIDTH_12Bit:
+            adc_bit_width = 12;
+            break;
+        default:
+            break;
+    }
+    return mp_const_none;
 }
 MP_DEFINE_CONST_FUN_OBJ_2(madc_width_fun_obj, madc_width);
 MP_DEFINE_CONST_CLASSMETHOD_OBJ(madc_width_obj, MP_ROM_PTR(&madc_width_fun_obj));
 
 STATIC const mp_rom_map_elem_t madc_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_read_u16), MP_ROM_PTR(&madc_read_u16_obj) },
+
     { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&madc_read_obj) },
     { MP_ROM_QSTR(MP_QSTR_atten), MP_ROM_PTR(&madc_atten_obj) },
     { MP_ROM_QSTR(MP_QSTR_width), MP_ROM_PTR(&madc_width_obj) },
diff --git a/ports/esp32/machine_dac.c b/ports/esp32/machine_dac.c
index bd0804ec41514..02855fcf8048e 100644
--- a/ports/esp32/machine_dac.c
+++ b/ports/esp32/machine_dac.c
@@ -48,22 +48,29 @@ STATIC const mdac_obj_t mdac_obj[] = {
 };
 
 STATIC mp_obj_t mdac_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw,
-        const mp_obj_t *args) {
+    const mp_obj_t *args) {
 
     mp_arg_check_num(n_args, n_kw, 1, 1, true);
     gpio_num_t pin_id = machine_pin_get_id(args[0]);
     const mdac_obj_t *self = NULL;
     for (int i = 0; i < MP_ARRAY_SIZE(mdac_obj); i++) {
-        if (pin_id == mdac_obj[i].gpio_id) { self = &mdac_obj[i]; break; }
+        if (pin_id == mdac_obj[i].gpio_id) {
+            self = &mdac_obj[i];
+            break;
+        }
+    }
+    if (!self) {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid Pin for DAC"));
     }
-    if (!self) mp_raise_ValueError("invalid Pin for DAC");
 
     esp_err_t err = dac_output_enable(self->dac_id);
     if (err == ESP_OK) {
         err = dac_output_voltage(self->dac_id, 0);
     }
-    if (err == ESP_OK) return MP_OBJ_FROM_PTR(self);
-    mp_raise_ValueError("Parameter Error");
+    if (err == ESP_OK) {
+        return MP_OBJ_FROM_PTR(self);
+    }
+    mp_raise_ValueError(MP_ERROR_TEXT("parameter error"));
 }
 
 STATIC void mdac_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
@@ -74,11 +81,15 @@ STATIC void mdac_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_
 STATIC mp_obj_t mdac_write(mp_obj_t self_in, mp_obj_t value_in) {
     mdac_obj_t *self = self_in;
     int value = mp_obj_get_int(value_in);
-    if (value < 0 || value > 255) mp_raise_ValueError("Value out of range");
+    if (value < 0 || value > 255) {
+        mp_raise_ValueError(MP_ERROR_TEXT("value out of range"));
+    }
 
     esp_err_t err = dac_output_voltage(self->dac_id, value);
-    if (err == ESP_OK) return mp_const_none;
-    mp_raise_ValueError("Parameter Error");
+    if (err == ESP_OK) {
+        return mp_const_none;
+    }
+    mp_raise_ValueError(MP_ERROR_TEXT("parameter error"));
 }
 MP_DEFINE_CONST_FUN_OBJ_2(mdac_write_obj, mdac_write);
 
diff --git a/ports/esp32/machine_hw_spi.c b/ports/esp32/machine_hw_spi.c
index 2f63a32d4a8cf..3962e26b78610 100644
--- a/ports/esp32/machine_hw_spi.c
+++ b/ports/esp32/machine_hw_spi.c
@@ -64,21 +64,21 @@ STATIC machine_hw_spi_obj_t machine_hw_spi_obj[2];
 STATIC void machine_hw_spi_deinit_internal(machine_hw_spi_obj_t *self) {
     switch (spi_bus_remove_device(self->spi)) {
         case ESP_ERR_INVALID_ARG:
-            mp_raise_msg(&mp_type_OSError, "invalid configuration");
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid configuration"));
             return;
 
         case ESP_ERR_INVALID_STATE:
-            mp_raise_msg(&mp_type_OSError, "SPI device already freed");
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("SPI device already freed"));
             return;
     }
 
     switch (spi_bus_free(self->host)) {
         case ESP_ERR_INVALID_ARG:
-            mp_raise_msg(&mp_type_OSError, "invalid configuration");
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid configuration"));
             return;
 
         case ESP_ERR_INVALID_STATE:
-            mp_raise_msg(&mp_type_OSError, "SPI bus already freed");
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("SPI bus already freed"));
             return;
     }
 
@@ -94,16 +94,16 @@ STATIC void machine_hw_spi_deinit_internal(machine_hw_spi_obj_t *self) {
 }
 
 STATIC void machine_hw_spi_init_internal(
-    machine_hw_spi_obj_t    *self,
-    int8_t                  host,
-    int32_t                 baudrate,
-    int8_t                  polarity,
-    int8_t                  phase,
-    int8_t                  bits,
-    int8_t                  firstbit,
-    int8_t                  sck,
-    int8_t                  mosi,
-    int8_t                  miso) {
+    machine_hw_spi_obj_t *self,
+    int8_t host,
+    int32_t baudrate,
+    int8_t polarity,
+    int8_t phase,
+    int8_t bits,
+    int8_t firstbit,
+    int8_t sck,
+    int8_t mosi,
+    int8_t miso) {
 
     // if we're not initialized, then we're
     // implicitly 'changed', since this is the init routine
@@ -129,7 +129,7 @@ STATIC void machine_hw_spi_init_internal(
     }
 
     if (phase != -1 && phase != self->phase) {
-        self->phase =  phase;
+        self->phase = phase;
         changed = true;
     }
 
@@ -159,7 +159,7 @@ STATIC void machine_hw_spi_init_internal(
     }
 
     if (self->host != HSPI_HOST && self->host != VSPI_HOST) {
-        mp_raise_ValueError("SPI ID must be either HSPI(1) or VSPI(2)");
+        mp_raise_ValueError(MP_ERROR_TEXT("SPI ID must be either HSPI(1) or VSPI(2)"));
     }
 
     if (changed) {
@@ -188,7 +188,7 @@ STATIC void machine_hw_spi_init_internal(
         .pre_cb = NULL
     };
 
-    //Initialize the SPI bus
+    // Initialize the SPI bus
 
     // Select DMA channel based on the hardware SPI host
     int dma_chan = 0;
@@ -201,28 +201,28 @@ STATIC void machine_hw_spi_init_internal(
     ret = spi_bus_initialize(self->host, &buscfg, dma_chan);
     switch (ret) {
         case ESP_ERR_INVALID_ARG:
-            mp_raise_msg(&mp_type_OSError, "invalid configuration");
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid configuration"));
             return;
 
         case ESP_ERR_INVALID_STATE:
-            mp_raise_msg(&mp_type_OSError, "SPI device already in use");
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("SPI host already in use"));
             return;
     }
 
     ret = spi_bus_add_device(self->host, &devcfg, &self->spi);
     switch (ret) {
         case ESP_ERR_INVALID_ARG:
-            mp_raise_msg(&mp_type_OSError, "invalid configuration");
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("invalid configuration"));
             spi_bus_free(self->host);
             return;
 
         case ESP_ERR_NO_MEM:
-            mp_raise_msg(&mp_type_OSError, "out of memory");
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("out of memory"));
             spi_bus_free(self->host);
             return;
 
         case ESP_ERR_NOT_FOUND:
-            mp_raise_msg(&mp_type_OSError, "no free slots");
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("no free slots"));
             spi_bus_free(self->host);
             return;
     }
@@ -230,7 +230,7 @@ STATIC void machine_hw_spi_init_internal(
 }
 
 STATIC void machine_hw_spi_deinit(mp_obj_base_t *self_in) {
-    machine_hw_spi_obj_t *self = (machine_hw_spi_obj_t *) self_in;
+    machine_hw_spi_obj_t *self = (machine_hw_spi_obj_t *)self_in;
     if (self->state == MACHINE_HW_SPI_STATE_INIT) {
         self->state = MACHINE_HW_SPI_STATE_DEINIT;
         machine_hw_spi_deinit_internal(self);
@@ -241,7 +241,7 @@ STATIC void machine_hw_spi_transfer(mp_obj_base_t *self_in, size_t len, const ui
     machine_hw_spi_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
     if (self->state == MACHINE_HW_SPI_STATE_DEINIT) {
-        mp_raise_msg(&mp_type_OSError, "transfer on deinitialized SPI");
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("transfer on deinitialized SPI"));
         return;
     }
 
@@ -295,13 +295,13 @@ STATIC void machine_hw_spi_transfer(mp_obj_base_t *self_in, size_t len, const ui
 STATIC void machine_hw_spi_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     machine_hw_spi_obj_t *self = MP_OBJ_TO_PTR(self_in);
     mp_printf(print, "SPI(id=%u, baudrate=%u, polarity=%u, phase=%u, bits=%u, firstbit=%u, sck=%d, mosi=%d, miso=%d)",
-              self->host, self->baudrate, self->polarity,
-              self->phase, self->bits, self->firstbit,
-              self->sck, self->mosi, self->miso);
+        self->host, self->baudrate, self->polarity,
+        self->phase, self->bits, self->firstbit,
+        self->sck, self->mosi, self->miso);
 }
 
 STATIC void machine_hw_spi_init(mp_obj_base_t *self_in, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    machine_hw_spi_obj_t *self = (machine_hw_spi_obj_t *) self_in;
+    machine_hw_spi_obj_t *self = (machine_hw_spi_obj_t *)self_in;
 
     enum { ARG_id, ARG_baudrate, ARG_polarity, ARG_phase, ARG_bits, ARG_firstbit, ARG_sck, ARG_mosi, ARG_miso };
     static const mp_arg_t allowed_args[] = {
@@ -318,7 +318,7 @@ STATIC void machine_hw_spi_init(mp_obj_base_t *self_in, size_t n_args, const mp_
 
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args),
-                     allowed_args, args);
+        allowed_args, args);
     int8_t sck, mosi, miso;
 
     if (args[ARG_sck].u_obj == MP_OBJ_NULL) {
@@ -346,8 +346,8 @@ STATIC void machine_hw_spi_init(mp_obj_base_t *self_in, size_t n_args, const mp_
     }
 
     machine_hw_spi_init_internal(self, args[ARG_id].u_int, args[ARG_baudrate].u_int,
-                                 args[ARG_polarity].u_int, args[ARG_phase].u_int, args[ARG_bits].u_int,
-                                 args[ARG_firstbit].u_int, sck, mosi, miso);
+        args[ARG_polarity].u_int, args[ARG_phase].u_int, args[ARG_bits].u_int,
+        args[ARG_firstbit].u_int, sck, mosi, miso);
 }
 
 mp_obj_t machine_hw_spi_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
@@ -401,5 +401,5 @@ const mp_obj_type_t machine_hw_spi_type = {
     .print = machine_hw_spi_print,
     .make_new = machine_hw_spi_make_new,
     .protocol = &machine_hw_spi_p,
-    .locals_dict = (mp_obj_dict_t *) &mp_machine_spi_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&mp_machine_spi_locals_dict,
 };
diff --git a/ports/esp32/machine_i2c.c b/ports/esp32/machine_i2c.c
new file mode 100644
index 0000000000000..8362ed5e7be5a
--- /dev/null
+++ b/ports/esp32/machine_i2c.c
@@ -0,0 +1,179 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "py/mperrno.h"
+#include "extmod/machine_i2c.h"
+
+#include "driver/i2c.h"
+
+#define I2C_0_DEFAULT_SCL (GPIO_NUM_18)
+#define I2C_0_DEFAULT_SDA (GPIO_NUM_19)
+#define I2C_1_DEFAULT_SCL (GPIO_NUM_25)
+#define I2C_1_DEFAULT_SDA (GPIO_NUM_26)
+
+#define I2C_DEFAULT_TIMEOUT_US (10000) // 10ms
+
+typedef struct _machine_hw_i2c_obj_t {
+    mp_obj_base_t base;
+    i2c_port_t port : 8;
+    gpio_num_t scl : 8;
+    gpio_num_t sda : 8;
+} machine_hw_i2c_obj_t;
+
+STATIC const mp_obj_type_t machine_hw_i2c_type;
+STATIC machine_hw_i2c_obj_t machine_hw_i2c_obj[I2C_NUM_MAX];
+
+STATIC void machine_hw_i2c_init(machine_hw_i2c_obj_t *self, uint32_t freq, uint32_t timeout_us, bool first_init) {
+    if (!first_init) {
+        i2c_driver_delete(self->port);
+    }
+    i2c_config_t conf = {
+        .mode = I2C_MODE_MASTER,
+        .sda_io_num = self->sda,
+        .sda_pullup_en = GPIO_PULLUP_ENABLE,
+        .scl_io_num = self->scl,
+        .scl_pullup_en = GPIO_PULLUP_ENABLE,
+        .master.clk_speed = freq,
+    };
+    i2c_param_config(self->port, &conf);
+    i2c_set_timeout(self->port, I2C_APB_CLK_FREQ / 1000000 * timeout_us);
+    i2c_driver_install(self->port, I2C_MODE_MASTER, 0, 0, 0);
+}
+
+int machine_hw_i2c_transfer(mp_obj_base_t *self_in, uint16_t addr, size_t n, mp_machine_i2c_buf_t *bufs, unsigned int flags) {
+    machine_hw_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
+    i2c_master_start(cmd);
+    i2c_master_write_byte(cmd, addr << 1 | (flags & MP_MACHINE_I2C_FLAG_READ), true);
+
+    int data_len = 0;
+    for (; n--; ++bufs) {
+        if (flags & MP_MACHINE_I2C_FLAG_READ) {
+            i2c_master_read(cmd, bufs->buf, bufs->len, n == 0 ? I2C_MASTER_LAST_NACK : I2C_MASTER_ACK);
+        } else {
+            if (bufs->len != 0) {
+                i2c_master_write(cmd, bufs->buf, bufs->len, true);
+            }
+        }
+        data_len += bufs->len;
+    }
+
+    if (flags & MP_MACHINE_I2C_FLAG_STOP) {
+        i2c_master_stop(cmd);
+    }
+
+    // TODO proper timeout
+    esp_err_t err = i2c_master_cmd_begin(self->port, cmd, 100 * (1 + data_len) / portTICK_RATE_MS);
+    i2c_cmd_link_delete(cmd);
+
+    if (err == ESP_FAIL) {
+        return -MP_ENODEV;
+    } else if (err == ESP_ERR_TIMEOUT) {
+        return -MP_ETIMEDOUT;
+    } else if (err != ESP_OK) {
+        return -abs(err);
+    }
+
+    return data_len;
+}
+
+/******************************************************************************/
+// MicroPython bindings for machine API
+
+STATIC void machine_hw_i2c_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    machine_hw_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    int h, l;
+    i2c_get_period(self->port, &h, &l);
+    mp_printf(print, "I2C(%u, scl=%u, sda=%u, freq=%u)",
+        self->port, self->scl, self->sda, I2C_APB_CLK_FREQ / (h + l));
+}
+
+mp_obj_t machine_hw_i2c_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    // Parse args
+    enum { ARG_id, ARG_scl, ARG_sda, ARG_freq, ARG_timeout };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_id, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_scl, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_sda, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_freq, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 400000} },
+        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = I2C_DEFAULT_TIMEOUT_US} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // Get I2C bus
+    mp_int_t i2c_id = mp_obj_get_int(args[ARG_id].u_obj);
+    if (!(I2C_NUM_0 <= i2c_id && i2c_id < I2C_NUM_MAX)) {
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("I2C(%d) doesn't exist"), i2c_id);
+    }
+
+    // Get static peripheral object
+    machine_hw_i2c_obj_t *self = (machine_hw_i2c_obj_t *)&machine_hw_i2c_obj[i2c_id];
+
+    bool first_init = false;
+    if (self->base.type == NULL) {
+        // Created for the first time, set default pins
+        self->base.type = &machine_hw_i2c_type;
+        self->port = i2c_id;
+        if (self->port == I2C_NUM_0) {
+            self->scl = I2C_0_DEFAULT_SCL;
+            self->sda = I2C_0_DEFAULT_SDA;
+        } else {
+            self->scl = I2C_1_DEFAULT_SCL;
+            self->sda = I2C_1_DEFAULT_SDA;
+        }
+        first_init = true;
+    }
+
+    // Set SCL/SDA pins if given
+    if (args[ARG_scl].u_obj != MP_OBJ_NULL) {
+        self->scl = mp_hal_get_pin_obj(args[ARG_scl].u_obj);
+    }
+    if (args[ARG_sda].u_obj != MP_OBJ_NULL) {
+        self->sda = mp_hal_get_pin_obj(args[ARG_sda].u_obj);
+    }
+
+    // Initialise the I2C peripheral
+    machine_hw_i2c_init(self, args[ARG_freq].u_int, args[ARG_timeout].u_int, first_init);
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC const mp_machine_i2c_p_t machine_hw_i2c_p = {
+    .transfer = machine_hw_i2c_transfer,
+};
+
+STATIC const mp_obj_type_t machine_hw_i2c_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_I2C,
+    .print = machine_hw_i2c_print,
+    .make_new = machine_hw_i2c_make_new,
+    .protocol = &machine_hw_i2c_p,
+    .locals_dict = (mp_obj_dict_t *)&mp_machine_soft_i2c_locals_dict,
+};
diff --git a/ports/esp32/machine_pin.c b/ports/esp32/machine_pin.c
index cca7c0ef66be3..a55cc1f4abaca 100644
--- a/ports/esp32/machine_pin.c
+++ b/ports/esp32/machine_pin.c
@@ -126,7 +126,7 @@ STATIC void machine_pin_isr_handler(void *arg) {
 
 gpio_num_t machine_pin_get_id(mp_obj_t pin_in) {
     if (mp_obj_get_type(pin_in) != &machine_pin_type) {
-        mp_raise_ValueError("expecting a pin");
+        mp_raise_ValueError(MP_ERROR_TEXT("expecting a pin"));
     }
     machine_pin_obj_t *self = pin_in;
     return self->id;
@@ -162,7 +162,7 @@ STATIC mp_obj_t machine_pin_obj_init_helper(const machine_pin_obj_t *self, size_
     if (args[ARG_mode].u_obj != mp_const_none) {
         mp_int_t pin_io_mode = mp_obj_get_int(args[ARG_mode].u_obj);
         if (self->id >= 34 && (pin_io_mode & GPIO_MODE_DEF_OUTPUT)) {
-            mp_raise_ValueError("pin can only be input");
+            mp_raise_ValueError(MP_ERROR_TEXT("pin can only be input"));
         } else {
             gpio_set_direction(self->id, pin_io_mode);
         }
@@ -202,10 +202,10 @@ mp_obj_t mp_pin_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw,
     int wanted_pin = mp_obj_get_int(args[0]);
     const machine_pin_obj_t *self = NULL;
     if (0 <= wanted_pin && wanted_pin < MP_ARRAY_SIZE(machine_pin_obj)) {
-        self = (machine_pin_obj_t*)&machine_pin_obj[wanted_pin];
+        self = (machine_pin_obj_t *)&machine_pin_obj[wanted_pin];
     }
     if (self == NULL || self->base.type == NULL) {
-        mp_raise_ValueError("invalid pin");
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid pin"));
     }
 
     if (n_args > 1 || n_kw > 0) {
@@ -282,24 +282,24 @@ STATIC mp_obj_t machine_pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_
             mp_int_t wake;
             if (mp_obj_get_int_maybe(wake_obj, &wake)) {
                 if (wake < 2 || wake > 7) {
-                    mp_raise_ValueError("bad wake value");
+                    mp_raise_ValueError(MP_ERROR_TEXT("bad wake value"));
                 }
             } else {
-                mp_raise_ValueError("bad wake value");
+                mp_raise_ValueError(MP_ERROR_TEXT("bad wake value"));
             }
 
             if (machine_rtc_config.wake_on_touch) { // not compatible
-                mp_raise_ValueError("no resources");
+                mp_raise_ValueError(MP_ERROR_TEXT("no resources"));
             }
 
             if (!RTC_IS_VALID_EXT_PIN(self->id)) {
-                mp_raise_ValueError("invalid pin for wake");
+                mp_raise_ValueError(MP_ERROR_TEXT("invalid pin for wake"));
             }
 
             if (machine_rtc_config.ext0_pin == -1) {
                 machine_rtc_config.ext0_pin = self->id;
             } else if (machine_rtc_config.ext0_pin != self->id) {
-                mp_raise_ValueError("no resources");
+                mp_raise_ValueError(MP_ERROR_TEXT("no resources"));
             }
 
             machine_rtc_config.ext0_level = trigger == GPIO_PIN_INTR_LOLEVEL ? 0 : 1;
@@ -316,7 +316,7 @@ STATIC mp_obj_t machine_pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_
             gpio_isr_handler_remove(self->id);
             MP_STATE_PORT(machine_pin_irq_handler)[self->id] = handler;
             gpio_set_intr_type(self->id, trigger);
-            gpio_isr_handler_add(self->id, machine_pin_isr_handler, (void*)self);
+            gpio_isr_handler_add(self->id, machine_pin_isr_handler, (void *)self);
         }
     }
 
@@ -365,7 +365,7 @@ STATIC mp_uint_t pin_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, i
 STATIC MP_DEFINE_CONST_DICT(machine_pin_locals_dict, machine_pin_locals_dict_table);
 
 STATIC const mp_pin_p_t pin_pin_p = {
-  .ioctl = pin_ioctl,
+    .ioctl = pin_ioctl,
 };
 
 const mp_obj_type_t machine_pin_type = {
@@ -429,7 +429,7 @@ STATIC const machine_pin_irq_obj_t machine_pin_irq_object[] = {
 STATIC mp_obj_t machine_pin_irq_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     machine_pin_irq_obj_t *self = self_in;
     mp_arg_check_num(n_args, n_kw, 0, 0, false);
-    machine_pin_isr_handler((void*)&machine_pin_obj[self->id]);
+    machine_pin_isr_handler((void *)&machine_pin_obj[self->id]);
     return mp_const_none;
 }
 
@@ -454,5 +454,5 @@ STATIC const mp_obj_type_t machine_pin_irq_type = {
     { &mp_type_type },
     .name = MP_QSTR_IRQ,
     .call = machine_pin_irq_call,
-    .locals_dict = (mp_obj_dict_t*)&machine_pin_irq_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&machine_pin_irq_locals_dict,
 };
diff --git a/ports/esp32/machine_pwm.c b/ports/esp32/machine_pwm.c
index 7376470dccbf2..7592f243b76f3 100644
--- a/ports/esp32/machine_pwm.c
+++ b/ports/esp32/machine_pwm.c
@@ -120,7 +120,7 @@ STATIC void esp32_pwm_print(const mp_print_t *print, mp_obj_t self_in, mp_print_
 }
 
 STATIC void esp32_pwm_init_helper(esp32_pwm_obj_t *self,
-        size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     enum { ARG_freq, ARG_duty };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_freq, MP_ARG_INT, {.u_int = -1} },
@@ -145,7 +145,7 @@ STATIC void esp32_pwm_init_helper(esp32_pwm_obj_t *self,
     }
     if (channel >= LEDC_CHANNEL_MAX) {
         if (avail == -1) {
-            mp_raise_ValueError("out of PWM channels");
+            mp_raise_ValueError(MP_ERROR_TEXT("out of PWM channels"));
         }
         channel = avail;
     }
@@ -163,8 +163,7 @@ STATIC void esp32_pwm_init_helper(esp32_pwm_obj_t *self,
             .timer_sel = PWTIMER,
         };
         if (ledc_channel_config(&cfg) != ESP_OK) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-                "PWM not supported on pin %d", self->pin));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("PWM not supported on pin %d"), self->pin);
         }
         chan_gpio[channel] = self->pin;
     }
@@ -174,8 +173,7 @@ STATIC void esp32_pwm_init_helper(esp32_pwm_obj_t *self,
     if (tval != -1) {
         if (tval != timer_cfg.freq_hz) {
             if (!set_freq(tval)) {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-                    "Bad frequency %d", tval));
+                mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("bad frequency %d"), tval);
             }
         }
     }
@@ -183,7 +181,7 @@ STATIC void esp32_pwm_init_helper(esp32_pwm_obj_t *self,
     // Set duty cycle?
     int dval = args[ARG_duty].u_int;
     if (dval != -1) {
-        dval &= ((1 << PWRES)-1);
+        dval &= ((1 << PWRES) - 1);
         dval >>= PWRES - timer_cfg.duty_resolution;
         ledc_set_duty(PWMODE, channel, dval);
         ledc_update_duty(PWMODE, channel);
@@ -191,7 +189,7 @@ STATIC void esp32_pwm_init_helper(esp32_pwm_obj_t *self,
 }
 
 STATIC mp_obj_t esp32_pwm_make_new(const mp_obj_type_t *type,
-        size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    size_t n_args, size_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
     gpio_num_t pin_id = machine_pin_get_id(args[0]);
 
@@ -217,7 +215,7 @@ STATIC mp_obj_t esp32_pwm_make_new(const mp_obj_type_t *type,
 }
 
 STATIC mp_obj_t esp32_pwm_init(size_t n_args,
-        const mp_obj_t *args, mp_map_t *kw_args) {
+    const mp_obj_t *args, mp_map_t *kw_args) {
     esp32_pwm_init_helper(args[0], n_args - 1, args + 1, kw_args);
     return mp_const_none;
 }
@@ -249,8 +247,7 @@ STATIC mp_obj_t esp32_pwm_freq(size_t n_args, const mp_obj_t *args) {
     // set
     int tval = mp_obj_get_int(args[1]);
     if (!set_freq(tval)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-            "Bad frequency %d", tval));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("bad frequency %d"), tval);
     }
     return mp_const_none;
 }
@@ -270,7 +267,7 @@ STATIC mp_obj_t esp32_pwm_duty(size_t n_args, const mp_obj_t *args) {
 
     // set
     duty = mp_obj_get_int(args[1]);
-    duty &= ((1 << PWRES)-1);
+    duty &= ((1 << PWRES) - 1);
     duty >>= PWRES - timer_cfg.duty_resolution;
     ledc_set_duty(PWMODE, self->channel, duty);
     ledc_update_duty(PWMODE, self->channel);
@@ -295,5 +292,5 @@ const mp_obj_type_t machine_pwm_type = {
     .name = MP_QSTR_PWM,
     .print = esp32_pwm_print,
     .make_new = esp32_pwm_make_new,
-    .locals_dict = (mp_obj_dict_t*)&esp32_pwm_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&esp32_pwm_locals_dict,
 };
diff --git a/ports/esp32/machine_rtc.c b/ports/esp32/machine_rtc.c
index 08c7b02bfd4c2..c776eaa8d3d1c 100644
--- a/ports/esp32/machine_rtc.c
+++ b/ports/esp32/machine_rtc.c
@@ -44,17 +44,29 @@ typedef struct _machine_rtc_obj_t {
     mp_obj_base_t base;
 } machine_rtc_obj_t;
 
-#define MEM_MAGIC           0x75507921
 /* There is 8K of rtc_slow_memory, but some is used by the system software
-    If the USER_MAXLEN is set to high, the following compile error will happen:
+    If the MICROPY_HW_RTC_USER_MEM_MAX is set too high, the following compile error will happen:
         region `rtc_slow_seg' overflowed by N bytes
     The current system software allows almost 4096 to be used.
     To avoid running into issues if the system software uses more, 2048 was picked as a max length
+
+    You can also change this max length at compile time by defining MICROPY_HW_RTC_USER_MEM_MAX
+    either on your make line, or in your board config.
+
+    If MICROPY_HW_RTC_USER_MEM_MAX is set to 0, the RTC.memory() functionality will be not
+    be compiled which frees some extra flash and RTC memory.
 */
-#define MEM_USER_MAXLEN     2048
+#ifndef MICROPY_HW_RTC_USER_MEM_MAX
+#define MICROPY_HW_RTC_USER_MEM_MAX     2048
+#endif
+
+// Optionally compile user memory functionality if the size of memory is greater than 0
+#if MICROPY_HW_RTC_USER_MEM_MAX > 0
+#define MEM_MAGIC           0x75507921
 RTC_DATA_ATTR uint32_t rtc_user_mem_magic;
-RTC_DATA_ATTR uint32_t rtc_user_mem_len;
-RTC_DATA_ATTR uint8_t rtc_user_mem_data[MEM_USER_MAXLEN];
+RTC_DATA_ATTR uint16_t rtc_user_mem_len;
+RTC_DATA_ATTR uint8_t rtc_user_mem_data[MICROPY_HW_RTC_USER_MEM_MAX];
+#endif
 
 // singleton RTC object
 STATIC const machine_rtc_obj_t machine_rtc_obj = {{&machine_rtc_type}};
@@ -62,7 +74,7 @@ STATIC const machine_rtc_obj_t machine_rtc_obj = {{&machine_rtc_type}};
 machine_rtc_config_t machine_rtc_config = {
     .ext1_pins = 0,
     .ext0_pin = -1
-    };
+};
 
 STATIC mp_obj_t machine_rtc_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     // check arguments
@@ -103,6 +115,7 @@ STATIC mp_obj_t machine_rtc_datetime_helper(mp_uint_t n_args, const mp_obj_t *ar
 
         struct timeval tv = {0};
         tv.tv_sec = timeutils_seconds_since_2000(mp_obj_get_int(items[0]), mp_obj_get_int(items[1]), mp_obj_get_int(items[2]), mp_obj_get_int(items[4]), mp_obj_get_int(items[5]), mp_obj_get_int(items[6]));
+        tv.tv_usec = mp_obj_get_int(items[7]);
         settimeofday(&tv, NULL);
 
         return mp_const_none;
@@ -117,40 +130,46 @@ STATIC mp_obj_t machine_rtc_init(mp_obj_t self_in, mp_obj_t date) {
     mp_obj_t args[2] = {self_in, date};
     machine_rtc_datetime_helper(2, args);
 
+    #if MICROPY_HW_RTC_USER_MEM_MAX > 0
     if (rtc_user_mem_magic != MEM_MAGIC) {
         rtc_user_mem_magic = MEM_MAGIC;
         rtc_user_mem_len = 0;
     }
+    #endif
+
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(machine_rtc_init_obj, machine_rtc_init);
 
+#if MICROPY_HW_RTC_USER_MEM_MAX > 0
 STATIC mp_obj_t machine_rtc_memory(mp_uint_t n_args, const mp_obj_t *args) {
     if (n_args == 1) {
         // read RTC memory
-        uint32_t len = rtc_user_mem_len;
-        uint8_t rtcram[MEM_USER_MAXLEN];
-        memcpy( (char *) rtcram, (char *) rtc_user_mem_data, len);
-        return mp_obj_new_bytes(rtcram,  len);
+        uint8_t rtcram[MICROPY_HW_RTC_USER_MEM_MAX];
+        memcpy((char *)rtcram, (char *)rtc_user_mem_data, rtc_user_mem_len);
+        return mp_obj_new_bytes(rtcram, rtc_user_mem_len);
     } else {
         // write RTC memory
         mp_buffer_info_t bufinfo;
         mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ);
 
-        if (bufinfo.len > MEM_USER_MAXLEN) {
-            mp_raise_ValueError("buffer too long");
+        if (bufinfo.len > MICROPY_HW_RTC_USER_MEM_MAX) {
+            mp_raise_ValueError(MP_ERROR_TEXT("buffer too long"));
         }
-        memcpy( (char *) rtc_user_mem_data, (char *) bufinfo.buf, bufinfo.len);
+        memcpy((char *)rtc_user_mem_data, (char *)bufinfo.buf, bufinfo.len);
         rtc_user_mem_len = bufinfo.len;
         return mp_const_none;
     }
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_rtc_memory_obj, 1, 2, machine_rtc_memory);
+#endif
 
 STATIC const mp_rom_map_elem_t machine_rtc_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_rtc_init_obj) },
     { MP_ROM_QSTR(MP_QSTR_datetime), MP_ROM_PTR(&machine_rtc_datetime_obj) },
+    #if MICROPY_HW_RTC_USER_MEM_MAX > 0
     { MP_ROM_QSTR(MP_QSTR_memory), MP_ROM_PTR(&machine_rtc_memory_obj) },
+    #endif
 };
 STATIC MP_DEFINE_CONST_DICT(machine_rtc_locals_dict, machine_rtc_locals_dict_table);
 
diff --git a/ports/esp32/machine_rtc.h b/ports/esp32/machine_rtc.h
index e34deb9be60c6..6e70f7438501c 100644
--- a/ports/esp32/machine_rtc.h
+++ b/ports/esp32/machine_rtc.h
@@ -4,7 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2017 "Eric Poulsen" <eric@zyxod.com>
- * Copyright (c) 2017 "Tom Manning" <tom@manningetal.com> 
+ * Copyright (c) 2017 "Tom Manning" <tom@manningetal.com>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
diff --git a/ports/esp32/machine_sdcard.c b/ports/esp32/machine_sdcard.c
new file mode 100644
index 0000000000000..40686508a1e20
--- /dev/null
+++ b/ports/esp32/machine_sdcard.c
@@ -0,0 +1,381 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Nicko van Someren
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <string.h>
+
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "py/mperrno.h"
+#include "extmod/vfs_fat.h"
+
+#include "driver/sdmmc_host.h"
+#include "driver/sdspi_host.h"
+#include "sdmmc_cmd.h"
+#include "esp_log.h"
+
+#define DEBUG 0
+#if DEBUG
+#define DEBUG_printf(...) ESP_LOGI("modsdcard", __VA_ARGS__)
+#else
+#define DEBUG_printf(...) (void)0
+#endif
+
+//
+// There are three layers of abstraction: host, slot and card.
+// Creating an SD Card object will initialise the host and slot.
+// Cards gets initialised by ioctl op==1 and de-inited by ioctl 2
+// Hosts are de-inited in __del__. Slots do not need de-initing.
+//
+
+// Currently the ESP32 Library doesn't support MMC cards, so
+// we don't enable on MICROPY_HW_ENABLE_MMCARD.
+#if MICROPY_HW_ENABLE_SDCARD
+
+// Forward declaration
+const mp_obj_type_t machine_sdcard_type;
+
+typedef struct _sdcard_obj_t {
+    mp_obj_base_t base;
+    mp_int_t flags;
+    sdmmc_host_t host;
+    // The card structure duplicates the host. It's not clear if we
+    // can avoid this given the way that it is copied.
+    sdmmc_card_t card;
+} sdcard_card_obj_t;
+
+#define SDCARD_CARD_FLAGS_HOST_INIT_DONE 0x01
+#define SDCARD_CARD_FLAGS_CARD_INIT_DONE 0x02
+
+#define _SECTOR_SIZE(self) (self->card.csd.sector_size)
+
+STATIC gpio_num_t pin_or_int(const mp_obj_t arg) {
+    if (mp_obj_is_small_int(arg)) {
+        return MP_OBJ_SMALL_INT_VALUE(arg);
+    } else {
+        // This raises a value error if the argument is not a Pin.
+        return machine_pin_get_id(arg);
+    }
+}
+
+#define SET_CONFIG_PIN(config, pin_var, arg_id) \
+    if (arg_vals[arg_id].u_obj != mp_const_none) \
+    config.pin_var = pin_or_int(arg_vals[arg_id].u_obj)
+
+STATIC esp_err_t sdcard_ensure_card_init(sdcard_card_obj_t *self, bool force) {
+    if (force || !(self->flags & SDCARD_CARD_FLAGS_CARD_INIT_DONE)) {
+        DEBUG_printf("  Calling card init");
+
+        esp_err_t err = sdmmc_card_init(&(self->host), &(self->card));
+        if (err == ESP_OK) {
+            self->flags |= SDCARD_CARD_FLAGS_CARD_INIT_DONE;
+        } else {
+            self->flags &= ~SDCARD_CARD_FLAGS_CARD_INIT_DONE;
+        }
+        DEBUG_printf("  Card init returned: %i", err);
+
+        return err;
+    } else {
+        return ESP_OK;
+    }
+}
+
+/******************************************************************************/
+// MicroPython bindings
+//
+// Expose the SD card or MMC as an object with the block protocol.
+
+// Create a new SDCard object
+// The driver supports either the host SD/MMC controller (default) or SPI mode
+// In both cases there are two "slots". Slot 0 on the SD/MMC controller is
+// typically tied up with the flash interface in most ESP32 modules but in
+// theory supports 1, 4 or 8-bit transfers. Slot 1 supports only 1 and 4-bit
+// transfers. Only 1-bit is supported on the SPI interfaces.
+// card = SDCard(slot=1, width=None, present_pin=None, wp_pin=None)
+
+STATIC mp_obj_t machine_sdcard_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    // check arguments
+    enum {
+        ARG_slot,
+        ARG_width,
+        ARG_cd,
+        ARG_wp,
+        ARG_miso,
+        ARG_mosi,
+        ARG_sck,
+        ARG_cs,
+        ARG_freq,
+    };
+    STATIC const mp_arg_t allowed_args[] = {
+        { MP_QSTR_slot,     MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} },
+        { MP_QSTR_width,    MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} },
+        { MP_QSTR_cd,       MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_wp,       MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        // These are only needed if using SPI mode
+        { MP_QSTR_miso,     MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_mosi,     MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_sck,      MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_cs,       MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        // freq is valid for both SPI and SDMMC interfaces
+        { MP_QSTR_freq,     MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 20000000} },
+    };
+    mp_arg_val_t arg_vals[MP_ARRAY_SIZE(allowed_args)];
+    mp_map_t kw_args;
+
+    DEBUG_printf("Making new SDCard:n");
+    DEBUG_printf("  Unpacking arguments");
+
+    mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+
+    mp_arg_parse_all(n_args, args, &kw_args,
+        MP_ARRAY_SIZE(allowed_args), allowed_args, arg_vals);
+
+    DEBUG_printf("  slot=%d, width=%d, cd=%p, wp=%p",
+        arg_vals[ARG_slot].u_int, arg_vals[ARG_width].u_int,
+        arg_vals[ARG_cd].u_obj, arg_vals[ARG_wp].u_obj);
+
+    DEBUG_printf("  miso=%p, mosi=%p, sck=%p, cs=%p",
+        arg_vals[ARG_miso].u_obj, arg_vals[ARG_mosi].u_obj,
+        arg_vals[ARG_sck].u_obj, arg_vals[ARG_cs].u_obj);
+
+    int slot_num = arg_vals[ARG_slot].u_int;
+    if (slot_num < 0 || slot_num > 3) {
+        mp_raise_ValueError(MP_ERROR_TEXT("slot number must be between 0 and 3 inclusive"));
+    }
+
+    // Slots 0 and 1 are native SD/MMC, slots 2 and 3 are SPI
+    bool is_spi = (slot_num >= 2);
+    if (is_spi) {
+        slot_num -= 2;
+    }
+
+    DEBUG_printf("  Setting up host configuration");
+
+    sdcard_card_obj_t *self = m_new_obj_with_finaliser(sdcard_card_obj_t);
+    self->base.type = &machine_sdcard_type;
+    self->flags = 0;
+    // Note that these defaults are macros that expand to structure
+    // constants so we can't directly assign them to fields.
+    int freq = arg_vals[ARG_freq].u_int;
+    if (is_spi) {
+        sdmmc_host_t _temp_host = SDSPI_HOST_DEFAULT();
+        _temp_host.max_freq_khz = freq / 1000;
+        self->host = _temp_host;
+    } else {
+        sdmmc_host_t _temp_host = SDMMC_HOST_DEFAULT();
+        _temp_host.max_freq_khz = freq / 1000;
+        self->host = _temp_host;
+    }
+
+    if (is_spi) {
+        self->host.slot = slot_num ? HSPI_HOST : VSPI_HOST;
+    }
+
+    DEBUG_printf("  Calling host.init()");
+
+    check_esp_err(self->host.init());
+    self->flags |= SDCARD_CARD_FLAGS_HOST_INIT_DONE;
+
+    if (is_spi) {
+        // SPI interface
+        STATIC const sdspi_slot_config_t slot_defaults[2] = {
+            {
+                .gpio_miso = GPIO_NUM_19,
+                .gpio_mosi = GPIO_NUM_23,
+                .gpio_sck = GPIO_NUM_18,
+                .gpio_cs = GPIO_NUM_5,
+                .gpio_cd = SDSPI_SLOT_NO_CD,
+                .gpio_wp = SDSPI_SLOT_NO_WP,
+                .dma_channel = 2
+            },
+            SDSPI_SLOT_CONFIG_DEFAULT()
+        };
+
+        DEBUG_printf("  Setting up SPI slot configuration");
+        sdspi_slot_config_t slot_config = slot_defaults[slot_num];
+
+        SET_CONFIG_PIN(slot_config, gpio_cd, ARG_cd);
+        SET_CONFIG_PIN(slot_config, gpio_wp, ARG_wp);
+        SET_CONFIG_PIN(slot_config, gpio_miso, ARG_miso);
+        SET_CONFIG_PIN(slot_config, gpio_mosi, ARG_mosi);
+        SET_CONFIG_PIN(slot_config, gpio_sck, ARG_sck);
+        SET_CONFIG_PIN(slot_config, gpio_cs, ARG_cs);
+
+        DEBUG_printf("  Calling init_slot()");
+        check_esp_err(sdspi_host_init_slot(self->host.slot, &slot_config));
+    } else {
+        // SD/MMC interface
+        DEBUG_printf("  Setting up SDMMC slot configuration");
+        sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
+
+        // Stronger external pull-ups are still needed but apparently
+        // it is a good idea to set the internal pull-ups anyway.
+        // slot_config.flags = SDMMC_SLOT_FLAG_INTERNAL_PULLUP;
+
+        SET_CONFIG_PIN(slot_config, gpio_cd, ARG_cd);
+        SET_CONFIG_PIN(slot_config, gpio_wp, ARG_wp);
+
+        int width = arg_vals[ARG_width].u_int;
+        if (width == 1 || width == 4 || (width == 8 && slot_num == 0)) {
+            slot_config.width = width;
+        } else {
+            mp_raise_ValueError(MP_ERROR_TEXT("width must be 1 or 4 (or 8 on slot 0)"));
+        }
+
+        DEBUG_printf("  Calling init_slot()");
+        check_esp_err(sdmmc_host_init_slot(self->host.slot, &slot_config));
+    }
+
+    DEBUG_printf("  Returning new card object: %p", self);
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC mp_obj_t sd_deinit(mp_obj_t self_in) {
+    sdcard_card_obj_t *self = self_in;
+
+    DEBUG_printf("De-init host\n");
+
+    if (self->flags & SDCARD_CARD_FLAGS_HOST_INIT_DONE) {
+        self->host.deinit();
+        self->flags &= ~SDCARD_CARD_FLAGS_HOST_INIT_DONE;
+    }
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(sd_deinit_obj, sd_deinit);
+
+STATIC mp_obj_t sd_info(mp_obj_t self_in) {
+    sdcard_card_obj_t *self = self_in;
+    // We could potential return a great deal more SD card data but it
+    // is not clear that it is worth the extra code space to do
+    // so. For the most part people only care about the card size and
+    // block size.
+
+    check_esp_err(sdcard_ensure_card_init((sdcard_card_obj_t *)self, false));
+
+    uint32_t log_block_nbr = self->card.csd.capacity;
+    uint32_t log_block_size = _SECTOR_SIZE(self);
+
+    mp_obj_t tuple[2] = {
+        mp_obj_new_int_from_ull((uint64_t)log_block_nbr * (uint64_t)log_block_size),
+        mp_obj_new_int_from_uint(log_block_size),
+    };
+    return mp_obj_new_tuple(2, tuple);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(sd_info_obj, sd_info);
+
+STATIC mp_obj_t machine_sdcard_readblocks(mp_obj_t self_in, mp_obj_t block_num, mp_obj_t buf) {
+    sdcard_card_obj_t *self = self_in;
+    mp_buffer_info_t bufinfo;
+    esp_err_t err;
+
+    err = sdcard_ensure_card_init((sdcard_card_obj_t *)self, false);
+    if (err != ESP_OK) {
+        return false;
+    }
+
+    mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_WRITE);
+    err = sdmmc_read_sectors(&(self->card), bufinfo.buf, mp_obj_get_int(block_num), bufinfo.len / _SECTOR_SIZE(self));
+
+    return mp_obj_new_bool(err == ESP_OK);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(machine_sdcard_readblocks_obj, machine_sdcard_readblocks);
+
+STATIC mp_obj_t machine_sdcard_writeblocks(mp_obj_t self_in, mp_obj_t block_num, mp_obj_t buf) {
+    sdcard_card_obj_t *self = self_in;
+    mp_buffer_info_t bufinfo;
+    esp_err_t err;
+
+    err = sdcard_ensure_card_init((sdcard_card_obj_t *)self, false);
+    if (err != ESP_OK) {
+        return false;
+    }
+
+    mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_READ);
+    err = sdmmc_write_sectors(&(self->card), bufinfo.buf, mp_obj_get_int(block_num), bufinfo.len / _SECTOR_SIZE(self));
+
+    return mp_obj_new_bool(err == ESP_OK);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(machine_sdcard_writeblocks_obj, machine_sdcard_writeblocks);
+
+STATIC mp_obj_t machine_sdcard_ioctl(mp_obj_t self_in, mp_obj_t cmd_in, mp_obj_t arg_in) {
+    sdcard_card_obj_t *self = self_in;
+    esp_err_t err = ESP_OK;
+    mp_int_t cmd = mp_obj_get_int(cmd_in);
+
+    switch (cmd) {
+        case MP_BLOCKDEV_IOCTL_INIT:
+            err = sdcard_ensure_card_init(self, false);
+            return MP_OBJ_NEW_SMALL_INT((err == ESP_OK) ? 0 : -1);
+
+        case MP_BLOCKDEV_IOCTL_DEINIT:
+            // Ensure that future attempts to look at info re-read the card
+            self->flags &= ~SDCARD_CARD_FLAGS_CARD_INIT_DONE;
+            return MP_OBJ_NEW_SMALL_INT(0); // success
+
+        case MP_BLOCKDEV_IOCTL_SYNC:
+            // nothing to do
+            return MP_OBJ_NEW_SMALL_INT(0); // success
+
+        case MP_BLOCKDEV_IOCTL_BLOCK_COUNT:
+            err = sdcard_ensure_card_init(self, false);
+            if (err != ESP_OK) {
+                return MP_OBJ_NEW_SMALL_INT(-1);
+            }
+            return MP_OBJ_NEW_SMALL_INT(self->card.csd.capacity);
+
+        case MP_BLOCKDEV_IOCTL_BLOCK_SIZE:
+            err = sdcard_ensure_card_init(self, false);
+            if (err != ESP_OK) {
+                return MP_OBJ_NEW_SMALL_INT(-1);
+            }
+            return MP_OBJ_NEW_SMALL_INT(_SECTOR_SIZE(self));
+
+        default: // unknown command
+            return MP_OBJ_NEW_SMALL_INT(-1); // error
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(machine_sdcard_ioctl_obj, machine_sdcard_ioctl);
+
+STATIC const mp_rom_map_elem_t machine_sdcard_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_info), MP_ROM_PTR(&sd_info_obj) },
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&sd_deinit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&sd_deinit_obj) },
+    // block device protocol
+    { MP_ROM_QSTR(MP_QSTR_readblocks), MP_ROM_PTR(&machine_sdcard_readblocks_obj) },
+    { MP_ROM_QSTR(MP_QSTR_writeblocks), MP_ROM_PTR(&machine_sdcard_writeblocks_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ioctl), MP_ROM_PTR(&machine_sdcard_ioctl_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(machine_sdcard_locals_dict, machine_sdcard_locals_dict_table);
+
+const mp_obj_type_t machine_sdcard_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_SDCard,
+    .make_new = machine_sdcard_make_new,
+    .locals_dict = (mp_obj_dict_t *)&machine_sdcard_locals_dict,
+};
+
+#endif // MICROPY_HW_ENABLE_SDCARD
diff --git a/ports/esp32/machine_timer.c b/ports/esp32/machine_timer.c
index 081a46b9c1c50..6e5824094ea25 100644
--- a/ports/esp32/machine_timer.c
+++ b/ports/esp32/machine_timer.c
@@ -64,17 +64,14 @@ const mp_obj_type_t machine_timer_type;
 
 STATIC void machine_timer_disable(machine_timer_obj_t *self);
 
-STATIC esp_err_t check_esp_err(esp_err_t code) {
-    if (code) {
-        mp_raise_OSError(code);
-    }
-
-    return code;
-}
-
 void machine_timer_deinit_all(void) {
-    while (MP_STATE_PORT(machine_timer_obj_head) != NULL) {
-        machine_timer_disable(MP_STATE_PORT(machine_timer_obj_head));
+    // Disable, deallocate and remove all timers from list
+    machine_timer_obj_t **t = &MP_STATE_PORT(machine_timer_obj_head);
+    while (*t != NULL) {
+        machine_timer_disable(*t);
+        machine_timer_obj_t *next = (*t)->next;
+        m_del_obj(machine_timer_obj_t, *t);
+        *t = next;
     }
 }
 
@@ -93,12 +90,24 @@ STATIC void machine_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_pr
 
 STATIC mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 1, 1, false);
+    mp_uint_t group = (mp_obj_get_int(args[0]) >> 1) & 1;
+    mp_uint_t index = mp_obj_get_int(args[0]) & 1;
+
+    // Check whether the timer is already initialized, if so return it
+    for (machine_timer_obj_t *t = MP_STATE_PORT(machine_timer_obj_head); t; t = t->next) {
+        if (t->group == group && t->index == index) {
+            return t;
+        }
+    }
+
     machine_timer_obj_t *self = m_new_obj(machine_timer_obj_t);
     self->base.type = &machine_timer_type;
+    self->group = group;
+    self->index = index;
 
-    self->group = (mp_obj_get_int(args[0]) >> 1) & 1;
-    self->index = mp_obj_get_int(args[0]) & 1;
-    self->next = NULL;
+    // Add the timer to the linked-list of timers
+    self->next = MP_STATE_PORT(machine_timer_obj_head);
+    MP_STATE_PORT(machine_timer_obj_head) = self;
 
     return self;
 }
@@ -110,13 +119,8 @@ STATIC void machine_timer_disable(machine_timer_obj_t *self) {
         self->handle = NULL;
     }
 
-    // Remove the timer from the linked-list of active timers
-    for (machine_timer_obj_t **t = &MP_STATE_PORT(machine_timer_obj_head); *t; t = &(*t)->next) {
-        if (*t == self) {
-            *t = (*t)->next;
-            break;
-        }
-    }
+    // We let the disabled timer stay in the list, as it might be
+    // referenced elsewhere
 }
 
 STATIC void machine_timer_isr(void *self_in) {
@@ -148,12 +152,8 @@ STATIC void machine_timer_enable(machine_timer_obj_t *self) {
     check_esp_err(timer_set_counter_value(self->group, self->index, 0x00000000));
     check_esp_err(timer_set_alarm_value(self->group, self->index, self->period));
     check_esp_err(timer_enable_intr(self->group, self->index));
-    check_esp_err(timer_isr_register(self->group, self->index, machine_timer_isr, (void*)self, TIMER_FLAGS, &self->handle));
+    check_esp_err(timer_isr_register(self->group, self->index, machine_timer_isr, (void *)self, TIMER_FLAGS, &self->handle));
     check_esp_err(timer_start(self->group, self->index));
-
-    // Add the timer to the linked-list of active timers
-    self->next = MP_STATE_PORT(machine_timer_obj_head);
-    MP_STATE_PORT(machine_timer_obj_head) = self;
 }
 
 STATIC mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
@@ -169,11 +169,11 @@ STATIC mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, mp_uint_t n
         { MP_QSTR_callback,     MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
         { MP_QSTR_period,       MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0xffffffff} },
         { MP_QSTR_tick_hz,      MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1000} },
-#if MICROPY_PY_BUILTINS_FLOAT
+        #if MICROPY_PY_BUILTINS_FLOAT
         { MP_QSTR_freq,         MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
-#else
+        #else
         { MP_QSTR_freq,         MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0xffffffff} },
-#endif
+        #endif
     };
 
     machine_timer_disable(self);
@@ -181,15 +181,15 @@ STATIC mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, mp_uint_t n
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-#if MICROPY_PY_BUILTINS_FLOAT
+    #if MICROPY_PY_BUILTINS_FLOAT
     if (args[ARG_freq].u_obj != mp_const_none) {
         self->period = (uint64_t)(TIMER_SCALE / mp_obj_get_float(args[ARG_freq].u_obj));
     }
-#else
+    #else
     if (args[ARG_freq].u_int != 0xffffffff) {
         self->period = TIMER_SCALE / ((uint64_t)args[ARG_freq].u_int);
     }
-#endif
+    #endif
     else {
         self->period = (((uint64_t)args[ARG_period].u_int) * TIMER_SCALE) / args[ARG_tick_hz].u_int;
     }
diff --git a/ports/esp32/machine_touchpad.c b/ports/esp32/machine_touchpad.c
index 96de1a2a1d74a..44efac37562c3 100644
--- a/ports/esp32/machine_touchpad.c
+++ b/ports/esp32/machine_touchpad.c
@@ -56,32 +56,42 @@ STATIC const mtp_obj_t touchpad_obj[] = {
 };
 
 STATIC mp_obj_t mtp_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw,
-        const mp_obj_t *args) {
+    const mp_obj_t *args) {
 
     mp_arg_check_num(n_args, n_kw, 1, 1, true);
     gpio_num_t pin_id = machine_pin_get_id(args[0]);
     const mtp_obj_t *self = NULL;
     for (int i = 0; i < MP_ARRAY_SIZE(touchpad_obj); i++) {
-        if (pin_id == touchpad_obj[i].gpio_id) { self = &touchpad_obj[i]; break; }
+        if (pin_id == touchpad_obj[i].gpio_id) {
+            self = &touchpad_obj[i];
+            break;
+        }
+    }
+    if (!self) {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid pin for touchpad"));
     }
-    if (!self) mp_raise_ValueError("invalid pin for touchpad");
 
     static int initialized = 0;
     if (!initialized) {
         touch_pad_init();
+        touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER);
         initialized = 1;
     }
     esp_err_t err = touch_pad_config(self->touchpad_id, 0);
-    if (err == ESP_OK) return MP_OBJ_FROM_PTR(self);
-    mp_raise_ValueError("Touch pad error");
+    if (err == ESP_OK) {
+        return MP_OBJ_FROM_PTR(self);
+    }
+    mp_raise_ValueError(MP_ERROR_TEXT("Touch pad error"));
 }
 
 STATIC mp_obj_t mtp_config(mp_obj_t self_in, mp_obj_t value_in) {
     mtp_obj_t *self = self_in;
     uint16_t value = mp_obj_get_int(value_in);
     esp_err_t err = touch_pad_config(self->touchpad_id, value);
-    if (err == ESP_OK) return mp_const_none;
-    mp_raise_ValueError("Touch pad error");
+    if (err == ESP_OK) {
+        return mp_const_none;
+    }
+    mp_raise_ValueError(MP_ERROR_TEXT("Touch pad error"));
 }
 MP_DEFINE_CONST_FUN_OBJ_2(mtp_config_obj, mtp_config);
 
@@ -89,8 +99,10 @@ STATIC mp_obj_t mtp_read(mp_obj_t self_in) {
     mtp_obj_t *self = self_in;
     uint16_t value;
     esp_err_t err = touch_pad_read(self->touchpad_id, &value);
-    if (err == ESP_OK) return MP_OBJ_NEW_SMALL_INT(value);
-    mp_raise_ValueError("Touch pad error");
+    if (err == ESP_OK) {
+        return MP_OBJ_NEW_SMALL_INT(value);
+    }
+    mp_raise_ValueError(MP_ERROR_TEXT("Touch pad error"));
 }
 MP_DEFINE_CONST_FUN_OBJ_1(mtp_read_obj, mtp_read);
 
diff --git a/ports/esp32/machine_uart.c b/ports/esp32/machine_uart.c
index b3c70de1e7b46..c334e694b21b0 100644
--- a/ports/esp32/machine_uart.c
+++ b/ports/esp32/machine_uart.c
@@ -50,6 +50,7 @@ typedef struct _machine_uart_obj_t {
     uint16_t rxbuf;
     uint16_t timeout;       // timeout waiting for first char (in ms)
     uint16_t timeout_char;  // timeout waiting between chars (in ms)
+    uint32_t invert;        // lines to invert
 } machine_uart_obj_t;
 
 STATIC const char *_parity_name[] = {"None", "1", "0"};
@@ -61,13 +62,42 @@ STATIC void machine_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_pri
     machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
     uint32_t baudrate;
     uart_get_baudrate(self->uart_num, &baudrate);
-    mp_printf(print, "UART(%u, baudrate=%u, bits=%u, parity=%s, stop=%u, tx=%d, rx=%d, rts=%d, cts=%d, txbuf=%u, rxbuf=%u, timeout=%u, timeout_char=%u)",
+    mp_printf(print, "UART(%u, baudrate=%u, bits=%u, parity=%s, stop=%u, tx=%d, rx=%d, rts=%d, cts=%d, txbuf=%u, rxbuf=%u, timeout=%u, timeout_char=%u",
         self->uart_num, baudrate, self->bits, _parity_name[self->parity],
         self->stop, self->tx, self->rx, self->rts, self->cts, self->txbuf, self->rxbuf, self->timeout, self->timeout_char);
+    if (self->invert) {
+        mp_printf(print, ", invert=");
+        uint32_t invert_mask = self->invert;
+        if (invert_mask & UART_INVERSE_TXD) {
+            mp_printf(print, "INV_TX");
+            invert_mask &= ~UART_INVERSE_TXD;
+            if (invert_mask) {
+                mp_printf(print, "|");
+            }
+        }
+        if (invert_mask & UART_INVERSE_RXD) {
+            mp_printf(print, "INV_RX");
+            invert_mask &= ~UART_INVERSE_RXD;
+            if (invert_mask) {
+                mp_printf(print, "|");
+            }
+        }
+        if (invert_mask & UART_INVERSE_RTS) {
+            mp_printf(print, "INV_RTS");
+            invert_mask &= ~UART_INVERSE_RTS;
+            if (invert_mask) {
+                mp_printf(print, "|");
+            }
+        }
+        if (invert_mask & UART_INVERSE_CTS) {
+            mp_printf(print, "INV_CTS");
+        }
+    }
+    mp_printf(print, ")");
 }
 
 STATIC void machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_baudrate, ARG_bits, ARG_parity, ARG_stop, ARG_tx, ARG_rx, ARG_rts, ARG_cts, ARG_txbuf, ARG_rxbuf, ARG_timeout, ARG_timeout_char };
+    enum { ARG_baudrate, ARG_bits, ARG_parity, ARG_stop, ARG_tx, ARG_rx, ARG_rts, ARG_cts, ARG_txbuf, ARG_rxbuf, ARG_timeout, ARG_timeout_char, ARG_invert };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_baudrate, MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_bits, MP_ARG_INT, {.u_int = 0} },
@@ -81,6 +111,7 @@ STATIC void machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, co
         { MP_QSTR_rxbuf, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
         { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_timeout_char, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_invert, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
@@ -156,7 +187,7 @@ STATIC void machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, co
             self->bits = 8;
             break;
         default:
-            mp_raise_ValueError("invalid data bits");
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid data bits"));
             break;
     }
 
@@ -191,7 +222,7 @@ STATIC void machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, co
             self->stop = 2;
             break;
         default:
-            mp_raise_ValueError("invalid stop bits");
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid stop bits"));
             break;
     }
 
@@ -205,6 +236,13 @@ STATIC void machine_uart_init_helper(machine_uart_obj_t *self, size_t n_args, co
     if (self->timeout_char < min_timeout_char) {
         self->timeout_char = min_timeout_char;
     }
+
+    // set line inversion
+    if (args[ARG_invert].u_int & ~UART_LINE_INV_MASK) {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid inversion mask"));
+    }
+    self->invert = args[ARG_invert].u_int;
+    uart_set_line_inverse(self->uart_num, self->invert);
 }
 
 STATIC mp_obj_t machine_uart_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
@@ -213,16 +251,16 @@ STATIC mp_obj_t machine_uart_make_new(const mp_obj_type_t *type, size_t n_args,
     // get uart id
     mp_int_t uart_num = mp_obj_get_int(args[0]);
     if (uart_num < 0 || uart_num >= UART_NUM_MAX) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%d) does not exist", uart_num));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("UART(%d) does not exist"), uart_num);
     }
 
     // Attempts to use UART0 from Python has resulted in all sorts of fun errors.
     // FIXME: UART0 is disabled for now.
     if (uart_num == UART_NUM_0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%d) is disabled (dedicated to REPL)", uart_num));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("UART(%d) is disabled (dedicated to REPL)"), uart_num);
     }
 
-     // Defaults
+    // Defaults
     uart_config_t uartcfg = {
         .baud_rate = 115200,
         .data_bits = UART_DATA_8_BITS,
@@ -286,6 +324,13 @@ STATIC mp_obj_t machine_uart_init(size_t n_args, const mp_obj_t *args, mp_map_t
 }
 MP_DEFINE_CONST_FUN_OBJ_KW(machine_uart_init_obj, 1, machine_uart_init);
 
+STATIC mp_obj_t machine_uart_deinit(mp_obj_t self_in) {
+    machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    uart_driver_delete(self->uart_num);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_uart_deinit_obj, machine_uart_deinit);
+
 STATIC mp_obj_t machine_uart_any(mp_obj_t self_in) {
     machine_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
     size_t rxbufsize;
@@ -327,13 +372,18 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_uart_sendbreak_obj, machine_uart_sendbr
 
 STATIC const mp_rom_map_elem_t machine_uart_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_uart_init_obj) },
-
+    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_uart_deinit_obj) },
     { MP_ROM_QSTR(MP_QSTR_any), MP_ROM_PTR(&machine_uart_any_obj) },
     { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
     { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
     { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
     { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
     { MP_ROM_QSTR(MP_QSTR_sendbreak), MP_ROM_PTR(&machine_uart_sendbreak_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_INV_TX), MP_ROM_INT(UART_INVERSE_TXD) },
+    { MP_ROM_QSTR(MP_QSTR_INV_RX), MP_ROM_INT(UART_INVERSE_RXD) },
+    { MP_ROM_QSTR(MP_QSTR_INV_RTS), MP_ROM_INT(UART_INVERSE_RTS) },
+    { MP_ROM_QSTR(MP_QSTR_INV_CTS), MP_ROM_INT(UART_INVERSE_CTS) },
 };
 
 STATIC MP_DEFINE_CONST_DICT(machine_uart_locals_dict, machine_uart_locals_dict_table);
@@ -413,5 +463,5 @@ const mp_obj_type_t machine_uart_type = {
     .getiter = mp_identity_getiter,
     .iternext = mp_stream_unbuffered_iter,
     .protocol = &uart_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&machine_uart_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&machine_uart_locals_dict,
 };
diff --git a/ports/esp32/machine_wdt.c b/ports/esp32/machine_wdt.c
index 88a58f056a1fd..f0ec6928e05df 100644
--- a/ports/esp32/machine_wdt.c
+++ b/ports/esp32/machine_wdt.c
@@ -41,21 +41,34 @@ typedef struct _machine_wdt_obj_t {
 
 STATIC machine_wdt_obj_t wdt_default = {{&machine_wdt_type}};
 
-STATIC mp_obj_t machine_wdt_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
-    mp_arg_check_num(n_args, n_kw, 0, 1, false);
+STATIC mp_obj_t machine_wdt_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    enum { ARG_id, ARG_timeout };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_id, MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_timeout, MP_ARG_INT, {.u_int = 5000} }
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
-    mp_int_t id = 0;
-    if (n_args > 0) {
-        id = mp_obj_get_int(args[0]);
+    if (args[ARG_id].u_int != 0) {
+        mp_raise_ValueError(NULL);
     }
 
-    switch (id) {
-        case 0:
-            esp_task_wdt_add(NULL);
-            return &wdt_default;
-        default:
-            mp_raise_ValueError(NULL);
+    // Convert milliseconds to seconds (esp_task_wdt_init needs seconds)
+    args[ARG_timeout].u_int /= 1000;
+
+    if (args[ARG_timeout].u_int <= 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("WDT timeout too short"));
+    }
+
+    mp_int_t rs_code = esp_task_wdt_init(args[ARG_timeout].u_int, true);
+    if (rs_code != ESP_OK) {
+        mp_raise_OSError(rs_code);
     }
+
+    esp_task_wdt_add(NULL);
+
+    return &wdt_default;
 }
 
 STATIC mp_obj_t machine_wdt_feed(mp_obj_t self_in) {
diff --git a/ports/esp32/main.c b/ports/esp32/main.c
index 188fb5e70dd34..81e4a64346180 100644
--- a/ports/esp32/main.c
+++ b/ports/esp32/main.c
@@ -37,12 +37,17 @@
 #include "esp_task.h"
 #include "soc/cpu.h"
 #include "esp_log.h"
+#if MICROPY_ESP_IDF_4
+#include "esp32/spiram.h"
+#else
 #include "esp_spiram.h"
+#endif
 
 #include "py/stackctrl.h"
 #include "py/nlr.h"
 #include "py/compile.h"
 #include "py/runtime.h"
+#include "py/persistentcode.h"
 #include "py/repl.h"
 #include "py/gc.h"
 #include "py/mphal.h"
@@ -53,6 +58,10 @@
 #include "modnetwork.h"
 #include "mpthreadport.h"
 
+#if MICROPY_BLUETOOTH_NIMBLE
+#include "extmod/modbluetooth.h"
+#endif
+
 // MicroPython runs as a task under FreeRTOS
 #define MP_TASK_PRIORITY        (ESP_TASK_PRIO_MIN + 1)
 #define MP_TASK_STACK_SIZE      (16 * 1024)
@@ -70,10 +79,11 @@ void mp_task(void *pvParameter) {
     #endif
     uart_init();
 
-    #if CONFIG_SPIRAM_SUPPORT
+    // TODO: CONFIG_SPIRAM_SUPPORT is for 3.3 compatibility, remove after move to 4.0.
+    #if CONFIG_ESP32_SPIRAM_SUPPORT || CONFIG_SPIRAM_SUPPORT
     // Try to use the entire external SPIRAM directly for the heap
     size_t mp_task_heap_size;
-    void *mp_task_heap = (void*)0x3f800000;
+    void *mp_task_heap = (void *)0x3f800000;
     switch (esp_spiram_get_chip_size()) {
         case ESP_SPIRAM_SIZE_16MBITS:
             mp_task_heap_size = 2 * 1024 * 1024;
@@ -111,9 +121,9 @@ void mp_task(void *pvParameter) {
 
     // run boot-up scripts
     pyexec_frozen_module("_boot.py");
-    pyexec_file("boot.py");
+    pyexec_file_if_exists("boot.py");
     if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
-        pyexec_file("main.py");
+        pyexec_file_if_exists("main.py");
     }
 
     for (;;) {
@@ -130,6 +140,10 @@ void mp_task(void *pvParameter) {
         }
     }
 
+    #if MICROPY_BLUETOOTH_NIMBLE
+    mp_bluetooth_deinit();
+    #endif
+
     machine_timer_deinit_all();
 
     #if MICROPY_PY_THREAD
@@ -150,8 +164,12 @@ void mp_task(void *pvParameter) {
 }
 
 void app_main(void) {
-    nvs_flash_init();
-    xTaskCreate(mp_task, "mp_task", MP_TASK_STACK_LEN, NULL, MP_TASK_PRIORITY, &mp_main_task_handle);
+    esp_err_t ret = nvs_flash_init();
+    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
+        nvs_flash_erase();
+        nvs_flash_init();
+    }
+    xTaskCreatePinnedToCore(mp_task, "mp_task", MP_TASK_STACK_LEN, NULL, MP_TASK_PRIORITY, &mp_main_task_handle, MP_TASK_COREID);
 }
 
 void nlr_jump_fail(void *val) {
@@ -163,3 +181,16 @@ void nlr_jump_fail(void *val) {
 void mbedtls_debug_set_threshold(int threshold) {
     (void)threshold;
 }
+
+void *esp_native_code_commit(void *buf, size_t len, void *reloc) {
+    len = (len + 3) & ~3;
+    uint32_t *p = heap_caps_malloc(len, MALLOC_CAP_EXEC);
+    if (p == NULL) {
+        m_malloc_fail(len);
+    }
+    if (reloc) {
+        mp_native_relocate(reloc, buf, (uintptr_t)p);
+    }
+    memcpy(p, buf, len);
+    return p;
+}
diff --git a/ports/esp32/makeimg.py b/ports/esp32/makeimg.py
index aeedbff7ef27f..9f27ed6ef883d 100644
--- a/ports/esp32/makeimg.py
+++ b/ports/esp32/makeimg.py
@@ -5,21 +5,21 @@
 OFFSET_APPLICATION = 0x10000
 
 files_in = [
-    ('bootloader', OFFSET_BOOTLOADER, sys.argv[1]),
-    ('partitions', OFFSET_PARTITIONS, sys.argv[2]),
-    ('application', OFFSET_APPLICATION, sys.argv[3]),
+    ("bootloader", OFFSET_BOOTLOADER, sys.argv[1]),
+    ("partitions", OFFSET_PARTITIONS, sys.argv[2]),
+    ("application", OFFSET_APPLICATION, sys.argv[3]),
 ]
 file_out = sys.argv[4]
 
 cur_offset = OFFSET_BOOTLOADER
-with open(file_out, 'wb') as fout:
+with open(file_out, "wb") as fout:
     for name, offset, file_in in files_in:
         assert offset >= cur_offset
-        fout.write(b'\xff' * (offset - cur_offset))
+        fout.write(b"\xff" * (offset - cur_offset))
         cur_offset = offset
-        with open(file_in, 'rb') as fin:
+        with open(file_in, "rb") as fin:
             data = fin.read()
             fout.write(data)
             cur_offset += len(data)
-            print('%-12s% 8d' % (name, len(data))) 
-    print('%-12s% 8d' % ('total', cur_offset))
+            print("%-12s% 8d" % (name, len(data)))
+    print("%-12s% 8d" % ("total", cur_offset))
diff --git a/ports/esp32/modesp.c b/ports/esp32/modesp.c
index e614f77a6aea6..369649c119ffd 100644
--- a/ports/esp32/modesp.c
+++ b/ports/esp32/modesp.c
@@ -29,7 +29,9 @@
 
 #include <stdio.h>
 
+#if !MICROPY_ESP_IDF_4
 #include "rom/gpio.h"
+#endif
 #include "esp_log.h"
 #include "esp_spi_flash.h"
 
@@ -117,7 +119,7 @@ STATIC mp_obj_t esp_neopixel_write_(mp_obj_t pin, mp_obj_t buf, mp_obj_t timing)
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_READ);
     esp_neopixel_write(mp_hal_get_pin_obj(pin),
-        (uint8_t*)bufinfo.buf, bufinfo.len, mp_obj_get_int(timing));
+        (uint8_t *)bufinfo.buf, bufinfo.len, mp_obj_get_int(timing));
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_3(esp_neopixel_write_obj, esp_neopixel_write_);
@@ -152,6 +154,6 @@ STATIC MP_DEFINE_CONST_DICT(esp_module_globals, esp_module_globals_table);
 
 const mp_obj_module_t esp_module = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&esp_module_globals,
+    .globals = (mp_obj_dict_t *)&esp_module_globals,
 };
 
diff --git a/ports/esp32/modesp32.c b/ports/esp32/modesp32.c
index 2e2d8236cf234..8e248370ffb6d 100644
--- a/ports/esp32/modesp32.c
+++ b/ports/esp32/modesp32.c
@@ -33,6 +33,9 @@
 #include "soc/sens_reg.h"
 #include "driver/gpio.h"
 #include "driver/adc.h"
+#include "esp_heap_caps.h"
+#include "multi_heap.h"
+#include "../heap_private.h"
 
 #include "py/nlr.h"
 #include "py/obj.h"
@@ -46,9 +49,9 @@
 STATIC mp_obj_t esp32_wake_on_touch(const mp_obj_t wake) {
 
     if (machine_rtc_config.ext0_pin != -1) {
-        mp_raise_ValueError("no resources");
+        mp_raise_ValueError(MP_ERROR_TEXT("no resources"));
     }
-     //nlr_raise(mp_obj_new_exception_msg(&mp_type_RuntimeError, "touchpad wakeup not available for this version of ESP-IDF"));
+    // mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("touchpad wakeup not available for this version of ESP-IDF"));
 
     machine_rtc_config.wake_on_touch = mp_obj_is_true(wake);
     return mp_const_none;
@@ -58,7 +61,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp32_wake_on_touch_obj, esp32_wake_on_touch);
 STATIC mp_obj_t esp32_wake_on_ext0(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
 
     if (machine_rtc_config.wake_on_touch) {
-        mp_raise_ValueError("no resources");
+        mp_raise_ValueError(MP_ERROR_TEXT("no resources"));
     }
     enum {ARG_pin, ARG_level};
     const mp_arg_t allowed_args[] = {
@@ -74,7 +77,7 @@ STATIC mp_obj_t esp32_wake_on_ext0(size_t n_args, const mp_obj_t *pos_args, mp_m
         gpio_num_t pin_id = machine_pin_get_id(args[ARG_pin].u_obj);
         if (pin_id != machine_rtc_config.ext0_pin) {
             if (!RTC_IS_VALID_EXT_PIN(pin_id)) {
-                nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "invalid pin"));
+                mp_raise_ValueError(MP_ERROR_TEXT("invalid pin"));
             }
             machine_rtc_config.ext0_pin = pin_id;
         }
@@ -109,7 +112,7 @@ STATIC mp_obj_t esp32_wake_on_ext1(size_t n_args, const mp_obj_t *pos_args, mp_m
 
             gpio_num_t pin_id = machine_pin_get_id(elem[i]);
             if (!RTC_IS_VALID_EXT_PIN(pin_id)) {
-                nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "invalid pin"));
+                mp_raise_ValueError(MP_ERROR_TEXT("invalid pin"));
                 break;
             }
             ext1_pins |= (1ll << pin_id);
@@ -145,6 +148,28 @@ STATIC mp_obj_t esp32_hall_sensor(void) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp32_hall_sensor_obj, esp32_hall_sensor);
 
+STATIC mp_obj_t esp32_idf_heap_info(const mp_obj_t cap_in) {
+    mp_int_t cap = mp_obj_get_int(cap_in);
+    multi_heap_info_t info;
+    heap_t *heap;
+    mp_obj_t heap_list = mp_obj_new_list(0, 0);
+    SLIST_FOREACH(heap, &registered_heaps, next) {
+        if (heap_caps_match(heap, cap)) {
+            multi_heap_get_info(heap->heap, &info);
+            mp_obj_t data[] = {
+                MP_OBJ_NEW_SMALL_INT(heap->end - heap->start), // total heap size
+                MP_OBJ_NEW_SMALL_INT(info.total_free_bytes),   // total free bytes
+                MP_OBJ_NEW_SMALL_INT(info.largest_free_block), // largest free contiguous
+                MP_OBJ_NEW_SMALL_INT(info.minimum_free_bytes), // minimum free seen
+            };
+            mp_obj_t this_heap = mp_obj_new_tuple(4, data);
+            mp_obj_list_append(heap_list, this_heap);
+        }
+    }
+    return heap_list;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp32_idf_heap_info_obj, esp32_idf_heap_info);
+
 STATIC const mp_rom_map_elem_t esp32_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_esp32) },
 
@@ -153,16 +178,22 @@ STATIC const mp_rom_map_elem_t esp32_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_wake_on_ext1), MP_ROM_PTR(&esp32_wake_on_ext1_obj) },
     { MP_ROM_QSTR(MP_QSTR_raw_temperature), MP_ROM_PTR(&esp32_raw_temperature_obj) },
     { MP_ROM_QSTR(MP_QSTR_hall_sensor), MP_ROM_PTR(&esp32_hall_sensor_obj) },
+    { MP_ROM_QSTR(MP_QSTR_idf_heap_info), MP_ROM_PTR(&esp32_idf_heap_info_obj) },
 
+    { MP_ROM_QSTR(MP_QSTR_Partition), MP_ROM_PTR(&esp32_partition_type) },
+    { MP_ROM_QSTR(MP_QSTR_RMT), MP_ROM_PTR(&esp32_rmt_type) },
     { MP_ROM_QSTR(MP_QSTR_ULP), MP_ROM_PTR(&esp32_ulp_type) },
 
-    { MP_ROM_QSTR(MP_QSTR_WAKEUP_ALL_LOW), MP_ROM_PTR(&mp_const_false_obj) },
-    { MP_ROM_QSTR(MP_QSTR_WAKEUP_ANY_HIGH), MP_ROM_PTR(&mp_const_true_obj) },
+    { MP_ROM_QSTR(MP_QSTR_WAKEUP_ALL_LOW), MP_ROM_FALSE },
+    { MP_ROM_QSTR(MP_QSTR_WAKEUP_ANY_HIGH), MP_ROM_TRUE },
+
+    { MP_ROM_QSTR(MP_QSTR_HEAP_DATA), MP_ROM_INT(MALLOC_CAP_8BIT) },
+    { MP_ROM_QSTR(MP_QSTR_HEAP_EXEC), MP_ROM_INT(MALLOC_CAP_EXEC) },
 };
 
 STATIC MP_DEFINE_CONST_DICT(esp32_module_globals, esp32_module_globals_table);
 
 const mp_obj_module_t esp32_module = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&esp32_module_globals,
+    .globals = (mp_obj_dict_t *)&esp32_module_globals,
 };
diff --git a/ports/esp32/modesp32.h b/ports/esp32/modesp32.h
index 1d18cb41fbe53..f4c0491f7c27f 100644
--- a/ports/esp32/modesp32.h
+++ b/ports/esp32/modesp32.h
@@ -2,10 +2,10 @@
 #define MICROPY_INCLUDED_ESP32_MODESP32_H
 
 #define RTC_VALID_EXT_PINS \
-( \
-    (1ll << 0)  | \
-    (1ll << 2)  | \
-    (1ll << 4)  | \
+    ( \
+    (1ll << 0) | \
+    (1ll << 2) | \
+    (1ll << 4) | \
     (1ll << 12) | \
     (1ll << 13) | \
     (1ll << 14) | \
@@ -21,11 +21,13 @@
     (1ll << 37) | \
     (1ll << 38) | \
     (1ll << 39)   \
-)
+    )
 
 #define RTC_LAST_EXT_PIN 39
 #define RTC_IS_VALID_EXT_PIN(pin_id) ((1ll << (pin_id)) & RTC_VALID_EXT_PINS)
 
+extern const mp_obj_type_t esp32_partition_type;
+extern const mp_obj_type_t esp32_rmt_type;
 extern const mp_obj_type_t esp32_ulp_type;
 
 #endif // MICROPY_INCLUDED_ESP32_MODESP32_H
diff --git a/ports/esp32/modmachine.c b/ports/esp32/modmachine.c
index bc459ee5c29b2..82a02522f7b41 100644
--- a/ports/esp32/modmachine.c
+++ b/ports/esp32/modmachine.c
@@ -32,14 +32,21 @@
 
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
+#if MICROPY_ESP_IDF_4
+#include "esp32/rom/rtc.h"
+#include "esp32/clk.h"
+#include "esp_sleep.h"
+#else
 #include "rom/ets_sys.h"
 #include "rom/rtc.h"
 #include "esp_clk.h"
+#endif
 #include "esp_pm.h"
 #include "driver/touch_pad.h"
 
 #include "py/obj.h"
 #include "py/runtime.h"
+#include "lib/utils/pyexec.h"
 #include "extmod/machine_mem.h"
 #include "extmod/machine_signal.h"
 #include "extmod/machine_pulse.h"
@@ -66,7 +73,7 @@ STATIC mp_obj_t machine_freq(size_t n_args, const mp_obj_t *args) {
         // set
         mp_int_t freq = mp_obj_get_int(args[0]) / 1000000;
         if (freq != 20 && freq != 40 && freq != 80 && freq != 160 && freq != 240) {
-            mp_raise_ValueError("frequency must be 20MHz, 40MHz, 80Mhz, 160MHz or 240MHz");
+            mp_raise_ValueError(MP_ERROR_TEXT("frequency must be 20MHz, 40MHz, 80Mhz, 160MHz or 240MHz"));
         }
         esp_pm_config_esp32_t pm;
         pm.max_freq_mhz = freq;
@@ -113,11 +120,11 @@ STATIC mp_obj_t machine_sleep_helper(wake_type_t wake_type, size_t n_args, const
 
     if (machine_rtc_config.wake_on_touch) {
         if (esp_sleep_enable_touchpad_wakeup() != ESP_OK) {
-            nlr_raise(mp_obj_new_exception_msg(&mp_type_RuntimeError, "esp_sleep_enable_touchpad_wakeup() failed"));
+            mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("esp_sleep_enable_touchpad_wakeup() failed"));
         }
     }
 
-    switch(wake_type) {
+    switch (wake_type) {
         case MACHINE_WAKE_SLEEP:
             esp_light_sleep_start();
             break;
@@ -139,36 +146,30 @@ STATIC mp_obj_t machine_deepsleep(size_t n_args, const mp_obj_t *pos_args, mp_ma
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_deepsleep_obj, 0,  machine_deepsleep);
 
 STATIC mp_obj_t machine_reset_cause(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    switch(rtc_get_reset_reason(0)) {
-        case POWERON_RESET:
+    switch (esp_reset_reason()) {
+        case ESP_RST_POWERON:
+        case ESP_RST_BROWNOUT:
             return MP_OBJ_NEW_SMALL_INT(MP_PWRON_RESET);
             break;
-        case SW_RESET:
-        case SW_CPU_RESET:
-            return MP_OBJ_NEW_SMALL_INT(MP_SOFT_RESET);
-            break;
-        case OWDT_RESET:
-        case TG0WDT_SYS_RESET:
-        case TG1WDT_SYS_RESET:
-        case RTCWDT_SYS_RESET:
-        case RTCWDT_BROWN_OUT_RESET:
-        case RTCWDT_CPU_RESET:
-        case RTCWDT_RTC_RESET:
-        case TGWDT_CPU_RESET:
+
+        case ESP_RST_INT_WDT:
+        case ESP_RST_TASK_WDT:
+        case ESP_RST_WDT:
             return MP_OBJ_NEW_SMALL_INT(MP_WDT_RESET);
             break;
 
-        case DEEPSLEEP_RESET:
+        case ESP_RST_DEEPSLEEP:
             return MP_OBJ_NEW_SMALL_INT(MP_DEEPSLEEP_RESET);
             break;
 
-        case EXT_CPU_RESET:
+        case ESP_RST_SW:
+        case ESP_RST_PANIC:
+        case ESP_RST_EXT: // Comment in ESP-IDF: "For ESP32, ESP_RST_EXT is never returned"
             return MP_OBJ_NEW_SMALL_INT(MP_HARD_RESET);
             break;
 
-        case NO_MEAN:
-        case SDIO_RESET:
-        case INTRUSION_RESET:
+        case ESP_RST_SDIO:
+        case ESP_RST_UNKNOWN:
         default:
             return MP_OBJ_NEW_SMALL_INT(0);
             break;
@@ -187,6 +188,12 @@ STATIC mp_obj_t machine_reset(void) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_reset_obj, machine_reset);
 
+STATIC mp_obj_t machine_soft_reset(void) {
+    pyexec_system_exit = PYEXEC_FORCED_EXIT;
+    mp_raise_type(&mp_type_SystemExit);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_soft_reset_obj, machine_soft_reset);
+
 STATIC mp_obj_t machine_unique_id(void) {
     uint8_t chipid[6];
     esp_efuse_mac_get_default(chipid);
@@ -222,6 +229,7 @@ STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
 
     { MP_ROM_QSTR(MP_QSTR_freq), MP_ROM_PTR(&machine_freq_obj) },
     { MP_ROM_QSTR(MP_QSTR_reset), MP_ROM_PTR(&machine_reset_obj) },
+    { MP_ROM_QSTR(MP_QSTR_soft_reset), MP_ROM_PTR(&machine_soft_reset_obj) },
     { MP_ROM_QSTR(MP_QSTR_unique_id), MP_ROM_PTR(&machine_unique_id_obj) },
     { MP_ROM_QSTR(MP_QSTR_sleep), MP_ROM_PTR(&machine_lightsleep_obj) },
     { MP_ROM_QSTR(MP_QSTR_lightsleep), MP_ROM_PTR(&machine_lightsleep_obj) },
@@ -235,6 +243,9 @@ STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
 
     { MP_ROM_QSTR(MP_QSTR_Timer), MP_ROM_PTR(&machine_timer_type) },
     { MP_ROM_QSTR(MP_QSTR_WDT), MP_ROM_PTR(&machine_wdt_type) },
+    #if MICROPY_HW_ENABLE_SDCARD
+    { MP_ROM_QSTR(MP_QSTR_SDCard), MP_ROM_PTR(&machine_sdcard_type) },
+    #endif
 
     // wake abilities
     { MP_ROM_QSTR(MP_QSTR_SLEEP), MP_ROM_INT(MACHINE_WAKE_SLEEP) },
@@ -272,7 +283,7 @@ STATIC MP_DEFINE_CONST_DICT(machine_module_globals, machine_module_globals_table
 
 const mp_obj_module_t mp_module_machine = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&machine_module_globals,
+    .globals = (mp_obj_dict_t *)&machine_module_globals,
 };
 
 #endif // MICROPY_PY_MACHINE
diff --git a/ports/esp32/modmachine.h b/ports/esp32/modmachine.h
index b65b427b4ea33..fbb43250ff42e 100644
--- a/ports/esp32/modmachine.h
+++ b/ports/esp32/modmachine.h
@@ -4,7 +4,7 @@
 #include "py/obj.h"
 
 typedef enum {
-    //MACHINE_WAKE_IDLE=0x01,
+    // MACHINE_WAKE_IDLE=0x01,
     MACHINE_WAKE_SLEEP=0x02,
     MACHINE_WAKE_DEEPSLEEP=0x04
 } wake_type_t;
@@ -19,6 +19,7 @@ extern const mp_obj_type_t machine_pwm_type;
 extern const mp_obj_type_t machine_hw_spi_type;
 extern const mp_obj_type_t machine_uart_type;
 extern const mp_obj_type_t machine_rtc_type;
+extern const mp_obj_type_t machine_sdcard_type;
 
 void machine_pins_init(void);
 void machine_pins_deinit(void);
diff --git a/ports/esp32/modnetwork.c b/ports/esp32/modnetwork.c
index 5d3c19b802702..975029121ed0b 100644
--- a/ports/esp32/modnetwork.c
+++ b/ports/esp32/modnetwork.c
@@ -43,65 +43,69 @@
 #include "netutils.h"
 #include "esp_eth.h"
 #include "esp_wifi.h"
-#include "esp_wifi_types.h"
 #include "esp_log.h"
-#include "esp_event_loop.h"
 #include "lwip/dns.h"
 #include "tcpip_adapter.h"
+#include "mdns.h"
+
+#if !MICROPY_ESP_IDF_4
+#include "esp_wifi_types.h"
+#include "esp_event_loop.h"
+#endif
 
 #include "modnetwork.h"
 
 #define MODNETWORK_INCLUDE_CONSTANTS (1)
 
 NORETURN void _esp_exceptions(esp_err_t e) {
-   switch (e) {
-      case ESP_ERR_WIFI_NOT_INIT: 
-        mp_raise_msg(&mp_type_OSError, "Wifi Not Initialized");
-      case ESP_ERR_WIFI_NOT_STARTED:
-        mp_raise_msg(&mp_type_OSError, "Wifi Not Started");
-      case ESP_ERR_WIFI_NOT_STOPPED:
-        mp_raise_msg(&mp_type_OSError, "Wifi Not Stopped");
-      case ESP_ERR_WIFI_IF:
-        mp_raise_msg(&mp_type_OSError, "Wifi Invalid Interface");
-      case ESP_ERR_WIFI_MODE:
-        mp_raise_msg(&mp_type_OSError, "Wifi Invalid Mode");
-      case ESP_ERR_WIFI_STATE:
-        mp_raise_msg(&mp_type_OSError, "Wifi Internal State Error");
-      case ESP_ERR_WIFI_CONN:
-        mp_raise_msg(&mp_type_OSError, "Wifi Internal Error");
-      case ESP_ERR_WIFI_NVS:
-        mp_raise_msg(&mp_type_OSError, "Wifi Internal NVS Error");
-      case ESP_ERR_WIFI_MAC:
-        mp_raise_msg(&mp_type_OSError, "Wifi Invalid MAC Address");
-      case ESP_ERR_WIFI_SSID:
-        mp_raise_msg(&mp_type_OSError, "Wifi SSID Invalid");
-      case ESP_ERR_WIFI_PASSWORD:
-        mp_raise_msg(&mp_type_OSError, "Wifi Invalid Password");
-      case ESP_ERR_WIFI_TIMEOUT:
-        mp_raise_OSError(MP_ETIMEDOUT);
-      case ESP_ERR_WIFI_WAKE_FAIL:
-        mp_raise_msg(&mp_type_OSError, "Wifi Wakeup Failure");
-      case ESP_ERR_WIFI_WOULD_BLOCK:
-        mp_raise_msg(&mp_type_OSError, "Wifi Would Block");
-      case ESP_ERR_WIFI_NOT_CONNECT:
-        mp_raise_msg(&mp_type_OSError, "Wifi Not Connected");
-      case ESP_ERR_TCPIP_ADAPTER_INVALID_PARAMS:
-        mp_raise_msg(&mp_type_OSError, "TCP/IP Invalid Parameters");
-      case ESP_ERR_TCPIP_ADAPTER_IF_NOT_READY:
-        mp_raise_msg(&mp_type_OSError, "TCP/IP IF Not Ready");
-      case ESP_ERR_TCPIP_ADAPTER_DHCPC_START_FAILED:
-        mp_raise_msg(&mp_type_OSError, "TCP/IP DHCP Client Start Failed");
-      case ESP_ERR_TCPIP_ADAPTER_NO_MEM:
-        mp_raise_OSError(MP_ENOMEM); 
-      default:
-        nlr_raise(mp_obj_new_exception_msg_varg(
-          &mp_type_RuntimeError, "Wifi Unknown Error 0x%04x", e
-        ));
-   }
+    switch (e) {
+        case ESP_ERR_WIFI_NOT_INIT:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Initialized"));
+        case ESP_ERR_WIFI_NOT_STARTED:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Started"));
+        case ESP_ERR_WIFI_NOT_STOPPED:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Stopped"));
+        case ESP_ERR_WIFI_IF:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid Interface"));
+        case ESP_ERR_WIFI_MODE:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid Mode"));
+        case ESP_ERR_WIFI_STATE:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Internal State Error"));
+        case ESP_ERR_WIFI_CONN:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Internal Error"));
+        case ESP_ERR_WIFI_NVS:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Internal NVS Error"));
+        case ESP_ERR_WIFI_MAC:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid MAC Address"));
+        case ESP_ERR_WIFI_SSID:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi SSID Invalid"));
+        case ESP_ERR_WIFI_PASSWORD:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Invalid Password"));
+        case ESP_ERR_WIFI_TIMEOUT:
+            mp_raise_OSError(MP_ETIMEDOUT);
+        case ESP_ERR_WIFI_WAKE_FAIL:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Wakeup Failure"));
+        case ESP_ERR_WIFI_WOULD_BLOCK:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Would Block"));
+        case ESP_ERR_WIFI_NOT_CONNECT:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("Wifi Not Connected"));
+        case ESP_ERR_TCPIP_ADAPTER_INVALID_PARAMS:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("TCP/IP Invalid Parameters"));
+        case ESP_ERR_TCPIP_ADAPTER_IF_NOT_READY:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("TCP/IP IF Not Ready"));
+        case ESP_ERR_TCPIP_ADAPTER_DHCPC_START_FAILED:
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("TCP/IP DHCP Client Start Failed"));
+        case ESP_ERR_TCPIP_ADAPTER_NO_MEM:
+            mp_raise_OSError(MP_ENOMEM);
+        default:
+            mp_raise_msg_varg(&mp_type_RuntimeError, MP_ERROR_TEXT("Wifi Unknown Error 0x%04x"), e);
+    }
 }
 
 static inline void esp_exceptions(esp_err_t e) {
-    if (e != ESP_OK) _esp_exceptions(e);
+    if (e != ESP_OK) {
+        _esp_exceptions(e);
+    }
 }
 
 #define ESP_EXCEPTIONS(x) do { esp_exceptions(x); } while (0);
@@ -128,89 +132,108 @@ static bool wifi_sta_connected = false;
 // Store the current status. 0 means None here, safe to do so as first enum value is WIFI_REASON_UNSPECIFIED=1.
 static uint8_t wifi_sta_disconn_reason = 0;
 
+#if MICROPY_HW_ENABLE_MDNS_QUERIES || MICROPY_HW_ENABLE_MDNS_RESPONDER
+// Whether mDNS has been initialised or not
+static bool mdns_initialised = false;
+#endif
+
 // This function is called by the system-event task and so runs in a different
 // thread to the main MicroPython task.  It must not raise any Python exceptions.
 static esp_err_t event_handler(void *ctx, system_event_t *event) {
-   switch(event->event_id) {
-    case SYSTEM_EVENT_STA_START:
-        ESP_LOGI("wifi", "STA_START");
-        break;
-    case SYSTEM_EVENT_STA_CONNECTED:
-        ESP_LOGI("network", "CONNECTED");
-        break;
-    case SYSTEM_EVENT_STA_GOT_IP:
-        ESP_LOGI("network", "GOT_IP");
-        wifi_sta_connected = true;
-        wifi_sta_disconn_reason = 0; // Success so clear error. (in case of new error will be replaced anyway)
-        break;
-    case SYSTEM_EVENT_STA_DISCONNECTED: {
-        // This is a workaround as ESP32 WiFi libs don't currently
-        // auto-reassociate.
-        system_event_sta_disconnected_t *disconn = &event->event_info.disconnected;
-        char *message = "";
-        wifi_sta_disconn_reason = disconn->reason;
-        switch (disconn->reason) {
-            case WIFI_REASON_BEACON_TIMEOUT:
-                // AP has dropped out; try to reconnect.
-                message = "\nbeacon timeout";
-                break;
-            case WIFI_REASON_NO_AP_FOUND:
-                // AP may not exist, or it may have momentarily dropped out; try to reconnect.
-                message = "\nno AP found";
-                break;
-            case WIFI_REASON_AUTH_FAIL:
-                message = "\nauthentication failed";
-                wifi_sta_connect_requested = false;
-                break;
-            default:
-                // Let other errors through and try to reconnect.
-                break;
-        }
-        ESP_LOGI("wifi", "STA_DISCONNECTED, reason:%d%s", disconn->reason, message);
-
-        wifi_sta_connected = false;
-        if (wifi_sta_connect_requested) {
-            wifi_mode_t mode;
-            if (esp_wifi_get_mode(&mode) == ESP_OK) {
-                if (mode & WIFI_MODE_STA) {
-                    // STA is active so attempt to reconnect.
-                    esp_err_t e = esp_wifi_connect();
-                    if (e != ESP_OK) {
-                        ESP_LOGI("wifi", "error attempting to reconnect: 0x%04x", e);
+    switch (event->event_id) {
+        case SYSTEM_EVENT_STA_START:
+            ESP_LOGI("wifi", "STA_START");
+            break;
+        case SYSTEM_EVENT_STA_CONNECTED:
+            ESP_LOGI("network", "CONNECTED");
+            break;
+        case SYSTEM_EVENT_STA_GOT_IP:
+            ESP_LOGI("network", "GOT_IP");
+            wifi_sta_connected = true;
+            wifi_sta_disconn_reason = 0; // Success so clear error. (in case of new error will be replaced anyway)
+            #if MICROPY_HW_ENABLE_MDNS_QUERIES || MICROPY_HW_ENABLE_MDNS_RESPONDER
+            if (!mdns_initialised) {
+                mdns_init();
+                #if MICROPY_HW_ENABLE_MDNS_RESPONDER
+                const char *hostname = NULL;
+                if (tcpip_adapter_get_hostname(WIFI_IF_STA, &hostname) != ESP_OK || hostname == NULL) {
+                    hostname = "esp32";
+                }
+                mdns_hostname_set(hostname);
+                mdns_instance_name_set(hostname);
+                #endif
+                mdns_initialised = true;
+            }
+            #endif
+            break;
+        case SYSTEM_EVENT_STA_DISCONNECTED: {
+            // This is a workaround as ESP32 WiFi libs don't currently
+            // auto-reassociate.
+            system_event_sta_disconnected_t *disconn = &event->event_info.disconnected;
+            char *message = "";
+            wifi_sta_disconn_reason = disconn->reason;
+            switch (disconn->reason) {
+                case WIFI_REASON_BEACON_TIMEOUT:
+                    // AP has dropped out; try to reconnect.
+                    message = "\nbeacon timeout";
+                    break;
+                case WIFI_REASON_NO_AP_FOUND:
+                    // AP may not exist, or it may have momentarily dropped out; try to reconnect.
+                    message = "\nno AP found";
+                    break;
+                case WIFI_REASON_AUTH_FAIL:
+                    // Password may be wrong, or it just failed to connect; try to reconnect.
+                    message = "\nauthentication failed";
+                    break;
+                default:
+                    // Let other errors through and try to reconnect.
+                    break;
+            }
+            ESP_LOGI("wifi", "STA_DISCONNECTED, reason:%d%s", disconn->reason, message);
+
+            wifi_sta_connected = false;
+            if (wifi_sta_connect_requested) {
+                wifi_mode_t mode;
+                if (esp_wifi_get_mode(&mode) == ESP_OK) {
+                    if (mode & WIFI_MODE_STA) {
+                        // STA is active so attempt to reconnect.
+                        esp_err_t e = esp_wifi_connect();
+                        if (e != ESP_OK) {
+                            ESP_LOGI("wifi", "error attempting to reconnect: 0x%04x", e);
+                        }
                     }
                 }
             }
+            break;
         }
-        break;
-    }
-    case SYSTEM_EVENT_GOT_IP6:
-        ESP_LOGI("network", "Got IPv6");
-        break;
-    case SYSTEM_EVENT_ETH_START:
-        ESP_LOGI("ethernet", "start");
-        break;
-    case SYSTEM_EVENT_ETH_STOP:
-        ESP_LOGI("ethernet", "stop");
-        break;
-    case SYSTEM_EVENT_ETH_CONNECTED:
-        ESP_LOGI("ethernet", "LAN cable connected");
-        break;
-    case SYSTEM_EVENT_ETH_DISCONNECTED:
-        ESP_LOGI("ethernet", "LAN cable disconnected");
-        break;
-    case SYSTEM_EVENT_ETH_GOT_IP:
-        ESP_LOGI("ethernet", "Got IP");
-        break;
-    default:
-        ESP_LOGI("network", "event %d", event->event_id);
-        break;
+        case SYSTEM_EVENT_GOT_IP6:
+            ESP_LOGI("network", "Got IPv6");
+            break;
+        case SYSTEM_EVENT_ETH_START:
+            ESP_LOGI("ethernet", "start");
+            break;
+        case SYSTEM_EVENT_ETH_STOP:
+            ESP_LOGI("ethernet", "stop");
+            break;
+        case SYSTEM_EVENT_ETH_CONNECTED:
+            ESP_LOGI("ethernet", "LAN cable connected");
+            break;
+        case SYSTEM_EVENT_ETH_DISCONNECTED:
+            ESP_LOGI("ethernet", "LAN cable disconnected");
+            break;
+        case SYSTEM_EVENT_ETH_GOT_IP:
+            ESP_LOGI("ethernet", "Got IP");
+            break;
+        default:
+            ESP_LOGI("network", "event %d", event->event_id);
+            break;
     }
     return ESP_OK;
 }
 
 /*void error_check(bool status, const char *msg) {
     if (!status) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, msg));
+        mp_raise_msg(&mp_type_OSError, msg);
     }
 }
 */
@@ -218,7 +241,7 @@ static esp_err_t event_handler(void *ctx, system_event_t *event) {
 STATIC void require_if(mp_obj_t wlan_if, int if_no) {
     wlan_if_obj_t *self = MP_OBJ_TO_PTR(wlan_if);
     if (self->if_id != if_no) {
-        mp_raise_msg(&mp_type_OSError, if_no == WIFI_IF_STA ? "STA required" : "AP required");
+        mp_raise_msg(&mp_type_OSError, if_no == WIFI_IF_STA ? MP_ERROR_TEXT("STA required") : MP_ERROR_TEXT("AP required"));
     }
 }
 
@@ -227,8 +250,8 @@ STATIC mp_obj_t get_wlan(size_t n_args, const mp_obj_t *args) {
     if (!initialized) {
         wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
         ESP_LOGD("modnetwork", "Initializing WiFi");
-        ESP_EXCEPTIONS( esp_wifi_init(&cfg) );
-        ESP_EXCEPTIONS( esp_wifi_set_storage(WIFI_STORAGE_RAM) );
+        ESP_EXCEPTIONS(esp_wifi_init(&cfg));
+        ESP_EXCEPTIONS(esp_wifi_set_storage(WIFI_STORAGE_RAM));
         ESP_LOGD("modnetwork", "Initialized");
         initialized = 1;
     }
@@ -239,7 +262,7 @@ STATIC mp_obj_t get_wlan(size_t n_args, const mp_obj_t *args) {
     } else if (idx == WIFI_IF_AP) {
         return MP_OBJ_FROM_PTR(&wlan_ap_obj);
     } else {
-        mp_raise_ValueError("invalid WLAN interface identifier");
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid WLAN interface identifier"));
     }
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(get_wlan_obj, 0, 1, get_wlan);
@@ -250,7 +273,7 @@ STATIC mp_obj_t esp_initialize() {
         ESP_LOGD("modnetwork", "Initializing TCP/IP");
         tcpip_adapter_init();
         ESP_LOGD("modnetwork", "Initializing Event Loop");
-        ESP_EXCEPTIONS( esp_event_loop_init(event_handler, NULL) );
+        ESP_EXCEPTIONS(esp_event_loop_init(event_handler, NULL));
         ESP_LOGD("modnetwork", "esp_event_loop_init done");
         initialized = 1;
     }
@@ -312,7 +335,7 @@ STATIC mp_obj_t esp_connect(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
 
     // configure any parameters that are given
     if (n_args > 1) {
-        mp_uint_t len;
+        size_t len;
         const char *p;
         if (args[ARG_ssid].u_obj != mp_const_none) {
             p = mp_obj_str_get_data(args[ARG_ssid].u_obj, &len);
@@ -330,12 +353,12 @@ STATIC mp_obj_t esp_connect(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
             wifi_sta_config.sta.bssid_set = 1;
             memcpy(wifi_sta_config.sta.bssid, p, sizeof(wifi_sta_config.sta.bssid));
         }
-        ESP_EXCEPTIONS( esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_sta_config) );
+        ESP_EXCEPTIONS(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_sta_config));
     }
 
     // connect to the WiFi AP
     MP_THREAD_GIL_EXIT();
-    ESP_EXCEPTIONS( esp_wifi_connect() );
+    ESP_EXCEPTIONS(esp_wifi_connect());
     MP_THREAD_GIL_ENTER();
     wifi_sta_connect_requested = true;
 
@@ -345,7 +368,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp_connect_obj, 1, esp_connect);
 
 STATIC mp_obj_t esp_disconnect(mp_obj_t self_in) {
     wifi_sta_connect_requested = false;
-    ESP_EXCEPTIONS( esp_wifi_disconnect() );
+    ESP_EXCEPTIONS(esp_wifi_disconnect());
     return mp_const_none;
 }
 
@@ -388,7 +411,7 @@ STATIC mp_obj_t esp_status(size_t n_args, const mp_obj_t *args) {
             require_if(args[0], WIFI_IF_AP);
             wifi_sta_list_t station_list;
             ESP_EXCEPTIONS(esp_wifi_ap_get_sta_list(&station_list));
-            wifi_sta_info_t *stations = (wifi_sta_info_t*)station_list.sta;
+            wifi_sta_info_t *stations = (wifi_sta_info_t *)station_list.sta;
             mp_obj_t list = mp_obj_new_list(0, NULL);
             for (int i = 0; i < station_list.num; ++i) {
                 mp_obj_tuple_t *t = mp_obj_new_tuple(1, NULL);
@@ -406,7 +429,7 @@ STATIC mp_obj_t esp_status(size_t n_args, const mp_obj_t *args) {
             return MP_OBJ_NEW_SMALL_INT(info.rssi);
         }
         default:
-            mp_raise_ValueError("unknown status param");
+            mp_raise_ValueError(MP_ERROR_TEXT("unknown status param"));
     }
 
     return mp_const_none;
@@ -418,7 +441,7 @@ STATIC mp_obj_t esp_scan(mp_obj_t self_in) {
     wifi_mode_t mode;
     ESP_EXCEPTIONS(esp_wifi_get_mode(&mode));
     if ((mode & WIFI_MODE_STA) == 0) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "STA must be active"));
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("STA must be active"));
     }
 
     mp_obj_t list = mp_obj_new_list(0, NULL);
@@ -429,9 +452,9 @@ STATIC mp_obj_t esp_scan(mp_obj_t self_in) {
     MP_THREAD_GIL_ENTER();
     if (status == 0) {
         uint16_t count = 0;
-        ESP_EXCEPTIONS( esp_wifi_scan_get_ap_num(&count) );
+        ESP_EXCEPTIONS(esp_wifi_scan_get_ap_num(&count));
         wifi_ap_record_t *wifi_ap_records = calloc(count, sizeof(wifi_ap_record_t));
-        ESP_EXCEPTIONS( esp_wifi_scan_get_ap_records(&count, wifi_ap_records) );
+        ESP_EXCEPTIONS(esp_wifi_scan_get_ap_records(&count, wifi_ap_records));
         for (uint16_t i = 0; i < count; i++) {
             mp_obj_tuple_t *t = mp_obj_new_tuple(6, NULL);
             uint8_t *x = memchr(wifi_ap_records[i].ssid, 0, sizeof(wifi_ap_records[i].ssid));
@@ -472,10 +495,10 @@ STATIC mp_obj_t esp_ifconfig(size_t n_args, const mp_obj_t *args) {
     if (n_args == 1) {
         // get
         mp_obj_t tuple[4] = {
-            netutils_format_ipv4_addr((uint8_t*)&info.ip, NETUTILS_BIG),
-            netutils_format_ipv4_addr((uint8_t*)&info.netmask, NETUTILS_BIG),
-            netutils_format_ipv4_addr((uint8_t*)&info.gw, NETUTILS_BIG),
-            netutils_format_ipv4_addr((uint8_t*)&dns_info.ip, NETUTILS_BIG),
+            netutils_format_ipv4_addr((uint8_t *)&info.ip, NETUTILS_BIG),
+            netutils_format_ipv4_addr((uint8_t *)&info.netmask, NETUTILS_BIG),
+            netutils_format_ipv4_addr((uint8_t *)&info.gw, NETUTILS_BIG),
+            netutils_format_ipv4_addr((uint8_t *)&dns_info.ip, NETUTILS_BIG),
         };
         return mp_obj_new_tuple(4, tuple);
     } else {
@@ -483,28 +506,32 @@ STATIC mp_obj_t esp_ifconfig(size_t n_args, const mp_obj_t *args) {
         if (mp_obj_is_type(args[1], &mp_type_tuple) || mp_obj_is_type(args[1], &mp_type_list)) {
             mp_obj_t *items;
             mp_obj_get_array_fixed_n(args[1], 4, &items);
-            netutils_parse_ipv4_addr(items[0], (void*)&info.ip, NETUTILS_BIG);
+            netutils_parse_ipv4_addr(items[0], (void *)&info.ip, NETUTILS_BIG);
             if (mp_obj_is_integer(items[1])) {
                 // allow numeric netmask, i.e.:
                 // 24 -> 255.255.255.0
                 // 16 -> 255.255.0.0
                 // etc...
-                uint32_t* m = (uint32_t*)&info.netmask;
+                uint32_t *m = (uint32_t *)&info.netmask;
                 *m = htonl(0xffffffff << (32 - mp_obj_get_int(items[1])));
             } else {
-                netutils_parse_ipv4_addr(items[1], (void*)&info.netmask, NETUTILS_BIG);
+                netutils_parse_ipv4_addr(items[1], (void *)&info.netmask, NETUTILS_BIG);
             }
-            netutils_parse_ipv4_addr(items[2], (void*)&info.gw, NETUTILS_BIG);
-            netutils_parse_ipv4_addr(items[3], (void*)&dns_info.ip, NETUTILS_BIG);
+            netutils_parse_ipv4_addr(items[2], (void *)&info.gw, NETUTILS_BIG);
+            netutils_parse_ipv4_addr(items[3], (void *)&dns_info.ip, NETUTILS_BIG);
             // To set a static IP we have to disable DHCP first
             if (self->if_id == WIFI_IF_STA || self->if_id == ESP_IF_ETH) {
                 esp_err_t e = tcpip_adapter_dhcpc_stop(self->if_id);
-                if (e != ESP_OK && e != ESP_ERR_TCPIP_ADAPTER_DHCP_ALREADY_STOPPED) _esp_exceptions(e);
+                if (e != ESP_OK && e != ESP_ERR_TCPIP_ADAPTER_DHCP_ALREADY_STOPPED) {
+                    _esp_exceptions(e);
+                }
                 ESP_EXCEPTIONS(tcpip_adapter_set_ip_info(self->if_id, &info));
                 ESP_EXCEPTIONS(tcpip_adapter_set_dns_info(self->if_id, TCPIP_ADAPTER_DNS_MAIN, &dns_info));
             } else if (self->if_id == WIFI_IF_AP) {
                 esp_err_t e = tcpip_adapter_dhcps_stop(WIFI_IF_AP);
-                if (e != ESP_OK && e != ESP_ERR_TCPIP_ADAPTER_DHCP_ALREADY_STOPPED) _esp_exceptions(e);
+                if (e != ESP_OK && e != ESP_ERR_TCPIP_ADAPTER_DHCP_ALREADY_STOPPED) {
+                    _esp_exceptions(e);
+                }
                 ESP_EXCEPTIONS(tcpip_adapter_set_ip_info(WIFI_IF_AP, &info));
                 ESP_EXCEPTIONS(tcpip_adapter_set_dns_info(WIFI_IF_AP, TCPIP_ADAPTER_DNS_MAIN, &dns_info));
                 ESP_EXCEPTIONS(tcpip_adapter_dhcps_start(WIFI_IF_AP));
@@ -513,7 +540,7 @@ STATIC mp_obj_t esp_ifconfig(size_t n_args, const mp_obj_t *args) {
             // check for the correct string
             const char *mode = mp_obj_str_get_str(args[1]);
             if ((self->if_id != WIFI_IF_STA && self->if_id != ESP_IF_ETH) || strcmp("dhcp", mode)) {
-                mp_raise_ValueError("invalid arguments");
+                mp_raise_ValueError(MP_ERROR_TEXT("invalid arguments"));
             }
             ESP_EXCEPTIONS(tcpip_adapter_dhcpc_start(self->if_id));
         }
@@ -525,35 +552,42 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_ifconfig_obj, 1, 2, esp_ifconfig);
 
 STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
     if (n_args != 1 && kwargs->used != 0) {
-        mp_raise_TypeError("either pos or kw args are allowed");
+        mp_raise_TypeError(MP_ERROR_TEXT("either pos or kw args are allowed"));
     }
 
     wlan_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
 
-    // get the config for the interface
+    bool is_wifi = self->if_id == WIFI_IF_AP || self->if_id == WIFI_IF_STA;
+
     wifi_config_t cfg;
-    ESP_EXCEPTIONS(esp_wifi_get_config(self->if_id, &cfg));
+    if (is_wifi) {
+        ESP_EXCEPTIONS(esp_wifi_get_config(self->if_id, &cfg));
+    }
+
+    #define QS(x) (uintptr_t)MP_OBJ_NEW_QSTR(x)
 
     if (kwargs->used != 0) {
+        if (!is_wifi) {
+            goto unknown;
+        }
 
         for (size_t i = 0; i < kwargs->alloc; i++) {
             if (mp_map_slot_is_filled(kwargs, i)) {
                 int req_if = -1;
 
-                #define QS(x) (uintptr_t)MP_OBJ_NEW_QSTR(x)
                 switch ((uintptr_t)kwargs->table[i].key) {
                     case QS(MP_QSTR_mac): {
                         mp_buffer_info_t bufinfo;
                         mp_get_buffer_raise(kwargs->table[i].value, &bufinfo, MP_BUFFER_READ);
                         if (bufinfo.len != 6) {
-                            mp_raise_ValueError("invalid buffer length");
+                            mp_raise_ValueError(MP_ERROR_TEXT("invalid buffer length"));
                         }
                         ESP_EXCEPTIONS(esp_wifi_set_mac(self->if_id, bufinfo.buf));
                         break;
                     }
                     case QS(MP_QSTR_essid): {
                         req_if = WIFI_IF_AP;
-                        mp_uint_t len;
+                        size_t len;
                         const char *s = mp_obj_str_get_data(kwargs->table[i].value, &len);
                         len = MIN(len, sizeof(cfg.ap.ssid));
                         memcpy(cfg.ap.ssid, s, len);
@@ -572,7 +606,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
                     }
                     case QS(MP_QSTR_password): {
                         req_if = WIFI_IF_AP;
-                        mp_uint_t len;
+                        size_t len;
                         const char *s = mp_obj_str_get_data(kwargs->table[i].value, &len);
                         len = MIN(len, sizeof(cfg.ap.password) - 1);
                         memcpy(cfg.ap.password, s, len);
@@ -589,10 +623,14 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
                         ESP_EXCEPTIONS(tcpip_adapter_set_hostname(self->if_id, s));
                         break;
                     }
+                    case QS(MP_QSTR_max_clients): {
+                        req_if = WIFI_IF_AP;
+                        cfg.ap.max_connection = mp_obj_get_int(kwargs->table[i].value);
+                        break;
+                    }
                     default:
                         goto unknown;
                 }
-                #undef QS
 
                 // We post-check interface requirements to save on code size
                 if (req_if >= 0) {
@@ -609,24 +647,41 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
     // Get config
 
     if (n_args != 2) {
-        mp_raise_TypeError("can query only one param");
+        mp_raise_TypeError(MP_ERROR_TEXT("can query only one param"));
     }
 
     int req_if = -1;
-    mp_obj_t val;
+    mp_obj_t val = mp_const_none;
 
-    #define QS(x) (uintptr_t)MP_OBJ_NEW_QSTR(x)
     switch ((uintptr_t)args[1]) {
         case QS(MP_QSTR_mac): {
             uint8_t mac[6];
-            ESP_EXCEPTIONS(esp_wifi_get_mac(self->if_id, mac));
-            return mp_obj_new_bytes(mac, sizeof(mac));
+            switch (self->if_id) {
+                case WIFI_IF_AP: // fallthrough intentional
+                case WIFI_IF_STA:
+                    ESP_EXCEPTIONS(esp_wifi_get_mac(self->if_id, mac));
+                    return mp_obj_new_bytes(mac, sizeof(mac));
+
+                #if !MICROPY_ESP_IDF_4
+                case ESP_IF_ETH:
+                    esp_eth_get_mac(mac);
+                    return mp_obj_new_bytes(mac, sizeof(mac));
+                #endif
+
+                default:
+                    goto unknown;
+            }
         }
         case QS(MP_QSTR_essid):
-            if (self->if_id == WIFI_IF_STA) {
-                val = mp_obj_new_str((char*)cfg.sta.ssid, strlen((char*)cfg.sta.ssid));
-            } else {
-                val = mp_obj_new_str((char*)cfg.ap.ssid, cfg.ap.ssid_len);
+            switch (self->if_id) {
+                case WIFI_IF_STA:
+                    val = mp_obj_new_str((char *)cfg.sta.ssid, strlen((char *)cfg.sta.ssid));
+                    break;
+                case WIFI_IF_AP:
+                    val = mp_obj_new_str((char *)cfg.ap.ssid, cfg.ap.ssid_len);
+                    break;
+                default:
+                    req_if = WIFI_IF_AP;
             }
             break;
         case QS(MP_QSTR_hidden):
@@ -647,10 +702,15 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
             val = mp_obj_new_str(s, strlen(s));
             break;
         }
+        case QS(MP_QSTR_max_clients): {
+            val = MP_OBJ_NEW_SMALL_INT(cfg.ap.max_connection);
+            break;
+        }
         default:
             goto unknown;
     }
-    #undef QS
+
+#undef QS
 
     // We post-check interface requirements to save on code size
     if (req_if >= 0) {
@@ -660,10 +720,9 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
     return val;
 
 unknown:
-    mp_raise_ValueError("unknown config param");
+    mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
 }
-
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp_config_obj, 1, esp_config);
+MP_DEFINE_CONST_FUN_OBJ_KW(esp_config_obj, 1, esp_config);
 
 STATIC const mp_rom_map_elem_t wlan_if_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_active), MP_ROM_PTR(&esp_active_obj) },
@@ -694,11 +753,13 @@ STATIC const mp_rom_map_elem_t mp_module_network_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_network) },
     { MP_ROM_QSTR(MP_QSTR___init__), MP_ROM_PTR(&esp_initialize_obj) },
     { MP_ROM_QSTR(MP_QSTR_WLAN), MP_ROM_PTR(&get_wlan_obj) },
+    #if !MICROPY_ESP_IDF_4
     { MP_ROM_QSTR(MP_QSTR_LAN), MP_ROM_PTR(&get_lan_obj) },
     { MP_ROM_QSTR(MP_QSTR_PPP), MP_ROM_PTR(&ppp_make_new_obj) },
+    #endif
     { MP_ROM_QSTR(MP_QSTR_phy_mode), MP_ROM_PTR(&esp_phy_mode_obj) },
 
-#if MODNETWORK_INCLUDE_CONSTANTS
+    #if MODNETWORK_INCLUDE_CONSTANTS
     { MP_ROM_QSTR(MP_QSTR_STA_IF), MP_ROM_INT(WIFI_IF_STA)},
     { MP_ROM_QSTR(MP_QSTR_AP_IF), MP_ROM_INT(WIFI_IF_AP)},
 
@@ -717,12 +778,14 @@ STATIC const mp_rom_map_elem_t mp_module_network_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_PHY_TLK110), MP_ROM_INT(PHY_TLK110) },
 
     // ETH Clock modes from ESP-IDF
+    #if !MICROPY_ESP_IDF_4
     { MP_ROM_QSTR(MP_QSTR_ETH_CLOCK_GPIO0_IN), MP_ROM_INT(ETH_CLOCK_GPIO0_IN) },
     // Disabled at Aug 22nd 2018, reenabled Jan 28th 2019 in ESP-IDF
     // Because we use older SDK, it's currently disabled
-    //{ MP_ROM_QSTR(MP_QSTR_ETH_CLOCK_GPIO0_OUT), MP_ROM_INT(ETH_CLOCK_GPIO0_OUT) },
+    // { MP_ROM_QSTR(MP_QSTR_ETH_CLOCK_GPIO0_OUT), MP_ROM_INT(ETH_CLOCK_GPIO0_OUT) },
     { MP_ROM_QSTR(MP_QSTR_ETH_CLOCK_GPIO16_OUT), MP_ROM_INT(ETH_CLOCK_GPIO16_OUT) },
     { MP_ROM_QSTR(MP_QSTR_ETH_CLOCK_GPIO17_OUT), MP_ROM_INT(ETH_CLOCK_GPIO17_OUT) },
+    #endif
 
     { MP_ROM_QSTR(MP_QSTR_STAT_IDLE), MP_ROM_INT(STAT_IDLE)},
     { MP_ROM_QSTR(MP_QSTR_STAT_CONNECTING), MP_ROM_INT(STAT_CONNECTING)},
@@ -733,12 +796,12 @@ STATIC const mp_rom_map_elem_t mp_module_network_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_STAT_BEACON_TIMEOUT), MP_ROM_INT(WIFI_REASON_BEACON_TIMEOUT)},
     { MP_ROM_QSTR(MP_QSTR_STAT_ASSOC_FAIL), MP_ROM_INT(WIFI_REASON_ASSOC_FAIL)},
     { MP_ROM_QSTR(MP_QSTR_STAT_HANDSHAKE_TIMEOUT), MP_ROM_INT(WIFI_REASON_HANDSHAKE_TIMEOUT)},
-#endif
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(mp_module_network_globals, mp_module_network_globals_table);
 
 const mp_obj_module_t mp_module_network = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_network_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_network_globals,
 };
diff --git a/ports/esp32/modnetwork.h b/ports/esp32/modnetwork.h
index f39a2919d7d57..64d2da018c056 100644
--- a/ports/esp32/modnetwork.h
+++ b/ports/esp32/modnetwork.h
@@ -31,6 +31,7 @@ enum { PHY_LAN8720, PHY_TLK110 };
 MP_DECLARE_CONST_FUN_OBJ_KW(get_lan_obj);
 MP_DECLARE_CONST_FUN_OBJ_1(ppp_make_new_obj);
 MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(esp_ifconfig_obj);
+MP_DECLARE_CONST_FUN_OBJ_KW(esp_config_obj);
 
 void usocket_events_deinit(void);
 
diff --git a/ports/esp32/modsocket.c b/ports/esp32/modsocket.c
index 1d7aec5efa2a2..85433e575fc51 100644
--- a/ports/esp32/modsocket.c
+++ b/ports/esp32/modsocket.c
@@ -47,6 +47,7 @@
 #include "py/mperrno.h"
 #include "lib/netutils/netutils.h"
 #include "tcpip_adapter.h"
+#include "mdns.h"
 #include "modnetwork.h"
 
 #include "lwip/sockets.h"
@@ -55,7 +56,21 @@
 #include "lwip/igmp.h"
 #include "esp_log.h"
 
+#if !MICROPY_ESP_IDF_4
+#define lwip_bind lwip_bind_r
+#define lwip_listen lwip_listen_r
+#define lwip_accept lwip_accept_r
+#define lwip_setsockopt lwip_setsockopt_r
+#define lwip_fnctl lwip_fnctl_r
+#define lwip_recvfrom lwip_recvfrom_r
+#define lwip_write lwip_write_r
+#define lwip_sendto lwip_sendto_r
+#define lwip_close lwip_close_r
+#endif
+
 #define SOCKET_POLL_US (100000)
+#define MDNS_QUERY_TIMEOUT_MS (5000)
+#define MDNS_LOCAL_SUFFIX ".local"
 
 typedef struct _socket_obj_t {
     mp_obj_base_t base;
@@ -140,14 +155,68 @@ void usocket_events_handler(void) {
 
 NORETURN static void exception_from_errno(int _errno) {
     // Here we need to convert from lwip errno values to MicroPython's standard ones
-    if (_errno == EINPROGRESS) {
+    if (_errno == EADDRINUSE) {
+        _errno = MP_EADDRINUSE;
+    } else if (_errno == EINPROGRESS) {
         _errno = MP_EINPROGRESS;
     }
     mp_raise_OSError(_errno);
 }
 
 static inline void check_for_exceptions(void) {
-    mp_handle_pending();
+    mp_handle_pending(true);
+}
+
+// This function mimics lwip_getaddrinfo, with added support for mDNS queries
+static int _socket_getaddrinfo3(const char *nodename, const char *servname,
+    const struct addrinfo *hints, struct addrinfo **res) {
+
+    #if MICROPY_HW_ENABLE_MDNS_QUERIES
+    int nodename_len = strlen(nodename);
+    const int local_len = sizeof(MDNS_LOCAL_SUFFIX) - 1;
+    if (nodename_len > local_len
+        && strcasecmp(nodename + nodename_len - local_len, MDNS_LOCAL_SUFFIX) == 0) {
+        // mDNS query
+        char nodename_no_local[nodename_len - local_len + 1];
+        memcpy(nodename_no_local, nodename, nodename_len - local_len);
+        nodename_no_local[nodename_len - local_len] = '\0';
+
+        struct ip4_addr addr = {0};
+        esp_err_t err = mdns_query_a(nodename_no_local, MDNS_QUERY_TIMEOUT_MS, &addr);
+        if (err != ESP_OK) {
+            if (err == ESP_ERR_NOT_FOUND) {
+                *res = NULL;
+                return 0;
+            }
+            *res = NULL;
+            return err;
+        }
+
+        struct addrinfo *ai = memp_malloc(MEMP_NETDB);
+        if (ai == NULL) {
+            *res = NULL;
+            return EAI_MEMORY;
+        }
+        memset(ai, 0, sizeof(struct addrinfo) + sizeof(struct sockaddr_storage));
+
+        struct sockaddr_in *sa = (struct sockaddr_in *)((uint8_t *)ai + sizeof(struct addrinfo));
+        inet_addr_from_ip4addr(&sa->sin_addr, &addr);
+        sa->sin_family = AF_INET;
+        sa->sin_len = sizeof(struct sockaddr_in);
+        sa->sin_port = lwip_htons((u16_t)atoi(servname));
+        ai->ai_family = AF_INET;
+        ai->ai_canonname = ((char *)sa + sizeof(struct sockaddr_storage));
+        memcpy(ai->ai_canonname, nodename, nodename_len + 1);
+        ai->ai_addrlen = sizeof(struct sockaddr_storage);
+        ai->ai_addr = (struct sockaddr *)sa;
+
+        *res = ai;
+        return 0;
+    }
+    #endif
+
+    // Normal query
+    return lwip_getaddrinfo(nodename, servname, hints, res);
 }
 
 static int _socket_getaddrinfo2(const mp_obj_t host, const mp_obj_t portx, struct addrinfo **resp) {
@@ -172,22 +241,27 @@ static int _socket_getaddrinfo2(const mp_obj_t host, const mp_obj_t portx, struc
     }
 
     MP_THREAD_GIL_EXIT();
-    int res = lwip_getaddrinfo(host_str, port_str, &hints, resp);
+    int res = _socket_getaddrinfo3(host_str, port_str, &hints, resp);
     MP_THREAD_GIL_ENTER();
 
+    // Per docs: instead of raising gaierror getaddrinfo raises negative error number
+    if (res != 0) {
+        mp_raise_OSError(res > 0 ? -res : res);
+    }
+    // Somehow LwIP returns a resolution of 0.0.0.0 for failed lookups, traced it as far back
+    // as netconn_gethostbyname_addrtype returning OK instead of error.
+    if (*resp == NULL ||
+        (strcmp(resp[0]->ai_canonname, "0.0.0.0") == 0 && strcmp(host_str, "0.0.0.0") != 0)) {
+        mp_raise_OSError(-2); // name or service not known
+    }
+
     return res;
 }
 
 STATIC void _socket_getaddrinfo(const mp_obj_t addrtuple, struct addrinfo **resp) {
     mp_obj_t *elem;
     mp_obj_get_array_fixed_n(addrtuple, 2, &elem);
-    int res = _socket_getaddrinfo2(elem[0], elem[1], resp);
-    if (res != 0) {
-        mp_raise_OSError(res);
-    }
-    if (*resp == NULL) {
-        mp_raise_OSError(-2); // name or service not known
-    }
+    _socket_getaddrinfo2(elem[0], elem[1], resp);
 }
 
 STATIC mp_obj_t socket_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
@@ -222,18 +296,22 @@ STATIC mp_obj_t socket_bind(const mp_obj_t arg0, const mp_obj_t arg1) {
     socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
     struct addrinfo *res;
     _socket_getaddrinfo(arg1, &res);
-    int r = lwip_bind_r(self->fd, res->ai_addr, res->ai_addrlen);
+    int r = lwip_bind(self->fd, res->ai_addr, res->ai_addrlen);
     lwip_freeaddrinfo(res);
-    if (r < 0) exception_from_errno(errno);
+    if (r < 0) {
+        exception_from_errno(errno);
+    }
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_bind_obj, socket_bind);
-    
+
 STATIC mp_obj_t socket_listen(const mp_obj_t arg0, const mp_obj_t arg1) {
     socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
     int backlog = mp_obj_get_int(arg1);
-    int r = lwip_listen_r(self->fd, backlog);
-    if (r < 0) exception_from_errno(errno);
+    int r = lwip_listen(self->fd, backlog);
+    if (r < 0) {
+        exception_from_errno(errno);
+    }
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_listen_obj, socket_listen);
@@ -245,15 +323,25 @@ STATIC mp_obj_t socket_accept(const mp_obj_t arg0) {
     socklen_t addr_len = sizeof(addr);
 
     int new_fd = -1;
-    for (int i=0; i<=self->retries; i++) {
+    for (int i = 0; i <= self->retries; i++) {
         MP_THREAD_GIL_EXIT();
-        new_fd = lwip_accept_r(self->fd, &addr, &addr_len);
+        new_fd = lwip_accept(self->fd, &addr, &addr_len);
         MP_THREAD_GIL_ENTER();
-        if (new_fd >= 0) break;
-        if (errno != EAGAIN) exception_from_errno(errno);
+        if (new_fd >= 0) {
+            break;
+        }
+        if (errno != EAGAIN) {
+            exception_from_errno(errno);
+        }
         check_for_exceptions();
     }
-    if (new_fd < 0) mp_raise_OSError(MP_ETIMEDOUT);
+    if (new_fd < 0) {
+        if (self->retries == 0) {
+            mp_raise_OSError(MP_EAGAIN);
+        } else {
+            mp_raise_OSError(MP_ETIMEDOUT);
+        }
+    }
 
     // create new socket object
     socket_obj_t *sock = m_new_obj_with_finaliser(socket_obj_t);
@@ -266,8 +354,8 @@ STATIC mp_obj_t socket_accept(const mp_obj_t arg0) {
     _socket_settimeout(sock, UINT64_MAX);
 
     // make the return value
-    uint8_t *ip = (uint8_t*)&((struct sockaddr_in*)&addr)->sin_addr;
-    mp_uint_t port = lwip_ntohs(((struct sockaddr_in*)&addr)->sin_port);
+    uint8_t *ip = (uint8_t *)&((struct sockaddr_in *)&addr)->sin_addr;
+    mp_uint_t port = lwip_ntohs(((struct sockaddr_in *)&addr)->sin_port);
     mp_obj_tuple_t *client = mp_obj_new_tuple(2, NULL);
     client->items[0] = sock;
     client->items[1] = netutils_format_inet_addr(ip, port, NETUTILS_BIG);
@@ -281,7 +369,7 @@ STATIC mp_obj_t socket_connect(const mp_obj_t arg0, const mp_obj_t arg1) {
     struct addrinfo *res;
     _socket_getaddrinfo(arg1, &res);
     MP_THREAD_GIL_EXIT();
-    int r = lwip_connect_r(self->fd, res->ai_addr, res->ai_addrlen);
+    int r = lwip_connect(self->fd, res->ai_addr, res->ai_addrlen);
     MP_THREAD_GIL_ENTER();
     lwip_freeaddrinfo(res);
     if (r != 0) {
@@ -302,14 +390,14 @@ STATIC mp_obj_t socket_setsockopt(size_t n_args, const mp_obj_t *args) {
         // level: SOL_SOCKET
         case SO_REUSEADDR: {
             int val = mp_obj_get_int(args[3]);
-            int ret = lwip_setsockopt_r(self->fd, SOL_SOCKET, opt, &val, sizeof(int));
+            int ret = lwip_setsockopt(self->fd, SOL_SOCKET, opt, &val, sizeof(int));
             if (ret != 0) {
                 exception_from_errno(errno);
             }
             break;
         }
 
-        #if MICROPY_PY_USOCKET_EVENTS
+            #if MICROPY_PY_USOCKET_EVENTS
         // level: SOL_SOCKET
         // special "register callback" option
         case 20: {
@@ -326,7 +414,7 @@ STATIC mp_obj_t socket_setsockopt(size_t n_args, const mp_obj_t *args) {
             }
             break;
         }
-        #endif
+            #endif
 
         // level: IPPROTO_IP
         case IP_ADD_MEMBERSHIP: {
@@ -337,7 +425,7 @@ STATIC mp_obj_t socket_setsockopt(size_t n_args, const mp_obj_t *args) {
             }
 
             // POSIX setsockopt has order: group addr, if addr, lwIP has it vice-versa
-            err_t err = igmp_joingroup((const ip4_addr_t*)bufinfo.buf + 1, bufinfo.buf);
+            err_t err = igmp_joingroup((const ip4_addr_t *)bufinfo.buf + 1, bufinfo.buf);
             if (err != ERR_OK) {
                 mp_raise_OSError(-err);
             }
@@ -363,17 +451,18 @@ void _socket_settimeout(socket_obj_t *sock, uint64_t timeout_ms) {
         .tv_sec = 0,
         .tv_usec = timeout_ms ? SOCKET_POLL_US : 0
     };
-    lwip_setsockopt_r(sock->fd, SOL_SOCKET, SO_SNDTIMEO, (const void *)&timeout, sizeof(timeout));
-    lwip_setsockopt_r(sock->fd, SOL_SOCKET, SO_RCVTIMEO, (const void *)&timeout, sizeof(timeout));
-    lwip_fcntl_r(sock->fd, F_SETFL, timeout_ms ? 0 : O_NONBLOCK);
+    lwip_setsockopt(sock->fd, SOL_SOCKET, SO_SNDTIMEO, (const void *)&timeout, sizeof(timeout));
+    lwip_setsockopt(sock->fd, SOL_SOCKET, SO_RCVTIMEO, (const void *)&timeout, sizeof(timeout));
+    lwip_fcntl(sock->fd, F_SETFL, timeout_ms ? 0 : O_NONBLOCK);
 }
 
 STATIC mp_obj_t socket_settimeout(const mp_obj_t arg0, const mp_obj_t arg1) {
     socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
-    if (arg1 == mp_const_none) _socket_settimeout(self, UINT64_MAX);
-    else {
+    if (arg1 == mp_const_none) {
+        _socket_settimeout(self, UINT64_MAX);
+    } else {
         #if MICROPY_PY_BUILTINS_FLOAT
-        _socket_settimeout(self, mp_obj_get_float(arg1) * 1000L);
+        _socket_settimeout(self, (uint64_t)(mp_obj_get_float(arg1) * MICROPY_FLOAT_CONST(1000.0)));
         #else
         _socket_settimeout(self, mp_obj_get_int(arg1) * 1000);
         #endif
@@ -384,8 +473,11 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_settimeout_obj, socket_settimeout);
 
 STATIC mp_obj_t socket_setblocking(const mp_obj_t arg0, const mp_obj_t arg1) {
     socket_obj_t *self = MP_OBJ_TO_PTR(arg0);
-    if (mp_obj_is_true(arg1)) _socket_settimeout(self, UINT64_MAX);
-    else _socket_settimeout(self, 0);
+    if (mp_obj_is_true(arg1)) {
+        _socket_settimeout(self, UINT64_MAX);
+    } else {
+        _socket_settimeout(self, 0);
+    }
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_setblocking_obj, socket_setblocking);
@@ -398,7 +490,7 @@ STATIC mp_uint_t _socket_read_data(mp_obj_t self_in, void *buf, size_t size,
     socket_obj_t *sock = MP_OBJ_TO_PTR(self_in);
 
     // If the peer closed the connection then the lwIP socket API will only return "0" once
-    // from lwip_recvfrom_r and then block on subsequent calls.  To emulate POSIX behaviour,
+    // from lwip_recvfrom and then block on subsequent calls.  To emulate POSIX behaviour,
     // which continues to return "0" for each call on a closed socket, we set a flag when
     // the peer closed the socket.
     if (sock->peer_closed) {
@@ -421,7 +513,7 @@ STATIC mp_uint_t _socket_read_data(mp_obj_t self_in, void *buf, size_t size,
         if (release_gil) {
             MP_THREAD_GIL_EXIT();
         }
-        int r = lwip_recvfrom_r(sock->fd, buf, size, 0, from, from_len);
+        int r = lwip_recvfrom(sock->fd, buf, size, 0, from, from_len);
         if (release_gil) {
             MP_THREAD_GIL_ENTER();
         }
@@ -443,7 +535,7 @@ STATIC mp_uint_t _socket_read_data(mp_obj_t self_in, void *buf, size_t size,
 }
 
 mp_obj_t _socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in,
-        struct sockaddr *from, socklen_t *from_len) {
+    struct sockaddr *from, socklen_t *from_len) {
     size_t len = mp_obj_get_int(len_in);
     vstr_t vstr;
     vstr_init_len(&vstr, len);
@@ -470,8 +562,8 @@ STATIC mp_obj_t socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in) {
     mp_obj_t tuple[2];
     tuple[0] = _socket_recvfrom(self_in, len_in, &from, &fromlen);
 
-    uint8_t *ip = (uint8_t*)&((struct sockaddr_in*)&from)->sin_addr;
-    mp_uint_t port = lwip_ntohs(((struct sockaddr_in*)&from)->sin_port);
+    uint8_t *ip = (uint8_t *)&((struct sockaddr_in *)&from)->sin_addr;
+    mp_uint_t port = lwip_ntohs(((struct sockaddr_in *)&from)->sin_port);
     tuple[1] = netutils_format_inet_addr(ip, port, NETUTILS_BIG);
 
     return mp_obj_new_tuple(2, tuple);
@@ -480,15 +572,21 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_recvfrom_obj, socket_recvfrom);
 
 int _socket_send(socket_obj_t *sock, const char *data, size_t datalen) {
     int sentlen = 0;
-    for (int i=0; i<=sock->retries && sentlen < datalen; i++) {
+    for (int i = 0; i <= sock->retries && sentlen < datalen; i++) {
         MP_THREAD_GIL_EXIT();
-        int r = lwip_write_r(sock->fd, data+sentlen, datalen-sentlen);
+        int r = lwip_write(sock->fd, data + sentlen, datalen - sentlen);
         MP_THREAD_GIL_ENTER();
-        if (r < 0 && errno != EWOULDBLOCK) exception_from_errno(errno);
-        if (r > 0) sentlen += r;
+        if (r < 0 && errno != EWOULDBLOCK) {
+            exception_from_errno(errno);
+        }
+        if (r > 0) {
+            sentlen += r;
+        }
         check_for_exceptions();
     }
-    if (sentlen == 0) mp_raise_OSError(MP_ETIMEDOUT); 
+    if (sentlen == 0) {
+        mp_raise_OSError(MP_ETIMEDOUT);
+    }
     return sentlen;
 }
 
@@ -508,7 +606,9 @@ STATIC mp_obj_t socket_sendall(const mp_obj_t arg0, const mp_obj_t arg1) {
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(arg1, &bufinfo, MP_BUFFER_READ);
     int r = _socket_send(sock, bufinfo.buf, bufinfo.len);
-    if (r < bufinfo.len) mp_raise_OSError(MP_ETIMEDOUT);
+    if (r < bufinfo.len) {
+        mp_raise_OSError(MP_ETIMEDOUT);
+    }
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_sendall_obj, socket_sendall);
@@ -524,20 +624,22 @@ STATIC mp_obj_t socket_sendto(mp_obj_t self_in, mp_obj_t data_in, mp_obj_t addr_
     struct sockaddr_in to;
     to.sin_len = sizeof(to);
     to.sin_family = AF_INET;
-    to.sin_port = lwip_htons(netutils_parse_inet_addr(addr_in, (uint8_t*)&to.sin_addr, NETUTILS_BIG));
+    to.sin_port = lwip_htons(netutils_parse_inet_addr(addr_in, (uint8_t *)&to.sin_addr, NETUTILS_BIG));
 
     // send the data
-    for (int i=0; i<=self->retries; i++) {
+    for (int i = 0; i <= self->retries; i++) {
         MP_THREAD_GIL_EXIT();
-        int ret = lwip_sendto_r(self->fd, bufinfo.buf, bufinfo.len, 0, (struct sockaddr*)&to, sizeof(to));
+        int ret = lwip_sendto(self->fd, bufinfo.buf, bufinfo.len, 0, (struct sockaddr *)&to, sizeof(to));
         MP_THREAD_GIL_ENTER();
-        if (ret > 0) return mp_obj_new_int_from_uint(ret);
+        if (ret > 0) {
+            return mp_obj_new_int_from_uint(ret);
+        }
         if (ret == -1 && errno != EWOULDBLOCK) {
             exception_from_errno(errno);
         }
         check_for_exceptions();
     }
-    mp_raise_OSError(MP_ETIMEDOUT); 
+    mp_raise_OSError(MP_ETIMEDOUT);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_3(socket_sendto_obj, socket_sendto);
 
@@ -559,12 +661,17 @@ STATIC mp_uint_t socket_stream_read(mp_obj_t self_in, void *buf, mp_uint_t size,
 
 STATIC mp_uint_t socket_stream_write(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode) {
     socket_obj_t *sock = self_in;
-    for (int i=0; i<=sock->retries; i++) {
+    for (int i = 0; i <= sock->retries; i++) {
         MP_THREAD_GIL_EXIT();
-        int r = lwip_write_r(sock->fd, buf, size);
+        int r = lwip_write(sock->fd, buf, size);
         MP_THREAD_GIL_ENTER();
-        if (r > 0) return r;
-        if (r < 0 && errno != EWOULDBLOCK) { *errcode = errno; return MP_STREAM_ERROR; }
+        if (r > 0) {
+            return r;
+        }
+        if (r < 0 && errno != EWOULDBLOCK) {
+            *errcode = errno;
+            return MP_STREAM_ERROR;
+        }
         check_for_exceptions();
     }
     *errcode = sock->retries == 0 ? MP_EWOULDBLOCK : MP_ETIMEDOUT;
@@ -572,27 +679,45 @@ STATIC mp_uint_t socket_stream_write(mp_obj_t self_in, const void *buf, mp_uint_
 }
 
 STATIC mp_uint_t socket_stream_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
-    socket_obj_t * socket = self_in;
+    socket_obj_t *socket = self_in;
     if (request == MP_STREAM_POLL) {
+        if (socket->fd == -1) {
+            return MP_STREAM_POLL_NVAL;
+        }
 
-        fd_set rfds; FD_ZERO(&rfds);
-        fd_set wfds; FD_ZERO(&wfds);
-        fd_set efds; FD_ZERO(&efds);
+        fd_set rfds;
+        FD_ZERO(&rfds);
+        fd_set wfds;
+        FD_ZERO(&wfds);
+        fd_set efds;
+        FD_ZERO(&efds);
         struct timeval timeout = { .tv_sec = 0, .tv_usec = 0 };
-        if (arg & MP_STREAM_POLL_RD) FD_SET(socket->fd, &rfds);
-        if (arg & MP_STREAM_POLL_WR) FD_SET(socket->fd, &wfds);
-        if (arg & MP_STREAM_POLL_HUP) FD_SET(socket->fd, &efds);
+        if (arg & MP_STREAM_POLL_RD) {
+            FD_SET(socket->fd, &rfds);
+        }
+        if (arg & MP_STREAM_POLL_WR) {
+            FD_SET(socket->fd, &wfds);
+        }
+        if (arg & MP_STREAM_POLL_HUP) {
+            FD_SET(socket->fd, &efds);
+        }
 
-        int r = select((socket->fd)+1, &rfds, &wfds, &efds, &timeout);
+        int r = select((socket->fd) + 1, &rfds, &wfds, &efds, &timeout);
         if (r < 0) {
             *errcode = MP_EIO;
             return MP_STREAM_ERROR;
         }
 
         mp_uint_t ret = 0;
-        if (FD_ISSET(socket->fd, &rfds)) ret |= MP_STREAM_POLL_RD;
-        if (FD_ISSET(socket->fd, &wfds)) ret |= MP_STREAM_POLL_WR;
-        if (FD_ISSET(socket->fd, &efds)) ret |= MP_STREAM_POLL_HUP;
+        if (FD_ISSET(socket->fd, &rfds)) {
+            ret |= MP_STREAM_POLL_RD;
+        }
+        if (FD_ISSET(socket->fd, &wfds)) {
+            ret |= MP_STREAM_POLL_WR;
+        }
+        if (FD_ISSET(socket->fd, &efds)) {
+            ret |= MP_STREAM_POLL_HUP;
+        }
         return ret;
     } else if (request == MP_STREAM_CLOSE) {
         if (socket->fd >= 0) {
@@ -602,7 +727,7 @@ STATIC mp_uint_t socket_stream_ioctl(mp_obj_t self_in, mp_uint_t request, uintpt
                 socket->events_callback = MP_OBJ_NULL;
             }
             #endif
-            int ret = lwip_close_r(socket->fd);
+            int ret = lwip_close(socket->fd);
             if (ret != 0) {
                 *errcode = errno;
                 return MP_STREAM_ERROR;
@@ -670,7 +795,7 @@ STATIC mp_obj_t esp_socket_getaddrinfo(size_t n_args, const mp_obj_t *args) {
             mp_obj_new_str(resi->ai_canonname, strlen(resi->ai_canonname)),
             mp_const_none
         };
-        
+
         if (resi->ai_family == AF_INET) {
             struct sockaddr_in *addr = (struct sockaddr_in *)resi->ai_addr;
             // This looks odd, but it's really just a u32_t
@@ -686,7 +811,9 @@ STATIC mp_obj_t esp_socket_getaddrinfo(size_t n_args, const mp_obj_t *args) {
         mp_obj_list_append(ret_list, mp_obj_new_tuple(5, addrinfo_objs));
     }
 
-    if (res) lwip_freeaddrinfo(res);
+    if (res) {
+        lwip_freeaddrinfo(res);
+    }
     return ret_list;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_socket_getaddrinfo_obj, 2, 6, esp_socket_getaddrinfo);
@@ -725,5 +852,5 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_socket_globals, mp_module_socket_globals_t
 
 const mp_obj_module_t mp_module_usocket = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_socket_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_socket_globals,
 };
diff --git a/ports/esp32/modules/_boot.py b/ports/esp32/modules/_boot.py
index bf40ea3a9f319..a7d9813090bfd 100644
--- a/ports/esp32/modules/_boot.py
+++ b/ports/esp32/modules/_boot.py
@@ -4,9 +4,10 @@
 
 try:
     if bdev:
-        uos.mount(bdev, '/')
+        uos.mount(bdev, "/")
 except OSError:
     import inisetup
+
     vfs = inisetup.setup()
 
 gc.collect()
diff --git a/ports/esp32/modules/dht.py b/ports/esp32/modules/dht.py
deleted file mode 120000
index 2aa2f5cbfed8a..0000000000000
--- a/ports/esp32/modules/dht.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../drivers/dht/dht.py
\ No newline at end of file
diff --git a/ports/esp32/modules/ds18x20.py b/ports/esp32/modules/ds18x20.py
deleted file mode 120000
index 9721929a3f0e6..0000000000000
--- a/ports/esp32/modules/ds18x20.py
+++ /dev/null
@@ -1 +0,0 @@
-../../esp8266/modules/ds18x20.py
\ No newline at end of file
diff --git a/ports/esp32/modules/flashbdev.py b/ports/esp32/modules/flashbdev.py
index 935f5342fcc25..bf4fec9f38343 100644
--- a/ports/esp32/modules/flashbdev.py
+++ b/ports/esp32/modules/flashbdev.py
@@ -1,34 +1,4 @@
-import esp
+from esp32 import Partition
 
-class FlashBdev:
-
-    SEC_SIZE = 4096
-    START_SEC = esp.flash_user_start() // SEC_SIZE
-
-    def __init__(self, blocks):
-        self.blocks = blocks
-
-    def readblocks(self, n, buf):
-        #print("readblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
-        esp.flash_read((n + self.START_SEC) * self.SEC_SIZE, buf)
-
-    def writeblocks(self, n, buf):
-        #print("writeblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
-        #assert len(buf) <= self.SEC_SIZE, len(buf)
-        esp.flash_erase(n + self.START_SEC)
-        esp.flash_write((n + self.START_SEC) * self.SEC_SIZE, buf)
-
-    def ioctl(self, op, arg):
-        #print("ioctl(%d, %r)" % (op, arg))
-        if op == 4:  # BP_IOCTL_SEC_COUNT
-            return self.blocks
-        if op == 5:  # BP_IOCTL_SEC_SIZE
-            return self.SEC_SIZE
-
-size = esp.flash_size()
-if size < 1024*1024:
-    # flash too small for a filesystem
-    bdev = None
-else:
-    # for now we use a fixed size for the filesystem
-    bdev = FlashBdev(2048 * 1024 // FlashBdev.SEC_SIZE)
+bdev = Partition.find(Partition.TYPE_DATA, label="vfs")
+bdev = bdev[0] if bdev else None
diff --git a/ports/esp32/modules/inisetup.py b/ports/esp32/modules/inisetup.py
index 0e9c72fe86133..9995d6bc07dd2 100644
--- a/ports/esp32/modules/inisetup.py
+++ b/ports/esp32/modules/inisetup.py
@@ -1,42 +1,49 @@
 import uos
 from flashbdev import bdev
 
+
 def check_bootsec():
-    buf = bytearray(bdev.SEC_SIZE)
+    buf = bytearray(bdev.ioctl(5, 0))  # 5 is SEC_SIZE
     bdev.readblocks(0, buf)
     empty = True
     for b in buf:
-        if b != 0xff:
+        if b != 0xFF:
             empty = False
             break
     if empty:
         return True
     fs_corrupted()
 
+
 def fs_corrupted():
     import time
+
     while 1:
-        print("""\
+        print(
+            """\
 FAT filesystem appears to be corrupted. If you had important data there, you
 may want to make a flash snapshot to try to recover it. Otherwise, perform
 factory reprogramming of MicroPython firmware (completely erase flash, followed
 by firmware programming).
-""")
+"""
+        )
         time.sleep(3)
 
+
 def setup():
     check_bootsec()
     print("Performing initial setup")
-    uos.VfsFat.mkfs(bdev)
-    vfs = uos.VfsFat(bdev)
-    uos.mount(vfs, '/flash')
-    uos.chdir('/flash')
+    uos.VfsLfs2.mkfs(bdev)
+    vfs = uos.VfsLfs2(bdev)
+    uos.mount(vfs, "/")
     with open("boot.py", "w") as f:
-        f.write("""\
+        f.write(
+            """\
 # This file is executed on every boot (including wake-boot from deepsleep)
 #import esp
 #esp.osdebug(None)
 #import webrepl
 #webrepl.start()
-""")
+"""
+        )
     return vfs
diff --git a/ports/esp32/modules/neopixel.py b/ports/esp32/modules/neopixel.py
index 91f1d79f6d162..aa0de8112b5a4 100644
--- a/ports/esp32/modules/neopixel.py
+++ b/ports/esp32/modules/neopixel.py
@@ -6,7 +6,7 @@
 
 class NeoPixel:
     ORDER = (1, 0, 2, 3)
-    
+
     def __init__(self, pin, n, bpp=3, timing=1):
         self.pin = pin
         self.n = n
@@ -22,8 +22,7 @@ def __setitem__(self, index, val):
 
     def __getitem__(self, index):
         offset = index * self.bpp
-        return tuple(self.buf[offset + self.ORDER[i]]
-                     for i in range(self.bpp))
+        return tuple(self.buf[offset + self.ORDER[i]] for i in range(self.bpp))
 
     def fill(self, color):
         for i in range(self.n):
diff --git a/ports/esp32/modules/ntptime.py b/ports/esp32/modules/ntptime.py
deleted file mode 120000
index e90900d5a985c..0000000000000
--- a/ports/esp32/modules/ntptime.py
+++ /dev/null
@@ -1 +0,0 @@
-../../esp8266/modules/ntptime.py
\ No newline at end of file
diff --git a/ports/esp32/modules/onewire.py b/ports/esp32/modules/onewire.py
deleted file mode 120000
index 091629488e0bb..0000000000000
--- a/ports/esp32/modules/onewire.py
+++ /dev/null
@@ -1 +0,0 @@
-../../esp8266/modules/onewire.py
\ No newline at end of file
diff --git a/ports/esp32/modules/umqtt/robust.py b/ports/esp32/modules/umqtt/robust.py
deleted file mode 120000
index 6bfbbcf552957..0000000000000
--- a/ports/esp32/modules/umqtt/robust.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../micropython-lib/umqtt.robust/umqtt/robust.py
\ No newline at end of file
diff --git a/ports/esp32/modules/umqtt/simple.py b/ports/esp32/modules/umqtt/simple.py
deleted file mode 120000
index 6419a46647a4e..0000000000000
--- a/ports/esp32/modules/umqtt/simple.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../../../micropython-lib/umqtt.simple/umqtt/simple.py
\ No newline at end of file
diff --git a/ports/esp32/modules/upip.py b/ports/esp32/modules/upip.py
deleted file mode 120000
index 130eb69016485..0000000000000
--- a/ports/esp32/modules/upip.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../tools/upip.py
\ No newline at end of file
diff --git a/ports/esp32/modules/upip_utarfile.py b/ports/esp32/modules/upip_utarfile.py
deleted file mode 120000
index d9653d6a60808..0000000000000
--- a/ports/esp32/modules/upip_utarfile.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../tools/upip_utarfile.py
\ No newline at end of file
diff --git a/ports/esp32/modules/upysh.py b/ports/esp32/modules/upysh.py
deleted file mode 120000
index 12d100c29c115..0000000000000
--- a/ports/esp32/modules/upysh.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../../micropython-lib/upysh/upysh.py
\ No newline at end of file
diff --git a/ports/esp32/modules/urequests.py b/ports/esp32/modules/urequests.py
deleted file mode 120000
index 76661112e1c3f..0000000000000
--- a/ports/esp32/modules/urequests.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../../micropython-lib/urequests/urequests.py
\ No newline at end of file
diff --git a/ports/esp32/modules/webrepl.py b/ports/esp32/modules/webrepl.py
deleted file mode 120000
index 2a3987a729904..0000000000000
--- a/ports/esp32/modules/webrepl.py
+++ /dev/null
@@ -1 +0,0 @@
-../../esp8266/modules/webrepl.py
\ No newline at end of file
diff --git a/ports/esp32/modules/webrepl_setup.py b/ports/esp32/modules/webrepl_setup.py
deleted file mode 120000
index 999888bf13ae7..0000000000000
--- a/ports/esp32/modules/webrepl_setup.py
+++ /dev/null
@@ -1 +0,0 @@
-../../esp8266/modules/webrepl_setup.py
\ No newline at end of file
diff --git a/ports/esp32/modules/websocket_helper.py b/ports/esp32/modules/websocket_helper.py
deleted file mode 120000
index 4bcf3bcb6ab70..0000000000000
--- a/ports/esp32/modules/websocket_helper.py
+++ /dev/null
@@ -1 +0,0 @@
-../../esp8266/modules/websocket_helper.py
\ No newline at end of file
diff --git a/ports/esp32/moduos.c b/ports/esp32/moduos.c
index dc85136f3d717..50c0d7ea5c716 100644
--- a/ports/esp32/moduos.c
+++ b/ports/esp32/moduos.c
@@ -38,6 +38,7 @@
 #include "extmod/misc.h"
 #include "extmod/vfs.h"
 #include "extmod/vfs_fat.h"
+#include "extmod/vfs_lfs.h"
 #include "genhdr/mpversion.h"
 
 extern const mp_obj_type_t mp_fat_vfs_type;
@@ -61,7 +62,7 @@ STATIC MP_DEFINE_ATTRTUPLE(
     (mp_obj_t)&os_uname_info_release_obj,
     (mp_obj_t)&os_uname_info_version_obj,
     (mp_obj_t)&os_uname_info_machine_obj
-);
+    );
 
 STATIC mp_obj_t os_uname(void) {
     return (mp_obj_t)&os_uname_info_obj;
@@ -123,6 +124,12 @@ STATIC const mp_rom_map_elem_t os_module_globals_table[] = {
     #if MICROPY_VFS_FAT
     { MP_ROM_QSTR(MP_QSTR_VfsFat), MP_ROM_PTR(&mp_fat_vfs_type) },
     #endif
+    #if MICROPY_VFS_LFS1
+    { MP_ROM_QSTR(MP_QSTR_VfsLfs1), MP_ROM_PTR(&mp_type_vfs_lfs1) },
+    #endif
+    #if MICROPY_VFS_LFS2
+    { MP_ROM_QSTR(MP_QSTR_VfsLfs2), MP_ROM_PTR(&mp_type_vfs_lfs2) },
+    #endif
     #endif
 };
 
@@ -130,5 +137,5 @@ STATIC MP_DEFINE_CONST_DICT(os_module_globals, os_module_globals_table);
 
 const mp_obj_module_t uos_module = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&os_module_globals,
+    .globals = (mp_obj_dict_t *)&os_module_globals,
 };
diff --git a/ports/esp32/modutime.c b/ports/esp32/modutime.c
index 002854298b08a..0325bd469391d 100644
--- a/ports/esp32/modutime.c
+++ b/ports/esp32/modutime.c
@@ -66,12 +66,12 @@ STATIC mp_obj_t time_mktime(mp_obj_t tuple) {
 
     // localtime generates a tuple of len 8. CPython uses 9, so we accept both.
     if (len < 8 || len > 9) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "mktime needs a tuple of length 8 or 9 (%d given)", len));
+        mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("mktime needs a tuple of length 8 or 9 (%d given)"), len);
     }
 
     return mp_obj_new_int_from_uint(timeutils_mktime(mp_obj_get_int(elem[0]),
-            mp_obj_get_int(elem[1]), mp_obj_get_int(elem[2]), mp_obj_get_int(elem[3]),
-            mp_obj_get_int(elem[4]), mp_obj_get_int(elem[5])));
+        mp_obj_get_int(elem[1]), mp_obj_get_int(elem[2]), mp_obj_get_int(elem[3]),
+        mp_obj_get_int(elem[4]), mp_obj_get_int(elem[5])));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(time_mktime_obj, time_mktime);
 
@@ -102,5 +102,5 @@ STATIC MP_DEFINE_CONST_DICT(time_module_globals, time_module_globals_table);
 
 const mp_obj_module_t utime_module = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&time_module_globals,
+    .globals = (mp_obj_dict_t *)&time_module_globals,
 };
diff --git a/ports/esp32/mpconfigport.h b/ports/esp32/mpconfigport.h
index 7b9b40025035a..7c09bdbd9218c 100644
--- a/ports/esp32/mpconfigport.h
+++ b/ports/esp32/mpconfigport.h
@@ -1,9 +1,15 @@
 // Options to control how MicroPython is built for this port,
 // overriding defaults in py/mpconfig.h.
 
+// Board-specific definitions
+#include "mpconfigboard.h"
+
 #include <stdint.h>
 #include <alloca.h>
+
+#if !MICROPY_ESP_IDF_4
 #include "rom/ets_sys.h"
+#endif
 
 // object representation and NLR handling
 #define MICROPY_OBJ_REPR                    (MICROPY_OBJ_REPR_A)
@@ -14,6 +20,7 @@
 
 // emitters
 #define MICROPY_PERSISTENT_CODE_LOAD        (1)
+#define MICROPY_EMIT_XTENSAWIN              (1)
 
 // compiler configuration
 #define MICROPY_COMP_MODULE_CONST           (1)
@@ -52,7 +59,6 @@
 #define MICROPY_ENABLE_SCHEDULER            (1)
 #define MICROPY_SCHEDULER_DEPTH             (8)
 #define MICROPY_VFS                         (1)
-#define MICROPY_VFS_FAT                     (1)
 
 // control over Python builtins
 #define MICROPY_PY_FUNCTION_ATTRS           (1)
@@ -67,11 +73,11 @@
 #define MICROPY_PY_BUILTINS_SET             (1)
 #define MICROPY_PY_BUILTINS_SLICE           (1)
 #define MICROPY_PY_BUILTINS_SLICE_ATTRS     (1)
+#define MICROPY_PY_BUILTINS_SLICE_INDICES   (1)
 #define MICROPY_PY_BUILTINS_FROZENSET       (1)
 #define MICROPY_PY_BUILTINS_PROPERTY        (1)
 #define MICROPY_PY_BUILTINS_RANGE_ATTRS     (1)
 #define MICROPY_PY_BUILTINS_ROUND_INT       (1)
-#define MICROPY_PY_BUILTINS_TIMEOUTERROR    (1)
 #define MICROPY_PY_ALL_SPECIAL_METHODS      (1)
 #define MICROPY_PY_BUILTINS_COMPILE         (1)
 #define MICROPY_PY_BUILTINS_ENUMERATE       (1)
@@ -95,6 +101,7 @@
 #define MICROPY_PY_COLLECTIONS_ORDEREDDICT  (1)
 #define MICROPY_PY_MATH                     (1)
 #define MICROPY_PY_MATH_SPECIAL_FUNCTIONS   (1)
+#define MICROPY_PY_MATH_ISCLOSE             (1)
 #define MICROPY_PY_CMATH                    (1)
 #define MICROPY_PY_GC                       (1)
 #define MICROPY_PY_IO                       (1)
@@ -117,6 +124,7 @@
 #define MICROPY_PY_THREAD_GIL_VM_DIVISOR    (32)
 
 // extended modules
+#define MICROPY_PY_UASYNCIO                 (1)
 #define MICROPY_PY_UCTYPES                  (1)
 #define MICROPY_PY_UZLIB                    (1)
 #define MICROPY_PY_UJSON                    (1)
@@ -137,10 +145,12 @@
 #define MICROPY_PY_MACHINE_PIN_MAKE_NEW     mp_pin_make_new
 #define MICROPY_PY_MACHINE_PULSE            (1)
 #define MICROPY_PY_MACHINE_I2C              (1)
+#define MICROPY_PY_MACHINE_I2C_MAKE_NEW     machine_hw_i2c_make_new
 #define MICROPY_PY_MACHINE_SPI              (1)
 #define MICROPY_PY_MACHINE_SPI_MSB          (0)
 #define MICROPY_PY_MACHINE_SPI_LSB          (1)
 #define MICROPY_PY_MACHINE_SPI_MAKE_NEW     machine_hw_spi_make_new
+#define MICROPY_HW_ENABLE_SDCARD            (1)
 #define MICROPY_HW_SOFTSPI_MIN_DELAY        (0)
 #define MICROPY_HW_SOFTSPI_MAX_BAUDRATE     (ets_get_cpu_frequency() * 1000000 / 200) // roughly
 #define MICROPY_PY_USSL                     (1)
@@ -150,6 +160,8 @@
 #define MICROPY_PY_WEBREPL                  (1)
 #define MICROPY_PY_FRAMEBUF                 (1)
 #define MICROPY_PY_USOCKET_EVENTS           (MICROPY_PY_WEBREPL)
+#define MICROPY_PY_BLUETOOTH_RANDOM_ADDR    (1)
+#define MICROPY_PY_BLUETOOTH_DEFAULT_GAP_NAME ("ESP32")
 
 // fatfs configuration
 #define MICROPY_FATFS_ENABLE_LFN            (1)
@@ -190,38 +202,30 @@ extern const struct _mp_obj_module_t mp_module_onewire;
     { MP_OBJ_NEW_QSTR(MP_QSTR__onewire), (mp_obj_t)&mp_module_onewire }, \
     { MP_OBJ_NEW_QSTR(MP_QSTR_uhashlib), (mp_obj_t)&mp_module_uhashlib }, \
 
-#define MICROPY_PORT_BUILTIN_MODULE_WEAK_LINKS \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_binascii), (mp_obj_t)&mp_module_ubinascii }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_collections), (mp_obj_t)&mp_module_collections }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_errno), (mp_obj_t)&mp_module_uerrno }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_hashlib), (mp_obj_t)&mp_module_uhashlib }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_heapq), (mp_obj_t)&mp_module_uheapq }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_io), (mp_obj_t)&mp_module_io }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_json), (mp_obj_t)&mp_module_ujson }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_os), (mp_obj_t)&uos_module }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_random), (mp_obj_t)&mp_module_urandom }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_re), (mp_obj_t)&mp_module_ure }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_select), (mp_obj_t)&mp_module_uselect }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_socket), (mp_obj_t)&mp_module_usocket }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_ssl), (mp_obj_t)&mp_module_ussl }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_struct), (mp_obj_t)&mp_module_ustruct }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_time), (mp_obj_t)&utime_module }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_zlib), (mp_obj_t)&mp_module_uzlib }, \
-
 #define MP_STATE_PORT MP_STATE_VM
 
 struct _machine_timer_obj_t;
 
+#if MICROPY_BLUETOOTH_NIMBLE
+struct mp_bluetooth_nimble_root_pointers_t;
+#define MICROPY_PORT_ROOT_POINTER_BLUETOOTH_NIMBLE struct _mp_bluetooth_nimble_root_pointers_t *bluetooth_nimble_root_pointers;
+#else
+#define MICROPY_PORT_ROOT_POINTER_BLUETOOTH_NIMBLE
+#endif
+
 #define MICROPY_PORT_ROOT_POINTERS \
     const char *readline_hist[8]; \
     mp_obj_t machine_pin_irq_handler[40]; \
     struct _machine_timer_obj_t *machine_timer_obj_head; \
+    MICROPY_PORT_ROOT_POINTER_BLUETOOTH_NIMBLE
 
 // type definitions for the specific machine
 
 #define BYTES_PER_WORD (4)
-#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void*)((mp_uint_t)(p)))
+#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)((mp_uint_t)(p)))
 #define MP_PLAT_PRINT_STRN(str, len) mp_hal_stdout_tx_strn_cooked(str, len)
+void *esp_native_code_commit(void *, size_t, void *);
+#define MP_PLAT_COMMIT_EXEC(buf, len, reloc) esp_native_code_commit(buf, len, reloc)
 #define MP_SSIZE_MAX (0x7fffffff)
 
 // Note: these "critical nested" macros do not ensure cross-CPU exclusion,
@@ -240,8 +244,8 @@ struct _machine_timer_obj_t;
 #if MICROPY_PY_THREAD
 #define MICROPY_EVENT_POLL_HOOK \
     do { \
-        extern void mp_handle_pending(void); \
-        mp_handle_pending(); \
+        extern void mp_handle_pending(bool); \
+        mp_handle_pending(true); \
         MICROPY_PY_USOCKET_EVENTS_HANDLER \
         MP_THREAD_GIL_EXIT(); \
         MP_THREAD_GIL_ENTER(); \
@@ -249,13 +253,16 @@ struct _machine_timer_obj_t;
 #else
 #define MICROPY_EVENT_POLL_HOOK \
     do { \
-        extern void mp_handle_pending(void); \
-        mp_handle_pending(); \
+        extern void mp_handle_pending(bool); \
+        mp_handle_pending(true); \
         MICROPY_PY_USOCKET_EVENTS_HANDLER \
-        asm("waiti 0"); \
+        asm ("waiti 0"); \
     } while (0);
 #endif
 
+// Functions that should go in IRAM
+#define MICROPY_WRAP_MP_KEYBOARD_INTERRUPT(f) IRAM_ATTR f
+
 #define UINT_FMT "%u"
 #define INT_FMT "%d"
 
@@ -266,7 +273,12 @@ typedef long mp_off_t;
 #include <sys/types.h>
 
 // board specifics
-
-#define MICROPY_HW_BOARD_NAME "ESP32 module"
-#define MICROPY_HW_MCU_NAME "ESP32"
 #define MICROPY_PY_SYS_PLATFORM "esp32"
+
+#ifndef MICROPY_HW_ENABLE_MDNS_QUERIES
+#define MICROPY_HW_ENABLE_MDNS_QUERIES      (1)
+#endif
+
+#ifndef MICROPY_HW_ENABLE_MDNS_RESPONDER
+#define MICROPY_HW_ENABLE_MDNS_RESPONDER    (1)
+#endif
diff --git a/ports/esp32/mphalport.c b/ports/esp32/mphalport.c
index 804c719869ef8..99548ad627be5 100644
--- a/ports/esp32/mphalport.c
+++ b/ports/esp32/mphalport.c
@@ -31,9 +31,16 @@
 
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
+
+#if MICROPY_ESP_IDF_4
+#include "esp32/rom/uart.h"
+#else
 #include "rom/uart.h"
+#endif
 
 #include "py/obj.h"
+#include "py/objstr.h"
+#include "py/stream.h"
 #include "py/mpstate.h"
 #include "py/mphal.h"
 #include "extmod/misc.h"
@@ -45,6 +52,46 @@ TaskHandle_t mp_main_task_handle;
 STATIC uint8_t stdin_ringbuf_array[256];
 ringbuf_t stdin_ringbuf = {stdin_ringbuf_array, sizeof(stdin_ringbuf_array)};
 
+// Check the ESP-IDF error code and raise an OSError if it's not ESP_OK.
+void check_esp_err(esp_err_t code) {
+    if (code != ESP_OK) {
+        // map esp-idf error code to posix error code
+        uint32_t pcode = -code;
+        switch (code) {
+            case ESP_ERR_NO_MEM:
+                pcode = MP_ENOMEM;
+                break;
+            case ESP_ERR_TIMEOUT:
+                pcode = MP_ETIMEDOUT;
+                break;
+            case ESP_ERR_NOT_SUPPORTED:
+                pcode = MP_EOPNOTSUPP;
+                break;
+        }
+        // construct string object
+        mp_obj_str_t *o_str = m_new_obj_maybe(mp_obj_str_t);
+        if (o_str == NULL) {
+            mp_raise_OSError(pcode);
+            return;
+        }
+        o_str->base.type = &mp_type_str;
+        o_str->data = (const byte *)esp_err_to_name(code); // esp_err_to_name ret's ptr to const str
+        o_str->len = strlen((char *)o_str->data);
+        o_str->hash = qstr_compute_hash(o_str->data, o_str->len);
+        // raise
+        mp_obj_t args[2] = { MP_OBJ_NEW_SMALL_INT(pcode), MP_OBJ_FROM_PTR(o_str)};
+        nlr_raise(mp_obj_exception_make_new(&mp_type_OSError, 2, 0, args));
+    }
+}
+
+uintptr_t mp_hal_stdio_poll(uintptr_t poll_flags) {
+    uintptr_t ret = 0;
+    if ((poll_flags & MP_STREAM_POLL_RD) && stdin_ringbuf.iget != stdin_ringbuf.iput) {
+        ret |= MP_STREAM_POLL_RD;
+    }
+    return ret;
+}
+
 int mp_hal_stdin_rx_chr(void) {
     for (;;) {
         int c = ringbuf_get(&stdin_ringbuf);
@@ -143,18 +190,11 @@ void mp_hal_delay_us(uint32_t us) {
         if (dt + pend_overhead < us) {
             // we have enough time to service pending events
             // (don't use MICROPY_EVENT_POLL_HOOK because it also yields)
-            mp_handle_pending();
+            mp_handle_pending(true);
         }
     }
 }
 
-/*
-extern int mp_stream_errno;
-int *__errno() {
-    return &mp_stream_errno;
-}
-*/
-
 // Wake up the main task if it is sleeping
 void mp_hal_wake_main_task_from_isr(void) {
     BaseType_t xHigherPriorityTaskWoken = pdFALSE;
diff --git a/ports/esp32/mphalport.h b/ports/esp32/mphalport.h
index ff39b7aa1cbcc..1f78d820a3f17 100644
--- a/ports/esp32/mphalport.h
+++ b/ports/esp32/mphalport.h
@@ -35,15 +35,21 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 
+// The core that the MicroPython task(s) are pinned to
+#define MP_TASK_COREID (1)
+
 extern TaskHandle_t mp_main_task_handle;
 
 extern ringbuf_t stdin_ringbuf;
 
+// Check the ESP-IDF error code and raise an OSError if it's not ESP_OK.
+void check_esp_err(esp_err_t code);
+
 uint32_t mp_hal_ticks_us(void);
 __attribute__((always_inline)) static inline uint32_t mp_hal_ticks_cpu(void) {
-  uint32_t ccount;
-  __asm__ __volatile__("rsr %0,ccount":"=a" (ccount));
-  return ccount;
+    uint32_t ccount;
+    __asm__ __volatile__ ("rsr %0,ccount" : "=a" (ccount));
+    return ccount;
 }
 
 void mp_hal_delay_us(uint32_t);
diff --git a/ports/esp32/mpthreadport.c b/ports/esp32/mpthreadport.c
index 6c4ed9b5e357d..f39c99b68d41a 100644
--- a/ports/esp32/mpthreadport.c
+++ b/ports/esp32/mpthreadport.c
@@ -27,13 +27,16 @@
 
 #include "stdio.h"
 
-#include "py/mpconfig.h"
-#include "py/mpstate.h"
+#include "py/runtime.h"
 #include "py/gc.h"
 #include "py/mpthread.h"
+#include "py/mphal.h"
 #include "mpthreadport.h"
 
 #include "esp_task.h"
+#if !MICROPY_ESP_IDF_4
+#include "freertos/semphr.h"
+#endif
 
 #if MICROPY_PY_THREAD
 
@@ -72,7 +75,7 @@ void mp_thread_init(void *stack, uint32_t stack_len) {
 void mp_thread_gc_others(void) {
     mp_thread_mutex_lock(&thread_mutex, 1);
     for (thread_t *th = thread; th != NULL; th = th->next) {
-        gc_collect_root((void**)&th, 1);
+        gc_collect_root((void **)&th, 1);
         gc_collect_root(&th->arg, 1); // probably not needed
         if (th->id == xTaskGetCurrentTaskHandle()) {
             continue;
@@ -89,7 +92,7 @@ mp_state_thread_t *mp_thread_get_state(void) {
     return pvTaskGetThreadLocalStoragePointer(NULL, 1);
 }
 
-void mp_thread_set_state(void *state) {
+void mp_thread_set_state(mp_state_thread_t *state) {
     vTaskSetThreadLocalStoragePointer(NULL, 1, state);
 }
 
@@ -104,17 +107,18 @@ void mp_thread_start(void) {
     mp_thread_mutex_unlock(&thread_mutex);
 }
 
-STATIC void *(*ext_thread_entry)(void*) = NULL;
+STATIC void *(*ext_thread_entry)(void *) = NULL;
 
 STATIC void freertos_entry(void *arg) {
     if (ext_thread_entry) {
         ext_thread_entry(arg);
     }
     vTaskDelete(NULL);
-    for (;;);
+    for (;;) {;
+    }
 }
 
-void mp_thread_create_ex(void *(*entry)(void*), void *arg, size_t *stack_size, int priority, char *name) {
+void mp_thread_create_ex(void *(*entry)(void *), void *arg, size_t *stack_size, int priority, char *name) {
     // store thread entry function into a global variable so we can access it
     ext_thread_entry = entry;
 
@@ -130,10 +134,10 @@ void mp_thread_create_ex(void *(*entry)(void*), void *arg, size_t *stack_size, i
     mp_thread_mutex_lock(&thread_mutex, 1);
 
     // create thread
-    BaseType_t result = xTaskCreate(freertos_entry, name, *stack_size / sizeof(StackType_t), arg, priority, &th->id);
+    BaseType_t result = xTaskCreatePinnedToCore(freertos_entry, name, *stack_size / sizeof(StackType_t), arg, priority, &th->id, MP_TASK_COREID);
     if (result != pdPASS) {
         mp_thread_mutex_unlock(&thread_mutex);
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "can't create thread"));
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't create thread"));
     }
 
     // adjust the stack_size to provide room to recover from hitting the limit
@@ -150,7 +154,7 @@ void mp_thread_create_ex(void *(*entry)(void*), void *arg, size_t *stack_size, i
     mp_thread_mutex_unlock(&thread_mutex);
 }
 
-void mp_thread_create(void *(*entry)(void*), void *arg, size_t *stack_size) {
+void mp_thread_create(void *(*entry)(void *), void *arg, size_t *stack_size) {
     mp_thread_create_ex(entry, arg, stack_size, MP_THREAD_PRIORITY, "mp_thread");
 }
 
@@ -174,7 +178,7 @@ void vPortCleanUpTCB(void *tcb) {
     mp_thread_mutex_lock(&thread_mutex, 1);
     for (thread_t *th = thread; th != NULL; prev = th, th = th->next) {
         // unlink the node from the list
-        if ((void*)th->id == tcb) {
+        if ((void *)th->id == tcb) {
             if (prev != NULL) {
                 prev->next = th->next;
             } else {
@@ -194,7 +198,7 @@ void mp_thread_mutex_init(mp_thread_mutex_t *mutex) {
 }
 
 int mp_thread_mutex_lock(mp_thread_mutex_t *mutex, int wait) {
-    return (pdTRUE == xSemaphoreTake(mutex->handle, wait ? portMAX_DELAY : 0));
+    return pdTRUE == xSemaphoreTake(mutex->handle, wait ? portMAX_DELAY : 0);
 }
 
 void mp_thread_mutex_unlock(mp_thread_mutex_t *mutex) {
diff --git a/ports/esp32/network_lan.c b/ports/esp32/network_lan.c
index 10f17ebcf81b1..1f9a733a7aef1 100644
--- a/ports/esp32/network_lan.c
+++ b/ports/esp32/network_lan.c
@@ -26,6 +26,7 @@
  * THE SOFTWARE.
  */
 
+#if !MICROPY_ESP_IDF_4
 #include "py/runtime.h"
 #include "py/mphal.h"
 
@@ -54,7 +55,7 @@ const mp_obj_type_t lan_if_type;
 STATIC lan_if_obj_t lan_obj = {{&lan_if_type}, ESP_IF_ETH, false, false};
 
 STATIC void phy_power_enable(bool enable) {
-    lan_if_obj_t* self = &lan_obj;
+    lan_if_obj_t *self = &lan_obj;
 
     if (self->phy_power_pin != -1) {
 
@@ -82,13 +83,13 @@ STATIC void phy_power_enable(bool enable) {
 }
 
 STATIC void init_lan_rmii() {
-    lan_if_obj_t* self = &lan_obj;
+    lan_if_obj_t *self = &lan_obj;
     phy_rmii_configure_data_interface_pins();
     phy_rmii_smi_configure_pins(self->mdc_pin, self->mdio_pin);
 }
 
 STATIC mp_obj_t get_lan(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    lan_if_obj_t* self = &lan_obj;
+    lan_if_obj_t *self = &lan_obj;
 
     if (self->initialized) {
         return MP_OBJ_FROM_PTR(&lan_obj);
@@ -110,7 +111,7 @@ STATIC mp_obj_t get_lan(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_ar
 
     if (args[ARG_id].u_obj != mp_const_none) {
         if (mp_obj_get_int(args[ARG_id].u_obj) != 0) {
-            mp_raise_ValueError("invalid LAN interface identifier");
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid LAN interface identifier"));
         }
     }
 
@@ -119,20 +120,20 @@ STATIC mp_obj_t get_lan(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_ar
     self->phy_power_pin = args[ARG_power].u_obj == mp_const_none ? -1 : machine_pin_get_id(args[ARG_power].u_obj);
 
     if (args[ARG_phy_addr].u_int < 0x00 || args[ARG_phy_addr].u_int > 0x1f) {
-        mp_raise_ValueError("invalid phy address");
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid phy address"));
     }
 
     if (args[ARG_phy_type].u_int != PHY_LAN8720 && args[ARG_phy_type].u_int != PHY_TLK110) {
-        mp_raise_ValueError("invalid phy type");
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid phy type"));
     }
 
     if (args[ARG_clock_mode].u_int != -1 &&
         args[ARG_clock_mode].u_int != ETH_CLOCK_GPIO0_IN &&
         // Disabled due ESP-IDF (see modnetwork.c note)
-        //args[ARG_clock_mode].u_int != ETH_CLOCK_GPIO0_OUT &&
+        // args[ARG_clock_mode].u_int != ETH_CLOCK_GPIO0_OUT &&
         args[ARG_clock_mode].u_int != ETH_CLOCK_GPIO16_OUT &&
         args[ARG_clock_mode].u_int != ETH_CLOCK_GPIO17_OUT) {
-        mp_raise_ValueError("invalid clock mode");
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid clock mode"));
     }
 
     eth_config_t config;
@@ -164,7 +165,7 @@ STATIC mp_obj_t get_lan(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_ar
         self->active = false;
         self->initialized = true;
     } else {
-        mp_raise_msg(&mp_type_OSError, "esp_eth_init() failed");
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("esp_eth_init() failed"));
     }
     return MP_OBJ_FROM_PTR(&lan_obj);
 }
@@ -177,12 +178,12 @@ STATIC mp_obj_t lan_active(size_t n_args, const mp_obj_t *args) {
         if (mp_obj_is_true(args[1])) {
             self->active = (esp_eth_enable() == ESP_OK);
             if (!self->active) {
-                mp_raise_msg(&mp_type_OSError, "ethernet enable failed");
+                mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("ethernet enable failed"));
             }
         } else {
             self->active = !(esp_eth_disable() == ESP_OK);
             if (self->active) {
-                mp_raise_msg(&mp_type_OSError, "ethernet disable failed");
+                mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("ethernet disable failed"));
             }
         }
     }
@@ -205,6 +206,7 @@ STATIC const mp_rom_map_elem_t lan_if_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_active), MP_ROM_PTR(&lan_active_obj) },
     { MP_ROM_QSTR(MP_QSTR_isconnected), MP_ROM_PTR(&lan_isconnected_obj) },
     { MP_ROM_QSTR(MP_QSTR_status), MP_ROM_PTR(&lan_status_obj) },
+    { MP_ROM_QSTR(MP_QSTR_config), MP_ROM_PTR(&esp_config_obj) },
     { MP_ROM_QSTR(MP_QSTR_ifconfig), MP_ROM_PTR(&esp_ifconfig_obj) },
 };
 
@@ -213,5 +215,7 @@ STATIC MP_DEFINE_CONST_DICT(lan_if_locals_dict, lan_if_locals_dict_table);
 const mp_obj_type_t lan_if_type = {
     { &mp_type_type },
     .name = MP_QSTR_LAN,
-    .locals_dict = (mp_obj_dict_t*)&lan_if_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&lan_if_locals_dict,
 };
+
+#endif // !MICROPY_ESP_IDF_4
diff --git a/ports/esp32/network_ppp.c b/ports/esp32/network_ppp.c
index da821478b8823..c3046c9fc77b9 100644
--- a/ports/esp32/network_ppp.c
+++ b/ports/esp32/network_ppp.c
@@ -26,6 +26,7 @@
  * THE SOFTWARE.
  */
 
+#if !MICROPY_ESP_IDF_4
 #include "py/runtime.h"
 #include "py/mphal.h"
 #include "py/objtype.h"
@@ -42,21 +43,24 @@
 #include "lwip/dns.h"
 #include "netif/ppp/pppapi.h"
 
+#define PPP_CLOSE_TIMEOUT_MS (4000)
+
 typedef struct _ppp_if_obj_t {
     mp_obj_base_t base;
     bool active;
     bool connected;
+    volatile bool clean_close;
     ppp_pcb *pcb;
     mp_obj_t stream;
     SemaphoreHandle_t inactiveWaitSem;
-    TaskHandle_t client_task_handle;
+    volatile TaskHandle_t client_task_handle;
     struct netif pppif;
 } ppp_if_obj_t;
 
 const mp_obj_type_t ppp_if_type;
 
 static void ppp_status_cb(ppp_pcb *pcb, int err_code, void *ctx) {
-    ppp_if_obj_t* self = ctx;
+    ppp_if_obj_t *self = ctx;
     struct netif *pppif = ppp_netif(self->pcb);
 
     switch (err_code) {
@@ -64,7 +68,7 @@ static void ppp_status_cb(ppp_pcb *pcb, int err_code, void *ctx) {
             self->connected = (pppif->ip_addr.u_addr.ip4.addr != 0);
             break;
         case PPPERR_USER:
-            xSemaphoreGive(self->inactiveWaitSem);
+            self->clean_close = true;
             break;
         case PPPERR_CONNECT:
             self->connected = false;
@@ -83,10 +87,9 @@ STATIC mp_obj_t ppp_make_new(mp_obj_t stream) {
     self->stream = stream;
     self->active = false;
     self->connected = false;
-    self->inactiveWaitSem = xSemaphoreCreateBinary();
+    self->clean_close = false;
     self->client_task_handle = NULL;
 
-    assert(self->inactiveWaitSem != NULL);
     return MP_OBJ_FROM_PTR(self);
 }
 MP_DEFINE_CONST_FUN_OBJ_1(ppp_make_new_obj, ppp_make_new);
@@ -98,16 +101,18 @@ static u32_t ppp_output_callback(ppp_pcb *pcb, u8_t *data, u32_t len, void *ctx)
 }
 
 static void pppos_client_task(void *self_in) {
-    ppp_if_obj_t *self = (ppp_if_obj_t*)self_in;
+    ppp_if_obj_t *self = (ppp_if_obj_t *)self_in;
     uint8_t buf[256];
 
     while (ulTaskNotifyTake(pdTRUE, 0) == 0) {
         int err;
         int len = mp_stream_rw(self->stream, buf, sizeof(buf), &err, 0);
         if (len > 0) {
-            pppos_input_tcpip(self->pcb, (u8_t*)buf, len);
+            pppos_input_tcpip(self->pcb, (u8_t *)buf, len);
         }
     }
+
+    self->client_task_handle = NULL;
     vTaskDelete(NULL);
 }
 
@@ -123,27 +128,28 @@ STATIC mp_obj_t ppp_active(size_t n_args, const mp_obj_t *args) {
             self->pcb = pppapi_pppos_create(&self->pppif, ppp_output_callback, ppp_status_cb, self);
 
             if (self->pcb == NULL) {
-                mp_raise_msg(&mp_type_RuntimeError, "init failed");
+                mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("init failed"));
             }
-            pppapi_set_default(self->pcb);
-            pppapi_connect(self->pcb, 0);
-
-            xTaskCreate(pppos_client_task, "ppp", 2048, self, 1, &self->client_task_handle);
             self->active = true;
         } else {
             if (!self->active) {
                 return mp_const_false;
             }
 
-            // Wait for PPPERR_USER
-            pppapi_close(self->pcb, 0);
-            xSemaphoreTake(self->inactiveWaitSem, portMAX_DELAY);
-            xSemaphoreGive(self->inactiveWaitSem);
+            if (self->client_task_handle != NULL) { // is connecting or connected?
+                // Wait for PPPERR_USER, with timeout
+                pppapi_close(self->pcb, 0);
+                uint32_t t0 = mp_hal_ticks_ms();
+                while (!self->clean_close && mp_hal_ticks_ms() - t0 < PPP_CLOSE_TIMEOUT_MS) {
+                    mp_hal_delay_ms(10);
+                }
 
-            // Shutdown task
-            xTaskNotifyGive(self->client_task_handle);
-            while (eTaskGetState(self->client_task_handle) != eDeleted) {
-                mp_hal_delay_ms(10);
+                // Shutdown task
+                xTaskNotifyGive(self->client_task_handle);
+                t0 = mp_hal_ticks_ms();
+                while (self->client_task_handle != NULL && mp_hal_ticks_ms() - t0 < PPP_CLOSE_TIMEOUT_MS) {
+                    mp_hal_delay_ms(10);
+                }
             }
 
             // Release PPP
@@ -151,14 +157,68 @@ STATIC mp_obj_t ppp_active(size_t n_args, const mp_obj_t *args) {
             self->pcb = NULL;
             self->active = false;
             self->connected = false;
+            self->clean_close = false;
         }
     }
     return mp_obj_new_bool(self->active);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(ppp_active_obj, 1, 2, ppp_active);
 
+STATIC mp_obj_t ppp_connect_py(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    enum { ARG_authmode, ARG_username, ARG_password };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_authmode, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = PPPAUTHTYPE_NONE} },
+        { MP_QSTR_username, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_password, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+    };
+
+    mp_arg_val_t parsed_args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, parsed_args);
+
+    ppp_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+
+    if (!self->active) {
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("must be active"));
+    }
+
+    if (self->client_task_handle != NULL) {
+        mp_raise_OSError(MP_EALREADY);
+    }
+
+    switch (parsed_args[ARG_authmode].u_int) {
+        case PPPAUTHTYPE_NONE:
+        case PPPAUTHTYPE_PAP:
+        case PPPAUTHTYPE_CHAP:
+            break;
+        default:
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid auth"));
+    }
+
+    if (parsed_args[ARG_authmode].u_int != PPPAUTHTYPE_NONE) {
+        const char *username_str = mp_obj_str_get_str(parsed_args[ARG_username].u_obj);
+        const char *password_str = mp_obj_str_get_str(parsed_args[ARG_password].u_obj);
+        pppapi_set_auth(self->pcb, parsed_args[ARG_authmode].u_int, username_str, password_str);
+    }
+    if (pppapi_set_default(self->pcb) != ESP_OK) {
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("set default failed"));
+    }
+
+    ppp_set_usepeerdns(self->pcb, true);
+
+    if (pppapi_connect(self->pcb, 0) != ESP_OK) {
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("connect failed"));
+    }
+
+    if (xTaskCreatePinnedToCore(pppos_client_task, "ppp", 2048, self, 1, (TaskHandle_t *)&self->client_task_handle, MP_TASK_COREID) != pdPASS) {
+        mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("failed to create worker task"));
+    }
+
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(ppp_connect_obj, 1, ppp_connect_py);
+
 STATIC mp_obj_t ppp_delete(mp_obj_t self_in) {
-    ppp_if_obj_t* self = MP_OBJ_TO_PTR(self_in);
+    ppp_if_obj_t *self = MP_OBJ_TO_PTR(self_in);
     mp_obj_t args[] = {self, mp_const_false};
     ppp_active(2, args);
     return mp_const_none;
@@ -167,17 +227,17 @@ MP_DEFINE_CONST_FUN_OBJ_1(ppp_delete_obj, ppp_delete);
 
 STATIC mp_obj_t ppp_ifconfig(size_t n_args, const mp_obj_t *args) {
     ppp_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
-    ip_addr_t dns;
     if (n_args == 1) {
         // get
+        const ip_addr_t *dns;
         if (self->pcb != NULL) {
             dns = dns_getserver(0);
             struct netif *pppif = ppp_netif(self->pcb);
             mp_obj_t tuple[4] = {
-                netutils_format_ipv4_addr((uint8_t*)&pppif->ip_addr, NETUTILS_BIG),
-                netutils_format_ipv4_addr((uint8_t*)&pppif->gw, NETUTILS_BIG),
-                netutils_format_ipv4_addr((uint8_t*)&pppif->netmask, NETUTILS_BIG),
-                netutils_format_ipv4_addr((uint8_t*)&dns, NETUTILS_BIG),
+                netutils_format_ipv4_addr((uint8_t *)&pppif->ip_addr, NETUTILS_BIG),
+                netutils_format_ipv4_addr((uint8_t *)&pppif->gw, NETUTILS_BIG),
+                netutils_format_ipv4_addr((uint8_t *)&pppif->netmask, NETUTILS_BIG),
+                netutils_format_ipv4_addr((uint8_t *)dns, NETUTILS_BIG),
             };
             return mp_obj_new_tuple(4, tuple);
         } else {
@@ -185,9 +245,10 @@ STATIC mp_obj_t ppp_ifconfig(size_t n_args, const mp_obj_t *args) {
             return mp_obj_new_tuple(4, tuple);
         }
     } else {
+        ip_addr_t dns;
         mp_obj_t *items;
         mp_obj_get_array_fixed_n(args[1], 4, &items);
-        netutils_parse_ipv4_addr(items[3], (uint8_t*)&dns.u_addr.ip4, NETUTILS_BIG);
+        netutils_parse_ipv4_addr(items[3], (uint8_t *)&dns.u_addr.ip4, NETUTILS_BIG);
         dns_setserver(0, &dns);
         return mp_const_none;
     }
@@ -207,15 +268,21 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(ppp_isconnected_obj, ppp_isconnected);
 
 STATIC const mp_rom_map_elem_t ppp_if_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_active), MP_ROM_PTR(&ppp_active_obj) },
+    { MP_ROM_QSTR(MP_QSTR_connect), MP_ROM_PTR(&ppp_connect_obj) },
     { MP_ROM_QSTR(MP_QSTR_isconnected), MP_ROM_PTR(&ppp_isconnected_obj) },
     { MP_ROM_QSTR(MP_QSTR_status), MP_ROM_PTR(&ppp_status_obj) },
     { MP_ROM_QSTR(MP_QSTR_ifconfig), MP_ROM_PTR(&ppp_ifconfig_obj) },
     { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&ppp_delete_obj) },
+    { MP_ROM_QSTR(MP_QSTR_AUTH_NONE), MP_ROM_INT(PPPAUTHTYPE_NONE) },
+    { MP_ROM_QSTR(MP_QSTR_AUTH_PAP), MP_ROM_INT(PPPAUTHTYPE_PAP) },
+    { MP_ROM_QSTR(MP_QSTR_AUTH_CHAP), MP_ROM_INT(PPPAUTHTYPE_CHAP) },
 };
 STATIC MP_DEFINE_CONST_DICT(ppp_if_locals_dict, ppp_if_locals_dict_table);
 
 const mp_obj_type_t ppp_if_type = {
     { &mp_type_type },
     .name = MP_QSTR_PPP,
-    .locals_dict = (mp_obj_dict_t*)&ppp_if_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&ppp_if_locals_dict,
 };
+
+#endif // !MICROPY_ESP_IDF_4
diff --git a/ports/esp32/nimble.c b/ports/esp32/nimble.c
new file mode 100644
index 0000000000000..e60e08badfbe1
--- /dev/null
+++ b/ports/esp32/nimble.c
@@ -0,0 +1,57 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Jim Mussared
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+#include "py/mphal.h"
+
+#if MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_NIMBLE
+
+#include "esp_nimble_hci.h"
+#include "nimble/nimble_port.h"
+#include "nimble/nimble_port_freertos.h"
+
+STATIC void ble_host_task(void *param) {
+    nimble_port_run(); // This function will return only when nimble_port_stop() is executed.
+    nimble_port_freertos_deinit();
+}
+
+void mp_bluetooth_nimble_port_preinit(void) {
+    esp_nimble_hci_and_controller_init();
+}
+
+void mp_bluetooth_nimble_port_postinit(void) {
+    nimble_port_freertos_init(ble_host_task);
+}
+
+void mp_bluetooth_nimble_port_deinit(void) {
+    nimble_port_stop();
+}
+
+void mp_bluetooth_nimble_port_start(void) {
+}
+
+#endif
diff --git a/ports/esp32/partitions-2MiB.csv b/ports/esp32/partitions-2MiB.csv
new file mode 100644
index 0000000000000..2d3d4c120446c
--- /dev/null
+++ b/ports/esp32/partitions-2MiB.csv
@@ -0,0 +1,8 @@
+# Notes: the offset of the partition table itself is set in
+# $ESPIDF/components/partition_table/Kconfig.projbuild and the
+# offset of the factory/ota_0 partition is set in makeimg.py
+# Name,     Type, SubType, Offset,   Size, Flags
+nvs,        data, nvs,     0x9000,   0x6000,
+phy_init,   data, phy,     0xf000,   0x1000,
+factory,    app,  factory, 0x10000,  0x110000,
+vfs,        data, fat,     0x120000, 0xA0000,
diff --git a/ports/esp32/partitions-ota.csv b/ports/esp32/partitions-ota.csv
new file mode 100644
index 0000000000000..08576b6a36af2
--- /dev/null
+++ b/ports/esp32/partitions-ota.csv
@@ -0,0 +1,11 @@
+# Partition table for MicroPython with OTA support using 4MB flash
+# Notes: the offset of the partition table itself is set in
+# $ESPIDF/components/partition_table/Kconfig.projbuild and the
+# offset of the factory/ota_0 partition is set in makeimg.py
+# Name,   Type, SubType, Offset,   Size,     Flags
+nvs,      data, nvs,     0x9000,   0x4000,
+otadata,  data, ota,     0xd000,   0x2000,
+phy_init, data, phy,     0xf000,   0x1000,
+ota_0,    app,  ota_0,   0x10000,  0x180000,
+ota_1,    app,  ota_1,   0x190000, 0x180000,
+vfs,      data, fat,     0x310000, 0x0f0000,
diff --git a/ports/esp32/partitions.csv b/ports/esp32/partitions.csv
index 98adcd20a7037..68ab4b356a91e 100644
--- a/ports/esp32/partitions.csv
+++ b/ports/esp32/partitions.csv
@@ -1,5 +1,8 @@
+# Notes: the offset of the partition table itself is set in
+# $ESPIDF/components/partition_table/Kconfig.projbuild and the
+# offset of the factory/ota_0 partition is set in makeimg.py
 # Name,   Type, SubType, Offset,  Size, Flags
-# Note: if you change the phy_init or app partition offset, make sure to change the offset in Kconfig.projbuild
 nvs,      data, nvs,     0x9000,  0x6000,
 phy_init, data, phy,     0xf000,  0x1000,
 factory,  app,  factory, 0x10000, 0x180000,
+vfs,      data, fat,     0x200000, 0x200000,
diff --git a/ports/esp32/qstrdefsport.h b/ports/esp32/qstrdefsport.h
index ff6c2cc426b8b..47e22388bc109 100644
--- a/ports/esp32/qstrdefsport.h
+++ b/ports/esp32/qstrdefsport.h
@@ -25,6 +25,7 @@
  */
 
 // qstrs specific to this port, only needed if they aren't auto-generated
+// *FORMAT-OFF*
 
 // Entries for sys.path
 Q(/lib)
diff --git a/ports/esp32/uart.c b/ports/esp32/uart.c
index 10a4ba462e08f..381be7f4f016c 100644
--- a/ports/esp32/uart.c
+++ b/ports/esp32/uart.c
@@ -30,7 +30,7 @@
 
 #include "driver/uart.h"
 
-#include "py/mpstate.h"
+#include "py/runtime.h"
 #include "py/mphal.h"
 
 STATIC void uart_irq_handler(void *arg);
@@ -50,13 +50,7 @@ STATIC void IRAM_ATTR uart_irq_handler(void *arg) {
     while (uart->status.rxfifo_cnt) {
         uint8_t c = uart->fifo.rw_byte;
         if (c == mp_interrupt_char) {
-            // inline version of mp_keyboard_interrupt();
-            MP_STATE_VM(mp_pending_exception) = MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_kbd_exception));
-            #if MICROPY_ENABLE_SCHEDULER
-            if (MP_STATE_VM(sched_state) == MP_SCHED_IDLE) {
-                MP_STATE_VM(sched_state) = MP_SCHED_PENDING;
-            }
-            #endif
+            mp_keyboard_interrupt();
         } else {
             // this is an inline function so will be in IRAM
             ringbuf_put(&stdin_ringbuf, c);
diff --git a/ports/esp8266/Makefile b/ports/esp8266/Makefile
index 2162c72f075d7..38b91a545dea3 100644
--- a/ports/esp8266/Makefile
+++ b/ports/esp8266/Makefile
@@ -1,27 +1,46 @@
+# Select the board to build for: if not given on the command line,
+# then default to GENERIC.
+BOARD ?= GENERIC
+
+# If the build directory is not given, make it reflect the board name.
+BUILD ?= build-$(BOARD)
+
+BOARD_DIR ?= boards/$(BOARD)
+ifeq ($(wildcard $(BOARD_DIR)/.),)
+$(error Invalid BOARD specified: $(BOARD_DIR))
+endif
+
 include ../../py/mkenv.mk
 
+# Optional
+-include $(BOARD_DIR)/mpconfigboard.mk
+
 # qstr definitions (must come before including py.mk)
 QSTR_DEFS = qstrdefsport.h #$(BUILD)/pins_qstr.h
+QSTR_GLOBAL_DEPENDENCIES = $(BOARD_DIR)/mpconfigboard.h
 
+# MicroPython feature configurations
+MICROPY_ROM_TEXT_COMPRESSION ?= 1
 MICROPY_PY_USSL = 1
 MICROPY_SSL_AXTLS = 1
 AXTLS_DEFS_EXTRA = -Dabort=abort_ -DRT_MAX_PLAIN_LENGTH=1024 -DRT_EXTRA=4096
-MICROPY_FATFS = 1
-MICROPY_PY_BTREE = 1
 BTREE_DEFS_EXTRA = -DDEFPSIZE=1024 -DMINCACHE=3
 
-FROZEN_DIR ?= scripts
-FROZEN_MPY_DIR ?= modules
+FROZEN_MANIFEST ?= boards/manifest.py
+FROZEN_DIR ?=
+FROZEN_MPY_DIR ?=
 
 # include py core make definitions
 include $(TOP)/py/py.mk
 
+GIT_SUBMODULES = lib/axtls lib/berkeley-db-1.xx
+
 FWBIN = $(BUILD)/firmware-combined.bin
 PORT ?= /dev/ttyACM0
 BAUD ?= 115200
 FLASH_MODE ?= qio
 FLASH_SIZE ?= detect
-CROSS_COMPILE = xtensa-lx106-elf-
+CROSS_COMPILE ?= xtensa-lx106-elf-
 ESP_SDK = $(shell $(CC) -print-sysroot)/usr
 
 INC += -I.
@@ -40,10 +59,10 @@ CFLAGS_XTENSA = -fsingle-precision-constant -Wdouble-promotion \
 	-DLWIP_OPEN_SRC
 
 CFLAGS = $(INC) -Wall -Wpointer-arith -Werror -std=gnu99 -nostdlib -DUART_OS=$(UART_OS) \
-	$(CFLAGS_XTENSA) $(CFLAGS_MOD) $(COPT) $(CFLAGS_EXTRA)
+	$(CFLAGS_XTENSA) $(CFLAGS_MOD) $(COPT) $(CFLAGS_EXTRA) -I$(BOARD_DIR)
 
-LDSCRIPT = esp8266.ld
-LDFLAGS = -nostdlib -T $(LDSCRIPT) -Map=$(@:.elf=.map) --cref
+LD_FILES ?= boards/esp8266_2m.ld
+LDFLAGS = -nostdlib -T $(LD_FILES) -Map=$(@:.elf=.map) --cref
 LIBS = -L$(ESP_SDK)/lib -lmain -ljson -llwip_open -lpp -lnet80211 -lwpa -lphy -lnet80211 $(LDFLAGS_MOD)
 
 LIBGCC_FILE_NAME = $(shell $(CC) $(CFLAGS) -print-libgcc-file-name)
@@ -74,7 +93,6 @@ SRC_C = \
 	esppwm.c \
 	espneopixel.c \
 	espapa102.c \
-	intr.c \
 	modpyb.c \
 	modmachine.c \
 	machine_pin.c \
@@ -92,6 +110,7 @@ SRC_C = \
 	fatfs_port.c \
 	posix_helpers.c \
 	hspi.c \
+	$(wildcard $(BOARD_DIR)/*.c) \
 	$(SRC_MOD)
 
 EXTMOD_SRC_C = $(addprefix extmod/,\
@@ -100,6 +119,7 @@ EXTMOD_SRC_C = $(addprefix extmod/,\
         )
 
 LIB_SRC_C = $(addprefix lib/,\
+	embed/__errno.c \
 	libc/string0.c \
 	libm/math.c \
 	libm/fmodf.c \
@@ -119,6 +139,7 @@ LIB_SRC_C = $(addprefix lib/,\
 	libm/asinfacosf.c \
 	libm/atanf.c \
 	libm/atan2f.c \
+	libm/roundf.c \
 	mp-readline/readline.c \
 	netutils/netutils.c \
 	timeutils/timeutils.c \
@@ -127,12 +148,6 @@ LIB_SRC_C = $(addprefix lib/,\
 	utils/sys_stdio_mphal.c \
 	)
 
-ifeq ($(MICROPY_FATFS), 1)
-LIB_SRC_C += \
-	lib/oofatfs/ff.c \
-	lib/oofatfs/ffunicode.c
-endif
-
 DRIVERS_SRC_C = $(addprefix drivers/,\
 	bus/softspi.c \
 	dht/dht.c \
@@ -160,15 +175,24 @@ CONFVARS_FILE = $(BUILD)/confvars
 
 ifeq ($(wildcard $(CONFVARS_FILE)),)
 $(shell $(MKDIR) -p $(BUILD))
-$(shell echo $(FROZEN_DIR) $(UART_OS) > $(CONFVARS_FILE))
-else ifneq ($(shell cat $(CONFVARS_FILE)), $(FROZEN_DIR) $(UART_OS))
-$(shell echo $(FROZEN_DIR) $(UART_OS) > $(CONFVARS_FILE))
+$(shell echo $(FROZEN_MANIFEST) $(UART_OS) > $(CONFVARS_FILE))
+else ifneq ($(shell cat $(CONFVARS_FILE)), $(FROZEN_MANIFEST) $(UART_OS))
+$(shell echo $(FROZEN_MANIFEST) $(UART_OS) > $(CONFVARS_FILE))
 endif
 
 $(BUILD)/uart.o: $(CONFVARS_FILE)
 
 FROZEN_EXTRA_DEPS = $(CONFVARS_FILE)
 
+ifneq ($(FROZEN_MANIFEST)$(FROZEN_MPY_DIR),)
+CFLAGS += -DMICROPY_MODULE_FROZEN_MPY
+CFLAGS += -DMICROPY_QSTR_EXTRA_POOL=mp_qstr_frozen_const_pool
+endif
+
+ifneq ($(FROZEN_MANIFEST)$(FROZEN_DIR),)
+CFLAGS += -DMICROPY_MODULE_FROZEN_STR
+endif
+
 .PHONY: deploy
 
 deploy: $(BUILD)/firmware-combined.bin
@@ -192,15 +216,12 @@ $(BUILD)/firmware.elf: $(OBJ)
 	$(Q)$(LD) $(LDFLAGS) -o $@ $^ $(LIBS)
 	$(Q)$(SIZE) $@
 
-512k:
-	$(MAKE) LDSCRIPT=esp8266_512k.ld CFLAGS_EXTRA='-DMP_CONFIGFILE="<mpconfigport_512k.h>"' MICROPY_FATFS=0 MICROPY_PY_BTREE=0
-
 ota:
 	rm -f $(BUILD)/firmware.elf $(BUILD)/firmware.elf*.bin
-	$(MAKE) LDSCRIPT=esp8266_ota.ld FWBIN=$(BUILD)/firmware-ota.bin
+	$(MAKE) LD_FILES=boards/esp8266_ota.ld FWBIN=$(BUILD)/firmware-ota.bin
 
 include $(TOP)/py/mkrules.mk
 
 clean-modules:
 	git clean -f -d modules
-	rm -f build/frozen*.c
+	rm -f $(BUILD)/frozen*.c
diff --git a/ports/esp8266/README.md b/ports/esp8266/README.md
index 402798928c883..15ca7f891c263 100644
--- a/ports/esp8266/README.md
+++ b/ports/esp8266/README.md
@@ -22,21 +22,30 @@ Supported features include:
 - Modules for HTTP, MQTT, many other formats and protocols via
   https://github.com/micropython/micropython-lib .
 
-Work-in-progress documentation is available at
-http://docs.micropython.org/en/latest/esp8266/ .
+Documentation is available at http://docs.micropython.org/en/latest/esp8266/quickref.html.
 
 Build instructions
 ------------------
 
-The tool chain required for the build is the OpenSource ESP SDK, which can be
-found at <https://github.com/pfalcon/esp-open-sdk>.  Clone this repository and
-run `make` in its directory to build and install the SDK locally.  Make sure
-to add toolchain bin directory to your PATH.  Read esp-open-sdk's README for
-additional important information on toolchain setup.
+You need the esp-open-sdk toolchain (which provides both the compiler and libraries), which
+you can obtain using one of the following two options:
+
+ - Use a Docker image with a pre-built toolchain (**recommended**).
+   To use this, install Docker, then prepend
+   `docker run --rm -v $HOME:$HOME -u $UID -w $PWD larsks/esp-open-sdk ` to the start
+   of the mpy-cross and firmware `make` commands below. This will run the commands using the
+   toolchain inside the container but using the files on your local filesystem.
+
+ - or, install the esp-open-sdk directly on your PC, which can be found at
+   <https://github.com/pfalcon/esp-open-sdk>. Clone this repository and
+   run `make` in its directory to build and install the SDK locally.  Make sure
+   to add toolchain bin directory to your PATH.  Read esp-open-sdk's README for
+   additional important information on toolchain setup.
+   If you use this approach, then the command below will work exactly.
 
 Add the external dependencies to the MicroPython repository checkout:
 ```bash
-$ git submodule update --init
+$ make -C ports/esp8266 submodules
 ```
 See the README in the repository root for more information about external
 dependencies.
@@ -46,47 +55,64 @@ built-in scripts to bytecode.  This can be done using:
 ```bash
 $ make -C mpy-cross
 ```
+(Prepend the Docker command if using Docker, see above)
 
 Then, to build MicroPython for the ESP8266, just run:
 ```bash
 $ cd ports/esp8266
 $ make
 ```
-This will produce binary images in the `build/` subdirectory. If you install
-MicroPython to your module for the first time, or after installing any other
-firmware, you should erase flash completely:
+(Prepend the Docker command if using Docker, see above)
 
+This will produce binary images in the `build-GENERIC/` subdirectory. If you
+install MicroPython to your module for the first time, or after installing any
+other firmware, you should erase flash completely:
+```bash
+$ esptool.py --port /dev/ttyXXX erase_flash
 ```
-esptool.py --port /dev/ttyXXX erase_flash
-```
 
-Erase flash also as a troubleshooting measure, if a module doesn't behave as
-expected.
+You can install esptool.py either from your system package manager or from PyPi.
+
+Erasing the flash is also useful as a troubleshooting measure, if a module doesn't
+behave as expected.
 
 To flash MicroPython image to your ESP8266, use:
 ```bash
 $ make deploy
 ```
+(This should not be run inside Docker as it will need access to the serial port.)
+
 This will use the `esptool.py` script to download the images.  You must have
 your ESP module in the bootloader mode, and connected to a serial port on your PC.
 The default serial port is `/dev/ttyACM0`, flash mode is `qio` and flash size is
-`detect` (auto-detect based on Flash ID). To specify other values, use, eg (note
-that flash size is in megabits):
+`detect` (auto-detect based on Flash ID).
+
+To specify other values for `esptool.py`, use, e.g.:
 ```bash
 $ make PORT=/dev/ttyUSB0 FLASH_MODE=qio FLASH_SIZE=32m deploy
 ```
+(note that flash size is in megabits)
+
+If you want to flash manually using `esptool.py` directly, the image produced is
+`build-GENERIC/firmware-combined.bin`, to be flashed at 0x00000.
+
+The default board definition is the directory `boards/GENERIC`.
+For a custom configuration you can define your own board in the directory `boards/`.
 
-The image produced is `build/firmware-combined.bin`, to be flashed at 0x00000.
+The `BOARD` variable can be set on the make command line, for example:
+```bash
+$ make BOARD=GENERIC_512K
+```
 
 __512KB FlashROM version__
 
 The normal build described above requires modules with at least 1MB of FlashROM
 onboard. There's a special configuration for 512KB modules, which can be
-built with `make 512k`. This configuration is highly limited, lacks filesystem
-support, WebREPL, and has many other features disabled. It's mostly suitable
-for advanced users who are interested to fine-tune options to achieve a required
-setup. If you are an end user, please consider using a module with at least 1MB
-of FlashROM.
+built with `make BOARD=GENERIC_512K`. This configuration is highly limited, lacks
+filesystem support, WebREPL, and has many other features disabled. It's mostly
+suitable for advanced users who are interested to fine-tune options to achieve a
+required setup. If you are an end user, please consider using a module with at
+least 1MB of FlashROM.
 
 First start
 -----------
diff --git a/ports/esp8266/boards/GENERIC/manifest.py b/ports/esp8266/boards/GENERIC/manifest.py
new file mode 100644
index 0000000000000..4e65b256f92c8
--- /dev/null
+++ b/ports/esp8266/boards/GENERIC/manifest.py
@@ -0,0 +1,2 @@
+include("$(PORT_DIR)/boards/manifest.py")
+include("$(MPY_DIR)/extmod/uasyncio/manifest.py")
diff --git a/ports/esp8266/boards/GENERIC/mpconfigboard.h b/ports/esp8266/boards/GENERIC/mpconfigboard.h
new file mode 100644
index 0000000000000..d33943df80019
--- /dev/null
+++ b/ports/esp8266/boards/GENERIC/mpconfigboard.h
@@ -0,0 +1,21 @@
+#define MICROPY_HW_BOARD_NAME "ESP module"
+#define MICROPY_HW_MCU_NAME "ESP8266"
+
+#define MICROPY_PERSISTENT_CODE_LOAD    (1)
+#define MICROPY_EMIT_XTENSA             (1)
+#define MICROPY_EMIT_INLINE_XTENSA      (1)
+
+#define MICROPY_DEBUG_PRINTERS          (1)
+#define MICROPY_ERROR_REPORTING         (MICROPY_ERROR_REPORTING_NORMAL)
+
+#define MICROPY_READER_VFS              (MICROPY_VFS)
+#define MICROPY_VFS                     (1)
+
+#define MICROPY_PY_BUILTINS_SLICE_ATTRS (1)
+#define MICROPY_PY_ALL_SPECIAL_METHODS  (1)
+#define MICROPY_PY_IO_FILEIO            (1)
+#define MICROPY_PY_SYS_STDIO_BUFFER     (1)
+#define MICROPY_PY_UASYNCIO             (1)
+#define MICROPY_PY_URE_SUB              (1)
+#define MICROPY_PY_UCRYPTOLIB           (1)
+#define MICROPY_PY_FRAMEBUF             (1)
diff --git a/ports/esp8266/boards/GENERIC/mpconfigboard.mk b/ports/esp8266/boards/GENERIC/mpconfigboard.mk
new file mode 100644
index 0000000000000..6861317218b37
--- /dev/null
+++ b/ports/esp8266/boards/GENERIC/mpconfigboard.mk
@@ -0,0 +1,7 @@
+LD_FILES = boards/esp8266_2m.ld
+
+MICROPY_PY_BTREE ?= 1
+MICROPY_VFS_FAT ?= 1
+MICROPY_VFS_LFS2 ?= 1
+
+FROZEN_MANIFEST ?= $(BOARD_DIR)/manifest.py
diff --git a/ports/esp8266/boards/GENERIC_1M/mpconfigboard.h b/ports/esp8266/boards/GENERIC_1M/mpconfigboard.h
new file mode 100644
index 0000000000000..ed50729936b71
--- /dev/null
+++ b/ports/esp8266/boards/GENERIC_1M/mpconfigboard.h
@@ -0,0 +1,20 @@
+#define MICROPY_HW_BOARD_NAME "ESP module (1M)"
+#define MICROPY_HW_MCU_NAME "ESP8266"
+
+#define MICROPY_PERSISTENT_CODE_LOAD    (1)
+#define MICROPY_EMIT_XTENSA             (1)
+#define MICROPY_EMIT_INLINE_XTENSA      (1)
+
+#define MICROPY_DEBUG_PRINTERS          (1)
+#define MICROPY_ERROR_REPORTING         (MICROPY_ERROR_REPORTING_NORMAL)
+
+#define MICROPY_READER_VFS              (MICROPY_VFS)
+#define MICROPY_VFS                     (1)
+
+#define MICROPY_PY_BUILTINS_SLICE_ATTRS (1)
+#define MICROPY_PY_ALL_SPECIAL_METHODS  (1)
+#define MICROPY_PY_IO_FILEIO            (1)
+#define MICROPY_PY_SYS_STDIO_BUFFER     (1)
+#define MICROPY_PY_URE_SUB              (1)
+#define MICROPY_PY_UCRYPTOLIB           (1)
+#define MICROPY_PY_FRAMEBUF             (1)
diff --git a/ports/esp8266/boards/GENERIC_1M/mpconfigboard.mk b/ports/esp8266/boards/GENERIC_1M/mpconfigboard.mk
new file mode 100644
index 0000000000000..fdbb0d82451e7
--- /dev/null
+++ b/ports/esp8266/boards/GENERIC_1M/mpconfigboard.mk
@@ -0,0 +1,4 @@
+LD_FILES = boards/esp8266_1m.ld
+
+MICROPY_PY_BTREE ?= 1
+MICROPY_VFS_LFS2 ?= 1
diff --git a/ports/esp8266/boards/GENERIC_512K/mpconfigboard.h b/ports/esp8266/boards/GENERIC_512K/mpconfigboard.h
new file mode 100644
index 0000000000000..0693232aa1fb6
--- /dev/null
+++ b/ports/esp8266/boards/GENERIC_512K/mpconfigboard.h
@@ -0,0 +1,4 @@
+#define MICROPY_HW_BOARD_NAME "ESP module (512K)"
+#define MICROPY_HW_MCU_NAME "ESP8266"
+
+#define MICROPY_ERROR_REPORTING         (MICROPY_ERROR_REPORTING_TERSE)
diff --git a/ports/esp8266/boards/GENERIC_512K/mpconfigboard.mk b/ports/esp8266/boards/GENERIC_512K/mpconfigboard.mk
new file mode 100644
index 0000000000000..a7566f9f19ec9
--- /dev/null
+++ b/ports/esp8266/boards/GENERIC_512K/mpconfigboard.mk
@@ -0,0 +1 @@
+LD_FILES = boards/esp8266_512k.ld
diff --git a/ports/esp8266/eagle.rom.addr.v6.ld b/ports/esp8266/boards/eagle.rom.addr.v6.ld
similarity index 100%
rename from ports/esp8266/eagle.rom.addr.v6.ld
rename to ports/esp8266/boards/eagle.rom.addr.v6.ld
diff --git a/ports/esp8266/boards/esp8266_1m.ld b/ports/esp8266/boards/esp8266_1m.ld
new file mode 100644
index 0000000000000..94bc6a229a75b
--- /dev/null
+++ b/ports/esp8266/boards/esp8266_1m.ld
@@ -0,0 +1,19 @@
+/* GNU linker script for ESP8266 with 1M flash
+
+   Flash layout:
+    0x40200000 36k  header + iram/dram init
+    0x40209000 572k firmware (irom0)
+    0x40298000 396k filesystem
+    0x402fb000 20k  SDK parameters
+*/
+
+MEMORY
+{
+    dport0_0_seg : org = 0x3ff00000, len = 16
+    dram0_0_seg :  org = 0x3ffe8000, len = 80K
+    iram1_0_seg :  org = 0x40100000, len = 32K
+    irom0_0_seg :  org = 0x40209000, len = 572K
+}
+
+/* define common sections and symbols */
+INCLUDE boards/esp8266_common.ld
diff --git a/ports/esp8266/boards/esp8266_2m.ld b/ports/esp8266/boards/esp8266_2m.ld
new file mode 100644
index 0000000000000..b5813ce0fb7a4
--- /dev/null
+++ b/ports/esp8266/boards/esp8266_2m.ld
@@ -0,0 +1,18 @@
+/* GNU linker script for ESP8266 with 2M or more flash
+
+   Flash layout:
+    0x40200000 36k  header + iram/dram init
+    0x40209000 988k firmware (irom0)
+    0x40300000 1M+  filesystem (not memory mapped)
+*/
+
+MEMORY
+{
+    dport0_0_seg : org = 0x3ff00000, len = 16
+    dram0_0_seg :  org = 0x3ffe8000, len = 80K
+    iram1_0_seg :  org = 0x40100000, len = 32K
+    irom0_0_seg :  org = 0x40209000, len = 1M - 36K
+}
+
+/* define common sections and symbols */
+INCLUDE boards/esp8266_common.ld
diff --git a/ports/esp8266/boards/esp8266_512k.ld b/ports/esp8266/boards/esp8266_512k.ld
new file mode 100644
index 0000000000000..c4cc798499df0
--- /dev/null
+++ b/ports/esp8266/boards/esp8266_512k.ld
@@ -0,0 +1,18 @@
+/* GNU linker script for ESP8266 with 512K flash
+
+   Flash layout:
+    0x40200000 36k  header + iram/dram init
+    0x40209000 456k firmware (irom0)
+    0x4027b000 20k  SDK parameters
+*/
+
+MEMORY
+{
+    dport0_0_seg : org = 0x3ff00000, len = 16
+    dram0_0_seg :  org = 0x3ffe8000, len = 80K
+    iram1_0_seg :  org = 0x40100000, len = 32K
+    irom0_0_seg :  org = 0x40209000, len = 512K - 36K - 20K
+}
+
+/* define common sections and symbols */
+INCLUDE boards/esp8266_common.ld
diff --git a/ports/esp8266/esp8266_common.ld b/ports/esp8266/boards/esp8266_common.ld
similarity index 96%
rename from ports/esp8266/esp8266_common.ld
rename to ports/esp8266/boards/esp8266_common.ld
index f4b4207f27e3d..c6e37d942c6bf 100644
--- a/ports/esp8266/esp8266_common.ld
+++ b/ports/esp8266/boards/esp8266_common.ld
@@ -109,7 +109,9 @@ SECTIONS
         *py/nlr*.o*(.literal* .text*)
         *py/obj*.o*(.literal* .text*)
         *py/opmethods.o*(.literal* .text*)
+        *py/pairheap*.o*(.literal* .text*)
         *py/parse*.o*(.literal* .text*)
+        *py/profile*.o*(.literal* .text*)
         *py/qstr.o*(.literal* .text*)
         *py/repl.o*(.literal* .text*)
         *py/runtime.o*(.literal* .text*)
@@ -131,6 +133,7 @@ SECTIONS
         *lib/axtls/*.o(.literal*, .text*)
         *lib/berkeley-db-1.xx/*.o(.literal*, .text*)
         *lib/libm/*.o*(.literal*, .text*)
+        *lib/littlefs/*.o*(.literal*, .text*)
         *lib/mp-readline/*.o(.literal*, .text*)
         *lib/netutils/*.o*(.literal*, .text*)
         *lib/timeutils/*.o*(.literal*, .text*)
@@ -138,10 +141,10 @@ SECTIONS
         *lib/utils/sys_stdio_mphal.o*(.literal*, .text*)
         *lib/utils/pyexec.o*(.literal*, .text*)
         *lib/utils/stdout_helpers.o*(.literal*, .text*)
-        *lib/utils/interrupt_char.o*(.literal.mp_hal_set_interrupt_char, .text.mp_hal_set_interrupt_char)
+        *lib/utils/interrupt_char.o*(.literal*, .text*)
         *drivers/bus/*.o(.literal* .text*)
 
-        build/main.o(.literal* .text*)
+        build-*/main.o(.literal* .text*)
         *fatfs_port.o(.literal* .text*)
         *gccollect.o(.literal* .text*)
         *gchelper.o(.literal* .text*)
@@ -167,6 +170,7 @@ SECTIONS
         *modlwip.o(.literal* .text*)
         *modsocket.o(.literal* .text*)
         *modonewire.o(.literal* .text*)
+        *esp_mphal.o(.literal* .text*)
 
         /* we put as much rodata as possible in this section */
         /* note that only rodata accessed as a machine word is allowed here */
@@ -178,7 +182,7 @@ SECTIONS
         */frozen.o(.rodata.mp_frozen_content) /* frozen modules */
 
         /* for -mforce-l32 */
-        build/*.o(.rodata*)
+        build-*/*.o(.rodata*)
 
         _irom0_text_end = ABSOLUTE(.);
     } >irom0_0_seg :irom0_0_phdr
@@ -312,4 +316,4 @@ SECTIONS
 }
 
 /* get ROM code address */
-INCLUDE "eagle.rom.addr.v6.ld"
+INCLUDE "boards/eagle.rom.addr.v6.ld"
diff --git a/ports/esp8266/esp8266_ota.ld b/ports/esp8266/boards/esp8266_ota.ld
similarity index 92%
rename from ports/esp8266/esp8266_ota.ld
rename to ports/esp8266/boards/esp8266_ota.ld
index 604480a0a9630..7fdf6abef00e3 100644
--- a/ports/esp8266/esp8266_ota.ld
+++ b/ports/esp8266/boards/esp8266_ota.ld
@@ -10,4 +10,4 @@ MEMORY
 }
 
 /* define common sections and symbols */
-INCLUDE esp8266_common.ld
+INCLUDE boards/esp8266_common.ld
diff --git a/ports/esp8266/boards/manifest.py b/ports/esp8266/boards/manifest.py
new file mode 100644
index 0000000000000..de719f8f1e29c
--- /dev/null
+++ b/ports/esp8266/boards/manifest.py
@@ -0,0 +1,5 @@
+freeze("$(PORT_DIR)/modules")
+freeze("$(MPY_DIR)/tools", ("upip.py", "upip_utarfile.py"))
+freeze("$(MPY_DIR)/drivers/dht", "dht.py")
+freeze("$(MPY_DIR)/drivers/onewire")
+include("$(MPY_DIR)/extmod/webrepl/manifest.py")
diff --git a/ports/esp8266/boards/manifest_release.py b/ports/esp8266/boards/manifest_release.py
new file mode 100644
index 0000000000000..5a3194ae9bd45
--- /dev/null
+++ b/ports/esp8266/boards/manifest_release.py
@@ -0,0 +1,23 @@
+include("manifest.py")
+
+# drivers
+freeze("$(MPY_DIR)/drivers/display", "ssd1306.py")
+
+# file utilities
+freeze("$(MPY_LIB_DIR)/upysh", "upysh.py")
+
+# requests
+freeze("$(MPY_LIB_DIR)/urequests", "urequests.py")
+freeze("$(MPY_LIB_DIR)/urllib.urequest", "urllib/urequest.py")
+
+# umqtt with examples
+freeze("$(MPY_LIB_DIR)/umqtt.simple", "umqtt/simple.py")
+freeze("$(MPY_LIB_DIR)/umqtt.robust", "umqtt/robust.py")
+freeze("$(MPY_LIB_DIR)/umqtt.simple", "example_pub_button.py")
+freeze("$(MPY_LIB_DIR)/umqtt.simple", "example_sub_led.py")
+
+# HTTP examples
+freeze("$(MPY_DIR)/examples/network", "http_client.py")
+freeze("$(MPY_DIR)/examples/network", "http_client_ssl.py")
+freeze("$(MPY_DIR)/examples/network", "http_server.py")
+freeze("$(MPY_DIR)/examples/network", "http_server_ssl.py")
diff --git a/ports/esp8266/esp8266.ld b/ports/esp8266/esp8266.ld
deleted file mode 100644
index deeb82b456122..0000000000000
--- a/ports/esp8266/esp8266.ld
+++ /dev/null
@@ -1,12 +0,0 @@
-/* GNU linker script for ESP8266 */
-
-MEMORY
-{
-    dport0_0_seg : org = 0x3ff00000, len = 0x10
-    dram0_0_seg :  org = 0x3ffe8000, len = 0x14000
-    iram1_0_seg :  org = 0x40100000, len = 0x8000
-    irom0_0_seg :  org = 0x40209000, len = 0x8f000
-}
-
-/* define common sections and symbols */
-INCLUDE esp8266_common.ld
diff --git a/ports/esp8266/esp8266_512k.ld b/ports/esp8266/esp8266_512k.ld
deleted file mode 100644
index 0ae663db11e29..0000000000000
--- a/ports/esp8266/esp8266_512k.ld
+++ /dev/null
@@ -1,12 +0,0 @@
-/* GNU linker script for ESP8266 */
-
-MEMORY
-{
-    dport0_0_seg : org = 0x3ff00000, len = 0x10
-    dram0_0_seg :  org = 0x3ffe8000, len = 0x14000
-    iram1_0_seg :  org = 0x40100000, len = 0x8000
-    irom0_0_seg :  org = 0x40209000, len = 0x72000
-}
-
-/* define common sections and symbols */
-INCLUDE esp8266_common.ld
diff --git a/ports/esp8266/esp_init_data.c b/ports/esp8266/esp_init_data.c
index b14de573a76d0..eb4d99ebda1f7 100644
--- a/ports/esp8266/esp_init_data.c
+++ b/ports/esp8266/esp_init_data.c
@@ -36,20 +36,20 @@ void ets_printf(const char *fmt, ...);
 extern char flashchip;
 
 static const uint8_t default_init_data[] __attribute__((aligned(4))) = {
-0x05, 0x00, 0x04, 0x02, 0x05, 0x05, 0x05, 0x02, 0x05, 0x00, 0x04, 0x05, 0x05, 0x04, 0x05, 0x05,
-0x04, 0xfe, 0xfd, 0xff, 0xf0, 0xf0, 0xf0, 0xe0, 0xe0, 0xe0, 0xe1, 0x0a, 0xff, 0xff, 0xf8, 0x00,
-0xf8, 0xf8, 0x52, 0x4e, 0x4a, 0x44, 0x40, 0x38, 0x00, 0x00, 0x01, 0x01, 0x02, 0x03, 0x04, 0x05,
-0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0xe1, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x93, 0x43, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    0x05, 0x00, 0x04, 0x02, 0x05, 0x05, 0x05, 0x02, 0x05, 0x00, 0x04, 0x05, 0x05, 0x04, 0x05, 0x05,
+    0x04, 0xfe, 0xfd, 0xff, 0xf0, 0xf0, 0xf0, 0xe0, 0xe0, 0xe0, 0xe1, 0x0a, 0xff, 0xff, 0xf8, 0x00,
+    0xf8, 0xf8, 0x52, 0x4e, 0x4a, 0x44, 0x40, 0x38, 0x00, 0x00, 0x01, 0x01, 0x02, 0x03, 0x04, 0x05,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xe1, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x93, 0x43, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
 
 void firmware_start(void) {
     // For SDK 1.5.2, either address has shifted and not mirrored in
     // eagle.rom.addr.v6.ld, or extra initial member was added.
-    SpiFlashChip *flash = (SpiFlashChip*)(&flashchip + 4);
+    SpiFlashChip *flash = (SpiFlashChip *)(&flashchip + 4);
 
     char buf[128];
     SPIRead(flash->chip_size - 4 * 0x1000, buf, sizeof(buf));
@@ -73,5 +73,5 @@ void firmware_start(void) {
         SPIWrite(flash->chip_size - 4 * 0x1000, buf, sizeof(buf));
     }
 
-    asm("j call_user_start");
+    asm ("j call_user_start");
 }
diff --git a/ports/esp8266/esp_mphal.c b/ports/esp8266/esp_mphal.c
index df97a73430235..c467ab72db7ec 100644
--- a/ports/esp8266/esp_mphal.c
+++ b/ports/esp8266/esp_mphal.c
@@ -32,6 +32,7 @@
 #include "user_interface.h"
 #include "ets_alt_task.h"
 #include "py/runtime.h"
+#include "py/stream.h"
 #include "extmod/misc.h"
 #include "lib/utils/pyexec.h"
 
@@ -43,19 +44,27 @@ const mp_print_t mp_debug_print = {NULL, mp_hal_debug_tx_strn_cooked};
 int uart_attached_to_dupterm;
 
 void mp_hal_init(void) {
-    //ets_wdt_disable(); // it's a pain while developing
+    // ets_wdt_disable(); // it's a pain while developing
     mp_hal_rtc_init();
     uart_init(UART_BIT_RATE_115200, UART_BIT_RATE_115200);
     uart_attached_to_dupterm = 0;
 }
 
-void mp_hal_delay_us(uint32_t us) {
+void MP_FASTCODE(mp_hal_delay_us)(uint32_t us) {
     uint32_t start = system_get_time();
     while (system_get_time() - start < us) {
         ets_event_poll();
     }
 }
 
+uintptr_t mp_hal_stdio_poll(uintptr_t poll_flags) {
+    uintptr_t ret = 0;
+    if ((poll_flags & MP_STREAM_POLL_RD) && stdin_ringbuf.iget != stdin_ringbuf.iput) {
+        ret |= MP_STREAM_POLL_RD;
+    }
+    return ret;
+}
+
 int mp_hal_stdin_rx_chr(void) {
     for (;;) {
         int c = ringbuf_get(&stdin_ringbuf);
@@ -65,7 +74,7 @@ int mp_hal_stdin_rx_chr(void) {
         #if 0
         // Idles CPU but need more testing before enabling
         if (!ets_loop_iter()) {
-            asm("waiti 0");
+            asm ("waiti 0");
         }
         #else
         mp_hal_delay_us(1);
@@ -119,30 +128,28 @@ void mp_hal_debug_tx_strn_cooked(void *env, const char *str, uint32_t len) {
     }
 }
 
-uint32_t mp_hal_ticks_ms(void) {
-    return ((uint64_t)system_time_high_word << 32 | (uint64_t)system_get_time()) / 1000;
+uint32_t MP_FASTCODE(mp_hal_ticks_ms)(void) {
+    // Compute milliseconds from 64-bit microsecond counter
+    system_time_update();
+    return ((uint64_t)system_time_high_word << 32 | (uint64_t)system_time_low_word) / 1000;
 }
 
-uint32_t mp_hal_ticks_us(void) {
-    return system_get_time();
-}
-
-void mp_hal_delay_ms(uint32_t delay) {
+void MP_FASTCODE(mp_hal_delay_ms)(uint32_t delay) {
     mp_hal_delay_us(delay * 1000);
 }
 
 void ets_event_poll(void) {
     ets_loop_iter();
-    mp_handle_pending();
+    mp_handle_pending(true);
 }
 
 void __assert_func(const char *file, int line, const char *func, const char *expr) {
     printf("assert:%s:%d:%s: %s\n", file, line, func, expr);
-    nlr_raise(mp_obj_new_exception_msg(&mp_type_AssertionError,
-        "C-level assert"));
+    mp_raise_msg(&mp_type_AssertionError, MP_ERROR_TEXT("C-level assert"));
 }
 
-void mp_hal_signal_input(void) {
+// May be called by uart0_rx_intr_handler.
+void MP_FASTCODE(mp_hal_signal_input)(void) {
     #if MICROPY_REPL_EVENT_DRIVEN
     system_os_post(UART_TASK_ID, 0, 0);
     #endif
@@ -179,7 +186,7 @@ void mp_hal_signal_dupterm_input(void) {
 void *ets_get_esf_buf_ctlblk(void) {
     // Get literal ptr before start of esf_rx_buf_alloc func
     extern void *esf_rx_buf_alloc();
-    return ((void**)esf_rx_buf_alloc)[-1];
+    return ((void **)esf_rx_buf_alloc)[-1];
 }
 
 // Get number of esf_buf free buffers of given type, as encoded by index
@@ -188,16 +195,11 @@ void *ets_get_esf_buf_ctlblk(void) {
 // 1 - tx buffer, 5 - management frame tx buffer; 8 - rx buffer
 int ets_esf_free_bufs(int idx) {
     uint32_t *p = ets_get_esf_buf_ctlblk();
-    uint32_t *b = (uint32_t*)p[idx];
+    uint32_t *b = (uint32_t *)p[idx];
     int cnt = 0;
     while (b) {
-        b = (uint32_t*)b[0x20 / 4];
+        b = (uint32_t *)b[0x20 / 4];
         cnt++;
     }
     return cnt;
 }
-
-extern int mp_stream_errno;
-int *__errno() {
-    return &mp_stream_errno;
-}
diff --git a/ports/esp8266/esp_mphal.h b/ports/esp8266/esp_mphal.h
index 8712a2a33b07c..89f4e0ff08544 100644
--- a/ports/esp8266/esp_mphal.h
+++ b/ports/esp8266/esp_mphal.h
@@ -24,6 +24,7 @@
  * THE SOFTWARE.
  */
 
+#include "user_interface.h"
 #include "py/ringbuf.h"
 #include "lib/utils/interrupt_char.h"
 #include "xtirq.h"
@@ -46,11 +47,14 @@ extern int uart_attached_to_dupterm;
 void mp_hal_init(void);
 void mp_hal_rtc_init(void);
 
-uint32_t mp_hal_ticks_us(void);
+__attribute__((always_inline)) static inline uint32_t mp_hal_ticks_us(void) {
+    return system_get_time();
+}
+
 __attribute__((always_inline)) static inline uint32_t mp_hal_ticks_cpu(void) {
-  uint32_t ccount;
-  __asm__ __volatile__("rsr %0,ccount":"=a" (ccount));
-  return ccount;
+    uint32_t ccount;
+    __asm__ __volatile__ ("rsr %0,ccount" : "=a" (ccount));
+    return ccount;
 }
 
 void mp_hal_delay_us(uint32_t);
@@ -86,16 +90,16 @@ void mp_hal_pin_open_drain(mp_hal_pin_obj_t pin);
 #define mp_hal_pin_od_low(p) do { \
         if ((p) == 16) { WRITE_PERI_REG(RTC_GPIO_ENABLE, (READ_PERI_REG(RTC_GPIO_ENABLE) & ~1) | 1); } \
         else { gpio_output_set(0, 1 << (p), 1 << (p), 0); } \
-    } while (0)
+} while (0)
 #define mp_hal_pin_od_high(p) do { \
         if ((p) == 16) { WRITE_PERI_REG(RTC_GPIO_ENABLE, (READ_PERI_REG(RTC_GPIO_ENABLE) & ~1)); } \
         else { gpio_output_set(0, 0, 0, 1 << (p)); /* set as input to avoid glitches */ } \
-    } while (0)
+} while (0)
 // The DHT driver requires using the open-drain feature of the GPIO to get it to work reliably
 #define mp_hal_pin_od_high_dht(p) do { \
         if ((p) == 16) { WRITE_PERI_REG(RTC_GPIO_ENABLE, (READ_PERI_REG(RTC_GPIO_ENABLE) & ~1)); } \
         else { gpio_output_set(1 << (p), 0, 1 << (p), 0); } \
-    } while (0)
+} while (0)
 #define mp_hal_pin_read(p) pin_get(p)
 #define mp_hal_pin_write(p, v) pin_set((p), (v))
 
diff --git a/ports/esp8266/espapa102.c b/ports/esp8266/espapa102.c
index 4295fe42d8443..2bea26609af06 100644
--- a/ports/esp8266/espapa102.c
+++ b/ports/esp8266/espapa102.c
@@ -33,7 +33,7 @@
 #include "user_interface.h"
 #include "espapa102.h"
 
-#define NOP asm volatile(" nop \n\t")
+#define NOP asm volatile (" nop \n\t")
 
 static inline void _esp_apa102_send_byte(uint32_t clockPinMask, uint32_t dataPinMask, uint8_t byte) {
     for (uint32_t i = 0; i < 8; i++) {
diff --git a/ports/esp8266/espneopixel.c b/ports/esp8266/espneopixel.c
index 6c76591865128..d2166a8b068b4 100644
--- a/ports/esp8266/espneopixel.c
+++ b/ports/esp8266/espneopixel.c
@@ -18,48 +18,58 @@
 
 void /*ICACHE_RAM_ATTR*/ esp_neopixel_write(uint8_t pin, uint8_t *pixels, uint32_t numBytes, bool is800KHz) {
 
-  uint8_t *p, *end, pix, mask;
-  uint32_t t, time0, time1, period, c, startTime, pinMask;
+    uint8_t *p, *end, pix, mask;
+    uint32_t t, time0, time1, period, c, startTime, pinMask;
 
-  pinMask   = 1 << pin;
-  p         =  pixels;
-  end       =  p + numBytes;
-  pix       = *p++;
-  mask      = 0x80;
-  startTime = 0;
+    pinMask = 1 << pin;
+    p = pixels;
+    end = p + numBytes;
+    pix = *p++;
+    mask = 0x80;
+    startTime = 0;
 
-  uint32_t fcpu = system_get_cpu_freq() * 1000000;
+    uint32_t fcpu = system_get_cpu_freq() * 1000000;
 
-#ifdef NEO_KHZ400
-  if(is800KHz) {
-#endif
-    time0  = fcpu / 2857143; // 0.35us
-    time1  = fcpu / 1250000; // 0.8us
-    period = fcpu /  800000; // 1.25us per bit
-#ifdef NEO_KHZ400
-  } else { // 400 KHz bitstream
-    time0  = fcpu / 2000000; // 0.5uS
-    time1  = fcpu /  833333; // 1.2us
-    period = fcpu /  400000; // 2.5us per bit
-  }
-#endif
+    #ifdef NEO_KHZ400
+    if (is800KHz) {
+    #endif
+    time0 = fcpu / 2857143;  // 0.35us
+    time1 = fcpu / 1250000;  // 0.8us
+    period = fcpu / 800000;  // 1.25us per bit
+    #ifdef NEO_KHZ400
+} else {   // 400 KHz bitstream
+    time0 = fcpu / 2000000;  // 0.5uS
+    time1 = fcpu / 833333;   // 1.2us
+    period = fcpu / 400000;  // 2.5us per bit
+}
+    #endif
 
-  uint32_t irq_state = mp_hal_quiet_timing_enter();
-  for(t = time0;; t = time0) {
-    if(pix & mask) t = time1;                             // Bit high duration
-    while(((c = mp_hal_ticks_cpu()) - startTime) < period); // Wait for bit start
-    GPIO_REG_WRITE(GPIO_OUT_W1TS_ADDRESS, pinMask);       // Set high
-    startTime = c;                                        // Save start time
-    while(((c = mp_hal_ticks_cpu()) - startTime) < t);      // Wait high duration
-    GPIO_REG_WRITE(GPIO_OUT_W1TC_ADDRESS, pinMask);       // Set low
-    if(!(mask >>= 1)) {                                   // Next bit/byte
-      if(p >= end) break;
-      pix  = *p++;
-      mask = 0x80;
+    uint32_t irq_state = mp_hal_quiet_timing_enter();
+    for (t = time0;; t = time0) {
+        if (pix & mask) {
+            t = time1;                                    // Bit high duration
+        }
+        while (((c = mp_hal_ticks_cpu()) - startTime) < period) {
+            ;                                               // Wait for bit start
+        }
+        GPIO_REG_WRITE(GPIO_OUT_W1TS_ADDRESS, pinMask);   // Set high
+        startTime = c;                                    // Save start time
+        while (((c = mp_hal_ticks_cpu()) - startTime) < t) {
+            ;                                               // Wait high duration
+        }
+        GPIO_REG_WRITE(GPIO_OUT_W1TC_ADDRESS, pinMask);   // Set low
+        if (!(mask >>= 1)) {                              // Next bit/byte
+            if (p >= end) {
+                break;
+            }
+            pix = *p++;
+            mask = 0x80;
+        }
+    }
+    while ((mp_hal_ticks_cpu() - startTime) < period) {
+        ;                                           // Wait for last bit
     }
-  }
-  while((mp_hal_ticks_cpu() - startTime) < period); // Wait for last bit
-  mp_hal_quiet_timing_exit(irq_state);
+    mp_hal_quiet_timing_exit(irq_state);
 }
 
 #endif // MICROPY_ESP8266_NEOPIXEL
diff --git a/ports/esp8266/esppwm.c b/ports/esp8266/esppwm.c
index 33eaf3b9a1b82..d5bcea9acd8cc 100644
--- a/ports/esp8266/esppwm.c
+++ b/ports/esp8266/esppwm.c
@@ -20,7 +20,7 @@
 
 #include "py/mpprint.h"
 #define PWM_DBG(...)
-//#define PWM_DBG(...) mp_printf(&mp_plat_print, __VA_ARGS__)
+// #define PWM_DBG(...) mp_printf(&mp_plat_print, __VA_ARGS__)
 
 #define ICACHE_RAM_ATTR // __attribute__((section(".text")))
 
@@ -57,16 +57,17 @@ STATIC uint8_t pwm_timer_down = 1;
 STATIC uint8_t pwm_current_channel = 0;
 STATIC uint16_t pwm_gpio = 0;
 STATIC uint8_t pwm_channel_num = 0;
+STATIC volatile uint8_t pwm_toggle_request = 0;
 
-//XXX: 0xffffffff/(80000000/16)=35A
+// XXX: 0xffffffff/(80000000/16)=35A
 #define US_TO_RTC_TIMER_TICKS(t)          \
     ((t) ?                                   \
-     (((t) > 0x35A) ?                   \
-      (((t)>>2) * ((APB_CLK_FREQ>>4)/250000) + ((t)&0x3) * ((APB_CLK_FREQ>>4)/1000000))  :    \
-      (((t) *(APB_CLK_FREQ>>4)) / 1000000)) :    \
-     0)
+    (((t) > 0x35A) ?                   \
+    (((t) >> 2) * ((APB_CLK_FREQ >> 4) / 250000) + ((t) & 0x3) * ((APB_CLK_FREQ >> 4) / 1000000))  :    \
+    (((t) * (APB_CLK_FREQ >> 4)) / 1000000)) :    \
+    0)
 
-//FRC1
+// FRC1
 #define FRC1_ENABLE_TIMER  BIT7
 
 typedef enum {
@@ -81,8 +82,7 @@ typedef enum {
 } TIMER_INT_MODE;
 
 STATIC void ICACHE_FLASH_ATTR
-pwm_insert_sort(struct pwm_single_param pwm[], uint8 n)
-{
+pwm_insert_sort(struct pwm_single_param pwm[], uint8 n) {
     uint8 i;
 
     for (i = 1; i < n; i++) {
@@ -109,17 +109,16 @@ pwm_insert_sort(struct pwm_single_param pwm[], uint8 n)
 STATIC volatile uint8 critical = 0;
 
 #define LOCK_PWM(c)  do {                       \
-    while( (c)==1 );                            \
-    (c) = 1;                                    \
+        while ((c) == 1);                            \
+        (c) = 1;                                    \
 } while (0)
 
 #define UNLOCK_PWM(c) do {                      \
-    (c) = 0;                                    \
+        (c) = 0;                                    \
 } while (0)
 
 void ICACHE_FLASH_ATTR
-pwm_start(void)
-{
+pwm_start(void) {
     uint8 i, j;
     PWM_DBG("--Function pwm_start() is called\n");
     PWM_DBG("pwm_gpio:%x,pwm_channel_num:%d\n",pwm_gpio,pwm_channel_num);
@@ -128,6 +127,9 @@ pwm_start(void)
 
     LOCK_PWM(critical);   // enter critical
 
+    // if a toggle is pending, we reset it since we're changing the settings again
+    pwm_toggle_request = 0;
+
     struct pwm_single_param *local_single = pwm_single_toggle[pwm_toggle ^ 0x01];
     uint8 *local_channel = &pwm_channel_toggle[pwm_toggle ^ 0x01];
 
@@ -169,7 +171,7 @@ pwm_start(void)
     }
 
     // step 5: last channel needs to clean
-    local_single[*local_channel-1].gpio_clear = 0;
+    local_single[*local_channel - 1].gpio_clear = 0;
 
     // step 6: if first channel duty is 0, remove it
     if (local_single[0].h_time == 0) {
@@ -190,14 +192,14 @@ pwm_start(void)
         // start
         gpio_output_set(local_single[0].gpio_set, local_single[0].gpio_clear, pwm_gpio, 0);
 
+        // do the first toggle because timer has to have a valid set to do it's job
+        pwm_toggle ^= 0x01;
+
         pwm_timer_down = 0;
         RTC_REG_WRITE(FRC1_LOAD_ADDRESS, local_single[0].h_time);
-    }
-
-    if (pwm_toggle == 1) {
-        pwm_toggle = 0;
     } else {
-        pwm_toggle = 1;
+        // request pwm_tim1_intr_handler to swap the timing buffers
+        pwm_toggle_request = 1;
     }
 
     UNLOCK_PWM(critical);   // leave critical
@@ -212,17 +214,17 @@ pwm_start(void)
  * Returns      : NONE
 *******************************************************************************/
 void ICACHE_FLASH_ATTR
-pwm_set_duty(int16_t duty, uint8 channel)
-{
+pwm_set_duty(int16_t duty, uint8 channel) {
     uint8 i;
-    for(i=0;i<pwm_channel_num;i++){
-        if(pwm_out_io_num[i] == channel){
+    for (i = 0; i < pwm_channel_num; i++) {
+        if (pwm_out_io_num[i] == channel) {
             channel = i;
             break;
         }
     }
-    if(i==pwm_channel_num)      // non found
+    if (i == pwm_channel_num) {    // non found
         return;
+    }
 
     LOCK_PWM(critical);   // enter critical
     if (duty < 1) {
@@ -242,8 +244,7 @@ pwm_set_duty(int16_t duty, uint8 channel)
  * Returns      : NONE
 *******************************************************************************/
 void ICACHE_FLASH_ATTR
-pwm_set_freq(uint16 freq, uint8 channel)
-{
+pwm_set_freq(uint16 freq, uint8 channel) {
     LOCK_PWM(critical);   // enter critical
     if (freq > PWM_FREQ_MAX) {
         pwm.freq = PWM_FREQ_MAX;
@@ -264,17 +265,17 @@ pwm_set_freq(uint16 freq, uint8 channel)
  * Returns      : NONE
 *******************************************************************************/
 uint16 ICACHE_FLASH_ATTR
-pwm_get_duty(uint8 channel)
-{
+pwm_get_duty(uint8 channel) {
     uint8 i;
-    for(i=0;i<pwm_channel_num;i++){
-        if(pwm_out_io_num[i] == channel){
+    for (i = 0; i < pwm_channel_num; i++) {
+        if (pwm_out_io_num[i] == channel) {
             channel = i;
             break;
         }
     }
-    if(i==pwm_channel_num)      // non found
+    if (i == pwm_channel_num) {    // non found
         return 0;
+    }
 
     return pwm.duty[channel];
 }
@@ -286,8 +287,7 @@ pwm_get_duty(uint8 channel)
  * Returns      : uint16 : pwm frequency
 *******************************************************************************/
 uint16 ICACHE_FLASH_ATTR
-pwm_get_freq(uint8 channel)
-{
+pwm_get_freq(uint8 channel) {
     return pwm.freq;
 }
 
@@ -299,28 +299,33 @@ pwm_get_freq(uint8 channel)
  * Returns      : NONE
 *******************************************************************************/
 STATIC void ICACHE_RAM_ATTR
-pwm_tim1_intr_handler(void *dummy)
-{
+pwm_tim1_intr_handler(void *dummy) {
     (void)dummy;
-    uint8 local_toggle = pwm_toggle;                        // pwm_toggle may change outside
+
     RTC_CLR_REG_MASK(FRC1_INT_ADDRESS, FRC1_INT_CLR_MASK);
 
     if (pwm_current_channel >= (*pwm_channel - 1)) {        // *pwm_channel may change outside
-        pwm_single = pwm_single_toggle[local_toggle];
-        pwm_channel = &pwm_channel_toggle[local_toggle];
+
+        if (pwm_toggle_request != 0) {
+            pwm_toggle ^= 1;
+            pwm_toggle_request = 0;
+        }
+
+        pwm_single = pwm_single_toggle[pwm_toggle];
+        pwm_channel = &pwm_channel_toggle[pwm_toggle];
 
         gpio_output_set(pwm_single[*pwm_channel - 1].gpio_set,
-                        pwm_single[*pwm_channel - 1].gpio_clear,
-                        pwm_gpio,
-                        0);
+            pwm_single[*pwm_channel - 1].gpio_clear,
+            pwm_gpio,
+            0);
 
         pwm_current_channel = 0;
 
         RTC_REG_WRITE(FRC1_LOAD_ADDRESS, pwm_single[pwm_current_channel].h_time);
     } else {
         gpio_output_set(pwm_single[pwm_current_channel].gpio_set,
-                        pwm_single[pwm_current_channel].gpio_clear,
-                        pwm_gpio, 0);
+            pwm_single[pwm_current_channel].gpio_clear,
+            pwm_gpio, 0);
 
         pwm_current_channel++;
         RTC_REG_WRITE(FRC1_LOAD_ADDRESS, pwm_single[pwm_current_channel].h_time);
@@ -335,14 +340,13 @@ pwm_tim1_intr_handler(void *dummy)
  * Returns      : NONE
 *******************************************************************************/
 void ICACHE_FLASH_ATTR
-pwm_init(void)
-{
+pwm_init(void) {
     uint8 i;
 
-    RTC_REG_WRITE(FRC1_CTRL_ADDRESS,  //FRC2_AUTO_RELOAD|
-                  DIVDED_BY_16
-                  | FRC1_ENABLE_TIMER
-                  | TM_EDGE_INT);
+    RTC_REG_WRITE(FRC1_CTRL_ADDRESS,  // FRC2_AUTO_RELOAD|
+        DIVDED_BY_16
+        | FRC1_ENABLE_TIMER
+        | TM_EDGE_INT);
     RTC_REG_WRITE(FRC1_LOAD_ADDRESS, 0);
 
     for (i = 0; i < PWM_CHANNEL; i++) {
@@ -359,7 +363,7 @@ pwm_init(void)
 }
 
 int ICACHE_FLASH_ATTR
-pwm_add(uint8_t pin_id, uint32_t pin_mux, uint32_t pin_func){
+pwm_add(uint8_t pin_id, uint32_t pin_mux, uint32_t pin_func) {
     PWM_DBG("--Function pwm_add() is called. channel:%d\n", channel);
     PWM_DBG("pwm_gpio:%x,pwm_channel_num:%d\n",pwm_gpio,pwm_channel_num);
     PWM_DBG("pwm_out_io_num[0]:%d,[1]:%d,[2]:%d\n",pwm_out_io_num[0],pwm_out_io_num[1],pwm_out_io_num[2]);
@@ -375,16 +379,17 @@ pwm_add(uint8_t pin_id, uint32_t pin_mux, uint32_t pin_func){
         return -1;
     }
     uint8 i;
-    for(i=0;i<PWM_CHANNEL;i++){
-        if(pwm_out_io_num[i]==channel)  // already exist
+    for (i = 0; i < PWM_CHANNEL; i++) {
+        if (pwm_out_io_num[i] == channel) { // already exist
             return channel;
-        if(pwm_out_io_num[i] == -1){ // empty exist
+        }
+        if (pwm_out_io_num[i] == -1) { // empty exist
             LOCK_PWM(critical);   // enter critical
             pwm_out_io_num[i] = channel;
             pwm.duty[i] = 0;
             pwm_gpio |= (1 << pin_num[channel]);
             PIN_FUNC_SELECT(pin_mux, pin_func);
-            GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[channel])), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[channel]))) & (~ GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE))); //disable open drain;
+            GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[channel])), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[channel]))) & (~GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE)));  // disable open drain;
             pwm_channel_num++;
             UNLOCK_PWM(critical);   // leave critical
             return channel;
@@ -394,23 +399,23 @@ pwm_add(uint8_t pin_id, uint32_t pin_mux, uint32_t pin_func){
 }
 
 bool ICACHE_FLASH_ATTR
-pwm_delete(uint8 channel){
+pwm_delete(uint8 channel) {
     PWM_DBG("--Function pwm_delete() is called. channel:%d\n", channel);
     PWM_DBG("pwm_gpio:%x,pwm_channel_num:%d\n",pwm_gpio,pwm_channel_num);
     PWM_DBG("pwm_out_io_num[0]:%d,[1]:%d,[2]:%d\n",pwm_out_io_num[0],pwm_out_io_num[1],pwm_out_io_num[2]);
     PWM_DBG("pwm.duty[0]:%d,[1]:%d,[2]:%d\n",pwm.duty[0],pwm.duty[1],pwm.duty[2]);
     uint8 i,j;
-    for(i=0;i<pwm_channel_num;i++){
-        if(pwm_out_io_num[i]==channel){  // exist
+    for (i = 0; i < pwm_channel_num; i++) {
+        if (pwm_out_io_num[i] == channel) { // exist
             LOCK_PWM(critical);   // enter critical
             pwm_out_io_num[i] = -1;
-            pwm_gpio &= ~(1 << pin_num[channel]);   //clear the bit
-            for(j=i;j<pwm_channel_num-1;j++){
-                pwm_out_io_num[j] = pwm_out_io_num[j+1];
-                pwm.duty[j] = pwm.duty[j+1];
+            pwm_gpio &= ~(1 << pin_num[channel]);   // clear the bit
+            for (j = i; j < pwm_channel_num - 1; j++) {
+                pwm_out_io_num[j] = pwm_out_io_num[j + 1];
+                pwm.duty[j] = pwm.duty[j + 1];
             }
-            pwm_out_io_num[pwm_channel_num-1] = -1;
-            pwm.duty[pwm_channel_num-1] = 0;
+            pwm_out_io_num[pwm_channel_num - 1] = -1;
+            pwm.duty[pwm_channel_num - 1] = 0;
             pwm_channel_num--;
             UNLOCK_PWM(critical);   // leave critical
             return true;
diff --git a/ports/esp8266/ets_alt_task.c b/ports/esp8266/ets_alt_task.c
index b724b8f14a183..71d022a32eb7d 100644
--- a/ports/esp8266/ets_alt_task.c
+++ b/ports/esp8266/ets_alt_task.c
@@ -25,9 +25,9 @@ static void (*idle_cb)(void *);
 static void *idle_arg;
 
 #if ESP_SDK_VERSION >= 010500
-# define FIRST_PRIO 0
+#define FIRST_PRIO 0
 #else
-# define FIRST_PRIO 0x14
+#define FIRST_PRIO 0x14
 #endif
 #define LAST_PRIO 0x20
 #define PRIO2ID(prio) ((prio) - FIRST_PRIO)
@@ -38,7 +38,9 @@ static inline int prio2id(uint8_t prio) {
     int id = PRIO2ID(prio);
     if (id < 0 || id >= MP_ARRAY_SIZE(emu_tasks)) {
         printf("task prio out of range: %d\n", prio);
-        while (1);
+        while (1) {
+            ;
+        }
     }
     return id;
 }
@@ -62,9 +64,9 @@ void dump_tasks(void) {
 bool ets_task(os_task_t task, uint8 prio, os_event_t *queue, uint8 qlen) {
     static unsigned cnt;
     printf("#%d ets_task(%p, %d, %p, %d)\n", cnt++, task, prio, queue, qlen);
-#if USE_ETS_TASK
+    #if USE_ETS_TASK
     return _ets_task(task, prio, queue, qlen);
-#else
+    #else
     int id = prio2id(prio);
     emu_tasks[id].task = task;
     emu_tasks[id].queue = queue;
@@ -72,14 +74,14 @@ bool ets_task(os_task_t task, uint8 prio, os_event_t *queue, uint8 qlen) {
     emu_tasks[id].i_get = 0;
     emu_tasks[id].i_put = 0;
     return true;
-#endif
+    #endif
 }
 
 bool ets_post(uint8 prio, os_signal_t sig, os_param_t param) {
 //    static unsigned cnt; printf("#%d ets_post(%d, %x, %x)\n", cnt++, prio, sig, param);
-#if USE_ETS_TASK
+    #if USE_ETS_TASK
     return _ets_post(prio, sig, param);
-#else
+    #else
     ets_intr_lock();
 
     const int id = prio2id(prio);
@@ -99,35 +101,40 @@ bool ets_post(uint8 prio, os_signal_t sig, os_param_t param) {
         // queue got full
         emu_tasks[id].i_put = -1;
     }
-    //printf("after ets_post: "); dump_task(prio, &emu_tasks[id]);
-    //dump_tasks();
+    // printf("after ets_post: "); dump_task(prio, &emu_tasks[id]);
+    // dump_tasks();
 
     ets_intr_unlock();
 
     return 0;
-#endif
+    #endif
 }
 
 int ets_loop_iter_disable = 0;
 int ets_loop_dont_feed_sw_wdt = 0;
 
 // to implement a 64-bit wide microsecond counter
-static uint32_t system_time_prev = 0;
+uint32_t system_time_low_word = 0;
 uint32_t system_time_high_word = 0;
 
-bool ets_loop_iter(void) {
-    if (ets_loop_iter_disable) {
-        return false;
-    }
-
-    // handle overflow of system microsecond counter
+void system_time_update(void) {
+    // Handle overflow of system microsecond counter
     ets_intr_lock();
     uint32_t system_time_cur = system_get_time();
-    if (system_time_cur < system_time_prev) {
+    if (system_time_cur < system_time_low_word) {
         system_time_high_word += 1; // record overflow of low 32-bits
     }
-    system_time_prev = system_time_cur;
+    system_time_low_word = system_time_cur;
     ets_intr_unlock();
+}
+
+bool ets_loop_iter(void) {
+    if (ets_loop_iter_disable) {
+        return false;
+    }
+
+    // Update 64-bit microsecond counter
+    system_time_update();
 
     // 6 words before pend_flag_noise_check is a variable that is used by
     // the software WDT.  A 1.6 second period timer will increment this
@@ -135,17 +142,17 @@ bool ets_loop_iter(void) {
     extern uint32_t pend_flag_noise_check;
     uint32_t *sw_wdt = &pend_flag_noise_check - 6;
 
-    //static unsigned cnt;
+    // static unsigned cnt;
     bool progress = false;
     for (volatile struct task_entry *t = emu_tasks; t < &emu_tasks[MP_ARRAY_SIZE(emu_tasks)]; t++) {
         if (!ets_loop_dont_feed_sw_wdt) {
             system_soft_wdt_feed();
         }
         ets_intr_lock();
-        //printf("etc_loop_iter: "); dump_task(t - emu_tasks + FIRST_PRIO, t);
+        // printf("etc_loop_iter: "); dump_task(t - emu_tasks + FIRST_PRIO, t);
         if (t->i_get != t->i_put) {
             progress = true;
-            //printf("#%d Calling task %d(%p) (%x, %x)\n", cnt++,
+            // printf("#%d Calling task %d(%p) (%x, %x)\n", cnt++,
             //    t - emu_tasks + FIRST_PRIO, t->task, t->queue[t->i_get].sig, t->queue[t->i_get].par);
             int idx = t->i_get;
             if (t->i_put == -1) {
@@ -154,15 +161,15 @@ bool ets_loop_iter(void) {
             if (++t->i_get == t->qlen) {
                 t->i_get = 0;
             }
-            //ets_intr_unlock();
+            // ets_intr_unlock();
             uint32_t old_sw_wdt = *sw_wdt;
             t->task(&t->queue[idx]);
             if (ets_loop_dont_feed_sw_wdt) {
                 // Restore previous SW WDT counter, in case task fed/cleared it
                 *sw_wdt = old_sw_wdt;
             }
-            //ets_intr_lock();
-            //printf("Done calling task %d\n", t - emu_tasks + FIRST_PRIO);
+            // ets_intr_lock();
+            // printf("Done calling task %d\n", t - emu_tasks + FIRST_PRIO);
         }
         ets_intr_unlock();
     }
@@ -188,7 +195,7 @@ void ets_timer_init() {
     ets_isr_attach(10, my_timer_isr, NULL);
     SET_PERI_REG_MASK(0x3FF00004, 4);
     ETS_INTR_ENABLE(10);
-    ets_task((os_task_t)0x40002E3C, 0x1f, (os_event_t*)0x3FFFDDC0, 4);
+    ets_task((os_task_t)0x40002E3C, 0x1f, (os_event_t *)0x3FFFDDC0, 4);
 
     WRITE_PERI_REG(PERIPHS_TIMER_BASEDDR + 0x30, 0);
     WRITE_PERI_REG(PERIPHS_TIMER_BASEDDR + 0x28, 0x88);
@@ -198,36 +205,36 @@ void ets_timer_init() {
 #endif
 
 bool ets_run(void) {
-#if USE_ETS_TASK
+    #if USE_ETS_TASK
     #if SDK_BELOW_1_1_1
     ets_isr_attach(10, my_timer_isr, NULL);
     #endif
     _ets_run();
-#else
+    #else
 //    ets_timer_init();
-    *(char*)0x3FFFC6FC = 0;
+    *(char *)0x3FFFC6FC = 0;
     ets_intr_lock();
     printf("ets_alt_task: ets_run\n");
-#if DEBUG
+    #if DEBUG
     dump_tasks();
-#endif
+    #endif
     ets_intr_unlock();
     while (1) {
         if (!ets_loop_iter()) {
-            //printf("idle\n");
+            // printf("idle\n");
             ets_intr_lock();
             if (idle_cb) {
                 idle_cb(idle_arg);
             }
-            asm("waiti 0");
+            asm ("waiti 0");
             ets_intr_unlock();
         }
     }
-#endif
+    #endif
 }
 
 void ets_set_idle_cb(void (*handler)(void *), void *arg) {
-    //printf("ets_set_idle_cb(%p, %p)\n", handler, arg);
+    // printf("ets_set_idle_cb(%p, %p)\n", handler, arg);
     idle_cb = handler;
     idle_arg = arg;
 }
diff --git a/ports/esp8266/ets_alt_task.h b/ports/esp8266/ets_alt_task.h
index e7a15c3ad57f5..7eb8ff3a54816 100644
--- a/ports/esp8266/ets_alt_task.h
+++ b/ports/esp8266/ets_alt_task.h
@@ -3,8 +3,10 @@
 
 extern int ets_loop_iter_disable;
 extern int ets_loop_dont_feed_sw_wdt;
+extern uint32_t system_time_low_word;
 extern uint32_t system_time_high_word;
 
+void system_time_update(void);
 bool ets_loop_iter(void);
 
 #endif // MICROPY_INCLUDED_ESP8266_ETS_ALT_TASK_H
diff --git a/ports/esp8266/etshal.h b/ports/esp8266/etshal.h
index 8d64573119eab..f7b34b8356686 100644
--- a/ports/esp8266/etshal.h
+++ b/ports/esp8266/etshal.h
@@ -4,7 +4,7 @@
 #include <os_type.h>
 
 // see http://esp8266-re.foogod.com/wiki/Random_Number_Generator
-#define WDEV_HWRNG ((volatile uint32_t*)0x3ff20e44)
+#define WDEV_HWRNG ((volatile uint32_t *)0x3ff20e44)
 
 void ets_delay_us(uint16_t us);
 void ets_intr_lock(void);
diff --git a/ports/esp8266/fatfs_port.c b/ports/esp8266/fatfs_port.c
index a8865c817ea26..8cef0acec3c62 100644
--- a/ports/esp8266/fatfs_port.c
+++ b/ports/esp8266/fatfs_port.c
@@ -38,6 +38,6 @@ DWORD get_fattime(void) {
     timeutils_struct_time_t tm;
     timeutils_seconds_since_2000_to_struct_time(secs, &tm);
 
-    return (((DWORD)(tm.tm_year - 1980) << 25) | ((DWORD)tm.tm_mon << 21) | ((DWORD)tm.tm_mday << 16) |
-           ((DWORD)tm.tm_hour << 11) | ((DWORD)tm.tm_min << 5) | ((DWORD)tm.tm_sec >> 1));
+    return ((DWORD)(tm.tm_year - 1980) << 25) | ((DWORD)tm.tm_mon << 21) | ((DWORD)tm.tm_mday << 16) |
+           ((DWORD)tm.tm_hour << 11) | ((DWORD)tm.tm_min << 5) | ((DWORD)tm.tm_sec >> 1);
 }
diff --git a/ports/esp8266/gccollect.c b/ports/esp8266/gccollect.c
index dbe7bc186ca3e..3618a56644e6f 100644
--- a/ports/esp8266/gccollect.c
+++ b/ports/esp8266/gccollect.c
@@ -44,7 +44,7 @@ void gc_collect(void) {
     mp_uint_t sp = gc_helper_get_regs_and_sp(regs);
 
     // trace the stack, including the registers (since they live on the stack in this function)
-    gc_collect_root((void**)sp, (STACK_END - sp) / sizeof(uint32_t));
+    gc_collect_root((void **)sp, (STACK_END - sp) / sizeof(uint32_t));
 
     // end the GC
     gc_collect_end();
diff --git a/ports/esp8266/help.c b/ports/esp8266/help.c
index 0a851f4c487c4..4dd586c1a8bbe 100644
--- a/ports/esp8266/help.c
+++ b/ports/esp8266/help.c
@@ -27,28 +27,28 @@
 #include "py/builtin.h"
 
 const char esp_help_text[] =
-"Welcome to MicroPython!\n"
-"\n"
-"For online docs please visit http://docs.micropython.org/en/latest/esp8266/ .\n"
-"For diagnostic information to include in bug reports execute 'import port_diag'.\n"
-"\n"
-"Basic WiFi configuration:\n"
-"\n"
-"import network\n"
-"sta_if = network.WLAN(network.STA_IF); sta_if.active(True)\n"
-"sta_if.scan()                             # Scan for available access points\n"
-"sta_if.connect(\"<AP_name>\", \"<password>\") # Connect to an AP\n"
-"sta_if.isconnected()                      # Check for successful connection\n"
-"# Change name/password of ESP8266's AP:\n"
-"ap_if = network.WLAN(network.AP_IF)\n"
-"ap_if.config(essid=\"<AP_NAME>\", authmode=network.AUTH_WPA_WPA2_PSK, password=\"<password>\")\n"
-"\n"
-"Control commands:\n"
-"  CTRL-A        -- on a blank line, enter raw REPL mode\n"
-"  CTRL-B        -- on a blank line, enter normal REPL mode\n"
-"  CTRL-C        -- interrupt a running program\n"
-"  CTRL-D        -- on a blank line, do a soft reset of the board\n"
-"  CTRL-E        -- on a blank line, enter paste mode\n"
-"\n"
-"For further help on a specific object, type help(obj)\n"
+    "Welcome to MicroPython!\n"
+    "\n"
+    "For online docs please visit http://docs.micropython.org/en/latest/esp8266/ .\n"
+    "For diagnostic information to include in bug reports execute 'import port_diag'.\n"
+    "\n"
+    "Basic WiFi configuration:\n"
+    "\n"
+    "import network\n"
+    "sta_if = network.WLAN(network.STA_IF); sta_if.active(True)\n"
+    "sta_if.scan()                             # Scan for available access points\n"
+    "sta_if.connect(\"<AP_name>\", \"<password>\") # Connect to an AP\n"
+    "sta_if.isconnected()                      # Check for successful connection\n"
+    "# Change name/password of ESP8266's AP:\n"
+    "ap_if = network.WLAN(network.AP_IF)\n"
+    "ap_if.config(essid=\"<AP_NAME>\", authmode=network.AUTH_WPA_WPA2_PSK, password=\"<password>\")\n"
+    "\n"
+    "Control commands:\n"
+    "  CTRL-A        -- on a blank line, enter raw REPL mode\n"
+    "  CTRL-B        -- on a blank line, enter normal REPL mode\n"
+    "  CTRL-C        -- interrupt a running program\n"
+    "  CTRL-D        -- on a blank line, do a soft reset of the board\n"
+    "  CTRL-E        -- on a blank line, enter paste mode\n"
+    "\n"
+    "For further help on a specific object, type help(obj)\n"
 ;
diff --git a/ports/esp8266/hspi.c b/ports/esp8266/hspi.c
index 554a50460f85b..cecf0b755ca76 100644
--- a/ports/esp8266/hspi.c
+++ b/ports/esp8266/hspi.c
@@ -36,7 +36,7 @@ void spi_init(uint8_t spi_no) {
     spi_tx_byte_order(spi_no, SPI_BYTE_ORDER_HIGH_TO_LOW);
     spi_rx_byte_order(spi_no, SPI_BYTE_ORDER_HIGH_TO_LOW);
 
-    SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_CS_SETUP|SPI_CS_HOLD);
+    SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_CS_SETUP | SPI_CS_HOLD);
     CLEAR_PERI_REG_MASK(SPI_USER(spi_no), SPI_FLASH_MODE);
 }
 
@@ -84,14 +84,14 @@ void spi_init_gpio(uint8_t spi_no, uint8_t sysclk_as_spiclk) {
     }
     if (spi_no == SPI) {
         // Set bit 8 if 80MHz sysclock required
-        WRITE_PERI_REG(PERIPHS_IO_MUX, 0x005 | (clock_div_flag<<8));
+        WRITE_PERI_REG(PERIPHS_IO_MUX, 0x005 | (clock_div_flag << 8));
         PIN_FUNC_SELECT(PERIPHS_IO_MUX_SD_CLK_U, 1);
         PIN_FUNC_SELECT(PERIPHS_IO_MUX_SD_CMD_U, 1);
         PIN_FUNC_SELECT(PERIPHS_IO_MUX_SD_DATA0_U, 1);
         PIN_FUNC_SELECT(PERIPHS_IO_MUX_SD_DATA1_U, 1);
     } else if (spi_no == HSPI) {
         // Set bit 9 if 80MHz sysclock required
-        WRITE_PERI_REG(PERIPHS_IO_MUX, 0x105 | (clock_div_flag<<9));
+        WRITE_PERI_REG(PERIPHS_IO_MUX, 0x105 | (clock_div_flag << 9));
         // GPIO12 is HSPI MISO pin (Master Data In)
         PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDI_U, 2);
         // GPIO13 is HSPI MOSI pin (Master Data Out)
@@ -117,11 +117,11 @@ void spi_clock(uint8_t spi_no, uint16_t prediv, uint8_t cntdiv) {
         WRITE_PERI_REG(SPI_CLOCK(spi_no), SPI_CLK_EQU_SYSCLK);
     } else {
         WRITE_PERI_REG(SPI_CLOCK(spi_no),
-           (((prediv - 1) & SPI_CLKDIV_PRE) << SPI_CLKDIV_PRE_S) |
-           (((cntdiv - 1) & SPI_CLKCNT_N) << SPI_CLKCNT_N_S) |
-           (((cntdiv >> 1) & SPI_CLKCNT_H) << SPI_CLKCNT_H_S) |
-           ((0 & SPI_CLKCNT_L) << SPI_CLKCNT_L_S)
-        );
+            (((prediv - 1) & SPI_CLKDIV_PRE) << SPI_CLKDIV_PRE_S) |
+            (((cntdiv - 1) & SPI_CLKCNT_N) << SPI_CLKCNT_N_S) |
+            (((cntdiv >> 1) & SPI_CLKCNT_H) << SPI_CLKCNT_H_S) |
+            ((0 & SPI_CLKCNT_L) << SPI_CLKCNT_L_S)
+            );
     }
 }
 
@@ -185,15 +185,17 @@ Note: all data is assumed to be stored in the lower bits of the data variables
 (for anything <32 bits).
 */
 uint32_t spi_transaction(uint8_t spi_no, uint8_t cmd_bits, uint16_t cmd_data,
-                         uint32_t addr_bits, uint32_t addr_data,
-                         uint32_t dout_bits, uint32_t dout_data,
-                         uint32_t din_bits, uint32_t dummy_bits) {
-    while (spi_busy(spi_no)) {};  // Wait for SPI to be ready
+    uint32_t addr_bits, uint32_t addr_data,
+    uint32_t dout_bits, uint32_t dout_data,
+    uint32_t din_bits, uint32_t dummy_bits) {
+    while (spi_busy(spi_no)) {
+    }
+    ;                             // Wait for SPI to be ready
 
 // Enable SPI Functions
     // Disable MOSI, MISO, ADDR, COMMAND, DUMMY in case previously set.
     CLEAR_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_MOSI | SPI_USR_MISO |
-                        SPI_USR_COMMAND | SPI_USR_ADDR | SPI_USR_DUMMY);
+        SPI_USR_COMMAND | SPI_USR_ADDR | SPI_USR_DUMMY);
 
     // Enable functions based on number of bits. 0 bits = disabled.
     // This is rather inefficient but allows for a very generic function.
@@ -213,25 +215,25 @@ uint32_t spi_transaction(uint8_t spi_no, uint8_t cmd_bits, uint16_t cmd_data,
     WRITE_PERI_REG(SPI_USER1(spi_no),
         // Number of bits in Address
         ((addr_bits - 1) & SPI_USR_ADDR_BITLEN) << SPI_USR_ADDR_BITLEN_S |
-        // Number of bits to Send
-        ((dout_bits - 1) & SPI_USR_MOSI_BITLEN) << SPI_USR_MOSI_BITLEN_S |
-        // Number of bits to receive
-        ((din_bits - 1) & SPI_USR_MISO_BITLEN) << SPI_USR_MISO_BITLEN_S |
-        // Number of Dummy bits to insert
-        ((dummy_bits - 1) & SPI_USR_DUMMY_CYCLELEN) << SPI_USR_DUMMY_CYCLELEN_S);
+            // Number of bits to Send
+                ((dout_bits - 1) & SPI_USR_MOSI_BITLEN) << SPI_USR_MOSI_BITLEN_S |
+            // Number of bits to receive
+                ((din_bits - 1) & SPI_USR_MISO_BITLEN) << SPI_USR_MISO_BITLEN_S |
+            // Number of Dummy bits to insert
+                ((dummy_bits - 1) & SPI_USR_DUMMY_CYCLELEN) << SPI_USR_DUMMY_CYCLELEN_S);
 
 // Setup Command Data
     if (cmd_bits) {
         // Enable COMMAND function in SPI module
         SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_COMMAND);
         // Align command data to high bits
-        uint16_t command = cmd_data << (16-cmd_bits);
+        uint16_t command = cmd_data << (16 - cmd_bits);
         // Swap byte order
-        command = ((command>>8)&0xff) | ((command<<8)&0xff00);
+        command = ((command >> 8) & 0xff) | ((command << 8) & 0xff00);
         WRITE_PERI_REG(SPI_USER2(spi_no), (
             (((cmd_bits - 1) & SPI_USR_COMMAND_BITLEN) << SPI_USR_COMMAND_BITLEN_S) |
             (command & SPI_USR_COMMAND_VALUE)
-        ));
+            ));
     }
 
 // Setup Address Data
@@ -246,42 +248,44 @@ uint32_t spi_transaction(uint8_t spi_no, uint8_t cmd_bits, uint16_t cmd_data,
     if (dout_bits) {
         // Enable MOSI function in SPI module
         SET_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_MOSI);
-    // Copy data to W0
-    if (READ_PERI_REG(SPI_USER(spi_no))&SPI_WR_BYTE_ORDER) {
-        WRITE_PERI_REG(SPI_W0(spi_no), dout_data << (32 - dout_bits));
-    } else {
-        uint8_t dout_extra_bits = dout_bits%8;
-
-        if (dout_extra_bits) {
-            // If your data isn't a byte multiple (8/16/24/32 bits) and you
-            // don't have SPI_WR_BYTE_ORDER set, you need this to move the
-            // non-8bit remainder to the MSBs. Not sure if there's even a use
-            // case for this, but it's here if you need it... For example,
-            // 0xDA4 12 bits without SPI_WR_BYTE_ORDER would usually be output
-            // as if it were 0x0DA4, of which 0xA4, and then 0x0 would be
-            // shifted out (first 8 bits of low byte, then 4 MSB bits of high
-            // byte - ie reverse byte order).
-            // The code below shifts it out as 0xA4 followed by 0xD as you
-            // might require.
-            WRITE_PERI_REG(SPI_W0(spi_no), (
-                (0xFFFFFFFF << (dout_bits - dout_extra_bits) & dout_data)
-                    << (8-dout_extra_bits) |
-                ((0xFFFFFFFF >> (32 - (dout_bits - dout_extra_bits)))
-                    & dout_data)
-            ));
+        // Copy data to W0
+        if (READ_PERI_REG(SPI_USER(spi_no)) & SPI_WR_BYTE_ORDER) {
+            WRITE_PERI_REG(SPI_W0(spi_no), dout_data << (32 - dout_bits));
         } else {
-            WRITE_PERI_REG(SPI_W0(spi_no), dout_data);
+            uint8_t dout_extra_bits = dout_bits % 8;
+
+            if (dout_extra_bits) {
+                // If your data isn't a byte multiple (8/16/24/32 bits) and you
+                // don't have SPI_WR_BYTE_ORDER set, you need this to move the
+                // non-8bit remainder to the MSBs. Not sure if there's even a use
+                // case for this, but it's here if you need it... For example,
+                // 0xDA4 12 bits without SPI_WR_BYTE_ORDER would usually be output
+                // as if it were 0x0DA4, of which 0xA4, and then 0x0 would be
+                // shifted out (first 8 bits of low byte, then 4 MSB bits of high
+                // byte - ie reverse byte order).
+                // The code below shifts it out as 0xA4 followed by 0xD as you
+                // might require.
+                WRITE_PERI_REG(SPI_W0(spi_no), (
+                    (0xFFFFFFFF << (dout_bits - dout_extra_bits) & dout_data)
+                        << (8 - dout_extra_bits) |
+                            ((0xFFFFFFFF >> (32 - (dout_bits - dout_extra_bits)))
+                        & dout_data)
+                    ));
+            } else {
+                WRITE_PERI_REG(SPI_W0(spi_no), dout_data);
+            }
         }
     }
-}
 
 // Begin SPI Transaction
     SET_PERI_REG_MASK(SPI_CMD(spi_no), SPI_USR);
 
 // Return DIN data
     if (din_bits) {
-        while (spi_busy(spi_no)) {}; // Wait for SPI transaction to complete
-        if (READ_PERI_REG(SPI_USER(spi_no))&SPI_RD_BYTE_ORDER) {
+        while (spi_busy(spi_no)) {
+        }
+        ;                            // Wait for SPI transaction to complete
+        if (READ_PERI_REG(SPI_USER(spi_no)) & SPI_RD_BYTE_ORDER) {
             // Assuming data in is written to MSB. TBC
             return READ_PERI_REG(SPI_W0(spi_no)) >> (32 - din_bits);
         } else {
@@ -301,19 +305,21 @@ uint32_t spi_transaction(uint8_t spi_no, uint8_t cmd_bits, uint16_t cmd_data,
 Just do minimal work needed to send 8 bits.
 */
 inline void spi_tx8fast(uint8_t spi_no, uint8_t dout_data) {
-    while (spi_busy(spi_no)) {};  // Wait for SPI to be ready
+    while (spi_busy(spi_no)) {
+    }
+    ;                             // Wait for SPI to be ready
 
 // Enable SPI Functions
     // Disable MOSI, MISO, ADDR, COMMAND, DUMMY in case previously set.
     CLEAR_PERI_REG_MASK(SPI_USER(spi_no), SPI_USR_MOSI | SPI_USR_MISO |
-                        SPI_USR_COMMAND | SPI_USR_ADDR | SPI_USR_DUMMY);
+        SPI_USR_COMMAND | SPI_USR_ADDR | SPI_USR_DUMMY);
 
 // Setup Bitlengths
     WRITE_PERI_REG(SPI_USER1(spi_no),
         // Number of bits to Send
         ((8 - 1) & SPI_USR_MOSI_BITLEN) << SPI_USR_MOSI_BITLEN_S |
-        // Number of bits to receive
-        ((8 - 1) & SPI_USR_MISO_BITLEN) << SPI_USR_MISO_BITLEN_S);
+            // Number of bits to receive
+                ((8 - 1) & SPI_USR_MISO_BITLEN) << SPI_USR_MISO_BITLEN_S);
 
 
 // Setup DOUT data
diff --git a/ports/esp8266/hspi.h b/ports/esp8266/hspi.h
index c68366ef4434d..f92a13994d522 100644
--- a/ports/esp8266/hspi.h
+++ b/ports/esp8266/hspi.h
@@ -41,7 +41,7 @@
 #define SPI_BYTE_ORDER_HIGH_TO_LOW 1
 #define SPI_BYTE_ORDER_LOW_TO_HIGH 0
 
-#ifndef CPU_CLK_FREQ //Should already be defined in eagle_soc.h
+#ifndef CPU_CLK_FREQ // Should already be defined in eagle_soc.h
 #define CPU_CLK_FREQ (80 * 1000000)
 #endif
 
@@ -58,18 +58,18 @@ void spi_clock(uint8_t spi_no, uint16_t prediv, uint8_t cntdiv);
 void spi_tx_byte_order(uint8_t spi_no, uint8_t byte_order);
 void spi_rx_byte_order(uint8_t spi_no, uint8_t byte_order);
 uint32_t spi_transaction(uint8_t spi_no, uint8_t cmd_bits, uint16_t cmd_data,
-                         uint32_t addr_bits, uint32_t addr_data,
-                         uint32_t dout_bits, uint32_t dout_data,
-                         uint32_t din_bits, uint32_t dummy_bits);
+    uint32_t addr_bits, uint32_t addr_data,
+    uint32_t dout_bits, uint32_t dout_data,
+    uint32_t din_bits, uint32_t dummy_bits);
 void spi_tx8fast(uint8_t spi_no, uint8_t dout_data);
 
 // Expansion Macros
-#define spi_busy(spi_no) READ_PERI_REG(SPI_CMD(spi_no))&SPI_USR
+#define spi_busy(spi_no) READ_PERI_REG(SPI_CMD(spi_no)) & SPI_USR
 
-#define spi_txd(spi_no, bits, data) spi_transaction(spi_no, 0, 0, 0, 0, bits, (uint32_t) data, 0, 0)
-#define spi_tx8(spi_no, data)       spi_transaction(spi_no, 0, 0, 0, 0, 8,    (uint32_t) data, 0, 0)
-#define spi_tx16(spi_no, data)      spi_transaction(spi_no, 0, 0, 0, 0, 16,   (uint32_t) data, 0, 0)
-#define spi_tx32(spi_no, data)      spi_transaction(spi_no, 0, 0, 0, 0, 32,   (uint32_t) data, 0, 0)
+#define spi_txd(spi_no, bits, data) spi_transaction(spi_no, 0, 0, 0, 0, bits, (uint32_t)data, 0, 0)
+#define spi_tx8(spi_no, data)       spi_transaction(spi_no, 0, 0, 0, 0, 8,    (uint32_t)data, 0, 0)
+#define spi_tx16(spi_no, data)      spi_transaction(spi_no, 0, 0, 0, 0, 16,   (uint32_t)data, 0, 0)
+#define spi_tx32(spi_no, data)      spi_transaction(spi_no, 0, 0, 0, 0, 32,   (uint32_t)data, 0, 0)
 
 #define spi_rxd(spi_no, bits) spi_transaction(spi_no, 0, 0, 0, 0, 0, 0, bits, 0)
 #define spi_rx8(spi_no)       spi_transaction(spi_no, 0, 0, 0, 0, 0, 0, 8,    0)
diff --git a/ports/esp8266/hspi_register.h b/ports/esp8266/hspi_register.h
index 4dd335b400464..50ef2fdca3e19 100644
--- a/ports/esp8266/hspi_register.h
+++ b/ports/esp8266/hspi_register.h
@@ -8,6 +8,8 @@
  *  names of these defines are likely to change.
  */
 
+// *FORMAT-OFF*
+
 #ifndef SPI_REGISTER_H_INCLUDED
 #define SPI_REGISTER_H_INCLUDED
 
diff --git a/ports/esp8266/lexerstr32.c b/ports/esp8266/lexerstr32.c
index 6fb84bb74e805..a921efbbdcec5 100644
--- a/ports/esp8266/lexerstr32.c
+++ b/ports/esp8266/lexerstr32.c
@@ -36,7 +36,7 @@ typedef struct _mp_lexer_str32_buf_t {
 } mp_lexer_str32_buf_t;
 
 STATIC mp_uint_t str32_buf_next_byte(void *sb_in) {
-    mp_lexer_str32_buf_t *sb = (mp_lexer_str32_buf_t*)sb_in;
+    mp_lexer_str32_buf_t *sb = (mp_lexer_str32_buf_t *)sb_in;
     byte c = sb->val & 0xff;
     if (c == 0) {
         return MP_READER_EOF;
@@ -53,14 +53,14 @@ STATIC mp_uint_t str32_buf_next_byte(void *sb_in) {
 }
 
 STATIC void str32_buf_free(void *sb_in) {
-    mp_lexer_str32_buf_t *sb = (mp_lexer_str32_buf_t*)sb_in;
+    mp_lexer_str32_buf_t *sb = (mp_lexer_str32_buf_t *)sb_in;
     m_del_obj(mp_lexer_str32_buf_t, sb);
 }
 
 mp_lexer_t *mp_lexer_new_from_str32(qstr src_name, const char *str, mp_uint_t len, mp_uint_t free_len) {
     mp_lexer_str32_buf_t *sb = m_new_obj(mp_lexer_str32_buf_t);
     sb->byte_off = (uint32_t)str & 3;
-    sb->src_cur = (uint32_t*)(str - sb->byte_off);
+    sb->src_cur = (uint32_t *)(str - sb->byte_off);
     sb->val = *sb->src_cur++ >> sb->byte_off * 8;
     mp_reader_t reader = {sb, str32_buf_next_byte, str32_buf_free};
     return mp_lexer_new(src_name, reader);
diff --git a/ports/esp8266/machine_adc.c b/ports/esp8266/machine_adc.c
index b422f0f9ecea2..471e14d8dfbed 100644
--- a/ports/esp8266/machine_adc.c
+++ b/ports/esp8266/machine_adc.c
@@ -28,54 +28,71 @@
 #include <string.h>
 
 #include "py/runtime.h"
+#include "py/mphal.h"
 #include "user_interface.h"
 
-const mp_obj_type_t pyb_adc_type;
-
-typedef struct _pyb_adc_obj_t {
+typedef struct _machine_adc_obj_t {
     mp_obj_base_t base;
     bool isvdd;
-} pyb_adc_obj_t;
+} machine_adc_obj_t;
+
+extern const mp_obj_type_t machine_adc_type;
+
+STATIC machine_adc_obj_t machine_adc_vdd3 = {{&machine_adc_type}, true};
+STATIC machine_adc_obj_t machine_adc_adc = {{&machine_adc_type}, false};
 
-STATIC pyb_adc_obj_t pyb_adc_vdd3 = {{&pyb_adc_type}, true};
-STATIC pyb_adc_obj_t pyb_adc_adc = {{&pyb_adc_type}, false};
+STATIC uint16_t adc_read(machine_adc_obj_t *self) {
+    if (self->isvdd) {
+        return system_get_vdd33();
+    } else {
+        return system_adc_read();
+    }
+}
+void machine_adc_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    machine_adc_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_printf(print, "ADC(%u)", self->isvdd);
+}
 
-STATIC mp_obj_t pyb_adc_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw,
-    const mp_obj_t *args) {
+mp_obj_t machine_adc_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 1, 1, false);
 
     mp_int_t chn = mp_obj_get_int(args[0]);
 
     switch (chn) {
-    case 0:
-        return &pyb_adc_adc;
-    case 1:
-        return &pyb_adc_vdd3;
-    default:
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-            "not a valid ADC Channel: %d", chn));
+        case 0:
+            return &machine_adc_adc;
+        case 1:
+            return &machine_adc_vdd3;
+        default:
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("ADC(%d) doesn't exist"), chn);
     }
 }
 
-STATIC mp_obj_t pyb_adc_read(mp_obj_t self_in) {
-    pyb_adc_obj_t *adc = self_in;
+// read_u16()
+STATIC mp_obj_t machine_adc_read_u16(mp_obj_t self_in) {
+    machine_adc_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    uint32_t value = adc_read(self);
+    return MP_OBJ_NEW_SMALL_INT(value * 65535 / 1024);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_adc_read_u16_obj, machine_adc_read_u16);
 
-    if (adc->isvdd) {
-        return mp_obj_new_int(system_get_vdd33());
-    } else {
-        return mp_obj_new_int(system_adc_read());
-    }
+// Legacy method
+STATIC mp_obj_t machine_adc_read(mp_obj_t self_in) {
+    machine_adc_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    return mp_obj_new_int(adc_read(self));
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_adc_read_obj, pyb_adc_read);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_adc_read_obj, machine_adc_read);
 
-STATIC const mp_rom_map_elem_t pyb_adc_locals_dict_table[] = {
-    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&pyb_adc_read_obj) }
+STATIC const mp_rom_map_elem_t machine_adc_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_read_u16), MP_ROM_PTR(&machine_adc_read_u16_obj) },
+    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&machine_adc_read_obj) }
 };
-STATIC MP_DEFINE_CONST_DICT(pyb_adc_locals_dict, pyb_adc_locals_dict_table);
+STATIC MP_DEFINE_CONST_DICT(machine_adc_locals_dict, machine_adc_locals_dict_table);
 
-const mp_obj_type_t pyb_adc_type = {
+const mp_obj_type_t machine_adc_type = {
     { &mp_type_type },
     .name = MP_QSTR_ADC,
-    .make_new = pyb_adc_make_new,
-    .locals_dict = (mp_obj_dict_t*)&pyb_adc_locals_dict,
+    .print = machine_adc_print,
+    .make_new = machine_adc_make_new,
+    .locals_dict = (mp_obj_dict_t *)&machine_adc_locals_dict,
 };
diff --git a/ports/esp8266/machine_hspi.c b/ports/esp8266/machine_hspi.c
index 07770c8c89dc8..7319194d763d3 100644
--- a/ports/esp8266/machine_hspi.c
+++ b/ports/esp8266/machine_hspi.c
@@ -101,7 +101,7 @@ STATIC void machine_hspi_print(const mp_print_t *print, mp_obj_t self_in, mp_pri
 }
 
 STATIC void machine_hspi_init(mp_obj_base_t *self_in, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    machine_hspi_obj_t *self = (machine_hspi_obj_t*)self_in;
+    machine_hspi_obj_t *self = (machine_hspi_obj_t *)self_in;
 
     enum { ARG_baudrate, ARG_polarity, ARG_phase };
     static const mp_arg_t allowed_args[] = {
@@ -111,7 +111,7 @@ STATIC void machine_hspi_init(mp_obj_base_t *self_in, size_t n_args, const mp_ob
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args),
-                     allowed_args, args);
+        allowed_args, args);
 
     if (args[ARG_baudrate].u_int != -1) {
         self->baudrate = args[ARG_baudrate].u_int;
@@ -127,13 +127,13 @@ STATIC void machine_hspi_init(mp_obj_base_t *self_in, size_t n_args, const mp_ob
         spi_init_gpio(HSPI, SPI_CLK_80MHZ_NODIV);
         spi_clock(HSPI, 0, 0);
     } else if (self->baudrate > 40000000L) {
-        mp_raise_ValueError("impossible baudrate");
+        mp_raise_ValueError(MP_ERROR_TEXT("impossible baudrate"));
     } else {
         uint32_t divider = 40000000L / self->baudrate;
         uint16_t prediv = MIN(divider, SPI_CLKDIV_PRE + 1);
         uint16_t cntdiv = (divider / prediv) * 2; // cntdiv has to be even
         if (cntdiv > SPI_CLKCNT_N + 1 || cntdiv == 0 || prediv == 0) {
-            mp_raise_ValueError("impossible baudrate");
+            mp_raise_ValueError(MP_ERROR_TEXT("impossible baudrate"));
         }
         self->baudrate = 80000000L / (prediv * cntdiv);
         spi_init_gpio(HSPI, SPI_CLK_USE_DIV);
@@ -143,10 +143,10 @@ STATIC void machine_hspi_init(mp_obj_base_t *self_in, size_t n_args, const mp_ob
     spi_tx_byte_order(HSPI, SPI_BYTE_ORDER_HIGH_TO_LOW);
     spi_rx_byte_order(HSPI, SPI_BYTE_ORDER_HIGH_TO_LOW);
     CLEAR_PERI_REG_MASK(SPI_USER(HSPI), SPI_FLASH_MODE | SPI_USR_MISO |
-                        SPI_USR_ADDR | SPI_USR_COMMAND | SPI_USR_DUMMY);
+        SPI_USR_ADDR | SPI_USR_COMMAND | SPI_USR_DUMMY);
     // Clear Dual or Quad lines transmission mode
     CLEAR_PERI_REG_MASK(SPI_CTRL(HSPI), SPI_QIO_MODE | SPI_DIO_MODE |
-                        SPI_DOUT_MODE | SPI_QOUT_MODE);
+        SPI_DOUT_MODE | SPI_QOUT_MODE);
     spi_mode(HSPI, self->phase, self->polarity);
 }
 
@@ -165,7 +165,7 @@ mp_obj_t machine_hspi_make_new(const mp_obj_type_t *type, size_t n_args, size_t
     self->phase = 0;
     mp_map_t kw_args;
     mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
-    machine_hspi_init((mp_obj_base_t*)self, n_args - 1, args + 1, &kw_args);
+    machine_hspi_init((mp_obj_base_t *)self, n_args - 1, args + 1, &kw_args);
     return MP_OBJ_FROM_PTR(self);
 }
 
@@ -180,7 +180,7 @@ const mp_obj_type_t machine_hspi_type = {
     .print = machine_hspi_print,
     .make_new = mp_machine_spi_make_new, // delegate to master constructor
     .protocol = &machine_hspi_p,
-    .locals_dict = (mp_obj_dict_t*)&mp_machine_spi_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&mp_machine_spi_locals_dict,
 };
 
 #endif // MICROPY_PY_MACHINE_SPI
diff --git a/ports/esp8266/machine_pin.c b/ports/esp8266/machine_pin.c
index 14505c8f024c0..419ee87a7332b 100644
--- a/ports/esp8266/machine_pin.c
+++ b/ports/esp8266/machine_pin.c
@@ -43,8 +43,8 @@
     GPIO_PIN_INT_TYPE_GET(GPIO_REG_READ(GPIO_PIN_ADDR(phys_port)))
 #define SET_TRIGGER(phys_port, trig) \
     (GPIO_REG_WRITE(GPIO_PIN_ADDR(phys_port), \
-        (GPIO_REG_READ(GPIO_PIN_ADDR(phys_port)) & ~GPIO_PIN_INT_TYPE_MASK) \
-        | GPIO_PIN_INT_TYPE_SET(trig))) \
+    (GPIO_REG_READ(GPIO_PIN_ADDR(phys_port)) & ~GPIO_PIN_INT_TYPE_MASK) \
+    | GPIO_PIN_INT_TYPE_SET(trig))) \
 
 #define GPIO_MODE_INPUT (0)
 #define GPIO_MODE_OUTPUT (1)
@@ -52,13 +52,16 @@
 #define GPIO_PULL_NONE (0)
 #define GPIO_PULL_UP (1)
 // Removed in SDK 1.1.0
-//#define GPIO_PULL_DOWN (2)
+// #define GPIO_PULL_DOWN (2)
 
 typedef struct _pin_irq_obj_t {
     mp_obj_base_t base;
     uint16_t phys_port;
 } pin_irq_obj_t;
 
+STATIC void pin_intr_handler_part1(void *arg);
+STATIC void pin_intr_handler_part2(uint32_t status);
+
 const pyb_pin_obj_t pyb_pin_obj[16 + 1] = {
     {{&pyb_pin_type}, 0, FUNC_GPIO0, PERIPHS_IO_MUX_GPIO0_U},
     {{&pyb_pin_type}, 1, FUNC_GPIO1, PERIPHS_IO_MUX_U0TXD_U},
@@ -86,15 +89,11 @@ STATIC uint8_t pin_mode[16 + 1];
 // forward declaration
 STATIC const pin_irq_obj_t pin_irq_obj[16];
 
-// whether the irq is hard or soft
-STATIC bool pin_irq_is_hard[16];
-
 void pin_init0(void) {
     ETS_GPIO_INTR_DISABLE();
-    ETS_GPIO_INTR_ATTACH(pin_intr_handler_iram, NULL);
+    ETS_GPIO_INTR_ATTACH(pin_intr_handler_part1, NULL);
     // disable all interrupts
     memset(&MP_STATE_PORT(pin_irq_handler)[0], 0, 16 * sizeof(mp_obj_t));
-    memset(pin_irq_is_hard, 0, sizeof(pin_irq_is_hard));
     for (int p = 0; p < 16; ++p) {
         GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, 1 << p);
         SET_TRIGGER(p, 0);
@@ -102,29 +101,27 @@ void pin_init0(void) {
     ETS_GPIO_INTR_ENABLE();
 }
 
-void pin_intr_handler(uint32_t status) {
-    mp_sched_lock();
-    gc_lock();
+void MP_FASTCODE(pin_intr_handler_part1)(void *arg) {
+    uint32_t status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
+    GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, status);
+    pin_intr_handler_part2(status);
+}
+
+void MP_FASTCODE(pin_intr_handler_part2)(uint32_t status) {
     status &= 0xffff;
     for (int p = 0; status; ++p, status >>= 1) {
         if (status & 1) {
             mp_obj_t handler = MP_STATE_PORT(pin_irq_handler)[p];
             if (handler != MP_OBJ_NULL) {
-                if (pin_irq_is_hard[p]) {
-                    mp_call_function_1_protected(handler, MP_OBJ_FROM_PTR(&pyb_pin_obj[p]));
-                } else {
-                    mp_sched_schedule(handler, MP_OBJ_FROM_PTR(&pyb_pin_obj[p]));
-                }
+                mp_sched_schedule(handler, MP_OBJ_FROM_PTR(&pyb_pin_obj[p]));
             }
         }
     }
-    gc_unlock();
-    mp_sched_unlock();
 }
 
 pyb_pin_obj_t *mp_obj_get_pin_obj(mp_obj_t pin_in) {
     if (mp_obj_get_type(pin_in) != &pyb_pin_type) {
-        mp_raise_ValueError("expecting a pin");
+        mp_raise_ValueError(MP_ERROR_TEXT("expecting a pin"));
     }
     pyb_pin_obj_t *self = pin_in;
     return self;
@@ -279,7 +276,7 @@ STATIC mp_obj_t pyb_pin_obj_init_helper(pyb_pin_obj_t *self, size_t n_args, cons
         // only pull-down seems to be supported by the hardware, and
         // we only expose pull-up behaviour in software
         if (pull != GPIO_PULL_NONE) {
-            mp_raise_ValueError("Pin(16) doesn't support pull");
+            mp_raise_ValueError(MP_ERROR_TEXT("Pin(16) doesn't support pull"));
         }
     } else {
         PIN_FUNC_SELECT(self->periph, self->func);
@@ -315,10 +312,10 @@ mp_obj_t mp_pin_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw,
     int wanted_pin = mp_obj_get_int(args[0]);
     pyb_pin_obj_t *pin = NULL;
     if (0 <= wanted_pin && wanted_pin < MP_ARRAY_SIZE(pyb_pin_obj)) {
-        pin = (pyb_pin_obj_t*)&pyb_pin_obj[wanted_pin];
+        pin = (pyb_pin_obj_t *)&pyb_pin_obj[wanted_pin];
     }
     if (pin == NULL || pin->base.type == NULL) {
-        mp_raise_ValueError("invalid pin");
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid pin"));
     }
 
     if (n_args > 1 || n_kw > 0) {
@@ -384,7 +381,10 @@ STATIC mp_obj_t pyb_pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
     if (self->phys_port >= 16) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "pin does not have IRQ capabilities"));
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("pin does not have IRQ capabilities"));
+    }
+    if (args[ARG_hard].u_bool) {
+        mp_raise_ValueError(MP_ERROR_TEXT("hard IRQ not supported"));
     }
 
     if (n_args > 1 || kw_args->used != 0) {
@@ -397,7 +397,6 @@ STATIC mp_obj_t pyb_pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
         }
         ETS_GPIO_INTR_DISABLE();
         MP_STATE_PORT(pin_irq_handler)[self->phys_port] = handler;
-        pin_irq_is_hard[self->phys_port] = args[ARG_hard].u_bool;
         SET_TRIGGER(self->phys_port, trigger);
         GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, 1 << self->phys_port);
         ETS_GPIO_INTR_ENABLE();
@@ -438,7 +437,7 @@ STATIC const mp_rom_map_elem_t pyb_pin_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_OUT),       MP_ROM_INT(GPIO_MODE_OUTPUT) },
     { MP_ROM_QSTR(MP_QSTR_OPEN_DRAIN), MP_ROM_INT(GPIO_MODE_OPEN_DRAIN) },
     { MP_ROM_QSTR(MP_QSTR_PULL_UP),   MP_ROM_INT(GPIO_PULL_UP) },
-    //{ MP_ROM_QSTR(MP_QSTR_PULL_DOWN), MP_ROM_INT(GPIO_PULL_DOWN) },
+    // { MP_ROM_QSTR(MP_QSTR_PULL_DOWN), MP_ROM_INT(GPIO_PULL_DOWN) },
 
     // IRQ triggers, can be or'd together
     { MP_ROM_QSTR(MP_QSTR_IRQ_RISING), MP_ROM_INT(GPIO_PIN_INTR_POSEDGE) },
@@ -458,7 +457,7 @@ const mp_obj_type_t pyb_pin_type = {
     .make_new = mp_pin_make_new,
     .call = pyb_pin_call,
     .protocol = &pin_pin_p,
-    .locals_dict = (mp_obj_dict_t*)&pyb_pin_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_pin_locals_dict,
 };
 
 /******************************************************************************/
@@ -488,7 +487,7 @@ STATIC const pin_irq_obj_t pin_irq_obj[16] = {
 STATIC mp_obj_t pin_irq_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     pin_irq_obj_t *self = self_in;
     mp_arg_check_num(n_args, n_kw, 0, 0, false);
-    pin_intr_handler(1 << self->phys_port);
+    pin_intr_handler_part2(1 << self->phys_port);
     return mp_const_none;
 }
 
@@ -514,5 +513,5 @@ STATIC const mp_obj_type_t pin_irq_type = {
     { &mp_type_type },
     .name = MP_QSTR_IRQ,
     .call = pin_irq_call,
-    .locals_dict = (mp_obj_dict_t*)&pin_irq_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pin_irq_locals_dict,
 };
diff --git a/ports/esp8266/machine_pwm.c b/ports/esp8266/machine_pwm.c
index 4c5cb8727779b..1d6a6cfe5894f 100644
--- a/ports/esp8266/machine_pwm.c
+++ b/ports/esp8266/machine_pwm.c
@@ -65,8 +65,7 @@ STATIC void pyb_pwm_init_helper(pyb_pwm_obj_t *self, size_t n_args, const mp_obj
 
     int channel = pwm_add(self->pin->phys_port, self->pin->periph, self->pin->func);
     if (channel == -1) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-            "PWM not supported on pin %d", self->pin->phys_port));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("PWM not supported on pin %d"), self->pin->phys_port);
     }
 
     self->channel = channel;
@@ -122,7 +121,7 @@ STATIC mp_obj_t pyb_pwm_deinit(mp_obj_t self_in) {
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_pwm_deinit_obj, pyb_pwm_deinit);
 
 STATIC mp_obj_t pyb_pwm_freq(size_t n_args, const mp_obj_t *args) {
-    //pyb_pwm_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    // pyb_pwm_obj_t *self = MP_OBJ_TO_PTR(args[0]);
     if (n_args == 1) {
         // get
         return MP_OBJ_NEW_SMALL_INT(pwm_get_freq(0));
@@ -167,5 +166,5 @@ const mp_obj_type_t pyb_pwm_type = {
     .name = MP_QSTR_PWM,
     .print = pyb_pwm_print,
     .make_new = pyb_pwm_make_new,
-    .locals_dict = (mp_obj_dict_t*)&pyb_pwm_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_pwm_locals_dict,
 };
diff --git a/ports/esp8266/machine_rtc.c b/ports/esp8266/machine_rtc.c
index bbfc172cd8aba..1aa73f9b317f8 100644
--- a/ports/esp8266/machine_rtc.c
+++ b/ports/esp8266/machine_rtc.c
@@ -181,7 +181,7 @@ STATIC mp_obj_t pyb_rtc_memory(size_t n_args, const mp_obj_t *args) {
         mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ);
 
         if (bufinfo.len > MEM_USER_MAXLEN) {
-            mp_raise_ValueError("buffer too long");
+            mp_raise_ValueError(MP_ERROR_TEXT("buffer too long"));
         }
 
         len = bufinfo.len;
@@ -205,7 +205,7 @@ STATIC mp_obj_t pyb_rtc_alarm(mp_obj_t self_in, mp_obj_t alarm_id, mp_obj_t time
 
     // check we want alarm0
     if (mp_obj_get_int(alarm_id) != 0) {
-        mp_raise_ValueError("invalid alarm");
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid alarm"));
     }
 
     // set expiry time (in microseconds)
@@ -219,7 +219,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_rtc_alarm_obj, pyb_rtc_alarm);
 STATIC mp_obj_t pyb_rtc_alarm_left(size_t n_args, const mp_obj_t *args) {
     // check we want alarm0
     if (n_args > 1 && mp_obj_get_int(args[1]) != 0) {
-        mp_raise_ValueError("invalid alarm");
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid alarm"));
     }
 
     uint64_t now = pyb_rtc_get_us_since_2000();
@@ -242,7 +242,7 @@ STATIC mp_obj_t pyb_rtc_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
 
     // check we want alarm0
     if (args[ARG_trigger].u_int != 0) {
-        mp_raise_ValueError("invalid alarm");
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid alarm"));
     }
 
     // set the wake value
@@ -266,5 +266,5 @@ const mp_obj_type_t pyb_rtc_type = {
     { &mp_type_type },
     .name = MP_QSTR_RTC,
     .make_new = pyb_rtc_make_new,
-    .locals_dict = (mp_obj_dict_t*)&pyb_rtc_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_rtc_locals_dict,
 };
diff --git a/ports/esp8266/machine_uart.c b/ports/esp8266/machine_uart.c
index 21336c7fd4343..a8ea5e38d3154 100644
--- a/ports/esp8266/machine_uart.c
+++ b/ports/esp8266/machine_uart.c
@@ -29,11 +29,13 @@
 #include <string.h>
 
 #include "ets_sys.h"
+#include "user_interface.h"
 #include "uart.h"
 
 #include "py/runtime.h"
 #include "py/stream.h"
 #include "py/mperrno.h"
+#include "py/mphal.h"
 #include "modmachine.h"
 
 // UartDev is defined and initialized in rom code.
@@ -63,14 +65,14 @@ STATIC void pyb_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_print_k
 }
 
 STATIC void pyb_uart_init_helper(pyb_uart_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_baudrate, ARG_bits, ARG_parity, ARG_stop, ARG_rxbuf, ARG_timeout, ARG_timeout_char };
+    enum { ARG_baudrate, ARG_bits, ARG_parity, ARG_stop, ARG_tx, ARG_rx, ARG_rxbuf, ARG_timeout, ARG_timeout_char };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_baudrate, MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_bits, MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_parity, MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
         { MP_QSTR_stop, MP_ARG_INT, {.u_int = 0} },
-        //{ MP_QSTR_tx, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
-        //{ MP_QSTR_rx, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_tx, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_rx, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
         { MP_QSTR_rxbuf, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_timeout_char, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
@@ -105,7 +107,7 @@ STATIC void pyb_uart_init_helper(pyb_uart_obj_t *self, size_t n_args, const mp_o
             self->bits = 8;
             break;
         default:
-            mp_raise_ValueError("invalid data bits");
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid data bits"));
             break;
     }
 
@@ -128,6 +130,22 @@ STATIC void pyb_uart_init_helper(pyb_uart_obj_t *self, size_t n_args, const mp_o
         }
     }
 
+    // set tx/rx pins
+    mp_hal_pin_obj_t tx = 1, rx = 3;
+    if (args[ARG_tx].u_obj != MP_OBJ_NULL) {
+        tx = mp_hal_get_pin_obj(args[ARG_tx].u_obj);
+    }
+    if (args[ARG_rx].u_obj != MP_OBJ_NULL) {
+        rx = mp_hal_get_pin_obj(args[ARG_rx].u_obj);
+    }
+    if (tx == 1 && rx == 3) {
+        system_uart_de_swap();
+    } else if (tx == 15 && rx == 13) {
+        system_uart_swap();
+    } else {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid tx/rx"));
+    }
+
     // set stop bits
     switch (args[ARG_stop].u_int) {
         case 0:
@@ -141,7 +159,7 @@ STATIC void pyb_uart_init_helper(pyb_uart_obj_t *self, size_t n_args, const mp_o
             self->stop = 2;
             break;
         default:
-            mp_raise_ValueError("invalid stop bits");
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid stop bits"));
             break;
     }
 
@@ -180,7 +198,7 @@ STATIC mp_obj_t pyb_uart_make_new(const mp_obj_type_t *type, size_t n_args, size
     // get uart id
     mp_int_t uart_id = mp_obj_get_int(args[0]);
     if (uart_id != 0 && uart_id != 1) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%d) does not exist", uart_id));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("UART(%d) does not exist"), uart_id);
     }
 
     // create instance
@@ -230,7 +248,7 @@ STATIC mp_uint_t pyb_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, i
     pyb_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
     if (self->uart_id == 1) {
-        mp_raise_msg(&mp_type_OSError, "UART(1) can't read");
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("UART(1) can't read"));
     }
 
     // make sure we want at least 1 char
@@ -250,7 +268,7 @@ STATIC mp_uint_t pyb_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, i
         *buf++ = uart_rx_char();
         if (--size == 0 || !uart_rx_wait(self->timeout_char * 1000)) {
             // return number of bytes read
-            return buf - (uint8_t*)buf_in;
+            return buf - (uint8_t *)buf_in;
         }
     }
 }
@@ -310,5 +328,5 @@ const mp_obj_type_t pyb_uart_type = {
     .getiter = mp_identity_getiter,
     .iternext = mp_stream_unbuffered_iter,
     .protocol = &uart_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&pyb_uart_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_uart_locals_dict,
 };
diff --git a/ports/esp8266/machine_wdt.c b/ports/esp8266/machine_wdt.c
index fad0b2e4dea0f..b64830e7d6733 100644
--- a/ports/esp8266/machine_wdt.c
+++ b/ports/esp8266/machine_wdt.c
@@ -24,7 +24,6 @@
  * THE SOFTWARE.
  */
 
-//#include <stdio.h>
 #include <string.h>
 
 #include "py/runtime.h"
@@ -49,12 +48,12 @@ STATIC mp_obj_t machine_wdt_make_new(const mp_obj_type_t *type_in, size_t n_args
     }
 
     switch (id) {
-    case 0:
-        ets_loop_dont_feed_sw_wdt = 1;
-        system_soft_wdt_feed();
-        return &wdt_default;
-    default:
-        mp_raise_ValueError(NULL);
+        case 0:
+            ets_loop_dont_feed_sw_wdt = 1;
+            system_soft_wdt_feed();
+            return &wdt_default;
+        default:
+            mp_raise_ValueError(NULL);
     }
 }
 
@@ -82,5 +81,5 @@ const mp_obj_type_t esp_wdt_type = {
     { &mp_type_type },
     .name = MP_QSTR_WDT,
     .make_new = machine_wdt_make_new,
-    .locals_dict = (mp_obj_dict_t*)&machine_wdt_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&machine_wdt_locals_dict,
 };
diff --git a/ports/esp8266/main.c b/ports/esp8266/main.c
index 67157ce18c563..a73fbbcf5f25f 100644
--- a/ports/esp8266/main.c
+++ b/ports/esp8266/main.c
@@ -4,6 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2014 Damien P. George
+ * Copyright (c) 2015-2016 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -46,7 +47,7 @@
 STATIC char heap[38 * 1024];
 
 STATIC void mp_reset(void) {
-    mp_stack_set_top((void*)0x40000000);
+    mp_stack_set_top((void *)0x40000000);
     mp_stack_set_limit(8192);
     mp_hal_init();
     gc_init(heap, heap + sizeof(heap));
@@ -77,9 +78,9 @@ STATIC void mp_reset(void) {
 
     #if MICROPY_MODULE_FROZEN
     pyexec_frozen_module("_boot.py");
-    pyexec_file("boot.py");
+    pyexec_file_if_exists("boot.py");
     if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
-        pyexec_file("main.py");
+        pyexec_file_if_exists("main.py");
     }
     #endif
 }
@@ -157,7 +158,7 @@ void MP_FASTCODE(nlr_jump_fail)(void *val) {
     }
 }
 
-//void __assert(const char *file, int line, const char *func, const char *expr) {
+// void __assert(const char *file, int line, const char *func, const char *expr) {
 void __assert(const char *file, int line, const char *expr) {
     printf("Assertion '%s' failed, at file %s:%d\n", expr, file, line);
     for (;;) {
diff --git a/ports/esp8266/makeimg.py b/ports/esp8266/makeimg.py
index 091854fa4d8af..4d31cc0799604 100644
--- a/ports/esp8266/makeimg.py
+++ b/ports/esp8266/makeimg.py
@@ -2,39 +2,53 @@
 import struct
 import hashlib
 
+# This region at the start of flash contains a small header and then segments
+# containing .text, .data and .rodata, and so must be large enough to hold all
+# of this.  This data is loaded to the appropriate places in RAM by the ROM
+# bootloader at boot.  After this in flash comes .irom0.text, which must begin
+# on a flash erase-page boundary.
 SEGS_MAX_SIZE = 0x9000
 
 assert len(sys.argv) == 4
 
 md5 = hashlib.md5()
 
-with open(sys.argv[3], 'wb') as fout:
+with open(sys.argv[3], "wb") as fout:
 
-    with open(sys.argv[1], 'rb') as f:
+    with open(sys.argv[1], "rb") as f:
         data_flash = f.read()
         fout.write(data_flash)
         # First 4 bytes include flash size, etc. which may be changed
         # by esptool.py, etc.
         md5.update(data_flash[4:])
-        print('flash    ', len(data_flash))
-
-    with open(sys.argv[2], 'rb') as f:
+        print("flash    ", len(data_flash))
+
+        # Print info about segments in this first part of flash
+        num_segs = struct.unpack_from("<BBBBI", data_flash, 0)[1]
+        offset = 8
+        for seg_num in range(num_segs):
+            seg_name = [".text", ".data", ".rodata"][seg_num]
+            seg_offset, seg_size = struct.unpack_from("<II", data_flash, offset)
+            print(" {:7}  {} at 0x{:x}".format(seg_name, seg_size, seg_offset))
+            offset += 8 + seg_size
+
+    with open(sys.argv[2], "rb") as f:
         data_rom = f.read()
 
-    pad = b'\xff' * (SEGS_MAX_SIZE - len(data_flash))
+    pad = b"\xff" * (SEGS_MAX_SIZE - len(data_flash))
     assert len(pad) >= 4
     fout.write(pad[:-4])
     md5.update(pad[:-4])
     len_data = struct.pack("I", SEGS_MAX_SIZE + len(data_rom))
     fout.write(len_data)
     md5.update(len_data)
-    print('padding  ', len(pad))
+    print("padding  ", len(pad))
 
     fout.write(data_rom)
     md5.update(data_rom)
-    print('irom0text', len(data_rom))
+    print("irom0text", len(data_rom))
 
     fout.write(md5.digest())
 
-    print('total    ', SEGS_MAX_SIZE + len(data_rom))
-    print('md5      ', md5.hexdigest())
+    print("total    ", SEGS_MAX_SIZE + len(data_rom))
+    print("md5      ", md5.hexdigest())
diff --git a/ports/esp8266/modesp.c b/ports/esp8266/modesp.c
index 6c9fa9e1316d1..022447313c982 100644
--- a/ports/esp8266/modesp.c
+++ b/ports/esp8266/modesp.c
@@ -28,6 +28,7 @@
 
 #include "py/gc.h"
 #include "py/runtime.h"
+#include "py/persistentcode.h"
 #include "py/mperrno.h"
 #include "py/mphal.h"
 #include "drivers/dht/dht.h"
@@ -41,9 +42,9 @@
 
 #define MODESP_INCLUDE_CONSTANTS (1)
 
-void error_check(bool status, const char *msg) {
+void error_check(bool status, mp_rom_error_text_t msg) {
     if (!status) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, msg));
+        mp_raise_msg(&mp_type_OSError, msg);
     }
 }
 
@@ -100,7 +101,7 @@ STATIC mp_obj_t esp_flash_read(mp_obj_t offset_in, mp_obj_t len_or_buf_in) {
     }
 
     // We know that allocation will be 4-byte aligned for sure
-    SpiFlashOpResult res = spi_flash_read(offset, (uint32_t*)buf, len);
+    SpiFlashOpResult res = spi_flash_read(offset, (uint32_t *)buf, len);
     if (res == SPI_FLASH_RESULT_OK) {
         if (alloc_buf) {
             return mp_obj_new_bytes(buf, len);
@@ -119,7 +120,7 @@ STATIC mp_obj_t esp_flash_write(mp_obj_t offset_in, const mp_obj_t buf_in) {
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);
     if (bufinfo.len & 0x3) {
-        mp_raise_ValueError("len must be multiple of 4");
+        mp_raise_ValueError(MP_ERROR_TEXT("len must be multiple of 4"));
     }
     ets_loop_iter(); // flash access takes time so run any pending tasks
     SpiFlashOpResult res = spi_flash_write(offset, bufinfo.buf, bufinfo.len);
@@ -147,7 +148,7 @@ STATIC mp_obj_t esp_flash_size(void) {
     extern char flashchip;
     // For SDK 1.5.2, either address has shifted and not mirrored in
     // eagle.rom.addr.v6.ld, or extra initial member was added.
-    SpiFlashChip *flash = (SpiFlashChip*)(&flashchip + 4);
+    SpiFlashChip *flash = (SpiFlashChip *)(&flashchip + 4);
     #if 0
     printf("deviceId: %x\n", flash->deviceId);
     printf("chip_size: %u\n", flash->chip_size);
@@ -162,7 +163,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp_flash_size_obj, esp_flash_size);
 
 // If there's just 1 loadable segment at the start of flash,
 // we assume there's a yaota8266 bootloader.
-#define IS_OTA_FIRMWARE() ((*(uint32_t*)0x40200000 & 0xff00) == 0x100)
+#define IS_OTA_FIRMWARE() ((*(uint32_t *)0x40200000 & 0xff00) == 0x100)
 
 extern byte _firmware_size[];
 
@@ -173,13 +174,13 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp_flash_user_start_obj, esp_flash_user_start)
 
 STATIC mp_obj_t esp_check_fw(void) {
     MD5_CTX ctx;
-    char *fw_start = (char*)0x40200000;
+    char *fw_start = (char *)0x40200000;
     if (IS_OTA_FIRMWARE()) {
         // Skip yaota8266 bootloader
         fw_start += 0x3c000;
     }
 
-    uint32_t size = *(uint32_t*)(fw_start + 0x8ffc);
+    uint32_t size = *(uint32_t *)(fw_start + 0x8ffc);
     printf("size: %d\n", size);
     if (size > 1024 * 1024) {
         printf("Invalid size\n");
@@ -203,7 +204,7 @@ STATIC mp_obj_t esp_neopixel_write_(mp_obj_t pin, mp_obj_t buf, mp_obj_t is800k)
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_READ);
     esp_neopixel_write(mp_obj_get_pin_obj(pin)->phys_port,
-        (uint8_t*)bufinfo.buf, bufinfo.len, mp_obj_is_true(is800k));
+        (uint8_t *)bufinfo.buf, bufinfo.len, mp_obj_is_true(is800k));
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_3(esp_neopixel_write_obj, esp_neopixel_write_);
@@ -214,7 +215,7 @@ STATIC mp_obj_t esp_apa102_write_(mp_obj_t clockPin, mp_obj_t dataPin, mp_obj_t
     mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_READ);
     esp_apa102_write(mp_obj_get_pin_obj(clockPin)->phys_port,
         mp_obj_get_pin_obj(dataPin)->phys_port,
-        (uint8_t*)bufinfo.buf, bufinfo.len);
+        (uint8_t *)bufinfo.buf, bufinfo.len);
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_3(esp_apa102_write_obj, esp_apa102_write_);
@@ -237,7 +238,7 @@ STATIC mp_obj_t esp_malloc(mp_obj_t size_in) {
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_malloc_obj, esp_malloc);
 
 STATIC mp_obj_t esp_free(mp_obj_t addr_in) {
-    os_free((void*)mp_obj_get_int(addr_in));
+    os_free((void *)mp_obj_get_int(addr_in));
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_free_obj, esp_free);
@@ -282,18 +283,26 @@ void esp_native_code_init(void) {
     esp_native_code_erased = 0;
 }
 
-void *esp_native_code_commit(void *buf, size_t len) {
-    //printf("COMMIT(buf=%p, len=%u, start=%08x, cur=%08x, end=%08x, erased=%08x)\n", buf, len, esp_native_code_start, esp_native_code_cur, esp_native_code_end, esp_native_code_erased);
+void *esp_native_code_commit(void *buf, size_t len, void *reloc) {
+    // printf("COMMIT(buf=%p, len=%u, start=%08x, cur=%08x, end=%08x, erased=%08x)\n", buf, len, esp_native_code_start, esp_native_code_cur, esp_native_code_end, esp_native_code_erased);
 
     len = (len + 3) & ~3;
     if (esp_native_code_cur + len > esp_native_code_end) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_MemoryError,
-            "memory allocation failed, allocating %u bytes for native code", (uint)len));
+        mp_raise_msg_varg(&mp_type_MemoryError,
+            MP_ERROR_TEXT("memory allocation failed, allocating %u bytes for native code"), (uint)len);
     }
 
     void *dest;
     if (esp_native_code_location == ESP_NATIVE_CODE_IRAM1) {
-        dest = (void*)esp_native_code_cur;
+        dest = (void *)esp_native_code_cur;
+    } else {
+        dest = (void *)(FLASH_START + esp_native_code_cur);
+    }
+    if (reloc) {
+        mp_native_relocate(reloc, buf, (uintptr_t)dest);
+    }
+
+    if (esp_native_code_location == ESP_NATIVE_CODE_IRAM1) {
         memcpy(dest, buf, len);
     } else {
         SpiFlashOpResult res;
@@ -313,7 +322,6 @@ void *esp_native_code_commit(void *buf, size_t len) {
         if (res != SPI_FLASH_RESULT_OK) {
             mp_raise_OSError(res == SPI_FLASH_RESULT_TIMEOUT ? MP_ETIMEDOUT : MP_EIO);
         }
-        dest = (void*)(FLASH_START + esp_native_code_cur);
     }
 
     esp_native_code_cur += len;
@@ -334,7 +342,7 @@ STATIC mp_obj_t esp_set_native_code_location(mp_obj_t start_in, mp_obj_t len_in)
         esp_native_code_erased = esp_native_code_start;
         // memory-mapped flash is limited in extents to 1MByte
         if (esp_native_code_end > FLASH_END - FLASH_START) {
-            mp_raise_ValueError("flash location must be below 1MByte");
+            mp_raise_ValueError(MP_ERROR_TEXT("flash location must be below 1MByte"));
         }
     }
     return mp_const_none;
@@ -373,16 +381,16 @@ STATIC const mp_rom_map_elem_t esp_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_set_native_code_location), MP_ROM_PTR(&esp_set_native_code_location_obj) },
     #endif
 
-#if MODESP_INCLUDE_CONSTANTS
+    #if MODESP_INCLUDE_CONSTANTS
     { MP_ROM_QSTR(MP_QSTR_SLEEP_NONE), MP_ROM_INT(NONE_SLEEP_T) },
     { MP_ROM_QSTR(MP_QSTR_SLEEP_LIGHT), MP_ROM_INT(LIGHT_SLEEP_T) },
     { MP_ROM_QSTR(MP_QSTR_SLEEP_MODEM), MP_ROM_INT(MODEM_SLEEP_T) },
-#endif
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(esp_module_globals, esp_module_globals_table);
 
 const mp_obj_module_t esp_module = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&esp_module_globals,
+    .globals = (mp_obj_dict_t *)&esp_module_globals,
 };
diff --git a/ports/esp8266/modmachine.c b/ports/esp8266/modmachine.c
index 58368b8f0b43f..bc838b420645d 100644
--- a/ports/esp8266/modmachine.c
+++ b/ports/esp8266/modmachine.c
@@ -30,6 +30,7 @@
 
 #include "py/obj.h"
 #include "py/runtime.h"
+#include "lib/utils/pyexec.h"
 
 // This needs to be set before we include the RTOS headers
 #define USE_US_TIMER 1
@@ -49,8 +50,8 @@
 
 #if MICROPY_PY_MACHINE
 
-//#define MACHINE_WAKE_IDLE (0x01)
-//#define MACHINE_WAKE_SLEEP (0x02)
+// #define MACHINE_WAKE_IDLE (0x01)
+// #define MACHINE_WAKE_SLEEP (0x02)
 #define MACHINE_WAKE_DEEPSLEEP (0x04)
 
 extern const mp_obj_type_t esp_wdt_type;
@@ -63,7 +64,7 @@ STATIC mp_obj_t machine_freq(size_t n_args, const mp_obj_t *args) {
         // set
         mp_int_t freq = mp_obj_get_int(args[0]) / 1000000;
         if (freq != 80 && freq != 160) {
-            mp_raise_ValueError("frequency can only be either 80Mhz or 160MHz");
+            mp_raise_ValueError(MP_ERROR_TEXT("frequency can only be either 80Mhz or 160MHz"));
         }
         system_update_cpu_freq(freq);
         return mp_const_none;
@@ -77,6 +78,12 @@ STATIC mp_obj_t machine_reset(void) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_reset_obj, machine_reset);
 
+STATIC mp_obj_t machine_soft_reset(void) {
+    pyexec_system_exit = PYEXEC_FORCED_EXIT;
+    mp_raise_type(&mp_type_SystemExit);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_soft_reset_obj, machine_soft_reset);
+
 STATIC mp_obj_t machine_reset_cause(void) {
     return MP_OBJ_NEW_SMALL_INT(system_get_rst_info()->reason);
 }
@@ -84,13 +91,13 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_reset_cause_obj, machine_reset_cause);
 
 STATIC mp_obj_t machine_unique_id(void) {
     uint32_t id = system_get_chip_id();
-    return mp_obj_new_bytes((byte*)&id, sizeof(id));
+    return mp_obj_new_bytes((byte *)&id, sizeof(id));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_unique_id_obj, machine_unique_id);
 
 STATIC mp_obj_t machine_idle(void) {
     uint32_t t = mp_hal_ticks_cpu();
-    asm("waiti 0");
+    asm ("waiti 0");
     t = mp_hal_ticks_cpu() - t;
     ets_event_poll(); // handle any events after possibly a long wait (eg feed WDT)
     return MP_OBJ_NEW_SMALL_INT(t);
@@ -112,7 +119,7 @@ STATIC mp_obj_t machine_lightsleep(size_t n_args, const mp_obj_t *args) {
         ets_event_poll();
         if (wifi_mode == NULL_MODE) {
             // Can only idle if the wifi is off
-            asm("waiti 0");
+            asm ("waiti 0");
         }
     }
     return mp_const_none;
@@ -167,12 +174,49 @@ STATIC mp_obj_t machine_deepsleep(size_t n_args, const mp_obj_t *args) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_deepsleep_obj, 0, 1, machine_deepsleep);
 
+// These values are from the datasheet
+#define ESP_TIMER_US_MIN (100)
+#define ESP_TIMER_US_MAX (0xfffffff)
+#define ESP_TIMER_MS_MAX (0x689d0)
+
 typedef struct _esp_timer_obj_t {
     mp_obj_base_t base;
     os_timer_t timer;
+    uint32_t remain_ms; // if non-zero, remaining time to handle large periods
+    uint32_t period_ms; // if non-zero, periodic timer with a large period
     mp_obj_t callback;
 } esp_timer_obj_t;
 
+STATIC void esp_timer_arm_ms(esp_timer_obj_t *self, uint32_t ms, bool repeat) {
+    if (ms <= ESP_TIMER_MS_MAX) {
+        self->remain_ms = 0;
+        self->period_ms = 0;
+    } else {
+        self->remain_ms = ms - ESP_TIMER_MS_MAX;
+        if (repeat) {
+            repeat = false;
+            self->period_ms = ms;
+        } else {
+            self->period_ms = 0;
+        }
+        ms = ESP_TIMER_MS_MAX;
+    }
+    os_timer_arm(&self->timer, ms, repeat);
+}
+
+STATIC void esp_timer_arm_us(esp_timer_obj_t *self, uint32_t us, bool repeat) {
+    if (us < ESP_TIMER_US_MIN) {
+        us = ESP_TIMER_US_MIN;
+    }
+    if (us <= ESP_TIMER_US_MAX) {
+        self->remain_ms = 0;
+        self->period_ms = 0;
+        os_timer_arm_us(&self->timer, us, repeat);
+    } else {
+        esp_timer_arm_ms(self, us / 1000, repeat);
+    }
+}
+
 const mp_obj_type_t esp_timer_type;
 
 STATIC void esp_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
@@ -189,7 +233,21 @@ STATIC mp_obj_t esp_timer_make_new(const mp_obj_type_t *type, size_t n_args, siz
 
 STATIC void esp_timer_cb(void *arg) {
     esp_timer_obj_t *self = arg;
-    mp_sched_schedule(self->callback, self);
+    if (self->remain_ms != 0) {
+        // Handle periods larger than the maximum system period
+        uint32_t next_period_ms = self->remain_ms;
+        if (next_period_ms > ESP_TIMER_MS_MAX) {
+            next_period_ms = ESP_TIMER_MS_MAX;
+        }
+        self->remain_ms -= next_period_ms;
+        os_timer_arm(&self->timer, next_period_ms, false);
+    } else {
+        mp_sched_schedule(self->callback, self);
+        if (self->period_ms != 0) {
+            // A periodic timer with a larger period: reschedule it
+            esp_timer_arm_ms(self, self->period_ms, true);
+        }
+    }
 }
 
 STATIC mp_obj_t esp_timer_init_helper(esp_timer_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
@@ -205,11 +263,11 @@ STATIC mp_obj_t esp_timer_init_helper(esp_timer_obj_t *self, size_t n_args, cons
         { MP_QSTR_callback,     MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
         { MP_QSTR_period,       MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0xffffffff} },
         { MP_QSTR_tick_hz,      MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1000} },
-#if MICROPY_PY_BUILTINS_FLOAT
+        #if MICROPY_PY_BUILTINS_FLOAT
         { MP_QSTR_freq,         MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
-#else
+        #else
         { MP_QSTR_freq,         MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0xffffffff} },
-#endif
+        #endif
     };
 
     // parse args
@@ -221,34 +279,34 @@ STATIC mp_obj_t esp_timer_init_helper(esp_timer_obj_t *self, size_t n_args, cons
     os_timer_disarm(&self->timer);
     os_timer_setfn(&self->timer, esp_timer_cb, self);
 
-#if MICROPY_PY_BUILTINS_FLOAT
+    #if MICROPY_PY_BUILTINS_FLOAT
     if (args[ARG_freq].u_obj != mp_const_none) {
         mp_float_t freq = mp_obj_get_float(args[ARG_freq].u_obj);
         if (freq < 0.001) {
-            os_timer_arm(&self->timer, (mp_int_t)(1000 / freq), args[ARG_mode].u_int);
+            esp_timer_arm_ms(self, (mp_int_t)(1000 / freq), args[ARG_mode].u_int);
         } else {
-            os_timer_arm_us(&self->timer, (mp_int_t)(1000000 / freq), args[ARG_mode].u_int);
+            esp_timer_arm_us(self, (mp_int_t)(1000000 / freq), args[ARG_mode].u_int);
         }
     }
-#else
+    #else
     if (args[ARG_freq].u_int != 0xffffffff) {
-        os_timer_arm_us(&self->timer, 1000000 / args[ARG_freq].u_int, args[ARG_mode].u_int);
+        esp_timer_arm_us(self, 1000000 / args[ARG_freq].u_int, args[ARG_mode].u_int);
     }
-#endif
+    #endif
     else {
         mp_int_t period = args[ARG_period].u_int;
         mp_int_t hz = args[ARG_tick_hz].u_int;
         if (hz == 1000) {
-            os_timer_arm(&self->timer, period, args[ARG_mode].u_int);
+            esp_timer_arm_ms(self, period, args[ARG_mode].u_int);
         } else if (hz == 1000000) {
-            os_timer_arm_us(&self->timer, period, args[ARG_mode].u_int);
+            esp_timer_arm_us(self, period, args[ARG_mode].u_int);
         } else {
             // Use a long long to ensure that we don't either overflow or loose accuracy
             uint64_t period_us = (((uint64_t)period) * 1000000) / hz;
             if (period_us < 0x80000000ull) {
-                os_timer_arm_us(&self->timer, (mp_int_t)period_us, args[ARG_mode].u_int);
+                esp_timer_arm_us(self, (mp_int_t)period_us, args[ARG_mode].u_int);
             } else {
-                os_timer_arm(&self->timer, (mp_int_t)(period_us / 1000), args[ARG_mode].u_int);
+                esp_timer_arm_ms(self, (mp_int_t)(period_us / 1000), args[ARG_mode].u_int);
             }
         }
     }
@@ -282,7 +340,7 @@ const mp_obj_type_t esp_timer_type = {
     .name = MP_QSTR_Timer,
     .print = esp_timer_print,
     .make_new = esp_timer_make_new,
-    .locals_dict = (mp_obj_dict_t*)&esp_timer_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&esp_timer_locals_dict,
 };
 
 // this bit is unused in the Xtensa PS register
@@ -304,6 +362,35 @@ STATIC mp_obj_t machine_enable_irq(mp_obj_t state_in) {
 }
 MP_DEFINE_CONST_FUN_OBJ_1(machine_enable_irq_obj, machine_enable_irq);
 
+// Custom version of this function that feeds system WDT if necessary
+mp_uint_t machine_time_pulse_us(mp_hal_pin_obj_t pin, int pulse_level, mp_uint_t timeout_us) {
+    int nchanges = 2;
+    uint32_t start = system_get_time(); // in microseconds
+    for (;;) {
+        uint32_t dt = system_get_time() - start;
+
+        // Check if pin changed to wanted value
+        if (mp_hal_pin_read(pin) == pulse_level) {
+            if (--nchanges == 0) {
+                return dt;
+            }
+            pulse_level = 1 - pulse_level;
+            start = system_get_time();
+            continue;
+        }
+
+        // Check for timeout
+        if (dt >= timeout_us) {
+            return (mp_uint_t)-nchanges;
+        }
+
+        // Only feed WDT every now and then, to make sure edge timing is accurate
+        if ((dt & 0xffff) == 0xffff && !ets_loop_dont_feed_sw_wdt) {
+            system_soft_wdt_feed();
+        }
+    }
+}
+
 STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_umachine) },
     { MP_ROM_QSTR(MP_QSTR_mem8), MP_ROM_PTR(&machine_mem8_obj) },
@@ -312,6 +399,7 @@ STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
 
     { MP_ROM_QSTR(MP_QSTR_freq), MP_ROM_PTR(&machine_freq_obj) },
     { MP_ROM_QSTR(MP_QSTR_reset), MP_ROM_PTR(&machine_reset_obj) },
+    { MP_ROM_QSTR(MP_QSTR_soft_reset), MP_ROM_PTR(&machine_soft_reset_obj) },
     { MP_ROM_QSTR(MP_QSTR_reset_cause), MP_ROM_PTR(&machine_reset_cause_obj) },
     { MP_ROM_QSTR(MP_QSTR_unique_id), MP_ROM_PTR(&machine_unique_id_obj) },
     { MP_ROM_QSTR(MP_QSTR_idle), MP_ROM_PTR(&machine_idle_obj) },
@@ -330,7 +418,7 @@ STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_Pin), MP_ROM_PTR(&pyb_pin_type) },
     { MP_ROM_QSTR(MP_QSTR_Signal), MP_ROM_PTR(&machine_signal_type) },
     { MP_ROM_QSTR(MP_QSTR_PWM), MP_ROM_PTR(&pyb_pwm_type) },
-    { MP_ROM_QSTR(MP_QSTR_ADC), MP_ROM_PTR(&pyb_adc_type) },
+    { MP_ROM_QSTR(MP_QSTR_ADC), MP_ROM_PTR(&machine_adc_type) },
     { MP_ROM_QSTR(MP_QSTR_UART), MP_ROM_PTR(&pyb_uart_type) },
     #if MICROPY_PY_MACHINE_I2C
     { MP_ROM_QSTR(MP_QSTR_I2C), MP_ROM_PTR(&machine_i2c_type) },
@@ -354,7 +442,7 @@ STATIC MP_DEFINE_CONST_DICT(machine_module_globals, machine_module_globals_table
 
 const mp_obj_module_t mp_module_machine = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&machine_module_globals,
+    .globals = (mp_obj_dict_t *)&machine_module_globals,
 };
 
 #endif // MICROPY_PY_MACHINE
diff --git a/ports/esp8266/modmachine.h b/ports/esp8266/modmachine.h
index eae351f68d3bf..f5cfc0fa2cd52 100644
--- a/ports/esp8266/modmachine.h
+++ b/ports/esp8266/modmachine.h
@@ -5,7 +5,7 @@
 
 extern const mp_obj_type_t pyb_pin_type;
 extern const mp_obj_type_t pyb_pwm_type;
-extern const mp_obj_type_t pyb_adc_type;
+extern const mp_obj_type_t machine_adc_type;
 extern const mp_obj_type_t pyb_rtc_type;
 extern const mp_obj_type_t pyb_uart_type;
 extern const mp_obj_type_t pyb_i2c_type;
@@ -23,8 +23,6 @@ typedef struct _pyb_pin_obj_t {
 const pyb_pin_obj_t pyb_pin_obj[16 + 1];
 
 void pin_init0(void);
-void pin_intr_handler_iram(void *arg);
-void pin_intr_handler(uint32_t);
 
 uint mp_obj_get_pin(mp_obj_t pin_in);
 pyb_pin_obj_t *mp_obj_get_pin_obj(mp_obj_t pin_in);
diff --git a/ports/esp8266/modnetwork.c b/ports/esp8266/modnetwork.c
index c58aae1cbd005..cad53d912cafc 100644
--- a/ports/esp8266/modnetwork.c
+++ b/ports/esp8266/modnetwork.c
@@ -181,7 +181,7 @@ STATIC mp_obj_t esp_status(size_t n_args, const mp_obj_t *args) {
                     return MP_OBJ_NEW_SMALL_INT(wifi_station_get_rssi());
                 }
         }
-        mp_raise_ValueError("unknown status param");
+        mp_raise_ValueError(MP_ERROR_TEXT("unknown status param"));
     }
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_status_obj, 1, 2, esp_status);
@@ -204,7 +204,7 @@ STATIC void esp_scan_cb(void *result, STATUS status) {
                 // but is present in SDK headers since 1.4.0
                 t->items[0] = mp_obj_new_bytes(bs->ssid, bs->ssid_len);
                 #else
-                t->items[0] = mp_obj_new_bytes(bs->ssid, strlen((char*)bs->ssid));
+                t->items[0] = mp_obj_new_bytes(bs->ssid, strlen((char *)bs->ssid));
                 #endif
                 t->items[1] = mp_obj_new_bytes(bs->bssid, sizeof(bs->bssid));
                 t->items[2] = MP_OBJ_NEW_SMALL_INT(bs->channel);
@@ -229,8 +229,7 @@ STATIC void esp_scan_cb(void *result, STATUS status) {
 STATIC mp_obj_t esp_scan(mp_obj_t self_in) {
     require_if(self_in, STATION_IF);
     if ((wifi_get_opmode() & STATION_MODE) == 0) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
-            "STA must be active"));
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("STA must be active"));
     }
     mp_obj_t list = mp_obj_new_list(0, NULL);
     esp_scan_list = &list;
@@ -247,7 +246,7 @@ STATIC mp_obj_t esp_scan(mp_obj_t self_in) {
         ets_loop_iter();
     }
     if (list == MP_OBJ_NULL) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "scan failed"));
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("scan failed"));
     }
     return list;
 }
@@ -281,30 +280,35 @@ STATIC mp_obj_t esp_ifconfig(size_t n_args, const mp_obj_t *args) {
         // get
         dns_addr = dns_getserver(0);
         mp_obj_t tuple[4] = {
-            netutils_format_ipv4_addr((uint8_t*)&info.ip, NETUTILS_BIG),
-            netutils_format_ipv4_addr((uint8_t*)&info.netmask, NETUTILS_BIG),
-            netutils_format_ipv4_addr((uint8_t*)&info.gw, NETUTILS_BIG),
-            netutils_format_ipv4_addr((uint8_t*)&dns_addr, NETUTILS_BIG),
+            netutils_format_ipv4_addr((uint8_t *)&info.ip, NETUTILS_BIG),
+            netutils_format_ipv4_addr((uint8_t *)&info.netmask, NETUTILS_BIG),
+            netutils_format_ipv4_addr((uint8_t *)&info.gw, NETUTILS_BIG),
+            netutils_format_ipv4_addr((uint8_t *)&dns_addr, NETUTILS_BIG),
         };
         return mp_obj_new_tuple(4, tuple);
+    } else if (args[1] == MP_OBJ_NEW_QSTR(MP_QSTR_dhcp)) {
+        // use DHCP to configure the IP addresses
+        require_if(args[0], STATION_IF);
+        wifi_station_dhcpc_start();
+        return mp_const_none;
     } else {
         // set
         mp_obj_t *items;
         bool restart_dhcp_server = false;
         mp_obj_get_array_fixed_n(args[1], 4, &items);
-        netutils_parse_ipv4_addr(items[0], (void*)&info.ip, NETUTILS_BIG);
+        netutils_parse_ipv4_addr(items[0], (void *)&info.ip, NETUTILS_BIG);
         if (mp_obj_is_integer(items[1])) {
             // allow numeric netmask, i.e.:
             // 24 -> 255.255.255.0
             // 16 -> 255.255.0.0
             // etc...
-            uint32_t* m = (uint32_t*)&info.netmask;
+            uint32_t *m = (uint32_t *)&info.netmask;
             *m = htonl(0xffffffff << (32 - mp_obj_get_int(items[1])));
         } else {
-            netutils_parse_ipv4_addr(items[1], (void*)&info.netmask, NETUTILS_BIG);
+            netutils_parse_ipv4_addr(items[1], (void *)&info.netmask, NETUTILS_BIG);
         }
-        netutils_parse_ipv4_addr(items[2], (void*)&info.gw, NETUTILS_BIG);
-        netutils_parse_ipv4_addr(items[3], (void*)&dns_addr, NETUTILS_BIG);
+        netutils_parse_ipv4_addr(items[2], (void *)&info.gw, NETUTILS_BIG);
+        netutils_parse_ipv4_addr(items[3], (void *)&dns_addr, NETUTILS_BIG);
         // To set a static IP we have to disable DHCP first
         if (self->if_id == STATION_IF) {
             wifi_station_dhcpc_stop();
@@ -313,8 +317,7 @@ STATIC mp_obj_t esp_ifconfig(size_t n_args, const mp_obj_t *args) {
             wifi_softap_dhcps_stop();
         }
         if (!wifi_set_ip_info(self->if_id, &info)) {
-          nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
-            "wifi_set_ip_info() failed"));
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("wifi_set_ip_info() failed"));
         }
         dns_setserver(0, &dns_addr);
         if (restart_dhcp_server) {
@@ -327,7 +330,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_ifconfig_obj, 1, 2, esp_ifconfig)
 
 STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
     if (n_args != 1 && kwargs->used != 0) {
-        mp_raise_TypeError("either pos or kw args are allowed");
+        mp_raise_TypeError(MP_ERROR_TEXT("either pos or kw args are allowed"));
     }
 
     wlan_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
@@ -354,7 +357,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
                         mp_buffer_info_t bufinfo;
                         mp_get_buffer_raise(kwargs->table[i].value, &bufinfo, MP_BUFFER_READ);
                         if (bufinfo.len != 6) {
-                            mp_raise_ValueError("invalid buffer length");
+                            mp_raise_ValueError(MP_ERROR_TEXT("invalid buffer length"));
                         }
                         wifi_set_macaddr(self->if_id, bufinfo.buf);
                         break;
@@ -396,14 +399,14 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
                         req_if = STATION_IF;
                         if (self->if_id == STATION_IF) {
                             const char *s = mp_obj_str_get_str(kwargs->table[i].value);
-                            wifi_station_set_hostname((char*)s);
+                            wifi_station_set_hostname((char *)s);
                         }
                         break;
                     }
                     default:
                         goto unknown;
                 }
-                #undef QS
+#undef QS
             }
         }
 
@@ -424,7 +427,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
     // Get config
 
     if (n_args != 2) {
-        mp_raise_TypeError("can query only one param");
+        mp_raise_TypeError(MP_ERROR_TEXT("can query only one param"));
     }
 
     mp_obj_t val;
@@ -438,9 +441,9 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
         }
         case MP_QSTR_essid:
             if (self->if_id == STATION_IF) {
-                val = mp_obj_new_str((char*)cfg.sta.ssid, strlen((char*)cfg.sta.ssid));
+                val = mp_obj_new_str((char *)cfg.sta.ssid, strlen((char *)cfg.sta.ssid));
             } else {
-                val = mp_obj_new_str((char*)cfg.ap.ssid, cfg.ap.ssid_len);
+                val = mp_obj_new_str((char *)cfg.ap.ssid, cfg.ap.ssid_len);
             }
             break;
         case MP_QSTR_hidden:
@@ -457,7 +460,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
             break;
         case MP_QSTR_dhcp_hostname: {
             req_if = STATION_IF;
-            char* s = wifi_station_get_hostname();
+            char *s = wifi_station_get_hostname();
             if (s == NULL) {
                 val = MP_OBJ_NEW_QSTR(MP_QSTR_);
             } else {
@@ -477,7 +480,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
     return val;
 
 unknown:
-    mp_raise_ValueError("unknown config param");
+    mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp_config_obj, 1, esp_config);
 
@@ -497,7 +500,7 @@ STATIC MP_DEFINE_CONST_DICT(wlan_if_locals_dict, wlan_if_locals_dict_table);
 const mp_obj_type_t wlan_if_type = {
     { &mp_type_type },
     .name = MP_QSTR_WLAN,
-    .locals_dict = (mp_obj_dict_t*)&wlan_if_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&wlan_if_locals_dict,
 };
 
 STATIC mp_obj_t esp_phy_mode(size_t n_args, const mp_obj_t *args) {
@@ -515,7 +518,7 @@ STATIC const mp_rom_map_elem_t mp_module_network_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_WLAN), MP_ROM_PTR(&get_wlan_obj) },
     { MP_ROM_QSTR(MP_QSTR_phy_mode), MP_ROM_PTR(&esp_phy_mode_obj) },
 
-#if MODNETWORK_INCLUDE_CONSTANTS
+    #if MODNETWORK_INCLUDE_CONSTANTS
     { MP_ROM_QSTR(MP_QSTR_STA_IF), MP_ROM_INT(STATION_IF)},
     { MP_ROM_QSTR(MP_QSTR_AP_IF), MP_ROM_INT(SOFTAP_IF)},
 
@@ -535,12 +538,12 @@ STATIC const mp_rom_map_elem_t mp_module_network_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_AUTH_WPA_PSK), MP_ROM_INT(AUTH_WPA_PSK) },
     { MP_ROM_QSTR(MP_QSTR_AUTH_WPA2_PSK), MP_ROM_INT(AUTH_WPA2_PSK) },
     { MP_ROM_QSTR(MP_QSTR_AUTH_WPA_WPA2_PSK), MP_ROM_INT(AUTH_WPA_WPA2_PSK) },
-#endif
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(mp_module_network_globals, mp_module_network_globals_table);
 
 const mp_obj_module_t network_module = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_network_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_network_globals,
 };
diff --git a/ports/esp8266/modules/_boot.py b/ports/esp8266/modules/_boot.py
index 81eb20dd631ef..1f77d88024635 100644
--- a/ports/esp8266/modules/_boot.py
+++ b/ports/esp8266/modules/_boot.py
@@ -1,13 +1,15 @@
 import gc
+
 gc.threshold((gc.mem_free() + gc.mem_alloc()) // 4)
 import uos
 from flashbdev import bdev
 
-try:
-    if bdev:
-        uos.mount(bdev, '/')
-except OSError:
-    import inisetup
-    inisetup.setup()
+if bdev:
+    try:
+        uos.mount(bdev, "/")
+    except:
+        import inisetup
+
+        inisetup.setup()
 
 gc.collect()
diff --git a/ports/esp8266/modules/dht.py b/ports/esp8266/modules/dht.py
deleted file mode 120000
index 2aa2f5cbfed8a..0000000000000
--- a/ports/esp8266/modules/dht.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../drivers/dht/dht.py
\ No newline at end of file
diff --git a/ports/esp8266/modules/ds18x20.py b/ports/esp8266/modules/ds18x20.py
deleted file mode 120000
index 1ec92d1c9963b..0000000000000
--- a/ports/esp8266/modules/ds18x20.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../drivers/onewire/ds18x20.py
\ No newline at end of file
diff --git a/ports/esp8266/modules/flashbdev.py b/ports/esp8266/modules/flashbdev.py
index 40ba655c64d10..652fe9a4ba411 100644
--- a/ports/esp8266/modules/flashbdev.py
+++ b/ports/esp8266/modules/flashbdev.py
@@ -1,35 +1,42 @@
 import esp
 
-class FlashBdev:
 
+class FlashBdev:
     SEC_SIZE = 4096
-    RESERVED_SECS = 1
-    START_SEC = esp.flash_user_start() // SEC_SIZE + RESERVED_SECS
-    NUM_BLK = 0x6b - RESERVED_SECS
 
-    def __init__(self, blocks=NUM_BLK):
+    def __init__(self, start_sec, blocks):
+        self.start_sec = start_sec
         self.blocks = blocks
 
-    def readblocks(self, n, buf):
-        #print("readblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
-        esp.flash_read((n + self.START_SEC) * self.SEC_SIZE, buf)
+    def readblocks(self, n, buf, off=0):
+        # print("readblocks(%s, %x(%d), %d)" % (n, id(buf), len(buf), off))
+        esp.flash_read((n + self.start_sec) * self.SEC_SIZE + off, buf)
 
-    def writeblocks(self, n, buf):
-        #print("writeblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
-        #assert len(buf) <= self.SEC_SIZE, len(buf)
-        esp.flash_erase(n + self.START_SEC)
-        esp.flash_write((n + self.START_SEC) * self.SEC_SIZE, buf)
+    def writeblocks(self, n, buf, off=None):
+        # print("writeblocks(%s, %x(%d), %d)" % (n, id(buf), len(buf), off))
+        # assert len(buf) <= self.SEC_SIZE, len(buf)
+        if off is None:
+            esp.flash_erase(n + self.start_sec)
+            off = 0
+        esp.flash_write((n + self.start_sec) * self.SEC_SIZE + off, buf)
 
     def ioctl(self, op, arg):
-        #print("ioctl(%d, %r)" % (op, arg))
-        if op == 4:  # BP_IOCTL_SEC_COUNT
+        # print("ioctl(%d, %r)" % (op, arg))
+        if op == 4:  # MP_BLOCKDEV_IOCTL_BLOCK_COUNT
             return self.blocks
-        if op == 5:  # BP_IOCTL_SEC_SIZE
+        if op == 5:  # MP_BLOCKDEV_IOCTL_BLOCK_SIZE
             return self.SEC_SIZE
+        if op == 6:  # MP_BLOCKDEV_IOCTL_BLOCK_ERASE
+            esp.flash_erase(arg + self.start_sec)
+            return 0
+
 
 size = esp.flash_size()
-if size < 1024*1024:
+if size < 1024 * 1024:
     bdev = None
 else:
+    start_sec = esp.flash_user_start() // FlashBdev.SEC_SIZE
+    if start_sec < 256:
+        start_sec += 1  # Reserve space for native code
     # 20K at the flash end is reserved for SDK params storage
-    bdev = FlashBdev((size - 20480) // FlashBdev.SEC_SIZE - FlashBdev.START_SEC)
+    bdev = FlashBdev(start_sec, (size - 20480) // FlashBdev.SEC_SIZE - start_sec)
diff --git a/ports/esp8266/modules/inisetup.py b/ports/esp8266/modules/inisetup.py
index cb4fc04134380..79576e9d62aa7 100644
--- a/ports/esp8266/modules/inisetup.py
+++ b/ports/esp8266/modules/inisetup.py
@@ -2,45 +2,55 @@
 import network
 from flashbdev import bdev
 
+
 def wifi():
     import ubinascii
+
     ap_if = network.WLAN(network.AP_IF)
     essid = b"MicroPython-%s" % ubinascii.hexlify(ap_if.config("mac")[-3:])
     ap_if.config(essid=essid, authmode=network.AUTH_WPA_WPA2_PSK, password=b"micropythoN")
 
+
 def check_bootsec():
     buf = bytearray(bdev.SEC_SIZE)
     bdev.readblocks(0, buf)
     empty = True
     for b in buf:
-        if b != 0xff:
+        if b != 0xFF:
             empty = False
             break
     if empty:
         return True
     fs_corrupted()
 
+
 def fs_corrupted():
     import time
+
     while 1:
-        print("""\
+        print(
+            """\
 The FAT filesystem starting at sector %d with size %d sectors appears to
 be corrupted. If you had important data there, you may want to make a flash
 snapshot to try to recover it. Otherwise, perform factory reprogramming
 of MicroPython firmware (completely erase flash, followed by firmware
 programming).
-""" % (bdev.START_SEC, bdev.blocks))
+"""
+            % (bdev.START_SEC, bdev.blocks)
+        )
         time.sleep(3)
 
+
 def setup():
     check_bootsec()
     print("Performing initial setup")
     wifi()
-    uos.VfsFat.mkfs(bdev)
-    vfs = uos.VfsFat(bdev)
-    uos.mount(vfs, '/')
+    uos.VfsLfs2.mkfs(bdev)
+    vfs = uos.VfsLfs2(bdev)
+    uos.mount(vfs, "/")
     with open("boot.py", "w") as f:
-        f.write("""\
+        f.write(
+            """\
 # This file is executed on every boot (including wake-boot from deepsleep)
 #import esp
 #esp.osdebug(None)
@@ -50,5 +60,6 @@ def setup():
 #import webrepl
 #webrepl.start()
 gc.collect()
-""")
+"""
+        )
     return vfs
diff --git a/ports/esp8266/modules/neopixel.py b/ports/esp8266/modules/neopixel.py
index b13424d7d825d..be56ed1b07266 100644
--- a/ports/esp8266/modules/neopixel.py
+++ b/ports/esp8266/modules/neopixel.py
@@ -21,8 +21,7 @@ def __setitem__(self, index, val):
 
     def __getitem__(self, index):
         offset = index * self.bpp
-        return tuple(self.buf[offset + self.ORDER[i]]
-                     for i in range(self.bpp))
+        return tuple(self.buf[offset + self.ORDER[i]] for i in range(self.bpp))
 
     def fill(self, color):
         for i in range(self.n):
diff --git a/ports/esp8266/modules/ntptime.py b/ports/esp8266/modules/ntptime.py
index 85c754af6c4b3..92ae6ab077cfb 100644
--- a/ports/esp8266/modules/ntptime.py
+++ b/ports/esp8266/modules/ntptime.py
@@ -10,26 +10,31 @@
 # (date(2000, 1, 1) - date(1900, 1, 1)).days * 24*60*60
 NTP_DELTA = 3155673600
 
+# The NTP host can be configured at runtime by doing: ntptime.host = 'myhost.org'
 host = "pool.ntp.org"
 
+
 def time():
     NTP_QUERY = bytearray(48)
-    NTP_QUERY[0] = 0x1b
+    NTP_QUERY[0] = 0x1B
     addr = socket.getaddrinfo(host, 123)[0][-1]
     s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    s.settimeout(1)
-    res = s.sendto(NTP_QUERY, addr)
-    msg = s.recv(48)
-    s.close()
+    try:
+        s.settimeout(1)
+        res = s.sendto(NTP_QUERY, addr)
+        msg = s.recv(48)
+    finally:
+        s.close()
     val = struct.unpack("!I", msg[40:44])[0]
     return val - NTP_DELTA
 
+
 # There's currently no timezone support in MicroPython, so
 # utime.localtime() will return UTC time (as if it was .gmtime())
 def settime():
     t = time()
     import machine
     import utime
+
     tm = utime.localtime(t)
-    tm = tm[0:3] + (0,) + tm[3:6] + (0,)
-    machine.RTC().datetime(tm)
+    machine.RTC().datetime((tm[0], tm[1], tm[2], tm[6] + 1, tm[3], tm[4], tm[5], 0))
diff --git a/ports/esp8266/modules/onewire.py b/ports/esp8266/modules/onewire.py
deleted file mode 120000
index 33f30e84f11cd..0000000000000
--- a/ports/esp8266/modules/onewire.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../drivers/onewire/onewire.py
\ No newline at end of file
diff --git a/ports/esp8266/modules/port_diag.py b/ports/esp8266/modules/port_diag.py
index ef8800355aed4..f2c69ecacd96b 100644
--- a/ports/esp8266/modules/port_diag.py
+++ b/ports/esp8266/modules/port_diag.py
@@ -10,13 +10,16 @@ def main():
     fid = esp.flash_id()
 
     print("FlashROM:")
-    print("Flash ID: %x (Vendor: %x Device: %x)" % (fid, fid & 0xff, fid & 0xff00 | fid >> 16))
+    print("Flash ID: %x (Vendor: %x Device: %x)" % (fid, fid & 0xFF, fid & 0xFF00 | fid >> 16))
 
     print("Flash bootloader data:")
     SZ_MAP = {0: "512KB", 1: "256KB", 2: "1MB", 3: "2MB", 4: "4MB"}
-    FREQ_MAP = {0: "40MHZ", 1: "26MHZ", 2: "20MHz", 0xf: "80MHz"}
+    FREQ_MAP = {0: "40MHZ", 1: "26MHZ", 2: "20MHz", 0xF: "80MHz"}
     print("Byte @2: %02x" % ROM[2])
-    print("Byte @3: %02x (Flash size: %s Flash freq: %s)" % (ROM[3], SZ_MAP.get(ROM[3] >> 4, "?"), FREQ_MAP.get(ROM[3] & 0xf)))
+    print(
+        "Byte @3: %02x (Flash size: %s Flash freq: %s)"
+        % (ROM[3], SZ_MAP.get(ROM[3] >> 4, "?"), FREQ_MAP.get(ROM[3] & 0xF))
+    )
     print("Firmware checksum:")
     print(esp.check_fw())
 
@@ -24,7 +27,9 @@ def main():
     print("STA ifconfig:", network.WLAN(network.STA_IF).ifconfig())
     print("AP ifconfig:", network.WLAN(network.AP_IF).ifconfig())
     print("Free WiFi driver buffers of type:")
-    for i, comm in enumerate(("1,2 TX", "4 Mngmt TX(len: 0x41-0x100)", "5 Mngmt TX (len: 0-0x40)", "7", "8 RX")):
+    for i, comm in enumerate(
+        ("1,2 TX", "4 Mngmt TX(len: 0x41-0x100)", "5 Mngmt TX (len: 0-0x40)", "7", "8 RX")
+    ):
         print("%d: %d (%s)" % (i, esp.esf_free_bufs(i), comm))
     print("lwIP PCBs:")
     lwip.print_pcbs()
diff --git a/ports/esp8266/modules/upip.py b/ports/esp8266/modules/upip.py
deleted file mode 120000
index 130eb69016485..0000000000000
--- a/ports/esp8266/modules/upip.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../tools/upip.py
\ No newline at end of file
diff --git a/ports/esp8266/modules/upip_utarfile.py b/ports/esp8266/modules/upip_utarfile.py
deleted file mode 120000
index d9653d6a60808..0000000000000
--- a/ports/esp8266/modules/upip_utarfile.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../tools/upip_utarfile.py
\ No newline at end of file
diff --git a/ports/esp8266/moduos.c b/ports/esp8266/moduos.c
index 7a32c11c078f8..f04094fbed907 100644
--- a/ports/esp8266/moduos.c
+++ b/ports/esp8266/moduos.c
@@ -4,6 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2015 Josef Gajdusek
+ * Copyright (c) 2016 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -31,6 +32,7 @@
 #include "extmod/misc.h"
 #include "extmod/vfs.h"
 #include "extmod/vfs_fat.h"
+#include "extmod/vfs_lfs.h"
 #include "genhdr/mpversion.h"
 #include "esp_mphal.h"
 #include "user_interface.h"
@@ -104,8 +106,7 @@ STATIC const mp_rom_map_elem_t os_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_dupterm), MP_ROM_PTR(&os_dupterm_obj) },
     { MP_ROM_QSTR(MP_QSTR_dupterm_notify), MP_ROM_PTR(&os_dupterm_notify_obj) },
     #endif
-    #if MICROPY_VFS_FAT
-    { MP_ROM_QSTR(MP_QSTR_VfsFat), MP_ROM_PTR(&mp_fat_vfs_type) },
+    #if MICROPY_VFS
     { MP_ROM_QSTR(MP_QSTR_ilistdir), MP_ROM_PTR(&mp_vfs_ilistdir_obj) },
     { MP_ROM_QSTR(MP_QSTR_listdir), MP_ROM_PTR(&mp_vfs_listdir_obj) },
     { MP_ROM_QSTR(MP_QSTR_mkdir), MP_ROM_PTR(&mp_vfs_mkdir_obj) },
@@ -118,6 +119,15 @@ STATIC const mp_rom_map_elem_t os_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_statvfs), MP_ROM_PTR(&mp_vfs_statvfs_obj) },
     { MP_ROM_QSTR(MP_QSTR_mount), MP_ROM_PTR(&mp_vfs_mount_obj) },
     { MP_ROM_QSTR(MP_QSTR_umount), MP_ROM_PTR(&mp_vfs_umount_obj) },
+    #if MICROPY_VFS_FAT
+    { MP_ROM_QSTR(MP_QSTR_VfsFat), MP_ROM_PTR(&mp_fat_vfs_type) },
+    #endif
+    #if MICROPY_VFS_LFS1
+    { MP_ROM_QSTR(MP_QSTR_VfsLfs1), MP_ROM_PTR(&mp_type_vfs_lfs1) },
+    #endif
+    #if MICROPY_VFS_LFS2
+    { MP_ROM_QSTR(MP_QSTR_VfsLfs2), MP_ROM_PTR(&mp_type_vfs_lfs2) },
+    #endif
     #endif
 };
 
@@ -125,5 +135,5 @@ STATIC MP_DEFINE_CONST_DICT(os_module_globals, os_module_globals_table);
 
 const mp_obj_module_t uos_module = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&os_module_globals,
+    .globals = (mp_obj_dict_t *)&os_module_globals,
 };
diff --git a/ports/esp8266/modutime.c b/ports/esp8266/modutime.c
index ab9cb7dc23b3c..9e924121bbc78 100644
--- a/ports/esp8266/modutime.c
+++ b/ports/esp8266/modutime.c
@@ -88,12 +88,12 @@ STATIC mp_obj_t time_mktime(mp_obj_t tuple) {
 
     // localtime generates a tuple of len 8. CPython uses 9, so we accept both.
     if (len < 8 || len > 9) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "mktime needs a tuple of length 8 or 9 (%d given)", len));
+        mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("mktime needs a tuple of length 8 or 9 (%d given)"), len);
     }
 
     return mp_obj_new_int_from_uint(timeutils_mktime(mp_obj_get_int(elem[0]),
-            mp_obj_get_int(elem[1]), mp_obj_get_int(elem[2]), mp_obj_get_int(elem[3]),
-            mp_obj_get_int(elem[4]), mp_obj_get_int(elem[5])));
+        mp_obj_get_int(elem[1]), mp_obj_get_int(elem[2]), mp_obj_get_int(elem[3]),
+        mp_obj_get_int(elem[4]), mp_obj_get_int(elem[5])));
 }
 MP_DEFINE_CONST_FUN_OBJ_1(time_mktime_obj, time_mktime);
 
@@ -125,5 +125,5 @@ STATIC MP_DEFINE_CONST_DICT(time_module_globals, time_module_globals_table);
 
 const mp_obj_module_t utime_module = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&time_module_globals,
+    .globals = (mp_obj_dict_t *)&time_module_globals,
 };
diff --git a/ports/esp8266/mpconfigport.h b/ports/esp8266/mpconfigport.h
index 03be59b06321b..5344a98d6a548 100644
--- a/ports/esp8266/mpconfigport.h
+++ b/ports/esp8266/mpconfigport.h
@@ -1,6 +1,10 @@
-#include <stdint.h>
+// Options to control how MicroPython is built for this port,
+// overriding defaults in py/mpconfig.h.
+
+// Board-specific definitions
+#include "mpconfigboard.h"
 
-// options to control how MicroPython is built
+#include <stdint.h>
 
 #define MICROPY_OBJ_REPR            (MICROPY_OBJ_REPR_C)
 #define MICROPY_GC_STACK_ENTRY_TYPE uint16_t
@@ -10,13 +14,8 @@
 #define MICROPY_ALLOC_PARSE_RULE_INC    (8)
 #define MICROPY_ALLOC_PARSE_RESULT_INC  (8)
 #define MICROPY_ALLOC_PARSE_CHUNK_INIT  (64)
-#define MICROPY_PERSISTENT_CODE_LOAD (1)
-#define MICROPY_EMIT_XTENSA         (1)
-#define MICROPY_EMIT_INLINE_XTENSA  (1)
 #define MICROPY_MEM_STATS           (0)
 #define MICROPY_DEBUG_PRINTER       (&mp_debug_print)
-#define MICROPY_DEBUG_PRINTERS      (1)
-#define MICROPY_READER_VFS          (MICROPY_VFS)
 #define MICROPY_ENABLE_GC           (1)
 #define MICROPY_ENABLE_FINALISER    (1)
 #define MICROPY_STACK_CHECK         (1)
@@ -32,7 +31,6 @@
 #define MICROPY_USE_INTERNAL_ERRNO  (1)
 #define MICROPY_ENABLE_SCHEDULER    (1)
 #define MICROPY_PY_DESCRIPTORS      (1)
-#define MICROPY_PY_ALL_SPECIAL_METHODS (1)
 #define MICROPY_PY_BUILTINS_COMPLEX (0)
 #define MICROPY_PY_BUILTINS_STR_UNICODE (1)
 #define MICROPY_PY_BUILTINS_BYTEARRAY (1)
@@ -40,7 +38,6 @@
 #define MICROPY_PY_BUILTINS_FROZENSET (1)
 #define MICROPY_PY_BUILTINS_SET     (1)
 #define MICROPY_PY_BUILTINS_SLICE   (1)
-#define MICROPY_PY_BUILTINS_SLICE_ATTRS (1)
 #define MICROPY_PY_BUILTINS_PROPERTY (1)
 #define MICROPY_PY_BUILTINS_ROUND_INT (1)
 #define MICROPY_PY_BUILTINS_INPUT   (1)
@@ -58,29 +55,26 @@
 #define MICROPY_PY_CMATH            (0)
 #define MICROPY_PY_IO               (1)
 #define MICROPY_PY_IO_IOBASE        (1)
-#define MICROPY_PY_IO_FILEIO        (1)
 #define MICROPY_PY_STRUCT           (1)
 #define MICROPY_PY_SYS              (1)
 #define MICROPY_PY_SYS_MAXSIZE      (1)
 #define MICROPY_PY_SYS_EXIT         (1)
 #define MICROPY_PY_SYS_STDFILES     (1)
-#define MICROPY_PY_SYS_STDIO_BUFFER (1)
 #define MICROPY_PY_UERRNO           (1)
 #define MICROPY_PY_UBINASCII        (1)
 #define MICROPY_PY_UCTYPES          (1)
 #define MICROPY_PY_UHASHLIB         (1)
 #define MICROPY_PY_UHASHLIB_SHA1    (MICROPY_PY_USSL && MICROPY_SSL_AXTLS)
-#define MICROPY_PY_UCRYPTOLIB       (1)
 #define MICROPY_PY_UHEAPQ           (1)
 #define MICROPY_PY_UTIMEQ           (1)
 #define MICROPY_PY_UJSON            (1)
 #define MICROPY_PY_URANDOM          (1)
 #define MICROPY_PY_URE              (1)
-#define MICROPY_PY_URE_SUB          (1)
 #define MICROPY_PY_USELECT          (1)
 #define MICROPY_PY_UTIME_MP_HAL     (1)
 #define MICROPY_PY_UZLIB            (1)
 #define MICROPY_PY_LWIP             (1)
+#define MICROPY_PY_LWIP_SOCK_RAW    (1)
 #define MICROPY_PY_MACHINE          (1)
 #define MICROPY_PY_MACHINE_PIN_MAKE_NEW mp_pin_make_new
 #define MICROPY_PY_MACHINE_PULSE    (1)
@@ -90,28 +84,22 @@
 #define MICROPY_PY_UWEBSOCKET       (1)
 #define MICROPY_PY_WEBREPL          (1)
 #define MICROPY_PY_WEBREPL_DELAY    (20)
-#define MICROPY_PY_FRAMEBUF         (1)
+#define MICROPY_PY_WEBREPL_STATIC_FILEBUF (1)
 #define MICROPY_PY_MICROPYTHON_MEM_INFO (1)
 #define MICROPY_PY_OS_DUPTERM       (2)
 #define MICROPY_CPYTHON_COMPAT      (1)
 #define MICROPY_LONGINT_IMPL        (MICROPY_LONGINT_IMPL_MPZ)
 #define MICROPY_FLOAT_IMPL          (MICROPY_FLOAT_IMPL_FLOAT)
-#define MICROPY_ERROR_REPORTING     (MICROPY_ERROR_REPORTING_NORMAL)
 #define MICROPY_WARNINGS            (1)
 #define MICROPY_PY_STR_BYTES_CMP_WARN (1)
 #define MICROPY_STREAMS_NON_BLOCK   (1)
 #define MICROPY_STREAMS_POSIX_API   (1)
-#define MICROPY_MODULE_FROZEN_STR   (1)
-#define MICROPY_MODULE_FROZEN_MPY   (1)
 #define MICROPY_MODULE_FROZEN_LEXER mp_lexer_new_from_str32
-#define MICROPY_QSTR_EXTRA_POOL     mp_qstr_frozen_const_pool
 
-#define MICROPY_VFS                    (1)
 #define MICROPY_FATFS_ENABLE_LFN       (1)
 #define MICROPY_FATFS_RPATH            (2)
 #define MICROPY_FATFS_MAX_SS           (4096)
 #define MICROPY_FATFS_LFN_CODE_PAGE    437 /* 1=SFN/ANSI 437=LFN/U.S.(OEM) */
-#define MICROPY_VFS_FAT                (1)
 #define MICROPY_ESP8266_APA102         (1)
 #define MICROPY_ESP8266_NEOPIXEL       (1)
 
@@ -122,13 +110,17 @@
         vm_hook_divisor = MICROPY_VM_HOOK_COUNT; \
         extern void ets_loop_iter(void); \
         ets_loop_iter(); \
-    }
+}
 #define MICROPY_VM_HOOK_LOOP MICROPY_VM_HOOK_POLL
 #define MICROPY_VM_HOOK_RETURN MICROPY_VM_HOOK_POLL
 
+#include "xtirq.h"
+#define MICROPY_BEGIN_ATOMIC_SECTION() disable_irq()
+#define MICROPY_END_ATOMIC_SECTION(state) enable_irq(state)
+
 // type definitions for the specific machine
 
-#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void*)((mp_uint_t)(p)))
+#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)((mp_uint_t)(p)))
 
 #define MP_SSIZE_MAX (0x7fffffff)
 
@@ -143,14 +135,22 @@ typedef uint32_t sys_prot_t; // for modlwip
 #include <sys/types.h>
 
 #define MP_PLAT_PRINT_STRN(str, len) mp_hal_stdout_tx_strn_cooked(str, len)
-void *esp_native_code_commit(void*, size_t);
-#define MP_PLAT_COMMIT_EXEC(buf, len) esp_native_code_commit(buf, len)
+void *esp_native_code_commit(void *, size_t, void *);
+#define MP_PLAT_COMMIT_EXEC(buf, len, reloc) esp_native_code_commit(buf, len, reloc)
 
 // printer for debugging output, goes to UART only
 extern const struct _mp_print_t mp_debug_print;
 
+#if MICROPY_VFS_FAT
 #define mp_type_fileio mp_type_vfs_fat_fileio
 #define mp_type_textio mp_type_vfs_fat_textio
+#elif MICROPY_VFS_LFS1
+#define mp_type_fileio mp_type_vfs_lfs1_fileio
+#define mp_type_textio mp_type_vfs_lfs1_textio
+#elif MICROPY_VFS_LFS2
+#define mp_type_fileio mp_type_vfs_lfs2_fileio
+#define mp_type_textio mp_type_vfs_lfs2_textio
+#endif
 
 // use vfs's functions for import stat and builtin open
 #define mp_import_stat mp_vfs_import_stat
@@ -179,23 +179,6 @@ extern const struct _mp_obj_module_t mp_module_onewire;
     { MP_ROM_QSTR(MP_QSTR_machine), MP_ROM_PTR(&mp_module_machine) }, \
     { MP_ROM_QSTR(MP_QSTR__onewire), MP_ROM_PTR(&mp_module_onewire) }, \
 
-#define MICROPY_PORT_BUILTIN_MODULE_WEAK_LINKS \
-    { MP_ROM_QSTR(MP_QSTR_binascii), MP_ROM_PTR(&mp_module_ubinascii) }, \
-    { MP_ROM_QSTR(MP_QSTR_collections), MP_ROM_PTR(&mp_module_collections) }, \
-    { MP_ROM_QSTR(MP_QSTR_errno), MP_ROM_PTR(&mp_module_uerrno) }, \
-    { MP_ROM_QSTR(MP_QSTR_hashlib), MP_ROM_PTR(&mp_module_uhashlib) }, \
-    { MP_ROM_QSTR(MP_QSTR_io), MP_ROM_PTR(&mp_module_io) }, \
-    { MP_ROM_QSTR(MP_QSTR_json), MP_ROM_PTR(&mp_module_ujson) }, \
-    { MP_ROM_QSTR(MP_QSTR_os), MP_ROM_PTR(&uos_module) }, \
-    { MP_ROM_QSTR(MP_QSTR_random), MP_ROM_PTR(&mp_module_urandom) }, \
-    { MP_ROM_QSTR(MP_QSTR_re), MP_ROM_PTR(&mp_module_ure) }, \
-    { MP_ROM_QSTR(MP_QSTR_select), MP_ROM_PTR(&mp_module_uselect) }, \
-    { MP_ROM_QSTR(MP_QSTR_socket), MP_ROM_PTR(&mp_module_lwip) }, \
-    { MP_ROM_QSTR(MP_QSTR_ssl), MP_ROM_PTR(&mp_module_ussl) }, \
-    { MP_ROM_QSTR(MP_QSTR_struct), MP_ROM_PTR(&mp_module_ustruct) }, \
-    { MP_ROM_QSTR(MP_QSTR_time), MP_ROM_PTR(&utime_module) }, \
-    { MP_ROM_QSTR(MP_QSTR_zlib), MP_ROM_PTR(&mp_module_uzlib) }, \
-
 #define MP_STATE_PORT MP_STATE_VM
 
 #define MICROPY_PORT_ROOT_POINTERS \
@@ -209,10 +192,10 @@ extern const struct _mp_obj_module_t mp_module_onewire;
 // board specifics
 
 #define MICROPY_MPHALPORT_H "esp_mphal.h"
-#define MICROPY_HW_BOARD_NAME "ESP module"
-#define MICROPY_HW_MCU_NAME "ESP8266"
 #define MICROPY_PY_SYS_PLATFORM "esp8266"
 
 #define MP_FASTCODE(n) __attribute__((section(".iram0.text." #n))) n
+#define MICROPY_WRAP_MP_KEYBOARD_INTERRUPT(f) MP_FASTCODE(f)
+#define MICROPY_WRAP_MP_SCHED_SCHEDULE(f) MP_FASTCODE(f)
 
 #define _assert(expr) ((expr) ? (void)0 : __assert_func(__FILE__, __LINE__, __func__, #expr))
diff --git a/ports/esp8266/mpconfigport_512k.h b/ports/esp8266/mpconfigport_512k.h
deleted file mode 100644
index df670d4c96b72..0000000000000
--- a/ports/esp8266/mpconfigport_512k.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#include <mpconfigport.h>
-
-#undef MICROPY_EMIT_XTENSA
-#define MICROPY_EMIT_XTENSA             (0)
-#undef MICROPY_EMIT_INLINE_XTENSA
-#define MICROPY_EMIT_INLINE_XTENSA      (0)
-
-#undef MICROPY_DEBUG_PRINTERS
-#define MICROPY_DEBUG_PRINTERS          (0)
-
-#undef MICROPY_ERROR_REPORTING
-#define MICROPY_ERROR_REPORTING         (MICROPY_ERROR_REPORTING_TERSE)
-
-#undef MICROPY_VFS
-#define MICROPY_VFS                     (0)
-#undef MICROPY_VFS_FAT
-#define MICROPY_VFS_FAT                 (0)
-
-#undef MICROPY_PERSISTENT_CODE_LOAD
-#define MICROPY_PERSISTENT_CODE_LOAD    (0)
-
-#undef MICROPY_PY_IO_FILEIO
-#define MICROPY_PY_IO_FILEIO            (0)
-
-#undef MICROPY_PY_SYS_STDIO_BUFFER
-#define MICROPY_PY_SYS_STDIO_BUFFER     (0)
-#undef MICROPY_PY_BUILTINS_SLICE_ATTRS
-#define MICROPY_PY_BUILTINS_SLICE_ATTRS (0)
-#undef MICROPY_PY_ALL_SPECIAL_METHODS
-#define MICROPY_PY_ALL_SPECIAL_METHODS  (0)
-
-#undef MICROPY_PY_FRAMEBUF
-#define MICROPY_PY_FRAMEBUF             (0)
-
-#undef MICROPY_PY_URE_SUB
-#define MICROPY_PY_URE_SUB              (0)
-
-#undef MICROPY_PY_UCRYPTOLIB
-#define MICROPY_PY_UCRYPTOLIB           (0)
-
-#undef mp_import_stat
-#undef mp_builtin_open
-#undef mp_builtin_open_obj
diff --git a/ports/esp8266/qstrdefsport.h b/ports/esp8266/qstrdefsport.h
index 8f301a69c5adf..b84790c66e71e 100644
--- a/ports/esp8266/qstrdefsport.h
+++ b/ports/esp8266/qstrdefsport.h
@@ -25,6 +25,7 @@
  */
 
 // qstrs specific to this port, only needed if they aren't auto-generated
+// *FORMAT-OFF*
 
 // Entries for sys.path
 Q(/)
diff --git a/ports/esp8266/strtoll.c b/ports/esp8266/strtoll.c
index 4e8a4d05669f4..f095f7606d2fb 100644
--- a/ports/esp8266/strtoll.c
+++ b/ports/esp8266/strtoll.c
@@ -23,7 +23,7 @@ long long int strtoll(const char *nptr, char **endptr, int base) {
         val = val * base + v;
     }
 
-    *endptr = (char*)nptr;
+    *endptr = (char *)nptr;
 
     return val;
 }
diff --git a/ports/esp8266/uart.c b/ports/esp8266/uart.c
index cf9e8f61b230f..7d88555c05ef5 100644
--- a/ports/esp8266/uart.c
+++ b/ports/esp8266/uart.c
@@ -65,9 +65,9 @@ static void ICACHE_FLASH_ATTR uart_config(uint8 uart_no) {
     uart_div_modify(uart_no, UART_CLK_FREQ / (UartDev.baut_rate));
 
     WRITE_PERI_REG(UART_CONF0(uart_no), UartDev.exist_parity
-                 | UartDev.parity
-                 | (UartDev.stop_bits << UART_STOP_BIT_NUM_S)
-                 | (UartDev.data_bits << UART_BIT_NUM_S));
+        | UartDev.parity
+        | (UartDev.stop_bits << UART_STOP_BIT_NUM_S)
+        | (UartDev.data_bits << UART_BIT_NUM_S));
 
     // clear rx and tx fifo,not ready
     SET_PERI_REG_MASK(UART_CONF0(uart_no), UART_RXFIFO_RST | UART_TXFIFO_RST);
@@ -76,16 +76,16 @@ static void ICACHE_FLASH_ATTR uart_config(uint8 uart_no) {
     if (uart_no == UART0) {
         // set rx fifo trigger
         WRITE_PERI_REG(UART_CONF1(uart_no),
-                   ((0x10 & UART_RXFIFO_FULL_THRHD) << UART_RXFIFO_FULL_THRHD_S) |
-                   ((0x10 & UART_RX_FLOW_THRHD) << UART_RX_FLOW_THRHD_S) |
-                   UART_RX_FLOW_EN |
-                   (0x02 & UART_RX_TOUT_THRHD) << UART_RX_TOUT_THRHD_S |
-                   UART_RX_TOUT_EN);
+            ((0x10 & UART_RXFIFO_FULL_THRHD) << UART_RXFIFO_FULL_THRHD_S) |
+            ((0x10 & UART_RX_FLOW_THRHD) << UART_RX_FLOW_THRHD_S) |
+            UART_RX_FLOW_EN |
+            (0x02 & UART_RX_TOUT_THRHD) << UART_RX_TOUT_THRHD_S |
+                UART_RX_TOUT_EN);
         SET_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_TOUT_INT_ENA |
-                      UART_FRM_ERR_INT_ENA);
+            UART_FRM_ERR_INT_ENA);
     } else {
         WRITE_PERI_REG(UART_CONF1(uart_no),
-                   ((UartDev.rcv_buff.TrigLvl & UART_RXFIFO_FULL_THRHD) << UART_RXFIFO_FULL_THRHD_S));
+            ((UartDev.rcv_buff.TrigLvl & UART_RXFIFO_FULL_THRHD) << UART_RXFIFO_FULL_THRHD_S));
     }
 
     // clear all interrupt
@@ -103,7 +103,7 @@ static void ICACHE_FLASH_ATTR uart_config(uint8 uart_no) {
 *******************************************************************************/
 void uart_tx_one_char(uint8 uart, uint8 TxChar) {
     while (true) {
-        uint32 fifo_cnt = READ_PERI_REG(UART_STATUS(uart)) & (UART_TXFIFO_CNT<<UART_TXFIFO_CNT_S);
+        uint32 fifo_cnt = READ_PERI_REG(UART_STATUS(uart)) & (UART_TXFIFO_CNT << UART_TXFIFO_CNT_S);
         if ((fifo_cnt >> UART_TXFIFO_CNT_S & UART_TXFIFO_CNT) < 126) {
             break;
         }
@@ -113,7 +113,7 @@ void uart_tx_one_char(uint8 uart, uint8 TxChar) {
 
 void uart_flush(uint8 uart) {
     while (true) {
-        uint32 fifo_cnt = READ_PERI_REG(UART_STATUS(uart)) & (UART_TXFIFO_CNT<<UART_TXFIFO_CNT_S);
+        uint32 fifo_cnt = READ_PERI_REG(UART_STATUS(uart)) & (UART_TXFIFO_CNT << UART_TXFIFO_CNT_S);
         if ((fifo_cnt >> UART_TXFIFO_CNT_S & UART_TXFIFO_CNT) == 0) {
             break;
         }
@@ -155,9 +155,9 @@ uart_os_config(int uart) {
 *******************************************************************************/
 
 static void uart0_rx_intr_handler(void *para) {
-  /* uart0 and uart1 intr combine togther, when interrupt occur, see reg 0x3ff20020, bit2, bit0 represents
-    * uart1 and uart0 respectively
-    */
+    /* uart0 and uart1 intr combine togther, when interrupt occur, see reg 0x3ff20020, bit2, bit0 represents
+      * uart1 and uart0 respectively
+      */
 
     uint8 uart_no = UART_REPL;
 
@@ -170,7 +170,7 @@ static void uart0_rx_intr_handler(void *para) {
         // fifo full
         goto read_chars;
     } else if (UART_RXFIFO_TOUT_INT_ST == (READ_PERI_REG(UART_INT_ST(uart_no)) & UART_RXFIFO_TOUT_INT_ST)) {
-        read_chars:
+    read_chars:
         ETS_UART_INTR_DISABLE();
 
         while (READ_PERI_REG(UART_STATUS(uart_no)) & (UART_RXFIFO_CNT << UART_RXFIFO_CNT_S)) {
@@ -200,7 +200,7 @@ static void uart0_rx_intr_handler(void *para) {
 
 // Waits at most timeout microseconds for at least 1 char to become ready for reading.
 // Returns true if something available, false if not.
-bool uart_rx_wait(uint32_t timeout_us) {
+bool ICACHE_FLASH_ATTR uart_rx_wait(uint32_t timeout_us) {
     uint32_t start = system_get_time();
     for (;;) {
         if (uart_ringbuf.iget != uart_ringbuf.iput) {
@@ -288,7 +288,7 @@ void ICACHE_FLASH_ATTR uart0_set_rxbuf(uint8 *buf, int len) {
 #include "lib/utils/pyexec.h"
 
 #if MICROPY_REPL_EVENT_DRIVEN
-void uart_task_handler(os_event_t *evt) {
+void ICACHE_FLASH_ATTR uart_task_handler(os_event_t *evt) {
     if (pyexec_repl_active) {
         // TODO: Just returning here isn't exactly right.
         // What really should be done is something like
@@ -301,7 +301,7 @@ void uart_task_handler(os_event_t *evt) {
     }
 
     int c, ret = 0;
-    while ((c = ringbuf_get(&input_buf)) >= 0) {
+    while ((c = ringbuf_get(&stdin_ringbuf)) >= 0) {
         if (c == mp_interrupt_char) {
             mp_keyboard_interrupt();
         }
diff --git a/ports/esp8266/uart.h b/ports/esp8266/uart.h
index 0e67783cd83bc..de0919bde056d 100644
--- a/ports/esp8266/uart.h
+++ b/ports/esp8266/uart.h
@@ -58,17 +58,17 @@ typedef enum {
 } RcvMsgBuffState;
 
 typedef struct {
-    uint32     RcvBuffSize;
-    uint8     *pRcvMsgBuff;
-    uint8     *pWritePos;
-    uint8     *pReadPos;
-    uint8      TrigLvl; //JLU: may need to pad
-    RcvMsgBuffState  BuffState;
+    uint32 RcvBuffSize;
+    uint8 *pRcvMsgBuff;
+    uint8 *pWritePos;
+    uint8 *pReadPos;
+    uint8 TrigLvl;      // JLU: may need to pad
+    RcvMsgBuffState BuffState;
 } RcvMsgBuff;
 
 typedef struct {
-    uint32   TrxBuffSize;
-    uint8   *pTrxBuff;
+    uint32 TrxBuffSize;
+    uint8 *pTrxBuff;
 } TrxMsgBuff;
 
 typedef enum {
@@ -80,17 +80,17 @@ typedef enum {
 } RcvMsgState;
 
 typedef struct {
-    UartBautRate      baut_rate;
-    UartBitsNum4Char  data_bits;
-    UartExistParity   exist_parity;
-    UartParityMode    parity;    // chip size in byte
-    UartStopBitsNum   stop_bits;
-    UartFlowCtrl      flow_ctrl;
-    RcvMsgBuff        rcv_buff;
-    TrxMsgBuff        trx_buff;
-    RcvMsgState       rcv_state;
-    int               received;
-    int               buff_uart_no;  //indicate which uart use tx/rx buffer
+    UartBautRate baut_rate;
+    UartBitsNum4Char data_bits;
+    UartExistParity exist_parity;
+    UartParityMode parity;       // chip size in byte
+    UartStopBitsNum stop_bits;
+    UartFlowCtrl flow_ctrl;
+    RcvMsgBuff rcv_buff;
+    TrxMsgBuff trx_buff;
+    RcvMsgState rcv_state;
+    int received;
+    int buff_uart_no;                // indicate which uart use tx/rx buffer
 } UartDevice;
 
 extern uint8 uart_ringbuf_array[UART0_STATIC_RXBUF_LEN];
diff --git a/ports/esp8266/uart_register.h b/ports/esp8266/uart_register.h
index 6398879ee204a..f0d646a525212 100644
--- a/ports/esp8266/uart_register.h
+++ b/ports/esp8266/uart_register.h
@@ -1,4 +1,4 @@
-//Generated at 2012-07-03 18:44:06
+// Generated at 2012-07-03 18:44:06
 /*
  *  Copyright (c) 2010 - 2011 Espressif System
  *
@@ -6,14 +6,14 @@
 
 #ifndef UART_REGISTER_H_INCLUDED
 #define UART_REGISTER_H_INCLUDED
-#define REG_UART_BASE( i )  (0x60000000+(i)*0xf00)
-//version value:32'h062000
+#define REG_UART_BASE(i)  (0x60000000 + (i) * 0xf00)
+// version value:32'h062000
 
-#define UART_FIFO( i )                          (REG_UART_BASE( i ) + 0x0)
+#define UART_FIFO(i)                          (REG_UART_BASE(i) + 0x0)
 #define UART_RXFIFO_RD_BYTE 0x000000FF
 #define UART_RXFIFO_RD_BYTE_S 0
 
-#define UART_INT_RAW( i )                       (REG_UART_BASE( i ) + 0x4)
+#define UART_INT_RAW(i)                       (REG_UART_BASE(i) + 0x4)
 #define UART_RXFIFO_TOUT_INT_RAW (BIT(8))
 #define UART_BRK_DET_INT_RAW (BIT(7))
 #define UART_CTS_CHG_INT_RAW (BIT(6))
@@ -24,7 +24,7 @@
 #define UART_TXFIFO_EMPTY_INT_RAW (BIT(1))
 #define UART_RXFIFO_FULL_INT_RAW (BIT(0))
 
-#define UART_INT_ST( i )                        (REG_UART_BASE( i ) + 0x8)
+#define UART_INT_ST(i)                        (REG_UART_BASE(i) + 0x8)
 #define UART_RXFIFO_TOUT_INT_ST (BIT(8))
 #define UART_BRK_DET_INT_ST (BIT(7))
 #define UART_CTS_CHG_INT_ST (BIT(6))
@@ -35,7 +35,7 @@
 #define UART_TXFIFO_EMPTY_INT_ST (BIT(1))
 #define UART_RXFIFO_FULL_INT_ST (BIT(0))
 
-#define UART_INT_ENA( i )                       (REG_UART_BASE( i ) + 0xC)
+#define UART_INT_ENA(i)                       (REG_UART_BASE(i) + 0xC)
 #define UART_RXFIFO_TOUT_INT_ENA (BIT(8))
 #define UART_BRK_DET_INT_ENA (BIT(7))
 #define UART_CTS_CHG_INT_ENA (BIT(6))
@@ -46,7 +46,7 @@
 #define UART_TXFIFO_EMPTY_INT_ENA (BIT(1))
 #define UART_RXFIFO_FULL_INT_ENA (BIT(0))
 
-#define UART_INT_CLR( i )                       (REG_UART_BASE( i ) + 0x10)
+#define UART_INT_CLR(i)                       (REG_UART_BASE(i) + 0x10)
 #define UART_RXFIFO_TOUT_INT_CLR (BIT(8))
 #define UART_BRK_DET_INT_CLR (BIT(7))
 #define UART_CTS_CHG_INT_CLR (BIT(6))
@@ -57,16 +57,16 @@
 #define UART_TXFIFO_EMPTY_INT_CLR (BIT(1))
 #define UART_RXFIFO_FULL_INT_CLR (BIT(0))
 
-#define UART_CLKDIV( i )                        (REG_UART_BASE( i ) + 0x14)
+#define UART_CLKDIV(i)                        (REG_UART_BASE(i) + 0x14)
 #define UART_CLKDIV_CNT 0x000FFFFF
 #define UART_CLKDIV_S 0
 
-#define UART_AUTOBAUD( i )                      (REG_UART_BASE( i ) + 0x18)
+#define UART_AUTOBAUD(i)                      (REG_UART_BASE(i) + 0x18)
 #define UART_GLITCH_FILT 0x000000FF
 #define UART_GLITCH_FILT_S 8
 #define UART_AUTOBAUD_EN (BIT(0))
 
-#define UART_STATUS( i )                        (REG_UART_BASE( i ) + 0x1C)
+#define UART_STATUS(i)                        (REG_UART_BASE(i) + 0x1C)
 #define UART_TXD (BIT(31))
 #define UART_RTSN (BIT(30))
 #define UART_DTRN (BIT(29))
@@ -78,7 +78,7 @@
 #define UART_RXFIFO_CNT 0x000000FF
 #define UART_RXFIFO_CNT_S 0
 
-#define UART_CONF0( i )                         (REG_UART_BASE( i ) + 0x20)
+#define UART_CONF0(i)                         (REG_UART_BASE(i) + 0x20)
 #define UART_TXFIFO_RST (BIT(18))
 #define UART_RXFIFO_RST (BIT(17))
 #define UART_IRDA_EN (BIT(16))
@@ -99,7 +99,7 @@
 #define UART_PARITY_EN (BIT(1))
 #define UART_PARITY (BIT(0))
 
-#define UART_CONF1( i )                         (REG_UART_BASE( i ) + 0x24)
+#define UART_CONF1(i)                         (REG_UART_BASE(i) + 0x24)
 #define UART_RX_TOUT_EN (BIT(31))
 #define UART_RX_TOUT_THRHD 0x0000007F
 #define UART_RX_TOUT_THRHD_S 24
@@ -111,18 +111,18 @@
 #define UART_RXFIFO_FULL_THRHD 0x0000007F
 #define UART_RXFIFO_FULL_THRHD_S 0
 
-#define UART_LOWPULSE( i )                      (REG_UART_BASE( i ) + 0x28)
+#define UART_LOWPULSE(i)                      (REG_UART_BASE(i) + 0x28)
 #define UART_LOWPULSE_MIN_CNT         0x000FFFFF
 #define UART_LOWPULSE_MIN_CNT_S     0
 
-#define UART_HIGHPULSE( i )                     (REG_UART_BASE( i ) + 0x2C)
+#define UART_HIGHPULSE(i)                     (REG_UART_BASE(i) + 0x2C)
 #define UART_HIGHPULSE_MIN_CNT         0x000FFFFF
 #define UART_HIGHPULSE_MIN_CNT_S     0
 
-#define UART_PULSE_NUM( i )                     (REG_UART_BASE( i ) + 0x30)
+#define UART_PULSE_NUM(i)                     (REG_UART_BASE(i) + 0x30)
 #define UART_PULSE_NUM_CNT                  0x0003FF
 #define UART_PULSE_NUM_CNT_S               0
 
-#define UART_DATE( i )                          (REG_UART_BASE( i ) + 0x78)
-#define UART_ID( i )                            (REG_UART_BASE( i ) + 0x7C)
+#define UART_DATE(i)                          (REG_UART_BASE(i) + 0x78)
+#define UART_ID(i)                            (REG_UART_BASE(i) + 0x7C)
 #endif // UART_REGISTER_H_INCLUDED
diff --git a/ports/esp8266/xtirq.h b/ports/esp8266/xtirq.h
index 595052fc73f3c..835f06bcae957 100644
--- a/ports/esp8266/xtirq.h
+++ b/ports/esp8266/xtirq.h
@@ -31,7 +31,7 @@
 // returns the value of "intlevel" from the PS register
 static inline uint32_t query_irq(void) {
     uint32_t ps;
-    __asm__ volatile("rsr %0, ps" : "=a" (ps));
+    __asm__ volatile ("rsr %0, ps" : "=a" (ps));
     return ps & 0xf;
 }
 
@@ -45,7 +45,7 @@ static inline uint32_t raise_irq_pri(uint32_t intlevel) {
 
 // "ps" should be the value returned from raise_irq_pri
 static inline void restore_irq_pri(uint32_t ps) {
-    __asm__ volatile ("wsr %0, ps; rsync" :: "a" (ps));
+    __asm__ volatile ("wsr %0, ps; rsync" : : "a" (ps));
 }
 
 static inline uint32_t disable_irq(void) {
diff --git a/ports/javascript/Makefile b/ports/javascript/Makefile
index 9b0f4d89c0c56..4f9dd444befa0 100644
--- a/ports/javascript/Makefile
+++ b/ports/javascript/Makefile
@@ -19,12 +19,19 @@ ifdef EMSCRIPTEN
     CPP += -isystem $(EMSCRIPTEN)/system/include/libc -cxx-isystem $(EMSCRIPTEN)/system/include/libcxx
 endif
 
-CFLAGS = -m32 -Wall -Werror $(INC) -std=c99 $(COPT)
+CFLAGS = -m32 -Wall -Werror -Wdouble-promotion -Wfloat-conversion $(INC) -std=c99 $(COPT)
 LDFLAGS = -m32 -Wl,-Map=$@.map,--cref -Wl,--gc-sections
 
 CFLAGS += -O0 -DNDEBUG
 CFLAGS += -fdata-sections -ffunction-sections
 
+ifneq ($(FROZEN_MPY_DIR),)
+# To use frozen bytecode, put your .py files in a subdirectory (eg frozen/) and
+# then invoke make with FROZEN_MPY_DIR=frozen (be sure to build from scratch).
+CFLAGS += -DMICROPY_QSTR_EXTRA_POOL=mp_qstr_frozen_const_pool
+CFLAGS += -DMICROPY_MODULE_FROZEN_MPY
+endif
+
 SRC_LIB = $(addprefix lib/,\
 	utils/interrupt_char.c \
 	utils/stdout_helpers.c \
@@ -44,7 +51,7 @@ OBJ = $(PY_O)
 OBJ += $(addprefix $(BUILD)/, $(SRC_LIB:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
 
-JSFLAGS = -O0 -s EXPORTED_FUNCTIONS="['_mp_js_init', '_mp_js_init_repl', '_mp_js_do_str', '_mp_js_process_char', '_mp_hal_get_interrupt_char', '_mp_keyboard_interrupt']" -s EXTRA_EXPORTED_RUNTIME_METHODS="['ccall', 'cwrap']" --memory-init-file 0 --js-library library.js
+JSFLAGS = -O0 -s EXPORTED_FUNCTIONS="['_mp_js_init', '_mp_js_init_repl', '_mp_js_do_str', '_mp_js_process_char', '_mp_hal_get_interrupt_char', '_mp_keyboard_interrupt']" -s EXTRA_EXPORTED_RUNTIME_METHODS="['ccall', 'cwrap']" -s "BINARYEN_TRAP_MODE='clamp'" --memory-init-file 0 --js-library library.js
 
 all: $(BUILD)/micropython.js
 
diff --git a/ports/javascript/library.js b/ports/javascript/library.js
index ed58167d5d905..9aab3e4320aa1 100644
--- a/ports/javascript/library.js
+++ b/ports/javascript/library.js
@@ -27,10 +27,12 @@
 mergeInto(LibraryManager.library, {
     mp_js_write: function(ptr, len) {
         for (var i = 0; i < len; ++i) {
-            c = String.fromCharCode(getValue(ptr + i, 'i8'));
             if (typeof window === 'undefined') {
-                process.stdout.write(c);
+                var b = Buffer.alloc(1);
+                b.writeInt8(getValue(ptr + i, 'i8'));
+                process.stdout.write(b);
             } else {
+                var c = String.fromCharCode(getValue(ptr + i, 'i8'));
                 var mp_js_stdout = document.getElementById('mp_js_stdout');
                 var print = new Event('print');
                 print.data = c;
@@ -48,7 +50,7 @@ mergeInto(LibraryManager.library, {
             var mp_interrupt_char = Module.ccall('mp_hal_get_interrupt_char', 'number', ['number'], ['null']);
             var fs = require('fs');
 
-            var buf = new Buffer(1);
+            var buf = Buffer.alloc(1);
             try {
                 var n = fs.readSync(process.stdin.fd, buf, 0, 1);
                 if (n > 0) {
diff --git a/ports/javascript/main.c b/ports/javascript/main.c
index 65bae98b44d89..5d295f92956e9 100644
--- a/ports/javascript/main.c
+++ b/ports/javascript/main.c
@@ -39,30 +39,41 @@
 #include "library.h"
 
 #if MICROPY_ENABLE_COMPILER
-void do_str(const char *src, mp_parse_input_kind_t input_kind) {
+int do_str(const char *src, mp_parse_input_kind_t input_kind) {
+    int ret = 0;
     nlr_buf_t nlr;
     if (nlr_push(&nlr) == 0) {
         mp_lexer_t *lex = mp_lexer_new_from_str_len(MP_QSTR__lt_stdin_gt_, src, strlen(src), 0);
         qstr source_name = lex->source_name;
         mp_parse_tree_t parse_tree = mp_parse(lex, input_kind);
-        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, MP_EMIT_OPT_NONE, false);
+        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, false);
         mp_call_function_0(module_fun);
         nlr_pop();
     } else {
         // uncaught exception
         if (mp_obj_is_subclass_fast(mp_obj_get_type((mp_obj_t)nlr.ret_val), &mp_type_SystemExit)) {
-            // at the moment, the value of SystemExit is unused
+            mp_obj_t exit_val = mp_obj_exception_get_value(MP_OBJ_FROM_PTR(nlr.ret_val));
+            if (exit_val != mp_const_none) {
+                mp_int_t int_val;
+                if (mp_obj_get_int_maybe(exit_val, &int_val)) {
+                    ret = int_val & 255;
+                } else {
+                    ret = 1;
+                }
+            }
         } else {
             mp_obj_print_exception(&mp_plat_print, (mp_obj_t)nlr.ret_val);
+            ret = 1;
         }
     }
+    return ret;
 }
 #endif
 
 static char *stack_top;
 
-void mp_js_do_str(const char *code) {
-    do_str(code, MP_PARSE_FILE_INPUT);
+int mp_js_do_str(const char *code) {
+    return do_str(code, MP_PARSE_FILE_INPUT);
 }
 
 int mp_js_process_char(int c) {
@@ -71,10 +82,10 @@ int mp_js_process_char(int c) {
 
 void mp_js_init(int heap_size) {
     int stack_dummy;
-    stack_top = (char*)&stack_dummy;
+    stack_top = (char *)&stack_dummy;
 
     #if MICROPY_ENABLE_GC
-    char *heap = (char*)malloc(heap_size * sizeof(char));
+    char *heap = (char *)malloc(heap_size * sizeof(char));
     gc_init(heap, heap + heap_size);
     #endif
 
@@ -84,7 +95,7 @@ void mp_js_init(int heap_size) {
     #endif
 
     mp_init();
-    
+
     mp_obj_list_init(mp_sys_path, 0);
     mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR_));
     mp_obj_list_init(mp_sys_argv, 0);
@@ -102,7 +113,7 @@ void gc_collect(void) {
         longjmp(dummy, 1);
     }
     gc_collect_start();
-    gc_collect_root((void*)stack_top, ((mp_uint_t)(void*)(&dummy + 1) - (mp_uint_t)stack_top) / sizeof(mp_uint_t));
+    gc_collect_root((void *)stack_top, ((mp_uint_t)(void *)(&dummy + 1) - (mp_uint_t)stack_top) / sizeof(mp_uint_t));
     gc_collect_end();
 }
 
@@ -120,11 +131,15 @@ mp_obj_t mp_builtin_open(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs)
 MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
 
 void nlr_jump_fail(void *val) {
-    while (1);
+    while (1) {
+        ;
+    }
 }
 
 void NORETURN __fatal_error(const char *msg) {
-    while (1);
+    while (1) {
+        ;
+    }
 }
 
 #ifndef NDEBUG
diff --git a/ports/javascript/modutime.c b/ports/javascript/modutime.c
index 6c6bdcfa27227..d05d832ab153d 100644
--- a/ports/javascript/modutime.c
+++ b/ports/javascript/modutime.c
@@ -52,5 +52,5 @@ STATIC MP_DEFINE_CONST_DICT(time_module_globals, time_module_globals_table);
 
 const mp_obj_module_t mp_module_utime = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&time_module_globals,
+    .globals = (mp_obj_dict_t *)&time_module_globals,
 };
diff --git a/ports/javascript/mpconfigport.h b/ports/javascript/mpconfigport.h
index 228113c48e4ce..0101e10c8d613 100644
--- a/ports/javascript/mpconfigport.h
+++ b/ports/javascript/mpconfigport.h
@@ -36,14 +36,14 @@
 #define MICROPY_QSTR_BYTES_IN_HASH  (2)
 #define MICROPY_ALLOC_PATH_MAX      (256)
 #define MICROPY_ALLOC_PARSE_CHUNK_INIT (16)
-#define MICROPY_EMIT_X64            (0) //BROKEN
-#define MICROPY_EMIT_THUMB          (0) //BROKEN
+#define MICROPY_EMIT_X64            (0) // BROKEN
+#define MICROPY_EMIT_THUMB          (0) // BROKEN
 #define MICROPY_EMIT_INLINE_THUMB   (0)
 #define MICROPY_COMP_MODULE_CONST   (0)
 #define MICROPY_COMP_CONST          (1)
 #define MICROPY_COMP_DOUBLE_TUPLE_ASSIGN (1)
 #define MICROPY_COMP_TRIPLE_TUPLE_ASSIGN (0)
-#define MICROPY_MEM_STATS           (0) //BROKEN
+#define MICROPY_MEM_STATS           (0) // BROKEN
 #define MICROPY_DEBUG_PRINTERS      (0)
 #define MICROPY_ENABLE_GC           (1)
 #define MICROPY_GC_ALLOC_THRESHOLD  (1)
@@ -73,6 +73,7 @@
 #define MICROPY_PY_COLLECTIONS      (1)
 #define MICROPY_PY_MATH             (1)
 #define MICROPY_PY_MATH_SPECIAL_FUNCTIONS (1)
+#define MICROPY_PY_MATH_ISCLOSE     (1)
 #define MICROPY_PY_CMATH            (1)
 #define MICROPY_PY_IO               (1)
 #define MICROPY_PY_STRUCT           (1)
@@ -130,27 +131,12 @@ extern const struct _mp_obj_module_t mp_module_utime;
 #define MICROPY_PORT_BUILTIN_MODULES \
     { MP_ROM_QSTR(MP_QSTR_utime), MP_ROM_PTR(&mp_module_utime) }, \
 
-#define MICROPY_PORT_BUILTIN_MODULE_WEAK_LINKS \
-    { MP_ROM_QSTR(MP_QSTR_binascii), MP_ROM_PTR(&mp_module_ubinascii) }, \
-    { MP_ROM_QSTR(MP_QSTR_collections), MP_ROM_PTR(&mp_module_collections) }, \
-    { MP_ROM_QSTR(MP_QSTR_re), MP_ROM_PTR(&mp_module_ure) }, \
-    { MP_ROM_QSTR(MP_QSTR_zlib), MP_ROM_PTR(&mp_module_uzlib) }, \
-    { MP_ROM_QSTR(MP_QSTR_json), MP_ROM_PTR(&mp_module_ujson) }, \
-    { MP_ROM_QSTR(MP_QSTR_heapq), MP_ROM_PTR(&mp_module_uheapq) }, \
-    { MP_ROM_QSTR(MP_QSTR_hashlib), MP_ROM_PTR(&mp_module_uhashlib) }, \
-    { MP_ROM_QSTR(MP_QSTR_io), MP_ROM_PTR(&mp_module_io) }, \
-    { MP_ROM_QSTR(MP_QSTR_random), MP_ROM_PTR(&mp_module_urandom) }, \
-    { MP_ROM_QSTR(MP_QSTR_time), MP_ROM_PTR(&mp_module_utime) }, \
-    { MP_ROM_QSTR(MP_QSTR_select), MP_ROM_PTR(&mp_module_uselect) }, \
-    { MP_ROM_QSTR(MP_QSTR_struct), MP_ROM_PTR(&mp_module_ustruct) }, \
-    { MP_ROM_QSTR(MP_QSTR_errno), MP_ROM_PTR(&mp_module_uerrno) }, \
-
-//#define MICROPY_EVENT_POLL_HOOK {ets_event_poll();}
+// #define MICROPY_EVENT_POLL_HOOK {ets_event_poll();}
 #if MICROPY_PY_THREAD
 #define MICROPY_EVENT_POLL_HOOK \
     do { \
-        extern void mp_handle_pending(void); \
-        mp_handle_pending(); \
+        extern void mp_handle_pending(bool); \
+        mp_handle_pending(true); \
         if (pyb_thread_enabled) { \
             MP_THREAD_GIL_EXIT(); \
             pyb_thread_yield(); \
@@ -163,8 +149,8 @@ extern const struct _mp_obj_module_t mp_module_utime;
 #else
 #define MICROPY_EVENT_POLL_HOOK \
     do { \
-        extern void mp_handle_pending(void); \
-        mp_handle_pending(); \
+        extern void mp_handle_pending(bool); \
+        mp_handle_pending(true); \
     } while (0);
 
 #define MICROPY_THREAD_YIELD()
@@ -176,13 +162,13 @@ extern const struct _mp_obj_module_t mp_module_utime;
         vm_hook_divisor = MICROPY_VM_HOOK_COUNT; \
         extern void mp_js_hook(void); \
         mp_js_hook(); \
-    }
+}
 #define MICROPY_VM_HOOK_LOOP MICROPY_VM_HOOK_POLL
 #define MICROPY_VM_HOOK_RETURN MICROPY_VM_HOOK_POLL
 
 // type definitions for the specific machine
 
-//#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void*)((mp_uint_t)(p) | 1))
+// #define MICROPY_MAKE_POINTER_CALLABLE(p) ((void*)((mp_uint_t)(p) | 1))
 
 // This port is intended to be 32-bit, but unfortunately, int32_t for
 // different targets may be defined in different ways - either as int
diff --git a/ports/javascript/qstrdefsport.h b/ports/javascript/qstrdefsport.h
index 3ba897069bf73..00d3e2ae3c555 100644
--- a/ports/javascript/qstrdefsport.h
+++ b/ports/javascript/qstrdefsport.h
@@ -1 +1,2 @@
 // qstrs specific to this port
+// *FORMAT-OFF*
diff --git a/ports/javascript/wrapper.js b/ports/javascript/wrapper.js
index 84ad2ae3a7729..ae0f24e7e46d1 100644
--- a/ports/javascript/wrapper.js
+++ b/ports/javascript/wrapper.js
@@ -29,7 +29,7 @@ var Module = {};
 var mainProgram = function()
 {
   mp_js_init = Module.cwrap('mp_js_init', 'null', ['number']);
-  mp_js_do_str = Module.cwrap('mp_js_do_str', 'null', ['string']);
+  mp_js_do_str = Module.cwrap('mp_js_do_str', 'number', ['string']);
   mp_js_init_repl = Module.cwrap('mp_js_init_repl', 'null', ['null']);
   mp_js_process_char = Module.cwrap('mp_js_process_char', 'number', ['number']);
 
@@ -69,9 +69,9 @@ var mainProgram = function()
               }
           });
       } else {
-          mp_js_do_str(contents);
+          process.exitCode = mp_js_do_str(contents);
       }
   }
 }
 
-Module["onRuntimeInitialized"] = mainProgram;
\ No newline at end of file
+Module["onRuntimeInitialized"] = mainProgram;
diff --git a/ports/mimxrt/Makefile b/ports/mimxrt/Makefile
new file mode 100644
index 0000000000000..cbd2b8595791a
--- /dev/null
+++ b/ports/mimxrt/Makefile
@@ -0,0 +1,134 @@
+BOARD ?= TEENSY40
+BOARD_DIR ?= boards/$(BOARD)
+BUILD ?= build-$(BOARD)
+
+CROSS_COMPILE ?= arm-none-eabi-
+
+ifeq ($(wildcard $(BOARD_DIR)/.),)
+$(error Invalid BOARD specified: $(BOARD_DIR))
+endif
+
+include ../../py/mkenv.mk
+include $(BOARD_DIR)/mpconfigboard.mk
+
+# Qstr definitions (must come before including py.mk)
+QSTR_DEFS = qstrdefsport.h
+QSTR_GLOBAL_DEPENDENCIES = $(BOARD_DIR)/mpconfigboard.h
+
+# Include py core make definitions
+include $(TOP)/py/py.mk
+
+GIT_SUBMODULES = lib/tinyusb lib/nxp_driver
+
+MCU_DIR = lib/nxp_driver/sdk/devices/$(MCU_SERIES)
+LD_FILES = boards/$(MCU_SERIES).ld $(TOP)/$(MCU_DIR)/gcc/$(MCU_SERIES)xxxxx_flexspi_nor.ld
+
+# mcu driver cause following warnings
+#CFLAGS += -Wno-error=float-equal -Wno-error=nested-externs
+CFLAGS += -Wno-error=unused-parameter
+
+INC += -I.
+INC += -I$(TOP)
+INC += -I$(BUILD)
+INC += -I$(BOARD_DIR)
+INC += -I$(TOP)/lib/cmsis/inc
+INC += -I$(TOP)/$(MCU_DIR)
+INC += -I$(TOP)/$(MCU_DIR)/drivers
+INC += -I$(TOP)/$(MCU_DIR)/project_template
+INC += -I$(TOP)/lib/tinyusb/src
+INC += -I$(TOP)/lib/tinyusb/hw
+INC += -I$(TOP)/lib/tinyusb/hw/bsp/teensy_40
+
+CFLAGS_MCU = -mtune=cortex-m7 -mcpu=cortex-m7 -mfloat-abi=hard -mfpu=fpv5-d16
+CFLAGS = $(INC) -Wall -Werror -Wdouble-promotion -Wfloat-conversion -std=c99 -nostdlib -mthumb $(CFLAGS_MCU)
+CFLAGS += -DCPU_$(MCU_SERIES) -DCPU_$(MCU_VARIANT)
+CFLAGS += -DXIP_EXTERNAL_FLASH=1 \
+	-DXIP_BOOT_HEADER_ENABLE=1 \
+	-DCFG_TUSB_MCU=OPT_MCU_MIMXRT10XX \
+	-D__STARTUP_CLEAR_BSS \
+	-D__START=main \
+	-DCPU_HEADER_H='<$(MCU_SERIES).h>'
+
+LDFLAGS = $(addprefix -T,$(LD_FILES)) -Map=$@.map --cref
+LIBS = $(shell $(CC) $(CFLAGS) -print-libgcc-file-name)
+
+# Tune for Debugging or Optimization
+ifeq ($(DEBUG),1)
+CFLAGS += -O0 -ggdb
+else
+CFLAGS += -Os -DNDEBUG
+LDFLAGS += --gc-sections
+CFLAGS += -fdata-sections -ffunction-sections
+endif
+
+# TinyUSB Stack source
+SRC_TINYUSB_C += \
+	lib/tinyusb/src/tusb.c \
+	lib/tinyusb/src/common/tusb_fifo.c \
+	lib/tinyusb/src/device/usbd.c \
+	lib/tinyusb/src/device/usbd_control.c \
+	lib/tinyusb/src/class/msc/msc_device.c \
+	lib/tinyusb/src/class/cdc/cdc_device.c \
+	lib/tinyusb/src/class/dfu/dfu_rt_device.c \
+	lib/tinyusb/src/class/hid/hid_device.c \
+	lib/tinyusb/src/class/midi/midi_device.c \
+	lib/tinyusb/src/class/usbtmc/usbtmc_device.c \
+	lib/tinyusb/src/class/vendor/vendor_device.c \
+	lib/tinyusb/src/portable/nxp/transdimension/dcd_transdimension.c
+
+SRC_TINYUSB_IMX_C += \
+	$(MCU_DIR)/system_$(MCU_SERIES).c \
+	$(MCU_DIR)/xip/fsl_flexspi_nor_boot.c \
+	$(MCU_DIR)/project_template/clock_config.c \
+	$(MCU_DIR)/drivers/fsl_clock.c \
+	$(MCU_DIR)/drivers/fsl_gpio.c \
+	$(MCU_DIR)/drivers/fsl_common.c \
+	$(MCU_DIR)/drivers/fsl_lpuart.c \
+	$(MCU_DIR)/drivers/fsl_flexram.c \
+
+SRC_C = \
+	main.c \
+	tusb_port.c \
+	board_init.c \
+	$(BOARD_DIR)/flash_config.c \
+	modutime.c \
+	modmachine.c \
+	mphalport.c \
+	lib/mp-readline/readline.c \
+	lib/libc/string0.c \
+	lib/utils/gchelper_native.c \
+	lib/utils/printf.c \
+	lib/utils/pyexec.c \
+	lib/utils/stdout_helpers.c \
+	$(SRC_TINYUSB_C) \
+	$(SRC_TINYUSB_IMX_C) \
+
+SRC_SS = $(MCU_DIR)/gcc/startup_$(MCU_SERIES).S
+
+SRC_S = lib/utils/gchelper_m3.s \
+
+# List of sources for qstr extraction
+SRC_QSTR += modutime.c modmachine.c
+
+OBJ += $(PY_O)
+OBJ += $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
+OBJ += $(addprefix $(BUILD)/, $(SRC_S:.s=.o))
+OBJ += $(addprefix $(BUILD)/, $(SRC_SS:.S=.o))
+
+# Workaround for bug in older gcc, warning on "static usbd_device_t _usbd_dev = { 0 };"
+$(BUILD)/lib/tinyusb/src/device/usbd.o: CFLAGS += -Wno-missing-braces
+
+all: $(BUILD)/firmware.hex
+
+$(BUILD)/firmware.elf: $(OBJ)
+	$(ECHO) "LINK $@"
+	$(Q)$(LD) $(LDFLAGS) -o $@ $^ $(LIBS)
+	$(Q)$(SIZE) $@
+
+$(BUILD)/firmware.bin: $(BUILD)/firmware.elf
+	$(Q)$(OBJCOPY) -O binary $^ $@
+
+$(BUILD)/firmware.hex: $(BUILD)/firmware.elf
+	$(Q)$(OBJCOPY) -O ihex -R .eeprom $< $@
+
+include $(TOP)/py/mkrules.mk
diff --git a/ports/mimxrt/README.md b/ports/mimxrt/README.md
new file mode 100644
index 0000000000000..a2b5cf79a16ae
--- /dev/null
+++ b/ports/mimxrt/README.md
@@ -0,0 +1,14 @@
+Port of MicroPython to NXP iMX RT 10xx
+======================================
+
+Currently supports Teensy 4.0 and the i.MX RT1010 EVK board.
+
+Features:
+  - REPL over USB VCP
+
+Known issues:
+  - pyboard.py doesn't work with files larger than 64 bytes
+
+TODO:
+  - Enable TCM
+  - Peripherals (pins, LED, Timers, etc)
diff --git a/ports/mimxrt/board_init.c b/ports/mimxrt/board_init.c
new file mode 100644
index 0000000000000..a3c27b045bba5
--- /dev/null
+++ b/ports/mimxrt/board_init.c
@@ -0,0 +1,114 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * Based on tinyusb/hw/bsp/teensy_40/teensy40.c
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018, hathach (tinyusb.org)
+ * Copyright (c) 2020, Jim Mussared
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+
+#include "tusb.h"
+
+#include "fsl_device_registers.h"
+#include "fsl_gpio.h"
+#include "fsl_iomuxc.h"
+#include "fsl_clock.h"
+#include "fsl_lpuart.h"
+
+#include "clock_config.h"
+
+#define LED_STATE_ON (0)
+
+volatile uint32_t systick_ms = 0;
+
+const uint8_t dcd_data[] = { 0x00 };
+
+void board_led_write(bool state);
+
+void board_init(void) {
+    // Init clock
+    BOARD_BootClockRUN();
+    SystemCoreClockUpdate();
+
+    // Enable IOCON clock
+    CLOCK_EnableClock(kCLOCK_Iomuxc);
+
+    // 1ms tick timer
+    SysTick_Config(SystemCoreClock / 1000);
+
+    // LED
+    IOMUXC_SetPinMux(MICROPY_HW_LED_PINMUX, 0U);
+    IOMUXC_SetPinConfig(MICROPY_HW_LED_PINMUX, 0x10B0U);
+
+    gpio_pin_config_t led_config = { kGPIO_DigitalOutput, 0, kGPIO_NoIntmode };
+    GPIO_PinInit(MICROPY_HW_LED_PORT, MICROPY_HW_LED_PIN, &led_config);
+    board_led_write(true);
+
+    // ------------- USB0 ------------- //
+
+    // Clock
+    CLOCK_EnableUsbhs0PhyPllClock(kCLOCK_Usbphy480M, 480000000U);
+    CLOCK_EnableUsbhs0Clock(kCLOCK_Usb480M, 480000000U);
+
+    #ifdef USBPHY1
+    USBPHY_Type *usb_phy = USBPHY1;
+    #else
+    USBPHY_Type *usb_phy = USBPHY;
+    #endif
+
+    // Enable PHY support for Low speed device + LS via FS Hub
+    usb_phy->CTRL |= USBPHY_CTRL_SET_ENUTMILEVEL2_MASK | USBPHY_CTRL_SET_ENUTMILEVEL3_MASK;
+
+    // Enable all power for normal operation
+    usb_phy->PWD = 0;
+
+    // TX Timing
+    uint32_t phytx = usb_phy->TX;
+    phytx &= ~(USBPHY_TX_D_CAL_MASK | USBPHY_TX_TXCAL45DM_MASK | USBPHY_TX_TXCAL45DP_MASK);
+    phytx |= USBPHY_TX_D_CAL(0x0C) | USBPHY_TX_TXCAL45DP(0x06) | USBPHY_TX_TXCAL45DM(0x06);
+    usb_phy->TX = phytx;
+
+    // USB1
+    //  CLOCK_EnableUsbhs1PhyPllClock(kCLOCK_Usbphy480M, 480000000U);
+    //  CLOCK_EnableUsbhs1Clock(kCLOCK_Usb480M, 480000000U);
+}
+
+void board_led_write(bool state) {
+    GPIO_PinWrite(MICROPY_HW_LED_PORT, MICROPY_HW_LED_PIN, state ? LED_STATE_ON : (1 - LED_STATE_ON));
+}
+
+void SysTick_Handler(void) {
+    systick_ms++;
+}
+
+void USB_OTG1_IRQHandler(void) {
+    tud_isr(0);
+    tud_task();
+}
+
+void USB_OTG2_IRQHandler(void) {
+    tud_isr(1);
+    tud_task();
+}
diff --git a/ports/mimxrt/boards/MIMXRT1010_EVK/evkmimxrt1010_flexspi_nor_config.h b/ports/mimxrt/boards/MIMXRT1010_EVK/evkmimxrt1010_flexspi_nor_config.h
new file mode 100644
index 0000000000000..8fa31c8320f33
--- /dev/null
+++ b/ports/mimxrt/boards/MIMXRT1010_EVK/evkmimxrt1010_flexspi_nor_config.h
@@ -0,0 +1,269 @@
+/*
+ * Copyright 2019 NXP
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+// Based on tinyusb/hw/bsp/teensy_40/evkmimxrt1010_flexspi_nor_config.h
+
+#ifndef __EVKMIMXRT1011_FLEXSPI_NOR_CONFIG__
+#define __EVKMIMXRT1011_FLEXSPI_NOR_CONFIG__
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "fsl_common.h"
+
+/*! @name Driver version */
+/*@{*/
+/*! @brief XIP_BOARD driver version 2.0.0. */
+#define FSL_XIP_BOARD_DRIVER_VERSION (MAKE_VERSION(2, 0, 0))
+/*@}*/
+
+/* FLEXSPI memory config block related defintions */
+#define FLEXSPI_CFG_BLK_TAG (0x42464346UL)     // ascii "FCFB" Big Endian
+#define FLEXSPI_CFG_BLK_VERSION (0x56010400UL) // V1.4.0
+#define FLEXSPI_CFG_BLK_SIZE (512)
+
+/* FLEXSPI Feature related definitions */
+#define FLEXSPI_FEATURE_HAS_PARALLEL_MODE 1
+
+/* Lookup table related defintions */
+#define CMD_INDEX_READ 0
+#define CMD_INDEX_READSTATUS 1
+#define CMD_INDEX_WRITEENABLE 2
+#define CMD_INDEX_WRITE 4
+
+#define CMD_LUT_SEQ_IDX_READ 0
+#define CMD_LUT_SEQ_IDX_READSTATUS 1
+#define CMD_LUT_SEQ_IDX_WRITEENABLE 3
+#define CMD_LUT_SEQ_IDX_WRITE 9
+
+#define CMD_SDR 0x01
+#define CMD_DDR 0x21
+#define RADDR_SDR 0x02
+#define RADDR_DDR 0x22
+#define CADDR_SDR 0x03
+#define CADDR_DDR 0x23
+#define MODE1_SDR 0x04
+#define MODE1_DDR 0x24
+#define MODE2_SDR 0x05
+#define MODE2_DDR 0x25
+#define MODE4_SDR 0x06
+#define MODE4_DDR 0x26
+#define MODE8_SDR 0x07
+#define MODE8_DDR 0x27
+#define WRITE_SDR 0x08
+#define WRITE_DDR 0x28
+#define READ_SDR 0x09
+#define READ_DDR 0x29
+#define LEARN_SDR 0x0A
+#define LEARN_DDR 0x2A
+#define DATSZ_SDR 0x0B
+#define DATSZ_DDR 0x2B
+#define DUMMY_SDR 0x0C
+#define DUMMY_DDR 0x2C
+#define DUMMY_RWDS_SDR 0x0D
+#define DUMMY_RWDS_DDR 0x2D
+#define JMP_ON_CS 0x1F
+#define STOP 0
+
+#define FLEXSPI_1PAD 0
+#define FLEXSPI_2PAD 1
+#define FLEXSPI_4PAD 2
+#define FLEXSPI_8PAD 3
+
+#define FLEXSPI_LUT_SEQ(cmd0, pad0, op0, cmd1, pad1, op1)                                                              \
+    (FLEXSPI_LUT_OPERAND0(op0) | FLEXSPI_LUT_NUM_PADS0(pad0) | FLEXSPI_LUT_OPCODE0(cmd0) | FLEXSPI_LUT_OPERAND1(op1) | \
+     FLEXSPI_LUT_NUM_PADS1(pad1) | FLEXSPI_LUT_OPCODE1(cmd1))
+
+//!@brief Definitions for FlexSPI Serial Clock Frequency
+typedef enum _FlexSpiSerialClockFreq
+{
+    kFlexSpiSerialClk_30MHz  = 1,
+    kFlexSpiSerialClk_50MHz  = 2,
+    kFlexSpiSerialClk_60MHz  = 3,
+    kFlexSpiSerialClk_75MHz  = 4,
+    kFlexSpiSerialClk_80MHz  = 5,
+    kFlexSpiSerialClk_100MHz = 6,
+    kFlexSpiSerialClk_120MHz = 7,
+    kFlexSpiSerialClk_133MHz = 8,
+} flexspi_serial_clk_freq_t;
+
+//!@brief FlexSPI clock configuration type
+enum
+{
+    kFlexSpiClk_SDR, //!< Clock configure for SDR mode
+    kFlexSpiClk_DDR, //!< Clock configurat for DDR mode
+};
+
+//!@brief FlexSPI Read Sample Clock Source definition
+typedef enum _FlashReadSampleClkSource
+{
+    kFlexSPIReadSampleClk_LoopbackInternally      = 0,
+    kFlexSPIReadSampleClk_LoopbackFromDqsPad      = 1,
+    kFlexSPIReadSampleClk_LoopbackFromSckPad      = 2,
+    kFlexSPIReadSampleClk_ExternalInputFromDqsPad = 3,
+} flexspi_read_sample_clk_t;
+
+//!@brief Misc feature bit definitions
+enum
+{
+    kFlexSpiMiscOffset_DiffClkEnable            = 0, //!< Bit for Differential clock enable
+    kFlexSpiMiscOffset_Ck2Enable                = 1, //!< Bit for CK2 enable
+    kFlexSpiMiscOffset_ParallelEnable           = 2, //!< Bit for Parallel mode enable
+    kFlexSpiMiscOffset_WordAddressableEnable    = 3, //!< Bit for Word Addressable enable
+    kFlexSpiMiscOffset_SafeConfigFreqEnable     = 4, //!< Bit for Safe Configuration Frequency enable
+    kFlexSpiMiscOffset_PadSettingOverrideEnable = 5, //!< Bit for Pad setting override enable
+    kFlexSpiMiscOffset_DdrModeEnable            = 6, //!< Bit for DDR clock confiuration indication.
+};
+
+//!@brief Flash Type Definition
+enum
+{
+    kFlexSpiDeviceType_SerialNOR    = 1,    //!< Flash devices are Serial NOR
+    kFlexSpiDeviceType_SerialNAND   = 2,    //!< Flash devices are Serial NAND
+    kFlexSpiDeviceType_SerialRAM    = 3,    //!< Flash devices are Serial RAM/HyperFLASH
+    kFlexSpiDeviceType_MCP_NOR_NAND = 0x12, //!< Flash device is MCP device, A1 is Serial NOR, A2 is Serial NAND
+    kFlexSpiDeviceType_MCP_NOR_RAM  = 0x13, //!< Flash deivce is MCP device, A1 is Serial NOR, A2 is Serial RAMs
+};
+
+//!@brief Flash Pad Definitions
+enum
+{
+    kSerialFlash_1Pad  = 1,
+    kSerialFlash_2Pads = 2,
+    kSerialFlash_4Pads = 4,
+    kSerialFlash_8Pads = 8,
+};
+
+//!@brief FlexSPI LUT Sequence structure
+typedef struct _lut_sequence
+{
+    uint8_t seqNum; //!< Sequence Number, valid number: 1-16
+    uint8_t seqId;  //!< Sequence Index, valid number: 0-15
+    uint16_t reserved;
+} flexspi_lut_seq_t;
+
+//!@brief Flash Configuration Command Type
+enum
+{
+    kDeviceConfigCmdType_Generic,    //!< Generic command, for example: configure dummy cycles, drive strength, etc
+    kDeviceConfigCmdType_QuadEnable, //!< Quad Enable command
+    kDeviceConfigCmdType_Spi2Xpi,    //!< Switch from SPI to DPI/QPI/OPI mode
+    kDeviceConfigCmdType_Xpi2Spi,    //!< Switch from DPI/QPI/OPI to SPI mode
+    kDeviceConfigCmdType_Spi2NoCmd,  //!< Switch to 0-4-4/0-8-8 mode
+    kDeviceConfigCmdType_Reset,      //!< Reset device command
+};
+
+//!@brief FlexSPI Memory Configuration Block
+typedef struct _FlexSPIConfig
+{
+    uint32_t tag;               //!< [0x000-0x003] Tag, fixed value 0x42464346UL
+    uint32_t version;           //!< [0x004-0x007] Version,[31:24] -'V', [23:16] - Major, [15:8] - Minor, [7:0] - bugfix
+    uint32_t reserved0;         //!< [0x008-0x00b] Reserved for future use
+    uint8_t readSampleClkSrc;   //!< [0x00c-0x00c] Read Sample Clock Source, valid value: 0/1/3
+    uint8_t csHoldTime;         //!< [0x00d-0x00d] CS hold time, default value: 3
+    uint8_t csSetupTime;        //!< [0x00e-0x00e] CS setup time, default value: 3
+    uint8_t columnAddressWidth; //!< [0x00f-0x00f] Column Address with, for HyperBus protocol, it is fixed to 3, For
+    //! Serial NAND, need to refer to datasheet
+    uint8_t deviceModeCfgEnable; //!< [0x010-0x010] Device Mode Configure enable flag, 1 - Enable, 0 - Disable
+    uint8_t deviceModeType; //!< [0x011-0x011] Specify the configuration command type:Quad Enable, DPI/QPI/OPI switch,
+    //! Generic configuration, etc.
+    uint16_t waitTimeCfgCommands; //!< [0x012-0x013] Wait time for all configuration commands, unit: 100us, Used for
+    //! DPI/QPI/OPI switch or reset command
+    flexspi_lut_seq_t deviceModeSeq; //!< [0x014-0x017] Device mode sequence info, [7:0] - LUT sequence id, [15:8] - LUt
+    //! sequence number, [31:16] Reserved
+    uint32_t deviceModeArg;    //!< [0x018-0x01b] Argument/Parameter for device configuration
+    uint8_t configCmdEnable;   //!< [0x01c-0x01c] Configure command Enable Flag, 1 - Enable, 0 - Disable
+    uint8_t configModeType[3]; //!< [0x01d-0x01f] Configure Mode Type, similar as deviceModeTpe
+    flexspi_lut_seq_t
+        configCmdSeqs[3]; //!< [0x020-0x02b] Sequence info for Device Configuration command, similar as deviceModeSeq
+    uint32_t reserved1;   //!< [0x02c-0x02f] Reserved for future use
+    uint32_t configCmdArgs[3];     //!< [0x030-0x03b] Arguments/Parameters for device Configuration commands
+    uint32_t reserved2;            //!< [0x03c-0x03f] Reserved for future use
+    uint32_t controllerMiscOption; //!< [0x040-0x043] Controller Misc Options, see Misc feature bit definitions for more
+    //! details
+    uint8_t deviceType;    //!< [0x044-0x044] Device Type:  See Flash Type Definition for more details
+    uint8_t sflashPadType; //!< [0x045-0x045] Serial Flash Pad Type: 1 - Single, 2 - Dual, 4 - Quad, 8 - Octal
+    uint8_t serialClkFreq; //!< [0x046-0x046] Serial Flash Frequencey, device specific definitions, See System Boot
+    //! Chapter for more details
+    uint8_t lutCustomSeqEnable; //!< [0x047-0x047] LUT customization Enable, it is required if the program/erase cannot
+    //! be done using 1 LUT sequence, currently, only applicable to HyperFLASH
+    uint32_t reserved3[2];           //!< [0x048-0x04f] Reserved for future use
+    uint32_t sflashA1Size;           //!< [0x050-0x053] Size of Flash connected to A1
+    uint32_t sflashA2Size;           //!< [0x054-0x057] Size of Flash connected to A2
+    uint32_t sflashB1Size;           //!< [0x058-0x05b] Size of Flash connected to B1
+    uint32_t sflashB2Size;           //!< [0x05c-0x05f] Size of Flash connected to B2
+    uint32_t csPadSettingOverride;   //!< [0x060-0x063] CS pad setting override value
+    uint32_t sclkPadSettingOverride; //!< [0x064-0x067] SCK pad setting override value
+    uint32_t dataPadSettingOverride; //!< [0x068-0x06b] data pad setting override value
+    uint32_t dqsPadSettingOverride;  //!< [0x06c-0x06f] DQS pad setting override value
+    uint32_t timeoutInMs;            //!< [0x070-0x073] Timeout threshold for read status command
+    uint32_t commandInterval;        //!< [0x074-0x077] CS deselect interval between two commands
+    uint16_t dataValidTime[2]; //!< [0x078-0x07b] CLK edge to data valid time for PORT A and PORT B, in terms of 0.1ns
+    uint16_t busyOffset;       //!< [0x07c-0x07d] Busy offset, valid value: 0-31
+    uint16_t busyBitPolarity;  //!< [0x07e-0x07f] Busy flag polarity, 0 - busy flag is 1 when flash device is busy, 1 -
+    //! busy flag is 0 when flash device is busy
+    uint32_t lookupTable[64];           //!< [0x080-0x17f] Lookup table holds Flash command sequences
+    flexspi_lut_seq_t lutCustomSeq[12]; //!< [0x180-0x1af] Customizable LUT Sequences
+    uint32_t reserved4[4];              //!< [0x1b0-0x1bf] Reserved for future use
+} flexspi_mem_config_t;
+
+/*  */
+#define NOR_CMD_INDEX_READ CMD_INDEX_READ               //!< 0
+#define NOR_CMD_INDEX_READSTATUS CMD_INDEX_READSTATUS   //!< 1
+#define NOR_CMD_INDEX_WRITEENABLE CMD_INDEX_WRITEENABLE //!< 2
+#define NOR_CMD_INDEX_ERASESECTOR 3                     //!< 3
+#define NOR_CMD_INDEX_PAGEPROGRAM CMD_INDEX_WRITE       //!< 4
+#define NOR_CMD_INDEX_CHIPERASE 5                       //!< 5
+#define NOR_CMD_INDEX_DUMMY 6                           //!< 6
+#define NOR_CMD_INDEX_ERASEBLOCK 7                      //!< 7
+
+#define NOR_CMD_LUT_SEQ_IDX_READ CMD_LUT_SEQ_IDX_READ //!< 0  READ LUT sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_READSTATUS \
+    CMD_LUT_SEQ_IDX_READSTATUS //!< 1  Read Status LUT sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_READSTATUS_XPI \
+    2 //!< 2  Read status DPI/QPI/OPI sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_WRITEENABLE \
+    CMD_LUT_SEQ_IDX_WRITEENABLE //!< 3  Write Enable sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_WRITEENABLE_XPI \
+    4 //!< 4  Write Enable DPI/QPI/OPI sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_ERASESECTOR 5 //!< 5  Erase Sector sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_ERASEBLOCK 8  //!< 8 Erase Block sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_PAGEPROGRAM \
+    CMD_LUT_SEQ_IDX_WRITE                //!< 9  Program sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_CHIPERASE 11 //!< 11 Chip Erase sequence in lookupTable id stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_READ_SFDP 13 //!< 13 Read SFDP sequence in lookupTable id stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_RESTORE_NOCMD \
+    14 //!< 14 Restore 0-4-4/0-8-8 mode sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_EXIT_NOCMD \
+    15 //!< 15 Exit 0-4-4/0-8-8 mode sequence id in lookupTable stored in config blobk
+
+/*
+ *  Serial NOR configuration block
+ */
+typedef struct _flexspi_nor_config
+{
+    flexspi_mem_config_t memConfig; //!< Common memory configuration info via FlexSPI
+    uint32_t pageSize;              //!< Page size of Serial NOR
+    uint32_t sectorSize;            //!< Sector size of Serial NOR
+    uint8_t ipcmdSerialClkFreq;     //!< Clock frequency for IP command
+    uint8_t isUniformBlockSize;     //!< Sector/Block size is the same
+    uint8_t reserved0[2];           //!< Reserved for future use
+    uint8_t serialNorType;          //!< Serial NOR Flash type: 0/1/2/3
+    uint8_t needExitNoCmdMode;      //!< Need to exit NoCmd mode before other IP command
+    uint8_t halfClkForNonReadCmd;   //!< Half the Serial Clock for non-read command: true/false
+    uint8_t needRestoreNoCmdMode;   //!< Need to Restore NoCmd mode after IP commmand execution
+    uint32_t blockSize;             //!< Block size
+    uint32_t reserve2[11];          //!< Reserved for future use
+} flexspi_nor_config_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __EVKMIMXRT1011_FLEXSPI_NOR_CONFIG__ */
diff --git a/ports/mimxrt/boards/MIMXRT1010_EVK/flash_config.c b/ports/mimxrt/boards/MIMXRT1010_EVK/flash_config.c
new file mode 100644
index 0000000000000..a03ee07865ba9
--- /dev/null
+++ b/ports/mimxrt/boards/MIMXRT1010_EVK/flash_config.c
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2019 NXP
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+// Based on tinyusb/hw/bsp/teensy_40/evkmimxrt1010_flexspi_nor_config.c
+
+#include "evkmimxrt1010_flexspi_nor_config.h"
+
+/* Component ID definition, used by tools. */
+#ifndef FSL_COMPONENT_ID
+#define FSL_COMPONENT_ID "platform.drivers.xip_board"
+#endif
+
+/*******************************************************************************
+ * Code
+ ******************************************************************************/
+#if defined(XIP_BOOT_HEADER_ENABLE) && (XIP_BOOT_HEADER_ENABLE == 1)
+#if defined(__CC_ARM) || defined(__ARMCC_VERSION) || defined(__GNUC__)
+__attribute__((section(".boot_hdr.conf")))
+#elif defined(__ICCARM__)
+#pragma location = ".boot_hdr.conf"
+#endif
+
+const flexspi_nor_config_t qspiflash_config = {
+    .memConfig =
+        {
+            .tag              = FLEXSPI_CFG_BLK_TAG,
+            .version          = FLEXSPI_CFG_BLK_VERSION,
+            .readSampleClkSrc = kFlexSPIReadSampleClk_LoopbackFromDqsPad,
+            .csHoldTime       = 3u,
+            .csSetupTime      = 3u,
+            .sflashPadType    = kSerialFlash_4Pads,
+            .serialClkFreq    = kFlexSpiSerialClk_100MHz,
+            .sflashA1Size     = 16u * 1024u * 1024u,
+            .lookupTable =
+                {
+                    // Read LUTs
+                    FLEXSPI_LUT_SEQ(CMD_SDR, FLEXSPI_1PAD, 0xEB, RADDR_SDR, FLEXSPI_4PAD, 0x18),
+                    FLEXSPI_LUT_SEQ(DUMMY_SDR, FLEXSPI_4PAD, 0x06, READ_SDR, FLEXSPI_4PAD, 0x04),
+                },
+        },
+    .pageSize           = 256u,
+    .sectorSize         = 4u * 1024u,
+    .blockSize          = 256u * 1024u,
+    .isUniformBlockSize = false,
+};
+#endif /* XIP_BOOT_HEADER_ENABLE */
diff --git a/ports/mimxrt/boards/MIMXRT1010_EVK/mpconfigboard.h b/ports/mimxrt/boards/MIMXRT1010_EVK/mpconfigboard.h
new file mode 100644
index 0000000000000..02d34fc42f052
--- /dev/null
+++ b/ports/mimxrt/boards/MIMXRT1010_EVK/mpconfigboard.h
@@ -0,0 +1,8 @@
+#define MICROPY_HW_BOARD_NAME "i.MX RT1010 EVK"
+#define MICROPY_HW_MCU_NAME   "MIMXRT1011DAE5A"
+
+#define BOARD_FLASH_SIZE (16 * 1024 * 1024)
+
+#define MICROPY_HW_LED_PINMUX  IOMUXC_GPIO_11_GPIOMUX_IO11
+#define MICROPY_HW_LED_PORT    GPIO1
+#define MICROPY_HW_LED_PIN     11
diff --git a/ports/mimxrt/boards/MIMXRT1010_EVK/mpconfigboard.mk b/ports/mimxrt/boards/MIMXRT1010_EVK/mpconfigboard.mk
new file mode 100644
index 0000000000000..e178545845b2d
--- /dev/null
+++ b/ports/mimxrt/boards/MIMXRT1010_EVK/mpconfigboard.mk
@@ -0,0 +1,7 @@
+MCU_SERIES = MIMXRT1011
+MCU_VARIANT = MIMXRT1011DAE5A
+
+JLINK_PATH = /media/RT1010-EVK/
+
+deploy: $(BUILD)/firmware.bin
+	cp $< $(JLINK_PATH)
diff --git a/ports/mimxrt/boards/MIMXRT1011.ld b/ports/mimxrt/boards/MIMXRT1011.ld
new file mode 100644
index 0000000000000..6b59649fcaf7e
--- /dev/null
+++ b/ports/mimxrt/boards/MIMXRT1011.ld
@@ -0,0 +1,8 @@
+/* 24kiB stack. */
+__stack_size__ = 0x6000;
+_estack = __StackTop;
+_sstack = __StackLimit;
+
+/* Use second OCRAM bank for GC heap. */
+_gc_heap_start = ORIGIN(m_data2);
+_gc_heap_end = ORIGIN(m_data2) + LENGTH(m_data2);
diff --git a/ports/mimxrt/boards/MIMXRT1060_EVK/evkmimxrt1060_flexspi_nor_config.h b/ports/mimxrt/boards/MIMXRT1060_EVK/evkmimxrt1060_flexspi_nor_config.h
new file mode 100644
index 0000000000000..8bb771fd8ad44
--- /dev/null
+++ b/ports/mimxrt/boards/MIMXRT1060_EVK/evkmimxrt1060_flexspi_nor_config.h
@@ -0,0 +1,268 @@
+/*
+ * Copyright 2018 NXP
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef __EVKMIMXRT1060_FLEXSPI_NOR_CONFIG__
+#define __EVKMIMXRT1060_FLEXSPI_NOR_CONFIG__
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "fsl_common.h"
+
+/*! @name Driver version */
+/*@{*/
+/*! @brief XIP_BOARD driver version 2.0.0. */
+#define FSL_XIP_BOARD_DRIVER_VERSION (MAKE_VERSION(2, 0, 0))
+/*@}*/
+
+/* FLEXSPI memory config block related defintions */
+#define FLEXSPI_CFG_BLK_TAG     (0x42464346UL) // ascii "FCFB" Big Endian
+#define FLEXSPI_CFG_BLK_VERSION (0x56010400UL) // V1.4.0
+#define FLEXSPI_CFG_BLK_SIZE    (512)
+
+/* FLEXSPI Feature related definitions */
+#define FLEXSPI_FEATURE_HAS_PARALLEL_MODE 1
+
+/* Lookup table related defintions */
+#define CMD_INDEX_READ        0
+#define CMD_INDEX_READSTATUS  1
+#define CMD_INDEX_WRITEENABLE 2
+#define CMD_INDEX_WRITE       4
+
+#define CMD_LUT_SEQ_IDX_READ        0
+#define CMD_LUT_SEQ_IDX_READSTATUS  1
+#define CMD_LUT_SEQ_IDX_WRITEENABLE 3
+#define CMD_LUT_SEQ_IDX_WRITE       9
+
+#define CMD_SDR        0x01
+#define CMD_DDR        0x21
+#define RADDR_SDR      0x02
+#define RADDR_DDR      0x22
+#define CADDR_SDR      0x03
+#define CADDR_DDR      0x23
+#define MODE1_SDR      0x04
+#define MODE1_DDR      0x24
+#define MODE2_SDR      0x05
+#define MODE2_DDR      0x25
+#define MODE4_SDR      0x06
+#define MODE4_DDR      0x26
+#define MODE8_SDR      0x07
+#define MODE8_DDR      0x27
+#define WRITE_SDR      0x08
+#define WRITE_DDR      0x28
+#define READ_SDR       0x09
+#define READ_DDR       0x29
+#define LEARN_SDR      0x0A
+#define LEARN_DDR      0x2A
+#define DATSZ_SDR      0x0B
+#define DATSZ_DDR      0x2B
+#define DUMMY_SDR      0x0C
+#define DUMMY_DDR      0x2C
+#define DUMMY_RWDS_SDR 0x0D
+#define DUMMY_RWDS_DDR 0x2D
+#define JMP_ON_CS      0x1F
+#define STOP           0
+
+#define FLEXSPI_1PAD 0
+#define FLEXSPI_2PAD 1
+#define FLEXSPI_4PAD 2
+#define FLEXSPI_8PAD 3
+
+#define FLEXSPI_LUT_SEQ(cmd0, pad0, op0, cmd1, pad1, op1)                                                              \
+    (FLEXSPI_LUT_OPERAND0(op0) | FLEXSPI_LUT_NUM_PADS0(pad0) | FLEXSPI_LUT_OPCODE0(cmd0) | FLEXSPI_LUT_OPERAND1(op1) | \
+     FLEXSPI_LUT_NUM_PADS1(pad1) | FLEXSPI_LUT_OPCODE1(cmd1))
+
+//!@brief Definitions for FlexSPI Serial Clock Frequency
+typedef enum _FlexSpiSerialClockFreq
+{
+    kFlexSpiSerialClk_30MHz  = 1,
+    kFlexSpiSerialClk_50MHz  = 2,
+    kFlexSpiSerialClk_60MHz  = 3,
+    kFlexSpiSerialClk_75MHz  = 4,
+    kFlexSpiSerialClk_80MHz  = 5,
+    kFlexSpiSerialClk_100MHz = 6,
+    kFlexSpiSerialClk_120MHz = 7,
+    kFlexSpiSerialClk_133MHz = 8,
+    kFlexSpiSerialClk_166MHz = 9,
+} flexspi_serial_clk_freq_t;
+
+//!@brief FlexSPI clock configuration type
+enum
+{
+    kFlexSpiClk_SDR, //!< Clock configure for SDR mode
+    kFlexSpiClk_DDR, //!< Clock configurat for DDR mode
+};
+
+//!@brief FlexSPI Read Sample Clock Source definition
+typedef enum _FlashReadSampleClkSource
+{
+    kFlexSPIReadSampleClk_LoopbackInternally      = 0,
+    kFlexSPIReadSampleClk_LoopbackFromDqsPad      = 1,
+    kFlexSPIReadSampleClk_LoopbackFromSckPad      = 2,
+    kFlexSPIReadSampleClk_ExternalInputFromDqsPad = 3,
+} flexspi_read_sample_clk_t;
+
+//!@brief Misc feature bit definitions
+enum
+{
+    kFlexSpiMiscOffset_DiffClkEnable            = 0, //!< Bit for Differential clock enable
+    kFlexSpiMiscOffset_Ck2Enable                = 1, //!< Bit for CK2 enable
+    kFlexSpiMiscOffset_ParallelEnable           = 2, //!< Bit for Parallel mode enable
+    kFlexSpiMiscOffset_WordAddressableEnable    = 3, //!< Bit for Word Addressable enable
+    kFlexSpiMiscOffset_SafeConfigFreqEnable     = 4, //!< Bit for Safe Configuration Frequency enable
+    kFlexSpiMiscOffset_PadSettingOverrideEnable = 5, //!< Bit for Pad setting override enable
+    kFlexSpiMiscOffset_DdrModeEnable            = 6, //!< Bit for DDR clock confiuration indication.
+};
+
+//!@brief Flash Type Definition
+enum
+{
+    kFlexSpiDeviceType_SerialNOR    = 1,    //!< Flash devices are Serial NOR
+    kFlexSpiDeviceType_SerialNAND   = 2,    //!< Flash devices are Serial NAND
+    kFlexSpiDeviceType_SerialRAM    = 3,    //!< Flash devices are Serial RAM/HyperFLASH
+    kFlexSpiDeviceType_MCP_NOR_NAND = 0x12, //!< Flash device is MCP device, A1 is Serial NOR, A2 is Serial NAND
+    kFlexSpiDeviceType_MCP_NOR_RAM  = 0x13, //!< Flash deivce is MCP device, A1 is Serial NOR, A2 is Serial RAMs
+};
+
+//!@brief Flash Pad Definitions
+enum
+{
+    kSerialFlash_1Pad  = 1,
+    kSerialFlash_2Pads = 2,
+    kSerialFlash_4Pads = 4,
+    kSerialFlash_8Pads = 8,
+};
+
+//!@brief FlexSPI LUT Sequence structure
+typedef struct _lut_sequence
+{
+    uint8_t seqNum; //!< Sequence Number, valid number: 1-16
+    uint8_t seqId;  //!< Sequence Index, valid number: 0-15
+    uint16_t reserved;
+} flexspi_lut_seq_t;
+
+//!@brief Flash Configuration Command Type
+enum
+{
+    kDeviceConfigCmdType_Generic,    //!< Generic command, for example: configure dummy cycles, drive strength, etc
+    kDeviceConfigCmdType_QuadEnable, //!< Quad Enable command
+    kDeviceConfigCmdType_Spi2Xpi,    //!< Switch from SPI to DPI/QPI/OPI mode
+    kDeviceConfigCmdType_Xpi2Spi,    //!< Switch from DPI/QPI/OPI to SPI mode
+    kDeviceConfigCmdType_Spi2NoCmd,  //!< Switch to 0-4-4/0-8-8 mode
+    kDeviceConfigCmdType_Reset,      //!< Reset device command
+};
+
+//!@brief FlexSPI Memory Configuration Block
+typedef struct _FlexSPIConfig
+{
+    uint32_t tag;               //!< [0x000-0x003] Tag, fixed value 0x42464346UL
+    uint32_t version;           //!< [0x004-0x007] Version,[31:24] -'V', [23:16] - Major, [15:8] - Minor, [7:0] - bugfix
+    uint32_t reserved0;         //!< [0x008-0x00b] Reserved for future use
+    uint8_t readSampleClkSrc;   //!< [0x00c-0x00c] Read Sample Clock Source, valid value: 0/1/3
+    uint8_t csHoldTime;         //!< [0x00d-0x00d] CS hold time, default value: 3
+    uint8_t csSetupTime;        //!< [0x00e-0x00e] CS setup time, default value: 3
+    uint8_t columnAddressWidth; //!< [0x00f-0x00f] Column Address with, for HyperBus protocol, it is fixed to 3, For
+    //! Serial NAND, need to refer to datasheet
+    uint8_t deviceModeCfgEnable; //!< [0x010-0x010] Device Mode Configure enable flag, 1 - Enable, 0 - Disable
+    uint8_t deviceModeType; //!< [0x011-0x011] Specify the configuration command type:Quad Enable, DPI/QPI/OPI switch,
+    //! Generic configuration, etc.
+    uint16_t waitTimeCfgCommands; //!< [0x012-0x013] Wait time for all configuration commands, unit: 100us, Used for
+    //! DPI/QPI/OPI switch or reset command
+    flexspi_lut_seq_t deviceModeSeq; //!< [0x014-0x017] Device mode sequence info, [7:0] - LUT sequence id, [15:8] - LUt
+    //! sequence number, [31:16] Reserved
+    uint32_t deviceModeArg;    //!< [0x018-0x01b] Argument/Parameter for device configuration
+    uint8_t configCmdEnable;   //!< [0x01c-0x01c] Configure command Enable Flag, 1 - Enable, 0 - Disable
+    uint8_t configModeType[3]; //!< [0x01d-0x01f] Configure Mode Type, similar as deviceModeTpe
+    flexspi_lut_seq_t
+        configCmdSeqs[3]; //!< [0x020-0x02b] Sequence info for Device Configuration command, similar as deviceModeSeq
+    uint32_t reserved1;   //!< [0x02c-0x02f] Reserved for future use
+    uint32_t configCmdArgs[3];     //!< [0x030-0x03b] Arguments/Parameters for device Configuration commands
+    uint32_t reserved2;            //!< [0x03c-0x03f] Reserved for future use
+    uint32_t controllerMiscOption; //!< [0x040-0x043] Controller Misc Options, see Misc feature bit definitions for more
+    //! details
+    uint8_t deviceType;    //!< [0x044-0x044] Device Type:  See Flash Type Definition for more details
+    uint8_t sflashPadType; //!< [0x045-0x045] Serial Flash Pad Type: 1 - Single, 2 - Dual, 4 - Quad, 8 - Octal
+    uint8_t serialClkFreq; //!< [0x046-0x046] Serial Flash Frequencey, device specific definitions, See System Boot
+    //! Chapter for more details
+    uint8_t lutCustomSeqEnable; //!< [0x047-0x047] LUT customization Enable, it is required if the program/erase cannot
+    //! be done using 1 LUT sequence, currently, only applicable to HyperFLASH
+    uint32_t reserved3[2];           //!< [0x048-0x04f] Reserved for future use
+    uint32_t sflashA1Size;           //!< [0x050-0x053] Size of Flash connected to A1
+    uint32_t sflashA2Size;           //!< [0x054-0x057] Size of Flash connected to A2
+    uint32_t sflashB1Size;           //!< [0x058-0x05b] Size of Flash connected to B1
+    uint32_t sflashB2Size;           //!< [0x05c-0x05f] Size of Flash connected to B2
+    uint32_t csPadSettingOverride;   //!< [0x060-0x063] CS pad setting override value
+    uint32_t sclkPadSettingOverride; //!< [0x064-0x067] SCK pad setting override value
+    uint32_t dataPadSettingOverride; //!< [0x068-0x06b] data pad setting override value
+    uint32_t dqsPadSettingOverride;  //!< [0x06c-0x06f] DQS pad setting override value
+    uint32_t timeoutInMs;            //!< [0x070-0x073] Timeout threshold for read status command
+    uint32_t commandInterval;        //!< [0x074-0x077] CS deselect interval between two commands
+    uint16_t dataValidTime[2]; //!< [0x078-0x07b] CLK edge to data valid time for PORT A and PORT B, in terms of 0.1ns
+    uint16_t busyOffset;       //!< [0x07c-0x07d] Busy offset, valid value: 0-31
+    uint16_t busyBitPolarity;  //!< [0x07e-0x07f] Busy flag polarity, 0 - busy flag is 1 when flash device is busy, 1 -
+    //! busy flag is 0 when flash device is busy
+    uint32_t lookupTable[64];           //!< [0x080-0x17f] Lookup table holds Flash command sequences
+    flexspi_lut_seq_t lutCustomSeq[12]; //!< [0x180-0x1af] Customizable LUT Sequences
+    uint32_t reserved4[4];              //!< [0x1b0-0x1bf] Reserved for future use
+} flexspi_mem_config_t;
+
+/*  */
+#define NOR_CMD_INDEX_READ        CMD_INDEX_READ        //!< 0
+#define NOR_CMD_INDEX_READSTATUS  CMD_INDEX_READSTATUS  //!< 1
+#define NOR_CMD_INDEX_WRITEENABLE CMD_INDEX_WRITEENABLE //!< 2
+#define NOR_CMD_INDEX_ERASESECTOR 3                     //!< 3
+#define NOR_CMD_INDEX_PAGEPROGRAM CMD_INDEX_WRITE       //!< 4
+#define NOR_CMD_INDEX_CHIPERASE   5                     //!< 5
+#define NOR_CMD_INDEX_DUMMY       6                     //!< 6
+#define NOR_CMD_INDEX_ERASEBLOCK  7                     //!< 7
+
+#define NOR_CMD_LUT_SEQ_IDX_READ CMD_LUT_SEQ_IDX_READ //!< 0  READ LUT sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_READSTATUS \
+    CMD_LUT_SEQ_IDX_READSTATUS //!< 1  Read Status LUT sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_READSTATUS_XPI \
+    2 //!< 2  Read status DPI/QPI/OPI sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_WRITEENABLE \
+    CMD_LUT_SEQ_IDX_WRITEENABLE //!< 3  Write Enable sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_WRITEENABLE_XPI \
+    4 //!< 4  Write Enable DPI/QPI/OPI sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_ERASESECTOR 5 //!< 5  Erase Sector sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_ERASEBLOCK  8 //!< 8 Erase Block sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_PAGEPROGRAM \
+    CMD_LUT_SEQ_IDX_WRITE                //!< 9  Program sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_CHIPERASE 11 //!< 11 Chip Erase sequence in lookupTable id stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_READ_SFDP 13 //!< 13 Read SFDP sequence in lookupTable id stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_RESTORE_NOCMD \
+    14 //!< 14 Restore 0-4-4/0-8-8 mode sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_EXIT_NOCMD \
+    15 //!< 15 Exit 0-4-4/0-8-8 mode sequence id in lookupTable stored in config blobk
+
+/*
+ *  Serial NOR configuration block
+ */
+typedef struct _flexspi_nor_config
+{
+    flexspi_mem_config_t memConfig; //!< Common memory configuration info via FlexSPI
+    uint32_t pageSize;              //!< Page size of Serial NOR
+    uint32_t sectorSize;            //!< Sector size of Serial NOR
+    uint8_t ipcmdSerialClkFreq;     //!< Clock frequency for IP command
+    uint8_t isUniformBlockSize;     //!< Sector/Block size is the same
+    uint8_t reserved0[2];           //!< Reserved for future use
+    uint8_t serialNorType;          //!< Serial NOR Flash type: 0/1/2/3
+    uint8_t needExitNoCmdMode;      //!< Need to exit NoCmd mode before other IP command
+    uint8_t halfClkForNonReadCmd;   //!< Half the Serial Clock for non-read command: true/false
+    uint8_t needRestoreNoCmdMode;   //!< Need to Restore NoCmd mode after IP commmand execution
+    uint32_t blockSize;             //!< Block size
+    uint32_t reserve2[11];          //!< Reserved for future use
+} flexspi_nor_config_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __EVKMIMXRT1060_FLEXSPI_NOR_CONFIG__ */
diff --git a/ports/mimxrt/boards/MIMXRT1060_EVK/flash_config.c b/ports/mimxrt/boards/MIMXRT1060_EVK/flash_config.c
new file mode 100644
index 0000000000000..095a922e9efe1
--- /dev/null
+++ b/ports/mimxrt/boards/MIMXRT1060_EVK/flash_config.c
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2018 NXP
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "evkmimxrt1060_flexspi_nor_config.h"
+
+/* Component ID definition, used by tools. */
+#ifndef FSL_COMPONENT_ID
+#define FSL_COMPONENT_ID "platform.drivers.xip_board"
+#endif
+
+/*******************************************************************************
+ * Code
+ ******************************************************************************/
+#if defined(XIP_BOOT_HEADER_ENABLE) && (XIP_BOOT_HEADER_ENABLE == 1)
+#if defined(__CC_ARM) || defined(__ARMCC_VERSION) || defined(__GNUC__)
+__attribute__((section(".boot_hdr.conf")))
+#elif defined(__ICCARM__)
+#pragma location = ".boot_hdr.conf"
+#endif
+
+const flexspi_nor_config_t qspiflash_config = {
+    .memConfig =
+        {
+            .tag              = FLEXSPI_CFG_BLK_TAG,
+            .version          = FLEXSPI_CFG_BLK_VERSION,
+            .readSampleClkSrc = kFlexSPIReadSampleClk_LoopbackFromDqsPad,
+            .csHoldTime       = 3u,
+            .csSetupTime      = 3u,
+            .sflashPadType    = kSerialFlash_4Pads,
+            .serialClkFreq    = kFlexSpiSerialClk_100MHz,
+            .sflashA1Size     = 8u * 1024u * 1024u,
+            .lookupTable =
+                {
+                    // Read LUTs
+                    FLEXSPI_LUT_SEQ(CMD_SDR, FLEXSPI_1PAD, 0xEB, RADDR_SDR, FLEXSPI_4PAD, 0x18),
+                    FLEXSPI_LUT_SEQ(DUMMY_SDR, FLEXSPI_4PAD, 0x06, READ_SDR, FLEXSPI_4PAD, 0x04),
+                },
+        },
+    .pageSize           = 256u,
+    .sectorSize         = 4u * 1024u,
+    .blockSize          = 64u * 1024u,
+    .isUniformBlockSize = false,
+};
+#endif /* XIP_BOOT_HEADER_ENABLE */
diff --git a/ports/mimxrt/boards/MIMXRT1060_EVK/mpconfigboard.h b/ports/mimxrt/boards/MIMXRT1060_EVK/mpconfigboard.h
new file mode 100644
index 0000000000000..714f987a54c9d
--- /dev/null
+++ b/ports/mimxrt/boards/MIMXRT1060_EVK/mpconfigboard.h
@@ -0,0 +1,8 @@
+#define MICROPY_HW_BOARD_NAME "i.MX RT1060 EVK"
+#define MICROPY_HW_MCU_NAME   "MIMXRT1062DVJ6A"
+
+#define BOARD_FLASH_SIZE (8 * 1024 * 1024)
+
+#define MICROPY_HW_LED_PINMUX  IOMUXC_GPIO_AD_B0_09_GPIO1_IO09
+#define MICROPY_HW_LED_PORT    GPIO1
+#define MICROPY_HW_LED_PIN     9
diff --git a/ports/mimxrt/boards/MIMXRT1060_EVK/mpconfigboard.mk b/ports/mimxrt/boards/MIMXRT1060_EVK/mpconfigboard.mk
new file mode 100644
index 0000000000000..b34169801b900
--- /dev/null
+++ b/ports/mimxrt/boards/MIMXRT1060_EVK/mpconfigboard.mk
@@ -0,0 +1,7 @@
+MCU_SERIES = MIMXRT1062
+MCU_VARIANT = MIMXRT1062DVJ6A
+
+JLINK_PATH ?= /media/RT1060-EVK/
+
+deploy: $(BUILD)/firmware.bin
+	cp $< $(JLINK_PATH)
diff --git a/ports/mimxrt/boards/MIMXRT1062.ld b/ports/mimxrt/boards/MIMXRT1062.ld
new file mode 100644
index 0000000000000..23520b5624733
--- /dev/null
+++ b/ports/mimxrt/boards/MIMXRT1062.ld
@@ -0,0 +1,8 @@
+/* 32kiB stack. */
+__stack_size__ = 0x8000;
+_estack = __StackTop;
+_sstack = __StackLimit;
+
+/* Use second OCRAM bank for GC heap. */
+_gc_heap_start = ORIGIN(m_data2);
+_gc_heap_end = ORIGIN(m_data2) + LENGTH(m_data2);
diff --git a/ports/mimxrt/boards/TEENSY40/flash_config.c b/ports/mimxrt/boards/TEENSY40/flash_config.c
new file mode 100644
index 0000000000000..39a6b910886c9
--- /dev/null
+++ b/ports/mimxrt/boards/TEENSY40/flash_config.c
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2018 NXP
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+// Based on tinyusb/hw/bsp/teensy_40/teensy40_flexspi_nor_config.c
+
+#include "teensy40_flexspi_nor_config.h"
+
+/* Component ID definition, used by tools. */
+#ifndef FSL_COMPONENT_ID
+#define FSL_COMPONENT_ID "platform.drivers.xip_board"
+#endif
+
+/*******************************************************************************
+ * Code
+ ******************************************************************************/
+#if defined(XIP_BOOT_HEADER_ENABLE) && (XIP_BOOT_HEADER_ENABLE == 1)
+#if defined(__CC_ARM) || defined(__ARMCC_VERSION) || defined(__GNUC__)
+__attribute__((section(".boot_hdr.conf")))
+#elif defined(__ICCARM__)
+#pragma location = ".boot_hdr.conf"
+#endif
+
+const flexspi_nor_config_t qspiflash_config = {
+    .memConfig =
+        {
+            .tag              = FLEXSPI_CFG_BLK_TAG,
+            .version          = FLEXSPI_CFG_BLK_VERSION,
+            .readSampleClkSrc = kFlexSPIReadSampleClk_LoopbackFromDqsPad,
+            .csHoldTime       = 3u,
+            .csSetupTime      = 3u,
+            // Enable DDR mode, Wordaddassable, Safe configuration, Differential clock
+            .sflashPadType = kSerialFlash_4Pads,
+            .serialClkFreq = kFlexSpiSerialClk_100MHz,
+            .sflashA1Size  = 2u * 1024u * 1024u,
+            .lookupTable =
+                {
+                    // Read LUTs
+                    FLEXSPI_LUT_SEQ(CMD_SDR, FLEXSPI_1PAD, 0xEB, RADDR_SDR, FLEXSPI_4PAD, 0x18),
+                    FLEXSPI_LUT_SEQ(DUMMY_SDR, FLEXSPI_4PAD, 0x06, READ_SDR, FLEXSPI_4PAD, 0x04),
+                },
+        },
+    .pageSize           = 256u,
+    .sectorSize         = 4u * 1024u,
+    .blockSize          = 256u * 1024u,
+    .isUniformBlockSize = false,
+};
+#endif /* XIP_BOOT_HEADER_ENABLE */
diff --git a/ports/mimxrt/boards/TEENSY40/mpconfigboard.h b/ports/mimxrt/boards/TEENSY40/mpconfigboard.h
new file mode 100644
index 0000000000000..10c8b7a6d1ffa
--- /dev/null
+++ b/ports/mimxrt/boards/TEENSY40/mpconfigboard.h
@@ -0,0 +1,8 @@
+#define MICROPY_HW_BOARD_NAME "Teensy 4.0"
+#define MICROPY_HW_MCU_NAME   "MIMXRT1062DVJ6A"
+
+#define BOARD_FLASH_SIZE (2 * 1024 * 1024)
+
+#define MICROPY_HW_LED_PINMUX   IOMUXC_GPIO_B0_03_GPIO2_IO03 // D13
+#define MICROPY_HW_LED_PORT     GPIO2
+#define MICROPY_HW_LED_PIN      3
diff --git a/ports/mimxrt/boards/TEENSY40/mpconfigboard.mk b/ports/mimxrt/boards/TEENSY40/mpconfigboard.mk
new file mode 100644
index 0000000000000..6b939a3afde9d
--- /dev/null
+++ b/ports/mimxrt/boards/TEENSY40/mpconfigboard.mk
@@ -0,0 +1,5 @@
+MCU_SERIES = MIMXRT1062
+MCU_VARIANT = MIMXRT1062DVJ6A
+
+deploy: $(BUILD)/firmware.hex
+	teensy_loader_cli --mcu=imxrt1062 -v -w $<
diff --git a/ports/mimxrt/boards/TEENSY40/teensy40_flexspi_nor_config.h b/ports/mimxrt/boards/TEENSY40/teensy40_flexspi_nor_config.h
new file mode 100644
index 0000000000000..2c7bf48b62d81
--- /dev/null
+++ b/ports/mimxrt/boards/TEENSY40/teensy40_flexspi_nor_config.h
@@ -0,0 +1,270 @@
+/*
+ * Copyright 2018 NXP
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+// Based on tinyusb/hw/bsp/teensy_40/teensy40_flexspi_nor_config.h
+
+#ifndef __TEENSY40_FLEXSPI_NOR_CONFIG__
+#define __TEENSY40_FLEXSPI_NOR_CONFIG__
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "fsl_common.h"
+
+/*! @name Driver version */
+/*@{*/
+/*! @brief XIP_BOARD driver version 2.0.0. */
+#define FSL_XIP_BOARD_DRIVER_VERSION (MAKE_VERSION(2, 0, 0))
+/*@}*/
+
+/* FLEXSPI memory config block related defintions */
+#define FLEXSPI_CFG_BLK_TAG (0x42464346UL)     // ascii "FCFB" Big Endian
+#define FLEXSPI_CFG_BLK_VERSION (0x56010400UL) // V1.4.0
+#define FLEXSPI_CFG_BLK_SIZE (512)
+
+/* FLEXSPI Feature related definitions */
+#define FLEXSPI_FEATURE_HAS_PARALLEL_MODE 1
+
+/* Lookup table related defintions */
+#define CMD_INDEX_READ 0
+#define CMD_INDEX_READSTATUS 1
+#define CMD_INDEX_WRITEENABLE 2
+#define CMD_INDEX_WRITE 4
+
+#define CMD_LUT_SEQ_IDX_READ 0
+#define CMD_LUT_SEQ_IDX_READSTATUS 1
+#define CMD_LUT_SEQ_IDX_WRITEENABLE 3
+#define CMD_LUT_SEQ_IDX_WRITE 9
+
+#define CMD_SDR 0x01
+#define CMD_DDR 0x21
+#define RADDR_SDR 0x02
+#define RADDR_DDR 0x22
+#define CADDR_SDR 0x03
+#define CADDR_DDR 0x23
+#define MODE1_SDR 0x04
+#define MODE1_DDR 0x24
+#define MODE2_SDR 0x05
+#define MODE2_DDR 0x25
+#define MODE4_SDR 0x06
+#define MODE4_DDR 0x26
+#define MODE8_SDR 0x07
+#define MODE8_DDR 0x27
+#define WRITE_SDR 0x08
+#define WRITE_DDR 0x28
+#define READ_SDR 0x09
+#define READ_DDR 0x29
+#define LEARN_SDR 0x0A
+#define LEARN_DDR 0x2A
+#define DATSZ_SDR 0x0B
+#define DATSZ_DDR 0x2B
+#define DUMMY_SDR 0x0C
+#define DUMMY_DDR 0x2C
+#define DUMMY_RWDS_SDR 0x0D
+#define DUMMY_RWDS_DDR 0x2D
+#define JMP_ON_CS 0x1F
+#define STOP 0
+
+#define FLEXSPI_1PAD 0
+#define FLEXSPI_2PAD 1
+#define FLEXSPI_4PAD 2
+#define FLEXSPI_8PAD 3
+
+#define FLEXSPI_LUT_SEQ(cmd0, pad0, op0, cmd1, pad1, op1)                                                              \
+    (FLEXSPI_LUT_OPERAND0(op0) | FLEXSPI_LUT_NUM_PADS0(pad0) | FLEXSPI_LUT_OPCODE0(cmd0) | FLEXSPI_LUT_OPERAND1(op1) | \
+     FLEXSPI_LUT_NUM_PADS1(pad1) | FLEXSPI_LUT_OPCODE1(cmd1))
+
+//!@brief Definitions for FlexSPI Serial Clock Frequency
+typedef enum _FlexSpiSerialClockFreq
+{
+    kFlexSpiSerialClk_30MHz  = 1,
+    kFlexSpiSerialClk_50MHz  = 2,
+    kFlexSpiSerialClk_60MHz  = 3,
+    kFlexSpiSerialClk_75MHz  = 4,
+    kFlexSpiSerialClk_80MHz  = 5,
+    kFlexSpiSerialClk_100MHz = 6,
+    kFlexSpiSerialClk_120MHz = 7,
+    kFlexSpiSerialClk_133MHz = 8,
+    kFlexSpiSerialClk_166MHz = 9,
+} flexspi_serial_clk_freq_t;
+
+//!@brief FlexSPI clock configuration type
+enum
+{
+    kFlexSpiClk_SDR, //!< Clock configure for SDR mode
+    kFlexSpiClk_DDR, //!< Clock configurat for DDR mode
+};
+
+//!@brief FlexSPI Read Sample Clock Source definition
+typedef enum _FlashReadSampleClkSource
+{
+    kFlexSPIReadSampleClk_LoopbackInternally      = 0,
+    kFlexSPIReadSampleClk_LoopbackFromDqsPad      = 1,
+    kFlexSPIReadSampleClk_LoopbackFromSckPad      = 2,
+    kFlexSPIReadSampleClk_ExternalInputFromDqsPad = 3,
+} flexspi_read_sample_clk_t;
+
+//!@brief Misc feature bit definitions
+enum
+{
+    kFlexSpiMiscOffset_DiffClkEnable            = 0, //!< Bit for Differential clock enable
+    kFlexSpiMiscOffset_Ck2Enable                = 1, //!< Bit for CK2 enable
+    kFlexSpiMiscOffset_ParallelEnable           = 2, //!< Bit for Parallel mode enable
+    kFlexSpiMiscOffset_WordAddressableEnable    = 3, //!< Bit for Word Addressable enable
+    kFlexSpiMiscOffset_SafeConfigFreqEnable     = 4, //!< Bit for Safe Configuration Frequency enable
+    kFlexSpiMiscOffset_PadSettingOverrideEnable = 5, //!< Bit for Pad setting override enable
+    kFlexSpiMiscOffset_DdrModeEnable            = 6, //!< Bit for DDR clock confiuration indication.
+};
+
+//!@brief Flash Type Definition
+enum
+{
+    kFlexSpiDeviceType_SerialNOR    = 1,    //!< Flash devices are Serial NOR
+    kFlexSpiDeviceType_SerialNAND   = 2,    //!< Flash devices are Serial NAND
+    kFlexSpiDeviceType_SerialRAM    = 3,    //!< Flash devices are Serial RAM/HyperFLASH
+    kFlexSpiDeviceType_MCP_NOR_NAND = 0x12, //!< Flash device is MCP device, A1 is Serial NOR, A2 is Serial NAND
+    kFlexSpiDeviceType_MCP_NOR_RAM  = 0x13, //!< Flash deivce is MCP device, A1 is Serial NOR, A2 is Serial RAMs
+};
+
+//!@brief Flash Pad Definitions
+enum
+{
+    kSerialFlash_1Pad  = 1,
+    kSerialFlash_2Pads = 2,
+    kSerialFlash_4Pads = 4,
+    kSerialFlash_8Pads = 8,
+};
+
+//!@brief FlexSPI LUT Sequence structure
+typedef struct _lut_sequence
+{
+    uint8_t seqNum; //!< Sequence Number, valid number: 1-16
+    uint8_t seqId;  //!< Sequence Index, valid number: 0-15
+    uint16_t reserved;
+} flexspi_lut_seq_t;
+
+//!@brief Flash Configuration Command Type
+enum
+{
+    kDeviceConfigCmdType_Generic,    //!< Generic command, for example: configure dummy cycles, drive strength, etc
+    kDeviceConfigCmdType_QuadEnable, //!< Quad Enable command
+    kDeviceConfigCmdType_Spi2Xpi,    //!< Switch from SPI to DPI/QPI/OPI mode
+    kDeviceConfigCmdType_Xpi2Spi,    //!< Switch from DPI/QPI/OPI to SPI mode
+    kDeviceConfigCmdType_Spi2NoCmd,  //!< Switch to 0-4-4/0-8-8 mode
+    kDeviceConfigCmdType_Reset,      //!< Reset device command
+};
+
+//!@brief FlexSPI Memory Configuration Block
+typedef struct _FlexSPIConfig
+{
+    uint32_t tag;               //!< [0x000-0x003] Tag, fixed value 0x42464346UL
+    uint32_t version;           //!< [0x004-0x007] Version,[31:24] -'V', [23:16] - Major, [15:8] - Minor, [7:0] - bugfix
+    uint32_t reserved0;         //!< [0x008-0x00b] Reserved for future use
+    uint8_t readSampleClkSrc;   //!< [0x00c-0x00c] Read Sample Clock Source, valid value: 0/1/3
+    uint8_t csHoldTime;         //!< [0x00d-0x00d] CS hold time, default value: 3
+    uint8_t csSetupTime;        //!< [0x00e-0x00e] CS setup time, default value: 3
+    uint8_t columnAddressWidth; //!< [0x00f-0x00f] Column Address with, for HyperBus protocol, it is fixed to 3, For
+    //! Serial NAND, need to refer to datasheet
+    uint8_t deviceModeCfgEnable; //!< [0x010-0x010] Device Mode Configure enable flag, 1 - Enable, 0 - Disable
+    uint8_t deviceModeType; //!< [0x011-0x011] Specify the configuration command type:Quad Enable, DPI/QPI/OPI switch,
+    //! Generic configuration, etc.
+    uint16_t waitTimeCfgCommands; //!< [0x012-0x013] Wait time for all configuration commands, unit: 100us, Used for
+    //! DPI/QPI/OPI switch or reset command
+    flexspi_lut_seq_t deviceModeSeq; //!< [0x014-0x017] Device mode sequence info, [7:0] - LUT sequence id, [15:8] - LUt
+    //! sequence number, [31:16] Reserved
+    uint32_t deviceModeArg;    //!< [0x018-0x01b] Argument/Parameter for device configuration
+    uint8_t configCmdEnable;   //!< [0x01c-0x01c] Configure command Enable Flag, 1 - Enable, 0 - Disable
+    uint8_t configModeType[3]; //!< [0x01d-0x01f] Configure Mode Type, similar as deviceModeTpe
+    flexspi_lut_seq_t
+        configCmdSeqs[3]; //!< [0x020-0x02b] Sequence info for Device Configuration command, similar as deviceModeSeq
+    uint32_t reserved1;   //!< [0x02c-0x02f] Reserved for future use
+    uint32_t configCmdArgs[3];     //!< [0x030-0x03b] Arguments/Parameters for device Configuration commands
+    uint32_t reserved2;            //!< [0x03c-0x03f] Reserved for future use
+    uint32_t controllerMiscOption; //!< [0x040-0x043] Controller Misc Options, see Misc feature bit definitions for more
+    //! details
+    uint8_t deviceType;    //!< [0x044-0x044] Device Type:  See Flash Type Definition for more details
+    uint8_t sflashPadType; //!< [0x045-0x045] Serial Flash Pad Type: 1 - Single, 2 - Dual, 4 - Quad, 8 - Octal
+    uint8_t serialClkFreq; //!< [0x046-0x046] Serial Flash Frequencey, device specific definitions, See System Boot
+    //! Chapter for more details
+    uint8_t lutCustomSeqEnable; //!< [0x047-0x047] LUT customization Enable, it is required if the program/erase cannot
+    //! be done using 1 LUT sequence, currently, only applicable to HyperFLASH
+    uint32_t reserved3[2];           //!< [0x048-0x04f] Reserved for future use
+    uint32_t sflashA1Size;           //!< [0x050-0x053] Size of Flash connected to A1
+    uint32_t sflashA2Size;           //!< [0x054-0x057] Size of Flash connected to A2
+    uint32_t sflashB1Size;           //!< [0x058-0x05b] Size of Flash connected to B1
+    uint32_t sflashB2Size;           //!< [0x05c-0x05f] Size of Flash connected to B2
+    uint32_t csPadSettingOverride;   //!< [0x060-0x063] CS pad setting override value
+    uint32_t sclkPadSettingOverride; //!< [0x064-0x067] SCK pad setting override value
+    uint32_t dataPadSettingOverride; //!< [0x068-0x06b] data pad setting override value
+    uint32_t dqsPadSettingOverride;  //!< [0x06c-0x06f] DQS pad setting override value
+    uint32_t timeoutInMs;            //!< [0x070-0x073] Timeout threshold for read status command
+    uint32_t commandInterval;        //!< [0x074-0x077] CS deselect interval between two commands
+    uint16_t dataValidTime[2]; //!< [0x078-0x07b] CLK edge to data valid time for PORT A and PORT B, in terms of 0.1ns
+    uint16_t busyOffset;       //!< [0x07c-0x07d] Busy offset, valid value: 0-31
+    uint16_t busyBitPolarity;  //!< [0x07e-0x07f] Busy flag polarity, 0 - busy flag is 1 when flash device is busy, 1 -
+    //! busy flag is 0 when flash device is busy
+    uint32_t lookupTable[64];           //!< [0x080-0x17f] Lookup table holds Flash command sequences
+    flexspi_lut_seq_t lutCustomSeq[12]; //!< [0x180-0x1af] Customizable LUT Sequences
+    uint32_t reserved4[4];              //!< [0x1b0-0x1bf] Reserved for future use
+} flexspi_mem_config_t;
+
+/*  */
+#define NOR_CMD_INDEX_READ CMD_INDEX_READ               //!< 0
+#define NOR_CMD_INDEX_READSTATUS CMD_INDEX_READSTATUS   //!< 1
+#define NOR_CMD_INDEX_WRITEENABLE CMD_INDEX_WRITEENABLE //!< 2
+#define NOR_CMD_INDEX_ERASESECTOR 3                     //!< 3
+#define NOR_CMD_INDEX_PAGEPROGRAM CMD_INDEX_WRITE       //!< 4
+#define NOR_CMD_INDEX_CHIPERASE 5                       //!< 5
+#define NOR_CMD_INDEX_DUMMY 6                           //!< 6
+#define NOR_CMD_INDEX_ERASEBLOCK 7                      //!< 7
+
+#define NOR_CMD_LUT_SEQ_IDX_READ CMD_LUT_SEQ_IDX_READ //!< 0  READ LUT sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_READSTATUS \
+    CMD_LUT_SEQ_IDX_READSTATUS //!< 1  Read Status LUT sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_READSTATUS_XPI \
+    2 //!< 2  Read status DPI/QPI/OPI sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_WRITEENABLE \
+    CMD_LUT_SEQ_IDX_WRITEENABLE //!< 3  Write Enable sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_WRITEENABLE_XPI \
+    4 //!< 4  Write Enable DPI/QPI/OPI sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_ERASESECTOR 5 //!< 5  Erase Sector sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_ERASEBLOCK 8  //!< 8 Erase Block sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_PAGEPROGRAM \
+    CMD_LUT_SEQ_IDX_WRITE                //!< 9  Program sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_CHIPERASE 11 //!< 11 Chip Erase sequence in lookupTable id stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_READ_SFDP 13 //!< 13 Read SFDP sequence in lookupTable id stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_RESTORE_NOCMD \
+    14 //!< 14 Restore 0-4-4/0-8-8 mode sequence id in lookupTable stored in config block
+#define NOR_CMD_LUT_SEQ_IDX_EXIT_NOCMD \
+    15 //!< 15 Exit 0-4-4/0-8-8 mode sequence id in lookupTable stored in config blobk
+
+/*
+ *  Serial NOR configuration block
+ */
+typedef struct _flexspi_nor_config
+{
+    flexspi_mem_config_t memConfig; //!< Common memory configuration info via FlexSPI
+    uint32_t pageSize;              //!< Page size of Serial NOR
+    uint32_t sectorSize;            //!< Sector size of Serial NOR
+    uint8_t ipcmdSerialClkFreq;     //!< Clock frequency for IP command
+    uint8_t isUniformBlockSize;     //!< Sector/Block size is the same
+    uint8_t reserved0[2];           //!< Reserved for future use
+    uint8_t serialNorType;          //!< Serial NOR Flash type: 0/1/2/3
+    uint8_t needExitNoCmdMode;      //!< Need to exit NoCmd mode before other IP command
+    uint8_t halfClkForNonReadCmd;   //!< Half the Serial Clock for non-read command: true/false
+    uint8_t needRestoreNoCmdMode;   //!< Need to Restore NoCmd mode after IP commmand execution
+    uint32_t blockSize;             //!< Block size
+    uint32_t reserve2[11];          //!< Reserved for future use
+} flexspi_nor_config_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __EVKMIMXRT1060_FLEXSPI_NOR_CONFIG__ */
diff --git a/ports/mimxrt/main.c b/ports/mimxrt/main.c
new file mode 100644
index 0000000000000..d94bf24412452
--- /dev/null
+++ b/ports/mimxrt/main.c
@@ -0,0 +1,106 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ * Copyright (c) 2020 Jim Mussared
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/compile.h"
+#include "py/runtime.h"
+#include "py/gc.h"
+#include "py/mperrno.h"
+#include "py/stackctrl.h"
+#include "lib/utils/gchelper.h"
+#include "lib/utils/pyexec.h"
+#include "tusb.h"
+
+extern uint8_t _sstack, _estack, _gc_heap_start, _gc_heap_end;
+
+void board_init(void);
+
+int main(void) {
+    board_init();
+    tusb_init();
+
+    mp_stack_set_top(&_estack);
+    mp_stack_set_limit(&_estack - &_sstack - 1024);
+
+    for (;;) {
+        gc_init(&_gc_heap_start, &_gc_heap_end);
+        mp_init();
+
+        mp_obj_list_init(MP_OBJ_TO_PTR(mp_sys_path), 0);
+        mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR_));
+        mp_obj_list_init(MP_OBJ_TO_PTR(mp_sys_argv), 0);
+
+        for (;;) {
+            if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
+                if (pyexec_raw_repl() != 0) {
+                    break;
+                }
+            } else {
+                if (pyexec_friendly_repl() != 0) {
+                    break;
+                }
+            }
+        }
+
+        mp_printf(MP_PYTHON_PRINTER, "MPY: soft reboot\n");
+        gc_sweep_all();
+        mp_deinit();
+    }
+
+    return 0;
+}
+
+void gc_collect(void) {
+    gc_collect_start();
+    gc_helper_collect_regs_and_stack();
+    gc_collect_end();
+}
+
+mp_lexer_t *mp_lexer_new_from_file(const char *filename) {
+    mp_raise_OSError(MP_ENOENT);
+}
+
+mp_import_stat_t mp_import_stat(const char *path) {
+    return MP_IMPORT_STAT_NO_EXIST;
+}
+
+mp_obj_t mp_builtin_open(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
+
+void nlr_jump_fail(void *val) {
+    for (;;) {
+    }
+}
+
+#ifndef NDEBUG
+void MP_WEAK __assert_func(const char *file, int line, const char *func, const char *expr) {
+    mp_printf(MP_PYTHON_PRINTER, "Assertion '%s' failed, at file %s:%d\n", expr, file, line);
+    for (;;) {
+    }
+}
+#endif
diff --git a/ports/cc3200/mods/modubinascii.c b/ports/mimxrt/modmachine.c
similarity index 51%
rename from ports/cc3200/mods/modubinascii.c
rename to ports/mimxrt/modmachine.c
index 6b020ab393b80..747b7bc27f56d 100644
--- a/ports/cc3200/mods/modubinascii.c
+++ b/ports/mimxrt/modmachine.c
@@ -3,8 +3,8 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2014 Paul Sokolovsky
- * Copyright (c) 2015 Daniel Campora
+ * Copyright (c) 2019 Damien P. George
+ * Copyright (c) 2020 Jim Mussared
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -26,35 +26,32 @@
  */
 
 #include "py/runtime.h"
-#include "py/binary.h"
-#include "extmod/modubinascii.h"
-#include "modubinascii.h"
-#include "inc/hw_types.h"
-#include "inc/hw_ints.h"
-#include "inc/hw_nvic.h"
-#include "inc/hw_dthe.h"
-#include "hw_memmap.h"
-#include "rom_map.h"
-#include "prcm.h"
-#include "crc.h"
-#include "cryptohash.h"
-#include "mpexception.h"
+#include "extmod/machine_mem.h"
 
+#include CPU_HEADER_H
 
-/******************************************************************************/
-// MicroPython bindings
+STATIC mp_obj_t machine_reset(void) {
+    NVIC_SystemReset();
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_0(machine_reset_obj, machine_reset);
 
-STATIC const mp_rom_map_elem_t mp_module_binascii_globals_table[] = {
-    { MP_ROM_QSTR(MP_QSTR___name__),        MP_ROM_QSTR(MP_QSTR_ubinascii) },
-    { MP_ROM_QSTR(MP_QSTR_hexlify),         MP_ROM_PTR(&mod_binascii_hexlify_obj) },
-    { MP_ROM_QSTR(MP_QSTR_unhexlify),       MP_ROM_PTR(&mod_binascii_unhexlify_obj) },
-    { MP_ROM_QSTR(MP_QSTR_a2b_base64),      MP_ROM_PTR(&mod_binascii_a2b_base64_obj) },
-    { MP_ROM_QSTR(MP_QSTR_b2a_base64),      MP_ROM_PTR(&mod_binascii_b2a_base64_obj) },
-};
+STATIC mp_obj_t machine_freq(void) {
+    return MP_OBJ_NEW_SMALL_INT(0);
+}
+MP_DEFINE_CONST_FUN_OBJ_0(machine_freq_obj, machine_freq);
 
-STATIC MP_DEFINE_CONST_DICT(mp_module_binascii_globals, mp_module_binascii_globals_table);
+STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__),            MP_ROM_QSTR(MP_QSTR_umachine) },
+    { MP_ROM_QSTR(MP_QSTR_reset),               MP_ROM_PTR(&machine_reset_obj) },
+    { MP_ROM_QSTR(MP_QSTR_freq),                MP_ROM_PTR(&machine_freq_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mem8),                MP_ROM_PTR(&machine_mem8_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mem16),               MP_ROM_PTR(&machine_mem16_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mem32),               MP_ROM_PTR(&machine_mem32_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(machine_module_globals, machine_module_globals_table);
 
-const mp_obj_module_t mp_module_ubinascii = {
+const mp_obj_module_t mp_module_machine = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_binascii_globals,
+    .globals = (mp_obj_dict_t *)&machine_module_globals,
 };
diff --git a/ports/mimxrt/modutime.c b/ports/mimxrt/modutime.c
new file mode 100644
index 0000000000000..bbdbda44e288f
--- /dev/null
+++ b/ports/mimxrt/modutime.c
@@ -0,0 +1,48 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ * Copyright (c) 2020 Jim Mussared
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "extmod/utime_mphal.h"
+
+STATIC const mp_rom_map_elem_t time_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_utime) },
+
+    { MP_ROM_QSTR(MP_QSTR_sleep), MP_ROM_PTR(&mp_utime_sleep_obj) },
+    { MP_ROM_QSTR(MP_QSTR_sleep_ms), MP_ROM_PTR(&mp_utime_sleep_ms_obj) },
+    { MP_ROM_QSTR(MP_QSTR_sleep_us), MP_ROM_PTR(&mp_utime_sleep_us_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ticks_ms), MP_ROM_PTR(&mp_utime_ticks_ms_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ticks_us), MP_ROM_PTR(&mp_utime_ticks_us_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ticks_cpu), MP_ROM_PTR(&mp_utime_ticks_cpu_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ticks_add), MP_ROM_PTR(&mp_utime_ticks_add_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ticks_diff), MP_ROM_PTR(&mp_utime_ticks_diff_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(time_module_globals, time_module_globals_table);
+
+const mp_obj_module_t mp_module_utime = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&time_module_globals,
+};
diff --git a/ports/mimxrt/mpconfigport.h b/ports/mimxrt/mpconfigport.h
new file mode 100644
index 0000000000000..344867fb819dd
--- /dev/null
+++ b/ports/mimxrt/mpconfigport.h
@@ -0,0 +1,109 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// Options controlling how MicroPython is built, overriding defaults in py/mpconfig.h
+
+// Board specific definitions
+#include "mpconfigboard.h"
+
+// Memory allocation policies
+#define MICROPY_GC_STACK_ENTRY_TYPE         uint16_t
+#define MICROPY_GC_ALLOC_THRESHOLD          (0)
+#define MICROPY_ALLOC_PARSE_CHUNK_INIT      (32)
+#define MICROPY_ALLOC_PATH_MAX              (256)
+#define MICROPY_QSTR_BYTES_IN_HASH          (1)
+
+// Compiler configuration
+#define MICROPY_COMP_CONST                  (0)
+
+// Python internal features
+#define MICROPY_ENABLE_GC                   (1)
+#define MICROPY_KBD_EXCEPTION               (1)
+#define MICROPY_HELPER_REPL                 (1)
+#define MICROPY_LONGINT_IMPL                (MICROPY_LONGINT_IMPL_MPZ)
+#define MICROPY_ENABLE_SOURCE_LINE          (1)
+#define MICROPY_ERROR_REPORTING             (MICROPY_ERROR_REPORTING_TERSE)
+#define MICROPY_CPYTHON_COMPAT              (0)
+#define MICROPY_CAN_OVERRIDE_BUILTINS       (1)
+
+// Control over Python builtins
+#define MICROPY_PY_ASYNC_AWAIT              (0)
+#define MICROPY_PY_BUILTINS_STR_COUNT       (0)
+#define MICROPY_PY_BUILTINS_MEMORYVIEW      (1)
+#define MICROPY_PY_BUILTINS_SET             (1)
+#define MICROPY_PY_BUILTINS_FROZENSET       (0)
+#define MICROPY_PY_BUILTINS_PROPERTY        (0)
+#define MICROPY_PY_BUILTINS_ENUMERATE       (0)
+#define MICROPY_PY_BUILTINS_FILTER          (0)
+#define MICROPY_PY_BUILTINS_REVERSED        (1)
+#define MICROPY_PY_BUILTINS_MIN_MAX         (0)
+#define MICROPY_PY___FILE__                 (0)
+#define MICROPY_PY_MICROPYTHON_MEM_INFO     (1)
+#define MICROPY_PY_ARRAY_SLICE_ASSIGN       (1)
+#define MICROPY_PY_ATTRTUPLE                (0)
+#define MICROPY_PY_COLLECTIONS              (0)
+#define MICROPY_PY_SYS_MAXSIZE              (1)
+
+// Extended modules
+#define MICROPY_PY_UTIME_MP_HAL             (1)
+#define MICROPY_PY_MACHINE                  (1)
+
+// Hooks to add builtins
+
+#define MICROPY_PORT_BUILTINS \
+    { MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&mp_builtin_open_obj) },
+
+extern const struct _mp_obj_module_t mp_module_machine;
+extern const struct _mp_obj_module_t mp_module_utime;
+
+#define MICROPY_PORT_BUILTIN_MODULES \
+    { MP_ROM_QSTR(MP_QSTR_machine), MP_ROM_PTR(&mp_module_machine) }, \
+    { MP_ROM_QSTR(MP_QSTR_utime), MP_ROM_PTR(&mp_module_utime) }, \
+
+#define MICROPY_PORT_ROOT_POINTERS \
+    const char *readline_hist[8];
+
+#define MP_STATE_PORT MP_STATE_VM
+
+// Miscellaneous settings
+
+#define MICROPY_EVENT_POLL_HOOK \
+    do { \
+        extern void mp_handle_pending(bool); \
+        mp_handle_pending(true); \
+        __WFI(); \
+    } while (0);
+
+#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)((mp_uint_t)(p) | 1))
+#define MP_PLAT_PRINT_STRN(str, len) mp_hal_stdout_tx_strn_cooked(str, len)
+
+#define MP_SSIZE_MAX (0x7fffffff)
+typedef int mp_int_t; // must be pointer size
+typedef unsigned mp_uint_t; // must be pointer size
+typedef long mp_off_t;
+
+// Need to provide a declaration/definition of alloca()
+#include <alloca.h>
diff --git a/ports/mimxrt/mphalport.c b/ports/mimxrt/mphalport.c
new file mode 100644
index 0000000000000..d7642d6b6d4a4
--- /dev/null
+++ b/ports/mimxrt/mphalport.c
@@ -0,0 +1,103 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ * Copyright (c) 2020 Jim Mussared
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "tusb.h"
+
+#include CPU_HEADER_H
+
+#if MICROPY_KBD_EXCEPTION
+
+void tud_cdc_rx_wanted_cb(uint8_t itf, char wanted_char) {
+    (void)itf;
+    (void)wanted_char;
+    tud_cdc_read_char(); // discard interrupt char
+    mp_keyboard_interrupt();
+}
+
+void mp_hal_set_interrupt_char(int c) {
+    tud_cdc_set_wanted_char(c);
+}
+
+#endif
+
+void mp_hal_delay_ms(mp_uint_t ms) {
+    ms += 1;
+    uint32_t t0 = systick_ms;
+    while (systick_ms - t0 < ms) {
+        MICROPY_EVENT_POLL_HOOK
+    }
+}
+
+void mp_hal_delay_us(mp_uint_t us) {
+    uint32_t ms = us / 1000 + 1;
+    uint32_t t0 = systick_ms;
+    while (systick_ms - t0 < ms) {
+        __WFI();
+    }
+}
+
+int mp_hal_stdin_rx_chr(void) {
+    for (;;) {
+        // TODO
+        // if (USARTx->USART.INTFLAG.bit.RXC) {
+        //     return USARTx->USART.DATA.bit.DATA;
+        // }
+        if (tud_cdc_connected() && tud_cdc_available()) {
+            uint8_t buf[1];
+            uint32_t count = tud_cdc_read(buf, sizeof(buf));
+            if (count) {
+                return buf[0];
+            }
+        }
+        __WFI();
+    }
+}
+
+void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) {
+    if (tud_cdc_connected()) {
+        for (size_t i = 0; i < len;) {
+            uint32_t n = len - i;
+            uint32_t n2 = tud_cdc_write(str + i, n);
+            if (n2 < n) {
+                while (!tud_cdc_write_flush()) {
+                    __WFI();
+                }
+            }
+            i += n2;
+        }
+        while (!tud_cdc_write_flush()) {
+            __WFI();
+        }
+    }
+    // TODO
+    // while (len--) {
+    //     while (!(USARTx->USART.INTFLAG.bit.DRE)) { }
+    //     USARTx->USART.DATA.bit.DATA = *str++;
+    // }
+}
diff --git a/ports/mimxrt/mphalport.h b/ports/mimxrt/mphalport.h
new file mode 100644
index 0000000000000..e1cf84f6c2cc7
--- /dev/null
+++ b/ports/mimxrt/mphalport.h
@@ -0,0 +1,48 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ * Copyright (c) 2020 Jim Mussared
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_MIMXRT_MPHALPORT_H
+#define MICROPY_INCLUDED_MIMXRT_MPHALPORT_H
+
+#include <stdint.h>
+
+extern volatile uint32_t systick_ms;
+
+void mp_hal_set_interrupt_char(int c);
+
+static inline mp_uint_t mp_hal_ticks_ms(void) {
+    return systick_ms;
+}
+
+static inline mp_uint_t mp_hal_ticks_us(void) {
+    return systick_ms * 1000;
+}
+
+static inline mp_uint_t mp_hal_ticks_cpu(void) {
+    return 0;
+}
+
+#endif // MICROPY_INCLUDED_MIMXRT_MPHALPORT_H
diff --git a/ports/mimxrt/qstrdefsport.h b/ports/mimxrt/qstrdefsport.h
new file mode 100644
index 0000000000000..00d3e2ae3c555
--- /dev/null
+++ b/ports/mimxrt/qstrdefsport.h
@@ -0,0 +1,2 @@
+// qstrs specific to this port
+// *FORMAT-OFF*
diff --git a/ports/mimxrt/tusb_config.h b/ports/mimxrt/tusb_config.h
new file mode 100644
index 0000000000000..f2367c2044384
--- /dev/null
+++ b/ports/mimxrt/tusb_config.h
@@ -0,0 +1,36 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Jim Mussared
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+#ifndef MICROPY_INCLUDED_MIMXRT_TUSB_CONFIG_H
+#define MICROPY_INCLUDED_MIMXRT_TUSB_CONFIG_H
+
+#define CFG_TUSB_RHPORT0_MODE   (OPT_MODE_DEVICE | OPT_MODE_HIGH_SPEED)
+
+#define CFG_TUSB_OS             (OPT_OS_NONE)
+
+#define CFG_TUD_CDC             (1)
+#define CFG_TUD_CDC_RX_BUFSIZE  (256)
+#define CFG_TUD_CDC_TX_BUFSIZE  (256)
+
+#endif // MICROPY_INCLUDED_MIMXRT_TUSB_CONFIG_H
diff --git a/ports/mimxrt/tusb_port.c b/ports/mimxrt/tusb_port.c
new file mode 100644
index 0000000000000..70f8ef527cd0d
--- /dev/null
+++ b/ports/mimxrt/tusb_port.c
@@ -0,0 +1,114 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "tusb.h"
+
+#define USBD_VID (0xf055)
+#define USBD_PID (0x9802)
+
+#define USBD_DESC_LEN (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN)
+#define USBD_MAX_POWER_MA (250)
+
+#define USBD_ITF_CDC (0) // needs 2 interfaces
+#define USBD_ITF_MAX (2)
+
+#define USBD_CDC_EP_CMD (0x81)
+#define USBD_CDC_EP_OUT (0x02)
+#define USBD_CDC_EP_IN (0x82)
+#define USBD_CDC_CMD_MAX_SIZE (8)
+
+#define USBD_STR_0 (0x00)
+#define USBD_STR_MANUF (0x01)
+#define USBD_STR_PRODUCT (0x02)
+#define USBD_STR_SERIAL (0x03)
+#define USBD_STR_CDC (0x04)
+
+// Note: descriptors returned from callbacks must exist long enough for transfer to complete
+
+static const tusb_desc_device_t usbd_desc_device = {
+    .bLength = sizeof(tusb_desc_device_t),
+    .bDescriptorType = TUSB_DESC_DEVICE,
+    .bcdUSB = 0x0200,
+    .bDeviceClass = TUSB_CLASS_MISC,
+    .bDeviceSubClass = MISC_SUBCLASS_COMMON,
+    .bDeviceProtocol = MISC_PROTOCOL_IAD,
+    .bMaxPacketSize0 = CFG_TUD_ENDPOINT0_SIZE,
+    .idVendor = USBD_VID,
+    .idProduct = USBD_PID,
+    .bcdDevice = 0x0100,
+    .iManufacturer = USBD_STR_MANUF,
+    .iProduct = USBD_STR_PRODUCT,
+    .iSerialNumber = USBD_STR_SERIAL,
+    .bNumConfigurations = 1,
+};
+
+static const uint8_t usbd_desc_cfg[USBD_DESC_LEN] = {
+    TUD_CONFIG_DESCRIPTOR(USBD_ITF_MAX, USBD_STR_0, USBD_DESC_LEN,
+        TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, USBD_MAX_POWER_MA),
+
+    TUD_CDC_DESCRIPTOR(USBD_ITF_CDC, USBD_STR_CDC, USBD_CDC_EP_CMD,
+        USBD_CDC_CMD_MAX_SIZE, USBD_CDC_EP_OUT, USBD_CDC_EP_IN, CFG_TUD_CDC_RX_BUFSIZE),
+};
+
+static const char *const usbd_desc_str[] = {
+    [USBD_STR_MANUF] = "MicroPython",
+    [USBD_STR_PRODUCT] = "Board in FS mode",
+    [USBD_STR_SERIAL] = "000000000000", // TODO
+    [USBD_STR_CDC] = "Board CDC",
+};
+
+const uint8_t *tud_descriptor_device_cb(void) {
+    return (const uint8_t *)&usbd_desc_device;
+}
+
+const uint8_t *tud_descriptor_configuration_cb(uint8_t index) {
+    (void)index;
+    return usbd_desc_cfg;
+}
+
+const uint16_t *tud_descriptor_string_cb(uint8_t index) {
+    #define DESC_STR_MAX (20)
+    static uint16_t desc_str[DESC_STR_MAX];
+
+    uint8_t len;
+    if (index == 0) {
+        desc_str[1] = 0x0409; // supported language is English
+        len = 1;
+    } else {
+        if (index >= sizeof(usbd_desc_str) / sizeof(usbd_desc_str[0])) {
+            return NULL;
+        }
+        const char *str = usbd_desc_str[index];
+        for (len = 0; len < DESC_STR_MAX - 1 && str[len]; ++len) {
+            desc_str[1 + len] = str[len];
+        }
+    }
+
+    // first byte is length (including header), second byte is string type
+    desc_str[0] = (TUSB_DESC_STRING << 8) | (2 * len + 2);
+
+    return desc_str;
+}
diff --git a/ports/minimal/Makefile b/ports/minimal/Makefile
index 64ad3cc0b2129..5801d64087b21 100644
--- a/ports/minimal/Makefile
+++ b/ports/minimal/Makefile
@@ -5,11 +5,14 @@ CROSS = 0
 # qstr definitions (must come before including py.mk)
 QSTR_DEFS = qstrdefsport.h
 
+# MicroPython feature configurations
+MICROPY_ROM_TEXT_COMPRESSION ?= 1
+
 # include py core make definitions
 include $(TOP)/py/py.mk
 
 ifeq ($(CROSS), 1)
-CROSS_COMPILE = arm-none-eabi-
+CROSS_COMPILE ?= arm-none-eabi-
 endif
 
 INC += -I.
@@ -19,15 +22,17 @@ INC += -I$(BUILD)
 ifeq ($(CROSS), 1)
 DFU = $(TOP)/tools/dfu.py
 PYDFU = $(TOP)/tools/pydfu.py
-CFLAGS_CORTEX_M4 = -mthumb -mtune=cortex-m4 -mabi=aapcs-linux -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -fsingle-precision-constant -Wdouble-promotion
+CFLAGS_CORTEX_M4 = -mthumb -mtune=cortex-m4 -mcpu=cortex-m4 -msoft-float -fsingle-precision-constant -Wdouble-promotion -Wfloat-conversion
 CFLAGS = $(INC) -Wall -Werror -std=c99 -nostdlib $(CFLAGS_CORTEX_M4) $(COPT)
 LDFLAGS = -nostdlib -T stm32f405.ld -Map=$@.map --cref --gc-sections
 else
 LD = gcc
-CFLAGS = -m32 $(INC) -Wall -Werror -std=c99 $(COPT)
+CFLAGS = -m32 $(INC) -Wall -Werror -Wdouble-promotion -Wfloat-conversion -std=c99 $(COPT)
 LDFLAGS = -m32 -Wl,-Map=$@.map,--cref -Wl,--gc-sections
 endif
 
+CSUPEROPT = -Os # save some code space
+
 # Tune for Debugging or Optimization
 ifeq ($(DEBUG), 1)
 CFLAGS += -O0 -ggdb
diff --git a/ports/minimal/frozentest.mpy b/ports/minimal/frozentest.mpy
index 08d7385322f41..8a89194a10487 100644
Binary files a/ports/minimal/frozentest.mpy and b/ports/minimal/frozentest.mpy differ
diff --git a/ports/minimal/frozentest.py b/ports/minimal/frozentest.py
index 0f99b74297fbb..78cdd60bf0431 100644
--- a/ports/minimal/frozentest.py
+++ b/ports/minimal/frozentest.py
@@ -1,7 +1,7 @@
-print('uPy')
-print('a long string that is not interned')
-print('a string that has unicode αβγ chars')
-print(b'bytes 1234\x01')
+print("uPy")
+print("a long string that is not interned")
+print("a string that has unicode αβγ chars")
+print(b"bytes 1234\x01")
 print(123456789)
 for i in range(4):
     print(i)
diff --git a/ports/minimal/main.c b/ports/minimal/main.c
index 5e145dc8293d7..6943ee7589f39 100644
--- a/ports/minimal/main.c
+++ b/ports/minimal/main.c
@@ -16,7 +16,7 @@ void do_str(const char *src, mp_parse_input_kind_t input_kind) {
         mp_lexer_t *lex = mp_lexer_new_from_str_len(MP_QSTR__lt_stdin_gt_, src, strlen(src), 0);
         qstr source_name = lex->source_name;
         mp_parse_tree_t parse_tree = mp_parse(lex, input_kind);
-        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, MP_EMIT_OPT_NONE, true);
+        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, true);
         mp_call_function_0(module_fun);
         nlr_pop();
     } else {
@@ -33,7 +33,7 @@ static char heap[2048];
 
 int main(int argc, char **argv) {
     int stack_dummy;
-    stack_top = (char*)&stack_dummy;
+    stack_top = (char *)&stack_dummy;
 
     #if MICROPY_ENABLE_GC
     gc_init(heap, heap + sizeof(heap));
@@ -51,8 +51,8 @@ int main(int argc, char **argv) {
     #else
     pyexec_friendly_repl();
     #endif
-    //do_str("print('hello world!', list(x+1 for x in range(10)), end='eol\\n')", MP_PARSE_SINGLE_INPUT);
-    //do_str("for i in range(10):\r\n  print(i)", MP_PARSE_FILE_INPUT);
+    // do_str("print('hello world!', list(x+1 for x in range(10)), end='eol\\n')", MP_PARSE_SINGLE_INPUT);
+    // do_str("for i in range(10):\r\n  print(i)", MP_PARSE_FILE_INPUT);
     #else
     pyexec_frozen_module("frozentest.py");
     #endif
@@ -84,11 +84,15 @@ mp_obj_t mp_builtin_open(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs)
 MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
 
 void nlr_jump_fail(void *val) {
-    while (1);
+    while (1) {
+        ;
+    }
 }
 
 void NORETURN __fatal_error(const char *msg) {
-    while (1);
+    while (1) {
+        ;
+    }
 }
 
 #ifndef NDEBUG
@@ -149,7 +153,7 @@ void _start(void) {
     // when we get here: stack is initialised, bss is clear, data is copied
 
     // SCB->CCR: enable 8-byte stack alignment for IRQ handlers, in accord with EABI
-    *((volatile uint32_t*)0xe000ed14) |= 1 << 9;
+    *((volatile uint32_t *)0xe000ed14) |= 1 << 9;
 
     // initialise the cpu and peripherals
     #if MICROPY_MIN_USE_STM32_MCU
@@ -205,10 +209,10 @@ typedef struct {
     volatile uint32_t CR1;
 } periph_uart_t;
 
-#define USART1 ((periph_uart_t*) 0x40011000)
-#define GPIOA  ((periph_gpio_t*) 0x40020000)
-#define GPIOB  ((periph_gpio_t*) 0x40020400)
-#define RCC    ((periph_rcc_t*)  0x40023800)
+#define USART1 ((periph_uart_t *)0x40011000)
+#define GPIOA  ((periph_gpio_t *)0x40020000)
+#define GPIOB  ((periph_gpio_t *)0x40020400)
+#define RCC    ((periph_rcc_t *)0x40023800)
 
 // simple GPIO interface
 #define GPIO_MODE_IN (0)
diff --git a/ports/minimal/mpconfigport.h b/ports/minimal/mpconfigport.h
index f2a43523d57b8..2507d0124d1ca 100644
--- a/ports/minimal/mpconfigport.h
+++ b/ports/minimal/mpconfigport.h
@@ -55,12 +55,13 @@
 #define MICROPY_PY_SYS              (0)
 #define MICROPY_MODULE_FROZEN_MPY   (1)
 #define MICROPY_CPYTHON_COMPAT      (0)
+#define MICROPY_MODULE_GETATTR      (0)
 #define MICROPY_LONGINT_IMPL        (MICROPY_LONGINT_IMPL_NONE)
 #define MICROPY_FLOAT_IMPL          (MICROPY_FLOAT_IMPL_NONE)
 
 // type definitions for the specific machine
 
-#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void*)((mp_uint_t)(p) | 1))
+#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)((mp_uint_t)(p) | 1))
 
 // This port is intended to be 32-bit, but unfortunately, int32_t for
 // different targets may be defined in different ways - either as int
diff --git a/ports/minimal/mphalport.h b/ports/minimal/mphalport.h
index 60d68bd2d6d50..5130d19a24ac5 100644
--- a/ports/minimal/mphalport.h
+++ b/ports/minimal/mphalport.h
@@ -1,2 +1,5 @@
-static inline mp_uint_t mp_hal_ticks_ms(void) { return 0; }
-static inline void mp_hal_set_interrupt_char(char c) {}
+static inline mp_uint_t mp_hal_ticks_ms(void) {
+    return 0;
+}
+static inline void mp_hal_set_interrupt_char(char c) {
+}
diff --git a/ports/minimal/qstrdefsport.h b/ports/minimal/qstrdefsport.h
index 3ba897069bf73..00d3e2ae3c555 100644
--- a/ports/minimal/qstrdefsport.h
+++ b/ports/minimal/qstrdefsport.h
@@ -1 +1,2 @@
 // qstrs specific to this port
+// *FORMAT-OFF*
diff --git a/ports/minimal/uart_core.c b/ports/minimal/uart_core.c
index d2d17b4d14180..c7af24404bd52 100644
--- a/ports/minimal/uart_core.c
+++ b/ports/minimal/uart_core.c
@@ -10,35 +10,35 @@ typedef struct {
     volatile uint32_t SR;
     volatile uint32_t DR;
 } periph_uart_t;
-#define USART1 ((periph_uart_t*)0x40011000)
+#define USART1 ((periph_uart_t *)0x40011000)
 #endif
 
 // Receive single character
 int mp_hal_stdin_rx_chr(void) {
     unsigned char c = 0;
-#if MICROPY_MIN_USE_STDOUT
-    int r = read(0, &c, 1);
+    #if MICROPY_MIN_USE_STDOUT
+    int r = read(STDIN_FILENO, &c, 1);
     (void)r;
-#elif MICROPY_MIN_USE_STM32_MCU
+    #elif MICROPY_MIN_USE_STM32_MCU
     // wait for RXNE
     while ((USART1->SR & (1 << 5)) == 0) {
     }
     c = USART1->DR;
-#endif
+    #endif
     return c;
 }
 
 // Send string of given length
 void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) {
-#if MICROPY_MIN_USE_STDOUT
-    int r = write(1, str, len);
+    #if MICROPY_MIN_USE_STDOUT
+    int r = write(STDOUT_FILENO, str, len);
     (void)r;
-#elif MICROPY_MIN_USE_STM32_MCU
+    #elif MICROPY_MIN_USE_STM32_MCU
     while (len--) {
         // wait for TXE
         while ((USART1->SR & (1 << 7)) == 0) {
         }
         USART1->DR = *str++;
     }
-#endif
+    #endif
 }
diff --git a/ports/nrf/.gitignore b/ports/nrf/.gitignore
index ace93515a20cf..4b46e05865781 100644
--- a/ports/nrf/.gitignore
+++ b/ports/nrf/.gitignore
@@ -1,8 +1,3 @@
 # Nordic files
 #####################
 drivers/bluetooth/s1*/
-
-# Build files
-#####################
-build-*/
-
diff --git a/ports/nrf/Makefile b/ports/nrf/Makefile
index 80110f9704ddf..23d5cd20d0d00 100644
--- a/ports/nrf/Makefile
+++ b/ports/nrf/Makefile
@@ -38,15 +38,19 @@ endif
 # qstr definitions (must come before including py.mk)
 QSTR_DEFS = qstrdefsport.h $(BUILD)/pins_qstr.h
 
+# MicroPython feature configurations
+MICROPY_ROM_TEXT_COMPRESSION ?= 1
+
 # include py core make definitions
 include ../../py/py.mk
 
-MICROPY_FATFS ?= 0
-FATFS_DIR = lib/oofatfs
+GIT_SUBMODULES = lib/nrfx lib/tinyusb
+
+MICROPY_VFS_FAT ?= 0
 MPY_CROSS = ../../mpy-cross/mpy-cross
 MPY_TOOL = ../../tools/mpy-tool.py
 
-CROSS_COMPILE = arm-none-eabi-
+CROSS_COMPILE ?= arm-none-eabi-
 
 INC += -I.
 INC += -I../..
@@ -55,7 +59,6 @@ INC += -I./../../lib/cmsis/inc
 INC += -I./modules/machine
 INC += -I./modules/ubluepy
 INC += -I./modules/music
-INC += -I./modules/random
 INC += -I./modules/ble
 INC += -I./modules/board
 INC += -I../../lib/mp-readline
@@ -66,6 +69,7 @@ INC += -I../../lib/nrfx/drivers
 INC += -I../../lib/nrfx/drivers/include
 INC += -I../../lib/nrfx/mdk
 INC += -I../../lib/nrfx/hal
+INC += -I../../lib/nrfx/drivers/src/
 
 MCU_VARIANT_UPPER = $(shell echo $(MCU_VARIANT) | tr '[:lower:]' '[:upper:]')
 MCU_SUB_VARIANT_UPPER = $(shell echo $(MCU_SUB_VARIANT) | tr '[:lower:]' '[:upper:]')
@@ -81,6 +85,9 @@ else ifeq ($(MCU_SUB_VARIANT),nrf52832)
 else ifeq ($(MCU_SUB_VARIANT),nrf52840)
 	SYSTEM_C_SRC += $(addprefix lib/nrfx/mdk/, system_nrf52840.c)
 	# Do not pass MCU_VARIANT_UPPER flag, as NRF52 defines NRF52832 only.
+else ifeq ($(MCU_SUB_VARIANT),nrf9160)
+        SYSTEM_C_SRC += $(addprefix lib/nrfx/mdk/, system_nrf9160.c)
+        NRF_DEFINES += -D$(MCU_VARIANT_UPPER)
 endif
 
 NRF_DEFINES += -D$(MCU_SUB_VARIANT_UPPER)
@@ -88,9 +95,11 @@ NRF_DEFINES += -DCONFIG_GPIO_AS_PINRESET
 
 CFLAGS_CORTEX_M = -mthumb -mabi=aapcs -fsingle-precision-constant -Wdouble-promotion
 
+CFLAGS_MCU_m33 = $(CFLAGS_CORTEX_M) -mcpu=cortex-m33 -march=armv8-m.main+dsp -mcmse -mfpu=fpv5-sp-d16 -mfloat-abi=hard
+
 CFLAGS_MCU_m4 = $(CFLAGS_CORTEX_M) -mtune=cortex-m4 -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard
 
-CFLAGS_MCU_m0 = $(CFLAGS_CORTEX_M) -fshort-enums -mtune=cortex-m0 -mcpu=cortex-m0 -mfloat-abi=soft -fno-builtin
+CFLAGS_MCU_m0 = $(CFLAGS_CORTEX_M) -fshort-enums -mtune=cortex-m0 -mcpu=cortex-m0 -mfloat-abi=soft
 
 LTO ?= 1
 ifeq ($(LTO),1)
@@ -101,7 +110,7 @@ LDFLAGS += -Wl,--gc-sections
 endif
 
 
-CFLAGS += $(CFLAGS_MCU_$(MCU_SERIES)) 
+CFLAGS += $(CFLAGS_MCU_$(MCU_SERIES))
 CFLAGS += $(INC) -Wall -Werror -g -ansi -std=c11 -nostdlib $(COPT) $(NRF_DEFINES) $(CFLAGS_MOD)
 CFLAGS += -fno-strict-aliasing
 CFLAGS += -Iboards/$(BOARD)
@@ -124,10 +133,32 @@ endif
 LIBS = \
 
 ifeq ($(MCU_VARIANT), nrf52)
-LIBGCC_FILE_NAME = $(shell $(CC) $(CFLAGS) -print-libgcc-file-name)
 
-LIBS += -L $(dir $(LIBGCC_FILE_NAME)) -lgcc
+SRC_LIB += $(addprefix lib/,\
+        libm/math.c \
+        libm/fmodf.c \
+        libm/nearbyintf.c \
+        libm/ef_sqrt.c \
+        libm/kf_rem_pio2.c \
+        libm/kf_sin.c \
+        libm/kf_cos.c \
+        libm/kf_tan.c \
+        libm/ef_rem_pio2.c \
+        libm/sf_sin.c \
+        libm/sf_cos.c \
+        libm/sf_tan.c \
+        libm/sf_frexp.c \
+        libm/sf_modf.c \
+        libm/sf_ldexp.c \
+        libm/asinfacosf.c \
+        libm/atanf.c \
+        libm/atan2f.c \
+        libm/roundf.c \
+	)
 
+endif
+
+ifeq ($(MCU_VARIANT), nrf91)
 
 SRC_LIB += $(addprefix lib/,\
         libm/math.c \
@@ -148,7 +179,14 @@ SRC_LIB += $(addprefix lib/,\
         libm/asinfacosf.c \
         libm/atanf.c \
         libm/atan2f.c \
-	)
+        )
+
+SRC_NRFX += $(addprefix lib/nrfx/drivers/src/,\
+        nrfx_uarte.c \
+        nrfx_twim.c \
+        )
+
+include drivers/secureboot/secureboot.mk
 
 endif
 
@@ -156,6 +194,7 @@ SRC_LIB += $(addprefix lib/,\
 	libc/string0.c \
 	mp-readline/readline.c \
 	utils/pyexec.c \
+	utils/sys_stdio_mphal.c \
 	utils/interrupt_char.c \
 	timeutils/timeutils.c \
 	)
@@ -173,6 +212,7 @@ SRC_NRFX += $(addprefix lib/nrfx/drivers/src/,\
 	nrfx_uart.c \
 	nrfx_adc.c \
 	nrfx_saadc.c \
+	nrfx_temp.c \
 	nrfx_rng.c \
 	nrfx_twi.c \
 	nrfx_spi.c \
@@ -181,10 +221,9 @@ SRC_NRFX += $(addprefix lib/nrfx/drivers/src/,\
 	nrfx_timer.c \
 	nrfx_pwm.c \
 	nrfx_gpiote.c \
-	)
-
-SRC_NRFX_HAL += $(addprefix lib/nrfx/hal/,\
-	nrf_nvmc.c \
+	nrfx_nvmc.c \
+	nrfx_power.c \
+	nrfx_clock.c \
 	)
 
 SRC_C += \
@@ -195,11 +234,39 @@ SRC_C += \
 	pin_named_pins.c \
 	fatfs_port.c \
 	drivers/flash.c \
+	drivers/rng.c \
 	drivers/softpwm.c \
 	drivers/ticker.c \
 	drivers/bluetooth/ble_drv.c \
 	drivers/bluetooth/ble_uart.c \
 
+ifeq ($(MCU_SUB_VARIANT), nrf52840)
+
+INC += -I./drivers/usb
+INC += -I../../lib/tinyusb/src
+
+
+# If SoftDevice is selected.
+ifneq ($(SD), )
+# For external tinyusb drivers to enable SoftDevice mode.
+CFLAGS += -DSOFTDEVICE_PRESENT
+endif
+
+SRC_C += $(addprefix drivers/usb/,\
+	usb_cdc.c \
+	usb_descriptors.c \
+	)
+
+SRC_C += $(addprefix lib/tinyusb/src/,\
+	common/tusb_fifo.c \
+	device/usbd.c \
+	device/usbd_control.c \
+	class/cdc/cdc_device.c \
+	tusb.c \
+	portable/nordic/nrf5x/dcd_nrf5x.c \
+	)
+endif
+
 DRIVERS_SRC_C += $(addprefix modules/,\
 	machine/modmachine.c \
 	machine/uart.c \
@@ -229,7 +296,6 @@ DRIVERS_SRC_C += $(addprefix modules/,\
 	music/modmusic.c \
 	music/musictunes.c \
 	ble/modble.c \
-	random/modrandom.c \
 	)
 
 # Custom micropython startup file with smaller interrupt vector table
@@ -242,21 +308,28 @@ FROZEN_MPY_PY_FILES := $(shell find -L $(FROZEN_MPY_DIR) -type f -name '*.py')
 FROZEN_MPY_MPY_FILES := $(addprefix $(BUILD)/,$(FROZEN_MPY_PY_FILES:.py=.mpy))
 endif
 
+LIBGCC_FILE_NAME = $(shell $(CC) $(CFLAGS) -print-libgcc-file-name)
+LIBS += -L $(dir $(LIBGCC_FILE_NAME)) -lgcc
+
 OBJ += $(PY_O) $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
-OBJ += $(addprefix $(BUILD)/, $(SRC_LIB:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(SRC_MOD:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(SRC_NRFX:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(SRC_NRFX_HAL:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(DRIVERS_SRC_C:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(SYSTEM_C_SRC:.c=.o))
+OBJ += $(addprefix $(BUILD)/, $(SRC_LIB:.c=.o))
 OBJ += $(BUILD)/pins_gen.o
 
-$(BUILD)/$(FATFS_DIR)/ff.o: COPT += -Os
+$(BUILD)/$(OOFATFS_DIR)/ff.o: COPT += -Os
 $(filter $(PY_BUILD)/../extmod/vfs_fat_%.o, $(PY_O)): COPT += -Os
 
-.PHONY: all flash sd binary hex
+.PHONY: all flash deploy sd binary hex
 
+ifeq ($(MCU_VARIANT), nrf91)
+all: binary hex secureboot
+else
 all: binary hex
+endif
 
 OUTPUT_FILENAME = firmware
 
@@ -276,10 +349,21 @@ FLASHER ?=
 
 ifeq ($(FLASHER),)
 
-flash: $(BUILD)/$(OUTPUT_FILENAME).hex
+ifeq ($(MCU_VARIANT), nrf91)
+
+deploy: $(BUILD)/$(OUTPUT_FILENAME).hex $(BUILD)/secureboot.hex
+	nrfjprog --program $(BUILD)/secureboot.hex --sectorerase -f $(MCU_VARIANT)
+	nrfjprog --program $(BUILD)/$(OUTPUT_FILENAME).hex --sectorerase -f $(MCU_VARIANT)
+	nrfjprog --reset -f $(MCU_VARIANT)
+
+else
+
+deploy: $(BUILD)/$(OUTPUT_FILENAME).hex
 	nrfjprog --program $< --sectorerase -f $(MCU_VARIANT)
 	nrfjprog --reset -f $(MCU_VARIANT)
 
+endif
+
 sd: $(BUILD)/$(OUTPUT_FILENAME).hex
 	nrfjprog --eraseall -f $(MCU_VARIANT)
 	nrfjprog --program $(SOFTDEV_HEX) -f $(MCU_VARIANT)
@@ -288,7 +372,7 @@ sd: $(BUILD)/$(OUTPUT_FILENAME).hex
 
 else ifeq ($(FLASHER), pyocd)
 
-flash: $(BUILD)/$(OUTPUT_FILENAME).hex
+deploy: $(BUILD)/$(OUTPUT_FILENAME).hex
 	pyocd-flashtool -t $(MCU_VARIANT) $<
 
 sd: $(BUILD)/$(OUTPUT_FILENAME).hex
@@ -296,15 +380,74 @@ sd: $(BUILD)/$(OUTPUT_FILENAME).hex
 	pyocd-flashtool -t $(MCU_VARIANT) $(SOFTDEV_HEX)
 	pyocd-flashtool -t $(MCU_VARIANT) $<
 
+else ifeq ($(FLASHER), idap)
+
+deploy: $(BUILD)/$(OUTPUT_FILENAME).hex
+	IDAPnRFPRog $<
+
+sd: $(BUILD)/$(OUTPUT_FILENAME).hex
+	IDAPnRFPRog $(SOFTDEV_HEX) $<
+
+else ifeq ($(FLASHER), bmp)
+
+BMP_PORT ?= /dev/ttyACM0
+
+deploy: $(BUILD)/$(OUTPUT_FILENAME).elf
+	$(Q)$(GDB) \
+	    -ex 'target extended-remote $(BMP_PORT)' \
+	    -ex 'monitor tpwr enable' \
+	    -ex 'monitor swdp_scan' \
+	    -ex 'attach 1' \
+	    -ex 'set mem inaccessible-by-default off' \
+	    -ex 'load' \
+	    -ex 'kill' \
+	    -ex 'quit' \
+	    $<
+
+sd: $(BUILD)/$(OUTPUT_FILENAME).elf
+	$(Q)$(GDB) \
+	    -ex 'target extended-remote $(BMP_PORT)' \
+	    -ex 'monitor tpwr enable' \
+	    -ex 'monitor swdp_scan' \
+	    -ex 'attach 1' \
+	    -ex 'set mem inaccessible-by-default off' \
+	    -ex 'monitor erase_mass' \
+	    -ex 'load' \
+	    -ex 'file $(SOFTDEV_HEX)' \
+	    -ex 'load' \
+	    -ex 'kill' \
+	    -ex 'quit' \
+	    $<
+
+else ifeq ($(FLASHER), openocd)
+
+OPENOCD ?= openocd
+
+ifeq ($(MCU_VARIANT), nrf51)
+OPENOCD_TARGET ?= target/nrf52.cfg
+else ifeq ($(MCU_VARIANT), nrf52)
+OPENOCD_TARGET ?= target/nrf52.cfg
+else
+$(error Unsupported openocd target)
+endif
+
+deploy: $(BUILD)/$(OUTPUT_FILENAME).hex
+	$(Q)$(OPENOCD) -f interface/cmsis-dap.cfg -f $(OPENOCD_TARGET) -c "init" -c "program $< verify reset" -c "exit"
+
+sd: $(BUILD)/$(OUTPUT_FILENAME).hex
+	$(Q)$(OPENOCD) -f interface/cmsis-dap.cfg -f $(OPENOCD_TARGET) -c "init" -c "program $(SOFTDEV_HEX) verify reset" -c "exit"
+
 endif
 
+flash: deploy
+
 $(BUILD)/$(OUTPUT_FILENAME).elf: $(OBJ)
 	$(ECHO) "LINK $@"
 	$(Q)$(CC) $(LDFLAGS) -o $@ $(OBJ) $(LIBS)
 	$(Q)$(SIZE) $@
 
 # List of sources for qstr extraction
-SRC_QSTR += $(SRC_C) $(DRIVERS_SRC_C) $(SRC_BOARD_MODULES)
+SRC_QSTR += $(SRC_C) $(SRC_LIB) $(DRIVERS_SRC_C) $(SRC_BOARD_MODULES)
 
 # Append any auto-generated sources that are needed by sources listed in
 # SRC_QSTR
diff --git a/ports/nrf/README.md b/ports/nrf/README.md
index 659a556ae2b26..b5f39267ebf2f 100644
--- a/ports/nrf/README.md
+++ b/ports/nrf/README.md
@@ -30,12 +30,19 @@ This is a port of MicroPython to the Nordic Semiconductor nRF series of chips.
   * PCA10031 (dongle)
   * [WT51822-S4AT](http://www.wireless-tag.com/wireless_module/BLE/WT51822-S4AT.html)
 * nRF52832
-  * [PCA10040](http://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.nrf52%2Fdita%2Fnrf52%2Fdevelopment%2Fnrf52_dev_kit.html) 
+  * [PCA10040](http://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.nrf52%2Fdita%2Fnrf52%2Fdevelopment%2Fnrf52_dev_kit.html)
   * [Adafruit Feather nRF52](https://www.adafruit.com/product/3406)
   * [Thingy:52](http://www.nordicsemi.com/eng/Products/Nordic-Thingy-52)
   * [Arduino Primo](http://www.arduino.org/products/boards/arduino-primo)
+  * [IBK-BLYST-NANO breakout board](https://www.crowdsupply.com/i-syst/blyst-nano)
+  * [BLUEIO-TAG-EVIM BLYST Nano Sensor board](https://www.crowdsupply.com/i-syst/blyst-nano)
+  * [uBlox EVK-NINA-B1](https://www.u-blox.com/en/product/evk-nina-b1)
 * nRF52840
   * [PCA10056](http://www.nordicsemi.com/eng/Products/nRF52840-Preview-DK)
+  * [PCA10059](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52840-Dongle)
+  * [Particle Xenon](https://docs.particle.io/xenon/)
+* nRF9160
+  * [PCA10090](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF9160-DK)
 
 ## Compile and Flash
 
@@ -43,11 +50,11 @@ Prerequisite steps for building the nrf port:
 
     git clone <URL>.git micropython
     cd micropython
-    git submodule update --init
     make -C mpy-cross
 
 By default, the PCA10040 (nrf52832) is used as compile target. To build and flash issue the following command inside the ports/nrf/ folder:
 
+    make submodules
     make
     make flash
 
@@ -69,7 +76,7 @@ the compilation:
 GNU ARM Embedded Toolchain 7.2.1/4Q17. It's recommended to use a toolchain after
 this release, for example 7.3.1/2Q18 or 8.2.1/4Q18. The alternative would be to
 build the target using the LTO=0 as described above.
- 
+
 ## Compile and Flash with Bluetooth Stack
 
 First prepare the bluetooth folder by downloading Bluetooth LE stacks and headers:
@@ -100,12 +107,12 @@ To use frozen modules, put them in a directory (e.g. `freeze/`) and supply
 
      make BOARD=pca10040 FROZEN_MPY_DIR=freeze
 
-## Enable MICROPY_FATFS
-As the `oofatfs` module is not having header guards that can exclude the implementation compile time, this port provides a flag to enable it explicitly. The MICROPY_FATFS is by default set to 0 and has to be set to 1 if `oofatfs` files should be compiled. This will be in addition of setting `MICROPY_VFS` and `MICROPY_VFS_FAT` in mpconfigport.h.
+## Enable MICROPY_VFS_FAT
+As the `oofatfs` module is not having header guards that can exclude the implementation compile time, this port provides a flag to enable it explicitly. The MICROPY_VFS_FAT is by default set to 0 and has to be set to 1 if `oofatfs` files should be compiled. This will be in addition of setting `MICROPY_VFS` in mpconfigport.h.
 
 For example:
 
-     make BOARD=pca10040 MICROPY_FATFS=1
+     make BOARD=pca10040 MICROPY_VFS_FAT=1
 
 ## Target Boards and Make Flags
 
@@ -120,7 +127,23 @@ wt51822_s4at         | s110                    | Peripheral             | Manual
 pca10040             | s132                    | Peripheral and Central | [Segger](#segger-targets)
 feather52            | s132                    | Peripheral and Central | Manual, SWDIO and SWCLK solder points on the bottom side of the board
 arduino_primo        | s132                    | Peripheral and Central | [PyOCD](#pyocdopenocd-targets)
+ibk_blyst_nano       | s132                    | Peripheral and Central | [IDAP](#idap-midap-link-targets)
+idk_blyst_nano       | s132                    | Peripheral and Central | [IDAP](#idap-midap-link-targets)
+blueio_tag_evim      | s132                    | Peripheral and Central | [IDAP](#idap-midap-link-targets)
+evk_nina_b1          | s132                    | Peripheral and Central | [Segger](#segger-targets)
 pca10056             | s140                    | Peripheral and Central | [Segger](#segger-targets)
+pca10059             | s140                    | Peripheral and Central | Manual, SWDIO and SWCLK solder points on the sides.
+particle_xenon       | s140                    | Peripheral and Central | [Black Magic Probe](#black-magic-probe-targets)
+pca10090             | None (bsdlib.a)         | None (LTE/GNSS)        | [Segger](#segger-targets)
+
+## IDAP-M/IDAP-Link Targets
+
+Install the necessary tools to flash and debug using IDAP-M/IDAP-Link CMSIS-DAP Debug JTAG:
+
+[IDAPnRFProg for Linux](https://sourceforge.net/projects/idaplinkfirmware/files/Linux/IDAPnRFProg_1_7_190320.zip/download)
+[IDAPnRFProg for OSX](https://sourceforge.net/projects/idaplinkfirmware/files/OSX/IDAPnRFProg_1_7_190320.zip/download)
+[IDAPnRFProg for Windows](https://sourceforge.net/projects/idaplinkfirmware/files/Windows/IDAPnRFProg_1_7_190320.zip/download)
+
 
 ## Segger Targets
 
@@ -139,6 +162,14 @@ Install the necessary tools to flash and debug using OpenOCD:
     sudo apt-get install openocd
     sudo pip install pyOCD
 
+## Black Magic Probe Targets
+
+This requires no further dependencies other than `arm-none-eabi-gdb`.
+
+`make deploy` will use gdb to load and run new firmware. See
+[this guide](https://github.com/blacksphere/blackmagic/wiki/Useful-GDB-commands)
+for more tips about using the BMP with GDB.
+
 ## Bluetooth LE REPL
 
 The port also implements a BLE REPL driver. This feature is disabled by default, as it will deactivate the UART REPL when activated. As some of the nRF devices only have one UART, using the BLE REPL free's the UART instance such that it can be used as a general UART peripheral not bound to REPL.
diff --git a/ports/nrf/boards/arduino_primo/mpconfigboard.h b/ports/nrf/boards/arduino_primo/mpconfigboard.h
index c34a74762c015..639b6869c0980 100644
--- a/ports/nrf/boards/arduino_primo/mpconfigboard.h
+++ b/ports/nrf/boards/arduino_primo/mpconfigboard.h
@@ -39,7 +39,8 @@
 #define MICROPY_PY_MACHINE_I2C      (1)
 #define MICROPY_PY_MACHINE_ADC      (1)
 #define MICROPY_PY_MACHINE_TEMP     (1)
-#define MICROPY_PY_RANDOM_HW_RNG    (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
 
 #define MICROPY_HW_HAS_LED          (1)
 #define MICROPY_HW_LED_COUNT        (1)
diff --git a/ports/nrf/boards/blueio_tag_evim/mpconfigboard.h b/ports/nrf/boards/blueio_tag_evim/mpconfigboard.h
new file mode 100644
index 0000000000000..2ceeadf8eb939
--- /dev/null
+++ b/ports/nrf/boards/blueio_tag_evim/mpconfigboard.h
@@ -0,0 +1,75 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 I-SYST inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#define MICROPY_HW_BOARD_NAME       "BLUEIO-TAG-EVIM"
+#define MICROPY_HW_MCU_NAME         "NRF52832"
+#define MICROPY_PY_SYS_PLATFORM     "BLYST Nano"
+
+#define MICROPY_PY_MACHINE_SOFT_PWM (1)
+#define MICROPY_PY_MUSIC            (1)
+
+#define MICROPY_PY_MACHINE_UART     (1)
+#define MICROPY_PY_MACHINE_HW_PWM   (1)
+#define MICROPY_PY_MACHINE_HW_SPI   (1)
+#define MICROPY_PY_MACHINE_TIMER    (1)
+#define MICROPY_PY_MACHINE_RTCOUNTER (1)
+#define MICROPY_PY_MACHINE_I2C      (1)
+#define MICROPY_PY_MACHINE_ADC      (1)
+#define MICROPY_PY_MACHINE_TEMP     (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
+
+#define MICROPY_HW_HAS_LED          (1)
+#define MICROPY_HW_LED_COUNT        (4)
+#define MICROPY_HW_LED_PULLUP       (1)
+
+#define MICROPY_HW_LED1             (30) // LED1
+#define MICROPY_HW_LED1_PULLUP      (0)
+#define MICROPY_HW_LED2             (20) // LED2
+#define MICROPY_HW_LED3             (19) // LED3
+#define MICROPY_HW_LED4             (18) // LED4
+
+// UART config
+#define MICROPY_HW_UART1_RX         (8)
+#define MICROPY_HW_UART1_TX         (7)
+#define MICROPY_HW_UART1_CTS        (12)
+#define MICROPY_HW_UART1_RTS        (11)
+#define MICROPY_HW_UART1_HWFC       (1)
+
+// SPI0 config
+#define MICROPY_HW_SPI0_NAME        "SPI0"
+#define MICROPY_HW_SPI0_SCK         (23) //
+#define MICROPY_HW_SPI0_MOSI        (24) //
+#define MICROPY_HW_SPI0_MISO        (25) //
+
+#define MICROPY_HW_PWM0_NAME        "PWM0"
+#define MICROPY_HW_PWM1_NAME        "PWM1"
+#define MICROPY_HW_PWM2_NAME        "PWM2"
+
+// buzzer pin
+#define MICROPY_HW_MUSIC_PIN        (14)
+
+#define HELP_TEXT_BOARD_LED         "1,2,3,4"
diff --git a/ports/nrf/boards/blueio_tag_evim/mpconfigboard.mk b/ports/nrf/boards/blueio_tag_evim/mpconfigboard.mk
new file mode 100644
index 0000000000000..02a3177446b10
--- /dev/null
+++ b/ports/nrf/boards/blueio_tag_evim/mpconfigboard.mk
@@ -0,0 +1,8 @@
+MCU_SERIES = m4
+MCU_VARIANT = nrf52
+MCU_SUB_VARIANT = nrf52832
+SOFTDEV_VERSION = 6.1.1
+LD_FILES += boards/nrf52832_512k_64k.ld
+FLASHER = idap
+
+NRF_DEFINES += -DNRF52832_XXAA
diff --git a/ports/nrf/boards/blueio_tag_evim/pins.csv b/ports/nrf/boards/blueio_tag_evim/pins.csv
new file mode 100644
index 0000000000000..90bf84a04d44a
--- /dev/null
+++ b/ports/nrf/boards/blueio_tag_evim/pins.csv
@@ -0,0 +1,30 @@
+P2,P2
+P3,P3
+P4,P4
+P5,P5
+P6,P6
+P7,P7
+P8,P8
+P9,P9
+P10,P10
+P11,P11
+P12,P12
+P13,P13
+P14,P14
+P15,P15
+P16,P16
+P17,P17
+P18,P18
+P19,P19
+P20,P20
+P21,P21
+P22,P22
+P23,P23
+P24,P24
+P25,P25
+P26,P26
+P27,P27
+P28,P28
+P29,P29
+P30,P30
+P31,P31
diff --git a/ports/nrf/boards/common.ld b/ports/nrf/boards/common.ld
index 2e1e6f7358cf0..d2e5eef7627fd 100644
--- a/ports/nrf/boards/common.ld
+++ b/ports/nrf/boards/common.ld
@@ -1,3 +1,5 @@
+ENTRY(Reset_Handler)
+
 /* define output sections */
 SECTIONS
 {
@@ -16,7 +18,7 @@ SECTIONS
         . = ALIGN(4);
         _etext = .;          /* define a global symbol at end of code */
     } >FLASH_TEXT
-     
+
     /*
     .ARM.extab :
     {
@@ -30,10 +32,10 @@ SECTIONS
         __exidx_end = .;
     } >FLASH
     */
-        
+
     /* used by the startup to initialize data */
     _sidata = LOADADDR(.data);
-        
+
     /* This is the initialized data section
     The program executes knowing that the data is in the RAM
     but the loader puts the initial values in the FLASH (inidata).
@@ -49,7 +51,7 @@ SECTIONS
         . = ALIGN(4);
         _edata = .;        /* define a global symbol at data end; used by startup code in order to initialise the .data section in RAM */
     } >RAM AT>FLASH_TEXT
-            
+
     /* Uninitialized data section */
     .bss :
     {
diff --git a/ports/nrf/boards/dvk_bl652/mpconfigboard.h b/ports/nrf/boards/dvk_bl652/mpconfigboard.h
index dee7dafa23299..d0b19a318453b 100644
--- a/ports/nrf/boards/dvk_bl652/mpconfigboard.h
+++ b/ports/nrf/boards/dvk_bl652/mpconfigboard.h
@@ -36,7 +36,8 @@
 #define MICROPY_PY_MACHINE_I2C      (1)
 #define MICROPY_PY_MACHINE_ADC      (1)
 #define MICROPY_PY_MACHINE_TEMP     (1)
-#define MICROPY_PY_RANDOM_HW_RNG    (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
 
 #define MICROPY_HW_HAS_LED          (1)
 #define MICROPY_HW_LED_COUNT        (2)
diff --git a/ports/nrf/boards/evk_nina_b1/mpconfigboard.h b/ports/nrf/boards/evk_nina_b1/mpconfigboard.h
new file mode 100644
index 0000000000000..f0629b3a23031
--- /dev/null
+++ b/ports/nrf/boards/evk_nina_b1/mpconfigboard.h
@@ -0,0 +1,73 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Roland van Straten
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// Datasheet for board:
+// https://www.u-blox.com/sites/default/files/EVK-NINA-B1_UserGuide_%28UBX-15028120%29.pdf
+#define MICROPY_HW_BOARD_NAME       "EVK_NINA_B1"
+#define MICROPY_HW_MCU_NAME         "NRF52832"
+#define MICROPY_PY_SYS_PLATFORM     "nrf52"
+
+#define MICROPY_PY_MACHINE_UART     (1)
+#define MICROPY_PY_MACHINE_HW_SPI   (1)
+#define MICROPY_PY_MACHINE_TIMER    (1)
+#define MICROPY_PY_MACHINE_RTCOUNTER (1)
+#define MICROPY_PY_MACHINE_I2C      (1)
+#define MICROPY_PY_MACHINE_ADC      (1)
+#define MICROPY_PY_MACHINE_TEMP     (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
+
+#define MICROPY_HW_HAS_LED          (1)
+#define MICROPY_HW_LED_TRICOLOR     (1)
+#define MICROPY_HW_LED_PULLUP       (1)
+
+#define MICROPY_HW_LED_RED          (8)   // LED1 DS8 Red
+#define MICROPY_HW_LED_GREEN        (16)  // LED2 DS8 Green
+#define MICROPY_HW_LED_BLUE         (18)  // LED3 DS8 Blue
+// LEDs conflict with UART
+//#define MICROPY_HW_LED4           (7)   // DS1 Green
+//#define MICROPY_HW_LED5           (31)  // DS2 Orange
+//#define MICROPY_HW_LED6           (5)   // DS7 Green
+//#define MICROPY_HW_LED7           (6)   // DS8 Orange
+
+// UART config
+#define MICROPY_HW_UART1_RX         (5)
+#define MICROPY_HW_UART1_TX         (6)
+#define MICROPY_HW_UART1_CTS        (7)
+#define MICROPY_HW_UART1_RTS        (31)
+#define MICROPY_HW_UART1_HWFC       (1)
+
+// SPI0 config
+#define MICROPY_HW_SPI0_NAME        "SPI0"
+#define MICROPY_HW_SPI0_SCK         (14)
+#define MICROPY_HW_SPI0_MOSI        (13)
+#define MICROPY_HW_SPI0_MISO        (12)
+
+#define MICROPY_HW_PWM0_NAME        "PWM0"
+#define MICROPY_HW_PWM1_NAME        "PWM1"
+#define MICROPY_HW_PWM2_NAME        "PWM2"
+
+#define HELP_TEXT_BOARD_LED         "1,2,3"
diff --git a/ports/nrf/boards/evk_nina_b1/mpconfigboard.mk b/ports/nrf/boards/evk_nina_b1/mpconfigboard.mk
new file mode 100644
index 0000000000000..db64a60dd3685
--- /dev/null
+++ b/ports/nrf/boards/evk_nina_b1/mpconfigboard.mk
@@ -0,0 +1,7 @@
+MCU_SERIES = m4
+MCU_VARIANT = nrf52
+MCU_SUB_VARIANT = nrf52832
+SOFTDEV_VERSION = 6.1.1
+LD_FILES += boards/nrf52832_512k_64k.ld
+
+NRF_DEFINES += -DNRF52832_XXAA
diff --git a/ports/nrf/boards/evk_nina_b1/pins.csv b/ports/nrf/boards/evk_nina_b1/pins.csv
new file mode 100644
index 0000000000000..876c7ddc1a904
--- /dev/null
+++ b/ports/nrf/boards/evk_nina_b1/pins.csv
@@ -0,0 +1,41 @@
+A0,P3,ADC0_IN1
+A1,P2,ADC0_IN0
+A2,P4,ADC0_IN2
+A3,P30,ADC0_IN6
+A4,P29,ADC0_IN5
+A5,P28,ADC0_IN4
+LED1,P8
+LED2,P16
+LED3,P18
+SW2,P30
+UART1_RX,P5
+UART1_TX,P6
+UART1_CTS,P7
+UART1_RTS,P8
+SDA,P2
+SCL,P3
+NFC1,P9
+NFC2,P10
+D0,P5
+D1,P6
+D2,P7
+D3,P31
+D4,P18
+D6,P9
+D7,P10
+D9,P8
+D10,P11
+D11,P13
+D12,P12
+D13,P14
+P15,P15
+P17,P17
+P19,P19
+P20,P20
+P21,P21
+P22,P22
+P23,P23
+P24,P24
+P25,P25
+P26,P26
+P27,P27
diff --git a/ports/nrf/boards/feather52/mpconfigboard.h b/ports/nrf/boards/feather52/mpconfigboard.h
index 8ec2b0c9ac601..10e0d999cebcd 100644
--- a/ports/nrf/boards/feather52/mpconfigboard.h
+++ b/ports/nrf/boards/feather52/mpconfigboard.h
@@ -36,7 +36,8 @@
 #define MICROPY_PY_MACHINE_I2C      (1)
 #define MICROPY_PY_MACHINE_ADC      (1)
 #define MICROPY_PY_MACHINE_TEMP     (1)
-#define MICROPY_PY_RANDOM_HW_RNG    (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
 
 #define MICROPY_HW_HAS_LED          (1)
 #define MICROPY_HW_LED_COUNT        (2)
diff --git a/ports/nrf/boards/ibk_blyst_nano/mpconfigboard.h b/ports/nrf/boards/ibk_blyst_nano/mpconfigboard.h
new file mode 100644
index 0000000000000..4897471ea56ce
--- /dev/null
+++ b/ports/nrf/boards/ibk_blyst_nano/mpconfigboard.h
@@ -0,0 +1,70 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 I-SYST inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#define MICROPY_HW_BOARD_NAME       "IBK-BLYST-NANO"
+#define MICROPY_HW_MCU_NAME         "NRF52832"
+#define MICROPY_PY_SYS_PLATFORM     "BLYST Nano"
+
+#define MICROPY_PY_MACHINE_SOFT_PWM (1)
+#define MICROPY_PY_MUSIC            (1)
+
+#define MICROPY_PY_MACHINE_UART     (1)
+#define MICROPY_PY_MACHINE_HW_PWM   (1)
+#define MICROPY_PY_MACHINE_HW_SPI   (1)
+#define MICROPY_PY_MACHINE_TIMER    (1)
+#define MICROPY_PY_MACHINE_RTCOUNTER (1)
+#define MICROPY_PY_MACHINE_I2C      (1)
+#define MICROPY_PY_MACHINE_ADC      (1)
+#define MICROPY_PY_MACHINE_TEMP     (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
+
+#define MICROPY_HW_HAS_LED          (1)
+#define MICROPY_HW_LED_COUNT        (3)
+#define MICROPY_HW_LED_PULLUP       (1)
+
+#define MICROPY_HW_LED1             (30) // LED1
+#define MICROPY_HW_LED2             (29) // LED2
+#define MICROPY_HW_LED3             (28) // LED3
+
+// UART config
+#define MICROPY_HW_UART1_RX         (8)
+#define MICROPY_HW_UART1_TX         (7)
+#define MICROPY_HW_UART1_CTS        (12)
+#define MICROPY_HW_UART1_RTS        (11)
+#define MICROPY_HW_UART1_HWFC       (1)
+
+// SPI0 config
+#define MICROPY_HW_SPI0_NAME        "SPI0"
+#define MICROPY_HW_SPI0_SCK         (23) //
+#define MICROPY_HW_SPI0_MOSI        (24) //
+#define MICROPY_HW_SPI0_MISO        (25) //
+
+#define MICROPY_HW_PWM0_NAME        "PWM0"
+#define MICROPY_HW_PWM1_NAME        "PWM1"
+#define MICROPY_HW_PWM2_NAME        "PWM2"
+
+#define HELP_TEXT_BOARD_LED         "1,2,3"
diff --git a/ports/nrf/boards/ibk_blyst_nano/mpconfigboard.mk b/ports/nrf/boards/ibk_blyst_nano/mpconfigboard.mk
new file mode 100644
index 0000000000000..02a3177446b10
--- /dev/null
+++ b/ports/nrf/boards/ibk_blyst_nano/mpconfigboard.mk
@@ -0,0 +1,8 @@
+MCU_SERIES = m4
+MCU_VARIANT = nrf52
+MCU_SUB_VARIANT = nrf52832
+SOFTDEV_VERSION = 6.1.1
+LD_FILES += boards/nrf52832_512k_64k.ld
+FLASHER = idap
+
+NRF_DEFINES += -DNRF52832_XXAA
diff --git a/ports/nrf/boards/ibk_blyst_nano/pins.csv b/ports/nrf/boards/ibk_blyst_nano/pins.csv
new file mode 100644
index 0000000000000..90bf84a04d44a
--- /dev/null
+++ b/ports/nrf/boards/ibk_blyst_nano/pins.csv
@@ -0,0 +1,30 @@
+P2,P2
+P3,P3
+P4,P4
+P5,P5
+P6,P6
+P7,P7
+P8,P8
+P9,P9
+P10,P10
+P11,P11
+P12,P12
+P13,P13
+P14,P14
+P15,P15
+P16,P16
+P17,P17
+P18,P18
+P19,P19
+P20,P20
+P21,P21
+P22,P22
+P23,P23
+P24,P24
+P25,P25
+P26,P26
+P27,P27
+P28,P28
+P29,P29
+P30,P30
+P31,P31
diff --git a/ports/nrf/boards/idk_blyst_nano/mpconfigboard.h b/ports/nrf/boards/idk_blyst_nano/mpconfigboard.h
new file mode 100644
index 0000000000000..06c16477387c7
--- /dev/null
+++ b/ports/nrf/boards/idk_blyst_nano/mpconfigboard.h
@@ -0,0 +1,71 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 I-SYST inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#define MICROPY_HW_BOARD_NAME       "IDK-BLYST-NANO"
+#define MICROPY_HW_MCU_NAME         "NRF52832"
+#define MICROPY_PY_SYS_PLATFORM     "BLYST Nano"
+
+#define MICROPY_PY_MACHINE_SOFT_PWM (1)
+#define MICROPY_PY_MUSIC            (1)
+
+#define MICROPY_PY_MACHINE_UART     (1)
+#define MICROPY_PY_MACHINE_HW_PWM   (1)
+#define MICROPY_PY_MACHINE_HW_SPI   (1)
+#define MICROPY_PY_MACHINE_TIMER    (1)
+#define MICROPY_PY_MACHINE_RTCOUNTER (1)
+#define MICROPY_PY_MACHINE_I2C      (1)
+#define MICROPY_PY_MACHINE_ADC      (1)
+#define MICROPY_PY_MACHINE_TEMP     (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
+
+#define MICROPY_HW_HAS_LED          (1)
+#define MICROPY_HW_LED_COUNT        (4)
+#define MICROPY_HW_LED_PULLUP       (1)
+
+#define MICROPY_HW_LED1             (30) // LED1
+#define MICROPY_HW_LED2             (29) // LED2
+#define MICROPY_HW_LED3             (28) // LED3
+#define MICROPY_HW_LED4             (27) // LED4
+
+// UART config
+#define MICROPY_HW_UART1_RX         (8)
+#define MICROPY_HW_UART1_TX         (7)
+#define MICROPY_HW_UART1_CTS        (12)
+#define MICROPY_HW_UART1_RTS        (11)
+#define MICROPY_HW_UART1_HWFC       (1)
+
+// SPI0 config
+#define MICROPY_HW_SPI0_NAME        "SPI0"
+#define MICROPY_HW_SPI0_SCK         (23) //
+#define MICROPY_HW_SPI0_MOSI        (24) //
+#define MICROPY_HW_SPI0_MISO        (25) //
+
+#define MICROPY_HW_PWM0_NAME        "PWM0"
+#define MICROPY_HW_PWM1_NAME        "PWM1"
+#define MICROPY_HW_PWM2_NAME        "PWM2"
+
+#define HELP_TEXT_BOARD_LED         "1,2,3,4"
diff --git a/ports/nrf/boards/idk_blyst_nano/mpconfigboard.mk b/ports/nrf/boards/idk_blyst_nano/mpconfigboard.mk
new file mode 100644
index 0000000000000..02a3177446b10
--- /dev/null
+++ b/ports/nrf/boards/idk_blyst_nano/mpconfigboard.mk
@@ -0,0 +1,8 @@
+MCU_SERIES = m4
+MCU_VARIANT = nrf52
+MCU_SUB_VARIANT = nrf52832
+SOFTDEV_VERSION = 6.1.1
+LD_FILES += boards/nrf52832_512k_64k.ld
+FLASHER = idap
+
+NRF_DEFINES += -DNRF52832_XXAA
diff --git a/ports/nrf/boards/idk_blyst_nano/pins.csv b/ports/nrf/boards/idk_blyst_nano/pins.csv
new file mode 100644
index 0000000000000..90bf84a04d44a
--- /dev/null
+++ b/ports/nrf/boards/idk_blyst_nano/pins.csv
@@ -0,0 +1,30 @@
+P2,P2
+P3,P3
+P4,P4
+P5,P5
+P6,P6
+P7,P7
+P8,P8
+P9,P9
+P10,P10
+P11,P11
+P12,P12
+P13,P13
+P14,P14
+P15,P15
+P16,P16
+P17,P17
+P18,P18
+P19,P19
+P20,P20
+P21,P21
+P22,P22
+P23,P23
+P24,P24
+P25,P25
+P26,P26
+P27,P27
+P28,P28
+P29,P29
+P30,P30
+P31,P31
diff --git a/ports/nrf/boards/make-pins.py b/ports/nrf/boards/make-pins.py
index 023b2161c8f0a..56c56ae5f42f3 100644
--- a/ports/nrf/boards/make-pins.py
+++ b/ports/nrf/boards/make-pins.py
@@ -7,27 +7,27 @@
 import sys
 import csv
 
-SUPPORTED_FN = {
-    'UART'  : ['RX', 'TX', 'CTS', 'RTS']
-}
+SUPPORTED_FN = {"UART": ["RX", "TX", "CTS", "RTS"]}
+
 
 def parse_pin(name_str):
     """Parses a string and returns a pin-num."""
     if len(name_str) < 1:
         raise ValueError("Expecting pin name to be at least 4 charcters.")
-    if name_str[0] != 'P':
+    if name_str[0] != "P":
         raise ValueError("Expecting pin name to start with P")
-    pin_str = name_str[1:].split('/')[0]
+    pin_str = name_str[1:].split("/")[0]
     if not pin_str.isdigit():
         raise ValueError("Expecting numeric pin number.")
     return int(pin_str)
 
+
 def split_name_num(name_num):
     num = None
     for num_idx in range(len(name_num) - 1, -1, -1):
         if not name_num[num_idx].isdigit():
-            name = name_num[0:num_idx + 1]
-            num_str = name_num[num_idx + 1:]
+            name = name_num[0 : num_idx + 1]
+            num_str = name_num[num_idx + 1 :]
             if len(num_str) > 0:
                 num = int(num_str)
             break
@@ -41,12 +41,12 @@ def __init__(self, idx, af_str):
         self.idx = idx
         self.af_str = af_str
 
-        self.func = ''
+        self.func = ""
         self.fn_num = None
-        self.pin_type = ''
+        self.pin_type = ""
         self.supported = False
 
-        af_words = af_str.split('_', 1)
+        af_words = af_str.split("_", 1)
         self.func, self.fn_num = split_name_num(af_words[0])
         if len(af_words) > 1:
             self.pin_type = af_words[1]
@@ -62,22 +62,25 @@ def ptr(self):
         """Returns the numbered function (i.e. USART6) for this AF."""
         if self.fn_num is None:
             return self.func
-        return '{:s}{:d}'.format(self.func, self.fn_num)
+        return "{:s}{:d}".format(self.func, self.fn_num)
 
     def mux_name(self):
-        return 'AF{:d}_{:s}'.format(self.idx, self.ptr())
+        return "AF{:d}_{:s}".format(self.idx, self.ptr())
 
     def print(self):
         """Prints the C representation of this AF."""
         if self.supported:
-            print('  AF',  end='')
+            print("  AF", end="")
         else:
-            print('  //', end='')
+            print("  //", end="")
         fn_num = self.fn_num
         if fn_num is None:
             fn_num = 0
-        print('({:2d}, {:8s}, {:2d}, {:10s}, {:8s}), // {:s}'.format(self.idx,
-              self.func, fn_num, self.pin_type, self.ptr(), self.af_str))
+        print(
+            "({:2d}, {:8s}, {:2d}, {:10s}, {:8s}), // {:s}".format(
+                self.idx, self.func, fn_num, self.pin_type, self.ptr(), self.af_str
+            )
+        )
 
     def qstr_list(self):
         return [self.mux_name()]
@@ -93,9 +96,10 @@ def __init__(self, pin):
         self.adc_num = 0
         self.adc_channel = 0
         self.board_pin = False
+        self.board_index = None
 
     def cpu_pin_name(self):
-        return '{:s}{:d}'.format("P", self.pin)
+        return "{:s}{:d}".format("P", self.pin)
 
     def is_board_pin(self):
         return self.board_pin
@@ -103,10 +107,13 @@ def is_board_pin(self):
     def set_is_board_pin(self):
         self.board_pin = True
 
+    def set_board_index(self, index):
+        self.board_index = index
+
     def parse_adc(self, adc_str):
-        if (adc_str[:3] != 'ADC'):
+        if adc_str[:3] != "ADC":
             return
-        (adc,channel) = adc_str.split('_')
+        (adc, channel) = adc_str.split("_")
         for idx in range(3, len(adc)):
             self.adc_num = int(adc[idx])
         self.adc_channel = int(channel[2:])
@@ -116,7 +123,7 @@ def parse_af(self, af_idx, af_strs_in):
             return
         # If there is a slash, then the slash separates 2 aliases for the
         # same alternate function.
-        af_strs = af_strs_in.split('/')
+        af_strs = af_strs_in.split("/")
         for af_str in af_strs:
             alt_fn = AlternateFunction(af_idx, af_str)
             self.alt_fn.append(alt_fn)
@@ -125,49 +132,55 @@ def parse_af(self, af_idx, af_strs_in):
 
     def alt_fn_name(self, null_if_0=False):
         if null_if_0 and self.alt_fn_count == 0:
-            return 'NULL'
-        return 'pin_{:s}_af'.format(self.cpu_pin_name())
+            return "NULL"
+        return "pin_{:s}_af".format(self.cpu_pin_name())
 
     def adc_num_str(self):
-        str = ''
-        for adc_num in range(1,4):
+        str = ""
+        for adc_num in range(1, 4):
             if self.adc_num & (1 << (adc_num - 1)):
                 if len(str) > 0:
-                    str += ' | '
-                str += 'PIN_ADC'
-                str += chr(ord('0') + adc_num)
+                    str += " | "
+                str += "PIN_ADC"
+                str += chr(ord("0") + adc_num)
         if len(str) == 0:
-            str = '0'
+            str = "0"
         return str
 
     def print_const_table_entry(self):
-        print('  PIN({:d}, {:s}, {:s}, {:d}),'.format(
-            self.pin,
-            self.alt_fn_name(null_if_0=True),
-            self.adc_num_str(), self.adc_channel))
+        print(
+            "  PIN({:d}, {:s}, {:s}, {:d}),".format(
+                self.pin, self.alt_fn_name(null_if_0=True), self.adc_num_str(), self.adc_channel
+            )
+        )
 
     def print(self):
         if self.alt_fn_count == 0:
-            print("// ",  end='')
-        print('const pin_af_obj_t {:s}[] = {{'.format(self.alt_fn_name()))
+            print("// ", end="")
+        print("const pin_af_obj_t {:s}[] = {{".format(self.alt_fn_name()))
         for alt_fn in self.alt_fn:
             alt_fn.print()
         if self.alt_fn_count == 0:
-            print("// ",  end='')
-        print('};')
-        print('')
-        print('const pin_obj_t pin_{:s} = PIN({:d}, {:s}, {:s}, {:d});'.format(
-            self.cpu_pin_name(), self.pin,
-            self.alt_fn_name(null_if_0=True),
-            self.adc_num_str(), self.adc_channel))
-        print('')
+            print("// ", end="")
+        print("};")
+        print("")
+        print(
+            "const pin_obj_t pin_{:s} = PIN({:d}, {:s}, {:s}, {:d});".format(
+                self.cpu_pin_name(),
+                self.pin,
+                self.alt_fn_name(null_if_0=True),
+                self.adc_num_str(),
+                self.adc_channel,
+            )
+        )
+        print("")
 
     def print_header(self, hdr_file):
-        hdr_file.write('extern const pin_obj_t pin_{:s};\n'.
-                       format(self.cpu_pin_name()))
+        hdr_file.write("extern const pin_obj_t pin_{:s};\n".format(self.cpu_pin_name()))
         if self.alt_fn_count > 0:
-            hdr_file.write('extern const pin_af_obj_t pin_{:s}_af[];\n'.
-                           format(self.cpu_pin_name()))
+            hdr_file.write(
+                "extern const pin_af_obj_t pin_{:s}_af[];\n".format(self.cpu_pin_name())
+            )
 
     def qstr_list(self):
         result = []
@@ -178,7 +191,6 @@ def qstr_list(self):
 
 
 class NamedPin(object):
-
     def __init__(self, name, pin):
         self._name = name
         self._pin = pin
@@ -191,10 +203,9 @@ def name(self):
 
 
 class Pins(object):
-
     def __init__(self):
-        self.cpu_pins = []   # list of NamedPin objects
-        self.board_pins = [] # list of NamedPin objects
+        self.cpu_pins = []  # list of NamedPin objects
+        self.board_pins = []  # list of NamedPin objects
 
     def find_pin(self, pin_num):
         for named_pin in self.cpu_pins:
@@ -203,7 +214,7 @@ def find_pin(self, pin_num):
                 return pin
 
     def parse_af_file(self, filename, pinname_col, af_col, af_col_end):
-        with open(filename, 'r') as csvfile:
+        with open(filename, "r") as csvfile:
             rows = csv.reader(csvfile)
             for row in rows:
                 try:
@@ -219,7 +230,7 @@ def parse_af_file(self, filename, pinname_col, af_col, af_col_end):
                 self.cpu_pins.append(NamedPin(pin.cpu_pin_name(), pin))
 
     def parse_board_file(self, filename):
-        with open(filename, 'r') as csvfile:
+        with open(filename, "r") as csvfile:
             rows = csv.reader(csvfile)
             for row in rows:
                 try:
@@ -232,61 +243,77 @@ def parse_board_file(self, filename):
                     self.board_pins.append(NamedPin(row[0], pin))
 
     def print_named(self, label, named_pins):
-        print('STATIC const mp_rom_map_elem_t pin_{:s}_pins_locals_dict_table[] = {{'.format(label))
-        index = 0
+        print(
+            "STATIC const mp_rom_map_elem_t pin_{:s}_pins_locals_dict_table[] = {{".format(label)
+        )
         for named_pin in named_pins:
             pin = named_pin.pin()
             if pin.is_board_pin():
-                print('  {{ MP_ROM_QSTR(MP_QSTR_{:s}), MP_ROM_PTR(&machine_pin_obj[{:d}]) }},'.format(named_pin.name(), index))
-                index += 1
-        print('};')
-        print('MP_DEFINE_CONST_DICT(pin_{:s}_pins_locals_dict, pin_{:s}_pins_locals_dict_table);'.format(label, label));
+                print(
+                    "  {{ MP_ROM_QSTR(MP_QSTR_{:s}), MP_ROM_PTR(&machine_board_pin_obj[{:d}]) }},".format(
+                        named_pin.name(), pin.board_index
+                    )
+                )
+        print("};")
+        print(
+            "MP_DEFINE_CONST_DICT(pin_{:s}_pins_locals_dict, pin_{:s}_pins_locals_dict_table);".format(
+                label, label
+            )
+        )
 
     def print_const_table(self):
-        print('')
-        print('const uint8_t machine_pin_num_of_pins = {:d};'.format(len(self.board_pins)))
-        print('')
-        print('const pin_obj_t machine_pin_obj[{:d}] = {{'.format(len(self.board_pins)))
+        num_board_pins = 0
+        for named_pin in self.cpu_pins:
+            pin = named_pin.pin()
+            if pin.is_board_pin():
+                pin.set_board_index(num_board_pins)
+                num_board_pins += 1
+        print("")
+        print("const uint8_t machine_pin_num_of_board_pins = {:d};".format(num_board_pins))
+        print("")
+        print("const pin_obj_t machine_board_pin_obj[{:d}] = {{".format(num_board_pins))
         for named_pin in self.cpu_pins:
             pin = named_pin.pin()
             if pin.is_board_pin():
                 pin.print_const_table_entry()
-        print('};');
+        print("};")
 
     def print(self):
-        self.print_named('cpu', self.cpu_pins)
-        print('')
-        self.print_named('board', self.board_pins)
+        self.print_named("cpu", self.cpu_pins)
+        print("")
+        self.print_named("board", self.board_pins)
 
     def print_adc(self, adc_num):
-        print('');
-        print('const pin_obj_t * const pin_adc{:d}[] = {{'.format(adc_num))
+        print("")
+        print("const pin_obj_t * const pin_adc{:d}[] = {{".format(adc_num))
         for channel in range(16):
             adc_found = False
             for named_pin in self.cpu_pins:
                 pin = named_pin.pin()
-                if (pin.is_board_pin() and
-                    (pin.adc_num & (1 << (adc_num - 1))) and (pin.adc_channel == channel)):
-                    print('  &pin_{:s}, // {:d}'.format(pin.cpu_pin_name(), channel))
+                if (
+                    pin.is_board_pin()
+                    and (pin.adc_num & (1 << (adc_num - 1)))
+                    and (pin.adc_channel == channel)
+                ):
+                    print("  &pin_{:s}, // {:d}".format(pin.cpu_pin_name(), channel))
                     adc_found = True
                     break
             if not adc_found:
-                print('  NULL,    // {:d}'.format(channel))
-        print('};')
-
+                print("  NULL,    // {:d}".format(channel))
+        print("};")
 
     def print_header(self, hdr_filename):
-        with open(hdr_filename, 'wt') as hdr_file:
+        with open(hdr_filename, "wt") as hdr_file:
             for named_pin in self.cpu_pins:
                 pin = named_pin.pin()
                 if pin.is_board_pin():
                     pin.print_header(hdr_file)
-            hdr_file.write('extern const pin_obj_t * const pin_adc1[];\n')
-            hdr_file.write('extern const pin_obj_t * const pin_adc2[];\n')
-            hdr_file.write('extern const pin_obj_t * const pin_adc3[];\n')
+            hdr_file.write("extern const pin_obj_t * const pin_adc1[];\n")
+            hdr_file.write("extern const pin_obj_t * const pin_adc2[];\n")
+            hdr_file.write("extern const pin_obj_t * const pin_adc3[];\n")
 
     def print_qstr(self, qstr_filename):
-        with open(qstr_filename, 'wt') as qstr_file:
+        with open(qstr_filename, "wt") as qstr_file:
             qstr_set = set([])
             for named_pin in self.cpu_pins:
                 pin = named_pin.pin()
@@ -296,11 +323,10 @@ def print_qstr(self, qstr_filename):
             for named_pin in self.board_pins:
                 qstr_set |= set([named_pin.name()])
             for qstr in sorted(qstr_set):
-                print('Q({})'.format(qstr), file=qstr_file)
-
+                print("Q({})".format(qstr), file=qstr_file)
 
     def print_af_hdr(self, af_const_filename):
-        with open(af_const_filename,  'wt') as af_const_file:
+        with open(af_const_filename, "wt") as af_const_file:
             af_hdr_set = set([])
             mux_name_width = 0
             for named_pin in self.cpu_pins:
@@ -313,88 +339,89 @@ def print_af_hdr(self, af_const_filename):
                             if len(mux_name) > mux_name_width:
                                 mux_name_width = len(mux_name)
             for mux_name in sorted(af_hdr_set):
-                key = 'MP_ROM_QSTR(MP_QSTR_{}),'.format(mux_name)
-                val = 'MP_ROM_INT(GPIO_{})'.format(mux_name)
-                print('    { %-*s %s },' % (mux_name_width + 26, key, val),
-                      file=af_const_file)
+                key = "MP_ROM_QSTR(MP_QSTR_{}),".format(mux_name)
+                val = "MP_ROM_INT(GPIO_{})".format(mux_name)
+                print("    { %-*s %s }," % (mux_name_width + 26, key, val), file=af_const_file)
 
     def print_af_py(self, af_py_filename):
-        with open(af_py_filename,  'wt') as af_py_file:
-            print('PINS_AF = (', file=af_py_file);
+        with open(af_py_filename, "wt") as af_py_file:
+            print("PINS_AF = (", file=af_py_file)
             for named_pin in self.board_pins:
-                print("  ('%s', " % named_pin.name(), end='', file=af_py_file)
+                print("  ('%s', " % named_pin.name(), end="", file=af_py_file)
                 for af in named_pin.pin().alt_fn:
                     if af.is_supported():
-                        print("(%d, '%s'), " % (af.idx, af.af_str), end='', file=af_py_file)
-                print('),', file=af_py_file)
-            print(')',  file=af_py_file)
+                        print("(%d, '%s'), " % (af.idx, af.af_str), end="", file=af_py_file)
+                print("),", file=af_py_file)
+            print(")", file=af_py_file)
 
 
 def main():
     parser = argparse.ArgumentParser(
         prog="make-pins.py",
         usage="%(prog)s [options] [command]",
-        description="Generate board specific pin file"
+        description="Generate board specific pin file",
     )
     parser.add_argument(
-        "-a", "--af",
+        "-a",
+        "--af",
         dest="af_filename",
         help="Specifies the alternate function file for the chip",
-        default="nrf.csv"
+        default="nrf.csv",
     )
     parser.add_argument(
         "--af-const",
         dest="af_const_filename",
         help="Specifies header file for alternate function constants.",
-        default="build/pins_af_const.h"
+        default="build/pins_af_const.h",
     )
     parser.add_argument(
         "--af-py",
         dest="af_py_filename",
         help="Specifies the filename for the python alternate function mappings.",
-        default="build/pins_af.py"
+        default="build/pins_af.py",
     )
     parser.add_argument(
-        "-b", "--board",
-        dest="board_filename",
-        help="Specifies the board file",
+        "-b", "--board", dest="board_filename", help="Specifies the board file",
     )
     parser.add_argument(
-        "-p", "--prefix",
+        "-p",
+        "--prefix",
         dest="prefix_filename",
         help="Specifies beginning portion of generated pins file",
-        default="nrf52_prefix.c"
+        default="nrf52_prefix.c",
     )
     parser.add_argument(
-        "-q", "--qstr",
+        "-q",
+        "--qstr",
         dest="qstr_filename",
         help="Specifies name of generated qstr header file",
-        default="build/pins_qstr.h"
+        default="build/pins_qstr.h",
     )
     parser.add_argument(
-        "-r", "--hdr",
+        "-r",
+        "--hdr",
         dest="hdr_filename",
         help="Specifies name of generated pin header file",
-        default="build/pins.h"
+        default="build/pins.h",
     )
     args = parser.parse_args(sys.argv[1:])
 
     pins = Pins()
 
-    print('// This file was automatically generated by make-pins.py')
-    print('//')
+    print("// This file was automatically generated by make-pins.py")
+    print("//")
     if args.af_filename:
-        print('// --af {:s}'.format(args.af_filename))
+        print("// --af {:s}".format(args.af_filename))
         pins.parse_af_file(args.af_filename, 1, 2, 2)
 
     if args.board_filename:
-        print('// --board {:s}'.format(args.board_filename))
+        print("// --board {:s}".format(args.board_filename))
         pins.parse_board_file(args.board_filename)
 
     if args.prefix_filename:
-        print('// --prefix {:s}'.format(args.prefix_filename))
-        print('')
-        with open(args.prefix_filename, 'r') as prefix_file:
+        print("// --prefix {:s}".format(args.prefix_filename))
+        print("")
+        with open(args.prefix_filename, "r") as prefix_file:
             print(prefix_file.read())
 
     pins.print_const_table()
diff --git a/ports/nrf/boards/microbit/modules/microbitdisplay.c b/ports/nrf/boards/microbit/modules/microbitdisplay.c
index 11ec004d073f7..979a4ddd08b63 100644
--- a/ports/nrf/boards/microbit/modules/microbitdisplay.c
+++ b/ports/nrf/boards/microbit/modules/microbitdisplay.c
@@ -90,7 +90,7 @@ mp_obj_t microbit_display_show_func(mp_uint_t n_args, const mp_obj_t *pos_args,
 
     if (mp_obj_is_str(image)) {
         // arg is a string object
-        mp_uint_t len;
+        size_t len;
         const char *str = mp_obj_str_get_data(image, &len);
         if (len == 0) {
             // There are no chars; do nothing.
@@ -256,15 +256,15 @@ static const uint16_t render_timings[] =
 // The scale is (approximately) exponential,
 // each step is approx x1.9 greater than the previous.
 {   0, // Bright, Ticks Duration, Relative power
-    2,   //   1,   2,     32µs,     inf
-    2,   //   2,   4,     64µs,     200%
-    4,   //   3,   8,     128µs,    200%
-    7,   //   4,   15,    240µs,    187%
-    13,  //   5,   28,    448µs,    187%
-    25,  //   6,   53,    848µs,    189%
-    49,  //   7,   102,   1632µs,   192%
-    97,  //   8,   199,   3184µs,   195%
-// Always on  9,   375,   6000µs,   188%
+    2,   //   1,   2,     32us,     inf
+    2,   //   2,   4,     64us,     200%
+    4,   //   3,   8,     128us,    200%
+    7,   //   4,   15,    240us,    187%
+    13,  //   5,   28,    448us,    187%
+    25,  //   6,   53,    848us,    189%
+    49,  //   7,   102,   1632us,   192%
+    97,  //   8,   199,   3184us,   195%
+// Always on  9,   375,   6000us,   188%
 };
 
 #define DISPLAY_TICKER_SLOT 1
@@ -281,7 +281,7 @@ static int32_t callback(void) {
         return -1;
     }
     display->previous_brightness = brightness;
-    // Return interval (in 16µs ticks) until next callback
+    // Return interval (in 16us ticks) until next callback
     return render_timings[brightness];
 }
 
@@ -297,7 +297,7 @@ static void draw_object(mp_obj_t obj) {
     } else if (mp_obj_get_type(obj) == &microbit_image_type) {
         microbit_display_show(display, (microbit_image_obj_t *)obj);
     } else if (mp_obj_is_str(obj)) {
-        mp_uint_t len;
+        size_t len;
         const char *str = mp_obj_str_get_data(obj, &len);
         if (len == 1) {
             microbit_display_show(display, microbit_image_for_char(str[0]));
@@ -305,7 +305,7 @@ static void draw_object(mp_obj_t obj) {
             async_stop();
         }
     } else {
-        MP_STATE_VM(mp_pending_exception) = mp_obj_new_exception_msg(&mp_type_TypeError, "not an image.");
+        MP_STATE_VM(mp_pending_exception) = mp_obj_new_exception_msg(&mp_type_TypeError, MP_ERROR_TEXT("not an image."));
         async_stop();
     }
 }
@@ -415,7 +415,7 @@ mp_obj_t microbit_display_scroll_func(mp_uint_t n_args, const mp_obj_t *pos_args
     microbit_display_obj_t *self = (microbit_display_obj_t*)pos_args[0];
     mp_arg_val_t args[MP_ARRAY_SIZE(scroll_allowed_args)];
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(scroll_allowed_args), scroll_allowed_args, args);
-    mp_uint_t len;
+    size_t len;
     const char* str = mp_obj_str_get_data(args[0].u_obj, &len);
     mp_obj_t iterable = scrolling_string_image_iterable(str, len, args[0].u_obj, args[3].u_bool /*monospace?*/, args[4].u_bool /*loop*/);
     microbit_display_animate(self, iterable, args[1].u_int /*delay*/, false/*clear*/, args[2].u_bool/*wait?*/);
@@ -499,10 +499,10 @@ MP_DEFINE_CONST_FUN_OBJ_1(microbit_display_clear_obj, microbit_display_clear_fun
 
 void microbit_display_set_pixel(microbit_display_obj_t *display, mp_int_t x, mp_int_t y, mp_int_t bright) {
     if (x < 0 || y < 0 || x > 4 || y > 4) {
-        mp_raise_ValueError("index out of bounds.");
+        mp_raise_ValueError(MP_ERROR_TEXT("index out of bounds."));
     }
     if (bright < 0 || bright > MAX_BRIGHTNESS) {
-        mp_raise_ValueError("brightness out of bounds.");
+        mp_raise_ValueError(MP_ERROR_TEXT("brightness out of bounds."));
     }
     display->image_buffer[x][y] = bright;
     display->brightnesses |= (1 << bright);
@@ -518,7 +518,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(microbit_display_set_pixel_obj, 4, 4, microb
 
 mp_int_t microbit_display_get_pixel(microbit_display_obj_t *display, mp_int_t x, mp_int_t y) {
     if (x < 0 || y < 0 || x > 4 || y > 4) {
-        mp_raise_ValueError("index out of bounds.");
+        mp_raise_ValueError(MP_ERROR_TEXT("index out of bounds."));
     }
     return display->image_buffer[x][y];
 }
diff --git a/ports/nrf/boards/microbit/modules/microbitimage.c b/ports/nrf/boards/microbit/modules/microbitimage.c
index aa519b4a2a361..d697a9081f9aa 100644
--- a/ports/nrf/boards/microbit/modules/microbitimage.c
+++ b/ports/nrf/boards/microbit/modules/microbitimage.c
@@ -62,7 +62,7 @@ STATIC void microbit_image_print(const mp_print_t *print, mp_obj_t self_in, mp_p
 
 uint8_t monochromeGetPixelValue(monochrome_5by5_t * p_mono, mp_int_t x, mp_int_t y) {
     unsigned int index = y*5+x;
-    if (index == 24) 
+    if (index == 24)
         return p_mono->pixel44;
     return (p_mono->bits24[index>>3] >> (index&7))&1;
 }
@@ -162,7 +162,7 @@ STATIC microbit_image_obj_t *image_from_parsed_str(const char *s, mp_int_t len)
         } else if ('c' >= '0' && c <= '9') {
             ++line_len;
         } else {
-            mp_raise_ValueError("Unexpected character in Image definition.");
+            mp_raise_ValueError(MP_ERROR_TEXT("Unexpected character in Image definition."));
         }
     }
     if (line_len) {
@@ -216,7 +216,7 @@ STATIC mp_obj_t microbit_image_make_new(const mp_obj_type_t *type_in, mp_uint_t
         case 1: {
             if (mp_obj_is_str(args[0])) {
                 // arg is a string object
-                mp_uint_t len;
+                size_t len;
                 const char *str = mp_obj_str_get_data(args[0], &len);
                 // make image from string
                 if (len == 1) {
@@ -227,8 +227,7 @@ STATIC mp_obj_t microbit_image_make_new(const mp_obj_type_t *type_in, mp_uint_t
                     return image_from_parsed_str(str, len);
                 }
             } else {
-                nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError,
-                    "Image(s) takes a string."));
+                mp_raise_TypeError(MP_ERROR_TEXT("Image(s) takes a string."));
             }
         }
 
@@ -244,7 +243,7 @@ STATIC mp_obj_t microbit_image_make_new(const mp_obj_type_t *type_in, mp_uint_t
                 mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_READ);
 
                 if (w < 0 || h < 0 || (size_t)(w * h) != bufinfo.len) {
-                    mp_raise_ValueError("image data is incorrect size");
+                    mp_raise_ValueError(MP_ERROR_TEXT("image data is incorrect size"));
                 }
                 mp_int_t i = 0;
                 for (mp_int_t y = 0; y < h; y++) {
@@ -259,8 +258,7 @@ STATIC mp_obj_t microbit_image_make_new(const mp_obj_type_t *type_in, mp_uint_t
         }
 
         default: {
-            nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError,
-                "Image() takes 0 to 3 arguments"));
+            mp_raise_TypeError(MP_ERROR_TEXT("Image() takes 0 to 3 arguments"));
         }
     }
 }
@@ -353,19 +351,19 @@ mp_obj_t microbit_image_get_pixel(mp_obj_t self_in, mp_obj_t x_in, mp_obj_t y_in
     mp_int_t x = mp_obj_get_int(x_in);
     mp_int_t y = mp_obj_get_int(y_in);
     if (x < 0 || y < 0) {
-        mp_raise_ValueError("index cannot be negative");
+        mp_raise_ValueError(MP_ERROR_TEXT("index can't be negative"));
     }
     if (x < imageWidth(self) && y < imageHeight(self)) {
         return MP_OBJ_NEW_SMALL_INT(imageGetPixelValue(self, x, y));
     }
-    mp_raise_ValueError("index too large");
+    mp_raise_ValueError(MP_ERROR_TEXT("index too large"));
 }
 MP_DEFINE_CONST_FUN_OBJ_3(microbit_image_get_pixel_obj, microbit_image_get_pixel);
 
 /* Raise an exception if not mutable */
 static void check_mutability(microbit_image_obj_t *self) {
     if (self->base.five) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "image cannot be modified (try copying first)"));
+        mp_raise_TypeError(MP_ERROR_TEXT("image can't be modified (try copying first)"));
     }
 }
 
@@ -377,16 +375,16 @@ mp_obj_t microbit_image_set_pixel(mp_uint_t n_args, const mp_obj_t *args) {
     mp_int_t x = mp_obj_get_int(args[1]);
     mp_int_t y = mp_obj_get_int(args[2]);
     if (x < 0 || y < 0) {
-        mp_raise_ValueError("index cannot be negative");
+        mp_raise_ValueError(MP_ERROR_TEXT("index can't be negative"));
     }
     mp_int_t bright = mp_obj_get_int(args[3]);
-    if (bright < 0 || bright > MAX_BRIGHTNESS) 
-        mp_raise_ValueError("brightness out of bounds.");
+    if (bright < 0 || bright > MAX_BRIGHTNESS)
+        mp_raise_ValueError(MP_ERROR_TEXT("brightness out of bounds."));
     if (x < imageWidth(self) && y < imageHeight(self)) {
         greyscaleSetPixelValue(&(self->greyscale), x, y, bright);
         return mp_const_none;
     }
-    mp_raise_ValueError("index too large");
+    mp_raise_ValueError(MP_ERROR_TEXT("index too large"));
 }
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(microbit_image_set_pixel_obj, 4, 4, microbit_image_set_pixel);
 
@@ -395,7 +393,7 @@ mp_obj_t microbit_image_fill(mp_obj_t self_in, mp_obj_t n_in) {
     check_mutability(self);
     mp_int_t n = mp_obj_get_int(n_in);
     if (n < 0 || n > MAX_BRIGHTNESS) {
-        mp_raise_ValueError("brightness out of bounds.");
+        mp_raise_ValueError(MP_ERROR_TEXT("brightness out of bounds."));
     }
     greyscaleFill(&self->greyscale, n);
     return mp_const_none;
@@ -408,18 +406,17 @@ mp_obj_t microbit_image_blit(mp_uint_t n_args, const mp_obj_t *args) {
 
     mp_obj_t src = args[1];
     if (mp_obj_get_type(src) != &microbit_image_type) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "expecting an image"));
+        mp_raise_TypeError(MP_ERROR_TEXT("expecting an image"));
     }
     if (n_args == 7) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError,
-            "must specify both offsets"));
+        mp_raise_TypeError(MP_ERROR_TEXT("must specify both offsets"));
     }
     mp_int_t x = mp_obj_get_int(args[2]);
     mp_int_t y = mp_obj_get_int(args[3]);
     mp_int_t w = mp_obj_get_int(args[4]);
     mp_int_t h = mp_obj_get_int(args[5]);
     if (w < 0 || h < 0) {
-        mp_raise_ValueError("size cannot be negative");
+        mp_raise_ValueError(MP_ERROR_TEXT("size can't be negative"));
     }
     mp_int_t xdest;
     mp_int_t ydest;
@@ -610,8 +607,8 @@ microbit_image_obj_t *microbit_image_dim(microbit_image_obj_t *lhs, mp_float_t f
 #else
 microbit_image_obj_t *microbit_image_dim(microbit_image_obj_t *lhs, mp_int_t fval) {
 #endif
-    if (fval < 0) 
-        mp_raise_ValueError("Brightness multiplier must not be negative.");
+    if (fval < 0)
+        mp_raise_ValueError(MP_ERROR_TEXT("Brightness multiplier must not be negative."));
     greyscale_t *result = greyscale_new(imageWidth(lhs), imageHeight(lhs));
     for (int x = 0; x < imageWidth(lhs); ++x) {
         for (int y = 0; y < imageWidth(lhs); ++y) {
@@ -631,7 +628,7 @@ microbit_image_obj_t *microbit_image_sum(microbit_image_obj_t *lhs, microbit_ima
     mp_int_t w = imageWidth(lhs);
     if (imageHeight(rhs) != h || imageWidth(lhs) != w) {
 // TODO: verify that image width in test above should really test (lhs != w)
-        mp_raise_ValueError("Images must be the same size.");
+        mp_raise_ValueError(MP_ERROR_TEXT("Images must be the same size."));
     }
     greyscale_t *result = greyscale_new(w, h);
     for (int x = 0; x < w; ++x) {
@@ -639,7 +636,7 @@ microbit_image_obj_t *microbit_image_sum(microbit_image_obj_t *lhs, microbit_ima
             int val;
             int lval = imageGetPixelValue(lhs, x,y);
             int rval = imageGetPixelValue(rhs, x,y);
-            if (add) 
+            if (add)
                 val = min(lval + rval, MAX_BRIGHTNESS);
             else
                 val = max(0, lval - rval);
@@ -647,7 +644,7 @@ microbit_image_obj_t *microbit_image_sum(microbit_image_obj_t *lhs, microbit_ima
         }
     }
     return (microbit_image_obj_t *)result;
-}                      
+}
 
 STATIC mp_obj_t image_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
     if (mp_obj_get_type(lhs_in) != &microbit_image_type) {
@@ -697,9 +694,9 @@ const mp_obj_type_t microbit_image_type = {
     .buffer_p = {NULL},
     .locals_dict = (mp_obj_dict_t*)&microbit_image_locals_dict,
 };
- 
+
 typedef struct _scrolling_string_t {
-    mp_obj_base_t base; 
+    mp_obj_base_t base;
     char const *str;
     mp_uint_t len;
     mp_obj_t ref;
@@ -708,7 +705,7 @@ typedef struct _scrolling_string_t {
 } scrolling_string_t;
 
 typedef struct _scrolling_string_iterator_t {
-    mp_obj_base_t base; 
+    mp_obj_base_t base;
     mp_obj_t ref;
     greyscale_t *img;
     char const *next_char;
@@ -880,7 +877,7 @@ static mp_obj_t string_image_facade_subscr(mp_obj_t self_in, mp_obj_t index_in,
     if (value == MP_OBJ_SENTINEL) {
         // Fill in image
         string_image_facade_t *self = (string_image_facade_t *)self_in;
-        mp_uint_t len;
+        size_t len;
         const char *text = mp_obj_str_get_data(self->string, &len);
         mp_uint_t index = mp_get_index(self->base.type, len, index_in, false);
         microbit_image_set_from_char(self->image, text[index]);
@@ -935,7 +932,7 @@ mp_obj_t microbit_string_facade(mp_obj_t string) {
 
 static mp_obj_t microbit_facade_iter_next(mp_obj_t iter_in) {
     facade_iterator_t *iter = (facade_iterator_t *)iter_in;
-    mp_uint_t len;
+    size_t len;
     const char *text = mp_obj_str_get_data(iter->string, &len);
     if (iter->index >= len) {
         return MP_OBJ_STOP_ITERATION;
@@ -962,7 +959,7 @@ const mp_obj_type_t microbit_facade_iterator_type = {
 };
 
 mp_obj_t microbit_facade_iterator(mp_obj_t iterable_in, mp_obj_iter_buf_t *iter_buf) {
-	(void)iter_buf;
+    (void)iter_buf;
     facade_iterator_t *result = m_new_obj(facade_iterator_t);
     string_image_facade_t *iterable = (string_image_facade_t *)iterable_in;
     result->base.type = &microbit_facade_iterator_type;
diff --git a/ports/nrf/boards/microbit/modules/microbitimage.h b/ports/nrf/boards/microbit/modules/microbitimage.h
index 23edbd6baac2d..41a6aff4ccd14 100644
--- a/ports/nrf/boards/microbit/modules/microbitimage.h
+++ b/ports/nrf/boards/microbit/modules/microbitimage.h
@@ -2,15 +2,15 @@
 #define __MICROPY_INCLUDED_MICROBIT_IMAGE_H__
 
 #include "py/runtime.h"
-   
+
 #define MAX_BRIGHTNESS 9
 
-/** Monochrome images are immutable, which means that 
+/** Monochrome images are immutable, which means that
  * we only need one bit per pixel which saves quite a lot
  * of memory */
 
 /* we reserve a couple of bits, so we won't need to modify the
- * layout if we need to add more functionality or subtypes. */ 
+ * layout if we need to add more functionality or subtypes. */
 #define TYPE_AND_FLAGS \
     mp_obj_base_t base; \
     uint8_t five:1; \
diff --git a/ports/nrf/boards/microbit/modules/modmicrobit.c b/ports/nrf/boards/microbit/modules/modmicrobit.c
index 061e095f6a744..b4cd3b4f185b4 100644
--- a/ports/nrf/boards/microbit/modules/modmicrobit.c
+++ b/ports/nrf/boards/microbit/modules/modmicrobit.c
@@ -31,7 +31,7 @@
 #include "microbitimage.h"
 #include "softpwm.h"
 #include "ticker.h"
-#include "nrf_temp.h"
+#include "modules/machine/temp.h"
 
 extern uint32_t ticks;
 
@@ -96,11 +96,11 @@ STATIC mp_obj_t microbit_panic(mp_uint_t n_args, const mp_obj_t *args) {
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(microbit_panic_obj, 0, 1, microbit_panic);
 
 STATIC mp_obj_t microbit_temperature(void) {
-    int temp = nrf_temp_read();
+    int temp = temp_read();
 #if MICROPY_PY_BUILTINS_FLOAT
-    return mp_obj_new_float(temp / 4);
+    return mp_obj_new_float((mp_float_t)temp / MICROPY_FLOAT_CONST(100.0));
 #else
-    return mp_obj_new_int(temp / 4);
+    return mp_obj_new_int(temp / 100);
 #endif
 }
 MP_DEFINE_CONST_FUN_OBJ_0(microbit_temperature_obj, microbit_temperature);
diff --git a/ports/nrf/boards/microbit/mpconfigboard.h b/ports/nrf/boards/microbit/mpconfigboard.h
index abe138b9cfbee..f05317fb5910d 100644
--- a/ports/nrf/boards/microbit/mpconfigboard.h
+++ b/ports/nrf/boards/microbit/mpconfigboard.h
@@ -37,7 +37,8 @@
 #define MICROPY_PY_MACHINE_I2C      (1)
 #define MICROPY_PY_MACHINE_ADC      (1)
 #define MICROPY_PY_MACHINE_TEMP     (1)
-#define MICROPY_PY_RANDOM_HW_RNG    (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
 
 #define MICROPY_HW_HAS_LED          (0)
 
diff --git a/ports/nrf/boards/nrf9160_1M_256k.ld b/ports/nrf/boards/nrf9160_1M_256k.ld
new file mode 100644
index 0000000000000..6347095a899ce
--- /dev/null
+++ b/ports/nrf/boards/nrf9160_1M_256k.ld
@@ -0,0 +1,13 @@
+/*
+    GNU linker script for NRF9160 NS
+*/
+
+_flash_size = 1M;
+_ram_size   = 256K;
+_sd_size = 0x00008000;
+_sd_ram  = 0x00020000;
+_fs_size = 80K;
+
+/* produce a link error if there is not this amount of RAM for these sections */
+_stack_size = 32K;
+_minimum_heap_size = 64K;
diff --git a/ports/nrf/boards/nrf9160_1M_256k_secure.ld b/ports/nrf/boards/nrf9160_1M_256k_secure.ld
new file mode 100644
index 0000000000000..79db18ab226ca
--- /dev/null
+++ b/ports/nrf/boards/nrf9160_1M_256k_secure.ld
@@ -0,0 +1,6 @@
+/* Specify the memory areas */
+MEMORY
+{
+    FLASH_TEXT (rx) : ORIGIN = 0x00000000,     LENGTH = 32K
+    RAM (xrw)       : ORIGIN = 0x20000000,     LENGTH = 64K
+}
diff --git a/ports/nrf/boards/nrf91_prefix.c b/ports/nrf/boards/nrf91_prefix.c
new file mode 100644
index 0000000000000..d8bb0fc70ba87
--- /dev/null
+++ b/ports/nrf/boards/nrf91_prefix.c
@@ -0,0 +1,29 @@
+// nrf91_prefix.c becomes the initial portion of the generated pins file.
+
+#include <stdio.h>
+
+#include "py/obj.h"
+#include "py/mphal.h"
+#include "pin.h"
+
+#define AF(af_idx, af_fn, af_unit, af_type, af_ptr) \
+{ \
+    { &pin_af_type }, \
+    .name = MP_QSTR_AF ## af_idx ## _ ## af_fn ## af_unit, \
+    .idx = (af_idx), \
+    .fn = AF_FN_ ## af_fn, \
+    .unit = (af_unit), \
+    .type = AF_PIN_TYPE_ ## af_fn ## _ ## af_type, \
+    .af_fn = (af_ptr) \
+}
+
+#define PIN(p_pin, p_af, p_adc_num, p_adc_channel) \
+{ \
+    { &pin_type }, \
+    .name = MP_QSTR_P ## p_pin, \
+    .pin = (p_pin), \
+    .num_af = (sizeof(p_af) / sizeof(pin_af_obj_t)), \
+    .af = p_af, \
+    .adc_num = p_adc_num, \
+    .adc_channel = p_adc_channel, \
+}
diff --git a/ports/nrf/boards/particle_xenon/mpconfigboard.h b/ports/nrf/boards/particle_xenon/mpconfigboard.h
new file mode 100644
index 0000000000000..7c814e377f603
--- /dev/null
+++ b/ports/nrf/boards/particle_xenon/mpconfigboard.h
@@ -0,0 +1,73 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Jim Mussared
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#define MICROPY_HW_BOARD_NAME       "XENON"
+#define MICROPY_HW_MCU_NAME         "NRF52840"
+#define MICROPY_PY_SYS_PLATFORM     "PARTICLE-XENON"
+
+#define MICROPY_PY_MACHINE_UART     (1)
+#define MICROPY_PY_MACHINE_HW_PWM   (1)
+#define MICROPY_PY_MACHINE_HW_SPI   (1)
+#define MICROPY_PY_MACHINE_TIMER    (1)
+#define MICROPY_PY_MACHINE_RTCOUNTER (1)
+#define MICROPY_PY_MACHINE_I2C      (1)
+#define MICROPY_PY_MACHINE_ADC      (1)
+#define MICROPY_PY_MACHINE_TEMP     (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
+
+#define MICROPY_HW_USB_CDC          (1)
+
+#define MICROPY_HW_HAS_LED          (1)
+#define MICROPY_HW_LED_TRICOLOR     (1)
+#define MICROPY_HW_LED_PULLUP       (1)
+
+#define MICROPY_HW_LED_RED          (13) // LED1
+#define MICROPY_HW_LED_GREEN        (14) // LED2
+#define MICROPY_HW_LED_BLUE         (15) // LED3
+
+// UART config
+#define MICROPY_HW_UART1_RX         (8)
+#define MICROPY_HW_UART1_TX         (6)
+#define MICROPY_HW_UART1_CTS        (32+2)
+#define MICROPY_HW_UART1_RTS        (32+1)
+#define MICROPY_HW_UART1_HWFC       (0)
+
+// SPI0 config
+#define MICROPY_HW_SPI0_NAME        "SPI0"
+
+#define MICROPY_HW_SPI0_SCK         (32+15)
+#define MICROPY_HW_SPI0_MOSI        (32+13)
+#define MICROPY_HW_SPI0_MISO        (32+14)
+
+#define MICROPY_HW_PWM0_NAME        "PWM0"
+#define MICROPY_HW_PWM1_NAME        "PWM1"
+#define MICROPY_HW_PWM2_NAME        "PWM2"
+#if 0
+#define MICROPY_HW_PWM3_NAME        "PWM3"
+#endif
+
+#define HELP_TEXT_BOARD_LED         "1,2,3"
diff --git a/ports/nrf/boards/particle_xenon/mpconfigboard.mk b/ports/nrf/boards/particle_xenon/mpconfigboard.mk
new file mode 100644
index 0000000000000..34bead59ff3f5
--- /dev/null
+++ b/ports/nrf/boards/particle_xenon/mpconfigboard.mk
@@ -0,0 +1,11 @@
+MCU_SERIES = m4
+MCU_VARIANT = nrf52
+MCU_SUB_VARIANT = nrf52840
+SOFTDEV_VERSION = 6.1.1
+LD_FILES += boards/nrf52840_1M_256k.ld
+
+NRF_DEFINES += -DNRF52840_XXAA
+
+# The nrf52-particle.cfg is not included here, it can be found in the Particle Workbench
+# Note: This requires openocd >0.10
+OPENOCD_TARGET ?= boards/$(BOARD)/nrf52-particle.cfg
diff --git a/ports/nrf/boards/particle_xenon/pins.csv b/ports/nrf/boards/particle_xenon/pins.csv
new file mode 100644
index 0000000000000..30f05c5564ff9
--- /dev/null
+++ b/ports/nrf/boards/particle_xenon/pins.csv
@@ -0,0 +1,38 @@
+LED1,P13
+LED2,P14
+LED3,P15
+A0,P3,ADC0_IN1
+A1,P4,ADC0_IN2
+A2,P28,ADC0_IN4
+A3,P29,ADC0_IN5
+A4,P30,ADC0_IN6
+A5,P31,ADC0_IN7
+SPI_SS,P31
+SPI_SCK,P47
+SPI_MOSI,P45
+SPI_MISO,P46
+SPI1_SCK,P33
+SPI1_MOSI,P34
+SPI1_MISO,P40
+UART1_RX,P8
+UART1_TX,P6
+UART2_RX,P42
+UART2_TX,P40
+SDA,P26
+SCL,P27
+SDA1,P33
+SCL1,P34
+D0,P26
+D1,P27
+D2,P33
+D3,P34
+D4,P40
+D5,P42
+D6,P43
+D7,P44
+D8,P35
+D9,P6
+D10,P8
+D11,P46
+D12,P45
+D13,P47
diff --git a/ports/nrf/boards/pca10000/mpconfigboard.h b/ports/nrf/boards/pca10000/mpconfigboard.h
index 16ee97b43015b..f61405d0480bb 100644
--- a/ports/nrf/boards/pca10000/mpconfigboard.h
+++ b/ports/nrf/boards/pca10000/mpconfigboard.h
@@ -35,7 +35,8 @@
 #define MICROPY_PY_MACHINE_I2C      (0)
 #define MICROPY_PY_MACHINE_ADC      (0)
 #define MICROPY_PY_MACHINE_TEMP     (1)
-#define MICROPY_PY_RANDOM_HW_RNG    (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
 
 #define MICROPY_HW_HAS_LED          (1)
 #define MICROPY_HW_LED_TRICOLOR     (1)
diff --git a/ports/nrf/boards/pca10001/mpconfigboard.h b/ports/nrf/boards/pca10001/mpconfigboard.h
index e6a0cecac5405..c101b0886aad7 100644
--- a/ports/nrf/boards/pca10001/mpconfigboard.h
+++ b/ports/nrf/boards/pca10001/mpconfigboard.h
@@ -35,7 +35,8 @@
 #define MICROPY_PY_MACHINE_I2C      (1)
 #define MICROPY_PY_MACHINE_ADC      (1)
 #define MICROPY_PY_MACHINE_TEMP     (1)
-#define MICROPY_PY_RANDOM_HW_RNG    (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
 
 #define MICROPY_HW_HAS_LED          (1)
 #define MICROPY_HW_LED_COUNT        (2)
diff --git a/ports/nrf/boards/pca10028/mpconfigboard.h b/ports/nrf/boards/pca10028/mpconfigboard.h
index 1061e6bb9d661..5488b4ba534c1 100644
--- a/ports/nrf/boards/pca10028/mpconfigboard.h
+++ b/ports/nrf/boards/pca10028/mpconfigboard.h
@@ -35,7 +35,8 @@
 #define MICROPY_PY_MACHINE_I2C      (1)
 #define MICROPY_PY_MACHINE_ADC      (1)
 #define MICROPY_PY_MACHINE_TEMP     (1)
-#define MICROPY_PY_RANDOM_HW_RNG    (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
 
 #define MICROPY_HW_HAS_LED          (1)
 #define MICROPY_HW_LED_COUNT        (4)
diff --git a/ports/nrf/boards/pca10031/mpconfigboard.h b/ports/nrf/boards/pca10031/mpconfigboard.h
index 6bcf2153e26ba..f16ffd7057ff5 100644
--- a/ports/nrf/boards/pca10031/mpconfigboard.h
+++ b/ports/nrf/boards/pca10031/mpconfigboard.h
@@ -35,7 +35,8 @@
 #define MICROPY_PY_MACHINE_I2C      (1)
 #define MICROPY_PY_MACHINE_ADC      (1)
 #define MICROPY_PY_MACHINE_TEMP     (1)
-#define MICROPY_PY_RANDOM_HW_RNG    (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
 
 #define MICROPY_HW_HAS_LED          (1)
 #define MICROPY_HW_LED_TRICOLOR     (1)
diff --git a/ports/nrf/boards/pca10040/mpconfigboard.h b/ports/nrf/boards/pca10040/mpconfigboard.h
index 82b74d9284916..1dd01d66a0482 100644
--- a/ports/nrf/boards/pca10040/mpconfigboard.h
+++ b/ports/nrf/boards/pca10040/mpconfigboard.h
@@ -36,7 +36,8 @@
 #define MICROPY_PY_MACHINE_I2C      (1)
 #define MICROPY_PY_MACHINE_ADC      (1)
 #define MICROPY_PY_MACHINE_TEMP     (1)
-#define MICROPY_PY_RANDOM_HW_RNG    (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
 
 #define MICROPY_HW_HAS_LED          (1)
 #define MICROPY_HW_LED_COUNT        (4)
diff --git a/ports/nrf/boards/pca10056/mpconfigboard.h b/ports/nrf/boards/pca10056/mpconfigboard.h
index e430c38a292cf..c037e2ecf5b28 100644
--- a/ports/nrf/boards/pca10056/mpconfigboard.h
+++ b/ports/nrf/boards/pca10056/mpconfigboard.h
@@ -36,7 +36,8 @@
 #define MICROPY_PY_MACHINE_I2C      (1)
 #define MICROPY_PY_MACHINE_ADC      (1)
 #define MICROPY_PY_MACHINE_TEMP     (1)
-#define MICROPY_PY_RANDOM_HW_RNG    (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
 
 #define MICROPY_HW_HAS_LED          (1)
 #define MICROPY_HW_LED_COUNT        (4)
diff --git a/ports/esp8266/intr.c b/ports/nrf/boards/pca10059/modules/boardmodules.h
similarity index 77%
rename from ports/esp8266/intr.c
rename to ports/nrf/boards/pca10059/modules/boardmodules.h
index 456d6cb0464f9..1d70ec91618df 100644
--- a/ports/esp8266/intr.c
+++ b/ports/nrf/boards/pca10059/modules/boardmodules.h
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 Damien P. George
+ * Copyright (c) 2019 Glenn Ruben Bakke
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,14 +24,11 @@
  * THE SOFTWARE.
  */
 
-#include "etshal.h"
-#include "ets_alt_task.h"
+#ifndef MICROPY_INCLUDED_NRF_BOARD_PCA10059_BOARD_MODULES_H
+#define MICROPY_INCLUDED_NRF_BOARD_PCA10059_BOARD_MODULES_H
 
-#include "modmachine.h"
+#define BOARD_MODULES
 
-// this is in a separate file so it can go in iRAM
-void pin_intr_handler_iram(void *arg) {
-    uint32_t status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
-    GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, status);
-    pin_intr_handler(status);
-}
+void board_modules_init0(void);
+
+#endif // MICROPY_INCLUDED_NRF_BOARD_PCA10059_BOARD_MODULES_H
diff --git a/ports/nrf/boards/pca10059/modules/boardmodules.mk b/ports/nrf/boards/pca10059/modules/boardmodules.mk
new file mode 100644
index 0000000000000..413790fbea7d5
--- /dev/null
+++ b/ports/nrf/boards/pca10059/modules/boardmodules.mk
@@ -0,0 +1,11 @@
+BOARD_PCA10059_DIR = boards/pca10059/modules
+
+INC += -I./$(BOARD_PCA10059_DIR)
+CFLAGS += -DBOARD_SPECIFIC_MODULES
+
+SRC_BOARD_MODULES = $(addprefix $(BOARD_PCA10059_DIR)/,\
+                      recover_uicr_regout0.c \
+                      )
+
+OBJ += $(addprefix $(BUILD)/, $(SRC_BOARD_MODULES:.c=.o))
+
diff --git a/ports/nrf/boards/pca10059/modules/recover_uicr_regout0.c b/ports/nrf/boards/pca10059/modules/recover_uicr_regout0.c
new file mode 100644
index 0000000000000..8ae5e218aaac8
--- /dev/null
+++ b/ports/nrf/boards/pca10059/modules/recover_uicr_regout0.c
@@ -0,0 +1,61 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Glenn Ruben Bakke
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdbool.h>
+
+#include "nrf.h"
+#include "nrf52840_bitfields.h"
+
+bool uicr_REGOUT0_erased() {
+    if (NRF_UICR->REGOUT0 == 0xFFFFFFFFUL) {
+        return true;
+    }
+    return false;
+}
+
+void board_modules_init0(void)
+{
+    if (uicr_REGOUT0_erased()) {
+
+        // Wait for pending NVMC operations to finish.
+        while (NRF_NVMC->READY != NVMC_READY_READY_Ready);
+
+        // Enable write mode in NVMC.
+        NRF_NVMC->CONFIG = NVMC_CONFIG_WEN_Wen;
+        while (NRF_NVMC->READY != NVMC_READY_READY_Ready);
+
+        // Write 3v3 value to UICR->REGOUT0.
+        NRF_UICR->REGOUT0 = (UICR_REGOUT0_VOUT_3V3 & UICR_REGOUT0_VOUT_Msk) << UICR_REGOUT0_VOUT_Pos;
+        while (NRF_NVMC->READY != NVMC_READY_READY_Ready);
+
+        // Enable read mode in NVMC.
+        NRF_NVMC->CONFIG = NVMC_CONFIG_WEN_Ren;
+        while (NRF_NVMC->READY != NVMC_READY_READY_Ready);
+
+        // Reset to apply the update.
+        NVIC_SystemReset();
+    }
+}
diff --git a/ports/nrf/boards/pca10059/mpconfigboard.h b/ports/nrf/boards/pca10059/mpconfigboard.h
new file mode 100644
index 0000000000000..3db599f2c35dd
--- /dev/null
+++ b/ports/nrf/boards/pca10059/mpconfigboard.h
@@ -0,0 +1,74 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Glenn Ruben Bakke
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#define MICROPY_HW_BOARD_NAME       "PCA10059"
+#define MICROPY_HW_MCU_NAME         "NRF52840"
+#define MICROPY_PY_SYS_PLATFORM     "nrf52840-Dongle"
+
+#define MICROPY_PY_MACHINE_UART     (1)
+#define MICROPY_PY_MACHINE_HW_PWM   (1)
+#define MICROPY_PY_MACHINE_HW_SPI   (1)
+#define MICROPY_PY_MACHINE_TIMER    (1)
+#define MICROPY_PY_MACHINE_RTCOUNTER (1)
+#define MICROPY_PY_MACHINE_I2C      (1)
+#define MICROPY_PY_MACHINE_ADC      (1)
+#define MICROPY_PY_MACHINE_TEMP     (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
+
+#define MICROPY_HW_USB_CDC          (1)
+
+#define MICROPY_HW_HAS_LED          (1)
+#define MICROPY_HW_LED_COUNT        (4)
+#define MICROPY_HW_LED_PULLUP       (1)
+
+#define MICROPY_HW_LED1             (6)  // LED1 GREEN
+#define MICROPY_HW_LED2             (8)  // LED2 RED (RGB)
+#define MICROPY_HW_LED3             (41) // LED2 GREEN (RGB)
+#define MICROPY_HW_LED4             (12) // LED2 BLUE (RGB)
+
+// UART config
+#define MICROPY_HW_UART1_RX         (13)
+#define MICROPY_HW_UART1_TX         (15)
+#define MICROPY_HW_UART1_CTS        (17)
+#define MICROPY_HW_UART1_RTS        (20)
+#define MICROPY_HW_UART1_HWFC       (1)
+
+// SPI0 config
+#define MICROPY_HW_SPI0_NAME        "SPI0"
+
+#define MICROPY_HW_SPI0_SCK         (22)
+#define MICROPY_HW_SPI0_MOSI        (32)
+#define MICROPY_HW_SPI0_MISO        (24)
+
+#define MICROPY_HW_PWM0_NAME        "PWM0"
+#define MICROPY_HW_PWM1_NAME        "PWM1"
+#define MICROPY_HW_PWM2_NAME        "PWM2"
+#if 0
+#define MICROPY_HW_PWM3_NAME        "PWM3"
+#endif
+
+#define HELP_TEXT_BOARD_LED         "1,2,3,4"
diff --git a/ports/nrf/boards/pca10059/mpconfigboard.mk b/ports/nrf/boards/pca10059/mpconfigboard.mk
new file mode 100644
index 0000000000000..ca555d3932aa4
--- /dev/null
+++ b/ports/nrf/boards/pca10059/mpconfigboard.mk
@@ -0,0 +1,7 @@
+MCU_SERIES = m4
+MCU_VARIANT = nrf52
+MCU_SUB_VARIANT = nrf52840
+SOFTDEV_VERSION = 6.1.1
+LD_FILES += boards/nrf52840_1M_256k.ld
+
+NRF_DEFINES += -DNRF52840_XXAA
diff --git a/ports/nrf/boards/pca10059/pins.csv b/ports/nrf/boards/pca10059/pins.csv
new file mode 100644
index 0000000000000..9d142b9f12168
--- /dev/null
+++ b/ports/nrf/boards/pca10059/pins.csv
@@ -0,0 +1,31 @@
+P2,P2,ADC0_IN0
+P4,P4,ADC0_IN2
+LED1_GREEN,P6
+LED2_RED,P8
+P9,P9
+P10,P10
+P11,P11
+LED2_BLUE,P12
+UART1_RX,P13
+P14,P14
+UART1_TX,P15
+P16,P16
+UART1_CTS,P17
+SWITCH2_NRESET,P18
+UART1_RTS,P20
+SPI0_SCK,P22,P22
+SPI0_MISO,P24
+P26,P26
+P29,P29,ADC0_IN5
+P31,P31,ADC0_IN7
+SPI0_MOSI,P32
+P33,P33
+P34,P34
+P36,P36
+SWITCH1,P38,P38
+P39,P39
+LED2_GREEN,P41
+P42,P42
+P43,P43
+P45,P45
+P47,P47
diff --git a/ports/nrf/boards/pca10090/mpconfigboard.h b/ports/nrf/boards/pca10090/mpconfigboard.h
new file mode 100644
index 0000000000000..e4e514290949b
--- /dev/null
+++ b/ports/nrf/boards/pca10090/mpconfigboard.h
@@ -0,0 +1,90 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Glenn Ruben Bakke
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#define PCA10090
+
+#define MICROPY_HW_BOARD_NAME       "PCA10090"
+#define MICROPY_HW_MCU_NAME         "NRF9160"
+#define MICROPY_PY_SYS_PLATFORM     "nrf9160-DK"
+
+#define MICROPY_PY_MACHINE_UART     (1)
+#define MICROPY_PY_MACHINE_HW_PWM   (0)
+#define MICROPY_PY_MACHINE_HW_SPI   (1)
+#define MICROPY_PY_MACHINE_TIMER    (0)
+#define MICROPY_PY_MACHINE_RTCOUNTER (0)
+#define MICROPY_PY_MACHINE_I2C      (1)
+#define MICROPY_PY_MACHINE_ADC      (0)
+#define MICROPY_PY_MACHINE_TEMP     (0)
+
+#define MICROPY_MBFS                (0)
+
+#define MICROPY_HW_HAS_LED          (1)
+#define MICROPY_HW_HAS_SWITCH       (0)
+#define MICROPY_HW_HAS_FLASH        (0)
+#define MICROPY_HW_HAS_SDCARD       (0)
+#define MICROPY_HW_HAS_MMA7660      (0)
+#define MICROPY_HW_HAS_LIS3DSH      (0)
+#define MICROPY_HW_HAS_LCD          (0)
+#define MICROPY_HW_ENABLE_RNG       (0)
+#define MICROPY_HW_ENABLE_RTC       (0)
+#define MICROPY_HW_ENABLE_TIMER     (0)
+#define MICROPY_HW_ENABLE_SERVO     (0)
+#define MICROPY_HW_ENABLE_DAC       (0)
+#define MICROPY_HW_ENABLE_CAN       (0)
+
+#define MICROPY_HW_LED_COUNT        (4)
+#define MICROPY_HW_LED_PULLUP       (0)
+
+#define MICROPY_HW_LED1             (2) // LED1
+#define MICROPY_HW_LED2             (3) // LED2
+#define MICROPY_HW_LED3             (4) // LED3
+#define MICROPY_HW_LED4             (5) // LED4
+
+// UART config
+// VCOM0
+#define MICROPY_HW_UART1_RX         (28)
+#define MICROPY_HW_UART1_TX         (29)
+#define MICROPY_HW_UART1_CTS        (26)
+#define MICROPY_HW_UART1_RTS        (27)
+#define MICROPY_HW_UART1_HWFC       (1)
+
+/*
+// VCOM2
+#define MICROPY_HW_UART1_RX         (0)
+#define MICROPY_HW_UART1_TX         (1)
+#define MICROPY_HW_UART1_CTS        (15)
+#define MICROPY_HW_UART1_RTS        (14)
+#define MICROPY_HW_UART1_HWFC       (1)
+*/
+
+// SPI0 config
+#define MICROPY_HW_SPI0_NAME        "SPI0"
+
+#define MICROPY_HW_SPI0_SCK         (13)
+#define MICROPY_HW_SPI0_MOSI        (11)
+#define MICROPY_HW_SPI0_MISO        (12)
+
+#define HELP_TEXT_BOARD_LED         "1,2,3,4"
diff --git a/ports/nrf/boards/pca10090/mpconfigboard.mk b/ports/nrf/boards/pca10090/mpconfigboard.mk
new file mode 100644
index 0000000000000..9363900e2b5dd
--- /dev/null
+++ b/ports/nrf/boards/pca10090/mpconfigboard.mk
@@ -0,0 +1,6 @@
+MCU_SERIES = m33
+MCU_VARIANT = nrf91
+MCU_SUB_VARIANT = nrf9160
+LD_FILES += boards/nrf9160_1M_256k.ld
+
+NRF_DEFINES += -DNRF9160_XXAA -DNRF_TRUSTZONE_NONSECURE
diff --git a/ports/nrf/boards/pca10090/pins.csv b/ports/nrf/boards/pca10090/pins.csv
new file mode 100644
index 0000000000000..7d060f68fff36
--- /dev/null
+++ b/ports/nrf/boards/pca10090/pins.csv
@@ -0,0 +1,32 @@
+P0,P0
+P1,P1
+P2,P2
+P3,P3
+P4,P4
+P5,P5
+P6,P6
+P7,P7
+P8,P8
+P9,P9
+P10,P10
+P11,P11
+P12,P12
+P13,P13
+P14,P14
+P15,P15
+P16,P16
+P17,P17
+P18,P18
+P19,P19
+P20,P20
+P21,P21
+P22,P22
+P23,P23
+P24,P24
+P25,P25
+P26,P26
+P27,P27
+P28,P28
+P29,P29
+P30,P30
+P31,P31
diff --git a/ports/nrf/boards/wt51822_s4at/mpconfigboard.h b/ports/nrf/boards/wt51822_s4at/mpconfigboard.h
index 4bc2b153d0394..8117bbd2a6c18 100644
--- a/ports/nrf/boards/wt51822_s4at/mpconfigboard.h
+++ b/ports/nrf/boards/wt51822_s4at/mpconfigboard.h
@@ -37,7 +37,8 @@
 #define MICROPY_PY_MACHINE_I2C      (1)
 #define MICROPY_PY_MACHINE_ADC      (1)
 #define MICROPY_PY_MACHINE_TEMP     (1)
-#define MICROPY_PY_RANDOM_HW_RNG    (1)
+
+#define MICROPY_HW_ENABLE_RNG       (1)
 
 #define MICROPY_HW_HAS_LED          (0)
 
diff --git a/ports/nrf/device/startup_nrf51822.c b/ports/nrf/device/startup_nrf51822.c
index 2f15f0f49c7f8..2063e272743e5 100644
--- a/ports/nrf/device/startup_nrf51822.c
+++ b/ports/nrf/device/startup_nrf51822.c
@@ -48,8 +48,8 @@ void Reset_Handler(void) {
     // RAM on in on-mode
     *ram_on_addr   = 3; // block 0 and 1
     *ram_on_b_addr = 3; // block 2 and 3
-#if 0 
-    // RAM on in off-mode 
+#if 0
+    // RAM on in off-mode
     ram_on_addr   = 1 << 16;
     ram_on_b_addr = 1 << 17;
 #endif
diff --git a/ports/nrf/device/startup_nrf52840.c b/ports/nrf/device/startup_nrf52840.c
index 0935d7d1d02a0..288b13820f534 100644
--- a/ports/nrf/device/startup_nrf52840.c
+++ b/ports/nrf/device/startup_nrf52840.c
@@ -176,7 +176,9 @@ const func __Vectors[] __attribute__ ((section(".isr_vector"),used)) = {
     UARTE1_IRQHandler,
     QSPI_IRQHandler,
     CRYPTOCELL_IRQHandler,
-    SPIM3_IRQHandler,
+    0,
     0,
     PWM3_IRQHandler,
+    0,
+    SPIM3_IRQHandler,
 };
diff --git a/ports/nrf/device/startup_nrf9160.c b/ports/nrf/device/startup_nrf9160.c
new file mode 100644
index 0000000000000..5a32ddff32a08
--- /dev/null
+++ b/ports/nrf/device/startup_nrf9160.c
@@ -0,0 +1,270 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Glenn Ruben Bakke
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdint.h>
+
+extern uint32_t _estack;
+extern uint32_t _sidata;
+extern uint32_t _sdata;
+extern uint32_t _edata;
+extern uint32_t _sbss;
+extern uint32_t _ebss;
+
+typedef void (*func)(void);
+
+extern void  _start(void) __attribute__((noreturn));
+extern void SystemInit(void);
+
+void Default_Handler(void) { while (1); }
+
+void Reserved_Handler1(void) { while (1); }
+void Reserved_Handler2(void) { while (1); }
+void Reserved_Handler3(void) { while (1); }
+void Reserved_Handler4(void) { while (1); }
+void Reserved_Handler5(void) { while (1); }
+void Reserved_Handler6(void) { while (1); }
+void Reserved_Handler7(void) { while (1); }
+void Reserved_Handler8(void) { while (1); }
+void Reserved_Handler9(void) { while (1); }
+void Reserved_Handler10(void) { while (1); }
+void Reserved_Handler11(void) { while (1); }
+void Reserved_Handler12(void) { while (1); }
+void Reserved_Handler13(void) { while (1); }
+void Reserved_Handler14(void) { while (1); }
+void Reserved_Handler15(void) { while (1); }
+void Reserved_Handler16(void) { while (1); }
+void Reserved_Handler17(void) { while (1); }
+void Reserved_Handler18(void) { while (1); }
+void Reserved_Handler19(void) { while (1); }
+void Reserved_Handler20(void) { while (1); }
+void Reserved_Handler21(void) { while (1); }
+void Reserved_Handler22(void) { while (1); }
+void Reserved_Handler23(void) { while (1); }
+void Reserved_Handler24(void) { while (1); }
+void Reserved_Handler25(void) { while (1); }
+void Reserved_Handler26(void) { while (1); }
+void Reserved_Handler27(void) { while (1); }
+void Reserved_Handler28(void) { while (1); }
+void Reserved_Handler29(void) { while (1); }
+void Reserved_Handler30(void) { while (1); }
+void Reserved_Handler31(void) { while (1); }
+void Reserved_Handler32(void) { while (1); }
+void Reserved_Handler33(void) { while (1); }
+void Reserved_Handler34(void) { while (1); }
+void Reserved_Handler35(void) { while (1); }
+void Reserved_Handler36(void) { while (1); }
+void Reserved_Handler37(void) { while (1); }
+void Reserved_Handler38(void) { while (1); }
+
+void Default_NMI_Handler                 (void) { while (1); }
+void Default_HardFault_Handler           (void) { while (1); }
+void Default_MemoryManagement_Handler    (void) { while (1); }
+void Default_BusFault_Handler            (void) { while (1); }
+void Default_UsageFault_Handler          (void) { while (1); }
+void Default_SecureFault_Handler         (void) { while (1); }
+void Default_SVC_Handler                 (void) { while (1); }
+void Default_DebugMon_Handler            (void) { while (1); }
+void Default_PendSV_Handler              (void) { while (1); }
+void Default_SysTick_Handler             (void) { while (1); }
+
+void Default_SPU_IRQHandler              (void) { while (1); }
+void Default_CLOCK_POWER_IRQHandler      (void) { while (1); }
+void Default_UARTE0_SPIM0_SPIS0_TWIM0_TWIS0_IRQHandler (void) { while (1); }
+void Default_UARTE1_SPIM1_SPIS1_TWIM1_TWIS1_IRQHandler (void) { while (1); }
+void Default_UARTE2_SPIM2_SPIS2_TWIM2_TWIS2_IRQHandler (void) { while (1); }
+void Default_UARTE3_SPIM3_SPIS3_TWIM3_TWIS3_IRQHandler (void) { while (1); }
+void Default_GPIOTE0_IRQHandler          (void) { while (1); }
+void Default_SAADC_IRQHandler            (void) { while (1); }
+void Default_TIMER0_IRQHandler           (void) { while (1); }
+void Default_TIMER1_IRQHandler           (void) { while (1); }
+void Default_TIMER2_IRQHandler           (void) { while (1); }
+void Default_RTC0_IRQHandler             (void) { while (1); }
+void Default_RTC1_IRQHandler             (void) { while (1); }
+void Default_WDT_IRQHandler              (void) { while (1); }
+void Default_EGU0_IRQHandler             (void) { while (1); }
+void Default_EGU1_IRQHandler             (void) { while (1); }
+void Default_EGU2_IRQHandler             (void) { while (1); }
+void Default_EGU3_IRQHandler             (void) { while (1); }
+void Default_EGU4_IRQHandler             (void) { while (1); }
+void Default_EGU5_IRQHandler             (void) { while (1); }
+void Default_PWM0_IRQHandler             (void) { while (1); }
+void Default_PWM1_IRQHandler             (void) { while (1); }
+void Default_PWM2_IRQHandler             (void) { while (1); }
+void Default_PWM3_IRQHandler             (void) { while (1); }
+void Default_PDM_IRQHandler              (void) { while (1); }
+void Default_I2S_IRQHandler              (void) { while (1); }
+void Default_IPC_IRQHandler              (void) { while (1); }
+void Default_FPU_IRQHandler              (void) { while (1); }
+void Default_GPIOTE1_IRQHandler          (void) { while (1); }
+void Default_KMU_IRQHandler              (void) { while (1); }
+void Default_CRYPTOCELL_IRQHandler       (void) { while (1); }
+
+void Reset_Handler(void) {
+    uint32_t * p_src  = &_sidata;
+    uint32_t * p_dest = &_sdata;
+
+    while (p_dest < &_edata) {
+      *p_dest++ = *p_src++;
+    }
+
+    uint32_t * p_bss     = &_sbss;
+    uint32_t * p_bss_end = &_ebss;
+    while (p_bss < p_bss_end) {
+        *p_bss++ = 0ul;
+    }
+
+    SystemInit();
+    _start();
+}
+
+void NMI_Handler                 (void) __attribute__ ((weak, alias("Default_Handler")));
+void HardFault_Handler           (void) __attribute__ ((weak, alias("Default_HardFault_Handler")));
+void MemoryManagement_Handler    (void) __attribute__ ((weak, alias("Default_MemoryManagement_Handler")));
+void BusFault_Handler            (void) __attribute__ ((weak, alias("Default_BusFault_Handler")));
+void UsageFault_Handler          (void) __attribute__ ((weak, alias("Default_UsageFault_Handler")));
+void SecureFault_Handler         (void) __attribute__ ((weak, alias("Default_SecureFault_Handler")));
+void SVC_Handler                 (void) __attribute__ ((weak, alias("Default_SVC_Handler")));
+void DebugMon_Handler            (void) __attribute__ ((weak, alias("Default_DebugMon_Handler")));
+void PendSV_Handler              (void) __attribute__ ((weak, alias("Default_PendSV_Handler")));
+void SysTick_Handler             (void) __attribute__ ((weak, alias("Default_SysTick_Handler")));
+
+void SPU_IRQHandler              (void) __attribute__ ((weak, alias("Default_SPU_IRQHandler")));
+void CLOCK_POWER_IRQHandler      (void) __attribute__ ((weak, alias("Default_CLOCK_POWER_IRQHandler")));
+void UARTE0_SPIM0_SPIS0_TWIM0_TWIS0_IRQHandler (void) __attribute__ ((weak, alias("Default_UARTE0_SPIM0_SPIS0_TWIM0_TWIS0_IRQHandler")));
+void UARTE1_SPIM1_SPIS1_TWIM1_TWIS1_IRQHandler (void) __attribute__ ((weak, alias("Default_UARTE1_SPIM1_SPIS1_TWIM1_TWIS1_IRQHandler")));
+void UARTE2_SPIM2_SPIS2_TWIM2_TWIS2_IRQHandler (void) __attribute__ ((weak, alias("Default_UARTE2_SPIM2_SPIS2_TWIM2_TWIS2_IRQHandler")));
+void UARTE3_SPIM3_SPIS3_TWIM3_TWIS3_IRQHandler (void) __attribute__ ((weak, alias("Default_UARTE3_SPIM3_SPIS3_TWIM3_TWIS3_IRQHandler")));
+void GPIOTE0_IRQHandler          (void) __attribute__ ((weak, alias("Default_GPIOTE0_IRQHandler")));
+void SAADC_IRQHandler            (void) __attribute__ ((weak, alias("Default_SAADC_IRQHandler")));
+void TIMER0_IRQHandler           (void) __attribute__ ((weak, alias("Default_TIMER0_IRQHandler")));
+void TIMER1_IRQHandler           (void) __attribute__ ((weak, alias("Default_TIMER1_IRQHandler")));
+void TIMER2_IRQHandler           (void) __attribute__ ((weak, alias("Default_TIMER2_IRQHandler")));
+void RTC0_IRQHandler             (void) __attribute__ ((weak, alias("Default_RTC0_IRQHandler")));
+void RTC1_IRQHandler             (void) __attribute__ ((weak, alias("Default_RTC1_IRQHandler")));
+void WDT_IRQHandler              (void) __attribute__ ((weak, alias("Default_WDT_IRQHandler")));
+void EGU0_IRQHandler             (void) __attribute__ ((weak, alias("Default_EGU0_IRQHandler")));
+void EGU1_IRQHandler             (void) __attribute__ ((weak, alias("Default_EGU1_IRQHandler")));
+void EGU2_IRQHandler             (void) __attribute__ ((weak, alias("Default_EGU2_IRQHandler")));
+void EGU3_IRQHandler             (void) __attribute__ ((weak, alias("Default_EGU3_IRQHandler")));
+void EGU4_IRQHandler             (void) __attribute__ ((weak, alias("Default_EGU4_IRQHandler")));
+void EGU5_IRQHandler             (void) __attribute__ ((weak, alias("Default_EGU5_IRQHandler")));
+void PWM0_IRQHandler             (void) __attribute__ ((weak, alias("Default_PWM0_IRQHandler")));
+void PWM1_IRQHandler             (void) __attribute__ ((weak, alias("Default_PWM1_IRQHandler")));
+void PWM2_IRQHandler             (void) __attribute__ ((weak, alias("Default_PWM2_IRQHandler")));
+void PWM3_IRQHandler             (void) __attribute__ ((weak, alias("Default_PWM3_IRQHandler")));
+void PDM_IRQHandler              (void) __attribute__ ((weak, alias("Default_PDM_IRQHandler")));
+void I2S_IRQHandler              (void) __attribute__ ((weak, alias("Default_I2S_IRQHandler")));
+void IPC_IRQHandler              (void) __attribute__ ((weak, alias("Default_IPC_IRQHandler")));
+void FPU_IRQHandler              (void) __attribute__ ((weak, alias("Default_FPU_IRQHandler")));
+void GPIOTE1_IRQHandler          (void) __attribute__ ((weak, alias("Default_GPIOTE1_IRQHandler")));
+void KMU_IRQHandler              (void) __attribute__ ((weak, alias("Default_KMU_IRQHandler")));
+void CRYPTOCELL_IRQHandler       (void) __attribute__ ((weak, alias("Default_CRYPTOCELL_IRQHandler")));
+
+const func __Vectors[] __attribute__ ((section(".isr_vector"),used)) = {
+    (func)&_estack,
+    Reset_Handler,
+    NMI_Handler,
+    HardFault_Handler,
+    MemoryManagement_Handler,
+    BusFault_Handler,
+    UsageFault_Handler,
+    SecureFault_Handler,
+    Reserved_Handler1,
+    Reserved_Handler2,
+    Reserved_Handler3,
+    SVC_Handler,
+    DebugMon_Handler,
+    Reserved_Handler4,
+    PendSV_Handler,
+    SysTick_Handler,
+
+    /* External Interrupts */
+    Reserved_Handler5,
+    Reserved_Handler6,
+    Reserved_Handler7,
+    SPU_IRQHandler,
+    Reserved_Handler8,
+    CLOCK_POWER_IRQHandler,
+    Reserved_Handler9,
+    Reserved_Handler10,
+    UARTE0_SPIM0_SPIS0_TWIM0_TWIS0_IRQHandler,
+    UARTE1_SPIM1_SPIS1_TWIM1_TWIS1_IRQHandler,
+    UARTE2_SPIM2_SPIS2_TWIM2_TWIS2_IRQHandler,
+    UARTE3_SPIM3_SPIS3_TWIM3_TWIS3_IRQHandler,
+    Reserved_Handler11,
+    GPIOTE0_IRQHandler,
+    SAADC_IRQHandler,
+    TIMER0_IRQHandler,
+    TIMER1_IRQHandler,
+    TIMER2_IRQHandler,
+    Reserved_Handler12,
+    Reserved_Handler13,
+    RTC0_IRQHandler,
+    RTC1_IRQHandler,
+    Reserved_Handler14,
+    Reserved_Handler15,
+    WDT_IRQHandler,
+    Reserved_Handler16,
+    Reserved_Handler17,
+    EGU0_IRQHandler,
+    EGU1_IRQHandler,
+    EGU2_IRQHandler,
+    EGU3_IRQHandler,
+    EGU4_IRQHandler,
+    EGU5_IRQHandler,
+    PWM0_IRQHandler,
+    PWM1_IRQHandler,
+    PWM2_IRQHandler,
+    PWM3_IRQHandler,
+    Reserved_Handler18,
+    PDM_IRQHandler,
+    Reserved_Handler19,
+    I2S_IRQHandler,
+    Reserved_Handler20,
+    IPC_IRQHandler,
+    Reserved_Handler21,
+    FPU_IRQHandler,
+    Reserved_Handler22,
+    Reserved_Handler23,
+    Reserved_Handler24,
+    Reserved_Handler25,
+    GPIOTE1_IRQHandler,
+    Reserved_Handler26,
+    Reserved_Handler27,
+    Reserved_Handler28,
+    Reserved_Handler29,
+    Reserved_Handler30,
+    Reserved_Handler31,
+    Reserved_Handler32,
+    KMU_IRQHandler,
+    Reserved_Handler33,
+    Reserved_Handler34,
+    Reserved_Handler35,
+    Reserved_Handler36,
+    Reserved_Handler37,
+    Reserved_Handler38,
+    CRYPTOCELL_IRQHandler,
+};
diff --git a/ports/nrf/drivers/bluetooth/ble_drv.c b/ports/nrf/drivers/bluetooth/ble_drv.c
index ff3c885c153f5..7619dc0399455 100644
--- a/ports/nrf/drivers/bluetooth/ble_drv.c
+++ b/ports/nrf/drivers/bluetooth/ble_drv.c
@@ -40,6 +40,10 @@
 #include "mphalport.h"
 
 
+#if MICROPY_HW_USB_CDC
+#include "usb_cdc.h"
+#endif
+
 #define BLE_DRIVER_VERBOSE 0
 
 #if BLE_DRIVER_VERBOSE
@@ -112,7 +116,7 @@ static mp_obj_t mp_gattc_char_data_observer;
 static uint8_t m_adv_handle = BLE_GAP_ADV_SET_HANDLE_NOT_SET;
 static uint8_t m_scan_buffer[BLE_GAP_SCAN_BUFFER_MIN];
 
-nrf_nvic_state_t nrf_nvic_state = {0};
+nrf_nvic_state_t nrf_nvic_state = {{0}, 0};
 #endif
 
 #if (BLUETOOTH_SD == 110)
@@ -219,8 +223,7 @@ uint32_t ble_drv_stack_enable(void) {
     if ((err_code = sd_ble_gap_device_name_set(&sec_mode,
                                                (const uint8_t *)device_name,
                                                 strlen(device_name))) != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                  "Cannot apply GAP parameters."));
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't apply GAP parameters"));
     }
 
     // set connection parameters
@@ -232,9 +235,7 @@ uint32_t ble_drv_stack_enable(void) {
     gap_conn_params.conn_sup_timeout  = BLE_CONN_SUP_TIMEOUT;
 
     if (sd_ble_gap_ppcp_set(&gap_conn_params) != 0) {
-
-    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-              "Cannot set PPCP parameters."));
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't set PPCP parameters"));
     }
 
     return err_code;
@@ -265,8 +266,7 @@ void ble_drv_address_get(ble_drv_addr_t * p_addr) {
 #endif
 
     if (err_code != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                  "Can not query for the device address."));
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't query for the device address"));
     }
 
     BLE_DRIVER_LOG("ble address, type: " HEX2_FMT ", " \
@@ -284,8 +284,7 @@ bool ble_drv_uuid_add_vs(uint8_t * p_uuid, uint8_t * idx) {
     SD_TEST_OR_ENABLE();
 
     if (sd_ble_uuid_vs_add((ble_uuid128_t const *)p_uuid, idx) != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                  "Can not add Vendor Specific 128-bit UUID."));
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't add Vendor Specific 128-bit UUID"));
     }
 
     return true;
@@ -304,8 +303,7 @@ bool ble_drv_service_add(ubluepy_service_obj_t * p_service_obj) {
         if (sd_ble_gatts_service_add(p_service_obj->type,
                                      &uuid,
                                      &p_service_obj->handle) != 0) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                      "Can not add Service."));
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't add Service"));
         }
     } else if (p_service_obj->p_uuid->type == BLE_UUID_TYPE_BLE) {
         BLE_DRIVER_LOG("adding service\n");
@@ -318,8 +316,7 @@ bool ble_drv_service_add(ubluepy_service_obj_t * p_service_obj) {
         if (sd_ble_gatts_service_add(p_service_obj->type,
                                      &uuid,
                                      &p_service_obj->handle) != 0) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                      "Can not add Service."));
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't add Service"));
         }
     }
     return true;
@@ -389,8 +386,7 @@ bool ble_drv_characteristic_add(ubluepy_characteristic_obj_t * p_char_obj) {
                                         &char_md,
                                         &attr_char_value,
                                         &handles) != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                  "Can not add Characteristic."));
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't add Characteristic"));
     }
 
     // apply handles to object instance
@@ -417,8 +413,7 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
         if (sd_ble_gap_device_name_set(&sec_mode,
                                        p_adv_params->p_device_name,
                                        p_adv_params->device_name_len) != 0) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-	              "Can not apply device name in the stack."));
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't apply device name in the stack"));
         }
 
         BLE_DRIVER_LOG("Device name applied\n");
@@ -481,14 +476,12 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
                 uuid.uuid += p_service->p_uuid->value[1] << 8;
                 // calculate total size of uuids
                 if (sd_ble_uuid_encode(&uuid, &encoded_size, NULL) != 0) {
-                    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                              "Can not encode UUID, to check length."));
+                    mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't encode UUID, to check length"));
                 }
 
                 // do encoding into the adv buffer
                 if (sd_ble_uuid_encode(&uuid, &encoded_size, &adv_data[byte_pos]) != 0) {
-                    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                              "Can encode UUID into the advertisment packet."));
+                    mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't encode UUID into advertisment packet"));
                 }
 
                 BLE_DRIVER_LOG("encoded uuid for service %u: ", 0);
@@ -531,14 +524,12 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
 
                 // calculate total size of uuids
                 if (sd_ble_uuid_encode(&uuid, &encoded_size, NULL) != 0) {
-                    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                              "Can not encode UUID, to check length."));
+                    mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't encode UUID, to check length"));
                 }
 
                 // do encoding into the adv buffer
                 if (sd_ble_uuid_encode(&uuid, &encoded_size, &adv_data[byte_pos]) != 0) {
-                    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                              "Can encode UUID into the advertisment packet."));
+                    mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't encode UUID into advertisment packet"));
                 }
 
                 BLE_DRIVER_LOG("encoded uuid for service %u: ", 0);
@@ -562,8 +553,7 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
 
     if ((p_adv_params->data_len > 0) && (p_adv_params->p_data != NULL)) {
         if (p_adv_params->data_len + byte_pos > BLE_GAP_ADV_MAX_SIZE) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                      "Can not fit data into the advertisment packet."));
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't fit data into advertisment packet"));
         }
 
         memcpy(adv_data, p_adv_params->p_data, p_adv_params->data_len);
@@ -616,13 +606,13 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
 
 #if (BLUETOOTH_SD == 110)
     if ((err_code = sd_ble_gap_adv_data_set(adv_data, byte_pos, NULL, 0)) != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                  "Can not apply advertisment data. status: 0x" HEX2_FMT, (uint16_t)err_code));
+        mp_raise_msg_varg(&mp_type_OSError,
+            "Can not apply advertisment data. status: 0x" HEX2_FMT, (uint16_t)err_code);
     }
 #else
     if ((err_code = sd_ble_gap_adv_set_configure(&m_adv_handle, &m_adv_data, &m_adv_params)) != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                  "Can not apply advertisment data. status: 0x" HEX2_FMT, (uint16_t)err_code));
+        mp_raise_msg_varg(&mp_type_OSError,
+            "Can not apply advertisment data. status: 0x" HEX2_FMT, (uint16_t)err_code);
     }
 #endif
     BLE_DRIVER_LOG("Set Adv data size: " UINT_FMT "\n", byte_pos);
@@ -636,8 +626,8 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
     err_code = sd_ble_gap_adv_start(m_adv_handle, conf_tag);
 #endif
     if (err_code != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                  "Can not start advertisment. status: 0x" HEX2_FMT, (uint16_t)err_code));
+        mp_raise_msg_varg(&mp_type_OSError,
+            "Can not start advertisment. status: 0x" HEX2_FMT, (uint16_t)err_code);
     }
 
     m_adv_in_progress = true;
@@ -651,13 +641,13 @@ void ble_drv_advertise_stop(void) {
 
 #if (BLUETOOTH_SD == 110)
         if ((err_code = sd_ble_gap_adv_stop()) != 0) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                      "Can not stop advertisment. status: 0x" HEX2_FMT, (uint16_t)err_code));
+            mp_raise_msg_varg(&mp_type_OSError,
+                "Can not stop advertisment. status: 0x" HEX2_FMT, (uint16_t)err_code);
         }
 #else
         if ((err_code = sd_ble_gap_adv_stop(m_adv_handle)) != 0) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                      "Can not stop advertisment. status: 0x" HEX2_FMT, (uint16_t)err_code));
+            mp_raise_msg_varg(&mp_type_OSError,
+                "Can not stop advertisment. status: 0x" HEX2_FMT, (uint16_t)err_code);
         }
 #endif
     }
@@ -676,8 +666,8 @@ void ble_drv_attr_s_read(uint16_t conn_handle, uint16_t handle, uint16_t len, ui
                                                handle,
                                                &gatts_value);
     if (err_code != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                  "Can not read attribute value. status: 0x" HEX2_FMT, (uint16_t)err_code));
+        mp_raise_msg_varg(&mp_type_OSError,
+            "Can not read attribute value. status: 0x" HEX2_FMT, (uint16_t)err_code);
     }
 
 }
@@ -693,8 +683,8 @@ void ble_drv_attr_s_write(uint16_t conn_handle, uint16_t handle, uint16_t len, u
     uint32_t err_code = sd_ble_gatts_value_set(conn_handle, handle, &gatts_value);
 
     if (err_code != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                  "Can not write attribute value. status: 0x" HEX2_FMT, (uint16_t)err_code));
+        mp_raise_msg_varg(&mp_type_OSError,
+            "Can not write attribute value. status: 0x" HEX2_FMT, (uint16_t)err_code);
     }
 }
 
@@ -717,8 +707,8 @@ void ble_drv_attr_s_notify(uint16_t conn_handle, uint16_t handle, uint16_t len,
     BLE_DRIVER_LOG("Request TX, m_tx_in_progress: %u\n", m_tx_in_progress);
     uint32_t err_code;
     if ((err_code = sd_ble_gatts_hvx(conn_handle, &hvx_params)) != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                  "Can not notify attribute value. status: 0x" HEX2_FMT, (uint16_t)err_code));
+        mp_raise_msg_varg(&mp_type_OSError,
+            "Can not notify attribute value. status: 0x" HEX2_FMT, (uint16_t)err_code);
     }
     m_tx_in_progress++;
     BLE_DRIVER_LOG("Queued TX, m_tx_in_progress: %u\n", m_tx_in_progress);
@@ -756,8 +746,8 @@ void ble_drv_attr_c_read(uint16_t conn_handle, uint16_t handle, mp_obj_t obj, bl
                                           handle,
                                           0);
     if (err_code != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                  "Can not read attribute value. status: 0x" HEX2_FMT, (uint16_t)err_code));
+        mp_raise_msg_varg(&mp_type_OSError,
+            "Can not read attribute value. status: 0x" HEX2_FMT, (uint16_t)err_code);
     }
 
     while (gattc_char_data_handle != NULL) {
@@ -786,8 +776,8 @@ void ble_drv_attr_c_write(uint16_t conn_handle, uint16_t handle, uint16_t len, u
     uint32_t err_code = sd_ble_gattc_write(conn_handle, &write_params);
 
     if (err_code != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-            "Can not write attribute value. status: 0x" HEX2_FMT, (uint16_t)err_code));
+        mp_raise_msg_varg(&mp_type_OSError,
+            "Can not write attribute value. status: 0x" HEX2_FMT, (uint16_t)err_code);
     }
 
     while (m_write_done != true) {
@@ -817,8 +807,8 @@ void ble_drv_scan_start(bool cont) {
         p_scan_params = NULL;
     }
     if ((err_code = sd_ble_gap_scan_start(p_scan_params, &scan_buffer)) != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                  "Can not start scanning. status: 0x" HEX2_FMT, (uint16_t)err_code));
+        mp_raise_msg_varg(&mp_type_OSError,
+            "Can not start scanning. status: 0x" HEX2_FMT, (uint16_t)err_code);
     }
 }
 
@@ -863,8 +853,8 @@ void ble_drv_connect(uint8_t * p_addr, uint8_t addr_type) {
                                        &scan_params,
                                        &conn_params,
                                        conn_tag)) != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                  "Can not connect. status: 0x" HEX2_FMT, (uint16_t)err_code));
+        mp_raise_msg_varg(&mp_type_OSError,
+            "Can not connect. status: 0x" HEX2_FMT, (uint16_t)err_code);
     }
 }
 
@@ -952,6 +942,10 @@ static void sd_evt_handler(uint32_t evt_id) {
             // unhandled event!
             break;
     }
+#if MICROPY_HW_USB_CDC
+    // Farward SOC events to USB CDC driver.
+    usb_cdc_sd_event_handler(evt_id);
+#endif
 }
 
 static void ble_evt_handler(ble_evt_t * p_ble_evt) {
diff --git a/ports/nrf/drivers/bluetooth/ble_uart.c b/ports/nrf/drivers/bluetooth/ble_uart.c
index 4a23cd6d2cc2c..b94780e26011b 100644
--- a/ports/nrf/drivers/bluetooth/ble_uart.c
+++ b/ports/nrf/drivers/bluetooth/ble_uart.c
@@ -190,7 +190,7 @@ void ble_uart_init0(void) {
     ble_uart_char_tx.service_handle = ble_uart_service.handle;
     bool retval = ble_drv_characteristic_add(&ble_uart_char_tx);
     if (retval) {
-    	ble_uart_char_tx.p_service = &ble_uart_service;
+        ble_uart_char_tx.p_service = &ble_uart_service;
     }
     mp_obj_list_append(ble_uart_service.char_list, MP_OBJ_FROM_PTR(&ble_uart_char_tx));
 
@@ -198,7 +198,7 @@ void ble_uart_init0(void) {
     ble_uart_char_rx.service_handle = ble_uart_service.handle;
     retval = ble_drv_characteristic_add(&ble_uart_char_rx);
     if (retval) {
-    	ble_uart_char_rx.p_service = &ble_uart_service;
+        ble_uart_char_rx.p_service = &ble_uart_service;
     }
     mp_obj_list_append(ble_uart_service.char_list, MP_OBJ_FROM_PTR(&ble_uart_char_rx));
 
diff --git a/ports/nrf/drivers/flash.h b/ports/nrf/drivers/flash.h
index 7e6fff37a97bb..ed53afd81bff6 100644
--- a/ports/nrf/drivers/flash.h
+++ b/ports/nrf/drivers/flash.h
@@ -27,13 +27,17 @@
 #ifndef __MICROPY_INCLUDED_LIB_FLASH_H__
 #define __MICROPY_INCLUDED_LIB_FLASH_H__
 
-#include "nrf_nvmc.h"
+#include "nrfx_nvmc.h"
 
 #if defined(NRF51)
 #define FLASH_PAGESIZE (1024)
 
 #elif defined(NRF52_SERIES)
 #define FLASH_PAGESIZE (4096)
+
+#elif defined(NRF91_SERIES)
+#define FLASH_PAGESIZE (4096)
+
 #else
 #error Unknown chip
 #endif
@@ -55,9 +59,9 @@ void flash_operation_finished(flash_state_t result);
 
 #else
 
-#define flash_page_erase nrf_nvmc_page_erase
-#define flash_write_byte nrf_nvmc_write_byte
-#define flash_write_bytes nrf_nvmc_write_bytes
+#define flash_page_erase nrfx_nvmc_page_erase
+#define flash_write_byte nrfx_nvmc_byte_write
+#define flash_write_bytes nrfx_nvmc_bytes_write
 
 #endif
 
diff --git a/ports/nrf/drivers/rng.c b/ports/nrf/drivers/rng.c
new file mode 100644
index 0000000000000..2737c74c4bfcb
--- /dev/null
+++ b/ports/nrf/drivers/rng.c
@@ -0,0 +1,79 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2017-2018 Glenn Ruben Bakke
+ * Copyright (c) 2018 Ayke van Laethem
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+
+#if MICROPY_HW_ENABLE_RNG
+
+#include "nrf_rng.h"
+#include "drivers/rng.h"
+
+#if BLUETOOTH_SD
+#include "nrf_soc.h"
+#include "ble_drv.h"
+#define BLUETOOTH_STACK_ENABLED() (ble_drv_stack_enabled())
+#endif
+
+static inline uint32_t generate_hw_random(void) {
+    uint32_t retval = 0;
+    uint8_t * p_retval = (uint8_t *)&retval;
+
+    nrf_rng_event_clear(NRF_RNG, NRF_RNG_EVENT_VALRDY);
+    nrf_rng_task_trigger(NRF_RNG, NRF_RNG_TASK_START);
+
+    for (uint16_t i = 0; i < 4; i++) {
+        while (!nrf_rng_event_check(NRF_RNG, NRF_RNG_EVENT_VALRDY)) {
+            ;
+        }
+
+        nrf_rng_event_clear(NRF_RNG, NRF_RNG_EVENT_VALRDY);
+        p_retval[i] = nrf_rng_random_value_get(NRF_RNG);
+    }
+
+    nrf_rng_task_trigger(NRF_RNG, NRF_RNG_TASK_STOP);
+
+    return retval;
+}
+
+uint32_t rng_generate_random_word(void) {
+
+#if BLUETOOTH_SD
+    if (BLUETOOTH_STACK_ENABLED() == 1) {
+        uint32_t retval = 0;
+        uint32_t status;
+        do {
+            status = sd_rand_application_vector_get((uint8_t *)&retval, 4); // Extract 4 bytes
+        } while (status != 0);
+
+        return retval;
+    }
+#endif
+
+    return generate_hw_random();
+}
+
+#endif // MICROPY_HW_ENABLE_RNG
diff --git a/ports/nrf/modules/random/modrandom.h b/ports/nrf/drivers/rng.h
similarity index 96%
rename from ports/nrf/modules/random/modrandom.h
rename to ports/nrf/drivers/rng.h
index 6a6b605c78b44..2fe49773f8bda 100644
--- a/ports/nrf/modules/random/modrandom.h
+++ b/ports/nrf/drivers/rng.h
@@ -24,4 +24,4 @@
  * THE SOFTWARE.
  */
 
-uint32_t machine_rng_generate_random_word(void);
+uint32_t rng_generate_random_word(void);
diff --git a/ports/nrf/drivers/secureboot/secureboot.mk b/ports/nrf/drivers/secureboot/secureboot.mk
new file mode 100644
index 0000000000000..89833cb6def16
--- /dev/null
+++ b/ports/nrf/drivers/secureboot/secureboot.mk
@@ -0,0 +1,55 @@
+DRIVERS_SECUREBOOT_DIR = drivers/secureboot
+
+SRC_SECUREBOOT += $(addprefix $(DRIVERS_SECUREBOOT_DIR)/,\
+        secureboot_main.c \
+        )
+
+SRC_SECUREBOOT += $(addprefix device/,\
+        startup_nrf9160.c \
+        )
+
+SRC_SECUREBOOT += $(addprefix $(TOP)/lib/nrfx/mdk/,\
+        system_nrf9160.c \
+        )
+
+.PHONY: secureboot clean
+
+INC_SECUREBOOT += -I./../../lib/nrfx/mdk
+INC_SECUREBOOT += -I./../../lib/cmsis/inc
+
+MCU_SERIES = m33
+
+CFLAGS_CORTEX_M = -mthumb -mabi=aapcs -fsingle-precision-constant -Wdouble-promotion
+
+CFLAGS_MCU_m33 = $(CFLAGS_CORTEX_M) -mcpu=cortex-m33 -march=armv8-m.main+dsp -mcmse -mfpu=fpv5-sp-d16 -mfloat-abi=hard
+
+
+CFLAGS_SECUREBOOT += -DNRF9160_XXAA
+CFLAGS_SECUREBOOT += $(CFLAGS_MCU_$(MCU_SERIES))
+CFLAGS_SECUREBOOT += -Wall -Werror -g -ansi -std=c11 -nostdlib $(COPT)
+CFLAGS_SECUREBOOT += -fno-strict-aliasing
+
+LD_FILES_SECUREBOOT += nrf9160_1M_256k_secure.ld common.ld
+
+LDFLAGS_SECUREBOOT = $(CFLAGS_SECUREBOOT)
+LDFLAGS_SECUREBOOT += -Xlinker -Map=$(@:.elf=.map)
+LDFLAGS_SECUREBOOT += -mthumb -mabi=aapcs $(addprefix -T,$(LD_FILES_SECUREBOOT)) -L ./boards
+
+CC = arm-none-eabi-gcc
+SIZE = arm-none-eabi-size
+OBJCOPY = arm-none-eabi-objcopy
+
+LIBGCC_FILE_NAME = $(shell $(CC) $(CFLAGS_SECUREBOOT) -print-libgcc-file-name)
+LIBC_FILE_NAME = $(shell $(CC) $(CFLAGS_SECUREBOOT) -print-file-name=libc.a)
+LIBS_SECUREBOOT += -L $(dir $(LIBGCC_FILE_NAME)) -lgcc
+LIBS_SECUREBOOT += -L $(dir $(LIBC_FILE_NAME)) -lc
+
+$(BUILD)/secureboot.elf:
+	$(Q)$(CC) $(LDFLAGS_SECUREBOOT) $(SRC_SECUREBOOT) $(INC_SECUREBOOT) -O3 -o $@ $(LIBS_SECUREBOOT)
+	$(SIZE) $@
+
+$(BUILD)/secureboot.hex: $(BUILD)/secureboot.elf
+	$(OBJCOPY) -O ihex $< $@
+
+secureboot: $(BUILD)/secureboot.hex
+	@echo "Secure boot"
diff --git a/ports/nrf/drivers/secureboot/secureboot_main.c b/ports/nrf/drivers/secureboot/secureboot_main.c
new file mode 100644
index 0000000000000..748e080a24fe2
--- /dev/null
+++ b/ports/nrf/drivers/secureboot/secureboot_main.c
@@ -0,0 +1,194 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Glenn Ruben Bakke
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <arm_cmse.h>
+#include <nrf.h>
+
+// Secure flash 32K.
+#define SECURE_32K_FLASH_PAGE_START    (0)
+#define SECURE_32K_FLASH_PAGE_END      (0)
+
+// Non-secure flash 992K.
+#define NONSECURE_32K_FLASH_PAGE_START (1)
+#define NONSECURE_32K_FLASH_PAGE_END   (31)
+
+// Secure RAM 64K.
+#define SECURE_8K_RAM_BLOCK_START      (0)
+#define SECURE_8K_RAM_BLOCK_END        (7)
+
+// Non-secure RAM 128K + 64K BSD lib.
+#define NONSECURE_8K_RAM_BLOCK_START   (8)
+#define NONSECURE_8K_RAM_BLOCK_END     (31)
+
+#define PERIPHERAL_ID_GET(base_addr) (((uint32_t)(base_addr) >> 12) & 0xFF)
+
+#if !defined(__ARM_FEATURE_CMSE)
+    #pragma warning "CMSE not enabled"
+#endif
+
+static void configure_flash(void) {
+    for (uint8_t i = SECURE_32K_FLASH_PAGE_START; i <= SECURE_32K_FLASH_PAGE_END; i++) {
+        uint32_t perm = 0;
+        perm |= (SPU_FLASHREGION_PERM_EXECUTE_Enable << SPU_FLASHREGION_PERM_EXECUTE_Pos);
+        perm |= (SPU_FLASHREGION_PERM_WRITE_Enable   << SPU_FLASHREGION_PERM_WRITE_Pos);
+        perm |= (SPU_FLASHREGION_PERM_READ_Enable    << SPU_FLASHREGION_PERM_READ_Pos);
+        perm |= (SPU_FLASHREGION_PERM_LOCK_Locked    << SPU_FLASHREGION_PERM_LOCK_Pos);
+        perm |= (SPU_FLASHREGION_PERM_SECATTR_Secure << SPU_FLASHREGION_PERM_SECATTR_Pos);
+        NRF_SPU_S->FLASHREGION[i].PERM = perm;
+    }
+
+    for (uint8_t i = NONSECURE_32K_FLASH_PAGE_START; i <= NONSECURE_32K_FLASH_PAGE_END; i++) {
+        uint32_t perm = 0;
+        perm |= (SPU_FLASHREGION_PERM_EXECUTE_Enable     << SPU_FLASHREGION_PERM_EXECUTE_Pos);
+        perm |= (SPU_FLASHREGION_PERM_WRITE_Enable       << SPU_FLASHREGION_PERM_WRITE_Pos);
+        perm |= (SPU_FLASHREGION_PERM_READ_Enable        << SPU_FLASHREGION_PERM_READ_Pos);
+        perm |= (SPU_FLASHREGION_PERM_LOCK_Locked        << SPU_FLASHREGION_PERM_LOCK_Pos);
+        perm |= (SPU_FLASHREGION_PERM_SECATTR_Non_Secure << SPU_FLASHREGION_PERM_SECATTR_Pos);
+        NRF_SPU_S->FLASHREGION[i].PERM = perm;
+    }
+}
+
+static void configure_ram(void) {
+    for (uint8_t i = SECURE_8K_RAM_BLOCK_START; i <= SECURE_8K_RAM_BLOCK_END; i++) {
+        uint32_t perm = 0;
+        perm |= (SPU_RAMREGION_PERM_EXECUTE_Enable << SPU_RAMREGION_PERM_EXECUTE_Pos);
+        perm |= (SPU_RAMREGION_PERM_WRITE_Enable << SPU_RAMREGION_PERM_WRITE_Pos);
+        perm |= (SPU_RAMREGION_PERM_READ_Enable << SPU_RAMREGION_PERM_READ_Pos);
+        perm |= (SPU_RAMREGION_PERM_LOCK_Locked << SPU_RAMREGION_PERM_LOCK_Pos);
+        perm |= (SPU_RAMREGION_PERM_SECATTR_Secure << SPU_RAMREGION_PERM_SECATTR_Pos);
+        NRF_SPU_S->RAMREGION[i].PERM = perm;
+    }
+
+    for (uint8_t i = NONSECURE_8K_RAM_BLOCK_START; i <= NONSECURE_8K_RAM_BLOCK_END; i++) {
+        uint32_t perm = 0;
+        perm |= (SPU_RAMREGION_PERM_EXECUTE_Enable << SPU_RAMREGION_PERM_EXECUTE_Pos);
+        perm |= (SPU_RAMREGION_PERM_WRITE_Enable << SPU_RAMREGION_PERM_WRITE_Pos);
+        perm |= (SPU_RAMREGION_PERM_READ_Enable << SPU_RAMREGION_PERM_READ_Pos);
+        perm |= (SPU_RAMREGION_PERM_LOCK_Locked << SPU_RAMREGION_PERM_LOCK_Pos);
+        perm |= (SPU_RAMREGION_PERM_SECATTR_Non_Secure << SPU_RAMREGION_PERM_SECATTR_Pos);
+        NRF_SPU_S->RAMREGION[i].PERM = perm;
+    }
+}
+
+static void peripheral_setup(uint8_t peripheral_id)
+{
+    NVIC_DisableIRQ(peripheral_id);
+    uint32_t perm = 0;
+    perm |= (SPU_PERIPHID_PERM_PRESENT_IsPresent << SPU_PERIPHID_PERM_PRESENT_Pos);
+    perm |= (SPU_PERIPHID_PERM_SECATTR_NonSecure << SPU_PERIPHID_PERM_SECATTR_Pos);
+    perm |= (SPU_PERIPHID_PERM_LOCK_Locked << SPU_PERIPHID_PERM_LOCK_Pos);
+    NRF_SPU_S->PERIPHID[peripheral_id].PERM = perm;
+
+    NVIC_SetTargetState(peripheral_id);
+}
+
+static void configure_peripherals(void)
+{
+    NRF_SPU_S->GPIOPORT[0].PERM = 0;
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_REGULATORS_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_CLOCK_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_UARTE0_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_UARTE1_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_UARTE2_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_UARTE3_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_SAADC_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_TIMER0_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_TIMER1_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_TIMER2_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_RTC0_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_RTC1_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_DPPIC_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_WDT_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_EGU1_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_EGU2_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_EGU3_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_EGU4_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_EGU5_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_PWM0_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_PWM1_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_PWM2_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_PWM3_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_PDM_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_I2S_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_IPC_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_FPU_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_GPIOTE1_NS));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_NVMC_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_VMC_S));
+    peripheral_setup(PERIPHERAL_ID_GET(NRF_P0_NS));
+}
+
+typedef void __attribute__((cmse_nonsecure_call)) nsfunc(void);
+
+static void jump_to_non_secure(void)
+{
+    TZ_SAU_Disable();
+    SAU->CTRL |= SAU_CTRL_ALLNS_Msk;
+
+    // Set NS vector table.
+    uint32_t * vtor_ns = (uint32_t *)0x8000;
+    SCB_NS->VTOR = (uint32_t)vtor_ns;
+
+    // Allow for FPU to be used by NS.
+    SCB->NSACR |= (1UL << SCB_NSACR_CP10_Pos) | (1UL << SCB_NSACR_CP11_Pos);
+
+    // Set stack pointers.
+    __TZ_set_MSP_NS(vtor_ns[0]);
+    __TZ_set_PSP_NS(0);
+
+    uint32_t control_ns = __TZ_get_CONTROL_NS();
+    control_ns &= ~(CONTROL_SPSEL_Msk | CONTROL_nPRIV_Msk);
+    __TZ_set_CONTROL_NS(control_ns);
+
+    // Cast NS Reset_Handler to a non-secure function.
+    nsfunc *fp = (nsfunc *)vtor_ns[1];
+    fp =  (nsfunc *)((intptr_t)(fp) & ~1);
+
+    if (cmse_is_nsfptr(fp)) {
+        __DSB();
+        __ISB();
+
+        // Jump to Non-Secure function.
+        fp();
+    }
+}
+
+int main(void) {
+    configure_flash();
+    configure_ram();
+    configure_peripherals();
+
+    jump_to_non_secure();
+
+    while (1) {
+	;
+    }
+
+    return 0;
+}
+
+void _start(void) {main();}
+
diff --git a/ports/nrf/drivers/ticker.h b/ports/nrf/drivers/ticker.h
index f6a95a9a25751..86f1c244778b0 100644
--- a/ports/nrf/drivers/ticker.h
+++ b/ports/nrf/drivers/ticker.h
@@ -35,7 +35,7 @@
 #define __MICROPY_INCLUDED_LIB_TICKER_H__
 
 /*************************************
- * 62.5kHz (16µs cycle time) ticker.
+ * 62.5kHz (16us cycle time) ticker.
  ************************************/
 
 #include "nrf.h"
diff --git a/ports/nrf/drivers/usb/tusb_config.h b/ports/nrf/drivers/usb/tusb_config.h
new file mode 100644
index 0000000000000..619578ad6ee3a
--- /dev/null
+++ b/ports/nrf/drivers/usb/tusb_config.h
@@ -0,0 +1,44 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_NRF_TUSB_CONFIG_H
+#define MICROPY_INCLUDED_NRF_TUSB_CONFIG_H
+
+// Common configuration
+
+#define CFG_TUSB_MCU                OPT_MCU_NRF5X
+#define CFG_TUSB_RHPORT0_MODE       OPT_MODE_DEVICE
+
+#define CFG_TUSB_MEM_SECTION
+#define CFG_TUSB_MEM_ALIGN          TU_ATTR_ALIGNED(4)
+
+// Device configuration
+
+#define CFG_TUD_ENDOINT0_SIZE       (64)
+#define CFG_TUD_CDC                 (1)
+#define CFG_TUD_CDC_RX_BUFSIZE      (64)
+#define CFG_TUD_CDC_TX_BUFSIZE      (64)
+
+#endif // MICROPY_INCLUDED_NRF_TUSB_CONFIG_H
diff --git a/ports/nrf/drivers/usb/usb_cdc.c b/ports/nrf/drivers/usb/usb_cdc.c
new file mode 100644
index 0000000000000..c90bced6bb563
--- /dev/null
+++ b/ports/nrf/drivers/usb/usb_cdc.c
@@ -0,0 +1,226 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Ha Thach (tinyusb.org)
+ * Copyright (c) 2019 Glenn Ruben Bakke
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * This file is part of the TinyUSB stack.
+ */
+
+#include "py/mphal.h"
+
+#if MICROPY_HW_USB_CDC
+
+#include "tusb.h"
+#include "nrfx.h"
+#include "nrfx_power.h"
+#include "nrfx_uart.h"
+#include "py/ringbuf.h"
+
+#ifdef BLUETOOTH_SD
+#include "nrf_sdm.h"
+#include "nrf_soc.h"
+#include "ble_drv.h"
+#endif
+
+extern void tusb_hal_nrf_power_event(uint32_t event);
+
+static void cdc_task(void);
+
+static uint8_t rx_ringbuf_array[1024];
+static uint8_t tx_ringbuf_array[1024];
+static volatile ringbuf_t rx_ringbuf;
+static volatile ringbuf_t tx_ringbuf;
+
+static void board_init(void) {
+    // Config clock source.
+#ifndef BLUETOOTH_SD
+    NRF_CLOCK->LFCLKSRC = (uint32_t)((CLOCK_LFCLKSRC_SRC_Xtal << CLOCK_LFCLKSRC_SRC_Pos) & CLOCK_LFCLKSRC_SRC_Msk);
+    NRF_CLOCK->TASKS_LFCLKSTART = 1UL;
+#endif
+
+    // Priorities 0, 1, 4 (nRF52) are reserved for SoftDevice
+    // 2 is highest for application
+    NRFX_IRQ_PRIORITY_SET(USBD_IRQn, 2);
+
+    // USB power may already be ready at this time -> no event generated
+    // We need to invoke the handler based on the status initially
+    uint32_t usb_reg;
+
+#ifdef BLUETOOTH_SD
+    uint8_t sd_en = false;
+    sd_softdevice_is_enabled(&sd_en);
+
+    if (sd_en) {
+        sd_power_usbdetected_enable(true);
+        sd_power_usbpwrrdy_enable(true);
+        sd_power_usbremoved_enable(true);
+
+        sd_power_usbregstatus_get(&usb_reg);
+    } else
+#endif
+    {
+        // Power module init
+        const nrfx_power_config_t pwr_cfg = { 0 };
+        nrfx_power_init(&pwr_cfg);
+
+        // Register tusb function as USB power handler
+        const nrfx_power_usbevt_config_t config = { .handler = (nrfx_power_usb_event_handler_t) tusb_hal_nrf_power_event };
+        nrfx_power_usbevt_init(&config);
+
+        nrfx_power_usbevt_enable();
+
+        usb_reg = NRF_POWER->USBREGSTATUS;
+    }
+
+    if (usb_reg & POWER_USBREGSTATUS_VBUSDETECT_Msk) {
+        tusb_hal_nrf_power_event(NRFX_POWER_USB_EVT_DETECTED);
+    }
+
+#ifndef BLUETOOTH_SD
+    if (usb_reg & POWER_USBREGSTATUS_OUTPUTRDY_Msk) {
+        tusb_hal_nrf_power_event(NRFX_POWER_USB_EVT_READY);
+    }
+#endif
+}
+
+static bool cdc_rx_any(void) {
+    return rx_ringbuf.iput != rx_ringbuf.iget;
+}
+
+static int cdc_rx_char(void) {
+    return ringbuf_get((ringbuf_t*)&rx_ringbuf);
+}
+
+static bool cdc_tx_any(void) {
+    return tx_ringbuf.iput != tx_ringbuf.iget;
+}
+
+static int cdc_tx_char(void) {
+    return ringbuf_get((ringbuf_t*)&tx_ringbuf);
+}
+
+static void cdc_task(void)
+{
+    if ( tud_cdc_connected() ) {
+        // connected and there are data available
+        while (tud_cdc_available()) {
+            int c;
+            uint32_t count = tud_cdc_read(&c, 1);
+            (void)count;
+            ringbuf_put((ringbuf_t*)&rx_ringbuf, c);
+        }
+
+        int chars = 0;
+        while (cdc_tx_any()) {
+            if (chars < 64) {
+               tud_cdc_write_char(cdc_tx_char());
+               chars++;
+            } else {
+               chars = 0;
+               tud_cdc_write_flush();
+            }
+        }
+
+        tud_cdc_write_flush();
+    }
+}
+
+static void usb_cdc_loop(void) {
+    tud_task();
+    cdc_task();
+}
+
+int usb_cdc_init(void)
+{
+    static bool initialized = false;
+    if (!initialized) {
+
+#if BLUETOOTH_SD
+        // Initialize the clock and BLE stack.
+        ble_drv_stack_enable();
+#endif
+
+        board_init();
+        initialized = true;
+    }
+
+    rx_ringbuf.buf = rx_ringbuf_array;
+    rx_ringbuf.size = sizeof(rx_ringbuf_array);
+    rx_ringbuf.iget = 0;
+    rx_ringbuf.iput = 0;
+
+    tx_ringbuf.buf = tx_ringbuf_array;
+    tx_ringbuf.size = sizeof(tx_ringbuf_array);
+    tx_ringbuf.iget = 0;
+    tx_ringbuf.iput = 0;
+
+    tusb_init();
+
+    return 0;
+}
+
+#ifdef BLUETOOTH_SD
+// process SOC event from SD
+void usb_cdc_sd_event_handler(uint32_t soc_evt) {
+    /*------------- usb power event handler -------------*/
+    int32_t usbevt = (soc_evt == NRF_EVT_POWER_USB_DETECTED   ) ? NRFX_POWER_USB_EVT_DETECTED:
+                     (soc_evt == NRF_EVT_POWER_USB_POWER_READY) ? NRFX_POWER_USB_EVT_READY   :
+                     (soc_evt == NRF_EVT_POWER_USB_REMOVED    ) ? NRFX_POWER_USB_EVT_REMOVED : -1;
+
+    if (usbevt >= 0) {
+        tusb_hal_nrf_power_event(usbevt);
+    }
+}
+#endif
+
+int mp_hal_stdin_rx_chr(void) {
+    for (;;) {
+        usb_cdc_loop();
+        if (cdc_rx_any()) {
+            return cdc_rx_char();
+        }
+    }
+
+    return 0;
+}
+
+void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) {
+
+    for (const char *top = str + len; str < top; str++) {
+        ringbuf_put((ringbuf_t*)&tx_ringbuf, *str);
+        usb_cdc_loop();
+    }
+}
+
+void mp_hal_stdout_tx_strn_cooked(const char *str, mp_uint_t len) {
+
+    for (const char *top = str + len; str < top; str++) {
+        if (*str == '\n') {
+            ringbuf_put((ringbuf_t*)&tx_ringbuf, '\r');
+            usb_cdc_loop();
+        }
+        ringbuf_put((ringbuf_t*)&tx_ringbuf, *str);
+        usb_cdc_loop();
+    }
+}
+
+#endif // MICROPY_HW_USB_CDC
diff --git a/ports/nrf/drivers/usb/usb_cdc.h b/ports/nrf/drivers/usb/usb_cdc.h
new file mode 100644
index 0000000000000..7cd94f85ba27b
--- /dev/null
+++ b/ports/nrf/drivers/usb/usb_cdc.h
@@ -0,0 +1,40 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Glenn Ruben Bakke
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef NRF_DRIVERS_USB_CDC_H__
+#define NRF_DRIVERS_USB_CDC_H__
+
+#include "tusb.h"
+
+void usb_cdc_init(void);
+
+void usb_cdc_loop(void);
+int  usb_cdc_read_char(void);
+void usb_cdc_write_char(char c);
+
+void usb_cdc_sd_event_handler(uint32_t soc_evt);
+
+#endif // NRF_DRIVERS_USB_CDC_H__
diff --git a/ports/nrf/drivers/usb/usb_descriptors.c b/ports/nrf/drivers/usb/usb_descriptors.c
new file mode 100644
index 0000000000000..3704e5d0dd180
--- /dev/null
+++ b/ports/nrf/drivers/usb/usb_descriptors.c
@@ -0,0 +1,114 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "tusb.h"
+
+#define USBD_VID (0xf055)
+#define USBD_PID (0x9802)
+
+#define USBD_DESC_LEN (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN)
+#define USBD_MAX_POWER_MA (250)
+
+#define USBD_ITF_CDC (0) // needs 2 interfaces
+#define USBD_ITF_MAX (2)
+
+#define USBD_CDC_EP_CMD (0x81)
+#define USBD_CDC_EP_OUT (0x02)
+#define USBD_CDC_EP_IN (0x82)
+#define USBD_CDC_CMD_MAX_SIZE (8)
+
+#define USBD_STR_0 (0x00)
+#define USBD_STR_MANUF (0x01)
+#define USBD_STR_PRODUCT (0x02)
+#define USBD_STR_SERIAL (0x03)
+#define USBD_STR_CDC (0x04)
+
+// Note: descriptors returned from callbacks must exist long enough for transfer to complete
+
+static const tusb_desc_device_t usbd_desc_device = {
+    .bLength            = sizeof(tusb_desc_device_t),
+    .bDescriptorType    = TUSB_DESC_DEVICE,
+    .bcdUSB             = 0x0200,
+    .bDeviceClass       = TUSB_CLASS_MISC,
+    .bDeviceSubClass    = MISC_SUBCLASS_COMMON,
+    .bDeviceProtocol    = MISC_PROTOCOL_IAD,
+    .bMaxPacketSize0    = CFG_TUD_ENDOINT0_SIZE,
+    .idVendor           = USBD_VID,
+    .idProduct          = USBD_PID,
+    .bcdDevice          = 0x0100,
+    .iManufacturer      = USBD_STR_MANUF,
+    .iProduct           = USBD_STR_PRODUCT,
+    .iSerialNumber      = USBD_STR_SERIAL,
+    .bNumConfigurations = 1,
+};
+
+static const uint8_t usbd_desc_cfg[USBD_DESC_LEN] = {
+    TUD_CONFIG_DESCRIPTOR(USBD_ITF_MAX, USBD_STR_0, USBD_DESC_LEN,
+        TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, USBD_MAX_POWER_MA),
+
+    TUD_CDC_DESCRIPTOR(USBD_ITF_CDC, USBD_STR_CDC, USBD_CDC_EP_CMD,
+        USBD_CDC_CMD_MAX_SIZE, USBD_CDC_EP_OUT, USBD_CDC_EP_IN, CFG_TUD_CDC_RX_BUFSIZE),
+};
+
+static const char *const usbd_desc_str[] = {
+    [USBD_STR_MANUF] = "MicroPython",
+    [USBD_STR_PRODUCT] = "Board in FS mode",
+    [USBD_STR_SERIAL] = "000000000000", // TODO
+    [USBD_STR_CDC] = "Board CDC",
+};
+
+const uint8_t *tud_descriptor_device_cb(void) {
+    return (const uint8_t*)&usbd_desc_device;
+}
+
+const uint8_t *tud_descriptor_configuration_cb(uint8_t index) {
+    (void)index;
+    return usbd_desc_cfg;
+}
+
+const uint16_t *tud_descriptor_string_cb(uint8_t index) {
+    #define DESC_STR_MAX (20)
+    static uint16_t desc_str[DESC_STR_MAX];
+
+    uint8_t len;
+    if (index == 0) {
+        desc_str[1] = 0x0409; // supported language is English
+        len = 1;
+    } else {
+        if (index >= sizeof(usbd_desc_str) / sizeof(usbd_desc_str[0])) {
+            return NULL;
+        }
+        const char* str = usbd_desc_str[index];
+        for (len = 0; len < DESC_STR_MAX - 1 && str[len]; ++len) {
+            desc_str[1 + len] = str[len];
+        }
+    }
+
+    // first byte is length (including header), second byte is string type
+    desc_str[0] = (TUSB_DESC_STRING << 8 ) | (2 * len + 2);
+
+    return desc_str;
+}
diff --git a/ports/nrf/examples/mountsd.py b/ports/nrf/examples/mountsd.py
index 64e1c888bea18..315205c6959b0 100644
--- a/ports/nrf/examples/mountsd.py
+++ b/ports/nrf/examples/mountsd.py
@@ -4,7 +4,7 @@
 and list a sdcard connected over SPI.
 
 
-Direct wireing on SD card (SPI):
+Direct wiring on SD card (SPI):
    ______________________________
   |                              \
   |             9.    | NC    |   \
@@ -24,12 +24,13 @@
 from machine import SPI, Pin
 from sdcard import SDCard
 
+
 def mnt():
     cs = Pin("P22", mode=Pin.OUT)
     sd = SDCard(SPI(0), cs)
-    os.mount(sd, '/')
+    os.mount(sd, "/")
+
 
 def list():
     files = os.listdir()
     print(files)
-
diff --git a/ports/nrf/examples/musictest.py b/ports/nrf/examples/musictest.py
index 46276d3ef3f43..8f4523877c379 100644
--- a/ports/nrf/examples/musictest.py
+++ b/ports/nrf/examples/musictest.py
@@ -1,4 +1,4 @@
-# 
+#
 # Example usage where "P3" is the Buzzer pin.
 #
 #  from musictest import play
@@ -8,6 +8,7 @@
 from machine import Pin
 import music
 
+
 def play(pin_str):
     p = Pin(pin_str, mode=Pin.OUT)
     music.play(music.PRELUDE, pin=p)
diff --git a/ports/nrf/examples/nrf52_pwm.py b/ports/nrf/examples/nrf52_pwm.py
index b242ea90e686e..ce3fa3205b6c0 100644
--- a/ports/nrf/examples/nrf52_pwm.py
+++ b/ports/nrf/examples/nrf52_pwm.py
@@ -1,6 +1,7 @@
 import time
 from machine import PWM, Pin
 
+
 def pulse():
     for i in range(0, 101):
         p = PWM(0, Pin("P17", mode=Pin.OUT), freq=PWM.FREQ_16MHZ, duty=i, period=16000)
@@ -9,7 +10,7 @@ def pulse():
         p.deinit()
 
     for i in range(0, 101):
-        p = PWM(0, Pin("P17", mode=Pin.OUT), freq=PWM.FREQ_16MHZ, duty=100-i, period=16000)
+        p = PWM(0, Pin("P17", mode=Pin.OUT), freq=PWM.FREQ_16MHZ, duty=100 - i, period=16000)
         p.init()
         time.sleep_ms(10)
         p.deinit()
diff --git a/ports/nrf/examples/nrf52_servo.py b/ports/nrf/examples/nrf52_servo.py
index baa8600a5884d..5506303ab7256 100644
--- a/ports/nrf/examples/nrf52_servo.py
+++ b/ports/nrf/examples/nrf52_servo.py
@@ -25,26 +25,34 @@
 import time
 from machine import PWM, Pin
 
-class Servo():
+
+class Servo:
     def __init__(self, pin_name=""):
         if pin_name:
             self.pin = Pin(pin_name, mode=Pin.OUT, pull=Pin.PULL_DOWN)
         else:
             self.pin = Pin("P22", mode=Pin.OUT, pull=Pin.PULL_DOWN)
+
     def left(self):
-        p = PWM(0, self.pin, freq=PWM.FREQ_125KHZ, pulse_width=105, period=2500, mode=PWM.MODE_HIGH_LOW)
+        p = PWM(
+            0, self.pin, freq=PWM.FREQ_125KHZ, pulse_width=105, period=2500, mode=PWM.MODE_HIGH_LOW
+        )
         p.init()
         time.sleep_ms(200)
         p.deinit()
-        
+
     def center(self):
-        p = PWM(0, self.pin, freq=PWM.FREQ_125KHZ, pulse_width=188, period=2500, mode=PWM.MODE_HIGH_LOW)
+        p = PWM(
+            0, self.pin, freq=PWM.FREQ_125KHZ, pulse_width=188, period=2500, mode=PWM.MODE_HIGH_LOW
+        )
         p.init()
         time.sleep_ms(200)
         p.deinit()
-        
+
     def right(self):
-        p = PWM(0, self.pin, freq=PWM.FREQ_125KHZ, pulse_width=275, period=2500, mode=PWM.MODE_HIGH_LOW)
+        p = PWM(
+            0, self.pin, freq=PWM.FREQ_125KHZ, pulse_width=275, period=2500, mode=PWM.MODE_HIGH_LOW
+        )
         p.init()
         time.sleep_ms(200)
         p.deinit()
diff --git a/ports/nrf/examples/powerup.py b/ports/nrf/examples/powerup.py
index 6f14309f39f34..2ecc63971c408 100644
--- a/ports/nrf/examples/powerup.py
+++ b/ports/nrf/examples/powerup.py
@@ -41,22 +41,25 @@
 from machine import Pin
 from ubluepy import Peripheral, Scanner, constants
 
+
 def bytes_to_str(bytes):
     string = ""
     for b in bytes:
         string += chr(b)
     return string
 
+
 def get_device_names(scan_entries):
     dev_names = []
     for e in scan_entries:
         scan = e.getScanData()
         if scan:
             for s in scan:
-               if s[0] == constants.ad_types.AD_TYPE_COMPLETE_LOCAL_NAME:
-                   dev_names.append((e, bytes_to_str(s[2])))
+                if s[0] == constants.ad_types.AD_TYPE_COMPLETE_LOCAL_NAME:
+                    dev_names.append((e, bytes_to_str(s[2])))
     return dev_names
 
+
 def find_device_by_name(name):
     s = Scanner()
     scan_res = s.scan(500)
@@ -66,6 +69,7 @@ def find_device_by_name(name):
         if name == dev[1]:
             return dev[0]
 
+
 class PowerUp3:
     def __init__(self):
         self.x_adc = ADC(1)
@@ -76,14 +80,14 @@ def __init__(self):
         self.btn_speed_off = Pin("P16", mode=Pin.IN, pull=Pin.PULL_UP)
 
         self.x_mid = 0
-        
+
         self.calibrate()
         self.connect()
         self.loop()
-        
+
     def read_stick_x(self):
         return self.x_adc.value()
-        
+
     def button_speed_up(self):
         return not bool(self.btn_speed_up.value())
 
@@ -146,7 +150,7 @@ def rudder_center(self):
             self.angle(0)
 
     def rudder_left(self, angle):
-        steps = (angle // self.interval_size_left)
+        steps = angle // self.interval_size_left
         new_angle = 60 - steps
 
         if self.old_angle != new_angle:
@@ -154,7 +158,7 @@ def rudder_left(self, angle):
             self.old_angle = new_angle
 
     def rudder_right(self, angle):
-        steps = (angle // self.interval_size_right)
+        steps = angle // self.interval_size_right
         new_angle = -steps
 
         if self.old_angle != new_angle:
@@ -162,9 +166,9 @@ def rudder_right(self, angle):
             self.old_angle = new_angle
 
     def throttle(self, speed):
-        if (speed > 200):
+        if speed > 200:
             speed = 200
-        elif (speed < 0):
+        elif speed < 0:
             speed = 0
 
         if self.old_speed != speed:
@@ -188,10 +192,10 @@ def loop(self):
 
             # read out new angle
             new_angle = self.read_stick_x()
-            if (new_angle < 256):
-                if (new_angle > right_threshold):
+            if new_angle < 256:
+                if new_angle > right_threshold:
                     self.rudder_right(new_angle - self.x_mid)
-                elif (new_angle < left_threshold):
+                elif new_angle < left_threshold:
                     self.rudder_left(new_angle)
                 else:
                     self.rudder_center()
diff --git a/ports/nrf/examples/seeed_tft.py b/ports/nrf/examples/seeed_tft.py
index c5cd4cc0a6007..bf246bed4f060 100644
--- a/ports/nrf/examples/seeed_tft.py
+++ b/ports/nrf/examples/seeed_tft.py
@@ -51,24 +51,28 @@
 from machine import SPI, Pin
 from sdcard import SDCard
 
+
 def mount_tf(self, mount_point="/"):
     sd = SDCard(SPI(0), Pin("P15", mode=Pin.OUT))
     os.mount(sd, mount_point)
 
+
 class ILI9341:
     def __init__(self, width, height):
         self.width = width
         self.height = height
         self.pages = self.height // 8
         self.buffer = bytearray(self.pages * self.width)
-        self.framebuf = framebuf.FrameBuffer(self.buffer, self.width, self.height, framebuf.MONO_VLSB)
+        self.framebuf = framebuf.FrameBuffer(
+            self.buffer, self.width, self.height, framebuf.MONO_VLSB
+        )
 
         self.spi = SPI(0)
         # chip select
         self.cs = Pin("P16", mode=Pin.OUT, pull=Pin.PULL_UP)
         # command
         self.dc = Pin("P17", mode=Pin.OUT, pull=Pin.PULL_UP)
-        
+
         # initialize all pins high
         self.cs.high()
         self.dc.high()
@@ -76,27 +80,26 @@ def __init__(self, width, height):
         self.spi.init(baudrate=8000000, phase=0, polarity=0)
 
         self.init_display()
-        
 
     def init_display(self):
         time.sleep_ms(500)
-        
+
         self.write_cmd(0x01)
-        
+
         time.sleep_ms(200)
-    
+
         self.write_cmd(0xCF)
         self.write_data(bytearray([0x00, 0x8B, 0x30]))
-    
+
         self.write_cmd(0xED)
         self.write_data(bytearray([0x67, 0x03, 0x12, 0x81]))
 
         self.write_cmd(0xE8)
         self.write_data(bytearray([0x85, 0x10, 0x7A]))
-    
+
         self.write_cmd(0xCB)
         self.write_data(bytearray([0x39, 0x2C, 0x00, 0x34, 0x02]))
-    
+
         self.write_cmd(0xF7)
         self.write_data(bytearray([0x20]))
 
@@ -107,54 +110,94 @@ def init_display(self):
         self.write_cmd(0xC0)
         # VRH[5:0]
         self.write_data(bytearray([0x1B]))
-        
+
         # Power control
         self.write_cmd(0xC1)
         # SAP[2:0];BT[3:0]
         self.write_data(bytearray([0x10]))
-        
+
         # VCM control
         self.write_cmd(0xC5)
         self.write_data(bytearray([0x3F, 0x3C]))
-    
+
         # VCM control2
         self.write_cmd(0xC7)
         self.write_data(bytearray([0xB7]))
-    
+
         # Memory Access Control
         self.write_cmd(0x36)
         self.write_data(bytearray([0x08]))
-    
+
         self.write_cmd(0x3A)
         self.write_data(bytearray([0x55]))
-    
+
         self.write_cmd(0xB1)
         self.write_data(bytearray([0x00, 0x1B]))
-        
+
         # Display Function Control
         self.write_cmd(0xB6)
         self.write_data(bytearray([0x0A, 0xA2]))
-    
+
         # 3Gamma Function Disable
         self.write_cmd(0xF2)
         self.write_data(bytearray([0x00]))
-        
+
         # Gamma curve selected
         self.write_cmd(0x26)
         self.write_data(bytearray([0x01]))
-    
+
         # Set Gamma
         self.write_cmd(0xE0)
-        self.write_data(bytearray([0x0F, 0x2A, 0x28, 0x08, 0x0E, 0x08, 0x54, 0XA9, 0x43, 0x0A, 0x0F, 0x00, 0x00, 0x00, 0x00]))
-    
+        self.write_data(
+            bytearray(
+                [
+                    0x0F,
+                    0x2A,
+                    0x28,
+                    0x08,
+                    0x0E,
+                    0x08,
+                    0x54,
+                    0xA9,
+                    0x43,
+                    0x0A,
+                    0x0F,
+                    0x00,
+                    0x00,
+                    0x00,
+                    0x00,
+                ]
+            )
+        )
+
         # Set Gamma
-        self.write_cmd(0XE1)
-        self.write_data(bytearray([0x00, 0x15, 0x17, 0x07, 0x11, 0x06, 0x2B, 0x56, 0x3C, 0x05, 0x10, 0x0F, 0x3F, 0x3F, 0x0F]))
-        
+        self.write_cmd(0xE1)
+        self.write_data(
+            bytearray(
+                [
+                    0x00,
+                    0x15,
+                    0x17,
+                    0x07,
+                    0x11,
+                    0x06,
+                    0x2B,
+                    0x56,
+                    0x3C,
+                    0x05,
+                    0x10,
+                    0x0F,
+                    0x3F,
+                    0x3F,
+                    0x0F,
+                ]
+            )
+        )
+
         # Exit Sleep
         self.write_cmd(0x11)
         time.sleep_ms(120)
-        
+
         # Display on
         self.write_cmd(0x29)
         time.sleep_ms(500)
@@ -164,14 +207,14 @@ def show(self):
         # set col
         self.write_cmd(0x2A)
         self.write_data(bytearray([0x00, 0x00]))
-        self.write_data(bytearray([0x00, 0xef]))
-        
-        # set page 
+        self.write_data(bytearray([0x00, 0xEF]))
+
+        # set page
         self.write_cmd(0x2B)
         self.write_data(bytearray([0x00, 0x00]))
-        self.write_data(bytearray([0x01, 0x3f]))
+        self.write_data(bytearray([0x01, 0x3F]))
 
-        self.write_cmd(0x2c);
+        self.write_cmd(0x2C)
 
         num_of_pixels = self.height * self.width
 
@@ -201,10 +244,9 @@ def write_cmd(self, cmd):
         self.cs.low()
         self.spi.write(bytearray([cmd]))
         self.cs.high()
-        
+
     def write_data(self, buf):
         self.dc.high()
         self.cs.low()
         self.spi.write(buf)
         self.cs.high()
-
diff --git a/ports/nrf/examples/ssd1306_mod.py b/ports/nrf/examples/ssd1306_mod.py
index d9614e54fb912..b083a3aa7e811 100644
--- a/ports/nrf/examples/ssd1306_mod.py
+++ b/ports/nrf/examples/ssd1306_mod.py
@@ -20,11 +20,11 @@
 
 from ssd1306 import SSD1306_I2C
 
-SET_COL_ADDR        = const(0x21)
-SET_PAGE_ADDR       = const(0x22)
+SET_COL_ADDR = const(0x21)
+SET_PAGE_ADDR = const(0x22)
 
-class SSD1306_I2C_Mod(SSD1306_I2C):
 
+class SSD1306_I2C_Mod(SSD1306_I2C):
     def show(self):
         x0 = 0
         x1 = self.width - 1
@@ -39,16 +39,15 @@ def show(self):
         self.write_cmd(0)
         self.write_cmd(self.pages - 1)
 
-        chunk_size = 254 # 255, excluding opcode.
+        chunk_size = 254  # 255, excluding opcode.
         num_of_chunks = len(self.buffer) // chunk_size
         leftover = len(self.buffer) - (num_of_chunks * chunk_size)
 
         for i in range(0, num_of_chunks):
-            self.write_data(self.buffer[chunk_size*i:chunk_size*(i+1)])
-        if (leftover > 0):
-            self.write_data(self.buffer[chunk_size * num_of_chunks:])
-
+            self.write_data(self.buffer[chunk_size * i : chunk_size * (i + 1)])
+        if leftover > 0:
+            self.write_data(self.buffer[chunk_size * num_of_chunks :])
 
     def write_data(self, buf):
-        buffer = bytearray([0x40]) + buf # Co=0, D/C#=1
+        buffer = bytearray([0x40]) + buf  # Co=0, D/C#=1
         self.i2c.writeto(self.addr, buffer)
diff --git a/ports/nrf/examples/ubluepy_eddystone.py b/ports/nrf/examples/ubluepy_eddystone.py
index c8abd5aea6ba0..1ebb2364d5415 100644
--- a/ports/nrf/examples/ubluepy_eddystone.py
+++ b/ports/nrf/examples/ubluepy_eddystone.py
@@ -1,13 +1,16 @@
 from ubluepy import Peripheral, constants
 
-BLE_GAP_ADV_FLAG_LE_GENERAL_DISC_MODE       = const(0x02)
-BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED       = const(0x04)
+BLE_GAP_ADV_FLAG_LE_GENERAL_DISC_MODE = const(0x02)
+BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED = const(0x04)
 
-BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE = const(BLE_GAP_ADV_FLAG_LE_GENERAL_DISC_MODE | BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED)
+BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE = const(
+    BLE_GAP_ADV_FLAG_LE_GENERAL_DISC_MODE | BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED
+)
+
+EDDYSTONE_FRAME_TYPE_URL = const(0x10)
+EDDYSTONE_URL_PREFIX_HTTP_WWW = const(0x00)  # "http://www".
+EDDYSTONE_URL_SUFFIX_DOT_COM = const(0x01)  # ".com"
 
-EDDYSTONE_FRAME_TYPE_URL                    = const(0x10)
-EDDYSTONE_URL_PREFIX_HTTP_WWW               = const(0x00) # "http://www".
-EDDYSTONE_URL_SUFFIX_DOT_COM                = const(0x01) # ".com"
 
 def string_to_binarray(text):
     b = bytearray([])
@@ -15,6 +18,7 @@ def string_to_binarray(text):
         b.append(ord(c))
     return b
 
+
 def gen_ad_type_content(ad_type, data):
     b = bytearray(1)
     b.append(ad_type)
@@ -22,6 +26,7 @@ def gen_ad_type_content(ad_type, data):
     b[0] = len(b) - 1
     return b
 
+
 def generate_eddystone_adv_packet(url):
     # flags
     disc_mode = bytearray([BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE])
@@ -29,10 +34,12 @@ def generate_eddystone_adv_packet(url):
 
     # 16-bit uuid
     uuid = bytearray([0xAA, 0xFE])
-    packet_uuid16 = gen_ad_type_content(constants.ad_types.AD_TYPE_16BIT_SERVICE_UUID_COMPLETE, uuid)
+    packet_uuid16 = gen_ad_type_content(
+        constants.ad_types.AD_TYPE_16BIT_SERVICE_UUID_COMPLETE, uuid
+    )
 
     # eddystone data
-    rssi = 0xEE # -18 dB, approx signal strength at 0m.
+    rssi = 0xEE  # -18 dB, approx signal strength at 0m.
     eddystone_data = bytearray([])
     eddystone_data.append(EDDYSTONE_FRAME_TYPE_URL)
     eddystone_data.append(rssi)
@@ -42,7 +49,9 @@ def generate_eddystone_adv_packet(url):
 
     # service data
     service_data = uuid + eddystone_data
-    packet_service_data = gen_ad_type_content(constants.ad_types.AD_TYPE_SERVICE_DATA, service_data)
+    packet_service_data = gen_ad_type_content(
+        constants.ad_types.AD_TYPE_SERVICE_DATA, service_data
+    )
 
     # generate advertisment packet
     packet = bytearray([])
@@ -52,7 +61,8 @@ def generate_eddystone_adv_packet(url):
 
     return packet
 
+
 def start():
-    adv_packet = generate_eddystone_adv_packet("micropython")  
+    adv_packet = generate_eddystone_adv_packet("micropython")
     p = Peripheral()
-    p.advertise(data=adv_packet, connectable=False)
\ No newline at end of file
+    p.advertise(data=adv_packet, connectable=False)
diff --git a/ports/nrf/examples/ubluepy_scan.py b/ports/nrf/examples/ubluepy_scan.py
index ab11661ccaa2e..37daa6c69baaf 100644
--- a/ports/nrf/examples/ubluepy_scan.py
+++ b/ports/nrf/examples/ubluepy_scan.py
@@ -1,38 +1,42 @@
 from ubluepy import Scanner, constants
 
+
 def bytes_to_str(bytes):
     string = ""
     for b in bytes:
         string += chr(b)
     return string
 
+
 def get_device_names(scan_entries):
     dev_names = []
     for e in scan_entries:
         scan = e.getScanData()
         if scan:
             for s in scan:
-               if s[0] == constants.ad_types.AD_TYPE_COMPLETE_LOCAL_NAME:
-                   dev_names.append((e, bytes_to_str(s[2])))
+                if s[0] == constants.ad_types.AD_TYPE_COMPLETE_LOCAL_NAME:
+                    dev_names.append((e, bytes_to_str(s[2])))
     return dev_names
 
+
 def find_device_by_name(name):
     s = Scanner()
     scan_res = s.scan(100)
-    
+
     device_names = get_device_names(scan_res)
     for dev in device_names:
         if name == dev[1]:
             return dev[0]
 
+
 # >>> res = find_device_by_name("micr")
 # >>> if res:
 # ...     print("address:", res.addr())
 # ...     print("address type:", res.addr_type())
 # ...     print("rssi:", res.rssi())
-# ...     
-# ...     
-# ... 
+# ...
+# ...
+# ...
 # address: c2:73:61:89:24:45
 # address type: 1
 # rssi: -26
diff --git a/ports/nrf/examples/ubluepy_temp.py b/ports/nrf/examples/ubluepy_temp.py
index 7df057bf4821b..f841849dee81b 100644
--- a/ports/nrf/examples/ubluepy_temp.py
+++ b/ports/nrf/examples/ubluepy_temp.py
@@ -26,12 +26,13 @@
 from machine import RTCounter, Temp
 from ubluepy import Service, Characteristic, UUID, Peripheral, constants
 
+
 def event_handler(id, handle, data):
     global rtc
     global periph
     global serv_env_sense
     global notif_enabled
- 
+
     if id == constants.EVT_GAP_CONNECTED:
         # indicated 'connected'
         LED(1).on()
@@ -50,11 +51,12 @@ def event_handler(id, handle, data):
             notif_enabled = True
             # start low power timer
             rtc.start()
-        else: 
+        else:
             notif_enabled = False
             # stop low power timer
             rtc.stop()
 
+
 def send_temp(timer_id):
     global notif_enabled
     global char_temp
@@ -62,26 +64,27 @@ def send_temp(timer_id):
     if notif_enabled:
         # measure chip temperature
         temp = Temp.read()
-        temp =  temp * 100
+        temp = temp * 100
         char_temp.write(bytearray([temp & 0xFF, temp >> 8]))
 
+
 # start off with LED(1) off
 LED(1).off()
 
-# use RTC1 as RTC0 is used by bluetooth stack 
+# use RTC1 as RTC0 is used by bluetooth stack
 # set up RTC callback every 5 second
 rtc = RTCounter(1, period=50, mode=RTCounter.PERIODIC, callback=send_temp)
 
 notif_enabled = False
 
-uuid_env_sense = UUID("0x181A") # Environmental Sensing service
-uuid_temp = UUID("0x2A6E") # Temperature characteristic
- 
+uuid_env_sense = UUID("0x181A")  # Environmental Sensing service
+uuid_temp = UUID("0x2A6E")  # Temperature characteristic
+
 serv_env_sense = Service(uuid_env_sense)
 
 temp_props = Characteristic.PROP_NOTIFY | Characteristic.PROP_READ
 temp_attrs = Characteristic.ATTR_CCCD
-char_temp = Characteristic(uuid_temp, props = temp_props, attrs = temp_attrs)
+char_temp = Characteristic(uuid_temp, props=temp_props, attrs=temp_attrs)
 
 serv_env_sense.addCharacteristic(char_temp)
 
@@ -89,4 +92,3 @@ def send_temp(timer_id):
 periph.addService(serv_env_sense)
 periph.setConnectionHandler(event_handler)
 periph.advertise(device_name="micr_temp", services=[serv_env_sense])
-
diff --git a/ports/nrf/fatfs_port.c b/ports/nrf/fatfs_port.c
index 13ac21fb1bcca..6a17f627bd585 100644
--- a/ports/nrf/fatfs_port.c
+++ b/ports/nrf/fatfs_port.c
@@ -28,6 +28,6 @@
 #include "lib/oofatfs/ff.h"
 
 DWORD get_fattime(void) {
-	// TODO: Implement this function. For now, fake it.
+    // TODO: Implement this function. For now, fake it.
     return ((2016 - 1980) << 25) | ((12) << 21) | ((4) << 16) | ((00) << 11) | ((18) << 5) | (23 / 2);
 }
diff --git a/ports/nrf/freeze/test.py b/ports/nrf/freeze/test.py
index e64bbc9f52c51..ba05ae1020965 100644
--- a/ports/nrf/freeze/test.py
+++ b/ports/nrf/freeze/test.py
@@ -1,4 +1,5 @@
 import sys
 
+
 def hello():
     print("Hello %s!" % sys.platform)
diff --git a/ports/nrf/gccollect.c b/ports/nrf/gccollect.c
index 68b8188532588..740561242f1f8 100644
--- a/ports/nrf/gccollect.c
+++ b/ports/nrf/gccollect.c
@@ -33,7 +33,7 @@
 
 static inline uintptr_t get_sp(void) {
     uintptr_t result;
-    __asm__ ("mov %0, sp\n" : "=r" (result) );
+    __asm__ ("mov %0, sp\n" : "=r" (result));
     return result;
 }
 
@@ -45,7 +45,7 @@ void gc_collect(void) {
     uintptr_t sp = get_sp();
 
     // trace the stack, including the registers (since they live on the stack in this function)
-    gc_collect_root((void**)sp, ((uint32_t)&_ram_end - sp) / sizeof(uint32_t));
+    gc_collect_root((void **)sp, ((uint32_t)&_ram_end - sp) / sizeof(uint32_t));
 
     // end the GC
     gc_collect_end();
diff --git a/ports/nrf/help.c b/ports/nrf/help.c
index 5856ef6e372de..afc979130f4e5 100644
--- a/ports/nrf/help.c
+++ b/ports/nrf/help.c
@@ -32,23 +32,23 @@
 #endif
 
 const char nrf5_help_text[] =
-"Welcome to MicroPython!\n"
-"\n"
-"For online help please visit http://micropython.org/help/.\n"
-"\n"
-"Quick overview of commands for the board:\n"
+    "Welcome to MicroPython!\n"
+    "\n"
+    "For online help please visit http://micropython.org/help/.\n"
+    "\n"
+    "Quick overview of commands for the board:\n"
 #if MICROPY_HW_HAS_LED
-"  board.LED(n)    -- create an LED object for LED n (n=" HELP_TEXT_BOARD_LED ")\n"
-"\n"
+    "  board.LED(n)    -- create an LED object for LED n (n=" HELP_TEXT_BOARD_LED ")\n"
+    "\n"
 #endif
 #if BLUETOOTH_SD
-HELP_TEXT_SD
+    HELP_TEXT_SD
 #endif
-"Control commands:\n"
-"  CTRL-A        -- on a blank line, enter raw REPL mode\n"
-"  CTRL-B        -- on a blank line, enter normal REPL mode\n"
-"  CTRL-D        -- on a blank line, do a soft reset of the board\n"
-"  CTRL-E        -- on a blank line, enter paste mode\n"
-"\n"
-"For further help on a specific object, type help(obj)\n"
+    "Control commands:\n"
+    "  CTRL-A        -- on a blank line, enter raw REPL mode\n"
+    "  CTRL-B        -- on a blank line, enter normal REPL mode\n"
+    "  CTRL-D        -- on a blank line, do a soft reset of the board\n"
+    "  CTRL-E        -- on a blank line, enter paste mode\n"
+    "\n"
+    "For further help on a specific object, type help(obj)\n"
 ;
diff --git a/ports/nrf/main.c b/ports/nrf/main.c
index b9c29e7538d8c..3c5d0a05d87f1 100644
--- a/ports/nrf/main.c
+++ b/ports/nrf/main.c
@@ -70,6 +70,10 @@
 #include "softpwm.h"
 #endif
 
+#if MICROPY_HW_USB_CDC
+#include "usb_cdc.h"
+#endif
+
 void do_str(const char *src, mp_parse_input_kind_t input_kind) {
     mp_lexer_t *lex = mp_lexer_new_from_str_len(MP_QSTR__lt_stdin_gt_, src, strlen(src), 0);
     if (lex == NULL) {
@@ -81,7 +85,7 @@ void do_str(const char *src, mp_parse_input_kind_t input_kind) {
     if (nlr_push(&nlr) == 0) {
         qstr source_name = lex->source_name;
         mp_parse_tree_t pn = mp_parse(lex, input_kind);
-        mp_obj_t module_fun = mp_compile(&pn, source_name, MP_EMIT_OPT_NONE, true);
+        mp_obj_t module_fun = mp_compile(&pn, source_name, true);
         mp_call_function_0(module_fun);
         nlr_pop();
     } else {
@@ -94,13 +98,19 @@ extern uint32_t _heap_start;
 extern uint32_t _heap_end;
 
 int main(int argc, char **argv) {
-    
+
+
 soft_reset:
+
+    led_init();
+
+    led_state(1, 1); // MICROPY_HW_LED_1 aka MICROPY_HW_LED_RED
+
     mp_stack_set_top(&_ram_end);
 
     // Stack limit should be less than real stack size, so we have a chance
     // to recover from limit hit.  (Limit is measured in bytes.)
-    mp_stack_set_limit((char*)&_ram_end - (char*)&_heap_end - 400);
+    mp_stack_set_limit((char *)&_ram_end - (char *)&_heap_end - 400);
 
     machine_init();
 
@@ -111,39 +121,38 @@ int main(int argc, char **argv) {
     mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR_)); // current dir (or base dir of the script)
     mp_obj_list_init(mp_sys_argv, 0);
 
-    pyb_set_repl_info(MP_OBJ_NEW_SMALL_INT(0));
-
     readline_init0();
 
-#if MICROPY_PY_MACHINE_HW_SPI
+
+    #if MICROPY_PY_MACHINE_HW_SPI
     spi_init0();
-#endif
+    #endif
 
-#if MICROPY_PY_MACHINE_I2C
+    #if MICROPY_PY_MACHINE_I2C
     i2c_init0();
-#endif
+    #endif
 
-#if MICROPY_PY_MACHINE_ADC
+    #if MICROPY_PY_MACHINE_ADC
     adc_init0();
-#endif
+    #endif
 
-#if MICROPY_PY_MACHINE_HW_PWM
+    #if MICROPY_PY_MACHINE_HW_PWM
     pwm_init0();
-#endif
+    #endif
 
-#if MICROPY_PY_MACHINE_RTCOUNTER
+    #if MICROPY_PY_MACHINE_RTCOUNTER
     rtc_init0();
-#endif
+    #endif
 
-#if MICROPY_PY_MACHINE_TIMER
+    #if MICROPY_PY_MACHINE_TIMER
     timer_init0();
-#endif
+    #endif
 
-#if MICROPY_PY_MACHINE_UART
+    #if MICROPY_PY_MACHINE_UART
     uart_init0();
-#endif
+    #endif
 
-#if (MICROPY_PY_BLE_NUS == 0)
+    #if (MICROPY_PY_BLE_NUS == 0) && (MICROPY_HW_USB_CDC == 0)
     {
         mp_obj_t args[2] = {
             MP_OBJ_NEW_SMALL_INT(0),
@@ -151,15 +160,15 @@ int main(int argc, char **argv) {
         };
         MP_STATE_PORT(board_stdio_uart) = machine_hard_uart_type.make_new((mp_obj_t)&machine_hard_uart_type, MP_ARRAY_SIZE(args), 0, args);
     }
-#endif
+    #endif
 
-pin_init0();
+    pin_init0();
 
-#if MICROPY_MBFS
+    #if MICROPY_MBFS
     microbit_filesystem_init();
-#endif
+    #endif
 
-#if MICROPY_HW_HAS_SDCARD
+    #if MICROPY_HW_HAS_SDCARD
     // if an SD card is present then mount it on /sd/
     if (sdcard_is_present()) {
         // create vfs object
@@ -169,7 +178,7 @@ pin_init0();
         }
         vfs->str = "/sd";
         vfs->len = 3;
-        vfs->flags = FSUSER_FREE_OBJ;
+        vfs->flags = MP_BLOCKDEV_FLAG_FREE_OBJ;
         sdcard_init_vfs(vfs);
 
         // put the sd device in slot 1 (it will be unused at this point)
@@ -185,55 +194,49 @@ pin_init0();
             mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_sd));
             mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_sd_slash_lib));
 
-			// use SD card as current directory
-			f_chdrive("/sd");
+            // use SD card as current directory
+            f_chdrive("/sd");
         }
-        no_mem_for_sd:;
+    no_mem_for_sd:;
     }
-#endif
-
-#if (MICROPY_HW_HAS_LED)
-    led_init();
-
-    do_str("import board\r\n" \
-           "board.LED(1).on()",
-           MP_PARSE_FILE_INPUT);
-#endif
+    #endif
 
     // Main script is finished, so now go into REPL mode.
     // The REPL mode can change, or it can request a soft reset.
     int ret_code = 0;
 
-#if MICROPY_PY_BLE_NUS
+    #if MICROPY_PY_BLE_NUS
     ble_uart_init0();
-#endif
+    #endif
 
-#if MICROPY_PY_MACHINE_SOFT_PWM
+    #if MICROPY_PY_MACHINE_SOFT_PWM
     ticker_init0();
     softpwm_init0();
-#endif
+    #endif
 
-#if MICROPY_PY_MUSIC
+    #if MICROPY_PY_MUSIC
     microbit_music_init0();
-#endif
-#if BOARD_SPECIFIC_MODULES
+    #endif
+    #if BOARD_SPECIFIC_MODULES
     board_modules_init0();
-#endif
+    #endif
 
-#if MICROPY_PY_MACHINE_SOFT_PWM
+    #if MICROPY_PY_MACHINE_SOFT_PWM
     ticker_start();
     pwm_start();
-#endif
+    #endif
+
+    led_state(1, 0);
 
-#if MICROPY_VFS || MICROPY_MBFS
+    #if MICROPY_VFS || MICROPY_MBFS || MICROPY_MODULE_FROZEN
     // run boot.py and main.py if they exist.
-    if (mp_import_stat("boot.py") == MP_IMPORT_STAT_FILE) {
-        pyexec_file("boot.py");
-    }
-    if (mp_import_stat("main.py") == MP_IMPORT_STAT_FILE) {
-        pyexec_file("main.py");
-    }
-#endif
+    pyexec_file_if_exists("boot.py");
+    pyexec_file_if_exists("main.py");
+    #endif
+
+    #if MICROPY_HW_USB_CDC
+    usb_cdc_init();
+    #endif
 
     for (;;) {
         if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
@@ -252,9 +255,9 @@ pin_init0();
 
     printf("MPY: soft reboot\n");
 
-#if BLUETOOTH_SD
+    #if BLUETOOTH_SD
     sd_softdevice_disable();
-#endif
+    #endif
 
     goto soft_reset;
 
@@ -294,26 +297,27 @@ MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
 #endif
 #endif
 
-void HardFault_Handler(void)
-{
-#if defined(NRF52_SERIES)
-	static volatile uint32_t reg;
-	static volatile uint32_t reg2;
-	static volatile uint32_t bfar;
-	reg = SCB->HFSR;
-	reg2 = SCB->CFSR;
-	bfar = SCB->BFAR;
-	for (int i = 0; i < 0; i++)
-	{
-		(void)reg;
-		(void)reg2;
-		(void)bfar;
-	}
-#endif
+
+void HardFault_Handler(void) {
+    #if defined(NRF52_SERIES) || defined(NRF91_SERIES)
+    static volatile uint32_t reg;
+    static volatile uint32_t reg2;
+    static volatile uint32_t bfar;
+    reg = SCB->HFSR;
+    reg2 = SCB->CFSR;
+    bfar = SCB->BFAR;
+    for (int i = 0; i < 0; i++) {
+        (void)reg;
+        (void)reg2;
+        (void)bfar;
+    }
+    #endif
 }
 
 void NORETURN __fatal_error(const char *msg) {
-    while (1);
+    while (1) {
+        ;
+    }
 }
 
 void nlr_jump_fail(void *val) {
@@ -327,4 +331,6 @@ void MP_WEAK __assert_func(const char *file, int line, const char *func, const c
     __fatal_error("Assertion failed");
 }
 
-void _start(void) {main(0, NULL);}
+void _start(void) {
+    main(0, NULL);
+}
diff --git a/ports/nrf/modules/ble/help_sd.h b/ports/nrf/modules/ble/help_sd.h
index 027bbdd513489..69ee5a53811d1 100644
--- a/ports/nrf/modules/ble/help_sd.h
+++ b/ports/nrf/modules/ble/help_sd.h
@@ -39,7 +39,7 @@
 "  ble.enabled()   -- check whether bluetooth stack is enabled\n" \
 "  ble.address()   -- return device address as text string\n" \
 "\n"
- 
+
 #else
 #define HELP_TEXT_SD
 #endif // MICROPY_PY_BLE
diff --git a/ports/nrf/modules/board/led.c b/ports/nrf/modules/board/led.c
index 687348cb86809..cbfc330d63309 100644
--- a/ports/nrf/modules/board/led.c
+++ b/ports/nrf/modules/board/led.c
@@ -33,31 +33,76 @@
 
 #if MICROPY_HW_HAS_LED
 
-#define LED_OFF(pin) {(MICROPY_HW_LED_PULLUP) ? nrf_gpio_pin_set(pin) : nrf_gpio_pin_clear(pin); }
-#define LED_ON(pin) {(MICROPY_HW_LED_PULLUP) ? nrf_gpio_pin_clear(pin) : nrf_gpio_pin_set(pin); }
-
 typedef struct _board_led_obj_t {
     mp_obj_base_t base;
     mp_uint_t led_id;
     mp_uint_t hw_pin;
     uint8_t hw_pin_port;
+    bool pullup;
 } board_led_obj_t;
 
-STATIC const board_led_obj_t board_led_obj[] = {
+static inline void led_off(board_led_obj_t * const led_obj) {
+    if (led_obj->pullup) {
+        nrf_gpio_pin_set(led_obj->hw_pin);
+    }
+    else {
+        nrf_gpio_pin_clear(led_obj->hw_pin);
+    }
+}
+
+static inline void led_on(board_led_obj_t * const led_obj) {
+    if (led_obj->pullup) {
+        nrf_gpio_pin_clear(led_obj->hw_pin);
+    }
+    else {
+        nrf_gpio_pin_set(led_obj->hw_pin);
+    }
+}
+
+
+static const board_led_obj_t board_led_obj[] = {
+
 #if MICROPY_HW_LED_TRICOLOR
-    {{&board_led_type}, BOARD_LED_RED, MICROPY_HW_LED_RED},
-    {{&board_led_type}, BOARD_LED_GREEN, MICROPY_HW_LED_GREEN},
-    {{&board_led_type}, BOARD_LED_BLUE, MICROPY_HW_LED_BLUE},
-#elif (MICROPY_HW_LED_COUNT == 1)
-    {{&board_led_type}, BOARD_LED1, MICROPY_HW_LED1},
-#elif (MICROPY_HW_LED_COUNT == 2)
-    {{&board_led_type}, BOARD_LED1, MICROPY_HW_LED1},
-    {{&board_led_type}, BOARD_LED2, MICROPY_HW_LED2},
-#else
-    {{&board_led_type}, BOARD_LED1, MICROPY_HW_LED1},
-    {{&board_led_type}, BOARD_LED2, MICROPY_HW_LED2},
-    {{&board_led_type}, BOARD_LED3, MICROPY_HW_LED3},
-    {{&board_led_type}, BOARD_LED4, MICROPY_HW_LED4},
+
+    {{&board_led_type}, BOARD_LED_RED, MICROPY_HW_LED_RED, 0, MICROPY_HW_LED_PULLUP},
+    {{&board_led_type}, BOARD_LED_GREEN, MICROPY_HW_LED_GREEN, 0, MICROPY_HW_LED_PULLUP},
+    {{&board_led_type}, BOARD_LED_BLUE, MICROPY_HW_LED_BLUE, 0, MICROPY_HW_LED_PULLUP},
+#endif
+#if (MICROPY_HW_LED_COUNT >= 1)
+    {{&board_led_type}, BOARD_LED1, MICROPY_HW_LED1, 0,
+    #ifdef MICROPY_HW_LED1_PULLUP
+        MICROPY_HW_LED1_PULLUP
+    #else
+        MICROPY_HW_LED_PULLUP
+    #endif
+    },
+#endif
+#if (MICROPY_HW_LED_COUNT >= 2)
+    {{&board_led_type}, BOARD_LED2, MICROPY_HW_LED2, 0,
+    #ifdef MICROPY_HW_LED2_PULLUP
+        MICROPY_HW_LED2_PULLUP
+    #else
+        MICROPY_HW_LED_PULLUP
+    #endif
+    },
+#endif
+#if (MICROPY_HW_LED_COUNT >= 3)
+    {{&board_led_type}, BOARD_LED3, MICROPY_HW_LED3, 0,
+    #ifdef MICROPY_HW_LED3_PULLUP
+        MICROPY_HW_LED3_PULLUP
+    #else
+        MICROPY_HW_LED_PULLUP
+    #endif
+    },
+#endif
+#if (MICROPY_HW_LED_COUNT == 4)
+    {{&board_led_type}, BOARD_LED4, MICROPY_HW_LED4, 0,
+    #ifdef MICROPY_HW_LED4_PULLUP
+        MICROPY_HW_LED4_PULLUP
+    #else
+        MICROPY_HW_LED_PULLUP
+    #endif
+    },
 #endif
 };
 
@@ -65,21 +110,22 @@ STATIC const board_led_obj_t board_led_obj[] = {
 
 void led_init(void) {
     for (uint8_t i = 0; i < NUM_LEDS; i++) {
-        LED_OFF(board_led_obj[i].hw_pin);
+        led_off((board_led_obj_t*)&board_led_obj[i]);
         nrf_gpio_cfg_output(board_led_obj[i].hw_pin);
     }
 }
 
-void led_state(board_led_obj_t * led_obj, int state) {
+void led_state(board_led_t led, int state) {
     if (state == 1) {
-        LED_ON(led_obj->hw_pin);
+        led_on((board_led_obj_t*)&board_led_obj[led-1]);
+
     } else {
-        LED_OFF(led_obj->hw_pin);
+        led_off((board_led_obj_t*)&board_led_obj[led-1]);
     }
 }
 
-void led_toggle(board_led_obj_t * led_obj) {
-    nrf_gpio_pin_toggle(led_obj->hw_pin);
+void led_toggle(board_led_t led) {
+    nrf_gpio_pin_toggle(board_led_obj[led-1].hw_pin);
 }
 
 
@@ -105,7 +151,7 @@ STATIC mp_obj_t led_obj_make_new(const mp_obj_type_t *type, size_t n_args, size_
 
     // check led number
     if (!(1 <= led_id && led_id <= NUM_LEDS)) {
-        mp_raise_ValueError("LED doesn't exist");
+        mp_raise_ValueError(MP_ERROR_TEXT("LED doesn't exist"));
     }
 
     // return static led object
@@ -116,7 +162,7 @@ STATIC mp_obj_t led_obj_make_new(const mp_obj_type_t *type, size_t n_args, size_
 /// Turn the LED on.
 mp_obj_t led_obj_on(mp_obj_t self_in) {
     board_led_obj_t *self = self_in;
-    led_state(self, 1);
+    led_state(self->led_id, 1);
     return mp_const_none;
 }
 
@@ -124,7 +170,7 @@ mp_obj_t led_obj_on(mp_obj_t self_in) {
 /// Turn the LED off.
 mp_obj_t led_obj_off(mp_obj_t self_in) {
     board_led_obj_t *self = self_in;
-    led_state(self, 0);
+    led_state(self->led_id, 0);
     return mp_const_none;
 }
 
@@ -132,7 +178,7 @@ mp_obj_t led_obj_off(mp_obj_t self_in) {
 /// Toggle the LED between on and off.
 mp_obj_t led_obj_toggle(mp_obj_t self_in) {
     board_led_obj_t *self = self_in;
-    led_toggle(self);
+    led_toggle(self->led_id);
     return mp_const_none;
 }
 
@@ -156,4 +202,13 @@ const mp_obj_type_t board_led_type = {
     .locals_dict = (mp_obj_dict_t*)&led_locals_dict,
 };
 
+#else
+// For boards with no LEDs, we leave an empty function here so that we don't
+// have to put conditionals everywhere.
+void led_init(void) {
+}
+void led_state(board_led_t led, int state) {
+}
+void led_toggle(board_led_t led) {
+}
 #endif // MICROPY_HW_HAS_LED
diff --git a/ports/nrf/modules/board/led.h b/ports/nrf/modules/board/led.h
index 6210039f498d3..187752189f1d3 100644
--- a/ports/nrf/modules/board/led.h
+++ b/ports/nrf/modules/board/led.h
@@ -38,6 +38,10 @@ typedef enum {
 #elif (MICROPY_HW_LED_COUNT == 2)
     BOARD_LED1 = 1,
     BOARD_LED2 = 2,
+#elif (MICROPY_HW_LED_COUNT == 3)
+    BOARD_LED1 = 1,
+    BOARD_LED2 = 2,
+    BOARD_LED3 = 3,
 #else
     BOARD_LED1 = 1,
     BOARD_LED2 = 2,
@@ -47,6 +51,8 @@ typedef enum {
 } board_led_t;
 
 void led_init(void);
+void led_state(board_led_t, int);
+void led_toggle(board_led_t);
 
 extern const mp_obj_type_t board_led_type;
 
diff --git a/ports/nrf/modules/board/modboard.c b/ports/nrf/modules/board/modboard.c
index 354a6169673c1..5f59a52a6b868 100644
--- a/ports/nrf/modules/board/modboard.c
+++ b/ports/nrf/modules/board/modboard.c
@@ -40,7 +40,9 @@
 
 STATIC const mp_rom_map_elem_t board_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_board) },
+    #if MICROPY_REPL_INFO
     { MP_ROM_QSTR(MP_QSTR_repl_info), MP_ROM_PTR(&pyb_set_repl_info_obj) },
+    #endif
     PYB_LED_MODULE
 };
 
diff --git a/ports/nrf/modules/machine/adc.c b/ports/nrf/modules/machine/adc.c
index 55b68c6b80b69..54870d2c18ee8 100644
--- a/ports/nrf/modules/machine/adc.c
+++ b/ports/nrf/modules/machine/adc.c
@@ -71,36 +71,33 @@ STATIC const machine_adc_obj_t machine_adc_obj[] = {
 #endif
 };
 
-#if defined(NRF52_SERIES)
-STATIC void saadc_event_handler(nrfx_saadc_evt_t const * p_event) {
-    (void)p_event;
-}
-#endif
-
 void adc_init0(void) {
 #if defined(NRF52_SERIES)
-    const nrfx_saadc_config_t config = {
-        .resolution         = NRF_SAADC_RESOLUTION_8BIT,
-        .oversample         = NRF_SAADC_OVERSAMPLE_DISABLED,
-        .interrupt_priority = 6,
-        .low_power_mode     = false
-    };
-
-    nrfx_saadc_init(&config, saadc_event_handler);
+    const uint8_t interrupt_priority = 6;
+    nrfx_saadc_init(interrupt_priority);
 #endif
 }
 
 STATIC int adc_find(mp_obj_t id) {
-    // given an integer id
-    int adc_id = mp_obj_get_int(id);
-
-    int adc_idx = adc_id;
+    int adc_idx;
+    if (mp_obj_is_int(id)) {
+        // Given an integer id
+        adc_idx = mp_obj_get_int(id);
+    } else {
+        // Assume it's a pin-compatible object and convert it to an ADC channel number
+        mp_hal_pin_obj_t pin = mp_hal_get_pin_obj(id);
+        if (pin->adc_num & PIN_ADC1) {
+            adc_idx = pin->adc_channel;
+        } else {
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid Pin for ADC"));
+        }
+    }
 
     if (adc_idx >= 0 && adc_idx < MP_ARRAY_SIZE(machine_adc_obj)
         && machine_adc_obj[adc_idx].id != (uint8_t)-1) {
         return adc_idx;
     }
-    mp_raise_ValueError("ADC doesn't exist");
+    mp_raise_ValueError(MP_ERROR_TEXT("ADC doesn't exist"));
 }
 
 /// \method __str__()
@@ -129,19 +126,22 @@ STATIC mp_obj_t machine_adc_make_new(const mp_obj_type_t *type, size_t n_args, s
     const machine_adc_obj_t *self = &machine_adc_obj[adc_id];
 
 #if defined(NRF52_SERIES)
-    const nrf_saadc_channel_config_t config = {
-        .resistor_p = NRF_SAADC_RESISTOR_DISABLED,
-        .resistor_n = NRF_SAADC_RESISTOR_DISABLED,
-        .gain       = NRF_SAADC_GAIN1_4,
-        .reference  = NRF_SAADC_REFERENCE_VDD4,
-        .acq_time   = NRF_SAADC_ACQTIME_3US,
-        .mode       = NRF_SAADC_MODE_SINGLE_ENDED,
-        .burst      = NRF_SAADC_BURST_DISABLED,
-        .pin_p      = self->id, // 0 - 7
-        .pin_n      = NRF_SAADC_INPUT_DISABLED
+    const nrfx_saadc_channel_t config = {                                                           \
+        .channel_config =
+        {
+            .resistor_p = NRF_SAADC_RESISTOR_DISABLED,
+            .resistor_n = NRF_SAADC_RESISTOR_DISABLED,
+            .gain       = NRF_SAADC_GAIN1_4,
+            .reference  = NRF_SAADC_REFERENCE_VDD4,
+            .acq_time   = NRF_SAADC_ACQTIME_3US,
+            .mode       = NRF_SAADC_MODE_SINGLE_ENDED,
+            .burst      = NRF_SAADC_BURST_DISABLED,
+        },
+        .pin_p          = (nrf_saadc_input_t)(1 + self->id), // pin_p=0 is AIN0, pin_p=8 is AIN7
+        .pin_n          = NRF_SAADC_INPUT_DISABLED,
+        .channel_index  = self->id,
     };
-
-    nrfx_saadc_channel_init(self->id, &config);
+    nrfx_saadc_channels_config(&config, 1);
 #endif
 
     return MP_OBJ_FROM_PTR(self);
@@ -164,11 +164,27 @@ int16_t machine_adc_value_read(machine_adc_obj_t * adc_obj) {
 #else // NRF52
     nrf_saadc_value_t value = 0;
 
-    nrfx_saadc_sample_convert(adc_obj->id, &value);
+    nrfx_saadc_simple_mode_set((1 << adc_obj->id), NRF_SAADC_RESOLUTION_8BIT, NRF_SAADC_INPUT_DISABLED, NULL);
+    nrfx_saadc_buffer_set(&value, 1);
+    nrfx_saadc_mode_trigger();
 #endif
     return value;
 }
 
+// read_u16()
+STATIC mp_obj_t machine_adc_read_u16(mp_obj_t self_in) {
+    machine_adc_obj_t *self = self_in;
+    int16_t raw = machine_adc_value_read(self);
+    #if defined(NRF52_SERIES)
+    // raw is signed but the channel is in single-ended mode and this method cannot return negative values
+    if (raw < 0) {
+        raw = 0;
+    }
+    #endif
+    // raw is an 8-bit value
+    return MP_OBJ_NEW_SMALL_INT(raw << 8 | raw);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_machine_adc_read_u16_obj, machine_adc_read_u16);
 
 /// \method value()
 /// Read adc level.
@@ -238,20 +254,26 @@ mp_obj_t machine_adc_battery_level(void) {
 #else // NRF52
     nrf_saadc_value_t value = 0;
 
-    const nrf_saadc_channel_config_t config = {
-        .resistor_p = NRF_SAADC_RESISTOR_DISABLED,
-        .resistor_n = NRF_SAADC_RESISTOR_DISABLED,
-        .gain       = NRF_SAADC_GAIN1_6,
-        .reference  = NRF_SAADC_REFERENCE_INTERNAL,
-        .acq_time   = NRF_SAADC_ACQTIME_3US,
-        .mode       = NRF_SAADC_MODE_SINGLE_ENDED,
-        .burst      = NRF_SAADC_BURST_DISABLED,
-        .pin_p      = NRF_SAADC_INPUT_VDD,
-        .pin_n      = NRF_SAADC_INPUT_DISABLED
+    const nrfx_saadc_channel_t config = {                                                           \
+        .channel_config =
+        {
+            .resistor_p = NRF_SAADC_RESISTOR_DISABLED,
+            .resistor_n = NRF_SAADC_RESISTOR_DISABLED,
+            .gain       = NRF_SAADC_GAIN1_6,
+            .reference  = NRF_SAADC_REFERENCE_INTERNAL,
+            .acq_time   = NRF_SAADC_ACQTIME_3US,
+            .mode       = NRF_SAADC_MODE_SINGLE_ENDED,
+            .burst      = NRF_SAADC_BURST_DISABLED,
+        },
+        .pin_p          = NRF_SAADC_INPUT_VDD,
+        .pin_n          = NRF_SAADC_INPUT_DISABLED,
+        .channel_index  = 0,
     };
+    nrfx_saadc_channels_config(&config, 1);
 
-    nrfx_saadc_channel_init(0, &config);
-    nrfx_saadc_sample_convert(0, &value);
+    nrfx_saadc_simple_mode_set((1 << 0), NRF_SAADC_RESOLUTION_8BIT, NRF_SAADC_INPUT_DISABLED, NULL);
+    nrfx_saadc_buffer_set(&value, 1);
+    nrfx_saadc_mode_trigger();
 #endif
 
     uint16_t batt_lvl_in_milli_volts = BATTERY_MILLIVOLT(value) + DIODE_VOLT_DROP_MILLIVOLT;
@@ -263,6 +285,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_0(mp_machine_adc_battery_level_obj, machine_adc_b
 
 STATIC const mp_rom_map_elem_t machine_adc_locals_dict_table[] = {
     // instance methods
+    { MP_ROM_QSTR(MP_QSTR_read_u16), MP_ROM_PTR(&mp_machine_adc_read_u16_obj) },
     { MP_ROM_QSTR(MP_QSTR_value), MP_ROM_PTR(&mp_machine_adc_value_obj) },
 
     // class methods
diff --git a/ports/nrf/modules/machine/i2c.c b/ports/nrf/modules/machine/i2c.c
index 8b79342a30de0..afa906c3598d7 100644
--- a/ports/nrf/modules/machine/i2c.c
+++ b/ports/nrf/modules/machine/i2c.c
@@ -31,11 +31,37 @@
 #include "py/runtime.h"
 #include "py/mperrno.h"
 #include "py/mphal.h"
+
+#if MICROPY_PY_MACHINE_I2C
+
 #include "extmod/machine_i2c.h"
 #include "i2c.h"
+#if NRFX_TWI_ENABLED
 #include "nrfx_twi.h"
+#else
+#include "nrfx_twim.h"
+#endif
 
-#if MICROPY_PY_MACHINE_I2C
+#if NRFX_TWIM_ENABLED
+
+#define nrfx_twi_t        nrfx_twim_t
+#define nrfx_twi_config_t nrfx_twim_config_t
+
+#define nrfx_twi_init     nrfx_twim_init
+#define nrfx_twi_enable   nrfx_twim_enable
+#define nrfx_twi_xfer     nrfx_twim_xfer
+#define nrfx_twi_disable  nrfx_twim_disable
+
+#define nrfx_twi_xfer_desc_t nrfx_twim_xfer_desc_t
+
+#define NRFX_TWI_XFER_DESC_RX NRFX_TWIM_XFER_DESC_RX
+#define NRFX_TWI_XFER_DESC_TX NRFX_TWIM_XFER_DESC_TX
+
+#define NRFX_TWI_INSTANCE NRFX_TWIM_INSTANCE
+
+#define NRF_TWI_FREQ_400K NRF_TWIM_FREQ_400K
+
+#endif
 
 STATIC const mp_obj_type_t machine_hard_i2c_type;
 
@@ -58,7 +84,7 @@ STATIC int i2c_find(mp_obj_t id) {
     if (i2c_id >= 0 && i2c_id < MP_ARRAY_SIZE(machine_hard_i2c_obj)) {
         return i2c_id;
     }
-    mp_raise_ValueError("I2C doesn't exist");
+    mp_raise_ValueError(MP_ERROR_TEXT("I2C doesn't exist"));
 }
 
 STATIC void machine_hard_i2c_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
@@ -99,35 +125,22 @@ mp_obj_t machine_hard_i2c_make_new(const mp_obj_type_t *type, size_t n_args, siz
     return MP_OBJ_FROM_PTR(self);
 }
 
-int machine_hard_i2c_readfrom(mp_obj_base_t *self_in, uint16_t addr, uint8_t *dest, size_t len, bool stop) {
+int machine_hard_i2c_transfer_single(mp_obj_base_t *self_in, uint16_t addr, size_t len, uint8_t *buf, unsigned int flags) {
     machine_hard_i2c_obj_t *self = (machine_hard_i2c_obj_t *)self_in;
 
     nrfx_twi_enable(&self->p_twi);
 
-    nrfx_err_t err_code = nrfx_twi_rx(&self->p_twi, addr, dest, len);
-
-    if (err_code != NRFX_SUCCESS) {
-        if (err_code == NRFX_ERROR_DRV_TWI_ERR_ANACK) {
-            return -MP_ENODEV;
-        }
-        else if (err_code == NRFX_ERROR_DRV_TWI_ERR_DNACK) {
-            return -MP_EIO;
-        }
-        return -MP_ETIMEDOUT;
+    nrfx_err_t err_code;
+    int transfer_ret = 0;
+    if (flags & MP_MACHINE_I2C_FLAG_READ) {
+        nrfx_twi_xfer_desc_t desc = NRFX_TWI_XFER_DESC_RX(addr, buf, len);
+        err_code = nrfx_twi_xfer(&self->p_twi, &desc, 0);
+    } else {
+        nrfx_twi_xfer_desc_t desc = NRFX_TWI_XFER_DESC_TX(addr, buf, len);
+        err_code = nrfx_twi_xfer(&self->p_twi, &desc, (flags & MP_MACHINE_I2C_FLAG_STOP) == 0);
+        transfer_ret = len;
     }
 
-    nrfx_twi_disable(&self->p_twi);
-
-    return 0;
-}
-
-int machine_hard_i2c_writeto(mp_obj_base_t *self_in, uint16_t addr, const uint8_t *src, size_t len, bool stop) {
-    machine_hard_i2c_obj_t *self = (machine_hard_i2c_obj_t *)self_in;
-
-    nrfx_twi_enable(&self->p_twi);
-
-    nrfx_err_t err_code = nrfx_twi_tx(&self->p_twi, addr, src, len, !stop);
-
     if (err_code != NRFX_SUCCESS) {
         if (err_code == NRFX_ERROR_DRV_TWI_ERR_ANACK) {
             return -MP_ENODEV;
@@ -140,12 +153,12 @@ int machine_hard_i2c_writeto(mp_obj_base_t *self_in, uint16_t addr, const uint8_
 
     nrfx_twi_disable(&self->p_twi);
 
-    return len;
+    return transfer_ret;
 }
 
 STATIC const mp_machine_i2c_p_t machine_hard_i2c_p = {
-    .readfrom = machine_hard_i2c_readfrom,
-    .writeto = machine_hard_i2c_writeto,
+    .transfer = mp_machine_i2c_transfer_adaptor,
+    .transfer_single = machine_hard_i2c_transfer_single,
 };
 
 STATIC const mp_obj_type_t machine_hard_i2c_type = {
diff --git a/ports/nrf/modules/machine/modmachine.c b/ports/nrf/modules/machine/modmachine.c
index 841e136d0dbb1..48730c849f6bf 100644
--- a/ports/nrf/modules/machine/modmachine.c
+++ b/ports/nrf/modules/machine/modmachine.c
@@ -78,8 +78,10 @@ void machine_init(void) {
         reset_cause = PYB_RESET_LOCKUP;
     } else if (state & POWER_RESETREAS_OFF_Msk) {
         reset_cause = PYB_RESET_POWER_ON;
+#if !defined(NRF9160_XXAA)
     } else if (state & POWER_RESETREAS_LPCOMP_Msk) {
         reset_cause = PYB_RESET_LPCOMP;
+#endif
     } else if (state & POWER_RESETREAS_DIF_Msk) {
         reset_cause = PYB_RESET_DIF;
 #if defined(NRF52_SERIES)
@@ -145,7 +147,7 @@ MP_DEFINE_CONST_FUN_OBJ_0(machine_reset_obj, machine_reset);
 
 STATIC mp_obj_t machine_soft_reset(void) {
     pyexec_system_exit = PYEXEC_FORCED_EXIT;
-    nlr_raise(mp_obj_new_exception(&mp_type_SystemExit));
+    mp_raise_type(&mp_type_SystemExit);
 }
 MP_DEFINE_CONST_FUN_OBJ_0(machine_soft_reset_obj, machine_soft_reset);
 
@@ -194,9 +196,6 @@ STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_soft_reset),         MP_ROM_PTR(&machine_soft_reset_obj) },
     { MP_ROM_QSTR(MP_QSTR_enable_irq),         MP_ROM_PTR(&machine_enable_irq_obj) },
     { MP_ROM_QSTR(MP_QSTR_disable_irq),        MP_ROM_PTR(&machine_disable_irq_obj) },
-#if MICROPY_HW_ENABLE_RNG
-    { MP_ROM_QSTR(MP_QSTR_rng),                MP_ROM_PTR(&random_module) },
-#endif
     { MP_ROM_QSTR(MP_QSTR_sleep),              MP_ROM_PTR(&machine_lightsleep_obj) },
     { MP_ROM_QSTR(MP_QSTR_lightsleep),         MP_ROM_PTR(&machine_lightsleep_obj) },
     { MP_ROM_QSTR(MP_QSTR_deepsleep),          MP_ROM_PTR(&machine_deepsleep_obj) },
diff --git a/ports/nrf/modules/machine/pin.c b/ports/nrf/modules/machine/pin.c
index d56abfd04e953..170caf6dde4c6 100644
--- a/ports/nrf/modules/machine/pin.c
+++ b/ports/nrf/modules/machine/pin.c
@@ -37,8 +37,8 @@
 #include "nrf_gpio.h"
 #include "nrfx_gpiote.h"
 
-extern const pin_obj_t machine_pin_obj[];
-extern const uint8_t machine_pin_num_of_pins;
+extern const pin_obj_t machine_board_pin_obj[];
+extern const uint8_t machine_pin_num_of_board_pins;
 
 /// \moduleref machine
 /// \class Pin - control I/O pins
@@ -114,7 +114,7 @@ void pin_init0(void) {
     }
     // Initialize GPIOTE if not done yet.
     if (!nrfx_gpiote_is_init()) {
-        nrfx_gpiote_init();
+        nrfx_gpiote_init(NRFX_GPIOTE_DEFAULT_CONFIG_IRQ_PRIORITY);
     }
 
     #if PIN_DEBUG
@@ -127,12 +127,12 @@ const pin_obj_t *pin_find(mp_obj_t user_obj) {
     const pin_obj_t *pin_obj;
     // If pin is SMALL_INT
     if (mp_obj_is_small_int(user_obj)) {
-	uint8_t value = MP_OBJ_SMALL_INT_VALUE(user_obj);
-        for (uint8_t i = 0; i < machine_pin_num_of_pins; i++) {
-            if (machine_pin_obj[i].pin == value) {
-                return &machine_pin_obj[i];
-	    }
-	}
+        uint8_t value = MP_OBJ_SMALL_INT_VALUE(user_obj);
+        for (uint8_t i = 0; i < machine_pin_num_of_board_pins; i++) {
+            if (machine_board_pin_obj[i].pin == value) {
+                return &machine_board_pin_obj[i];
+            }
+        }
     }
 
     // If a pin was provided, then use it
@@ -150,7 +150,7 @@ const pin_obj_t *pin_find(mp_obj_t user_obj) {
         pin_obj = mp_call_function_1(MP_STATE_PORT(pin_class_mapper), user_obj);
         if (pin_obj != mp_const_none) {
             if (!mp_obj_is_type(pin_obj, &pin_type)) {
-                mp_raise_ValueError("Pin.mapper didn't return a Pin object");
+                mp_raise_ValueError(MP_ERROR_TEXT("Pin.mapper didn't return a Pin object"));
             }
             if (pin_class_debug) {
                 printf("Pin.mapper maps ");
@@ -207,7 +207,7 @@ const pin_obj_t *pin_find(mp_obj_t user_obj) {
         return pin_obj;
     }
 
-    mp_raise_ValueError("not a valid pin identifier");
+    mp_raise_ValueError(MP_ERROR_TEXT("not a valid pin identifier"));
 }
 
 /// \method __str__()
@@ -364,8 +364,8 @@ STATIC mp_obj_t pin_obj_init_helper(const pin_obj_t *self, mp_uint_t n_args, con
     nrf_gpio_pin_dir_t mode = (nrf_gpio_pin_dir_t)args[0].u_int;
 
     // Connect input or not
-    nrf_gpio_pin_input_t input = (mode == NRF_GPIO_PIN_DIR_INPUT) ? NRF_GPIO_PIN_INPUT_CONNECT 
-	                                                          : NRF_GPIO_PIN_INPUT_DISCONNECT;
+    nrf_gpio_pin_input_t input = (mode == NRF_GPIO_PIN_DIR_INPUT) ? NRF_GPIO_PIN_INPUT_CONNECT
+                                                                  : NRF_GPIO_PIN_INPUT_DISCONNECT;
 
     if (mode == NRF_GPIO_PIN_DIR_OUTPUT || mode == NRF_GPIO_PIN_DIR_INPUT) {
         nrf_gpio_cfg(self->pin,
@@ -375,7 +375,7 @@ STATIC mp_obj_t pin_obj_init_helper(const pin_obj_t *self, mp_uint_t n_args, con
                      NRF_GPIO_PIN_S0S1,
                      NRF_GPIO_PIN_NOSENSE);
     } else {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid pin mode: %d", mode));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("invalid pin mode: %d"), mode);
     }
 
     return mp_const_none;
@@ -496,7 +496,7 @@ STATIC void pin_common_irq_handler(nrfx_gpiote_pin_t pin, nrf_gpiote_polarity_t
 }
 
 STATIC mp_obj_t pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-	enum {ARG_handler, ARG_trigger, ARG_wake};
+    enum {ARG_handler, ARG_trigger, ARG_wake};
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_handler, MP_ARG_OBJ | MP_ARG_REQUIRED,  {.u_obj = mp_const_none} },
         { MP_QSTR_trigger, MP_ARG_INT,  {.u_int = NRF_GPIOTE_POLARITY_LOTOHI | NRF_GPIOTE_POLARITY_HITOLO} },
diff --git a/ports/nrf/modules/machine/pwm.c b/ports/nrf/modules/machine/pwm.c
index cf8749302b4ae..a750285841e24 100644
--- a/ports/nrf/modules/machine/pwm.c
+++ b/ports/nrf/modules/machine/pwm.c
@@ -97,7 +97,7 @@ STATIC int hard_pwm_find(mp_obj_t id) {
         if (pwm_id >= 0 && pwm_id < MP_ARRAY_SIZE(machine_hard_pwm_obj)) {
             return pwm_id;
         }
-        mp_raise_ValueError("PWM doesn't exist");
+        mp_raise_ValueError(MP_ERROR_TEXT("PWM doesn't exist"));
     }
     return -1;
 }
@@ -249,7 +249,7 @@ STATIC mp_obj_t machine_hard_pwm_make_new(mp_arg_val_t *args) {
     if (args[ARG_period].u_obj != MP_OBJ_NULL) {
         self->p_config->period = mp_obj_get_int(args[ARG_period].u_obj);
     } else {
-        mp_raise_ValueError("PWM period must be within 16000 cycles");
+        mp_raise_ValueError(MP_ERROR_TEXT("PWM period must be within 16000 cycles"));
     }
 
     if (args[ARG_duty].u_obj != MP_OBJ_NULL) {
@@ -269,7 +269,7 @@ STATIC mp_obj_t machine_hard_pwm_make_new(mp_arg_val_t *args) {
     } else {
         self->p_config->mode = MODE_HIGH_LOW;
     }
- 
+
     return MP_OBJ_FROM_PTR(self);
 }
 
@@ -290,7 +290,7 @@ STATIC void machine_hard_pwm_init(mp_obj_t self_in, mp_arg_val_t *args) {
     config.load_mode      = NRF_PWM_LOAD_INDIVIDUAL;
     config.step_mode      = NRF_PWM_STEP_AUTO;
 
-    nrfx_pwm_init(self->p_pwm, &config, NULL);
+    nrfx_pwm_init(self->p_pwm, &config, NULL, NULL);
 
     uint16_t pulse_width = ((self->p_config->period * self->p_config->duty) / 100);
 
diff --git a/ports/nrf/modules/machine/rtcounter.c b/ports/nrf/modules/machine/rtcounter.c
index d51791905c697..5fb28557d8230 100644
--- a/ports/nrf/modules/machine/rtcounter.c
+++ b/ports/nrf/modules/machine/rtcounter.c
@@ -116,7 +116,7 @@ STATIC int rtc_find(mp_obj_t id) {
     if (rtc_id >= 0 && rtc_id < MP_ARRAY_SIZE(machine_rtc_obj)) {
         return rtc_id;
     }
-    mp_raise_ValueError("RTCounter doesn't exist");
+    mp_raise_ValueError(MP_ERROR_TEXT("RTCounter doesn't exist"));
 }
 
 STATIC void rtc_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
@@ -162,7 +162,7 @@ STATIC mp_obj_t machine_rtc_make_new(const mp_obj_type_t *type, size_t n_args, s
     } else if (mp_obj_is_fun(args[ARG_callback].u_obj)) {
         config->callback = args[ARG_callback].u_obj;
     } else {
-        mp_raise_ValueError("callback must be a function");
+        mp_raise_ValueError(MP_ERROR_TEXT("callback must be a function"));
     }
 
     // Periodic or one-shot
@@ -175,8 +175,8 @@ STATIC mp_obj_t machine_rtc_make_new(const mp_obj_type_t *type, size_t n_args, s
     }
 
     // Start the low-frequency clock (if it hasn't been started already)
-    if (!nrf_clock_lf_is_running()) {
-        nrf_clock_task_trigger(NRF_CLOCK_TASK_LFCLKSTART);
+    if (!nrf_clock_lf_is_running(NRF_CLOCK)) {
+        nrf_clock_task_trigger(NRF_CLOCK, NRF_CLOCK_TASK_LFCLKSTART);
     }
 
     // Make sure it's uninitialized.
diff --git a/ports/nrf/modules/machine/spi.c b/ports/nrf/modules/machine/spi.c
index 1c401b76d2920..2510c275020fd 100644
--- a/ports/nrf/modules/machine/spi.c
+++ b/ports/nrf/modules/machine/spi.c
@@ -140,23 +140,23 @@ STATIC int spi_find(mp_obj_t id) {
             return 1;
         #endif
         }
-        mp_raise_ValueError("SPI doesn't exist");
+        mp_raise_ValueError(MP_ERROR_TEXT("SPI doesn't exist"));
     } else {
         // given an integer id
         int spi_id = mp_obj_get_int(id);
         if (spi_id >= 0 && spi_id < MP_ARRAY_SIZE(machine_hard_spi_obj)) {
             return spi_id;
         }
-        mp_raise_ValueError("SPI doesn't exist");
+        mp_raise_ValueError(MP_ERROR_TEXT("SPI doesn't exist"));
     }
 }
 
 void spi_transfer(const machine_hard_spi_obj_t * self, size_t len, const void * src, void * dest) {
     nrfx_spi_xfer_desc_t xfer_desc = {
         .p_tx_buffer = src,
-	.tx_length   = len,
-	.p_rx_buffer = dest,
-	.rx_length   = len
+        .tx_length   = len,
+        .p_rx_buffer = dest,
+        .rx_length   = len
     };
 
     nrfx_spi_xfer(self->p_spi, &xfer_desc, 0);
@@ -340,7 +340,7 @@ STATIC void machine_hard_spi_init(mp_obj_t self_in, mp_arg_val_t *args) {
 
     // Active high
     if (args[ARG_INIT_polarity].u_int == 0) {
-	if (args[ARG_INIT_phase].u_int == 0) {
+        if (args[ARG_INIT_phase].u_int == 0) {
             // First clock edge
             self->p_config->mode = NRF_SPI_MODE_0;
         } else {
@@ -349,7 +349,7 @@ STATIC void machine_hard_spi_init(mp_obj_t self_in, mp_arg_val_t *args) {
         }
     // Active low
     } else {
-	if (args[ARG_INIT_phase].u_int == 0) {
+        if (args[ARG_INIT_phase].u_int == 0) {
             // First clock edge
             self->p_config->mode = NRF_SPI_MODE_2;
         } else {
@@ -415,7 +415,7 @@ STATIC mp_obj_t mp_machine_spi_write_readinto(mp_obj_t self, mp_obj_t wr_buf, mp
     mp_buffer_info_t dest;
     mp_get_buffer_raise(rd_buf, &dest, MP_BUFFER_WRITE);
     if (src.len != dest.len) {
-        mp_raise_ValueError("buffers must be the same length");
+        mp_raise_ValueError(MP_ERROR_TEXT("buffers must be the same length"));
     }
     spi_transfer(self, src.len, src.buf, dest.buf);
     return mp_const_none;
diff --git a/ports/nrf/modules/machine/temp.c b/ports/nrf/modules/machine/temp.c
index 361d988857890..82b02d09e9232 100644
--- a/ports/nrf/modules/machine/temp.c
+++ b/ports/nrf/modules/machine/temp.c
@@ -29,9 +29,13 @@
 
 #include "py/nlr.h"
 #include "py/runtime.h"
+#include "py/mperrno.h"
 #include "py/mphal.h"
+
+#if MICROPY_PY_MACHINE_TEMP
+
 #include "temp.h"
-#include "nrf_temp.h"
+#include "nrfx_temp.h"
 
 #if BLUETOOTH_SD
 #include "py/nlr.h"
@@ -40,8 +44,6 @@
 #define BLUETOOTH_STACK_ENABLED() (ble_drv_stack_enabled())
 #endif // BLUETOOTH_SD
 
-#if MICROPY_PY_MACHINE_TEMP
-
 typedef struct _machine_temp_obj_t {
     mp_obj_base_t base;
 } machine_temp_obj_t;
@@ -67,14 +69,26 @@ STATIC mp_obj_t machine_temp_make_new(const mp_obj_type_t *type, size_t n_args,
     // parse args
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-    
+
     machine_temp_obj_t *self = m_new_obj(machine_temp_obj_t);
-    
+
     self->base.type = &machine_temp_type;
 
     return MP_OBJ_FROM_PTR(self);
 }
 
+int32_t temp_read(void) {
+    const nrfx_temp_config_t config = NRFX_TEMP_DEFAULT_CONFIG;
+    nrfx_temp_init(&config, NULL); // Blocking mode.
+    if (nrfx_temp_measure() != NRFX_SUCCESS) {
+        mp_raise_OSError(MP_EIO);
+    }
+    int32_t raw_temp = nrfx_temp_result_get();
+    int32_t temp_c = nrfx_temp_calculate(raw_temp);
+    nrfx_temp_uninit();
+    return temp_c;
+}
+
 /// \method read()
 /// Get temperature.
 STATIC mp_obj_t machine_temp_read(mp_uint_t n_args, const mp_obj_t *args) {
@@ -87,7 +101,7 @@ STATIC mp_obj_t machine_temp_read(mp_uint_t n_args, const mp_obj_t *args) {
     }
 #endif // BLUETOOTH_SD
 
-    return MP_OBJ_NEW_SMALL_INT(nrf_temp_read());
+    return MP_OBJ_NEW_SMALL_INT(temp_read());
 }
 
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_machine_temp_read_obj, 0, 1, machine_temp_read);
diff --git a/ports/nrf/modules/machine/timer.c b/ports/nrf/modules/machine/timer.c
index 00a359118534a..c99713ef52c5d 100644
--- a/ports/nrf/modules/machine/timer.c
+++ b/ports/nrf/modules/machine/timer.c
@@ -77,7 +77,7 @@ STATIC int timer_find(mp_obj_t id) {
     if (timer_id >= 0 && timer_id < MP_ARRAY_SIZE(machine_timer_obj)) {
         return timer_id;
     }
-    mp_raise_ValueError("Timer doesn't exist");
+    mp_raise_ValueError(MP_ERROR_TEXT("Timer doesn't exist"));
 }
 
 STATIC void timer_print(const mp_print_t *print, mp_obj_t o, mp_print_kind_t kind) {
@@ -114,13 +114,13 @@ STATIC mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args,
 
 #if BLUETOOTH_SD
     if (timer_id == 0) {
-        mp_raise_ValueError("Timer reserved by Bluetooth LE stack");
+        mp_raise_ValueError(MP_ERROR_TEXT("Timer reserved by Bluetooth LE stack"));
     }
 #endif
 
 #if MICROPY_PY_MACHINE_SOFT_PWM
     if (timer_id == 1) {
-        mp_raise_ValueError("Timer reserved by ticker driver");
+        mp_raise_ValueError(MP_ERROR_TEXT("Timer reserved by ticker driver"));
     }
 #endif
 
@@ -131,7 +131,7 @@ STATIC mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args,
     } else if (args[ARG_callback].u_obj == mp_const_none) {
         machine_timer_callbacks[timer_id] = NULL;
     } else {
-        mp_raise_ValueError("callback must be a function");
+        mp_raise_ValueError(MP_ERROR_TEXT("callback must be a function"));
     }
 
     // Timer peripheral usage:
diff --git a/ports/nrf/modules/machine/uart.c b/ports/nrf/modules/machine/uart.c
index cef98fb07ffc2..4f69bfc620b94 100644
--- a/ports/nrf/modules/machine/uart.c
+++ b/ports/nrf/modules/machine/uart.c
@@ -35,27 +35,78 @@
 #include "py/stream.h"
 #include "py/mperrno.h"
 #include "py/mphal.h"
+#include "py/ringbuf.h"
 #include "pin.h"
 #include "genhdr/pins.h"
+#include "lib/utils/interrupt_char.h"
 
 #include "uart.h"
 #include "mpconfigboard.h"
 #include "nrf.h"
 #include "mphalport.h"
+
+#if NRFX_UART_ENABLED
 #include "nrfx_uart.h"
+#else
+#include "nrfx_uarte.h"
+#endif
 
 
 #if MICROPY_PY_MACHINE_UART
 
+typedef struct _machine_hard_uart_buf_t {
+    uint8_t tx_buf[1];
+    uint8_t rx_buf[1];
+    uint8_t rx_ringbuf_array[64];
+    volatile ringbuf_t rx_ringbuf;
+} machine_hard_uart_buf_t;
+
+#if NRFX_UARTE_ENABLED
+
+#define nrfx_uart_t               nrfx_uarte_t
+#define nrfx_uart_config_t        nrfx_uarte_config_t
+
+#define nrfx_uart_rx              nrfx_uarte_rx
+#define nrfx_uart_tx              nrfx_uarte_tx
+#define nrfx_uart_tx_in_progress  nrfx_uarte_tx_in_progress
+#define nrfx_uart_init            nrfx_uarte_init
+#define nrfx_uart_event_t         nrfx_uarte_event_t
+#define NRFX_UART_INSTANCE        NRFX_UARTE_INSTANCE
+
+#define NRF_UART_HWFC_ENABLED     NRF_UARTE_HWFC_ENABLED
+#define NRF_UART_HWFC_DISABLED    NRF_UARTE_HWFC_DISABLED
+#define NRF_UART_PARITY_EXCLUDED  NRF_UARTE_PARITY_EXCLUDED
+#define NRFX_UART_EVT_RX_DONE     NRFX_UARTE_EVT_RX_DONE
+
+#define NRF_UART_BAUDRATE_1200    NRF_UARTE_BAUDRATE_1200
+#define NRF_UART_BAUDRATE_2400    NRF_UARTE_BAUDRATE_2400
+#define NRF_UART_BAUDRATE_4800    NRF_UARTE_BAUDRATE_4800
+#define NRF_UART_BAUDRATE_9600    NRF_UARTE_BAUDRATE_9600
+#define NRF_UART_BAUDRATE_14400   NRF_UARTE_BAUDRATE_14400
+#define NRF_UART_BAUDRATE_19200   NRF_UARTE_BAUDRATE_19200
+#define NRF_UART_BAUDRATE_28800   NRF_UARTE_BAUDRATE_28800
+#define NRF_UART_BAUDRATE_38400   NRF_UARTE_BAUDRATE_38400
+#define NRF_UART_BAUDRATE_57600   NRF_UARTE_BAUDRATE_57600
+#define NRF_UART_BAUDRATE_76800   NRF_UARTE_BAUDRATE_76800
+#define NRF_UART_BAUDRATE_115200  NRF_UARTE_BAUDRATE_115200
+#define NRF_UART_BAUDRATE_230400  NRF_UARTE_BAUDRATE_230400
+#define NRF_UART_BAUDRATE_250000  NRF_UARTE_BAUDRATE_250000
+#define NRF_UART_BAUDRATE_1000000 NRF_UARTE_BAUDRATE_1000000
+
+#endif
+
 typedef struct _machine_hard_uart_obj_t {
     mp_obj_base_t       base;
     const nrfx_uart_t * p_uart;      // Driver instance
+    machine_hard_uart_buf_t *buf;
 } machine_hard_uart_obj_t;
 
 static const nrfx_uart_t instance0 = NRFX_UART_INSTANCE(0);
 
+STATIC machine_hard_uart_buf_t machine_hard_uart_buf[1];
+
 STATIC const machine_hard_uart_obj_t machine_hard_uart_obj[] = {
-    {{&machine_hard_uart_type}, .p_uart = &instance0},
+    {{&machine_hard_uart_type}, .p_uart = &instance0, .buf = &machine_hard_uart_buf[0]},
 };
 
 void uart_init0(void) {
@@ -67,30 +118,39 @@ STATIC int uart_find(mp_obj_t id) {
     if (uart_id >= 0 && uart_id < MP_ARRAY_SIZE(machine_hard_uart_obj)) {
         return uart_id;
     }
-    mp_raise_ValueError("UART doesn't exist");
+    mp_raise_ValueError(MP_ERROR_TEXT("UART doesn't exist"));
 }
 
-void uart_irq_handler(mp_uint_t uart_id) {
-
+STATIC void uart_event_handler(nrfx_uart_event_t const *p_event, void *p_context) {
+    machine_hard_uart_obj_t *self = p_context;
+    if (p_event->type == NRFX_UART_EVT_RX_DONE) {
+        int chr = self->buf->rx_buf[0];
+        nrfx_uart_rx(self->p_uart, &self->buf->rx_buf[0], 1);
+        #if !MICROPY_PY_BLE_NUS && MICROPY_KBD_EXCEPTION
+        if (chr == mp_interrupt_char) {
+            mp_keyboard_interrupt();
+        } else
+        #endif
+        {
+            ringbuf_put((ringbuf_t*)&self->buf->rx_ringbuf, chr);
+        }
+    }
 }
 
-bool uart_rx_any(const machine_hard_uart_obj_t *uart_obj) {
-    // TODO: uart will block for now.
-    return true;
+bool uart_rx_any(const machine_hard_uart_obj_t *self) {
+    return self->buf->rx_ringbuf.iput != self->buf->rx_ringbuf.iget;
 }
 
 int uart_rx_char(const machine_hard_uart_obj_t * self) {
-    uint8_t ch;
-    nrfx_uart_rx(self->p_uart, &ch, 1);
-    return (int)ch;
+    return ringbuf_get((ringbuf_t*)&self->buf->rx_ringbuf);
 }
 
 STATIC nrfx_err_t uart_tx_char(const machine_hard_uart_obj_t * self, int c) {
     while (nrfx_uart_tx_in_progress(self->p_uart)) {
         ;
     }
-
-    return nrfx_uart_tx(self->p_uart, (uint8_t *)&c, 1);
+    self->buf->tx_buf[0] = c;
+    return nrfx_uart_tx(self->p_uart, &self->buf->tx_buf[0], 1);
 }
 
 
@@ -113,10 +173,9 @@ void uart_tx_strn_cooked(const machine_hard_uart_obj_t *uart_obj, const char *st
 /* MicroPython bindings                                                      */
 
 STATIC void machine_hard_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    mp_printf(print, "UART(0)");
 }
 
-
-
 /// \method init(id, baudrate)
 ///
 /// Initialise the UART bus with the given parameters:
@@ -141,12 +200,12 @@ STATIC mp_obj_t machine_hard_uart_make_new(const mp_obj_type_t *type, size_t n_a
 
     // flow control
 #if MICROPY_HW_UART1_HWFC
-    config.hwfc = NRF_UART_HWFC_ENABLED;
+    config.hal_cfg.hwfc = NRF_UART_HWFC_ENABLED;
 #else
-    config.hwfc = NRF_UART_HWFC_DISABLED;
+    config.hal_cfg.hwfc = NRF_UART_HWFC_DISABLED;
 #endif
 
-    config.parity = NRF_UART_PARITY_EXCLUDED;
+    config.hal_cfg.parity = NRF_UART_PARITY_EXCLUDED;
 
 #if (BLUETOOTH_SD == 100)
     config.interrupt_priority = 3;
@@ -156,7 +215,7 @@ STATIC mp_obj_t machine_hard_uart_make_new(const mp_obj_type_t *type, size_t n_a
 
     // These baudrates are not supported, it seems.
     if (args[ARG_baudrate].u_int < 1200 || args[ARG_baudrate].u_int > 1000000) {
-        mp_raise_ValueError("UART baudrate not supported");
+        mp_raise_ValueError(MP_ERROR_TEXT("UART baudrate not supported"));
     }
 
     // Magic: calculate 'baudrate' register from the input number.
@@ -181,10 +240,19 @@ STATIC mp_obj_t machine_hard_uart_make_new(const mp_obj_type_t *type, size_t n_a
     // Set context to this instance of UART
     config.p_context = (void *)self;
 
-    // Set NULL as callback function to keep it blocking
-    nrfx_uart_init(self->p_uart, &config, NULL);
+    // Initialise ring buffer
+    self->buf->rx_ringbuf.buf = self->buf->rx_ringbuf_array;
+    self->buf->rx_ringbuf.size = sizeof(self->buf->rx_ringbuf_array);
+    self->buf->rx_ringbuf.iget = 0;
+    self->buf->rx_ringbuf.iput = 0;
 
+    // Enable event callback and start asynchronous receive
+    nrfx_uart_init(self->p_uart, &config, uart_event_handler);
+    nrfx_uart_rx(self->p_uart, &self->buf->rx_buf[0], 1);
+
+#if NRFX_UART_ENABLED
     nrfx_uart_rx_enable(self->p_uart);
+#endif
 
     return MP_OBJ_FROM_PTR(self);
 }
@@ -224,13 +292,11 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_hard_uart_sendbreak_obj, machine_hard_u
 
 STATIC const mp_rom_map_elem_t machine_hard_uart_locals_dict_table[] = {
     // instance methods
-    /// \method read([nbytes])
     { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
-    /// \method readline()
     { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
-    /// \method readinto(buf[, nbytes])
     { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
-    /// \method writechar(buf)
+    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
+
     { MP_ROM_QSTR(MP_QSTR_writechar), MP_ROM_PTR(&machine_hard_uart_writechar_obj) },
     { MP_ROM_QSTR(MP_QSTR_readchar), MP_ROM_PTR(&machine_hard_uart_readchar_obj) },
     { MP_ROM_QSTR(MP_QSTR_sendbreak), MP_ROM_PTR(&machine_hard_uart_sendbreak_obj) },
@@ -250,6 +316,8 @@ STATIC mp_uint_t machine_hard_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_
 
     // read the data
     for (size_t i = 0; i < size; i++) {
+        while (!uart_rx_any(self)) {
+        }
         buf[i] = uart_rx_char(self);
     }
 
diff --git a/ports/nrf/modules/music/modmusic.c b/ports/nrf/modules/music/modmusic.c
index 84a014c12df85..168e7613f581b 100644
--- a/ports/nrf/modules/music/modmusic.c
+++ b/ports/nrf/modules/music/modmusic.c
@@ -126,7 +126,7 @@ void microbit_music_tick(void) {
             music_data->async_state = ASYNC_MUSIC_STATE_NEXT_NOTE;
         } else {
             // a note
-            mp_uint_t note_len;
+            size_t note_len;
             const char *note_str = mp_obj_str_get_data(note, &note_len);
             uint32_t delay_on = start_note(note_str, note_len, music_data->async_pin);
             music_data->async_wait_ticks = ticks + delay_on;
@@ -284,7 +284,7 @@ STATIC mp_obj_t microbit_music_stop(mp_uint_t n_args, const mp_obj_t *args) {
 #ifdef MICROPY_HW_MUSIC_PIN
         pin = mp_hal_get_pin_obj(MP_OBJ_NEW_SMALL_INT(MICROPY_HW_MUSIC_PIN));
 #else
-        mp_raise_ValueError("pin parameter not given");
+        mp_raise_ValueError(MP_ERROR_TEXT("pin parameter not given"));
 #endif
     } else {
         pin = (pin_obj_t *)args[0];
@@ -337,7 +337,7 @@ STATIC mp_obj_t microbit_music_play(mp_uint_t n_args, const mp_obj_t *pos_args,
 #ifdef MICROPY_HW_MUSIC_PIN
         pin = mp_hal_get_pin_obj(MP_OBJ_NEW_SMALL_INT(MICROPY_HW_MUSIC_PIN));
 #else
-        mp_raise_ValueError("pin parameter not given");
+        mp_raise_ValueError(MP_ERROR_TEXT("pin parameter not given"));
 #endif
     } else {
         pin = (pin_obj_t *)args[1].u_obj;
@@ -392,7 +392,7 @@ STATIC mp_obj_t microbit_music_pitch(mp_uint_t n_args, const mp_obj_t *pos_args,
 #ifdef MICROPY_HW_MUSIC_PIN
         pin = mp_hal_get_pin_obj(MP_OBJ_NEW_SMALL_INT(MICROPY_HW_MUSIC_PIN));
 #else
-        mp_raise_ValueError("pin parameter not given");
+        mp_raise_ValueError(MP_ERROR_TEXT("pin parameter not given"));
 #endif
     } else {
         pin = (pin_obj_t *)args[2].u_obj;
@@ -408,7 +408,7 @@ STATIC mp_obj_t microbit_music_pitch(mp_uint_t n_args, const mp_obj_t *pos_args,
 //TODO: pwm_release(pin->name);
     } else if (pwm_set_period_us(1000000/frequency)) {
         pwm_release(pin->pin); // TODO: remove pin setting.
-        mp_raise_ValueError("invalid pitch");
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid pitch"));
     }
     if (duration >= 0) {
         // use async machinery to stop the pitch after the duration
diff --git a/ports/nrf/modules/random/modrandom.c b/ports/nrf/modules/random/modrandom.c
deleted file mode 100644
index f67bffb27786a..0000000000000
--- a/ports/nrf/modules/random/modrandom.c
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
- * This file is part of the MicroPython project, http://micropython.org/
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2016 Paul Sokolovsky
- * Copyright (c) 2016 Damien P. George
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include <assert.h>
-#include <string.h>
-
-#include "py/runtime.h"
-
-#if MICROPY_PY_RANDOM_HW_RNG
-
-#include "nrf_rng.h"
-#include "modrandom.h"
-
-#if BLUETOOTH_SD
-#include "nrf_soc.h"
-#include "ble_drv.h"
-#define BLUETOOTH_STACK_ENABLED() (ble_drv_stack_enabled())
-#endif
-
-static inline uint32_t generate_hw_random(void) {
-    uint32_t retval = 0;
-    uint8_t * p_retval = (uint8_t *)&retval;
-
-    nrf_rng_event_clear(NRF_RNG_EVENT_VALRDY);
-    nrf_rng_task_trigger(NRF_RNG_TASK_START);
-
-    for (uint16_t i = 0; i < 4; i++) {
-        while (!nrf_rng_event_get(NRF_RNG_EVENT_VALRDY)) {
-            ;
-        }
-
-        nrf_rng_event_clear(NRF_RNG_EVENT_VALRDY);
-        p_retval[i] = nrf_rng_random_value_get();
-    }
-
-    nrf_rng_task_trigger(NRF_RNG_TASK_STOP);
-
-    return retval;
-}
-
-uint32_t machine_rng_generate_random_word(void) {
-
-#if BLUETOOTH_SD
-    if (BLUETOOTH_STACK_ENABLED() == 1) {
-        uint32_t retval = 0;
-        uint32_t status;
-        do {
-            status = sd_rand_application_vector_get((uint8_t *)&retval, 4); // Extract 4 bytes
-        } while (status != 0);
-
-	return retval;
-    }
-#endif
-
-    return generate_hw_random();
-}
-
-static inline int rand30(void) {
-    uint32_t val = machine_rng_generate_random_word();
-    return (val & 0x3fffffff); // binary mask b00111111111111111111111111111111
-}
-
-static inline int randbelow(int n) {
-    return rand30() % n;
-}
-
-STATIC mp_obj_t mod_random_getrandbits(mp_obj_t num_in) {
-    int n = mp_obj_get_int(num_in);
-    if (n > 30 || n == 0) {
-        mp_raise_ValueError(NULL);
-    }
-    uint32_t mask = ~0;
-    // Beware of C undefined behavior when shifting by >= than bit size
-    mask >>= (32 - n);
-    return mp_obj_new_int_from_uint(rand30() & mask);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_random_getrandbits_obj, mod_random_getrandbits);
-
-STATIC mp_obj_t mod_random_randrange(size_t n_args, const mp_obj_t *args) {
-    mp_int_t start = mp_obj_get_int(args[0]);
-    if (n_args == 1) {
-        // range(stop)
-        if (start > 0) {
-            return mp_obj_new_int(randbelow(start));
-        } else {
-            mp_raise_ValueError(NULL);
-        }
-    } else {
-        mp_int_t stop = mp_obj_get_int(args[1]);
-        if (n_args == 2) {
-            // range(start, stop)
-            if (start < stop) {
-                return mp_obj_new_int(start + randbelow(stop - start));
-            } else {
-                mp_raise_ValueError(NULL);
-            }
-        } else {
-            // range(start, stop, step)
-            mp_int_t step = mp_obj_get_int(args[2]);
-            mp_int_t n;
-            if (step > 0) {
-                n = (stop - start + step - 1) / step;
-            } else if (step < 0) {
-                n = (stop - start + step + 1) / step;
-            } else {
-                mp_raise_ValueError(NULL);
-            }
-            if (n > 0) {
-                return mp_obj_new_int(start + step * randbelow(n));
-            } else {
-                mp_raise_ValueError(NULL);
-            }
-        }
-    }
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_random_randrange_obj, 1, 3, mod_random_randrange);
-
-STATIC mp_obj_t mod_random_randint(mp_obj_t a_in, mp_obj_t b_in) {
-    mp_int_t a = mp_obj_get_int(a_in);
-    mp_int_t b = mp_obj_get_int(b_in);
-    if (a <= b) {
-        return mp_obj_new_int(a + randbelow(b - a + 1));
-    } else {
-        mp_raise_ValueError(NULL);
-    }
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_random_randint_obj, mod_random_randint);
-
-STATIC mp_obj_t mod_random_choice(mp_obj_t seq) {
-    mp_int_t len = mp_obj_get_int(mp_obj_len(seq));
-    if (len > 0) {
-        return mp_obj_subscr(seq, mp_obj_new_int(randbelow(len)), MP_OBJ_SENTINEL);
-    } else {
-        nlr_raise(mp_obj_new_exception(&mp_type_IndexError));
-    }
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_random_choice_obj, mod_random_choice);
-
-#if MICROPY_PY_BUILTINS_FLOAT
-
-// returns a number in the range [0..1) using RNG to fill in the fraction bits
-STATIC mp_float_t randfloat(void) {
-    #if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
-    typedef uint64_t mp_float_int_t;
-    #elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
-    typedef uint32_t mp_float_int_t;
-    #endif
-    union {
-        mp_float_t f;
-        #if MP_ENDIANNESS_LITTLE
-        struct { mp_float_int_t frc:MP_FLOAT_FRAC_BITS, exp:MP_FLOAT_EXP_BITS, sgn:1; } p;
-        #else
-        struct { mp_float_int_t sgn:1, exp:MP_FLOAT_EXP_BITS, frc:MP_FLOAT_FRAC_BITS; } p;
-        #endif
-    } u;
-    u.p.sgn = 0;
-    u.p.exp = (1 << (MP_FLOAT_EXP_BITS - 1)) - 1;
-    if (MP_FLOAT_FRAC_BITS <= 30) {
-        u.p.frc = rand30();
-    } else {
-        u.p.frc = ((uint64_t)rand30() << 30) | (uint64_t)rand30();
-    }
-    return u.f - 1;
-}
-
-STATIC mp_obj_t mod_random_random(void) {
-    return mp_obj_new_float(randfloat());
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_random_random_obj, mod_random_random);
-
-STATIC mp_obj_t mod_random_uniform(mp_obj_t a_in, mp_obj_t b_in) {
-    mp_float_t a = mp_obj_get_float(a_in);
-    mp_float_t b = mp_obj_get_float(b_in);
-    return mp_obj_new_float(a + (b - a) * randfloat());
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_random_uniform_obj, mod_random_uniform);
-
-#endif
-
-STATIC const mp_rom_map_elem_t mp_module_random_globals_table[] = {
-    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_random) },
-    { MP_ROM_QSTR(MP_QSTR_getrandbits), MP_ROM_PTR(&mod_random_getrandbits_obj) },
-    { MP_ROM_QSTR(MP_QSTR_randrange), MP_ROM_PTR(&mod_random_randrange_obj) },
-    { MP_ROM_QSTR(MP_QSTR_randint), MP_ROM_PTR(&mod_random_randint_obj) },
-    { MP_ROM_QSTR(MP_QSTR_choice), MP_ROM_PTR(&mod_random_choice_obj) },
-#if MICROPY_PY_BUILTINS_FLOAT
-    { MP_ROM_QSTR(MP_QSTR_random), MP_ROM_PTR(&mod_random_random_obj) },
-    { MP_ROM_QSTR(MP_QSTR_uniform), MP_ROM_PTR(&mod_random_uniform_obj) },
-#endif
-};
-
-STATIC MP_DEFINE_CONST_DICT(mp_module_random_globals, mp_module_random_globals_table);
-
-const mp_obj_module_t random_module = {
-    .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_random_globals,
-};
-
-#endif // MICROPY_PY_RANDOM_HW_RNG
diff --git a/ports/nrf/modules/ubluepy/ubluepy_characteristic.c b/ports/nrf/modules/ubluepy/ubluepy_characteristic.c
index 2ca7f2f42759a..9adafaa64efdf 100644
--- a/ports/nrf/modules/ubluepy/ubluepy_characteristic.c
+++ b/ports/nrf/modules/ubluepy/ubluepy_characteristic.c
@@ -63,7 +63,7 @@ STATIC mp_obj_t ubluepy_characteristic_make_new(const mp_obj_type_t *type, size_
         s->p_uuid = MP_OBJ_TO_PTR(uuid_obj);
         // (void)sd_characterstic_add(s);
     } else {
-        mp_raise_ValueError("Invalid UUID parameter");
+        mp_raise_ValueError(MP_ERROR_TEXT("Invalid UUID parameter"));
     }
 
     if (args[1].u_int > 0) {
diff --git a/ports/nrf/modules/ubluepy/ubluepy_delegate.c b/ports/nrf/modules/ubluepy/ubluepy_delegate.c
index 07bb7f49286fd..74ad52bbfa35b 100644
--- a/ports/nrf/modules/ubluepy/ubluepy_delegate.c
+++ b/ports/nrf/modules/ubluepy/ubluepy_delegate.c
@@ -72,7 +72,7 @@ STATIC const mp_rom_map_elem_t ubluepy_delegate_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_handleConnection),   MP_ROM_PTR(&ubluepy_delegate_handle_conn_obj) },
     { MP_ROM_QSTR(MP_QSTR_handleNotification), MP_ROM_PTR(&ubluepy_delegate_handle_notif_obj) },
 #if 0
-	{ MP_ROM_QSTR(MP_QSTR_handleDiscovery),    MP_ROM_PTR(&ubluepy_delegate_handle_disc_obj) },
+    { MP_ROM_QSTR(MP_QSTR_handleDiscovery),    MP_ROM_PTR(&ubluepy_delegate_handle_disc_obj) },
 #endif
 };
 
diff --git a/ports/nrf/modules/ubluepy/ubluepy_peripheral.c b/ports/nrf/modules/ubluepy/ubluepy_peripheral.c
index 3a45e56a07648..8f07daa2a3297 100644
--- a/ports/nrf/modules/ubluepy/ubluepy_peripheral.c
+++ b/ports/nrf/modules/ubluepy/ubluepy_peripheral.c
@@ -481,7 +481,7 @@ STATIC const mp_rom_map_elem_t ubluepy_peripheral_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_advertise),              MP_ROM_PTR(&ubluepy_peripheral_advertise_obj) },
 #endif
 #if MICROPY_PY_UBLUEPY_OBSERVER
-	// Nothing yet.
+    // Nothing yet.
 #endif
 };
 
diff --git a/ports/nrf/modules/ubluepy/ubluepy_service.c b/ports/nrf/modules/ubluepy/ubluepy_service.c
index e5bf42a09fd30..7b51ce3055eba 100644
--- a/ports/nrf/modules/ubluepy/ubluepy_service.c
+++ b/ports/nrf/modules/ubluepy/ubluepy_service.c
@@ -68,13 +68,13 @@ STATIC mp_obj_t ubluepy_service_make_new(const mp_obj_type_t *type, size_t n_arg
         if (type > 0 &&  type <= UBLUEPY_SERVICE_PRIMARY) {
             s->type = type;
         } else {
-            mp_raise_ValueError("Invalid Service type");
+            mp_raise_ValueError(MP_ERROR_TEXT("Invalid Service type"));
         }
 
         (void)ble_drv_service_add(s);
 
     } else {
-        mp_raise_ValueError("Invalid UUID parameter");
+        mp_raise_ValueError(MP_ERROR_TEXT("Invalid UUID parameter"));
     }
 
     // clear reference to peripheral
@@ -125,7 +125,7 @@ STATIC mp_obj_t service_get_characteristic(mp_obj_t self_in, mp_obj_t uuid) {
 
     // validate that there is an UUID object passed in as parameter
     if (!(mp_obj_is_type(uuid, &ubluepy_uuid_type))) {
-        mp_raise_ValueError("Invalid UUID parameter");
+        mp_raise_ValueError(MP_ERROR_TEXT("Invalid UUID parameter"));
     }
 
     mp_obj_t * chars     = NULL;
@@ -162,7 +162,7 @@ STATIC const mp_rom_map_elem_t ubluepy_service_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_addCharacteristic),  MP_ROM_PTR(&ubluepy_service_add_char_obj) },
     { MP_ROM_QSTR(MP_QSTR_getCharacteristics), MP_ROM_PTR(&ubluepy_service_get_chars_obj) },
 #if 0
-	// Properties
+    // Properties
     { MP_ROM_QSTR(MP_QSTR_peripheral), MP_ROM_PTR(&ubluepy_service_get_peripheral_obj) },
 #endif
     { MP_ROM_QSTR(MP_QSTR_uuid),       MP_ROM_PTR(&ubluepy_service_get_uuid_obj) },
diff --git a/ports/nrf/modules/ubluepy/ubluepy_uuid.c b/ports/nrf/modules/ubluepy/ubluepy_uuid.c
index cbcb1009682f7..7b4a09dba4aba 100644
--- a/ports/nrf/modules/ubluepy/ubluepy_uuid.c
+++ b/ports/nrf/modules/ubluepy/ubluepy_uuid.c
@@ -122,7 +122,7 @@ STATIC mp_obj_t ubluepy_uuid_make_new(const mp_obj_type_t *type, size_t n_args,
 
             ble_drv_uuid_add_vs(buffer, &s->uuid_vs_idx);
         } else {
-            mp_raise_ValueError("Invalid UUID string length");
+            mp_raise_ValueError(MP_ERROR_TEXT("Invalid UUID string length"));
         }
     } else if (mp_obj_is_type(uuid_obj, &ubluepy_uuid_type)) {
         // deep copy instance
@@ -131,7 +131,7 @@ STATIC mp_obj_t ubluepy_uuid_make_new(const mp_obj_type_t *type, size_t n_args,
         s->value[0] = p_old->value[0];
         s->value[1] = p_old->value[1];
     } else {
-        mp_raise_ValueError("Invalid UUID parameter");
+        mp_raise_ValueError(MP_ERROR_TEXT("Invalid UUID parameter"));
     }
 
     return MP_OBJ_FROM_PTR(s);
diff --git a/ports/nrf/modules/uos/microbitfs.c b/ports/nrf/modules/uos/microbitfs.c
index d4c5a119a123d..7f16372cf2224 100644
--- a/ports/nrf/modules/uos/microbitfs.c
+++ b/ports/nrf/modules/uos/microbitfs.c
@@ -31,7 +31,7 @@
 
 #include "microbitfs.h"
 #include "drivers/flash.h"
-#include "modrandom.h"
+#include "drivers/rng.h"
 #include "py/obj.h"
 #include "py/stream.h"
 #include "py/runtime.h"
@@ -175,7 +175,7 @@ STATIC void init_limits(void) {
 }
 
 STATIC void randomise_start_index(void) {
-    start_index = machine_rng_generate_random_word() % chunks_in_file_system + 1;
+    start_index = rng_generate_random_word() % chunks_in_file_system + 1;
 }
 
 void microbit_filesystem_init(void) {
@@ -377,7 +377,7 @@ STATIC file_descriptor_obj *microbit_file_descriptor_new(uint8_t start_chunk, bo
 }
 
 STATIC mp_obj_t microbit_remove(mp_obj_t filename) {
-    mp_uint_t name_len;
+    size_t name_len;
     const char *name = mp_obj_str_get_data(filename, &name_len);
     mp_uint_t index = microbit_find_file(name, name_len);
     if (index == 255) {
@@ -389,7 +389,7 @@ STATIC mp_obj_t microbit_remove(mp_obj_t filename) {
 
 STATIC void check_file_open(file_descriptor_obj *self) {
     if (!self->open) {
-        mp_raise_ValueError("I/O operation on closed file");
+        mp_raise_ValueError(MP_ERROR_TEXT("I/O operation on closed file"));
     }
 }
 
@@ -487,7 +487,7 @@ STATIC mp_obj_t microbit_file_list(void) {
 }
 
 STATIC mp_obj_t microbit_file_size(mp_obj_t filename) {
-    mp_uint_t name_len;
+    size_t name_len;
     const char *name = mp_obj_str_get_data(filename, &name_len);
     uint8_t chunk = microbit_find_file(name, name_len);
     if (chunk == 255) {
@@ -659,7 +659,7 @@ mp_obj_t uos_mbfs_open(size_t n_args, const mp_obj_t *args) {
     int read = -1;
     int text = -1;
     if (n_args == 2) {
-        mp_uint_t len;
+        size_t len;
         const char *mode = mp_obj_str_get_data(args[1], &len);
         for (mp_uint_t i = 0; i < len; i++) {
             if (mode[i] == 'r' || mode[i] == 'w') {
@@ -677,7 +677,7 @@ mp_obj_t uos_mbfs_open(size_t n_args, const mp_obj_t *args) {
             }
         }
     }
-    mp_uint_t name_len;
+    size_t name_len;
     const char *filename = mp_obj_str_get_data(args[0], &name_len);
     file_descriptor_obj *res = microbit_file_open(filename, name_len, read == 0, text == 0);
     if (res == NULL) {
@@ -685,7 +685,7 @@ mp_obj_t uos_mbfs_open(size_t n_args, const mp_obj_t *args) {
     }
     return res;
 mode_error:
-    mp_raise_ValueError("illegal mode");
+    mp_raise_ValueError(MP_ERROR_TEXT("illegal mode"));
 }
 
 STATIC mp_obj_t uos_mbfs_stat(mp_obj_t filename) {
diff --git a/ports/nrf/modules/uos/moduos.c b/ports/nrf/modules/uos/moduos.c
index 03a8dba069985..98a5661f4f9ae 100644
--- a/ports/nrf/modules/uos/moduos.c
+++ b/ports/nrf/modules/uos/moduos.c
@@ -37,12 +37,10 @@
 #include "extmod/vfs.h"
 #include "extmod/vfs_fat.h"
 #include "genhdr/mpversion.h"
-//#include "timeutils.h"
 #include "uart.h"
-//#include "portmodules.h"
 
 #if MICROPY_HW_ENABLE_RNG
-#include "modrandom.h"
+#include "drivers/rng.h"
 #endif // MICROPY_HW_ENABLE_RNG
 
 /// \module os - basic "operating system" services
@@ -105,7 +103,7 @@ STATIC mp_obj_t os_urandom(mp_obj_t num) {
     vstr_t vstr;
     vstr_init_len(&vstr, n);
     for (int i = 0; i < n; i++) {
-        vstr.buf[i] = (uint8_t)(machine_rng_generate_random_word() & 0xFF);
+        vstr.buf[i] = (uint8_t)(rng_generate_random_word() & 0xFF);
     }
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
@@ -128,7 +126,7 @@ STATIC mp_obj_t os_dupterm(mp_uint_t n_args, const mp_obj_t *args) {
         } else if (mp_obj_get_type(args[0]) == &machine_hard_uart_type) {
             MP_STATE_PORT(board_stdio_uart) = args[0];
         } else {
-            mp_raise_ValueError("need a UART object");
+            mp_raise_ValueError(MP_ERROR_TEXT("need a UART object"));
         }
         return mp_const_none;
     }
diff --git a/ports/nrf/mpconfigport.h b/ports/nrf/mpconfigport.h
index 0e3cf7b39d6ee..28076114fe42a 100644
--- a/ports/nrf/mpconfigport.h
+++ b/ports/nrf/mpconfigport.h
@@ -33,7 +33,6 @@
 #ifndef MICROPY_VFS
 #define MICROPY_VFS                 (0)
 #endif
-#define MICROPY_VFS_FAT             (MICROPY_VFS)
 #define MICROPY_ALLOC_PATH_MAX      (512)
 #define MICROPY_PERSISTENT_CODE_LOAD (0)
 #define MICROPY_EMIT_THUMB          (0)
@@ -45,9 +44,10 @@
 #define MICROPY_ENABLE_FINALISER    (1)
 #define MICROPY_STACK_CHECK         (1)
 #define MICROPY_HELPER_REPL         (1)
+#define MICROPY_REPL_INFO           (1)
 #define MICROPY_REPL_EMACS_KEYS     (0)
 #define MICROPY_REPL_AUTO_INDENT    (1)
-#define MICROPY_KBD_EXCEPTION       (0)
+#define MICROPY_KBD_EXCEPTION       (1)
 #define MICROPY_ENABLE_SOURCE_LINE  (0)
 #define MICROPY_LONGINT_IMPL        (MICROPY_LONGINT_IMPL_MPZ)
 #if NRF51
@@ -118,8 +118,8 @@
 #define MICROPY_PY_IO_FILEIO        (0)
 #define MICROPY_PY_UERRNO           (0)
 #define MICROPY_PY_UBINASCII        (0)
-#define MICROPY_PY_URANDOM          (0)
-#define MICROPY_PY_URANDOM_EXTRA_FUNCS (0)
+#define MICROPY_PY_URANDOM          (1)
+#define MICROPY_PY_URANDOM_EXTRA_FUNCS (1)
 #define MICROPY_PY_UCTYPES          (0)
 #define MICROPY_PY_UZLIB            (0)
 #define MICROPY_PY_UJSON            (0)
@@ -174,10 +174,6 @@
 #define MICROPY_PY_MACHINE_RTCOUNTER (0)
 #endif
 
-#ifndef MICROPY_PY_RANDOM_HW_RNG
-#define MICROPY_PY_RANDOM_HW_RNG    (0)
-#endif
-
 
 #define MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF   (1)
 #define MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE  (0)
@@ -199,7 +195,7 @@
 
 #define BYTES_PER_WORD (4)
 
-#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void*)((mp_uint_t)(p) | 1))
+#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)((mp_uint_t)(p) | 1))
 
 #define MP_SSIZE_MAX (0x7fffffff)
 
@@ -218,7 +214,6 @@ extern const struct _mp_obj_module_t mp_module_utime;
 extern const struct _mp_obj_module_t mp_module_uos;
 extern const struct _mp_obj_module_t mp_module_ubluepy;
 extern const struct _mp_obj_module_t music_module;
-extern const struct _mp_obj_module_t random_module;
 
 #if MICROPY_PY_UBLUEPY
 #define UBLUEPY_MODULE                      { MP_ROM_QSTR(MP_QSTR_ubluepy), MP_ROM_PTR(&mp_module_ubluepy) },
@@ -232,12 +227,6 @@ extern const struct _mp_obj_module_t random_module;
 #define MUSIC_MODULE
 #endif
 
-#if MICROPY_PY_RANDOM_HW_RNG
-#define RANDOM_MODULE                       { MP_ROM_QSTR(MP_QSTR_random), MP_ROM_PTR(&random_module) },
-#else
-#define RANDOM_MODULE
-#endif
-
 #if BOARD_SPECIFIC_MODULES
 #include "boardmodules.h"
 #define MICROPY_BOARD_BUILTINS BOARD_MODULES
@@ -263,7 +252,6 @@ extern const struct _mp_obj_module_t ble_module;
     BLE_MODULE \
     MUSIC_MODULE \
     UBLUEPY_MODULE \
-    RANDOM_MODULE \
     MICROPY_BOARD_BUILTINS \
 
 
@@ -275,16 +263,11 @@ extern const struct _mp_obj_module_t ble_module;
     { MP_ROM_QSTR(MP_QSTR_utime), MP_ROM_PTR(&mp_module_utime) }, \
     { MP_ROM_QSTR(MP_QSTR_uos), MP_ROM_PTR(&mp_module_uos) }, \
     MUSIC_MODULE \
-    RANDOM_MODULE \
     MICROPY_BOARD_BUILTINS \
 
 
 #endif // BLUETOOTH_SD
 
-#define MICROPY_PORT_BUILTIN_MODULE_WEAK_LINKS \
-    { MP_ROM_QSTR(MP_QSTR_os), MP_ROM_PTR(&mp_module_uos) }, \
-    { MP_ROM_QSTR(MP_QSTR_time), MP_ROM_PTR(&mp_module_utime) }, \
-
 // extra built in names to add to the global namespace
 #define MICROPY_PORT_BUILTINS \
     { MP_ROM_QSTR(MP_QSTR_help), MP_ROM_PTR(&mp_builtin_help_obj) }, \
diff --git a/ports/nrf/mphalport.c b/ports/nrf/mphalport.c
index 9ce904514ecc6..4469adc80d84f 100644
--- a/ports/nrf/mphalport.c
+++ b/ports/nrf/mphalport.c
@@ -30,6 +30,7 @@
 #include "py/mphal.h"
 #include "py/mperrno.h"
 #include "py/runtime.h"
+#include "py/stream.h"
 #include "uart.h"
 #include "nrfx_errors.h"
 #include "nrfx_config.h"
@@ -53,11 +54,23 @@ void mp_hal_set_interrupt_char(int c) {
 #endif
 
 #if !MICROPY_PY_BLE_NUS
+uintptr_t mp_hal_stdio_poll(uintptr_t poll_flags) {
+    uintptr_t ret = 0;
+    if ((poll_flags & MP_STREAM_POLL_RD) && MP_STATE_PORT(board_stdio_uart) != NULL
+        && uart_rx_any(MP_STATE_PORT(board_stdio_uart))) {
+        ret |= MP_STREAM_POLL_RD;
+    }
+    return ret;
+}
+#endif
+
+#if !MICROPY_PY_BLE_NUS && !MICROPY_HW_USB_CDC
 int mp_hal_stdin_rx_chr(void) {
     for (;;) {
         if (MP_STATE_PORT(board_stdio_uart) != NULL && uart_rx_any(MP_STATE_PORT(board_stdio_uart))) {
             return uart_rx_char(MP_STATE_PORT(board_stdio_uart));
         }
+        __WFI();
     }
 
     return 0;
@@ -80,19 +93,18 @@ void mp_hal_stdout_tx_str(const char *str) {
     mp_hal_stdout_tx_strn(str, strlen(str));
 }
 
-void mp_hal_delay_us(mp_uint_t us)
-{
+void mp_hal_delay_us(mp_uint_t us) {
     if (us == 0) {
         return;
     }
-
-    register uint32_t delay __ASM ("r0") = us;
+    register uint32_t delay __ASM("r0") = us;
     __ASM volatile (
-#ifdef NRF51
-            ".syntax unified\n"
-#endif
         "1:\n"
+        #ifdef NRF51
+        " SUB %0, %0, #1\n"
+        #else
         " SUBS %0, %0, #1\n"
+        #endif
         " NOP\n"
         " NOP\n"
         " NOP\n"
@@ -105,7 +117,7 @@ void mp_hal_delay_us(mp_uint_t us)
         " NOP\n"
         " NOP\n"
         " NOP\n"
-#ifdef NRF52
+        #if defined(NRF52) || defined(NRF9160_XXAA)
         " NOP\n"
         " NOP\n"
         " NOP\n"
@@ -152,13 +164,12 @@ void mp_hal_delay_us(mp_uint_t us)
         " NOP\n"
         " NOP\n"
         " NOP\n"
-#endif
+        #endif
         " BNE 1b\n"
         : "+r" (delay));
 }
 
-void mp_hal_delay_ms(mp_uint_t ms)
-{
+void mp_hal_delay_ms(mp_uint_t ms) {
     for (mp_uint_t i = 0; i < ms; i++)
     {
         mp_hal_delay_us(999);
@@ -169,21 +180,21 @@ void mp_hal_delay_ms(mp_uint_t ms)
 
 static const char nrfx_error_unknown[1] = "";
 
-static const char nrfx_error_success[]            = "NRFX_SUCCESS";
-static const char nrfx_error_internal[]           = "NRFX_ERROR_INTERNAL";
-static const char nrfx_error_no_mem[]             = "NRFX_ERROR_NO_MEM";
-static const char nrfx_error_not_supported[]      = "NRFX_ERROR_NOT_SUPPORTED";
-static const char nrfx_error_invalid_param[]      = "NRFX_ERROR_INVALID_PARAM";
-static const char nrfx_error_invalid_state[]      = "NRFX_ERROR_INVALID_STATE";
-static const char nrfx_error_invalid_length[]     = "NRFX_ERROR_INVALID_LENGTH";
-static const char nrfx_error_timeout[]            = "NRFX_ERROR_TIMEOUT";
-static const char nrfx_error_forbidden[]          = "NRFX_ERROR_FORBIDDEN";
-static const char nrfx_error_null[]               = "NRFX_ERROR_NULL";
-static const char nrfx_error_invalid_addr[]       = "NRFX_ERROR_INVALID_ADDR";
-static const char nrfx_error_busy[]               = "NRFX_ERROR_BUSY";
+static const char nrfx_error_success[] = "NRFX_SUCCESS";
+static const char nrfx_error_internal[] = "NRFX_ERROR_INTERNAL";
+static const char nrfx_error_no_mem[] = "NRFX_ERROR_NO_MEM";
+static const char nrfx_error_not_supported[] = "NRFX_ERROR_NOT_SUPPORTED";
+static const char nrfx_error_invalid_param[] = "NRFX_ERROR_INVALID_PARAM";
+static const char nrfx_error_invalid_state[] = "NRFX_ERROR_INVALID_STATE";
+static const char nrfx_error_invalid_length[] = "NRFX_ERROR_INVALID_LENGTH";
+static const char nrfx_error_timeout[] = "NRFX_ERROR_TIMEOUT";
+static const char nrfx_error_forbidden[] = "NRFX_ERROR_FORBIDDEN";
+static const char nrfx_error_null[] = "NRFX_ERROR_NULL";
+static const char nrfx_error_invalid_addr[] = "NRFX_ERROR_INVALID_ADDR";
+static const char nrfx_error_busy[] = "NRFX_ERROR_BUSY";
 static const char nrfx_error_already_initalized[] = "NRFX_ERROR_ALREADY_INITIALIZED";
 
-static const char * nrfx_error_strings[13] = {
+static const char *nrfx_error_strings[13] = {
     nrfx_error_success,
     nrfx_error_internal,
     nrfx_error_no_mem,
@@ -200,16 +211,16 @@ static const char * nrfx_error_strings[13] = {
 };
 
 static const char nrfx_drv_error_twi_err_overrun[] = "NRFX_ERROR_DRV_TWI_ERR_OVERRUN";
-static const char nrfx_drv_error_twi_err_anack[]   = "NRFX_ERROR_DRV_TWI_ERR_ANACK";
-static const char nrfx_drv_error_twi_err_dnack[]   = "NRFX_ERROR_DRV_TWI_ERR_DNACK";
+static const char nrfx_drv_error_twi_err_anack[] = "NRFX_ERROR_DRV_TWI_ERR_ANACK";
+static const char nrfx_drv_error_twi_err_dnack[] = "NRFX_ERROR_DRV_TWI_ERR_DNACK";
 
-static const char * nrfx_drv_error_strings[3] = {
+static const char *nrfx_drv_error_strings[3] = {
     nrfx_drv_error_twi_err_overrun,
     nrfx_drv_error_twi_err_anack,
     nrfx_drv_error_twi_err_dnack
 };
 
-const char * nrfx_error_code_lookup(uint32_t err_code) {
+const char *nrfx_error_code_lookup(uint32_t err_code) {
     if (err_code >= NRFX_ERROR_BASE_NUM && err_code <= NRFX_ERROR_BASE_NUM + 13) {
         return nrfx_error_strings[err_code - NRFX_ERROR_BASE_NUM];
     } else if (err_code >= NRFX_ERROR_DRIVERS_BASE_NUM && err_code <= NRFX_ERROR_DRIVERS_BASE_NUM + 3) {
diff --git a/ports/nrf/mphalport.h b/ports/nrf/mphalport.h
index 18ff454fe6dc9..5614be29fa29f 100644
--- a/ports/nrf/mphalport.h
+++ b/ports/nrf/mphalport.h
@@ -35,14 +35,14 @@
 
 typedef enum
 {
-  HAL_OK       = 0x00,
-  HAL_ERROR    = 0x01,
-  HAL_BUSY     = 0x02,
-  HAL_TIMEOUT  = 0x03
+    HAL_OK       = 0x00,
+    HAL_ERROR    = 0x01,
+    HAL_BUSY     = 0x02,
+    HAL_TIMEOUT  = 0x03
 } HAL_StatusTypeDef;
 
 static inline uint32_t hal_tick_fake(void) {
-	return 0;
+    return 0;
 }
 
 #define mp_hal_ticks_ms hal_tick_fake // TODO: implement. Right now, return 0 always
@@ -58,14 +58,14 @@ void mp_hal_stdout_tx_str(const char *str);
 void mp_hal_delay_ms(mp_uint_t ms);
 void mp_hal_delay_us(mp_uint_t us);
 
-const char * nrfx_error_code_lookup(uint32_t err_code);
+const char *nrfx_error_code_lookup(uint32_t err_code);
 
-#define mp_hal_pin_obj_t const pin_obj_t*
+#define mp_hal_pin_obj_t const pin_obj_t *
 #define mp_hal_get_pin_obj(o)    pin_find(o)
 #define mp_hal_pin_high(p)       nrf_gpio_pin_set(p->pin)
 #define mp_hal_pin_low(p)        nrf_gpio_pin_clear(p->pin)
 #define mp_hal_pin_read(p)       (nrf_gpio_pin_dir_get(p->pin) == NRF_GPIO_PIN_DIR_OUTPUT) ? nrf_gpio_pin_out_read(p->pin) : nrf_gpio_pin_read(p->pin)
-#define mp_hal_pin_write(p, v)   do { if (v) { mp_hal_pin_high(p); } else { mp_hal_pin_low(p); } } while (0)
+#define mp_hal_pin_write(p, v)   ((v) ? mp_hal_pin_high(p) : mp_hal_pin_low(p))
 #define mp_hal_pin_od_low(p)     mp_hal_pin_low(p)
 #define mp_hal_pin_od_high(p)    mp_hal_pin_high(p)
 #define mp_hal_pin_open_drain(p) nrf_gpio_cfg_input(p->pin, NRF_GPIO_PIN_NOPULL)
diff --git a/ports/nrf/nrf52_af.csv b/ports/nrf/nrf52_af.csv
index 59686ff901037..bcb05c227f21e 100644
--- a/ports/nrf/nrf52_af.csv
+++ b/ports/nrf/nrf52_af.csv
@@ -1,9 +1,9 @@
 P0,P0
 P1,P1
-P2,P2
-P3,P3
-P4,P4
-P5,P5
+P2,P2,ADC1_CH0
+P3,P3,ADC1_CH1
+P4,P4,ADC1_CH2
+P5,P5,ADC1_CH3
 P6,P6
 P7,P7
 P8,P8
@@ -26,10 +26,10 @@ P24,P24
 P25,P25
 P26,P26
 P27,P27
-P28,P28
-P29,P29
-P30,P30
-P31,P31
+P28,P28,ADC1_CH4
+P29,P29,ADC1_CH5
+P30,P30,ADC1_CH6
+P31,P31,ADC1_CH7
 P32,P32
 P33,P33
 P34,P34
diff --git a/ports/nrf/nrf91_af.csv b/ports/nrf/nrf91_af.csv
new file mode 100644
index 0000000000000..7d060f68fff36
--- /dev/null
+++ b/ports/nrf/nrf91_af.csv
@@ -0,0 +1,32 @@
+P0,P0
+P1,P1
+P2,P2
+P3,P3
+P4,P4
+P5,P5
+P6,P6
+P7,P7
+P8,P8
+P9,P9
+P10,P10
+P11,P11
+P12,P12
+P13,P13
+P14,P14
+P15,P15
+P16,P16
+P17,P17
+P18,P18
+P19,P19
+P20,P20
+P21,P21
+P22,P22
+P23,P23
+P24,P24
+P25,P25
+P26,P26
+P27,P27
+P28,P28
+P29,P29
+P30,P30
+P31,P31
diff --git a/ports/nrf/nrfx_config.h b/ports/nrf/nrfx_config.h
index d8a7d521dae9d..19c744510feb5 100644
--- a/ports/nrf/nrfx_config.h
+++ b/ports/nrf/nrfx_config.h
@@ -45,22 +45,56 @@
   #define GPIO_COUNT 1
 #elif NRF52840 || NRF52840_XXAA
   #define GPIO_COUNT 2
+#elif NRF9160_XXAA
+  #define GPIO_COUNT 1
+#endif
+
+#if defined(NRF52840)
+// for tinyusb
+// #define NRFX_IRQ_IS_ENABLED 1
+#define NRFX_POWER_ENABLED 1
+#define NRFX_POWER_DEFAULT_CONFIG_IRQ_PRIORITY 2
+#define NRFX_SYSTICK_ENABLED 1
 #endif
 
 #define NRFX_GPIOTE_ENABLED 1
 #define NRFX_GPIOTE_CONFIG_NUM_OF_LOW_POWER_EVENTS 1
 #if NRF51
-  #define NRFX_GPIOTE_CONFIG_IRQ_PRIORITY 3
+  #define NRFX_GPIOTE_DEFAULT_CONFIG_IRQ_PRIORITY 3
 #else
-  #define NRFX_GPIOTE_CONFIG_IRQ_PRIORITY 6
+  #define NRFX_GPIOTE_DEFAULT_CONFIG_IRQ_PRIORITY 6
 #endif
 
-#define NRFX_UART_ENABLED 1
-#define NRFX_UART0_ENABLED 1
+#if defined(NRF51) || defined(NRF52_SERIES)
+#define NRFX_TEMP_ENABLED 1
+#if NRF51
+  #define NRFX_TEMP_DEFAULT_CONFIG_IRQ_PRIORITY 3
+#else
+  #define NRFX_TEMP_DEFAULT_CONFIG_IRQ_PRIORITY 7
+#endif
+#endif
 
-#define NRFX_TWI_ENABLED (MICROPY_PY_MACHINE_I2C)
-#define NRFX_TWI0_ENABLED 1
-#define NRFX_TWI1_ENABLED 1
+#if defined(NRF51) || defined(NRF52_SERIES)
+  #define NRFX_UART_ENABLED 1
+  #define NRFX_UART0_ENABLED 1
+  #define NRFX_UART1_ENABLED 1
+#else
+  #define NRFX_UARTE_ENABLED 1
+  #define NRFX_UARTE0_ENABLED 1
+  #define NRFX_UARTE1_ENABLED 1
+  #define NRFX_UARTE2_ENABLED 1
+  #define NRFX_UARTE3_ENABLED 1
+#endif
+
+#if defined(NRF51) || defined(NRF52_SERIES)
+  #define NRFX_TWI_ENABLED (MICROPY_PY_MACHINE_I2C)
+  #define NRFX_TWI0_ENABLED 1
+  #define NRFX_TWI1_ENABLED 1
+#elif defined(NRF9160_XXAA)
+  #define NRFX_TWIM_ENABLED (MICROPY_PY_MACHINE_I2C)
+  #define NRFX_TWIM0_ENABLED 1
+  #define NRFX_TWIM1_ENABLED 1
+#endif
 
 #if defined(NRF51) || defined(NRF52832)
   #define NRFX_SPI_ENABLED (MICROPY_PY_MACHINE_HW_SPI)
@@ -76,6 +110,15 @@
   #define NRFX_SPIM1_ENABLED 1
   #define NRFX_SPIM2_ENABLED 1
   #define NRFX_SPIM3_ENABLED (NRF52840)
+#elif defined(NRF9160_XXAA)
+  #define NRFX_SPIM_ENABLED (MICROPY_PY_MACHINE_HW_SPI)
+  #define NRFX_SPIM0_ENABLED 1
+  #define NRFX_SPIM1_ENABLED 1
+
+// 0 NRF_GPIO_PIN_NOPULL
+// 1 NRF_GPIO_PIN_PULLDOWN
+// 3 NRF_GPIO_PIN_PULLUP
+  #define NRFX_SPIM_MISO_PULL_CFG 1
 #endif // NRF51
 
 // 0 NRF_GPIO_PIN_NOPULL
@@ -93,8 +136,8 @@
 #define NRFX_TIMER0_ENABLED 1
 #define NRFX_TIMER1_ENABLED (!MICROPY_PY_MACHINE_SOFT_PWM)
 #define NRFX_TIMER2_ENABLED 1
-#define NRFX_TIMER3_ENABLED (!NRF51)
-#define NRFX_TIMER4_ENABLED (!NRF51)
+#define NRFX_TIMER3_ENABLED (!NRF51) && (!NRF9160_XXAA)
+#define NRFX_TIMER4_ENABLED (!NRF51) && (!NRF9160_XXAA)
 
 
 #define NRFX_PWM_ENABLED (!NRF51) && MICROPY_PY_MACHINE_HW_PWM
@@ -103,6 +146,8 @@
 #define NRFX_PWM2_ENABLED 1
 #define NRFX_PWM3_ENABLED (NRF52840)
 
+#define NRFX_NVMC_ENABLED 1
+
 // Peripheral Resource Sharing
 #if defined(NRF51) || defined(NRF52832)
   #define NRFX_PRS_BOX_0_ENABLED (NRFX_TWI_ENABLED && NRFX_TWI0_ENABLED && NRFX_SPI_ENABLED && NRFX_SPI0_ENABLED)
@@ -115,6 +160,10 @@
   #define NRFX_PRS_BOX_0_ENABLED (NRFX_TWI_ENABLED && NRFX_TWI0_ENABLED && NRFX_SPIM_ENABLED && NRFX_SPIM0_ENABLED)
   #define NRFX_PRS_BOX_1_ENABLED (NRFX_TWI_ENABLED && NRFX_TWI1_ENABLED && NRFX_SPIM_ENABLED && NRFX_SPIM1_ENABLED)
   #define NRFX_PRS_BOX_2_ENABLED (NRFX_TWI_ENABLED && NRFX_TWI2_ENABLED && NRFX_SPIM_ENABLED && NRFX_SPIM2_ENABLED)
+#elif defined(NRF9160_XXAA)
+  #define NRFX_PRS_BOX_0_ENABLED (NRFX_TWIM_ENABLED && NRFX_TWIM0_ENABLED && NRFX_SPIM_ENABLED && NRFX_SPIM0_ENABLED)
+  #define NRFX_PRS_BOX_1_ENABLED (NRFX_TWIM_ENABLED && NRFX_TWIM1_ENABLED && NRFX_SPIM_ENABLED && NRFX_SPIM1_ENABLED)
+  #define NRFX_PRS_BOX_2_ENABLED (NRFX_TWIM_ENABLED && NRFX_TWIM2_ENABLED && NRFX_SPIM_ENABLED && NRFX_SPIM2_ENABLED)
 #endif
 
 #define NRFX_PRS_ENABLED (NRFX_PRS_BOX_0_ENABLED || NRFX_PRS_BOX_1_ENABLED || NRFX_PRS_BOX_2_ENABLED)
@@ -122,4 +171,69 @@
 #define NRFX_SAADC_ENABLED !(NRF51) && (MICROPY_PY_MACHINE_ADC)
 #define NRFX_ADC_ENABLED (NRF51) && (MICROPY_PY_MACHINE_ADC)
 
+#if defined(NRF9160_XXAA)
+
+#define NRF_CLOCK      NRF_CLOCK_NS
+#define NRF_DPPIC      NRF_DPPIC_NS
+#define NRF_EGU0       NRF_EGU0_NS
+#define NRF_EGU1       NRF_EGU1_NS
+#define NRF_EGU2       NRF_EGU2_NS
+#define NRF_EGU3       NRF_EGU3_NS
+#define NRF_EGU4       NRF_EGU4_NS
+#define NRF_EGU5       NRF_EGU5_NS
+#define NRF_FPU        NRF_FPU_NS
+#define NRF_P0         NRF_P0_NS
+#define NRF_I2S        NRF_I2S_NS
+#define NRF_KMU        NRF_KMU_NS
+#define NRF_NVMC       NRF_NVMC_NS
+#define NRF_PDM        NRF_PDM_NS
+#define NRF_POWER      NRF_POWER_NS
+#define NRF_PWM0       NRF_PWM0_NS
+#define NRF_PWM1       NRF_PWM1_NS
+#define NRF_PWM2       NRF_PWM2_NS
+#define NRF_PWM3       NRF_PWM3_NS
+#define NRF_REGULATORS NRF_REGULATORS_NS
+#define NRF_RTC0       NRF_RTC0_NS
+#define NRF_RTC1       NRF_RTC1_NS
+#define NRF_SAADC      NRF_SAADC_NS
+#define NRF_SPIM0      NRF_SPIM0_NS
+#define NRF_SPIM1      NRF_SPIM1_NS
+#define NRF_SPIM2      NRF_SPIM2_NS
+#define NRF_SPIM3      NRF_SPIM3_NS
+#define NRF_SPIS0      NRF_SPIS0_NS
+#define NRF_SPIS1      NRF_SPIS1_NS
+#define NRF_SPIS2      NRF_SPIS2_NS
+#define NRF_SPIS3      NRF_SPIS3_NS
+#define NRF_TIMER0     NRF_TIMER0_NS
+#define NRF_TIMER1     NRF_TIMER1_NS
+#define NRF_TIMER2     NRF_TIMER2_NS
+#define NRF_TWIM0      NRF_TWIM0_NS
+#define NRF_TWIM1      NRF_TWIM1_NS
+#define NRF_TWIM2      NRF_TWIM2_NS
+#define NRF_TWIM3      NRF_TWIM3_NS
+#define NRF_TWIS0      NRF_TWIS0_NS
+#define NRF_TWIS1      NRF_TWIS1_NS
+#define NRF_TWIS2      NRF_TWIS2_NS
+#define NRF_TWIS3      NRF_TWIS3_NS
+#define NRF_UARTE0     NRF_UARTE0_NS
+#define NRF_UARTE1     NRF_UARTE1_NS
+#define NRF_UARTE2     NRF_UARTE2_NS
+#define NRF_UARTE3     NRF_UARTE3_NS
+#define NRF_VMC        NRF_VMC_NS
+#define NRF_WDT        NRF_WDT_NS
+#define NRF_IPC        NRF_IPC_NS
+
+#define NRF_CRYPTOCELL NRF_CRYPTOCELL_S
+#define NRF_FICR       NRF_FICR_S
+#define NRF_GPIOTE0    NRF_GPIOTE0_S
+#define NRF_GPIOTE1    NRF_GPIOTE1_NS
+#define NRF_SPU        NRF_SPU_S
+#define NRF_UICR       NRF_UICR_S
+
+#define NRF_GPIOTE        NRF_GPIOTE1_NS
+#define GPIOTE_IRQn       GPIOTE1_IRQn
+#define GPIOTE_IRQHandler GPIOTE1_IRQHandler
+
+#endif
+
 #endif // NRFX_CONFIG_H
diff --git a/ports/nrf/nrfx_glue.h b/ports/nrf/nrfx_glue.h
index 0108e3242fd19..b4a60257a893b 100644
--- a/ports/nrf/nrfx_glue.h
+++ b/ports/nrf/nrfx_glue.h
@@ -29,7 +29,11 @@
 
 #include <soc/nrfx_irqs.h>
 
+#define NRFX_STATIC_ASSERT(expression)
+
 #define NRFX_ASSERT(expression)  do { bool res = expression; (void)res; } while (0)
+
+void mp_hal_delay_us(mp_uint_t us);
 #define NRFX_DELAY_US            mp_hal_delay_us
 
 #if BLUETOOTH_SD
@@ -51,7 +55,7 @@
         } else { \
             NVIC_EnableIRQ(irq_number); \
         } \
-    } while(0)
+    } while (0)
 #else
 #define NRFX_IRQ_ENABLE(irq_number) sd_nvic_EnableIRQ(irq_number)
 #endif
@@ -65,7 +69,7 @@
         } else { \
             NVIC_DisableIRQ(irq_number); \
         } \
-    } while(0)
+    } while (0)
 #else
 #define NRFX_IRQ_DISABLE(irq_number) sd_nvic_DisableIRQ(irq_number)
 #endif
@@ -79,7 +83,7 @@
         } else { \
             NVIC_SetPriority(irq_number, priority); \
         } \
-    } while(0)
+    } while (0)
 #else
 #define NRFX_IRQ_PRIORITY_SET(irq_number, priority) sd_nvic_SetPriority(irq_number, priority)
 #endif
@@ -93,7 +97,7 @@
         } else { \
             NVIC_SetPendingIRQ(irq_number); \
         } \
-    } while(0)
+    } while (0)
 #else
 #define NRFX_IRQ_PENDING_SET(irq_number) sd_nvic_SetPendingIRQ(irq_number)
 #endif
@@ -107,7 +111,7 @@
         } else { \
             NVIC_ClearPendingIRQ(irq_number)(irq_number); \
         } \
-    } while(0)
+    } while (0)
 #else
 #define NRFX_IRQ_PENDING_CLEAR(irq_number) sd_nvic_ClearPendingIRQ(irq_number)
 #endif
@@ -118,8 +122,8 @@
         sd_nvic_critical_region_enter(&_is_nested_critical_region);
 
 #define NRFX_CRITICAL_SECTION_EXIT() \
-        sd_nvic_critical_region_exit(_is_nested_critical_region); \
-    }
+    sd_nvic_critical_region_exit(_is_nested_critical_region); \
+}
 
 #else // BLUETOOTH_SD
 
@@ -136,4 +140,6 @@
 
 #endif // !BLUETOOTH_SD
 
+#define NRFX_IRQ_IS_ENABLED(irq_number) (0 != (NVIC->ISER[irq_number / 32] & (1UL << (irq_number % 32))))
+
 #endif // NRFX_GLUE_H
diff --git a/ports/nrf/nrfx_log.h b/ports/nrf/nrfx_log.h
index ca2fd588ac95d..8710d3fc22d88 100644
--- a/ports/nrf/nrfx_log.h
+++ b/ports/nrf/nrfx_log.h
@@ -33,7 +33,7 @@
 
 #define LOG_TEST_UART 1
 
-#define TEST_MODULE_IMPL(x, y) LOG_TEST_ ## x == LOG_TEST_ ## y
+#define TEST_MODULE_IMPL(x, y) LOG_TEST_##x == LOG_TEST_##y
 #define TEST_MODULE(x, y) TEST_MODULE_IMPL(x, y)
 
 #if (!defined(NRFX_LOG_ENABLED) || (NRFX_LOG_ENABLED == 0)) || \
@@ -56,11 +56,11 @@
     #define VALUE(x) VALUE_TO_STR(x)
 
     #define LOG_PRINTF(fmt, ...) \
-        do { \
-            printf("%s: ", VALUE(NRFX_LOG_MODULE)); \
-            printf(fmt, ##__VA_ARGS__); \
-            printf("\n"); \
-        } while (0)
+    do { \
+        printf("%s: ", VALUE(NRFX_LOG_MODULE)); \
+        printf(fmt,##__VA_ARGS__); \
+        printf("\n"); \
+    } while (0)
 
     #define NRFX_LOG_DEBUG   LOG_PRINTF
     #define NRFX_LOG_ERROR   LOG_PRINTF
@@ -77,7 +77,7 @@
     #define NRFX_LOG_HEXDUMP_DEBUG(p_memory, length)
 
     #define NRFX_LOG_ERROR_STRING_GET(error_code) \
-        nrfx_error_code_lookup(error_code)
+    nrfx_error_code_lookup(error_code)
 
 #endif // NRFX_LOG_ENABLED
 
diff --git a/ports/nrf/pin_defs_nrf5.h b/ports/nrf/pin_defs_nrf5.h
index c84d048a424e2..a884c875b8fda 100644
--- a/ports/nrf/pin_defs_nrf5.h
+++ b/ports/nrf/pin_defs_nrf5.h
@@ -31,31 +31,39 @@
 #include "nrf_gpio.h"
 
 enum {
-  PORT_A,
-  PORT_B,
+    PORT_A,
+    PORT_B,
 };
 
 enum {
-  AF_FN_UART,
-  AF_FN_SPI,
+    AF_FN_UART,
+    AF_FN_SPI,
 };
 
 enum {
-  AF_PIN_TYPE_UART_TX = 0,
-  AF_PIN_TYPE_UART_RX,
-  AF_PIN_TYPE_UART_CTS,
-  AF_PIN_TYPE_UART_RTS,
-
-  AF_PIN_TYPE_SPI_MOSI = 0,
-  AF_PIN_TYPE_SPI_MISO,
-  AF_PIN_TYPE_SPI_SCK,
-  AF_PIN_TYPE_SPI_NSS,
+    AF_PIN_TYPE_UART_TX = 0,
+    AF_PIN_TYPE_UART_RX,
+    AF_PIN_TYPE_UART_CTS,
+    AF_PIN_TYPE_UART_RTS,
+
+    AF_PIN_TYPE_SPI_MOSI = 0,
+    AF_PIN_TYPE_SPI_MISO,
+    AF_PIN_TYPE_SPI_SCK,
+    AF_PIN_TYPE_SPI_NSS,
 };
 
+#if defined(NRF51) || defined(NRF52_SERIES)
+#define PIN_DEFS_PORT_AF_UNION \
+    NRF_UART_Type *UART;
+//  NRF_SPI_Type  *SPIM;
+//  NRF_SPIS_Type *SPIS;
+#elif defined(NRF91_SERIES)
 #define PIN_DEFS_PORT_AF_UNION \
-		NRF_UART_Type  *UART;
-//		NRF_SPI_Type  *SPIM;
-//		NRF_SPIS_Type *SPIS;
+    NRF_UARTE_Type *UART;
+#endif
 
+enum {
+    PIN_ADC1 = (1 << 0),
+};
 
 typedef NRF_GPIO_Type pin_gpio_t;
diff --git a/ports/nrf/qstrdefsport.h b/ports/nrf/qstrdefsport.h
index ef398a4c0acdc..9608dbb247a07 100644
--- a/ports/nrf/qstrdefsport.h
+++ b/ports/nrf/qstrdefsport.h
@@ -25,6 +25,8 @@
  */
 
 // qstrs specific to this port
+// *FORMAT-OFF*
+
 Q(a)
 Q(a#)
 Q(a#:1)
diff --git a/ports/pic16bit/Makefile b/ports/pic16bit/Makefile
index 8a931979d2986..fa6de38e39274 100644
--- a/ports/pic16bit/Makefile
+++ b/ports/pic16bit/Makefile
@@ -7,7 +7,7 @@ QSTR_DEFS = qstrdefsport.h
 include $(TOP)/py/py.mk
 
 XC16 = /opt/microchip/xc16/v1.35
-CROSS_COMPILE = $(XC16)/bin/xc16-
+CROSS_COMPILE ?= $(XC16)/bin/xc16-
 
 PARTFAMILY = dsPIC33F
 PART = 33FJ256GP506
diff --git a/ports/pic16bit/board.c b/ports/pic16bit/board.c
index 0321b0ee22de1..977dd2cfa810b 100644
--- a/ports/pic16bit/board.c
+++ b/ports/pic16bit/board.c
@@ -79,17 +79,29 @@ void led_init(void) {
 void led_state(int led, int state) {
     int val = state ? LED_ON : LED_OFF;
     switch (led) {
-        case 1: RED_LED = val; break;
-        case 2: YELLOW_LED = val; break;
-        case 3: GREEN_LED = val; break;
+        case 1:
+            RED_LED = val;
+            break;
+        case 2:
+            YELLOW_LED = val;
+            break;
+        case 3:
+            GREEN_LED = val;
+            break;
     }
 }
 
 void led_toggle(int led) {
     switch (led) {
-        case 1: RED_LED ^= 1; break;
-        case 2: YELLOW_LED ^= 1; break;
-        case 3: GREEN_LED ^= 1; break;
+        case 1:
+            RED_LED ^= 1;
+            break;
+        case 2:
+            YELLOW_LED ^= 1;
+            break;
+        case 3:
+            GREEN_LED ^= 1;
+            break;
     }
 }
 
@@ -111,8 +123,12 @@ void switch_init(void) {
 int switch_get(int sw) {
     int val = 1;
     switch (sw) {
-        case 1: val = SWITCH_S1; break;
-        case 2: val = SWITCH_S2; break;
+        case 1:
+            val = SWITCH_S1;
+            break;
+        case 2:
+            val = SWITCH_S2;
+            break;
     }
     return val == 0;
 }
diff --git a/ports/pic16bit/main.c b/ports/pic16bit/main.c
index c96ac54ea4867..07db3f58270c6 100644
--- a/ports/pic16bit/main.c
+++ b/ports/pic16bit/main.c
@@ -68,7 +68,7 @@ int main(int argc, char **argv) {
 
     // init MicroPython runtime
     int stack_dummy;
-    MP_STATE_THREAD(stack_top) = (char*)&stack_dummy;
+    MP_STATE_THREAD(stack_top) = (char *)&stack_dummy;
     gc_init(heap, heap + sizeof(heap));
     mp_init();
     mp_hal_init();
@@ -115,11 +115,15 @@ mp_obj_t mp_builtin_open(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs)
 MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
 
 void nlr_jump_fail(void *val) {
-    while (1);
+    while (1) {
+        ;
+    }
 }
 
 void NORETURN __fatal_error(const char *msg) {
-    while (1);
+    while (1) {
+        ;
+    }
 }
 
 #ifndef NDEBUG
diff --git a/ports/pic16bit/modpyb.c b/ports/pic16bit/modpyb.c
index 62991463364e8..a18b37700c44e 100644
--- a/ports/pic16bit/modpyb.c
+++ b/ports/pic16bit/modpyb.c
@@ -66,5 +66,5 @@ STATIC MP_DEFINE_CONST_DICT(pyb_module_globals, pyb_module_globals_table);
 
 const mp_obj_module_t pyb_module = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&pyb_module_globals,
+    .globals = (mp_obj_dict_t *)&pyb_module_globals,
 };
diff --git a/ports/pic16bit/modpybled.c b/ports/pic16bit/modpybled.c
index 0d200c60390a2..6adb2fda31265 100644
--- a/ports/pic16bit/modpybled.c
+++ b/ports/pic16bit/modpybled.c
@@ -50,7 +50,7 @@ STATIC mp_obj_t pyb_led_make_new(const mp_obj_type_t *type, size_t n_args, size_
     mp_arg_check_num(n_args, n_kw, 1, 1, false);
     mp_int_t led_id = mp_obj_get_int(args[0]);
     if (!(1 <= led_id && led_id <= NUM_LED)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "LED %d does not exist", led_id));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("LED %d does not exist"), led_id);
     }
     return (mp_obj_t)&pyb_led_obj[led_id - 1];
 }
diff --git a/ports/pic16bit/modpybswitch.c b/ports/pic16bit/modpybswitch.c
index 0799ad9e8281b..7b3d0f5f527bb 100644
--- a/ports/pic16bit/modpybswitch.c
+++ b/ports/pic16bit/modpybswitch.c
@@ -49,7 +49,7 @@ STATIC mp_obj_t pyb_switch_make_new(const mp_obj_type_t *type, size_t n_args, si
     mp_arg_check_num(n_args, n_kw, 1, 1, false);
     mp_int_t sw_id = mp_obj_get_int(args[0]);
     if (!(1 <= sw_id && sw_id <= NUM_SWITCH)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Switch %d does not exist", sw_id));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Switch %d does not exist"), sw_id);
     }
     return (mp_obj_t)&pyb_switch_obj[sw_id - 1];
 }
diff --git a/ports/pic16bit/mpconfigport.h b/ports/pic16bit/mpconfigport.h
index 59880dc5992e8..f121081e6fe8b 100644
--- a/ports/pic16bit/mpconfigport.h
+++ b/ports/pic16bit/mpconfigport.h
@@ -73,9 +73,9 @@
 // The xc16 compiler doesn't seem to respect alignment (!!) so we
 // need to use instead an object representation that allows for
 // 2-byte aligned pointers (see config setting above).
-//#define MICROPY_OBJ_BASE_ALIGNMENT  __attribute__((aligned(4)))
+// #define MICROPY_OBJ_BASE_ALIGNMENT  __attribute__((aligned(4)))
 
-#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void*)((mp_uint_t)(p)))
+#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)((mp_uint_t)(p)))
 
 #define UINT_FMT "%u"
 #define INT_FMT "%d"
diff --git a/ports/pic16bit/pic16bit_mphal.c b/ports/pic16bit/pic16bit_mphal.c
index 35955f2d3ee57..adab3819348bc 100644
--- a/ports/pic16bit/pic16bit_mphal.c
+++ b/ports/pic16bit/pic16bit_mphal.c
@@ -25,6 +25,7 @@
  */
 
 #include <string.h>
+#include "py/stream.h"
 #include "py/mphal.h"
 #include "board.h"
 
@@ -51,6 +52,14 @@ void mp_hal_set_interrupt_char(int c) {
     interrupt_char = c;
 }
 
+uintptr_t mp_hal_stdio_poll(uintptr_t poll_flags) {
+    uintptr_t ret = 0;
+    if ((poll_flags & MP_STREAM_POLL_RD) && uart_rx_any()) {
+        ret |= MP_STREAM_POLL_RD;
+    }
+    return ret;
+}
+
 int mp_hal_stdin_rx_chr(void) {
     for (;;) {
         if (uart_rx_any()) {
diff --git a/ports/pic16bit/qstrdefsport.h b/ports/pic16bit/qstrdefsport.h
index 3ba897069bf73..00d3e2ae3c555 100644
--- a/ports/pic16bit/qstrdefsport.h
+++ b/ports/pic16bit/qstrdefsport.h
@@ -1 +1,2 @@
 // qstrs specific to this port
+// *FORMAT-OFF*
diff --git a/ports/powerpc/Makefile b/ports/powerpc/Makefile
new file mode 100644
index 0000000000000..1f5ec80d43653
--- /dev/null
+++ b/ports/powerpc/Makefile
@@ -0,0 +1,65 @@
+include ../../py/mkenv.mk
+
+# qstr definitions (must come before including py.mk)
+QSTR_DEFS = qstrdefsport.h
+
+# include py core make definitions
+include $(TOP)/py/py.mk
+
+# potato or lpc_serial
+UART ?= potato
+
+ARCH = $(shell uname -m)
+ifneq ("$(ARCH)", "ppc64")
+ifneq ("$(ARCH)", "ppc64le")
+	CROSS_COMPILE ?= powerpc64le-linux-gnu-
+endif
+endif
+
+INC += -I.
+INC += -I$(TOP)
+INC += -I$(BUILD)
+
+CFLAGS = $(INC) -g -Wall -Wdouble-promotion -Wfloat-conversion -std=c99 $(COPT)
+CFLAGS += -mno-string -mno-multiple -mno-vsx -mno-altivec -nostdlib
+CFLAGS += -mlittle-endian -mstrict-align -msoft-float
+CFLAGS += -Os
+CFLAGS += -fdata-sections -ffunction-sections -fno-stack-protector -ffreestanding
+CFLAGS += -U_FORTIFY_SOURCE
+
+LDFLAGS = -N -T powerpc.lds -nostdlib
+
+LIBS =
+
+SRC_C = \
+	main.c \
+	uart_$(UART).c \
+	lib/utils/printf.c \
+	lib/utils/stdout_helpers.c \
+	lib/utils/pyexec.c \
+	lib/libc/string0.c \
+	lib/mp-readline/readline.c \
+	$(BUILD)/_frozen_mpy.c \
+
+OBJ = $(PY_CORE_O)
+OBJ += $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
+OBJ += $(BUILD)/head.o
+
+all: $(BUILD)/firmware.elf $(BUILD)/firmware.map $(BUILD)/firmware.bin
+
+$(BUILD)/_frozen_mpy.c: frozentest.mpy $(BUILD)/genhdr/qstrdefs.generated.h
+	$(ECHO) "MISC freezing bytecode"
+	$(Q)$(MPY_TOOL) -f -q $(BUILD)/genhdr/qstrdefs.preprocessed.h -mlongint-impl=mpz $< > $@
+
+$(BUILD)/firmware.elf: $(OBJ) powerpc.lds
+	$(ECHO) "LINK $@"
+	$(Q)$(LD) $(LDFLAGS) -o $@ $(OBJ) $(LIBS)
+	$(Q)$(SIZE) $@
+
+$(BUILD)/firmware.bin: $(BUILD)/firmware.elf
+	$(Q)$(OBJCOPY) -O binary $^ $(BUILD)/firmware.bin
+
+$(BUILD)/firmware.map: $(BUILD)/firmware.elf
+	$(Q)nm $^ | sort > $(BUILD)/firmware.map
+
+include $(TOP)/py/mkrules.mk
diff --git a/ports/powerpc/README.md b/ports/powerpc/README.md
new file mode 100644
index 0000000000000..631924c7c0afb
--- /dev/null
+++ b/ports/powerpc/README.md
@@ -0,0 +1,44 @@
+# The PowerPC port that runs on microwatt and qemu
+
+This port is intended to be a minimal MicroPython port that runs in
+QEMU, microwatt simulator with ghdl or microwatt on Xilinx FPGA with
+potato UART.
+
+## Building
+
+By default the port will be built with the potato uart for microwatt:
+
+    $ make
+
+To instead build for a machine with LPC serial, such as QEMU powernv:
+
+    $ make UART=lpc_serial
+
+## Cross compilation for POWERPC
+
+If you need to cross compilers you'll want to grab a powerpc64le
+compiler (not powerpc or powerpc64).
+
+On Ubuntu (18.04) you'll want:
+
+    $ apt install gcc-powerpc64le-linux-gnu
+
+*(Use CROSS_COMPILE=powerpc64le-linux-gnu-)*
+
+If your distro doesn't have cross compilers, you can get cross compilers here:
+- https://toolchains.bootlin.com/
+*(use CROSS_COMPILE=powerpc64le-buildroot-linux-gnu-)*
+
+(Avoid musl libc as it defines __assert_fail() differently to glibc
+which breaks the micropython powerpc code)
+
+Then do:
+
+    $ make CROSS_COMPILE=<compiler prefix>
+
+Building will produce the build/firmware.bin file which can be used
+QEMU or [microwatt](https://github.com/antonblanchard/microwatt).
+
+To run in QEMU use:
+
+    $ ./qemu-system-ppc64 -M powernv -cpu POWER9 -nographic -bios build/firmware.bin
diff --git a/ports/powerpc/frozentest.mpy b/ports/powerpc/frozentest.mpy
new file mode 100644
index 0000000000000..8a89194a10487
Binary files /dev/null and b/ports/powerpc/frozentest.mpy differ
diff --git a/ports/powerpc/frozentest.py b/ports/powerpc/frozentest.py
new file mode 100644
index 0000000000000..78cdd60bf0431
--- /dev/null
+++ b/ports/powerpc/frozentest.py
@@ -0,0 +1,7 @@
+print("uPy")
+print("a long string that is not interned")
+print("a string that has unicode αβγ chars")
+print(b"bytes 1234\x01")
+print(123456789)
+for i in range(4):
+    print(i)
diff --git a/ports/powerpc/head.S b/ports/powerpc/head.S
new file mode 100644
index 0000000000000..09aa62e59ca85
--- /dev/null
+++ b/ports/powerpc/head.S
@@ -0,0 +1,121 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019, Michael Neuling, IBM Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#define STACK_TOP 0x60000
+
+#define FIXUP_ENDIAN                                           \
+    tdi   0,0,0x48;   /* Reverse endian of b . + 8          */ \
+    b     191f;       /* Skip trampoline if endian is good  */ \
+    .long 0xa600607d; /* mfmsr r11                          */ \
+    .long 0x01006b69; /* xori r11,r11,1                     */ \
+    .long 0x05009f42; /* bcl 20,31,$+4                      */ \
+    .long 0xa602487d; /* mflr r10                           */ \
+    .long 0x14004a39; /* addi r10,r10,20                    */ \
+    .long 0xa64b5a7d; /* mthsrr0 r10                        */ \
+    .long 0xa64b7b7d; /* mthsrr1 r11                        */ \
+    .long 0x2402004c; /* hrfid                              */ \
+    191:
+
+/* Load an immediate 64-bit value into a register */
+#define LOAD_IMM64(r, e)                \
+    lis     r,(e)@highest;              \
+    ori     r,r,(e)@higher;             \
+    rldicr  r,r, 32, 31;                \
+    oris    r,r, (e)@h;                 \
+    ori     r,r, (e)@l;
+
+.section ".head","ax"
+
+/*
+ * Microwatt comes in at 0 as little endian so we do not need to worry up
+ * FIXUP_ENDIAN.
+ */
+    . = 0
+    .global _start
+_start:
+    b       boot_entry
+
+/* QEMU comes in at 0x10. Put a value in argc/r3 to distingush from
+ * microwatt. */
+    . = 0x10
+    FIXUP_ENDIAN
+    LOAD_IMM64(%r3, 1)
+    b       boot_entry
+
+    .global boot_entry
+    boot_entry:
+    /* Save R3 to non-volatile register */
+    mr      %r14, %r3
+    restart:
+    /*
+     * setup stack with a safety gap, since we might write to the
+     * previous frame.
+     */
+    LOAD_IMM64(%r1, STACK_TOP - 0x100)
+    LOAD_IMM64(%r12, main)
+    mtctr   %r12
+    bctrl
+
+    /* On exit, restart */
+    mr      %r3, %r14
+    b       restart
+
+#define EXCEPTION(nr)       \
+    .= nr;                  \
+b   .
+
+    /* More exception stubs */
+    EXCEPTION(0x300)
+    EXCEPTION(0x380)
+    EXCEPTION(0x400)
+    EXCEPTION(0x480)
+    EXCEPTION(0x500)
+    EXCEPTION(0x600)
+    EXCEPTION(0x700)
+    EXCEPTION(0x800)
+    EXCEPTION(0x900)
+    EXCEPTION(0x980)
+    EXCEPTION(0xa00)
+    EXCEPTION(0xb00)
+    EXCEPTION(0xc00)
+    EXCEPTION(0xd00)
+    EXCEPTION(0xe00)
+    EXCEPTION(0xe20)
+    EXCEPTION(0xe40)
+    EXCEPTION(0xe60)
+    EXCEPTION(0xe80)
+    EXCEPTION(0xf00)
+    EXCEPTION(0xf20)
+    EXCEPTION(0xf40)
+    EXCEPTION(0xf60)
+    EXCEPTION(0xf80)
+    EXCEPTION(0x1000)
+    EXCEPTION(0x1100)
+    EXCEPTION(0x1200)
+    EXCEPTION(0x1300)
+    EXCEPTION(0x1400)
+    EXCEPTION(0x1500)
+    EXCEPTION(0x1600)
diff --git a/ports/powerpc/main.c b/ports/powerpc/main.c
new file mode 100644
index 0000000000000..fdeec13abe0a5
--- /dev/null
+++ b/ports/powerpc/main.c
@@ -0,0 +1,143 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019, Michael Neuling, IBM Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdio.h>
+
+#include "py/compile.h"
+#include "py/runtime.h"
+#include "py/repl.h"
+#include "py/gc.h"
+#include "py/mperrno.h"
+#include "py/stackctrl.h"
+#include "lib/utils/pyexec.h"
+
+void __stack_chk_fail(void);
+void __stack_chk_fail(void) {
+    static bool failed_once;
+
+    if (failed_once) {
+        return;
+    }
+    failed_once = true;
+    printf("Stack corruption detected !\n");
+    assert(0);
+}
+
+/* fill in __assert_fail for libc */
+void __assert_fail(const char *__assertion, const char *__file,
+    unsigned int __line, const char *__function) {
+    printf("Assert at %s:%d:%s() \"%s\" failed\n", __file, __line, __function, __assertion);
+    for (;;) {;
+    }
+}
+
+static char *stack_top;
+#if MICROPY_ENABLE_GC
+static char heap[32 * 1024];
+#endif
+
+extern void uart_init_ppc(int qemu);
+
+int main(int argc, char **argv) {
+    int stack_dummy;
+    stack_top = (char *)&stack_dummy;
+
+    uart_init_ppc(argc);
+
+    #if MICROPY_ENABLE_PYSTACK
+    static mp_obj_t pystack[1024];
+    mp_pystack_init(pystack, &pystack[1024]);
+    #endif
+
+    #if MICROPY_STACK_CHECK
+    mp_stack_ctrl_init();
+    mp_stack_set_limit(48 * 1024);
+    #endif
+
+    #if MICROPY_ENABLE_GC
+    gc_init(heap, heap + sizeof(heap));
+    #endif
+    mp_init();
+    #if MICROPY_ENABLE_COMPILER
+    #if MICROPY_REPL_EVENT_DRIVEN
+    pyexec_event_repl_init();
+    for (;;) {
+        int c = mp_hal_stdin_rx_chr();
+        if (pyexec_event_repl_process_char(c)) {
+            break;
+        }
+    }
+    #else
+    pyexec_friendly_repl();
+    #endif
+    #else
+    pyexec_frozen_module("frozentest.py");
+    #endif
+    mp_deinit();
+    return 0;
+}
+
+void gc_collect(void) {
+    // WARNING: This gc_collect implementation doesn't try to get root
+    // pointers from CPU registers, and thus may function incorrectly.
+    void *dummy;
+    gc_collect_start();
+    gc_collect_root(&dummy, ((mp_uint_t)stack_top - (mp_uint_t)&dummy) / sizeof(mp_uint_t));
+    gc_collect_end();
+    gc_dump_info();
+}
+
+mp_lexer_t *mp_lexer_new_from_file(const char *filename) {
+    mp_raise_OSError(MP_ENOENT);
+}
+
+mp_import_stat_t mp_import_stat(const char *path) {
+    return MP_IMPORT_STAT_NO_EXIST;
+}
+
+mp_obj_t mp_builtin_open(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
+
+void nlr_jump_fail(void *val) {
+    while (1) {
+        ;
+    }
+}
+
+void NORETURN __fatal_error(const char *msg) {
+    while (1) {
+        ;
+    }
+}
+
+#ifndef NDEBUG
+void MP_WEAK __assert_func(const char *file, int line, const char *func, const char *expr) {
+    printf("Assertion '%s' failed, at file %s:%d\n", expr, file, line);
+    __fatal_error("Assertion failed");
+}
+#endif
diff --git a/ports/powerpc/mpconfigport.h b/ports/powerpc/mpconfigport.h
new file mode 100644
index 0000000000000..7a927773626d7
--- /dev/null
+++ b/ports/powerpc/mpconfigport.h
@@ -0,0 +1,123 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019, Michael Neuling, IBM Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdint.h>
+
+// options to control how MicroPython is built
+
+// You can disable the built-in MicroPython compiler by setting the following
+// config option to 0.  If you do this then you won't get a REPL prompt, but you
+// will still be able to execute pre-compiled scripts, compiled with mpy-cross.
+#define MICROPY_ENABLE_COMPILER     (1)
+
+// #define MICROPY_DEBUG_VERBOSE    (1)
+
+#define MICROPY_QSTR_BYTES_IN_HASH  (1)
+#define MICROPY_QSTR_EXTRA_POOL     mp_qstr_frozen_const_pool
+#define MICROPY_ALLOC_PATH_MAX      (256)
+#define MICROPY_ALLOC_PARSE_CHUNK_INIT (16)
+#define MICROPY_EMIT_X64            (0)
+#define MICROPY_EMIT_THUMB          (0)
+#define MICROPY_EMIT_INLINE_THUMB   (0)
+#define MICROPY_COMP_MODULE_CONST   (0)
+#define MICROPY_COMP_CONST          (0)
+#define MICROPY_COMP_DOUBLE_TUPLE_ASSIGN (0)
+#define MICROPY_COMP_TRIPLE_TUPLE_ASSIGN (0)
+#define MICROPY_MEM_STATS           (0)
+#define MICROPY_DEBUG_PRINTERS      (1)
+#define MICROPY_ENABLE_GC           (1)
+#define MICROPY_STACK_CHECK         (1)
+#define MICROPY_GC_ALLOC_THRESHOLD  (0)
+#define MICROPY_REPL_EVENT_DRIVEN   (0)
+#define MICROPY_HELPER_REPL         (1)
+#define MICROPY_HELPER_LEXER_UNIX   (0)
+#define MICROPY_ENABLE_SOURCE_LINE  (1)
+#define MICROPY_ENABLE_DOC_STRING   (0)
+#define MICROPY_ERROR_REPORTING     (MICROPY_ERROR_REPORTING_TERSE)
+#define MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG (0)
+#define MICROPY_PY_ASYNC_AWAIT      (0)
+#define MICROPY_MODULE_BUILTIN_INIT         (1)
+#define MICROPY_PY_BUILTINS_BYTEARRAY (1)
+#define MICROPY_PY_BUILTINS_DICT_FROMKEYS (1)
+#define MICROPY_PY_BUILTINS_MEMORYVIEW (1)
+#define MICROPY_PY_BUILTINS_ENUMERATE (1)
+#define MICROPY_PY_BUILTINS_FILTER  (1)
+#define MICROPY_PY_BUILTINS_FROZENSET (1)
+#define MICROPY_PY_BUILTINS_REVERSED (1)
+#define MICROPY_PY_BUILTINS_SET     (1)
+#define MICROPY_PY_BUILTINS_SLICE   (1)
+#define MICROPY_PY_BUILTINS_PROPERTY (1)
+#define MICROPY_PY_BUILTINS_MIN_MAX (1)
+#define MICROPY_PY_BUILTINS_STR_COUNT (1)
+#define MICROPY_PY_BUILTINS_STR_OP_MODULO (1)
+#define MICROPY_PY_BUILTINS_HELP    (1)
+#define MICROPY_PY_BUILTINS_HELP_MODULES (1)
+#define MICROPY_PY___FILE__         (0)
+#define MICROPY_PY_GC               (1)
+#define MICROPY_PY_ARRAY            (1)
+#define MICROPY_PY_COLLECTIONS      (1)
+#define MICROPY_PY_MATH             (0)
+#define MICROPY_PY_CMATH            (0)
+#define MICROPY_PY_IO               (0)
+#define MICROPY_PY_STRUCT           (1)
+#define MICROPY_PY_SYS              (1)
+#define MICROPY_MODULE_FROZEN_MPY   (1)
+#define MICROPY_CPYTHON_COMPAT      (0)
+#define MICROPY_LONGINT_IMPL        (MICROPY_LONGINT_IMPL_MPZ)
+#define MICROPY_FLOAT_IMPL          (MICROPY_FLOAT_IMPL_NONE)
+#define MICROPY_ENABLE_PYSTACK      (1)
+#define MICROPY_USE_INTERNAL_PRINTF (1)
+
+// type definitions for the specific machine
+
+#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)((mp_uint_t)(p) | 1))
+
+// This port is 64-bit
+#define UINT_FMT "%lu"
+#define INT_FMT "%ld"
+typedef signed long mp_int_t; // must be pointer size
+typedef unsigned long mp_uint_t; // must be pointer size
+
+typedef long mp_off_t;
+
+#define MP_PLAT_PRINT_STRN(str, len) mp_hal_stdout_tx_strn_cooked(str, len)
+
+// extra built in names to add to the global namespace
+#define MICROPY_PORT_BUILTINS \
+    { MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&mp_builtin_open_obj) },
+
+#define MICROPY_HW_BOARD_NAME "bare-metal"
+#define MICROPY_HW_MCU_NAME "POWERPC"
+
+#define MP_STATE_PORT MP_STATE_VM
+
+#define MICROPY_PORT_ROOT_POINTERS \
+    const char *readline_hist[8];
+
+// powerpc64 gcc doesn't seem to define these
+// These are pointers, so make them 64 bit types
+typedef long intptr_t;
+typedef unsigned long uintptr_t;
diff --git a/ports/powerpc/mphalport.h b/ports/powerpc/mphalport.h
new file mode 100644
index 0000000000000..bb7fa34cabc3f
--- /dev/null
+++ b/ports/powerpc/mphalport.h
@@ -0,0 +1,45 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019, Michael Neuling, IBM Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#define mftb()  ({unsigned long rval;                                   \
+                  __asm__ volatile ("mftb %0" : "=r" (rval)); rval;})
+
+#define TBFREQ 512000000
+
+static inline mp_uint_t mp_hal_ticks_ms(void) {
+    unsigned long tb = mftb();
+
+    return tb * 1000 / TBFREQ;
+}
+
+static inline mp_uint_t mp_hal_ticks_us(void) {
+    unsigned long tb = mftb();
+
+    return tb * 1000000 / TBFREQ;
+}
+
+static inline void mp_hal_set_interrupt_char(char c) {
+}
diff --git a/ports/powerpc/powerpc.lds b/ports/powerpc/powerpc.lds
new file mode 100644
index 0000000000000..93bd8a605cbd2
--- /dev/null
+++ b/ports/powerpc/powerpc.lds
@@ -0,0 +1,13 @@
+SECTIONS
+{
+        . = 0;
+        _start = .;
+        .head : {
+                KEEP(*(.head))
+        }
+
+        /* Put this at 0x1700 which is right after our execption
+         * vectors in head.S.
+         */
+        . = 0x1700;
+}
diff --git a/ports/powerpc/qstrdefsport.h b/ports/powerpc/qstrdefsport.h
new file mode 100644
index 0000000000000..00d3e2ae3c555
--- /dev/null
+++ b/ports/powerpc/qstrdefsport.h
@@ -0,0 +1,2 @@
+// qstrs specific to this port
+// *FORMAT-OFF*
diff --git a/ports/powerpc/uart_lpc_serial.c b/ports/powerpc/uart_lpc_serial.c
new file mode 100644
index 0000000000000..760615041cf94
--- /dev/null
+++ b/ports/powerpc/uart_lpc_serial.c
@@ -0,0 +1,119 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019, Michael Neuling, IBM Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/*
+ * This is the LPC serial UART used by POWER9 boxes. This is modelled
+ * in the qemu POWER9 machine.
+ */
+
+#include <unistd.h>
+#include <stdbool.h>
+#include "py/mpconfig.h"
+
+#define PROC_FREQ       50000000
+#define UART_FREQ       115200
+#define UART_BASE       0xc0002000
+#define LPC_UART_BASE   0x60300d00103f8
+
+/* Taken from skiboot */
+#define REG_RBR         0
+#define REG_THR         0
+#define REG_DLL         0
+#define REG_IER         1
+#define REG_DLM         1
+#define REG_FCR         2
+#define REG_IIR         2
+#define REG_LCR         3
+#define REG_MCR         4
+#define REG_LSR         5
+#define REG_MSR         6
+#define REG_SCR         7
+
+#define LSR_DR          0x01  /* Data ready */
+#define LSR_OE          0x02  /* Overrun */
+#define LSR_PE          0x04  /* Parity error */
+#define LSR_FE          0x08  /* Framing error */
+#define LSR_BI          0x10  /* Break */
+#define LSR_THRE        0x20  /* Xmit holding register empty */
+#define LSR_TEMT        0x40  /* Xmitter empty */
+#define LSR_ERR         0x80  /* Error */
+
+#define LCR_DLAB        0x80  /* DLL access */
+
+#define IER_RX          0x01
+#define IER_THRE        0x02
+#define IER_ALL         0x0f
+
+static uint64_t lpc_uart_base;
+
+static void lpc_uart_reg_write(uint64_t offset, uint8_t val) {
+    uint64_t addr;
+
+    addr = lpc_uart_base + offset;
+
+    *(volatile uint8_t *)addr = val;
+}
+
+static uint8_t lpc_uart_reg_read(uint64_t offset) {
+    uint64_t addr;
+    uint8_t val;
+
+    addr = lpc_uart_base + offset;
+
+    val = *(volatile uint8_t *)addr;
+
+    return val;
+}
+
+static int lpc_uart_tx_full(void) {
+    return !(lpc_uart_reg_read(REG_LSR) & LSR_THRE);
+}
+
+static int lpc_uart_rx_empty(void) {
+    return !(lpc_uart_reg_read(REG_LSR) & LSR_DR);
+}
+
+void uart_init_ppc(void) {
+    lpc_uart_base = LPC_UART_BASE;
+}
+
+int mp_hal_stdin_rx_chr(void) {
+    while (lpc_uart_rx_empty()) {
+        ;
+    }
+    return lpc_uart_reg_read(REG_THR);
+}
+
+
+void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) {
+    int i;
+    for (i = 0; i < len; i++) {
+        while (lpc_uart_tx_full()) {
+            ;
+        }
+        lpc_uart_reg_write(REG_RBR, str[i]);
+    }
+}
diff --git a/ports/cc3200/mods/modubinascii.h b/ports/powerpc/uart_lpc_serial.h
similarity index 85%
rename from ports/cc3200/mods/modubinascii.h
rename to ports/powerpc/uart_lpc_serial.h
index eb9fc4f219610..d0e35ca32bb5b 100644
--- a/ports/cc3200/mods/modubinascii.h
+++ b/ports/powerpc/uart_lpc_serial.h
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2014 Paul Sokolovsky
+ * Copyright (c) 2019, Michael Neuling, IBM Corporation.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -23,8 +23,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-#ifndef MICROPY_INCLUDED_CC3200_MODS_MODUBINASCII_H
-#define MICROPY_INCLUDED_CC3200_MODS_MODUBINASCII_H
 
-
-#endif // MICROPY_INCLUDED_CC3200_MODS_MODUBINASCII_H
+void lpc_uart_init(void);
+char lpc_uart_read(void);
+void lpc_uart_write(char c);
diff --git a/ports/powerpc/uart_potato.c b/ports/powerpc/uart_potato.c
new file mode 100644
index 0000000000000..29f21934ddf44
--- /dev/null
+++ b/ports/powerpc/uart_potato.c
@@ -0,0 +1,132 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019, Michael Neuling, IBM Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/*
+ * This is a driver for the potato UART used by the microwatt core.
+ * The original potato UART came from here
+ *    https://github.com/skordal/potato
+ */
+
+#include <unistd.h>
+#include <stdbool.h>
+#include "py/mpconfig.h"
+
+#define SYSCON_BASE     0xc0000000  /* System control regs */
+#define SYS_REG_CLKINFO                 0x20
+
+#define UART_FREQ                           115200
+#define POTATO_UART_BASE                    0xc0002000
+static uint64_t potato_uart_base;
+
+#define POTATO_CONSOLE_TX                   0x00
+#define POTATO_CONSOLE_RX                   0x08
+#define POTATO_CONSOLE_STATUS               0x10
+#define POTATO_CONSOLE_STATUS_RX_EMPTY      0x01
+#define POTATO_CONSOLE_STATUS_TX_EMPTY      0x02
+#define POTATO_CONSOLE_STATUS_RX_FULL       0x04
+#define POTATO_CONSOLE_STATUS_TX_FULL       0x08
+#define POTATO_CONSOLE_CLOCK_DIV            0x18
+#define POTATO_CONSOLE_IRQ_EN               0x20
+
+static uint64_t potato_uart_reg_read(int offset) {
+    uint64_t addr;
+    uint64_t val;
+
+    addr = potato_uart_base + offset;
+
+    val = *(volatile uint64_t *)addr;
+
+    return val;
+}
+
+static void potato_uart_reg_write(int offset, uint64_t val) {
+    uint64_t addr;
+
+    addr = potato_uart_base + offset;
+
+    *(volatile uint64_t *)addr = val;
+}
+
+static int potato_uart_rx_empty(void) {
+    uint64_t val;
+
+    val = potato_uart_reg_read(POTATO_CONSOLE_STATUS);
+
+    if (val & POTATO_CONSOLE_STATUS_RX_EMPTY) {
+        return 1;
+    }
+
+    return 0;
+}
+
+static int potato_uart_tx_full(void) {
+    uint64_t val;
+
+    val = potato_uart_reg_read(POTATO_CONSOLE_STATUS);
+
+    if (val & POTATO_CONSOLE_STATUS_TX_FULL) {
+        return 1;
+    }
+
+    return 0;
+}
+
+static unsigned long potato_uart_divisor(unsigned long proc_freq, unsigned long uart_freq) {
+    return proc_freq / (uart_freq * 16) - 1;
+}
+
+void uart_init_ppc(void) {
+    uint64_t proc_freq;
+
+    potato_uart_base = POTATO_UART_BASE;
+    proc_freq = *(volatile uint64_t *)(SYSCON_BASE + SYS_REG_CLKINFO);
+    potato_uart_reg_write(POTATO_CONSOLE_CLOCK_DIV, potato_uart_divisor(proc_freq, UART_FREQ));
+
+}
+
+int mp_hal_stdin_rx_chr(void) {
+    uint64_t val;
+
+    while (potato_uart_rx_empty()) {
+        ;
+    }
+    val = potato_uart_reg_read(POTATO_CONSOLE_RX);
+
+    return (char)(val & 0x000000ff);
+}
+
+void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) {
+    int i;
+
+    for (i = 0; i < len; i++) {
+        uint64_t val = str[i];
+
+        while (potato_uart_tx_full()) {
+            ;
+        }
+        potato_uart_reg_write(POTATO_CONSOLE_TX, val);
+    }
+}
diff --git a/ports/powerpc/uart_potato.h b/ports/powerpc/uart_potato.h
new file mode 100644
index 0000000000000..d6bd93aa4ea85
--- /dev/null
+++ b/ports/powerpc/uart_potato.h
@@ -0,0 +1,29 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019, Michael Neuling, IBM Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+void potato_uart_init(void);
+char potato_uart_read(void);
+void potato_uart_write(char c);
diff --git a/ports/powerpc/unistd.h b/ports/powerpc/unistd.h
new file mode 100644
index 0000000000000..88e3b27218ad6
--- /dev/null
+++ b/ports/powerpc/unistd.h
@@ -0,0 +1,36 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019, Michael Neuling, IBM Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_POWERPC_UNISTD_H
+#define MICROPY_INCLUDED_POWERPC_UNISTD_H
+
+// powerpc gcc compiler doesn't seem to have unistd.h file
+
+#define SEEK_SET 0
+#define SEEK_CUR 1
+
+typedef int ssize_t;
+
+#endif // MICROPY_INCLUDED_POWERPC_UNISTD_H
diff --git a/ports/qemu-arm/Makefile b/ports/qemu-arm/Makefile
index 03a8afe77ea9b..430740ccf73f7 100644
--- a/ports/qemu-arm/Makefile
+++ b/ports/qemu-arm/Makefile
@@ -4,10 +4,13 @@ include ../../py/mkenv.mk
 # qstr definitions (must come before including py.mk)
 QSTR_DEFS = qstrdefsport.h
 
+# MicroPython feature configurations
+MICROPY_ROM_TEXT_COMPRESSION ?= 1
+
 # include py core make definitions
 include $(TOP)/py/py.mk
 
-BOARD ?= netduino2
+BOARD ?= mps2-an385
 
 ifeq ($(BOARD),netduino2)
 CFLAGS += -mthumb -mcpu=cortex-m3 -mfloat-abi=soft
@@ -31,16 +34,13 @@ LDSCRIPT = mps2.ld
 SRC_BOARD_O = lib/utils/gchelper_m3.o
 endif
 
-CROSS_COMPILE = arm-none-eabi-
-
-TINYTEST = $(TOP)/lib/tinytest
+CROSS_COMPILE ?= arm-none-eabi-
 
 INC += -I.
 INC += -I$(TOP)
 INC += -I$(BUILD)
-INC += -I$(TINYTEST)
 
-CFLAGS += $(INC) -Wall -Wpointer-arith -Werror -std=gnu99 $(COPT) \
+CFLAGS += $(INC) -Wall -Wpointer-arith -Wdouble-promotion -Wfloat-conversion -Werror -std=gnu99 $(COPT) \
 	 -ffunction-sections -fdata-sections
 
 #Debugging/Optimization
@@ -71,6 +71,7 @@ SRC_RUN_C = \
 
 SRC_TEST_C = \
 	test_main.c \
+	lib/tinytest/tinytest.c \
 
 LIB_SRC_C += $(addprefix lib/,\
 	libc/string0.c \
@@ -92,6 +93,8 @@ LIB_SRC_C += $(addprefix lib/,\
 	libm/asinfacosf.c \
 	libm/atanf.c \
 	libm/atan2f.c \
+	libm/roundf.c \
+	utils/gchelper_native.c \
 	utils/sys_stdio_mphal.c \
 	)
 
@@ -104,9 +107,12 @@ OBJ_COMMON += $(addprefix $(BUILD)/, $(LIB_SRC_C:.c=.o))
 OBJ_RUN =
 OBJ_RUN += $(addprefix $(BUILD)/, $(SRC_RUN_C:.c=.o))
 
+ALL_OBJ_RUN = $(OBJ_COMMON) $(OBJ_RUN)
+
 OBJ_TEST =
 OBJ_TEST += $(addprefix $(BUILD)/, $(SRC_TEST_C:.c=.o))
-OBJ_TEST += $(BUILD)/tinytest.o
+
+ALL_OBJ_TEST = $(OBJ_COMMON) $(OBJ_TEST)
 
 # All object files, needed to get dependencies correct
 OBJ = $(OBJ_COMMON) $(OBJ_RUN) $(OBJ_TEST)
@@ -114,14 +120,21 @@ OBJ = $(OBJ_COMMON) $(OBJ_RUN) $(OBJ_TEST)
 # List of sources for qstr extraction
 SRC_QSTR += $(SRC_COMMON_C) $(SRC_RUN_C) $(LIB_SRC_C)
 
+ifneq ($(FROZEN_MANIFEST),)
+CFLAGS += -DMICROPY_MODULE_FROZEN_STR
+CFLAGS += -DMICROPY_MODULE_FROZEN_MPY
+CFLAGS += -DMICROPY_QSTR_EXTRA_POOL=mp_qstr_frozen_const_pool
+MPY_CROSS_FLAGS += -march=armv7m
+endif
+
 all: run
 
 run: $(BUILD)/firmware.elf
 	qemu-system-arm -machine $(BOARD) $(QEMU_EXTRA) -nographic -monitor null -semihosting -kernel $<
 
 ## `$(LD)` doesn't seem to like `--specs` for some reason, but we can just use `$(CC)` here.
-$(BUILD)/firmware.elf: $(OBJ_COMMON) $(OBJ_RUN)
-	$(Q)$(LD) $(LDFLAGS) -o $@ $^ $(LIBS)
+$(BUILD)/firmware.elf: $(LDSCRIPT) $(ALL_OBJ_RUN)
+	$(Q)$(LD) $(LDFLAGS) -o $@ $(ALL_OBJ_RUN) $(LIBS)
 	$(Q)$(SIZE) $@
 
 include $(TOP)/py/mkrules.mk
diff --git a/ports/qemu-arm/Makefile.test b/ports/qemu-arm/Makefile.test
index 347c2fefd3024..340e1c3b90d5e 100644
--- a/ports/qemu-arm/Makefile.test
+++ b/ports/qemu-arm/Makefile.test
@@ -1,5 +1,7 @@
 LIB_SRC_C = lib/upytesthelper/upytesthelper.c
 
+FROZEN_MANIFEST ?= "freeze('test-frzmpy')"
+
 include Makefile
 
 CFLAGS += -DTEST
@@ -8,17 +10,17 @@ CFLAGS += -DTEST
 
 $(BUILD)/test_main.o: $(BUILD)/genhdr/tests.h
 $(BUILD)/genhdr/tests.h:
-	(cd $(TOP)/tests; ./run-tests --write-exp)
+	(cd $(TOP)/tests; ./run-tests --target=qemu-arm --write-exp)
 	$(Q)echo "Generating $@";(cd $(TOP)/tests; ../tools/tinytest-codegen.py) > $@
 
-$(BUILD)/tinytest.o:
-	$(Q)$(CC) $(CFLAGS) -DNO_FORKING -o $@ -c $(TINYTEST)/tinytest.c
+$(BUILD)/lib/tinytest/tinytest.o: CFLAGS += -DNO_FORKING
 
-$(BUILD)/firmware-test.elf: $(OBJ_COMMON) $(OBJ_TEST)
-	$(Q)$(LD) $(LDFLAGS) -o $@ $^ $(LIBS)
+$(BUILD)/firmware-test.elf: $(LDSCRIPT) $(ALL_OBJ_TEST)
+	$(Q)$(LD) $(LDFLAGS) -o $@ $(ALL_OBJ_TEST) $(LIBS)
 	$(Q)$(SIZE) $@
 
+# Note: Using timeout(1) to handle cases where qemu hangs (e.g. this can happen with alignment errors).
 test: $(BUILD)/firmware-test.elf
-	qemu-system-arm -machine $(BOARD) $(QEMU_EXTRA) -nographic -monitor null -semihosting -kernel $< > $(BUILD)/console.out
+	timeout --foreground -k 5s 30s qemu-system-arm -machine $(BOARD) $(QEMU_EXTRA) -nographic -monitor null -semihosting -kernel $< > $(BUILD)/console.out
 	$(Q)tail -n2 $(BUILD)/console.out
 	$(Q)tail -n1 $(BUILD)/console.out | grep -q "status: 0"
diff --git a/ports/qemu-arm/main.c b/ports/qemu-arm/main.c
index 4cdd1482879ed..8c49d0c780c66 100644
--- a/ports/qemu-arm/main.c
+++ b/ports/qemu-arm/main.c
@@ -18,7 +18,7 @@ void do_str(const char *src, mp_parse_input_kind_t input_kind) {
         mp_lexer_t *lex = mp_lexer_new_from_str_len(MP_QSTR__lt_stdin_gt_, src, strlen(src), 0);
         qstr source_name = lex->source_name;
         mp_parse_tree_t parse_tree = mp_parse(lex, input_kind);
-        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, MP_EMIT_OPT_NONE, true);
+        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, true);
         mp_call_function_0(module_fun);
         nlr_pop();
     } else {
@@ -30,8 +30,8 @@ void do_str(const char *src, mp_parse_input_kind_t input_kind) {
 int main(int argc, char **argv) {
     mp_stack_ctrl_init();
     mp_stack_set_limit(10240);
-    uint32_t heap[16*1024 / 4];
-    gc_init(heap, (char*)heap + 16 * 1024);
+    uint32_t heap[16 * 1024 / 4];
+    gc_init(heap, (char *)heap + 16 * 1024);
     mp_init();
     do_str("print('hello world!')", MP_PARSE_SINGLE_INPUT);
     mp_deinit();
diff --git a/ports/qemu-arm/modmachine.c b/ports/qemu-arm/modmachine.c
index 0f66349a8befc..728fd4fa31b09 100644
--- a/ports/qemu-arm/modmachine.c
+++ b/ports/qemu-arm/modmachine.c
@@ -43,5 +43,5 @@ STATIC MP_DEFINE_CONST_DICT(machine_module_globals, machine_module_globals_table
 
 const mp_obj_module_t mp_module_machine = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&machine_module_globals,
+    .globals = (mp_obj_dict_t *)&machine_module_globals,
 };
diff --git a/ports/qemu-arm/moduos.c b/ports/qemu-arm/moduos.c
index a48b51db01ae0..23a1241869f54 100644
--- a/ports/qemu-arm/moduos.c
+++ b/ports/qemu-arm/moduos.c
@@ -49,5 +49,5 @@ STATIC MP_DEFINE_CONST_DICT(os_module_globals, os_module_globals_table);
 
 const mp_obj_module_t mp_module_uos = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&os_module_globals,
+    .globals = (mp_obj_dict_t *)&os_module_globals,
 };
diff --git a/ports/qemu-arm/mpconfigport.h b/ports/qemu-arm/mpconfigport.h
index 3d4abd52fffd9..498ab3ed2cfac 100644
--- a/ports/qemu-arm/mpconfigport.h
+++ b/ports/qemu-arm/mpconfigport.h
@@ -43,7 +43,7 @@
 
 // type definitions for the specific machine
 
-#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void*)((mp_uint_t)(p) | 1))
+#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)((mp_uint_t)(p) | 1))
 
 #define MP_SSIZE_MAX (0x7fffffff)
 
diff --git a/ports/qemu-arm/qstrdefsport.h b/ports/qemu-arm/qstrdefsport.h
index 3ba897069bf73..00d3e2ae3c555 100644
--- a/ports/qemu-arm/qstrdefsport.h
+++ b/ports/qemu-arm/qstrdefsport.h
@@ -1 +1,2 @@
 // qstrs specific to this port
+// *FORMAT-OFF*
diff --git a/ports/qemu-arm/startup.c b/ports/qemu-arm/startup.c
index 5198d089f979b..002d5ef62418a 100644
--- a/ports/qemu-arm/startup.c
+++ b/ports/qemu-arm/startup.c
@@ -68,7 +68,7 @@ __attribute__((naked)) void exit(int status) {
         ".notclean:\n"
         "movs r0, #0x18\n" // SYS_EXIT
         "bkpt 0xab\n"
-    );
+        );
     for (;;) {
     }
 }
diff --git a/ports/qemu-arm/test-frzmpy/native_frozen_align.py b/ports/qemu-arm/test-frzmpy/native_frozen_align.py
new file mode 100644
index 0000000000000..8675b8e7fa237
--- /dev/null
+++ b/ports/qemu-arm/test-frzmpy/native_frozen_align.py
@@ -0,0 +1,16 @@
+import micropython
+
+
+@micropython.native
+def native_x(x):
+    print(x + 1)
+
+
+@micropython.native
+def native_y(x):
+    print(x + 1)
+
+
+@micropython.native
+def native_z(x):
+    print(x + 1)
diff --git a/ports/qemu-arm/test_main.c b/ports/qemu-arm/test_main.c
index 3a85d65f38c6a..a59a8de0ad31a 100644
--- a/ports/qemu-arm/test_main.c
+++ b/ports/qemu-arm/test_main.c
@@ -12,9 +12,8 @@
 #include "py/gc.h"
 #include "py/mperrno.h"
 #include "lib/utils/gchelper.h"
-
-#include "tinytest.h"
-#include "tinytest_macros.h"
+#include "lib/tinytest/tinytest.h"
+#include "lib/tinytest/tinytest_macros.h"
 
 #define HEAP_SIZE (100 * 1024)
 
@@ -24,7 +23,7 @@ int main() {
     mp_stack_ctrl_init();
     mp_stack_set_limit(10240);
     static uint32_t heap[HEAP_SIZE / sizeof(uint32_t)];
-    upytest_set_heap(heap, (char*)heap + HEAP_SIZE);
+    upytest_set_heap(heap, (char *)heap + HEAP_SIZE);
     int r = tinytest_main(0, NULL, groups);
     printf("status: %d\n", r);
     return r;
@@ -32,14 +31,7 @@ int main() {
 
 void gc_collect(void) {
     gc_collect_start();
-
-    // get the registers and the sp
-    uintptr_t regs[10];
-    uintptr_t sp = gc_helper_get_regs_and_sp(regs);
-
-    // trace the stack, including the registers (since they live on the stack in this function)
-    gc_collect_root((void**)sp, ((uint32_t)MP_STATE_THREAD(stack_top) - (uint32_t)sp) / sizeof(uint32_t));
-
+    gc_helper_collect_regs_and_stack();
     gc_collect_end();
 }
 
diff --git a/ports/qemu-arm/uart.c b/ports/qemu-arm/uart.c
index a0ce737c06dc3..8710e9e9f681d 100644
--- a/ports/qemu-arm/uart.c
+++ b/ports/qemu-arm/uart.c
@@ -10,7 +10,7 @@ typedef struct _UART_t {
     volatile uint32_t DR;
 } UART_t;
 
-#define UART0 ((UART_t*)(0x40011000))
+#define UART0 ((UART_t *)(0x40011000))
 
 void uart_init(void) {
 }
@@ -32,7 +32,7 @@ typedef struct _UART_t {
     volatile uint32_t TXD;      // 0x51c
 } UART_t;
 
-#define UART0 ((UART_t*)(0x40002000))
+#define UART0 ((UART_t *)(0x40002000))
 
 void uart_init(void) {
     UART0->ENABLE = 4;
@@ -60,7 +60,7 @@ typedef struct _UART_t {
     volatile uint32_t BAUDDIV;
 } UART_t;
 
-#define UART0 ((UART_t*)(0x40004000))
+#define UART0 ((UART_t *)(0x40004000))
 
 void uart_init(void) {
     UART0->BAUDDIV = 16;
diff --git a/ports/samd/Makefile b/ports/samd/Makefile
new file mode 100644
index 0000000000000..ffd0f06a3f85c
--- /dev/null
+++ b/ports/samd/Makefile
@@ -0,0 +1,102 @@
+BOARD ?= ADAFRUIT_ITSYBITSY_M4_EXPRESS
+BOARD_DIR ?= boards/$(BOARD)
+BUILD ?= build-$(BOARD)
+
+CROSS_COMPILE ?= arm-none-eabi-
+UF2CONV ?= $(TOP)/tools/uf2conv.py
+
+ifeq ($(wildcard $(BOARD_DIR)/.),)
+$(error Invalid BOARD specified: $(BOARD_DIR))
+endif
+
+include ../../py/mkenv.mk
+include $(BOARD_DIR)/mpconfigboard.mk
+
+# Qstr definitions (must come before including py.mk)
+QSTR_DEFS = qstrdefsport.h
+QSTR_GLOBAL_DEPENDENCIES = $(BOARD_DIR)/mpconfigboard.h
+
+# Include py core make definitions
+include $(TOP)/py/py.mk
+
+GIT_SUBMODULES = lib/asf4 lib/tinyusb
+
+INC += -I.
+INC += -I$(TOP)
+INC += -I$(BUILD)
+INC += -I$(BOARD_DIR)
+INC += -I$(TOP)/lib/cmsis/inc
+INC += -I$(TOP)/lib/asf4/$(shell echo $(MCU_SERIES) | tr '[:upper:]' '[:lower:]')/include
+INC += -I$(TOP)/lib/tinyusb/src
+
+CFLAGS_MCU_SAMD21 = -mtune=cortex-m0plus -mcpu=cortex-m0plus -msoft-float
+CFLAGS_MCU_SAMD51 = -mtune=cortex-m4 -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard
+CFLAGS = $(INC) -Wall -Werror -std=c99 -nostdlib -mthumb $(CFLAGS_MCU_$(MCU_SERIES)) -fsingle-precision-constant -Wdouble-promotion
+CFLAGS += -DMCU_$(MCU_SERIES) -D__$(CMSIS_MCU)__
+LDFLAGS = -nostdlib $(addprefix -T,$(LD_FILES)) -Map=$@.map --cref
+LIBS = $(shell $(CC) $(CFLAGS) -print-libgcc-file-name)
+
+# Tune for Debugging or Optimization
+ifeq ($(DEBUG),1)
+CFLAGS += -O0 -ggdb
+else
+CFLAGS += -Os -DNDEBUG
+LDFLAGS += --gc-sections
+CFLAGS += -fdata-sections -ffunction-sections
+endif
+
+SRC_C = \
+	main.c \
+	modutime.c \
+	modmachine.c \
+	mphalport.c \
+	samd_isr.c \
+	samd_soc.c \
+	tusb_port.c \
+	lib/libc/string0.c \
+	lib/libm/ef_sqrt.c \
+	lib/libm/fmodf.c \
+	lib/libm/math.c \
+	lib/libm/nearbyintf.c \
+	lib/mp-readline/readline.c \
+	lib/tinyusb/src/class/cdc/cdc_device.c \
+	lib/tinyusb/src/common/tusb_fifo.c \
+	lib/tinyusb/src/device/usbd.c \
+	lib/tinyusb/src/device/usbd_control.c \
+	lib/tinyusb/src/portable/microchip/samd/dcd_samd.c \
+	lib/tinyusb/src/tusb.c \
+	lib/utils/gchelper_native.c \
+	lib/utils/printf.c \
+	lib/utils/pyexec.c \
+	lib/utils/stdout_helpers.c \
+
+ifeq ($(MCU_SERIES),SAMD21)
+SRC_S = lib/utils/gchelper_m0.s
+else
+SRC_S = lib/utils/gchelper_m3.s
+endif
+
+# List of sources for qstr extraction
+SRC_QSTR += modutime.c modmachine.c
+
+OBJ += $(PY_O)
+OBJ += $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
+OBJ += $(addprefix $(BUILD)/, $(SRC_S:.s=.o))
+
+# Workaround for bug in older gcc, warning on "static usbd_device_t _usbd_dev = { 0 };"
+$(BUILD)/lib/tinyusb/src/device/usbd.o: CFLAGS += -Wno-missing-braces
+
+all: $(BUILD)/firmware.uf2
+
+$(BUILD)/firmware.elf: $(OBJ)
+	$(ECHO) "LINK $@"
+	$(Q)$(LD) $(LDFLAGS) -o $@ $^ $(LIBS)
+	$(Q)$(SIZE) $@
+
+$(BUILD)/firmware.bin: $(BUILD)/firmware.elf
+	$(Q)$(OBJCOPY) -O binary -j .isr_vector -j .text -j .data $^ $(BUILD)/firmware.bin
+
+$(BUILD)/firmware.uf2: $(BUILD)/firmware.bin
+	$(Q)$(PYTHON) $(UF2CONV) -b $(TEXT0) -c -o $@ $<
+
+include $(TOP)/py/mkrules.mk
diff --git a/ports/samd/README.md b/ports/samd/README.md
new file mode 100644
index 0000000000000..b2ff4023ece75
--- /dev/null
+++ b/ports/samd/README.md
@@ -0,0 +1,7 @@
+Port of MicroPython to Microchip SAMD MCUs
+==========================================
+
+Supports SAMD21 and SAMD51.
+
+Features:
+- REPL over USB VCP
diff --git a/ports/samd/boards/ADAFRUIT_FEATHER_M0_EXPRESS/mpconfigboard.h b/ports/samd/boards/ADAFRUIT_FEATHER_M0_EXPRESS/mpconfigboard.h
new file mode 100644
index 0000000000000..cec9e9ccdda46
--- /dev/null
+++ b/ports/samd/boards/ADAFRUIT_FEATHER_M0_EXPRESS/mpconfigboard.h
@@ -0,0 +1,2 @@
+#define MICROPY_HW_BOARD_NAME "Feather M0 Express"
+#define MICROPY_HW_MCU_NAME   "SAMD21G18A"
diff --git a/ports/samd/boards/ADAFRUIT_FEATHER_M0_EXPRESS/mpconfigboard.mk b/ports/samd/boards/ADAFRUIT_FEATHER_M0_EXPRESS/mpconfigboard.mk
new file mode 100644
index 0000000000000..8696c966bc321
--- /dev/null
+++ b/ports/samd/boards/ADAFRUIT_FEATHER_M0_EXPRESS/mpconfigboard.mk
@@ -0,0 +1,4 @@
+MCU_SERIES = SAMD21
+CMSIS_MCU = SAMD21G18A
+LD_FILES = boards/samd21x18a.ld sections.ld
+TEXT0 = 0x2000
diff --git a/ports/samd/boards/ADAFRUIT_ITSYBITSY_M4_EXPRESS/mpconfigboard.h b/ports/samd/boards/ADAFRUIT_ITSYBITSY_M4_EXPRESS/mpconfigboard.h
new file mode 100644
index 0000000000000..490704eadb178
--- /dev/null
+++ b/ports/samd/boards/ADAFRUIT_ITSYBITSY_M4_EXPRESS/mpconfigboard.h
@@ -0,0 +1,7 @@
+#define MICROPY_HW_BOARD_NAME "ItsyBitsy M4 Express"
+#define MICROPY_HW_MCU_NAME   "SAMD51G19A"
+
+#define MICROPY_FLOAT_IMPL              (MICROPY_FLOAT_IMPL_FLOAT)
+#define MICROPY_PY_BUILTINS_COMPLEX     (0)
+#define MICROPY_PY_MATH                 (0)
+#define MICROPY_PY_CMATH                (0)
diff --git a/ports/samd/boards/ADAFRUIT_ITSYBITSY_M4_EXPRESS/mpconfigboard.mk b/ports/samd/boards/ADAFRUIT_ITSYBITSY_M4_EXPRESS/mpconfigboard.mk
new file mode 100644
index 0000000000000..2e5d7e68df7d6
--- /dev/null
+++ b/ports/samd/boards/ADAFRUIT_ITSYBITSY_M4_EXPRESS/mpconfigboard.mk
@@ -0,0 +1,4 @@
+MCU_SERIES = SAMD51
+CMSIS_MCU = SAMD51G19A
+LD_FILES = boards/samd51g19a.ld sections.ld
+TEXT0 = 0x4000
diff --git a/ports/samd/boards/ADAFRUIT_TRINKET_M0/mpconfigboard.h b/ports/samd/boards/ADAFRUIT_TRINKET_M0/mpconfigboard.h
new file mode 100644
index 0000000000000..d3a6ba2d8687e
--- /dev/null
+++ b/ports/samd/boards/ADAFRUIT_TRINKET_M0/mpconfigboard.h
@@ -0,0 +1,2 @@
+#define MICROPY_HW_BOARD_NAME "Trinket M0"
+#define MICROPY_HW_MCU_NAME   "SAMD21E18A"
diff --git a/ports/samd/boards/ADAFRUIT_TRINKET_M0/mpconfigboard.mk b/ports/samd/boards/ADAFRUIT_TRINKET_M0/mpconfigboard.mk
new file mode 100644
index 0000000000000..5b4d0b63e7e5a
--- /dev/null
+++ b/ports/samd/boards/ADAFRUIT_TRINKET_M0/mpconfigboard.mk
@@ -0,0 +1,4 @@
+MCU_SERIES = SAMD21
+CMSIS_MCU = SAMD21E18A
+LD_FILES = boards/samd21x18a.ld sections.ld
+TEXT0 = 0x2000
diff --git a/ports/samd/boards/MINISAM_M4/mpconfigboard.h b/ports/samd/boards/MINISAM_M4/mpconfigboard.h
new file mode 100644
index 0000000000000..0847a45bf1a4b
--- /dev/null
+++ b/ports/samd/boards/MINISAM_M4/mpconfigboard.h
@@ -0,0 +1,7 @@
+#define MICROPY_HW_BOARD_NAME "Mini SAM M4"
+#define MICROPY_HW_MCU_NAME   "SAMD51G19A"
+
+#define MICROPY_FLOAT_IMPL              (MICROPY_FLOAT_IMPL_FLOAT)
+#define MICROPY_PY_BUILTINS_COMPLEX     (0)
+#define MICROPY_PY_MATH                 (0)
+#define MICROPY_PY_CMATH                (0)
diff --git a/ports/samd/boards/MINISAM_M4/mpconfigboard.mk b/ports/samd/boards/MINISAM_M4/mpconfigboard.mk
new file mode 100644
index 0000000000000..54ed3273d547e
--- /dev/null
+++ b/ports/samd/boards/MINISAM_M4/mpconfigboard.mk
@@ -0,0 +1,5 @@
+# https://www.minifigboards.com/mini-sam-m4/mini-sam-m4-hardware/
+MCU_SERIES = SAMD51
+CMSIS_MCU = SAMD51G19A
+LD_FILES = boards/samd51g19a.ld sections.ld
+TEXT0 = 0x4000
diff --git a/ports/samd/boards/SAMD21_XPLAINED_PRO/mpconfigboard.h b/ports/samd/boards/SAMD21_XPLAINED_PRO/mpconfigboard.h
new file mode 100644
index 0000000000000..c69b5b4c149de
--- /dev/null
+++ b/ports/samd/boards/SAMD21_XPLAINED_PRO/mpconfigboard.h
@@ -0,0 +1,2 @@
+#define MICROPY_HW_BOARD_NAME "SAMD21-XPLAINED-PRO"
+#define MICROPY_HW_MCU_NAME   "SAMD21J18A"
diff --git a/ports/samd/boards/SAMD21_XPLAINED_PRO/mpconfigboard.mk b/ports/samd/boards/SAMD21_XPLAINED_PRO/mpconfigboard.mk
new file mode 100644
index 0000000000000..f95c6549381ba
--- /dev/null
+++ b/ports/samd/boards/SAMD21_XPLAINED_PRO/mpconfigboard.mk
@@ -0,0 +1,4 @@
+MCU_SERIES = SAMD21
+CMSIS_MCU = SAMD21J18A
+LD_FILES = boards/samd21x18a.ld sections.ld
+TEXT0 = 0x2000
diff --git a/ports/samd/boards/samd21x18a.ld b/ports/samd/boards/samd21x18a.ld
new file mode 100644
index 0000000000000..b7d59c315b643
--- /dev/null
+++ b/ports/samd/boards/samd21x18a.ld
@@ -0,0 +1,17 @@
+/*
+    GNU linker script for SAMD21
+*/
+
+/* Specify the memory areas */
+MEMORY
+{
+    FLASH (rx)  : ORIGIN = 0x00002000, LENGTH = 256K - 8K
+    RAM (xrw)   : ORIGIN = 0x20000000, LENGTH = 32K
+}
+
+/* Top end of the stack, with room for double-tap variable */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - 8;
+_sstack = _estack - 8K;
+
+_sheap = _ebss;
+_eheap = _sstack;
diff --git a/ports/samd/boards/samd51g19a.ld b/ports/samd/boards/samd51g19a.ld
new file mode 100644
index 0000000000000..e0baa9bba0281
--- /dev/null
+++ b/ports/samd/boards/samd51g19a.ld
@@ -0,0 +1,17 @@
+/*
+    GNU linker script for SAMD51
+*/
+
+/* Specify the memory areas */
+MEMORY
+{
+    FLASH (rx)  : ORIGIN = 0x00004000, LENGTH = 512K - 16K
+    RAM (xrw)   : ORIGIN = 0x20000000, LENGTH = 192K
+}
+
+/* Top end of the stack, with room for double-tap variable */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - 8;
+_sstack = _estack - 16K;
+
+_sheap = _ebss;
+_eheap = _sstack;
diff --git a/ports/samd/main.c b/ports/samd/main.c
new file mode 100644
index 0000000000000..038373ceb403b
--- /dev/null
+++ b/ports/samd/main.c
@@ -0,0 +1,96 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/compile.h"
+#include "py/runtime.h"
+#include "py/gc.h"
+#include "py/mperrno.h"
+#include "py/stackctrl.h"
+#include "lib/utils/gchelper.h"
+#include "lib/utils/pyexec.h"
+
+extern uint8_t _sstack, _estack, _sheap, _eheap;
+
+void samd_main(void) {
+    mp_stack_set_top(&_estack);
+    mp_stack_set_limit(&_estack - &_sstack - 1024);
+
+    for (;;) {
+        gc_init(&_sheap, &_eheap);
+        mp_init();
+        mp_obj_list_init(MP_OBJ_TO_PTR(mp_sys_path), 0);
+        mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR_));
+        mp_obj_list_init(MP_OBJ_TO_PTR(mp_sys_argv), 0);
+
+        for (;;) {
+            if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
+                if (pyexec_raw_repl() != 0) {
+                    break;
+                }
+            } else {
+                if (pyexec_friendly_repl() != 0) {
+                    break;
+                }
+            }
+        }
+
+        mp_printf(MP_PYTHON_PRINTER, "MPY: soft reboot\n");
+        gc_sweep_all();
+        mp_deinit();
+    }
+}
+
+void gc_collect(void) {
+    gc_collect_start();
+    gc_helper_collect_regs_and_stack();
+    gc_collect_end();
+}
+
+mp_lexer_t *mp_lexer_new_from_file(const char *filename) {
+    mp_raise_OSError(MP_ENOENT);
+}
+
+mp_import_stat_t mp_import_stat(const char *path) {
+    return MP_IMPORT_STAT_NO_EXIST;
+}
+
+mp_obj_t mp_builtin_open(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
+
+void nlr_jump_fail(void *val) {
+    for (;;) {
+    }
+}
+
+#ifndef NDEBUG
+void MP_WEAK __assert_func(const char *file, int line, const char *func, const char *expr) {
+    mp_printf(MP_PYTHON_PRINTER, "Assertion '%s' failed, at file %s:%d\n", expr, file, line);
+    for (;;) {
+    }
+}
+#endif
diff --git a/ports/samd/modmachine.c b/ports/samd/modmachine.c
new file mode 100644
index 0000000000000..207e4c71ca1a6
--- /dev/null
+++ b/ports/samd/modmachine.c
@@ -0,0 +1,72 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "extmod/machine_mem.h"
+#include "samd_soc.h"
+
+#if defined(MCU_SAMD21)
+#define DBL_TAP_ADDR ((volatile uint32_t *)(0x20000000 + 32 * 1024 - 4))
+#elif defined(MCU_SAMD51)
+#define DBL_TAP_ADDR ((volatile uint32_t *)(0x20000000 + 192 * 1024 - 4))
+#endif
+#define DBL_TAP_MAGIC_LOADER 0xf01669ef
+#define DBL_TAP_MAGIC_RESET 0xf02669ef
+
+STATIC mp_obj_t machine_reset(void) {
+    *DBL_TAP_ADDR = DBL_TAP_MAGIC_RESET;
+    NVIC_SystemReset();
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_0(machine_reset_obj, machine_reset);
+
+STATIC mp_obj_t machine_bootloader(void) {
+    *DBL_TAP_ADDR = DBL_TAP_MAGIC_LOADER;
+    NVIC_SystemReset();
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_0(machine_bootloader_obj, machine_bootloader);
+
+STATIC mp_obj_t machine_freq(void) {
+    return MP_OBJ_NEW_SMALL_INT(CPU_FREQ);
+}
+MP_DEFINE_CONST_FUN_OBJ_0(machine_freq_obj, machine_freq);
+
+STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__),            MP_ROM_QSTR(MP_QSTR_umachine) },
+    { MP_ROM_QSTR(MP_QSTR_reset),               MP_ROM_PTR(&machine_reset_obj) },
+    { MP_ROM_QSTR(MP_QSTR_bootloader),          MP_ROM_PTR(&machine_bootloader_obj) },
+    { MP_ROM_QSTR(MP_QSTR_freq),                MP_ROM_PTR(&machine_freq_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mem8),                MP_ROM_PTR(&machine_mem8_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mem16),               MP_ROM_PTR(&machine_mem16_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mem32),               MP_ROM_PTR(&machine_mem32_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(machine_module_globals, machine_module_globals_table);
+
+const mp_obj_module_t mp_module_machine = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&machine_module_globals,
+};
diff --git a/ports/samd/modutime.c b/ports/samd/modutime.c
new file mode 100644
index 0000000000000..8d6a4059446f6
--- /dev/null
+++ b/ports/samd/modutime.c
@@ -0,0 +1,47 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "extmod/utime_mphal.h"
+
+STATIC const mp_rom_map_elem_t time_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_utime) },
+
+    { MP_ROM_QSTR(MP_QSTR_sleep), MP_ROM_PTR(&mp_utime_sleep_obj) },
+    { MP_ROM_QSTR(MP_QSTR_sleep_ms), MP_ROM_PTR(&mp_utime_sleep_ms_obj) },
+    { MP_ROM_QSTR(MP_QSTR_sleep_us), MP_ROM_PTR(&mp_utime_sleep_us_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ticks_ms), MP_ROM_PTR(&mp_utime_ticks_ms_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ticks_us), MP_ROM_PTR(&mp_utime_ticks_us_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ticks_cpu), MP_ROM_PTR(&mp_utime_ticks_cpu_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ticks_add), MP_ROM_PTR(&mp_utime_ticks_add_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ticks_diff), MP_ROM_PTR(&mp_utime_ticks_diff_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(time_module_globals, time_module_globals_table);
+
+const mp_obj_module_t mp_module_utime = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&time_module_globals,
+};
diff --git a/ports/samd/mpconfigport.h b/ports/samd/mpconfigport.h
new file mode 100644
index 0000000000000..ffb30bf5e2188
--- /dev/null
+++ b/ports/samd/mpconfigport.h
@@ -0,0 +1,109 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// Options controlling how MicroPython is built, overriding defaults in py/mpconfig.h
+
+// Board specific definitions
+#include "mpconfigboard.h"
+
+// Memory allocation policies
+#define MICROPY_GC_STACK_ENTRY_TYPE         uint16_t
+#define MICROPY_GC_ALLOC_THRESHOLD          (0)
+#define MICROPY_ALLOC_PARSE_CHUNK_INIT      (32)
+#define MICROPY_ALLOC_PATH_MAX              (256)
+#define MICROPY_QSTR_BYTES_IN_HASH          (1)
+
+// Compiler configuration
+#define MICROPY_COMP_CONST                  (0)
+
+// Python internal features
+#define MICROPY_ENABLE_GC                   (1)
+#define MICROPY_KBD_EXCEPTION               (1)
+#define MICROPY_HELPER_REPL                 (1)
+#define MICROPY_LONGINT_IMPL                (MICROPY_LONGINT_IMPL_MPZ)
+#define MICROPY_ENABLE_SOURCE_LINE          (1)
+#define MICROPY_ERROR_REPORTING             (MICROPY_ERROR_REPORTING_TERSE)
+#define MICROPY_CPYTHON_COMPAT              (0)
+#define MICROPY_CAN_OVERRIDE_BUILTINS       (1)
+
+// Control over Python builtins
+#define MICROPY_PY_ASYNC_AWAIT              (0)
+#define MICROPY_PY_BUILTINS_STR_COUNT       (0)
+#define MICROPY_PY_BUILTINS_MEMORYVIEW      (1)
+#define MICROPY_PY_BUILTINS_SET             (0)
+#define MICROPY_PY_BUILTINS_FROZENSET       (0)
+#define MICROPY_PY_BUILTINS_PROPERTY        (0)
+#define MICROPY_PY_BUILTINS_ENUMERATE       (0)
+#define MICROPY_PY_BUILTINS_FILTER          (0)
+#define MICROPY_PY_BUILTINS_REVERSED        (0)
+#define MICROPY_PY_BUILTINS_MIN_MAX         (0)
+#define MICROPY_PY___FILE__                 (0)
+#define MICROPY_PY_MICROPYTHON_MEM_INFO     (1)
+#define MICROPY_PY_ARRAY_SLICE_ASSIGN       (1)
+#define MICROPY_PY_ATTRTUPLE                (0)
+#define MICROPY_PY_COLLECTIONS              (0)
+#define MICROPY_PY_SYS_MAXSIZE              (1)
+
+// Extended modules
+#define MICROPY_PY_UTIME_MP_HAL             (1)
+#define MICROPY_PY_MACHINE                  (1)
+
+// Hooks to add builtins
+
+#define MICROPY_PORT_BUILTINS \
+    { MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&mp_builtin_open_obj) },
+
+extern const struct _mp_obj_module_t mp_module_machine;
+extern const struct _mp_obj_module_t mp_module_utime;
+
+#define MICROPY_PORT_BUILTIN_MODULES \
+    { MP_ROM_QSTR(MP_QSTR_machine), MP_ROM_PTR(&mp_module_machine) }, \
+    { MP_ROM_QSTR(MP_QSTR_utime), MP_ROM_PTR(&mp_module_utime) }, \
+
+#define MICROPY_PORT_ROOT_POINTERS \
+    const char *readline_hist[8];
+
+#define MP_STATE_PORT MP_STATE_VM
+
+// Miscellaneous settings
+
+#define MICROPY_EVENT_POLL_HOOK \
+    do { \
+        extern void mp_handle_pending(bool); \
+        mp_handle_pending(true); \
+        __WFI(); \
+    } while (0);
+
+#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)((mp_uint_t)(p) | 1))
+#define MP_PLAT_PRINT_STRN(str, len) mp_hal_stdout_tx_strn_cooked(str, len)
+
+#define MP_SSIZE_MAX (0x7fffffff)
+typedef int mp_int_t; // must be pointer size
+typedef unsigned mp_uint_t; // must be pointer size
+typedef long mp_off_t;
+
+// Need to provide a declaration/definition of alloca()
+#include <alloca.h>
diff --git a/ports/samd/mphalport.c b/ports/samd/mphalport.c
new file mode 100644
index 0000000000000..67fc2cb0d6f17
--- /dev/null
+++ b/ports/samd/mphalport.c
@@ -0,0 +1,100 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "samd_soc.h"
+#include "tusb.h"
+
+#if MICROPY_KBD_EXCEPTION
+
+void tud_cdc_rx_wanted_cb(uint8_t itf, char wanted_char) {
+    (void)itf;
+    (void)wanted_char;
+    tud_cdc_read_char(); // discard interrupt char
+    mp_keyboard_interrupt();
+}
+
+void mp_hal_set_interrupt_char(int c) {
+    tud_cdc_set_wanted_char(c);
+}
+
+#endif
+
+void mp_hal_delay_ms(mp_uint_t ms) {
+    ms += 1;
+    uint32_t t0 = systick_ms;
+    while (systick_ms - t0 < ms) {
+        MICROPY_EVENT_POLL_HOOK
+    }
+}
+
+void mp_hal_delay_us(mp_uint_t us) {
+    uint32_t ms = us / 1000 + 1;
+    uint32_t t0 = systick_ms;
+    while (systick_ms - t0 < ms) {
+        __WFI();
+    }
+}
+
+int mp_hal_stdin_rx_chr(void) {
+    for (;;) {
+        if (USARTx->USART.INTFLAG.bit.RXC) {
+            return USARTx->USART.DATA.bit.DATA;
+        }
+        if (tud_cdc_connected() && tud_cdc_available()) {
+            uint8_t buf[1];
+            uint32_t count = tud_cdc_read(buf, sizeof(buf));
+            if (count) {
+                return buf[0];
+            }
+        }
+        __WFI();
+    }
+}
+
+void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) {
+    if (tud_cdc_connected()) {
+        for (size_t i = 0; i < len;) {
+            uint32_t n = len - i;
+            uint32_t n2 = tud_cdc_write(str + i, n);
+            if (n2 < n) {
+                while (!tud_cdc_write_flush()) {
+                    __WFI();
+                }
+            }
+            i += n2;
+        }
+        while (!tud_cdc_write_flush()) {
+            __WFI();
+        }
+    }
+    while (len--) {
+        while (!(USARTx->USART.INTFLAG.bit.DRE)) {
+        }
+        USARTx->USART.DATA.bit.DATA = *str++;
+    }
+}
diff --git a/ports/samd/mphalport.h b/ports/samd/mphalport.h
new file mode 100644
index 0000000000000..fc7dbe94cbc89
--- /dev/null
+++ b/ports/samd/mphalport.h
@@ -0,0 +1,45 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_SAMD_MPHALPORT_H
+#define MICROPY_INCLUDED_SAMD_MPHALPORT_H
+
+#include <stdint.h>
+
+extern volatile uint32_t systick_ms;
+
+void mp_hal_set_interrupt_char(int c);
+
+static inline mp_uint_t mp_hal_ticks_ms(void) {
+    return systick_ms;
+}
+static inline mp_uint_t mp_hal_ticks_us(void) {
+    return systick_ms * 1000;
+}
+static inline mp_uint_t mp_hal_ticks_cpu(void) {
+    return 0;
+}
+
+#endif // MICROPY_INCLUDED_SAMD_MPHALPORT_H
diff --git a/ports/samd/qstrdefsport.h b/ports/samd/qstrdefsport.h
new file mode 100644
index 0000000000000..00d3e2ae3c555
--- /dev/null
+++ b/ports/samd/qstrdefsport.h
@@ -0,0 +1,2 @@
+// qstrs specific to this port
+// *FORMAT-OFF*
diff --git a/ports/samd/samd_isr.c b/ports/samd/samd_isr.c
new file mode 100644
index 0000000000000..dcf80d28cab0c
--- /dev/null
+++ b/ports/samd/samd_isr.c
@@ -0,0 +1,252 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "samd_soc.h"
+
+typedef void (*ISR)(void);
+
+extern uint32_t _estack, _sidata, _sdata, _edata, _sbss, _ebss;
+
+const ISR isr_vector[];
+uint32_t systick_ms;
+
+void Reset_Handler(void) __attribute__((naked));
+void Reset_Handler(void) {
+    // Set stack pointer
+    #if __CORTEX_M >= 0x03
+    __asm volatile ("ldr sp, =_estack");
+    #else
+    __asm volatile ("ldr r0, =_estack");
+    __asm volatile ("mov sp, r0");
+    #endif
+    // Copy .data section from flash to RAM
+    for (uint32_t *src = &_sidata, *dest = &_sdata; dest < &_edata;) {
+        *dest++ = *src++;
+    }
+    // Zero out .bss section
+    for (uint32_t *dest = &_sbss; dest < &_ebss;) {
+        *dest++ = 0;
+    }
+
+    // When we get here: stack is initialised, bss is clear, data is copied
+
+    #if __FPU_PRESENT == 1 && __FPU_USED == 1
+    // Set CP10 and CP11 Full Access
+    SCB->CPACR |= (3UL << 10 * 2) | (3UL << 11 * 2);
+    #endif
+
+    // SCB->VTOR
+    *((volatile uint32_t *)0xe000ed08) = (uint32_t)&isr_vector;
+
+    // SCB->CCR: enable 8-byte stack alignment for IRQ handlers, in accord with EABI
+    *((volatile uint32_t *)0xe000ed14) |= 1 << 9;
+
+    // Initialise the cpu and peripherals
+    samd_init();
+
+    // Now that we have a basic system up and running we can call main
+    samd_main();
+
+    // we must not return
+    for (;;) {
+    }
+}
+
+void Default_Handler(void) {
+    for (;;) {
+    }
+}
+
+void SysTick_Handler(void) {
+    systick_ms += 1;
+}
+
+const ISR isr_vector[] __attribute__((section(".isr_vector"))) = {
+    (ISR)&_estack,
+    &Reset_Handler,
+    &Default_Handler, // NMI_Handler
+    &Default_Handler, // HardFault_Handler
+    &Default_Handler, // MemManage_Handler
+    &Default_Handler, // BusFault_Handler
+    &Default_Handler, // UsageFault_Handler
+    0,
+    0,
+    0,
+    0,
+    &Default_Handler, // SVC_Handler
+    &Default_Handler, // DebugMon_Handler
+    0,
+    &Default_Handler, // PendSV_Handler
+    &SysTick_Handler, // SysTick_Handler
+    0, // line 0
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    #if defined(MCU_SAMD21)
+    USB_Handler_wrapper, // line 7
+    #else
+    0,
+    #endif
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    #if defined(MCU_SAMD51)
+    &USB_0_Handler_wrapper, // line 80
+    &USB_1_Handler_wrapper,
+    &USB_2_Handler_wrapper,
+    &USB_3_Handler_wrapper,
+    #else
+    0,
+    0,
+    0,
+    0,
+    #endif
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+};
diff --git a/ports/samd/samd_soc.c b/ports/samd/samd_soc.c
new file mode 100644
index 0000000000000..a08d0de26900b
--- /dev/null
+++ b/ports/samd/samd_soc.c
@@ -0,0 +1,162 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "samd_soc.h"
+#include "tusb.h"
+
+static void uart0_init(void) {
+    #if defined(MCU_SAMD21)
+
+    // SERCOM0, TX=PA06=PAD2, RX=PA07=PAD3, ALT-D
+    PORT->Group[0].PMUX[3].reg = 0x33;
+    PORT->Group[0].PINCFG[6].reg = 1;
+    PORT->Group[0].PINCFG[7].reg = 1;
+
+    PM->APBCMASK.bit.SERCOM0_ = 1;
+    GCLK->CLKCTRL.reg = GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN_GCLK0 | GCLK_CLKCTRL_ID_SERCOM0_CORE;
+    while (GCLK->STATUS.bit.SYNCBUSY) {
+    }
+
+    uint32_t rxpo = 3;
+    uint32_t txpo = 1;
+
+    #elif defined(MCU_SAMD51)
+
+    // SERCOM3, TX=PA17=PAD0, RX=PA16=PAD1, ALT-D
+    PORT->Group[0].PMUX[8].reg = 0x33;
+    PORT->Group[0].PINCFG[16].reg = 1;
+    PORT->Group[0].PINCFG[17].reg = 1;
+
+    // Use Generator 0 which is already enabled and switched to DFLL @ 48MHz
+    GCLK->PCHCTRL[SERCOM3_GCLK_ID_CORE].reg = GCLK_PCHCTRL_CHEN | GCLK_PCHCTRL_GEN_GCLK0;
+    MCLK->APBBMASK.bit.SERCOM3_ = 1;
+
+    uint32_t rxpo = 1;
+    uint32_t txpo = 2;
+
+    #endif
+
+    while (USARTx->USART.SYNCBUSY.bit.SWRST) {
+    }
+    USARTx->USART.CTRLA.bit.SWRST = 1;
+    while (USARTx->USART.SYNCBUSY.bit.SWRST) {
+    }
+
+    USARTx->USART.CTRLA.reg =
+        SERCOM_USART_CTRLA_DORD
+        | SERCOM_USART_CTRLA_RXPO(rxpo)
+        | SERCOM_USART_CTRLA_TXPO(txpo)
+        | SERCOM_USART_CTRLA_MODE(1)
+    ;
+    USARTx->USART.CTRLB.reg = SERCOM_USART_CTRLB_RXEN | SERCOM_USART_CTRLB_TXEN;
+    while (USARTx->USART.SYNCBUSY.bit.CTRLB) {
+    }
+    #if CPU_FREQ == 8000000
+    uint32_t baud = 50437; // 115200 baud; 65536*(1 - 16 * 115200/8e6)
+    #elif CPU_FREQ == 48000000
+    uint32_t baud = 63019; // 115200 baud; 65536*(1 - 16 * 115200/48e6)
+    #elif CPU_FREQ == 120000000
+    uint32_t baud = 64529; // 115200 baud; 65536*(1 - 16 * 115200/120e6)
+    #endif
+    USARTx->USART.BAUD.bit.BAUD = baud;
+    USARTx->USART.CTRLA.bit.ENABLE = 1;
+    while (USARTx->USART.SYNCBUSY.bit.ENABLE) {
+    }
+}
+
+static void usb_init(void) {
+    // Init USB clock
+    #if defined(MCU_SAMD21)
+    GCLK->CLKCTRL.reg = GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN_GCLK0 | GCLK_CLKCTRL_ID_USB;
+    PM->AHBMASK.bit.USB_ = 1;
+    PM->APBBMASK.bit.USB_ = 1;
+    uint8_t alt = 6; // alt G, USB
+    #elif defined(MCU_SAMD51)
+    GCLK->PCHCTRL[USB_GCLK_ID].reg = GCLK_PCHCTRL_CHEN | GCLK_PCHCTRL_GEN_GCLK1;
+    while (GCLK->PCHCTRL[USB_GCLK_ID].bit.CHEN == 0) {
+    }
+    MCLK->AHBMASK.bit.USB_ = 1;
+    MCLK->APBBMASK.bit.USB_ = 1;
+    uint8_t alt = 7; // alt H, USB
+    #endif
+
+    // Init USB pins
+    PORT->Group[0].DIRSET.reg = 1 << 25 | 1 << 24;
+    PORT->Group[0].OUTCLR.reg = 1 << 25 | 1 << 24;
+    PORT->Group[0].PMUX[12].reg = alt << 4 | alt;
+    PORT->Group[0].PINCFG[24].reg = PORT_PINCFG_PMUXEN;
+    PORT->Group[0].PINCFG[25].reg = PORT_PINCFG_PMUXEN;
+
+    tusb_init();
+}
+
+void samd_init(void) {
+    #if defined(MCU_SAMD21)
+
+    NVMCTRL->CTRLB.bit.MANW = 1; // errata "Spurious Writes"
+    NVMCTRL->CTRLB.bit.RWS = 1; // 1 read wait state for 48MHz
+
+    // Enable DFLL48M
+    SYSCTRL->DFLLCTRL.reg = SYSCTRL_DFLLCTRL_ENABLE;
+    while (!SYSCTRL->PCLKSR.bit.DFLLRDY) {
+    }
+    SYSCTRL->DFLLMUL.reg = SYSCTRL_DFLLMUL_CSTEP(1) | SYSCTRL_DFLLMUL_FSTEP(1)
+        | SYSCTRL_DFLLMUL_MUL(48000);
+    uint32_t coarse = (*((uint32_t *)FUSES_DFLL48M_COARSE_CAL_ADDR) & FUSES_DFLL48M_COARSE_CAL_Msk)
+        >> FUSES_DFLL48M_COARSE_CAL_Pos;
+    if (coarse == 0x3f) {
+        coarse = 0x1f;
+    }
+    uint32_t fine = 512;
+    SYSCTRL->DFLLVAL.reg = SYSCTRL_DFLLVAL_COARSE(coarse) | SYSCTRL_DFLLVAL_FINE(fine);
+    SYSCTRL->DFLLCTRL.reg = SYSCTRL_DFLLCTRL_CCDIS | SYSCTRL_DFLLCTRL_USBCRM
+        | SYSCTRL_DFLLCTRL_MODE | SYSCTRL_DFLLCTRL_ENABLE;
+    while (!SYSCTRL->PCLKSR.bit.DFLLRDY) {
+    }
+
+    GCLK->GENDIV.reg = GCLK_GENDIV_ID(0) | GCLK_GENDIV_DIV(1);
+    GCLK->GENCTRL.reg = GCLK_GENCTRL_GENEN | GCLK_GENCTRL_SRC_DFLL48M | GCLK_GENCTRL_ID(0);
+    while (GCLK->STATUS.bit.SYNCBUSY) {
+    }
+
+    // Configure PA10 as output for LED
+    PORT->Group[0].DIRSET.reg = 1 << 10;
+
+    #elif defined(MCU_SAMD51)
+
+    GCLK->GENCTRL[1].reg = 1 << GCLK_GENCTRL_DIV_Pos | GCLK_GENCTRL_GENEN | GCLK_GENCTRL_SRC_DFLL;
+    while (GCLK->SYNCBUSY.bit.GENCTRL1) {
+    }
+
+    // Configure PA22 as output for LED
+    PORT->Group[0].DIRSET.reg = 1 << 22;
+
+    #endif
+
+    SysTick_Config(CPU_FREQ / 1000);
+    uart0_init();
+    usb_init();
+}
diff --git a/ports/cc3200/misc/mpexception.c b/ports/samd/samd_soc.h
similarity index 69%
rename from ports/cc3200/misc/mpexception.c
rename to ports/samd/samd_soc.h
index 72d4a155fafc4..5f68610e4d0a3 100644
--- a/ports/cc3200/misc/mpexception.c
+++ b/ports/samd/samd_soc.h
@@ -3,8 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
- * Copyright (c) 2015 Daniel Campora
+ * Copyright (c) 2019 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,16 +23,31 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+#ifndef MICROPY_INCLUDED_SAMD_SAMD_SOC_H
+#define MICROPY_INCLUDED_SAMD_SAMD_SOC_H
 
 #include <stdint.h>
-#include <string.h>
+#include "sam.h"
 
-#include "mpexception.h"
+#if defined(MCU_SAMD21)
 
+#define CPU_FREQ (48000000)
+#define USARTx SERCOM0
 
-/******************************************************************************
-DECLARE EXPORTED DATA
- ******************************************************************************/
-const char mpexception_value_invalid_arguments[]    = "invalid argument(s) value";
-const char mpexception_num_type_invalid_arguments[] = "invalid argument(s) num/type";
-const char mpexception_uncaught[]                   = "uncaught exception";
+#elif defined(MCU_SAMD51)
+
+#define CPU_FREQ (48000000)
+#define USARTx SERCOM3
+
+#endif
+
+void samd_init(void);
+void samd_main(void);
+
+void USB_Handler_wrapper(void);
+void USB_0_Handler_wrapper(void);
+void USB_1_Handler_wrapper(void);
+void USB_2_Handler_wrapper(void);
+void USB_3_Handler_wrapper(void);
+
+#endif // MICROPY_INCLUDED_SAMD_SAMD_SOC_H
diff --git a/ports/samd/sections.ld b/ports/samd/sections.ld
new file mode 100644
index 0000000000000..cbcad463d0580
--- /dev/null
+++ b/ports/samd/sections.ld
@@ -0,0 +1,37 @@
+/* Define output sections */
+SECTIONS
+{
+    .text :
+    {
+        . = ALIGN(4);
+        KEEP(*(.isr_vector))
+        *(.text)
+        *(.text*)
+        *(.rodata)
+        *(.rodata*)
+        . = ALIGN(4);
+        _etext = .;
+        _sidata = _etext;
+    } >FLASH
+
+    .data : AT ( _sidata )
+    {
+        . = ALIGN(4);
+        _sdata = .;
+        *(.data)
+        *(.data*)
+        . = ALIGN(4);
+        _edata = .;
+    } >RAM
+
+    .bss :
+    {
+        . = ALIGN(4);
+        _sbss = .;
+        *(.bss)
+        *(.bss*)
+        *(COMMON)
+        . = ALIGN(4);
+        _ebss = .;
+    } >RAM
+}
diff --git a/ports/samd/tusb_config.h b/ports/samd/tusb_config.h
new file mode 100644
index 0000000000000..07fa680cbbb6b
--- /dev/null
+++ b/ports/samd/tusb_config.h
@@ -0,0 +1,47 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_SAMD_TUSB_CONFIG_H
+#define MICROPY_INCLUDED_SAMD_TUSB_CONFIG_H
+
+// Common configuration
+
+#if defined(MCU_SAMD21)
+#define CFG_TUSB_MCU                OPT_MCU_SAMD21
+#elif defined(MCU_SAMD51)
+#define CFG_TUSB_MCU                OPT_MCU_SAMD51
+#endif
+#define CFG_TUSB_RHPORT0_MODE       OPT_MODE_DEVICE
+#define CFG_TUSB_MEM_SECTION
+#define CFG_TUSB_MEM_ALIGN          TU_ATTR_ALIGNED(4)
+
+// Device configuration
+
+#define CFG_TUD_ENDOINT0_SIZE       (64)
+#define CFG_TUD_CDC                 (1)
+#define CFG_TUD_CDC_RX_BUFSIZE      (64)
+#define CFG_TUD_CDC_TX_BUFSIZE      (64)
+
+#endif // MICROPY_INCLUDED_SAMD_TUSB_CONFIG_H
diff --git a/ports/samd/tusb_port.c b/ports/samd/tusb_port.c
new file mode 100644
index 0000000000000..019e3a891c262
--- /dev/null
+++ b/ports/samd/tusb_port.c
@@ -0,0 +1,146 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "samd_soc.h"
+#include "tusb.h"
+
+#define USBD_VID (0xf055)
+#define USBD_PID (0x9802)
+
+#define USBD_DESC_LEN (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN)
+#define USBD_MAX_POWER_MA (250)
+
+#define USBD_ITF_CDC (0) // needs 2 interfaces
+#define USBD_ITF_MAX (2)
+
+#define USBD_CDC_EP_CMD (0x81)
+#define USBD_CDC_EP_OUT (0x02)
+#define USBD_CDC_EP_IN (0x82)
+#define USBD_CDC_CMD_MAX_SIZE (8)
+
+#define USBD_STR_0 (0x00)
+#define USBD_STR_MANUF (0x01)
+#define USBD_STR_PRODUCT (0x02)
+#define USBD_STR_SERIAL (0x03)
+#define USBD_STR_CDC (0x04)
+
+// Note: descriptors returned from callbacks must exist long enough for transfer to complete
+
+static const tusb_desc_device_t usbd_desc_device = {
+    .bLength = sizeof(tusb_desc_device_t),
+    .bDescriptorType = TUSB_DESC_DEVICE,
+    .bcdUSB = 0x0200,
+    .bDeviceClass = TUSB_CLASS_MISC,
+    .bDeviceSubClass = MISC_SUBCLASS_COMMON,
+    .bDeviceProtocol = MISC_PROTOCOL_IAD,
+    .bMaxPacketSize0 = CFG_TUD_ENDOINT0_SIZE,
+    .idVendor = USBD_VID,
+    .idProduct = USBD_PID,
+    .bcdDevice = 0x0100,
+    .iManufacturer = USBD_STR_MANUF,
+    .iProduct = USBD_STR_PRODUCT,
+    .iSerialNumber = USBD_STR_SERIAL,
+    .bNumConfigurations = 1,
+};
+
+static const uint8_t usbd_desc_cfg[USBD_DESC_LEN] = {
+    TUD_CONFIG_DESCRIPTOR(USBD_ITF_MAX, USBD_STR_0, USBD_DESC_LEN,
+        TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, USBD_MAX_POWER_MA),
+
+    TUD_CDC_DESCRIPTOR(USBD_ITF_CDC, USBD_STR_CDC, USBD_CDC_EP_CMD,
+        USBD_CDC_CMD_MAX_SIZE, USBD_CDC_EP_OUT, USBD_CDC_EP_IN, CFG_TUD_CDC_RX_BUFSIZE),
+};
+
+static const char *const usbd_desc_str[] = {
+    [USBD_STR_MANUF] = "MicroPython",
+    [USBD_STR_PRODUCT] = "Board in FS mode",
+    [USBD_STR_SERIAL] = "000000000000", // TODO
+    [USBD_STR_CDC] = "Board CDC",
+};
+
+const uint8_t *tud_descriptor_device_cb(void) {
+    return (const uint8_t *)&usbd_desc_device;
+}
+
+const uint8_t *tud_descriptor_configuration_cb(uint8_t index) {
+    (void)index;
+    return usbd_desc_cfg;
+}
+
+const uint16_t *tud_descriptor_string_cb(uint8_t index) {
+    #define DESC_STR_MAX (20)
+    static uint16_t desc_str[DESC_STR_MAX];
+
+    uint8_t len;
+    if (index == 0) {
+        desc_str[1] = 0x0409; // supported language is English
+        len = 1;
+    } else {
+        if (index >= sizeof(usbd_desc_str) / sizeof(usbd_desc_str[0])) {
+            return NULL;
+        }
+        const char *str = usbd_desc_str[index];
+        for (len = 0; len < DESC_STR_MAX - 1 && str[len]; ++len) {
+            desc_str[1 + len] = str[len];
+        }
+    }
+
+    // first byte is length (including header), second byte is string type
+    desc_str[0] = (TUSB_DESC_STRING << 8) | (2 * len + 2);
+
+    return desc_str;
+}
+
+#if defined(MCU_SAMD21)
+
+void USB_Handler_wrapper(void) {
+    USB_Handler();
+    tud_task();
+}
+
+#elif defined(MCU_SAMD51)
+
+void USB_0_Handler_wrapper(void) {
+    USB_0_Handler();
+    tud_task();
+}
+
+void USB_1_Handler_wrapper(void) {
+    USB_1_Handler();
+    tud_task();
+}
+
+void USB_2_Handler_wrapper(void) {
+    USB_2_Handler();
+    tud_task();
+}
+
+void USB_3_Handler_wrapper(void) {
+    USB_3_Handler();
+    tud_task();
+}
+
+#endif
diff --git a/ports/stm32/.gitignore b/ports/stm32/.gitignore
deleted file mode 100644
index 414487d53eb83..0000000000000
--- a/ports/stm32/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-build-*/
diff --git a/ports/stm32/Makefile b/ports/stm32/Makefile
index 242ced38cb4d4..fdea95e92f5c9 100644
--- a/ports/stm32/Makefile
+++ b/ports/stm32/Makefile
@@ -14,33 +14,44 @@ include ../../py/mkenv.mk
 -include mpconfigport.mk
 include $(BOARD_DIR)/mpconfigboard.mk
 
+# Files that are generated and needed before the QSTR build.
+QSTR_GENERATED_HEADERS = $(BUILD)/pins_qstr.h $(BUILD)/modstm_qstr.h
+
 # qstr definitions (must come before including py.mk)
-QSTR_DEFS = qstrdefsport.h $(BUILD)/pins_qstr.h $(BUILD)/modstm_qstr.h
-QSTR_GLOBAL_DEPENDENCIES = mpconfigboard_common.h $(BOARD_DIR)/mpconfigboard.h
+QSTR_DEFS = qstrdefsport.h $(QSTR_GENERATED_HEADERS)
+QSTR_GLOBAL_DEPENDENCIES = mpconfigboard_common.h $(BOARD_DIR)/mpconfigboard.h $(QSTR_GENERATED_HEADERS)
+
+# MicroPython feature configurations
+MICROPY_ROM_TEXT_COMPRESSION ?= 1
 
-# directory containing scripts to be frozen as bytecode
-FROZEN_MPY_DIR ?= modules
+# File containing description of content to be frozen into firmware.
+FROZEN_MANIFEST ?= boards/manifest.py
 
 # include py core make definitions
 include $(TOP)/py/py.mk
 
+GIT_SUBMODULES = lib/lwip lib/mbedtls lib/mynewt-nimble lib/stm32lib
+
+MCU_SERIES_UPPER = $(shell echo $(MCU_SERIES) | tr '[:lower:]' '[:upper:]')
+CMSIS_MCU_LOWER = $(shell echo $(CMSIS_MCU) | tr '[:upper:]' '[:lower:]')
+
 LD_DIR=boards
 CMSIS_DIR=$(TOP)/lib/stm32lib/CMSIS/STM32$(MCU_SERIES_UPPER)xx/Include
-MCU_SERIES_UPPER = $(shell echo $(MCU_SERIES) | tr '[:lower:]' '[:upper:]')
 HAL_DIR=lib/stm32lib/STM32$(MCU_SERIES_UPPER)xx_HAL_Driver
 USBDEV_DIR=usbdev
 #USBHOST_DIR=usbhost
-FATFS_DIR=lib/oofatfs
 DFU=$(TOP)/tools/dfu.py
 # may need to prefix dfu-util with sudo
 USE_PYDFU ?= 1
 PYDFU ?= $(TOP)/tools/pydfu.py
 DFU_UTIL ?= dfu-util
-DEVICE=0483:df11
+BOOTLOADER_DFU_USB_VID ?= 0x0483
+BOOTLOADER_DFU_USB_PID ?= 0xDF11
 STFLASH ?= st-flash
 OPENOCD ?= openocd
 OPENOCD_CONFIG ?= boards/openocd_stm32f4.cfg
-STARTUP_FILE ?= boards/startup_stm32$(MCU_SERIES).o
+STARTUP_FILE ?= lib/stm32lib/CMSIS/STM32$(MCU_SERIES_UPPER)xx/Source/Templates/gcc/startup_$(CMSIS_MCU_LOWER).o
+SYSTEM_FILE ?= lib/stm32lib/CMSIS/STM32$(MCU_SERIES_UPPER)xx/Source/Templates/system_stm32$(MCU_SERIES)xx.o
 
 # Select the cross compile prefix
 CROSS_COMPILE ?= arm-none-eabi-
@@ -59,13 +70,18 @@ INC += -Ilwip_inc
 CFLAGS_CORTEX_M = -mthumb
 
 # Select hardware floating-point support
+SUPPORTS_HARDWARE_FP_SINGLE = 0
+SUPPORTS_HARDWARE_FP_DOUBLE = 0
 ifeq ($(CMSIS_MCU),$(filter $(CMSIS_MCU),STM32F765xx STM32F767xx STM32F769xx STM32H743xx))
 CFLAGS_CORTEX_M += -mfpu=fpv5-d16 -mfloat-abi=hard
+SUPPORTS_HARDWARE_FP_SINGLE = 1
+SUPPORTS_HARDWARE_FP_DOUBLE = 1
 else
-ifeq ($(MCU_SERIES),f0)
+ifeq ($(MCU_SERIES),$(filter $(MCU_SERIES),f0 l0))
 CFLAGS_CORTEX_M += -msoft-float
 else
 CFLAGS_CORTEX_M += -mfpu=fpv4-sp-d16 -mfloat-abi=hard
+SUPPORTS_HARDWARE_FP_SINGLE = 1
 endif
 endif
 
@@ -73,10 +89,12 @@ endif
 CFLAGS_MCU_f0 = $(CFLAGS_CORTEX_M) -mtune=cortex-m0 -mcpu=cortex-m0
 CFLAGS_MCU_f4 = $(CFLAGS_CORTEX_M) -mtune=cortex-m4 -mcpu=cortex-m4
 CFLAGS_MCU_f7 = $(CFLAGS_CORTEX_M) -mtune=cortex-m7 -mcpu=cortex-m7
+CFLAGS_MCU_l0 = $(CFLAGS_CORTEX_M) -mtune=cortex-m0plus -mcpu=cortex-m0plus
 CFLAGS_MCU_l4 = $(CFLAGS_CORTEX_M) -mtune=cortex-m4 -mcpu=cortex-m4
 CFLAGS_MCU_h7 = $(CFLAGS_CORTEX_M) -mtune=cortex-m7 -mcpu=cortex-m7
+CFLAGS_MCU_wb = $(CFLAGS_CORTEX_M) -mtune=cortex-m4 -mcpu=cortex-m4
 
-CFLAGS = $(INC) -Wall -Wpointer-arith -Werror -std=gnu99 -nostdlib $(CFLAGS_MOD) $(CFLAGS_EXTRA)
+CFLAGS += $(INC) -Wall -Wpointer-arith -Werror -Wdouble-promotion -Wfloat-conversion -std=gnu99 -nostdlib $(CFLAGS_MOD) $(CFLAGS_EXTRA)
 CFLAGS += -D$(CMSIS_MCU)
 CFLAGS += $(CFLAGS_MCU_$(MCU_SERIES))
 CFLAGS += $(COPT)
@@ -84,14 +102,28 @@ CFLAGS += -I$(BOARD_DIR)
 CFLAGS += -DSTM32_HAL_H='<stm32$(MCU_SERIES)xx_hal.h>'
 CFLAGS += -DMICROPY_HW_VTOR=$(TEXT0_ADDR)
 
+# Configure for nan-boxing object model if requested
+ifeq ($(NANBOX),1)
+CFLAGS += -DMP_CONFIGFILE='"mpconfigport_nanbox.h"'
+ifneq ($(MICROPY_FLOAT_IMPL),none)
+MICROPY_FLOAT_IMPL = double
+endif
+endif
+
+# Configure floating point support
 ifeq ($(MICROPY_FLOAT_IMPL),double)
 CFLAGS += -DMICROPY_FLOAT_IMPL=MICROPY_FLOAT_IMPL_DOUBLE
 else
+ifeq ($(MICROPY_FLOAT_IMPL),none)
+CFLAGS += -DMICROPY_FLOAT_IMPL=MICROPY_FLOAT_IMPL_NONE
+else
 CFLAGS += -DMICROPY_FLOAT_IMPL=MICROPY_FLOAT_IMPL_FLOAT
-CFLAGS += -fsingle-precision-constant -Wdouble-promotion
+CFLAGS += -fsingle-precision-constant
+endif
 endif
 
 LDFLAGS = -nostdlib -L $(LD_DIR) $(addprefix -T,$(LD_FILES)) -Map=$(@:.elf=.map) --cref
+LDFLAGS += --defsym=_estack_reserve=8
 LIBS = $(shell $(CC) $(CFLAGS) -print-libgcc-file-name)
 
 # Remove uncalled code from the final image.
@@ -109,14 +141,14 @@ endif
 # Options for mpy-cross
 MPY_CROSS_FLAGS += -march=armv7m
 
-SRC_LIB = $(addprefix lib/,\
+LIB_SRC_C = $(addprefix lib/,\
 	libc/string0.c \
-	oofatfs/ff.c \
-	oofatfs/ffunicode.c \
 	mp-readline/readline.c \
 	netutils/netutils.c \
 	netutils/trace.c \
+	netutils/dhcpserver.c \
 	timeutils/timeutils.c \
+	utils/gchelper_native.c \
 	utils/pyexec.c \
 	utils/interrupt_char.c \
 	utils/sys_stdio_mphal.c \
@@ -124,7 +156,7 @@ SRC_LIB = $(addprefix lib/,\
 	)
 
 ifeq ($(MICROPY_FLOAT_IMPL),double)
-SRC_LIBM = $(addprefix lib/libm_dbl/,\
+LIBM_SRC_C = $(addprefix lib/libm_dbl/,\
 	__cos.c \
 	__expo2.c \
 	__fpclassify.c \
@@ -162,14 +194,18 @@ SRC_LIBM = $(addprefix lib/libm_dbl/,\
 	scalbn.c \
 	sin.c \
 	sinh.c \
-	sqrt.c \
 	tan.c \
 	tanh.c \
 	tgamma.c \
 	trunc.c \
 	)
+ifeq ($(SUPPORTS_HARDWARE_FP_DOUBLE),1)
+LIBM_SRC_C += lib/libm_dbl/thumb_vfp_sqrt.c
+else
+LIBM_SRC_C += lib/libm_dbl/sqrt.c
+endif
 else
-SRC_LIBM = $(addprefix lib/libm/,\
+LIBM_SRC_C = $(addprefix lib/libm/,\
 	math.c \
 	acoshf.c \
 	asinfacosf.c \
@@ -186,6 +222,7 @@ SRC_LIBM = $(addprefix lib/libm/,\
 	kf_tan.c \
 	log1pf.c \
 	nearbyintf.c \
+	roundf.c \
 	sf_cos.c \
 	sf_erf.c \
 	sf_frexp.c \
@@ -196,11 +233,18 @@ SRC_LIBM = $(addprefix lib/libm/,\
 	wf_lgamma.c \
 	wf_tgamma.c \
 	)
-ifeq ($(MCU_SERIES),f0)
-SRC_LIBM += lib/libm/ef_sqrt.c
+ifeq ($(SUPPORTS_HARDWARE_FP_SINGLE),1)
+LIBM_SRC_C += lib/libm/thumb_vfp_sqrtf.c
 else
-SRC_LIBM += lib/libm/thumb_vfp_sqrtf.c
+LIBM_SRC_C += lib/libm/ef_sqrt.c
+endif
 endif
+
+LIBM_O = $(addprefix $(BUILD)/, $(LIBM_SRC_C:.c=.o))
+
+# Too many warnings in libm_dbl, disable for now.
+ifeq ($(MICROPY_FLOAT_IMPL),double)
+$(LIBM_O): CFLAGS := $(filter-out -Wdouble-promotion -Wfloat-conversion, $(CFLAGS))
 endif
 
 EXTMOD_SRC_C = $(addprefix extmod/,\
@@ -221,14 +265,18 @@ SRC_C = \
 	usbd_desc.c \
 	usbd_cdc_interface.c \
 	usbd_hid_interface.c \
-	usbd_msc_storage.c \
+	usbd_msc_interface.c \
 	mphalport.c \
 	mpthreadport.c \
 	irq.c \
 	pendsv.c \
 	systick.c  \
+	softtimer.c  \
 	powerctrl.c \
+	powerctrlboot.c \
+	rfcore.c \
 	pybthread.c \
+	factoryreset.c \
 	timer.c \
 	led.c \
 	pin.c \
@@ -243,13 +291,17 @@ SRC_C = \
 	qspi.c \
 	uart.c \
 	can.c \
+	fdcan.c \
+	pyb_can.c \
 	usb.c \
 	wdt.c \
 	eth.c \
 	gccollect.c \
 	help.c \
+	machine_adc.c \
 	machine_i2c.c \
 	machine_spi.c \
+	machine_timer.c \
 	machine_uart.c \
 	modmachine.c \
 	modpyb.c \
@@ -277,27 +329,33 @@ SRC_C = \
 	adc.c \
 	$(wildcard $(BOARD_DIR)/*.c)
 
-ifeq ($(MCU_SERIES),f0)
 SRC_O = \
 	$(STARTUP_FILE) \
-	system_stm32f0.o \
+	$(SYSTEM_FILE)
+
+ifeq ($(MCU_SERIES),f0)
+SRC_O += \
 	resethandler_m0.o \
 	lib/utils/gchelper_m0.o
 else
-SRC_O = \
-	$(STARTUP_FILE) \
+ifeq ($(MCU_SERIES),l0)
+CSUPEROPT = -Os # save some code space
+SRC_O += \
+	resethandler_m0.o \
+	lib/utils/gchelper_m0.o
+else
+SRC_O += \
 	system_stm32.o \
 	resethandler.o \
 	lib/utils/gchelper_m3.o
 endif
+endif
 
 SRC_HAL = $(addprefix $(HAL_DIR)/Src/stm32$(MCU_SERIES)xx_,\
 	hal.c \
 	hal_adc.c \
 	hal_adc_ex.c \
 	hal_cortex.c \
-	hal_dac.c \
-	hal_dac_ex.c \
 	hal_dma.c \
 	hal_flash.c \
 	hal_flash_ex.c \
@@ -317,13 +375,17 @@ SRC_HAL = $(addprefix $(HAL_DIR)/Src/stm32$(MCU_SERIES)xx_,\
 	hal_uart.c \
 	)
 
+ifeq ($(MCU_SERIES),$(filter $(MCU_SERIES),f4 f7 h7 l0 l4 wb))
+SRC_HAL += $(addprefix $(HAL_DIR)/Src/stm32$(MCU_SERIES)xx_,\
+	ll_usb.c \
+	)
+endif
+
 ifeq ($(MCU_SERIES),$(filter $(MCU_SERIES),f4 f7 h7 l4))
-$(BUILD)/$(HAL_DIR)/Src/stm32$(MCU_SERIES)xx_ll_usb.o: CFLAGS += -Wno-attributes
 SRC_HAL += $(addprefix $(HAL_DIR)/Src/stm32$(MCU_SERIES)xx_,\
 	hal_sd.c \
 	ll_sdmmc.c \
 	ll_fmc.c \
-	ll_usb.c \
 	)
 endif
 
@@ -339,8 +401,10 @@ endif
 ifeq ($(CMSIS_MCU),$(filter $(CMSIS_MCU),STM32H743xx))
     SRC_HAL += $(addprefix $(HAL_DIR)/Src/stm32$(MCU_SERIES)xx_, hal_fdcan.c)
 else
+ifeq ($(MCU_SERIES),$(filter $(MCU_SERIES),f0 f4 f7 h7 l4))
     SRC_HAL += $(addprefix $(HAL_DIR)/Src/stm32$(MCU_SERIES)xx_, hal_can.c)
 endif
+endif
 
 SRC_USBDEV = $(addprefix $(USBDEV_DIR)/,\
 	core/src/usbd_core.c \
@@ -349,13 +413,30 @@ SRC_USBDEV = $(addprefix $(USBDEV_DIR)/,\
 	class/src/usbd_cdc_msc_hid.c \
 	class/src/usbd_msc_bot.c \
 	class/src/usbd_msc_scsi.c \
-	class/src/usbd_msc_data.c \
 	)
 
+ifeq ($(MICROPY_PY_BLUETOOTH),1)
+CFLAGS_MOD += -DMICROPY_PY_BLUETOOTH=1
+CFLAGS_MOD += -DMICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE=1
+CFLAGS_MOD += -DMICROPY_PY_BLUETOOTH_GATTS_ON_READ_CALLBACK=1
+endif
+
+ifeq ($(MICROPY_PY_NETWORK_CYW43),1)
+CFLAGS_MOD += -DMICROPY_PY_NETWORK_CYW43=1
+SRC_C += sdio.c
+EXTMOD_SRC_C += extmod/network_cyw43.c
+DRIVERS_SRC_C += drivers/cyw43/cyw43_ctrl.c drivers/cyw43/cyw43_lwip.c
+LIBS += $(TOP)/drivers/cyw43/libcyw43.a
+endif
+
 ifneq ($(MICROPY_PY_WIZNET5K),0)
 WIZNET5K_DIR=drivers/wiznet5k
 INC += -I$(TOP)/$(WIZNET5K_DIR)
 CFLAGS_MOD += -DMICROPY_PY_WIZNET5K=$(MICROPY_PY_WIZNET5K) -D_WIZCHIP_=$(MICROPY_PY_WIZNET5K)
+ifeq ($(MICROPY_PY_LWIP),1)
+# When using MACRAW mode (with lwIP), maximum buffer space must be used for the raw socket
+CFLAGS_MOD += -DWIZCHIP_USE_MAX_BUFFER
+endif
 SRC_MOD += network_wiznet5k.c modnwwiznet5k.c
 SRC_MOD += $(addprefix $(WIZNET5K_DIR)/,\
 	ethernet/w$(MICROPY_PY_WIZNET5K)/w$(MICROPY_PY_WIZNET5K).c \
@@ -388,10 +469,41 @@ SRC_MOD += $(addprefix $(CC3000_DIR)/src/,\
 	)
 endif
 
+ifeq ($(MICROPY_SSL_MBEDTLS),1)
+CFLAGS_MOD += -DMBEDTLS_CONFIG_FILE='"mbedtls/mbedtls_config.h"'
+SRC_MOD += mbedtls/mbedtls_port.c
+endif
+
+ifeq ($(MICROPY_PY_BLUETOOTH),1)
+
+SRC_C += modbluetooth_hci.c
+
+ifeq ($(MICROPY_BLUETOOTH_NIMBLE),1)
+ifeq ($(MICROPY_BLUETOOTH_BTSTACK),1)
+$(error Cannot enable both NimBLE and BTstack at the same time)
+endif
+endif
+
+ifeq ($(MICROPY_BLUETOOTH_NIMBLE),1)
+include $(TOP)/extmod/nimble/nimble.mk
+SRC_C += nimble.c
+endif
+
+ifeq ($(MICROPY_BLUETOOTH_BTSTACK),1)
+include $(TOP)/extmod/btstack/btstack.mk
+SRC_C += btstack.c
+endif
+
+ifeq ($(MICROPY_PY_NETWORK_CYW43),1)
+DRIVERS_SRC_C += drivers/cyw43/cywbt.c
+endif
+
+endif
+
 OBJ =
 OBJ += $(PY_O)
-OBJ += $(addprefix $(BUILD)/, $(SRC_LIB:.c=.o))
-OBJ += $(addprefix $(BUILD)/, $(SRC_LIBM:.c=.o))
+OBJ += $(addprefix $(BUILD)/, $(LIB_SRC_C:.c=.o))
+OBJ += $(LIBM_O)
 OBJ += $(addprefix $(BUILD)/, $(EXTMOD_SRC_C:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(DRIVERS_SRC_C:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
@@ -410,7 +522,7 @@ $(BUILD)/lib/libc/string0.o: COPT += -O2
 # If we compile these using -O0 then it won't fit. So if you really want these
 # to be compiled with -O0, then edit boards/common.ld (in the .isr_vector section)
 # and comment out the following lines.
-$(BUILD)/$(FATFS_DIR)/ff.o: COPT += -Os
+$(BUILD)/$(OOFATFS_DIR)/ff.o: COPT += -Os
 $(filter $(PY_BUILD)/../extmod/vfs_fat_%.o, $(PY_O)): COPT += -Os
 $(PY_BUILD)/formatfloat.o: COPT += -Os
 $(PY_BUILD)/parsenum.o: COPT += -Os
@@ -423,13 +535,13 @@ $(TOP)/lib/stm32lib/README.md:
 	$(ECHO) "stm32lib submodule not found, fetching it now..."
 	(cd $(TOP) && git submodule update --init lib/stm32lib)
 
-ifneq ($(FROZEN_DIR),)
+ifneq ($(FROZEN_MANIFEST)$(FROZEN_DIR),)
 # To use frozen source modules, put your .py files in a subdirectory (eg scripts/)
 # and then invoke make with FROZEN_DIR=scripts (be sure to build from scratch).
 CFLAGS += -DMICROPY_MODULE_FROZEN_STR
 endif
 
-ifneq ($(FROZEN_MPY_DIR),)
+ifneq ($(FROZEN_MANIFEST)$(FROZEN_MPY_DIR),)
 # To use frozen bytecode, put your .py files in a subdirectory (eg frozen/) and
 # then invoke make with FROZEN_MPY_DIR=frozen (be sure to build from scratch).
 CFLAGS += -DMICROPY_QSTR_EXTRA_POOL=mp_qstr_frozen_const_pool
@@ -441,9 +553,9 @@ endif
 deploy: $(BUILD)/firmware.dfu
 	$(ECHO) "Writing $< to the board"
 ifeq ($(USE_PYDFU),1)
-	$(Q)$(PYTHON) $(PYDFU) -u $<
+	$(Q)$(PYTHON) $(PYDFU) --vid $(BOOTLOADER_DFU_USB_VID) --pid $(BOOTLOADER_DFU_USB_PID) -u $<
 else
-	$(Q)$(DFU_UTIL) -a 0 -d $(DEVICE) -D $<
+	$(Q)$(DFU_UTIL) -a 0 -d $(BOOTLOADER_DFU_USB_VID):$(BOOTLOADER_DFU_USB_PID) -D $<
 endif
 
 # A board should specify TEXT0_ADDR if to use a different location than the
@@ -467,7 +579,7 @@ deploy-openocd: $(BUILD)/firmware.dfu
 $(BUILD)/firmware.dfu: $(BUILD)/firmware.elf
 	$(ECHO) "Create $@"
 	$(Q)$(OBJCOPY) -O binary $(addprefix -j ,$(TEXT0_SECTIONS)) $^ $(BUILD)/firmware.bin
-	$(Q)$(PYTHON) $(DFU) -b $(TEXT0_ADDR):$(BUILD)/firmware.bin $@
+	$(Q)$(PYTHON) $(DFU) -D $(BOOTLOADER_DFU_USB_VID):$(BOOTLOADER_DFU_USB_PID) -b $(TEXT0_ADDR):$(BUILD)/firmware.bin $@
 
 else
 # TEXT0_ADDR and TEXT1_ADDR are specified so split firmware between these locations
@@ -489,7 +601,7 @@ $(BUILD)/firmware.dfu: $(BUILD)/firmware.elf
 	$(ECHO) "GEN $@"
 	$(Q)$(OBJCOPY) -O binary $(addprefix -j ,$(TEXT0_SECTIONS)) $^ $(BUILD)/firmware0.bin
 	$(Q)$(OBJCOPY) -O binary $(addprefix -j ,$(TEXT1_SECTIONS)) $^ $(BUILD)/firmware1.bin
-	$(Q)$(PYTHON) $(DFU) -b $(TEXT0_ADDR):$(BUILD)/firmware0.bin -b $(TEXT1_ADDR):$(BUILD)/firmware1.bin $@
+	$(Q)$(PYTHON) $(DFU) -D $(BOOTLOADER_DFU_USB_VID):$(BOOTLOADER_DFU_USB_PID) -b $(TEXT0_ADDR):$(BUILD)/firmware0.bin -b $(TEXT1_ADDR):$(BUILD)/firmware1.bin $@
 
 endif
 
@@ -501,6 +613,12 @@ $(BUILD)/firmware.elf: $(OBJ)
 	$(ECHO) "LINK $@"
 	$(Q)$(LD) $(LDFLAGS) -o $@ $^ $(LDFLAGS_MOD) $(LIBS)
 	$(Q)$(SIZE) $@
+ifneq ($(TEXT0_ADDR),0x08000000)
+	$(ECHO) "INFO: this build requires mboot to be installed first"
+endif
+ifeq ($(TEXT1_ADDR),0x90000000)
+	$(ECHO) "INFO: this build places firmware in external QSPI flash"
+endif
 
 PLLVALUES = boards/pllvalues.py
 MAKE_PINS = boards/make-pins.py
@@ -522,7 +640,7 @@ GEN_CDCINF_FILE = $(HEADER_BUILD)/pybcdc.inf
 GEN_CDCINF_HEADER = $(HEADER_BUILD)/pybcdc_inf.h
 
 # List of sources for qstr extraction
-SRC_QSTR += $(SRC_C) $(SRC_MOD) $(SRC_LIB) $(EXTMOD_SRC_C)
+SRC_QSTR += $(SRC_C) $(SRC_MOD) $(LIB_SRC_C) $(EXTMOD_SRC_C)
 # Append any auto-generated sources that are needed by sources listed in
 # SRC_QSTR
 SRC_QSTR_AUTO_DEPS += $(GEN_CDCINF_HEADER)
@@ -558,13 +676,12 @@ GEN_PLLFREQTABLE_HDR = $(HEADER_BUILD)/pllfreqtable.h
 GEN_STMCONST_HDR = $(HEADER_BUILD)/modstm_const.h
 GEN_STMCONST_QSTR = $(BUILD)/modstm_qstr.h
 GEN_STMCONST_MPZ = $(HEADER_BUILD)/modstm_mpz.h
-CMSIS_MCU_LOWER = $(shell echo $(CMSIS_MCU) | tr '[:upper:]' '[:lower:]')
 CMSIS_MCU_HDR = $(CMSIS_DIR)/$(CMSIS_MCU_LOWER).h
 
 modmachine.c: $(GEN_PLLFREQTABLE_HDR)
 $(GEN_PLLFREQTABLE_HDR): $(PLLVALUES) | $(HEADER_BUILD)
 	$(ECHO) "GEN $@"
-	$(Q)$(PYTHON) $(PLLVALUES) -c $(if $(filter $(MCU_SERIES),f7),--relax-pll48,) file:$(BOARD_DIR)/stm32$(MCU_SERIES)xx_hal_conf.h > $@
+	$(Q)$(PYTHON) $(PLLVALUES) -c -m $(MCU_SERIES) file:$(BOARD_DIR)/stm32$(MCU_SERIES)xx_hal_conf.h > $@
 
 $(BUILD)/modstm.o: $(GEN_STMCONST_HDR)
 # Use a pattern rule here so that make will only call make-stmconst.py once to
diff --git a/ports/stm32/README.md b/ports/stm32/README.md
index a0c3b7ff39d81..f2fdb4dd3bffe 100644
--- a/ports/stm32/README.md
+++ b/ports/stm32/README.md
@@ -40,7 +40,11 @@ see [here](https://launchpad.net/gcc-arm-embedded) for the main GCC ARM
 Embedded page.  The compiler can be changed using the `CROSS_COMPILE` variable
 when invoking `make`.
 
-To build for a given board, run:
+First the submodules must be obtained using:
+
+    $ make submodules
+
+Then to build for a given board, run:
 
     $ make BOARD=PYBV11
 
@@ -49,11 +53,31 @@ The default board is PYBV10 but any of the names of the subdirectories in the
 should produce binary images in the `build-PYBV11/` subdirectory (or the
 equivalent directory for the board specified).
 
-You must then get your board/microcontroller into DFU mode.  On the pyboard
-connect the 3V3 pin to the P1/DFU pin with a wire (they are next to each
-other on the bottom left of the board, second row from the bottom) and then
-reset (by pressing the RST button) or power on the board.  Then flash the
-firmware using the command:
+
+### Flashing the Firmware using DFU mode
+
+You must then get your board/microcontroller into DFU (Device Firmware
+Update) mode.
+
+If you already have MicroPython installed on the board you can do that by
+calling `machine.bootloader()` on the board, either at the REPL or using
+`pyboard.py`. A nice property of this approach is that you can automate it
+so you can update the board without manually pressing any buttons.
+
+If you do not have MicroPython running yet, temporarily jumper your board's
+DFU pin (typ. BOOT0) to 3.3v and reset or power-on the board.
+
+On a pyboard the P1/DFU pin and a 3.3v pin are next to each other (on the
+bottom left of the board, second row from the bottom) and the reset button
+is labeled RST.
+
+For the pyboard D-series you can enter the mboot DFU bootloader by holding down
+the USR button, pressing and releasing the RST button, and continuing to hold
+down USR until the LED is white (4th in the cycle), then let go of USR while
+the LED is white. The LED will then flash red once per second to indicate it
+is in USB DFU mode.
+
+Once the board is in DFU mode, flash the firmware using the command:
 
     $ make BOARD=PYBV11 deploy
 
diff --git a/ports/stm32/accel.c b/ports/stm32/accel.c
index 0d7708c0934fc..b07791a9a0b5a 100644
--- a/ports/stm32/accel.c
+++ b/ports/stm32/accel.c
@@ -33,36 +33,67 @@
 #include "i2c.h"
 #include "accel.h"
 
-#if MICROPY_HW_HAS_MMA7660
+#if MICROPY_HW_HAS_MMA7660 || MICROPY_HW_HAS_KXTJ3
 
 /// \moduleref pyb
 /// \class Accel - accelerometer control
 ///
-/// Accel is an object that controls the accelerometer.  Example usage:
+/// Accel is an object that controls the MMA7660 or the KXTJ3 accelerometer
+/// depending on one/two constant in mpconfigboard.h file of board project :
+/// #define MICROPY_HW_HAS_MMA7660      (1)
+/// #define MICROPY_HW_HAS_KXTJ3        (0) // not mandatory if equal to 0
+///
+/// Example usage:
 ///
 ///     accel = pyb.Accel()
 ///     for i in range(10):
 ///         print(accel.x(), accel.y(), accel.z())
 ///
-/// Raw values are between -32 and 31.
+/// Raw values are between -32 and 31 for -/+ 1.5G acceleration for MMA7660.
+/// Raw values are between -128 and 127 for -/+ 8G acceleration for KXTJ3.
+
+
+#define I2C_TIMEOUT_MS (50)
+
+#if MICROPY_HW_HAS_MMA7660
 
-#define MMA_ADDR (76)
-#define MMA_REG_X (0)
-#define MMA_REG_Y (1)
-#define MMA_REG_Z (2)
-#define MMA_REG_TILT (3)
-#define MMA_REG_MODE (7)
-#define MMA_AXIS_SIGNED_VALUE(i) (((i) & 0x3f) | ((i) & 0x20 ? (~0x1f) : 0))
+#define ACCEL_ADDR                  (76)
+#define ACCEL_REG_X                 (0)
+#define ACCEL_REG_Y                 (1)
+#define ACCEL_REG_Z                 (2)
+#define ACCEL_REG_TILT              (3)
+#define ACCEL_REG_MODE              (7)
+#define ACCEL_AXIS_SIGNED_VALUE(i)  (((i) & 0x3f) | ((i) & 0x20 ? (~0x1f) : 0))
+
+#elif MICROPY_HW_HAS_KXTJ3
+
+#define ACCEL_ADDR                  (0x0f)
+#define ACCEL_REG_DCST_RESP         (0x0c)
+#define ACCEL_REG_WHO_AM_I          (0x0f)
+#define ACCEL_REG_X                 (0x07) // XOUT_H
+#define ACCEL_REG_Y                 (0x09) // YOUT_H
+#define ACCEL_REG_Z                 (0x0B) // ZOUT_H
+#define ACCEL_REG_CTRL_REG1         (0x1B)
+#define ACCEL_REG_CTRL_REG2         (0x1d)
+#define ACCEL_REG_CTRL_REG2         (0x1d)
+#define ACCEL_REG_DATA_CTRL_REG     (0x21)
+#define ACCEL_AXIS_SIGNED_VALUE(i)  (((i) & 0x7f) | ((i) & 0x80 ? (~0x7f) : 0))
+
+#endif
 
 void accel_init(void) {
+    #if MICROPY_HW_HAS_MMA7660
     // PB5 is connected to AVDD; pull high to enable MMA accel device
     mp_hal_pin_low(MICROPY_HW_MMA_AVDD_PIN); // turn off AVDD
     mp_hal_pin_output(MICROPY_HW_MMA_AVDD_PIN);
+    #endif
 }
 
 STATIC void accel_start(void) {
     // start the I2C bus in master mode
-    i2c_init(I2C1, MICROPY_HW_I2C1_SCL, MICROPY_HW_I2C1_SDA, 400000);
+    i2c_init(I2C1, MICROPY_HW_I2C1_SCL, MICROPY_HW_I2C1_SDA, 400000, I2C_TIMEOUT_MS);
+
+    #if MICROPY_HW_HAS_MMA7660
 
     // turn off AVDD, wait 30ms, turn on AVDD, wait 30ms again
     mp_hal_pin_low(MICROPY_HW_MMA_AVDD_PIN); // turn off
@@ -72,22 +103,43 @@ STATIC void accel_start(void) {
 
     int ret;
     for (int i = 0; i < 4; i++) {
-        ret = i2c_writeto(I2C1, MMA_ADDR, NULL, 0, true);
+        ret = i2c_writeto(I2C1, ACCEL_ADDR, NULL, 0, true);
         if (ret == 0) {
             break;
         }
     }
 
     if (ret != 0) {
-        mp_raise_msg(&mp_type_OSError, "accelerometer not found");
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("accelerometer not found"));
     }
 
     // set MMA to active mode
-    uint8_t data[2] = {MMA_REG_MODE, 1}; // active mode
-    i2c_writeto(I2C1, MMA_ADDR, data, 2, true);
+    uint8_t data[2] = {ACCEL_REG_MODE, 1}; // active mode
+    i2c_writeto(I2C1, ACCEL_ADDR, data, 2, true);
 
     // wait for MMA to become active
     mp_hal_delay_ms(30);
+
+    #elif MICROPY_HW_HAS_KXTJ3
+
+    // readout WHO_AM_I register to check KXTJ3 device presence
+    uint8_t data[2] = { ACCEL_REG_WHO_AM_I };
+    i2c_writeto(I2C1, ACCEL_ADDR, data, 1, false);
+    i2c_readfrom(I2C1, ACCEL_ADDR, data, 1, true);
+    if (data[0] != 0x35) {
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("accelerometer not found"));
+    }
+
+    // set operating mode (default: 8 bits, range +/-8G)
+    data[0] = ACCEL_REG_CTRL_REG1;
+    data[1] = 0x90;
+    i2c_writeto(I2C1, ACCEL_ADDR, data, 2, true);
+    // set dat output rates to 200Hz (LPF roll-over 10ms), idd=35uA
+    data[0] = ACCEL_REG_DATA_CTRL_REG;
+    data[1] = 0x04;
+    i2c_writeto(I2C1, ACCEL_ADDR, data, 2, true);
+
+    #endif
 }
 
 /******************************************************************************/
@@ -127,39 +179,44 @@ STATIC mp_obj_t pyb_accel_make_new(const mp_obj_type_t *type, size_t n_args, siz
 
 STATIC mp_obj_t read_axis(int axis) {
     uint8_t data[1] = { axis };
-    i2c_writeto(I2C1, MMA_ADDR, data, 1, false);
-    i2c_readfrom(I2C1, MMA_ADDR, data, 1, true);
-    return mp_obj_new_int(MMA_AXIS_SIGNED_VALUE(data[0]));
+    i2c_writeto(I2C1, ACCEL_ADDR, data, 1, false);
+    i2c_readfrom(I2C1, ACCEL_ADDR, data, 1, true);
+    return mp_obj_new_int(ACCEL_AXIS_SIGNED_VALUE(data[0]));
 }
 
 /// \method x()
 /// Get the x-axis value.
 STATIC mp_obj_t pyb_accel_x(mp_obj_t self_in) {
-    return read_axis(MMA_REG_X);
+    return read_axis(ACCEL_REG_X);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_accel_x_obj, pyb_accel_x);
 
 /// \method y()
 /// Get the y-axis value.
 STATIC mp_obj_t pyb_accel_y(mp_obj_t self_in) {
-    return read_axis(MMA_REG_Y);
+    return read_axis(ACCEL_REG_Y);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_accel_y_obj, pyb_accel_y);
 
 /// \method z()
 /// Get the z-axis value.
 STATIC mp_obj_t pyb_accel_z(mp_obj_t self_in) {
-    return read_axis(MMA_REG_Z);
+    return read_axis(ACCEL_REG_Z);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_accel_z_obj, pyb_accel_z);
 
 /// \method tilt()
 /// Get the tilt register.
 STATIC mp_obj_t pyb_accel_tilt(mp_obj_t self_in) {
-    uint8_t data[1] = { MMA_REG_TILT };
-    i2c_writeto(I2C1, MMA_ADDR, data, 1, false);
-    i2c_readfrom(I2C1, MMA_ADDR, data, 1, true);
+    #if MICROPY_HW_HAS_MMA7660
+    uint8_t data[1] = { ACCEL_REG_TILT };
+    i2c_writeto(I2C1, ACCEL_ADDR, data, 1, false);
+    i2c_readfrom(I2C1, ACCEL_ADDR, data, 1, true);
     return mp_obj_new_int(data[0]);
+    #elif MICROPY_HW_HAS_KXTJ3
+    /// No tilt like register with KXTJ3 accelerometer
+    return 0;
+    #endif
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_accel_tilt_obj, pyb_accel_tilt);
 
@@ -170,13 +227,21 @@ STATIC mp_obj_t pyb_accel_filtered_xyz(mp_obj_t self_in) {
 
     memmove(self->buf, self->buf + NUM_AXIS, NUM_AXIS * (FILT_DEPTH - 1) * sizeof(int16_t));
 
-    uint8_t data[NUM_AXIS] = { MMA_REG_X };
-    i2c_writeto(I2C1, MMA_ADDR, data, 1, false);
-    i2c_readfrom(I2C1, MMA_ADDR, data, 3, true);
+    #if MICROPY_HW_HAS_MMA7660
+    const size_t DATA_SIZE = NUM_AXIS;
+    const size_t DATA_STRIDE = 1;
+    #elif MICROPY_HW_HAS_KXTJ3
+    const size_t DATA_SIZE = 5;
+    const size_t DATA_STRIDE = 2;
+    #endif
+    uint8_t data[DATA_SIZE];
+    data[0] = ACCEL_REG_X;
+    i2c_writeto(I2C1, ACCEL_ADDR, data, 1, false);
+    i2c_readfrom(I2C1, ACCEL_ADDR, data, DATA_SIZE, true);
 
     mp_obj_t tuple[NUM_AXIS];
     for (int i = 0; i < NUM_AXIS; i++) {
-        self->buf[NUM_AXIS * (FILT_DEPTH - 1) + i] = MMA_AXIS_SIGNED_VALUE(data[i]);
+        self->buf[NUM_AXIS * (FILT_DEPTH - 1) + i] = ACCEL_AXIS_SIGNED_VALUE(data[i * DATA_STRIDE]);
         int32_t val = 0;
         for (int j = 0; j < FILT_DEPTH; j++) {
             val += self->buf[i + NUM_AXIS * j];
@@ -190,15 +255,15 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_accel_filtered_xyz_obj, pyb_accel_filtered_
 
 STATIC mp_obj_t pyb_accel_read(mp_obj_t self_in, mp_obj_t reg) {
     uint8_t data[1] = { mp_obj_get_int(reg) };
-    i2c_writeto(I2C1, MMA_ADDR, data, 1, false);
-    i2c_writeto(I2C1, MMA_ADDR, data, 1, true);
+    i2c_writeto(I2C1, ACCEL_ADDR, data, 1, false);
+    i2c_readfrom(I2C1, ACCEL_ADDR, data, 1, true);
     return mp_obj_new_int(data[0]);
 }
 MP_DEFINE_CONST_FUN_OBJ_2(pyb_accel_read_obj, pyb_accel_read);
 
 STATIC mp_obj_t pyb_accel_write(mp_obj_t self_in, mp_obj_t reg, mp_obj_t val) {
     uint8_t data[2] = { mp_obj_get_int(reg), mp_obj_get_int(val) };
-    i2c_writeto(I2C1, MMA_ADDR, data, 2, true);
+    i2c_writeto(I2C1, ACCEL_ADDR, data, 2, true);
     return mp_const_none;
 }
 MP_DEFINE_CONST_FUN_OBJ_3(pyb_accel_write_obj, pyb_accel_write);
@@ -220,7 +285,7 @@ const mp_obj_type_t pyb_accel_type = {
     { &mp_type_type },
     .name = MP_QSTR_Accel,
     .make_new = pyb_accel_make_new,
-    .locals_dict = (mp_obj_dict_t*)&pyb_accel_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_accel_locals_dict,
 };
 
-#endif // MICROPY_HW_HAS_MMA7660
+#endif // MICROPY_HW_HAS_MMA7660 || MICROPY_HW_HAS_KXTJ3
diff --git a/ports/stm32/adc.c b/ports/stm32/adc.c
index 73588e4a3f172..bdd4ec1aeb8e8 100644
--- a/ports/stm32/adc.c
+++ b/ports/stm32/adc.c
@@ -63,7 +63,6 @@
 #endif
 
 #define ADCx_CLK_ENABLE         __HAL_RCC_ADC1_CLK_ENABLE
-#define ADC_NUM_CHANNELS        (19)
 
 #if defined(STM32F0)
 
@@ -71,8 +70,8 @@
 #define ADC_LAST_GPIO_CHANNEL   (15)
 #define ADC_SCALE_V             (3.3f)
 #define ADC_CAL_ADDRESS         (0x1ffff7ba)
-#define ADC_CAL1                ((uint16_t*)0x1ffff7b8)
-#define ADC_CAL2                ((uint16_t*)0x1ffff7c2)
+#define ADC_CAL1                ((uint16_t *)0x1ffff7b8)
+#define ADC_CAL2                ((uint16_t *)0x1ffff7c2)
 #define ADC_CAL_BITS            (12)
 
 #elif defined(STM32F4)
@@ -81,8 +80,8 @@
 #define ADC_LAST_GPIO_CHANNEL   (15)
 #define ADC_SCALE_V             (3.3f)
 #define ADC_CAL_ADDRESS         (0x1fff7a2a)
-#define ADC_CAL1                ((uint16_t*)(ADC_CAL_ADDRESS + 2))
-#define ADC_CAL2                ((uint16_t*)(ADC_CAL_ADDRESS + 4))
+#define ADC_CAL1                ((uint16_t *)(ADC_CAL_ADDRESS + 2))
+#define ADC_CAL2                ((uint16_t *)(ADC_CAL_ADDRESS + 4))
 #define ADC_CAL_BITS            (12)
 
 #elif defined(STM32F7)
@@ -97,8 +96,8 @@
 #define ADC_CAL_ADDRESS         (0x1ff0f44a)
 #endif
 
-#define ADC_CAL1                ((uint16_t*)(ADC_CAL_ADDRESS + 2))
-#define ADC_CAL2                ((uint16_t*)(ADC_CAL_ADDRESS + 4))
+#define ADC_CAL1                ((uint16_t *)(ADC_CAL_ADDRESS + 2))
+#define ADC_CAL2                ((uint16_t *)(ADC_CAL_ADDRESS + 4))
 #define ADC_CAL_BITS            (12)
 
 #elif defined(STM32H7)
@@ -107,10 +106,9 @@
 #define ADC_LAST_GPIO_CHANNEL   (16)
 #define ADC_SCALE_V             (3.3f)
 #define ADC_CAL_ADDRESS         (0x1FF1E860)
-#define ADC_CAL1                ((uint16_t*)(0x1FF1E820))
-#define ADC_CAL2                ((uint16_t*)(0x1FF1E840))
+#define ADC_CAL1                ((uint16_t *)(0x1FF1E820))
+#define ADC_CAL2                ((uint16_t *)(0x1FF1E840))
 #define ADC_CAL_BITS            (16)
-#define ADC_CHANNEL_VBAT        ADC_CHANNEL_VBAT_DIV4
 
 #elif defined(STM32L4)
 
@@ -118,8 +116,8 @@
 #define ADC_LAST_GPIO_CHANNEL   (16)
 #define ADC_SCALE_V             (3.0f)
 #define ADC_CAL_ADDRESS         (0x1fff75aa)
-#define ADC_CAL1                ((uint16_t*)(ADC_CAL_ADDRESS - 2))
-#define ADC_CAL2                ((uint16_t*)(ADC_CAL_ADDRESS + 0x20))
+#define ADC_CAL1                ((uint16_t *)(ADC_CAL_ADDRESS - 2))
+#define ADC_CAL2                ((uint16_t *)(ADC_CAL_ADDRESS + 0x20))
 #define ADC_CAL_BITS            (12)
 
 #else
@@ -132,21 +130,24 @@
 #define VBAT_DIV (2)
 #elif defined(STM32F405xx) || defined(STM32F415xx) || \
     defined(STM32F407xx) || defined(STM32F417xx) || \
-    defined(STM32F401xC) || defined(STM32F401xE) || \
-    defined(STM32F411xE)
+    defined(STM32F401xC) || defined(STM32F401xE)
 #define VBAT_DIV (2)
-#elif defined(STM32F427xx) || defined(STM32F429xx) || \
-      defined(STM32F437xx) || defined(STM32F439xx) || \
-      defined(STM32F446xx) || \
-      defined(STM32F722xx) || defined(STM32F723xx) || \
-      defined(STM32F732xx) || defined(STM32F733xx) || \
-      defined(STM32F746xx) || defined(STM32F765xx) || \
-      defined(STM32F767xx) || defined(STM32F769xx)
+#elif defined(STM32F411xE) || defined(STM32F412Zx) || \
+    defined(STM32F413xx) || defined(STM32F427xx) || \
+    defined(STM32F429xx) || defined(STM32F437xx) || \
+    defined(STM32F439xx) || defined(STM32F446xx)
+#define VBAT_DIV (4)
+#elif defined(STM32F722xx) || defined(STM32F723xx) || \
+    defined(STM32F732xx) || defined(STM32F733xx) || \
+    defined(STM32F746xx) || defined(STM32F765xx) || \
+    defined(STM32F767xx) || defined(STM32F769xx)
 #define VBAT_DIV (4)
 #elif defined(STM32H743xx)
 #define VBAT_DIV (4)
-#elif defined(STM32L432xx) || defined(STM32L475xx) || \
-      defined(STM32L476xx) || defined(STM32L496xx)
+#elif defined(STM32L432xx) || \
+    defined(STM32L451xx) || defined(STM32L452xx) || \
+    defined(STM32L462xx) || defined(STM32L475xx) || \
+    defined(STM32L476xx) || defined(STM32L496xx)
 #define VBAT_DIV (3)
 #else
 #error Unsupported processor
@@ -163,6 +164,13 @@
 #define ADC_SCALE (ADC_SCALE_V / ((1 << ADC_CAL_BITS) - 1))
 #define VREFIN_CAL ((uint16_t *)ADC_CAL_ADDRESS)
 
+#ifndef __HAL_ADC_IS_CHANNEL_INTERNAL
+#define __HAL_ADC_IS_CHANNEL_INTERNAL(channel) \
+    (channel == ADC_CHANNEL_VBAT \
+    || channel == ADC_CHANNEL_VREFINT \
+    || channel == ADC_CHANNEL_TEMPSENSOR)
+#endif
+
 typedef struct _pyb_obj_adc_t {
     mp_obj_base_t base;
     mp_obj_t pin_name;
@@ -183,92 +191,96 @@ static inline uint32_t adc_get_internal_channel(uint32_t channel) {
 }
 
 STATIC bool is_adcx_channel(int channel) {
-#if defined(STM32F411xE)
+    #if defined(STM32F411xE)
     // The HAL has an incorrect IS_ADC_CHANNEL macro for the F411 so we check for temp
     return IS_ADC_CHANNEL(channel) || channel == ADC_CHANNEL_TEMPSENSOR;
-#elif defined(STM32F0) || defined(STM32F4) || defined(STM32F7) || defined(STM32H7)
+    #elif defined(STM32F0) || defined(STM32F4) || defined(STM32F7)
     return IS_ADC_CHANNEL(channel);
-#elif defined(STM32L4)
+    #elif defined(STM32H7)
+    return __HAL_ADC_IS_CHANNEL_INTERNAL(channel)
+           || IS_ADC_CHANNEL(__HAL_ADC_DECIMAL_NB_TO_CHANNEL(channel));
+    #elif defined(STM32L4)
     ADC_HandleTypeDef handle;
     handle.Instance = ADCx;
     return IS_ADC_CHANNEL(&handle, channel);
-#else
+    #else
     #error Unsupported processor
-#endif
+    #endif
 }
 
 STATIC void adc_wait_for_eoc_or_timeout(int32_t timeout) {
     uint32_t tickstart = HAL_GetTick();
-#if defined(STM32F4) || defined(STM32F7)
+    #if defined(STM32F4) || defined(STM32F7)
     while ((ADCx->SR & ADC_FLAG_EOC) != ADC_FLAG_EOC) {
-#elif defined(STM32F0) || defined(STM32H7) || defined(STM32L4)
+    #elif defined(STM32F0) || defined(STM32H7) || defined(STM32L4)
     while (READ_BIT(ADCx->ISR, ADC_FLAG_EOC) != ADC_FLAG_EOC) {
-#else
+    #else
     #error Unsupported processor
-#endif
-        if (((HAL_GetTick() - tickstart ) > timeout)) {
+        #endif
+        if (((HAL_GetTick() - tickstart) > timeout)) {
             break; // timeout
         }
     }
 }
 
 STATIC void adcx_clock_enable(void) {
-#if defined(STM32F0) || defined(STM32F4) || defined(STM32F7)
+    #if defined(STM32F0) || defined(STM32F4) || defined(STM32F7)
     ADCx_CLK_ENABLE();
-#elif defined(STM32H7)
+    #elif defined(STM32H7)
     __HAL_RCC_ADC3_CLK_ENABLE();
     __HAL_RCC_ADC_CONFIG(RCC_ADCCLKSOURCE_CLKP);
-#elif defined(STM32L4)
+    #elif defined(STM32L4)
     __HAL_RCC_ADC_CLK_ENABLE();
-#else
+    #else
     #error Unsupported processor
-#endif
+    #endif
 }
 
 STATIC void adcx_init_periph(ADC_HandleTypeDef *adch, uint32_t resolution) {
     adcx_clock_enable();
 
-    adch->Instance                   = ADCx;
-    adch->Init.Resolution            = resolution;
-    adch->Init.ContinuousConvMode    = DISABLE;
+    adch->Instance = ADCx;
+    adch->Init.Resolution = resolution;
+    adch->Init.ContinuousConvMode = DISABLE;
     adch->Init.DiscontinuousConvMode = DISABLE;
     #if !defined(STM32F0)
-    adch->Init.NbrOfDiscConversion   = 0;
-    adch->Init.NbrOfConversion       = 1;
+    adch->Init.NbrOfDiscConversion = 0;
+    adch->Init.NbrOfConversion = 1;
     #endif
-    adch->Init.EOCSelection          = ADC_EOC_SINGLE_CONV;
-    adch->Init.ExternalTrigConv      = ADC_SOFTWARE_START;
-    adch->Init.ExternalTrigConvEdge  = ADC_EXTERNALTRIGCONVEDGE_NONE;
-    #if defined(STM32F0) || defined(STM32F4) || defined(STM32F7)
-    adch->Init.ClockPrescaler        = ADC_CLOCK_SYNC_PCLK_DIV2;
-    adch->Init.ScanConvMode          = DISABLE;
-    adch->Init.DataAlign             = ADC_DATAALIGN_RIGHT;
+    adch->Init.EOCSelection = ADC_EOC_SINGLE_CONV;
+    adch->Init.ExternalTrigConv = ADC_SOFTWARE_START;
+    adch->Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
+    #if defined(STM32F0)
+    adch->Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;        // 12MHz
+    adch->Init.ScanConvMode = DISABLE;
+    adch->Init.DataAlign = ADC_DATAALIGN_RIGHT;
+    adch->Init.DMAContinuousRequests = DISABLE;
+    adch->Init.SamplingTimeCommon = ADC_SAMPLETIME_55CYCLES_5;    // ~4uS
+    #elif defined(STM32F4) || defined(STM32F7)
+    adch->Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV2;
+    adch->Init.ScanConvMode = DISABLE;
+    adch->Init.DataAlign = ADC_DATAALIGN_RIGHT;
     adch->Init.DMAContinuousRequests = DISABLE;
     #elif defined(STM32H7)
-    adch->Init.ClockPrescaler        = ADC_CLOCK_SYNC_PCLK_DIV4;
-    adch->Init.BoostMode             = ENABLE;
-    adch->Init.ScanConvMode          = DISABLE;
-    adch->Init.LowPowerAutoWait      = DISABLE;
-    adch->Init.Overrun               = ADC_OVR_DATA_OVERWRITTEN;
-    adch->Init.OversamplingMode      = DISABLE;
-    adch->Init.LeftBitShift          = ADC_LEFTBITSHIFT_NONE;
+    adch->Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
+    adch->Init.ScanConvMode = DISABLE;
+    adch->Init.LowPowerAutoWait = DISABLE;
+    adch->Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
+    adch->Init.OversamplingMode = DISABLE;
+    adch->Init.LeftBitShift = ADC_LEFTBITSHIFT_NONE;
     adch->Init.ConversionDataManagement = ADC_CONVERSIONDATA_DR;
     #elif defined(STM32L4)
-    adch->Init.ClockPrescaler        = ADC_CLOCK_ASYNC_DIV1;
-    adch->Init.ScanConvMode          = ADC_SCAN_DISABLE;
-    adch->Init.LowPowerAutoWait      = DISABLE;
-    adch->Init.Overrun               = ADC_OVR_DATA_PRESERVED;
-    adch->Init.OversamplingMode      = DISABLE;
-    adch->Init.DataAlign             = ADC_DATAALIGN_RIGHT;
+    adch->Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
+    adch->Init.ScanConvMode = ADC_SCAN_DISABLE;
+    adch->Init.LowPowerAutoWait = DISABLE;
+    adch->Init.Overrun = ADC_OVR_DATA_PRESERVED;
+    adch->Init.OversamplingMode = DISABLE;
+    adch->Init.DataAlign = ADC_DATAALIGN_RIGHT;
     adch->Init.DMAContinuousRequests = DISABLE;
     #else
     #error Unsupported processor
     #endif
 
-    #if defined(STM32F0)
-    adch->Init.SamplingTimeCommon = ADC_SAMPLETIME_71CYCLES_5;
-    #endif
-
     HAL_ADC_Init(adch);
 
     #if defined(STM32H7)
@@ -280,9 +292,6 @@ STATIC void adcx_init_periph(ADC_HandleTypeDef *adch, uint32_t resolution) {
 }
 
 STATIC void adc_init_single(pyb_obj_adc_t *adc_obj) {
-    if (!is_adcx_channel(adc_obj->channel)) {
-        return;
-    }
 
     if (ADC_FIRST_GPIO_CHANNEL <= adc_obj->channel && adc_obj->channel <= ADC_LAST_GPIO_CHANNEL) {
         // Channels 0-16 correspond to real pins. Configure the GPIO pin in ADC mode.
@@ -292,30 +301,35 @@ STATIC void adc_init_single(pyb_obj_adc_t *adc_obj) {
 
     adcx_init_periph(&adc_obj->handle, ADC_RESOLUTION_12B);
 
-#if defined(STM32L4) && defined(ADC_DUALMODE_REGSIMULT_INJECSIMULT)
+    #if defined(STM32L4) && defined(ADC_DUALMODE_REGSIMULT_INJECSIMULT)
     ADC_MultiModeTypeDef multimode;
     multimode.Mode = ADC_MODE_INDEPENDENT;
-    if (HAL_ADCEx_MultiModeConfigChannel(&adc_obj->handle, &multimode) != HAL_OK)
-    {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Can not set multimode on ADC1 channel: %d", adc_obj->channel));
+    if (HAL_ADCEx_MultiModeConfigChannel(&adc_obj->handle, &multimode) != HAL_OK) {
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Can not set multimode on ADC1 channel: %d"), adc_obj->channel);
     }
-#endif
+    #endif
 }
 
 STATIC void adc_config_channel(ADC_HandleTypeDef *adc_handle, uint32_t channel) {
     ADC_ChannelConfTypeDef sConfig;
 
-    sConfig.Channel = channel;
+    #if defined(STM32H7)
+    sConfig.Rank = ADC_REGULAR_RANK_1;
+    if (__HAL_ADC_IS_CHANNEL_INTERNAL(channel) == 0) {
+        channel = __HAL_ADC_DECIMAL_NB_TO_CHANNEL(channel);
+    }
+    #else
     sConfig.Rank = 1;
-#if defined(STM32F0)
-    sConfig.SamplingTime = ADC_SAMPLETIME_71CYCLES_5;
-#elif defined(STM32F4) || defined(STM32F7)
+    #endif
+    sConfig.Channel = channel;
+
+    #if defined(STM32F0)
+    sConfig.SamplingTime = ADC_SAMPLETIME_55CYCLES_5;
+    #elif defined(STM32F4) || defined(STM32F7)
     sConfig.SamplingTime = ADC_SAMPLETIME_15CYCLES;
-#elif defined(STM32H7)
-    if (channel == ADC_CHANNEL_VREFINT
-        || channel == ADC_CHANNEL_TEMPSENSOR
-        || channel == ADC_CHANNEL_VBAT) {
-        sConfig.SamplingTime = ADC_SAMPLETIME_387CYCLES_5;
+    #elif defined(STM32H7)
+    if (__HAL_ADC_IS_CHANNEL_INTERNAL(channel)) {
+        sConfig.SamplingTime = ADC_SAMPLETIME_810CYCLES_5;
     } else {
         sConfig.SamplingTime = ADC_SAMPLETIME_8CYCLES_5;
     }
@@ -323,10 +337,8 @@ STATIC void adc_config_channel(ADC_HandleTypeDef *adc_handle, uint32_t channel)
     sConfig.OffsetNumber = ADC_OFFSET_NONE;
     sConfig.OffsetRightShift = DISABLE;
     sConfig.OffsetSignedSaturation = DISABLE;
-#elif defined(STM32L4)
-    if (channel == ADC_CHANNEL_VREFINT
-        || channel == ADC_CHANNEL_TEMPSENSOR
-        || channel == ADC_CHANNEL_VBAT) {
+    #elif defined(STM32L4)
+    if (__HAL_ADC_IS_CHANNEL_INTERNAL(channel)) {
         sConfig.SamplingTime = ADC_SAMPLETIME_247CYCLES_5;
     } else {
         sConfig.SamplingTime = ADC_SAMPLETIME_12CYCLES_5;
@@ -334,9 +346,9 @@ STATIC void adc_config_channel(ADC_HandleTypeDef *adc_handle, uint32_t channel)
     sConfig.SingleDiff = ADC_SINGLE_ENDED;
     sConfig.OffsetNumber = ADC_OFFSET_NONE;
     sConfig.Offset = 0;
-#else
+    #else
     #error Unsupported processor
-#endif
+    #endif
 
     #if defined(STM32F0)
     // On the STM32F0 we must select only one channel at a time to sample, so clear all
@@ -401,21 +413,20 @@ STATIC mp_obj_t adc_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_
         const pin_obj_t *pin = pin_find(pin_obj);
         if ((pin->adc_num & PIN_ADC_MASK) == 0) {
             // No ADC1 function on that pin
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "pin %q does not have ADC capabilities", pin->name));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("pin %q does not have ADC capabilities"), pin->name);
         }
         channel = pin->adc_channel;
     }
 
     if (!is_adcx_channel(channel)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "not a valid ADC Channel: %d", channel));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("not a valid ADC Channel: %d"), channel);
     }
 
 
     if (ADC_FIRST_GPIO_CHANNEL <= channel && channel <= ADC_LAST_GPIO_CHANNEL) {
         // these channels correspond to physical GPIO ports so make sure they exist
         if (pin_adc_table[channel] == NULL) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-                "channel %d not available on this board", channel));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("channel %d not available on this board"), channel);
         }
     }
 
@@ -510,13 +521,13 @@ STATIC mp_obj_t adc_read_timed(mp_obj_t self_in, mp_obj_t buf_in, mp_obj_t freq_
             HAL_ADC_Start(&self->handle);
         } else {
             // for subsequent samples we can just set the "start sample" bit
-#if defined(STM32F4) || defined(STM32F7)
+            #if defined(STM32F4) || defined(STM32F7)
             ADCx->CR2 |= (uint32_t)ADC_CR2_SWSTART;
-#elif defined(STM32F0) || defined(STM32H7) || defined(STM32L4)
+            #elif defined(STM32F0) || defined(STM32H7) || defined(STM32L4)
             SET_BIT(ADCx->CR, ADC_CR_ADSTART);
-#else
+            #else
             #error Unsupported processor
-#endif
+            #endif
         }
 
         // wait for sample to complete
@@ -561,10 +572,10 @@ STATIC mp_obj_t adc_read_timed_multi(mp_obj_t adc_array_in, mp_obj_t buf_array_i
     mp_obj_get_array(buf_array_in, &nbufs, &buf_array);
 
     if (nadcs < 1) {
-        mp_raise_ValueError("need at least 1 ADC");
+        mp_raise_ValueError(MP_ERROR_TEXT("need at least 1 ADC"));
     }
     if (nadcs != nbufs) {
-        mp_raise_ValueError("length of ADC and buffer lists differ");
+        mp_raise_ValueError(MP_ERROR_TEXT("length of ADC and buffer lists differ"));
     }
 
     // Get buf for first ADC, get word size, check other buffers match in type
@@ -576,7 +587,7 @@ STATIC mp_obj_t adc_read_timed_multi(mp_obj_t adc_array_in, mp_obj_t buf_array_i
         mp_buffer_info_t bufinfo_curr;
         mp_get_buffer_raise(buf_array[array_index], &bufinfo_curr, MP_BUFFER_WRITE);
         if ((bufinfo.len != bufinfo_curr.len) || (bufinfo.typecode != bufinfo_curr.typecode)) {
-            mp_raise_ValueError("size and type of buffers must match");
+            mp_raise_ValueError(MP_ERROR_TEXT("size and type of buffers must match"));
         }
         bufptrs[array_index] = bufinfo_curr.buf;
     }
@@ -663,7 +674,7 @@ const mp_obj_type_t pyb_adc_type = {
     .name = MP_QSTR_ADC,
     .print = adc_print,
     .make_new = adc_make_new,
-    .locals_dict = (mp_obj_dict_t*)&adc_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&adc_locals_dict,
 };
 
 /******************************************************************************/
@@ -678,17 +689,26 @@ void adc_init_all(pyb_adc_all_obj_t *adc_all, uint32_t resolution, uint32_t en_m
 
     switch (resolution) {
         #if !defined(STM32H7)
-        case 6:  resolution = ADC_RESOLUTION_6B;  break;
+        case 6:
+            resolution = ADC_RESOLUTION_6B;
+            break;
         #endif
-        case 8:  resolution = ADC_RESOLUTION_8B;  break;
-        case 10: resolution = ADC_RESOLUTION_10B; break;
-        case 12: resolution = ADC_RESOLUTION_12B; break;
+        case 8:
+            resolution = ADC_RESOLUTION_8B;
+            break;
+        case 10:
+            resolution = ADC_RESOLUTION_10B;
+            break;
+        case 12:
+            resolution = ADC_RESOLUTION_12B;
+            break;
         #if defined(STM32H7)
-        case 16: resolution = ADC_RESOLUTION_16B; break;
+        case 16:
+            resolution = ADC_RESOLUTION_16B;
+            break;
         #endif
         default:
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-                "resolution %d not supported", resolution));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("resolution %d not supported"), resolution);
     }
 
     for (uint32_t channel = ADC_FIRST_GPIO_CHANNEL; channel <= ADC_LAST_GPIO_CHANNEL; ++channel) {
@@ -710,13 +730,17 @@ int adc_get_resolution(ADC_HandleTypeDef *adcHandle) {
     uint32_t res_reg = ADC_GET_RESOLUTION(adcHandle);
 
     switch (res_reg) {
-       #if !defined(STM32H7)
-        case ADC_RESOLUTION_6B:  return 6;
+        #if !defined(STM32H7)
+        case ADC_RESOLUTION_6B:
+            return 6;
         #endif
-        case ADC_RESOLUTION_8B:  return 8;
-        case ADC_RESOLUTION_10B: return 10;
+        case ADC_RESOLUTION_8B:
+            return 8;
+        case ADC_RESOLUTION_10B:
+            return 10;
         #if defined(STM32H7)
-        case ADC_RESOLUTION_16B: return 16;
+        case ADC_RESOLUTION_16B:
+            return 16;
         #endif
     }
     return 12;
@@ -739,7 +763,7 @@ STATIC volatile float adc_refcor = 1.0f;
 
 float adc_read_core_temp_float(ADC_HandleTypeDef *adcHandle) {
     int32_t raw_value = adc_config_and_read_ref(adcHandle, ADC_CHANNEL_TEMPSENSOR);
-    float core_temp_avg_slope = (*ADC_CAL2 - *ADC_CAL1) / 80.0;
+    float core_temp_avg_slope = (*ADC_CAL2 - *ADC_CAL1) / 80.0f;
     return (((float)raw_value * adc_refcor - *ADC_CAL1) / core_temp_avg_slope) + 30.0f;
 }
 
@@ -771,7 +795,7 @@ STATIC mp_obj_t adc_all_make_new(const mp_obj_type_t *type, size_t n_args, size_
     mp_int_t res = mp_obj_get_int(args[0]);
     uint32_t en_mask = 0xffffffff;
     if (n_args > 1) {
-        en_mask =  mp_obj_get_int(args[1]);
+        en_mask = mp_obj_get_int(args[1]);
     }
     adc_init_all(o, res, en_mask);
 
@@ -792,7 +816,7 @@ STATIC mp_obj_t adc_all_read_core_temp(mp_obj_t self_in) {
     float data = adc_read_core_temp_float(&self->handle);
     return mp_obj_new_float(data);
     #else
-    int data  = adc_read_core_temp(&self->handle);
+    int data = adc_read_core_temp(&self->handle);
     return mp_obj_new_int(data);
     #endif
 }
@@ -808,7 +832,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(adc_all_read_core_vbat_obj, adc_all_read_core_v
 
 STATIC mp_obj_t adc_all_read_core_vref(mp_obj_t self_in) {
     pyb_adc_all_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    float data  = adc_read_core_vref(&self->handle);
+    float data = adc_read_core_vref(&self->handle);
     return mp_obj_new_float(data);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(adc_all_read_core_vref_obj, adc_all_read_core_vref);
@@ -824,11 +848,11 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(adc_all_read_vref_obj, adc_all_read_vref);
 STATIC const mp_rom_map_elem_t adc_all_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_read_channel), MP_ROM_PTR(&adc_all_read_channel_obj) },
     { MP_ROM_QSTR(MP_QSTR_read_core_temp), MP_ROM_PTR(&adc_all_read_core_temp_obj) },
-#if MICROPY_PY_BUILTINS_FLOAT
+    #if MICROPY_PY_BUILTINS_FLOAT
     { MP_ROM_QSTR(MP_QSTR_read_core_vbat), MP_ROM_PTR(&adc_all_read_core_vbat_obj) },
     { MP_ROM_QSTR(MP_QSTR_read_core_vref), MP_ROM_PTR(&adc_all_read_core_vref_obj) },
     { MP_ROM_QSTR(MP_QSTR_read_vref), MP_ROM_PTR(&adc_all_read_vref_obj) },
-#endif
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(adc_all_locals_dict, adc_all_locals_dict_table);
@@ -837,7 +861,7 @@ const mp_obj_type_t pyb_adc_all_type = {
     { &mp_type_type },
     .name = MP_QSTR_ADCAll,
     .make_new = adc_all_make_new,
-    .locals_dict = (mp_obj_dict_t*)&adc_all_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&adc_all_locals_dict,
 };
 
 #endif // MICROPY_HW_ENABLE_ADC
diff --git a/ports/stm32/boards/ADAFRUIT_F405_EXPRESS/mpconfigboard.h b/ports/stm32/boards/ADAFRUIT_F405_EXPRESS/mpconfigboard.h
new file mode 100644
index 0000000000000..36d1d31315e38
--- /dev/null
+++ b/ports/stm32/boards/ADAFRUIT_F405_EXPRESS/mpconfigboard.h
@@ -0,0 +1,86 @@
+#define MICROPY_HW_BOARD_NAME       "Adafruit Feather STM32F405"
+#define MICROPY_HW_MCU_NAME         "STM32F405RG"
+
+#define MICROPY_HW_HAS_SWITCH       (0)
+#define MICROPY_HW_HAS_FLASH        (1)
+#define MICROPY_HW_HAS_MMA7660      (0)
+#define MICROPY_HW_HAS_LCD          (0)
+#define MICROPY_HW_ENABLE_RNG       (1)
+#define MICROPY_HW_ENABLE_RTC       (1)
+#define MICROPY_HW_ENABLE_SERVO     (1)
+#define MICROPY_HW_ENABLE_DAC       (1)
+#define MICROPY_HW_ENABLE_USB       (1)
+#define MICROPY_HW_ENABLE_SDCARD    (1)
+
+// HSE is 12MHz
+#define MICROPY_HW_CLK_PLLM (12)
+#define MICROPY_HW_CLK_PLLN (336)
+#define MICROPY_HW_CLK_PLLP (RCC_PLLP_DIV2)
+#define MICROPY_HW_CLK_PLLQ (7)
+#define MICROPY_HW_CLK_LAST_FREQ (1)
+
+// The Feather has a 32kHz crystal for the RTC
+#define MICROPY_HW_RTC_USE_LSE      (1)
+#define MICROPY_HW_RTC_USE_US       (0)
+#define MICROPY_HW_RTC_USE_CALOUT   (1)
+
+// UART config
+#define MICROPY_HW_UART3_NAME   "UART3"    // on RX / TX
+#define MICROPY_HW_UART3_TX     (pin_B10)  // TX
+#define MICROPY_HW_UART3_RX     (pin_B11)  // RX
+#define MICROPY_HW_UART3_RTS    (pin_B14)  // MISO
+#define MICROPY_HW_UART3_CTS    (pin_B13)  // SCK
+
+#define MICROPY_HW_UART2_NAME   "UART2"   // on SDA/SCL
+#define MICROPY_HW_UART2_TX     (pin_B6)  // SCL
+#define MICROPY_HW_UART2_RX     (pin_B7)  // SDA
+
+#define MICROPY_HW_UART6_NAME   "UART6"   // on D5/D6
+#define MICROPY_HW_UART6_TX     (pin_C6)  // D6
+#define MICROPY_HW_UART6_RX     (pin_C7)  // D5
+
+// I2C busses
+#define MICROPY_HW_I2C1_NAME "I2C1"
+#define MICROPY_HW_I2C1_SCL (pin_B6)  // SCL
+#define MICROPY_HW_I2C1_SDA (pin_B7)  // SDA
+#define MICROPY_HW_I2C2_NAME "I2C2"
+#define MICROPY_HW_I2C2_SCL (pin_B10)  // TX
+#define MICROPY_HW_I2C2_SDA (pin_B11)  // RX
+
+// SPI busses
+#define MICROPY_HW_SPI1_NAME "SPIFLASH"
+#define MICROPY_HW_SPI1_NSS  (pin_A15) // FLASH CS
+#define MICROPY_HW_SPI1_SCK  (pin_B3) // FLASH CLK
+#define MICROPY_HW_SPI1_MISO (pin_B4) // FLASH MISO
+#define MICROPY_HW_SPI1_MOSI (pin_B5) // FLASH MOSI
+#define MICROPY_HW_SPI2_NAME "SPI1"
+#define MICROPY_HW_SPI2_NSS  (pin_B12) // SD DETECT
+#define MICROPY_HW_SPI2_SCK  (pin_B13) // SCK
+#define MICROPY_HW_SPI2_MISO (pin_B14) // MISO
+#define MICROPY_HW_SPI2_MOSI (pin_B15) // MOSI
+
+// CAN busses
+#define MICROPY_HW_CAN1_NAME "CAN1"
+#define MICROPY_HW_CAN1_TX   (pin_B9) // D10
+#define MICROPY_HW_CAN1_RX   (pin_B8) // D9
+
+// The Feather has 1 LED
+#define MICROPY_HW_LED1             (pin_C1) // red
+#define MICROPY_HW_LED_ON(pin)      (mp_hal_pin_high(pin))
+#define MICROPY_HW_LED_OFF(pin)     (mp_hal_pin_low(pin))
+
+// SD card detect switch
+#define MICROPY_HW_SDCARD_DETECT_PIN        (pin_B12)
+#define MICROPY_HW_SDCARD_DETECT_PULL       (GPIO_PULLUP)
+#define MICROPY_HW_SDCARD_DETECT_PRESENT    (GPIO_PIN_RESET)
+
+// USB config
+#define MICROPY_HW_USB_FS              (1)
+#define MICROPY_HW_USB_VBUS_DETECT_PIN (pin_A9)
+#define MICROPY_HW_USB_OTG_ID_PIN      (pin_A10)
+
+// Bootloader configuration (only needed if Mboot is used)
+#define MBOOT_I2C_PERIPH_ID 1
+#define MBOOT_I2C_SCL (pin_B8)
+#define MBOOT_I2C_SDA (pin_B9)
+#define MBOOT_I2C_ALTFUNC (4)
diff --git a/ports/stm32/boards/ADAFRUIT_F405_EXPRESS/mpconfigboard.mk b/ports/stm32/boards/ADAFRUIT_F405_EXPRESS/mpconfigboard.mk
new file mode 100644
index 0000000000000..a4430cc1df0e4
--- /dev/null
+++ b/ports/stm32/boards/ADAFRUIT_F405_EXPRESS/mpconfigboard.mk
@@ -0,0 +1,13 @@
+MCU_SERIES = f4
+CMSIS_MCU = STM32F405xx
+AF_FILE = boards/stm32f405_af.csv
+ifeq ($(USE_MBOOT),1)
+# When using Mboot all the text goes together after the filesystem
+LD_FILES = boards/stm32f405.ld boards/common_blifs.ld
+TEXT0_ADDR = 0x08020000
+else
+# When not using Mboot the ISR text goes first, then the rest after the filesystem
+LD_FILES = boards/stm32f405.ld boards/common_ifs.ld
+TEXT0_ADDR = 0x08000000
+TEXT1_ADDR = 0x08020000
+endif
diff --git a/ports/stm32/boards/ADAFRUIT_F405_EXPRESS/pins.csv b/ports/stm32/boards/ADAFRUIT_F405_EXPRESS/pins.csv
new file mode 100644
index 0000000000000..15e810e1ae546
--- /dev/null
+++ b/ports/stm32/boards/ADAFRUIT_F405_EXPRESS/pins.csv
@@ -0,0 +1,48 @@
+POWER,3.3V
+GND,GND
+USB_ID,PA10
+USB_DM,PA11
+USB_DP,PA12
+SWDIO,PA13
+SWCLK,PA14
+FLASH_CS,PA15
+BATTERY_MONITOR,PA3
+A0,PA4
+A1,PA5
+A2,PA6
+A3,PA7
+USB_VBUS,PA9
+TX,PB10
+D1,PB10
+RX,PB11
+D0,PB11
+SD_DETECT,PB12
+SCK,PB13
+MISO,PB14
+MOSI,PB15
+BOOT1,PB2
+FLASH_SCK,PB3
+FLASH_MISO,PB4
+FLASH_MOSI,PB5
+SCL,PB6
+SDA,PB7
+D9,PB8
+D10,PB9
+D8,PC0
+NEOPIXEL,PC0
+D13,PC1
+SD_D2,PC10
+SD_D3,PC11
+SD_CK,PC12
+D12,PC2
+D11,PC3
+A4,PC4
+A5,PC5
+D6,PC6
+D5,PC7
+SD_D0,PC8
+SD_D1,PC9
+SD_CMD,PD2
+NC_A0,PA0
+NC_A1,PA1
+NC_A2,PA2
diff --git a/ports/stm32/boards/ADAFRUIT_F405_EXPRESS/stm32f4xx_hal_conf.h b/ports/stm32/boards/ADAFRUIT_F405_EXPRESS/stm32f4xx_hal_conf.h
new file mode 100644
index 0000000000000..9719157e55cdf
--- /dev/null
+++ b/ports/stm32/boards/ADAFRUIT_F405_EXPRESS/stm32f4xx_hal_conf.h
@@ -0,0 +1,19 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+
+#include "boards/stm32f4xx_hal_conf_base.h"
+
+// Oscillator values in Hz
+#define HSE_VALUE (12000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/B_L072Z_LRWAN1/mpconfigboard.h b/ports/stm32/boards/B_L072Z_LRWAN1/mpconfigboard.h
new file mode 100644
index 0000000000000..531794de66f1b
--- /dev/null
+++ b/ports/stm32/boards/B_L072Z_LRWAN1/mpconfigboard.h
@@ -0,0 +1,70 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * MIT License; Copyright (c) 2019 Damien P. George
+ */
+
+#define MICROPY_HW_BOARD_NAME       "B-L072Z-LRWAN1"
+#define MICROPY_HW_MCU_NAME         "STM32L072CZ"
+
+#define MICROPY_EMIT_THUMB          (0)
+#define MICROPY_EMIT_INLINE_THUMB   (0)
+#define MICROPY_PY_BUILTINS_COMPLEX (0)
+#define MICROPY_PY_GENERATOR_PEND_THROW (0)
+#define MICROPY_PY_MATH             (0)
+#define MICROPY_PY_FRAMEBUF         (0)
+#define MICROPY_PY_USOCKET          (0)
+#define MICROPY_PY_NETWORK          (0)
+#define MICROPY_PY_STM              (0)
+#define MICROPY_PY_PYB_LEGACY       (0)
+#define MICROPY_PY_UHEAPQ           (0)
+#define MICROPY_PY_UTIMEQ           (0)
+
+#define MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE (0)
+#define MICROPY_HW_ENABLE_RTC       (1)
+#define MICROPY_HW_ENABLE_ADC       (0)
+#define MICROPY_HW_ENABLE_USB       (1)
+#define MICROPY_HW_HAS_SWITCH       (1)
+
+// UART config
+#define MICROPY_HW_UART1_TX         (pin_A9)
+#define MICROPY_HW_UART1_RX         (pin_A10)
+#define MICROPY_HW_UART2_TX         (pin_A2)
+#define MICROPY_HW_UART2_RX         (pin_A3)
+
+// USART2 is connected to the ST-LINK USB VCP
+#define MICROPY_HW_UART_REPL        PYB_UART_2
+#define MICROPY_HW_UART_REPL_BAUD   115200
+
+// I2C busses
+#define MICROPY_HW_I2C1_SCL         (pin_B8)
+#define MICROPY_HW_I2C1_SDA         (pin_B9)
+
+// SPI busses
+#define MICROPY_HW_SPI1_NSS         (pin_A15)
+#define MICROPY_HW_SPI1_SCK         (pin_A5)
+#define MICROPY_HW_SPI1_MISO        (pin_A6)
+#define MICROPY_HW_SPI1_MOSI        (pin_A7)
+#define MICROPY_HW_SPI2_NSS         (pin_B12)
+#define MICROPY_HW_SPI2_SCK         (pin_B13)
+#define MICROPY_HW_SPI2_MISO        (pin_B14)
+#define MICROPY_HW_SPI2_MOSI        (pin_B15)
+
+// USER B1 has a pull-up and is active low
+#define MICROPY_HW_USRSW_PIN        (pin_B2)
+#define MICROPY_HW_USRSW_PULL       (0)
+#define MICROPY_HW_USRSW_EXTI_MODE  (GPIO_MODE_IT_FALLING)
+#define MICROPY_HW_USRSW_PRESSED    (0)
+
+// 4 user LEDs
+#define MICROPY_HW_LED1             (pin_B5) // Green
+#define MICROPY_HW_LED2             (pin_A5) // Green (next to power LED)
+#define MICROPY_HW_LED3             (pin_B6) // Blue
+#define MICROPY_HW_LED4             (pin_B7) // Red
+#define MICROPY_HW_LED_ON(pin)      (mp_hal_pin_high(pin))
+#define MICROPY_HW_LED_OFF(pin)     (mp_hal_pin_low(pin))
+
+// USB config (need to bridge SB15/SB16)
+#define MICROPY_HW_USB_FS           (1)
+#define MICROPY_HW_USB_MSC          (0)
+#define MICROPY_HW_USB_HID          (0)
+#define USBD_CDC_RX_DATA_SIZE       (256)
+#define USBD_CDC_TX_DATA_SIZE       (256)
diff --git a/ports/stm32/boards/B_L072Z_LRWAN1/mpconfigboard.mk b/ports/stm32/boards/B_L072Z_LRWAN1/mpconfigboard.mk
new file mode 100644
index 0000000000000..03561f90ade3b
--- /dev/null
+++ b/ports/stm32/boards/B_L072Z_LRWAN1/mpconfigboard.mk
@@ -0,0 +1,11 @@
+MCU_SERIES = l0
+CMSIS_MCU = STM32L072xx
+MICROPY_FLOAT_IMPL = none
+AF_FILE = boards/stm32l072_af.csv
+LD_FILES = boards/stm32l072xz.ld boards/common_basic.ld
+
+# MicroPython settings
+MICROPY_VFS_FAT = 0
+
+# Don't include default frozen modules because MCU is tight on flash space
+FROZEN_MANIFEST ?=
diff --git a/ports/stm32/boards/B_L072Z_LRWAN1/pins.csv b/ports/stm32/boards/B_L072Z_LRWAN1/pins.csv
new file mode 100644
index 0000000000000..e54b8b818a89e
--- /dev/null
+++ b/ports/stm32/boards/B_L072Z_LRWAN1/pins.csv
@@ -0,0 +1,51 @@
+D0,PA3
+D1,PA2
+D2,PA10
+D3,PB13
+D4,PB5
+D5,PB7
+D6,PB2
+D7,PA8
+D8,PA9
+D9,PB12
+D10,PB6
+D11,PB15
+D12,PB14
+D13,PB13
+D14,PB9
+D15,PB8
+A0,PA0
+A2,PA4
+USER_B1,PB2
+LED2,PA5
+LED1,PB5
+LED3,PB6
+LED4,PB7
+LED_GREEN,PB5
+LED_BLUE,PB6
+LED_RED,PB7
+,PA0
+,PA2
+,PA3
+,PA4
+,PA5
+,PA6
+,PA7
+,PA8
+,PA9
+,PA10
+,PA11
+,PA12
+,PA13
+,PA14
+,PA15
+,PB2
+,PB5
+,PB6
+,PB7
+,PB8
+,PB9
+,PB12
+,PB13
+,PB14
+,PB15
diff --git a/ports/stm32/boards/B_L072Z_LRWAN1/stm32l0xx_hal_conf.h b/ports/stm32/boards/B_L072Z_LRWAN1/stm32l0xx_hal_conf.h
new file mode 100644
index 0000000000000..c88a7065103d3
--- /dev/null
+++ b/ports/stm32/boards/B_L072Z_LRWAN1/stm32l0xx_hal_conf.h
@@ -0,0 +1,18 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32L0XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32L0XX_HAL_CONF_H
+
+#include "boards/stm32l0xx_hal_conf_base.h"
+
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#endif // MICROPY_INCLUDED_STM32L0XX_HAL_CONF_H
diff --git a/ports/stm32/boards/B_L475E_IOT01A/mpconfigboard.h b/ports/stm32/boards/B_L475E_IOT01A/mpconfigboard.h
index 3ab3d5fa1719d..a88bcf675685e 100644
--- a/ports/stm32/boards/B_L475E_IOT01A/mpconfigboard.h
+++ b/ports/stm32/boards/B_L475E_IOT01A/mpconfigboard.h
@@ -12,9 +12,11 @@
 #define MICROPY_HW_CLK_PLLP (RCC_PLLP_DIV7)
 #define MICROPY_HW_CLK_PLLR (RCC_PLLR_DIV2)
 #define MICROPY_HW_CLK_PLLQ (RCC_PLLQ_DIV4)
-
 #define MICROPY_HW_FLASH_LATENCY    FLASH_LATENCY_4
 
+// The board has an external 32kHz crystal
+#define MICROPY_HW_RTC_USE_LSE      (1)
+
 // USART1 config connected to ST-Link
 #define MICROPY_HW_UART1_TX     (pin_B6)
 #define MICROPY_HW_UART1_RX     (pin_B7)
diff --git a/ports/stm32/boards/B_L475E_IOT01A/mpconfigboard.mk b/ports/stm32/boards/B_L475E_IOT01A/mpconfigboard.mk
index 55e443e919ac0..137b6be23d01a 100644
--- a/ports/stm32/boards/B_L475E_IOT01A/mpconfigboard.mk
+++ b/ports/stm32/boards/B_L475E_IOT01A/mpconfigboard.mk
@@ -1,9 +1,7 @@
 MCU_SERIES = l4
 CMSIS_MCU = STM32L475xx
 # The stm32l475 does not have a LDC controller which is
-# the only diffrence to the stm32l476 - so reuse some files.
+# the only difference to the stm32l476 - so reuse some files.
 AF_FILE = boards/stm32l476_af.csv
-LD_FILES = boards/stm32l476xg.ld boards/common_ifs.ld
-TEXT0_ADDR = 0x08000000
-TEXT1_ADDR = 0x08004000
+LD_FILES = boards/stm32l476xg.ld boards/common_basic.ld
 OPENOCD_CONFIG = boards/openocd_stm32l4.cfg
diff --git a/ports/stm32/boards/B_L475E_IOT01A/stm32l4xx_hal_conf.h b/ports/stm32/boards/B_L475E_IOT01A/stm32l4xx_hal_conf.h
index 6bfb28118a44b..fd380ab7357e2 100644
--- a/ports/stm32/boards/B_L475E_IOT01A/stm32l4xx_hal_conf.h
+++ b/ports/stm32/boards/B_L475E_IOT01A/stm32l4xx_hal_conf.h
@@ -1,372 +1,20 @@
-/**
-  ******************************************************************************
-  * @file    stm32l4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.2.0
-  * @date    25-November-2015
-  * @brief   HAL configuration template file.
-  *          This file should be copied to the application folder and renamed
-  *          to stm32l4xx_hal_conf.h.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
-
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32L4xx_HAL_CONF_H
-#define __STM32L4xx_HAL_CONF_H
-
-#ifdef __cplusplus
- extern "C" {
-#endif
-
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
-
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_COMP_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DFSDM_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_FIREWALL_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LCD_MODULE_ENABLED */
-/* #define HAL_LPTIM_MODULE_ENABLED */
-/* #define HAL_OPAMP_MODULE_ENABLED */
-#define HAL_PCD_MODULE_ENABLED
-#define HAL_PWR_MODULE_ENABLED
-/* #define HAL_QSPI_MODULE_ENABLED */
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_SMBUS_MODULE_ENABLED */
-#define HAL_SPI_MODULE_ENABLED
-/* #define HAL_SWPMI_MODULE_ENABLED */
-#define HAL_TIM_MODULE_ENABLED
-/* #define HAL_TSC_MODULE_ENABLED */
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-
-
-/* ########################## Oscillator Values adaptation ####################*/
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).  
-  */
-#if !defined  (HSE_VALUE) 
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal Multiple Speed oscillator (MSI) default value.
-  *        This value is the default MSI range value after Reset.
-  */
-#if !defined  (MSI_VALUE)
-  #define MSI_VALUE    ((uint32_t)4000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* MSI_VALUE */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL). 
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE) 
- #define LSI_VALUE  ((uint32_t)32000)       /*!< LSI Typical Value in Hz*/
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  *        This value is used by the UART, RTC HAL module to compute the system frequency
-  */
-#if !defined  (LSE_VALUE)
-  #define LSE_VALUE    ((uint32_t)32768) /*!< Value of the External oscillator in Hz*/
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000)   /*!< Time out for LSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for SAI1 peripheral
-  *        This value is used by the RCC HAL module to compute the SAI1 & SAI2 clock source 
-  *        frequency.
-  */
-#if !defined  (EXTERNAL_SAI1_CLOCK_VALUE)
-  #define EXTERNAL_SAI1_CLOCK_VALUE    ((uint32_t)48000) /*!< Value of the SAI1 External clock source in Hz*/
-#endif /* EXTERNAL_SAI1_CLOCK_VALUE */
-
-/**
-  * @brief External clock source for SAI2 peripheral
-  *        This value is used by the RCC HAL module to compute the SAI1 & SAI2 clock source 
-  *        frequency.
-  */
-#if !defined  (EXTERNAL_SAI2_CLOCK_VALUE)
-  #define EXTERNAL_SAI2_CLOCK_VALUE    ((uint32_t)48000) /*!< Value of the SAI2 External clock source in Hz*/
-#endif /* EXTERNAL_SAI2_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32l4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32l4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32l4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_DFSDM_MODULE_ENABLED
-  #include "stm32l4xx_hal_dfsdm.h"
-#endif /* HAL_DFSDM_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32l4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32l4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32l4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_COMP_MODULE_ENABLED
-  #include "stm32l4xx_hal_comp.h"
-#endif /* HAL_COMP_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32l4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32l4xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32l4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_FIREWALL_MODULE_ENABLED
-  #include "stm32l4xx_hal_firewall.h"
-#endif /* HAL_FIREWALL_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32l4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32l4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32l4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32l4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32l4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32l4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LCD_MODULE_ENABLED
- #include "stm32l4xx_hal_lcd.h"
-#endif /* HAL_LCD_MODULE_ENABLED */
-
-#ifdef HAL_LPTIM_MODULE_ENABLED
-#include "stm32l4xx_hal_lptim.h"
-#endif /* HAL_LPTIM_MODULE_ENABLED */
-
-#ifdef HAL_OPAMP_MODULE_ENABLED
-#include "stm32l4xx_hal_opamp.h"
-#endif /* HAL_OPAMP_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32l4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_QSPI_MODULE_ENABLED
- #include "stm32l4xx_hal_qspi.h"
-#endif /* HAL_QSPI_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32l4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32l4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32l4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32l4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SMBUS_MODULE_ENABLED
- #include "stm32l4xx_hal_smbus.h"
-#endif /* HAL_SMBUS_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32l4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_SWPMI_MODULE_ENABLED
- #include "stm32l4xx_hal_swpmi.h"
-#endif /* HAL_SWPMI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32l4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_TSC_MODULE_ENABLED
- #include "stm32l4xx_hal_tsc.h"
-#endif /* HAL_TSC_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32l4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32l4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32l4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32l4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32l4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32l4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32l4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32L4xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
+
+#include "boards/stm32l4xx_hal_conf_base.h"
+
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_SAI1_CLOCK_VALUE (48000)
+#define EXTERNAL_SAI2_CLOCK_VALUE (48000)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#endif // MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/CERB40/stm32f4xx_hal_conf.h b/ports/stm32/boards/CERB40/stm32f4xx_hal_conf.h
index e71ba33697721..9719157e55cdf 100644
--- a/ports/stm32/boards/CERB40/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/CERB40/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (12000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_I2S_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSE_VALUE)
-  #define HSE_VALUE    ((uint32_t)12000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE)
- #define LSI_VALUE  ((uint32_t)40000)
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source
-  *        frequency, this source is inserted directly through I2S_CKIN pad.
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
-
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
-
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */
-
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/ESPRUINO_PICO/mpconfigboard.mk b/ports/stm32/boards/ESPRUINO_PICO/mpconfigboard.mk
index 16cacc089e11f..d40825ec854ce 100644
--- a/ports/stm32/boards/ESPRUINO_PICO/mpconfigboard.mk
+++ b/ports/stm32/boards/ESPRUINO_PICO/mpconfigboard.mk
@@ -6,4 +6,4 @@ TEXT0_ADDR = 0x08000000
 TEXT1_ADDR = 0x08020000
 
 # Don't include default frozen modules because MCU is tight on flash space
-FROZEN_MPY_DIR ?=
+FROZEN_MANIFEST ?=
diff --git a/ports/stm32/boards/ESPRUINO_PICO/stm32f4xx_hal_conf.h b/ports/stm32/boards/ESPRUINO_PICO/stm32f4xx_hal_conf.h
index d27e2e9ef0819..de19251e0808a 100644
--- a/ports/stm32/boards/ESPRUINO_PICO/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/ESPRUINO_PICO/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-/* #define HAL_CAN_MODULE_ENABLED */
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-/* #define HAL_DAC_MODULE_ENABLED */
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_I2S_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-/* #define HAL_SD_MODULE_ENABLED */
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSE_VALUE)
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE)
- #define LSI_VALUE  ((uint32_t)40000)
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source
-  *        frequency, this source is inserted directly through I2S_CKIN pad.
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
-
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
-
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */
-
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/HYDRABUS/stm32f4xx_hal_conf.h b/ports/stm32/boards/HYDRABUS/stm32f4xx_hal_conf.h
index daf9b63ceca01..de19251e0808a 100644
--- a/ports/stm32/boards/HYDRABUS/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/HYDRABUS/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_I2S_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSE_VALUE)
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE)
- #define LSI_VALUE  ((uint32_t)40000)
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source
-  *        frequency, this source is inserted directly through I2S_CKIN pad.
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
-
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
-
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */
-
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/LIMIFROG/mpconfigboard.h b/ports/stm32/boards/LIMIFROG/mpconfigboard.h
index d27c2e66ef77d..4b750c17ff4f6 100644
--- a/ports/stm32/boards/LIMIFROG/mpconfigboard.h
+++ b/ports/stm32/boards/LIMIFROG/mpconfigboard.h
@@ -16,9 +16,11 @@ void LIMIFROG_board_early_init(void);
 #define MICROPY_HW_CLK_PLLP (RCC_PLLP_DIV7)
 #define MICROPY_HW_CLK_PLLR (RCC_PLLR_DIV2)
 #define MICROPY_HW_CLK_PLLQ (RCC_PLLQ_DIV2)
-
 #define MICROPY_HW_FLASH_LATENCY    FLASH_LATENCY_4
 
+// The board has an external 32kHz crystal
+#define MICROPY_HW_RTC_USE_LSE      (1)
+
 // USART config
 #define MICROPY_HW_UART3_TX (pin_C10)
 #define MICROPY_HW_UART3_RX (pin_C11)
diff --git a/ports/stm32/boards/LIMIFROG/mpconfigboard.mk b/ports/stm32/boards/LIMIFROG/mpconfigboard.mk
index 2adc98f0b1c90..ef1ec93b0b563 100644
--- a/ports/stm32/boards/LIMIFROG/mpconfigboard.mk
+++ b/ports/stm32/boards/LIMIFROG/mpconfigboard.mk
@@ -1,6 +1,4 @@
 MCU_SERIES = l4
 CMSIS_MCU = STM32L476xx
 AF_FILE = boards/stm32l476_af.csv
-LD_FILES = boards/stm32l476xe.ld boards/common_ifs.ld
-TEXT0_ADDR = 0x08000000
-TEXT1_ADDR = 0x08004000
+LD_FILES = boards/stm32l476xe.ld boards/common_basic.ld
diff --git a/ports/stm32/boards/LIMIFROG/stm32l4xx_hal_conf.h b/ports/stm32/boards/LIMIFROG/stm32l4xx_hal_conf.h
index 6bfb28118a44b..fd380ab7357e2 100644
--- a/ports/stm32/boards/LIMIFROG/stm32l4xx_hal_conf.h
+++ b/ports/stm32/boards/LIMIFROG/stm32l4xx_hal_conf.h
@@ -1,372 +1,20 @@
-/**
-  ******************************************************************************
-  * @file    stm32l4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.2.0
-  * @date    25-November-2015
-  * @brief   HAL configuration template file.
-  *          This file should be copied to the application folder and renamed
-  *          to stm32l4xx_hal_conf.h.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
-
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32L4xx_HAL_CONF_H
-#define __STM32L4xx_HAL_CONF_H
-
-#ifdef __cplusplus
- extern "C" {
-#endif
-
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
-
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_COMP_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DFSDM_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_FIREWALL_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LCD_MODULE_ENABLED */
-/* #define HAL_LPTIM_MODULE_ENABLED */
-/* #define HAL_OPAMP_MODULE_ENABLED */
-#define HAL_PCD_MODULE_ENABLED
-#define HAL_PWR_MODULE_ENABLED
-/* #define HAL_QSPI_MODULE_ENABLED */
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_SMBUS_MODULE_ENABLED */
-#define HAL_SPI_MODULE_ENABLED
-/* #define HAL_SWPMI_MODULE_ENABLED */
-#define HAL_TIM_MODULE_ENABLED
-/* #define HAL_TSC_MODULE_ENABLED */
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-
-
-/* ########################## Oscillator Values adaptation ####################*/
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).  
-  */
-#if !defined  (HSE_VALUE) 
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal Multiple Speed oscillator (MSI) default value.
-  *        This value is the default MSI range value after Reset.
-  */
-#if !defined  (MSI_VALUE)
-  #define MSI_VALUE    ((uint32_t)4000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* MSI_VALUE */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL). 
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE) 
- #define LSI_VALUE  ((uint32_t)32000)       /*!< LSI Typical Value in Hz*/
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  *        This value is used by the UART, RTC HAL module to compute the system frequency
-  */
-#if !defined  (LSE_VALUE)
-  #define LSE_VALUE    ((uint32_t)32768) /*!< Value of the External oscillator in Hz*/
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000)   /*!< Time out for LSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for SAI1 peripheral
-  *        This value is used by the RCC HAL module to compute the SAI1 & SAI2 clock source 
-  *        frequency.
-  */
-#if !defined  (EXTERNAL_SAI1_CLOCK_VALUE)
-  #define EXTERNAL_SAI1_CLOCK_VALUE    ((uint32_t)48000) /*!< Value of the SAI1 External clock source in Hz*/
-#endif /* EXTERNAL_SAI1_CLOCK_VALUE */
-
-/**
-  * @brief External clock source for SAI2 peripheral
-  *        This value is used by the RCC HAL module to compute the SAI1 & SAI2 clock source 
-  *        frequency.
-  */
-#if !defined  (EXTERNAL_SAI2_CLOCK_VALUE)
-  #define EXTERNAL_SAI2_CLOCK_VALUE    ((uint32_t)48000) /*!< Value of the SAI2 External clock source in Hz*/
-#endif /* EXTERNAL_SAI2_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32l4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32l4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32l4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_DFSDM_MODULE_ENABLED
-  #include "stm32l4xx_hal_dfsdm.h"
-#endif /* HAL_DFSDM_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32l4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32l4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32l4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_COMP_MODULE_ENABLED
-  #include "stm32l4xx_hal_comp.h"
-#endif /* HAL_COMP_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32l4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32l4xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32l4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_FIREWALL_MODULE_ENABLED
-  #include "stm32l4xx_hal_firewall.h"
-#endif /* HAL_FIREWALL_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32l4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32l4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32l4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32l4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32l4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32l4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LCD_MODULE_ENABLED
- #include "stm32l4xx_hal_lcd.h"
-#endif /* HAL_LCD_MODULE_ENABLED */
-
-#ifdef HAL_LPTIM_MODULE_ENABLED
-#include "stm32l4xx_hal_lptim.h"
-#endif /* HAL_LPTIM_MODULE_ENABLED */
-
-#ifdef HAL_OPAMP_MODULE_ENABLED
-#include "stm32l4xx_hal_opamp.h"
-#endif /* HAL_OPAMP_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32l4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_QSPI_MODULE_ENABLED
- #include "stm32l4xx_hal_qspi.h"
-#endif /* HAL_QSPI_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32l4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32l4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32l4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32l4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SMBUS_MODULE_ENABLED
- #include "stm32l4xx_hal_smbus.h"
-#endif /* HAL_SMBUS_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32l4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_SWPMI_MODULE_ENABLED
- #include "stm32l4xx_hal_swpmi.h"
-#endif /* HAL_SWPMI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32l4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_TSC_MODULE_ENABLED
- #include "stm32l4xx_hal_tsc.h"
-#endif /* HAL_TSC_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32l4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32l4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32l4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32l4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32l4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32l4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32l4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32L4xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
+
+#include "boards/stm32l4xx_hal_conf_base.h"
+
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_SAI1_CLOCK_VALUE (48000)
+#define EXTERNAL_SAI2_CLOCK_VALUE (48000)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#endif // MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/MIKROE_CLICKER2_STM32/mpconfigboard.h b/ports/stm32/boards/MIKROE_CLICKER2_STM32/mpconfigboard.h
new file mode 100644
index 0000000000000..eb622cd296a84
--- /dev/null
+++ b/ports/stm32/boards/MIKROE_CLICKER2_STM32/mpconfigboard.h
@@ -0,0 +1,85 @@
+#define MICROPY_HW_BOARD_NAME       "MIKROE_CLICKER2_STM32"
+#define MICROPY_HW_MCU_NAME         "STM32F407"
+
+#define MICROPY_HW_HAS_SWITCH       (1)
+#define MICROPY_HW_HAS_FLASH        (1)
+#define MICROPY_HW_ENABLE_RNG       (1)
+#define MICROPY_HW_ENABLE_RTC       (1)
+#define MICROPY_HW_ENABLE_DAC       (1)
+#define MICROPY_HW_ENABLE_USB       (1)
+
+// HSE is 25MHz
+#define MICROPY_HW_CLK_PLLM         (25)
+#define MICROPY_HW_CLK_PLLN         (336)
+#define MICROPY_HW_CLK_PLLP         (RCC_PLLP_DIV2)
+#define MICROPY_HW_CLK_PLLQ         (7)
+#define MICROPY_HW_CLK_LAST_FREQ    (1)
+
+// The board has a 32kHz crystal for the RTC
+#define MICROPY_HW_RTC_USE_LSE      (1)
+#define MICROPY_HW_RTC_USE_US       (0)
+#define MICROPY_HW_RTC_USE_CALOUT   (0)  // turn on/off PC13 512Hz output
+
+// UART config
+// mikroBUS slot 1
+#define MICROPY_HW_UART2_NAME       "SLOT1"
+#define MICROPY_HW_UART2_TX         (pin_D5)
+#define MICROPY_HW_UART2_RX         (pin_D6)
+// mikroBUS slot 2
+#define MICROPY_HW_UART3_NAME       "SLOT2"
+#define MICROPY_HW_UART3_TX         (pin_D8)
+#define MICROPY_HW_UART3_RX         (pin_D9)
+// HDR2
+#define MICROPY_HW_UART4_NAME       "HDR2"
+#define MICROPY_HW_UART4_TX         (pin_A0)
+#define MICROPY_HW_UART4_RX         (pin_A1)
+
+// I2C buses
+// mikroBUS slot 2 / HDR2
+#define MICROPY_HW_I2C2_NAME        "SLOT2"
+#define MICROPY_HW_I2C2_SCL         (pin_B10)
+#define MICROPY_HW_I2C2_SDA         (pin_B11)
+// mikroBUS slot 1
+#define MICROPY_HW_I2C3_NAME        "SLOT1"
+#define MICROPY_HW_I2C3_SCL         (pin_A8)
+#define MICROPY_HW_I2C3_SDA         (pin_C9)
+
+// SPI buses
+// mikroBUS slot 2 / HDR1
+#define MICROPY_HW_SPI2_NAME        "SLOT2"
+#define MICROPY_HW_SPI2_NSS         (pin_E11)
+#define MICROPY_HW_SPI2_SCK         (pin_B13)
+#define MICROPY_HW_SPI2_MISO        (pin_B14)
+#define MICROPY_HW_SPI2_MOSI        (pin_B15)
+// mikroBUS slot 1
+#define MICROPY_HW_SPI3_NAME        "SLOT1"
+#define MICROPY_HW_SPI3_NSS         (pin_E8)
+#define MICROPY_HW_SPI3_SCK         (pin_C10)
+#define MICROPY_HW_SPI3_MISO        (pin_C11)
+#define MICROPY_HW_SPI3_MOSI        (pin_C12)
+
+// USRSW is pulled high; pressing the button makes the input go low
+#define MICROPY_HW_USRSW_PIN        (pin_E0)
+#define MICROPY_HW_USRSW_PULL       (GPIO_NOPULL)
+#define MICROPY_HW_USRSW_EXTI_MODE  (GPIO_MODE_IT_FALLING)
+#define MICROPY_HW_USRSW_PRESSED    (0)
+
+// LEDs
+#define MICROPY_HW_LED1             (pin_E12) // red
+#define MICROPY_HW_LED2             (pin_E15) // red
+#define MICROPY_HW_LED_ON(pin)      (mp_hal_pin_high(pin))
+#define MICROPY_HW_LED_OFF(pin)     (mp_hal_pin_low(pin))
+
+// USB config
+#define MICROPY_HW_USB_FS              (1)
+#define MICROPY_HW_USB_VBUS_DETECT_PIN (pin_A9)
+
+// Bootloader configuration (only needed if Mboot is used)
+#define MBOOT_I2C_PERIPH_ID         2
+#define MBOOT_I2C_SCL               (pin_B10)
+#define MBOOT_I2C_SDA               (pin_B11)
+#define MBOOT_I2C_ALTFUNC           (4)
+#define MBOOT_BOOTPIN_PIN           (pin_A10)
+#define MBOOT_BOOTPIN_PULL          (MP_HAL_PIN_PULL_NONE)
+#define MBOOT_BOOTPIN_ACTIVE        (0)
+#define MBOOT_FSLOAD                (1)
diff --git a/ports/stm32/boards/MIKROE_CLICKER2_STM32/mpconfigboard.mk b/ports/stm32/boards/MIKROE_CLICKER2_STM32/mpconfigboard.mk
new file mode 100644
index 0000000000000..aa52f21162c31
--- /dev/null
+++ b/ports/stm32/boards/MIKROE_CLICKER2_STM32/mpconfigboard.mk
@@ -0,0 +1,13 @@
+MCU_SERIES = f4
+CMSIS_MCU = STM32F407xx
+AF_FILE = boards/stm32f405_af.csv
+ifeq ($(USE_MBOOT),1)
+# When using Mboot all the text goes together after the filesystem
+LD_FILES = boards/stm32f405.ld boards/common_blifs.ld
+TEXT0_ADDR = 0x08020000
+else
+# When not using Mboot the ISR text goes first, then the rest after the filesystem
+LD_FILES = boards/stm32f405.ld boards/common_ifs.ld
+TEXT0_ADDR = 0x08000000
+TEXT1_ADDR = 0x08020000
+endif
diff --git a/ports/stm32/boards/MIKROE_CLICKER2_STM32/pins.csv b/ports/stm32/boards/MIKROE_CLICKER2_STM32/pins.csv
new file mode 100644
index 0000000000000..09e1ccfb4b19b
--- /dev/null
+++ b/ports/stm32/boards/MIKROE_CLICKER2_STM32/pins.csv
@@ -0,0 +1,88 @@
+MB1_AN,PA2
+MB1_RST,PE7
+MB1_CS,PE8
+MB1_SCK,PC10
+MB1_MISO,PC11
+MB1_MOSI,PC12
+MB1_PWM,PE9
+MB1_INT,PE10
+MB1_RX,PD6
+MB1_TX,PD5
+MB1_SCL,PA8
+MB1_SDA,PC9
+MB2_AN,PA3
+MB2_RST,PE13
+MB2_CS,PE11
+MB2_SCK,PB13
+MB2_MISO,PB14
+MB2_MOSI,PB15
+MB2_PWM,PD12
+MB2_INT,PE14
+MB2_RX,PD9
+MB2_TX,PD8
+MB2_SCL,PB10
+MB2_SDA,PB11
+PIN1,VSYS
+PIN2,GND
+PIN3,PC0
+PIN4,PC1
+PIN5,PC2
+PIN6,PC3
+PIN7,PB1
+PIN8,PA4
+PIN9,PC4
+PIN10,PD3
+PIN11,PD1
+PIN12,PD2
+PIN13,PD0
+PIN14,PC8
+PIN15,PD15
+PIN16,PD14
+PIN17,PD13
+PIN18,PB7
+PIN19,PC7
+PIN20,PD11
+PIN21,PD10
+PIN22,PB13
+PIN23,PB14
+PIN24,PB15
+PIN25,3.3V
+PIN26,GND
+PIN27,RST
+PIN28,GND
+PIN30,NC
+PIN31,PB9
+PIN32,PB8
+PIN33,PE5
+PIN34,PB0
+PIN35,PA5
+PIN36,PA6
+PIN37,PA7
+PIN38,PE1
+PIN39,PE2
+PIN40,PE3
+PIN41,PE4
+PIN42,PE6
+PIN43,PB6
+PIN44,PB5
+PIN45,PD7
+PIN46,PC13
+PIN47,PA1
+PIN48,PA0
+PIN49,PB10
+PIN50,PB11
+PIN51,3.3V
+PIN52,GND
+OSC32_OUT,PC15
+OSC32_IN,PC14
+VSENSE,PC5
+SENSEL,PB12
+FAULT,PC6
+BATSTAT,PD4
+LD1,PE12
+LD2,PE15
+T2,PE0
+T3,PA10
+USB_VBUS,PA9
+USB_DM,PA11
+USB_DP,PA12
\ No newline at end of file
diff --git a/ports/stm32/boards/MIKROE_CLICKER2_STM32/stm32f4xx_hal_conf.h b/ports/stm32/boards/MIKROE_CLICKER2_STM32/stm32f4xx_hal_conf.h
new file mode 100644
index 0000000000000..f186d5a29228c
--- /dev/null
+++ b/ports/stm32/boards/MIKROE_CLICKER2_STM32/stm32f4xx_hal_conf.h
@@ -0,0 +1,19 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+
+#include "boards/stm32f4xx_hal_conf_base.h"
+
+// Oscillator values in Hz
+#define HSE_VALUE (25000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NADHAT_PYBF405/mpconfigboard.h b/ports/stm32/boards/NADHAT_PYBF405/mpconfigboard.h
new file mode 100644
index 0000000000000..c6f1a7bc6eb2b
--- /dev/null
+++ b/ports/stm32/boards/NADHAT_PYBF405/mpconfigboard.h
@@ -0,0 +1,105 @@
+#define MICROPY_HW_BOARD_NAME       "NADHAT_PYBF405"
+#define MICROPY_HW_MCU_NAME         "STM32F405RG"
+
+#define MICROPY_HW_HAS_SWITCH       (1)
+#define MICROPY_HW_HAS_FLASH        (1)
+#define MICROPY_HW_HAS_KXTJ3        (1)
+#define MICROPY_HW_HAS_LCD          (1)
+#define MICROPY_HW_ENABLE_RNG       (1)
+#define MICROPY_HW_ENABLE_RTC       (1)
+#define MICROPY_HW_ENABLE_SERVO     (1)
+#define MICROPY_HW_ENABLE_DAC       (1)
+#define MICROPY_HW_ENABLE_USB       (1)
+#define MICROPY_HW_ENABLE_SDCARD    (1)
+
+// HSE is 16MHz
+#define MICROPY_HW_CLK_PLLM         (16)
+#define MICROPY_HW_CLK_PLLN         (336)
+#define MICROPY_HW_CLK_PLLP         (RCC_PLLP_DIV2)
+#define MICROPY_HW_CLK_PLLQ         (7)
+#define MICROPY_HW_CLK_LAST_FREQ    (1)
+
+// The board has a 32kHz crystal for the RTC
+#define MICROPY_HW_RTC_USE_LSE      (1)
+#define MICROPY_HW_RTC_USE_US       (0)
+#define MICROPY_HW_RTC_USE_CALOUT   (1)
+
+// UART config
+#define MICROPY_HW_UART1_NAME       "XB"
+#define MICROPY_HW_UART1_TX         (pin_B6)
+#define MICROPY_HW_UART1_RX         (pin_B7)
+#define MICROPY_HW_UART2_TX         (pin_A2)
+#define MICROPY_HW_UART2_RX         (pin_A3)
+#define MICROPY_HW_UART2_RTS        (pin_A1)
+#define MICROPY_HW_UART2_CTS        (pin_A0)
+#define MICROPY_HW_UART3_NAME       "YB"
+#define MICROPY_HW_UART3_TX         (pin_B10)
+#define MICROPY_HW_UART3_RX         (pin_B11)
+#define MICROPY_HW_UART3_RTS        (pin_B14)
+#define MICROPY_HW_UART3_CTS        (pin_B13)
+#define MICROPY_HW_UART4_NAME       "XA"
+#define MICROPY_HW_UART4_TX         (pin_A0)
+#define MICROPY_HW_UART4_RX         (pin_A1)
+#define MICROPY_HW_UART6_NAME       "YA"
+#define MICROPY_HW_UART6_TX         (pin_C6)
+#define MICROPY_HW_UART6_RX         (pin_C7)
+
+// I2C buses
+#define MICROPY_HW_I2C1_NAME        "X"
+#define MICROPY_HW_I2C1_SCL         (pin_B6)
+#define MICROPY_HW_I2C1_SDA         (pin_B7)
+#define MICROPY_HW_I2C2_NAME        "Y"
+#define MICROPY_HW_I2C2_SCL         (pin_B10)
+#define MICROPY_HW_I2C2_SDA         (pin_B11)
+
+// SPI buses
+#define MICROPY_HW_SPI1_NAME        "X"
+#define MICROPY_HW_SPI1_NSS         (pin_A4) // X5
+#define MICROPY_HW_SPI1_SCK         (pin_A5) // X6
+#define MICROPY_HW_SPI1_MISO        (pin_A6) // X7
+#define MICROPY_HW_SPI1_MOSI        (pin_A7) // X8
+#define MICROPY_HW_SPI2_NAME        "Y"
+#define MICROPY_HW_SPI2_NSS         (pin_B12) // Y5
+#define MICROPY_HW_SPI2_SCK         (pin_B13) // Y6
+#define MICROPY_HW_SPI2_MISO        (pin_B14) // Y7
+#define MICROPY_HW_SPI2_MOSI        (pin_B15) // Y8
+
+// CAN buses
+#define MICROPY_HW_CAN1_NAME        "YA"
+#define MICROPY_HW_CAN1_TX          (pin_B9) // Y4
+#define MICROPY_HW_CAN1_RX          (pin_B8) // Y3
+#define MICROPY_HW_CAN2_NAME        "YB"
+#define MICROPY_HW_CAN2_TX          (pin_B13) // Y6
+#define MICROPY_HW_CAN2_RX          (pin_B12) // Y5
+
+// USRSW has no pullup or pulldown, and pressing the switch makes the input go low
+#define MICROPY_HW_USRSW_PIN        (pin_B3)
+#define MICROPY_HW_USRSW_PULL       (GPIO_PULLUP)
+#define MICROPY_HW_USRSW_EXTI_MODE  (GPIO_MODE_IT_FALLING)
+#define MICROPY_HW_USRSW_PRESSED    (0)
+
+// The board has 4 LEDs
+#define MICROPY_HW_LED1             (pin_A13) // red
+#define MICROPY_HW_LED2             (pin_A14) // green
+#define MICROPY_HW_LED3             (pin_A15) // yellow
+#define MICROPY_HW_LED4             (pin_B4)  // blue
+#define MICROPY_HW_LED3_PWM         { TIM2, 2, TIM_CHANNEL_1, GPIO_AF1_TIM2 }
+#define MICROPY_HW_LED4_PWM         { TIM3, 3, TIM_CHANNEL_1, GPIO_AF2_TIM3 }
+#define MICROPY_HW_LED_ON(pin)      (mp_hal_pin_high(pin))
+#define MICROPY_HW_LED_OFF(pin)     (mp_hal_pin_low(pin))
+
+// SD card detect switch
+#define MICROPY_HW_SDCARD_DETECT_PIN        (pin_A8)
+#define MICROPY_HW_SDCARD_DETECT_PULL       (GPIO_PULLUP)
+#define MICROPY_HW_SDCARD_DETECT_PRESENT    (GPIO_PIN_RESET)
+
+// USB config
+#define MICROPY_HW_USB_FS              (1)
+#define MICROPY_HW_USB_VBUS_DETECT_PIN (pin_A9)
+#define MICROPY_HW_USB_OTG_ID_PIN      (pin_A10)
+
+// Bootloader configuration (only needed if Mboot is used)
+#define MBOOT_I2C_PERIPH_ID         1
+#define MBOOT_I2C_SCL               (pin_B8)
+#define MBOOT_I2C_SDA               (pin_B9)
+#define MBOOT_I2C_ALTFUNC           (4)
diff --git a/ports/stm32/boards/NADHAT_PYBF405/mpconfigboard.mk b/ports/stm32/boards/NADHAT_PYBF405/mpconfigboard.mk
new file mode 100644
index 0000000000000..a4430cc1df0e4
--- /dev/null
+++ b/ports/stm32/boards/NADHAT_PYBF405/mpconfigboard.mk
@@ -0,0 +1,13 @@
+MCU_SERIES = f4
+CMSIS_MCU = STM32F405xx
+AF_FILE = boards/stm32f405_af.csv
+ifeq ($(USE_MBOOT),1)
+# When using Mboot all the text goes together after the filesystem
+LD_FILES = boards/stm32f405.ld boards/common_blifs.ld
+TEXT0_ADDR = 0x08020000
+else
+# When not using Mboot the ISR text goes first, then the rest after the filesystem
+LD_FILES = boards/stm32f405.ld boards/common_ifs.ld
+TEXT0_ADDR = 0x08000000
+TEXT1_ADDR = 0x08020000
+endif
diff --git a/ports/stm32/boards/NADHAT_PYBF405/pins.csv b/ports/stm32/boards/NADHAT_PYBF405/pins.csv
new file mode 100644
index 0000000000000..0a030e985c275
--- /dev/null
+++ b/ports/stm32/boards/NADHAT_PYBF405/pins.csv
@@ -0,0 +1,58 @@
+X1,PA0
+X2,PA1
+X3,PA2
+X4,PA3
+X5,PA4
+X6,PA5
+X7,PA6
+X8,PA7
+X9,PB6
+X10,PB7
+X11,PC4
+X12,PC5
+X13,Reset
+X14,GND
+X15,3.3V
+X16,VIN
+X17,PB3
+X18,PC13
+X19,PC0
+X20,PC1
+X21,PC2
+X22,PC3
+X23,A3.3V
+X24,AGND
+Y1,PC6
+Y2,PC7
+Y3,PB8
+Y4,PB9
+Y5,PB12
+Y6,PB13
+Y7,PB14
+Y8,PB15
+Y9,PB10
+Y10,PB11
+Y11,PB0
+Y12,PB1
+Y13,PB2
+Y14,GND
+Y15,3.3V
+Y16,VIN
+SW,PB3
+LED_RED,PA13
+LED_GREEN,PA14
+LED_YELLOW,PA15
+LED_BLUE,PB4
+NC,PB5
+SD_D0,PC8
+SD_D1,PC9
+SD_D2,PC10
+SD_D3,PC11
+SD_CMD,PD2
+SD_CK,PC12
+SD,PA8
+SD_SW,PA8
+USB_VBUS,PA9
+USB_ID,PA10
+USB_DM,PA11
+USB_DP,PA12
diff --git a/ports/stm32/boards/NADHAT_PYBF405/stm32f4xx_hal_conf.h b/ports/stm32/boards/NADHAT_PYBF405/stm32f4xx_hal_conf.h
new file mode 100644
index 0000000000000..7d6344f0a2453
--- /dev/null
+++ b/ports/stm32/boards/NADHAT_PYBF405/stm32f4xx_hal_conf.h
@@ -0,0 +1,19 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+
+#include "boards/stm32f4xx_hal_conf_base.h"
+
+// Oscillator values in Hz
+#define HSE_VALUE (16000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NETDUINO_PLUS_2/stm32f4xx_hal_conf.h b/ports/stm32/boards/NETDUINO_PLUS_2/stm32f4xx_hal_conf.h
index 4cb5a83e456f1..f186d5a29228c 100644
--- a/ports/stm32/boards/NETDUINO_PLUS_2/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/NETDUINO_PLUS_2/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (25000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_I2S_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSE_VALUE)
-  #define HSE_VALUE    ((uint32_t)25000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE)
- #define LSI_VALUE  ((uint32_t)40000)
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source
-  *        frequency, this source is inserted directly through I2S_CKIN pad.
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
-
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
-
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */
-
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_F091RC/mpconfigboard.h b/ports/stm32/boards/NUCLEO_F091RC/mpconfigboard.h
index 5e67916cbc80d..fb8de60221e99 100644
--- a/ports/stm32/boards/NUCLEO_F091RC/mpconfigboard.h
+++ b/ports/stm32/boards/NUCLEO_F091RC/mpconfigboard.h
@@ -7,7 +7,6 @@
 #define MICROPY_PY_NETWORK          (0)
 #define MICROPY_PY_STM              (0)
 #define MICROPY_PY_PYB_LEGACY       (0)
-#define MICROPY_VFS_FAT             (0)
 
 #define MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE (0)
 #define MICROPY_HW_ENABLE_RTC       (1)
@@ -16,7 +15,14 @@
 #define MICROPY_HW_ENABLE_TIMER     (1)
 #define MICROPY_HW_HAS_SWITCH       (1)
 
-// For system clock, board uses internal 48MHz, HSI48
+// For system clock, enable one source:
+//#define MICROPY_HW_CLK_USE_HSI      (1) // internal 8MHz -> PLL = 48MHz.
+#define MICROPY_HW_CLK_USE_HSI48    (1) // internal 48MHz.
+//#define MICROPY_HW_CLK_USE_HSE      (1) // external crystal -> PLL = 48MHz.
+// For HSE set the crystal / clock input frequency HSE_VALUE in stm32f0xx_hal_conf.h
+#if MICROPY_HW_CLK_USE_HSE
+#define MICROPY_HW_CLK_USE_BYPASS   (1) // HSE comes from STLINK 8MHz, not crystal.
+#endif
 
 // The board has an external 32kHz crystal
 #define MICROPY_HW_RTC_USE_LSE      (1)
diff --git a/ports/stm32/boards/NUCLEO_F091RC/mpconfigboard.mk b/ports/stm32/boards/NUCLEO_F091RC/mpconfigboard.mk
index 1d66f7e6b6952..984fe2f900540 100644
--- a/ports/stm32/boards/NUCLEO_F091RC/mpconfigboard.mk
+++ b/ports/stm32/boards/NUCLEO_F091RC/mpconfigboard.mk
@@ -3,5 +3,8 @@ CMSIS_MCU = STM32F091xC
 AF_FILE = boards/stm32f091_af.csv
 LD_FILES = boards/stm32f091xc.ld boards/common_basic.ld
 
+# MicroPython settings
+MICROPY_VFS_FAT = 0
+
 # Don't include default frozen modules because MCU is tight on flash space
-FROZEN_MPY_DIR ?=
+FROZEN_MANIFEST ?=
diff --git a/ports/stm32/boards/NUCLEO_F091RC/stm32f0xx_hal_conf.h b/ports/stm32/boards/NUCLEO_F091RC/stm32f0xx_hal_conf.h
index 53ea047cbd0cc..d5b2c4f7a2e72 100644
--- a/ports/stm32/boards/NUCLEO_F091RC/stm32f0xx_hal_conf.h
+++ b/ports/stm32/boards/NUCLEO_F091RC/stm32f0xx_hal_conf.h
@@ -1,312 +1,18 @@
-/**
-  ******************************************************************************
-  * @file    stm32f0xx_hal_conf_template.h
-  * @author  MCD Application Team
-  * @brief   HAL configuration template file.
-  *          This file should be copied to the application folder and renamed
-  *          to stm32f0xx_hal_conf.h.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F0XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F0XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F0xx_HAL_CONF_H
-#define __STM32F0xx_HAL_CONF_H
+#include "boards/stm32f0xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-#define HAL_CEC_MODULE_ENABLED
-#define HAL_COMP_MODULE_ENABLED
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_CRC_MODULE_ENABLED
-#define HAL_DAC_MODULE_ENABLED
-#define HAL_DMA_MODULE_ENABLED
-#define HAL_FLASH_MODULE_ENABLED
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-#define HAL_I2S_MODULE_ENABLED
-#define HAL_IRDA_MODULE_ENABLED
-#define HAL_IWDG_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-#define HAL_SMARTCARD_MODULE_ENABLED
-#define HAL_SMBUS_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_TSC_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-#define HAL_USART_MODULE_ENABLED
-#define HAL_WWDG_MODULE_ENABLED
-
-/* ######################### Oscillator Values adaptation ################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSE_VALUE)
-  #define HSE_VALUE            ((uint32_t)8000000)  /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-/**
-  * @brief In the following line adjust the External High Speed oscillator (HSE) Startup
-  *        Timeout value
-  */
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT  100U      /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE            8000000U  /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief In the following line adjust the Internal High Speed oscillator (HSI) Startup
-  *        Timeout value
-  */
-#if !defined  (HSI_STARTUP_TIMEOUT)
-  #define HSI_STARTUP_TIMEOUT  5000U     /*!< Time out for HSI start up */
-#endif /* HSI_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator for ADC (HSI14) value.
-  */
-#if !defined  (HSI14_VALUE)
-  #define HSI14_VALUE          14000000U /*!< Value of the Internal High Speed oscillator for ADC in Hz.
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-#endif /* HSI14_VALUE */
-
-/**
-  * @brief Internal High Speed oscillator for USB (HSI48) value.
-  */
-#if !defined  (HSI48_VALUE)
-  #define HSI48_VALUE          48000000U /*!< Value of the Internal High Speed oscillator for USB in Hz.
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-#endif /* HSI48_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE)
-  #define LSI_VALUE            40000U
-#endif /* LSI_VALUE */                   /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
-  #define LSE_VALUE            32768U    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-/**
-  * @brief Time out for LSE start up value in ms.
-  */
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT  5000U     /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    3300U  /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0U
-#define  PREFETCH_ENABLE              1U
-#define  INSTRUCTION_CACHE_ENABLE     0U
-#define  DATA_CACHE_ENABLE            0U
-#define  USE_SPI_CRC                  1U
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/*#define USE_FULL_ASSERT    1*/
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
- #include "stm32f0xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
- #include "stm32f0xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f0xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
- #include "stm32f0xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
- #include "stm32f0xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
- #include "stm32f0xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CEC_MODULE_ENABLED
- #include "stm32f0xx_hal_cec.h"
-#endif /* HAL_CEC_MODULE_ENABLED */
-
-#ifdef HAL_COMP_MODULE_ENABLED
- #include "stm32f0xx_hal_comp.h"
-#endif /* HAL_COMP_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
- #include "stm32f0xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
- #include "stm32f0xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
- #include "stm32f0xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f0xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f0xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f0xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f0xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f0xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f0xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f0xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f0xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_SMBUS_MODULE_ENABLED
- #include "stm32f0xx_hal_smbus.h"
-#endif /* HAL_SMBUS_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f0xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f0xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_TSC_MODULE_ENABLED
- #include "stm32f0xx_hal_tsc.h"
-#endif /* HAL_TSC_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f0xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f0xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f0xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0U : assert_failed((char *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(char* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0U)
-#endif /* USE_FULL_ASSERT */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F0xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F0XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_F401RE/stm32f4xx_hal_conf.h b/ports/stm32/boards/NUCLEO_F401RE/stm32f4xx_hal_conf.h
index daf9b63ceca01..de19251e0808a 100644
--- a/ports/stm32/boards/NUCLEO_F401RE/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/NUCLEO_F401RE/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_I2S_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSE_VALUE)
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE)
- #define LSI_VALUE  ((uint32_t)40000)
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source
-  *        frequency, this source is inserted directly through I2S_CKIN pad.
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
-
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
-
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */
-
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_F411RE/stm32f4xx_hal_conf.h b/ports/stm32/boards/NUCLEO_F411RE/stm32f4xx_hal_conf.h
index 8f0b6638119d4..de19251e0808a 100644
--- a/ports/stm32/boards/NUCLEO_F411RE/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/NUCLEO_F411RE/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */ 
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver 
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_I2S_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).  
-  */
-#if !defined  (HSE_VALUE) 
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL). 
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE) 
- #define LSI_VALUE  ((uint32_t)40000)    
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source 
-  *        frequency, this source is inserted directly through I2S_CKIN pad. 
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */     
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the 
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */   
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/ 
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/ 
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
- 
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-  
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
- 
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file 
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-   
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h" 
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
- 
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */ 
-  
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */      
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-   
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed. 
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
- 
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_F412ZG/mpconfigboard.h b/ports/stm32/boards/NUCLEO_F412ZG/mpconfigboard.h
new file mode 100644
index 0000000000000..2a557f1350885
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_F412ZG/mpconfigboard.h
@@ -0,0 +1,82 @@
+#define MICROPY_HW_BOARD_NAME       "NUCLEO-F412ZG"
+#define MICROPY_HW_MCU_NAME         "STM32F412Zx"
+
+#define MICROPY_HW_HAS_SWITCH       (1)
+#define MICROPY_HW_HAS_FLASH        (1)
+#define MICROPY_HW_ENABLE_RNG       (1)
+#define MICROPY_HW_ENABLE_RTC       (1)
+#define MICROPY_HW_ENABLE_USB       (1)
+
+// HSE is 8MHz, CPU freq set to 96MHz
+#define MICROPY_HW_CLK_PLLM         (8)
+#define MICROPY_HW_CLK_PLLN         (192)
+#define MICROPY_HW_CLK_PLLP         (RCC_PLLP_DIV2)
+#define MICROPY_HW_CLK_PLLQ         (4)
+
+#define MICROPY_HW_UART1_TX         (pin_B6)
+#define MICROPY_HW_UART1_RX         (pin_B3)
+#define MICROPY_HW_UART2_TX         (pin_D5)
+#define MICROPY_HW_UART2_RX         (pin_D6)
+#define MICROPY_HW_UART3_TX         (pin_D8)
+#define MICROPY_HW_UART3_RX         (pin_D9)
+#define MICROPY_HW_UART6_TX         (pin_G14)
+#define MICROPY_HW_UART6_RX         (pin_G9)
+#define MICROPY_HW_UART_REPL        PYB_UART_3
+#define MICROPY_HW_UART_REPL_BAUD   115200
+
+// I2C buses
+#define MICROPY_HW_I2C1_SCL         (pin_B8)
+#define MICROPY_HW_I2C1_SDA         (pin_B9)
+#define MICROPY_HW_I2C2_SCL         (pin_F1)
+#define MICROPY_HW_I2C2_SDA         (pin_F0)
+#define MICROPY_HW_I2C3_SCL         (pin_A8)
+#define MICROPY_HW_I2C3_SDA         (pin_C9)
+
+// SPI buses
+#define MICROPY_HW_SPI1_NSS         (pin_A4) // shared with DAC
+#define MICROPY_HW_SPI1_SCK         (pin_A5) // shared with DAC
+#define MICROPY_HW_SPI1_MISO        (pin_A6)
+#define MICROPY_HW_SPI1_MOSI        (pin_A7)
+#define MICROPY_HW_SPI2_NSS         (pin_B12)
+#define MICROPY_HW_SPI2_SCK         (pin_C7)
+#define MICROPY_HW_SPI2_MISO        (pin_C2)
+#define MICROPY_HW_SPI2_MOSI        (pin_C3)
+#define MICROPY_HW_SPI3_NSS         (pin_A15)
+#define MICROPY_HW_SPI3_SCK         (pin_C10)
+#define MICROPY_HW_SPI3_MISO        (pin_C11)
+#define MICROPY_HW_SPI3_MOSI        (pin_B5)
+#define MICROPY_HW_SPI4_NSS         (pin_E4)
+#define MICROPY_HW_SPI4_SCK         (pin_B13)
+#define MICROPY_HW_SPI4_MISO        (pin_E5)
+#define MICROPY_HW_SPI4_MOSI        (pin_E6)
+#define MICROPY_HW_SPI5_NSS         (pin_E11)
+#define MICROPY_HW_SPI5_SCK         (pin_E12)
+#define MICROPY_HW_SPI5_MISO        (pin_E13)
+#define MICROPY_HW_SPI5_MOSI        (pin_E14)
+
+// CAN buses
+#define MICROPY_HW_CAN1_TX          (pin_G1)
+#define MICROPY_HW_CAN1_RX          (pin_G0)
+#define MICROPY_HW_CAN2_TX          (pin_G12)
+#define MICROPY_HW_CAN2_RX          (pin_G11)
+
+// USRSW is pulled low. Pressing the button makes the input go high.
+#define MICROPY_HW_USRSW_PIN        (pin_C13)
+#define MICROPY_HW_USRSW_PULL       (GPIO_NOPULL)
+#define MICROPY_HW_USRSW_EXTI_MODE  (GPIO_MODE_IT_RISING)
+#define MICROPY_HW_USRSW_PRESSED    (1)
+
+// LEDs
+#define MICROPY_HW_LED1             (pin_B0) // Green
+#define MICROPY_HW_LED2             (pin_B7) // Blue
+#define MICROPY_HW_LED3             (pin_B14) // Red
+#define MICROPY_HW_LED1_PWM         { TIM1, 1, TIM_CHANNEL_2, GPIO_AF1_TIM1 }
+#define MICROPY_HW_LED2_PWM         { TIM4, 4, TIM_CHANNEL_2, GPIO_AF2_TIM4 }
+#define MICROPY_HW_LED3_PWM         { TIM12, 12, TIM_CHANNEL_1, GPIO_AF9_TIM12 }
+#define MICROPY_HW_LED_ON(pin)      (mp_hal_pin_high(pin))
+#define MICROPY_HW_LED_OFF(pin)     (mp_hal_pin_low(pin))
+
+// USB config (CN13 - USB OTG FS)
+#define MICROPY_HW_USB_FS           (1)
+#define MICROPY_HW_USB_VBUS_DETECT_PIN (pin_A9)
+#define MICROPY_HW_USB_OTG_ID_PIN   (pin_A10)
diff --git a/ports/stm32/boards/NUCLEO_F412ZG/mpconfigboard.mk b/ports/stm32/boards/NUCLEO_F412ZG/mpconfigboard.mk
new file mode 100644
index 0000000000000..dd671a9f90142
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_F412ZG/mpconfigboard.mk
@@ -0,0 +1,6 @@
+MCU_SERIES = f4
+CMSIS_MCU = STM32F412Zx
+AF_FILE = boards/stm32f412_af.csv
+LD_FILES = boards/stm32f412zx.ld boards/common_ifs.ld
+TEXT0_ADDR = 0x08000000
+TEXT1_ADDR = 0x08020000
diff --git a/ports/stm32/boards/NUCLEO_F412ZG/pins.csv b/ports/stm32/boards/NUCLEO_F412ZG/pins.csv
new file mode 100644
index 0000000000000..430d0972b32f1
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_F412ZG/pins.csv
@@ -0,0 +1,118 @@
+PA0,PA0
+PA1,PA1
+PA2,PA2
+PA3,PA3
+PA4,PA4
+PA5,PA5
+PA6,PA6
+PA7,PA7
+PA8,PA8
+PA9,PA9
+PA10,PA10
+PA11,PA11
+PA12,PA12
+PA13,PA13
+PA14,PA14
+PA15,PA15
+PB0,PB0
+PB1,PB1
+PB2,PB2
+PB3,PB3
+PB4,PB4
+PB5,PB5
+PB6,PB6
+PB7,PB7
+PB8,PB8
+PB9,PB9
+PB10,PB10
+PB11,PB11
+PB12,PB12
+PB13,PB13
+PB14,PB14
+PB15,PB15
+PC0,PC0
+PC1,PC1
+PC2,PC2
+PC3,PC3
+PC4,PC4
+PC5,PC5
+PC6,PC6
+PC7,PC7
+PC8,PC8
+PC9,PC9
+PC10,PC10
+PC11,PC11
+PC12,PC12
+PC13,PC13
+PC14,PC14
+PC15,PC15
+PD0,PD0
+PD1,PD1
+PD2,PD2
+PD3,PD3
+PD4,PD4
+PD5,PD5
+PD6,PD6
+PD7,PD7
+PD8,PD8
+PD9,PD9
+PD10,PD10
+PD11,PD11
+PD12,PD12
+PD13,PD13
+PD14,PD14
+PD15,PD15
+PE0,PE0
+PE1,PE1
+PE2,PE2
+PE3,PE3
+PE4,PE4
+PE5,PE5
+PE6,PE6
+PE7,PE7
+PE8,PE8
+PE9,PE9
+PE10,PE10
+PE11,PE11
+PE12,PE12
+PE13,PE13
+PE14,PE14
+PE15,PE15
+PF0,PF0
+PF1,PF1
+PF2,PF2
+PF3,PF3
+PF4,PF4
+PF5,PF5
+PF6,PF6
+PF7,PF7
+PF8,PF8
+PF9,PF9
+PF10,PF10
+PF11,PF11
+PF12,PF12
+PF13,PF13
+PF14,PF14
+PF15,PF15
+PG0,PG0
+PG1,PG1
+PG2,PG2
+PG3,PG3
+PG4,PG4
+PG5,PG5
+PG6,PG6
+PG7,PG7
+PG8,PG8
+PG9,PG9
+PG10,PG10
+PG11,PG11
+PG12,PG12
+PG13,PG13
+PG14,PG14
+PG15,PG15
+PH0,PH0
+PH1,PH1
+SW,C13
+LED_RED,B14
+LED_GREEN,B0
+LED_BLUE,B7
\ No newline at end of file
diff --git a/ports/stm32/boards/NUCLEO_F412ZG/stm32f4xx_hal_conf.h b/ports/stm32/boards/NUCLEO_F412ZG/stm32f4xx_hal_conf.h
new file mode 100644
index 0000000000000..de19251e0808a
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_F412ZG/stm32f4xx_hal_conf.h
@@ -0,0 +1,19 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+
+#include "boards/stm32f4xx_hal_conf_base.h"
+
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_F413ZH/mpconfigboard.h b/ports/stm32/boards/NUCLEO_F413ZH/mpconfigboard.h
new file mode 100644
index 0000000000000..2f488159a4f00
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_F413ZH/mpconfigboard.h
@@ -0,0 +1,101 @@
+#define MICROPY_HW_BOARD_NAME       "NUCLEO-F413ZH"
+#define MICROPY_HW_MCU_NAME         "STM32F413"
+
+#define MICROPY_HW_HAS_SWITCH       (1)
+#define MICROPY_HW_HAS_FLASH        (1)
+#define MICROPY_HW_ENABLE_RNG       (1)
+#define MICROPY_HW_ENABLE_RTC       (1)
+#define MICROPY_HW_ENABLE_DAC       (1)
+#define MICROPY_HW_ENABLE_USB       (1)
+
+// HSE is 8MHz, CPU freq set to 96MHz
+#define MICROPY_HW_CLK_PLLM (8)
+#define MICROPY_HW_CLK_PLLN (192)
+#define MICROPY_HW_CLK_PLLP (RCC_PLLP_DIV2)
+#define MICROPY_HW_CLK_PLLQ (4)
+
+// For 2.7 to 3.6 V, 75 to 100 MHz: 3 wait states.
+#define MICROPY_HW_FLASH_LATENCY    FLASH_LATENCY_3
+
+// UART config
+#define MICROPY_HW_UART1_TX     (pin_B6)
+#define MICROPY_HW_UART1_RX     (pin_B3) // shared with CAN3
+#define MICROPY_HW_UART2_TX     (pin_D5)
+#define MICROPY_HW_UART2_RX     (pin_D6)
+#define MICROPY_HW_UART3_TX     (pin_D8)
+#define MICROPY_HW_UART3_RX     (pin_D9)
+#define MICROPY_HW_UART4_TX     (pin_D1)
+#define MICROPY_HW_UART4_RX     (pin_D0)
+#define MICROPY_HW_UART5_TX     (pin_C12)
+#define MICROPY_HW_UART5_RX     (pin_D2)
+#define MICROPY_HW_UART6_TX     (pin_G14)
+#define MICROPY_HW_UART6_RX     (pin_G9)
+#define MICROPY_HW_UART7_TX     (pin_E8)
+#define MICROPY_HW_UART7_RX     (pin_E7)
+#define MICROPY_HW_UART8_TX     (pin_E1)
+#define MICROPY_HW_UART8_RX     (pin_E0)
+#define MICROPY_HW_UART9_TX     (pin_D15)
+#define MICROPY_HW_UART9_RX     (pin_D14)
+#define MICROPY_HW_UART10_TX    (pin_E3)
+#define MICROPY_HW_UART10_RX    (pin_E2)
+#define MICROPY_HW_UART_REPL        PYB_UART_3
+#define MICROPY_HW_UART_REPL_BAUD   115200
+
+// I2C busses
+#define MICROPY_HW_I2C1_SCL (pin_B8)
+#define MICROPY_HW_I2C1_SDA (pin_B9)
+#define MICROPY_HW_I2C2_SCL (pin_F1)
+#define MICROPY_HW_I2C2_SDA (pin_F0)
+#define MICROPY_HW_I2C3_SCL (pin_A8)
+#define MICROPY_HW_I2C3_SDA (pin_C9)
+
+// SPI busses
+#define MICROPY_HW_SPI1_NSS     (pin_A4) // shared with DAC
+#define MICROPY_HW_SPI1_SCK     (pin_A5) // shared with DAC
+#define MICROPY_HW_SPI1_MISO    (pin_A6)
+#define MICROPY_HW_SPI1_MOSI    (pin_A7)
+#define MICROPY_HW_SPI2_NSS     (pin_B12)
+#define MICROPY_HW_SPI2_SCK     (pin_C7)
+#define MICROPY_HW_SPI2_MISO    (pin_C2)
+#define MICROPY_HW_SPI2_MOSI    (pin_C3)
+#define MICROPY_HW_SPI3_NSS     (pin_A15)
+#define MICROPY_HW_SPI3_SCK     (pin_C10)
+#define MICROPY_HW_SPI3_MISO    (pin_C11)
+#define MICROPY_HW_SPI3_MOSI    (pin_B5)
+#define MICROPY_HW_SPI4_NSS     (pin_E4)
+#define MICROPY_HW_SPI4_SCK     (pin_B13)
+#define MICROPY_HW_SPI4_MISO    (pin_E5)
+#define MICROPY_HW_SPI4_MOSI    (pin_E6)
+#define MICROPY_HW_SPI5_NSS     (pin_E11)
+#define MICROPY_HW_SPI5_SCK     (pin_E12)
+#define MICROPY_HW_SPI5_MISO    (pin_E13)
+#define MICROPY_HW_SPI5_MOSI    (pin_E14)
+
+// CAN busses
+#define MICROPY_HW_CAN1_TX (pin_G1)
+#define MICROPY_HW_CAN1_RX (pin_G0)
+#define MICROPY_HW_CAN2_TX (pin_G12)
+#define MICROPY_HW_CAN2_RX (pin_G11)
+#define MICROPY_HW_CAN3_TX (pin_B4)
+#define MICROPY_HW_CAN3_RX (pin_B3) // shared with UART1 or use pin_A8 shared with I2C3
+
+// USRSW is pulled low. Pressing the button makes the input go high.
+#define MICROPY_HW_USRSW_PIN        (pin_C13)
+#define MICROPY_HW_USRSW_PULL       (GPIO_NOPULL)
+#define MICROPY_HW_USRSW_EXTI_MODE  (GPIO_MODE_IT_RISING)
+#define MICROPY_HW_USRSW_PRESSED    (1)
+
+// LEDs
+#define MICROPY_HW_LED1             (pin_B14) // red
+#define MICROPY_HW_LED2             (pin_B0) // green
+#define MICROPY_HW_LED3             (pin_B7) // blue
+#define MICROPY_HW_LED1_PWM         { TIM12, 12, TIM_CHANNEL_1, GPIO_AF9_TIM12 }
+#define MICROPY_HW_LED2_PWM         { TIM3, 3, TIM_CHANNEL_3, GPIO_AF2_TIM3 }
+#define MICROPY_HW_LED3_PWM         { TIM4, 4, TIM_CHANNEL_2, GPIO_AF2_TIM4 }
+#define MICROPY_HW_LED_ON(pin)      (mp_hal_pin_high(pin))
+#define MICROPY_HW_LED_OFF(pin)     (mp_hal_pin_low(pin))
+
+// USB config (CN13 - USB OTG FS)
+#define MICROPY_HW_USB_FS              (1)
+#define MICROPY_HW_USB_VBUS_DETECT_PIN (pin_A9)
+#define MICROPY_HW_USB_OTG_ID_PIN      (pin_A10)
diff --git a/ports/stm32/boards/NUCLEO_F413ZH/mpconfigboard.mk b/ports/stm32/boards/NUCLEO_F413ZH/mpconfigboard.mk
new file mode 100644
index 0000000000000..7d8ea6bf6bbb0
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_F413ZH/mpconfigboard.mk
@@ -0,0 +1,6 @@
+MCU_SERIES = f4
+CMSIS_MCU = STM32F413xx
+AF_FILE = boards/stm32f413_af.csv
+LD_FILES = boards/stm32f413xh.ld boards/common_ifs.ld
+TEXT0_ADDR = 0x08000000
+TEXT1_ADDR = 0x08060000
diff --git a/ports/stm32/boards/NUCLEO_F413ZH/pins.csv b/ports/stm32/boards/NUCLEO_F413ZH/pins.csv
new file mode 100644
index 0000000000000..31dcb99ed616c
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_F413ZH/pins.csv
@@ -0,0 +1,118 @@
+PA0,PA0
+PA1,PA1
+PA2,PA2
+PA3,PA3
+PA4,PA4
+PA5,PA5
+PA6,PA6
+PA7,PA7
+PA8,PA8
+PA9,PA9
+PA10,PA10
+PA11,PA11
+PA12,PA12
+PA13,PA13
+PA14,PA14
+PA15,PA15
+PB0,PB0
+PB1,PB1
+PB2,PB2
+PB3,PB3
+PB4,PB4
+PB5,PB5
+PB6,PB6
+PB7,PB7
+PB8,PB8
+PB9,PB9
+PB10,PB10
+PB11,PB11
+PB12,PB12
+PB13,PB13
+PB14,PB14
+PB15,PB15
+PC0,PC0
+PC1,PC1
+PC2,PC2
+PC3,PC3
+PC4,PC4
+PC5,PC5
+PC6,PC6
+PC7,PC7
+PC8,PC8
+PC9,PC9
+PC10,PC10
+PC11,PC11
+PC12,PC12
+PC13,PC13
+PC14,PC14
+PC15,PC15
+PD0,PD0
+PD1,PD1
+PD2,PD2
+PD3,PD3
+PD4,PD4
+PD5,PD5
+PD6,PD6
+PD7,PD7
+PD8,PD8
+PD9,PD9
+PD10,PD10
+PD11,PD11
+PD12,PD12
+PD13,PD13
+PD14,PD14
+PD15,PD15
+PE0,PE0
+PE1,PE1
+PE2,PE2
+PE3,PE3
+PE4,PE4
+PE5,PE5
+PE6,PE6
+PE7,PE7
+PE8,PE8
+PE9,PE9
+PE10,PE10
+PE11,PE11
+PE12,PE12
+PE13,PE13
+PE14,PE14
+PE15,PE15
+PF0,PF0
+PF1,PF1
+PF2,PF2
+PF3,PF3
+PF4,PF4
+PF5,PF5
+PF6,PF6
+PF7,PF7
+PF8,PF8
+PF9,PF9
+PF10,PF10
+PF11,PF11
+PF12,PF12
+PF13,PF13
+PF14,PF14
+PF15,PF15
+PG0,PG0
+PG1,PG1
+PG2,PG2
+PG3,PG3
+PG4,PG4
+PG5,PG5
+PG6,PG6
+PG7,PG7
+PG8,PG8
+PG9,PG9
+PG10,PG10
+PG11,PG11
+PG12,PG12
+PG13,PG13
+PG14,PG14
+PG15,PG15
+PH0,PH0
+PH1,PH1
+SW,C13
+LED_RED,B14
+LED_GREEN,B0
+LED_BLUE,B7
diff --git a/ports/stm32/boards/NUCLEO_F413ZH/stm32f4xx_hal_conf.h b/ports/stm32/boards/NUCLEO_F413ZH/stm32f4xx_hal_conf.h
new file mode 100644
index 0000000000000..de19251e0808a
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_F413ZH/stm32f4xx_hal_conf.h
@@ -0,0 +1,19 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+
+#include "boards/stm32f4xx_hal_conf_base.h"
+
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_F429ZI/mpconfigboard.mk b/ports/stm32/boards/NUCLEO_F429ZI/mpconfigboard.mk
index e542d1c9985d3..47b4432893c89 100644
--- a/ports/stm32/boards/NUCLEO_F429ZI/mpconfigboard.mk
+++ b/ports/stm32/boards/NUCLEO_F429ZI/mpconfigboard.mk
@@ -7,3 +7,5 @@ TEXT1_ADDR = 0x08020000
 
 # MicroPython settings
 MICROPY_PY_LWIP = 1
+MICROPY_PY_USSL = 1
+MICROPY_SSL_MBEDTLS = 1
diff --git a/ports/stm32/boards/NUCLEO_F429ZI/stm32f4xx_hal_conf.h b/ports/stm32/boards/NUCLEO_F429ZI/stm32f4xx_hal_conf.h
index 5b5a8a3e43e52..de19251e0808a 100644
--- a/ports/stm32/boards/NUCLEO_F429ZI/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/NUCLEO_F429ZI/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */ 
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
- /* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver 
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_I2S_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).  
-  */
-#if !defined  (HSE_VALUE) 
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL). 
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE) 
- #define LSI_VALUE  ((uint32_t)40000)    
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source 
-  *        frequency, this source is inserted directly through I2S_CKIN pad. 
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */     
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the 
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */   
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/ 
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/ 
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
- 
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-  
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
- 
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file 
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-   
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h" 
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
- 
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */ 
-  
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */      
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-   
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed. 
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
- 
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_F446RE/mpconfigboard.h b/ports/stm32/boards/NUCLEO_F446RE/mpconfigboard.h
index d801fa18854d3..cd4ad36fa0ee9 100644
--- a/ports/stm32/boards/NUCLEO_F446RE/mpconfigboard.h
+++ b/ports/stm32/boards/NUCLEO_F446RE/mpconfigboard.h
@@ -4,6 +4,7 @@
 #define MICROPY_HW_HAS_SWITCH       (1)
 #define MICROPY_HW_HAS_FLASH        (1)
 #define MICROPY_HW_ENABLE_RTC       (1)
+#define MICROPY_HW_ENABLE_DAC       (1)
 
 // HSE is 8MHz, CPU freq set to 168MHz. Using PLLQ for USB this gives a nice
 // 48 MHz clock for USB. To goto 180 MHz, I think that USB would need to be
diff --git a/ports/stm32/boards/NUCLEO_F446RE/stm32f4xx_hal_conf.h b/ports/stm32/boards/NUCLEO_F446RE/stm32f4xx_hal_conf.h
index 245fb9a06ab6e..de19251e0808a 100644
--- a/ports/stm32/boards/NUCLEO_F446RE/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/NUCLEO_F446RE/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */ 
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver 
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_I2S_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-/* #define HAL_RNG_MODULE_ENABLED */
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).  
-  */
-#if !defined  (HSE_VALUE) 
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL). 
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE) 
- #define LSI_VALUE  ((uint32_t)40000)    
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source 
-  *        frequency, this source is inserted directly through I2S_CKIN pad. 
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */     
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the 
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */   
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/ 
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/ 
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
- 
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-  
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
- 
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file 
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-   
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h" 
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
- 
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */ 
-  
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */      
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-   
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed. 
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
- 
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_F722ZE/board_init.c b/ports/stm32/boards/NUCLEO_F722ZE/board_init.c
new file mode 100644
index 0000000000000..5a7c6052af9bf
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_F722ZE/board_init.c
@@ -0,0 +1,8 @@
+#include "py/mphal.h"
+
+void board_early_init(void) {
+    // Turn off the USB switch
+    #define USB_PowerSwitchOn pin_G6
+    mp_hal_pin_output(USB_PowerSwitchOn);
+    mp_hal_pin_low(USB_PowerSwitchOn);
+}
diff --git a/ports/stm32/boards/NUCLEO_F722ZE/mpconfigboard.h b/ports/stm32/boards/NUCLEO_F722ZE/mpconfigboard.h
new file mode 100644
index 0000000000000..5a7f650067051
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_F722ZE/mpconfigboard.h
@@ -0,0 +1,68 @@
+// This board is only confirmed to operate using DFU mode and openocd.
+// DFU mode can be accessed by setting BOOT0 (see schematics)
+// To use openocd run "OPENOCD_CONFIG=boards/openocd_stm32f7.cfg" in
+// the make command.
+
+#define MICROPY_HW_BOARD_NAME       "NUCLEO-F722ZE"
+#define MICROPY_HW_MCU_NAME         "STM32F722"
+
+#define MICROPY_HW_HAS_SWITCH       (1)
+#define MICROPY_HW_HAS_FLASH        (1)
+#define MICROPY_HW_ENABLE_RNG       (1)
+#define MICROPY_HW_ENABLE_RTC       (1)
+#define MICROPY_HW_ENABLE_DAC       (1)
+#define MICROPY_HW_ENABLE_USB       (1)
+
+#define MICROPY_BOARD_EARLY_INIT    board_early_init
+void board_early_init(void);
+
+// HSE is 8MHz, run SYSCLK at 216MHz
+#define MICROPY_HW_CLK_PLLM         (4)
+#define MICROPY_HW_CLK_PLLN         (216)
+#define MICROPY_HW_CLK_PLLP         (RCC_PLLP_DIV2)
+#define MICROPY_HW_CLK_PLLQ         (9)
+#define MICROPY_HW_FLASH_LATENCY    (FLASH_LATENCY_7) // 210-216 MHz needs 7 wait states
+
+// UART config
+#define MICROPY_HW_UART2_TX         (pin_D5)
+#define MICROPY_HW_UART2_RX         (pin_D6)
+#define MICROPY_HW_UART2_RTS        (pin_D4)
+#define MICROPY_HW_UART2_CTS        (pin_D3)
+#define MICROPY_HW_UART3_TX         (pin_D8)
+#define MICROPY_HW_UART3_RX         (pin_D9)
+#define MICROPY_HW_UART6_TX         (pin_G14)
+#define MICROPY_HW_UART6_RX         (pin_G9)
+#define MICROPY_HW_UART_REPL        PYB_UART_3
+#define MICROPY_HW_UART_REPL_BAUD   115200
+
+// I2C buses
+#define MICROPY_HW_I2C1_SCL         (pin_B8)
+#define MICROPY_HW_I2C1_SDA         (pin_B9)
+
+// SPI buses
+#define MICROPY_HW_SPI3_NSS         (pin_A4)
+#define MICROPY_HW_SPI3_SCK         (pin_B3)
+#define MICROPY_HW_SPI3_MISO        (pin_B4)
+#define MICROPY_HW_SPI3_MOSI        (pin_B5)
+
+// CAN buses
+#define MICROPY_HW_CAN1_TX          (pin_B9)
+#define MICROPY_HW_CAN1_RX          (pin_B8)
+
+// USRSW is pulled low, and pressing the button makes the input go high
+#define MICROPY_HW_USRSW_PIN        (pin_C13)
+#define MICROPY_HW_USRSW_PULL       (GPIO_NOPULL)
+#define MICROPY_HW_USRSW_EXTI_MODE  (GPIO_MODE_IT_RISING)
+#define MICROPY_HW_USRSW_PRESSED    (1)
+
+// LEDs
+#define MICROPY_HW_LED1             (pin_B0) // green
+#define MICROPY_HW_LED2             (pin_B7) // blue
+#define MICROPY_HW_LED3             (pin_B14) // red
+#define MICROPY_HW_LED_ON(pin)      (mp_hal_pin_high(pin))
+#define MICROPY_HW_LED_OFF(pin)     (mp_hal_pin_low(pin))
+
+// USB config (CN13 - USB OTG FS)
+#define MICROPY_HW_USB_FS              (1)
+#define MICROPY_HW_USB_VBUS_DETECT_PIN (pin_A9)
+#define MICROPY_HW_USB_OTG_ID_PIN      (pin_A10)
diff --git a/ports/stm32/boards/NUCLEO_F722ZE/mpconfigboard.mk b/ports/stm32/boards/NUCLEO_F722ZE/mpconfigboard.mk
new file mode 100644
index 0000000000000..667c8e55da98c
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_F722ZE/mpconfigboard.mk
@@ -0,0 +1,6 @@
+MCU_SERIES = f7
+CMSIS_MCU = STM32F722xx
+AF_FILE = boards/stm32f722_af.csv
+LD_FILES = boards/stm32f722.ld boards/common_ifs.ld
+TEXT0_ADDR = 0x08000000
+TEXT1_ADDR = 0x08020000
diff --git a/ports/stm32/boards/NUCLEO_F722ZE/pins.csv b/ports/stm32/boards/NUCLEO_F722ZE/pins.csv
new file mode 100644
index 0000000000000..228d83a026b51
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_F722ZE/pins.csv
@@ -0,0 +1,104 @@
+A0,PA3
+A1,PC0
+A2,PC3
+A3,PF3
+A4,PF5
+A5,PF10
+A6,PB1
+A7,PC2
+A8,PF4
+D0,PG9
+D1,PG14
+D2,PF15
+D3,PE13
+D4,PF14
+D5,PE11
+D6,PE9
+D7,PF13
+D8,PF12
+D9,PD15
+D10,PD14
+D11,PA7
+D12,PA6
+D13,PA5
+D14,PB9
+D15,PB8
+D16,PC6
+D17,PB15
+D18,PB13
+D19,PB12
+D20,PA15
+D21,PC7
+D22,PB5
+D23,PB3
+D24,PA4
+D25,PB4
+D26,PB6
+D27,PB2
+D28,PD13
+D29,PD12
+D30,PD11
+D31,PE2
+D32,PA0
+D33,PB0
+D34,PE0
+D35,PB11
+D36,PB10
+D37,PE15
+D38,PE14
+D39,PE12
+D40,PE10
+D41,PE7
+D42,PE8
+D43,PC8
+D44,PC9
+D45,PC10
+D46,PC11
+D47,PC12
+D48,PD2
+D49,PG2
+D50,PG3
+D51,PD7
+D52,PD6
+D53,PD5
+D54,PD4
+D55,PD3
+D56,PE2
+D57,PE4
+D58,PE5
+D59,PE6
+D60,PE3
+D61,PF8
+D62,PF7
+D63,PF9
+D64,PG1
+D65,PG0
+D66,PD1
+D67,PD0
+D68,PF0
+D69,PF1
+D70,PF2
+D71,PA7
+LED1,PB0
+LED2,PB7
+LED3,PB14
+SW,PC13
+SD_SW,PC13
+OTG_FS_POWER,PG6
+OTG_FS_OVER_CURRENT,PG7
+USB_VBUS,PA9
+USB_ID,PA10
+USB_DM,PA11
+USB_DP,PA12
+USB_POWER,PG6
+VCP_TX,PD8
+VCP_RX,PD9
+UART2_TX,PD5
+UART2_RX,PD6
+UART2_RTS,PD4
+UART2_CTS,PD3
+UART6_TX,PG14
+UART6_RX,PG9
+SPI_B_NSS,PA4
+SPI_B_SCK,PB3
+SPI_B_MOSI,PB5
diff --git a/ports/stm32/boards/NUCLEO_F722ZE/stm32f7xx_hal_conf.h b/ports/stm32/boards/NUCLEO_F722ZE/stm32f7xx_hal_conf.h
new file mode 100644
index 0000000000000..9355a3867de50
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_F722ZE/stm32f7xx_hal_conf.h
@@ -0,0 +1,18 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * MIT License; Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
+
+#include "boards/stm32f7xx_hal_conf_base.h"
+
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (5000)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#endif // MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_F746ZG/mpconfigboard.h b/ports/stm32/boards/NUCLEO_F746ZG/mpconfigboard.h
index a9fbea5766c02..c9b0c60f274b0 100644
--- a/ports/stm32/boards/NUCLEO_F746ZG/mpconfigboard.h
+++ b/ports/stm32/boards/NUCLEO_F746ZG/mpconfigboard.h
@@ -75,3 +75,14 @@
 #define MICROPY_HW_USB_FS              (1)
 #define MICROPY_HW_USB_VBUS_DETECT_PIN (pin_A9)
 #define MICROPY_HW_USB_OTG_ID_PIN      (pin_A10)
+
+// Ethernet via RMII
+#define MICROPY_HW_ETH_MDC          (pin_C1)
+#define MICROPY_HW_ETH_MDIO         (pin_A2)
+#define MICROPY_HW_ETH_RMII_REF_CLK (pin_A1)
+#define MICROPY_HW_ETH_RMII_CRS_DV  (pin_A7)
+#define MICROPY_HW_ETH_RMII_RXD0    (pin_C4)
+#define MICROPY_HW_ETH_RMII_RXD1    (pin_C5)
+#define MICROPY_HW_ETH_RMII_TX_EN   (pin_G11)
+#define MICROPY_HW_ETH_RMII_TXD0    (pin_G13)
+#define MICROPY_HW_ETH_RMII_TXD1    (pin_B13)
diff --git a/ports/stm32/boards/NUCLEO_F746ZG/mpconfigboard.mk b/ports/stm32/boards/NUCLEO_F746ZG/mpconfigboard.mk
index 160218fd338aa..8b54dc84e113e 100644
--- a/ports/stm32/boards/NUCLEO_F746ZG/mpconfigboard.mk
+++ b/ports/stm32/boards/NUCLEO_F746ZG/mpconfigboard.mk
@@ -4,3 +4,8 @@ AF_FILE = boards/stm32f746_af.csv
 LD_FILES = boards/stm32f746.ld boards/common_ifs.ld
 TEXT0_ADDR = 0x08000000
 TEXT1_ADDR = 0x08020000
+
+# MicroPython settings
+MICROPY_PY_LWIP = 1
+MICROPY_PY_USSL = 1
+MICROPY_SSL_MBEDTLS = 1
diff --git a/ports/stm32/boards/NUCLEO_F746ZG/pins.csv b/ports/stm32/boards/NUCLEO_F746ZG/pins.csv
index aa5143e8c5ac1..c129f7417b595 100644
--- a/ports/stm32/boards/NUCLEO_F746ZG/pins.csv
+++ b/ports/stm32/boards/NUCLEO_F746ZG/pins.csv
@@ -66,3 +66,12 @@ UART6_RX,PG9
 SPI_B_NSS,PA4
 SPI_B_SCK,PB3
 SPI_B_MOSI,PB5
+ETH_MDC,PC1
+ETH_MDIO,PA2
+ETH_RMII_REF_CLK,PA1
+ETH_RMII_CRS_DV,PA7
+ETH_RMII_RXD0,PC4
+ETH_RMII_RXD1,PC5
+ETH_RMII_TX_EN,PG11
+ETH_RMII_TXD0,PG13
+ETH_RMII_TXD1,PB13
diff --git a/ports/stm32/boards/NUCLEO_F746ZG/stm32f7xx_hal_conf.h b/ports/stm32/boards/NUCLEO_F746ZG/stm32f7xx_hal_conf.h
index a019ee4ce9665..e241921ddd25b 100644
--- a/ports/stm32/boards/NUCLEO_F746ZG/stm32f7xx_hal_conf.h
+++ b/ports/stm32/boards/NUCLEO_F746ZG/stm32f7xx_hal_conf.h
@@ -1,427 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f7xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.0.1
-  * @date    25-June-2015
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F7xx_HAL_CONF_H
-#define __STM32F7xx_HAL_CONF_H
+#include "boards/stm32f7xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (5000)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CEC_MODULE_ENABLED   */
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-#define HAL_I2S_MODULE_ENABLED
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LPTIM_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-/* #define HAL_QSPI_MODULE_ENABLED */
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-/* #define HAL_SPDIFRX_MODULE_ENABLED */
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED  */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## Timeout Configuration ######################### */
-/**
-  * @brief This is the HAL configuration section
-  */
-#define HAL_ACCURATE_TIMEOUT_ENABLED   0
-#define HAL_TIMEOUT_VALUE              0x1FFFFFF
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSE_VALUE)
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)5000)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE)
- #define LSI_VALUE  ((uint32_t)32000)
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source
-  *        frequency, this source is inserted directly through I2S_CKIN pad.
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  ART_ACCLERATOR_ENABLE        1 /* To enable instruction cache and prefetch */
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   1
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)5)       /* 5 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)5)       /* 5 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-/* LAN8742A PHY Address*/
-#define LAN8742A_PHY_ADDRESS            0x00
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/
-#define PHY_RESET_DELAY                 ((uint32_t)0x00000FFF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
-
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
-
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f7xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f7xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f7xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f7xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f7xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f7xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CEC_MODULE_ENABLED
-  #include "stm32f7xx_hal_cec.h"
-#endif /* HAL_CEC_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f7xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f7xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f7xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f7xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f7xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f7xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f7xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f7xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f7xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f7xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f7xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f7xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f7xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f7xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f7xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LPTIM_MODULE_ENABLED
- #include "stm32f7xx_hal_lptim.h"
-#endif /* HAL_LPTIM_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f7xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f7xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_QSPI_MODULE_ENABLED
- #include "stm32f7xx_hal_qspi.h"
-#endif /* HAL_QSPI_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f7xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f7xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f7xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f7xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPDIFRX_MODULE_ENABLED
- #include "stm32f7xx_hal_spdifrx.h"
-#endif /* HAL_SPDIFRX_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f7xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f7xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f7xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f7xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f7xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f7xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f7xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f7xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f7xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F7xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_F767ZI/mpconfigboard.h b/ports/stm32/boards/NUCLEO_F767ZI/mpconfigboard.h
index 1ee73c303b380..b659223b4d94e 100644
--- a/ports/stm32/boards/NUCLEO_F767ZI/mpconfigboard.h
+++ b/ports/stm32/boards/NUCLEO_F767ZI/mpconfigboard.h
@@ -1,7 +1,5 @@
-// This board is only confirmed to operate using DFU mode and openocd.
-// DFU mode can be accessed by setting BOOT0 (see schematics)
-// To use openocd run "OPENOCD_CONFIG=boards/openocd_stm32f7.cfg" in
-// the make command.
+// Note: if the board shows odd behaviour check the option bits and make sure nDBANK is
+// set to make the 2MByte space continuous instead of divided into two 1MByte segments.
 
 #define MICROPY_HW_BOARD_NAME       "NUCLEO-F767ZI"
 #define MICROPY_HW_MCU_NAME         "STM32F767"
@@ -12,6 +10,7 @@
 #define MICROPY_HW_ENABLE_RTC       (1)
 #define MICROPY_HW_ENABLE_DAC       (1)
 #define MICROPY_HW_ENABLE_USB       (1)
+#define MICROPY_HW_ENABLE_SDCARD    (1)
 
 #define MICROPY_BOARD_EARLY_INIT    NUCLEO_F767ZI_board_early_init
 void NUCLEO_F767ZI_board_early_init(void);
@@ -30,16 +29,25 @@ void NUCLEO_F767ZI_board_early_init(void);
 #define MICROPY_HW_UART2_CTS        (pin_D3)
 #define MICROPY_HW_UART3_TX         (pin_D8)
 #define MICROPY_HW_UART3_RX         (pin_D9)
-#define MICROPY_HW_UART6_TX         (pin_G14)
-#define MICROPY_HW_UART6_RX         (pin_G9)
+#define MICROPY_HW_UART6_TX         (pin_C6)
+#define MICROPY_HW_UART6_RX         (pin_C7)
+#define MICROPY_HW_UART5_TX         (pin_B6)
+#define MICROPY_HW_UART5_RX         (pin_B12)
+#define MICROPY_HW_UART7_TX         (pin_F7)
+#define MICROPY_HW_UART7_RX         (pin_F6)
+#define MICROPY_HW_UART8_TX         (pin_E1)
+#define MICROPY_HW_UART8_RX         (pin_E0)
+
 #define MICROPY_HW_UART_REPL        PYB_UART_3
 #define MICROPY_HW_UART_REPL_BAUD   115200
 
 // I2C busses
 #define MICROPY_HW_I2C1_SCL         (pin_B8)
 #define MICROPY_HW_I2C1_SDA         (pin_B9)
-#define MICROPY_HW_I2C3_SCL         (pin_H7)
-#define MICROPY_HW_I2C3_SDA         (pin_H8)
+#define MICROPY_HW_I2C2_SCL         (pin_F1)
+#define MICROPY_HW_I2C2_SDA         (pin_F0)
+#define MICROPY_HW_I2C4_SCL         (pin_F14)
+#define MICROPY_HW_I2C4_SDA         (pin_F15)
 
 // SPI
 #define MICROPY_HW_SPI3_NSS         (pin_A4)
@@ -48,10 +56,8 @@ void NUCLEO_F767ZI_board_early_init(void);
 #define MICROPY_HW_SPI3_MOSI        (pin_B5)
 
 // CAN busses
-#define MICROPY_HW_CAN1_TX          (pin_B9)
-#define MICROPY_HW_CAN1_RX          (pin_B8)
-#define MICROPY_HW_CAN2_TX          (pin_B13)
-#define MICROPY_HW_CAN2_RX          (pin_B12)
+#define MICROPY_HW_CAN1_TX          (pin_D1)
+#define MICROPY_HW_CAN1_RX          (pin_D0)
 
 // USRSW is pulled low. Pressing the button makes the input go high.
 #define MICROPY_HW_USRSW_PIN        (pin_C13)
@@ -71,6 +77,11 @@ void NUCLEO_F767ZI_board_early_init(void);
 #define MICROPY_HW_USB_VBUS_DETECT_PIN (pin_A9)
 #define MICROPY_HW_USB_OTG_ID_PIN      (pin_A10)
 
+// SD card detect switch (actual pin may need to be changed for a particular use)
+#define MICROPY_HW_SDCARD_DETECT_PIN        (pin_G2)
+#define MICROPY_HW_SDCARD_DETECT_PULL       (GPIO_PULLUP)
+#define MICROPY_HW_SDCARD_DETECT_PRESENT    (GPIO_PIN_RESET)
+
 // Ethernet via RMII
 #define MICROPY_HW_ETH_MDC          (pin_C1)
 #define MICROPY_HW_ETH_MDIO         (pin_A2)
diff --git a/ports/stm32/boards/NUCLEO_F767ZI/mpconfigboard.mk b/ports/stm32/boards/NUCLEO_F767ZI/mpconfigboard.mk
index c3f12998c3ed7..0fdc1a6dcd17f 100644
--- a/ports/stm32/boards/NUCLEO_F767ZI/mpconfigboard.mk
+++ b/ports/stm32/boards/NUCLEO_F767ZI/mpconfigboard.mk
@@ -8,3 +8,5 @@ TEXT1_ADDR = 0x08020000
 
 # MicroPython settings
 MICROPY_PY_LWIP = 1
+MICROPY_PY_USSL = 1
+MICROPY_SSL_MBEDTLS = 1
diff --git a/ports/stm32/boards/NUCLEO_F767ZI/pins.csv b/ports/stm32/boards/NUCLEO_F767ZI/pins.csv
index d84f8e9d1957b..e447b76b05b06 100644
--- a/ports/stm32/boards/NUCLEO_F767ZI/pins.csv
+++ b/ports/stm32/boards/NUCLEO_F767ZI/pins.csv
@@ -33,43 +33,97 @@ D22,PB5
 D23,PB3
 D24,PA4
 D25,PB4
+D26,PB6
+D27,PB2
+D28,PD13
+D29,PD12
+D30,PD11
+D31,PE2
+D32,PA0
+D33,PB0
+D34,PE0
+D35,PB11
+D36,PB10
+D37,PE15
+D38,PE14
+D39,PE12
+D40,PE10
+D41,PE7
+D42,PE8
+D43,PC8
+D44,PC9
+D45,PC10
+D46,PC11
+D47,PC12
+D48,PD2
+D49,PG2
+D50,PG3
+D51,PD7
+D52,PD6
+D53,PD5
+D54,PD4
+D55,PD3
+D56,PE2
+D57,PE4
+D58,PE5
+D59,PE6
+D60,PE3
+D61,PF8
+D62,PF7
+D63,PF9
+D64,PG1
+D65,PG0
+D66,PD1
+D67,PD0
+D68,PF0
+D69,PF1
+D70,PF2
+D71,PA7
+DAC1,PA4
+DAC2,PA5
 LED1,PB0
 LED2,PB7
 LED3,PB14
 SW,PC13
-TP1,PH2
-TP2,PI8
-TP3,PH15
-AUDIO_INT,PD6
-AUDIO_SDA,PH8
-AUDIO_SCL,PH7
-EXT_SDA,PB9
-EXT_SCL,PB8
-EXT_RST,PG3
-SD_SW,PC13
-LCD_BL_CTRL,PK3
-LCD_INT,PI13
-LCD_SDA,PH8
-LCD_SCL,PH7
-OTG_FS_POWER,PD5
-OTG_FS_OVER_CURRENT,PD4
-OTG_HS_OVER_CURRENT,PE3
+SD_D0,PC8
+SD_D1,PC9
+SD_D2,PC10
+SD_D3,PC11
+SD_CMD,PD2
+SD_CK,PC12
+SD_SW,PG2
+OTG_FS_POWER,PG6
+OTG_FS_OVER_CURRENT,PG7
 USB_VBUS,PA9
 USB_ID,PA10
 USB_DM,PA11
 USB_DP,PA12
-USB_POWER,PG6
-VCP_TX,PD8
-VCP_RX,PD9
 UART2_TX,PD5
 UART2_RX,PD6
 UART2_RTS,PD4
 UART2_CTS,PD3
-UART6_TX,PG14
-UART6_RX,PG9
-SPI_B_NSS,PA4
-SPI_B_SCK,PB3
-SPI_B_MOSI,PB5
+VCP_TX,PD8
+VCP_RX,PD9
+UART3_TX,PD8
+UART3_RX,PD9
+UART5_TX,PB6
+UART5_RX,PB12
+UART6_TX,PC6
+UART6_RX,PC7
+UART7_TX,PF7
+UART7_RX,PF6
+UART8_TX,PE1
+UART8_RX,PE0
+SPI3_NSS,PA4
+SPI3_SCK,PB3
+SPI3_MISO,PB4
+SPI3_MOSI,PB5
+I2C1_SDA,PB9
+I2C1_SCL,PB8
+I2C2_SDA,PF0
+I2C2_SCL,PF1
+I2C4_SCL,PF14
+I2C4_SDA,PF15
 ETH_MDC,PC1
 ETH_MDIO,PA2
 ETH_RMII_REF_CLK,PA1
@@ -79,3 +133,5 @@ ETH_RMII_RXD1,PC5
 ETH_RMII_TX_EN,PG11
 ETH_RMII_TXD0,PG13
 ETH_RMII_TXD1,PB13
+SWDIO,PA13
+SWDCLK,PA14
diff --git a/ports/stm32/boards/NUCLEO_F767ZI/stm32f7xx_hal_conf.h b/ports/stm32/boards/NUCLEO_F767ZI/stm32f7xx_hal_conf.h
index a019ee4ce9665..e241921ddd25b 100644
--- a/ports/stm32/boards/NUCLEO_F767ZI/stm32f7xx_hal_conf.h
+++ b/ports/stm32/boards/NUCLEO_F767ZI/stm32f7xx_hal_conf.h
@@ -1,427 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f7xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.0.1
-  * @date    25-June-2015
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F7xx_HAL_CONF_H
-#define __STM32F7xx_HAL_CONF_H
+#include "boards/stm32f7xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (5000)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CEC_MODULE_ENABLED   */
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-#define HAL_I2S_MODULE_ENABLED
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LPTIM_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-/* #define HAL_QSPI_MODULE_ENABLED */
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-/* #define HAL_SPDIFRX_MODULE_ENABLED */
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED  */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## Timeout Configuration ######################### */
-/**
-  * @brief This is the HAL configuration section
-  */
-#define HAL_ACCURATE_TIMEOUT_ENABLED   0
-#define HAL_TIMEOUT_VALUE              0x1FFFFFF
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSE_VALUE)
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)5000)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE)
- #define LSI_VALUE  ((uint32_t)32000)
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source
-  *        frequency, this source is inserted directly through I2S_CKIN pad.
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  ART_ACCLERATOR_ENABLE        1 /* To enable instruction cache and prefetch */
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   1
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)5)       /* 5 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)5)       /* 5 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-/* LAN8742A PHY Address*/
-#define LAN8742A_PHY_ADDRESS            0x00
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/
-#define PHY_RESET_DELAY                 ((uint32_t)0x00000FFF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
-
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
-
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f7xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f7xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f7xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f7xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f7xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f7xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CEC_MODULE_ENABLED
-  #include "stm32f7xx_hal_cec.h"
-#endif /* HAL_CEC_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f7xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f7xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f7xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f7xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f7xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f7xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f7xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f7xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f7xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f7xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f7xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f7xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f7xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f7xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f7xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LPTIM_MODULE_ENABLED
- #include "stm32f7xx_hal_lptim.h"
-#endif /* HAL_LPTIM_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f7xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f7xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_QSPI_MODULE_ENABLED
- #include "stm32f7xx_hal_qspi.h"
-#endif /* HAL_QSPI_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f7xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f7xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f7xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f7xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPDIFRX_MODULE_ENABLED
- #include "stm32f7xx_hal_spdifrx.h"
-#endif /* HAL_SPDIFRX_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f7xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f7xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f7xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f7xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f7xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f7xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f7xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f7xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f7xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F7xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_H743ZI/mpconfigboard.h b/ports/stm32/boards/NUCLEO_H743ZI/mpconfigboard.h
index 68dece24ff293..4e6b162269a8a 100644
--- a/ports/stm32/boards/NUCLEO_H743ZI/mpconfigboard.h
+++ b/ports/stm32/boards/NUCLEO_H743ZI/mpconfigboard.h
@@ -31,8 +31,21 @@ void NUCLEO_H743ZI_board_early_init(void);
 #define MICROPY_HW_FLASH_LATENCY    FLASH_LATENCY_4
 
 // UART config
+#define MICROPY_HW_UART2_TX         (pin_D5)
+#define MICROPY_HW_UART2_RX         (pin_D6)
+#define MICROPY_HW_UART2_RTS        (pin_D4)
+#define MICROPY_HW_UART2_CTS        (pin_D3)
 #define MICROPY_HW_UART3_TX         (pin_D8)
 #define MICROPY_HW_UART3_RX         (pin_D9)
+#define MICROPY_HW_UART5_TX         (pin_B6)
+#define MICROPY_HW_UART5_RX         (pin_B12)
+#define MICROPY_HW_UART6_TX         (pin_C6)
+#define MICROPY_HW_UART6_RX         (pin_C7)
+#define MICROPY_HW_UART7_TX         (pin_F7)
+#define MICROPY_HW_UART7_RX         (pin_F6)
+#define MICROPY_HW_UART8_TX         (pin_E1)
+#define MICROPY_HW_UART8_RX         (pin_E0)
+
 #define MICROPY_HW_UART_REPL        PYB_UART_3
 #define MICROPY_HW_UART_REPL_BAUD   115200
 
@@ -41,12 +54,14 @@ void NUCLEO_H743ZI_board_early_init(void);
 #define MICROPY_HW_I2C1_SDA         (pin_B9)
 #define MICROPY_HW_I2C2_SCL         (pin_F1)
 #define MICROPY_HW_I2C2_SDA         (pin_F0)
+#define MICROPY_HW_I2C4_SCL         (pin_F14)
+#define MICROPY_HW_I2C4_SDA         (pin_F15)
 
 // SPI
-//#define MICROPY_HW_SPI2_NSS         (pin_I0)
-//#define MICROPY_HW_SPI2_SCK         (pin_I1)
-//#define MICROPY_HW_SPI2_MISO        (pin_B14)
-//#define MICROPY_HW_SPI2_MOSI        (pin_B15)
+#define MICROPY_HW_SPI3_NSS         (pin_A4)
+#define MICROPY_HW_SPI3_SCK         (pin_B3)
+#define MICROPY_HW_SPI3_MISO        (pin_B4)
+#define MICROPY_HW_SPI3_MOSI        (pin_B5)
 
 // USRSW is pulled low. Pressing the button makes the input go high.
 #define MICROPY_HW_USRSW_PIN        (pin_C13)
@@ -66,7 +81,23 @@ void NUCLEO_H743ZI_board_early_init(void);
 #define MICROPY_HW_USB_VBUS_DETECT_PIN (pin_A9)
 #define MICROPY_HW_USB_OTG_ID_PIN      (pin_A10)
 
+// FDCAN bus
+#define MICROPY_HW_CAN1_NAME  "FDCAN1"
+#define MICROPY_HW_CAN1_TX    (pin_D1)
+#define MICROPY_HW_CAN1_RX    (pin_D0)
+
 // SD card detect switch
 #define MICROPY_HW_SDCARD_DETECT_PIN        (pin_G2)
 #define MICROPY_HW_SDCARD_DETECT_PULL       (GPIO_PULLUP)
 #define MICROPY_HW_SDCARD_DETECT_PRESENT    (GPIO_PIN_RESET)
+
+// Ethernet via RMII (MDC define disabled for now until eth.c supports H7)
+//#define MICROPY_HW_ETH_MDC          (pin_C1)
+#define MICROPY_HW_ETH_MDIO         (pin_A2)
+#define MICROPY_HW_ETH_RMII_REF_CLK (pin_A1)
+#define MICROPY_HW_ETH_RMII_CRS_DV  (pin_A7)
+#define MICROPY_HW_ETH_RMII_RXD0    (pin_C4)
+#define MICROPY_HW_ETH_RMII_RXD1    (pin_C5)
+#define MICROPY_HW_ETH_RMII_TX_EN   (pin_G11)
+#define MICROPY_HW_ETH_RMII_TXD0    (pin_G13)
+#define MICROPY_HW_ETH_RMII_TXD1    (pin_B13)
diff --git a/ports/stm32/boards/NUCLEO_H743ZI/mpconfigboard.mk b/ports/stm32/boards/NUCLEO_H743ZI/mpconfigboard.mk
index 1d232e0803f19..ce8f83e57d52b 100644
--- a/ports/stm32/boards/NUCLEO_H743ZI/mpconfigboard.mk
+++ b/ports/stm32/boards/NUCLEO_H743ZI/mpconfigboard.mk
@@ -16,3 +16,8 @@ LD_FILES = boards/stm32h743.ld boards/common_ifs.ld
 TEXT0_ADDR = 0x08000000
 TEXT1_ADDR = 0x08040000
 endif
+
+# MicroPython settings
+MICROPY_PY_LWIP = 1
+MICROPY_PY_USSL = 1
+MICROPY_SSL_MBEDTLS = 1
diff --git a/ports/stm32/boards/NUCLEO_H743ZI/pins.csv b/ports/stm32/boards/NUCLEO_H743ZI/pins.csv
index 30910c4dd55c2..d3647ca42a3ea 100644
--- a/ports/stm32/boards/NUCLEO_H743ZI/pins.csv
+++ b/ports/stm32/boards/NUCLEO_H743ZI/pins.csv
@@ -1,42 +1,97 @@
-A0,PA0
-A1,PF10
-A2,PF9
-A3,PF8
-A4,PF7
-A5,PF6
-D0,PC7
-D1,PC6
-D2,PG6
-D3,PB4
-D4,PG7
-D5,PA8
-D6,PH6
-D7,PI3
-D8,PI2
-D9,PA15
-D10,PI0
-D11,PB15
-D12,PB14
-D13,PI1
+A0,PA3
+A1,PC0
+A2,PC3
+A3,PB1
+A4,PC2
+A5,PF10
+A6,PF4
+A7,PF5
+A8,PF6
+D0,PB7
+D1,PB6
+D2,PG14
+D3,PE13
+D4,PE14
+D5,PE11
+D6,PE9
+D7,PG12
+D8,PF3
+D9,PD15
+D10,PD14
+D11,PB5
+D12,PA6
+D13,PA7
 D14,PB9
 D15,PB8
+D16,PC6
+D17,PB15
+D18,PB13
+D19,PB12
+D20,PA15
+D21,PC7
+D22,PB5
+D23,PB3
+D24,PA4
+D25,PB4
+D26,PG6
+D27,PB2
+D28,PD13
+D29,PD12
+D30,PD11
+D31,PE2
+D32,PA0
+D33,PB0
+D34,PE0
+D35,PB11
+D36,PB10
+D37,PE15
+D38,PE6
+D39,PE12
+D40,PE10
+D41,PE7
+D42,PE8
+D43,PC8
+D44,PC9
+D45,PC10
+D46,PC11
+D47,PC12
+D48,PD2
+D49,PG2
+D50,PG3
+D51,PD7
+D52,PD6
+D53,PD5
+D54,PD4
+D55,PD3
+D56,PE2
+D57,PE4
+D58,PE5
+D59,PE6
+D60,PE3
+D61,PF8
+D62,PF7
+D63,PF9
+D64,PG1
+D65,PG0
+D66,PD1
+D67,PD0
+D68,PF0
+D69,PF1
+D70,PF2
+D71,PE9
+D72,PB2
 DAC1,PA4
 DAC2,PA5
 LED1,PB0
 LED2,PB7
 LED3,PB14
 SW,PC13
-TP1,PH2
-TP2,PI8
-TP3,PH15
-AUDIO_INT,PD6
-AUDIO_SDA,PH8
-AUDIO_SCL,PH7
 I2C1_SDA,PB9
 I2C1_SCL,PB8
 I2C2_SDA,PF0
 I2C2_SCL,PF1
-EXT_RST,PG3
+I2C4_SCL,PF14
+I2C4_SDA,PF15
 SD_D0,PC8
 SD_D1,PC9
 SD_D2,PC10
@@ -44,20 +99,32 @@ SD_D3,PC11
 SD_CMD,PD2
 SD_CK,PC12
 SD_SW,PG2
-LCD_BL_CTRL,PK3
-LCD_INT,PI13
-LCD_SDA,PH8
-LCD_SCL,PH7
-OTG_FS_POWER,PD5
-OTG_FS_OVER_CURRENT,PD4
-OTG_HS_OVER_CURRENT,PE3
-USB_VBUS,PJ12
-USB_ID,PA8
+OTG_FS_POWER,PG6
+OTG_FS_OVER_CURRENT,PG7
+USB_VBUS,PA9
+USB_ID,PA10
 USB_DM,PA11
 USB_DP,PA12
-UART1_TX,PA9
-UART1_RX,PA10
-UART5_TX,PC12
-UART5_RX,PD2
+UART2_TX,PD5
+UART2_RX,PD6
+UART2_RTS,PD4
+UART2_CTS,PD3
 UART3_TX,PD8
 UART3_RX,PD9
+UART5_TX,PB6
+UART5_RX,PB12
+UART6_TX,PC6
+UART6_RX,PC7
+UART7_TX,PF7
+UART7_RX,PF6
+UART8_TX,PE1
+UART8_RX,PE0
+ETH_MDC,PC1
+ETH_MDIO,PA2
+ETH_RMII_REF_CLK,PA1
+ETH_RMII_CRS_DV,PA7
+ETH_RMII_RXD0,PC4
+ETH_RMII_RXD1,PC5
+ETH_RMII_TX_EN,PG11
+ETH_RMII_TXD0,PG13
+ETH_RMII_TXD1,PB13
diff --git a/ports/stm32/boards/NUCLEO_H743ZI/stm32h7xx_hal_conf.h b/ports/stm32/boards/NUCLEO_H743ZI/stm32h7xx_hal_conf.h
index 97b141d49f8f3..45400cdcd734b 100644
--- a/ports/stm32/boards/NUCLEO_H743ZI/stm32h7xx_hal_conf.h
+++ b/ports/stm32/boards/NUCLEO_H743ZI/stm32h7xx_hal_conf.h
@@ -1,434 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32h7xx_hal_conf_template.h
-  * @author  MCD Application Team
-  * @version V1.2.0
-  * @date   29-December-2017
-  * @brief   HAL configuration template file.
-  *          This file should be copied to the application folder and renamed
-  *          to stm32h7xx_hal_conf.h.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32H7XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32H7XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32H7xx_HAL_CONF_H
-#define __STM32H7xx_HAL_CONF_H
+#include "boards/stm32h7xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (5000)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CEC_MODULE_ENABLED
-#define HAL_COMP_MODULE_ENABLED
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_CRC_MODULE_ENABLED
-#define HAL_CRYP_MODULE_ENABLED
-#define HAL_DAC_MODULE_ENABLED
-#define HAL_DCMI_MODULE_ENABLED
-#define HAL_DFSDM_MODULE_ENABLED
-#define HAL_DMA_MODULE_ENABLED
-#define HAL_DMA2D_MODULE_ENABLED
-#define HAL_ETH_MODULE_ENABLED
-#define HAL_FDCAN_MODULE_ENABLED
-#define HAL_FLASH_MODULE_ENABLED
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_HASH_MODULE_ENABLED
-#define HAL_HCD_MODULE_ENABLED
-#define HAL_HRTIM_MODULE_ENABLED
-#define HAL_HSEM_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-#define HAL_I2S_MODULE_ENABLED
-#define HAL_IRDA_MODULE_ENABLED
-#define HAL_IWDG_MODULE_ENABLED
-#define HAL_JPEG_MODULE_ENABLED
-#define HAL_LPTIM_MODULE_ENABLED
-#define HAL_LTDC_MODULE_ENABLED
-#define HAL_MDIOS_MODULE_ENABLED
-#define HAL_MDMA_MODULE_ENABLED
-#define HAL_MMC_MODULE_ENABLED
-#define HAL_NAND_MODULE_ENABLED
-#define HAL_NOR_MODULE_ENABLED
-#define HAL_OPAMP_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_QSPI_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-#define HAL_SAI_MODULE_ENABLED
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SDRAM_MODULE_ENABLED
-#define HAL_SMARTCARD_MODULE_ENABLED
-#define HAL_SMBUS_MODULE_ENABLED
-#define HAL_SPDIFRX_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_SRAM_MODULE_ENABLED
-#define HAL_SWPMI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-#define HAL_USART_MODULE_ENABLED
-#define HAL_WWDG_MODULE_ENABLED
-
-/* ########################## Oscillator Values adaptation ####################*/
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSE_VALUE)
-#define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)5000)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal  oscillator (CSI) default value.
-  *        This value is the default CSI value after Reset.
-  */
-#if !defined  (CSI_VALUE)
-  #define CSI_VALUE    ((uint32_t)4000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* CSI_VALUE */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)64000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  *        This value is used by the UART, RTC HAL module to compute the system frequency
-  */
-#if !defined  (LSE_VALUE)
-  #define LSE_VALUE    ((uint32_t)32768) /*!< Value of the External oscillator in Hz*/
-#endif /* LSE_VALUE */
-
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source
-  *        frequency, this source is inserted directly through I2S_CKIN pad.
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    12288000U /*!< Value of the External clock in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  USE_SD_TRANSCEIVER           0U               /*!< use uSD Transceiver */
-
-/* ########################### Ethernet Configuration ######################### */
-#define ETH_TX_DESC_CNT         4  /* number of Ethernet Tx DMA descriptors */
-#define ETH_RX_DESC_CNT         4  /* number of Ethernet Rx DMA descriptors */
-
-#define ETH_MAC_ADDR0    ((uint8_t)0x02)
-#define ETH_MAC_ADDR1    ((uint8_t)0x00)
-#define ETH_MAC_ADDR2    ((uint8_t)0x00)
-#define ETH_MAC_ADDR3    ((uint8_t)0x00)
-#define ETH_MAC_ADDR4    ((uint8_t)0x00)
-#define ETH_MAC_ADDR5    ((uint8_t)0x00)
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## SPI peripheral configuration ########################## */
-/**
-  * @brief Used to activate CRC feature inside HAL SPI Driver
-  *        Activated   (1U): CRC code is compiled within HAL SPI driver
-  *        Deactivated (0U): CRC code excluded from HAL SPI driver
-  */
-
-#define USE_SPI_CRC                   1U
-
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32h7xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32h7xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32h7xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_HASH_MODULE_ENABLED
-  #include "stm32h7xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32h7xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32h7xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DFSDM_MODULE_ENABLED
-  #include "stm32h7xx_hal_dfsdm.h"
-#endif /* HAL_DFSDM_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32h7xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32h7xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32h7xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_FDCAN_MODULE_ENABLED
-  #include "stm32h7xx_hal_fdcan.h"
-#endif /* HAL_FDCAN_MODULE_ENABLED */
-
-#ifdef HAL_CEC_MODULE_ENABLED
-  #include "stm32h7xx_hal_cec.h"
-#endif /* HAL_CEC_MODULE_ENABLED */
-
-#ifdef HAL_COMP_MODULE_ENABLED
-  #include "stm32h7xx_hal_comp.h"
-#endif /* HAL_COMP_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32h7xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32h7xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32h7xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32h7xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_HRTIM_MODULE_ENABLED
-  #include "stm32h7xx_hal_hrtim.h"
-#endif /* HAL_HRTIM_MODULE_ENABLED */
-
-#ifdef HAL_HSEM_MODULE_ENABLED
-  #include "stm32h7xx_hal_hsem.h"
-#endif /* HAL_HSEM_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32h7xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32h7xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32h7xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32h7xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32h7xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32h7xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_JPEG_MODULE_ENABLED
- #include "stm32h7xx_hal_jpeg.h"
-#endif /* HAL_JPEG_MODULE_ENABLED */
-
-#ifdef HAL_MDIOS_MODULE_ENABLED
- #include "stm32h7xx_hal_mdios.h"
-#endif /* HAL_MDIOS_MODULE_ENABLED */
-
-#ifdef HAL_MDMA_MODULE_ENABLED
- #include "stm32h7xx_hal_mdma.h"
-#endif /* HAL_MDMA_MODULE_ENABLED */
-
-#ifdef HAL_MMC_MODULE_ENABLED
- #include "stm32h7xx_hal_mmc.h"
-#endif /* HAL_MMC_MODULE_ENABLED */
-
-#ifdef HAL_LPTIM_MODULE_ENABLED
-#include "stm32h7xx_hal_lptim.h"
-#endif /* HAL_LPTIM_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
-#include "stm32h7xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_OPAMP_MODULE_ENABLED
-#include "stm32h7xx_hal_opamp.h"
-#endif /* HAL_OPAMP_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32h7xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_QSPI_MODULE_ENABLED
- #include "stm32h7xx_hal_qspi.h"
-#endif /* HAL_QSPI_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32h7xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32h7xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32h7xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32h7xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SDRAM_MODULE_ENABLED
- #include "stm32h7xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32h7xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_SPDIFRX_MODULE_ENABLED
- #include "stm32h7xx_hal_spdifrx.h"
-#endif /* HAL_SPDIFRX_MODULE_ENABLED */
-
-#ifdef HAL_SWPMI_MODULE_ENABLED
- #include "stm32h7xx_hal_swpmi.h"
-#endif /* HAL_SWPMI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32h7xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32h7xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32h7xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32h7xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32h7xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_SMBUS_MODULE_ENABLED
- #include "stm32h7xx_hal_smbus.h"
-#endif /* HAL_SMBUS_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32h7xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32h7xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32h7xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32H7xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32H7XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_L073RZ/mpconfigboard.h b/ports/stm32/boards/NUCLEO_L073RZ/mpconfigboard.h
new file mode 100644
index 0000000000000..2b01bd33a3f1d
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_L073RZ/mpconfigboard.h
@@ -0,0 +1,55 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * MIT License; Copyright (c) 2019 Damien P. George
+ */
+
+#define MICROPY_HW_BOARD_NAME       "NUCLEO-L073RZ"
+#define MICROPY_HW_MCU_NAME         "STM32L073RZT6"
+
+#define MICROPY_EMIT_THUMB          (0)
+#define MICROPY_EMIT_INLINE_THUMB   (0)
+#define MICROPY_PY_BUILTINS_COMPLEX (0)
+#define MICROPY_PY_GENERATOR_PEND_THROW (0)
+#define MICROPY_PY_MATH             (0)
+#define MICROPY_PY_FRAMEBUF         (0)
+#define MICROPY_PY_USOCKET          (0)
+#define MICROPY_PY_NETWORK          (0)
+#define MICROPY_PY_STM              (0)
+#define MICROPY_PY_PYB_LEGACY       (0)
+#define MICROPY_PY_UHEAPQ           (0)
+#define MICROPY_PY_UTIMEQ           (0)
+
+#define MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE (0)
+#define MICROPY_HW_ENABLE_RTC       (1)
+#define MICROPY_HW_ENABLE_ADC       (0)
+#define MICROPY_HW_HAS_SWITCH       (1)
+
+// UART config
+#define MICROPY_HW_UART1_TX     (pin_B6)
+#define MICROPY_HW_UART1_RX     (pin_B7)
+#define MICROPY_HW_UART2_TX     (pin_A2)
+#define MICROPY_HW_UART2_RX     (pin_A3)
+
+// USART2 is connected to the ST-LINK USB VCP
+#define MICROPY_HW_UART_REPL PYB_UART_2
+#define MICROPY_HW_UART_REPL_BAUD 115200
+
+// I2C busses
+#define MICROPY_HW_I2C1_SCL (pin_B8)        // Arduino D15, pin 3 on CN10
+#define MICROPY_HW_I2C1_SDA (pin_B9)        // Arduino D14, pin 5 on CN10
+
+// SPI busses
+#define MICROPY_HW_SPI1_NSS     (pin_A15)   //              pin 17 on CN7
+#define MICROPY_HW_SPI1_SCK     (pin_A5)    // Arduino D13, pin 11 on CN10
+#define MICROPY_HW_SPI1_MISO    (pin_A6)    // Arduino D12, pin 13 on CN10
+#define MICROPY_HW_SPI1_MOSI    (pin_A7)    // Arduino D11, pin 15 on CN10
+
+// USER B1 has a pull-up and is active low
+#define MICROPY_HW_USRSW_PIN        (pin_C13)
+#define MICROPY_HW_USRSW_PULL       (0)
+#define MICROPY_HW_USRSW_EXTI_MODE  (GPIO_MODE_IT_FALLING)
+#define MICROPY_HW_USRSW_PRESSED    (0)
+
+// NUCLEO-64 has one user LED
+#define MICROPY_HW_LED1             (pin_A5) // green
+#define MICROPY_HW_LED_ON(pin)      (mp_hal_pin_high(pin))
+#define MICROPY_HW_LED_OFF(pin)     (mp_hal_pin_low(pin))
diff --git a/ports/stm32/boards/NUCLEO_L073RZ/mpconfigboard.mk b/ports/stm32/boards/NUCLEO_L073RZ/mpconfigboard.mk
new file mode 100644
index 0000000000000..f3673f00601f0
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_L073RZ/mpconfigboard.mk
@@ -0,0 +1,10 @@
+MCU_SERIES = l0
+CMSIS_MCU = STM32L073xx
+AF_FILE = boards/stm32l072_af.csv
+LD_FILES = boards/stm32l072xz.ld boards/common_basic.ld
+
+# MicroPython settings
+MICROPY_VFS_FAT = 0
+
+# Don't include default frozen modules because MCU is tight on flash space
+FROZEN_MANIFEST ?=
diff --git a/ports/stm32/boards/NUCLEO_L073RZ/pins.csv b/ports/stm32/boards/NUCLEO_L073RZ/pins.csv
new file mode 100644
index 0000000000000..7386425acf81a
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_L073RZ/pins.csv
@@ -0,0 +1,87 @@
+D0,PA3
+D1,PA2
+D2,PA10
+D3,PB3
+D4,PB5
+D5,PB4
+D6,PB10
+D7,PA8
+D8,PA9
+D9,PC7
+D10,PB6
+D11,PA7
+D12,PA6
+D13,PA5
+D14,PB9
+D15,PB8
+A0,PA0
+A1,PA1
+A2,PA4
+A3,PB0
+A4,PC1
+A5,PC0
+RX,PA3
+TX,PA2
+SCL,PB8
+SDA,PB9
+SCK,PA5
+MISO,PA6
+MOSI,PA7
+CS,PB6
+BOOT0,PF11
+SWDIO,PA13
+SWCLK,PA14
+USER_B1,PC13
+LED_GREEN,PA5
+,PA0
+,PA1
+,PA2
+,PA3
+,PA4
+,PA5
+,PA6
+,PA7
+,PA8
+,PA9
+,PA10
+,PA11
+,PA12
+,PA13
+,PA14
+,PA15
+,PB0
+,PB1
+,PB2
+,PB3
+,PB4
+,PB5
+,PB6
+,PB7
+,PB8
+,PB9
+,PB10
+,PB11
+,PB12
+,PB13
+,PB14
+,PB15
+,PC0
+,PC1
+,PC2
+,PC3
+,PC4
+,PC5
+,PC6
+,PC7
+,PC8
+,PC9
+,PC10
+,PC11
+,PC12
+,PC13
+,PC14
+,PC15
+,PD2
+,PF0
+,PF1
+,PF11
diff --git a/ports/stm32/boards/NUCLEO_L073RZ/stm32l0xx_hal_conf.h b/ports/stm32/boards/NUCLEO_L073RZ/stm32l0xx_hal_conf.h
new file mode 100644
index 0000000000000..c88a7065103d3
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_L073RZ/stm32l0xx_hal_conf.h
@@ -0,0 +1,18 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32L0XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32L0XX_HAL_CONF_H
+
+#include "boards/stm32l0xx_hal_conf_base.h"
+
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#endif // MICROPY_INCLUDED_STM32L0XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_L432KC/mpconfigboard.h b/ports/stm32/boards/NUCLEO_L432KC/mpconfigboard.h
index aa8c9e67448c1..6a3a364dc57a9 100644
--- a/ports/stm32/boards/NUCLEO_L432KC/mpconfigboard.h
+++ b/ports/stm32/boards/NUCLEO_L432KC/mpconfigboard.h
@@ -3,16 +3,20 @@
 
 #define MICROPY_EMIT_THUMB          (0)
 #define MICROPY_EMIT_INLINE_THUMB   (0)
+#define MICROPY_PY_BUILTINS_COMPLEX (0)
+#define MICROPY_PY_GENERATOR_PEND_THROW (0)
 #define MICROPY_PY_USOCKET          (0)
 #define MICROPY_PY_NETWORK          (0)
 #define MICROPY_PY_STM              (0)
 #define MICROPY_PY_PYB_LEGACY       (0)
-#define MICROPY_VFS_FAT             (0)
+#define MICROPY_PY_UHEAPQ           (0)
+#define MICROPY_PY_UTIMEQ           (0)
 
 #define MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE (0)
 #define MICROPY_HW_ENABLE_RTC       (1)
 #define MICROPY_HW_ENABLE_ADC       (1)
 #define MICROPY_HW_ENABLE_DAC       (1)
+#define MICROPY_HW_ENABLE_USB       (0) // requires a custom USB connector on PA11/PA12
 #define MICROPY_HW_ENABLE_TIMER     (1)
 #define MICROPY_HW_HAS_SWITCH       (0)
 
@@ -23,6 +27,9 @@
 #define MICROPY_HW_CLK_PLLP (7)
 #define MICROPY_HW_CLK_PLLQ (2)
 
+// The board has an external 32kHz crystal
+#define MICROPY_HW_RTC_USE_LSE      (1)
+
 // UART config
 #define MICROPY_HW_UART1_TX     (pin_B6)
 #define MICROPY_HW_UART1_RX     (pin_B7)
@@ -56,4 +63,8 @@
 #define MICROPY_HW_LED_OFF(pin)     (mp_hal_pin_low(pin))
 
 // USB config
-#define MICROPY_HW_USB_FS (0)
+#define MICROPY_HW_USB_FS           (MICROPY_HW_ENABLE_USB)
+#define MICROPY_HW_USB_MSC          (0)
+#define MICROPY_HW_USB_HID          (0)
+#define USBD_CDC_RX_DATA_SIZE       (256)
+#define USBD_CDC_TX_DATA_SIZE       (256)
diff --git a/ports/stm32/boards/NUCLEO_L432KC/mpconfigboard.mk b/ports/stm32/boards/NUCLEO_L432KC/mpconfigboard.mk
index e8740d64adf35..6e220a4370db3 100644
--- a/ports/stm32/boards/NUCLEO_L432KC/mpconfigboard.mk
+++ b/ports/stm32/boards/NUCLEO_L432KC/mpconfigboard.mk
@@ -3,3 +3,9 @@ CMSIS_MCU = STM32L432xx
 AF_FILE = boards/stm32l432_af.csv
 LD_FILES = boards/stm32l432.ld boards/common_basic.ld
 OPENOCD_CONFIG = boards/openocd_stm32l4.cfg
+
+# MicroPython settings
+MICROPY_VFS_FAT = 0
+
+# Don't include default frozen modules because MCU is tight on flash space
+FROZEN_MANIFEST ?=
diff --git a/ports/stm32/boards/NUCLEO_L432KC/stm32l4xx_hal_conf.h b/ports/stm32/boards/NUCLEO_L432KC/stm32l4xx_hal_conf.h
index 1ee8fbabc4545..fd380ab7357e2 100755
--- a/ports/stm32/boards/NUCLEO_L432KC/stm32l4xx_hal_conf.h
+++ b/ports/stm32/boards/NUCLEO_L432KC/stm32l4xx_hal_conf.h
@@ -1,384 +1,20 @@
-/**
-  ******************************************************************************
-  * @file    stm32l4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.2.0
-  * @date    25-November-2015
-  * @brief   HAL configuration template file.
-  *          This file should be copied to the application folder and renamed
-  *          to stm32l4xx_hal_conf.h.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
-
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32L4xx_HAL_CONF_H
-#define __STM32L4xx_HAL_CONF_H
-
-#ifdef __cplusplus
- extern "C" {
-#endif
-
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
-
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_COMP_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DFSDM_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_FIREWALL_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LCD_MODULE_ENABLED */
-/* #define HAL_LPTIM_MODULE_ENABLED */
-/* #define HAL_OPAMP_MODULE_ENABLED */
-#define HAL_PCD_MODULE_ENABLED
-#define HAL_PWR_MODULE_ENABLED
-/* #define HAL_QSPI_MODULE_ENABLED */
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-/* #define HAL_SD_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_SMBUS_MODULE_ENABLED */
-#define HAL_SPI_MODULE_ENABLED
-/* #define HAL_SWPMI_MODULE_ENABLED */
-#define HAL_TIM_MODULE_ENABLED
-/* #define HAL_TSC_MODULE_ENABLED */
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-
-
-/* ########################## Oscillator Values adaptation ####################*/
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).  
-  */
-#if !defined  (HSE_VALUE) 
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal Multiple Speed oscillator (MSI) default value.
-  *        This value is the default MSI range value after Reset.
-  */
-#if !defined  (MSI_VALUE)
-  #define MSI_VALUE    ((uint32_t)4000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* MSI_VALUE */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL). 
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
- /**
-   * @brief Internal High Speed oscillator (HSI48) value for USB FS, SDMMC and RNG.
-   *        This internal oscillator is mainly dedicated to provide a high precision clock to
-   *        the USB peripheral by means of a special Clock Recovery System (CRS) circuitry.
-   *        When the CRS is not used, the HSI48 RC oscillator runs on it default frequency
-   *        which is subject to manufacturing process variations.
-   */
- #if !defined  (HSI48_VALUE)
-  #define HSI48_VALUE   ((uint32_t)48000000U) /*!< Value of the Internal High Speed oscillator for USB FS/SDMMC/RNG in Hz.
-                                               The real value my vary depending on manufacturing process variations.*/
- #endif /* HSI48_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE) 
- #define LSI_VALUE  ((uint32_t)32000)       /*!< LSI Typical Value in Hz*/
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  *        This value is used by the UART, RTC HAL module to compute the system frequency
-  */
-#if !defined  (LSE_VALUE)
-  #define LSE_VALUE    ((uint32_t)32768) /*!< Value of the External oscillator in Hz*/
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000)   /*!< Time out for LSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for SAI1 peripheral
-  *        This value is used by the RCC HAL module to compute the SAI1 & SAI2 clock source 
-  *        frequency.
-  */
-#if !defined  (EXTERNAL_SAI1_CLOCK_VALUE)
-  #define EXTERNAL_SAI1_CLOCK_VALUE    ((uint32_t)48000) /*!< Value of the SAI1 External clock source in Hz*/
-#endif /* EXTERNAL_SAI1_CLOCK_VALUE */
-
-/**
-  * @brief External clock source for SAI2 peripheral
-  *        This value is used by the RCC HAL module to compute the SAI1 & SAI2 clock source 
-  *        frequency.
-  */
-#if !defined  (EXTERNAL_SAI2_CLOCK_VALUE)
-  #define EXTERNAL_SAI2_CLOCK_VALUE    ((uint32_t)48000) /*!< Value of the SAI2 External clock source in Hz*/
-#endif /* EXTERNAL_SAI2_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32l4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32l4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32l4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_DFSDM_MODULE_ENABLED
-  #include "stm32l4xx_hal_dfsdm.h"
-#endif /* HAL_DFSDM_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32l4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32l4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32l4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_COMP_MODULE_ENABLED
-  #include "stm32l4xx_hal_comp.h"
-#endif /* HAL_COMP_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32l4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32l4xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32l4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_FIREWALL_MODULE_ENABLED
-  #include "stm32l4xx_hal_firewall.h"
-#endif /* HAL_FIREWALL_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32l4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32l4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32l4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32l4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32l4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32l4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LCD_MODULE_ENABLED
- #include "stm32l4xx_hal_lcd.h"
-#endif /* HAL_LCD_MODULE_ENABLED */
-
-#ifdef HAL_LPTIM_MODULE_ENABLED
-#include "stm32l4xx_hal_lptim.h"
-#endif /* HAL_LPTIM_MODULE_ENABLED */
-
-#ifdef HAL_OPAMP_MODULE_ENABLED
-#include "stm32l4xx_hal_opamp.h"
-#endif /* HAL_OPAMP_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32l4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_QSPI_MODULE_ENABLED
- #include "stm32l4xx_hal_qspi.h"
-#endif /* HAL_QSPI_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32l4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32l4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32l4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32l4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SMBUS_MODULE_ENABLED
- #include "stm32l4xx_hal_smbus.h"
-#endif /* HAL_SMBUS_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32l4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_SWPMI_MODULE_ENABLED
- #include "stm32l4xx_hal_swpmi.h"
-#endif /* HAL_SWPMI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32l4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_TSC_MODULE_ENABLED
- #include "stm32l4xx_hal_tsc.h"
-#endif /* HAL_TSC_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32l4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32l4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32l4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32l4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32l4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32l4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32l4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32L4xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
+
+#include "boards/stm32l4xx_hal_conf_base.h"
+
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_SAI1_CLOCK_VALUE (48000)
+#define EXTERNAL_SAI2_CLOCK_VALUE (48000)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#endif // MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_L452RE/mpconfigboard.h b/ports/stm32/boards/NUCLEO_L452RE/mpconfigboard.h
new file mode 100644
index 0000000000000..9823ae9b9b74d
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_L452RE/mpconfigboard.h
@@ -0,0 +1,74 @@
+#define MICROPY_HW_BOARD_NAME       "NUCLEO-L452RE"
+#define MICROPY_HW_MCU_NAME         "STM32L452RE"
+
+#define MICROPY_PY_USOCKET          (0)
+#define MICROPY_PY_NETWORK          (0)
+
+#define MICROPY_HW_ENABLE_RTC       (1)
+#define MICROPY_HW_ENABLE_RNG       (1)
+#define MICROPY_HW_ENABLE_DAC       (1)
+#define MICROPY_HW_ENABLE_SERVO     (0) // SERVO requires TIM5 (not on L452).
+#define MICROPY_HW_HAS_SWITCH       (1)
+
+// MSI is used and is 4MHz
+#define MICROPY_HW_CLK_PLLM (1)
+#define MICROPY_HW_CLK_PLLN (40)
+#define MICROPY_HW_CLK_PLLP (RCC_PLLP_DIV7)
+#define MICROPY_HW_CLK_PLLQ (RCC_PLLQ_DIV2)
+#define MICROPY_HW_CLK_PLLR (RCC_PLLR_DIV2)
+#define MICROPY_HW_FLASH_LATENCY FLASH_LATENCY_4
+
+// The board has an external 32kHz crystal
+#define MICROPY_HW_RTC_USE_LSE      (1)
+
+// UART config
+#define MICROPY_HW_UART1_TX     (pin_B6)
+#define MICROPY_HW_UART1_RX     (pin_B7)
+#define MICROPY_HW_UART2_TX     (pin_A2)    // VCP TX
+#define MICROPY_HW_UART2_RX     (pin_A3)    // VCP RX
+#define MICROPY_HW_UART3_TX     (pin_C10)
+#define MICROPY_HW_UART3_RX     (pin_C11)
+#define MICROPY_HW_UART4_TX     (pin_A0)
+#define MICROPY_HW_UART4_RX     (pin_A1)
+// USART2 is connected to the ST-LINK USB VCP
+#define MICROPY_HW_UART_REPL        PYB_UART_2
+#define MICROPY_HW_UART_REPL_BAUD   115200
+
+// I2C busses
+#define MICROPY_HW_I2C1_SCL     (pin_B8)    // Arduino D15, pin 3 on CN10
+#define MICROPY_HW_I2C1_SDA     (pin_B9)    // Arduino D14, pin 5 on CN10
+#define MICROPY_HW_I2C2_SCL     (pin_B10)   // Arduino D6,  pin 25 on CN10
+#define MICROPY_HW_I2C2_SDA     (pin_B11)   //              pin 18 on CN10
+#define MICROPY_HW_I2C3_SCL     (pin_A7)    //              pin 15 on CN10
+#define MICROPY_HW_I2C3_SDA     (pin_B4)    //              pin 27 on CN10
+#define MICROPY_HW_I2C4_SCL     (pin_C0)    //              pin 38 on CN7
+#define MICROPY_HW_I2C4_SDA     (pin_C1)    //              pin 36 on CN7
+
+// SPI busses
+#define MICROPY_HW_SPI1_NSS     (pin_A15)   //              pin 17 on CN7
+#define MICROPY_HW_SPI1_SCK     (pin_A5)    // Arduino D13, pin 11 on CN10
+#define MICROPY_HW_SPI1_MISO    (pin_A6)    // Arduino D12, pin 13 on CN10
+#define MICROPY_HW_SPI1_MOSI    (pin_A7)    // Arduino D11, pin 15 on CN10
+#define MICROPY_HW_SPI2_NSS     (pin_B12)   //              pin 16 on CN10
+#define MICROPY_HW_SPI2_SCK     (pin_B13)   //              pin 30 on CN10
+#define MICROPY_HW_SPI2_MISO    (pin_B14)   //              pin 28 on CN10
+#define MICROPY_HW_SPI2_MOSI    (pin_B15)   //              pin 26 on CN10
+#define MICROPY_HW_SPI3_NSS     (pin_A4)    //              pin 32 on CN7
+#define MICROPY_HW_SPI3_SCK     (pin_C10)   //              pin 1 on CN7
+#define MICROPY_HW_SPI3_MISO    (pin_C11)   //              pin 2 on CN7
+#define MICROPY_HW_SPI3_MOSI    (pin_C12)   //              pin 3 on CN7
+
+// CAN busses
+#define MICROPY_HW_CAN1_TX (pin_B9)
+#define MICROPY_HW_CAN1_RX (pin_B8)
+
+// USER B1 has a pull-up and is active low
+#define MICROPY_HW_USRSW_PIN        (pin_C13)
+#define MICROPY_HW_USRSW_PULL       (0)
+#define MICROPY_HW_USRSW_EXTI_MODE  (GPIO_MODE_IT_FALLING)
+#define MICROPY_HW_USRSW_PRESSED    (0)
+
+// NUCLEO-64 has one user LED
+#define MICROPY_HW_LED1             (pin_A5) // green
+#define MICROPY_HW_LED_ON(pin)      (mp_hal_pin_high(pin))
+#define MICROPY_HW_LED_OFF(pin)     (mp_hal_pin_low(pin))
diff --git a/ports/stm32/boards/NUCLEO_L452RE/mpconfigboard.mk b/ports/stm32/boards/NUCLEO_L452RE/mpconfigboard.mk
new file mode 100644
index 0000000000000..25ccb45a9427e
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_L452RE/mpconfigboard.mk
@@ -0,0 +1,5 @@
+MCU_SERIES = l4
+CMSIS_MCU = STM32L452xx
+AF_FILE = boards/stm32l452_af.csv
+LD_FILES = boards/stm32l452xe.ld boards/common_basic.ld
+OPENOCD_CONFIG = boards/openocd_stm32l4.cfg
diff --git a/ports/stm32/boards/NUCLEO_L452RE/pins.csv b/ports/stm32/boards/NUCLEO_L452RE/pins.csv
new file mode 100644
index 0000000000000..adc319575ac07
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_L452RE/pins.csv
@@ -0,0 +1,86 @@
+CN9_D0,PA3
+CN9_D1,PA2
+CN9_D2,PA10
+CN9_D3,PB3
+CN9_D4,PB5
+CN9_D5,PB4
+CN9_D6,PB10
+CN9_D7,PA8
+CN5_D8,PA9
+CN5_D9,PC7
+CN5_D10,PB6
+CN5_D11,PA7
+CN5_D12,PA6
+CN5_D13,PA5
+CN5_D14,PB9
+CN5_D15,PB8
+CN8_A0,PA0
+CN8_A1,PA1
+CN8_A2,PA4
+CN8_A3,PB0
+CN8_A4,PC1
+CN8_A5,PC0
+CN9_RX,PA3
+CN9_TX,PA2
+CN5_SCL,PB8
+CN5_SDA,PB9
+CN5_SCK,PA5
+CN5_MISO,PA6
+CN5_MOSI,PA7
+CN5_CS,PB6
+CN7_28,PA0
+CN7_30,PA1
+CN10_35,PA2
+CN10_37,PA3
+CN7_32,PA4
+CN10_11,PA5
+CN10_13,PA6
+CN10_15,PA7
+CN10_23,PA8
+CN10_21,PA9
+CN10_33,PA10
+CN10_14,PA11
+CN10_12,PA12
+CN7_13,PA13
+CN7_15,PA14
+CN7_17,PA15
+CN7_34,PB0
+CN10_24,PB1
+CN10_22,PB2
+CN10_31,PB3
+CN10_27,PB4
+CN10_29,PB5
+CN10_17,PB6
+CN7_21,PB7
+CN10_3,PB8
+CN10_5,PB9
+CN10_25,PB10
+CN10_18,PB11
+CN10_16,PB12
+CN10_30,PB13
+CN10_28,PB14
+CN10_26,PB15
+CN7_38,PC0
+CN7_36,PC1
+CN7_35,PC2
+CN7_37,PC3
+CN10_34,PC4
+CN10_6,PC5
+CN10_4,PC6
+CN10_19,PC7
+CN10_2,PC8
+CN10_1,PC9
+CN7_1,PC10
+CN7_2,PC11
+CN7_3,PC12
+CN7_23,PC13
+CN7_25,PC14
+CN7_27,PC15
+CN7_4,PD2
+CN7_29,PH0
+CN7_31,PH1
+BOOT0,PH3
+SWDIO,PA13
+SWCLK,PA14
+USER_B1,PC13
+LED_GREEN,PA5
diff --git a/ports/stm32/boards/NUCLEO_L452RE/stm32l4xx_hal_conf.h b/ports/stm32/boards/NUCLEO_L452RE/stm32l4xx_hal_conf.h
new file mode 100644
index 0000000000000..fd380ab7357e2
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_L452RE/stm32l4xx_hal_conf.h
@@ -0,0 +1,20 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
+
+#include "boards/stm32l4xx_hal_conf_base.h"
+
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_SAI1_CLOCK_VALUE (48000)
+#define EXTERNAL_SAI2_CLOCK_VALUE (48000)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#endif // MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_L476RG/mpconfigboard.h b/ports/stm32/boards/NUCLEO_L476RG/mpconfigboard.h
index 05298253ae059..00b033006ba9a 100644
--- a/ports/stm32/boards/NUCLEO_L476RG/mpconfigboard.h
+++ b/ports/stm32/boards/NUCLEO_L476RG/mpconfigboard.h
@@ -15,6 +15,9 @@
 #define MICROPY_HW_CLK_PLLQ (RCC_PLLQ_DIV2)
 #define MICROPY_HW_CLK_PLLR (RCC_PLLR_DIV2)
 
+// The board has an external 32kHz crystal
+#define MICROPY_HW_RTC_USE_LSE      (1)
+
 // UART config
 #define MICROPY_HW_UART2_TX     (pin_A2)
 #define MICROPY_HW_UART2_RX     (pin_A3)
diff --git a/ports/stm32/boards/NUCLEO_L476RG/mpconfigboard.mk b/ports/stm32/boards/NUCLEO_L476RG/mpconfigboard.mk
index 38ae5af212cfa..10c69461c9309 100644
--- a/ports/stm32/boards/NUCLEO_L476RG/mpconfigboard.mk
+++ b/ports/stm32/boards/NUCLEO_L476RG/mpconfigboard.mk
@@ -1,6 +1,5 @@
 MCU_SERIES = l4
 CMSIS_MCU = STM32L476xx
 AF_FILE = boards/stm32l476_af.csv
-LD_FILES = boards/stm32l476xg.ld boards/common_ifs.ld
-TEXT0_ADDR = 0x08000000
-TEXT1_ADDR = 0x08004000
+LD_FILES = boards/stm32l476xg.ld boards/common_basic.ld
+OPENOCD_CONFIG = boards/openocd_stm32l4.cfg
diff --git a/ports/stm32/boards/NUCLEO_L476RG/stm32l4xx_hal_conf.h b/ports/stm32/boards/NUCLEO_L476RG/stm32l4xx_hal_conf.h
index 6bfb28118a44b..fd380ab7357e2 100755
--- a/ports/stm32/boards/NUCLEO_L476RG/stm32l4xx_hal_conf.h
+++ b/ports/stm32/boards/NUCLEO_L476RG/stm32l4xx_hal_conf.h
@@ -1,372 +1,20 @@
-/**
-  ******************************************************************************
-  * @file    stm32l4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.2.0
-  * @date    25-November-2015
-  * @brief   HAL configuration template file.
-  *          This file should be copied to the application folder and renamed
-  *          to stm32l4xx_hal_conf.h.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
-
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32L4xx_HAL_CONF_H
-#define __STM32L4xx_HAL_CONF_H
-
-#ifdef __cplusplus
- extern "C" {
-#endif
-
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
-
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_COMP_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DFSDM_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_FIREWALL_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LCD_MODULE_ENABLED */
-/* #define HAL_LPTIM_MODULE_ENABLED */
-/* #define HAL_OPAMP_MODULE_ENABLED */
-#define HAL_PCD_MODULE_ENABLED
-#define HAL_PWR_MODULE_ENABLED
-/* #define HAL_QSPI_MODULE_ENABLED */
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_SMBUS_MODULE_ENABLED */
-#define HAL_SPI_MODULE_ENABLED
-/* #define HAL_SWPMI_MODULE_ENABLED */
-#define HAL_TIM_MODULE_ENABLED
-/* #define HAL_TSC_MODULE_ENABLED */
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-
-
-/* ########################## Oscillator Values adaptation ####################*/
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).  
-  */
-#if !defined  (HSE_VALUE) 
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal Multiple Speed oscillator (MSI) default value.
-  *        This value is the default MSI range value after Reset.
-  */
-#if !defined  (MSI_VALUE)
-  #define MSI_VALUE    ((uint32_t)4000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* MSI_VALUE */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL). 
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE) 
- #define LSI_VALUE  ((uint32_t)32000)       /*!< LSI Typical Value in Hz*/
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  *        This value is used by the UART, RTC HAL module to compute the system frequency
-  */
-#if !defined  (LSE_VALUE)
-  #define LSE_VALUE    ((uint32_t)32768) /*!< Value of the External oscillator in Hz*/
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000)   /*!< Time out for LSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for SAI1 peripheral
-  *        This value is used by the RCC HAL module to compute the SAI1 & SAI2 clock source 
-  *        frequency.
-  */
-#if !defined  (EXTERNAL_SAI1_CLOCK_VALUE)
-  #define EXTERNAL_SAI1_CLOCK_VALUE    ((uint32_t)48000) /*!< Value of the SAI1 External clock source in Hz*/
-#endif /* EXTERNAL_SAI1_CLOCK_VALUE */
-
-/**
-  * @brief External clock source for SAI2 peripheral
-  *        This value is used by the RCC HAL module to compute the SAI1 & SAI2 clock source 
-  *        frequency.
-  */
-#if !defined  (EXTERNAL_SAI2_CLOCK_VALUE)
-  #define EXTERNAL_SAI2_CLOCK_VALUE    ((uint32_t)48000) /*!< Value of the SAI2 External clock source in Hz*/
-#endif /* EXTERNAL_SAI2_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32l4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32l4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32l4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_DFSDM_MODULE_ENABLED
-  #include "stm32l4xx_hal_dfsdm.h"
-#endif /* HAL_DFSDM_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32l4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32l4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32l4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_COMP_MODULE_ENABLED
-  #include "stm32l4xx_hal_comp.h"
-#endif /* HAL_COMP_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32l4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32l4xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32l4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_FIREWALL_MODULE_ENABLED
-  #include "stm32l4xx_hal_firewall.h"
-#endif /* HAL_FIREWALL_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32l4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32l4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32l4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32l4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32l4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32l4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LCD_MODULE_ENABLED
- #include "stm32l4xx_hal_lcd.h"
-#endif /* HAL_LCD_MODULE_ENABLED */
-
-#ifdef HAL_LPTIM_MODULE_ENABLED
-#include "stm32l4xx_hal_lptim.h"
-#endif /* HAL_LPTIM_MODULE_ENABLED */
-
-#ifdef HAL_OPAMP_MODULE_ENABLED
-#include "stm32l4xx_hal_opamp.h"
-#endif /* HAL_OPAMP_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32l4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_QSPI_MODULE_ENABLED
- #include "stm32l4xx_hal_qspi.h"
-#endif /* HAL_QSPI_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32l4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32l4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32l4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32l4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SMBUS_MODULE_ENABLED
- #include "stm32l4xx_hal_smbus.h"
-#endif /* HAL_SMBUS_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32l4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_SWPMI_MODULE_ENABLED
- #include "stm32l4xx_hal_swpmi.h"
-#endif /* HAL_SWPMI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32l4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_TSC_MODULE_ENABLED
- #include "stm32l4xx_hal_tsc.h"
-#endif /* HAL_TSC_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32l4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32l4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32l4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32l4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32l4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32l4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32l4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32L4xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
+
+#include "boards/stm32l4xx_hal_conf_base.h"
+
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_SAI1_CLOCK_VALUE (48000)
+#define EXTERNAL_SAI2_CLOCK_VALUE (48000)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#endif // MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/NUCLEO_WB55/mpconfigboard.h b/ports/stm32/boards/NUCLEO_WB55/mpconfigboard.h
new file mode 100644
index 0000000000000..2992ccce71772
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_WB55/mpconfigboard.h
@@ -0,0 +1,68 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * MIT License; Copyright (c) 2019 Damien P. George
+ */
+
+#define MICROPY_HW_BOARD_NAME       "NUCLEO-WB55"
+#define MICROPY_HW_MCU_NAME         "STM32WB55RGV6"
+
+#define MICROPY_PY_PYB_LEGACY       (0)
+
+#define MICROPY_HW_HAS_FLASH        (1)
+#define MICROPY_HW_ENABLE_RTC       (1)
+#define MICROPY_HW_ENABLE_RNG       (1)
+#define MICROPY_HW_ENABLE_ADC       (0)
+#define MICROPY_HW_ENABLE_USB       (1)
+#define MICROPY_HW_HAS_SWITCH       (1)
+
+// There is an external 32kHz oscillator
+#define RTC_ASYNCH_PREDIV           (0)
+#define RTC_SYNCH_PREDIV            (0x7fff)
+#define MICROPY_HW_RTC_USE_LSE      (1)
+#define MICROPY_HW_RTC_USE_US       (1)
+
+// UART buses
+#define MICROPY_HW_UART1_TX         (pin_B6)
+#define MICROPY_HW_UART1_RX         (pin_B7)
+// USART 1 is connected to the virtual com port on the ST-LINK
+#define MICROPY_HW_UART_REPL        PYB_UART_1
+#define MICROPY_HW_UART_REPL_BAUD   115200
+
+// I2C buses
+#define MICROPY_HW_I2C1_SCL         (pin_B8)    // Arduino D15, pin 3 on CN10
+#define MICROPY_HW_I2C1_SDA         (pin_B9)    // Arduino D14, pin 5 on CN10
+#define MICROPY_HW_I2C3_SCL         (pin_C0)    // Arduino A0, pin 28 on CN7
+#define MICROPY_HW_I2C3_SDA         (pin_C1)    // Arduino A1, pin 30 on CN7
+
+// SPI buses
+#if 0 // TODO need working DMA
+#define MICROPY_HW_SPI1_NSS         (pin_A4)    // Arduino D10  pin 17 on CN10
+#define MICROPY_HW_SPI1_SCK         (pin_A5)    // Arduino D13, pin 11 on CN10
+#define MICROPY_HW_SPI1_MISO        (pin_A6)    // Arduino D12, pin 13 on CN10
+#define MICROPY_HW_SPI1_MOSI        (pin_A7)    // Arduino D11, pin 15 on CN10
+#define MICROPY_HW_SPI2_NSS         (pin_B12)   //              pin 16 on CN10
+#define MICROPY_HW_SPI2_SCK         (pin_B13)   //              pin 30 on CN10
+#define MICROPY_HW_SPI2_MISO        (pin_B14)   //              pin 28 on CN10
+#define MICROPY_HW_SPI2_MOSI        (pin_B15)   //              pin 26 on CN10
+#endif
+
+// User switch; pressing the button makes the input go low
+#define MICROPY_HW_USRSW_PIN        (pin_C4)
+#define MICROPY_HW_USRSW_PULL       (GPIO_PULLUP)
+#define MICROPY_HW_USRSW_EXTI_MODE  (GPIO_MODE_IT_FALLING)
+#define MICROPY_HW_USRSW_PRESSED    (0)
+
+// LEDs
+#define MICROPY_HW_LED1             (pin_B1) // red
+#define MICROPY_HW_LED2             (pin_B0) // green
+#define MICROPY_HW_LED3             (pin_B5) // blue
+#define MICROPY_HW_LED_ON(pin)      (mp_hal_pin_high(pin))
+#define MICROPY_HW_LED_OFF(pin)     (mp_hal_pin_low(pin))
+
+// USB config
+#define MICROPY_HW_USB_FS           (1)
+#define USBD_CDC_RX_DATA_SIZE       (512)
+#define USBD_CDC_TX_DATA_SIZE       (512)
+
+// Bluetooth config
+#define MICROPY_HW_BLE_UART_ID       (0)
+#define MICROPY_HW_BLE_UART_BAUDRATE (115200)
diff --git a/ports/stm32/boards/NUCLEO_WB55/mpconfigboard.mk b/ports/stm32/boards/NUCLEO_WB55/mpconfigboard.mk
new file mode 100644
index 0000000000000..416364df9ef6d
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_WB55/mpconfigboard.mk
@@ -0,0 +1,10 @@
+MCU_SERIES = wb
+CMSIS_MCU = STM32WB55xx
+AF_FILE = boards/stm32wb55_af.csv
+LD_FILES = boards/stm32wb55xg.ld boards/common_basic.ld
+STARTUP_FILE = lib/stm32lib/CMSIS/STM32WBxx/Source/Templates/gcc/startup_stm32wb55xx_cm4.o
+
+# MicroPython settings
+MICROPY_PY_BLUETOOTH = 1
+MICROPY_BLUETOOTH_NIMBLE = 1
+MICROPY_VFS_LFS2 = 1
diff --git a/ports/stm32/boards/NUCLEO_WB55/pins.csv b/ports/stm32/boards/NUCLEO_WB55/pins.csv
new file mode 100644
index 0000000000000..49fdab0c28c58
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_WB55/pins.csv
@@ -0,0 +1,34 @@
+,PA0
+,PA1
+,PA2
+,PA3
+,PA4
+,PA5
+,PA6
+,PA7
+,PB0
+,PB1
+,PB2
+,PB3
+,PB4
+,PB5
+,PB6
+,PB7
+,PB8
+,PB9
+,PB10
+,PB11
+,PB12
+,PB13
+,PB14
+,PB15
+,PC0
+,PC1
+,PC2
+,PC3
+SW,PC4
+LED_GREEN,PB0
+LED_RED,PB1
+LED_BLUE,PB5
+USB_DM,PA11
+USB_DP,PA12
diff --git a/ports/stm32/boards/NUCLEO_WB55/stm32wbxx_hal_conf.h b/ports/stm32/boards/NUCLEO_WB55/stm32wbxx_hal_conf.h
new file mode 100644
index 0000000000000..176857220eb8d
--- /dev/null
+++ b/ports/stm32/boards/NUCLEO_WB55/stm32wbxx_hal_conf.h
@@ -0,0 +1,19 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32WBXX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32WBXX_HAL_CONF_H
+
+// Oscillator values in Hz
+#define HSE_VALUE (32000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_SAI1_CLOCK_VALUE (48000)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#include "boards/stm32wbxx_hal_conf_base.h"
+
+#endif // MICROPY_INCLUDED_STM32WBXX_HAL_CONF_H
diff --git a/ports/stm32/boards/OLIMEX_E407/stm32f4xx_hal_conf.h b/ports/stm32/boards/OLIMEX_E407/stm32f4xx_hal_conf.h
index 24cc9228b80dd..9719157e55cdf 100644
--- a/ports/stm32/boards/OLIMEX_E407/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/OLIMEX_E407/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */ 
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (12000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver 
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-#define HAL_I2S_MODULE_ENABLED
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).  
-  */
-#if !defined  (HSE_VALUE) 
-  #define HSE_VALUE    ((uint32_t)12000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL). 
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE) 
- #define LSI_VALUE  ((uint32_t)40000)    
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source 
-  *        frequency, this source is inserted directly through I2S_CKIN pad. 
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */     
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the 
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */   
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/ 
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/ 
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
- 
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-  
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
- 
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file 
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-   
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h" 
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
- 
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */ 
-  
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */      
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-   
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed. 
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
- 
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/PYBD_SF2/bdev.c b/ports/stm32/boards/PYBD_SF2/bdev.c
new file mode 100644
index 0000000000000..6c5ff721ec707
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF2/bdev.c
@@ -0,0 +1,62 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "storage.h"
+#include "qspi.h"
+
+// Shared cache for first and second SPI block devices
+STATIC mp_spiflash_cache_t spi_bdev_cache;
+
+// First external SPI flash uses software QSPI interface
+
+STATIC const mp_soft_qspi_obj_t soft_qspi_bus = {
+    .cs = MICROPY_HW_SPIFLASH_CS,
+    .clk = MICROPY_HW_SPIFLASH_SCK,
+    .io0 = MICROPY_HW_SPIFLASH_IO0,
+    .io1 = MICROPY_HW_SPIFLASH_IO1,
+    .io2 = MICROPY_HW_SPIFLASH_IO2,
+    .io3 = MICROPY_HW_SPIFLASH_IO3,
+};
+
+const mp_spiflash_config_t spiflash_config = {
+    .bus_kind = MP_SPIFLASH_BUS_QSPI,
+    .bus.u_qspi.data = (void*)&soft_qspi_bus,
+    .bus.u_qspi.proto = &mp_soft_qspi_proto,
+    .cache = &spi_bdev_cache,
+};
+
+spi_bdev_t spi_bdev;
+
+// Second external SPI flash uses hardware QSPI interface
+
+const mp_spiflash_config_t spiflash2_config = {
+    .bus_kind = MP_SPIFLASH_BUS_QSPI,
+    .bus.u_qspi.data = NULL,
+    .bus.u_qspi.proto = &qspi_proto,
+    .cache = &spi_bdev_cache,
+};
+
+spi_bdev_t spi_bdev2;
diff --git a/ports/stm32/boards/PYBD_SF2/board_init.c b/ports/stm32/boards/PYBD_SF2/board_init.c
new file mode 100644
index 0000000000000..d1a0a09e7a477
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF2/board_init.c
@@ -0,0 +1,76 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <string.h>
+#include "py/mphal.h"
+#include "storage.h"
+
+#if defined(STM32F722xx) || defined(STM32F723xx) || defined(STM32F732xx) || defined(STM32F733xx)
+#define OTP_ADDR (0x1ff079e0)
+#else
+#define OTP_ADDR (0x1ff0f3c0)
+#endif
+#define OTP ((pyb_otp_t*)OTP_ADDR)
+
+typedef struct _pyb_otp_t {
+    uint16_t series;
+    uint16_t rev;
+    uint8_t mac[6];
+} pyb_otp_t;
+
+void mboot_board_early_init(void) {
+    // Enable 500mA on WBUS-DIP28
+    mp_hal_pin_config(pyb_pin_W23, MP_HAL_PIN_MODE_INPUT, MP_HAL_PIN_PULL_UP, 0);
+}
+
+void board_early_init(void) {
+    // Configure EN_3V3 as an output pin, but keep it turned off
+    mp_hal_pin_config(pyb_pin_EN_3V3, MP_HAL_PIN_MODE_OUTPUT, MP_HAL_PIN_PULL_NONE, 0);
+
+    // Explicitly init SPI2 because it's not enabled as a block device
+    spi_bdev_ioctl(&spi_bdev2, BDEV_IOCTL_INIT, (uint32_t)&spiflash2_config);
+}
+
+#if !BUILDING_MBOOT
+
+void board_sleep(int value) {
+    mp_spiflash_deepsleep(&spi_bdev.spiflash, value);
+    mp_spiflash_deepsleep(&spi_bdev2.spiflash, value);
+}
+
+void mp_hal_get_mac(int idx, uint8_t buf[6]) {
+    // Check if OTP region has a valid MAC address, and use it if it does
+    if (OTP->series == 0x00d1 && OTP->mac[0] == 'H' && OTP->mac[1] == 'J' && OTP->mac[2] == '0') {
+        memcpy(buf, OTP->mac, 6);
+        buf[5] += idx;
+        return;
+    }
+
+    // Generate a random locally administered MAC address (LAA)
+    mp_hal_generate_laa_mac(idx, buf);
+}
+
+#endif
diff --git a/ports/stm32/boards/PYBD_SF2/f722_qspi.ld b/ports/stm32/boards/PYBD_SF2/f722_qspi.ld
new file mode 100644
index 0000000000000..3b2e45d9b6a11
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF2/f722_qspi.ld
@@ -0,0 +1,110 @@
+/*
+    Linker script for PYBD with STM32F722/STM32F723/STM32F732/STM32F733
+
+    Memory layout for mboot configuration (this here describes the app part):
+
+    FLASH_APP   .isr_vector
+    FLASH_APP   .text
+    FLASH_APP   .data
+
+    FLASH_EXT   .big_const
+
+    RAM         .data
+    RAM         .bss
+    RAM         .heap
+    RAM         .stack
+*/
+
+/* Specify the memory areas */
+MEMORY
+{
+    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 512K
+    FLASH_ISR (rx)  : ORIGIN = 0x08000000, LENGTH = 32K     /* sectors 0,1 */
+    FLASH_APP (rx)  : ORIGIN = 0x08008000, LENGTH = 480K    /* sectors 2-7 */
+    FLASH_EXT (rx)  : ORIGIN = 0x90000000, LENGTH = 2048K   /* external QSPI */
+    RAM (rwx)       : ORIGIN = 0x20000000, LENGTH = 256K    /* DTCM+SRAM1+SRAM2 */
+}
+
+/* produce a link error if there is not this amount of RAM for these sections */
+_minimum_stack_size = 2K;
+_minimum_heap_size = 16K;
+
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 16K;
+
+/* RAM extents for the garbage collector */
+_ram_start = ORIGIN(RAM);
+_ram_end = ORIGIN(RAM) + LENGTH(RAM);
+_heap_start = _ebss; /* heap starts just after statically allocated memory */
+_heap_end = _sstack;
+
+ENTRY(Reset_Handler)
+
+/* Define output sections */
+SECTIONS
+{
+    .text_ext :
+    {
+        . = ALIGN(4);
+        *lib/btstack/*(.text* .rodata*)
+        *lib/mbedtls/*(.text* .rodata*)
+        *lib/mynewt-nimble/*(.text* .rodata*)
+        . = ALIGN(512);
+        *(.big_const*)
+        . = ALIGN(4);
+    } >FLASH_EXT
+
+    .isr_vector :
+    {
+        . = ALIGN(4);
+        KEEP(*(.isr_vector))
+        . = ALIGN(4);
+    } >FLASH_APP
+
+    .text :
+    {
+        . = ALIGN(4);
+        *(.text*)
+        *(.rodata*)
+        . = ALIGN(4);
+        _etext = .;
+    } >FLASH_APP
+
+    _sidata = LOADADDR(.data);
+
+    .data :
+    {
+        . = ALIGN(4);
+        _sdata = .;
+        *(.data*)
+
+        . = ALIGN(4);
+        _edata = .;
+    } >RAM AT> FLASH_APP
+
+    .bss :
+    {
+        . = ALIGN(4);
+        _sbss = .;
+        *(.bss*)
+        *(COMMON)
+        . = ALIGN(4);
+        _ebss = .;
+    } >RAM
+
+    .heap :
+    {
+        . = ALIGN(4);
+        . = . + _minimum_heap_size;
+        . = ALIGN(4);
+    } >RAM
+
+    .stack :
+    {
+        . = ALIGN(4);
+        . = . + _minimum_stack_size;
+        . = ALIGN(4);
+    } >RAM
+}
diff --git a/ports/stm32/boards/PYBD_SF2/manifest.py b/ports/stm32/boards/PYBD_SF2/manifest.py
new file mode 100644
index 0000000000000..3819aa01b3dc6
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF2/manifest.py
@@ -0,0 +1,2 @@
+include("$(PORT_DIR)/boards/manifest.py")
+include("$(MPY_DIR)/extmod/webrepl/manifest.py")
diff --git a/ports/stm32/boards/PYBD_SF2/mpconfigboard.h b/ports/stm32/boards/PYBD_SF2/mpconfigboard.h
new file mode 100644
index 0000000000000..757dacf9a7c18
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF2/mpconfigboard.h
@@ -0,0 +1,212 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#define MICROPY_HW_BOARD_NAME       "PYBD-SF2W"
+#define MICROPY_HW_MCU_NAME         "STM32F722IEK"
+
+#define MICROPY_PY_PYB_LEGACY       (1)
+#define MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE (0)
+#define MICROPY_HW_HAS_SWITCH       (1)
+#define MICROPY_HW_HAS_FLASH        (1)
+#define MICROPY_HW_ENABLE_RNG       (1)
+#define MICROPY_HW_ENABLE_RTC       (1)
+#define MICROPY_HW_ENABLE_TIMER     (1)
+#define MICROPY_HW_ENABLE_SERVO     (1)
+#define MICROPY_HW_ENABLE_DAC       (1)
+#define MICROPY_HW_ENABLE_USB       (1)
+#define MICROPY_HW_ENABLE_SDCARD    (1)
+#define MICROPY_HW_ENABLE_MMCARD    (1)
+
+#define MICROPY_BOARD_EARLY_INIT    board_early_init
+#define MICROPY_BOARD_ENTER_STOP    board_sleep(1);
+#define MICROPY_BOARD_LEAVE_STOP    board_sleep(0);
+#define MICROPY_BOARD_ENTER_STANDBY board_sleep(1);
+#define MICROPY_BOARD_SDCARD_POWER  mp_hal_pin_high(pyb_pin_EN_3V3);
+void board_early_init(void);
+void board_sleep(int value);
+
+// HSE is 25MHz, run SYS at 120MHz
+#define MICROPY_HW_CLK_PLLM         (20)
+#define MICROPY_HW_CLK_PLLN         (192)
+#define MICROPY_HW_CLK_PLLP         (RCC_PLLP_DIV2)
+#define MICROPY_HW_CLK_PLLQ         (5)
+#define MICROPY_HW_FLASH_LATENCY    (FLASH_LATENCY_3)
+
+// There is an external 32kHz oscillator
+#define RTC_ASYNCH_PREDIV           (3)
+#define RTC_SYNCH_PREDIV            (0x1fff)
+#define MICROPY_HW_RTC_USE_BYPASS   (1)
+#define MICROPY_HW_RTC_USE_US       (1)
+#define MICROPY_HW_RTC_USE_CALOUT   (1)
+
+// SPI flash #1, for R/W storage
+#define MICROPY_HW_SOFTQSPI_SCK_LOW(self) (GPIOE->BSRR = (0x10000 << 11))
+#define MICROPY_HW_SOFTQSPI_SCK_HIGH(self) (GPIOE->BSRR = (1 << 11))
+#define MICROPY_HW_SOFTQSPI_NIBBLE_READ(self) ((GPIOE->IDR >> 7) & 0xf)
+#define MICROPY_HW_SPIFLASH_SIZE_BITS (16 * 1024 * 1024)
+#define MICROPY_HW_SPIFLASH_CS      (pyb_pin_QSPI1_CS)
+#define MICROPY_HW_SPIFLASH_SCK     (pyb_pin_QSPI1_CLK)
+#define MICROPY_HW_SPIFLASH_IO0     (pyb_pin_QSPI1_D0)
+#define MICROPY_HW_SPIFLASH_IO1     (pyb_pin_QSPI1_D1)
+#define MICROPY_HW_SPIFLASH_IO2     (pyb_pin_QSPI1_D2)
+#define MICROPY_HW_SPIFLASH_IO3     (pyb_pin_QSPI1_D3)
+
+// SPI flash #1, block device config
+extern const struct _mp_spiflash_config_t spiflash_config;
+extern struct _spi_bdev_t spi_bdev;
+#define MICROPY_HW_BDEV_IOCTL(op, arg) ( \
+    (op) == BDEV_IOCTL_NUM_BLOCKS ? (MICROPY_HW_SPIFLASH_SIZE_BITS / 8 / FLASH_BLOCK_SIZE) : \
+    (op) == BDEV_IOCTL_INIT ? spi_bdev_ioctl(&spi_bdev, (op), (uint32_t)&spiflash_config) : \
+    spi_bdev_ioctl(&spi_bdev, (op), (arg)) \
+)
+#define MICROPY_HW_BDEV_READBLOCKS(dest, bl, n) spi_bdev_readblocks(&spi_bdev, (dest), (bl), (n))
+#define MICROPY_HW_BDEV_WRITEBLOCKS(src, bl, n) spi_bdev_writeblocks(&spi_bdev, (src), (bl), (n))
+#define MICROPY_HW_BDEV_SPIFLASH_EXTENDED (&spi_bdev) // for extended block protocol
+
+// SPI flash #2, to be memory mapped
+#define MICROPY_HW_QSPIFLASH_SIZE_BITS_LOG2 (24)
+#define MICROPY_HW_QSPIFLASH_CS     (pyb_pin_QSPI2_CS)
+#define MICROPY_HW_QSPIFLASH_SCK    (pyb_pin_QSPI2_CLK)
+#define MICROPY_HW_QSPIFLASH_IO0    (pyb_pin_QSPI2_D0)
+#define MICROPY_HW_QSPIFLASH_IO1    (pyb_pin_QSPI2_D1)
+#define MICROPY_HW_QSPIFLASH_IO2    (pyb_pin_QSPI2_D2)
+#define MICROPY_HW_QSPIFLASH_IO3    (pyb_pin_QSPI2_D3)
+
+// SPI flash #2, block device config
+extern const struct _mp_spiflash_config_t spiflash2_config;
+extern struct _spi_bdev_t spi_bdev2;
+
+// UART config
+#define MICROPY_HW_UART1_NAME       "YA"
+#define MICROPY_HW_UART1_TX         (pyb_pin_Y1)
+#define MICROPY_HW_UART1_RX         (pyb_pin_Y2)
+#define MICROPY_HW_UART2_TX         (pyb_pin_X3)
+#define MICROPY_HW_UART2_RX         (pyb_pin_X4)
+#define MICROPY_HW_UART2_RTS        (pyb_pin_X2)
+#define MICROPY_HW_UART2_CTS        (pyb_pin_X1)
+#define MICROPY_HW_UART3_NAME       "YB"
+#define MICROPY_HW_UART3_TX         (pyb_pin_Y9)
+#define MICROPY_HW_UART3_RX         (pyb_pin_Y10)
+#define MICROPY_HW_UART4_NAME       "XA"
+#define MICROPY_HW_UART4_TX         (pyb_pin_X1)
+#define MICROPY_HW_UART4_RX         (pyb_pin_X2)
+#define MICROPY_HW_UART6_TX         (pyb_pin_BT_TXD)
+#define MICROPY_HW_UART6_RX         (pyb_pin_BT_RXD)
+#define MICROPY_HW_UART6_RTS        (pyb_pin_BT_RTS)
+#define MICROPY_HW_UART6_CTS        (pyb_pin_BT_CTS)
+
+// I2C busses
+#define MICROPY_HW_I2C1_NAME        "X"
+#define MICROPY_HW_I2C1_SCL         (pyb_pin_X9)
+#define MICROPY_HW_I2C1_SDA         (pyb_pin_X10)
+#define MICROPY_HW_I2C2_NAME        "Y"
+#define MICROPY_HW_I2C2_SCL         (pyb_pin_Y9)
+#define MICROPY_HW_I2C2_SDA         (pyb_pin_Y10)
+
+// SPI busses
+#define MICROPY_HW_SPI1_NAME        "X"
+#define MICROPY_HW_SPI1_NSS         (pyb_pin_X5)
+#define MICROPY_HW_SPI1_SCK         (pyb_pin_X6)
+#define MICROPY_HW_SPI1_MISO        (pyb_pin_X7)
+#define MICROPY_HW_SPI1_MOSI        (pyb_pin_X8)
+#define MICROPY_HW_SPI2_NAME        "Y"
+#define MICROPY_HW_SPI2_NSS         (pyb_pin_Y5)
+#define MICROPY_HW_SPI2_SCK         (pyb_pin_Y6)
+#define MICROPY_HW_SPI2_MISO        (pyb_pin_Y7)
+#define MICROPY_HW_SPI2_MOSI        (pyb_pin_Y8)
+#define MICROPY_HW_SPI3_NSS         (pyb_pin_W16)
+#define MICROPY_HW_SPI3_SCK         (pyb_pin_W29)
+#define MICROPY_HW_SPI3_MISO        (pyb_pin_W50)
+#define MICROPY_HW_SPI3_MOSI        (pyb_pin_W46)
+
+// CAN busses
+#define MICROPY_HW_CAN1_NAME        "X"
+#define MICROPY_HW_CAN1_TX          (pyb_pin_X10)
+#define MICROPY_HW_CAN1_RX          (pyb_pin_X9)
+
+// USRSW is not pulled, and pressing the button makes the input go low.
+#define MICROPY_HW_USRSW_PIN        (pyb_pin_USR)
+#define MICROPY_HW_USRSW_PULL       (GPIO_PULLUP)
+#define MICROPY_HW_USRSW_EXTI_MODE  (GPIO_MODE_IT_FALLING)
+#define MICROPY_HW_USRSW_PRESSED    (0)
+
+// LEDs
+#define MICROPY_HW_LED_INVERTED     (1) // LEDs are on when pin is driven low
+#define MICROPY_HW_LED1             (pyb_pin_LED_RED)
+#define MICROPY_HW_LED2             (pyb_pin_LED_GREEN)
+#define MICROPY_HW_LED3             (pyb_pin_LED_BLUE)
+#define MICROPY_HW_LED_ON(pin)      (mp_hal_pin_low(pin))
+#define MICROPY_HW_LED_OFF(pin)     (mp_hal_pin_high(pin))
+
+// SD card
+#define MICROPY_HW_SDMMC2_CK                (pyb_pin_SD_CK)
+#define MICROPY_HW_SDMMC2_CMD               (pyb_pin_SD_CMD)
+#define MICROPY_HW_SDMMC2_D0                (pyb_pin_SD_D0)
+#define MICROPY_HW_SDMMC2_D1                (pyb_pin_SD_D1)
+#define MICROPY_HW_SDMMC2_D2                (pyb_pin_SD_D2)
+#define MICROPY_HW_SDMMC2_D3                (pyb_pin_SD_D3)
+#define MICROPY_HW_SDCARD_DETECT_PIN        (pyb_pin_SD_SW)
+#define MICROPY_HW_SDCARD_DETECT_PULL       (GPIO_PULLUP)
+#define MICROPY_HW_SDCARD_DETECT_PRESENT    (GPIO_PIN_RESET)
+#define MICROPY_HW_SDCARD_MOUNT_AT_BOOT     (0)
+
+// USB config
+#define MICROPY_HW_USB_FS           (1)
+#define MICROPY_HW_USB_HS           (1)
+#define MICROPY_HW_USB_HS_IN_FS     (1)
+#define MICROPY_HW_USB_MAIN_DEV     (USB_PHY_HS_ID)
+
+// Bluetooth config
+#define MICROPY_HW_BLE_UART_ID       (PYB_UART_6)
+#define MICROPY_HW_BLE_UART_BAUDRATE (115200)
+
+/******************************************************************************/
+// Bootloader configuration
+
+#define MBOOT_USB_AUTODETECT_PORT   (1)
+#define MBOOT_FSLOAD                (1)
+
+#define MBOOT_I2C_PERIPH_ID         1
+#define MBOOT_I2C_SCL               (pin_B8)
+#define MBOOT_I2C_SDA               (pin_B9)
+#define MBOOT_I2C_ALTFUNC           (4)
+
+#define MBOOT_SPIFLASH_ADDR         (0x80000000)
+#define MBOOT_SPIFLASH_BYTE_SIZE    (64 * 32 * 1024)
+#define MBOOT_SPIFLASH_LAYOUT       "/0x80000000/64*32Kg"
+#define MBOOT_SPIFLASH_ERASE_BLOCKS_PER_PAGE (32 / 4)
+#define MBOOT_SPIFLASH_SPIFLASH     (&spi_bdev.spiflash)
+#define MBOOT_SPIFLASH_CONFIG       (&spiflash_config)
+
+#define MBOOT_SPIFLASH2_ADDR        (0x90000000)
+#define MBOOT_SPIFLASH2_BYTE_SIZE   (64 * 32 * 1024)
+#define MBOOT_SPIFLASH2_LAYOUT      "/0x90000000/64*32Kg"
+#define MBOOT_SPIFLASH2_ERASE_BLOCKS_PER_PAGE (32 / 4)
+#define MBOOT_SPIFLASH2_SPIFLASH    (&spi_bdev2.spiflash)
+#define MBOOT_SPIFLASH2_CONFIG      (&spiflash2_config)
+
+#define MBOOT_BOARD_EARLY_INIT mboot_board_early_init
+void mboot_board_early_init(void);
diff --git a/ports/stm32/boards/PYBD_SF2/mpconfigboard.mk b/ports/stm32/boards/PYBD_SF2/mpconfigboard.mk
new file mode 100644
index 0000000000000..ead8bb8c07cf3
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF2/mpconfigboard.mk
@@ -0,0 +1,23 @@
+# MCU settings
+MCU_SERIES = f7
+CMSIS_MCU = STM32F722xx
+MICROPY_FLOAT_IMPL = single
+AF_FILE = boards/stm32f722_af.csv
+LD_FILES = boards/PYBD_SF2/f722_qspi.ld
+TEXT0_ADDR = 0x08008000
+TEXT1_ADDR = 0x90000000
+TEXT0_SECTIONS = .isr_vector .text .data
+TEXT1_SECTIONS = .text_ext
+
+# MicroPython settings
+MICROPY_PY_BLUETOOTH ?= 1
+MICROPY_BLUETOOTH_NIMBLE ?= 1
+MICROPY_BLUETOOTH_BTSTACK ?= 0
+MICROPY_PY_LWIP = 1
+MICROPY_PY_NETWORK_CYW43 = 1
+MICROPY_PY_USSL = 1
+MICROPY_SSL_MBEDTLS = 1
+MICROPY_VFS_LFS2 = 1
+
+# PYBD-specific frozen modules
+FROZEN_MANIFEST = $(BOARD_DIR)/manifest.py
diff --git a/ports/stm32/boards/PYBD_SF2/pins.csv b/ports/stm32/boards/PYBD_SF2/pins.csv
new file mode 100644
index 0000000000000..c11f3fe90624d
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF2/pins.csv
@@ -0,0 +1,189 @@
+W3,PE3
+W5,PA11
+W5B,PI0
+W6,PA5
+W7,PA4
+W7B,PG7
+W8,PB11
+W9,PA12
+W9B,PI1
+W10,PA6
+W11,PA3
+W12,PB10
+W14,PA7
+W15,PA2
+W16,PA15
+W17,PA1
+W18,PD3
+W19,PA0
+W20,PD0
+W21,PC14
+W22,PE12
+W22B,PF6
+W22C,PF7
+W22D,PF10
+W23,PE1
+W24,PC1
+W25,PE0
+W26,PC13
+W27,PA8
+W27B,PC6
+W28,PE6
+W29,PB3
+W30,PE5
+W32,PE4
+W33,PH2
+W34,PH3
+W43,PB0
+W43B,PC0
+W43C,PF9
+W43D,PF11
+W45,PB12
+W45B,PE14
+W45C,PH8
+W46,PB5
+W47,PC5
+W47B,PF14
+W49,PB13
+W50,PB4
+W51,PC4
+W51B,PF15
+W52,PA10
+W53,PC2
+W53B,PF8
+W54,PA9
+W55,PB9
+W56,PA14
+W57,PC3
+W57B,PF13
+W58,PG11
+W59,PB8
+W60,PG12
+W61,PB7
+W62,PD7
+W63,PB1
+W63B,PD9
+W64,PD6
+W65,PD8
+W66,PG9
+W67,PA13
+W68,PG10
+W70,PB14
+W71,PE15
+W72,PB15
+W73,PH6
+W74,PH7
+X1,PA0
+X2,PA1
+X3,PA2
+X4,PA3
+X5,PA4
+X5B,PG7
+X6,PA5
+X7,PA6
+X8,PA7
+X9,PB8
+X10,PB9
+X11,PC4
+X11B,PF15
+X12,PC5
+X12B,PF14
+Y1,PA9
+Y2,PA10
+Y3,PB4
+Y4,PB5
+Y5,PB12
+Y5B,PE14
+Y5C,PH8
+Y6,PB13
+Y7,PC2
+Y7B,PF8
+Y8,PC3
+Y8B,PF13
+Y9,PB10
+Y10,PB11
+Y11,PB0
+Y11B,PC0
+Y11C,PF9
+Y11D,PF11
+Y12,PB1
+Y12B,PD9
+EN_3V3,PF2
+PULL_SCL,PF1
+PULL_SDA,PH5
+LED_RED,PF3
+LED_GREEN,PF4
+LED_BLUE,PF5
+USR,PA13
+USB_DM,PA11
+USB_DP,PA12
+USB_HS_DM,PB14
+USB_HS_DP,PB15
+-QSPI1_CS,PE13
+-QSPI1_CLK,PE11
+-QSPI1_D0,PE7
+-QSPI1_D1,PE8
+-QSPI1_D2,PE9
+-QSPI1_D3,PE10
+-QSPI2_CS,PB6
+-QSPI2_CLK,PB2
+-QSPI2_D0,PD11
+-QSPI2_D1,PD12
+-QSPI2_D2,PE2
+-QSPI2_D3,PD13
+-SD_D0,PG9
+-SD_D1,PG10
+-SD_D2,PG11
+-SD_D3,PG12
+-SD_CMD,PD7
+-SD_CK,PD6
+SD_SW,PA14
+-WL_REG_ON,PD4
+-WL_HOST_WAKE,PI8
+-WL_RFSW_VDD,PI9
+-WL_GPIO_1,PI11
+-WL_GPIO_2,PI7
+-WL_GPIO_4,PI9
+-WL_SDIO_0,PC8
+-WL_SDIO_1,PC9
+-WL_SDIO_2,PC10
+-WL_SDIO_3,PC11
+-WL_SDIO_CMD,PD2
+-WL_SDIO_CLK,PC12
+-BT_RXD,PC7
+-BT_TXD,PG14
+-BT_CTS,PG13
+-BT_RTS,PG8
+-BT_GPIO_3,PG15
+-BT_GPIO_4,PI5
+-BT_GPIO_5,PI4
+-BT_PCM_SYNC,PE4
+-BT_PCM_IN,PE6
+-BT_PCM_OUT,PE3
+-BT_PCM_CLK,PE5
+-BT_I2C_D0,PI10
+-BT_REG_ON,PI6
+-BT_HOST_WAKE,PD10
+-BT_DEV_WAKE,PD5
+,PD1
+,PD14
+,PD15
+,PF0
+,PF12
+,PG0
+,PG1
+,PG2
+,PG3
+,PG4
+,PG5
+,PG6
+,PH4
+,PH9
+,PH10
+,PH11
+,PH12
+,PH13
+,PH14
+,PH15
+,PI2
+,PI3
diff --git a/ports/stm32/boards/PYBD_SF2/stm32f7xx_hal_conf.h b/ports/stm32/boards/PYBD_SF2/stm32f7xx_hal_conf.h
new file mode 100644
index 0000000000000..621b05c719e92
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF2/stm32f7xx_hal_conf.h
@@ -0,0 +1,19 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
+
+#include "boards/stm32f7xx_hal_conf_base.h"
+
+// Oscillator values in Hz
+#define HSE_VALUE (25000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (5000)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#endif // MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
diff --git a/ports/stm32/boards/PYBD_SF3/bdev.c b/ports/stm32/boards/PYBD_SF3/bdev.c
new file mode 100644
index 0000000000000..b43028c06b4a6
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF3/bdev.c
@@ -0,0 +1 @@
+#include "boards/PYBD_SF2/bdev.c"
diff --git a/ports/stm32/boards/PYBD_SF3/board_init.c b/ports/stm32/boards/PYBD_SF3/board_init.c
new file mode 100644
index 0000000000000..c7a9f28006be3
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF3/board_init.c
@@ -0,0 +1 @@
+#include "boards/PYBD_SF2/board_init.c"
diff --git a/ports/stm32/boards/PYBD_SF3/mpconfigboard.h b/ports/stm32/boards/PYBD_SF3/mpconfigboard.h
new file mode 100644
index 0000000000000..8c79e6fe64313
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF3/mpconfigboard.h
@@ -0,0 +1,34 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// Take PYBD_SF2 as base configuration
+#include "boards/PYBD_SF2/mpconfigboard.h"
+
+#undef MICROPY_HW_BOARD_NAME
+#undef MICROPY_HW_MCU_NAME
+
+#define MICROPY_HW_BOARD_NAME       "PYBD-SF3W"
+#define MICROPY_HW_MCU_NAME         "STM32F733IEK"
diff --git a/ports/stm32/boards/PYBD_SF3/mpconfigboard.mk b/ports/stm32/boards/PYBD_SF3/mpconfigboard.mk
new file mode 100644
index 0000000000000..119ec8f825b42
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF3/mpconfigboard.mk
@@ -0,0 +1,22 @@
+# MCU settings
+MCU_SERIES = f7
+CMSIS_MCU = STM32F733xx
+MICROPY_FLOAT_IMPL = single
+AF_FILE = boards/stm32f722_af.csv
+LD_FILES = boards/PYBD_SF2/f722_qspi.ld
+TEXT0_ADDR = 0x08008000
+TEXT1_ADDR = 0x90000000
+TEXT0_SECTIONS = .isr_vector .text .data
+TEXT1_SECTIONS = .text_ext
+
+# MicroPython settings
+MICROPY_PY_BLUETOOTH ?= 1
+MICROPY_BLUETOOTH_NIMBLE ?= 1
+MICROPY_BLUETOOTH_BTSTACK ?= 0
+MICROPY_PY_LWIP = 1
+MICROPY_PY_NETWORK_CYW43 = 1
+MICROPY_PY_USSL = 1
+MICROPY_SSL_MBEDTLS = 1
+
+# PYBD-specific frozen modules
+FROZEN_MANIFEST = boards/PYBD_SF2/manifest.py
diff --git a/ports/stm32/boards/PYBD_SF3/pins.csv b/ports/stm32/boards/PYBD_SF3/pins.csv
new file mode 100644
index 0000000000000..c11f3fe90624d
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF3/pins.csv
@@ -0,0 +1,189 @@
+W3,PE3
+W5,PA11
+W5B,PI0
+W6,PA5
+W7,PA4
+W7B,PG7
+W8,PB11
+W9,PA12
+W9B,PI1
+W10,PA6
+W11,PA3
+W12,PB10
+W14,PA7
+W15,PA2
+W16,PA15
+W17,PA1
+W18,PD3
+W19,PA0
+W20,PD0
+W21,PC14
+W22,PE12
+W22B,PF6
+W22C,PF7
+W22D,PF10
+W23,PE1
+W24,PC1
+W25,PE0
+W26,PC13
+W27,PA8
+W27B,PC6
+W28,PE6
+W29,PB3
+W30,PE5
+W32,PE4
+W33,PH2
+W34,PH3
+W43,PB0
+W43B,PC0
+W43C,PF9
+W43D,PF11
+W45,PB12
+W45B,PE14
+W45C,PH8
+W46,PB5
+W47,PC5
+W47B,PF14
+W49,PB13
+W50,PB4
+W51,PC4
+W51B,PF15
+W52,PA10
+W53,PC2
+W53B,PF8
+W54,PA9
+W55,PB9
+W56,PA14
+W57,PC3
+W57B,PF13
+W58,PG11
+W59,PB8
+W60,PG12
+W61,PB7
+W62,PD7
+W63,PB1
+W63B,PD9
+W64,PD6
+W65,PD8
+W66,PG9
+W67,PA13
+W68,PG10
+W70,PB14
+W71,PE15
+W72,PB15
+W73,PH6
+W74,PH7
+X1,PA0
+X2,PA1
+X3,PA2
+X4,PA3
+X5,PA4
+X5B,PG7
+X6,PA5
+X7,PA6
+X8,PA7
+X9,PB8
+X10,PB9
+X11,PC4
+X11B,PF15
+X12,PC5
+X12B,PF14
+Y1,PA9
+Y2,PA10
+Y3,PB4
+Y4,PB5
+Y5,PB12
+Y5B,PE14
+Y5C,PH8
+Y6,PB13
+Y7,PC2
+Y7B,PF8
+Y8,PC3
+Y8B,PF13
+Y9,PB10
+Y10,PB11
+Y11,PB0
+Y11B,PC0
+Y11C,PF9
+Y11D,PF11
+Y12,PB1
+Y12B,PD9
+EN_3V3,PF2
+PULL_SCL,PF1
+PULL_SDA,PH5
+LED_RED,PF3
+LED_GREEN,PF4
+LED_BLUE,PF5
+USR,PA13
+USB_DM,PA11
+USB_DP,PA12
+USB_HS_DM,PB14
+USB_HS_DP,PB15
+-QSPI1_CS,PE13
+-QSPI1_CLK,PE11
+-QSPI1_D0,PE7
+-QSPI1_D1,PE8
+-QSPI1_D2,PE9
+-QSPI1_D3,PE10
+-QSPI2_CS,PB6
+-QSPI2_CLK,PB2
+-QSPI2_D0,PD11
+-QSPI2_D1,PD12
+-QSPI2_D2,PE2
+-QSPI2_D3,PD13
+-SD_D0,PG9
+-SD_D1,PG10
+-SD_D2,PG11
+-SD_D3,PG12
+-SD_CMD,PD7
+-SD_CK,PD6
+SD_SW,PA14
+-WL_REG_ON,PD4
+-WL_HOST_WAKE,PI8
+-WL_RFSW_VDD,PI9
+-WL_GPIO_1,PI11
+-WL_GPIO_2,PI7
+-WL_GPIO_4,PI9
+-WL_SDIO_0,PC8
+-WL_SDIO_1,PC9
+-WL_SDIO_2,PC10
+-WL_SDIO_3,PC11
+-WL_SDIO_CMD,PD2
+-WL_SDIO_CLK,PC12
+-BT_RXD,PC7
+-BT_TXD,PG14
+-BT_CTS,PG13
+-BT_RTS,PG8
+-BT_GPIO_3,PG15
+-BT_GPIO_4,PI5
+-BT_GPIO_5,PI4
+-BT_PCM_SYNC,PE4
+-BT_PCM_IN,PE6
+-BT_PCM_OUT,PE3
+-BT_PCM_CLK,PE5
+-BT_I2C_D0,PI10
+-BT_REG_ON,PI6
+-BT_HOST_WAKE,PD10
+-BT_DEV_WAKE,PD5
+,PD1
+,PD14
+,PD15
+,PF0
+,PF12
+,PG0
+,PG1
+,PG2
+,PG3
+,PG4
+,PG5
+,PG6
+,PH4
+,PH9
+,PH10
+,PH11
+,PH12
+,PH13
+,PH14
+,PH15
+,PI2
+,PI3
diff --git a/ports/stm32/boards/PYBD_SF3/stm32f7xx_hal_conf.h b/ports/stm32/boards/PYBD_SF3/stm32f7xx_hal_conf.h
new file mode 100644
index 0000000000000..0f178c2ba310f
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF3/stm32f7xx_hal_conf.h
@@ -0,0 +1 @@
+#include "boards/PYBD_SF2/stm32f7xx_hal_conf.h"
diff --git a/ports/stm32/boards/PYBD_SF6/bdev.c b/ports/stm32/boards/PYBD_SF6/bdev.c
new file mode 100644
index 0000000000000..b43028c06b4a6
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF6/bdev.c
@@ -0,0 +1 @@
+#include "boards/PYBD_SF2/bdev.c"
diff --git a/ports/stm32/boards/PYBD_SF6/board_init.c b/ports/stm32/boards/PYBD_SF6/board_init.c
new file mode 100644
index 0000000000000..c7a9f28006be3
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF6/board_init.c
@@ -0,0 +1 @@
+#include "boards/PYBD_SF2/board_init.c"
diff --git a/ports/stm32/boards/PYBD_SF6/f767.ld b/ports/stm32/boards/PYBD_SF6/f767.ld
new file mode 100644
index 0000000000000..1dd4c11ed9898
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF6/f767.ld
@@ -0,0 +1,99 @@
+/*
+    Linker script for PYBD with STM32F767
+
+    Memory layout for mboot configuration (this here describes the app part):
+
+    FLASH_APP   .isr_vector
+    FLASH_APP   .text
+    FLASH_APP   .big_const
+    FLASH_APP   .data
+
+    RAM         .data
+    RAM         .bss
+    RAM         .heap
+    RAM         .stack
+*/
+
+/* Specify the memory areas */
+MEMORY
+{
+    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 2048K
+    FLASH_ISR (rx)  : ORIGIN = 0x08000000, LENGTH = 32K     /* sector 0, 32K */
+    FLASH_APP (rx)  : ORIGIN = 0x08008000, LENGTH = 2016K   /* sectors 1-11 3x32K 1*128K 7*256K */
+    FLASH_EXT (rx)  : ORIGIN = 0x90000000, LENGTH = 2048K   /* external QSPI */
+    RAM (rwx)       : ORIGIN = 0x20000000, LENGTH = 512K    /* DTCM=128k, SRAM1=368K, SRAM2=16K */
+}
+
+/* produce a link error if there is not this amount of RAM for these sections */
+_minimum_stack_size = 2K;
+_minimum_heap_size = 16K;
+
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 24K;
+
+/* RAM extents for the garbage collector */
+_ram_start = ORIGIN(RAM);
+_ram_end = ORIGIN(RAM) + LENGTH(RAM);
+_heap_start = _ebss; /* heap starts just after statically allocated memory */
+_heap_end = _sstack;
+
+ENTRY(Reset_Handler)
+
+/* Define output sections */
+SECTIONS
+{
+    .isr_vector :
+    {
+        . = ALIGN(4);
+        KEEP(*(.isr_vector))
+        . = ALIGN(4);
+    } >FLASH_APP
+
+    .text :
+    {
+        . = ALIGN(4);
+        *(.text*)
+        *(.rodata*)
+        . = ALIGN(512);
+        *(.big_const*)
+        . = ALIGN(4);
+        _etext = .;
+    } >FLASH_APP
+
+    _sidata = LOADADDR(.data);
+
+    .data :
+    {
+        . = ALIGN(4);
+        _sdata = .;
+        *(.data*)
+        . = ALIGN(4);
+        _edata = .;
+    } >RAM AT> FLASH_APP
+
+    .bss :
+    {
+        . = ALIGN(4);
+        _sbss = .;
+        *(.bss*)
+        *(COMMON)
+        . = ALIGN(4);
+        _ebss = .;
+    } >RAM
+
+    .heap :
+    {
+        . = ALIGN(4);
+        . = . + _minimum_heap_size;
+        . = ALIGN(4);
+    } >RAM
+
+    .stack :
+    {
+        . = ALIGN(4);
+        . = . + _minimum_stack_size;
+        . = ALIGN(4);
+    } >RAM
+}
diff --git a/ports/stm32/boards/PYBD_SF6/mpconfigboard.h b/ports/stm32/boards/PYBD_SF6/mpconfigboard.h
new file mode 100644
index 0000000000000..cbfbe39945daf
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF6/mpconfigboard.h
@@ -0,0 +1,66 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// Take PYBD_SF2 as base configuration
+#include "boards/PYBD_SF2/mpconfigboard.h"
+
+#undef MICROPY_HW_BOARD_NAME
+#undef MICROPY_HW_MCU_NAME
+#undef MICROPY_HW_CLK_PLLM
+#undef MICROPY_HW_CLK_PLLN
+#undef MICROPY_HW_CLK_PLLP
+#undef MICROPY_HW_CLK_PLLQ
+#undef MICROPY_HW_FLASH_LATENCY
+
+#define MICROPY_HW_BOARD_NAME       "PYBD-SF6W"
+#define MICROPY_HW_MCU_NAME         "STM32F767IIK"
+
+// HSE is 25MHz, run SYS at 144MHz
+#define MICROPY_HW_CLK_PLLM         (25)
+#define MICROPY_HW_CLK_PLLN         (288)
+#define MICROPY_HW_CLK_PLLP         (RCC_PLLP_DIV2)
+#define MICROPY_HW_CLK_PLLQ         (6)
+#define MICROPY_HW_FLASH_LATENCY    (FLASH_LATENCY_4)
+
+// Extra UART config
+#define MICROPY_HW_UART7_TX         (pyb_pin_W16)
+#define MICROPY_HW_UART7_RX         (pyb_pin_W22B)
+
+// Extra CAN busses
+#define MICROPY_HW_CAN2_NAME        "Y"
+#define MICROPY_HW_CAN2_TX          (pyb_pin_Y6)
+#define MICROPY_HW_CAN2_RX          (pyb_pin_Y5)
+
+// Ethernet via RMII
+#define MICROPY_HW_ETH_MDC          (pyb_pin_W24)
+#define MICROPY_HW_ETH_MDIO         (pyb_pin_W15)
+#define MICROPY_HW_ETH_RMII_REF_CLK (pyb_pin_W17)
+#define MICROPY_HW_ETH_RMII_CRS_DV  (pyb_pin_W14)
+#define MICROPY_HW_ETH_RMII_RXD0    (pyb_pin_W51)
+#define MICROPY_HW_ETH_RMII_RXD1    (pyb_pin_W47)
+#define MICROPY_HW_ETH_RMII_TX_EN   (pyb_pin_W8)
+#define MICROPY_HW_ETH_RMII_TXD0    (pyb_pin_W45)
+#define MICROPY_HW_ETH_RMII_TXD1    (pyb_pin_W49)
diff --git a/ports/stm32/boards/PYBD_SF6/mpconfigboard.mk b/ports/stm32/boards/PYBD_SF6/mpconfigboard.mk
new file mode 100644
index 0000000000000..ddc176e9cd422
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF6/mpconfigboard.mk
@@ -0,0 +1,19 @@
+# MCU settings
+MCU_SERIES = f7
+CMSIS_MCU = STM32F767xx
+MICROPY_FLOAT_IMPL = double
+AF_FILE = boards/stm32f767_af.csv
+LD_FILES = boards/PYBD_SF6/f767.ld
+TEXT0_ADDR = 0x08008000
+
+# MicroPython settings
+MICROPY_PY_BLUETOOTH ?= 1
+MICROPY_BLUETOOTH_NIMBLE ?= 1
+MICROPY_BLUETOOTH_BTSTACK ?= 0
+MICROPY_PY_LWIP = 1
+MICROPY_PY_NETWORK_CYW43 = 1
+MICROPY_PY_USSL = 1
+MICROPY_SSL_MBEDTLS = 1
+
+# PYBD-specific frozen modules
+FROZEN_MANIFEST = boards/PYBD_SF2/manifest.py
diff --git a/ports/stm32/boards/PYBD_SF6/pins.csv b/ports/stm32/boards/PYBD_SF6/pins.csv
new file mode 100644
index 0000000000000..c11f3fe90624d
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF6/pins.csv
@@ -0,0 +1,189 @@
+W3,PE3
+W5,PA11
+W5B,PI0
+W6,PA5
+W7,PA4
+W7B,PG7
+W8,PB11
+W9,PA12
+W9B,PI1
+W10,PA6
+W11,PA3
+W12,PB10
+W14,PA7
+W15,PA2
+W16,PA15
+W17,PA1
+W18,PD3
+W19,PA0
+W20,PD0
+W21,PC14
+W22,PE12
+W22B,PF6
+W22C,PF7
+W22D,PF10
+W23,PE1
+W24,PC1
+W25,PE0
+W26,PC13
+W27,PA8
+W27B,PC6
+W28,PE6
+W29,PB3
+W30,PE5
+W32,PE4
+W33,PH2
+W34,PH3
+W43,PB0
+W43B,PC0
+W43C,PF9
+W43D,PF11
+W45,PB12
+W45B,PE14
+W45C,PH8
+W46,PB5
+W47,PC5
+W47B,PF14
+W49,PB13
+W50,PB4
+W51,PC4
+W51B,PF15
+W52,PA10
+W53,PC2
+W53B,PF8
+W54,PA9
+W55,PB9
+W56,PA14
+W57,PC3
+W57B,PF13
+W58,PG11
+W59,PB8
+W60,PG12
+W61,PB7
+W62,PD7
+W63,PB1
+W63B,PD9
+W64,PD6
+W65,PD8
+W66,PG9
+W67,PA13
+W68,PG10
+W70,PB14
+W71,PE15
+W72,PB15
+W73,PH6
+W74,PH7
+X1,PA0
+X2,PA1
+X3,PA2
+X4,PA3
+X5,PA4
+X5B,PG7
+X6,PA5
+X7,PA6
+X8,PA7
+X9,PB8
+X10,PB9
+X11,PC4
+X11B,PF15
+X12,PC5
+X12B,PF14
+Y1,PA9
+Y2,PA10
+Y3,PB4
+Y4,PB5
+Y5,PB12
+Y5B,PE14
+Y5C,PH8
+Y6,PB13
+Y7,PC2
+Y7B,PF8
+Y8,PC3
+Y8B,PF13
+Y9,PB10
+Y10,PB11
+Y11,PB0
+Y11B,PC0
+Y11C,PF9
+Y11D,PF11
+Y12,PB1
+Y12B,PD9
+EN_3V3,PF2
+PULL_SCL,PF1
+PULL_SDA,PH5
+LED_RED,PF3
+LED_GREEN,PF4
+LED_BLUE,PF5
+USR,PA13
+USB_DM,PA11
+USB_DP,PA12
+USB_HS_DM,PB14
+USB_HS_DP,PB15
+-QSPI1_CS,PE13
+-QSPI1_CLK,PE11
+-QSPI1_D0,PE7
+-QSPI1_D1,PE8
+-QSPI1_D2,PE9
+-QSPI1_D3,PE10
+-QSPI2_CS,PB6
+-QSPI2_CLK,PB2
+-QSPI2_D0,PD11
+-QSPI2_D1,PD12
+-QSPI2_D2,PE2
+-QSPI2_D3,PD13
+-SD_D0,PG9
+-SD_D1,PG10
+-SD_D2,PG11
+-SD_D3,PG12
+-SD_CMD,PD7
+-SD_CK,PD6
+SD_SW,PA14
+-WL_REG_ON,PD4
+-WL_HOST_WAKE,PI8
+-WL_RFSW_VDD,PI9
+-WL_GPIO_1,PI11
+-WL_GPIO_2,PI7
+-WL_GPIO_4,PI9
+-WL_SDIO_0,PC8
+-WL_SDIO_1,PC9
+-WL_SDIO_2,PC10
+-WL_SDIO_3,PC11
+-WL_SDIO_CMD,PD2
+-WL_SDIO_CLK,PC12
+-BT_RXD,PC7
+-BT_TXD,PG14
+-BT_CTS,PG13
+-BT_RTS,PG8
+-BT_GPIO_3,PG15
+-BT_GPIO_4,PI5
+-BT_GPIO_5,PI4
+-BT_PCM_SYNC,PE4
+-BT_PCM_IN,PE6
+-BT_PCM_OUT,PE3
+-BT_PCM_CLK,PE5
+-BT_I2C_D0,PI10
+-BT_REG_ON,PI6
+-BT_HOST_WAKE,PD10
+-BT_DEV_WAKE,PD5
+,PD1
+,PD14
+,PD15
+,PF0
+,PF12
+,PG0
+,PG1
+,PG2
+,PG3
+,PG4
+,PG5
+,PG6
+,PH4
+,PH9
+,PH10
+,PH11
+,PH12
+,PH13
+,PH14
+,PH15
+,PI2
+,PI3
diff --git a/ports/stm32/boards/PYBD_SF6/stm32f7xx_hal_conf.h b/ports/stm32/boards/PYBD_SF6/stm32f7xx_hal_conf.h
new file mode 100644
index 0000000000000..0f178c2ba310f
--- /dev/null
+++ b/ports/stm32/boards/PYBD_SF6/stm32f7xx_hal_conf.h
@@ -0,0 +1 @@
+#include "boards/PYBD_SF2/stm32f7xx_hal_conf.h"
diff --git a/ports/stm32/boards/PYBLITEV10/stm32f4xx_hal_conf.h b/ports/stm32/boards/PYBLITEV10/stm32f4xx_hal_conf.h
index 4e96f785ad34b..9719157e55cdf 100644
--- a/ports/stm32/boards/PYBLITEV10/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/PYBLITEV10/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */ 
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (12000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver 
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_I2S_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).  
-  */
-#if !defined  (HSE_VALUE) 
-  #define HSE_VALUE    ((uint32_t)12000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL). 
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE) 
- #define LSI_VALUE  ((uint32_t)40000)    
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source 
-  *        frequency, this source is inserted directly through I2S_CKIN pad. 
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */     
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the 
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */   
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/ 
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/ 
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
- 
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-  
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
- 
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file 
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-   
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h" 
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
- 
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */ 
-  
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */      
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-   
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed. 
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
- 
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/PYBV10/mpconfigboard.mk b/ports/stm32/boards/PYBV10/mpconfigboard.mk
index a4430cc1df0e4..cb78a7846d933 100644
--- a/ports/stm32/boards/PYBV10/mpconfigboard.mk
+++ b/ports/stm32/boards/PYBV10/mpconfigboard.mk
@@ -11,3 +11,6 @@ LD_FILES = boards/stm32f405.ld boards/common_ifs.ld
 TEXT0_ADDR = 0x08000000
 TEXT1_ADDR = 0x08020000
 endif
+
+# MicroPython settings
+MICROPY_VFS_LFS2 = 1
diff --git a/ports/stm32/boards/PYBV10/stm32f4xx_hal_conf.h b/ports/stm32/boards/PYBV10/stm32f4xx_hal_conf.h
index 4f18ac81e369e..de19251e0808a 100644
--- a/ports/stm32/boards/PYBV10/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/PYBV10/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-#define HAL_I2S_MODULE_ENABLED
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSE_VALUE)
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE)
- #define LSI_VALUE  ((uint32_t)40000)
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source
-  *        frequency, this source is inserted directly through I2S_CKIN pad.
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
-
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
-
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */
-
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/PYBV11/mpconfigboard.mk b/ports/stm32/boards/PYBV11/mpconfigboard.mk
index a4430cc1df0e4..cb78a7846d933 100644
--- a/ports/stm32/boards/PYBV11/mpconfigboard.mk
+++ b/ports/stm32/boards/PYBV11/mpconfigboard.mk
@@ -11,3 +11,6 @@ LD_FILES = boards/stm32f405.ld boards/common_ifs.ld
 TEXT0_ADDR = 0x08000000
 TEXT1_ADDR = 0x08020000
 endif
+
+# MicroPython settings
+MICROPY_VFS_LFS2 = 1
diff --git a/ports/stm32/boards/PYBV11/stm32f4xx_hal_conf.h b/ports/stm32/boards/PYBV11/stm32f4xx_hal_conf.h
index 24cc9228b80dd..9719157e55cdf 100644
--- a/ports/stm32/boards/PYBV11/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/PYBV11/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */ 
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (12000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver 
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-#define HAL_I2S_MODULE_ENABLED
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).  
-  */
-#if !defined  (HSE_VALUE) 
-  #define HSE_VALUE    ((uint32_t)12000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL). 
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE) 
- #define LSI_VALUE  ((uint32_t)40000)    
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source 
-  *        frequency, this source is inserted directly through I2S_CKIN pad. 
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */     
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the 
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */   
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/ 
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/ 
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
- 
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-  
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
- 
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file 
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-   
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h" 
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
- 
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */ 
-  
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */      
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-   
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed. 
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
- 
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/PYBV3/stm32f4xx_hal_conf.h b/ports/stm32/boards/PYBV3/stm32f4xx_hal_conf.h
index daf9b63ceca01..de19251e0808a 100644
--- a/ports/stm32/boards/PYBV3/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/PYBV3/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_I2S_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSE_VALUE)
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE)
- #define LSI_VALUE  ((uint32_t)40000)
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source
-  *        frequency, this source is inserted directly through I2S_CKIN pad.
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
-
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
-
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */
-
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/PYBV4/stm32f4xx_hal_conf.h b/ports/stm32/boards/PYBV4/stm32f4xx_hal_conf.h
index daf9b63ceca01..de19251e0808a 100644
--- a/ports/stm32/boards/PYBV4/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/PYBV4/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_I2S_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSE_VALUE)
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE)
- #define LSI_VALUE  ((uint32_t)40000)
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source
-  *        frequency, this source is inserted directly through I2S_CKIN pad.
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
-
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
-
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */
-
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/STM32F411DISC/stm32f4xx_hal_conf.h b/ports/stm32/boards/STM32F411DISC/stm32f4xx_hal_conf.h
index 8f0b6638119d4..de19251e0808a 100644
--- a/ports/stm32/boards/STM32F411DISC/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/STM32F411DISC/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */ 
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver 
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_I2S_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).  
-  */
-#if !defined  (HSE_VALUE) 
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL). 
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE) 
- #define LSI_VALUE  ((uint32_t)40000)    
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source 
-  *        frequency, this source is inserted directly through I2S_CKIN pad. 
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */     
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the 
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */   
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/ 
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/ 
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
- 
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-  
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
- 
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file 
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-   
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h" 
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
- 
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */ 
-  
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */      
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-   
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed. 
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
- 
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/STM32F429DISC/mpconfigboard.h b/ports/stm32/boards/STM32F429DISC/mpconfigboard.h
index 1422e8d52c38c..9b65f617437a4 100644
--- a/ports/stm32/boards/STM32F429DISC/mpconfigboard.h
+++ b/ports/stm32/boards/STM32F429DISC/mpconfigboard.h
@@ -79,8 +79,8 @@
 // SDRAM
 #define MICROPY_HW_SDRAM_SIZE  (64 / 8 * 1024 * 1024)  // 64 Mbit
 #define MICROPY_HW_SDRAM_STARTUP_TEST             (1)
-#define MICROPY_HEAP_START              sdram_start()
-#define MICROPY_HEAP_END                sdram_end()
+#define MICROPY_HEAP_START  ((sdram_valid) ? sdram_start() : &_heap_start)
+#define MICROPY_HEAP_END    ((sdram_valid) ? sdram_end() : &_heap_end)
 
 // Timing configuration for 90 Mhz (11.90ns) of SD clock frequency (180Mhz/2)
 #define MICROPY_HW_SDRAM_TIMING_TMRD        (2)
diff --git a/ports/stm32/boards/STM32F429DISC/stm32f4xx_hal_conf.h b/ports/stm32/boards/STM32F429DISC/stm32f4xx_hal_conf.h
index ec70793c8b915..de19251e0808a 100644
--- a/ports/stm32/boards/STM32F429DISC/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/STM32F429DISC/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */ 
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
- /* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver 
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-#define HAL_SDRAM_MODULE_ENABLED
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_I2S_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).  
-  */
-#if !defined  (HSE_VALUE) 
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL). 
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE) 
- #define LSI_VALUE  ((uint32_t)40000)    
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source 
-  *        frequency, this source is inserted directly through I2S_CKIN pad. 
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */     
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the 
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */   
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/ 
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/ 
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
- 
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-  
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
- 
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file 
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-   
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h" 
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
- 
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */ 
-  
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */      
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-   
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed. 
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
- 
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/STM32F439/stm32f4xx_hal_conf.h b/ports/stm32/boards/STM32F439/stm32f4xx_hal_conf.h
index 5b5a8a3e43e52..de19251e0808a 100644
--- a/ports/stm32/boards/STM32F439/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/STM32F439/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */ 
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
- /* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver 
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_I2S_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).  
-  */
-#if !defined  (HSE_VALUE) 
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL). 
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE) 
- #define LSI_VALUE  ((uint32_t)40000)    
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source 
-  *        frequency, this source is inserted directly through I2S_CKIN pad. 
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */     
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the 
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */   
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/ 
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/ 
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
- 
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-  
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
- 
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file 
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-   
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h" 
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
- 
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */ 
-  
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */      
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-   
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed. 
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
- 
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/STM32F4DISC/staccel.py b/ports/stm32/boards/STM32F4DISC/staccel.py
index 2f2561d1cb04e..af77720412740 100644
--- a/ports/stm32/boards/STM32F4DISC/staccel.py
+++ b/ports/stm32/boards/STM32F4DISC/staccel.py
@@ -18,29 +18,30 @@
 from pyb import Pin
 from pyb import SPI
 
-READWRITE_CMD = const(0x80) 
+READWRITE_CMD = const(0x80)
 MULTIPLEBYTE_CMD = const(0x40)
-WHO_AM_I_ADDR = const(0x0f)
+WHO_AM_I_ADDR = const(0x0F)
 OUT_X_ADDR = const(0x29)
-OUT_Y_ADDR = const(0x2b)
-OUT_Z_ADDR = const(0x2d)
-OUT_T_ADDR = const(0x0c)
+OUT_Y_ADDR = const(0x2B)
+OUT_Z_ADDR = const(0x2D)
+OUT_T_ADDR = const(0x0C)
 
-LIS302DL_WHO_AM_I_VAL = const(0x3b)
+LIS302DL_WHO_AM_I_VAL = const(0x3B)
 LIS302DL_CTRL_REG1_ADDR = const(0x20)
 # Configuration for 100Hz sampling rate, +-2g range
 LIS302DL_CONF = const(0b01000111)
 
-LIS3DSH_WHO_AM_I_VAL = const(0x3f)
+LIS3DSH_WHO_AM_I_VAL = const(0x3F)
 LIS3DSH_CTRL_REG4_ADDR = const(0x20)
 LIS3DSH_CTRL_REG5_ADDR = const(0x24)
 # Configuration for 100Hz sampling rate, +-2g range
 LIS3DSH_CTRL_REG4_CONF = const(0b01100111)
 LIS3DSH_CTRL_REG5_CONF = const(0b00000000)
 
+
 class STAccel:
     def __init__(self):
-        self.cs_pin = Pin('PE3', Pin.OUT_PP, Pin.PULL_NONE)
+        self.cs_pin = Pin("PE3", Pin.OUT_PP, Pin.PULL_NONE)
         self.cs_pin.high()
         self.spi = SPI(1, SPI.MASTER, baudrate=328125, polarity=0, phase=1, bits=8)
 
@@ -54,7 +55,7 @@ def __init__(self):
             self.write_bytes(LIS3DSH_CTRL_REG5_ADDR, bytearray([LIS3DSH_CTRL_REG5_CONF]))
             self.sensitivity = 0.06 * 256
         else:
-            raise Exception('LIS302DL or LIS3DSH accelerometer not present')
+            raise Exception("LIS302DL or LIS3DSH accelerometer not present")
 
     def convert_raw_to_g(self, x):
         if x & 0x80:
@@ -68,7 +69,7 @@ def read_bytes(self, addr, nbytes):
             addr |= READWRITE_CMD
         self.cs_pin.low()
         self.spi.send(addr)
-        #buf = self.spi.send_recv(bytearray(nbytes * [0])) # read data, MSB first
+        # buf = self.spi.send_recv(bytearray(nbytes * [0])) # read data, MSB first
         buf = self.spi.recv(nbytes)
         self.cs_pin.high()
         return buf
diff --git a/ports/stm32/boards/STM32F4DISC/stm32f4xx_hal_conf.h b/ports/stm32/boards/STM32F4DISC/stm32f4xx_hal_conf.h
index daf9b63ceca01..de19251e0808a 100644
--- a/ports/stm32/boards/STM32F4DISC/stm32f4xx_hal_conf.h
+++ b/ports/stm32/boards/STM32F4DISC/stm32f4xx_hal_conf.h
@@ -1,409 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.1.0
-  * @date    19-June-2014
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F4xx_HAL_CONF_H
-#define __STM32F4xx_HAL_CONF_H
+#include "boards/stm32f4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_PCCARD_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-/* #define HAL_SDRAM_MODULE_ENABLED */
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_I2S_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSE_VALUE)
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100U)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE)
- #define LSI_VALUE  ((uint32_t)40000)
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source
-  *        frequency, this source is inserted directly through I2S_CKIN pad.
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   0
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)4)       /* 4 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)4)       /* 4 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-
-/* DP83848 PHY Address*/
-#define DP83848_PHY_ADDRESS             0x01
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/
-#define PHY_RESET_DELAY                 ((uint32_t)0x000000FF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
-
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
-
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f4xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f4xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_PCCARD_MODULE_ENABLED
-  #include "stm32f4xx_hal_pccard.h"
-#endif /* HAL_PCCARD_MODULE_ENABLED */
-
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f4xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f4xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F4xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/STM32F769DISC/board_init.c b/ports/stm32/boards/STM32F769DISC/board_init.c
index b75a00c970539..67fad407a0e28 100644
--- a/ports/stm32/boards/STM32F769DISC/board_init.c
+++ b/ports/stm32/boards/STM32F769DISC/board_init.c
@@ -1,16 +1,19 @@
-#include "drivers/memory/spiflash.h"
+#include "storage.h"
 #include "qspi.h"
 
 // This configuration is needed for mboot to be able to write to the external QSPI flash
 
+STATIC mp_spiflash_cache_t spi_bdev_cache;
+
 const mp_spiflash_config_t spiflash_config = {
     .bus_kind = MP_SPIFLASH_BUS_QSPI,
     .bus.u_qspi.data = NULL,
     .bus.u_qspi.proto = &qspi_proto,
     .cache = NULL,
+    .cache = &spi_bdev_cache,
 };
 
-mp_spiflash_t spiflash_instance;
+spi_bdev_t spi_bdev;
 
 // This init function is needed to memory map the QSPI flash early in the boot process
 
diff --git a/ports/stm32/boards/STM32F769DISC/f769_qspi.ld b/ports/stm32/boards/STM32F769DISC/f769_qspi.ld
index eb2cf783eb67b..5f920b417fdde 100644
--- a/ports/stm32/boards/STM32F769DISC/f769_qspi.ld
+++ b/ports/stm32/boards/STM32F769DISC/f769_qspi.ld
@@ -17,7 +17,7 @@
 
 MEMORY
 {
-    FLASH_APP (rx)  : ORIGIN = 0x08020000, LENGTH = 2016K   /* sectors 1-11 3x32K 1*128K 7*256K */
+    FLASH_APP (rx)  : ORIGIN = 0x08020000, LENGTH = 1920K   /* sectors 4-11 1*128K 7*256K */
     FLASH_QSPI (rx) : ORIGIN = 0x90000000, LENGTH = 64M     /* external QSPI flash in XIP mode */
     DTCM (xrw)      : ORIGIN = 0x20000000, LENGTH = 128K    /* Used for storage cache */
     RAM (xrw)       : ORIGIN = 0x20020000, LENGTH = 384K    /* SRAM1 = 368K, SRAM2 = 16K */
@@ -27,14 +27,16 @@ MEMORY
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* Define tho top end of the stack */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 32K; /* tunable */
 
 /* RAM extents for the garbage collector */
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x20078000; /* tunable */
+_heap_end = _sstack;
 
 ENTRY(Reset_Handler)
 
diff --git a/ports/stm32/boards/STM32F769DISC/mpconfigboard.h b/ports/stm32/boards/STM32F769DISC/mpconfigboard.h
index 9a700d8e42a55..8dbac2d01574a 100644
--- a/ports/stm32/boards/STM32F769DISC/mpconfigboard.h
+++ b/ports/stm32/boards/STM32F769DISC/mpconfigboard.h
@@ -26,7 +26,7 @@ void board_early_init(void);
 
 #define MICROPY_HW_FLASH_LATENCY    FLASH_LATENCY_7 // 210-216 MHz needs 7 wait states
 
-// 512MBit external QSPI flash, to be memory mapped
+// 512MBit external QSPI flash, used for either the filesystem or XIP memory mapped
 #define MICROPY_HW_QSPIFLASH_SIZE_BITS_LOG2 (29)
 #define MICROPY_HW_QSPIFLASH_CS     (pin_B6)
 #define MICROPY_HW_QSPIFLASH_SCK    (pin_B2)
@@ -35,6 +35,21 @@ void board_early_init(void);
 #define MICROPY_HW_QSPIFLASH_IO2    (pin_E2)
 #define MICROPY_HW_QSPIFLASH_IO3    (pin_D13)
 
+// SPI flash, block device config (when used as the filesystem)
+extern const struct _mp_spiflash_config_t spiflash_config;
+extern struct _spi_bdev_t spi_bdev;
+#if !USE_QSPI_XIP
+#define MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE (0)
+#define MICROPY_HW_BDEV_IOCTL(op, arg) ( \
+    (op) == BDEV_IOCTL_NUM_BLOCKS ? (64 * 1024 * 1024 / FLASH_BLOCK_SIZE) : \
+    (op) == BDEV_IOCTL_INIT ? spi_bdev_ioctl(&spi_bdev, (op), (uint32_t)&spiflash_config) : \
+    spi_bdev_ioctl(&spi_bdev, (op), (arg)) \
+)
+#define MICROPY_HW_BDEV_READBLOCKS(dest, bl, n) spi_bdev_readblocks(&spi_bdev, (dest), (bl), (n))
+#define MICROPY_HW_BDEV_WRITEBLOCKS(src, bl, n) spi_bdev_writeblocks(&spi_bdev, (src), (bl), (n))
+#define MICROPY_HW_BDEV_SPIFLASH_EXTENDED (&spi_bdev) // for extended block protocol
+#endif
+
 // UART config
 #define MICROPY_HW_UART1_TX         (pin_A9)
 #define MICROPY_HW_UART1_RX         (pin_A10)
@@ -87,6 +102,8 @@ void board_early_init(void);
 
 // USB config (CN15 - USB OTG HS with external PHY)
 #define MICROPY_HW_USB_HS (1)
+#define MICROPY_HW_USB_HS_ULPI_NXT  (pin_H4)
+#define MICROPY_HW_USB_HS_ULPI_DIR  (pin_I11)
 
 // Ethernet via RMII
 #define MICROPY_HW_ETH_MDC          (pin_C1)
@@ -100,7 +117,14 @@ void board_early_init(void);
 #define MICROPY_HW_ETH_RMII_TXD1    (pin_G14)
 
 #if 0
-// Optional SDRAM configuration; requires SYSCLK <= 200MHz
+// Optional SDRAM configuration.
+
+// Note: This requires SYSCLK <= 200MHz. 192MHz example below:
+// #define MICROPY_HW_CLK_PLLM (25)
+// #define MICROPY_HW_CLK_PLLN (384)
+// #define MICROPY_HW_CLK_PLLP (RCC_PLLP_DIV2)
+// #define MICROPY_HW_CLK_PLLQ (8)
+
 #define MICROPY_HW_SDRAM_SIZE (128 * 1024 * 1024 / 8) // 128 Mbit
 #define MICROPY_HW_SDRAM_STARTUP_TEST (0)
 #define MICROPY_HEAP_START sdram_start()
@@ -119,7 +143,7 @@ void board_early_init(void);
 #define MICROPY_HW_SDRAM_BURST_LENGTH       1
 #define MICROPY_HW_SDRAM_CAS_LATENCY        2
 #define MICROPY_HW_SDRAM_COLUMN_BITS_NUM    8
-#define MICROPY_HW_SDRAM_ROW_BITS_NUM       13
+#define MICROPY_HW_SDRAM_ROW_BITS_NUM       12
 #define MICROPY_HW_SDRAM_MEM_BUS_WIDTH      32
 #define MICROPY_HW_SDRAM_INTERN_BANKS_NUM   4
 #define MICROPY_HW_SDRAM_CLOCK_PERIOD       2
@@ -192,11 +216,9 @@ void board_early_init(void);
 // Bootloader configuration
 
 // Give Mboot access to the external QSPI flash
-extern const struct _mp_spiflash_config_t spiflash_config;
-extern struct _mp_spiflash_t spiflash_instance;
 #define MBOOT_SPIFLASH_ADDR                     (0x90000000)
 #define MBOOT_SPIFLASH_BYTE_SIZE                (512 * 128 * 1024)
 #define MBOOT_SPIFLASH_LAYOUT                   "/0x90000000/512*128Kg"
 #define MBOOT_SPIFLASH_ERASE_BLOCKS_PER_PAGE    (128 / 4) // 128k page, 4k erase block
 #define MBOOT_SPIFLASH_CONFIG                   (&spiflash_config)
-#define MBOOT_SPIFLASH_SPIFLASH                 (&spiflash_instance)
+#define MBOOT_SPIFLASH_SPIFLASH                 (&spi_bdev.spiflash)
diff --git a/ports/stm32/boards/STM32F769DISC/mpconfigboard.mk b/ports/stm32/boards/STM32F769DISC/mpconfigboard.mk
index 49b318d30b826..81add8c88e772 100644
--- a/ports/stm32/boards/STM32F769DISC/mpconfigboard.mk
+++ b/ports/stm32/boards/STM32F769DISC/mpconfigboard.mk
@@ -1,9 +1,11 @@
 # By default this board is configured to use mboot which must be deployed first
 USE_MBOOT ?= 1
 
-# By default this board puts some code into external QSPI flash set in XIP mode
+# By default the filesystem is in external QSPI flash.  But by setting the
+# following option this board puts some code into external flash set in XIP mode.
 # USE_MBOOT must be enabled; see f769_qspi.ld for code that goes in QSPI flash
-USE_QSPI ?= 1
+USE_QSPI_XIP ?= 0
+CFLAGS += -DUSE_QSPI_XIP=$(USE_QSPI_XIP)
 
 # MCU settings
 MCU_SERIES = f7
@@ -12,9 +14,11 @@ MICROPY_FLOAT_IMPL = double
 AF_FILE = boards/stm32f767_af.csv
 
 ifeq ($(USE_MBOOT),1)
-ifeq ($(USE_QSPI),1)
+ifeq ($(USE_QSPI_XIP),1)
 
-# When using Mboot and QSPI the text is split between internal and external flash
+# When using Mboot and QSPI-XIP the text is split between internal and external
+# QSPI flash, and the filesystem is in internal flash between the bootloader and
+# the main program text.
 LD_FILES = boards/STM32F769DISC/f769_qspi.ld
 TEXT0_ADDR = 0x08020000
 TEXT1_ADDR = 0x90000000
@@ -23,19 +27,23 @@ TEXT1_SECTIONS = .text_qspi
 
 else
 
-# When using Mboot but not QSPI all the text goes together after the filesystem
+# When using Mboot but not QSPI-XIP all the text goes together after the bootloader
+# (at same location as when QSPI-XIP is enabled so the same Mboot can be used for
+# either configuration) and the filesystem is in external flash.
 LD_FILES = boards/stm32f769.ld boards/common_blifs.ld
 TEXT0_ADDR = 0x08020000
 
 endif
 else
 
-# When not using Mboot the ISR text goes first, then the rest after the filesystem
-LD_FILES = boards/stm32f769.ld boards/common_ifs.ld
+# When not using Mboot (and so no ability to load text into QSPI) all the text goes
+# together at the start of internal flash, and the filesystem is in external flash.
+LD_FILES = boards/stm32f769.ld boards/common_basic.ld
 TEXT0_ADDR = 0x08000000
-TEXT1_ADDR = 0x08020000
 
 endif
 
 # MicroPython settings
 MICROPY_PY_LWIP = 1
+MICROPY_PY_USSL = 1
+MICROPY_SSL_MBEDTLS = 1
diff --git a/ports/stm32/boards/STM32F769DISC/stm32f7xx_hal_conf.h b/ports/stm32/boards/STM32F769DISC/stm32f7xx_hal_conf.h
index 15933906720da..621b05c719e92 100644
--- a/ports/stm32/boards/STM32F769DISC/stm32f7xx_hal_conf.h
+++ b/ports/stm32/boards/STM32F769DISC/stm32f7xx_hal_conf.h
@@ -1,427 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f7xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.0.1
-  * @date    25-June-2015
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F7xx_HAL_CONF_H
-#define __STM32F7xx_HAL_CONF_H
+#include "boards/stm32f7xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (25000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (5000)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CEC_MODULE_ENABLED   */
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-/* #define HAL_DAC_MODULE_ENABLED */
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-#define HAL_SDRAM_MODULE_ENABLED
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-#define HAL_I2S_MODULE_ENABLED
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LPTIM_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-/* #define HAL_QSPI_MODULE_ENABLED */
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-/* #define HAL_SPDIFRX_MODULE_ENABLED */
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED  */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## Timeout Configuration ######################### */
-/**
-  * @brief This is the HAL configuration section
-  */
-#define HAL_ACCURATE_TIMEOUT_ENABLED   0
-#define HAL_TIMEOUT_VALUE              0x1FFFFFF
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSE_VALUE)
-  #define HSE_VALUE    ((uint32_t)25000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)5000)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE)
- #define LSI_VALUE  ((uint32_t)32000)
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source
-  *        frequency, this source is inserted directly through I2S_CKIN pad.
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  ART_ACCLERATOR_ENABLE        1 /* To enable instruction cache and prefetch */
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   1
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)5)       /* 5 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)5)       /* 5 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-/* LAN8742A PHY Address*/
-#define LAN8742A_PHY_ADDRESS            0x00
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/
-#define PHY_RESET_DELAY                 ((uint32_t)0x00000FFF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
-
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
-
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f7xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f7xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f7xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f7xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f7xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f7xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CEC_MODULE_ENABLED
-  #include "stm32f7xx_hal_cec.h"
-#endif /* HAL_CEC_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f7xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f7xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f7xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f7xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f7xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f7xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f7xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f7xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f7xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f7xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f7xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f7xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f7xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f7xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f7xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LPTIM_MODULE_ENABLED
- #include "stm32f7xx_hal_lptim.h"
-#endif /* HAL_LPTIM_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f7xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f7xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_QSPI_MODULE_ENABLED
- #include "stm32f7xx_hal_qspi.h"
-#endif /* HAL_QSPI_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f7xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f7xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f7xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f7xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPDIFRX_MODULE_ENABLED
- #include "stm32f7xx_hal_spdifrx.h"
-#endif /* HAL_SPDIFRX_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f7xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f7xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f7xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f7xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f7xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f7xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f7xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f7xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f7xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F7xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
diff --git a/ports/stm32/boards/STM32F7DISC/mpconfigboard.mk b/ports/stm32/boards/STM32F7DISC/mpconfigboard.mk
index 4f88a139e7450..8b54dc84e113e 100644
--- a/ports/stm32/boards/STM32F7DISC/mpconfigboard.mk
+++ b/ports/stm32/boards/STM32F7DISC/mpconfigboard.mk
@@ -7,3 +7,5 @@ TEXT1_ADDR = 0x08020000
 
 # MicroPython settings
 MICROPY_PY_LWIP = 1
+MICROPY_PY_USSL = 1
+MICROPY_SSL_MBEDTLS = 1
diff --git a/ports/stm32/boards/STM32F7DISC/stm32f7xx_hal_conf.h b/ports/stm32/boards/STM32F7DISC/stm32f7xx_hal_conf.h
index 15933906720da..621b05c719e92 100644
--- a/ports/stm32/boards/STM32F7DISC/stm32f7xx_hal_conf.h
+++ b/ports/stm32/boards/STM32F7DISC/stm32f7xx_hal_conf.h
@@ -1,427 +1,19 @@
-/**
-  ******************************************************************************
-  * @file    stm32f7xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.0.1
-  * @date    25-June-2015
-  * @brief   HAL configuration file.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
 
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32F7xx_HAL_CONF_H
-#define __STM32F7xx_HAL_CONF_H
+#include "boards/stm32f7xx_hal_conf_base.h"
 
-#ifdef __cplusplus
- extern "C" {
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (25000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_CLOCK_VALUE (12288000)
 
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (5000)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_CEC_MODULE_ENABLED   */
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-/* #define HAL_DAC_MODULE_ENABLED */
-/* #define HAL_DCMI_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_ETH_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-#define HAL_SDRAM_MODULE_ENABLED
-/* #define HAL_HASH_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-#define HAL_I2S_MODULE_ENABLED
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LPTIM_MODULE_ENABLED */
-/* #define HAL_LTDC_MODULE_ENABLED */
-#define HAL_PWR_MODULE_ENABLED
-/* #define HAL_QSPI_MODULE_ENABLED */
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-/* #define HAL_SPDIFRX_MODULE_ENABLED */
-#define HAL_SPI_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_IRDA_MODULE_ENABLED  */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-
-
-/* ########################## Timeout Configuration ######################### */
-/**
-  * @brief This is the HAL configuration section
-  */
-#define HAL_ACCURATE_TIMEOUT_ENABLED   0
-#define HAL_TIMEOUT_VALUE              0x1FFFFFF
-
-/* ########################## HSE/HSI Values adaptation ##################### */
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSE_VALUE)
-  #define HSE_VALUE    ((uint32_t)25000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)5000)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL).
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE)
- #define LSI_VALUE  ((uint32_t)32000)
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  */
-#if !defined  (LSE_VALUE)
- #define LSE_VALUE  ((uint32_t)32768)    /*!< Value of the External Low Speed oscillator in Hz */
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000U)   /*!< Time out for LSE start up, in ms */
-#endif /* LSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for I2S peripheral
-  *        This value is used by the I2S HAL module to compute the I2S clock source
-  *        frequency, this source is inserted directly through I2S_CKIN pad.
-  */
-#if !defined  (EXTERNAL_CLOCK_VALUE)
-  #define EXTERNAL_CLOCK_VALUE    ((uint32_t)12288000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* EXTERNAL_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  ART_ACCLERATOR_ENABLE        1 /* To enable instruction cache and prefetch */
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* ################## Ethernet peripheral configuration ##################### */
-
-/* Section 1 : Ethernet peripheral configuration */
-
-/* MAC ADDRESS: MAC_ADDR0:MAC_ADDR1:MAC_ADDR2:MAC_ADDR3:MAC_ADDR4:MAC_ADDR5 */
-#define MAC_ADDR0   2
-#define MAC_ADDR1   1
-#define MAC_ADDR2   0
-#define MAC_ADDR3   0
-#define MAC_ADDR4   0
-#define MAC_ADDR5   0
-
-/* Definition of the Ethernet driver buffers size and count */
-#define ETH_RX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for receive               */
-#define ETH_TX_BUF_SIZE                ETH_MAX_PACKET_SIZE /* buffer size for transmit              */
-#define ETH_RXBUFNB                    ((uint32_t)5)       /* 5 Rx buffers of size ETH_RX_BUF_SIZE  */
-#define ETH_TXBUFNB                    ((uint32_t)5)       /* 5 Tx buffers of size ETH_TX_BUF_SIZE  */
-
-/* Section 2: PHY configuration section */
-/* LAN8742A PHY Address*/
-#define LAN8742A_PHY_ADDRESS            0x00
-/* PHY Reset delay these values are based on a 1 ms Systick interrupt*/
-#define PHY_RESET_DELAY                 ((uint32_t)0x00000FFF)
-/* PHY Configuration delay */
-#define PHY_CONFIG_DELAY                ((uint32_t)0x00000FFFF)
-
-#define PHY_READ_TO                     ((uint32_t)0x0000FFFF)
-#define PHY_WRITE_TO                    ((uint32_t)0x0000FFFF)
-
-/* Section 3: Common PHY Registers */
-
-#define PHY_BCR                         ((uint16_t)0x00)    /*!< Transceiver Basic Control Register   */
-#define PHY_BSR                         ((uint16_t)0x01)    /*!< Transceiver Basic Status Register    */
-
-#define PHY_RESET                       ((uint16_t)0x8000)  /*!< PHY Reset */
-#define PHY_LOOPBACK                    ((uint16_t)0x4000)  /*!< Select loop-back mode */
-#define PHY_FULLDUPLEX_100M             ((uint16_t)0x2100)  /*!< Set the full-duplex mode at 100 Mb/s */
-#define PHY_HALFDUPLEX_100M             ((uint16_t)0x2000)  /*!< Set the half-duplex mode at 100 Mb/s */
-#define PHY_FULLDUPLEX_10M              ((uint16_t)0x0100)  /*!< Set the full-duplex mode at 10 Mb/s  */
-#define PHY_HALFDUPLEX_10M              ((uint16_t)0x0000)  /*!< Set the half-duplex mode at 10 Mb/s  */
-#define PHY_AUTONEGOTIATION             ((uint16_t)0x1000)  /*!< Enable auto-negotiation function     */
-#define PHY_RESTART_AUTONEGOTIATION     ((uint16_t)0x0200)  /*!< Restart auto-negotiation function    */
-#define PHY_POWERDOWN                   ((uint16_t)0x0800)  /*!< Select the power down mode           */
-#define PHY_ISOLATE                     ((uint16_t)0x0400)  /*!< Isolate PHY from MII                 */
-
-#define PHY_AUTONEGO_COMPLETE           ((uint16_t)0x0020)  /*!< Auto-Negotiation process completed   */
-#define PHY_LINKED_STATUS               ((uint16_t)0x0004)  /*!< Valid link established               */
-#define PHY_JABBER_DETECTION            ((uint16_t)0x0002)  /*!< Jabber condition detected            */
-
-/* Section 4: Extended PHY Registers */
-
-#define PHY_SR                          ((uint16_t)0x10)    /*!< PHY status register Offset                      */
-#define PHY_MICR                        ((uint16_t)0x11)    /*!< MII Interrupt Control Register                  */
-#define PHY_MISR                        ((uint16_t)0x12)    /*!< MII Interrupt Status and Misc. Control Register */
-
-#define PHY_LINK_STATUS                 ((uint16_t)0x0001)  /*!< PHY Link mask                                   */
-#define PHY_SPEED_STATUS                ((uint16_t)0x0002)  /*!< PHY Speed mask                                  */
-#define PHY_DUPLEX_STATUS               ((uint16_t)0x0004)  /*!< PHY Duplex mask                                 */
-
-#define PHY_MICR_INT_EN                 ((uint16_t)0x0002)  /*!< PHY Enable interrupts                           */
-#define PHY_MICR_INT_OE                 ((uint16_t)0x0001)  /*!< PHY Enable output interrupt events              */
-
-#define PHY_MISR_LINK_INT_EN            ((uint16_t)0x0020)  /*!< Enable Interrupt on change of link status       */
-#define PHY_LINK_INTERRUPT              ((uint16_t)0x2000)  /*!< PHY link status interrupt mask                  */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32f7xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32f7xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32f7xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32f7xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32f7xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32f7xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_CEC_MODULE_ENABLED
-  #include "stm32f7xx_hal_cec.h"
-#endif /* HAL_CEC_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32f7xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32f7xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32f7xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32f7xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32f7xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_ETH_MODULE_ENABLED
-  #include "stm32f7xx_hal_eth.h"
-#endif /* HAL_ETH_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32f7xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32f7xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32f7xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32f7xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_SDRAM_MODULE_ENABLED
-  #include "stm32f7xx_hal_sdram.h"
-#endif /* HAL_SDRAM_MODULE_ENABLED */
-
-#ifdef HAL_HASH_MODULE_ENABLED
- #include "stm32f7xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32f7xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_I2S_MODULE_ENABLED
- #include "stm32f7xx_hal_i2s.h"
-#endif /* HAL_I2S_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32f7xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LPTIM_MODULE_ENABLED
- #include "stm32f7xx_hal_lptim.h"
-#endif /* HAL_LPTIM_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
- #include "stm32f7xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32f7xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_QSPI_MODULE_ENABLED
- #include "stm32f7xx_hal_qspi.h"
-#endif /* HAL_QSPI_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32f7xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32f7xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32f7xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32f7xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SPDIFRX_MODULE_ENABLED
- #include "stm32f7xx_hal_spdifrx.h"
-#endif /* HAL_SPDIFRX_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32f7xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32f7xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32f7xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32f7xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32f7xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32f7xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32f7xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32f7xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32f7xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32F7xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32F7XX_HAL_CONF_H
diff --git a/ports/stm32/boards/STM32L476DISC/mpconfigboard.mk b/ports/stm32/boards/STM32L476DISC/mpconfigboard.mk
index 2cad9e2e566fe..10c69461c9309 100644
--- a/ports/stm32/boards/STM32L476DISC/mpconfigboard.mk
+++ b/ports/stm32/boards/STM32L476DISC/mpconfigboard.mk
@@ -1,7 +1,5 @@
 MCU_SERIES = l4
 CMSIS_MCU = STM32L476xx
 AF_FILE = boards/stm32l476_af.csv
-LD_FILES = boards/stm32l476xg.ld boards/common_ifs.ld
-TEXT0_ADDR = 0x08000000
-TEXT1_ADDR = 0x08004000
+LD_FILES = boards/stm32l476xg.ld boards/common_basic.ld
 OPENOCD_CONFIG = boards/openocd_stm32l4.cfg
diff --git a/ports/stm32/boards/STM32L476DISC/stm32l4xx_hal_conf.h b/ports/stm32/boards/STM32L476DISC/stm32l4xx_hal_conf.h
index 6bfb28118a44b..fd380ab7357e2 100644
--- a/ports/stm32/boards/STM32L476DISC/stm32l4xx_hal_conf.h
+++ b/ports/stm32/boards/STM32L476DISC/stm32l4xx_hal_conf.h
@@ -1,372 +1,20 @@
-/**
-  ******************************************************************************
-  * @file    stm32l4xx_hal_conf.h
-  * @author  MCD Application Team
-  * @version V1.2.0
-  * @date    25-November-2015
-  * @brief   HAL configuration template file.
-  *          This file should be copied to the application folder and renamed
-  *          to stm32l4xx_hal_conf.h.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
-
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32L4xx_HAL_CONF_H
-#define __STM32L4xx_HAL_CONF_H
-
-#ifdef __cplusplus
- extern "C" {
-#endif
-
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
-
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_COMP_MODULE_ENABLED */
-#define HAL_CORTEX_MODULE_ENABLED
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DFSDM_MODULE_ENABLED */
-#define HAL_DMA_MODULE_ENABLED
-/* #define HAL_FIREWALL_MODULE_ENABLED */
-#define HAL_FLASH_MODULE_ENABLED
-/* #define HAL_HCD_MODULE_ENABLED */
-/* #define HAL_NAND_MODULE_ENABLED */
-/* #define HAL_NOR_MODULE_ENABLED */
-/* #define HAL_SRAM_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-/* #define HAL_IRDA_MODULE_ENABLED */
-/* #define HAL_IWDG_MODULE_ENABLED */
-/* #define HAL_LCD_MODULE_ENABLED */
-/* #define HAL_LPTIM_MODULE_ENABLED */
-/* #define HAL_OPAMP_MODULE_ENABLED */
-#define HAL_PCD_MODULE_ENABLED
-#define HAL_PWR_MODULE_ENABLED
-/* #define HAL_QSPI_MODULE_ENABLED */
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-/* #define HAL_SMBUS_MODULE_ENABLED */
-#define HAL_SPI_MODULE_ENABLED
-/* #define HAL_SWPMI_MODULE_ENABLED */
-#define HAL_TIM_MODULE_ENABLED
-/* #define HAL_TSC_MODULE_ENABLED */
-#define HAL_UART_MODULE_ENABLED
-/* #define HAL_USART_MODULE_ENABLED */
-/* #define HAL_WWDG_MODULE_ENABLED */
-
-
-/* ########################## Oscillator Values adaptation ####################*/
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).  
-  */
-#if !defined  (HSE_VALUE) 
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal Multiple Speed oscillator (MSI) default value.
-  *        This value is the default MSI range value after Reset.
-  */
-#if !defined  (MSI_VALUE)
-  #define MSI_VALUE    ((uint32_t)4000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* MSI_VALUE */
-
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL). 
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE) 
- #define LSI_VALUE  ((uint32_t)32000)       /*!< LSI Typical Value in Hz*/
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  *        This value is used by the UART, RTC HAL module to compute the system frequency
-  */
-#if !defined  (LSE_VALUE)
-  #define LSE_VALUE    ((uint32_t)32768) /*!< Value of the External oscillator in Hz*/
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000)   /*!< Time out for LSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for SAI1 peripheral
-  *        This value is used by the RCC HAL module to compute the SAI1 & SAI2 clock source 
-  *        frequency.
-  */
-#if !defined  (EXTERNAL_SAI1_CLOCK_VALUE)
-  #define EXTERNAL_SAI1_CLOCK_VALUE    ((uint32_t)48000) /*!< Value of the SAI1 External clock source in Hz*/
-#endif /* EXTERNAL_SAI1_CLOCK_VALUE */
-
-/**
-  * @brief External clock source for SAI2 peripheral
-  *        This value is used by the RCC HAL module to compute the SAI1 & SAI2 clock source 
-  *        frequency.
-  */
-#if !defined  (EXTERNAL_SAI2_CLOCK_VALUE)
-  #define EXTERNAL_SAI2_CLOCK_VALUE    ((uint32_t)48000) /*!< Value of the SAI2 External clock source in Hz*/
-#endif /* EXTERNAL_SAI2_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32l4xx_hal_rcc.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32l4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32l4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_DFSDM_MODULE_ENABLED
-  #include "stm32l4xx_hal_dfsdm.h"
-#endif /* HAL_DFSDM_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32l4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32l4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32l4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_COMP_MODULE_ENABLED
-  #include "stm32l4xx_hal_comp.h"
-#endif /* HAL_COMP_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32l4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32l4xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32l4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_FIREWALL_MODULE_ENABLED
-  #include "stm32l4xx_hal_firewall.h"
-#endif /* HAL_FIREWALL_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32l4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32l4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32l4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32l4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
- #include "stm32l4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
- #include "stm32l4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LCD_MODULE_ENABLED
- #include "stm32l4xx_hal_lcd.h"
-#endif /* HAL_LCD_MODULE_ENABLED */
-
-#ifdef HAL_LPTIM_MODULE_ENABLED
-#include "stm32l4xx_hal_lptim.h"
-#endif /* HAL_LPTIM_MODULE_ENABLED */
-
-#ifdef HAL_OPAMP_MODULE_ENABLED
-#include "stm32l4xx_hal_opamp.h"
-#endif /* HAL_OPAMP_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
- #include "stm32l4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_QSPI_MODULE_ENABLED
- #include "stm32l4xx_hal_qspi.h"
-#endif /* HAL_QSPI_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
- #include "stm32l4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
- #include "stm32l4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
- #include "stm32l4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
- #include "stm32l4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SMBUS_MODULE_ENABLED
- #include "stm32l4xx_hal_smbus.h"
-#endif /* HAL_SMBUS_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
- #include "stm32l4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_SWPMI_MODULE_ENABLED
- #include "stm32l4xx_hal_swpmi.h"
-#endif /* HAL_SWPMI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
- #include "stm32l4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_TSC_MODULE_ENABLED
- #include "stm32l4xx_hal_tsc.h"
-#endif /* HAL_TSC_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
- #include "stm32l4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
- #include "stm32l4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
- #include "stm32l4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
- #include "stm32l4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
- #include "stm32l4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
- #include "stm32l4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
- #include "stm32l4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0)
-#endif /* USE_FULL_ASSERT */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __STM32L4xx_HAL_CONF_H */
-
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
+
+#include "boards/stm32l4xx_hal_conf_base.h"
+
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_SAI1_CLOCK_VALUE (48000)
+#define EXTERNAL_SAI2_CLOCK_VALUE (48000)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#endif // MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/STM32L496GDISC/mpconfigboard.h b/ports/stm32/boards/STM32L496GDISC/mpconfigboard.h
index 6a17d74d3a016..5d9fa25bc3b84 100644
--- a/ports/stm32/boards/STM32L496GDISC/mpconfigboard.h
+++ b/ports/stm32/boards/STM32L496GDISC/mpconfigboard.h
@@ -14,9 +14,11 @@
 #define MICROPY_HW_CLK_PLLP (RCC_PLLP_DIV7)
 #define MICROPY_HW_CLK_PLLR (RCC_PLLR_DIV2)
 #define MICROPY_HW_CLK_PLLQ (RCC_PLLQ_DIV2)
-
 #define MICROPY_HW_FLASH_LATENCY    FLASH_LATENCY_4
 
+// The board has an external 32kHz crystal
+#define MICROPY_HW_RTC_USE_LSE      (1)
+
 // USART config
 #define MICROPY_HW_UART2_TX     (pin_A2)
 #define MICROPY_HW_UART2_RX     (pin_D6)
diff --git a/ports/stm32/boards/STM32L496GDISC/mpconfigboard.mk b/ports/stm32/boards/STM32L496GDISC/mpconfigboard.mk
index 3a617465563b0..a85635e306d91 100644
--- a/ports/stm32/boards/STM32L496GDISC/mpconfigboard.mk
+++ b/ports/stm32/boards/STM32L496GDISC/mpconfigboard.mk
@@ -1,7 +1,5 @@
 MCU_SERIES = l4
 CMSIS_MCU = STM32L496xx
 AF_FILE = boards/stm32l496_af.csv
-LD_FILES = boards/stm32l496xg.ld boards/common_ifs.ld
-TEXT0_ADDR = 0x08000000
-TEXT1_ADDR = 0x08004000
+LD_FILES = boards/stm32l496xg.ld boards/common_basic.ld
 OPENOCD_CONFIG = boards/openocd_stm32l4.cfg
diff --git a/ports/stm32/boards/STM32L496GDISC/stm32l4xx_hal_conf.h b/ports/stm32/boards/STM32L496GDISC/stm32l4xx_hal_conf.h
index 884db5ef1a3de..fd380ab7357e2 100644
--- a/ports/stm32/boards/STM32L496GDISC/stm32l4xx_hal_conf.h
+++ b/ports/stm32/boards/STM32L496GDISC/stm32l4xx_hal_conf.h
@@ -1,421 +1,20 @@
-/**
-  ******************************************************************************
-  * @file    stm32l4xx_hal_conf.h
-  * @brief   HAL configuration file.             
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2018 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
-
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef __STM32L4xx_HAL_CONF_H
-#define __STM32L4xx_HAL_CONF_H
-
-#ifdef __cplusplus
- extern "C" {
-#endif
-
-/* Exported types ------------------------------------------------------------*/
-/* Exported constants --------------------------------------------------------*/
-
-/* ########################## Module Selection ############################## */
-/**
-  * @brief This is the list of modules to be used in the HAL driver
-  */
-
-#define HAL_MODULE_ENABLED
-#define HAL_ADC_MODULE_ENABLED
-/*#define HAL_CRYP_MODULE_ENABLED   */
-#define HAL_CAN_MODULE_ENABLED
-/* #define HAL_COMP_MODULE_ENABLED */
-/* #define HAL_CRC_MODULE_ENABLED */
-/* #define HAL_CRYP_MODULE_ENABLED */
-#define HAL_DAC_MODULE_ENABLED
-/* #define HAL_DCMI_MODULE_ENABLED */
-/*#define HAL_DMA2D_MODULE_ENABLED */
-/* #define HAL_DFSDM_MODULE_ENABLED */
-/*#define HAL_DSI_MODULE_ENABLED   */
-/*#define HAL_FIREWALL_MODULE_ENABLED   */
-/*#define HAL_GFXMMU_MODULE_ENABLED   */
-/*#define HAL_HCD_MODULE_ENABLED   */
-/*#define HAL_HASH_MODULE_ENABLED   */
-/*#define HAL_I2S_MODULE_ENABLED   */
-/*#define HAL_IRDA_MODULE_ENABLED */
-/*#define HAL_IWDG_MODULE_ENABLED */
-/*#define HAL_LTDC_MODULE_ENABLED   */
-/*#define HAL_LCD_MODULE_ENABLED   */
-/*#define HAL_LPTIM_MODULE_ENABLED   */
-/*#define HAL_NAND_MODULE_ENABLED   */
-/*#define HAL_NOR_MODULE_ENABLED   */
-/*#define HAL_OPAMP_MODULE_ENABLED   */
-/*#define HAL_OSPI_MODULE_ENABLED   */
-#define HAL_PCD_MODULE_ENABLED
-#define HAL_RNG_MODULE_ENABLED
-#define HAL_RTC_MODULE_ENABLED
-/* #define HAL_SAI_MODULE_ENABLED */
-#define HAL_SD_MODULE_ENABLED
-/* #define HAL_SMBUS_MODULE_ENABLED */
-/* #define HAL_SMARTCARD_MODULE_ENABLED */
-#define HAL_SPI_MODULE_ENABLED
-/*#define HAL_SRAM_MODULE_ENABLED */
-/*#define HAL_SWPMI_MODULE_ENABLED */
-#define HAL_TIM_MODULE_ENABLED
-/*#define HAL_TSC_MODULE_ENABLED */
-#define HAL_UART_MODULE_ENABLED
-/*#define HAL_USART_MODULE_ENABLED */
-/*#define HAL_WWDG_MODULE_ENABLED */
-#define HAL_GPIO_MODULE_ENABLED
-#define HAL_I2C_MODULE_ENABLED
-#define HAL_DMA_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-#define HAL_FLASH_MODULE_ENABLED
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_CORTEX_MODULE_ENABLED
-
-/* ########################## Oscillator Values adaptation ####################*/
-/**
-  * @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSE is used as system clock source, directly or through the PLL).  
-  */
-#if !defined  (HSE_VALUE) 
-  #define HSE_VALUE    ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
-#endif /* HSE_VALUE */
-
-#if !defined  (HSE_STARTUP_TIMEOUT)
-  #define HSE_STARTUP_TIMEOUT    ((uint32_t)100)   /*!< Time out for HSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief Internal Multiple Speed oscillator (MSI) default value.
-  *        This value is the default MSI range value after Reset.
-  */
-#if !defined  (MSI_VALUE)
-  #define MSI_VALUE    ((uint32_t)4000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* MSI_VALUE */
-/**
-  * @brief Internal High Speed oscillator (HSI) value.
-  *        This value is used by the RCC HAL module to compute the system frequency
-  *        (when HSI is used as system clock source, directly or through the PLL). 
-  */
-#if !defined  (HSI_VALUE)
-  #define HSI_VALUE    ((uint32_t)16000000) /*!< Value of the Internal oscillator in Hz*/
-#endif /* HSI_VALUE */
-
- /**
-   * @brief Internal High Speed oscillator (HSI48) value for USB FS, SDMMC and RNG.
-   *        This internal oscillator is mainly dedicated to provide a high precision clock to
-   *        the USB peripheral by means of a special Clock Recovery System (CRS) circuitry.
-   *        When the CRS is not used, the HSI48 RC oscillator runs on it default frequency
-   *        which is subject to manufacturing process variations.
-   */
- #if !defined  (HSI48_VALUE)
-  #define HSI48_VALUE   ((uint32_t)48000000U) /*!< Value of the Internal High Speed oscillator for USB FS/SDMMC/RNG in Hz.
-                                               The real value my vary depending on manufacturing process variations.*/
- #endif /* HSI48_VALUE */
-
-/**
-  * @brief Internal Low Speed oscillator (LSI) value.
-  */
-#if !defined  (LSI_VALUE) 
- #define LSI_VALUE  ((uint32_t)32000)      /*!< LSI Typical Value in Hz*/
-#endif /* LSI_VALUE */                      /*!< Value of the Internal Low Speed oscillator in Hz
-                                             The real value may vary depending on the variations
-                                             in voltage and temperature.  */
-/**
-  * @brief External Low Speed oscillator (LSE) value.
-  *        This value is used by the UART, RTC HAL module to compute the system frequency
-  */
-#if !defined  (LSE_VALUE)
-  #define LSE_VALUE    ((uint32_t)32768) /*!< Value of the External oscillator in Hz*/
-#endif /* LSE_VALUE */
-
-#if !defined  (LSE_STARTUP_TIMEOUT)
-  #define LSE_STARTUP_TIMEOUT    ((uint32_t)5000)   /*!< Time out for LSE start up, in ms */
-#endif /* HSE_STARTUP_TIMEOUT */
-
-/**
-  * @brief External clock source for SAI1 peripheral
-  *        This value is used by the RCC HAL module to compute the SAI1 & SAI2 clock source 
-  *        frequency.
-  */
-#if !defined  (EXTERNAL_SAI1_CLOCK_VALUE)
-  #define EXTERNAL_SAI1_CLOCK_VALUE    ((uint32_t)48000) /*!< Value of the SAI1 External clock source in Hz*/
-#endif /* EXTERNAL_SAI1_CLOCK_VALUE */
-
-/**
-  * @brief External clock source for SAI2 peripheral
-  *        This value is used by the RCC HAL module to compute the SAI1 & SAI2 clock source 
-  *        frequency.
-  */
-#if !defined  (EXTERNAL_SAI2_CLOCK_VALUE)
-  #define EXTERNAL_SAI2_CLOCK_VALUE    ((uint32_t)48000) /*!< Value of the SAI2 External clock source in Hz*/
-#endif /* EXTERNAL_SAI2_CLOCK_VALUE */
-
-/* Tip: To avoid modifying this file each time you need to use different HSE,
-   ===  you can define the HSE value in your toolchain compiler preprocessor. */
-
-/* ########################### System Configuration ######################### */
-/**
-  * @brief This is the HAL system configuration section
-  */
-#define  VDD_VALUE                    ((uint32_t)3300) /*!< Value of VDD in mv */
-#define  TICK_INT_PRIORITY            ((uint32_t)0x00) /*!< tick interrupt priority */
-#define  USE_RTOS                     0
-#define  PREFETCH_ENABLE              1
-#define  INSTRUCTION_CACHE_ENABLE     1
-#define  DATA_CACHE_ENABLE            1
-
-/* ########################## Assert Selection ############################## */
-/**
-  * @brief Uncomment the line below to expanse the "assert_param" macro in the
-  *        HAL drivers code
-  */
-/* #define USE_FULL_ASSERT    1 */
-
-/* CRC FEATURE: Use to activate CRC feature inside HAL SPI Driver
- * Activated: CRC code is present inside driver
- * Deactivated: CRC code cleaned from driver
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
  */
+#ifndef MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
 
-#define USE_SPI_CRC                   0
-
-/* Includes ------------------------------------------------------------------*/
-/**
-  * @brief Include module's header file
-  */
-
-#ifdef HAL_RCC_MODULE_ENABLED
-  #include "stm32l4xx_hal_rcc.h"
-  #include "stm32l4xx_hal_rcc_ex.h"
-#endif /* HAL_RCC_MODULE_ENABLED */
-
-#ifdef HAL_GPIO_MODULE_ENABLED
-  #include "stm32l4xx_hal_gpio.h"
-#endif /* HAL_GPIO_MODULE_ENABLED */
-
-#ifdef HAL_DMA_MODULE_ENABLED
-  #include "stm32l4xx_hal_dma.h"
-#endif /* HAL_DMA_MODULE_ENABLED */
-
-#ifdef HAL_DFSDM_MODULE_ENABLED
-  #include "stm32l4xx_hal_dfsdm.h"
-#endif /* HAL_DFSDM_MODULE_ENABLED */
-
-#ifdef HAL_CORTEX_MODULE_ENABLED
-  #include "stm32l4xx_hal_cortex.h"
-#endif /* HAL_CORTEX_MODULE_ENABLED */
-
-#ifdef HAL_ADC_MODULE_ENABLED
-  #include "stm32l4xx_hal_adc.h"
-#endif /* HAL_ADC_MODULE_ENABLED */
-
-#ifdef HAL_CAN_MODULE_ENABLED
-  #include "stm32l4xx_hal_can.h"
-#endif /* HAL_CAN_MODULE_ENABLED */
-
-#ifdef HAL_COMP_MODULE_ENABLED
-  #include "stm32l4xx_hal_comp.h"
-#endif /* HAL_COMP_MODULE_ENABLED */
-
-#ifdef HAL_CRC_MODULE_ENABLED
-  #include "stm32l4xx_hal_crc.h"
-#endif /* HAL_CRC_MODULE_ENABLED */
-
-#ifdef HAL_CRYP_MODULE_ENABLED
-  #include "stm32l4xx_hal_cryp.h"
-#endif /* HAL_CRYP_MODULE_ENABLED */
-
-#ifdef HAL_DAC_MODULE_ENABLED
-  #include "stm32l4xx_hal_dac.h"
-#endif /* HAL_DAC_MODULE_ENABLED */
-
-#ifdef HAL_DCMI_MODULE_ENABLED
-  #include "stm32l4xx_hal_dcmi.h"
-#endif /* HAL_DCMI_MODULE_ENABLED */
-
-#ifdef HAL_DMA2D_MODULE_ENABLED
-  #include "stm32l4xx_hal_dma2d.h"
-#endif /* HAL_DMA2D_MODULE_ENABLED */
-
-#ifdef HAL_DSI_MODULE_ENABLED
-  #include "stm32l4xx_hal_dsi.h"
-#endif /* HAL_DSI_MODULE_ENABLED */
-
-#ifdef HAL_FIREWALL_MODULE_ENABLED
-  #include "stm32l4xx_hal_firewall.h"
-#endif /* HAL_FIREWALL_MODULE_ENABLED */
-
-#ifdef HAL_FLASH_MODULE_ENABLED
-  #include "stm32l4xx_hal_flash.h"
-#endif /* HAL_FLASH_MODULE_ENABLED */
-
-#ifdef HAL_HASH_MODULE_ENABLED
-  #include "stm32l4xx_hal_hash.h"
-#endif /* HAL_HASH_MODULE_ENABLED */
-
-#ifdef HAL_SRAM_MODULE_ENABLED
-  #include "stm32l4xx_hal_sram.h"
-#endif /* HAL_SRAM_MODULE_ENABLED */
-
-#ifdef HAL_NOR_MODULE_ENABLED
-  #include "stm32l4xx_hal_nor.h"
-#endif /* HAL_NOR_MODULE_ENABLED */
-
-#ifdef HAL_NAND_MODULE_ENABLED
-  #include "stm32l4xx_hal_nand.h"
-#endif /* HAL_NAND_MODULE_ENABLED */
-
-#ifdef HAL_I2C_MODULE_ENABLED
-  #include "stm32l4xx_hal_i2c.h"
-#endif /* HAL_I2C_MODULE_ENABLED */
-
-#ifdef HAL_IWDG_MODULE_ENABLED
-  #include "stm32l4xx_hal_iwdg.h"
-#endif /* HAL_IWDG_MODULE_ENABLED */
-
-#ifdef HAL_LCD_MODULE_ENABLED
-  #include "stm32l4xx_hal_lcd.h"
-#endif /* HAL_LCD_MODULE_ENABLED */
-
-#ifdef HAL_LPTIM_MODULE_ENABLED
-  #include "stm32l4xx_hal_lptim.h"
-#endif /* HAL_LPTIM_MODULE_ENABLED */
-
-#ifdef HAL_LTDC_MODULE_ENABLED
-  #include "stm32l4xx_hal_ltdc.h"
-#endif /* HAL_LTDC_MODULE_ENABLED */
-
-#ifdef HAL_OPAMP_MODULE_ENABLED
-  #include "stm32l4xx_hal_opamp.h"
-#endif /* HAL_OPAMP_MODULE_ENABLED */
-
-#ifdef HAL_OSPI_MODULE_ENABLED
-  #include "stm32l4xx_hal_ospi.h"
-#endif /* HAL_OSPI_MODULE_ENABLED */
-
-#ifdef HAL_PWR_MODULE_ENABLED
-  #include "stm32l4xx_hal_pwr.h"
-#endif /* HAL_PWR_MODULE_ENABLED */
-
-#ifdef HAL_QSPI_MODULE_ENABLED
-  #include "stm32l4xx_hal_qspi.h"
-#endif /* HAL_QSPI_MODULE_ENABLED */
-
-#ifdef HAL_RNG_MODULE_ENABLED
-  #include "stm32l4xx_hal_rng.h"
-#endif /* HAL_RNG_MODULE_ENABLED */
-
-#ifdef HAL_RTC_MODULE_ENABLED
-  #include "stm32l4xx_hal_rtc.h"
-#endif /* HAL_RTC_MODULE_ENABLED */
-
-#ifdef HAL_SAI_MODULE_ENABLED
-  #include "stm32l4xx_hal_sai.h"
-#endif /* HAL_SAI_MODULE_ENABLED */
-
-#ifdef HAL_SD_MODULE_ENABLED
-  #include "stm32l4xx_hal_sd.h"
-#endif /* HAL_SD_MODULE_ENABLED */
-
-#ifdef HAL_SMBUS_MODULE_ENABLED
-  #include "stm32l4xx_hal_smbus.h"
-#endif /* HAL_SMBUS_MODULE_ENABLED */
-
-#ifdef HAL_SPI_MODULE_ENABLED
-  #include "stm32l4xx_hal_spi.h"
-#endif /* HAL_SPI_MODULE_ENABLED */
-
-#ifdef HAL_SWPMI_MODULE_ENABLED
-  #include "stm32l4xx_hal_swpmi.h"
-#endif /* HAL_SWPMI_MODULE_ENABLED */
-
-#ifdef HAL_TIM_MODULE_ENABLED
-  #include "stm32l4xx_hal_tim.h"
-#endif /* HAL_TIM_MODULE_ENABLED */
-
-#ifdef HAL_TSC_MODULE_ENABLED
-  #include "stm32l4xx_hal_tsc.h"
-#endif /* HAL_TSC_MODULE_ENABLED */
-
-#ifdef HAL_UART_MODULE_ENABLED
-  #include "stm32l4xx_hal_uart.h"
-#endif /* HAL_UART_MODULE_ENABLED */
-
-#ifdef HAL_USART_MODULE_ENABLED
-  #include "stm32l4xx_hal_usart.h"
-#endif /* HAL_USART_MODULE_ENABLED */
-
-#ifdef HAL_IRDA_MODULE_ENABLED
-  #include "stm32l4xx_hal_irda.h"
-#endif /* HAL_IRDA_MODULE_ENABLED */
-
-#ifdef HAL_SMARTCARD_MODULE_ENABLED
-  #include "stm32l4xx_hal_smartcard.h"
-#endif /* HAL_SMARTCARD_MODULE_ENABLED */
-
-#ifdef HAL_WWDG_MODULE_ENABLED
-  #include "stm32l4xx_hal_wwdg.h"
-#endif /* HAL_WWDG_MODULE_ENABLED */
-
-#ifdef HAL_PCD_MODULE_ENABLED
-  #include "stm32l4xx_hal_pcd.h"
-#endif /* HAL_PCD_MODULE_ENABLED */
-
-#ifdef HAL_HCD_MODULE_ENABLED
-  #include "stm32l4xx_hal_hcd.h"
-#endif /* HAL_HCD_MODULE_ENABLED */
-
-#ifdef HAL_GFXMMU_MODULE_ENABLED
-  #include "stm32l4xx_hal_gfxmmu.h"
-#endif /* HAL_GFXMMU_MODULE_ENABLED */
-
-/* Exported macro ------------------------------------------------------------*/
-#ifdef  USE_FULL_ASSERT
-/**
-  * @brief  The assert_param macro is used for function's parameters check.
-  * @param  expr: If expr is false, it calls assert_failed function
-  *         which reports the name of the source file and the source
-  *         line number of the call that failed.
-  *         If expr is true, it returns no value.
-  * @retval None
-  */
-  #define assert_param(expr) ((expr) ? (void)0U : assert_failed((uint8_t *)__FILE__, __LINE__))
-/* Exported functions ------------------------------------------------------- */
-  void assert_failed(uint8_t* file, uint32_t line);
-#else
-  #define assert_param(expr) ((void)0U)
-#endif /* USE_FULL_ASSERT */
+#include "boards/stm32l4xx_hal_conf_base.h"
 
-#ifdef __cplusplus
-}
-#endif
+// Oscillator values in Hz
+#define HSE_VALUE (8000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_SAI1_CLOCK_VALUE (48000)
+#define EXTERNAL_SAI2_CLOCK_VALUE (48000)
 
-#endif /* __STM32L4xx_HAL_CONF_H */
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
 
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif // MICROPY_INCLUDED_STM32L4XX_HAL_CONF_H
diff --git a/ports/stm32/boards/USBDONGLE_WB55/mpconfigboard.h b/ports/stm32/boards/USBDONGLE_WB55/mpconfigboard.h
new file mode 100644
index 0000000000000..0ff751d613a54
--- /dev/null
+++ b/ports/stm32/boards/USBDONGLE_WB55/mpconfigboard.h
@@ -0,0 +1,47 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * MIT License; Copyright (c) 2019 Damien P. George
+ */
+
+#define MICROPY_HW_BOARD_NAME       "USBDongle-WB55"
+#define MICROPY_HW_MCU_NAME         "STM32WB55CGU6"
+
+#define MICROPY_PY_PYB_LEGACY       (0)
+
+#define MICROPY_HW_HAS_FLASH        (1)
+#define MICROPY_HW_ENABLE_RTC       (1)
+#define MICROPY_HW_ENABLE_RNG       (1)
+#define MICROPY_HW_ENABLE_ADC       (0)
+#define MICROPY_HW_ENABLE_USB       (1)
+#define MICROPY_HW_HAS_SWITCH       (1)
+
+// There is an external 32kHz oscillator
+#define RTC_ASYNCH_PREDIV           (0)
+#define RTC_SYNCH_PREDIV            (0x7fff)
+#define MICROPY_HW_RTC_USE_LSE      (1)
+#define MICROPY_HW_RTC_USE_US       (1)
+
+// I2C buses
+#define MICROPY_HW_I2C1_SCL         (pin_B8)
+#define MICROPY_HW_I2C1_SDA         (pin_B9)
+
+// User switch; pressing the button makes the input go low
+#define MICROPY_HW_USRSW_PIN        (pin_A10)
+#define MICROPY_HW_USRSW_PULL       (GPIO_PULLUP)
+#define MICROPY_HW_USRSW_EXTI_MODE  (GPIO_MODE_IT_FALLING)
+#define MICROPY_HW_USRSW_PRESSED    (0)
+
+// LEDs
+#define MICROPY_HW_LED1             (pin_B1) // red
+#define MICROPY_HW_LED2             (pin_B0) // green
+#define MICROPY_HW_LED3             (pin_A4) // blue
+#define MICROPY_HW_LED_ON(pin)      (mp_hal_pin_high(pin))
+#define MICROPY_HW_LED_OFF(pin)     (mp_hal_pin_low(pin))
+
+// USB config
+#define MICROPY_HW_USB_FS           (1)
+#define USBD_CDC_RX_DATA_SIZE       (512)
+#define USBD_CDC_TX_DATA_SIZE       (512)
+
+// Bluetooth config
+#define MICROPY_HW_BLE_UART_ID       (0)
+#define MICROPY_HW_BLE_UART_BAUDRATE (115200)
diff --git a/ports/stm32/boards/USBDONGLE_WB55/mpconfigboard.mk b/ports/stm32/boards/USBDONGLE_WB55/mpconfigboard.mk
new file mode 100644
index 0000000000000..416364df9ef6d
--- /dev/null
+++ b/ports/stm32/boards/USBDONGLE_WB55/mpconfigboard.mk
@@ -0,0 +1,10 @@
+MCU_SERIES = wb
+CMSIS_MCU = STM32WB55xx
+AF_FILE = boards/stm32wb55_af.csv
+LD_FILES = boards/stm32wb55xg.ld boards/common_basic.ld
+STARTUP_FILE = lib/stm32lib/CMSIS/STM32WBxx/Source/Templates/gcc/startup_stm32wb55xx_cm4.o
+
+# MicroPython settings
+MICROPY_PY_BLUETOOTH = 1
+MICROPY_BLUETOOTH_NIMBLE = 1
+MICROPY_VFS_LFS2 = 1
diff --git a/ports/stm32/boards/USBDONGLE_WB55/pins.csv b/ports/stm32/boards/USBDONGLE_WB55/pins.csv
new file mode 100644
index 0000000000000..2b115c5c40fe6
--- /dev/null
+++ b/ports/stm32/boards/USBDONGLE_WB55/pins.csv
@@ -0,0 +1,32 @@
+,PA0
+,PA1
+,PA2
+,PA3
+,PA4
+,PA5
+,PA6
+,PA7
+,PA8
+,PA9
+,PA10
+,PA11
+,PA12
+,PA13
+,PA14
+,PA15
+,PB0
+,PB1
+,PB2
+,PB3
+,PB4
+,PB5
+,PB6
+,PB7
+,PB8
+,PB9
+SW,PA10
+LED_GREEN,PB0
+LED_RED,PB1
+LED_BLUE,PA4
+USB_DM,PA11
+USB_DP,PA12
diff --git a/ports/stm32/boards/USBDONGLE_WB55/stm32wbxx_hal_conf.h b/ports/stm32/boards/USBDONGLE_WB55/stm32wbxx_hal_conf.h
new file mode 100644
index 0000000000000..176857220eb8d
--- /dev/null
+++ b/ports/stm32/boards/USBDONGLE_WB55/stm32wbxx_hal_conf.h
@@ -0,0 +1,19 @@
+/* This file is part of the MicroPython project, http://micropython.org/
+ * The MIT License (MIT)
+ * Copyright (c) 2019 Damien P. George
+ */
+#ifndef MICROPY_INCLUDED_STM32WBXX_HAL_CONF_H
+#define MICROPY_INCLUDED_STM32WBXX_HAL_CONF_H
+
+// Oscillator values in Hz
+#define HSE_VALUE (32000000)
+#define LSE_VALUE (32768)
+#define EXTERNAL_SAI1_CLOCK_VALUE (48000)
+
+// Oscillator timeouts in ms
+#define HSE_STARTUP_TIMEOUT (100)
+#define LSE_STARTUP_TIMEOUT (5000)
+
+#include "boards/stm32wbxx_hal_conf_base.h"
+
+#endif // MICROPY_INCLUDED_STM32WBXX_HAL_CONF_H
diff --git a/ports/stm32/boards/make-pins.py b/ports/stm32/boards/make-pins.py
index ed112e05f0f32..692387f404ea5 100755
--- a/ports/stm32/boards/make-pins.py
+++ b/ports/stm32/boards/make-pins.py
@@ -9,52 +9,54 @@
 
 # Must have matching entries in AF_FN_* enum in ../pin_defs_stm32.h
 SUPPORTED_FN = {
-    'TIM'   : ['CH1',  'CH2',  'CH3',  'CH4',
-               'CH1N', 'CH2N', 'CH3N', 'CH1_ETR', 'ETR', 'BKIN'],
-    'I2C'   : ['SDA', 'SCL'],
-    'I2S'   : ['CK', 'MCK', 'SD', 'WS', 'EXTSD'],
-    'USART' : ['RX', 'TX', 'CTS', 'RTS', 'CK'],
-    'UART'  : ['RX', 'TX', 'CTS', 'RTS'],
-    'SPI'   : ['NSS', 'SCK', 'MISO', 'MOSI'],
-    'SDMMC' : ['CK', 'CMD', 'D0', 'D1', 'D2', 'D3'],
-    'CAN'   : ['TX', 'RX'],
+    "TIM": ["CH1", "CH2", "CH3", "CH4", "CH1N", "CH2N", "CH3N", "CH1_ETR", "ETR", "BKIN"],
+    "I2C": ["SDA", "SCL"],
+    "I2S": ["CK", "MCK", "SD", "WS", "EXTSD"],
+    "USART": ["RX", "TX", "CTS", "RTS", "CK"],
+    "UART": ["RX", "TX", "CTS", "RTS"],
+    "SPI": ["NSS", "SCK", "MISO", "MOSI"],
+    "SDMMC": ["CK", "CMD", "D0", "D1", "D2", "D3"],
+    "CAN": ["TX", "RX"],
 }
 
 CONDITIONAL_VAR = {
-    'I2C'   : 'MICROPY_HW_I2C{num}_SCL',
-    'I2S'   : 'MICROPY_HW_ENABLE_I2S{num}',
-    'SPI'   : 'MICROPY_HW_SPI{num}_SCK',
-    'UART'  : 'MICROPY_HW_UART{num}_TX',
-    'USART' : 'MICROPY_HW_UART{num}_TX',
-    'SDMMC' : 'MICROPY_HW_SDMMC{num}_CK',
-    'CAN'   : 'MICROPY_HW_CAN{num}_TX',
+    "I2C": "MICROPY_HW_I2C{num}_SCL",
+    "I2S": "MICROPY_HW_ENABLE_I2S{num}",
+    "SPI": "MICROPY_HW_SPI{num}_SCK",
+    "UART": "MICROPY_HW_UART{num}_TX",
+    "USART": "MICROPY_HW_UART{num}_TX",
+    "SDMMC": "MICROPY_HW_SDMMC{num}_CK",
+    "CAN": "MICROPY_HW_CAN{num}_TX",
 }
 
+
 def parse_port_pin(name_str):
     """Parses a string and returns a (port-num, pin-num) tuple."""
     if len(name_str) < 3:
         raise ValueError("Expecting pin name to be at least 3 charcters.")
-    if name_str[0] != 'P':
+    if name_str[0] != "P":
         raise ValueError("Expecting pin name to start with P")
-    if name_str[1] < 'A' or name_str[1] > 'K':
+    if name_str[1] < "A" or name_str[1] > "K":
         raise ValueError("Expecting pin port to be between A and K")
-    port = ord(name_str[1]) - ord('A')
+    port = ord(name_str[1]) - ord("A")
     pin_str = name_str[2:]
     if not pin_str.isdigit():
         raise ValueError("Expecting numeric pin number.")
     return (port, int(pin_str))
 
+
 def split_name_num(name_num):
     num = None
     for num_idx in range(len(name_num) - 1, -1, -1):
         if not name_num[num_idx].isdigit():
-            name = name_num[0:num_idx + 1]
-            num_str = name_num[num_idx + 1:]
+            name = name_num[0 : num_idx + 1]
+            num_str = name_num[num_idx + 1 :]
             if len(num_str) > 0:
                 num = int(num_str)
             break
     return name, num
 
+
 def conditional_var(name_num):
     # Try the specific instance first. For example, if name_num is UART4_RX
     # then try UART4 first, and then try UART second.
@@ -66,19 +68,21 @@ def conditional_var(name_num):
         var.append(CONDITIONAL_VAR[name_num])
     return var
 
+
 def print_conditional_if(cond_var, file=None):
     if cond_var:
         cond_str = []
         for var in cond_var:
-            if var.find('ENABLE') >= 0:
-                cond_str.append('(defined({0}) && {0})'.format(var))
+            if var.find("ENABLE") >= 0:
+                cond_str.append("(defined({0}) && {0})".format(var))
             else:
-                cond_str.append('defined({0})'.format(var))
-        print('#if ' + ' || '.join(cond_str), file=file)
+                cond_str.append("defined({0})".format(var))
+        print("#if " + " || ".join(cond_str), file=file)
+
 
 def print_conditional_endif(cond_var, file=None):
     if cond_var:
-        print('#endif', file=file)
+        print("#endif", file=file)
 
 
 class AlternateFunction(object):
@@ -88,16 +92,16 @@ def __init__(self, idx, af_str):
         self.idx = idx
         # Special case. We change I2S2ext_SD into I2S2_EXTSD so that it parses
         # the same way the other peripherals do.
-        af_str = af_str.replace('ext_', '_EXT')
+        af_str = af_str.replace("ext_", "_EXT")
 
         self.af_str = af_str
 
-        self.func = ''
+        self.func = ""
         self.fn_num = None
-        self.pin_type = ''
+        self.pin_type = ""
         self.supported = False
 
-        af_words = af_str.split('_', 1)
+        af_words = af_str.split("_", 1)
         self.func, self.fn_num = split_name_num(af_words[0])
         if len(af_words) > 1:
             self.pin_type = af_words[1]
@@ -113,25 +117,28 @@ def ptr(self):
         """Returns the numbered function (i.e. USART6) for this AF."""
         if self.fn_num is None:
             return self.func
-        return '{:s}{:d}'.format(self.func, self.fn_num)
+        return "{:s}{:d}".format(self.func, self.fn_num)
 
     def mux_name(self):
-        return 'AF{:d}_{:s}'.format(self.idx, self.ptr())
+        return "AF{:d}_{:s}".format(self.idx, self.ptr())
 
     def print(self):
         """Prints the C representation of this AF."""
         cond_var = None
         if self.supported:
-            cond_var = conditional_var('{}{}'.format(self.func, self.fn_num))
+            cond_var = conditional_var("{}{}".format(self.func, self.fn_num))
             print_conditional_if(cond_var)
-            print('  AF',  end='')
+            print("  AF", end="")
         else:
-            print('  //', end='')
+            print("  //", end="")
         fn_num = self.fn_num
         if fn_num is None:
             fn_num = 0
-        print('({:2d}, {:8s}, {:2d}, {:10s}, {:8s}), // {:s}'.format(self.idx,
-              self.func, fn_num, self.pin_type, self.ptr(), self.af_str))
+        print(
+            "({:2d}, {:8s}, {:2d}, {:10s}, {:8s}), // {:s}".format(
+                self.idx, self.func, fn_num, self.pin_type, self.ptr(), self.af_str
+            )
+        )
         print_conditional_endif(cond_var)
 
     def qstr_list(self):
@@ -151,10 +158,10 @@ def __init__(self, port, pin):
         self.board_pin = False
 
     def port_letter(self):
-        return chr(self.port + ord('A'))
+        return chr(self.port + ord("A"))
 
     def cpu_pin_name(self):
-        return '{:s}{:d}'.format(self.port_letter(), self.pin)
+        return "{:s}{:d}".format(self.port_letter(), self.pin)
 
     def is_board_pin(self):
         return self.board_pin
@@ -163,16 +170,16 @@ def set_is_board_pin(self):
         self.board_pin = True
 
     def parse_adc(self, adc_str):
-        if (adc_str[:3] != 'ADC'):
+        if adc_str[:3] != "ADC":
             return
 
-        if adc_str.find('_INP') != -1:
+        if adc_str.find("_INP") != -1:
             # STM32H7xx, entries have the form: ADCxx_IN[PN]yy/...
             # for now just pick the entry with the most ADC periphs
             adc, channel = None, None
-            for ss in adc_str.split('/'):
-                if ss.find('_INP') != -1:
-                    a, c = ss.split('_')
+            for ss in adc_str.split("/"):
+                if ss.find("_INP") != -1:
+                    a, c = ss.split("_")
                     if adc is None or len(a) > len(adc):
                         adc, channel = a, c
             if adc is None:
@@ -180,12 +187,12 @@ def parse_adc(self, adc_str):
             channel = channel[3:]
         else:
             # all other MCUs, entries have the form: ADCxx_INyy
-            adc, channel = adc_str.split('_')
+            adc, channel = adc_str.split("_")
             channel = channel[2:]
 
         for idx in range(3, len(adc)):
-            adc_num = int(adc[idx]) # 1, 2, or 3
-            self.adc_num |= (1 << (adc_num - 1))
+            adc_num = int(adc[idx])  # 1, 2, or 3
+            self.adc_num |= 1 << (adc_num - 1)
         self.adc_channel = int(channel)
 
     def parse_af(self, af_idx, af_strs_in):
@@ -193,7 +200,7 @@ def parse_af(self, af_idx, af_strs_in):
             return
         # If there is a slash, then the slash separates 2 aliases for the
         # same alternate function.
-        af_strs = af_strs_in.split('/')
+        af_strs = af_strs_in.split("/")
         for af_str in af_strs:
             alt_fn = AlternateFunction(af_idx, af_str)
             self.alt_fn.append(alt_fn)
@@ -202,43 +209,49 @@ def parse_af(self, af_idx, af_strs_in):
 
     def alt_fn_name(self, null_if_0=False):
         if null_if_0 and self.alt_fn_count == 0:
-            return 'NULL'
-        return 'pin_{:s}_af'.format(self.cpu_pin_name())
+            return "NULL"
+        return "pin_{:s}_af".format(self.cpu_pin_name())
 
     def adc_num_str(self):
-        str = ''
-        for adc_num in range(1,4):
+        str = ""
+        for adc_num in range(1, 4):
             if self.adc_num & (1 << (adc_num - 1)):
                 if len(str) > 0:
-                    str += ' | '
-                str += 'PIN_ADC'
-                str += chr(ord('0') + adc_num)
+                    str += " | "
+                str += "PIN_ADC"
+                str += chr(ord("0") + adc_num)
         if len(str) == 0:
-            str = '0'
+            str = "0"
         return str
 
     def print(self):
         if self.alt_fn_count == 0:
-            print("// ",  end='')
-        print('const pin_af_obj_t {:s}[] = {{'.format(self.alt_fn_name()))
+            print("// ", end="")
+        print("const pin_af_obj_t {:s}[] = {{".format(self.alt_fn_name()))
         for alt_fn in self.alt_fn:
             alt_fn.print()
         if self.alt_fn_count == 0:
-            print("// ",  end='')
-        print('};')
-        print('')
-        print('const pin_obj_t pin_{:s}_obj = PIN({:s}, {:d}, {:s}, {:s}, {:d});'.format(
-            self.cpu_pin_name(), self.port_letter(), self.pin,
-            self.alt_fn_name(null_if_0=True),
-            self.adc_num_str(), self.adc_channel))
-        print('')
+            print("// ", end="")
+        print("};")
+        print("")
+        print(
+            "const pin_obj_t pin_{:s}_obj = PIN({:s}, {:d}, {:s}, {:s}, {:d});".format(
+                self.cpu_pin_name(),
+                self.port_letter(),
+                self.pin,
+                self.alt_fn_name(null_if_0=True),
+                self.adc_num_str(),
+                self.adc_channel,
+            )
+        )
+        print("")
 
     def print_header(self, hdr_file):
         n = self.cpu_pin_name()
-        hdr_file.write('extern const pin_obj_t pin_{:s}_obj;\n'.format(n))
-        hdr_file.write('#define pin_{:s} (&pin_{:s}_obj)\n'.format(n, n))
+        hdr_file.write("extern const pin_obj_t pin_{:s}_obj;\n".format(n))
+        hdr_file.write("#define pin_{:s} (&pin_{:s}_obj)\n".format(n, n))
         if self.alt_fn_count > 0:
-            hdr_file.write('extern const pin_af_obj_t pin_{:s}_af[];\n'.format(n))
+            hdr_file.write("extern const pin_af_obj_t pin_{:s}_af[];\n".format(n))
 
     def qstr_list(self):
         result = []
@@ -249,11 +262,18 @@ def qstr_list(self):
 
 
 class NamedPin(object):
-
     def __init__(self, name, pin):
-        self._name = name
+        if name.startswith("-"):
+            self._is_hidden = True
+            self._name = name[1:]
+        else:
+            self._is_hidden = False
+            self._name = name
         self._pin = pin
 
+    def is_hidden(self):
+        return self._is_hidden
+
     def pin(self):
         return self._pin
 
@@ -262,10 +282,9 @@ def name(self):
 
 
 class Pins(object):
-
     def __init__(self):
-        self.cpu_pins = []   # list of NamedPin objects
-        self.board_pins = [] # list of NamedPin objects
+        self.cpu_pins = []  # list of NamedPin objects
+        self.board_pins = []  # list of NamedPin objects
 
     def find_pin(self, port_num, pin_num):
         for named_pin in self.cpu_pins:
@@ -274,7 +293,7 @@ def find_pin(self, port_num, pin_num):
                 return pin
 
     def parse_af_file(self, filename, pinname_col, af_col):
-        with open(filename, 'r') as csvfile:
+        with open(filename, "r") as csvfile:
             rows = csv.reader(csvfile)
             for row in rows:
                 try:
@@ -290,7 +309,7 @@ def parse_af_file(self, filename, pinname_col, af_col):
                 self.cpu_pins.append(NamedPin(pin.cpu_pin_name(), pin))
 
     def parse_board_file(self, filename):
-        with open(filename, 'r') as csvfile:
+        with open(filename, "r") as csvfile:
             rows = csv.reader(csvfile)
             for row in rows:
                 try:
@@ -300,63 +319,80 @@ def parse_board_file(self, filename):
                 pin = self.find_pin(port_num, pin_num)
                 if pin:
                     pin.set_is_board_pin()
-                    self.board_pins.append(NamedPin(row[0], pin))
+                    if row[0]:  # Only add board pins that have a name
+                        self.board_pins.append(NamedPin(row[0], pin))
 
     def print_named(self, label, named_pins):
-        print('STATIC const mp_rom_map_elem_t pin_{:s}_pins_locals_dict_table[] = {{'.format(label))
+        print(
+            "STATIC const mp_rom_map_elem_t pin_{:s}_pins_locals_dict_table[] = {{".format(label)
+        )
         for named_pin in named_pins:
             pin = named_pin.pin()
-            if pin.is_board_pin():
-                print('  {{ MP_ROM_QSTR(MP_QSTR_{:s}), MP_ROM_PTR(&pin_{:s}_obj) }},'.format(named_pin.name(),  pin.cpu_pin_name()))
-        print('};')
-        print('MP_DEFINE_CONST_DICT(pin_{:s}_pins_locals_dict, pin_{:s}_pins_locals_dict_table);'.format(label, label))
+            if pin.is_board_pin() and not named_pin.is_hidden():
+                print(
+                    "  {{ MP_ROM_QSTR(MP_QSTR_{:s}), MP_ROM_PTR(&pin_{:s}_obj) }},".format(
+                        named_pin.name(), pin.cpu_pin_name()
+                    )
+                )
+        print("};")
+        print(
+            "MP_DEFINE_CONST_DICT(pin_{:s}_pins_locals_dict, pin_{:s}_pins_locals_dict_table);".format(
+                label, label
+            )
+        )
 
     def print(self):
         for named_pin in self.cpu_pins:
             pin = named_pin.pin()
             if pin.is_board_pin():
                 pin.print()
-        self.print_named('cpu', self.cpu_pins)
-        print('')
-        self.print_named('board', self.board_pins)
+        self.print_named("cpu", self.cpu_pins)
+        print("")
+        self.print_named("board", self.board_pins)
 
     def print_adc(self, adc_num):
-        print('')
-        print('const pin_obj_t * const pin_adc{:d}[] = {{'.format(adc_num))
+        print("")
+        print("const pin_obj_t * const pin_adc{:d}[] = {{".format(adc_num))
         for channel in range(17):
             if channel == 16:
-                print('#if defined(STM32L4)')
+                print("#if defined(STM32L4)")
             adc_found = False
             for named_pin in self.cpu_pins:
                 pin = named_pin.pin()
-                if (pin.is_board_pin() and
-                    (pin.adc_num & (1 << (adc_num - 1))) and (pin.adc_channel == channel)):
-                    print('  &pin_{:s}_obj, // {:d}'.format(pin.cpu_pin_name(), channel))
+                if (
+                    pin.is_board_pin()
+                    and (pin.adc_num & (1 << (adc_num - 1)))
+                    and (pin.adc_channel == channel)
+                ):
+                    print("  &pin_{:s}_obj, // {:d}".format(pin.cpu_pin_name(), channel))
                     adc_found = True
                     break
             if not adc_found:
-                print('  NULL,    // {:d}'.format(channel))
+                print("  NULL,    // {:d}".format(channel))
             if channel == 16:
-                print('#endif')
-        print('};')
-
+                print("#endif")
+        print("};")
 
     def print_header(self, hdr_filename, obj_decls):
-        with open(hdr_filename, 'wt') as hdr_file:
+        with open(hdr_filename, "wt") as hdr_file:
             if obj_decls:
                 for named_pin in self.cpu_pins:
                     pin = named_pin.pin()
                     if pin.is_board_pin():
                         pin.print_header(hdr_file)
-                hdr_file.write('extern const pin_obj_t * const pin_adc1[];\n')
-                hdr_file.write('extern const pin_obj_t * const pin_adc2[];\n')
-                hdr_file.write('extern const pin_obj_t * const pin_adc3[];\n')
+                hdr_file.write("extern const pin_obj_t * const pin_adc1[];\n")
+                hdr_file.write("extern const pin_obj_t * const pin_adc2[];\n")
+                hdr_file.write("extern const pin_obj_t * const pin_adc3[];\n")
             # provide #define's mapping board to cpu name
             for named_pin in self.board_pins:
-                hdr_file.write("#define pyb_pin_{:s} pin_{:s}\n".format(named_pin.name(), named_pin.pin().cpu_pin_name()))
+                hdr_file.write(
+                    "#define pyb_pin_{:s} pin_{:s}\n".format(
+                        named_pin.name(), named_pin.pin().cpu_pin_name()
+                    )
+                )
 
     def print_qstr(self, qstr_filename):
-        with open(qstr_filename, 'wt') as qstr_file:
+        with open(qstr_filename, "wt") as qstr_file:
             qstr_set = set([])
             for named_pin in self.cpu_pins:
                 pin = named_pin.pin()
@@ -364,18 +400,19 @@ def print_qstr(self, qstr_filename):
                     qstr_set |= set(pin.qstr_list())
                     qstr_set |= set([named_pin.name()])
             for named_pin in self.board_pins:
-                qstr_set |= set([named_pin.name()])
+                if not named_pin.is_hidden():
+                    qstr_set |= set([named_pin.name()])
             for qstr in sorted(qstr_set):
                 cond_var = None
-                if qstr.startswith('AF'):
-                    af_words = qstr.split('_')
+                if qstr.startswith("AF"):
+                    af_words = qstr.split("_")
                     cond_var = conditional_var(af_words[1])
                     print_conditional_if(cond_var, file=qstr_file)
-                print('Q({})'.format(qstr), file=qstr_file)
+                print("Q({})".format(qstr), file=qstr_file)
                 print_conditional_endif(cond_var, file=qstr_file)
 
     def print_af_hdr(self, af_const_filename):
-        with open(af_const_filename,  'wt') as af_const_file:
+        with open(af_const_filename, "wt") as af_const_file:
             af_hdr_set = set([])
             mux_name_width = 0
             for named_pin in self.cpu_pins:
@@ -388,36 +425,37 @@ def print_af_hdr(self, af_const_filename):
                             if len(mux_name) > mux_name_width:
                                 mux_name_width = len(mux_name)
             for mux_name in sorted(af_hdr_set):
-                af_words = mux_name.split('_')  # ex mux_name: AF9_I2C2
+                af_words = mux_name.split("_")  # ex mux_name: AF9_I2C2
                 cond_var = conditional_var(af_words[1])
                 print_conditional_if(cond_var, file=af_const_file)
-                key = 'MP_ROM_QSTR(MP_QSTR_{}),'.format(mux_name)
-                val = 'MP_ROM_INT(GPIO_{})'.format(mux_name)
-                print('    { %-*s %s },' % (mux_name_width + 26, key, val),
-                      file=af_const_file)
+                key = "MP_ROM_QSTR(MP_QSTR_{}),".format(mux_name)
+                val = "MP_ROM_INT(GPIO_{})".format(mux_name)
+                print("    { %-*s %s }," % (mux_name_width + 26, key, val), file=af_const_file)
                 print_conditional_endif(cond_var, file=af_const_file)
 
     def print_af_defs(self, af_defs_filename, cmp_strings):
-        with open(af_defs_filename,  'wt') as af_defs_file:
+        with open(af_defs_filename, "wt") as af_defs_file:
 
             STATIC_AF_TOKENS = {}
             for named_pin in self.board_pins:
                 for af in named_pin.pin().alt_fn:
                     func = "%s%d" % (af.func, af.fn_num) if af.fn_num else af.func
-                    pin_type = (af.pin_type or "NULL").split('(')[0]
+                    pin_type = (af.pin_type or "NULL").split("(")[0]
                     tok = "#define STATIC_AF_%s_%s(pin_obj) ( \\" % (func, pin_type)
                     if tok not in STATIC_AF_TOKENS:
                         STATIC_AF_TOKENS[tok] = []
                     if cmp_strings:
                         pin_name = named_pin.pin().cpu_pin_name()
-                        cmp_str = '    ((strcmp( #pin_obj , "(&pin_%s_obj)") ' \
-                            ' & strcmp( #pin_obj , "((&pin_%s_obj))")) == 0) ? (%d) : \\' % (
-                                pin_name, pin_name, af.idx
-                            )
+                        cmp_str = (
+                            '    ((strcmp( #pin_obj , "(&pin_%s_obj)") '
+                            ' & strcmp( #pin_obj , "((&pin_%s_obj))")) == 0) ? (%d) : \\'
+                            % (pin_name, pin_name, af.idx)
+                        )
                     else:
-                        cmp_str = '    ((pin_obj) == (pin_%s)) ? (%d) : \\' % (
-                                named_pin.pin().cpu_pin_name(), af.idx
-                            )
+                        cmp_str = "    ((pin_obj) == (pin_%s)) ? (%d) : \\" % (
+                            named_pin.pin().cpu_pin_name(),
+                            af.idx,
+                        )
                     STATIC_AF_TOKENS[tok].append(cmp_str)
 
             for tok, pins in STATIC_AF_TOKENS.items():
@@ -426,46 +464,49 @@ def print_af_defs(self, af_defs_filename, cmp_strings):
                 print("    (0xffffffffffffffffULL))\n", file=af_defs_file)
 
     def print_af_py(self, af_py_filename):
-        with open(af_py_filename,  'wt') as af_py_file:
-            print('PINS_AF = (', file=af_py_file)
+        with open(af_py_filename, "wt") as af_py_file:
+            print("PINS_AF = (", file=af_py_file)
             for named_pin in self.board_pins:
-                print("  ('%s', " % named_pin.name(), end='', file=af_py_file)
+                if named_pin.is_hidden():
+                    continue
+                print("  ('%s', " % named_pin.name(), end="", file=af_py_file)
                 for af in named_pin.pin().alt_fn:
                     if af.is_supported():
-                        print("(%d, '%s'), " % (af.idx, af.af_str), end='', file=af_py_file)
-                print('),', file=af_py_file)
-            print(')',  file=af_py_file)
+                        print("(%d, '%s'), " % (af.idx, af.af_str), end="", file=af_py_file)
+                print("),", file=af_py_file)
+            print(")", file=af_py_file)
 
 
 def main():
     parser = argparse.ArgumentParser(
         prog="make-pins.py",
         usage="%(prog)s [options] [command]",
-        description="Generate board specific pin file"
+        description="Generate board specific pin file",
     )
     parser.add_argument(
-        "-a", "--af",
+        "-a",
+        "--af",
         dest="af_filename",
         help="Specifies the alternate function file for the chip",
-        default="stm32f4xx_af.csv"
+        default="stm32f4xx_af.csv",
     )
     parser.add_argument(
         "--af-const",
         dest="af_const_filename",
         help="Specifies header file for alternate function constants.",
-        default="build/pins_af_const.h"
+        default="build/pins_af_const.h",
     )
     parser.add_argument(
         "--af-py",
         dest="af_py_filename",
         help="Specifies the filename for the python alternate function mappings.",
-        default="build/pins_af.py"
+        default="build/pins_af.py",
     )
     parser.add_argument(
         "--af-defs",
         dest="af_defs_filename",
         help="Specifies the filename for the alternate function defines.",
-        default="build/pins_af_defs.h"
+        default="build/pins_af_defs.h",
     )
     parser.add_argument(
         "--af-defs-cmp-strings",
@@ -474,52 +515,53 @@ def main():
         action="store_true",
     )
     parser.add_argument(
-        "-b", "--board",
-        dest="board_filename",
-        help="Specifies the board file",
+        "-b", "--board", dest="board_filename", help="Specifies the board file",
     )
     parser.add_argument(
-        "-p", "--prefix",
+        "-p",
+        "--prefix",
         dest="prefix_filename",
         help="Specifies beginning portion of generated pins file",
-        default="stm32f4xx_prefix.c"
+        default="stm32f4xx_prefix.c",
     )
     parser.add_argument(
-        "-q", "--qstr",
+        "-q",
+        "--qstr",
         dest="qstr_filename",
         help="Specifies name of generated qstr header file",
-        default="build/pins_qstr.h"
+        default="build/pins_qstr.h",
     )
     parser.add_argument(
-        "-r", "--hdr",
+        "-r",
+        "--hdr",
         dest="hdr_filename",
         help="Specifies name of generated pin header file",
-        default="build/pins.h"
+        default="build/pins.h",
     )
     parser.add_argument(
         "--hdr-obj-decls",
         dest="hdr_obj_decls",
         help="Whether to include declarations for pin objects in pin header file",
-        action="store_true"
+        action="store_true",
     )
     args = parser.parse_args(sys.argv[1:])
 
     pins = Pins()
 
-    print('// This file was automatically generated by make-pins.py')
-    print('//')
+    print("// This file was automatically generated by make-pins.py")
+    print("//")
     if args.af_filename:
-        print('// --af {:s}'.format(args.af_filename))
+        print("// --af {:s}".format(args.af_filename))
         pins.parse_af_file(args.af_filename, 1, 2)
 
     if args.board_filename:
-        print('// --board {:s}'.format(args.board_filename))
+        print("// --board {:s}".format(args.board_filename))
         pins.parse_board_file(args.board_filename)
 
     if args.prefix_filename:
-        print('// --prefix {:s}'.format(args.prefix_filename))
-        print('')
-        with open(args.prefix_filename, 'r') as prefix_file:
+        print("// --prefix {:s}".format(args.prefix_filename))
+        print("")
+        with open(args.prefix_filename, "r") as prefix_file:
             print(prefix_file.read())
     pins.print()
     pins.print_adc(1)
diff --git a/ports/stm32/boards/manifest.py b/ports/stm32/boards/manifest.py
new file mode 100644
index 0000000000000..81b85834101de
--- /dev/null
+++ b/ports/stm32/boards/manifest.py
@@ -0,0 +1,4 @@
+include("$(MPY_DIR)/extmod/uasyncio/manifest.py")
+freeze("$(MPY_DIR)/drivers/dht", "dht.py")
+freeze("$(MPY_DIR)/drivers/display", ("lcd160cr.py", "lcd160cr_test.py"))
+freeze("$(MPY_DIR)/drivers/onewire", "onewire.py")
diff --git a/ports/stm32/boards/pllvalues.py b/ports/stm32/boards/pllvalues.py
index 4b090c455b47c..59d660364afca 100644
--- a/ports/stm32/boards/pllvalues.py
+++ b/ports/stm32/boards/pllvalues.py
@@ -5,13 +5,50 @@
 """
 
 from __future__ import print_function
+import re
+
+
+class MCU:
+    def __init__(
+        self, range_sysclk, range_m, range_n, range_p, range_q, range_vco_in, range_vco_out
+    ):
+        self.range_sysclk = range_sysclk
+        self.range_m = range_m
+        self.range_n = range_n
+        self.range_p = range_p
+        self.range_q = range_q
+        self.range_vco_in = range_vco_in
+        self.range_vco_out = range_vco_out
+
+
+mcu_default = MCU(
+    range_sysclk=range(2, 216 + 1, 2),
+    range_m=range(2, 63 + 1),
+    range_n=range(192, 432 + 1),
+    range_p=range(2, 8 + 1, 2),
+    range_q=range(2, 15 + 1),
+    range_vco_in=range(1, 2 + 1),
+    range_vco_out=range(192, 432 + 1),
+)
+
+mcu_h7 = MCU(
+    range_sysclk=range(2, 400 + 1, 2),  # above 400MHz currently unsupported
+    range_m=range(1, 63 + 1),
+    range_n=range(4, 512 + 1),
+    range_p=range(2, 128 + 1, 2),
+    range_q=range(1, 128 + 1),
+    range_vco_in=range(1, 16 + 1),
+    range_vco_out=range(150, 960 + 1),  # 150-420=medium, 192-960=wide
+)
+
 
 def close_int(x):
     return abs(x - round(x)) < 0.01
 
+
 # original version that requires N/M to be an integer (for simplicity)
 def compute_pll(hse, sys):
-    for P in (2, 4, 6, 8): # allowed values of P
+    for P in (2, 4, 6, 8):  # allowed values of P
         Q = sys * P / 48
         NbyM = sys * P / hse
         # N/M and Q must be integers
@@ -38,44 +75,44 @@ def compute_pll(hse, sys):
     # no valid values found
     return None
 
+
 # improved version that doesn't require N/M to be an integer
 def compute_pll2(hse, sys, relax_pll48):
     # Loop over the allowed values of P, looking for a valid PLL configuration
-    # that gives the desired "sys" frequency.  We use floats for P to force
-    # floating point arithmetic on Python 2.
+    # that gives the desired "sys" frequency.
     fallback = None
-    for P in (2.0, 4.0, 6.0, 8.0):
-        NbyM = sys * P / hse
+    for P in mcu.range_p:
         # VCO_OUT must be between 192MHz and 432MHz
-        if not (192 <= hse * NbyM <= 432):
+        if not sys * P in mcu.range_vco_out:
             continue
+        NbyM = float(sys * P) / hse  # float for Python 2
         # scan M
-        M = int(192 // NbyM) # starting value
-        while 2 * M < hse:
-            M += 1
-        # VCO_IN must be between 1MHz and 2MHz (2MHz recommended)
-        for M in range(M, hse + 1):
-            if NbyM * M < 191.99 or not close_int(NbyM * M):
-                continue
+        M_min = mcu.range_n[0] // int(round(NbyM))  # starting value
+        while mcu.range_vco_in[-1] * M_min < hse:
+            M_min += 1
+        # VCO_IN must be >=1MHz, but higher is better for stability so start high (low M)
+        for M in range(M_min, hse + 1):
             # compute N
             N = NbyM * M
             # N must be an integer
             if not close_int(N):
                 continue
+            N = round(N)
             # N is restricted
-            if not (192 <= N <= 432):
+            if N not in mcu.range_n:
                 continue
-            Q = (sys * P / 48)
+            Q = float(sys * P) / 48  # float for Python 2
             # Q must be an integer in a set range
-            if not (2 <= Q <= 15):
-                continue
-            if not close_int(Q):
-                if int(M) == int(hse) and fallback is None:
-                    # the values don't give 48MHz on PLL48 but are otherwise OK
-                    fallback = M, N, P, int(Q)
+            if close_int(Q) and round(Q) in mcu.range_q:
+                # found valid values
+                return (M, N, P, Q)
+            # Re-try Q to get at most 48MHz
+            Q = (sys * P + 47) // 48
+            if Q not in mcu.range_q:
                 continue
-            # found valid values
-            return (M, N, P, Q)
+            if fallback is None:
+                # the values don't give 48MHz on PLL48 but are otherwise OK
+                fallback = M, N, P, Q
     if relax_pll48:
         # might have found values which don't give 48MHz on PLL48
         return fallback
@@ -83,7 +120,9 @@ def compute_pll2(hse, sys, relax_pll48):
         # no valid values found which give 48MHz on PLL48
         return None
 
+
 def compute_derived(hse, pll):
+    hse = float(hse)  # float for Python 2
     M, N, P, Q = pll
     vco_in = hse / M
     vco_out = hse * N / M
@@ -91,6 +130,7 @@ def compute_derived(hse, pll):
     pll48ck = hse / M * N / Q
     return (vco_in, vco_out, pllck, pll48ck)
 
+
 def verify_pll(hse, pll):
     M, N, P, Q = pll
     vco_in, vco_out, pllck, pll48ck = compute_derived(hse, pll)
@@ -102,24 +142,63 @@ def verify_pll(hse, pll):
     assert close_int(Q)
 
     # verify range
-    assert 2 <= M <= 63
-    assert 192 <= N <= 432
-    assert P in (2, 4, 6, 8)
-    assert 2 <= Q <= 15
-    assert 1 <= vco_in <= 2
-    assert 192 <= vco_out <= 432
+    assert M in mcu.range_m
+    assert N in mcu.range_n
+    assert P in mcu.range_p
+    assert Q in mcu.range_q
+    assert mcu.range_vco_in[0] <= vco_in <= mcu.range_vco_in[-1]
+    assert mcu.range_vco_out[0] <= vco_out <= mcu.range_vco_out[-1]
+
+
+def compute_pll_table(source_clk, relax_pll48):
+    valid_plls = []
+    for sysclk in mcu.range_sysclk:
+        pll = compute_pll2(source_clk, sysclk, relax_pll48)
+        if pll is not None:
+            verify_pll(source_clk, pll)
+            valid_plls.append((sysclk, pll))
+    return valid_plls
+
 
 def generate_c_table(hse, valid_plls):
-    valid_plls = valid_plls + [(16, (0, 0, 2, 0))]
-    if hse < 16:
-        valid_plls.append((hse, (1, 0, 2, 0)))
     valid_plls.sort()
-    print("// (M, P/2-1, SYS) values for %u MHz HSE" % hse)
-    print("static const uint16_t pll_freq_table[%u] = {" % len(valid_plls))
+    if (
+        mcu.range_sysclk[-1] <= 0xFF
+        and mcu.range_m[-1] <= 0x3F
+        and mcu.range_p[-1] // 2 - 1 <= 0x3
+    ):
+        typedef = "uint16_t"
+        sys_mask = 0xFF
+        m_shift = 10
+        m_mask = 0x3F
+        p_shift = 8
+        p_mask = 0x3
+    else:
+        typedef = "uint32_t"
+        sys_mask = 0xFFFF
+        m_shift = 24
+        m_mask = 0xFF
+        p_shift = 16
+        p_mask = 0xFF
+    print("#define PLL_FREQ_TABLE_SYS(pll) ((pll) & %d)" % (sys_mask,))
+    print("#define PLL_FREQ_TABLE_M(pll) (((pll) >> %d) & %d)" % (m_shift, m_mask))
+    print("#define PLL_FREQ_TABLE_P(pll) (((((pll) >> %d) & %d) + 1) * 2)" % (p_shift, p_mask))
+    print("typedef %s pll_freq_table_t;" % (typedef,))
+    print("// (M, P/2-1, SYS) values for %u MHz source" % hse)
+    print("static const pll_freq_table_t pll_freq_table[%u] = {" % (len(valid_plls),))
     for sys, (M, N, P, Q) in valid_plls:
-        print("    (%u << 10) | (%u << 8) | %u," % (M, P // 2 - 1, sys))
+        print("    (%u << %u) | (%u << %u) | %u," % (M, m_shift, P // 2 - 1, p_shift, sys), end="")
+        if M >= 2:
+            vco_in, vco_out, pllck, pll48ck = compute_derived(hse, (M, N, P, Q))
+            print(
+                " // M=%u N=%u P=%u Q=%u vco_in=%.2f vco_out=%.2f pll48=%.2f"
+                % (M, N, P, Q, vco_in, vco_out, pll48ck),
+                end="",
+            )
+        print()
     print("};")
 
+
 def print_table(hse, valid_plls):
     print("HSE =", hse, "MHz")
     print("sys :  M      N     P     Q : VCO_IN VCO_OUT   PLLCK PLL48CK")
@@ -128,57 +207,96 @@ def print_table(hse, valid_plls):
         print(out_format % ((sys,) + pll + compute_derived(hse, pll)))
     print("found %u valid configurations" % len(valid_plls))
 
+
+def search_header_for_hsx_values(filename, vals):
+    regex_inc = re.compile(r'#include "(boards/[A-Za-z0-9_./]+)"')
+    regex_def = re.compile(r"#define +(HSE_VALUE|HSI_VALUE) +\((\(uint32_t\))?([0-9]+)\)")
+    with open(filename) as f:
+        for line in f:
+            line = line.strip()
+            m = regex_inc.match(line)
+            if m:
+                # Search included file
+                search_header_for_hsx_values(m.group(1), vals)
+                continue
+            m = regex_def.match(line)
+            if m:
+                # Found HSE_VALUE or HSI_VALUE
+                val = int(m.group(3)) // 1000000
+                if m.group(1) == "HSE_VALUE":
+                    vals[0] = val
+                else:
+                    vals[1] = val
+    return vals
+
+
 def main():
+    global mcu
     global out_format
 
     # parse input args
     import sys
+
     argv = sys.argv[1:]
 
     c_table = False
-    relax_pll48 = False
+    mcu_series = "f4"
+    hse = None
+    hsi = None
 
     while True:
-        if argv[0] == '-c':
+        if argv[0] == "-c":
             c_table = True
             argv.pop(0)
-        elif argv[0] == '--relax-pll48':
-            relax_pll48 = True
+        elif argv[0] == "-m":
             argv.pop(0)
+            mcu_series = argv.pop(0).lower()
         else:
             break
 
     if len(argv) != 1:
-        print("usage: pllvalues.py [-c] <hse in MHz>")
+        print("usage: pllvalues.py [-c] [-m <mcu_series>] <hse in MHz>")
         sys.exit(1)
 
     if argv[0].startswith("file:"):
-        # extract HSE_VALUE from header file
-        with open(argv[0][5:]) as f:
-            for line in f:
-                line = line.strip()
-                if line.startswith("#define") and line.find("HSE_VALUE") != -1:
-                    idx_start = line.find("((uint32_t)") + 11
-                    idx_end = line.find(")", idx_start)
-                    hse = int(line[idx_start:idx_end]) // 1000000
-                    break
-            else:
-                raise ValueError("%s does not contain a definition of HSE_VALUE" % argv[0])
+        # extract HSE_VALUE, and optionally HSI_VALUE, from header file
+        hse, hsi = search_header_for_hsx_values(argv[0][5:], [None, None])
+        if hse is None:
+            raise ValueError("%s does not contain a definition of HSE_VALUE" % argv[0])
+        if hsi is not None and hsi > 16:
+            # Currently, a HSI value greater than 16MHz is not supported
+            hsi = None
     else:
         # HSE given directly as an integer
         hse = int(argv[0])
 
-    valid_plls = []
-    for sysclk in range(2, 217, 2):
-        pll = compute_pll2(hse, sysclk, relax_pll48)
-        if pll is not None:
-            verify_pll(hse, pll)
-            valid_plls.append((sysclk, pll))
+    # Select MCU parameters
+    if mcu_series == "h7":
+        mcu = mcu_h7
+    else:
+        mcu = mcu_default
+
+    # Relax constraight on PLLQ being 48MHz on F7 and H7 MCUs, which have separate PLLs for 48MHz
+    relax_pll48 = mcu_series in ("f7", "h7")
+
+    hse_valid_plls = compute_pll_table(hse, relax_pll48)
+    if hsi is not None:
+        hsi_valid_plls = compute_pll_table(hsi, relax_pll48)
 
     if c_table:
-        generate_c_table(hse, valid_plls)
+        print("#if MICROPY_HW_CLK_USE_HSI")
+        if hsi is not None:
+            hsi_valid_plls.append((hsi, (0, 0, 2, 0)))
+            generate_c_table(hsi, hsi_valid_plls)
+        print("#else")
+        if hsi is not None:
+            hse_valid_plls.append((hsi, (0, 0, 2, 0)))
+        hse_valid_plls.append((hse, (1, 0, 2, 0)))
+        generate_c_table(hse, hse_valid_plls)
+        print("#endif")
     else:
-        print_table(hse, valid_plls)
+        print_table(hse, hse_valid_plls)
+
 
 if __name__ == "__main__":
     main()
diff --git a/ports/stm32/boards/startup_stm32f0.s b/ports/stm32/boards/startup_stm32f0.s
deleted file mode 100644
index eb5c4961e017a..0000000000000
--- a/ports/stm32/boards/startup_stm32f0.s
+++ /dev/null
@@ -1,303 +0,0 @@
-/**
-  ******************************************************************************
-  * @file      startup_stm32f091xc.s
-  * @author    MCD Application Team
-  * @brief     STM32F091xC devices vector table for GCC toolchain.
-  *            This module performs:
-  *                - Set the initial SP
-  *                - Set the initial PC == Reset_Handler,
-  *                - Set the vector table entries with the exceptions ISR address
-  *                - Branches to main in the C library (which eventually
-  *                  calls main()).
-  *            After Reset the Cortex-M0 processor is in Thread mode,
-  *            priority is Privileged, and the Stack is set to Main.
-  ******************************************************************************
-  * 
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
-
-  .syntax unified
-  .cpu cortex-m0
-  .fpu softvfp
-  .thumb
-
-.global g_pfnVectors
-.global Default_Handler
-
-/* start address for the initialization values of the .data section.
-defined in linker script */
-.word _sidata
-/* start address for the .data section. defined in linker script */
-.word _sdata
-/* end address for the .data section. defined in linker script */
-.word _edata
-/* start address for the .bss section. defined in linker script */
-.word _sbss
-/* end address for the .bss section. defined in linker script */
-.word _ebss
-
-  .section .text.Reset_Handler
-  .weak Reset_Handler
-  .type Reset_Handler, %function
-Reset_Handler:
-  ldr   r0, =_estack
-  mov   sp, r0          /* set stack pointer */
-
-/* Copy the data segment initializers from flash to SRAM */
-  ldr r0, =_sdata
-  ldr r1, =_edata
-  ldr r2, =_sidata
-  movs r3, #0
-  b LoopCopyDataInit
-
-CopyDataInit:
-  ldr r4, [r2, r3]
-  str r4, [r0, r3]
-  adds r3, r3, #4
-
-LoopCopyDataInit:
-  adds r4, r0, r3
-  cmp r4, r1
-  bcc CopyDataInit
-  
-/* Zero fill the bss segment. */
-  ldr r2, =_sbss
-  ldr r4, =_ebss
-  movs r3, #0
-  b LoopFillZerobss
-
-FillZerobss:
-  str  r3, [r2]
-  adds r2, r2, #4
-
-LoopFillZerobss:
-  cmp r2, r4
-  bcc FillZerobss
-
-/* Call the clock system intitialization function.*/
-  bl  SystemInit
-/* Call static constructors */
-  /*bl __libc_init_array*/
-/* Call the application's entry point.*/
-  bl main
-
-LoopForever:
-    b LoopForever
-
-
-.size Reset_Handler, .-Reset_Handler
-
-/**
- * @brief  This is the code that gets called when the processor receives an
- *         unexpected interrupt.  This simply enters an infinite loop, preserving
- *         the system state for examination by a debugger.
- *
- * @param  None
- * @retval : None
-*/
-    .section .text.Default_Handler,"ax",%progbits
-Default_Handler:
-Infinite_Loop:
-  b Infinite_Loop
-  .size Default_Handler, .-Default_Handler
-/******************************************************************************
-*
-* The minimal vector table for a Cortex M0.  Note that the proper constructs
-* must be placed on this to ensure that it ends up at physical address
-* 0x0000.0000.
-*
-******************************************************************************/
-   .section .isr_vector,"a",%progbits
-  .type g_pfnVectors, %object
-  .size g_pfnVectors, .-g_pfnVectors
-
-
-g_pfnVectors:
-  .word  _estack
-  .word  Reset_Handler
-  .word  NMI_Handler
-  .word  HardFault_Handler
-  .word  0
-  .word  0
-  .word  0
-  .word  0
-  .word  0
-  .word  0
-  .word  0
-  .word  SVC_Handler
-  .word  0
-  .word  0
-  .word  PendSV_Handler
-  .word  SysTick_Handler
-  .word  WWDG_IRQHandler                   /* Window WatchDog              */
-  .word  PVD_VDDIO2_IRQHandler             /* PVD and VDDIO2 through EXTI Line detect */
-  .word  RTC_IRQHandler                    /* RTC through the EXTI line    */
-  .word  FLASH_IRQHandler                  /* FLASH                        */
-  .word  RCC_CRS_IRQHandler                /* RCC and CRS                  */
-  .word  EXTI0_1_IRQHandler                /* EXTI Line 0 and 1            */
-  .word  EXTI2_3_IRQHandler                /* EXTI Line 2 and 3            */
-  .word  EXTI4_15_IRQHandler               /* EXTI Line 4 to 15            */
-  .word  TSC_IRQHandler                    /* TSC                          */
-  .word  DMA1_Ch1_IRQHandler               /* DMA1 Channel 1               */
-  .word  DMA1_Ch2_3_DMA2_Ch1_2_IRQHandler  /* DMA1 Channel 2 and 3 & DMA2 Channel 1 and 2 */
-  .word  DMA1_Ch4_7_DMA2_Ch3_5_IRQHandler  /* DMA1 Channel 4 to 7 & DMA2 Channel 3 to 5 */
-  .word  ADC1_COMP_IRQHandler              /* ADC1, COMP1 and COMP2         */
-  .word  TIM1_BRK_UP_TRG_COM_IRQHandler    /* TIM1 Break, Update, Trigger and Commutation */
-  .word  TIM1_CC_IRQHandler                /* TIM1 Capture Compare         */
-  .word  TIM2_IRQHandler                   /* TIM2                         */
-  .word  TIM3_IRQHandler                   /* TIM3                         */
-  .word  TIM6_DAC_IRQHandler               /* TIM6 and DAC                 */
-  .word  TIM7_IRQHandler                   /* TIM7                         */
-  .word  TIM14_IRQHandler                  /* TIM14                        */
-  .word  TIM15_IRQHandler                  /* TIM15                        */
-  .word  TIM16_IRQHandler                  /* TIM16                        */
-  .word  TIM17_IRQHandler                  /* TIM17                        */
-  .word  I2C1_IRQHandler                   /* I2C1                         */
-  .word  I2C2_IRQHandler                   /* I2C2                         */
-  .word  SPI1_IRQHandler                   /* SPI1                         */
-  .word  SPI2_IRQHandler                   /* SPI2                         */
-  .word  USART1_IRQHandler                 /* USART1                       */
-  .word  USART2_IRQHandler                 /* USART2                       */
-  .word  USART3_8_IRQHandler               /* USART3, USART4, USART5, USART6, USART7, USART8 */
-  .word  CEC_CAN_IRQHandler                /* CEC and CAN                  */
-
-/*******************************************************************************
-*
-* Provide weak aliases for each Exception handler to the Default_Handler.
-* As they are weak aliases, any function with the same name will override
-* this definition.
-*
-*******************************************************************************/
-
-  .weak      NMI_Handler
-  .thumb_set NMI_Handler,Default_Handler
-
-  .weak      HardFault_Handler
-  .thumb_set HardFault_Handler,Default_Handler
-
-  .weak      SVC_Handler
-  .thumb_set SVC_Handler,Default_Handler
-
-  .weak      PendSV_Handler
-  .thumb_set PendSV_Handler,Default_Handler
-
-  .weak      SysTick_Handler
-  .thumb_set SysTick_Handler,Default_Handler
-
-  .weak      WWDG_IRQHandler
-  .thumb_set WWDG_IRQHandler,Default_Handler
-
-  .weak      PVD_VDDIO2_IRQHandler
-  .thumb_set PVD_VDDIO2_IRQHandler,Default_Handler
-
-  .weak      RTC_IRQHandler
-  .thumb_set RTC_IRQHandler,Default_Handler
-
-  .weak      FLASH_IRQHandler
-  .thumb_set FLASH_IRQHandler,Default_Handler
-
-  .weak      RCC_CRS_IRQHandler
-  .thumb_set RCC_CRS_IRQHandler,Default_Handler
-
-  .weak      EXTI0_1_IRQHandler
-  .thumb_set EXTI0_1_IRQHandler,Default_Handler
-
-  .weak      EXTI2_3_IRQHandler
-  .thumb_set EXTI2_3_IRQHandler,Default_Handler
-
-  .weak      EXTI4_15_IRQHandler
-  .thumb_set EXTI4_15_IRQHandler,Default_Handler
-
-  .weak      TSC_IRQHandler
-  .thumb_set TSC_IRQHandler,Default_Handler
-
-  .weak      DMA1_Ch1_IRQHandler
-  .thumb_set DMA1_Ch1_IRQHandler,Default_Handler
-
-  .weak      DMA1_Ch2_3_DMA2_Ch1_2_IRQHandler
-  .thumb_set DMA1_Ch2_3_DMA2_Ch1_2_IRQHandler,Default_Handler
-
-  .weak      DMA1_Ch4_7_DMA2_Ch3_5_IRQHandler
-  .thumb_set DMA1_Ch4_7_DMA2_Ch3_5_IRQHandler,Default_Handler
-
-  .weak      ADC1_COMP_IRQHandler
-  .thumb_set ADC1_COMP_IRQHandler,Default_Handler
-
-  .weak      TIM1_BRK_UP_TRG_COM_IRQHandler
-  .thumb_set TIM1_BRK_UP_TRG_COM_IRQHandler,Default_Handler
-
-  .weak      TIM1_CC_IRQHandler
-  .thumb_set TIM1_CC_IRQHandler,Default_Handler
-
-  .weak      TIM2_IRQHandler
-  .thumb_set TIM2_IRQHandler,Default_Handler
-
-  .weak      TIM3_IRQHandler
-  .thumb_set TIM3_IRQHandler,Default_Handler
-
-  .weak      TIM6_DAC_IRQHandler
-  .thumb_set TIM6_DAC_IRQHandler,Default_Handler
-
-  .weak      TIM7_IRQHandler
-  .thumb_set TIM7_IRQHandler,Default_Handler
-
-  .weak      TIM14_IRQHandler
-  .thumb_set TIM14_IRQHandler,Default_Handler
-
-  .weak      TIM15_IRQHandler
-  .thumb_set TIM15_IRQHandler,Default_Handler
-
-  .weak      TIM16_IRQHandler
-  .thumb_set TIM16_IRQHandler,Default_Handler
-
-  .weak      TIM17_IRQHandler
-  .thumb_set TIM17_IRQHandler,Default_Handler
-
-  .weak      I2C1_IRQHandler
-  .thumb_set I2C1_IRQHandler,Default_Handler
-
-  .weak      I2C2_IRQHandler
-  .thumb_set I2C2_IRQHandler,Default_Handler
-
-  .weak      SPI1_IRQHandler
-  .thumb_set SPI1_IRQHandler,Default_Handler
-
-  .weak      SPI2_IRQHandler
-  .thumb_set SPI2_IRQHandler,Default_Handler
-
-  .weak      USART1_IRQHandler
-  .thumb_set USART1_IRQHandler,Default_Handler
-
-  .weak      USART2_IRQHandler
-  .thumb_set USART2_IRQHandler,Default_Handler
-
-  .weak      USART3_8_IRQHandler
-  .thumb_set USART3_8_IRQHandler,Default_Handler
-
-  .weak      CEC_CAN_IRQHandler
-  .thumb_set CEC_CAN_IRQHandler,Default_Handler
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
-
diff --git a/ports/stm32/boards/startup_stm32f4.s b/ports/stm32/boards/startup_stm32f4.s
deleted file mode 100644
index 3e29a79a5631d..0000000000000
--- a/ports/stm32/boards/startup_stm32f4.s
+++ /dev/null
@@ -1,530 +0,0 @@
-/**
-  ******************************************************************************
-  * @file      startup_stm32.S
-  * @author    MCD Application Team
-  * @version   V2.0.0
-  * @date      18-February-2014
-  * @brief     STM32Fxxxxx Devices vector table for Atollic TrueSTUDIO toolchain.
-  *            This module performs:
-  *                - Set the initial SP
-  *                - Set the initial PC == Reset_Handler,
-  *                - Set the vector table entries with the exceptions ISR address
-  *                - Branches to main in the C library (which eventually
-  *                  calls main()).
-  *            After Reset the Cortex-M4/M7 processor is in Thread mode,
-  *            priority is Privileged, and the Stack is set to Main.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
-
-  .syntax unified
-  .cpu cortex-m4
-  .fpu softvfp
-  .thumb
-
-.global  g_pfnVectors
-.global  Default_Handler
-
-/* start address for the initialization values of the .data section.
-defined in linker script */
-.word  _sidata
-/* start address for the .data section. defined in linker script */
-.word  _sdata
-/* end address for the .data section. defined in linker script */
-.word  _edata
-/* start address for the .bss section. defined in linker script */
-.word  _sbss
-/* end address for the .bss section. defined in linker script */
-.word  _ebss
-/* stack used for SystemInit_ExtMemCtl; always internal RAM used */
-
-/**
- * @brief  This is the code that gets called when the processor first
- *          starts execution following a reset event. Only the absolutely
- *          necessary set is performed, after which the application
- *          supplied main() routine is called.
- * @param  None
- * @retval : None
-*/
-
-    .section  .text.Reset_Handler
-  .weak  Reset_Handler
-  .type  Reset_Handler, %function
-Reset_Handler:
-  ldr   sp, =_estack     /* set stack pointer */
-
-/* Copy the data segment initializers from flash to SRAM */
-  movs  r1, #0
-  b  LoopCopyDataInit
-
-CopyDataInit:
-  ldr  r3, =_sidata
-  ldr  r3, [r3, r1]
-  str  r3, [r0, r1]
-  adds  r1, r1, #4
-
-LoopCopyDataInit:
-  ldr  r0, =_sdata
-  ldr  r3, =_edata
-  adds  r2, r0, r1
-  cmp  r2, r3
-  bcc  CopyDataInit
-  ldr  r2, =_sbss
-  b  LoopFillZerobss
-/* Zero fill the bss segment. */
-FillZerobss:
-  movs  r3, #0
-  str  r3, [r2], #4
-
-LoopFillZerobss:
-  ldr  r3, = _ebss
-  cmp  r2, r3
-  bcc  FillZerobss
-
-/* Call the clock system initialization function.*/
-  bl  SystemInit
-/* Call static constructors */
-    /*bl __libc_init_array*/
-/* Call the application's entry point.*/
-  bl  main
-  bx  lr
-.size  Reset_Handler, .-Reset_Handler
-
-/**
- * @brief  This is the code that gets called when the processor receives an
- *         unexpected interrupt.  This simply enters an infinite loop, preserving
- *         the system state for examination by a debugger.
- * @param  None
- * @retval None
-*/
-    .section  .text.Default_Handler,"ax",%progbits
-Default_Handler:
-Infinite_Loop:
-  b  Infinite_Loop
-  .size  Default_Handler, .-Default_Handler
-/******************************************************************************
-*
-* The minimal vector table for a Cortex M4/M7. Note that the proper constructs
-* must be placed on this to ensure that it ends up at physical address
-* 0x0000.0000.
-*
-*******************************************************************************/
-   .section  .isr_vector,"a",%progbits
-  .type  g_pfnVectors, %object
-  .size  g_pfnVectors, .-g_pfnVectors
-
-
-g_pfnVectors:
-  .word  _estack
-  .word  Reset_Handler
-  .word  NMI_Handler
-  .word  HardFault_Handler
-  .word  MemManage_Handler
-  .word  BusFault_Handler
-  .word  UsageFault_Handler
-  .word  0
-  .word  0
-  .word  0
-  .word  0
-  .word  SVC_Handler
-  .word  DebugMon_Handler
-  .word  0
-  .word  PendSV_Handler
-  .word  SysTick_Handler
-
-  /* External Interrupts */
-  .word     WWDG_IRQHandler                   /* Window WatchDog              */
-  .word     PVD_IRQHandler                    /* PVD through EXTI Line detection */
-  .word     TAMP_STAMP_IRQHandler             /* Tamper and TimeStamps through the EXTI line */
-  .word     RTC_WKUP_IRQHandler               /* RTC Wakeup through the EXTI line */
-  .word     FLASH_IRQHandler                  /* FLASH                        */
-  .word     RCC_IRQHandler                    /* RCC                          */
-  .word     EXTI0_IRQHandler                  /* EXTI Line0                   */
-  .word     EXTI1_IRQHandler                  /* EXTI Line1                   */
-  .word     EXTI2_IRQHandler                  /* EXTI Line2                   */
-  .word     EXTI3_IRQHandler                  /* EXTI Line3                   */
-  .word     EXTI4_IRQHandler                  /* EXTI Line4                   */
-  .word     DMA1_Stream0_IRQHandler           /* DMA1 Stream 0                */
-  .word     DMA1_Stream1_IRQHandler           /* DMA1 Stream 1                */
-  .word     DMA1_Stream2_IRQHandler           /* DMA1 Stream 2                */
-  .word     DMA1_Stream3_IRQHandler           /* DMA1 Stream 3                */
-  .word     DMA1_Stream4_IRQHandler           /* DMA1 Stream 4                */
-  .word     DMA1_Stream5_IRQHandler           /* DMA1 Stream 5                */
-  .word     DMA1_Stream6_IRQHandler           /* DMA1 Stream 6                */
-  .word     ADC_IRQHandler                    /* ADC1, ADC2 and ADC3s         */
-  .word     CAN1_TX_IRQHandler                /* CAN1 TX                      */
-  .word     CAN1_RX0_IRQHandler               /* CAN1 RX0                     */
-  .word     CAN1_RX1_IRQHandler               /* CAN1 RX1                     */
-  .word     CAN1_SCE_IRQHandler               /* CAN1 SCE                     */
-  .word     EXTI9_5_IRQHandler                /* External Line[9:5]s          */
-  .word     TIM1_BRK_TIM9_IRQHandler          /* TIM1 Break and TIM9          */
-  .word     TIM1_UP_TIM10_IRQHandler          /* TIM1 Update and TIM10        */
-  .word     TIM1_TRG_COM_TIM11_IRQHandler     /* TIM1 Trigger and Commutation and TIM11 */
-  .word     TIM1_CC_IRQHandler                /* TIM1 Capture Compare         */
-  .word     TIM2_IRQHandler                   /* TIM2                         */
-  .word     TIM3_IRQHandler                   /* TIM3                         */
-  .word     TIM4_IRQHandler                   /* TIM4                         */
-  .word     I2C1_EV_IRQHandler                /* I2C1 Event                   */
-  .word     I2C1_ER_IRQHandler                /* I2C1 Error                   */
-  .word     I2C2_EV_IRQHandler                /* I2C2 Event                   */
-  .word     I2C2_ER_IRQHandler                /* I2C2 Error                   */
-  .word     SPI1_IRQHandler                   /* SPI1                         */
-  .word     SPI2_IRQHandler                   /* SPI2                         */
-  .word     USART1_IRQHandler                 /* USART1                       */
-  .word     USART2_IRQHandler                 /* USART2                       */
-  .word     USART3_IRQHandler                 /* USART3                       */
-  .word     EXTI15_10_IRQHandler              /* External Line[15:10]s        */
-  .word     RTC_Alarm_IRQHandler              /* RTC Alarm (A and B) through EXTI Line */
-  .word     OTG_FS_WKUP_IRQHandler            /* USB OTG FS Wakeup through EXTI line */
-  .word     TIM8_BRK_TIM12_IRQHandler         /* TIM8 Break and TIM12         */
-  .word     TIM8_UP_TIM13_IRQHandler          /* TIM8 Update and TIM13        */
-  .word     TIM8_TRG_COM_TIM14_IRQHandler     /* TIM8 Trigger and Commutation and TIM14 */
-  .word     TIM8_CC_IRQHandler                /* TIM8 Capture Compare         */
-  .word     DMA1_Stream7_IRQHandler           /* DMA1 Stream7                 */
-  .word     FSMC_IRQHandler                   /* FSMC                         */
-  .word     SDIO_IRQHandler                   /* SDIO                         */
-  .word     TIM5_IRQHandler                   /* TIM5                         */
-  .word     SPI3_IRQHandler                   /* SPI3                         */
-  .word     UART4_IRQHandler                  /* UART4                        */
-  .word     UART5_IRQHandler                  /* UART5                        */
-  .word     TIM6_DAC_IRQHandler               /* TIM6 and DAC1&2 underrun errors */
-  .word     TIM7_IRQHandler                   /* TIM7                         */
-  .word     DMA2_Stream0_IRQHandler           /* DMA2 Stream 0                */
-  .word     DMA2_Stream1_IRQHandler           /* DMA2 Stream 1                */
-  .word     DMA2_Stream2_IRQHandler           /* DMA2 Stream 2                */
-  .word     DMA2_Stream3_IRQHandler           /* DMA2 Stream 3                */
-  .word     DMA2_Stream4_IRQHandler           /* DMA2 Stream 4                */
-  .word     ETH_IRQHandler                    /* Ethernet                     */
-  .word     ETH_WKUP_IRQHandler               /* Ethernet Wakeup through EXTI line */
-  .word     CAN2_TX_IRQHandler                /* CAN2 TX                      */
-  .word     CAN2_RX0_IRQHandler               /* CAN2 RX0                     */
-  .word     CAN2_RX1_IRQHandler               /* CAN2 RX1                     */
-  .word     CAN2_SCE_IRQHandler               /* CAN2 SCE                     */
-  .word     OTG_FS_IRQHandler                 /* USB OTG FS                   */
-  .word     DMA2_Stream5_IRQHandler           /* DMA2 Stream 5                */
-  .word     DMA2_Stream6_IRQHandler           /* DMA2 Stream 6                */
-  .word     DMA2_Stream7_IRQHandler           /* DMA2 Stream 7                */
-  .word     USART6_IRQHandler                 /* USART6                       */
-  .word     I2C3_EV_IRQHandler                /* I2C3 event                   */
-  .word     I2C3_ER_IRQHandler                /* I2C3 error                   */
-  .word     OTG_HS_EP1_OUT_IRQHandler         /* USB OTG HS End Point 1 Out   */
-  .word     OTG_HS_EP1_IN_IRQHandler          /* USB OTG HS End Point 1 In    */
-  .word     OTG_HS_WKUP_IRQHandler            /* USB OTG HS Wakeup through EXTI */
-  .word     OTG_HS_IRQHandler                 /* USB OTG HS                   */
-  .word     DCMI_IRQHandler                   /* DCMI                         */
-  .word     0                                 /* CRYP crypto                  */
-  .word     HASH_RNG_IRQHandler               /* Hash and Rng                 */
-  .word     FPU_IRQHandler                    /* FPU                          */
-  .word     UART7_IRQHandler                  /* UART7                        */
-  .word     UART8_IRQHandler                  /* UART8                        */
-
-/*******************************************************************************
-*
-* Provide weak aliases for each Exception handler to the Default_Handler.
-* As they are weak aliases, any function with the same name will override
-* this definition.
-*
-*******************************************************************************/
-   .weak      NMI_Handler
-   .thumb_set NMI_Handler,Default_Handler
-
-   .weak      HardFault_Handler
-   .thumb_set HardFault_Handler,Default_Handler
-
-   .weak      MemManage_Handler
-   .thumb_set MemManage_Handler,Default_Handler
-
-   .weak      BusFault_Handler
-   .thumb_set BusFault_Handler,Default_Handler
-
-   .weak      UsageFault_Handler
-   .thumb_set UsageFault_Handler,Default_Handler
-
-   .weak      SVC_Handler
-   .thumb_set SVC_Handler,Default_Handler
-
-   .weak      DebugMon_Handler
-   .thumb_set DebugMon_Handler,Default_Handler
-
-   .weak      PendSV_Handler
-   .thumb_set PendSV_Handler,Default_Handler
-
-   .weak      SysTick_Handler
-   .thumb_set SysTick_Handler,Default_Handler
-
-   .weak      WWDG_IRQHandler
-   .thumb_set WWDG_IRQHandler,Default_Handler
-
-   .weak      PVD_IRQHandler
-   .thumb_set PVD_IRQHandler,Default_Handler
-
-   .weak      TAMP_STAMP_IRQHandler
-   .thumb_set TAMP_STAMP_IRQHandler,Default_Handler
-
-   .weak      RTC_WKUP_IRQHandler
-   .thumb_set RTC_WKUP_IRQHandler,Default_Handler
-
-   .weak      FLASH_IRQHandler
-   .thumb_set FLASH_IRQHandler,Default_Handler
-
-   .weak      RCC_IRQHandler
-   .thumb_set RCC_IRQHandler,Default_Handler
-
-   .weak      EXTI0_IRQHandler
-   .thumb_set EXTI0_IRQHandler,Default_Handler
-
-   .weak      EXTI1_IRQHandler
-   .thumb_set EXTI1_IRQHandler,Default_Handler
-
-   .weak      EXTI2_IRQHandler
-   .thumb_set EXTI2_IRQHandler,Default_Handler
-
-   .weak      EXTI3_IRQHandler
-   .thumb_set EXTI3_IRQHandler,Default_Handler
-
-   .weak      EXTI4_IRQHandler
-   .thumb_set EXTI4_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream0_IRQHandler
-   .thumb_set DMA1_Stream0_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream1_IRQHandler
-   .thumb_set DMA1_Stream1_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream2_IRQHandler
-   .thumb_set DMA1_Stream2_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream3_IRQHandler
-   .thumb_set DMA1_Stream3_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream4_IRQHandler
-   .thumb_set DMA1_Stream4_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream5_IRQHandler
-   .thumb_set DMA1_Stream5_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream6_IRQHandler
-   .thumb_set DMA1_Stream6_IRQHandler,Default_Handler
-
-   .weak      ADC_IRQHandler
-   .thumb_set ADC_IRQHandler,Default_Handler
-
-   .weak      CAN1_TX_IRQHandler
-   .thumb_set CAN1_TX_IRQHandler,Default_Handler
-
-   .weak      CAN1_RX0_IRQHandler
-   .thumb_set CAN1_RX0_IRQHandler,Default_Handler
-
-   .weak      CAN1_RX1_IRQHandler
-   .thumb_set CAN1_RX1_IRQHandler,Default_Handler
-
-   .weak      CAN1_SCE_IRQHandler
-   .thumb_set CAN1_SCE_IRQHandler,Default_Handler
-
-   .weak      EXTI9_5_IRQHandler
-   .thumb_set EXTI9_5_IRQHandler,Default_Handler
-
-   .weak      TIM1_BRK_TIM9_IRQHandler
-   .thumb_set TIM1_BRK_TIM9_IRQHandler,Default_Handler
-
-   .weak      TIM1_UP_TIM10_IRQHandler
-   .thumb_set TIM1_UP_TIM10_IRQHandler,Default_Handler
-
-   .weak      TIM1_TRG_COM_TIM11_IRQHandler
-   .thumb_set TIM1_TRG_COM_TIM11_IRQHandler,Default_Handler
-
-   .weak      TIM1_CC_IRQHandler
-   .thumb_set TIM1_CC_IRQHandler,Default_Handler
-
-   .weak      TIM2_IRQHandler
-   .thumb_set TIM2_IRQHandler,Default_Handler
-
-   .weak      TIM3_IRQHandler
-   .thumb_set TIM3_IRQHandler,Default_Handler
-
-   .weak      TIM4_IRQHandler
-   .thumb_set TIM4_IRQHandler,Default_Handler
-
-   .weak      I2C1_EV_IRQHandler
-   .thumb_set I2C1_EV_IRQHandler,Default_Handler
-
-   .weak      I2C1_ER_IRQHandler
-   .thumb_set I2C1_ER_IRQHandler,Default_Handler
-
-   .weak      I2C2_EV_IRQHandler
-   .thumb_set I2C2_EV_IRQHandler,Default_Handler
-
-   .weak      I2C2_ER_IRQHandler
-   .thumb_set I2C2_ER_IRQHandler,Default_Handler
-
-   .weak      SPI1_IRQHandler
-   .thumb_set SPI1_IRQHandler,Default_Handler
-
-   .weak      SPI2_IRQHandler
-   .thumb_set SPI2_IRQHandler,Default_Handler
-
-   .weak      USART1_IRQHandler
-   .thumb_set USART1_IRQHandler,Default_Handler
-
-   .weak      USART2_IRQHandler
-   .thumb_set USART2_IRQHandler,Default_Handler
-
-   .weak      USART3_IRQHandler
-   .thumb_set USART3_IRQHandler,Default_Handler
-
-   .weak      EXTI15_10_IRQHandler
-   .thumb_set EXTI15_10_IRQHandler,Default_Handler
-
-   .weak      RTC_Alarm_IRQHandler
-   .thumb_set RTC_Alarm_IRQHandler,Default_Handler
-
-   .weak      OTG_FS_WKUP_IRQHandler
-   .thumb_set OTG_FS_WKUP_IRQHandler,Default_Handler
-
-   .weak      TIM8_BRK_TIM12_IRQHandler
-   .thumb_set TIM8_BRK_TIM12_IRQHandler,Default_Handler
-
-   .weak      TIM8_UP_TIM13_IRQHandler
-   .thumb_set TIM8_UP_TIM13_IRQHandler,Default_Handler
-
-   .weak      TIM8_TRG_COM_TIM14_IRQHandler
-   .thumb_set TIM8_TRG_COM_TIM14_IRQHandler,Default_Handler
-
-   .weak      TIM8_CC_IRQHandler
-   .thumb_set TIM8_CC_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream7_IRQHandler
-   .thumb_set DMA1_Stream7_IRQHandler,Default_Handler
-
-   .weak      FSMC_IRQHandler
-   .thumb_set FSMC_IRQHandler,Default_Handler
-
-   .weak      SDIO_IRQHandler
-   .thumb_set SDIO_IRQHandler,Default_Handler
-
-   .weak      TIM5_IRQHandler
-   .thumb_set TIM5_IRQHandler,Default_Handler
-
-   .weak      SPI3_IRQHandler
-   .thumb_set SPI3_IRQHandler,Default_Handler
-
-   .weak      UART4_IRQHandler
-   .thumb_set UART4_IRQHandler,Default_Handler
-
-   .weak      UART5_IRQHandler
-   .thumb_set UART5_IRQHandler,Default_Handler
-
-   .weak      TIM6_DAC_IRQHandler
-   .thumb_set TIM6_DAC_IRQHandler,Default_Handler
-
-   .weak      TIM7_IRQHandler
-   .thumb_set TIM7_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream0_IRQHandler
-   .thumb_set DMA2_Stream0_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream1_IRQHandler
-   .thumb_set DMA2_Stream1_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream2_IRQHandler
-   .thumb_set DMA2_Stream2_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream3_IRQHandler
-   .thumb_set DMA2_Stream3_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream4_IRQHandler
-   .thumb_set DMA2_Stream4_IRQHandler,Default_Handler
-
-   .weak      ETH_IRQHandler
-   .thumb_set ETH_IRQHandler,Default_Handler
-
-   .weak      ETH_WKUP_IRQHandler
-   .thumb_set ETH_WKUP_IRQHandler,Default_Handler
-
-   .weak      CAN2_TX_IRQHandler
-   .thumb_set CAN2_TX_IRQHandler,Default_Handler
-
-   .weak      CAN2_RX0_IRQHandler
-   .thumb_set CAN2_RX0_IRQHandler,Default_Handler
-
-   .weak      CAN2_RX1_IRQHandler
-   .thumb_set CAN2_RX1_IRQHandler,Default_Handler
-
-   .weak      CAN2_SCE_IRQHandler
-   .thumb_set CAN2_SCE_IRQHandler,Default_Handler
-
-   .weak      OTG_FS_IRQHandler
-   .thumb_set OTG_FS_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream5_IRQHandler
-   .thumb_set DMA2_Stream5_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream6_IRQHandler
-   .thumb_set DMA2_Stream6_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream7_IRQHandler
-   .thumb_set DMA2_Stream7_IRQHandler,Default_Handler
-
-   .weak      USART6_IRQHandler
-   .thumb_set USART6_IRQHandler,Default_Handler
-
-   .weak      I2C3_EV_IRQHandler
-   .thumb_set I2C3_EV_IRQHandler,Default_Handler
-
-   .weak      I2C3_ER_IRQHandler
-   .thumb_set I2C3_ER_IRQHandler,Default_Handler
-
-   .weak      OTG_HS_EP1_OUT_IRQHandler
-   .thumb_set OTG_HS_EP1_OUT_IRQHandler,Default_Handler
-
-   .weak      OTG_HS_EP1_IN_IRQHandler
-   .thumb_set OTG_HS_EP1_IN_IRQHandler,Default_Handler
-
-   .weak      OTG_HS_WKUP_IRQHandler
-   .thumb_set OTG_HS_WKUP_IRQHandler,Default_Handler
-
-   .weak      OTG_HS_IRQHandler
-   .thumb_set OTG_HS_IRQHandler,Default_Handler
-
-   .weak      DCMI_IRQHandler
-   .thumb_set DCMI_IRQHandler,Default_Handler
-
-   .weak      HASH_RNG_IRQHandler
-   .thumb_set HASH_RNG_IRQHandler,Default_Handler
-
-   .weak      FPU_IRQHandler
-   .thumb_set FPU_IRQHandler,Default_Handler
-
-   .weak      UART7_IRQHandler
-   .thumb_set UART7_IRQHandler,Default_Handler
-
-   .weak      UART8_IRQHandler
-   .thumb_set UART8_IRQHandler,Default_Handler
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
diff --git a/ports/stm32/boards/startup_stm32f7.s b/ports/stm32/boards/startup_stm32f7.s
deleted file mode 100644
index 633ba01e9313d..0000000000000
--- a/ports/stm32/boards/startup_stm32f7.s
+++ /dev/null
@@ -1,604 +0,0 @@
-/**
-  ******************************************************************************
-  * @file      startup_stm32.S
-  * @author    MCD Application Team
-  * @version   V2.0.0
-  * @date      18-February-2014
-  * @brief     STM32Fxxxxx Devices vector table for Atollic TrueSTUDIO toolchain.
-  *            This module performs:
-  *                - Set the initial SP
-  *                - Set the initial PC == Reset_Handler,
-  *                - Set the vector table entries with the exceptions ISR address
-  *                - Branches to main in the C library (which eventually
-  *                  calls main()).
-  *            After Reset the Cortex-M4/M7 processor is in Thread mode,
-  *            priority is Privileged, and the Stack is set to Main.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT 2014 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
-
-  .syntax unified
-  .cpu cortex-m7
-  .fpu softvfp
-  .thumb
-
-.global  g_pfnVectors
-.global  Default_Handler
-
-/* start address for the initialization values of the .data section.
-defined in linker script */
-.word  _sidata
-/* start address for the .data section. defined in linker script */
-.word  _sdata
-/* end address for the .data section. defined in linker script */
-.word  _edata
-/* start address for the .bss section. defined in linker script */
-.word  _sbss
-/* end address for the .bss section. defined in linker script */
-.word  _ebss
-/* stack used for SystemInit_ExtMemCtl; always internal RAM used */
-
-/**
- * @brief  This is the code that gets called when the processor first
- *          starts execution following a reset event. Only the absolutely
- *          necessary set is performed, after which the application
- *          supplied main() routine is called.
- * @param  None
- * @retval : None
-*/
-
-    .section  .text.Reset_Handler
-  .weak  Reset_Handler
-  .type  Reset_Handler, %function
-Reset_Handler:
-  ldr   sp, =_estack     /* set stack pointer */
-
-/* Copy the data segment initializers from flash to SRAM */
-  movs  r1, #0
-  b  LoopCopyDataInit
-
-CopyDataInit:
-  ldr  r3, =_sidata
-  ldr  r3, [r3, r1]
-  str  r3, [r0, r1]
-  adds  r1, r1, #4
-
-LoopCopyDataInit:
-  ldr  r0, =_sdata
-  ldr  r3, =_edata
-  adds  r2, r0, r1
-  cmp  r2, r3
-  bcc  CopyDataInit
-  ldr  r2, =_sbss
-  b  LoopFillZerobss
-/* Zero fill the bss segment. */
-FillZerobss:
-  movs  r3, #0
-  str  r3, [r2], #4
-
-LoopFillZerobss:
-  ldr  r3, = _ebss
-  cmp  r2, r3
-  bcc  FillZerobss
-
-/* Call the clock system initialization function.*/
-  bl  SystemInit
-/* Call static constructors */
-    /*bl __libc_init_array*/
-/* Call the application's entry point.*/
-  bl  main
-  bx  lr
-.size  Reset_Handler, .-Reset_Handler
-
-/**
- * @brief  This is the code that gets called when the processor receives an
- *         unexpected interrupt.  This simply enters an infinite loop, preserving
- *         the system state for examination by a debugger.
- * @param  None
- * @retval None
-*/
-    .section  .text.Default_Handler,"ax",%progbits
-Default_Handler:
-Infinite_Loop:
-  b  Infinite_Loop
-  .size  Default_Handler, .-Default_Handler
-/******************************************************************************
-*
-* The minimal vector table for a Cortex M4/M7. Note that the proper constructs
-* must be placed on this to ensure that it ends up at physical address
-* 0x0000.0000.
-*
-*******************************************************************************/
-   .section  .isr_vector,"a",%progbits
-  .type  g_pfnVectors, %object
-  .size  g_pfnVectors, .-g_pfnVectors
-
-
-g_pfnVectors:
-  .word  _estack
-  .word  Reset_Handler
-  .word  NMI_Handler
-  .word  HardFault_Handler
-  .word  MemManage_Handler
-  .word  BusFault_Handler
-  .word  UsageFault_Handler
-  .word  0
-  .word  0
-  .word  0
-  .word  0
-  .word  SVC_Handler
-  .word  DebugMon_Handler
-  .word  0
-  .word  PendSV_Handler
-  .word  SysTick_Handler
-
-  /* External Interrupts */
-  .word     WWDG_IRQHandler                   /* Window WatchDog              */
-  .word     PVD_IRQHandler                    /* PVD through EXTI Line detection */
-  .word     TAMP_STAMP_IRQHandler             /* Tamper and TimeStamps through the EXTI line */
-  .word     RTC_WKUP_IRQHandler               /* RTC Wakeup through the EXTI line */
-  .word     FLASH_IRQHandler                  /* FLASH                        */
-  .word     RCC_IRQHandler                    /* RCC                          */
-  .word     EXTI0_IRQHandler                  /* EXTI Line0                   */
-  .word     EXTI1_IRQHandler                  /* EXTI Line1                   */
-  .word     EXTI2_IRQHandler                  /* EXTI Line2                   */
-  .word     EXTI3_IRQHandler                  /* EXTI Line3                   */
-  .word     EXTI4_IRQHandler                  /* EXTI Line4                   */
-  .word     DMA1_Stream0_IRQHandler           /* DMA1 Stream 0                */
-  .word     DMA1_Stream1_IRQHandler           /* DMA1 Stream 1                */
-  .word     DMA1_Stream2_IRQHandler           /* DMA1 Stream 2                */
-  .word     DMA1_Stream3_IRQHandler           /* DMA1 Stream 3                */
-  .word     DMA1_Stream4_IRQHandler           /* DMA1 Stream 4                */
-  .word     DMA1_Stream5_IRQHandler           /* DMA1 Stream 5                */
-  .word     DMA1_Stream6_IRQHandler           /* DMA1 Stream 6                */
-  .word     ADC_IRQHandler                    /* ADC1, ADC2 and ADC3s         */
-  .word     CAN1_TX_IRQHandler                /* CAN1 TX                      */
-  .word     CAN1_RX0_IRQHandler               /* CAN1 RX0                     */
-  .word     CAN1_RX1_IRQHandler               /* CAN1 RX1                     */
-  .word     CAN1_SCE_IRQHandler               /* CAN1 SCE                     */
-  .word     EXTI9_5_IRQHandler                /* External Line[9:5]s          */
-  .word     TIM1_BRK_TIM9_IRQHandler          /* TIM1 Break and TIM9          */
-  .word     TIM1_UP_TIM10_IRQHandler          /* TIM1 Update and TIM10        */
-  .word     TIM1_TRG_COM_TIM11_IRQHandler     /* TIM1 Trigger and Commutation and TIM11 */
-  .word     TIM1_CC_IRQHandler                /* TIM1 Capture Compare         */
-  .word     TIM2_IRQHandler                   /* TIM2                         */
-  .word     TIM3_IRQHandler                   /* TIM3                         */
-  .word     TIM4_IRQHandler                   /* TIM4                         */
-  .word     I2C1_EV_IRQHandler                /* I2C1 Event                   */
-  .word     I2C1_ER_IRQHandler                /* I2C1 Error                   */
-  .word     I2C2_EV_IRQHandler                /* I2C2 Event                   */
-  .word     I2C2_ER_IRQHandler                /* I2C2 Error                   */
-  .word     SPI1_IRQHandler                   /* SPI1                         */
-  .word     SPI2_IRQHandler                   /* SPI2                         */
-  .word     USART1_IRQHandler                 /* USART1                       */
-  .word     USART2_IRQHandler                 /* USART2                       */
-  .word     USART3_IRQHandler                 /* USART3                       */
-  .word     EXTI15_10_IRQHandler              /* External Line[15:10]s        */
-  .word     RTC_Alarm_IRQHandler              /* RTC Alarm (A and B) through EXTI Line */
-  .word     OTG_FS_WKUP_IRQHandler            /* USB OTG FS Wakeup through EXTI line */
-  .word     TIM8_BRK_TIM12_IRQHandler         /* TIM8 Break and TIM12         */
-  .word     TIM8_UP_TIM13_IRQHandler          /* TIM8 Update and TIM13        */
-  .word     TIM8_TRG_COM_TIM14_IRQHandler     /* TIM8 Trigger and Commutation and TIM14 */
-  .word     TIM8_CC_IRQHandler                /* TIM8 Capture Compare         */
-  .word     DMA1_Stream7_IRQHandler           /* DMA1 Stream7                 */
-  .word     FMC_IRQHandler                    /* FMC                          */
-  .word     SDMMC1_IRQHandler                 /* SDMMC1                       */
-  .word     TIM5_IRQHandler                   /* TIM5                         */
-  .word     SPI3_IRQHandler                   /* SPI3                         */
-  .word     UART4_IRQHandler                  /* UART4                        */
-  .word     UART5_IRQHandler                  /* UART5                        */
-  .word     TIM6_DAC_IRQHandler               /* TIM6 and DAC1&2 underrun errors */
-  .word     TIM7_IRQHandler                   /* TIM7                         */
-  .word     DMA2_Stream0_IRQHandler           /* DMA2 Stream 0                */
-  .word     DMA2_Stream1_IRQHandler           /* DMA2 Stream 1                */
-  .word     DMA2_Stream2_IRQHandler           /* DMA2 Stream 2                */
-  .word     DMA2_Stream3_IRQHandler           /* DMA2 Stream 3                */
-  .word     DMA2_Stream4_IRQHandler           /* DMA2 Stream 4                */
-  .word     ETH_IRQHandler                    /* Ethernet                     */
-  .word     ETH_WKUP_IRQHandler               /* Ethernet Wakeup through EXTI line */
-  .word     CAN2_TX_IRQHandler                /* CAN2 TX                      */
-  .word     CAN2_RX0_IRQHandler               /* CAN2 RX0                     */
-  .word     CAN2_RX1_IRQHandler               /* CAN2 RX1                     */
-  .word     CAN2_SCE_IRQHandler               /* CAN2 SCE                     */
-  .word     OTG_FS_IRQHandler                 /* USB OTG FS                   */
-  .word     DMA2_Stream5_IRQHandler           /* DMA2 Stream 5                */
-  .word     DMA2_Stream6_IRQHandler           /* DMA2 Stream 6                */
-  .word     DMA2_Stream7_IRQHandler           /* DMA2 Stream 7                */
-  .word     USART6_IRQHandler                 /* USART6                       */
-  .word     I2C3_EV_IRQHandler                /* I2C3 event                   */
-  .word     I2C3_ER_IRQHandler                /* I2C3 error                   */
-  .word     OTG_HS_EP1_OUT_IRQHandler         /* USB OTG HS End Point 1 Out   */
-  .word     OTG_HS_EP1_IN_IRQHandler          /* USB OTG HS End Point 1 In    */
-  .word     OTG_HS_WKUP_IRQHandler            /* USB OTG HS Wakeup through EXTI */
-  .word     OTG_HS_IRQHandler                 /* USB OTG HS                   */
-  .word     DCMI_IRQHandler                   /* DCMI                         */
-  .word     0                                 /* CRYP crypto                  */
-  .word     HASH_RNG_IRQHandler               /* Hash and Rng                 */
-  .word     FPU_IRQHandler                    /* FPU                          */
-  .word     UART7_IRQHandler                  /* UART7                        */
-  .word     UART8_IRQHandler                  /* UART8                        */
-  .word     SPI4_IRQHandler                   /* SPI4                         */
-  .word     SPI5_IRQHandler                   /* SPI5                         */
-  .word     SPI6_IRQHandler                   /* SPI6                         */
-  .word     SAI1_IRQHandler                   /* SAI1                         */
-  .word     0                                 /* Reserved                     */
-  .word     0                                 /* Reserved                     */
-  .word     DMA2D_IRQHandler                  /* DMA2D                        */
-  .word     SAI2_IRQHandler                   /* SAI2                         */
-  .word     QUADSPI_IRQHandler                /* QUADSPI                      */
-  .word     LPTIM1_IRQHandler                 /* LPTIM1                       */
-  .word     CEC_IRQHandler                    /* HDMI_CEC                     */
-  .word     I2C4_EV_IRQHandler                /* I2C4 Event                   */
-  .word     I2C4_ER_IRQHandler                /* I2C4 Error                   */
-  .word     SPDIF_RX_IRQHandler               /* SPDIF_RX                     */
-  .word     DSIHOST_IRQHandler                /* DSI host                     */
-  .word     DFSDM1_FLT0_IRQHandler            /* DFSDM1 filter 0              */
-  .word     DFSDM1_FLT1_IRQHandler            /* DFSDM1 filter 1              */
-  .word     DFSDM1_FLT2_IRQHandler            /* DFSDM1 filter 2              */
-  .word     DFSDM1_FLT3_IRQHandler            /* DFSDM1 filter 3              */
-  .word     SDMMC2_IRQHandler                 /* SDMMC2                       */
-
-/*******************************************************************************
-*
-* Provide weak aliases for each Exception handler to the Default_Handler.
-* As they are weak aliases, any function with the same name will override
-* this definition.
-*
-*******************************************************************************/
-   .weak      NMI_Handler
-   .thumb_set NMI_Handler,Default_Handler
-
-   .weak      HardFault_Handler
-   .thumb_set HardFault_Handler,Default_Handler
-
-   .weak      MemManage_Handler
-   .thumb_set MemManage_Handler,Default_Handler
-
-   .weak      BusFault_Handler
-   .thumb_set BusFault_Handler,Default_Handler
-
-   .weak      UsageFault_Handler
-   .thumb_set UsageFault_Handler,Default_Handler
-
-   .weak      SVC_Handler
-   .thumb_set SVC_Handler,Default_Handler
-
-   .weak      DebugMon_Handler
-   .thumb_set DebugMon_Handler,Default_Handler
-
-   .weak      PendSV_Handler
-   .thumb_set PendSV_Handler,Default_Handler
-
-   .weak      SysTick_Handler
-   .thumb_set SysTick_Handler,Default_Handler
-
-   .weak      WWDG_IRQHandler
-   .thumb_set WWDG_IRQHandler,Default_Handler
-
-   .weak      PVD_IRQHandler
-   .thumb_set PVD_IRQHandler,Default_Handler
-
-   .weak      TAMP_STAMP_IRQHandler
-   .thumb_set TAMP_STAMP_IRQHandler,Default_Handler
-
-   .weak      RTC_WKUP_IRQHandler
-   .thumb_set RTC_WKUP_IRQHandler,Default_Handler
-
-   .weak      FLASH_IRQHandler
-   .thumb_set FLASH_IRQHandler,Default_Handler
-
-   .weak      RCC_IRQHandler
-   .thumb_set RCC_IRQHandler,Default_Handler
-
-   .weak      EXTI0_IRQHandler
-   .thumb_set EXTI0_IRQHandler,Default_Handler
-
-   .weak      EXTI1_IRQHandler
-   .thumb_set EXTI1_IRQHandler,Default_Handler
-
-   .weak      EXTI2_IRQHandler
-   .thumb_set EXTI2_IRQHandler,Default_Handler
-
-   .weak      EXTI3_IRQHandler
-   .thumb_set EXTI3_IRQHandler,Default_Handler
-
-   .weak      EXTI4_IRQHandler
-   .thumb_set EXTI4_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream0_IRQHandler
-   .thumb_set DMA1_Stream0_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream1_IRQHandler
-   .thumb_set DMA1_Stream1_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream2_IRQHandler
-   .thumb_set DMA1_Stream2_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream3_IRQHandler
-   .thumb_set DMA1_Stream3_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream4_IRQHandler
-   .thumb_set DMA1_Stream4_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream5_IRQHandler
-   .thumb_set DMA1_Stream5_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream6_IRQHandler
-   .thumb_set DMA1_Stream6_IRQHandler,Default_Handler
-
-   .weak      ADC_IRQHandler
-   .thumb_set ADC_IRQHandler,Default_Handler
-
-   .weak      CAN1_TX_IRQHandler
-   .thumb_set CAN1_TX_IRQHandler,Default_Handler
-
-   .weak      CAN1_RX0_IRQHandler
-   .thumb_set CAN1_RX0_IRQHandler,Default_Handler
-
-   .weak      CAN1_RX1_IRQHandler
-   .thumb_set CAN1_RX1_IRQHandler,Default_Handler
-
-   .weak      CAN1_SCE_IRQHandler
-   .thumb_set CAN1_SCE_IRQHandler,Default_Handler
-
-   .weak      EXTI9_5_IRQHandler
-   .thumb_set EXTI9_5_IRQHandler,Default_Handler
-
-   .weak      TIM1_BRK_TIM9_IRQHandler
-   .thumb_set TIM1_BRK_TIM9_IRQHandler,Default_Handler
-
-   .weak      TIM1_UP_TIM10_IRQHandler
-   .thumb_set TIM1_UP_TIM10_IRQHandler,Default_Handler
-
-   .weak      TIM1_TRG_COM_TIM11_IRQHandler
-   .thumb_set TIM1_TRG_COM_TIM11_IRQHandler,Default_Handler
-
-   .weak      TIM1_CC_IRQHandler
-   .thumb_set TIM1_CC_IRQHandler,Default_Handler
-
-   .weak      TIM2_IRQHandler
-   .thumb_set TIM2_IRQHandler,Default_Handler
-
-   .weak      TIM3_IRQHandler
-   .thumb_set TIM3_IRQHandler,Default_Handler
-
-   .weak      TIM4_IRQHandler
-   .thumb_set TIM4_IRQHandler,Default_Handler
-
-   .weak      I2C1_EV_IRQHandler
-   .thumb_set I2C1_EV_IRQHandler,Default_Handler
-
-   .weak      I2C1_ER_IRQHandler
-   .thumb_set I2C1_ER_IRQHandler,Default_Handler
-
-   .weak      I2C2_EV_IRQHandler
-   .thumb_set I2C2_EV_IRQHandler,Default_Handler
-
-   .weak      I2C2_ER_IRQHandler
-   .thumb_set I2C2_ER_IRQHandler,Default_Handler
-
-   .weak      SPI1_IRQHandler
-   .thumb_set SPI1_IRQHandler,Default_Handler
-
-   .weak      SPI2_IRQHandler
-   .thumb_set SPI2_IRQHandler,Default_Handler
-
-   .weak      USART1_IRQHandler
-   .thumb_set USART1_IRQHandler,Default_Handler
-
-   .weak      USART2_IRQHandler
-   .thumb_set USART2_IRQHandler,Default_Handler
-
-   .weak      USART3_IRQHandler
-   .thumb_set USART3_IRQHandler,Default_Handler
-
-   .weak      EXTI15_10_IRQHandler
-   .thumb_set EXTI15_10_IRQHandler,Default_Handler
-
-   .weak      RTC_Alarm_IRQHandler
-   .thumb_set RTC_Alarm_IRQHandler,Default_Handler
-
-   .weak      OTG_FS_WKUP_IRQHandler
-   .thumb_set OTG_FS_WKUP_IRQHandler,Default_Handler
-
-   .weak      TIM8_BRK_TIM12_IRQHandler
-   .thumb_set TIM8_BRK_TIM12_IRQHandler,Default_Handler
-
-   .weak      TIM8_UP_TIM13_IRQHandler
-   .thumb_set TIM8_UP_TIM13_IRQHandler,Default_Handler
-
-   .weak      TIM8_TRG_COM_TIM14_IRQHandler
-   .thumb_set TIM8_TRG_COM_TIM14_IRQHandler,Default_Handler
-
-   .weak      TIM8_CC_IRQHandler
-   .thumb_set TIM8_CC_IRQHandler,Default_Handler
-
-   .weak      DMA1_Stream7_IRQHandler
-   .thumb_set DMA1_Stream7_IRQHandler,Default_Handler
-
-   .weak      FMC_IRQHandler
-   .thumb_set FMC_IRQHandler,Default_Handler
-
-   .weak      SDMMC1_IRQHandler
-   .thumb_set SDMMC1_IRQHandler,Default_Handler
-
-   .weak      TIM5_IRQHandler
-   .thumb_set TIM5_IRQHandler,Default_Handler
-
-   .weak      SPI3_IRQHandler
-   .thumb_set SPI3_IRQHandler,Default_Handler
-
-   .weak      UART4_IRQHandler
-   .thumb_set UART4_IRQHandler,Default_Handler
-
-   .weak      UART5_IRQHandler
-   .thumb_set UART5_IRQHandler,Default_Handler
-
-   .weak      TIM6_DAC_IRQHandler
-   .thumb_set TIM6_DAC_IRQHandler,Default_Handler
-
-   .weak      TIM7_IRQHandler
-   .thumb_set TIM7_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream0_IRQHandler
-   .thumb_set DMA2_Stream0_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream1_IRQHandler
-   .thumb_set DMA2_Stream1_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream2_IRQHandler
-   .thumb_set DMA2_Stream2_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream3_IRQHandler
-   .thumb_set DMA2_Stream3_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream4_IRQHandler
-   .thumb_set DMA2_Stream4_IRQHandler,Default_Handler
-
-   .weak      ETH_IRQHandler
-   .thumb_set ETH_IRQHandler,Default_Handler
-
-   .weak      ETH_WKUP_IRQHandler
-   .thumb_set ETH_WKUP_IRQHandler,Default_Handler
-
-   .weak      CAN2_TX_IRQHandler
-   .thumb_set CAN2_TX_IRQHandler,Default_Handler
-
-   .weak      CAN2_RX0_IRQHandler
-   .thumb_set CAN2_RX0_IRQHandler,Default_Handler
-
-   .weak      CAN2_RX1_IRQHandler
-   .thumb_set CAN2_RX1_IRQHandler,Default_Handler
-
-   .weak      CAN2_SCE_IRQHandler
-   .thumb_set CAN2_SCE_IRQHandler,Default_Handler
-
-   .weak      OTG_FS_IRQHandler
-   .thumb_set OTG_FS_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream5_IRQHandler
-   .thumb_set DMA2_Stream5_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream6_IRQHandler
-   .thumb_set DMA2_Stream6_IRQHandler,Default_Handler
-
-   .weak      DMA2_Stream7_IRQHandler
-   .thumb_set DMA2_Stream7_IRQHandler,Default_Handler
-
-   .weak      USART6_IRQHandler
-   .thumb_set USART6_IRQHandler,Default_Handler
-
-   .weak      I2C3_EV_IRQHandler
-   .thumb_set I2C3_EV_IRQHandler,Default_Handler
-
-   .weak      I2C3_ER_IRQHandler
-   .thumb_set I2C3_ER_IRQHandler,Default_Handler
-
-   .weak      OTG_HS_EP1_OUT_IRQHandler
-   .thumb_set OTG_HS_EP1_OUT_IRQHandler,Default_Handler
-
-   .weak      OTG_HS_EP1_IN_IRQHandler
-   .thumb_set OTG_HS_EP1_IN_IRQHandler,Default_Handler
-
-   .weak      OTG_HS_WKUP_IRQHandler
-   .thumb_set OTG_HS_WKUP_IRQHandler,Default_Handler
-
-   .weak      OTG_HS_IRQHandler
-   .thumb_set OTG_HS_IRQHandler,Default_Handler
-
-   .weak      DCMI_IRQHandler
-   .thumb_set DCMI_IRQHandler,Default_Handler
-
-   .weak      HASH_RNG_IRQHandler
-   .thumb_set HASH_RNG_IRQHandler,Default_Handler
-
-   .weak      FPU_IRQHandler
-   .thumb_set FPU_IRQHandler,Default_Handler
-
-   .weak      UART7_IRQHandler
-   .thumb_set UART7_IRQHandler,Default_Handler
-
-   .weak      UART8_IRQHandler
-   .thumb_set UART8_IRQHandler,Default_Handler
-
-   .weak      SPI4_IRQHandler
-   .thumb_set SPI4_IRQHandler,Default_Handler
-
-   .weak      SPI5_IRQHandler
-   .thumb_set SPI5_IRQHandler,Default_Handler
-
-   .weak      SPI6_IRQHandler
-   .thumb_set SPI6_IRQHandler,Default_Handler
-
-   .weak      SAI1_IRQHandler
-   .thumb_set SAI1_IRQHandler,Default_Handler
-
-   .weak      DMA2D_IRQHandler
-   .thumb_set DMA2D_IRQHandler,Default_Handler
-
-   .weak      SAI2_IRQHandler
-   .thumb_set SAI2_IRQHandler,Default_Handler
-
-   .weak      QUADSPI_IRQHandler
-   .thumb_set QUADSPI_IRQHandler,Default_Handler
-
-   .weak      LPTIM1_IRQHandler
-   .thumb_set LPTIM1_IRQHandler,Default_Handler
-
-   .weak      CEC_IRQHandler
-   .thumb_set CEC_IRQHandler,Default_Handler
-
-   .weak      I2C4_EV_IRQHandler
-   .thumb_set I2C4_EV_IRQHandler,Default_Handler
-
-   .weak      I2C4_ER_IRQHandler
-   .thumb_set I2C4_ER_IRQHandler,Default_Handler
-
-   .weak      SPDIF_RX_IRQHandler
-   .thumb_set SPDIF_RX_IRQHandler,Default_Handler
-
-   .weak      DSIHOST_IRQHandler
-   .thumb_set DSIHOST_IRQHandler,Default_Handler
-
-   .weak      DFSDM1_FLT0_IRQHandler
-   .thumb_set DFSDM1_FLT0_IRQHandler,Default_Handler
-
-   .weak      DFSDM1_FLT1_IRQHandler
-   .thumb_set DFSDM1_FLT1_IRQHandler,Default_Handler
-
-   .weak      DFSDM1_FLT2_IRQHandler
-   .thumb_set DFSDM1_FLT2_IRQHandler,Default_Handler
-
-   .weak      DFSDM1_FLT3_IRQHandler
-   .thumb_set DFSDM1_FLT3_IRQHandler,Default_Handler
-
-   .weak      SDMMC2_IRQHandler
-   .thumb_set SDMMC2_IRQHandler,Default_Handler
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
diff --git a/ports/stm32/boards/startup_stm32h7.s b/ports/stm32/boards/startup_stm32h7.s
deleted file mode 100644
index 53d46205fd692..0000000000000
--- a/ports/stm32/boards/startup_stm32h7.s
+++ /dev/null
@@ -1,763 +0,0 @@
-/**
-  ******************************************************************************
-  * @file      startup_stm32h743xx.s
-  * @author    MCD Application Team
-  * @version   V1.2.0
-  * @date      29-December-2017
-  * @brief     STM32H743xx Devices vector table for GCC based toolchain. 
-  *            This module performs:
-  *                - Set the initial SP
-  *                - Set the initial PC == Reset_Handler,
-  *                - Set the vector table entries with the exceptions ISR address
-  *                - Branches to main in the C library (which eventually
-  *                  calls main()).
-  *            After Reset the Cortex-M processor is in Thread mode,
-  *            priority is Privileged, and the Stack is set to Main.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT 2017 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
-    
-  .syntax unified
-  .cpu cortex-m7
-  .fpu softvfp
-  .thumb
-
-.global  g_pfnVectors
-.global  Default_Handler
-
-/* start address for the initialization values of the .data section. 
-defined in linker script */
-.word  _sidata
-/* start address for the .data section. defined in linker script */  
-.word  _sdata
-/* end address for the .data section. defined in linker script */
-.word  _edata
-/* start address for the .bss section. defined in linker script */
-.word  _sbss
-/* end address for the .bss section. defined in linker script */
-.word  _ebss
-/* stack used for SystemInit_ExtMemCtl; always internal RAM used */
-
-/**
- * @brief  This is the code that gets called when the processor first
- *          starts execution following a reset event. Only the absolutely
- *          necessary set is performed, after which the application
- *          supplied main() routine is called. 
- * @param  None
- * @retval : None
-*/
-
-    .section  .text.Reset_Handler
-  .weak  Reset_Handler
-  .type  Reset_Handler, %function
-Reset_Handler:  
-  ldr   sp, =_estack      /* set stack pointer */
-
-/* Copy the data segment initializers from flash to SRAM */  
-  movs  r1, #0
-  b  LoopCopyDataInit
-
-CopyDataInit:
-  ldr  r3, =_sidata
-  ldr  r3, [r3, r1]
-  str  r3, [r0, r1]
-  adds  r1, r1, #4
-    
-LoopCopyDataInit:
-  ldr  r0, =_sdata
-  ldr  r3, =_edata
-  adds  r2, r0, r1
-  cmp  r2, r3
-  bcc  CopyDataInit
-  ldr  r2, =_sbss
-  b  LoopFillZerobss
-/* Zero fill the bss segment. */  
-FillZerobss:
-  movs  r3, #0
-  str  r3, [r2], #4
-    
-LoopFillZerobss:
-  ldr  r3, = _ebss
-  cmp  r2, r3
-  bcc  FillZerobss
-
-/* Call the clock system intitialization function.*/
-  bl  SystemInit   
-/* Call static constructors */
-/*    bl __libc_init_array */
-/* Call the application's entry point.*/
-  bl  main
-  bx  lr    
-.size  Reset_Handler, .-Reset_Handler
-
-/**
- * @brief  This is the code that gets called when the processor receives an 
- *         unexpected interrupt.  This simply enters an infinite loop, preserving
- *         the system state for examination by a debugger.
- * @param  None     
- * @retval None       
-*/
-    .section  .text.Default_Handler,"ax",%progbits
-Default_Handler:
-Infinite_Loop:
-  b  Infinite_Loop
-  .size  Default_Handler, .-Default_Handler
-/******************************************************************************
-*
-* The minimal vector table for a Cortex M. Note that the proper constructs
-* must be placed on this to ensure that it ends up at physical address
-* 0x0000.0000.
-* 
-*******************************************************************************/
-   .section  .isr_vector,"a",%progbits
-  .type  g_pfnVectors, %object
-  .size  g_pfnVectors, .-g_pfnVectors
-   
-   
-g_pfnVectors:
-  .word  _estack
-  .word  Reset_Handler
-
-  .word  NMI_Handler
-  .word  HardFault_Handler
-  .word  MemManage_Handler
-  .word  BusFault_Handler
-  .word  UsageFault_Handler
-  .word  0
-  .word  0
-  .word  0
-  .word  0
-  .word  SVC_Handler
-  .word  DebugMon_Handler
-  .word  0
-  .word  PendSV_Handler
-  .word  SysTick_Handler
-  
-  /* External Interrupts */
-  .word     WWDG_IRQHandler                   /* Window WatchDog              */                                        
-  .word     PVD_AVD_IRQHandler                /* PVD/AVD through EXTI Line detection */                        
-  .word     TAMP_STAMP_IRQHandler             /* Tamper and TimeStamps through the EXTI line */            
-  .word     RTC_WKUP_IRQHandler               /* RTC Wakeup through the EXTI line */                      
-  .word     FLASH_IRQHandler                  /* FLASH                        */                                          
-  .word     RCC_IRQHandler                    /* RCC                          */                                            
-  .word     EXTI0_IRQHandler                  /* EXTI Line0                   */                        
-  .word     EXTI1_IRQHandler                  /* EXTI Line1                   */                          
-  .word     EXTI2_IRQHandler                  /* EXTI Line2                   */                          
-  .word     EXTI3_IRQHandler                  /* EXTI Line3                   */                          
-  .word     EXTI4_IRQHandler                  /* EXTI Line4                   */                          
-  .word     DMA1_Stream0_IRQHandler           /* DMA1 Stream 0                */                  
-  .word     DMA1_Stream1_IRQHandler           /* DMA1 Stream 1                */                   
-  .word     DMA1_Stream2_IRQHandler           /* DMA1 Stream 2                */                   
-  .word     DMA1_Stream3_IRQHandler           /* DMA1 Stream 3                */                   
-  .word     DMA1_Stream4_IRQHandler           /* DMA1 Stream 4                */                   
-  .word     DMA1_Stream5_IRQHandler           /* DMA1 Stream 5                */                   
-  .word     DMA1_Stream6_IRQHandler           /* DMA1 Stream 6                */                   
-  .word     ADC_IRQHandler                    /* ADC1, ADC2 and ADC3s         */                   
-  .word     FDCAN1_IT0_IRQHandler             /* FDCAN1 interrupt line 0      */                    
-  .word     FDCAN2_IT0_IRQHandler             /* FDCAN2 interrupt line 0      */                    
-  .word     FDCAN1_IT1_IRQHandler             /* FDCAN1 interrupt line 1      */                    
-  .word     FDCAN2_IT1_IRQHandler             /* FDCAN2 interrupt line 1      */                    
-  .word     EXTI9_5_IRQHandler                /* External Line[9:5]s          */                          
-  .word     TIM1_BRK_IRQHandler               /* TIM1 Break interrupt         */         
-  .word     TIM1_UP_IRQHandler                /* TIM1 Update interrupt        */         
-  .word     TIM1_TRG_COM_IRQHandler           /* TIM1 Trigger and Commutation interrupt */
-  .word     TIM1_CC_IRQHandler                /* TIM1 Capture Compare         */                          
-  .word     TIM2_IRQHandler                   /* TIM2                         */                   
-  .word     TIM3_IRQHandler                   /* TIM3                         */                   
-  .word     TIM4_IRQHandler                   /* TIM4                         */                   
-  .word     I2C1_EV_IRQHandler                /* I2C1 Event                   */                          
-  .word     I2C1_ER_IRQHandler                /* I2C1 Error                   */                          
-  .word     I2C2_EV_IRQHandler                /* I2C2 Event                   */                          
-  .word     I2C2_ER_IRQHandler                /* I2C2 Error                   */                            
-  .word     SPI1_IRQHandler                   /* SPI1                         */                   
-  .word     SPI2_IRQHandler                   /* SPI2                         */                   
-  .word     USART1_IRQHandler                 /* USART1                       */                   
-  .word     USART2_IRQHandler                 /* USART2                       */                   
-  .word     USART3_IRQHandler                 /* USART3                       */                   
-  .word     EXTI15_10_IRQHandler              /* External Line[15:10]s        */                          
-  .word     RTC_Alarm_IRQHandler              /* RTC Alarm (A and B) through EXTI Line */                 
-  .word     0                                 /* Reserved                     */                       
-  .word     TIM8_BRK_TIM12_IRQHandler         /* TIM8 Break and TIM12         */         
-  .word     TIM8_UP_TIM13_IRQHandler          /* TIM8 Update and TIM13        */         
-  .word     TIM8_TRG_COM_TIM14_IRQHandler     /* TIM8 Trigger and Commutation and TIM14 */
-  .word     TIM8_CC_IRQHandler                /* TIM8 Capture Compare         */                          
-  .word     DMA1_Stream7_IRQHandler           /* DMA1 Stream7                 */                          
-  .word     FMC_IRQHandler                    /* FMC                          */                   
-  .word     SDMMC1_IRQHandler                 /* SDMMC1                       */                   
-  .word     TIM5_IRQHandler                   /* TIM5                         */                   
-  .word     SPI3_IRQHandler                   /* SPI3                         */                   
-  .word     UART4_IRQHandler                  /* UART4                        */                   
-  .word     UART5_IRQHandler                  /* UART5                        */                   
-  .word     TIM6_DAC_IRQHandler               /* TIM6 and DAC1&2 underrun errors */                   
-  .word     TIM7_IRQHandler                   /* TIM7                         */
-  .word     DMA2_Stream0_IRQHandler           /* DMA2 Stream 0                */                   
-  .word     DMA2_Stream1_IRQHandler           /* DMA2 Stream 1                */                   
-  .word     DMA2_Stream2_IRQHandler           /* DMA2 Stream 2                */                   
-  .word     DMA2_Stream3_IRQHandler           /* DMA2 Stream 3                */                   
-  .word     DMA2_Stream4_IRQHandler           /* DMA2 Stream 4                */                   
-  .word     ETH_IRQHandler                    /* Ethernet                     */                   
-  .word     ETH_WKUP_IRQHandler               /* Ethernet Wakeup through EXTI line */                     
-  .word     FDCAN_CAL_IRQHandler              /* FDCAN calibration unit interrupt*/                                               
-  .word     0                                 /* Reserved                     */                          
-  .word     0                                 /* Reserved                     */                       
-  .word     0                                 /* Reserved                     */                           
-  .word     0                                 /* Reserved                     */                  
-  .word     DMA2_Stream5_IRQHandler           /* DMA2 Stream 5                */                   
-  .word     DMA2_Stream6_IRQHandler           /* DMA2 Stream 6                */                   
-  .word     DMA2_Stream7_IRQHandler           /* DMA2 Stream 7                */                   
-  .word     USART6_IRQHandler                 /* USART6                       */                    
-  .word     I2C3_EV_IRQHandler                /* I2C3 event                   */                          
-  .word     I2C3_ER_IRQHandler                /* I2C3 error                   */                          
-  .word     OTG_HS_EP1_OUT_IRQHandler         /* USB OTG HS End Point 1 Out   */                   
-  .word     OTG_HS_EP1_IN_IRQHandler          /* USB OTG HS End Point 1 In    */                   
-  .word     OTG_HS_WKUP_IRQHandler            /* USB OTG HS Wakeup through EXTI */                         
-  .word     OTG_HS_IRQHandler                 /* USB OTG HS                   */                   
-  .word     DCMI_IRQHandler                   /* DCMI                         */                   
-  .word     0                                 /* Reserved                     */                   
-  .word     RNG_IRQHandler                    /* Rng                          */
-  .word     FPU_IRQHandler                    /* FPU                          */
-  .word     UART7_IRQHandler                  /* UART7                        */      
-  .word     UART8_IRQHandler                  /* UART8                        */
-  .word     SPI4_IRQHandler                   /* SPI4                         */
-  .word     SPI5_IRQHandler                   /* SPI5                         */
-  .word     SPI6_IRQHandler                   /* SPI6                         */
-  .word     SAI1_IRQHandler                   /* SAI1                         */
-  .word     LTDC_IRQHandler                   /* LTDC                         */
-  .word     LTDC_ER_IRQHandler                /* LTDC error                   */
-  .word     DMA2D_IRQHandler                  /* DMA2D                        */
-  .word     SAI2_IRQHandler                   /* SAI2                         */
-  .word     QUADSPI_IRQHandler                /* QUADSPI                      */
-  .word     LPTIM1_IRQHandler                 /* LPTIM1                       */
-  .word     CEC_IRQHandler                    /* HDMI_CEC                     */
-  .word     I2C4_EV_IRQHandler                /* I2C4 Event                   */
-  .word     I2C4_ER_IRQHandler                /* I2C4 Error                   */
-  .word     SPDIF_RX_IRQHandler               /* SPDIF_RX                     */ 
-  .word     OTG_FS_EP1_OUT_IRQHandler         /* USB OTG FS End Point 1 Out   */   
-  .word     OTG_FS_EP1_IN_IRQHandler          /* USB OTG FS End Point 1 In    */   
-  .word     OTG_FS_WKUP_IRQHandler            /* USB OTG FS Wakeup through EXTI */  
-  .word     OTG_FS_IRQHandler                 /* USB OTG FS                   */
-  .word     DMAMUX1_OVR_IRQHandler            /* DMAMUX1 Overrun interrupt    */  
-  .word     HRTIM1_Master_IRQHandler          /* HRTIM Master Timer global Interrupt */
-  .word     HRTIM1_TIMA_IRQHandler            /* HRTIM Timer A global Interrupt */  
-  .word     HRTIM1_TIMB_IRQHandler            /* HRTIM Timer B global Interrupt */  
-  .word     HRTIM1_TIMC_IRQHandler            /* HRTIM Timer C global Interrupt */  
-  .word     HRTIM1_TIMD_IRQHandler            /* HRTIM Timer D global Interrupt */  
-  .word     HRTIM1_TIME_IRQHandler            /* HRTIM Timer E global Interrupt */  
-  .word     HRTIM1_FLT_IRQHandler             /* HRTIM Fault global Interrupt   */ 
-  .word     DFSDM1_FLT0_IRQHandler            /* DFSDM Filter0 Interrupt        */
-  .word     DFSDM1_FLT1_IRQHandler            /* DFSDM Filter1 Interrupt        */     
-  .word     DFSDM1_FLT2_IRQHandler            /* DFSDM Filter2 Interrupt        */    
-  .word     DFSDM1_FLT3_IRQHandler            /* DFSDM Filter3 Interrupt        */   
-  .word     SAI3_IRQHandler                   /* SAI3 global Interrupt          */   
-  .word     SWPMI1_IRQHandler                 /* Serial Wire Interface 1 global interrupt */
-  .word     TIM15_IRQHandler                  /* TIM15 global Interrupt      */        
-  .word     TIM16_IRQHandler                  /* TIM16 global Interrupt      */      
-  .word     TIM17_IRQHandler                  /* TIM17 global Interrupt      */      
-  .word     MDIOS_WKUP_IRQHandler             /* MDIOS Wakeup  Interrupt     */     
-  .word     MDIOS_IRQHandler                  /* MDIOS global Interrupt      */    
-  .word     JPEG_IRQHandler                   /* JPEG global Interrupt       */    
-  .word     MDMA_IRQHandler                   /* MDMA global Interrupt       */    
-  .word     0                                 /* Reserved                    */    
-  .word     SDMMC2_IRQHandler                 /* SDMMC2 global Interrupt     */    
-  .word     HSEM1_IRQHandler                  /* HSEM1 global Interrupt      */    
-  .word     0                                 /* Reserved                    */    
-  .word     ADC3_IRQHandler                   /* ADC3 global Interrupt       */    
-  .word     DMAMUX2_OVR_IRQHandler            /* DMAMUX Overrun interrupt    */    
-  .word     BDMA_Channel0_IRQHandler          /* BDMA Channel 0 global Interrupt */
-  .word     BDMA_Channel1_IRQHandler          /* BDMA Channel 1 global Interrupt */ 
-  .word     BDMA_Channel2_IRQHandler          /* BDMA Channel 2 global Interrupt */ 
-  .word     BDMA_Channel3_IRQHandler          /* BDMA Channel 3 global Interrupt */ 
-  .word     BDMA_Channel4_IRQHandler          /* BDMA Channel 4 global Interrupt */ 
-  .word     BDMA_Channel5_IRQHandler          /* BDMA Channel 5 global Interrupt */ 
-  .word     BDMA_Channel6_IRQHandler          /* BDMA Channel 6 global Interrupt */ 
-  .word     BDMA_Channel7_IRQHandler          /* BDMA Channel 7 global Interrupt */ 
-  .word     COMP1_IRQHandler                  /* COMP1 global Interrupt     */          
-  .word     LPTIM2_IRQHandler                 /* LP TIM2 global interrupt   */      
-  .word     LPTIM3_IRQHandler                 /* LP TIM3 global interrupt   */     
-  .word     LPTIM4_IRQHandler                 /* LP TIM4 global interrupt   */     
-  .word     LPTIM5_IRQHandler                 /* LP TIM5 global interrupt   */     
-  .word     LPUART1_IRQHandler                /* LP UART1 interrupt         */     
-  .word     0                                 /* Reserved                   */     
-  .word     CRS_IRQHandler                    /* Clock Recovery Global Interrupt */ 
-  .word     0                                 /* Reserved                   */     
-  .word     SAI4_IRQHandler                   /* SAI4 global interrupt      */      
-  .word     0                                 /* Reserved                   */      
-  .word     0                                 /* Reserved                   */      
-  .word     WAKEUP_PIN_IRQHandler             /* Interrupt for all 6 wake-up pins */
-
-/*******************************************************************************
-*
-* Provide weak aliases for each Exception handler to the Default_Handler. 
-* As they are weak aliases, any function with the same name will override 
-* this definition.
-* 
-*******************************************************************************/
-   .weak      NMI_Handler
-   .thumb_set NMI_Handler,Default_Handler
-  
-   .weak      HardFault_Handler
-   .thumb_set HardFault_Handler,Default_Handler
-  
-   .weak      MemManage_Handler
-   .thumb_set MemManage_Handler,Default_Handler
-  
-   .weak      BusFault_Handler
-   .thumb_set BusFault_Handler,Default_Handler
-
-   .weak      UsageFault_Handler
-   .thumb_set UsageFault_Handler,Default_Handler
-
-   .weak      SVC_Handler
-   .thumb_set SVC_Handler,Default_Handler
-
-   .weak      DebugMon_Handler
-   .thumb_set DebugMon_Handler,Default_Handler
-
-   .weak      PendSV_Handler
-   .thumb_set PendSV_Handler,Default_Handler
-
-   .weak      SysTick_Handler
-   .thumb_set SysTick_Handler,Default_Handler              
-  
-   .weak      WWDG_IRQHandler                   
-   .thumb_set WWDG_IRQHandler,Default_Handler      
-                  
-   .weak      PVD_AVD_IRQHandler      
-   .thumb_set PVD_AVD_IRQHandler,Default_Handler
-               
-   .weak      TAMP_STAMP_IRQHandler            
-   .thumb_set TAMP_STAMP_IRQHandler,Default_Handler
-            
-   .weak      RTC_WKUP_IRQHandler                  
-   .thumb_set RTC_WKUP_IRQHandler,Default_Handler
-            
-   .weak      FLASH_IRQHandler         
-   .thumb_set FLASH_IRQHandler,Default_Handler
-                  
-   .weak      RCC_IRQHandler      
-   .thumb_set RCC_IRQHandler,Default_Handler
-                  
-   .weak      EXTI0_IRQHandler         
-   .thumb_set EXTI0_IRQHandler,Default_Handler
-                  
-   .weak      EXTI1_IRQHandler         
-   .thumb_set EXTI1_IRQHandler,Default_Handler
-                     
-   .weak      EXTI2_IRQHandler         
-   .thumb_set EXTI2_IRQHandler,Default_Handler 
-                 
-   .weak      EXTI3_IRQHandler         
-   .thumb_set EXTI3_IRQHandler,Default_Handler
-                        
-   .weak      EXTI4_IRQHandler         
-   .thumb_set EXTI4_IRQHandler,Default_Handler
-                  
-   .weak      DMA1_Stream0_IRQHandler               
-   .thumb_set DMA1_Stream0_IRQHandler,Default_Handler
-         
-   .weak      DMA1_Stream1_IRQHandler               
-   .thumb_set DMA1_Stream1_IRQHandler,Default_Handler
-                  
-   .weak      DMA1_Stream2_IRQHandler               
-   .thumb_set DMA1_Stream2_IRQHandler,Default_Handler
-                  
-   .weak      DMA1_Stream3_IRQHandler               
-   .thumb_set DMA1_Stream3_IRQHandler,Default_Handler 
-                 
-   .weak      DMA1_Stream4_IRQHandler              
-   .thumb_set DMA1_Stream4_IRQHandler,Default_Handler
-                  
-   .weak      DMA1_Stream5_IRQHandler               
-   .thumb_set DMA1_Stream5_IRQHandler,Default_Handler
-                  
-   .weak      DMA1_Stream6_IRQHandler               
-   .thumb_set DMA1_Stream6_IRQHandler,Default_Handler
-                  
-   .weak      ADC_IRQHandler      
-   .thumb_set ADC_IRQHandler,Default_Handler
-               
-   .weak      FDCAN1_IT0_IRQHandler   
-   .thumb_set FDCAN1_IT0_IRQHandler,Default_Handler
-            
-   .weak      FDCAN2_IT0_IRQHandler                  
-   .thumb_set FDCAN2_IT0_IRQHandler,Default_Handler
-                           
-   .weak      FDCAN1_IT1_IRQHandler                  
-   .thumb_set FDCAN1_IT1_IRQHandler,Default_Handler
-            
-   .weak      FDCAN2_IT1_IRQHandler                  
-   .thumb_set FDCAN2_IT1_IRQHandler,Default_Handler
-            
-   .weak      EXTI9_5_IRQHandler   
-   .thumb_set EXTI9_5_IRQHandler,Default_Handler
-            
-   .weak      TIM1_BRK_IRQHandler            
-   .thumb_set TIM1_BRK_IRQHandler,Default_Handler
-            
-   .weak      TIM1_UP_IRQHandler            
-   .thumb_set TIM1_UP_IRQHandler,Default_Handler
-
-   .weak      TIM1_TRG_COM_IRQHandler      
-   .thumb_set TIM1_TRG_COM_IRQHandler,Default_Handler
-      
-   .weak      TIM1_CC_IRQHandler   
-   .thumb_set TIM1_CC_IRQHandler,Default_Handler
-                  
-   .weak      TIM2_IRQHandler            
-   .thumb_set TIM2_IRQHandler,Default_Handler
-                  
-   .weak      TIM3_IRQHandler            
-   .thumb_set TIM3_IRQHandler,Default_Handler
-                  
-   .weak      TIM4_IRQHandler            
-   .thumb_set TIM4_IRQHandler,Default_Handler
-                  
-   .weak      I2C1_EV_IRQHandler   
-   .thumb_set I2C1_EV_IRQHandler,Default_Handler
-                     
-   .weak      I2C1_ER_IRQHandler   
-   .thumb_set I2C1_ER_IRQHandler,Default_Handler
-                     
-   .weak      I2C2_EV_IRQHandler   
-   .thumb_set I2C2_EV_IRQHandler,Default_Handler
-                  
-   .weak      I2C2_ER_IRQHandler   
-   .thumb_set I2C2_ER_IRQHandler,Default_Handler
-                           
-   .weak      SPI1_IRQHandler            
-   .thumb_set SPI1_IRQHandler,Default_Handler
-                        
-   .weak      SPI2_IRQHandler            
-   .thumb_set SPI2_IRQHandler,Default_Handler
-                  
-   .weak      USART1_IRQHandler      
-   .thumb_set USART1_IRQHandler,Default_Handler
-                     
-   .weak      USART2_IRQHandler      
-   .thumb_set USART2_IRQHandler,Default_Handler
-                     
-   .weak      USART3_IRQHandler      
-   .thumb_set USART3_IRQHandler,Default_Handler
-                  
-   .weak      EXTI15_10_IRQHandler               
-   .thumb_set EXTI15_10_IRQHandler,Default_Handler
-               
-   .weak      RTC_Alarm_IRQHandler               
-   .thumb_set RTC_Alarm_IRQHandler,Default_Handler
-            
-   .weak      TIM8_BRK_TIM12_IRQHandler         
-   .thumb_set TIM8_BRK_TIM12_IRQHandler,Default_Handler
-         
-   .weak      TIM8_UP_TIM13_IRQHandler            
-   .thumb_set TIM8_UP_TIM13_IRQHandler,Default_Handler
-         
-   .weak      TIM8_TRG_COM_TIM14_IRQHandler      
-   .thumb_set TIM8_TRG_COM_TIM14_IRQHandler,Default_Handler
-      
-   .weak      TIM8_CC_IRQHandler   
-   .thumb_set TIM8_CC_IRQHandler,Default_Handler
-                  
-   .weak      DMA1_Stream7_IRQHandler               
-   .thumb_set DMA1_Stream7_IRQHandler,Default_Handler
-                     
-   .weak      FMC_IRQHandler            
-   .thumb_set FMC_IRQHandler,Default_Handler
-                     
-   .weak      SDMMC1_IRQHandler            
-   .thumb_set SDMMC1_IRQHandler,Default_Handler
-                     
-   .weak      TIM5_IRQHandler            
-   .thumb_set TIM5_IRQHandler,Default_Handler
-                     
-   .weak      SPI3_IRQHandler            
-   .thumb_set SPI3_IRQHandler,Default_Handler
-                     
-   .weak      UART4_IRQHandler         
-   .thumb_set UART4_IRQHandler,Default_Handler
-                  
-   .weak      UART5_IRQHandler         
-   .thumb_set UART5_IRQHandler,Default_Handler
-                  
-   .weak      TIM6_DAC_IRQHandler                  
-   .thumb_set TIM6_DAC_IRQHandler,Default_Handler
-               
-   .weak      TIM7_IRQHandler            
-   .thumb_set TIM7_IRQHandler,Default_Handler
-         
-   .weak      DMA2_Stream0_IRQHandler               
-   .thumb_set DMA2_Stream0_IRQHandler,Default_Handler
-               
-   .weak      DMA2_Stream1_IRQHandler               
-   .thumb_set DMA2_Stream1_IRQHandler,Default_Handler
-                  
-   .weak      DMA2_Stream2_IRQHandler               
-   .thumb_set DMA2_Stream2_IRQHandler,Default_Handler
-            
-   .weak      DMA2_Stream3_IRQHandler               
-   .thumb_set DMA2_Stream3_IRQHandler,Default_Handler
-            
-   .weak      DMA2_Stream4_IRQHandler               
-   .thumb_set DMA2_Stream4_IRQHandler,Default_Handler
-    
-   .weak      ETH_IRQHandler   
-   .thumb_set ETH_IRQHandler,Default_Handler
-   
-   .weak      ETH_WKUP_IRQHandler   
-   .thumb_set ETH_WKUP_IRQHandler,Default_Handler
-
-   .weak      FDCAN_CAL_IRQHandler   
-   .thumb_set FDCAN_CAL_IRQHandler,Default_Handler   
-                                                                  
-   .weak      DMA2_Stream5_IRQHandler               
-   .thumb_set DMA2_Stream5_IRQHandler,Default_Handler
-                  
-   .weak      DMA2_Stream6_IRQHandler               
-   .thumb_set DMA2_Stream6_IRQHandler,Default_Handler
-                  
-   .weak      DMA2_Stream7_IRQHandler               
-   .thumb_set DMA2_Stream7_IRQHandler,Default_Handler
-                  
-   .weak      USART6_IRQHandler      
-   .thumb_set USART6_IRQHandler,Default_Handler
-                        
-   .weak      I2C3_EV_IRQHandler   
-   .thumb_set I2C3_EV_IRQHandler,Default_Handler
-                        
-   .weak      I2C3_ER_IRQHandler   
-   .thumb_set I2C3_ER_IRQHandler,Default_Handler
-                        
-   .weak      OTG_HS_EP1_OUT_IRQHandler         
-   .thumb_set OTG_HS_EP1_OUT_IRQHandler,Default_Handler
-               
-   .weak      OTG_HS_EP1_IN_IRQHandler            
-   .thumb_set OTG_HS_EP1_IN_IRQHandler,Default_Handler
-               
-   .weak      OTG_HS_WKUP_IRQHandler         
-   .thumb_set OTG_HS_WKUP_IRQHandler,Default_Handler
-            
-   .weak      OTG_HS_IRQHandler      
-   .thumb_set OTG_HS_IRQHandler,Default_Handler
-                  
-   .weak      DCMI_IRQHandler            
-   .thumb_set DCMI_IRQHandler,Default_Handler
-
-   .weak      RNG_IRQHandler            
-   .thumb_set RNG_IRQHandler,Default_Handler   
-
-   .weak      FPU_IRQHandler                  
-   .thumb_set FPU_IRQHandler,Default_Handler
-
-   .weak      UART7_IRQHandler                  
-   .thumb_set UART7_IRQHandler,Default_Handler
-
-   .weak      UART8_IRQHandler                  
-   .thumb_set UART8_IRQHandler,Default_Handler   
-
-   .weak      SPI4_IRQHandler            
-   .thumb_set SPI4_IRQHandler,Default_Handler
-   
-   .weak      SPI5_IRQHandler            
-   .thumb_set SPI5_IRQHandler,Default_Handler
-
-   .weak      SPI6_IRQHandler            
-   .thumb_set SPI6_IRQHandler,Default_Handler   
-
-   .weak      SAI1_IRQHandler            
-   .thumb_set SAI1_IRQHandler,Default_Handler
-   
-   .weak      LTDC_IRQHandler            
-   .thumb_set LTDC_IRQHandler,Default_Handler
-
-   .weak      LTDC_ER_IRQHandler            
-   .thumb_set LTDC_ER_IRQHandler,Default_Handler
-
-   .weak      DMA2D_IRQHandler            
-   .thumb_set DMA2D_IRQHandler,Default_Handler   
-
-   .weak      SAI2_IRQHandler            
-   .thumb_set SAI2_IRQHandler,Default_Handler
-   
-   .weak      QUADSPI_IRQHandler            
-   .thumb_set QUADSPI_IRQHandler,Default_Handler
- 
-   .weak      LPTIM1_IRQHandler            
-   .thumb_set LPTIM1_IRQHandler,Default_Handler
-
-   .weak      CEC_IRQHandler            
-   .thumb_set CEC_IRQHandler,Default_Handler
-   
-   .weak      I2C4_EV_IRQHandler            
-   .thumb_set I2C4_EV_IRQHandler,Default_Handler 
- 
-   .weak      I2C4_ER_IRQHandler            
-   .thumb_set I2C4_ER_IRQHandler,Default_Handler
-   
-   .weak      SPDIF_RX_IRQHandler            
-   .thumb_set SPDIF_RX_IRQHandler,Default_Handler
-
-   .weak      OTG_FS_EP1_OUT_IRQHandler            
-   .thumb_set OTG_FS_EP1_OUT_IRQHandler,Default_Handler
-   
-   .weak      OTG_FS_EP1_IN_IRQHandler            
-   .thumb_set OTG_FS_EP1_IN_IRQHandler,Default_Handler 
-
-   .weak      OTG_FS_WKUP_IRQHandler            
-   .thumb_set OTG_FS_WKUP_IRQHandler,Default_Handler
-
-   .weak      OTG_FS_IRQHandler            
-   .thumb_set OTG_FS_IRQHandler,Default_Handler
-   
-   .weak      DMAMUX1_OVR_IRQHandler            
-   .thumb_set DMAMUX1_OVR_IRQHandler,Default_Handler
-
-   .weak      HRTIM1_Master_IRQHandler            
-   .thumb_set HRTIM1_Master_IRQHandler,Default_Handler
-   
-   .weak      HRTIM1_TIMA_IRQHandler            
-   .thumb_set HRTIM1_TIMA_IRQHandler,Default_Handler
-
-   .weak      HRTIM1_TIMB_IRQHandler            
-   .thumb_set HRTIM1_TIMB_IRQHandler,Default_Handler 
-
-   .weak      HRTIM1_TIMC_IRQHandler            
-   .thumb_set HRTIM1_TIMC_IRQHandler,Default_Handler 
-
-   .weak      HRTIM1_TIMD_IRQHandler            
-   .thumb_set HRTIM1_TIMD_IRQHandler,Default_Handler 
-
-   .weak      HRTIM1_TIME_IRQHandler            
-   .thumb_set HRTIM1_TIME_IRQHandler,Default_Handler 
-
-   .weak      HRTIM1_FLT_IRQHandler            
-   .thumb_set HRTIM1_FLT_IRQHandler,Default_Handler
-
-   .weak      DFSDM1_FLT0_IRQHandler            
-   .thumb_set DFSDM1_FLT0_IRQHandler,Default_Handler   
-
-   .weak      DFSDM1_FLT1_IRQHandler            
-   .thumb_set DFSDM1_FLT1_IRQHandler,Default_Handler 
-
-   .weak      DFSDM1_FLT2_IRQHandler            
-   .thumb_set DFSDM1_FLT2_IRQHandler,Default_Handler 
-
-   .weak      DFSDM1_FLT3_IRQHandler            
-   .thumb_set DFSDM1_FLT3_IRQHandler,Default_Handler    
- 
-   .weak      SAI3_IRQHandler            
-   .thumb_set SAI3_IRQHandler,Default_Handler
-   
-   .weak      SWPMI1_IRQHandler            
-   .thumb_set SWPMI1_IRQHandler,Default_Handler
-
-   .weak      TIM15_IRQHandler            
-   .thumb_set TIM15_IRQHandler,Default_Handler 
-
-   .weak      TIM16_IRQHandler            
-   .thumb_set TIM16_IRQHandler,Default_Handler 
-
-   .weak      TIM17_IRQHandler            
-   .thumb_set TIM17_IRQHandler,Default_Handler 
-
-   .weak      MDIOS_WKUP_IRQHandler            
-   .thumb_set MDIOS_WKUP_IRQHandler,Default_Handler 
-
-   .weak      MDIOS_IRQHandler            
-   .thumb_set MDIOS_IRQHandler,Default_Handler 
-
-   .weak      JPEG_IRQHandler            
-   .thumb_set JPEG_IRQHandler,Default_Handler 
-
-   .weak      MDMA_IRQHandler            
-   .thumb_set MDMA_IRQHandler,Default_Handler 
-
-   .weak      SDMMC2_IRQHandler            
-   .thumb_set SDMMC2_IRQHandler,Default_Handler 
-   
-   .weak      HSEM1_IRQHandler            
-   .thumb_set HSEM1_IRQHandler,Default_Handler
-
-   .weak      ADC3_IRQHandler            
-   .thumb_set ADC3_IRQHandler,Default_Handler 
-
-   .weak      DMAMUX2_OVR_IRQHandler            
-   .thumb_set DMAMUX2_OVR_IRQHandler,Default_Handler 
-
-   .weak      BDMA_Channel0_IRQHandler            
-   .thumb_set BDMA_Channel0_IRQHandler,Default_Handler 
-
-   .weak      BDMA_Channel1_IRQHandler            
-   .thumb_set BDMA_Channel1_IRQHandler,Default_Handler 
-
-   .weak      BDMA_Channel2_IRQHandler            
-   .thumb_set BDMA_Channel2_IRQHandler,Default_Handler 
-
-   .weak      BDMA_Channel3_IRQHandler            
-   .thumb_set BDMA_Channel3_IRQHandler,Default_Handler 
-
-   .weak      BDMA_Channel4_IRQHandler            
-   .thumb_set BDMA_Channel4_IRQHandler,Default_Handler 
-
-   .weak      BDMA_Channel5_IRQHandler            
-   .thumb_set BDMA_Channel5_IRQHandler,Default_Handler    
-
-   .weak      BDMA_Channel6_IRQHandler            
-   .thumb_set BDMA_Channel6_IRQHandler,Default_Handler
-
-   .weak      BDMA_Channel7_IRQHandler            
-   .thumb_set BDMA_Channel7_IRQHandler,Default_Handler 
-
-   .weak      COMP1_IRQHandler            
-   .thumb_set COMP1_IRQHandler,Default_Handler 
-
-   .weak      LPTIM2_IRQHandler            
-   .thumb_set LPTIM2_IRQHandler,Default_Handler 
-
-   .weak      LPTIM3_IRQHandler            
-   .thumb_set LPTIM3_IRQHandler,Default_Handler 
-
-   .weak      LPTIM4_IRQHandler            
-   .thumb_set LPTIM4_IRQHandler,Default_Handler 
-
-   .weak      LPTIM5_IRQHandler            
-   .thumb_set LPTIM5_IRQHandler,Default_Handler 
-
-   .weak      LPUART1_IRQHandler            
-   .thumb_set LPUART1_IRQHandler,Default_Handler 
-
-   .weak      CRS_IRQHandler            
-   .thumb_set CRS_IRQHandler,Default_Handler 
-
-   .weak      SAI4_IRQHandler            
-   .thumb_set SAI4_IRQHandler,Default_Handler 
-
-   .weak      WAKEUP_PIN_IRQHandler            
-   .thumb_set WAKEUP_PIN_IRQHandler,Default_Handler 
-   
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/        
- 
diff --git a/ports/stm32/boards/startup_stm32l4.s b/ports/stm32/boards/startup_stm32l4.s
deleted file mode 100644
index 3225723ff5cfb..0000000000000
--- a/ports/stm32/boards/startup_stm32l4.s
+++ /dev/null
@@ -1,549 +0,0 @@
-/**
-  ******************************************************************************
-  * @file      startup_stm32l496xx.s
-  * @author    MCD Application Team
-  * @brief     STM32L496xx devices vector table GCC toolchain.
-  *            This module performs:
-  *                - Set the initial SP
-  *                - Set the initial PC == Reset_Handler,
-  *                - Set the vector table entries with the exceptions ISR address,
-  *                - Branches to main in the C library (which eventually
-  *                  calls main()).
-  *            After Reset the Cortex-M4 processor is in Thread mode,
-  *            priority is Privileged, and the Stack is set to Main.
-  *  Taken from STM32L4 template code for stm32l496 in STM32Cube_FW_L4_V1.11.0
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT 2017 STMicroelectronics</center></h2>
-  *
-  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
-  * You may not use this file except in compliance with the License.
-  * You may obtain a copy of the License at:
-  *
-  *        http://www.st.com/software_license_agreement_liberty_v2
-  *
-  * Unless required by applicable law or agreed to in writing, software
-  * distributed under the License is distributed on an "AS IS" BASIS,
-  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  * See the License for the specific language governing permissions and
-  * limitations under the License.
-  *
-  ******************************************************************************
-  */
-
-  .syntax unified
-  .cpu cortex-m4
-  .fpu softvfp
-  .thumb
-
-.global  g_pfnVectors
-.global  Default_Handler
-
-/* start address for the initialization values of the .data section.
-defined in linker script */
-.word  _sidata
-/* start address for the .data section. defined in linker script */
-.word  _sdata
-/* end address for the .data section. defined in linker script */
-.word  _edata
-/* start address for the .bss section. defined in linker script */
-.word  _sbss
-/* end address for the .bss section. defined in linker script */
-.word  _ebss
-/* stack used for SystemInit_ExtMemCtl; always internal RAM used */
-
-.equ BootRAM,        0xF1E0F85F
-/**
- * @brief  This is the code that gets called when the processor first
- *          starts execution following a reset event. Only the absolutely
- *          necessary set is performed, after which the application
- *          supplied main() routine is called.
- * @param  None
- * @retval : None
-*/
-
-    .section  .text.Reset_Handler
-  .weak  Reset_Handler
-  .type  Reset_Handler, %function
-Reset_Handler:
-  ldr   sp, =_estack     /* set stack pointer */
-
-/* Copy the data segment initializers from flash to SRAM */
-  movs  r1, #0
-  b  LoopCopyDataInit
-
-CopyDataInit:
-  ldr  r3, =_sidata
-  ldr  r3, [r3, r1]
-  str  r3, [r0, r1]
-  adds  r1, r1, #4
-
-LoopCopyDataInit:
-  ldr  r0, =_sdata
-  ldr  r3, =_edata
-  adds  r2, r0, r1
-  cmp  r2, r3
-  bcc  CopyDataInit
-  ldr  r2, =_sbss
-  b  LoopFillZerobss
-/* Zero fill the bss segment. */
-FillZerobss:
-  movs  r3, #0
-  str  r3, [r2], #4
-
-LoopFillZerobss:
-  ldr  r3, = _ebss
-  cmp  r2, r3
-  bcc  FillZerobss
-
-/* Call the clock system initialization function.*/
-  bl  SystemInit
-/* Call static constructors */
-    /*bl __libc_init_array*/
-/* Call the application's entry point.*/
-  bl  main
-  bx  lr
-.size  Reset_Handler, .-Reset_Handler
-
-/**
- * @brief  This is the code that gets called when the processor receives an
- *         unexpected interrupt.  This simply enters an infinite loop, preserving
- *         the system state for examination by a debugger.
- *
- * @param  None
- * @retval None
-*/
-    .section  .text.Default_Handler,"ax",%progbits
-Default_Handler:
-Infinite_Loop:
-  b  Infinite_Loop
-  .size  Default_Handler, .-Default_Handler
-/******************************************************************************
-*
-* The minimal vector table for a Cortex-M4.  Note that the proper constructs
-* must be placed on this to ensure that it ends up at physical address
-* 0x0000.0000.
-*
-*******************************************************************************/
-   .section  .isr_vector,"a",%progbits
-  .type  g_pfnVectors, %object
-  .size  g_pfnVectors, .-g_pfnVectors
-
-
-g_pfnVectors:
-  .word  _estack
-  .word  Reset_Handler
-  .word  NMI_Handler
-  .word  HardFault_Handler
-  .word  MemManage_Handler
-  .word  BusFault_Handler
-  .word  UsageFault_Handler
-  .word  0
-  .word  0
-  .word  0
-  .word  0
-  .word  SVC_Handler
-  .word  DebugMon_Handler
-  .word  0
-  .word  PendSV_Handler
-  .word  SysTick_Handler
-
-  /* External Interrupts */
-  .word     WWDG_IRQHandler                   /* Window WatchDog              */
-  .word     PVD_PVM_IRQHandler                /* PVD and PVM through EXTI line detection */
-  .word     TAMP_STAMP_IRQHandler             /* Tamper and TimeStamps through the EXTI line */
-  .word     RTC_WKUP_IRQHandler               /* RTC Wakeup through the EXTI line */
-  .word     FLASH_IRQHandler                  /* FLASH                        */
-  .word     RCC_IRQHandler                    /* RCC                          */
-  .word     EXTI0_IRQHandler                  /* EXTI Line0                   */
-  .word     EXTI1_IRQHandler                  /* EXTI Line1                   */
-  .word     EXTI2_IRQHandler                  /* EXTI Line2                   */
-  .word     EXTI3_IRQHandler                  /* EXTI Line3                   */
-  .word     EXTI4_IRQHandler                  /* EXTI Line4                   */
-  .word     DMA1_Channel1_IRQHandler          /* DMA1 Channel 1               */
-  .word     DMA1_Channel2_IRQHandler          /* DMA1 Channel 2               */
-  .word     DMA1_Channel3_IRQHandler          /* DMA1 Channel 3               */
-  .word     DMA1_Channel4_IRQHandler          /* DMA1 Channel 4               */
-  .word     DMA1_Channel5_IRQHandler          /* DMA1 Channel 5               */
-  .word     DMA1_Channel6_IRQHandler          /* DMA1 Channel 6               */
-  .word     DMA1_Channel7_IRQHandler          /* DMA1 Channel 7               */
-  .word     ADC1_2_IRQHandler                 /* ADC1 and ADC2                */
-  .word     CAN1_TX_IRQHandler                /* CAN1 TX                      */
-  .word     CAN1_RX0_IRQHandler               /* CAN1 RX0                     */
-  .word     CAN1_RX1_IRQHandler               /* CAN1 RX1                     */
-  .word     CAN1_SCE_IRQHandler               /* CAN1 SCE                     */
-  .word     EXTI9_5_IRQHandler                /* External Line[9:5]s          */
-  .word     TIM1_BRK_TIM15_IRQHandler         /* TIM1 Break and TIM15         */
-  .word     TIM1_UP_TIM16_IRQHandler          /* TIM1 Update and TIM16        */
-  .word     TIM1_TRG_COM_TIM17_IRQHandler     /* TIM1 Trigger and Commutation and TIM17 */
-  .word     TIM1_CC_IRQHandler                /* TIM1 Capture Compare         */
-  .word     TIM2_IRQHandler                   /* TIM2                         */
-  .word     TIM3_IRQHandler                   /* TIM3                         */
-  .word     TIM4_IRQHandler                   /* TIM4                         */
-  .word     I2C1_EV_IRQHandler                /* I2C1 Event                   */
-  .word     I2C1_ER_IRQHandler                /* I2C1 Error                   */
-  .word     I2C2_EV_IRQHandler                /* I2C2 Event                   */
-  .word     I2C2_ER_IRQHandler                /* I2C2 Error                   */
-  .word     SPI1_IRQHandler                   /* SPI1                         */
-  .word     SPI2_IRQHandler                   /* SPI2                         */
-  .word     USART1_IRQHandler                 /* USART1                       */
-  .word     USART2_IRQHandler                 /* USART2                       */
-  .word     USART3_IRQHandler                 /* USART3                       */
-  .word     EXTI15_10_IRQHandler              /* External Line[15:10]s        */
-  .word     RTC_Alarm_IRQHandler              /* RTC Alarm (A and B) through EXTI Line */
-  .word     DFSDM1_FLT3_IRQHandler            /* Digital filter 3 for sigma delta modulator */
-  .word     TIM8_BRK_IRQHandler               /* TIM8 Break                   */
-  .word     TIM8_UP_IRQHandler                /* TIM8 Update                  */
-  .word     TIM8_TRG_COM_IRQHandler           /* TIM8 Trigger and Commutation */
-  .word     TIM8_CC_IRQHandler                /* TIM8 Capture Compare         */
-  .word     ADC3_IRQHandler                   /* ADC3 global interrupt        */
-  .word     FMC_IRQHandler                    /* FMC                          */
-  .word     SDMMC1_IRQHandler                 /* SDMMC1                       */
-  .word     TIM5_IRQHandler                   /* TIM5                         */
-  .word     SPI3_IRQHandler                   /* SPI3                         */
-  .word     UART4_IRQHandler                  /* UART4                        */
-  .word     UART5_IRQHandler                  /* UART5                        */
-  .word     TIM6_DAC_IRQHandler               /* TIM6 and DAC1&2 underrun errors */
-  .word     TIM7_IRQHandler                   /* TIM7                         */
-  .word     DMA2_Channel1_IRQHandler          /* DMA2 Channel 1               */
-  .word     DMA2_Channel2_IRQHandler          /* DMA2 Channel 2               */
-  .word     DMA2_Channel3_IRQHandler          /* DMA2 Channel 3               */
-  .word     DMA2_Channel4_IRQHandler          /* DMA2 Channel 4               */
-  .word     DMA2_Channel5_IRQHandler          /* DMA2 Channel 5               */
-  .word     DFSDM1_FLT0_IRQHandler            /* Digital filter 0 for sigma delta modulator */
-  .word     DFSDM1_FLT1_IRQHandler            /* Digital filter 1 for sigma delta modulator */
-  .word     DFSDM1_FLT2_IRQHandler            /* Digital filter 2 for sigma delta modulator */
-  .word     COMP_IRQHandler                   /* Comporator thru EXTI line    */
-  .word     LPTIM1_IRQHandler                 /* Low power timer 1            */
-  .word     LPTIM2_IRQHandler                 /* Low power timer 2            */
-  .word     OTG_FS_IRQHandler                 /* USB OTG FS                   */
-  .word     DMA2_Channel6_IRQHandler          /* DMA2 Channel 6               */
-  .word     DMA2_Channel7_IRQHandler          /* DMA2 Channel 7               */
-  .word     LPUART1_IRQHandler                /* Low power UART               */
-  .word     QUADSPI_IRQHandler                /* Quad SPI                     */
-  .word     I2C3_EV_IRQHandler                /* I2C3 event                   */
-  .word     I2C3_ER_IRQHandler                /* I2C3 error                   */
-  .word     SAI1_IRQHandler                   /* Serial audio interface 1     */
-  .word     SAI2_IRQHandler                   /* Serial audio interface 2     */
-  .word     SWPMI1_IRQHandler                 /* Single wire protocole 1      */
-  .word     TSC_IRQHandler                    /* Touch sensig controller      */
-  .word     LCD_IRQHandler                    /* LCD                          */
-  .word     0                                 /* CRYP crypto                  */
-  .word     RNG_IRQHandler                    /* Random number generator      */
-  .word     FPU_IRQHandler                    /* FPU                          */
-  /* Following Handlers are only used on L496/4A6xx devices */
-  .word     CRS_IRQHandler                    /* HASH and CRS interrupt       */
-  .word     I2C4_EV_IRQHandler                /* I2C4 event interrupt         */
-  .word     I2C4_ER_IRQHandler                /* I2C4 error interrupt         */
-  .word     DCMI_IRQHandler                   /* DCMI global interrupt        */
-  .word     CAN2_TX_IRQHandler                /* CAN2 TX interrupt            */
-  .word     CAN2_RX0_IRQHandler               /* CAN2 RX0 interrupt           */
-  .word     CAN2_RX1_IRQHandler               /* CAN2 RX1 interrupt           */
-  .word     CAN2_SCE_IRQHandler               /* CAN SCE interrupt            */
-  .word     DMA2D_IRQHandler                  /* DMA2D global interrupt       */
-
-/*******************************************************************************
-*
-* Provide weak aliases for each Exception handler to the Default_Handler.
-* As they are weak aliases, any function with the same name will override
-* this definition.
-*
-*******************************************************************************/
-   .weak      NMI_Handler
-   .thumb_set NMI_Handler,Default_Handler
-
-   .weak      HardFault_Handler
-   .thumb_set HardFault_Handler,Default_Handler
-
-   .weak      MemManage_Handler
-   .thumb_set MemManage_Handler,Default_Handler
-
-   .weak      BusFault_Handler
-   .thumb_set BusFault_Handler,Default_Handler
-
-   .weak      UsageFault_Handler
-   .thumb_set UsageFault_Handler,Default_Handler
-
-   .weak      SVC_Handler
-   .thumb_set SVC_Handler,Default_Handler
-
-   .weak      DebugMon_Handler
-   .thumb_set DebugMon_Handler,Default_Handler
-
-   .weak      PendSV_Handler
-   .thumb_set PendSV_Handler,Default_Handler
-
-   .weak      SysTick_Handler
-   .thumb_set SysTick_Handler,Default_Handler
-
-   .weak      WWDG_IRQHandler
-   .thumb_set WWDG_IRQHandler,Default_Handler
-
-   .weak      PVD_PVM_IRQHandler
-   .thumb_set PVD_PVM_IRQHandler,Default_Handler
-
-   .weak      TAMP_STAMP_IRQHandler
-   .thumb_set TAMP_STAMP_IRQHandler,Default_Handler
-
-   .weak      RTC_WKUP_IRQHandler
-   .thumb_set RTC_WKUP_IRQHandler,Default_Handler
-
-   .weak      FLASH_IRQHandler
-   .thumb_set FLASH_IRQHandler,Default_Handler
-
-   .weak      RCC_IRQHandler
-   .thumb_set RCC_IRQHandler,Default_Handler
-
-   .weak      EXTI0_IRQHandler
-   .thumb_set EXTI0_IRQHandler,Default_Handler
-
-   .weak      EXTI1_IRQHandler
-   .thumb_set EXTI1_IRQHandler,Default_Handler
-
-   .weak      EXTI2_IRQHandler
-   .thumb_set EXTI2_IRQHandler,Default_Handler
-
-   .weak      EXTI3_IRQHandler
-   .thumb_set EXTI3_IRQHandler,Default_Handler
-
-   .weak      EXTI4_IRQHandler
-   .thumb_set EXTI4_IRQHandler,Default_Handler
-
-   .weak      DMA1_Channel1_IRQHandler
-   .thumb_set DMA1_Channel1_IRQHandler,Default_Handler
-
-   .weak      DMA1_Channel2_IRQHandler
-   .thumb_set DMA1_Channel2_IRQHandler,Default_Handler
-
-   .weak      DMA1_Channel3_IRQHandler
-   .thumb_set DMA1_Channel3_IRQHandler,Default_Handler
-
-   .weak      DMA1_Channel4_IRQHandler
-   .thumb_set DMA1_Channel4_IRQHandler,Default_Handler
-
-   .weak      DMA1_Channel5_IRQHandler
-   .thumb_set DMA1_Channel5_IRQHandler,Default_Handler
-
-   .weak      DMA1_Channel6_IRQHandler
-   .thumb_set DMA1_Channel6_IRQHandler,Default_Handler
-
-   .weak      DMA1_Channel7_IRQHandler
-   .thumb_set DMA1_Channel7_IRQHandler,Default_Handler
-
-   .weak      ADC1_2_IRQHandler
-   .thumb_set ADC1_2_IRQHandler,Default_Handler
-
-   .weak      CAN1_TX_IRQHandler
-   .thumb_set CAN1_TX_IRQHandler,Default_Handler
-
-   .weak      CAN1_RX0_IRQHandler
-   .thumb_set CAN1_RX0_IRQHandler,Default_Handler
-
-   .weak      CAN1_RX1_IRQHandler
-   .thumb_set CAN1_RX1_IRQHandler,Default_Handler
-
-   .weak      CAN1_SCE_IRQHandler
-   .thumb_set CAN1_SCE_IRQHandler,Default_Handler
-
-   .weak      EXTI9_5_IRQHandler
-   .thumb_set EXTI9_5_IRQHandler,Default_Handler
-
-   .weak      TIM1_BRK_TIM15_IRQHandler
-   .thumb_set TIM1_BRK_TIM15_IRQHandler,Default_Handler
-
-   .weak      TIM1_UP_TIM16_IRQHandler
-   .thumb_set TIM1_UP_TIM16_IRQHandler,Default_Handler
-
-   .weak      TIM1_TRG_COM_TIM17_IRQHandler
-   .thumb_set TIM1_TRG_COM_TIM17_IRQHandler,Default_Handler
-
-   .weak      TIM1_CC_IRQHandler
-   .thumb_set TIM1_CC_IRQHandler,Default_Handler
-
-   .weak      TIM2_IRQHandler
-   .thumb_set TIM2_IRQHandler,Default_Handler
-
-   .weak      TIM3_IRQHandler
-   .thumb_set TIM3_IRQHandler,Default_Handler
-
-   .weak      TIM4_IRQHandler
-   .thumb_set TIM4_IRQHandler,Default_Handler
-
-   .weak      I2C1_EV_IRQHandler
-   .thumb_set I2C1_EV_IRQHandler,Default_Handler
-
-   .weak      I2C1_ER_IRQHandler
-   .thumb_set I2C1_ER_IRQHandler,Default_Handler
-
-   .weak      I2C2_EV_IRQHandler
-   .thumb_set I2C2_EV_IRQHandler,Default_Handler
-
-   .weak      I2C2_ER_IRQHandler
-   .thumb_set I2C2_ER_IRQHandler,Default_Handler
-
-   .weak      SPI1_IRQHandler
-   .thumb_set SPI1_IRQHandler,Default_Handler
-
-   .weak      SPI2_IRQHandler
-   .thumb_set SPI2_IRQHandler,Default_Handler
-
-   .weak      USART1_IRQHandler
-   .thumb_set USART1_IRQHandler,Default_Handler
-
-   .weak      USART2_IRQHandler
-   .thumb_set USART2_IRQHandler,Default_Handler
-
-   .weak      USART3_IRQHandler
-   .thumb_set USART3_IRQHandler,Default_Handler
-
-   .weak      EXTI15_10_IRQHandler
-   .thumb_set EXTI15_10_IRQHandler,Default_Handler
-
-   .weak      RTC_Alarm_IRQHandler
-   .thumb_set RTC_Alarm_IRQHandler,Default_Handler
-
-   .weak      DFSDM1_FLT3_IRQHandler
-   .thumb_set DFSDM1_FLT3_IRQHandler,Default_Handler
-
-   .weak      TIM8_BRK_IRQHandler
-   .thumb_set TIM8_BRK_IRQHandler,Default_Handler
-
-   .weak      TIM8_UP_IRQHandler
-   .thumb_set TIM8_UP_IRQHandler,Default_Handler
-
-   .weak      TIM8_TRG_COM_IRQHandler
-   .thumb_set TIM8_TRG_COM_IRQHandler,Default_Handler
-
-   .weak      TIM8_CC_IRQHandler
-   .thumb_set TIM8_CC_IRQHandler,Default_Handler
-
-   .weak      ADC3_IRQHandler
-   .thumb_set ADC3_IRQHandler,Default_Handler
-
-   .weak      FMC_IRQHandler
-   .thumb_set FMC_IRQHandler,Default_Handler
-
-   .weak      SDMMC1_IRQHandler
-   .thumb_set SDMMC1_IRQHandler,Default_Handler
-
-   .weak      TIM5_IRQHandler
-   .thumb_set TIM5_IRQHandler,Default_Handler
-
-   .weak      SPI3_IRQHandler
-   .thumb_set SPI3_IRQHandler,Default_Handler
-
-   .weak      UART4_IRQHandler
-   .thumb_set UART4_IRQHandler,Default_Handler
-
-   .weak      UART5_IRQHandler
-   .thumb_set UART5_IRQHandler,Default_Handler
-
-   .weak      TIM6_DAC_IRQHandler
-   .thumb_set TIM6_DAC_IRQHandler,Default_Handler
-
-   .weak      TIM7_IRQHandler
-   .thumb_set TIM7_IRQHandler,Default_Handler
-
-   .weak      DMA2_Channel1_IRQHandler
-   .thumb_set DMA2_Channel1_IRQHandler,Default_Handler
-
-   .weak      DMA2_Channel2_IRQHandler
-   .thumb_set DMA2_Channel2_IRQHandler,Default_Handler
-
-   .weak      DMA2_Channel3_IRQHandler
-   .thumb_set DMA2_Channel3_IRQHandler,Default_Handler
-
-   .weak      DMA2_Channel4_IRQHandler
-   .thumb_set DMA2_Channel4_IRQHandler,Default_Handler
-
-   .weak      DMA2_Channel5_IRQHandler
-   .thumb_set DMA2_Channel5_IRQHandler,Default_Handler
-
-   .weak      DFSDM1_FLT0_IRQHandler
-   .thumb_set DFSDM1_FLT0_IRQHandler,Default_Handler
-
-   .weak      DFSDM1_FLT1_IRQHandler
-   .thumb_set DFSDM1_FLT1_IRQHandler,Default_Handler
-
-   .weak      DFSDM1_FLT2_IRQHandler
-   .thumb_set DFSDM1_FLT2_IRQHandler,Default_Handler
-
-   .weak      COMP_IRQHandler
-   .thumb_set COMP_IRQHandler,Default_Handler
-
-   .weak      LPTIM1_IRQHandler
-   .thumb_set LPTIM1_IRQHandler,Default_Handler
-
-   .weak      LPTIM2_IRQHandler
-   .thumb_set LPTIM2_IRQHandler,Default_Handler
-
-   .weak      OTG_FS_IRQHandler
-   .thumb_set OTG_FS_IRQHandler,Default_Handler
-
-   .weak      DMA2_Channel6_IRQHandler
-   .thumb_set DMA2_Channel6_IRQHandler,Default_Handler
-
-   .weak      DMA2_Channel7_IRQHandler
-   .thumb_set DMA2_Channel7_IRQHandler,Default_Handler
-
-   .weak      LPUART1_IRQHandler
-   .thumb_set LPUART1_IRQHandler,Default_Handler
-
-   .weak      QUADSPI_IRQHandler
-   .thumb_set QUADSPI_IRQHandler,Default_Handler
-
-   .weak      I2C3_EV_IRQHandler
-   .thumb_set I2C3_EV_IRQHandler,Default_Handler
-
-   .weak      I2C3_ER_IRQHandler
-   .thumb_set I2C3_ER_IRQHandler,Default_Handler
-
-   .weak      SAI1_IRQHandler
-   .thumb_set SAI1_IRQHandler,Default_Handler
-
-   .weak      SAI2_IRQHandler
-   .thumb_set SAI2_IRQHandler,Default_Handler
-
-   .weak      SWPMI1_IRQHandler
-   .thumb_set SWPMI1_IRQHandler,Default_Handler
-
-   .weak      TSC_IRQHandler
-   .thumb_set TSC_IRQHandler,Default_Handler
-
-   .weak      LCD_IRQHandler
-   .thumb_set LCD_IRQHandler,Default_Handler
-
-   .weak      RNG_IRQHandler
-   .thumb_set RNG_IRQHandler,Default_Handler
-
-   .weak      FPU_IRQHandler
-   .thumb_set FPU_IRQHandler,Default_Handler
-
-   .weak      CRS_IRQHandler
-   .thumb_set CRS_IRQHandler,Default_Handler
-
-   .weak      I2C4_EV_IRQHandler
-   .thumb_set I2C4_EV_IRQHandler,Default_Handler
-
-   .weak      I2C4_ER_IRQHandler
-   .thumb_set I2C4_ER_IRQHandler,Default_Handler
-
-   .weak      DCMI_IRQHandler
-   .thumb_set DCMI_IRQHandler,Default_Handler
-
-   .weak      CAN2_TX_IRQHandler
-   .thumb_set CAN2_TX_IRQHandler,Default_Handler
-
-   .weak      CAN2_RX0_IRQHandler
-   .thumb_set CAN2_RX0_IRQHandler,Default_Handler
-
-   .weak      CAN2_RX1_IRQHandler
-   .thumb_set CAN2_RX1_IRQHandler,Default_Handler
-
-   .weak      CAN2_SCE_IRQHandler
-   .thumb_set CAN2_SCE_IRQHandler,Default_Handler
-
-   .weak      DMA2D_IRQHandler
-   .thumb_set DMA2D_IRQHandler,Default_Handler
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
diff --git a/ports/stm32/boards/stm32f091xc.ld b/ports/stm32/boards/stm32f091xc.ld
index 73b8442957dc9..5bcc4c7275de6 100644
--- a/ports/stm32/boards/stm32f091xc.ld
+++ b/ports/stm32/boards/stm32f091xc.ld
@@ -14,13 +14,13 @@ MEMORY
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* Define tho top end of the stack.  The stack is full descending so begins just
-   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
-   aligned for a call. */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 6K; /* tunable */
 
 /* RAM extents for the garbage collector */
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x20006800; /* room for a 6k stack */
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32f0xx_hal_conf_base.h b/ports/stm32/boards/stm32f0xx_hal_conf_base.h
new file mode 100644
index 0000000000000..9cb7761ac2ca4
--- /dev/null
+++ b/ports/stm32/boards/stm32f0xx_hal_conf_base.h
@@ -0,0 +1,90 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_STM32F0XX_HAL_CONF_BASE_H
+#define MICROPY_INCLUDED_STM32F0XX_HAL_CONF_BASE_H
+
+// Include various HAL modules for convenience
+#include "stm32f0xx_hal_dma.h"
+#include "stm32f0xx_hal_adc.h"
+#include "stm32f0xx_hal_can.h"
+#include "stm32f0xx_hal_cortex.h"
+#include "stm32f0xx_hal_crc.h"
+#include "stm32f0xx_hal_dac.h"
+#include "stm32f0xx_hal_flash.h"
+#include "stm32f0xx_hal_gpio.h"
+#include "stm32f0xx_hal_i2c.h"
+#include "stm32f0xx_hal_i2s.h"
+#include "stm32f0xx_hal_iwdg.h"
+#include "stm32f0xx_hal_pcd.h"
+#include "stm32f0xx_hal_pwr.h"
+#include "stm32f0xx_hal_rcc.h"
+#include "stm32f0xx_hal_rtc.h"
+#include "stm32f0xx_hal_spi.h"
+#include "stm32f0xx_hal_tim.h"
+#include "stm32f0xx_hal_uart.h"
+#include "stm32f0xx_hal_usart.h"
+#include "stm32f0xx_hal_wwdg.h"
+
+// Enable various HAL modules
+#define HAL_MODULE_ENABLED
+#define HAL_ADC_MODULE_ENABLED
+#define HAL_CAN_MODULE_ENABLED
+#define HAL_CORTEX_MODULE_ENABLED
+#define HAL_CRC_MODULE_ENABLED
+#define HAL_DAC_MODULE_ENABLED
+#define HAL_DMA_MODULE_ENABLED
+#define HAL_FLASH_MODULE_ENABLED
+#define HAL_GPIO_MODULE_ENABLED
+#define HAL_I2C_MODULE_ENABLED
+#define HAL_I2S_MODULE_ENABLED
+#define HAL_IWDG_MODULE_ENABLED
+#define HAL_PCD_MODULE_ENABLED
+#define HAL_PWR_MODULE_ENABLED
+#define HAL_RCC_MODULE_ENABLED
+#define HAL_RTC_MODULE_ENABLED
+#define HAL_SPI_MODULE_ENABLED
+#define HAL_TIM_MODULE_ENABLED
+#define HAL_UART_MODULE_ENABLED
+#define HAL_USART_MODULE_ENABLED
+#define HAL_WWDG_MODULE_ENABLED
+
+// Oscillator values in Hz
+#define HSI_VALUE   (8000000)
+#define HSI48_VALUE (48000000)
+#define LSI_VALUE   (40000)
+
+// SysTick has the highest priority
+#define TICK_INT_PRIORITY (0x00)
+
+// Miscellaneous HAL settings
+#define PREFETCH_ENABLE 1
+#define USE_RTOS        0
+#define USE_SPI_CRC     1
+
+// HAL parameter assertions are disabled
+#define assert_param(expr) ((void)0)
+
+#endif // MICROPY_INCLUDED_STM32F0XX_HAL_CONF_BASE_H
diff --git a/ports/stm32/boards/stm32f401xd.ld b/ports/stm32/boards/stm32f401xd.ld
index 7c0e790185620..f4146abc6d728 100644
--- a/ports/stm32/boards/stm32f401xd.ld
+++ b/ports/stm32/boards/stm32f401xd.ld
@@ -14,15 +14,15 @@ MEMORY
 
 /* produce a link error if there is not this amount of RAM for these sections */
 _minimum_stack_size = 2K;
-_minimum_heap_size = 16K;
+_minimum_heap_size = 16K; /* tunable */
 
-/* Define tho top end of the stack.  The stack is full descending so begins just
-   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
-   aligned for a call. */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 16K;
 
 /* RAM extents for the garbage collector */
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x20014000; /* tunable */
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32f401xe.ld b/ports/stm32/boards/stm32f401xe.ld
index e76bbad1c2dee..e7bd8edfed1fb 100644
--- a/ports/stm32/boards/stm32f401xe.ld
+++ b/ports/stm32/boards/stm32f401xe.ld
@@ -16,13 +16,13 @@ MEMORY
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* Define tho top end of the stack.  The stack is full descending so begins just
-   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
-   aligned for a call. */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 16K; /* tunable */
 
 /* RAM extents for the garbage collector */
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x20014000; /* tunable */
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32f405.ld b/ports/stm32/boards/stm32f405.ld
index 0375491f65aae..b6f5d3057847a 100644
--- a/ports/stm32/boards/stm32f405.ld
+++ b/ports/stm32/boards/stm32f405.ld
@@ -17,13 +17,13 @@ MEMORY
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* Define tho top end of the stack.  The stack is full descending so begins just
-   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
-   aligned for a call. */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 16K; /* tunable */
 
 /* RAM extents for the garbage collector */
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x2001c000; /* tunable */
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32f405_af.csv b/ports/stm32/boards/stm32f405_af.csv
index e6d8fcc2b5b6a..2602db877504d 100644
--- a/ports/stm32/boards/stm32f405_af.csv
+++ b/ports/stm32/boards/stm32f405_af.csv
@@ -1,7 +1,7 @@
 Port,,AF0,AF1,AF2,AF3,AF4,AF5,AF6,AF7,AF8,AF9,AF10,AF11,AF12,AF13,AF14,AF15,
 ,,SYS,TIM1/2,TIM3/4/5,TIM8/9/10/11,I2C1/2/3,SPI1/SPI2/I2S2/I2S2ext,SPI3/I2Sext/I2S3,USART1/2/3/I2S3ext,UART4/5/USART6,CAN1/CAN2/TIM12/13/14,OTG_FS/OTG_HS,ETH,FSMC/SDIO/OTG_FS,DCMI,,,ADC
 PortA,PA0,,TIM2_CH1/TIM2_ETR,TIM5_CH1,TIM8_ETR,,,,USART2_CTS,UART4_TX,,,ETH_MII_CRS,,,,EVENTOUT,ADC123_IN0
-PortA,PA1,,TIM2_CH2,TIM5_CH2,,,,,USART2_RTS,UART4_RX,,,ETH_MII_RX_CLK/ETH_RMII__REF_CLK,,,,EVENTOUT,ADC123_IN1
+PortA,PA1,,TIM2_CH2,TIM5_CH2,,,,,USART2_RTS,UART4_RX,,,ETH_MII_RX_CLK/ETH_RMII_REF_CLK,,,,EVENTOUT,ADC123_IN1
 PortA,PA2,,TIM2_CH3,TIM5_CH3,TIM9_CH1,,,,USART2_TX,,,,ETH_MDIO,,,,EVENTOUT,ADC123_IN2
 PortA,PA3,,TIM2_CH4,TIM5_CH4,TIM9_CH2,,,,USART2_RX,,,OTG_HS_ULPI_D0,ETH_MII_COL,,,,EVENTOUT,ADC123_IN3
 PortA,PA4,,,,,,SPI1_NSS,SPI3_NSS/I2S3_WS,USART2_CK,,,,,OTG_HS_SOF,DCMI_HSYNC,,EVENTOUT,ADC12_IN4
diff --git a/ports/stm32/boards/stm32f411.ld b/ports/stm32/boards/stm32f411.ld
index 9e3e6bc154650..50633118eb240 100644
--- a/ports/stm32/boards/stm32f411.ld
+++ b/ports/stm32/boards/stm32f411.ld
@@ -16,13 +16,13 @@ MEMORY
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* Define tho top end of the stack.  The stack is full descending so begins just
-   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
-   aligned for a call. */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 16K; /* tunable */
 
 /* RAM extents for the garbage collector */
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x2001c000; /* tunable */
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32f412_af.csv b/ports/stm32/boards/stm32f412_af.csv
new file mode 100644
index 0000000000000..90eb3d1df6503
--- /dev/null
+++ b/ports/stm32/boards/stm32f412_af.csv
@@ -0,0 +1,116 @@
+Port,,AF0,AF1,AF2,AF3,AF4,AF5,AF6,AF7,AF8,AF9,AF10,AF11,AF12,AF13,AF14,AF15,
+,,SYS_AF,TIM1/TIM2,TIM3/TIM4/TIM5,TIM8/9/10/11,I2C1/2/3/I2CFMP1,SPI1/2/3/4/I2S1/2/3/4,SPI2/3/4/5/I2S2/3/4/5/DFSDM1/2,SPI3/I2S3/USART1/2/3,USART3/6/CAN1/DFSDM1,I2C2/I2C3/I2CFMP1/CAN1/2/TIM12/13/14/QUADSPI,DFSDM1/QUADSPI/FSMC/OTG1_FS,,FSMC /SDIO,,,SYS_AF,ADC
+PortA,PA0,,TIM2_CH1/TIM2_ETR,TIM5_CH1,TIM8_ETR,,,,USART2_CTS,,,,,,,,EVENTOUT,ADC1_IN0
+PortA,PA1,,TIM2_CH2,TIM5_CH2,,,SPI4_MOSI/I2S4_SD,,USART2_RTS,,QUADSPI_BK1_IO3,,,,,,EVENTOUT,ADC1_IN1
+PortA,PA2,,TIM2_CH3,TIM5_CH3,TIM9_CH1,,I2S2_CKIN,,USART2_TX,,,,,FSMC_D4,,,EVENTOUT,ADC1_IN2
+PortA,PA3,,TIM2_CH4,TIM5_CH4,TIM9_CH2,,I2S2_MCK,,USART2_RX,,,,,FSMC_D5,,,EVENTOUT,ADC1_IN3
+PortA,PA4,,,,,,SPI1_NSS/I2S1_WS,SPI3_NSS/I2S3_WS,USART2_CK,DFSDM1_DATIN1,,,,FSMC_D6,,,EVENTOUT,ADC1_IN4
+PortA,PA5,,TIM2_CH1/TIM2_ETR,,TIM8_CH1N,,SPI1_SCK/I2S1_CK,,,DFSDM1_CKIN1,,,,FSMC_D7,,,EVENTOUT,ADC1_IN5
+PortA,PA6,,TIM1_BKIN,TIM3_CH1,TIM8_BKIN,,SPI1_MISO,I2S2_MCK,,,TIM13_CH1,QUADSPI_BK2_IO0,,SDIO_CMD,,,EVENTOUT,ADC1_IN6
+PortA,PA7,,TIM1_CH1N,TIM3_CH2,TIM8_CH1N,,SPI1_MOSI/I2S1_SD,,,,TIM14_CH1,QUADSPI_BK2_IO1,,,,,EVENTOUT,ADC1_IN7
+PortA,PA8,MCO_1,TIM1_CH1,,,I2C3_SCL,,DFSDM1_CKOUT,USART1_CK,,,USB_FS_SOF,,SDIO_D1,,,EVENTOUT,
+PortA,PA9,,TIM1_CH2,,,I2C3_SMBA,SPI2_SCK/I2S2_CK,,USART1_TX,,,USB_FS_VBUS,,SDIO_D2,,,EVENTOUT,
+PortA,PA10,,TIM1_CH3,,,,SPI2_MOSI/I2S2_SD,SPI5_MOSI/I2S5_SD,USART1_RX,,,USB_FS_ID,,,,,EVENTOUT,
+PortA,PA11,,TIM1_CH4,,,,SPI2_NSS/I2S2_WS,SPI4_MISO,USART1_CTS,USART6_TX,CAN1_RX,USB_FS_DM,,,,,EVENTOUT,
+PortA,PA12,,TIM1_ETR,,,,SPI2_MISO,SPI5_MISO,USART1_RTS,USART6_RX,CAN1_TX,USB_FS_DP,,,,,EVENTOUT,
+PortA,PA13,JTMS/SWDIO,,,,,,,,,,,,,,,EVENTOUT,
+PortA,PA14,JTCK/SWCLK,,,,,,,,,,,,,,,EVENTOUT,
+PortA,PA15,JTDI,TIM2_CH1/TIM2_ETR,,,,SPI1_NSS/I2S1_WS,SPI3_NSS/I2S3_WS,USART1_TX,,,,,,,,EVENTOUT,
+PortB,PB0,,TIM1_CH2N,TIM3_CH3,TIM8_CH2N,,,SPI5_SCK/I2S5_CK,,,,,,,,,EVENTOUT,ADC1_IN8
+PortB,PB1,,TIM1_CH3N,TIM3_CH4,TIM8_CH3N,,,SPI5_NSS/I2S5_WS,,DFSDM1_DATIN0,QUADSPI_CLK,,,,,,EVENTOUT,ADC1_IN9
+PortB,PB2,,,,,,,DFSDM1_CKIN0,,,QUADSPI_CLK,,,,,,EVENTOUT,
+PortB,PB3,JTDO,TIM2_CH2,,,I2CFMP1_SDA,SPI1_SCK/I2S1_CK,SPI3_SCK/I2S3_CK,USART1_RX,UART7_RX,I2C2_SDA,,,,,,EVENTOUT,
+PortB,PB4,JTRST,,TIM3_CH1,,,SPI1_MISO,SPI3_MISO,I2S3ext_SD,UART7_TX,I2C3_SDA,,,SDIO_D0,,,EVENTOUT,
+PortB,PB5,,,TIM3_CH2,,I2C1_SMBA,SPI1_MOSI/I2S1_SD,SPI3_MOSI/I2S3_SD,,,CAN2_RX,,,SDIO_D3,,,EVENTOUT,
+PortB,PB6,,,TIM4_CH1,,I2C1_SCL,,DFSDM2_CKIN7,USART1_TX,,CAN2_TX,QUADSPI_BK1_NCS,,SDIO_D0,,,EVENTOUT,
+PortB,PB7,,,TIM4_CH2,,I2C1_SDA,,DFSDM2_DATIN7,USART1_RX,,,,,FSMC_NL,,,EVENTOUT,
+PortB,PB8,,,TIM4_CH3,TIM10_CH1,I2C1_SCL,,SPI5_MOSI/I2S5_SD,,CAN1_RX,I2C3_SDA,,,SDIO_D4,,,EVENTOUT,
+PortB,PB9,,,TIM4_CH4,TIM11_CH1,I2C1_SDA,SPI2_NSS/I2S2_WS,DFSDM2_DATIN1,,CAN1_TX,I2C2_SDA,,,SDIO_D5,,,EVENTOUT,
+PortB,PB10,,TIM2_CH3,,,I2C2_SCL,SPI2_SCK/I2S2_CK,I2S3_MCK,USART3_TX,,I2CFMP4_SCL,,,SDIO_D7,,,EVENTOUT,
+PortB,PB11,,TIM2_CH4,,,I2C2_SDA,I2S2_CKIN,,USART3_RX,,,,,,,,EVENTOUT,
+PortB,PB12,,TIM1_BKIN,,,I2C2_SMBA,SPI2_NSS/I2S2_WS,SPI4_NSS/I2S4_WS,SPI3_SCK/I2S3_CK,USART3__CK,CAN2_RX,DFSDM1_DATIN1,,FSMC_D13/FSMC_DA13,,,EVENTOUT,
+PortB,PB13,,TIM1_CH1N,,,I2CFMP1_SMBA,SPI2_SCK/I2S2_CK,SPI4_SCK/I2S4_CK,,USART3_CTS,CAN2_TX,DFSDM1_CKIN1,,,,,EVENTOUT,
+PortB,PB14,,TIM1_CH2N,,TIM8_CH2N,I2CFMP1_SDA,SPI2_MISO,I2S2ext_SD,USART3_RTS,DFSDM1_DATIN2,TIM12_CH1,FSMC_D0,,SDIO_D6,,,EVENTOUT,
+PortB,PB15,RTC_50HZ,TIM1_CH3N,,TIM8_CH3N,I2CFMP1_SCL,SPI2_MOSI/I2S2_SD,,,DFSDM1_CKIN2,TIM12_CH2,,,SDIO_CK,,,EVENTOUT,
+PortC,PC0,,,,,,,,SAI1_MCLK_B,,,,,,,,EVENTOUT,ADC1_IN10
+PortC,PC1,,,,,,,,SAI1_SD_B,,,,,,,,EVENTOUT,ADC1_IN11
+PortC,PC2,,,,,,SPI2_MISO,I2S2ext_SD,SAI1_SCK_B,DFSDM1_CKOUT,,,,FSMC_NWE,,,EVENTOUT,ADC1_IN12
+PortC,PC3,,,,,,SPI2_MOSI/I2S2_SD,,SAI1_FS_B,,,,,FSMC_A0,,,EVENTOUT,ADC1_IN13
+PortC,PC4,,,,,,I2S1_MCK,,,,,QUADSPI_BK2_IO2,,FSMC_NE4,,,EVENTOUT,ADC1_IN14
+PortC,PC5,,,,,I2CFMP1_SMBA,,,USART3_RX,,,QUADSPI_BK2_IO3,,FSMC_NOE,,,EVENTOUT,ADC1_IN15
+PortC,PC6,,,TIM3_CH1,TIM8_CH1,2CFMP1_SCL,I2S2_MCK,DFSDM1_CKIN3,,USART6_TX,,FSMC_D1,,SDIO_D6,,,EVENTOUT,
+PortC,PC7,,,TIM3_CH2,TIM8_CH2,I2CFMP1_SDA,SPI2_SCK/I2S2_CK,I2S3_MCK,,USART6_RX,,DFSDM1_DATIN3,,SDIO_D7,,,EVENTOUT,
+PortC,PC8,,,TIM3_CH3,TIM8_CH3,,,,,USART6_CK,QUADSPI_BK1_IO2,,,SDIO_D0,,,EVENTOUT,
+PortC,PC9,MCO_2,,TIM3_CH4,TIM8_CH4,I2C3_SDA,I2S2_CKIN,,,,QUADSPI_BK1_IO0,,,SDIO_D1,,,EVENTOUT,
+PortC,PC10,,,,,,,SPI3_SCK/I2S3_CK,USART3_TX,,QUADSPI_BK1_IO1,,,SDIO_D2,,,EVENTOUT,
+PortC,PC11,,,,,,I2S3ext_SD,SPI3_MISO,USART3_RX,,QUADSPI_BK2_NCS,FSMC_D2,,SDIO_D3,,,EVENTOUT,
+PortC,PC12,,,,,,,SPI3_MOSI/I2S3_SD,USART3_CK,,,FSMC_D3,,SDIO_CK,,,EVENTOUT,
+PortC,PC13,,,,,,,,,,,,,,,,EVENTOUT,
+PortC,PC14,,,,,,,,,,,,,,,,EVENTOUT,
+PortC,PC15,,,,,,,,,,,,,,,,EVENTOUT,
+PortD,PD0,,,,,,,,,,CAN1_RX,,,FSMC_D2/FSMC_DA2,,,EVENTOUT,
+PortD,PD1,,,,,,,,,,CAN1_TX,,,FSMC_D3/FSMC_DA3,,,EVENTOUT,
+PortD,PD2,,,TIM3_ETR,,,,,,,,FSMC_NWE,,SDIO_CMD,,,EVENTOUT,
+PortD,PD3,TRACED1,,,,,SPI2_SCK/I2S2_CK,DFSDM1_DATIN0,USART2_CTS,,QUADSPI_CLK,,,FSMC_CLK,,,EVENTOUT,
+PortD,PD4,,,,,,,DFSDM1_CKIN0,USART2_RTS,,,,,FSMC_NOE,,,EVENTOUT,
+PortD,PD5,,,,,,,,USART2_TX,,,,,FSMC_NWE,,,EVENTOUT,
+PortD,PD6,,,,,,SPI3_MOSI/I2S3_SD,DFSDM1_DATIN1,USART2_RX,,,,,FSMC_NWAIT,,,EVENTOUT,
+PortD,PD7,,,,,,,DFSDM1_CKIN1,USART2_CK,,,,,FSMC_NE1,,,EVENTOUT,
+PortD,PD8,,,,,,,,USART3_TX,,,,,FSMC_D13/FSMC_DA13,,,EVENTOUT,
+PortD,PD9,,,,,,,,USART3_RX,,,,,FSMC_D14/FSMC_DA14,,,EVENTOUT,
+PortD,PD10,,,,,,,,USART3_CK,,,,,FSMC_D15/FSMC_DA15,,,EVENTOUT,
+PortD,PD11,,,,,I2CFMP1_SMBA,,,USART3_CTS,,QUADSPI_BK1_IO0,,,FSMC_A16,,,EVENTOUT,
+PortD,PD12,,,TIM4_CH1,,I2CFMP1_SCL,,,USART3_RTS,,QUADSPI_BK1_IO1,,,FSMC_A17,,,EVENTOUT,
+PortD,PD13,,,TIM4_CH2,,I2CFMP1_SDA,,,,,QUADSPI_BK1_IO3,,,FSMC_A18,,,EVENTOUT,
+PortD,PD14,,,TIM4_CH3,,I2CFMP1_SCL,,,,,,,,FSMC_D0/FSMC_DA0,,,EVENTOUT,
+PortD,PD15,,,TIM4_CH4,,I2CFMP1_SDA,,,,,,,,FSMC_D1/FSMC_DA1,,,EVENTOUT,
+PortE,PE0,,,TIM4_ETR,,,,,,,,,,FSMC_NBL0,,,EVENTOUT,
+PortE,PE1,,,,,,,,,,,,,FSMC_NBL1,,,EVENTOUT,
+PortE,PE2,TRACECLK,,,,,SPI4_SCK/I2S4_CK,SPI5_SCK/I2S5_CK,SAI1_MCLK_A,,QUADSPI_BK1_IO2,,,FSMC_A23,,,EVENTOUT,
+PortE,PE3,TRACED0,,,,,,,SAI1_SD_B,,,,,FSMC_A19,,,EVENTOUT,
+PortE,PE4,TRACED1,,,,,SPI4_NSS/I2S4_WS,SPI5_NSS/I2S5_WS,SAI1_SD_A,DFSDM1_DATIN3,,,,FSMC_A20,,,EVENTOUT,
+PortE,PE5,TRACED2,,,TIM9_CH1,,SPI4_MISO,SPI5_MISO,SAI1_SCK_A,DFSDM1_CKIN3,,,,FSMC_A21,,,EVENTOUT,
+PortE,PE6,TRACED3,,,TIM9_CH2,,SPI4_MOSI/I2S4_SD,SPI5_MOSI/I2S5_SD,SAI1_FS_A,,,,,FSMC_A22,,,EVENTOUT,
+PortE,PE7,,TIM1_ETR,,,,,DFSDM1_DATIN2,,,,QUADSPI_BK2_IO0,,FSMC_D4/FSMC_DA4,,,EVENTOUT,
+PortE,PE8,,TIM1_CH1N,,,,,DFSDM1_CKIN2,,,,QUADSPI_BK2_IO1,,FSMC_D5/FSMC_DA5,,,EVENTOUT,
+PortE,PE9,,TIM1_CH1,,,,,DFSDM1_CKOUT,,,,QUADSPI_BK2_IO2,,FSMC_D6/FSMC_DA6,,,EVENTOUT,
+PortE,PE10,,TIM1_CH2N,,,,,,,,,QUADSPI_BK2_IO3,,FSMC_D7/FSMC_DA7,,,EVENTOUT,
+PortE,PE11,,TIM1_CH2,,,,SPI4_NSS/I2S4_WS,SPI5_NSS/I2S5_WS,,,,,,FSMC_D8/FSMC_DA8,,,EVENTOUT,
+PortE,PE12,,TIM1_CH3N,,,,SPI4_SCK/I2S4_CK,SPI5_SCK/I2S5_CK,,,,,,FSMC_D9/FSMC_DA9,,,EVENTOUT,
+PortE,PE13,,TIM1_CH3,,,,SPI4_MISO,SPI5_MISO,,,,,,FSMC_D10/FSMC_DA10,,,EVENTOUT,
+PortE,PE14,,TIM1_CH4,,,,SPI4_MOSI/I2S4_SD,SPI5_MOSI/I2S5_SD,,,,,,FSMC_D11/FSMC_DA11,,,EVENTOUT,
+PortE,PE15,,TIM1_BKIN,,,,,,,,,,,FSMC_D12/FSMC_DA12,,,EVENTOUT,
+PortF,PF0,,,,,I2C2_SDA,,,,,,,,FSMC_A0,,,EVENTOUT,
+PortF,PF1,,,,,I2C2_SCL,,,,,,,,FSMC_A1,,,EVENTOUT,
+PortF,PF2,,,,,I2C2_SMBA,,,,,,,,FSMC_A2,,,EVENTOUT,
+PortF,PF3,,,TIM5_CH1,,,,,,,,,,FSMC_A3,,,EVENTOUT,
+PortF,PF4,,,TIM5_CH2,,,,,,,,,,FSMC_A4,,,EVENTOUT,
+PortF,PF5,,,TIM5_CH3,,,,,,,,,,FSMC_A5,,,EVENTOUT,
+PortF,PF6,TRACED0,,,TIM10_CH1,,,,SAI1_SD_B,,QUADSPI_BK1_IO3,,,,,,EVENTOUT,
+PortF,PF7,TRACED1,,,TIM11_CH1,,,,SAI1_MCLK_B,,QUADSPI_BK1_IO2,,,,,,EVENTOUT,
+PortF,PF8,,,,,,,,SAI1_SCK_B,,TIM13_CH1,QUADSPI_BK1_IO0,,,,,EVENTOUT,
+PortF,PF9,,,,,,,,SAI1_FS_B,,TIM14_CH1,QUADSPI_BK1_IO1,,,,,EVENTOUT,
+PortF,PF10,,TIM1_ETR,TIM5_CH4,,,,,,,,,,,,,EVENTOUT,
+PortF,PF11,,,,TIM8_ETR,,,,,,,,,,,,EVENTOUT,
+PortF,PF12,,,,TIM8_BKIN,,,,,,,,,FSMC_A6,,,EVENTOUT,
+PortF,PF13,,,,,I2CFMP1_SMBA,,,,,,,,FSMC_A7,,,EVENTOUT,
+PortF,PF14,,,,,I2CFMP1_SCL,,,,,,,,FSMC_A8,,,EVENTOUT,
+PortF,PF15,,,,,I2CFMP1_SDA,,,,,,,,FSMC_A9,,,EVENTOUT,
+PortG,PG0,,,,,,,,,,CAN1_RX,,,FSMC_A10,,,EVENTOUT,
+PortG,PG1,,,,,,,,,,CAN1_TX,,,FSMC_A11,,,EVENTOUT,
+PortG,PG2,,,,,,,,,,,,,FSMC_A12,,,EVENTOUT,
+PortG,PG3,,,,,,,,,,,,,FSMC_A13,,,EVENTOUT,
+PortG,PG4,,,,,,,,,,,,,FSMC_A14,,,EVENTOUT,
+PortG,PG5,,,,,,,,,,,,,FSMC_A15,,,EVENTOUT,
+PortG,PG6,,,,,,,,,,,QUADSPI_BK1_NCS,,,,,EVENTOUT,
+PortG,PG7,,,,,,,,,USART6_CK,,,,,,,EVENTOUT,
+PortG,PG8,,,,,,,,,USART6_RTS,,,,,,,EVENTOUT,
+PortG,PG9,,,,,,,,,USART6_RX,QUADSPI_BK2_IO2,,,FSMC_NE2,,,EVENTOUT,
+PortG,PG10,,,,,,,,,,,,,FSMC_NE3,,,EVENTOUT,
+PortG,PG11,,,,,,,,,,CAN2_RX,,,,,,EVENTOUT,
+PortG,PG12,,,,,,,,,USART6_RTS,CAN2_TX,,,FSMC_NE4,,,EVENTOUT,
+PortG,PG13,TRACED2,,,,,,,,USART6_CTS,,,,FSMC_A24,,,EVENTOUT,
+PortG,PG14,TRACED3,,,,,,,,USART6_TX,QUADSPI_BK2_IO3,,,FSMC_A25,,,EVENTOUT,
+PortG,PG15,,,,,,,,,USART6_CTS,,,,,,,EVENTOUT,
+PortH,PH0,,,,,,,,,,,,,,,,EVENTOUT,
+PortH,PH1,,,,,,,,,,,,,,,,EVENTOUT,
diff --git a/ports/stm32/boards/stm32f412zx.ld b/ports/stm32/boards/stm32f412zx.ld
new file mode 100644
index 0000000000000..55aa608657383
--- /dev/null
+++ b/ports/stm32/boards/stm32f412zx.ld
@@ -0,0 +1,28 @@
+/*
+    GNU linker script for STM32F412zx (1MB flash, 256kB RAM)
+*/
+
+/* Specify the memory areas */
+MEMORY
+{
+    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 1024K /* entire flash */
+    FLASH_ISR (rx)  : ORIGIN = 0x08000000, LENGTH = 16K /* sector 0 */
+    FLASH_FS (rx)   : ORIGIN = 0x08004000, LENGTH = 112K /* sectors 1,2,3 are 16K, 4 is 64K */
+    FLASH_TEXT (rx) : ORIGIN = 0x08020000, LENGTH = 896K /* sectors 5,6,7,8,9,10,11 are 128K */
+    RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 256K
+}
+
+/* produce a link error if there is not this amount of RAM for these sections */
+_minimum_stack_size = 2K;
+_minimum_heap_size = 16K;
+
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 16K; /* tunable */
+
+/* RAM extents for the garbage collector */
+_ram_start = ORIGIN(RAM);
+_ram_end = ORIGIN(RAM) + LENGTH(RAM);
+_heap_start = _ebss; /* heap starts just after statically allocated memory */
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32f413_af.csv b/ports/stm32/boards/stm32f413_af.csv
new file mode 100644
index 0000000000000..428ce44cfcbbe
--- /dev/null
+++ b/ports/stm32/boards/stm32f413_af.csv
@@ -0,0 +1,116 @@
+Port,,AF0,AF1,AF2,AF3,AF4,AF5,AF6,AF7,AF8,AF9,AF10,AF11,AF12,AF13,AF14,AF15,
+,,SYS_AF,TIM1/TIM2/LPTIM1,TIM3/TIM4/TIM5,TIM8/9/10/11/DFSDM2,I2C1/2/3/I2CFMP1,SPI1/2/3/4/I2S1/2/3/4,SPI2/3/4/5/I2S2/3/4/5/DFSDM1/2,SPI3/I2S3/USART1/2/3/DFSDM2,USART3/4/5/6/7/8/CAN1/DFSDM1,I2C2/I2C3/I2CFMP1/CAN1/2/TIM12/13/14/QUADSPI,SAI1/DFSDM1/DFSDM2/QUADSPI/FSMC/OTG1_FS,UART4/5/9/10/CAN3,FSMC /SDIO,,RNG,SYS_AF,ADC
+PortA,PA0,,TIM2_CH1/TIM2_ETR,TIM5_CH1,TIM8_ETR,,,,USART2_CTS,UART4_TX,,,,,,,EVENTOUT,ADC1_IN0
+PortA,PA1,,TIM2_CH2,TIM5_CH2,,,SPI4_MOSI/I2S4_SD,,USART2_RTS,UART4_RX,QUADSPI_BK1_IO3,,,,,,EVENTOUT,ADC1_IN1
+PortA,PA2,,TIM2_CH3,TIM5_CH3,TIM9_CH1,,I2S2_CKIN,,USART2_TX,,,,,FSMC_D4,,,EVENTOUT,ADC1_IN2
+PortA,PA3,,TIM2_CH4,TIM5_CH4,TIM9_CH2,,I2S2_MCK,,USART2_RX,,,SAI1_SD_B,,FSMC_D5,,,EVENTOUT,ADC1_IN3
+PortA,PA4,,,,,,SPI1_NSS/I2S1_WS,SPI3_NSS/I2S3_WS,USART2_CK,DFSDM1_DATIN1,,,,FSMC_D6,,,EVENTOUT,ADC1_IN4
+PortA,PA5,,TIM2_CH1/TIM2_ETR,,TIM8_CH1N,,SPI1_SCK/I2S1_CK,,,DFSDM1_CKIN1,,,,FSMC_D7,,,EVENTOUT,ADC1_IN5
+PortA,PA6,,TIM1_BKIN,TIM3_CH1,TIM8_BKIN,,SPI1_MISO,I2S2_MCK,DFSDM2_CKIN1,,TIM13_CH1,QUADSPI_BK2_IO0,,SDIO_CMD,,,EVENTOUT,ADC1_IN6
+PortA,PA7,,TIM1_CH1N,TIM3_CH2,TIM8_CH1N,,SPI1_MOSI/I2S1_SD,,DFSDM2_DATIN1,,TIM14_CH1,QUADSPI_BK2_IO1,,,,,EVENTOUT,ADC1_IN7
+PortA,PA8,MCO_1,TIM1_CH1,,,I2C3_SCL,,DFSDM1_CKOUT,USART1_CK,UART7_RX,,USB_FS_SOF,CAN3_RX,SDIO_D1,,,EVENTOUT,
+PortA,PA9,,TIM1_CH2,,DFSDM2_CKIN3,I2C3_SMBA,SPI2_SCK/I2S2_CK,,USART1_TX,,,USB_FS_VBUS,,SDIO_D2,,,EVENTOUT,
+PortA,PA10,,TIM1_CH3,,DFSDM2_DATIN3,,SPI2_MOSI/I2S2_SD,SPI5_MOSI/I2S5_SD,USART1_RX,,,USB_FS_ID,,,,,EVENTOUT,
+PortA,PA11,,TIM1_CH4,,DFSDM2_CKIN5,,SPI2_NSS/I2S2_WS,SPI4_MISO,USART1_CTS,USART6_TX,CAN1_RX,USB_FS_DM,UART4_RX,,,,EVENTOUT,
+PortA,PA12,,TIM1_ETR,,DFSDM2_DATIN5,,SPI2_MISO,SPI5_MISO,USART1_RTS,USART6_RX,CAN1_TX,USB_FS_DP,UART4_TX,,,,EVENTOUT,
+PortA,PA13,JTMS/SWDIO,,,,,,,,,,,,,,,EVENTOUT,
+PortA,PA14,JTCK/SWCLK,,,,,,,,,,,,,,,EVENTOUT,
+PortA,PA15,JTDI,TIM2_CH1/TIM2_ETR,,,,SPI1_NSS/I2S1_WS,SPI3_NSS/I2S3_WS,USART1_TX,UART7_TX,,SAI1_MCLK_A,CAN3_TX,,,,EVENTOUT,
+PortB,PB0,,TIM1_CH2N,TIM3_CH3,TIM8_CH2N,,,SPI5_SCK/I2S5_CK,,,,,,,,,EVENTOUT,ADC1_IN8
+PortB,PB1,,TIM1_CH3N,TIM3_CH4,TIM8_CH3N,,,SPI5_NSS/I2S5_WS,,DFSDM1_DATIN0,QUADSPI_CLK,,,,,,EVENTOUT,ADC1_IN9
+PortB,PB2,,LPTIM1_OUT,,,,,DFSDM1_CKIN0,,,QUADSPI_CLK,,,,,,EVENTOUT,
+PortB,PB3,JTDO,TIM2_CH2,,,I2CFMP1_SDA,SPI1_SCK/I2S1_CK,SPI3_SCK/I2S3_CK,USART1_RX,UART7_RX,I2C2_SDA,SAI1_SD_A,CAN3_RX,,,,EVENTOUT,
+PortB,PB4,JTRST,,TIM3_CH1,,,SPI1_MISO,SPI3_MISO,I2S3ext_SD,UART7_TX,I2C3_SDA,SAI1_SCK_A,CAN3_TX,SDIO_D0,,,EVENTOUT,
+PortB,PB5,,LPTIM1_IN1,TIM3_CH2,,I2C1_SMBA,SPI1_MOSI/I2S1_SD,SPI3_MOSI/I2S3_SD,,,CAN2_RX,SAI1_FS_A,UART5_RX,SDIO_D3,,,EVENTOUT,
+PortB,PB6,,LPTIM1_ETR,TIM4_CH1,,I2C1_SCL,,DFSDM2_CKIN7,USART1_TX,,CAN2_TX,QUADSPI_BK1_NCS,UART5_TX,SDIO_D0,,,EVENTOUT,
+PortB,PB7,,LPTIM1_IN2,TIM4_CH2,,I2C1_SDA,,DFSDM2_DATIN7,USART1_RX,,,,,FSMC_NL,,,EVENTOUT,
+PortB,PB8,,LPTIM1_OUT,TIM4_CH3,TIM10_CH1,I2C1_SCL,,SPI5_MOSI/I2S5_SD,DFSDM2_CKIN1,CAN1_RX,I2C3_SDA,,UART5_RX,SDIO_D4,,,EVENTOUT,
+PortB,PB9,,,TIM4_CH4,TIM11_CH1,I2C1_SDA,SPI2_NSS/I2S2_WS,DFSDM2_DATIN1,,CAN1_TX,I2C2_SDA,,UART5_TX,SDIO_D5,,,EVENTOUT,
+PortB,PB10,,TIM2_CH3,,,I2C2_SCL,SPI2_SCK/I2S2_CK,I2S3_MCK,USART3_TX,,I2CFMP4_SCL,DFSDM2_CKOUT,,SDIO_D7,,,EVENTOUT,
+PortB,PB11,,TIM2_CH4,,,I2C2_SDA,I2S2_CKIN,,USART3_RX,,,,,,,,EVENTOUT,
+PortB,PB12,,TIM1_BKIN,,,I2C2_SMBA,SPI2_NSS/I2S2_WS,SPI4_NSS/I2S4_WS,SPI3_SCK/I2S3_CK,USART3__CK,CAN2_RX,DFSDM1_DATIN1,UART5_RX,FSMC_D13/FSMC_DA13,,,EVENTOUT,
+PortB,PB13,,TIM1_CH1N,,,I2CFMP1_SMBA,SPI2_SCK/I2S2_CK,SPI4_SCK/I2S4_CK,,USART3_CTS,CAN2_TX,DFSDM1_CKIN1,UART5_TX,,,,EVENTOUT,
+PortB,PB14,,TIM1_CH2N,,TIM8_CH2N,I2CFMP1_SDA,SPI2_MISO,I2S2ext_SD,USART3_RTS,DFSDM1_DATIN2,TIM12_CH1,FSMC_D0,,SDIO_D6,,,EVENTOUT,
+PortB,PB15,RTC_REFIN,TIM1_CH3N,,TIM8_CH3N,I2CFMP1_SCL,SPI2_MOSI/I2S2_SD,,,DFSDM1_CKIN2,TIM12_CH2,,,SDIO_CK,,,EVENTOUT,
+PortC,PC0,,LPTIM1_IN1,,DFSDM2_CKIN4,,,,SAI1_MCLK_B,,,,,,,,EVENTOUT,ADC1_IN10
+PortC,PC1,,LPTIM1_OUT,,DFSDM2_DATIN4,,,,SAI1_SD_B,,,,,,,,EVENTOUT,ADC1_IN11
+PortC,PC2,,LPTIM1_IN2,,DFSDM2_DATIN7,,SPI2_MISO,I2S2ext_SD,SAI1_SCK_B,DFSDM1_CKOUT,,,,FSMC_NWE,,,EVENTOUT,ADC1_IN12
+PortC,PC3,,LPTIM1_ETR,,DFSDM2_CKIN7,,SPI2_MOSI/I2S2_SD,,SAI1_FS_B,,,,,FSMC_A0,,,EVENTOUT,ADC1_IN13
+PortC,PC4,,,,DFSDM2_CKIN2,,I2S1_MCK,,,,,QUADSPI_BK2_IO2,,FSMC_NE4,,,EVENTOUT,ADC1_IN14
+PortC,PC5,,,,DFSDM2_DATIN2,I2CFMP1_SMBA,,,USART3_RX,,,QUADSPI_BK2_IO3,,FSMC_NOE,,,EVENTOUT,ADC1_IN15
+PortC,PC6,,,TIM3_CH1,TIM8_CH1,2CFMP1_SCL,I2S2_MCK,DFSDM1_CKIN3,DFSDM2_DATIN6,USART6_TX,,FSMC_D1,,SDIO_D6,,,EVENTOUT,
+PortC,PC7,,,TIM3_CH2,TIM8_CH2,I2CFMP1_SDA,SPI2_SCK/I2S2_CK,I2S3_MCK,DFSDM2_CKIN6,USART6_RX,,DFSDM1_DATIN3,,SDIO_D7,,,EVENTOUT,
+PortC,PC8,,,TIM3_CH3,TIM8_CH3,,,,DFSDM2_CKIN3,USART6_CK,QUADSPI_BK1_IO2,,,SDIO_D0,,,EVENTOUT,
+PortC,PC9,MCO_2,,TIM3_CH4,TIM8_CH4,I2C3_SDA,I2S2_CKIN,,DFSDM2_DATIN3,,QUADSPI_BK1_IO0,,,SDIO_D1,,,EVENTOUT,
+PortC,PC10,,,,DFSDM2_CKIN5,,,SPI3_SCK/I2S3_CK,USART3_TX,,QUADSPI_BK1_IO1,,,SDIO_D2,,,EVENTOUT,
+PortC,PC11,,,,DFSDM2_DATIN5,,I2S3ext_SD,SPI3_MISO,USART3_RX,UART4_RX,QUADSPI_BK2_NCS,FSMC_D2,,SDIO_D3,,,EVENTOUT,
+PortC,PC12,,,,,,,SPI3_MOSI/I2S3_SD,USART3_CK,UART5_TX,,FSMC_D3,,SDIO_CK,,,EVENTOUT,
+PortC,PC13,,,,,,,,,,,,,,,,EVENTOUT,
+PortC,PC14,,,,,,,,,,,,,,,,EVENTOUT,
+PortC,PC15,,,,,,,,,,,,,,,,EVENTOUT,
+PortD,PD0,,,,DFSDM2_CKIN6,,,,,,CAN1_RX,,UART4_RX,FSMC_D2/FSMC_DA2,,,EVENTOUT,
+PortD,PD1,,,,DFSDM2_DATIN6,,,,,,CAN1_TX,,UART4_TX,FSMC_D3/FSMC_DA3,,,EVENTOUT,
+PortD,PD2,,,TIM3_ETR,DFSDM2_CKOUT,,,,,UART5_RX,,FSMC_NWE,,SDIO_CMD,,,EVENTOUT,
+PortD,PD3,TRACED1,,,,,SPI2_SCK/I2S2_CK,DFSDM1_DATIN0,USART2_CTS,,QUADSPI_CLK,,,FSMC_CLK,,,EVENTOUT,
+PortD,PD4,,,,,,,DFSDM1_CKIN0,USART2_RTS,,,,,FSMC_NOE,,,EVENTOUT,
+PortD,PD5,,,,DFSDM2_CKOUT,,,,USART2_TX,,,,,FSMC_NWE,,,EVENTOUT,
+PortD,PD6,,,,,,SPI3_MOSI/I2S3_SD,DFSDM1_DATIN1,USART2_RX,,,,,FSMC_NWAIT,,,EVENTOUT,
+PortD,PD7,,,,,,,DFSDM1_CKIN1,USART2_CK,,,,,FSMC_NE1,,,EVENTOUT,
+PortD,PD8,,,,,,,,USART3_TX,,,,,FSMC_D13/FSMC_DA13,,,EVENTOUT,
+PortD,PD9,,,,,,,,USART3_RX,,,,,FSMC_D14/FSMC_DA14,,,EVENTOUT,
+PortD,PD10,,,,,,,,USART3_CK,UART4_TX,,,,FSMC_D15/FSMC_DA15,,,EVENTOUT,
+PortD,PD11,,,,DFSDM2_DATIN2,I2CFMP1_SMBA,,,USART3_CTS,,QUADSPI_BK1_IO0,,,FSMC_A16,,,EVENTOUT,
+PortD,PD12,,,TIM4_CH1,DFSDM2_CKIN2,I2CFMP1_SCL,,,USART3_RTS,,QUADSPI_BK1_IO1,,,FSMC_A17,,,EVENTOUT,
+PortD,PD13,,,TIM4_CH2,,I2CFMP1_SDA,,,,,QUADSPI_BK1_IO3,,,FSMC_A18,,,EVENTOUT,
+PortD,PD14,,,TIM4_CH3,,I2CFMP1_SCL,,,,,,DFSDM2_CKIN0,UART9_RX,FSMC_D0/FSMC_DA0,,,EVENTOUT,
+PortD,PD15,,,TIM4_CH4,,I2CFMP1_SDA,,,,,,DFSDM2_DATIN0,UART9_TX,FSMC_D1/FSMC_DA1,,,EVENTOUT,
+PortE,PE0,,,TIM4_ETR,DFSDM2_CKIN4,,,,,UART8_RX,,,,FSMC_NBL0,,,EVENTOUT,
+PortE,PE1,,,,DFSDM2_DATIN4,,,,,UART8_TX,,,,FSMC_NBL1,,,EVENTOUT,
+PortE,PE2,TRACECLK,,,,,SPI4_SCK/I2S4_CK,SPI5_SCK/I2S5_CK,SAI1_MCLK_A,,QUADSPI_BK1_IO2,,UART10_RX,FSMC_A23,,,EVENTOUT,
+PortE,PE3,TRACED0,,,,,,,SAI1_SD_B,,,,UART10_TX,FSMC_A19,,,EVENTOUT,
+PortE,PE4,TRACED1,,,,,SPI4_NSS/I2S4_WS,SPI5_NSS/I2S5_WS,SAI1_SD_A,DFSDM1_DATIN3,,,,FSMC_A20,,,EVENTOUT,
+PortE,PE5,TRACED2,,,TIM9_CH1,,SPI4_MISO,SPI5_MISO,SAI1_SCK_A,DFSDM1_CKIN3,,,,FSMC_A21,,,EVENTOUT,
+PortE,PE6,TRACED3,,,TIM9_CH2,,SPI4_MOSI/I2S4_SD,SPI5_MOSI/I2S5_SD,SAI1_FS_A,,,,,FSMC_A22,,,EVENTOUT,
+PortE,PE7,,TIM1_ETR,,,,,DFSDM1_DATIN2,,UART7_RX,,QUADSPI_BK2_IO0,,FSMC_D4/FSMC_DA4,,,EVENTOUT,
+PortE,PE8,,TIM1_CH1N,,,,,DFSDM1_CKIN2,,UART7_TX,,QUADSPI_BK2_IO1,,FSMC_D5/FSMC_DA5,,,EVENTOUT,
+PortE,PE9,,TIM1_CH1,,,,,DFSDM1_CKOUT,,,,QUADSPI_BK2_IO2,,FSMC_D6/FSMC_DA6,,,EVENTOUT,
+PortE,PE10,,TIM1_CH2N,,DFSDM2_DATIN0,,,,,,,QUADSPI_BK2_IO3,,FSMC_D7/FSMC_DA7,,,EVENTOUT,
+PortE,PE11,,TIM1_CH2,,DFSDM2_CKIN0,,SPI4_NSS/I2S4_WS,SPI5_NSS/I2S5_WS,,,,,,FSMC_D8/FSMC_DA8,,,EVENTOUT,
+PortE,PE12,,TIM1_CH3N,,DFSDM2_DATIN7,,SPI4_SCK/I2S4_CK,SPI5_SCK/I2S5_CK,,,,,,FSMC_D9/FSMC_DA9,,,EVENTOUT,
+PortE,PE13,,TIM1_CH3,,DFSDM2_CKIN7,,SPI4_MISO,SPI5_MISO,,,,,,FSMC_D10/FSMC_DA10,,,EVENTOUT,
+PortE,PE14,,TIM1_CH4,,,,SPI4_MOSI/I2S4_SD,SPI5_MOSI/I2S5_SD,,,,DFSDM2_DATIN1,,FSMC_D11/FSMC_DA11,,,EVENTOUT,
+PortE,PE15,,TIM1_BKIN,,,,,,,,,DFSDM2_CKIN1,,FSMC_D12/FSMC_DA12,,,EVENTOUT,
+PortF,PF0,,,,,I2C2_SDA,,,,,,,,FSMC_A0,,,EVENTOUT,
+PortF,PF1,,,,,I2C2_SCL,,,,,,,,FSMC_A1,,,EVENTOUT,
+PortF,PF2,,,,,I2C2_SMBA,,,,,,,,FSMC_A2,,,EVENTOUT,
+PortF,PF3,,,TIM5_CH1,,,,,,,,,,FSMC_A3,,,EVENTOUT,
+PortF,PF4,,,TIM5_CH2,,,,,,,,,,FSMC_A4,,,EVENTOUT,
+PortF,PF5,,,TIM5_CH3,,,,,,,,,,FSMC_A5,,,EVENTOUT,
+PortF,PF6,TRACED0,,,TIM10_CH1,,,,SAI1_SD_B,UART7_RX,QUADSPI_BK1_IO3,,,,,,EVENTOUT,
+PortF,PF7,TRACED1,,,TIM11_CH1,,,,SAI1_MCLK_B,UART7_TX,QUADSPI_BK1_IO2,,,,,,EVENTOUT,
+PortF,PF8,,,,,,,,SAI1_SCK_B,UART8_RX,TIM13_CH1,QUADSPI_BK1_IO0,,,,,EVENTOUT,
+PortF,PF9,,,,,,,,SAI1_FS_B,UART8_TX,TIM14_CH1,QUADSPI_BK1_IO1,,,,,EVENTOUT,
+PortF,PF10,,TIM1_ETR,TIM5_CH4,,,,,,,,,,,,,EVENTOUT,
+PortF,PF11,,,,TIM8_ETR,,,,,,,,,,,,EVENTOUT,
+PortF,PF12,,,,TIM8_BKIN,,,,,,,,,FSMC_A6,,,EVENTOUT,
+PortF,PF13,,,,,I2CFMP1_SMBA,,,,,,,,FSMC_A7,,,EVENTOUT,
+PortF,PF14,,,,,I2CFMP1_SCL,,,,,,,,FSMC_A8,,,EVENTOUT,
+PortF,PF15,,,,,I2CFMP1_SDA,,,,,,,,FSMC_A9,,,EVENTOUT,
+PortG,PG0,,,,,,,,,,CAN1_RX,,UART9_RX,FSMC_A10,,,EVENTOUT,
+PortG,PG1,,,,,,,,,,CAN1_TX,,UART9_TX,FSMC_A11,,,EVENTOUT,
+PortG,PG2,,,,,,,,,,,,,FSMC_A12,,,EVENTOUT,
+PortG,PG3,,,,,,,,,,,,,FSMC_A13,,,EVENTOUT,
+PortG,PG4,,,,,,,,,,,,,FSMC_A14,,,EVENTOUT,
+PortG,PG5,,,,,,,,,,,,,FSMC_A15,,,EVENTOUT,
+PortG,PG6,,,,,,,,,,,QUADSPI_BK1_NCS,,,,,EVENTOUT,
+PortG,PG7,,,,,,,,,USART6_CK,,,,,,,EVENTOUT,
+PortG,PG8,,,,,,,,,USART6_RTS,,,,,,,EVENTOUT,
+PortG,PG9,,,,,,,,,USART6_RX,QUADSPI_BK2_IO2,,,FSMC_NE2,,,EVENTOUT,
+PortG,PG10,,,,,,,,,,,,,FSMC_NE3,,,EVENTOUT,
+PortG,PG11,,,,,,,,,,CAN2_RX,,UART10_RX,,,,EVENTOUT,
+PortG,PG12,,,,,,,,,USART6_RTS,CAN2_TX,,UART10_TX,FSMC_NE4,,,EVENTOUT,
+PortG,PG13,TRACED2,,,,,,,,USART6_CTS,,,,FSMC_A24,,,EVENTOUT,
+PortG,PG14,TRACED3,,,,,,,,USART6_TX,QUADSPI_BK2_IO3,,,FSMC_A25,,,EVENTOUT,
+PortG,PG15,,,,,,,,,USART6_CTS,,,,,,,EVENTOUT,
+PortH,PH0,,,,,,,,,,,,,,,,EVENTOUT,
+PortH,PH1,,,,,,,,,,,,,,,,EVENTOUT,
diff --git a/ports/stm32/boards/stm32f413xg.ld b/ports/stm32/boards/stm32f413xg.ld
new file mode 100644
index 0000000000000..96d6dc5fb0d17
--- /dev/null
+++ b/ports/stm32/boards/stm32f413xg.ld
@@ -0,0 +1,31 @@
+/*
+    GNU linker script for STM32F413xg (1MB flash, 320kB RAM)
+*/
+
+/* Specify the memory areas */
+/* FLASH_FS2 is placed before FLASH_TEXT to support 1MB and 1.5MB FLASH with common code in flashbdev.c */
+MEMORY
+{
+    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 1024K /* entire flash */
+    FLASH_ISR (rx)  : ORIGIN = 0x08000000, LENGTH = 16K /* sector 0 */
+    FLASH_FS (rx)   : ORIGIN = 0x08004000, LENGTH = 176K /* sectors 1,2,3 are 16K, 4 is 64K, 5 is 128K (64K used) for filesystem */
+    FLASH_FS2 (rx)  : ORIGIN = 0x08040000, LENGTH = 128K /* sector 6 is 128K (64K used) for filesystem, Total filesystem 240K */
+    FLASH_TEXT (rx) : ORIGIN = 0x08060000, LENGTH = 640K /* sectors 7,8,9,10,11  are 128K*/
+    SRAM2 (xrw)     : ORIGIN = 0x10000000, LENGTH = 64K
+    RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 256K
+}
+
+/* produce a link error if there is not this amount of RAM for these sections */
+_minimum_stack_size = 2K;
+_minimum_heap_size = 16K;
+
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 16K; /* tunable */
+
+/* RAM extents for the garbage collector */
+_ram_start = ORIGIN(RAM);
+_ram_end = ORIGIN(RAM) + LENGTH(RAM);
+_heap_start = _ebss; /* heap starts just after statically allocated memory */
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32f413xh.ld b/ports/stm32/boards/stm32f413xh.ld
new file mode 100644
index 0000000000000..0b28730de53d5
--- /dev/null
+++ b/ports/stm32/boards/stm32f413xh.ld
@@ -0,0 +1,31 @@
+/*
+    GNU linker script for STM32F413xh (1.5MB flash, 320kB RAM)
+*/
+
+/* Specify the memory areas */
+/* FLASH_FS2 is placed before FLASH_TEXT to support 1MB and 1.5MB FLASH with common code in flashbdev.c */
+MEMORY
+{
+    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 1536K /* entire flash */
+    FLASH_ISR (rx)  : ORIGIN = 0x08000000, LENGTH = 16K /* sector 0 */
+    FLASH_FS (rx)   : ORIGIN = 0x08004000, LENGTH = 176K /* sectors 1,2,3 are 16K, 4 is 64K, 5 is 128K (64K used) for filesystem */
+    FLASH_FS2 (rx)  : ORIGIN = 0x08040000, LENGTH = 128K /* sector 6 is 128K (64K used) for filesystem, Total filesystem 240K */
+    FLASH_TEXT (rx) : ORIGIN = 0x08060000, LENGTH = 1152K /* sectors 7,8,9,10,11,12,13,14,15  are 128K*/
+    SRAM2 (xrw)     : ORIGIN = 0x10000000, LENGTH = 64K
+    RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 256K
+}
+
+/* produce a link error if there is not this amount of RAM for these sections */
+_minimum_stack_size = 2K;
+_minimum_heap_size = 16K;
+
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 16K; /* tunable */
+
+/* RAM extents for the garbage collector */
+_ram_start = ORIGIN(RAM);
+_ram_end = ORIGIN(RAM) + LENGTH(RAM);
+_heap_start = _ebss; /* heap starts just after statically allocated memory */
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32f429.ld b/ports/stm32/boards/stm32f429.ld
index d91f625ef6735..beeaa4df21237 100644
--- a/ports/stm32/boards/stm32f429.ld
+++ b/ports/stm32/boards/stm32f429.ld
@@ -17,13 +17,13 @@ MEMORY
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* Define tho top end of the stack.  The stack is full descending so begins just
-   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
-   aligned for a call. */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 16K; /* tunable */
 
 /* RAM extents for the garbage collector */
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x2002c000; /* tunable */
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32f439.ld b/ports/stm32/boards/stm32f439.ld
index 16c606eccc94c..e847646b35ed3 100644
--- a/ports/stm32/boards/stm32f439.ld
+++ b/ports/stm32/boards/stm32f439.ld
@@ -18,11 +18,13 @@ MEMORY
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* top end of the stack */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 16K; /* tunable */
 
 /* RAM extents for the garbage collector */
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x2002c000; /* tunable */
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32f4xx_hal_conf_base.h b/ports/stm32/boards/stm32f4xx_hal_conf_base.h
new file mode 100644
index 0000000000000..cdae0c5629e20
--- /dev/null
+++ b/ports/stm32/boards/stm32f4xx_hal_conf_base.h
@@ -0,0 +1,101 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_STM32F4XX_HAL_CONF_BASE_H
+#define MICROPY_INCLUDED_STM32F4XX_HAL_CONF_BASE_H
+
+// Include various HAL modules for convenience
+#include "stm32f4xx_hal_dma.h"
+#include "stm32f4xx_hal_adc.h"
+#include "stm32f4xx_hal_can.h"
+#include "stm32f4xx_hal_cortex.h"
+#include "stm32f4xx_hal_crc.h"
+#include "stm32f4xx_hal_dac.h"
+#include "stm32f4xx_hal_dcmi.h"
+#include "stm32f4xx_hal_eth.h"
+#include "stm32f4xx_hal_flash.h"
+#include "stm32f4xx_hal_gpio.h"
+#include "stm32f4xx_hal_hash.h"
+#include "stm32f4xx_hal_hcd.h"
+#include "stm32f4xx_hal_i2c.h"
+#include "stm32f4xx_hal_i2s.h"
+#include "stm32f4xx_hal_iwdg.h"
+#include "stm32f4xx_hal_pcd.h"
+#include "stm32f4xx_hal_pwr.h"
+#include "stm32f4xx_hal_rcc.h"
+#include "stm32f4xx_hal_rtc.h"
+#include "stm32f4xx_hal_sd.h"
+#include "stm32f4xx_hal_sdram.h"
+#include "stm32f4xx_hal_spi.h"
+#include "stm32f4xx_hal_tim.h"
+#include "stm32f4xx_hal_uart.h"
+#include "stm32f4xx_hal_usart.h"
+#include "stm32f4xx_hal_wwdg.h"
+
+// Enable various HAL modules
+#define HAL_ADC_MODULE_ENABLED
+#define HAL_CAN_MODULE_ENABLED
+#define HAL_CORTEX_MODULE_ENABLED
+#define HAL_CRC_MODULE_ENABLED
+#define HAL_DAC_MODULE_ENABLED
+#define HAL_DCMI_MODULE_ENABLED
+#define HAL_DMA_MODULE_ENABLED
+#define HAL_ETH_MODULE_ENABLED
+#define HAL_FLASH_MODULE_ENABLED
+#define HAL_GPIO_MODULE_ENABLED
+#define HAL_HASH_MODULE_ENABLED
+#define HAL_HCD_MODULE_ENABLED
+#define HAL_I2C_MODULE_ENABLED
+#define HAL_I2S_MODULE_ENABLED
+#define HAL_IWDG_MODULE_ENABLED
+#define HAL_PCD_MODULE_ENABLED
+#define HAL_PWR_MODULE_ENABLED
+#define HAL_RCC_MODULE_ENABLED
+#define HAL_RTC_MODULE_ENABLED
+#define HAL_SD_MODULE_ENABLED
+#define HAL_SDRAM_MODULE_ENABLED
+#define HAL_SPI_MODULE_ENABLED
+#define HAL_TIM_MODULE_ENABLED
+#define HAL_UART_MODULE_ENABLED
+#define HAL_USART_MODULE_ENABLED
+#define HAL_WWDG_MODULE_ENABLED
+
+// Oscillator values in Hz
+#define HSI_VALUE (16000000)
+#define LSI_VALUE (40000)
+
+// SysTick has the highest priority
+#define TICK_INT_PRIORITY (0x00)
+
+// Miscellaneous HAL settings
+#define DATA_CACHE_ENABLE           1
+#define INSTRUCTION_CACHE_ENABLE    1
+#define PREFETCH_ENABLE             1
+#define USE_RTOS                    0
+
+// HAL parameter assertions are disabled
+#define assert_param(expr) ((void)0)
+
+#endif // MICROPY_INCLUDED_STM32F4XX_HAL_CONF_BASE_H
diff --git a/ports/stm32/boards/stm32f722.ld b/ports/stm32/boards/stm32f722.ld
index f2a1d8511728a..fe84a49637e51 100644
--- a/ports/stm32/boards/stm32f722.ld
+++ b/ports/stm32/boards/stm32f722.ld
@@ -6,22 +6,24 @@
 MEMORY
 {
     FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 512K
-    FLASH_ISR (rx)  : ORIGIN = 0x08000000, LENGTH = 32K     /* sectors 0,1 */
-    FLASH_APP (rx)  : ORIGIN = 0x08008000, LENGTH = 480K    /* sectors 2-7 */
-    RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 256K    /* DTCM+SRAM1+SRAM2 */
+    FLASH_ISR (rx)  : ORIGIN = 0x08000000, LENGTH = 16K     /* sector 0, 16K */
+    FLASH_FS (r)    : ORIGIN = 0x08004000, LENGTH = 112K    /* sectors 1-4 3*16KiB 1*64KiB*/
+    FLASH_TEXT (rx) : ORIGIN = 0x08020000, LENGTH = 384K    /* sectors 5-7 3*128KiB = 384K */
+    DTCM (xrw)      : ORIGIN = 0x20000000, LENGTH = 64K     /* Used for storage cache */
+    RAM (xrw)       : ORIGIN = 0x20010000, LENGTH = 192K    /* SRAM1 = 176K, SRAM2 = 16K */
 }
 
 /* produce a link error if there is not this amount of RAM for these sections */
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* Define tho top end of the stack.  The stack is full descending so begins just
-   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
-   aligned for a call. */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 32K; /* tunable */
 
 /* RAM extents for the garbage collector */
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x20038000; /* tunable */
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32f746.ld b/ports/stm32/boards/stm32f746.ld
index b5864453dd031..0f1de2696456f 100644
--- a/ports/stm32/boards/stm32f746.ld
+++ b/ports/stm32/boards/stm32f746.ld
@@ -1,5 +1,5 @@
 /*
-    GNU linker script for STM32F405
+    GNU linker script for STM32F746
 */
 
 /* Specify the memory areas */
@@ -17,13 +17,13 @@ MEMORY
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* Define tho top end of the stack.  The stack is full descending so begins just
-   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
-   aligned for a call. */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 16K; /* tunable */
 
 /* RAM extents for the garbage collector */
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x2004c000; /* tunable */
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32f746_af.csv b/ports/stm32/boards/stm32f746_af.csv
index 8069edc7b9732..d9e42008d616f 100644
--- a/ports/stm32/boards/stm32f746_af.csv
+++ b/ports/stm32/boards/stm32f746_af.csv
@@ -1,170 +1,170 @@
-Port,,AF0,AF1,AF2,AF3,AF4,AF5,AF6,AF7,AF8,AF9,AF10,AF11,AF12,AF13,AF14,AF15
-,,SYS,TIM1/2,TIM3/4/5,TIM8/9/10/11/LPTIM1/CEC,I2C1/2/3/4/CEC,SPI1/2/3/4/5/6,SPI3/SAI1,SPI2/3/USART1/2/3/UART5/SPDIFRX,SAI2/USART6/UART4/5/7/8/SPDIFRX,CAN1/2/TIM12/13/14/QUADSPI/LCD,SAI2/QUADSPI/OTG2_HS/OTG1_FS,ETH/OTG1_FS,FMC/SDMMC1/OTG2_FS,DCMI,LCD,SYS
-PortA,PA0,,TIM2_CH1/TIM2_ETR,TIM5_CH1,TIM8_ETR,,,,USART2_CTS,UART4_TX,,SAI2_SD_B,ETH_MII_CRS,,,,EVENTOUT
-PortA,PA1,,TIM2_CH2,TIM5_CH2,,,,,USART2_RTS,UART4_RX,QUADSPI_BK1_IO3,SAI2_MCK_B,ETH_MII_RX_CLK/ETH_RMII_REF_CLK,,,LCD_R2,EVENTOUT
-PortA,PA2,,TIM2_CH3,TIM5_CH3,TIM9_CH1,,,,USART2_TX,SAI2_SCK_B,,,ETH_MDIO,,,LCD_R1,EVENTOUT
-PortA,PA3,,TIM2_CH4,TIM5_CH4,TIM9_CH2,,,,USART2_RX,,,OTG_HS_ULPI_D0,ETH_MII_COL,,,LCD_B5,EVENTOUT
-PortA,PA4,,,,,,SPI1_NSS/I2S1_WS,SPI3_NSS/I2S3_WS,USART2_CK,,,,,OTG_HS_SOF,DCMI_HSYNC,LCD_VSYNC,EVENTOUT
-PortA,PA5,,TIM2_CH1/TIM2_ETR,,TIM8_CH1N,,SPI1_SCK/I2S1_CK,,,,,OTG_HS_ULPI_CK,,,,LCD_R4,EVENTOUT
-PortA,PA6,,TIM1_BKIN,TIM3_CH1,TIM8_BKIN,,SPI1_MISO,,,,TIM13_CH1,,,,DCMI_PIXCLK,LCD_G2,EVENTOUT
-PortA,PA7,,TIM1_CH1N,TIM3_CH2,TIM8_CH1N,,SPI1_MOSI/I2S1_SD,,,,TIM14_CH1,,ETH_MII_RX_DV/ETH_RMII_CRS_DV,FMC_SDNWE,,,EVENTOUT
-PortA,PA8,MCO1,TIM1_CH1,,TIM8_BKIN2,I2C3_SCL,,,USART1_CK,,,OTG_FS_SOF,,,,LCD_R6,EVENTOUT
-PortA,PA9,,TIM1_CH2,,,I2C3_SMBA,SPI2_SCK/I2S2_CK,,USART1_TX,,,,,,DCMI_D0,,EVENTOUT
-PortA,PA10,,TIM1_CH3,,,,,,USART1_RX,,,OTG_FS_ID,,,DCMI_D1,,EVENTOUT
-PortA,PA11,,TIM1_CH4,,,,,,USART1_CTS,,CAN1_RX,OTG_FS_DM,,,,LCD_R4,EVENTOUT
-PortA,PA12,,TIM1_ETR,,,,,,USART1_RTS,SAI2_FS_B,CAN1_TX,OTG_FS_DP,,,,LCD_R5,EVENTOUT
-PortA,PA13,JTMS/SWDIO,,,,,,,,,,,,,,,EVENTOUT
-PortA,PA14,JTCK/SWCLK,,,,,,,,,,,,,,,EVENTOUT
-PortA,PA15,JTDI,TIM2_CH1/TIM2_ETR,,,HDMI_CEC,SPI1_NSS/I2S1_WS,SPI3_NSS/I2S3_WS,,UART4_RTS,,,,,,,EVENTOUT
-PortB,PB0,,TIM1_CH2N,TIM3_CH3,TIM8_CH2N,,,,,UART4_CTS,LCD_R3,OTG_HS_ULPI_D1,ETH_MII_RXD2,,,,EVENTOUT
-PortB,PB1,,TIM1_CH3N,TIM3_CH4,TIM8_CH3N,,,,,,LCD_R6,OTG_HS_ULPI_D2,ETH_MII_RXD3,,,,EVENTOUT
-PortB,PB2,,,,,,,SAI1_SD_A,SPI3_MOSI/I2S3_SD,,QUADSPI_CLK,,,,,,EVENTOUT
-PortB,PB3,JTDO/TRACESWO,TIM2_CH2,,,,SPI1_SCK/I2S1_CK,SPI3_SCK/I2S3_CK,,,,,,,,,EVENTOUT
-PortB,PB4,NJTRST,,TIM3_CH1,,,SPI1_MISO,SPI3_MISO,SPI2_NSS/I2S2_WS,,,,,,,,EVENTOUT
-PortB,PB5,,,TIM3_CH2,,I2C1_SMBA,SPI1_MOSI/I2S1_SD,SPI3_MOSI/I2S3_SD,,,CAN2_RX,OTG_HS_ULPI_D7,ETH_PPS_OUT,FMC_SDCKE1,DCMI_D10,,EVENTOUT
-PortB,PB6,,,TIM4_CH1,HDMI_CEC,I2C1_SCL,,,USART1_TX,,CAN2_TX,QUADSPI_BK1_NCS,,FMC_SDNE1,DCMI_D5,,EVENTOUT
-PortB,PB7,,,TIM4_CH2,,I2C1_SDA,,,USART1_RX,,,,,FMC_NL,DCMI_VSYNC,,EVENTOUT
-PortB,PB8,,,TIM4_CH3,TIM10_CH1,I2C1_SCL,,,,,CAN1_RX,,ETH_MII_TXD3,SDMMC1_D4,DCMI_D6,LCD_B6,EVENTOUT
-PortB,PB9,,,TIM4_CH4,TIM11_CH1,I2C1_SDA,SPI2_NSS/I2S2_WS,,,,CAN1_TX,,,SDMMC1_D5,DCMI_D7,LCD_B7,EVENTOUT
-PortB,PB10,,TIM2_CH3,,,I2C2_SCL,SPI2_SCK/I2S2_CK,,USART3_TX,,,OTG_HS_ULPI_D3,ETH_MII_RX_ER,,,LCD_G4,EVENTOUT
-PortB,PB11,,TIM2_CH4,,,I2C2_SDA,,,USART3_RX,,,OTG_HS_ULPI_D4,ETH_MII_TX_EN/ETH_RMII_TX_EN,,,LCD_G5,EVENTOUT
-PortB,PB12,,TIM1_BKIN,,,I2C2_SMBA,SPI2_NSS/I2S2_WS,,USART3_CK,,CAN2_RX,OTG_HS_ULPI_D5,ETH_MII_TXD0/ETH_RMII_TXD0,OTG_HS_ID,,,EVENTOUT
-PortB,PB13,,TIM1_CH1N,,,,SPI2_SCK/I2S2_CK,,USART3_CTS,,CAN2_TX,OTG_HS_ULPI_D6,ETH_MII_TXD1/ETH_RMII_TXD1,,,,EVENTOUT
-PortB,PB14,,TIM1_CH2N,,TIM8_CH2N,,SPI2_MISO,,USART3_RTS,,TIM12_CH1,,,OTG_HS_DM,,,EVENTOUT
-PortB,PB15,RTC_REFIN,TIM1_CH3N,,TIM8_CH3N,,SPI2_MOSI/I2S2_SD,,,,TIM12_CH2,,,OTG_HS_DP,,,EVENTOUT
-PortC,PC0,,,,,,,,,SAI2_FS_B,,OTG_HS_ULPI_STP,,FMC_SDNWE,,LCD_R5,EVENTOUT
-PortC,PC1,TRACED0,,,,,SPI2_MOSI/I2S2_SD,SAI1_SD_A,,,,,ETH_MDC,,,,EVENTOUT
-PortC,PC2,,,,,,SPI2_MISO,,,,,OTG_HS_ULPI_DIR,ETH_MII_TXD2,FMC_SDNE0,,,EVENTOUT
-PortC,PC3,,,,,,SPI2_MOSI/I2S2_SD,,,,,OTG_HS_ULPI_NXT,ETH_MII_TX_CLK,FMC_SDCKE0,,,EVENTOUT
-PortC,PC4,,,,,,I2S1_MCK,,,SPDIFRX_IN2,,,ETH_MII_RXD0/ETH_RMII_RXD0,FMC_SDNE0,,,EVENTOUT
-PortC,PC5,,,,,,,,,SPDIFRX_IN3,,,ETH_MII_RXD1/ETH_RMII_RXD1,FMC_SDCKE0,,,EVENTOUT
-PortC,PC6,,,TIM3_CH1,TIM8_CH1,,I2S2_MCK,,,USART6_TX,,,,SDMMC1_D6,DCMI_D0,LCD_HSYNC,EVENTOUT
-PortC,PC7,,,TIM3_CH2,TIM8_CH2,,,I2S3_MCK,,USART6_RX,,,,SDMMC1_D7,DCMI_D1,LCD_G6,EVENTOUT
-PortC,PC8,TRACED1,,TIM3_CH3,TIM8_CH3,,,,UART5_RTS,USART6_CK,,,,SDMMC1_D0,DCMI_D2,,EVENTOUT
-PortC,PC9,MCO2,,TIM3_CH4,TIM8_CH4,I2C3_SDA,I2S_CKIN,,UART5_CTS,,QUADSPI_BK1_IO0,,,SDMMC1_D1,DCMI_D3,,EVENTOUT
-PortC,PC10,,,,,,,SPI3_SCK/I2S3_CK,USART3_TX,UART4_TX,QUADSPI_BK1_IO1,,,SDMMC1_D2,DCMI_D8,LCD_R2,EVENTOUT
-PortC,PC11,,,,,,,SPI3_MISO,USART3_RX,UART4_RX,QUADSPI_BK2_NCS,,,SDMMC1_D3,DCMI_D4,,EVENTOUT
-PortC,PC12,TRACED3,,,,,,SPI3_MOSI/I2S3_SD,USART3_CK,UART5_TX,,,,SDMMC1_CK,DCMI_D9,,EVENTOUT
-PortC,PC13,,,,,,,,,,,,,,,,EVENTOUT
-PortC,PC14,,,,,,,,,,,,,,,,EVENTOUT
-PortC,PC15,,,,,,,,,,,,,,,,EVENTOUT
-PortD,PD0,,,,,,,,,,CAN1_RX,,,FMC_D2,,,EVENTOUT
-PortD,PD1,,,,,,,,,,CAN1_TX,,,FMC_D3,,,EVENTOUT
-PortD,PD2,TRACED2,,TIM3_ETR,,,,,,UART5_RX,,,,SDMMC1_CMD,DCMI_D11,,EVENTOUT
-PortD,PD3,,,,,,SPI2_SCK/I2S2_CK,,USART2_CTS,,,,,FMC_CLK,DCMI_D5,LCD_G7,EVENTOUT
-PortD,PD4,,,,,,,,USART2_RTS,,,,,FMC_NOE,,,EVENTOUT
-PortD,PD5,,,,,,,,USART2_TX,,,,,FMC_NWE,,,EVENTOUT
-PortD,PD6,,,,,,SPI3_MOSI/I2S3_SD,SAI1_SD_A,USART2_RX,,,,,FMC_NWAIT,DCMI_D10,LCD_B2,EVENTOUT
-PortD,PD7,,,,,,,,USART2_CK,SPDIFRX_IN0,,,,FMC_NE1,,,EVENTOUT
-PortD,PD8,,,,,,,,USART3_TX,SPDIFRX_IN1,,,,FMC_D13,,,EVENTOUT
-PortD,PD9,,,,,,,,USART3_RX,,,,,FMC_D14,,,EVENTOUT
-PortD,PD10,,,,,,,,USART3_CK,,,,,FMC_D15,,LCD_B3,EVENTOUT
-PortD,PD11,,,,,I2C4_SMBA,,,USART3_CTS,,QUADSPI_BK1_IO0,SAI2_SD_A,,FMC_A16/FMC_CLE,,,EVENTOUT
-PortD,PD12,,,TIM4_CH1,LPTIM1_IN1,I2C4_SCL,,,USART3_RTS,,QUADSPI_BK1_IO1,SAI2_FS_A,,FMC_A17/FMC_ALE,,,EVENTOUT
-PortD,PD13,,,TIM4_CH2,LPTIM1_OUT,I2C4_SDA,,,,,QUADSPI_BK1_IO3,SAI2_SCK_A,,FMC_A18,,,EVENTOUT
-PortD,PD14,,,TIM4_CH3,,,,,,UART8_CTS,,,,FMC_D0,,,EVENTOUT
-PortD,PD15,,,TIM4_CH4,,,,,,UART8_RTS,,,,FMC_D1,,,EVENTOUT
-PortE,PE0,,,TIM4_ETR,LPTIM1_ETR,,,,,UART8_RX,,SAI2_MCK_A,,FMC_NBL0,DCMI_D2,,EVENTOUT
-PortE,PE1,,,,LPTIM1_IN2,,,,,UART8_TX,,,,FMC_NBL1,DCMI_D3,,EVENTOUT
-PortE,PE2,TRACECLK,,,,,SPI4_SCK,SAI1_MCLK_A,,,QUADSPI_BK1_IO2,,ETH_MII_TXD3,FMC_A23,,,EVENTOUT
-PortE,PE3,TRACED0,,,,,,SAI1_SD_B,,,,,,FMC_A19,,,EVENTOUT
-PortE,PE4,TRACED1,,,,,SPI4_NSS,SAI1_FS_A,,,,,,FMC_A20,DCMI_D4,LCD_B0,EVENTOUT
-PortE,PE5,TRACED2,,,TIM9_CH1,,SPI4_MISO,SAI1_SCK_A,,,,,,FMC_A21,DCMI_D6,LCD_G0,EVENTOUT
-PortE,PE6,TRACED3,TIM1_BKIN2,,TIM9_CH2,,SPI4_MOSI,SAI1_SD_A,,,,SAI2_MCK_B,,FMC_A22,DCMI_D7,LCD_G1,EVENTOUT
-PortE,PE7,,TIM1_ETR,,,,,,,UART7_RX,,QUADSPI_BK2_IO0,,FMC_D4,,,EVENTOUT
-PortE,PE8,,TIM1_CH1N,,,,,,,UART7_TX,,QUADSPI_BK2_IO1,,FMC_D5,,,EVENTOUT
-PortE,PE9,,TIM1_CH1,,,,,,,UART7_RTS,,QUADSPI_BK2_IO2,,FMC_D6,,,EVENTOUT
-PortE,PE10,,TIM1_CH2N,,,,,,,UART7_CTS,,QUADSPI_BK2_IO3,,FMC_D7,,,EVENTOUT
-PortE,PE11,,TIM1_CH2,,,,SPI4_NSS,,,,,SAI2_SD_B,,FMC_D8,,LCD_G3,EVENTOUT
-PortE,PE12,,TIM1_CH3N,,,,SPI4_SCK,,,,,SAI2_SCK_B,,FMC_D9,,LCD_B4,EVENTOUT
-PortE,PE13,,TIM1_CH3,,,,SPI4_MISO,,,,,SAI2_FS_B,,FMC_D10,,LCD_DE,EVENTOUT
-PortE,PE14,,TIM1_CH4,,,,SPI4_MOSI,,,,,SAI2_MCK_B,,FMC_D11,,LCD_CLK,EVENTOUT
-PortE,PE15,,TIM1_BKIN,,,,,,,,,,,FMC_D12,,LCD_R7,EVENTOUT
-PortF,PF0,,,,,I2C2_SDA,,,,,,,,FMC_A0,,,EVENTOUT
-PortF,PF1,,,,,I2C2_SCL,,,,,,,,FMC_A1,,,EVENTOUT
-PortF,PF2,,,,,I2C2_SMBA,,,,,,,,FMC_A2,,,EVENTOUT
-PortF,PF3,,,,,,,,,,,,,FMC_A3,,,EVENTOUT
-PortF,PF4,,,,,,,,,,,,,FMC_A4,,,EVENTOUT
-PortF,PF5,,,,,,,,,,,,,FMC_A5,,,EVENTOUT
-PortF,PF6,,,,TIM10_CH1,,SPI5_NSS,SAI1_SD_B,,UART7_RX,QUADSPI_BK1_IO3,,,,,,EVENTOUT
-PortF,PF7,,,,TIM11_CH1,,SPI5_SCK,SAI1_MCLK_B,,UART7_TX,QUADSPI_BK1_IO2,,,,,,EVENTOUT
-PortF,PF8,,,,,,SPI5_MISO,SAI1_SCK_B,,UART7_RTS,TIM13_CH1,QUADSPI_BK1_IO0,,,,,EVENTOUT
-PortF,PF9,,,,,,SPI5_MOSI,SAI1_FS_B,,UART7_CTS,TIM14_CH1,QUADSPI_BK1_IO1,,,,,EVENTOUT
-PortF,PF10,,,,,,,,,,,,,,DCMI_D11,LCD_DE,EVENTOUT
-PortF,PF11,,,,,,SPI5_MOSI,,,,,SAI2_SD_B,,FMC_SDNRAS,DCMI_D12,,EVENTOUT
-PortF,PF12,,,,,,,,,,,,,FMC_A6,,,EVENTOUT
-PortF,PF13,,,,,I2C4_SMBA,,,,,,,,FMC_A7,,,EVENTOUT
-PortF,PF14,,,,,I2C4_SCL,,,,,,,,FMC_A8,,,EVENTOUT
-PortF,PF15,,,,,I2C4_SDA,,,,,,,,FMC_A9,,,EVENTOUT
-PortG,PG0,,,,,,,,,,,,,FMC_A10,,,EVENTOUT
-PortG,PG1,,,,,,,,,,,,,FMC_A11,,,EVENTOUT
-PortG,PG2,,,,,,,,,,,,,FMC_A12,,,EVENTOUT
-PortG,PG3,,,,,,,,,,,,,FMC_A13,,,EVENTOUT
-PortG,PG4,,,,,,,,,,,,,FMC_A14/FMC_BA0,,,EVENTOUT
-PortG,PG5,,,,,,,,,,,,,FMC_A15/FMC_BA1,,,EVENTOUT
-PortG,PG6,,,,,,,,,,,,,,DCMI_D12,LCD_R7,EVENTOUT
-PortG,PG7,,,,,,,,,USART6_CK,,,,FMC_INT,DCMI_D13,LCD_CLK,EVENTOUT
-PortG,PG8,,,,,,SPI6_NSS,,SPDIFRX_IN2,USART6_RTS,,,ETH_PPS_OUT,FMC_SDCLK,,,EVENTOUT
-PortG,PG9,,,,,,,,SPDIFRX_IN3,USART6_RX,QUADSPI_BK2_IO2,SAI2_FS_B,,FMC_NE2/FMC_NCE,DCMI_VSYNC,,EVENTOUT
-PortG,PG10,,,,,,,,,,LCD_G3,SAI2_SD_B,,FMC_NE3,DCMI_D2,LCD_B2,EVENTOUT
-PortG,PG11,,,,,,,,SPDIFRX_IN0,,,,ETH_MII_TX_EN/ETH_RMII_TX_EN,,DCMI_D3,LCD_B3,EVENTOUT
-PortG,PG12,,,,LPTIM1_IN1,,SPI6_MISO,,SPDIFRX_IN1,USART6_RTS,LCD_B4,,,FMC_NE4,,LCD_B1,EVENTOUT
-PortG,PG13,TRACED0,,,LPTIM1_OUT,,SPI6_SCK,,,USART6_CTS,,,ETH_MII_TXD0/ETH_RMII_TXD0,FMC_A24,,LCD_R0,EVENTOUT
-PortG,PG14,TRACED1,,,LPTIM1_ETR,,SPI6_MOSI,,,USART6_TX,QUADSPI_BK2_IO3,,ETH_MII_TXD1/ETH_RMII_TXD1,FMC_A25,,LCD_B0,EVENTOUT
-PortG,PG15,,,,,,,,,USART6_CTS,,,,FMC_SDNCAS,DCMI_D13,,EVENTOUT
-PortH,PH0,,,,,,,,,,,,,,,,EVENTOUT
-PortH,PH1,,,,,,,,,,,,,,,,EVENTOUT
-PortH,PH2,,,,LPTIM1_IN2,,,,,,QUADSPI_BK2_IO0,SAI2_SCK_B,ETH_MII_CRS,FMC_SDCKE0,,LCD_R0,EVENTOUT
-PortH,PH3,,,,,,,,,,QUADSPI_BK2_IO1,SAI2_MCK_B,ETH_MII_COL,FMC_SDNE0,,LCD_R1,EVENTOUT
-PortH,PH4,,,,,I2C2_SCL,,,,,,OTG_HS_ULPI_NXT,,,,,EVENTOUT
-PortH,PH5,,,,,I2C2_SDA,SPI5_NSS,,,,,,,FMC_SDNWE,,,EVENTOUT
-PortH,PH6,,,,,I2C2_SMBA,SPI5_SCK,,,,TIM12_CH1,,ETH_MII_RXD2,FMC_SDNE1,DCMI_D8,,EVENTOUT
-PortH,PH7,,,,,I2C3_SCL,SPI5_MISO,,,,,,ETH_MII_RXD3,FMC_SDCKE1,DCMI_D9,,EVENTOUT
-PortH,PH8,,,,,I2C3_SDA,,,,,,,,FMC_D16,DCMI_HSYNC,LCD_R2,EVENTOUT
-PortH,PH9,,,,,I2C3_SMBA,,,,,TIM12_CH2,,,FMC_D17,DCMI_D0,LCD_R3,EVENTOUT
-PortH,PH10,,,TIM5_CH1,,I2C4_SMBA,,,,,,,,FMC_D18,DCMI_D1,LCD_R4,EVENTOUT
-PortH,PH11,,,TIM5_CH2,,I2C4_SCL,,,,,,,,FMC_D19,DCMI_D2,LCD_R5,EVENTOUT
-PortH,PH12,,,TIM5_CH3,,I2C4_SDA,,,,,,,,FMC_D20,DCMI_D3,LCD_R6,EVENTOUT
-PortH,PH13,,,,TIM8_CH1N,,,,,,CAN1_TX,,,FMC_D21,,LCD_G2,EVENTOUT
-PortH,PH14,,,,TIM8_CH2N,,,,,,,,,FMC_D22,DCMI_D4,LCD_G3,EVENTOUT
-PortH,PH15,,,,TIM8_CH3N,,,,,,,,,FMC_D23,DCMI_D11,LCD_G4,EVENTOUT
-PortI,PI0,,,TIM5_CH4,,,SPI2_NSS/I2S2_WS,,,,,,,FMC_D24,DCMI_D13,LCD_G5,EVENTOUT
-PortI,PI1,,,,TIM8_BKIN2,,SPI2_SCK/I2S2_CK,,,,,,,FMC_D25,DCMI_D8,LCD_G6,EVENTOUT
-PortI,PI2,,,,TIM8_CH4,,SPI2_MISO,,,,,,,FMC_D26,DCMI_D9,LCD_G7,EVENTOUT
-PortI,PI3,,,,TIM8_ETR,,SPI2_MOSI/I2S2_SD,,,,,,,FMC_D27,DCMI_D10,,EVENTOUT
-PortI,PI4,,,,TIM8_BKIN,,,,,,,SAI2_MCK_A,,FMC_NBL2,DCMI_D5,LCD_B4,EVENTOUT
-PortI,PI5,,,,TIM8_CH1,,,,,,,SAI2_SCK_A,,FMC_NBL3,DCMI_VSYNC,LCD_B5,EVENTOUT
-PortI,PI6,,,,TIM8_CH2,,,,,,,SAI2_SD_A,,FMC_D28,DCMI_D6,LCD_B6,EVENTOUT
-PortI,PI7,,,,TIM8_CH3,,,,,,,SAI2_FS_A,,FMC_D29,DCMI_D7,LCD_B7,EVENTOUT
-PortI,PI8,,,,,,,,,,,,,,,,EVENTOUT
-PortI,PI9,,,,,,,,,,CAN1_RX,,,FMC_D30,,LCD_VSYNC,EVENTOUT
-PortI,PI10,,,,,,,,,,,,ETH_MII_RX_ER,FMC_D31,,LCD_HSYNC,EVENTOUT
-PortI,PI11,,,,,,,,,,,OTG_HS_ULPI_DIR,,,,,EVENTOUT
-PortI,PI12,,,,,,,,,,,,,,,LCD_HSYNC,EVENTOUT
-PortI,PI13,,,,,,,,,,,,,,,LCD_VSYNC,EVENTOUT
-PortI,PI14,,,,,,,,,,,,,,,LCD_CLK,EVENTOUT
-PortI,PI15,,,,,,,,,,,,,,,LCD_R0,EVENTOUT
-PortJ,PJ0,,,,,,,,,,,,,,,LCD_R1,EVENTOUT
-PortJ,PJ1,,,,,,,,,,,,,,,LCD_R2,EVENTOUT
-PortJ,PJ2,,,,,,,,,,,,,,,LCD_R3,EVENTOUT
-PortJ,PJ3,,,,,,,,,,,,,,,LCD_R4,EVENTOUT
-PortJ,PJ4,,,,,,,,,,,,,,,LCD_R5,EVENTOUT
-PortJ,PJ5,,,,,,,,,,,,,,,LCD_R6,EVENTOUT
-PortJ,PJ6,,,,,,,,,,,,,,,LCD_R7,EVENTOUT
-PortJ,PJ7,,,,,,,,,,,,,,,LCD_G0,EVENTOUT
-PortJ,PJ8,,,,,,,,,,,,,,,LCD_G1,EVENTOUT
-PortJ,PJ9,,,,,,,,,,,,,,,LCD_G2,EVENTOUT
-PortJ,PJ10,,,,,,,,,,,,,,,LCD_G3,EVENTOUT
-PortJ,PJ11,,,,,,,,,,,,,,,LCD_G4,EVENTOUT
-PortJ,PJ12,,,,,,,,,,,,,,,LCD_B0,EVENTOUT
-PortJ,PJ13,,,,,,,,,,,,,,,LCD_B1,EVENTOUT
-PortJ,PJ14,,,,,,,,,,,,,,,LCD_B2,EVENTOUT
-PortJ,PJ15,,,,,,,,,,,,,,,LCD_B3,EVENTOUT
-PortK,PK0,,,,,,,,,,,,,,,LCD_G5,EVENTOUT
-PortK,PK1,,,,,,,,,,,,,,,LCD_G6,EVENTOUT
-PortK,PK2,,,,,,,,,,,,,,,LCD_G7,EVENTOUT
-PortK,PK3,,,,,,,,,,,,,,,LCD_B4,EVENTOUT
-PortK,PK4,,,,,,,,,,,,,,,LCD_B5,EVENTOUT
-PortK,PK5,,,,,,,,,,,,,,,LCD_B6,EVENTOUT
-PortK,PK6,,,,,,,,,,,,,,,LCD_B7,EVENTOUT
-PortK,PK7,,,,,,,,,,,,,,,LCD_DE,EVENTOUT
+Port,,AF0,AF1,AF2,AF3,AF4,AF5,AF6,AF7,AF8,AF9,AF10,AF11,AF12,AF13,AF14,AF15,
+,,SYS,TIM1/2,TIM3/4/5,TIM8/9/10/11/LPTIM1/CEC,I2C1/2/3/4/CEC,SPI1/2/3/4/5/6,SPI3/SAI1,SPI2/3/USART1/2/3/UART5/SPDIFRX,SAI2/USART6/UART4/5/7/8/SPDIFRX,CAN1/2/TIM12/13/14/QUADSPI/LCD,SAI2/QUADSPI/OTG2_HS/OTG1_FS,ETH/OTG1_FS,FMC/SDMMC1/OTG2_FS,DCMI,LCD,SYS,ADC
+PortA,PA0,,TIM2_CH1/TIM2_ETR,TIM5_CH1,TIM8_ETR,,,,USART2_CTS,UART4_TX,,SAI2_SD_B,ETH_MII_CRS,,,,EVENTOUT,ADC123_IN0
+PortA,PA1,,TIM2_CH2,TIM5_CH2,,,,,USART2_RTS,UART4_RX,QUADSPI_BK1_IO3,SAI2_MCK_B,ETH_MII_RX_CLK/ETH_RMII_REF_CLK,,,LCD_R2,EVENTOUT,ADC123_IN1
+PortA,PA2,,TIM2_CH3,TIM5_CH3,TIM9_CH1,,,,USART2_TX,SAI2_SCK_B,,,ETH_MDIO,,,LCD_R1,EVENTOUT,ADC123_IN2
+PortA,PA3,,TIM2_CH4,TIM5_CH4,TIM9_CH2,,,,USART2_RX,,,OTG_HS_ULPI_D0,ETH_MII_COL,,,LCD_B5,EVENTOUT,ADC123_IN3
+PortA,PA4,,,,,,SPI1_NSS/I2S1_WS,SPI3_NSS/I2S3_WS,USART2_CK,,,,,OTG_HS_SOF,DCMI_HSYNC,LCD_VSYNC,EVENTOUT,ADC12_IN4
+PortA,PA5,,TIM2_CH1/TIM2_ETR,,TIM8_CH1N,,SPI1_SCK/I2S1_CK,,,,,OTG_HS_ULPI_CK,,,,LCD_R4,EVENTOUT,ADC12_IN5
+PortA,PA6,,TIM1_BKIN,TIM3_CH1,TIM8_BKIN,,SPI1_MISO,,,,TIM13_CH1,,,,DCMI_PIXCLK,LCD_G2,EVENTOUT,ADC12_IN6
+PortA,PA7,,TIM1_CH1N,TIM3_CH2,TIM8_CH1N,,SPI1_MOSI/I2S1_SD,,,,TIM14_CH1,,ETH_MII_RX_DV/ETH_RMII_CRS_DV,FMC_SDNWE,,,EVENTOUT,ADC12_IN7
+PortA,PA8,MCO1,TIM1_CH1,,TIM8_BKIN2,I2C3_SCL,,,USART1_CK,,,OTG_FS_SOF,,,,LCD_R6,EVENTOUT,
+PortA,PA9,,TIM1_CH2,,,I2C3_SMBA,SPI2_SCK/I2S2_CK,,USART1_TX,,,,,,DCMI_D0,,EVENTOUT,
+PortA,PA10,,TIM1_CH3,,,,,,USART1_RX,,,OTG_FS_ID,,,DCMI_D1,,EVENTOUT,
+PortA,PA11,,TIM1_CH4,,,,,,USART1_CTS,,CAN1_RX,OTG_FS_DM,,,,LCD_R4,EVENTOUT,
+PortA,PA12,,TIM1_ETR,,,,,,USART1_RTS,SAI2_FS_B,CAN1_TX,OTG_FS_DP,,,,LCD_R5,EVENTOUT,
+PortA,PA13,JTMS/SWDIO,,,,,,,,,,,,,,,EVENTOUT,
+PortA,PA14,JTCK/SWCLK,,,,,,,,,,,,,,,EVENTOUT,
+PortA,PA15,JTDI,TIM2_CH1/TIM2_ETR,,,HDMI_CEC,SPI1_NSS/I2S1_WS,SPI3_NSS/I2S3_WS,,UART4_RTS,,,,,,,EVENTOUT,
+PortB,PB0,,TIM1_CH2N,TIM3_CH3,TIM8_CH2N,,,,,UART4_CTS,LCD_R3,OTG_HS_ULPI_D1,ETH_MII_RXD2,,,,EVENTOUT,ADC12_IN8
+PortB,PB1,,TIM1_CH3N,TIM3_CH4,TIM8_CH3N,,,,,,LCD_R6,OTG_HS_ULPI_D2,ETH_MII_RXD3,,,,EVENTOUT,ADC12_IN9
+PortB,PB2,,,,,,,SAI1_SD_A,SPI3_MOSI/I2S3_SD,,QUADSPI_CLK,,,,,,EVENTOUT,
+PortB,PB3,JTDO/TRACESWO,TIM2_CH2,,,,SPI1_SCK/I2S1_CK,SPI3_SCK/I2S3_CK,,,,,,,,,EVENTOUT,
+PortB,PB4,NJTRST,,TIM3_CH1,,,SPI1_MISO,SPI3_MISO,SPI2_NSS/I2S2_WS,,,,,,,,EVENTOUT,
+PortB,PB5,,,TIM3_CH2,,I2C1_SMBA,SPI1_MOSI/I2S1_SD,SPI3_MOSI/I2S3_SD,,,CAN2_RX,OTG_HS_ULPI_D7,ETH_PPS_OUT,FMC_SDCKE1,DCMI_D10,,EVENTOUT,
+PortB,PB6,,,TIM4_CH1,HDMI_CEC,I2C1_SCL,,,USART1_TX,,CAN2_TX,QUADSPI_BK1_NCS,,FMC_SDNE1,DCMI_D5,,EVENTOUT,
+PortB,PB7,,,TIM4_CH2,,I2C1_SDA,,,USART1_RX,,,,,FMC_NL,DCMI_VSYNC,,EVENTOUT,
+PortB,PB8,,,TIM4_CH3,TIM10_CH1,I2C1_SCL,,,,,CAN1_RX,,ETH_MII_TXD3,SDMMC1_D4,DCMI_D6,LCD_B6,EVENTOUT,
+PortB,PB9,,,TIM4_CH4,TIM11_CH1,I2C1_SDA,SPI2_NSS/I2S2_WS,,,,CAN1_TX,,,SDMMC1_D5,DCMI_D7,LCD_B7,EVENTOUT,
+PortB,PB10,,TIM2_CH3,,,I2C2_SCL,SPI2_SCK/I2S2_CK,,USART3_TX,,,OTG_HS_ULPI_D3,ETH_MII_RX_ER,,,LCD_G4,EVENTOUT,
+PortB,PB11,,TIM2_CH4,,,I2C2_SDA,,,USART3_RX,,,OTG_HS_ULPI_D4,ETH_MII_TX_EN/ETH_RMII_TX_EN,,,LCD_G5,EVENTOUT,
+PortB,PB12,,TIM1_BKIN,,,I2C2_SMBA,SPI2_NSS/I2S2_WS,,USART3_CK,,CAN2_RX,OTG_HS_ULPI_D5,ETH_MII_TXD0/ETH_RMII_TXD0,OTG_HS_ID,,,EVENTOUT,
+PortB,PB13,,TIM1_CH1N,,,,SPI2_SCK/I2S2_CK,,USART3_CTS,,CAN2_TX,OTG_HS_ULPI_D6,ETH_MII_TXD1/ETH_RMII_TXD1,,,,EVENTOUT,
+PortB,PB14,,TIM1_CH2N,,TIM8_CH2N,,SPI2_MISO,,USART3_RTS,,TIM12_CH1,,,OTG_HS_DM,,,EVENTOUT,
+PortB,PB15,RTC_REFIN,TIM1_CH3N,,TIM8_CH3N,,SPI2_MOSI/I2S2_SD,,,,TIM12_CH2,,,OTG_HS_DP,,,EVENTOUT,
+PortC,PC0,,,,,,,,,SAI2_FS_B,,OTG_HS_ULPI_STP,,FMC_SDNWE,,LCD_R5,EVENTOUT,ADC123_IN10
+PortC,PC1,TRACED0,,,,,SPI2_MOSI/I2S2_SD,SAI1_SD_A,,,,,ETH_MDC,,,,EVENTOUT,ADC123_IN11
+PortC,PC2,,,,,,SPI2_MISO,,,,,OTG_HS_ULPI_DIR,ETH_MII_TXD2,FMC_SDNE0,,,EVENTOUT,ADC123_IN12
+PortC,PC3,,,,,,SPI2_MOSI/I2S2_SD,,,,,OTG_HS_ULPI_NXT,ETH_MII_TX_CLK,FMC_SDCKE0,,,EVENTOUT,ADC123_IN13
+PortC,PC4,,,,,,I2S1_MCK,,,SPDIFRX_IN2,,,ETH_MII_RXD0/ETH_RMII_RXD0,FMC_SDNE0,,,EVENTOUT,ADC12_IN14
+PortC,PC5,,,,,,,,,SPDIFRX_IN3,,,ETH_MII_RXD1/ETH_RMII_RXD1,FMC_SDCKE0,,,EVENTOUT,ADC12_IN15
+PortC,PC6,,,TIM3_CH1,TIM8_CH1,,I2S2_MCK,,,USART6_TX,,,,SDMMC1_D6,DCMI_D0,LCD_HSYNC,EVENTOUT,
+PortC,PC7,,,TIM3_CH2,TIM8_CH2,,,I2S3_MCK,,USART6_RX,,,,SDMMC1_D7,DCMI_D1,LCD_G6,EVENTOUT,
+PortC,PC8,TRACED1,,TIM3_CH3,TIM8_CH3,,,,UART5_RTS,USART6_CK,,,,SDMMC1_D0,DCMI_D2,,EVENTOUT,
+PortC,PC9,MCO2,,TIM3_CH4,TIM8_CH4,I2C3_SDA,I2S_CKIN,,UART5_CTS,,QUADSPI_BK1_IO0,,,SDMMC1_D1,DCMI_D3,,EVENTOUT,
+PortC,PC10,,,,,,,SPI3_SCK/I2S3_CK,USART3_TX,UART4_TX,QUADSPI_BK1_IO1,,,SDMMC1_D2,DCMI_D8,LCD_R2,EVENTOUT,
+PortC,PC11,,,,,,,SPI3_MISO,USART3_RX,UART4_RX,QUADSPI_BK2_NCS,,,SDMMC1_D3,DCMI_D4,,EVENTOUT,
+PortC,PC12,TRACED3,,,,,,SPI3_MOSI/I2S3_SD,USART3_CK,UART5_TX,,,,SDMMC1_CK,DCMI_D9,,EVENTOUT,
+PortC,PC13,,,,,,,,,,,,,,,,EVENTOUT,
+PortC,PC14,,,,,,,,,,,,,,,,EVENTOUT,
+PortC,PC15,,,,,,,,,,,,,,,,EVENTOUT,
+PortD,PD0,,,,,,,,,,CAN1_RX,,,FMC_D2,,,EVENTOUT,
+PortD,PD1,,,,,,,,,,CAN1_TX,,,FMC_D3,,,EVENTOUT,
+PortD,PD2,TRACED2,,TIM3_ETR,,,,,,UART5_RX,,,,SDMMC1_CMD,DCMI_D11,,EVENTOUT,
+PortD,PD3,,,,,,SPI2_SCK/I2S2_CK,,USART2_CTS,,,,,FMC_CLK,DCMI_D5,LCD_G7,EVENTOUT,
+PortD,PD4,,,,,,,,USART2_RTS,,,,,FMC_NOE,,,EVENTOUT,
+PortD,PD5,,,,,,,,USART2_TX,,,,,FMC_NWE,,,EVENTOUT,
+PortD,PD6,,,,,,SPI3_MOSI/I2S3_SD,SAI1_SD_A,USART2_RX,,,,,FMC_NWAIT,DCMI_D10,LCD_B2,EVENTOUT,
+PortD,PD7,,,,,,,,USART2_CK,SPDIFRX_IN0,,,,FMC_NE1,,,EVENTOUT,
+PortD,PD8,,,,,,,,USART3_TX,SPDIFRX_IN1,,,,FMC_D13,,,EVENTOUT,
+PortD,PD9,,,,,,,,USART3_RX,,,,,FMC_D14,,,EVENTOUT,
+PortD,PD10,,,,,,,,USART3_CK,,,,,FMC_D15,,LCD_B3,EVENTOUT,
+PortD,PD11,,,,,I2C4_SMBA,,,USART3_CTS,,QUADSPI_BK1_IO0,SAI2_SD_A,,FMC_A16/FMC_CLE,,,EVENTOUT,
+PortD,PD12,,,TIM4_CH1,LPTIM1_IN1,I2C4_SCL,,,USART3_RTS,,QUADSPI_BK1_IO1,SAI2_FS_A,,FMC_A17/FMC_ALE,,,EVENTOUT,
+PortD,PD13,,,TIM4_CH2,LPTIM1_OUT,I2C4_SDA,,,,,QUADSPI_BK1_IO3,SAI2_SCK_A,,FMC_A18,,,EVENTOUT,
+PortD,PD14,,,TIM4_CH3,,,,,,UART8_CTS,,,,FMC_D0,,,EVENTOUT,
+PortD,PD15,,,TIM4_CH4,,,,,,UART8_RTS,,,,FMC_D1,,,EVENTOUT,
+PortE,PE0,,,TIM4_ETR,LPTIM1_ETR,,,,,UART8_RX,,SAI2_MCK_A,,FMC_NBL0,DCMI_D2,,EVENTOUT,
+PortE,PE1,,,,LPTIM1_IN2,,,,,UART8_TX,,,,FMC_NBL1,DCMI_D3,,EVENTOUT,
+PortE,PE2,TRACECLK,,,,,SPI4_SCK,SAI1_MCLK_A,,,QUADSPI_BK1_IO2,,ETH_MII_TXD3,FMC_A23,,,EVENTOUT,
+PortE,PE3,TRACED0,,,,,,SAI1_SD_B,,,,,,FMC_A19,,,EVENTOUT,
+PortE,PE4,TRACED1,,,,,SPI4_NSS,SAI1_FS_A,,,,,,FMC_A20,DCMI_D4,LCD_B0,EVENTOUT,
+PortE,PE5,TRACED2,,,TIM9_CH1,,SPI4_MISO,SAI1_SCK_A,,,,,,FMC_A21,DCMI_D6,LCD_G0,EVENTOUT,
+PortE,PE6,TRACED3,TIM1_BKIN2,,TIM9_CH2,,SPI4_MOSI,SAI1_SD_A,,,,SAI2_MCK_B,,FMC_A22,DCMI_D7,LCD_G1,EVENTOUT,
+PortE,PE7,,TIM1_ETR,,,,,,,UART7_RX,,QUADSPI_BK2_IO0,,FMC_D4,,,EVENTOUT,
+PortE,PE8,,TIM1_CH1N,,,,,,,UART7_TX,,QUADSPI_BK2_IO1,,FMC_D5,,,EVENTOUT,
+PortE,PE9,,TIM1_CH1,,,,,,,UART7_RTS,,QUADSPI_BK2_IO2,,FMC_D6,,,EVENTOUT,
+PortE,PE10,,TIM1_CH2N,,,,,,,UART7_CTS,,QUADSPI_BK2_IO3,,FMC_D7,,,EVENTOUT,
+PortE,PE11,,TIM1_CH2,,,,SPI4_NSS,,,,,SAI2_SD_B,,FMC_D8,,LCD_G3,EVENTOUT,
+PortE,PE12,,TIM1_CH3N,,,,SPI4_SCK,,,,,SAI2_SCK_B,,FMC_D9,,LCD_B4,EVENTOUT,
+PortE,PE13,,TIM1_CH3,,,,SPI4_MISO,,,,,SAI2_FS_B,,FMC_D10,,LCD_DE,EVENTOUT,
+PortE,PE14,,TIM1_CH4,,,,SPI4_MOSI,,,,,SAI2_MCK_B,,FMC_D11,,LCD_CLK,EVENTOUT,
+PortE,PE15,,TIM1_BKIN,,,,,,,,,,,FMC_D12,,LCD_R7,EVENTOUT,
+PortF,PF0,,,,,I2C2_SDA,,,,,,,,FMC_A0,,,EVENTOUT,
+PortF,PF1,,,,,I2C2_SCL,,,,,,,,FMC_A1,,,EVENTOUT,
+PortF,PF2,,,,,I2C2_SMBA,,,,,,,,FMC_A2,,,EVENTOUT,
+PortF,PF3,,,,,,,,,,,,,FMC_A3,,,EVENTOUT,ADC3_IN9
+PortF,PF4,,,,,,,,,,,,,FMC_A4,,,EVENTOUT,ADC3_IN14
+PortF,PF5,,,,,,,,,,,,,FMC_A5,,,EVENTOUT,ADC3_IN15
+PortF,PF6,,,,TIM10_CH1,,SPI5_NSS,SAI1_SD_B,,UART7_RX,QUADSPI_BK1_IO3,,,,,,EVENTOUT,ADC3_IN4
+PortF,PF7,,,,TIM11_CH1,,SPI5_SCK,SAI1_MCLK_B,,UART7_TX,QUADSPI_BK1_IO2,,,,,,EVENTOUT,ADC3_IN5
+PortF,PF8,,,,,,SPI5_MISO,SAI1_SCK_B,,UART7_RTS,TIM13_CH1,QUADSPI_BK1_IO0,,,,,EVENTOUT,ADC3_IN6
+PortF,PF9,,,,,,SPI5_MOSI,SAI1_FS_B,,UART7_CTS,TIM14_CH1,QUADSPI_BK1_IO1,,,,,EVENTOUT,ADC3_IN7
+PortF,PF10,,,,,,,,,,,,,,DCMI_D11,LCD_DE,EVENTOUT,ADC3_IN8
+PortF,PF11,,,,,,SPI5_MOSI,,,,,SAI2_SD_B,,FMC_SDNRAS,DCMI_D12,,EVENTOUT,
+PortF,PF12,,,,,,,,,,,,,FMC_A6,,,EVENTOUT,
+PortF,PF13,,,,,I2C4_SMBA,,,,,,,,FMC_A7,,,EVENTOUT,
+PortF,PF14,,,,,I2C4_SCL,,,,,,,,FMC_A8,,,EVENTOUT,
+PortF,PF15,,,,,I2C4_SDA,,,,,,,,FMC_A9,,,EVENTOUT,
+PortG,PG0,,,,,,,,,,,,,FMC_A10,,,EVENTOUT,
+PortG,PG1,,,,,,,,,,,,,FMC_A11,,,EVENTOUT,
+PortG,PG2,,,,,,,,,,,,,FMC_A12,,,EVENTOUT,
+PortG,PG3,,,,,,,,,,,,,FMC_A13,,,EVENTOUT,
+PortG,PG4,,,,,,,,,,,,,FMC_A14/FMC_BA0,,,EVENTOUT,
+PortG,PG5,,,,,,,,,,,,,FMC_A15/FMC_BA1,,,EVENTOUT,
+PortG,PG6,,,,,,,,,,,,,,DCMI_D12,LCD_R7,EVENTOUT,
+PortG,PG7,,,,,,,,,USART6_CK,,,,FMC_INT,DCMI_D13,LCD_CLK,EVENTOUT,
+PortG,PG8,,,,,,SPI6_NSS,,SPDIFRX_IN2,USART6_RTS,,,ETH_PPS_OUT,FMC_SDCLK,,,EVENTOUT,
+PortG,PG9,,,,,,,,SPDIFRX_IN3,USART6_RX,QUADSPI_BK2_IO2,SAI2_FS_B,,FMC_NE2/FMC_NCE,DCMI_VSYNC,,EVENTOUT,
+PortG,PG10,,,,,,,,,,LCD_G3,SAI2_SD_B,,FMC_NE3,DCMI_D2,LCD_B2,EVENTOUT,
+PortG,PG11,,,,,,,,SPDIFRX_IN0,,,,ETH_MII_TX_EN/ETH_RMII_TX_EN,,DCMI_D3,LCD_B3,EVENTOUT,
+PortG,PG12,,,,LPTIM1_IN1,,SPI6_MISO,,SPDIFRX_IN1,USART6_RTS,LCD_B4,,,FMC_NE4,,LCD_B1,EVENTOUT,
+PortG,PG13,TRACED0,,,LPTIM1_OUT,,SPI6_SCK,,,USART6_CTS,,,ETH_MII_TXD0/ETH_RMII_TXD0,FMC_A24,,LCD_R0,EVENTOUT,
+PortG,PG14,TRACED1,,,LPTIM1_ETR,,SPI6_MOSI,,,USART6_TX,QUADSPI_BK2_IO3,,ETH_MII_TXD1/ETH_RMII_TXD1,FMC_A25,,LCD_B0,EVENTOUT,
+PortG,PG15,,,,,,,,,USART6_CTS,,,,FMC_SDNCAS,DCMI_D13,,EVENTOUT,
+PortH,PH0,,,,,,,,,,,,,,,,EVENTOUT,
+PortH,PH1,,,,,,,,,,,,,,,,EVENTOUT,
+PortH,PH2,,,,LPTIM1_IN2,,,,,,QUADSPI_BK2_IO0,SAI2_SCK_B,ETH_MII_CRS,FMC_SDCKE0,,LCD_R0,EVENTOUT,
+PortH,PH3,,,,,,,,,,QUADSPI_BK2_IO1,SAI2_MCK_B,ETH_MII_COL,FMC_SDNE0,,LCD_R1,EVENTOUT,
+PortH,PH4,,,,,I2C2_SCL,,,,,,OTG_HS_ULPI_NXT,,,,,EVENTOUT,
+PortH,PH5,,,,,I2C2_SDA,SPI5_NSS,,,,,,,FMC_SDNWE,,,EVENTOUT,
+PortH,PH6,,,,,I2C2_SMBA,SPI5_SCK,,,,TIM12_CH1,,ETH_MII_RXD2,FMC_SDNE1,DCMI_D8,,EVENTOUT,
+PortH,PH7,,,,,I2C3_SCL,SPI5_MISO,,,,,,ETH_MII_RXD3,FMC_SDCKE1,DCMI_D9,,EVENTOUT,
+PortH,PH8,,,,,I2C3_SDA,,,,,,,,FMC_D16,DCMI_HSYNC,LCD_R2,EVENTOUT,
+PortH,PH9,,,,,I2C3_SMBA,,,,,TIM12_CH2,,,FMC_D17,DCMI_D0,LCD_R3,EVENTOUT,
+PortH,PH10,,,TIM5_CH1,,I2C4_SMBA,,,,,,,,FMC_D18,DCMI_D1,LCD_R4,EVENTOUT,
+PortH,PH11,,,TIM5_CH2,,I2C4_SCL,,,,,,,,FMC_D19,DCMI_D2,LCD_R5,EVENTOUT,
+PortH,PH12,,,TIM5_CH3,,I2C4_SDA,,,,,,,,FMC_D20,DCMI_D3,LCD_R6,EVENTOUT,
+PortH,PH13,,,,TIM8_CH1N,,,,,,CAN1_TX,,,FMC_D21,,LCD_G2,EVENTOUT,
+PortH,PH14,,,,TIM8_CH2N,,,,,,,,,FMC_D22,DCMI_D4,LCD_G3,EVENTOUT,
+PortH,PH15,,,,TIM8_CH3N,,,,,,,,,FMC_D23,DCMI_D11,LCD_G4,EVENTOUT,
+PortI,PI0,,,TIM5_CH4,,,SPI2_NSS/I2S2_WS,,,,,,,FMC_D24,DCMI_D13,LCD_G5,EVENTOUT,
+PortI,PI1,,,,TIM8_BKIN2,,SPI2_SCK/I2S2_CK,,,,,,,FMC_D25,DCMI_D8,LCD_G6,EVENTOUT,
+PortI,PI2,,,,TIM8_CH4,,SPI2_MISO,,,,,,,FMC_D26,DCMI_D9,LCD_G7,EVENTOUT,
+PortI,PI3,,,,TIM8_ETR,,SPI2_MOSI/I2S2_SD,,,,,,,FMC_D27,DCMI_D10,,EVENTOUT,
+PortI,PI4,,,,TIM8_BKIN,,,,,,,SAI2_MCK_A,,FMC_NBL2,DCMI_D5,LCD_B4,EVENTOUT,
+PortI,PI5,,,,TIM8_CH1,,,,,,,SAI2_SCK_A,,FMC_NBL3,DCMI_VSYNC,LCD_B5,EVENTOUT,
+PortI,PI6,,,,TIM8_CH2,,,,,,,SAI2_SD_A,,FMC_D28,DCMI_D6,LCD_B6,EVENTOUT,
+PortI,PI7,,,,TIM8_CH3,,,,,,,SAI2_FS_A,,FMC_D29,DCMI_D7,LCD_B7,EVENTOUT,
+PortI,PI8,,,,,,,,,,,,,,,,EVENTOUT,
+PortI,PI9,,,,,,,,,,CAN1_RX,,,FMC_D30,,LCD_VSYNC,EVENTOUT,
+PortI,PI10,,,,,,,,,,,,ETH_MII_RX_ER,FMC_D31,,LCD_HSYNC,EVENTOUT,
+PortI,PI11,,,,,,,,,,,OTG_HS_ULPI_DIR,,,,,EVENTOUT,
+PortI,PI12,,,,,,,,,,,,,,,LCD_HSYNC,EVENTOUT,
+PortI,PI13,,,,,,,,,,,,,,,LCD_VSYNC,EVENTOUT,
+PortI,PI14,,,,,,,,,,,,,,,LCD_CLK,EVENTOUT,
+PortI,PI15,,,,,,,,,,,,,,,LCD_R0,EVENTOUT,
+PortJ,PJ0,,,,,,,,,,,,,,,LCD_R1,EVENTOUT,
+PortJ,PJ1,,,,,,,,,,,,,,,LCD_R2,EVENTOUT,
+PortJ,PJ2,,,,,,,,,,,,,,,LCD_R3,EVENTOUT,
+PortJ,PJ3,,,,,,,,,,,,,,,LCD_R4,EVENTOUT,
+PortJ,PJ4,,,,,,,,,,,,,,,LCD_R5,EVENTOUT,
+PortJ,PJ5,,,,,,,,,,,,,,,LCD_R6,EVENTOUT,
+PortJ,PJ6,,,,,,,,,,,,,,,LCD_R7,EVENTOUT,
+PortJ,PJ7,,,,,,,,,,,,,,,LCD_G0,EVENTOUT,
+PortJ,PJ8,,,,,,,,,,,,,,,LCD_G1,EVENTOUT,
+PortJ,PJ9,,,,,,,,,,,,,,,LCD_G2,EVENTOUT,
+PortJ,PJ10,,,,,,,,,,,,,,,LCD_G3,EVENTOUT,
+PortJ,PJ11,,,,,,,,,,,,,,,LCD_G4,EVENTOUT,
+PortJ,PJ12,,,,,,,,,,,,,,,LCD_B0,EVENTOUT,
+PortJ,PJ13,,,,,,,,,,,,,,,LCD_B1,EVENTOUT,
+PortJ,PJ14,,,,,,,,,,,,,,,LCD_B2,EVENTOUT,
+PortJ,PJ15,,,,,,,,,,,,,,,LCD_B3,EVENTOUT,
+PortK,PK0,,,,,,,,,,,,,,,LCD_G5,EVENTOUT,
+PortK,PK1,,,,,,,,,,,,,,,LCD_G6,EVENTOUT,
+PortK,PK2,,,,,,,,,,,,,,,LCD_G7,EVENTOUT,
+PortK,PK3,,,,,,,,,,,,,,,LCD_B4,EVENTOUT,
+PortK,PK4,,,,,,,,,,,,,,,LCD_B5,EVENTOUT,
+PortK,PK5,,,,,,,,,,,,,,,LCD_B6,EVENTOUT,
+PortK,PK6,,,,,,,,,,,,,,,LCD_B7,EVENTOUT,
+PortK,PK7,,,,,,,,,,,,,,,LCD_DE,EVENTOUT,
diff --git a/ports/stm32/boards/stm32f767.ld b/ports/stm32/boards/stm32f767.ld
index c05fd8021b079..d07f2ecbef085 100644
--- a/ports/stm32/boards/stm32f767.ld
+++ b/ports/stm32/boards/stm32f767.ld
@@ -5,7 +5,7 @@
 /* Specify the memory areas */
 MEMORY
 {
-    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 1024K
+    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 2048K
     FLASH_ISR (rx)  : ORIGIN = 0x08000000, LENGTH = 32K     /* sector 0, 32K */
     FLASH_APP (rx)  : ORIGIN = 0x08008000, LENGTH = 2016K   /* sectors 1-11 3x32K 1*128K 7*256K */
     FLASH_FS (r)    : ORIGIN = 0x08008000, LENGTH = 96K     /* sectors 1, 2, 3 (32K each) */
@@ -18,13 +18,13 @@ MEMORY
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* Define tho top end of the stack.  The stack is full descending so begins just
-   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
-   aligned for a call. */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 32K; /* tunable */
 
 /* RAM extents for the garbage collector */
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x20078000; /* tunable */
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32f769.ld b/ports/stm32/boards/stm32f769.ld
index d6da439435903..ebc6d033d9bb6 100644
--- a/ports/stm32/boards/stm32f769.ld
+++ b/ports/stm32/boards/stm32f769.ld
@@ -17,13 +17,13 @@ MEMORY
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* Define tho top end of the stack.  The stack is full descending so begins just
-   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
-   aligned for a call. */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 32K; /* tunable */
 
 /* RAM extents for the garbage collector */
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x20078000; /* tunable */
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32f7xx_hal_conf_base.h b/ports/stm32/boards/stm32f7xx_hal_conf_base.h
new file mode 100644
index 0000000000000..05ab10fea08ad
--- /dev/null
+++ b/ports/stm32/boards/stm32f7xx_hal_conf_base.h
@@ -0,0 +1,99 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_STM32F7XX_HAL_CONF_BASE_H
+#define MICROPY_INCLUDED_STM32F7XX_HAL_CONF_BASE_H
+
+// Include various HAL modules for convenience
+#include "stm32f7xx_hal_dma.h"
+#include "stm32f7xx_hal_adc.h"
+#include "stm32f7xx_hal_can.h"
+#include "stm32f7xx_hal_cortex.h"
+#include "stm32f7xx_hal_crc.h"
+#include "stm32f7xx_hal_dac.h"
+#include "stm32f7xx_hal_dcmi.h"
+#include "stm32f7xx_hal_flash.h"
+#include "stm32f7xx_hal_gpio.h"
+#include "stm32f7xx_hal_hash.h"
+#include "stm32f7xx_hal_hcd.h"
+#include "stm32f7xx_hal_i2c.h"
+#include "stm32f7xx_hal_i2s.h"
+#include "stm32f7xx_hal_iwdg.h"
+#include "stm32f7xx_hal_mmc.h"
+#include "stm32f7xx_hal_pcd.h"
+#include "stm32f7xx_hal_pwr.h"
+#include "stm32f7xx_hal_rcc.h"
+#include "stm32f7xx_hal_rtc.h"
+#include "stm32f7xx_hal_sd.h"
+#include "stm32f7xx_hal_sdram.h"
+#include "stm32f7xx_hal_spi.h"
+#include "stm32f7xx_hal_tim.h"
+#include "stm32f7xx_hal_uart.h"
+#include "stm32f7xx_hal_usart.h"
+#include "stm32f7xx_hal_wwdg.h"
+
+// Enable various HAL modules
+#define HAL_ADC_MODULE_ENABLED
+#define HAL_CAN_MODULE_ENABLED
+#define HAL_CORTEX_MODULE_ENABLED
+#define HAL_CRC_MODULE_ENABLED
+#define HAL_DAC_MODULE_ENABLED
+#define HAL_DCMI_MODULE_ENABLED
+#define HAL_DMA_MODULE_ENABLED
+#define HAL_FLASH_MODULE_ENABLED
+#define HAL_GPIO_MODULE_ENABLED
+#define HAL_HASH_MODULE_ENABLED
+#define HAL_HCD_MODULE_ENABLED
+#define HAL_I2C_MODULE_ENABLED
+#define HAL_I2S_MODULE_ENABLED
+#define HAL_IWDG_MODULE_ENABLED
+#define HAL_MMC_MODULE_ENABLED
+#define HAL_PCD_MODULE_ENABLED
+#define HAL_PWR_MODULE_ENABLED
+#define HAL_RCC_MODULE_ENABLED
+#define HAL_RTC_MODULE_ENABLED
+#define HAL_SD_MODULE_ENABLED
+#define HAL_SDRAM_MODULE_ENABLED
+#define HAL_SPI_MODULE_ENABLED
+#define HAL_TIM_MODULE_ENABLED
+#define HAL_UART_MODULE_ENABLED
+#define HAL_USART_MODULE_ENABLED
+#define HAL_WWDG_MODULE_ENABLED
+
+// Oscillator values in Hz
+#define HSI_VALUE (16000000)
+#define LSI_VALUE (32000)
+
+// SysTick has the highest priority
+#define TICK_INT_PRIORITY (0x00)
+
+// Miscellaneous HAL settings
+#define ART_ACCLERATOR_ENABLE   1
+#define USE_RTOS                0
+
+// HAL parameter assertions are disabled
+#define assert_param(expr) ((void)0)
+
+#endif // MICROPY_INCLUDED_STM32F7XX_HAL_CONF_BASE_H
diff --git a/ports/stm32/boards/stm32h743.ld b/ports/stm32/boards/stm32h743.ld
index ca429edb7be17..69738ab8b913a 100644
--- a/ports/stm32/boards/stm32h743.ld
+++ b/ports/stm32/boards/stm32h743.ld
@@ -17,13 +17,13 @@ MEMORY
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* Define tho top end of the stack.  The stack is full descending so begins just
-   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
-   aligned for a call. */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte
+   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 16K; /* tunable */
 
 /* RAM extents for the garbage collector */
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x2407C000; /* tunable */
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32h7xx_hal_conf_base.h b/ports/stm32/boards/stm32h7xx_hal_conf_base.h
new file mode 100644
index 0000000000000..5c97e2c44b720
--- /dev/null
+++ b/ports/stm32/boards/stm32h7xx_hal_conf_base.h
@@ -0,0 +1,99 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_STM32H7XX_HAL_CONF_BASE_H
+#define MICROPY_INCLUDED_STM32H7XX_HAL_CONF_BASE_H
+
+// Include various HAL modules for convenience
+#include "stm32h7xx_hal_dma.h"
+#include "stm32h7xx_hal_mdma.h"
+#include "stm32h7xx_hal_adc.h"
+#include "stm32h7xx_hal_cortex.h"
+#include "stm32h7xx_hal_crc.h"
+#include "stm32h7xx_hal_dac.h"
+#include "stm32h7xx_hal_dcmi.h"
+#include "stm32h7xx_hal_fdcan.h"
+#include "stm32h7xx_hal_flash.h"
+#include "stm32h7xx_hal_gpio.h"
+#include "stm32h7xx_hal_hash.h"
+#include "stm32h7xx_hal_hcd.h"
+#include "stm32h7xx_hal_i2c.h"
+#include "stm32h7xx_hal_i2s.h"
+#include "stm32h7xx_hal_iwdg.h"
+#include "stm32h7xx_hal_pcd.h"
+#include "stm32h7xx_hal_pwr.h"
+#include "stm32h7xx_hal_rcc.h"
+#include "stm32h7xx_hal_rtc.h"
+#include "stm32h7xx_hal_sd.h"
+#include "stm32h7xx_hal_sdram.h"
+#include "stm32h7xx_hal_spi.h"
+#include "stm32h7xx_hal_tim.h"
+#include "stm32h7xx_hal_uart.h"
+#include "stm32h7xx_hal_usart.h"
+#include "stm32h7xx_hal_wwdg.h"
+
+// Enable various HAL modules
+#define HAL_ADC_MODULE_ENABLED
+#define HAL_CORTEX_MODULE_ENABLED
+#define HAL_CRC_MODULE_ENABLED
+#define HAL_DAC_MODULE_ENABLED
+#define HAL_DCMI_MODULE_ENABLED
+#define HAL_DMA_MODULE_ENABLED
+#define HAL_FDCAN_MODULE_ENABLED
+#define HAL_FLASH_MODULE_ENABLED
+#define HAL_GPIO_MODULE_ENABLED
+#define HAL_HASH_MODULE_ENABLED
+#define HAL_HCD_MODULE_ENABLED
+#define HAL_I2C_MODULE_ENABLED
+#define HAL_I2S_MODULE_ENABLED
+#define HAL_IWDG_MODULE_ENABLED
+#define HAL_PCD_MODULE_ENABLED
+#define HAL_PWR_MODULE_ENABLED
+#define HAL_RCC_MODULE_ENABLED
+#define HAL_RTC_MODULE_ENABLED
+#define HAL_SD_MODULE_ENABLED
+#define HAL_SDRAM_MODULE_ENABLED
+#define HAL_SPI_MODULE_ENABLED
+#define HAL_TIM_MODULE_ENABLED
+#define HAL_UART_MODULE_ENABLED
+#define HAL_USART_MODULE_ENABLED
+#define HAL_WWDG_MODULE_ENABLED
+
+// Oscillator values in Hz
+#define CSI_VALUE (4000000)
+#define HSI_VALUE (64000000)
+
+// SysTick has the highest priority
+#define TICK_INT_PRIORITY (0x00)
+
+// Miscellaneous HAL settings
+#define USE_RTOS            0
+#define USE_SD_TRANSCEIVER  0
+#define USE_SPI_CRC         1
+
+// HAL parameter assertions are disabled
+#define assert_param(expr) ((void)0)
+
+#endif // MICROPY_INCLUDED_STM32H7XX_HAL_CONF_BASE_H
diff --git a/ports/stm32/boards/stm32l072_af.csv b/ports/stm32/boards/stm32l072_af.csv
new file mode 100644
index 0000000000000..0b1115b164a90
--- /dev/null
+++ b/ports/stm32/boards/stm32l072_af.csv
@@ -0,0 +1,84 @@
+Port,Pin,AF0,AF1,AF2,AF3,AF4,AF5,AF6,AF7,,
+,,SPI1/SPI2/I2S2/USART1/2/LPUART1/USB/LPTIM1/TSC/TIM2/21/22/EVENTOUT/SYS_AF,SPI1/SPI2/I2S2/I2C1/TIM2/21,SPI1/SPI2/I2S2/LPUART1/USART5/USB/LPTIM1/TIM2/3/EVENTOUT/SYS_AF,I2C1/TSC/EVENTOUT,I2C1/USART1/2/LPUART1/TIM3/22/EVENTOUT,SPI2/I2S2/I2C2/USART1/TIM2/21/22,I2C1/2/LPUART1/USART4/UASRT5/TIM21/EVENTOUT,I2C3/LPUART1/COMP1/2/TIM3,,ADC
+PortA,PA0,,,TIM2_CH1,TSC_G1_IO1,USART2_CTS,TIM2_ETR,USART4_TX,COMP1_OUT,,ADC_IN0
+PortA,PA1,EVENTOUT,,TIM2_CH2,TSC_G1_IO2,USART2_RTS_DE,TIM21_ETR,USART4_RX,,,ADC_IN1
+PortA,PA2,TIM21_CH1,,TIM2_CH3,TSC_G1_IO3,USART2_TX,,LPUART1_TX,COMP2_OUT,,ADC_IN2
+PortA,PA3,TIM21_CH2,,TIM2_CH4,TSC_G1_IO4,USART2_RX,,LPUART1_RX,,,ADC_IN3
+PortA,PA4,SPI1_NSS,,,TSC_G2_IO1,USART2_CK,TIM22_ETR,,,,ADC_IN4
+PortA,PA5,SPI1_SCK,,TIM2_ETR,TSC_G2_IO2,,TIM2_CH1,,,,ADC_IN5
+PortA,PA6,SPI1_MISO,,TIM3_CH1,TSC_G2_IO3,LPUART1_CTS,TIM22_CH1,EVENTOUT,COMP1_OUT,,ADC_IN6
+PortA,PA7,SPI1_MOSI,,TIM3_CH2,TSC_G2_IO4,,TIM22_CH2,EVENTOUT,COMP2_OUT,,ADC_IN7
+PortA,PA8,MCO,,USB_CRS_SYNC,EVENTOUT,USART1_CK,,,I2C3_SCL,,
+PortA,PA9,MCO,,,TSC_G4_IO1,USART1_TX,,I2C1_SCL,I2C3_SMBA,,
+PortA,PA10,,,,TSC_G4_IO2,USART1_RX,,I2C1_SDA,,,
+PortA,PA11,SPI1_MISO,,EVENTOUT,TSC_G4_IO3,USART1_CTS,,,COMP1_OUT,,
+PortA,PA12,SPI1_MOSI,,EVENTOUT,TSC_G4_IO4,USART1_RTS_DE,,,COMP2_OUT,,
+PortA,PA13,SWDIO,,USB_NOE,,,,LPUART1_RX,,,
+PortA,PA14,SWCLK,,,,USART2_TX,,LPUART1_TX,,,
+PortA,PA15,SPI1_NSS,,TIM2_ETR,EVENTOUT,USART2_RX,TIM2_CH1,USART4_RTS_DE,,,
+PortB,PB0,EVENTOUT,,TIM3_CH3,TSC_G3_IO2,,,,,,ADC_IN8
+PortB,PB1,,,TIM3_CH4,TSC_G3_IO3,LPUART1_RTS_DE,,,,,ADC_IN9
+PortB,PB2,,,LPTIM1_OUT,TSC_G3_IO4,,,,I2C3_SMBA,,
+PortB,PB3,SPI1_SCK,,TIM2_CH2,TSC_G5_IO1,EVENTOUT,USART1_RTS_DE,USART5_TX,,,
+PortB,PB4,SPI1_MISO,,TIM3_CH1,TSC_G5_IO2,TIM22_CH1,USART1_CTS,USART5_RX,I2C3_SDA,,
+PortB,PB5,SPI1_MOSI,,LPTIM1_IN1,I2C1_SMBA,TIM3_CH2/TIM22_CH2,USART1_CK,USART5_CK/USART5_RTS_DE,,,
+PortB,PB6,USART1_TX,I2C1_SCL,LPTIM1_ETR,TSC_G5_IO3,,,,,,
+PortB,PB7,USART1_RX,I2C1_SDA,LPTIM1_IN2,TSC_G5_IO4,,,USART4_CTS,,,
+PortB,PB8,,,,TSC_SYNC,I2C1_SCL,,,,,
+PortB,PB9,,,EVENTOUT,,I2C1_SDA,SPI2_NSS/I2S2_WS,,,,
+PortB,PB10,,,TIM2_CH3,TSC_SYNC,LPUART1_TX,SPI2_SCK,I2C2_SCL,LPUART1_RX,,
+PortB,PB11,EVENTOUT,,TIM2_CH4,TSC_G6_IO1,LPUART1_RX,,I2C2_SDA,LPUART1_TX,,
+PortB,PB12,SPI2_NSS/I2S2_WS,,LPUART1_RTS_DE,TSC_G6_IO2,I2C2_SMBA,,EVENTOUT,,,
+PortB,PB13,SPI2_SCK/I2S2_CK,,MCO,TSC_G6_IO3,LPUART1_CTS,I2C2_SCL,TIM21_CH1,,,
+PortB,PB14,SPI2_MISO/I2S2_MCK,,RTC_OUT,TSC_G6_IO4,LPUART1_RTS_DE,I2C2_SDA,TIM21_CH2,,,
+PortB,PB15,SPI2_MOSI/I2S2_SD,,RTC_REFIN,,,,,,,
+PortC,PC0,LPTIM1_IN1,,EVENTOUT,TSC_G7_IO1,,,LPUART1_RX,I2C3_SCL,,ADC_IN10
+PortC,PC1,LPTIM1_OUT,,EVENTOUT,TSC_G7_IO2,,,LPUART1_TX,I2C3_SDA,,ADC_IN11
+PortC,PC2,LPTIM1_IN2,,SPI2_MISO/I2S2_MCK,TSC_G7_IO3,,,,,,ADC_IN12
+PortC,PC3,LPTIM1_ETR,,SPI2_MOSI/I2S2_SD,TSC_G7_IO4,,,,,,ADC_IN13
+PortC,PC4,EVENTOUT,,LPUART1_TX,,,,,,,ADC_IN14
+PortC,PC5,LPUART1_RX,,TSC_G3_IO1,,,,,,,ADC_IN15
+PortC,PC6,TIM22_CH1,,TIM3_CH1,TSC_G8_IO1,,,,,,
+PortC,PC7,TIM22_CH2,,TIM3_CH2,TSC_G8_IO2,,,,,,
+PortC,PC8,TIM22_ETR,,TIM3_CH3,TSC_G8_IO3,,,,,,
+PortC,PC9,TIM21_ETR,,USB_NOE/TIM3_CH4,TSC_G8_IO4,,,,I2C3_SDA,,
+PortC,PC10,LPUART1_TX,,,,,,USART4_TX,,,
+PortC,PC11,LPUART1_RX,,,,,,USART4_RX,,,
+PortC,PC12,,,USART5_TX,,,,USART4_CK,,,
+PortC,PC13,,,,,,,,,,
+PortC,PC14,,,,,,,,,,
+PortC,PC15,,,,,,,,,,
+PortD,PD0,TIM21_CH1,SPI2_NSS/I2S2_WS,,,,,,,,
+PortD,PD1,,SPI2_SCK/I2S2_CK,,,,,,,,
+PortD,PD2,LPUART1_RTS_DE,,TIM3_ETR,,,,USART5_RX,,,
+PortD,PD3,USART2_CTS,,SPI2_MISO/I2S2_MCK,,,,,,,
+PortD,PD4,USART2_RTS_DE,SPI2_MOSI/I2S2_SD,,,,,,,,
+PortD,PD5,USART2_TX,,,,,,,,,
+PortD,PD6,USART2_RX,,,,,,,,,
+PortD,PD7,USART2_CK,TIM21_CH2,,,,,,,,
+PortD,PD8,LPUART1_TX,,,,,,,,,
+PortD,PD9,LPUART1_RX,,,,,,,,,
+PortD,PD10,,,,,,,,,,
+PortD,PD11,LPUART1_CTS,,,,,,,,,
+PortD,PD12,LPUART1_RTS_DE,,,,,,,,,
+PortD,PD13,,,,,,,,,,
+PortD,PD14,,,,,,,,,,
+PortD,PD15,USB_CRS_SYNC,,,,,,,,,
+PortE,PE0,,,EVENTOUT,,,,,,,
+PortE,PE1,,,EVENTOUT,,,,,,,
+PortE,PE2,,,TIM3_ETR,,,,,,,
+PortE,PE3,TIM22_CH1,,TIM3_CH1,,,,,,,
+PortE,PE4,TIM22_CH2,,TIM3_CH2,,,,,,,
+PortE,PE5,TIM21_CH1,,TIM3_CH3,,,,,,,
+PortE,PE6,TIM21_CH2,,TIM3_CH4,,,,,,,
+PortE,PE7,,,,,,,USART5_CK/USART5_RTS_DE,,,
+PortE,PE8,,,,,,,USART4_TX,,,
+PortE,PE9,TIM2_CH1,,TIM2_ETR,,,,USART4_RX,,,
+PortE,PE10,TIM2_CH2,,,,,,USART5_TX,,,
+PortE,PE11,TIM2_CH3,,,,,,USART5_RX,,,
+PortE,PE12,TIM2_CH4,,SPI1_NSS,,,,,,,
+PortE,PE13,,,SPI1_SCK,,,,,,,
+PortE,PE14,,,SPI1_MISO,,,,,,,
+PortE,PE15,,,SPI1_MOSI,,,,,,,
+PortH,PH0,USB_CRS_SYNC,,,,,,,,,
+PortH,PH1,,,,,,,,,,
diff --git a/ports/stm32/boards/stm32l072xz.ld b/ports/stm32/boards/stm32l072xz.ld
new file mode 100644
index 0000000000000..538950747be00
--- /dev/null
+++ b/ports/stm32/boards/stm32l072xz.ld
@@ -0,0 +1,27 @@
+/*
+    GNU linker script for STM32F072xZ
+*/
+
+/* Specify the memory areas */
+MEMORY
+{
+    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 192K
+    RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 20K
+}
+
+/* produce a link error if there is not this amount of RAM for these sections */
+_minimum_stack_size = 2K;
+_minimum_heap_size = 8K;
+
+_ram_start = ORIGIN(RAM);
+_ram_end = ORIGIN(RAM) + LENGTH(RAM);
+
+/* Define the top end of the stack.  The stack is full descending so begins just
+   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
+   aligned for a call. */
+_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
+_sstack = _estack - 4K;
+
+/* RAM extents for the main heap */
+_heap_start = _ebss;
+_heap_end = _sstack;
diff --git a/ports/stm32/boards/stm32l0xx_hal_conf_base.h b/ports/stm32/boards/stm32l0xx_hal_conf_base.h
new file mode 100644
index 0000000000000..ed524fecca9c3
--- /dev/null
+++ b/ports/stm32/boards/stm32l0xx_hal_conf_base.h
@@ -0,0 +1,91 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_STM32L0XX_HAL_CONF_BASE_H
+#define MICROPY_INCLUDED_STM32L0XX_HAL_CONF_BASE_H
+
+// Include various HAL modules for convenience
+#include "stm32l0xx_hal_dma.h"
+#include "stm32l0xx_hal_adc.h"
+#include "stm32l0xx_hal_cortex.h"
+#include "stm32l0xx_hal_crc.h"
+#include "stm32l0xx_hal_dac.h"
+#include "stm32l0xx_hal_flash.h"
+#include "stm32l0xx_hal_gpio.h"
+#include "stm32l0xx_hal_i2c.h"
+#include "stm32l0xx_hal_i2s.h"
+#include "stm32l0xx_hal_iwdg.h"
+#include "stm32l0xx_hal_pcd.h"
+#include "stm32l0xx_hal_pwr.h"
+#include "stm32l0xx_hal_rcc.h"
+#include "stm32l0xx_hal_rtc.h"
+#include "stm32l0xx_hal_spi.h"
+#include "stm32l0xx_hal_tim.h"
+#include "stm32l0xx_hal_uart.h"
+#include "stm32l0xx_hal_usart.h"
+#include "stm32l0xx_hal_wwdg.h"
+
+// Enable various HAL modules
+#define HAL_MODULE_ENABLED
+#define HAL_ADC_MODULE_ENABLED
+#define HAL_CORTEX_MODULE_ENABLED
+#define HAL_CRC_MODULE_ENABLED
+#define HAL_DAC_MODULE_ENABLED
+#define HAL_DMA_MODULE_ENABLED
+#define HAL_FLASH_MODULE_ENABLED
+#define HAL_GPIO_MODULE_ENABLED
+#define HAL_I2C_MODULE_ENABLED
+#define HAL_I2S_MODULE_ENABLED
+#define HAL_IWDG_MODULE_ENABLED
+#define HAL_PCD_MODULE_ENABLED
+#define HAL_PWR_MODULE_ENABLED
+#define HAL_RCC_MODULE_ENABLED
+#define HAL_RTC_MODULE_ENABLED
+#define HAL_SPI_MODULE_ENABLED
+#define HAL_TIM_MODULE_ENABLED
+#define HAL_UART_MODULE_ENABLED
+#define HAL_USART_MODULE_ENABLED
+#define HAL_WWDG_MODULE_ENABLED
+
+// Oscillator values in Hz
+#define HSI_VALUE   (16000000)
+#define HSI48_VALUE (48000000)
+#define LSI_VALUE   (37000)
+#define MSI_VALUE   (2097152)
+
+// SysTick has the highest priority
+#define TICK_INT_PRIORITY (0x00)
+
+// Miscellaneous HAL settings
+#define PREFETCH_ENABLE         1
+#define PREREAD_ENABLE          0
+#define BUFFER_CACHE_DISABLE    0
+#define USE_RTOS                0
+#define USE_SPI_CRC             0
+
+// HAL parameter assertions are disabled
+#define assert_param(expr) ((void)0)
+
+#endif // MICROPY_INCLUDED_STM32L0XX_HAL_CONF_BASE_H
diff --git a/ports/stm32/boards/stm32l432.ld b/ports/stm32/boards/stm32l432.ld
index 70956c95bef69..4699543d66912 100644
--- a/ports/stm32/boards/stm32l432.ld
+++ b/ports/stm32/boards/stm32l432.ld
@@ -5,23 +5,30 @@
 /* Specify the memory areas */
 MEMORY
 {
-    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 256K
-    FLASH_TEXT (rx) : ORIGIN = 0x08000000, LENGTH = 256K
-    RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 48K
-    SRAM2 (xrw)     : ORIGIN = 0x10000000, LENGTH = 16K
+    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 230K /* sectors 0-114 */
+    FLASH_FS (r)    : ORIGIN = 0x08060000, LENGTH = 26K /* sectors 115-127 */
+    RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 64K /* SRAM1, 48K + SRAM2, 16K */
 }
 
 /* produce a link error if there is not this amount of RAM for these sections */
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* Define the top end of the stack.  The stack is full descending so begins just
-   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
-   aligned for a call. */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte of RAM,
+   or bottom of FS cache..  Note that EABI requires the stack to be 8-byte aligned for a call. */
 
 /* RAM extents for the garbage collector */
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
+
+_ram_fs_cache_end = _ram_end;
+_ram_fs_cache_start = _ram_fs_cache_end - 2K; /* fs cache = 2K */
+
+_estack = _ram_fs_cache_start - _estack_reserve;
+_sstack = _estack - 10K; /* stack = 10K */
+
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x2000A800; /* room for a 6k stack */
+_heap_end = _sstack; /* bss + heap = 52K, tunable by adjusting stack size */
+
+_flash_fs_start = ORIGIN(FLASH_FS);
+_flash_fs_end   = ORIGIN(FLASH_FS) + LENGTH(FLASH_FS);
diff --git a/ports/stm32/boards/stm32l452_af.csv b/ports/stm32/boards/stm32l452_af.csv
new file mode 100644
index 0000000000000..f7170d1c65db5
--- /dev/null
+++ b/ports/stm32/boards/stm32l452_af.csv
@@ -0,0 +1,85 @@
+Port,,AF0,AF1,AF2,AF3,AF4,AF5,AF6,AF7,AF8,AF9,AF10,AF11,AF12,AF13,AF14,AF15,,,
+,,SYS_AF,TIM1/TIM2/LPTIM1,I2C4/TIM1/TIM2/TIM3,I2C4/USART2/CAN1/TIM1,I2C1/I2C2/I2C3/I2C4,SPI1/SPI2/I2C4,SPI3/DFSDM/COMP1,USART1/USART2/USART3,UART4/LPUART1/CAN1,CAN1/TSC,CAN1/USB/QUADSPI,,SDMMC1/COMP1/COMP2,SAI1,TIM2/TIM15/TIM16/LPTIM2,EVENTOUT,ADC,COMP,DAC
+PortA,PA0,,TIM2_CH1,,,,,,USART2_CTS,UART4_TX,,,,COMP1_OUT,SAI1_EXTCLK,TIM2_ETR,EVENTOUT,ADC12_IN5,COMP1_INM,
+PortA,PA1,,TIM2_CH2,,,I2C1_SMBA,SPI1_SCK,,USART2_RTS/USART2_DE,UART4_RX,,,,,,TIM15_CH1N,EVENTOUT,ADC12_IN6,COMP1_INP,
+PortA,PA2,,TIM2_CH3,,,,,,USART2_TX,LPUART1_TX,,QUADSPI_BK1_NCS,,COMP2_OUT,,TIM15_CH1,EVENTOUT,ADC12_IN7,COMP2_INM,
+PortA,PA3,,TIM2_CH4,,,,,,USART2_RX,LPUART1_RX,,QUADSPI_CLK,,,SAI1_MCLK_A,TIM15_CH2,EVENTOUT,ADC12_IN8,COMP2_INP,
+PortA,PA4,,,,,,SPI1_NSS,SPI3_NSS,USART2_CK,,,,,,SAI1_FS_B,LPTIM2_OUT,EVENTOUT,ADC12_IN9,COMP1_INM/COMP2_INM,DAC1_OUT1
+PortA,PA5,,TIM2_CH1,TIM2_ETR,,,SPI1_SCK,DFSDM1_CKOUT,,,,,,,,LPTIM2_ETR,EVENTOUT,ADC12_IN10,COMP1_INM/COMP2_INM,
+PortA,PA6,,TIM1_BKIN,TIM3_CH1,,,SPI1_MISO,COMP1_OUT,USART3_CTS,LPUART1_CTS,,QUADSPI_BK1_IO3,,TIM1_BKIN_COMP2,,TIM16_CH1,EVENTOUT,ADC12_IN11,,
+PortA,PA7,,TIM1_CH1N,TIM3_CH2,,I2C3_SCL,SPI1_MOSI,DFSDM1_DATIN0,,,,QUADSPI_BK1_IO2,,COMP2_OUT,,,EVENTOUT,ADC12_IN12,,
+PortA,PA8,MCO,TIM1_CH1,,,,,DFSDM1_CKIN1,USART1_CK,,,,,,SAI1_SCK_A,LPTIM2_OUT,EVENTOUT,,,
+PortA,PA9,,TIM1_CH2,,,I2C1_SCL,,DFSDM1_DATIN1,USART1_TX,,,,,,SAI1_FS_A,TIM15_BKIN,EVENTOUT,,,
+PortA,PA10,,TIM1_CH3,,,I2C1_SDA,,,USART1_RX,,,USBCRS_SYNC,,,SAI1_SD_A,,EVENTOUT,,,
+PortA,PA11,,TIM1_CH4,TIM1_BKIN2,,,SPI1_MISO,COMP1_OUT,USART1_CTS,,CAN1_RX,USBDM,,TIM1_BKIN2_COMP1,,,EVENTOUT,,,
+PortA,PA12,,TIM1_ETR,,,,SPI1_MOSI,,USART1_RTS/USART1_DE,,CAN1_TX,USBDP,,,,,EVENTOUT,,,
+PortA,PA13,JTMS/SWDIO,IR_OUT,,,,,,,,,USBNOE,,,SAI1_SD_B,,EVENTOUT,,,
+PortA,PA14,JTCK/SWCLK,LPTIM1_OUT,,,I2C1_SMBA,I2C4_SMBA,,,,,,,,SAI1_FS_B,,EVENTOUT,,,
+PortA,PA15,JTDI,TIM2_CH1,TIM2_ETR,USART2_RX,,SPI1_NSS,SPI3_NSS,USART3_RTS/USART3_DE,UART4_RTS/UART4_DE,TSC_G3_IO1,,,,,,EVENTOUT,,,
+PortB,PB0,,TIM1_CH2N,TIM3_CH3,,,SPI1_NSS,DFSDM1_CKIN0,USART3_CK,,,QUADSPI_BK1_IO1,,COMP1_OUT,SAI1_EXTCLK,,EVENTOUT,ADC12_IN15,,
+PortB,PB1,,TIM1_CH3N,TIM3_CH4,,,,DFSDM_DATIN0,USART3_RTS/USART3_DE,LPUART1_RTS/LPUART1_DE,,QUADSPI_BK1_IO0,,,,LPTIM2_IN1,EVENTOUT,ADC12_IN16,COMP1_INN,
+PortB,PB2,RTC_OUT,LPTIM1_OUT,,,I2C3_SMBA,,DFSDM_CKIN0,,,,,,,,,EVENTOUT,,COMP1_INP,
+PortB,PB3,JTDO/TRACESWO,TIM2_CH2,,,,SPI1_SCK,SPI3_SCK,USART1_RTS/USART1_DE,,,,,,SAI1_SCK_B,,EVENTOUT,,COMP2_INM,
+PortB,PB4,NJTRST,,TIM3_CH1,,I2C3_SDA,SPI1_MISO,SPI3_MISO,USART1_CTS,,TSC_G2_IO1,,,,SAI1_MCLK_B,,EVENTOUT,,COMP2_INP,
+PortB,PB5,,LPTIM1_IN1,TIM3_CH2,CAN1_RX,I2C1_SMBA,SPI1_MOSI,SPI3_MOSI,USART1_CK,,TSC_G2_IO2,,,COMP2_OUT,SAI1_SD_B,TIM16_BKIN,EVENTOUT,,,
+PortB,PB6,,LPTIM1_ETR,,,I2C1_SCL,I2C4_SCL,,USART1_TX,CAN1_TX,TSC_G2_IO3,,,,SAI1_FS_B,TIM16_CH1N,EVENTOUT,,COMP2_INP,
+PortB,PB7,,LPTIM1_IN2,,,I2C1_SDA,I2C4_SDA,,USART1_RX,UART4_CTS,TSC_G2_IO4,,,,,,EVENTOUT,,COMP2_INM,
+PortB,PB8,,,,,I2C1_SCL,,,,,CAN1_RX,,,SDMMC1_D4,SAI1_MCLK_A,TIM16_CH1,EVENTOUT,,,
+PortB,PB9,,IR_OUT,,,I2C1_SDA,SPI2_NSS,,,,CAN1_TX,,,SDMMC1_D5,SAI1_FS_A,,EVENTOUT,,,
+PortB,PB10,,TIM2_CH3,,I2C4_SCL,I2C2_SCL,SPI2_SCK,,USART3_TX,LPUART1_RX,TSC_SYNC,QUADSPI_CLK,,COMP1_OUT,SAI1_SCK_A,,EVENTOUT,,,
+PortB,PB11,,TIM2_CH4,,I2C4_SDA,I2C2_SDA,,,USART3_RX,LPUART1_TX,,QUADSPI_NCS,,COMP2_OUT,,,EVENTOUT,,,
+PortB,PB12,,TIM1_BKIN,,TIM1_BKIN_COMP2,I2C2_SMBA,SPI2_NSS,DFSDM_DATIN1,USART3_CK,LPUART1_RTS/LPUART1_DE,TSC_G1_IO1,CAN1_RX,,,SAI1_FS_A,TIM15_BKIN,EVENTOUT,,,
+PortB,PB13,,TIM1_CH1N,,,I2C2_SCL,SPI2_SCK,DFSDM_CKIN1,USART3_CTS,LPUART1_CTS,TSC_G1_IO2,CAN1_TX,,,SAI1_SCK_A,TIM15_CH1N,EVENTOUT,,,
+PortB,PB14,,TIM1_CH2N,,,I2C2_SDA,SPI2_MISO,DFSDM_DATIN2,USART3_RTS_DE,,TSC_G1_IO3,,,,SAI1_MCLK_A,TIM15_CH1,EVENTOUT,,,
+PortB,PB15,RTC_REFIN,TIM1_CH3N,,,,SPI2_MOSI,DFSDM_CKIN2,,,TSC_G1_IO4,,,,SAI1_SD_A,TIM15_CH2,EVENTOUT,,,
+PortC,PC0,,LPTIM1_IN1,I2C4_SCL,,I2C3_SCL,,,,LPUART1_RX,,,,,,LPTIM2_IN1,EVENTOUT,ADC123_IN1,,
+PortC,PC1,TRACED0,LPTIM1_OUT,I2C4_SDA,,I2C3_SDA,,,,LPUART1_TX,,,,,,,EVENTOUT,ADC123_IN2,,
+PortC,PC2,,LPTIM1_IN2,,,,SPI2_MISO,DFSDM_CKOUT,,,,,,,,,EVENTOUT,ADC123_IN3,,
+PortC,PC3,,LPTIM1_ETR,,,,SPI2_MOSI,,,,,,,,SAI1_SD_A,LPTIM2_ETR,EVENTOUT,ADC123_IN4,,
+PortC,PC4,,,,,,,,USART3_TX,,,,,,,,EVENTOUT,ADC12_IN13,COMP1_INM,
+PortC,PC5,,,,,,,,USART3_RX,,,,,,,,EVENTOUT,ADC12_IN14,COMP1_INP,
+PortC,PC6,,,TIM3_CH1,,,,DFSDM_CKIN3,,,TSC_G4_IO1,,,SDMMC1_D6,,,EVENTOUT,,,
+PortC,PC7,,,TIM3_CH2,,,,DFSDM_DATIN3,,,TSC_G4_IO2,,,SDMMC1_D7,,,EVENTOUT,,,
+PortC,PC8,,,TIM3_CH3,,,,,,,TSC_G4_IO3,,,SDMMC1_D0,,,EVENTOUT,,,
+PortC,PC9,,,TIM3_CH4,,,,,,,TSC_G4_IO4,USBNOE,,SDMMC1_D1,,,EVENTOUT,,,
+PortC,PC10,TRACED1,,,,,,SPI3_SCK,USART3_TX,UART4_TX,TSC_G3_IO2,,,SDMMC1_D2,,,EVENTOUT,,,
+PortC,PC11,,,,,,,SPI3_MISO,USART3_RX,UART4_RX,TSC_G3_IO3,,,SDMMC1_D3,,,EVENTOUT,,,
+PortC,PC12,TRACED3,,,,,,SPI3_MOSI,USART3_CK,,TSC_G3_IO4,,,SDMMC1_CK,,,EVENTOUT,,,
+PortC,PC13,,,,,,,,,,,,,,,,EVENTOUT,,,
+PortC,PC14,,,,,,,,,,,,,,,,EVENTOUT,,,
+PortC,PC15,,,,,,,,,,,,,,,,EVENTOUT,,,
+PortD,PD0,,,,,,SPI2_NSS,,,,CAN1_RX,,,,,,EVENTOUT,,,
+PortD,PD1,,,,,,SPI2_SCK,,,,CAN1_TX,,,,,,EVENTOUT,,,
+PortD,PD2,TRACED2,,TIM3_ETR,,,,,USART3_RTS/USART3_DE,,TSC_SYNC,,,SDMMC1_CMD,,,EVENTOUT,,,
+PortD,PD3,,,,,,SPI2_MISO,DFSDM_DATIN0,USART2_CTS,,,QUADSPI_BK2_NCS,,,,,EVENTOUT,,,
+PortD,PD4,,,,,,SPI2_MOSI,DFSDM_CKIN0,USART2_RTS/USART2_DE,,,QUADSPI_BK2_IO0,,,,,EVENTOUT,,,
+PortD,PD5,,,,,,,,USART2_TX,,,QUADSPI_BK2_IO1,,,,,EVENTOUT,,,
+PortD,PD6,,,,,,,DFSDM_DATIN1,USART2_RX,,,QUADSPI_BK2_IO2,,,SAI1_SD_A,,EVENTOUT,,,
+PortD,PD7,,,,,,,DFSDM_CKIN1,USART2_CK,,,QUADSPI_BK2_IO3,,,,,EVENTOUT,,,
+PortD,PD8,,,,,,,,USART3_TX,,,,,,,,EVENTOUT,,,
+PortD,PD9,,,,,,,,USART3_RX,,,,,,,,EVENTOUT,,,
+PortD,PD10,,,,,,,,USART3_CK,,TSC_G6_IO1,,,,,,EVENTOUT,,,
+PortD,PD11,,,,,I2C4_SMBA,,,USART3_CTS,,TSC_G6_IO2,,,,,LPTIM2_ETR,EVENTOUT,,,
+PortD,PD12,,,,,I2C4_SCL,,,USART3_RTS/USART3_DE,,TSC_G6_IO3,,,,,LPTIM2_IN1,EVENTOUT,,,
+PortD,PD13,,,,,I2C4_SDA,,,,,TSC_G6_IO4,,,,,LPTIM2_OUT,EVENTOUT,,,
+PortD,PD14,,,,,,,,,,,,,,,,EVENTOUT,,,
+PortD,PD15,,,,,,,,,,,,,,,,EVENTOUT,,,
+PortE,PE0,,,,,,,,,,,,,,,TIM16_CH1,EVENTOUT,,,
+PortE,PE1,,,,,,,,,,,,,,,,EVENTOUT,,,
+PortE,PE2,TRACECLK,,TIM3_ETR,,,,,,,TSC_G7_IO1,,,,SAI1_MCLK_A,,EVENTOUT,,,
+PortE,PE3,TRACED0,,TIM3_CH1,,,,,,,TSC_G7_IO2,,,,SAI1_SD_B,,EVENTOUT,,,
+PortE,PE4,TRACED1,,TIM3_CH2,,,,DFSDM_DATIN3,,,TSC_G7_IO3,,,,SAI1_FS_A,,EVENTOUT,,,
+PortE,PE5,TRACED2,,TIM3_CH3,,,,DFSDM_CKIN3,,,TSC_G7_IO4,,,,SAI1_SCK_A,,EVENTOUT,,,
+PortE,PE6,TRACED3,,TIM3_CH4,,,,,,,,,,,SAI1_SD_A,,EVENTOUT,,,
+PortE,PE7,,TIM1_ETR,,,,,DFSDM_DATIN2,,,,,,,SAI1_SD_B,,EVENTOUT,,,
+PortE,PE8,,TIM1_CH1N,,,,,DFSDM_CKIN2,,,,,,,SAI1_SCK_B,,EVENTOUT,,,
+PortE,PE9,,TIM1_CH1,,,,,DFSDM_CKOUT,,,,,,,SAI1_FS_B,,EVENTOUT,,,
+PortE,PE10,,TIM1_CH2N,,,,,,,,TSC_G5_IO1,QUADSPI_CLK,,,SAI1_MCLK_B,,EVENTOUT,,,
+PortE,PE11,,TIM1_CH2,,,,,,,,TSC_G5_IO2,QUADSPI_BK1_NCS,,,,,EVENTOUT,,,
+PortE,PE12,,TIM1_CH3N,,,,SPI1_NSS,,,,TSC_G5_IO3,QUADSPI_BK1_IO0,,,,,EVENTOUT,,,
+PortE,PE13,,TIM1_CH3,,,,SPI1_SCK,,,,TSC_G5_IO4,QUADSPI_BK1_IO1,,,,,EVENTOUT,,,
+PortE,PE14,,TIM1_CH4,TIM1_BKIN2,TIM1_BKIN2_COMP2,,SPI1_MISO,,,,,QUADSPI_BK1_IO2,,,,,EVENTOUT,,,
+PortE,PE15,,TIM1_BKIN,,TIM1_BKIN_COMP1,,SPI1_MOSI,,,,,QUADSPI_BK1_IO3,,,,,EVENTOUT,,,
+PortH,PH0,,,,,,,,,,,,,,,,EVENTOUT,,,
+PortH,PH1,,,,,,,,,,,,,,,,EVENTOUT,,,
+PortH,PH3,,,,,,,,,,,,,,,,,,,
diff --git a/ports/stm32/boards/stm32l452xe.ld b/ports/stm32/boards/stm32l452xe.ld
new file mode 100644
index 0000000000000..7b07ee7018dd8
--- /dev/null
+++ b/ports/stm32/boards/stm32l452xe.ld
@@ -0,0 +1,34 @@
+/*
+    GNU linker script for STM32L452XE
+*/
+
+/* Specify the memory areas */
+MEMORY
+{
+    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 384K /* sectors 0-191 */
+    FLASH_FS (r)    : ORIGIN = 0x08060000, LENGTH = 128K /* sectors 192-255 */
+    RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 160K /* SRAM1, 128K + SRAM2, 32K */
+}
+
+/* produce a link error if there is not this amount of RAM for these sections */
+_minimum_stack_size = 2K;
+_minimum_heap_size = 16K;
+
+/* Define the stack.  The stack is full descending so begins just above last byte of RAM,
+   or bottom of FS cache..  Note that EABI requires the stack to be 8-byte aligned for a call. */
+
+/* RAM extents for the garbage collector */
+_ram_start = ORIGIN(RAM);
+_ram_end = ORIGIN(RAM) + LENGTH(RAM);
+
+_ram_fs_cache_end = _ram_end;
+_ram_fs_cache_start = _ram_fs_cache_end - 2K; /* fs cache = 2K */
+
+_estack = _ram_fs_cache_start - _estack_reserve;
+_sstack = _estack - 16K; /* stack = 16K */
+
+_heap_start = _ebss; /* heap starts just after statically allocated memory */
+_heap_end = _sstack; /* bss + heap = 142K, tunable by adjusting stack size */
+
+_flash_fs_start = ORIGIN(FLASH_FS);
+_flash_fs_end   = ORIGIN(FLASH_FS) + LENGTH(FLASH_FS);
diff --git a/ports/stm32/boards/stm32l476xe.ld b/ports/stm32/boards/stm32l476xe.ld
index 31929517d77f6..6eaf71545d0a1 100644
--- a/ports/stm32/boards/stm32l476xe.ld
+++ b/ports/stm32/boards/stm32l476xe.ld
@@ -5,31 +5,31 @@
 /* Specify the memory areas */
 MEMORY
 {
-    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 512K
-    FLASH_ISR (rx)  : ORIGIN = 0x08000000, LENGTH = 16K /* sectors 0-7 */
-    FLASH_TEXT (rx) : ORIGIN = 0x08004000, LENGTH = 368K /* sectors 8-191 */
+    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 384K /* sectors 0-191 */
     FLASH_FS (r)    : ORIGIN = 0x08060000, LENGTH = 128K /* sectors 192-255 */
     RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 96K
-    SRAM2 (xrw)     : ORIGIN = 0x10000000, LENGTH = 32K
-    FS_CACHE(xrw)   : ORIGIN = 0x10007800, LENGTH = 2K
+    SRAM2 (xrw)     : ORIGIN = 0x10000000, LENGTH = 32K /* not contiguous with RAM */
 }
 
 /* produce a link error if there is not this amount of RAM for these sections */
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* Define the top end of the stack.  The stack is full descending so begins just
-   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
-   aligned for a call. */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte of RAM,
+   or bottom of FS cache..  Note that EABI requires the stack to be 8-byte aligned for a call. */
 
 /* RAM extents for the garbage collector */
-_ram_fs_cache_start = ORIGIN(FS_CACHE);
-_ram_fs_cache_end = ORIGIN(FS_CACHE) + LENGTH(FS_CACHE);
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
+
+_ram_fs_cache_end = ORIGIN(SRAM2) + LENGTH(SRAM2); /* fs_cache in SRAM2 */
+_ram_fs_cache_start = _ram_fs_cache_end - 2K; /* fs cache = 2K */
+
+_estack = _ram_fs_cache_start - _estack_reserve; /* stack in SRAM2 */
+_sstack = ORIGIN(SRAM2); /* stack = 30K */
+
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x20014000; /* tunable */
+_heap_end = _ram_end; /* bss + heap = 96K, tunable by adjusting stack size */
 
 _flash_fs_start = ORIGIN(FLASH_FS);
 _flash_fs_end   = ORIGIN(FLASH_FS) + LENGTH(FLASH_FS);
diff --git a/ports/stm32/boards/stm32l476xg.ld b/ports/stm32/boards/stm32l476xg.ld
index 59c5d90b69aca..09c3f29c54999 100644
--- a/ports/stm32/boards/stm32l476xg.ld
+++ b/ports/stm32/boards/stm32l476xg.ld
@@ -5,31 +5,31 @@
 /* Specify the memory areas */
 MEMORY
 {
-    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 1024K
-    FLASH_ISR (rx)  : ORIGIN = 0x08000000, LENGTH = 16K /* sectors 0-7 */
-    FLASH_TEXT (rx) : ORIGIN = 0x08004000, LENGTH = 496K /* sectors 8-255 */
+    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 512K /* sectors 0-255 */
     FLASH_FS (r)    : ORIGIN = 0x08080000, LENGTH = 512K /* sectors 256-511 */
     RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 96K
-    SRAM2 (xrw)     : ORIGIN = 0x10000000, LENGTH = 32K
-    FS_CACHE(xrw)   : ORIGIN = 0x10007800, LENGTH = 2K
+    SRAM2 (xrw)     : ORIGIN = 0x10000000, LENGTH = 32K /* not contiguous with RAM */
 }
 
 /* produce a link error if there is not this amount of RAM for these sections */
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* Define the top end of the stack.  The stack is full descending so begins just
-   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
-   aligned for a call. */
-_estack = ORIGIN(RAM) + LENGTH(RAM);
+/* Define the stack.  The stack is full descending so begins just above last byte of RAM,
+   or bottom of FS cache..  Note that EABI requires the stack to be 8-byte aligned for a call. */
 
 /* RAM extents for the garbage collector */
-_ram_fs_cache_start = ORIGIN(FS_CACHE);
-_ram_fs_cache_end = ORIGIN(FS_CACHE) + LENGTH(FS_CACHE);
 _ram_start = ORIGIN(RAM);
 _ram_end = ORIGIN(RAM) + LENGTH(RAM);
+
+_ram_fs_cache_end = ORIGIN(SRAM2) + LENGTH(SRAM2); /* fs_cache in SRAM2 */
+_ram_fs_cache_start = _ram_fs_cache_end - 2K; /* fs cache = 2K */
+
+_estack = _ram_fs_cache_start - _estack_reserve; /* stack in SRAM2 */
+_sstack = ORIGIN(SRAM2); /* stack = 30K */
+
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x20014000; /* tunable */
+_heap_end = _ram_end; /* bss + heap = 96K, tunable by adjusting stack size */
 
 _flash_fs_start = ORIGIN(FLASH_FS);
 _flash_fs_end   = ORIGIN(FLASH_FS) + LENGTH(FLASH_FS);
diff --git a/ports/stm32/boards/stm32l496xg.ld b/ports/stm32/boards/stm32l496xg.ld
index b42087319964e..327cb5ce13407 100644
--- a/ports/stm32/boards/stm32l496xg.ld
+++ b/ports/stm32/boards/stm32l496xg.ld
@@ -5,31 +5,30 @@
 /* Specify the memory areas */
 MEMORY
 {
-    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 1024K
-    FLASH_ISR (rx)  : ORIGIN = 0x08000000, LENGTH = 16K       /* sectors 0-7 */
-    FLASH_TEXT (rx) : ORIGIN = 0x08004000, LENGTH = 596K      /* sectors 8-305 */
-    FLASH_FS (r)    : ORIGIN = 0x08099000, LENGTH = 412K      /* sectors 306-511 412 KiB */
-    RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 256K
-    SRAM2 (xrw)     : ORIGIN = 0x20040000, LENGTH = 62K       /* leave 2K for flash fs cache */
-    FS_CACHE(xrw)   : ORIGIN = 0x2004f800, LENGTH = 2K
+    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 612K /* sectors 0-305 */
+    FLASH_FS (r)    : ORIGIN = 0x08099000, LENGTH = 412K /* sectors 306-511 412 KiB */
+    RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 320K /* SRAM1, 256K + SRAM2, 64K */
 }
 
 /* produce a link error if there is not this amount of RAM for these sections */
 _minimum_stack_size = 2K;
 _minimum_heap_size = 16K;
 
-/* Define the top end of the stack.  The stack is full descending so begins just
-   above last byte of RAM.  Note that EABI requires the stack to be 8-byte
-   aligned for a call. */
-_estack = ORIGIN(RAM) + LENGTH(RAM) + LENGTH(SRAM2);
+/* Define the stack.  The stack is full descending so begins just above last byte of RAM,
+   or bottom of FS cache..  Note that EABI requires the stack to be 8-byte aligned for a call. */
 
 /* RAM extents for the garbage collector */
-_ram_fs_cache_start = ORIGIN(FS_CACHE);
-_ram_fs_cache_end = ORIGIN(FS_CACHE) + LENGTH(FS_CACHE);
 _ram_start = ORIGIN(RAM);
-_ram_end = ORIGIN(RAM) + LENGTH(RAM) + LENGTH(SRAM2);
+_ram_end = ORIGIN(RAM) + LENGTH(RAM);
+
+_ram_fs_cache_end = _ram_end;
+_ram_fs_cache_start = _ram_fs_cache_end - 2K; /* fs cache = 2K */
+
+_estack = _ram_fs_cache_start - _estack_reserve;
+_sstack = _estack - 16K; /* stack = 16K */
+
 _heap_start = _ebss; /* heap starts just after statically allocated memory */
-_heap_end = 0x2001C000; /* tunable */
+_heap_end = _sstack; /* bss + heap = 302K, tunable by adjusting stack size */
 
 _flash_fs_start = ORIGIN(FLASH_FS);
 _flash_fs_end   = ORIGIN(FLASH_FS) + LENGTH(FLASH_FS);
diff --git a/ports/stm32/boards/stm32l4xx_hal_conf_base.h b/ports/stm32/boards/stm32l4xx_hal_conf_base.h
new file mode 100644
index 0000000000000..7e249138f566e
--- /dev/null
+++ b/ports/stm32/boards/stm32l4xx_hal_conf_base.h
@@ -0,0 +1,99 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_STM32L4XX_HAL_CONF_BASE_H
+#define MICROPY_INCLUDED_STM32L4XX_HAL_CONF_BASE_H
+
+// Include various HAL modules for convenience
+#include "stm32l4xx_hal_dma.h"
+#include "stm32l4xx_hal_adc.h"
+#include "stm32l4xx_hal_can.h"
+#include "stm32l4xx_hal_cortex.h"
+#include "stm32l4xx_hal_crc.h"
+#include "stm32l4xx_hal_dac.h"
+#include "stm32l4xx_hal_dcmi.h"
+#include "stm32l4xx_hal_flash.h"
+#include "stm32l4xx_hal_gpio.h"
+#include "stm32l4xx_hal_hash.h"
+#include "stm32l4xx_hal_hcd.h"
+#include "stm32l4xx_hal_i2c.h"
+#include "stm32l4xx_hal_iwdg.h"
+#include "stm32l4xx_hal_pcd.h"
+#include "stm32l4xx_hal_pwr.h"
+#include "stm32l4xx_hal_rcc.h"
+#include "stm32l4xx_hal_rtc.h"
+#include "stm32l4xx_hal_sd.h"
+#include "stm32l4xx_hal_spi.h"
+#include "stm32l4xx_hal_tim.h"
+#include "stm32l4xx_hal_uart.h"
+#include "stm32l4xx_hal_usart.h"
+#include "stm32l4xx_hal_wwdg.h"
+
+// Enable various HAL modules
+#define HAL_MODULE_ENABLED
+#define HAL_ADC_MODULE_ENABLED
+#define HAL_CAN_MODULE_ENABLED
+#define HAL_CORTEX_MODULE_ENABLED
+#define HAL_CRC_MODULE_ENABLED
+#define HAL_DAC_MODULE_ENABLED
+#define HAL_DCMI_MODULE_ENABLED
+#define HAL_DMA_MODULE_ENABLED
+#define HAL_FLASH_MODULE_ENABLED
+#define HAL_GPIO_MODULE_ENABLED
+#define HAL_HASH_MODULE_ENABLED
+#define HAL_HCD_MODULE_ENABLED
+#define HAL_I2C_MODULE_ENABLED
+#define HAL_IWDG_MODULE_ENABLED
+#define HAL_PCD_MODULE_ENABLED
+#define HAL_PWR_MODULE_ENABLED
+#define HAL_RCC_MODULE_ENABLED
+#define HAL_RTC_MODULE_ENABLED
+#define HAL_SD_MODULE_ENABLED
+#define HAL_SPI_MODULE_ENABLED
+#define HAL_TIM_MODULE_ENABLED
+#define HAL_UART_MODULE_ENABLED
+#define HAL_USART_MODULE_ENABLED
+#define HAL_WWDG_MODULE_ENABLED
+
+// Oscillator values in Hz
+#define HSI_VALUE   (16000000)
+#define HSI48_VALUE (48000000)
+#define LSI_VALUE   (32000)
+#define MSI_VALUE   (4000000)
+
+// SysTick has the highest priority
+#define TICK_INT_PRIORITY (0x00)
+
+// Miscellaneous HAL settings
+#define DATA_CACHE_ENABLE           1
+#define INSTRUCTION_CACHE_ENABLE    1
+#define PREFETCH_ENABLE             1
+#define USE_SPI_CRC                 0
+#define USE_RTOS                    0
+
+// HAL parameter assertions are disabled
+#define assert_param(expr) ((void)0)
+
+#endif // MICROPY_INCLUDED_STM32L4XX_HAL_CONF_BASE_H
diff --git a/ports/stm32/boards/stm32wb55_af.csv b/ports/stm32/boards/stm32wb55_af.csv
new file mode 100644
index 0000000000000..074c33089261d
--- /dev/null
+++ b/ports/stm32/boards/stm32wb55_af.csv
@@ -0,0 +1,74 @@
+Port,,AF0,AF1,AF2,AF3,AF4,AF5,AF6,AF7,AF8,AF9,AF10,AF11,AF12,AF13,AF14,AF15,
+,,SYS_AF,TIM1/TIM2/LPTIM1,TIM1/TIM2,SPI2/SAI1/TIM1,I2C1/I2C3,SPI1/SPI2,RF,USART1,LPUART1,TSC,USB/QUADSPI,LCD,COMP1/COMP2/TIM1,SAI1,TIM2/TIM16/TIM17/LPTIM2,EVENTOUT,ADC
+PortA,PA0,,TIM2_CH1,,,,,,,,,,,COMP1_OUT,SAI1_EXTCLK,TIM2_ETR,EVENTOUT,ADC1_IN5
+PortA,PA1,,TIM2_CH2,,,I2C1_SMBA,SPI1_SCK,,,,,,LCD_SEG0,,,,EVENTOUT,ADC1_IN6
+PortA,PA2,LSCO,TIM2_CH3,,,,,,,LPUART1_TX,,QUADSPI_BK1_NCS,LCD_SEG1,COMP2_OUT,,,EVENTOUT,ADC1_IN7
+PortA,PA3,,TIM2_CH4,,SAI1_PDM_CK1,,,,,LPUART1_RX,,QUADSPI_CLK,LCD_SEG2,,SAI1_MCLK_A,,EVENTOUT,ADC1_IN8
+PortA,PA4,,,,,,SPI1_NSS,,,,,,LCD_SEG5,,SAI1_FS_B,LPTIM2_OUT,EVENTOUT,ADC1_IN9
+PortA,PA5,,TIM2_CH1,TIM2_ETR,,,SPI1_SCK,,,,,,,,SAI1_SD_B,LPTIM2_ETR,EVENTOUT,ADC1_IN10
+PortA,PA6,,TIM1_BKIN,,,,SPI1_MISO,,,LPUART1_CTS,,QUADSPI_BK1_IO3,LCD_SEG3,TIM1_BKIN,,TIM16_CH1,EVENTOUT,ADC1_IN11
+PortA,PA7,,TIM1_CH1N,,,I2C3_SCL,SPI1_MOSI,,,,,QUADSPI_BK1_IO2,LCD_SEG4,COMP2_OUT,,TIM17_CH1,EVENTOUT,ADC1_IN12
+PortA,PA8,MCO,TIM1_CH1,,SAI1_PDM_CK2,,,,USART1_CK,,,,LCD_COM0,,SAI1_SCK_A,LPTIM2_OUT,EVENTOUT,ADC1_IN15
+PortA,PA9,,TIM1_CH2,,SAI1_PDM_DI2,I2C1_SCL,SPI2_SCK,,USART1_TX,,,,LCD_COM1,,SAI1_FS_A,,EVENTOUT,ADC1_IN16
+PortA,PA10,,TIM1_CH3,,SAI1_PDM_DI1,I2C1_SDA,,,USART1_RX,,,USB_CRS_SYNC,LCD_COM2,,SAI1_SD_A,TIM17_BKIN,EVENTOUT,
+PortA,PA11,,TIM1_CH4,TIM1_BKIN2,,,SPI1_MISO,,USART1_CTS,,,USB_DM,,TIM1_BKIN2,,,EVENTOUT,
+PortA,PA12,,TIM1_ETR,,,,SPI1_MOSI,,USART1_RTS_DE,LPUART1_RX,,USB_DP,,,,,EVENTOUT,
+PortA,PA13,JTMS/SWDIO,,,,,,,,IR_OUT,,USB_NOE,,,SAI1_SD_B,,EVENTOUT,
+PortA,PA14,JTCK/SWCLK,LPTIM1_OUT,,,I2C1_SMBA,,,,,,,LCD_SEG5,,SAI1_FS_B,,EVENTOUT,
+PortA,PA15,JTDI,TIM2_CH1,TIM2_ETR,,,SPI1_NSS,,,,TSC_G3_IO1,,LCD_SEG17,,,,EVENTOUT,
+PortB,PB0,,,,,,,EXT_PA_TX,,,,,,COMP1_OUT,,,EVENTOUT,
+PortB,PB1,,,,,,,,,LPUART1_RTS_DE,,,,,,LPTIM2_IN1,EVENTOUT,
+PortB,PB2,RTC_OUT,LPTIM1_OUT,,,I2C3_SMBA,SPI1_NSS,,,,,,LCD_VLCD,,SAI1_EXTCLK,,EVENTOUT,
+PortB,PB3,JTDO/TRACESWO,TIM2_CH2,,,,SPI1_SCK,,USART1_RTS_DE,,,,LCD_SEG7,,SAI1_SCK_B,,EVENTOUT,
+PortB,PB4,NJTRST,,,,I2C3_SDA,SPI1_MISO,,USART1_CTS,,TSC_G2_IO1,,LCD_SEG8,,SAI1_MCLK_B,TIM17_BKIN,EVENTOUT,
+PortB,PB5,,LPTIM1_IN1,,,I2C1_SMBA,SPI1_MOSI,,USART1_CK,LPUART1_TX,TSC_G2_IO2,,LCD_SEG9,COMP2_OUT,SAI1_SD_B,TIM16_BKIN,EVENTOUT,
+PortB,PB6,MCO,LPTIM1_ETR,,,I2C1_SCL,,,USART1_TX,,TSC_G2_IO3,,LCD_SEG6,,SAI1_FS_B,TIM16_CH1N,EVENTOUT,
+PortB,PB7,,LPTIM1_IN2,,TIM1_BKIN,I2C1_SDA,,,USART1_RX,,TSC_G2_IO4,,LCD_SEG21,,,TIM17_CH1N,EVENTOUT,
+PortB,PB8,,TIM1_CH2N,,SAI1_PDM_CK1,I2C1_SCL,,,,,,QUADSPI_BK1_IO1,LCD_SEG16,,SAI1_MCLK_A,TIM16_CH1,EVENTOUT,
+PortB,PB9,,TIM1_CH3N,,SAI1_PDM_DI2,I2C1_SDA,SPI2_NSS,,,IR_OUT,TSC_G7_IO4,QUADSPI_BK1_IO0,LCD_COM3,,SAI1_FS_A,TIM17_CH1,EVENTOUT,
+PortB,PB10,,TIM2_CH3,,,I2C3_SCL,SPI2_SCK,,,LPUART1_RX,TSC_SYNC,QUADSPI_CLK,LCD_SEG10,COMP1_OUT,SAI1_SCK_A,,EVENTOUT,
+PortB,PB11,,TIM2_CH4,,,I2C3_SDA,,,,LPUART1_TX,,QUADSPI_BK1_NCS,LCD_SEG11,COMP2_OUT,,,EVENTOUT,
+PortB,PB12,,TIM1_BKIN,,TIM1_BKIN,I2C3_SMBA,SPI2_NSS,,,LPUART1_RTS,TSC_G1_IO1,,LCD_SEG12,,SAI1_FS_A,,EVENTOUT,
+PortB,PB13,,TIM1_CH1N,,,I2C3_SCL,SPI2_SCK,,,LPUART1_CTS,TSC_G1_IO2,,LCD_SEG13,,SAI1_SCK_A,,EVENTOUT,
+PortB,PB14,,TIM1_CH2N,,,I2C3_SDA,SPI2_MISO,,,,TSC_G1_IO3,,LCD_SEG14,,SAI1_MCLK_A,,EVENTOUT,
+PortB,PB15,RTC_REFIN,TIM1_CH3N,,,,SPI2_MOSI,,,,TSC_G1_IO4,,LCD_SEG15,,SAI1_SD_A,,EVENTOUT,
+PortC,PC0,,LPTIM1_IN1,,,I2C3_SCL,,,,LPUART1_RX,,,LCD_SEG18,,,LPTIM2_IN1,EVENTOUT,ADC1_IN1
+PortC,PC1,,LPTIM1_OUT,,SPI2_MOSI,I2C3_SDA,,,,LPUART1_TX,,,LCD_SEG19,,,,EVENTOUT,ADC1_IN2
+PortC,PC2,,LPTIM1_IN2,,,,SPI2_MISO,,,,,,LCD_SEG20,,,,EVENTOUT,ADC1_IN3
+PortC,PC3,,LPTIM1_ETR,,SAI1_PDM_DI1,,SPI2_MOSI,,,,,,LCD_VLCD,,SAI1_SD_A,LPTIM2_ETR,EVENTOUT,ADC1_IN4
+PortC,PC4,,,,,,,,,,,,LCD_SEG22,,,,EVENTOUT,ADC1_IN13
+PortC,PC5,,,,SAI1_PDM_DI3,,,,,,,,LCD_SEG23,,,,EVENTOUT,ADC1_IN14
+PortC,PC6,,,,,,,,,,TSC_G4_IO1,,LCD_SEG24,,,,EVENTOUT,
+PortC,PC7,,,,,,,,,,TSC_G4_IO2,,LCD_SEG25,,,,EVENTOUT,
+PortC,PC8,,,,,,,,,,TSC_G4_IO3,,LCD_SEG26,,,,EVENTOUT,
+PortC,PC9,,,,TIM1_BKIN,,,,,,TSC_G4_IO4,USB_NOE,LCD_SEG27,,SAI1_SCK_B,,EVENTOUT,
+PortC,PC10,TRACED1,,,,,,,,,TSC_G3_IO2,,LCD_COM4LCD_SEG28LCD_SEG40,,,,EVENTOUT,
+PortC,PC11,,,,,,,,,,TSC_G3_IO3,,LCD_COM5LCD_SEG29LCD_SEG41,,,,EVENTOUT,
+PortC,PC12,TRACED3,,,,,,,,,TSC_G3_IO4,,LCD_COM6LCD_SEG30LCD_SEG42,,,,EVENTOUT,
+PortC,PC13,,,,,,,,,,,,,,,,EVENTOUT,
+PortC,PC14,,,,,,,,,,,,,,,,EVENTOUT,
+PortC,PC15,,,,,,,,,,,,,,,,EVENTOUT,
+PortD,PD0,,,,,,SPI2_NSS,,,,,,,,,,EVENTOUT,
+PortD,PD1,,,,,,SPI2_SCK,,,,,,,,,,EVENTOUT,
+PortD,PD2,TRACED2,,,,,,,,,TSC_SYNC,,LCD_COM7LCD_SEG31LCD_SEG43,,,,EVENTOUT,
+PortD,PD3,,,,SPI2_SCK,,SPI2_MISO,,,,,QUADSPI_BK1_NCS,,,,,EVENTOUT,
+PortD,PD4,,,,,,SPI2_MOSI,,,,TSC_G5_IO1,QUADSPI_BK1_IO0,,,,,EVENTOUT,
+PortD,PD5,,,,,,,,,,TSC_G5_IO2,QUADSPI_BK1_IO1,,,SAI1_MCLK_B,,EVENTOUT,
+PortD,PD6,,,,SAI1_PDM_DI1,,,,,,TSC_G5_IO3,QUADSPI_BK1_IO2,,,SAI1_SD_A,,EVENTOUT,
+PortD,PD7,,,,,,,,,,TSC_G5_IO4,QUADSPI_BK1_IO3,LCD_SEG39,,,,EVENTOUT,
+PortD,PD8,,,TIM1_BKIN2,,,,,,,,,LCD_SEG28,,,,EVENTOUT,
+PortD,PD9,TRACED0,,,,,,,,,,,LCD_SEG29,,,,EVENTOUT,
+PortD,PD10,TRIG_INOUT,,,,,,,,,TSC_G6_IO1,,LCD_SEG30,,,,EVENTOUT,
+PortD,PD11,,,,,,,,,,TSC_G6_IO2,,LCD_SEG31,,,LPTIM2_ETR,EVENTOUT,
+PortD,PD12,,,,,,,,,,TSC_G6_IO3,,LCD_SEG32,,,LPTIM2_IN1,EVENTOUT,
+PortD,PD13,,,,,,,,,,TSC_G6_IO4,,LCD_SEG33,,,LPTIM2_OUT,EVENTOUT,
+PortD,PD14,,TIM1_CH1,,,,,,,,,,LCD_SEG34,,,,EVENTOUT,
+PortD,PD15,,TIM1_CH2,,,,,,,,,,LCD_SEG35,,,,EVENTOUT,
+PortE,PE0,,TIM1_ETR,,,,,,,,TSC_G7_IO3,,LCD_SEG36,,,TIM16_CH1,EVENTOUT,
+PortE,PE1,,,,,,,,,,TSC_G7_IO2,,LCD_SEG37,,,TIM17_CH1,EVENTOUT,
+PortE,PE2,TRACECK,,,SAI1_PDM_CK1,,,,,,TSC_G7_IO1,,LCD_SEG38,,SAI1_MCLK_A,,EVENTOUT,
+PortE,PE3,,,,,,,,,,,,,,,,EVENTOUT,
+PortE,PE4,,,,,,,,,,,,,,,,EVENTOUT,
+PortH,PH0,,,,,,,,,,,,,,,,EVENTOUT,
+PortH,PH1,,,,,,,,,,,,,,,,EVENTOUT,
+PortH,PH3,LSCO,,,,,,,,,,,,,,,EVENTOUT,
diff --git a/ports/stm32/boards/stm32wb55xg.ld b/ports/stm32/boards/stm32wb55xg.ld
new file mode 100644
index 0000000000000..77596d7759689
--- /dev/null
+++ b/ports/stm32/boards/stm32wb55xg.ld
@@ -0,0 +1,44 @@
+/*
+    GNU linker script for STM32WB55xG
+*/
+
+/* Specify the memory areas */
+MEMORY
+{
+    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 512K /* sectors 0-127 */
+    FLASH_FS (r)    : ORIGIN = 0x08080000, LENGTH = 256K /* sectors 128-191 */
+    RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 192K /* SRAM1 */
+    RAM2A (xrw)     : ORIGIN = 0x20030020, LENGTH = 8K /* SRAM2A */
+}
+
+/* produce a link error if there is not this amount of RAM for these sections */
+_minimum_stack_size = 2K;
+_minimum_heap_size = 16K;
+
+/* RAM extents for the garbage collector */
+_ram_start = ORIGIN(RAM);
+_ram_end = ORIGIN(RAM) + LENGTH(RAM);
+
+_ram_fs_cache_end = ORIGIN(RAM) + LENGTH(RAM);
+_ram_fs_cache_start = _ram_fs_cache_end - 4K; /* fs cache = 4K */
+
+/* Define the stack.  The stack is full descending so begins at the bottom of FS cache.
+   Note that EABI requires the stack to be 8-byte aligned for a call. */
+_estack = _ram_fs_cache_start - _estack_reserve;
+_sstack = _estack - 16K;
+
+_heap_start = _ebss; /* heap starts just after statically allocated memory */
+_heap_end = _sstack;
+
+_flash_fs_start = ORIGIN(FLASH_FS);
+_flash_fs_end   = ORIGIN(FLASH_FS) + LENGTH(FLASH_FS);
+
+SECTIONS
+{
+    .ram2a_bss :
+    {
+        . = ALIGN(4);
+        *rfcore.o(.bss.ipcc_mem_*)
+        . = ALIGN(4);
+    } >RAM2A
+}
diff --git a/ports/stm32/boards/stm32wbxx_hal_conf_base.h b/ports/stm32/boards/stm32wbxx_hal_conf_base.h
new file mode 100644
index 0000000000000..8dbc9ecea7f12
--- /dev/null
+++ b/ports/stm32/boards/stm32wbxx_hal_conf_base.h
@@ -0,0 +1,78 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_STM32WBXX_HAL_CONF_BASE_H
+#define MICROPY_INCLUDED_STM32WBXX_HAL_CONF_BASE_H
+
+// Include various HAL modules for convenience
+#include "stm32wbxx_hal_dma.h"
+#include "stm32wbxx_hal_adc.h"
+#include "stm32wbxx_hal_cortex.h"
+#include "stm32wbxx_hal_flash.h"
+#include "stm32wbxx_hal_gpio.h"
+#include "stm32wbxx_hal_i2c.h"
+#include "stm32wbxx_hal_pcd.h"
+#include "stm32wbxx_hal_pwr.h"
+#include "stm32wbxx_hal_rcc.h"
+#include "stm32wbxx_hal_rtc.h"
+#include "stm32wbxx_hal_spi.h"
+#include "stm32wbxx_hal_tim.h"
+#include "stm32wbxx_hal_uart.h"
+#include "stm32wbxx_hal_usart.h"
+
+// Enable various HAL modules
+#define HAL_MODULE_ENABLED
+#define HAL_ADC_MODULE_ENABLED
+#define HAL_CORTEX_MODULE_ENABLED
+#define HAL_DMA_MODULE_ENABLED
+#define HAL_FLASH_MODULE_ENABLED
+#define HAL_GPIO_MODULE_ENABLED
+#define HAL_I2C_MODULE_ENABLED
+#define HAL_PCD_MODULE_ENABLED
+#define HAL_PWR_MODULE_ENABLED
+#define HAL_RCC_MODULE_ENABLED
+#define HAL_RTC_MODULE_ENABLED
+#define HAL_SPI_MODULE_ENABLED
+#define HAL_TIM_MODULE_ENABLED
+#define HAL_UART_MODULE_ENABLED
+#define HAL_USART_MODULE_ENABLED
+
+// Oscillator values in Hz
+#define MSI_VALUE   (4000000)
+
+// SysTick has the highest priority
+#define TICK_INT_PRIORITY (0x00)
+
+// Miscellaneous HAL settings
+#define DATA_CACHE_ENABLE           1
+#define INSTRUCTION_CACHE_ENABLE    1
+#define PREFETCH_ENABLE             0
+#define USE_SPI_CRC                 0
+#define USE_RTOS                    0
+
+// HAL parameter assertions are disabled
+#define assert_param(expr) ((void)0)
+
+#endif // MICROPY_INCLUDED_STM32WBXX_HAL_CONF_BASE_H
diff --git a/ports/stm32/btstack.c b/ports/stm32/btstack.c
new file mode 100644
index 0000000000000..cbb15a86cb972
--- /dev/null
+++ b/ports/stm32/btstack.c
@@ -0,0 +1,223 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+#include "py/mphal.h"
+
+#if MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_BTSTACK
+
+#include "lib/btstack/src/btstack.h"
+#include "lib/btstack/platform/embedded/btstack_run_loop_embedded.h"
+#include "lib/btstack/platform/embedded/hal_cpu.h"
+#include "lib/btstack/platform/embedded/hal_time_ms.h"
+
+#include "extmod/modbluetooth_hci.h"
+#include "extmod/btstack/modbluetooth_btstack.h"
+
+// We pass the bytes directly to the UART during a send, but then notify btstack in the next poll.
+STATIC bool send_done;
+STATIC void (*send_handler)(void);
+
+// btstack issues a read of len bytes, and gives us a buffer to asynchronously fill up.
+STATIC uint8_t *recv_buf;
+STATIC size_t recv_len;
+STATIC size_t recv_idx;
+STATIC void (*recv_handler)(void);
+
+// The IRQ functionality in btstack_run_loop_embedded.c is not used, so the
+// following three functions are empty.
+
+void hal_cpu_disable_irqs(void) {
+}
+
+void hal_cpu_enable_irqs(void) {
+}
+
+void hal_cpu_enable_irqs_and_sleep(void) {
+}
+
+uint32_t hal_time_ms(void) {
+    return mp_hal_ticks_ms();
+}
+
+STATIC int btstack_uart_init(const btstack_uart_config_t *uart_config) {
+    send_done = false;
+    recv_len = 0;
+    recv_idx = 0;
+    recv_handler = NULL;
+    send_handler = NULL;
+
+    // Set up the UART periperhal.
+    mp_bluetooth_hci_uart_init(MICROPY_HW_BLE_UART_ID);
+
+    return 0;
+}
+
+STATIC int btstack_uart_open(void) {
+    // Attach IRQ and power up the HCI controller.
+    mp_bluetooth_hci_uart_activate();
+    return 0;
+}
+
+STATIC int btstack_uart_close(void) {
+    return 0;
+}
+
+STATIC void btstack_uart_set_block_received(void (*block_handler)(void)) {
+    recv_handler = block_handler;
+}
+
+STATIC void btstack_uart_set_block_sent(void (*block_handler)(void)) {
+    send_handler = block_handler;
+}
+
+STATIC int btstack_uart_set_baudrate(uint32_t baudrate) {
+    mp_bluetooth_hci_uart_set_baudrate(baudrate);
+    return 0;
+}
+
+STATIC int btstack_uart_set_parity(int parity) {
+    return 0;
+}
+
+STATIC int btstack_uart_set_flowcontrol(int flowcontrol) {
+    return 0;
+}
+
+STATIC void btstack_uart_receive_block(uint8_t *buf, uint16_t len) {
+    recv_buf = buf;
+    recv_len = len;
+}
+
+STATIC void btstack_uart_send_block(const uint8_t *buf, uint16_t len) {
+    mp_bluetooth_hci_uart_write(buf, len);
+    send_done = true;
+}
+
+STATIC int btstack_uart_get_supported_sleep_modes(void) {
+    return 0;
+}
+
+STATIC void btstack_uart_set_sleep(btstack_uart_sleep_mode_t sleep_mode) {
+    // printf("btstack_uart_set_sleep %u\n", sleep_mode);
+}
+
+STATIC void btstack_uart_set_wakeup_handler(void (*wakeup_handler)(void)) {
+    // printf("btstack_uart_set_wakeup_handler\n");
+}
+
+STATIC const btstack_uart_block_t btstack_uart_block = {
+    &btstack_uart_init,
+    &btstack_uart_open,
+    &btstack_uart_close,
+    &btstack_uart_set_block_received,
+    &btstack_uart_set_block_sent,
+    &btstack_uart_set_baudrate,
+    &btstack_uart_set_parity,
+    &btstack_uart_set_flowcontrol,
+    &btstack_uart_receive_block,
+    &btstack_uart_send_block,
+    &btstack_uart_get_supported_sleep_modes,
+    &btstack_uart_set_sleep,
+    &btstack_uart_set_wakeup_handler,
+};
+
+STATIC const hci_transport_config_uart_t hci_transport_config_uart = {
+    HCI_TRANSPORT_CONFIG_UART,
+    MICROPY_HW_BLE_UART_BAUDRATE,
+    3000000,
+    0,
+    NULL,
+};
+
+STATIC void btstack_uart_process(void) {
+    if (send_done) {
+        // If we'd done a TX in the last interval, notify btstack that it's complete.
+        send_done = false;
+        if (send_handler) {
+            send_handler();
+        }
+    }
+
+    // Append any new bytes to the recv buffer, notifying bstack if we've got
+    // the number of bytes it was looking for.
+    int chr;
+    while (recv_idx < recv_len && (chr = mp_bluetooth_hci_uart_readchar()) >= 0) {
+        recv_buf[recv_idx++] = chr;
+        if (recv_idx == recv_len) {
+            recv_idx = 0;
+            recv_len = 0;
+            if (recv_handler) {
+                recv_handler();
+            }
+        }
+    }
+}
+
+void mp_bluetooth_hci_poll(void) {
+    if (mp_bluetooth_btstack_state == MP_BLUETOOTH_BTSTACK_STATE_OFF) {
+        return;
+    }
+
+    // Process uart data.
+    bool host_wake = mp_bluetooth_hci_controller_woken();
+    btstack_uart_process();
+    if (host_wake) {
+        mp_bluetooth_hci_controller_sleep_maybe();
+    }
+
+    // Call the BTstack run loop.
+    btstack_run_loop_embedded_execute_once();
+}
+
+void mp_bluetooth_btstack_port_init(void) {
+    static bool run_loop_init = false;
+    if (!run_loop_init) {
+        run_loop_init = true;
+        btstack_run_loop_init(btstack_run_loop_embedded_get_instance());
+    } else {
+        btstack_run_loop_embedded_get_instance()->init();
+    }
+
+    // hci_dump_open(NULL, HCI_DUMP_STDOUT);
+    const hci_transport_t *transport = hci_transport_h4_instance(&btstack_uart_block);
+    hci_init(transport, &hci_transport_config_uart);
+
+    // TODO: Probably not necessary for BCM (we have our own firmware loader),
+    // but might be worth investigating for other controllers in the future.
+    // hci_set_chipset(btstack_chipset_bcm_instance());
+}
+
+void mp_bluetooth_btstack_port_deinit(void) {
+    hci_power_control(HCI_POWER_OFF);
+}
+
+void mp_bluetooth_btstack_port_start(void) {
+    hci_power_control(HCI_POWER_ON);
+}
+
+#endif // MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_BTSTACK
diff --git a/ports/stm32/can.c b/ports/stm32/can.c
index 2293f94db8818..e5fc55e409bbc 100644
--- a/ports/stm32/can.c
+++ b/ports/stm32/can.c
@@ -24,85 +24,45 @@
  * THE SOFTWARE.
  */
 
-#include <stdio.h>
-#include <string.h>
-#include <stdarg.h>
-
-#include "py/objtuple.h"
-#include "py/objarray.h"
 #include "py/runtime.h"
-#include "py/gc.h"
-#include "py/binary.h"
-#include "py/stream.h"
 #include "py/mperrno.h"
 #include "py/mphal.h"
-#include "bufhelper.h"
 #include "can.h"
 #include "irq.h"
 
 #if MICROPY_HW_ENABLE_CAN
 
-#define MASK16 (0)
-#define LIST16 (1)
-#define MASK32 (2)
-#define LIST32 (3)
-
-enum {
-    CAN_STATE_STOPPED,
-    CAN_STATE_ERROR_ACTIVE,
-    CAN_STATE_ERROR_WARNING,
-    CAN_STATE_ERROR_PASSIVE,
-    CAN_STATE_BUS_OFF,
-};
-
-/// \moduleref pyb
-/// \class CAN - controller area network communication bus
-///
-/// CAN implements the standard CAN communications protocol.  At
-/// the physical level it consists of 2 lines: RX and TX.  Note that
-/// to connect the pyboard to a CAN bus you must use a CAN transceiver
-/// to convert the CAN logic signals from the pyboard to the correct
-/// voltage levels on the bus.
-///
-/// Note that this driver does not yet support filter configuration
-/// (it defaults to a single filter that lets through all messages),
-/// or bus timing configuration (except for setting the prescaler).
-///
-/// Example usage (works without anything connected):
-///
-///     from pyb import CAN
-///     can = pyb.CAN(1, pyb.CAN.LOOPBACK)
-///     can.send('message!', 123)   # send message with id 123
-///     can.recv(0)                 # receive message on FIFO 0
-
-typedef enum _rx_state_t {
-    RX_STATE_FIFO_EMPTY = 0,
-    RX_STATE_MESSAGE_PENDING,
-    RX_STATE_FIFO_FULL,
-    RX_STATE_FIFO_OVERFLOW,
-} rx_state_t;
+void can_init0(void) {
+    for (uint i = 0; i < MP_ARRAY_SIZE(MP_STATE_PORT(pyb_can_obj_all)); i++) {
+        MP_STATE_PORT(pyb_can_obj_all)[i] = NULL;
+    }
+}
 
-typedef struct _pyb_can_obj_t {
-    mp_obj_base_t base;
-    mp_obj_t rxcallback0;
-    mp_obj_t rxcallback1;
-    mp_uint_t can_id : 8;
-    bool is_enabled : 1;
-    bool extframe : 1;
-    byte rx_state0;
-    byte rx_state1;
-    uint16_t num_error_warning;
-    uint16_t num_error_passive;
-    uint16_t num_bus_off;
-    CAN_HandleTypeDef can;
-} pyb_can_obj_t;
+void can_deinit_all(void) {
+    for (int i = 0; i < MP_ARRAY_SIZE(MP_STATE_PORT(pyb_can_obj_all)); i++) {
+        pyb_can_obj_t *can_obj = MP_STATE_PORT(pyb_can_obj_all)[i];
+        if (can_obj != NULL) {
+            can_deinit(can_obj);
+        }
+    }
+}
 
-STATIC mp_obj_t pyb_can_deinit(mp_obj_t self_in);
+#if !MICROPY_HW_ENABLE_FDCAN
 
-STATIC uint8_t can2_start_bank = 14;
+bool can_init(pyb_can_obj_t *can_obj, uint32_t mode, uint32_t prescaler, uint32_t sjw, uint32_t bs1, uint32_t bs2, bool auto_restart) {
+    CAN_InitTypeDef *init = &can_obj->can.Init;
+    init->Mode = mode << 4; // shift-left so modes fit in a small-int
+    init->Prescaler = prescaler;
+    init->SJW = ((sjw - 1) & 3) << 24;
+    init->BS1 = ((bs1 - 1) & 0xf) << 16;
+    init->BS2 = ((bs2 - 1) & 7) << 20;
+    init->TTCM = DISABLE;
+    init->ABOM = auto_restart ? ENABLE : DISABLE;
+    init->AWUM = DISABLE;
+    init->NART = DISABLE;
+    init->RFLM = DISABLE;
+    init->TXFP = DISABLE;
 
-// assumes Init parameters have been set up correctly
-STATIC bool can_init(pyb_can_obj_t *can_obj) {
     CAN_TypeDef *CANx = NULL;
     uint32_t sce_irq = 0;
     const pin_obj_t *pins[2];
@@ -114,7 +74,7 @@ STATIC bool can_init(pyb_can_obj_t *can_obj) {
             sce_irq = CAN1_SCE_IRQn;
             pins[0] = MICROPY_HW_CAN1_TX;
             pins[1] = MICROPY_HW_CAN1_RX;
-            __CAN1_CLK_ENABLE();
+            __HAL_RCC_CAN1_CLK_ENABLE();
             break;
         #endif
 
@@ -124,8 +84,18 @@ STATIC bool can_init(pyb_can_obj_t *can_obj) {
             sce_irq = CAN2_SCE_IRQn;
             pins[0] = MICROPY_HW_CAN2_TX;
             pins[1] = MICROPY_HW_CAN2_RX;
-            __CAN1_CLK_ENABLE(); // CAN2 is a "slave" and needs CAN1 enabled as well
-            __CAN2_CLK_ENABLE();
+            __HAL_RCC_CAN1_CLK_ENABLE(); // CAN2 is a "slave" and needs CAN1 enabled as well
+            __HAL_RCC_CAN2_CLK_ENABLE();
+            break;
+        #endif
+
+        #if defined(MICROPY_HW_CAN3_TX)
+        case PYB_CAN_3:
+            CANx = CAN3;
+            sce_irq = CAN3_SCE_IRQn;
+            pins[0] = MICROPY_HW_CAN3_TX;
+            pins[1] = MICROPY_HW_CAN3_RX;
+            __HAL_RCC_CAN3_CLK_ENABLE(); // CAN3 is a "master" and doesn't need CAN1 enabled as well
             break;
         #endif
 
@@ -134,10 +104,10 @@ STATIC bool can_init(pyb_can_obj_t *can_obj) {
     }
 
     // init GPIO
-    uint32_t mode = MP_HAL_PIN_MODE_ALT;
-    uint32_t pull = MP_HAL_PIN_PULL_UP;
+    uint32_t pin_mode = MP_HAL_PIN_MODE_ALT;
+    uint32_t pin_pull = MP_HAL_PIN_PULL_UP;
     for (int i = 0; i < 2; i++) {
-        if (!mp_hal_pin_config_alt(pins[i], mode, pull, AF_FN_CAN, can_obj->can_id)) {
+        if (!mp_hal_pin_config_alt(pins[i], pin_mode, pin_pull, AF_FN_CAN, can_obj->can_id)) {
             return false;
         }
     }
@@ -159,44 +129,60 @@ STATIC bool can_init(pyb_can_obj_t *can_obj) {
     return true;
 }
 
-void can_init0(void) {
-    for (uint i = 0; i < MP_ARRAY_SIZE(MP_STATE_PORT(pyb_can_obj_all)); i++) {
-        MP_STATE_PORT(pyb_can_obj_all)[i] = NULL;
-    }
-}
-
-void can_deinit(void) {
-    for (int i = 0; i < MP_ARRAY_SIZE(MP_STATE_PORT(pyb_can_obj_all)); i++) {
-        pyb_can_obj_t *can_obj = MP_STATE_PORT(pyb_can_obj_all)[i];
-        if (can_obj != NULL) {
-            pyb_can_deinit(MP_OBJ_FROM_PTR(can_obj));
-        }
+void can_deinit(pyb_can_obj_t *self) {
+    self->is_enabled = false;
+    HAL_CAN_DeInit(&self->can);
+    if (self->can.Instance == CAN1) {
+        HAL_NVIC_DisableIRQ(CAN1_RX0_IRQn);
+        HAL_NVIC_DisableIRQ(CAN1_RX1_IRQn);
+        HAL_NVIC_DisableIRQ(CAN1_SCE_IRQn);
+        __HAL_RCC_CAN1_FORCE_RESET();
+        __HAL_RCC_CAN1_RELEASE_RESET();
+        __HAL_RCC_CAN1_CLK_DISABLE();
+    #if defined(CAN2)
+    } else if (self->can.Instance == CAN2) {
+        HAL_NVIC_DisableIRQ(CAN2_RX0_IRQn);
+        HAL_NVIC_DisableIRQ(CAN2_RX1_IRQn);
+        HAL_NVIC_DisableIRQ(CAN2_SCE_IRQn);
+        __HAL_RCC_CAN2_FORCE_RESET();
+        __HAL_RCC_CAN2_RELEASE_RESET();
+        __HAL_RCC_CAN2_CLK_DISABLE();
+    #endif
+    #if defined(CAN3)
+    } else if (self->can.Instance == CAN3) {
+        HAL_NVIC_DisableIRQ(CAN3_RX0_IRQn);
+        HAL_NVIC_DisableIRQ(CAN3_RX1_IRQn);
+        HAL_NVIC_DisableIRQ(CAN3_SCE_IRQn);
+        __HAL_RCC_CAN3_FORCE_RESET();
+        __HAL_RCC_CAN3_RELEASE_RESET();
+        __HAL_RCC_CAN3_CLK_DISABLE();
+    #endif
     }
 }
 
-STATIC void can_clearfilter(uint32_t f) {
+void can_clearfilter(pyb_can_obj_t *self, uint32_t f, uint8_t bank) {
     CAN_FilterConfTypeDef filter;
 
-    filter.FilterIdHigh         = 0;
-    filter.FilterIdLow          = 0;
-    filter.FilterMaskIdHigh     = 0;
-    filter.FilterMaskIdLow      = 0;
+    filter.FilterIdHigh = 0;
+    filter.FilterIdLow = 0;
+    filter.FilterMaskIdHigh = 0;
+    filter.FilterMaskIdLow = 0;
     filter.FilterFIFOAssignment = CAN_FILTER_FIFO0;
-    filter.FilterNumber         = f;
-    filter.FilterMode           = CAN_FILTERMODE_IDMASK;
-    filter.FilterScale          = CAN_FILTERSCALE_16BIT;
-    filter.FilterActivation     = DISABLE;
-    filter.BankNumber           = can2_start_bank;
+    filter.FilterNumber = f;
+    filter.FilterMode = CAN_FILTERMODE_IDMASK;
+    filter.FilterScale = CAN_FILTERSCALE_16BIT;
+    filter.FilterActivation = DISABLE;
+    filter.BankNumber = bank;
 
     HAL_CAN_ConfigFilter(NULL, &filter);
 }
 
-STATIC int can_receive(CAN_TypeDef *can, int fifo, CanRxMsgTypeDef *msg, uint32_t timeout_ms) {
+int can_receive(CAN_HandleTypeDef *can, int fifo, CanRxMsgTypeDef *msg, uint8_t *data, uint32_t timeout_ms) {
     volatile uint32_t *rfr;
     if (fifo == CAN_FIFO0) {
-        rfr = &can->RF0R;
+        rfr = &can->Instance->RF0R;
     } else {
-        rfr = &can->RF1R;
+        rfr = &can->Instance->RF1R;
     }
 
     // Wait for a message to become available, with timeout
@@ -209,7 +195,7 @@ STATIC int can_receive(CAN_TypeDef *can, int fifo, CanRxMsgTypeDef *msg, uint32_
     }
 
     // Read message data
-    CAN_FIFOMailBox_TypeDef *box = &can->sFIFOMailBox[fifo];
+    CAN_FIFOMailBox_TypeDef *box = &can->Instance->sFIFOMailBox[fifo];
     msg->IDE = box->RIR & 4;
     if (msg->IDE == CAN_ID_STD) {
         msg->StdId = box->RIR >> 21;
@@ -220,15 +206,15 @@ STATIC int can_receive(CAN_TypeDef *can, int fifo, CanRxMsgTypeDef *msg, uint32_
     msg->DLC = box->RDTR & 0xf;
     msg->FMI = box->RDTR >> 8 & 0xff;
     uint32_t rdlr = box->RDLR;
-    msg->Data[0] = rdlr;
-    msg->Data[1] = rdlr >> 8;
-    msg->Data[2] = rdlr >> 16;
-    msg->Data[3] = rdlr >> 24;
+    data[0] = rdlr;
+    data[1] = rdlr >> 8;
+    data[2] = rdlr >> 16;
+    data[3] = rdlr >> 24;
     uint32_t rdhr = box->RDHR;
-    msg->Data[4] = rdhr;
-    msg->Data[5] = rdhr >> 8;
-    msg->Data[6] = rdhr >> 16;
-    msg->Data[7] = rdhr >> 24;
+    data[4] = rdhr;
+    data[5] = rdhr >> 8;
+    data[6] = rdhr >> 16;
+    data[7] = rdhr >> 24;
 
     // Release (free) message from FIFO
     *rfr |= CAN_RF0R_RFOM0;
@@ -237,7 +223,7 @@ STATIC int can_receive(CAN_TypeDef *can, int fifo, CanRxMsgTypeDef *msg, uint32_
 }
 
 // We have our own version of CAN transmit so we can handle Timeout=0 correctly.
-STATIC HAL_StatusTypeDef CAN_Transmit(CAN_HandleTypeDef *hcan, uint32_t Timeout) {
+HAL_StatusTypeDef CAN_Transmit(CAN_HandleTypeDef *hcan, uint32_t Timeout) {
     uint32_t transmitmailbox;
     uint32_t tickstart;
     uint32_t rqcpflag;
@@ -249,15 +235,15 @@ STATIC HAL_StatusTypeDef CAN_Transmit(CAN_HandleTypeDef *hcan, uint32_t Timeout)
     assert_param(IS_CAN_DLC(hcan->pTxMsg->DLC));
 
     // Select one empty transmit mailbox
-    if ((hcan->Instance->TSR&CAN_TSR_TME0) == CAN_TSR_TME0) {
+    if ((hcan->Instance->TSR & CAN_TSR_TME0) == CAN_TSR_TME0) {
         transmitmailbox = CAN_TXMAILBOX_0;
         rqcpflag = CAN_FLAG_RQCP0;
         txokflag = CAN_FLAG_TXOK0;
-    } else if ((hcan->Instance->TSR&CAN_TSR_TME1) == CAN_TSR_TME1) {
+    } else if ((hcan->Instance->TSR & CAN_TSR_TME1) == CAN_TSR_TME1) {
         transmitmailbox = CAN_TXMAILBOX_1;
         rqcpflag = CAN_FLAG_RQCP1;
         txokflag = CAN_FLAG_TXOK1;
-    } else if ((hcan->Instance->TSR&CAN_TSR_TME2) == CAN_TSR_TME2) {
+    } else if ((hcan->Instance->TSR & CAN_TSR_TME2) == CAN_TSR_TME2) {
         transmitmailbox = CAN_TXMAILBOX_2;
         rqcpflag = CAN_FLAG_RQCP2;
         txokflag = CAN_FLAG_TXOK2;
@@ -271,12 +257,12 @@ STATIC HAL_StatusTypeDef CAN_Transmit(CAN_HandleTypeDef *hcan, uint32_t Timeout)
         if (hcan->pTxMsg->IDE == CAN_ID_STD) {
             assert_param(IS_CAN_STDID(hcan->pTxMsg->StdId));
             hcan->Instance->sTxMailBox[transmitmailbox].TIR |= ((hcan->pTxMsg->StdId << 21) | \
-                                                        hcan->pTxMsg->RTR);
+                hcan->pTxMsg->RTR);
         } else {
             assert_param(IS_CAN_EXTID(hcan->pTxMsg->ExtId));
             hcan->Instance->sTxMailBox[transmitmailbox].TIR |= ((hcan->pTxMsg->ExtId << 3) | \
-                                                        hcan->pTxMsg->IDE | \
-                                                        hcan->pTxMsg->RTR);
+                hcan->pTxMsg->IDE | \
+                hcan->pTxMsg->RTR);
         }
 
         // Set up the DLC
@@ -286,13 +272,13 @@ STATIC HAL_StatusTypeDef CAN_Transmit(CAN_HandleTypeDef *hcan, uint32_t Timeout)
 
         // Set up the data field
         hcan->Instance->sTxMailBox[transmitmailbox].TDLR = (((uint32_t)hcan->pTxMsg->Data[3] << 24) |
-                                                ((uint32_t)hcan->pTxMsg->Data[2] << 16) |
-                                                ((uint32_t)hcan->pTxMsg->Data[1] << 8) |
-                                                ((uint32_t)hcan->pTxMsg->Data[0]));
+            ((uint32_t)hcan->pTxMsg->Data[2] << 16) |
+            ((uint32_t)hcan->pTxMsg->Data[1] << 8) |
+            ((uint32_t)hcan->pTxMsg->Data[0]));
         hcan->Instance->sTxMailBox[transmitmailbox].TDHR = (((uint32_t)hcan->pTxMsg->Data[7] << 24) |
-                                                ((uint32_t)hcan->pTxMsg->Data[6] << 16) |
-                                                ((uint32_t)hcan->pTxMsg->Data[5] << 8) |
-                                                ((uint32_t)hcan->pTxMsg->Data[4]));
+            ((uint32_t)hcan->pTxMsg->Data[6] << 16) |
+            ((uint32_t)hcan->pTxMsg->Data[5] << 8) |
+            ((uint32_t)hcan->pTxMsg->Data[4]));
         // Request transmission
         hcan->Instance->sTxMailBox[transmitmailbox].TIR |= CAN_TI0R_TXRQ;
 
@@ -326,683 +312,7 @@ STATIC HAL_StatusTypeDef CAN_Transmit(CAN_HandleTypeDef *hcan, uint32_t Timeout)
     }
 }
 
-/******************************************************************************/
-// MicroPython bindings
-
-STATIC void pyb_can_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
-    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    if (!self->is_enabled) {
-        mp_printf(print, "CAN(%u)", self->can_id);
-    } else {
-        qstr mode;
-        switch (self->can.Init.Mode) {
-            case CAN_MODE_NORMAL: mode = MP_QSTR_NORMAL; break;
-            case CAN_MODE_LOOPBACK: mode = MP_QSTR_LOOPBACK; break;
-            case CAN_MODE_SILENT: mode = MP_QSTR_SILENT; break;
-            case CAN_MODE_SILENT_LOOPBACK: default: mode = MP_QSTR_SILENT_LOOPBACK; break;
-        }
-        mp_printf(print, "CAN(%u, CAN.%q, extframe=%q, auto_restart=%q)",
-            self->can_id,
-            mode,
-            self->extframe ? MP_QSTR_True : MP_QSTR_False,
-            (self->can.Instance->MCR & CAN_MCR_ABOM) ? MP_QSTR_True : MP_QSTR_False);
-    }
-}
-
-// init(mode, extframe=False, prescaler=100, *, sjw=1, bs1=6, bs2=8)
-STATIC mp_obj_t pyb_can_init_helper(pyb_can_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_mode, ARG_extframe, ARG_prescaler, ARG_sjw, ARG_bs1, ARG_bs2, ARG_auto_restart };
-    static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_mode,         MP_ARG_REQUIRED | MP_ARG_INT,   {.u_int  = CAN_MODE_NORMAL} },
-        { MP_QSTR_extframe,     MP_ARG_BOOL,                    {.u_bool = false} },
-        { MP_QSTR_prescaler,    MP_ARG_INT,                     {.u_int  = 100} },
-        { MP_QSTR_sjw,          MP_ARG_KW_ONLY | MP_ARG_INT,    {.u_int = 1} },
-        { MP_QSTR_bs1,          MP_ARG_KW_ONLY | MP_ARG_INT,    {.u_int = 6} },
-        { MP_QSTR_bs2,          MP_ARG_KW_ONLY | MP_ARG_INT,    {.u_int = 8} },
-        { MP_QSTR_auto_restart, MP_ARG_KW_ONLY | MP_ARG_BOOL,   {.u_bool = false} },
-    };
-
-    // parse args
-    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
-    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-
-    self->extframe = args[ARG_extframe].u_bool;
-
-    // set the CAN configuration values
-    memset(&self->can, 0, sizeof(self->can));
-    CAN_InitTypeDef *init = &self->can.Init;
-    init->Mode = args[ARG_mode].u_int << 4; // shift-left so modes fit in a small-int
-    init->Prescaler = args[ARG_prescaler].u_int;
-    init->SJW = ((args[ARG_sjw].u_int - 1) & 3) << 24;
-    init->BS1 = ((args[ARG_bs1].u_int - 1) & 0xf) << 16;
-    init->BS2 = ((args[ARG_bs2].u_int - 1) & 7) << 20;
-    init->TTCM = DISABLE;
-    init->ABOM = args[ARG_auto_restart].u_bool ? ENABLE : DISABLE;
-    init->AWUM = DISABLE;
-    init->NART = DISABLE;
-    init->RFLM = DISABLE;
-    init->TXFP = DISABLE;
-
-    // init CAN (if it fails, it's because the port doesn't exist)
-    if (!can_init(self)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "CAN(%d) doesn't exist", self->can_id));
-    }
-
-    return mp_const_none;
-}
-
-/// \classmethod \constructor(bus, ...)
-///
-/// Construct a CAN object on the given bus.  `bus` can be 1-2, or 'YA' or 'YB'.
-/// With no additional parameters, the CAN object is created but not
-/// initialised (it has the settings from the last initialisation of
-/// the bus, if any).  If extra arguments are given, the bus is initialised.
-/// See `init` for parameters of initialisation.
-///
-/// The physical pins of the CAN busses are:
-///
-///   - `CAN(1)` is on `YA`: `(RX, TX) = (Y3, Y4) = (PB8, PB9)`
-///   - `CAN(2)` is on `YB`: `(RX, TX) = (Y5, Y6) = (PB12, PB13)`
-STATIC mp_obj_t pyb_can_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
-    // check arguments
-    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
-
-    // work out port
-    mp_uint_t can_idx;
-    if (mp_obj_is_str(args[0])) {
-        const char *port = mp_obj_str_get_str(args[0]);
-        if (0) {
-        #ifdef MICROPY_HW_CAN1_NAME
-        } else if (strcmp(port, MICROPY_HW_CAN1_NAME) == 0) {
-            can_idx = PYB_CAN_1;
-        #endif
-        #ifdef MICROPY_HW_CAN2_NAME
-        } else if (strcmp(port, MICROPY_HW_CAN2_NAME) == 0) {
-            can_idx = PYB_CAN_2;
-        #endif
-        } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "CAN(%s) doesn't exist", port));
-        }
-    } else {
-        can_idx = mp_obj_get_int(args[0]);
-    }
-    if (can_idx < 1 || can_idx > MP_ARRAY_SIZE(MP_STATE_PORT(pyb_can_obj_all))) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "CAN(%d) doesn't exist", can_idx));
-    }
-
-    pyb_can_obj_t *self;
-    if (MP_STATE_PORT(pyb_can_obj_all)[can_idx - 1] == NULL) {
-        self = m_new_obj(pyb_can_obj_t);
-        self->base.type = &pyb_can_type;
-        self->can_id = can_idx;
-        self->is_enabled = false;
-        MP_STATE_PORT(pyb_can_obj_all)[can_idx - 1] = self;
-    } else {
-        self = MP_STATE_PORT(pyb_can_obj_all)[can_idx - 1];
-    }
-
-    if (!self->is_enabled || n_args > 1) {
-        if (self->is_enabled) {
-            // The caller is requesting a reconfiguration of the hardware
-            // this can only be done if the hardware is in init mode
-            pyb_can_deinit(MP_OBJ_FROM_PTR(self));
-        }
-
-        self->rxcallback0 = mp_const_none;
-        self->rxcallback1 = mp_const_none;
-        self->rx_state0 = RX_STATE_FIFO_EMPTY;
-        self->rx_state1 = RX_STATE_FIFO_EMPTY;
-
-        if (n_args > 1 || n_kw > 0) {
-            // start the peripheral
-            mp_map_t kw_args;
-            mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
-            pyb_can_init_helper(self, n_args - 1, args + 1, &kw_args);
-        }
-    }
-
-    return MP_OBJ_FROM_PTR(self);
-}
-
-STATIC mp_obj_t pyb_can_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
-    return pyb_can_init_helper(MP_OBJ_TO_PTR(args[0]), n_args - 1, args + 1, kw_args);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_can_init_obj, 1, pyb_can_init);
-
-/// \method deinit()
-/// Turn off the CAN bus.
-STATIC mp_obj_t pyb_can_deinit(mp_obj_t self_in) {
-    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    self->is_enabled = false;
-    HAL_CAN_DeInit(&self->can);
-    if (self->can.Instance == CAN1) {
-        HAL_NVIC_DisableIRQ(CAN1_RX0_IRQn);
-        HAL_NVIC_DisableIRQ(CAN1_RX1_IRQn);
-        HAL_NVIC_DisableIRQ(CAN1_SCE_IRQn);
-        __CAN1_FORCE_RESET();
-        __CAN1_RELEASE_RESET();
-        __CAN1_CLK_DISABLE();
-    #if defined(CAN2)
-    } else if (self->can.Instance == CAN2) {
-        HAL_NVIC_DisableIRQ(CAN2_RX0_IRQn);
-        HAL_NVIC_DisableIRQ(CAN2_RX1_IRQn);
-        HAL_NVIC_DisableIRQ(CAN2_SCE_IRQn);
-        __CAN2_FORCE_RESET();
-        __CAN2_RELEASE_RESET();
-        __CAN2_CLK_DISABLE();
-    #endif
-    }
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_can_deinit_obj, pyb_can_deinit);
-
-// Force a software restart of the controller, to allow transmission after a bus error
-STATIC mp_obj_t pyb_can_restart(mp_obj_t self_in) {
-    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    if (!self->is_enabled) {
-        mp_raise_ValueError(NULL);
-    }
-    CAN_TypeDef *can = self->can.Instance;
-    can->MCR |= CAN_MCR_INRQ;
-    while ((can->MSR & CAN_MSR_INAK) == 0) {
-    }
-    can->MCR &= ~CAN_MCR_INRQ;
-    while ((can->MSR & CAN_MSR_INAK)) {
-    }
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_can_restart_obj, pyb_can_restart);
-
-// Get the state of the controller
-STATIC mp_obj_t pyb_can_state(mp_obj_t self_in) {
-    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    mp_int_t state = CAN_STATE_STOPPED;
-    if (self->is_enabled) {
-        CAN_TypeDef *can = self->can.Instance;
-        if (can->ESR & CAN_ESR_BOFF) {
-            state = CAN_STATE_BUS_OFF;
-        } else if (can->ESR & CAN_ESR_EPVF) {
-            state = CAN_STATE_ERROR_PASSIVE;
-        } else if (can->ESR & CAN_ESR_EWGF) {
-            state = CAN_STATE_ERROR_WARNING;
-        } else {
-            state = CAN_STATE_ERROR_ACTIVE;
-        }
-    }
-    return MP_OBJ_NEW_SMALL_INT(state);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_can_state_obj, pyb_can_state);
-
-// Get info about error states and TX/RX buffers
-STATIC mp_obj_t pyb_can_info(size_t n_args, const mp_obj_t *args) {
-    pyb_can_obj_t *self = MP_OBJ_TO_PTR(args[0]);
-    mp_obj_list_t *list;
-    if (n_args == 1) {
-        list = MP_OBJ_TO_PTR(mp_obj_new_list(8, NULL));
-    } else {
-        if (!mp_obj_is_type(args[1], &mp_type_list)) {
-            mp_raise_TypeError(NULL);
-        }
-        list = MP_OBJ_TO_PTR(args[1]);
-        if (list->len < 8) {
-            mp_raise_ValueError(NULL);
-        }
-    }
-    CAN_TypeDef *can = self->can.Instance;
-    uint32_t esr = can->ESR;
-    list->items[0] = MP_OBJ_NEW_SMALL_INT(esr >> CAN_ESR_TEC_Pos & 0xff);
-    list->items[1] = MP_OBJ_NEW_SMALL_INT(esr >> CAN_ESR_REC_Pos & 0xff);
-    list->items[2] = MP_OBJ_NEW_SMALL_INT(self->num_error_warning);
-    list->items[3] = MP_OBJ_NEW_SMALL_INT(self->num_error_passive);
-    list->items[4] = MP_OBJ_NEW_SMALL_INT(self->num_bus_off);
-    int n_tx_pending = 0x01121223 >> ((can->TSR >> CAN_TSR_TME_Pos & 7) << 2) & 0xf;
-    list->items[5] = MP_OBJ_NEW_SMALL_INT(n_tx_pending);
-    list->items[6] = MP_OBJ_NEW_SMALL_INT(can->RF0R >> CAN_RF0R_FMP0_Pos & 3);
-    list->items[7] = MP_OBJ_NEW_SMALL_INT(can->RF1R >> CAN_RF1R_FMP1_Pos & 3);
-    return MP_OBJ_FROM_PTR(list);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_can_info_obj, 1, 2, pyb_can_info);
-
-/// \method any(fifo)
-/// Return `True` if any message waiting on the FIFO, else `False`.
-STATIC mp_obj_t pyb_can_any(mp_obj_t self_in, mp_obj_t fifo_in) {
-    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    mp_int_t fifo = mp_obj_get_int(fifo_in);
-    if (fifo == 0) {
-        if (__HAL_CAN_MSG_PENDING(&self->can, CAN_FIFO0) != 0) {
-            return mp_const_true;
-        }
-    } else {
-        if (__HAL_CAN_MSG_PENDING(&self->can, CAN_FIFO1) != 0) {
-            return mp_const_true;
-        }
-    }
-    return mp_const_false;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_can_any_obj, pyb_can_any);
-
-/// \method send(send, addr, *, timeout=5000)
-/// Send a message on the bus:
-///
-///   - `send` is the data to send (an integer to send, or a buffer object).
-///   - `addr` is the address to send to
-///   - `timeout` is the timeout in milliseconds to wait for the send.
-///
-/// Return value: `None`.
-STATIC mp_obj_t pyb_can_send(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_data, ARG_id, ARG_timeout, ARG_rtr };
-    static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_data,    MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
-        { MP_QSTR_id,      MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
-        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
-        { MP_QSTR_rtr,     MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
-    };
-
-    // parse args
-    pyb_can_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
-    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
-    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-
-    // get the buffer to send from
-    mp_buffer_info_t bufinfo;
-    uint8_t data[1];
-    pyb_buf_get_for_send(args[ARG_data].u_obj, &bufinfo, data);
-
-    if (bufinfo.len > 8) {
-        mp_raise_ValueError("CAN data field too long");
-    }
-
-    // send the data
-    CanTxMsgTypeDef tx_msg;
-    if (self->extframe) {
-        tx_msg.ExtId = args[ARG_id].u_int & 0x1FFFFFFF;
-        tx_msg.IDE = CAN_ID_EXT;
-    } else {
-        tx_msg.StdId = args[ARG_id].u_int & 0x7FF;
-        tx_msg.IDE = CAN_ID_STD;
-    }
-    if (args[ARG_rtr].u_bool == false) {
-        tx_msg.RTR = CAN_RTR_DATA;
-    } else  {
-        tx_msg.RTR = CAN_RTR_REMOTE;
-    }
-    tx_msg.DLC = bufinfo.len;
-    for (mp_uint_t i = 0; i < bufinfo.len; i++) {
-        tx_msg.Data[i] = ((byte*)bufinfo.buf)[i]; // Data is uint32_t but holds only 1 byte
-    }
-
-    self->can.pTxMsg = &tx_msg;
-    HAL_StatusTypeDef status = CAN_Transmit(&self->can, args[ARG_timeout].u_int);
-
-    if (status != HAL_OK) {
-        mp_hal_raise(status);
-    }
-
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_can_send_obj, 1, pyb_can_send);
-
-/// \method recv(fifo, list=None, *, timeout=5000)
-///
-/// Receive data on the bus:
-///
-///   - `fifo` is an integer, which is the FIFO to receive on
-///   - `list` if not None is a list with at least 4 elements
-///   - `timeout` is the timeout in milliseconds to wait for the receive.
-///
-/// Return value: buffer of data bytes.
-STATIC mp_obj_t pyb_can_recv(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_fifo, ARG_list, ARG_timeout };
-    static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_fifo,    MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
-        { MP_QSTR_list,    MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
-        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} },
-    };
-
-    // parse args
-    pyb_can_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
-    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
-    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-
-    // receive the data
-    CanRxMsgTypeDef rx_msg;
-    int ret = can_receive(self->can.Instance, args[ARG_fifo].u_int, &rx_msg, args[ARG_timeout].u_int);
-    if (ret < 0) {
-        mp_raise_OSError(-ret);
-    }
-
-    // Manage the rx state machine
-    mp_int_t fifo = args[ARG_fifo].u_int;
-    if ((fifo == CAN_FIFO0 && self->rxcallback0 != mp_const_none) ||
-        (fifo == CAN_FIFO1 && self->rxcallback1 != mp_const_none)) {
-        byte *state = (fifo == CAN_FIFO0) ? &self->rx_state0 : &self->rx_state1;
-
-        switch (*state) {
-        case RX_STATE_FIFO_EMPTY:
-            break;
-        case RX_STATE_MESSAGE_PENDING:
-            if (__HAL_CAN_MSG_PENDING(&self->can, fifo) == 0) {
-                // Fifo is empty
-                __HAL_CAN_ENABLE_IT(&self->can, (fifo == CAN_FIFO0) ? CAN_IT_FMP0 : CAN_IT_FMP1);
-                *state = RX_STATE_FIFO_EMPTY;
-            }
-            break;
-        case RX_STATE_FIFO_FULL:
-            __HAL_CAN_ENABLE_IT(&self->can, (fifo == CAN_FIFO0) ? CAN_IT_FF0 : CAN_IT_FF1);
-            *state = RX_STATE_MESSAGE_PENDING;
-            break;
-        case RX_STATE_FIFO_OVERFLOW:
-            __HAL_CAN_ENABLE_IT(&self->can, (fifo == CAN_FIFO0) ? CAN_IT_FOV0 : CAN_IT_FOV1);
-            __HAL_CAN_ENABLE_IT(&self->can, (fifo == CAN_FIFO0) ? CAN_IT_FF0  : CAN_IT_FF1);
-            *state = RX_STATE_MESSAGE_PENDING;
-            break;
-        }
-    }
-
-    // Create the tuple, or get the list, that will hold the return values
-    // Also populate the fourth element, either a new bytes or reuse existing memoryview
-    mp_obj_t ret_obj = args[ARG_list].u_obj;
-    mp_obj_t *items;
-    if (ret_obj == mp_const_none) {
-        ret_obj = mp_obj_new_tuple(4, NULL);
-        items = ((mp_obj_tuple_t*)MP_OBJ_TO_PTR(ret_obj))->items;
-        items[3] = mp_obj_new_bytes(&rx_msg.Data[0], rx_msg.DLC);
-    } else {
-        // User should provide a list of length at least 4 to hold the values
-        if (!mp_obj_is_type(ret_obj, &mp_type_list)) {
-            mp_raise_TypeError(NULL);
-        }
-        mp_obj_list_t *list = MP_OBJ_TO_PTR(ret_obj);
-        if (list->len < 4) {
-            mp_raise_ValueError(NULL);
-        }
-        items = list->items;
-        // Fourth element must be a memoryview which we assume points to a
-        // byte-like array which is large enough, and then we resize it inplace
-        if (!mp_obj_is_type(items[3], &mp_type_memoryview)) {
-            mp_raise_TypeError(NULL);
-        }
-        mp_obj_array_t *mv = MP_OBJ_TO_PTR(items[3]);
-        if (!(mv->typecode == (MP_OBJ_ARRAY_TYPECODE_FLAG_RW | BYTEARRAY_TYPECODE)
-            || (mv->typecode | 0x20) == (MP_OBJ_ARRAY_TYPECODE_FLAG_RW | 'b'))) {
-            mp_raise_ValueError(NULL);
-        }
-        mv->len = rx_msg.DLC;
-        memcpy(mv->items, &rx_msg.Data[0], rx_msg.DLC);
-    }
-
-    // Populate the first 3 values of the tuple/list
-    if (rx_msg.IDE == CAN_ID_STD) {
-        items[0] = MP_OBJ_NEW_SMALL_INT(rx_msg.StdId);
-    } else {
-        items[0] = MP_OBJ_NEW_SMALL_INT(rx_msg.ExtId);
-    }
-    items[1] = rx_msg.RTR == CAN_RTR_REMOTE ? mp_const_true : mp_const_false;
-    items[2] = MP_OBJ_NEW_SMALL_INT(rx_msg.FMI);
-
-    // Return the result
-    return ret_obj;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_can_recv_obj, 1, pyb_can_recv);
-
-/// \class method initfilterbanks
-///
-/// Set up the filterbanks. All filter will be disabled and set to their reset states.
-///
-///   - `banks` is an integer that sets how many filter banks that are reserved for CAN1.
-///     0  -> no filters assigned for CAN1
-///     28 -> all filters are assigned to CAN1
-///     CAN2 will get the rest of the 28 available.
-///
-/// Return value: none.
-STATIC mp_obj_t pyb_can_initfilterbanks(mp_obj_t self, mp_obj_t bank_in) {
-    can2_start_bank = mp_obj_get_int(bank_in);
-
-    for (int f = 0; f < 28; f++) {
-        can_clearfilter(f);
-    }
-
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_can_initfilterbanks_fun_obj, pyb_can_initfilterbanks);
-STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(pyb_can_initfilterbanks_obj, MP_ROM_PTR(&pyb_can_initfilterbanks_fun_obj));
-
-STATIC mp_obj_t pyb_can_clearfilter(mp_obj_t self_in, mp_obj_t bank_in) {
-    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    mp_int_t f = mp_obj_get_int(bank_in);
-    if (self->can_id == 2) {
-        f += can2_start_bank;
-    }
-    can_clearfilter(f);
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_can_clearfilter_obj, pyb_can_clearfilter);
-
-/// Configures a filterbank
-/// Return value: `None`.
-#define EXTENDED_ID_TO_16BIT_FILTER(id) (((id & 0xC00000) >> 13) | ((id & 0x38000) >> 15)) | 8
-STATIC mp_obj_t pyb_can_setfilter(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    enum { ARG_bank, ARG_mode, ARG_fifo, ARG_params, ARG_rtr };
-    static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_bank,     MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
-        { MP_QSTR_mode,     MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
-        { MP_QSTR_fifo,     MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = CAN_FILTER_FIFO0} },
-        { MP_QSTR_params,   MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
-        { MP_QSTR_rtr,      MP_ARG_KW_ONLY  | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
-    };
-
-    // parse args
-    pyb_can_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
-    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
-    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
-
-    size_t len;
-    size_t rtr_len;
-    mp_uint_t rtr_masks[4] = {0, 0, 0, 0};
-    mp_obj_t *rtr_flags;
-    mp_obj_t *params;
-    mp_obj_get_array(args[ARG_params].u_obj, &len, &params);
-    if (args[ARG_rtr].u_obj != MP_OBJ_NULL){
-        mp_obj_get_array(args[ARG_rtr].u_obj, &rtr_len, &rtr_flags);
-    }
-
-    CAN_FilterConfTypeDef filter;
-    if (args[ARG_mode].u_int == MASK16 || args[ARG_mode].u_int == LIST16) {
-        if (len != 4) {
-            goto error;
-        }
-        filter.FilterScale = CAN_FILTERSCALE_16BIT;
-        if (self->extframe) {
-            if (args[ARG_rtr].u_obj != MP_OBJ_NULL) {
-                if (args[ARG_mode].u_int == MASK16) {
-                    rtr_masks[0] = mp_obj_get_int(rtr_flags[0]) ? 0x02 : 0;
-                    rtr_masks[1] = 0x02;
-                    rtr_masks[2] = mp_obj_get_int(rtr_flags[1]) ? 0x02 : 0;
-                    rtr_masks[3] = 0x02;
-                } else {  // LIST16
-                    rtr_masks[0] = mp_obj_get_int(rtr_flags[0]) ? 0x02 : 0;
-                    rtr_masks[1] = mp_obj_get_int(rtr_flags[1]) ? 0x02 : 0;
-                    rtr_masks[2] = mp_obj_get_int(rtr_flags[2]) ? 0x02 : 0;
-                    rtr_masks[3] = mp_obj_get_int(rtr_flags[3]) ? 0x02 : 0;
-                }
-            }
-            filter.FilterIdLow      = EXTENDED_ID_TO_16BIT_FILTER(mp_obj_get_int(params[0])) | rtr_masks[0]; // id1
-            filter.FilterMaskIdLow  = EXTENDED_ID_TO_16BIT_FILTER(mp_obj_get_int(params[1])) | rtr_masks[1]; // mask1
-            filter.FilterIdHigh     = EXTENDED_ID_TO_16BIT_FILTER(mp_obj_get_int(params[2])) | rtr_masks[2]; // id2
-            filter.FilterMaskIdHigh = EXTENDED_ID_TO_16BIT_FILTER(mp_obj_get_int(params[3])) | rtr_masks[3]; // mask2
-        } else { // Basic frames
-            if (args[ARG_rtr].u_obj != MP_OBJ_NULL) {
-                if (args[ARG_mode].u_int == MASK16) {
-                    rtr_masks[0] = mp_obj_get_int(rtr_flags[0]) ? 0x10 : 0;
-                    rtr_masks[1] = 0x10;
-                    rtr_masks[2] = mp_obj_get_int(rtr_flags[1]) ? 0x10 : 0;
-                    rtr_masks[3] = 0x10;
-                } else {  // LIST16
-                    rtr_masks[0] = mp_obj_get_int(rtr_flags[0]) ? 0x10 : 0;
-                    rtr_masks[1] = mp_obj_get_int(rtr_flags[1]) ? 0x10 : 0;
-                    rtr_masks[2] = mp_obj_get_int(rtr_flags[2]) ? 0x10 : 0;
-                    rtr_masks[3] = mp_obj_get_int(rtr_flags[3]) ? 0x10 : 0;
-                }
-            }
-            filter.FilterIdLow      = (mp_obj_get_int(params[0]) << 5) | rtr_masks[0]; // id1
-            filter.FilterMaskIdLow  = (mp_obj_get_int(params[1]) << 5) | rtr_masks[1]; // mask1
-            filter.FilterIdHigh     = (mp_obj_get_int(params[2]) << 5) | rtr_masks[2]; // id2
-            filter.FilterMaskIdHigh = (mp_obj_get_int(params[3]) << 5) | rtr_masks[3]; // mask2
-        }
-        if (args[ARG_mode].u_int == MASK16) {
-            filter.FilterMode  = CAN_FILTERMODE_IDMASK;
-        }
-        if (args[ARG_mode].u_int == LIST16) {
-            filter.FilterMode  = CAN_FILTERMODE_IDLIST;
-        }
-    }
-    else if (args[ARG_mode].u_int == MASK32 || args[ARG_mode].u_int == LIST32) {
-        if (len != 2) {
-            goto error;
-        }
-        filter.FilterScale = CAN_FILTERSCALE_32BIT;
-        if (args[ARG_rtr].u_obj != MP_OBJ_NULL) {
-            if (args[ARG_mode].u_int == MASK32) {
-                rtr_masks[0] = mp_obj_get_int(rtr_flags[0]) ? 0x02 : 0;
-                rtr_masks[1] = 0x02;
-            } else {  // LIST32
-                rtr_masks[0] = mp_obj_get_int(rtr_flags[0]) ? 0x02 : 0;
-                rtr_masks[1] = mp_obj_get_int(rtr_flags[1]) ? 0x02 : 0;
-            }
-        }
-        filter.FilterIdHigh     = (mp_obj_get_int(params[0]) & 0x1FFFE000)  >> 13;
-        filter.FilterIdLow      = (((mp_obj_get_int(params[0]) & 0x00001FFF) << 3) | 4) | rtr_masks[0];
-        filter.FilterMaskIdHigh = (mp_obj_get_int(params[1]) & 0x1FFFE000 ) >> 13;
-        filter.FilterMaskIdLow  = (((mp_obj_get_int(params[1]) & 0x00001FFF) << 3) | 4) | rtr_masks[1];
-        if (args[ARG_mode].u_int == MASK32) {
-            filter.FilterMode  = CAN_FILTERMODE_IDMASK;
-        }
-        if (args[ARG_mode].u_int == LIST32) {
-            filter.FilterMode  = CAN_FILTERMODE_IDLIST;
-        }
-    } else {
-        goto error;
-    }
-
-    filter.FilterFIFOAssignment = args[ARG_fifo].u_int;
-    filter.FilterNumber = args[ARG_bank].u_int;
-    if (self->can_id == 1) {
-        if (filter.FilterNumber >= can2_start_bank) {
-            goto error;
-        }
-    } else {
-        filter.FilterNumber = filter.FilterNumber + can2_start_bank;
-        if (filter.FilterNumber > 27) {
-            goto error;
-        }
-    }
-    filter.FilterActivation = ENABLE;
-    filter.BankNumber = can2_start_bank;
-    HAL_CAN_ConfigFilter(&self->can, &filter);
-
-    return mp_const_none;
-
-error:
-    mp_raise_ValueError("CAN filter parameter error");
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_can_setfilter_obj, 1, pyb_can_setfilter);
-
-STATIC mp_obj_t pyb_can_rxcallback(mp_obj_t self_in, mp_obj_t fifo_in, mp_obj_t callback_in) {
-    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    mp_int_t fifo = mp_obj_get_int(fifo_in);
-    mp_obj_t *callback;
-
-    callback = (fifo == 0) ? &self->rxcallback0 : &self->rxcallback1;
-    if (callback_in == mp_const_none) {
-        __HAL_CAN_DISABLE_IT(&self->can, (fifo == 0) ? CAN_IT_FMP0 : CAN_IT_FMP1);
-        __HAL_CAN_DISABLE_IT(&self->can, (fifo == 0) ? CAN_IT_FF0 : CAN_IT_FF1);
-        __HAL_CAN_DISABLE_IT(&self->can, (fifo == 0) ? CAN_IT_FOV0 : CAN_IT_FOV1);
-        __HAL_CAN_CLEAR_FLAG(&self->can, (fifo == CAN_FIFO0) ? CAN_FLAG_FF0 : CAN_FLAG_FF1);
-        __HAL_CAN_CLEAR_FLAG(&self->can, (fifo == CAN_FIFO0) ? CAN_FLAG_FOV0 : CAN_FLAG_FOV1);
-        *callback = mp_const_none;
-    } else if (*callback != mp_const_none) {
-        // Rx call backs has already been initialized
-        // only the callback function should be changed
-        *callback = callback_in;
-    } else if (mp_obj_is_callable(callback_in)) {
-        *callback = callback_in;
-        uint32_t irq = 0;
-        if (self->can_id == PYB_CAN_1) {
-            irq = (fifo == 0) ? CAN1_RX0_IRQn : CAN1_RX1_IRQn;
-        #if defined(CAN2)
-        } else {
-            irq = (fifo == 0) ? CAN2_RX0_IRQn : CAN2_RX1_IRQn;
-        #endif
-        }
-        NVIC_SetPriority(irq, IRQ_PRI_CAN);
-        HAL_NVIC_EnableIRQ(irq);
-        __HAL_CAN_ENABLE_IT(&self->can, (fifo == 0) ? CAN_IT_FMP0 : CAN_IT_FMP1);
-        __HAL_CAN_ENABLE_IT(&self->can, (fifo == 0) ? CAN_IT_FF0  : CAN_IT_FF1);
-        __HAL_CAN_ENABLE_IT(&self->can, (fifo == 0) ? CAN_IT_FOV0 : CAN_IT_FOV1);
-    }
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_can_rxcallback_obj, pyb_can_rxcallback);
-
-STATIC const mp_rom_map_elem_t pyb_can_locals_dict_table[] = {
-    // instance methods
-    { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&pyb_can_init_obj) },
-    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&pyb_can_deinit_obj) },
-    { MP_ROM_QSTR(MP_QSTR_restart), MP_ROM_PTR(&pyb_can_restart_obj) },
-    { MP_ROM_QSTR(MP_QSTR_state), MP_ROM_PTR(&pyb_can_state_obj) },
-    { MP_ROM_QSTR(MP_QSTR_info), MP_ROM_PTR(&pyb_can_info_obj) },
-    { MP_ROM_QSTR(MP_QSTR_any), MP_ROM_PTR(&pyb_can_any_obj) },
-    { MP_ROM_QSTR(MP_QSTR_send), MP_ROM_PTR(&pyb_can_send_obj) },
-    { MP_ROM_QSTR(MP_QSTR_recv), MP_ROM_PTR(&pyb_can_recv_obj) },
-    { MP_ROM_QSTR(MP_QSTR_initfilterbanks), MP_ROM_PTR(&pyb_can_initfilterbanks_obj) },
-    { MP_ROM_QSTR(MP_QSTR_setfilter), MP_ROM_PTR(&pyb_can_setfilter_obj) },
-    { MP_ROM_QSTR(MP_QSTR_clearfilter), MP_ROM_PTR(&pyb_can_clearfilter_obj) },
-    { MP_ROM_QSTR(MP_QSTR_rxcallback), MP_ROM_PTR(&pyb_can_rxcallback_obj) },
-
-    // class constants
-    // Note: we use the ST constants >> 4 so they fit in a small-int.  The
-    // right-shift is undone when the constants are used in the init function.
-    { MP_ROM_QSTR(MP_QSTR_NORMAL), MP_ROM_INT(CAN_MODE_NORMAL >> 4) },
-    { MP_ROM_QSTR(MP_QSTR_LOOPBACK), MP_ROM_INT(CAN_MODE_LOOPBACK >> 4) },
-    { MP_ROM_QSTR(MP_QSTR_SILENT), MP_ROM_INT(CAN_MODE_SILENT >> 4) },
-    { MP_ROM_QSTR(MP_QSTR_SILENT_LOOPBACK), MP_ROM_INT(CAN_MODE_SILENT_LOOPBACK >> 4) },
-    { MP_ROM_QSTR(MP_QSTR_MASK16), MP_ROM_INT(MASK16) },
-    { MP_ROM_QSTR(MP_QSTR_LIST16), MP_ROM_INT(LIST16) },
-    { MP_ROM_QSTR(MP_QSTR_MASK32), MP_ROM_INT(MASK32) },
-    { MP_ROM_QSTR(MP_QSTR_LIST32), MP_ROM_INT(LIST32) },
-
-    // values for CAN.state()
-    { MP_ROM_QSTR(MP_QSTR_STOPPED), MP_ROM_INT(CAN_STATE_STOPPED) },
-    { MP_ROM_QSTR(MP_QSTR_ERROR_ACTIVE), MP_ROM_INT(CAN_STATE_ERROR_ACTIVE) },
-    { MP_ROM_QSTR(MP_QSTR_ERROR_WARNING), MP_ROM_INT(CAN_STATE_ERROR_WARNING) },
-    { MP_ROM_QSTR(MP_QSTR_ERROR_PASSIVE), MP_ROM_INT(CAN_STATE_ERROR_PASSIVE) },
-    { MP_ROM_QSTR(MP_QSTR_BUS_OFF), MP_ROM_INT(CAN_STATE_BUS_OFF) },
-};
-
-STATIC MP_DEFINE_CONST_DICT(pyb_can_locals_dict, pyb_can_locals_dict_table);
-
-mp_uint_t can_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
-    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    mp_uint_t ret;
-    if (request == MP_STREAM_POLL) {
-        uintptr_t flags = arg;
-        ret = 0;
-        if ((flags & MP_STREAM_POLL_RD)
-            && ((__HAL_CAN_MSG_PENDING(&self->can, CAN_FIFO0) != 0)
-                || (__HAL_CAN_MSG_PENDING(&self->can, CAN_FIFO1) != 0))) {
-            ret |= MP_STREAM_POLL_RD;
-        }
-        if ((flags & MP_STREAM_POLL_WR) && (self->can.Instance->TSR & CAN_TSR_TME)) {
-            ret |= MP_STREAM_POLL_WR;
-        }
-    } else {
-        *errcode = MP_EINVAL;
-        ret = -1;
-    }
-    return ret;
-}
-
-void can_rx_irq_handler(uint can_id, uint fifo_id) {
+STATIC void can_rx_irq_handler(uint can_id, uint fifo_id) {
     mp_obj_t callback;
     pyb_can_obj_t *self;
     mp_obj_t irq_reason = MP_OBJ_NEW_SMALL_INT(0);
@@ -1041,25 +351,10 @@ void can_rx_irq_handler(uint can_id, uint fifo_id) {
             break;
     }
 
-    if (callback != mp_const_none) {
-        mp_sched_lock();
-        gc_lock();
-        nlr_buf_t nlr;
-        if (nlr_push(&nlr) == 0) {
-            mp_call_function_2(callback, MP_OBJ_FROM_PTR(self), irq_reason);
-            nlr_pop();
-        } else {
-            // Uncaught exception; disable the callback so it doesn't run again.
-            pyb_can_rxcallback(MP_OBJ_FROM_PTR(self), MP_OBJ_NEW_SMALL_INT(fifo_id), mp_const_none);
-            printf("uncaught exception in CAN(%u) rx interrupt handler\n", self->can_id);
-            mp_obj_print_exception(&mp_plat_print, MP_OBJ_FROM_PTR(nlr.ret_val));
-        }
-        gc_unlock();
-        mp_sched_unlock();
-    }
+    pyb_can_handle_callback(self, fifo_id, callback, irq_reason);
 }
 
-void can_sce_irq_handler(uint can_id) {
+STATIC void can_sce_irq_handler(uint can_id) {
     pyb_can_obj_t *self = MP_STATE_PORT(pyb_can_obj_all)[can_id - 1];
     if (self) {
         self->can.Instance->MSR = CAN_MSR_ERRI;
@@ -1074,20 +369,66 @@ void can_sce_irq_handler(uint can_id) {
     }
 }
 
-STATIC const mp_stream_p_t can_stream_p = {
-    //.read = can_read, // is read sensible for CAN?
-    //.write = can_write, // is write sensible for CAN?
-    .ioctl = can_ioctl,
-    .is_text = false,
-};
+#if defined(MICROPY_HW_CAN1_TX)
+void CAN1_RX0_IRQHandler(void) {
+    IRQ_ENTER(CAN1_RX0_IRQn);
+    can_rx_irq_handler(PYB_CAN_1, CAN_FIFO0);
+    IRQ_EXIT(CAN1_RX0_IRQn);
+}
+
+void CAN1_RX1_IRQHandler(void) {
+    IRQ_ENTER(CAN1_RX1_IRQn);
+    can_rx_irq_handler(PYB_CAN_1, CAN_FIFO1);
+    IRQ_EXIT(CAN1_RX1_IRQn);
+}
+
+void CAN1_SCE_IRQHandler(void) {
+    IRQ_ENTER(CAN1_SCE_IRQn);
+    can_sce_irq_handler(PYB_CAN_1);
+    IRQ_EXIT(CAN1_SCE_IRQn);
+}
+#endif
+
+#if defined(MICROPY_HW_CAN2_TX)
+void CAN2_RX0_IRQHandler(void) {
+    IRQ_ENTER(CAN2_RX0_IRQn);
+    can_rx_irq_handler(PYB_CAN_2, CAN_FIFO0);
+    IRQ_EXIT(CAN2_RX0_IRQn);
+}
+
+void CAN2_RX1_IRQHandler(void) {
+    IRQ_ENTER(CAN2_RX1_IRQn);
+    can_rx_irq_handler(PYB_CAN_2, CAN_FIFO1);
+    IRQ_EXIT(CAN2_RX1_IRQn);
+}
+
+void CAN2_SCE_IRQHandler(void) {
+    IRQ_ENTER(CAN2_SCE_IRQn);
+    can_sce_irq_handler(PYB_CAN_2);
+    IRQ_EXIT(CAN2_SCE_IRQn);
+}
+#endif
+
+#if defined(MICROPY_HW_CAN3_TX)
+void CAN3_RX0_IRQHandler(void) {
+    IRQ_ENTER(CAN3_RX0_IRQn);
+    can_rx_irq_handler(PYB_CAN_3, CAN_FIFO0);
+    IRQ_EXIT(CAN3_RX0_IRQn);
+}
+
+void CAN3_RX1_IRQHandler(void) {
+    IRQ_ENTER(CAN3_RX1_IRQn);
+    can_rx_irq_handler(PYB_CAN_3, CAN_FIFO1);
+    IRQ_EXIT(CAN3_RX1_IRQn);
+}
+
+void CAN3_SCE_IRQHandler(void) {
+    IRQ_ENTER(CAN3_SCE_IRQn);
+    can_sce_irq_handler(PYB_CAN_3);
+    IRQ_EXIT(CAN3_SCE_IRQn);
+}
+#endif
 
-const mp_obj_type_t pyb_can_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_CAN,
-    .print = pyb_can_print,
-    .make_new = pyb_can_make_new,
-    .protocol = &can_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&pyb_can_locals_dict,
-};
+#endif // !MICROPY_HW_ENABLE_FDCAN
 
 #endif // MICROPY_HW_ENABLE_CAN
diff --git a/ports/stm32/can.h b/ports/stm32/can.h
index 54e7deaa5e0f9..bb26c0b7e2ec7 100644
--- a/ports/stm32/can.h
+++ b/ports/stm32/can.h
@@ -26,14 +26,68 @@
 #ifndef MICROPY_INCLUDED_STM32_CAN_H
 #define MICROPY_INCLUDED_STM32_CAN_H
 
+#include "py/obj.h"
+
+#if MICROPY_HW_ENABLE_CAN
+
 #define PYB_CAN_1 (1)
 #define PYB_CAN_2 (2)
+#define PYB_CAN_3 (3)
+
+#define MASK16 (0)
+#define LIST16 (1)
+#define MASK32 (2)
+#define LIST32 (3)
+
+#if MICROPY_HW_ENABLE_FDCAN
+#define CAN_TypeDef                 FDCAN_GlobalTypeDef
+#define CAN_HandleTypeDef           FDCAN_HandleTypeDef
+#define CanTxMsgTypeDef             FDCAN_TxHeaderTypeDef
+#define CanRxMsgTypeDef             FDCAN_RxHeaderTypeDef
+#endif
+
+enum {
+    CAN_STATE_STOPPED,
+    CAN_STATE_ERROR_ACTIVE,
+    CAN_STATE_ERROR_WARNING,
+    CAN_STATE_ERROR_PASSIVE,
+    CAN_STATE_BUS_OFF,
+};
+
+typedef enum _rx_state_t {
+    RX_STATE_FIFO_EMPTY = 0,
+    RX_STATE_MESSAGE_PENDING,
+    RX_STATE_FIFO_FULL,
+    RX_STATE_FIFO_OVERFLOW,
+} rx_state_t;
+
+typedef struct _pyb_can_obj_t {
+    mp_obj_base_t base;
+    mp_obj_t rxcallback0;
+    mp_obj_t rxcallback1;
+    mp_uint_t can_id : 8;
+    bool is_enabled : 1;
+    bool extframe : 1;
+    byte rx_state0;
+    byte rx_state1;
+    uint16_t num_error_warning;
+    uint16_t num_error_passive;
+    uint16_t num_bus_off;
+    CAN_HandleTypeDef can;
+} pyb_can_obj_t;
 
 extern const mp_obj_type_t pyb_can_type;
 
 void can_init0(void);
-void can_deinit(void);
-void can_rx_irq_handler(uint can_id, uint fifo_id);
-void can_sce_irq_handler(uint can_id);
+void can_deinit_all(void);
+bool can_init(pyb_can_obj_t *can_obj, uint32_t mode, uint32_t prescaler, uint32_t sjw, uint32_t bs1, uint32_t bs2, bool auto_restart);
+void can_deinit(pyb_can_obj_t *self);
+
+void can_clearfilter(pyb_can_obj_t *self, uint32_t f, uint8_t bank);
+int can_receive(CAN_HandleTypeDef *can, int fifo, CanRxMsgTypeDef *msg, uint8_t *data, uint32_t timeout_ms);
+HAL_StatusTypeDef CAN_Transmit(CAN_HandleTypeDef *hcan, uint32_t Timeout);
+void pyb_can_handle_callback(pyb_can_obj_t *self, uint fifo_id, mp_obj_t callback, mp_obj_t irq_reason);
+
+#endif // MICROPY_HW_ENABLE_CAN
 
 #endif // MICROPY_INCLUDED_STM32_CAN_H
diff --git a/ports/stm32/dac.c b/ports/stm32/dac.c
index 3a92258ffb994..fe3aecdde8747 100644
--- a/ports/stm32/dac.c
+++ b/ports/stm32/dac.c
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2013-2019 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -70,15 +70,6 @@
 #define DAC DAC1
 #endif
 
-STATIC DAC_HandleTypeDef DAC_Handle;
-
-void dac_init(void) {
-    memset(&DAC_Handle, 0, sizeof DAC_Handle);
-    DAC_Handle.Instance = DAC;
-    DAC_Handle.State = HAL_DAC_STATE_RESET;
-    HAL_DAC_Init(&DAC_Handle);
-}
-
 #if defined(TIM6)
 STATIC void TIM6_Config(uint freq) {
     // Init TIM6 at the required frequency (in Hz)
@@ -127,31 +118,107 @@ STATIC uint32_t TIMx_Config(mp_obj_t timer) {
         return DAC_TRIGGER_T8_TRGO;
     #endif
     } else {
-        mp_raise_ValueError("Timer does not support DAC triggering");
+        mp_raise_ValueError(MP_ERROR_TEXT("Timer does not support DAC triggering"));
+    }
+}
+
+STATIC void dac_deinit(uint32_t dac_channel) {
+    DAC->CR &= ~(DAC_CR_EN1 << dac_channel);
+    #if defined(STM32H7) || defined(STM32L4)
+    DAC->MCR = (DAC->MCR & ~(DAC_MCR_MODE1_Msk << dac_channel)) | (DAC_OUTPUTBUFFER_DISABLE << dac_channel);
+    #else
+    DAC->CR |= DAC_CR_BOFF1 << dac_channel;
+    #endif
+}
+
+STATIC void dac_config_channel(uint32_t dac_channel, uint32_t trig, uint32_t outbuf) {
+    DAC->CR &= ~(DAC_CR_EN1 << dac_channel);
+    uint32_t cr_off = DAC_CR_DMAEN1 | DAC_CR_MAMP1 | DAC_CR_WAVE1 | DAC_CR_TSEL1 | DAC_CR_TEN1;
+    uint32_t cr_on = trig;
+    #if defined(STM32H7) || defined(STM32L4)
+    DAC->MCR = (DAC->MCR & ~(DAC_MCR_MODE1_Msk << dac_channel)) | (outbuf << dac_channel);
+    #else
+    cr_off |= DAC_CR_BOFF1;
+    cr_on |= outbuf;
+    #endif
+    DAC->CR = (DAC->CR & ~(cr_off << dac_channel)) | (cr_on << dac_channel);
+}
+
+STATIC void dac_set_value(uint32_t dac_channel, uint32_t align, uint32_t value) {
+    uint32_t base;
+    if (dac_channel == DAC_CHANNEL_1) {
+        base = (uint32_t)&DAC->DHR12R1;
+    #if !defined(STM32L452xx)
+    } else {
+        base = (uint32_t)&DAC->DHR12R2;
+    #endif
+    }
+    *(volatile uint32_t *)(base + align) = value;
+}
+
+STATIC void dac_start(uint32_t dac_channel) {
+    DAC->CR |= DAC_CR_EN1 << dac_channel;
+}
+
+STATIC void dac_start_dma(uint32_t dac_channel, const dma_descr_t *dma_descr, uint32_t dma_mode, uint32_t bit_size, uint32_t dac_align, size_t len, void *buf) {
+    uint32_t dma_align;
+    if (bit_size == 8) {
+        dma_align = DMA_MDATAALIGN_BYTE | DMA_PDATAALIGN_BYTE;
+    } else {
+        dma_align = DMA_MDATAALIGN_HALFWORD | DMA_PDATAALIGN_HALFWORD;
+    }
+
+    uint32_t base;
+    if (dac_channel == DAC_CHANNEL_1) {
+        base = (uint32_t)&DAC->DHR12R1;
+    #if !defined(STM32L452xx)
+    } else {
+        base = (uint32_t)&DAC->DHR12R2;
+    #endif
     }
+
+    dma_nohal_deinit(dma_descr);
+    dma_nohal_init(dma_descr, DMA_MEMORY_TO_PERIPH | dma_mode | dma_align);
+    dma_nohal_start(dma_descr, (uint32_t)buf, base + dac_align, len);
+
+    DAC->CR |= DAC_CR_EN1 << dac_channel;
 }
 
 /******************************************************************************/
 // MicroPython bindings
 
-typedef enum {
-    DAC_STATE_RESET,
-    DAC_STATE_WRITE_SINGLE,
-    DAC_STATE_BUILTIN_WAVEFORM,
-    DAC_STATE_DMA_WAVEFORM, // should be last enum since we use space beyond it
-} pyb_dac_state_t;
-
 typedef struct _pyb_dac_obj_t {
     mp_obj_base_t base;
-    uint32_t dac_channel; // DAC_CHANNEL_1 or DAC_CHANNEL_2
-    const dma_descr_t *tx_dma_descr;
-    mp_hal_pin_obj_t pin; // pin_A4 or pin_A5
+    uint8_t dac_channel; // DAC_CHANNEL_1 or DAC_CHANNEL_2. STM32L452 only has CHANNEL_1.
     uint8_t bits; // 8 or 12
-    uint8_t state;
     uint8_t outbuf_single;
     uint8_t outbuf_waveform;
 } pyb_dac_obj_t;
 
+STATIC pyb_dac_obj_t pyb_dac_obj[2];
+
+STATIC void pyb_dac_reconfigure(pyb_dac_obj_t *self, uint32_t cr, uint32_t outbuf, uint32_t value) {
+    bool restart = false;
+    const uint32_t cr_mask = DAC_CR_DMAEN1 | DAC_CR_MAMP1 | DAC_CR_WAVE1 | DAC_CR_TSEL1 | DAC_CR_TEN1 | DAC_CR_EN1;
+    if (((DAC->CR >> self->dac_channel) & cr_mask) != (cr | DAC_CR_EN1)) {
+        const dma_descr_t *tx_dma_descr;
+        if (self->dac_channel == DAC_CHANNEL_1) {
+            tx_dma_descr = &dma_DAC_1_TX;
+        #if !defined(STM32L452xx)
+        } else {
+            tx_dma_descr = &dma_DAC_2_TX;
+        #endif
+        }
+        dma_nohal_deinit(tx_dma_descr);
+        dac_config_channel(self->dac_channel, cr, outbuf);
+        restart = true;
+    }
+    dac_set_value(self->dac_channel, DAC_ALIGN_12B_R, value);
+    if (restart) {
+        dac_start(self->dac_channel);
+    }
+}
+
 STATIC void pyb_dac_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     pyb_dac_obj_t *self = MP_OBJ_TO_PTR(self_in);
     mp_printf(print, "DAC(%u, bits=%u)",
@@ -162,7 +229,7 @@ STATIC void pyb_dac_print(const mp_print_t *print, mp_obj_t self_in, mp_print_ki
 STATIC mp_obj_t pyb_dac_init_helper(pyb_dac_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_bits, MP_ARG_INT, {.u_int = 8} },
-        { MP_QSTR_buffering, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_buffering, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
     };
 
     // parse args
@@ -170,7 +237,15 @@ STATIC mp_obj_t pyb_dac_init_helper(pyb_dac_obj_t *self, size_t n_args, const mp
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
     // GPIO configuration
-    mp_hal_pin_config(self->pin, MP_HAL_PIN_MODE_ANALOG, MP_HAL_PIN_PULL_NONE, 0);
+    mp_hal_pin_obj_t pin;
+    if (self->dac_channel == DAC_CHANNEL_1) {
+        pin = pin_A4;
+    #if !defined(STM32L452xx)
+    } else {
+        pin = pin_A5;
+    #endif
+    }
+    mp_hal_pin_config(pin, MP_HAL_PIN_MODE_ANALOG, MP_HAL_PIN_PULL_NONE, 0);
 
     // DAC peripheral clock
     #if defined(STM32F4) || defined(STM32F7)
@@ -183,26 +258,14 @@ STATIC mp_obj_t pyb_dac_init_helper(pyb_dac_obj_t *self, size_t n_args, const mp
     #error Unsupported Processor
     #endif
 
-    // stop anything already going on
-    __HAL_RCC_DMA1_CLK_ENABLE();
-    DMA_HandleTypeDef DMA_Handle;
-    /* Get currently configured dma */
-    dma_init_handle(&DMA_Handle, self->tx_dma_descr, DMA_MEMORY_TO_PERIPH, (void*)NULL);
-    // Need to deinit DMA first
-    DMA_Handle.State = HAL_DMA_STATE_READY;
-    HAL_DMA_DeInit(&DMA_Handle);
-
-    HAL_DAC_Stop(&DAC_Handle, self->dac_channel);
-    if ((self->dac_channel == DAC_CHANNEL_1 && DAC_Handle.DMA_Handle1 != NULL)
-            || (self->dac_channel == DAC_CHANNEL_2 && DAC_Handle.DMA_Handle2 != NULL)) {
-        HAL_DAC_Stop_DMA(&DAC_Handle, self->dac_channel);
-    }
+    // Stop the DAC in case it was already running
+    DAC->CR &= ~(DAC_CR_EN1 << self->dac_channel);
 
     // set bit resolution
     if (args[0].u_int == 8 || args[0].u_int == 12) {
         self->bits = args[0].u_int;
     } else {
-        mp_raise_ValueError("unsupported bits");
+        mp_raise_ValueError(MP_ERROR_TEXT("unsupported bits"));
     }
 
     // set output buffer config
@@ -218,9 +281,6 @@ STATIC mp_obj_t pyb_dac_init_helper(pyb_dac_obj_t *self, size_t n_args, const mp
         self->outbuf_waveform = DAC_OUTPUTBUFFER_DISABLE;
     }
 
-    // reset state of DAC
-    self->state = DAC_STATE_RESET;
-
     return mp_const_none;
 }
 
@@ -247,29 +307,31 @@ STATIC mp_obj_t pyb_dac_make_new(const mp_obj_type_t *type, size_t n_args, size_
         } else if (pin == pin_A5) {
             dac_id = 2;
         } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Pin(%q) doesn't have DAC capabilities", pin->name));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Pin(%q) doesn't have DAC capabilities"), pin->name);
         }
     }
 
-    pyb_dac_obj_t *dac = m_new_obj(pyb_dac_obj_t);
-    dac->base.type = &pyb_dac_type;
-
+    uint32_t dac_channel;
     if (dac_id == 1) {
-        dac->pin = pin_A4;
-        dac->dac_channel = DAC_CHANNEL_1;
-        dac->tx_dma_descr = &dma_DAC_1_TX;
+        dac_channel = DAC_CHANNEL_1;
+    #if !defined(STM32L452xx)
     } else if (dac_id == 2) {
-        dac->pin = pin_A5;
-        dac->dac_channel = DAC_CHANNEL_2;
-        dac->tx_dma_descr = &dma_DAC_2_TX;
+        dac_channel = DAC_CHANNEL_2;
+    #endif
     } else {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "DAC(%d) doesn't exist", dac_id));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("DAC(%d) doesn't exist"), dac_id);
     }
 
-    // configure the peripheral
-    mp_map_t kw_args;
-    mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
-    pyb_dac_init_helper(dac, n_args - 1, args + 1, &kw_args);
+    pyb_dac_obj_t *dac = &pyb_dac_obj[dac_id - 1];
+    dac->base.type = &pyb_dac_type;
+    dac->dac_channel = dac_channel;
+
+    if (dac->bits == 0 || n_args > 1 || n_kw > 0) {
+        // configure the peripheral
+        mp_map_t kw_args;
+        mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+        pyb_dac_init_helper(dac, n_args - 1, args + 1, &kw_args);
+    }
 
     // return object
     return MP_OBJ_FROM_PTR(dac);
@@ -284,21 +346,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_dac_init_obj, 1, pyb_dac_init);
 /// Turn off the DAC, enable other use of pin.
 STATIC mp_obj_t pyb_dac_deinit(mp_obj_t self_in) {
     pyb_dac_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    if (self->dac_channel == DAC_CHANNEL_1) {
-        DAC_Handle.Instance->CR &= ~DAC_CR_EN1;
-        #if defined(STM32H7) || defined(STM32L4)
-        DAC->MCR = (DAC->MCR & ~(7 << DAC_MCR_MODE1_Pos)) | 2 << DAC_MCR_MODE1_Pos;
-        #else
-        DAC_Handle.Instance->CR |= DAC_CR_BOFF1;
-        #endif
-    } else {
-        DAC_Handle.Instance->CR &= ~DAC_CR_EN2;
-        #if defined(STM32H7) || defined(STM32L4)
-        DAC->MCR = (DAC->MCR & ~(7 << DAC_MCR_MODE2_Pos)) | 2 << DAC_MCR_MODE2_Pos;
-        #else
-        DAC_Handle.Instance->CR |= DAC_CR_BOFF2;
-        #endif
-    }
+    dac_deinit(self->dac_channel);
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_dac_deinit_obj, pyb_dac_deinit);
@@ -313,19 +361,9 @@ STATIC mp_obj_t pyb_dac_noise(mp_obj_t self_in, mp_obj_t freq) {
     // set TIM6 to trigger the DAC at the given frequency
     TIM6_Config(mp_obj_get_int(freq));
 
-    if (self->state != DAC_STATE_BUILTIN_WAVEFORM) {
-        // configure DAC to trigger via TIM6
-        DAC_ChannelConfTypeDef config;
-        config.DAC_Trigger = DAC_TRIGGER_T6_TRGO;
-        config.DAC_OutputBuffer = self->outbuf_waveform;
-        HAL_DAC_ConfigChannel(&DAC_Handle, &config, self->dac_channel);
-        self->state = DAC_STATE_BUILTIN_WAVEFORM;
-    }
-
-    // set noise wave generation
-    HAL_DACEx_NoiseWaveGenerate(&DAC_Handle, self->dac_channel, DAC_LFSRUNMASK_BITS10_0);
-    HAL_DAC_SetValue(&DAC_Handle, self->dac_channel, DAC_ALIGN_12B_L, 0x7ff0);
-    HAL_DAC_Start(&DAC_Handle, self->dac_channel);
+    // Configure DAC in noise mode with trigger via TIM6
+    uint32_t cr = DAC_LFSRUNMASK_BITS11_0 | DAC_CR_WAVE1_0 | DAC_TRIGGER_T6_TRGO;
+    pyb_dac_reconfigure(self, cr, self->outbuf_waveform, 0);
 
     return mp_const_none;
 }
@@ -335,27 +373,17 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_dac_noise_obj, pyb_dac_noise);
 #if defined(TIM6)
 /// \method triangle(freq)
 /// Generate a triangle wave.  The value on the DAC output changes at
-/// the given frequency, and the frequence of the repeating triangle wave
-/// itself is 256 (or 1024, need to check) times smaller.
+/// the given frequency, and the frequency of the repeating triangle wave
+/// itself is 8192 times smaller.
 STATIC mp_obj_t pyb_dac_triangle(mp_obj_t self_in, mp_obj_t freq) {
     pyb_dac_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
     // set TIM6 to trigger the DAC at the given frequency
     TIM6_Config(mp_obj_get_int(freq));
 
-    if (self->state != DAC_STATE_BUILTIN_WAVEFORM) {
-        // configure DAC to trigger via TIM6
-        DAC_ChannelConfTypeDef config;
-        config.DAC_Trigger = DAC_TRIGGER_T6_TRGO;
-        config.DAC_OutputBuffer = self->outbuf_waveform;
-        HAL_DAC_ConfigChannel(&DAC_Handle, &config, self->dac_channel);
-        self->state = DAC_STATE_BUILTIN_WAVEFORM;
-    }
-
-    // set triangle wave generation
-    HAL_DACEx_TriangleWaveGenerate(&DAC_Handle, self->dac_channel, DAC_TRIANGLEAMPLITUDE_1023);
-    HAL_DAC_SetValue(&DAC_Handle, self->dac_channel, DAC_ALIGN_12B_R, 0x100);
-    HAL_DAC_Start(&DAC_Handle, self->dac_channel);
+    // Configure DAC in full-scale triangle mode with trigger via TIM6
+    uint32_t cr = DAC_TRIANGLEAMPLITUDE_4095 | DAC_CR_WAVE1_1 | DAC_TRIGGER_T6_TRGO;
+    pyb_dac_reconfigure(self, cr, self->outbuf_waveform, 0);
 
     return mp_const_none;
 }
@@ -367,20 +395,11 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_dac_triangle_obj, pyb_dac_triangle);
 STATIC mp_obj_t pyb_dac_write(mp_obj_t self_in, mp_obj_t val) {
     pyb_dac_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
-    if (self->state != DAC_STATE_WRITE_SINGLE) {
-        DAC_ChannelConfTypeDef config;
-        config.DAC_Trigger = DAC_TRIGGER_NONE;
-        config.DAC_OutputBuffer = self->outbuf_single;
-        HAL_DAC_ConfigChannel(&DAC_Handle, &config, self->dac_channel);
-        self->state = DAC_STATE_WRITE_SINGLE;
-    }
-
     // DAC output is always 12-bit at the hardware level, and we provide support
     // for multiple bit "resolutions" simply by shifting the input value.
-    HAL_DAC_SetValue(&DAC_Handle, self->dac_channel, DAC_ALIGN_12B_R,
-        mp_obj_get_int(val) << (12 - self->bits));
-
-    HAL_DAC_Start(&DAC_Handle, self->dac_channel);
+    uint32_t cr = DAC_TRIGGER_NONE;
+    uint32_t value = mp_obj_get_int(val) << (12 - self->bits);
+    pyb_dac_reconfigure(self, cr, self->outbuf_single, value);
 
     return mp_const_none;
 }
@@ -432,83 +451,26 @@ mp_obj_t pyb_dac_write_timed(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
         dac_trigger = TIMx_Config(args[1].u_obj);
     }
 
-    __HAL_RCC_DMA1_CLK_ENABLE();
-
-    DMA_HandleTypeDef DMA_Handle;
-    /* Get currently configured dma */
-    dma_init_handle(&DMA_Handle, self->tx_dma_descr, DMA_MEMORY_TO_PERIPH, (void*)NULL);
-    /*
-    DMA_Cmd(DMA_Handle->Instance, DISABLE);
-    while (DMA_GetCmdStatus(DMA_Handle->Instance) != DISABLE) {
-    }
-
-    DAC_Cmd(self->dac_channel, DISABLE);
-    */
-
-    /*
-    // DAC channel configuration
-    DAC_InitTypeDef DAC_InitStructure;
-    DAC_InitStructure.DAC_Trigger = DAC_Trigger_T7_TRGO;
-    DAC_InitStructure.DAC_WaveGeneration = DAC_WaveGeneration_None;
-    DAC_InitStructure.DAC_LFSRUnmask_TriangleAmplitude = DAC_TriangleAmplitude_1; // unused, but need to set it to a valid value
-    DAC_InitStructure.DAC_OutputBuffer = DAC_OutputBuffer_Enable;
-    DAC_Init(self->dac_channel, &DAC_InitStructure);
-    */
-
-    // Need to deinit DMA first
-    DMA_Handle.State = HAL_DMA_STATE_READY;
-    HAL_DMA_DeInit(&DMA_Handle);
-
-    if (self->bits == 8) {
-        DMA_Handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
-        DMA_Handle.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
-    } else {
-        DMA_Handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
-        DMA_Handle.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
-    }
-    DMA_Handle.Init.Mode = args[2].u_int;
-    HAL_DMA_Init(&DMA_Handle);
+    dac_config_channel(self->dac_channel, DAC_CR_DMAEN1 | dac_trigger, self->outbuf_waveform);
 
+    const dma_descr_t *tx_dma_descr;
     if (self->dac_channel == DAC_CHANNEL_1) {
-        __HAL_LINKDMA(&DAC_Handle, DMA_Handle1, DMA_Handle);
+        tx_dma_descr = &dma_DAC_1_TX;
+    #if !defined(STM32L452xx)
     } else {
-        __HAL_LINKDMA(&DAC_Handle, DMA_Handle2, DMA_Handle);
-    }
-
-    DAC_Handle.Instance = DAC;
-    DAC_Handle.State = HAL_DAC_STATE_RESET;
-    HAL_DAC_Init(&DAC_Handle);
-
-    if (self->state != DAC_STATE_DMA_WAVEFORM + dac_trigger) {
-        DAC_ChannelConfTypeDef config;
-        config.DAC_Trigger = dac_trigger;
-        config.DAC_OutputBuffer = self->outbuf_waveform;
-        HAL_DAC_ConfigChannel(&DAC_Handle, &config, self->dac_channel);
-        self->state = DAC_STATE_DMA_WAVEFORM + dac_trigger;
+        tx_dma_descr = &dma_DAC_2_TX;
+    #endif
     }
 
+    uint32_t align;
     if (self->bits == 8) {
-        HAL_DAC_Start_DMA(&DAC_Handle, self->dac_channel,
-            (uint32_t*)bufinfo.buf, bufinfo.len, DAC_ALIGN_8B_R);
+        align = DAC_ALIGN_8B_R;
     } else {
-        HAL_DAC_Start_DMA(&DAC_Handle, self->dac_channel,
-            (uint32_t*)bufinfo.buf, bufinfo.len / 2, DAC_ALIGN_12B_R);
-    }
-
-    /*
-    // enable DMA stream
-    DMA_Cmd(DMA_Handle->Instance, ENABLE);
-    while (DMA_GetCmdStatus(DMA_Handle->Instance) == DISABLE) {
+        align = DAC_ALIGN_12B_R;
+        bufinfo.len /= 2;
     }
 
-    // enable DAC channel
-    DAC_Cmd(self->dac_channel, ENABLE);
-
-    // enable DMA for DAC channel
-    DAC_DMACmd(self->dac_channel, ENABLE);
-    */
-
-    //printf("DMA: %p %lu\n", bufinfo.buf, bufinfo.len);
+    dac_start_dma(self->dac_channel, tx_dma_descr, args[2].u_int, self->bits, align, bufinfo.len, bufinfo.buf);
 
     return mp_const_none;
 }
@@ -538,7 +500,7 @@ const mp_obj_type_t pyb_dac_type = {
     .name = MP_QSTR_DAC,
     .print = pyb_dac_print,
     .make_new = pyb_dac_make_new,
-    .locals_dict = (mp_obj_dict_t*)&pyb_dac_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_dac_locals_dict,
 };
 
 #endif // MICROPY_HW_ENABLE_DAC
diff --git a/ports/stm32/dac.h b/ports/stm32/dac.h
index 1d8f0ab61e70c..fca36e019ea83 100644
--- a/ports/stm32/dac.h
+++ b/ports/stm32/dac.h
@@ -26,8 +26,6 @@
 #ifndef MICROPY_INCLUDED_STM32_DAC_H
 #define MICROPY_INCLUDED_STM32_DAC_H
 
-void dac_init(void);
-
 extern const mp_obj_type_t pyb_dac_type;
 
 #endif // MICROPY_INCLUDED_STM32_DAC_H
diff --git a/ports/stm32/dma.c b/ports/stm32/dma.c
index 3b8b74081c856..cbcc8542a19a2 100644
--- a/ports/stm32/dma.c
+++ b/ports/stm32/dma.c
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2015 Damien P. George
+ * Copyright (c) 2015-2019 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -29,10 +29,23 @@
 #include <stdint.h>
 
 #include "py/obj.h"
+#include "py/mphal.h"
 #include "systick.h"
 #include "dma.h"
 #include "irq.h"
 
+#if defined(STM32WB)
+
+// DMA is currently not implemented for this MCU
+
+void dma_init(DMA_HandleTypeDef *dma, const dma_descr_t *dma_descr, uint32_t dir, void *data) {
+}
+
+void dma_deinit(const dma_descr_t *dma_descr) {
+}
+
+#else
+
 #define DMA_IDLE_ENABLED()  (dma_idle.enabled != 0)
 #define DMA_SYSTICK_LOG2    (3)
 #define DMA_SYSTICK_MASK    ((1 << DMA_SYSTICK_LOG2) - 1)
@@ -69,7 +82,7 @@ typedef union {
 struct _dma_descr_t {
     #if defined(STM32F4) || defined(STM32F7) || defined(STM32H7)
     DMA_Stream_TypeDef *instance;
-    #elif defined(STM32F0) || defined(STM32L4)
+    #elif defined(STM32F0) || defined(STM32L0) || defined(STM32L4)
     DMA_Channel_TypeDef *instance;
     #else
     #error "Unsupported Processor"
@@ -83,22 +96,22 @@ struct _dma_descr_t {
 // vary depending on the peripheral instance so they get passed separately
 static const DMA_InitTypeDef dma_init_struct_spi_i2c = {
     #if defined(STM32F4) || defined(STM32F7)
-    .Channel             = 0,
-    #elif defined(STM32L4)
-    .Request             = 0,
+    .Channel = 0,
+    #elif defined(STM32H7) || defined(STM32L0) || defined(STM32L4)
+    .Request = 0,
     #endif
-    .Direction           = 0,
-    .PeriphInc           = DMA_PINC_DISABLE,
-    .MemInc              = DMA_MINC_ENABLE,
+    .Direction = 0,
+    .PeriphInc = DMA_PINC_DISABLE,
+    .MemInc = DMA_MINC_ENABLE,
     .PeriphDataAlignment = DMA_PDATAALIGN_BYTE,
-    .MemDataAlignment    = DMA_MDATAALIGN_BYTE,
-    .Mode                = DMA_NORMAL,
-    .Priority            = DMA_PRIORITY_LOW,
-    #if defined(STM32F4) || defined(STM32F7)
-    .FIFOMode            = DMA_FIFOMODE_DISABLE,
-    .FIFOThreshold       = DMA_FIFO_THRESHOLD_FULL,
-    .MemBurst            = DMA_MBURST_INC4,
-    .PeriphBurst         = DMA_PBURST_INC4
+    .MemDataAlignment = DMA_MDATAALIGN_BYTE,
+    .Mode = DMA_NORMAL,
+    .Priority = DMA_PRIORITY_LOW,
+    #if defined(STM32F4) || defined(STM32F7) || defined(STM32H7)
+    .FIFOMode = DMA_FIFOMODE_DISABLE,
+    .FIFOThreshold = DMA_FIFO_THRESHOLD_FULL,
+    .MemBurst = DMA_MBURST_INC4,
+    .PeriphBurst = DMA_PBURST_INC4
     #endif
 };
 
@@ -106,26 +119,26 @@ static const DMA_InitTypeDef dma_init_struct_spi_i2c = {
 // Parameters to dma_init() for SDIO tx and rx.
 static const DMA_InitTypeDef dma_init_struct_sdio = {
     #if defined(STM32F4) || defined(STM32F7)
-    .Channel             = 0,
-    #elif defined(STM32L4)
-    .Request             = 0,
+    .Channel = 0,
+    #elif defined(STM32L0) || defined(STM32L4)
+    .Request = 0,
     #endif
-    .Direction           = 0,
-    .PeriphInc           = DMA_PINC_DISABLE,
-    .MemInc              = DMA_MINC_ENABLE,
+    .Direction = 0,
+    .PeriphInc = DMA_PINC_DISABLE,
+    .MemInc = DMA_MINC_ENABLE,
     .PeriphDataAlignment = DMA_PDATAALIGN_WORD,
-    .MemDataAlignment    = DMA_MDATAALIGN_WORD,
+    .MemDataAlignment = DMA_MDATAALIGN_WORD,
     #if defined(STM32F4) || defined(STM32F7)
-    .Mode                = DMA_PFCTRL,
-    #elif defined(STM32L4)
-    .Mode                = DMA_NORMAL,
+    .Mode = DMA_PFCTRL,
+    #elif defined(STM32L0) || defined(STM32L4)
+    .Mode = DMA_NORMAL,
     #endif
-    .Priority            = DMA_PRIORITY_VERY_HIGH,
+    .Priority = DMA_PRIORITY_VERY_HIGH,
     #if defined(STM32F4) || defined(STM32F7)
-    .FIFOMode            = DMA_FIFOMODE_ENABLE,
-    .FIFOThreshold       = DMA_FIFO_THRESHOLD_FULL,
-    .MemBurst            = DMA_MBURST_INC4,
-    .PeriphBurst         = DMA_PBURST_INC4,
+    .FIFOMode = DMA_FIFOMODE_ENABLE,
+    .FIFOThreshold = DMA_FIFO_THRESHOLD_FULL,
+    .MemBurst = DMA_MBURST_INC4,
+    .PeriphBurst = DMA_PBURST_INC4,
     #endif
 };
 #endif
@@ -134,22 +147,22 @@ static const DMA_InitTypeDef dma_init_struct_sdio = {
 // Default parameters to dma_init() for DAC tx
 static const DMA_InitTypeDef dma_init_struct_dac = {
     #if defined(STM32F4) || defined(STM32F7)
-    .Channel             = 0,
-    #elif defined(STM32L4)
-    .Request             = 0,
+    .Channel = 0,
+    #elif defined(STM32H7) || defined(STM32L0) || defined(STM32L4)
+    .Request = 0,
     #endif
-    .Direction           = 0,
-    .PeriphInc           = DMA_PINC_DISABLE,
-    .MemInc              = DMA_MINC_ENABLE,
+    .Direction = 0,
+    .PeriphInc = DMA_PINC_DISABLE,
+    .MemInc = DMA_MINC_ENABLE,
     .PeriphDataAlignment = DMA_PDATAALIGN_BYTE,
-    .MemDataAlignment    = DMA_MDATAALIGN_BYTE,
-    .Mode                = DMA_NORMAL,
-    .Priority            = DMA_PRIORITY_HIGH,
-    #if defined(STM32F4) || defined(STM32F7)
-    .FIFOMode            = DMA_FIFOMODE_DISABLE,
-    .FIFOThreshold       = DMA_FIFO_THRESHOLD_HALFFULL,
-    .MemBurst            = DMA_MBURST_SINGLE,
-    .PeriphBurst         = DMA_PBURST_SINGLE,
+    .MemDataAlignment = DMA_MDATAALIGN_BYTE,
+    .Mode = DMA_NORMAL,
+    .Priority = DMA_PRIORITY_HIGH,
+    #if defined(STM32F4) || defined(STM32F7) || defined(STM32H7)
+    .FIFOMode = DMA_FIFOMODE_DISABLE,
+    .FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL,
+    .MemBurst = DMA_MBURST_SINGLE,
+    .PeriphBurst = DMA_PBURST_SINGLE,
     #endif
 };
 #endif
@@ -157,21 +170,21 @@ static const DMA_InitTypeDef dma_init_struct_dac = {
 #if MICROPY_HW_ENABLE_DCMI
 static const DMA_InitTypeDef dma_init_struct_dcmi = {
     #if defined(STM32H7)
-    .Request             = DMA_REQUEST_DCMI,
+    .Request = DMA_REQUEST_DCMI,
     #else
-    .Channel             = DMA_CHANNEL_1,
+    .Channel = DMA_CHANNEL_1,
     #endif
-    .Direction           = DMA_PERIPH_TO_MEMORY,
-    .PeriphInc           = DMA_PINC_DISABLE,
-    .MemInc              = DMA_MINC_ENABLE,
+    .Direction = DMA_PERIPH_TO_MEMORY,
+    .PeriphInc = DMA_PINC_DISABLE,
+    .MemInc = DMA_MINC_ENABLE,
     .PeriphDataAlignment = DMA_PDATAALIGN_WORD,
-    .MemDataAlignment    = DMA_MDATAALIGN_WORD,
-    .Mode                = DMA_NORMAL,
-    .Priority            = DMA_PRIORITY_HIGH,
-    .FIFOMode            = DMA_FIFOMODE_ENABLE,
-    .FIFOThreshold       = DMA_FIFO_THRESHOLD_FULL,
-    .MemBurst            = DMA_MBURST_INC4,
-    .PeriphBurst         = DMA_PBURST_SINGLE
+    .MemDataAlignment = DMA_MDATAALIGN_WORD,
+    .Mode = DMA_NORMAL,
+    .Priority = DMA_PRIORITY_HIGH,
+    .FIFOMode = DMA_FIFOMODE_ENABLE,
+    .FIFOThreshold = DMA_FIFO_THRESHOLD_FULL,
+    .MemBurst = DMA_MBURST_INC4,
+    .PeriphBurst = DMA_PBURST_SINGLE
 };
 #endif
 
@@ -274,13 +287,13 @@ const dma_descr_t dma_SPI_5_TX = { DMA2_Stream4, DMA_CHANNEL_2, dma_id_12,  &dma
 const dma_descr_t dma_SPI_4_TX = { DMA2_Stream4, DMA_CHANNEL_5, dma_id_12,  &dma_init_struct_spi_i2c };
 const dma_descr_t dma_SPI_6_TX = { DMA2_Stream5, DMA_CHANNEL_1, dma_id_13,  &dma_init_struct_spi_i2c };
 const dma_descr_t dma_SPI_1_TX = { DMA2_Stream5, DMA_CHANNEL_3, dma_id_13,  &dma_init_struct_spi_i2c };
-//#if defined(STM32F7) && defined(SDMMC2) && ENABLE_SDIO
-//const dma_descr_t dma_SDMMC_2 = { DMA2_Stream5, DMA_CHANNEL_11, dma_id_13,  &dma_init_struct_sdio };
-//#endif
+// #if defined(STM32F7) && defined(SDMMC2) && ENABLE_SDIO
+// const dma_descr_t dma_SDMMC_2 = { DMA2_Stream5, DMA_CHANNEL_11, dma_id_13,  &dma_init_struct_sdio };
+// #endif
 const dma_descr_t dma_SPI_6_RX = { DMA2_Stream6, DMA_CHANNEL_1, dma_id_14,  &dma_init_struct_spi_i2c };
-//#if ENABLE_SDIO
-//const dma_descr_t dma_SDIO_0 = { DMA2_Stream6, DMA_CHANNEL_4, dma_id_14,  &dma_init_struct_sdio };
-//#endif
+// #if ENABLE_SDIO
+// const dma_descr_t dma_SDIO_0 = { DMA2_Stream6, DMA_CHANNEL_4, dma_id_14,  &dma_init_struct_sdio };
+// #endif
 /* not preferred streams
 const dma_descr_t dma_SPI_1_TX = { DMA2_Stream3, DMA_CHANNEL_3, dma_id_11,  &dma_init_struct_spi_i2c };
 const dma_descr_t dma_SPI_1_RX = { DMA2_Stream0, DMA_CHANNEL_3, dma_id_8,   &dma_init_struct_spi_i2c };
@@ -309,6 +322,47 @@ static const uint8_t dma_irqn[NSTREAM] = {
     DMA2_Stream7_IRQn,
 };
 
+#elif defined(STM32L0)
+
+#define NCONTROLLERS            (1)
+#define NSTREAMS_PER_CONTROLLER (7)
+#define NSTREAM                 (NCONTROLLERS * NSTREAMS_PER_CONTROLLER)
+
+#define DMA_SUB_INSTANCE_AS_UINT8(dma_request) (dma_request)
+
+#define DMA1_ENABLE_MASK (0x007f) // Bits in dma_enable_mask corresponding to DMA1
+
+// These descriptors are ordered by DMAx_Channel number, and within a channel by request
+// number. The duplicate streams are ok as long as they aren't used at the same time.
+
+// DMA1 streams
+const dma_descr_t dma_SPI_1_RX = { DMA1_Channel2, DMA_REQUEST_1,  dma_id_1,   &dma_init_struct_spi_i2c };
+const dma_descr_t dma_I2C_3_TX = { DMA1_Channel2, DMA_REQUEST_14, dma_id_1,   &dma_init_struct_spi_i2c };
+#if MICROPY_HW_ENABLE_DAC
+const dma_descr_t dma_DAC_1_TX = { DMA1_Channel2, DMA_REQUEST_9,  dma_id_1,   &dma_init_struct_dac };
+#endif
+const dma_descr_t dma_SPI_1_TX = { DMA1_Channel3, DMA_REQUEST_1,  dma_id_2,   &dma_init_struct_spi_i2c };
+const dma_descr_t dma_I2C_3_RX = { DMA1_Channel3, DMA_REQUEST_14, dma_id_2,   &dma_init_struct_spi_i2c };
+const dma_descr_t dma_SPI_2_RX = { DMA1_Channel4, DMA_REQUEST_2,  dma_id_3,   &dma_init_struct_spi_i2c };
+const dma_descr_t dma_I2C_2_TX = { DMA1_Channel4, DMA_REQUEST_7,  dma_id_3,   &dma_init_struct_spi_i2c };
+#if MICROPY_HW_ENABLE_DAC
+const dma_descr_t dma_DAC_2_TX = { DMA1_Channel4, DMA_REQUEST_15, dma_id_3,   &dma_init_struct_dac };
+#endif
+const dma_descr_t dma_SPI_2_TX = { DMA1_Channel5, DMA_REQUEST_2,  dma_id_4,   &dma_init_struct_spi_i2c };
+const dma_descr_t dma_I2C_2_RX = { DMA1_Channel5, DMA_REQUEST_7,  dma_id_4,   &dma_init_struct_spi_i2c };
+const dma_descr_t dma_I2C_1_TX = { DMA1_Channel6, DMA_REQUEST_6,  dma_id_5,   &dma_init_struct_spi_i2c };
+const dma_descr_t dma_I2C_1_RX = { DMA1_Channel7, DMA_REQUEST_6,  dma_id_6,   &dma_init_struct_spi_i2c };
+
+static const uint8_t dma_irqn[NSTREAM] = {
+    DMA1_Channel1_IRQn,
+    DMA1_Channel2_3_IRQn,
+    DMA1_Channel2_3_IRQn,
+    DMA1_Channel4_5_6_7_IRQn,
+    DMA1_Channel4_5_6_7_IRQn,
+    DMA1_Channel4_5_6_7_IRQn,
+    DMA1_Channel4_5_6_7_IRQn,
+};
+
 #elif defined(STM32L4)
 
 #define NCONTROLLERS            (2)
@@ -324,11 +378,11 @@ static const uint8_t dma_irqn[NSTREAM] = {
 // number. The duplicate streams are ok as long as they aren't used at the same time.
 
 // DMA1 streams
-//const dma_descr_t dma_ADC_1_RX = { DMA1_Channel1, DMA_REQUEST_0, dma_id_0,   NULL }; // unused
-//const dma_descr_t dma_ADC_2_RX = { DMA1_Channel2, DMA_REQUEST_0, dma_id_1,   NULL }; // unused
+// const dma_descr_t dma_ADC_1_RX = { DMA1_Channel1, DMA_REQUEST_0, dma_id_0,   NULL }; // unused
+// const dma_descr_t dma_ADC_2_RX = { DMA1_Channel2, DMA_REQUEST_0, dma_id_1,   NULL }; // unused
 const dma_descr_t dma_SPI_1_RX = { DMA1_Channel2, DMA_REQUEST_1, dma_id_1,   &dma_init_struct_spi_i2c };
 const dma_descr_t dma_I2C_3_TX = { DMA1_Channel2, DMA_REQUEST_3, dma_id_1,   &dma_init_struct_spi_i2c };
-//const dma_descr_t dma_ADC_3_RX = { DMA1_Channel3, DMA_REQUEST_0, dma_id_2,   NULL }; // unused
+// const dma_descr_t dma_ADC_3_RX = { DMA1_Channel3, DMA_REQUEST_0, dma_id_2,   NULL }; // unused
 const dma_descr_t dma_SPI_1_TX = { DMA1_Channel3, DMA_REQUEST_1, dma_id_2,   &dma_init_struct_spi_i2c };
 const dma_descr_t dma_I2C_3_RX = { DMA1_Channel3, DMA_REQUEST_3, dma_id_2,   &dma_init_struct_spi_i2c };
 #if MICROPY_HW_ENABLE_DAC
@@ -345,7 +399,9 @@ const dma_descr_t dma_I2C_1_TX = { DMA1_Channel6, DMA_REQUEST_3, dma_id_5,   &dm
 const dma_descr_t dma_I2C_1_RX = { DMA1_Channel7, DMA_REQUEST_3, dma_id_6,   &dma_init_struct_spi_i2c };
 
 // DMA2 streams
+const dma_descr_t dma_I2C_4_RX = { DMA2_Channel1, DMA_REQUEST_0, dma_id_0,   &dma_init_struct_spi_i2c };
 const dma_descr_t dma_SPI_3_RX = { DMA2_Channel1, DMA_REQUEST_3, dma_id_7,   &dma_init_struct_spi_i2c };
+const dma_descr_t dma_I2C_4_TX = { DMA2_Channel2, DMA_REQUEST_0, dma_id_1,   &dma_init_struct_spi_i2c };
 const dma_descr_t dma_SPI_3_TX = { DMA2_Channel2, DMA_REQUEST_3, dma_id_8,   &dma_init_struct_spi_i2c };
 /* not preferred streams
 const dma_descr_t dma_ADC_1_RX = { DMA2_Channel3, DMA_REQUEST_0, dma_id_9,   NULL };
@@ -458,9 +514,11 @@ volatile dma_idle_count_t dma_idle;
 
 #define DMA_INVALID_CHANNEL 0xff    // Value stored in dma_last_channel which means invalid
 
-#if defined(STM32F0)
+#if defined(STM32F0) || defined(STM32L0)
 #define DMA1_IS_CLK_ENABLED()   ((RCC->AHBENR & RCC_AHBENR_DMA1EN) != 0)
+#if defined(DMA2)
 #define DMA2_IS_CLK_ENABLED()   ((RCC->AHBENR & RCC_AHBENR_DMA2EN) != 0)
+#endif
 #else
 #define DMA1_IS_CLK_ENABLED()   ((RCC->AHB1ENR & RCC_AHB1ENR_DMA1EN) != 0)
 #define DMA2_IS_CLK_ENABLED()   ((RCC->AHB1ENR & RCC_AHB1ENR_DMA2EN) != 0)
@@ -508,39 +566,257 @@ void DMA1_Ch4_7_DMA2_Ch3_5_IRQHandler(void) {
 
 #elif defined(STM32F4) || defined(STM32F7) || defined(STM32H7)
 
-void DMA1_Stream0_IRQHandler(void) { IRQ_ENTER(DMA1_Stream0_IRQn); if (dma_handle[dma_id_0] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_0]); } IRQ_EXIT(DMA1_Stream0_IRQn); }
-void DMA1_Stream1_IRQHandler(void) { IRQ_ENTER(DMA1_Stream1_IRQn); if (dma_handle[dma_id_1] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_1]); } IRQ_EXIT(DMA1_Stream1_IRQn); }
-void DMA1_Stream2_IRQHandler(void) { IRQ_ENTER(DMA1_Stream2_IRQn); if (dma_handle[dma_id_2] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_2]); } IRQ_EXIT(DMA1_Stream2_IRQn); }
-void DMA1_Stream3_IRQHandler(void) { IRQ_ENTER(DMA1_Stream3_IRQn); if (dma_handle[dma_id_3] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_3]); } IRQ_EXIT(DMA1_Stream3_IRQn); }
-void DMA1_Stream4_IRQHandler(void) { IRQ_ENTER(DMA1_Stream4_IRQn); if (dma_handle[dma_id_4] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_4]); } IRQ_EXIT(DMA1_Stream4_IRQn); }
-void DMA1_Stream5_IRQHandler(void) { IRQ_ENTER(DMA1_Stream5_IRQn); if (dma_handle[dma_id_5] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_5]); } IRQ_EXIT(DMA1_Stream5_IRQn); }
-void DMA1_Stream6_IRQHandler(void) { IRQ_ENTER(DMA1_Stream6_IRQn); if (dma_handle[dma_id_6] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_6]); } IRQ_EXIT(DMA1_Stream6_IRQn); }
-void DMA1_Stream7_IRQHandler(void) { IRQ_ENTER(DMA1_Stream7_IRQn); if (dma_handle[dma_id_7] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_7]); } IRQ_EXIT(DMA1_Stream7_IRQn); }
-void DMA2_Stream0_IRQHandler(void) { IRQ_ENTER(DMA2_Stream0_IRQn); if (dma_handle[dma_id_8] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_8]); } IRQ_EXIT(DMA2_Stream0_IRQn); }
-void DMA2_Stream1_IRQHandler(void) { IRQ_ENTER(DMA2_Stream1_IRQn); if (dma_handle[dma_id_9] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_9]); } IRQ_EXIT(DMA2_Stream1_IRQn); }
-void DMA2_Stream2_IRQHandler(void) { IRQ_ENTER(DMA2_Stream2_IRQn); if (dma_handle[dma_id_10] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_10]); } IRQ_EXIT(DMA2_Stream2_IRQn); }
-void DMA2_Stream3_IRQHandler(void) { IRQ_ENTER(DMA2_Stream3_IRQn); if (dma_handle[dma_id_11] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_11]); } IRQ_EXIT(DMA2_Stream3_IRQn); }
-void DMA2_Stream4_IRQHandler(void) { IRQ_ENTER(DMA2_Stream4_IRQn); if (dma_handle[dma_id_12] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_12]); } IRQ_EXIT(DMA2_Stream4_IRQn); }
-void DMA2_Stream5_IRQHandler(void) { IRQ_ENTER(DMA2_Stream5_IRQn); if (dma_handle[dma_id_13] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_13]); } IRQ_EXIT(DMA2_Stream5_IRQn); }
-void DMA2_Stream6_IRQHandler(void) { IRQ_ENTER(DMA2_Stream6_IRQn); if (dma_handle[dma_id_14] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_14]); } IRQ_EXIT(DMA2_Stream6_IRQn); }
-void DMA2_Stream7_IRQHandler(void) { IRQ_ENTER(DMA2_Stream7_IRQn); if (dma_handle[dma_id_15] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_15]); } IRQ_EXIT(DMA2_Stream7_IRQn); }
+void DMA1_Stream0_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Stream0_IRQn);
+    if (dma_handle[dma_id_0] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_0]);
+    }
+    IRQ_EXIT(DMA1_Stream0_IRQn);
+}
+void DMA1_Stream1_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Stream1_IRQn);
+    if (dma_handle[dma_id_1] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_1]);
+    }
+    IRQ_EXIT(DMA1_Stream1_IRQn);
+}
+void DMA1_Stream2_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Stream2_IRQn);
+    if (dma_handle[dma_id_2] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_2]);
+    }
+    IRQ_EXIT(DMA1_Stream2_IRQn);
+}
+void DMA1_Stream3_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Stream3_IRQn);
+    if (dma_handle[dma_id_3] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_3]);
+    }
+    IRQ_EXIT(DMA1_Stream3_IRQn);
+}
+void DMA1_Stream4_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Stream4_IRQn);
+    if (dma_handle[dma_id_4] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_4]);
+    }
+    IRQ_EXIT(DMA1_Stream4_IRQn);
+}
+void DMA1_Stream5_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Stream5_IRQn);
+    if (dma_handle[dma_id_5] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_5]);
+    }
+    IRQ_EXIT(DMA1_Stream5_IRQn);
+}
+void DMA1_Stream6_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Stream6_IRQn);
+    if (dma_handle[dma_id_6] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_6]);
+    }
+    IRQ_EXIT(DMA1_Stream6_IRQn);
+}
+void DMA1_Stream7_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Stream7_IRQn);
+    if (dma_handle[dma_id_7] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_7]);
+    }
+    IRQ_EXIT(DMA1_Stream7_IRQn);
+}
+void DMA2_Stream0_IRQHandler(void) {
+    IRQ_ENTER(DMA2_Stream0_IRQn);
+    if (dma_handle[dma_id_8] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_8]);
+    }
+    IRQ_EXIT(DMA2_Stream0_IRQn);
+}
+void DMA2_Stream1_IRQHandler(void) {
+    IRQ_ENTER(DMA2_Stream1_IRQn);
+    if (dma_handle[dma_id_9] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_9]);
+    }
+    IRQ_EXIT(DMA2_Stream1_IRQn);
+}
+void DMA2_Stream2_IRQHandler(void) {
+    IRQ_ENTER(DMA2_Stream2_IRQn);
+    if (dma_handle[dma_id_10] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_10]);
+    }
+    IRQ_EXIT(DMA2_Stream2_IRQn);
+}
+void DMA2_Stream3_IRQHandler(void) {
+    IRQ_ENTER(DMA2_Stream3_IRQn);
+    if (dma_handle[dma_id_11] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_11]);
+    }
+    IRQ_EXIT(DMA2_Stream3_IRQn);
+}
+void DMA2_Stream4_IRQHandler(void) {
+    IRQ_ENTER(DMA2_Stream4_IRQn);
+    if (dma_handle[dma_id_12] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_12]);
+    }
+    IRQ_EXIT(DMA2_Stream4_IRQn);
+}
+void DMA2_Stream5_IRQHandler(void) {
+    IRQ_ENTER(DMA2_Stream5_IRQn);
+    if (dma_handle[dma_id_13] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_13]);
+    }
+    IRQ_EXIT(DMA2_Stream5_IRQn);
+}
+void DMA2_Stream6_IRQHandler(void) {
+    IRQ_ENTER(DMA2_Stream6_IRQn);
+    if (dma_handle[dma_id_14] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_14]);
+    }
+    IRQ_EXIT(DMA2_Stream6_IRQn);
+}
+void DMA2_Stream7_IRQHandler(void) {
+    IRQ_ENTER(DMA2_Stream7_IRQn);
+    if (dma_handle[dma_id_15] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_15]);
+    }
+    IRQ_EXIT(DMA2_Stream7_IRQn);
+}
+
+#elif defined(STM32L0)
+
+void DMA1_Channel1_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Channel1_IRQn);
+    if (dma_handle[dma_id_0] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_0]);
+    }
+    IRQ_EXIT(DMA1_Channel1_IRQn);
+}
+
+void DMA1_Channel2_3_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Channel2_3_IRQn);
+    if (dma_handle[dma_id_1] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_1]);
+    }
+    if (dma_handle[dma_id_2] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_2]);
+    }
+    IRQ_EXIT(DMA1_Channel2_3_IRQn);
+}
+
+void DMA1_Channel4_5_6_7_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Channel4_5_6_7_IRQn);
+    if (dma_handle[dma_id_3] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_3]);
+    }
+    if (dma_handle[dma_id_4] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_4]);
+    }
+    if (dma_handle[dma_id_5] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_5]);
+    }
+    if (dma_handle[dma_id_6] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_6]);
+    }
+    IRQ_EXIT(DMA1_Channel4_5_6_7_IRQn);
+}
 
 #elif defined(STM32L4)
 
-void DMA1_Channel1_IRQHandler(void) { IRQ_ENTER(DMA1_Channel1_IRQn); if (dma_handle[dma_id_0] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_0]); } IRQ_EXIT(DMA1_Channel1_IRQn); }
-void DMA1_Channel2_IRQHandler(void) { IRQ_ENTER(DMA1_Channel2_IRQn); if (dma_handle[dma_id_1] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_1]); } IRQ_EXIT(DMA1_Channel2_IRQn); }
-void DMA1_Channel3_IRQHandler(void) { IRQ_ENTER(DMA1_Channel3_IRQn); if (dma_handle[dma_id_2] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_2]); } IRQ_EXIT(DMA1_Channel3_IRQn); }
-void DMA1_Channel4_IRQHandler(void) { IRQ_ENTER(DMA1_Channel4_IRQn); if (dma_handle[dma_id_3] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_3]); } IRQ_EXIT(DMA1_Channel4_IRQn); }
-void DMA1_Channel5_IRQHandler(void) { IRQ_ENTER(DMA1_Channel5_IRQn); if (dma_handle[dma_id_4] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_4]); } IRQ_EXIT(DMA1_Channel5_IRQn); }
-void DMA1_Channel6_IRQHandler(void) { IRQ_ENTER(DMA1_Channel6_IRQn); if (dma_handle[dma_id_5] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_5]); } IRQ_EXIT(DMA1_Channel6_IRQn); }
-void DMA1_Channel7_IRQHandler(void) { IRQ_ENTER(DMA1_Channel7_IRQn); if (dma_handle[dma_id_6] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_6]); } IRQ_EXIT(DMA1_Channel7_IRQn); }
-void DMA2_Channel1_IRQHandler(void) { IRQ_ENTER(DMA2_Channel1_IRQn); if (dma_handle[dma_id_7] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_7]); } IRQ_EXIT(DMA2_Channel1_IRQn); }
-void DMA2_Channel2_IRQHandler(void) { IRQ_ENTER(DMA2_Channel2_IRQn); if (dma_handle[dma_id_8] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_8]); } IRQ_EXIT(DMA2_Channel2_IRQn); }
-void DMA2_Channel3_IRQHandler(void) { IRQ_ENTER(DMA2_Channel3_IRQn); if (dma_handle[dma_id_9] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_9]); } IRQ_EXIT(DMA2_Channel3_IRQn); }
-void DMA2_Channel4_IRQHandler(void) { IRQ_ENTER(DMA2_Channel4_IRQn); if (dma_handle[dma_id_10] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_10]);} IRQ_EXIT(DMA2_Channel4_IRQn); }
-void DMA2_Channel5_IRQHandler(void) { IRQ_ENTER(DMA2_Channel5_IRQn); if (dma_handle[dma_id_11] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_11]);} IRQ_EXIT(DMA2_Channel5_IRQn); }
-void DMA2_Channel6_IRQHandler(void) { IRQ_ENTER(DMA2_Channel6_IRQn); if (dma_handle[dma_id_12] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_12]);} IRQ_EXIT(DMA2_Channel6_IRQn); }
-void DMA2_Channel7_IRQHandler(void) { IRQ_ENTER(DMA2_Channel7_IRQn); if (dma_handle[dma_id_13] != NULL) { HAL_DMA_IRQHandler(dma_handle[dma_id_13]);} IRQ_EXIT(DMA2_Channel7_IRQn); }
+void DMA1_Channel1_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Channel1_IRQn);
+    if (dma_handle[dma_id_0] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_0]);
+    }
+    IRQ_EXIT(DMA1_Channel1_IRQn);
+}
+void DMA1_Channel2_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Channel2_IRQn);
+    if (dma_handle[dma_id_1] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_1]);
+    }
+    IRQ_EXIT(DMA1_Channel2_IRQn);
+}
+void DMA1_Channel3_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Channel3_IRQn);
+    if (dma_handle[dma_id_2] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_2]);
+    }
+    IRQ_EXIT(DMA1_Channel3_IRQn);
+}
+void DMA1_Channel4_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Channel4_IRQn);
+    if (dma_handle[dma_id_3] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_3]);
+    }
+    IRQ_EXIT(DMA1_Channel4_IRQn);
+}
+void DMA1_Channel5_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Channel5_IRQn);
+    if (dma_handle[dma_id_4] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_4]);
+    }
+    IRQ_EXIT(DMA1_Channel5_IRQn);
+}
+void DMA1_Channel6_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Channel6_IRQn);
+    if (dma_handle[dma_id_5] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_5]);
+    }
+    IRQ_EXIT(DMA1_Channel6_IRQn);
+}
+void DMA1_Channel7_IRQHandler(void) {
+    IRQ_ENTER(DMA1_Channel7_IRQn);
+    if (dma_handle[dma_id_6] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_6]);
+    }
+    IRQ_EXIT(DMA1_Channel7_IRQn);
+}
+void DMA2_Channel1_IRQHandler(void) {
+    IRQ_ENTER(DMA2_Channel1_IRQn);
+    if (dma_handle[dma_id_7] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_7]);
+    }
+    IRQ_EXIT(DMA2_Channel1_IRQn);
+}
+void DMA2_Channel2_IRQHandler(void) {
+    IRQ_ENTER(DMA2_Channel2_IRQn);
+    if (dma_handle[dma_id_8] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_8]);
+    }
+    IRQ_EXIT(DMA2_Channel2_IRQn);
+}
+void DMA2_Channel3_IRQHandler(void) {
+    IRQ_ENTER(DMA2_Channel3_IRQn);
+    if (dma_handle[dma_id_9] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_9]);
+    }
+    IRQ_EXIT(DMA2_Channel3_IRQn);
+}
+void DMA2_Channel4_IRQHandler(void) {
+    IRQ_ENTER(DMA2_Channel4_IRQn);
+    if (dma_handle[dma_id_10] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_10]);
+    }
+    IRQ_EXIT(DMA2_Channel4_IRQn);
+}
+void DMA2_Channel5_IRQHandler(void) {
+    IRQ_ENTER(DMA2_Channel5_IRQn);
+    if (dma_handle[dma_id_11] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_11]);
+    }
+    IRQ_EXIT(DMA2_Channel5_IRQn);
+}
+void DMA2_Channel6_IRQHandler(void) {
+    IRQ_ENTER(DMA2_Channel6_IRQn);
+    if (dma_handle[dma_id_12] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_12]);
+    }
+    IRQ_EXIT(DMA2_Channel6_IRQn);
+}
+void DMA2_Channel7_IRQHandler(void) {
+    IRQ_ENTER(DMA2_Channel7_IRQn);
+    if (dma_handle[dma_id_13] != NULL) {
+        HAL_DMA_IRQHandler(dma_handle[dma_id_13]);
+    }
+    IRQ_EXIT(DMA2_Channel7_IRQn);
+}
 
 #endif
 
@@ -571,18 +847,21 @@ static void dma_enable_clock(dma_id_t dma_id) {
                 dma_last_sub_instance[channel] = DMA_INVALID_CHANNEL;
             }
         }
-    } else {
+    }
+    #if defined(DMA2)
+    else {
         if (((old_enable_mask & DMA2_ENABLE_MASK) == 0) && !DMA2_IS_CLK_ENABLED()) {
             __HAL_RCC_DMA2_CLK_ENABLE();
 
             // We just turned on the clock. This means that anything stored
-            // in dma_last_channel (for DMA1) needs to be invalidated.
+            // in dma_last_channel (for DMA2) needs to be invalidated.
 
             for (int channel = NSTREAMS_PER_CONTROLLER; channel < NSTREAM; channel++) {
                 dma_last_sub_instance[channel] = DMA_INVALID_CHANNEL;
             }
         }
     }
+    #endif
 }
 
 static void dma_disable_clock(dma_id_t dma_id) {
@@ -598,7 +877,7 @@ void dma_init_handle(DMA_HandleTypeDef *dma, const dma_descr_t *dma_descr, uint3
     dma->Instance = dma_descr->instance;
     dma->Init = *dma_descr->init;
     dma->Init.Direction = dir;
-    #if defined(STM32L4) || defined(STM32H7)
+    #if defined(STM32L0) || defined(STM32L4) || defined(STM32H7)
     dma->Init.Request = dma_descr->sub_instance;
     #else
     #if !defined(STM32F0)
@@ -610,14 +889,14 @@ void dma_init_handle(DMA_HandleTypeDef *dma, const dma_descr_t *dma_descr, uint3
     dma->Parent = data;
 }
 
-void dma_init(DMA_HandleTypeDef *dma, const dma_descr_t *dma_descr, uint32_t dir, void *data){
+void dma_init(DMA_HandleTypeDef *dma, const dma_descr_t *dma_descr, uint32_t dir, void *data) {
     // Some drivers allocate the DMA_HandleTypeDef from the stack
     // (i.e. dac, i2c, spi) and for those cases we need to clear the
     // structure so we don't get random values from the stack)
     memset(dma, 0, sizeof(*dma));
 
     if (dma_descr != NULL) {
-        dma_id_t dma_id  = dma_descr->id;
+        dma_id_t dma_id = dma_descr->id;
 
         dma_init_handle(dma, dma_descr, dir, data);
         // set global pointer for IRQ handler
@@ -625,10 +904,10 @@ void dma_init(DMA_HandleTypeDef *dma, const dma_descr_t *dma_descr, uint32_t dir
 
         dma_enable_clock(dma_id);
 
-        #if defined(STM32L4)
-        // Always reset and configure the L4 DMA peripheral
+        #if defined(STM32H7) || defined(STM32L0) || defined(STM32L4)
+        // Always reset and configure the H7 and L0/L4 DMA peripheral
         // (dma->State is set to HAL_DMA_STATE_RESET by memset above)
-        // TODO: understand how L4 DMA works so this is not needed
+        // TODO: understand how L0/L4 DMA works so this is not needed
         HAL_DMA_DeInit(dma);
         HAL_DMA_Init(dma);
         NVIC_SetPriority(IRQn_NONNEG(dma_irqn[dma_id]), IRQ_PRI_DMA);
@@ -690,7 +969,7 @@ void dma_invalidate_channel(const dma_descr_t *dma_descr) {
     if (dma_descr != NULL) {
         dma_id_t dma_id = dma_descr->id;
         // Only compare the sub-instance, not the direction bit (MSB)
-        if ((dma_last_sub_instance[dma_id] & 0x7f) == DMA_SUB_INSTANCE_AS_UINT8(dma_descr->sub_instance) ) {
+        if ((dma_last_sub_instance[dma_id] & 0x7f) == DMA_SUB_INSTANCE_AS_UINT8(dma_descr->sub_instance)) {
             dma_last_sub_instance[dma_id] = DMA_INVALID_CHANNEL;
         }
     }
@@ -703,8 +982,11 @@ static void dma_idle_handler(uint32_t tick) {
         return;
     }
 
-    static const uint32_t   controller_mask[] = {
-        DMA1_ENABLE_MASK, DMA2_ENABLE_MASK
+    static const uint32_t controller_mask[] = {
+        DMA1_ENABLE_MASK,
+        #if defined(DMA2)
+        DMA2_ENABLE_MASK,
+        #endif
     };
     {
         int controller = (tick >> DMA_SYSTICK_LOG2) & 1;
@@ -718,9 +1000,12 @@ static void dma_idle_handler(uint32_t tick) {
                 dma_idle.counter[controller] = 0;
                 if (controller == 0) {
                     __HAL_RCC_DMA1_CLK_DISABLE();
-                } else {
+                }
+                #if defined(DMA2)
+                else {
                     __HAL_RCC_DMA2_CLK_DISABLE();
                 }
+                #endif
             } else {
                 // Something is still active, but the counter never got
                 // reset, so we'll reset the counter here.
@@ -729,3 +1014,126 @@ static void dma_idle_handler(uint32_t tick) {
         }
     }
 }
+
+#if defined(STM32F0) || defined(STM32L0) || defined(STM32L4)
+
+void dma_nohal_init(const dma_descr_t *descr, uint32_t config) {
+    DMA_Channel_TypeDef *dma = descr->instance;
+
+    // Enable the DMA peripheral
+    dma_enable_clock(descr->id);
+
+    // Set main configuration register
+    dma->CCR =
+        descr->init->Priority       // PL
+        | descr->init->MemInc       // MINC
+        | descr->init->PeriphInc    // PINC
+        | config                    // MSIZE | PSIZE | CIRC | DIR
+    ;
+
+    // Select channel that the DMA stream uses
+    #if defined(STM32F0)
+    if (dma < DMA2_Channel1) {
+        __HAL_DMA1_REMAP(descr->sub_instance);
+    } else {
+        __HAL_DMA2_REMAP(descr->sub_instance);
+    }
+    #else
+    DMA_Request_TypeDef *dma_ctrl = (void *)(((uint32_t)dma & ~0xff) + (DMA1_CSELR_BASE - DMA1_BASE)); // DMA1_CSELR or DMA2_CSELR
+    uint32_t channel_number = (((uint32_t)dma & 0xff) - 0x08) / 20; // 0 through 6
+    uint32_t channel_pos = channel_number * 4;
+    dma_ctrl->CSELR = (dma_ctrl->CSELR & ~(0xf << channel_pos)) | (descr->sub_instance << channel_pos);
+    #endif
+}
+
+void dma_nohal_deinit(const dma_descr_t *descr) {
+    DMA_Channel_TypeDef *dma = descr->instance;
+    dma->CCR &= ~DMA_CCR_EN;
+    dma->CCR = 0;
+    dma->CNDTR = 0;
+    dma_deinit(descr);
+}
+
+void dma_nohal_start(const dma_descr_t *descr, uint32_t src_addr, uint32_t dst_addr, uint16_t len) {
+    DMA_Channel_TypeDef *dma = descr->instance;
+    dma->CNDTR = len;
+    dma->CPAR = dst_addr;
+    dma->CMAR = src_addr;
+    dma->CCR |= DMA_CCR_EN;
+}
+
+#else
+
+void dma_nohal_init(const dma_descr_t *descr, uint32_t config) {
+    DMA_Stream_TypeDef *dma = descr->instance;
+
+    // Enable the DMA peripheral
+    dma_enable_clock(descr->id);
+
+    // Set main configuration register
+    const DMA_InitTypeDef *init = descr->init;
+    dma->CR =
+        descr->sub_instance         // CHSEL
+        | init->MemBurst            // MBURST
+        | init->PeriphBurst         // PBURST
+        | init->Priority            // PL
+        | init->MemInc              // MINC
+        | init->PeriphInc           // PINC
+        | config                    // MSIZE | PSIZE | CIRC | DIR
+    ;
+
+    // Set FIFO control register
+    dma->FCR =
+        init->FIFOMode              // DMDIS
+        | init->FIFOThreshold       // FTH
+    ;
+}
+
+void dma_nohal_deinit(const dma_descr_t *descr) {
+    DMA_Stream_TypeDef *dma = descr->instance;
+    dma->CR &= ~DMA_SxCR_EN;
+    uint32_t t0 = mp_hal_ticks_ms();
+    while ((dma->CR & DMA_SxCR_EN) && mp_hal_ticks_ms() - t0 < 100) {
+    }
+    dma->CR = 0;
+    dma->NDTR = 0;
+    dma->FCR = 0x21;
+    dma_deinit(descr);
+}
+
+void dma_nohal_start(const dma_descr_t *descr, uint32_t src_addr, uint32_t dst_addr, uint16_t len) {
+    // Must clear all event flags for this stream before enabling it
+    DMA_TypeDef *dma_ctrl;
+    uint32_t ch = descr->id;
+    if (ch < NSTREAMS_PER_CONTROLLER) {
+        dma_ctrl = DMA1;
+    } else {
+        dma_ctrl = DMA2;
+        ch -= NSTREAMS_PER_CONTROLLER;
+    }
+    __IO uint32_t *ifcr;
+    if (ch <= 3) {
+        ifcr = &dma_ctrl->LIFCR;
+    } else {
+        ifcr = &dma_ctrl->HIFCR;
+        ch -= 4;
+    }
+    if (ch <= 1) {
+        ch = ch * 6;
+    } else {
+        ch = 4 + ch * 6;
+    }
+    *ifcr = 0x3d << ch;
+
+    // Configure and enable stream
+    DMA_Stream_TypeDef *dma = descr->instance;
+    dma->CR &= ~DMA_SxCR_DBM;
+    dma->NDTR = len;
+    dma->PAR = dst_addr;
+    dma->M0AR = src_addr;
+    dma->CR |= DMA_SxCR_EN;
+}
+
+#endif
+
+#endif // defined(STM32WB)
diff --git a/ports/stm32/dma.h b/ports/stm32/dma.h
index 73cb9c32826a2..5a17276a49de2 100644
--- a/ports/stm32/dma.h
+++ b/ports/stm32/dma.h
@@ -58,7 +58,22 @@ extern const dma_descr_t dma_SPI_6_RX;
 extern const dma_descr_t dma_SDIO_0;
 extern const dma_descr_t dma_DCMI_0;
 
-#elif defined(STM32L4)
+#elif defined(STM32L0)
+
+extern const dma_descr_t dma_SPI_1_RX;
+extern const dma_descr_t dma_I2C_3_TX;
+extern const dma_descr_t dma_SPI_1_TX;
+extern const dma_descr_t dma_I2C_3_RX;
+extern const dma_descr_t dma_DAC_1_TX;
+extern const dma_descr_t dma_SPI_2_RX;
+extern const dma_descr_t dma_I2C_2_TX;
+extern const dma_descr_t dma_DAC_2_TX;
+extern const dma_descr_t dma_SPI_2_TX;
+extern const dma_descr_t dma_I2C_2_RX;
+extern const dma_descr_t dma_I2C_1_TX;
+extern const dma_descr_t dma_I2C_1_RX;
+
+#elif defined(STM32L4) || defined(STM32WB)
 
 extern const dma_descr_t dma_ADC_1_RX;
 extern const dma_descr_t dma_ADC_2_RX;
@@ -78,6 +93,8 @@ extern const dma_descr_t dma_I2C_1_RX;
 extern const dma_descr_t dma_SPI_3_RX;
 extern const dma_descr_t dma_SPI_3_TX;
 extern const dma_descr_t dma_SDIO_0;
+extern const dma_descr_t dma_I2C_4_TX;
+extern const dma_descr_t dma_I2C_4_RX;
 
 #endif
 
@@ -86,4 +103,8 @@ void dma_init_handle(DMA_HandleTypeDef *dma, const dma_descr_t *dma_descr, uint3
 void dma_deinit(const dma_descr_t *dma_descr);
 void dma_invalidate_channel(const dma_descr_t *dma_descr);
 
+void dma_nohal_init(const dma_descr_t *descr, uint32_t config);
+void dma_nohal_deinit(const dma_descr_t *descr);
+void dma_nohal_start(const dma_descr_t *descr, uint32_t src_addr, uint32_t dst_addr, uint16_t len);
+
 #endif // MICROPY_INCLUDED_STM32_DMA_H
diff --git a/ports/stm32/eth.c b/ports/stm32/eth.c
index 665495c17429c..33d20707e21c0 100644
--- a/ports/stm32/eth.c
+++ b/ports/stm32/eth.c
@@ -30,6 +30,7 @@
 #include "lib/netutils/netutils.h"
 #include "pin_static_af.h"
 #include "modnetwork.h"
+#include "mpu.h"
 #include "eth.h"
 
 #if defined(MICROPY_HW_ETH_MDC)
@@ -107,7 +108,6 @@ typedef struct _eth_dma_t {
 } eth_dma_t;
 
 typedef struct _eth_t {
-    mod_network_nic_type_t base;
     uint32_t trace_flags;
     struct netif netif;
     struct dhcp dhcp_struct;
@@ -142,35 +142,6 @@ STATIC uint32_t eth_phy_read(uint32_t reg) {
     return ETH->MACMIIDR;
 }
 
-STATIC void mpu_config(uint32_t region, uint32_t base_addr, uint32_t size) {
-    __DMB();
-
-    // Disable MPU
-    SCB->SHCSR &= ~SCB_SHCSR_MEMFAULTENA_Msk;
-    MPU->CTRL = 0;
-
-    // Config MPU region
-    MPU->RNR = region;
-    MPU->RBAR = base_addr;
-    MPU->RASR =
-        MPU_INSTRUCTION_ACCESS_DISABLE  << MPU_RASR_XN_Pos
-        | MPU_REGION_FULL_ACCESS        << MPU_RASR_AP_Pos
-        | MPU_TEX_LEVEL1                << MPU_RASR_TEX_Pos
-        | MPU_ACCESS_SHAREABLE          << MPU_RASR_S_Pos
-        | MPU_ACCESS_NOT_CACHEABLE      << MPU_RASR_C_Pos
-        | MPU_ACCESS_NOT_BUFFERABLE     << MPU_RASR_B_Pos
-        | 0x00                          << MPU_RASR_SRD_Pos
-        | size                          << MPU_RASR_SIZE_Pos
-        | MPU_REGION_ENABLE             << MPU_RASR_ENABLE_Pos;
-
-    // Enable MPU
-    MPU->CTRL = MPU_PRIVILEGED_DEFAULT | MPU_CTRL_ENABLE_Msk;
-    SCB->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk;
-
-    __DSB();
-    __ISB();
-}
-
 void eth_init(eth_t *self, int mac_idx) {
     mp_hal_get_mac(mac_idx, &self->netif.hwaddr[0]);
     self->netif.hwaddr_len = 6;
@@ -182,7 +153,9 @@ void eth_set_trace(eth_t *self, uint32_t value) {
 
 STATIC int eth_mac_init(eth_t *self) {
     // Configure MPU
-    mpu_config(MPU_REGION_NUMBER0, (uint32_t)&eth_dma, MPU_REGION_SIZE_16KB);
+    uint32_t irq_state = mpu_config_start();
+    mpu_config_region(MPU_REGION_ETH, (uint32_t)&eth_dma, MPU_CONFIG_ETH(MPU_REGION_SIZE_16KB));
+    mpu_config_end(irq_state);
 
     // Configure GPIO
     mp_hal_pin_config_alt_static(MICROPY_HW_ETH_MDC, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_NONE, STATIC_AF_ETH_MDC);
@@ -283,15 +256,15 @@ STATIC int eth_mac_init(eth_t *self) {
     ETH->DMAIER =
         ETH_DMAIER_NISE // enable normal interrupts
         | ETH_DMAIER_RIE // enable RX interrupt
-        ;
+    ;
 
     // Configure RX descriptor lists
     for (size_t i = 0; i < RX_BUF_NUM; ++i) {
         eth_dma.rx_descr[i].rdes0 = 1 << RX_DESCR_0_OWN_Pos;
         eth_dma.rx_descr[i].rdes1 =
             1 << RX_DESCR_1_RCH_Pos // chained
-            | RX_BUF_SIZE << RX_DESCR_1_RBS1_Pos
-            ;
+                | RX_BUF_SIZE << RX_DESCR_1_RBS1_Pos
+        ;
         eth_dma.rx_descr[i].rdes2 = (uint32_t)&eth_dma.rx_buf[i * RX_BUF_SIZE];
         eth_dma.rx_descr[i].rdes3 = (uint32_t)&eth_dma.rx_descr[(i + 1) % RX_BUF_NUM];
     }
@@ -312,13 +285,13 @@ STATIC int eth_mac_init(eth_t *self) {
     ETH->DMAOMR =
         ETH_DMAOMR_RSF // read from RX FIFO after a full frame is written
         | ETH_DMAOMR_TSF // transmit when a full frame is in TX FIFO (needed by errata)
-        ;
+    ;
     mp_hal_delay_ms(2);
 
     // Select MAC filtering options
     ETH->MACFFR =
         ETH_MACFFR_RA // pass all frames up
-        ;
+    ;
     mp_hal_delay_ms(2);
 
     // Set MAC address
@@ -334,21 +307,21 @@ STATIC int eth_mac_init(eth_t *self) {
         : (phy_scsr & PHY_SCSR_SPEED_Msk) == PHY_SCSR_SPEED_100HALF ? ETH_MACCR_FES
         : (phy_scsr & PHY_SCSR_SPEED_Msk) == PHY_SCSR_SPEED_100FULL ? (ETH_MACCR_FES | ETH_MACCR_DM)
         : 0
-        ;
+    ;
     mp_hal_delay_ms(2);
 
     // Start MAC layer
     ETH->MACCR |=
         ETH_MACCR_TE // enable TX
         | ETH_MACCR_RE // enable RX
-        ;
+    ;
     mp_hal_delay_ms(2);
 
     // Start DMA layer
     ETH->DMAOMR |=
         ETH_DMAOMR_ST // start TX
         | ETH_DMAOMR_SR // start RX
-        ;
+    ;
     mp_hal_delay_ms(2);
 
     // Enable interrupts
@@ -400,11 +373,11 @@ STATIC int eth_tx_buf_send(void) {
     // Schedule to send next outgoing frame
     tx_descr->tdes0 =
         1 << TX_DESCR_0_OWN_Pos     // owned by DMA
-        | 1 << TX_DESCR_0_LS_Pos    // last segment
-        | 1 << TX_DESCR_0_FS_Pos    // first segment
-        | 3 << TX_DESCR_0_CIC_Pos   // enable all checksums inserted by hardware
-        | 1 << TX_DESCR_0_TCH_Pos   // TX descriptor is chained
-        ;
+            | 1 << TX_DESCR_0_LS_Pos // last segment
+            | 1 << TX_DESCR_0_FS_Pos // first segment
+            | 3 << TX_DESCR_0_CIC_Pos // enable all checksums inserted by hardware
+            | 1 << TX_DESCR_0_TCH_Pos // TX descriptor is chained
+    ;
 
     // Notify ETH DMA that there is a new TX descriptor for sending
     __DMB();
@@ -425,8 +398,8 @@ STATIC void eth_dma_rx_free(void) {
     // Schedule to get next incoming frame
     rx_descr->rdes1 =
         1 << RX_DESCR_1_RCH_Pos                 // RX descriptor is chained
-        | RX_BUF_SIZE << RX_DESCR_1_RBS1_Pos    // maximum buffer length
-        ;
+            | RX_BUF_SIZE << RX_DESCR_1_RBS1_Pos // maximum buffer length
+    ;
     rx_descr->rdes2 = (uint32_t)buf;
     rx_descr->rdes3 = (uint32_t)&eth_dma.rx_descr[eth_dma.rx_descr_idx];
     rx_descr->rdes0 = 1 << RX_DESCR_0_OWN_Pos;  // owned by DMA
@@ -451,7 +424,7 @@ void ETH_IRQHandler(void) {
             // Get RX buffer containing new frame
             size_t len = (rx_descr->rdes0 & RX_DESCR_0_FL_Msk) >> RX_DESCR_0_FL_Pos;
             len -= 4; // discard CRC at end
-            uint8_t *buf = (uint8_t*)rx_descr->rdes2;
+            uint8_t *buf = (uint8_t *)rx_descr->rdes2;
 
             // Process frame
             eth_process_frame(&eth_instance, len, buf);
diff --git a/ports/stm32/extint.c b/ports/stm32/extint.c
index 59b20d5bd9242..695655f09f5e2 100644
--- a/ports/stm32/extint.c
+++ b/ports/stm32/extint.c
@@ -31,6 +31,7 @@
 #include "py/runtime.h"
 #include "py/gc.h"
 #include "py/mphal.h"
+#include "pendsv.h"
 #include "pin.h"
 #include "extint.h"
 #include "irq.h"
@@ -83,13 +84,14 @@
 
 // TODO Add python method to change callback object.
 
+#if defined(STM32F4) || defined(STM32L4)
+// These MCUs have bitband support so define macros to atomically set/clear bits in IMR/EMR and SWIER
 #define EXTI_OFFSET (EXTI_BASE - PERIPH_BASE)
-
-// Macro used to set/clear the bit corresponding to the line in the IMR/EMR
-// register in an atomic fashion by using bitband addressing.
 #define EXTI_MODE_BB(mode, line) (*(__IO uint32_t *)(PERIPH_BB_BASE + ((EXTI_OFFSET + (mode)) * 32) + ((line) * 4)))
+#define EXTI_SWIER_BB(line) (*(__IO uint32_t *)(PERIPH_BB_BASE + ((EXTI_OFFSET + offsetof(EXTI_TypeDef, SWIER)) * 32) + ((line) * 4)))
+#endif
 
-#if defined(STM32L4)
+#if defined(STM32L4) || defined(STM32WB)
 // The L4 MCU supports 40 Events/IRQs lines of the type configurable and direct.
 // Here we only support configurable line types.  Details, see page 330 of RM0351, Rev 1.
 // The USB_FS_WAKUP event is a direct type and there is no support for it.
@@ -115,8 +117,6 @@
 #define EXTI_FTSR EXTI->FTSR
 #endif
 
-#define EXTI_SWIER_BB(line) (*(__IO uint32_t *)(PERIPH_BB_BASE + ((EXTI_OFFSET + offsetof(EXTI_TypeDef, SWIER)) * 32) + ((line) * 4)))
-
 typedef struct {
     mp_obj_base_t base;
     mp_int_t line;
@@ -139,23 +139,41 @@ STATIC mp_obj_t pyb_extint_callback_arg[EXTI_NUM_VECTORS];
 #endif
 
 STATIC const uint8_t nvic_irq_channel[EXTI_NUM_VECTORS] = {
-    #if defined(STM32F0)
+    #if defined(STM32F0) || defined(STM32L0)
+
     EXTI0_1_IRQn,  EXTI0_1_IRQn,  EXTI2_3_IRQn,  EXTI2_3_IRQn,
     EXTI4_15_IRQn, EXTI4_15_IRQn, EXTI4_15_IRQn, EXTI4_15_IRQn,
     EXTI4_15_IRQn, EXTI4_15_IRQn, EXTI4_15_IRQn, EXTI4_15_IRQn,
     EXTI4_15_IRQn, EXTI4_15_IRQn, EXTI4_15_IRQn, EXTI4_15_IRQn,
+    #if defined(STM32L0)
+    PVD_IRQn,
+    #else
     PVD_VDDIO2_IRQn,
+    #endif
     RTC_IRQn,
     0, // internal USB wakeup event
     RTC_IRQn,
     RTC_IRQn,
     ADC1_COMP_IRQn,
     ADC1_COMP_IRQn,
+
     #else
+
     EXTI0_IRQn,     EXTI1_IRQn,     EXTI2_IRQn,     EXTI3_IRQn,     EXTI4_IRQn,
     EXTI9_5_IRQn,   EXTI9_5_IRQn,   EXTI9_5_IRQn,   EXTI9_5_IRQn,   EXTI9_5_IRQn,
     EXTI15_10_IRQn, EXTI15_10_IRQn, EXTI15_10_IRQn, EXTI15_10_IRQn, EXTI15_10_IRQn,
     EXTI15_10_IRQn,
+    #if defined(STM32H7)
+    PVD_AVD_IRQn,
+    RTC_Alarm_IRQn,
+    TAMP_STAMP_IRQn,
+    RTC_WKUP_IRQn,
+    #elif defined(STM32WB)
+    PVD_PVM_IRQn,
+    RTC_Alarm_IRQn,
+    TAMP_STAMP_LSECSS_IRQn,
+    RTC_WKUP_IRQn,
+    #else
     #if defined(STM32L4)
     PVD_PVM_IRQn,
     #else
@@ -173,6 +191,8 @@ STATIC const uint8_t nvic_irq_channel[EXTI_NUM_VECTORS] = {
     TAMP_STAMP_IRQn,
     RTC_WKUP_IRQn,
     #endif
+
+    #endif
 };
 
 // Set override_callback_obj to true if you want to unconditionally set the
@@ -187,10 +207,10 @@ uint extint_register(mp_obj_t pin_obj, uint32_t mode, uint32_t pull, mp_obj_t ca
         // get both the port number and line number.
         v_line = mp_obj_get_int(pin_obj);
         if (v_line < 16) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "ExtInt vector %d < 16, use a Pin object", v_line));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("ExtInt vector %d < 16, use a Pin object"), v_line);
         }
         if (v_line >= EXTI_NUM_VECTORS) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "ExtInt vector %d >= max of %d", v_line, EXTI_NUM_VECTORS));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("ExtInt vector %d >= max of %d"), v_line, EXTI_NUM_VECTORS);
         }
     } else {
         pin = pin_find(pin_obj);
@@ -202,17 +222,17 @@ uint extint_register(mp_obj_t pin_obj, uint32_t mode, uint32_t pull, mp_obj_t ca
         mode != GPIO_MODE_EVT_RISING &&
         mode != GPIO_MODE_EVT_FALLING &&
         mode != GPIO_MODE_EVT_RISING_FALLING) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid ExtInt Mode: %d", mode));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("invalid ExtInt Mode: %d"), mode);
     }
     if (pull != GPIO_NOPULL &&
         pull != GPIO_PULLUP &&
         pull != GPIO_PULLDOWN) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid ExtInt Pull: %d", pull));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("invalid ExtInt Pull: %d"), pull);
     }
 
     mp_obj_t *cb = &MP_STATE_PORT(pyb_extint_callback)[v_line];
     if (!override_callback_obj && *cb != mp_const_none && callback_obj != mp_const_none) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "ExtInt vector %d is already in use", v_line));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("ExtInt vector %d is already in use"), v_line);
     }
 
     // We need to update callback atomically, so we disable the line
@@ -259,12 +279,11 @@ void extint_register_pin(const pin_obj_t *pin, uint32_t mode, bool hard_irq, mp_
     mp_obj_t *cb = &MP_STATE_PORT(pyb_extint_callback)[line];
     if (*cb != mp_const_none && MP_OBJ_FROM_PTR(pin) != pyb_extint_callback_arg[line]) {
         if (mp_obj_is_small_int(pyb_extint_callback_arg[line])) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                "ExtInt vector %d is already in use", line));
+            mp_raise_msg_varg(&mp_type_OSError, MP_ERROR_TEXT("ExtInt vector %d is already in use"), line);
         } else {
             const pin_obj_t *other_pin = MP_OBJ_TO_PTR(pyb_extint_callback_arg[line]);
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
-                "IRQ resource already taken by Pin('%q')", other_pin->name));
+            mp_raise_msg_varg(&mp_type_OSError,
+                MP_ERROR_TEXT("IRQ resource already taken by Pin('%q')"), other_pin->name);
         }
     }
 
@@ -281,7 +300,9 @@ void extint_register_pin(const pin_obj_t *pin, uint32_t mode, bool hard_irq, mp_
         pyb_extint_callback_arg[line] = MP_OBJ_FROM_PTR(pin);
 
         // Route the GPIO to EXTI
+        #if !defined(STM32WB)
         __HAL_RCC_SYSCFG_CLK_ENABLE();
+        #endif
         SYSCFG->EXTICR[line >> 2] =
             (SYSCFG->EXTICR[line >> 2] & ~(0x0f << (4 * (line & 0x03))))
             | ((uint32_t)(GPIO_GET_INDEX(pin->gpio)) << (4 * (line & 0x03)));
@@ -297,22 +318,75 @@ void extint_register_pin(const pin_obj_t *pin, uint32_t mode, bool hard_irq, mp_
     }
 }
 
+void extint_set(const pin_obj_t *pin, uint32_t mode) {
+    uint32_t line = pin->pin;
+
+    mp_obj_t *cb = &MP_STATE_PORT(pyb_extint_callback)[line];
+
+    extint_disable(line);
+
+    *cb = MP_OBJ_SENTINEL;
+
+    pyb_extint_mode[line] = (mode & 0x00010000) ? // GPIO_MODE_IT == 0x00010000
+        EXTI_Mode_Interrupt : EXTI_Mode_Event;
+
+    {
+        // Configure and enable the callback
+
+        pyb_extint_hard_irq[line] = 1;
+        pyb_extint_callback_arg[line] = MP_OBJ_FROM_PTR(pin);
+
+        // Route the GPIO to EXTI
+        #if !defined(STM32WB)
+        __HAL_RCC_SYSCFG_CLK_ENABLE();
+        #endif
+        SYSCFG->EXTICR[line >> 2] =
+            (SYSCFG->EXTICR[line >> 2] & ~(0x0f << (4 * (line & 0x03))))
+            | ((uint32_t)(GPIO_GET_INDEX(pin->gpio)) << (4 * (line & 0x03)));
+
+        // Enable or disable the rising detector
+        if ((mode & GPIO_MODE_IT_RISING) == GPIO_MODE_IT_RISING) {
+            EXTI_RTSR |= 1 << line;
+        } else {
+            EXTI_RTSR &= ~(1 << line);
+        }
+
+        // Enable or disable the falling detector
+        if ((mode & GPIO_MODE_IT_FALLING) == GPIO_MODE_IT_FALLING) {
+            EXTI_FTSR |= 1 << line;
+        } else {
+            EXTI_FTSR &= ~(1 << line);
+        }
+
+        // Configure the NVIC
+        NVIC_SetPriority(IRQn_NONNEG(nvic_irq_channel[line]), IRQ_PRI_EXTINT);
+        HAL_NVIC_EnableIRQ(nvic_irq_channel[line]);
+
+        // Enable the interrupt
+        extint_enable(line);
+    }
+}
+
 void extint_enable(uint line) {
     if (line >= EXTI_NUM_VECTORS) {
         return;
     }
-    #if defined(STM32F0) || defined(STM32F7) || defined(STM32H7)
-    // The Cortex-M7 doesn't have bitband support.
+    #if !defined(EXTI_MODE_BB)
+    // This MCU doesn't have bitband support.
     mp_uint_t irq_state = disable_irq();
     if (pyb_extint_mode[line] == EXTI_Mode_Interrupt) {
         #if defined(STM32H7)
         EXTI_D1->IMR1 |= (1 << line);
+        #elif defined(STM32WB)
+        EXTI->IMR1 |= (1 << line);
         #else
         EXTI->IMR |= (1 << line);
         #endif
     } else {
         #if defined(STM32H7)
         EXTI_D1->EMR1 |= (1 << line);
+        #elif defined(STM32WB)
+        EXTI->EMR1 |= (1 << line);
         #else
         EXTI->EMR |= (1 << line);
         #endif
@@ -331,12 +405,15 @@ void extint_disable(uint line) {
         return;
     }
 
-    #if defined(STM32F0) || defined(STM32F7) || defined(STM32H7)
-    // The Cortex-M7 doesn't have bitband support.
+    #if !defined(EXTI_MODE_BB)
+    // This MCU doesn't have bitband support.
     mp_uint_t irq_state = disable_irq();
     #if defined(STM32H7)
     EXTI_D1->IMR1 &= ~(1 << line);
     EXTI_D1->EMR1 &= ~(1 << line);
+    #elif defined(STM32WB)
+    EXTI->IMR1 &= ~(1 << line);
+    EXTI->EMR1 &= ~(1 << line);
     #else
     EXTI->IMR &= ~(1 << line);
     EXTI->EMR &= ~(1 << line);
@@ -356,21 +433,21 @@ void extint_swint(uint line) {
         return;
     }
     // we need 0 to 1 transition to trigger the interrupt
-#if defined(STM32L4) || defined(STM32H7)
+    #if defined(STM32L4) || defined(STM32H7) || defined(STM32WB)
     EXTI->SWIER1 &= ~(1 << line);
     EXTI->SWIER1 |= (1 << line);
-#else
+    #else
     EXTI->SWIER &= ~(1 << line);
     EXTI->SWIER |= (1 << line);
-#endif
+    #endif
 }
 
 void extint_trigger_mode(uint line, uint32_t mode) {
     if (line >= EXTI_NUM_VECTORS) {
         return;
     }
-    #if defined(STM32F0) || defined(STM32F7) || defined(STM32H7)
-    // The Cortex-M7 doesn't have bitband support.
+    #if !defined(EXTI_MODE_BB)
+    // This MCU doesn't have bitband support.
     mp_uint_t irq_state = disable_irq();
     // Enable or disable the rising detector
     if ((mode & GPIO_MODE_IT_RISING) == GPIO_MODE_IT_RISING) {
@@ -434,7 +511,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(extint_obj_swint_obj,  extint_obj_swint);
 /// \classmethod regs()
 /// Dump the values of the EXTI registers.
 STATIC mp_obj_t extint_regs(void) {
-    #if defined(STM32L4)
+    #if defined(STM32L4) || defined(STM32WB)
     printf("EXTI_IMR1   %08x\n", (unsigned int)EXTI->IMR1);
     printf("EXTI_IMR2   %08x\n", (unsigned int)EXTI->IMR2);
     printf("EXTI_EMR1   %08x\n", (unsigned int)EXTI->EMR1);
@@ -547,14 +624,17 @@ const mp_obj_type_t extint_type = {
     .name = MP_QSTR_ExtInt,
     .print = extint_obj_print,
     .make_new = extint_make_new,
-    .locals_dict = (mp_obj_dict_t*)&extint_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&extint_locals_dict,
 };
 
 void extint_init0(void) {
     for (int i = 0; i < PYB_EXTI_NUM_VECTORS; i++) {
+        if (MP_STATE_PORT(pyb_extint_callback)[i] == MP_OBJ_SENTINEL) {
+            continue;
+        }
         MP_STATE_PORT(pyb_extint_callback)[i] = mp_const_none;
         pyb_extint_mode[i] = EXTI_Mode_Interrupt;
-   }
+    }
 }
 
 // Interrupt handler
@@ -563,6 +643,15 @@ void Handle_EXTI_Irq(uint32_t line) {
         __HAL_GPIO_EXTI_CLEAR_FLAG(1 << line);
         if (line < EXTI_NUM_VECTORS) {
             mp_obj_t *cb = &MP_STATE_PORT(pyb_extint_callback)[line];
+            #if MICROPY_PY_NETWORK_CYW43 && defined(pyb_pin_WL_HOST_WAKE)
+            if (pyb_extint_callback_arg[line] == MP_OBJ_FROM_PTR(pyb_pin_WL_HOST_WAKE)) {
+                extern void (*cyw43_poll)(void);
+                if (cyw43_poll) {
+                    pendsv_schedule_dispatch(PENDSV_DISPATCH_CYW43, cyw43_poll);
+                }
+                return;
+            }
+            #endif
             if (*cb != mp_const_none) {
                 // If it's a soft IRQ handler then just schedule callback for later
                 if (!pyb_extint_hard_irq[line]) {
@@ -582,7 +671,7 @@ void Handle_EXTI_Irq(uint32_t line) {
                     // Uncaught exception; disable the callback so it doesn't run again.
                     *cb = mp_const_none;
                     extint_disable(line);
-                    printf("Uncaught exception in ExtInt interrupt handler line %u\n", (unsigned int)line);
+                    mp_printf(MICROPY_ERROR_PRINTER, "uncaught exception in ExtInt interrupt handler line %u\n", (unsigned int)line);
                     mp_obj_print_exception(&mp_plat_print, MP_OBJ_FROM_PTR(nlr.ret_val));
                 }
                 gc_unlock();
diff --git a/ports/stm32/extint.h b/ports/stm32/extint.h
index d275087c9e28f..907af53dc22b1 100644
--- a/ports/stm32/extint.h
+++ b/ports/stm32/extint.h
@@ -46,7 +46,7 @@
 #if defined(STM32F0) || defined(STM32L4)
 #define EXTI_RTC_TIMESTAMP      (19)
 #define EXTI_RTC_WAKEUP         (20)
-#elif defined(STM32H7)
+#elif defined(STM32H7) || defined(STM32WB)
 #define EXTI_RTC_TIMESTAMP      (18)
 #define EXTI_RTC_WAKEUP         (19)
 #else
diff --git a/ports/stm32/factoryreset.c b/ports/stm32/factoryreset.c
new file mode 100644
index 0000000000000..04591101e87df
--- /dev/null
+++ b/ports/stm32/factoryreset.c
@@ -0,0 +1,131 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+#include "extmod/vfs_fat.h"
+#include "systick.h"
+#include "led.h"
+#include "storage.h"
+#include "factoryreset.h"
+
+#if MICROPY_HW_ENABLE_STORAGE
+
+static const char fresh_boot_py[] =
+    "# boot.py -- run on boot-up\r\n"
+    "# can run arbitrary Python, but best to keep it minimal\r\n"
+    "\r\n"
+    "import machine\r\n"
+    "import pyb\r\n"
+    "pyb.country('US') # ISO 3166-1 Alpha-2 code, eg US, GB, DE, AU\r\n"
+    "#pyb.main('main.py') # main script to run after this one\r\n"
+#if MICROPY_HW_ENABLE_USB
+    "#pyb.usb_mode('VCP+MSC') # act as a serial and a storage device\r\n"
+    "#pyb.usb_mode('VCP+HID') # act as a serial device and a mouse\r\n"
+#endif
+;
+
+static const char fresh_main_py[] =
+    "# main.py -- put your code here!\r\n"
+;
+
+#if MICROPY_HW_ENABLE_USB
+static const char fresh_pybcdc_inf[] =
+#include "genhdr/pybcdc_inf.h"
+;
+
+static const char fresh_readme_txt[] =
+    "This is a MicroPython board\r\n"
+    "\r\n"
+    "You can get started right away by writing your Python code in 'main.py'.\r\n"
+    "\r\n"
+    "For a serial prompt:\r\n"
+    " - Windows: you need to go to 'Device manager', right click on the unknown device,\r\n"
+    "   then update the driver software, using the 'pybcdc.inf' file found on this drive.\r\n"
+    "   Then use a terminal program like Hyperterminal or putty.\r\n"
+    " - Mac OS X: use the command: screen /dev/tty.usbmodem*\r\n"
+    " - Linux: use the command: screen /dev/ttyACM0\r\n"
+    "\r\n"
+    "Please visit http://micropython.org/help/ for further help.\r\n"
+;
+#endif
+
+typedef struct _factory_file_t {
+    const char *name;
+    size_t len;
+    const char *data;
+} factory_file_t;
+
+static const factory_file_t factory_files[] = {
+    {"boot.py", sizeof(fresh_boot_py) - 1, fresh_boot_py},
+    {"main.py", sizeof(fresh_main_py) - 1, fresh_main_py},
+    #if MICROPY_HW_ENABLE_USB
+    {"pybcdc.inf", sizeof(fresh_pybcdc_inf) - 1, fresh_pybcdc_inf},
+    {"README.txt", sizeof(fresh_readme_txt) - 1, fresh_readme_txt},
+    #endif
+};
+
+MP_WEAK void factory_reset_make_files(FATFS *fatfs) {
+    for (int i = 0; i < MP_ARRAY_SIZE(factory_files); ++i) {
+        const factory_file_t *f = &factory_files[i];
+        FIL fp;
+        FRESULT res = f_open(fatfs, &fp, f->name, FA_WRITE | FA_CREATE_ALWAYS);
+        if (res == FR_OK) {
+            UINT n;
+            f_write(&fp, f->data, f->len, &n);
+            f_close(&fp);
+        }
+    }
+}
+
+MP_WEAK int factory_reset_create_filesystem(void) {
+    // LED on to indicate creation of local filesystem
+    led_state(PYB_LED_GREEN, 1);
+    uint32_t start_tick = HAL_GetTick();
+
+    fs_user_mount_t vfs;
+    pyb_flash_init_vfs(&vfs);
+    uint8_t working_buf[FF_MAX_SS];
+    FRESULT res = f_mkfs(&vfs.fatfs, FM_FAT, 0, working_buf, sizeof(working_buf));
+    if (res != FR_OK) {
+        mp_printf(&mp_plat_print, "MPY: can't create flash filesystem\n");
+        return -MP_ENODEV;
+    }
+
+    // Set label
+    f_setlabel(&vfs.fatfs, MICROPY_HW_FLASH_FS_LABEL);
+
+    // Populate the filesystem with factory files
+    factory_reset_make_files(&vfs.fatfs);
+
+    // Keep LED on for at least 200ms
+    systick_wait_at_least(start_tick, 200);
+    led_state(PYB_LED_GREEN, 0);
+
+    return 0; // success
+}
+
+#endif // MICROPY_HW_ENABLE_STORAGE
diff --git a/ports/stm32/factoryreset.h b/ports/stm32/factoryreset.h
new file mode 100644
index 0000000000000..1d1f4b857165d
--- /dev/null
+++ b/ports/stm32/factoryreset.h
@@ -0,0 +1,34 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_STM32_FACTORYRESET_H
+#define MICROPY_INCLUDED_STM32_FACTORYRESET_H
+
+#include "lib/oofatfs/ff.h"
+
+void factory_reset_make_files(FATFS *fatfs);
+int factory_reset_create_filesystem(void);
+
+#endif // MICROPY_INCLUDED_STM32_FACTORYRESET_H
diff --git a/ports/stm32/fdcan.c b/ports/stm32/fdcan.c
new file mode 100644
index 0000000000000..b3b1da998c79d
--- /dev/null
+++ b/ports/stm32/fdcan.c
@@ -0,0 +1,325 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014-2018 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+#include "py/mphal.h"
+#include "can.h"
+#include "irq.h"
+
+#if MICROPY_HW_ENABLE_CAN && MICROPY_HW_ENABLE_FDCAN
+
+#define FDCAN_ELEMENT_MASK_STDID (0x1ffc0000) // Standard Identifier
+#define FDCAN_ELEMENT_MASK_EXTID (0x1fffffff) // Extended Identifier
+#define FDCAN_ELEMENT_MASK_RTR   (0x20000000) // Remote Transmission Request
+#define FDCAN_ELEMENT_MASK_XTD   (0x40000000) // Extended Identifier
+#define FDCAN_ELEMENT_MASK_ESI   (0x80000000) // Error State Indicator
+#define FDCAN_ELEMENT_MASK_TS    (0x0000ffff) // Timestamp
+#define FDCAN_ELEMENT_MASK_DLC   (0x000f0000) // Data Length Code
+#define FDCAN_ELEMENT_MASK_BRS   (0x00100000) // Bit Rate Switch
+#define FDCAN_ELEMENT_MASK_FDF   (0x00200000) // FD Format
+#define FDCAN_ELEMENT_MASK_FIDX  (0x7f000000) // Filter Index
+#define FDCAN_ELEMENT_MASK_ANMF  (0x80000000) // Accepted Non-matching Frame
+
+bool can_init(pyb_can_obj_t *can_obj, uint32_t mode, uint32_t prescaler, uint32_t sjw, uint32_t bs1, uint32_t bs2, bool auto_restart) {
+    (void)auto_restart;
+
+    FDCAN_InitTypeDef *init = &can_obj->can.Init;
+    init->FrameFormat = FDCAN_FRAME_CLASSIC;
+    init->Mode = mode;
+
+    init->NominalPrescaler = prescaler; // tq = NominalPrescaler x (1/fdcan_ker_ck)
+    init->NominalSyncJumpWidth = sjw;
+    init->NominalTimeSeg1 = bs1; // NominalTimeSeg1 = Propagation_segment + Phase_segment_1
+    init->NominalTimeSeg2 = bs2;
+
+    init->AutoRetransmission = ENABLE;
+    init->TransmitPause = DISABLE;
+    init->ProtocolException = ENABLE;
+
+    // The Message RAM is shared between CAN1 and CAN2. Setting the offset to half
+    // the Message RAM for the second CAN and using half the resources for each CAN.
+    if (can_obj->can_id == PYB_CAN_1) {
+        init->MessageRAMOffset = 0;
+    } else {
+        init->MessageRAMOffset = 2560 / 2;
+    }
+
+    init->StdFiltersNbr = 64; // 128 / 2
+    init->ExtFiltersNbr = 0; // Not used
+
+    init->TxEventsNbr = 16;  // 32 / 2
+    init->RxBuffersNbr = 32; // 64 / 2
+    init->TxBuffersNbr = 16; // 32 / 2
+
+    init->RxFifo0ElmtsNbr = 64; // 128 / 2
+    init->RxFifo0ElmtSize = FDCAN_DATA_BYTES_8;
+
+    init->RxFifo1ElmtsNbr = 64; // 128 / 2
+    init->RxFifo1ElmtSize = FDCAN_DATA_BYTES_8;
+
+    init->TxFifoQueueElmtsNbr = 16; // Tx fifo elements
+    init->TxElmtSize = FDCAN_DATA_BYTES_8;
+    init->TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION;
+
+    FDCAN_GlobalTypeDef *CANx = NULL;
+    const pin_obj_t *pins[2];
+
+    switch (can_obj->can_id) {
+        #if defined(MICROPY_HW_CAN1_TX)
+        case PYB_CAN_1:
+            CANx = FDCAN1;
+            pins[0] = MICROPY_HW_CAN1_TX;
+            pins[1] = MICROPY_HW_CAN1_RX;
+            break;
+        #endif
+
+        #if defined(MICROPY_HW_CAN2_TX)
+        case PYB_CAN_2:
+            CANx = FDCAN2;
+            pins[0] = MICROPY_HW_CAN2_TX;
+            pins[1] = MICROPY_HW_CAN2_RX;
+            break;
+        #endif
+
+        default:
+            return false;
+    }
+
+    // Enable FDCAN clock
+    __HAL_RCC_FDCAN_CLK_ENABLE();
+
+    // init GPIO
+    uint32_t pin_mode = MP_HAL_PIN_MODE_ALT;
+    uint32_t pin_pull = MP_HAL_PIN_PULL_UP;
+    for (int i = 0; i < 2; ++i) {
+        if (!mp_hal_pin_config_alt(pins[i], pin_mode, pin_pull, AF_FN_CAN, can_obj->can_id)) {
+            return false;
+        }
+    }
+
+    // init CANx
+    can_obj->can.Instance = CANx;
+    HAL_FDCAN_Init(&can_obj->can);
+
+    // Disable acceptance of non-matching frames (enabled by default)
+    HAL_FDCAN_ConfigGlobalFilter(&can_obj->can, FDCAN_REJECT, FDCAN_REJECT, DISABLE, DISABLE);
+
+    // The configuration registers are locked after CAN is started.
+    HAL_FDCAN_Start(&can_obj->can);
+
+    // Reset all filters
+    for (int f = 0; f < 64; ++f) {
+        can_clearfilter(can_obj, f, 0);
+    }
+
+    can_obj->is_enabled = true;
+    can_obj->num_error_warning = 0;
+    can_obj->num_error_passive = 0;
+    can_obj->num_bus_off = 0;
+
+    switch (can_obj->can_id) {
+        case PYB_CAN_1:
+            NVIC_SetPriority(FDCAN1_IT0_IRQn, IRQ_PRI_CAN);
+            HAL_NVIC_EnableIRQ(FDCAN1_IT0_IRQn);
+            NVIC_SetPriority(FDCAN1_IT1_IRQn, IRQ_PRI_CAN);
+            HAL_NVIC_EnableIRQ(FDCAN1_IT1_IRQn);
+            break;
+        case PYB_CAN_2:
+            NVIC_SetPriority(FDCAN2_IT0_IRQn, IRQ_PRI_CAN);
+            HAL_NVIC_EnableIRQ(FDCAN2_IT0_IRQn);
+            NVIC_SetPriority(FDCAN2_IT1_IRQn, IRQ_PRI_CAN);
+            HAL_NVIC_EnableIRQ(FDCAN2_IT1_IRQn);
+            break;
+        default:
+            return false;
+    }
+
+    __HAL_FDCAN_ENABLE_IT(&can_obj->can, FDCAN_IT_BUS_OFF | FDCAN_IT_ERROR_WARNING | FDCAN_IT_ERROR_PASSIVE);
+    __HAL_FDCAN_ENABLE_IT(&can_obj->can, FDCAN_IT_RX_FIFO0_NEW_MESSAGE | FDCAN_IT_RX_FIFO1_NEW_MESSAGE);
+    __HAL_FDCAN_ENABLE_IT(&can_obj->can, FDCAN_IT_RX_FIFO0_MESSAGE_LOST | FDCAN_IT_RX_FIFO1_MESSAGE_LOST);
+    __HAL_FDCAN_ENABLE_IT(&can_obj->can, FDCAN_IT_RX_FIFO0_FULL | FDCAN_IT_RX_FIFO1_FULL);
+
+    return true;
+}
+
+void can_deinit(pyb_can_obj_t *self) {
+    self->is_enabled = false;
+    HAL_FDCAN_DeInit(&self->can);
+    if (self->can.Instance == FDCAN1) {
+        HAL_NVIC_DisableIRQ(FDCAN1_IT0_IRQn);
+        HAL_NVIC_DisableIRQ(FDCAN1_IT1_IRQn);
+        // TODO check if FDCAN2 is used.
+        __HAL_RCC_FDCAN_FORCE_RESET();
+        __HAL_RCC_FDCAN_RELEASE_RESET();
+        __HAL_RCC_FDCAN_CLK_DISABLE();
+    #if defined(MICROPY_HW_CAN2_TX)
+    } else if (self->can.Instance == FDCAN2) {
+        HAL_NVIC_DisableIRQ(FDCAN2_IT0_IRQn);
+        HAL_NVIC_DisableIRQ(FDCAN2_IT1_IRQn);
+        // TODO check if FDCAN2 is used.
+        __HAL_RCC_FDCAN_FORCE_RESET();
+        __HAL_RCC_FDCAN_RELEASE_RESET();
+        __HAL_RCC_FDCAN_CLK_DISABLE();
+    #endif
+    }
+}
+
+void can_clearfilter(pyb_can_obj_t *self, uint32_t f, uint8_t bank) {
+    if (self && self->can.Instance) {
+        FDCAN_FilterTypeDef filter = {0};
+        filter.IdType = FDCAN_STANDARD_ID;
+        filter.FilterIndex = f;
+        filter.FilterConfig = FDCAN_FILTER_DISABLE;
+        HAL_FDCAN_ConfigFilter(&self->can, &filter);
+    }
+}
+
+int can_receive(FDCAN_HandleTypeDef *can, int fifo, FDCAN_RxHeaderTypeDef *hdr, uint8_t *data, uint32_t timeout_ms) {
+    volatile uint32_t *rxf, *rxa;
+    if (fifo == FDCAN_RX_FIFO0) {
+        rxf = &can->Instance->RXF0S;
+        rxa = &can->Instance->RXF0A;
+    } else {
+        rxf = &can->Instance->RXF1S;
+        rxa = &can->Instance->RXF1A;
+    }
+
+    // Wait for a message to become available, with timeout
+    uint32_t start = HAL_GetTick();
+    while ((*rxf & 7) == 0) {
+        MICROPY_EVENT_POLL_HOOK
+        if (HAL_GetTick() - start >= timeout_ms) {
+            return -MP_ETIMEDOUT;
+        }
+    }
+
+    // Get pointer to incoming message
+    uint32_t index = (can->Instance->RXF0S & FDCAN_RXF0S_F0GI) >> 8;
+    uint32_t *address = (uint32_t *)(can->msgRam.RxFIFO0SA + (index * can->Init.RxFifo0ElmtSize * 4));
+
+    // Parse header of message
+    hdr->IdType = *address & FDCAN_ELEMENT_MASK_XTD;
+    if (hdr->IdType == FDCAN_STANDARD_ID) {
+        hdr->Identifier = (*address & FDCAN_ELEMENT_MASK_STDID) >> 18;
+    } else {
+        hdr->Identifier = *address & FDCAN_ELEMENT_MASK_EXTID;
+    }
+    hdr->RxFrameType = *address & FDCAN_ELEMENT_MASK_RTR;
+    hdr->ErrorStateIndicator = *address++ & FDCAN_ELEMENT_MASK_ESI;
+    hdr->RxTimestamp = *address & FDCAN_ELEMENT_MASK_TS;
+    hdr->DataLength = (*address & FDCAN_ELEMENT_MASK_DLC) >> 16;
+    hdr->BitRateSwitch = *address & FDCAN_ELEMENT_MASK_BRS;
+    hdr->FDFormat = *address & FDCAN_ELEMENT_MASK_FDF;
+    hdr->FilterIndex = (*address & FDCAN_ELEMENT_MASK_FIDX) >> 24;
+    hdr->IsFilterMatchingFrame = (*address++ & FDCAN_ELEMENT_MASK_ANMF) >> 31;
+
+    // Copy data
+    uint8_t *pdata = (uint8_t *)address;
+    for (uint32_t i = 0; i < 8; ++i) { // TODO use DLCtoBytes[hdr->DataLength] for length > 8
+        *data++ = *pdata++;
+    }
+
+    // Release (free) message from FIFO
+    *rxa = index;
+
+    return 0; // success
+}
+
+STATIC void can_rx_irq_handler(uint can_id, uint fifo_id) {
+    mp_obj_t callback;
+    pyb_can_obj_t *self;
+    mp_obj_t irq_reason = MP_OBJ_NEW_SMALL_INT(0);
+    byte *state;
+
+    self = MP_STATE_PORT(pyb_can_obj_all)[can_id - 1];
+
+    if (fifo_id == FDCAN_RX_FIFO0) {
+        callback = self->rxcallback0;
+        state = &self->rx_state0;
+    } else {
+        callback = self->rxcallback1;
+        state = &self->rx_state1;
+    }
+
+    switch (*state) {
+        case RX_STATE_FIFO_EMPTY:
+            __HAL_FDCAN_DISABLE_IT(&self->can,  (fifo_id == FDCAN_RX_FIFO0) ?
+                FDCAN_IT_RX_FIFO0_NEW_MESSAGE : FDCAN_IT_RX_FIFO1_NEW_MESSAGE);
+            irq_reason = MP_OBJ_NEW_SMALL_INT(0);
+            *state = RX_STATE_MESSAGE_PENDING;
+            break;
+        case RX_STATE_MESSAGE_PENDING:
+            __HAL_FDCAN_DISABLE_IT(&self->can, (fifo_id == FDCAN_RX_FIFO0) ? FDCAN_IT_RX_FIFO0_FULL : FDCAN_IT_RX_FIFO1_FULL);
+            __HAL_FDCAN_CLEAR_FLAG(&self->can, (fifo_id == FDCAN_RX_FIFO0) ? FDCAN_FLAG_RX_FIFO0_FULL : FDCAN_FLAG_RX_FIFO1_FULL);
+            irq_reason = MP_OBJ_NEW_SMALL_INT(1);
+            *state = RX_STATE_FIFO_FULL;
+            break;
+        case RX_STATE_FIFO_FULL:
+            __HAL_FDCAN_DISABLE_IT(&self->can, (fifo_id == FDCAN_RX_FIFO0) ?
+                FDCAN_IT_RX_FIFO0_MESSAGE_LOST : FDCAN_IT_RX_FIFO1_MESSAGE_LOST);
+            __HAL_FDCAN_CLEAR_FLAG(&self->can, (fifo_id == FDCAN_RX_FIFO0) ?
+                FDCAN_FLAG_RX_FIFO0_MESSAGE_LOST : FDCAN_FLAG_RX_FIFO1_MESSAGE_LOST);
+            irq_reason = MP_OBJ_NEW_SMALL_INT(2);
+            *state = RX_STATE_FIFO_OVERFLOW;
+            break;
+        case RX_STATE_FIFO_OVERFLOW:
+            // This should never happen
+            break;
+    }
+
+    pyb_can_handle_callback(self, fifo_id, callback, irq_reason);
+}
+
+#if defined(MICROPY_HW_CAN1_TX)
+void FDCAN1_IT0_IRQHandler(void) {
+    IRQ_ENTER(FDCAN1_IT0_IRQn);
+    can_rx_irq_handler(PYB_CAN_1, FDCAN_RX_FIFO0);
+    IRQ_EXIT(FDCAN1_IT0_IRQn);
+}
+
+void FDCAN1_IT1_IRQHandler(void) {
+    IRQ_ENTER(FDCAN1_IT1_IRQn);
+    can_rx_irq_handler(PYB_CAN_1, FDCAN_RX_FIFO1);
+    IRQ_EXIT(FDCAN1_IT1_IRQn);
+}
+#endif
+
+#if defined(MICROPY_HW_CAN2_TX)
+void FDCAN2_IT0_IRQHandler(void) {
+    IRQ_ENTER(FDCAN2_IT0_IRQn);
+    can_rx_irq_handler(PYB_CAN_2, FDCAN_RX_FIFO0);
+    IRQ_EXIT(FDCAN2_IT0_IRQn);
+}
+
+void FDCAN2_IT1_IRQHandler(void) {
+    IRQ_ENTER(FDCAN2_IT1_IRQn);
+    can_rx_irq_handler(PYB_CAN_2, FDCAN_RX_FIFO1);
+    IRQ_EXIT(FDCAN2_IT1_IRQn);
+}
+#endif
+
+#endif // MICROPY_HW_ENABLE_CAN && MICROPY_HW_ENABLE_FDCAN
diff --git a/ports/stm32/flash.c b/ports/stm32/flash.c
index e1cf707d3431c..99c95f7d993ed 100644
--- a/ports/stm32/flash.c
+++ b/ports/stm32/flash.c
@@ -62,13 +62,21 @@ static const flash_layout_t flash_layout[] = {
 // FLASH_FLAG_ERSERR (Erasing Sequence Error) in STM32F7
 #define FLASH_FLAG_PGSERR FLASH_FLAG_ERSERR
 
+#if defined(STM32F722xx) || defined(STM32F723xx) || defined(STM32F732xx) || defined(STM32F733xx)
+static const flash_layout_t flash_layout[] = {
+    { 0x08000000, 0x04000, 4 },
+    { 0x08010000, 0x10000, 1 },
+    { 0x08020000, 0x20000, 3 },
+};
+#else
 static const flash_layout_t flash_layout[] = {
     { 0x08000000, 0x08000, 4 },
     { 0x08020000, 0x20000, 1 },
     { 0x08040000, 0x40000, 3 },
 };
+#endif
 
-#elif defined(STM32L4)
+#elif defined(STM32L0) || defined(STM32L4) || defined(STM32WB)
 
 static const flash_layout_t flash_layout[] = {
     { (uint32_t)FLASH_BASE, (uint32_t)FLASH_PAGE_SIZE, 512 },
@@ -92,7 +100,7 @@ static uint32_t get_bank(uint32_t addr) {
     if (READ_BIT(FLASH->OPTCR, FLASH_OPTCR_SWAP_BANK) == 0) {
     #else
     if (READ_BIT(SYSCFG->MEMRMP, SYSCFG_MEMRMP_FB_MODE) == 0) {
-    #endif
+        #endif
         // no bank swap
         if (addr < (FLASH_BASE + FLASH_BANK_SIZE)) {
             return FLASH_BANK_1;
@@ -122,6 +130,12 @@ static uint32_t get_page(uint32_t addr) {
 }
 #endif
 
+#elif (defined(STM32L4) && !defined(SYSCFG_MEMRMP_FB_MODE)) || defined(STM32WB)
+
+static uint32_t get_page(uint32_t addr) {
+    return (addr - FLASH_BASE) / FLASH_PAGE_SIZE;
+}
+
 #endif
 
 uint32_t flash_get_sector_info(uint32_t addr, uint32_t *start_addr, uint32_t *size) {
@@ -161,31 +175,37 @@ void flash_erase(uint32_t flash_dest, uint32_t num_word32) {
 
     #if defined(STM32F0)
     __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_WRPERR | FLASH_FLAG_PGERR);
-    EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
+    EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;
+    EraseInitStruct.PageAddress = flash_dest;
+    EraseInitStruct.NbPages = (4 * num_word32 + FLASH_PAGE_SIZE - 4) / FLASH_PAGE_SIZE;
+    #elif defined(STM32L0)
+    __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR);
+    EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;
     EraseInitStruct.PageAddress = flash_dest;
-    EraseInitStruct.NbPages     = (4 * num_word32 + FLASH_PAGE_SIZE - 4) / FLASH_PAGE_SIZE;
-    #elif  (defined(STM32L4) && !defined(SYSCFG_MEMRMP_FB_MODE))
+    EraseInitStruct.NbPages = (4 * num_word32 + FLASH_PAGE_SIZE - 4) / FLASH_PAGE_SIZE;
+    #elif (defined(STM32L4) && !defined(SYSCFG_MEMRMP_FB_MODE)) || defined(STM32WB)
     __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_ALL_ERRORS);
-    EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
-    EraseInitStruct.Page        = flash_dest;
-    EraseInitStruct.NbPages     = (4 * num_word32 + FLASH_PAGE_SIZE - 4) / FLASH_PAGE_SIZE;
+    EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;
+    EraseInitStruct.Page = get_page(flash_dest);
+    EraseInitStruct.NbPages = (4 * num_word32 + FLASH_PAGE_SIZE - 4) / FLASH_PAGE_SIZE;
     #elif defined(STM32L4)
     __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_ALL_ERRORS);
 
     // erase the sector(s)
     // The sector returned by flash_get_sector_info can not be used
     // as the flash has on each bank 0/1 pages 0..255
-    EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
-    EraseInitStruct.Banks       = get_bank(flash_dest);
-    EraseInitStruct.Page        = get_page(flash_dest);
-    EraseInitStruct.NbPages     = get_page(flash_dest + 4 * num_word32 - 1) - EraseInitStruct.Page + 1;;
+    EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;
+    EraseInitStruct.Banks = get_bank(flash_dest);
+    EraseInitStruct.Page = get_page(flash_dest);
+    EraseInitStruct.NbPages = get_page(flash_dest + 4 * num_word32 - 1) - EraseInitStruct.Page + 1;
+    ;
     #else
     // Clear pending flags (if any)
     #if defined(STM32H7)
     __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_ALL_ERRORS_BANK1 | FLASH_FLAG_ALL_ERRORS_BANK2);
     #else
     __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
-                           FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
+        FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
     #endif
 
     // erase the sector(s)
@@ -236,11 +256,11 @@ void flash_erase_it(uint32_t flash_dest, uint32_t num_word32) {
 */
 
 void flash_write(uint32_t flash_dest, const uint32_t *src, uint32_t num_word32) {
-    #if defined(STM32L4)
+    #if defined(STM32L4) || defined(STM32WB)
 
     // program the flash uint64 by uint64
     for (int i = 0; i < num_word32 / 2; i++) {
-        uint64_t val = *(uint64_t*)src;
+        uint64_t val = *(uint64_t *)src;
         if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, flash_dest, val) != HAL_OK) {
             // error occurred during flash write
             HAL_FLASH_Lock(); // lock the flash
@@ -250,7 +270,7 @@ void flash_write(uint32_t flash_dest, const uint32_t *src, uint32_t num_word32)
         src += 2;
     }
     if ((num_word32 & 0x01) == 1) {
-        uint64_t val = *(uint64_t*)flash_dest;
+        uint64_t val = *(uint64_t *)flash_dest;
         val = (val & 0xffffffff00000000uL) | (*src);
         if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, flash_dest, val) != HAL_OK) {
             // error occurred during flash write
diff --git a/ports/stm32/flashbdev.c b/ports/stm32/flashbdev.c
index 0b95dcc4ffc0c..e105bd35381b9 100644
--- a/ports/stm32/flashbdev.c
+++ b/ports/stm32/flashbdev.c
@@ -53,7 +53,7 @@
 #define FLASH_MEM_SEG2_NUM_BLOCKS (128) // sector 11: 128k
 #endif
 
-#elif defined(STM32F401xE) || defined(STM32F411xE) || defined(STM32F446xx)
+#elif defined(STM32F401xE) || defined(STM32F411xE) || defined(STM32F412Zx) || defined(STM32F446xx)
 
 STATIC byte flash_cache_mem[0x4000] __attribute__((aligned(4))); // 16k
 #define CACHE_MEM_START_ADDR (&flash_cache_mem[0])
@@ -61,6 +61,15 @@ STATIC byte flash_cache_mem[0x4000] __attribute__((aligned(4))); // 16k
 #define FLASH_MEM_SEG1_START_ADDR (0x08004000) // sector 1
 #define FLASH_MEM_SEG1_NUM_BLOCKS (128) // sectors 1,2,3,4: 16k+16k+16k+16k(of 64k)=64k
 
+#elif defined(STM32F413xx)
+
+#define CACHE_MEM_START_ADDR (0x10000000) // SRAM2 data RAM, 64k
+#define FLASH_SECTOR_SIZE_MAX (0x10000) // 64k max, size of SRAM2
+#define FLASH_MEM_SEG1_START_ADDR (0x08004000) // sector 1
+#define FLASH_MEM_SEG1_NUM_BLOCKS (352) // sectors 1,2,3,4,5: 16k+16k+16k+64k+64k(of 128k)=176k
+#define FLASH_MEM_SEG2_START_ADDR (0x08040000) // sector 6
+#define FLASH_MEM_SEG2_NUM_BLOCKS (128) // sector 6: 64k(of 128k). Filesystem 176K + 64K = 240K
+
 #elif defined(STM32F429xx)
 
 #define CACHE_MEM_START_ADDR (0x10000000) // CCM data RAM, 64k
@@ -77,6 +86,13 @@ STATIC byte flash_cache_mem[0x4000] __attribute__((aligned(4))); // 16k
 #define FLASH_MEM_SEG2_START_ADDR (0x08140000) // sector 18
 #define FLASH_MEM_SEG2_NUM_BLOCKS (128) // sector 18: 64k(of 128k)
 
+#elif defined(STM32F722xx) || defined(STM32F723xx) || defined(STM32F732xx) || defined(STM32F733xx)
+
+#define CACHE_MEM_START_ADDR (0x20000000) // DTCM data RAM, 64k
+#define FLASH_SECTOR_SIZE_MAX (0x10000) // 64k max
+#define FLASH_MEM_SEG1_START_ADDR (0x08004000) // sector 1
+#define FLASH_MEM_SEG1_NUM_BLOCKS (224) // sectors 1,2,3,4: 16k+16k+16k+64k=112k
+
 #elif defined(STM32F746xx) || defined(STM32F765xx) || defined(STM32F767xx) || defined(STM32F769xx)
 
 // The STM32F746 doesn't really have CCRAM, so we use the 64K DTCM for this.
@@ -94,9 +110,12 @@ STATIC byte flash_cache_mem[0x4000] __attribute__((aligned(4))); // 16k
 #define FLASH_MEM_SEG1_START_ADDR (0x08020000) // sector 1
 #define FLASH_MEM_SEG1_NUM_BLOCKS (256) // Sector 1: 128k / 512b = 256 blocks
 
-#elif defined(STM32L432xx) || defined(STM32L475xx) || defined(STM32L476xx) || defined(STM32L496xx)
+#elif defined(STM32L432xx) || \
+    defined(STM32L451xx) || defined(STM32L452xx) || defined(STM32L462xx) || \
+    defined(STM32L475xx) || defined(STM32L476xx) || defined(STM32L496xx) || \
+    defined(STM32WB)
 
-// The STM32L475/6 doesn't have CCRAM, so we use the 32K SRAM2 for this, although
+// The STM32L4xx doesn't have CCRAM, so we use SRAM2 for this, although
 // actual location and size is defined by the linker script.
 extern uint8_t _flash_fs_start;
 extern uint8_t _flash_fs_end;
@@ -168,7 +187,7 @@ static uint8_t *flash_cache_get_addr_for_write(uint32_t flash_addr) {
     }
     if (flash_cache_sector_id != flash_sector_id) {
         flash_bdev_ioctl(BDEV_IOCTL_SYNC, 0);
-        memcpy((void*)CACHE_MEM_START_ADDR, (const void*)flash_sector_start, flash_sector_size);
+        memcpy((void *)CACHE_MEM_START_ADDR, (const void *)flash_sector_start, flash_sector_size);
         flash_cache_sector_id = flash_sector_id;
         flash_cache_sector_start = flash_sector_start;
         flash_cache_sector_size = flash_sector_size;
@@ -176,7 +195,7 @@ static uint8_t *flash_cache_get_addr_for_write(uint32_t flash_addr) {
     flash_flags |= FLASH_FLAG_DIRTY;
     led_state(PYB_LED_RED, 1); // indicate a dirty cache with LED on
     flash_tick_counter_last_write = HAL_GetTick();
-    return (uint8_t*)CACHE_MEM_START_ADDR + flash_addr - flash_sector_start;
+    return (uint8_t *)CACHE_MEM_START_ADDR + flash_addr - flash_sector_start;
 }
 
 static uint8_t *flash_cache_get_addr_for_read(uint32_t flash_addr) {
@@ -185,10 +204,10 @@ static uint8_t *flash_cache_get_addr_for_read(uint32_t flash_addr) {
     uint32_t flash_sector_id = flash_get_sector_info(flash_addr, &flash_sector_start, &flash_sector_size);
     if (flash_cache_sector_id == flash_sector_id) {
         // in cache, copy from there
-        return (uint8_t*)CACHE_MEM_START_ADDR + flash_addr - flash_sector_start;
+        return (uint8_t *)CACHE_MEM_START_ADDR + flash_addr - flash_sector_start;
     }
     // not in cache, copy straight from flash
-    return (uint8_t*)flash_addr;
+    return (uint8_t *)flash_addr;
 }
 
 static uint32_t convert_block_to_flash_addr(uint32_t block) {
@@ -239,7 +258,7 @@ static void flash_bdev_irq_handler(void) {
     // On file close and flash unmount we get a forced write, so we can afford to wait a while
     if ((flash_flags & FLASH_FLAG_FORCE_WRITE) || HAL_GetTick() - flash_tick_counter_last_write >= 5000) {
         // sync the cache RAM buffer by writing it to the flash page
-        flash_write(flash_cache_sector_start, (const uint32_t*)CACHE_MEM_START_ADDR, flash_cache_sector_size / 4);
+        flash_write(flash_cache_sector_start, (const uint32_t *)CACHE_MEM_START_ADDR, flash_cache_sector_size / 4);
         // clear the flash flags now that we have a clean cache
         flash_flags = 0;
         // indicate a clean cache with LED off
@@ -273,4 +292,44 @@ bool flash_bdev_writeblock(const uint8_t *src, uint32_t block) {
     return true;
 }
 
+int flash_bdev_readblocks_ext(uint8_t *dest, uint32_t block, uint32_t offset, uint32_t len) {
+    // Get data from flash memory, possibly via cache
+    while (len) {
+        uint32_t l = MIN(len, FLASH_BLOCK_SIZE - offset);
+        uint32_t flash_addr = convert_block_to_flash_addr(block);
+        if (flash_addr == -1) {
+            // bad block number
+            return -1;
+        }
+        uint8_t *src = flash_cache_get_addr_for_read(flash_addr + offset);
+        memcpy(dest, src, l);
+        dest += l;
+        block += 1;
+        offset = 0;
+        len -= l;
+    }
+    return 0;
+}
+
+int flash_bdev_writeblocks_ext(const uint8_t *src, uint32_t block, uint32_t offset, uint32_t len) {
+    // Copy to cache
+    while (len) {
+        uint32_t l = MIN(len, FLASH_BLOCK_SIZE - offset);
+        uint32_t flash_addr = convert_block_to_flash_addr(block);
+        if (flash_addr == -1) {
+            // bad block number
+            return -1;
+        }
+        uint32_t basepri = raise_irq_pri(IRQ_PRI_FLASH); // prevent cache flushing and USB access
+        uint8_t *dest = flash_cache_get_addr_for_write(flash_addr + offset);
+        memcpy(dest, src, l);
+        restore_irq_pri(basepri);
+        src += l;
+        block += 1;
+        offset = 0;
+        len -= l;
+    }
+    return 0;
+}
+
 #endif // MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE
diff --git a/ports/stm32/font_petme128_8x8.h b/ports/stm32/font_petme128_8x8.h
index cdc4e73a79a30..9963698b17519 100644
--- a/ports/stm32/font_petme128_8x8.h
+++ b/ports/stm32/font_petme128_8x8.h
@@ -27,7 +27,7 @@
 #define MICROPY_INCLUDED_STM32_FONT_PETME128_8X8_H
 
 static const uint8_t font_petme128_8x8[] = {
-    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 32= 
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 32=
     0x00,0x00,0x00,0x4f,0x4f,0x00,0x00,0x00, // 33=!
     0x00,0x07,0x07,0x00,0x00,0x07,0x07,0x00, // 34="
     0x14,0x7f,0x7f,0x14,0x14,0x7f,0x7f,0x14, // 35=#
diff --git a/ports/stm32/gccollect.c b/ports/stm32/gccollect.c
index 5c1bf1e06d626..ad5645738ea16 100644
--- a/ports/stm32/gccollect.c
+++ b/ports/stm32/gccollect.c
@@ -43,16 +43,8 @@ void gc_collect(void) {
     // start the GC
     gc_collect_start();
 
-    // get the registers and the sp
-    uintptr_t regs[10];
-    uintptr_t sp = gc_helper_get_regs_and_sp(regs);
-
-    // trace the stack, including the registers (since they live on the stack in this function)
-    #if MICROPY_PY_THREAD
-    gc_collect_root((void**)sp, ((uint32_t)MP_STATE_THREAD(stack_top) - sp) / sizeof(uint32_t));
-    #else
-    gc_collect_root((void**)sp, ((uint32_t)&_ram_end - sp) / sizeof(uint32_t));
-    #endif
+    // trace the stack and registers
+    gc_helper_collect_regs_and_stack();
 
     // trace root pointers from any threads
     #if MICROPY_PY_THREAD
diff --git a/ports/stm32/gccollect.h b/ports/stm32/gccollect.h
index 25a74a306a939..4992a96897e40 100644
--- a/ports/stm32/gccollect.h
+++ b/ports/stm32/gccollect.h
@@ -37,6 +37,7 @@ extern uint32_t _sbss;
 extern uint32_t _ebss;
 extern uint32_t _heap_start;
 extern uint32_t _heap_end;
+extern uint32_t _sstack;
 extern uint32_t _estack;
 extern uint32_t _ram_end;
 
diff --git a/ports/stm32/help.c b/ports/stm32/help.c
index f9d97b70d662d..fba0a6937fe8a 100644
--- a/ports/stm32/help.c
+++ b/ports/stm32/help.c
@@ -27,45 +27,45 @@
 #include "py/builtin.h"
 
 const char stm32_help_text[] =
-"Welcome to MicroPython!\n"
-"\n"
-"For online help please visit http://micropython.org/help/.\n"
-"\n"
-"Quick overview of commands for the board:\n"
-"  pyb.info()    -- print some general information\n"
-"  pyb.delay(n)  -- wait for n milliseconds\n"
-"  pyb.millis()  -- get number of milliseconds since hard reset\n"
-"  pyb.Switch()  -- create a switch object\n"
-"                   Switch methods: (), callback(f)\n"
-"  pyb.LED(n)    -- create an LED object for LED n (n=1,2,3,4)\n"
-"                   LED methods: on(), off(), toggle(), intensity(<n>)\n"
-"  pyb.Pin(pin)  -- get a pin, eg pyb.Pin('X1')\n"
-"  pyb.Pin(pin, m, [p]) -- get a pin and configure it for IO mode m, pull mode p\n"
-"                   Pin methods: init(..), value([v]), high(), low()\n"
-"  pyb.ExtInt(pin, m, p, callback) -- create an external interrupt object\n"
-"  pyb.ADC(pin)  -- make an analog object from a pin\n"
-"                   ADC methods: read(), read_timed(buf, freq)\n"
-"  pyb.DAC(port) -- make a DAC object\n"
-"                   DAC methods: triangle(freq), write(n), write_timed(buf, freq)\n"
-"  pyb.RTC()     -- make an RTC object; methods: datetime([val])\n"
-"  pyb.rng()     -- get a 30-bit hardware random number\n"
-"  pyb.Servo(n)  -- create Servo object for servo n (n=1,2,3,4)\n"
-"                   Servo methods: calibration(..), angle([x, [t]]), speed([x, [t]])\n"
-"  pyb.Accel()   -- create an Accelerometer object\n"
-"                   Accelerometer methods: x(), y(), z(), tilt(), filtered_xyz()\n"
-"\n"
-"Pins are numbered X1-X12, X17-X22, Y1-Y12, or by their MCU name\n"
-"Pin IO modes are: pyb.Pin.IN, pyb.Pin.OUT_PP, pyb.Pin.OUT_OD\n"
-"Pin pull modes are: pyb.Pin.PULL_NONE, pyb.Pin.PULL_UP, pyb.Pin.PULL_DOWN\n"
-"Additional serial bus objects: pyb.I2C(n), pyb.SPI(n), pyb.UART(n)\n"
-"\n"
-"Control commands:\n"
-"  CTRL-A        -- on a blank line, enter raw REPL mode\n"
-"  CTRL-B        -- on a blank line, enter normal REPL mode\n"
-"  CTRL-C        -- interrupt a running program\n"
-"  CTRL-D        -- on a blank line, do a soft reset of the board\n"
-"  CTRL-E        -- on a blank line, enter paste mode\n"
-"\n"
-"For further help on a specific object, type help(obj)\n"
-"For a list of available modules, type help('modules')\n"
+    "Welcome to MicroPython!\n"
+    "\n"
+    "For online help please visit http://micropython.org/help/.\n"
+    "\n"
+    "Quick overview of commands for the board:\n"
+    "  pyb.info()    -- print some general information\n"
+    "  pyb.delay(n)  -- wait for n milliseconds\n"
+    "  pyb.millis()  -- get number of milliseconds since hard reset\n"
+    "  pyb.Switch()  -- create a switch object\n"
+    "                   Switch methods: (), callback(f)\n"
+    "  pyb.LED(n)    -- create an LED object for LED n (n=1,2,3,4)\n"
+    "                   LED methods: on(), off(), toggle(), intensity(<n>)\n"
+    "  pyb.Pin(pin)  -- get a pin, eg pyb.Pin('X1')\n"
+    "  pyb.Pin(pin, m, [p]) -- get a pin and configure it for IO mode m, pull mode p\n"
+    "                   Pin methods: init(..), value([v]), high(), low()\n"
+    "  pyb.ExtInt(pin, m, p, callback) -- create an external interrupt object\n"
+    "  pyb.ADC(pin)  -- make an analog object from a pin\n"
+    "                   ADC methods: read(), read_timed(buf, freq)\n"
+    "  pyb.DAC(port) -- make a DAC object\n"
+    "                   DAC methods: triangle(freq), write(n), write_timed(buf, freq)\n"
+    "  pyb.RTC()     -- make an RTC object; methods: datetime([val])\n"
+    "  pyb.rng()     -- get a 30-bit hardware random number\n"
+    "  pyb.Servo(n)  -- create Servo object for servo n (n=1,2,3,4)\n"
+    "                   Servo methods: calibration(..), angle([x, [t]]), speed([x, [t]])\n"
+    "  pyb.Accel()   -- create an Accelerometer object\n"
+    "                   Accelerometer methods: x(), y(), z(), tilt(), filtered_xyz()\n"
+    "\n"
+    "Pins are numbered X1-X12, X17-X22, Y1-Y12, or by their MCU name\n"
+    "Pin IO modes are: pyb.Pin.IN, pyb.Pin.OUT_PP, pyb.Pin.OUT_OD\n"
+    "Pin pull modes are: pyb.Pin.PULL_NONE, pyb.Pin.PULL_UP, pyb.Pin.PULL_DOWN\n"
+    "Additional serial bus objects: pyb.I2C(n), pyb.SPI(n), pyb.UART(n)\n"
+    "\n"
+    "Control commands:\n"
+    "  CTRL-A        -- on a blank line, enter raw REPL mode\n"
+    "  CTRL-B        -- on a blank line, enter normal REPL mode\n"
+    "  CTRL-C        -- interrupt a running program\n"
+    "  CTRL-D        -- on a blank line, do a soft reset of the board\n"
+    "  CTRL-E        -- on a blank line, enter paste mode\n"
+    "\n"
+    "For further help on a specific object, type help(obj)\n"
+    "For a list of available modules, type help('modules')\n"
 ;
diff --git a/ports/stm32/i2c.c b/ports/stm32/i2c.c
index 109b9418f8665..5981df11c5bd8 100644
--- a/ports/stm32/i2c.c
+++ b/ports/stm32/i2c.c
@@ -30,11 +30,11 @@
 
 #if MICROPY_HW_ENABLE_HW_I2C
 
-#define I2C_POLL_TIMEOUT_MS (50)
-
 #if defined(STM32F4)
 
-int i2c_init(i2c_t *i2c, mp_hal_pin_obj_t scl, mp_hal_pin_obj_t sda, uint32_t freq) {
+STATIC uint16_t i2c_timeout_ms[MICROPY_HW_MAX_I2C];
+
+int i2c_init(i2c_t *i2c, mp_hal_pin_obj_t scl, mp_hal_pin_obj_t sda, uint32_t freq, uint16_t timeout_ms) {
     uint32_t i2c_id = ((uint32_t)i2c - I2C1_BASE) / (I2C2_BASE - I2C1_BASE);
 
     // Init pins
@@ -45,6 +45,9 @@ int i2c_init(i2c_t *i2c, mp_hal_pin_obj_t scl, mp_hal_pin_obj_t sda, uint32_t fr
         return -MP_EPERM;
     }
 
+    // Save timeout value
+    i2c_timeout_ms[i2c_id] = timeout_ms;
+
     // Force reset I2C peripheral
     RCC->APB1RSTR |= RCC_APB1RSTR_I2C1RST << i2c_id;
     RCC->APB1RSTR &= ~(RCC_APB1RSTR_I2C1RST << i2c_id);
@@ -88,9 +91,10 @@ int i2c_init(i2c_t *i2c, mp_hal_pin_obj_t scl, mp_hal_pin_obj_t sda, uint32_t fr
 }
 
 STATIC int i2c_wait_sr1_set(i2c_t *i2c, uint32_t mask) {
+    uint32_t i2c_id = ((uint32_t)i2c - I2C1_BASE) / (I2C2_BASE - I2C1_BASE);
     uint32_t t0 = HAL_GetTick();
     while (!(i2c->SR1 & mask)) {
-        if (HAL_GetTick() - t0 >= I2C_POLL_TIMEOUT_MS) {
+        if (HAL_GetTick() - t0 >= i2c_timeout_ms[i2c_id]) {
             i2c->CR1 &= ~I2C_CR1_PE;
             return -MP_ETIMEDOUT;
         }
@@ -99,9 +103,10 @@ STATIC int i2c_wait_sr1_set(i2c_t *i2c, uint32_t mask) {
 }
 
 STATIC int i2c_wait_stop(i2c_t *i2c) {
+    uint32_t i2c_id = ((uint32_t)i2c - I2C1_BASE) / (I2C2_BASE - I2C1_BASE);
     uint32_t t0 = HAL_GetTick();
     while (i2c->CR1 & I2C_CR1_STOP) {
-        if (HAL_GetTick() - t0 >= I2C_POLL_TIMEOUT_MS) {
+        if (HAL_GetTick() - t0 >= i2c_timeout_ms[i2c_id]) {
             i2c->CR1 &= ~I2C_CR1_PE;
             return -MP_ETIMEDOUT;
         }
@@ -264,7 +269,9 @@ int i2c_write(i2c_t *i2c, const uint8_t *src, size_t len, size_t next_len) {
 
 #elif defined(STM32F0) || defined(STM32F7)
 
-int i2c_init(i2c_t *i2c, mp_hal_pin_obj_t scl, mp_hal_pin_obj_t sda, uint32_t freq) {
+STATIC uint16_t i2c_timeout_ms[MICROPY_HW_MAX_I2C];
+
+int i2c_init(i2c_t *i2c, mp_hal_pin_obj_t scl, mp_hal_pin_obj_t sda, uint32_t freq, uint16_t timeout_ms) {
     uint32_t i2c_id = ((uint32_t)i2c - I2C1_BASE) / (I2C2_BASE - I2C1_BASE);
 
     // Init pins
@@ -275,6 +282,9 @@ int i2c_init(i2c_t *i2c, mp_hal_pin_obj_t scl, mp_hal_pin_obj_t sda, uint32_t fr
         return -MP_EPERM;
     }
 
+    // Save timeout value
+    i2c_timeout_ms[i2c_id] = timeout_ms;
+
     // Enable I2C peripheral clock
     RCC->APB1ENR |= RCC_APB1ENR_I2C1EN << i2c_id;
     volatile uint32_t tmp = RCC->APB1ENR; // delay after RCC clock enable
@@ -303,9 +313,10 @@ int i2c_init(i2c_t *i2c, mp_hal_pin_obj_t scl, mp_hal_pin_obj_t sda, uint32_t fr
 }
 
 STATIC int i2c_wait_cr2_clear(i2c_t *i2c, uint32_t mask) {
+    uint32_t i2c_id = ((uint32_t)i2c - I2C1_BASE) / (I2C2_BASE - I2C1_BASE);
     uint32_t t0 = HAL_GetTick();
     while (i2c->CR2 & mask) {
-        if (HAL_GetTick() - t0 >= I2C_POLL_TIMEOUT_MS) {
+        if (HAL_GetTick() - t0 >= i2c_timeout_ms[i2c_id]) {
             i2c->CR1 &= ~I2C_CR1_PE;
             return -MP_ETIMEDOUT;
         }
@@ -314,9 +325,10 @@ STATIC int i2c_wait_cr2_clear(i2c_t *i2c, uint32_t mask) {
 }
 
 STATIC int i2c_wait_isr_set(i2c_t *i2c, uint32_t mask) {
+    uint32_t i2c_id = ((uint32_t)i2c - I2C1_BASE) / (I2C2_BASE - I2C1_BASE);
     uint32_t t0 = HAL_GetTick();
     while (!(i2c->ISR & mask)) {
-        if (HAL_GetTick() - t0 >= I2C_POLL_TIMEOUT_MS) {
+        if (HAL_GetTick() - t0 >= i2c_timeout_ms[i2c_id]) {
             i2c->CR1 &= ~I2C_CR1_PE;
             return -MP_ETIMEDOUT;
         }
@@ -328,8 +340,7 @@ STATIC int i2c_wait_isr_set(i2c_t *i2c, uint32_t mask) {
 int i2c_start_addr(i2c_t *i2c, int rd_wrn, uint16_t addr, size_t len, bool stop) {
     // Enable the peripheral and send the START condition with slave address
     i2c->CR1 |= I2C_CR1_PE;
-    i2c->CR2 = stop << I2C_CR2_AUTOEND_Pos
-        | (len > 1) << I2C_CR2_RELOAD_Pos
+    i2c->CR2 = (len > 1) << I2C_CR2_RELOAD_Pos
         | (len > 0) << I2C_CR2_NBYTES_Pos
         | rd_wrn << I2C_CR2_RD_WRN_Pos
         | (addr & 0x7f) << 1;
@@ -349,6 +360,11 @@ int i2c_start_addr(i2c_t *i2c, int rd_wrn, uint16_t addr, size_t len, bool stop)
         return -MP_ENODEV;
     }
 
+    // Configure automatic STOP if needed
+    if (stop) {
+        i2c->CR2 |= I2C_CR2_AUTOEND;
+    }
+
     // Repurpose OAR1 to indicate that we loaded CR2
     i2c->OAR1 = 1;
 
diff --git a/ports/stm32/i2c.h b/ports/stm32/i2c.h
index 5599f41235cf4..4846f1cf3ab52 100644
--- a/ports/stm32/i2c.h
+++ b/ports/stm32/i2c.h
@@ -55,7 +55,7 @@ void i2c_er_irq_handler(mp_uint_t i2c_id);
 
 typedef I2C_TypeDef i2c_t;
 
-int i2c_init(i2c_t *i2c, mp_hal_pin_obj_t scl, mp_hal_pin_obj_t sda, uint32_t freq);
+int i2c_init(i2c_t *i2c, mp_hal_pin_obj_t scl, mp_hal_pin_obj_t sda, uint32_t freq, uint16_t timeout);
 int i2c_start_addr(i2c_t *i2c, int rd_wrn, uint16_t addr, size_t len, bool stop);
 int i2c_read(i2c_t *i2c, uint8_t *dest, size_t len, size_t next_len);
 int i2c_write(i2c_t *i2c, const uint8_t *src, size_t len, size_t next_len);
diff --git a/ports/stm32/i2cslave.c b/ports/stm32/i2cslave.c
index da165294ac6ec..cacc00e0c4141 100644
--- a/ports/stm32/i2cslave.c
+++ b/ports/stm32/i2cslave.c
@@ -90,7 +90,7 @@ void i2c_slave_ev_irq_handler(i2c_slave_t *i2c) {
         i2c->ICR = I2C_ICR_STOPCF;
         i2c->OAR1 &= ~I2C_OAR1_OA1EN;
         if (i2c->ISR & I2C_ISR_DIR) {
-            //i2c_slave_process_tx_end();
+            // i2c_slave_process_tx_end();
         } else {
             i2c_slave_process_rx_end();
         }
diff --git a/ports/stm32/irq.c b/ports/stm32/irq.c
index 7298a4b504c75..0100899733098 100644
--- a/ports/stm32/irq.c
+++ b/ports/stm32/irq.c
@@ -31,7 +31,7 @@
 /// \moduleref pyb
 
 #if IRQ_ENABLE_STATS
-uint32_t irq_stats[FPU_IRQn + 1] = {0};
+uint32_t irq_stats[IRQ_STATS_MAX] = {0};
 #endif
 
 /// \function wfi()
diff --git a/ports/stm32/irq.h b/ports/stm32/irq.h
index 9919013f894e5..4b1251666c202 100644
--- a/ports/stm32/irq.h
+++ b/ports/stm32/irq.h
@@ -39,7 +39,12 @@
 #define IRQ_ENABLE_STATS (0)
 
 #if IRQ_ENABLE_STATS
-extern uint32_t irq_stats[FPU_IRQn + 1];
+#if defined(STM32H7)
+#define IRQ_STATS_MAX   (256)
+#else
+#define IRQ_STATS_MAX   (128)
+#endif
+extern uint32_t irq_stats[IRQ_STATS_MAX];
 #define IRQ_ENTER(irq) ++irq_stats[irq]
 #define IRQ_EXIT(irq)
 #else
@@ -74,6 +79,17 @@ static inline void restore_irq_pri(uint32_t basepri) {
     __set_BASEPRI(basepri);
 }
 
+#else
+
+static inline uint32_t raise_irq_pri(uint32_t pri) {
+    return disable_irq();
+}
+
+// "state" should be the value returned from raise_irq_pri
+static inline void restore_irq_pri(uint32_t state) {
+    enable_irq(state);
+}
+
 #endif
 
 MP_DECLARE_CONST_FUN_OBJ_0(pyb_wfi_obj);
@@ -104,7 +120,7 @@ MP_DECLARE_CONST_FUN_OBJ_0(pyb_irq_stats_obj);
 
 #if __CORTEX_M == 0
 
-//#def  IRQ_PRI_SYSTICK         0
+#define IRQ_PRI_SYSTICK         0
 #define IRQ_PRI_UART            1
 #define IRQ_PRI_SDIO            1
 #define IRQ_PRI_DMA             1
@@ -120,7 +136,7 @@ MP_DECLARE_CONST_FUN_OBJ_0(pyb_irq_stats_obj);
 
 #else
 
-//#def  IRQ_PRI_SYSTICK         NVIC_EncodePriority(NVIC_PRIORITYGROUP_4, 0, 0)
+#define IRQ_PRI_SYSTICK         NVIC_EncodePriority(NVIC_PRIORITYGROUP_4, 0, 0)
 
 // The UARTs have no FIFOs, so if they don't get serviced quickly then characters
 // get dropped. The handling for each character only consumes about 0.5 usec
@@ -144,6 +160,8 @@ MP_DECLARE_CONST_FUN_OBJ_0(pyb_irq_stats_obj);
 
 #define IRQ_PRI_CAN             NVIC_EncodePriority(NVIC_PRIORITYGROUP_4, 7, 0)
 
+#define IRQ_PRI_SPI             NVIC_EncodePriority(NVIC_PRIORITYGROUP_4, 8, 0)
+
 // Interrupt priority for non-special timers.
 #define IRQ_PRI_TIMX            NVIC_EncodePriority(NVIC_PRIORITYGROUP_4, 13, 0)
 
diff --git a/ports/stm32/lcd.c b/ports/stm32/lcd.c
index b35bd3bbdbf79..bfc9a0a5fd635 100644
--- a/ports/stm32/lcd.c
+++ b/ports/stm32/lcd.c
@@ -218,7 +218,7 @@ STATIC mp_obj_t pyb_lcd_make_new(const mp_obj_type_t *type, size_t n_args, size_
         lcd->pin_a0 = pyb_pin_Y5;
         lcd->pin_bl = pyb_pin_Y12;
     } else {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "LCD(%s) doesn't exist", lcd_id));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("LCD(%s) doesn't exist"), lcd_id);
     }
 
     // init the SPI bus
@@ -236,14 +236,23 @@ STATIC mp_obj_t pyb_lcd_make_new(const mp_obj_type_t *type, size_t n_args, size_
         spi_clock = HAL_RCC_GetPCLK1Freq();
     }
     uint br_prescale = spi_clock / 16000000; // datasheet says LCD can run at 20MHz, but we go for 16MHz
-    if (br_prescale <= 2) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2; }
-    else if (br_prescale <= 4) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4; }
-    else if (br_prescale <= 8) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8; }
-    else if (br_prescale <= 16) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16; }
-    else if (br_prescale <= 32) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32; }
-    else if (br_prescale <= 64) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64; }
-    else if (br_prescale <= 128) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128; }
-    else { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256; }
+    if (br_prescale <= 2) {
+        init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
+    } else if (br_prescale <= 4) {
+        init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
+    } else if (br_prescale <= 8) {
+        init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
+    } else if (br_prescale <= 16) {
+        init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
+    } else if (br_prescale <= 32) {
+        init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
+    } else if (br_prescale <= 64) {
+        init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
+    } else if (br_prescale <= 128) {
+        init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
+    } else {
+        init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
+    }
 
     // data is sent bigendian, latches on rising clock
     init->CLKPolarity = SPI_POLARITY_HIGH;
@@ -328,7 +337,7 @@ STATIC mp_obj_t pyb_lcd_command(mp_obj_t self_in, mp_obj_t instr_data_in, mp_obj
 
     // send the data
     for (uint i = 0; i < bufinfo.len; i++) {
-        lcd_out(self, instr_data, ((byte*)bufinfo.buf)[i]);
+        lcd_out(self, instr_data, ((byte *)bufinfo.buf)[i]);
     }
 
     return mp_const_none;
@@ -452,7 +461,7 @@ STATIC mp_obj_t pyb_lcd_text(size_t n_args, const mp_obj_t *args) {
     // loop over chars
     for (const char *top = data + len; data < top; data++) {
         // get char and make sure its in range of font
-        uint chr = *(byte*)data;
+        uint chr = *(byte *)data;
         if (chr < 32 || chr > 127) {
             chr = 127;
         }
@@ -521,7 +530,7 @@ const mp_obj_type_t pyb_lcd_type = {
     { &mp_type_type },
     .name = MP_QSTR_LCD,
     .make_new = pyb_lcd_make_new,
-    .locals_dict = (mp_obj_dict_t*)&pyb_lcd_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_lcd_locals_dict,
 };
 
 #endif // MICROPY_HW_HAS_LCD
diff --git a/ports/stm32/led.c b/ports/stm32/led.c
index be7d196cfd3a2..923171884629f 100644
--- a/ports/stm32/led.c
+++ b/ports/stm32/led.c
@@ -52,15 +52,15 @@ typedef struct _pyb_led_obj_t {
 
 STATIC const pyb_led_obj_t pyb_led_obj[] = {
     {{&pyb_led_type}, 1, MICROPY_HW_LED1},
-#if defined(MICROPY_HW_LED2)
+    #if defined(MICROPY_HW_LED2)
     {{&pyb_led_type}, 2, MICROPY_HW_LED2},
-#if defined(MICROPY_HW_LED3)
+    #if defined(MICROPY_HW_LED3)
     {{&pyb_led_type}, 3, MICROPY_HW_LED3},
-#if defined(MICROPY_HW_LED4)
+    #if defined(MICROPY_HW_LED4)
     {{&pyb_led_type}, 4, MICROPY_HW_LED4},
-#endif
-#endif
-#endif
+    #endif
+    #endif
+    #endif
 };
 #define NUM_LEDS MP_ARRAY_SIZE(pyb_led_obj)
 
@@ -102,7 +102,7 @@ void led_init(void) {
 #define LED_PWM_TIM_PERIOD (10000) // TIM runs at 1MHz and fires every 10ms
 
 // this gives the address of the CCR register for channels 1-4
-#define LED_PWM_CCR(pwm_cfg) ((volatile uint32_t*)&(pwm_cfg)->tim->CCR1 + ((pwm_cfg)->tim_channel >> 2))
+#define LED_PWM_CCR(pwm_cfg) ((volatile uint32_t *)&(pwm_cfg)->tim->CCR1 + ((pwm_cfg)->tim_channel >> 2))
 
 typedef struct _led_pwm_config_t {
     TIM_TypeDef *tim;
@@ -135,10 +135,17 @@ STATIC void led_pwm_init(int led) {
 
     // TIM configuration
     switch (pwm_cfg->tim_id) {
-        case 1: __TIM1_CLK_ENABLE(); break;
-        case 2: __TIM2_CLK_ENABLE(); break;
-        case 3: __TIM3_CLK_ENABLE(); break;
-        default: assert(0);
+        case 1:
+            __TIM1_CLK_ENABLE();
+            break;
+        case 2:
+            __TIM2_CLK_ENABLE();
+            break;
+        case 3:
+            __TIM3_CLK_ENABLE();
+            break;
+        default:
+            assert(0);
     }
     TIM_HandleTypeDef tim = {0};
     tim.Instance = pwm_cfg->tim;
@@ -187,7 +194,7 @@ void led_state(pyb_led_t led, int state) {
     }
 
     const pin_obj_t *led_pin = pyb_led_obj[led - 1].led_pin;
-    //printf("led_state(%d,%d)\n", led, state);
+    // printf("led_state(%d,%d)\n", led, state);
     if (state == 0) {
         // turn LED off
         MICROPY_HW_LED_OFF(led_pin);
@@ -297,7 +304,7 @@ STATIC mp_obj_t led_obj_make_new(const mp_obj_type_t *type, size_t n_args, size_
 
     // check led number
     if (!(1 <= led_id && led_id <= NUM_LEDS)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "LED(%d) doesn't exist", led_id));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("LED(%d) doesn't exist"), led_id);
     }
 
     // return static led object
@@ -361,7 +368,7 @@ const mp_obj_type_t pyb_led_type = {
     .name = MP_QSTR_LED,
     .print = led_obj_print,
     .make_new = led_obj_make_new,
-    .locals_dict = (mp_obj_dict_t*)&led_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&led_locals_dict,
 };
 
 #else
diff --git a/ports/stm32/lwip_inc/arch/cc.h b/ports/stm32/lwip_inc/arch/cc.h
index 635b1c805651c..fc5230ef723ea 100644
--- a/ports/stm32/lwip_inc/arch/cc.h
+++ b/ports/stm32/lwip_inc/arch/cc.h
@@ -5,4 +5,6 @@
 #define LWIP_PLATFORM_DIAG(x)
 #define LWIP_PLATFORM_ASSERT(x)  { assert(1); }
 
+#define LWIP_NO_CTYPE_H 1
+
 #endif // MICROPY_INCLUDED_STM32_LWIP_ARCH_CC_H
diff --git a/ports/stm32/lwip_inc/lwipopts.h b/ports/stm32/lwip_inc/lwipopts.h
index 64ff104f7126b..7b2460fa80aaa 100644
--- a/ports/stm32/lwip_inc/lwipopts.h
+++ b/ports/stm32/lwip_inc/lwipopts.h
@@ -3,6 +3,11 @@
 
 #include <stdint.h>
 
+// This protection is not needed, instead we execute all lwIP code at PendSV priority
+#define SYS_ARCH_DECL_PROTECT(lev) do { } while (0)
+#define SYS_ARCH_PROTECT(lev) do { } while (0)
+#define SYS_ARCH_UNPROTECT(lev) do { } while (0)
+
 #define NO_SYS                          1
 #define SYS_LIGHTWEIGHT_PROT            1
 #define MEM_ALIGNMENT                   4
@@ -12,18 +17,28 @@
 
 #define LWIP_ARP                        1
 #define LWIP_ETHERNET                   1
+#define LWIP_RAW                        1
 #define LWIP_NETCONN                    0
 #define LWIP_SOCKET                     0
 #define LWIP_STATS                      0
 #define LWIP_NETIF_HOSTNAME             1
+#define LWIP_NETIF_EXT_STATUS_CALLBACK  1
 
 #define LWIP_IPV6                       0
 #define LWIP_DHCP                       1
 #define LWIP_DHCP_CHECK_LINK_UP         1
+#define DHCP_DOES_ARP_CHECK             0 // to speed DHCP up
 #define LWIP_DNS                        1
+#define LWIP_DNS_SUPPORT_MDNS_QUERIES   1
+#define LWIP_MDNS_RESPONDER             1
 #define LWIP_IGMP                       1
 
+#define LWIP_NUM_NETIF_CLIENT_DATA      LWIP_MDNS_RESPONDER
+#define MEMP_NUM_UDP_PCB                (4 + LWIP_MDNS_RESPONDER)
+#define MEMP_NUM_SYS_TIMEOUT            (LWIP_NUM_SYS_TIMEOUT_INTERNAL + LWIP_MDNS_RESPONDER)
+
 #define SO_REUSE                        1
+#define TCP_LISTEN_BACKLOG              1
 
 extern uint32_t rng_get(void);
 #define LWIP_RAND() rng_get()
diff --git a/ports/stm32/machine_adc.c b/ports/stm32/machine_adc.c
new file mode 100644
index 0000000000000..5ba000a2338c8
--- /dev/null
+++ b/ports/stm32/machine_adc.c
@@ -0,0 +1,450 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mphal.h"
+
+#if defined(STM32F0) || defined(STM32H7) || defined(STM32L0) || defined(STM32L4) || defined(STM32WB)
+#define ADC_V2 (1)
+#else
+#define ADC_V2 (0)
+#endif
+
+#if defined(STM32F4) || defined(STM32L4)
+#define ADCx_COMMON ADC_COMMON_REGISTER(0)
+#elif defined(STM32F7)
+#define ADCx_COMMON ADC123_COMMON
+#endif
+
+#if defined(STM32F0) || defined(STM32L0)
+#define ADC_STAB_DELAY_US (1)
+#define ADC_TEMPSENSOR_DELAY_US (10)
+#elif defined(STM32L4)
+#define ADC_STAB_DELAY_US (10)
+#elif defined(STM32WB)
+#define ADC_STAB_DELAY_US (1)
+#endif
+
+#if defined(STM32F0)
+#define ADC_SAMPLETIME_DEFAULT      ADC_SAMPLETIME_13CYCLES_5
+#define ADC_SAMPLETIME_DEFAULT_INT  ADC_SAMPLETIME_239CYCLES_5
+#elif defined(STM32F4) || defined(STM32F7)
+#define ADC_SAMPLETIME_DEFAULT      ADC_SAMPLETIME_15CYCLES
+#define ADC_SAMPLETIME_DEFAULT_INT  ADC_SAMPLETIME_480CYCLES
+#elif defined(STM32H7)
+#define ADC_SAMPLETIME_DEFAULT      ADC_SAMPLETIME_8CYCLES_5
+#define ADC_SAMPLETIME_DEFAULT_INT  ADC_SAMPLETIME_387CYCLES_5
+#elif defined(STM32L0)
+#define ADC_SAMPLETIME_DEFAULT      ADC_SAMPLETIME_12CYCLES_5
+#define ADC_SAMPLETIME_DEFAULT_INT  ADC_SAMPLETIME_160CYCLES_5
+#elif defined(STM32L4) || defined(STM32WB)
+#define ADC_SAMPLETIME_DEFAULT      ADC_SAMPLETIME_12CYCLES_5
+#define ADC_SAMPLETIME_DEFAULT_INT  ADC_SAMPLETIME_247CYCLES_5
+#endif
+
+// Timeout for waiting for end-of-conversion
+#define ADC_EOC_TIMEOUT_MS (10)
+
+// This is a synthesised channel representing the maximum ADC reading (useful to scale other channels)
+#define ADC_CHANNEL_VREF (0xffff)
+
+static inline void adc_stabilisation_delay_us(uint32_t us) {
+    mp_hal_delay_us(us + 1);
+}
+
+STATIC void adc_wait_eoc(ADC_TypeDef *adc, int32_t timeout_ms) {
+    uint32_t t0 = mp_hal_ticks_ms();
+    #if ADC_V2
+    while (!(adc->ISR & ADC_ISR_EOC))
+    #else
+    while (!(adc->SR & ADC_SR_EOC))
+    #endif
+    {
+        if (mp_hal_ticks_ms() - t0 > timeout_ms) {
+            break; // timeout
+        }
+    }
+}
+
+#if defined(STM32H7)
+STATIC const uint8_t adc_cr_to_bits_table[] = {16, 14, 12, 10, 8, 8, 8, 8};
+#else
+STATIC const uint8_t adc_cr_to_bits_table[] = {12, 10, 8, 6};
+#endif
+
+STATIC void adc_config(ADC_TypeDef *adc, uint32_t bits) {
+    // Configure ADC clock source and enable ADC clock
+    #if defined(STM32L4) || defined(STM32WB)
+    __HAL_RCC_ADC_CONFIG(RCC_ADCCLKSOURCE_SYSCLK);
+    __HAL_RCC_ADC_CLK_ENABLE();
+    #else
+    if (adc == ADC1) {
+        #if defined(STM32H7)
+        __HAL_RCC_ADC12_CLK_ENABLE();
+        #else
+        __HAL_RCC_ADC1_CLK_ENABLE();
+        #endif
+    }
+    #if defined(ADC2)
+    if (adc == ADC2) {
+        #if defined(STM32H7)
+        __HAL_RCC_ADC12_CLK_ENABLE();
+        #else
+        __HAL_RCC_ADC2_CLK_ENABLE();
+        #endif
+    }
+    #endif
+    #if defined(ADC3)
+    if (adc == ADC3) {
+        __HAL_RCC_ADC3_CLK_ENABLE();
+    }
+    #endif
+    #endif
+
+    // Configure clock mode
+    #if defined(STM32F0)
+    adc->CFGR2 = 2 << ADC_CFGR2_CKMODE_Pos; // PCLK/4 (synchronous clock mode)
+    #elif defined(STM32F4) || defined(STM32F7) || defined(STM32L4)
+    ADCx_COMMON->CCR = 0; // ADCPR=PCLK/2
+    #elif defined(STM32H7)
+    ADC12_COMMON->CCR = 3 << ADC_CCR_CKMODE_Pos;
+    ADC3_COMMON->CCR = 3 << ADC_CCR_CKMODE_Pos;
+    #elif defined(STM32L0) || defined(STM32WB)
+    ADC1_COMMON->CCR = 0; // ADCPR=PCLK/2
+    #endif
+
+    #if defined(STM32H7) || defined(STM32L4) || defined(STM32WB)
+    if (adc->CR & ADC_CR_DEEPPWD) {
+        adc->CR = 0; // disable deep powerdown
+    }
+    #endif
+
+    #if defined(STM32H7) || defined(STM32L0) || defined(STM32L4) || defined(STM32WB)
+    if (!(adc->CR & ADC_CR_ADVREGEN)) {
+        adc->CR = ADC_CR_ADVREGEN; // enable VREG
+        #if defined(STM32H7)
+        mp_hal_delay_us(10); // T_ADCVREG_STUP
+        #elif defined(STM32L4) || defined(STM32WB)
+        mp_hal_delay_us(20); // T_ADCVREG_STUP
+        #endif
+    }
+    #endif
+
+    #if ADC_V2
+    if (adc->CR == 0) {
+        // ADC hasn't been enabled so calibrate it
+        adc->CR |= ADC_CR_ADCAL;
+        while (adc->CR & ADC_CR_ADCAL) {
+        }
+    }
+
+    if (adc->CR & ADC_CR_ADEN) {
+        // ADC enabled, need to disable it to change configuration
+        if (adc->CR & ADC_CR_ADSTART) {
+            adc->CR |= ADC_CR_ADSTP;
+            while (adc->CR & ADC_CR_ADSTP) {
+            }
+        }
+        adc->CR |= ADC_CR_ADDIS;
+        while (adc->CR & ADC_CR_ADDIS) {
+        }
+    }
+    #endif
+
+    // Find resolution, defaulting to last element in table
+    uint32_t res;
+    for (res = 0; res <= MP_ARRAY_SIZE(adc_cr_to_bits_table); ++res) {
+        if (adc_cr_to_bits_table[res] == bits) {
+            break;
+        }
+    }
+
+    #if defined(STM32F0) || defined(STM32L0)
+
+    uint32_t cfgr1_clr = ADC_CFGR1_CONT | ADC_CFGR1_EXTEN | ADC_CFGR1_ALIGN | ADC_CFGR1_RES | ADC_CFGR1_DMAEN;
+    uint32_t cfgr1 = res << ADC_CFGR1_RES_Pos;
+    adc->CFGR1 = (adc->CFGR1 & ~cfgr1_clr) | cfgr1;
+
+    #elif defined(STM32F4) || defined(STM32F7)
+
+    uint32_t cr1_clr = ADC_CR1_RES;
+    uint32_t cr1 = res << ADC_CR1_RES_Pos;
+    adc->CR1 = (adc->CR1 & ~cr1_clr) | cr1;
+    uint32_t cr2_clr = ADC_CR2_EXTEN | ADC_CR2_ALIGN | ADC_CR2_DMA | ADC_CR2_CONT;
+    uint32_t cr2 = 0;
+    adc->CR2 = (adc->CR2 & ~cr2_clr) | cr2;
+    adc->SQR1 = 1 << ADC_SQR1_L_Pos; // 1 conversion in regular sequence
+
+    #elif defined(STM32H7) || defined(STM32L4) || defined(STM32WB)
+
+    uint32_t cfgr_clr = ADC_CFGR_CONT | ADC_CFGR_EXTEN | ADC_CFGR_RES;
+    #if defined(STM32H7)
+    cfgr_clr |= ADC_CFGR_DMNGT;
+    #else
+    cfgr_clr |= ADC_CFGR_ALIGN | ADC_CFGR_DMAEN;
+    #endif
+    uint32_t cfgr = res << ADC_CFGR_RES_Pos;
+    adc->CFGR = (adc->CFGR & ~cfgr_clr) | cfgr;
+
+    #endif
+}
+
+STATIC int adc_get_bits(ADC_TypeDef *adc) {
+    #if defined(STM32F0) || defined(STM32L0)
+    uint32_t res = (adc->CFGR1 & ADC_CFGR1_RES) >> ADC_CFGR1_RES_Pos;
+    #elif defined(STM32F4) || defined(STM32F7)
+    uint32_t res = (adc->CR1 & ADC_CR1_RES) >> ADC_CR1_RES_Pos;
+    #elif defined(STM32H7) || defined(STM32L4) || defined(STM32WB)
+    uint32_t res = (adc->CFGR & ADC_CFGR_RES) >> ADC_CFGR_RES_Pos;
+    #endif
+    return adc_cr_to_bits_table[res];
+}
+
+STATIC void adc_config_channel(ADC_TypeDef *adc, uint32_t channel, uint32_t sample_time) {
+    #if ADC_V2
+    if (!(adc->CR & ADC_CR_ADEN)) {
+        if (adc->CR & 0x3f) {
+            // Cannot enable ADC with CR!=0
+            return;
+        }
+        adc->ISR = ADC_ISR_ADRDY; // clear ADRDY
+        adc->CR |= ADC_CR_ADEN;
+        adc_stabilisation_delay_us(ADC_STAB_DELAY_US);
+        while (!(adc->ISR & ADC_ISR_ADRDY)) {
+        }
+    }
+    #else
+    if (!(adc->CR2 & ADC_CR2_ADON)) {
+        adc->CR2 |= ADC_CR2_ADON;
+        adc_stabilisation_delay_us(ADC_STAB_DELAY_US);
+    }
+    #endif
+
+    #if defined(STM32F0) || defined(STM32L0)
+
+    if (channel == ADC_CHANNEL_VREFINT) {
+        ADC1_COMMON->CCR |= ADC_CCR_VREFEN;
+    } else if (channel == ADC_CHANNEL_TEMPSENSOR) {
+        ADC1_COMMON->CCR |= ADC_CCR_TSEN;
+        adc_stabilisation_delay_us(ADC_TEMPSENSOR_DELAY_US);
+    #if defined(ADC_CHANNEL_VBAT)
+    } else if (channel == ADC_CHANNEL_VBAT) {
+        ADC1_COMMON->CCR |= ADC_CCR_VBATEN;
+    #endif
+    }
+    adc->SMPR = sample_time << ADC_SMPR_SMP_Pos; // select sample time
+    adc->CHSELR = 1 << channel; // select channel for conversion
+
+    #elif defined(STM32F4) || defined(STM32F7)
+
+    if (channel == ADC_CHANNEL_VREFINT || channel == ADC_CHANNEL_TEMPSENSOR) {
+        ADCx_COMMON->CCR = (ADCx_COMMON->CCR & ~ADC_CCR_VBATE) | ADC_CCR_TSVREFE;
+        if (channel == ADC_CHANNEL_TEMPSENSOR) {
+            adc_stabilisation_delay_us(ADC_TEMPSENSOR_DELAY_US);
+        }
+    } else if (channel == ADC_CHANNEL_VBAT) {
+        ADCx_COMMON->CCR |= ADC_CCR_VBATE;
+    }
+
+    adc->SQR3 = (channel & 0x1f) << ADC_SQR3_SQ1_Pos; // select channel for first conversion
+
+    __IO uint32_t *smpr;
+    if (channel <= 9) {
+        smpr = &adc->SMPR2;
+    } else {
+        smpr = &adc->SMPR1;
+        channel -= 10;
+    }
+    *smpr = (*smpr & ~(7 << (channel * 3))) | sample_time << (channel * 3); // select sample time
+
+    #elif defined(STM32H7) || defined(STM32L4) || defined(STM32WB)
+
+    #if defined(STM32H7)
+    adc->PCSEL |= 1 << channel;
+    ADC_Common_TypeDef *adc_common = adc == ADC3 ? ADC3_COMMON : ADC12_COMMON;
+    #elif defined(STM32L4)
+    ADC_Common_TypeDef *adc_common = ADCx_COMMON;
+    #elif defined(STM32WB)
+    ADC_Common_TypeDef *adc_common = ADC1_COMMON;
+    #endif
+    if (channel == ADC_CHANNEL_VREFINT) {
+        adc_common->CCR |= ADC_CCR_VREFEN;
+    } else if (channel == ADC_CHANNEL_TEMPSENSOR) {
+        adc_common->CCR |= ADC_CCR_TSEN;
+        adc_stabilisation_delay_us(ADC_TEMPSENSOR_DELAY_US);
+    } else if (channel == ADC_CHANNEL_VBAT) {
+        adc_common->CCR |= ADC_CCR_VBATEN;
+    }
+    adc->SQR1 = (channel & 0x1f) << ADC_SQR1_SQ1_Pos | (1 - 1) << ADC_SQR1_L_Pos;
+    __IO uint32_t *smpr;
+    if (channel <= 9) {
+        smpr = &adc->SMPR1;
+    } else {
+        smpr = &adc->SMPR2;
+        channel -= 10;
+    }
+    *smpr = (*smpr & ~(7 << (channel * 3))) | sample_time << (channel * 3); // select sample time
+
+    #endif
+}
+
+STATIC uint32_t adc_read_channel(ADC_TypeDef *adc) {
+    #if ADC_V2
+    adc->CR |= ADC_CR_ADSTART;
+    #else
+    adc->CR2 |= ADC_CR2_SWSTART;
+    #endif
+    adc_wait_eoc(adc, ADC_EOC_TIMEOUT_MS);
+    uint32_t value = adc->DR;
+    return value;
+}
+
+STATIC uint32_t adc_config_and_read_u16(ADC_TypeDef *adc, uint32_t channel, uint32_t sample_time) {
+    if (channel == ADC_CHANNEL_VREF) {
+        return 0xffff;
+    }
+
+    adc_config_channel(adc, channel, sample_time);
+    uint32_t raw = adc_read_channel(adc);
+    uint32_t bits = adc_get_bits(adc);
+    // Scale raw reading to 16 bit value using a Taylor expansion (for 8 <= bits <= 16)
+    #if defined(STM32H7)
+    if (bits < 8) {
+        // For 6 and 7 bits
+        return raw << (16 - bits) | raw << (16 - 2 * bits) | raw >> (3 * bits - 16);
+    }
+    #endif
+    return raw << (16 - bits) | raw >> (2 * bits - 16);
+}
+
+/******************************************************************************/
+// MicroPython bindings for machine.ADC
+
+const mp_obj_type_t machine_adc_type;
+
+typedef struct _machine_adc_obj_t {
+    mp_obj_base_t base;
+    ADC_TypeDef *adc;
+    uint32_t channel;
+    uint32_t sample_time;
+} machine_adc_obj_t;
+
+STATIC void machine_adc_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    machine_adc_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    unsigned adc_id = 1;
+    #if defined(ADC2)
+    if (self->adc == ADC2) {
+        adc_id = 2;
+    }
+    #endif
+    #if defined(ADC3)
+    if (self->adc == ADC3) {
+        adc_id = 3;
+    }
+    #endif
+    mp_printf(print, "<ADC%u channel=%u>", adc_id, self->channel);
+}
+
+// ADC(id)
+STATIC mp_obj_t machine_adc_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    // Check number of arguments
+    mp_arg_check_num(n_args, n_kw, 1, 1, false);
+
+    mp_obj_t source = all_args[0];
+
+    uint32_t channel;
+    uint32_t sample_time = ADC_SAMPLETIME_DEFAULT;
+    ADC_TypeDef *adc;
+    if (mp_obj_is_int(source)) {
+        adc = ADC1;
+        channel = mp_obj_get_int(source);
+        if (channel == ADC_CHANNEL_VREFINT
+            || channel == ADC_CHANNEL_TEMPSENSOR
+            #if defined(ADC_CHANNEL_VBAT)
+            || channel == ADC_CHANNEL_VBAT
+            #endif
+            ) {
+            sample_time = ADC_SAMPLETIME_DEFAULT_INT;
+        }
+    } else {
+        const pin_obj_t *pin = pin_find(source);
+        if (pin->adc_num & PIN_ADC1) {
+            adc = ADC1;
+        #if defined(ADC2)
+        } else if (pin->adc_num & PIN_ADC2) {
+            adc = ADC2;
+        #endif
+        #if defined(ADC2)
+        } else if (pin->adc_num & PIN_ADC3) {
+            adc = ADC3;
+        #endif
+        } else {
+            // No ADC function on given pin
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Pin(%q) does not have ADC capabilities"), pin->name);
+        }
+        channel = pin->adc_channel;
+
+        // Configure the GPIO pin in ADC mode
+        mp_hal_pin_config(pin, MP_HAL_PIN_MODE_ADC, MP_HAL_PIN_PULL_NONE, 0);
+    }
+
+    adc_config(adc, 12);
+
+    machine_adc_obj_t *o = m_new_obj(machine_adc_obj_t);
+    o->base.type = &machine_adc_type;
+    o->adc = adc;
+    o->channel = channel;
+    o->sample_time = sample_time;
+
+    return MP_OBJ_FROM_PTR(o);
+}
+
+// read_u16()
+STATIC mp_obj_t machine_adc_read_u16(mp_obj_t self_in) {
+    machine_adc_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    return MP_OBJ_NEW_SMALL_INT(adc_config_and_read_u16(self->adc, self->channel, self->sample_time));
+}
+MP_DEFINE_CONST_FUN_OBJ_1(machine_adc_read_u16_obj, machine_adc_read_u16);
+
+STATIC const mp_rom_map_elem_t machine_adc_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_read_u16), MP_ROM_PTR(&machine_adc_read_u16_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_VREF), MP_ROM_INT(ADC_CHANNEL_VREF) },
+    { MP_ROM_QSTR(MP_QSTR_CORE_VREF), MP_ROM_INT(ADC_CHANNEL_VREFINT) },
+    { MP_ROM_QSTR(MP_QSTR_CORE_TEMP), MP_ROM_INT(ADC_CHANNEL_TEMPSENSOR) },
+    #if defined(ADC_CHANNEL_VBAT)
+    { MP_ROM_QSTR(MP_QSTR_CORE_VBAT), MP_ROM_INT(ADC_CHANNEL_VBAT) },
+    #endif
+};
+STATIC MP_DEFINE_CONST_DICT(machine_adc_locals_dict, machine_adc_locals_dict_table);
+
+const mp_obj_type_t machine_adc_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_ADC,
+    .print = machine_adc_print,
+    .make_new = machine_adc_make_new,
+    .locals_dict = (mp_obj_dict_t *)&machine_adc_locals_dict,
+};
diff --git a/ports/stm32/machine_i2c.c b/ports/stm32/machine_i2c.c
index 940e98d715fa8..14dd88b78f4dc 100644
--- a/ports/stm32/machine_i2c.c
+++ b/ports/stm32/machine_i2c.c
@@ -37,6 +37,8 @@
 
 STATIC const mp_obj_type_t machine_hard_i2c_type;
 
+#define I2C_POLL_DEFAULT_TIMEOUT_US (50000) // 50ms
+
 #if defined(STM32F0) || defined(STM32F4) || defined(STM32F7)
 
 typedef struct _machine_hard_i2c_obj_t {
@@ -46,26 +48,18 @@ typedef struct _machine_hard_i2c_obj_t {
     mp_hal_pin_obj_t sda;
 } machine_hard_i2c_obj_t;
 
-STATIC const machine_hard_i2c_obj_t machine_hard_i2c_obj[] = {
+STATIC const machine_hard_i2c_obj_t machine_hard_i2c_obj[MICROPY_HW_MAX_I2C] = {
     #if defined(MICROPY_HW_I2C1_SCL)
-    {{&machine_hard_i2c_type}, I2C1, MICROPY_HW_I2C1_SCL, MICROPY_HW_I2C1_SDA},
-    #else
-    {{NULL}, NULL, NULL, NULL},
+    [0] = {{&machine_hard_i2c_type}, I2C1, MICROPY_HW_I2C1_SCL, MICROPY_HW_I2C1_SDA},
     #endif
     #if defined(MICROPY_HW_I2C2_SCL)
-    {{&machine_hard_i2c_type}, I2C2, MICROPY_HW_I2C2_SCL, MICROPY_HW_I2C2_SDA},
-    #else
-    {{NULL}, NULL, NULL, NULL},
+    [1] = {{&machine_hard_i2c_type}, I2C2, MICROPY_HW_I2C2_SCL, MICROPY_HW_I2C2_SDA},
     #endif
     #if defined(MICROPY_HW_I2C3_SCL)
-    {{&machine_hard_i2c_type}, I2C3, MICROPY_HW_I2C3_SCL, MICROPY_HW_I2C3_SDA},
-    #else
-    {{NULL}, NULL, NULL, NULL},
+    [2] = {{&machine_hard_i2c_type}, I2C3, MICROPY_HW_I2C3_SCL, MICROPY_HW_I2C3_SDA},
     #endif
     #if defined(MICROPY_HW_I2C4_SCL)
-    {{&machine_hard_i2c_type}, I2C4, MICROPY_HW_I2C4_SCL, MICROPY_HW_I2C4_SDA},
-    #else
-    {{NULL}, NULL, NULL, NULL},
+    [3] = {{&machine_hard_i2c_type}, I2C4, MICROPY_HW_I2C4_SCL, MICROPY_HW_I2C4_SDA},
     #endif
 };
 
@@ -104,19 +98,39 @@ STATIC void machine_hard_i2c_print(const mp_print_t *print, mp_obj_t self_in, mp
     #endif
 }
 
-void machine_hard_i2c_init(machine_hard_i2c_obj_t *self, uint32_t freq, uint32_t timeout) {
-    (void)timeout;
-    i2c_init(self->i2c, self->scl, self->sda, freq);
+void machine_hard_i2c_init(machine_hard_i2c_obj_t *self, uint32_t freq, uint32_t timeout_us) {
+    uint32_t timeout_ms = (timeout_us + 999) / 1000;
+    i2c_init(self->i2c, self->scl, self->sda, freq, timeout_ms);
 }
 
-int machine_hard_i2c_readfrom(mp_obj_base_t *self_in, uint16_t addr, uint8_t *dest, size_t len, bool stop) {
+int machine_hard_i2c_transfer(mp_obj_base_t *self_in, uint16_t addr, size_t n, mp_machine_i2c_buf_t *bufs, unsigned int flags) {
     machine_hard_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    return i2c_readfrom(self->i2c, addr, dest, len, stop);
-}
 
-int machine_hard_i2c_writeto(mp_obj_base_t *self_in, uint16_t addr, const uint8_t *src, size_t len, bool stop) {
-    machine_hard_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    return i2c_writeto(self->i2c, addr, src, len, stop);
+    size_t remain_len = 0;
+    for (size_t i = 0; i < n; ++i) {
+        remain_len += bufs[i].len;
+    }
+
+    int ret = i2c_start_addr(self->i2c, flags & MP_MACHINE_I2C_FLAG_READ, addr, remain_len, flags & MP_MACHINE_I2C_FLAG_STOP);
+    if (ret < 0) {
+        return ret;
+    }
+
+    int num_acks = 0; // only valid for write; for read it'll be 0
+    for (; n--; ++bufs) {
+        remain_len -= bufs->len;
+        if (flags & MP_MACHINE_I2C_FLAG_READ) {
+            ret = i2c_read(self->i2c, bufs->buf, bufs->len, remain_len);
+        } else {
+            ret = i2c_write(self->i2c, bufs->buf, bufs->len, remain_len);
+        }
+        if (ret < 0) {
+            return ret;
+        }
+        num_acks += ret;
+    }
+
+    return num_acks;
 }
 
 #else
@@ -125,26 +139,18 @@ int machine_hard_i2c_writeto(mp_obj_base_t *self_in, uint16_t addr, const uint8_
 
 typedef mp_machine_soft_i2c_obj_t machine_hard_i2c_obj_t;
 
-STATIC machine_hard_i2c_obj_t machine_hard_i2c_obj[] = {
+STATIC machine_hard_i2c_obj_t machine_hard_i2c_obj[MICROPY_HW_MAX_I2C] = {
     #if defined(MICROPY_HW_I2C1_SCL)
-    {{&machine_hard_i2c_type}, 1, 500, MICROPY_HW_I2C1_SCL, MICROPY_HW_I2C1_SDA},
-    #else
-    {{NULL}, 0, 0, NULL, NULL},
+    [0] = {{&machine_hard_i2c_type}, 1, I2C_POLL_DEFAULT_TIMEOUT_US, MICROPY_HW_I2C1_SCL, MICROPY_HW_I2C1_SDA},
     #endif
     #if defined(MICROPY_HW_I2C2_SCL)
-    {{&machine_hard_i2c_type}, 1, 500, MICROPY_HW_I2C2_SCL, MICROPY_HW_I2C2_SDA},
-    #else
-    {{NULL}, 0, 0, NULL, NULL},
+    [1] = {{&machine_hard_i2c_type}, 1, I2C_POLL_DEFAULT_TIMEOUT_US, MICROPY_HW_I2C2_SCL, MICROPY_HW_I2C2_SDA},
     #endif
     #if defined(MICROPY_HW_I2C3_SCL)
-    {{&machine_hard_i2c_type}, 1, 500, MICROPY_HW_I2C3_SCL, MICROPY_HW_I2C3_SDA},
-    #else
-    {{NULL}, 0, 0, NULL, NULL},
+    [2] = {{&machine_hard_i2c_type}, 1, I2C_POLL_DEFAULT_TIMEOUT_US, MICROPY_HW_I2C3_SCL, MICROPY_HW_I2C3_SDA},
     #endif
     #if defined(MICROPY_HW_I2C4_SCL)
-    {{&machine_hard_i2c_type}, 1, 500, MICROPY_HW_I2C4_SCL, MICROPY_HW_I2C4_SDA},
-    #else
-    {{NULL}, 0, 0, NULL, NULL},
+    [3] = {{&machine_hard_i2c_type}, 1, I2C_POLL_DEFAULT_TIMEOUT_US, MICROPY_HW_I2C4_SCL, MICROPY_HW_I2C4_SDA},
     #endif
 };
 
@@ -174,23 +180,31 @@ STATIC void machine_hard_i2c_init(machine_hard_i2c_obj_t *self, uint32_t freq, u
     mp_hal_pin_open_drain(self->sda);
 }
 
-#define machine_hard_i2c_readfrom mp_machine_soft_i2c_readfrom
-#define machine_hard_i2c_writeto mp_machine_soft_i2c_writeto
+#define machine_hard_i2c_transfer mp_machine_soft_i2c_transfer
 
 #endif
 
 /******************************************************************************/
 /* MicroPython bindings for machine API                                       */
 
+#if defined(STM32F0) || defined(STM32F7)
+#define MACHINE_I2C_TIMINGR (1)
+#else
+#define MACHINE_I2C_TIMINGR (0)
+#endif
+
 mp_obj_t machine_hard_i2c_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
     // parse args
-    enum { ARG_id, ARG_scl, ARG_sda, ARG_freq, ARG_timeout };
+    enum { ARG_id, ARG_scl, ARG_sda, ARG_freq, ARG_timeout, ARG_timingr };
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_id, MP_ARG_REQUIRED | MP_ARG_OBJ },
         { MP_QSTR_scl, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
         { MP_QSTR_sda, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
         { MP_QSTR_freq, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 400000} },
-        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1000} },
+        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = I2C_POLL_DEFAULT_TIMEOUT_US} },
+        #if MACHINE_I2C_TIMINGR
+        { MP_QSTR_timingr, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        #endif
     };
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
@@ -212,36 +226,44 @@ mp_obj_t machine_hard_i2c_make_new(const mp_obj_type_t *type, size_t n_args, siz
         } else if (strcmp(port, MICROPY_HW_I2C3_NAME) == 0) {
             i2c_id = 3;
         #endif
+        #ifdef MICROPY_HW_I2C4_NAME
+        } else if (strcmp(port, MICROPY_HW_I2C4_NAME) == 0) {
+            i2c_id = 4;
+        #endif
         } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-                "I2C(%s) doesn't exist", port));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("I2C(%s) doesn't exist"), port);
         }
     } else {
         i2c_id = mp_obj_get_int(args[ARG_id].u_obj);
         if (i2c_id < 1 || i2c_id > MP_ARRAY_SIZE(machine_hard_i2c_obj)
             || machine_hard_i2c_obj[i2c_id - 1].base.type == NULL) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-                "I2C(%d) doesn't exist", i2c_id));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("I2C(%d) doesn't exist"), i2c_id);
         }
     }
 
     // get static peripheral object
-    machine_hard_i2c_obj_t *self = (machine_hard_i2c_obj_t*)&machine_hard_i2c_obj[i2c_id - 1];
+    machine_hard_i2c_obj_t *self = (machine_hard_i2c_obj_t *)&machine_hard_i2c_obj[i2c_id - 1];
 
     // here we would check the scl/sda pins and configure them, but it's not implemented
     if (args[ARG_scl].u_obj != MP_OBJ_NULL || args[ARG_sda].u_obj != MP_OBJ_NULL) {
-        mp_raise_ValueError("explicit choice of scl/sda is not implemented");
+        mp_raise_ValueError(MP_ERROR_TEXT("explicit choice of scl/sda is not implemented"));
     }
 
     // initialise the I2C peripheral
     machine_hard_i2c_init(self, args[ARG_freq].u_int, args[ARG_timeout].u_int);
 
+    #if MACHINE_I2C_TIMINGR
+    // If given, explicitly set the TIMINGR value
+    if (args[ARG_timingr].u_obj != mp_const_none) {
+        self->i2c->TIMINGR = mp_obj_get_int_truncated(args[ARG_timingr].u_obj);
+    }
+    #endif
+
     return MP_OBJ_FROM_PTR(self);
 }
 
 STATIC const mp_machine_i2c_p_t machine_hard_i2c_p = {
-    .readfrom = machine_hard_i2c_readfrom,
-    .writeto = machine_hard_i2c_writeto,
+    .transfer = machine_hard_i2c_transfer,
 };
 
 STATIC const mp_obj_type_t machine_hard_i2c_type = {
@@ -250,7 +272,7 @@ STATIC const mp_obj_type_t machine_hard_i2c_type = {
     .print = machine_hard_i2c_print,
     .make_new = machine_hard_i2c_make_new,
     .protocol = &machine_hard_i2c_p,
-    .locals_dict = (mp_obj_dict_t*)&mp_machine_soft_i2c_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&mp_machine_soft_i2c_locals_dict,
 };
 
 #endif // MICROPY_HW_ENABLE_HW_I2C
diff --git a/ports/stm32/machine_spi.c b/ports/stm32/machine_spi.c
index dedcafc8bfd02..cf6e96ab67bf6 100644
--- a/ports/stm32/machine_spi.c
+++ b/ports/stm32/machine_spi.c
@@ -69,7 +69,7 @@ mp_obj_t machine_hard_spi_make_new(const mp_obj_type_t *type, size_t n_args, siz
     if (args[ARG_sck].u_obj != MP_OBJ_NULL
         || args[ARG_mosi].u_obj != MP_OBJ_NULL
         || args[ARG_miso].u_obj != MP_OBJ_NULL) {
-        mp_raise_ValueError("explicit choice of sck/mosi/miso is not implemented");
+        mp_raise_ValueError(MP_ERROR_TEXT("explicit choice of sck/mosi/miso is not implemented"));
     }
 
     // set the SPI configuration values
@@ -95,7 +95,7 @@ mp_obj_t machine_hard_spi_make_new(const mp_obj_type_t *type, size_t n_args, siz
 }
 
 STATIC void machine_hard_spi_init(mp_obj_base_t *self_in, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    machine_hard_spi_obj_t *self = (machine_hard_spi_obj_t*)self_in;
+    machine_hard_spi_obj_t *self = (machine_hard_spi_obj_t *)self_in;
 
     enum { ARG_baudrate, ARG_polarity, ARG_phase, ARG_bits, ARG_firstbit };
     static const mp_arg_t allowed_args[] = {
@@ -118,12 +118,12 @@ STATIC void machine_hard_spi_init(mp_obj_base_t *self_in, size_t n_args, const m
 }
 
 STATIC void machine_hard_spi_deinit(mp_obj_base_t *self_in) {
-    machine_hard_spi_obj_t *self = (machine_hard_spi_obj_t*)self_in;
+    machine_hard_spi_obj_t *self = (machine_hard_spi_obj_t *)self_in;
     spi_deinit(self->spi);
 }
 
 STATIC void machine_hard_spi_transfer(mp_obj_base_t *self_in, size_t len, const uint8_t *src, uint8_t *dest) {
-    machine_hard_spi_obj_t *self = (machine_hard_spi_obj_t*)self_in;
+    machine_hard_spi_obj_t *self = (machine_hard_spi_obj_t *)self_in;
     spi_transfer(self->spi, len, src, dest, SPI_TRANSFER_TIMEOUT(len));
 }
 
@@ -139,5 +139,5 @@ const mp_obj_type_t machine_hard_spi_type = {
     .print = machine_hard_spi_print,
     .make_new = mp_machine_spi_make_new, // delegate to master constructor
     .protocol = &machine_hard_spi_p,
-    .locals_dict = (mp_obj_dict_t*)&mp_machine_spi_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&mp_machine_spi_locals_dict,
 };
diff --git a/ports/stm32/machine_timer.c b/ports/stm32/machine_timer.c
new file mode 100644
index 0000000000000..e9b16ab72f4b9
--- /dev/null
+++ b/ports/stm32/machine_timer.c
@@ -0,0 +1,132 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "softtimer.h"
+
+typedef soft_timer_entry_t machine_timer_obj_t;
+
+const mp_obj_type_t machine_timer_type;
+
+STATIC void machine_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    machine_timer_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    qstr mode = self->mode == SOFT_TIMER_MODE_ONE_SHOT ? MP_QSTR_ONE_SHOT : MP_QSTR_PERIODIC;
+    mp_printf(print, "Timer(mode=%q, period=%u)", mode, self->delta_ms);
+}
+
+STATIC mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_mode, ARG_callback, ARG_period, ARG_tick_hz, ARG_freq, };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_mode,         MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = SOFT_TIMER_MODE_PERIODIC} },
+        { MP_QSTR_callback,     MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_period,       MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0xffffffff} },
+        { MP_QSTR_tick_hz,      MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1000} },
+        { MP_QSTR_freq,         MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+    };
+
+    // Parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    self->mode = args[ARG_mode].u_int;
+    if (args[ARG_freq].u_obj != mp_const_none) {
+        // Frequency specified in Hz
+        #if MICROPY_PY_BUILTINS_FLOAT
+        self->delta_ms = (uint32_t)(MICROPY_FLOAT_CONST(1000.0) / mp_obj_get_float(args[ARG_freq].u_obj));
+        #else
+        self->delta_ms = 1000 / mp_obj_get_int(args[ARG_freq].u_obj);
+        #endif
+    } else {
+        // Period specified
+        self->delta_ms = args[ARG_period].u_int * 1000 / args[ARG_tick_hz].u_int;
+    }
+    if (self->delta_ms < 1) {
+        self->delta_ms = 1;
+    }
+    self->expiry_ms = mp_hal_ticks_ms() + self->delta_ms;
+
+    self->callback = args[ARG_callback].u_obj;
+    soft_timer_insert(self);
+
+    return mp_const_none;
+}
+
+STATIC mp_obj_t machine_timer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    machine_timer_obj_t *self = m_new_obj(machine_timer_obj_t);
+    self->pairheap.base.type = &machine_timer_type;
+
+    // Get timer id (only soft timer (-1) supported at the moment)
+    mp_int_t id = -1;
+    if (n_args > 0) {
+        id = mp_obj_get_int(args[0]);
+        --n_args;
+        ++args;
+    }
+    if (id != -1) {
+        mp_raise_ValueError(MP_ERROR_TEXT("Timer doesn't exist"));
+    }
+
+    if (n_args > 0 || n_kw > 0) {
+        // Start the timer
+        mp_map_t kw_args;
+        mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+        machine_timer_init_helper(self, n_args, args, &kw_args);
+    }
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC mp_obj_t machine_timer_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    machine_timer_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    soft_timer_remove(self);
+    return machine_timer_init_helper(self, n_args - 1, args + 1, kw_args);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_timer_init_obj, 1, machine_timer_init);
+
+STATIC mp_obj_t machine_timer_deinit(mp_obj_t self_in) {
+    machine_timer_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    soft_timer_remove(self);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_timer_deinit_obj, machine_timer_deinit);
+
+STATIC const mp_rom_map_elem_t machine_timer_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&machine_timer_init_obj) },
+    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_timer_deinit_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_ONE_SHOT), MP_ROM_INT(SOFT_TIMER_MODE_ONE_SHOT) },
+    { MP_ROM_QSTR(MP_QSTR_PERIODIC), MP_ROM_INT(SOFT_TIMER_MODE_PERIODIC) },
+};
+STATIC MP_DEFINE_CONST_DICT(machine_timer_locals_dict, machine_timer_locals_dict_table);
+
+const mp_obj_type_t machine_timer_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Timer,
+    .print = machine_timer_print,
+    .make_new = machine_timer_make_new,
+    .locals_dict = (mp_obj_dict_t *)&machine_timer_locals_dict,
+};
diff --git a/ports/stm32/machine_uart.c b/ports/stm32/machine_uart.c
index c1e594807146a..232f3629ee6b9 100644
--- a/ports/stm32/machine_uart.c
+++ b/ports/stm32/machine_uart.c
@@ -188,7 +188,7 @@ STATIC void pyb_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_print_k
             if (cr3 & USART_CR3_RTSE) {
                 mp_print_str(print, "RTS");
                 if (cr3 & USART_CR3_CTSE) {
-                   mp_print_str(print, "|");
+                    mp_print_str(print, "|");
                 }
             }
             if (cr3 & USART_CR3_CTSE) {
@@ -221,10 +221,10 @@ STATIC mp_obj_t pyb_uart_init_helper(pyb_uart_obj_t *self, size_t n_args, const
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_baudrate, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 9600} },
         { MP_QSTR_bits, MP_ARG_INT, {.u_int = 8} },
-        { MP_QSTR_parity, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_parity, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
         { MP_QSTR_stop, MP_ARG_INT, {.u_int = 1} },
         { MP_QSTR_flow, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = UART_HWCONTROL_NONE} },
-        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1000} },
+        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_timeout_char, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_rxbuf, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
         { MP_QSTR_read_buf_len, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 64} }, // legacy
@@ -235,11 +235,11 @@ STATIC mp_obj_t pyb_uart_init_helper(pyb_uart_obj_t *self, size_t n_args, const
         mp_arg_val_t baudrate, bits, parity, stop, flow, timeout, timeout_char, rxbuf, read_buf_len;
     } args;
     mp_arg_parse_all(n_args, pos_args, kw_args,
-        MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t*)&args);
+        MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t *)&args);
 
     // static UARTs are used for internal purposes and shouldn't be reconfigured
     if (self->is_static) {
-        mp_raise_ValueError("UART is static and can't be init'd");
+        mp_raise_ValueError(MP_ERROR_TEXT("UART is static and can't be init'd"));
     }
 
     // baudrate
@@ -266,14 +266,18 @@ STATIC mp_obj_t pyb_uart_init_helper(pyb_uart_obj_t *self, size_t n_args, const
         bits = UART_WORDLENGTH_7B;
     #endif
     } else {
-        mp_raise_ValueError("unsupported combination of bits and parity");
+        mp_raise_ValueError(MP_ERROR_TEXT("unsupported combination of bits and parity"));
     }
 
     // stop bits
     uint32_t stop;
     switch (args.stop.u_int) {
-        case 1: stop = UART_STOPBITS_1; break;
-        default: stop = UART_STOPBITS_2; break;
+        case 1:
+            stop = UART_STOPBITS_1;
+            break;
+        default:
+            stop = UART_STOPBITS_2;
+            break;
     }
 
     // flow control
@@ -281,7 +285,7 @@ STATIC mp_obj_t pyb_uart_init_helper(pyb_uart_obj_t *self, size_t n_args, const
 
     // init UART (if it fails, it's because the port doesn't exist)
     if (!uart_init(self, baudrate, bits, parity, stop, flow)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%d) doesn't exist", self->uart_id));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("UART(%d) doesn't exist"), self->uart_id);
     }
 
     // set timeout
@@ -323,7 +327,7 @@ STATIC mp_obj_t pyb_uart_init_helper(pyb_uart_obj_t *self, size_t n_args, const
         baudrate_diff = baudrate - actual_baudrate;
     }
     if (20 * baudrate_diff > actual_baudrate) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "set baudrate %d is not within 5%% of desired value", actual_baudrate));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("set baudrate %d is not within 5%% of desired value"), actual_baudrate);
     }
 
     return mp_const_none;
@@ -385,13 +389,21 @@ STATIC mp_obj_t pyb_uart_make_new(const mp_obj_type_t *type, size_t n_args, size
         } else if (strcmp(port, MICROPY_HW_UART8_NAME) == 0) {
             uart_id = PYB_UART_8;
         #endif
+        #ifdef MICROPY_HW_UART9_NAME
+        } else if (strcmp(port, MICROPY_HW_UART9_NAME) == 0) {
+            uart_id = PYB_UART_9;
+        #endif
+        #ifdef MICROPY_HW_UART10_NAME
+        } else if (strcmp(port, MICROPY_HW_UART10_NAME) == 0) {
+            uart_id = PYB_UART_10;
+        #endif
         } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%s) doesn't exist", port));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("UART(%s) doesn't exist"), port);
         }
     } else {
         uart_id = mp_obj_get_int(args[0]);
         if (!uart_exists(uart_id)) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%d) doesn't exist", uart_id));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("UART(%d) doesn't exist"), uart_id);
         }
     }
 
@@ -481,7 +493,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_uart_readchar_obj, pyb_uart_readchar);
 // uart.sendbreak()
 STATIC mp_obj_t pyb_uart_sendbreak(mp_obj_t self_in) {
     pyb_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    #if defined(STM32F0) || defined(STM32F7) || defined(STM32L4) || defined(STM32H7)
+    #if defined(STM32F0) || defined(STM32F7) || defined(STM32L0) || defined(STM32L4) || defined(STM32H7) || defined(STM32WB)
     self->uartx->RQR = USART_RQR_SBKRQ; // write-only register
     #else
     self->uartx->CR1 |= USART_CR1_SBK;
@@ -505,14 +517,14 @@ STATIC mp_obj_t pyb_uart_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
         // Check the handler
         mp_obj_t handler = args[MP_IRQ_ARG_INIT_handler].u_obj;
         if (handler != mp_const_none && !mp_obj_is_callable(handler)) {
-            mp_raise_ValueError("handler must be None or callable");
+            mp_raise_ValueError(MP_ERROR_TEXT("handler must be None or callable"));
         }
 
         // Check the trigger
         mp_uint_t trigger = args[MP_IRQ_ARG_INIT_trigger].u_int;
         mp_uint_t not_supported = trigger & ~mp_irq_allowed;
         if (trigger != 0 && not_supported) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "trigger 0x%08x unsupported", not_supported));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("trigger 0x%08x unsupported"), not_supported);
         }
 
         // Reconfigure user IRQs
@@ -588,7 +600,7 @@ STATIC mp_uint_t pyb_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, i
     for (;;) {
         int data = uart_rx_char(self);
         if (self->char_width == CHAR_WIDTH_9BIT) {
-            *(uint16_t*)buf = data;
+            *(uint16_t *)buf = data;
             buf += 2;
         } else {
             *buf++ = data;
@@ -661,5 +673,5 @@ const mp_obj_type_t pyb_uart_type = {
     .getiter = mp_identity_getiter,
     .iternext = mp_stream_unbuffered_iter,
     .protocol = &uart_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&pyb_uart_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_uart_locals_dict,
 };
diff --git a/ports/stm32/main.c b/ports/stm32/main.c
index 8c2d7d529ae02..b5dbfa50fd5cc 100644
--- a/ports/stm32/main.c
+++ b/ports/stm32/main.c
@@ -30,22 +30,39 @@
 #include "py/runtime.h"
 #include "py/stackctrl.h"
 #include "py/gc.h"
+#include "py/mperrno.h"
 #include "py/mphal.h"
 #include "lib/mp-readline/readline.h"
 #include "lib/utils/pyexec.h"
 #include "lib/oofatfs/ff.h"
+#include "lib/littlefs/lfs1.h"
+#include "lib/littlefs/lfs1_util.h"
+#include "lib/littlefs/lfs2.h"
+#include "lib/littlefs/lfs2_util.h"
 #include "extmod/vfs.h"
 #include "extmod/vfs_fat.h"
+#include "extmod/vfs_lfs.h"
 
 #if MICROPY_PY_LWIP
 #include "lwip/init.h"
+#include "lwip/apps/mdns.h"
+#include "drivers/cyw43/cyw43.h"
 #endif
 
+#if MICROPY_PY_BLUETOOTH
+#include "extmod/modbluetooth.h"
+#endif
+
+#include "mpu.h"
+#include "rfcore.h"
 #include "systick.h"
 #include "pendsv.h"
+#include "powerctrl.h"
 #include "pybthread.h"
 #include "gccollect.h"
+#include "factoryreset.h"
 #include "modmachine.h"
+#include "softtimer.h"
 #include "i2c.h"
 #include "spi.h"
 #include "uart.h"
@@ -66,19 +83,13 @@
 #include "can.h"
 #include "modnetwork.h"
 
-void SystemClock_Config(void);
-
 #if MICROPY_PY_THREAD
 STATIC pyb_thread_t pyb_thread_main;
 #endif
 
-#if MICROPY_HW_ENABLE_STORAGE
-STATIC fs_user_mount_t fs_user_mount_flash;
-#endif
-
 #if defined(MICROPY_HW_UART_REPL)
 #ifndef MICROPY_HW_UART_REPL_RXBUF
-#define MICROPY_HW_UART_REPL_RXBUF (64)
+#define MICROPY_HW_UART_REPL_RXBUF (260)
 #endif
 STATIC pyb_uart_obj_t pyb_uart_repl_obj;
 STATIC uint8_t pyb_uart_repl_rxbuf[MICROPY_HW_UART_REPL_RXBUF];
@@ -141,143 +152,78 @@ STATIC mp_obj_t pyb_main(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_a
         // parse args
         mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
         mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+        #if MICROPY_ENABLE_COMPILER
         MP_STATE_VM(mp_optimise_value) = args[0].u_int;
+        #endif
     }
     return mp_const_none;
 }
 MP_DEFINE_CONST_FUN_OBJ_KW(pyb_main_obj, 1, pyb_main);
 
 #if MICROPY_HW_ENABLE_STORAGE
-static const char fresh_boot_py[] =
-"# boot.py -- run on boot-up\r\n"
-"# can run arbitrary Python, but best to keep it minimal\r\n"
-"\r\n"
-"import machine\r\n"
-"import pyb\r\n"
-"#pyb.main('main.py') # main script to run after this one\r\n"
-#if MICROPY_HW_ENABLE_USB
-"#pyb.usb_mode('VCP+MSC') # act as a serial and a storage device\r\n"
-"#pyb.usb_mode('VCP+HID') # act as a serial device and a mouse\r\n"
-#endif
-;
-
-static const char fresh_main_py[] =
-"# main.py -- put your code here!\r\n"
-;
-
-static const char fresh_pybcdc_inf[] =
-#include "genhdr/pybcdc_inf.h"
-;
-
-static const char fresh_readme_txt[] =
-"This is a MicroPython board\r\n"
-"\r\n"
-"You can get started right away by writing your Python code in 'main.py'.\r\n"
-"\r\n"
-"For a serial prompt:\r\n"
-" - Windows: you need to go to 'Device manager', right click on the unknown device,\r\n"
-"   then update the driver software, using the 'pybcdc.inf' file found on this drive.\r\n"
-"   Then use a terminal program like Hyperterminal or putty.\r\n"
-" - Mac OS X: use the command: screen /dev/tty.usbmodem*\r\n"
-" - Linux: use the command: screen /dev/ttyACM0\r\n"
-"\r\n"
-"Please visit http://micropython.org/help/ for further help.\r\n"
-;
-
 // avoid inlining to avoid stack usage within main()
 MP_NOINLINE STATIC bool init_flash_fs(uint reset_mode) {
-    // init the vfs object
-    fs_user_mount_t *vfs_fat = &fs_user_mount_flash;
-    vfs_fat->flags = 0;
-    pyb_flash_init_vfs(vfs_fat);
+    if (reset_mode == 3) {
+        // Asked by user to reset filesystem
+        factory_reset_create_filesystem();
+    }
 
-    // try to mount the flash
-    FRESULT res = f_mount(&vfs_fat->fatfs);
+    // Default block device to entire flash storage
+    mp_obj_t bdev = MP_OBJ_FROM_PTR(&pyb_flash_obj);
 
-    if (reset_mode == 3 || res == FR_NO_FILESYSTEM) {
-        // no filesystem, or asked to reset it, so create a fresh one
+    #if MICROPY_VFS_LFS1 || MICROPY_VFS_LFS2
 
-        // LED on to indicate creation of LFS
-        led_state(PYB_LED_GREEN, 1);
-        uint32_t start_tick = HAL_GetTick();
+    // Try to detect the block device used for the main filesystem, based on the first block
 
-        uint8_t working_buf[FF_MAX_SS];
-        res = f_mkfs(&vfs_fat->fatfs, FM_FAT, 0, working_buf, sizeof(working_buf));
-        if (res == FR_OK) {
-            // success creating fresh LFS
-        } else {
-            printf("MPY: can't create flash filesystem\n");
-            return false;
-        }
+    uint8_t buf[FLASH_BLOCK_SIZE];
+    storage_read_blocks(buf, FLASH_PART1_START_BLOCK, 1);
 
-        // set label
-        f_setlabel(&vfs_fat->fatfs, MICROPY_HW_FLASH_FS_LABEL);
-
-        // create empty main.py
-        FIL fp;
-        f_open(&vfs_fat->fatfs, &fp, "/main.py", FA_WRITE | FA_CREATE_ALWAYS);
-        UINT n;
-        f_write(&fp, fresh_main_py, sizeof(fresh_main_py) - 1 /* don't count null terminator */, &n);
-        // TODO check we could write n bytes
-        f_close(&fp);
-
-        // create .inf driver file
-        f_open(&vfs_fat->fatfs, &fp, "/pybcdc.inf", FA_WRITE | FA_CREATE_ALWAYS);
-        f_write(&fp, fresh_pybcdc_inf, sizeof(fresh_pybcdc_inf) - 1 /* don't count null terminator */, &n);
-        f_close(&fp);
-
-        // create readme file
-        f_open(&vfs_fat->fatfs, &fp, "/README.txt", FA_WRITE | FA_CREATE_ALWAYS);
-        f_write(&fp, fresh_readme_txt, sizeof(fresh_readme_txt) - 1 /* don't count null terminator */, &n);
-        f_close(&fp);
-
-        // keep LED on for at least 200ms
-        systick_wait_at_least(start_tick, 200);
-        led_state(PYB_LED_GREEN, 0);
-    } else if (res == FR_OK) {
-        // mount sucessful
-    } else {
-    fail:
-        printf("MPY: can't mount flash\n");
-        return false;
+    mp_int_t len = -1;
+
+    #if MICROPY_VFS_LFS1
+    if (memcmp(&buf[40], "littlefs", 8) == 0) {
+        // LFS1
+        lfs1_superblock_t *superblock = (void *)&buf[12];
+        uint32_t block_size = lfs1_fromle32(superblock->d.block_size);
+        uint32_t block_count = lfs1_fromle32(superblock->d.block_count);
+        len = block_count * block_size;
     }
+    #endif
 
-    // mount the flash device (there should be no other devices mounted at this point)
-    // we allocate this structure on the heap because vfs->next is a root pointer
-    mp_vfs_mount_t *vfs = m_new_obj_maybe(mp_vfs_mount_t);
-    if (vfs == NULL) {
-        goto fail;
+    #if MICROPY_VFS_LFS2
+    if (memcmp(&buf[8], "littlefs", 8) == 0) {
+        // LFS2
+        lfs2_superblock_t *superblock = (void *)&buf[20];
+        uint32_t block_size = lfs2_fromle32(superblock->block_size);
+        uint32_t block_count = lfs2_fromle32(superblock->block_count);
+        len = block_count * block_size;
     }
-    vfs->str = "/flash";
-    vfs->len = 6;
-    vfs->obj = MP_OBJ_FROM_PTR(vfs_fat);
-    vfs->next = NULL;
-    MP_STATE_VM(vfs_mount_table) = vfs;
-
-    // The current directory is used as the boot up directory.
-    // It is set to the internal flash filesystem by default.
-    MP_STATE_PORT(vfs_cur) = vfs;
-
-    // Make sure we have a /flash/boot.py.  Create it if needed.
-    FILINFO fno;
-    res = f_stat(&vfs_fat->fatfs, "/boot.py", &fno);
-    if (res != FR_OK) {
-        // doesn't exist, create fresh file
-
-        // LED on to indicate creation of boot.py
-        led_state(PYB_LED_GREEN, 1);
-        uint32_t start_tick = HAL_GetTick();
+    #endif
+
+    if (len != -1) {
+        // Detected a littlefs filesystem so create correct block device for it
+        mp_obj_t args[] = { MP_OBJ_NEW_QSTR(MP_QSTR_len), MP_OBJ_NEW_SMALL_INT(len) };
+        bdev = pyb_flash_type.make_new(&pyb_flash_type, 0, 1, args);
+    }
+
+    #endif
 
-        FIL fp;
-        f_open(&vfs_fat->fatfs, &fp, "/boot.py", FA_WRITE | FA_CREATE_ALWAYS);
-        UINT n;
-        f_write(&fp, fresh_boot_py, sizeof(fresh_boot_py) - 1 /* don't count null terminator */, &n);
-        // TODO check we could write n bytes
-        f_close(&fp);
+    // Try to mount the flash on "/flash" and chdir to it for the boot-up directory.
+    mp_obj_t mount_point = MP_OBJ_NEW_QSTR(MP_QSTR__slash_flash);
+    int ret = mp_vfs_mount_and_chdir_protected(bdev, mount_point);
 
-        // keep LED on for at least 200ms
-        systick_wait_at_least(start_tick, 200);
-        led_state(PYB_LED_GREEN, 0);
+    if (ret == -MP_ENODEV && bdev == MP_OBJ_FROM_PTR(&pyb_flash_obj) && reset_mode != 3) {
+        // No filesystem, bdev is still the default (so didn't detect a possibly corrupt littlefs),
+        // and didn't already create a filesystem, so try to create a fresh one now.
+        ret = factory_reset_create_filesystem();
+        if (ret == 0) {
+            ret = mp_vfs_mount_and_chdir_protected(bdev, mount_point);
+        }
+    }
+
+    if (ret != 0) {
+        printf("MPY: can't mount flash\n");
+        return false;
     }
 
     return true;
@@ -294,7 +240,7 @@ STATIC bool init_sdcard_fs(void) {
         if (vfs == NULL || vfs_fat == NULL) {
             break;
         }
-        vfs_fat->flags = FSUSER_FREE_OBJ;
+        vfs_fat->blockdev.flags = MP_BLOCKDEV_FLAG_FREE_OBJ;
         sdcard_init_vfs(vfs_fat, part_num);
 
         // try to mount the partition
@@ -314,7 +260,7 @@ STATIC bool init_sdcard_fs(void) {
                 // subsequent partitions are numbered by their index in the partition table
                 if (part_num == 2) {
                     vfs->str = "/sd2";
-                } else if (part_num == 2) {
+                } else if (part_num == 3) {
                     vfs->str = "/sd3";
                 } else {
                     vfs->str = "/sd4";
@@ -438,6 +384,17 @@ STATIC uint update_reset_mode(uint reset_mode) {
 #endif
 
 void stm32_main(uint32_t reset_mode) {
+    #if !defined(STM32F0) && defined(MICROPY_HW_VTOR)
+    // Change IRQ vector table if configured differently
+    SCB->VTOR = MICROPY_HW_VTOR;
+    #endif
+
+    // Enable 8-byte stack alignment for IRQ handlers, in accord with EABI
+    SCB->CCR |= SCB_CCR_STKALIGN_Msk;
+
+    // Check if bootloader should be entered instead of main application
+    powerctrl_check_enter_bootloader();
+
     // Enable caches and prefetch buffers
 
     #if defined(STM32F4)
@@ -475,6 +432,8 @@ void stm32_main(uint32_t reset_mode) {
 
     #endif
 
+    mpu_init();
+
     #if __CORTEX_M >= 0x03
     // Set the priority grouping
     NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
@@ -494,20 +453,20 @@ void stm32_main(uint32_t reset_mode) {
     __HAL_RCC_GPIOD_CLK_ENABLE();
     #endif
 
-    #if defined(STM32F4) ||  defined(STM32F7)
-        #if defined(__HAL_RCC_DTCMRAMEN_CLK_ENABLE)
-        // The STM32F746 doesn't really have CCM memory, but it does have DTCM,
-        // which behaves more or less like normal SRAM.
-        __HAL_RCC_DTCMRAMEN_CLK_ENABLE();
-        #elif defined(CCMDATARAM_BASE)
-        // enable the CCM RAM
-        __HAL_RCC_CCMDATARAMEN_CLK_ENABLE();
-        #endif
+    #if defined(STM32F4) || defined(STM32F7)
+    #if defined(__HAL_RCC_DTCMRAMEN_CLK_ENABLE)
+    // The STM32F746 doesn't really have CCM memory, but it does have DTCM,
+    // which behaves more or less like normal SRAM.
+    __HAL_RCC_DTCMRAMEN_CLK_ENABLE();
+    #elif defined(CCMDATARAM_BASE)
+    // enable the CCM RAM
+    __HAL_RCC_CCMDATARAMEN_CLK_ENABLE();
+    #endif
     #elif defined(STM32H7)
-        // Enable D2 SRAM1/2/3 clocks.
-        __HAL_RCC_D2SRAM1_CLK_ENABLE();
-        __HAL_RCC_D2SRAM2_CLK_ENABLE();
-        __HAL_RCC_D2SRAM3_CLK_ENABLE();
+    // Enable D2 SRAM1/2/3 clocks.
+    __HAL_RCC_D2SRAM1_CLK_ENABLE();
+    __HAL_RCC_D2SRAM2_CLK_ENABLE();
+    __HAL_RCC_D2SRAM3_CLK_ENABLE();
     #endif
 
 
@@ -516,10 +475,15 @@ void stm32_main(uint32_t reset_mode) {
     #endif
 
     // basic sub-system init
+    #if defined(STM32WB)
+    rfcore_init();
+    #endif
     #if MICROPY_HW_SDRAM_SIZE
     sdram_init();
+    bool sdram_valid = true;
+    UNUSED(sdram_valid);
     #if MICROPY_HW_SDRAM_STARTUP_TEST
-    sdram_test(true);
+    sdram_valid = sdram_test(true);
     #endif
     #endif
     #if MICROPY_PY_THREAD
@@ -550,8 +514,26 @@ void stm32_main(uint32_t reset_mode) {
     // because the system timeout list (next_timeout) is only ever reset by BSS clearing.
     // So for now we only init the lwIP stack once on power-up.
     lwip_init();
+    #if LWIP_MDNS_RESPONDER
+    mdns_resp_init();
+    #endif
     systick_enable_dispatch(SYSTICK_DISPATCH_LWIP, mod_network_lwip_poll_wrapper);
     #endif
+    #if MICROPY_PY_BLUETOOTH
+    extern void mp_bluetooth_hci_poll_wrapper(uint32_t ticks_ms);
+    systick_enable_dispatch(SYSTICK_DISPATCH_BLUETOOTH_HCI, mp_bluetooth_hci_poll_wrapper);
+    #endif
+
+    #if MICROPY_PY_NETWORK_CYW43
+    {
+        cyw43_init(&cyw43_state);
+        uint8_t buf[8];
+        memcpy(&buf[0], "PYBD", 4);
+        mp_hal_get_mac_ascii(MP_HAL_MAC_WLAN0, 8, 4, (char *)&buf[4]);
+        cyw43_wifi_ap_set_ssid(&cyw43_state, 8, buf);
+        cyw43_wifi_ap_set_password(&cyw43_state, 8, (const uint8_t *)"pybd0123");
+    }
+    #endif
 
     #if defined(MICROPY_HW_UART_REPL)
     // Set up a UART REPL using a statically allocated object
@@ -592,7 +574,7 @@ void stm32_main(uint32_t reset_mode) {
     // to recover from limit hit.  (Limit is measured in bytes.)
     // Note: stack control relies on main thread being initialised above
     mp_stack_set_top(&_estack);
-    mp_stack_set_limit((char*)&_estack - (char*)&_heap_end - 1024);
+    mp_stack_set_limit((char *)&_estack - (char *)&_sstack - 1024);
 
     // GC init
     gc_init(MICROPY_HEAP_START, MICROPY_HEAP_END);
@@ -630,10 +612,6 @@ void stm32_main(uint32_t reset_mode) {
 
     #if MICROPY_HW_ENABLE_USB
     pyb_usb_init0();
-
-    // Activate USB_VCP(0) on dupterm slot 1 for the REPL
-    MP_STATE_VM(dupterm_objs[1]) = MP_OBJ_FROM_PTR(&pyb_usb_vcp_obj);
-    usb_vcp_attach_to_repl(&pyb_usb_vcp_obj, true);
     #endif
 
     // Initialise the local flash filesystem.
@@ -648,7 +626,7 @@ void stm32_main(uint32_t reset_mode) {
     // if an SD card is present then mount it on /sd/
     if (sdcard_is_present()) {
         // if there is a file in the flash called "SKIPSD", then we don't mount the SD card
-        if (!mounted_flash || f_stat(&fs_user_mount_flash.fatfs, "/SKIPSD", NULL) != FR_OK) {
+        if (!mounted_flash || mp_vfs_import_stat("SKIPSD") == MP_IMPORT_STAT_NO_EXIST) {
             mounted_sdcard = init_sdcard_fs();
         }
     }
@@ -678,15 +656,12 @@ void stm32_main(uint32_t reset_mode) {
     // TODO perhaps have pyb.reboot([bootpy]) function to soft-reboot and execute custom boot.py
     if (reset_mode == 1 || reset_mode == 3) {
         const char *boot_py = "boot.py";
-        mp_import_stat_t stat = mp_import_stat(boot_py);
-        if (stat == MP_IMPORT_STAT_FILE) {
-            int ret = pyexec_file(boot_py);
-            if (ret & PYEXEC_FORCED_EXIT) {
-                goto soft_reset_exit;
-            }
-            if (!ret) {
-                flash_error(4);
-            }
+        int ret = pyexec_file_if_exists(boot_py);
+        if (ret & PYEXEC_FORCED_EXIT) {
+            goto soft_reset_exit;
+        }
+        if (!ret) {
+            flash_error(4);
         }
     }
 
@@ -708,7 +683,14 @@ void stm32_main(uint32_t reset_mode) {
     #if MICROPY_HW_ENABLE_USB
     // init USB device to default setting if it was not already configured
     if (!(pyb_usb_flags & PYB_USB_FLAG_USB_MODE_CALLED)) {
-        pyb_usb_dev_init(USBD_VID, USBD_PID_CDC_MSC, USBD_MODE_CDC_MSC, NULL);
+        #if MICROPY_HW_USB_MSC
+        const uint16_t pid = USBD_PID_CDC_MSC;
+        const uint8_t mode = USBD_MODE_CDC_MSC;
+        #else
+        const uint16_t pid = USBD_PID_CDC;
+        const uint8_t mode = USBD_MODE_CDC;
+        #endif
+        pyb_usb_dev_init(pyb_usb_dev_detect(), USBD_VID, pid, mode, 0, NULL, NULL);
     }
     #endif
 
@@ -721,10 +703,6 @@ void stm32_main(uint32_t reset_mode) {
     servo_init();
     #endif
 
-    #if MICROPY_HW_ENABLE_DAC
-    dac_init();
-    #endif
-
     #if MICROPY_PY_NETWORK
     mod_network_init();
     #endif
@@ -739,18 +717,16 @@ void stm32_main(uint32_t reset_mode) {
         } else {
             main_py = mp_obj_str_get_str(MP_STATE_PORT(pyb_config_main));
         }
-        mp_import_stat_t stat = mp_import_stat(main_py);
-        if (stat == MP_IMPORT_STAT_FILE) {
-            int ret = pyexec_file(main_py);
-            if (ret & PYEXEC_FORCED_EXIT) {
-                goto soft_reset_exit;
-            }
-            if (!ret) {
-                flash_error(3);
-            }
+        int ret = pyexec_file_if_exists(main_py);
+        if (ret & PYEXEC_FORCED_EXIT) {
+            goto soft_reset_exit;
+        }
+        if (!ret) {
+            flash_error(3);
         }
     }
 
+    #if MICROPY_ENABLE_COMPILER
     // Main script is finished, so now go into REPL mode.
     // The REPL mode can change, or it can request a soft reset.
     for (;;) {
@@ -764,6 +740,7 @@ void stm32_main(uint32_t reset_mode) {
             }
         }
     }
+    #endif
 
 soft_reset_exit:
 
@@ -775,13 +752,17 @@ void stm32_main(uint32_t reset_mode) {
     #endif
 
     printf("MPY: soft reboot\n");
+    #if MICROPY_PY_BLUETOOTH
+    mp_bluetooth_deinit();
+    #endif
     #if MICROPY_PY_NETWORK
     mod_network_deinit();
     #endif
+    soft_timer_deinit();
     timer_deinit();
     uart_deinit_all();
     #if MICROPY_HW_ENABLE_CAN
-    can_deinit();
+    can_deinit_all();
     #endif
     machine_deinit();
 
diff --git a/ports/stm32/make-stmconst.py b/ports/stm32/make-stmconst.py
index cfcc12f59e1d1..1b3cc08d951f3 100644
--- a/ports/stm32/make-stmconst.py
+++ b/ports/stm32/make-stmconst.py
@@ -11,16 +11,23 @@
 
 # Python 2/3 compatibility
 import platform
-if platform.python_version_tuple()[0] == '2':
+
+if platform.python_version_tuple()[0] == "2":
+
     def convert_bytes_to_str(b):
         return b
-elif platform.python_version_tuple()[0] == '3':
+
+
+elif platform.python_version_tuple()[0] == "3":
+
     def convert_bytes_to_str(b):
         try:
-            return str(b, 'utf8')
+            return str(b, "utf8")
         except ValueError:
             # some files have invalid utf8 bytes, so filter them out
-            return ''.join(chr(l) for l in b if l <= 126)
+            return "".join(chr(l) for l in b if l <= 126)
+
+
 # end compatibility code
 
 # given a list of (name,regex) pairs, find the first one that matches the given line
@@ -31,29 +38,64 @@ def re_match_first(regexs, line):
             return name, match
     return None, None
 
+
 class LexerError(Exception):
     def __init__(self, line):
         self.line = line
 
+
 class Lexer:
-    re_io_reg = r'__IO uint(?P<bits>8|16|32)_t +(?P<reg>[A-Z0-9]+)'
-    re_comment = r'(?P<comment>[A-Za-z0-9 \-/_()&]+)'
-    re_addr_offset = r'Address offset: (?P<offset>0x[0-9A-Z]{2,3})'
+    re_io_reg = r"__IO uint(?P<bits>8|16|32)_t +(?P<reg>[A-Z0-9]+)"
+    re_comment = r"(?P<comment>[A-Za-z0-9 \-/_()&]+)"
+    re_addr_offset = r"Address offset: (?P<offset>0x[0-9A-Z]{2,3})"
     regexs = (
-        ('#define hex', re.compile(r'#define +(?P<id>[A-Z0-9_]+) +(?:\(\(uint32_t\))?(?P<hex>0x[0-9A-F]+)U?(?:\))?($| +/\*)')),
-        ('#define X', re.compile(r'#define +(?P<id>[A-Z0-9_]+) +(?P<id2>[A-Z0-9_]+)($| +/\*)')),
-        ('#define X+hex', re.compile(r'#define +(?P<id>[A-Za-z0-9_]+) +\((?P<id2>[A-Z0-9_]+) \+ (?P<hex>0x[0-9A-F]+)U?\)($| +/\*)')),
-        ('#define typedef', re.compile(r'#define +(?P<id>[A-Z0-9_]+(ext)?) +\(\([A-Za-z0-9_]+_TypeDef \*\) (?P<id2>[A-Za-z0-9_]+)\)($| +/\*)')),
-        ('typedef struct', re.compile(r'typedef struct$')),
-        ('{', re.compile(r'{$')),
-        ('}', re.compile(r'}$')),
-        ('} TypeDef', re.compile(r'} *(?P<id>[A-Z][A-Za-z0-9_]+)_(?P<global>([A-Za-z0-9_]+)?)TypeDef;$')),
-        ('IO reg', re.compile(re_io_reg + r'; */\*!< *' + re_comment + r', +' + re_addr_offset + r' *\*/')),
-        ('IO reg array', re.compile(re_io_reg + r'\[(?P<array>[2-8])\]; */\*!< *' + re_comment + r', +' + re_addr_offset + r'-(0x[0-9A-Z]{2,3}) *\*/')),
+        (
+            "#define hex",
+            re.compile(
+                r"#define +(?P<id>[A-Z0-9_]+) +\(?(\(uint32_t\))?(?P<hex>0x[0-9A-F]+)U?L?\)?($| */\*)"
+            ),
+        ),
+        ("#define X", re.compile(r"#define +(?P<id>[A-Z0-9_]+) +(?P<id2>[A-Z0-9_]+)($| +/\*)")),
+        (
+            "#define X+hex",
+            re.compile(
+                r"#define +(?P<id>[A-Za-z0-9_]+) +\(?(?P<id2>[A-Z0-9_]+) \+ (?P<hex>0x[0-9A-F]+)U?L?\)?($| +/\*)"
+            ),
+        ),
+        (
+            "#define typedef",
+            re.compile(
+                r"#define +(?P<id>[A-Z0-9_]+(ext)?) +\(\([A-Za-z0-9_]+_TypeDef \*\) (?P<id2>[A-Za-z0-9_]+)\)($| +/\*)"
+            ),
+        ),
+        ("typedef struct", re.compile(r"typedef struct$")),
+        ("{", re.compile(r"{$")),
+        ("}", re.compile(r"}$")),
+        (
+            "} TypeDef",
+            re.compile(r"} *(?P<id>[A-Z][A-Za-z0-9_]+)_(?P<global>([A-Za-z0-9_]+)?)TypeDef;$"),
+        ),
+        (
+            "IO reg",
+            re.compile(
+                re_io_reg + r"; */\*!< *" + re_comment + r", +" + re_addr_offset + r" *\*/"
+            ),
+        ),
+        (
+            "IO reg array",
+            re.compile(
+                re_io_reg
+                + r"\[(?P<array>[2-8])\]; */\*!< *"
+                + re_comment
+                + r", +"
+                + re_addr_offset
+                + r"-(0x[0-9A-Z]{2,3}) *\*/"
+            ),
+        ),
     )
 
     def __init__(self, filename):
-        self.file = open(filename, 'rb')
+        self.file = open(filename, "rb")
         self.line_number = 0
 
     def next_match(self, strictly_next=False):
@@ -62,7 +104,7 @@ def next_match(self, strictly_next=False):
             line = convert_bytes_to_str(line)
             self.line_number += 1
             if len(line) == 0:
-                return ('EOF', None)
+                return ("EOF", None)
             match = re_match_first(Lexer.regexs, line.strip())
             if strictly_next or match[0] is not None:
                 return match
@@ -73,6 +115,7 @@ def must_match(self, kind):
             raise LexerError(self.line_number)
         return match
 
+
 def parse_file(filename):
     lexer = Lexer(filename)
 
@@ -81,71 +124,75 @@ def parse_file(filename):
     periphs = []
     while True:
         m = lexer.next_match()
-        if m[0] == 'EOF':
+        if m[0] == "EOF":
             break
-        elif m[0] == '#define hex':
+        elif m[0] == "#define hex":
             d = m[1].groupdict()
-            consts[d['id']] = int(d['hex'], base=16)
-        elif m[0] == '#define X':
+            consts[d["id"]] = int(d["hex"], base=16)
+        elif m[0] == "#define X":
             d = m[1].groupdict()
-            if d['id2'] in consts:
-                consts[d['id']] = consts[d['id2']]
-        elif m[0] == '#define X+hex':
+            if d["id2"] in consts:
+                consts[d["id"]] = consts[d["id2"]]
+        elif m[0] == "#define X+hex":
             d = m[1].groupdict()
-            if d['id2'] in consts:
-                consts[d['id']] = consts[d['id2']] + int(d['hex'], base=16)
-        elif m[0] == '#define typedef':
+            if d["id2"] in consts:
+                consts[d["id"]] = consts[d["id2"]] + int(d["hex"], base=16)
+        elif m[0] == "#define typedef":
             d = m[1].groupdict()
-            if d['id2'] in consts:
-                periphs.append((d['id'], consts[d['id2']]))
-        elif m[0] == 'typedef struct':
-            lexer.must_match('{')
+            if d["id2"] in consts:
+                periphs.append((d["id"], consts[d["id2"]]))
+        elif m[0] == "typedef struct":
+            lexer.must_match("{")
             m = lexer.next_match()
             regs = []
-            while m[0] in ('IO reg', 'IO reg array'):
+            while m[0] in ("IO reg", "IO reg array"):
                 d = m[1].groupdict()
-                reg = d['reg']
-                offset = int(d['offset'], base=16)
-                bits = int(d['bits'])
-                comment = d['comment']
-                if m[0] == 'IO reg':
+                reg = d["reg"]
+                offset = int(d["offset"], base=16)
+                bits = int(d["bits"])
+                comment = d["comment"]
+                if m[0] == "IO reg":
                     regs.append((reg, offset, bits, comment))
                 else:
-                    for i in range(int(d['array'])):
+                    for i in range(int(d["array"])):
                         regs.append((reg + str(i), offset + i * bits // 8, bits, comment))
                 m = lexer.next_match()
-            if m[0] == '}':
+            if m[0] == "}":
                 pass
-            elif m[0] == '} TypeDef':
-                reg_defs[m[1].groupdict()['id']] = regs
+            elif m[0] == "} TypeDef":
+                reg_defs[m[1].groupdict()["id"]] = regs
             else:
                 raise LexerError(lexer.line_number)
 
     return periphs, reg_defs
 
+
 def print_int_obj(val, needed_mpzs):
     if -0x40000000 <= val < 0x40000000:
-        print('MP_ROM_INT(%#x)' % val, end='')
+        print("MP_ROM_INT(%#x)" % val, end="")
     else:
-        print('MP_ROM_PTR(&mpz_%08x)' % val, end='')
+        print("MP_ROM_PTR(&mpz_%08x)" % val, end="")
         needed_mpzs.add(val)
 
+
 def print_periph(periph_name, periph_val, needed_qstrs, needed_mpzs):
     qstr = periph_name.upper()
-    print('{ MP_ROM_QSTR(MP_QSTR_%s), ' % qstr, end='')
+    print("{ MP_ROM_QSTR(MP_QSTR_%s), " % qstr, end="")
     print_int_obj(periph_val, needed_mpzs)
-    print(' },')
+    print(" },")
     needed_qstrs.add(qstr)
 
+
 def print_regs(reg_name, reg_defs, needed_qstrs, needed_mpzs):
     reg_name = reg_name.upper()
     for r in reg_defs:
-        qstr = reg_name + '_' + r[0]
-        print('{ MP_ROM_QSTR(MP_QSTR_%s), ' % qstr, end='')
+        qstr = reg_name + "_" + r[0]
+        print("{ MP_ROM_QSTR(MP_QSTR_%s), " % qstr, end="")
         print_int_obj(r[1], needed_mpzs)
-        print(' }, // %s-bits, %s' % (r[2], r[3]))
+        print(" }, // %s-bits, %s" % (r[2], r[3]))
         needed_qstrs.add(qstr)
 
+
 # This version of print regs groups registers together into submodules (eg GPIO submodule).
 # This makes the qstrs shorter, and makes the list of constants more manageable (since
 # they are not all in one big module) but it is then harder to compile the constants, and
@@ -154,21 +201,28 @@ def print_regs(reg_name, reg_defs, needed_qstrs, needed_mpzs):
 # And for the number of constants we have, this function seems to use about the same amount
 # of ROM as print_regs.
 def print_regs_as_submodules(reg_name, reg_defs, modules, needed_qstrs):
-    mod_name_lower = reg_name.lower() + '_'
+    mod_name_lower = reg_name.lower() + "_"
     mod_name_upper = mod_name_lower.upper()
     modules.append((mod_name_lower, mod_name_upper))
 
-    print("""
+    print(
+        """
 STATIC const mp_rom_map_elem_t stm_%s_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_%s) },
-""" % (mod_name_lower, mod_name_upper))
+"""
+        % (mod_name_lower, mod_name_upper)
+    )
     needed_qstrs.add(mod_name_upper)
 
     for r in reg_defs:
-        print('    { MP_ROM_QSTR(MP_QSTR_%s), MP_ROM_INT(%#x) }, // %s-bits, %s' % (r[0], r[1], r[2], r[3]))
+        print(
+            "    { MP_ROM_QSTR(MP_QSTR_%s), MP_ROM_INT(%#x) }, // %s-bits, %s"
+            % (r[0], r[1], r[2], r[3])
+        )
         needed_qstrs.add(r[0])
 
-    print("""};
+    print(
+        """};
 
 STATIC MP_DEFINE_CONST_DICT(stm_%s_globals, stm_%s_globals_table);
 
@@ -177,23 +231,35 @@ def print_regs_as_submodules(reg_name, reg_defs, modules, needed_qstrs):
     .name = MP_QSTR_%s,
     .globals = (mp_obj_dict_t*)&stm_%s_globals,
 };
-""" % (mod_name_lower, mod_name_lower, mod_name_lower, mod_name_upper, mod_name_lower))
+"""
+        % (mod_name_lower, mod_name_lower, mod_name_lower, mod_name_upper, mod_name_lower)
+    )
+
 
 def main():
-    cmd_parser = argparse.ArgumentParser(description='Extract ST constants from a C header file.')
-    cmd_parser.add_argument('file', nargs=1, help='input file')
-    cmd_parser.add_argument('-q', '--qstr', dest='qstr_filename', default='build/stmconst_qstr.h',
-                            help='Specified the name of the generated qstr header file')
-    cmd_parser.add_argument('--mpz', dest='mpz_filename', default='build/stmconst_mpz.h',
-                            help='the destination file of the generated mpz header')
+    cmd_parser = argparse.ArgumentParser(description="Extract ST constants from a C header file.")
+    cmd_parser.add_argument("file", nargs=1, help="input file")
+    cmd_parser.add_argument(
+        "-q",
+        "--qstr",
+        dest="qstr_filename",
+        default="build/stmconst_qstr.h",
+        help="Specified the name of the generated qstr header file",
+    )
+    cmd_parser.add_argument(
+        "--mpz",
+        dest="mpz_filename",
+        default="build/stmconst_mpz.h",
+        help="the destination file of the generated mpz header",
+    )
     args = cmd_parser.parse_args()
 
     periphs, reg_defs = parse_file(args.file[0])
 
     # add legacy GPIO constants that were removed when upgrading CMSIS
-    if 'GPIO' in reg_defs and 'stm32f4' in args.file[0]:
-        reg_defs['GPIO'].append(['BSRRL', 0x18, 16, 'legacy register'])
-        reg_defs['GPIO'].append(['BSRRH', 0x1a, 16, 'legacy register'])
+    if "GPIO" in reg_defs and "stm32f4" in args.file[0]:
+        reg_defs["GPIO"].append(["BSRRL", 0x18, 16, "legacy register"])
+        reg_defs["GPIO"].append(["BSRRH", 0x1A, 16, "legacy register"])
 
     modules = []
     needed_qstrs = set()
@@ -206,55 +272,60 @@ def main():
         print_periph(periph_name, periph_val, needed_qstrs, needed_mpzs)
 
     for reg in (
-        'ADC',
+        "ADC",
         #'ADC_Common',
         #'CAN_TxMailBox',
         #'CAN_FIFOMailBox',
         #'CAN_FilterRegister',
         #'CAN',
-        'CRC',
-        'DAC',
-        'DBGMCU',
-        'DMA_Stream',
-        'DMA',
-        'EXTI',
-        'FLASH',
-        'GPIO',
-        'SYSCFG',
-        'I2C',
-        'IWDG',
-        'PWR',
-        'RCC',
-        'RTC',
+        "CRC",
+        "DAC",
+        "DBGMCU",
+        "DMA_Stream",
+        "DMA",
+        "EXTI",
+        "FLASH",
+        "GPIO",
+        "SYSCFG",
+        "I2C",
+        "IWDG",
+        "PWR",
+        "RCC",
+        "RTC",
         #'SDIO',
-        'SPI',
-        'TIM',
-        'USART',
-        'WWDG',
-        'RNG',
-        ):
+        "SPI",
+        "TIM",
+        "USART",
+        "WWDG",
+        "RNG",
+    ):
         if reg in reg_defs:
             print_regs(reg, reg_defs[reg], needed_qstrs, needed_mpzs)
-        #print_regs_as_submodules(reg, reg_defs[reg], modules, needed_qstrs)
+        # print_regs_as_submodules(reg, reg_defs[reg], modules, needed_qstrs)
 
-    #print("#define MOD_STM_CONST_MODULES \\")
-    #for mod_lower, mod_upper in modules:
+    # print("#define MOD_STM_CONST_MODULES \\")
+    # for mod_lower, mod_upper in modules:
     #    print("    { MP_ROM_QSTR(MP_QSTR_%s), MP_ROM_PTR(&stm_%s_obj) }, \\" % (mod_upper, mod_lower))
 
     print("")
 
-    with open(args.qstr_filename, 'wt') as qstr_file:
-        print('#if MICROPY_PY_STM', file=qstr_file)
+    with open(args.qstr_filename, "wt") as qstr_file:
+        print("#if MICROPY_PY_STM", file=qstr_file)
         for qstr in sorted(needed_qstrs):
-            print('Q({})'.format(qstr), file=qstr_file)
-        print('#endif // MICROPY_PY_STM', file=qstr_file)
+            print("Q({})".format(qstr), file=qstr_file)
+        print("#endif // MICROPY_PY_STM", file=qstr_file)
 
-    with open(args.mpz_filename, 'wt') as mpz_file:
+    with open(args.mpz_filename, "wt") as mpz_file:
         for mpz in sorted(needed_mpzs):
-            assert 0 <= mpz <= 0xffffffff
-            print('STATIC const mp_obj_int_t mpz_%08x = {{&mp_type_int}, '
-                '{.neg=0, .fixed_dig=1, .alloc=2, .len=2, ' '.dig=(uint16_t*)(const uint16_t[]){%#x, %#x}}};'
-                % (mpz, mpz & 0xffff, (mpz >> 16) & 0xffff), file=mpz_file)
+            assert 0 <= mpz <= 0xFFFFFFFF
+            print(
+                "STATIC const mp_obj_int_t mpz_%08x = {{&mp_type_int}, "
+                "{.neg=0, .fixed_dig=1, .alloc=2, .len=2, "
+                ".dig=(uint16_t*)(const uint16_t[]){%#x, %#x}}};"
+                % (mpz, mpz & 0xFFFF, (mpz >> 16) & 0xFFFF),
+                file=mpz_file,
+            )
+
 
 if __name__ == "__main__":
     main()
diff --git a/ports/stm32/mbedtls/mbedtls_config.h b/ports/stm32/mbedtls/mbedtls_config.h
new file mode 100644
index 0000000000000..338c8b354146b
--- /dev/null
+++ b/ports/stm32/mbedtls/mbedtls_config.h
@@ -0,0 +1,98 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_MBEDTLS_CONFIG_H
+#define MICROPY_INCLUDED_MBEDTLS_CONFIG_H
+
+// Set mbedtls configuration
+#define MBEDTLS_PLATFORM_MEMORY
+#define MBEDTLS_PLATFORM_NO_STD_FUNCTIONS
+#define MBEDTLS_DEPRECATED_REMOVED
+#define MBEDTLS_ENTROPY_HARDWARE_ALT
+#define MBEDTLS_AES_ROM_TABLES
+#define MBEDTLS_CIPHER_MODE_CBC
+#define MBEDTLS_ECP_DP_SECP192R1_ENABLED
+#define MBEDTLS_ECP_DP_SECP224R1_ENABLED
+#define MBEDTLS_ECP_DP_SECP256R1_ENABLED
+#define MBEDTLS_ECP_DP_SECP384R1_ENABLED
+#define MBEDTLS_ECP_DP_SECP521R1_ENABLED
+#define MBEDTLS_ECP_DP_SECP192K1_ENABLED
+#define MBEDTLS_ECP_DP_SECP224K1_ENABLED
+#define MBEDTLS_ECP_DP_SECP256K1_ENABLED
+#define MBEDTLS_ECP_DP_BP256R1_ENABLED
+#define MBEDTLS_ECP_DP_BP384R1_ENABLED
+#define MBEDTLS_ECP_DP_BP512R1_ENABLED
+#define MBEDTLS_ECP_DP_CURVE25519_ENABLED
+#define MBEDTLS_KEY_EXCHANGE_RSA_ENABLED
+#define MBEDTLS_NO_PLATFORM_ENTROPY
+#define MBEDTLS_PKCS1_V15
+#define MBEDTLS_SHA256_SMALLER
+#define MBEDTLS_SSL_PROTO_TLS1
+#define MBEDTLS_SSL_PROTO_TLS1_1
+#define MBEDTLS_SSL_PROTO_TLS1_2
+#define MBEDTLS_SSL_SERVER_NAME_INDICATION
+
+// Use a smaller output buffer to reduce size of SSL context
+#define MBEDTLS_SSL_MAX_CONTENT_LEN (16384)
+#define MBEDTLS_SSL_IN_CONTENT_LEN  (MBEDTLS_SSL_MAX_CONTENT_LEN)
+#define MBEDTLS_SSL_OUT_CONTENT_LEN (4096)
+
+// Enable mbedtls modules
+#define MBEDTLS_AES_C
+#define MBEDTLS_ASN1_PARSE_C
+#define MBEDTLS_BIGNUM_C
+#define MBEDTLS_CIPHER_C
+#define MBEDTLS_CTR_DRBG_C
+//#define MBEDTLS_ECP_C
+#define MBEDTLS_ENTROPY_C
+#define MBEDTLS_MD_C
+#define MBEDTLS_MD5_C
+#define MBEDTLS_OID_C
+#define MBEDTLS_PKCS5_C
+#define MBEDTLS_PK_C
+#define MBEDTLS_PK_PARSE_C
+#define MBEDTLS_PLATFORM_C
+#define MBEDTLS_RSA_C
+#define MBEDTLS_SHA1_C
+#define MBEDTLS_SHA256_C
+#define MBEDTLS_SHA512_C
+#define MBEDTLS_SSL_CLI_C
+#define MBEDTLS_SSL_SRV_C
+#define MBEDTLS_SSL_TLS_C
+#define MBEDTLS_X509_CRT_PARSE_C
+#define MBEDTLS_X509_USE_C
+
+// Memory allocation hooks
+#include <stdlib.h>
+#include <stdio.h>
+void *m_calloc_mbedtls(size_t nmemb, size_t size);
+void m_free_mbedtls(void *ptr);
+#define MBEDTLS_PLATFORM_STD_CALLOC m_calloc_mbedtls
+#define MBEDTLS_PLATFORM_STD_FREE m_free_mbedtls
+#define MBEDTLS_PLATFORM_SNPRINTF_MACRO snprintf
+
+#include "mbedtls/check_config.h"
+
+#endif /* MICROPY_INCLUDED_MBEDTLS_CONFIG_H */
diff --git a/ports/stm32/mbedtls/mbedtls_port.c b/ports/stm32/mbedtls/mbedtls_port.c
new file mode 100644
index 0000000000000..efb8d2c2a43ae
--- /dev/null
+++ b/ports/stm32/mbedtls/mbedtls_port.c
@@ -0,0 +1,96 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/gc.h"
+#include "rng.h"
+#include "mbedtls_config.h"
+
+#define DEBUG (0)
+
+#if DEBUG
+static size_t count_links(uint32_t *nb) {
+    void **p = MP_STATE_PORT(mbedtls_memory);
+    size_t n = 0;
+    *nb = 0;
+    while (p != NULL) {
+        ++n;
+        *nb += gc_nbytes(p);
+        p = (void**)p[1];
+    }
+    return n;
+}
+#endif
+
+void *m_calloc_mbedtls(size_t nmemb, size_t size) {
+    void **ptr = m_malloc0(nmemb * size + 2 * sizeof(uintptr_t));
+    #if DEBUG
+    uint32_t nb;
+    size_t n = count_links(&nb);
+    printf("mbed_alloc(%u, %u) -> (%u;%u) %p\n", nmemb, size, n, (uint)nb, ptr);
+    #endif
+    if (MP_STATE_PORT(mbedtls_memory) != NULL) {
+        MP_STATE_PORT(mbedtls_memory)[0] = ptr;
+    }
+    ptr[0] = NULL;
+    ptr[1] = MP_STATE_PORT(mbedtls_memory);
+    MP_STATE_PORT(mbedtls_memory) = ptr;
+    return &ptr[2];
+}
+
+void m_free_mbedtls(void *ptr_in) {
+    void **ptr = &((void**)ptr_in)[-2];
+    #if DEBUG
+    uint32_t nb;
+    size_t n = count_links(&nb);
+    printf("mbed_free(%p, [%p, %p], nbytes=%u, links=%u;%u)\n", ptr, ptr[0], ptr[1], gc_nbytes(ptr), n, (uint)nb);
+    #endif
+    if (ptr[1] != NULL) {
+        ((void**)ptr[1])[0] = ptr[0];
+    }
+    if (ptr[0] != NULL) {
+        ((void**)ptr[0])[1] = ptr[1];
+    } else {
+        MP_STATE_PORT(mbedtls_memory) = ptr[1];
+    }
+    m_free(ptr);
+}
+
+int mbedtls_hardware_poll(void *data, unsigned char *output, size_t len, size_t *olen) {
+    uint32_t val;
+    int n = 0;
+    *olen = len;
+    while (len--) {
+        if (!n) {
+            val = rng_get();
+            n = 4;
+        }
+        *output++ = val;
+        val >>= 8;
+        --n;
+    }
+    return 0;
+}
diff --git a/ports/stm32/mboot/Makefile b/ports/stm32/mboot/Makefile
index 0a5759347f74d..43aae2a6785f3 100755
--- a/ports/stm32/mboot/Makefile
+++ b/ports/stm32/mboot/Makefile
@@ -20,18 +20,22 @@ endif
 include ../../../py/mkenv.mk
 include $(BOARD_DIR)/mpconfigboard.mk
 
-CMSIS_DIR=$(TOP)/lib/stm32lib/CMSIS/STM32$(MCU_SERIES_UPPER)xx/Include
 MCU_SERIES_UPPER = $(shell echo $(MCU_SERIES) | tr '[:lower:]' '[:upper:]')
+CMSIS_MCU_LOWER = $(shell echo $(CMSIS_MCU) | tr '[:upper:]' '[:lower:]')
+
+CMSIS_DIR=$(TOP)/lib/stm32lib/CMSIS/STM32$(MCU_SERIES_UPPER)xx/Include
 HAL_DIR=lib/stm32lib/STM32$(MCU_SERIES_UPPER)xx_HAL_Driver
 USBDEV_DIR=usbdev
 DFU=$(TOP)/tools/dfu.py
 PYDFU ?= $(TOP)/tools/pydfu.py
-DEVICE=0483:df11
+BOOTLOADER_DFU_USB_VID ?= 0x0483
+BOOTLOADER_DFU_USB_PID ?= 0xDF11
 STFLASH ?= st-flash
 OPENOCD ?= openocd
 OPENOCD_CONFIG ?= boards/openocd_stm32f4.cfg
+STARTUP_FILE ?= lib/stm32lib/CMSIS/STM32$(MCU_SERIES_UPPER)xx/Source/Templates/gcc/startup_$(CMSIS_MCU_LOWER).o
 
-CROSS_COMPILE = arm-none-eabi-
+CROSS_COMPILE ?= arm-none-eabi-
 
 INC += -I.
 INC += -I..
@@ -51,7 +55,7 @@ CFLAGS_MCU_f7 = $(CFLAGS_CORTEX_M) -mtune=cortex-m7 -mcpu=cortex-m7
 CFLAGS_MCU_h7 = $(CFLAGS_CORTEX_M) -mtune=cortex-m7 -mcpu=cortex-m7
 CFLAGS_MCU_l4 = $(CFLAGS_CORTEX_M) -mtune=cortex-m4 -mcpu=cortex-m4
 
-CFLAGS = $(INC) -Wall -Wpointer-arith -Werror -std=gnu99 -nostdlib $(CFLAGS_MOD) $(CFLAGS_EXTRA)
+CFLAGS = $(INC) -Wall -Wpointer-arith -Wdouble-promotion -Wfloat-conversion -Werror -std=gnu99 -nostdlib $(CFLAGS_MOD) $(CFLAGS_EXTRA)
 CFLAGS += -D$(CMSIS_MCU)
 CFLAGS += $(CFLAGS_MCU_$(MCU_SERIES))
 CFLAGS += $(COPT)
@@ -60,6 +64,8 @@ CFLAGS += -DSTM32_HAL_H='<stm32$(MCU_SERIES)xx_hal.h>'
 CFLAGS += -DBOARD_$(BOARD)
 CFLAGS += -DAPPLICATION_ADDR=$(TEXT0_ADDR)
 CFLAGS += -DFFCONF_H=\"ports/stm32/mboot/ffconf.h\"
+CFLAGS += -DBUILDING_MBOOT=1
+CFLAGS += -DBOOTLOADER_DFU_USB_VID=$(BOOTLOADER_DFU_USB_VID) -DBOOTLOADER_DFU_USB_PID=$(BOOTLOADER_DFU_USB_PID)
 
 LDFLAGS = -nostdlib -L . -T stm32_generic.ld -Map=$(@:.elf=.map) --cref
 LIBS = $(shell $(CC) $(CFLAGS) -print-libgcc-file-name)
@@ -76,7 +82,7 @@ else
 COPT += -Os -DNDEBUG
 endif
 
-SRC_LIB = \
+LIB_SRC_C = \
 	lib/libc/string0.c \
 	lib/oofatfs/ff.c \
 	lib/oofatfs/ffunicode.c \
@@ -101,7 +107,7 @@ SRC_C = \
 	$(wildcard $(BOARD_DIR)/*.c)
 
 SRC_O = \
-	ports/stm32/boards/startup_stm32$(MCU_SERIES).o \
+	$(STARTUP_FILE) \
 	ports/stm32/resethandler.o \
 
 $(BUILD)/$(HAL_DIR)/Src/stm32$(MCU_SERIES)xx_ll_usb.o: CFLAGS += -Wno-attributes
@@ -121,7 +127,7 @@ SRC_USBDEV = $(addprefix ports/stm32/$(USBDEV_DIR)/,\
 	)
 
 OBJ =
-OBJ += $(addprefix $(BUILD)/, $(SRC_LIB:.c=.o))
+OBJ += $(addprefix $(BUILD)/, $(LIB_SRC_C:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(SRC_O))
 OBJ += $(addprefix $(BUILD)/, $(SRC_HAL:.c=.o))
@@ -175,7 +181,7 @@ GEN_PINS_AF_CONST = $(HEADER_BUILD)/pins_af_const.h
 GEN_PINS_AF_DEFS = $(HEADER_BUILD)/pins_af_defs.h
 GEN_PINS_AF_PY = $(BUILD)/pins_af.py
 
-$(BUILD)/main.o: $(GEN_QSTRDEFS_GENERATED) $(GEN_PINS_AF_DEFS)
+$(OBJ): $(GEN_QSTRDEFS_GENERATED) $(GEN_PINS_AF_DEFS)
 
 $(HEADER_BUILD):
 	$(MKDIR) -p $(BUILD)/genhdr
diff --git a/ports/stm32/mboot/README.md b/ports/stm32/mboot/README.md
index 14bfc66f9cd53..52bbf55675414 100644
--- a/ports/stm32/mboot/README.md
+++ b/ports/stm32/mboot/README.md
@@ -46,14 +46,14 @@ How to use
 
    This assumes that the board declares and defines the relevant SPI flash
    configuration structs, eg in the board-specific bdev.c file.  The
-   `MBOOT_SPIFLASH2_LAYOUT` string will be seen by the USB DFU utility and
+   `MBOOT_SPIFLASH_LAYOUT` string will be seen by the USB DFU utility and
    must describe the SPI flash layout.  Note that the number of pages in
    this layout description (the `64` above) cannot be larger than 99 (it
    must fit in two digits) so the reported page size (the `32Kg` above)
    must be made large enough so the number of pages fits in two digits.
    Alternatively the layout can specify multiple sections like
    `32*16Kg,32*16Kg`, in which case `MBOOT_SPIFLASH_ERASE_BLOCKS_PER_PAGE`
-   must be changed to `16 / 4` to match tho `16Kg` value.
+   must be changed to `16 / 4` to match the `16Kg` value.
 
    Mboot supports up to two external SPI flash devices.  To configure the
    second one use the same configuration names as above but with
@@ -115,6 +115,10 @@ The last element in the data sequence must be the end element:
 
 * END: type=1, len=0
 
+Note: MicroPython's `machine.bootloader()` function performs steps 1-4
+above, and also accepts an optional bytes argument as additional data to
+pass through to Mboot.
+
 Loading firmware from a filesystem
 ----------------------------------
 
@@ -128,7 +132,11 @@ are located and what filename to program.  The elements to use are:
 
 `u32` means unsigned 32-bit little-endian integer.
 
-The firmware to load must be a gzip'd DfuSe file (.dfu.gz).
+The firmware to load must be a gzip'd DfuSe file (.dfu.gz) and stored within a
+FAT formatted partition.
+
+The provided fwupdate.py script contains helper functions to call into Mboot
+with the correct data, and also to update Mboot itself.
 
 Example: Mboot on PYBv1.x
 -------------------------
diff --git a/ports/stm32/mboot/dfu.h b/ports/stm32/mboot/dfu.h
new file mode 100644
index 0000000000000..e826e217f032f
--- /dev/null
+++ b/ports/stm32/mboot/dfu.h
@@ -0,0 +1,103 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2017-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_STM32_MBOOT_DFU_H
+#define MICROPY_INCLUDED_STM32_MBOOT_DFU_H
+
+#include <stdint.h>
+
+// DFU spec: https://www.usb.org/sites/default/files/DFU_1.1.pdf
+
+#define DFU_XFER_SIZE (2048)
+
+// The DFU standard allows for error messages to be sent (via str index) in GETSTATUS responses
+#define MBOOT_ERROR_STR_OVERWRITE_BOOTLOADER_IDX 0x10
+#define MBOOT_ERROR_STR_OVERWRITE_BOOTLOADER "Can't overwrite mboot"
+
+#define MBOOT_ERROR_STR_INVALID_ADDRESS_IDX 0x11
+#define MBOOT_ERROR_STR_INVALID_ADDRESS "Address out of range"
+
+// DFU class requests
+enum {
+    DFU_DETACH = 0,
+    DFU_DNLOAD = 1,
+    DFU_UPLOAD = 2,
+    DFU_GETSTATUS = 3,
+    DFU_CLRSTATUS = 4,
+    DFU_GETSTATE = 5,
+    DFU_ABORT = 6,
+};
+
+// DFU States
+typedef enum {
+    DFU_STATE_IDLE = 2,
+    DFU_STATE_BUSY = 4,
+    DFU_STATE_DNLOAD_IDLE = 5,
+    DFU_STATE_MANIFEST = 7,
+    DFU_STATE_UPLOAD_IDLE = 9,
+    DFU_STATE_ERROR = 0xa,
+} dfu_state_t;
+
+typedef enum {
+    DFU_CMD_NONE = 0,
+    DFU_CMD_EXIT = 1,
+    DFU_CMD_UPLOAD = 7,
+    DFU_CMD_DNLOAD = 8,
+} dfu_cmd_t;
+
+// Error status flags
+typedef enum {
+    DFU_STATUS_OK = 0x00,  // No error condition is present.
+    DFU_STATUS_ERROR_TARGET = 0x01,  // File is not targeted for use by this device.
+    DFU_STATUS_ERROR_FILE = 0x02,  // File is for this device but fails some vendor-specific verification test.
+    DFU_STATUS_ERROR_WRITE = 0x03,  // Device is unable to write memory.
+    DFU_STATUS_ERROR_ERASE = 0x04,  // Memory erase function failed.
+    DFU_STATUS_ERROR_CHECK_ERASED = 0x05,  // Memory erase check failed.
+    DFU_STATUS_ERROR_PROG = 0x06,  // Program memory function failed.
+    DFU_STATUS_ERROR_VERIFY = 0x07,  // Programmed memory failed verification.
+    DFU_STATUS_ERROR_ADDRESS = 0x08,  // Cannot program memory due to received address that is out of range.
+    DFU_STATUS_ERROR_NOTDONE = 0x09,  // Received DFU_DNLOAD with wLength = 0, but device does not think it has all of the data yet.
+    DFU_STATUS_ERROR_FIRMWARE = 0x0A,  // Device's firmware is corrupt. It cannot return to run-time (non-DFU) operations.
+    DFU_STATUS_ERROR_VENDOR = 0x0B,  // iString indicates a vendor-specific error.
+    DFU_STATUS_ERROR_USBR = 0x0C,  // Device detected unexpected USB reset signaling.
+    DFU_STATUS_ERROR_POR = 0x0D,  // Device detected unexpected power on reset.
+    DFU_STATUS_ERROR_UNKNOWN = 0x0E,  // Something went wrong, but the device does not know what it was.
+    DFU_STATUS_ERROR_STALLEDPKT = 0x0F,  // Device stalled an unexpected request.
+} dfu_status_t;
+
+typedef struct _dfu_state_t {
+    dfu_state_t state;
+    dfu_cmd_t cmd;
+    dfu_status_t status;
+    uint8_t error;
+    uint16_t wBlockNum;
+    uint16_t wLength;
+    uint32_t addr;
+    uint8_t buf[DFU_XFER_SIZE] __attribute__((aligned(4)));
+} dfu_context_t;
+
+static dfu_context_t dfu_context SECTION_NOZERO_BSS;
+
+#endif // MICROPY_INCLUDED_STM32_MBOOT_DFU_H
diff --git a/ports/stm32/mboot/fwupdate.py b/ports/stm32/mboot/fwupdate.py
index b2690e8cdae74..b44ed772c3047 100644
--- a/ports/stm32/mboot/fwupdate.py
+++ b/ports/stm32/mboot/fwupdate.py
@@ -6,7 +6,7 @@
 
 
 FLASH_KEY1 = 0x45670123
-FLASH_KEY2 = 0xcdef89ab
+FLASH_KEY2 = 0xCDEF89AB
 
 
 def check_mem_contains(addr, buf):
@@ -17,99 +17,100 @@ def check_mem_contains(addr, buf):
             return False
     return True
 
+
 def check_mem_erased(addr, size):
     mem16 = stm.mem16
     r = range(0, size, 2)
     for off in r:
-        if mem16[addr + off] != 0xffff:
+        if mem16[addr + off] != 0xFFFF:
             return False
     return True
 
+
 def dfu_read(filename):
-    f = open(filename, 'rb')
+    f = open(filename, "rb")
 
     hdr = f.read(3)
     f.seek(0)
-    if hdr == b'Dfu':
+    if hdr == b"Dfu":
         pass
-    elif hdr == b'\x1f\x8b\x08':
+    elif hdr == b"\x1f\x8b\x08":
         f = uzlib.DecompIO(f, 16 + 15)
     else:
-        print('Invalid firmware', filename)
+        print("Invalid firmware", filename)
         return None
 
     elems = []
 
     hdr = f.read(11)
-    sig, ver, size, num_targ = struct.unpack('<5sBIB', hdr)
+    sig, ver, size, num_targ = struct.unpack("<5sBIB", hdr)
 
     file_offset = 11
 
     for i in range(num_targ):
         hdr = f.read(274)
-        sig, alt, has_name, name, t_size, num_elem = struct.unpack('<6sBi255sII', hdr)
+        sig, alt, has_name, name, t_size, num_elem = struct.unpack("<6sBi255sII", hdr)
 
         file_offset += 274
         file_offset_t = file_offset
         for j in range(num_elem):
             hdr = f.read(8)
-            addr, e_size = struct.unpack('<II', hdr)
+            addr, e_size = struct.unpack("<II", hdr)
             data = f.read(e_size)
             elems.append((addr, data))
             file_offset += 8 + e_size
 
         if t_size != file_offset - file_offset_t:
-            print('corrupt DFU', t_size, file_offset - file_offset_t)
+            print("corrupt DFU", t_size, file_offset - file_offset_t)
             return None
 
     if size != file_offset:
-        print('corrupt DFU', size, file_offset)
+        print("corrupt DFU", size, file_offset)
         return None
 
     hdr = f.read(16)
-    hdr = struct.unpack('<HHHH3sBI', hdr)
+    hdr = struct.unpack("<HHHH3sBI", hdr)
 
     return elems
 
+
 def flash_wait_not_busy():
     while stm.mem32[stm.FLASH + stm.FLASH_SR] & 1 << 16:
         machine.idle()
 
+
 def flash_unlock():
     stm.mem32[stm.FLASH + stm.FLASH_KEYR] = FLASH_KEY1
     stm.mem32[stm.FLASH + stm.FLASH_KEYR] = FLASH_KEY2
 
+
 def flash_lock():
-    stm.mem32[stm.FLASH + stm.FLASH_CR] = 1 << 31 # LOCK
+    stm.mem32[stm.FLASH + stm.FLASH_CR] = 1 << 31  # LOCK
+
 
 def flash_erase_sector(sector):
-    assert 0 <= sector <= 7 # for F722
+    assert 0 <= sector <= 7  # for F722
     flash_wait_not_busy()
-    cr = (
-        2 << 8 # PSIZE = 32 bits
-        | sector << 3 # SNB
-        | 1 << 1 # SER
-    )
+    cr = 2 << 8 | sector << 3 | 1 << 1  # PSIZE = 32 bits  # SNB  # SER
     stm.mem32[stm.FLASH + stm.FLASH_CR] = cr
-    stm.mem32[stm.FLASH + stm.FLASH_CR] = cr | 1 << 16 # STRT
+    stm.mem32[stm.FLASH + stm.FLASH_CR] = cr | 1 << 16  # STRT
     flash_wait_not_busy()
     stm.mem32[stm.FLASH + stm.FLASH_CR] = 0
 
+
 def flash_write(addr, buf):
     assert len(buf) % 4 == 0
     flash_wait_not_busy()
-    cr = (
-        2 << 8 # PSIZE = 32 bits
-        | 1 << 0 # PG
-    )
+    cr = 2 << 8 | 1 << 0  # PSIZE = 32 bits  # PG
     stm.mem32[stm.FLASH + stm.FLASH_CR] = cr
     for off in range(0, len(buf), 4):
-        stm.mem32[addr + off] = struct.unpack_from('I', buf, off)[0]
+        stm.mem32[addr + off] = struct.unpack_from("I", buf, off)[0]
         flash_wait_not_busy()
     stm.mem32[stm.FLASH + stm.FLASH_CR] = 0
 
+
 def update_mboot(filename):
-    print('Loading file', filename)
+    print("Loading file", filename)
 
     mboot_fw = dfu_read(filename)
     if mboot_fw is None:
@@ -122,14 +123,14 @@ def update_mboot(filename):
 
     # TODO: Validate firmware in a simple way
 
-    print('Found Mboot data with size %u.' % len(mboot_fw))
+    print("Found Mboot data with size %u." % len(mboot_fw))
 
     chk = check_mem_contains(mboot_addr, mboot_fw)
     if chk:
-        print('Supplied version of Mboot is already on device.')
+        print("Supplied version of Mboot is already on device.")
         return
 
-    print('Programming Mboot, do not turn off!')
+    print("Programming Mboot, do not turn off!")
     time.sleep_ms(50)
 
     irq = machine.disable_irq()
@@ -141,24 +142,25 @@ def update_mboot(filename):
     flash_lock()
     machine.enable_irq(irq)
 
-    print('New Mboot programmed.')
+    print("New Mboot programmed.")
 
     if check_mem_contains(mboot_addr, mboot_fw):
-        print('Verification of new Mboot succeeded.')
+        print("Verification of new Mboot succeeded.")
     else:
-        print('Verification of new Mboot FAILED!  Try rerunning.')
+        print("Verification of new Mboot FAILED!  Try rerunning.")
+
+    print("Programming finished, can now reset or turn off.")
 
-    print('Programming finished, can now reset or turn off.')
 
 def update_mpy(filename, fs_base, fs_len):
     # Check firmware is of .dfu.gz type
     try:
-        with open(filename, 'rb') as f:
+        with open(filename, "rb") as f:
             hdr = uzlib.DecompIO(f, 16 + 15).read(6)
     except Exception:
         hdr = None
-    if hdr != b'DfuSe\x01':
-        print('Firmware must be a .dfu.gz file.')
+    if hdr != b"DfuSe\x01":
+        print("Firmware must be a .dfu.gz file.")
         return
 
     ELEM_TYPE_END = 1
@@ -166,7 +168,11 @@ def update_mpy(filename, fs_base, fs_len):
     ELEM_TYPE_FSLOAD = 3
     ELEM_MOUNT_FAT = 1
     mount_point = 1
-    mount = struct.pack('<BBBBLL', ELEM_TYPE_MOUNT, 10, mount_point, ELEM_MOUNT_FAT, fs_base, fs_len)
-    fsup = struct.pack('<BBB', ELEM_TYPE_FSLOAD, 1 + len(filename), mount_point) + bytes(filename, 'ascii')
-    end = struct.pack('<BB', ELEM_TYPE_END, 0)
+    mount = struct.pack(
+        "<BBBBLL", ELEM_TYPE_MOUNT, 10, mount_point, ELEM_MOUNT_FAT, fs_base, fs_len
+    )
+    fsup = struct.pack("<BBB", ELEM_TYPE_FSLOAD, 1 + len(filename), mount_point) + bytes(
+        filename, "ascii"
+    )
+    end = struct.pack("<BB", ELEM_TYPE_END, 0)
     machine.bootloader(mount + fsup + end)
diff --git a/ports/stm32/mboot/main.c b/ports/stm32/mboot/main.c
index f6b89004d4162..4ae575f3ddf41 100644
--- a/ports/stm32/mboot/main.c
+++ b/ports/stm32/mboot/main.c
@@ -33,6 +33,7 @@
 #include "storage.h"
 #include "i2cslave.h"
 #include "mboot.h"
+#include "dfu.h"
 
 // Using polling is about 10% faster than not using it (and using IRQ instead)
 // This DFU code with polling runs in about 70% of the time of the ST bootloader
@@ -408,24 +409,39 @@ void mp_hal_pin_config_speed(uint32_t port_pin, uint32_t speed) {
 
 #define LED0 MICROPY_HW_LED1
 #define LED1 MICROPY_HW_LED2
+#ifdef MICROPY_HW_LED3
 #define LED2 MICROPY_HW_LED3
+#endif
 #ifdef MICROPY_HW_LED4
 #define LED3 MICROPY_HW_LED4
 #endif
 
-void led_init(void) {
+// For flashing states: bit 0 is "active", bit 1 is "inactive", bits 2-6 are flash rate.
+typedef enum {
+    LED0_STATE_OFF = 0,
+    LED0_STATE_ON = 1,
+    LED0_STATE_SLOW_FLASH = (20 << 2) | 1,
+    LED0_STATE_FAST_FLASH = (2 << 2) | 1,
+    LED0_STATE_SLOW_INVERTED_FLASH = (20 << 2) | 2,
+} led0_state_t;
+
+static led0_state_t led0_cur_state = LED0_STATE_OFF;
+static uint32_t led0_ms_interval = 0;
+static int led0_toggle_count = 0;
+
+MP_WEAK void led_init(void) {
     mp_hal_pin_output(LED0);
     mp_hal_pin_output(LED1);
+    #ifdef LED2
     mp_hal_pin_output(LED2);
+    #endif
     #ifdef LED3
     mp_hal_pin_output(LED3);
     #endif
+    led0_cur_state = LED0_STATE_OFF;
 }
 
-void led_state(int led, int val) {
-    if (led == 1) {
-        led = LED0;
-    }
+MP_WEAK void led_state(uint32_t led, int val) {
     if (val) {
         MICROPY_HW_LED_ON(led);
     } else {
@@ -436,12 +452,32 @@ void led_state(int led, int val) {
 void led_state_all(unsigned int mask) {
     led_state(LED0, mask & 1);
     led_state(LED1, mask & 2);
+    #ifdef LED2
     led_state(LED2, mask & 4);
+    #endif
     #ifdef LED3
     led_state(LED3, mask & 8);
     #endif
 }
 
+void led0_state(led0_state_t state) {
+    led0_cur_state = state;
+    if (state == LED0_STATE_OFF || state == LED0_STATE_ON) {
+        led_state(LED0, state);
+    }
+}
+
+void led0_update() {
+    if (led0_cur_state != LED0_STATE_OFF && systick_ms - led0_ms_interval > 50) {
+        uint8_t rate = (led0_cur_state >> 2) & 0x1f;
+        led0_ms_interval += 50;
+        if (++led0_toggle_count >= rate) {
+            led0_toggle_count = 0;
+        }
+        led_state(LED0, (led0_cur_state & (led0_toggle_count == 0 ? 1 : 2)));
+    }
+}
+
 /******************************************************************************/
 // USR BUTTON
 
@@ -519,6 +555,13 @@ static const flash_layout_t flash_layout[] = {
 
 #endif
 
+static inline bool flash_is_valid_addr(uint32_t addr) {
+    uint8_t last = MP_ARRAY_SIZE(flash_layout) - 1;
+    uint32_t end_of_flash = flash_layout[last].base_address +
+        flash_layout[last].sector_count * flash_layout[last].sector_size;
+    return flash_layout[0].base_address <= addr && addr < end_of_flash;
+}
+
 static uint32_t flash_get_sector_index(uint32_t addr, uint32_t *sector_size) {
     if (addr >= flash_layout[0].base_address) {
         uint32_t sector_index = 0;
@@ -568,6 +611,8 @@ static int flash_page_erase(uint32_t addr, uint32_t *next_addr) {
     uint32_t sector = flash_get_sector_index(addr, &sector_size);
     if (sector == 0) {
         // Don't allow to erase the sector with this bootloader in it
+        dfu_context.status = DFU_STATUS_ERROR_ADDRESS;
+        dfu_context.error = MBOOT_ERROR_STR_OVERWRITE_BOOTLOADER_IDX;
         return -1;
     }
 
@@ -612,6 +657,8 @@ static int flash_page_erase(uint32_t addr, uint32_t *next_addr) {
 static int flash_write(uint32_t addr, const uint8_t *src8, size_t len) {
     if (addr >= flash_layout[0].base_address && addr < flash_layout[0].base_address + flash_layout[0].sector_size) {
         // Don't allow to write the sector with this bootloader in it
+        dfu_context.status = DFU_STATUS_ERROR_ADDRESS;
+        dfu_context.error = MBOOT_ERROR_STR_OVERWRITE_BOOTLOADER_IDX;
         return -1;
     }
 
@@ -670,62 +717,72 @@ static int spiflash_page_erase(mp_spiflash_t *spif, uint32_t addr, uint32_t n_bl
 #endif
 
 int do_page_erase(uint32_t addr, uint32_t *next_addr) {
-    led_state(LED0, 1);
+    int ret = -1;
+    led0_state(LED0_STATE_ON);
 
     #if defined(MBOOT_SPIFLASH_ADDR)
     if (MBOOT_SPIFLASH_ADDR <= addr && addr < MBOOT_SPIFLASH_ADDR + MBOOT_SPIFLASH_BYTE_SIZE) {
         *next_addr = addr + MBOOT_SPIFLASH_ERASE_BLOCKS_PER_PAGE * MP_SPIFLASH_ERASE_BLOCK_SIZE;
-        return spiflash_page_erase(MBOOT_SPIFLASH_SPIFLASH,
+        ret = spiflash_page_erase(MBOOT_SPIFLASH_SPIFLASH,
             addr - MBOOT_SPIFLASH_ADDR, MBOOT_SPIFLASH_ERASE_BLOCKS_PER_PAGE);
-    }
+    } else
     #endif
-
     #if defined(MBOOT_SPIFLASH2_ADDR)
     if (MBOOT_SPIFLASH2_ADDR <= addr && addr < MBOOT_SPIFLASH2_ADDR + MBOOT_SPIFLASH2_BYTE_SIZE) {
         *next_addr = addr + MBOOT_SPIFLASH2_ERASE_BLOCKS_PER_PAGE * MP_SPIFLASH_ERASE_BLOCK_SIZE;
-        return spiflash_page_erase(MBOOT_SPIFLASH2_SPIFLASH,
+        ret = spiflash_page_erase(MBOOT_SPIFLASH2_SPIFLASH,
             addr - MBOOT_SPIFLASH2_ADDR, MBOOT_SPIFLASH2_ERASE_BLOCKS_PER_PAGE);
-    }
+    } else
     #endif
+    {
+        ret = flash_page_erase(addr, next_addr);
+    }
 
-    return flash_page_erase(addr, next_addr);
+    led0_state((ret == 0) ? LED0_STATE_SLOW_FLASH : LED0_STATE_SLOW_INVERTED_FLASH);
+    return ret;
 }
 
 void do_read(uint32_t addr, int len, uint8_t *buf) {
+    led0_state(LED0_STATE_FAST_FLASH);
     #if defined(MBOOT_SPIFLASH_ADDR)
     if (MBOOT_SPIFLASH_ADDR <= addr && addr < MBOOT_SPIFLASH_ADDR + MBOOT_SPIFLASH_BYTE_SIZE) {
         mp_spiflash_read(MBOOT_SPIFLASH_SPIFLASH, addr - MBOOT_SPIFLASH_ADDR, len, buf);
-        return;
-    }
+    } else
     #endif
     #if defined(MBOOT_SPIFLASH2_ADDR)
     if (MBOOT_SPIFLASH2_ADDR <= addr && addr < MBOOT_SPIFLASH2_ADDR + MBOOT_SPIFLASH2_BYTE_SIZE) {
         mp_spiflash_read(MBOOT_SPIFLASH2_SPIFLASH, addr - MBOOT_SPIFLASH2_ADDR, len, buf);
-        return;
-    }
+    } else
     #endif
-
-    // Other addresses, just read directly from memory
-    memcpy(buf, (void*)addr, len);
+    {
+        // Other addresses, just read directly from memory
+        memcpy(buf, (void*)addr, len);
+    }
+    led0_state(LED0_STATE_SLOW_FLASH);
 }
 
 int do_write(uint32_t addr, const uint8_t *src8, size_t len) {
-    static uint32_t led_tog = 0;
-    led_state(LED0, (led_tog++) & 4);
-
+    int ret = -1;
+    led0_state(LED0_STATE_FAST_FLASH);
     #if defined(MBOOT_SPIFLASH_ADDR)
     if (MBOOT_SPIFLASH_ADDR <= addr && addr < MBOOT_SPIFLASH_ADDR + MBOOT_SPIFLASH_BYTE_SIZE) {
-        return mp_spiflash_write(MBOOT_SPIFLASH_SPIFLASH, addr - MBOOT_SPIFLASH_ADDR, len, src8);
-    }
+        ret = mp_spiflash_write(MBOOT_SPIFLASH_SPIFLASH, addr - MBOOT_SPIFLASH_ADDR, len, src8);
+    } else
     #endif
-
     #if defined(MBOOT_SPIFLASH2_ADDR)
     if (MBOOT_SPIFLASH2_ADDR <= addr && addr < MBOOT_SPIFLASH2_ADDR + MBOOT_SPIFLASH2_BYTE_SIZE) {
-        return mp_spiflash_write(MBOOT_SPIFLASH2_SPIFLASH, addr - MBOOT_SPIFLASH2_ADDR, len, src8);
-    }
+        ret = mp_spiflash_write(MBOOT_SPIFLASH2_SPIFLASH, addr - MBOOT_SPIFLASH2_ADDR, len, src8);
+    } else
     #endif
+    if (flash_is_valid_addr(addr)) {
+        ret = flash_write(addr, src8, len);
+    } else {
+        dfu_context.status = DFU_STATUS_ERROR_ADDRESS;
+        dfu_context.error = MBOOT_ERROR_STR_INVALID_ADDRESS_IDX;
+    }
 
-    return flash_write(addr, src8, len);
+    led0_state((ret == 0) ? LED0_STATE_SLOW_FLASH : LED0_STATE_SLOW_INVERTED_FLASH);
+    return ret;
 }
 
 /******************************************************************************/
@@ -899,113 +956,82 @@ uint8_t i2c_slave_process_tx_byte(void) {
 /******************************************************************************/
 // DFU
 
-#define DFU_XFER_SIZE (2048)
-
-enum {
-    DFU_DNLOAD = 1,
-    DFU_UPLOAD = 2,
-    DFU_GETSTATUS = 3,
-    DFU_CLRSTATUS = 4,
-    DFU_ABORT = 6,
-};
-
-enum {
-    DFU_STATUS_IDLE = 2,
-    DFU_STATUS_BUSY = 4,
-    DFU_STATUS_DNLOAD_IDLE = 5,
-    DFU_STATUS_MANIFEST = 7,
-    DFU_STATUS_UPLOAD_IDLE = 9,
-    DFU_STATUS_ERROR = 0xa,
-};
-
-enum {
-    DFU_CMD_NONE = 0,
-    DFU_CMD_EXIT = 1,
-    DFU_CMD_UPLOAD = 7,
-    DFU_CMD_DNLOAD = 8,
-};
-
-typedef struct _dfu_state_t {
-    int status;
-    int cmd;
-    uint16_t wBlockNum;
-    uint16_t wLength;
-    uint32_t addr;
-    uint8_t buf[DFU_XFER_SIZE] __attribute__((aligned(4)));
-} dfu_state_t;
-
-static dfu_state_t dfu_state SECTION_NOZERO_BSS;
-
 static void dfu_init(void) {
-    dfu_state.status = DFU_STATUS_IDLE;
-    dfu_state.cmd = DFU_CMD_NONE;
-    dfu_state.addr = 0x08000000;
+    dfu_context.state = DFU_STATE_IDLE;
+    dfu_context.cmd = DFU_CMD_NONE;
+    dfu_context.status = DFU_STATUS_OK;
+    dfu_context.error = 0;
+    dfu_context.addr = 0x08000000;
 }
 
 static int dfu_process_dnload(void) {
     int ret = -1;
-    if (dfu_state.wBlockNum == 0) {
+    if (dfu_context.wBlockNum == 0) {
         // download control commands
-        if (dfu_state.wLength >= 1 && dfu_state.buf[0] == 0x41) {
-            if (dfu_state.wLength == 1) {
+        if (dfu_context.wLength >= 1 && dfu_context.buf[0] == 0x41) {
+            if (dfu_context.wLength == 1) {
                 // mass erase
                 ret = do_mass_erase();
-            } else if (dfu_state.wLength == 5) {
+            } else if (dfu_context.wLength == 5) {
                 // erase page
                 uint32_t next_addr;
-                ret = do_page_erase(get_le32(&dfu_state.buf[1]), &next_addr);
+                ret = do_page_erase(get_le32(&dfu_context.buf[1]), &next_addr);
             }
-        } else if (dfu_state.wLength >= 1 && dfu_state.buf[0] == 0x21) {
-            if (dfu_state.wLength == 5) {
+        } else if (dfu_context.wLength >= 1 && dfu_context.buf[0] == 0x21) {
+            if (dfu_context.wLength == 5) {
                 // set address
-                dfu_state.addr = get_le32(&dfu_state.buf[1]);
+                dfu_context.addr = get_le32(&dfu_context.buf[1]);
                 ret = 0;
             }
         }
-    } else if (dfu_state.wBlockNum > 1) {
+    } else if (dfu_context.wBlockNum > 1) {
         // write data to memory
-        uint32_t addr = (dfu_state.wBlockNum - 2) * DFU_XFER_SIZE + dfu_state.addr;
-        ret = do_write(addr, dfu_state.buf, dfu_state.wLength);
+        uint32_t addr = (dfu_context.wBlockNum - 2) * DFU_XFER_SIZE + dfu_context.addr;
+        ret = do_write(addr, dfu_context.buf, dfu_context.wLength);
     }
     if (ret == 0) {
-        return DFU_STATUS_DNLOAD_IDLE;
+        return DFU_STATE_DNLOAD_IDLE;
     } else {
-        return DFU_STATUS_ERROR;
+        return DFU_STATE_ERROR;
     }
 }
 
 static void dfu_handle_rx(int cmd, int arg, int len, const void *buf) {
     if (cmd == DFU_CLRSTATUS) {
         // clear status
-        dfu_state.status = DFU_STATUS_IDLE;
-        dfu_state.cmd = DFU_CMD_NONE;
+        dfu_context.state = DFU_STATE_IDLE;
+        dfu_context.cmd = DFU_CMD_NONE;
+        dfu_context.status = DFU_STATUS_OK;
+        dfu_context.error = 0;
     } else if (cmd == DFU_ABORT) {
         // clear status
-        dfu_state.status = DFU_STATUS_IDLE;
-        dfu_state.cmd = DFU_CMD_NONE;
+        dfu_context.state = DFU_STATE_IDLE;
+        dfu_context.cmd = DFU_CMD_NONE;
+        dfu_context.status = DFU_STATUS_OK;
+        dfu_context.error = 0;
     } else if (cmd == DFU_DNLOAD) {
         if (len == 0) {
             // exit DFU
-            dfu_state.cmd = DFU_CMD_EXIT;
+            dfu_context.cmd = DFU_CMD_EXIT;
         } else {
             // download
-            dfu_state.cmd = DFU_CMD_DNLOAD;
-            dfu_state.wBlockNum = arg;
-            dfu_state.wLength = len;
-            memcpy(dfu_state.buf, buf, len);
+            dfu_context.cmd = DFU_CMD_DNLOAD;
+            dfu_context.wBlockNum = arg;
+            dfu_context.wLength = len;
+            memcpy(dfu_context.buf, buf, len);
         }
     }
 }
 
 static void dfu_process(void) {
-    if (dfu_state.status == DFU_STATUS_MANIFEST) {
+    if (dfu_context.state == DFU_STATE_MANIFEST) {
         do_reset();
     }
 
-    if (dfu_state.status == DFU_STATUS_BUSY) {
-        if (dfu_state.cmd == DFU_CMD_DNLOAD) {
-            dfu_state.cmd = DFU_CMD_NONE;
-            dfu_state.status = dfu_process_dnload();
+    if (dfu_context.state == DFU_STATE_BUSY) {
+        if (dfu_context.cmd == DFU_CMD_DNLOAD) {
+            dfu_context.cmd = DFU_CMD_NONE;
+            dfu_context.state = dfu_process_dnload();
         }
     }
 }
@@ -1013,32 +1039,34 @@ static void dfu_process(void) {
 static int dfu_handle_tx(int cmd, int arg, int len, uint8_t *buf, int max_len) {
     if (cmd == DFU_UPLOAD) {
         if (arg >= 2) {
-            dfu_state.cmd = DFU_CMD_UPLOAD;
-            uint32_t addr = (arg - 2) * max_len + dfu_state.addr;
+            dfu_context.cmd = DFU_CMD_UPLOAD;
+            uint32_t addr = (arg - 2) * max_len + dfu_context.addr;
             do_read(addr, len, buf);
             return len;
         }
     } else if (cmd == DFU_GETSTATUS && len == 6) {
         // execute command and get status
-        switch (dfu_state.cmd) {
+        switch (dfu_context.cmd) {
             case DFU_CMD_NONE:
                 break;
             case DFU_CMD_EXIT:
-                dfu_state.status = DFU_STATUS_MANIFEST;
+                dfu_context.state = DFU_STATE_MANIFEST;
                 break;
             case DFU_CMD_UPLOAD:
-                dfu_state.status = DFU_STATUS_UPLOAD_IDLE;
+                dfu_context.state = DFU_STATE_UPLOAD_IDLE;
                 break;
             case DFU_CMD_DNLOAD:
-                dfu_state.status = DFU_STATUS_BUSY;
+                dfu_context.state = DFU_STATE_BUSY;
                 break;
+            default:
+                dfu_context.state = DFU_STATE_BUSY;
         }
-        buf[0] = 0;
-        buf[1] = dfu_state.cmd; // TODO is this correct?
-        buf[2] = 0;
-        buf[3] = 0;
-        buf[4] = dfu_state.status;
-        buf[5] = 0;
+        buf[0] = dfu_context.status; // bStatus
+        buf[1] = 0; // bwPollTimeout (ms)
+        buf[2] = 0; // bwPollTimeout (ms)
+        buf[3] = 0; // bwPollTimeout (ms)
+        buf[4] = dfu_context.state; // bState
+        buf[5] = dfu_context.error; // iString
         return 6;
     }
     return -1;
@@ -1081,13 +1109,20 @@ typedef struct _pyb_usbdd_obj_t {
 #endif
 
 #ifndef MBOOT_USB_VID
-#define MBOOT_USB_VID 0x0483
+#define MBOOT_USB_VID BOOTLOADER_DFU_USB_VID
 #endif
 
 #ifndef MBOOT_USB_PID
-#define MBOOT_USB_PID 0xDF11
+#define MBOOT_USB_PID BOOTLOADER_DFU_USB_PID
 #endif
 
+static const uint8_t usbd_fifo_size[] = {
+    32, 8, 16, 8, 16, 0, 0, // FS: RX, EP0(in), 5x IN endpoints
+    #if MICROPY_HW_USB_HS
+    116, 8, 64, 4, 64, 0, 0, 0, 0, 0, // HS: RX, EP0(in), 8x IN endpoints
+    #endif
+};
+
 __ALIGN_BEGIN static const uint8_t USBD_LangIDDesc[USB_LEN_LANGID_STR_DESC] __ALIGN_END = {
     USB_LEN_LANGID_STR_DESC,
     USB_DESC_TYPE_STRING,
@@ -1175,6 +1210,14 @@ static uint8_t *pyb_usbdd_StrDescriptor(USBD_HandleTypeDef *pdev, uint8_t idx, u
             USBD_GetString((uint8_t*)FLASH_LAYOUT_STR, str_desc, length);
             return str_desc;
 
+        case MBOOT_ERROR_STR_OVERWRITE_BOOTLOADER_IDX:
+            USBD_GetString((uint8_t*)MBOOT_ERROR_STR_OVERWRITE_BOOTLOADER, str_desc, length);
+            return str_desc;
+
+        case MBOOT_ERROR_STR_INVALID_ADDRESS_IDX:
+            USBD_GetString((uint8_t*)MBOOT_ERROR_STR_INVALID_ADDRESS, str_desc, length);
+            return str_desc;
+
         default:
             return NULL;
     }
@@ -1315,7 +1358,7 @@ static void pyb_usbdd_start(pyb_usbdd_obj_t *self) {
         while (!(PWR->CR3 & PWR_CR3_USB33RDY)) {
         }
         #endif
-        USBD_LL_Init(&self->hUSBDDevice, 0);
+        USBD_LL_Init(&self->hUSBDDevice, 0, usbd_fifo_size);
         USBD_LL_Start(&self->hUSBDDevice);
         self->started = true;
     }
@@ -1338,11 +1381,15 @@ static int pyb_usbdd_shutdown(void) {
 
 #define RESET_MODE_NUM_STATES (4)
 #define RESET_MODE_TIMEOUT_CYCLES (8)
+#ifdef LED2
 #ifdef LED3
 #define RESET_MODE_LED_STATES 0x8421
 #else
 #define RESET_MODE_LED_STATES 0x7421
 #endif
+#else
+#define RESET_MODE_LED_STATES 0x3210
+#endif
 
 static int get_reset_mode(void) {
     usrbtn_init();
@@ -1504,10 +1551,10 @@ void stm32_main(int initial_r0) {
     #endif
 
     led_state_all(0);
+    led0_state(LED0_STATE_SLOW_FLASH);
 
-    #if USE_USB_POLLING
-    uint32_t ss = systick_ms;
-    int ss2 = -1;
+    #if MBOOT_USB_RESET_ON_DISCONNECT
+    bool has_connected = false;
     #endif
     for (;;) {
         #if USE_USB_POLLING
@@ -1524,23 +1571,17 @@ void stm32_main(int initial_r0) {
         if (!pyb_usbdd.tx_pending) {
             dfu_process();
         }
+        #else // !USE_USB_POLLING
+        __WFI();
         #endif
 
-        #if USE_USB_POLLING
-        //__WFI(); // slows it down way too much; might work with 10x faster systick
-        if (systick_ms - ss > 50) {
-            ss += 50;
-            ss2 = (ss2 + 1) % 20;
-            switch (ss2) {
-                case 0: led_state(LED0, 1); break;
-                case 1: led_state(LED0, 0); break;
-            }
+        #if MBOOT_USB_RESET_ON_DISCONNECT
+        if (pyb_usbdd.hUSBDDevice.dev_state == USBD_STATE_CONFIGURED) {
+            has_connected = true;
+        }
+        if (has_connected && pyb_usbdd.hUSBDDevice.dev_state == USBD_STATE_SUSPENDED) {
+            do_reset();
         }
-        #else
-        led_state(LED0, 1);
-        mp_hal_delay_ms(50);
-        led_state(LED0, 0);
-        mp_hal_delay_ms(950);
         #endif
     }
 }
@@ -1582,6 +1623,10 @@ void SysTick_Handler(void) {
     // the COUNTFLAG bit, which makes the logic in mp_hal_ticks_us
     // work properly.
     SysTick->CTRL;
+
+    // Update the LED0 state from here to ensure it's consistent regardless of
+    // other processing going on in interrupts or main.
+    led0_update();
 }
 
 #if defined(MBOOT_I2C_SCL)
diff --git a/ports/stm32/mboot/mboot.h b/ports/stm32/mboot/mboot.h
index 54b3dc7298aca..7dc1ada0c32f6 100644
--- a/ports/stm32/mboot/mboot.h
+++ b/ports/stm32/mboot/mboot.h
@@ -30,8 +30,9 @@
 // Use this to tag global static data in RAM that doesn't need to be zeroed on startup
 #define SECTION_NOZERO_BSS __attribute__((section(".nozero_bss")))
 
-#define ELEM_DATA_START (&_estack)
-#define ELEM_DATA_MAX (ELEM_DATA_START + 1024)
+#define ELEM_DATA_SIZE (1024)
+#define ELEM_DATA_START (&_estack[0])
+#define ELEM_DATA_MAX (&_estack[ELEM_DATA_SIZE])
 
 enum {
     ELEM_TYPE_END = 1,
@@ -48,7 +49,7 @@ typedef struct _fsload_bdev_t {
     uint32_t byte_len;
 } fsload_bdev_t;
 
-extern uint8_t _estack;
+extern uint8_t _estack[ELEM_DATA_SIZE];
 
 uint32_t get_le32(const uint8_t *b);
 void led_state_all(unsigned int mask);
diff --git a/ports/stm32/mboot/mboot.py b/ports/stm32/mboot/mboot.py
index 39ae0f6f2db91..e0dab163cecbe 100644
--- a/ports/stm32/mboot/mboot.py
+++ b/ports/stm32/mboot/mboot.py
@@ -27,9 +27,9 @@ def __init__(self, i2c, addr):
         self.addr = addr
         self.buf1 = bytearray(1)
         try:
-            self.i2c.writeto(addr, b'')
+            self.i2c.writeto(addr, b"")
         except OSError:
-            raise Exception('no I2C mboot device found')
+            raise Exception("no I2C mboot device found")
 
     def wait_response(self):
         start = time.ticks_ms()
@@ -41,47 +41,47 @@ def wait_response(self):
             except OSError as er:
                 time.sleep_us(500)
             if time.ticks_diff(time.ticks_ms(), start) > 5000:
-                raise Exception('timeout')
+                raise Exception("timeout")
         if n >= 129:
             raise Exception(n)
         if n == 0:
-            return b''
+            return b""
         else:
             return self.i2c.readfrom(self.addr, n)
 
     def wait_empty_response(self):
         ret = self.wait_response()
         if ret:
-            raise Exception('expected empty response got %r' % ret)
+            raise Exception("expected empty response got %r" % ret)
         else:
             return None
 
     def echo(self, data):
-        self.i2c.writeto(self.addr, struct.pack('<B', I2C_CMD_ECHO) + data)
+        self.i2c.writeto(self.addr, struct.pack("<B", I2C_CMD_ECHO) + data)
         return self.wait_response()
 
     def getid(self):
-        self.i2c.writeto(self.addr, struct.pack('<B', I2C_CMD_GETID))
+        self.i2c.writeto(self.addr, struct.pack("<B", I2C_CMD_GETID))
         ret = self.wait_response()
         unique_id = ret[:12]
-        mcu_name, board_name = ret[12:].split(b'\x00')
-        return unique_id, str(mcu_name, 'ascii'), str(board_name, 'ascii')
+        mcu_name, board_name = ret[12:].split(b"\x00")
+        return unique_id, str(mcu_name, "ascii"), str(board_name, "ascii")
 
     def reset(self):
-        self.i2c.writeto(self.addr, struct.pack('<B', I2C_CMD_RESET))
+        self.i2c.writeto(self.addr, struct.pack("<B", I2C_CMD_RESET))
         # we don't expect any response
 
     def getlayout(self):
-        self.i2c.writeto(self.addr, struct.pack('<B', I2C_CMD_GETLAYOUT))
+        self.i2c.writeto(self.addr, struct.pack("<B", I2C_CMD_GETLAYOUT))
         layout = self.wait_response()
-        id, flash_addr, layout = layout.split(b'/')
-        assert id == b'@Internal Flash  '
+        id, flash_addr, layout = layout.split(b"/")
+        assert id == b"@Internal Flash  "
         flash_addr = int(flash_addr, 16)
         pages = []
-        for chunk in layout.split(b','):
-            n, sz = chunk.split(b'*')
+        for chunk in layout.split(b","):
+            n, sz = chunk.split(b"*")
             n = int(n)
-            assert sz.endswith(b'Kg')
+            assert sz.endswith(b"Kg")
             sz = int(sz[:-2]) * 1024
             for i in range(n):
                 pages.append((flash_addr, sz))
@@ -89,43 +89,43 @@ def getlayout(self):
         return pages
 
     def pageerase(self, addr):
-        self.i2c.writeto(self.addr, struct.pack('<BI', I2C_CMD_PAGEERASE, addr))
+        self.i2c.writeto(self.addr, struct.pack("<BI", I2C_CMD_PAGEERASE, addr))
         self.wait_empty_response()
 
     def setrdaddr(self, addr):
-        self.i2c.writeto(self.addr, struct.pack('<BI', I2C_CMD_SETRDADDR, addr))
+        self.i2c.writeto(self.addr, struct.pack("<BI", I2C_CMD_SETRDADDR, addr))
         self.wait_empty_response()
 
     def setwraddr(self, addr):
-        self.i2c.writeto(self.addr, struct.pack('<BI', I2C_CMD_SETWRADDR, addr))
+        self.i2c.writeto(self.addr, struct.pack("<BI", I2C_CMD_SETWRADDR, addr))
         self.wait_empty_response()
 
     def read(self, n):
-        self.i2c.writeto(self.addr, struct.pack('<BB', I2C_CMD_READ, n))
+        self.i2c.writeto(self.addr, struct.pack("<BB", I2C_CMD_READ, n))
         return self.wait_response()
 
     def write(self, buf):
-        self.i2c.writeto(self.addr, struct.pack('<B', I2C_CMD_WRITE) + buf)
+        self.i2c.writeto(self.addr, struct.pack("<B", I2C_CMD_WRITE) + buf)
         self.wait_empty_response()
 
     def calchash(self, n):
-        self.i2c.writeto(self.addr, struct.pack('<BI', I2C_CMD_CALCHASH, n))
+        self.i2c.writeto(self.addr, struct.pack("<BI", I2C_CMD_CALCHASH, n))
         return self.wait_response()
 
     def markvalid(self):
-        self.i2c.writeto(self.addr, struct.pack('<B', I2C_CMD_MARKVALID))
+        self.i2c.writeto(self.addr, struct.pack("<B", I2C_CMD_MARKVALID))
         self.wait_empty_response()
 
     def deployfile(self, filename, addr):
         pages = self.getlayout()
         page_erased = [False] * len(pages)
-        buf = bytearray(128) # maximum payload supported by I2C protocol
+        buf = bytearray(128)  # maximum payload supported by I2C protocol
         start_addr = addr
         self.setwraddr(addr)
         fsize = os.stat(filename)[6]
         local_sha = hashlib.sha256()
-        print('Deploying %s to location 0x%08x' % (filename, addr))
-        with open(filename, 'rb') as f:
+        print("Deploying %s to location 0x%08x" % (filename, addr))
+        with open(filename, "rb") as f:
             t0 = time.ticks_ms()
             while True:
                 n = f.readinto(buf)
@@ -137,12 +137,16 @@ def deployfile(self, filename, addr):
                     if p[0] <= addr < p[0] + p[1]:
                         # found page
                         if not page_erased[i]:
-                            print('\r% 3u%% erase 0x%08x' % (100 * (addr - start_addr) // fsize, addr), end='')
+                            print(
+                                "\r% 3u%% erase 0x%08x"
+                                % (100 * (addr - start_addr) // fsize, addr),
+                                end="",
+                            )
                             self.pageerase(addr)
                             page_erased[i] = True
                         break
                 else:
-                    raise Exception('address 0x%08x not valid' % addr)
+                    raise Exception("address 0x%08x not valid" % addr)
 
                 # write the data
                 self.write(buf)
@@ -158,20 +162,20 @@ def deployfile(self, filename, addr):
                 addr += n
                 ntotal = addr - start_addr
                 if ntotal % 2048 == 0 or ntotal == fsize:
-                    print('\r% 3u%% % 7u bytes   ' % (100 * ntotal // fsize, ntotal), end='')
+                    print("\r% 3u%% % 7u bytes   " % (100 * ntotal // fsize, ntotal), end="")
             t1 = time.ticks_ms()
         print()
-        print('rate: %.2f KiB/sec' % (1024 * ntotal / (t1 - t0) / 1000))
+        print("rate: %.2f KiB/sec" % (1024 * ntotal / (t1 - t0) / 1000))
 
         local_sha = local_sha.digest()
-        print('Local SHA256: ', ''.join('%02x' % x for x in local_sha))
+        print("Local SHA256: ", "".join("%02x" % x for x in local_sha))
 
         self.setrdaddr(start_addr)
         remote_sha = self.calchash(ntotal)
-        print('Remote SHA256:', ''.join('%02x' % x for x in remote_sha))
+        print("Remote SHA256:", "".join("%02x" % x for x in remote_sha))
 
         if local_sha == remote_sha:
-            print('Marking app firmware as valid')
+            print("Marking app firmware as valid")
             self.markvalid()
 
         self.reset()
diff --git a/ports/stm32/mboot/mphalport.h b/ports/stm32/mboot/mphalport.h
index 69ca0b035b5bc..0c8cb91a6883a 100644
--- a/ports/stm32/mboot/mphalport.h
+++ b/ports/stm32/mboot/mphalport.h
@@ -48,17 +48,12 @@
 #define mp_hal_pin_input(p)     mp_hal_pin_config((p), MP_HAL_PIN_MODE_INPUT, MP_HAL_PIN_PULL_NONE, 0)
 #define mp_hal_pin_output(p)    mp_hal_pin_config((p), MP_HAL_PIN_MODE_OUTPUT, MP_HAL_PIN_PULL_NONE, 0)
 #define mp_hal_pin_open_drain(p) mp_hal_pin_config((p), MP_HAL_PIN_MODE_OPEN_DRAIN, MP_HAL_PIN_PULL_NONE, 0)
-#if defined(STM32H7)
-#define mp_hal_pin_low(p)       (((GPIO_TypeDef*)((p) & ~0xf))->BSRRH = 1 << ((p) & 0xf))
-#define mp_hal_pin_high(p)      (((GPIO_TypeDef*)((p) & ~0xf))->BSRRL = 1 << ((p) & 0xf))
-#else
 #define mp_hal_pin_low(p)       (((GPIO_TypeDef*)((p) & ~0xf))->BSRR = 0x10000 << ((p) & 0xf))
 #define mp_hal_pin_high(p)      (((GPIO_TypeDef*)((p) & ~0xf))->BSRR = 1 << ((p) & 0xf))
-#endif
 #define mp_hal_pin_od_low(p)    mp_hal_pin_low(p)
 #define mp_hal_pin_od_high(p)   mp_hal_pin_high(p)
 #define mp_hal_pin_read(p)      ((((GPIO_TypeDef*)((p) & ~0xf))->IDR >> ((p) & 0xf)) & 1)
-#define mp_hal_pin_write(p, v)  do { if (v) { mp_hal_pin_high(p); } else { mp_hal_pin_low(p); } } while (0)
+#define mp_hal_pin_write(p, v)  ((v) ? mp_hal_pin_high(p) : mp_hal_pin_low(p))
 
 void mp_hal_pin_config(uint32_t port_pin, uint32_t mode, uint32_t pull, uint32_t alt);
 void mp_hal_pin_config_speed(uint32_t port_pin, uint32_t speed);
diff --git a/ports/stm32/modbluetooth_hci.c b/ports/stm32/modbluetooth_hci.c
new file mode 100644
index 0000000000000..4e016eae8451c
--- /dev/null
+++ b/ports/stm32/modbluetooth_hci.c
@@ -0,0 +1,200 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2020 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "extmod/modbluetooth_hci.h"
+#include "systick.h"
+#include "pendsv.h"
+
+#include "py/obj.h"
+
+#if MICROPY_PY_BLUETOOTH
+
+uint8_t mp_bluetooth_hci_cmd_buf[4 + 256];
+
+// Must be provided by the stack bindings.
+extern void mp_bluetooth_hci_poll(void);
+
+// Hook for pendsv poller to run this periodically every 128ms
+#define BLUETOOTH_HCI_TICK(tick) (((tick) & ~(SYSTICK_DISPATCH_NUM_SLOTS - 1) & 0x7f) == 0)
+
+// Called periodically (systick) or directly (e.g. uart irq).
+void mp_bluetooth_hci_poll_wrapper(uint32_t ticks_ms) {
+    if (ticks_ms == 0 || BLUETOOTH_HCI_TICK(ticks_ms)) {
+        pendsv_schedule_dispatch(PENDSV_DISPATCH_BLUETOOTH_HCI, mp_bluetooth_hci_poll);
+    }
+}
+
+#if defined(STM32WB)
+
+/******************************************************************************/
+// HCI over IPCC
+
+#include <string.h>
+#include "rfcore.h"
+
+STATIC uint16_t hci_uart_rx_buf_cur;
+STATIC uint16_t hci_uart_rx_buf_len;
+STATIC uint8_t hci_uart_rx_buf_data[256];
+
+int mp_bluetooth_hci_controller_deactivate(void) {
+    return 0;
+}
+
+int mp_bluetooth_hci_controller_sleep_maybe(void) {
+    return 0;
+}
+
+bool mp_bluetooth_hci_controller_woken(void) {
+    return true;
+}
+
+int mp_bluetooth_hci_controller_wakeup(void) {
+    return 0;
+}
+
+int mp_bluetooth_hci_uart_init(uint32_t port) {
+    (void)port;
+    return 0;
+}
+
+int mp_bluetooth_hci_uart_activate(void) {
+    rfcore_ble_init();
+    hci_uart_rx_buf_cur = 0;
+    hci_uart_rx_buf_len = 0;
+    return 0;
+}
+
+int mp_bluetooth_hci_uart_set_baudrate(uint32_t baudrate) {
+    (void)baudrate;
+    return 0;
+}
+
+int mp_bluetooth_hci_uart_write(const uint8_t *buf, size_t len) {
+    MICROPY_PY_BLUETOOTH_ENTER
+    rfcore_ble_hci_cmd(len, (const uint8_t *)buf);
+    MICROPY_PY_BLUETOOTH_EXIT
+    return 0;
+}
+
+// Callback to copy data into local hci_uart_rx_buf_data buffer for subsequent use.
+STATIC int mp_bluetooth_hci_uart_msg_cb(void *env, const uint8_t *buf, size_t len) {
+    (void)env;
+    if (hci_uart_rx_buf_len + len > MP_ARRAY_SIZE(hci_uart_rx_buf_data)) {
+        len = MP_ARRAY_SIZE(hci_uart_rx_buf_data) - hci_uart_rx_buf_len;
+    }
+    memcpy(hci_uart_rx_buf_data + hci_uart_rx_buf_len, buf, len);
+    hci_uart_rx_buf_len += len;
+    return 0;
+}
+
+int mp_bluetooth_hci_uart_readchar(void) {
+    if (hci_uart_rx_buf_cur >= hci_uart_rx_buf_len) {
+        hci_uart_rx_buf_cur = 0;
+        hci_uart_rx_buf_len = 0;
+        rfcore_ble_check_msg(mp_bluetooth_hci_uart_msg_cb, NULL);
+    }
+
+    if (hci_uart_rx_buf_cur < hci_uart_rx_buf_len) {
+        return hci_uart_rx_buf_data[hci_uart_rx_buf_cur++];
+    } else {
+        return -1;
+    }
+}
+
+#else
+
+/******************************************************************************/
+// HCI over UART
+
+#include "pendsv.h"
+#include "uart.h"
+
+pyb_uart_obj_t mp_bluetooth_hci_uart_obj;
+
+static uint8_t hci_uart_rxbuf[512];
+
+mp_obj_t mp_uart_interrupt(mp_obj_t self_in) {
+    // New HCI data, schedule mp_bluetooth_hci_poll to make the stack handle it.
+    mp_bluetooth_hci_poll_wrapper(0);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_1(mp_uart_interrupt_obj, mp_uart_interrupt);
+
+int mp_bluetooth_hci_uart_init(uint32_t port) {
+    // bits (8), stop (1), parity (none) and flow (rts/cts) are assumed to match MYNEWT_VAL_BLE_HCI_UART_ constants in syscfg.h.
+    mp_bluetooth_hci_uart_obj.base.type = &pyb_uart_type;
+    mp_bluetooth_hci_uart_obj.uart_id = port;
+    mp_bluetooth_hci_uart_obj.is_static = true;
+    mp_bluetooth_hci_uart_obj.timeout = 2;
+    mp_bluetooth_hci_uart_obj.timeout_char = 2;
+    MP_STATE_PORT(pyb_uart_obj_all)[mp_bluetooth_hci_uart_obj.uart_id - 1] = &mp_bluetooth_hci_uart_obj;
+    return 0;
+}
+
+int mp_bluetooth_hci_uart_set_baudrate(uint32_t baudrate) {
+    uart_init(&mp_bluetooth_hci_uart_obj, baudrate, UART_WORDLENGTH_8B, UART_PARITY_NONE, UART_STOPBITS_1, UART_HWCONTROL_RTS | UART_HWCONTROL_CTS);
+    uart_set_rxbuf(&mp_bluetooth_hci_uart_obj, sizeof(hci_uart_rxbuf), hci_uart_rxbuf);
+    return 0;
+}
+
+int mp_bluetooth_hci_uart_activate(void) {
+    // Interrupt on RX chunk received (idle)
+    // Trigger stack poll when this happens
+    mp_obj_t uart_irq_fn = mp_load_attr(MP_OBJ_FROM_PTR(&mp_bluetooth_hci_uart_obj), MP_QSTR_irq);
+    mp_obj_t uargs[] = {
+        MP_OBJ_FROM_PTR(&mp_uart_interrupt_obj),
+        MP_OBJ_NEW_SMALL_INT(UART_FLAG_IDLE),
+        mp_const_true,
+    };
+    mp_call_function_n_kw(uart_irq_fn, 3, 0, uargs);
+
+    mp_bluetooth_hci_controller_init();
+    mp_bluetooth_hci_controller_activate();
+
+    return 0;
+}
+
+int mp_bluetooth_hci_uart_write(const uint8_t *buf, size_t len) {
+    mp_bluetooth_hci_controller_wakeup();
+    uart_tx_strn(&mp_bluetooth_hci_uart_obj, (void *)buf, len);
+    return 0;
+}
+
+// This function expects the controller to be in the wake state via a previous call
+// to mp_bluetooth_hci_controller_woken.
+int mp_bluetooth_hci_uart_readchar(void) {
+    if (uart_rx_any(&mp_bluetooth_hci_uart_obj)) {
+        return uart_rx_char(&mp_bluetooth_hci_uart_obj);
+    } else {
+        return -1;
+    }
+}
+
+#endif // defined(STM32WB)
+
+#endif // MICROPY_PY_BLUETOOTH
diff --git a/ports/stm32/modmachine.c b/ports/stm32/modmachine.c
index f7b84bae6734d..0795d2ccf04b8 100644
--- a/ports/stm32/modmachine.c
+++ b/ports/stm32/modmachine.c
@@ -56,7 +56,12 @@
 #include "uart.h"
 #include "wdt.h"
 
-#if defined(STM32L4)
+#if defined(STM32L0)
+// L0 does not have a BOR, so use POR instead
+#define RCC_CSR_BORRSTF RCC_CSR_PORRSTF
+#endif
+
+#if defined(STM32L4) || defined(STM32WB)
 // L4 does not have a POR, so use BOR instead
 #define RCC_CSR_PORRSTF RCC_CSR_BORRSTF
 #endif
@@ -119,10 +124,10 @@ void machine_init(void) {
         if (state & RCC_SR_IWDGRSTF || state & RCC_SR_WWDGRSTF) {
             reset_cause = PYB_RESET_WDT;
         } else if (state & RCC_SR_PORRSTF
-            #if !defined(STM32F0)
-            || state & RCC_SR_BORRSTF
-            #endif
-            ) {
+                   #if !defined(STM32F0) && !defined(STM32F412Zx)
+                   || state & RCC_SR_BORRSTF
+                   #endif
+                   ) {
             reset_cause = PYB_RESET_POWER_ON;
         } else if (state & RCC_SR_PINRSTF) {
             reset_cause = PYB_RESET_HARD;
@@ -145,7 +150,7 @@ void machine_deinit(void) {
 STATIC mp_obj_t machine_info(size_t n_args, const mp_obj_t *args) {
     // get and print unique id; 96 bits
     {
-        byte *id = (byte*)MP_HAL_UNIQUE_ID_ADDRESS;
+        byte *id = (byte *)MP_HAL_UNIQUE_ID_ADDRESS;
         printf("ID=%02x%02x%02x%02x:%02x%02x%02x%02x:%02x%02x%02x%02x\n", id[0], id[1], id[2], id[3], id[4], id[5], id[6], id[7], id[8], id[9], id[10], id[11]);
     }
 
@@ -154,15 +159,15 @@ STATIC mp_obj_t machine_info(size_t n_args, const mp_obj_t *args) {
     {
         #if defined(STM32F0)
         printf("S=%u\nH=%u\nP1=%u\n",
-               (unsigned int)HAL_RCC_GetSysClockFreq(),
-               (unsigned int)HAL_RCC_GetHCLKFreq(),
-               (unsigned int)HAL_RCC_GetPCLK1Freq());
+            (unsigned int)HAL_RCC_GetSysClockFreq(),
+            (unsigned int)HAL_RCC_GetHCLKFreq(),
+            (unsigned int)HAL_RCC_GetPCLK1Freq());
         #else
         printf("S=%u\nH=%u\nP1=%u\nP2=%u\n",
-               (unsigned int)HAL_RCC_GetSysClockFreq(),
-               (unsigned int)HAL_RCC_GetHCLKFreq(),
-               (unsigned int)HAL_RCC_GetPCLK1Freq(),
-               (unsigned int)HAL_RCC_GetPCLK2Freq());
+            (unsigned int)HAL_RCC_GetSysClockFreq(),
+            (unsigned int)HAL_RCC_GetHCLKFreq(),
+            (unsigned int)HAL_RCC_GetPCLK1Freq(),
+            (unsigned int)HAL_RCC_GetPCLK2Freq());
         #endif
     }
 
@@ -174,6 +179,7 @@ STATIC mp_obj_t machine_info(size_t n_args, const mp_obj_t *args) {
         printf("_edata=%p\n", &_edata);
         printf("_sbss=%p\n", &_sbss);
         printf("_ebss=%p\n", &_ebss);
+        printf("_sstack=%p\n", &_sstack);
         printf("_estack=%p\n", &_estack);
         printf("_ram_start=%p\n", &_ram_start);
         printf("_heap_start=%p\n", &_heap_start);
@@ -229,21 +235,21 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_info_obj, 0, 1, machine_info);
 
 // Returns a string of 12 bytes (96 bits), which is the unique ID for the MCU.
 STATIC mp_obj_t machine_unique_id(void) {
-    byte *id = (byte*)MP_HAL_UNIQUE_ID_ADDRESS;
+    byte *id = (byte *)MP_HAL_UNIQUE_ID_ADDRESS;
     return mp_obj_new_bytes(id, 12);
 }
 MP_DEFINE_CONST_FUN_OBJ_0(machine_unique_id_obj, machine_unique_id);
 
 // Resets the pyboard in a manner similar to pushing the external RESET button.
 STATIC mp_obj_t machine_reset(void) {
-    NVIC_SystemReset();
+    powerctrl_mcu_reset();
     return mp_const_none;
 }
 MP_DEFINE_CONST_FUN_OBJ_0(machine_reset_obj, machine_reset);
 
 STATIC mp_obj_t machine_soft_reset(void) {
     pyexec_system_exit = PYEXEC_FORCED_EXIT;
-    nlr_raise(mp_obj_new_exception(&mp_type_SystemExit));
+    mp_raise_type(&mp_type_SystemExit);
 }
 MP_DEFINE_CONST_FUN_OBJ_0(machine_soft_reset_obj, machine_soft_reset);
 
@@ -256,59 +262,33 @@ STATIC NORETURN mp_obj_t machine_bootloader(size_t n_args, const mp_obj_t *args)
     storage_flush();
     #endif
 
-    HAL_RCC_DeInit();
-    HAL_DeInit();
-
-    #if (__MPU_PRESENT == 1)
-    // MPU must be disabled for bootloader to function correctly
-    HAL_MPU_Disable();
-    #endif
+    __disable_irq();
 
     #if MICROPY_HW_USES_BOOTLOADER
     if (n_args == 0 || !mp_obj_is_true(args[0])) {
         // By default, with no args given, we enter the custom bootloader (mboot)
-        #if __DCACHE_PRESENT == 1
-        SCB_DisableICache();
-        SCB_DisableDCache();
-        #endif
-        __set_MSP(*(volatile uint32_t*)0x08000000);
-        ((void (*)(uint32_t)) *((volatile uint32_t*)(0x08000000 + 4)))(0x70ad0000);
+        powerctrl_enter_bootloader(0x70ad0000, 0x08000000);
     }
 
     if (n_args == 1 && mp_obj_is_str_or_bytes(args[0])) {
         // With a string/bytes given, pass its data to the custom bootloader
         size_t len;
         const char *data = mp_obj_str_get_data(args[0], &len);
-        void *mboot_region = (void*)*((volatile uint32_t*)0x08000000);
+        void *mboot_region = (void *)*((volatile uint32_t *)0x08000000);
         memmove(mboot_region, data, len);
-        #if __DCACHE_PRESENT == 1
-        SCB_DisableICache();
-        SCB_DisableDCache();
-        #endif
-        __set_MSP(*(volatile uint32_t*)0x08000000);
-        ((void (*)(uint32_t)) *((volatile uint32_t*)(0x08000000 + 4)))(0x70ad0080);
+        powerctrl_enter_bootloader(0x70ad0080, 0x08000000);
     }
     #endif
 
-#if defined(STM32F7) || defined(STM32H7)
-    // arm-none-eabi-gcc 4.9.0 does not correctly inline this
-    // MSP function, so we write it out explicitly here.
-    //__set_MSP(*((uint32_t*) 0x1FF00000));
-    __ASM volatile ("movw r3, #0x0000\nmovt r3, #0x1FF0\nldr r3, [r3, #0]\nMSR msp, r3\n" : : : "r3", "sp");
-
-    ((void (*)(void)) *((uint32_t*) 0x1FF00004))();
-#else
-    __HAL_SYSCFG_REMAPMEMORY_SYSTEMFLASH();
-
-    // arm-none-eabi-gcc 4.9.0 does not correctly inline this
-    // MSP function, so we write it out explicitly here.
-    //__set_MSP(*((uint32_t*) 0x00000000));
-    __ASM volatile ("movs r3, #0\nldr r3, [r3, #0]\nMSR msp, r3\n" : : : "r3", "sp");
-
-    ((void (*)(void)) *((uint32_t*) 0x00000004))();
-#endif
+    #if defined(STM32F7) || defined(STM32H7)
+    powerctrl_enter_bootloader(0, 0x1ff00000);
+    #else
+    powerctrl_enter_bootloader(0, 0x00000000);
+    #endif
 
-    while (1);
+    while (1) {
+        ;
+    }
 }
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_bootloader_obj, 0, 1, machine_bootloader);
 
@@ -317,21 +297,26 @@ STATIC mp_obj_t machine_freq(size_t n_args, const mp_obj_t *args) {
     if (n_args == 0) {
         // get
         mp_obj_t tuple[] = {
-           mp_obj_new_int(HAL_RCC_GetSysClockFreq()),
-           mp_obj_new_int(HAL_RCC_GetHCLKFreq()),
-           mp_obj_new_int(HAL_RCC_GetPCLK1Freq()),
-           #if !defined(STM32F0)
-           mp_obj_new_int(HAL_RCC_GetPCLK2Freq()),
-           #endif
+            mp_obj_new_int(HAL_RCC_GetSysClockFreq()),
+            mp_obj_new_int(HAL_RCC_GetHCLKFreq()),
+            mp_obj_new_int(HAL_RCC_GetPCLK1Freq()),
+            #if !defined(STM32F0)
+            mp_obj_new_int(HAL_RCC_GetPCLK2Freq()),
+            #endif
         };
         return mp_obj_new_tuple(MP_ARRAY_SIZE(tuple), tuple);
     } else {
         // set
-        #if defined(STM32F0) || defined(STM32L4)
-        mp_raise_NotImplementedError("machine.freq set not supported yet");
+        #if defined(STM32F0) || defined(STM32L0) || defined(STM32L4) || defined(STM32WB)
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("machine.freq set not supported yet"));
         #else
         mp_int_t sysclk = mp_obj_get_int(args[0]);
         mp_int_t ahb = sysclk;
+        #if defined(STM32H7)
+        if (ahb > 200000000) {
+            ahb /= 2;
+        }
+        #endif
         mp_int_t apb1 = ahb / 4;
         mp_int_t apb2 = ahb / 2;
         if (n_args > 1) {
@@ -345,7 +330,7 @@ STATIC mp_obj_t machine_freq(size_t n_args, const mp_obj_t *args) {
         }
         int ret = powerctrl_set_sysclk(sysclk, ahb, apb1, apb2);
         if (ret == -MP_EINVAL) {
-            mp_raise_ValueError("invalid freq");
+            mp_raise_ValueError(MP_ERROR_TEXT("invalid freq"));
         } else if (ret < 0) {
             void NORETURN __fatal_error(const char *msg);
             __fatal_error("can't change freq");
@@ -389,17 +374,17 @@ STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_soft_reset),          MP_ROM_PTR(&machine_soft_reset_obj) },
     { MP_ROM_QSTR(MP_QSTR_bootloader),          MP_ROM_PTR(&machine_bootloader_obj) },
     { MP_ROM_QSTR(MP_QSTR_freq),                MP_ROM_PTR(&machine_freq_obj) },
-#if MICROPY_HW_ENABLE_RNG
+    #if MICROPY_HW_ENABLE_RNG
     { MP_ROM_QSTR(MP_QSTR_rng),                 MP_ROM_PTR(&pyb_rng_get_obj) },
-#endif
+    #endif
     { MP_ROM_QSTR(MP_QSTR_idle),                MP_ROM_PTR(&pyb_wfi_obj) },
     { MP_ROM_QSTR(MP_QSTR_sleep),               MP_ROM_PTR(&machine_lightsleep_obj) },
     { MP_ROM_QSTR(MP_QSTR_lightsleep),          MP_ROM_PTR(&machine_lightsleep_obj) },
     { MP_ROM_QSTR(MP_QSTR_deepsleep),           MP_ROM_PTR(&machine_deepsleep_obj) },
     { MP_ROM_QSTR(MP_QSTR_reset_cause),         MP_ROM_PTR(&machine_reset_cause_obj) },
-#if 0
+    #if 0
     { MP_ROM_QSTR(MP_QSTR_wake_reason),         MP_ROM_PTR(&machine_wake_reason_obj) },
-#endif
+    #endif
 
     { MP_ROM_QSTR(MP_QSTR_disable_irq),         MP_ROM_PTR(&pyb_disable_irq_obj) },
     { MP_ROM_QSTR(MP_QSTR_enable_irq),          MP_ROM_PTR(&pyb_enable_irq_obj) },
@@ -413,18 +398,16 @@ STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_Pin),                 MP_ROM_PTR(&pin_type) },
     { MP_ROM_QSTR(MP_QSTR_Signal),              MP_ROM_PTR(&machine_signal_type) },
 
-#if 0
     { MP_ROM_QSTR(MP_QSTR_RTC),                 MP_ROM_PTR(&pyb_rtc_type) },
-    { MP_ROM_QSTR(MP_QSTR_ADC),                 MP_ROM_PTR(&pyb_adc_type) },
-#endif
-#if MICROPY_PY_MACHINE_I2C
+    { MP_ROM_QSTR(MP_QSTR_ADC),                 MP_ROM_PTR(&machine_adc_type) },
+    #if MICROPY_PY_MACHINE_I2C
     { MP_ROM_QSTR(MP_QSTR_I2C),                 MP_ROM_PTR(&machine_i2c_type) },
-#endif
+    #endif
     { MP_ROM_QSTR(MP_QSTR_SPI),                 MP_ROM_PTR(&machine_hard_spi_type) },
     { MP_ROM_QSTR(MP_QSTR_UART),                MP_ROM_PTR(&pyb_uart_type) },
     { MP_ROM_QSTR(MP_QSTR_WDT),                 MP_ROM_PTR(&pyb_wdt_type) },
-#if 0
-    { MP_ROM_QSTR(MP_QSTR_Timer),               MP_ROM_PTR(&pyb_timer_type) },
+    { MP_ROM_QSTR(MP_QSTR_Timer),               MP_ROM_PTR(&machine_timer_type) },
+    #if 0
     { MP_ROM_QSTR(MP_QSTR_HeartBeat),           MP_ROM_PTR(&pyb_heartbeat_type) },
     { MP_ROM_QSTR(MP_QSTR_SD),                  MP_ROM_PTR(&pyb_sd_type) },
 
@@ -432,23 +415,23 @@ STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_IDLE),                MP_ROM_INT(PYB_PWR_MODE_ACTIVE) },
     { MP_ROM_QSTR(MP_QSTR_SLEEP),               MP_ROM_INT(PYB_PWR_MODE_LPDS) },
     { MP_ROM_QSTR(MP_QSTR_DEEPSLEEP),           MP_ROM_INT(PYB_PWR_MODE_HIBERNATE) },
-#endif
+    #endif
     { MP_ROM_QSTR(MP_QSTR_PWRON_RESET),         MP_ROM_INT(PYB_RESET_POWER_ON) },
     { MP_ROM_QSTR(MP_QSTR_HARD_RESET),          MP_ROM_INT(PYB_RESET_HARD) },
     { MP_ROM_QSTR(MP_QSTR_WDT_RESET),           MP_ROM_INT(PYB_RESET_WDT) },
     { MP_ROM_QSTR(MP_QSTR_DEEPSLEEP_RESET),     MP_ROM_INT(PYB_RESET_DEEPSLEEP) },
     { MP_ROM_QSTR(MP_QSTR_SOFT_RESET),          MP_ROM_INT(PYB_RESET_SOFT) },
-#if 0
+    #if 0
     { MP_ROM_QSTR(MP_QSTR_WLAN_WAKE),           MP_ROM_INT(PYB_SLP_WAKED_BY_WLAN) },
     { MP_ROM_QSTR(MP_QSTR_PIN_WAKE),            MP_ROM_INT(PYB_SLP_WAKED_BY_GPIO) },
     { MP_ROM_QSTR(MP_QSTR_RTC_WAKE),            MP_ROM_INT(PYB_SLP_WAKED_BY_RTC) },
-#endif
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(machine_module_globals, machine_module_globals_table);
 
 const mp_obj_module_t machine_module = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&machine_module_globals,
+    .globals = (mp_obj_dict_t *)&machine_module_globals,
 };
 
diff --git a/ports/stm32/modmachine.h b/ports/stm32/modmachine.h
index 414e5b37c7a60..f04bfb486bb81 100644
--- a/ports/stm32/modmachine.h
+++ b/ports/stm32/modmachine.h
@@ -28,6 +28,9 @@
 
 #include "py/obj.h"
 
+extern const mp_obj_type_t machine_adc_type;
+extern const mp_obj_type_t machine_timer_type;
+
 void machine_init(void);
 void machine_deinit(void);
 
diff --git a/ports/stm32/modnetwork.c b/ports/stm32/modnetwork.c
index ea43f75573680..4279df0884c3d 100644
--- a/ports/stm32/modnetwork.c
+++ b/ports/stm32/modnetwork.c
@@ -44,6 +44,9 @@
 #include "lwip/timeouts.h"
 #include "lwip/dns.h"
 #include "lwip/dhcp.h"
+#include "lwip/apps/mdns.h"
+#include "extmod/network_cyw43.h"
+#include "drivers/cyw43/cyw43.h"
 
 // Poll lwIP every 128ms
 #define LWIP_TICK(tick) (((tick) & ~(SYSTICK_DISPATCH_NUM_SLOTS - 1) & 0x7f) == 0)
@@ -53,15 +56,11 @@ u32_t sys_now(void) {
 }
 
 STATIC void pyb_lwip_poll(void) {
-    // Poll all the NICs for incoming data
-    for (struct netif *netif = netif_list; netif != NULL; netif = netif->next) {
-        if (netif->flags & NETIF_FLAG_LINK_UP) {
-            mod_network_nic_type_t *nic = netif->state;
-            if (nic->poll_callback) {
-                nic->poll_callback(nic, netif);
-            }
-        }
-    }
+    #if MICROPY_PY_WIZNET5K
+    // Poll the NIC for incoming data
+    wiznet5k_poll();
+    #endif
+
     // Run the lwIP internal updates
     sys_check_timeouts();
 }
@@ -70,6 +69,16 @@ void mod_network_lwip_poll_wrapper(uint32_t ticks_ms) {
     if (LWIP_TICK(ticks_ms)) {
         pendsv_schedule_dispatch(PENDSV_DISPATCH_LWIP, pyb_lwip_poll);
     }
+
+    #if MICROPY_PY_NETWORK_CYW43
+    if (cyw43_poll) {
+        if (cyw43_sleep != 0) {
+            if (--cyw43_sleep == 0) {
+                pendsv_schedule_dispatch(PENDSV_DISPATCH_CYW43, cyw43_poll);
+            }
+        }
+    }
+    #endif
 }
 
 #endif
@@ -101,11 +110,11 @@ mp_obj_t mod_network_find_nic(const uint8_t *ip) {
     for (mp_uint_t i = 0; i < MP_STATE_PORT(mod_network_nic_list).len; i++) {
         mp_obj_t nic = MP_STATE_PORT(mod_network_nic_list).items[i];
         // TODO check IP suitability here
-        //mod_network_nic_type_t *nic_type = (mod_network_nic_type_t*)mp_obj_get_type(nic);
+        // mod_network_nic_type_t *nic_type = (mod_network_nic_type_t*)mp_obj_get_type(nic);
         return nic;
     }
 
-    nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "no available NIC"));
+    mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("no available NIC"));
 }
 
 STATIC mp_obj_t network_route(void) {
@@ -119,6 +128,9 @@ STATIC const mp_rom_map_elem_t mp_module_network_globals_table[] = {
     #if defined(MICROPY_HW_ETH_MDC)
     { MP_ROM_QSTR(MP_QSTR_LAN), MP_ROM_PTR(&network_lan_type) },
     #endif
+    #if MICROPY_PY_NETWORK_CYW43
+    { MP_ROM_QSTR(MP_QSTR_WLAN), MP_ROM_PTR(&mp_network_cyw43_type) },
+    #endif
 
     #if MICROPY_PY_WIZNET5K
     { MP_ROM_QSTR(MP_QSTR_WIZNET5K), MP_ROM_PTR(&mod_network_nic_type_wiznet5k) },
@@ -128,13 +140,19 @@ STATIC const mp_rom_map_elem_t mp_module_network_globals_table[] = {
     #endif
 
     { MP_ROM_QSTR(MP_QSTR_route), MP_ROM_PTR(&network_route_obj) },
+
+    // Constants
+    #if MICROPY_PY_NETWORK_CYW43
+    { MP_ROM_QSTR(MP_QSTR_STA_IF), MP_ROM_INT(CYW43_ITF_STA)},
+    { MP_ROM_QSTR(MP_QSTR_AP_IF), MP_ROM_INT(CYW43_ITF_AP)},
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(mp_module_network_globals, mp_module_network_globals_table);
 
 const mp_obj_module_t mp_module_network = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_network_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_network_globals,
 };
 
 /*******************************************************************************/
@@ -147,10 +165,10 @@ mp_obj_t mod_network_nic_ifconfig(struct netif *netif, size_t n_args, const mp_o
         // Get IP addresses
         const ip_addr_t *dns = dns_getserver(0);
         mp_obj_t tuple[4] = {
-            netutils_format_ipv4_addr((uint8_t*)&netif->ip_addr, NETUTILS_BIG),
-            netutils_format_ipv4_addr((uint8_t*)&netif->netmask, NETUTILS_BIG),
-            netutils_format_ipv4_addr((uint8_t*)&netif->gw, NETUTILS_BIG),
-            netutils_format_ipv4_addr((uint8_t*)dns, NETUTILS_BIG),
+            netutils_format_ipv4_addr((uint8_t *)&netif->ip_addr, NETUTILS_BIG),
+            netutils_format_ipv4_addr((uint8_t *)&netif->netmask, NETUTILS_BIG),
+            netutils_format_ipv4_addr((uint8_t *)&netif->gw, NETUTILS_BIG),
+            netutils_format_ipv4_addr((uint8_t *)dns, NETUTILS_BIG),
         };
         return mp_obj_new_tuple(4, tuple);
     } else if (args[0] == MP_OBJ_NEW_QSTR(MP_QSTR_dhcp)) {
@@ -166,7 +184,7 @@ mp_obj_t mod_network_nic_ifconfig(struct netif *netif, size_t n_args, const mp_o
         uint32_t start = mp_hal_ticks_ms();
         while (!dhcp_supplied_address(netif)) {
             if (mp_hal_ticks_ms() - start > 10000) {
-                mp_raise_msg(&mp_type_OSError, "timeout waiting for DHCP to get IP address");
+                mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("timeout waiting for DHCP to get IP address"));
             }
             mp_hal_delay_ms(100);
         }
@@ -179,11 +197,11 @@ mp_obj_t mod_network_nic_ifconfig(struct netif *netif, size_t n_args, const mp_o
         // Set static IP addresses
         mp_obj_t *items;
         mp_obj_get_array_fixed_n(args[0], 4, &items);
-        netutils_parse_ipv4_addr(items[0], (uint8_t*)&netif->ip_addr, NETUTILS_BIG);
-        netutils_parse_ipv4_addr(items[1], (uint8_t*)&netif->netmask, NETUTILS_BIG);
-        netutils_parse_ipv4_addr(items[2], (uint8_t*)&netif->gw, NETUTILS_BIG);
+        netutils_parse_ipv4_addr(items[0], (uint8_t *)&netif->ip_addr, NETUTILS_BIG);
+        netutils_parse_ipv4_addr(items[1], (uint8_t *)&netif->netmask, NETUTILS_BIG);
+        netutils_parse_ipv4_addr(items[2], (uint8_t *)&netif->gw, NETUTILS_BIG);
         ip_addr_t dns;
-        netutils_parse_ipv4_addr(items[3], (uint8_t*)&dns, NETUTILS_BIG);
+        netutils_parse_ipv4_addr(items[3], (uint8_t *)&dns, NETUTILS_BIG);
         dns_setserver(0, &dns);
         return mp_const_none;
     }
diff --git a/ports/stm32/modnetwork.h b/ports/stm32/modnetwork.h
index 41a0017dab007..0b6d0c4a7fbcf 100644
--- a/ports/stm32/modnetwork.h
+++ b/ports/stm32/modnetwork.h
@@ -39,17 +39,14 @@
 
 struct netif;
 
-typedef struct _mod_network_nic_type_t {
-    mp_obj_base_t base;
-    void (*poll_callback)(void *data, struct netif *netif);
-} mod_network_nic_type_t;
-
 extern const mp_obj_type_t network_lan_type;
 extern const mp_obj_type_t mod_network_nic_type_wiznet5k;
 
 void mod_network_lwip_poll_wrapper(uint32_t ticks_ms);
 mp_obj_t mod_network_nic_ifconfig(struct netif *netif, size_t n_args, const mp_obj_t *args);
 
+void wiznet5k_poll(void);
+
 #else
 
 struct _mod_network_socket_obj_t;
diff --git a/ports/stm32/modnwcc3k.c b/ports/stm32/modnwcc3k.c
index 8723994f45251..b52958ba2291f 100644
--- a/ports/stm32/modnwcc3k.c
+++ b/ports/stm32/modnwcc3k.c
@@ -52,8 +52,8 @@
 #include "patch_prog.h"
 
 #define MAX_ADDRSTRLEN      (128)
-#define MAX_RX_PACKET       (CC3000_RX_BUFFER_SIZE-CC3000_MINIMAL_RX_SIZE-1)
-#define MAX_TX_PACKET       (CC3000_TX_BUFFER_SIZE-CC3000_MINIMAL_TX_SIZE-1)
+#define MAX_RX_PACKET       (CC3000_RX_BUFFER_SIZE - CC3000_MINIMAL_RX_SIZE - 1)
+#define MAX_TX_PACKET       (CC3000_TX_BUFFER_SIZE - CC3000_MINIMAL_TX_SIZE - 1)
 
 #define MAKE_SOCKADDR(addr, ip, port) \
     sockaddr addr; \
@@ -115,7 +115,7 @@ STATIC void cc3k_callback(long event_type, char *data, unsigned char length) {
 STATIC int cc3k_gethostbyname(mp_obj_t nic, const char *name, mp_uint_t len, uint8_t *out_ip) {
     uint32_t ip;
     // CC3000 gethostbyname is unreliable and usually returns -95 on first call
-    for (int retry = 5; CC3000_EXPORT(gethostbyname)((char*)name, len, &ip) < 0; retry--) {
+    for (int retry = 5; CC3000_EXPORT(gethostbyname)((char *)name, len, &ip) < 0; retry--) {
         if (retry == 0 || CC3000_EXPORT(errno) != -95) {
             return CC3000_EXPORT(errno);
         }
@@ -143,10 +143,18 @@ STATIC int cc3k_socket_socket(mod_network_socket_obj_t *socket, int *_errno) {
 
     mp_uint_t type;
     switch (socket->u_param.type) {
-        case MOD_NETWORK_SOCK_STREAM: type = SOCK_STREAM; break;
-        case MOD_NETWORK_SOCK_DGRAM: type = SOCK_DGRAM; break;
-        case MOD_NETWORK_SOCK_RAW: type = SOCK_RAW; break;
-        default: *_errno = MP_EINVAL; return -1;
+        case MOD_NETWORK_SOCK_STREAM:
+            type = SOCK_STREAM;
+            break;
+        case MOD_NETWORK_SOCK_DGRAM:
+            type = SOCK_DGRAM;
+            break;
+        case MOD_NETWORK_SOCK_RAW:
+            type = SOCK_RAW;
+            break;
+        default:
+            *_errno = MP_EINVAL;
+            return -1;
     }
 
     // open socket
@@ -215,7 +223,7 @@ STATIC int cc3k_socket_accept(mod_network_socket_obj_t *socket, mod_network_sock
 
     // return ip and port
     // it seems CC3000 returns little endian for accept??
-    //UNPACK_SOCKADDR(addr, ip, *port);
+    // UNPACK_SOCKADDR(addr, ip, *port);
     *port = (addr.sa_data[1] << 8) | addr.sa_data[0];
     ip[3] = addr.sa_data[2];
     ip[2] = addr.sa_data[3];
@@ -247,7 +255,7 @@ STATIC mp_uint_t cc3k_socket_send(mod_network_socket_obj_t *socket, const byte *
     mp_int_t bytes = 0;
     while (bytes < len) {
         int n = MIN((len - bytes), MAX_TX_PACKET);
-        n = CC3000_EXPORT(send)(socket->u_state, (uint8_t*)buf + bytes, n, 0);
+        n = CC3000_EXPORT(send)(socket->u_state, (uint8_t *)buf + bytes, n, 0);
         if (n <= 0) {
             *_errno = CC3000_EXPORT(errno);
             return -1;
@@ -291,7 +299,7 @@ STATIC mp_uint_t cc3k_socket_recv(mod_network_socket_obj_t *socket, byte *buf, m
 
 STATIC mp_uint_t cc3k_socket_sendto(mod_network_socket_obj_t *socket, const byte *buf, mp_uint_t len, byte *ip, mp_uint_t port, int *_errno) {
     MAKE_SOCKADDR(addr, ip, port)
-    int ret = CC3000_EXPORT(sendto)(socket->u_state, (byte*)buf, len, 0, (sockaddr*)&addr, sizeof(addr));
+    int ret = CC3000_EXPORT(sendto)(socket->u_state, (byte *)buf, len, 0, (sockaddr *)&addr, sizeof(addr));
     if (ret < 0) {
         *_errno = CC3000_EXPORT(errno);
         return -1;
@@ -416,7 +424,7 @@ typedef struct _cc3k_obj_t {
     mp_obj_base_t base;
 } cc3k_obj_t;
 
-STATIC const cc3k_obj_t cc3k_obj = {{(mp_obj_type_t*)&mod_network_nic_type_cc3k}};
+STATIC const cc3k_obj_t cc3k_obj = {{(mp_obj_type_t *)&mod_network_nic_type_cc3k}};
 
 // \classmethod \constructor(spi, pin_cs, pin_en, pin_irq)
 // Initialise the CC3000 using the given SPI bus and pins and return a CC3K object.
@@ -436,24 +444,24 @@ STATIC mp_obj_t cc3k_make_new(const mp_obj_type_t *type, size_t n_args, size_t n
         pin_find(args[1]),
         pin_find(args[2]),
         pin_find(args[3])
-    );
+        );
 
     // initialize and start the module
     wlan_init(cc3k_callback, NULL, NULL, NULL,
-            ReadWlanInterruptPin, SpiResumeSpi, SpiPauseSpi, WriteWlanPin);
+        ReadWlanInterruptPin, SpiResumeSpi, SpiPauseSpi, WriteWlanPin);
 
     if (wlan_start(0) != 0) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "failed to init CC3000 module"));
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("failed to init CC3000 module"));
     }
 
     // set connection policy. this should be called explicitly by the user
     // wlan_ioctl_set_connection_policy(0, 0, 0);
 
     // Mask out all non-required events from the CC3000
-    wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|
-                        HCI_EVNT_WLAN_UNSOL_INIT|
-                        HCI_EVNT_WLAN_ASYNC_PING_REPORT|
-                        HCI_EVNT_WLAN_ASYNC_SIMPLE_CONFIG_DONE);
+    wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE |
+        HCI_EVNT_WLAN_UNSOL_INIT |
+        HCI_EVNT_WLAN_ASYNC_PING_REPORT |
+        HCI_EVNT_WLAN_ASYNC_SIMPLE_CONFIG_DONE);
 
     // register with network module
     mod_network_register_nic((mp_obj_t)&cc3k_obj);
@@ -494,8 +502,8 @@ STATIC mp_obj_t cc3k_connect(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
     }
 
     // connect to AP
-    if (wlan_connect(sec, (char*)ssid, ssid_len, (uint8_t*)bssid, (uint8_t*)key, key_len) != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, "could not connect to ssid=%s, sec=%d, key=%s\n", ssid, sec, key));
+    if (wlan_connect(sec, (char *)ssid, ssid_len, (uint8_t *)bssid, (uint8_t *)key, key_len) != 0) {
+        mp_raise_msg_varg(&mp_type_OSError, MP_ERROR_TEXT("could not connect to ssid=%s, sec=%d, key=%s\n"), ssid, sec, key);
     }
 
     return mp_const_none;
@@ -531,7 +539,7 @@ STATIC mp_obj_t cc3k_ifconfig(mp_obj_t self_in) {
         netutils_format_ipv4_addr(ipconfig.aucDNSServer, NETUTILS_LITTLE),
         netutils_format_ipv4_addr(ipconfig.aucDHCPServer, NETUTILS_LITTLE),
         mp_obj_new_str(mac_vstr.buf, mac_vstr.len),
-        mp_obj_new_str((const char*)ipconfig.uaSSID, strlen((const char*)ipconfig.uaSSID)),
+        mp_obj_new_str((const char *)ipconfig.uaSSID, strlen((const char *)ipconfig.uaSSID)),
     };
     return mp_obj_new_tuple(MP_ARRAY_SIZE(tuple), tuple);
 }
@@ -581,7 +589,7 @@ const mod_network_nic_type_t mod_network_nic_type_cc3k = {
         { &mp_type_type },
         .name = MP_QSTR_CC3K,
         .make_new = cc3k_make_new,
-        .locals_dict = (mp_obj_dict_t*)&cc3k_locals_dict,
+        .locals_dict = (mp_obj_dict_t *)&cc3k_locals_dict,
     },
     .gethostbyname = cc3k_gethostbyname,
     .socket = cc3k_socket_socket,
diff --git a/ports/stm32/modnwwiznet5k.c b/ports/stm32/modnwwiznet5k.c
index bf4b72ff215c3..204b9fcc3f0cd 100644
--- a/ports/stm32/modnwwiznet5k.c
+++ b/ports/stm32/modnwwiznet5k.c
@@ -79,7 +79,7 @@ STATIC void wiz_spi_read(uint8_t *buf, uint32_t len) {
 }
 
 STATIC void wiz_spi_write(const uint8_t *buf, uint32_t len) {
-    HAL_StatusTypeDef status = HAL_SPI_Transmit(wiznet5k_obj.spi->spi, (uint8_t*)buf, len, 5000);
+    HAL_StatusTypeDef status = HAL_SPI_Transmit(wiznet5k_obj.spi->spi, (uint8_t *)buf, len, 5000);
     (void)status;
 }
 
@@ -87,7 +87,7 @@ STATIC int wiznet5k_gethostbyname(mp_obj_t nic, const char *name, mp_uint_t len,
     uint8_t dns_ip[MOD_NETWORK_IPADDR_BUF_SIZE] = {8, 8, 8, 8};
     uint8_t *buf = m_new(uint8_t, MAX_DNS_BUF_SIZE);
     DNS_init(0, buf);
-    mp_int_t ret = DNS_run(dns_ip, (uint8_t*)name, out_ip);
+    mp_int_t ret = DNS_run(dns_ip, (uint8_t *)name, out_ip);
     m_del(uint8_t, buf, MAX_DNS_BUF_SIZE);
     if (ret == 1) {
         // success
@@ -105,9 +105,15 @@ STATIC int wiznet5k_socket_socket(mod_network_socket_obj_t *socket, int *_errno)
     }
 
     switch (socket->u_param.type) {
-        case MOD_NETWORK_SOCK_STREAM: socket->u_param.type = Sn_MR_TCP; break;
-        case MOD_NETWORK_SOCK_DGRAM: socket->u_param.type = Sn_MR_UDP; break;
-        default: *_errno = MP_EINVAL; return -1;
+        case MOD_NETWORK_SOCK_STREAM:
+            socket->u_param.type = Sn_MR_TCP;
+            break;
+        case MOD_NETWORK_SOCK_DGRAM:
+            socket->u_param.type = Sn_MR_UDP;
+            break;
+        default:
+            *_errno = MP_EINVAL;
+            return -1;
     }
 
     if (socket->u_param.fileno == -1) {
@@ -185,11 +191,11 @@ STATIC int wiznet5k_socket_accept(mod_network_socket_obj_t *socket, mod_network_
             socket->u_param.fileno = -1;
             int _errno2;
             if (wiznet5k_socket_socket(socket, &_errno2) != 0) {
-                //printf("(bad resocket %d)\n", _errno2);
+                // printf("(bad resocket %d)\n", _errno2);
             } else if (wiznet5k_socket_bind(socket, NULL, *port, &_errno2) != 0) {
-                //printf("(bad rebind %d)\n", _errno2);
+                // printf("(bad rebind %d)\n", _errno2);
             } else if (wiznet5k_socket_listen(socket, 0, &_errno2) != 0) {
-                //printf("(bad relisten %d)\n", _errno2);
+                // printf("(bad relisten %d)\n", _errno2);
             }
 
             return 0;
@@ -226,7 +232,7 @@ STATIC int wiznet5k_socket_connect(mod_network_socket_obj_t *socket, byte *ip, m
 
 STATIC mp_uint_t wiznet5k_socket_send(mod_network_socket_obj_t *socket, const byte *buf, mp_uint_t len, int *_errno) {
     MP_THREAD_GIL_EXIT();
-    mp_int_t ret = WIZCHIP_EXPORT(send)(socket->u_param.fileno, (byte*)buf, len);
+    mp_int_t ret = WIZCHIP_EXPORT(send)(socket->u_param.fileno, (byte *)buf, len);
     MP_THREAD_GIL_ENTER();
 
     // TODO convert Wiz errno's to POSIX ones
@@ -261,7 +267,7 @@ STATIC mp_uint_t wiznet5k_socket_sendto(mod_network_socket_obj_t *socket, const
     }
 
     MP_THREAD_GIL_EXIT();
-    mp_int_t ret = WIZCHIP_EXPORT(sendto)(socket->u_param.fileno, (byte*)buf, len, ip, port);
+    mp_int_t ret = WIZCHIP_EXPORT(sendto)(socket->u_param.fileno, (byte *)buf, len, ip, port);
     MP_THREAD_GIL_ENTER();
 
     if (ret < 0) {
@@ -344,7 +350,7 @@ STATIC mp_obj_t wiznet5k_make_new(const mp_obj_type_t *type, size_t n_args, size
     mp_arg_check_num(n_args, n_kw, 3, 3, false);
 
     // init the wiznet5k object
-    wiznet5k_obj.base.type = (mp_obj_type_t*)&mod_network_nic_type_wiznet5k;
+    wiznet5k_obj.base.type = (mp_obj_type_t *)&mod_network_nic_type_wiznet5k;
     wiznet5k_obj.cris_state = 0;
     wiznet5k_obj.spi = spi_from_mp_obj(args[0]);
     wiznet5k_obj.cs = pin_find(args[1]);
@@ -390,7 +396,7 @@ STATIC mp_obj_t wiznet5k_make_new(const mp_obj_type_t *type, size_t n_args, size
         .dns = {8, 8, 8, 8}, // Google public DNS
         .dhcp = NETINFO_STATIC,
     };
-    ctlnetwork(CN_SET_NETINFO, (void*)&netinfo);
+    ctlnetwork(CN_SET_NETINFO, (void *)&netinfo);
 
     // seems we need a small delay after init
     mp_hal_delay_ms(250);
@@ -405,7 +411,7 @@ STATIC mp_obj_t wiznet5k_make_new(const mp_obj_type_t *type, size_t n_args, size
 /// \method regs()
 /// Dump WIZNET5K registers.
 STATIC mp_obj_t wiznet5k_regs(mp_obj_t self_in) {
-    //wiznet5k_obj_t *self = self_in;
+    // wiznet5k_obj_t *self = self_in;
     printf("Wiz CREG:");
     for (int i = 0; i < 0x50; ++i) {
         if (i % 16 == 0) {
@@ -484,7 +490,7 @@ const mod_network_nic_type_t mod_network_nic_type_wiznet5k = {
         { &mp_type_type },
         .name = MP_QSTR_WIZNET5K,
         .make_new = wiznet5k_make_new,
-        .locals_dict = (mp_obj_dict_t*)&wiznet5k_locals_dict,
+        .locals_dict = (mp_obj_dict_t *)&wiznet5k_locals_dict,
     },
     .gethostbyname = wiznet5k_gethostbyname,
     .socket = wiznet5k_socket_socket,
diff --git a/ports/stm32/modpyb.c b/ports/stm32/modpyb.c
index 85c6ee1381b4f..321fb62e9a162 100644
--- a/ports/stm32/modpyb.c
+++ b/ports/stm32/modpyb.c
@@ -56,6 +56,8 @@
 #include "extmod/vfs.h"
 #include "extmod/utime_mphal.h"
 
+char pyb_country_code[2];
+
 STATIC mp_obj_t pyb_fault_debug(mp_obj_t value) {
     pyb_hard_fault_debug = mp_obj_is_true(value);
     return mp_const_none;
@@ -105,13 +107,29 @@ STATIC mp_obj_t pyb_repl_uart(size_t n_args, const mp_obj_t *args) {
             MP_STATE_PORT(pyb_stdio_uart) = MP_OBJ_TO_PTR(args[0]);
             uart_attach_to_repl(MP_STATE_PORT(pyb_stdio_uart), true);
         } else {
-            mp_raise_ValueError("need a UART object");
+            mp_raise_ValueError(MP_ERROR_TEXT("need a UART object"));
         }
         return mp_const_none;
     }
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_repl_uart_obj, 0, 1, pyb_repl_uart);
 
+STATIC mp_obj_t pyb_country(size_t n_args, const mp_obj_t *args) {
+    if (n_args == 0) {
+        return mp_obj_new_str(pyb_country_code, 2);
+    } else {
+        size_t len;
+        const char *str = mp_obj_str_get_data(args[0], &len);
+        if (len != 2) {
+            mp_raise_ValueError(NULL);
+        }
+        pyb_country_code[0] = str[0];
+        pyb_country_code[1] = str[1];
+        return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_country_obj, 0, 1, pyb_country);
+
 STATIC const mp_rom_map_elem_t pyb_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_pyb) },
 
@@ -124,7 +142,9 @@ STATIC const mp_rom_map_elem_t pyb_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_unique_id), MP_ROM_PTR(&machine_unique_id_obj) },
     { MP_ROM_QSTR(MP_QSTR_freq), MP_ROM_PTR(&machine_freq_obj) },
     #endif
+    #if MICROPY_REPL_INFO
     { MP_ROM_QSTR(MP_QSTR_repl_info), MP_ROM_PTR(&pyb_set_repl_info_obj) },
+    #endif
 
     { MP_ROM_QSTR(MP_QSTR_wfi), MP_ROM_PTR(&pyb_wfi_obj) },
     { MP_ROM_QSTR(MP_QSTR_disable_irq), MP_ROM_PTR(&pyb_disable_irq_obj) },
@@ -139,19 +159,24 @@ STATIC const mp_rom_map_elem_t pyb_module_globals_table[] = {
     #endif
     { MP_ROM_QSTR(MP_QSTR_main), MP_ROM_PTR(&pyb_main_obj) },
     { MP_ROM_QSTR(MP_QSTR_repl_uart), MP_ROM_PTR(&pyb_repl_uart_obj) },
+    { MP_ROM_QSTR(MP_QSTR_country), MP_ROM_PTR(&pyb_country_obj) },
 
     #if MICROPY_HW_ENABLE_USB
     { MP_ROM_QSTR(MP_QSTR_usb_mode), MP_ROM_PTR(&pyb_usb_mode_obj) },
+    #if MICROPY_HW_USB_HID
     { MP_ROM_QSTR(MP_QSTR_hid_mouse), MP_ROM_PTR(&pyb_usb_hid_mouse_obj) },
     { MP_ROM_QSTR(MP_QSTR_hid_keyboard), MP_ROM_PTR(&pyb_usb_hid_keyboard_obj) },
-    { MP_ROM_QSTR(MP_QSTR_USB_VCP), MP_ROM_PTR(&pyb_usb_vcp_type) },
     { MP_ROM_QSTR(MP_QSTR_USB_HID), MP_ROM_PTR(&pyb_usb_hid_type) },
+    #endif
+    { MP_ROM_QSTR(MP_QSTR_USB_VCP), MP_ROM_PTR(&pyb_usb_vcp_type) },
     #if MICROPY_PY_PYB_LEGACY
     // these 2 are deprecated; use USB_VCP.isconnected and USB_HID.send instead
     { MP_ROM_QSTR(MP_QSTR_have_cdc), MP_ROM_PTR(&pyb_have_cdc_obj) },
+    #if MICROPY_HW_USB_HID
     { MP_ROM_QSTR(MP_QSTR_hid), MP_ROM_PTR(&pyb_hid_send_report_obj) },
     #endif
     #endif
+    #endif
 
     #if MICROPY_PY_PYB_LEGACY
     { MP_ROM_QSTR(MP_QSTR_millis), MP_ROM_PTR(&mp_utime_ticks_ms_obj) },
@@ -169,74 +194,74 @@ STATIC const mp_rom_map_elem_t pyb_module_globals_table[] = {
 
     { MP_ROM_QSTR(MP_QSTR_Timer), MP_ROM_PTR(&pyb_timer_type) },
 
-#if MICROPY_HW_ENABLE_RNG
+    #if MICROPY_HW_ENABLE_RNG
     { MP_ROM_QSTR(MP_QSTR_rng), MP_ROM_PTR(&pyb_rng_get_obj) },
-#endif
+    #endif
 
-#if MICROPY_HW_ENABLE_RTC
+    #if MICROPY_HW_ENABLE_RTC
     { MP_ROM_QSTR(MP_QSTR_RTC), MP_ROM_PTR(&pyb_rtc_type) },
-#endif
+    #endif
 
     { MP_ROM_QSTR(MP_QSTR_Pin), MP_ROM_PTR(&pin_type) },
     { MP_ROM_QSTR(MP_QSTR_ExtInt), MP_ROM_PTR(&extint_type) },
 
-#if MICROPY_HW_ENABLE_SERVO
+    #if MICROPY_HW_ENABLE_SERVO
     { MP_ROM_QSTR(MP_QSTR_pwm), MP_ROM_PTR(&pyb_pwm_set_obj) },
     { MP_ROM_QSTR(MP_QSTR_servo), MP_ROM_PTR(&pyb_servo_set_obj) },
     { MP_ROM_QSTR(MP_QSTR_Servo), MP_ROM_PTR(&pyb_servo_type) },
-#endif
+    #endif
 
-#if MICROPY_HW_HAS_SWITCH
+    #if MICROPY_HW_HAS_SWITCH
     { MP_ROM_QSTR(MP_QSTR_Switch), MP_ROM_PTR(&pyb_switch_type) },
-#endif
+    #endif
 
-#if MICROPY_HW_HAS_FLASH
+    #if MICROPY_HW_HAS_FLASH
     { MP_ROM_QSTR(MP_QSTR_Flash), MP_ROM_PTR(&pyb_flash_type) },
-#endif
+    #endif
 
-#if MICROPY_HW_ENABLE_SDCARD
+    #if MICROPY_HW_ENABLE_SDCARD
     #if MICROPY_PY_PYB_LEGACY
     { MP_ROM_QSTR(MP_QSTR_SD), MP_ROM_PTR(&pyb_sdcard_obj) }, // now obsolete
     #endif
     { MP_ROM_QSTR(MP_QSTR_SDCard), MP_ROM_PTR(&pyb_sdcard_type) },
-#endif
+    #endif
     #if MICROPY_HW_ENABLE_MMCARD
     { MP_ROM_QSTR(MP_QSTR_MMCard), MP_ROM_PTR(&pyb_mmcard_type) },
     #endif
 
-#if defined(MICROPY_HW_LED1)
+    #if defined(MICROPY_HW_LED1)
     { MP_ROM_QSTR(MP_QSTR_LED), MP_ROM_PTR(&pyb_led_type) },
-#endif
+    #endif
     #if MICROPY_PY_PYB_LEGACY && MICROPY_HW_ENABLE_HW_I2C
     { MP_ROM_QSTR(MP_QSTR_I2C), MP_ROM_PTR(&pyb_i2c_type) },
     #endif
     { MP_ROM_QSTR(MP_QSTR_SPI), MP_ROM_PTR(&pyb_spi_type) },
     { MP_ROM_QSTR(MP_QSTR_UART), MP_ROM_PTR(&pyb_uart_type) },
-#if MICROPY_HW_ENABLE_CAN
+    #if MICROPY_HW_ENABLE_CAN
     { MP_ROM_QSTR(MP_QSTR_CAN), MP_ROM_PTR(&pyb_can_type) },
-#endif
+    #endif
 
     #if MICROPY_HW_ENABLE_ADC
     { MP_ROM_QSTR(MP_QSTR_ADC), MP_ROM_PTR(&pyb_adc_type) },
     { MP_ROM_QSTR(MP_QSTR_ADCAll), MP_ROM_PTR(&pyb_adc_all_type) },
     #endif
 
-#if MICROPY_HW_ENABLE_DAC
+    #if MICROPY_HW_ENABLE_DAC
     { MP_ROM_QSTR(MP_QSTR_DAC), MP_ROM_PTR(&pyb_dac_type) },
-#endif
+    #endif
 
-#if MICROPY_HW_HAS_MMA7660
+    #if MICROPY_HW_HAS_MMA7660 || MICROPY_HW_HAS_KXTJ3
     { MP_ROM_QSTR(MP_QSTR_Accel), MP_ROM_PTR(&pyb_accel_type) },
-#endif
+    #endif
 
-#if MICROPY_HW_HAS_LCD
+    #if MICROPY_HW_HAS_LCD
     { MP_ROM_QSTR(MP_QSTR_LCD), MP_ROM_PTR(&pyb_lcd_type) },
-#endif
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(pyb_module_globals, pyb_module_globals_table);
 
 const mp_obj_module_t pyb_module = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&pyb_module_globals,
+    .globals = (mp_obj_dict_t *)&pyb_module_globals,
 };
diff --git a/ports/stm32/modstm.c b/ports/stm32/modstm.c
index 3fae3a57c4e0b..418b8bde2a14e 100644
--- a/ports/stm32/modstm.c
+++ b/ports/stm32/modstm.c
@@ -43,14 +43,14 @@ STATIC const mp_rom_map_elem_t stm_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_mem16), MP_ROM_PTR(&machine_mem16_obj) },
     { MP_ROM_QSTR(MP_QSTR_mem32), MP_ROM_PTR(&machine_mem32_obj) },
 
-#include "genhdr/modstm_const.h"
+    #include "genhdr/modstm_const.h"
 };
 
 STATIC MP_DEFINE_CONST_DICT(stm_module_globals, stm_module_globals_table);
 
 const mp_obj_module_t stm_module = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&stm_module_globals,
+    .globals = (mp_obj_dict_t *)&stm_module_globals,
 };
 
 #endif // MICROPY_PY_STM
diff --git a/ports/stm32/modules/dht.py b/ports/stm32/modules/dht.py
deleted file mode 120000
index 2aa2f5cbfed8a..0000000000000
--- a/ports/stm32/modules/dht.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../drivers/dht/dht.py
\ No newline at end of file
diff --git a/ports/stm32/modules/lcd160cr.py b/ports/stm32/modules/lcd160cr.py
deleted file mode 120000
index 9e63f1d23f851..0000000000000
--- a/ports/stm32/modules/lcd160cr.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../drivers/display/lcd160cr.py
\ No newline at end of file
diff --git a/ports/stm32/modules/lcd160cr_test.py b/ports/stm32/modules/lcd160cr_test.py
deleted file mode 120000
index 5f5bcc1281807..0000000000000
--- a/ports/stm32/modules/lcd160cr_test.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../drivers/display/lcd160cr_test.py
\ No newline at end of file
diff --git a/ports/stm32/modules/onewire.py b/ports/stm32/modules/onewire.py
deleted file mode 120000
index 33f30e84f11cd..0000000000000
--- a/ports/stm32/modules/onewire.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../drivers/onewire/onewire.py
\ No newline at end of file
diff --git a/ports/stm32/moduos.c b/ports/stm32/moduos.c
index ead2380b33253..6f9740c645fe5 100644
--- a/ports/stm32/moduos.c
+++ b/ports/stm32/moduos.c
@@ -36,6 +36,7 @@
 #include "extmod/misc.h"
 #include "extmod/vfs.h"
 #include "extmod/vfs_fat.h"
+#include "extmod/vfs_lfs.h"
 #include "genhdr/mpversion.h"
 #include "rng.h"
 #include "usb.h"
@@ -73,7 +74,7 @@ STATIC MP_DEFINE_ATTRTUPLE(
     MP_ROM_PTR(&os_uname_info_release_obj),
     MP_ROM_PTR(&os_uname_info_version_obj),
     MP_ROM_PTR(&os_uname_info_machine_obj)
-);
+    );
 
 STATIC mp_obj_t os_uname(void) {
     return MP_OBJ_FROM_PTR(&os_uname_info_obj);
@@ -110,12 +111,12 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_urandom_obj, os_urandom);
 #endif
 
 bool mp_uos_dupterm_is_builtin_stream(mp_const_obj_t stream) {
-    mp_obj_type_t *type = mp_obj_get_type(stream);
+    const mp_obj_type_t *type = mp_obj_get_type(stream);
     return type == &pyb_uart_type
-        #if MICROPY_HW_ENABLE_USB
-        || type == &pyb_usb_vcp_type
-        #endif
-        ;
+           #if MICROPY_HW_ENABLE_USB
+           || type == &pyb_usb_vcp_type
+           #endif
+    ;
 }
 
 STATIC mp_obj_t uos_dupterm(size_t n_args, const mp_obj_t *args) {
@@ -163,9 +164,9 @@ STATIC const mp_rom_map_elem_t os_module_globals_table[] = {
     /// \constant sep - separation character used in paths
     { MP_ROM_QSTR(MP_QSTR_sep), MP_ROM_QSTR(MP_QSTR__slash_) },
 
-#if MICROPY_HW_ENABLE_RNG
+    #if MICROPY_HW_ENABLE_RNG
     { MP_ROM_QSTR(MP_QSTR_urandom), MP_ROM_PTR(&os_urandom_obj) },
-#endif
+    #endif
 
     // these are MicroPython extensions
     { MP_ROM_QSTR(MP_QSTR_dupterm), MP_ROM_PTR(&uos_dupterm_obj) },
@@ -174,11 +175,17 @@ STATIC const mp_rom_map_elem_t os_module_globals_table[] = {
     #if MICROPY_VFS_FAT
     { MP_ROM_QSTR(MP_QSTR_VfsFat), MP_ROM_PTR(&mp_fat_vfs_type) },
     #endif
+    #if MICROPY_VFS_LFS1
+    { MP_ROM_QSTR(MP_QSTR_VfsLfs1), MP_ROM_PTR(&mp_type_vfs_lfs1) },
+    #endif
+    #if MICROPY_VFS_LFS2
+    { MP_ROM_QSTR(MP_QSTR_VfsLfs2), MP_ROM_PTR(&mp_type_vfs_lfs2) },
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(os_module_globals, os_module_globals_table);
 
 const mp_obj_module_t mp_module_uos = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&os_module_globals,
+    .globals = (mp_obj_dict_t *)&os_module_globals,
 };
diff --git a/ports/stm32/modusocket.c b/ports/stm32/modusocket.c
index 7503ecbd68d20..2732d472b5cdc 100644
--- a/ports/stm32/modusocket.c
+++ b/ports/stm32/modusocket.c
@@ -71,7 +71,7 @@ STATIC void socket_select_nic(mod_network_socket_obj_t *self, const byte *ip) {
     if (self->nic == MP_OBJ_NULL) {
         // select NIC based on IP
         self->nic = mod_network_find_nic(ip);
-        self->nic_type = (mod_network_nic_type_t*)mp_obj_get_type(self->nic);
+        self->nic_type = (mod_network_nic_type_t *)mp_obj_get_type(self->nic);
 
         // call the NIC to open the socket
         int _errno;
@@ -125,6 +125,11 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_listen_obj, socket_listen);
 STATIC mp_obj_t socket_accept(mp_obj_t self_in) {
     mod_network_socket_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
+    if (self->nic == MP_OBJ_NULL) {
+        // not bound
+        mp_raise_OSError(MP_EINVAL);
+    }
+
     // create new socket object
     // starts with empty NIC so that finaliser doesn't run close() method if accept() fails
     mod_network_socket_obj_t *socket2 = m_new_obj_with_finaliser(mod_network_socket_obj_t);
@@ -203,7 +208,7 @@ STATIC mp_obj_t socket_recv(mp_obj_t self_in, mp_obj_t len_in) {
     vstr_t vstr;
     vstr_init_len(&vstr, len);
     int _errno;
-    mp_uint_t ret = self->nic_type->recv(self, (byte*)vstr.buf, len, &_errno);
+    mp_uint_t ret = self->nic_type->recv(self, (byte *)vstr.buf, len, &_errno);
     if (ret == -1) {
         mp_raise_OSError(_errno);
     }
@@ -253,7 +258,7 @@ STATIC mp_obj_t socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in) {
     byte ip[4];
     mp_uint_t port;
     int _errno;
-    mp_int_t ret = self->nic_type->recvfrom(self, (byte*)vstr.buf, vstr.len, ip, &port, &_errno);
+    mp_int_t ret = self->nic_type->recvfrom(self, (byte *)vstr.buf, vstr.len, ip, &port, &_errno);
     if (ret == -1) {
         mp_raise_OSError(_errno);
     }
@@ -314,7 +319,7 @@ STATIC mp_obj_t socket_settimeout(mp_obj_t self_in, mp_obj_t timeout_in) {
         timeout = -1;
     } else {
         #if MICROPY_PY_BUILTINS_FLOAT
-        timeout = 1000 * mp_obj_get_float(timeout_in);
+        timeout = (mp_uint_t)(MICROPY_FLOAT_CONST(1000.0) * mp_obj_get_float(timeout_in));
         #else
         timeout = 1000 * mp_obj_get_int(timeout_in);
         #endif
@@ -364,6 +369,13 @@ mp_uint_t socket_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *
         }
         return 0;
     }
+    if (self->nic == MP_OBJ_NULL) {
+        if (request == MP_STREAM_POLL) {
+            return MP_STREAM_POLL_NVAL;
+        }
+        *errcode = MP_EINVAL;
+        return MP_STREAM_ERROR;
+    }
     return self->nic_type->ioctl(self, request, arg, errcode);
 }
 
@@ -377,7 +389,7 @@ STATIC const mp_obj_type_t socket_type = {
     .name = MP_QSTR_socket,
     .make_new = socket_make_new,
     .protocol = &socket_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&socket_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&socket_locals_dict,
 };
 
 /******************************************************************************/
@@ -407,7 +419,7 @@ STATIC mp_obj_t mod_usocket_getaddrinfo(mp_obj_t host_in, mp_obj_t port_in) {
         // find a NIC that can do a name lookup
         for (mp_uint_t i = 0; i < MP_STATE_PORT(mod_network_nic_list).len; i++) {
             mp_obj_t nic = MP_STATE_PORT(mod_network_nic_list).items[i];
-            mod_network_nic_type_t *nic_type = (mod_network_nic_type_t*)mp_obj_get_type(nic);
+            mod_network_nic_type_t *nic_type = (mod_network_nic_type_t *)mp_obj_get_type(nic);
             if (nic_type->gethostbyname != NULL) {
                 int ret = nic_type->gethostbyname(nic, host, hlen, out_ip);
                 if (ret != 0) {
@@ -420,7 +432,7 @@ STATIC mp_obj_t mod_usocket_getaddrinfo(mp_obj_t host_in, mp_obj_t port_in) {
     }
 
     if (!have_ip) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "no available NIC"));
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("no available NIC"));
     }
 
     mp_obj_tuple_t *tuple = MP_OBJ_TO_PTR(mp_obj_new_tuple(5, NULL));
@@ -429,7 +441,7 @@ STATIC mp_obj_t mod_usocket_getaddrinfo(mp_obj_t host_in, mp_obj_t port_in) {
     tuple->items[2] = MP_OBJ_NEW_SMALL_INT(0);
     tuple->items[3] = MP_OBJ_NEW_QSTR(MP_QSTR_);
     tuple->items[4] = netutils_format_inet_addr(out_ip, port, NETUTILS_BIG);
-    return mp_obj_new_list(1, (mp_obj_t*)&tuple);
+    return mp_obj_new_list(1, (mp_obj_t *)&tuple);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_usocket_getaddrinfo_obj, mod_usocket_getaddrinfo);
 
@@ -462,7 +474,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_usocket_globals, mp_module_usocket_globals
 
 const mp_obj_module_t mp_module_usocket = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_usocket_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_usocket_globals,
 };
 
 #endif // MICROPY_PY_USOCKET && !MICROPY_PY_LWIP
diff --git a/ports/stm32/modutime.c b/ports/stm32/modutime.c
index 6b5c841151494..77ec7468c99b6 100644
--- a/ports/stm32/modutime.c
+++ b/ports/stm32/modutime.c
@@ -106,12 +106,12 @@ STATIC mp_obj_t time_mktime(mp_obj_t tuple) {
 
     // localtime generates a tuple of len 8. CPython uses 9, so we accept both.
     if (len < 8 || len > 9) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "mktime needs a tuple of length 8 or 9 (%d given)", len));
+        mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("mktime needs a tuple of length 8 or 9 (%d given)"), len);
     }
 
     return mp_obj_new_int_from_uint(timeutils_mktime(mp_obj_get_int(elem[0]),
-            mp_obj_get_int(elem[1]), mp_obj_get_int(elem[2]), mp_obj_get_int(elem[3]),
-            mp_obj_get_int(elem[4]), mp_obj_get_int(elem[5])));
+        mp_obj_get_int(elem[1]), mp_obj_get_int(elem[2]), mp_obj_get_int(elem[3]),
+        mp_obj_get_int(elem[4]), mp_obj_get_int(elem[5])));
 }
 MP_DEFINE_CONST_FUN_OBJ_1(time_mktime_obj, time_mktime);
 
@@ -149,5 +149,5 @@ STATIC MP_DEFINE_CONST_DICT(time_module_globals, time_module_globals_table);
 
 const mp_obj_module_t mp_module_utime = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&time_module_globals,
+    .globals = (mp_obj_dict_t *)&time_module_globals,
 };
diff --git a/ports/stm32/mpconfigboard_common.h b/ports/stm32/mpconfigboard_common.h
index 1ace8fcaf4160..127696b19374a 100644
--- a/ports/stm32/mpconfigboard_common.h
+++ b/ports/stm32/mpconfigboard_common.h
@@ -102,6 +102,11 @@
 #define MICROPY_HW_ENABLE_MMCARD (0)
 #endif
 
+// SD/MMC interface bus width (defaults to 4 bits)
+#ifndef MICROPY_HW_SDMMC_BUS_WIDTH
+#define MICROPY_HW_SDMMC_BUS_WIDTH (4)
+#endif
+
 // Whether to automatically mount (and boot from) the SD card if it's present
 #ifndef MICROPY_HW_SDCARD_MOUNT_AT_BOOT
 #define MICROPY_HW_SDCARD_MOUNT_AT_BOOT (MICROPY_HW_ENABLE_SDCARD)
@@ -138,6 +143,7 @@
 
 #define MP_HAL_UNIQUE_ID_ADDRESS (0x1ffff7ac)
 #define PYB_EXTI_NUM_VECTORS (23)
+#define MICROPY_HW_MAX_I2C (2)
 #define MICROPY_HW_MAX_TIMER (17)
 #define MICROPY_HW_MAX_UART (8)
 
@@ -146,9 +152,16 @@
 
 #define MP_HAL_UNIQUE_ID_ADDRESS (0x1fff7a10)
 #define PYB_EXTI_NUM_VECTORS (23)
+#define MICROPY_HW_MAX_I2C (3)
 #define MICROPY_HW_MAX_TIMER (14)
-#ifdef UART8
+#if defined(UART10)
+#define MICROPY_HW_MAX_UART (10)
+#elif defined(UART9)
+#define MICROPY_HW_MAX_UART (9)
+#elif defined(UART8)
 #define MICROPY_HW_MAX_UART (8)
+#elif defined(UART7)
+#define MICROPY_HW_MAX_UART (7)
 #else
 #define MICROPY_HW_MAX_UART (6)
 #endif
@@ -163,6 +176,7 @@
 #endif
 
 #define PYB_EXTI_NUM_VECTORS (24)
+#define MICROPY_HW_MAX_I2C (4)
 #define MICROPY_HW_MAX_TIMER (17)
 #define MICROPY_HW_MAX_UART (8)
 
@@ -171,17 +185,37 @@
 
 #define MP_HAL_UNIQUE_ID_ADDRESS (0x1ff1e800)
 #define PYB_EXTI_NUM_VECTORS (24)
+#define MICROPY_HW_MAX_I2C (4)
 #define MICROPY_HW_MAX_TIMER (17)
 #define MICROPY_HW_MAX_UART (8)
 
+// Configuration for STM32L0 series
+#elif defined(STM32L0)
+
+#define MP_HAL_UNIQUE_ID_ADDRESS (0x1FF80050)
+#define PYB_EXTI_NUM_VECTORS (30) // TODO (22 configurable, 7 direct)
+#define MICROPY_HW_MAX_I2C (3)
+#define MICROPY_HW_MAX_TIMER (22)
+#define MICROPY_HW_MAX_UART (5)
+
 // Configuration for STM32L4 series
 #elif defined(STM32L4)
 
 #define MP_HAL_UNIQUE_ID_ADDRESS (0x1fff7590)
 #define PYB_EXTI_NUM_VECTORS (23)
+#define MICROPY_HW_MAX_I2C (4)
 #define MICROPY_HW_MAX_TIMER (17)
 #define MICROPY_HW_MAX_UART (6)
 
+// Configuration for STM32WB series
+#elif defined(STM32WB)
+
+#define MP_HAL_UNIQUE_ID_ADDRESS (UID_BASE)
+#define PYB_EXTI_NUM_VECTORS (20)
+#define MICROPY_HW_MAX_I2C (3)
+#define MICROPY_HW_MAX_TIMER (17)
+#define MICROPY_HW_MAX_UART (1)
+
 #else
 #error Unsupported MCU series
 #endif
@@ -210,6 +244,12 @@
 #endif
 #endif
 
+// If disabled then try normal (non-bypass) LSE first, with fallback to LSI.
+// If enabled first try LSE in bypass mode.  If that fails to start, try non-bypass mode, with fallback to LSI.
+#ifndef MICROPY_HW_RTC_USE_BYPASS
+#define MICROPY_HW_RTC_USE_BYPASS (0)
+#endif
+
 #if MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE
 // Provide block device macros if internal flash storage is enabled
 #define MICROPY_HW_BDEV_IOCTL flash_bdev_ioctl
@@ -233,10 +273,39 @@
 #endif
 
 // Enable CAN if there are any peripherals defined
-#if defined(MICROPY_HW_CAN1_TX) || defined(MICROPY_HW_CAN2_TX)
+#if defined(MICROPY_HW_CAN1_TX) || defined(MICROPY_HW_CAN2_TX) || defined(MICROPY_HW_CAN3_TX)
 #define MICROPY_HW_ENABLE_CAN (1)
+#if defined(STM32H7)
+#define MICROPY_HW_ENABLE_FDCAN (1) // define for MCUs with FDCAN
+#endif
 #else
 #define MICROPY_HW_ENABLE_CAN (0)
+#define MICROPY_HW_MAX_CAN (0)
+#endif
+#if defined(MICROPY_HW_CAN3_TX)
+#define MICROPY_HW_MAX_CAN (3)
+#elif defined(MICROPY_HW_CAN2_TX)
+#define MICROPY_HW_MAX_CAN (2)
+#elif defined(MICROPY_HW_CAN1_TX)
+#define MICROPY_HW_MAX_CAN (1)
+#endif
+
+// Whether the USB peripheral is device-only, or multiple OTG
+#if defined(STM32L0) || defined(STM32L432xx) || defined(STM32WB)
+#define MICROPY_HW_USB_IS_MULTI_OTG (0)
+#else
+#define MICROPY_HW_USB_IS_MULTI_OTG (1)
+#endif
+
+// Configure maximum number of CDC VCP interfaces, and whether MSC/HID are supported
+#ifndef MICROPY_HW_USB_CDC_NUM
+#define MICROPY_HW_USB_CDC_NUM (1)
+#endif
+#ifndef MICROPY_HW_USB_MSC
+#define MICROPY_HW_USB_MSC (MICROPY_HW_ENABLE_USB)
+#endif
+#ifndef MICROPY_HW_USB_HID
+#define MICROPY_HW_USB_HID (MICROPY_HW_ENABLE_USB)
 #endif
 
 // Pin definition header file
@@ -245,11 +314,11 @@
 // D-cache clean/invalidate helpers
 #if __DCACHE_PRESENT == 1
 #define MP_HAL_CLEANINVALIDATE_DCACHE(addr, size) \
-    (SCB_CleanInvalidateDCache_by_Addr((uint32_t*)((uint32_t)addr & ~0x1f), \
-        ((uint32_t)((uint8_t*)addr + size + 0x1f) & ~0x1f) - ((uint32_t)addr & ~0x1f)))
+    (SCB_CleanInvalidateDCache_by_Addr((uint32_t *)((uint32_t)addr & ~0x1f), \
+    ((uint32_t)((uint8_t *)addr + size + 0x1f) & ~0x1f) - ((uint32_t)addr & ~0x1f)))
 #define MP_HAL_CLEAN_DCACHE(addr, size) \
-    (SCB_CleanDCache_by_Addr((uint32_t*)((uint32_t)addr & ~0x1f), \
-        ((uint32_t)((uint8_t*)addr + size + 0x1f) & ~0x1f) - ((uint32_t)addr & ~0x1f)))
+    (SCB_CleanDCache_by_Addr((uint32_t *)((uint32_t)addr & ~0x1f), \
+    ((uint32_t)((uint8_t *)addr + size + 0x1f) & ~0x1f) - ((uint32_t)addr & ~0x1f)))
 #else
 #define MP_HAL_CLEANINVALIDATE_DCACHE(addr, size)
 #define MP_HAL_CLEAN_DCACHE(addr, size)
diff --git a/ports/stm32/mpconfigport.h b/ports/stm32/mpconfigport.h
index 7cb67a115ac25..13dce6e96d334 100644
--- a/ports/stm32/mpconfigport.h
+++ b/ports/stm32/mpconfigport.h
@@ -70,6 +70,7 @@
 #define MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE (0)
 #define MICROPY_KBD_EXCEPTION       (1)
 #define MICROPY_HELPER_REPL         (1)
+#define MICROPY_REPL_INFO           (1)
 #define MICROPY_REPL_EMACS_KEYS     (1)
 #define MICROPY_REPL_AUTO_INDENT    (1)
 #define MICROPY_LONGINT_IMPL        (MICROPY_LONGINT_IMPL_MPZ)
@@ -84,9 +85,6 @@
 #define MICROPY_ENABLE_SCHEDULER    (1)
 #define MICROPY_SCHEDULER_DEPTH     (8)
 #define MICROPY_VFS                 (1)
-#ifndef MICROPY_VFS_FAT
-#define MICROPY_VFS_FAT             (1)
-#endif
 
 // control over Python builtins
 #define MICROPY_PY_FUNCTION_ATTRS   (1)
@@ -99,21 +97,25 @@
 #define MICROPY_PY_BUILTINS_MEMORYVIEW (1)
 #define MICROPY_PY_BUILTINS_FROZENSET (1)
 #define MICROPY_PY_BUILTINS_SLICE_ATTRS (1)
+#define MICROPY_PY_BUILTINS_SLICE_INDICES (1)
 #define MICROPY_PY_BUILTINS_ROUND_INT (1)
 #define MICROPY_PY_ALL_SPECIAL_METHODS (1)
-#define MICROPY_PY_BUILTINS_COMPILE (1)
-#define MICROPY_PY_BUILTINS_EXECFILE (1)
+#define MICROPY_PY_BUILTINS_COMPILE (MICROPY_ENABLE_COMPILER)
+#define MICROPY_PY_BUILTINS_EXECFILE (MICROPY_ENABLE_COMPILER)
 #define MICROPY_PY_BUILTINS_NOTIMPLEMENTED (1)
 #define MICROPY_PY_BUILTINS_INPUT   (1)
 #define MICROPY_PY_BUILTINS_POW3    (1)
 #define MICROPY_PY_BUILTINS_HELP    (1)
+#ifndef MICROPY_PY_BUILTINS_HELP_TEXT
 #define MICROPY_PY_BUILTINS_HELP_TEXT stm32_help_text
+#endif
 #define MICROPY_PY_BUILTINS_HELP_MODULES (1)
 #define MICROPY_PY_MICROPYTHON_MEM_INFO (1)
 #define MICROPY_PY_ARRAY_SLICE_ASSIGN (1)
 #define MICROPY_PY_COLLECTIONS_DEQUE (1)
 #define MICROPY_PY_COLLECTIONS_ORDEREDDICT (1)
 #define MICROPY_PY_MATH_SPECIAL_FUNCTIONS (1)
+#define MICROPY_PY_MATH_ISCLOSE     (1)
 #define MICROPY_PY_MATH_FACTORIAL   (1)
 #define MICROPY_PY_CMATH            (1)
 #define MICROPY_PY_IO               (1)
@@ -132,21 +134,50 @@
 #endif
 
 // extended modules
+#ifndef MICROPY_PY_UASYNCIO
+#define MICROPY_PY_UASYNCIO         (1)
+#endif
+#ifndef MICROPY_PY_UCTYPES
 #define MICROPY_PY_UCTYPES          (1)
+#endif
+#ifndef MICROPY_PY_UZLIB
 #define MICROPY_PY_UZLIB            (1)
+#endif
+#ifndef MICROPY_PY_UJSON
 #define MICROPY_PY_UJSON            (1)
+#endif
+#ifndef MICROPY_PY_URE
 #define MICROPY_PY_URE              (1)
+#endif
+#ifndef MICROPY_PY_URE_SUB
 #define MICROPY_PY_URE_SUB          (1)
+#endif
+#ifndef MICROPY_PY_UHEAPQ
 #define MICROPY_PY_UHEAPQ           (1)
+#endif
+#ifndef MICROPY_PY_UHASHLIB
 #define MICROPY_PY_UHASHLIB         (1)
+#endif
+#define MICROPY_PY_UHASHLIB_MD5     (MICROPY_PY_USSL)
+#define MICROPY_PY_UHASHLIB_SHA1    (MICROPY_PY_USSL)
+#define MICROPY_PY_UCRYPTOLIB       (MICROPY_PY_USSL)
+#ifndef MICROPY_PY_UBINASCII
 #define MICROPY_PY_UBINASCII        (1)
+#endif
+#ifndef MICROPY_PY_URANDOM
 #define MICROPY_PY_URANDOM          (1)
+#endif
+#ifndef MICROPY_PY_URANDOM_EXTRA_FUNCS
 #define MICROPY_PY_URANDOM_EXTRA_FUNCS (1)
+#endif
 #define MICROPY_PY_USELECT          (1)
+#ifndef MICROPY_PY_UTIMEQ
 #define MICROPY_PY_UTIMEQ           (1)
+#endif
 #define MICROPY_PY_UTIME_MP_HAL     (1)
 #define MICROPY_PY_OS_DUPTERM       (3)
 #define MICROPY_PY_UOS_DUPTERM_BUILTIN_STREAM (1)
+#define MICROPY_PY_LWIP_SOCK_RAW    (MICROPY_PY_LWIP)
 #define MICROPY_PY_MACHINE          (1)
 #define MICROPY_PY_MACHINE_PULSE    (1)
 #define MICROPY_PY_MACHINE_PIN_MAKE_NEW mp_pin_make_new
@@ -160,7 +191,11 @@
 #define MICROPY_PY_MACHINE_SPI_MAKE_NEW machine_hard_spi_make_new
 #define MICROPY_HW_SOFTSPI_MIN_DELAY (0)
 #define MICROPY_HW_SOFTSPI_MAX_BAUDRATE (HAL_RCC_GetSysClockFreq() / 48)
+#define MICROPY_PY_UWEBSOCKET       (MICROPY_PY_LWIP)
+#define MICROPY_PY_WEBREPL          (MICROPY_PY_LWIP)
+#ifndef MICROPY_PY_FRAMEBUF
 #define MICROPY_PY_FRAMEBUF         (1)
+#endif
 #ifndef MICROPY_PY_USOCKET
 #define MICROPY_PY_USOCKET          (1)
 #endif
@@ -213,15 +248,12 @@ extern const struct _mp_obj_module_t mp_module_onewire;
 #if MICROPY_PY_USOCKET && MICROPY_PY_LWIP
 // usocket implementation provided by lwIP
 #define SOCKET_BUILTIN_MODULE               { MP_ROM_QSTR(MP_QSTR_usocket), MP_ROM_PTR(&mp_module_lwip) },
-#define SOCKET_BUILTIN_MODULE_WEAK_LINKS    { MP_ROM_QSTR(MP_QSTR_socket), MP_ROM_PTR(&mp_module_lwip) },
 #elif MICROPY_PY_USOCKET
 // usocket implementation provided by skeleton wrapper
 #define SOCKET_BUILTIN_MODULE               { MP_ROM_QSTR(MP_QSTR_usocket), MP_ROM_PTR(&mp_module_usocket) },
-#define SOCKET_BUILTIN_MODULE_WEAK_LINKS    { MP_ROM_QSTR(MP_QSTR_socket), MP_ROM_PTR(&mp_module_usocket) },
 #else
 // no usocket module
 #define SOCKET_BUILTIN_MODULE
-#define SOCKET_BUILTIN_MODULE_WEAK_LINKS
 #endif
 
 #if MICROPY_PY_NETWORK
@@ -240,24 +272,6 @@ extern const struct _mp_obj_module_t mp_module_onewire;
     NETWORK_BUILTIN_MODULE \
     { MP_ROM_QSTR(MP_QSTR__onewire), MP_ROM_PTR(&mp_module_onewire) }, \
 
-#define MICROPY_PORT_BUILTIN_MODULE_WEAK_LINKS \
-    { MP_ROM_QSTR(MP_QSTR_binascii), MP_ROM_PTR(&mp_module_ubinascii) }, \
-    { MP_ROM_QSTR(MP_QSTR_collections), MP_ROM_PTR(&mp_module_collections) }, \
-    { MP_ROM_QSTR(MP_QSTR_re), MP_ROM_PTR(&mp_module_ure) }, \
-    { MP_ROM_QSTR(MP_QSTR_zlib), MP_ROM_PTR(&mp_module_uzlib) }, \
-    { MP_ROM_QSTR(MP_QSTR_json), MP_ROM_PTR(&mp_module_ujson) }, \
-    { MP_ROM_QSTR(MP_QSTR_heapq), MP_ROM_PTR(&mp_module_uheapq) }, \
-    { MP_ROM_QSTR(MP_QSTR_hashlib), MP_ROM_PTR(&mp_module_uhashlib) }, \
-    { MP_ROM_QSTR(MP_QSTR_io), MP_ROM_PTR(&mp_module_io) }, \
-    { MP_ROM_QSTR(MP_QSTR_os), MP_ROM_PTR(&mp_module_uos) }, \
-    { MP_ROM_QSTR(MP_QSTR_random), MP_ROM_PTR(&mp_module_urandom) }, \
-    { MP_ROM_QSTR(MP_QSTR_time), MP_ROM_PTR(&mp_module_utime) }, \
-    { MP_ROM_QSTR(MP_QSTR_select), MP_ROM_PTR(&mp_module_uselect) }, \
-    SOCKET_BUILTIN_MODULE_WEAK_LINKS \
-    { MP_ROM_QSTR(MP_QSTR_struct), MP_ROM_PTR(&mp_module_ustruct) }, \
-    { MP_ROM_QSTR(MP_QSTR_machine), MP_ROM_PTR(&machine_module) }, \
-    { MP_ROM_QSTR(MP_QSTR_errno), MP_ROM_PTR(&mp_module_uerrno) }, \
-
 // extra constants
 #define MICROPY_PORT_CONSTANTS \
     { MP_ROM_QSTR(MP_QSTR_umachine), MP_ROM_PTR(&machine_module) }, \
@@ -267,6 +281,26 @@ extern const struct _mp_obj_module_t mp_module_onewire;
 
 #define MP_STATE_PORT MP_STATE_VM
 
+#if MICROPY_SSL_MBEDTLS
+#define MICROPY_PORT_ROOT_POINTER_MBEDTLS void **mbedtls_memory;
+#else
+#define MICROPY_PORT_ROOT_POINTER_MBEDTLS
+#endif
+
+#if MICROPY_BLUETOOTH_NIMBLE
+struct _mp_bluetooth_nimble_root_pointers_t;
+#define MICROPY_PORT_ROOT_POINTER_BLUETOOTH_NIMBLE void **bluetooth_nimble_memory; struct _mp_bluetooth_nimble_root_pointers_t *bluetooth_nimble_root_pointers;
+#else
+#define MICROPY_PORT_ROOT_POINTER_BLUETOOTH_NIMBLE
+#endif
+
+#if MICROPY_BLUETOOTH_BTSTACK
+struct _mp_bluetooth_btstack_root_pointers_t;
+#define MICROPY_PORT_ROOT_POINTER_BLUETOOTH_BTSTACK struct _mp_bluetooth_btstack_root_pointers_t *bluetooth_btstack_root_pointers;
+#else
+#define MICROPY_PORT_ROOT_POINTER_BLUETOOTH_BTSTACK
+#endif
+
 #define MICROPY_PORT_ROOT_POINTERS \
     const char *readline_hist[8]; \
     \
@@ -281,6 +315,8 @@ extern const struct _mp_obj_module_t mp_module_onewire;
     \
     mp_obj_t pyb_extint_callback[PYB_EXTI_NUM_VECTORS]; \
     \
+    struct _soft_timer_entry_t *soft_timer_heap; \
+    \
     /* pointers to all Timer objects (if they have been created) */ \
     struct _pyb_timer_obj_t *pyb_timer_obj_all[MICROPY_HW_MAX_TIMER]; \
     \
@@ -291,22 +327,29 @@ extern const struct _mp_obj_module_t mp_module_onewire;
     struct _pyb_uart_obj_t *pyb_uart_obj_all[MICROPY_HW_MAX_UART]; \
     \
     /* pointers to all CAN objects (if they have been created) */ \
-    struct _pyb_can_obj_t *pyb_can_obj_all[2]; \
+    struct _pyb_can_obj_t *pyb_can_obj_all[MICROPY_HW_MAX_CAN]; \
     \
     /* list of registered NICs */ \
     mp_obj_list_t mod_network_nic_list; \
+    \
+    MICROPY_PORT_ROOT_POINTER_MBEDTLS \
+    MICROPY_PORT_ROOT_POINTER_BLUETOOTH_NIMBLE \
+        MICROPY_PORT_ROOT_POINTER_BLUETOOTH_BTSTACK \
 
 // type definitions for the specific machine
 
-#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void*)((mp_uint_t)(p) | 1))
+#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)((uint32_t)(p) | 1))
 
 #define MP_SSIZE_MAX (0x7fffffff)
 
+// Assume that if we already defined the obj repr then we also defined these items
+#ifndef MICROPY_OBJ_REPR
 #define UINT_FMT "%u"
 #define INT_FMT "%d"
-
 typedef int mp_int_t; // must be pointer size
 typedef unsigned int mp_uint_t; // must be pointer size
+#endif
+
 typedef long mp_off_t;
 
 #define MP_PLAT_PRINT_STRN(str, len) mp_hal_stdout_tx_strn_cooked(str, len)
@@ -335,8 +378,8 @@ static inline mp_uint_t disable_irq(void) {
 #if MICROPY_PY_THREAD
 #define MICROPY_EVENT_POLL_HOOK \
     do { \
-        extern void mp_handle_pending(void); \
-        mp_handle_pending(); \
+        extern void mp_handle_pending(bool); \
+        mp_handle_pending(true); \
         if (pyb_thread_enabled) { \
             MP_THREAD_GIL_EXIT(); \
             pyb_thread_yield(); \
@@ -350,8 +393,8 @@ static inline mp_uint_t disable_irq(void) {
 #else
 #define MICROPY_EVENT_POLL_HOOK \
     do { \
-        extern void mp_handle_pending(void); \
-        mp_handle_pending(); \
+        extern void mp_handle_pending(bool); \
+        mp_handle_pending(true); \
         __WFI(); \
     } while (0);
 
@@ -359,9 +402,13 @@ static inline mp_uint_t disable_irq(void) {
 #endif
 
 // The LwIP interface must run at a raised IRQ priority
-#define MICROPY_PY_LWIP_ENTER   uint32_t irq_state = raise_irq_pri(IRQ_PRI_PENDSV);
-#define MICROPY_PY_LWIP_REENTER irq_state = raise_irq_pri(IRQ_PRI_PENDSV);
-#define MICROPY_PY_LWIP_EXIT    restore_irq_pri(irq_state);
+#define MICROPY_PY_LWIP_ENTER   uint32_t atomic_state = raise_irq_pri(IRQ_PRI_PENDSV);
+#define MICROPY_PY_LWIP_REENTER atomic_state = raise_irq_pri(IRQ_PRI_PENDSV);
+#define MICROPY_PY_LWIP_EXIT    restore_irq_pri(atomic_state);
+
+// Bluetooth calls must run at a raised IRQ priority
+#define MICROPY_PY_BLUETOOTH_ENTER MICROPY_PY_LWIP_ENTER
+#define MICROPY_PY_BLUETOOTH_EXIT MICROPY_PY_LWIP_EXIT
 
 // We need an implementation of the log2 function which is not a macro
 #define MP_NEED_LOG2 (1)
diff --git a/ports/stm32/mpconfigport.mk b/ports/stm32/mpconfigport.mk
index e708de6c1b0e1..c6b3ddc74f4e0 100644
--- a/ports/stm32/mpconfigport.mk
+++ b/ports/stm32/mpconfigport.mk
@@ -8,3 +8,6 @@ MICROPY_PY_WIZNET5K ?= 0
 
 # cc3k module for wifi support
 MICROPY_PY_CC3K ?= 0
+
+# VFS FAT FS support
+MICROPY_VFS_FAT ?= 1
diff --git a/ports/unix/mpconfigport_nanbox.h b/ports/stm32/mpconfigport_nanbox.h
similarity index 85%
rename from ports/unix/mpconfigport_nanbox.h
rename to ports/stm32/mpconfigport_nanbox.h
index 7da2cf7b80cb0..f36d55aca9b4c 100644
--- a/ports/unix/mpconfigport_nanbox.h
+++ b/ports/stm32/mpconfigport_nanbox.h
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 Damien P. George
+ * Copyright (c) 2019 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,20 +24,20 @@
  * THE SOFTWARE.
  */
 
-// select nan-boxing object model
+#include <stdint.h>
+
+// Select nan-boxing object model
 #define MICROPY_OBJ_REPR (MICROPY_OBJ_REPR_D)
 
-// native emitters don't work with nan-boxing
-#define MICROPY_EMIT_X86 (0)
-#define MICROPY_EMIT_X64 (0)
+// Native emitters don't work with nan-boxing
 #define MICROPY_EMIT_THUMB (0)
-#define MICROPY_EMIT_ARM (0)
-
-#include <stdint.h>
+#define MICROPY_EMIT_INLINE_THUMB (0)
 
-typedef int64_t mp_int_t;
-typedef uint64_t mp_uint_t;
+// Types needed for nan-boxing
 #define UINT_FMT "%llu"
 #define INT_FMT "%lld"
+typedef int64_t mp_int_t;
+typedef uint64_t mp_uint_t;
 
+// Include base configuration file for rest of configuration
 #include <mpconfigport.h>
diff --git a/ports/stm32/mphalport.c b/ports/stm32/mphalport.c
index c770b62d2e045..0e40911ed1852 100644
--- a/ports/stm32/mphalport.c
+++ b/ports/stm32/mphalport.c
@@ -1,6 +1,7 @@
 #include <string.h>
 
 #include "py/runtime.h"
+#include "py/stream.h"
 #include "py/mperrno.h"
 #include "py/mphal.h"
 #include "extmod/misc.h"
@@ -19,17 +20,28 @@ NORETURN void mp_hal_raise(HAL_StatusTypeDef status) {
     mp_raise_OSError(mp_hal_status_to_errno_table[status]);
 }
 
+MP_WEAK uintptr_t mp_hal_stdio_poll(uintptr_t poll_flags) {
+    uintptr_t ret = 0;
+    if (MP_STATE_PORT(pyb_stdio_uart) != NULL) {
+        mp_obj_t pyb_stdio_uart = MP_OBJ_FROM_PTR(MP_STATE_PORT(pyb_stdio_uart));
+        int errcode;
+        const mp_stream_p_t *stream_p = mp_get_stream(pyb_stdio_uart);
+        ret = stream_p->ioctl(pyb_stdio_uart, MP_STREAM_POLL, poll_flags, &errcode);
+    }
+    return ret | mp_uos_dupterm_poll(poll_flags);
+}
+
 MP_WEAK int mp_hal_stdin_rx_chr(void) {
     for (;;) {
-#if 0
-#ifdef USE_HOST_MODE
+        #if 0
+        #ifdef USE_HOST_MODE
         pyb_usb_host_process();
         int c = pyb_usb_host_get_keyboard();
         if (c != 0) {
             return c;
         }
-#endif
-#endif
+        #endif
+        #endif
         if (MP_STATE_PORT(pyb_stdio_uart) != NULL && uart_rx_any(MP_STATE_PORT(pyb_stdio_uart))) {
             return uart_rx_char(MP_STATE_PORT(pyb_stdio_uart));
         }
@@ -49,9 +61,9 @@ MP_WEAK void mp_hal_stdout_tx_strn(const char *str, size_t len) {
     if (MP_STATE_PORT(pyb_stdio_uart) != NULL) {
         uart_tx_strn(MP_STATE_PORT(pyb_stdio_uart), str, len);
     }
-#if 0 && defined(USE_HOST_MODE) && MICROPY_HW_HAS_LCD
+    #if 0 && defined(USE_HOST_MODE) && MICROPY_HW_HAS_LCD
     lcd_print_strn(str, len);
-#endif
+    #endif
     mp_uos_dupterm_tx_strn(str, len);
 }
 
@@ -108,7 +120,10 @@ void mp_hal_gpio_clock_enable(GPIO_TypeDef *gpio) {
     #elif defined(STM32H7)
     #define AHBxENR AHB4ENR
     #define AHBxENR_GPIOAEN_Pos RCC_AHB4ENR_GPIOAEN_Pos
-    #elif defined(STM32L4)
+    #elif defined(STM32L0)
+    #define AHBxENR IOPENR
+    #define AHBxENR_GPIOAEN_Pos RCC_IOPENR_IOPAEN_Pos
+    #elif defined(STM32L4) || defined(STM32WB)
     #define AHBxENR AHB2ENR
     #define AHBxENR_GPIOAEN_Pos RCC_AHB2ENR_GPIOAEN_Pos
     #endif
@@ -151,8 +166,11 @@ void mp_hal_pin_config_speed(mp_hal_pin_obj_t pin_obj, uint32_t speed) {
     gpio->OSPEEDR = (gpio->OSPEEDR & ~(3 << (2 * pin))) | (speed << (2 * pin));
 }
 
-MP_WEAK void mp_hal_get_mac(int idx, uint8_t buf[6]) {
-    // Generate a random locally administered MAC address (LAA)
+/*******************************************************************************/
+// MAC address
+
+// Generate a random locally administered MAC address (LAA)
+void mp_hal_generate_laa_mac(int idx, uint8_t buf[6]) {
     uint8_t *id = (uint8_t *)MP_HAL_UNIQUE_ID_ADDRESS;
     buf[0] = 0x02; // LAA range
     buf[1] = (id[11] << 4) | (id[10] & 0xf);
@@ -161,3 +179,17 @@ MP_WEAK void mp_hal_get_mac(int idx, uint8_t buf[6]) {
     buf[4] = id[2];
     buf[5] = (id[0] << 2) | idx;
 }
+
+// A board can override this if needed
+MP_WEAK void mp_hal_get_mac(int idx, uint8_t buf[6]) {
+    mp_hal_generate_laa_mac(idx, buf);
+}
+
+void mp_hal_get_mac_ascii(int idx, size_t chr_off, size_t chr_len, char *dest) {
+    static const char hexchr[16] = "0123456789ABCDEF";
+    uint8_t mac[6];
+    mp_hal_get_mac(idx, mac);
+    for (; chr_len; ++chr_off, --chr_len) {
+        *dest++ = hexchr[mac[chr_off >> 1] >> (4 * (1 - (chr_off & 1))) & 0xf];
+    }
+}
diff --git a/ports/stm32/mphalport.h b/ports/stm32/mphalport.h
index d828bb9dd4983..fe9378a1c7252 100644
--- a/ports/stm32/mphalport.h
+++ b/ports/stm32/mphalport.h
@@ -57,23 +57,18 @@ static inline mp_uint_t mp_hal_ticks_cpu(void) {
 #define MP_HAL_PIN_SPEED_HIGH           (GPIO_SPEED_FREQ_HIGH)
 #define MP_HAL_PIN_SPEED_VERY_HIGH      (GPIO_SPEED_FREQ_VERY_HIGH)
 
-#define mp_hal_pin_obj_t const pin_obj_t*
+#define mp_hal_pin_obj_t const pin_obj_t *
 #define mp_hal_get_pin_obj(o)   pin_find(o)
 #define mp_hal_pin_name(p)      ((p)->name)
 #define mp_hal_pin_input(p)     mp_hal_pin_config((p), MP_HAL_PIN_MODE_INPUT, MP_HAL_PIN_PULL_NONE, 0)
 #define mp_hal_pin_output(p)    mp_hal_pin_config((p), MP_HAL_PIN_MODE_OUTPUT, MP_HAL_PIN_PULL_NONE, 0)
 #define mp_hal_pin_open_drain(p) mp_hal_pin_config((p), MP_HAL_PIN_MODE_OPEN_DRAIN, MP_HAL_PIN_PULL_NONE, 0)
-#if defined(STM32H7)
-#define mp_hal_pin_high(p)      (((p)->gpio->BSRRL) = (p)->pin_mask)
-#define mp_hal_pin_low(p)       (((p)->gpio->BSRRH) = (p)->pin_mask)
-#else
 #define mp_hal_pin_high(p)      (((p)->gpio->BSRR) = (p)->pin_mask)
 #define mp_hal_pin_low(p)       (((p)->gpio->BSRR) = ((p)->pin_mask << 16))
-#endif
 #define mp_hal_pin_od_low(p)    mp_hal_pin_low(p)
 #define mp_hal_pin_od_high(p)   mp_hal_pin_high(p)
 #define mp_hal_pin_read(p)      (((p)->gpio->IDR >> (p)->pin) & 1)
-#define mp_hal_pin_write(p, v)  do { if (v) { mp_hal_pin_high(p); } else { mp_hal_pin_low(p); } } while (0)
+#define mp_hal_pin_write(p, v)  ((v) ? mp_hal_pin_high(p) : mp_hal_pin_low(p))
 
 void mp_hal_gpio_clock_enable(GPIO_TypeDef *gpio);
 void mp_hal_pin_config(mp_hal_pin_obj_t pin, uint32_t mode, uint32_t pull, uint32_t alt);
@@ -87,4 +82,6 @@ enum {
     MP_HAL_MAC_ETH0,
 };
 
+void mp_hal_generate_laa_mac(int idx, uint8_t buf[6]);
 void mp_hal_get_mac(int idx, uint8_t buf[6]);
+void mp_hal_get_mac_ascii(int idx, size_t chr_off, size_t chr_len, char *dest);
diff --git a/ports/stm32/mpthreadport.c b/ports/stm32/mpthreadport.c
index 7b3b92934b0f4..ecdb2684684c4 100644
--- a/ports/stm32/mpthreadport.c
+++ b/ports/stm32/mpthreadport.c
@@ -26,7 +26,7 @@
 
 #include <stdio.h>
 
-#include "py/mpstate.h"
+#include "py/runtime.h"
 #include "py/gc.h"
 #include "py/mpthread.h"
 #include "gccollect.h"
@@ -44,7 +44,7 @@ void mp_thread_init(void) {
 void mp_thread_gc_others(void) {
     mp_thread_mutex_lock(&thread_mutex, 1);
     for (pyb_thread_t *th = pyb_thread_all; th != NULL; th = th->all_next) {
-        gc_collect_root((void**)&th, 1);
+        gc_collect_root((void **)&th, 1);
         gc_collect_root(&th->arg, 1);
         gc_collect_root(&th->stack, 1);
         if (th != pyb_thread_cur) {
@@ -54,7 +54,7 @@ void mp_thread_gc_others(void) {
     mp_thread_mutex_unlock(&thread_mutex);
 }
 
-void mp_thread_create(void *(*entry)(void*), void *arg, size_t *stack_size) {
+void mp_thread_create(void *(*entry)(void *), void *arg, size_t *stack_size) {
     if (*stack_size == 0) {
         *stack_size = 4096; // default stack size
     } else if (*stack_size < 2048) {
@@ -75,7 +75,7 @@ void mp_thread_create(void *(*entry)(void*), void *arg, size_t *stack_size) {
     uint32_t id = pyb_thread_new(th, stack, stack_len, entry, arg);
     if (id == 0) {
         mp_thread_mutex_unlock(&thread_mutex);
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "can't create thread"));
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't create thread"));
     }
 
     mp_thread_mutex_unlock(&thread_mutex);
diff --git a/ports/stm32/mpthreadport.h b/ports/stm32/mpthreadport.h
index 8e2372dcb4350..e2b39979fb4c8 100644
--- a/ports/stm32/mpthreadport.h
+++ b/ports/stm32/mpthreadport.h
@@ -32,7 +32,7 @@ typedef pyb_mutex_t mp_thread_mutex_t;
 void mp_thread_init(void);
 void mp_thread_gc_others(void);
 
-static inline void mp_thread_set_state(void *state) {
+static inline void mp_thread_set_state(struct _mp_state_thread_t *state) {
     pyb_thread_set_local(state);
 }
 
diff --git a/ports/stm32/mpu.h b/ports/stm32/mpu.h
new file mode 100644
index 0000000000000..ff51f382eeec0
--- /dev/null
+++ b/ports/stm32/mpu.h
@@ -0,0 +1,105 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_STM32_MPU_H
+#define MICROPY_INCLUDED_STM32_MPU_H
+
+#if defined(STM32F7) || defined(STM32H7) || defined(MICROPY_HW_ETH_MDC)
+
+#define MPU_REGION_ETH      (MPU_REGION_NUMBER0)
+#define MPU_REGION_QSPI1    (MPU_REGION_NUMBER1)
+#define MPU_REGION_QSPI2    (MPU_REGION_NUMBER2)
+#define MPU_REGION_QSPI3    (MPU_REGION_NUMBER3)
+#define MPU_REGION_SDRAM1   (MPU_REGION_NUMBER4)
+#define MPU_REGION_SDRAM2   (MPU_REGION_NUMBER5)
+
+#define MPU_CONFIG_DISABLE(srd, size) ( \
+    MPU_INSTRUCTION_ACCESS_DISABLE << MPU_RASR_XN_Pos \
+        | MPU_REGION_NO_ACCESS << MPU_RASR_AP_Pos \
+        | MPU_TEX_LEVEL0 << MPU_RASR_TEX_Pos \
+        | MPU_ACCESS_NOT_SHAREABLE << MPU_RASR_S_Pos \
+        | MPU_ACCESS_NOT_CACHEABLE << MPU_RASR_C_Pos \
+        | MPU_ACCESS_NOT_BUFFERABLE << MPU_RASR_B_Pos \
+        | (srd) << MPU_RASR_SRD_Pos \
+        | (size) << MPU_RASR_SIZE_Pos \
+        | MPU_REGION_ENABLE << MPU_RASR_ENABLE_Pos \
+    )
+
+#define MPU_CONFIG_ETH(size) ( \
+    MPU_INSTRUCTION_ACCESS_DISABLE << MPU_RASR_XN_Pos \
+        | MPU_REGION_FULL_ACCESS << MPU_RASR_AP_Pos \
+        | MPU_TEX_LEVEL1 << MPU_RASR_TEX_Pos \
+        | MPU_ACCESS_SHAREABLE << MPU_RASR_S_Pos \
+        | MPU_ACCESS_NOT_CACHEABLE << MPU_RASR_C_Pos \
+        | MPU_ACCESS_NOT_BUFFERABLE << MPU_RASR_B_Pos \
+        | 0x00 << MPU_RASR_SRD_Pos \
+        | (size) << MPU_RASR_SIZE_Pos \
+        | MPU_REGION_ENABLE << MPU_RASR_ENABLE_Pos \
+    )
+
+#define MPU_CONFIG_SDRAM(size) ( \
+    MPU_INSTRUCTION_ACCESS_ENABLE << MPU_RASR_XN_Pos \
+        | MPU_REGION_FULL_ACCESS << MPU_RASR_AP_Pos \
+        | MPU_TEX_LEVEL1 << MPU_RASR_TEX_Pos \
+        | MPU_ACCESS_NOT_SHAREABLE << MPU_RASR_S_Pos \
+        | MPU_ACCESS_CACHEABLE << MPU_RASR_C_Pos \
+        | MPU_ACCESS_BUFFERABLE << MPU_RASR_B_Pos \
+        | 0x00 << MPU_RASR_SRD_Pos \
+        | (size) << MPU_RASR_SIZE_Pos \
+        | MPU_REGION_ENABLE << MPU_RASR_ENABLE_Pos \
+    )
+
+static inline void mpu_init(void) {
+    MPU->CTRL = MPU_PRIVILEGED_DEFAULT | MPU_CTRL_ENABLE_Msk;
+    SCB->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk;
+    __DSB();
+    __ISB();
+}
+
+static inline uint32_t mpu_config_start(void) {
+    return disable_irq();
+}
+
+static inline void mpu_config_region(uint32_t region, uint32_t base_addr, uint32_t attr_size) {
+    MPU->RNR = region;
+    MPU->RBAR = base_addr;
+    MPU->RASR = attr_size;
+}
+
+static inline void mpu_config_end(uint32_t irq_state) {
+    __ISB();
+    __DSB();
+    __DMB();
+    enable_irq(irq_state);
+}
+
+#else
+
+static inline void mpu_init(void) {
+}
+
+#endif
+
+#endif // MICROPY_INCLUDED_STM32_MPU_H
diff --git a/ports/stm32/network_lan.c b/ports/stm32/network_lan.c
index d89c23765c84b..19b4e786d9ea5 100644
--- a/ports/stm32/network_lan.c
+++ b/ports/stm32/network_lan.c
@@ -50,7 +50,7 @@ STATIC void network_lan_print(const mp_print_t *print, mp_obj_t self_in, mp_prin
         netif->ip_addr.addr >> 8 & 0xff,
         netif->ip_addr.addr >> 16 & 0xff,
         netif->ip_addr.addr >> 24
-    );
+        );
 }
 
 STATIC mp_obj_t network_lan_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
@@ -100,7 +100,7 @@ STATIC mp_obj_t network_lan_status(size_t n_args, const mp_obj_t *args) {
         return MP_OBJ_NEW_SMALL_INT(eth_link_status(self->eth));
     }
 
-    mp_raise_ValueError("unknown status param");
+    mp_raise_ValueError(MP_ERROR_TEXT("unknown status param"));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(network_lan_status_obj, 1, 2, network_lan_status);
 
@@ -110,7 +110,7 @@ STATIC mp_obj_t network_lan_config(size_t n_args, const mp_obj_t *args, mp_map_t
     if (kwargs->used == 0) {
         // Get config value
         if (n_args != 2) {
-            mp_raise_TypeError("must query one param");
+            mp_raise_TypeError(MP_ERROR_TEXT("must query one param"));
         }
 
         switch (mp_obj_str_get_qstr(args[1])) {
@@ -118,12 +118,12 @@ STATIC mp_obj_t network_lan_config(size_t n_args, const mp_obj_t *args, mp_map_t
                 return mp_obj_new_bytes(&eth_netif(self->eth)->hwaddr[0], 6);
             }
             default:
-                mp_raise_ValueError("unknown config param");
+                mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
         }
     } else {
         // Set config value(s)
         if (n_args != 1) {
-            mp_raise_TypeError("can't specify pos and kw args");
+            mp_raise_TypeError(MP_ERROR_TEXT("can't specify pos and kw args"));
         }
 
         for (size_t i = 0; i < kwargs->alloc; ++i) {
@@ -135,7 +135,7 @@ STATIC mp_obj_t network_lan_config(size_t n_args, const mp_obj_t *args, mp_map_t
                         break;
                     }
                     default:
-                        mp_raise_ValueError("unknown config param");
+                        mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
                 }
             }
         }
@@ -159,7 +159,7 @@ const mp_obj_type_t network_lan_type = {
     .name = MP_QSTR_LAN,
     .print = network_lan_print,
     .make_new = network_lan_make_new,
-    .locals_dict = (mp_obj_dict_t*)&network_lan_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&network_lan_locals_dict,
 };
 
 #endif // defined(MICROPY_HW_ETH_MDC)
diff --git a/ports/stm32/network_wiznet5k.c b/ports/stm32/network_wiznet5k.c
index 3bbe639acc316..c85ef5e88e7b0 100644
--- a/ports/stm32/network_wiznet5k.c
+++ b/ports/stm32/network_wiznet5k.c
@@ -48,7 +48,7 @@
 // Wiznet5k Ethernet driver in MACRAW mode
 
 typedef struct _wiznet5k_obj_t {
-    mod_network_nic_type_t base;
+    mp_obj_base_t base;
     mp_uint_t cris_state;
     const spi_t *spi;
     mp_hal_pin_obj_t cs;
@@ -63,7 +63,6 @@ typedef struct _wiznet5k_obj_t {
 STATIC wiznet5k_obj_t wiznet5k_obj;
 
 STATIC void wiznet5k_lwip_init(wiznet5k_obj_t *self);
-STATIC void wiznet5k_lwip_poll(void *self_in, struct netif *netif);
 
 STATIC void wiz_cris_enter(void) {
     wiznet5k_obj.cris_state = MICROPY_BEGIN_ATOMIC_SECTION();
@@ -87,7 +86,7 @@ STATIC void wiz_spi_read(uint8_t *buf, uint32_t len) {
 }
 
 STATIC void wiz_spi_write(const uint8_t *buf, uint32_t len) {
-    HAL_StatusTypeDef status = HAL_SPI_Transmit(wiznet5k_obj.spi->spi, (uint8_t*)buf, len, 5000);
+    HAL_StatusTypeDef status = HAL_SPI_Transmit(wiznet5k_obj.spi->spi, (uint8_t *)buf, len, 5000);
     (void)status;
 }
 
@@ -157,7 +156,7 @@ STATIC void wiznet5k_get_mac_address(wiznet5k_obj_t *self, uint8_t mac[6]) {
 
 STATIC void wiznet5k_send_ethernet(wiznet5k_obj_t *self, size_t len, const uint8_t *buf) {
     uint8_t ip[4] = {1, 1, 1, 1}; // dummy
-    int ret = WIZCHIP_EXPORT(sendto)(0, (byte*)buf, len, ip, 11); // dummy port
+    int ret = WIZCHIP_EXPORT(sendto)(0, (byte *)buf, len, ip, 11); // dummy port
     if (ret != len) {
         printf("wiznet5k_send_ethernet: fatal error %d\n", ret);
         netif_set_link_down(&self->netif);
@@ -176,7 +175,7 @@ STATIC uint16_t wiznet5k_recv_ethernet(wiznet5k_obj_t *self) {
     uint16_t port;
     int ret = WIZCHIP_EXPORT(recvfrom)(0, self->eth_frame, 1514, ip, &port);
     if (ret <= 0) {
-        printf("wiznet5k_lwip_poll: fatal error len=%u ret=%d\n", len, ret);
+        printf("wiznet5k_poll: fatal error len=%u ret=%d\n", len, ret);
         netif_set_link_down(&self->netif);
         netif_set_down(&self->netif);
         return 0;
@@ -237,8 +236,11 @@ STATIC void wiznet5k_lwip_init(wiznet5k_obj_t *self) {
     self->netif.flags &= ~NETIF_FLAG_UP;
 }
 
-STATIC void wiznet5k_lwip_poll(void *self_in, struct netif *netif) {
-    wiznet5k_obj_t *self = self_in;
+void wiznet5k_poll(void) {
+    wiznet5k_obj_t *self = &wiznet5k_obj;
+    if (!(self->netif.flags & NETIF_FLAG_LINK_UP)) {
+        return;
+    }
     uint16_t len;
     while ((len = wiznet5k_recv_ethernet(self)) > 0) {
         if (self->trace_flags & TRACE_ETH_RX) {
@@ -267,16 +269,15 @@ STATIC mp_obj_t wiznet5k_make_new(const mp_obj_type_t *type, size_t n_args, size
     mp_hal_pin_obj_t rst = pin_find(args[2]);
 
     // Access the existing object, if it has been constructed with the same hardware interface
-    if (wiznet5k_obj.base.base.type == &mod_network_nic_type_wiznet5k) {
+    if (wiznet5k_obj.base.type == &mod_network_nic_type_wiznet5k) {
         if (!(wiznet5k_obj.spi == spi && wiznet5k_obj.cs == cs && wiznet5k_obj.rst == rst
-            && wiznet5k_obj.netif.flags != 0)) {
+              && wiznet5k_obj.netif.flags != 0)) {
             wiznet5k_deinit();
         }
     }
 
     // Init the wiznet5k object
-    wiznet5k_obj.base.base.type = &mod_network_nic_type_wiznet5k;
-    wiznet5k_obj.base.poll_callback = wiznet5k_lwip_poll;
+    wiznet5k_obj.base.type = &mod_network_nic_type_wiznet5k;
     wiznet5k_obj.cris_state = 0;
     wiznet5k_obj.spi = spi;
     wiznet5k_obj.cs = cs;
@@ -326,7 +327,7 @@ STATIC mp_obj_t wiznet5k_isconnected(mp_obj_t self_in) {
         wizphy_getphylink() == PHY_LINK_ON
         && (self->netif.flags & NETIF_FLAG_UP)
         && self->netif.ip_addr.addr != 0
-    );
+        );
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(wiznet5k_isconnected_obj, wiznet5k_isconnected);
 
@@ -376,7 +377,7 @@ STATIC mp_obj_t wiznet5k_status(size_t n_args, const mp_obj_t *args) {
         }
     }
 
-    mp_raise_ValueError("unknown config param");
+    mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(wiznet5k_status_obj, 1, 2, wiznet5k_status);
 
@@ -386,7 +387,7 @@ STATIC mp_obj_t wiznet5k_config(size_t n_args, const mp_obj_t *args, mp_map_t *k
     if (kwargs->used == 0) {
         // Get config value
         if (n_args != 2) {
-            mp_raise_TypeError("must query one param");
+            mp_raise_TypeError(MP_ERROR_TEXT("must query one param"));
         }
 
         switch (mp_obj_str_get_qstr(args[1])) {
@@ -396,12 +397,12 @@ STATIC mp_obj_t wiznet5k_config(size_t n_args, const mp_obj_t *args, mp_map_t *k
                 return mp_obj_new_bytes(buf, 6);
             }
             default:
-                mp_raise_ValueError("unknown config param");
+                mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
         }
     } else {
         // Set config value(s)
         if (n_args != 1) {
-            mp_raise_TypeError("can't specify pos and kw args");
+            mp_raise_TypeError(MP_ERROR_TEXT("can't specify pos and kw args"));
         }
 
         for (size_t i = 0; i < kwargs->alloc; ++i) {
@@ -423,7 +424,7 @@ STATIC mp_obj_t wiznet5k_config(size_t n_args, const mp_obj_t *args, mp_map_t *k
                         break;
                     }
                     default:
-                        mp_raise_ValueError("unknown config param");
+                        mp_raise_ValueError(MP_ERROR_TEXT("unknown config param"));
                 }
             }
         }
@@ -458,7 +459,7 @@ const mp_obj_type_t mod_network_nic_type_wiznet5k = {
     { &mp_type_type },
     .name = MP_QSTR_WIZNET5K,
     .make_new = wiznet5k_make_new,
-    .locals_dict = (mp_obj_dict_t*)&wiznet5k_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&wiznet5k_locals_dict,
 };
 
 #endif // MICROPY_PY_WIZNET5K && MICROPY_PY_LWIP
diff --git a/ports/stm32/nimble.c b/ports/stm32/nimble.c
new file mode 100644
index 0000000000000..0d349585fb1ae
--- /dev/null
+++ b/ports/stm32/nimble.c
@@ -0,0 +1,88 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Jim Mussared
+ * Copyright (c) 2020 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+#include "py/mphal.h"
+
+#if MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_NIMBLE
+
+#include "transport/uart/ble_hci_uart.h"
+#include "host/ble_hs.h"
+
+#include "extmod/modbluetooth_hci.h"
+#include "extmod/nimble/modbluetooth_nimble.h"
+#include "extmod/nimble/nimble/nimble_hci_uart.h"
+
+extern void os_eventq_run_all(void);
+extern void os_callout_process(void);
+
+void mp_bluetooth_hci_poll(void) {
+    if (mp_bluetooth_nimble_ble_state == MP_BLUETOOTH_NIMBLE_BLE_STATE_OFF) {
+        return;
+    }
+
+    mp_bluetooth_nimble_hci_uart_process();
+    os_callout_process();
+    os_eventq_run_all();
+}
+
+void mp_bluetooth_nimble_port_preinit(void) {
+    MP_STATE_PORT(bluetooth_nimble_memory) = NULL;
+    ble_hci_uart_init();
+}
+
+void mp_bluetooth_nimble_port_postinit(void) {
+}
+
+void mp_bluetooth_nimble_port_deinit(void) {
+    mp_bluetooth_hci_controller_deactivate();
+}
+
+void mp_bluetooth_nimble_port_start(void) {
+    ble_hs_start();
+}
+
+void mp_bluetooth_nimble_hci_uart_rx(hal_uart_rx_cb_t rx_cb, void *rx_arg) {
+    bool host_wake = mp_bluetooth_hci_controller_woken();
+
+    int chr;
+    while ((chr = mp_bluetooth_hci_uart_readchar()) >= 0) {
+        // printf("UART RX: %02x\n", data);
+        rx_cb(rx_arg, chr);
+    }
+
+    if (host_wake) {
+        mp_bluetooth_hci_controller_sleep_maybe();
+    }
+}
+
+void mp_bluetooth_nimble_hci_uart_tx_strn(const char *str, uint len) {
+    mp_bluetooth_hci_uart_write((const uint8_t *)str, len);
+}
+
+#endif // MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_NIMBLE
diff --git a/ports/stm32/pendsv.c b/ports/stm32/pendsv.c
index 2979dc402c640..60b8709be34fd 100644
--- a/ports/stm32/pendsv.c
+++ b/ports/stm32/pendsv.c
@@ -180,5 +180,5 @@ __attribute__((naked)) void PendSV_Handler(void) {
         #endif
         "pendsv_object_ptr: .word pendsv_object\n"
         "nlr_jump_ptr: .word nlr_jump\n"
-    );
+        );
 }
diff --git a/ports/stm32/pendsv.h b/ports/stm32/pendsv.h
index 18ae1d63e9614..585f81e8bd441 100644
--- a/ports/stm32/pendsv.h
+++ b/ports/stm32/pendsv.h
@@ -27,15 +27,20 @@
 #define MICROPY_INCLUDED_STM32_PENDSV_H
 
 enum {
+    PENDSV_DISPATCH_SOFT_TIMER,
     #if MICROPY_PY_NETWORK && MICROPY_PY_LWIP
     PENDSV_DISPATCH_LWIP,
+    #if MICROPY_PY_NETWORK_CYW43
+    PENDSV_DISPATCH_CYW43,
+    #endif
+    #endif
+    #if MICROPY_PY_BLUETOOTH
+    PENDSV_DISPATCH_BLUETOOTH_HCI,
     #endif
     PENDSV_DISPATCH_MAX
 };
 
-#if MICROPY_PY_NETWORK && MICROPY_PY_LWIP
 #define PENDSV_DISPATCH_NUM_SLOTS PENDSV_DISPATCH_MAX
-#endif
 
 typedef void (*pendsv_dispatch_t)(void);
 
diff --git a/ports/stm32/pin.c b/ports/stm32/pin.c
index a8068d8998329..f1c5eee8506d4 100644
--- a/ports/stm32/pin.c
+++ b/ports/stm32/pin.c
@@ -119,7 +119,7 @@ const pin_obj_t *pin_find(mp_obj_t user_obj) {
         mp_obj_t o = mp_call_function_1(MP_STATE_PORT(pin_class_mapper), user_obj);
         if (o != mp_const_none) {
             if (!mp_obj_is_type(o, &pin_type)) {
-                mp_raise_ValueError("Pin.mapper didn't return a Pin object");
+                mp_raise_ValueError(MP_ERROR_TEXT("Pin.mapper didn't return a Pin object"));
             }
             if (pin_class_debug) {
                 printf("Pin.mapper maps ");
@@ -176,7 +176,7 @@ const pin_obj_t *pin_find(mp_obj_t user_obj) {
         return pin_obj;
     }
 
-    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Pin(%s) doesn't exist", mp_obj_str_get_str(user_obj)));
+    mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Pin(%s) doesn't exist"), mp_obj_str_get_str(user_obj));
 }
 
 /// \method __str__()
@@ -214,14 +214,14 @@ STATIC void pin_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t
         mp_print_str(print, qstr_str(mode_qst));
 
         // pull mode
-        qstr pull_qst = MP_QSTR_NULL;
+        qstr pull_qst = MP_QSTRnull;
         uint32_t pull = pin_get_pull(self);
         if (pull == GPIO_PULLUP) {
             pull_qst = MP_QSTR_PULL_UP;
         } else if (pull == GPIO_PULLDOWN) {
             pull_qst = MP_QSTR_PULL_DOWN;
         }
-        if (pull_qst != MP_QSTR_NULL) {
+        if (pull_qst != MP_QSTRnull) {
             mp_printf(print, ", pull=Pin.%q", pull_qst);
         }
 
@@ -329,7 +329,7 @@ STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(pin_debug_obj, MP_ROM_PTR(&pin_debug_fun_
 STATIC mp_obj_t pin_obj_init_helper(const pin_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_mode, MP_ARG_REQUIRED | MP_ARG_INT },
-        { MP_QSTR_pull, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)}},
+        { MP_QSTR_pull, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE}},
         { MP_QSTR_af, MP_ARG_INT, {.u_int = -1}}, // legacy
         { MP_QSTR_value, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL}},
         { MP_QSTR_alt, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1}},
@@ -342,7 +342,7 @@ STATIC mp_obj_t pin_obj_init_helper(const pin_obj_t *self, size_t n_args, const
     // get io mode
     uint mode = args[0].u_int;
     if (!IS_GPIO_MODE(mode)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid pin mode: %d", mode));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("invalid pin mode: %d"), mode);
     }
 
     // get pull mode
@@ -351,7 +351,7 @@ STATIC mp_obj_t pin_obj_init_helper(const pin_obj_t *self, size_t n_args, const
         pull = mp_obj_get_int(args[1].u_obj);
     }
     if (!IS_GPIO_PULL(pull)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid pin pull: %d", pull));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("invalid pin pull: %d"), pull);
     }
 
     // get af (alternate function); alt-arg overrides af-arg
@@ -360,7 +360,7 @@ STATIC mp_obj_t pin_obj_init_helper(const pin_obj_t *self, size_t n_args, const
         af = args[2].u_int;
     }
     if ((mode == GPIO_MODE_AF_PP || mode == GPIO_MODE_AF_OD) && !IS_GPIO_AF(af)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid pin af: %d", af));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("invalid pin af: %d"), af);
     }
 
     // enable the peripheral clock for the port of this pin
@@ -418,7 +418,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(pin_on_obj, pin_on);
 STATIC mp_obj_t pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     enum { ARG_handler, ARG_trigger, ARG_hard };
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_handler, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_handler, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
         { MP_QSTR_trigger, MP_ARG_INT, {.u_int = GPIO_MODE_IT_RISING | GPIO_MODE_IT_FALLING} },
         { MP_QSTR_hard, MP_ARG_BOOL, {.u_bool = false} },
     };
@@ -564,7 +564,7 @@ STATIC const mp_rom_map_elem_t pin_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_AF_OD),     MP_ROM_INT(GPIO_MODE_AF_OD) },
     { MP_ROM_QSTR(MP_QSTR_PULL_NONE), MP_ROM_INT(GPIO_NOPULL) },
 
-#include "genhdr/pins_af_const.h"
+    #include "genhdr/pins_af_const.h"
 };
 
 STATIC MP_DEFINE_CONST_DICT(pin_locals_dict, pin_locals_dict_table);
@@ -596,7 +596,7 @@ const mp_obj_type_t pin_type = {
     .make_new = mp_pin_make_new,
     .call = pin_call,
     .protocol = &pin_pin_p,
-    .locals_dict = (mp_obj_dict_t*)&pin_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pin_locals_dict,
 };
 
 /// \moduleref pyb
@@ -670,5 +670,5 @@ const mp_obj_type_t pin_af_type = {
     { &mp_type_type },
     .name = MP_QSTR_PinAF,
     .print = pin_af_obj_print,
-    .locals_dict = (mp_obj_dict_t*)&pin_af_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pin_af_locals_dict,
 };
diff --git a/ports/stm32/pin.h b/ports/stm32/pin.h
index ea57b0a274643..2397a9d48ee95 100644
--- a/ports/stm32/pin.h
+++ b/ports/stm32/pin.h
@@ -33,26 +33,26 @@
 #include "py/obj.h"
 
 typedef struct {
-  mp_obj_base_t base;
-  qstr name;
-  uint8_t idx;
-  uint8_t fn;
-  uint8_t unit;
-  uint8_t type;
-  void *reg; // The peripheral associated with this AF
+    mp_obj_base_t base;
+    qstr name;
+    uint8_t idx;
+    uint8_t fn;
+    uint8_t unit;
+    uint8_t type;
+    void *reg; // The peripheral associated with this AF
 } pin_af_obj_t;
 
 typedef struct {
-  mp_obj_base_t base;
-  qstr name;
-  uint32_t port   : 4;
-  uint32_t pin    : 5;      // Some ARM processors use 32 bits/PORT
-  uint32_t num_af : 4;
-  uint32_t adc_channel : 5; // Some ARM processors use 32 bits/PORT
-  uint32_t adc_num  : 3;    // 1 bit per ADC
-  uint32_t pin_mask;
-  pin_gpio_t *gpio;
-  const pin_af_obj_t *af;
+    mp_obj_base_t base;
+    qstr name;
+    uint32_t port   : 4;
+    uint32_t pin    : 5;    // Some ARM processors use 32 bits/PORT
+    uint32_t num_af : 4;
+    uint32_t adc_channel : 5; // Some ARM processors use 32 bits/PORT
+    uint32_t adc_num  : 3;  // 1 bit per ADC
+    uint32_t pin_mask;
+    pin_gpio_t *gpio;
+    const pin_af_obj_t *af;
 } pin_obj_t;
 
 extern const mp_obj_type_t pin_type;
@@ -62,14 +62,14 @@ extern const mp_obj_type_t pin_af_type;
 #include "genhdr/pins.h"
 
 typedef struct {
-  const char *name;
-  const pin_obj_t *pin;
+    const char *name;
+    const pin_obj_t *pin;
 } pin_named_pin_t;
 
 extern const pin_named_pin_t pin_board_pins[];
 extern const pin_named_pin_t pin_cpu_pins[];
 
-//extern pin_map_obj_t pin_map_obj;
+// extern pin_map_obj_t pin_map_obj;
 
 typedef struct {
     mp_obj_base_t base;
diff --git a/ports/stm32/pin_defs_stm32.h b/ports/stm32/pin_defs_stm32.h
index 89b659de5d321..33a1790807660 100644
--- a/ports/stm32/pin_defs_stm32.h
+++ b/ports/stm32/pin_defs_stm32.h
@@ -28,76 +28,76 @@
 // This file should only ever be #included by pin.h and not directly.
 
 enum {
-  PORT_A,
-  PORT_B,
-  PORT_C,
-  PORT_D,
-  PORT_E,
-  PORT_F,
-  PORT_G,
-  PORT_H,
-  PORT_I,
-  PORT_J,
-  PORT_K,
+    PORT_A,
+    PORT_B,
+    PORT_C,
+    PORT_D,
+    PORT_E,
+    PORT_F,
+    PORT_G,
+    PORT_H,
+    PORT_I,
+    PORT_J,
+    PORT_K,
 };
 
 // Must have matching entries in SUPPORTED_FN in boards/make-pins.py
 enum {
-  AF_FN_TIM,
-  AF_FN_I2C,
-  AF_FN_USART,
-  AF_FN_UART = AF_FN_USART,
-  AF_FN_SPI,
-  AF_FN_I2S,
-  AF_FN_SDMMC,
-  AF_FN_CAN,
+    AF_FN_TIM,
+    AF_FN_I2C,
+    AF_FN_USART,
+    AF_FN_UART = AF_FN_USART,
+    AF_FN_SPI,
+    AF_FN_I2S,
+    AF_FN_SDMMC,
+    AF_FN_CAN,
 };
 
 enum {
-  AF_PIN_TYPE_TIM_CH1 = 0,
-  AF_PIN_TYPE_TIM_CH2,
-  AF_PIN_TYPE_TIM_CH3,
-  AF_PIN_TYPE_TIM_CH4,
-  AF_PIN_TYPE_TIM_CH1N,
-  AF_PIN_TYPE_TIM_CH2N,
-  AF_PIN_TYPE_TIM_CH3N,
-  AF_PIN_TYPE_TIM_CH1_ETR,
-  AF_PIN_TYPE_TIM_ETR,
-  AF_PIN_TYPE_TIM_BKIN,
-
-  AF_PIN_TYPE_I2C_SDA = 0,
-  AF_PIN_TYPE_I2C_SCL,
-
-  AF_PIN_TYPE_USART_TX = 0,
-  AF_PIN_TYPE_USART_RX,
-  AF_PIN_TYPE_USART_CTS,
-  AF_PIN_TYPE_USART_RTS,
-  AF_PIN_TYPE_USART_CK,
-  AF_PIN_TYPE_UART_TX  = AF_PIN_TYPE_USART_TX,
-  AF_PIN_TYPE_UART_RX  = AF_PIN_TYPE_USART_RX,
-  AF_PIN_TYPE_UART_CTS = AF_PIN_TYPE_USART_CTS,
-  AF_PIN_TYPE_UART_RTS = AF_PIN_TYPE_USART_RTS,
-
-  AF_PIN_TYPE_SPI_MOSI = 0,
-  AF_PIN_TYPE_SPI_MISO,
-  AF_PIN_TYPE_SPI_SCK,
-  AF_PIN_TYPE_SPI_NSS,
-
-  AF_PIN_TYPE_I2S_CK = 0,
-  AF_PIN_TYPE_I2S_MCK,
-  AF_PIN_TYPE_I2S_SD,
-  AF_PIN_TYPE_I2S_WS,
-  AF_PIN_TYPE_I2S_EXTSD,
-
-  AF_PIN_TYPE_SDMMC_CK = 0,
-  AF_PIN_TYPE_SDMMC_CMD,
-  AF_PIN_TYPE_SDMMC_D0,
-  AF_PIN_TYPE_SDMMC_D1,
-  AF_PIN_TYPE_SDMMC_D2,
-  AF_PIN_TYPE_SDMMC_D3,
-
-  AF_PIN_TYPE_CAN_TX = 0,
-  AF_PIN_TYPE_CAN_RX,
+    AF_PIN_TYPE_TIM_CH1 = 0,
+    AF_PIN_TYPE_TIM_CH2,
+    AF_PIN_TYPE_TIM_CH3,
+    AF_PIN_TYPE_TIM_CH4,
+    AF_PIN_TYPE_TIM_CH1N,
+    AF_PIN_TYPE_TIM_CH2N,
+    AF_PIN_TYPE_TIM_CH3N,
+    AF_PIN_TYPE_TIM_CH1_ETR,
+    AF_PIN_TYPE_TIM_ETR,
+    AF_PIN_TYPE_TIM_BKIN,
+
+    AF_PIN_TYPE_I2C_SDA = 0,
+    AF_PIN_TYPE_I2C_SCL,
+
+    AF_PIN_TYPE_USART_TX = 0,
+    AF_PIN_TYPE_USART_RX,
+    AF_PIN_TYPE_USART_CTS,
+    AF_PIN_TYPE_USART_RTS,
+    AF_PIN_TYPE_USART_CK,
+    AF_PIN_TYPE_UART_TX  = AF_PIN_TYPE_USART_TX,
+    AF_PIN_TYPE_UART_RX  = AF_PIN_TYPE_USART_RX,
+    AF_PIN_TYPE_UART_CTS = AF_PIN_TYPE_USART_CTS,
+    AF_PIN_TYPE_UART_RTS = AF_PIN_TYPE_USART_RTS,
+
+    AF_PIN_TYPE_SPI_MOSI = 0,
+    AF_PIN_TYPE_SPI_MISO,
+    AF_PIN_TYPE_SPI_SCK,
+    AF_PIN_TYPE_SPI_NSS,
+
+    AF_PIN_TYPE_I2S_CK = 0,
+    AF_PIN_TYPE_I2S_MCK,
+    AF_PIN_TYPE_I2S_SD,
+    AF_PIN_TYPE_I2S_WS,
+    AF_PIN_TYPE_I2S_EXTSD,
+
+    AF_PIN_TYPE_SDMMC_CK = 0,
+    AF_PIN_TYPE_SDMMC_CMD,
+    AF_PIN_TYPE_SDMMC_D0,
+    AF_PIN_TYPE_SDMMC_D1,
+    AF_PIN_TYPE_SDMMC_D2,
+    AF_PIN_TYPE_SDMMC_D3,
+
+    AF_PIN_TYPE_CAN_TX = 0,
+    AF_PIN_TYPE_CAN_RX,
 };
 
 // The HAL uses a slightly different naming than we chose, so we provide
@@ -114,10 +114,18 @@ enum {
 #define I2S2  SPI2
 #define I2S3  SPI3
 
+#if defined(STM32H7)
+// Make H7 FDCAN more like CAN
+#define CAN1 FDCAN1
+#define CAN2 FDCAN2
+#define GPIO_AF9_CAN1 GPIO_AF9_FDCAN1
+#define GPIO_AF9_CAN2 GPIO_AF9_FDCAN2
+#endif
+
 enum {
-  PIN_ADC1  = (1 << 0),
-  PIN_ADC2  = (1 << 1),
-  PIN_ADC3  = (1 << 2),
+    PIN_ADC1  = (1 << 0),
+    PIN_ADC2  = (1 << 1),
+    PIN_ADC3  = (1 << 2),
 };
 
 typedef GPIO_TypeDef pin_gpio_t;
diff --git a/ports/stm32/pin_named_pins.c b/ports/stm32/pin_named_pins.c
index 1c7e6434228c5..3a8e0f9fce9da 100644
--- a/ports/stm32/pin_named_pins.c
+++ b/ports/stm32/pin_named_pins.c
@@ -34,18 +34,18 @@
 const mp_obj_type_t pin_cpu_pins_obj_type = {
     { &mp_type_type },
     .name = MP_QSTR_cpu,
-    .locals_dict = (mp_obj_dict_t*)&pin_cpu_pins_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pin_cpu_pins_locals_dict,
 };
 
 const mp_obj_type_t pin_board_pins_obj_type = {
     { &mp_type_type },
     .name = MP_QSTR_board,
-    .locals_dict = (mp_obj_dict_t*)&pin_board_pins_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pin_board_pins_locals_dict,
 };
 
 const pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name) {
     const mp_map_t *named_map = &named_pins->map;
-    mp_map_elem_t *named_elem = mp_map_lookup((mp_map_t*)named_map, name, MP_MAP_LOOKUP);
+    mp_map_elem_t *named_elem = mp_map_lookup((mp_map_t *)named_map, name, MP_MAP_LOOKUP);
     if (named_elem != NULL && named_elem->value != MP_OBJ_NULL) {
         return MP_OBJ_TO_PTR(named_elem->value);
     }
diff --git a/ports/stm32/pin_static_af.h b/ports/stm32/pin_static_af.h
index f5f4e6fd4d194..49580a2787467 100644
--- a/ports/stm32/pin_static_af.h
+++ b/ports/stm32/pin_static_af.h
@@ -32,18 +32,18 @@
 
 #if 0 // Enable to test if AF's are statically compiled
 #define mp_hal_pin_config_alt_static(pin_obj, mode, pull, fn_type) \
-        mp_hal_pin_config(pin_obj, mode, pull, fn_type(pin_obj)); \
-        _Static_assert(fn_type(pin_obj) != -1, ""); \
-        _Static_assert(__builtin_constant_p(fn_type(pin_obj)) == 1, "")
+    mp_hal_pin_config(pin_obj, mode, pull, fn_type(pin_obj)); \
+    _Static_assert(fn_type(pin_obj) != -1, ""); \
+    _Static_assert(__builtin_constant_p(fn_type(pin_obj)) == 1, "")
 
 #else
 
 #define mp_hal_pin_config_alt_static(pin_obj, mode, pull, fn_type) \
-        mp_hal_pin_config(pin_obj, mode, pull, fn_type(pin_obj)) /* Overflow Error => alt func not found */
+    mp_hal_pin_config(pin_obj, mode, pull, fn_type(pin_obj))     /* Overflow Error => alt func not found */
 
 #define mp_hal_pin_config_alt_static_speed(pin_obj, mode, pull, speed, fn_type) \
-        mp_hal_pin_config(pin_obj, mode, pull, fn_type(pin_obj)); /* Overflow Error => alt func not found */ \
-        mp_hal_pin_config_speed(pin_obj, speed)
+    mp_hal_pin_config(pin_obj, mode, pull, fn_type(pin_obj));     /* Overflow Error => alt func not found */ \
+    mp_hal_pin_config_speed(pin_obj, speed)
 
 #endif
 
diff --git a/ports/stm32/powerctrl.c b/ports/stm32/powerctrl.c
index 165919977fe3c..e11de8b021fd9 100644
--- a/ports/stm32/powerctrl.c
+++ b/ports/stm32/powerctrl.c
@@ -30,19 +30,118 @@
 #include "rtc.h"
 #include "genhdr/pllfreqtable.h"
 
-#if !defined(STM32F0)
+#if defined(STM32H7)
+#define RCC_SR          RSR
+#define RCC_SR_SFTRSTF  RCC_RSR_SFTRSTF
+#define RCC_SR_RMVF     RCC_RSR_RMVF
+#else
+#define RCC_SR          CSR
+#define RCC_SR_SFTRSTF  RCC_CSR_SFTRSTF
+#define RCC_SR_RMVF     RCC_CSR_RMVF
+#endif
+
+// Location in RAM of bootloader state (just after the top of the stack)
+extern uint32_t _estack[];
+#define BL_STATE ((uint32_t *)&_estack)
+
+static inline void powerctrl_disable_hsi_if_unused(void) {
+    #if !MICROPY_HW_CLK_USE_HSI && (defined(STM32F4) || defined(STM32F7) || defined(STM32H7))
+    // Disable HSI if it's not used to save a little bit of power
+    __HAL_RCC_HSI_DISABLE();
+    #endif
+}
+
+NORETURN void powerctrl_mcu_reset(void) {
+    BL_STATE[1] = 1; // invalidate bootloader address
+    #if __DCACHE_PRESENT == 1
+    SCB_CleanDCache();
+    #endif
+    NVIC_SystemReset();
+}
+
+NORETURN void powerctrl_enter_bootloader(uint32_t r0, uint32_t bl_addr) {
+    BL_STATE[0] = r0;
+    BL_STATE[1] = bl_addr;
+    #if __DCACHE_PRESENT == 1
+    SCB_CleanDCache();
+    #endif
+    NVIC_SystemReset();
+}
+
+static __attribute__((naked)) void branch_to_bootloader(uint32_t r0, uint32_t bl_addr) {
+    __asm volatile (
+        "ldr r2, [r1, #0]\n"    // get address of stack pointer
+        "msr msp, r2\n"         // get stack pointer
+        "ldr r2, [r1, #4]\n"    // get address of destination
+        "bx r2\n"               // branch to bootloader
+        );
+}
+
+void powerctrl_check_enter_bootloader(void) {
+    uint32_t bl_addr = BL_STATE[1];
+    BL_STATE[1] = 1; // invalidate bootloader address
+    if ((bl_addr & 0xfff) == 0 && (RCC->RCC_SR & RCC_SR_SFTRSTF)) {
+        // Reset by NVIC_SystemReset with bootloader data set -> branch to bootloader
+        RCC->RCC_SR = RCC_SR_RMVF;
+        #if defined(STM32F0) || defined(STM32F4) || defined(STM32L0) || defined(STM32L4) || defined(STM32WB)
+        __HAL_SYSCFG_REMAPMEMORY_SYSTEMFLASH();
+        #endif
+        uint32_t r0 = BL_STATE[0];
+        branch_to_bootloader(r0, bl_addr);
+    }
+}
+
+#if !defined(STM32F0) && !defined(STM32L0) && !defined(STM32WB)
+
+typedef struct _sysclk_scaling_table_entry_t {
+    uint16_t mhz;
+    uint16_t value;
+} sysclk_scaling_table_entry_t;
+
+#if defined(STM32F7)
+STATIC const sysclk_scaling_table_entry_t volt_scale_table[] = {
+    { 151, PWR_REGULATOR_VOLTAGE_SCALE3 },
+    { 180, PWR_REGULATOR_VOLTAGE_SCALE2 },
+    // Above 180MHz uses default PWR_REGULATOR_VOLTAGE_SCALE1
+};
+#elif defined(STM32H7)
+STATIC const sysclk_scaling_table_entry_t volt_scale_table[] = {
+    // See table 55 "Kernel clock distribution overview" of RM0433.
+    {200, PWR_REGULATOR_VOLTAGE_SCALE3},
+    {300, PWR_REGULATOR_VOLTAGE_SCALE2},
+    // Above 300MHz uses default PWR_REGULATOR_VOLTAGE_SCALE1
+    // (above 400MHz needs special handling for overdrive, currently unsupported)
+};
+#endif
+
+STATIC int powerctrl_config_vos(uint32_t sysclk_mhz) {
+    #if defined(STM32F7) || defined(STM32H7)
+    uint32_t volt_scale = PWR_REGULATOR_VOLTAGE_SCALE1;
+    for (int i = 0; i < MP_ARRAY_SIZE(volt_scale_table); ++i) {
+        if (sysclk_mhz <= volt_scale_table[i].mhz) {
+            volt_scale = volt_scale_table[i].value;
+            break;
+        }
+    }
+    if (HAL_PWREx_ControlVoltageScaling(volt_scale) != HAL_OK) {
+        return -MP_EIO;
+    }
+    #endif
+    return 0;
+}
 
 // Assumes that PLL is used as the SYSCLK source
 int powerctrl_rcc_clock_config_pll(RCC_ClkInitTypeDef *rcc_init, uint32_t sysclk_mhz, bool need_pllsai) {
     uint32_t flash_latency;
 
     #if defined(STM32F7)
-
     if (need_pllsai) {
         // Configure PLLSAI at 48MHz for those peripherals that need this freq
-        const uint32_t pllsain = 192;
+        // (calculation assumes it can get an integral value of PLLSAIN)
+        const uint32_t pllm = (RCC->PLLCFGR >> RCC_PLLCFGR_PLLM_Pos) & 0x3f;
         const uint32_t pllsaip = 4;
         const uint32_t pllsaiq = 2;
+        const uint32_t pllsain = 48 * pllsaip * pllm / (HSE_VALUE / 1000000);
         RCC->PLLSAICFGR = pllsaiq << RCC_PLLSAICFGR_PLLSAIQ_Pos
             | (pllsaip / 2 - 1) << RCC_PLLSAICFGR_PLLSAIP_Pos
             | pllsain << RCC_PLLSAICFGR_PLLSAIN_Pos;
@@ -54,23 +153,17 @@ int powerctrl_rcc_clock_config_pll(RCC_ClkInitTypeDef *rcc_init, uint32_t sysclk
             }
         }
         RCC->DCKCFGR2 |= RCC_DCKCFGR2_CK48MSEL;
-    } else {
-        RCC->DCKCFGR2 &= ~RCC_DCKCFGR2_CK48MSEL;
     }
+    #endif
 
     // If possible, scale down the internal voltage regulator to save power
-    uint32_t volt_scale;
-    if (sysclk_mhz <= 151) {
-        volt_scale = PWR_REGULATOR_VOLTAGE_SCALE3;
-    } else if (sysclk_mhz <= 180) {
-        volt_scale = PWR_REGULATOR_VOLTAGE_SCALE2;
-    } else {
-        volt_scale = PWR_REGULATOR_VOLTAGE_SCALE1;
-    }
-    if (HAL_PWREx_ControlVoltageScaling(volt_scale) != HAL_OK) {
-        return -MP_EIO;
+    int ret = powerctrl_config_vos(sysclk_mhz);
+    if (ret) {
+        return ret;
     }
 
+    #if defined(STM32F7)
+
     // These flash_latency values assume a supply voltage between 2.7V and 3.6V
     if (sysclk_mhz <= 30) {
         flash_latency = FLASH_LATENCY_0;
@@ -101,31 +194,103 @@ int powerctrl_rcc_clock_config_pll(RCC_ClkInitTypeDef *rcc_init, uint32_t sysclk
         return -MP_EIO;
     }
 
+    powerctrl_disable_hsi_if_unused();
+
     return 0;
 }
 
 #endif
 
-#if !(defined(STM32F0) || defined(STM32L4))
+#if !defined(STM32F0) && !defined(STM32L0) && !defined(STM32L4) && !defined(STM32WB)
 
 STATIC uint32_t calc_ahb_div(uint32_t wanted_div) {
-    if (wanted_div <= 1) { return RCC_SYSCLK_DIV1; }
-    else if (wanted_div <= 2) { return RCC_SYSCLK_DIV2; }
-    else if (wanted_div <= 4) { return RCC_SYSCLK_DIV4; }
-    else if (wanted_div <= 8) { return RCC_SYSCLK_DIV8; }
-    else if (wanted_div <= 16) { return RCC_SYSCLK_DIV16; }
-    else if (wanted_div <= 64) { return RCC_SYSCLK_DIV64; }
-    else if (wanted_div <= 128) { return RCC_SYSCLK_DIV128; }
-    else if (wanted_div <= 256) { return RCC_SYSCLK_DIV256; }
-    else { return RCC_SYSCLK_DIV512; }
+    #if defined(STM32H7)
+    if (wanted_div <= 1) {
+        return RCC_HCLK_DIV1;
+    } else if (wanted_div <= 2) {
+        return RCC_HCLK_DIV2;
+    } else if (wanted_div <= 4) {
+        return RCC_HCLK_DIV4;
+    } else if (wanted_div <= 8) {
+        return RCC_HCLK_DIV8;
+    } else if (wanted_div <= 16) {
+        return RCC_HCLK_DIV16;
+    } else if (wanted_div <= 64) {
+        return RCC_HCLK_DIV64;
+    } else if (wanted_div <= 128) {
+        return RCC_HCLK_DIV128;
+    } else if (wanted_div <= 256) {
+        return RCC_HCLK_DIV256;
+    } else {
+        return RCC_HCLK_DIV512;
+    }
+    #else
+    if (wanted_div <= 1) {
+        return RCC_SYSCLK_DIV1;
+    } else if (wanted_div <= 2) {
+        return RCC_SYSCLK_DIV2;
+    } else if (wanted_div <= 4) {
+        return RCC_SYSCLK_DIV4;
+    } else if (wanted_div <= 8) {
+        return RCC_SYSCLK_DIV8;
+    } else if (wanted_div <= 16) {
+        return RCC_SYSCLK_DIV16;
+    } else if (wanted_div <= 64) {
+        return RCC_SYSCLK_DIV64;
+    } else if (wanted_div <= 128) {
+        return RCC_SYSCLK_DIV128;
+    } else if (wanted_div <= 256) {
+        return RCC_SYSCLK_DIV256;
+    } else {
+        return RCC_SYSCLK_DIV512;
+    }
+    #endif
 }
 
-STATIC uint32_t calc_apb_div(uint32_t wanted_div) {
-    if (wanted_div <= 1) { return RCC_HCLK_DIV1; }
-    else if (wanted_div <= 2) { return RCC_HCLK_DIV2; }
-    else if (wanted_div <= 4) { return RCC_HCLK_DIV4; }
-    else if (wanted_div <= 8) { return RCC_HCLK_DIV8; }
-    else { return RCC_SYSCLK_DIV16; }
+STATIC uint32_t calc_apb1_div(uint32_t wanted_div) {
+    #if defined(STM32H7)
+    if (wanted_div <= 1) {
+        return RCC_APB1_DIV1;
+    } else if (wanted_div <= 2) {
+        return RCC_APB1_DIV2;
+    } else if (wanted_div <= 4) {
+        return RCC_APB1_DIV4;
+    } else if (wanted_div <= 8) {
+        return RCC_APB1_DIV8;
+    } else {
+        return RCC_APB1_DIV16;
+    }
+    #else
+    if (wanted_div <= 1) {
+        return RCC_HCLK_DIV1;
+    } else if (wanted_div <= 2) {
+        return RCC_HCLK_DIV2;
+    } else if (wanted_div <= 4) {
+        return RCC_HCLK_DIV4;
+    } else if (wanted_div <= 8) {
+        return RCC_HCLK_DIV8;
+    } else {
+        return RCC_HCLK_DIV16;
+    }
+    #endif
+}
+
+STATIC uint32_t calc_apb2_div(uint32_t wanted_div) {
+    #if defined(STM32H7)
+    if (wanted_div <= 1) {
+        return RCC_APB2_DIV1;
+    } else if (wanted_div <= 2) {
+        return RCC_APB2_DIV2;
+    } else if (wanted_div <= 4) {
+        return RCC_APB2_DIV4;
+    } else if (wanted_div <= 8) {
+        return RCC_APB2_DIV8;
+    } else {
+        return RCC_APB2_DIV16;
+    }
+    #else
+    return calc_apb1_div(wanted_div);
+    #endif
 }
 
 int powerctrl_set_sysclk(uint32_t sysclk, uint32_t ahb, uint32_t apb1, uint32_t apb2) {
@@ -138,17 +303,17 @@ int powerctrl_set_sysclk(uint32_t sysclk, uint32_t ahb, uint32_t apb1, uint32_t
     }
 
     // Default PLL parameters that give 48MHz on PLL48CK
-    uint32_t m = HSE_VALUE / 1000000, n = 336, p = 2, q = 7;
+    uint32_t m = MICROPY_HW_CLK_VALUE / 1000000, n = 336, p = 2, q = 7;
     uint32_t sysclk_source;
     bool need_pllsai = false;
 
     // Search for a valid PLL configuration that keeps USB at 48MHz
     uint32_t sysclk_mhz = sysclk / 1000000;
-    for (const uint16_t *pll = &pll_freq_table[MP_ARRAY_SIZE(pll_freq_table) - 1]; pll >= &pll_freq_table[0]; --pll) {
-        uint32_t sys = *pll & 0xff;
+    for (const pll_freq_table_t *pll = &pll_freq_table[MP_ARRAY_SIZE(pll_freq_table) - 1]; pll >= &pll_freq_table[0]; --pll) {
+        uint32_t sys = PLL_FREQ_TABLE_SYS(*pll);
         if (sys <= sysclk_mhz) {
-            m = (*pll >> 10) & 0x3f;
-            p = ((*pll >> 7) & 0x6) + 2;
+            m = PLL_FREQ_TABLE_M(*pll);
+            p = PLL_FREQ_TABLE_P(*pll);
             if (m == 0) {
                 // special entry for using HSI directly
                 sysclk_source = RCC_SYSCLKSOURCE_HSI;
@@ -159,7 +324,7 @@ int powerctrl_set_sysclk(uint32_t sysclk, uint32_t ahb, uint32_t apb1, uint32_t
                 // use PLL
                 sysclk_source = RCC_SYSCLKSOURCE_PLLCLK;
                 uint32_t vco_out = sys * p;
-                n = vco_out * m / (HSE_VALUE / 1000000);
+                n = vco_out * m / (MICROPY_HW_CLK_VALUE / 1000000);
                 q = vco_out / 48;
                 #if defined(STM32F7)
                 need_pllsai = vco_out % 48 != 0;
@@ -180,7 +345,11 @@ int powerctrl_set_sysclk(uint32_t sysclk, uint32_t ahb, uint32_t apb1, uint32_t
     if (sysclk_source == RCC_SYSCLKSOURCE_PLLCLK) {
         // Set HSE as system clock source to allow modification of the PLL configuration
         // We then change to PLL after re-configuring PLL
+        #if MICROPY_HW_CLK_USE_HSI
+        RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
+        #else
         RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSE;
+        #endif
     } else {
         // Directly set the system clock source as desired
         RCC_ClkInitStruct.SYSCLKSource = sysclk_source;
@@ -192,8 +361,13 @@ int powerctrl_set_sysclk(uint32_t sysclk, uint32_t ahb, uint32_t apb1, uint32_t
     #if !defined(STM32H7)
     ahb = sysclk >> AHBPrescTable[RCC_ClkInitStruct.AHBCLKDivider >> RCC_CFGR_HPRE_Pos];
     #endif
-    RCC_ClkInitStruct.APB1CLKDivider = calc_apb_div(ahb / apb1);
-    RCC_ClkInitStruct.APB2CLKDivider = calc_apb_div(ahb / apb2);
+    RCC_ClkInitStruct.APB1CLKDivider = calc_apb1_div(ahb / apb1);
+    RCC_ClkInitStruct.APB2CLKDivider = calc_apb2_div(ahb / apb2);
+    #if defined(STM32H7)
+    RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
+    RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;
+    RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;
+    #endif
 
     #if MICROPY_HW_CLK_LAST_FREQ
     // Save the bus dividers for use later
@@ -208,6 +382,8 @@ int powerctrl_set_sysclk(uint32_t sysclk, uint32_t ahb, uint32_t apb1, uint32_t
     }
 
     #if defined(STM32F7)
+    // Deselect PLLSAI as 48MHz source if we were using it
+    RCC->DCKCFGR2 &= ~RCC_DCKCFGR2_CK48MSEL;
     // Turn PLLSAI off because we are changing PLLM (which drives PLLSAI)
     RCC->CR &= ~RCC_CR_PLLSAION;
     #endif
@@ -217,12 +393,34 @@ int powerctrl_set_sysclk(uint32_t sysclk, uint32_t ahb, uint32_t apb1, uint32_t
     RCC_OscInitTypeDef RCC_OscInitStruct;
     RCC_OscInitStruct.OscillatorType = MICROPY_HW_RCC_OSCILLATOR_TYPE;
     RCC_OscInitStruct.HSEState = MICROPY_HW_RCC_HSE_STATE;
+    RCC_OscInitStruct.HSIState = MICROPY_HW_RCC_HSI_STATE;
+    RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
     RCC_OscInitStruct.PLL.PLLSource = MICROPY_HW_RCC_PLL_SRC;
     RCC_OscInitStruct.PLL.PLLM = m;
     RCC_OscInitStruct.PLL.PLLN = n;
     RCC_OscInitStruct.PLL.PLLP = p;
     RCC_OscInitStruct.PLL.PLLQ = q;
+
+    #if defined(STM32H7)
+    RCC_OscInitStruct.PLL.PLLR = 0;
+    if (MICROPY_HW_CLK_VALUE / 1000000 <= 2 * m) {
+        RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_0; // 1-2MHz
+    } else if (MICROPY_HW_CLK_VALUE / 1000000 <= 4 * m) {
+        RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_1; // 2-4MHz
+    } else if (MICROPY_HW_CLK_VALUE / 1000000 <= 8 * m) {
+        RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_2; // 4-8MHz
+    } else {
+        RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_3; // 8-16MHz
+    }
+    if (MICROPY_HW_CLK_VALUE / 1000000 * n <= 420 * m) {
+        RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOMEDIUM; // 150-420MHz
+    } else {
+        RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE; // 192-960MHz
+    }
+    RCC_OscInitStruct.PLL.PLLFRACN = 0;
+    #endif
+
     if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
         return -MP_EIO;
     }
@@ -264,19 +462,23 @@ void powerctrl_enter_stop_mode(void) {
     // executed until after the clocks are reconfigured
     uint32_t irq_state = disable_irq();
 
+    #if defined(MICROPY_BOARD_ENTER_STOP)
+    MICROPY_BOARD_ENTER_STOP
+    #endif
+
     #if defined(STM32L4)
     // Configure the MSI as the clock source after waking up
     __HAL_RCC_WAKEUPSTOP_CLK_CONFIG(RCC_STOP_WAKEUPCLOCK_MSI);
     #endif
 
-    #if !defined(STM32F0) && !defined(STM32L4)
+    #if !defined(STM32F0) && !defined(STM32L0) && !defined(STM32L4) && !defined(STM32WB)
     // takes longer to wake but reduces stop current
     HAL_PWREx_EnableFlashPowerDown();
     #endif
 
-    # if defined(STM32F7)
+    #if defined(STM32F7)
     HAL_PWR_EnterSTOPMode((PWR_CR1_LPDS | PWR_CR1_LPUDS | PWR_CR1_FPDS | PWR_CR1_UDEN), PWR_STOPENTRY_WFI);
-    # else
+    #else
     HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
     #endif
 
@@ -306,6 +508,11 @@ void powerctrl_enter_stop_mode(void) {
     }
     #endif
 
+    #if defined(STM32F7)
+    // Enable overdrive to reach 216MHz (if needed)
+    HAL_PWREx_EnableOverDrive();
+    #endif
+
     // enable PLL
     __HAL_RCC_PLL_ENABLE();
     while (!__HAL_RCC_GET_FLAG(RCC_FLAG_PLLRDY)) {
@@ -316,11 +523,16 @@ void powerctrl_enter_stop_mode(void) {
     #if defined(STM32H7)
     while (__HAL_RCC_GET_SYSCLK_SOURCE() != RCC_CFGR_SWS_PLL1) {
     }
+    #elif defined(STM32WB)
+    while (__HAL_RCC_GET_SYSCLK_SOURCE() != RCC_SYSCLKSOURCE_STATUS_PLLCLK) {
+    }
     #else
     while (__HAL_RCC_GET_SYSCLK_SOURCE() != RCC_CFGR_SWS_PLL) {
     }
     #endif
 
+    powerctrl_disable_hsi_if_unused();
+
     #if defined(STM32F7)
     if (RCC->DCKCFGR2 & RCC_DCKCFGR2_CK48MSEL) {
         // Enable PLLSAI if it is selected as 48MHz source
@@ -330,6 +542,13 @@ void powerctrl_enter_stop_mode(void) {
     }
     #endif
 
+    #if defined(STM32H7)
+    // Enable PLL3 for USB
+    RCC->CR |= RCC_CR_PLL3ON;
+    while (!(RCC->CR & RCC_CR_PLL3RDY)) {
+    }
+    #endif
+
     #if defined(STM32L4)
     // Enable PLLSAI1 for peripherals that use it
     RCC->CR |= RCC_CR_PLLSAI1ON;
@@ -339,6 +558,10 @@ void powerctrl_enter_stop_mode(void) {
 
     #endif
 
+    #if defined(MICROPY_BOARD_LEAVE_STOP)
+    MICROPY_BOARD_LEAVE_STOP
+    #endif
+
     // Enable IRQs now that all clocks are reconfigured
     enable_irq(irq_state);
 }
@@ -346,6 +569,10 @@ void powerctrl_enter_stop_mode(void) {
 void powerctrl_enter_standby_mode(void) {
     rtc_init_finalise();
 
+    #if defined(MICROPY_BOARD_ENTER_STANDBY)
+    MICROPY_BOARD_ENTER_STANDBY
+    #endif
+
     // We need to clear the PWR wake-up-flag before entering standby, since
     // the flag may have been set by a previous wake-up event.  Furthermore,
     // we need to disable the wake-up sources while clearing this flag, so
@@ -354,7 +581,7 @@ void powerctrl_enter_standby_mode(void) {
 
     // Note: we only support RTC ALRA, ALRB, WUT and TS.
     // TODO support TAMP and WKUP (PA0 external pin).
-    #if defined(STM32F0)
+    #if defined(STM32F0) || defined(STM32L0)
     #define CR_BITS (RTC_CR_ALRAIE | RTC_CR_WUTIE | RTC_CR_TSIE)
     #define ISR_BITS (RTC_ISR_ALRAF | RTC_ISR_WUTF | RTC_ISR_TSF)
     #else
@@ -378,7 +605,7 @@ void powerctrl_enter_standby_mode(void) {
     PWR->CR2 |= PWR_CR2_CWUPF6 | PWR_CR2_CWUPF5 | PWR_CR2_CWUPF4 | PWR_CR2_CWUPF3 | PWR_CR2_CWUPF2 | PWR_CR2_CWUPF1;
     #elif defined(STM32H7)
     // TODO
-    #elif defined(STM32L4)
+    #elif defined(STM32L4) || defined(STM32WB)
     // clear all wake-up flags
     PWR->SCR |= PWR_SCR_CWUF5 | PWR_SCR_CWUF4 | PWR_SCR_CWUF3 | PWR_SCR_CWUF2 | PWR_SCR_CWUF1;
     // TODO
@@ -390,6 +617,12 @@ void powerctrl_enter_standby_mode(void) {
     // enable previously-enabled RTC interrupts
     RTC->CR |= save_irq_bits;
 
+    #if defined(STM32F7)
+    // Enable the internal (eg RTC) wakeup sources
+    // See Errata 2.2.2 "Wakeup from Standby mode when the back-up SRAM regulator is enabled"
+    PWR->CSR1 |= PWR_CSR1_EIWUP;
+    #endif
+
     // enter standby mode
     HAL_PWR_EnterSTANDBYMode();
     // we never return; MCU is reset on exit from standby
diff --git a/ports/stm32/powerctrl.h b/ports/stm32/powerctrl.h
index b26cab391cbec..6e5f899a4cd1b 100644
--- a/ports/stm32/powerctrl.h
+++ b/ports/stm32/powerctrl.h
@@ -28,6 +28,12 @@
 
 #include <stdint.h>
 
+void SystemClock_Config(void);
+
+NORETURN void powerctrl_mcu_reset(void);
+NORETURN void powerctrl_enter_bootloader(uint32_t r0, uint32_t bl_addr);
+void powerctrl_check_enter_bootloader(void);
+
 int powerctrl_rcc_clock_config_pll(RCC_ClkInitTypeDef *rcc_init, uint32_t sysclk_mhz, bool need_pllsai);
 int powerctrl_set_sysclk(uint32_t sysclk, uint32_t ahb, uint32_t apb1, uint32_t apb2);
 void powerctrl_enter_stop_mode(void);
diff --git a/ports/stm32/powerctrlboot.c b/ports/stm32/powerctrlboot.c
new file mode 100644
index 0000000000000..749cb5505caaa
--- /dev/null
+++ b/ports/stm32/powerctrlboot.c
@@ -0,0 +1,198 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mphal.h"
+#include "powerctrl.h"
+
+static inline void powerctrl_config_systick(void) {
+    // Configure SYSTICK to run at 1kHz (1ms interval)
+    SysTick->CTRL |= SYSTICK_CLKSOURCE_HCLK;
+    SysTick_Config(HAL_RCC_GetHCLKFreq() / 1000);
+    NVIC_SetPriority(SysTick_IRQn, IRQ_PRI_SYSTICK);
+}
+
+#if defined(STM32F0)
+
+void SystemClock_Config(void) {
+    // Enable power control peripheral
+    __HAL_RCC_PWR_CLK_ENABLE();
+
+    // Set flash latency to 1 because SYSCLK > 24MHz
+    FLASH->ACR = (FLASH->ACR & ~0x7) | 0x1;
+
+    #if MICROPY_HW_CLK_USE_HSI48
+    // Use the 48MHz internal oscillator
+    // HAL does not support RCC CFGR SW=3 (HSI48 direct to SYSCLK)
+    // so use HSI48 -> PREDIV(divide by 2) -> PLL (mult by 2) -> SYSCLK.
+
+    RCC->CR2 |= RCC_CR2_HSI48ON;
+    while ((RCC->CR2 & RCC_CR2_HSI48RDY) == 0) {
+        // Wait for HSI48 to be ready
+    }
+    RCC->CFGR = 0 << RCC_CFGR_PLLMUL_Pos | 3 << RCC_CFGR_PLLSRC_Pos; // PLL mult by 2, src = HSI48/PREDIV
+    RCC->CFGR2 = 1; // Input clock divided by 2
+
+    #elif MICROPY_HW_CLK_USE_HSE
+    // Use HSE and the PLL to get a 48MHz SYSCLK
+
+    #if MICROPY_HW_CLK_USE_BYPASS
+    RCC->CR |= RCC_CR_HSEBYP;
+    #endif
+    RCC->CR |= RCC_CR_HSEON;
+    while ((RCC->CR & RCC_CR_HSERDY) == 0) {
+        // Wait for HSE to be ready
+    }
+    RCC->CFGR = ((48000000 / HSE_VALUE) - 2) << RCC_CFGR_PLLMUL_Pos | 2 << RCC_CFGR_PLLSRC_Pos;
+    RCC->CFGR2 = 0; // Input clock not divided
+
+    #elif MICROPY_HW_CLK_USE_HSI
+    // Use the 8MHz internal oscillator and the PLL to get a 48MHz SYSCLK
+
+    RCC->CR |= RCC_CR_HSION;
+    while ((RCC->CR & RCC_CR_HSIRDY) == 0) {
+        // Wait for HSI to be ready
+    }
+    RCC->CFGR = 4 << RCC_CFGR_PLLMUL_Pos | 1 << RCC_CFGR_PLLSRC_Pos; // PLL mult by 6, src = HSI
+    RCC->CFGR2 = 0; // Input clock not divided
+
+    #else
+    #error System clock not specified
+    #endif
+
+    RCC->CR |= RCC_CR_PLLON; // Turn PLL on
+    while ((RCC->CR & RCC_CR_PLLRDY) == 0) {
+        // Wait for PLL to lock
+    }
+    const uint32_t sysclk_src = 2;
+
+    // Select SYSCLK source
+    RCC->CFGR |= sysclk_src << RCC_CFGR_SW_Pos;
+    while (((RCC->CFGR >> RCC_CFGR_SWS_Pos) & 0x3) != sysclk_src) {
+        // Wait for SYSCLK source to change
+    }
+
+    SystemCoreClockUpdate();
+    powerctrl_config_systick();
+}
+
+#elif defined(STM32L0)
+
+void SystemClock_Config(void) {
+    // Enable power control peripheral
+    __HAL_RCC_PWR_CLK_ENABLE();
+
+    // Set flash latency to 1 because SYSCLK > 16MHz
+    FLASH->ACR |= FLASH_ACR_LATENCY;
+
+    // Enable the 16MHz internal oscillator
+    RCC->CR |= RCC_CR_HSION;
+    while (!(RCC->CR & RCC_CR_HSIRDY)) {
+    }
+
+    // Use HSI16 and the PLL to get a 32MHz SYSCLK
+    RCC->CFGR = 1 << RCC_CFGR_PLLDIV_Pos | 1 << RCC_CFGR_PLLMUL_Pos;
+    RCC->CR |= RCC_CR_PLLON;
+    while (!(RCC->CR & RCC_CR_PLLRDY)) {
+        // Wait for PLL to lock
+    }
+    const uint32_t sysclk_src = 3;
+
+    // Select SYSCLK source
+    RCC->CFGR |= sysclk_src << RCC_CFGR_SW_Pos;
+    while (((RCC->CFGR >> RCC_CFGR_SWS_Pos) & 0x3) != sysclk_src) {
+        // Wait for SYSCLK source to change
+    }
+
+    SystemCoreClockUpdate();
+    powerctrl_config_systick();
+
+    #if MICROPY_HW_ENABLE_RNG || MICROPY_HW_ENABLE_USB
+    // Enable the 48MHz internal oscillator
+    RCC->CRRCR |= RCC_CRRCR_HSI48ON;
+    RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN;
+    SYSCFG->CFGR3 |= SYSCFG_CFGR3_ENREF_HSI48;
+    while (!(RCC->CRRCR & RCC_CRRCR_HSI48RDY)) {
+        // Wait for HSI48 to be ready
+    }
+
+    // Select RC48 as HSI48 for USB and RNG
+    RCC->CCIPR |= RCC_CCIPR_HSI48SEL;
+
+    #if MICROPY_HW_ENABLE_USB
+    // Synchronise HSI48 with 1kHz USB SoF
+    __HAL_RCC_CRS_CLK_ENABLE();
+    CRS->CR = 0x20 << CRS_CR_TRIM_Pos;
+    CRS->CFGR = 2 << CRS_CFGR_SYNCSRC_Pos | 0x22 << CRS_CFGR_FELIM_Pos
+        | __HAL_RCC_CRS_RELOADVALUE_CALCULATE(48000000, 1000) << CRS_CFGR_RELOAD_Pos;
+    #endif
+    #endif
+}
+
+#elif defined(STM32WB)
+
+void SystemClock_Config(void) {
+    // Enable the 32MHz external oscillator
+    RCC->CR |= RCC_CR_HSEON;
+    while (!(RCC->CR & RCC_CR_HSERDY)) {
+    }
+
+    // Use HSE and the PLL to get a 64MHz SYSCLK
+    #define PLLM (HSE_VALUE / 8000000) // VCO input is 8MHz
+    #define PLLN (24) // 24*8MHz = 192MHz
+    #define PLLQ (4) // f_Q = 48MHz
+    #define PLLR (3) // f_R = 64MHz
+    RCC->PLLCFGR =
+        (PLLR - 1) << RCC_PLLCFGR_PLLR_Pos | RCC_PLLCFGR_PLLREN
+            | (PLLQ - 1) << RCC_PLLCFGR_PLLQ_Pos | RCC_PLLCFGR_PLLQEN
+            | PLLN << RCC_PLLCFGR_PLLN_Pos
+            | (PLLM - 1) << RCC_PLLCFGR_PLLM_Pos
+            | 3 << RCC_PLLCFGR_PLLSRC_Pos;
+    RCC->CR |= RCC_CR_PLLON;
+    while (!(RCC->CR & RCC_CR_PLLRDY)) {
+        // Wait for PLL to lock
+    }
+    const uint32_t sysclk_src = 3;
+
+    // Set divider for HCLK2 to 2 so f_HCLK2 = 32MHz
+    RCC->EXTCFGR = 8 << RCC_EXTCFGR_C2HPRE_Pos;
+
+    // Set flash latency to 3 because SYSCLK > 54MHz
+    FLASH->ACR |= 3 << FLASH_ACR_LATENCY_Pos;
+
+    // Select SYSCLK source
+    RCC->CFGR |= sysclk_src << RCC_CFGR_SW_Pos;
+    while (((RCC->CFGR >> RCC_CFGR_SWS_Pos) & 0x3) != sysclk_src) {
+        // Wait for SYSCLK source to change
+    }
+
+    // Select PLLQ as 48MHz source for USB and RNG
+    RCC->CCIPR = 2 << RCC_CCIPR_CLK48SEL_Pos;
+
+    SystemCoreClockUpdate();
+    powerctrl_config_systick();
+}
+
+#endif
diff --git a/ports/stm32/pyb_can.c b/ports/stm32/pyb_can.c
new file mode 100644
index 0000000000000..ad2efbef4be1a
--- /dev/null
+++ b/ports/stm32/pyb_can.c
@@ -0,0 +1,909 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014-2018 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <string.h>
+
+#include "py/objarray.h"
+#include "py/runtime.h"
+#include "py/gc.h"
+#include "py/binary.h"
+#include "py/stream.h"
+#include "py/mperrno.h"
+#include "py/mphal.h"
+#include "bufhelper.h"
+#include "can.h"
+#include "irq.h"
+
+#if MICROPY_HW_ENABLE_CAN
+
+#if MICROPY_HW_ENABLE_FDCAN
+
+#define CAN_MAX_FILTER              (64)
+
+#define CAN_FIFO0                   FDCAN_RX_FIFO0
+#define CAN_FIFO1                   FDCAN_RX_FIFO1
+#define CAN_FILTER_FIFO0            (0)
+
+// Default timings; 125Kbps assuming 48MHz clock
+#define CAN_DEFAULT_PRESCALER       (32)
+#define CAN_DEFAULT_SJW             (1)
+#define CAN_DEFAULT_BS1             (8)
+#define CAN_DEFAULT_BS2             (3)
+
+#define CAN_MODE_NORMAL             FDCAN_MODE_NORMAL
+#define CAN_MODE_LOOPBACK           FDCAN_MODE_EXTERNAL_LOOPBACK
+#define CAN_MODE_SILENT             FDCAN_MODE_BUS_MONITORING
+#define CAN_MODE_SILENT_LOOPBACK    FDCAN_MODE_INTERNAL_LOOPBACK
+
+#define CAN1_RX0_IRQn               FDCAN1_IT0_IRQn
+#define CAN1_RX1_IRQn               FDCAN1_IT1_IRQn
+#define CAN2_RX0_IRQn               FDCAN2_IT0_IRQn
+#define CAN2_RX1_IRQn               FDCAN2_IT1_IRQn
+
+#define CAN_IT_FIFO0_FULL           FDCAN_IT_RX_FIFO0_FULL
+#define CAN_IT_FIFO1_FULL           FDCAN_IT_RX_FIFO1_FULL
+#define CAN_IT_FIFO0_OVRF           FDCAN_IT_RX_FIFO0_MESSAGE_LOST
+#define CAN_IT_FIFO1_OVRF           FDCAN_IT_RX_FIFO1_MESSAGE_LOST
+#define CAN_IT_FIFO0_PENDING        FDCAN_IT_RX_FIFO0_NEW_MESSAGE
+#define CAN_IT_FIFO1_PENDING        FDCAN_IT_RX_FIFO1_NEW_MESSAGE
+#define CAN_FLAG_FIFO0_FULL         FDCAN_FLAG_RX_FIFO0_FULL
+#define CAN_FLAG_FIFO1_FULL         FDCAN_FLAG_RX_FIFO1_FULL
+#define CAN_FLAG_FIFO0_OVRF         FDCAN_FLAG_RX_FIFO0_MESSAGE_LOST
+#define CAN_FLAG_FIFO1_OVRF         FDCAN_FLAG_RX_FIFO1_MESSAGE_LOST
+
+#define __HAL_CAN_ENABLE_IT         __HAL_FDCAN_ENABLE_IT
+#define __HAL_CAN_DISABLE_IT        __HAL_FDCAN_DISABLE_IT
+#define __HAL_CAN_CLEAR_FLAG        __HAL_FDCAN_CLEAR_FLAG
+#define __HAL_CAN_MSG_PENDING       HAL_FDCAN_GetRxFifoFillLevel
+
+// Both banks start at 0
+STATIC uint8_t can2_start_bank = 0;
+
+#else
+
+#define CAN_MAX_FILTER              (28)
+
+#define CAN_DEFAULT_PRESCALER       (100)
+#define CAN_DEFAULT_SJW             (1)
+#define CAN_DEFAULT_BS1             (6)
+#define CAN_DEFAULT_BS2             (8)
+
+#define CAN_IT_FIFO0_FULL           CAN_IT_FF0
+#define CAN_IT_FIFO1_FULL           CAN_IT_FF1
+#define CAN_IT_FIFO0_OVRF           CAN_IT_FOV0
+#define CAN_IT_FIFO1_OVRF           CAN_IT_FOV1
+#define CAN_IT_FIFO0_PENDING        CAN_IT_FMP0
+#define CAN_IT_FIFO1_PENDING        CAN_IT_FMP1
+#define CAN_FLAG_FIFO0_FULL         CAN_FLAG_FF0
+#define CAN_FLAG_FIFO1_FULL         CAN_FLAG_FF1
+#define CAN_FLAG_FIFO0_OVRF         CAN_FLAG_FOV0
+#define CAN_FLAG_FIFO1_OVRF         CAN_FLAG_FOV1
+
+STATIC uint8_t can2_start_bank = 14;
+
+#endif
+
+STATIC void pyb_can_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (!self->is_enabled) {
+        mp_printf(print, "CAN(%u)", self->can_id);
+    } else {
+        qstr mode;
+        switch (self->can.Init.Mode) {
+            case CAN_MODE_NORMAL:
+                mode = MP_QSTR_NORMAL;
+                break;
+            case CAN_MODE_LOOPBACK:
+                mode = MP_QSTR_LOOPBACK;
+                break;
+            case CAN_MODE_SILENT:
+                mode = MP_QSTR_SILENT;
+                break;
+            case CAN_MODE_SILENT_LOOPBACK:
+            default:
+                mode = MP_QSTR_SILENT_LOOPBACK;
+                break;
+        }
+        mp_printf(print, "CAN(%u, CAN.%q, extframe=%q, auto_restart=%q)",
+            self->can_id,
+            mode,
+            self->extframe ? MP_QSTR_True : MP_QSTR_False,
+            #if MICROPY_HW_ENABLE_FDCAN
+            (self->can.Instance->CCCR & FDCAN_CCCR_DAR) ? MP_QSTR_True : MP_QSTR_False
+            #else
+                (self->can.Instance->MCR & CAN_MCR_ABOM) ? MP_QSTR_True : MP_QSTR_False
+            #endif
+            );
+    }
+}
+
+// init(mode, extframe=False, prescaler=100, *, sjw=1, bs1=6, bs2=8)
+STATIC mp_obj_t pyb_can_init_helper(pyb_can_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_mode, ARG_extframe, ARG_prescaler, ARG_sjw, ARG_bs1, ARG_bs2, ARG_auto_restart };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_mode,         MP_ARG_REQUIRED | MP_ARG_INT,   {.u_int = CAN_MODE_NORMAL} },
+        { MP_QSTR_extframe,     MP_ARG_BOOL,                    {.u_bool = false} },
+        { MP_QSTR_prescaler,    MP_ARG_INT,                     {.u_int = CAN_DEFAULT_PRESCALER} },
+        { MP_QSTR_sjw,          MP_ARG_KW_ONLY | MP_ARG_INT,    {.u_int = CAN_DEFAULT_SJW} },
+        { MP_QSTR_bs1,          MP_ARG_KW_ONLY | MP_ARG_INT,    {.u_int = CAN_DEFAULT_BS1} },
+        { MP_QSTR_bs2,          MP_ARG_KW_ONLY | MP_ARG_INT,    {.u_int = CAN_DEFAULT_BS2} },
+        { MP_QSTR_auto_restart, MP_ARG_KW_ONLY | MP_ARG_BOOL,   {.u_bool = false} },
+    };
+
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    self->extframe = args[ARG_extframe].u_bool;
+
+    // set the CAN configuration values
+    memset(&self->can, 0, sizeof(self->can));
+
+    // init CAN (if it fails, it's because the port doesn't exist)
+    if (!can_init(self, args[ARG_mode].u_int, args[ARG_prescaler].u_int, args[ARG_sjw].u_int,
+        args[ARG_bs1].u_int, args[ARG_bs2].u_int, args[ARG_auto_restart].u_bool)) {
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("CAN(%d) doesn't exist"), self->can_id);
+    }
+
+    return mp_const_none;
+}
+
+// CAN(bus, ...)
+STATIC mp_obj_t pyb_can_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    // check arguments
+    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
+
+    // work out port
+    mp_uint_t can_idx;
+    if (mp_obj_is_str(args[0])) {
+        const char *port = mp_obj_str_get_str(args[0]);
+        if (0) {
+        #ifdef MICROPY_HW_CAN1_NAME
+        } else if (strcmp(port, MICROPY_HW_CAN1_NAME) == 0) {
+            can_idx = PYB_CAN_1;
+        #endif
+        #ifdef MICROPY_HW_CAN2_NAME
+        } else if (strcmp(port, MICROPY_HW_CAN2_NAME) == 0) {
+            can_idx = PYB_CAN_2;
+        #endif
+        #ifdef MICROPY_HW_CAN3_NAME
+        } else if (strcmp(port, MICROPY_HW_CAN3_NAME) == 0) {
+            can_idx = PYB_CAN_3;
+        #endif
+        } else {
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("CAN(%s) doesn't exist"), port);
+        }
+    } else {
+        can_idx = mp_obj_get_int(args[0]);
+    }
+    if (can_idx < 1 || can_idx > MP_ARRAY_SIZE(MP_STATE_PORT(pyb_can_obj_all))) {
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("CAN(%d) doesn't exist"), can_idx);
+    }
+
+    pyb_can_obj_t *self;
+    if (MP_STATE_PORT(pyb_can_obj_all)[can_idx - 1] == NULL) {
+        self = m_new_obj(pyb_can_obj_t);
+        self->base.type = &pyb_can_type;
+        self->can_id = can_idx;
+        self->is_enabled = false;
+        MP_STATE_PORT(pyb_can_obj_all)[can_idx - 1] = self;
+    } else {
+        self = MP_STATE_PORT(pyb_can_obj_all)[can_idx - 1];
+    }
+
+    if (!self->is_enabled || n_args > 1) {
+        if (self->is_enabled) {
+            // The caller is requesting a reconfiguration of the hardware
+            // this can only be done if the hardware is in init mode
+            can_deinit(self);
+        }
+
+        self->rxcallback0 = mp_const_none;
+        self->rxcallback1 = mp_const_none;
+        self->rx_state0 = RX_STATE_FIFO_EMPTY;
+        self->rx_state1 = RX_STATE_FIFO_EMPTY;
+
+        if (n_args > 1 || n_kw > 0) {
+            // start the peripheral
+            mp_map_t kw_args;
+            mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+            pyb_can_init_helper(self, n_args - 1, args + 1, &kw_args);
+        }
+    }
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC mp_obj_t pyb_can_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    return pyb_can_init_helper(MP_OBJ_TO_PTR(args[0]), n_args - 1, args + 1, kw_args);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_can_init_obj, 1, pyb_can_init);
+
+// deinit()
+STATIC mp_obj_t pyb_can_deinit(mp_obj_t self_in) {
+    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    can_deinit(self);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_can_deinit_obj, pyb_can_deinit);
+
+// Force a software restart of the controller, to allow transmission after a bus error
+STATIC mp_obj_t pyb_can_restart(mp_obj_t self_in) {
+    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (!self->is_enabled) {
+        mp_raise_ValueError(NULL);
+    }
+    CAN_TypeDef *can = self->can.Instance;
+    #if MICROPY_HW_ENABLE_FDCAN
+    can->CCCR |= FDCAN_CCCR_INIT;
+    while ((can->CCCR & FDCAN_CCCR_INIT) == 0) {
+    }
+    can->CCCR &= ~FDCAN_CCCR_INIT;
+    while ((can->CCCR & FDCAN_CCCR_INIT)) {
+    }
+    #else
+    can->MCR |= CAN_MCR_INRQ;
+    while ((can->MSR & CAN_MSR_INAK) == 0) {
+    }
+    can->MCR &= ~CAN_MCR_INRQ;
+    while ((can->MSR & CAN_MSR_INAK)) {
+    }
+    #endif
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_can_restart_obj, pyb_can_restart);
+
+// Get the state of the controller
+STATIC mp_obj_t pyb_can_state(mp_obj_t self_in) {
+    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_int_t state = CAN_STATE_STOPPED;
+    if (self->is_enabled) {
+        CAN_TypeDef *can = self->can.Instance;
+        #if MICROPY_HW_ENABLE_FDCAN
+        if (can->PSR & FDCAN_PSR_BO) {
+            state = CAN_STATE_BUS_OFF;
+        } else if (can->PSR & FDCAN_PSR_EP) {
+            state = CAN_STATE_ERROR_PASSIVE;
+        } else if (can->PSR & FDCAN_PSR_EW) {
+            state = CAN_STATE_ERROR_WARNING;
+        } else {
+            state = CAN_STATE_ERROR_ACTIVE;
+        }
+        #else
+        if (can->ESR & CAN_ESR_BOFF) {
+            state = CAN_STATE_BUS_OFF;
+        } else if (can->ESR & CAN_ESR_EPVF) {
+            state = CAN_STATE_ERROR_PASSIVE;
+        } else if (can->ESR & CAN_ESR_EWGF) {
+            state = CAN_STATE_ERROR_WARNING;
+        } else {
+            state = CAN_STATE_ERROR_ACTIVE;
+        }
+        #endif
+    }
+    return MP_OBJ_NEW_SMALL_INT(state);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_can_state_obj, pyb_can_state);
+
+// Get info about error states and TX/RX buffers
+STATIC mp_obj_t pyb_can_info(size_t n_args, const mp_obj_t *args) {
+    #if MICROPY_HW_ENABLE_FDCAN
+    // TODO implement for FDCAN
+    return mp_const_none;
+    #else
+    pyb_can_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    mp_obj_list_t *list;
+    if (n_args == 1) {
+        list = MP_OBJ_TO_PTR(mp_obj_new_list(8, NULL));
+    } else {
+        if (!mp_obj_is_type(args[1], &mp_type_list)) {
+            mp_raise_TypeError(NULL);
+        }
+        list = MP_OBJ_TO_PTR(args[1]);
+        if (list->len < 8) {
+            mp_raise_ValueError(NULL);
+        }
+    }
+    CAN_TypeDef *can = self->can.Instance;
+    uint32_t esr = can->ESR;
+    list->items[0] = MP_OBJ_NEW_SMALL_INT(esr >> CAN_ESR_TEC_Pos & 0xff);
+    list->items[1] = MP_OBJ_NEW_SMALL_INT(esr >> CAN_ESR_REC_Pos & 0xff);
+    list->items[2] = MP_OBJ_NEW_SMALL_INT(self->num_error_warning);
+    list->items[3] = MP_OBJ_NEW_SMALL_INT(self->num_error_passive);
+    list->items[4] = MP_OBJ_NEW_SMALL_INT(self->num_bus_off);
+    int n_tx_pending = 0x01121223 >> ((can->TSR >> CAN_TSR_TME_Pos & 7) << 2) & 0xf;
+    list->items[5] = MP_OBJ_NEW_SMALL_INT(n_tx_pending);
+    list->items[6] = MP_OBJ_NEW_SMALL_INT(can->RF0R >> CAN_RF0R_FMP0_Pos & 3);
+    list->items[7] = MP_OBJ_NEW_SMALL_INT(can->RF1R >> CAN_RF1R_FMP1_Pos & 3);
+    return MP_OBJ_FROM_PTR(list);
+    #endif
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_can_info_obj, 1, 2, pyb_can_info);
+
+// any(fifo) - return `True` if any message waiting on the FIFO, else `False`
+STATIC mp_obj_t pyb_can_any(mp_obj_t self_in, mp_obj_t fifo_in) {
+    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_int_t fifo = mp_obj_get_int(fifo_in);
+    if (fifo == 0) {
+        if (__HAL_CAN_MSG_PENDING(&self->can, CAN_FIFO0) != 0) {
+            return mp_const_true;
+        }
+    } else {
+        if (__HAL_CAN_MSG_PENDING(&self->can, CAN_FIFO1) != 0) {
+            return mp_const_true;
+        }
+    }
+    return mp_const_false;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_can_any_obj, pyb_can_any);
+
+// send(send, addr, *, timeout=5000)
+STATIC mp_obj_t pyb_can_send(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_data, ARG_id, ARG_timeout, ARG_rtr };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_data,    MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_id,      MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_rtr,     MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
+    };
+
+    // parse args
+    pyb_can_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // get the buffer to send from
+    mp_buffer_info_t bufinfo;
+    uint8_t data[1];
+    pyb_buf_get_for_send(args[ARG_data].u_obj, &bufinfo, data);
+
+    if (bufinfo.len > 8) {
+        mp_raise_ValueError(MP_ERROR_TEXT("CAN data field too long"));
+    }
+
+    // send the data
+    CanTxMsgTypeDef tx_msg;
+
+    #if MICROPY_HW_ENABLE_FDCAN
+    uint8_t tx_data[8];
+    tx_msg.MessageMarker = 0;
+    tx_msg.ErrorStateIndicator = FDCAN_ESI_ACTIVE;
+    tx_msg.BitRateSwitch = FDCAN_BRS_OFF;
+    tx_msg.FDFormat = FDCAN_CLASSIC_CAN;
+    tx_msg.TxEventFifoControl = FDCAN_NO_TX_EVENTS;
+    tx_msg.DataLength = (bufinfo.len << 16); // TODO DLC for len > 8
+
+    if (self->extframe) {
+        tx_msg.Identifier = args[ARG_id].u_int & 0x1FFFFFFF;
+        tx_msg.IdType = FDCAN_EXTENDED_ID;
+    } else {
+        tx_msg.Identifier = args[ARG_id].u_int & 0x7FF;
+        tx_msg.IdType = FDCAN_STANDARD_ID;
+    }
+    if (args[ARG_rtr].u_bool == false) {
+        tx_msg.TxFrameType = FDCAN_DATA_FRAME;
+    } else {
+        tx_msg.TxFrameType = FDCAN_REMOTE_FRAME;
+    }
+    #else
+    tx_msg.DLC = bufinfo.len;
+    uint8_t *tx_data = tx_msg.Data; // Data is uint32_t but holds only 1 byte
+
+    if (self->extframe) {
+        tx_msg.ExtId = args[ARG_id].u_int & 0x1FFFFFFF;
+        tx_msg.IDE = CAN_ID_EXT;
+    } else {
+        tx_msg.StdId = args[ARG_id].u_int & 0x7FF;
+        tx_msg.IDE = CAN_ID_STD;
+    }
+    if (args[ARG_rtr].u_bool == false) {
+        tx_msg.RTR = CAN_RTR_DATA;
+    } else {
+        tx_msg.RTR = CAN_RTR_REMOTE;
+    }
+    #endif
+
+    for (mp_uint_t i = 0; i < bufinfo.len; i++) {
+        tx_data[i] = ((byte *)bufinfo.buf)[i];
+    }
+
+    HAL_StatusTypeDef status;
+    #if MICROPY_HW_ENABLE_FDCAN
+    status = HAL_FDCAN_AddMessageToTxFifoQ(&self->can, &tx_msg, tx_data);
+    #else
+    self->can.pTxMsg = &tx_msg;
+    status = CAN_Transmit(&self->can, args[ARG_timeout].u_int);
+    #endif
+
+    if (status != HAL_OK) {
+        mp_hal_raise(status);
+    }
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_can_send_obj, 1, pyb_can_send);
+
+// recv(fifo, list=None, *, timeout=5000)
+STATIC mp_obj_t pyb_can_recv(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_fifo, ARG_list, ARG_timeout };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_fifo,    MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_list,    MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 5000} },
+    };
+
+    // parse args
+    pyb_can_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // receive the data
+    CanRxMsgTypeDef rx_msg;
+    #if MICROPY_HW_ENABLE_FDCAN
+    uint8_t rx_data[8];
+    #else
+    uint8_t *rx_data = rx_msg.Data;
+    #endif
+
+    mp_uint_t fifo = args[ARG_fifo].u_int;
+    if (fifo == 0) {
+        fifo = CAN_FIFO0;
+    } else if (fifo == 1) {
+        fifo = CAN_FIFO1;
+    } else {
+        mp_raise_TypeError(NULL);
+    }
+
+    int ret = can_receive(&self->can, fifo, &rx_msg, rx_data, args[ARG_timeout].u_int);
+    if (ret < 0) {
+        mp_raise_OSError(-ret);
+    }
+
+    #if MICROPY_HW_ENABLE_FDCAN
+    uint32_t rx_dlc = rx_msg.DataLength;
+    #else
+    uint32_t rx_dlc = rx_msg.DLC;
+    #endif
+
+    // Manage the rx state machine
+    if ((fifo == CAN_FIFO0 && self->rxcallback0 != mp_const_none) ||
+        (fifo == CAN_FIFO1 && self->rxcallback1 != mp_const_none)) {
+        byte *state = (fifo == CAN_FIFO0) ? &self->rx_state0 : &self->rx_state1;
+
+        switch (*state) {
+            case RX_STATE_FIFO_EMPTY:
+                break;
+            case RX_STATE_MESSAGE_PENDING:
+                if (__HAL_CAN_MSG_PENDING(&self->can, fifo) == 0) {
+                    // Fifo is empty
+                    __HAL_CAN_ENABLE_IT(&self->can, (fifo == CAN_FIFO0) ? CAN_IT_FIFO0_PENDING : CAN_IT_FIFO1_PENDING);
+                    *state = RX_STATE_FIFO_EMPTY;
+                }
+                break;
+            case RX_STATE_FIFO_FULL:
+                __HAL_CAN_ENABLE_IT(&self->can, (fifo == CAN_FIFO0) ? CAN_IT_FIFO0_FULL : CAN_IT_FIFO1_FULL);
+                *state = RX_STATE_MESSAGE_PENDING;
+                break;
+            case RX_STATE_FIFO_OVERFLOW:
+                __HAL_CAN_ENABLE_IT(&self->can, (fifo == CAN_FIFO0) ? CAN_IT_FIFO0_OVRF : CAN_IT_FIFO1_OVRF);
+                __HAL_CAN_ENABLE_IT(&self->can, (fifo == CAN_FIFO0) ? CAN_IT_FIFO0_FULL : CAN_IT_FIFO1_FULL);
+                *state = RX_STATE_MESSAGE_PENDING;
+                break;
+        }
+    }
+
+    // Create the tuple, or get the list, that will hold the return values
+    // Also populate the fourth element, either a new bytes or reuse existing memoryview
+    mp_obj_t ret_obj = args[ARG_list].u_obj;
+    mp_obj_t *items;
+    if (ret_obj == mp_const_none) {
+        ret_obj = mp_obj_new_tuple(4, NULL);
+        items = ((mp_obj_tuple_t *)MP_OBJ_TO_PTR(ret_obj))->items;
+        items[3] = mp_obj_new_bytes(rx_data, rx_dlc);
+    } else {
+        // User should provide a list of length at least 4 to hold the values
+        if (!mp_obj_is_type(ret_obj, &mp_type_list)) {
+            mp_raise_TypeError(NULL);
+        }
+        mp_obj_list_t *list = MP_OBJ_TO_PTR(ret_obj);
+        if (list->len < 4) {
+            mp_raise_ValueError(NULL);
+        }
+        items = list->items;
+        // Fourth element must be a memoryview which we assume points to a
+        // byte-like array which is large enough, and then we resize it inplace
+        if (!mp_obj_is_type(items[3], &mp_type_memoryview)) {
+            mp_raise_TypeError(NULL);
+        }
+        mp_obj_array_t *mv = MP_OBJ_TO_PTR(items[3]);
+        if (!(mv->typecode == (MP_OBJ_ARRAY_TYPECODE_FLAG_RW | BYTEARRAY_TYPECODE)
+              || (mv->typecode | 0x20) == (MP_OBJ_ARRAY_TYPECODE_FLAG_RW | 'b'))) {
+            mp_raise_ValueError(NULL);
+        }
+        mv->len = rx_dlc;
+        memcpy(mv->items, rx_data, rx_dlc);
+    }
+
+    // Populate the first 3 values of the tuple/list
+    #if MICROPY_HW_ENABLE_FDCAN
+    items[0] = MP_OBJ_NEW_SMALL_INT(rx_msg.Identifier);
+    items[1] = rx_msg.RxFrameType == FDCAN_REMOTE_FRAME ? mp_const_true : mp_const_false;
+    items[2] = MP_OBJ_NEW_SMALL_INT(rx_msg.FilterIndex);
+    #else
+    items[0] = MP_OBJ_NEW_SMALL_INT((rx_msg.IDE == CAN_ID_STD ? rx_msg.StdId : rx_msg.ExtId));
+    items[1] = rx_msg.RTR == CAN_RTR_REMOTE ? mp_const_true : mp_const_false;
+    items[2] = MP_OBJ_NEW_SMALL_INT(rx_msg.FMI);
+    #endif
+
+    // Return the result
+    return ret_obj;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_can_recv_obj, 1, pyb_can_recv);
+
+// initfilterbanks(n)
+STATIC mp_obj_t pyb_can_initfilterbanks(mp_obj_t self, mp_obj_t bank_in) {
+    #if MICROPY_HW_ENABLE_FDCAN
+    can2_start_bank = 0;
+    #else
+    can2_start_bank = mp_obj_get_int(bank_in);
+    #endif
+
+    for (int f = 0; f < CAN_MAX_FILTER; f++) {
+        can_clearfilter(MP_OBJ_TO_PTR(self), f, can2_start_bank);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_can_initfilterbanks_fun_obj, pyb_can_initfilterbanks);
+STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(pyb_can_initfilterbanks_obj, MP_ROM_PTR(&pyb_can_initfilterbanks_fun_obj));
+
+STATIC mp_obj_t pyb_can_clearfilter(mp_obj_t self_in, mp_obj_t bank_in) {
+    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_int_t f = mp_obj_get_int(bank_in);
+    if (self->can_id == 2) {
+        f += can2_start_bank;
+    }
+    can_clearfilter(self, f, can2_start_bank);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_can_clearfilter_obj, pyb_can_clearfilter);
+
+// setfilter(bank, mode, fifo, params, *, rtr)
+#define EXTENDED_ID_TO_16BIT_FILTER(id) (((id & 0xC00000) >> 13) | ((id & 0x38000) >> 15)) | 8
+STATIC mp_obj_t pyb_can_setfilter(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_bank, ARG_mode, ARG_fifo, ARG_params, ARG_rtr };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_bank,     MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_mode,     MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_fifo,     MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = CAN_FILTER_FIFO0} },
+        { MP_QSTR_params,   MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_rtr,      MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+    };
+
+    // parse args
+    pyb_can_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    #if MICROPY_HW_ENABLE_FDCAN
+    FDCAN_FilterTypeDef filter = {0};
+    filter.IdType = FDCAN_STANDARD_ID;
+    // TODO check filter index
+    filter.FilterIndex = args[ARG_bank].u_int;
+
+    // Check filter mode
+    if (((args[ARG_mode].u_int != FDCAN_FILTER_RANGE) &&
+         (args[ARG_mode].u_int != FDCAN_FILTER_DUAL) &&
+         (args[ARG_mode].u_int != FDCAN_FILTER_MASK))) {
+        goto error;
+    }
+
+    // Check FIFO index.
+    if (args[ARG_fifo].u_int == 0) {
+        filter.FilterConfig = FDCAN_FILTER_TO_RXFIFO0;
+    } else if (args[ARG_fifo].u_int == 1) {
+        filter.FilterConfig = FDCAN_FILTER_TO_RXFIFO1;
+    } else {
+        goto error;
+    }
+
+    size_t len;
+    mp_obj_t *params;
+    mp_obj_get_array(args[ARG_params].u_obj, &len, &params);
+    if (len != 2) { // Check params len
+        goto error;
+    }
+    filter.FilterID1 = mp_obj_get_int(params[0]);
+    filter.FilterID2 = mp_obj_get_int(params[1]);
+    filter.FilterType = args[ARG_mode].u_int;
+    HAL_FDCAN_ConfigFilter(&self->can, &filter);
+
+    #else
+
+    size_t len;
+    size_t rtr_len;
+    mp_uint_t rtr_masks[4] = {0, 0, 0, 0};
+    mp_obj_t *rtr_flags;
+    mp_obj_t *params;
+    mp_obj_get_array(args[ARG_params].u_obj, &len, &params);
+    if (args[ARG_rtr].u_obj != MP_OBJ_NULL) {
+        mp_obj_get_array(args[ARG_rtr].u_obj, &rtr_len, &rtr_flags);
+    }
+
+    CAN_FilterConfTypeDef filter;
+    if (args[ARG_mode].u_int == MASK16 || args[ARG_mode].u_int == LIST16) {
+        if (len != 4) {
+            goto error;
+        }
+        filter.FilterScale = CAN_FILTERSCALE_16BIT;
+        if (self->extframe) {
+            if (args[ARG_rtr].u_obj != MP_OBJ_NULL) {
+                if (args[ARG_mode].u_int == MASK16) {
+                    rtr_masks[0] = mp_obj_get_int(rtr_flags[0]) ? 0x02 : 0;
+                    rtr_masks[1] = 0x02;
+                    rtr_masks[2] = mp_obj_get_int(rtr_flags[1]) ? 0x02 : 0;
+                    rtr_masks[3] = 0x02;
+                } else {  // LIST16
+                    rtr_masks[0] = mp_obj_get_int(rtr_flags[0]) ? 0x02 : 0;
+                    rtr_masks[1] = mp_obj_get_int(rtr_flags[1]) ? 0x02 : 0;
+                    rtr_masks[2] = mp_obj_get_int(rtr_flags[2]) ? 0x02 : 0;
+                    rtr_masks[3] = mp_obj_get_int(rtr_flags[3]) ? 0x02 : 0;
+                }
+            }
+            filter.FilterIdLow = EXTENDED_ID_TO_16BIT_FILTER(mp_obj_get_int(params[0])) | rtr_masks[0];      // id1
+            filter.FilterMaskIdLow = EXTENDED_ID_TO_16BIT_FILTER(mp_obj_get_int(params[1])) | rtr_masks[1];  // mask1
+            filter.FilterIdHigh = EXTENDED_ID_TO_16BIT_FILTER(mp_obj_get_int(params[2])) | rtr_masks[2];     // id2
+            filter.FilterMaskIdHigh = EXTENDED_ID_TO_16BIT_FILTER(mp_obj_get_int(params[3])) | rtr_masks[3]; // mask2
+        } else { // Basic frames
+            if (args[ARG_rtr].u_obj != MP_OBJ_NULL) {
+                if (args[ARG_mode].u_int == MASK16) {
+                    rtr_masks[0] = mp_obj_get_int(rtr_flags[0]) ? 0x10 : 0;
+                    rtr_masks[1] = 0x10;
+                    rtr_masks[2] = mp_obj_get_int(rtr_flags[1]) ? 0x10 : 0;
+                    rtr_masks[3] = 0x10;
+                } else {  // LIST16
+                    rtr_masks[0] = mp_obj_get_int(rtr_flags[0]) ? 0x10 : 0;
+                    rtr_masks[1] = mp_obj_get_int(rtr_flags[1]) ? 0x10 : 0;
+                    rtr_masks[2] = mp_obj_get_int(rtr_flags[2]) ? 0x10 : 0;
+                    rtr_masks[3] = mp_obj_get_int(rtr_flags[3]) ? 0x10 : 0;
+                }
+            }
+            filter.FilterIdLow = (mp_obj_get_int(params[0]) << 5) | rtr_masks[0];      // id1
+            filter.FilterMaskIdLow = (mp_obj_get_int(params[1]) << 5) | rtr_masks[1];  // mask1
+            filter.FilterIdHigh = (mp_obj_get_int(params[2]) << 5) | rtr_masks[2];     // id2
+            filter.FilterMaskIdHigh = (mp_obj_get_int(params[3]) << 5) | rtr_masks[3]; // mask2
+        }
+        if (args[ARG_mode].u_int == MASK16) {
+            filter.FilterMode = CAN_FILTERMODE_IDMASK;
+        }
+        if (args[ARG_mode].u_int == LIST16) {
+            filter.FilterMode = CAN_FILTERMODE_IDLIST;
+        }
+    } else if (args[ARG_mode].u_int == MASK32 || args[ARG_mode].u_int == LIST32) {
+        if (len != 2) {
+            goto error;
+        }
+        filter.FilterScale = CAN_FILTERSCALE_32BIT;
+        if (args[ARG_rtr].u_obj != MP_OBJ_NULL) {
+            if (args[ARG_mode].u_int == MASK32) {
+                rtr_masks[0] = mp_obj_get_int(rtr_flags[0]) ? 0x02 : 0;
+                rtr_masks[1] = 0x02;
+            } else {  // LIST32
+                rtr_masks[0] = mp_obj_get_int(rtr_flags[0]) ? 0x02 : 0;
+                rtr_masks[1] = mp_obj_get_int(rtr_flags[1]) ? 0x02 : 0;
+            }
+        }
+        filter.FilterIdHigh = (mp_obj_get_int(params[0]) & 0x1FFFE000) >> 13;
+        filter.FilterIdLow = (((mp_obj_get_int(params[0]) & 0x00001FFF) << 3) | 4) | rtr_masks[0];
+        filter.FilterMaskIdHigh = (mp_obj_get_int(params[1]) & 0x1FFFE000) >> 13;
+        filter.FilterMaskIdLow = (((mp_obj_get_int(params[1]) & 0x00001FFF) << 3) | 4) | rtr_masks[1];
+        if (args[ARG_mode].u_int == MASK32) {
+            filter.FilterMode = CAN_FILTERMODE_IDMASK;
+        }
+        if (args[ARG_mode].u_int == LIST32) {
+            filter.FilterMode = CAN_FILTERMODE_IDLIST;
+        }
+    } else {
+        goto error;
+    }
+
+    filter.FilterFIFOAssignment = args[ARG_fifo].u_int;
+    filter.FilterNumber = args[ARG_bank].u_int;
+    if (self->can_id == 1) {
+        if (filter.FilterNumber >= can2_start_bank) {
+            goto error;
+        }
+    } else if (self->can_id == 2) {
+        filter.FilterNumber = filter.FilterNumber + can2_start_bank;
+        if (filter.FilterNumber > 27) {
+            goto error;
+        }
+    } else {
+        if (filter.FilterNumber > 13) { // CAN3 is independant and has its own 14 filters.
+            goto error;
+        }
+    }
+    filter.FilterActivation = ENABLE;
+    filter.BankNumber = can2_start_bank;
+    HAL_CAN_ConfigFilter(&self->can, &filter);
+    #endif
+
+    return mp_const_none;
+error:
+    mp_raise_ValueError(MP_ERROR_TEXT("CAN filter parameter error"));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_can_setfilter_obj, 1, pyb_can_setfilter);
+
+STATIC mp_obj_t pyb_can_rxcallback(mp_obj_t self_in, mp_obj_t fifo_in, mp_obj_t callback_in) {
+    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_int_t fifo = mp_obj_get_int(fifo_in);
+    mp_obj_t *callback;
+
+    callback = (fifo == 0) ? &self->rxcallback0 : &self->rxcallback1;
+    if (callback_in == mp_const_none) {
+        __HAL_CAN_DISABLE_IT(&self->can, (fifo == 0) ? CAN_IT_FIFO0_PENDING : CAN_IT_FIFO1_PENDING);
+        __HAL_CAN_DISABLE_IT(&self->can, (fifo == 0) ? CAN_IT_FIFO0_FULL : CAN_IT_FIFO1_FULL);
+        __HAL_CAN_DISABLE_IT(&self->can, (fifo == 0) ? CAN_IT_FIFO0_OVRF : CAN_IT_FIFO1_OVRF);
+        __HAL_CAN_CLEAR_FLAG(&self->can, (fifo == CAN_FIFO0) ? CAN_FLAG_FIFO0_FULL : CAN_FLAG_FIFO1_FULL);
+        __HAL_CAN_CLEAR_FLAG(&self->can, (fifo == CAN_FIFO0) ? CAN_FLAG_FIFO0_OVRF : CAN_FLAG_FIFO1_OVRF);
+        *callback = mp_const_none;
+    } else if (*callback != mp_const_none) {
+        // Rx call backs has already been initialized
+        // only the callback function should be changed
+        *callback = callback_in;
+    } else if (mp_obj_is_callable(callback_in)) {
+        *callback = callback_in;
+        uint32_t irq = 0;
+        if (self->can_id == PYB_CAN_1) {
+            irq = (fifo == 0) ? CAN1_RX0_IRQn : CAN1_RX1_IRQn;
+        #if defined(CAN2)
+        } else if (self->can_id == PYB_CAN_2) {
+            irq = (fifo == 0) ? CAN2_RX0_IRQn : CAN2_RX1_IRQn;
+        #endif
+        #if defined(CAN3)
+        } else {
+            irq = (fifo == 0) ? CAN3_RX0_IRQn : CAN3_RX1_IRQn;
+        #endif
+        }
+        NVIC_SetPriority(irq, IRQ_PRI_CAN);
+        HAL_NVIC_EnableIRQ(irq);
+        __HAL_CAN_ENABLE_IT(&self->can, (fifo == 0) ? CAN_IT_FIFO0_PENDING : CAN_IT_FIFO1_PENDING);
+        __HAL_CAN_ENABLE_IT(&self->can, (fifo == 0) ? CAN_IT_FIFO0_FULL : CAN_IT_FIFO1_FULL);
+        __HAL_CAN_ENABLE_IT(&self->can, (fifo == 0) ? CAN_IT_FIFO0_OVRF : CAN_IT_FIFO1_OVRF);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_can_rxcallback_obj, pyb_can_rxcallback);
+
+STATIC const mp_rom_map_elem_t pyb_can_locals_dict_table[] = {
+    // instance methods
+    { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&pyb_can_init_obj) },
+    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&pyb_can_deinit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_restart), MP_ROM_PTR(&pyb_can_restart_obj) },
+    { MP_ROM_QSTR(MP_QSTR_state), MP_ROM_PTR(&pyb_can_state_obj) },
+    { MP_ROM_QSTR(MP_QSTR_info), MP_ROM_PTR(&pyb_can_info_obj) },
+    { MP_ROM_QSTR(MP_QSTR_any), MP_ROM_PTR(&pyb_can_any_obj) },
+    { MP_ROM_QSTR(MP_QSTR_send), MP_ROM_PTR(&pyb_can_send_obj) },
+    { MP_ROM_QSTR(MP_QSTR_recv), MP_ROM_PTR(&pyb_can_recv_obj) },
+    { MP_ROM_QSTR(MP_QSTR_initfilterbanks), MP_ROM_PTR(&pyb_can_initfilterbanks_obj) },
+    { MP_ROM_QSTR(MP_QSTR_setfilter), MP_ROM_PTR(&pyb_can_setfilter_obj) },
+    { MP_ROM_QSTR(MP_QSTR_clearfilter), MP_ROM_PTR(&pyb_can_clearfilter_obj) },
+    { MP_ROM_QSTR(MP_QSTR_rxcallback), MP_ROM_PTR(&pyb_can_rxcallback_obj) },
+
+    #if MICROPY_HW_ENABLE_FDCAN
+    { MP_ROM_QSTR(MP_QSTR_NORMAL), MP_ROM_INT(CAN_MODE_NORMAL) },
+    { MP_ROM_QSTR(MP_QSTR_LOOPBACK), MP_ROM_INT(CAN_MODE_LOOPBACK) },
+    { MP_ROM_QSTR(MP_QSTR_SILENT), MP_ROM_INT(CAN_MODE_SILENT) },
+    { MP_ROM_QSTR(MP_QSTR_SILENT_LOOPBACK), MP_ROM_INT(CAN_MODE_SILENT_LOOPBACK) },
+
+    { MP_ROM_QSTR(MP_QSTR_RANGE), MP_ROM_INT(FDCAN_FILTER_RANGE) },
+    { MP_ROM_QSTR(MP_QSTR_DUAL), MP_ROM_INT(FDCAN_FILTER_DUAL) },
+    { MP_ROM_QSTR(MP_QSTR_MASK), MP_ROM_INT(FDCAN_FILTER_MASK) },
+    #else
+    // class constants
+    // Note: we use the ST constants >> 4 so they fit in a small-int.  The
+    // right-shift is undone when the constants are used in the init function.
+    { MP_ROM_QSTR(MP_QSTR_NORMAL), MP_ROM_INT(CAN_MODE_NORMAL >> 4) },
+    { MP_ROM_QSTR(MP_QSTR_LOOPBACK), MP_ROM_INT(CAN_MODE_LOOPBACK >> 4) },
+    { MP_ROM_QSTR(MP_QSTR_SILENT), MP_ROM_INT(CAN_MODE_SILENT >> 4) },
+    { MP_ROM_QSTR(MP_QSTR_SILENT_LOOPBACK), MP_ROM_INT(CAN_MODE_SILENT_LOOPBACK >> 4) },
+
+    { MP_ROM_QSTR(MP_QSTR_MASK16), MP_ROM_INT(MASK16) },
+    { MP_ROM_QSTR(MP_QSTR_LIST16), MP_ROM_INT(LIST16) },
+    { MP_ROM_QSTR(MP_QSTR_MASK32), MP_ROM_INT(MASK32) },
+    { MP_ROM_QSTR(MP_QSTR_LIST32), MP_ROM_INT(LIST32) },
+    #endif
+
+    // values for CAN.state()
+    { MP_ROM_QSTR(MP_QSTR_STOPPED), MP_ROM_INT(CAN_STATE_STOPPED) },
+    { MP_ROM_QSTR(MP_QSTR_ERROR_ACTIVE), MP_ROM_INT(CAN_STATE_ERROR_ACTIVE) },
+    { MP_ROM_QSTR(MP_QSTR_ERROR_WARNING), MP_ROM_INT(CAN_STATE_ERROR_WARNING) },
+    { MP_ROM_QSTR(MP_QSTR_ERROR_PASSIVE), MP_ROM_INT(CAN_STATE_ERROR_PASSIVE) },
+    { MP_ROM_QSTR(MP_QSTR_BUS_OFF), MP_ROM_INT(CAN_STATE_BUS_OFF) },
+};
+STATIC MP_DEFINE_CONST_DICT(pyb_can_locals_dict, pyb_can_locals_dict_table);
+
+STATIC mp_uint_t can_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    pyb_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_uint_t ret;
+    if (request == MP_STREAM_POLL) {
+        uintptr_t flags = arg;
+        ret = 0;
+        if ((flags & MP_STREAM_POLL_RD)
+            && ((__HAL_CAN_MSG_PENDING(&self->can, CAN_FIFO0) != 0)
+                || (__HAL_CAN_MSG_PENDING(&self->can, CAN_FIFO1) != 0))) {
+            ret |= MP_STREAM_POLL_RD;
+        }
+        #if MICROPY_HW_ENABLE_FDCAN
+        if ((flags & MP_STREAM_POLL_WR) && (self->can.Instance->IR & FDCAN_IR_TFE))
+        #else
+        if ((flags & MP_STREAM_POLL_WR) && (self->can.Instance->TSR & CAN_TSR_TME))
+        #endif
+        {
+            ret |= MP_STREAM_POLL_WR;
+        }
+    } else {
+        *errcode = MP_EINVAL;
+        ret = -1;
+    }
+    return ret;
+}
+
+void pyb_can_handle_callback(pyb_can_obj_t *self, uint fifo_id, mp_obj_t callback, mp_obj_t irq_reason) {
+    if (callback != mp_const_none) {
+        mp_sched_lock();
+        gc_lock();
+        nlr_buf_t nlr;
+        if (nlr_push(&nlr) == 0) {
+            mp_call_function_2(callback, MP_OBJ_FROM_PTR(self), irq_reason);
+            nlr_pop();
+        } else {
+            // Uncaught exception; disable the callback so it doesn't run again.
+            pyb_can_rxcallback(MP_OBJ_FROM_PTR(self), MP_OBJ_NEW_SMALL_INT(fifo_id), mp_const_none);
+            mp_printf(MICROPY_ERROR_PRINTER, "uncaught exception in CAN(%u) rx interrupt handler\n", self->can_id);
+            mp_obj_print_exception(&mp_plat_print, MP_OBJ_FROM_PTR(nlr.ret_val));
+        }
+        gc_unlock();
+        mp_sched_unlock();
+    }
+}
+
+STATIC const mp_stream_p_t can_stream_p = {
+    // .read = can_read, // is read sensible for CAN?
+    // .write = can_write, // is write sensible for CAN?
+    .ioctl = can_ioctl,
+    .is_text = false,
+};
+
+const mp_obj_type_t pyb_can_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_CAN,
+    .print = pyb_can_print,
+    .make_new = pyb_can_make_new,
+    .protocol = &can_stream_p,
+    .locals_dict = (mp_obj_dict_t *)&pyb_can_locals_dict,
+};
+
+#endif // MICROPY_HW_ENABLE_CAN
diff --git a/ports/stm32/pyb_i2c.c b/ports/stm32/pyb_i2c.c
index 233cbba512f40..4f8f7a0e3741c 100644
--- a/ports/stm32/pyb_i2c.c
+++ b/ports/stm32/pyb_i2c.c
@@ -135,6 +135,8 @@ const pyb_i2c_obj_t pyb_i2c_obj[] = {
 // The STM32F0, F3, F7, H7 and L4 use a TIMINGR register rather than ClockSpeed and
 // DutyCycle.
 
+#define PYB_I2C_TIMINGR (1)
+
 #if defined(STM32F746xx)
 
 // The value 0x40912732 was obtained from the DISCOVERY_I2Cx_TIMING constant
@@ -143,7 +145,7 @@ const pyb_i2c_obj_t pyb_i2c_obj[] = {
         {PYB_I2C_SPEED_STANDARD, 0x40912732}, \
         {PYB_I2C_SPEED_FULL, 0x10911823}, \
         {PYB_I2C_SPEED_FAST, 0x00611116}, \
-    }
+}
 #define MICROPY_HW_I2C_BAUDRATE_DEFAULT (PYB_I2C_SPEED_FULL)
 #define MICROPY_HW_I2C_BAUDRATE_MAX (PYB_I2C_SPEED_FAST)
 
@@ -157,7 +159,7 @@ const pyb_i2c_obj_t pyb_i2c_obj[] = {
         {PYB_I2C_SPEED_STANDARD, 0xb0420f13}, \
         {PYB_I2C_SPEED_FULL, 0x70330309}, \
         {PYB_I2C_SPEED_FAST, 0x50100103}, \
-    }
+}
 #define MICROPY_HW_I2C_BAUDRATE_DEFAULT (PYB_I2C_SPEED_FULL)
 #define MICROPY_HW_I2C_BAUDRATE_MAX (PYB_I2C_SPEED_FAST)
 
@@ -168,7 +170,7 @@ const pyb_i2c_obj_t pyb_i2c_obj[] = {
         {PYB_I2C_SPEED_STANDARD, 0x40604E73}, \
         {PYB_I2C_SPEED_FULL, 0x00901954}, \
         {PYB_I2C_SPEED_FAST, 0x10810915}, \
-    }
+}
 #define MICROPY_HW_I2C_BAUDRATE_DEFAULT (PYB_I2C_SPEED_FULL)
 #define MICROPY_HW_I2C_BAUDRATE_MAX (PYB_I2C_SPEED_FAST)
 
@@ -185,8 +187,8 @@ const pyb_i2c_obj_t pyb_i2c_obj[] = {
 #endif
 
 STATIC const struct {
-    uint32_t    baudrate;
-    uint32_t    timing;
+    uint32_t baudrate;
+    uint32_t timing;
 } pyb_i2c_baudrate_timing[] = MICROPY_HW_I2C_BAUDRATE_TIMING;
 
 #define NUM_BAUDRATE_TIMINGS MP_ARRAY_SIZE(pyb_i2c_baudrate_timing)
@@ -198,8 +200,7 @@ STATIC void i2c_set_baudrate(I2C_InitTypeDef *init, uint32_t baudrate) {
             return;
         }
     }
-    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-                                            "Unsupported I2C baudrate: %u", baudrate));
+    mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("unsupported I2C baudrate: %u"), baudrate);
 }
 
 uint32_t pyb_i2c_get_baudrate(I2C_HandleTypeDef *i2c) {
@@ -213,6 +214,8 @@ uint32_t pyb_i2c_get_baudrate(I2C_HandleTypeDef *i2c) {
 
 #else
 
+#define PYB_I2C_TIMINGR (0)
+
 #define MICROPY_HW_I2C_BAUDRATE_DEFAULT (PYB_I2C_SPEED_FULL)
 #define MICROPY_HW_I2C_BAUDRATE_MAX (PYB_I2C_SPEED_FULL)
 
@@ -376,12 +379,12 @@ void i2c_deinit(I2C_HandleTypeDef *i2c) {
 void pyb_i2c_init_freq(const pyb_i2c_obj_t *self, mp_int_t freq) {
     I2C_InitTypeDef *init = &self->i2c->Init;
 
-    init->AddressingMode    = I2C_ADDRESSINGMODE_7BIT;
-    init->DualAddressMode   = I2C_DUALADDRESS_DISABLED;
-    init->GeneralCallMode   = I2C_GENERALCALL_DISABLED;
-    init->NoStretchMode     = I2C_NOSTRETCH_DISABLE;
-    init->OwnAddress1       = PYB_I2C_MASTER_ADDRESS;
-    init->OwnAddress2       = 0; // unused
+    init->AddressingMode = I2C_ADDRESSINGMODE_7BIT;
+    init->DualAddressMode = I2C_DUALADDRESS_DISABLED;
+    init->GeneralCallMode = I2C_GENERALCALL_DISABLED;
+    init->NoStretchMode = I2C_NOSTRETCH_DISABLE;
+    init->OwnAddress1 = PYB_I2C_MASTER_ADDRESS;
+    init->OwnAddress2 = 0;       // unused
     if (freq != -1) {
         i2c_set_baudrate(init, MIN(freq, MICROPY_HW_I2C_BAUDRATE_MAX));
     }
@@ -540,31 +543,50 @@ STATIC HAL_StatusTypeDef i2c_wait_dma_finished(I2C_HandleTypeDef *i2c, uint32_t
 /******************************************************************************/
 /* MicroPython bindings                                                       */
 
-static inline bool in_master_mode(pyb_i2c_obj_t *self) { return self->i2c->Init.OwnAddress1 == PYB_I2C_MASTER_ADDRESS; }
+static inline bool in_master_mode(pyb_i2c_obj_t *self) {
+    return self->i2c->Init.OwnAddress1 == PYB_I2C_MASTER_ADDRESS;
+}
 
 STATIC void pyb_i2c_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     pyb_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
     uint i2c_num = 0;
-    if (0) { }
+    if (0) {
+    }
     #if defined(MICROPY_HW_I2C1_SCL)
-    else if (self->i2c->Instance == I2C1) { i2c_num = 1; }
+    else if (self->i2c->Instance == I2C1) {
+        i2c_num = 1;
+    }
     #endif
     #if defined(MICROPY_HW_I2C2_SCL)
-    else if (self->i2c->Instance == I2C2) { i2c_num = 2; }
+    else if (self->i2c->Instance == I2C2) {
+        i2c_num = 2;
+    }
     #endif
     #if defined(MICROPY_HW_I2C3_SCL)
-    else if (self->i2c->Instance == I2C3) { i2c_num = 3; }
+    else if (self->i2c->Instance == I2C3) {
+        i2c_num = 3;
+    }
     #endif
     #if defined(MICROPY_HW_I2C4_SCL)
-    else if (self->i2c->Instance == I2C4) { i2c_num = 4; }
+    else if (self->i2c->Instance == I2C4) {
+        i2c_num = 4;
+    }
     #endif
 
     if (self->i2c->State == HAL_I2C_STATE_RESET) {
         mp_printf(print, "I2C(%u)", i2c_num);
     } else {
         if (in_master_mode(self)) {
-            mp_printf(print, "I2C(%u, I2C.MASTER, baudrate=%u)", i2c_num, pyb_i2c_get_baudrate(self->i2c));
+            mp_printf(print, "I2C(%u, I2C.MASTER, baudrate=%u"
+                #if PYB_I2C_TIMINGR
+                ", timingr=0x%08x"
+                #endif
+                ")", i2c_num, pyb_i2c_get_baudrate(self->i2c)
+                #if PYB_I2C_TIMINGR
+                , self->i2c->Init.Timing
+                #endif
+                );
         } else {
             mp_printf(print, "I2C(%u, I2C.SLAVE, addr=0x%02x)", i2c_num, (self->i2c->Instance->OAR1 >> 1) & 0x7f);
         }
@@ -586,6 +608,9 @@ STATIC mp_obj_t pyb_i2c_init_helper(const pyb_i2c_obj_t *self, size_t n_args, co
         { MP_QSTR_baudrate, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = MICROPY_HW_I2C_BAUDRATE_DEFAULT} },
         { MP_QSTR_gencall,  MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
         { MP_QSTR_dma,      MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
+        #if PYB_I2C_TIMINGR
+        { MP_QSTR_timingr,  MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        #endif
     };
 
     // parse args
@@ -602,12 +627,21 @@ STATIC mp_obj_t pyb_i2c_init_helper(const pyb_i2c_obj_t *self, size_t n_args, co
         init->OwnAddress1 = (args[1].u_int << 1) & 0xfe;
     }
 
-    i2c_set_baudrate(init, MIN(args[2].u_int, MICROPY_HW_I2C_BAUDRATE_MAX));
-    init->AddressingMode  = I2C_ADDRESSINGMODE_7BIT;
+    // Set baudrate or timing value (if supported)
+    #if PYB_I2C_TIMINGR
+    if (args[5].u_obj != mp_const_none) {
+        init->Timing = mp_obj_get_int_truncated(args[5].u_obj);
+    } else
+    #endif
+    {
+        i2c_set_baudrate(init, MIN(args[2].u_int, MICROPY_HW_I2C_BAUDRATE_MAX));
+    }
+
+    init->AddressingMode = I2C_ADDRESSINGMODE_7BIT;
     init->DualAddressMode = I2C_DUALADDRESS_DISABLED;
     init->GeneralCallMode = args[3].u_bool ? I2C_GENERALCALL_ENABLED : I2C_GENERALCALL_DISABLED;
-    init->OwnAddress2     = 0; // unused
-    init->NoStretchMode   = I2C_NOSTRETCH_DISABLE;
+    init->OwnAddress2 = 0;     // unused
+    init->NoStretchMode = I2C_NOSTRETCH_DISABLE;
 
     *self->use_dma = args[4].u_bool;
 
@@ -656,15 +690,13 @@ STATIC mp_obj_t pyb_i2c_make_new(const mp_obj_type_t *type, size_t n_args, size_
             i2c_id = 4;
         #endif
         } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-                "I2C(%s) doesn't exist", port));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("I2C(%s) doesn't exist"), port);
         }
     } else {
         i2c_id = mp_obj_get_int(args[0]);
         if (i2c_id < 1 || i2c_id > MP_ARRAY_SIZE(pyb_i2c_obj)
             || pyb_i2c_obj[i2c_id - 1].i2c == NULL) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-                "I2C(%d) doesn't exist", i2c_id));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("I2C(%d) doesn't exist"), i2c_id);
         }
     }
 
@@ -701,7 +733,7 @@ STATIC mp_obj_t pyb_i2c_is_ready(mp_obj_t self_in, mp_obj_t i2c_addr_o) {
     pyb_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
     if (!in_master_mode(self)) {
-        mp_raise_TypeError("I2C must be a master");
+        mp_raise_TypeError(MP_ERROR_TEXT("I2C must be a master"));
     }
 
     mp_uint_t i2c_addr = mp_obj_get_int(i2c_addr_o) << 1;
@@ -724,7 +756,7 @@ STATIC mp_obj_t pyb_i2c_scan(mp_obj_t self_in) {
     pyb_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
     if (!in_master_mode(self)) {
-        mp_raise_TypeError("I2C must be a master");
+        mp_raise_TypeError(MP_ERROR_TEXT("I2C must be a master"));
     }
 
     mp_obj_t list = mp_obj_new_list(0, NULL);
@@ -782,7 +814,7 @@ STATIC mp_obj_t pyb_i2c_send(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
             if (use_dma) {
                 dma_deinit(self->tx_dma_descr);
             }
-            mp_raise_TypeError("addr argument required");
+            mp_raise_TypeError(MP_ERROR_TEXT("addr argument required"));
         }
         mp_uint_t i2c_addr = args[1].u_int << 1;
         if (!use_dma) {
@@ -858,21 +890,21 @@ STATIC mp_obj_t pyb_i2c_recv(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
     HAL_StatusTypeDef status;
     if (in_master_mode(self)) {
         if (args[1].u_int == PYB_I2C_MASTER_ADDRESS) {
-            mp_raise_TypeError("addr argument required");
+            mp_raise_TypeError(MP_ERROR_TEXT("addr argument required"));
         }
         mp_uint_t i2c_addr = args[1].u_int << 1;
         if (!use_dma) {
-            status = HAL_I2C_Master_Receive(self->i2c, i2c_addr, (uint8_t*)vstr.buf, vstr.len, args[2].u_int);
+            status = HAL_I2C_Master_Receive(self->i2c, i2c_addr, (uint8_t *)vstr.buf, vstr.len, args[2].u_int);
         } else {
             MP_HAL_CLEANINVALIDATE_DCACHE(vstr.buf, vstr.len);
-            status = HAL_I2C_Master_Receive_DMA(self->i2c, i2c_addr, (uint8_t*)vstr.buf, vstr.len);
+            status = HAL_I2C_Master_Receive_DMA(self->i2c, i2c_addr, (uint8_t *)vstr.buf, vstr.len);
         }
     } else {
         if (!use_dma) {
-            status = HAL_I2C_Slave_Receive(self->i2c, (uint8_t*)vstr.buf, vstr.len, args[2].u_int);
+            status = HAL_I2C_Slave_Receive(self->i2c, (uint8_t *)vstr.buf, vstr.len, args[2].u_int);
         } else {
             MP_HAL_CLEANINVALIDATE_DCACHE(vstr.buf, vstr.len);
-            status = HAL_I2C_Slave_Receive_DMA(self->i2c, (uint8_t*)vstr.buf, vstr.len);
+            status = HAL_I2C_Slave_Receive_DMA(self->i2c, (uint8_t *)vstr.buf, vstr.len);
         }
     }
 
@@ -925,7 +957,7 @@ STATIC mp_obj_t pyb_i2c_mem_read(size_t n_args, const mp_obj_t *pos_args, mp_map
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(pyb_i2c_mem_read_allowed_args), pyb_i2c_mem_read_allowed_args, args);
 
     if (!in_master_mode(self)) {
-        mp_raise_TypeError("I2C must be a master");
+        mp_raise_TypeError(MP_ERROR_TEXT("I2C must be a master"));
     }
 
     // get the buffer to read into
@@ -946,14 +978,14 @@ STATIC mp_obj_t pyb_i2c_mem_read(size_t n_args, const mp_obj_t *pos_args, mp_map
 
     HAL_StatusTypeDef status;
     if (!use_dma) {
-        status = HAL_I2C_Mem_Read(self->i2c, i2c_addr, mem_addr, mem_addr_size, (uint8_t*)vstr.buf, vstr.len, args[3].u_int);
+        status = HAL_I2C_Mem_Read(self->i2c, i2c_addr, mem_addr, mem_addr_size, (uint8_t *)vstr.buf, vstr.len, args[3].u_int);
     } else {
         DMA_HandleTypeDef rx_dma;
         dma_init(&rx_dma, self->rx_dma_descr, DMA_PERIPH_TO_MEMORY, self->i2c);
         self->i2c->hdmatx = NULL;
         self->i2c->hdmarx = &rx_dma;
         MP_HAL_CLEANINVALIDATE_DCACHE(vstr.buf, vstr.len);
-        status = HAL_I2C_Mem_Read_DMA(self->i2c, i2c_addr, mem_addr, mem_addr_size, (uint8_t*)vstr.buf, vstr.len);
+        status = HAL_I2C_Mem_Read_DMA(self->i2c, i2c_addr, mem_addr, mem_addr_size, (uint8_t *)vstr.buf, vstr.len);
         if (status == HAL_OK) {
             status = i2c_wait_dma_finished(self->i2c, args[3].u_int);
         }
@@ -993,7 +1025,7 @@ STATIC mp_obj_t pyb_i2c_mem_write(size_t n_args, const mp_obj_t *pos_args, mp_ma
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(pyb_i2c_mem_read_allowed_args), pyb_i2c_mem_read_allowed_args, args);
 
     if (!in_master_mode(self)) {
-        mp_raise_TypeError("I2C must be a master");
+        mp_raise_TypeError(MP_ERROR_TEXT("I2C must be a master"));
     }
 
     // get the buffer to write from
@@ -1063,7 +1095,7 @@ const mp_obj_type_t pyb_i2c_type = {
     .name = MP_QSTR_I2C,
     .print = pyb_i2c_print,
     .make_new = pyb_i2c_make_new,
-    .locals_dict = (mp_obj_dict_t*)&pyb_i2c_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_i2c_locals_dict,
 };
 
 #endif // MICROPY_PY_PYB_LEGACY && MICROPY_HW_ENABLE_HW_I2C
diff --git a/ports/stm32/pyb_spi.c b/ports/stm32/pyb_spi.c
index e76369973ceb4..cc9dd1163623d 100644
--- a/ports/stm32/pyb_spi.c
+++ b/ports/stm32/pyb_spi.c
@@ -86,7 +86,7 @@ STATIC mp_obj_t pyb_spi_init_helper(const pyb_spi_obj_t *self, size_t n_args, co
         { MP_QSTR_nss,      MP_ARG_KW_ONLY | MP_ARG_INT,  {.u_int = SPI_NSS_SOFT} },
         { MP_QSTR_firstbit, MP_ARG_KW_ONLY | MP_ARG_INT,  {.u_int = SPI_FIRSTBIT_MSB} },
         { MP_QSTR_ti,       MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
-        { MP_QSTR_crc,      MP_ARG_KW_ONLY | MP_ARG_OBJ,  {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_crc,      MP_ARG_KW_ONLY | MP_ARG_OBJ,  {.u_rom_obj = MP_ROM_NONE} },
     };
 
     // parse args
@@ -223,7 +223,7 @@ STATIC mp_obj_t pyb_spi_recv(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
     mp_obj_t o_ret = pyb_buf_get_for_recv(args[0].u_obj, &vstr);
 
     // receive the data
-    spi_transfer(self->spi, vstr.len, NULL, (uint8_t*)vstr.buf, args[1].u_int);
+    spi_transfer(self->spi, vstr.len, NULL, (uint8_t *)vstr.buf, args[1].u_int);
 
     // return the received data
     if (o_ret != MP_OBJ_NULL) {
@@ -285,7 +285,7 @@ STATIC mp_obj_t pyb_spi_send_recv(size_t n_args, const mp_obj_t *pos_args, mp_ma
             // recv argument given
             mp_get_buffer_raise(args[1].u_obj, &bufinfo_recv, MP_BUFFER_WRITE);
             if (bufinfo_recv.len != bufinfo_send.len) {
-                mp_raise_ValueError("recv must be same length as send");
+                mp_raise_ValueError(MP_ERROR_TEXT("recv must be same length as send"));
             }
             o_ret = args[1].u_obj;
         }
@@ -339,7 +339,7 @@ STATIC const mp_rom_map_elem_t pyb_spi_locals_dict_table[] = {
 STATIC MP_DEFINE_CONST_DICT(pyb_spi_locals_dict, pyb_spi_locals_dict_table);
 
 STATIC void spi_transfer_machine(mp_obj_base_t *self_in, size_t len, const uint8_t *src, uint8_t *dest) {
-    pyb_spi_obj_t *self = (pyb_spi_obj_t*)self_in;
+    pyb_spi_obj_t *self = (pyb_spi_obj_t *)self_in;
     spi_transfer(self->spi, len, src, dest, SPI_TRANSFER_TIMEOUT(len));
 }
 
@@ -353,5 +353,5 @@ const mp_obj_type_t pyb_spi_type = {
     .print = pyb_spi_print,
     .make_new = pyb_spi_make_new,
     .protocol = &pyb_spi_p,
-    .locals_dict = (mp_obj_dict_t*)&pyb_spi_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_spi_locals_dict,
 };
diff --git a/ports/stm32/pybthread.c b/ports/stm32/pybthread.c
index 6baf88f66b25a..603bc2e4ec090 100644
--- a/ports/stm32/pybthread.c
+++ b/ports/stm32/pybthread.c
@@ -34,15 +34,15 @@
 
 #if MICROPY_PY_THREAD
 
-#define PYB_MUTEX_UNLOCKED ((void*)0)
-#define PYB_MUTEX_LOCKED ((void*)1)
+#define PYB_MUTEX_UNLOCKED ((void *)0)
+#define PYB_MUTEX_LOCKED ((void *)1)
 
 // These macros are used when we only need to protect against a thread
 // switch; other interrupts are still allowed to proceed.
 #define RAISE_IRQ_PRI() raise_irq_pri(IRQ_PRI_PENDSV)
 #define RESTORE_IRQ_PRI(state) restore_irq_pri(state)
 
-extern void __fatal_error(const char*);
+extern void __fatal_error(const char *);
 
 volatile int pyb_thread_enabled;
 pyb_thread_t *volatile pyb_thread_all;
@@ -70,8 +70,8 @@ void pyb_thread_init(pyb_thread_t *thread) {
     thread->sp = NULL; // will be set when this thread switches out
     thread->local_state = 0; // will be set by mp_thread_init
     thread->arg = NULL;
-    thread->stack = &_heap_end;
-    thread->stack_len = ((uint32_t)&_estack - (uint32_t)&_heap_end) / sizeof(uint32_t);
+    thread->stack = &_sstack;
+    thread->stack_len = ((uint32_t)&_estack - (uint32_t)&_sstack) / sizeof(uint32_t);
     thread->all_next = NULL;
     thread->run_prev = thread;
     thread->run_next = thread;
@@ -94,7 +94,7 @@ STATIC void pyb_thread_terminate(void) {
     // take current thread off the run list
     pyb_thread_remove_from_runable(thread);
     // take current thread off the list of all threads
-    for (pyb_thread_t **n = (pyb_thread_t**)&pyb_thread_all;; n = &(*n)->all_next) {
+    for (pyb_thread_t **n = (pyb_thread_t **)&pyb_thread_all;; n = &(*n)->all_next) {
         if (*n == thread) {
             *n = thread->all_next;
             break;
@@ -116,7 +116,7 @@ STATIC void pyb_thread_terminate(void) {
 }
 
 uint32_t pyb_thread_new(pyb_thread_t *thread, void *stack, size_t stack_len, void *entry, void *arg) {
-    uint32_t *stack_top = (uint32_t*)stack + stack_len; // stack is full descending
+    uint32_t *stack_top = (uint32_t *)stack + stack_len; // stack is full descending
     *--stack_top = 0x01000000; // xPSR (thumb bit set)
     *--stack_top = (uint32_t)entry & 0xfffffffe; // pc (must have bit 0 cleared, even for thumb code)
     *--stack_top = (uint32_t)pyb_thread_terminate; // lr
diff --git a/ports/stm32/pybthread.h b/ports/stm32/pybthread.h
index 42300508c9923..8e5ce2570caec 100644
--- a/ports/stm32/pybthread.h
+++ b/ports/stm32/pybthread.h
@@ -59,7 +59,7 @@ static inline void pyb_thread_set_local(void *value) {
 }
 
 static inline void *pyb_thread_get_local(void) {
-    return (void*)pyb_thread_cur->local_state;
+    return (void *)pyb_thread_cur->local_state;
 }
 
 static inline void pyb_thread_yield(void) {
diff --git a/ports/stm32/qspi.c b/ports/stm32/qspi.c
index 8c8b9c4940832..b82d3d81c08ee 100644
--- a/ports/stm32/qspi.c
+++ b/ports/stm32/qspi.c
@@ -28,11 +28,14 @@
 
 #include "py/mperrno.h"
 #include "py/mphal.h"
+#include "mpu.h"
 #include "qspi.h"
 #include "pin_static_af.h"
 
 #if defined(MICROPY_HW_QSPIFLASH_SIZE_BITS_LOG2)
 
+#define QSPI_MAP_ADDR (0x90000000)
+
 #ifndef MICROPY_HW_QSPI_PRESCALER
 #define MICROPY_HW_QSPI_PRESCALER       3  // F_CLK = F_AHB/3 (72MHz when CPU is 216MHz)
 #endif
@@ -49,7 +52,39 @@
 #define MICROPY_HW_QSPI_CS_HIGH_CYCLES  2  // nCS stays high for 2 cycles
 #endif
 
+#if (MICROPY_HW_QSPIFLASH_SIZE_BITS_LOG2 - 3 - 1) >= 24
+#define QSPI_CMD 0xec
+#define QSPI_ADSIZE 3
+#else
+#define QSPI_CMD 0xeb
+#define QSPI_ADSIZE 2
+#endif
+
+static inline void qspi_mpu_disable_all(void) {
+    // Configure MPU to disable access to entire QSPI region, to prevent CPU
+    // speculative execution from accessing this region and modifying QSPI registers.
+    uint32_t irq_state = mpu_config_start();
+    mpu_config_region(MPU_REGION_QSPI1, QSPI_MAP_ADDR, MPU_CONFIG_DISABLE(0x00, MPU_REGION_SIZE_256MB));
+    mpu_config_end(irq_state);
+}
+
+static inline void qspi_mpu_enable_mapped(void) {
+    // Configure MPU to allow access to only the valid part of external SPI flash.
+    // The memory accesses to the mapped QSPI are faster if the MPU is not used
+    // for the memory-mapped region, so 3 MPU regions are used to disable access
+    // to everything except the valid address space, using holes in the bottom
+    // of the regions and nesting them.
+    // At the moment this is hard-coded to 2MiB of QSPI address space.
+    uint32_t irq_state = mpu_config_start();
+    mpu_config_region(MPU_REGION_QSPI1, QSPI_MAP_ADDR, MPU_CONFIG_DISABLE(0x01, MPU_REGION_SIZE_256MB));
+    mpu_config_region(MPU_REGION_QSPI2, QSPI_MAP_ADDR, MPU_CONFIG_DISABLE(0x0f, MPU_REGION_SIZE_32MB));
+    mpu_config_region(MPU_REGION_QSPI3, QSPI_MAP_ADDR, MPU_CONFIG_DISABLE(0x01, MPU_REGION_SIZE_16MB));
+    mpu_config_end(irq_state);
+}
+
 void qspi_init(void) {
+    qspi_mpu_disable_all();
+
     // Configure pins
     mp_hal_pin_config_alt_static_speed(MICROPY_HW_QSPIFLASH_CS, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_NONE, MP_HAL_PIN_SPEED_VERY_HIGH, STATIC_AF_QUADSPI_BK1_NCS);
     mp_hal_pin_config_alt_static_speed(MICROPY_HW_QSPIFLASH_SCK, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_NONE, MP_HAL_PIN_SPEED_VERY_HIGH, STATIC_AF_QUADSPI_CLK);
@@ -61,10 +96,12 @@ void qspi_init(void) {
     // Bring up the QSPI peripheral
 
     __HAL_RCC_QSPI_CLK_ENABLE();
+    __HAL_RCC_QSPI_FORCE_RESET();
+    __HAL_RCC_QSPI_RELEASE_RESET();
 
     QUADSPI->CR =
         (MICROPY_HW_QSPI_PRESCALER - 1) << QUADSPI_CR_PRESCALER_Pos
-        | 3 << QUADSPI_CR_FTHRES_Pos // 4 bytes must be available to read/write
+            | 3 << QUADSPI_CR_FTHRES_Pos // 4 bytes must be available to read/write
         #if defined(QUADSPI_CR_FSEL_Pos)
         | 0 << QUADSPI_CR_FSEL_Pos // FLASH 1 selected
         #endif
@@ -72,34 +109,37 @@ void qspi_init(void) {
         | 0 << QUADSPI_CR_DFM_Pos // dual-flash mode disabled
         #endif
         | MICROPY_HW_QSPI_SAMPLE_SHIFT << QUADSPI_CR_SSHIFT_Pos
-        | MICROPY_HW_QSPI_TIMEOUT_COUNTER << QUADSPI_CR_TCEN_Pos
-        | 1 << QUADSPI_CR_EN_Pos // enable the peripheral
-        ;
+            | MICROPY_HW_QSPI_TIMEOUT_COUNTER << QUADSPI_CR_TCEN_Pos
+            | 1 << QUADSPI_CR_EN_Pos // enable the peripheral
+    ;
 
     QUADSPI->DCR =
         (MICROPY_HW_QSPIFLASH_SIZE_BITS_LOG2 - 3 - 1) << QUADSPI_DCR_FSIZE_Pos
-        | (MICROPY_HW_QSPI_CS_HIGH_CYCLES - 1) << QUADSPI_DCR_CSHT_Pos
-        | 0 << QUADSPI_DCR_CKMODE_Pos // CLK idles at low state
-        ;
+            | (MICROPY_HW_QSPI_CS_HIGH_CYCLES - 1) << QUADSPI_DCR_CSHT_Pos
+            | 0 << QUADSPI_DCR_CKMODE_Pos // CLK idles at low state
+    ;
 }
 
 void qspi_memory_map(void) {
     // Enable memory-mapped mode
 
     QUADSPI->ABR = 0; // disable continuous read mode
+
     QUADSPI->CCR =
         0 << QUADSPI_CCR_DDRM_Pos // DDR mode disabled
-        | 0 << QUADSPI_CCR_SIOO_Pos // send instruction every transaction
-        | 3 << QUADSPI_CCR_FMODE_Pos // memory-mapped mode
-        | 3 << QUADSPI_CCR_DMODE_Pos // data on 4 lines
-        | 4 << QUADSPI_CCR_DCYC_Pos // 4 dummy cycles
-        | 0 << QUADSPI_CCR_ABSIZE_Pos // 8-bit alternate byte
-        | 3 << QUADSPI_CCR_ABMODE_Pos // alternate byte on 4 lines
-        | 2 << QUADSPI_CCR_ADSIZE_Pos // 24-bit address size
-        | 3 << QUADSPI_CCR_ADMODE_Pos // address on 4 lines
-        | 1 << QUADSPI_CCR_IMODE_Pos // instruction on 1 line
-        | 0xeb << QUADSPI_CCR_INSTRUCTION_Pos // quad read opcode
-        ;
+            | 0 << QUADSPI_CCR_SIOO_Pos // send instruction every transaction
+            | 3 << QUADSPI_CCR_FMODE_Pos // memory-mapped mode
+            | 3 << QUADSPI_CCR_DMODE_Pos // data on 4 lines
+            | 4 << QUADSPI_CCR_DCYC_Pos // 4 dummy cycles
+            | 0 << QUADSPI_CCR_ABSIZE_Pos // 8-bit alternate byte
+            | 3 << QUADSPI_CCR_ABMODE_Pos // alternate byte on 4 lines
+            | QSPI_ADSIZE << QUADSPI_CCR_ADSIZE_Pos
+            | 3 << QUADSPI_CCR_ADMODE_Pos // address on 4 lines
+            | 1 << QUADSPI_CCR_IMODE_Pos // instruction on 1 line
+            | QSPI_CMD << QUADSPI_CCR_INSTRUCTION_Pos
+    ;
+
+    qspi_mpu_enable_mapped();
 }
 
 STATIC int qspi_ioctl(void *self_in, uint32_t cmd) {
@@ -108,6 +148,16 @@ STATIC int qspi_ioctl(void *self_in, uint32_t cmd) {
         case MP_QSPI_IOCTL_INIT:
             qspi_init();
             break;
+        case MP_QSPI_IOCTL_BUS_ACQUIRE:
+            // Disable memory-mapped region during bus access
+            qspi_mpu_disable_all();
+            // Abort any ongoing transfer if peripheral is busy
+            if (QUADSPI->SR & QUADSPI_SR_BUSY) {
+                QUADSPI->CR |= QUADSPI_CR_ABORT;
+                while (QUADSPI->CR & QUADSPI_CR_ABORT) {
+                }
+            }
+            break;
         case MP_QSPI_IOCTL_BUS_RELEASE:
             // Switch to memory-map mode when bus is idle
             qspi_memory_map();
@@ -124,32 +174,32 @@ STATIC void qspi_write_cmd_data(void *self_in, uint8_t cmd, size_t len, uint32_t
     if (len == 0) {
         QUADSPI->CCR =
             0 << QUADSPI_CCR_DDRM_Pos // DDR mode disabled
-            | 0 << QUADSPI_CCR_SIOO_Pos // send instruction every transaction
-            | 0 << QUADSPI_CCR_FMODE_Pos // indirect write mode
-            | 0 << QUADSPI_CCR_DMODE_Pos // no data
-            | 0 << QUADSPI_CCR_DCYC_Pos // 0 dummy cycles
-            | 0 << QUADSPI_CCR_ABMODE_Pos // no alternate byte
-            | 0 << QUADSPI_CCR_ADMODE_Pos // no address
-            | 1 << QUADSPI_CCR_IMODE_Pos // instruction on 1 line
-            | cmd << QUADSPI_CCR_INSTRUCTION_Pos // write opcode
-            ;
+                | 0 << QUADSPI_CCR_SIOO_Pos // send instruction every transaction
+                | 0 << QUADSPI_CCR_FMODE_Pos // indirect write mode
+                | 0 << QUADSPI_CCR_DMODE_Pos // no data
+                | 0 << QUADSPI_CCR_DCYC_Pos // 0 dummy cycles
+                | 0 << QUADSPI_CCR_ABMODE_Pos // no alternate byte
+                | 0 << QUADSPI_CCR_ADMODE_Pos // no address
+                | 1 << QUADSPI_CCR_IMODE_Pos // instruction on 1 line
+                | cmd << QUADSPI_CCR_INSTRUCTION_Pos // write opcode
+        ;
     } else {
         QUADSPI->DLR = len - 1;
 
         QUADSPI->CCR =
             0 << QUADSPI_CCR_DDRM_Pos // DDR mode disabled
-            | 0 << QUADSPI_CCR_SIOO_Pos // send instruction every transaction
-            | 0 << QUADSPI_CCR_FMODE_Pos // indirect write mode
-            | 1 << QUADSPI_CCR_DMODE_Pos // data on 1 line
-            | 0 << QUADSPI_CCR_DCYC_Pos // 0 dummy cycles
-            | 0 << QUADSPI_CCR_ABMODE_Pos // no alternate byte
-            | 0 << QUADSPI_CCR_ADMODE_Pos // no address
-            | 1 << QUADSPI_CCR_IMODE_Pos // instruction on 1 line
-            | cmd << QUADSPI_CCR_INSTRUCTION_Pos // write opcode
-            ;
+                | 0 << QUADSPI_CCR_SIOO_Pos // send instruction every transaction
+                | 0 << QUADSPI_CCR_FMODE_Pos // indirect write mode
+                | 1 << QUADSPI_CCR_DMODE_Pos // data on 1 line
+                | 0 << QUADSPI_CCR_DCYC_Pos // 0 dummy cycles
+                | 0 << QUADSPI_CCR_ABMODE_Pos // no alternate byte
+                | 0 << QUADSPI_CCR_ADMODE_Pos // no address
+                | 1 << QUADSPI_CCR_IMODE_Pos // instruction on 1 line
+                | cmd << QUADSPI_CCR_INSTRUCTION_Pos // write opcode
+        ;
 
         // This assumes len==2
-        *(uint16_t*)&QUADSPI->DR = data;
+        *(uint16_t *)&QUADSPI->DR = data;
     }
 
     // Wait for write to finish
@@ -162,21 +212,23 @@ STATIC void qspi_write_cmd_data(void *self_in, uint8_t cmd, size_t len, uint32_t
 STATIC void qspi_write_cmd_addr_data(void *self_in, uint8_t cmd, uint32_t addr, size_t len, const uint8_t *src) {
     (void)self_in;
 
+    uint8_t adsize = MP_SPI_ADDR_IS_32B(addr) ? 3 : 2;
+
     QUADSPI->FCR = QUADSPI_FCR_CTCF; // clear TC flag
 
     if (len == 0) {
         QUADSPI->CCR =
             0 << QUADSPI_CCR_DDRM_Pos // DDR mode disabled
-            | 0 << QUADSPI_CCR_SIOO_Pos // send instruction every transaction
-            | 0 << QUADSPI_CCR_FMODE_Pos // indirect write mode
-            | 0 << QUADSPI_CCR_DMODE_Pos // no data
-            | 0 << QUADSPI_CCR_DCYC_Pos // 0 dummy cycles
-            | 0 << QUADSPI_CCR_ABMODE_Pos // no alternate byte
-            | 2 << QUADSPI_CCR_ADSIZE_Pos // 24-bit address size
-            | 1 << QUADSPI_CCR_ADMODE_Pos // address on 1 line
-            | 1 << QUADSPI_CCR_IMODE_Pos // instruction on 1 line
-            | cmd << QUADSPI_CCR_INSTRUCTION_Pos // write opcode
-            ;
+                | 0 << QUADSPI_CCR_SIOO_Pos // send instruction every transaction
+                | 0 << QUADSPI_CCR_FMODE_Pos // indirect write mode
+                | 0 << QUADSPI_CCR_DMODE_Pos // no data
+                | 0 << QUADSPI_CCR_DCYC_Pos // 0 dummy cycles
+                | 0 << QUADSPI_CCR_ABMODE_Pos // no alternate byte
+                | adsize << QUADSPI_CCR_ADSIZE_Pos // 32/24-bit address size
+                | 1 << QUADSPI_CCR_ADMODE_Pos // address on 1 line
+                | 1 << QUADSPI_CCR_IMODE_Pos // instruction on 1 line
+                | cmd << QUADSPI_CCR_INSTRUCTION_Pos // write opcode
+        ;
 
         QUADSPI->AR = addr;
     } else {
@@ -184,16 +236,16 @@ STATIC void qspi_write_cmd_addr_data(void *self_in, uint8_t cmd, uint32_t addr,
 
         QUADSPI->CCR =
             0 << QUADSPI_CCR_DDRM_Pos // DDR mode disabled
-            | 0 << QUADSPI_CCR_SIOO_Pos // send instruction every transaction
-            | 0 << QUADSPI_CCR_FMODE_Pos // indirect write mode
-            | 1 << QUADSPI_CCR_DMODE_Pos // data on 1 line
-            | 0 << QUADSPI_CCR_DCYC_Pos // 0 dummy cycles
-            | 0 << QUADSPI_CCR_ABMODE_Pos // no alternate byte
-            | 2 << QUADSPI_CCR_ADSIZE_Pos // 24-bit address size
-            | 1 << QUADSPI_CCR_ADMODE_Pos // address on 1 line
-            | 1 << QUADSPI_CCR_IMODE_Pos // instruction on 1 line
-            | cmd << QUADSPI_CCR_INSTRUCTION_Pos // write opcode
-            ;
+                | 0 << QUADSPI_CCR_SIOO_Pos // send instruction every transaction
+                | 0 << QUADSPI_CCR_FMODE_Pos // indirect write mode
+                | 1 << QUADSPI_CCR_DMODE_Pos // data on 1 line
+                | 0 << QUADSPI_CCR_DCYC_Pos // 0 dummy cycles
+                | 0 << QUADSPI_CCR_ABMODE_Pos // no alternate byte
+                | adsize << QUADSPI_CCR_ADSIZE_Pos // 32/24-bit address size
+                | 1 << QUADSPI_CCR_ADMODE_Pos // address on 1 line
+                | 1 << QUADSPI_CCR_IMODE_Pos // instruction on 1 line
+                | cmd << QUADSPI_CCR_INSTRUCTION_Pos // write opcode
+        ;
 
         QUADSPI->AR = addr;
 
@@ -201,7 +253,7 @@ STATIC void qspi_write_cmd_addr_data(void *self_in, uint8_t cmd, uint32_t addr,
         while (len) {
             while (!(QUADSPI->SR & QUADSPI_SR_FTF)) {
             }
-            *(volatile uint8_t*)&QUADSPI->DR = *src++;
+            *(volatile uint8_t *)&QUADSPI->DR = *src++;
             --len;
         }
     }
@@ -222,15 +274,15 @@ STATIC uint32_t qspi_read_cmd(void *self_in, uint8_t cmd, size_t len) {
 
     QUADSPI->CCR =
         0 << QUADSPI_CCR_DDRM_Pos // DDR mode disabled
-        | 0 << QUADSPI_CCR_SIOO_Pos // send instruction every transaction
-        | 1 << QUADSPI_CCR_FMODE_Pos // indirect read mode
-        | 1 << QUADSPI_CCR_DMODE_Pos // data on 1 line
-        | 0 << QUADSPI_CCR_DCYC_Pos // 0 dummy cycles
-        | 0 << QUADSPI_CCR_ABMODE_Pos // no alternate byte
-        | 0 << QUADSPI_CCR_ADMODE_Pos // no address
-        | 1 << QUADSPI_CCR_IMODE_Pos // instruction on 1 line
-        | cmd << QUADSPI_CCR_INSTRUCTION_Pos // read opcode
-        ;
+            | 0 << QUADSPI_CCR_SIOO_Pos // send instruction every transaction
+            | 1 << QUADSPI_CCR_FMODE_Pos // indirect read mode
+            | 1 << QUADSPI_CCR_DMODE_Pos // data on 1 line
+            | 0 << QUADSPI_CCR_DCYC_Pos // 0 dummy cycles
+            | 0 << QUADSPI_CCR_ABMODE_Pos // no alternate byte
+            | 0 << QUADSPI_CCR_ADMODE_Pos // no address
+            | 1 << QUADSPI_CCR_IMODE_Pos // instruction on 1 line
+            | cmd << QUADSPI_CCR_INSTRUCTION_Pos // read opcode
+    ;
 
     // Wait for read to finish
     while (!(QUADSPI->SR & QUADSPI_SR_TCF)) {
@@ -244,23 +296,26 @@ STATIC uint32_t qspi_read_cmd(void *self_in, uint8_t cmd, size_t len) {
 
 STATIC void qspi_read_cmd_qaddr_qdata(void *self_in, uint8_t cmd, uint32_t addr, size_t len, uint8_t *dest) {
     (void)self_in;
+
+    uint8_t adsize = MP_SPI_ADDR_IS_32B(addr) ? 3 : 2;
+
     QUADSPI->FCR = QUADSPI_FCR_CTCF; // clear TC flag
 
     QUADSPI->DLR = len - 1; // number of bytes to read
 
     QUADSPI->CCR =
         0 << QUADSPI_CCR_DDRM_Pos // DDR mode disabled
-        | 0 << QUADSPI_CCR_SIOO_Pos // send instruction every transaction
-        | 1 << QUADSPI_CCR_FMODE_Pos // indirect read mode
-        | 3 << QUADSPI_CCR_DMODE_Pos // data on 4 lines
-        | 4 << QUADSPI_CCR_DCYC_Pos // 4 dummy cycles
-        | 0 << QUADSPI_CCR_ABSIZE_Pos // 8-bit alternate byte
-        | 3 << QUADSPI_CCR_ABMODE_Pos // alternate byte on 4 lines
-        | 2 << QUADSPI_CCR_ADSIZE_Pos // 24-bit address size
-        | 3 << QUADSPI_CCR_ADMODE_Pos // address on 4 lines
-        | 1 << QUADSPI_CCR_IMODE_Pos // instruction on 1 line
-        | cmd << QUADSPI_CCR_INSTRUCTION_Pos // quad read opcode
-        ;
+            | 0 << QUADSPI_CCR_SIOO_Pos // send instruction every transaction
+            | 1 << QUADSPI_CCR_FMODE_Pos // indirect read mode
+            | 3 << QUADSPI_CCR_DMODE_Pos // data on 4 lines
+            | 4 << QUADSPI_CCR_DCYC_Pos // 4 dummy cycles
+            | 0 << QUADSPI_CCR_ABSIZE_Pos // 8-bit alternate byte
+            | 3 << QUADSPI_CCR_ABMODE_Pos // alternate byte on 4 lines
+            | adsize << QUADSPI_CCR_ADSIZE_Pos // 32 or 24-bit address size
+            | 3 << QUADSPI_CCR_ADMODE_Pos // address on 4 lines
+            | 1 << QUADSPI_CCR_IMODE_Pos // instruction on 1 line
+            | cmd << QUADSPI_CCR_INSTRUCTION_Pos // quad read opcode
+    ;
 
     QUADSPI->ABR = 0; // alternate byte: disable continuous read mode
     QUADSPI->AR = addr; // addres to read from
@@ -270,7 +325,7 @@ STATIC void qspi_read_cmd_qaddr_qdata(void *self_in, uint8_t cmd, uint32_t addr,
         while (len >= 4) {
             while (!(QUADSPI->SR & QUADSPI_SR_FTF)) {
             }
-            *(uint32_t*)dest = QUADSPI->DR;
+            *(uint32_t *)dest = QUADSPI->DR;
             dest += 4;
             len -= 4;
         }
@@ -280,7 +335,7 @@ STATIC void qspi_read_cmd_qaddr_qdata(void *self_in, uint8_t cmd, uint32_t addr,
     while (len) {
         while (!((QUADSPI->SR >> QUADSPI_SR_FLEVEL_Pos) & 0x3f)) {
         }
-        *dest++ = *(volatile uint8_t*)&QUADSPI->DR;
+        *dest++ = *(volatile uint8_t *)&QUADSPI->DR;
         --len;
     }
 
diff --git a/ports/stm32/qstrdefsport.h b/ports/stm32/qstrdefsport.h
index 31220c5a42b23..bc07f2752aa85 100644
--- a/ports/stm32/qstrdefsport.h
+++ b/ports/stm32/qstrdefsport.h
@@ -25,23 +25,20 @@
  */
 
 // qstrs specific to this port
+// *FORMAT-OFF*
 
-Q(boot.py)
-Q(main.py)
 // Entries for sys.path
 Q(/flash)
 Q(/flash/lib)
 Q(/sd)
 Q(/sd/lib)
+
+// For uos.sep
+Q(/)
+
+#if MICROPY_HW_ENABLE_USB
 // for usb modes
 Q(MSC+HID)
 Q(VCP+MSC)
 Q(VCP+HID)
-Q(CDC+MSC)
-Q(CDC+HID)
-Q(/)
-
-
-// The following qstrings not referenced from anywhere in the sources
-Q(CDC)
-Q(flash)
+#endif
diff --git a/ports/stm32/rfcore.c b/ports/stm32/rfcore.c
new file mode 100644
index 0000000000000..602ef974b262b
--- /dev/null
+++ b/ports/stm32/rfcore.c
@@ -0,0 +1,423 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "py/mperrno.h"
+#include "py/mphal.h"
+#include "rtc.h"
+#include "rfcore.h"
+
+#if defined(STM32WB)
+
+// Define to 1 to print traces of HCI packets
+#define HCI_TRACE (0)
+
+#define IPCC_CH_BLE         (0x01) // BLE HCI command and response
+#define IPCC_CH_SYS         (0x02) // system HCI command and response
+#define IPCC_CH_MM          (0x08) // release buffer
+#define IPCC_CH_HCI_ACL     (0x20) // HCI ACL outgoing data
+
+#define OGF_VENDOR          (0x3f)
+#define OCF_WRITE_CONFIG    (0x0c)
+#define OCF_SET_TX_POWER    (0x0f)
+#define OCF_BLE_INIT        (0x66)
+
+#define HCI_OPCODE(ogf, ocf) ((ogf) << 10 | (ocf))
+
+typedef struct _tl_list_node_t {
+    volatile struct _tl_list_node_t *next;
+    volatile struct _tl_list_node_t *prev;
+    uint8_t body[0];
+} tl_list_node_t;
+
+typedef struct _parse_hci_info_t {
+    int (*cb_fun)(void *, const uint8_t *, size_t);
+    void *cb_env;
+    bool was_hci_reset_evt;
+} parse_hci_info_t;
+
+static volatile uint32_t ipcc_mem_dev_info_tab[8];
+static volatile uint32_t ipcc_mem_ble_tab[4];
+static volatile uint32_t ipcc_mem_sys_tab[2];
+static volatile uint32_t ipcc_mem_memmgr_tab[7];
+
+static volatile uint32_t ipcc_mem_sys_cmd_buf[272 / 4];
+static volatile tl_list_node_t ipcc_mem_sys_queue;
+
+static volatile tl_list_node_t ipcc_mem_memmgr_free_buf_queue;
+static volatile uint32_t ipcc_mem_memmgr_ble_spare_evt_buf[272 / 4];
+static volatile uint32_t ipcc_mem_memmgr_sys_spare_evt_buf[272 / 4];
+static volatile uint32_t ipcc_mem_memmgr_evt_pool[6 * 272 / 4];
+
+static volatile uint32_t ipcc_mem_ble_cmd_buf[272 / 4];
+static volatile uint32_t ipcc_mem_ble_cs_buf[272 / 4];
+static volatile tl_list_node_t ipcc_mem_ble_evt_queue;
+static volatile uint32_t ipcc_mem_ble_hci_acl_data_buf[272 / 4];
+
+/******************************************************************************/
+// Transport layer linked list
+
+STATIC void tl_list_init(volatile tl_list_node_t *n) {
+    n->next = n;
+    n->prev = n;
+}
+
+STATIC volatile tl_list_node_t *tl_list_unlink(volatile tl_list_node_t *n) {
+    volatile tl_list_node_t *next = n->next;
+    volatile tl_list_node_t *prev = n->prev;
+    prev->next = next;
+    next->prev = prev;
+    return next;
+}
+
+STATIC void tl_list_append(volatile tl_list_node_t *head, volatile tl_list_node_t *n) {
+    n->next = head;
+    n->prev = head->prev;
+    head->prev->next = n;
+    head->prev = n;
+}
+
+/******************************************************************************/
+// IPCC interface
+
+STATIC uint32_t get_ipccdba(void) {
+    return *(uint32_t *)(OPTION_BYTE_BASE + 0x68) & 0x3fff;
+}
+
+STATIC volatile void **get_buffer_table(void) {
+    return (volatile void **)(SRAM2A_BASE + get_ipccdba());
+}
+
+void ipcc_init(uint32_t irq_pri) {
+    // Setup buffer table pointers
+    volatile void **tab = get_buffer_table();
+    tab[0] = &ipcc_mem_dev_info_tab[0];
+    tab[1] = &ipcc_mem_ble_tab[0];
+    tab[3] = &ipcc_mem_sys_tab[0];
+    tab[4] = &ipcc_mem_memmgr_tab[0];
+
+    // Start IPCC peripheral
+    __HAL_RCC_IPCC_CLK_ENABLE();
+
+    // Enable wanted IRQs
+    IPCC->C1CR = 0; // IPCC_C1CR_RXOIE;
+    IPCC->C1MR = 0xffffffff;
+    NVIC_SetPriority(IPCC_C1_RX_IRQn, irq_pri);
+    HAL_NVIC_EnableIRQ(IPCC_C1_RX_IRQn);
+
+    // Device info table will be populated by FUS/WS
+
+    // Populate system table
+    tl_list_init(&ipcc_mem_sys_queue);
+    ipcc_mem_sys_tab[0] = (uint32_t)&ipcc_mem_sys_cmd_buf[0];
+    ipcc_mem_sys_tab[1] = (uint32_t)&ipcc_mem_sys_queue;
+
+    // Populate memory manager table
+    tl_list_init(&ipcc_mem_memmgr_free_buf_queue);
+    ipcc_mem_memmgr_tab[0] = (uint32_t)&ipcc_mem_memmgr_ble_spare_evt_buf[0];
+    ipcc_mem_memmgr_tab[1] = (uint32_t)&ipcc_mem_memmgr_sys_spare_evt_buf[0];
+    ipcc_mem_memmgr_tab[2] = (uint32_t)&ipcc_mem_memmgr_evt_pool[0];
+    ipcc_mem_memmgr_tab[3] = sizeof(ipcc_mem_memmgr_evt_pool);
+    ipcc_mem_memmgr_tab[4] = (uint32_t)&ipcc_mem_memmgr_free_buf_queue;
+    ipcc_mem_memmgr_tab[5] = 0;
+    ipcc_mem_memmgr_tab[6] = 0;
+
+    // Populate BLE table
+    tl_list_init(&ipcc_mem_ble_evt_queue);
+    ipcc_mem_ble_tab[0] = (uint32_t)&ipcc_mem_ble_cmd_buf[0];
+    ipcc_mem_ble_tab[1] = (uint32_t)&ipcc_mem_ble_cs_buf[0];
+    ipcc_mem_ble_tab[2] = (uint32_t)&ipcc_mem_ble_evt_queue;
+    ipcc_mem_ble_tab[3] = (uint32_t)&ipcc_mem_ble_hci_acl_data_buf[0];
+}
+
+STATIC int ipcc_wait_ack(unsigned int ch, uint32_t timeout_ms) {
+    uint32_t t0 = mp_hal_ticks_ms();
+    while (IPCC->C1TOC2SR & ch) {
+        if (mp_hal_ticks_ms() - t0 > timeout_ms) {
+            printf("ipcc_wait_ack: timeout\n");
+            return -MP_ETIMEDOUT;
+        }
+    }
+    // C2 cleared IPCC flag
+    return 0;
+}
+
+STATIC int ipcc_wait_msg(unsigned int ch, uint32_t timeout_ms) {
+    uint32_t t0 = mp_hal_ticks_ms();
+    while (!(IPCC->C2TOC1SR & ch)) {
+        if (mp_hal_ticks_ms() - t0 > timeout_ms) {
+            printf("ipcc_wait_msg: timeout\n");
+            return -MP_ETIMEDOUT;
+        }
+    }
+    // C2 set IPCC flag
+    return 0;
+}
+
+/******************************************************************************/
+// Transport layer HCI interface
+
+STATIC void tl_parse_hci_msg(const uint8_t *buf, parse_hci_info_t *parse) {
+    const char *kind;
+    size_t len = 3 + buf[2];
+    switch (buf[0]) {
+        case 0x02: {
+            // Standard BT HCI ACL packet
+            kind = "HCI_ACL";
+            if (parse != NULL) {
+                parse->cb_fun(parse->cb_env, buf, len);
+            }
+            break;
+        }
+        case 0x04: {
+            // Standard BT HCI event packet
+            kind = "HCI_EVT";
+            if (parse != NULL) {
+                bool fix = false;
+                if (buf[1] == 0x0e && len == 7 && buf[3] == 0x01 && buf[4] == 0x63 && buf[5] == 0x0c && buf[6] == 0x01) {
+                    len -= 1;
+                    fix = true;
+                }
+                parse->cb_fun(parse->cb_env, buf, len);
+                if (fix) {
+                    len += 1;
+                    uint8_t data = 0x00; // success
+                    parse->cb_fun(parse->cb_env, &data, 1);
+                }
+                // Check for successful HCI_Reset event
+                parse->was_hci_reset_evt = buf[1] == 0x0e && buf[2] == 0x04 && buf[3] == 0x01
+                    && buf[4] == 0x03 && buf[5] == 0x0c && buf[6] == 0x00;
+            }
+            break;
+        }
+        case 0x11: {
+            // Response packet
+            // assert(buf[1] == 0x0e);
+            kind = "VEND_RESP";
+            // uint16_t cmd = buf[4] | buf[5] << 8;
+            // uint8_t status = buf[6];
+            break;
+        }
+        case 0x12: {
+            // Event packet
+            // assert(buf[1] == 0xff);
+            kind = "VEND_EVT";
+            // uint16_t evt = buf[3] | buf[4] << 8;
+            break;
+        }
+        default:
+            kind = "HCI_UNKNOWN";
+            break;
+    }
+
+    #if HCI_TRACE
+    printf("[% 8d] %s(%02x", mp_hal_ticks_ms(), kind, buf[0]);
+    for (int i = 1; i < len; ++i) {
+        printf(":%02x", buf[i]);
+    }
+    printf(")\n");
+    #else
+    (void)kind;
+    #endif
+}
+
+STATIC void tl_check_msg(volatile tl_list_node_t *head, unsigned int ch, parse_hci_info_t *parse) {
+    if (IPCC->C2TOC1SR & ch) {
+        // Message available on CH2
+        volatile tl_list_node_t *cur = head->next;
+        bool free = false;
+        while (cur != head) {
+            tl_parse_hci_msg((uint8_t *)cur->body, parse);
+            volatile tl_list_node_t *next = tl_list_unlink(cur);
+            if ((void *)&ipcc_mem_memmgr_evt_pool[0] <= (void *)cur
+                && (void *)cur < (void *)&ipcc_mem_memmgr_evt_pool[MP_ARRAY_SIZE(ipcc_mem_memmgr_evt_pool)]) {
+                // Place memory back in free pool
+                tl_list_append(&ipcc_mem_memmgr_free_buf_queue, cur);
+                free = true;
+            }
+            cur = next;
+        }
+        if (free) {
+            // Notify change in free pool
+            IPCC->C1SCR = IPCC_CH_MM << 16;
+        }
+        // Clear receive channel
+        IPCC->C1SCR = ch;
+    }
+}
+
+STATIC void tl_hci_cmd(uint8_t *cmd, unsigned int ch, uint8_t hdr, uint16_t opcode, size_t len, const uint8_t *buf) {
+    tl_list_node_t *n = (tl_list_node_t *)cmd;
+    n->next = n;
+    n->prev = n;
+    cmd[8] = hdr;
+    cmd[9] = opcode;
+    cmd[10] = opcode >> 8;
+    cmd[11] = len;
+    memcpy(&cmd[12], buf, len);
+    // IPCC indicate
+    IPCC->C1SCR = ch << 16;
+}
+
+STATIC void tl_sys_wait_resp(const uint8_t *buf, unsigned int ch) {
+    if (ipcc_wait_ack(ch, 250) == 0) {
+        tl_parse_hci_msg(buf, NULL);
+    }
+}
+
+STATIC void tl_sys_hci_cmd_resp(uint16_t opcode, size_t len, const uint8_t *buf) {
+    tl_hci_cmd((uint8_t *)&ipcc_mem_sys_cmd_buf, IPCC_CH_SYS, 0x10, opcode, len, buf);
+    tl_sys_wait_resp((uint8_t *)&ipcc_mem_sys_cmd_buf, IPCC_CH_SYS);
+}
+
+STATIC void tl_ble_hci_cmd_resp(uint16_t opcode, size_t len, const uint8_t *buf) {
+    tl_hci_cmd((uint8_t *)&ipcc_mem_ble_cmd_buf[0], IPCC_CH_BLE, 0x01, opcode, len, buf);
+    ipcc_wait_msg(IPCC_CH_BLE, 250);
+    tl_check_msg(&ipcc_mem_ble_evt_queue, IPCC_CH_BLE, NULL);
+}
+
+/******************************************************************************/
+// RF core interface
+
+void rfcore_init(void) {
+    // Ensure LSE is running
+    rtc_init_finalise();
+
+    // Select LSE as RF wakeup source
+    RCC->CSR = (RCC->CSR & ~RCC_CSR_RFWKPSEL) | 1 << RCC_CSR_RFWKPSEL_Pos;
+
+    // Initialise IPCC and shared memory structures
+    ipcc_init(IRQ_PRI_SDIO);
+
+    // Boot the second core
+    __SEV();
+    __WFE();
+    PWR->CR4 |= PWR_CR4_C2BOOT;
+}
+
+static const struct {
+    uint8_t *pBleBufferAddress;     // unused
+    uint32_t BleBufferSize;         // unused
+    uint16_t NumAttrRecord;
+    uint16_t NumAttrServ;
+    uint16_t AttrValueArrSize;
+    uint8_t NumOfLinks;
+    uint8_t ExtendedPacketLengthEnable;
+    uint8_t PrWriteListSize;
+    uint8_t MblockCount;
+    uint16_t AttMtu;
+    uint16_t SlaveSca;
+    uint8_t MasterSca;
+    uint8_t LsSource;               // 0=LSE 1=internal RO
+    uint32_t MaxConnEventLength;
+    uint16_t HsStartupTime;
+    uint8_t ViterbiEnable;
+    uint8_t LlOnly;                 // 0=LL+Host, 1=LL only
+    uint8_t HwVersion;
+} ble_init_params = {
+    0,
+    0,
+    0, // NumAttrRecord
+    0, // NumAttrServ
+    0, // AttrValueArrSize
+    1, // NumOfLinks
+    1, // ExtendedPacketLengthEnable
+    0, // PrWriteListSize
+    0x79, // MblockCount
+    0, // AttMtu
+    0, // SlaveSca
+    0, // MasterSca
+    1, // LsSource
+    0xffffffff, // MaxConnEventLength
+    0x148, // HsStartupTime
+    0, // ViterbiEnable
+    1, // LlOnly
+    0, // HwVersion
+};
+
+void rfcore_ble_init(void) {
+    // Clear any outstanding messages from ipcc_init
+    tl_check_msg(&ipcc_mem_sys_queue, IPCC_CH_SYS, NULL);
+    tl_check_msg(&ipcc_mem_ble_evt_queue, IPCC_CH_BLE, NULL);
+
+    // Configure and reset the BLE controller
+    tl_sys_hci_cmd_resp(HCI_OPCODE(OGF_VENDOR, OCF_BLE_INIT), sizeof(ble_init_params), (const uint8_t *)&ble_init_params);
+    tl_ble_hci_cmd_resp(HCI_OPCODE(0x03, 0x0003), 0, NULL);
+}
+
+void rfcore_ble_hci_cmd(size_t len, const uint8_t *src) {
+    #if HCI_TRACE
+    printf("[% 8d] HCI_CMD(%02x", mp_hal_ticks_ms(), src[0]);
+    for (int i = 1; i < len; ++i) {
+        printf(":%02x", src[i]);
+    }
+    printf(")\n");
+    #endif
+
+    tl_list_node_t *n;
+    uint32_t ch;
+    if (src[0] == 0x01) {
+        n = (tl_list_node_t *)&ipcc_mem_ble_cmd_buf[0];
+        ch = IPCC_CH_BLE;
+    } else if (src[0] == 0x02) {
+        n = (tl_list_node_t *)&ipcc_mem_ble_hci_acl_data_buf[0];
+        ch = IPCC_CH_HCI_ACL;
+    } else {
+        printf("** UNEXPECTED HCI HDR: 0x%02x **\n", src[0]);
+        return;
+    }
+
+    n->next = n;
+    n->prev = n;
+    memcpy(n->body, src, len);
+
+    // IPCC indicate
+    IPCC->C1SCR = ch << 16;
+}
+
+void rfcore_ble_check_msg(int (*cb)(void *, const uint8_t *, size_t), void *env) {
+    parse_hci_info_t parse = { cb, env, false };
+    tl_check_msg(&ipcc_mem_ble_evt_queue, IPCC_CH_BLE, &parse);
+
+    // Intercept HCI_Reset events and reconfigure the controller following the reset
+    if (parse.was_hci_reset_evt) {
+        uint8_t buf[8];
+        buf[0] = 0; // config offset
+        buf[1] = 6; // config length
+        mp_hal_get_mac(MP_HAL_MAC_BDADDR, &buf[2]);
+        #define SWAP_UINT8(a, b) { uint8_t temp = a; a = b; b = temp; \
+}
+        SWAP_UINT8(buf[2], buf[7]);
+        SWAP_UINT8(buf[3], buf[6]);
+        SWAP_UINT8(buf[4], buf[5]);
+        tl_ble_hci_cmd_resp(HCI_OPCODE(OGF_VENDOR, OCF_WRITE_CONFIG), 8, buf); // set BDADDR
+        tl_ble_hci_cmd_resp(HCI_OPCODE(OGF_VENDOR, OCF_SET_TX_POWER), 2, (const uint8_t *)"\x00\x06"); // 0 dBm
+    }
+}
+
+#endif // defined(STM32WB)
diff --git a/ports/stm32/rfcore.h b/ports/stm32/rfcore.h
new file mode 100644
index 0000000000000..138c438f12eae
--- /dev/null
+++ b/ports/stm32/rfcore.h
@@ -0,0 +1,37 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_STM32_RFCORE_H
+#define MICROPY_INCLUDED_STM32_RFCORE_H
+
+#include <stdint.h>
+
+void rfcore_init(void);
+
+void rfcore_ble_init(void);
+void rfcore_ble_hci_cmd(size_t len, const uint8_t *src);
+void rfcore_ble_check_msg(int (*cb)(void *, const uint8_t *, size_t), void *env);
+
+#endif // MICROPY_INCLUDED_STM32_RFCORE_H
diff --git a/ports/stm32/rtc.c b/ports/stm32/rtc.c
index 250c34bcf5209..de26352004771 100644
--- a/ports/stm32/rtc.c
+++ b/ports/stm32/rtc.c
@@ -31,6 +31,14 @@
 #include "rtc.h"
 #include "irq.h"
 
+#if defined(STM32WB)
+#define RCC_CSR_LSION RCC_CSR_LSI1ON
+#define RCC_FLAG_LSIRDY RCC_FLAG_LSI1RDY
+#define RCC_OSCILLATORTYPE_LSI RCC_OSCILLATORTYPE_LSI1
+#define __HAL_RCC_LSI_ENABLE __HAL_RCC_LSI1_ENABLE
+#define __HAL_RCC_LSI_DISABLE __HAL_RCC_LSI1_DISABLE
+#endif
+
 /// \moduleref pyb
 /// \class RTC - real time clock
 ///
@@ -52,7 +60,7 @@ static mp_uint_t rtc_info;
 // Note: LSI is around (32KHz), these dividers should work either way
 // ck_spre(1Hz) = RTCCLK(LSE) /(uwAsynchPrediv + 1)*(uwSynchPrediv + 1)
 // modify RTC_ASYNCH_PREDIV & RTC_SYNCH_PREDIV in board/<BN>/mpconfigport.h to change sub-second ticks
-// default is 3906.25 µs, min is ~30.52 µs (will increas Ivbat by ~500nA)
+// default is 3906.25 us, min is ~30.52 us (will increase Ivbat by ~500nA)
 #ifndef RTC_ASYNCH_PREDIV
 #define RTC_ASYNCH_PREDIV (0x7f)
 #endif
@@ -61,11 +69,11 @@ static mp_uint_t rtc_info;
 #endif
 
 STATIC HAL_StatusTypeDef PYB_RTC_Init(RTC_HandleTypeDef *hrtc);
-STATIC void PYB_RTC_MspInit_Kick(RTC_HandleTypeDef *hrtc, bool rtc_use_lse);
+STATIC void PYB_RTC_MspInit_Kick(RTC_HandleTypeDef *hrtc, bool rtc_use_lse, bool rtc_use_byp);
 STATIC HAL_StatusTypeDef PYB_RTC_MspInit_Finalise(RTC_HandleTypeDef *hrtc);
 STATIC void RTC_CalendarConfig(void);
 
-#if defined(MICROPY_HW_RTC_USE_LSE) && MICROPY_HW_RTC_USE_LSE
+#if MICROPY_HW_RTC_USE_LSE || MICROPY_HW_RTC_USE_BYPASS
 STATIC bool rtc_use_lse = true;
 #else
 STATIC bool rtc_use_lse = false;
@@ -73,35 +81,16 @@ STATIC bool rtc_use_lse = false;
 STATIC uint32_t rtc_startup_tick;
 STATIC bool rtc_need_init_finalise = false;
 
-// check if LSE exists
-// not well tested, should probably be removed
-STATIC bool lse_magic(void) {
-#if 0
-    uint32_t mode_in = GPIOC->MODER & 0x3fffffff;
-    uint32_t mode_out = mode_in | 0x40000000;
-    GPIOC->MODER = mode_out;
-    GPIOC->OTYPER &= 0x7fff;
-    GPIOC->BSRRH = 0x8000;
-    GPIOC->OSPEEDR &= 0x3fffffff;
-    GPIOC->PUPDR &= 0x3fffffff;
-    int i = 0xff0;
-    __IO int d = 0;
-    uint32_t tc = 0;
-    __IO uint32_t j;
-    while (i) {
-        GPIOC->MODER = mode_out;
-        GPIOC->MODER = mode_in;
-        for (j = 0; j < d; j++) ;
-        i--;
-        if ((GPIOC->IDR & 0x8000) == 0) {
-            tc++;
-        }
-    }
-    return (tc < 0xff0)?true:false;
-#else
-    return false;
+#if defined(STM32L0)
+#define BDCR CSR
+#define RCC_BDCR_RTCEN RCC_CSR_RTCEN
+#define RCC_BDCR_RTCSEL RCC_CSR_RTCSEL
+#define RCC_BDCR_RTCSEL_0 RCC_CSR_RTCSEL_0
+#define RCC_BDCR_RTCSEL_1 RCC_CSR_RTCSEL_1
+#define RCC_BDCR_LSEON RCC_CSR_LSEON
+#define RCC_BDCR_LSERDY RCC_CSR_LSERDY
+#define RCC_BDCR_LSEBYP RCC_CSR_LSEBYP
 #endif
-}
 
 void rtc_init_start(bool force_init) {
     RTCHandle.Instance = RTC;
@@ -136,7 +125,7 @@ void rtc_init_start(bool force_init) {
             rtc_info |= 0x40000 | (RCC->BDCR & 7) | (RCC->CSR & 3) << 8;
             return;
         } else if ((bdcr & (RCC_BDCR_RTCEN | RCC_BDCR_RTCSEL))
-            == (RCC_BDCR_RTCEN | RCC_BDCR_RTCSEL_1)) {
+                   == (RCC_BDCR_RTCEN | RCC_BDCR_RTCSEL_1)) {
             // LSI configured as the RTC clock source --> no need to (re-)init RTC
             // remove Backup Domain write protection
             HAL_PWR_EnableBkUpAccess();
@@ -152,14 +141,7 @@ void rtc_init_start(bool force_init) {
 
     rtc_startup_tick = HAL_GetTick();
     rtc_info = 0x3f000000 | (rtc_startup_tick & 0xffffff);
-    if (rtc_use_lse) {
-        if (lse_magic()) {
-            // don't even try LSE
-            rtc_use_lse = false;
-            rtc_info &= ~0x01000000;
-        }
-    }
-    PYB_RTC_MspInit_Kick(&RTCHandle, rtc_use_lse);
+    PYB_RTC_MspInit_Kick(&RTCHandle, rtc_use_lse, MICROPY_HW_RTC_USE_BYPASS);
 }
 
 void rtc_init_finalise() {
@@ -167,26 +149,34 @@ void rtc_init_finalise() {
         return;
     }
 
-    rtc_info = 0x20000000;
-    if (PYB_RTC_Init(&RTCHandle) != HAL_OK) {
+    rtc_info = 0;
+    while (PYB_RTC_Init(&RTCHandle) != HAL_OK) {
         if (rtc_use_lse) {
-            // fall back to LSI...
-            rtc_use_lse = false;
+            #if MICROPY_HW_RTC_USE_BYPASS
+            if (RCC->BDCR & RCC_BDCR_LSEBYP) {
+                // LSEBYP failed, fallback to LSE non-bypass
+                rtc_info |= 0x02000000;
+            } else
+            #endif
+            {
+                // LSE failed, fallback to LSI
+                rtc_use_lse = false;
+                rtc_info |= 0x01000000;
+            }
             rtc_startup_tick = HAL_GetTick();
-            PYB_RTC_MspInit_Kick(&RTCHandle, rtc_use_lse);
+            PYB_RTC_MspInit_Kick(&RTCHandle, rtc_use_lse, false);
             HAL_PWR_EnableBkUpAccess();
             RTCHandle.State = HAL_RTC_STATE_RESET;
-            if (PYB_RTC_Init(&RTCHandle) != HAL_OK) {
-                rtc_info = 0x0100ffff; // indicate error
-                return;
-            }
         } else {
             // init error
-            rtc_info = 0xffff; // indicate error
+            rtc_info |= 0xffff; // indicate error
             return;
         }
     }
 
+    // RTC started successfully
+    rtc_info = 0x20000000;
+
     // record if LSE or LSI is used
     rtc_info |= (rtc_use_lse << 28);
 
@@ -195,15 +185,15 @@ void rtc_init_finalise() {
 
     // fresh reset; configure RTC Calendar
     RTC_CalendarConfig();
-    #if defined(STM32L4)
-    if(__HAL_RCC_GET_FLAG(RCC_FLAG_BORRST) != RESET) {
+    #if defined(STM32L4) || defined(STM32WB)
+    if (__HAL_RCC_GET_FLAG(RCC_FLAG_BORRST) != RESET) {
     #else
-    if(__HAL_RCC_GET_FLAG(RCC_FLAG_PORRST) != RESET) {
-    #endif
+    if (__HAL_RCC_GET_FLAG(RCC_FLAG_PORRST) != RESET) {
+        #endif
         // power on reset occurred
         rtc_info |= 0x10000;
     }
-    if(__HAL_RCC_GET_FLAG(RCC_FLAG_PINRST) != RESET) {
+    if (__HAL_RCC_GET_FLAG(RCC_FLAG_PINRST) != RESET) {
         // external reset occurred
         rtc_info |= 0x20000;
     }
@@ -212,7 +202,7 @@ void rtc_init_finalise() {
     rtc_need_init_finalise = false;
 }
 
-STATIC HAL_StatusTypeDef PYB_RCC_OscConfig(RCC_OscInitTypeDef  *RCC_OscInitStruct) {
+STATIC HAL_StatusTypeDef PYB_RCC_OscConfig(RCC_OscInitTypeDef *RCC_OscInitStruct) {
     /*------------------------------ LSI Configuration -------------------------*/
     if ((RCC_OscInitStruct->OscillatorType & RCC_OSCILLATORTYPE_LSI) == RCC_OSCILLATORTYPE_LSI) {
         // Check the LSI State
@@ -227,7 +217,7 @@ STATIC HAL_StatusTypeDef PYB_RCC_OscConfig(RCC_OscInitTypeDef  *RCC_OscInitStruc
 
     /*------------------------------ LSE Configuration -------------------------*/
     if ((RCC_OscInitStruct->OscillatorType & RCC_OSCILLATORTYPE_LSE) == RCC_OSCILLATORTYPE_LSE) {
-        #if !defined(STM32H7)
+        #if !defined(STM32H7) && !defined(STM32WB)
         // Enable Power Clock
         __HAL_RCC_PWR_CLK_ENABLE();
         #endif
@@ -236,10 +226,10 @@ STATIC HAL_StatusTypeDef PYB_RCC_OscConfig(RCC_OscInitTypeDef  *RCC_OscInitStruc
         HAL_PWR_EnableBkUpAccess();
         uint32_t tickstart = HAL_GetTick();
 
-        #if defined(STM32F7) || defined(STM32L4) || defined(STM32H7)
-        //__HAL_RCC_PWR_CLK_ENABLE();
+        #if defined(STM32F7) || defined(STM32L4) || defined(STM32H7) || defined(STM32WB)
+        // __HAL_RCC_PWR_CLK_ENABLE();
         // Enable write access to Backup domain
-        //PWR->CR1 |= PWR_CR1_DBP;
+        // PWR->CR1 |= PWR_CR1_DBP;
         // Wait for Backup domain Write protection disable
         while ((PWR->CR1 & PWR_CR1_DBP) == RESET) {
             if (HAL_GetTick() - tickstart > RCC_DBP_TIMEOUT_VALUE) {
@@ -248,7 +238,7 @@ STATIC HAL_StatusTypeDef PYB_RCC_OscConfig(RCC_OscInitTypeDef  *RCC_OscInitStruc
         }
         #else
         // Enable write access to Backup domain
-        //PWR->CR |= PWR_CR_DBP;
+        // PWR->CR |= PWR_CR_DBP;
         // Wait for Backup domain Write protection disable
         while ((PWR->CR & PWR_CR_DBP) == RESET) {
             if (HAL_GetTick() - tickstart > RCC_DBP_TIMEOUT_VALUE) {
@@ -257,6 +247,16 @@ STATIC HAL_StatusTypeDef PYB_RCC_OscConfig(RCC_OscInitTypeDef  *RCC_OscInitStruc
         }
         #endif
 
+        #if MICROPY_HW_RTC_USE_BYPASS
+        // If LSEBYP is enabled and new state is non-bypass then disable LSEBYP
+        if (RCC_OscInitStruct->LSEState == RCC_LSE_ON && (RCC->BDCR & RCC_BDCR_LSEBYP)) {
+            CLEAR_BIT(RCC->BDCR, RCC_BDCR_LSEON);
+            while (RCC->BDCR & RCC_BDCR_LSERDY) {
+            }
+            CLEAR_BIT(RCC->BDCR, RCC_BDCR_LSEBYP);
+        }
+        #endif
+
         // Set the new LSE configuration
         __HAL_RCC_LSE_CONFIG(RCC_OscInitStruct->LSEState);
     }
@@ -295,7 +295,7 @@ STATIC HAL_StatusTypeDef PYB_RTC_Init(RTC_HandleTypeDef *hrtc) {
         return HAL_ERROR;
     } else {
         // Clear RTC_CR FMT, OSEL and POL Bits
-        hrtc->Instance->CR &= ((uint32_t)~(RTC_CR_FMT | RTC_CR_OSEL | RTC_CR_POL));
+        hrtc->Instance->CR &= ((uint32_t) ~(RTC_CR_FMT | RTC_CR_OSEL | RTC_CR_POL));
         // Set RTC_CR register
         hrtc->Instance->CR |= (uint32_t)(hrtc->Init.HourFormat | hrtc->Init.OutPut | hrtc->Init.OutPutPolarity);
 
@@ -304,16 +304,16 @@ STATIC HAL_StatusTypeDef PYB_RTC_Init(RTC_HandleTypeDef *hrtc) {
         hrtc->Instance->PRER |= (uint32_t)(hrtc->Init.AsynchPrediv << 16);
 
         // Exit Initialization mode
-        hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
+        hrtc->Instance->ISR &= (uint32_t) ~RTC_ISR_INIT;
 
-        #if defined(STM32L4) || defined(STM32H7)
-        hrtc->Instance->OR &= (uint32_t)~RTC_OR_ALARMOUTTYPE;
+        #if defined(STM32L0) || defined(STM32L4) || defined(STM32H7) || defined(STM32WB)
+        hrtc->Instance->OR &= (uint32_t) ~RTC_OR_ALARMOUTTYPE;
         hrtc->Instance->OR |= (uint32_t)(hrtc->Init.OutPutType);
         #elif defined(STM32F7)
-        hrtc->Instance->OR &= (uint32_t)~RTC_OR_ALARMTYPE;
+        hrtc->Instance->OR &= (uint32_t) ~RTC_OR_ALARMTYPE;
         hrtc->Instance->OR |= (uint32_t)(hrtc->Init.OutPutType);
         #else
-        hrtc->Instance->TAFCR &= (uint32_t)~RTC_TAFCR_ALARMOUTTYPE;
+        hrtc->Instance->TAFCR &= (uint32_t) ~RTC_TAFCR_ALARMOUTTYPE;
         hrtc->Instance->TAFCR |= (uint32_t)(hrtc->Init.OutPutType);
         #endif
 
@@ -327,7 +327,7 @@ STATIC HAL_StatusTypeDef PYB_RTC_Init(RTC_HandleTypeDef *hrtc) {
     }
 }
 
-STATIC void PYB_RTC_MspInit_Kick(RTC_HandleTypeDef *hrtc, bool rtc_use_lse) {
+STATIC void PYB_RTC_MspInit_Kick(RTC_HandleTypeDef *hrtc, bool rtc_use_lse, bool rtc_use_byp) {
     /* To change the source clock of the RTC feature (LSE, LSI), You have to:
        - Enable the power clock using __PWR_CLK_ENABLE()
        - Enable write access using HAL_PWR_EnableBkUpAccess() function before to
@@ -340,14 +340,16 @@ STATIC void PYB_RTC_MspInit_Kick(RTC_HandleTypeDef *hrtc, bool rtc_use_lse) {
     // configuration variable is set.  Otherwise it uses LSI (internal osc).
 
     RCC_OscInitTypeDef RCC_OscInitStruct;
-    RCC_OscInitStruct.OscillatorType =  RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE;
+    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE;
     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
-    if (rtc_use_lse) {
-        #if MICROPY_HW_RTC_USE_BYPASS
+    #if MICROPY_HW_RTC_USE_BYPASS
+    if (rtc_use_byp) {
         RCC_OscInitStruct.LSEState = RCC_LSE_BYPASS;
-        #else
+        RCC_OscInitStruct.LSIState = RCC_LSI_OFF;
+    } else
+    #endif
+    if (rtc_use_lse) {
         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
-        #endif
         RCC_OscInitStruct.LSIState = RCC_LSI_OFF;
     } else {
         RCC_OscInitStruct.LSEState = RCC_LSE_OFF;
@@ -359,16 +361,29 @@ STATIC void PYB_RTC_MspInit_Kick(RTC_HandleTypeDef *hrtc, bool rtc_use_lse) {
     rtc_need_init_finalise = true;
 }
 
-#define PYB_LSE_TIMEOUT_VALUE 1000  // ST docs spec 2000 ms LSE startup, seems to be too pessimistic
-#define PYB_LSI_TIMEOUT_VALUE 500   // this is way too pessimistic, typ. < 1ms
+#ifndef MICROPY_HW_RTC_LSE_TIMEOUT_MS
+#define MICROPY_HW_RTC_LSE_TIMEOUT_MS 1000  // ST docs spec 2000 ms LSE startup, seems to be too pessimistic
+#endif
+#ifndef MICROPY_HW_RTC_LSI_TIMEOUT_MS
+#define MICROPY_HW_RTC_LSI_TIMEOUT_MS 500   // this is way too pessimistic, typ. < 1ms
+#endif
+#ifndef MICROPY_HW_RTC_BYP_TIMEOUT_MS
+#define MICROPY_HW_RTC_BYP_TIMEOUT_MS 150
+#endif
 
 STATIC HAL_StatusTypeDef PYB_RTC_MspInit_Finalise(RTC_HandleTypeDef *hrtc) {
     // we already had a kick so now wait for the corresponding ready state...
     if (rtc_use_lse) {
         // we now have to wait for LSE ready or timeout
+        uint32_t timeout = MICROPY_HW_RTC_LSE_TIMEOUT_MS;
+        #if MICROPY_HW_RTC_USE_BYPASS
+        if (RCC->BDCR & RCC_BDCR_LSEBYP) {
+            timeout = MICROPY_HW_RTC_BYP_TIMEOUT_MS;
+        }
+        #endif
         uint32_t tickstart = rtc_startup_tick;
         while (__HAL_RCC_GET_FLAG(RCC_FLAG_LSERDY) == RESET) {
-            if ((HAL_GetTick() - tickstart ) > PYB_LSE_TIMEOUT_VALUE) {
+            if ((HAL_GetTick() - tickstart) > timeout) {
                 return HAL_TIMEOUT;
             }
         }
@@ -376,7 +391,7 @@ STATIC HAL_StatusTypeDef PYB_RTC_MspInit_Finalise(RTC_HandleTypeDef *hrtc) {
         // we now have to wait for LSI ready or timeout
         uint32_t tickstart = rtc_startup_tick;
         while (__HAL_RCC_GET_FLAG(RCC_FLAG_LSIRDY) == RESET) {
-            if ((HAL_GetTick() - tickstart ) > PYB_LSI_TIMEOUT_VALUE) {
+            if ((HAL_GetTick() - tickstart) > MICROPY_HW_RTC_LSI_TIMEOUT_MS) {
                 return HAL_TIMEOUT;
             }
         }
@@ -390,7 +405,7 @@ STATIC HAL_StatusTypeDef PYB_RTC_MspInit_Finalise(RTC_HandleTypeDef *hrtc) {
         PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
     }
     if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK) {
-        //Error_Handler();
+        // Error_Handler();
         return HAL_ERROR;
     }
 
@@ -407,7 +422,7 @@ STATIC void RTC_CalendarConfig(void) {
     date.Date = 1;
     date.WeekDay = RTC_WEEKDAY_THURSDAY;
 
-    if(HAL_RTC_SetDate(&RTCHandle, &date, RTC_FORMAT_BIN) != HAL_OK) {
+    if (HAL_RTC_SetDate(&RTCHandle, &date, RTC_FORMAT_BIN) != HAL_OK) {
         // init error
         return;
     }
@@ -543,7 +558,7 @@ mp_obj_t pyb_rtc_datetime(size_t n_args, const mp_obj_t *args) {
 }
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_rtc_datetime_obj, 1, 2, pyb_rtc_datetime);
 
-#if defined(STM32F0)
+#if defined(STM32F0) || defined(STM32L0)
 #define RTC_WKUP_IRQn RTC_IRQn
 #endif
 
@@ -594,7 +609,7 @@ mp_obj_t pyb_rtc_wakeup(size_t n_args, const mp_obj_t *args) {
                     wut -= 0x10000;
                     if (wut > 0x10000) {
                         // wut still too large
-                        mp_raise_ValueError("wakeup value too large");
+                        mp_raise_ValueError(MP_ERROR_TEXT("wakeup value too large"));
                     }
                 }
             }
@@ -642,7 +657,7 @@ mp_obj_t pyb_rtc_wakeup(size_t n_args, const mp_obj_t *args) {
         RTC->WPR = 0xff;
 
         // enable external interrupts on line EXTI_RTC_WAKEUP
-        #if defined(STM32L4)
+        #if defined(STM32L4) || defined(STM32WB)
         EXTI->IMR1 |= 1 << EXTI_RTC_WAKEUP;
         EXTI->RTSR1 |= 1 << EXTI_RTC_WAKEUP;
         #elif defined(STM32H7)
@@ -655,7 +670,7 @@ mp_obj_t pyb_rtc_wakeup(size_t n_args, const mp_obj_t *args) {
 
         // clear interrupt flags
         RTC->ISR &= ~RTC_ISR_WUTF;
-        #if defined(STM32L4)
+        #if defined(STM32L4) || defined(STM32WB)
         EXTI->PR1 = 1 << EXTI_RTC_WAKEUP;
         #elif defined(STM32H7)
         EXTI_D1->PR1 = 1 << EXTI_RTC_WAKEUP;
@@ -666,7 +681,7 @@ mp_obj_t pyb_rtc_wakeup(size_t n_args, const mp_obj_t *args) {
         NVIC_SetPriority(RTC_WKUP_IRQn, IRQ_PRI_RTC_WKUP);
         HAL_NVIC_EnableIRQ(RTC_WKUP_IRQn);
 
-        //printf("wut=%d wucksel=%d\n", wut, wucksel);
+        // printf("wut=%d wucksel=%d\n", wut, wucksel);
     } else {
         // clear WUTIE to disable interrupts
         RTC->CR &= ~RTC_CR_WUTIE;
@@ -675,7 +690,7 @@ mp_obj_t pyb_rtc_wakeup(size_t n_args, const mp_obj_t *args) {
         RTC->WPR = 0xff;
 
         // disable external interrupts on line EXTI_RTC_WAKEUP
-        #if defined(STM32L4)
+        #if defined(STM32L4) || defined(STM32WB)
         EXTI->IMR1 &= ~(1 << EXTI_RTC_WAKEUP);
         #elif defined(STM32H7)
         EXTI_D1->IMR1 |= 1 << EXTI_RTC_WAKEUP;
@@ -699,7 +714,7 @@ mp_obj_t pyb_rtc_calibration(size_t n_args, const mp_obj_t *args) {
         cal = mp_obj_get_int(args[1]);
         mp_uint_t cal_p, cal_m;
         if (cal < -511 || cal > 512) {
-#if defined(MICROPY_HW_RTC_USE_CALOUT) && MICROPY_HW_RTC_USE_CALOUT
+            #if defined(MICROPY_HW_RTC_USE_CALOUT) && MICROPY_HW_RTC_USE_CALOUT
             if ((cal & 0xfffe) == 0x0ffe) {
                 // turn on/off X18 (PC13) 512Hz output
                 // Note:
@@ -711,11 +726,11 @@ mp_obj_t pyb_rtc_calibration(size_t n_args, const mp_obj_t *args) {
                 }
                 return mp_obj_new_int(cal & 1);
             } else {
-                mp_raise_ValueError("calibration value out of range");
+                mp_raise_ValueError(MP_ERROR_TEXT("calibration value out of range"));
             }
-#else
-            mp_raise_ValueError("calibration value out of range");
-#endif
+            #else
+            mp_raise_ValueError(MP_ERROR_TEXT("calibration value out of range"));
+            #endif
         }
         if (cal > 0) {
             cal_p = RTC_SMOOTHCALIB_PLUSPULSES_SET;
@@ -752,5 +767,5 @@ const mp_obj_type_t pyb_rtc_type = {
     { &mp_type_type },
     .name = MP_QSTR_RTC,
     .make_new = pyb_rtc_make_new,
-    .locals_dict = (mp_obj_dict_t*)&pyb_rtc_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_rtc_locals_dict,
 };
diff --git a/ports/stm32/sdcard.c b/ports/stm32/sdcard.c
index 16e6506156fdd..9d77722302c99 100644
--- a/ports/stm32/sdcard.c
+++ b/ports/stm32/sdcard.c
@@ -156,22 +156,28 @@ void sdcard_init(void) {
     mp_hal_pin_config_alt_static(MICROPY_HW_SDMMC2_CK, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, STATIC_AF_SDMMC2_CK);
     mp_hal_pin_config_alt_static(MICROPY_HW_SDMMC2_CMD, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, STATIC_AF_SDMMC2_CMD);
     mp_hal_pin_config_alt_static(MICROPY_HW_SDMMC2_D0, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, STATIC_AF_SDMMC2_D0);
+    #if MICROPY_HW_SDMMC_BUS_WIDTH == 4
     mp_hal_pin_config_alt_static(MICROPY_HW_SDMMC2_D1, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, STATIC_AF_SDMMC2_D1);
     mp_hal_pin_config_alt_static(MICROPY_HW_SDMMC2_D2, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, STATIC_AF_SDMMC2_D2);
     mp_hal_pin_config_alt_static(MICROPY_HW_SDMMC2_D3, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, STATIC_AF_SDMMC2_D3);
+    #endif
     #else
     // Default SDIO/SDMMC1 config
+    mp_hal_pin_config_alt_static(MICROPY_HW_SDMMC_CK, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, STATIC_AF_SDMMC_CK);
+    mp_hal_pin_config_alt_static(MICROPY_HW_SDMMC_CMD, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, STATIC_AF_SDMMC_CMD);
     mp_hal_pin_config_alt_static(MICROPY_HW_SDMMC_D0, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, STATIC_AF_SDMMC_D0);
+    #if MICROPY_HW_SDMMC_BUS_WIDTH == 4
     mp_hal_pin_config_alt_static(MICROPY_HW_SDMMC_D1, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, STATIC_AF_SDMMC_D1);
     mp_hal_pin_config_alt_static(MICROPY_HW_SDMMC_D2, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, STATIC_AF_SDMMC_D2);
     mp_hal_pin_config_alt_static(MICROPY_HW_SDMMC_D3, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, STATIC_AF_SDMMC_D3);
-    mp_hal_pin_config_alt_static(MICROPY_HW_SDMMC_CK, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, STATIC_AF_SDMMC_CK);
-    mp_hal_pin_config_alt_static(MICROPY_HW_SDMMC_CMD, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, STATIC_AF_SDMMC_CMD);
+    #endif
     #endif
 
     // configure the SD card detect pin
     // we do this here so we can detect if the SD card is inserted before powering it on
+    #if defined(MICROPY_HW_SDCARD_DETECT_PIN)
     mp_hal_pin_config(MICROPY_HW_SDCARD_DETECT_PIN, MP_HAL_PIN_MODE_INPUT, MICROPY_HW_SDCARD_DETECT_PULL, 0);
+    #endif
 }
 
 STATIC void sdmmc_msp_init(void) {
@@ -227,21 +233,25 @@ bool sdcard_is_present(void) {
         return false;
     }
     #endif
+    #if defined(MICROPY_HW_SDCARD_DETECT_PIN)
     return HAL_GPIO_ReadPin(MICROPY_HW_SDCARD_DETECT_PIN->gpio, MICROPY_HW_SDCARD_DETECT_PIN->pin_mask) == MICROPY_HW_SDCARD_DETECT_PRESENT;
+    #else
+    return true;
+    #endif
 }
 
 #if MICROPY_HW_ENABLE_SDCARD
 STATIC HAL_StatusTypeDef sdmmc_init_sd(void) {
     // SD device interface configuration
     sdmmc_handle.sd.Instance = SDIO;
-    sdmmc_handle.sd.Init.ClockEdge           = SDIO_CLOCK_EDGE_RISING;
+    sdmmc_handle.sd.Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
     #ifndef STM32H7
-    sdmmc_handle.sd.Init.ClockBypass         = SDIO_CLOCK_BYPASS_DISABLE;
+    sdmmc_handle.sd.Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
     #endif
-    sdmmc_handle.sd.Init.ClockPowerSave      = SDIO_CLOCK_POWER_SAVE_ENABLE;
-    sdmmc_handle.sd.Init.BusWide             = SDIO_BUS_WIDE_1B;
+    sdmmc_handle.sd.Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_ENABLE;
+    sdmmc_handle.sd.Init.BusWide = SDIO_BUS_WIDE_1B;
     sdmmc_handle.sd.Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
-    sdmmc_handle.sd.Init.ClockDiv            = SDIO_TRANSFER_CLK_DIV;
+    sdmmc_handle.sd.Init.ClockDiv = SDIO_TRANSFER_CLK_DIV;
 
     // init the SD interface, with retry if it's not ready yet
     HAL_StatusTypeDef status;
@@ -252,12 +262,14 @@ STATIC HAL_StatusTypeDef sdmmc_init_sd(void) {
         mp_hal_delay_ms(50);
     }
 
-    // configure the SD bus width for wide operation
+    #if MICROPY_HW_SDMMC_BUS_WIDTH == 4
+    // configure the SD bus width for 4-bit wide operation
     status = HAL_SD_ConfigWideBusOperation(&sdmmc_handle.sd, SDIO_BUS_WIDE_4B);
     if (status != HAL_OK) {
         HAL_SD_DeInit(&sdmmc_handle.sd);
         return status;
     }
+    #endif
 
     return HAL_OK;
 }
@@ -267,14 +279,14 @@ STATIC HAL_StatusTypeDef sdmmc_init_sd(void) {
 STATIC HAL_StatusTypeDef sdmmc_init_mmc(void) {
     // MMC device interface configuration
     sdmmc_handle.mmc.Instance = SDIO;
-    sdmmc_handle.mmc.Init.ClockEdge           = SDIO_CLOCK_EDGE_RISING;
+    sdmmc_handle.mmc.Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
     #ifndef STM32H7
-    sdmmc_handle.mmc.Init.ClockBypass         = SDIO_CLOCK_BYPASS_DISABLE;
+    sdmmc_handle.mmc.Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
     #endif
-    sdmmc_handle.mmc.Init.ClockPowerSave      = SDIO_CLOCK_POWER_SAVE_ENABLE;
-    sdmmc_handle.mmc.Init.BusWide             = SDIO_BUS_WIDE_1B;
+    sdmmc_handle.mmc.Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_ENABLE;
+    sdmmc_handle.mmc.Init.BusWide = SDIO_BUS_WIDE_1B;
     sdmmc_handle.mmc.Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
-    sdmmc_handle.mmc.Init.ClockDiv            = SDIO_TRANSFER_CLK_DIV;
+    sdmmc_handle.mmc.Init.ClockDiv = SDIO_TRANSFER_CLK_DIV;
 
     // Init the SDIO interface
     HAL_StatusTypeDef status = HAL_MMC_Init(&sdmmc_handle.mmc);
@@ -285,7 +297,8 @@ STATIC HAL_StatusTypeDef sdmmc_init_mmc(void) {
     // As this is an eMMC card, overwrite LogBlockNbr with actual value
     sdmmc_handle.mmc.MmcCard.LogBlockNbr = 7469056 + 2048;
 
-    // Configure the SDIO bus width for wide operation
+    #if MICROPY_HW_SDMMC_BUS_WIDTH == 4
+    // Configure the SDIO bus width for 4-bit wide operation
     #ifdef STM32F7
     sdmmc_handle.mmc.Init.ClockBypass = SDIO_CLOCK_BYPASS_ENABLE;
     #endif
@@ -294,6 +307,7 @@ STATIC HAL_StatusTypeDef sdmmc_init_mmc(void) {
         HAL_MMC_DeInit(&sdmmc_handle.mmc);
         return status;
     }
+    #endif
 
     return HAL_OK;
 }
@@ -304,6 +318,10 @@ bool sdcard_power_on(void) {
         return true;
     }
 
+    #ifdef MICROPY_BOARD_SDCARD_POWER
+    MICROPY_BOARD_SDCARD_POWER
+    #endif
+
     HAL_StatusTypeDef status = HAL_ERROR;
     switch (pyb_sdmmc_flags) {
         #if MICROPY_HW_ENABLE_SDCARD
@@ -370,10 +388,12 @@ STATIC void sdmmc_irq_handler(void) {
         #if MICROPY_HW_ENABLE_SDCARD
         case PYB_SDMMC_FLAG_ACTIVE | PYB_SDMMC_FLAG_SD:
             HAL_SD_IRQHandler(&sdmmc_handle.sd);
+            break;
         #endif
         #if MICROPY_HW_ENABLE_MMCARD
         case PYB_SDMMC_FLAG_ACTIVE | PYB_SDMMC_FLAG_MMC:
             HAL_MMC_IRQHandler(&sdmmc_handle.mmc);
+            break;
         #endif
     }
 }
@@ -483,8 +503,8 @@ mp_uint_t sdcard_read_blocks(uint8_t *dest, uint32_t block_num, uint32_t num_blo
         // bytes at the aligned location should be able to be changed for the
         // duration of this function call.
         orig_dest = dest;
-        dest = (uint8_t*)((uint32_t)dest & ~3);
-        saved_word = *(uint32_t*)dest;
+        dest = (uint8_t *)((uint32_t)dest & ~3);
+        saved_word = *(uint32_t *)dest;
     }
 
     if (query_irq() == IRQ_STATE_ENABLED) {
@@ -606,11 +626,11 @@ mp_uint_t sdcard_write_blocks(const uint8_t *src, uint32_t block_num, uint32_t n
         sdcard_reset_periph();
         #if MICROPY_HW_ENABLE_MMCARD
         if (pyb_sdmmc_flags & PYB_SDMMC_FLAG_MMC) {
-            err = HAL_MMC_WriteBlocks_DMA(&sdmmc_handle.mmc, (uint8_t*)src, block_num, num_blocks);
+            err = HAL_MMC_WriteBlocks_DMA(&sdmmc_handle.mmc, (uint8_t *)src, block_num, num_blocks);
         } else
         #endif
         {
-            err = HAL_SD_WriteBlocks_DMA(&sdmmc_handle.sd, (uint8_t*)src, block_num, num_blocks);
+            err = HAL_SD_WriteBlocks_DMA(&sdmmc_handle.sd, (uint8_t *)src, block_num, num_blocks);
         }
         if (err == HAL_OK) {
             err = sdcard_wait_finished(60000);
@@ -632,11 +652,11 @@ mp_uint_t sdcard_write_blocks(const uint8_t *src, uint32_t block_num, uint32_t n
     } else {
         #if MICROPY_HW_ENABLE_MMCARD
         if (pyb_sdmmc_flags & PYB_SDMMC_FLAG_MMC) {
-            err = HAL_MMC_WriteBlocks(&sdmmc_handle.mmc, (uint8_t*)src, block_num, num_blocks, 60000);
+            err = HAL_MMC_WriteBlocks(&sdmmc_handle.mmc, (uint8_t *)src, block_num, num_blocks, 60000);
         } else
         #endif
         {
-            err = HAL_SD_WriteBlocks(&sdmmc_handle.sd, (uint8_t*)src, block_num, num_blocks, 60000);
+            err = HAL_SD_WriteBlocks(&sdmmc_handle.sd, (uint8_t *)src, block_num, num_blocks, 60000);
         }
         if (err == HAL_OK) {
             err = sdcard_wait_finished(60000);
@@ -666,7 +686,7 @@ STATIC mp_obj_t pyb_sdcard_make_new(const mp_obj_type_t *type, size_t n_args, si
 
     #if MICROPY_HW_ENABLE_MMCARD
     if (pyb_sdmmc_flags & PYB_SDMMC_FLAG_MMC) {
-        mp_raise_ValueError("peripheral used by MMCard");
+        mp_raise_ValueError(MP_ERROR_TEXT("peripheral used by MMCard"));
     }
     #endif
 
@@ -684,7 +704,7 @@ STATIC mp_obj_t pyb_mmcard_make_new(const mp_obj_type_t *type, size_t n_args, si
 
     #if MICROPY_HW_ENABLE_SDCARD
     if (pyb_sdmmc_flags & PYB_SDMMC_FLAG_SD) {
-        mp_raise_ValueError("peripheral used by SDCard");
+        mp_raise_ValueError(MP_ERROR_TEXT("peripheral used by SDCard"));
     }
     #endif
 
@@ -748,7 +768,7 @@ STATIC mp_obj_t sd_read(mp_obj_t self, mp_obj_t block_num) {
 
     if (ret != 0) {
         m_del(uint8_t, dest, SDCARD_BLOCK_SIZE);
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_Exception, "sdcard_read_blocks failed [%u]", ret));
+        mp_raise_msg_varg(&mp_type_Exception, MP_ERROR_TEXT("sdcard_read_blocks failed [%u]"), ret);
     }
 
     return mp_obj_new_bytearray_by_ref(SDCARD_BLOCK_SIZE, dest);
@@ -760,13 +780,13 @@ STATIC mp_obj_t sd_write(mp_obj_t self, mp_obj_t block_num, mp_obj_t data) {
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
     if (bufinfo.len % SDCARD_BLOCK_SIZE != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "writes must be a multiple of %d bytes", SDCARD_BLOCK_SIZE));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("writes must be a multiple of %d bytes"), SDCARD_BLOCK_SIZE);
     }
 
     mp_uint_t ret = sdcard_write_blocks(bufinfo.buf, mp_obj_get_int(block_num), bufinfo.len / SDCARD_BLOCK_SIZE);
 
     if (ret != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_Exception, "sdcard_write_blocks failed [%u]", ret));
+        mp_raise_msg_varg(&mp_type_Exception, MP_ERROR_TEXT("sdcard_write_blocks failed [%u]"), ret);
     }
 
     return mp_const_none;
@@ -792,24 +812,24 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_sdcard_writeblocks_obj, pyb_sdcard_writeblo
 STATIC mp_obj_t pyb_sdcard_ioctl(mp_obj_t self, mp_obj_t cmd_in, mp_obj_t arg_in) {
     mp_int_t cmd = mp_obj_get_int(cmd_in);
     switch (cmd) {
-        case BP_IOCTL_INIT:
+        case MP_BLOCKDEV_IOCTL_INIT:
             if (!sdcard_power_on()) {
                 return MP_OBJ_NEW_SMALL_INT(-1); // error
             }
             return MP_OBJ_NEW_SMALL_INT(0); // success
 
-        case BP_IOCTL_DEINIT:
+        case MP_BLOCKDEV_IOCTL_DEINIT:
             sdcard_power_off();
             return MP_OBJ_NEW_SMALL_INT(0); // success
 
-        case BP_IOCTL_SYNC:
+        case MP_BLOCKDEV_IOCTL_SYNC:
             // nothing to do
             return MP_OBJ_NEW_SMALL_INT(0); // success
 
-        case BP_IOCTL_SEC_COUNT:
+        case MP_BLOCKDEV_IOCTL_BLOCK_COUNT:
             return MP_OBJ_NEW_SMALL_INT(sdcard_get_capacity_in_bytes() / SDCARD_BLOCK_SIZE);
 
-        case BP_IOCTL_SEC_SIZE:
+        case MP_BLOCKDEV_IOCTL_BLOCK_SIZE:
             return MP_OBJ_NEW_SMALL_INT(SDCARD_BLOCK_SIZE);
 
         default: // unknown command
@@ -837,7 +857,7 @@ const mp_obj_type_t pyb_sdcard_type = {
     { &mp_type_type },
     .name = MP_QSTR_SDCard,
     .make_new = pyb_sdcard_make_new,
-    .locals_dict = (mp_obj_dict_t*)&pyb_sdcard_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_sdcard_locals_dict,
 };
 #endif
 
@@ -846,24 +866,24 @@ const mp_obj_type_t pyb_mmcard_type = {
     { &mp_type_type },
     .name = MP_QSTR_MMCard,
     .make_new = pyb_mmcard_make_new,
-    .locals_dict = (mp_obj_dict_t*)&pyb_sdcard_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_sdcard_locals_dict,
 };
 #endif
 
 void sdcard_init_vfs(fs_user_mount_t *vfs, int part) {
     pyb_sdmmc_flags = (pyb_sdmmc_flags & PYB_SDMMC_FLAG_ACTIVE) | PYB_SDMMC_FLAG_SD; // force SD mode
     vfs->base.type = &mp_fat_vfs_type;
-    vfs->flags |= FSUSER_NATIVE | FSUSER_HAVE_IOCTL;
+    vfs->blockdev.flags |= MP_BLOCKDEV_FLAG_NATIVE | MP_BLOCKDEV_FLAG_HAVE_IOCTL;
     vfs->fatfs.drv = vfs;
     vfs->fatfs.part = part;
-    vfs->readblocks[0] = MP_OBJ_FROM_PTR(&pyb_sdcard_readblocks_obj);
-    vfs->readblocks[1] = MP_OBJ_FROM_PTR(&pyb_sdcard_obj);
-    vfs->readblocks[2] = MP_OBJ_FROM_PTR(sdcard_read_blocks); // native version
-    vfs->writeblocks[0] = MP_OBJ_FROM_PTR(&pyb_sdcard_writeblocks_obj);
-    vfs->writeblocks[1] = MP_OBJ_FROM_PTR(&pyb_sdcard_obj);
-    vfs->writeblocks[2] = MP_OBJ_FROM_PTR(sdcard_write_blocks); // native version
-    vfs->u.ioctl[0] = MP_OBJ_FROM_PTR(&pyb_sdcard_ioctl_obj);
-    vfs->u.ioctl[1] = MP_OBJ_FROM_PTR(&pyb_sdcard_obj);
+    vfs->blockdev.readblocks[0] = MP_OBJ_FROM_PTR(&pyb_sdcard_readblocks_obj);
+    vfs->blockdev.readblocks[1] = MP_OBJ_FROM_PTR(&pyb_sdcard_obj);
+    vfs->blockdev.readblocks[2] = MP_OBJ_FROM_PTR(sdcard_read_blocks); // native version
+    vfs->blockdev.writeblocks[0] = MP_OBJ_FROM_PTR(&pyb_sdcard_writeblocks_obj);
+    vfs->blockdev.writeblocks[1] = MP_OBJ_FROM_PTR(&pyb_sdcard_obj);
+    vfs->blockdev.writeblocks[2] = MP_OBJ_FROM_PTR(sdcard_write_blocks); // native version
+    vfs->blockdev.u.ioctl[0] = MP_OBJ_FROM_PTR(&pyb_sdcard_ioctl_obj);
+    vfs->blockdev.u.ioctl[1] = MP_OBJ_FROM_PTR(&pyb_sdcard_obj);
 }
 
 #endif // MICROPY_HW_ENABLE_SDCARD || MICROPY_HW_ENABLE_MMCARD
diff --git a/ports/stm32/sdio.c b/ports/stm32/sdio.c
new file mode 100644
index 0000000000000..79cc9c9a323a9
--- /dev/null
+++ b/ports/stm32/sdio.c
@@ -0,0 +1,418 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdio.h>
+
+#include "py/mperrno.h"
+#include "py/mphal.h"
+#include "genhdr/pins.h"
+#include "pendsv.h"
+#include "sdio.h"
+
+#if MICROPY_PY_NETWORK_CYW43
+
+#define DEFAULT_MASK (0)
+
+enum {
+    SDMMC_IRQ_STATE_DONE,
+    SDMMC_IRQ_STATE_CMD_DONE,
+    SDMMC_IRQ_STATE_CMD_DATA_PENDING,
+};
+
+static volatile int sdmmc_irq_state;
+static volatile uint32_t sdmmc_block_size_log2;
+static volatile bool sdmmc_write;
+static volatile bool sdmmc_dma;
+static volatile uint32_t sdmmc_error;
+static volatile uint8_t *sdmmc_buf_cur;
+static volatile uint8_t *sdmmc_buf_top;
+
+void sdio_init(uint32_t irq_pri) {
+    // configure IO pins
+    mp_hal_pin_config(pin_C8, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, 12);
+    mp_hal_pin_config(pin_C9, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, 12);
+    mp_hal_pin_config(pin_C10, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, 12);
+    mp_hal_pin_config(pin_C11, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, 12);
+    mp_hal_pin_config(pin_C12, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_NONE, 12); // CLK doesn't need pull-up
+    mp_hal_pin_config(pin_D2, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP, 12);
+
+    __HAL_RCC_SDMMC1_CLK_ENABLE(); // enable SDIO peripheral
+
+    SDMMC_TypeDef *SDIO = SDMMC1;
+    #if defined(STM32F7)
+    SDIO->CLKCR = SDMMC_CLKCR_HWFC_EN | SDMMC_CLKCR_PWRSAV | (120 - 2); // 1-bit, 400kHz
+    #else
+    SDIO->CLKCR = SDMMC_CLKCR_HWFC_EN | SDMMC_CLKCR_PWRSAV | (120 / 2); // 1-bit, 400kHz
+    #endif
+    mp_hal_delay_us(10);
+    SDIO->POWER = 3; // the card is clocked
+    mp_hal_delay_us(10);
+    SDIO->DCTRL = SDMMC_DCTRL_RWMOD; // RWMOD is SDIO_CK
+    #if defined(STM32F7)
+    SDIO->CLKCR |= SDMMC_CLKCR_CLKEN;
+    #endif
+    mp_hal_delay_us(10);
+
+    __HAL_RCC_DMA2_CLK_ENABLE(); // enable DMA2 peripheral
+
+    NVIC_SetPriority(SDMMC1_IRQn, irq_pri);
+
+    SDIO->MASK = 0;
+    HAL_NVIC_EnableIRQ(SDMMC1_IRQn);
+}
+
+void sdio_deinit(void) {
+    __HAL_RCC_SDMMC1_CLK_DISABLE();
+    #if defined(STM32F7)
+    __HAL_RCC_DMA2_CLK_DISABLE();
+    #endif
+}
+
+void sdio_enable_high_speed_4bit(void) {
+    SDMMC_TypeDef *SDIO = SDMMC1;
+    SDIO->POWER = 0; // power off
+    mp_hal_delay_us(10);
+    #if defined(STM32F7)
+    SDIO->CLKCR = SDMMC_CLKCR_HWFC_EN | SDMMC_CLKCR_WIDBUS_0 | SDMMC_CLKCR_BYPASS /*| SDMMC_CLKCR_PWRSAV*/; // 4-bit, 48MHz
+    #else
+    SDIO->CLKCR = SDMMC_CLKCR_HWFC_EN | SDMMC_CLKCR_WIDBUS_0; // 4-bit, 48MHz
+    #endif
+    mp_hal_delay_us(10);
+    SDIO->POWER = 3; // the card is clocked
+    mp_hal_delay_us(10);
+    SDIO->DCTRL = SDMMC_DCTRL_SDIOEN | SDMMC_DCTRL_RWMOD; // SDIOEN, RWMOD is SDIO_CK
+    #if defined(STM32F7)
+    SDIO->CLKCR |= SDMMC_CLKCR_CLKEN;
+    #endif
+    SDIO->MASK = DEFAULT_MASK;
+    mp_hal_delay_us(10);
+}
+
+void SDMMC1_IRQHandler(void) {
+    if (SDMMC1->STA & SDMMC_STA_CMDREND) {
+        SDMMC1->ICR = SDMMC_ICR_CMDRENDC;
+        uint32_t r1 = SDMMC1->RESP1;
+        if (SDMMC1->RESPCMD == 53 && r1 & 0x800) {
+            printf("bad RESP1: %lu %lx\n", SDMMC1->RESPCMD, r1);
+            sdmmc_error = 0xffffffff;
+            SDMMC1->MASK &= SDMMC_MASK_SDIOITIE;
+            sdmmc_irq_state = SDMMC_IRQ_STATE_DONE;
+            return;
+        }
+        #if defined(STM32H7)
+        if (!sdmmc_dma) {
+            while (sdmmc_buf_cur < sdmmc_buf_top && (SDMMC1->STA & SDMMC_STA_DPSMACT) && !(SDMMC1->STA & SDMMC_STA_RXFIFOE)) {
+                *(uint32_t *)sdmmc_buf_cur = SDMMC1->FIFO;
+                sdmmc_buf_cur += 4;
+            }
+        }
+        #endif
+        if (sdmmc_buf_cur >= sdmmc_buf_top) {
+            // data transfer finished, so we are done
+            SDMMC1->MASK &= SDMMC_MASK_SDIOITIE;
+            sdmmc_irq_state = SDMMC_IRQ_STATE_DONE;
+            return;
+        }
+        if (sdmmc_write) {
+            SDMMC1->DCTRL =
+                SDMMC_DCTRL_SDIOEN
+                | SDMMC_DCTRL_RWMOD
+                | sdmmc_block_size_log2 << SDMMC_DCTRL_DBLOCKSIZE_Pos
+                #if defined(STM32F7)
+                | (sdmmc_dma << SDMMC_DCTRL_DMAEN_Pos)
+                #endif
+                | (!sdmmc_write) << SDMMC_DCTRL_DTDIR_Pos
+                    | SDMMC_DCTRL_DTEN
+            ;
+            if (!sdmmc_dma) {
+                SDMMC1->MASK |= SDMMC_MASK_TXFIFOHEIE;
+            }
+        }
+        sdmmc_irq_state = SDMMC_IRQ_STATE_CMD_DONE;
+    } else if (SDMMC1->STA & SDMMC_STA_DATAEND) {
+        // data transfer complete
+        // note: it's possible to get DATAEND before CMDREND
+        SDMMC1->ICR = SDMMC_ICR_DATAENDC;
+        #if defined(STM32F7)
+        // check if there is some remaining data in RXFIFO
+        if (!sdmmc_dma) {
+            while (SDMMC1->STA & SDMMC_STA_RXDAVL) {
+                *(uint32_t *)sdmmc_buf_cur = SDMMC1->FIFO;
+                sdmmc_buf_cur += 4;
+            }
+        }
+        #endif
+        if (sdmmc_irq_state == SDMMC_IRQ_STATE_CMD_DONE) {
+            // command and data finished, so we are done
+            SDMMC1->MASK &= SDMMC_MASK_SDIOITIE;
+            sdmmc_irq_state = SDMMC_IRQ_STATE_DONE;
+        }
+    } else if (SDMMC1->STA & SDMMC_STA_TXFIFOHE) {
+        if (!sdmmc_dma && sdmmc_write) {
+            // write up to 8 words to fifo
+            for (size_t i = 8; i && sdmmc_buf_cur < sdmmc_buf_top; --i) {
+                SDMMC1->FIFO = *(uint32_t *)sdmmc_buf_cur;
+                sdmmc_buf_cur += 4;
+            }
+            if (sdmmc_buf_cur >= sdmmc_buf_top) {
+                // finished, disable IRQ
+                SDMMC1->MASK &= ~SDMMC_MASK_TXFIFOHEIE;
+            }
+        }
+    } else if (SDMMC1->STA & SDMMC_STA_RXFIFOHF) {
+        if (!sdmmc_dma && !sdmmc_write) {
+            // read up to 8 words from fifo
+            for (size_t i = 8; i && sdmmc_buf_cur < sdmmc_buf_top; --i) {
+                *(uint32_t *)sdmmc_buf_cur = SDMMC1->FIFO;
+                sdmmc_buf_cur += 4;
+            }
+        }
+    } else if (SDMMC1->STA & SDMMC_STA_SDIOIT) {
+        SDMMC1->MASK &= ~SDMMC_MASK_SDIOITIE;
+        SDMMC1->ICR = SDMMC_ICR_SDIOITC;
+
+        #if MICROPY_PY_NETWORK_CYW43
+        extern void (*cyw43_poll)(void);
+        if (cyw43_poll) {
+            pendsv_schedule_dispatch(PENDSV_DISPATCH_CYW43, cyw43_poll);
+        }
+        #endif
+    } else if (SDMMC1->STA & 0x3f) {
+        // an error
+        sdmmc_error = SDMMC1->STA;
+        SDMMC1->ICR = SDMMC_STATIC_FLAGS;
+        SDMMC1->MASK &= SDMMC_MASK_SDIOITIE;
+        sdmmc_irq_state = SDMMC_IRQ_STATE_DONE;
+    }
+}
+
+int sdio_transfer(uint32_t cmd, uint32_t arg, uint32_t *resp) {
+    #if defined(STM32F7)
+    // Wait for any outstanding TX to complete
+    while (SDMMC1->STA & SDMMC_STA_TXACT) {
+    }
+    #endif
+
+    DMA2_Stream3->CR = 0; // ensure DMA is reset
+    SDMMC1->ICR = SDMMC_STATIC_FLAGS; // clear interrupts
+    SDMMC1->ARG = arg;
+    SDMMC1->CMD = cmd | SDMMC_CMD_WAITRESP_0 | SDMMC_CMD_CPSMEN;
+
+    sdmmc_irq_state = SDMMC_IRQ_STATE_CMD_DATA_PENDING;
+    sdmmc_error = 0;
+    sdmmc_buf_cur = NULL;
+    sdmmc_buf_top = NULL;
+    SDMMC1->MASK = (SDMMC1->MASK & SDMMC_MASK_SDIOITIE) | SDMMC_MASK_CMDRENDIE | 0x3f;
+
+    uint32_t start = mp_hal_ticks_ms();
+    for (;;) {
+        __WFI();
+        if (sdmmc_irq_state == SDMMC_IRQ_STATE_DONE) {
+            break;
+        }
+        if (mp_hal_ticks_ms() - start > 1000) {
+            SDMMC1->MASK = DEFAULT_MASK;
+            printf("sdio_transfer timeout STA=0x%08x\n", (uint)SDMMC1->STA);
+            return -MP_ETIMEDOUT;
+        }
+    }
+
+    SDMMC1->MASK &= SDMMC_MASK_SDIOITIE;
+
+    if (sdmmc_error == SDMMC_STA_CCRCFAIL && cmd == 5) {
+        // Errata: CMD CRC error is incorrectly generated for CMD 5
+        return 0;
+    } else if (sdmmc_error) {
+        return -(0x1000000 | sdmmc_error);
+    }
+
+    uint32_t rcmd = SDMMC1->RESPCMD;
+    if (rcmd != cmd) {
+        printf("sdio_transfer: cmd=%lu rcmd=%lu\n", cmd, rcmd);
+        return -MP_EIO;
+    }
+    if (resp != NULL) {
+        *resp = SDMMC1->RESP1;
+    }
+    return 0;
+}
+
+int sdio_transfer_cmd53(bool write, uint32_t block_size, uint32_t arg, size_t len, uint8_t *buf) {
+    #if defined(STM32F7)
+    // Wait for any outstanding TX to complete
+    while (SDMMC1->STA & SDMMC_STA_TXACT) {
+    }
+    #endif
+
+    // for SDIO_BYTE_MODE the SDIO chuck of data must be a single block of the length of buf
+    int block_size_log2 = 0;
+    if (block_size == 4) {
+        block_size_log2 = 2;
+    } else if (block_size == 8) {
+        block_size_log2 = 3;
+    } else if (block_size == 16) {
+        block_size_log2 = 4;
+    } else if (block_size == 32) {
+        block_size_log2 = 5;
+    } else if (block_size == 64) {
+        block_size_log2 = 6;
+    } else if (block_size == 128) {
+        block_size_log2 = 7;
+    } else if (block_size == 256) {
+        block_size_log2 = 8;
+    } else {
+        printf("sdio_transfer_cmd53: invalid block_size %lu", block_size);
+        return -MP_EINVAL;
+    }
+
+    bool dma = (len > 16);
+
+    SDMMC1->ICR = SDMMC_STATIC_FLAGS; // clear interrupts
+    SDMMC1->MASK &= SDMMC_MASK_SDIOITIE;
+
+    SDMMC1->DTIMER = 0x2000000; // about 700ms running at 48MHz
+    SDMMC1->DLEN = (len + block_size - 1) & ~(block_size - 1);
+
+    DMA2_Stream3->CR = 0;
+
+    if (dma) {
+        // prepare DMA so it's ready when the DPSM starts its transfer
+
+        #if defined(STM32F7)
+        // enable DMA2 peripheral in case it was turned off by someone else
+        RCC->AHB1ENR |= RCC_AHB1ENR_DMA2EN;
+        #endif
+
+        if (write) {
+            // make sure cache is flushed to RAM so the DMA can read the correct data
+            MP_HAL_CLEAN_DCACHE(buf, len);
+        } else {
+            // make sure cache is flushed and invalidated so when DMA updates the RAM
+            // from reading the peripheral the CPU then reads the new data
+            MP_HAL_CLEANINVALIDATE_DCACHE(buf, len);
+        }
+
+        #if defined(STM32F7)
+        DMA2->LIFCR = 0x3f << 22;
+        DMA2_Stream3->FCR = 0x07; // ?
+        DMA2_Stream3->PAR = (uint32_t)&SDMMC1->FIFO;
+        if ((uint32_t)buf & 3) {
+            printf("sdio_transfer_cmd53: buf=%p is not aligned for DMA\n", buf);
+            return -MP_EINVAL;
+        }
+        DMA2_Stream3->M0AR = (uint32_t)buf;
+        DMA2_Stream3->NDTR = ((len + block_size - 1) & ~(block_size - 1)) / 4;
+        DMA2_Stream3->CR = 4 << 25 // channel 4
+            | 1 << 23 // MBURST INCR4
+            | 1 << 21 // PBURST INCR4
+            | 3 << 16 // PL very high
+            | 2 << 13 // MSIZE word
+            | 2 << 11 // PSIZE word
+            | 1 << 10 // MINC enabled
+            | 0 << 9 // PINC disabled
+            | write << 6 // DIR mem-to-periph
+            | 1 << 5 // PFCTRL periph is flow controller
+            | 1 << 0 // EN
+        ;
+        #else
+        SDMMC1->IDMABASE0 = (uint32_t)buf;
+        SDMMC1->IDMACTRL = SDMMC_IDMA_IDMAEN;
+        #endif
+    } else {
+        #if defined(STM32H7)
+        SDMMC1->IDMACTRL = 0;
+        #endif
+    }
+
+    // for reading, need to initialise the DPSM before starting the CPSM
+    // so that the DPSM is ready to receive when the device sends data
+    // (and in case we get a long-running unrelated IRQ here on the host just
+    // after writing to CMD to initiate the command)
+    if (!write) {
+        SDMMC1->DCTRL =
+            SDMMC_DCTRL_SDIOEN
+            | SDMMC_DCTRL_RWMOD
+            | block_size_log2 << SDMMC_DCTRL_DBLOCKSIZE_Pos
+            #if defined(STM32F7)
+            | (dma << SDMMC_DCTRL_DMAEN_Pos)
+            #endif
+            | (!write) << SDMMC_DCTRL_DTDIR_Pos
+                | SDMMC_DCTRL_DTEN
+        ;
+    }
+
+    SDMMC1->ARG = arg;
+    SDMMC1->CMD = 53 | SDMMC_CMD_WAITRESP_0 | SDMMC_CMD_CPSMEN;
+
+    sdmmc_irq_state = SDMMC_IRQ_STATE_CMD_DATA_PENDING;
+    sdmmc_block_size_log2 = block_size_log2;
+    sdmmc_write = write;
+    sdmmc_dma = dma;
+    sdmmc_error = 0;
+    sdmmc_buf_cur = (uint8_t *)buf;
+    sdmmc_buf_top = (uint8_t *)buf + len;
+    SDMMC1->MASK = (SDMMC1->MASK & SDMMC_MASK_SDIOITIE) | SDMMC_MASK_CMDRENDIE | SDMMC_MASK_DATAENDIE | SDMMC_MASK_RXFIFOHFIE | 0x3f;
+
+    // wait to complete transfer
+    uint32_t start = mp_hal_ticks_ms();
+    for (;;) {
+        __WFI();
+        if (sdmmc_irq_state == SDMMC_IRQ_STATE_DONE) {
+            break;
+        }
+        if (mp_hal_ticks_ms() - start > 200) {
+            SDMMC1->MASK &= SDMMC_MASK_SDIOITIE;
+            #if defined(STM32F7)
+            printf("sdio_transfer_cmd53: timeout wr=%d len=%u dma=%u buf_idx=%u STA=%08x SDMMC=%08x:%08x DMA=%08x:%08x:%08x RCC=%08x\n", write, (uint)len, (uint)dma, sdmmc_buf_cur - buf, (uint)SDMMC1->STA, (uint)SDMMC1->DCOUNT, (uint)SDMMC1->FIFOCNT, (uint)DMA2->LISR, (uint)DMA2->HISR, (uint)DMA2_Stream3->NDTR, (uint)RCC->AHB1ENR);
+            #else
+            printf("sdio_transfer_cmd53: timeout wr=%d len=%u dma=%u buf_idx=%u STA=%08x SDMMC=%08x:%08x IDMA=%08x\n", write, (uint)len, (uint)dma, sdmmc_buf_cur - buf, (uint)SDMMC1->STA, (uint)SDMMC1->DCOUNT, (uint)SDMMC1->DCTRL, (uint)SDMMC1->IDMACTRL);
+            #endif
+            return -MP_ETIMEDOUT;
+        }
+    }
+
+    SDMMC1->MASK &= SDMMC_MASK_SDIOITIE;
+
+    if (sdmmc_error) {
+        #if defined(STM32F7)
+        printf("sdio_transfer_cmd53: error=%08lx wr=%d len=%u dma=%u buf_idx=%u STA=%08x SDMMC=%08x:%08x DMA=%08x:%08x:%08x RCC=%08x\n", sdmmc_error, write, (uint)len, (uint)dma, sdmmc_buf_cur - buf, (uint)SDMMC1->STA, (uint)SDMMC1->DCOUNT, (uint)SDMMC1->FIFOCNT, (uint)DMA2->LISR, (uint)DMA2->HISR, (uint)DMA2_Stream3->NDTR, (uint)RCC->AHB1ENR);
+        #else
+        printf("sdio_transfer_cmd53: error=%08lx wr=%d len=%u dma=%u buf_idx=%u STA=%08x SDMMC=%08x:%08x IDMA=%08x\n", sdmmc_error, write, (uint)len, (uint)dma, sdmmc_buf_cur - buf, (uint)SDMMC1->STA, (uint)SDMMC1->DCOUNT, (uint)SDMMC1->DCTRL, (uint)SDMMC1->IDMACTRL);
+        #endif
+        return -(0x1000000 | sdmmc_error);
+    }
+
+    if (!sdmmc_dma) {
+        if (sdmmc_buf_cur != sdmmc_buf_top) {
+            printf("sdio_transfer_cmd53: didn't transfer correct length: cur=%p top=%p\n", sdmmc_buf_cur, sdmmc_buf_top);
+            return -MP_EIO;
+        }
+    }
+
+    return 0;
+}
+
+#endif
diff --git a/ports/stm32/sdio.h b/ports/stm32/sdio.h
new file mode 100644
index 0000000000000..e7115e6f80c65
--- /dev/null
+++ b/ports/stm32/sdio.h
@@ -0,0 +1,38 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_STM32_SDIO_H
+#define MICROPY_INCLUDED_STM32_SDIO_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+void sdio_init(uint32_t irq_pri);
+void sdio_deinit(void);
+void sdio_enable_high_speed_4bit(void);
+int sdio_transfer(uint32_t cmd, uint32_t arg, uint32_t *resp);
+int sdio_transfer_cmd53(bool write, uint32_t block_size, uint32_t arg, size_t len, uint8_t *buf);
+
+#endif // MICROPY_INCLUDED_STM32_SDIO_H
diff --git a/ports/stm32/sdram.c b/ports/stm32/sdram.c
index e2b29c56e2166..0aae74e116b16 100644
--- a/ports/stm32/sdram.c
+++ b/ports/stm32/sdram.c
@@ -13,6 +13,7 @@
 #include "py/mphal.h"
 #include "pin.h"
 #include "pin_static_af.h"
+#include "mpu.h"
 #include "systick.h"
 #include "sdram.h"
 
@@ -39,10 +40,17 @@
 #define SDRAM_START_ADDRESS 0xD0000000
 #endif
 
+// Provides the MPU_REGION_SIZE_X value when passed the size of region in bytes
+// "m" must be a power of 2 between 32 and 4G (2**5 and 2**32) and this formula
+// computes the log2 of "m", minus 1
+#define MPU_REGION_SIZE(m) (((m) - 1) / (((m) - 1) % 255 + 1) / 255 % 255 * 8 + 7 - 86 / (((m) - 1) % 255 + 12) - 1)
+
+#define SDRAM_MPU_REGION_SIZE (MPU_REGION_SIZE(MICROPY_HW_SDRAM_SIZE))
+
 #ifdef FMC_SDRAM_BANK
 
 static void sdram_init_seq(SDRAM_HandleTypeDef
-        *hsdram, FMC_SDRAM_CommandTypeDef *command);
+    *hsdram, FMC_SDRAM_CommandTypeDef *command);
 extern void __fatal_error(const char *msg);
 
 bool sdram_init(void) {
@@ -127,36 +135,36 @@ bool sdram_init(void) {
     hsdram.Instance = FMC_SDRAM_DEVICE;
     /* Timing configuration for 90 Mhz of SD clock frequency (180Mhz/2) */
     /* TMRD: 2 Clock cycles */
-    SDRAM_Timing.LoadToActiveDelay    = MICROPY_HW_SDRAM_TIMING_TMRD;
+    SDRAM_Timing.LoadToActiveDelay = MICROPY_HW_SDRAM_TIMING_TMRD;
     /* TXSR: min=70ns (6x11.90ns) */
     SDRAM_Timing.ExitSelfRefreshDelay = MICROPY_HW_SDRAM_TIMING_TXSR;
     /* TRAS */
-    SDRAM_Timing.SelfRefreshTime      = MICROPY_HW_SDRAM_TIMING_TRAS;
+    SDRAM_Timing.SelfRefreshTime = MICROPY_HW_SDRAM_TIMING_TRAS;
     /* TRC */
-    SDRAM_Timing.RowCycleDelay        = MICROPY_HW_SDRAM_TIMING_TRC;
+    SDRAM_Timing.RowCycleDelay = MICROPY_HW_SDRAM_TIMING_TRC;
     /* TWR */
-    SDRAM_Timing.WriteRecoveryTime    = MICROPY_HW_SDRAM_TIMING_TWR;
+    SDRAM_Timing.WriteRecoveryTime = MICROPY_HW_SDRAM_TIMING_TWR;
     /* TRP */
-    SDRAM_Timing.RPDelay              = MICROPY_HW_SDRAM_TIMING_TRP;
+    SDRAM_Timing.RPDelay = MICROPY_HW_SDRAM_TIMING_TRP;
     /* TRCD */
-    SDRAM_Timing.RCDDelay             = MICROPY_HW_SDRAM_TIMING_TRCD;
+    SDRAM_Timing.RCDDelay = MICROPY_HW_SDRAM_TIMING_TRCD;
 
-    #define _FMC_INIT(x, n) x ## _ ## n
+    #define _FMC_INIT(x, n) x##_##n
     #define FMC_INIT(x, n) _FMC_INIT(x,  n)
 
-    hsdram.Init.SDBank             = FMC_SDRAM_BANK;
-    hsdram.Init.ColumnBitsNumber   = FMC_INIT(FMC_SDRAM_COLUMN_BITS_NUM, MICROPY_HW_SDRAM_COLUMN_BITS_NUM);
-    hsdram.Init.RowBitsNumber      = FMC_INIT(FMC_SDRAM_ROW_BITS_NUM, MICROPY_HW_SDRAM_ROW_BITS_NUM);
-    hsdram.Init.MemoryDataWidth    = FMC_INIT(FMC_SDRAM_MEM_BUS_WIDTH, MICROPY_HW_SDRAM_MEM_BUS_WIDTH);
+    hsdram.Init.SDBank = FMC_SDRAM_BANK;
+    hsdram.Init.ColumnBitsNumber = FMC_INIT(FMC_SDRAM_COLUMN_BITS_NUM, MICROPY_HW_SDRAM_COLUMN_BITS_NUM);
+    hsdram.Init.RowBitsNumber = FMC_INIT(FMC_SDRAM_ROW_BITS_NUM, MICROPY_HW_SDRAM_ROW_BITS_NUM);
+    hsdram.Init.MemoryDataWidth = FMC_INIT(FMC_SDRAM_MEM_BUS_WIDTH, MICROPY_HW_SDRAM_MEM_BUS_WIDTH);
     hsdram.Init.InternalBankNumber = FMC_INIT(FMC_SDRAM_INTERN_BANKS_NUM, MICROPY_HW_SDRAM_INTERN_BANKS_NUM);
-    hsdram.Init.CASLatency         = FMC_INIT(FMC_SDRAM_CAS_LATENCY, MICROPY_HW_SDRAM_CAS_LATENCY);
-    hsdram.Init.SDClockPeriod      = FMC_INIT(FMC_SDRAM_CLOCK_PERIOD, MICROPY_HW_SDRAM_CLOCK_PERIOD);
-    hsdram.Init.ReadPipeDelay      = FMC_INIT(FMC_SDRAM_RPIPE_DELAY, MICROPY_HW_SDRAM_RPIPE_DELAY);
-    hsdram.Init.ReadBurst          = (MICROPY_HW_SDRAM_RBURST) ? FMC_SDRAM_RBURST_ENABLE : FMC_SDRAM_RBURST_DISABLE;
-    hsdram.Init.WriteProtection    = (MICROPY_HW_SDRAM_WRITE_PROTECTION) ? FMC_SDRAM_WRITE_PROTECTION_ENABLE : FMC_SDRAM_WRITE_PROTECTION_DISABLE;
+    hsdram.Init.CASLatency = FMC_INIT(FMC_SDRAM_CAS_LATENCY, MICROPY_HW_SDRAM_CAS_LATENCY);
+    hsdram.Init.SDClockPeriod = FMC_INIT(FMC_SDRAM_CLOCK_PERIOD, MICROPY_HW_SDRAM_CLOCK_PERIOD);
+    hsdram.Init.ReadPipeDelay = FMC_INIT(FMC_SDRAM_RPIPE_DELAY, MICROPY_HW_SDRAM_RPIPE_DELAY);
+    hsdram.Init.ReadBurst = (MICROPY_HW_SDRAM_RBURST) ? FMC_SDRAM_RBURST_ENABLE : FMC_SDRAM_RBURST_DISABLE;
+    hsdram.Init.WriteProtection = (MICROPY_HW_SDRAM_WRITE_PROTECTION) ? FMC_SDRAM_WRITE_PROTECTION_ENABLE : FMC_SDRAM_WRITE_PROTECTION_DISABLE;
 
     /* Initialize the SDRAM controller */
-    if(HAL_SDRAM_Init(&hsdram, &SDRAM_Timing) != HAL_OK) {
+    if (HAL_SDRAM_Init(&hsdram, &SDRAM_Timing) != HAL_OK) {
         return false;
     }
 
@@ -165,23 +173,22 @@ bool sdram_init(void) {
 }
 
 void *sdram_start(void) {
-    return (void*)SDRAM_START_ADDRESS;
+    return (void *)SDRAM_START_ADDRESS;
 }
 
 void *sdram_end(void) {
-    return (void*)(SDRAM_START_ADDRESS + MICROPY_HW_SDRAM_SIZE);
+    return (void *)(SDRAM_START_ADDRESS + MICROPY_HW_SDRAM_SIZE);
 }
 
 static void sdram_init_seq(SDRAM_HandleTypeDef
-        *hsdram, FMC_SDRAM_CommandTypeDef *command)
-{
+    *hsdram, FMC_SDRAM_CommandTypeDef *command) {
     /* Program the SDRAM external device */
-    __IO uint32_t tmpmrd =0;
+    __IO uint32_t tmpmrd = 0;
 
     /* Step 3:  Configure a clock configuration enable command */
-    command->CommandMode           = FMC_SDRAM_CMD_CLK_ENABLE;
-    command->CommandTarget         = FMC_SDRAM_CMD_TARGET_BANK;
-    command->AutoRefreshNumber     = 1;
+    command->CommandMode = FMC_SDRAM_CMD_CLK_ENABLE;
+    command->CommandTarget = FMC_SDRAM_CMD_TARGET_BANK;
+    command->AutoRefreshNumber = 1;
     command->ModeRegisterDefinition = 0;
 
     /* Send the command */
@@ -191,18 +198,18 @@ static void sdram_init_seq(SDRAM_HandleTypeDef
     HAL_Delay(100);
 
     /* Step 5: Configure a PALL (precharge all) command */
-    command->CommandMode           = FMC_SDRAM_CMD_PALL;
-    command->CommandTarget         = FMC_SDRAM_CMD_TARGET_BANK;
-    command->AutoRefreshNumber     = 1;
+    command->CommandMode = FMC_SDRAM_CMD_PALL;
+    command->CommandTarget = FMC_SDRAM_CMD_TARGET_BANK;
+    command->AutoRefreshNumber = 1;
     command->ModeRegisterDefinition = 0;
 
     /* Send the command */
     HAL_SDRAM_SendCommand(hsdram, command, 0x1000);
 
     /* Step 6 : Configure a Auto-Refresh command */
-    command->CommandMode           = FMC_SDRAM_CMD_AUTOREFRESH_MODE;
-    command->CommandTarget         = FMC_SDRAM_CMD_TARGET_BANK;
-    command->AutoRefreshNumber     = MICROPY_HW_SDRAM_AUTOREFRESH_NUM;
+    command->CommandMode = FMC_SDRAM_CMD_AUTOREFRESH_MODE;
+    command->CommandTarget = FMC_SDRAM_CMD_TARGET_BANK;
+    command->AutoRefreshNumber = MICROPY_HW_SDRAM_AUTOREFRESH_NUM;
     command->ModeRegisterDefinition = 0;
 
     /* Send the command */
@@ -210,14 +217,14 @@ static void sdram_init_seq(SDRAM_HandleTypeDef
 
     /* Step 7: Program the external memory mode register */
     tmpmrd = (uint32_t)FMC_INIT(SDRAM_MODEREG_BURST_LENGTH, MICROPY_HW_SDRAM_BURST_LENGTH) |
-        SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL   |
+        SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL |
         FMC_INIT(SDRAM_MODEREG_CAS_LATENCY, MICROPY_HW_SDRAM_CAS_LATENCY) |
         SDRAM_MODEREG_OPERATING_MODE_STANDARD |
         SDRAM_MODEREG_WRITEBURST_MODE_SINGLE;
 
-    command->CommandMode           = FMC_SDRAM_CMD_LOAD_MODE;
-    command->CommandTarget         = FMC_SDRAM_CMD_TARGET_BANK;
-    command->AutoRefreshNumber     = 1;
+    command->CommandMode = FMC_SDRAM_CMD_LOAD_MODE;
+    command->CommandTarget = FMC_SDRAM_CMD_TARGET_BANK;
+    command->AutoRefreshNumber = 1;
     command->ModeRegisterDefinition = tmpmrd;
 
     /* Send the command */
@@ -237,43 +244,27 @@ static void sdram_init_seq(SDRAM_HandleTypeDef
     #if defined(STM32F7)
     /* Enable MPU for the SDRAM Memory Region to allow non-aligned
        accesses (hard-fault otherwise)
+       Initially disable all access for the entire SDRAM memory space,
+       then enable access/caching for the size used
     */
-
-    MPU_Region_InitTypeDef MPU_InitStruct;
-
-    /* Disable the MPU */
-    HAL_MPU_Disable();
-
-    /* Configure the MPU attributes as Write-Through for External SDRAM */
-    MPU_InitStruct.Enable = MPU_REGION_ENABLE;
-    MPU_InitStruct.BaseAddress = SDRAM_START_ADDRESS;
-    MPU_InitStruct.Size = MPU_REGION_SIZE_256MB;
-    MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
-    MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;
-    MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;
-    MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
-    MPU_InitStruct.Number = MPU_REGION_NUMBER0;
-    MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
-    MPU_InitStruct.SubRegionDisable = 0x00;
-    MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
-    HAL_MPU_ConfigRegion(&MPU_InitStruct);
-
-    /* Enable the MPU */
-    HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
+    uint32_t irq_state = mpu_config_start();
+    mpu_config_region(MPU_REGION_SDRAM1, SDRAM_START_ADDRESS, MPU_CONFIG_DISABLE(0x00, MPU_REGION_SIZE_512MB));
+    mpu_config_region(MPU_REGION_SDRAM2, SDRAM_START_ADDRESS, MPU_CONFIG_SDRAM(SDRAM_MPU_REGION_SIZE));
+    mpu_config_end(irq_state);
     #endif
 }
 
-bool __attribute__((optimize("O0"))) sdram_test(bool fast) {
+bool sdram_test(bool fast) {
     uint8_t const pattern = 0xaa;
     uint8_t const antipattern = 0x55;
-    uint8_t *const mem_base = (uint8_t*)sdram_start();
+    uint8_t *const mem_base = (uint8_t *)sdram_start();
 
     /* test data bus */
     for (uint8_t i = 1; i; i <<= 1) {
         *mem_base = i;
         if (*mem_base != i) {
             printf("data bus lines test failed! data (%d)\n", i);
-            __asm__ volatile ("BKPT");
+            return false;
         }
     }
 
@@ -283,7 +274,7 @@ bool __attribute__((optimize("O0"))) sdram_test(bool fast) {
         mem_base[i] = pattern;
         if (mem_base[i] != pattern) {
             printf("address bus lines test failed! address (%p)\n", &mem_base[i]);
-            __asm__ volatile ("BKPT");
+            return false;
         }
     }
 
@@ -292,7 +283,7 @@ bool __attribute__((optimize("O0"))) sdram_test(bool fast) {
     for (uint32_t i = 1; i < MICROPY_HW_SDRAM_SIZE; i <<= 1) {
         if (mem_base[i] != pattern) {
             printf("address bus overlap %p\n", &mem_base[i]);
-            __asm__ volatile ("BKPT");
+            return false;
         }
     }
 
@@ -302,7 +293,7 @@ bool __attribute__((optimize("O0"))) sdram_test(bool fast) {
             mem_base[i] = pattern;
             if (mem_base[i] != pattern) {
                 printf("address bus test failed! address (%p)\n", &mem_base[i]);
-                __asm__ volatile ("BKPT");
+                return false;
             }
         }
     } else {
diff --git a/ports/stm32/servo.c b/ports/stm32/servo.c
index 691c8037f5e6c..a347c6bbd06d4 100644
--- a/ports/stm32/servo.c
+++ b/ports/stm32/servo.c
@@ -125,7 +125,7 @@ void servo_timer_irq_callback(void) {
 
 STATIC void servo_init_channel(pyb_servo_obj_t *s) {
     static const uint8_t channel_table[4] =
-        {TIM_CHANNEL_1, TIM_CHANNEL_2, TIM_CHANNEL_3, TIM_CHANNEL_4};
+    {TIM_CHANNEL_1, TIM_CHANNEL_2, TIM_CHANNEL_3, TIM_CHANNEL_4};
     uint32_t channel = channel_table[s->pin->pin];
 
     // GPIO configuration
@@ -153,13 +153,25 @@ STATIC void servo_init_channel(pyb_servo_obj_t *s) {
 STATIC mp_obj_t pyb_servo_set(mp_obj_t port, mp_obj_t value) {
     int p = mp_obj_get_int(port);
     int v = mp_obj_get_int(value);
-    if (v < 50) { v = 50; }
-    if (v > 250) { v = 250; }
+    if (v < 50) {
+        v = 50;
+    }
+    if (v > 250) {
+        v = 250;
+    }
     switch (p) {
-        case 1: TIM5->CCR1 = v; break;
-        case 2: TIM5->CCR2 = v; break;
-        case 3: TIM5->CCR3 = v; break;
-        case 4: TIM5->CCR4 = v; break;
+        case 1:
+            TIM5->CCR1 = v;
+            break;
+        case 2:
+            TIM5->CCR2 = v;
+            break;
+        case 3:
+            TIM5->CCR3 = v;
+            break;
+        case 4:
+            TIM5->CCR4 = v;
+            break;
     }
     return mp_const_none;
 }
@@ -192,7 +204,7 @@ STATIC mp_obj_t pyb_servo_make_new(const mp_obj_type_t *type, size_t n_args, siz
 
     // check servo number
     if (!(0 <= servo_id && servo_id < PYB_SERVO_NUM)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Servo(%d) doesn't exist", servo_id + 1));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Servo(%d) doesn't exist"), servo_id + 1);
     }
 
     // get and init servo object
@@ -250,7 +262,7 @@ STATIC mp_obj_t pyb_servo_calibration(size_t n_args, const mp_obj_t *args) {
     }
 
     // bad number of arguments
-    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "calibration expecting 1, 4 or 6 arguments, got %d", n_args));
+    mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("calibration expecting 1, 4 or 6 arguments, got %d"), n_args);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_servo_calibration_obj, 1, 6, pyb_servo_calibration);
 
@@ -265,11 +277,11 @@ STATIC mp_obj_t pyb_servo_angle(size_t n_args, const mp_obj_t *args) {
         // get angle
         return mp_obj_new_int((self->pulse_cur - self->pulse_centre) * 90 / self->pulse_angle_90);
     } else {
-#if MICROPY_PY_BUILTINS_FLOAT
-        self->pulse_dest = self->pulse_centre + self->pulse_angle_90 * mp_obj_get_float(args[1]) / 90.0;
-#else
+        #if MICROPY_PY_BUILTINS_FLOAT
+        self->pulse_dest = self->pulse_centre + (uint16_t)((mp_float_t)self->pulse_angle_90 * mp_obj_get_float(args[1]) / MICROPY_FLOAT_CONST(90.0));
+        #else
         self->pulse_dest = self->pulse_centre + self->pulse_angle_90 * mp_obj_get_int(args[1]) / 90;
-#endif
+        #endif
         if (n_args == 2) {
             // set angle immediately
             self->time_left = 0;
@@ -295,11 +307,11 @@ STATIC mp_obj_t pyb_servo_speed(size_t n_args, const mp_obj_t *args) {
         // get speed
         return mp_obj_new_int((self->pulse_cur - self->pulse_centre) * 100 / self->pulse_speed_100);
     } else {
-#if MICROPY_PY_BUILTINS_FLOAT
-        self->pulse_dest = self->pulse_centre + self->pulse_speed_100 * mp_obj_get_float(args[1]) / 100.0;
-#else
+        #if MICROPY_PY_BUILTINS_FLOAT
+        self->pulse_dest = self->pulse_centre + (uint16_t)((mp_float_t)self->pulse_speed_100 * mp_obj_get_float(args[1]) / MICROPY_FLOAT_CONST(100.0));
+        #else
         self->pulse_dest = self->pulse_centre + self->pulse_speed_100 * mp_obj_get_int(args[1]) / 100;
-#endif
+        #endif
         if (n_args == 2) {
             // set speed immediately
             self->time_left = 0;
@@ -329,7 +341,7 @@ const mp_obj_type_t pyb_servo_type = {
     .name = MP_QSTR_Servo,
     .print = pyb_servo_print,
     .make_new = pyb_servo_make_new,
-    .locals_dict = (mp_obj_dict_t*)&pyb_servo_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_servo_locals_dict,
 };
 
 #endif // MICROPY_HW_ENABLE_SERVO
diff --git a/ports/stm32/softtimer.c b/ports/stm32/softtimer.c
new file mode 100644
index 0000000000000..d0a186c7d0489
--- /dev/null
+++ b/ports/stm32/softtimer.c
@@ -0,0 +1,98 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdint.h>
+#include "py/runtime.h"
+#include "irq.h"
+#include "softtimer.h"
+
+#define TICKS_PERIOD 0x80000000
+#define TICKS_DIFF(t1, t0) ((int32_t)(((t1 - t0 + TICKS_PERIOD / 2) & (TICKS_PERIOD - 1)) - TICKS_PERIOD / 2))
+
+extern __IO uint32_t uwTick;
+
+volatile uint32_t soft_timer_next;
+
+void soft_timer_deinit(void) {
+    MP_STATE_PORT(soft_timer_heap) = NULL;
+}
+
+STATIC int soft_timer_lt(mp_pairheap_t *n1, mp_pairheap_t *n2) {
+    soft_timer_entry_t *e1 = (soft_timer_entry_t *)n1;
+    soft_timer_entry_t *e2 = (soft_timer_entry_t *)n2;
+    return TICKS_DIFF(e1->expiry_ms, e2->expiry_ms) < 0;
+}
+
+STATIC void soft_timer_schedule_systick(uint32_t ticks_ms) {
+    uint32_t irq_state = disable_irq();
+    uint32_t uw_tick = uwTick;
+    if (TICKS_DIFF(ticks_ms, uw_tick) <= 0) {
+        soft_timer_next = uw_tick + 1;
+    } else {
+        soft_timer_next = ticks_ms;
+    }
+    enable_irq(irq_state);
+}
+
+// Must be executed at IRQ_PRI_PENDSV
+void soft_timer_handler(void) {
+    uint32_t ticks_ms = uwTick;
+    soft_timer_entry_t *heap = MP_STATE_PORT(soft_timer_heap);
+    while (heap != NULL && TICKS_DIFF(heap->expiry_ms, ticks_ms) <= 0) {
+        soft_timer_entry_t *entry = heap;
+        heap = (soft_timer_entry_t *)mp_pairheap_pop(soft_timer_lt, &heap->pairheap);
+        mp_sched_schedule(entry->callback, MP_OBJ_FROM_PTR(entry));
+        if (entry->mode == SOFT_TIMER_MODE_PERIODIC) {
+            entry->expiry_ms += entry->delta_ms;
+            heap = (soft_timer_entry_t *)mp_pairheap_push(soft_timer_lt, &heap->pairheap, &entry->pairheap);
+        }
+    }
+    MP_STATE_PORT(soft_timer_heap) = heap;
+    if (heap == NULL) {
+        // No more timers left, set largest delay possible
+        soft_timer_next = uwTick;
+    } else {
+        // Set soft_timer_next so SysTick calls us back at the correct time
+        soft_timer_schedule_systick(heap->expiry_ms);
+    }
+}
+
+void soft_timer_insert(soft_timer_entry_t *entry) {
+    mp_pairheap_init_node(soft_timer_lt, &entry->pairheap);
+    uint32_t irq_state = raise_irq_pri(IRQ_PRI_PENDSV);
+    MP_STATE_PORT(soft_timer_heap) = (soft_timer_entry_t *)mp_pairheap_push(soft_timer_lt, &MP_STATE_PORT(soft_timer_heap)->pairheap, &entry->pairheap);
+    if (entry == MP_STATE_PORT(soft_timer_heap)) {
+        // This new timer became the earliest one so set soft_timer_next
+        soft_timer_schedule_systick(entry->expiry_ms);
+    }
+    restore_irq_pri(irq_state);
+}
+
+void soft_timer_remove(soft_timer_entry_t *entry) {
+    uint32_t irq_state = raise_irq_pri(IRQ_PRI_PENDSV);
+    MP_STATE_PORT(soft_timer_heap) = (soft_timer_entry_t *)mp_pairheap_delete(soft_timer_lt, &MP_STATE_PORT(soft_timer_heap)->pairheap, &entry->pairheap);
+    restore_irq_pri(irq_state);
+}
diff --git a/ports/stm32/softtimer.h b/ports/stm32/softtimer.h
new file mode 100644
index 0000000000000..a80d9087b57e3
--- /dev/null
+++ b/ports/stm32/softtimer.h
@@ -0,0 +1,49 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_STM32_SOFTTIMER_H
+#define MICROPY_INCLUDED_STM32_SOFTTIMER_H
+
+#include "py/pairheap.h"
+
+#define SOFT_TIMER_MODE_ONE_SHOT (1)
+#define SOFT_TIMER_MODE_PERIODIC (2)
+
+typedef struct _soft_timer_entry_t {
+    mp_pairheap_t pairheap;
+    uint32_t mode;
+    uint32_t expiry_ms;
+    uint32_t delta_ms; // for periodic mode
+    mp_obj_t callback;
+} soft_timer_entry_t;
+
+extern volatile uint32_t soft_timer_next;
+
+void soft_timer_deinit(void);
+void soft_timer_handler(void);
+void soft_timer_insert(soft_timer_entry_t *entry);
+void soft_timer_remove(soft_timer_entry_t *entry);
+
+#endif // MICROPY_INCLUDED_STM32_SOFTTIMER_H
diff --git a/ports/stm32/spi.c b/ports/stm32/spi.c
index b7298b4aaaae2..5f9b1c1a28d7f 100644
--- a/ports/stm32/spi.c
+++ b/ports/stm32/spi.c
@@ -97,6 +97,52 @@ const spi_t spi_obj[6] = {
     #endif
 };
 
+#if defined(STM32H7)
+// STM32H7 HAL requires SPI IRQs to be enabled and handled.
+#if defined(MICROPY_HW_SPI1_SCK)
+void SPI1_IRQHandler(void) {
+    IRQ_ENTER(SPI1_IRQn);
+    HAL_SPI_IRQHandler(&SPIHandle1);
+    IRQ_EXIT(SPI1_IRQn);
+}
+#endif
+#if defined(MICROPY_HW_SPI2_SCK)
+void SPI2_IRQHandler(void) {
+    IRQ_ENTER(SPI2_IRQn);
+    HAL_SPI_IRQHandler(&SPIHandle2);
+    IRQ_EXIT(SPI2_IRQn);
+}
+#endif
+#if defined(MICROPY_HW_SPI3_SCK)
+void SPI3_IRQHandler(void) {
+    IRQ_ENTER(SPI3_IRQn);
+    HAL_SPI_IRQHandler(&SPIHandle3);
+    IRQ_EXIT(SPI3_IRQn);
+}
+#endif
+#if defined(MICROPY_HW_SPI4_SCK)
+void SPI4_IRQHandler(void) {
+    IRQ_ENTER(SPI4_IRQn);
+    HAL_SPI_IRQHandler(&SPIHandle4);
+    IRQ_EXIT(SPI4_IRQn);
+}
+#endif
+#if defined(MICROPY_HW_SPI5_SCK)
+void SPI5_IRQHandler(void) {
+    IRQ_ENTER(SPI5_IRQn);
+    HAL_SPI_IRQHandler(&SPIHandle5);
+    IRQ_EXIT(SPI5_IRQn);
+}
+#endif
+#if defined(MICROPY_HW_SPI6_SCK)
+void SPI6_IRQHandler(void) {
+    IRQ_ENTER(SPI6_IRQn);
+    HAL_SPI_IRQHandler(&SPIHandle6);
+    IRQ_EXIT(SPI6_IRQn);
+}
+#endif
+#endif
+
 void spi_init0(void) {
     // Initialise the SPI handles.
     // The structs live on the BSS so all other fields will be zero after a reset.
@@ -150,8 +196,7 @@ int spi_find_index(mp_obj_t id) {
             return 6;
         #endif
         }
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-            "SPI(%s) doesn't exist", port));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("SPI(%s) doesn't exist"), port);
     } else {
         // given an integer id
         int spi_id = mp_obj_get_int(id);
@@ -159,11 +204,41 @@ int spi_find_index(mp_obj_t id) {
             && spi_obj[spi_id - 1].spi != NULL) {
             return spi_id;
         }
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-            "SPI(%d) doesn't exist", spi_id));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("SPI(%d) doesn't exist"), spi_id);
     }
 }
 
+STATIC uint32_t spi_get_source_freq(SPI_HandleTypeDef *spi) {
+    #if defined(STM32F0)
+    return HAL_RCC_GetPCLK1Freq();
+    #elif defined(STM32H7)
+    if (spi->Instance == SPI1 || spi->Instance == SPI2 || spi->Instance == SPI3) {
+        return HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI123);
+    } else if (spi->Instance == SPI4 || spi->Instance == SPI5) {
+        return HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI45);
+    } else {
+        return HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI6);
+    }
+    #else
+    #if defined(SPI2)
+    if (spi->Instance == SPI2) {
+        // SPI2 is on APB1
+        return HAL_RCC_GetPCLK1Freq();
+    } else
+    #endif
+    #if defined(SPI3)
+    if (spi->Instance == SPI3) {
+        // SPI3 is on APB1
+        return HAL_RCC_GetPCLK1Freq();
+    } else
+    #endif
+    {
+        // SPI1, SPI4, SPI5 and SPI6 are on APB2
+        return HAL_RCC_GetPCLK2Freq();
+    }
+    #endif
+}
+
 // sets the parameters in the SPI_InitTypeDef struct
 // if an argument is -1 then the corresponding parameter is not changed
 void spi_set_params(const spi_t *spi_obj, uint32_t prescale, int32_t baudrate,
@@ -174,41 +249,25 @@ void spi_set_params(const spi_t *spi_obj, uint32_t prescale, int32_t baudrate,
     if (prescale != 0xffffffff || baudrate != -1) {
         if (prescale == 0xffffffff) {
             // prescaler not given, so select one that yields at most the requested baudrate
-            mp_uint_t spi_clock;
-            #if defined(STM32F0)
-            spi_clock = HAL_RCC_GetPCLK1Freq();
-            #elif defined(STM32H7)
-            if (spi->Instance == SPI1 || spi->Instance == SPI2 || spi->Instance == SPI3) {
-                spi_clock = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI123);
-            } else if (spi->Instance == SPI4 || spi->Instance == SPI5) {
-                spi_clock = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI45);
-            } else {
-                spi_clock = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI6);
-            }
-            #else
-            if (spi->Instance == SPI3) {
-                // SPI3 is on APB1
-                spi_clock = HAL_RCC_GetPCLK1Freq();
-            #if defined(SPI2)
-            } else if (spi->Instance == SPI2) {
-                // SPI2 is on APB1
-                spi_clock = HAL_RCC_GetPCLK1Freq();
-            #endif
-            } else {
-                // SPI1, SPI4, SPI5 and SPI6 are on APB2
-                spi_clock = HAL_RCC_GetPCLK2Freq();
-            }
-            #endif
-            prescale = (spi_clock + baudrate - 1) / baudrate;
+            prescale = (spi_get_source_freq(spi) + baudrate - 1) / baudrate;
+        }
+        if (prescale <= 2) {
+            init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
+        } else if (prescale <= 4) {
+            init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
+        } else if (prescale <= 8) {
+            init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
+        } else if (prescale <= 16) {
+            init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
+        } else if (prescale <= 32) {
+            init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
+        } else if (prescale <= 64) {
+            init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
+        } else if (prescale <= 128) {
+            init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
+        } else {
+            init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
         }
-        if (prescale <= 2) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2; }
-        else if (prescale <= 4) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4; }
-        else if (prescale <= 8) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8; }
-        else if (prescale <= 16) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16; }
-        else if (prescale <= 32) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32; }
-        else if (prescale <= 64) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64; }
-        else if (prescale <= 128) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128; }
-        else { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256; }
     }
 
     if (polarity != -1) {
@@ -231,11 +290,13 @@ void spi_set_params(const spi_t *spi_obj, uint32_t prescale, int32_t baudrate,
 // TODO allow to take a list of pins to use
 void spi_init(const spi_t *self, bool enable_nss_pin) {
     SPI_HandleTypeDef *spi = self->spi;
+    uint32_t irqn = 0;
     const pin_obj_t *pins[4] = { NULL, NULL, NULL, NULL };
 
     if (0) {
     #if defined(MICROPY_HW_SPI1_SCK)
     } else if (spi->Instance == SPI1) {
+        irqn = SPI1_IRQn;
         #if defined(MICROPY_HW_SPI1_NSS)
         pins[0] = MICROPY_HW_SPI1_NSS;
         #endif
@@ -249,6 +310,7 @@ void spi_init(const spi_t *self, bool enable_nss_pin) {
     #endif
     #if defined(MICROPY_HW_SPI2_SCK)
     } else if (spi->Instance == SPI2) {
+        irqn = SPI2_IRQn;
         #if defined(MICROPY_HW_SPI2_NSS)
         pins[0] = MICROPY_HW_SPI2_NSS;
         #endif
@@ -262,6 +324,7 @@ void spi_init(const spi_t *self, bool enable_nss_pin) {
     #endif
     #if defined(MICROPY_HW_SPI3_SCK)
     } else if (spi->Instance == SPI3) {
+        irqn = SPI3_IRQn;
         #if defined(MICROPY_HW_SPI3_NSS)
         pins[0] = MICROPY_HW_SPI3_NSS;
         #endif
@@ -275,6 +338,7 @@ void spi_init(const spi_t *self, bool enable_nss_pin) {
     #endif
     #if defined(MICROPY_HW_SPI4_SCK)
     } else if (spi->Instance == SPI4) {
+        irqn = SPI4_IRQn;
         #if defined(MICROPY_HW_SPI4_NSS)
         pins[0] = MICROPY_HW_SPI4_NSS;
         #endif
@@ -288,6 +352,7 @@ void spi_init(const spi_t *self, bool enable_nss_pin) {
     #endif
     #if defined(MICROPY_HW_SPI5_SCK)
     } else if (spi->Instance == SPI5) {
+        irqn = SPI5_IRQn;
         #if defined(MICROPY_HW_SPI5_NSS)
         pins[0] = MICROPY_HW_SPI5_NSS;
         #endif
@@ -301,6 +366,7 @@ void spi_init(const spi_t *self, bool enable_nss_pin) {
     #endif
     #if defined(MICROPY_HW_SPI6_SCK)
     } else if (spi->Instance == SPI6) {
+        irqn = SPI6_IRQn;
         #if defined(MICROPY_HW_SPI6_NSS)
         pins[0] = MICROPY_HW_SPI6_NSS;
         #endif
@@ -341,6 +407,13 @@ void spi_init(const spi_t *self, bool enable_nss_pin) {
     // an initialisation the next time we use it.
     dma_invalidate_channel(self->tx_dma_descr);
     dma_invalidate_channel(self->rx_dma_descr);
+
+    #if defined(STM32H7)
+    NVIC_SetPriority(irqn, IRQ_PRI_SPI);
+    HAL_NVIC_EnableIRQ(irqn);
+    #else
+    (void)irqn;
+    #endif
 }
 
 void spi_deinit(const spi_t *spi_obj) {
@@ -352,36 +425,42 @@ void spi_deinit(const spi_t *spi_obj) {
         __HAL_RCC_SPI1_FORCE_RESET();
         __HAL_RCC_SPI1_RELEASE_RESET();
         __HAL_RCC_SPI1_CLK_DISABLE();
+        HAL_NVIC_DisableIRQ(SPI1_IRQn);
     #endif
     #if defined(MICROPY_HW_SPI2_SCK)
     } else if (spi->Instance == SPI2) {
         __HAL_RCC_SPI2_FORCE_RESET();
         __HAL_RCC_SPI2_RELEASE_RESET();
         __HAL_RCC_SPI2_CLK_DISABLE();
+        HAL_NVIC_DisableIRQ(SPI2_IRQn);
     #endif
     #if defined(MICROPY_HW_SPI3_SCK)
     } else if (spi->Instance == SPI3) {
         __HAL_RCC_SPI3_FORCE_RESET();
         __HAL_RCC_SPI3_RELEASE_RESET();
         __HAL_RCC_SPI3_CLK_DISABLE();
+        HAL_NVIC_DisableIRQ(SPI3_IRQn);
     #endif
     #if defined(MICROPY_HW_SPI4_SCK)
     } else if (spi->Instance == SPI4) {
         __HAL_RCC_SPI4_FORCE_RESET();
         __HAL_RCC_SPI4_RELEASE_RESET();
         __HAL_RCC_SPI4_CLK_DISABLE();
+        HAL_NVIC_DisableIRQ(SPI4_IRQn);
     #endif
     #if defined(MICROPY_HW_SPI5_SCK)
     } else if (spi->Instance == SPI5) {
         __HAL_RCC_SPI5_FORCE_RESET();
         __HAL_RCC_SPI5_RELEASE_RESET();
         __HAL_RCC_SPI5_CLK_DISABLE();
+        HAL_NVIC_DisableIRQ(SPI5_IRQn);
     #endif
     #if defined(MICROPY_HW_SPI6_SCK)
     } else if (spi->Instance == SPI6) {
         __HAL_RCC_SPI6_FORCE_RESET();
         __HAL_RCC_SPI6_RELEASE_RESET();
         __HAL_RCC_SPI6_CLK_DISABLE();
+        HAL_NVIC_DisableIRQ(SPI6_IRQn);
     #endif
     }
 }
@@ -416,7 +495,7 @@ void spi_transfer(const spi_t *self, size_t len, const uint8_t *src, uint8_t *de
     if (dest == NULL) {
         // send only
         if (len == 1 || query_irq() == IRQ_STATE_DISABLED) {
-            status = HAL_SPI_Transmit(self->spi, (uint8_t*)src, len, timeout);
+            status = HAL_SPI_Transmit(self->spi, (uint8_t *)src, len, timeout);
         } else {
             DMA_HandleTypeDef tx_dma;
             dma_init(&tx_dma, self->tx_dma_descr, DMA_MEMORY_TO_PERIPH, self->spi);
@@ -426,7 +505,7 @@ void spi_transfer(const spi_t *self, size_t len, const uint8_t *src, uint8_t *de
             uint32_t t_start = HAL_GetTick();
             do {
                 uint32_t l = MIN(len, 65535);
-                status = HAL_SPI_Transmit_DMA(self->spi, (uint8_t*)src, l);
+                status = HAL_SPI_Transmit_DMA(self->spi, (uint8_t *)src, l);
                 if (status != HAL_OK) {
                     break;
                 }
@@ -477,7 +556,7 @@ void spi_transfer(const spi_t *self, size_t len, const uint8_t *src, uint8_t *de
     } else {
         // send and receive
         if (len == 1 || query_irq() == IRQ_STATE_DISABLED) {
-            status = HAL_SPI_TransmitReceive(self->spi, (uint8_t*)src, dest, len, timeout);
+            status = HAL_SPI_TransmitReceive(self->spi, (uint8_t *)src, dest, len, timeout);
         } else {
             DMA_HandleTypeDef tx_dma, rx_dma;
             dma_init(&tx_dma, self->tx_dma_descr, DMA_MEMORY_TO_PERIPH, self->spi);
@@ -489,7 +568,7 @@ void spi_transfer(const spi_t *self, size_t len, const uint8_t *src, uint8_t *de
             uint32_t t_start = HAL_GetTick();
             do {
                 uint32_t l = MIN(len, 65535);
-                status = HAL_SPI_TransmitReceive_DMA(self->spi, (uint8_t*)src, dest, l);
+                status = HAL_SPI_TransmitReceive_DMA(self->spi, (uint8_t *)src, dest, l);
                 if (status != HAL_OK) {
                     break;
                 }
@@ -515,55 +594,40 @@ void spi_print(const mp_print_t *print, const spi_t *spi_obj, bool legacy) {
     SPI_HandleTypeDef *spi = spi_obj->spi;
 
     uint spi_num = 1; // default to SPI1
-    if (0) { }
+    if (0) {
+    }
     #if defined(SPI2)
-    else if (spi->Instance == SPI2) { spi_num = 2; }
+    else if (spi->Instance == SPI2) {
+        spi_num = 2;
+    }
     #endif
     #if defined(SPI3)
-    else if (spi->Instance == SPI3) { spi_num = 3; }
+    else if (spi->Instance == SPI3) {
+        spi_num = 3;
+    }
     #endif
     #if defined(SPI4)
-    else if (spi->Instance == SPI4) { spi_num = 4; }
+    else if (spi->Instance == SPI4) {
+        spi_num = 4;
+    }
     #endif
     #if defined(SPI5)
-    else if (spi->Instance == SPI5) { spi_num = 5; }
+    else if (spi->Instance == SPI5) {
+        spi_num = 5;
+    }
     #endif
     #if defined(SPI6)
-    else if (spi->Instance == SPI6) { spi_num = 6; }
+    else if (spi->Instance == SPI6) {
+        spi_num = 6;
+    }
     #endif
 
     mp_printf(print, "SPI(%u", spi_num);
     if (spi->State != HAL_SPI_STATE_RESET) {
         if (spi->Init.Mode == SPI_MODE_MASTER) {
             // compute baudrate
-            uint spi_clock;
-            #if defined(STM32F0)
-            spi_clock = HAL_RCC_GetPCLK1Freq();
-            #elif defined(STM32H7)
-            if (spi->Instance == SPI1 || spi->Instance == SPI2 || spi->Instance == SPI3) {
-                spi_clock = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI123);
-            } else if (spi->Instance == SPI4 || spi->Instance == SPI5) {
-                spi_clock = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI45);
-            } else {
-                spi_clock = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SPI6);
-            }
-            #else
-            #if defined(SPI2)
-            if (spi->Instance == SPI2) {
-                // SPI2 is on APB1
-                spi_clock = HAL_RCC_GetPCLK1Freq();
-            } else
-            #endif
-            if (spi->Instance == SPI3) {
-                // SPI2 and SPI3 are on APB1
-                spi_clock = HAL_RCC_GetPCLK1Freq();
-            } else {
-                // SPI1, SPI4, SPI5 and SPI6 are on APB2
-                spi_clock = HAL_RCC_GetPCLK2Freq();
-            }
-            #endif
             uint log_prescaler = (spi->Init.BaudRatePrescaler >> 3) + 1;
-            uint baudrate = spi_clock >> log_prescaler;
+            uint baudrate = spi_get_source_freq(spi) >> log_prescaler;
             if (legacy) {
                 mp_printf(print, ", SPI.MASTER");
             }
@@ -590,7 +654,7 @@ const spi_t *spi_from_mp_obj(mp_obj_t o) {
         machine_hard_spi_obj_t *self = MP_OBJ_TO_PTR(o);
         return self->spi;
     } else {
-        mp_raise_TypeError("expecting an SPI object");
+        mp_raise_TypeError(MP_ERROR_TEXT("expecting an SPI object"));
     }
 }
 
@@ -598,7 +662,7 @@ const spi_t *spi_from_mp_obj(mp_obj_t o) {
 // Implementation of low-level SPI C protocol
 
 STATIC int spi_proto_ioctl(void *self_in, uint32_t cmd) {
-    spi_proto_cfg_t *self = (spi_proto_cfg_t*)self_in;
+    spi_proto_cfg_t *self = (spi_proto_cfg_t *)self_in;
 
     switch (cmd) {
         case MP_SPI_IOCTL_INIT:
@@ -621,7 +685,7 @@ STATIC int spi_proto_ioctl(void *self_in, uint32_t cmd) {
 }
 
 STATIC void spi_proto_transfer(void *self_in, size_t len, const uint8_t *src, uint8_t *dest) {
-    spi_proto_cfg_t *self = (spi_proto_cfg_t*)self_in;
+    spi_proto_cfg_t *self = (spi_proto_cfg_t *)self_in;
     spi_transfer(self->spi, len, src, dest, SPI_TRANSFER_TIMEOUT(len));
 }
 
diff --git a/ports/stm32/spibdev.c b/ports/stm32/spibdev.c
index 9b5a10b400372..05c8819a7737f 100644
--- a/ports/stm32/spibdev.c
+++ b/ports/stm32/spibdev.c
@@ -35,7 +35,7 @@
 int32_t spi_bdev_ioctl(spi_bdev_t *bdev, uint32_t op, uint32_t arg) {
     switch (op) {
         case BDEV_IOCTL_INIT:
-            bdev->spiflash.config = (const mp_spiflash_config_t*)arg;
+            bdev->spiflash.config = (const mp_spiflash_config_t *)arg;
             mp_spiflash_init(&bdev->spiflash);
             bdev->flash_tick_counter_last_write = 0;
             return 0;
@@ -55,6 +55,13 @@ int32_t spi_bdev_ioctl(spi_bdev_t *bdev, uint32_t op, uint32_t arg) {
                 restore_irq_pri(basepri);
             }
             return 0;
+
+        case BDEV_IOCTL_BLOCK_ERASE: {
+            uint32_t basepri = raise_irq_pri(IRQ_PRI_FLASH); // prevent cache flushing and USB access
+            mp_spiflash_erase_block(&bdev->spiflash, arg * MP_SPIFLASH_ERASE_BLOCK_SIZE);
+            restore_irq_pri(basepri);
+            return 0;
+        }
     }
     return -MP_EINVAL;
 }
@@ -79,4 +86,20 @@ int spi_bdev_writeblocks(spi_bdev_t *bdev, const uint8_t *src, uint32_t block_nu
     return ret;
 }
 
+int spi_bdev_readblocks_raw(spi_bdev_t *bdev, uint8_t *dest, uint32_t block_num, uint32_t block_offset, uint32_t num_bytes) {
+    uint32_t basepri = raise_irq_pri(IRQ_PRI_FLASH); // prevent cache flushing and USB access
+    mp_spiflash_read(&bdev->spiflash, block_num * MP_SPIFLASH_ERASE_BLOCK_SIZE + block_offset, num_bytes, dest);
+    restore_irq_pri(basepri);
+
+    return 0;
+}
+
+int spi_bdev_writeblocks_raw(spi_bdev_t *bdev, const uint8_t *src, uint32_t block_num, uint32_t block_offset, uint32_t num_bytes) {
+    uint32_t basepri = raise_irq_pri(IRQ_PRI_FLASH); // prevent cache flushing and USB access
+    int ret = mp_spiflash_write(&bdev->spiflash, block_num * MP_SPIFLASH_ERASE_BLOCK_SIZE + block_offset, num_bytes, src);
+    restore_irq_pri(basepri);
+
+    return ret;
+}
+
 #endif
diff --git a/ports/stm32/stm32_it.c b/ports/stm32/stm32_it.c
index 637442a9169b1..b84f4adfaeb81 100644
--- a/ports/stm32/stm32_it.c
+++ b/ports/stm32/stm32_it.c
@@ -72,18 +72,18 @@
 #include "stm32_it.h"
 #include "pendsv.h"
 #include "irq.h"
+#include "powerctrl.h"
 #include "pybthread.h"
 #include "gccollect.h"
 #include "extint.h"
 #include "timer.h"
 #include "uart.h"
 #include "storage.h"
-#include "can.h"
 #include "dma.h"
 #include "i2c.h"
 #include "usb.h"
 
-extern void __fatal_error(const char*);
+extern void __fatal_error(const char *);
 #if defined(MICROPY_HW_USB_FS)
 extern PCD_HandleTypeDef pcd_fs_handle;
 #endif
@@ -107,9 +107,9 @@ STATIC char *fmt_hex(uint32_t val, char *buf) {
     buf[2] = hexDig[(val >> 20) & 0x0f];
     buf[3] = hexDig[(val >> 16) & 0x0f];
     buf[4] = hexDig[(val >> 12) & 0x0f];
-    buf[5] = hexDig[(val >>  8) & 0x0f];
-    buf[6] = hexDig[(val >>  4) & 0x0f];
-    buf[7] = hexDig[(val >>  0) & 0x0f];
+    buf[5] = hexDig[(val >> 8) & 0x0f];
+    buf[6] = hexDig[(val >> 4) & 0x0f];
+    buf[7] = hexDig[(val >> 0) & 0x0f];
     buf[8] = '\0';
 
     return buf;
@@ -137,14 +137,14 @@ STATIC void print_hex_hex(const char *label, uint32_t val1, uint32_t val2) {
 // // stack: R0, R1, R2, R3, R12, LR, PC, XPSR
 
 typedef struct {
-    uint32_t    r0, r1, r2, r3, r12, lr, pc, xpsr;
+    uint32_t r0, r1, r2, r3, r12, lr, pc, xpsr;
 } ExceptionRegisters_t;
 
 int pyb_hard_fault_debug = 0;
 
 void HardFault_C_Handler(ExceptionRegisters_t *regs) {
     if (!pyb_hard_fault_debug) {
-        NVIC_SystemReset();
+        powerctrl_mcu_reset();
     }
 
     #if MICROPY_HW_ENABLE_USB
@@ -178,14 +178,14 @@ void HardFault_C_Handler(ExceptionRegisters_t *regs) {
     }
     #endif
 
-    if ((void*)&_ram_start <= (void*)regs && (void*)regs < (void*)&_ram_end) {
+    if ((void *)&_ram_start <= (void *)regs && (void *)regs < (void *)&_ram_end) {
         mp_hal_stdout_tx_str("Stack:\r\n");
         uint32_t *stack_top = &_estack;
-        if ((void*)regs < (void*)&_heap_end) {
+        if ((void *)regs < (void *)&_sstack) {
             // stack not in static stack area so limit the amount we print
-            stack_top = (uint32_t*)regs + 32;
+            stack_top = (uint32_t *)regs + 32;
         }
-        for (uint32_t *sp = (uint32_t*)regs; sp < stack_top; ++sp) {
+        for (uint32_t *sp = (uint32_t *)regs; sp < stack_top; ++sp) {
             print_hex_hex("  ", (uint32_t)sp, *sp);
         }
     }
@@ -210,23 +210,23 @@ void HardFault_Handler(void) {
     // was stacked up using the process stack pointer (aka PSP).
 
     #if __CORTEX_M == 0
-    __asm volatile(
-    " mov r0, lr    \n"
-    " lsr r0, r0, #3 \n"        // Shift Bit 3 into carry to see which stack pointer we should use.
-    " mrs r0, msp   \n"         // Make R0 point to main stack pointer
-    " bcc .use_msp  \n"         // Keep MSP in R0 if SPSEL (carry) is 0
-    " mrs r0, psp   \n"         // Make R0 point to process stack pointer
-    " .use_msp:     \n"
-    " b HardFault_C_Handler \n" // Off to C land
-    );
+    __asm volatile (
+        " mov r0, lr    \n"
+        " lsr r0, r0, #3 \n"    // Shift Bit 3 into carry to see which stack pointer we should use.
+        " mrs r0, msp   \n"     // Make R0 point to main stack pointer
+        " bcc .use_msp  \n"     // Keep MSP in R0 if SPSEL (carry) is 0
+        " mrs r0, psp   \n"     // Make R0 point to process stack pointer
+        " .use_msp:     \n"
+        " b HardFault_C_Handler \n" // Off to C land
+        );
     #else
-    __asm volatile(
-    " tst lr, #4    \n"         // Test Bit 3 to see which stack pointer we should use.
-    " ite eq        \n"         // Tell the assembler that the nest 2 instructions are if-then-else
-    " mrseq r0, msp \n"         // Make R0 point to main stack pointer
-    " mrsne r0, psp \n"         // Make R0 point to process stack pointer
-    " b HardFault_C_Handler \n" // Off to C land
-    );
+    __asm volatile (
+        " tst lr, #4    \n"     // Test Bit 3 to see which stack pointer we should use.
+        " ite eq        \n"     // Tell the assembler that the nest 2 instructions are if-then-else
+        " mrseq r0, msp \n"     // Make R0 point to main stack pointer
+        " mrsne r0, psp \n"     // Make R0 point to process stack pointer
+        " b HardFault_C_Handler \n" // Off to C land
+        );
     #endif
 }
 
@@ -297,6 +297,24 @@ void DebugMon_Handler(void) {
 /*  file (startup_stm32f4xx.s).                                               */
 /******************************************************************************/
 
+#if defined(STM32L0) || defined(STM32L432xx)
+
+#if MICROPY_HW_USB_FS
+void USB_IRQHandler(void) {
+    HAL_PCD_IRQHandler(&pcd_fs_handle);
+}
+#endif
+
+#elif defined(STM32WB)
+
+#if MICROPY_HW_USB_FS
+void USB_LP_IRQHandler(void) {
+    HAL_PCD_IRQHandler(&pcd_fs_handle);
+}
+#endif
+
+#else
+
 /**
   * @brief  This function handles USB-On-The-Go FS global interrupt request.
   * @param  None
@@ -325,43 +343,43 @@ void OTG_HS_IRQHandler(void) {
   */
 STATIC void OTG_CMD_WKUP_Handler(PCD_HandleTypeDef *pcd_handle) {
 
-  if (pcd_handle->Init.low_power_enable) {
-    /* Reset SLEEPDEEP bit of Cortex System Control Register */
-    SCB->SCR &= (uint32_t)~((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));
+    if (pcd_handle->Init.low_power_enable) {
+        /* Reset SLEEPDEEP bit of Cortex System Control Register */
+        SCB->SCR &= (uint32_t) ~((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));
 
-    /* Configures system clock after wake-up from STOP: enable HSE/HSI, PLL and select
-    PLL as system clock source (HSE/HSI and PLL are disabled in STOP mode) */
+        /* Configures system clock after wake-up from STOP: enable HSE/HSI, PLL and select
+        PLL as system clock source (HSE/HSI and PLL are disabled in STOP mode) */
 
-    __HAL_RCC_HSE_CONFIG(MICROPY_HW_RCC_HSE_STATE);
-    #if MICROPY_HW_CLK_USE_HSI
-    __HAL_RCC_HSI_ENABLE();
-    #endif
+        __HAL_RCC_HSE_CONFIG(MICROPY_HW_RCC_HSE_STATE);
+        #if MICROPY_HW_CLK_USE_HSI
+        __HAL_RCC_HSI_ENABLE();
+        #endif
 
-    /* Wait till HSE/HSI is ready */
-    while(__HAL_RCC_GET_FLAG(MICROPY_HW_RCC_FLAG_HSxRDY) == RESET)
-    {}
+        /* Wait till HSE/HSI is ready */
+        while (__HAL_RCC_GET_FLAG(MICROPY_HW_RCC_FLAG_HSxRDY) == RESET) {
+        }
 
-    /* Enable the main PLL. */
-    __HAL_RCC_PLL_ENABLE();
+        /* Enable the main PLL. */
+        __HAL_RCC_PLL_ENABLE();
 
-    /* Wait till PLL is ready */
-    while(__HAL_RCC_GET_FLAG(RCC_FLAG_PLLRDY) == RESET)
-    {}
+        /* Wait till PLL is ready */
+        while (__HAL_RCC_GET_FLAG(RCC_FLAG_PLLRDY) == RESET) {
+        }
 
-    /* Select PLL as SYSCLK */
-    MODIFY_REG(RCC->CFGR, RCC_CFGR_SW, RCC_SYSCLKSOURCE_PLLCLK);
+        /* Select PLL as SYSCLK */
+        MODIFY_REG(RCC->CFGR, RCC_CFGR_SW, RCC_SYSCLKSOURCE_PLLCLK);
 
-    #if defined(STM32H7)
-    while (__HAL_RCC_GET_SYSCLK_SOURCE() != RCC_CFGR_SWS_PLL1)
-    {}
-    #else
-    while (__HAL_RCC_GET_SYSCLK_SOURCE() != RCC_CFGR_SWS_PLL)
-    {}
-    #endif
+        #if defined(STM32H7)
+        while (__HAL_RCC_GET_SYSCLK_SOURCE() != RCC_CFGR_SWS_PLL1) {
+        }
+        #else
+        while (__HAL_RCC_GET_SYSCLK_SOURCE() != RCC_CFGR_SWS_PLL) {
+        }
+        #endif
 
-    /* ungate PHY clock */
-     __HAL_PCD_UNGATE_PHYCLOCK(pcd_handle);
-  }
+        /* ungate PHY clock */
+        __HAL_PCD_UNGATE_PHYCLOCK(pcd_handle);
+    }
 
 }
 #endif
@@ -375,10 +393,12 @@ STATIC void OTG_CMD_WKUP_Handler(PCD_HandleTypeDef *pcd_handle) {
 void OTG_FS_WKUP_IRQHandler(void) {
     IRQ_ENTER(OTG_FS_WKUP_IRQn);
 
-  OTG_CMD_WKUP_Handler(&pcd_fs_handle);
+    OTG_CMD_WKUP_Handler(&pcd_fs_handle);
 
-  /* Clear EXTI pending Bit*/
-  __HAL_USB_FS_EXTI_CLEAR_FLAG();
+    #if !defined(STM32H7)
+    /* Clear EXTI pending Bit*/
+    __HAL_USB_FS_EXTI_CLEAR_FLAG();
+    #endif
 
     IRQ_EXIT(OTG_FS_WKUP_IRQn);
 }
@@ -393,15 +413,19 @@ void OTG_FS_WKUP_IRQHandler(void) {
 void OTG_HS_WKUP_IRQHandler(void) {
     IRQ_ENTER(OTG_HS_WKUP_IRQn);
 
-  OTG_CMD_WKUP_Handler(&pcd_hs_handle);
+    OTG_CMD_WKUP_Handler(&pcd_hs_handle);
 
-  /* Clear EXTI pending Bit*/
-  __HAL_USB_HS_EXTI_CLEAR_FLAG();
+    #if !defined(STM32H7)
+    /* Clear EXTI pending Bit*/
+    __HAL_USB_HS_EXTI_CLEAR_FLAG();
+    #endif
 
     IRQ_EXIT(OTG_HS_WKUP_IRQn);
 }
 #endif
 
+#endif // !defined(STM32L0)
+
 /**
   * @brief  This function handles PPP interrupt request.
   * @param  None
@@ -488,7 +512,7 @@ void RTC_Alarm_IRQHandler(void) {
 }
 
 #if defined(ETH)    // The 407 has ETH, the 405 doesn't
-void ETH_WKUP_IRQHandler(void)  {
+void ETH_WKUP_IRQHandler(void) {
     IRQ_ENTER(ETH_WKUP_IRQn);
     Handle_EXTI_Irq(EXTI_ETH_WAKEUP);
     IRQ_EXIT(ETH_WKUP_IRQn);
@@ -508,7 +532,7 @@ void RTC_WKUP_IRQHandler(void) {
     IRQ_EXIT(RTC_WKUP_IRQn);
 }
 
-#if defined(STM32F0)
+#if defined(STM32F0) || defined(STM32L0)
 
 void RTC_IRQHandler(void) {
     IRQ_ENTER(RTC_IRQn);
@@ -587,6 +611,14 @@ void TIM1_UP_TIM16_IRQHandler(void) {
 }
 #endif
 
+#if defined(STM32H7)
+void TIM1_UP_IRQHandler(void) {
+    IRQ_ENTER(TIM1_UP_IRQn);
+    timer_irq_handler(1);
+    IRQ_EXIT(TIM1_UP_IRQn);
+}
+#endif
+
 void TIM1_TRG_COM_TIM11_IRQHandler(void) {
     IRQ_ENTER(TIM1_TRG_COM_TIM11_IRQn);
     timer_irq_handler(11);
@@ -683,6 +715,26 @@ void TIM8_TRG_COM_TIM14_IRQHandler(void) {
 }
 #endif
 
+#if defined(STM32H7)
+void TIM15_IRQHandler(void) {
+    IRQ_ENTER(TIM15_IRQn);
+    timer_irq_handler(15);
+    IRQ_EXIT(TIM15_IRQn);
+}
+
+void TIM16_IRQHandler(void) {
+    IRQ_ENTER(TIM16_IRQn);
+    timer_irq_handler(16);
+    IRQ_EXIT(TIM16_IRQn);
+}
+
+void TIM17_IRQHandler(void) {
+    IRQ_ENTER(TIM17_IRQn);
+    timer_irq_handler(17);
+    IRQ_EXIT(TIM17_IRQn);
+}
+#endif
+
 // UART/USART IRQ handlers
 void USART1_IRQHandler(void) {
     IRQ_ENTER(USART1_IRQn);
@@ -709,6 +761,15 @@ void USART3_8_IRQHandler(void) {
     IRQ_EXIT(USART3_8_IRQn);
 }
 
+#elif defined(STM32L0)
+
+void USART4_5_IRQHandler(void) {
+    IRQ_ENTER(USART4_5_IRQn);
+    uart_irq_handler(4);
+    uart_irq_handler(5);
+    IRQ_EXIT(USART4_5_IRQn);
+}
+
 #else
 
 void USART3_IRQHandler(void) {
@@ -751,46 +812,22 @@ void UART8_IRQHandler(void) {
 }
 #endif
 
-#endif
-
-#if defined(MICROPY_HW_CAN1_TX)
-void CAN1_RX0_IRQHandler(void) {
-    IRQ_ENTER(CAN1_RX0_IRQn);
-    can_rx_irq_handler(PYB_CAN_1, CAN_FIFO0);
-    IRQ_EXIT(CAN1_RX0_IRQn);
-}
-
-void CAN1_RX1_IRQHandler(void) {
-    IRQ_ENTER(CAN1_RX1_IRQn);
-    can_rx_irq_handler(PYB_CAN_1, CAN_FIFO1);
-    IRQ_EXIT(CAN1_RX1_IRQn);
-}
-
-void CAN1_SCE_IRQHandler(void) {
-    IRQ_ENTER(CAN1_SCE_IRQn);
-    can_sce_irq_handler(PYB_CAN_1);
-    IRQ_EXIT(CAN1_SCE_IRQn);
+#if defined(UART9)
+void UART9_IRQHandler(void) {
+    IRQ_ENTER(UART9_IRQn);
+    uart_irq_handler(9);
+    IRQ_EXIT(UART9_IRQn);
 }
 #endif
 
-#if defined(MICROPY_HW_CAN2_TX)
-void CAN2_RX0_IRQHandler(void) {
-    IRQ_ENTER(CAN2_RX0_IRQn);
-    can_rx_irq_handler(PYB_CAN_2, CAN_FIFO0);
-    IRQ_EXIT(CAN2_RX0_IRQn);
-}
-
-void CAN2_RX1_IRQHandler(void) {
-    IRQ_ENTER(CAN2_RX1_IRQn);
-    can_rx_irq_handler(PYB_CAN_2, CAN_FIFO1);
-    IRQ_EXIT(CAN2_RX1_IRQn);
+#if defined(UART10)
+void UART10_IRQHandler(void) {
+    IRQ_ENTER(UART10_IRQn);
+    uart_irq_handler(10);
+    IRQ_EXIT(UART10_IRQn);
 }
+#endif
 
-void CAN2_SCE_IRQHandler(void) {
-    IRQ_ENTER(CAN2_SCE_IRQn);
-    can_sce_irq_handler(PYB_CAN_2);
-    IRQ_EXIT(CAN2_SCE_IRQn);
-}
 #endif
 
 #if MICROPY_PY_PYB_LEGACY
diff --git a/ports/stm32/storage.c b/ports/stm32/storage.c
index b150d73763612..0fefcbab9063c 100644
--- a/ports/stm32/storage.c
+++ b/ports/stm32/storage.c
@@ -28,6 +28,7 @@
 #include <string.h>
 
 #include "py/runtime.h"
+#include "py/mperrno.h"
 #include "extmod/vfs_fat.h"
 
 #include "systick.h"
@@ -40,10 +41,8 @@
 #define STORAGE_SYSTICK_MASK    (0x1ff) // 512ms
 #define STORAGE_IDLE_TICK(tick) (((tick) & ~(SYSTICK_DISPATCH_NUM_SLOTS - 1) & STORAGE_SYSTICK_MASK) == 0)
 
-#define FLASH_PART1_START_BLOCK (0x100)
-
 #if defined(MICROPY_HW_BDEV2_IOCTL)
-#define FLASH_PART2_START_BLOCK (FLASH_PART1_START_BLOCK + MICROPY_HW_BDEV2_IOCTL(BDEV_IOCTL_NUM_BLOCKS, 0))
+#define FLASH_PART2_START_BLOCK (FLASH_PART1_START_BLOCK + MICROPY_HW_BDEV_IOCTL(BDEV_IOCTL_NUM_BLOCKS, 0))
 #endif
 
 static bool storage_is_initialised = false;
@@ -141,7 +140,7 @@ static void build_partition(uint8_t *buf, int boot, int type, uint32_t start_blo
 }
 
 bool storage_read_block(uint8_t *dest, uint32_t block) {
-    //printf("RD %u\n", block);
+    // printf("RD %u\n", block);
     if (block == 0) {
         // fake the MBR so we can decide on our own partition table
 
@@ -173,7 +172,7 @@ bool storage_read_block(uint8_t *dest, uint32_t block) {
 }
 
 bool storage_write_block(const uint8_t *src, uint32_t block) {
-    //printf("WR %u\n", block);
+    // printf("WR %u\n", block);
     if (block == 0) {
         // can't write MBR, but pretend we did
         return true;
@@ -186,7 +185,7 @@ bool storage_write_block(const uint8_t *src, uint32_t block) {
     }
 }
 
-mp_uint_t storage_read_blocks(uint8_t *dest, uint32_t block_num, uint32_t num_blocks) {
+int storage_read_blocks(uint8_t *dest, uint32_t block_num, uint32_t num_blocks) {
     #if defined(MICROPY_HW_BDEV_READBLOCKS)
     if (FLASH_PART1_START_BLOCK <= block_num && block_num + num_blocks <= FLASH_PART1_START_BLOCK + MICROPY_HW_BDEV_IOCTL(BDEV_IOCTL_NUM_BLOCKS, 0)) {
         return MICROPY_HW_BDEV_READBLOCKS(dest, block_num - FLASH_PART1_START_BLOCK, num_blocks);
@@ -201,13 +200,13 @@ mp_uint_t storage_read_blocks(uint8_t *dest, uint32_t block_num, uint32_t num_bl
 
     for (size_t i = 0; i < num_blocks; i++) {
         if (!storage_read_block(dest + i * FLASH_BLOCK_SIZE, block_num + i)) {
-            return 1; // error
+            return -MP_EIO; // error
         }
     }
     return 0; // success
 }
 
-mp_uint_t storage_write_blocks(const uint8_t *src, uint32_t block_num, uint32_t num_blocks) {
+int storage_write_blocks(const uint8_t *src, uint32_t block_num, uint32_t num_blocks) {
     #if defined(MICROPY_HW_BDEV_WRITEBLOCKS)
     if (FLASH_PART1_START_BLOCK <= block_num && block_num + num_blocks <= FLASH_PART1_START_BLOCK + MICROPY_HW_BDEV_IOCTL(BDEV_IOCTL_NUM_BLOCKS, 0)) {
         return MICROPY_HW_BDEV_WRITEBLOCKS(src, block_num - FLASH_PART1_START_BLOCK, num_blocks);
@@ -222,7 +221,7 @@ mp_uint_t storage_write_blocks(const uint8_t *src, uint32_t block_num, uint32_t
 
     for (size_t i = 0; i < num_blocks; i++) {
         if (!storage_write_block(src + i * FLASH_BLOCK_SIZE, block_num + i)) {
-            return 1; // error
+            return -MP_EIO; // error
         }
     }
     return 0; // success
@@ -233,42 +232,203 @@ mp_uint_t storage_write_blocks(const uint8_t *src, uint32_t block_num, uint32_t
 //
 // Expose the flash as an object with the block protocol.
 
-// there is a singleton Flash object
-STATIC const mp_obj_base_t pyb_flash_obj = {&pyb_flash_type};
+#ifdef MICROPY_HW_BDEV_SPIFLASH_EXTENDED
+// Board defined an external SPI flash for use with extended block protocol
+#define SPIFLASH (MICROPY_HW_BDEV_SPIFLASH_EXTENDED)
+#define PYB_FLASH_NATIVE_BLOCK_SIZE (MP_SPIFLASH_ERASE_BLOCK_SIZE)
+#define MICROPY_HW_BDEV_READBLOCKS_EXT(dest, bl, off, len) (spi_bdev_readblocks_raw(SPIFLASH, (dest), (bl), (off), (len)))
+#define MICROPY_HW_BDEV_WRITEBLOCKS_EXT(dest, bl, off, len) (spi_bdev_writeblocks_raw(SPIFLASH, (dest), (bl), (off), (len)))
+
+#elif (MICROPY_VFS_LFS1 || MICROPY_VFS_LFS2) && MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE
+// Board uses littlefs and internal flash, so enable extended block protocol on internal flash
+#define PYB_FLASH_NATIVE_BLOCK_SIZE (FLASH_BLOCK_SIZE)
+#define MICROPY_HW_BDEV_READBLOCKS_EXT(dest, bl, off, len) (flash_bdev_readblocks_ext((dest), (bl), (off), (len)))
+#define MICROPY_HW_BDEV_WRITEBLOCKS_EXT(dest, bl, off, len) (flash_bdev_writeblocks_ext((dest), (bl), (off), (len)))
+#endif
+
+#ifndef PYB_FLASH_NATIVE_BLOCK_SIZE
+#define PYB_FLASH_NATIVE_BLOCK_SIZE (FLASH_BLOCK_SIZE)
+#endif
+
+typedef struct _pyb_flash_obj_t {
+    mp_obj_base_t base;
+    uint32_t start; // in bytes
+    uint32_t len; // in bytes
+    #if defined(SPIFLASH)
+    bool use_native_block_size;
+    #endif
+} pyb_flash_obj_t;
+
+// This Flash object represents the entire available flash, with emulated partition table at start
+const pyb_flash_obj_t pyb_flash_obj = {
+    { &pyb_flash_type },
+    -(FLASH_PART1_START_BLOCK * FLASH_BLOCK_SIZE), // to offset FLASH_PART1_START_BLOCK
+    0, // actual size handled in ioctl, MP_BLOCKDEV_IOCTL_BLOCK_COUNT case
+};
+
+STATIC void pyb_flash_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    pyb_flash_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self == &pyb_flash_obj) {
+        mp_printf(print, "Flash()");
+    } else {
+        mp_printf(print, "Flash(start=%u, len=%u)", self->start, self->len);
+    }
+}
+
+STATIC mp_obj_t pyb_flash_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
+    // Parse arguments
+    enum { ARG_start, ARG_len };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_start, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+        { MP_QSTR_len,   MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    if (args[ARG_start].u_int == -1 && args[ARG_len].u_int == -1) {
+        // Default singleton object that accesses entire flash, including virtual partition table
+        return MP_OBJ_FROM_PTR(&pyb_flash_obj);
+    }
+
+    pyb_flash_obj_t *self = m_new_obj(pyb_flash_obj_t);
+    self->base.type = &pyb_flash_type;
+    #if defined(SPIFLASH)
+    self->use_native_block_size = false;
+    #endif
+
+    uint32_t bl_len = (storage_get_block_count() - FLASH_PART1_START_BLOCK) * FLASH_BLOCK_SIZE;
 
-STATIC mp_obj_t pyb_flash_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
-    // check arguments
-    mp_arg_check_num(n_args, n_kw, 0, 0, false);
+    mp_int_t start = args[ARG_start].u_int;
+    if (start == -1) {
+        start = 0;
+    } else if (!(0 <= start && start < bl_len && start % PYB_FLASH_NATIVE_BLOCK_SIZE == 0)) {
+        mp_raise_ValueError(NULL);
+    }
+
+    mp_int_t len = args[ARG_len].u_int;
+    if (len == -1) {
+        len = bl_len - start;
+    } else if (!(0 < len && start + len <= bl_len && len % PYB_FLASH_NATIVE_BLOCK_SIZE == 0)) {
+        mp_raise_ValueError(NULL);
+    }
 
-    // return singleton object
-    return MP_OBJ_FROM_PTR(&pyb_flash_obj);
+    self->start = start;
+    self->len = len;
+
+    return MP_OBJ_FROM_PTR(self);
 }
 
-STATIC mp_obj_t pyb_flash_readblocks(mp_obj_t self, mp_obj_t block_num, mp_obj_t buf) {
+STATIC mp_obj_t pyb_flash_readblocks(size_t n_args, const mp_obj_t *args) {
+    pyb_flash_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    uint32_t block_num = mp_obj_get_int(args[1]);
     mp_buffer_info_t bufinfo;
-    mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_WRITE);
-    mp_uint_t ret = storage_read_blocks(bufinfo.buf, mp_obj_get_int(block_num), bufinfo.len / FLASH_BLOCK_SIZE);
+    mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_WRITE);
+    mp_uint_t ret = -MP_EIO;
+    if (n_args == 3) {
+        // Cast self->start to signed in case it's pyb_flash_obj with negative start
+        block_num += FLASH_PART1_START_BLOCK + (int32_t)self->start / FLASH_BLOCK_SIZE;
+        ret = storage_read_blocks(bufinfo.buf, block_num, bufinfo.len / FLASH_BLOCK_SIZE);
+    }
+    #if defined(MICROPY_HW_BDEV_READBLOCKS_EXT)
+    else if (self != &pyb_flash_obj) {
+        // Extended block read on a sub-section of the flash storage
+        uint32_t offset = mp_obj_get_int(args[3]);
+        block_num += self->start / PYB_FLASH_NATIVE_BLOCK_SIZE;
+        ret = MICROPY_HW_BDEV_READBLOCKS_EXT(bufinfo.buf, block_num, offset, bufinfo.len);
+    }
+    #endif
     return MP_OBJ_NEW_SMALL_INT(ret);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_flash_readblocks_obj, pyb_flash_readblocks);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_flash_readblocks_obj, 3, 4, pyb_flash_readblocks);
 
-STATIC mp_obj_t pyb_flash_writeblocks(mp_obj_t self, mp_obj_t block_num, mp_obj_t buf) {
+STATIC mp_obj_t pyb_flash_writeblocks(size_t n_args, const mp_obj_t *args) {
+    pyb_flash_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    uint32_t block_num = mp_obj_get_int(args[1]);
     mp_buffer_info_t bufinfo;
-    mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_READ);
-    mp_uint_t ret = storage_write_blocks(bufinfo.buf, mp_obj_get_int(block_num), bufinfo.len / FLASH_BLOCK_SIZE);
+    mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_READ);
+    mp_uint_t ret = -MP_EIO;
+    if (n_args == 3) {
+        // Cast self->start to signed in case it's pyb_flash_obj with negative start
+        block_num += FLASH_PART1_START_BLOCK + (int32_t)self->start / FLASH_BLOCK_SIZE;
+        ret = storage_write_blocks(bufinfo.buf, block_num, bufinfo.len / FLASH_BLOCK_SIZE);
+    }
+    #if defined(MICROPY_HW_BDEV_WRITEBLOCKS_EXT)
+    else if (self != &pyb_flash_obj) {
+        // Extended block write on a sub-section of the flash storage
+        uint32_t offset = mp_obj_get_int(args[3]);
+        block_num += self->start / PYB_FLASH_NATIVE_BLOCK_SIZE;
+        ret = MICROPY_HW_BDEV_WRITEBLOCKS_EXT(bufinfo.buf, block_num, offset, bufinfo.len);
+    }
+    #endif
     return MP_OBJ_NEW_SMALL_INT(ret);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_flash_writeblocks_obj, pyb_flash_writeblocks);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_flash_writeblocks_obj, 3, 4, pyb_flash_writeblocks);
 
-STATIC mp_obj_t pyb_flash_ioctl(mp_obj_t self, mp_obj_t cmd_in, mp_obj_t arg_in) {
+STATIC mp_obj_t pyb_flash_ioctl(mp_obj_t self_in, mp_obj_t cmd_in, mp_obj_t arg_in) {
+    pyb_flash_obj_t *self = MP_OBJ_TO_PTR(self_in);
     mp_int_t cmd = mp_obj_get_int(cmd_in);
     switch (cmd) {
-        case BP_IOCTL_INIT: storage_init(); return MP_OBJ_NEW_SMALL_INT(0);
-        case BP_IOCTL_DEINIT: storage_flush(); return MP_OBJ_NEW_SMALL_INT(0); // TODO properly
-        case BP_IOCTL_SYNC: storage_flush(); return MP_OBJ_NEW_SMALL_INT(0);
-        case BP_IOCTL_SEC_COUNT: return MP_OBJ_NEW_SMALL_INT(storage_get_block_count());
-        case BP_IOCTL_SEC_SIZE: return MP_OBJ_NEW_SMALL_INT(storage_get_block_size());
-        default: return mp_const_none;
+        case MP_BLOCKDEV_IOCTL_INIT: {
+            mp_int_t ret = 0;
+            storage_init();
+            if (mp_obj_get_int(arg_in) == 1) {
+                // Will be using extended block protocol
+                if (self == &pyb_flash_obj) {
+                    ret = -1;
+                #if defined(SPIFLASH)
+                } else {
+                    // Switch to use native block size of SPI flash
+                    self->use_native_block_size = true;
+                #endif
+                }
+            }
+            return MP_OBJ_NEW_SMALL_INT(ret);
+        }
+        case MP_BLOCKDEV_IOCTL_DEINIT:
+            storage_flush();
+            return MP_OBJ_NEW_SMALL_INT(0);                                             // TODO properly
+        case MP_BLOCKDEV_IOCTL_SYNC:
+            storage_flush();
+            return MP_OBJ_NEW_SMALL_INT(0);
+
+        case MP_BLOCKDEV_IOCTL_BLOCK_COUNT: {
+            mp_int_t n;
+            if (self == &pyb_flash_obj) {
+                // Get true size
+                n = storage_get_block_count();
+            #if defined(SPIFLASH)
+            } else if (self->use_native_block_size) {
+                n = self->len / PYB_FLASH_NATIVE_BLOCK_SIZE;
+            #endif
+            } else {
+                n = self->len / FLASH_BLOCK_SIZE;
+            }
+            return MP_OBJ_NEW_SMALL_INT(n);
+        }
+
+        case MP_BLOCKDEV_IOCTL_BLOCK_SIZE: {
+            mp_int_t n = FLASH_BLOCK_SIZE;
+            #if defined(SPIFLASH)
+            if (self->use_native_block_size) {
+                n = PYB_FLASH_NATIVE_BLOCK_SIZE;
+            }
+            #endif
+            return MP_OBJ_NEW_SMALL_INT(n);
+        }
+
+        case MP_BLOCKDEV_IOCTL_BLOCK_ERASE: {
+            int ret = 0;
+            #if defined(SPIFLASH)
+            if (self->use_native_block_size) {
+                mp_int_t block_num = self->start / PYB_FLASH_NATIVE_BLOCK_SIZE + mp_obj_get_int(arg_in);
+                ret = spi_bdev_ioctl(SPIFLASH, BDEV_IOCTL_BLOCK_ERASE, block_num);
+            }
+            #endif
+            return MP_OBJ_NEW_SMALL_INT(ret);
+        }
+
+        default:
+            return mp_const_none;
     }
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_flash_ioctl_obj, pyb_flash_ioctl);
@@ -284,23 +444,24 @@ STATIC MP_DEFINE_CONST_DICT(pyb_flash_locals_dict, pyb_flash_locals_dict_table);
 const mp_obj_type_t pyb_flash_type = {
     { &mp_type_type },
     .name = MP_QSTR_Flash,
+    .print = pyb_flash_print,
     .make_new = pyb_flash_make_new,
-    .locals_dict = (mp_obj_dict_t*)&pyb_flash_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_flash_locals_dict,
 };
 
 void pyb_flash_init_vfs(fs_user_mount_t *vfs) {
     vfs->base.type = &mp_fat_vfs_type;
-    vfs->flags |= FSUSER_NATIVE | FSUSER_HAVE_IOCTL;
+    vfs->blockdev.flags |= MP_BLOCKDEV_FLAG_NATIVE | MP_BLOCKDEV_FLAG_HAVE_IOCTL;
     vfs->fatfs.drv = vfs;
     vfs->fatfs.part = 1; // flash filesystem lives on first partition
-    vfs->readblocks[0] = MP_OBJ_FROM_PTR(&pyb_flash_readblocks_obj);
-    vfs->readblocks[1] = MP_OBJ_FROM_PTR(&pyb_flash_obj);
-    vfs->readblocks[2] = MP_OBJ_FROM_PTR(storage_read_blocks); // native version
-    vfs->writeblocks[0] = MP_OBJ_FROM_PTR(&pyb_flash_writeblocks_obj);
-    vfs->writeblocks[1] = MP_OBJ_FROM_PTR(&pyb_flash_obj);
-    vfs->writeblocks[2] = MP_OBJ_FROM_PTR(storage_write_blocks); // native version
-    vfs->u.ioctl[0] = MP_OBJ_FROM_PTR(&pyb_flash_ioctl_obj);
-    vfs->u.ioctl[1] = MP_OBJ_FROM_PTR(&pyb_flash_obj);
+    vfs->blockdev.readblocks[0] = MP_OBJ_FROM_PTR(&pyb_flash_readblocks_obj);
+    vfs->blockdev.readblocks[1] = MP_OBJ_FROM_PTR(&pyb_flash_obj);
+    vfs->blockdev.readblocks[2] = MP_OBJ_FROM_PTR(storage_read_blocks); // native version
+    vfs->blockdev.writeblocks[0] = MP_OBJ_FROM_PTR(&pyb_flash_writeblocks_obj);
+    vfs->blockdev.writeblocks[1] = MP_OBJ_FROM_PTR(&pyb_flash_obj);
+    vfs->blockdev.writeblocks[2] = MP_OBJ_FROM_PTR(storage_write_blocks); // native version
+    vfs->blockdev.u.ioctl[0] = MP_OBJ_FROM_PTR(&pyb_flash_ioctl_obj);
+    vfs->blockdev.u.ioctl[1] = MP_OBJ_FROM_PTR(&pyb_flash_obj);
 }
 
 #endif
diff --git a/ports/stm32/storage.h b/ports/stm32/storage.h
index 826b465a66d97..490fc4a09b8ac 100644
--- a/ports/stm32/storage.h
+++ b/ports/stm32/storage.h
@@ -29,13 +29,15 @@
 #include "drivers/memory/spiflash.h"
 
 #define FLASH_BLOCK_SIZE (512)
+#define FLASH_PART1_START_BLOCK (0x100)
 
 // Try to match Python-level VFS block protocol where possible for these constants
 enum {
     BDEV_IOCTL_INIT = 1,
     BDEV_IOCTL_SYNC = 3,
     BDEV_IOCTL_NUM_BLOCKS = 4,
-    BDEV_IOCTL_IRQ_HANDLER = 6,
+    BDEV_IOCTL_BLOCK_ERASE = 6,
+    BDEV_IOCTL_IRQ_HANDLER = 7,
 };
 
 void storage_init(void);
@@ -45,13 +47,15 @@ void storage_flush(void);
 bool storage_read_block(uint8_t *dest, uint32_t block);
 bool storage_write_block(const uint8_t *src, uint32_t block);
 
-// these return 0 on success, non-zero on error
-mp_uint_t storage_read_blocks(uint8_t *dest, uint32_t block_num, uint32_t num_blocks);
-mp_uint_t storage_write_blocks(const uint8_t *src, uint32_t block_num, uint32_t num_blocks);
+// these return 0 on success, negative errno on error
+int storage_read_blocks(uint8_t *dest, uint32_t block_num, uint32_t num_blocks);
+int storage_write_blocks(const uint8_t *src, uint32_t block_num, uint32_t num_blocks);
 
 int32_t flash_bdev_ioctl(uint32_t op, uint32_t arg);
 bool flash_bdev_readblock(uint8_t *dest, uint32_t block);
 bool flash_bdev_writeblock(const uint8_t *src, uint32_t block);
+int flash_bdev_readblocks_ext(uint8_t *dest, uint32_t block, uint32_t offset, uint32_t len);
+int flash_bdev_writeblocks_ext(const uint8_t *src, uint32_t block, uint32_t offset, uint32_t len);
 
 typedef struct _spi_bdev_t {
     mp_spiflash_t spiflash;
@@ -62,7 +66,12 @@ int32_t spi_bdev_ioctl(spi_bdev_t *bdev, uint32_t op, uint32_t arg);
 int spi_bdev_readblocks(spi_bdev_t *bdev, uint8_t *dest, uint32_t block_num, uint32_t num_blocks);
 int spi_bdev_writeblocks(spi_bdev_t *bdev, const uint8_t *src, uint32_t block_num, uint32_t num_blocks);
 
+// These raw functions bypass the cache and go directly to SPI flash
+int spi_bdev_readblocks_raw(spi_bdev_t *bdev, uint8_t *dest, uint32_t block_num, uint32_t block_offset, uint32_t num_bytes);
+int spi_bdev_writeblocks_raw(spi_bdev_t *bdev, const uint8_t *src, uint32_t block_num, uint32_t block_offset, uint32_t num_bytes);
+
 extern const struct _mp_obj_type_t pyb_flash_type;
+extern const struct _pyb_flash_obj_t pyb_flash_obj;
 
 struct _fs_user_mount_t;
 void pyb_flash_init_vfs(struct _fs_user_mount_t *vfs);
diff --git a/ports/stm32/system_stm32.c b/ports/stm32/system_stm32.c
index be8badea43115..00b7213869eae 100644
--- a/ports/stm32/system_stm32.c
+++ b/ports/stm32/system_stm32.c
@@ -75,221 +75,12 @@
   ******************************************************************************
   */
 
-/** @addtogroup CMSIS
-  * @{
-  */
-
-/** @addtogroup stm32fxxx_system
-  * @{
-  */
-
-/** @addtogroup STM32Fxxx_System_Private_Includes
-  * @{
-  */
-
 #include "py/mphal.h"
 #include "powerctrl.h"
 
-void __fatal_error(const char *msg);
-
-/**
-  * @}
-  */
-
-/** @addtogroup STM32Fxxx_System_Private_TypesDefinitions
-  * @{
-  */
-
-/**
-  * @}
-  */
-
-/** @addtogroup STM32Fxxx_System_Private_Defines
-  * @{
-  */
-
-#if defined(STM32F4) || defined(STM32F7)
-
-#define CONFIG_RCC_CR_1ST (RCC_CR_HSION)
-#define CONFIG_RCC_CR_2ND (MICROPY_HW_RCC_CR_HSxON | RCC_CR_CSSON | RCC_CR_PLLON)
-#define CONFIG_RCC_PLLCFGR (0x24003010)
-
-#if defined(STM32F4)
-const uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9};
-const uint8_t APBPrescTable[8] = {0, 0, 0, 0, 1, 2, 3, 4};
-#elif defined(STM32F7)
-const uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9};
-const uint8_t APBPrescTable[8] = {0, 0, 0, 0, 1, 2, 3, 4};
-#endif
-
-#elif defined(STM32L4)
-
-#define CONFIG_RCC_CR_1ST (RCC_CR_MSION)
-#define CONFIG_RCC_CR_2ND (RCC_CR_HSEON | RCC_CR_CSSON | RCC_CR_HSION | RCC_CR_PLLON)
-#define CONFIG_RCC_PLLCFGR (0x00001000)
-/*
- * FIXME Do not know why I have to define these arrays here! they should be defined in the
- * hal_rcc-file!!
- *
- */
-const uint8_t  AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9};
-const uint8_t  APBPrescTable[8] =  {0, 0, 0, 0, 1, 2, 3, 4};
-const uint32_t MSIRangeTable[12] = {100000, 200000, 400000, 800000, 1000000, 2000000, \
-                                  4000000, 8000000, 16000000, 24000000, 32000000, 48000000};
-#elif defined(STM32H7)
-
-#define CONFIG_RCC_CR_1ST   (RCC_CR_HSION)
-#define CONFIG_RCC_CR_2ND   (~0xEAF6ED7F)
-#define CONFIG_RCC_PLLCFGR  (0x00000000)
-
-#define SRAM_BASE D1_AXISRAM_BASE
-#define FLASH_BASE FLASH_BANK1_BASE
-uint32_t SystemD2Clock = 64000000;
-const uint8_t D1CorePrescTable[16] = {0, 0, 0, 0, 1, 2, 3, 4, 1, 2, 3, 4, 6, 7, 8, 9};
-
-#else
-#error Unknown processor
-#endif
-
-/************************* Miscellaneous Configuration ************************/
-
-/*!< Uncomment the following line if you need to relocate your vector Table in
-     Internal SRAM. */
-/* #define VECT_TAB_SRAM */
-#define VECT_TAB_OFFSET  0x00 /*!< Vector Table base offset field.
-                                   This value must be a multiple of 0x200. */
-/******************************************************************************/
-
-/**
-  * @}
-  */
-
-/** @addtogroup STM32Fxxx_System_Private_Macros
-  * @{
-  */
-
-/**
-  * @}
-  */
-
-/** @addtogroup STM32Fxxx_System_Private_Variables
-  * @{
-  */
-  /* This variable is updated in three ways:
-      1) by calling CMSIS function SystemCoreClockUpdate()
-      2) by calling HAL API function HAL_RCC_GetHCLKFreq()
-      3) each time HAL_RCC_ClockConfig() is called to configure the system clock frequency
-         Note: If you use this function to configure the system clock; then there
-               is no need to call the 2 first functions listed above, since SystemCoreClock
-               variable is updated automatically.
-  */
-  uint32_t SystemCoreClock = 16000000;
-
-/**
-  * @}
-  */
-
-/** @addtogroup STM32Fxxx_System_Private_FunctionPrototypes
-  * @{
-  */
-
-/**
-  * @}
-  */
-
-/** @addtogroup STM32Fxxx_System_Private_Functions
-  * @{
-  */
-
-/**
-  * @brief  Setup the microcontroller system
-  *         Initialize the FPU setting, vector table location and External memory
-  *         configuration.
-  * @param  None
-  * @retval None
-  */
-void SystemInit(void)
-{
-  /* FPU settings ------------------------------------------------------------*/
-  #if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
-    SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2));  /* set CP10 and CP11 Full Access */
-  #endif
-  /* Reset the RCC clock configuration to the default reset state ------------*/
-
-  /* Set configured startup clk source */
-  RCC->CR |= CONFIG_RCC_CR_1ST;
-
-  /* Reset CFGR register */
-  RCC->CFGR = 0x00000000;
-
-  /* Reset HSxON, CSSON and PLLON bits */
-  RCC->CR &= ~ CONFIG_RCC_CR_2ND;
-
-  /* Reset PLLCFGR register */
-  RCC->PLLCFGR = CONFIG_RCC_PLLCFGR;
-
-  #if defined(STM32H7)
-  /* Reset D1CFGR register */
-  RCC->D1CFGR = 0x00000000;
-
-  /* Reset D2CFGR register */
-  RCC->D2CFGR = 0x00000000;
-
-  /* Reset D3CFGR register */
-  RCC->D3CFGR = 0x00000000;
-
-  /* Reset PLLCKSELR register */
-  RCC->PLLCKSELR = 0x00000000;
-
-  /* Reset PLL1DIVR register */
-  RCC->PLL1DIVR = 0x00000000;
-
-  /* Reset PLL1FRACR register */
-  RCC->PLL1FRACR = 0x00000000;
-
-  /* Reset PLL2DIVR register */
-  RCC->PLL2DIVR = 0x00000000;
-
-  /* Reset PLL2FRACR register */
-  RCC->PLL2FRACR = 0x00000000;
-
-  /* Reset PLL3DIVR register */
-  RCC->PLL3DIVR = 0x00000000;
-
-  /* Reset PLL3FRACR register */
-  RCC->PLL3FRACR = 0x00000000;
-  #endif
-
-  /* Reset HSEBYP bit */
-  RCC->CR &= (uint32_t)0xFFFBFFFF;
-
-  /* Disable all interrupts */
-  #if defined(STM32F4) || defined(STM32F7)
-  RCC->CIR = 0x00000000;
-  #elif defined(STM32L4) || defined(STM32H7)
-  RCC->CIER = 0x00000000;
-  #endif
-
-  #if defined(STM32H7)
-  /* Change the switch matrix read issuing capability to 1 for the AXI SRAM target (Target 7) */
-  *((__IO uint32_t*)0x51008108) = 0x00000001;
-  #endif
-
-  /* Configure the Vector Table location add offset address ------------------*/
-#ifdef MICROPY_HW_VTOR
-  SCB->VTOR = MICROPY_HW_VTOR;
-#else
-#ifdef VECT_TAB_SRAM
-  SCB->VTOR = SRAM1_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal SRAM */
-#else
-  SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal FLASH */
-#endif
-#endif
-
-  /* dpgeorge: enable 8-byte stack alignment for IRQ handlers, in accord with EABI */
-  SCB->CCR |= SCB_CCR_STKALIGN_Msk;
-}
+#if defined(STM32F4) || defined(STM32F7) || defined(STM32H7) || defined(STM32L4)
 
+void __fatal_error(const char *msg);
 
 /**
   * @brief  System Clock Configuration
@@ -372,8 +163,7 @@ void SystemInit(void)
   *
   * Timers run from APBx if APBx_PRESC=1, else 2x APBx
   */
-void SystemClock_Config(void)
-{
+void SystemClock_Config(void) {
     #if defined(STM32F7)
     // The DFU bootloader changes the clocksource register from its default power
     // on reset value, so we set it back here, so the clocksources are the same
@@ -422,12 +212,31 @@ void SystemClock_Config(void)
     #endif
     RCC_OscInitStruct.PLL.PLLSource = MICROPY_HW_RCC_PLL_SRC;
     #elif defined(STM32L4)
-    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE|RCC_OSCILLATORTYPE_MSI;
-    RCC_OscInitStruct.LSEState = RCC_LSE_ON;
+
+    #if MICROPY_HW_CLK_USE_HSE
+    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
+    RCC_OscInitStruct.HSEState = RCC_HSE_ON;
+    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
+    RCC_OscInitStruct.PLL.PLLM = MICROPY_HW_CLK_PLLM;
+    RCC_OscInitStruct.PLL.PLLN = MICROPY_HW_CLK_PLLN;
+    RCC_OscInitStruct.PLL.PLLP = MICROPY_HW_CLK_PLLP;
+    RCC_OscInitStruct.PLL.PLLQ = MICROPY_HW_CLK_PLLQ;
+    RCC_OscInitStruct.PLL.PLLR = MICROPY_HW_CLK_PLLR;
+    RCC_OscInitStruct.MSIState = RCC_MSI_OFF;
+    #else
+    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE | RCC_OSCILLATORTYPE_MSI;
     RCC_OscInitStruct.MSIState = RCC_MSI_ON;
     RCC_OscInitStruct.MSICalibrationValue = RCC_MSICALIBRATION_DEFAULT;
     RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_6;
     RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_MSI;
+    #endif
+
+    #if MICROPY_HW_RTC_USE_LSE
+    RCC_OscInitStruct.LSEState = RCC_LSE_ON;
+    #else
+    RCC_OscInitStruct.LSEState = RCC_LSE_OFF;
+    #endif
+
     #endif
     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
     /* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2
@@ -437,7 +246,7 @@ void SystemClock_Config(void)
     RCC_ClkInitStruct.ClockType |= (RCC_CLOCKTYPE_D3PCLK1 | RCC_CLOCKTYPE_D1PCLK1);
     #endif
 
-#if defined(MICROPY_HW_CLK_LAST_FREQ) && MICROPY_HW_CLK_LAST_FREQ
+    #if defined(MICROPY_HW_CLK_LAST_FREQ) && MICROPY_HW_CLK_LAST_FREQ
     #if defined(STM32F7)
     #define FREQ_BKP BKP31R
     #elif defined(STM32L4)
@@ -455,7 +264,7 @@ void SystemClock_Config(void)
     uint32_t b1 = (m >> 26) & 0x7;
     uint32_t b2 = (m >> 29) & 0x7;
     q = (m >> 18) & 0xf;
-    p = (((m >> 16) & 0x03)+1)*2;
+    p = (((m >> 16) & 0x03) + 1) * 2;
     n = (m >> 6) & 0x3ff;
     m &= 0x3f;
     if ((q < 2) || (q > 15) || (p > 8) || (p < 2) || (n < 192) || (n >= 433) || (m < 2)) {
@@ -471,15 +280,15 @@ void SystemClock_Config(void)
         b1 <<= 10;
         b2 <<= 10;
     }
-    RCC_OscInitStruct.PLL.PLLM = m; //MICROPY_HW_CLK_PLLM;
-    RCC_OscInitStruct.PLL.PLLN = n; //MICROPY_HW_CLK_PLLN;
-    RCC_OscInitStruct.PLL.PLLP = p; //MICROPY_HW_CLK_PLLP;
-    RCC_OscInitStruct.PLL.PLLQ = q; //MICROPY_HW_CLK_PLLQ;
-
-    RCC_ClkInitStruct.AHBCLKDivider = h;  //RCC_SYSCLK_DIV1;
-    RCC_ClkInitStruct.APB1CLKDivider = b1; //RCC_HCLK_DIV4;
-    RCC_ClkInitStruct.APB2CLKDivider = b2; //RCC_HCLK_DIV2;
-#else // defined(MICROPY_HW_CLK_LAST_FREQ) && MICROPY_HW_CLK_LAST_FREQ
+    RCC_OscInitStruct.PLL.PLLM = m; // MICROPY_HW_CLK_PLLM;
+    RCC_OscInitStruct.PLL.PLLN = n; // MICROPY_HW_CLK_PLLN;
+    RCC_OscInitStruct.PLL.PLLP = p; // MICROPY_HW_CLK_PLLP;
+    RCC_OscInitStruct.PLL.PLLQ = q; // MICROPY_HW_CLK_PLLQ;
+
+    RCC_ClkInitStruct.AHBCLKDivider = h; // RCC_SYSCLK_DIV1;
+    RCC_ClkInitStruct.APB1CLKDivider = b1; // RCC_HCLK_DIV4;
+    RCC_ClkInitStruct.APB2CLKDivider = b2; // RCC_HCLK_DIV2;
+    #else // defined(MICROPY_HW_CLK_LAST_FREQ) && MICROPY_HW_CLK_LAST_FREQ
     RCC_OscInitStruct.PLL.PLLM = MICROPY_HW_CLK_PLLM;
     RCC_OscInitStruct.PLL.PLLN = MICROPY_HW_CLK_PLLN;
     RCC_OscInitStruct.PLL.PLLP = MICROPY_HW_CLK_PLLP;
@@ -495,28 +304,28 @@ void SystemClock_Config(void)
     #endif
 
     #if defined(STM32F4) || defined(STM32F7)
-    RCC_ClkInitStruct.AHBCLKDivider  = RCC_SYSCLK_DIV1;
+    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
     RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
     #elif defined(STM32L4)
-    RCC_ClkInitStruct.AHBCLKDivider  = RCC_SYSCLK_DIV1;
+    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
     RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
     #elif defined(STM32H7)
-    RCC_ClkInitStruct.SYSCLKDivider  = RCC_SYSCLK_DIV1;
-    RCC_ClkInitStruct.AHBCLKDivider  = RCC_HCLK_DIV2;
+    RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
+    RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
     RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;
     RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
     RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
     RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;
     #endif
-#endif
+    #endif
 
-    if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
-      __fatal_error("HAL_RCC_OscConfig");
+    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
+        __fatal_error("HAL_RCC_OscConfig");
     }
 
-#if defined(STM32H7)
+    #if defined(STM32H7)
     /* PLL3 for USB Clock */
     PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USB;
     PeriphClkInitStruct.UsbClockSelection = RCC_USBCLKSOURCE_PLL3;
@@ -531,15 +340,14 @@ void SystemClock_Config(void)
     if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK) {
         __fatal_error("HAL_RCCEx_PeriphCLKConfig");
     }
-#endif
+    #endif
 
-#if defined(STM32F7)
-  /* Activate the OverDrive to reach the 200 MHz Frequency */
-  if (HAL_PWREx_EnableOverDrive() != HAL_OK)
-  {
-    __fatal_error("HAL_PWREx_EnableOverDrive");
-  }
-#endif
+    #if defined(STM32F7)
+    /* Activate the OverDrive to reach the 200 MHz Frequency */
+    if (HAL_PWREx_EnableOverDrive() != HAL_OK) {
+        __fatal_error("HAL_PWREx_EnableOverDrive");
+    }
+    #endif
 
     uint32_t vco_out = RCC_OscInitStruct.PLL.PLLN * (MICROPY_HW_CLK_VALUE / 1000000) / RCC_OscInitStruct.PLL.PLLM;
     uint32_t sysclk_mhz = vco_out / RCC_OscInitStruct.PLL.PLLP;
@@ -548,49 +356,64 @@ void SystemClock_Config(void)
         __fatal_error("HAL_RCC_ClockConfig");
     }
 
-#if defined(STM32H7)
-  /* Activate CSI clock mandatory for I/O Compensation Cell*/
-  __HAL_RCC_CSI_ENABLE() ;
+    #if defined(STM32H7)
+    /* Activate CSI clock mandatory for I/O Compensation Cell*/
+    __HAL_RCC_CSI_ENABLE();
 
-  /* Enable SYSCFG clock mandatory for I/O Compensation Cell */
-  __HAL_RCC_SYSCFG_CLK_ENABLE() ;
+    /* Enable SYSCFG clock mandatory for I/O Compensation Cell */
+    __HAL_RCC_SYSCFG_CLK_ENABLE();
 
-  /* Enable the I/O Compensation Cell */
-  HAL_EnableCompensationCell();
+    /* Enable the I/O Compensation Cell */
+    HAL_EnableCompensationCell();
 
-  /* Enable the USB voltage level detector */
-  HAL_PWREx_EnableUSBVoltageDetector();
-#endif
+    /* Enable the USB voltage level detector */
+    HAL_PWREx_EnableUSBVoltageDetector();
+    #endif
 
-#if defined(STM32L4)
+    #if defined(STM32L4)
     // Enable MSI-Hardware auto calibration mode with LSE
     HAL_RCCEx_EnableMSIPLLMode();
 
     RCC_PeriphCLKInitTypeDef PeriphClkInitStruct;
-    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_SAI1|RCC_PERIPHCLK_I2C1
-                                              |RCC_PERIPHCLK_USB |RCC_PERIPHCLK_ADC
-                                              |RCC_PERIPHCLK_RNG |RCC_PERIPHCLK_RTC;
+    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_SAI1 | RCC_PERIPHCLK_I2C1
+        | RCC_PERIPHCLK_USB | RCC_PERIPHCLK_ADC
+        | RCC_PERIPHCLK_RNG | RCC_PERIPHCLK_RTC;
     PeriphClkInitStruct.I2c1ClockSelection = RCC_I2C1CLKSOURCE_PCLK1;
-    /* PLLSAI is used to clock USB, ADC, I2C1 and RNG. The frequency is
-       MSI(4MHz)/PLLM(1)*PLLSAI1N(24)/PLLSAIQ(2) = 48MHz. See the STM32CubeMx
-       application or the reference manual. */
+
     PeriphClkInitStruct.Sai1ClockSelection = RCC_SAI1CLKSOURCE_PLLSAI1;
     PeriphClkInitStruct.AdcClockSelection = RCC_ADCCLKSOURCE_PLLSAI1;
     PeriphClkInitStruct.UsbClockSelection = RCC_USBCLKSOURCE_PLLSAI1;
-    PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
     PeriphClkInitStruct.RngClockSelection = RCC_RNGCLKSOURCE_PLLSAI1;
+
+    #if MICROPY_HW_RTC_USE_LSE
+    PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
+    #else
+    PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
+    #endif
+
+    #if MICROPY_HW_CLK_USE_HSE
+    PeriphClkInitStruct.PLLSAI1.PLLSAI1Source = RCC_PLLSOURCE_HSE;
+    PeriphClkInitStruct.PLLSAI1.PLLSAI1M = 1; // MICROPY_HW_CLK_PLLSAIM;
+    PeriphClkInitStruct.PLLSAI1.PLLSAI1N = MICROPY_HW_CLK_PLLSAIN;
+    PeriphClkInitStruct.PLLSAI1.PLLSAI1P = MICROPY_HW_CLK_PLLSAIP;
+    PeriphClkInitStruct.PLLSAI1.PLLSAI1Q = MICROPY_HW_CLK_PLLSAIQ;
+    PeriphClkInitStruct.PLLSAI1.PLLSAI1R = MICROPY_HW_CLK_PLLSAIR;
+    #else
+    /* PLLSAI is used to clock USB, ADC, I2C1 and RNG. The frequency is
+       MSI(4MHz)/PLLM(1)*PLLSAI1N(24)/PLLSAIQ(2) = 48MHz. See the STM32CubeMx
+       application or the reference manual. */
     PeriphClkInitStruct.PLLSAI1.PLLSAI1Source = RCC_PLLSOURCE_MSI;
     PeriphClkInitStruct.PLLSAI1.PLLSAI1M = 1;
     PeriphClkInitStruct.PLLSAI1.PLLSAI1N = 24;
     PeriphClkInitStruct.PLLSAI1.PLLSAI1P = RCC_PLLP_DIV7;
     PeriphClkInitStruct.PLLSAI1.PLLSAI1Q = RCC_PLLQ_DIV2;
     PeriphClkInitStruct.PLLSAI1.PLLSAI1R = RCC_PLLR_DIV2;
+    #endif
     PeriphClkInitStruct.PLLSAI1.PLLSAI1ClockOut = RCC_PLLSAI1_SAI1CLK
-                                                 |RCC_PLLSAI1_48M2CLK
-                                                 |RCC_PLLSAI1_ADC1CLK;
+        | RCC_PLLSAI1_48M2CLK
+        | RCC_PLLSAI1_ADC1CLK;
 
-    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
-    {
+    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK) {
         __fatal_error("HAL_RCCEx_PeriphCLKConfig");
     }
 
@@ -598,8 +421,10 @@ void SystemClock_Config(void)
 
     HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);
 
-    HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
+    HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq() / 1000);
     HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
     NVIC_SetPriority(SysTick_IRQn, NVIC_EncodePriority(NVIC_PRIORITYGROUP_4, TICK_INT_PRIORITY, 0));
-#endif
+    #endif
 }
+
+#endif
diff --git a/ports/stm32/system_stm32f0.c b/ports/stm32/system_stm32f0.c
deleted file mode 100644
index 9d4b06e56821d..0000000000000
--- a/ports/stm32/system_stm32f0.c
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * This file is part of the MicroPython project, http://micropython.org/
- *
- * Taken from ST Cube library and modified.  See below for original header.
- */
-
-/**
-  ******************************************************************************
-  * @file    system_stm32f0xx.c
-  * @author  MCD Application Team
-  * @brief   CMSIS Cortex-M0 Device Peripheral Access Layer System Source File.
-  *
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without modification,
-  * are permitted provided that the following conditions are met:
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
-
-#include STM32_HAL_H
-
-#ifndef HSE_VALUE
-#define HSE_VALUE (8000000)
-#endif
-
-#ifndef HSI_VALUE
-#define HSI_VALUE (8000000)
-#endif
-
-#ifndef HSI48_VALUE
-#define HSI48_VALUE (48000000)
-#endif
-
-/* This variable is updated in three ways:
-  1) by calling CMSIS function SystemCoreClockUpdate()
-  2) by calling HAL API function HAL_RCC_GetHCLKFreq()
-  3) each time HAL_RCC_ClockConfig() is called to configure the system clock frequency
-     Note: If you use this function to configure the system clock there is no need to
-           call the 2 first functions listed above, since SystemCoreClock variable is
-           updated automatically.
-*/
-uint32_t SystemCoreClock = 8000000;
-
-const uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9};
-const uint8_t APBPrescTable[8]  = {0, 0, 0, 0, 1, 2, 3, 4};
-
-void SystemInit(void) {
-    // Set HSION bit
-    RCC->CR |= (uint32_t)0x00000001U;
-
-    #if defined(STM32F051x8) || defined(STM32F058x8)
-    // Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE and MCOSEL[2:0] bits
-    RCC->CFGR &= (uint32_t)0xF8FFB80CU;
-    #else
-    // Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE, MCOSEL[2:0], MCOPRE[2:0] and PLLNODIV bits
-    RCC->CFGR &= (uint32_t)0x08FFB80CU;
-    #endif
-
-    // Reset HSEON, CSSON and PLLON bits
-    RCC->CR &= (uint32_t)0xFEF6FFFFU;
-
-    // Reset HSEBYP bit
-    RCC->CR &= (uint32_t)0xFFFBFFFFU;
-
-    // Reset PLLSRC, PLLXTPRE and PLLMUL[3:0] bits
-    RCC->CFGR &= (uint32_t)0xFFC0FFFFU;
-
-    // Reset PREDIV[3:0] bits
-    RCC->CFGR2 &= (uint32_t)0xFFFFFFF0U;
-
-    #if defined(STM32F072xB) || defined(STM32F078xx)
-    // Reset USART2SW[1:0], USART1SW[1:0], I2C1SW, CECSW, USBSW and ADCSW bits
-    RCC->CFGR3 &= (uint32_t)0xFFFCFE2CU;
-    #elif defined(STM32F071xB)
-    // Reset USART2SW[1:0], USART1SW[1:0], I2C1SW, CECSW and ADCSW bits
-    RCC->CFGR3 &= (uint32_t)0xFFFFCEACU;
-    #elif defined(STM32F091xC) || defined(STM32F098xx)
-    // Reset USART3SW[1:0], USART2SW[1:0], USART1SW[1:0], I2C1SW, CECSW and ADCSW bits
-    RCC->CFGR3 &= (uint32_t)0xFFF0FEACU;
-    #elif defined(STM32F030x6) || defined(STM32F030x8) || defined(STM32F031x6) || defined(STM32F038xx) || defined(STM32F030xC)
-    // Reset USART1SW[1:0], I2C1SW and ADCSW bits
-    RCC->CFGR3 &= (uint32_t)0xFFFFFEECU;
-    #elif defined(STM32F051x8) || defined(STM32F058xx)
-    // Reset USART1SW[1:0], I2C1SW, CECSW and ADCSW bits
-    RCC->CFGR3 &= (uint32_t)0xFFFFFEACU;
-    #elif defined(STM32F042x6) || defined(STM32F048xx)
-    // Reset USART1SW[1:0], I2C1SW, CECSW, USBSW and ADCSW bits
-    RCC->CFGR3 &= (uint32_t)0xFFFFFE2CU;
-    #elif defined(STM32F070x6) || defined(STM32F070xB)
-    // Reset USART1SW[1:0], I2C1SW, USBSW and ADCSW bits
-    RCC->CFGR3 &= (uint32_t)0xFFFFFE6CU;
-    // Set default USB clock to PLLCLK, since there is no HSI48
-    RCC->CFGR3 |= (uint32_t)0x00000080U;
-    #else
-    #warning "No target selected"
-    #endif
-
-    // Reset HSI14 bit
-    RCC->CR2 &= (uint32_t)0xFFFFFFFEU;
-
-    // Disable all interrupts
-    RCC->CIR = 0x00000000U;
-
-    // dpgeorge: enable 8-byte stack alignment for IRQ handlers, in accord with EABI
-    SCB->CCR |= SCB_CCR_STKALIGN_Msk;
-}
-
-void SystemClock_Config(void) {
-    // Set flash latency to 1 because SYSCLK > 24MHz
-    FLASH->ACR = (FLASH->ACR & ~0x7) | 0x1;
-
-    // Use the 48MHz internal oscillator
-    RCC->CR2 |= RCC_CR2_HSI48ON;
-    while ((RCC->CR2 & RCC_CR2_HSI48RDY) == 0) {
-    }
-    RCC->CFGR |= 3 << RCC_CFGR_SW_Pos;
-    while (((RCC->CFGR >> RCC_CFGR_SWS_Pos) & 0x3) != 0x03) {
-        // Wait for SYSCLK source to change
-    }
-
-    SystemCoreClockUpdate();
-
-    HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq() / 1000);
-    HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
-}
-
-void SystemCoreClockUpdate(void) {
-    // Get SYSCLK source
-    uint32_t tmp = RCC->CFGR & RCC_CFGR_SWS;
-
-    switch (tmp) {
-        case RCC_CFGR_SWS_HSI:
-            SystemCoreClock = HSI_VALUE;
-            break;
-        case RCC_CFGR_SWS_HSE:
-            SystemCoreClock = HSE_VALUE;
-            break;
-        case RCC_CFGR_SWS_PLL: {
-            /* Get PLL clock source and multiplication factor */
-            uint32_t pllmull = RCC->CFGR & RCC_CFGR_PLLMUL;
-            uint32_t pllsource = RCC->CFGR & RCC_CFGR_PLLSRC;
-            pllmull = (pllmull >> 18) + 2;
-            uint32_t predivfactor = (RCC->CFGR2 & RCC_CFGR2_PREDIV) + 1;
-
-            if (pllsource == RCC_CFGR_PLLSRC_HSE_PREDIV) {
-                /* HSE used as PLL clock source : SystemCoreClock = HSE/PREDIV * PLLMUL */
-                SystemCoreClock = (HSE_VALUE/predivfactor) * pllmull;
-            #if defined(STM32F042x6) || defined(STM32F048xx) || defined(STM32F072xB) \
-                || defined(STM32F078xx) || defined(STM32F091xC) || defined(STM32F098xx)
-            } else if (pllsource == RCC_CFGR_PLLSRC_HSI48_PREDIV) {
-                /* HSI48 used as PLL clock source : SystemCoreClock = HSI48/PREDIV * PLLMUL */
-                SystemCoreClock = (HSI48_VALUE/predivfactor) * pllmull;
-            #endif
-            } else {
-                #if defined(STM32F042x6) || defined(STM32F048xx)  || defined(STM32F070x6) \
-                    || defined(STM32F078xx) || defined(STM32F071xB)  || defined(STM32F072xB) \
-                    || defined(STM32F070xB) || defined(STM32F091xC) || defined(STM32F098xx)  || defined(STM32F030xC)
-                /* HSI used as PLL clock source : SystemCoreClock = HSI/PREDIV * PLLMUL */
-                SystemCoreClock = (HSI_VALUE / predivfactor) * pllmull;
-                #else
-                /* HSI used as PLL clock source : SystemCoreClock = HSI/2 * PLLMUL */
-                SystemCoreClock = (HSI_VALUE >> 1) * pllmull;
-                #endif
-            }
-            break;
-        }
-        case RCC_CFGR_SWS_HSI48:
-            SystemCoreClock = HSI48_VALUE;
-            break;
-        default:
-            SystemCoreClock = HSI_VALUE;
-            break;
-    }
-
-    // Compute HCLK clock frequency
-    tmp = AHBPrescTable[((RCC->CFGR & RCC_CFGR_HPRE) >> 4)];
-    SystemCoreClock >>= tmp;
-}
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
diff --git a/ports/stm32/systick.c b/ports/stm32/systick.c
index d92f9d75dcf62..d70fc005395c3 100644
--- a/ports/stm32/systick.c
+++ b/ports/stm32/systick.c
@@ -27,7 +27,9 @@
 #include "py/runtime.h"
 #include "py/mphal.h"
 #include "irq.h"
+#include "pendsv.h"
 #include "systick.h"
+#include "softtimer.h"
 #include "pybthread.h"
 
 extern __IO uint32_t uwTick;
@@ -52,6 +54,10 @@ void SysTick_Handler(void) {
         f(uw_tick);
     }
 
+    if (soft_timer_next == uw_tick) {
+        pendsv_schedule_dispatch(PENDSV_DISPATCH_SOFT_TIMER, soft_timer_handler);
+    }
+
     #if MICROPY_PY_THREAD
     if (pyb_thread_enabled) {
         if (pyb_thread_cur->timeslice == 0) {
@@ -148,7 +154,7 @@ mp_uint_t mp_hal_ticks_us(void) {
     mp_uint_t irq_state = disable_irq();
     uint32_t counter = SysTick->VAL;
     uint32_t milliseconds = HAL_GetTick();
-    uint32_t status  = SysTick->CTRL;
+    uint32_t status = SysTick->CTRL;
     enable_irq(irq_state);
 
     // It's still possible for the countflag bit to get set if the counter was
diff --git a/ports/stm32/systick.h b/ports/stm32/systick.h
index 6a05a4990ac6a..6aef3f2e4e731 100644
--- a/ports/stm32/systick.h
+++ b/ports/stm32/systick.h
@@ -37,6 +37,9 @@ enum {
     #if MICROPY_PY_NETWORK && MICROPY_PY_LWIP
     SYSTICK_DISPATCH_LWIP,
     #endif
+    #if MICROPY_PY_BLUETOOTH
+    SYSTICK_DISPATCH_BLUETOOTH_HCI,
+    #endif
     SYSTICK_DISPATCH_MAX
 };
 
diff --git a/ports/stm32/timer.c b/ports/stm32/timer.c
index b3bb92f2e5ad1..491221ec2a7de 100644
--- a/ports/stm32/timer.c
+++ b/ports/stm32/timer.c
@@ -25,7 +25,6 @@
  */
 
 #include <stdint.h>
-#include <stdio.h>
 #include <string.h>
 
 #include "py/runtime.h"
@@ -95,8 +94,8 @@ typedef enum {
 } pyb_channel_mode;
 
 STATIC const struct {
-    qstr        name;
-    uint32_t    oc_mode;
+    qstr name;
+    uint32_t oc_mode;
 } channel_mode_info[] = {
     { MP_QSTR_PWM,                TIM_OCMODE_PWM1 },
     { MP_QSTR_PWM_INVERTED,       TIM_OCMODE_PWM2 },
@@ -282,22 +281,22 @@ STATIC uint32_t compute_prescaler_period_from_freq(pyb_timer_obj_t *self, mp_obj
     if (0) {
     #if MICROPY_PY_BUILTINS_FLOAT
     } else if (mp_obj_is_type(freq_in, &mp_type_float)) {
-        float freq = mp_obj_get_float(freq_in);
+        float freq = mp_obj_get_float_to_f(freq_in);
         if (freq <= 0) {
             goto bad_freq;
         }
         while (freq < 1 && prescaler < 6553) {
             prescaler *= 10;
-            freq *= 10;
+            freq *= 10.0f;
         }
-        period = (float)source_freq / freq;
+        period = (uint32_t)((float)source_freq / freq);
     #endif
     } else {
         mp_int_t freq = mp_obj_get_int(freq_in);
         if (freq <= 0) {
             goto bad_freq;
-            bad_freq:
-            mp_raise_ValueError("must have positive freq");
+        bad_freq:
+            mp_raise_ValueError(MP_ERROR_TEXT("must have positive freq"));
         }
         period = source_freq / freq;
     }
@@ -324,7 +323,7 @@ STATIC uint32_t compute_prescaler_period_from_freq(pyb_timer_obj_t *self, mp_obj
 STATIC uint32_t compute_prescaler_period_from_t(pyb_timer_obj_t *self, int32_t t_num, int32_t t_den, uint32_t *period_out) {
     uint32_t source_freq = timer_get_source_freq(self->tim_id);
     if (t_num <= 0 || t_den <= 0) {
-        mp_raise_ValueError("must have positive freq");
+        mp_raise_ValueError(MP_ERROR_TEXT("must have positive freq"));
     }
     uint64_t period = (uint64_t)source_freq * (uint64_t)t_num / (uint64_t)t_den;
     uint32_t prescaler = 1;
@@ -346,7 +345,7 @@ STATIC uint32_t compute_prescaler_period_from_t(pyb_timer_obj_t *self, int32_t t
                 prescaler |= period_lsb;
             }
             if (prescaler > 0x10000) {
-                mp_raise_ValueError("period too large");
+                mp_raise_ValueError(MP_ERROR_TEXT("period too large"));
             }
         }
     }
@@ -383,7 +382,7 @@ STATIC uint32_t compute_pwm_value_from_percent(uint32_t period, mp_obj_t percent
         } else if (percent >= 100.0) {
             cmp = period;
         } else {
-            cmp = percent / 100.0 * ((mp_float_t)period);
+            cmp = (uint32_t)(percent / MICROPY_FLOAT_CONST(100.0) * ((mp_float_t)period));
         }
     #endif
     } else {
@@ -427,6 +426,8 @@ STATIC mp_obj_t compute_percent_from_pwm_value(uint32_t period, uint32_t cmp) {
     #endif
 }
 
+#if !defined(STM32L0)
+
 // Computes the 8-bit value for the DTG field in the BDTR register.
 //
 // 1 tick = 1 count of the timer's clock (source_freq) divided by div.
@@ -470,19 +471,27 @@ STATIC mp_int_t compute_ticks_from_dtg(uint32_t dtg) {
 
 STATIC void config_deadtime(pyb_timer_obj_t *self, mp_int_t ticks, mp_int_t brk) {
     TIM_BreakDeadTimeConfigTypeDef deadTimeConfig;
-    deadTimeConfig.OffStateRunMode  = TIM_OSSR_DISABLE;
+    deadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
     deadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
-    deadTimeConfig.LockLevel        = TIM_LOCKLEVEL_OFF;
-    deadTimeConfig.DeadTime         = compute_dtg_from_ticks(ticks);
-    deadTimeConfig.BreakState       = brk == BRK_OFF ? TIM_BREAK_DISABLE : TIM_BREAK_ENABLE;
-    deadTimeConfig.BreakPolarity    = brk == BRK_LOW ? TIM_BREAKPOLARITY_LOW : TIM_BREAKPOLARITY_HIGH;
-    deadTimeConfig.AutomaticOutput  = TIM_AUTOMATICOUTPUT_DISABLE;
+    deadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
+    deadTimeConfig.DeadTime = compute_dtg_from_ticks(ticks);
+    deadTimeConfig.BreakState = brk == BRK_OFF ? TIM_BREAK_DISABLE : TIM_BREAK_ENABLE;
+    deadTimeConfig.BreakPolarity = brk == BRK_LOW ? TIM_BREAKPOLARITY_LOW : TIM_BREAKPOLARITY_HIGH;
+    #if defined(STM32F7) || defined(STM32H7) | defined(STM32L4)
+    deadTimeConfig.BreakFilter = 0;
+    deadTimeConfig.Break2State = TIM_BREAK_DISABLE;
+    deadTimeConfig.Break2Polarity = TIM_BREAKPOLARITY_LOW;
+    deadTimeConfig.Break2Filter = 0;
+    #endif
+    deadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
     HAL_TIMEx_ConfigBreakDeadTime(&self->tim, &deadTimeConfig);
 }
 
+#endif
+
 TIM_HandleTypeDef *pyb_timer_get_handle(mp_obj_t timer) {
     if (mp_obj_get_type(timer) != &pyb_timer_type) {
-        mp_raise_ValueError("need a Timer object");
+        mp_raise_ValueError(MP_ERROR_TEXT("need a Timer object"));
     }
     pyb_timer_obj_t *self = MP_OBJ_TO_PTR(timer);
     return &self->tim;
@@ -508,6 +517,7 @@ STATIC void pyb_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_
             self->tim.Init.ClockDivision == TIM_CLOCKDIVISION_DIV4 ? 4 :
             self->tim.Init.ClockDivision == TIM_CLOCKDIVISION_DIV2 ? 2 : 1);
 
+        #if !defined(STM32L0)
         #if defined(IS_TIM_ADVANCED_INSTANCE)
         if (IS_TIM_ADVANCED_INSTANCE(self->tim.Instance))
         #elif defined(IS_TIM_BREAK_INSTANCE)
@@ -525,6 +535,7 @@ STATIC void pyb_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_
                 mp_printf(print, ", brk=BRK_OFF");
             }
         }
+        #endif
         mp_print_str(print, ")");
     }
 }
@@ -583,13 +594,13 @@ STATIC void pyb_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_
 STATIC mp_obj_t pyb_timer_init_helper(pyb_timer_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     enum { ARG_freq, ARG_prescaler, ARG_period, ARG_tick_hz, ARG_mode, ARG_div, ARG_callback, ARG_deadtime, ARG_brk };
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_freq,         MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_freq,         MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
         { MP_QSTR_prescaler,    MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0xffffffff} },
         { MP_QSTR_period,       MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0xffffffff} },
         { MP_QSTR_tick_hz,      MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1000} },
         { MP_QSTR_mode,         MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = TIM_COUNTERMODE_UP} },
         { MP_QSTR_div,          MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} },
-        { MP_QSTR_callback,     MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_callback,     MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
         { MP_QSTR_deadtime,     MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_brk,          MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = BRK_OFF} },
     };
@@ -612,68 +623,131 @@ STATIC mp_obj_t pyb_timer_init_helper(pyb_timer_obj_t *self, size_t n_args, cons
         // set prescaler and period from desired period and tick_hz scale
         init->Prescaler = compute_prescaler_period_from_t(self, args[ARG_period].u_int, args[ARG_tick_hz].u_int, &init->Period);
     } else {
-        mp_raise_TypeError("must specify either freq, period, or prescaler and period");
+        mp_raise_TypeError(MP_ERROR_TEXT("must specify either freq, period, or prescaler and period"));
     }
 
     init->CounterMode = args[ARG_mode].u_int;
     if (!IS_TIM_COUNTER_MODE(init->CounterMode)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid mode (%d)", init->CounterMode));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("invalid mode (%d)"), init->CounterMode);
     }
 
     init->ClockDivision = args[ARG_div].u_int == 2 ? TIM_CLOCKDIVISION_DIV2 :
-                          args[ARG_div].u_int == 4 ? TIM_CLOCKDIVISION_DIV4 :
-                                                     TIM_CLOCKDIVISION_DIV1;
+        args[ARG_div].u_int == 4 ? TIM_CLOCKDIVISION_DIV4 :
+        TIM_CLOCKDIVISION_DIV1;
 
+    #if !defined(STM32L0)
     init->RepetitionCounter = 0;
+    #endif
 
     // enable TIM clock
     switch (self->tim_id) {
-        case 1: __HAL_RCC_TIM1_CLK_ENABLE(); break;
-        case 2: __HAL_RCC_TIM2_CLK_ENABLE(); break;
+        #if defined(TIM1)
+        case 1:
+            __HAL_RCC_TIM1_CLK_ENABLE();
+            break;
+        #endif
+        case 2:
+            __HAL_RCC_TIM2_CLK_ENABLE();
+            break;
         #if defined(TIM3)
-        case 3: __HAL_RCC_TIM3_CLK_ENABLE(); break;
+        case 3:
+            __HAL_RCC_TIM3_CLK_ENABLE();
+            break;
         #endif
         #if defined(TIM4)
-        case 4: __HAL_RCC_TIM4_CLK_ENABLE(); break;
+        case 4:
+            __HAL_RCC_TIM4_CLK_ENABLE();
+            break;
         #endif
         #if defined(TIM5)
-        case 5: __HAL_RCC_TIM5_CLK_ENABLE(); break;
+        case 5:
+            __HAL_RCC_TIM5_CLK_ENABLE();
+            break;
         #endif
         #if defined(TIM6)
-        case 6: __HAL_RCC_TIM6_CLK_ENABLE(); break;
+        case 6:
+            __HAL_RCC_TIM6_CLK_ENABLE();
+            break;
         #endif
         #if defined(TIM7)
-        case 7: __HAL_RCC_TIM7_CLK_ENABLE(); break;
+        case 7:
+            __HAL_RCC_TIM7_CLK_ENABLE();
+            break;
         #endif
         #if defined(TIM8)
-        case 8: __HAL_RCC_TIM8_CLK_ENABLE(); break;
+        case 8:
+            __HAL_RCC_TIM8_CLK_ENABLE();
+            break;
         #endif
         #if defined(TIM9)
-        case 9: __HAL_RCC_TIM9_CLK_ENABLE(); break;
+        case 9:
+            __HAL_RCC_TIM9_CLK_ENABLE();
+            break;
         #endif
         #if defined(TIM10)
-        case 10: __HAL_RCC_TIM10_CLK_ENABLE(); break;
+        case 10:
+            __HAL_RCC_TIM10_CLK_ENABLE();
+            break;
         #endif
         #if defined(TIM11)
-        case 11: __HAL_RCC_TIM11_CLK_ENABLE(); break;
+        case 11:
+            __HAL_RCC_TIM11_CLK_ENABLE();
+            break;
         #endif
         #if defined(TIM12)
-        case 12: __HAL_RCC_TIM12_CLK_ENABLE(); break;
+        case 12:
+            __HAL_RCC_TIM12_CLK_ENABLE();
+            break;
         #endif
         #if defined(TIM13)
-        case 13: __HAL_RCC_TIM13_CLK_ENABLE(); break;
+        case 13:
+            __HAL_RCC_TIM13_CLK_ENABLE();
+            break;
         #endif
         #if defined(TIM14)
-        case 14: __HAL_RCC_TIM14_CLK_ENABLE(); break;
+        case 14:
+            __HAL_RCC_TIM14_CLK_ENABLE();
+            break;
         #endif
         #if defined(TIM15)
-        case 15: __HAL_RCC_TIM15_CLK_ENABLE(); break;
+        case 15:
+            __HAL_RCC_TIM15_CLK_ENABLE();
+            break;
         #endif
         #if defined(TIM16)
-        case 16: __HAL_RCC_TIM16_CLK_ENABLE(); break;
+        case 16:
+            __HAL_RCC_TIM16_CLK_ENABLE();
+            break;
         #endif
         #if defined(TIM17)
-        case 17: __HAL_RCC_TIM17_CLK_ENABLE(); break;
+        case 17:
+            __HAL_RCC_TIM17_CLK_ENABLE();
+            break;
+        #endif
+        #if defined(TIM18)
+        case 18:
+            __HAL_RCC_TIM18_CLK_ENABLE();
+            break;
+        #endif
+        #if defined(TIM19)
+        case 19:
+            __HAL_RCC_TIM19_CLK_ENABLE();
+            break;
+        #endif
+        #if defined(TIM20)
+        case 20:
+            __HAL_RCC_TIM20_CLK_ENABLE();
+            break;
+        #endif
+        #if defined(TIM21)
+        case 21:
+            __HAL_RCC_TIM21_CLK_ENABLE();
+            break;
+        #endif
+        #if defined(TIM22)
+        case 22:
+            __HAL_RCC_TIM22_CLK_ENABLE();
+            break;
         #endif
     }
 
@@ -681,26 +755,30 @@ STATIC mp_obj_t pyb_timer_init_helper(pyb_timer_obj_t *self, size_t n_args, cons
     if (self->tim_id != 5) {
         NVIC_SetPriority(IRQn_NONNEG(self->irqn), IRQ_PRI_TIMX);
         if (self->tim_id == 1) {
+            #if defined(TIM1)
             NVIC_SetPriority(TIM1_CC_IRQn, IRQ_PRI_TIMX);
-        #if defined(TIM8)
+            #endif
         } else if (self->tim_id == 8) {
+            #if defined(TIM8)
             NVIC_SetPriority(TIM8_CC_IRQn, IRQ_PRI_TIMX);
-        #endif
+            #endif
         }
     }
 
     // init TIM
     HAL_TIM_Base_Init(&self->tim);
+    #if !defined(STM32L0)
     #if defined(IS_TIM_ADVANCED_INSTANCE)
     if (IS_TIM_ADVANCED_INSTANCE(self->tim.Instance)) {
     #elif defined(IS_TIM_BREAK_INSTANCE)
     if (IS_TIM_BREAK_INSTANCE(self->tim.Instance)) {
     #else
     if (0) {
-    #endif
+        #endif
         config_deadtime(self, args[ARG_deadtime].u_int, args[ARG_brk].u_int);
 
     }
+    #endif
 
     // Enable ARPE so that the auto-reload register is buffered.
     // This allows to smoothly change the frequency of the timer.
@@ -720,13 +798,17 @@ STATIC mp_obj_t pyb_timer_init_helper(pyb_timer_obj_t *self, size_t n_args, cons
 // It assumes that timer instance pointer has the lower 8 bits cleared.
 #define TIM_ENTRY(id, irq) [id - 1] = (uint32_t)TIM##id | irq
 STATIC const uint32_t tim_instance_table[MICROPY_HW_MAX_TIMER] = {
+    #if defined(TIM1)
     #if defined(STM32F0)
     TIM_ENTRY(1, TIM1_BRK_UP_TRG_COM_IRQn),
     #elif defined(STM32F4) || defined(STM32F7)
     TIM_ENTRY(1, TIM1_UP_TIM10_IRQn),
+    #elif defined(STM32H7)
+    TIM_ENTRY(1, TIM1_UP_IRQn),
     #elif defined(STM32L4)
     TIM_ENTRY(1, TIM1_UP_TIM16_IRQn),
     #endif
+    #endif
     TIM_ENTRY(2, TIM2_IRQn),
     #if defined(TIM3)
     TIM_ENTRY(3, TIM3_IRQn),
@@ -738,13 +820,17 @@ STATIC const uint32_t tim_instance_table[MICROPY_HW_MAX_TIMER] = {
     TIM_ENTRY(5, TIM5_IRQn),
     #endif
     #if defined(TIM6)
+    #if defined(STM32F412Zx)
+    TIM_ENTRY(6, TIM6_IRQn),
+    #else
     TIM_ENTRY(6, TIM6_DAC_IRQn),
     #endif
+    #endif
     #if defined(TIM7)
     TIM_ENTRY(7, TIM7_IRQn),
     #endif
     #if defined(TIM8)
-    #if defined(STM32F4) || defined(STM32F7)
+    #if defined(STM32F4) || defined(STM32F7) || defined(STM32H7)
     TIM_ENTRY(8, TIM8_UP_TIM13_IRQn),
     #elif defined(STM32L4)
     TIM_ENTRY(8, TIM8_UP_IRQn),
@@ -807,7 +893,7 @@ STATIC mp_obj_t pyb_timer_make_new(const mp_obj_type_t *type, size_t n_args, siz
 
     // check if the timer exists
     if (tim_id <= 0 || tim_id > MICROPY_HW_MAX_TIMER || tim_instance_table[tim_id - 1] == 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Timer(%d) doesn't exist", tim_id));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Timer(%d) doesn't exist"), tim_id);
     }
 
     pyb_timer_obj_t *tim;
@@ -820,7 +906,7 @@ STATIC mp_obj_t pyb_timer_make_new(const mp_obj_type_t *type, size_t n_args, siz
         tim->is_32bit = tim_id == 2 || tim_id == 5;
         tim->callback = mp_const_none;
         uint32_t ti = tim_instance_table[tim_id - 1];
-        tim->tim.Instance = (TIM_TypeDef*)(ti & 0xffffff00);
+        tim->tim.Instance = (TIM_TypeDef *)(ti & 0xffffff00);
         tim->irqn = ti & 0xff;
         MP_STATE_PORT(pyb_timer_obj_all)[tim_id - 1] = tim;
     } else {
@@ -944,10 +1030,10 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_timer_deinit_obj, pyb_timer_deinit);
 STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_mode,                MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
-        { MP_QSTR_callback,            MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
-        { MP_QSTR_pin,                 MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_callback,            MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_pin,                 MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
         { MP_QSTR_pulse_width,         MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
-        { MP_QSTR_pulse_width_percent, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_pulse_width_percent, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
         { MP_QSTR_compare,             MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
         { MP_QSTR_polarity,            MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0xffffffff} },
     };
@@ -956,7 +1042,7 @@ STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *pos_args, mp_ma
     mp_int_t channel = mp_obj_get_int(pos_args[1]);
 
     if (channel < 1 || channel > 4) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid channel (%d)", channel));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("invalid channel (%d)"), channel);
     }
 
     pyb_timer_channel_obj_t *chan = self->channel;
@@ -1009,12 +1095,12 @@ STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *pos_args, mp_ma
     mp_obj_t pin_obj = args[2].u_obj;
     if (pin_obj != mp_const_none) {
         if (!mp_obj_is_type(pin_obj, &pin_type)) {
-            mp_raise_ValueError("pin argument needs to be be a Pin type");
+            mp_raise_ValueError(MP_ERROR_TEXT("pin argument needs to be be a Pin type"));
         }
         const pin_obj_t *pin = MP_OBJ_TO_PTR(pin_obj);
         const pin_af_obj_t *af = pin_find_af(pin, AF_FN_TIM, self->tim_id);
         if (af == NULL) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Pin(%q) doesn't have an af for Timer(%d)", pin->name, self->tim_id));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Pin(%q) doesn't have an af for Timer(%d)"), pin->name, self->tim_id);
         }
         // pin.init(mode=AF_PP, af=idx)
         const mp_obj_t args2[6] = {
@@ -1047,11 +1133,13 @@ STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *pos_args, mp_ma
                 // use absolute pulse width value (defaults to 0 if nothing given)
                 oc_config.Pulse = args[3].u_int;
             }
-            oc_config.OCPolarity   = TIM_OCPOLARITY_HIGH;
-            oc_config.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
-            oc_config.OCFastMode   = TIM_OCFAST_DISABLE;
-            oc_config.OCIdleState  = TIM_OCIDLESTATE_SET;
+            oc_config.OCPolarity = TIM_OCPOLARITY_HIGH;
+            oc_config.OCFastMode = TIM_OCFAST_DISABLE;
+            #if !defined(STM32L0)
+            oc_config.OCNPolarity = TIM_OCNPOLARITY_HIGH;
+            oc_config.OCIdleState = TIM_OCIDLESTATE_SET;
             oc_config.OCNIdleState = TIM_OCNIDLESTATE_SET;
+            #endif
 
             HAL_TIM_PWM_ConfigChannel(&self->tim, &oc_config, TIMER_CHANNEL(chan));
             if (chan->callback == mp_const_none) {
@@ -1059,10 +1147,12 @@ STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *pos_args, mp_ma
             } else {
                 pyb_timer_channel_callback(MP_OBJ_FROM_PTR(chan), chan->callback);
             }
+            #if !defined(STM32L0)
             // Start the complimentary channel too (if its supported)
             if (IS_TIM_CCXN_INSTANCE(self->tim.Instance, TIMER_CHANNEL(chan))) {
                 HAL_TIMEx_PWMN_Start(&self->tim, TIMER_CHANNEL(chan));
             }
+            #endif
             break;
         }
 
@@ -1073,23 +1163,25 @@ STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *pos_args, mp_ma
         case CHANNEL_MODE_OC_FORCED_ACTIVE:
         case CHANNEL_MODE_OC_FORCED_INACTIVE: {
             TIM_OC_InitTypeDef oc_config;
-            oc_config.OCMode       = channel_mode_info[chan->mode].oc_mode;
-            oc_config.Pulse        = args[5].u_int;
-            oc_config.OCPolarity   = args[6].u_int;
+            oc_config.OCMode = channel_mode_info[chan->mode].oc_mode;
+            oc_config.Pulse = args[5].u_int;
+            oc_config.OCPolarity = args[6].u_int;
             if (oc_config.OCPolarity == 0xffffffff) {
                 oc_config.OCPolarity = TIM_OCPOLARITY_HIGH;
             }
+            oc_config.OCFastMode = TIM_OCFAST_DISABLE;
+            #if !defined(STM32L0)
             if (oc_config.OCPolarity == TIM_OCPOLARITY_HIGH) {
-                oc_config.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
+                oc_config.OCNPolarity = TIM_OCNPOLARITY_HIGH;
             } else {
-                oc_config.OCNPolarity  = TIM_OCNPOLARITY_LOW;
+                oc_config.OCNPolarity = TIM_OCNPOLARITY_LOW;
             }
-            oc_config.OCFastMode   = TIM_OCFAST_DISABLE;
-            oc_config.OCIdleState  = TIM_OCIDLESTATE_SET;
+            oc_config.OCIdleState = TIM_OCIDLESTATE_SET;
             oc_config.OCNIdleState = TIM_OCNIDLESTATE_SET;
+            #endif
 
             if (!IS_TIM_OC_POLARITY(oc_config.OCPolarity)) {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid polarity (%d)", oc_config.OCPolarity));
+                mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("invalid polarity (%d)"), oc_config.OCPolarity);
             }
             HAL_TIM_OC_ConfigChannel(&self->tim, &oc_config, TIMER_CHANNEL(chan));
             if (chan->callback == mp_const_none) {
@@ -1097,26 +1189,28 @@ STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *pos_args, mp_ma
             } else {
                 pyb_timer_channel_callback(MP_OBJ_FROM_PTR(chan), chan->callback);
             }
+            #if !defined(STM32L0)
             // Start the complimentary channel too (if its supported)
             if (IS_TIM_CCXN_INSTANCE(self->tim.Instance, TIMER_CHANNEL(chan))) {
                 HAL_TIMEx_OCN_Start(&self->tim, TIMER_CHANNEL(chan));
             }
+            #endif
             break;
         }
 
         case CHANNEL_MODE_IC: {
             TIM_IC_InitTypeDef ic_config;
 
-            ic_config.ICPolarity  = args[6].u_int;
+            ic_config.ICPolarity = args[6].u_int;
             if (ic_config.ICPolarity == 0xffffffff) {
                 ic_config.ICPolarity = TIM_ICPOLARITY_RISING;
             }
             ic_config.ICSelection = TIM_ICSELECTION_DIRECTTI;
             ic_config.ICPrescaler = TIM_ICPSC_DIV1;
-            ic_config.ICFilter    = 0;
+            ic_config.ICFilter = 0;
 
             if (!IS_TIM_IC_POLARITY(ic_config.ICPolarity)) {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid polarity (%d)", ic_config.ICPolarity));
+                mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("invalid polarity (%d)"), ic_config.ICPolarity);
             }
             HAL_TIM_IC_ConfigChannel(&self->tim, &ic_config, TIMER_CHANNEL(chan));
             if (chan->callback == mp_const_none) {
@@ -1133,38 +1227,42 @@ STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *pos_args, mp_ma
             TIM_Encoder_InitTypeDef enc_config;
 
             enc_config.EncoderMode = channel_mode_info[chan->mode].oc_mode;
-            enc_config.IC1Polarity  = args[6].u_int;
+            enc_config.IC1Polarity = args[6].u_int;
             if (enc_config.IC1Polarity == 0xffffffff) {
                 enc_config.IC1Polarity = TIM_ICPOLARITY_RISING;
             }
-            enc_config.IC2Polarity  = enc_config.IC1Polarity;
+            enc_config.IC2Polarity = enc_config.IC1Polarity;
             enc_config.IC1Selection = TIM_ICSELECTION_DIRECTTI;
             enc_config.IC2Selection = TIM_ICSELECTION_DIRECTTI;
             enc_config.IC1Prescaler = TIM_ICPSC_DIV1;
             enc_config.IC2Prescaler = TIM_ICPSC_DIV1;
-            enc_config.IC1Filter    = 0;
-            enc_config.IC2Filter    = 0;
+            enc_config.IC1Filter = 0;
+            enc_config.IC2Filter = 0;
 
             if (!IS_TIM_IC_POLARITY(enc_config.IC1Polarity)) {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid polarity (%d)", enc_config.IC1Polarity));
+                mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("invalid polarity (%d)"), enc_config.IC1Polarity);
             }
             // Only Timers 1, 2, 3, 4, 5, and 8 support encoder mode
-            if (self->tim.Instance != TIM1
-            &&  self->tim.Instance != TIM2
-            #if defined(TIM3)
-            &&  self->tim.Instance != TIM3
-            #endif
-            #if defined(TIM4)
-            &&  self->tim.Instance != TIM4
-            #endif
-            #if defined(TIM5)
-            &&  self->tim.Instance != TIM5
-            #endif
-            #if defined(TIM8)
-            &&  self->tim.Instance != TIM8
-            #endif
-            ) {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "encoder not supported on timer %d", self->tim_id));
+            if (
+                #if defined(TIM1)
+                self->tim.Instance != TIM1
+                &&
+                #endif
+                self->tim.Instance != TIM2
+                #if defined(TIM3)
+                && self->tim.Instance != TIM3
+                #endif
+                #if defined(TIM4)
+                && self->tim.Instance != TIM4
+                #endif
+                #if defined(TIM5)
+                && self->tim.Instance != TIM5
+                #endif
+                #if defined(TIM8)
+                && self->tim.Instance != TIM8
+                #endif
+                ) {
+                mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("encoder not supported on timer %d"), self->tim_id);
             }
 
             // Disable & clear the timer interrupt so that we don't trigger
@@ -1181,7 +1279,7 @@ STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *pos_args, mp_ma
         }
 
         default:
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid mode (%d)", chan->mode));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("invalid mode (%d)"), chan->mode);
     }
 
     return MP_OBJ_FROM_PTR(chan);
@@ -1221,15 +1319,21 @@ STATIC mp_obj_t pyb_timer_freq(size_t n_args, const mp_obj_t *args) {
         uint32_t prescaler = self->tim.Instance->PSC & 0xffff;
         uint32_t period = __HAL_TIM_GET_AUTORELOAD(&self->tim) & TIMER_CNT_MASK(self);
         uint32_t source_freq = timer_get_source_freq(self->tim_id);
-        uint32_t divide = ((prescaler + 1) * (period + 1));
+        uint32_t divide_a = prescaler + 1;
+        uint32_t divide_b = period + 1;
         #if MICROPY_PY_BUILTINS_FLOAT
-        if (source_freq % divide != 0) {
-            return mp_obj_new_float((float)source_freq / (float)divide);
-        } else
-        #endif
-        {
-            return mp_obj_new_int(source_freq / divide);
+        if (source_freq % divide_a != 0) {
+            return mp_obj_new_float((mp_float_t)source_freq / (mp_float_t)divide_a / (mp_float_t)divide_b);
+        }
+        source_freq /= divide_a;
+        if (source_freq % divide_b != 0) {
+            return mp_obj_new_float((mp_float_t)source_freq / (mp_float_t)divide_b);
+        } else {
+            return mp_obj_new_int(source_freq / divide_b);
         }
+        #else
+        return mp_obj_new_int(source_freq / divide_a / divide_b);
+        #endif
     } else {
         // set
         uint32_t period;
@@ -1290,7 +1394,7 @@ STATIC mp_obj_t pyb_timer_callback(mp_obj_t self_in, mp_obj_t callback) {
         HAL_TIM_Base_Start_IT(&self->tim); // This will re-enable the IRQ
         HAL_NVIC_EnableIRQ(self->irqn);
     } else {
-        mp_raise_ValueError("callback must be None or a callable object");
+        mp_raise_ValueError(MP_ERROR_TEXT("callback must be None or a callable object"));
     }
     return mp_const_none;
 }
@@ -1338,7 +1442,7 @@ const mp_obj_type_t pyb_timer_type = {
     .name = MP_QSTR_Timer,
     .print = pyb_timer_print,
     .make_new = pyb_timer_make_new,
-    .locals_dict = (mp_obj_dict_t*)&pyb_timer_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_timer_locals_dict,
 };
 
 /// \moduleref pyb
@@ -1351,9 +1455,9 @@ STATIC void pyb_timer_channel_print(const mp_print_t *print, mp_obj_t self_in, m
     pyb_timer_channel_obj_t *self = MP_OBJ_TO_PTR(self_in);
 
     mp_printf(print, "TimerChannel(timer=%u, channel=%u, mode=%s)",
-          self->timer->tim_id,
-          self->channel,
-          qstr_str(channel_mode_info[self->mode].name));
+        self->timer->tim_id,
+        self->channel,
+        qstr_str(channel_mode_info[self->mode].name));
 }
 
 /// \method capture([value])
@@ -1420,15 +1524,18 @@ STATIC mp_obj_t pyb_timer_channel_callback(mp_obj_t self_in, mp_obj_t callback)
         self->callback = mp_const_none;
     } else if (mp_obj_is_callable(callback)) {
         self->callback = callback;
-        uint8_t tim_id = self->timer->tim_id;
         __HAL_TIM_CLEAR_IT(&self->timer->tim, TIMER_IRQ_MASK(self->channel));
-        if (tim_id == 1) {
+        #if defined(TIM1)
+        if (self->timer->tim_id == 1) {
             HAL_NVIC_EnableIRQ(TIM1_CC_IRQn);
+        } else
+        #endif
         #if defined(TIM8) // STM32F401 doesn't have a TIM8
-        } else if (tim_id == 8) {
+        if (self->timer->tim_id == 8) {
             HAL_NVIC_EnableIRQ(TIM8_CC_IRQn);
+        } else
         #endif
-        } else {
+        {
             HAL_NVIC_EnableIRQ(self->timer->irqn);
         }
         // start timer, so that it interrupts on overflow
@@ -1450,7 +1557,7 @@ STATIC mp_obj_t pyb_timer_channel_callback(mp_obj_t self_in, mp_obj_t callback)
                 break;
         }
     } else {
-        mp_raise_ValueError("callback must be None or a callable object");
+        mp_raise_ValueError(MP_ERROR_TEXT("callback must be None or a callable object"));
     }
     return mp_const_none;
 }
@@ -1470,7 +1577,7 @@ STATIC const mp_obj_type_t pyb_timer_channel_type = {
     { &mp_type_type },
     .name = MP_QSTR_TimerChannel,
     .print = pyb_timer_channel_print,
-    .locals_dict = (mp_obj_dict_t*)&pyb_timer_channel_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_timer_channel_locals_dict,
 };
 
 STATIC void timer_handle_irq_channel(pyb_timer_obj_t *tim, uint8_t channel, mp_obj_t callback) {
@@ -1496,9 +1603,9 @@ STATIC void timer_handle_irq_channel(pyb_timer_obj_t *tim, uint8_t channel, mp_o
                     tim->callback = mp_const_none;
                     __HAL_TIM_DISABLE_IT(&tim->tim, irq_mask);
                     if (channel == 0) {
-                        printf("uncaught exception in Timer(%u) interrupt handler\n", tim->tim_id);
+                        mp_printf(MICROPY_ERROR_PRINTER, "uncaught exception in Timer(%u) interrupt handler\n", tim->tim_id);
                     } else {
-                        printf("uncaught exception in Timer(%u) channel %u interrupt handler\n", tim->tim_id, channel);
+                        mp_printf(MICROPY_ERROR_PRINTER, "uncaught exception in Timer(%u) channel %u interrupt handler\n", tim->tim_id, channel);
                     }
                     mp_obj_print_exception(&mp_plat_print, MP_OBJ_FROM_PTR(nlr.ret_val));
                 }
@@ -1539,7 +1646,7 @@ void timer_irq_handler(uint tim_id) {
         if (unhandled != 0) {
             __HAL_TIM_DISABLE_IT(&tim->tim, unhandled);
             __HAL_TIM_CLEAR_IT(&tim->tim, unhandled);
-            printf("Unhandled interrupt SR=0x%02x (now disabled)\n", (unsigned int)unhandled);
+            mp_printf(MICROPY_ERROR_PRINTER, "unhandled interrupt SR=0x%02x (now disabled)\n", (unsigned int)unhandled);
         }
     }
 }
diff --git a/ports/stm32/uart.c b/ports/stm32/uart.c
index 4156551038443..8693813fa4413 100644
--- a/ports/stm32/uart.c
+++ b/ports/stm32/uart.c
@@ -40,6 +40,8 @@
 
 #if defined(STM32F4)
 #define UART_RXNE_IS_SET(uart) ((uart)->SR & USART_SR_RXNE)
+#elif defined(STM32H7)
+#define UART_RXNE_IS_SET(uart) ((uart)->ISR & USART_ISR_RXNE_RXFNE)
 #else
 #define UART_RXNE_IS_SET(uart) ((uart)->ISR & USART_ISR_RXNE)
 #endif
@@ -74,7 +76,12 @@
 #define USART_CR2_IE_ALL (USART_CR2_IE_BASE)
 #define USART_CR3_IE_ALL (USART_CR3_IE_BASE | USART_CR3_RXFTIE | USART_CR3_TCBGTIE | USART_CR3_TXFTIE | USART_CR3_WUFIE)
 
-#elif defined(STM32L4)
+#elif defined(STM32L0)
+#define USART_CR1_IE_ALL (USART_CR1_IE_BASE | USART_CR1_EOBIE | USART_CR1_RTOIE | USART_CR1_CMIE)
+#define USART_CR2_IE_ALL (USART_CR2_IE_BASE)
+#define USART_CR3_IE_ALL (USART_CR3_IE_BASE | USART_CR3_WUFIE)
+
+#elif defined(STM32L4) || defined(STM32WB)
 #define USART_CR1_IE_ALL (USART_CR1_IE_BASE | USART_CR1_EOBIE | USART_CR1_RTOIE | USART_CR1_CMIE)
 #define USART_CR2_IE_ALL (USART_CR2_IE_BASE)
 #if defined(USART_CR3_TCBGTIE)
@@ -123,38 +130,57 @@ bool uart_exists(int uart_id) {
     }
     switch (uart_id) {
         #if defined(MICROPY_HW_UART1_TX) && defined(MICROPY_HW_UART1_RX)
-        case PYB_UART_1: return true;
+        case PYB_UART_1:
+            return true;
         #endif
 
         #if defined(MICROPY_HW_UART2_TX) && defined(MICROPY_HW_UART2_RX)
-        case PYB_UART_2: return true;
+        case PYB_UART_2:
+            return true;
         #endif
 
         #if defined(MICROPY_HW_UART3_TX) && defined(MICROPY_HW_UART3_RX)
-        case PYB_UART_3: return true;
+        case PYB_UART_3:
+            return true;
         #endif
 
         #if defined(MICROPY_HW_UART4_TX) && defined(MICROPY_HW_UART4_RX)
-        case PYB_UART_4: return true;
+        case PYB_UART_4:
+            return true;
         #endif
 
         #if defined(MICROPY_HW_UART5_TX) && defined(MICROPY_HW_UART5_RX)
-        case PYB_UART_5: return true;
+        case PYB_UART_5:
+            return true;
         #endif
 
         #if defined(MICROPY_HW_UART6_TX) && defined(MICROPY_HW_UART6_RX)
-        case PYB_UART_6: return true;
+        case PYB_UART_6:
+            return true;
         #endif
 
         #if defined(MICROPY_HW_UART7_TX) && defined(MICROPY_HW_UART7_RX)
-        case PYB_UART_7: return true;
+        case PYB_UART_7:
+            return true;
         #endif
 
         #if defined(MICROPY_HW_UART8_TX) && defined(MICROPY_HW_UART8_RX)
-        case PYB_UART_8: return true;
+        case PYB_UART_8:
+            return true;
+        #endif
+
+        #if defined(MICROPY_HW_UART9_TX) && defined(MICROPY_HW_UART9_RX)
+        case PYB_UART_9:
+            return true;
+        #endif
+
+        #if defined(MICROPY_HW_UART10_TX) && defined(MICROPY_HW_UART10_RX)
+        case PYB_UART_10:
+            return true;
         #endif
 
-        default: return false;
+        default:
+            return false;
     }
 }
 
@@ -232,6 +258,10 @@ bool uart_init(pyb_uart_obj_t *uart_obj,
             UARTx = USART4;
             irqn = USART3_8_IRQn;
             __HAL_RCC_USART4_CLK_ENABLE();
+            #elif defined(STM32L0)
+            UARTx = USART4;
+            irqn = USART4_5_IRQn;
+            __HAL_RCC_USART4_CLK_ENABLE();
             #else
             UARTx = UART4;
             irqn = UART4_IRQn;
@@ -239,6 +269,16 @@ bool uart_init(pyb_uart_obj_t *uart_obj,
             #endif
             pins[0] = MICROPY_HW_UART4_TX;
             pins[1] = MICROPY_HW_UART4_RX;
+            #if defined(MICROPY_HW_UART4_RTS)
+            if (flow & UART_HWCONTROL_RTS) {
+                pins[2] = MICROPY_HW_UART4_RTS;
+            }
+            #endif
+            #if defined(MICROPY_HW_UART4_CTS)
+            if (flow & UART_HWCONTROL_CTS) {
+                pins[3] = MICROPY_HW_UART4_CTS;
+            }
+            #endif
             break;
         #endif
 
@@ -249,6 +289,10 @@ bool uart_init(pyb_uart_obj_t *uart_obj,
             UARTx = USART5;
             irqn = USART3_8_IRQn;
             __HAL_RCC_USART5_CLK_ENABLE();
+            #elif defined(STM32L0)
+            UARTx = USART5;
+            irqn = USART4_5_IRQn;
+            __HAL_RCC_USART5_CLK_ENABLE();
             #else
             UARTx = UART5;
             irqn = UART5_IRQn;
@@ -318,6 +362,28 @@ bool uart_init(pyb_uart_obj_t *uart_obj,
             break;
         #endif
 
+        #if defined(MICROPY_HW_UART9_TX) && defined(MICROPY_HW_UART9_RX)
+        case PYB_UART_9:
+            uart_unit = 9;
+            UARTx = UART9;
+            irqn = UART9_IRQn;
+            __HAL_RCC_UART9_CLK_ENABLE();
+            pins[0] = MICROPY_HW_UART9_TX;
+            pins[1] = MICROPY_HW_UART9_RX;
+            break;
+        #endif
+
+        #if defined(MICROPY_HW_UART10_TX) && defined(MICROPY_HW_UART10_RX)
+        case PYB_UART_10:
+            uart_unit = 10;
+            UARTx = UART10;
+            irqn = UART10_IRQn;
+            __HAL_RCC_UART10_CLK_ENABLE();
+            pins[0] = MICROPY_HW_UART10_TX;
+            pins[1] = MICROPY_HW_UART10_RX;
+            break;
+        #endif
+
         default:
             // UART does not exist or is not configured for this board
             return false;
@@ -402,11 +468,13 @@ void uart_deinit(pyb_uart_obj_t *self) {
         __HAL_RCC_USART1_FORCE_RESET();
         __HAL_RCC_USART1_RELEASE_RESET();
         __HAL_RCC_USART1_CLK_DISABLE();
+    #if defined(USART2)
     } else if (self->uart_id == 2) {
         HAL_NVIC_DisableIRQ(USART2_IRQn);
         __HAL_RCC_USART2_FORCE_RESET();
         __HAL_RCC_USART2_RELEASE_RESET();
         __HAL_RCC_USART2_CLK_DISABLE();
+    #endif
     #if defined(USART3)
     } else if (self->uart_id == 3) {
         #if !defined(STM32F0)
@@ -475,6 +543,20 @@ void uart_deinit(pyb_uart_obj_t *self) {
         __HAL_RCC_USART8_RELEASE_RESET();
         __HAL_RCC_USART8_CLK_DISABLE();
     #endif
+    #if defined(UART9)
+    } else if (self->uart_id == 9) {
+        HAL_NVIC_DisableIRQ(UART9_IRQn);
+        __HAL_RCC_UART9_FORCE_RESET();
+        __HAL_RCC_UART9_RELEASE_RESET();
+        __HAL_RCC_UART9_CLK_DISABLE();
+    #endif
+    #if defined(UART10)
+    } else if (self->uart_id == 10) {
+        HAL_NVIC_DisableIRQ(UART10_IRQn);
+        __HAL_RCC_UART10_FORCE_RESET();
+        __HAL_RCC_UART10_RELEASE_RESET();
+        __HAL_RCC_UART10_CLK_DISABLE();
+    #endif
     }
 }
 
@@ -538,6 +620,12 @@ uint32_t uart_get_baudrate(pyb_uart_obj_t *self) {
         #if defined(USART6)
         || self->uart_id == 6
         #endif
+        #if defined(UART9)
+        || self->uart_id == 9
+        #endif
+        #if defined(UART10)
+        || self->uart_id == 10
+        #endif
         ) {
         uart_clk = HAL_RCC_GetPCLK2Freq();
     } else {
@@ -584,7 +672,7 @@ int uart_rx_char(pyb_uart_obj_t *self) {
         // buffering via IRQ
         int data;
         if (self->char_width == CHAR_WIDTH_9BIT) {
-            data = ((uint16_t*)self->read_buf)[self->read_buf_tail];
+            data = ((uint16_t *)self->read_buf)[self->read_buf_tail];
         } else {
             data = self->read_buf[self->read_buf_tail];
         }
@@ -596,7 +684,7 @@ int uart_rx_char(pyb_uart_obj_t *self) {
         return data;
     } else {
         // no buffering
-        #if defined(STM32F0) || defined(STM32F7) || defined(STM32L4) || defined(STM32H7)
+        #if defined(STM32F0) || defined(STM32F7) || defined(STM32L0) || defined(STM32L4) || defined(STM32H7) || defined(STM32WB)
         int data = self->uartx->RDR & self->char_mask;
         self->uartx->ICR = USART_ICR_ORECF; // clear ORE if it was set
         return data;
@@ -667,7 +755,7 @@ size_t uart_tx_data(pyb_uart_obj_t *self, const void *src_in, size_t num_chars,
         timeout = 2 * self->timeout_char;
     }
 
-    const uint8_t *src = (const uint8_t*)src_in;
+    const uint8_t *src = (const uint8_t *)src_in;
     size_t num_tx = 0;
     USART_TypeDef *uart = self->uartx;
 
@@ -678,7 +766,7 @@ size_t uart_tx_data(pyb_uart_obj_t *self, const void *src_in, size_t num_chars,
         }
         uint32_t data;
         if (self->char_width == CHAR_WIDTH_9BIT) {
-            data = *((uint16_t*)src) & 0x1ff;
+            data = *((uint16_t *)src) & 0x1ff;
             src += 2;
         } else {
             data = *src++;
@@ -722,7 +810,7 @@ void uart_irq_handler(mp_uint_t uart_id) {
             uint16_t next_head = (self->read_buf_head + 1) % self->read_buf_len;
             if (next_head != self->read_buf_tail) {
                 // only read data if room in buf
-                #if defined(STM32F0) || defined(STM32F7) || defined(STM32L4) || defined(STM32H7)
+                #if defined(STM32F0) || defined(STM32F7) || defined(STM32L0) || defined(STM32L4) || defined(STM32H7) || defined(STM32WB)
                 int data = self->uartx->RDR; // clears UART_FLAG_RXNE
                 self->uartx->ICR = USART_ICR_ORECF; // clear ORE if it was set
                 #else
@@ -734,7 +822,7 @@ void uart_irq_handler(mp_uint_t uart_id) {
                     pendsv_kbd_intr();
                 } else {
                     if (self->char_width == CHAR_WIDTH_9BIT) {
-                        ((uint16_t*)self->read_buf)[self->read_buf_head] = data;
+                        ((uint16_t *)self->read_buf)[self->read_buf_head] = data;
                     } else {
                         self->read_buf[self->read_buf_head] = data;
                     }
diff --git a/ports/stm32/uart.h b/ports/stm32/uart.h
index 827b3c12d7d01..62676fb91be51 100644
--- a/ports/stm32/uart.h
+++ b/ports/stm32/uart.h
@@ -38,6 +38,8 @@ typedef enum {
     PYB_UART_6 = 6,
     PYB_UART_7 = 7,
     PYB_UART_8 = 8,
+    PYB_UART_9 = 9,
+    PYB_UART_10 = 10,
 } pyb_uart_t;
 
 #define CHAR_WIDTH_8BIT (0)
@@ -86,6 +88,8 @@ void uart_tx_strn(pyb_uart_obj_t *uart_obj, const char *str, uint len);
 static inline bool uart_tx_avail(pyb_uart_obj_t *self) {
     #if defined(STM32F4)
     return self->uartx->SR & USART_SR_TXE;
+    #elif defined(STM32H7)
+    return self->uartx->ISR & USART_ISR_TXE_TXFNF;
     #else
     return self->uartx->ISR & USART_ISR_TXE;
     #endif
diff --git a/ports/stm32/usb.c b/ports/stm32/usb.c
index ce2a828598d4a..cd5238172188e 100644
--- a/ports/stm32/usb.c
+++ b/ports/stm32/usb.c
@@ -31,7 +31,7 @@
 #include "usbd_desc.h"
 #include "usbd_cdc_msc_hid.h"
 #include "usbd_cdc_interface.h"
-#include "usbd_msc_storage.h"
+#include "usbd_msc_interface.h"
 #include "usbd_hid_interface.h"
 
 #include "py/objstr.h"
@@ -40,6 +40,8 @@
 #include "py/mperrno.h"
 #include "py/mphal.h"
 #include "bufhelper.h"
+#include "storage.h"
+#include "sdcard.h"
 #include "usb.h"
 
 #if MICROPY_HW_ENABLE_USB
@@ -55,6 +57,21 @@
 #endif
 #endif
 
+// Maximum number of endpoints (excluding EP0)
+#if defined(STM32L0) || defined(STM32WB)
+#define MAX_ENDPOINT(dev_id) (7)
+#elif defined(STM32L4)
+#define MAX_ENDPOINT(dev_id) (5)
+#elif defined(STM32F4)
+#define MAX_ENDPOINT(dev_id) ((dev_id) == USB_PHY_FS_ID ? 3 : 5)
+#elif defined(STM32F7)
+#define MAX_ENDPOINT(dev_id) ((dev_id) == USB_PHY_FS_ID ? 5 : 8)
+#elif defined(STM32H7)
+#define MAX_ENDPOINT(dev_id) (8)
+#endif
+
+STATIC void pyb_usb_vcp_init0(void);
+
 // this will be persistent across a soft-reset
 mp_uint_t pyb_usb_flags = 0;
 
@@ -62,16 +79,84 @@ typedef struct _usb_device_t {
     uint32_t enabled;
     USBD_HandleTypeDef hUSBDDevice;
     usbd_cdc_msc_hid_state_t usbd_cdc_msc_hid_state;
-    usbd_cdc_itf_t usbd_cdc_itf;
-    #if MICROPY_HW_USB_ENABLE_CDC2
-    usbd_cdc_itf_t usbd_cdc2_itf;
-    #endif
+    usbd_cdc_itf_t usbd_cdc_itf[MICROPY_HW_USB_CDC_NUM];
+    #if MICROPY_HW_USB_HID
     usbd_hid_itf_t usbd_hid_itf;
+    #endif
 } usb_device_t;
 
-usb_device_t usb_device;
+usb_device_t usb_device = {0};
 pyb_usb_storage_medium_t pyb_usb_storage_medium = PYB_USB_STORAGE_MEDIUM_NONE;
 
+#if !MICROPY_HW_USB_IS_MULTI_OTG
+
+// Units of FIFO size arrays below are 4x 16-bit words = 8 bytes
+// There are 512x 16-bit words it total to use here (when using PCD_SNG_BUF)
+
+// EP0(out), EP0(in), MSC/HID(out), MSC/HID(in), unused, CDC_CMD(in), CDC_DATA(out), CDC_DATA(in)
+STATIC const uint8_t usbd_fifo_size_cdc1[] = {16, 16, 16, 16, 0, 16, 16, 16};
+
+#else
+
+// Units of FIFO size arrays below are 4x 32-bit words = 16 bytes
+// FS: there are 320x 32-bit words in total to use here
+// HS: there are 1024x 32-bit words in total to use here
+
+// RX; EP0(in), MSC/HID, CDC_CMD, CDC_DATA
+STATIC const uint8_t usbd_fifo_size_cdc1[] = {
+    32, 8, 16, 8, 16, 0, 0, // FS: RX, EP0(in), 5x IN endpoints
+    #if MICROPY_HW_USB_HS
+    116, 8, 64, 4, 64, 0, 0, 0, 0, 0, // HS: RX, EP0(in), 8x IN endpoints
+    #endif
+};
+
+// RX; EP0(in), MSC/HID, CDC_CMD, CDC_DATA, HID
+STATIC const uint8_t usbd_fifo_size_cdc1_msc_hid[] = {
+    32, 8, 16, 4, 12, 8, 0,
+    #if MICROPY_HW_USB_HS
+    116, 8, 64, 4, 56, 8, 0, 0, 0, 0,
+    #endif
+};
+
+#if MICROPY_HW_USB_CDC_NUM >= 2
+// RX; EP0(in), MSC/HID, CDC_CMD, CDC_DATA, CDC2_CMD, CDC2_DATA
+STATIC const uint8_t usbd_fifo_size_cdc2[] = {
+    32, 8, 16, 4, 8, 4, 8,
+    #if MICROPY_HW_USB_HS
+    116, 8, 64, 2, 32, 2, 32, 0, 0, 0,
+    #endif
+};
+
+// RX; EP0(in), MSC/HID, CDC_CMD, CDC_DATA, CDC2_CMD/HID, CDC2_DATA, HID
+STATIC const uint8_t usbd_fifo_size_cdc2_msc_hid[] = {
+    0, 0, 0, 0, 0, 0, 0, // FS: can't support 2xVCP+MSC+HID
+    #if MICROPY_HW_USB_HS
+    102, 8, 64, 2, 32, 8, 32, 8, 0, 0,
+    #endif
+};
+#endif
+
+#if MICROPY_HW_USB_CDC_NUM >= 3
+// RX; EP0(in), MSC/HID, CDC_CMD, CDC_DATA, CDC2_CMD, CDC2_DATA, CDC3_CMD, CDC3_DATA
+STATIC const uint8_t usbd_fifo_size_cdc3[] = {
+    0, 0, 0, 0, 0, 0, 0, // FS: can't support 3x VCP mode
+    #if MICROPY_HW_USB_HS
+    82, 8, 64, 2, 32, 2, 32, 2, 32, 0,
+    #endif
+};
+
+// RX; EP0(in), MSC/HID, CDC_CMD, CDC_DATA, CDC2_CMD/HID, CDC2_DATA, CDC3_CMD/HID, CDC3_DATA, HID
+STATIC const uint8_t usbd_fifo_size_cdc3_msc_hid[] = {
+    0, 0, 0, 0, 0, 0, 0, // FS: can't support 3x VCP mode
+    #if MICROPY_HW_USB_HS
+    82, 8, 64, 2, 25, 8, 25, 8, 25, 8,
+    #endif
+};
+#endif
+
+#endif
+
+#if MICROPY_HW_USB_HID
 // predefined hid mouse data
 STATIC const mp_obj_str_t pyb_usb_hid_mouse_desc_obj = {
     {&mp_type_bytes},
@@ -109,56 +194,117 @@ const mp_rom_obj_tuple_t pyb_usb_hid_keyboard_obj = {
         MP_ROM_PTR(&pyb_usb_hid_keyboard_desc_obj),
     },
 };
+#endif
 
 void pyb_usb_init0(void) {
-    usb_device.usbd_cdc_itf.attached_to_repl = false;
-    #if MICROPY_HW_USB_ENABLE_CDC2
-    usb_device.usbd_cdc2_itf.attached_to_repl = false;
-    #endif
-    mp_hal_set_interrupt_char(-1);
+    for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
+        usb_device.usbd_cdc_itf[i].attached_to_repl = false;
+    }
     MP_STATE_PORT(pyb_hid_report_desc) = MP_OBJ_NULL;
+
+    pyb_usb_vcp_init0();
+}
+
+int pyb_usb_dev_detect(void) {
+    if (usb_device.enabled) {
+        return usb_device.hUSBDDevice.id;
+    }
+
+    #if MICROPY_HW_USB_FS && MICROPY_HW_USB_HS
+    // Try to auto-detect which USB is connected by reading DP/DM pins
+    for (int i = 0; i < 2; ++i) {
+        mp_hal_pin_obj_t dp = i == 0 ? pyb_pin_USB_DP : pyb_pin_USB_HS_DP;
+        mp_hal_pin_obj_t dm = i == 0 ? pyb_pin_USB_DM : pyb_pin_USB_HS_DM;
+        mp_hal_pin_config(dp, MP_HAL_PIN_MODE_INPUT, MP_HAL_PIN_PULL_UP, 0);
+        mp_hal_pin_config(dm, MP_HAL_PIN_MODE_INPUT, MP_HAL_PIN_PULL_UP, 0);
+        int state = mp_hal_pin_read(dp) == 0 && mp_hal_pin_read(dm) == 0;
+        mp_hal_pin_config(dp, MP_HAL_PIN_MODE_INPUT, MP_HAL_PIN_PULL_NONE, 0);
+        mp_hal_pin_config(dm, MP_HAL_PIN_MODE_INPUT, MP_HAL_PIN_PULL_NONE, 0);
+        if (state) {
+            // DP and DM pins are actively held low so assume USB is connected
+            return i == 0 ? USB_PHY_FS_ID : USB_PHY_HS_ID;
+        }
+    }
+    #endif
+
+    return MICROPY_HW_USB_MAIN_DEV;
 }
 
-bool pyb_usb_dev_init(uint16_t vid, uint16_t pid, usb_device_mode_t mode, USBD_HID_ModeInfoTypeDef *hid_info) {
-    bool high_speed = (mode & USBD_MODE_HIGH_SPEED) != 0;
-    mode &= 0x7f;
+bool pyb_usb_dev_init(int dev_id, uint16_t vid, uint16_t pid, uint8_t mode, size_t msc_n, const void *msc_unit, USBD_HID_ModeInfoTypeDef *hid_info) {
     usb_device_t *usb_dev = &usb_device;
     if (!usb_dev->enabled) {
         // only init USB once in the device's power-lifetime
 
         // set up the USBD state
         USBD_HandleTypeDef *usbd = &usb_dev->hUSBDDevice;
-        usbd->id = MICROPY_HW_USB_MAIN_DEV;
-        usbd->dev_state  = USBD_STATE_DEFAULT;
-        usbd->pDesc = (USBD_DescriptorsTypeDef*)&USBD_Descriptors;
+        usbd->id = dev_id;
+        usbd->dev_state = USBD_STATE_DEFAULT;
+        usbd->pDesc = (USBD_DescriptorsTypeDef *)&USBD_Descriptors;
         usbd->pClass = &USBD_CDC_MSC_HID;
         usb_dev->usbd_cdc_msc_hid_state.pdev = usbd;
-        usb_dev->usbd_cdc_msc_hid_state.cdc = &usb_dev->usbd_cdc_itf.base;
-        #if MICROPY_HW_USB_ENABLE_CDC2
-        usb_dev->usbd_cdc_msc_hid_state.cdc2 = &usb_dev->usbd_cdc2_itf.base;
-        #endif
+        for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
+            usb_dev->usbd_cdc_msc_hid_state.cdc[i] = &usb_dev->usbd_cdc_itf[i].base;
+        }
+        #if MICROPY_HW_USB_HID
         usb_dev->usbd_cdc_msc_hid_state.hid = &usb_dev->usbd_hid_itf.base;
+        #endif
         usbd->pClassData = &usb_dev->usbd_cdc_msc_hid_state;
 
         // configure the VID, PID and the USBD mode (interfaces it will expose)
-        USBD_SetVIDPIDRelease(&usb_dev->usbd_cdc_msc_hid_state, vid, pid, 0x0200, mode == USBD_MODE_CDC);
-        if (USBD_SelectMode(&usb_dev->usbd_cdc_msc_hid_state, mode, hid_info) != 0) {
+        int cdc_only = (mode & USBD_MODE_IFACE_MASK) == USBD_MODE_CDC;
+        USBD_SetVIDPIDRelease(&usb_dev->usbd_cdc_msc_hid_state, vid, pid, 0x0200, cdc_only);
+        if (USBD_SelectMode(&usb_dev->usbd_cdc_msc_hid_state, mode, hid_info, MAX_ENDPOINT(dev_id)) != 0) {
             return false;
         }
 
-        switch (pyb_usb_storage_medium) {
-            #if MICROPY_HW_ENABLE_SDCARD
-            case PYB_USB_STORAGE_MEDIUM_SDCARD:
-                USBD_MSC_RegisterStorage(&usb_dev->usbd_cdc_msc_hid_state, (USBD_StorageTypeDef*)&USBD_SDCARD_STORAGE_fops);
-                break;
-            #endif
-            default:
-                USBD_MSC_RegisterStorage(&usb_dev->usbd_cdc_msc_hid_state, (USBD_StorageTypeDef*)&USBD_FLASH_STORAGE_fops);
-                break;
+        #if MICROPY_HW_USB_MSC
+        // Configure the MSC interface
+        const void *msc_unit_default[1];
+        if (msc_n == 0) {
+            msc_n = 1;
+            msc_unit = msc_unit_default;
+            switch (pyb_usb_storage_medium) {
+                #if MICROPY_HW_ENABLE_SDCARD
+                case PYB_USB_STORAGE_MEDIUM_SDCARD:
+                    msc_unit_default[0] = &pyb_sdcard_type;
+                    break;
+                #endif
+                default:
+                    msc_unit_default[0] = &pyb_flash_type;
+                    break;
+            }
+        }
+        usbd_msc_init_lu(msc_n, msc_unit);
+        USBD_MSC_RegisterStorage(&usb_dev->usbd_cdc_msc_hid_state, (USBD_StorageTypeDef *)&usbd_msc_fops);
+        #endif
+
+        const uint8_t *fifo_size = usbd_fifo_size_cdc1;
+        #if MICROPY_HW_USB_IS_MULTI_OTG
+        if ((mode & USBD_MODE_MSC_HID) == USBD_MODE_MSC_HID) {
+            fifo_size = usbd_fifo_size_cdc1_msc_hid;
+        }
+        #endif
+        #if MICROPY_HW_USB_CDC_NUM >= 3
+        if (mode & USBD_MODE_IFACE_CDC(2)) {
+            if ((mode & USBD_MODE_MSC_HID) == USBD_MODE_MSC_HID) {
+                fifo_size = usbd_fifo_size_cdc3_msc_hid;
+            } else {
+                fifo_size = usbd_fifo_size_cdc3;
+            }
+        } else
+        #endif
+        #if MICROPY_HW_USB_CDC_NUM >= 2
+        if (mode & USBD_MODE_IFACE_CDC(1)) {
+            if ((mode & USBD_MODE_MSC_HID) == USBD_MODE_MSC_HID) {
+                fifo_size = usbd_fifo_size_cdc2_msc_hid;
+            } else {
+                fifo_size = usbd_fifo_size_cdc2;
+            }
         }
+        #endif
 
         // start the USB device
-        USBD_LL_Init(usbd, high_speed);
+        USBD_LL_Init(usbd, (mode & USBD_MODE_HIGH_SPEED) != 0, fifo_size);
         USBD_LL_Start(usbd);
         usb_dev->enabled = true;
     }
@@ -180,22 +326,17 @@ bool usb_vcp_is_enabled(void) {
 }
 
 int usb_vcp_recv_byte(uint8_t *c) {
-    return usbd_cdc_rx(&usb_device.usbd_cdc_itf, c, 1, 0);
+    return usbd_cdc_rx(&usb_device.usbd_cdc_itf[0], c, 1, 0);
 }
 
 void usb_vcp_send_strn(const char *str, int len) {
     if (usb_device.enabled) {
-        usbd_cdc_tx_always(&usb_device.usbd_cdc_itf, (const uint8_t*)str, len);
+        usbd_cdc_tx_always(&usb_device.usbd_cdc_itf[0], (const uint8_t *)str, len);
     }
 }
 
 usbd_cdc_itf_t *usb_vcp_get(int idx) {
-    #if MICROPY_HW_USB_ENABLE_CDC2
-    if (idx == 1) {
-        return &usb_device.usbd_cdc2_itf;
-    }
-    #endif
-    return &usb_device.usbd_cdc_itf;
+    return &usb_device.usbd_cdc_itf[idx];
 }
 
 /******************************************************************************/
@@ -228,11 +369,29 @@ usbd_cdc_itf_t *usb_vcp_get(int idx) {
 */
 
 STATIC mp_obj_t pyb_usb_mode(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum {
+        ARG_mode, ARG_port, ARG_vid, ARG_pid,
+        #if MICROPY_HW_USB_MSC
+        ARG_msc,
+        #endif
+        #if MICROPY_HW_USB_HID
+        ARG_hid,
+        #endif
+        #if USBD_SUPPORT_HS_MODE
+        ARG_high_speed
+        #endif
+    };
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_mode, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_mode, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_port, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
         { MP_QSTR_vid, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = USBD_VID} },
         { MP_QSTR_pid, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
+        #if MICROPY_HW_USB_MSC
+        { MP_QSTR_msc, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_empty_tuple_obj)} },
+        #endif
+        #if MICROPY_HW_USB_HID
         { MP_QSTR_hid, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&pyb_usb_hid_mouse_obj)} },
+        #endif
         #if USBD_SUPPORT_HS_MODE
         { MP_QSTR_high_speed, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
         #endif
@@ -240,11 +399,11 @@ STATIC mp_obj_t pyb_usb_mode(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
 
     // fetch the current usb mode -> pyb.usb_mode()
     if (n_args == 0) {
-    #if defined(USE_HOST_MODE)
+        #if defined(USE_HOST_MODE)
         return MP_OBJ_NEW_QSTR(MP_QSTR_host);
-    #else
+        #else
         uint8_t mode = USBD_GetMode(&usb_device.usbd_cdc_msc_hid_state);
-        switch (mode) {
+        switch (mode & USBD_MODE_IFACE_MASK) {
             case USBD_MODE_CDC:
                 return MP_OBJ_NEW_QSTR(MP_QSTR_VCP);
             case USBD_MODE_MSC:
@@ -260,7 +419,7 @@ STATIC mp_obj_t pyb_usb_mode(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
             default:
                 return mp_const_none;
         }
-    #endif
+        #endif
     }
 
     // parse args
@@ -271,16 +430,16 @@ STATIC mp_obj_t pyb_usb_mode(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
     pyb_usb_flags |= PYB_USB_FLAG_USB_MODE_CALLED;
 
     // check if user wants to disable the USB
-    if (args[0].u_obj == mp_const_none) {
+    if (args[ARG_mode].u_obj == mp_const_none) {
         // disable usb
         pyb_usb_dev_deinit();
         return mp_const_none;
     }
 
     // get mode string
-    const char *mode_str = mp_obj_str_get_str(args[0].u_obj);
+    const char *mode_str = mp_obj_str_get_str(args[ARG_mode].u_obj);
 
-#if defined(USE_HOST_MODE)
+    #if defined(USE_HOST_MODE)
 
     // hardware configured for USB host mode
 
@@ -290,40 +449,72 @@ STATIC mp_obj_t pyb_usb_mode(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
         goto bad_mode;
     }
 
-#else
+    #else
 
     // hardware configured for USB device mode
 
     // get the VID, PID and USB mode
     // note: PID=-1 means select PID based on mode
     // note: we support CDC as a synonym for VCP for backward compatibility
-    uint16_t vid = args[1].u_int;
-    uint16_t pid = args[2].u_int;
-    usb_device_mode_t mode;
+    uint16_t vid = args[ARG_vid].u_int;
+    mp_int_t pid = args[ARG_pid].u_int;
+    uint8_t mode;
     if (strcmp(mode_str, "CDC+MSC") == 0 || strcmp(mode_str, "VCP+MSC") == 0) {
-        if (args[2].u_int == -1) {
+        if (pid == -1) {
             pid = USBD_PID_CDC_MSC;
         }
         mode = USBD_MODE_CDC_MSC;
-    #if MICROPY_HW_USB_ENABLE_CDC2
+    } else if (strcmp(mode_str, "VCP+MSC+HID") == 0) {
+        if (pid == -1) {
+            pid = USBD_PID_CDC_MSC_HID;
+        }
+        mode = USBD_MODE_CDC_MSC_HID;
+    #if MICROPY_HW_USB_CDC_NUM >= 2
+    } else if (strcmp(mode_str, "VCP+VCP") == 0) {
+        if (pid == -1) {
+            pid = USBD_PID_CDC2;
+        }
+        mode = USBD_MODE_CDC2;
     } else if (strcmp(mode_str, "VCP+VCP+MSC") == 0) {
-        if (args[2].u_int == -1) {
+        if (pid == -1) {
             pid = USBD_PID_CDC2_MSC;
         }
         mode = USBD_MODE_CDC2_MSC;
+    } else if (strcmp(mode_str, "2xVCP+MSC+HID") == 0) {
+        if (pid == -1) {
+            pid = USBD_PID_CDC2_MSC_HID;
+        }
+        mode = USBD_MODE_CDC2_MSC_HID;
+    #endif
+    #if MICROPY_HW_USB_CDC_NUM >= 3
+    } else if (strcmp(mode_str, "3xVCP") == 0) {
+        if (pid == -1) {
+            pid = USBD_PID_CDC3;
+        }
+        mode = USBD_MODE_CDC3;
+    } else if (strcmp(mode_str, "3xVCP+MSC") == 0) {
+        if (pid == -1) {
+            pid = USBD_PID_CDC3_MSC;
+        }
+        mode = USBD_MODE_CDC3_MSC;
+    } else if (strcmp(mode_str, "3xVCP+MSC+HID") == 0) {
+        if (pid == -1) {
+            pid = USBD_PID_CDC3_MSC_HID;
+        }
+        mode = USBD_MODE_CDC3_MSC_HID;
     #endif
     } else if (strcmp(mode_str, "CDC+HID") == 0 || strcmp(mode_str, "VCP+HID") == 0) {
-        if (args[2].u_int == -1) {
+        if (pid == -1) {
             pid = USBD_PID_CDC_HID;
         }
         mode = USBD_MODE_CDC_HID;
     } else if (strcmp(mode_str, "CDC") == 0 || strcmp(mode_str, "VCP") == 0) {
-        if (args[2].u_int == -1) {
+        if (pid == -1) {
             pid = USBD_PID_CDC;
         }
         mode = USBD_MODE_CDC;
     } else if (strcmp(mode_str, "MSC") == 0) {
-        if (args[2].u_int == -1) {
+        if (pid == -1) {
             pid = USBD_PID_MSC;
         }
         mode = USBD_MODE_MSC;
@@ -331,11 +522,40 @@ STATIC mp_obj_t pyb_usb_mode(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
         goto bad_mode;
     }
 
+    // Get MSC logical units
+    size_t msc_n = 0;
+    const void *msc_unit[USBD_MSC_MAX_LUN];
+    #if MICROPY_HW_USB_MSC
+    if (mode & USBD_MODE_IFACE_MSC) {
+        mp_obj_t *items;
+        mp_obj_get_array(args[ARG_msc].u_obj, &msc_n, &items);
+        if (msc_n > USBD_MSC_MAX_LUN) {
+            mp_raise_ValueError(MP_ERROR_TEXT("too many logical units"));
+        }
+        for (size_t i = 0; i < msc_n; ++i) {
+            const mp_obj_type_t *type = mp_obj_get_type(items[i]);
+            if (type == &pyb_flash_type
+                #if MICROPY_HW_ENABLE_SDCARD
+                || type == &pyb_sdcard_type
+                #endif
+                #if MICROPY_HW_ENABLE_MMCARD
+                || type == &pyb_mmcard_type
+                #endif
+                ) {
+                msc_unit[i] = type;
+            } else {
+                mp_raise_ValueError(MP_ERROR_TEXT("unsupported logical unit"));
+            }
+        }
+    }
+    #endif
+
     // get hid info if user selected such a mode
     USBD_HID_ModeInfoTypeDef hid_info;
-    if (mode & USBD_MODE_HID) {
+    #if MICROPY_HW_USB_HID
+    if (mode & USBD_MODE_IFACE_HID) {
         mp_obj_t *items;
-        mp_obj_get_array_fixed_n(args[3].u_obj, 5, &items);
+        mp_obj_get_array_fixed_n(args[ARG_hid].u_obj, 5, &items);
         hid_info.subclass = mp_obj_get_int(items[0]);
         hid_info.protocol = mp_obj_get_int(items[1]);
         hid_info.max_packet_len = mp_obj_get_int(items[2]);
@@ -348,24 +568,31 @@ STATIC mp_obj_t pyb_usb_mode(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
         // need to keep a copy of this so report_desc does not get GC'd
         MP_STATE_PORT(pyb_hid_report_desc) = items[4];
     }
+    #endif
 
     #if USBD_SUPPORT_HS_MODE
-    if (args[4].u_bool) {
+    if (args[ARG_high_speed].u_bool) {
         mode |= USBD_MODE_HIGH_SPEED;
     }
     #endif
 
+    // Work out which port/peripheral to use, either user supplied or auto detect
+    int dev_id = args[ARG_port].u_int;
+    if (dev_id == -1) {
+        dev_id = pyb_usb_dev_detect();
+    }
+
     // init the USB device
-    if (!pyb_usb_dev_init(vid, pid, mode, &hid_info)) {
+    if (!pyb_usb_dev_init(dev_id, vid, pid, mode, msc_n, msc_unit, &hid_info)) {
         goto bad_mode;
     }
 
-#endif
+    #endif
 
     return mp_const_none;
 
 bad_mode:
-    mp_raise_ValueError("bad USB mode");
+    mp_raise_ValueError(MP_ERROR_TEXT("bad USB mode"));
 }
 MP_DEFINE_CONST_FUN_OBJ_KW(pyb_usb_mode_obj, 0, pyb_usb_mode);
 
@@ -384,18 +611,35 @@ typedef struct _pyb_usb_vcp_obj_t {
     usbd_cdc_itf_t *cdc_itf;
 } pyb_usb_vcp_obj_t;
 
-const pyb_usb_vcp_obj_t pyb_usb_vcp_obj = {{&pyb_usb_vcp_type}, &usb_device.usbd_cdc_itf};
-#if MICROPY_HW_USB_ENABLE_CDC2
-STATIC const pyb_usb_vcp_obj_t pyb_usb_vcp2_obj = {{&pyb_usb_vcp_type}, &usb_device.usbd_cdc2_itf};
-#endif
+const pyb_usb_vcp_obj_t pyb_usb_vcp_obj[MICROPY_HW_USB_CDC_NUM] = {
+    {{&pyb_usb_vcp_type}, &usb_device.usbd_cdc_itf[0]},
+    #if MICROPY_HW_USB_CDC_NUM >= 2
+    {{&pyb_usb_vcp_type}, &usb_device.usbd_cdc_itf[1]},
+    #endif
+    #if MICROPY_HW_USB_CDC_NUM >= 3
+    {{&pyb_usb_vcp_type}, &usb_device.usbd_cdc_itf[2]},
+    #endif
+};
+
+STATIC void pyb_usb_vcp_init0(void) {
+    // Activate USB_VCP(0) on dupterm slot 1 for the REPL
+    MP_STATE_VM(dupterm_objs[1]) = MP_OBJ_FROM_PTR(&pyb_usb_vcp_obj[0]);
+    usb_vcp_attach_to_repl(&pyb_usb_vcp_obj[0], true);
+}
 
 STATIC void pyb_usb_vcp_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
-    int id = ((pyb_usb_vcp_obj_t*)MP_OBJ_TO_PTR(self_in))->cdc_itf - &usb_device.usbd_cdc_itf;
+    int id = ((pyb_usb_vcp_obj_t *)MP_OBJ_TO_PTR(self_in))->cdc_itf - &usb_device.usbd_cdc_itf[0];
     mp_printf(print, "USB_VCP(%u)", id);
 }
 
 void usb_vcp_attach_to_repl(const pyb_usb_vcp_obj_t *self, bool attached) {
     self->cdc_itf->attached_to_repl = attached;
+    if (attached) {
+        // Default behavior is non-blocking when attached to repl
+        self->cdc_itf->flow &= ~USBD_CDC_FLOWCONTROL_CTS;
+    } else {
+        self->cdc_itf->flow |= USBD_CDC_FLOWCONTROL_CTS;
+    }
 }
 
 /// \classmethod \constructor()
@@ -407,12 +651,8 @@ STATIC mp_obj_t pyb_usb_vcp_make_new(const mp_obj_type_t *type, size_t n_args, s
     // TODO raise exception if USB is not configured for VCP
 
     int id = (n_args == 0) ? 0 : mp_obj_get_int(args[0]);
-    if (id == 0) {
-        return MP_OBJ_FROM_PTR(&pyb_usb_vcp_obj);
-    #if MICROPY_HW_USB_ENABLE_CDC2
-    } else if (id == 1) {
-        return MP_OBJ_FROM_PTR(&pyb_usb_vcp2_obj);
-    #endif
+    if (0 <= id && id < MICROPY_HW_USB_CDC_NUM) {
+        return MP_OBJ_FROM_PTR(&pyb_usb_vcp_obj[id]);
     } else {
         mp_raise_ValueError(NULL);
     }
@@ -453,7 +693,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_usb_vcp_isconnected_obj, pyb_usb_vcp_isconn
 
 // deprecated in favour of USB_VCP.isconnected
 STATIC mp_obj_t pyb_have_cdc(void) {
-    return pyb_usb_vcp_isconnected(MP_OBJ_FROM_PTR(&pyb_usb_vcp_obj));
+    return pyb_usb_vcp_isconnected(MP_OBJ_FROM_PTR(&pyb_usb_vcp_obj[0]));
 }
 MP_DEFINE_CONST_FUN_OBJ_0(pyb_have_cdc_obj, pyb_have_cdc);
 
@@ -521,7 +761,7 @@ STATIC mp_obj_t pyb_usb_vcp_recv(size_t n_args, const mp_obj_t *args, mp_map_t *
     mp_obj_t o_ret = pyb_buf_get_for_recv(vals[0].u_obj, &vstr);
 
     // receive the data
-    int ret = usbd_cdc_rx(self->cdc_itf, (uint8_t*)vstr.buf, vstr.len, vals[1].u_int);
+    int ret = usbd_cdc_rx(self->cdc_itf, (uint8_t *)vstr.buf, vstr.len, vals[1].u_int);
 
     // return the received data
     if (o_ret != MP_OBJ_NULL) {
@@ -557,13 +797,14 @@ STATIC const mp_rom_map_elem_t pyb_usb_vcp_locals_dict_table[] = {
 
     // class constants
     { MP_ROM_QSTR(MP_QSTR_RTS), MP_ROM_INT(USBD_CDC_FLOWCONTROL_RTS) },
+    { MP_ROM_QSTR(MP_QSTR_CTS), MP_ROM_INT(USBD_CDC_FLOWCONTROL_CTS) },
 };
 
 STATIC MP_DEFINE_CONST_DICT(pyb_usb_vcp_locals_dict, pyb_usb_vcp_locals_dict_table);
 
 STATIC mp_uint_t pyb_usb_vcp_read(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode) {
     pyb_usb_vcp_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    int ret = usbd_cdc_rx(self->cdc_itf, (byte*)buf, size, 0);
+    int ret = usbd_cdc_rx(self->cdc_itf, (byte *)buf, size, 0);
     if (ret == 0) {
         // return EAGAIN error to indicate non-blocking
         *errcode = MP_EAGAIN;
@@ -574,18 +815,13 @@ STATIC mp_uint_t pyb_usb_vcp_read(mp_obj_t self_in, void *buf, mp_uint_t size, i
 
 STATIC mp_uint_t pyb_usb_vcp_write(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode) {
     pyb_usb_vcp_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    if (self->cdc_itf->attached_to_repl) {
-        usbd_cdc_tx_always(self->cdc_itf, (const byte*)buf, size);
-        return size;
-    } else {
-        int ret = usbd_cdc_tx(self->cdc_itf, (const byte*)buf, size, 0);
-        if (ret == 0) {
-            // return EAGAIN error to indicate non-blocking
-            *errcode = MP_EAGAIN;
-            return MP_STREAM_ERROR;
-        }
-        return ret;
+    int ret = usbd_cdc_tx_flow(self->cdc_itf, (const byte *)buf, size);
+    if (ret == 0) {
+        // return EAGAIN error to indicate non-blocking
+        *errcode = MP_EAGAIN;
+        return MP_STREAM_ERROR;
     }
+    return ret;
 }
 
 STATIC mp_uint_t pyb_usb_vcp_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
@@ -621,12 +857,14 @@ const mp_obj_type_t pyb_usb_vcp_type = {
     .getiter = mp_identity_getiter,
     .iternext = mp_stream_unbuffered_iter,
     .protocol = &pyb_usb_vcp_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&pyb_usb_vcp_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_usb_vcp_locals_dict,
 };
 
 /******************************************************************************/
 // MicroPython bindings for USB HID
 
+#if MICROPY_HW_USB_HID
+
 typedef struct _pyb_usb_hid_obj_t {
     mp_obj_base_t base;
     usb_device_t *usb_dev;
@@ -670,7 +908,12 @@ STATIC mp_obj_t pyb_usb_hid_recv(size_t n_args, const mp_obj_t *args, mp_map_t *
     mp_obj_t o_ret = pyb_buf_get_for_recv(vals[0].u_obj, &vstr);
 
     // receive the data
-    int ret = usbd_hid_rx(&self->usb_dev->usbd_hid_itf, vstr.len, (uint8_t*)vstr.buf, vals[1].u_int);
+    int ret = usbd_hid_rx(&self->usb_dev->usbd_hid_itf, vstr.len, (uint8_t *)vstr.buf, vals[1].u_int);
+
+    if (ret < 0) {
+        // error, just return 0/empty bytes
+        ret = 0;
+    }
 
     // return the received data
     if (o_ret != MP_OBJ_NULL) {
@@ -692,7 +935,7 @@ STATIC mp_obj_t pyb_usb_hid_send(mp_obj_t self_in, mp_obj_t report_in) {
         mp_obj_t *items;
         mp_obj_get_array(report_in, &bufinfo.len, &items);
         if (bufinfo.len > sizeof(temp_buf)) {
-            mp_raise_ValueError("tuple/list too large for HID report; use bytearray instead");
+            mp_raise_ValueError(MP_ERROR_TEXT("tuple/list too large for HID report; use bytearray instead"));
         }
         for (int i = 0; i < bufinfo.len; i++) {
             temp_buf[i] = mp_obj_get_int(items[i]);
@@ -752,9 +995,11 @@ const mp_obj_type_t pyb_usb_hid_type = {
     .name = MP_QSTR_USB_HID,
     .make_new = pyb_usb_hid_make_new,
     .protocol = &pyb_usb_hid_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&pyb_usb_hid_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_usb_hid_locals_dict,
 };
 
+#endif // MICROPY_HW_USB_HID
+
 /******************************************************************************/
 // code for experimental USB OTG support
 
@@ -767,7 +1012,7 @@ const mp_obj_type_t pyb_usb_hid_type = {
 #include "usbh_hid_keybd.h"
 #include "usbh_hid_mouse.h"
 
-__ALIGN_BEGIN USBH_HOST USB_Host __ALIGN_END ;
+__ALIGN_BEGIN USBH_HOST USB_Host __ALIGN_END;
 
 static int host_is_enabled = 0;
 
diff --git a/ports/stm32/usb.h b/ports/stm32/usb.h
index 2a3861f210c14..f69af86e5b366 100644
--- a/ports/stm32/usb.h
+++ b/ports/stm32/usb.h
@@ -37,6 +37,12 @@
 #define USBD_PID_CDC     (0x9802)
 #define USBD_PID_MSC     (0x9803)
 #define USBD_PID_CDC2_MSC (0x9804)
+#define USBD_PID_CDC2    (0x9805)
+#define USBD_PID_CDC3    (0x9806)
+#define USBD_PID_CDC3_MSC (0x9807)
+#define USBD_PID_CDC_MSC_HID (0x9808)
+#define USBD_PID_CDC2_MSC_HID (0x9809)
+#define USBD_PID_CDC3_MSC_HID (0x980a)
 
 typedef enum {
     PYB_USB_STORAGE_MEDIUM_NONE = 0,
@@ -57,18 +63,18 @@ extern const struct _mp_rom_obj_tuple_t pyb_usb_hid_mouse_obj;
 extern const struct _mp_rom_obj_tuple_t pyb_usb_hid_keyboard_obj;
 extern const mp_obj_type_t pyb_usb_vcp_type;
 extern const mp_obj_type_t pyb_usb_hid_type;
-extern const pyb_usb_vcp_obj_t pyb_usb_vcp_obj;
 
 MP_DECLARE_CONST_FUN_OBJ_KW(pyb_usb_mode_obj);
 MP_DECLARE_CONST_FUN_OBJ_0(pyb_have_cdc_obj); // deprecated
 MP_DECLARE_CONST_FUN_OBJ_1(pyb_hid_send_report_obj); // deprecated
 
 void pyb_usb_init0(void);
-bool pyb_usb_dev_init(uint16_t vid, uint16_t pid, usb_device_mode_t mode, USBD_HID_ModeInfoTypeDef *hid_info);
+int pyb_usb_dev_detect(void);
+bool pyb_usb_dev_init(int dev_id, uint16_t vid, uint16_t pid, uint8_t mode, size_t msc_n, const void *msc_unit, USBD_HID_ModeInfoTypeDef *hid_info);
 void pyb_usb_dev_deinit(void);
 bool usb_vcp_is_enabled(void);
 int usb_vcp_recv_byte(uint8_t *c); // if a byte is available, return 1 and put the byte in *c, else return 0
-void usb_vcp_send_strn(const char* str, int len);
+void usb_vcp_send_strn(const char *str, int len);
 void usb_vcp_attach_to_repl(const pyb_usb_vcp_obj_t *self, bool attached);
 
 void pyb_usb_host_init(void);
diff --git a/ports/stm32/usbd_cdc_interface.c b/ports/stm32/usbd_cdc_interface.c
index 586f2d525e007..a0e19de9750aa 100644
--- a/ports/stm32/usbd_cdc_interface.c
+++ b/ports/stm32/usbd_cdc_interface.c
@@ -62,25 +62,31 @@
 static uint8_t usbd_cdc_connect_tx_timer;
 
 uint8_t *usbd_cdc_init(usbd_cdc_state_t *cdc_in) {
-    usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t*)cdc_in;
+    usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t *)cdc_in;
 
-    // Reset all the CDC state
-    // Note: we don't reset tx_buf_ptr_in in order to allow the output buffer to
-    // be filled (by usbd_cdc_tx_always) before the USB device is connected.
+    // Reset the CDC state due to a new USB host connection
+    // Note: we don't reset tx_buf_ptr_* in order to allow the output buffer to
+    // be filled (by usbd_cdc_tx_always) before the USB device is connected, and
+    // to retain transmit buffer state across multiple USB connections (they will
+    // be 0 at MCU reset since the variables live in the BSS).
     cdc->rx_buf_put = 0;
     cdc->rx_buf_get = 0;
     cdc->rx_buf_full = false;
-    cdc->tx_buf_ptr_out = 0;
-    cdc->tx_buf_ptr_out_shadow = 0;
     cdc->tx_need_empty_packet = 0;
     cdc->connect_state = USBD_CDC_CONNECT_STATE_DISCONNECTED;
+    if (cdc->attached_to_repl) {
+        // Default behavior is non-blocking when attached to repl
+        cdc->flow &= ~USBD_CDC_FLOWCONTROL_CTS;
+    } else {
+        cdc->flow |= USBD_CDC_FLOWCONTROL_CTS;
+    }
 
     // Return the buffer to place the first USB OUT packet
     return cdc->rx_packet_buf;
 }
 
 void usbd_cdc_deinit(usbd_cdc_state_t *cdc_in) {
-    usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t*)cdc_in;
+    usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t *)cdc_in;
     cdc->connect_state = USBD_CDC_CONNECT_STATE_DISCONNECTED;
 }
 
@@ -89,8 +95,8 @@ void usbd_cdc_deinit(usbd_cdc_state_t *cdc_in) {
 // pbuf: buffer containing command data (request parameters)
 // length: number of data to be sent (in bytes)
 // Returns USBD_OK if all operations are OK else USBD_FAIL
-int8_t usbd_cdc_control(usbd_cdc_state_t *cdc_in, uint8_t cmd, uint8_t* pbuf, uint16_t length) {
-    usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t*)cdc_in;
+int8_t usbd_cdc_control(usbd_cdc_state_t *cdc_in, uint8_t cmd, uint8_t *pbuf, uint16_t length) {
+    usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t *)cdc_in;
 
     switch (cmd) {
         case CDC_SEND_ENCAPSULATED_COMMAND:
@@ -115,11 +121,11 @@ int8_t usbd_cdc_control(usbd_cdc_state_t *cdc_in, uint8_t cmd, uint8_t* pbuf, ui
 
         case CDC_SET_LINE_CODING:
             #if 0
-            LineCoding.bitrate    = (uint32_t)(pbuf[0] | (pbuf[1] << 8) |\
-                                    (pbuf[2] << 16) | (pbuf[3] << 24));
-            LineCoding.format     = pbuf[4];
+            LineCoding.bitrate = (uint32_t)(pbuf[0] | (pbuf[1] << 8) | \
+                (pbuf[2] << 16) | (pbuf[3] << 24));
+            LineCoding.format = pbuf[4];
             LineCoding.paritytype = pbuf[5];
-            LineCoding.datatype   = pbuf[6];
+            LineCoding.datatype = pbuf[6];
             /* Set the new configuration */
             #endif
             break;
@@ -140,11 +146,14 @@ int8_t usbd_cdc_control(usbd_cdc_state_t *cdc_in, uint8_t cmd, uint8_t* pbuf, ui
             if (length & 1) {
                 // The actual connection state is delayed to give the host a chance to
                 // configure its serial port (in most cases to disable local echo)
-                PCD_HandleTypeDef *hpcd = cdc->base.usbd->pdev->pData;
-                USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
                 cdc->connect_state = USBD_CDC_CONNECT_STATE_CONNECTING;
                 usbd_cdc_connect_tx_timer = 8; // wait for 8 SOF IRQs
-                USBx->GINTMSK |= USB_OTG_GINTMSK_SOFM;
+                #if !MICROPY_HW_USB_IS_MULTI_OTG
+                USB->CNTR |= USB_CNTR_SOFM;
+                #else
+                PCD_HandleTypeDef *hpcd = cdc->base.usbd->pdev->pData;
+                hpcd->Instance->GINTMSK |= USB_OTG_GINTMSK_SOFM;
+                #endif
             } else {
                 cdc->connect_state = USBD_CDC_CONNECT_STATE_DISCONNECTED;
             }
@@ -166,7 +175,7 @@ int8_t usbd_cdc_control(usbd_cdc_state_t *cdc_in, uint8_t cmd, uint8_t* pbuf, ui
 // (cdc.base.tx_in_progress must be 0)
 void usbd_cdc_tx_ready(usbd_cdc_state_t *cdc_in) {
 
-    usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t*)cdc_in;
+    usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t *)cdc_in;
     cdc->tx_buf_ptr_out = cdc->tx_buf_ptr_out_shadow;
 
     if (cdc->tx_buf_ptr_out == cdc->tx_buf_ptr_in && !cdc->tx_need_empty_packet) {
@@ -215,26 +224,25 @@ void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd) {
     if (usbd_cdc_connect_tx_timer > 0) {
         --usbd_cdc_connect_tx_timer;
     } else {
-        usbd_cdc_msc_hid_state_t *usbd = ((USBD_HandleTypeDef*)hpcd->pData)->pClassData;
+        usbd_cdc_msc_hid_state_t *usbd = ((USBD_HandleTypeDef *)hpcd->pData)->pClassData;
+        #if !MICROPY_HW_USB_IS_MULTI_OTG
+        USB->CNTR &= ~USB_CNTR_SOFM;
+        #else
         hpcd->Instance->GINTMSK &= ~USB_OTG_GINTMSK_SOFM;
-        usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t*)usbd->cdc;
-        if (cdc->connect_state == USBD_CDC_CONNECT_STATE_CONNECTING) {
-            cdc->connect_state = USBD_CDC_CONNECT_STATE_CONNECTED;
-            usbd_cdc_try_tx(cdc);
-        }
-        #if MICROPY_HW_USB_ENABLE_CDC2
-        cdc = (usbd_cdc_itf_t*)usbd->cdc2;
-        if (cdc->connect_state == USBD_CDC_CONNECT_STATE_CONNECTING) {
-            cdc->connect_state = USBD_CDC_CONNECT_STATE_CONNECTED;
-            usbd_cdc_try_tx(cdc);
-        }
         #endif
+        for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
+            usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t *)usbd->cdc[i];
+            if (cdc->connect_state == USBD_CDC_CONNECT_STATE_CONNECTING) {
+                cdc->connect_state = USBD_CDC_CONNECT_STATE_CONNECTED;
+                usbd_cdc_try_tx(cdc);
+            }
+        }
     }
 }
 
 bool usbd_cdc_rx_buffer_full(usbd_cdc_itf_t *cdc) {
     int get = cdc->rx_buf_get, put = cdc->rx_buf_put;
-    int remaining = (get - put) + (-((int) (get <= put)) & USBD_CDC_RX_DATA_SIZE);
+    int remaining = (get - put) + (-((int)(get <= put)) & USBD_CDC_RX_DATA_SIZE);
     return remaining < CDC_DATA_MAX_PACKET_SIZE + 1;
 }
 
@@ -255,11 +263,11 @@ void usbd_cdc_rx_check_resume(usbd_cdc_itf_t *cdc) {
 // len: number of bytes received into the buffer we passed to USBD_CDC_ReceivePacket
 // Returns USBD_OK if all operations are OK else USBD_FAIL
 int8_t usbd_cdc_receive(usbd_cdc_state_t *cdc_in, size_t len) {
-    usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t*)cdc_in;
+    usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t *)cdc_in;
 
     // copy the incoming data into the circular buffer
     for (const uint8_t *src = cdc->rx_packet_buf, *top = cdc->rx_packet_buf + len; src < top; ++src) {
-        if (cdc->attached_to_repl && mp_interrupt_char != -1 && *src == mp_interrupt_char) {
+        if (cdc->attached_to_repl && *src == mp_interrupt_char) {
             pendsv_kbd_intr();
         } else {
             uint16_t next_put = (cdc->rx_buf_put + 1) & (USBD_CDC_RX_DATA_SIZE - 1);
@@ -290,6 +298,19 @@ int usbd_cdc_tx_half_empty(usbd_cdc_itf_t *cdc) {
     return tx_waiting <= USBD_CDC_TX_DATA_SIZE / 2;
 }
 
+// Writes only the data that fits if flow & CTS, else writes all data
+// Returns number of bytes actually written to the device
+int usbd_cdc_tx_flow(usbd_cdc_itf_t *cdc, const uint8_t *buf, uint32_t len) {
+    if (cdc->flow & USBD_CDC_FLOWCONTROL_CTS) {
+        // Only write as much as can fit in tx buffer
+        return usbd_cdc_tx(cdc, buf, len, 0);
+    } else {
+        // Never block, keep most recent data in rolling buffer
+        usbd_cdc_tx_always(cdc, buf, len);
+        return len;
+    }
+}
+
 // timout in milliseconds.
 // Returns number of bytes written to the device.
 int usbd_cdc_tx(usbd_cdc_itf_t *cdc, const uint8_t *buf, uint32_t len, uint32_t timeout) {
@@ -297,7 +318,7 @@ int usbd_cdc_tx(usbd_cdc_itf_t *cdc, const uint8_t *buf, uint32_t len, uint32_t
         // Wait until the device is connected and the buffer has space, with a given timeout
         uint32_t start = HAL_GetTick();
         while (cdc->connect_state == USBD_CDC_CONNECT_STATE_DISCONNECTED
-            || ((cdc->tx_buf_ptr_in + 1) & (USBD_CDC_TX_DATA_SIZE - 1)) == cdc->tx_buf_ptr_out) {
+               || ((cdc->tx_buf_ptr_in + 1) & (USBD_CDC_TX_DATA_SIZE - 1)) == cdc->tx_buf_ptr_out) {
             usbd_cdc_try_tx(cdc);
             // Wraparound of tick is taken care of by 2's complement arithmetic.
             if (HAL_GetTick() - start >= timeout) {
diff --git a/ports/stm32/usbd_cdc_interface.h b/ports/stm32/usbd_cdc_interface.h
index 780d4816e836f..1847b3a6b0eb1 100644
--- a/ports/stm32/usbd_cdc_interface.h
+++ b/ports/stm32/usbd_cdc_interface.h
@@ -31,8 +31,12 @@
   ******************************************************************************
   */
 
+#ifndef USBD_CDC_RX_DATA_SIZE
 #define USBD_CDC_RX_DATA_SIZE (1024) // this must be 2 or greater, and a power of 2
+#endif
+#ifndef USBD_CDC_TX_DATA_SIZE
 #define USBD_CDC_TX_DATA_SIZE (1024) // I think this can be any value (was 2048)
+#endif
 
 // Values for connect_state
 #define USBD_CDC_CONNECT_STATE_DISCONNECTED (0)
@@ -42,6 +46,7 @@
 // Flow control settings
 #define USBD_CDC_FLOWCONTROL_NONE (0)
 #define USBD_CDC_FLOWCONTROL_RTS (1)
+#define USBD_CDC_FLOWCONTROL_CTS (2)
 
 typedef struct _usbd_cdc_itf_t {
     usbd_cdc_state_t base; // state for the base CDC layer
@@ -71,6 +76,7 @@ static inline int usbd_cdc_is_connected(usbd_cdc_itf_t *cdc) {
 }
 
 int usbd_cdc_tx_half_empty(usbd_cdc_itf_t *cdc);
+int usbd_cdc_tx_flow(usbd_cdc_itf_t *cdc, const uint8_t *buf, uint32_t len);
 int usbd_cdc_tx(usbd_cdc_itf_t *cdc, const uint8_t *buf, uint32_t len, uint32_t timeout);
 void usbd_cdc_tx_always(usbd_cdc_itf_t *cdc, const uint8_t *buf, uint32_t len);
 
diff --git a/ports/stm32/usbd_conf.c b/ports/stm32/usbd_conf.c
index b7c1665f0a214..d24881d202fbf 100644
--- a/ports/stm32/usbd_conf.c
+++ b/ports/stm32/usbd_conf.c
@@ -44,6 +44,11 @@ PCD_HandleTypeDef pcd_fs_handle;
 PCD_HandleTypeDef pcd_hs_handle;
 #endif
 
+#if !MICROPY_HW_USB_IS_MULTI_OTG
+// The MCU has a single USB device-only instance
+#define USB_OTG_FS USB
+#endif
+
 /*******************************************************************************
                        PCD BSP Routines
 *******************************************************************************/
@@ -57,6 +62,12 @@ void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd) {
     if (hpcd->Instance == USB_OTG_FS) {
         #if defined(STM32H7)
         const uint32_t otg_alt = GPIO_AF10_OTG1_FS;
+        #elif defined(STM32L0)
+        const uint32_t otg_alt = GPIO_AF0_USB;
+        #elif defined(STM32L432xx)
+        const uint32_t otg_alt = GPIO_AF10_USB_FS;
+        #elif defined(STM32WB)
+        const uint32_t otg_alt = GPIO_AF10_USB;
         #else
         const uint32_t otg_alt = GPIO_AF10_OTG_FS;
         #endif
@@ -83,7 +94,11 @@ void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd) {
         #endif
 
         // Enable USB FS Clocks
+        #if !MICROPY_HW_USB_IS_MULTI_OTG
+        __HAL_RCC_USB_CLK_ENABLE();
+        #else
         __USB_OTG_FS_CLK_ENABLE();
+        #endif
 
         #if defined(STM32L4)
         // Enable VDDUSB
@@ -97,8 +112,19 @@ void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd) {
         #endif
 
         // Configure and enable USB FS interrupt
+        #if defined(STM32L0)
+        NVIC_SetPriority(USB_IRQn, IRQ_PRI_OTG_FS);
+        HAL_NVIC_EnableIRQ(USB_IRQn);
+        #elif defined(STM32L432xx)
+        NVIC_SetPriority(USB_FS_IRQn, IRQ_PRI_OTG_FS);
+        HAL_NVIC_EnableIRQ(USB_FS_IRQn);
+        #elif defined(STM32WB)
+        NVIC_SetPriority(USB_LP_IRQn, IRQ_PRI_OTG_FS);
+        HAL_NVIC_EnableIRQ(USB_LP_IRQn);
+        #else
         NVIC_SetPriority(OTG_FS_IRQn, IRQ_PRI_OTG_FS);
         HAL_NVIC_EnableIRQ(OTG_FS_IRQn);
+        #endif
     }
     #if MICROPY_HW_USB_HS
     else if (hpcd->Instance == USB_OTG_HS) {
@@ -145,7 +171,7 @@ void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd) {
 
         // Configure USB HS GPIOs
         static const mp_hal_pin_obj_t usb_pins[] = {
-            pin_A5, pin_C0, pin_H4, pin_I11, // CLK, STP, NXT, DIR
+            pin_A5, pin_C0, MICROPY_HW_USB_HS_ULPI_NXT, MICROPY_HW_USB_HS_ULPI_DIR, // CLK, STP, NXT, DIR
             pin_A3, pin_B0, pin_B1, pin_B5, pin_B10, pin_B11, pin_B12, pin_B13, // D0-D7
         };
         for (size_t i = 0; i < MP_ARRAY_SIZE(usb_pins); ++i) {
@@ -174,6 +200,10 @@ void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd) {
   * @retval None
   */
 void HAL_PCD_MspDeInit(PCD_HandleTypeDef *hpcd) {
+    #if !MICROPY_HW_USB_IS_MULTI_OTG
+    __HAL_RCC_USB_CLK_DISABLE();
+    #else
+
     if (hpcd->Instance == USB_OTG_FS) {
         /* Disable USB FS Clocks */
         __USB_OTG_FS_CLK_DISABLE();
@@ -186,6 +216,8 @@ void HAL_PCD_MspDeInit(PCD_HandleTypeDef *hpcd) {
         __SYSCFG_CLK_DISABLE();
     }
     #endif
+
+    #endif
 }
 
 /*******************************************************************************
@@ -329,19 +361,21 @@ void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd) {
   * @param  pdev: Device handle
   * @retval USBD Status
   */
-USBD_StatusTypeDef USBD_LL_Init(USBD_HandleTypeDef *pdev, int high_speed) {
+USBD_StatusTypeDef USBD_LL_Init(USBD_HandleTypeDef *pdev, int high_speed, const uint8_t *fifo_size) {
     #if MICROPY_HW_USB_FS
-    if (pdev->id ==  USB_PHY_FS_ID) {
+    if (pdev->id == USB_PHY_FS_ID) {
+        #if defined(STM32WB)
+        PWR->CR2 |= PWR_CR2_USV; // USB supply is valid
+        #endif
+
         // Set LL Driver parameters
         pcd_fs_handle.Instance = USB_OTG_FS;
-        #if MICROPY_HW_USB_ENABLE_CDC2
+        #if MICROPY_HW_USB_CDC_NUM == 2
         pcd_fs_handle.Init.dev_endpoints = 6;
         #else
         pcd_fs_handle.Init.dev_endpoints = 4;
         #endif
-        pcd_fs_handle.Init.use_dedicated_ep1 = 0;
         pcd_fs_handle.Init.ep0_mps = 0x40;
-        pcd_fs_handle.Init.dma_enable = 0;
         pcd_fs_handle.Init.low_power_enable = 0;
         pcd_fs_handle.Init.phy_itface = PCD_PHY_EMBEDDED;
         pcd_fs_handle.Init.Sof_enable = 0;
@@ -350,11 +384,15 @@ USBD_StatusTypeDef USBD_LL_Init(USBD_HandleTypeDef *pdev, int high_speed) {
         pcd_fs_handle.Init.lpm_enable = DISABLE;
         pcd_fs_handle.Init.battery_charging_enable = DISABLE;
         #endif
+        #if MICROPY_HW_USB_IS_MULTI_OTG
+        pcd_fs_handle.Init.use_dedicated_ep1 = 0;
+        pcd_fs_handle.Init.dma_enable = 0;
         #if !defined(MICROPY_HW_USB_VBUS_DETECT_PIN)
         pcd_fs_handle.Init.vbus_sensing_enable = 0; // No VBUS Sensing on USB0
         #else
         pcd_fs_handle.Init.vbus_sensing_enable = 1;
         #endif
+        #endif
 
         // Link The driver to the stack
         pcd_fs_handle.pData = pdev;
@@ -363,21 +401,19 @@ USBD_StatusTypeDef USBD_LL_Init(USBD_HandleTypeDef *pdev, int high_speed) {
         // Initialize LL Driver
         HAL_PCD_Init(&pcd_fs_handle);
 
-        // We have 320 32-bit words in total to use here
-        #if MICROPY_HW_USB_ENABLE_CDC2
-        HAL_PCD_SetRxFiFo(&pcd_fs_handle, 128);
-        HAL_PCD_SetTxFiFo(&pcd_fs_handle, 0, 32); // EP0
-        HAL_PCD_SetTxFiFo(&pcd_fs_handle, 1, 64); // MSC / HID
-        HAL_PCD_SetTxFiFo(&pcd_fs_handle, 2, 16); // CDC CMD
-        HAL_PCD_SetTxFiFo(&pcd_fs_handle, 3, 32); // CDC DATA
-        HAL_PCD_SetTxFiFo(&pcd_fs_handle, 4, 16); // CDC2 CMD
-        HAL_PCD_SetTxFiFo(&pcd_fs_handle, 5, 32); // CDC2 DATA
+        // Set FIFO buffer sizes
+        #if !MICROPY_HW_USB_IS_MULTI_OTG
+        uint32_t fifo_offset = USBD_PMA_RESERVE; // need to reserve some data at start of FIFO
+        for (size_t i = 0; i < USBD_PMA_NUM_FIFO; ++i) {
+            uint16_t ep_addr = ((i & 1) * 0x80) | (i >> 1);
+            HAL_PCDEx_PMAConfig(&pcd_fs_handle, ep_addr, PCD_SNG_BUF, fifo_offset);
+            fifo_offset += fifo_size[i] * 4;
+        }
         #else
-        HAL_PCD_SetRxFiFo(&pcd_fs_handle, 128);
-        HAL_PCD_SetTxFiFo(&pcd_fs_handle, 0, 32); // EP0
-        HAL_PCD_SetTxFiFo(&pcd_fs_handle, 1, 64); // MSC / HID
-        HAL_PCD_SetTxFiFo(&pcd_fs_handle, 2, 32); // CDC CMD
-        HAL_PCD_SetTxFiFo(&pcd_fs_handle, 3, 64); // CDC DATA
+        HAL_PCD_SetRxFiFo(&pcd_fs_handle, fifo_size[0] * 4);
+        for (size_t i = 0; i < USBD_FS_NUM_TX_FIFO; ++i) {
+            HAL_PCD_SetTxFiFo(&pcd_fs_handle, i, fifo_size[1 + i] * 4);
+        }
         #endif
     }
     #endif
@@ -385,7 +421,11 @@ USBD_StatusTypeDef USBD_LL_Init(USBD_HandleTypeDef *pdev, int high_speed) {
     if (pdev->id == USB_PHY_HS_ID) {
         // Set LL Driver parameters
         pcd_hs_handle.Instance = USB_OTG_HS;
+        #if MICROPY_HW_USB_CDC_NUM == 3
+        pcd_hs_handle.Init.dev_endpoints = 8;
+        #else
         pcd_hs_handle.Init.dev_endpoints = 6;
+        #endif
         pcd_hs_handle.Init.use_dedicated_ep1 = 0;
         pcd_hs_handle.Init.ep0_mps = 0x40;
         pcd_hs_handle.Init.dma_enable = 0;
@@ -430,14 +470,12 @@ USBD_StatusTypeDef USBD_LL_Init(USBD_HandleTypeDef *pdev, int high_speed) {
         // Initialize LL Driver
         HAL_PCD_Init(&pcd_hs_handle);
 
-        // We have 1024 32-bit words in total to use here
-        HAL_PCD_SetRxFiFo(&pcd_hs_handle, 464);
-        HAL_PCD_SetTxFiFo(&pcd_hs_handle, 0, 32); // EP0
-        HAL_PCD_SetTxFiFo(&pcd_hs_handle, 1, 256); // MSC / HID
-        HAL_PCD_SetTxFiFo(&pcd_hs_handle, 2, 8); // CDC CMD
-        HAL_PCD_SetTxFiFo(&pcd_hs_handle, 3, 128); // CDC DATA
-        HAL_PCD_SetTxFiFo(&pcd_hs_handle, 4, 8); // CDC2 CMD
-        HAL_PCD_SetTxFiFo(&pcd_hs_handle, 5, 128); // CDC2 DATA
+        // Set FIFO buffer sizes
+        fifo_size += USBD_FS_NUM_FIFO; // skip over FS FIFO size values
+        HAL_PCD_SetRxFiFo(&pcd_hs_handle, fifo_size[0] * 4);
+        for (size_t i = 0; i < USBD_HS_NUM_TX_FIFO; ++i) {
+            HAL_PCD_SetTxFiFo(&pcd_hs_handle, i, fifo_size[1 + i] * 4);
+        }
     }
     #endif  // MICROPY_HW_USB_HS
 
@@ -593,7 +631,7 @@ USBD_StatusTypeDef USBD_LL_PrepareReceive(USBD_HandleTypeDef *pdev,
   * @param  ep_addr: Endpoint Number
   * @retval Recived Data Size
   */
-uint32_t USBD_LL_GetRxDataSize(USBD_HandleTypeDef *pdev, uint8_t  ep_addr) {
+uint32_t USBD_LL_GetRxDataSize(USBD_HandleTypeDef *pdev, uint8_t ep_addr) {
     return HAL_PCD_EP_GetRxCount(pdev->pData, ep_addr);
 }
 
diff --git a/ports/stm32/usbd_conf.h b/ports/stm32/usbd_conf.h
index c5faf6c8c8879..5237ba3a96e72 100644
--- a/ports/stm32/usbd_conf.h
+++ b/ports/stm32/usbd_conf.h
@@ -39,7 +39,7 @@
 
 #include "py/mpconfig.h"
 
-#define USBD_MAX_NUM_INTERFACES               4
+#define USBD_MAX_NUM_INTERFACES               8
 #define USBD_MAX_NUM_CONFIGURATION            1
 #define USBD_MAX_STR_DESC_SIZ                 0x100
 #if MICROPY_HW_USB_SELF_POWERED
@@ -49,6 +49,16 @@
 #endif
 #define USBD_DEBUG_LEVEL                      0
 
+// For MCUs with a device-only USB peripheral
+#define USBD_PMA_RESERVE                      (64)
+#define USBD_PMA_NUM_FIFO                     (8)
+
+// For MCUs with multiple OTG USB peripherals
+#define USBD_FS_NUM_TX_FIFO                   (6)
+#define USBD_FS_NUM_FIFO                      (1 + USBD_FS_NUM_TX_FIFO)
+#define USBD_HS_NUM_TX_FIFO                   (9)
+#define USBD_HS_NUM_FIFO                      (1 + USBD_HS_NUM_TX_FIFO)
+
 #endif // MICROPY_INCLUDED_STM32_USBD_CONF_H
 
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
diff --git a/ports/stm32/usbd_desc.c b/ports/stm32/usbd_desc.c
index a7de71ef20394..aa6837163de4d 100644
--- a/ports/stm32/usbd_desc.c
+++ b/ports/stm32/usbd_desc.c
@@ -37,7 +37,7 @@
 #include "py/mphal.h"
 
 // need this header for any overrides to the below constants
-#include "mpconfigboard.h"
+#include "py/mpconfig.h"
 
 #ifndef USBD_LANGID_STRING
 #define USBD_LANGID_STRING            0x409
@@ -119,7 +119,7 @@ void USBD_SetVIDPIDRelease(usbd_cdc_msc_hid_state_t *usbd, uint16_t vid, uint16_
   * @retval Pointer to descriptor buffer
   */
 STATIC uint8_t *USBD_DeviceDescriptor(USBD_HandleTypeDef *pdev, uint16_t *length) {
-    uint8_t *dev_desc = ((usbd_cdc_msc_hid_state_t*)pdev->pClassData)->usbd_device_desc;
+    uint8_t *dev_desc = ((usbd_cdc_msc_hid_state_t *)pdev->pClassData)->usbd_device_desc;
     *length = USB_LEN_DEV_DESC;
     return dev_desc;
 }
@@ -137,7 +137,7 @@ STATIC uint8_t *USBD_StrDescriptor(USBD_HandleTypeDef *pdev, uint8_t idx, uint16
     switch (idx) {
         case USBD_IDX_LANGID_STR:
             *length = sizeof(USBD_LangIDDesc);
-            return (uint8_t*)USBD_LangIDDesc; // the data should only be read from this buf
+            return (uint8_t *)USBD_LangIDDesc; // the data should only be read from this buf
 
         case USBD_IDX_MFC_STR:
             str = USBD_MANUFACTURER_STRING;
@@ -193,8 +193,8 @@ STATIC uint8_t *USBD_StrDescriptor(USBD_HandleTypeDef *pdev, uint8_t idx, uint16
             return NULL;
     }
 
-    uint8_t *str_desc = ((usbd_cdc_msc_hid_state_t*)pdev->pClassData)->usbd_str_desc;
-    USBD_GetString((uint8_t*)str, str_desc, length);
+    uint8_t *str_desc = ((usbd_cdc_msc_hid_state_t *)pdev->pClassData)->usbd_str_desc;
+    USBD_GetString((uint8_t *)str, str_desc, length);
     return str_desc;
 }
 
diff --git a/ports/stm32/usbd_hid_interface.c b/ports/stm32/usbd_hid_interface.c
index 3ffc0b425ddbc..c167fb38f2522 100644
--- a/ports/stm32/usbd_hid_interface.c
+++ b/ports/stm32/usbd_hid_interface.c
@@ -1,109 +1,71 @@
 /*
  * This file is part of the MicroPython project, http://micropython.org/
  *
- * Taken from ST Cube library and heavily modified.  See below for original
- * copyright header.
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
  */
 
-/**
-  ******************************************************************************
-  * @file    USB_Device/CDC_Standalone/Src/usbd_cdc_interface.c
-  * @author  MCD Application Team
-  * @version V1.0.1
-  * @date    26-February-2014
-  * @brief   Source file for USBD CDC interface
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
-  *
-  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
-  * You may not use this file except in compliance with the License.
-  * You may obtain a copy of the License at:
-  *
-  *        http://www.st.com/software_license_agreement_liberty_v2
-  *
-  * Unless required by applicable law or agreed to in writing, software
-  * distributed under the License is distributed on an "AS IS" BASIS,
-  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  * See the License for the specific language governing permissions and
-  * limitations under the License.
-  *
-  ******************************************************************************
-  */
-
-/* Includes ------------------------------------------------------------------*/
-
-#include <stdint.h>
-
 #include "usbd_hid_interface.h"
 
-#include "py/obj.h"
-#include "irq.h"
+#include "py/mpstate.h"
+#include "py/mperrno.h"
+#include "py/mphal.h"
 #include "usb.h"
 
-uint8_t *usbd_hid_init(usbd_hid_state_t *hid_in) {
-    usbd_hid_itf_t *hid = (usbd_hid_itf_t*)hid_in;
-
-    hid->current_read_buffer = 0;
-    hid->last_read_len = 0;
-    hid->current_write_buffer = 0;
+#if MICROPY_HW_USB_HID
 
-    // Return the buffer to place the first USB OUT packet
-    return hid->buffer[hid->current_write_buffer];
+uint8_t *usbd_hid_init(usbd_hid_state_t *hid_in) {
+    usbd_hid_itf_t *hid = (usbd_hid_itf_t *)hid_in;
+    hid->report_in_len = USBD_HID_REPORT_INVALID;
+    return &hid->report_in_buf[0]; // location to place first incoming report
 }
 
-// Data received over USB OUT endpoint is processed here.
-// len: number of bytes received into the buffer we passed to USBD_HID_ReceivePacket
-// Returns USBD_OK if all operations are OK else USBD_FAIL
 int8_t usbd_hid_receive(usbd_hid_state_t *hid_in, size_t len) {
-    usbd_hid_itf_t *hid = (usbd_hid_itf_t*)hid_in;
-
-    hid->current_write_buffer = !hid->current_write_buffer;
-    hid->last_read_len = len;
-    // initiate next USB packet transfer, to append to existing data in buffer
-    USBD_HID_ReceivePacket(&hid->base, hid->buffer[hid->current_write_buffer]);
-    // Set NAK to indicate we need to process read buffer
-    USBD_HID_SetNAK(&hid->base);
+    // Incoming report: save the length but don't schedule next report until user reads this one
+    usbd_hid_itf_t *hid = (usbd_hid_itf_t *)hid_in;
+    hid->report_in_len = len;
     return USBD_OK;
 }
 
-// Returns number of ready rx buffers.
-int usbd_hid_rx_num(usbd_hid_itf_t *hid) {
-    return hid->current_read_buffer != hid->current_write_buffer;
-}
-
-// timout in milliseconds.
-// Returns number of bytes read from the device.
-int usbd_hid_rx(usbd_hid_itf_t *hid, size_t len, uint8_t *buf, uint32_t timeout) {
-    // Wait until we have buffer to read
-    uint32_t start = HAL_GetTick();
-    while (hid->current_read_buffer == hid->current_write_buffer) {
-        // Wraparound of tick is taken care of by 2's complement arithmetic.
-        if (HAL_GetTick() - start >= timeout) {
-            // timeout
-            return 0;
+int usbd_hid_rx(usbd_hid_itf_t *hid, size_t len, uint8_t *buf, uint32_t timeout_ms) {
+    // Wait for an incoming report
+    uint32_t t0 = mp_hal_ticks_ms();
+    while (hid->report_in_len == USBD_HID_REPORT_INVALID) {
+        if (mp_hal_ticks_ms() - t0 >= timeout_ms || query_irq() == IRQ_STATE_DISABLED) {
+            return -MP_ETIMEDOUT;
         }
-        if (query_irq() == IRQ_STATE_DISABLED) {
-            // IRQs disabled so buffer will never be filled; return immediately
-            return 0;
-        }
-        __WFI(); // enter sleep mode, waiting for interrupt
-    }
-
-    // There is not enough space in buffer
-    if (len < hid->last_read_len) {
-        return 0;
+        MICROPY_EVENT_POLL_HOOK
     }
 
-    // Copy bytes from device to user buffer
-    int read_len = hid->last_read_len;
-    memcpy(buf, hid->buffer[hid->current_read_buffer], read_len);
-    hid->current_read_buffer = !hid->current_read_buffer;
+    // Copy bytes from report to user buffer
+    int n = MIN(len, hid->report_in_len);
+    memcpy(buf, &hid->report_in_buf[0], n);
 
-    // Clear NAK to indicate we are ready to read more data
-    USBD_HID_ClearNAK(&hid->base);
+    // Schedule to receive next incoming report
+    hid->report_in_len = USBD_HID_REPORT_INVALID;
+    USBD_HID_ReceivePacket(&hid->base, &hid->report_in_buf[0]);
 
-    // Success, return number of bytes read
-    return read_len;
+    // Return number of bytes read into user buffer
+    return n;
 }
+
+#endif // MICROPY_HW_USB_HID
diff --git a/ports/stm32/usbd_hid_interface.h b/ports/stm32/usbd_hid_interface.h
index 777fa93403052..5d2c9ad870f15 100644
--- a/ports/stm32/usbd_hid_interface.h
+++ b/ports/stm32/usbd_hid_interface.h
@@ -4,18 +4,22 @@
 #ifndef MICROPY_INCLUDED_STM32_USBD_HID_INTERFACE_H
 #define MICROPY_INCLUDED_STM32_USBD_HID_INTERFACE_H
 
+#include <stdint.h>
 #include "usbd_cdc_msc_hid.h"
 
+#define USBD_HID_REPORT_INVALID ((size_t)-1)
+
 typedef struct _usbd_hid_itf_t {
     usbd_hid_state_t base; // state for the base HID layer
 
-    uint8_t buffer[2][HID_DATA_FS_MAX_PACKET_SIZE]; // pair of buffers to read individual packets into
-    int8_t current_read_buffer; // which buffer to read from
-    uint32_t last_read_len; // length of last read
-    int8_t current_write_buffer; // which buffer to write to
+    volatile size_t report_in_len;
+    uint8_t report_in_buf[HID_DATA_FS_MAX_PACKET_SIZE];
 } usbd_hid_itf_t;
 
-int usbd_hid_rx_num(usbd_hid_itf_t *hid);
-int usbd_hid_rx(usbd_hid_itf_t *hid, size_t len, uint8_t *buf, uint32_t timeout);
+static inline int usbd_hid_rx_num(usbd_hid_itf_t *hid) {
+    return hid->report_in_len != USBD_HID_REPORT_INVALID;
+}
+
+int usbd_hid_rx(usbd_hid_itf_t *hid, size_t len, uint8_t *buf, uint32_t timeout_ms);
 
 #endif // MICROPY_INCLUDED_STM32_USBD_HID_INTERFACE_H
diff --git a/ports/stm32/usbd_msc_interface.c b/ports/stm32/usbd_msc_interface.c
new file mode 100644
index 0000000000000..62fe32bf5a0bb
--- /dev/null
+++ b/ports/stm32/usbd_msc_interface.c
@@ -0,0 +1,348 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdint.h>
+
+#include "usbd_cdc_msc_hid.h"
+#include "usbd_msc_interface.h"
+
+#include "extmod/vfs.h"
+#include "storage.h"
+#include "sdcard.h"
+
+#if MICROPY_HW_USB_MSC
+
+// This flag is needed to support removal of the medium, so that the USB drive
+// can be unmounted and won't be remounted automatically.
+#define FLAGS_STARTED (0x01)
+
+#define FLAGS_READONLY (0x02)
+
+STATIC const void *usbd_msc_lu_data[USBD_MSC_MAX_LUN];
+STATIC uint8_t usbd_msc_lu_num;
+STATIC uint16_t usbd_msc_lu_flags;
+
+static inline void lu_flag_set(uint8_t lun, uint8_t flag) {
+    usbd_msc_lu_flags |= flag << (lun * 2);
+}
+
+static inline void lu_flag_clr(uint8_t lun, uint8_t flag) {
+    usbd_msc_lu_flags &= ~(flag << (lun * 2));
+}
+
+static inline bool lu_flag_is_set(uint8_t lun, uint8_t flag) {
+    return usbd_msc_lu_flags & (flag << (lun * 2));
+}
+
+// Sent in response to MODE SENSE(6) command
+const uint8_t USBD_MSC_Mode_Sense6_Data[4] = {
+    0x03, // mode data length
+    0x00, // medium type
+    0x00, // bit 7: write protect
+    0x00, // block descriptor length
+};
+
+// Sent in response to MODE SENSE(10) command
+const uint8_t USBD_MSC_Mode_Sense10_Data[8] = {
+    0x00, 0x06, // mode data length
+    0x00, // medium type
+    0x00, // bit 7: write protect
+    0x00,
+    0x00,
+    0x00, 0x00, // block descriptor length
+};
+
+STATIC const uint8_t usbd_msc_vpd00[6] = {
+    0x00, // peripheral qualifier; peripheral device type
+    0x00, // page code
+    0x00, // reserved
+    2, // page length (additional bytes beyond this entry)
+    0x00, // page 0x00 supported
+    0x83, // page 0x83 supported
+};
+
+STATIC const uint8_t usbd_msc_vpd83[4] = {
+    0x00, // peripheral qualifier; peripheral device type
+    0x83, // page code
+    0x00, 0x00, // page length (additional bytes beyond this entry)
+};
+
+STATIC const int8_t usbd_msc_inquiry_data[36] = {
+    0x00, // peripheral qualifier; peripheral device type
+    0x80, // 0x00 for a fixed drive, 0x80 for a removable drive
+    0x02, // version
+    0x02, // response data format
+    (STANDARD_INQUIRY_DATA_LEN - 5), // additional length
+    0x00, // various flags
+    0x00, // various flags
+    0x00, // various flags
+    'M', 'i', 'c', 'r', 'o', 'P', 'y', ' ', // Manufacturer : 8 bytes
+    'p', 'y', 'b', 'o', 'a', 'r', 'd', ' ', // Product      : 16 Bytes
+    'F', 'l', 'a', 's', 'h', ' ', ' ', ' ',
+    '1', '.', '0','0',                      // Version      : 4 Bytes
+};
+
+// Set the logical units that will be exposed over MSC
+void usbd_msc_init_lu(size_t lu_n, const void *lu_data) {
+    usbd_msc_lu_num = MIN(lu_n, USBD_MSC_MAX_LUN);
+    memcpy(usbd_msc_lu_data, lu_data, sizeof(void *) * usbd_msc_lu_num);
+    usbd_msc_lu_flags = 0;
+}
+
+// Helper function to perform an ioctl on a logical unit
+STATIC int lu_ioctl(uint8_t lun, int op, uint32_t *data) {
+    if (lun >= usbd_msc_lu_num) {
+        return -1;
+    }
+    const void *lu = usbd_msc_lu_data[lun];
+
+    if (lu == &pyb_flash_type) {
+        switch (op) {
+            case MP_BLOCKDEV_IOCTL_INIT:
+                storage_init();
+                *data = 0;
+                return 0;
+            case MP_BLOCKDEV_IOCTL_SYNC:
+                storage_flush();
+                return 0;
+            case MP_BLOCKDEV_IOCTL_BLOCK_SIZE:
+                *data = storage_get_block_size();
+                return 0;
+            case MP_BLOCKDEV_IOCTL_BLOCK_COUNT:
+                *data = storage_get_block_count();
+                return 0;
+            default:
+                return -1;
+        }
+    #if MICROPY_HW_ENABLE_SDCARD
+    } else if (lu == &pyb_sdcard_type
+               #if MICROPY_HW_ENABLE_MMCARD
+               || lu == &pyb_mmcard_type
+               #endif
+               ) {
+        switch (op) {
+            case MP_BLOCKDEV_IOCTL_INIT:
+                if (!sdcard_power_on()) {
+                    return -1;
+                }
+                *data = 0;
+                return 0;
+            case MP_BLOCKDEV_IOCTL_SYNC:
+                return 0;
+            case MP_BLOCKDEV_IOCTL_BLOCK_SIZE:
+                *data = SDCARD_BLOCK_SIZE;
+                return 0;
+            case MP_BLOCKDEV_IOCTL_BLOCK_COUNT:
+                *data = sdcard_get_capacity_in_bytes() / (uint64_t)SDCARD_BLOCK_SIZE;
+                return 0;
+            default:
+                return -1;
+        }
+    #endif
+    } else {
+        return -1;
+    }
+}
+
+// Initialise all logical units (it's only ever called once, with lun_in=0)
+STATIC int8_t usbd_msc_Init(uint8_t lun_in) {
+    if (lun_in != 0) {
+        return 0;
+    }
+    for (int lun = 0; lun < usbd_msc_lu_num; ++lun) {
+        uint32_t data = 0;
+        int res = lu_ioctl(lun, MP_BLOCKDEV_IOCTL_INIT, &data);
+        if (res != 0) {
+            lu_flag_clr(lun, FLAGS_STARTED);
+        } else {
+            lu_flag_set(lun, FLAGS_STARTED);
+            if (data) {
+                lu_flag_set(lun, FLAGS_READONLY);
+            }
+        }
+    }
+    return 0;
+}
+
+// Process SCSI INQUIRY command for the logical unit
+STATIC int usbd_msc_Inquiry(uint8_t lun, const uint8_t *params, uint8_t *data_out) {
+    if (params[1] & 1) {
+        // EVPD set - return vital product data parameters
+        uint8_t page_code = params[2];
+        switch (page_code) {
+            case 0x00: // Supported VPD pages
+                memcpy(data_out, usbd_msc_vpd00, sizeof(usbd_msc_vpd00));
+                return sizeof(usbd_msc_vpd00);
+            case 0x83: // Device identification
+                memcpy(data_out, usbd_msc_vpd83, sizeof(usbd_msc_vpd83));
+                return sizeof(usbd_msc_vpd83);
+            default: // Unsupported
+                return -1;
+        }
+    }
+
+    // A standard inquiry
+
+    if (lun >= usbd_msc_lu_num) {
+        return -1;
+    }
+
+    uint8_t alloc_len = params[3] << 8 | params[4];
+    int len = MIN(sizeof(usbd_msc_inquiry_data), alloc_len);
+    memcpy(data_out, usbd_msc_inquiry_data, len);
+
+    #if MICROPY_HW_ENABLE_SDCARD
+    const void *lu = usbd_msc_lu_data[lun];
+    if (len == sizeof(usbd_msc_inquiry_data)) {
+        if (lu == &pyb_sdcard_type) {
+            memcpy(data_out + 24, "SDCard", sizeof("SDCard") - 1);
+        }
+        #if MICROPY_HW_ENABLE_MMCARD
+        else if (lu == &pyb_mmcard_type) {
+            memcpy(data_out + 24, "MMCard", sizeof("MMCard") - 1);
+        }
+        #endif
+    }
+    #endif
+
+    return len;
+}
+
+// Get storage capacity of a logical unit
+STATIC int8_t usbd_msc_GetCapacity(uint8_t lun, uint32_t *block_num, uint16_t *block_size) {
+    uint32_t block_size_u32 = 0;
+    int res = lu_ioctl(lun, MP_BLOCKDEV_IOCTL_BLOCK_SIZE, &block_size_u32);
+    if (res != 0) {
+        return -1;
+    }
+    *block_size = block_size_u32;
+    return lu_ioctl(lun, MP_BLOCKDEV_IOCTL_BLOCK_COUNT, block_num);
+}
+
+// Check if a logical unit is ready
+STATIC int8_t usbd_msc_IsReady(uint8_t lun) {
+    if (lun >= usbd_msc_lu_num) {
+        return -1;
+    }
+    return lu_flag_is_set(lun, FLAGS_STARTED) ? 0 : -1;
+}
+
+// Check if a logical unit is write protected
+STATIC int8_t usbd_msc_IsWriteProtected(uint8_t lun) {
+    if (lun >= usbd_msc_lu_num) {
+        return -1;
+    }
+    return lu_flag_is_set(lun, FLAGS_READONLY) ? 1 : 0;
+}
+
+// Start or stop a logical unit
+STATIC int8_t usbd_msc_StartStopUnit(uint8_t lun, uint8_t started) {
+    if (lun >= usbd_msc_lu_num) {
+        return -1;
+    }
+    if (started) {
+        lu_flag_set(lun, FLAGS_STARTED);
+    } else {
+        lu_flag_clr(lun, FLAGS_STARTED);
+    }
+    return 0;
+}
+
+// Prepare a logical unit for possible removal
+STATIC int8_t usbd_msc_PreventAllowMediumRemoval(uint8_t lun, uint8_t param) {
+    uint32_t dummy;
+    // Sync the logical unit so the device can be unplugged/turned off
+    return lu_ioctl(lun, MP_BLOCKDEV_IOCTL_SYNC, &dummy);
+}
+
+// Read data from a logical unit
+STATIC int8_t usbd_msc_Read(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len) {
+    if (lun >= usbd_msc_lu_num) {
+        return -1;
+    }
+    const void *lu = usbd_msc_lu_data[lun];
+
+    if (lu == &pyb_flash_type) {
+        storage_read_blocks(buf, blk_addr, blk_len);
+        return 0;
+    #if MICROPY_HW_ENABLE_SDCARD
+    } else if (lu == &pyb_sdcard_type
+               #if MICROPY_HW_ENABLE_MMCARD
+               || lu == &pyb_mmcard_type
+               #endif
+               ) {
+        if (sdcard_read_blocks(buf, blk_addr, blk_len) == 0) {
+            return 0;
+        }
+    #endif
+    }
+    return -1;
+}
+
+// Write data to a logical unit
+STATIC int8_t usbd_msc_Write(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len) {
+    if (lun >= usbd_msc_lu_num) {
+        return -1;
+    }
+    const void *lu = usbd_msc_lu_data[lun];
+
+    if (lu == &pyb_flash_type) {
+        storage_write_blocks(buf, blk_addr, blk_len);
+        return 0;
+    #if MICROPY_HW_ENABLE_SDCARD
+    } else if (lu == &pyb_sdcard_type
+               #if MICROPY_HW_ENABLE_MMCARD
+               || lu == &pyb_mmcard_type
+               #endif
+               ) {
+        if (sdcard_write_blocks(buf, blk_addr, blk_len) == 0) {
+            return 0;
+        }
+    #endif
+    }
+    return -1;
+}
+
+// Get the number of attached logical units
+STATIC int8_t usbd_msc_GetMaxLun(void) {
+    return usbd_msc_lu_num - 1;
+}
+
+// Table of operations for the SCSI layer to call
+const USBD_StorageTypeDef usbd_msc_fops = {
+    usbd_msc_Init,
+    usbd_msc_Inquiry,
+    usbd_msc_GetCapacity,
+    usbd_msc_IsReady,
+    usbd_msc_IsWriteProtected,
+    usbd_msc_StartStopUnit,
+    usbd_msc_PreventAllowMediumRemoval,
+    usbd_msc_Read,
+    usbd_msc_Write,
+    usbd_msc_GetMaxLun,
+};
+
+#endif // MICROPY_HW_USB_MSC
diff --git a/ports/stm32/usbd_msc_storage.h b/ports/stm32/usbd_msc_interface.h
similarity index 80%
rename from ports/stm32/usbd_msc_storage.h
rename to ports/stm32/usbd_msc_interface.h
index 669f7df5812a3..411c707cab7df 100644
--- a/ports/stm32/usbd_msc_storage.h
+++ b/ports/stm32/usbd_msc_interface.h
@@ -23,10 +23,13 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-#ifndef MICROPY_INCLUDED_STM32_USBD_MSC_STORAGE_H
-#define MICROPY_INCLUDED_STM32_USBD_MSC_STORAGE_H
+#ifndef MICROPY_INCLUDED_STM32_USBD_MSC_INTERFACE_H
+#define MICROPY_INCLUDED_STM32_USBD_MSC_INTERFACE_H
 
-extern const USBD_StorageTypeDef USBD_FLASH_STORAGE_fops;
-extern const USBD_StorageTypeDef USBD_SDCARD_STORAGE_fops;
+#define USBD_MSC_MAX_LUN (2)
 
-#endif // MICROPY_INCLUDED_STM32_USBD_MSC_STORAGE_H
+extern const USBD_StorageTypeDef usbd_msc_fops;
+
+void usbd_msc_init_lu(size_t lu_n, const void *lu_data);
+
+#endif // MICROPY_INCLUDED_STM32_USBD_MSC_INTERFACE_H
diff --git a/ports/stm32/usbd_msc_storage.c b/ports/stm32/usbd_msc_storage.c
deleted file mode 100644
index 01d15f6e75c77..0000000000000
--- a/ports/stm32/usbd_msc_storage.c
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
- * This file is part of the MicroPython project, http://micropython.org/
- */
-
-/**
-  ******************************************************************************
-  * @file    usbd_storage_msd.c
-  * @author  MCD application Team
-  * @version V1.1.0
-  * @date    19-March-2012
-  * @brief   This file provides the disk operations functions.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT 2012 STMicroelectronics</center></h2>
-  *
-  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
-  * You may not use this file except in compliance with the License.
-  * You may obtain a copy of the License at:
-  *
-  *        http://www.st.com/software_license_agreement_liberty_v2
-  *
-  * Unless required by applicable law or agreed to in writing, software
-  * distributed under the License is distributed on an "AS IS" BASIS,
-  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  * See the License for the specific language governing permissions and
-  * limitations under the License.
-  *
-  * Heavily modified by dpgeorge for MicroPython.
-  *
-  ******************************************************************************
-  */
-
-#include <stdint.h>
-
-#include "usbd_cdc_msc_hid.h"
-#include "usbd_msc_storage.h"
-
-#include "py/mpstate.h"
-#include "storage.h"
-#include "sdcard.h"
-
-// These are needed to support removal of the medium, so that the USB drive
-// can be unmounted, and won't be remounted automatically.
-static uint8_t flash_started = 0;
-
-#if MICROPY_HW_ENABLE_SDCARD
-static uint8_t sdcard_started = 0;
-#endif
-
-/******************************************************************************/
-// Callback functions for when the internal flash is the mass storage device
-
-static const int8_t FLASH_STORAGE_Inquirydata[] = { // 36 bytes
-    // LUN 0
-    0x00,
-    0x80, // 0x00 for a fixed drive, 0x80 for a removable drive
-    0x02,
-    0x02,
-    (STANDARD_INQUIRY_DATA_LEN - 5),
-    0x00,
-    0x00,
-    0x00,
-    'u', 'P', 'y', ' ', ' ', ' ', ' ', ' ', // Manufacturer : 8 bytes
-    'm', 'i', 'c', 'r', 'o', 'S', 'D', ' ', // Product      : 16 Bytes
-    'F', 'l', 'a', 's', 'h', ' ', ' ', ' ',
-    '1', '.', '0' ,'0',                     // Version      : 4 Bytes
-};
-
-/**
-  * @brief  Initialize the storage medium
-  * @param  lun : logical unit number
-  * @retval Status
-  */
-int8_t FLASH_STORAGE_Init(uint8_t lun) {
-    storage_init();
-    flash_started = 1;
-    return 0;
-}
-
-/**
-  * @brief  return medium capacity and block size
-  * @param  lun : logical unit number
-  * @param  block_num :  number of physical block
-  * @param  block_size : size of a physical block
-  * @retval Status
-  */
-int8_t FLASH_STORAGE_GetCapacity(uint8_t lun, uint32_t *block_num, uint16_t *block_size) {
-    *block_size = storage_get_block_size();
-    *block_num = storage_get_block_count();
-    return 0;
-}
-
-/**
-  * @brief  check whether the medium is ready
-  * @param  lun : logical unit number
-  * @retval Status
-  */
-int8_t FLASH_STORAGE_IsReady(uint8_t lun) {
-    if (flash_started) {
-        return 0;
-    }
-    return -1;
-}
-
-/**
-  * @brief  check whether the medium is write-protected
-  * @param  lun : logical unit number
-  * @retval Status
-  */
-int8_t FLASH_STORAGE_IsWriteProtected(uint8_t lun) {
-    return  0;
-}
-
-// Remove the lun
-int8_t FLASH_STORAGE_StartStopUnit(uint8_t lun, uint8_t started) {
-    flash_started = started;
-    return 0;
-}
-
-int8_t FLASH_STORAGE_PreventAllowMediumRemoval(uint8_t lun, uint8_t param) {
-    // sync the flash so that the cache is cleared and the device can be unplugged/turned off
-    storage_flush();
-    return 0;
-}
-
-/**
-  * @brief  Read data from the medium
-  * @param  lun : logical unit number
-  * @param  buf : Pointer to the buffer to save data
-  * @param  blk_addr :  address of 1st block to be read
-  * @param  blk_len : nmber of blocks to be read
-  * @retval Status
-  */
-int8_t FLASH_STORAGE_Read(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len) {
-    storage_read_blocks(buf, blk_addr, blk_len);
-    return 0;
-}
-
-/**
-  * @brief  Write data to the medium
-  * @param  lun : logical unit number
-  * @param  buf : Pointer to the buffer to write from
-  * @param  blk_addr :  address of 1st block to be written
-  * @param  blk_len : nmber of blocks to be read
-  * @retval Status
-  */
-int8_t FLASH_STORAGE_Write (uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len) {
-    storage_write_blocks(buf, blk_addr, blk_len);
-    return 0;
-}
-
-/**
-  * @brief  Return number of supported logical unit
-  * @param  None
-  * @retval number of logical unit
-  */
-int8_t FLASH_STORAGE_GetMaxLun(void) {
-    return 0;
-}
-
-const USBD_StorageTypeDef USBD_FLASH_STORAGE_fops = {
-    FLASH_STORAGE_Init,
-    FLASH_STORAGE_GetCapacity,
-    FLASH_STORAGE_IsReady,
-    FLASH_STORAGE_IsWriteProtected,
-    FLASH_STORAGE_StartStopUnit,
-    FLASH_STORAGE_PreventAllowMediumRemoval,
-    FLASH_STORAGE_Read,
-    FLASH_STORAGE_Write,
-    FLASH_STORAGE_GetMaxLun,
-    (int8_t *)FLASH_STORAGE_Inquirydata,
-};
-
-/******************************************************************************/
-// Callback functions for when the SD card is the mass storage device
-
-#if MICROPY_HW_ENABLE_SDCARD
-
-static const int8_t SDCARD_STORAGE_Inquirydata[] = { // 36 bytes
-    // LUN 0
-    0x00,
-    0x80, // 0x00 for a fixed drive, 0x80 for a removable drive
-    0x02,
-    0x02,
-    (STANDARD_INQUIRY_DATA_LEN - 5),
-    0x00,
-    0x00,
-    0x00,
-    'u', 'P', 'y', ' ', ' ', ' ', ' ', ' ', // Manufacturer : 8 bytes
-    'm', 'i', 'c', 'r', 'o', 'S', 'D', ' ', // Product      : 16 Bytes
-    'S', 'D', ' ', 'c', 'a', 'r', 'd', ' ',
-    '1', '.', '0' ,'0',                     // Version      : 4 Bytes
-};
-
-/**
-  * @brief  Initialize the storage medium
-  * @param  lun : logical unit number
-  * @retval Status
-  */
-int8_t SDCARD_STORAGE_Init(uint8_t lun) {
-    if (!sdcard_power_on()) {
-        return -1;
-    }
-    sdcard_started = 1;
-    return 0;
-
-}
-
-/**
-  * @brief  return medium capacity and block size
-  * @param  lun : logical unit number
-  * @param  block_num :  number of physical block
-  * @param  block_size : size of a physical block
-  * @retval Status
-  */
-int8_t SDCARD_STORAGE_GetCapacity(uint8_t lun, uint32_t *block_num, uint16_t *block_size) {
-    *block_size = SDCARD_BLOCK_SIZE;
-    *block_num =  sdcard_get_capacity_in_bytes() / SDCARD_BLOCK_SIZE;
-    return 0;
-}
-
-/**
-  * @brief  check whether the medium is ready
-  * @param  lun : logical unit number
-  * @retval Status
-  */
-int8_t SDCARD_STORAGE_IsReady(uint8_t lun) {
-    if (sdcard_started) {
-        return 0;
-    }
-    return -1;
-}
-
-/**
-  * @brief  check whether the medium is write-protected
-  * @param  lun : logical unit number
-  * @retval Status
-  */
-int8_t SDCARD_STORAGE_IsWriteProtected(uint8_t lun) {
-    return 0;
-}
-
-// Remove the lun
-int8_t SDCARD_STORAGE_StartStopUnit(uint8_t lun, uint8_t started) {
-    sdcard_started = started;
-    return 0;
-}
-
-int8_t SDCARD_STORAGE_PreventAllowMediumRemoval(uint8_t lun, uint8_t param) {
-    return 0;
-}
-
-/**
-  * @brief  Read data from the medium
-  * @param  lun : logical unit number
-  * @param  buf : Pointer to the buffer to save data
-  * @param  blk_addr :  address of 1st block to be read
-  * @param  blk_len : nmber of blocks to be read
-  * @retval Status
-  */
-int8_t SDCARD_STORAGE_Read(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len) {
-    if (sdcard_read_blocks(buf, blk_addr, blk_len) != 0) {
-        return -1;
-    }
-    return 0;
-}
-
-/**
-  * @brief  Write data to the medium
-  * @param  lun : logical unit number
-  * @param  buf : Pointer to the buffer to write from
-  * @param  blk_addr :  address of 1st block to be written
-  * @param  blk_len : nmber of blocks to be read
-  * @retval Status
-  */
-int8_t SDCARD_STORAGE_Write(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len) {
-    if (sdcard_write_blocks(buf, blk_addr, blk_len) != 0) {
-        return -1;
-    }
-    return 0;
-}
-
-/**
-  * @brief  Return number of supported logical unit
-  * @param  None
-  * @retval number of logical unit
-  */
-int8_t SDCARD_STORAGE_GetMaxLun(void) {
-    return 0;
-}
-
-const USBD_StorageTypeDef USBD_SDCARD_STORAGE_fops = {
-    SDCARD_STORAGE_Init,
-    SDCARD_STORAGE_GetCapacity,
-    SDCARD_STORAGE_IsReady,
-    SDCARD_STORAGE_IsWriteProtected,
-    SDCARD_STORAGE_StartStopUnit,
-    SDCARD_STORAGE_PreventAllowMediumRemoval,
-    SDCARD_STORAGE_Read,
-    SDCARD_STORAGE_Write,
-    SDCARD_STORAGE_GetMaxLun,
-    (int8_t *)SDCARD_STORAGE_Inquirydata,
-};
-
-#endif // MICROPY_HW_ENABLE_SDCARD
diff --git a/ports/stm32/usbdev/class/inc/usbd_cdc_msc_hid.h b/ports/stm32/usbdev/class/inc/usbd_cdc_msc_hid.h
index 1857273e0725e..d934f4676c4df 100644
--- a/ports/stm32/usbdev/class/inc/usbd_cdc_msc_hid.h
+++ b/ports/stm32/usbdev/class/inc/usbd_cdc_msc_hid.h
@@ -7,8 +7,7 @@
 #include  "usbd_ioreq.h"
 
 // These are included to get direct access the MICROPY_HW_USB_xxx config
-#include "mpconfigboard.h"
-#include "mpconfigboard_common.h"
+#include "py/mpconfig.h"
 
 // Work out if we should support USB high-speed device mode
 #if MICROPY_HW_USB_HS \
@@ -18,13 +17,9 @@
 #define USBD_SUPPORT_HS_MODE (0)
 #endif
 
-// Needed for the CDC+MSC+HID state and should be maximum of all template
-// config descriptors defined in usbd_cdc_msc_hid.c
-#if MICROPY_HW_USB_ENABLE_CDC2
-#define MAX_TEMPLATE_CONFIG_DESC_SIZE (9 + 23 + (8 + 58) + (8 + 58))
-#else
-#define MAX_TEMPLATE_CONFIG_DESC_SIZE (107)
-#endif
+// Should be maximum of possible config descriptors that might be configured
+// Maximum is: 9 + MSC + NxCDC + HID
+#define MAX_TEMPLATE_CONFIG_DESC_SIZE (9 + (23) + MICROPY_HW_USB_CDC_NUM * (8 + 58) + (9 + 9 + 7 + 7))
 
 // CDC, MSC and HID packet sizes
 #define MSC_FS_MAX_PACKET           (64)
@@ -58,6 +53,7 @@ typedef struct {
 
 typedef struct _USBD_STORAGE {
   int8_t (* Init) (uint8_t lun);
+  int    (* Inquiry) (uint8_t lun, const uint8_t *params, uint8_t *data_out);
   int8_t (* GetCapacity) (uint8_t lun, uint32_t *block_num, uint16_t *block_size);
   int8_t (* IsReady) (uint8_t lun);
   int8_t (* IsWriteProtected) (uint8_t lun);
@@ -66,7 +62,6 @@ typedef struct _USBD_STORAGE {
   int8_t (* Read) (uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len);
   int8_t (* Write)(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len);
   int8_t (* GetMaxLun)(void);
-  int8_t *pInquiry;
 } USBD_StorageTypeDef;
 
 typedef struct {
@@ -115,22 +110,26 @@ typedef struct _usbd_cdc_msc_hid_state_t {
     USBD_HandleTypeDef *pdev;
 
     uint8_t usbd_mode;
-    uint8_t usbd_config_desc_size;
+    uint16_t usbd_config_desc_size;
 
+    #if MICROPY_HW_USB_MSC
     USBD_MSC_BOT_HandleTypeDef MSC_BOT_ClassData;
+    #endif
 
     // RAM to hold the current descriptors, which we configure on the fly
     __ALIGN_BEGIN uint8_t usbd_device_desc[USB_LEN_DEV_DESC] __ALIGN_END;
     __ALIGN_BEGIN uint8_t usbd_str_desc[USBD_MAX_STR_DESC_SIZ] __ALIGN_END;
     __ALIGN_BEGIN uint8_t usbd_config_desc[MAX_TEMPLATE_CONFIG_DESC_SIZE] __ALIGN_END;
 
-    usbd_cdc_state_t *cdc;
-    #if MICROPY_HW_USB_ENABLE_CDC2
-    usbd_cdc_state_t *cdc2;
-    #endif
+    usbd_cdc_state_t *cdc[MICROPY_HW_USB_CDC_NUM];
+    #if MICROPY_HW_USB_HID
     usbd_hid_state_t *hid;
+    #endif
 } usbd_cdc_msc_hid_state_t;
 
+extern const uint8_t USBD_MSC_Mode_Sense6_Data[4];
+extern const uint8_t USBD_MSC_Mode_Sense10_Data[8];
+
 #define USBD_HID_MOUSE_MAX_PACKET          (4)
 #define USBD_HID_MOUSE_REPORT_DESC_SIZE    (74)
 
@@ -166,16 +165,18 @@ static inline uint32_t usbd_cdc_max_packet(USBD_HandleTypeDef *pdev) {
 }
 
 // returns 0 on success, -1 on failure
-int USBD_SelectMode(usbd_cdc_msc_hid_state_t *usbd, uint32_t mode, USBD_HID_ModeInfoTypeDef *hid_info);
+int USBD_SelectMode(usbd_cdc_msc_hid_state_t *usbd, uint32_t mode, USBD_HID_ModeInfoTypeDef *hid_info, uint8_t max_endpoint);
 // returns the current usb mode
 uint8_t USBD_GetMode(usbd_cdc_msc_hid_state_t *usbd);
 
 uint8_t USBD_CDC_ReceivePacket(usbd_cdc_state_t *cdc, uint8_t *buf);
 uint8_t USBD_CDC_TransmitPacket(usbd_cdc_state_t *cdc, size_t len, const uint8_t *buf);
 
+#if MICROPY_HW_USB_MSC
 static inline void USBD_MSC_RegisterStorage(usbd_cdc_msc_hid_state_t *usbd, USBD_StorageTypeDef *fops) {
     usbd->MSC_BOT_ClassData.bdev_ops = fops;
 }
+#endif
 
 uint8_t USBD_HID_ReceivePacket(usbd_hid_state_t *usbd, uint8_t *buf);
 int USBD_HID_CanSendReport(usbd_hid_state_t *usbd);
diff --git a/ports/stm32/usbdev/class/inc/usbd_cdc_msc_hid0.h b/ports/stm32/usbdev/class/inc/usbd_cdc_msc_hid0.h
index c876dcf2987b2..7614dde691fe1 100644
--- a/ports/stm32/usbdev/class/inc/usbd_cdc_msc_hid0.h
+++ b/ports/stm32/usbdev/class/inc/usbd_cdc_msc_hid0.h
@@ -29,18 +29,27 @@
 // these are exports for the CDC/MSC/HID interface that are independent
 // from any other definitions/declarations
 
-// only CDC_MSC and CDC_HID are available
-typedef enum {
-    USBD_MODE_CDC = 0x01,
-    USBD_MODE_MSC = 0x02,
-    USBD_MODE_HID = 0x04,
-    USBD_MODE_CDC2 = 0x08,
-    USBD_MODE_CDC_MSC = USBD_MODE_CDC | USBD_MODE_MSC,
-    USBD_MODE_CDC_HID = USBD_MODE_CDC | USBD_MODE_HID,
-    USBD_MODE_MSC_HID = USBD_MODE_MSC | USBD_MODE_HID,
-    USBD_MODE_CDC2_MSC = USBD_MODE_CDC | USBD_MODE_MSC | USBD_MODE_CDC2,
-    USBD_MODE_HIGH_SPEED = 0x80, // or with one of the above
-} usb_device_mode_t;
+// These can be or'd together (but not all combinations may be available)
+#define USBD_MODE_IFACE_MASK    (0x7f)
+#define USBD_MODE_IFACE_CDC(i)  (0x01 << (i))
+#define USBD_MODE_IFACE_HID     (0x10)
+#define USBD_MODE_IFACE_MSC     (0x20)
+#define USBD_MODE_HIGH_SPEED    (0x80)
+
+// Convenience macros for supported mode combinations
+#define USBD_MODE_CDC       (USBD_MODE_IFACE_CDC(0))
+#define USBD_MODE_CDC2      (USBD_MODE_IFACE_CDC(0) | USBD_MODE_IFACE_CDC(1))
+#define USBD_MODE_CDC3      (USBD_MODE_IFACE_CDC(0) | USBD_MODE_IFACE_CDC(1) | USBD_MODE_IFACE_CDC(2))
+#define USBD_MODE_CDC_HID   (USBD_MODE_IFACE_CDC(0) | USBD_MODE_IFACE_HID)
+#define USBD_MODE_CDC_MSC   (USBD_MODE_IFACE_CDC(0) | USBD_MODE_IFACE_MSC)
+#define USBD_MODE_CDC2_MSC  (USBD_MODE_IFACE_CDC(0) | USBD_MODE_IFACE_CDC(1) | USBD_MODE_IFACE_MSC)
+#define USBD_MODE_CDC3_MSC  (USBD_MODE_IFACE_CDC(0) | USBD_MODE_IFACE_CDC(1) | USBD_MODE_IFACE_CDC(2) | USBD_MODE_IFACE_MSC)
+#define USBD_MODE_CDC_MSC_HID (USBD_MODE_IFACE_CDC(0) | USBD_MODE_IFACE_MSC | USBD_MODE_IFACE_HID)
+#define USBD_MODE_CDC2_MSC_HID (USBD_MODE_IFACE_CDC(0) | USBD_MODE_IFACE_CDC(1) | USBD_MODE_IFACE_MSC | USBD_MODE_IFACE_HID)
+#define USBD_MODE_CDC3_MSC_HID (USBD_MODE_IFACE_CDC(0) | USBD_MODE_IFACE_CDC(1) | USBD_MODE_IFACE_CDC(2) | USBD_MODE_IFACE_MSC | USBD_MODE_IFACE_HID)
+#define USBD_MODE_HID       (USBD_MODE_IFACE_HID)
+#define USBD_MODE_MSC       (USBD_MODE_IFACE_MSC)
+#define USBD_MODE_MSC_HID   (USBD_MODE_IFACE_MSC | USBD_MODE_IFACE_HID)
 
 typedef struct _USBD_HID_ModeInfoTypeDef {
     uint8_t subclass; // 0=no sub class, 1=boot
diff --git a/ports/stm32/usbdev/class/inc/usbd_msc_data.h b/ports/stm32/usbdev/class/inc/usbd_msc_data.h
deleted file mode 100644
index afd39e4f0940e..0000000000000
--- a/ports/stm32/usbdev/class/inc/usbd_msc_data.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/**
-  ******************************************************************************
-  * @file    usbd_msc_data.h
-  * @author  MCD Application Team
-  * @version V2.0.0
-  * @date    18-February-2014
-  * @brief   header for the usbd_msc_data.c file
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT 2014 STMicroelectronics</center></h2>
-  *
-  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
-  * You may not use this file except in compliance with the License.
-  * You may obtain a copy of the License at:
-  *
-  *        http://www.st.com/software_license_agreement_liberty_v2
-  *
-  * Unless required by applicable law or agreed to in writing, software
-  * distributed under the License is distributed on an "AS IS" BASIS,
-  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  * See the License for the specific language governing permissions and
-  * limitations under the License.
-  *
-  ******************************************************************************
-  */
-
-/* Define to prevent recursive inclusion -------------------------------------*/
-
-#ifndef _USBD_MSC_DATA_H_
-#define _USBD_MSC_DATA_H_
-
-/* Includes ------------------------------------------------------------------*/
-#include "usbd_conf.h"
-
-/** @addtogroup STM32_USB_OTG_DEVICE_LIBRARY
-  * @{
-  */
-
-/** @defgroup USB_INFO
-  * @brief general defines for the usb device library file
-  * @{
-  */
-
-/** @defgroup USB_INFO_Exported_Defines
-  * @{
-  */
-#define MODE_SENSE6_LEN                  8
-#define MODE_SENSE10_LEN                 8
-#define LENGTH_INQUIRY_PAGE00            7
-#define LENGTH_FORMAT_CAPACITIES        20
-
-/**
-  * @}
-  */
-
-
-/** @defgroup USBD_INFO_Exported_TypesDefinitions
-  * @{
-  */
-/**
-  * @}
-  */
-
-
-
-/** @defgroup USBD_INFO_Exported_Macros
-  * @{
-  */
-
-/**
-  * @}
-  */
-
-/** @defgroup USBD_INFO_Exported_Variables
-  * @{
-  */
-extern const uint8_t MSC_Page00_Inquiry_Data[];
-extern const uint8_t MSC_Mode_Sense6_data[];
-extern const uint8_t MSC_Mode_Sense10_data[] ;
-
-/**
-  * @}
-  */
-
-/** @defgroup USBD_INFO_Exported_FunctionsPrototype
-  * @{
-  */
-
-/**
-  * @}
-  */
-
-#endif /* _USBD_MSC_DATA_H_ */
-
-/**
-  * @}
-  */
-
-/**
-* @}
-*/
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
diff --git a/ports/stm32/usbdev/class/src/usbd_cdc_msc_hid.c b/ports/stm32/usbdev/class/src/usbd_cdc_msc_hid.c
index a576796e27a6f..5e24730a0fac9 100644
--- a/ports/stm32/usbdev/class/src/usbd_cdc_msc_hid.c
+++ b/ports/stm32/usbdev/class/src/usbd_cdc_msc_hid.c
@@ -30,18 +30,26 @@
 
 #if MICROPY_HW_ENABLE_USB
 
-#define MSC_TEMPLATE_CONFIG_DESC_SIZE (32)
+#define HEAD_DESC_SIZE (9)
+#define MSC_CLASS_DESC_SIZE (9 + 7 + 7)
+#define CDC_CLASS_DESC_SIZE (8 + 58)
+#define HID_CLASS_DESC_SIZE (9 + 9 + 7 + 7)
+
 #define MSC_TEMPLATE_MSC_DESC_OFFSET (9)
-#define CDC_TEMPLATE_CONFIG_DESC_SIZE (67)
-#define CDC_MSC_TEMPLATE_CONFIG_DESC_SIZE (98)
 #define CDC_MSC_TEMPLATE_MSC_DESC_OFFSET (9)
 #define CDC_MSC_TEMPLATE_CDC_DESC_OFFSET (40)
-#define CDC2_MSC_TEMPLATE_CONFIG_DESC_SIZE (9 + 23 + (8 + 58) + (8 + 58))
+#define CDC2_TEMPLATE_CDC_DESC_OFFSET (9 + 8)
+#define CDC2_TEMPLATE_CDC2_DESC_OFFSET (9 + (8 + 58) + 8)
 #define CDC2_MSC_TEMPLATE_MSC_DESC_OFFSET (9)
 #define CDC2_MSC_TEMPLATE_CDC_DESC_OFFSET (9 + 23 + 8)
 #define CDC2_MSC_TEMPLATE_CDC2_DESC_OFFSET (9 + 23 + (8 + 58) + 8)
-#define CDC_HID_TEMPLATE_CONFIG_DESC_SIZE (107)
-#define CDC_HID_TEMPLATE_HID_DESC_OFFSET (9)
+#define CDC3_TEMPLATE_CDC_DESC_OFFSET (9 + 8)
+#define CDC3_TEMPLATE_CDC2_DESC_OFFSET (9 + (8 + 58) + 8)
+#define CDC3_TEMPLATE_CDC3_DESC_OFFSET (9 + (8 + 58) + (8 + 58) + 8)
+#define CDC3_MSC_TEMPLATE_MSC_DESC_OFFSET (9)
+#define CDC3_MSC_TEMPLATE_CDC_DESC_OFFSET (9 + 23 + 8)
+#define CDC3_MSC_TEMPLATE_CDC2_DESC_OFFSET (9 + 23 + (8 + 58) + 8)
+#define CDC3_MSC_TEMPLATE_CDC3_DESC_OFFSET (9 + 23 + (8 + 58) + (8 + 58) + 8)
 #define CDC_HID_TEMPLATE_CDC_DESC_OFFSET (49)
 #define CDC_TEMPLATE_CDC_DESC_OFFSET (9)
 #define CDC_DESC_OFFSET_INTR_INTERVAL (34)
@@ -53,9 +61,11 @@
 #define HID_DESC_OFFSET_PROTOCOL (7)
 #define HID_DESC_OFFSET_SUBDESC (9)
 #define HID_DESC_OFFSET_REPORT_DESC_LEN (16)
+#define HID_DESC_OFFSET_IN_EP (20)
 #define HID_DESC_OFFSET_MAX_PACKET_LO (22)
 #define HID_DESC_OFFSET_MAX_PACKET_HI (23)
 #define HID_DESC_OFFSET_POLLING_INTERVAL (24)
+#define HID_DESC_OFFSET_OUT_EP (27)
 #define HID_DESC_OFFSET_MAX_PACKET_OUT_LO (29)
 #define HID_DESC_OFFSET_MAX_PACKET_OUT_HI (30)
 #define HID_DESC_OFFSET_POLLING_INTERVAL_OUT (31)
@@ -63,24 +73,32 @@
 
 #define CDC_IFACE_NUM_ALONE (0)
 #define CDC_IFACE_NUM_WITH_MSC (1)
+#define CDC2_IFACE_NUM_WITH_CDC (2)
+#define CDC3_IFACE_NUM_WITH_CDC (4)
 #define CDC2_IFACE_NUM_WITH_MSC (3)
+#define CDC3_IFACE_NUM_WITH_MSC (5)
 #define CDC_IFACE_NUM_WITH_HID (1)
 #define MSC_IFACE_NUM_WITH_CDC (0)
 #define HID_IFACE_NUM_WITH_CDC (0)
 #define HID_IFACE_NUM_WITH_MSC (1)
+#define HID_IFACE_NUM_WITH_CDC_MSC (3)
+#define HID_IFACE_NUM_WITH_CDC2_MSC (5)
+#define HID_IFACE_NUM_WITH_CDC3_MSC (7)
 
-#define CDC_IN_EP (0x83)
-#define CDC_OUT_EP (0x03)
-#define CDC_CMD_EP (0x82)
-
-#define CDC2_IN_EP (0x85)
-#define CDC2_OUT_EP (0x05)
-#define CDC2_CMD_EP (0x84)
+#define CDC_IN_EP(i) (0x83 + 2 * (i))
+#define CDC_OUT_EP(i) (0x03 + 2 * (i))
+#define CDC_CMD_EP(i) (0x82 + 2 * (i))
 
 #define HID_IN_EP_WITH_CDC (0x81)
 #define HID_OUT_EP_WITH_CDC (0x01)
 #define HID_IN_EP_WITH_MSC (0x83)
 #define HID_OUT_EP_WITH_MSC (0x03)
+#define HID_IN_EP_WITH_CDC_MSC (0x84)
+#define HID_OUT_EP_WITH_CDC_MSC (0x04)
+#define HID_IN_EP_WITH_CDC2_MSC (0x86)
+#define HID_OUT_EP_WITH_CDC2_MSC (0x06)
+#define HID_IN_EP_WITH_CDC3_MSC (0x88)
+#define HID_OUT_EP_WITH_CDC3_MSC (0x08)
 
 #define USB_DESC_TYPE_ASSOCIATION (0x0b)
 
@@ -126,68 +144,24 @@ __ALIGN_BEGIN static uint8_t USBD_CDC_MSC_HID_DeviceQualifierDesc[USB_LEN_DEV_QU
 };
 #endif
 
-// USB MSC device Configuration Descriptor
-static const uint8_t msc_template_config_desc[MSC_TEMPLATE_CONFIG_DESC_SIZE] = {
+// USB partial configuration descriptor
+static const uint8_t head_desc_data[HEAD_DESC_SIZE] = {
     //--------------------------------------------------------------------------
     // Configuration Descriptor
     0x09,   // bLength: Configuration Descriptor size
     USB_DESC_TYPE_CONFIGURATION, // bDescriptorType: Configuration
-    LOBYTE(MSC_TEMPLATE_CONFIG_DESC_SIZE), // wTotalLength: no of returned bytes
-    HIBYTE(MSC_TEMPLATE_CONFIG_DESC_SIZE),
-    0x01,   // bNumInterfaces: 1 interfaces
+    0x00,   // wTotalLength -- to be filled in
+    0x00,   // wTotalLength -- to be filled in
+    0x00,   // bNumInterfaces -- to be filled in
     0x01,   // bConfigurationValue: Configuration value
     0x00,   // iConfiguration: Index of string descriptor describing the configuration
     CONFIG_DESC_ATTRIBUTES, // bmAttributes
     CONFIG_DESC_MAXPOWER, // bMaxPower
-
-    //==========================================================================
-    // MSC only has 1 interface so doesn't need an IAD
-
-    //--------------------------------------------------------------------------
-    // Interface Descriptor
-    0x09,   // bLength: Interface Descriptor size
-    USB_DESC_TYPE_INTERFACE, // bDescriptorType: interface descriptor
-    MSC_IFACE_NUM_WITH_CDC, // bInterfaceNumber: Number of Interface
-    0x00,   // bAlternateSetting: Alternate setting
-    0x02,   // bNumEndpoints
-    0x08,   // bInterfaceClass: MSC Class
-    0x06,   // bInterfaceSubClass : SCSI transparent
-    0x50,   // nInterfaceProtocol
-    0x00,   // iInterface:
-
-    // Endpoint IN descriptor
-    0x07,                           // bLength: Endpoint descriptor length
-    USB_DESC_TYPE_ENDPOINT,         // bDescriptorType: Endpoint descriptor type
-    MSC_IN_EP,                      // bEndpointAddress: IN, address 3
-    0x02,                           // bmAttributes: Bulk endpoint type
-    LOBYTE(MSC_FS_MAX_PACKET),      // wMaxPacketSize
-    HIBYTE(MSC_FS_MAX_PACKET),
-    0x00,                           // bInterval: ignore for Bulk transfer
-
-    // Endpoint OUT descriptor
-    0x07,                           // bLength: Endpoint descriptor length
-    USB_DESC_TYPE_ENDPOINT,         // bDescriptorType: Endpoint descriptor type
-    MSC_OUT_EP,                     // bEndpointAddress: OUT, address 3
-    0x02,                           // bmAttributes: Bulk endpoint type
-    LOBYTE(MSC_FS_MAX_PACKET),      // wMaxPacketSize
-    HIBYTE(MSC_FS_MAX_PACKET),
-    0x00,                           // bInterval: ignore for Bulk transfer
 };
 
-// USB CDC MSC device Configuration Descriptor
-static const uint8_t cdc_msc_template_config_desc[CDC_MSC_TEMPLATE_CONFIG_DESC_SIZE] = {
-    //--------------------------------------------------------------------------
-    // Configuration Descriptor
-    0x09,   // bLength: Configuration Descriptor size
-    USB_DESC_TYPE_CONFIGURATION, // bDescriptorType: Configuration
-    LOBYTE(CDC_MSC_TEMPLATE_CONFIG_DESC_SIZE), // wTotalLength: no of returned bytes
-    HIBYTE(CDC_MSC_TEMPLATE_CONFIG_DESC_SIZE),
-    0x03,   // bNumInterfaces: 3 interfaces
-    0x01,   // bConfigurationValue: Configuration value
-    0x00,   // iConfiguration: Index of string descriptor describing the configuration
-    CONFIG_DESC_ATTRIBUTES, // bmAttributes
-    CONFIG_DESC_MAXPOWER, // bMaxPower
-
+#if MICROPY_HW_USB_MSC
+// USB MSC partial configuration descriptor
+static const uint8_t msc_class_desc_data[MSC_CLASS_DESC_SIZE] = {
     //==========================================================================
     // MSC only has 1 interface so doesn't need an IAD
 
@@ -220,12 +194,16 @@ static const uint8_t cdc_msc_template_config_desc[CDC_MSC_TEMPLATE_CONFIG_DESC_S
     LOBYTE(MSC_FS_MAX_PACKET),      // wMaxPacketSize
     HIBYTE(MSC_FS_MAX_PACKET),
     0x00,                           // bInterval: ignore for Bulk transfer
+};
+#endif
 
+// USB CDC partial configuration descriptor
+static const uint8_t cdc_class_desc_data[CDC_CLASS_DESC_SIZE] = {
     //==========================================================================
     // Interface Association for CDC VCP
     0x08,   // bLength: 8 bytes
     USB_DESC_TYPE_ASSOCIATION, // bDescriptorType: IAD
-    CDC_IFACE_NUM_WITH_MSC, // bFirstInterface: first interface for this association
+    0x00,   // bFirstInterface: first interface for this association -- to be filled in
     0x02,   // bInterfaceCount: nummber of interfaces for this association
     0x02,   // bFunctionClass: Communication Interface Class
     0x02,   // bFunctionSubClass: Abstract Control Model
@@ -236,7 +214,7 @@ static const uint8_t cdc_msc_template_config_desc[CDC_MSC_TEMPLATE_CONFIG_DESC_S
     // Interface Descriptor
     0x09,   // bLength: Interface Descriptor size
     USB_DESC_TYPE_INTERFACE, // bDescriptorType: Interface
-    CDC_IFACE_NUM_WITH_MSC, // bInterfaceNumber: Number of Interface
+    0x00,   // bInterfaceNumber: Number of Interface -- to be filled in
     0x00,   // bAlternateSetting: Alternate setting
     0x01,   // bNumEndpoints: One endpoints used
     0x02,   // bInterfaceClass: Communication Interface Class
@@ -256,7 +234,7 @@ static const uint8_t cdc_msc_template_config_desc[CDC_MSC_TEMPLATE_CONFIG_DESC_S
     0x24,   // bDescriptorType: CS_INTERFACE
     0x01,   // bDescriptorSubtype: Call Management Func Desc
     0x00,   // bmCapabilities: D0+D1
-    CDC_IFACE_NUM_WITH_MSC + 1,   // bDataInterface: 1
+    0x00,   // bDataInterface -- to be filled in
 
     // ACM Functional Descriptor
     0x04,   // bFunctionLength
@@ -268,13 +246,13 @@ static const uint8_t cdc_msc_template_config_desc[CDC_MSC_TEMPLATE_CONFIG_DESC_S
     0x05,   // bFunctionLength
     0x24,   // bDescriptorType: CS_INTERFACE
     0x06,   // bDescriptorSubtype: Union func desc
-    CDC_IFACE_NUM_WITH_MSC + 0,   // bMasterInterface: Communication class interface
-    CDC_IFACE_NUM_WITH_MSC + 1,   // bSlaveInterface0: Data Class Interface
+    0x00,   // bMasterInterface: Communication class interface -- to be filled in
+    0x00,   // bSlaveInterface0: Data Class Interface -- to be filled in
 
-    // Endpoint 2 Descriptor
+    // Endpoint CMD Descriptor
     0x07,                           // bLength: Endpoint Descriptor size
     USB_DESC_TYPE_ENDPOINT,         // bDescriptorType: Endpoint
-    CDC_CMD_EP,                     // bEndpointAddress
+    CDC_CMD_EP(0),                  // bEndpointAddress
     0x03,                           // bmAttributes: Interrupt
     LOBYTE(CDC_CMD_PACKET_SIZE),    // wMaxPacketSize:
     HIBYTE(CDC_CMD_PACKET_SIZE),
@@ -284,7 +262,7 @@ static const uint8_t cdc_msc_template_config_desc[CDC_MSC_TEMPLATE_CONFIG_DESC_S
     // Data class interface descriptor
     0x09,   // bLength: Endpoint Descriptor size
     USB_DESC_TYPE_INTERFACE, // bDescriptorType: interface
-    CDC_IFACE_NUM_WITH_MSC + 1,   // bInterfaceNumber: Number of Interface
+    0x00,   // bInterfaceNumber: Number of Interface -- to be filled in
     0x00,   // bAlternateSetting: Alternate setting
     0x02,   // bNumEndpoints: Two endpoints used
     0x0A,   // bInterfaceClass: CDC
@@ -295,7 +273,7 @@ static const uint8_t cdc_msc_template_config_desc[CDC_MSC_TEMPLATE_CONFIG_DESC_S
     // Endpoint OUT Descriptor
     0x07,                               // bLength: Endpoint Descriptor size
     USB_DESC_TYPE_ENDPOINT,             // bDescriptorType: Endpoint
-    CDC_OUT_EP,                         // bEndpointAddress
+    CDC_OUT_EP(0),                      // bEndpointAddress
     0x02,                               // bmAttributes: Bulk
     LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),// wMaxPacketSize:
     HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
@@ -304,27 +282,16 @@ static const uint8_t cdc_msc_template_config_desc[CDC_MSC_TEMPLATE_CONFIG_DESC_S
     // Endpoint IN Descriptor
     0x07,                               // bLength: Endpoint Descriptor size
     USB_DESC_TYPE_ENDPOINT,             // bDescriptorType: Endpoint
-    CDC_IN_EP,                          // bEndpointAddress
+    CDC_IN_EP(0),                       // bEndpointAddress
     0x02,                               // bmAttributes: Bulk
     LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),// wMaxPacketSize:
     HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
     0x00,                               // bInterval: ignore for Bulk transfer
 };
 
-// USB CDC HID device Configuration Descriptor
-static const uint8_t cdc_hid_template_config_desc[CDC_HID_TEMPLATE_CONFIG_DESC_SIZE] = {
-    //--------------------------------------------------------------------------
-    // Configuration Descriptor
-    0x09,   // bLength: Configuration Descriptor size
-    USB_DESC_TYPE_CONFIGURATION, // bDescriptorType: Configuration
-    LOBYTE(CDC_HID_TEMPLATE_CONFIG_DESC_SIZE), // wTotalLength: no of returned bytes
-    HIBYTE(CDC_HID_TEMPLATE_CONFIG_DESC_SIZE),
-    0x03,   // bNumInterfaces: 3 interfaces
-    0x01,   // bConfigurationValue: Configuration value
-    0x00,   // iConfiguration: Index of string descriptor describing the configuration
-    CONFIG_DESC_ATTRIBUTES, // bmAttributes
-    CONFIG_DESC_MAXPOWER, // bMaxPower
-
+#if MICROPY_HW_USB_HID
+// USB HID partial configuration descriptor
+static const uint8_t hid_class_desc_data[HID_CLASS_DESC_SIZE] = {
     //==========================================================================
     // HID only has 1 interface so doesn't need an IAD
 
@@ -368,187 +335,6 @@ static const uint8_t cdc_hid_template_config_desc[CDC_HID_TEMPLATE_CONFIG_DESC_S
     LOBYTE(USBD_HID_MOUSE_MAX_PACKET), // wMaxPacketSize
     HIBYTE(USBD_HID_MOUSE_MAX_PACKET),
     0x08,                           // bInterval: Polling interval
-
-    //==========================================================================
-    // Interface Association for CDC VCP
-    0x08,   // bLength: 8 bytes
-    USB_DESC_TYPE_ASSOCIATION, // bDescriptorType: IAD
-    CDC_IFACE_NUM_WITH_HID, // bFirstInterface: first interface for this association
-    0x02,   // bInterfaceCount: nummber of interfaces for this association
-    0x02,   // bFunctionClass: Communication Interface Class
-    0x02,   // bFunctionSubClass: Abstract Control Model
-    0x01,   // bFunctionProtocol: Common AT commands
-    0x00,   // iFunction: index of string for this function
-
-    //--------------------------------------------------------------------------
-    // Interface Descriptor
-    0x09,   // bLength: Interface Descriptor size
-    USB_DESC_TYPE_INTERFACE, // bDescriptorType: Interface
-    CDC_IFACE_NUM_WITH_HID, // bInterfaceNumber: Number of Interface
-    0x00,   // bAlternateSetting: Alternate setting
-    0x01,   // bNumEndpoints: One endpoints used
-    0x02,   // bInterfaceClass: Communication Interface Class
-    0x02,   // bInterfaceSubClass: Abstract Control Model
-    0x01,   // bInterfaceProtocol: Common AT commands
-    0x00,   // iInterface:
-
-    // Header Functional Descriptor
-    0x05,   // bLength: Endpoint Descriptor size
-    0x24,   // bDescriptorType: CS_INTERFACE
-    0x00,   // bDescriptorSubtype: Header Func Desc
-    0x10,   // bcdCDC: spec release number
-    0x01,   // ?
-
-    // Call Management Functional Descriptor
-    0x05,   // bFunctionLength
-    0x24,   // bDescriptorType: CS_INTERFACE
-    0x01,   // bDescriptorSubtype: Call Management Func Desc
-    0x00,   // bmCapabilities: D0+D1
-    CDC_IFACE_NUM_WITH_HID + 1,   // bDataInterface: 1
-
-    // ACM Functional Descriptor
-    0x04,   // bFunctionLength
-    0x24,   // bDescriptorType: CS_INTERFACE
-    0x02,   // bDescriptorSubtype: Abstract Control Management desc
-    0x02,   // bmCapabilities
-
-    // Union Functional Descriptor
-    0x05,   // bFunctionLength
-    0x24,   // bDescriptorType: CS_INTERFACE
-    0x06,   // bDescriptorSubtype: Union func desc
-    CDC_IFACE_NUM_WITH_HID + 0,   // bMasterInterface: Communication class interface
-    CDC_IFACE_NUM_WITH_HID + 1,   // bSlaveInterface0: Data Class Interface
-
-    // Endpoint 2 Descriptor
-    0x07,                           // bLength: Endpoint Descriptor size
-    USB_DESC_TYPE_ENDPOINT,         // bDescriptorType: Endpoint
-    CDC_CMD_EP,                     // bEndpointAddress
-    0x03,                           // bmAttributes: Interrupt
-    LOBYTE(CDC_CMD_PACKET_SIZE),    // wMaxPacketSize:
-    HIBYTE(CDC_CMD_PACKET_SIZE),
-    0x20,                           // bInterval: polling interval in frames of 1ms
-
-    //--------------------------------------------------------------------------
-    // Data class interface descriptor
-    0x09,   // bLength: Endpoint Descriptor size
-    USB_DESC_TYPE_INTERFACE, // bDescriptorType: interface
-    CDC_IFACE_NUM_WITH_HID + 1,   // bInterfaceNumber: Number of Interface
-    0x00,   // bAlternateSetting: Alternate setting
-    0x02,   // bNumEndpoints: Two endpoints used
-    0x0A,   // bInterfaceClass: CDC
-    0x00,   // bInterfaceSubClass: ?
-    0x00,   // bInterfaceProtocol: ?
-    0x00,   // iInterface:
-
-    // Endpoint OUT Descriptor
-    0x07,                               // bLength: Endpoint Descriptor size
-    USB_DESC_TYPE_ENDPOINT,             // bDescriptorType: Endpoint
-    CDC_OUT_EP,                         // bEndpointAddress
-    0x02,                               // bmAttributes: Bulk
-    LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),// wMaxPacketSize:
-    HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
-    0x00,                               // bInterval: ignore for Bulk transfer
-
-    // Endpoint IN Descriptor
-    0x07,                               // bLength: Endpoint Descriptor size
-    USB_DESC_TYPE_ENDPOINT,             // bDescriptorType: Endpoint
-    CDC_IN_EP,                          // bEndpointAddress
-    0x02,                               // bmAttributes: Bulk
-    LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),// wMaxPacketSize:
-    HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
-    0x00,                               // bInterval: ignore for Bulk transfer
-};
-
-static const uint8_t cdc_template_config_desc[CDC_TEMPLATE_CONFIG_DESC_SIZE] = {
-    //--------------------------------------------------------------------------
-    // Configuration Descriptor
-    0x09,   // bLength: Configuration Descriptor size
-    USB_DESC_TYPE_CONFIGURATION, // bDescriptorType: Configuration
-    LOBYTE(CDC_TEMPLATE_CONFIG_DESC_SIZE), // wTotalLength:no of returned bytes
-    HIBYTE(CDC_TEMPLATE_CONFIG_DESC_SIZE),
-    0x02,   // bNumInterfaces: 2 interface
-    0x01,   // bConfigurationValue: Configuration value
-    0x00,   // iConfiguration: Index of string descriptor describing the configuration
-    CONFIG_DESC_ATTRIBUTES, // bmAttributes
-    CONFIG_DESC_MAXPOWER, // bMaxPower
-
-    //--------------------------------------------------------------------------
-    // Interface Descriptor
-    0x09,   // bLength: Interface Descriptor size
-    USB_DESC_TYPE_INTERFACE,  // bDescriptorType: Interface
-    CDC_IFACE_NUM_ALONE,   // bInterfaceNumber: Number of Interface
-    0x00,   // bAlternateSetting: Alternate setting
-    0x01,   // bNumEndpoints: One endpoints used
-    0x02,   // bInterfaceClass: Communication Interface Class
-    0x02,   // bInterfaceSubClass: Abstract Control Model
-    0x01,   // bInterfaceProtocol: Common AT commands
-    0x00,   // iInterface:
-
-    // Header Functional Descriptor
-    0x05,   // bLength: Endpoint Descriptor size
-    0x24,   // bDescriptorType: CS_INTERFACE
-    0x00,   // bDescriptorSubtype: Header Func Desc
-    0x10,   // bcdCDC: spec release number
-    0x01,   // ?
-
-    // Call Management Functional Descriptor
-    0x05,   // bFunctionLength
-    0x24,   // bDescriptorType: CS_INTERFACE
-    0x01,   // bDescriptorSubtype: Call Management Func Desc
-    0x00,   // bmCapabilities: D0+D1
-    CDC_IFACE_NUM_ALONE + 1,   // bDataInterface: 1
-
-    // ACM Functional Descriptor
-    0x04,   // bFunctionLength
-    0x24,   // bDescriptorType: CS_INTERFACE
-    0x02,   // bDescriptorSubtype: Abstract Control Management desc
-    0x02,   // bmCapabilities
-
-    // Union Functional Descriptor
-    0x05,   // bFunctionLength
-    0x24,   // bDescriptorType: CS_INTERFACE
-    0x06,   // bDescriptorSubtype: Union func desc
-    CDC_IFACE_NUM_ALONE + 0,   // bMasterInterface: Communication class interface
-    CDC_IFACE_NUM_ALONE + 1,   // bSlaveInterface0: Data Class Interface
-
-    // Endpoint 2 Descriptor
-    0x07,                           // bLength: Endpoint Descriptor size
-    USB_DESC_TYPE_ENDPOINT,         // bDescriptorType: Endpoint
-    CDC_CMD_EP,                     // bEndpointAddress
-    0x03,                           // bmAttributes: Interrupt
-    LOBYTE(CDC_CMD_PACKET_SIZE),    // wMaxPacketSize:
-    HIBYTE(CDC_CMD_PACKET_SIZE),
-    0x20,                           // bInterval: polling interval in frames of 1ms
-
-    //--------------------------------------------------------------------------
-    // Data class interface descriptor
-    0x09,   // bLength: Endpoint Descriptor size
-    USB_DESC_TYPE_INTERFACE,  // bDescriptorType:
-    CDC_IFACE_NUM_ALONE + 1,   // bInterfaceNumber: Number of Interface
-    0x00,   // bAlternateSetting: Alternate setting
-    0x02,   // bNumEndpoints: Two endpoints used
-    0x0a,   // bInterfaceClass: CDC
-    0x00,   // bInterfaceSubClass: ?
-    0x00,   // bInterfaceProtocol: ?
-    0x00,   // iInterface:
-
-    // Endpoint OUT Descriptor
-    0x07,                               // bLength: Endpoint Descriptor size
-    USB_DESC_TYPE_ENDPOINT,             // bDescriptorType: Endpoint
-    CDC_OUT_EP,                         // bEndpointAddress
-    0x02,                               // bmAttributes: Bulk
-    LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),// wMaxPacketSize:
-    HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
-    0x00,                               // bInterval: ignore for Bulk transfer
-
-    // Endpoint IN Descriptor
-    0x07,                               // bLength: Endpoint Descriptor size
-    USB_DESC_TYPE_ENDPOINT,             // bDescriptorType: Endpoint
-    CDC_IN_EP,                          // bEndpointAddress
-    0x02,                               // bmAttributes: Bulk
-    LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),// wMaxPacketSize:
-    HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
-    0x00                                // bInterval: ignore for Bulk transfer
 };
 
 __ALIGN_BEGIN const uint8_t USBD_HID_MOUSE_ReportDesc[USBD_HID_MOUSE_REPORT_DESC_SIZE] __ALIGN_END = {
@@ -627,68 +413,222 @@ __ALIGN_BEGIN const uint8_t USBD_HID_KEYBOARD_ReportDesc[USBD_HID_KEYBOARD_REPOR
     0x81, 0x00,         // Input (Data, Array), ;Key arrays (6 bytes)
     0xC0            // End Collection
 };
+#endif
+
+static void make_head_desc(uint8_t *dest, uint16_t len, uint8_t num_itf) {
+    memcpy(dest, head_desc_data, sizeof(head_desc_data));
+    dest[2] = LOBYTE(len); // wTotalLength
+    dest[3] = HIBYTE(len);
+    dest[4] = num_itf; // bNumInterfaces
+}
+
+#if MICROPY_HW_USB_MSC
+static size_t make_msc_desc(uint8_t *dest) {
+    memcpy(dest, msc_class_desc_data, sizeof(msc_class_desc_data));
+    return sizeof(msc_class_desc_data);
+}
+#endif
+
+static size_t make_cdc_desc(uint8_t *dest, int need_iad, uint8_t iface_num) {
+    if (need_iad) {
+        memcpy(dest, cdc_class_desc_data, sizeof(cdc_class_desc_data));
+        dest[2] = iface_num; // bFirstInterface
+        dest += 8;
+    } else {
+        memcpy(dest, cdc_class_desc_data + 8, sizeof(cdc_class_desc_data) - 8);
+    }
+    dest[2] = iface_num;        // bInterfaceNumber, main class
+    dest[18] = iface_num + 1;   // bDataInterface
+    dest[26] = iface_num + 0;   // bMasterInterface
+    dest[27] = iface_num + 1;   // bSlaveInterface
+    dest[37] = iface_num + 1;   // bInterfaceNumber, data class
+    return need_iad ? 8 + 58 : 58;
+}
+
+#if MICROPY_HW_USB_CDC_NUM >= 2
+static size_t make_cdc_desc_ep(uint8_t *dest, int need_iad, uint8_t iface_num, uint8_t cmd_ep, uint8_t out_ep, uint8_t in_ep) {
+    size_t n = make_cdc_desc(dest, need_iad, iface_num);
+    if (need_iad) {
+        dest += 8;
+    }
+    dest[30] = cmd_ep;          // bEndpointAddress, main class CMD
+    dest[46] = out_ep;          // bEndpointAddress, data class OUT
+    dest[53] = in_ep;           // bEndpointAddress, data class IN
+    return n;
+}
+#endif
+
+#if MICROPY_HW_USB_HID
+static size_t make_hid_desc(uint8_t *dest, USBD_HID_ModeInfoTypeDef *hid_info, uint8_t iface_num) {
+    memcpy(dest, hid_class_desc_data, sizeof(hid_class_desc_data));
+    dest[2] = iface_num;
+    dest[HID_DESC_OFFSET_SUBCLASS] = hid_info->subclass;
+    dest[HID_DESC_OFFSET_PROTOCOL] = hid_info->protocol;
+    dest[HID_DESC_OFFSET_REPORT_DESC_LEN] = hid_info->report_desc_len;
+    dest[HID_DESC_OFFSET_MAX_PACKET_LO] = hid_info->max_packet_len;
+    dest[HID_DESC_OFFSET_MAX_PACKET_HI] = 0;
+    dest[HID_DESC_OFFSET_POLLING_INTERVAL] = hid_info->polling_interval;
+    dest[HID_DESC_OFFSET_MAX_PACKET_OUT_LO] = hid_info->max_packet_len;
+    dest[HID_DESC_OFFSET_MAX_PACKET_OUT_HI] = 0;
+    dest[HID_DESC_OFFSET_POLLING_INTERVAL_OUT] = hid_info->polling_interval;
+    return sizeof(hid_class_desc_data);
+}
+
+#if MICROPY_HW_USB_MSC
+static size_t make_hid_desc_ep(uint8_t *dest, USBD_HID_ModeInfoTypeDef *hid_info, uint8_t iface_num, uint8_t in_ep, uint8_t out_ep) {
+    size_t n = make_hid_desc(dest, hid_info, iface_num);
+    dest[HID_DESC_OFFSET_IN_EP] = in_ep;
+    dest[HID_DESC_OFFSET_OUT_EP] = out_ep;
+    return n;
+}
+#endif
+#endif
 
 // return the saved usb mode
 uint8_t USBD_GetMode(usbd_cdc_msc_hid_state_t *usbd) {
     return usbd->usbd_mode;
 }
 
-int USBD_SelectMode(usbd_cdc_msc_hid_state_t *usbd, uint32_t mode, USBD_HID_ModeInfoTypeDef *hid_info) {
+int USBD_SelectMode(usbd_cdc_msc_hid_state_t *usbd, uint32_t mode, USBD_HID_ModeInfoTypeDef *hid_info, uint8_t max_endpoint) {
     // save mode
     usbd->usbd_mode = mode;
 
     // construct config desc
-    switch (usbd->usbd_mode) {
+    size_t n = HEAD_DESC_SIZE;
+    uint8_t *d = usbd->usbd_config_desc;
+    uint8_t num_itf = 0;
+    switch (usbd->usbd_mode & USBD_MODE_IFACE_MASK) {
+        #if MICROPY_HW_USB_MSC
         case USBD_MODE_MSC:
-            usbd->usbd_config_desc_size = sizeof(msc_template_config_desc);
-            memcpy(usbd->usbd_config_desc, msc_template_config_desc, sizeof(msc_template_config_desc));
+            n += make_msc_desc(d + n);
+            num_itf = 1;
             break;
 
         case USBD_MODE_CDC_MSC:
-            usbd->usbd_config_desc_size = sizeof(cdc_msc_template_config_desc);
-            memcpy(usbd->usbd_config_desc, cdc_msc_template_config_desc, sizeof(cdc_msc_template_config_desc));
-            usbd->cdc->iface_num = CDC_IFACE_NUM_WITH_MSC;
+            n += make_msc_desc(d + n);
+            n += make_cdc_desc(d + n, 1, CDC_IFACE_NUM_WITH_MSC);
+            usbd->cdc[0]->iface_num = CDC_IFACE_NUM_WITH_MSC;
+            num_itf = 3;
+            break;
+
+        #if MICROPY_HW_USB_HID
+        case USBD_MODE_CDC_MSC_HID:
+            n += make_msc_desc(d + n);
+            n += make_cdc_desc(d + n, 1, CDC_IFACE_NUM_WITH_MSC);
+            usbd->hid->desc = d + n;
+            n += make_hid_desc_ep(d + n, hid_info, HID_IFACE_NUM_WITH_CDC_MSC, HID_IN_EP_WITH_CDC_MSC, HID_OUT_EP_WITH_CDC_MSC);
+            usbd->cdc[0]->iface_num = CDC_IFACE_NUM_WITH_MSC;
+            usbd->hid->in_ep = HID_IN_EP_WITH_CDC_MSC;
+            usbd->hid->out_ep = HID_OUT_EP_WITH_CDC_MSC;
+            usbd->hid->iface_num = HID_IFACE_NUM_WITH_CDC_MSC;
+            usbd->hid->report_desc = hid_info->report_desc;
+            num_itf = 4;
+            break;
+        #endif
+        #endif
+
+        #if MICROPY_HW_USB_CDC_NUM >= 2
+        case USBD_MODE_CDC2: {
+            n += make_cdc_desc(d + n, 1, CDC_IFACE_NUM_ALONE);
+            n += make_cdc_desc_ep(d + n, 1, CDC2_IFACE_NUM_WITH_CDC, CDC_CMD_EP(1), CDC_OUT_EP(1), CDC_IN_EP(1));
+            usbd->cdc[0]->iface_num = CDC_IFACE_NUM_ALONE;
+            usbd->cdc[1]->iface_num = CDC2_IFACE_NUM_WITH_CDC;
+            num_itf = 4;
             break;
+        }
 
-        #if MICROPY_HW_USB_ENABLE_CDC2
+        #if MICROPY_HW_USB_MSC
         case USBD_MODE_CDC2_MSC: {
-            usbd->usbd_config_desc_size = CDC2_MSC_TEMPLATE_CONFIG_DESC_SIZE;
-            uint8_t *d = usbd->usbd_config_desc;
-            memcpy(d, cdc_msc_template_config_desc, sizeof(cdc_msc_template_config_desc));
-            d[2] = LOBYTE(CDC2_MSC_TEMPLATE_CONFIG_DESC_SIZE); // wTotalLength
-            d[3] = HIBYTE(CDC2_MSC_TEMPLATE_CONFIG_DESC_SIZE);
-            d[4] = 5; // bNumInterfaces
-            memcpy(d + 9 + 23 + (8 + 58), d + 9 + 23, 8 + 58);
-            d += 9 + 23 + (8 + 58);
-            d[2] = CDC2_IFACE_NUM_WITH_MSC; // bFirstInterface
-            d[10] = CDC2_IFACE_NUM_WITH_MSC; // bInterfaceNumber
-            d[26] = CDC2_IFACE_NUM_WITH_MSC + 1; // bDataInterface
-            d[34] = CDC2_IFACE_NUM_WITH_MSC + 0; // bMasterInterface
-            d[35] = CDC2_IFACE_NUM_WITH_MSC + 1; // bSlaveInterface
-            d[38] = CDC2_CMD_EP; // bEndpointAddress
-            d[45] = CDC2_IFACE_NUM_WITH_MSC + 1; // bInterfaceNumber
-            d[54] = CDC2_OUT_EP; // bEndpointAddress
-            d[61] = CDC2_IN_EP; // bEndpointAddress
-            usbd->cdc->iface_num = CDC_IFACE_NUM_WITH_MSC;
-            usbd->cdc2->iface_num = CDC2_IFACE_NUM_WITH_MSC;
+            n += make_msc_desc(d + n);
+            n += make_cdc_desc(d + n, 1, CDC_IFACE_NUM_WITH_MSC);
+            n += make_cdc_desc_ep(d + n, 1, CDC2_IFACE_NUM_WITH_MSC, CDC_CMD_EP(1), CDC_OUT_EP(1), CDC_IN_EP(1));
+            usbd->cdc[0]->iface_num = CDC_IFACE_NUM_WITH_MSC;
+            usbd->cdc[1]->iface_num = CDC2_IFACE_NUM_WITH_MSC;
+            num_itf = 5;
+            break;
+        }
+
+        case USBD_MODE_CDC2_MSC_HID: {
+            n += make_msc_desc(d + n);
+            n += make_cdc_desc(d + n, 1, CDC_IFACE_NUM_WITH_MSC);
+            n += make_cdc_desc_ep(d + n, 1, CDC2_IFACE_NUM_WITH_MSC, CDC_CMD_EP(1), CDC_OUT_EP(1), CDC_IN_EP(1));
+            usbd->hid->desc = d + n;
+            n += make_hid_desc_ep(d + n, hid_info, HID_IFACE_NUM_WITH_CDC2_MSC, HID_IN_EP_WITH_CDC2_MSC, HID_OUT_EP_WITH_CDC2_MSC);
+            usbd->cdc[0]->iface_num = CDC_IFACE_NUM_WITH_MSC;
+            usbd->cdc[1]->iface_num = CDC2_IFACE_NUM_WITH_MSC;
+            usbd->hid->in_ep = HID_IN_EP_WITH_CDC2_MSC;
+            usbd->hid->out_ep = HID_OUT_EP_WITH_CDC2_MSC;
+            usbd->hid->iface_num = HID_IFACE_NUM_WITH_CDC2_MSC;
+            usbd->hid->report_desc = hid_info->report_desc;
+            num_itf = 6;
             break;
         }
         #endif
+        #endif
 
+        #if MICROPY_HW_USB_CDC_NUM >= 3
+        case USBD_MODE_CDC3: {
+            n += make_cdc_desc(d + n, 1, CDC_IFACE_NUM_ALONE);
+            n += make_cdc_desc_ep(d + n, 1, CDC2_IFACE_NUM_WITH_CDC, CDC_CMD_EP(1), CDC_OUT_EP(1), CDC_IN_EP(1));
+            n += make_cdc_desc_ep(d + n, 1, CDC3_IFACE_NUM_WITH_CDC, CDC_CMD_EP(2), CDC_OUT_EP(2), CDC_IN_EP(2));
+            usbd->cdc[0]->iface_num = CDC_IFACE_NUM_ALONE;
+            usbd->cdc[1]->iface_num = CDC2_IFACE_NUM_WITH_CDC;
+            usbd->cdc[2]->iface_num = CDC3_IFACE_NUM_WITH_CDC;
+            num_itf = 6;
+            break;
+        }
+
+        #if MICROPY_HW_USB_MSC
+        case USBD_MODE_CDC3_MSC: {
+            n += make_msc_desc(d + n);
+            n += make_cdc_desc(d + n, 1, CDC_IFACE_NUM_WITH_MSC);
+            n += make_cdc_desc_ep(d + n, 1, CDC2_IFACE_NUM_WITH_MSC, CDC_CMD_EP(1), CDC_OUT_EP(1), CDC_IN_EP(1));
+            n += make_cdc_desc_ep(d + n, 1, CDC3_IFACE_NUM_WITH_MSC, CDC_CMD_EP(2), CDC_OUT_EP(2), CDC_IN_EP(2));
+            usbd->cdc[0]->iface_num = CDC_IFACE_NUM_WITH_MSC;
+            usbd->cdc[1]->iface_num = CDC2_IFACE_NUM_WITH_MSC;
+            usbd->cdc[2]->iface_num = CDC3_IFACE_NUM_WITH_MSC;
+            num_itf = 7;
+            break;
+        }
+
+        case USBD_MODE_CDC3_MSC_HID: {
+            n += make_msc_desc(d + n);
+            n += make_cdc_desc(d + n, 1, CDC_IFACE_NUM_WITH_MSC);
+            n += make_cdc_desc_ep(d + n, 1, CDC2_IFACE_NUM_WITH_MSC, CDC_CMD_EP(1), CDC_OUT_EP(1), CDC_IN_EP(1));
+            n += make_cdc_desc_ep(d + n, 1, CDC3_IFACE_NUM_WITH_MSC, CDC_CMD_EP(2), CDC_OUT_EP(2), CDC_IN_EP(2));
+            usbd->hid->desc = d + n;
+            n += make_hid_desc_ep(d + n, hid_info, HID_IFACE_NUM_WITH_CDC3_MSC, HID_IN_EP_WITH_CDC3_MSC, HID_OUT_EP_WITH_CDC3_MSC);
+            usbd->cdc[0]->iface_num = CDC_IFACE_NUM_WITH_MSC;
+            usbd->cdc[1]->iface_num = CDC2_IFACE_NUM_WITH_MSC;
+            usbd->cdc[2]->iface_num = CDC3_IFACE_NUM_WITH_MSC;
+            usbd->hid->in_ep = HID_IN_EP_WITH_CDC3_MSC;
+            usbd->hid->out_ep = HID_OUT_EP_WITH_CDC3_MSC;
+            usbd->hid->iface_num = HID_IFACE_NUM_WITH_CDC3_MSC;
+            usbd->hid->report_desc = hid_info->report_desc;
+            num_itf = 8;
+            break;
+        }
+        #endif
+        #endif
+
+        #if MICROPY_HW_USB_HID
         case USBD_MODE_CDC_HID:
-            usbd->usbd_config_desc_size = sizeof(cdc_hid_template_config_desc);
-            memcpy(usbd->usbd_config_desc, cdc_hid_template_config_desc, sizeof(cdc_hid_template_config_desc));
-            usbd->cdc->iface_num = CDC_IFACE_NUM_WITH_HID;
+            usbd->hid->desc = d + n;
+            n += make_hid_desc(d + n, hid_info, HID_IFACE_NUM_WITH_CDC);
+            n += make_cdc_desc(d + n, 1, CDC_IFACE_NUM_WITH_HID);
+            usbd->cdc[0]->iface_num = CDC_IFACE_NUM_WITH_HID;
             usbd->hid->in_ep = HID_IN_EP_WITH_CDC;
             usbd->hid->out_ep = HID_OUT_EP_WITH_CDC;
             usbd->hid->iface_num = HID_IFACE_NUM_WITH_CDC;
-            usbd->hid->desc = usbd->usbd_config_desc + CDC_HID_TEMPLATE_HID_DESC_OFFSET;
+            usbd->hid->report_desc = hid_info->report_desc;
+            num_itf = 3;
             break;
+        #endif
 
         case USBD_MODE_CDC:
-            usbd->usbd_config_desc_size = sizeof(cdc_template_config_desc);
-            memcpy(usbd->usbd_config_desc, cdc_template_config_desc, sizeof(cdc_template_config_desc));
-            usbd->cdc->iface_num = CDC_IFACE_NUM_ALONE;
+            n += make_cdc_desc(d + n, 0, CDC_IFACE_NUM_ALONE);
+            usbd->cdc[0]->iface_num = CDC_IFACE_NUM_ALONE;
+            num_itf = 2;
             break;
 
             /*
@@ -705,31 +645,25 @@ int USBD_SelectMode(usbd_cdc_msc_hid_state_t *usbd, uint32_t mode, USBD_HID_Mode
             return -1;
     }
 
-    if (usbd->usbd_mode & USBD_MODE_CDC) {
-        usbd->cdc->in_ep = CDC_IN_EP;
-        usbd->cdc->out_ep = CDC_OUT_EP;
-    }
+    make_head_desc(d, n, num_itf);
+    usbd->usbd_config_desc_size = n;
 
-    #if MICROPY_HW_USB_ENABLE_CDC2
-    if (usbd->usbd_mode & USBD_MODE_CDC2) {
-        usbd->cdc2->in_ep = CDC2_IN_EP;
-        usbd->cdc2->out_ep = CDC2_OUT_EP;
+    for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
+        if (usbd->usbd_mode & USBD_MODE_IFACE_CDC(i)) {
+            usbd->cdc[i]->in_ep = CDC_IN_EP(i);
+            usbd->cdc[i]->out_ep = CDC_OUT_EP(i);
+        }
     }
-    #endif
 
-    // configure the HID descriptor, if needed
-    if (usbd->usbd_mode & USBD_MODE_HID) {
-        uint8_t *hid_desc = usbd->hid->desc;
-        hid_desc[HID_DESC_OFFSET_SUBCLASS] = hid_info->subclass;
-        hid_desc[HID_DESC_OFFSET_PROTOCOL] = hid_info->protocol;
-        hid_desc[HID_DESC_OFFSET_REPORT_DESC_LEN] = hid_info->report_desc_len;
-        hid_desc[HID_DESC_OFFSET_MAX_PACKET_LO] = hid_info->max_packet_len;
-        hid_desc[HID_DESC_OFFSET_MAX_PACKET_HI] = 0;
-        hid_desc[HID_DESC_OFFSET_POLLING_INTERVAL] = hid_info->polling_interval;
-        hid_desc[HID_DESC_OFFSET_MAX_PACKET_OUT_LO] = hid_info->max_packet_len;
-        hid_desc[HID_DESC_OFFSET_MAX_PACKET_OUT_HI] = 0;
-        hid_desc[HID_DESC_OFFSET_POLLING_INTERVAL_OUT] = hid_info->polling_interval;
-        usbd->hid->report_desc = hid_info->report_desc;
+    // Verify that the endpoints that are used fit within the maximum number
+    d = usbd->usbd_config_desc;
+    const uint8_t *d_top = d + n;
+    while (d < d_top) {
+        if (d[0] == 7 && d[1] == USB_DESC_TYPE_ENDPOINT && (d[2] & 0x7f) > max_endpoint) {
+            // Endpoint out of range of hardware
+            return -1;
+        }
+        d += d[0];
     }
 
     return 0;
@@ -765,19 +699,15 @@ static uint8_t USBD_CDC_MSC_HID_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx) {
 
     usbd_cdc_msc_hid_state_t *usbd = pdev->pClassData;
 
-    if (usbd->usbd_mode & USBD_MODE_CDC) {
-        // CDC VCP component
-        usbd_cdc_state_init(pdev, usbd, usbd->cdc, CDC_CMD_EP);
-    }
-
-    #if MICROPY_HW_USB_ENABLE_CDC2
-    if (usbd->usbd_mode & USBD_MODE_CDC2) {
-        // CDC VCP #2 component
-        usbd_cdc_state_init(pdev, usbd, usbd->cdc2, CDC2_CMD_EP);
+    // CDC VCP component(s)
+    for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
+        if (usbd->usbd_mode & USBD_MODE_IFACE_CDC(i)) {
+            usbd_cdc_state_init(pdev, usbd, usbd->cdc[i], CDC_CMD_EP(i));
+        }
     }
-    #endif
 
-    if (usbd->usbd_mode & USBD_MODE_MSC) {
+    #if MICROPY_HW_USB_MSC
+    if (usbd->usbd_mode & USBD_MODE_IFACE_MSC) {
         // MSC component
 
         int mp = usbd_msc_max_packet(pdev);
@@ -797,8 +727,10 @@ static uint8_t USBD_CDC_MSC_HID_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx) {
         // Init the BOT layer
         MSC_BOT_Init(pdev);
     }
+    #endif
 
-    if (usbd->usbd_mode & USBD_MODE_HID) {
+    #if MICROPY_HW_USB_HID
+    if (usbd->usbd_mode & USBD_MODE_IFACE_HID) {
         // HID component
 
         // get max packet lengths from descriptor
@@ -824,6 +756,7 @@ static uint8_t USBD_CDC_MSC_HID_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx) {
 
         usbd->hid->state = HID_IDLE;
     }
+    #endif
 
     return 0;
 }
@@ -831,31 +764,21 @@ static uint8_t USBD_CDC_MSC_HID_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx) {
 static uint8_t USBD_CDC_MSC_HID_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx) {
     usbd_cdc_msc_hid_state_t *usbd = pdev->pClassData;
 
-    if ((usbd->usbd_mode & USBD_MODE_CDC) && usbd->cdc) {
-        // CDC VCP component
-
-        usbd_cdc_deinit(usbd->cdc);
-
-        // close endpoints
-        USBD_LL_CloseEP(pdev, CDC_IN_EP);
-        USBD_LL_CloseEP(pdev, CDC_OUT_EP);
-        USBD_LL_CloseEP(pdev, CDC_CMD_EP);
-    }
-
-    #if MICROPY_HW_USB_ENABLE_CDC2
-    if ((usbd->usbd_mode & USBD_MODE_CDC2) && usbd->cdc2) {
-        // CDC VCP #2 component
+    for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
+        if ((usbd->usbd_mode & USBD_MODE_IFACE_CDC(i)) && usbd->cdc[i]) {
+            // CDC VCP component
 
-        usbd_cdc_deinit(usbd->cdc2);
+            usbd_cdc_deinit(usbd->cdc[i]);
 
-        // close endpoints
-        USBD_LL_CloseEP(pdev, CDC2_IN_EP);
-        USBD_LL_CloseEP(pdev, CDC2_OUT_EP);
-        USBD_LL_CloseEP(pdev, CDC2_CMD_EP);
+            // close endpoints
+            USBD_LL_CloseEP(pdev, CDC_IN_EP(i));
+            USBD_LL_CloseEP(pdev, CDC_OUT_EP(i));
+            USBD_LL_CloseEP(pdev, CDC_CMD_EP(i));
+        }
     }
-    #endif
 
-    if (usbd->usbd_mode & USBD_MODE_MSC) {
+    #if MICROPY_HW_USB_MSC
+    if (usbd->usbd_mode & USBD_MODE_IFACE_MSC) {
         // MSC component
 
         // close endpoints
@@ -865,14 +788,17 @@ static uint8_t USBD_CDC_MSC_HID_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
         // DeInit the BOT layer
         MSC_BOT_DeInit(pdev);
     }
+    #endif
 
-    if (usbd->usbd_mode & USBD_MODE_HID) {
+    #if MICROPY_HW_USB_HID
+    if (usbd->usbd_mode & USBD_MODE_IFACE_HID) {
         // HID component
 
         // close endpoints
         USBD_LL_CloseEP(pdev, usbd->hid->in_ep);
         USBD_LL_CloseEP(pdev, usbd->hid->out_ep);
     }
+    #endif
 
     return 0;
 }
@@ -904,35 +830,47 @@ static uint8_t USBD_CDC_MSC_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTyp
     switch (req->bmRequest & USB_REQ_RECIPIENT_MASK) {
         case USB_REQ_RECIPIENT_INTERFACE: {
             uint16_t iface = req->wIndex;
-            if ((mode & USBD_MODE_CDC) && iface == usbd->cdc->iface_num) {
-                recipient = USBD_MODE_CDC;
-                cdc = usbd->cdc;
-            #if MICROPY_HW_USB_ENABLE_CDC2
-            } else if ((mode & USBD_MODE_CDC2) && iface == usbd->cdc2->iface_num) {
-                recipient = USBD_MODE_CDC;
-                cdc = usbd->cdc2;
-            #endif
-            } else if ((mode & USBD_MODE_MSC) && iface == MSC_IFACE_NUM_WITH_CDC) {
+            #if MICROPY_HW_USB_MSC
+            if ((mode & USBD_MODE_IFACE_MSC) && iface == MSC_IFACE_NUM_WITH_CDC) {
                 recipient = USBD_MODE_MSC;
-            } else if ((mode & USBD_MODE_HID) && iface == usbd->hid->iface_num) {
+            } else
+            #endif
+            #if MICROPY_HW_USB_HID
+            if ((mode & USBD_MODE_IFACE_HID) && iface == usbd->hid->iface_num) {
                 recipient = USBD_MODE_HID;
+            } else
+            #endif
+            {
+                for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
+                    if ((mode & USBD_MODE_IFACE_CDC(i)) && iface == usbd->cdc[i]->iface_num) {
+                        recipient = USBD_MODE_CDC;
+                        cdc = usbd->cdc[i];
+                        break;
+                    }
+                }
             }
             break;
         }
         case USB_REQ_RECIPIENT_ENDPOINT: {
             uint8_t ep = req->wIndex & 0x7f;
-            if ((mode & USBD_MODE_CDC) && (ep == CDC_OUT_EP || ep == (CDC_CMD_EP & 0x7f))) {
-                recipient = USBD_MODE_CDC;
-                cdc = usbd->cdc;
-            #if MICROPY_HW_USB_ENABLE_CDC2
-            } else if ((mode & USBD_MODE_CDC2) && (ep == CDC2_OUT_EP || ep == (CDC2_CMD_EP & 0x7f))) {
-                recipient = USBD_MODE_CDC;
-                cdc = usbd->cdc2;
-            #endif
-            } else if ((mode & USBD_MODE_MSC) && ep == MSC_OUT_EP) {
+            #if MICROPY_HW_USB_MSC
+            if ((mode & USBD_MODE_IFACE_MSC) && ep == MSC_OUT_EP) {
                 recipient = USBD_MODE_MSC;
-            } else if ((mode & USBD_MODE_HID) && ep == usbd->hid->out_ep) {
+            } else
+            #endif
+            #if MICROPY_HW_USB_HID
+            if ((mode & USBD_MODE_IFACE_HID) && ep == usbd->hid->out_ep) {
                 recipient = USBD_MODE_HID;
+            } else
+            #endif
+            {
+                for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
+                    if ((mode & USBD_MODE_IFACE_CDC(i)) && (ep == CDC_OUT_EP(i) || ep == (CDC_CMD_EP(i) & 0x7f))) {
+                        recipient = USBD_MODE_CDC;
+                        cdc = usbd->cdc[i];
+                        break;
+                    }
+                }
             }
             break;
         }
@@ -965,7 +903,9 @@ static uint8_t USBD_CDC_MSC_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTyp
                     // Transfer the command to the interface layer
                     return usbd_cdc_control(cdc, req->bRequest, NULL, req->wValue);
                 }
-            } else if (recipient == USBD_MODE_MSC) {
+            }
+            #if MICROPY_HW_USB_MSC
+            if (recipient == USBD_MODE_MSC) {
                 switch (req->bRequest) {
                     case BOT_GET_MAX_LUN:
                         if ((req->wValue  == 0) && (req->wLength == 1) && ((req->bmRequest & 0x80) == 0x80)) {
@@ -990,7 +930,10 @@ static uint8_t USBD_CDC_MSC_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTyp
                         USBD_CtlError(pdev, req);
                         return USBD_FAIL;
                 }
-            } else if (recipient == USBD_MODE_HID) {
+            }
+            #endif
+            #if MICROPY_HW_USB_HID
+            if (recipient == USBD_MODE_HID) {
                 switch (req->bRequest) {
                     case HID_REQ_SET_PROTOCOL:
                         usbd->hid->ctl_protocol = (uint8_t)(req->wValue);
@@ -1013,9 +956,11 @@ static uint8_t USBD_CDC_MSC_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTyp
                         return USBD_FAIL;
                 }
             }
+            #endif
             break;
 
         case USB_REQ_TYPE_STANDARD:
+            #if MICROPY_HW_USB_MSC
             if (recipient == USBD_MODE_MSC) {
                 switch (req->bRequest) {
                     case USB_REQ_GET_INTERFACE :
@@ -1043,7 +988,10 @@ static uint8_t USBD_CDC_MSC_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTyp
                         MSC_BOT_CplClrFeature(pdev, (uint8_t)req->wIndex);
                         break;
                 }
-            } else if (recipient == USBD_MODE_HID) {
+            }
+            #endif
+            #if MICROPY_HW_USB_HID
+            if (recipient == USBD_MODE_HID) {
                 switch (req->bRequest) {
                     case USB_REQ_GET_DESCRIPTOR: {
                         uint16_t len = 0;
@@ -1069,6 +1017,7 @@ static uint8_t USBD_CDC_MSC_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTyp
                         break;
                 }
             }
+            #endif
             break;
     }
     return USBD_OK;
@@ -1081,68 +1030,69 @@ static uint8_t EP0_TxSent(USBD_HandleTypeDef *pdev) {
 
 static uint8_t USBD_CDC_MSC_HID_EP0_RxReady(USBD_HandleTypeDef *pdev) {
     usbd_cdc_msc_hid_state_t *usbd = pdev->pClassData;
-    if (usbd->cdc != NULL && usbd->cdc->cur_request != 0xff) {
-        usbd_cdc_control(usbd->cdc, usbd->cdc->cur_request, (uint8_t*)usbd->cdc->ctl_packet_buf, usbd->cdc->cur_length);
-        usbd->cdc->cur_request = 0xff;
-    }
-    #if MICROPY_HW_USB_ENABLE_CDC2
-    if (usbd->cdc2 != NULL && usbd->cdc2->cur_request != 0xff) {
-        usbd_cdc_control(usbd->cdc2, usbd->cdc2->cur_request, (uint8_t*)usbd->cdc2->ctl_packet_buf, usbd->cdc2->cur_length);
-        usbd->cdc2->cur_request = 0xff;
+    for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
+        if (usbd->cdc[i] != NULL && usbd->cdc[i]->cur_request != 0xff) {
+            usbd_cdc_control(usbd->cdc[i], usbd->cdc[i]->cur_request, (uint8_t*)usbd->cdc[i]->ctl_packet_buf, usbd->cdc[i]->cur_length);
+            usbd->cdc[i]->cur_request = 0xff;
+        }
     }
-    #endif
-
     return USBD_OK;
 }
 
 static uint8_t USBD_CDC_MSC_HID_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum) {
     usbd_cdc_msc_hid_state_t *usbd = pdev->pClassData;
-    if ((usbd->usbd_mode & USBD_MODE_CDC) && (epnum == (CDC_IN_EP & 0x7f) || epnum == (CDC_CMD_EP & 0x7f))) {
-        usbd->cdc->tx_in_progress = 0;
-        usbd_cdc_tx_ready(usbd->cdc);
-        return USBD_OK;
-    #if MICROPY_HW_USB_ENABLE_CDC2
-    } else if ((usbd->usbd_mode & USBD_MODE_CDC2) && (epnum == (CDC2_IN_EP & 0x7f) || epnum == (CDC2_CMD_EP & 0x7f))) {
-        usbd->cdc2->tx_in_progress = 0;
-        usbd_cdc_tx_ready(usbd->cdc2);
-        return USBD_OK;
-    #endif
-    } else if ((usbd->usbd_mode & USBD_MODE_MSC) && epnum == (MSC_IN_EP & 0x7f)) {
+
+    for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
+        if ((usbd->usbd_mode & USBD_MODE_IFACE_CDC(i)) && (epnum == (CDC_IN_EP(i) & 0x7f) || epnum == (CDC_CMD_EP(i) & 0x7f))) {
+            usbd->cdc[i]->tx_in_progress = 0;
+            usbd_cdc_tx_ready(usbd->cdc[i]);
+            return USBD_OK;
+        }
+    }
+
+    #if MICROPY_HW_USB_MSC
+    if ((usbd->usbd_mode & USBD_MODE_IFACE_MSC) && epnum == (MSC_IN_EP & 0x7f)) {
         MSC_BOT_DataIn(pdev, epnum);
         return USBD_OK;
-    } else if ((usbd->usbd_mode & USBD_MODE_HID) && epnum == (usbd->hid->in_ep & 0x7f)) {
+    }
+    #endif
+
+    #if MICROPY_HW_USB_HID
+    if ((usbd->usbd_mode & USBD_MODE_IFACE_HID) && epnum == (usbd->hid->in_ep & 0x7f)) {
         /* Ensure that the FIFO is empty before a new transfer, this condition could
         be caused by  a new transfer before the end of the previous transfer */
         usbd->hid->state = HID_IDLE;
         return USBD_OK;
     }
+    #endif
 
     return USBD_OK;
 }
 
 static uint8_t USBD_CDC_MSC_HID_DataOut(USBD_HandleTypeDef *pdev, uint8_t epnum) {
     usbd_cdc_msc_hid_state_t *usbd = pdev->pClassData;
-    if ((usbd->usbd_mode & USBD_MODE_CDC) && epnum == (CDC_OUT_EP & 0x7f)) {
-        /* Get the received data length */
-        size_t len = USBD_LL_GetRxDataSize (pdev, epnum);
 
-        /* USB data will be immediately processed, this allow next USB traffic being
-        NAKed till the end of the application Xfer */
-        return usbd_cdc_receive(usbd->cdc, len);
+    for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
+        if ((usbd->usbd_mode & USBD_MODE_IFACE_CDC(i)) && epnum == (CDC_OUT_EP(i) & 0x7f)) {
+            size_t len = USBD_LL_GetRxDataSize(pdev, epnum);
+            // USB data will be immediately processed, and next USB traffic is NAKed until it's done
+            return usbd_cdc_receive(usbd->cdc[i], len);
+        }
+    }
 
-    #if MICROPY_HW_USB_ENABLE_CDC2
-    } else if ((usbd->usbd_mode & USBD_MODE_CDC2) && epnum == (CDC2_OUT_EP & 0x7f)) {
-        size_t len = USBD_LL_GetRxDataSize(pdev, epnum);
-        return usbd_cdc_receive(usbd->cdc2, len);
-        
-    #endif
-    } else if ((usbd->usbd_mode & USBD_MODE_MSC) && epnum == (MSC_OUT_EP & 0x7f)) {
+    #if MICROPY_HW_USB_MSC
+    if ((usbd->usbd_mode & USBD_MODE_IFACE_MSC) && epnum == (MSC_OUT_EP & 0x7f)) {
         MSC_BOT_DataOut(pdev, epnum);
         return USBD_OK;
-    } else if ((usbd->usbd_mode & USBD_MODE_HID) && epnum == (usbd->hid->out_ep & 0x7f)) {
+    }
+    #endif
+
+    #if MICROPY_HW_USB_HID
+    if ((usbd->usbd_mode & USBD_MODE_IFACE_HID) && epnum == (usbd->hid->out_ep & 0x7f)) {
         size_t len = USBD_LL_GetRxDataSize(pdev, epnum);
-        usbd_hid_receive(usbd->hid, len);
+        return usbd_hid_receive(usbd->hid, len);
     }
+    #endif
 
     return USBD_OK;
 }
@@ -1168,48 +1118,69 @@ static uint8_t *USBD_CDC_MSC_HID_GetCfgDesc(USBD_HandleTypeDef *pdev, uint16_t *
     usbd_cdc_msc_hid_state_t *usbd = pdev->pClassData;
 
     #if USBD_SUPPORT_HS_MODE
-    uint8_t *cdc_desc = NULL;
-    #if MICROPY_HW_USB_ENABLE_CDC2
-    uint8_t *cdc2_desc = NULL;
-    #endif
+    uint8_t *cdc_desc[MICROPY_HW_USB_CDC_NUM] = {0};
     uint8_t *msc_desc = NULL;
-    switch (usbd->usbd_mode) {
+    switch (usbd->usbd_mode & USBD_MODE_IFACE_MASK) {
+        #if MICROPY_HW_USB_MSC
         case USBD_MODE_MSC:
             msc_desc = usbd->usbd_config_desc + MSC_TEMPLATE_MSC_DESC_OFFSET;
             break;
 
         case USBD_MODE_CDC_MSC:
-            cdc_desc = usbd->usbd_config_desc + CDC_MSC_TEMPLATE_CDC_DESC_OFFSET;
+            cdc_desc[0] = usbd->usbd_config_desc + CDC_MSC_TEMPLATE_CDC_DESC_OFFSET;
             msc_desc = usbd->usbd_config_desc + CDC_MSC_TEMPLATE_MSC_DESC_OFFSET;
             break;
+        #endif
+
+        #if MICROPY_HW_USB_CDC_NUM >= 2
+        case USBD_MODE_CDC2:
+            cdc_desc[0] = usbd->usbd_config_desc + CDC2_TEMPLATE_CDC_DESC_OFFSET;
+            cdc_desc[1] = usbd->usbd_config_desc + CDC2_TEMPLATE_CDC2_DESC_OFFSET;
+            break;
 
-        #if MICROPY_HW_USB_ENABLE_CDC2
+        #if MICROPY_HW_USB_MSC
         case USBD_MODE_CDC2_MSC:
-            cdc_desc = usbd->usbd_config_desc + CDC2_MSC_TEMPLATE_CDC_DESC_OFFSET;
-            cdc2_desc = usbd->usbd_config_desc + CDC2_MSC_TEMPLATE_CDC2_DESC_OFFSET;
+            cdc_desc[0] = usbd->usbd_config_desc + CDC2_MSC_TEMPLATE_CDC_DESC_OFFSET;
+            cdc_desc[1] = usbd->usbd_config_desc + CDC2_MSC_TEMPLATE_CDC2_DESC_OFFSET;
             msc_desc = usbd->usbd_config_desc + CDC2_MSC_TEMPLATE_MSC_DESC_OFFSET;
             break;
         #endif
+        #endif
 
+        #if MICROPY_HW_USB_CDC_NUM >= 3
+        case USBD_MODE_CDC3:
+            cdc_desc[0] = usbd->usbd_config_desc + CDC3_TEMPLATE_CDC_DESC_OFFSET;
+            cdc_desc[1] = usbd->usbd_config_desc + CDC3_TEMPLATE_CDC2_DESC_OFFSET;
+            cdc_desc[2] = usbd->usbd_config_desc + CDC3_TEMPLATE_CDC3_DESC_OFFSET;
+            break;
+
+        #if MICROPY_HW_USB_MSC
+        case USBD_MODE_CDC3_MSC:
+            cdc_desc[0] = usbd->usbd_config_desc + CDC3_MSC_TEMPLATE_CDC_DESC_OFFSET;
+            cdc_desc[1] = usbd->usbd_config_desc + CDC3_MSC_TEMPLATE_CDC2_DESC_OFFSET;
+            cdc_desc[2] = usbd->usbd_config_desc + CDC3_MSC_TEMPLATE_CDC3_DESC_OFFSET;
+            msc_desc = usbd->usbd_config_desc + CDC3_MSC_TEMPLATE_MSC_DESC_OFFSET;
+            break;
+        #endif
+        #endif
+
+        #if MICROPY_HW_USB_HID
         case USBD_MODE_CDC_HID:
-            cdc_desc = usbd->usbd_config_desc + CDC_HID_TEMPLATE_CDC_DESC_OFFSET;
+            cdc_desc[0] = usbd->usbd_config_desc + CDC_HID_TEMPLATE_CDC_DESC_OFFSET;
             break;
+        #endif
 
         case USBD_MODE_CDC:
-            cdc_desc = usbd->usbd_config_desc + CDC_TEMPLATE_CDC_DESC_OFFSET;
+            cdc_desc[0] = usbd->usbd_config_desc + CDC_TEMPLATE_CDC_DESC_OFFSET;
             break;
     }
 
     // configure CDC descriptors, if needed
-    if (cdc_desc != NULL) {
-        usbd_cdc_desc_config_max_packet(pdev, cdc_desc);
-    }
-
-    #if MICROPY_HW_USB_ENABLE_CDC2
-    if (cdc2_desc != NULL) {
-        usbd_cdc_desc_config_max_packet(pdev, cdc2_desc);
+    for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
+        if (cdc_desc[i] != NULL) {
+            usbd_cdc_desc_config_max_packet(pdev, cdc_desc[i]);
+        }
     }
-    #endif
 
     if (msc_desc != NULL) {
         uint32_t mp = usbd_msc_max_packet(pdev);
@@ -1264,6 +1235,8 @@ uint8_t USBD_CDC_ReceivePacket(usbd_cdc_state_t *cdc, uint8_t *buf) {
     return USBD_OK;
 }
 
+#if MICROPY_HW_USB_HID
+
 // prepare OUT endpoint for reception
 uint8_t USBD_HID_ReceivePacket(usbd_hid_state_t *hid, uint8_t *buf) {
     // Suspend or Resume USB Out process
@@ -1298,23 +1271,7 @@ uint8_t USBD_HID_SendReport(usbd_hid_state_t *hid, uint8_t *report, uint16_t len
     return USBD_FAIL;
 }
 
-uint8_t USBD_HID_SetNAK(usbd_hid_state_t *hid) {
-    // get USBx object from pdev (needed for USBx_OUTEP macro below)
-    PCD_HandleTypeDef *hpcd = hid->usbd->pdev->pData;
-    USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
-    // set NAK on HID OUT endpoint
-    USBx_OUTEP(HID_OUT_EP_WITH_CDC)->DOEPCTL |= USB_OTG_DOEPCTL_SNAK;
-    return USBD_OK;
-}
-
-uint8_t USBD_HID_ClearNAK(usbd_hid_state_t *hid) {
-    // get USBx object from pdev (needed for USBx_OUTEP macro below)
-    PCD_HandleTypeDef *hpcd = hid->usbd->pdev->pData;
-    USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
-    // clear NAK on HID OUT endpoint
-    USBx_OUTEP(HID_OUT_EP_WITH_CDC)->DOEPCTL |= USB_OTG_DOEPCTL_CNAK;
-    return USBD_OK;
-}
+#endif
 
 // CDC/MSC/HID interface class callback structure
 const USBD_ClassTypeDef USBD_CDC_MSC_HID = {
diff --git a/ports/stm32/usbdev/class/src/usbd_msc_bot.c b/ports/stm32/usbdev/class/src/usbd_msc_bot.c
index d20f7a8dc0a17..44a74a66023d4 100644
--- a/ports/stm32/usbdev/class/src/usbd_msc_bot.c
+++ b/ports/stm32/usbdev/class/src/usbd_msc_bot.c
@@ -31,6 +31,8 @@
 #include "usbd_cdc_msc_hid.h"
 #include "usbd_ioreq.h"
 
+#if MICROPY_HW_USB_MSC
+
 /** @addtogroup STM32_USB_OTG_DEVICE_LIBRARY
   * @{
   */
@@ -404,4 +406,6 @@ void  MSC_BOT_CplClrFeature (USBD_HandleTypeDef  *pdev, uint8_t epnum)
   * @}
   */
 
+#endif // MICROPY_HW_USB_MSC
+
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
diff --git a/ports/stm32/usbdev/class/src/usbd_msc_data.c b/ports/stm32/usbdev/class/src/usbd_msc_data.c
deleted file mode 100644
index 96740a3a4fba2..0000000000000
--- a/ports/stm32/usbdev/class/src/usbd_msc_data.c
+++ /dev/null
@@ -1,134 +0,0 @@
-/**
-  ******************************************************************************
-  * @file    usbd_msc_data.c
-  * @author  MCD Application Team
-  * @version V2.0.0
-  * @date    18-February-2014
-  * @brief   This file provides all the vital inquiry pages and sense data.
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; COPYRIGHT 2014 STMicroelectronics</center></h2>
-  *
-  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
-  * You may not use this file except in compliance with the License.
-  * You may obtain a copy of the License at:
-  *
-  *        http://www.st.com/software_license_agreement_liberty_v2
-  *
-  * Unless required by applicable law or agreed to in writing, software
-  * distributed under the License is distributed on an "AS IS" BASIS,
-  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  * See the License for the specific language governing permissions and
-  * limitations under the License.
-  *
-  ******************************************************************************
-  */
-
-/* Includes ------------------------------------------------------------------*/
-#include "usbd_msc_data.h"
-
-
-/** @addtogroup STM32_USB_OTG_DEVICE_LIBRARY
-  * @{
-  */
-
-
-/** @defgroup MSC_DATA
-  * @brief Mass storage info/data module
-  * @{
-  */
-
-/** @defgroup MSC_DATA_Private_TypesDefinitions
-  * @{
-  */
-/**
-  * @}
-  */
-
-
-/** @defgroup MSC_DATA_Private_Defines
-  * @{
-  */
-/**
-  * @}
-  */
-
-
-/** @defgroup MSC_DATA_Private_Macros
-  * @{
-  */
-/**
-  * @}
-  */
-
-
-/** @defgroup MSC_DATA_Private_Variables
-  * @{
-  */
-
-
-/* USB Mass storage Page 0 Inquiry Data */
-const uint8_t  MSC_Page00_Inquiry_Data[] = {//7
-        0x00,
-        0x00,
-        0x00,
-        (LENGTH_INQUIRY_PAGE00 - 4),
-        0x00,
-        0x80,
-        0x83
-};
-/* USB Mass storage sense 6  Data */
-const uint8_t  MSC_Mode_Sense6_data[] = {
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00
-};
-/* USB Mass storage sense 10  Data */
-const uint8_t  MSC_Mode_Sense10_data[] = {
-        0x00,
-        0x06,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00,
-        0x00
-};
-/**
-  * @}
-  */
-
-
-/** @defgroup MSC_DATA_Private_FunctionPrototypes
-  * @{
-  */
-/**
-  * @}
-  */
-
-
-/** @defgroup MSC_DATA_Private_Functions
-  * @{
-  */
-
-/**
-  * @}
-  */
-
-
-/**
-  * @}
-  */
-
-
-/**
-  * @}
-  */
-
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
diff --git a/ports/stm32/usbdev/class/src/usbd_msc_scsi.c b/ports/stm32/usbdev/class/src/usbd_msc_scsi.c
index 9da90337716da..d0413b758a5d6 100644
--- a/ports/stm32/usbdev/class/src/usbd_msc_scsi.c
+++ b/ports/stm32/usbdev/class/src/usbd_msc_scsi.c
@@ -28,10 +28,9 @@
 /* Includes ------------------------------------------------------------------*/
 #include "usbd_msc_bot.h"
 #include "usbd_msc_scsi.h"
-#include "usbd_msc_data.h"
 #include "usbd_cdc_msc_hid.h"
 
-
+#if MICROPY_HW_USB_MSC
 
 /** @addtogroup STM32_USB_OTG_DEVICE_LIBRARY
   * @{
@@ -225,33 +224,15 @@ static int8_t SCSI_TestUnitReady(USBD_HandleTypeDef  *pdev, uint8_t lun, uint8_t
 */
 static int8_t  SCSI_Inquiry(USBD_HandleTypeDef  *pdev, uint8_t lun, uint8_t *params)
 {
-  uint8_t* pPage;
-  uint16_t len;
   USBD_MSC_BOT_HandleTypeDef *hmsc = &((usbd_cdc_msc_hid_state_t*)pdev->pClassData)->MSC_BOT_ClassData;
 
-  if (params[1] & 0x01)/*Evpd is set*/
-  {
-    pPage = (uint8_t *)MSC_Page00_Inquiry_Data;
-    len = LENGTH_INQUIRY_PAGE00;
-  }
-  else
-  {
-
-    pPage = (uint8_t *)&hmsc->bdev_ops->pInquiry[lun * STANDARD_INQUIRY_DATA_LEN];
-    len = pPage[4] + 5;
-
-    if (params[4] <= len)
-    {
-      len = params[4];
-    }
-  }
-  hmsc->bot_data_length = len;
-
-  while (len)
+  int res = hmsc->bdev_ops->Inquiry(lun, params, hmsc->bot_data);
+  if (res < 0)
   {
-    len--;
-    hmsc->bot_data[len] = pPage[len];
+    SCSI_SenseCode(pdev, lun, ILLEGAL_REQUEST, INVALID_CDB);
+    return -1;
   }
+  hmsc->bot_data_length = res;
   return 0;
 }
 
@@ -346,13 +327,13 @@ static int8_t SCSI_ReadFormatCapacity(USBD_HandleTypeDef  *pdev, uint8_t lun, ui
 static int8_t SCSI_ModeSense6 (USBD_HandleTypeDef  *pdev, uint8_t lun, uint8_t *params)
 {
   USBD_MSC_BOT_HandleTypeDef *hmsc = &((usbd_cdc_msc_hid_state_t*)pdev->pClassData)->MSC_BOT_ClassData;
-  uint16_t len = 8 ;
+  uint16_t len = sizeof(USBD_MSC_Mode_Sense6_Data);
   hmsc->bot_data_length = len;
 
   while (len)
   {
     len--;
-    hmsc->bot_data[len] = MSC_Mode_Sense6_data[len];
+    hmsc->bot_data[len] = USBD_MSC_Mode_Sense6_Data[len];
   }
   return 0;
 }
@@ -366,7 +347,7 @@ static int8_t SCSI_ModeSense6 (USBD_HandleTypeDef  *pdev, uint8_t lun, uint8_t *
 */
 static int8_t SCSI_ModeSense10 (USBD_HandleTypeDef  *pdev, uint8_t lun, uint8_t *params)
 {
-  uint16_t len = 8;
+  uint16_t len = sizeof(USBD_MSC_Mode_Sense10_Data);
   USBD_MSC_BOT_HandleTypeDef *hmsc = &((usbd_cdc_msc_hid_state_t*)pdev->pClassData)->MSC_BOT_ClassData;
 
   hmsc->bot_data_length = len;
@@ -374,7 +355,7 @@ static int8_t SCSI_ModeSense10 (USBD_HandleTypeDef  *pdev, uint8_t lun, uint8_t
   while (len)
   {
     len--;
-    hmsc->bot_data[len] = MSC_Mode_Sense10_data[len];
+    hmsc->bot_data[len] = USBD_MSC_Mode_Sense10_Data[len];
   }
   return 0;
 }
@@ -808,4 +789,6 @@ static int8_t SCSI_ProcessWrite (USBD_HandleTypeDef  *pdev, uint8_t lun)
   * @}
   */
 
+#endif // MICROPY_HW_USB_MSC
+
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
diff --git a/ports/stm32/usbdev/core/inc/usbd_core.h b/ports/stm32/usbdev/core/inc/usbd_core.h
index 5494be3a22ec2..d3925fc6b7148 100644
--- a/ports/stm32/usbdev/core/inc/usbd_core.h
+++ b/ports/stm32/usbdev/core/inc/usbd_core.h
@@ -111,7 +111,7 @@ USBD_StatusTypeDef USBD_LL_DevConnected(USBD_HandleTypeDef  *pdev);
 USBD_StatusTypeDef USBD_LL_DevDisconnected(USBD_HandleTypeDef  *pdev);
 
 /* USBD Low Level Driver */
-USBD_StatusTypeDef  USBD_LL_Init (USBD_HandleTypeDef *pdev, int high_speed);
+USBD_StatusTypeDef  USBD_LL_Init (USBD_HandleTypeDef *pdev, int high_speed, const uint8_t *fifo_size);
 USBD_StatusTypeDef  USBD_LL_DeInit (USBD_HandleTypeDef *pdev);
 USBD_StatusTypeDef  USBD_LL_Start(USBD_HandleTypeDef *pdev);
 USBD_StatusTypeDef  USBD_LL_Stop (USBD_HandleTypeDef *pdev);
diff --git a/ports/stm32/usbdev/core/src/usbd_core.c b/ports/stm32/usbdev/core/src/usbd_core.c
index f235b24ee6c3e..4c69a77eb60c6 100644
--- a/ports/stm32/usbdev/core/src/usbd_core.c
+++ b/ports/stm32/usbdev/core/src/usbd_core.c
@@ -85,6 +85,7 @@
 * @{
 */
 
+#if 0
 /**
 * @brief  USBD_Init
 *         Initailizes the device stack and load the class driver
@@ -122,6 +123,7 @@ USBD_StatusTypeDef USBD_Init(USBD_HandleTypeDef *pdev, USBD_DescriptorsTypeDef *
 
   return USBD_OK;
 }
+#endif
 
 /**
 * @brief  USBD_DeInit
diff --git a/ports/stm32/usrsw.c b/ports/stm32/usrsw.c
index 4519f8018e4b6..596efba0530a7 100644
--- a/ports/stm32/usrsw.c
+++ b/ports/stm32/usrsw.c
@@ -119,10 +119,10 @@ mp_obj_t pyb_switch_callback(mp_obj_t self_in, mp_obj_t callback) {
     // may have been disabled by an exception in the interrupt, or the
     // user disabling the line explicitly.
     extint_register(MP_OBJ_FROM_PTR(MICROPY_HW_USRSW_PIN),
-                    MICROPY_HW_USRSW_EXTI_MODE,
-                    MICROPY_HW_USRSW_PULL,
-                    callback == mp_const_none ? mp_const_none : MP_OBJ_FROM_PTR(&switch_callback_obj),
-                    true);
+        MICROPY_HW_USRSW_EXTI_MODE,
+        MICROPY_HW_USRSW_PULL,
+        callback == mp_const_none ? mp_const_none : MP_OBJ_FROM_PTR(&switch_callback_obj),
+        true);
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_switch_callback_obj, pyb_switch_callback);
@@ -140,7 +140,7 @@ const mp_obj_type_t pyb_switch_type = {
     .print = pyb_switch_print,
     .make_new = pyb_switch_make_new,
     .call = pyb_switch_call,
-    .locals_dict = (mp_obj_dict_t*)&pyb_switch_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_switch_locals_dict,
 };
 
 #endif // MICROPY_HW_HAS_SWITCH
diff --git a/ports/stm32/wdt.c b/ports/stm32/wdt.c
index 3cfbd7f2ed80d..d794607bc0a71 100644
--- a/ports/stm32/wdt.c
+++ b/ports/stm32/wdt.c
@@ -51,7 +51,7 @@ STATIC mp_obj_t pyb_wdt_make_new(const mp_obj_type_t *type, size_t n_args, size_
 
     mp_int_t id = args[ARG_id].u_int;
     if (id != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "WDT(%d) doesn't exist", id));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("WDT(%d) doesn't exist"), id);
     }
 
     // timeout is in milliseconds
@@ -65,9 +65,9 @@ STATIC mp_obj_t pyb_wdt_make_new(const mp_obj_type_t *type, size_t n_args, size_
     // convert milliseconds to ticks
     timeout *= 8; // 32kHz / 4 = 8 ticks per millisecond (approx)
     if (timeout <= 0) {
-        mp_raise_ValueError("WDT timeout too short");
+        mp_raise_ValueError(MP_ERROR_TEXT("WDT timeout too short"));
     } else if (timeout > 0xfff) {
-        mp_raise_ValueError("WDT timeout too long");
+        mp_raise_ValueError(MP_ERROR_TEXT("WDT timeout too long"));
     }
     timeout -= 1;
 
@@ -106,5 +106,5 @@ const mp_obj_type_t pyb_wdt_type = {
     { &mp_type_type },
     .name = MP_QSTR_WDT,
     .make_new = pyb_wdt_make_new,
-    .locals_dict = (mp_obj_dict_t*)&pyb_wdt_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&pyb_wdt_locals_dict,
 };
diff --git a/ports/teensy/Makefile b/ports/teensy/Makefile
index 663a86fabd7af..f2623eabd3dc3 100644
--- a/ports/teensy/Makefile
+++ b/ports/teensy/Makefile
@@ -3,6 +3,9 @@ include ../../py/mkenv.mk
 # qstr definitions (must come before including py.mk)
 QSTR_DEFS = qstrdefsport.h $(BUILD)/pins_qstr.h
 
+# MicroPython feature configurations
+MICROPY_ROM_TEXT_COMPRESSION ?= 1
+
 # include py core make definitions
 include $(TOP)/py/py.mk
 
@@ -20,10 +23,10 @@ endif
 
 ifeq ($(USE_ARDUINO_TOOLCHAIN),1)
 $(info Using ARDUINO toolchain)
-CROSS_COMPILE = $(ARDUINO)/hardware/tools/arm-none-eabi/bin/arm-none-eabi-
+CROSS_COMPILE ?= $(ARDUINO)/hardware/tools/arm-none-eabi/bin/arm-none-eabi-
 else
 $(info Using toolchain from PATH)
-CROSS_COMPILE = arm-none-eabi-
+CROSS_COMPILE ?= arm-none-eabi-
 endif
 
 CFLAGS_TEENSY = -DF_CPU=96000000 -DUSB_SERIAL -D__MK20DX256__
@@ -101,6 +104,7 @@ STM_SRC_C = $(addprefix ports/stm32/,\
 LIB_SRC_C = $(addprefix lib/,\
 	libc/string0.c \
 	mp-readline/readline.c \
+	utils/gchelper_native.c \
 	utils/pyexec.c \
 	utils/sys_stdio_mphal.c \
 	)
diff --git a/ports/teensy/hal_ftm.c b/ports/teensy/hal_ftm.c
index 3c031bf6dd875..7ae70b2bbba64 100644
--- a/ports/teensy/hal_ftm.c
+++ b/ports/teensy/hal_ftm.c
@@ -43,7 +43,7 @@ void HAL_FTM_Base_Init(FTM_HandleTypeDef *hftm) {
     FTMx->MOD = hftm->Init.Period;
     uint32_t sc = FTM_SC_PS(hftm->Init.PrescalerShift);
     if (hftm->Init.CounterMode == FTM_COUNTERMODE_CENTER) {
-      sc |= FTM_SC_CPWMS;
+        sc |= FTM_SC_CPWMS;
     }
     FTMx->SC = sc;
 
@@ -89,7 +89,7 @@ void HAL_FTM_OC_Init(FTM_HandleTypeDef *hftm) {
     HAL_FTM_Base_Init(hftm);
 }
 
-void HAL_FTM_OC_ConfigChannel(FTM_HandleTypeDef *hftm, FTM_OC_InitTypeDef* sConfig, uint32_t channel) {
+void HAL_FTM_OC_ConfigChannel(FTM_HandleTypeDef *hftm, FTM_OC_InitTypeDef *sConfig, uint32_t channel) {
     FTM_TypeDef *FTMx = hftm->Instance;
     assert_param(IS_FTM_INSTANCE(FTMx));
     assert_param(IS_FTM_CHANNEL(channel));
@@ -100,11 +100,11 @@ void HAL_FTM_OC_ConfigChannel(FTM_HandleTypeDef *hftm, FTM_OC_InitTypeDef* sConf
     hftm->State = HAL_FTM_STATE_BUSY;
 
     FTMx->channel[channel].CSC = sConfig->OCMode;
-    FTMx->channel[channel].CV  = sConfig->Pulse;
+    FTMx->channel[channel].CV = sConfig->Pulse;
     if (sConfig->OCPolarity & 1) {
-      FTMx->POL |= (1 << channel); 
+        FTMx->POL |= (1 << channel);
     } else {
-      FTMx->POL &= ~(1 << channel); 
+        FTMx->POL &= ~(1 << channel);
     }
 
     hftm->State = HAL_FTM_STATE_READY;
@@ -129,7 +129,7 @@ void HAL_FTM_PWM_Init(FTM_HandleTypeDef *hftm) {
     HAL_FTM_Base_Init(hftm);
 }
 
-void HAL_FTM_PWM_ConfigChannel(FTM_HandleTypeDef *hftm, FTM_OC_InitTypeDef* sConfig, uint32_t channel) {
+void HAL_FTM_PWM_ConfigChannel(FTM_HandleTypeDef *hftm, FTM_OC_InitTypeDef *sConfig, uint32_t channel) {
     FTM_TypeDef *FTMx = hftm->Instance;
     assert_param(IS_FTM_INSTANCE(FTMx));
     assert_param(IS_FTM_CHANNEL(channel));
@@ -140,11 +140,11 @@ void HAL_FTM_PWM_ConfigChannel(FTM_HandleTypeDef *hftm, FTM_OC_InitTypeDef* sCon
     hftm->State = HAL_FTM_STATE_BUSY;
 
     FTMx->channel[channel].CSC = sConfig->OCMode;
-    FTMx->channel[channel].CV  = sConfig->Pulse;
+    FTMx->channel[channel].CV = sConfig->Pulse;
     if (sConfig->OCPolarity & 1) {
-      FTMx->POL |= (1 << channel); 
+        FTMx->POL |= (1 << channel);
     } else {
-      FTMx->POL &= ~(1 << channel); 
+        FTMx->POL &= ~(1 << channel);
     }
 
     hftm->State = HAL_FTM_STATE_READY;
@@ -169,7 +169,7 @@ void HAL_FTM_IC_Init(FTM_HandleTypeDef *hftm) {
     HAL_FTM_Base_Init(hftm);
 }
 
-void HAL_FTM_IC_ConfigChannel(FTM_HandleTypeDef *hftm, FTM_IC_InitTypeDef* sConfig, uint32_t channel) {
+void HAL_FTM_IC_ConfigChannel(FTM_HandleTypeDef *hftm, FTM_IC_InitTypeDef *sConfig, uint32_t channel) {
     FTM_TypeDef *FTMx = hftm->Instance;
     assert_param(IS_FTM_INSTANCE(FTMx));
     assert_param(IS_FTM_CHANNEL(channel));
@@ -183,8 +183,8 @@ void HAL_FTM_IC_ConfigChannel(FTM_HandleTypeDef *hftm, FTM_IC_InitTypeDef* sConf
 }
 
 void HAL_FTM_IC_Start(FTM_HandleTypeDef *hftm, uint32_t channel) {
-    //FTM_TypeDef *FTMx = hftm->Instance;
-    //assert_param(IS_FTM_INSTANCE(FTMx));
+    // FTM_TypeDef *FTMx = hftm->Instance;
+    // assert_param(IS_FTM_INSTANCE(FTMx));
 
     // Nothing else to do
 }
diff --git a/ports/teensy/hal_ftm.h b/ports/teensy/hal_ftm.h
index 84fae8312b9d9..17503c8f2d3b6 100644
--- a/ports/teensy/hal_ftm.h
+++ b/ports/teensy/hal_ftm.h
@@ -31,64 +31,64 @@
 #define FTM2    ((FTM_TypeDef *)&FTM2_SC)
 
 typedef struct {
-    volatile uint32_t CSC;	// Channel x Status And Control
-    volatile uint32_t CV;		// Channel x Value
+    volatile uint32_t CSC;      // Channel x Status And Control
+    volatile uint32_t CV;               // Channel x Value
 } FTM_ChannelTypeDef;
 
 typedef struct {
-    volatile uint32_t SC;		// Status And Control
-    volatile uint32_t CNT;		// Counter
-    volatile uint32_t MOD;		// Modulo
+    volatile uint32_t SC;               // Status And Control
+    volatile uint32_t CNT;              // Counter
+    volatile uint32_t MOD;              // Modulo
     FTM_ChannelTypeDef channel[8];
-    volatile uint32_t CNTIN;	// Counter Initial Value
-    volatile uint32_t STATUS;	// Capture And Compare Status
-    volatile uint32_t MODE;		// Features Mode Selection
-    volatile uint32_t SYNC;		// Synchronization
+    volatile uint32_t CNTIN;    // Counter Initial Value
+    volatile uint32_t STATUS;   // Capture And Compare Status
+    volatile uint32_t MODE;             // Features Mode Selection
+    volatile uint32_t SYNC;             // Synchronization
     volatile uint32_t OUTINIT;  // Initial State For Channels Output
-    volatile uint32_t OUTMASK;	// Output Mask
-    volatile uint32_t COMBINE;	// Function For Linked Channels
+    volatile uint32_t OUTMASK;  // Output Mask
+    volatile uint32_t COMBINE;  // Function For Linked Channels
     volatile uint32_t DEADTIME; // Deadtime Insertion Control
-    volatile uint32_t EXTTRIG;	// FTM External Trigger
-    volatile uint32_t POL;		// Channels Polarity
-    volatile uint32_t FMS;		// Fault Mode Status
-    volatile uint32_t FILTER;	// Input Capture Filter Control
-    volatile uint32_t FLTCTRL;	// Fault Control
-    volatile uint32_t QDCTRL;	// Quadrature Decoder Control And Status
-    volatile uint32_t CONF;		// Configuration
-    volatile uint32_t FLTPOL;	// FTM Fault Input Polarity
-    volatile uint32_t SYNCONF;	// Synchronization Configuration
-    volatile uint32_t INVCTRL;	// FTM Inverting Control
-    volatile uint32_t SWOCTRL;	// FTM Software Output Control
+    volatile uint32_t EXTTRIG;  // FTM External Trigger
+    volatile uint32_t POL;              // Channels Polarity
+    volatile uint32_t FMS;              // Fault Mode Status
+    volatile uint32_t FILTER;   // Input Capture Filter Control
+    volatile uint32_t FLTCTRL;  // Fault Control
+    volatile uint32_t QDCTRL;   // Quadrature Decoder Control And Status
+    volatile uint32_t CONF;             // Configuration
+    volatile uint32_t FLTPOL;   // FTM Fault Input Polarity
+    volatile uint32_t SYNCONF;  // Synchronization Configuration
+    volatile uint32_t INVCTRL;  // FTM Inverting Control
+    volatile uint32_t SWOCTRL;  // FTM Software Output Control
     volatile uint32_t PWMLOAD;  // FTM PWM Load
 } FTM_TypeDef;
 
 typedef struct {
-    uint32_t    PrescalerShift; // Sets the prescaler to 1 << PrescalerShift
-    uint32_t    CounterMode;    // One of FTM_COUNTERMODE_xxx
-    uint32_t    Period;         // Specifies the Period for determining timer overflow
+    uint32_t PrescalerShift;    // Sets the prescaler to 1 << PrescalerShift
+    uint32_t CounterMode;       // One of FTM_COUNTERMODE_xxx
+    uint32_t Period;            // Specifies the Period for determining timer overflow
 } FTM_Base_InitTypeDef;
 
 typedef struct {
-    uint32_t    OCMode;         // One of FTM_OCMODE_xxx
-    uint32_t    Pulse;          // Specifies initial pulse width (0-0xffff)
-    uint32_t    OCPolarity;     // One of FTM_OCPOLRITY_xxx
+    uint32_t OCMode;            // One of FTM_OCMODE_xxx
+    uint32_t Pulse;             // Specifies initial pulse width (0-0xffff)
+    uint32_t OCPolarity;        // One of FTM_OCPOLRITY_xxx
 } FTM_OC_InitTypeDef;
 
 typedef struct {
-    uint32_t    ICPolarity;     // Specifies Rising/Falling/Both
+    uint32_t ICPolarity;        // Specifies Rising/Falling/Both
 } FTM_IC_InitTypeDef;
 
-#define IS_FTM_INSTANCE(INSTANCE)   (((INSTANCE) == FTM0)   || \
-                                     ((INSTANCE) == FTM1)   || \
-                                     ((INSTANCE) == FTM2))
+#define IS_FTM_INSTANCE(INSTANCE)   (((INSTANCE) == FTM0) || \
+    ((INSTANCE) == FTM1) || \
+    ((INSTANCE) == FTM2))
 
-#define IS_FTM_PRESCALERSHIFT(PRESCALERSHIFT) (((PRESCALERSHIFT) & ~7) == 0)
+#define IS_FTM_PRESCALERSHIFT(PRESCALERSHIFT) (((PRESCALERSHIFT)&~7) == 0)
 
 #define FTM_COUNTERMODE_UP      (0)
 #define FTM_COUNTERMODE_CENTER  (FTM_SC_CPWMS)
 
-#define IS_FTM_COUNTERMODE(MODE) (((MODE) == FTM_COUNTERMODE_UP)        ||\
-                                  ((MODE) == FTM_COUNTERMODE_CENTER))
+#define IS_FTM_COUNTERMODE(MODE) (((MODE) == FTM_COUNTERMODE_UP) || \
+    ((MODE) == FTM_COUNTERMODE_CENTER))
 
 #define IS_FTM_PERIOD(PERIOD)   (((PERIOD) & 0xFFFF0000) == 0)
 
@@ -108,12 +108,12 @@ typedef struct {
 #define FTM_OCMODE_PWM2     (FTM_CSC_MSB | FTM_CSC_ELSA)
 
 #define IS_FTM_OC_MODE(mode)        ((mode) == FTM_OCMODE_TIMING || \
-                                     (mode) == FTM_OCMODE_ACTIVE || \
-                                     (mode) == FTM_OCMODE_INACTIVE || \
-                                     (mode) == FTM_OCMODE_TOGGLE )
+    (mode) == FTM_OCMODE_ACTIVE || \
+    (mode) == FTM_OCMODE_INACTIVE || \
+    (mode) == FTM_OCMODE_TOGGLE)
 
 #define IS_FTM_PWM_MODE(mode)       ((mode) == FTM_OCMODE_PWM1 || \
-                                     (mode) == FTM_OCMODE_PWM2)
+    (mode) == FTM_OCMODE_PWM2)
 
 #define IS_FTM_CHANNEL(channel)     (((channel) & ~7) == 0)
 
@@ -122,16 +122,16 @@ typedef struct {
 #define FTM_OCPOLARITY_HIGH     (0)
 #define FTM_OCPOLARITY_LOW      (1)
 
-#define IS_FTM_OC_POLARITY(polarity) ((polarity) == FTM_OCPOLARITY_HIGH    || \
-                                      (polarity) == FTM_OCPOLARITY_LOW)
+#define IS_FTM_OC_POLARITY(polarity) ((polarity) == FTM_OCPOLARITY_HIGH || \
+    (polarity) == FTM_OCPOLARITY_LOW)
 
 #define FTM_ICPOLARITY_RISING   (FTM_CSC_ELSA)
 #define FTM_ICPOLARITY_FALLING  (FTM_CSC_ELSB)
 #define FTM_ICPOLARITY_BOTH     (FTM_CSC_ELSA | FTM_CSC_ELSB)
 
-#define IS_FTM_IC_POLARITY(polarity) ((polarity) == FTM_ICPOLARITY_RISING    || \
-                                      (polarity) == FTM_ICPOLARITY_FALLING   || \
-                                      (polarity) == FTM_ICPOLARITY_BOTH)
+#define IS_FTM_IC_POLARITY(polarity) ((polarity) == FTM_ICPOLARITY_RISING || \
+    (polarity) == FTM_ICPOLARITY_FALLING || \
+    (polarity) == FTM_ICPOLARITY_BOTH)
 
 typedef enum {
     HAL_FTM_STATE_RESET     = 0x00,
@@ -140,9 +140,9 @@ typedef enum {
 } HAL_FTM_State;
 
 typedef struct {
-    FTM_TypeDef            *Instance;
-    FTM_Base_InitTypeDef    Init;
-    HAL_FTM_State           State;
+    FTM_TypeDef *Instance;
+    FTM_Base_InitTypeDef Init;
+    HAL_FTM_State State;
 
 } FTM_HandleTypeDef;
 
@@ -166,19 +166,19 @@ void HAL_FTM_Base_Start_IT(FTM_HandleTypeDef *hftm);
 void HAL_FTM_Base_DeInit(FTM_HandleTypeDef *hftm);
 
 void HAL_FTM_OC_Init(FTM_HandleTypeDef *hftm);
-void HAL_FTM_OC_ConfigChannel(FTM_HandleTypeDef *hftm, FTM_OC_InitTypeDef* sConfig, uint32_t channel);
+void HAL_FTM_OC_ConfigChannel(FTM_HandleTypeDef *hftm, FTM_OC_InitTypeDef *sConfig, uint32_t channel);
 void HAL_FTM_OC_Start(FTM_HandleTypeDef *hftm, uint32_t channel);
 void HAL_FTM_OC_Start_IT(FTM_HandleTypeDef *hftm, uint32_t channel);
 void HAL_FTM_OC_DeInit(FTM_HandleTypeDef *hftm);
 
 void HAL_FTM_PWM_Init(FTM_HandleTypeDef *hftm);
-void HAL_FTM_PWM_ConfigChannel(FTM_HandleTypeDef *hftm, FTM_OC_InitTypeDef* sConfig, uint32_t channel);
+void HAL_FTM_PWM_ConfigChannel(FTM_HandleTypeDef *hftm, FTM_OC_InitTypeDef *sConfig, uint32_t channel);
 void HAL_FTM_PWM_Start(FTM_HandleTypeDef *hftm, uint32_t channel);
 void HAL_FTM_PWM_Start_IT(FTM_HandleTypeDef *hftm, uint32_t channel);
 void HAL_FTM_PWM_DeInit(FTM_HandleTypeDef *hftm);
 
 void HAL_FTM_IC_Init(FTM_HandleTypeDef *hftm);
-void HAL_FTM_IC_ConfigChannel(FTM_HandleTypeDef *hftm, FTM_IC_InitTypeDef* sConfig, uint32_t channel);
+void HAL_FTM_IC_ConfigChannel(FTM_HandleTypeDef *hftm, FTM_IC_InitTypeDef *sConfig, uint32_t channel);
 void HAL_FTM_IC_Start(FTM_HandleTypeDef *hftm, uint32_t channel);
 void HAL_FTM_IC_Start_IT(FTM_HandleTypeDef *hftm, uint32_t channel);
 void HAL_FTM_IC_DeInit(FTM_HandleTypeDef *hftm);
diff --git a/ports/teensy/hal_gpio.c b/ports/teensy/hal_gpio.c
index f9e137602c63c..e8bc1eb5ce1c0 100644
--- a/ports/teensy/hal_gpio.c
+++ b/ports/teensy/hal_gpio.c
@@ -4,8 +4,7 @@
 
 #define GPIO_NUMBER 32
 
-void HAL_GPIO_Init(GPIO_TypeDef *GPIOx, GPIO_InitTypeDef *GPIO_Init)
-{
+void HAL_GPIO_Init(GPIO_TypeDef *GPIOx, GPIO_InitTypeDef *GPIO_Init) {
     /* Check the parameters */
     assert_param(IS_GPIO_PIN(GPIO_Init->Pin));
     assert_param(IS_GPIO_MODE(GPIO_Init->Mode));
@@ -24,11 +23,9 @@ void HAL_GPIO_Init(GPIO_TypeDef *GPIOx, GPIO_InitTypeDef *GPIO_Init)
         if ((GPIO_Init->Mode == GPIO_MODE_AF_PP) || (GPIO_Init->Mode == GPIO_MODE_AF_OD)) {
             /* Check the Alternate function parameter */
             assert_param(IS_GPIO_AF(GPIO_Init->Alternate));
-        }
-        else if (GPIO_Init->Mode == GPIO_MODE_ANALOG) {
+        } else if (GPIO_Init->Mode == GPIO_MODE_ANALOG) {
             GPIO_Init->Alternate = 0;
-        }
-        else {
+        } else {
             GPIO_Init->Alternate = 1;
         }
 
@@ -80,44 +77,39 @@ void HAL_GPIO_Init(GPIO_TypeDef *GPIOx, GPIO_InitTypeDef *GPIO_Init)
             }
         }
 
-#if 0
+        #if 0
         /*--------------------- EXTI Mode Configuration ------------------------*/
         /* Configure the External Interrupt or event for the current IO */
-        if((GPIO_Init->Mode & EXTI_MODE) == EXTI_MODE)
-        {
-          /* Enable SYSCFG Clock */
-          __SYSCFG_CLK_ENABLE();
-
-          temp = ((uint32_t)0x0F) << (4 * (position & 0x03));
-          SYSCFG->EXTICR[position >> 2] &= ~temp;
-          SYSCFG->EXTICR[position >> 2] |= ((uint32_t)(__HAL_GET_GPIO_SOURCE(GPIOx)) << (4 * (position & 0x03)));
-
-          /* Clear EXTI line configuration */
-          EXTI->IMR &= ~((uint32_t)iocurrent);
-          EXTI->EMR &= ~((uint32_t)iocurrent);
-
-          if((GPIO_Init->Mode & GPIO_MODE_IT) == GPIO_MODE_IT)
-          {
-            EXTI->IMR |= iocurrent;
-          }
-          if((GPIO_Init->Mode & GPIO_MODE_EVT) == GPIO_MODE_EVT)
-          {
-            EXTI->EMR |= iocurrent;
-          }
-
-          /* Clear Rising Falling edge configuration */
-          EXTI->RTSR &= ~((uint32_t)iocurrent);
-          EXTI->FTSR &= ~((uint32_t)iocurrent);
-
-          if((GPIO_Init->Mode & RISING_EDGE) == RISING_EDGE)
-          {
-            EXTI->RTSR |= iocurrent;
-          }
-          if((GPIO_Init->Mode & FALLING_EDGE) == FALLING_EDGE)
-          {
-            EXTI->FTSR |= iocurrent;
-          }
+        if ((GPIO_Init->Mode & EXTI_MODE) == EXTI_MODE) {
+            /* Enable SYSCFG Clock */
+            __SYSCFG_CLK_ENABLE();
+
+            temp = ((uint32_t)0x0F) << (4 * (position & 0x03));
+            SYSCFG->EXTICR[position >> 2] &= ~temp;
+            SYSCFG->EXTICR[position >> 2] |= ((uint32_t)(__HAL_GET_GPIO_SOURCE(GPIOx)) << (4 * (position & 0x03)));
+
+            /* Clear EXTI line configuration */
+            EXTI->IMR &= ~((uint32_t)iocurrent);
+            EXTI->EMR &= ~((uint32_t)iocurrent);
+
+            if ((GPIO_Init->Mode & GPIO_MODE_IT) == GPIO_MODE_IT) {
+                EXTI->IMR |= iocurrent;
+            }
+            if ((GPIO_Init->Mode & GPIO_MODE_EVT) == GPIO_MODE_EVT) {
+                EXTI->EMR |= iocurrent;
+            }
+
+            /* Clear Rising Falling edge configuration */
+            EXTI->RTSR &= ~((uint32_t)iocurrent);
+            EXTI->FTSR &= ~((uint32_t)iocurrent);
+
+            if ((GPIO_Init->Mode & RISING_EDGE) == RISING_EDGE) {
+                EXTI->RTSR |= iocurrent;
+            }
+            if ((GPIO_Init->Mode & FALLING_EDGE) == FALLING_EDGE) {
+                EXTI->FTSR |= iocurrent;
+            }
         }
-#endif
+        #endif
     }
 }
diff --git a/ports/teensy/help.c b/ports/teensy/help.c
index a2370c04d2cd7..11625afc5a887 100644
--- a/ports/teensy/help.c
+++ b/ports/teensy/help.c
@@ -27,43 +27,43 @@
 #include "py/builtin.h"
 
 const char teensy_help_text[] =
-"Welcome to MicroPython!\n"
-"\n"
-"For online help please visit http://micropython.org/help/.\n"
-"\n"
-"Quick overview of commands for the board:\n"
-"  pyb.info()    -- print some general information\n"
-"  pyb.gc()      -- run the garbage collector\n"
-"  pyb.delay(n)  -- wait for n milliseconds\n"
-"  pyb.Switch()  -- create a switch object\n"
-"                   Switch methods: (), callback(f)\n"
-"  pyb.LED(n)    -- create an LED object for LED n (n=1,2,3,4)\n"
-"                   LED methods: on(), off(), toggle(), intensity(<n>)\n"
-"  pyb.Pin(pin)  -- get a pin, eg pyb.Pin('X1')\n"
-"  pyb.Pin(pin, m, [p]) -- get a pin and configure it for IO mode m, pull mode p\n"
-"                   Pin methods: init(..), value([v]), high(), low()\n"
-"  pyb.ExtInt(pin, m, p, callback) -- create an external interrupt object\n"
-"  pyb.ADC(pin)  -- make an analog object from a pin\n"
-"                   ADC methods: read(), read_timed(buf, freq)\n"
-"  pyb.DAC(port) -- make a DAC object\n"
-"                   DAC methods: triangle(freq), write(n), write_timed(buf, freq)\n"
-"  pyb.RTC()     -- make an RTC object; methods: datetime([val])\n"
-"  pyb.rng()     -- get a 30-bit hardware random number\n"
-"  pyb.Servo(n)  -- create Servo object for servo n (n=1,2,3,4)\n"
-"                   Servo methods: calibration(..), angle([x, [t]]), speed([x, [t]])\n"
-"  pyb.Accel()   -- create an Accelerometer object\n"
-"                   Accelerometer methods: x(), y(), z(), tilt(), filtered_xyz()\n"
-"\n"
-"Pins are numbered X1-X12, X17-X22, Y1-Y12, or by their MCU name\n"
-"Pin IO modes are: pyb.Pin.IN, pyb.Pin.OUT_PP, pyb.Pin.OUT_OD\n"
-"Pin pull modes are: pyb.Pin.PULL_NONE, pyb.Pin.PULL_UP, pyb.Pin.PULL_DOWN\n"
-"Additional serial bus objects: pyb.I2C(n), pyb.SPI(n), pyb.UART(n)\n"
-"\n"
-"Control commands:\n"
-"  CTRL-A        -- on a blank line, enter raw REPL mode\n"
-"  CTRL-B        -- on a blank line, enter normal REPL mode\n"
-"  CTRL-C        -- interrupt a running program\n"
-"  CTRL-D        -- on a blank line, do a soft reset of the board\n"
-"\n"
-"For further help on a specific object, type help(obj)\n"
+    "Welcome to MicroPython!\n"
+    "\n"
+    "For online help please visit http://micropython.org/help/.\n"
+    "\n"
+    "Quick overview of commands for the board:\n"
+    "  pyb.info()    -- print some general information\n"
+    "  pyb.gc()      -- run the garbage collector\n"
+    "  pyb.delay(n)  -- wait for n milliseconds\n"
+    "  pyb.Switch()  -- create a switch object\n"
+    "                   Switch methods: (), callback(f)\n"
+    "  pyb.LED(n)    -- create an LED object for LED n (n=1,2,3,4)\n"
+    "                   LED methods: on(), off(), toggle(), intensity(<n>)\n"
+    "  pyb.Pin(pin)  -- get a pin, eg pyb.Pin('X1')\n"
+    "  pyb.Pin(pin, m, [p]) -- get a pin and configure it for IO mode m, pull mode p\n"
+    "                   Pin methods: init(..), value([v]), high(), low()\n"
+    "  pyb.ExtInt(pin, m, p, callback) -- create an external interrupt object\n"
+    "  pyb.ADC(pin)  -- make an analog object from a pin\n"
+    "                   ADC methods: read(), read_timed(buf, freq)\n"
+    "  pyb.DAC(port) -- make a DAC object\n"
+    "                   DAC methods: triangle(freq), write(n), write_timed(buf, freq)\n"
+    "  pyb.RTC()     -- make an RTC object; methods: datetime([val])\n"
+    "  pyb.rng()     -- get a 30-bit hardware random number\n"
+    "  pyb.Servo(n)  -- create Servo object for servo n (n=1,2,3,4)\n"
+    "                   Servo methods: calibration(..), angle([x, [t]]), speed([x, [t]])\n"
+    "  pyb.Accel()   -- create an Accelerometer object\n"
+    "                   Accelerometer methods: x(), y(), z(), tilt(), filtered_xyz()\n"
+    "\n"
+    "Pins are numbered X1-X12, X17-X22, Y1-Y12, or by their MCU name\n"
+    "Pin IO modes are: pyb.Pin.IN, pyb.Pin.OUT_PP, pyb.Pin.OUT_OD\n"
+    "Pin pull modes are: pyb.Pin.PULL_NONE, pyb.Pin.PULL_UP, pyb.Pin.PULL_DOWN\n"
+    "Additional serial bus objects: pyb.I2C(n), pyb.SPI(n), pyb.UART(n)\n"
+    "\n"
+    "Control commands:\n"
+    "  CTRL-A        -- on a blank line, enter raw REPL mode\n"
+    "  CTRL-B        -- on a blank line, enter normal REPL mode\n"
+    "  CTRL-C        -- interrupt a running program\n"
+    "  CTRL-D        -- on a blank line, do a soft reset of the board\n"
+    "\n"
+    "For further help on a specific object, type help(obj)\n"
 ;
diff --git a/ports/teensy/led.c b/ports/teensy/led.c
index cf59dbd0a385a..d79e63cf7102a 100644
--- a/ports/teensy/led.c
+++ b/ports/teensy/led.c
@@ -16,15 +16,15 @@ typedef struct _pyb_led_obj_t {
 
 STATIC const pyb_led_obj_t pyb_led_obj[] = {
     {{&pyb_led_type}, 1, &MICROPY_HW_LED1},
-#if defined(MICROPY_HW_LED2)
+    #if defined(MICROPY_HW_LED2)
     {{&pyb_led_type}, 2, &MICROPY_HW_LED2},
-#if defined(MICROPY_HW_LED3)
+    #if defined(MICROPY_HW_LED3)
     {{&pyb_led_type}, 3, &MICROPY_HW_LED3},
-#if defined(MICROPY_HW_LED4)
+    #if defined(MICROPY_HW_LED4)
     {{&pyb_led_type}, 4, &MICROPY_HW_LED4},
-#endif
-#endif
-#endif
+    #endif
+    #endif
+    #endif
 };
 #define NUM_LEDS MP_ARRAY_SIZE(pyb_led_obj)
 
@@ -51,7 +51,7 @@ void led_state(pyb_led_t led, int state) {
         return;
     }
     const pin_obj_t *led_pin = pyb_led_obj[led - 1].led_pin;
-    //printf("led_state(%d,%d)\n", led, state);
+    // printf("led_state(%d,%d)\n", led, state);
     if (state == 0) {
         // turn LED off
         MICROPY_HW_LED_OFF(led_pin);
@@ -97,7 +97,7 @@ STATIC mp_obj_t led_obj_make_new(const mp_obj_type_t *type, uint n_args, uint n_
 
     // check led number
     if (!(1 <= led_id && led_id <= NUM_LEDS)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "LED %d does not exist", led_id));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("LED %d does not exist"), led_id);
     }
 
     // return static led object
diff --git a/ports/teensy/main.c b/ports/teensy/main.c
index ad98a43644009..df3fd1ffcf5ac 100644
--- a/ports/teensy/main.c
+++ b/ports/teensy/main.c
@@ -93,7 +93,7 @@ mp_obj_t pyb_analog_write_frequency(mp_obj_t pin_obj, mp_obj_t freq_obj) {
 static mp_obj_t pyb_info(void) {
     // get and print unique id; 96 bits
     {
-        byte *id = (byte*)0x40048058;
+        byte *id = (byte *)0x40048058;
         printf("ID=%02x%02x%02x%02x:%02x%02x%02x%02x:%02x%02x%02x%02x\n", id[0], id[1], id[2], id[3], id[4], id[5], id[6], id[7], id[8], id[9], id[10], id[11]);
     }
 
@@ -121,7 +121,7 @@ static mp_obj_t pyb_info(void) {
         printf("  1=%u 2=%u m=%u\n", info.num_1block, info.num_2block, info.max_block);
     }
 
-#if 0
+    #if 0
     // free space on flash
     {
         DWORD nclst;
@@ -129,7 +129,7 @@ static mp_obj_t pyb_info(void) {
         f_getfree("0:", &nclst, &fatfs);
         printf("LFS free: %u bytes\n", (uint)(nclst * fatfs->csize * 512));
     }
-#endif
+    #endif
 
     return mp_const_none;
 }
@@ -150,7 +150,7 @@ mp_obj_t pyb_gc(void) {
 }
 
 mp_obj_t pyb_gpio(int n_args, mp_obj_t *args) {
-    //assert(1 <= n_args && n_args <= 2);
+    // assert(1 <= n_args && n_args <= 2);
 
     uint pin = mp_obj_get_int(args[0]);
     if (pin > CORE_NUM_DIGITAL) {
@@ -162,14 +162,14 @@ mp_obj_t pyb_gpio(int n_args, mp_obj_t *args) {
         pinMode(pin, INPUT);
         return MP_OBJ_NEW_SMALL_INT(digitalRead(pin));
     }
-    
+
     // set pin
     pinMode(pin, OUTPUT);
     digitalWrite(pin, mp_obj_is_true(args[1]));
     return mp_const_none;
 
 pin_error:
-    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "pin %d does not exist", pin));
+    mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("pin %d does not exist"), pin);
 }
 
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_gpio_obj, 1, 2, pyb_gpio);
@@ -264,7 +264,7 @@ int main(void) {
     led_state(PYB_LED_BUILTIN, 1);
 
     // GC init
-    gc_init(&_heap_start, (void*)HEAP_END);
+    gc_init(&_heap_start, (void *)HEAP_END);
 
     // MicroPython init
     mp_init();
@@ -276,7 +276,7 @@ int main(void) {
 
     pin_init0();
 
-#if 0
+    #if 0
     // add some functions to the python namespace
     {
         mp_store_name(MP_QSTR_help, mp_make_function_n(0, pyb_help));
@@ -297,23 +297,23 @@ int main(void) {
         mp_store_attr(m, MP_QSTR_Servo, mp_make_function_n(0, pyb_Servo));
         mp_store_name(MP_QSTR_pyb, m);
     }
-#endif
+    #endif
 
-#if MICROPY_MODULE_FROZEN
+    #if MICROPY_MODULE_FROZEN
     pyexec_frozen_module("boot.py");
-#else
-    if (!pyexec_file("/boot.py")) {
+    #else
+    if (!pyexec_file_if_exists("/boot.py")) {
         flash_error(4);
     }
-#endif
+    #endif
 
     // Turn bootup LED off
     led_state(PYB_LED_BUILTIN, 0);
 
     // run main script
-#if MICROPY_MODULE_FROZEN
+    #if MICROPY_MODULE_FROZEN
     pyexec_frozen_module("main.py");
-#else
+    #else
     {
         vstr_t *vstr = vstr_new(16);
         vstr_add_str(vstr, "/");
@@ -322,12 +322,12 @@ int main(void) {
         } else {
             vstr_add_str(vstr, mp_obj_str_get_str(pyb_config_main));
         }
-        if (!pyexec_file(vstr_null_terminated_str(vstr))) {
+        if (!pyexec_file_if_exists(vstr_null_terminated_str(vstr))) {
             flash_error(3);
         }
         vstr_free(vstr);
     }
-#endif
+    #endif
 
     // enter REPL
     // REPL mode can change, or it can request a soft reset
@@ -358,24 +358,25 @@ void __libc_init_array(void) {
 // ultoa is used by usb_init_serialnumber. Normally ultoa would be provided
 // by nonstd.c from the teensy core, but it conflicts with some of the
 // MicroPython functions in string0.c, so we provide ultoa here.
-char * ultoa(unsigned long val, char *buf, int radix) 	
-{
-	unsigned digit;
-	int i=0, j;
-	char t;
-
-	while (1) {
-		digit = val % radix;
-		buf[i] = ((digit < 10) ? '0' + digit : 'A' + digit - 10);
-		val /= radix;
-		if (val == 0) break;
-		i++;
-	}
-	buf[i + 1] = 0;
-	for (j=0; j < i; j++, i--) {
-		t = buf[j];
-		buf[j] = buf[i];
-		buf[i] = t;
-	}
-	return buf;
+char *ultoa(unsigned long val, char *buf, int radix) {
+    unsigned digit;
+    int i = 0, j;
+    char t;
+
+    while (1) {
+        digit = val % radix;
+        buf[i] = ((digit < 10) ? '0' + digit : 'A' + digit - 10);
+        val /= radix;
+        if (val == 0) {
+            break;
+        }
+        i++;
+    }
+    buf[i + 1] = 0;
+    for (j = 0; j < i; j++, i--) {
+        t = buf[j];
+        buf[j] = buf[i];
+        buf[i] = t;
+    }
+    return buf;
 }
diff --git a/ports/teensy/make-pins.py b/ports/teensy/make-pins.py
index 0f6c5f28d4fef..ddefae8521c50 100755
--- a/ports/teensy/make-pins.py
+++ b/ports/teensy/make-pins.py
@@ -8,33 +8,34 @@
 import csv
 
 SUPPORTED_FN = {
-    'FTM'   : ['CH0',  'CH1',  'CH2',  'CH3', 'CH4', 'CH5', 'CH6', 'CH7',
-               'QD_PHA', 'QD_PHB'],
-    'I2C'   : ['SDA', 'SCL'],
-    'UART'  : ['RX', 'TX', 'CTS', 'RTS'],
-    'SPI'   : ['NSS', 'SCK', 'MISO', 'MOSI']
+    "FTM": ["CH0", "CH1", "CH2", "CH3", "CH4", "CH5", "CH6", "CH7", "QD_PHA", "QD_PHB"],
+    "I2C": ["SDA", "SCL"],
+    "UART": ["RX", "TX", "CTS", "RTS"],
+    "SPI": ["NSS", "SCK", "MISO", "MOSI"],
 }
 
+
 def parse_port_pin(name_str):
     """Parses a string and returns a (port-num, pin-num) tuple."""
     if len(name_str) < 4:
         raise ValueError("Expecting pin name to be at least 4 charcters.")
-    if name_str[0:2] != 'PT':
+    if name_str[0:2] != "PT":
         raise ValueError("Expecting pin name to start with PT")
-    if name_str[2] not in ('A', 'B', 'C', 'D', 'E', 'Z'):
+    if name_str[2] not in ("A", "B", "C", "D", "E", "Z"):
         raise ValueError("Expecting pin port to be between A and E or Z")
-    port = ord(name_str[2]) - ord('A')
-    pin_str = name_str[3:].split('/')[0]
+    port = ord(name_str[2]) - ord("A")
+    pin_str = name_str[3:].split("/")[0]
     if not pin_str.isdigit():
         raise ValueError("Expecting numeric pin number.")
     return (port, int(pin_str))
 
+
 def split_name_num(name_num):
     num = None
     for num_idx in range(len(name_num) - 1, -1, -1):
         if not name_num[num_idx].isdigit():
-            name = name_num[0:num_idx + 1]
-            num_str = name_num[num_idx + 1:]
+            name = name_num[0 : num_idx + 1]
+            num_str = name_num[num_idx + 1 :]
             if len(num_str) > 0:
                 num = int(num_str)
             break
@@ -48,12 +49,12 @@ def __init__(self, idx, af_str):
         self.idx = idx
         self.af_str = af_str
 
-        self.func = ''
+        self.func = ""
         self.fn_num = None
-        self.pin_type = ''
+        self.pin_type = ""
         self.supported = False
 
-        af_words = af_str.split('_', 1)
+        af_words = af_str.split("_", 1)
         self.func, self.fn_num = split_name_num(af_words[0])
         if len(af_words) > 1:
             self.pin_type = af_words[1]
@@ -69,22 +70,25 @@ def ptr(self):
         """Returns the numbered function (i.e. USART6) for this AF."""
         if self.fn_num is None:
             return self.func
-        return '{:s}{:d}'.format(self.func, self.fn_num)
+        return "{:s}{:d}".format(self.func, self.fn_num)
 
     def mux_name(self):
-        return 'AF{:d}_{:s}'.format(self.idx, self.ptr())
+        return "AF{:d}_{:s}".format(self.idx, self.ptr())
 
     def print(self):
         """Prints the C representation of this AF."""
         if self.supported:
-            print('  AF',  end='')
+            print("  AF", end="")
         else:
-            print('  //', end='')
+            print("  //", end="")
         fn_num = self.fn_num
         if fn_num is None:
             fn_num = 0
-        print('({:2d}, {:8s}, {:2d}, {:10s}, {:8s}), // {:s}'.format(self.idx,
-              self.func, fn_num, self.pin_type, self.ptr(), self.af_str))
+        print(
+            "({:2d}, {:8s}, {:2d}, {:10s}, {:8s}), // {:s}".format(
+                self.idx, self.func, fn_num, self.pin_type, self.ptr(), self.af_str
+            )
+        )
 
     def qstr_list(self):
         return [self.mux_name()]
@@ -103,10 +107,10 @@ def __init__(self, port, pin):
         self.board_pin = False
 
     def port_letter(self):
-        return chr(self.port + ord('A'))
+        return chr(self.port + ord("A"))
 
     def cpu_pin_name(self):
-        return '{:s}{:d}'.format(self.port_letter(), self.pin)
+        return "{:s}{:d}".format(self.port_letter(), self.pin)
 
     def is_board_pin(self):
         return self.board_pin
@@ -115,12 +119,12 @@ def set_is_board_pin(self):
         self.board_pin = True
 
     def parse_adc(self, adc_str):
-        if (adc_str[:3] != 'ADC'):
+        if adc_str[:3] != "ADC":
             return
-        (adc,channel) = adc_str.split('_')
+        (adc, channel) = adc_str.split("_")
         for idx in range(3, len(adc)):
-            adc_num = int(adc[idx]) # 1, 2, or 3
-            self.adc_num |= (1 << (adc_num - 1))
+            adc_num = int(adc[idx])  # 1, 2, or 3
+            self.adc_num |= 1 << (adc_num - 1)
         self.adc_channel = int(channel[2:])
 
     def parse_af(self, af_idx, af_strs_in):
@@ -128,7 +132,7 @@ def parse_af(self, af_idx, af_strs_in):
             return
         # If there is a slash, then the slash separates 2 aliases for the
         # same alternate function.
-        af_strs = af_strs_in.split('/')
+        af_strs = af_strs_in.split("/")
         for af_str in af_strs:
             alt_fn = AlternateFunction(af_idx, af_str)
             self.alt_fn.append(alt_fn)
@@ -137,43 +141,50 @@ def parse_af(self, af_idx, af_strs_in):
 
     def alt_fn_name(self, null_if_0=False):
         if null_if_0 and self.alt_fn_count == 0:
-            return 'NULL'
-        return 'pin_{:s}_af'.format(self.cpu_pin_name())
+            return "NULL"
+        return "pin_{:s}_af".format(self.cpu_pin_name())
 
     def adc_num_str(self):
-        str = ''
-        for adc_num in range(1,4):
+        str = ""
+        for adc_num in range(1, 4):
             if self.adc_num & (1 << (adc_num - 1)):
                 if len(str) > 0:
-                    str += ' | '
-                str += 'PIN_ADC'
-                str += chr(ord('0') + adc_num)
+                    str += " | "
+                str += "PIN_ADC"
+                str += chr(ord("0") + adc_num)
         if len(str) == 0:
-            str = '0'
+            str = "0"
         return str
 
     def print(self):
         if self.alt_fn_count == 0:
-            print("// ",  end='')
-        print('const pin_af_obj_t {:s}[] = {{'.format(self.alt_fn_name()))
+            print("// ", end="")
+        print("const pin_af_obj_t {:s}[] = {{".format(self.alt_fn_name()))
         for alt_fn in self.alt_fn:
             alt_fn.print()
         if self.alt_fn_count == 0:
-            print("// ",  end='')
-        print('};')
-        print('')
-        print('const pin_obj_t pin_{:s} = PIN({:s}, {:d}, {:d}, {:s}, {:s}, {:d});'.format(
-            self.cpu_pin_name(), self.port_letter(), self.pin,
-            self.alt_fn_count, self.alt_fn_name(null_if_0=True),
-            self.adc_num_str(), self.adc_channel))
-        print('')
+            print("// ", end="")
+        print("};")
+        print("")
+        print(
+            "const pin_obj_t pin_{:s} = PIN({:s}, {:d}, {:d}, {:s}, {:s}, {:d});".format(
+                self.cpu_pin_name(),
+                self.port_letter(),
+                self.pin,
+                self.alt_fn_count,
+                self.alt_fn_name(null_if_0=True),
+                self.adc_num_str(),
+                self.adc_channel,
+            )
+        )
+        print("")
 
     def print_header(self, hdr_file):
-        hdr_file.write('extern const pin_obj_t pin_{:s};\n'.
-                       format(self.cpu_pin_name()))
+        hdr_file.write("extern const pin_obj_t pin_{:s};\n".format(self.cpu_pin_name()))
         if self.alt_fn_count > 0:
-            hdr_file.write('extern const pin_af_obj_t pin_{:s}_af[];\n'.
-                           format(self.cpu_pin_name()))
+            hdr_file.write(
+                "extern const pin_af_obj_t pin_{:s}_af[];\n".format(self.cpu_pin_name())
+            )
 
     def qstr_list(self):
         result = []
@@ -184,7 +195,6 @@ def qstr_list(self):
 
 
 class NamedPin(object):
-
     def __init__(self, name, pin):
         self._name = name
         self._pin = pin
@@ -197,10 +207,9 @@ def name(self):
 
 
 class Pins(object):
-
     def __init__(self):
-        self.cpu_pins = []   # list of NamedPin objects
-        self.board_pins = [] # list of NamedPin objects
+        self.cpu_pins = []  # list of NamedPin objects
+        self.board_pins = []  # list of NamedPin objects
 
     def find_pin(self, port_num, pin_num):
         for named_pin in self.cpu_pins:
@@ -209,7 +218,7 @@ def find_pin(self, port_num, pin_num):
                 return pin
 
     def parse_af_file(self, filename, pinname_col, af_col):
-        with open(filename, 'r') as csvfile:
+        with open(filename, "r") as csvfile:
             rows = csv.reader(csvfile)
             for row in rows:
                 try:
@@ -223,7 +232,7 @@ def parse_af_file(self, filename, pinname_col, af_col):
                 self.cpu_pins.append(NamedPin(pin.cpu_pin_name(), pin))
 
     def parse_board_file(self, filename):
-        with open(filename, 'r') as csvfile:
+        with open(filename, "r") as csvfile:
             rows = csv.reader(csvfile)
             for row in rows:
                 try:
@@ -236,52 +245,64 @@ def parse_board_file(self, filename):
                     self.board_pins.append(NamedPin(row[0], pin))
 
     def print_named(self, label, named_pins):
-        print('STATIC const mp_rom_map_elem_t pin_{:s}_pins_locals_dict_table[] = {{'.format(label))
+        print(
+            "STATIC const mp_rom_map_elem_t pin_{:s}_pins_locals_dict_table[] = {{".format(label)
+        )
         for named_pin in named_pins:
             pin = named_pin.pin()
             if pin.is_board_pin():
-                print('  {{ MP_ROM_QSTR(MP_QSTR_{:s}), MP_ROM_PTR(&pin_{:s}) }},'.format(named_pin.name(),  pin.cpu_pin_name()))
-        print('};')
-        print('MP_DEFINE_CONST_DICT(pin_{:s}_pins_locals_dict, pin_{:s}_pins_locals_dict_table);'.format(label, label));
+                print(
+                    "  {{ MP_ROM_QSTR(MP_QSTR_{:s}), MP_ROM_PTR(&pin_{:s}) }},".format(
+                        named_pin.name(), pin.cpu_pin_name()
+                    )
+                )
+        print("};")
+        print(
+            "MP_DEFINE_CONST_DICT(pin_{:s}_pins_locals_dict, pin_{:s}_pins_locals_dict_table);".format(
+                label, label
+            )
+        )
 
     def print(self):
         for named_pin in self.cpu_pins:
             pin = named_pin.pin()
             if pin.is_board_pin():
                 pin.print()
-        self.print_named('cpu', self.cpu_pins)
-        print('')
-        self.print_named('board', self.board_pins)
+        self.print_named("cpu", self.cpu_pins)
+        print("")
+        self.print_named("board", self.board_pins)
 
     def print_adc(self, adc_num):
-        print('');
-        print('const pin_obj_t * const pin_adc{:d}[] = {{'.format(adc_num))
+        print("")
+        print("const pin_obj_t * const pin_adc{:d}[] = {{".format(adc_num))
         for channel in range(16):
             adc_found = False
             for named_pin in self.cpu_pins:
                 pin = named_pin.pin()
-                if (pin.is_board_pin() and
-                    (pin.adc_num & (1 << (adc_num - 1))) and (pin.adc_channel == channel)):
-                    print('  &pin_{:s}, // {:d}'.format(pin.cpu_pin_name(), channel))
+                if (
+                    pin.is_board_pin()
+                    and (pin.adc_num & (1 << (adc_num - 1)))
+                    and (pin.adc_channel == channel)
+                ):
+                    print("  &pin_{:s}, // {:d}".format(pin.cpu_pin_name(), channel))
                     adc_found = True
                     break
             if not adc_found:
-                print('  NULL,    // {:d}'.format(channel))
-        print('};')
-
+                print("  NULL,    // {:d}".format(channel))
+        print("};")
 
     def print_header(self, hdr_filename):
-        with open(hdr_filename, 'wt') as hdr_file:
+        with open(hdr_filename, "wt") as hdr_file:
             for named_pin in self.cpu_pins:
                 pin = named_pin.pin()
                 if pin.is_board_pin():
                     pin.print_header(hdr_file)
-            hdr_file.write('extern const pin_obj_t * const pin_adc1[];\n')
-            hdr_file.write('extern const pin_obj_t * const pin_adc2[];\n')
-            hdr_file.write('extern const pin_obj_t * const pin_adc3[];\n')
+            hdr_file.write("extern const pin_obj_t * const pin_adc1[];\n")
+            hdr_file.write("extern const pin_obj_t * const pin_adc2[];\n")
+            hdr_file.write("extern const pin_obj_t * const pin_adc3[];\n")
 
     def print_qstr(self, qstr_filename):
-        with open(qstr_filename, 'wt') as qstr_file:
+        with open(qstr_filename, "wt") as qstr_file:
             qstr_set = set([])
             for named_pin in self.cpu_pins:
                 pin = named_pin.pin()
@@ -291,11 +312,10 @@ def print_qstr(self, qstr_filename):
             for named_pin in self.board_pins:
                 qstr_set |= set([named_pin.name()])
             for qstr in sorted(qstr_set):
-                print('Q({})'.format(qstr), file=qstr_file)
-
+                print("Q({})".format(qstr), file=qstr_file)
 
     def print_af_hdr(self, af_const_filename):
-        with open(af_const_filename,  'wt') as af_const_file:
+        with open(af_const_filename, "wt") as af_const_file:
             af_hdr_set = set([])
             mux_name_width = 0
             for named_pin in self.cpu_pins:
@@ -308,88 +328,89 @@ def print_af_hdr(self, af_const_filename):
                             if len(mux_name) > mux_name_width:
                                 mux_name_width = len(mux_name)
             for mux_name in sorted(af_hdr_set):
-                key = 'MP_OBJ_NEW_QSTR(MP_QSTR_{}),'.format(mux_name)
-                val = 'MP_OBJ_NEW_SMALL_INT(GPIO_{})'.format(mux_name)
-                print('    { %-*s %s },' % (mux_name_width + 26, key, val),
-                      file=af_const_file)
+                key = "MP_OBJ_NEW_QSTR(MP_QSTR_{}),".format(mux_name)
+                val = "MP_OBJ_NEW_SMALL_INT(GPIO_{})".format(mux_name)
+                print("    { %-*s %s }," % (mux_name_width + 26, key, val), file=af_const_file)
 
     def print_af_py(self, af_py_filename):
-        with open(af_py_filename,  'wt') as af_py_file:
-            print('PINS_AF = (', file=af_py_file);
+        with open(af_py_filename, "wt") as af_py_file:
+            print("PINS_AF = (", file=af_py_file)
             for named_pin in self.board_pins:
-                print("  ('%s', " % named_pin.name(), end='', file=af_py_file)
+                print("  ('%s', " % named_pin.name(), end="", file=af_py_file)
                 for af in named_pin.pin().alt_fn:
                     if af.is_supported():
-                        print("(%d, '%s'), " % (af.idx, af.af_str), end='', file=af_py_file)
-                print('),', file=af_py_file)
-            print(')',  file=af_py_file)
+                        print("(%d, '%s'), " % (af.idx, af.af_str), end="", file=af_py_file)
+                print("),", file=af_py_file)
+            print(")", file=af_py_file)
 
 
 def main():
     parser = argparse.ArgumentParser(
         prog="make-pins.py",
         usage="%(prog)s [options] [command]",
-        description="Generate board specific pin file"
+        description="Generate board specific pin file",
     )
     parser.add_argument(
-        "-a", "--af",
+        "-a",
+        "--af",
         dest="af_filename",
         help="Specifies the alternate function file for the chip",
-        default="mk20dx256_af.csv"
+        default="mk20dx256_af.csv",
     )
     parser.add_argument(
         "--af-const",
         dest="af_const_filename",
         help="Specifies header file for alternate function constants.",
-        default="build/pins_af_const.h"
+        default="build/pins_af_const.h",
     )
     parser.add_argument(
         "--af-py",
         dest="af_py_filename",
         help="Specifies the filename for the python alternate function mappings.",
-        default="build/pins_af.py"
+        default="build/pins_af.py",
     )
     parser.add_argument(
-        "-b", "--board",
-        dest="board_filename",
-        help="Specifies the board file",
+        "-b", "--board", dest="board_filename", help="Specifies the board file",
     )
     parser.add_argument(
-        "-p", "--prefix",
+        "-p",
+        "--prefix",
         dest="prefix_filename",
         help="Specifies beginning portion of generated pins file",
-        default="mk20dx256_prefix.c"
+        default="mk20dx256_prefix.c",
     )
     parser.add_argument(
-        "-q", "--qstr",
+        "-q",
+        "--qstr",
         dest="qstr_filename",
         help="Specifies name of generated qstr header file",
-        default="build/pins_qstr.h"
+        default="build/pins_qstr.h",
     )
     parser.add_argument(
-        "-r", "--hdr",
+        "-r",
+        "--hdr",
         dest="hdr_filename",
         help="Specifies name of generated pin header file",
-        default="build/pins.h"
+        default="build/pins.h",
     )
     args = parser.parse_args(sys.argv[1:])
 
     pins = Pins()
 
-    print('// This file was automatically generated by make-pins.py')
-    print('//')
+    print("// This file was automatically generated by make-pins.py")
+    print("//")
     if args.af_filename:
-        print('// --af {:s}'.format(args.af_filename))
+        print("// --af {:s}".format(args.af_filename))
         pins.parse_af_file(args.af_filename, 4, 3)
 
     if args.board_filename:
-        print('// --board {:s}'.format(args.board_filename))
+        print("// --board {:s}".format(args.board_filename))
         pins.parse_board_file(args.board_filename)
 
     if args.prefix_filename:
-        print('// --prefix {:s}'.format(args.prefix_filename))
-        print('')
-        with open(args.prefix_filename, 'r') as prefix_file:
+        print("// --prefix {:s}".format(args.prefix_filename))
+        print("")
+        with open(args.prefix_filename, "r") as prefix_file:
             print(prefix_file.read())
     pins.print()
     pins.print_adc(1)
diff --git a/ports/teensy/memzip_files/boot.py b/ports/teensy/memzip_files/boot.py
index 6dd5516a97527..e2279896d5b41 100644
--- a/ports/teensy/memzip_files/boot.py
+++ b/ports/teensy/memzip_files/boot.py
@@ -1,12 +1,15 @@
 import pyb
+
 print("Executing boot.py")
 
+
 def pins():
     for pin_name in dir(pyb.Pin.board):
         pin = pyb.Pin(pin_name)
-        print('{:10s} {:s}'.format(pin_name, str(pin)))
+        print("{:10s} {:s}".format(pin_name, str(pin)))
+
 
 def af():
     for pin_name in dir(pyb.Pin.board):
         pin = pyb.Pin(pin_name)
-        print('{:10s} {:s}'.format(pin_name, str(pin.af_list())))
+        print("{:10s} {:s}".format(pin_name, str(pin.af_list())))
diff --git a/ports/teensy/memzip_files/main.py b/ports/teensy/memzip_files/main.py
index b652377f97de5..a3b3904e89089 100644
--- a/ports/teensy/memzip_files/main.py
+++ b/ports/teensy/memzip_files/main.py
@@ -11,5 +11,3 @@
 led.on()
 pyb.delay(100)
 led.off()
-
-
diff --git a/ports/teensy/mk20dx256_prefix.c b/ports/teensy/mk20dx256_prefix.c
index 58ab07d6ecb6e..4790bb83ca9e0 100644
--- a/ports/teensy/mk20dx256_prefix.c
+++ b/ports/teensy/mk20dx256_prefix.c
@@ -8,26 +8,26 @@
 #include "pin.h"
 
 #define AF(af_idx, af_fn, af_unit, af_type, af_ptr) \
-{ \
-    { &pin_af_type }, \
-    .name = MP_QSTR_AF ## af_idx ## _ ## af_fn ## af_unit, \
-    .idx = (af_idx), \
-    .fn = AF_FN_ ## af_fn, \
-    .unit = (af_unit), \
-    .type = AF_PIN_TYPE_ ## af_fn ## _ ## af_type, \
-    .reg = (af_ptr) \
-}
+    { \
+        { &pin_af_type }, \
+        .name = MP_QSTR_AF##af_idx##_##af_fn##af_unit, \
+        .idx = (af_idx), \
+        .fn = AF_FN_##af_fn, \
+        .unit = (af_unit), \
+        .type = AF_PIN_TYPE_##af_fn##_##af_type, \
+        .reg = (af_ptr) \
+    }
 
 #define PIN(p_port, p_pin, p_num_af, p_af, p_adc_num, p_adc_channel) \
-{ \
-    { &pin_type }, \
-    .name = MP_QSTR_ ## p_port ## p_pin, \
-    .port = PORT_ ## p_port, \
-    .pin = (p_pin), \
-    .num_af = (p_num_af), \
-    .pin_mask = (1 << (p_pin)), \
-    .gpio = GPIO ## p_port, \
-    .af = p_af, \
-    .adc_num = p_adc_num, \
-    .adc_channel = p_adc_channel, \
-}
+    { \
+        { &pin_type }, \
+        .name = MP_QSTR_##p_port##p_pin, \
+        .port = PORT_##p_port, \
+        .pin = (p_pin), \
+        .num_af = (p_num_af), \
+        .pin_mask = (1 << (p_pin)), \
+        .gpio = GPIO##p_port, \
+        .af = p_af, \
+        .adc_num = p_adc_num, \
+        .adc_channel = p_adc_channel, \
+    }
diff --git a/ports/teensy/modpyb.c b/ports/teensy/modpyb.c
index e4c399fc84326..26e3f4c43a0dc 100644
--- a/ports/teensy/modpyb.c
+++ b/ports/teensy/modpyb.c
@@ -44,9 +44,6 @@
 #include "extint.h"
 #include "usrsw.h"
 #include "rng.h"
-//#include "rtc.h"
-//#include "i2c.h"
-//#include "spi.h"
 #include "uart.h"
 #include "adc.h"
 #include "storage.h"
@@ -74,7 +71,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_bootloader_obj, pyb_bootloader);
 STATIC mp_obj_t pyb_info(uint n_args, const mp_obj_t *args) {
     // get and print unique id; 96 bits
     {
-        byte *id = (byte*)0x40048058;
+        byte *id = (byte *)0x40048058;
         printf("ID=%02x%02x%02x%02x:%02x%02x%02x%02x:%02x%02x%02x%02x\n", id[0], id[1], id[2], id[3], id[4], id[5], id[6], id[7], id[8], id[9], id[10], id[11]);
     }
 
@@ -125,7 +122,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_info_obj, 0, 1, pyb_info);
 /// \function unique_id()
 /// Returns a string of 12 bytes (96 bits), which is the unique ID for the MCU.
 STATIC mp_obj_t pyb_unique_id(void) {
-    byte *id = (byte*)0x40048058;
+    byte *id = (byte *)0x40048058;
     return mp_obj_new_bytes(id, 12);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_unique_id_obj, pyb_unique_id);
@@ -135,9 +132,9 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_unique_id_obj, pyb_unique_id);
 // TODO should also be able to set frequency via this function
 STATIC mp_obj_t pyb_freq(void) {
     mp_obj_t tuple[3] = {
-       mp_obj_new_int(F_CPU),
-       mp_obj_new_int(F_BUS),
-       mp_obj_new_int(F_MEM),
+        mp_obj_new_int(F_CPU),
+        mp_obj_new_int(F_BUS),
+        mp_obj_new_int(F_MEM),
     };
     return mp_obj_new_tuple(3, tuple);
 }
@@ -247,7 +244,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_standby_obj, pyb_standby);
 
 /// \function have_cdc()
 /// Return True if USB is connected as a serial device, False otherwise.
-STATIC mp_obj_t pyb_have_cdc(void ) {
+STATIC mp_obj_t pyb_have_cdc(void) {
     return mp_obj_new_bool(usb_vcp_is_connected());
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_have_cdc_obj, pyb_have_cdc);
@@ -256,9 +253,9 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_have_cdc_obj, pyb_have_cdc);
 /// Takes a 4-tuple (or list) and sends it to the USB host (the PC) to
 /// signal a HID mouse-motion event.
 STATIC mp_obj_t pyb_hid_send_report(mp_obj_t arg) {
-#if 1
+    #if 1
     printf("hid_send_report not currently implemented\n");
-#else
+    #else
     mp_obj_t *items;
     mp_obj_get_array_fixed_n(arg, 4, &items);
     uint8_t data[4];
@@ -267,7 +264,7 @@ STATIC mp_obj_t pyb_hid_send_report(mp_obj_t arg) {
     data[2] = mp_obj_get_int(items[2]);
     data[3] = mp_obj_get_int(items[3]);
     usb_hid_send_report(data);
-#endif
+    #endif
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_hid_send_report_obj, pyb_hid_send_report);
@@ -283,7 +280,9 @@ STATIC const mp_rom_map_elem_t pyb_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_info), MP_ROM_PTR(&pyb_info_obj) },
     { MP_ROM_QSTR(MP_QSTR_unique_id), MP_ROM_PTR(&pyb_unique_id_obj) },
     { MP_ROM_QSTR(MP_QSTR_freq), MP_ROM_PTR(&pyb_freq_obj) },
+    #if MICROPY_REPL_INFO
     { MP_ROM_QSTR(MP_QSTR_repl_info), MP_ROM_PTR(&pyb_set_repl_info_obj) },
+    #endif
 
     { MP_ROM_QSTR(MP_QSTR_wfi), MP_ROM_PTR(&pyb_wfi_obj) },
     { MP_ROM_QSTR(MP_QSTR_disable_irq), MP_ROM_PTR(&pyb_disable_irq_obj) },
@@ -308,30 +307,30 @@ STATIC const mp_rom_map_elem_t pyb_module_globals_table[] = {
 
     { MP_ROM_QSTR(MP_QSTR_Timer), MP_ROM_PTR(&pyb_timer_type) },
 
-//#if MICROPY_HW_ENABLE_RNG
+// #if MICROPY_HW_ENABLE_RNG
 //    { MP_ROM_QSTR(MP_QSTR_rng), MP_ROM_PTR(&pyb_rng_get_obj) },
-//#endif
+// #endif
 
-//#if MICROPY_HW_ENABLE_RTC
+// #if MICROPY_HW_ENABLE_RTC
 //    { MP_ROM_QSTR(MP_QSTR_RTC), MP_ROM_PTR(&pyb_rtc_type) },
-//#endif
+// #endif
 
     { MP_ROM_QSTR(MP_QSTR_Pin), MP_ROM_PTR(&pin_type) },
 //    { MP_ROM_QSTR(MP_QSTR_ExtInt), MP_ROM_PTR(&extint_type) },
 
-#if MICROPY_HW_ENABLE_SERVO
+    #if MICROPY_HW_ENABLE_SERVO
     { MP_ROM_QSTR(MP_QSTR_pwm), MP_ROM_PTR(&pyb_pwm_set_obj) },
     { MP_ROM_QSTR(MP_QSTR_servo), MP_ROM_PTR(&pyb_servo_set_obj) },
     { MP_ROM_QSTR(MP_QSTR_Servo), MP_ROM_PTR(&pyb_servo_type) },
-#endif
+    #endif
 
-#if MICROPY_HW_HAS_SWITCH
+    #if MICROPY_HW_HAS_SWITCH
     { MP_ROM_QSTR(MP_QSTR_Switch), MP_ROM_PTR(&pyb_switch_type) },
-#endif
+    #endif
 
-//#if MICROPY_HW_HAS_SDCARD
+// #if MICROPY_HW_HAS_SDCARD
 //    { MP_ROM_QSTR(MP_QSTR_SD), MP_ROM_PTR(&pyb_sdcard_obj) },
-//#endif
+// #endif
 
     { MP_ROM_QSTR(MP_QSTR_LED), MP_ROM_PTR(&pyb_led_type) },
 //    { MP_ROM_QSTR(MP_QSTR_I2C), MP_ROM_PTR(&pyb_i2c_type) },
@@ -341,18 +340,18 @@ STATIC const mp_rom_map_elem_t pyb_module_globals_table[] = {
 //    { MP_ROM_QSTR(MP_QSTR_ADC), MP_ROM_PTR(&pyb_adc_type) },
 //    { MP_ROM_QSTR(MP_QSTR_ADCAll), MP_ROM_PTR(&pyb_adc_all_type) },
 
-//#if MICROPY_HW_ENABLE_DAC
+// #if MICROPY_HW_ENABLE_DAC
 //    { MP_ROM_QSTR(MP_QSTR_DAC), MP_ROM_PTR(&pyb_dac_type) },
-//#endif
+// #endif
 
-//#if MICROPY_HW_HAS_MMA7660
+// #if MICROPY_HW_HAS_MMA7660
 //    { MP_ROM_QSTR(MP_QSTR_Accel), MP_ROM_PTR(&pyb_accel_type) },
-//#endif
+// #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(pyb_module_globals, pyb_module_globals_table);
 
 const mp_obj_module_t pyb_module = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&pyb_module_globals,
+    .globals = (mp_obj_dict_t *)&pyb_module_globals,
 };
diff --git a/ports/teensy/mpconfigport.h b/ports/teensy/mpconfigport.h
index b45b5ad4e3c5a..24269c3b981e6 100644
--- a/ports/teensy/mpconfigport.h
+++ b/ports/teensy/mpconfigport.h
@@ -9,6 +9,7 @@
 #define MICROPY_ENABLE_FINALISER    (1)
 #define MICROPY_STACK_CHECK         (1)
 #define MICROPY_HELPER_REPL         (1)
+#define MICROPY_REPL_INFO           (1)
 #define MICROPY_ENABLE_SOURCE_LINE  (1)
 #define MICROPY_LONGINT_IMPL        (MICROPY_LONGINT_IMPL_MPZ)
 #define MICROPY_FLOAT_IMPL          (MICROPY_FLOAT_IMPL_FLOAT)
@@ -72,24 +73,24 @@ typedef long mp_off_t;
 // to know the machine-specific values, see irq.h.
 
 #ifndef __disable_irq
-#define __disable_irq() __asm__ volatile("CPSID i");
+#define __disable_irq() __asm__ volatile ("CPSID i");
 #endif
 
-__attribute__(( always_inline )) static inline uint32_t __get_PRIMASK(void) {
+__attribute__((always_inline)) static inline uint32_t __get_PRIMASK(void) {
     uint32_t result;
     __asm volatile ("MRS %0, primask" : "=r" (result));
-    return(result);
+    return result;
 }
 
-__attribute__(( always_inline )) static inline void __set_PRIMASK(uint32_t priMask) {
+__attribute__((always_inline)) static inline void __set_PRIMASK(uint32_t priMask) {
     __asm volatile ("MSR primask, %0" : : "r" (priMask) : "memory");
 }
 
-__attribute__(( always_inline )) static inline void enable_irq(mp_uint_t state) {
+__attribute__((always_inline)) static inline void enable_irq(mp_uint_t state) {
     __set_PRIMASK(state);
 }
 
-__attribute__(( always_inline )) static inline mp_uint_t disable_irq(void) {
+__attribute__((always_inline)) static inline mp_uint_t disable_irq(void) {
     mp_uint_t state = __get_PRIMASK();
     __disable_irq();
     return state;
diff --git a/ports/teensy/pin_defs_teensy.c b/ports/teensy/pin_defs_teensy.c
index e7af1e9697b1f..9041a379e1d28 100644
--- a/ports/teensy/pin_defs_teensy.c
+++ b/ports/teensy/pin_defs_teensy.c
@@ -43,7 +43,7 @@ uint32_t pin_get_pull(const pin_obj_t *pin) {
         // Analog only pin
         return GPIO_NOPULL;
     }
-    volatile uint32_t *port_pcr = GPIO_PIN_TO_PORT_PCR(pin->gpio, pin->pin); 
+    volatile uint32_t *port_pcr = GPIO_PIN_TO_PORT_PCR(pin->gpio, pin->pin);
 
     uint32_t pcr = *port_pcr;
     uint32_t af = (pcr & PORT_PCR_MUX_MASK) >> 8;
diff --git a/ports/teensy/pin_defs_teensy.h b/ports/teensy/pin_defs_teensy.h
index d3a700be21c04..fa248483e9016 100644
--- a/ports/teensy/pin_defs_teensy.h
+++ b/ports/teensy/pin_defs_teensy.h
@@ -1,10 +1,10 @@
 enum {
-  PORT_A,
-  PORT_B,
-  PORT_C,
-  PORT_D,
-  PORT_E,
-  PORT_Z,
+    PORT_A,
+    PORT_B,
+    PORT_C,
+    PORT_D,
+    PORT_E,
+    PORT_Z,
 };
 
 enum {
diff --git a/ports/teensy/qstrdefsport.h b/ports/teensy/qstrdefsport.h
index 3ba897069bf73..00d3e2ae3c555 100644
--- a/ports/teensy/qstrdefsport.h
+++ b/ports/teensy/qstrdefsport.h
@@ -1 +1,2 @@
 // qstrs specific to this port
+// *FORMAT-OFF*
diff --git a/ports/teensy/reg.c b/ports/teensy/reg.c
index 4f1fd52c2934c..97a9e6082cc2b 100644
--- a/ports/teensy/reg.c
+++ b/ports/teensy/reg.c
@@ -11,7 +11,7 @@ mp_obj_t reg_cmd(void *base, reg_t *reg, mp_uint_t num_regs, uint n_args, const
 
         for (mp_uint_t reg_idx = 0; reg_idx < num_regs; reg_idx++, reg++) {
             printf("  %-8s @0x%08x = 0x%08lx\n",
-                   reg->name, (mp_uint_t)base + reg->offset, *(uint32_t *)((uint8_t *)base + reg->offset));
+                reg->name, (mp_uint_t)base + reg->offset, *(uint32_t *)((uint8_t *)base + reg->offset));
         }
         return mp_const_none;
     }
diff --git a/ports/teensy/reg.h b/ports/teensy/reg.h
index 0da6378ee7add..8202b537b19e9 100644
--- a/ports/teensy/reg.h
+++ b/ports/teensy/reg.h
@@ -3,7 +3,7 @@
 
 typedef struct {
     const char *name;
-    mp_uint_t   offset;
+    mp_uint_t offset;
 } reg_t;
 
 #define REG_ENTRY(st, name) { #name, offsetof(st, name) }
diff --git a/ports/teensy/servo.c b/ports/teensy/servo.c
index 262daaeb66fa6..8c81255f2e2f0 100644
--- a/ports/teensy/servo.c
+++ b/ports/teensy/servo.c
@@ -17,7 +17,7 @@
 #define REFRESH_INTERVAL    20000     // minumim time to refresh servos in microseconds
 
 #define PDB_CONFIG (PDB_SC_TRGSEL(15) | PDB_SC_PDBEN | PDB_SC_PDBIE \
-	| PDB_SC_CONT | PDB_SC_PRESCALER(2) | PDB_SC_MULT(0))
+    | PDB_SC_CONT | PDB_SC_PRESCALER(2) | PDB_SC_MULT(0))
 #define PDB_PRESCALE 4
 #define usToTicks(us)    ((us) * (F_BUS / 1000) / PDB_PRESCALE / 1000)
 #define ticksToUs(ticks) ((ticks) * PDB_PRESCALE * 1000 / (F_BUS / 1000))
@@ -36,14 +36,12 @@ typedef struct _pyb_servo_obj_t {
 
 #define clamp(v, min_val, max_val) ((v) < (min_val) ? (min_val) : (v) > (max_val) ? (max_val) : (v))
 
-static float map_uint_to_float(uint x, uint in_min, uint in_max, float out_min, float out_max)
-{
-	return (float)(x - in_min) * (out_max - out_min) / (float)(in_max - in_min) + (float)out_min;
+static float map_uint_to_float(uint x, uint in_min, uint in_max, float out_min, float out_max) {
+    return (float)(x - in_min) * (out_max - out_min) / (float)(in_max - in_min) + (float)out_min;
 }
 
-static uint map_float_to_uint(float x, float in_min, float in_max, uint out_min, uint out_max)
-{
-	return (int)((x - in_min) * (float)(out_max - out_min) / (in_max - in_min) + (float)out_min);
+static uint map_float_to_uint(float x, float in_min, float in_max, uint out_min, uint out_max) {
+    return (int)((x - in_min) * (float)(out_max - out_min) / (in_max - in_min) + (float)out_min);
 }
 
 static mp_obj_t servo_obj_attach(mp_obj_t self_in, mp_obj_t pin_obj) {
@@ -70,11 +68,11 @@ static mp_obj_t servo_obj_attach(mp_obj_t self_in, mp_obj_t pin_obj) {
     return mp_const_none;
 
 pin_error:
-    nlr_raise(mp_obj_new_exception_msg_varg(MP_QSTR_ValueError, "pin %d does not exist", pin));
+    mp_raise_msg_varg(MP_QSTR_ValueError, MP_ERROR_TEXT("pin %d does not exist"), pin);
 }
 
 static mp_obj_t servo_obj_detach(mp_obj_t self_in) {
-    //pyb_servo_obj_t *self = self_in;
+    // pyb_servo_obj_t *self = self_in;
     return mp_const_none;
 }
 
@@ -110,9 +108,9 @@ static mp_obj_t servo_obj_angle(int n_args, const mp_obj_t *args) {
     if (n_args == 1) {
         // get
         float angle = map_uint_to_float(servo_ticks[self->servo_id],
-                                        usToTicks(self->min_usecs),
-                                        usToTicks(self->max_usecs),
-                                        0.0, 180.0);
+            usToTicks(self->min_usecs),
+            usToTicks(self->max_usecs),
+            0.0, 180.0);
         return mp_obj_new_float(angle);
     }
     // Set
@@ -124,9 +122,9 @@ static mp_obj_t servo_obj_angle(int n_args, const mp_obj_t *args) {
         angle = 180.0F;
     }
     servo_ticks[self->servo_id] = map_float_to_uint(angle,
-                                                    0.0F, 180.0F,
-                                                    usToTicks(self->min_usecs),
-                                                    usToTicks(self->max_usecs));
+        0.0F, 180.0F,
+        usToTicks(self->min_usecs),
+        usToTicks(self->max_usecs));
     return mp_const_none;
 }
 
@@ -207,7 +205,7 @@ mp_obj_t pyb_Servo(void) {
     /* Find an unallocated servo id */
 
     self->servo_id = 0;
-    for (mask=1; mask < (1<<MAX_SERVOS); mask <<= 1) {
+    for (mask = 1; mask < (1 << MAX_SERVOS); mask <<= 1) {
         if (!(servo_allocated_mask & mask)) {
             servo_allocated_mask |= mask;
             servo_active_mask &= ~mask;
@@ -217,49 +215,51 @@ mp_obj_t pyb_Servo(void) {
         self->servo_id++;
     }
     m_del_obj(pyb_servo_obj_t, self);
-    mp_raise_ValueError("No available servo ids");
+    mp_raise_ValueError(MP_ERROR_TEXT("No available servo ids"));
     return mp_const_none;
 }
 
-void pdb_isr(void)
-{
-	static int8_t channel = 0, channel_high = MAX_SERVOS;
-	static uint32_t tick_accum = 0;
-	uint32_t ticks;
-	int32_t wait_ticks;
+void pdb_isr(void) {
+    static int8_t channel = 0, channel_high = MAX_SERVOS;
+    static uint32_t tick_accum = 0;
+    uint32_t ticks;
+    int32_t wait_ticks;
 
-	// first, if any channel was left high from the previous
-	// run, now is the time to shut it off
-	if (servo_active_mask & (1 << channel_high)) {
-		digitalWrite(servo_pin[channel_high], LOW);
-		channel_high = MAX_SERVOS;
-	}
-	// search for the next channel to turn on
-	while (channel < MAX_SERVOS) {
-		if (servo_active_mask & (1 << channel)) {
-			digitalWrite(servo_pin[channel], HIGH);
-			channel_high = channel;
-			ticks = servo_ticks[channel];
-			tick_accum += ticks;
-			PDB0_IDLY += ticks;
-			PDB0_SC = PDB_CONFIG | PDB_SC_LDOK;
-			channel++;
-			return;
-		}
-		channel++;
-	}
-	// when all channels have output, wait for the
-	// minimum refresh interval
-	wait_ticks = usToTicks(REFRESH_INTERVAL) - tick_accum;
-	if (wait_ticks < usToTicks(100)) wait_ticks = usToTicks(100);
-	else if (wait_ticks > 60000) wait_ticks = 60000;
-	tick_accum += wait_ticks;
-	PDB0_IDLY += wait_ticks;
-	PDB0_SC = PDB_CONFIG | PDB_SC_LDOK;
-	// if this wait is enough to satisfy the refresh
-	// interval, next time begin again at channel zero
-	if (tick_accum >= usToTicks(REFRESH_INTERVAL)) {
-		tick_accum = 0;
-		channel = 0;
-	}
+    // first, if any channel was left high from the previous
+    // run, now is the time to shut it off
+    if (servo_active_mask & (1 << channel_high)) {
+        digitalWrite(servo_pin[channel_high], LOW);
+        channel_high = MAX_SERVOS;
+    }
+    // search for the next channel to turn on
+    while (channel < MAX_SERVOS) {
+        if (servo_active_mask & (1 << channel)) {
+            digitalWrite(servo_pin[channel], HIGH);
+            channel_high = channel;
+            ticks = servo_ticks[channel];
+            tick_accum += ticks;
+            PDB0_IDLY += ticks;
+            PDB0_SC = PDB_CONFIG | PDB_SC_LDOK;
+            channel++;
+            return;
+        }
+        channel++;
+    }
+    // when all channels have output, wait for the
+    // minimum refresh interval
+    wait_ticks = usToTicks(REFRESH_INTERVAL) - tick_accum;
+    if (wait_ticks < usToTicks(100)) {
+        wait_ticks = usToTicks(100);
+    } else if (wait_ticks > 60000) {
+        wait_ticks = 60000;
+    }
+    tick_accum += wait_ticks;
+    PDB0_IDLY += wait_ticks;
+    PDB0_SC = PDB_CONFIG | PDB_SC_LDOK;
+    // if this wait is enough to satisfy the refresh
+    // interval, next time begin again at channel zero
+    if (tick_accum >= usToTicks(REFRESH_INTERVAL)) {
+        tick_accum = 0;
+        channel = 0;
+    }
 }
diff --git a/ports/teensy/teensy_hal.c b/ports/teensy/teensy_hal.c
index 7ce82f1d2a778..342e7c6501dd8 100644
--- a/ports/teensy/teensy_hal.c
+++ b/ports/teensy/teensy_hal.c
@@ -2,23 +2,37 @@
 #include <string.h>
 
 #include "py/runtime.h"
+#include "py/stream.h"
 #include "py/mphal.h"
 #include "usb.h"
 #include "uart.h"
 #include "Arduino.h"
 
 mp_uint_t mp_hal_ticks_ms(void) {
-  return millis();
+    return millis();
 }
 
 void mp_hal_delay_ms(mp_uint_t ms) {
-  delay(ms);
+    delay(ms);
 }
 
 void mp_hal_set_interrupt_char(int c) {
-  // The teensy 3.1 usb stack doesn't currently have the notion of generating
-  // an exception when a certain character is received. That just means that
-  // you can't press Control-C and get your python script to stop.
+    // The teensy 3.1 usb stack doesn't currently have the notion of generating
+    // an exception when a certain character is received. That just means that
+    // you can't press Control-C and get your python script to stop.
+}
+
+uintptr_t mp_hal_stdio_poll(uintptr_t poll_flags) {
+    uintptr_t ret = 0;
+    if (poll_flags & MP_STREAM_POLL_RD) {
+        if (usb_vcp_rx_num()) {
+            ret |= MP_STREAM_POLL_RD;
+        }
+        if (MP_STATE_PORT(pyb_stdio_uart) != NULL && uart_rx_any(MP_STATE_PORT(pyb_stdio_uart))) {
+            ret |= MP_STREAM_POLL_RD;
+        }
+    }
+    return ret;
 }
 
 int mp_hal_stdin_rx_chr(void) {
diff --git a/ports/teensy/teensy_hal.h b/ports/teensy/teensy_hal.h
index aef38a2ad9ecb..515d2d0efb4ac 100644
--- a/ports/teensy/teensy_hal.h
+++ b/ports/teensy/teensy_hal.h
@@ -3,7 +3,7 @@
 
 #ifdef  USE_FULL_ASSERT
   #define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
-  void assert_failed(uint8_t* file, uint32_t line);
+void assert_failed(uint8_t *file, uint32_t line);
 #else
   #define assert_param(expr) ((void)0)
 #endif /* USE_FULL_ASSERT */
@@ -41,12 +41,12 @@ typedef struct {
 } SPI_TypeDef;
 
 typedef struct {
-    volatile    uint32_t    PDOR;   // Output register
-    volatile    uint32_t    PSOR;   // Set output register
-    volatile    uint32_t    PCOR;   // Clear output register
-    volatile    uint32_t    PTOR;   // Toggle output register
-    volatile    uint32_t    PDIR;   // Data Input register
-    volatile    uint32_t    PDDR;   // Data Direction register
+    volatile uint32_t PDOR;         // Output register
+    volatile uint32_t PSOR;         // Set output register
+    volatile uint32_t PCOR;         // Clear output register
+    volatile uint32_t PTOR;         // Toggle output register
+    volatile uint32_t PDIR;         // Data Input register
+    volatile uint32_t PDDR;         // Data Direction register
 } GPIO_TypeDef;
 
 #define GPIO_OUTPUT_TYPE    ((uint32_t)0x00000010)  // Indicates OD
@@ -60,19 +60,19 @@ typedef struct {
 #define GPIO_MODE_IT_RISING ((uint32_t)1)
 #define GPIO_MODE_IT_FALLING ((uint32_t)2)
 
-#define IS_GPIO_MODE(MODE) (((MODE) == GPIO_MODE_INPUT)              ||\
-                            ((MODE) == GPIO_MODE_OUTPUT_PP)          ||\
-                            ((MODE) == GPIO_MODE_OUTPUT_OD)          ||\
-                            ((MODE) == GPIO_MODE_AF_PP)              ||\
-                            ((MODE) == GPIO_MODE_AF_OD)              ||\
-                            ((MODE) == GPIO_MODE_ANALOG))
+#define IS_GPIO_MODE(MODE) (((MODE) == GPIO_MODE_INPUT) || \
+    ((MODE) == GPIO_MODE_OUTPUT_PP) || \
+    ((MODE) == GPIO_MODE_OUTPUT_OD) || \
+    ((MODE) == GPIO_MODE_AF_PP) || \
+    ((MODE) == GPIO_MODE_AF_OD) || \
+    ((MODE) == GPIO_MODE_ANALOG))
 
 #define GPIO_NOPULL         ((uint32_t)0)
 #define GPIO_PULLUP         ((uint32_t)1)
 #define GPIO_PULLDOWN       ((uint32_t)2)
 
 #define IS_GPIO_PULL(PULL) (((PULL) == GPIO_NOPULL) || ((PULL) == GPIO_PULLUP) || \
-                            ((PULL) == GPIO_PULLDOWN))
+    ((PULL) == GPIO_PULLDOWN))
 
 #define GPIO_SPEED_FREQ_LOW       ((uint32_t)0)
 #define GPIO_SPEED_FREQ_MEDIUM    ((uint32_t)1)
@@ -82,11 +82,11 @@ typedef struct {
 #define IS_GPIO_AF(af)      ((af) >= 0 && (af) <= 7)
 
 typedef struct {
-    uint32_t    Pin;
-    uint32_t    Mode;
-    uint32_t    Pull;
-    uint32_t    Speed;
-    uint32_t    Alternate;
+    uint32_t Pin;
+    uint32_t Mode;
+    uint32_t Pull;
+    uint32_t Speed;
+    uint32_t Alternate;
 } GPIO_InitTypeDef;
 
 #define GPIO_PORT_TO_PORT_NUM(GPIOx) \
@@ -110,8 +110,8 @@ typedef struct {
 #define GPIO_AF6_I2C1   6
 #define GPIO_AF7_FTM1   7
 
-__attribute__(( always_inline )) static inline void __WFI(void) {
-  __asm volatile ("wfi");
+__attribute__((always_inline)) static inline void __WFI(void) {
+    __asm volatile ("wfi");
 }
 
 void mp_hal_set_interrupt_char(int c);
@@ -121,8 +121,8 @@ void mp_hal_gpio_clock_enable(GPIO_TypeDef *gpio);
 void HAL_GPIO_Init(GPIO_TypeDef *GPIOx, GPIO_InitTypeDef *init);
 
 struct _pin_obj_t;
-#define mp_hal_pin_obj_t const struct _pin_obj_t*
+#define mp_hal_pin_obj_t const struct _pin_obj_t *
 #define mp_hal_pin_high(p) (((p)->gpio->PSOR) = (p)->pin_mask)
 #define mp_hal_pin_low(p)  (((p)->gpio->PCOR) = (p)->pin_mask)
 #define mp_hal_pin_read(p) (((p)->gpio->PDIR >> (p)->pin) & 1)
-#define mp_hal_pin_write(p, v)  do { if (v) { mp_hal_pin_high(p); } else { mp_hal_pin_low(p); } } while (0)
+#define mp_hal_pin_write(p, v)  ((v) ? mp_hal_pin_high(p) : mp_hal_pin_low(p))
diff --git a/ports/teensy/timer.c b/ports/teensy/timer.c
index c958f5349f86f..68dc965eb8bc8 100644
--- a/ports/teensy/timer.c
+++ b/ports/teensy/timer.c
@@ -49,8 +49,8 @@ typedef enum {
 } pyb_channel_mode;
 
 STATIC const struct {
-    qstr        name;
-    uint32_t    oc_mode;
+    qstr name;
+    uint32_t oc_mode;
 } channel_mode_info[] = {
     { MP_QSTR_PWM,                FTM_OCMODE_PWM1 },
     { MP_QSTR_PWM_INVERTED,       FTM_OCMODE_PWM2 },
@@ -114,7 +114,7 @@ mp_uint_t get_prescaler_shift(mp_int_t prescaler) {
             return prescaler_shift;
         }
     }
-    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "prescaler must be a power of 2 between 1 and 128, not %d", prescaler));
+    mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("prescaler must be a power of 2 between 1 and 128, not %d"), prescaler);
 }
 
 /******************************************************************************/
@@ -195,8 +195,8 @@ STATIC void pyb_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_
         mp_printf(print, "Timer(%u, prescaler=%u, period=%u, mode=%s)",
             self->tim_id,
             1 << (self->ftm.Instance->SC & 7),
-            self->ftm.Instance->MOD & 0xffff,
-            self->ftm.Init.CounterMode == FTM_COUNTERMODE_UP ? "UP" : "CENTER");
+                self->ftm.Instance->MOD & 0xffff,
+                self->ftm.Init.CounterMode == FTM_COUNTERMODE_UP ? "UP" : "CENTER");
     }
 }
 
@@ -254,7 +254,7 @@ STATIC mp_obj_t pyb_timer_init_helper(pyb_timer_obj_t *self, uint n_args, const
         // set prescaler and period from frequency
 
         if (vals[0].u_int == 0) {
-            mp_raise_ValueError("can't have 0 frequency");
+            mp_raise_ValueError(MP_ERROR_TEXT("can't have 0 frequency"));
         }
 
         uint32_t period = MAX(1, F_BUS / vals[0].u_int);
@@ -273,15 +273,15 @@ STATIC mp_obj_t pyb_timer_init_helper(pyb_timer_obj_t *self, uint n_args, const
         init->PrescalerShift = get_prescaler_shift(vals[1].u_int);
         init->Period = vals[2].u_int;
         if (!IS_FTM_PERIOD(init->Period)) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "period must be between 0 and 65535, not %d", init->Period));
+            mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("period must be between 0 and 65535, not %d"), init->Period);
         }
     } else {
-        mp_raise_TypeError("must specify either freq, or prescaler and period");
+        mp_raise_TypeError(MP_ERROR_TEXT("must specify either freq, or prescaler and period"));
     }
 
     init->CounterMode = vals[3].u_int;
     if (!IS_FTM_COUNTERMODE(init->CounterMode)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "invalid counter mode: %d", init->CounterMode));
+        mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("invalid counter mode: %d"), init->CounterMode);
     }
 
     // Currently core/mk20dx128.c sets SIM_SCGC6_FTM0, SIM_SCGC6_FTM1, SIM_SCGC3_FTM2
@@ -319,10 +319,20 @@ STATIC mp_obj_t pyb_timer_make_new(const mp_obj_type_t *type, size_t n_args, siz
     tim->tim_id = mp_obj_get_int(args[0]);
 
     switch (tim->tim_id) {
-        case 0: tim->ftm.Instance = FTM0; tim->irqn = IRQ_FTM0; break;
-        case 1: tim->ftm.Instance = FTM1; tim->irqn = IRQ_FTM1; break;
-        case 2: tim->ftm.Instance = FTM2; tim->irqn = IRQ_FTM2; break;
-        default: nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Timer %d does not exist", tim->tim_id));
+        case 0:
+            tim->ftm.Instance = FTM0;
+            tim->irqn = IRQ_FTM0;
+            break;
+        case 1:
+            tim->ftm.Instance = FTM1;
+            tim->irqn = IRQ_FTM1;
+            break;
+        case 2:
+            tim->ftm.Instance = FTM2;
+            tim->irqn = IRQ_FTM2;
+            break;
+        default:
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Timer %d does not exist"), tim->tim_id);
     }
 
     if (n_args > 1 || n_kw > 0) {
@@ -444,7 +454,7 @@ STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *args, mp_map_t
     mp_int_t channel = mp_obj_get_int(args[1]);
 
     if (channel < 0 || channel > 7) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Invalid channel (%d)", channel));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Invalid channel (%d)"), channel);
     }
 
     pyb_timer_channel_obj_t *chan = self->channel;
@@ -497,12 +507,12 @@ STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *args, mp_map_t
     mp_obj_t pin_obj = vals[1].u_obj;
     if (pin_obj != mp_const_none) {
         if (!mp_obj_is_type(pin_obj, &pin_type)) {
-            mp_raise_ValueError("pin argument needs to be be a Pin type");
+            mp_raise_ValueError(MP_ERROR_TEXT("pin argument needs to be be a Pin type"));
         }
         const pin_obj_t *pin = pin_obj;
         const pin_af_obj_t *af = pin_find_af(pin, AF_FN_FTM, self->tim_id);
         if (af == NULL) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "pin %s doesn't have an af for TIM%d", qstr_str(pin->name), self->tim_id));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("pin %s doesn't have an af for TIM%d"), qstr_str(pin->name), self->tim_id);
         }
         // pin.init(mode=AF_PP, af=idx)
         const mp_obj_t args[6] = {
@@ -551,15 +561,15 @@ STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *args, mp_map_t
         case CHANNEL_MODE_OC_INACTIVE:
         case CHANNEL_MODE_OC_TOGGLE: {
             FTM_OC_InitTypeDef oc_config;
-            oc_config.OCMode       = channel_mode_info[chan->mode].oc_mode;
-            oc_config.Pulse        = vals[4].u_int;
-            oc_config.OCPolarity   = vals[5].u_int;
+            oc_config.OCMode = channel_mode_info[chan->mode].oc_mode;
+            oc_config.Pulse = vals[4].u_int;
+            oc_config.OCPolarity = vals[5].u_int;
             if (oc_config.OCPolarity == 0xffffffff) {
                 oc_config.OCPolarity = FTM_OCPOLARITY_HIGH;
             }
 
             if (!IS_FTM_OC_POLARITY(oc_config.OCPolarity)) {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Invalid polarity (%d)", oc_config.OCPolarity));
+                mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Invalid polarity (%d)"), oc_config.OCPolarity);
             }
             HAL_FTM_OC_ConfigChannel(&self->ftm, &oc_config, channel);
             if (chan->callback == mp_const_none) {
@@ -573,13 +583,13 @@ STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *args, mp_map_t
         case CHANNEL_MODE_IC: {
             FTM_IC_InitTypeDef ic_config;
 
-            ic_config.ICPolarity  = vals[5].u_int;
+            ic_config.ICPolarity = vals[5].u_int;
             if (ic_config.ICPolarity == 0xffffffff) {
                 ic_config.ICPolarity = FTM_ICPOLARITY_RISING;
             }
 
             if (!IS_FTM_IC_POLARITY(ic_config.ICPolarity)) {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Invalid polarity (%d)", ic_config.ICPolarity));
+                mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Invalid polarity (%d)"), ic_config.ICPolarity);
             }
             HAL_FTM_IC_ConfigChannel(&self->ftm, &ic_config, chan->channel);
             if (chan->callback == mp_const_none) {
@@ -591,7 +601,7 @@ STATIC mp_obj_t pyb_timer_channel(size_t n_args, const mp_obj_t *args, mp_map_t
         }
 
         default:
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Invalid mode (%d)", chan->mode));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Invalid mode (%d)"), chan->mode);
     }
 
     return chan;
@@ -667,7 +677,7 @@ STATIC mp_obj_t pyb_timer_callback(mp_obj_t self_in, mp_obj_t callback) {
         // start timer, so that it interrupts on overflow
         HAL_FTM_Base_Start_IT(&self->ftm);
     } else {
-        mp_raise_ValueError("callback must be None or a callable object");
+        mp_raise_ValueError(MP_ERROR_TEXT("callback must be None or a callable object"));
     }
     return mp_const_none;
 }
@@ -716,9 +726,9 @@ STATIC const mp_rom_map_elem_t pyb_timer_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_prescaler), MP_ROM_PTR(&pyb_timer_prescaler_obj) },
     { MP_ROM_QSTR(MP_QSTR_period), MP_ROM_PTR(&pyb_timer_period_obj) },
     { MP_ROM_QSTR(MP_QSTR_callback), MP_ROM_PTR(&pyb_timer_callback_obj) },
-#if MICROPY_TIMER_REG
+    #if MICROPY_TIMER_REG
     { MP_ROM_QSTR(MP_QSTR_reg), MP_ROM_PTR(&pyb_timer_reg_obj) },
-#endif
+    #endif
     { MP_ROM_QSTR(MP_QSTR_UP),              MP_ROM_INT(FTM_COUNTERMODE_UP) },
     { MP_ROM_QSTR(MP_QSTR_CENTER),          MP_ROM_INT(FTM_COUNTERMODE_CENTER) },
     { MP_ROM_QSTR(MP_QSTR_PWM),             MP_ROM_INT(CHANNEL_MODE_PWM_NORMAL) },
@@ -754,9 +764,9 @@ STATIC void pyb_timer_channel_print(const mp_print_t *print, mp_obj_t self_in, m
     pyb_timer_channel_obj_t *self = self_in;
 
     mp_printf(print, "TimerChannel(timer=%u, channel=%u, mode=%s)",
-          self->timer->tim_id,
-          self->channel,
-          qstr_str(channel_mode_info[self->mode].name));
+        self->timer->tim_id,
+        self->channel,
+        qstr_str(channel_mode_info[self->mode].name));
 }
 
 /// \method capture([value])
@@ -773,7 +783,7 @@ STATIC void pyb_timer_channel_print(const mp_print_t *print, mp_obj_t self_in, m
 /// Get or set the pulse width value associated with a channel.
 /// capture, compare, and pulse_width are all aliases for the same function.
 /// pulse_width is the logical name to use when the channel is in PWM mode.
-/// 
+///
 /// In edge aligned mode, a pulse_width of `period + 1` corresponds to a duty cycle of 100%
 /// In center aligned mode, a pulse width of `period` corresponds to a duty cycle of 100%
 STATIC mp_obj_t pyb_timer_channel_capture_compare(size_t n_args, const mp_obj_t *args) {
@@ -845,7 +855,7 @@ STATIC mp_obj_t pyb_timer_channel_callback(mp_obj_t self_in, mp_obj_t callback)
                 break;
         }
     } else {
-        mp_raise_ValueError("callback must be None or a callable object");
+        mp_raise_ValueError(MP_ERROR_TEXT("callback must be None or a callable object"));
     }
     return mp_const_none;
 }
@@ -860,8 +870,8 @@ reg_t timer_channel_reg[] = {
 mp_obj_t pyb_timer_channel_reg(uint n_args, const mp_obj_t *args) {
     pyb_timer_channel_obj_t *self = args[0];
     return reg_cmd(&self->timer->ftm.Instance->channel[self->channel],
-                   timer_channel_reg, MP_ARRAY_SIZE(timer_channel_reg),
-                   n_args - 1, args + 1);
+        timer_channel_reg, MP_ARRAY_SIZE(timer_channel_reg),
+        n_args - 1, args + 1);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_timer_channel_reg_obj, 1, 3, pyb_timer_channel_reg);
 #endif
@@ -873,9 +883,9 @@ STATIC const mp_rom_map_elem_t pyb_timer_channel_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_pulse_width_percent), MP_ROM_PTR(&pyb_timer_channel_pulse_width_percent_obj) },
     { MP_ROM_QSTR(MP_QSTR_capture), MP_ROM_PTR(&pyb_timer_channel_capture_compare_obj) },
     { MP_ROM_QSTR(MP_QSTR_compare), MP_ROM_PTR(&pyb_timer_channel_capture_compare_obj) },
-#if MICROPY_TIMER_REG
+    #if MICROPY_TIMER_REG
     { MP_ROM_QSTR(MP_QSTR_reg), MP_ROM_PTR(&pyb_timer_channel_reg_obj) },
-#endif
+    #endif
 };
 STATIC MP_DEFINE_CONST_DICT(pyb_timer_channel_locals_dict, pyb_timer_channel_locals_dict_table);
 
@@ -906,10 +916,10 @@ STATIC bool ftm_handle_irq_callback(pyb_timer_obj_t *self, mp_uint_t channel, mp
         self->callback = mp_const_none;
         if (channel == 0xffffffff) {
             printf("Uncaught exception in Timer(" UINT_FMT
-                   ") interrupt handler\n", self->tim_id);
+                ") interrupt handler\n", self->tim_id);
         } else {
             printf("Uncaught exception in Timer(" UINT_FMT ") channel "
-                   UINT_FMT " interrupt handler\n", self->tim_id, channel);
+                UINT_FMT " interrupt handler\n", self->tim_id, channel);
         }
         mp_obj_print_exception(&mp_plat_print, (mp_obj_t)nlr.ret_val);
     }
@@ -956,7 +966,7 @@ STATIC void ftm_irq_handler(uint tim_id) {
             } else {
                 __HAL_FTM_DISABLE_CH_IT(&self->ftm, chan->channel);
                 printf("No callback for Timer %d channel %u (now disabled)\n",
-                       self->tim_id, chan->channel);
+                    self->tim_id, chan->channel);
             }
         }
         chan = chan->next;
@@ -971,7 +981,7 @@ STATIC void ftm_irq_handler(uint tim_id) {
                     __HAL_FTM_CLEAR_CH_FLAG(&self->ftm, channel);
                     __HAL_FTM_DISABLE_CH_IT(&self->ftm, channel);
                     printf("Unhandled interrupt Timer %d channel %u (now disabled)\n",
-                           tim_id, channel);
+                        tim_id, channel);
                 }
             }
         }
diff --git a/ports/teensy/uart.c b/ports/teensy/uart.c
index ee0eae39ae587..471b40ee0169d 100644
--- a/ports/teensy/uart.c
+++ b/ports/teensy/uart.c
@@ -62,12 +62,12 @@ pyb_uart_obj_t *pyb_uart_global_debug = NULL;
 
 // assumes Init parameters have been set up correctly
 bool uart_init2(pyb_uart_obj_t *uart_obj) {
-#if 0
+    #if 0
     USART_TypeDef *UARTx = NULL;
 
     uint32_t GPIO_Pin = 0;
-    uint8_t  GPIO_AF_UARTx = 0;
-    GPIO_TypeDef* GPIO_Port = NULL;
+    uint8_t GPIO_AF_UARTx = 0;
+    GPIO_TypeDef *GPIO_Port = NULL;
 
     switch (uart_obj->uart_id) {
         // USART1 is on PA9/PA10 (CK on PA8), PB6/PB7
@@ -75,13 +75,13 @@ bool uart_init2(pyb_uart_obj_t *uart_obj) {
             UARTx = USART1;
             GPIO_AF_UARTx = GPIO_AF7_USART1;
 
-#if defined (PYBV4) || defined(PYBV10)
+            #if defined(PYBV4) || defined(PYBV10)
             GPIO_Port = GPIOB;
             GPIO_Pin = GPIO_PIN_6 | GPIO_PIN_7;
-#else
+            #else
             GPIO_Port = GPIOA;
             GPIO_Pin = GPIO_PIN_9 | GPIO_PIN_10;
-#endif
+            #endif
 
             __USART1_CLK_ENABLE();
             break;
@@ -102,13 +102,13 @@ bool uart_init2(pyb_uart_obj_t *uart_obj) {
             UARTx = USART3;
             GPIO_AF_UARTx = GPIO_AF7_USART3;
 
-#if defined(PYBV3) || defined(PYBV4) | defined(PYBV10)
+            #if defined(PYBV3) || defined(PYBV4) | defined(PYBV10)
             GPIO_Port = GPIOB;
             GPIO_Pin = GPIO_PIN_10 | GPIO_PIN_11;
-#else
+            #else
             GPIO_Port = GPIOD;
             GPIO_Pin = GPIO_PIN_8 | GPIO_PIN_9;
-#endif
+            #endif
             __USART3_CLK_ENABLE();
             break;
 
@@ -152,12 +152,12 @@ bool uart_init2(pyb_uart_obj_t *uart_obj) {
     HAL_UART_Init(&uart_obj->uart);
 
     uart_obj->is_enabled = true;
-#endif
+    #endif
     return true;
 }
 
 bool uart_init(pyb_uart_obj_t *uart_obj, uint32_t baudrate) {
-#if 0
+    #if 0
     UART_HandleTypeDef *uh = &uart_obj->uart;
     memset(uh, 0, sizeof(*uh));
     uh->Init.BaudRate = baudrate;
@@ -167,47 +167,47 @@ bool uart_init(pyb_uart_obj_t *uart_obj, uint32_t baudrate) {
     uh->Init.Mode = UART_MODE_TX_RX;
     uh->Init.HwFlowCtl = UART_HWCONTROL_NONE;
     uh->Init.OverSampling = UART_OVERSAMPLING_16;
-#endif
+    #endif
     return uart_init2(uart_obj);
 }
 
 mp_uint_t uart_rx_any(pyb_uart_obj_t *uart_obj) {
-#if 0
+    #if 0
     return __HAL_UART_GET_FLAG(&uart_obj->uart, UART_FLAG_RXNE);
-#else
+    #else
     return 0;
-#endif
+    #endif
 }
 
 int uart_rx_char(pyb_uart_obj_t *uart_obj) {
     uint8_t ch;
-#if 0
+    #if 0
     if (HAL_UART_Receive(&uart_obj->uart, &ch, 1, 0) != HAL_OK) {
         ch = 0;
     }
-#else
+    #else
     ch = 'A';
-#endif
+    #endif
     return ch;
 }
 
 void uart_tx_char(pyb_uart_obj_t *uart_obj, int c) {
-#if 0
+    #if 0
     uint8_t ch = c;
     HAL_UART_Transmit(&uart_obj->uart, &ch, 1, 100000);
-#endif
+    #endif
 }
 
 void uart_tx_str(pyb_uart_obj_t *uart_obj, const char *str) {
-#if 0
-    HAL_UART_Transmit(&uart_obj->uart, (uint8_t*)str, strlen(str), 100000);
-#endif
+    #if 0
+    HAL_UART_Transmit(&uart_obj->uart, (uint8_t *)str, strlen(str), 100000);
+    #endif
 }
 
 void uart_tx_strn(pyb_uart_obj_t *uart_obj, const char *str, uint len) {
-#if 0
-    HAL_UART_Transmit(&uart_obj->uart, (uint8_t*)str, len, 100000);
-#endif
+    #if 0
+    HAL_UART_Transmit(&uart_obj->uart, (uint8_t *)str, len, 100000);
+    #endif
 }
 
 void uart_tx_strn_cooked(pyb_uart_obj_t *uart_obj, const char *str, uint len) {
@@ -227,7 +227,7 @@ STATIC void pyb_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_print_k
     if (!self->is_enabled) {
         mp_printf(print, "UART(%lu)", self->uart_id);
     } else {
-#if 0
+        #if 0
         mp_printf(print, "UART(%lu, baudrate=%u, bits=%u, stop=%u",
             self->uart_id, self->uart.Init.BaudRate,
             self->uart.Init.WordLength == UART_WORDLENGTH_8B ? 8 : 9,
@@ -237,7 +237,7 @@ STATIC void pyb_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_print_k
         } else {
             mp_printf(print, ", parity=%u)", self->uart.Init.Parity == UART_PARITY_EVEN ? 0 : 1);
         }
-#endif
+        #endif
     }
 }
 
@@ -261,15 +261,19 @@ STATIC mp_obj_t pyb_uart_init_helper(pyb_uart_obj_t *self, uint n_args, const mp
     // parse args
     mp_arg_val_t vals[PYB_UART_INIT_NUM_ARGS];
     mp_arg_parse_all(n_args, args, kw_args, PYB_UART_INIT_NUM_ARGS, pyb_uart_init_args, vals);
-#if 0
+    #if 0
     // set the UART configuration values
     memset(&self->uart, 0, sizeof(self->uart));
     UART_InitTypeDef *init = &self->uart.Init;
     init->BaudRate = vals[0].u_int;
     init->WordLength = vals[1].u_int == 8 ? UART_WORDLENGTH_8B : UART_WORDLENGTH_9B;
     switch (vals[2].u_int) {
-        case 1: init->StopBits = UART_STOPBITS_1; break;
-        default: init->StopBits = UART_STOPBITS_2; break;
+        case 1:
+            init->StopBits = UART_STOPBITS_1;
+            break;
+        default:
+            init->StopBits = UART_STOPBITS_2;
+            break;
     }
     if (vals[3].u_obj == mp_const_none) {
         init->Parity = UART_PARITY_NONE;
@@ -283,9 +287,9 @@ STATIC mp_obj_t pyb_uart_init_helper(pyb_uart_obj_t *self, uint n_args, const mp
 
     // init UART (if it fails, it's because the port doesn't exist)
     if (!uart_init2(self)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART port %d does not exist", self->uart_id));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("UART port %d does not exist"), self->uart_id);
     }
-#endif
+    #endif
 
     return mp_const_none;
 }
@@ -315,11 +319,11 @@ STATIC mp_obj_t pyb_uart_make_new(const mp_obj_type_t *type, uint n_args, uint n
 
     // work out port
     o->uart_id = 0;
-#if 0
+    #if 0
     if (mp_obj_is_str(args[0])) {
         const char *port = mp_obj_str_get_str(args[0]);
         if (0) {
-#if defined(PYBV10)
+        #if defined(PYBV10)
         } else if (strcmp(port, "XA") == 0) {
             o->uart_id = PYB_UART_XA;
         } else if (strcmp(port, "XB") == 0) {
@@ -328,14 +332,14 @@ STATIC mp_obj_t pyb_uart_make_new(const mp_obj_type_t *type, uint n_args, uint n
             o->uart_id = PYB_UART_YA;
         } else if (strcmp(port, "YB") == 0) {
             o->uart_id = PYB_UART_YB;
-#endif
+        #endif
         } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART port %s does not exist", port));
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("UART port %s does not exist"), port);
         }
     } else {
         o->uart_id = mp_obj_get_int(args[0]);
     }
-#endif
+    #endif
 
     if (n_args > 1 || n_kw > 0) {
         // start the peripheral
@@ -355,7 +359,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_uart_init_obj, 1, pyb_uart_init);
 /// \method deinit()
 /// Turn off the UART bus.
 STATIC mp_obj_t pyb_uart_deinit(mp_obj_t self_in) {
-    //pyb_uart_obj_t *self = self_in;
+    // pyb_uart_obj_t *self = self_in;
     // TODO
     return mp_const_none;
 }
@@ -395,7 +399,7 @@ STATIC mp_obj_t pyb_uart_send(uint n_args, const mp_obj_t *args, mp_map_t *kw_ar
     mp_arg_val_t vals[PYB_UART_SEND_NUM_ARGS];
     mp_arg_parse_all(n_args - 1, args + 1, kw_args, PYB_UART_SEND_NUM_ARGS, pyb_uart_send_args, vals);
 
-#if 0
+    #if 0
     // get the buffer to send from
     mp_buffer_info_t bufinfo;
     uint8_t data[1];
@@ -406,11 +410,11 @@ STATIC mp_obj_t pyb_uart_send(uint n_args, const mp_obj_t *args, mp_map_t *kw_ar
 
     if (status != HAL_OK) {
         // TODO really need a HardwareError object, or something
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_Exception, "HAL_UART_Transmit failed with code %d", status));
+        mp_raise_msg_varg(&mp_type_Exception, MP_ERROR_TEXT("HAL_UART_Transmit failed with code %d"), status);
     }
-#else
+    #else
     (void)self;
-#endif
+    #endif
 
     return mp_const_none;
 }
@@ -439,7 +443,7 @@ STATIC mp_obj_t pyb_uart_recv(uint n_args, const mp_obj_t *args, mp_map_t *kw_ar
 
     pyb_uart_obj_t *self = args[0];
 
-#if 0
+    #if 0
     // parse args
     mp_arg_val_t vals[PYB_UART_RECV_NUM_ARGS];
     mp_arg_parse_all(n_args - 1, args + 1, kw_args, PYB_UART_RECV_NUM_ARGS, pyb_uart_recv_args, vals);
@@ -453,7 +457,7 @@ STATIC mp_obj_t pyb_uart_recv(uint n_args, const mp_obj_t *args, mp_map_t *kw_ar
 
     if (status != HAL_OK) {
         // TODO really need a HardwareError object, or something
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_Exception, "HAL_UART_Receive failed with code %d", status));
+        mp_raise_msg_varg(&mp_type_Exception, MP_ERROR_TEXT("HAL_UART_Receive failed with code %d"), status);
     }
 
     // return the received data
@@ -462,10 +466,10 @@ STATIC mp_obj_t pyb_uart_recv(uint n_args, const mp_obj_t *args, mp_map_t *kw_ar
     } else {
         return mp_obj_str_builder_end(o_ret);
     }
-#else
+    #else
     (void)self;
     return mp_const_none;
-#endif
+    #endif
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_uart_recv_obj, 1, pyb_uart_recv);
 
diff --git a/ports/teensy/usb.c b/ports/teensy/usb.c
index ed96826b350f9..a906f91288b40 100644
--- a/ports/teensy/usb.c
+++ b/ports/teensy/usb.c
@@ -7,46 +7,40 @@
 #include "usb.h"
 #include "usb_serial.h"
 
-bool usb_vcp_is_connected(void)
-{
-  return usb_configuration && (usb_cdc_line_rtsdtr & (USB_SERIAL_DTR | USB_SERIAL_RTS));
+bool usb_vcp_is_connected(void) {
+    return usb_configuration && (usb_cdc_line_rtsdtr & (USB_SERIAL_DTR | USB_SERIAL_RTS));
 }
 
-bool usb_vcp_is_enabled(void)
-{
-  return true;
+bool usb_vcp_is_enabled(void) {
+    return true;
 }
 
 int usb_vcp_rx_num(void) {
-  return usb_serial_available();
+    return usb_serial_available();
 }
 
-int usb_vcp_recv_byte(uint8_t *ptr)
-{
-  int ch = usb_serial_getchar();
-  if (ch < 0) {
-    return 0;
-  }
-  *ptr = ch;
-  return 1;
+int usb_vcp_recv_byte(uint8_t *ptr) {
+    int ch = usb_serial_getchar();
+    if (ch < 0) {
+        return 0;
+    }
+    *ptr = ch;
+    return 1;
 }
 
-void usb_vcp_send_str(const char* str)
-{
-  usb_vcp_send_strn(str, strlen(str));
+void usb_vcp_send_str(const char *str) {
+    usb_vcp_send_strn(str, strlen(str));
 }
 
-void usb_vcp_send_strn(const char* str, int len)
-{
-  usb_serial_write(str, len);
+void usb_vcp_send_strn(const char *str, int len) {
+    usb_serial_write(str, len);
 }
 
-void usb_vcp_send_strn_cooked(const char *str, int len)
-{
-  for (const char *top = str + len; str < top; str++) {
-    if (*str == '\n') {
-      usb_serial_putchar('\r');
+void usb_vcp_send_strn_cooked(const char *str, int len) {
+    for (const char *top = str + len; str < top; str++) {
+        if (*str == '\n') {
+            usb_serial_putchar('\r');
+        }
+        usb_serial_putchar(*str);
     }
-    usb_serial_putchar(*str);
-  }
 }
diff --git a/ports/teensy/usb.h b/ports/teensy/usb.h
index 50fb3ff90d628..7ca0eacb9bbf2 100644
--- a/ports/teensy/usb.h
+++ b/ports/teensy/usb.h
@@ -5,8 +5,8 @@ bool usb_vcp_is_connected(void);
 bool usb_vcp_is_enabled(void);
 int usb_vcp_rx_num(void);
 int usb_vcp_recv_byte(uint8_t *ptr);
-void usb_vcp_send_str(const char* str);
-void usb_vcp_send_strn(const char* str, int len);
+void usb_vcp_send_str(const char *str);
+void usb_vcp_send_strn(const char *str, int len);
 void usb_vcp_send_strn_cooked(const char *str, int len);
 
 #endif // MICROPY_INCLUDED_TEENSY_USB_H
diff --git a/ports/unix/.gitignore b/ports/unix/.gitignore
index 706b7732dc51e..6745218688c20 100644
--- a/ports/unix/.gitignore
+++ b/ports/unix/.gitignore
@@ -1,14 +1,4 @@
-build
-build-fast
-build-minimal
-build-coverage
-build-nanbox
-build-freedos
 micropython
-micropython_fast
-micropython_minimal
-micropython_coverage
-micropython_nanbox
-micropython_freedos*
+micropython-*
 *.py
 *.gcov
diff --git a/ports/unix/Makefile b/ports/unix/Makefile
index 41552bf5c99ae..ec14166149ba8 100644
--- a/ports/unix/Makefile
+++ b/ports/unix/Makefile
@@ -1,14 +1,29 @@
--include mpconfigport.mk
+# Select the variant to build for.
+VARIANT ?= standard
+
+# If the build directory is not given, make it reflect the variant name.
+BUILD ?= build-$(VARIANT)
+
+VARIANT_DIR ?= variants/$(VARIANT)
+ifeq ($(wildcard $(VARIANT_DIR)/.),)
+$(error Invalid VARIANT specified: $(VARIANT_DIR))
+endif
+
 include ../../py/mkenv.mk
+-include mpconfigport.mk
+include $(VARIANT_DIR)/mpconfigvariant.mk
 
-FROZEN_DIR = scripts
-FROZEN_MPY_DIR = modules
+# use FROZEN_MANIFEST for new projects, others are legacy
+FROZEN_MANIFEST ?= manifest.py
+FROZEN_DIR =
+FROZEN_MPY_DIR =
 
-# define main target
-PROG = micropython
+# This should be configured by the mpconfigvariant.mk
+PROG ?= micropython
 
 # qstr definitions (must come before including py.mk)
 QSTR_DEFS = qstrdefsport.h
+QSTR_GLOBAL_DEPENDENCIES = $(VARIANT_DIR)/mpconfigvariant.h
 
 # OS name, for simple autoconfig
 UNAME_S := $(shell uname -s)
@@ -16,21 +31,31 @@ UNAME_S := $(shell uname -s)
 # include py core make definitions
 include $(TOP)/py/py.mk
 
+GIT_SUBMODULES += lib/axtls lib/berkeley-db-1.xx lib/libffi
+
 INC +=  -I.
 INC +=  -I$(TOP)
 INC += -I$(BUILD)
 
 # compiler settings
 CWARN = -Wall -Werror
-CWARN += -Wpointer-arith -Wuninitialized
-CFLAGS = $(INC) $(CWARN) -std=gnu99 -DUNIX $(CFLAGS_MOD) $(COPT) $(CFLAGS_EXTRA)
+CWARN += -Wpointer-arith -Wuninitialized -Wdouble-promotion -Wsign-compare -Wfloat-conversion
+CFLAGS += $(INC) $(CWARN) -std=gnu99 -DUNIX $(CFLAGS_MOD) $(COPT) -I$(VARIANT_DIR) $(CFLAGS_EXTRA)
 
 # Debugging/Optimization
 ifdef DEBUG
-CFLAGS += -g
-COPT = -O0
+COPT ?= -O0
 else
-COPT = -Os -fdata-sections -ffunction-sections -DNDEBUG
+COPT ?= -Os
+COPT += -fdata-sections -ffunction-sections
+COPT += -DNDEBUG
+endif
+
+# Always enable symbols -- They're occasionally useful, and don't make it into the
+# final .bin/.hex/.dfu so the extra size doesn't matter.
+CFLAGS += -g
+
+ifndef DEBUG
 # _FORTIFY_SOURCE is a feature in gcc/glibc which is intended to provide extra
 # security for detecting buffer overflows. Some distros (Ubuntu at the very least)
 # have it enabled by default.
@@ -74,7 +99,7 @@ else
 # Use gcc syntax for map file
 LDFLAGS_ARCH = -Wl,-Map=$@.map,--cref -Wl,--gc-sections
 endif
-LDFLAGS = $(LDFLAGS_MOD) $(LDFLAGS_ARCH) -lm $(LDFLAGS_EXTRA)
+LDFLAGS += $(LDFLAGS_MOD) $(LDFLAGS_ARCH) -lm $(LDFLAGS_EXTRA)
 
 # Flags to link with pthread library
 LIBPTHREAD = -lpthread
@@ -107,6 +132,28 @@ CFLAGS_MOD += -DMICROPY_PY_THREAD=1 -DMICROPY_PY_THREAD_GIL=0
 LDFLAGS_MOD += $(LIBPTHREAD)
 endif
 
+# If the variant enables it and we have libusb, enable BTStack support for USB adaptors.
+ifeq ($(MICROPY_PY_BLUETOOTH),1)
+
+HAVE_LIBUSB := $(shell (which pkg-config > /dev/null && pkg-config --exists libusb-1.0) 2>/dev/null && echo '1')
+ifeq ($(HAVE_LIBUSB),1)
+
+CFLAGS_MOD += -DMICROPY_PY_BLUETOOTH=1
+CFLAGS_MOD += -DMICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE=1
+CFLAGS_MOD += -DMICROPY_PY_BLUETOOTH_GATTS_ON_READ_CALLBACK=1
+
+MICROPY_BLUETOOTH_BTSTACK ?= 1
+MICROPY_BLUETOOTH_BTSTACK_USB ?= 1
+
+ifeq ($(MICROPY_BLUETOOTH_BTSTACK),1)
+GIT_SUBMODULES += lib/btstack
+
+include $(TOP)/extmod/btstack/btstack.mk
+endif
+
+endif
+endif
+
 ifeq ($(MICROPY_PY_FFI),1)
 
 ifeq ($(MICROPY_STANDALONE),1)
@@ -143,7 +190,6 @@ SRC_C = \
 	unix_mphal.c \
 	mpthreadport.c \
 	input.c \
-	file.c \
 	modmachine.c \
 	modos.c \
 	moduos_vfs.c \
@@ -152,117 +198,66 @@ SRC_C = \
 	alloc.c \
 	coverage.c \
 	fatfs_port.c \
-	$(SRC_MOD)
+	btstack_usb.c \
+	$(SRC_MOD) \
+	$(wildcard $(VARIANT_DIR)/*.c)
 
-LIB_SRC_C = $(addprefix lib/,\
+LIB_SRC_C += $(addprefix lib/,\
 	$(LIB_SRC_C_EXTRA) \
 	timeutils/timeutils.c \
-	)
-
-# FatFS VFS support
-LIB_SRC_C += $(addprefix lib/,\
-	oofatfs/ff.c \
-	oofatfs/ffunicode.c \
+	utils/gchelper_generic.c \
 	)
 
 OBJ = $(PY_O)
 OBJ += $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(LIB_SRC_C:.c=.o))
+OBJ += $(addprefix $(BUILD)/, $(EXTMOD_SRC_C:.c=.o))
 
 # List of sources for qstr extraction
-SRC_QSTR += $(SRC_C) $(LIB_SRC_C)
+SRC_QSTR += $(SRC_C) $(LIB_SRC_C) $(EXTMOD_SRC_C)
 # Append any auto-generated sources that are needed by sources listed in
 # SRC_QSTR
 SRC_QSTR_AUTO_DEPS +=
 
-ifneq ($(FROZEN_MPY_DIR),)
-# To use frozen bytecode, put your .py files in a subdirectory (eg frozen/) and
-# then invoke make with FROZEN_MPY_DIR=frozen (be sure to build from scratch).
+ifneq ($(FROZEN_MANIFEST)$(FROZEN_MPY_DIR),)
+# To use frozen code create a manifest.py file with a description of files to
+# freeze, then invoke make with FROZEN_MANIFEST=manifest.py (be sure to build from scratch).
 CFLAGS += -DMICROPY_QSTR_EXTRA_POOL=mp_qstr_frozen_const_pool
 CFLAGS += -DMICROPY_MODULE_FROZEN_MPY
 CFLAGS += -DMPZ_DIG_SIZE=16 # force 16 bits to work on both 32 and 64 bit archs
 MPY_CROSS_FLAGS += -mcache-lookup-bc
 endif
 
+ifneq ($(FROZEN_MANIFEST)$(FROZEN_DIR),)
+CFLAGS += -DMICROPY_MODULE_FROZEN_STR
+endif
+
+ifeq ($(MICROPY_FORCE_32BIT),1)
+RUN_TESTS_MPY_CROSS_FLAGS = --mpy-cross-flags='-mcache-lookup-bc -march=x86'
+else
+RUN_TESTS_MPY_CROSS_FLAGS = --mpy-cross-flags='-mcache-lookup-bc'
+endif
 
 include $(TOP)/py/mkrules.mk
 
-.PHONY: test
+.PHONY: test test_full
 
 test: $(PROG) $(TOP)/tests/run-tests
 	$(eval DIRNAME=ports/$(notdir $(CURDIR)))
 	cd $(TOP)/tests && MICROPY_MICROPYTHON=../$(DIRNAME)/$(PROG) ./run-tests
 
-# install micropython in /usr/local/bin
-TARGET = micropython
-PREFIX = $(DESTDIR)/usr/local
-BINDIR = $(PREFIX)/bin
-
-install: micropython
-	install -d $(BINDIR)
-	install $(TARGET) $(BINDIR)/$(TARGET)
-
-# uninstall micropython
-uninstall:
-	-rm $(BINDIR)/$(TARGET)
-
-# build synthetically fast interpreter for benchmarking
-fast:
-	$(MAKE) COPT="-O2 -DNDEBUG -fno-crossjumping" CFLAGS_EXTRA='-DMP_CONFIGFILE="<mpconfigport_fast.h>"' BUILD=build-fast PROG=micropython_fast
-
-# build a minimal interpreter
-minimal:
-	$(MAKE) COPT="-Os -DNDEBUG" CFLAGS_EXTRA='-DMP_CONFIGFILE="<mpconfigport_minimal.h>"' \
-	    BUILD=build-minimal PROG=micropython_minimal FROZEN_DIR= FROZEN_MPY_DIR= \
-	    MICROPY_PY_BTREE=0 MICROPY_PY_FFI=0 MICROPY_PY_SOCKET=0 MICROPY_PY_THREAD=0 \
-	    MICROPY_PY_TERMIOS=0 MICROPY_PY_USSL=0 \
-	    MICROPY_USE_READLINE=0
-
-# build interpreter with nan-boxing as object model
-nanbox:
-	$(MAKE) \
-	CFLAGS_EXTRA='-DMP_CONFIGFILE="<mpconfigport_nanbox.h>"' \
-	BUILD=build-nanbox \
-	PROG=micropython_nanbox \
-	MICROPY_FORCE_32BIT=1
-
-freedos:
-	$(MAKE) \
-	CC=i586-pc-msdosdjgpp-gcc \
-	STRIP=i586-pc-msdosdjgpp-strip \
-	SIZE=i586-pc-msdosdjgpp-size \
-	CFLAGS_EXTRA='-DMP_CONFIGFILE="<mpconfigport_freedos.h>" -DMICROPY_NLR_SETJMP -Dtgamma=gamma -DMICROPY_EMIT_X86=0 -DMICROPY_NO_ALLOCA=1 -DMICROPY_PY_USELECT_POSIX=0' \
-	BUILD=build-freedos \
-	PROG=micropython_freedos \
-	MICROPY_PY_SOCKET=0 \
-	MICROPY_PY_FFI=0 \
-	MICROPY_PY_JNI=0 \
-	MICROPY_PY_BTREE=0 \
-	MICROPY_PY_THREAD=0 \
-	MICROPY_PY_USSL=0
-
-# build an interpreter for coverage testing and do the testing
-coverage:
-	$(MAKE) \
-	    COPT="-O0" CFLAGS_EXTRA='$(CFLAGS_EXTRA) -DMP_CONFIGFILE="<mpconfigport_coverage.h>" \
-	    -fprofile-arcs -ftest-coverage \
-	    -Wdouble-promotion -Wformat -Wmissing-declarations -Wmissing-prototypes -Wsign-compare \
-	    -Wold-style-definition -Wpointer-arith -Wshadow -Wuninitialized -Wunused-parameter \
-	    -DMICROPY_UNIX_COVERAGE' \
-	    LDFLAGS_EXTRA='-fprofile-arcs -ftest-coverage' \
-	    FROZEN_DIR=coverage-frzstr FROZEN_MPY_DIR=coverage-frzmpy \
-	    BUILD=build-coverage PROG=micropython_coverage
-
-coverage_test: coverage
+test_full: $(PROG) $(TOP)/tests/run-tests
 	$(eval DIRNAME=ports/$(notdir $(CURDIR)))
-	cd $(TOP)/tests && MICROPY_MICROPYTHON=../$(DIRNAME)/micropython_coverage ./run-tests
-	cd $(TOP)/tests && MICROPY_MICROPYTHON=../$(DIRNAME)/micropython_coverage ./run-tests -d thread
-	cd $(TOP)/tests && MICROPY_MICROPYTHON=../$(DIRNAME)/micropython_coverage ./run-tests --emit native
-	cd $(TOP)/tests && MICROPY_MICROPYTHON=../$(DIRNAME)/micropython_coverage ./run-tests --via-mpy -d basics float micropython
-	cd $(TOP)/tests && MICROPY_MICROPYTHON=../$(DIRNAME)/micropython_coverage ./run-tests --via-mpy --emit native -d basics float micropython
-	cat $(TOP)/tests/basics/0prelim.py | ./micropython_coverage | grep -q 'abc'
-	gcov -o build-coverage/py $(TOP)/py/*.c
-	gcov -o build-coverage/extmod $(TOP)/extmod/*.c
+	cd $(TOP)/tests && MICROPY_MICROPYTHON=../$(DIRNAME)/$(PROG) ./run-tests
+	cd $(TOP)/tests && MICROPY_MICROPYTHON=../$(DIRNAME)/$(PROG) ./run-tests -d thread
+	cd $(TOP)/tests && MICROPY_MICROPYTHON=../$(DIRNAME)/$(PROG) ./run-tests --emit native
+	cd $(TOP)/tests && MICROPY_MICROPYTHON=../$(DIRNAME)/$(PROG) ./run-tests --via-mpy $(RUN_TESTS_MPY_CROSS_FLAGS) -d basics float micropython
+	cd $(TOP)/tests && MICROPY_MICROPYTHON=../$(DIRNAME)/$(PROG) ./run-tests --via-mpy $(RUN_TESTS_MPY_CROSS_FLAGS) --emit native -d basics float micropython
+	cat $(TOP)/tests/basics/0prelim.py | ./$(PROG) | grep -q 'abc'
+
+test_gcov: test_full
+	gcov -o $(BUILD)/py $(TOP)/py/*.c
+	gcov -o $(BUILD)/extmod $(TOP)/extmod/*.c
 
 # Value of configure's --host= option (required for cross-compilation).
 # Deduce it from CROSS_COMPILE by default, but can be overridden.
@@ -291,3 +286,13 @@ axtls: $(TOP)/lib/axtls/README
 $(TOP)/lib/axtls/README:
 	@echo "You cloned without --recursive, fetching submodules for you."
 	(cd $(TOP); git submodule update --init --recursive)
+
+PREFIX = /usr/local
+BINDIR = $(DESTDIR)$(PREFIX)/bin
+
+install: $(PROG)
+	install -d $(BINDIR)
+	install $(PROG) $(BINDIR)/$(PROG)
+
+uninstall:
+	-rm $(BINDIR)/$(PROG)
diff --git a/ports/unix/alloc.c b/ports/unix/alloc.c
index ca12d025b64b1..7fe7b4dba4e71 100644
--- a/ports/unix/alloc.c
+++ b/ports/unix/alloc.c
@@ -69,7 +69,7 @@ void mp_unix_free_exec(void *ptr, size_t size) {
     munmap(ptr, size);
 
     // unlink the mmap'd region from the list
-    for (mmap_region_t **rg = (mmap_region_t**)&MP_STATE_VM(mmap_region_head); *rg != NULL; *rg = (*rg)->next) {
+    for (mmap_region_t **rg = (mmap_region_t **)&MP_STATE_VM(mmap_region_head); *rg != NULL; *rg = (*rg)->next) {
         if ((*rg)->ptr == ptr) {
             mmap_region_t *next = (*rg)->next;
             m_del_obj(mmap_region_t, *rg);
diff --git a/ports/unix/btstack_usb.c b/ports/unix/btstack_usb.c
new file mode 100644
index 0000000000000..da9d72fe15258
--- /dev/null
+++ b/ports/unix/btstack_usb.c
@@ -0,0 +1,172 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Jim Mussared
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <pthread.h>
+#include <unistd.h>
+
+#include "py/runtime.h"
+#include "py/mperrno.h"
+#include "py/mphal.h"
+
+#if MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_BTSTACK
+
+#include "lib/btstack/src/btstack.h"
+#include "lib/btstack/platform/embedded/btstack_run_loop_embedded.h"
+#include "lib/btstack/platform/embedded/hal_cpu.h"
+#include "lib/btstack/platform/embedded/hal_time_ms.h"
+
+#include "extmod/btstack/modbluetooth_btstack.h"
+
+#if !MICROPY_PY_THREAD
+#error Unix btstack requires MICROPY_PY_THREAD
+#endif
+
+STATIC const useconds_t USB_POLL_INTERVAL_US = 1000;
+
+STATIC const uint8_t read_static_address_command_complete_prefix[] = { 0x0e, 0x1b, 0x01, 0x09, 0xfc };
+
+STATIC uint8_t local_addr[6] = {0};
+STATIC uint8_t static_address[6] = {0};
+STATIC volatile bool have_addr = false;
+STATIC bool using_static_address = false;
+
+STATIC btstack_packet_callback_registration_t hci_event_callback_registration;
+
+STATIC void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size) {
+    (void)channel;
+    (void)size;
+    if (packet_type != HCI_EVENT_PACKET) {
+        return;
+    }
+    switch (hci_event_packet_get_type(packet)) {
+        case BTSTACK_EVENT_STATE:
+            if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) {
+                return;
+            }
+            gap_local_bd_addr(local_addr);
+            if (using_static_address) {
+                memcpy(local_addr, static_address, sizeof(local_addr));
+            }
+            have_addr = true;
+            break;
+        case HCI_EVENT_COMMAND_COMPLETE:
+            if (memcmp(packet, read_static_address_command_complete_prefix, sizeof(read_static_address_command_complete_prefix)) == 0) {
+                reverse_48(&packet[7], static_address);
+                gap_random_address_set(static_address);
+                using_static_address = true;
+                have_addr = true;
+            }
+            break;
+        default:
+            break;
+    }
+}
+
+// The IRQ functionality in btstack_run_loop_embedded.c is not used, so the
+// following three functions are empty.
+
+void hal_cpu_disable_irqs(void) {
+}
+
+void hal_cpu_enable_irqs(void) {
+}
+
+void hal_cpu_enable_irqs_and_sleep(void) {
+}
+
+uint32_t hal_time_ms(void) {
+    return mp_hal_ticks_ms();
+}
+
+void mp_bluetooth_btstack_port_init(void) {
+    static bool run_loop_init = false;
+    if (!run_loop_init) {
+        run_loop_init = true;
+        btstack_run_loop_init(btstack_run_loop_embedded_get_instance());
+    } else {
+        btstack_run_loop_embedded_get_instance()->init();
+    }
+
+    // TODO: allow setting USB device path via cmdline/env var.
+
+    // hci_dump_open(NULL, HCI_DUMP_STDOUT);
+    hci_init(hci_transport_usb_instance(), NULL);
+
+    hci_event_callback_registration.callback = &packet_handler;
+    hci_add_event_handler(&hci_event_callback_registration);
+}
+
+STATIC pthread_t bstack_thread_id;
+
+void mp_bluetooth_btstack_port_deinit(void) {
+    hci_power_control(HCI_POWER_OFF);
+
+    // Wait for the poll loop to terminate when the state is set to OFF.
+    pthread_join(bstack_thread_id, NULL);
+    have_addr = false;
+}
+
+STATIC void *btstack_thread(void *arg) {
+    (void)arg;
+    hci_power_control(HCI_POWER_ON);
+
+    // modbluetooth_btstack.c will have set the state to STARTING before
+    // calling mp_bluetooth_btstack_port_start.
+    // This loop will terminate when the HCI_POWER_OFF above results
+    // in modbluetooth_btstack.c setting the state back to OFF.
+    // Or, if a timeout results in it being set to TIMEOUT.
+
+    while (mp_bluetooth_btstack_state == MP_BLUETOOTH_BTSTACK_STATE_STARTING || mp_bluetooth_btstack_state == MP_BLUETOOTH_BTSTACK_STATE_ACTIVE) {
+        btstack_run_loop_embedded_execute_once();
+
+        // The USB transport schedules events to the run loop at 1ms intervals,
+        // and the implementation currently polls rather than selects.
+        usleep(USB_POLL_INTERVAL_US);
+    }
+
+    hci_close();
+
+    return NULL;
+}
+
+void mp_bluetooth_btstack_port_start(void) {
+    // Create a thread to run the btstack loop.
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+    pthread_create(&bstack_thread_id, &attr, &btstack_thread, NULL);
+}
+
+void mp_hal_get_mac(int idx, uint8_t buf[6]) {
+    if (idx == MP_HAL_MAC_BDADDR) {
+        if (!have_addr) {
+            mp_raise_OSError(MP_ENODEV);
+        }
+        memcpy(buf, local_addr, sizeof(local_addr));
+    }
+}
+
+#endif // MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_BTSTACK
diff --git a/ports/unix/coverage-frzmpy/frzqstr.py b/ports/unix/coverage-frzmpy/frzqstr.py
new file mode 100644
index 0000000000000..051f2a9c1676a
--- /dev/null
+++ b/ports/unix/coverage-frzmpy/frzqstr.py
@@ -0,0 +1,3 @@
+# Checks for regression on MP_QSTR_NULL
+def returns_NULL():
+    return "NULL"
diff --git a/ports/unix/coverage.c b/ports/unix/coverage.c
index 3c121a153836d..7169c7793bd93 100644
--- a/ports/unix/coverage.c
+++ b/ports/unix/coverage.c
@@ -10,10 +10,14 @@
 #include "py/builtin.h"
 #include "py/emit.h"
 #include "py/formatfloat.h"
+#include "py/ringbuf.h"
+#include "py/pairheap.h"
 #include "py/stream.h"
 #include "py/binary.h"
 #include "py/bc.h"
 
+// expected output of this file is found in extra_coverage.py.exp
+
 #if defined(MICROPY_UNIX_COVERAGE)
 
 // stream testing object
@@ -104,7 +108,7 @@ STATIC const mp_stream_p_t fileio_stream_p = {
 STATIC const mp_obj_type_t mp_type_stest_fileio = {
     { &mp_type_type },
     .protocol = &fileio_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&rawfile_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&rawfile_locals_dict,
 };
 
 // stream read returns non-blocking error
@@ -131,12 +135,46 @@ STATIC const mp_stream_p_t textio_stream_p2 = {
 STATIC const mp_obj_type_t mp_type_stest_textio2 = {
     { &mp_type_type },
     .protocol = &textio_stream_p2,
-    .locals_dict = (mp_obj_dict_t*)&rawfile_locals_dict2,
+    .locals_dict = (mp_obj_dict_t *)&rawfile_locals_dict2,
 };
 
 // str/bytes objects without a valid hash
-STATIC const mp_obj_str_t str_no_hash_obj = {{&mp_type_str}, 0, 10, (const byte*)"0123456789"};
-STATIC const mp_obj_str_t bytes_no_hash_obj = {{&mp_type_bytes}, 0, 10, (const byte*)"0123456789"};
+STATIC const mp_obj_str_t str_no_hash_obj = {{&mp_type_str}, 0, 10, (const byte *)"0123456789"};
+STATIC const mp_obj_str_t bytes_no_hash_obj = {{&mp_type_bytes}, 0, 10, (const byte *)"0123456789"};
+
+STATIC int pairheap_lt(mp_pairheap_t *a, mp_pairheap_t *b) {
+    return (uintptr_t)a < (uintptr_t)b;
+}
+
+// ops array contain operations: x>=0 means push(x), x<0 means delete(-x)
+STATIC void pairheap_test(size_t nops, int *ops) {
+    mp_pairheap_t node[8];
+    for (size_t i = 0; i < MP_ARRAY_SIZE(node); ++i) {
+        mp_pairheap_init_node(pairheap_lt, &node[i]);
+    }
+    mp_pairheap_t *heap = mp_pairheap_new(pairheap_lt);
+    printf("create:");
+    for (size_t i = 0; i < nops; ++i) {
+        if (ops[i] >= 0) {
+            heap = mp_pairheap_push(pairheap_lt, heap, &node[ops[i]]);
+        } else {
+            heap = mp_pairheap_delete(pairheap_lt, heap, &node[-ops[i]]);
+        }
+        if (mp_pairheap_is_empty(pairheap_lt, heap)) {
+            mp_printf(&mp_plat_print, " -");
+        } else {
+            mp_printf(&mp_plat_print, " %d", mp_pairheap_peek(pairheap_lt, heap) - &node[0]);
+            ;
+        }
+    }
+    printf("\npop all:");
+    while (!mp_pairheap_is_empty(pairheap_lt, heap)) {
+        mp_printf(&mp_plat_print, " %d", mp_pairheap_peek(pairheap_lt, heap) - &node[0]);
+        ;
+        heap = mp_pairheap_pop(pairheap_lt, heap);
+    }
+    printf("\n");
+}
 
 // function to run extra tests for things that can't be checked by scripts
 STATIC mp_obj_t extra_coverage(void) {
@@ -161,6 +199,7 @@ STATIC mp_obj_t extra_coverage(void) {
         mp_printf(&mp_plat_print, "%x\n", 0x80000000); // should print unsigned
         mp_printf(&mp_plat_print, "%X\n", 0x80000000); // should print unsigned
         mp_printf(&mp_plat_print, "abc\n%"); // string ends in middle of format specifier
+        mp_printf(&mp_plat_print, "%%\n"); // literal % character
     }
 
     // GC
@@ -332,6 +371,32 @@ STATIC mp_obj_t extra_coverage(void) {
         mp_call_function_2_protected(MP_OBJ_FROM_PTR(&mp_builtin_divmod_obj), MP_OBJ_NEW_SMALL_INT(1), MP_OBJ_NEW_SMALL_INT(1));
         // call mp_call_function_2_protected with invalid args
         mp_call_function_2_protected(MP_OBJ_FROM_PTR(&mp_builtin_divmod_obj), mp_obj_new_str("abc", 3), mp_obj_new_str("abc", 3));
+
+        // mp_obj_int_get_uint_checked with non-negative small-int
+        mp_printf(&mp_plat_print, "%d\n", (int)mp_obj_int_get_uint_checked(MP_OBJ_NEW_SMALL_INT(1)));
+
+        // mp_obj_int_get_uint_checked with non-negative big-int
+        mp_printf(&mp_plat_print, "%d\n", (int)mp_obj_int_get_uint_checked(mp_obj_new_int_from_ll(2)));
+
+        // mp_obj_int_get_uint_checked with negative small-int (should raise exception)
+        nlr_buf_t nlr;
+        if (nlr_push(&nlr) == 0) {
+            mp_obj_int_get_uint_checked(MP_OBJ_NEW_SMALL_INT(-1));
+            nlr_pop();
+        } else {
+            mp_obj_print_exception(&mp_plat_print, MP_OBJ_FROM_PTR(nlr.ret_val));
+        }
+
+        // mp_obj_int_get_uint_checked with negative big-int (should raise exception)
+        if (nlr_push(&nlr) == 0) {
+            mp_obj_int_get_uint_checked(mp_obj_new_int_from_ll(-2));
+            nlr_pop();
+        } else {
+            mp_obj_print_exception(&mp_plat_print, MP_OBJ_FROM_PTR(nlr.ret_val));
+        }
+
+        // call mp_obj_new_exception_args (it's a part of the public C API and not used in the core)
+        mp_obj_print_exception(&mp_plat_print, mp_obj_new_exception_args(&mp_type_ValueError, 0, NULL));
     }
 
     // warning
@@ -378,12 +443,12 @@ STATIC mp_obj_t extra_coverage(void) {
 
         // call mp_execute_bytecode with invalide bytecode (should raise NotImplementedError)
         mp_obj_fun_bc_t fun_bc;
-        fun_bc.bytecode = (const byte*)"\x01"; // just needed for n_state
+        fun_bc.bytecode = (const byte *)"\x01"; // just needed for n_state
         mp_code_state_t *code_state = m_new_obj_var(mp_code_state_t, mp_obj_t, 1);
         code_state->fun_bc = &fun_bc;
-        code_state->ip = (const byte*)"\x00"; // just needed for an invalid opcode
+        code_state->ip = (const byte *)"\x00"; // just needed for an invalid opcode
         code_state->sp = &code_state->state[0];
-        code_state->exc_sp = NULL;
+        code_state->exc_sp_idx = 0;
         code_state->old_globals = NULL;
         mp_vm_return_kind_t ret = mp_execute_bytecode(code_state, MP_OBJ_NULL);
         mp_printf(&mp_plat_print, "%d %d\n", ret, mp_obj_get_type(code_state->state[0]) == &mp_type_NotImplementedError);
@@ -406,7 +471,7 @@ STATIC mp_obj_t extra_coverage(void) {
         mp_sched_unlock();
 
         // shouldn't do anything while scheduler is locked
-        mp_handle_pending();
+        mp_handle_pending(true);
 
         // unlock scheduler
         mp_sched_unlock();
@@ -414,10 +479,155 @@ STATIC mp_obj_t extra_coverage(void) {
 
         // drain pending callbacks
         while (mp_sched_num_pending()) {
-            mp_handle_pending();
+            mp_handle_pending(true);
         }
+
+        // setting the keyboard interrupt and raising it during mp_handle_pending
+        mp_keyboard_interrupt();
+        nlr_buf_t nlr;
+        if (nlr_push(&nlr) == 0) {
+            mp_handle_pending(true);
+            nlr_pop();
+        } else {
+            mp_obj_print_exception(&mp_plat_print, MP_OBJ_FROM_PTR(nlr.ret_val));
+        }
+
+        // setting the keyboard interrupt (twice) and cancelling it during mp_handle_pending
+        mp_keyboard_interrupt();
+        mp_keyboard_interrupt();
+        mp_handle_pending(false);
+
+        // setting keyboard interrupt and a pending event (intr should be handled first)
+        mp_sched_schedule(MP_OBJ_FROM_PTR(&mp_builtin_print_obj), MP_OBJ_NEW_SMALL_INT(10));
+        mp_keyboard_interrupt();
+        if (nlr_push(&nlr) == 0) {
+            mp_handle_pending(true);
+            nlr_pop();
+        } else {
+            mp_obj_print_exception(&mp_plat_print, MP_OBJ_FROM_PTR(nlr.ret_val));
+        }
+        mp_handle_pending(true);
+    }
+
+    // ringbuf
+    {
+        byte buf[100];
+        ringbuf_t ringbuf = {buf, sizeof(buf), 0, 0};
+
+        mp_printf(&mp_plat_print, "# ringbuf\n");
+
+        // Single-byte put/get with empty ringbuf.
+        mp_printf(&mp_plat_print, "%d %d\n", ringbuf_free(&ringbuf), ringbuf_avail(&ringbuf));
+        ringbuf_put(&ringbuf, 22);
+        mp_printf(&mp_plat_print, "%d %d\n", ringbuf_free(&ringbuf), ringbuf_avail(&ringbuf));
+        mp_printf(&mp_plat_print, "%d\n", ringbuf_get(&ringbuf));
+        mp_printf(&mp_plat_print, "%d %d\n", ringbuf_free(&ringbuf), ringbuf_avail(&ringbuf));
+
+        // Two-byte put/get with empty ringbuf.
+        ringbuf_put16(&ringbuf, 0xaa55);
+        mp_printf(&mp_plat_print, "%d %d\n", ringbuf_free(&ringbuf), ringbuf_avail(&ringbuf));
+        mp_printf(&mp_plat_print, "%04x\n", ringbuf_get16(&ringbuf));
+        mp_printf(&mp_plat_print, "%d %d\n", ringbuf_free(&ringbuf), ringbuf_avail(&ringbuf));
+
+        // Two-byte put with full ringbuf.
+        for (int i = 0; i < 99; ++i) {
+            ringbuf_put(&ringbuf, i);
+        }
+        mp_printf(&mp_plat_print, "%d %d\n", ringbuf_free(&ringbuf), ringbuf_avail(&ringbuf));
+        mp_printf(&mp_plat_print, "%d\n", ringbuf_put16(&ringbuf, 0x11bb));
+        // Two-byte put with one byte free.
+        ringbuf_get(&ringbuf);
+        mp_printf(&mp_plat_print, "%d %d\n", ringbuf_free(&ringbuf), ringbuf_avail(&ringbuf));
+        mp_printf(&mp_plat_print, "%d\n", ringbuf_put16(&ringbuf, 0x3377));
+        ringbuf_get(&ringbuf);
+        mp_printf(&mp_plat_print, "%d %d\n", ringbuf_free(&ringbuf), ringbuf_avail(&ringbuf));
+        mp_printf(&mp_plat_print, "%d\n", ringbuf_put16(&ringbuf, 0xcc99));
+        for (int i = 0; i < 97; ++i) {
+            ringbuf_get(&ringbuf);
+        }
+        mp_printf(&mp_plat_print, "%04x\n", ringbuf_get16(&ringbuf));
+        mp_printf(&mp_plat_print, "%d %d\n", ringbuf_free(&ringbuf), ringbuf_avail(&ringbuf));
+
+        // Two-byte put with wrap around on first byte:
+        ringbuf.iput = 0;
+        ringbuf.iget = 0;
+        for (int i = 0; i < 99; ++i) {
+            ringbuf_put(&ringbuf, i);
+            ringbuf_get(&ringbuf);
+        }
+        mp_printf(&mp_plat_print, "%d\n", ringbuf_put16(&ringbuf, 0x11bb));
+        mp_printf(&mp_plat_print, "%04x\n", ringbuf_get16(&ringbuf));
+
+        // Two-byte put with wrap around on second byte:
+        ringbuf.iput = 0;
+        ringbuf.iget = 0;
+        for (int i = 0; i < 98; ++i) {
+            ringbuf_put(&ringbuf, i);
+            ringbuf_get(&ringbuf);
+        }
+        mp_printf(&mp_plat_print, "%d\n", ringbuf_put16(&ringbuf, 0x22ff));
+        mp_printf(&mp_plat_print, "%04x\n", ringbuf_get16(&ringbuf));
+
+        // Two-byte get from empty ringbuf.
+        ringbuf.iput = 0;
+        ringbuf.iget = 0;
+        mp_printf(&mp_plat_print, "%d\n", ringbuf_get16(&ringbuf));
+
+        // Two-byte get from ringbuf with one byte available.
+        ringbuf.iput = 0;
+        ringbuf.iget = 0;
+        ringbuf_put(&ringbuf, 0xaa);
+        mp_printf(&mp_plat_print, "%d\n", ringbuf_get16(&ringbuf));
     }
 
+    // pairheap
+    {
+        mp_printf(&mp_plat_print, "# pairheap\n");
+
+        // Basic case.
+        int t0[] = {0, 2, 1, 3};
+        pairheap_test(MP_ARRAY_SIZE(t0), t0);
+
+        // All pushed in reverse order.
+        int t1[] = {7, 6, 5, 4, 3, 2, 1, 0};
+        pairheap_test(MP_ARRAY_SIZE(t1), t1);
+
+        // Basic deletion.
+        int t2[] = {1, -1, -1, 1, 2, -2, 2, 3, -3};
+        pairheap_test(MP_ARRAY_SIZE(t2), t2);
+
+        // Deletion of first child that has next node (the -3).
+        int t3[] = {1, 2, 3, 4, -1, -3};
+        pairheap_test(MP_ARRAY_SIZE(t3), t3);
+
+        // Deletion of node that's not first child (the -2).
+        int t4[] = {1, 2, 3, 4, -2};
+        pairheap_test(MP_ARRAY_SIZE(t4), t4);
+
+        // Deletion of node that's not first child and has children (the -3).
+        int t5[] = {3, 4, 5, 1, 2, -3};
+        pairheap_test(MP_ARRAY_SIZE(t5), t5);
+    }
+
+    // mp_obj_is_type and derivatives
+    {
+        mp_printf(&mp_plat_print, "# mp_obj_is_type\n");
+
+        // mp_obj_is_bool accepts only booleans
+        mp_printf(&mp_plat_print, "%d %d\n", mp_obj_is_bool(mp_const_true), mp_obj_is_bool(mp_const_false));
+        mp_printf(&mp_plat_print, "%d %d\n", mp_obj_is_bool(MP_OBJ_NEW_SMALL_INT(1)), mp_obj_is_bool(mp_const_none));
+
+        // mp_obj_is_integer accepts ints and booleans
+        mp_printf(&mp_plat_print, "%d %d\n", mp_obj_is_integer(MP_OBJ_NEW_SMALL_INT(1)), mp_obj_is_integer(mp_obj_new_int_from_ll(1)));
+        mp_printf(&mp_plat_print, "%d %d\n", mp_obj_is_integer(mp_const_true), mp_obj_is_integer(mp_const_false));
+        mp_printf(&mp_plat_print, "%d %d\n", mp_obj_is_integer(mp_obj_new_str("1", 1)), mp_obj_is_integer(mp_const_none));
+
+        // mp_obj_is_int accepts small int and object ints
+        mp_printf(&mp_plat_print, "%d %d\n", mp_obj_is_int(MP_OBJ_NEW_SMALL_INT(1)), mp_obj_is_int(mp_obj_new_int_from_ll(1)));
+    }
+
+    mp_printf(&mp_plat_print, "# end coverage.c\n");
+
     mp_obj_streamtest_t *s = m_new_obj(mp_obj_streamtest_t);
     s->base.type = &mp_type_stest_fileio;
     s->buf = NULL;
diff --git a/ports/unix/file.c b/ports/unix/file.c
deleted file mode 100644
index bb841da209cae..0000000000000
--- a/ports/unix/file.c
+++ /dev/null
@@ -1,282 +0,0 @@
-/*
- * This file is part of the MicroPython project, http://micropython.org/
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2013, 2014 Damien P. George
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include <stdio.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include "py/runtime.h"
-#include "py/stream.h"
-#include "py/builtin.h"
-#include "py/mphal.h"
-#include "fdfile.h"
-
-#if MICROPY_PY_IO && !MICROPY_VFS
-
-#ifdef _WIN32
-#define fsync _commit
-#endif
-
-#ifdef MICROPY_CPYTHON_COMPAT
-STATIC void check_fd_is_open(const mp_obj_fdfile_t *o) {
-    if (o->fd < 0) {
-        mp_raise_ValueError("I/O operation on closed file");
-    }
-}
-#else
-#define check_fd_is_open(o)
-#endif
-
-extern const mp_obj_type_t mp_type_fileio;
-extern const mp_obj_type_t mp_type_textio;
-
-STATIC void fdfile_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
-    (void)kind;
-    mp_obj_fdfile_t *self = MP_OBJ_TO_PTR(self_in);
-    mp_printf(print, "<io.%s %d>", mp_obj_get_type_str(self_in), self->fd);
-}
-
-STATIC mp_uint_t fdfile_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
-    mp_obj_fdfile_t *o = MP_OBJ_TO_PTR(o_in);
-    check_fd_is_open(o);
-    mp_int_t r = read(o->fd, buf, size);
-    if (r == -1) {
-        *errcode = errno;
-        return MP_STREAM_ERROR;
-    }
-    return r;
-}
-
-STATIC mp_uint_t fdfile_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
-    mp_obj_fdfile_t *o = MP_OBJ_TO_PTR(o_in);
-    check_fd_is_open(o);
-    #if MICROPY_PY_OS_DUPTERM
-    if (o->fd <= STDERR_FILENO) {
-        mp_hal_stdout_tx_strn(buf, size);
-        return size;
-    }
-    #endif
-    mp_int_t r = write(o->fd, buf, size);
-    while (r == -1 && errno == EINTR) {
-        if (MP_STATE_VM(mp_pending_exception) != MP_OBJ_NULL) {
-            mp_obj_t obj = MP_STATE_VM(mp_pending_exception);
-            MP_STATE_VM(mp_pending_exception) = MP_OBJ_NULL;
-            nlr_raise(obj);
-        }
-        r = write(o->fd, buf, size);
-    }
-    if (r == -1) {
-        *errcode = errno;
-        return MP_STREAM_ERROR;
-    }
-    return r;
-}
-
-STATIC mp_uint_t fdfile_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
-    mp_obj_fdfile_t *o = MP_OBJ_TO_PTR(o_in);
-    check_fd_is_open(o);
-    switch (request) {
-        case MP_STREAM_SEEK: {
-            struct mp_stream_seek_t *s = (struct mp_stream_seek_t*)arg;
-            off_t off = lseek(o->fd, s->offset, s->whence);
-            if (off == (off_t)-1) {
-                *errcode = errno;
-                return MP_STREAM_ERROR;
-            }
-            s->offset = off;
-            return 0;
-        }
-        case MP_STREAM_FLUSH:
-            if (fsync(o->fd) < 0) {
-                *errcode = errno;
-                return MP_STREAM_ERROR;
-            }
-            return 0;
-        case MP_STREAM_CLOSE:
-            close(o->fd);
-            #ifdef MICROPY_CPYTHON_COMPAT
-            o->fd = -1;
-            #endif
-            return 0;
-        case MP_STREAM_GET_FILENO:
-            return o->fd;
-        default:
-            *errcode = EINVAL;
-            return MP_STREAM_ERROR;
-    }
-}
-
-STATIC mp_obj_t fdfile___exit__(size_t n_args, const mp_obj_t *args) {
-    (void)n_args;
-    return mp_stream_close(args[0]);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(fdfile___exit___obj, 4, 4, fdfile___exit__);
-
-STATIC mp_obj_t fdfile_fileno(mp_obj_t self_in) {
-    mp_obj_fdfile_t *self = MP_OBJ_TO_PTR(self_in);
-    check_fd_is_open(self);
-    return MP_OBJ_NEW_SMALL_INT(self->fd);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(fdfile_fileno_obj, fdfile_fileno);
-
-// Note: encoding is ignored for now; it's also not a valid kwarg for CPython's FileIO,
-// but by adding it here we can use one single mp_arg_t array for open() and FileIO's constructor
-STATIC const mp_arg_t file_open_args[] = {
-    { MP_QSTR_file, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
-    { MP_QSTR_mode, MP_ARG_OBJ, {.u_obj = MP_OBJ_NEW_QSTR(MP_QSTR_r)} },
-    { MP_QSTR_buffering, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
-    { MP_QSTR_encoding, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
-};
-#define FILE_OPEN_NUM_ARGS MP_ARRAY_SIZE(file_open_args)
-
-STATIC mp_obj_t fdfile_open(const mp_obj_type_t *type, mp_arg_val_t *args) {
-    mp_obj_fdfile_t *o = m_new_obj(mp_obj_fdfile_t);
-    const char *mode_s = mp_obj_str_get_str(args[1].u_obj);
-
-    int mode_rw = 0, mode_x = 0;
-    while (*mode_s) {
-        switch (*mode_s++) {
-            case 'r':
-                mode_rw = O_RDONLY;
-                break;
-            case 'w':
-                mode_rw = O_WRONLY;
-                mode_x = O_CREAT | O_TRUNC;
-                break;
-            case 'a':
-                mode_rw = O_WRONLY;
-                mode_x = O_CREAT | O_APPEND;
-                break;
-            case '+':
-                mode_rw = O_RDWR;
-                break;
-            #if MICROPY_PY_IO_FILEIO
-            // If we don't have io.FileIO, then files are in text mode implicitly
-            case 'b':
-                type = &mp_type_fileio;
-                break;
-            case 't':
-                type = &mp_type_textio;
-                break;
-            #endif
-        }
-    }
-
-    o->base.type = type;
-
-    mp_obj_t fid = args[0].u_obj;
-
-    if (mp_obj_is_small_int(fid)) {
-        o->fd = MP_OBJ_SMALL_INT_VALUE(fid);
-        return MP_OBJ_FROM_PTR(o);
-    }
-
-    const char *fname = mp_obj_str_get_str(fid);
-    int fd = open(fname, mode_x | mode_rw, 0644);
-    if (fd == -1) {
-        mp_raise_OSError(errno);
-    }
-    o->fd = fd;
-    return MP_OBJ_FROM_PTR(o);
-}
-
-STATIC mp_obj_t fdfile_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
-    mp_arg_val_t arg_vals[FILE_OPEN_NUM_ARGS];
-    mp_arg_parse_all_kw_array(n_args, n_kw, args, FILE_OPEN_NUM_ARGS, file_open_args, arg_vals);
-    return fdfile_open(type, arg_vals);
-}
-
-STATIC const mp_rom_map_elem_t rawfile_locals_dict_table[] = {
-    { MP_ROM_QSTR(MP_QSTR_fileno), MP_ROM_PTR(&fdfile_fileno_obj) },
-    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
-    { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
-    { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
-    { MP_ROM_QSTR(MP_QSTR_readlines), MP_ROM_PTR(&mp_stream_unbuffered_readlines_obj) },
-    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
-    { MP_ROM_QSTR(MP_QSTR_seek), MP_ROM_PTR(&mp_stream_seek_obj) },
-    { MP_ROM_QSTR(MP_QSTR_tell), MP_ROM_PTR(&mp_stream_tell_obj) },
-    { MP_ROM_QSTR(MP_QSTR_flush), MP_ROM_PTR(&mp_stream_flush_obj) },
-    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
-    { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&mp_identity_obj) },
-    { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&fdfile___exit___obj) },
-};
-
-STATIC MP_DEFINE_CONST_DICT(rawfile_locals_dict, rawfile_locals_dict_table);
-
-#if MICROPY_PY_IO_FILEIO
-STATIC const mp_stream_p_t fileio_stream_p = {
-    .read = fdfile_read,
-    .write = fdfile_write,
-    .ioctl = fdfile_ioctl,
-};
-
-const mp_obj_type_t mp_type_fileio = {
-    { &mp_type_type },
-    .name = MP_QSTR_FileIO,
-    .print = fdfile_print,
-    .make_new = fdfile_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &fileio_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&rawfile_locals_dict,
-};
-#endif
-
-STATIC const mp_stream_p_t textio_stream_p = {
-    .read = fdfile_read,
-    .write = fdfile_write,
-    .ioctl = fdfile_ioctl,
-    .is_text = true,
-};
-
-const mp_obj_type_t mp_type_textio = {
-    { &mp_type_type },
-    .name = MP_QSTR_TextIOWrapper,
-    .print = fdfile_print,
-    .make_new = fdfile_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &textio_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&rawfile_locals_dict,
-};
-
-// Factory function for I/O stream classes
-mp_obj_t mp_builtin_open(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
-    // TODO: analyze buffering args and instantiate appropriate type
-    mp_arg_val_t arg_vals[FILE_OPEN_NUM_ARGS];
-    mp_arg_parse_all(n_args, args, kwargs, FILE_OPEN_NUM_ARGS, file_open_args, arg_vals);
-    return fdfile_open(&mp_type_textio, arg_vals);
-}
-MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
-
-const mp_obj_fdfile_t mp_sys_stdin_obj  = { .base = {&mp_type_textio}, .fd = STDIN_FILENO };
-const mp_obj_fdfile_t mp_sys_stdout_obj = { .base = {&mp_type_textio}, .fd = STDOUT_FILENO };
-const mp_obj_fdfile_t mp_sys_stderr_obj = { .base = {&mp_type_textio}, .fd = STDERR_FILENO };
-
-#endif // MICROPY_PY_IO && !MICROPY_VFS
diff --git a/ports/unix/gccollect.c b/ports/unix/gccollect.c
index 02f6fc91a8400..f0441e4ea3860 100644
--- a/ports/unix/gccollect.c
+++ b/ports/unix/gccollect.c
@@ -29,141 +29,15 @@
 #include "py/mpstate.h"
 #include "py/gc.h"
 
-#if MICROPY_ENABLE_GC
-
-// Even if we have specific support for an architecture, it is
-// possible to force use of setjmp-based implementation.
-#if !MICROPY_GCREGS_SETJMP
-
-// We capture here callee-save registers, i.e. ones which may contain
-// interesting values held there by our callers. It doesn't make sense
-// to capture caller-saved registers, because they, well, put on the
-// stack already by the caller.
-#if defined(__x86_64__)
-typedef mp_uint_t regs_t[6];
-
-STATIC void gc_helper_get_regs(regs_t arr) {
-    register long rbx asm ("rbx");
-    register long rbp asm ("rbp");
-    register long r12 asm ("r12");
-    register long r13 asm ("r13");
-    register long r14 asm ("r14");
-    register long r15 asm ("r15");
-#ifdef __clang__
-    // TODO:
-    // This is dirty workaround for Clang. It tries to get around
-    // uncompliant (wrt to GCC) behavior of handling register variables.
-    // Application of this patch here is random, and done only to unbreak
-    // MacOS build. Better, cross-arch ways to deal with Clang issues should
-    // be found.
-    asm("" : "=r"(rbx));
-    asm("" : "=r"(rbp));
-    asm("" : "=r"(r12));
-    asm("" : "=r"(r13));
-    asm("" : "=r"(r14));
-    asm("" : "=r"(r15));
-#endif
-    arr[0] = rbx;
-    arr[1] = rbp;
-    arr[2] = r12;
-    arr[3] = r13;
-    arr[4] = r14;
-    arr[5] = r15;
-}
-
-#elif defined(__i386__)
-
-typedef mp_uint_t regs_t[4];
-
-STATIC void gc_helper_get_regs(regs_t arr) {
-    register long ebx asm ("ebx");
-    register long esi asm ("esi");
-    register long edi asm ("edi");
-    register long ebp asm ("ebp");
-#ifdef __clang__
-    // TODO:
-    // This is dirty workaround for Clang. It tries to get around
-    // uncompliant (wrt to GCC) behavior of handling register variables.
-    // Application of this patch here is random, and done only to unbreak
-    // MacOS build. Better, cross-arch ways to deal with Clang issues should
-    // be found.
-    asm("" : "=r"(ebx));
-    asm("" : "=r"(esi));
-    asm("" : "=r"(edi));
-    asm("" : "=r"(ebp));
-#endif
-    arr[0] = ebx;
-    arr[1] = esi;
-    arr[2] = edi;
-    arr[3] = ebp;
-}
-
-#elif defined(__thumb2__) || defined(__thumb__) || defined(__arm__)
-
-typedef mp_uint_t regs_t[10];
-
-STATIC void gc_helper_get_regs(regs_t arr) {
-    register long r4 asm ("r4");
-    register long r5 asm ("r5");
-    register long r6 asm ("r6");
-    register long r7 asm ("r7");
-    register long r8 asm ("r8");
-    register long r9 asm ("r9");
-    register long r10 asm ("r10");
-    register long r11 asm ("r11");
-    register long r12 asm ("r12");
-    register long r13 asm ("r13");
-    arr[0] = r4;
-    arr[1] = r5;
-    arr[2] = r6;
-    arr[3] = r7;
-    arr[4] = r8;
-    arr[5] = r9;
-    arr[6] = r10;
-    arr[7] = r11;
-    arr[8] = r12;
-    arr[9] = r13;
-}
-
-#else
-
-// If we don't have architecture-specific optimized support,
-// just fall back to setjmp-based implementation.
-#undef MICROPY_GCREGS_SETJMP
-#define MICROPY_GCREGS_SETJMP (1)
-
-#endif // Arch-specific selection
-#endif // !MICROPY_GCREGS_SETJMP
-
-// If MICROPY_GCREGS_SETJMP was requested explicitly, or if
-// we enabled it as a fallback above.
-#if MICROPY_GCREGS_SETJMP
-#include <setjmp.h>
-
-typedef jmp_buf regs_t;
+#include "lib/utils/gchelper.h"
 
-STATIC void gc_helper_get_regs(regs_t arr) {
-    setjmp(arr);
-}
-
-#endif // MICROPY_GCREGS_SETJMP
-
-// this function is used by mpthreadport.c
-void gc_collect_regs_and_stack(void);
-
-void gc_collect_regs_and_stack(void) {
-    regs_t regs;
-    gc_helper_get_regs(regs);
-    // GC stack (and regs because we captured them)
-    void **regs_ptr = (void**)(void*)&regs;
-    gc_collect_root(regs_ptr, ((uintptr_t)MP_STATE_THREAD(stack_top) - (uintptr_t)&regs) / sizeof(uintptr_t));
-}
+#if MICROPY_ENABLE_GC
 
 void gc_collect(void) {
-    //gc_dump_info();
+    // gc_dump_info();
 
     gc_collect_start();
-    gc_collect_regs_and_stack();
+    gc_helper_collect_regs_and_stack();
     #if MICROPY_PY_THREAD
     mp_thread_gc_others();
     #endif
@@ -172,8 +46,8 @@ void gc_collect(void) {
     #endif
     gc_collect_end();
 
-    //printf("-----\n");
-    //gc_dump_info();
+    // printf("-----\n");
+    // gc_dump_info();
 }
 
-#endif //MICROPY_ENABLE_GC
+#endif // MICROPY_ENABLE_GC
diff --git a/ports/unix/input.c b/ports/unix/input.c
index 7d60b46cc7856..4a77d1b278159 100644
--- a/ports/unix/input.c
+++ b/ports/unix/input.c
@@ -24,6 +24,7 @@
  * THE SOFTWARE.
  */
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -59,7 +60,7 @@ char *prompt(char *p) {
 #endif
 
 void prompt_read_history(void) {
-#if MICROPY_USE_READLINE_HISTORY
+    #if MICROPY_USE_READLINE_HISTORY
     #if MICROPY_USE_READLINE == 1
     readline_init0(); // will clear history pointers
     char *home = getenv("HOME");
@@ -74,6 +75,9 @@ void prompt_read_history(void) {
                 char c;
                 int sz = read(fd, &c, 1);
                 if (sz < 0) {
+                    if (errno == EINTR) {
+                        continue;
+                    }
                     break;
                 }
                 if (sz == 0 || c == '\n') {
@@ -91,11 +95,11 @@ void prompt_read_history(void) {
         vstr_clear(&vstr);
     }
     #endif
-#endif
+    #endif
 }
 
 void prompt_write_history(void) {
-#if MICROPY_USE_READLINE_HISTORY
+    #if MICROPY_USE_READLINE_HISTORY
     #if MICROPY_USE_READLINE == 1
     char *home = getenv("HOME");
     if (home != NULL) {
@@ -107,15 +111,15 @@ void prompt_write_history(void) {
             for (int i = MP_ARRAY_SIZE(MP_STATE_PORT(readline_hist)) - 1; i >= 0; i--) {
                 const char *line = MP_STATE_PORT(readline_hist)[i];
                 if (line != NULL) {
-                    int res;
-                    res = write(fd, line, strlen(line));
-                    res = write(fd, "\n", 1);
-                    (void)res;
+                    while (write(fd, line, strlen(line)) == -1 && errno == EINTR) {
+                    }
+                    while (write(fd, "\n", 1) == -1 && errno == EINTR) {
+                    }
                 }
             }
             close(fd);
         }
     }
     #endif
-#endif
+    #endif
 }
diff --git a/ports/unix/main.c b/ports/unix/main.c
index 8d455fa834e4f..c38b7b0c287a9 100644
--- a/ports/unix/main.c
+++ b/ports/unix/main.c
@@ -4,6 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2014-2017 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -58,14 +59,14 @@ STATIC uint emit_opt = MP_EMIT_OPT_NONE;
 #if MICROPY_ENABLE_GC
 // Heap size of GC heap (if enabled)
 // Make it larger on a 64 bit machine, because pointers are larger.
-long heap_size = 1024*1024 * (sizeof(mp_uint_t) / 4);
+long heap_size = 1024 * 1024 * (sizeof(mp_uint_t) / 4);
 #endif
 
 STATIC void stderr_print_strn(void *env, const char *str, size_t len) {
     (void)env;
-    ssize_t dummy = write(STDERR_FILENO, str, len);
+    ssize_t ret;
+    MP_HAL_RETRY_SYSCALL(ret, write(STDERR_FILENO, str, len), {});
     mp_uos_dupterm_tx_strn(str, len);
-    (void)dummy;
 }
 
 const mp_print_t mp_stderr_print = {NULL, stderr_print_strn};
@@ -113,7 +114,7 @@ STATIC int execute_from_lexer(int source_kind, const void *source, mp_parse_inpu
             const vstr_t *vstr = source;
             lex = mp_lexer_new_from_str_len(MP_QSTR__lt_stdin_gt_, vstr->buf, vstr->len, false);
         } else if (source_kind == LEX_SRC_FILENAME) {
-            lex = mp_lexer_new_from_file((const char*)source);
+            lex = mp_lexer_new_from_file((const char *)source);
         } else { // LEX_SRC_STDIN
             lex = mp_lexer_new_from_fd(MP_QSTR__lt_stdin_gt_, 0, false);
         }
@@ -137,26 +138,22 @@ STATIC int execute_from_lexer(int source_kind, const void *source, mp_parse_inpu
         }
         #endif
 
-        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, emit_opt, is_repl);
+        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, is_repl);
 
         if (!compile_only) {
             // execute it
             mp_call_function_0(module_fun);
-            // check for pending exception
-            if (MP_STATE_VM(mp_pending_exception) != MP_OBJ_NULL) {
-                mp_obj_t obj = MP_STATE_VM(mp_pending_exception);
-                MP_STATE_VM(mp_pending_exception) = MP_OBJ_NULL;
-                nlr_raise(obj);
-            }
         }
 
         mp_hal_set_interrupt_char(-1);
+        mp_handle_pending(true);
         nlr_pop();
         return 0;
 
     } else {
         // uncaught exception
         mp_hal_set_interrupt_char(-1);
+        mp_handle_pending(false);
         return handle_uncaught_exception(nlr.ret_val);
     }
 }
@@ -300,32 +297,43 @@ STATIC int do_str(const char *str) {
     return execute_from_lexer(LEX_SRC_STR, str, MP_PARSE_FILE_INPUT, false);
 }
 
-STATIC int usage(char **argv) {
+STATIC void print_help(char **argv) {
     printf(
-"usage: %s [<opts>] [-X <implopt>] [-c <command>] [<filename>]\n"
-"Options:\n"
-"-v : verbose (trace various operations); can be multiple\n"
-"-O[N] : apply bytecode optimizations of level N\n"
-"\n"
-"Implementation specific options (-X):\n", argv[0]
-);
+        "usage: %s [<opts>] [-X <implopt>] [-c <command> | -m <module> | <filename>]\n"
+        "Options:\n"
+        "-h : print this help message\n"
+        "-i : enable inspection via REPL after running command/module/file\n"
+        #if MICROPY_DEBUG_PRINTERS
+        "-v : verbose (trace various operations); can be multiple\n"
+        #endif
+        "-O[N] : apply bytecode optimizations of level N\n"
+        "\n"
+        "Implementation specific options (-X):\n", argv[0]
+        );
     int impl_opts_cnt = 0;
     printf(
-"  compile-only                 -- parse and compile only\n"
-"  emit={bytecode,native,viper} -- set the default code emitter\n"
-);
+        "  compile-only                 -- parse and compile only\n"
+        #if MICROPY_EMIT_NATIVE
+        "  emit={bytecode,native,viper} -- set the default code emitter\n"
+        #else
+        "  emit=bytecode                -- set the default code emitter\n"
+        #endif
+        );
     impl_opts_cnt++;
-#if MICROPY_ENABLE_GC
+    #if MICROPY_ENABLE_GC
     printf(
-"  heapsize=<n>[w][K|M] -- set the heap size for the GC (default %ld)\n"
-, heap_size);
+        "  heapsize=<n>[w][K|M] -- set the heap size for the GC (default %ld)\n"
+        , heap_size);
     impl_opts_cnt++;
-#endif
+    #endif
 
     if (impl_opts_cnt == 0) {
         printf("  (none)\n");
     }
+}
 
+STATIC int invalid_args(void) {
+    fprintf(stderr, "Invalid command line arguments. Use -h option for help.\n");
     return 1;
 }
 
@@ -333,20 +341,26 @@ STATIC int usage(char **argv) {
 STATIC void pre_process_options(int argc, char **argv) {
     for (int a = 1; a < argc; a++) {
         if (argv[a][0] == '-') {
+            if (strcmp(argv[a], "-h") == 0) {
+                print_help(argv);
+                exit(0);
+            }
             if (strcmp(argv[a], "-X") == 0) {
                 if (a + 1 >= argc) {
-                    exit(usage(argv));
+                    exit(invalid_args());
                 }
                 if (0) {
                 } else if (strcmp(argv[a + 1], "compile-only") == 0) {
                     compile_only = true;
                 } else if (strcmp(argv[a + 1], "emit=bytecode") == 0) {
                     emit_opt = MP_EMIT_OPT_BYTECODE;
+                #if MICROPY_EMIT_NATIVE
                 } else if (strcmp(argv[a + 1], "emit=native") == 0) {
                     emit_opt = MP_EMIT_OPT_NATIVE_PYTHON;
                 } else if (strcmp(argv[a + 1], "emit=viper") == 0) {
                     emit_opt = MP_EMIT_OPT_VIPER;
-#if MICROPY_ENABLE_GC
+                #endif
+                #if MICROPY_ENABLE_GC
                 } else if (strncmp(argv[a + 1], "heapsize=", sizeof("heapsize=") - 1) == 0) {
                     char *end;
                     heap_size = strtol(argv[a + 1] + sizeof("heapsize=") - 1, &end, 0);
@@ -379,11 +393,10 @@ STATIC void pre_process_options(int argc, char **argv) {
                     if (heap_size < 700) {
                         goto invalid_arg;
                     }
-#endif
+                #endif
                 } else {
-invalid_arg:
-                    printf("Invalid option\n");
-                    exit(usage(argv));
+                invalid_arg:
+                    exit(invalid_args());
                 }
                 a++;
             }
@@ -437,10 +450,10 @@ MP_NOINLINE int main_(int argc, char **argv) {
 
     pre_process_options(argc, argv);
 
-#if MICROPY_ENABLE_GC
+    #if MICROPY_ENABLE_GC
     char *heap = malloc(heap_size);
     gc_init(heap, heap + heap_size);
-#endif
+    #endif
 
     #if MICROPY_ENABLE_PYSTACK
     static mp_obj_t pystack[1024];
@@ -449,6 +462,13 @@ MP_NOINLINE int main_(int argc, char **argv) {
 
     mp_init();
 
+    #if MICROPY_EMIT_NATIVE
+    // Set default emitter options
+    MP_STATE_VM(default_emit_opt) = emit_opt;
+    #else
+    (void)emit_opt;
+    #endif
+
     #if MICROPY_VFS_POSIX
     {
         // Mount the host FS at the root of our internal VFS
@@ -456,7 +476,7 @@ MP_NOINLINE int main_(int argc, char **argv) {
             mp_type_vfs_posix.make_new(&mp_type_vfs_posix, 0, 0, NULL),
             MP_OBJ_NEW_QSTR(MP_QSTR__slash_),
         };
-        mp_vfs_mount(2, args, (mp_map_t*)&mp_const_empty_map);
+        mp_vfs_mount(2, args, (mp_map_t *)&mp_const_empty_map);
         MP_STATE_VM(vfs_cur) = MP_STATE_VM(vfs_mount_table);
     }
     #endif
@@ -471,7 +491,7 @@ MP_NOINLINE int main_(int argc, char **argv) {
         #endif
     }
     size_t path_num = 1; // [0] is for current dir (or base dir of the script)
-    if (*path == ':') {
+    if (*path == PATHLIST_SEP_CHAR) {
         path_num++;
     }
     for (char *p = path; p != NULL; p = strchr(p, PATHLIST_SEP_CHAR)) {
@@ -485,25 +505,25 @@ MP_NOINLINE int main_(int argc, char **argv) {
     mp_obj_list_get(mp_sys_path, &path_num, &path_items);
     path_items[0] = MP_OBJ_NEW_QSTR(MP_QSTR_);
     {
-    char *p = path;
-    for (mp_uint_t i = 1; i < path_num; i++) {
-        char *p1 = strchr(p, PATHLIST_SEP_CHAR);
-        if (p1 == NULL) {
-            p1 = p + strlen(p);
-        }
-        if (p[0] == '~' && p[1] == '/' && home != NULL) {
-            // Expand standalone ~ to $HOME
-            int home_l = strlen(home);
-            vstr_t vstr;
-            vstr_init(&vstr, home_l + (p1 - p - 1) + 1);
-            vstr_add_strn(&vstr, home, home_l);
-            vstr_add_strn(&vstr, p + 1, p1 - p - 1);
-            path_items[i] = mp_obj_new_str_from_vstr(&mp_type_str, &vstr);
-        } else {
-            path_items[i] = mp_obj_new_str_via_qstr(p, p1 - p);
+        char *p = path;
+        for (mp_uint_t i = 1; i < path_num; i++) {
+            char *p1 = strchr(p, PATHLIST_SEP_CHAR);
+            if (p1 == NULL) {
+                p1 = p + strlen(p);
+            }
+            if (p[0] == '~' && p[1] == '/' && home != NULL) {
+                // Expand standalone ~ to $HOME
+                int home_l = strlen(home);
+                vstr_t vstr;
+                vstr_init(&vstr, home_l + (p1 - p - 1) + 1);
+                vstr_add_strn(&vstr, home, home_l);
+                vstr_add_strn(&vstr, p + 1, p1 - p - 1);
+                path_items[i] = mp_obj_new_str_from_vstr(&mp_type_str, &vstr);
+            } else {
+                path_items[i] = mp_obj_new_str_via_qstr(p, p1 - p);
+            }
+            p = p1 + 1;
         }
-        p = p1 + 1;
-    }
     }
 
     mp_obj_list_init(MP_OBJ_TO_PTR(mp_sys_argv), 0);
@@ -544,7 +564,7 @@ MP_NOINLINE int main_(int argc, char **argv) {
                 inspect = true;
             } else if (strcmp(argv[a], "-c") == 0) {
                 if (a + 1 >= argc) {
-                    return usage(argv);
+                    return invalid_args();
                 }
                 ret = do_str(argv[a + 1]);
                 if (ret & FORCED_EXIT) {
@@ -553,7 +573,7 @@ MP_NOINLINE int main_(int argc, char **argv) {
                 a += 1;
             } else if (strcmp(argv[a], "-m") == 0) {
                 if (a + 1 >= argc) {
-                    return usage(argv);
+                    return invalid_args();
                 }
                 mp_obj_t import_args[4];
                 import_args[0] = mp_obj_new_str(argv[a + 1], strlen(argv[a + 1]));
@@ -605,10 +625,11 @@ MP_NOINLINE int main_(int argc, char **argv) {
                     MP_STATE_VM(mp_optimise_value) = argv[a][2] & 0xf;
                 } else {
                     MP_STATE_VM(mp_optimise_value) = 0;
-                    for (char *p = argv[a] + 1; *p && *p == 'O'; p++, MP_STATE_VM(mp_optimise_value)++);
+                    for (char *p = argv[a] + 1; *p && *p == 'O'; p++, MP_STATE_VM(mp_optimise_value)++) {;
+                    }
                 }
             } else {
-                return usage(argv);
+                return invalid_args();
             }
         } else {
             char *pathbuf = malloc(PATH_MAX);
@@ -631,8 +652,12 @@ MP_NOINLINE int main_(int argc, char **argv) {
         }
     }
 
+    const char *inspect_env = getenv("MICROPYINSPECT");
+    if (inspect_env && inspect_env[0] != '\0') {
+        inspect = true;
+    }
     if (ret == NOTHING_EXECUTED || inspect) {
-        if (isatty(0)) {
+        if (isatty(0) || inspect) {
             prompt_read_history();
             ret = do_repl();
             prompt_write_history();
@@ -641,12 +666,28 @@ MP_NOINLINE int main_(int argc, char **argv) {
         }
     }
 
+    #if MICROPY_PY_SYS_SETTRACE
+    MP_STATE_THREAD(prof_trace_callback) = MP_OBJ_NULL;
+    #endif
+
+    #if MICROPY_PY_SYS_ATEXIT
+    // Beware, the sys.settrace callback should be disabled before running sys.atexit.
+    if (mp_obj_is_callable(MP_STATE_VM(sys_exitfunc))) {
+        mp_call_function_0(MP_STATE_VM(sys_exitfunc));
+    }
+    #endif
+
     #if MICROPY_PY_MICROPYTHON_MEM_INFO
     if (mp_verbose_flag) {
         mp_micropython_mem_info(0, NULL);
     }
     #endif
 
+    #if MICROPY_PY_BLUETOOTH
+    void mp_bluetooth_deinit(void);
+    mp_bluetooth_deinit();
+    #endif
+
     #if MICROPY_PY_THREAD
     mp_thread_deinit();
     #endif
@@ -657,13 +698,13 @@ MP_NOINLINE int main_(int argc, char **argv) {
 
     mp_deinit();
 
-#if MICROPY_ENABLE_GC && !defined(NDEBUG)
+    #if MICROPY_ENABLE_GC && !defined(NDEBUG)
     // We don't really need to free memory since we are about to exit the
     // process, but doing so helps to find memory leaks.
     free(heap);
-#endif
+    #endif
 
-    //printf("total bytes = %d\n", m_get_total_bytes_allocated());
+    // printf("total bytes = %d\n", m_get_total_bytes_allocated());
     return ret & 0xff;
 }
 
@@ -679,9 +720,27 @@ uint mp_import_stat(const char *path) {
     }
     return MP_IMPORT_STAT_NO_EXIST;
 }
+
+#if MICROPY_PY_IO
+// Factory function for I/O stream classes, only needed if generic VFS subsystem isn't used.
+// Note: buffering and encoding are currently ignored.
+mp_obj_t mp_builtin_open(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kwargs) {
+    enum { ARG_file, ARG_mode };
+    STATIC const mp_arg_t allowed_args[] = {
+        { MP_QSTR_file, MP_ARG_OBJ | MP_ARG_REQUIRED, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_mode, MP_ARG_OBJ, {.u_obj = MP_OBJ_NEW_QSTR(MP_QSTR_r)} },
+        { MP_QSTR_buffering, MP_ARG_INT, {.u_int = -1} },
+        { MP_QSTR_encoding, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kwargs, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    return mp_vfs_posix_file_open(&mp_type_textio, args[ARG_file].u_obj, args[ARG_mode].u_obj);
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
+#endif
 #endif
 
 void nlr_jump_fail(void *val) {
-    printf("FATAL: uncaught NLR %p\n", val);
+    fprintf(stderr, "FATAL: uncaught NLR %p\n", val);
     exit(1);
 }
diff --git a/ports/unix/manifest.py b/ports/unix/manifest.py
new file mode 100644
index 0000000000000..666b4c0ab3eee
--- /dev/null
+++ b/ports/unix/manifest.py
@@ -0,0 +1,2 @@
+freeze_as_mpy('$(MPY_DIR)/tools', 'upip.py')
+freeze_as_mpy('$(MPY_DIR)/tools', 'upip_utarfile.py', opt=3)
diff --git a/ports/unix/manifest_coverage.py b/ports/unix/manifest_coverage.py
new file mode 100644
index 0000000000000..0c32d08578e94
--- /dev/null
+++ b/ports/unix/manifest_coverage.py
@@ -0,0 +1,2 @@
+freeze_as_str('coverage-frzstr')
+freeze_as_mpy('coverage-frzmpy')
diff --git a/ports/unix/modffi.c b/ports/unix/modffi.c
index 0f8551e0a06d9..598a28cd54a02 100644
--- a/ports/unix/modffi.c
+++ b/ports/unix/modffi.c
@@ -4,7 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2013, 2014 Damien P. George
- * Copyright (c) 2014 Paul Sokolovsky
+ * Copyright (c) 2014-2018 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -91,41 +91,54 @@ typedef struct _mp_obj_fficallback_t {
     ffi_type *params[];
 } mp_obj_fficallback_t;
 
-//STATIC const mp_obj_type_t opaque_type;
+// STATIC const mp_obj_type_t opaque_type;
 STATIC const mp_obj_type_t ffimod_type;
 STATIC const mp_obj_type_t ffifunc_type;
 STATIC const mp_obj_type_t fficallback_type;
 STATIC const mp_obj_type_t ffivar_type;
 
-STATIC ffi_type *char2ffi_type(char c)
-{
+STATIC ffi_type *char2ffi_type(char c) {
     switch (c) {
-        case 'b': return &ffi_type_schar;
-        case 'B': return &ffi_type_uchar;
-        case 'h': return &ffi_type_sshort;
-        case 'H': return &ffi_type_ushort;
-        case 'i': return &ffi_type_sint;
-        case 'I': return &ffi_type_uint;
-        case 'l': return &ffi_type_slong;
-        case 'L': return &ffi_type_ulong;
-        case 'q': return &ffi_type_sint64;
-        case 'Q': return &ffi_type_uint64;
+        case 'b':
+            return &ffi_type_schar;
+        case 'B':
+            return &ffi_type_uchar;
+        case 'h':
+            return &ffi_type_sshort;
+        case 'H':
+            return &ffi_type_ushort;
+        case 'i':
+            return &ffi_type_sint;
+        case 'I':
+            return &ffi_type_uint;
+        case 'l':
+            return &ffi_type_slong;
+        case 'L':
+            return &ffi_type_ulong;
+        case 'q':
+            return &ffi_type_sint64;
+        case 'Q':
+            return &ffi_type_uint64;
         #if MICROPY_PY_BUILTINS_FLOAT
-        case 'f': return &ffi_type_float;
-        case 'd': return &ffi_type_double;
+        case 'f':
+            return &ffi_type_float;
+        case 'd':
+            return &ffi_type_double;
         #endif
         case 'O': // mp_obj_t
         case 'C': // (*)()
         case 'P': // const void*
         case 'p': // void*
-        case 's': return &ffi_type_pointer;
-        case 'v': return &ffi_type_void;
-        default: return NULL;
+        case 's':
+            return &ffi_type_pointer;
+        case 'v':
+            return &ffi_type_void;
+        default:
+            return NULL;
     }
 }
 
-STATIC ffi_type *get_ffi_type(mp_obj_t o_in)
-{
+STATIC ffi_type *get_ffi_type(mp_obj_t o_in) {
     if (mp_obj_is_str(o_in)) {
         const char *s = mp_obj_str_get_str(o_in);
         ffi_type *t = char2ffi_type(*s);
@@ -135,11 +148,10 @@ STATIC ffi_type *get_ffi_type(mp_obj_t o_in)
     }
     // TODO: Support actual libffi type objects
 
-    mp_raise_TypeError("Unknown type");
+    mp_raise_TypeError(MP_ERROR_TEXT("unknown type"));
 }
 
-STATIC mp_obj_t return_ffi_value(ffi_arg val, char type)
-{
+STATIC mp_obj_t return_ffi_value(ffi_arg val, char type) {
     switch (type) {
         case 's': {
             const char *s = (const char *)(intptr_t)val;
@@ -152,12 +164,14 @@ STATIC mp_obj_t return_ffi_value(ffi_arg val, char type)
             return mp_const_none;
         #if MICROPY_PY_BUILTINS_FLOAT
         case 'f': {
-            union { ffi_arg ffi; float flt; } val_union = { .ffi = val };
-            return mp_obj_new_float(val_union.flt);
+            union { ffi_arg ffi;
+                    float flt;
+            } val_union = { .ffi = val };
+            return mp_obj_new_float_from_f(val_union.flt);
         }
         case 'd': {
-            double *p = (double*)&val;
-            return mp_obj_new_float(*p);
+            double *p = (double *)&val;
+            return mp_obj_new_float_from_d(*p);
         }
         #endif
         case 'O':
@@ -187,7 +201,7 @@ STATIC mp_obj_t make_func(mp_obj_t rettype_in, void *func, mp_obj_t argtypes_in)
     const char *argtypes = mp_obj_str_get_str(argtypes_in);
 
     mp_int_t nparams = MP_OBJ_SMALL_INT_VALUE(mp_obj_len_maybe(argtypes_in));
-    mp_obj_ffifunc_t *o = m_new_obj_var(mp_obj_ffifunc_t, ffi_type*, nparams);
+    mp_obj_ffifunc_t *o = m_new_obj_var(mp_obj_ffifunc_t, ffi_type *, nparams);
     o->base.type = &ffifunc_type;
 
     o->func = func;
@@ -204,7 +218,7 @@ STATIC mp_obj_t make_func(mp_obj_t rettype_in, void *func, mp_obj_t argtypes_in)
 
     int res = ffi_prep_cif(&o->cif, FFI_DEFAULT_ABI, nparams, char2ffi_type(*rettype), o->params);
     if (res != FFI_OK) {
-        mp_raise_ValueError("Error in ffi_prep_cif");
+        mp_raise_ValueError(MP_ERROR_TEXT("error in ffi_prep_cif"));
     }
 
     return MP_OBJ_FROM_PTR(o);
@@ -224,20 +238,20 @@ STATIC mp_obj_t ffimod_func(size_t n_args, const mp_obj_t *args) {
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(ffimod_func_obj, 4, 4, ffimod_func);
 
 STATIC mp_obj_t mod_ffi_func(mp_obj_t rettype, mp_obj_t addr_in, mp_obj_t argtypes) {
-    void *addr = (void*)MP_OBJ_TO_PTR(mp_obj_int_get_truncated(addr_in));
+    void *addr = (void *)MP_OBJ_TO_PTR(mp_obj_int_get_truncated(addr_in));
     return make_func(rettype, addr, argtypes);
 }
 MP_DEFINE_CONST_FUN_OBJ_3(mod_ffi_func_obj, mod_ffi_func);
 
-STATIC void call_py_func(ffi_cif *cif, void *ret, void** args, void *func) {
+STATIC void call_py_func(ffi_cif *cif, void *ret, void **args, void *func) {
     mp_obj_t pyargs[cif->nargs];
     for (uint i = 0; i < cif->nargs; i++) {
-        pyargs[i] = mp_obj_new_int(*(mp_int_t*)args[i]);
+        pyargs[i] = mp_obj_new_int(*(mp_int_t *)args[i]);
     }
     mp_obj_t res = mp_call_function_n_kw(MP_OBJ_FROM_PTR(func), cif->nargs, 0, pyargs);
 
     if (res != mp_const_none) {
-        *(ffi_arg*)ret = mp_obj_int_get_truncated(res);
+        *(ffi_arg *)ret = mp_obj_int_get_truncated(res);
     }
 }
 
@@ -245,7 +259,7 @@ STATIC mp_obj_t mod_ffi_callback(mp_obj_t rettype_in, mp_obj_t func_in, mp_obj_t
     const char *rettype = mp_obj_str_get_str(rettype_in);
 
     mp_int_t nparams = MP_OBJ_SMALL_INT_VALUE(mp_obj_len_maybe(paramtypes_in));
-    mp_obj_fficallback_t *o = m_new_obj_var(mp_obj_fficallback_t, ffi_type*, nparams);
+    mp_obj_fficallback_t *o = m_new_obj_var(mp_obj_fficallback_t, ffi_type *, nparams);
     o->base.type = &fficallback_type;
 
     o->clo = ffi_closure_alloc(sizeof(ffi_closure), &o->func);
@@ -262,12 +276,12 @@ STATIC mp_obj_t mod_ffi_callback(mp_obj_t rettype_in, mp_obj_t func_in, mp_obj_t
 
     int res = ffi_prep_cif(&o->cif, FFI_DEFAULT_ABI, nparams, char2ffi_type(*rettype), o->params);
     if (res != FFI_OK) {
-        mp_raise_ValueError("Error in ffi_prep_cif");
+        mp_raise_ValueError(MP_ERROR_TEXT("error in ffi_prep_cif"));
     }
 
     res = ffi_prep_closure_loc(o->clo, &o->cif, call_py_func, MP_OBJ_TO_PTR(func_in), o->func);
     if (res != FFI_OK) {
-        mp_raise_ValueError("ffi_prep_closure_loc");
+        mp_raise_ValueError(MP_ERROR_TEXT("ffi_prep_closure_loc"));
     }
 
     return MP_OBJ_FROM_PTR(o);
@@ -337,7 +351,7 @@ STATIC const mp_obj_type_t ffimod_type = {
     .name = MP_QSTR_ffimod,
     .print = ffimod_print,
     .make_new = ffimod_make_new,
-    .locals_dict = (mp_obj_dict_t*)&ffimod_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&ffimod_locals_dict,
 };
 
 // FFI function
@@ -363,11 +377,11 @@ STATIC mp_obj_t ffifunc_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const
             values[i] = (ffi_arg)(intptr_t)a;
         #if MICROPY_PY_BUILTINS_FLOAT
         } else if (*argtype == 'f') {
-            float *p = (float*)&values[i];
-            *p = mp_obj_get_float(a);
+            float *p = (float *)&values[i];
+            *p = mp_obj_get_float_to_f(a);
         } else if (*argtype == 'd') {
-            double *p = (double*)&values[i];
-            *p = mp_obj_get_float(a);
+            double *p = (double *)&values[i];
+            *p = mp_obj_get_float_to_d(a);
         #endif
         } else if (a == mp_const_none) {
             values[i] = 0;
@@ -376,8 +390,8 @@ STATIC mp_obj_t ffifunc_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const
         } else if (mp_obj_is_str(a)) {
             const char *s = mp_obj_str_get_str(a);
             values[i] = (ffi_arg)(intptr_t)s;
-        } else if (((mp_obj_base_t*)MP_OBJ_TO_PTR(a))->type->buffer_p.get_buffer != NULL) {
-            mp_obj_base_t *o = (mp_obj_base_t*)MP_OBJ_TO_PTR(a);
+        } else if (((mp_obj_base_t *)MP_OBJ_TO_PTR(a))->type->buffer_p.get_buffer != NULL) {
+            mp_obj_base_t *o = (mp_obj_base_t *)MP_OBJ_TO_PTR(a);
             mp_buffer_info_t bufinfo;
             int ret = o->type->buffer_p.get_buffer(MP_OBJ_FROM_PTR(o), &bufinfo, MP_BUFFER_READ); // TODO: MP_BUFFER_READ?
             if (ret != 0) {
@@ -401,7 +415,7 @@ STATIC mp_obj_t ffifunc_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const
     if (sizeof(ffi_arg) == 4 && self->rettype == 'd') {
         double retval;
         ffi_call(&self->cif, self->func, &retval, valueptrs);
-        return mp_obj_new_float(retval);
+        return mp_obj_new_float_from_d(retval);
     } else
     #endif
     {
@@ -411,7 +425,7 @@ STATIC mp_obj_t ffifunc_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const
     }
 
 error:
-    mp_raise_TypeError("Don't know how to pass object to native function");
+    mp_raise_TypeError(MP_ERROR_TEXT("don't know how to pass object to native function"));
 }
 
 STATIC const mp_obj_type_t ffifunc_type = {
@@ -441,7 +455,7 @@ STATIC void ffivar_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kin
     (void)kind;
     mp_obj_ffivar_t *self = MP_OBJ_TO_PTR(self_in);
     // Variable value printed as cast to int
-    mp_printf(print, "<ffivar @%p: 0x%x>", self->var, *(int*)self->var);
+    mp_printf(print, "<ffivar @%p: 0x%x>", self->var, *(int *)self->var);
 }
 
 STATIC mp_obj_t ffivar_get(mp_obj_t self_in) {
@@ -468,7 +482,7 @@ STATIC const mp_obj_type_t ffivar_type = {
     { &mp_type_type },
     .name = MP_QSTR_ffivar,
     .print = ffivar_print,
-    .locals_dict = (mp_obj_dict_t*)&ffivar_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&ffivar_locals_dict,
 };
 
 // Generic opaque storage object (unused)
@@ -487,7 +501,7 @@ STATIC mp_obj_t mod_ffi_open(size_t n_args, const mp_obj_t *args) {
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_ffi_open_obj, 1, 2, mod_ffi_open);
 
 STATIC mp_obj_t mod_ffi_as_bytearray(mp_obj_t ptr, mp_obj_t size) {
-    return mp_obj_new_bytearray_by_ref(mp_obj_int_get_truncated(size), (void*)(uintptr_t)mp_obj_int_get_truncated(ptr));
+    return mp_obj_new_bytearray_by_ref(mp_obj_int_get_truncated(size), (void *)(uintptr_t)mp_obj_int_get_truncated(ptr));
 }
 MP_DEFINE_CONST_FUN_OBJ_2(mod_ffi_as_bytearray_obj, mod_ffi_as_bytearray);
 
@@ -503,5 +517,5 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_ffi_globals, mp_module_ffi_globals_table);
 
 const mp_obj_module_t mp_module_ffi = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_ffi_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_ffi_globals,
 };
diff --git a/ports/unix/modjni.c b/ports/unix/modjni.c
index 902c34f10b993..74e7221de3037 100644
--- a/ports/unix/modjni.c
+++ b/ports/unix/modjni.c
@@ -98,7 +98,7 @@ STATIC bool is_object_type(const char *jtypesig) {
 STATIC void check_exception(void) {
     jobject exc = JJ1(ExceptionOccurred);
     if (exc) {
-        //JJ1(ExceptionDescribe);
+        // JJ1(ExceptionDescribe);
         mp_obj_t py_e = new_jobject(exc);
         JJ1(ExceptionClear);
         if (JJ(IsInstanceOf, exc, IndexException_class)) {
@@ -142,7 +142,7 @@ STATIC void jclass_attr(mp_obj_t self_in, qstr attr_in, mp_obj_t *dest) {
             dest[0] = new_jobject(obj);
             return;
         }
-        //JJ1(ExceptionDescribe);
+        // JJ1(ExceptionDescribe);
         JJ1(ExceptionClear);
 
         mp_obj_jmethod_t *o = m_new_obj(mp_obj_jmethod_t);
@@ -157,7 +157,7 @@ STATIC void jclass_attr(mp_obj_t self_in, qstr attr_in, mp_obj_t *dest) {
 
 STATIC mp_obj_t jclass_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     if (n_kw != 0) {
-        mp_raise_TypeError("kwargs not supported");
+        mp_raise_TypeError(MP_ERROR_TEXT("kwargs not supported"));
     }
     mp_obj_jclass_t *self = MP_OBJ_TO_PTR(self_in);
 
@@ -179,7 +179,7 @@ STATIC const mp_obj_type_t jclass_type = {
     .print = jclass_print,
     .attr = jclass_attr,
     .call = jclass_call,
-    .locals_dict = (mp_obj_dict_t*)&jclass_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&jclass_locals_dict,
 };
 
 STATIC mp_obj_t new_jclass(jclass jc) {
@@ -220,7 +220,7 @@ STATIC void jobject_attr(mp_obj_t self_in, qstr attr_in, mp_obj_t *dest) {
             dest[0] = new_jobject(obj);
             return;
         }
-        //JJ1(ExceptionDescribe);
+        // JJ1(ExceptionDescribe);
         JJ1(ExceptionClear);
 
         mp_obj_jmethod_t *o = m_new_obj(mp_obj_jmethod_t);
@@ -246,7 +246,7 @@ STATIC mp_obj_t jobject_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value)
     mp_uint_t idx = mp_obj_get_int(index);
     char class_name[64];
     get_jclass_name(self->obj, class_name);
-    //printf("class: %s\n", class_name);
+    // printf("class: %s\n", class_name);
 
     if (class_name[0] == '[') {
         if (class_name[1] == 'L' || class_name[1] == '[') {
@@ -288,7 +288,7 @@ STATIC mp_obj_t jobject_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value)
     }
 
 
-return MP_OBJ_NULL;
+    return MP_OBJ_NULL;
 }
 
 STATIC mp_obj_t jobject_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
@@ -364,10 +364,10 @@ STATIC void jmethod_print(const mp_print_t *print, mp_obj_t self_in, mp_print_ki
 #define IMATCH(s, static) ((!strncmp(s, static, sizeof(static) - 1)) && (s += sizeof(static) - 1))
 
 #define CHECK_TYPE(java_type_name) \
-                if (strncmp(arg_type, java_type_name, sizeof(java_type_name) - 1) != 0) { \
-                    return false; \
-                } \
-                arg_type += sizeof(java_type_name) - 1;
+    if (strncmp(arg_type, java_type_name, sizeof(java_type_name) - 1) != 0) { \
+        return false; \
+    } \
+    arg_type += sizeof(java_type_name) - 1;
 
 STATIC const char *strprev(const char *s, char c) {
     while (*s != c) {
@@ -412,7 +412,7 @@ STATIC bool py2jvalue(const char **jtypesig, mp_obj_t arg, jvalue *out) {
         if (!MATCH(expected_type, "java.lang.Object")) {
             char class_name[64];
             get_jclass_name(jo->obj, class_name);
-            //printf("Arg class: %s\n", class_name);
+            // printf("Arg class: %s\n", class_name);
             if (strcmp(class_name, expected_type) != 0) {
                 return false;
             }
@@ -425,13 +425,13 @@ STATIC bool py2jvalue(const char **jtypesig, mp_obj_t arg, jvalue *out) {
             return false;
         }
     } else if (arg == mp_const_none) {
-        //printf("TODO: Check java arg type!!\n");
+        // printf("TODO: Check java arg type!!\n");
         while (isalpha(*arg_type) || *arg_type == '.') {
             arg_type++;
         }
         out->l = NULL;
     } else {
-        mp_raise_TypeError("arg type not supported");
+        mp_raise_TypeError(MP_ERROR_TEXT("arg type not supported"));
     }
 
     *jtypesig = arg_type;
@@ -470,7 +470,7 @@ STATIC mp_obj_t call_method(jobject obj, const char *name, jarray methods, bool
         jobject name_o = JJ(CallObjectMethod, meth, Object_toString_mid);
         const char *decl = JJ(GetStringUTFChars, name_o, NULL);
         const char *arg_types = strchr(decl, '(') + 1;
-        //const char *arg_types_end = strchr(arg_types, ')');
+        // const char *arg_types_end = strchr(arg_types, ')');
 //        printf("method[%d]=%p %s\n", i, meth, decl);
 
         const char *meth_name = NULL;
@@ -481,7 +481,7 @@ STATIC mp_obj_t call_method(jobject obj, const char *name, jarray methods, bool
             ret_type = strprev(ret_type, ' ') + 1;
 
             int name_len = strlen(name);
-            if (strncmp(name, meth_name, name_len/*arg_types - meth_name - 1*/) || meth_name[name_len] != '('/*(*/) {
+            if (strncmp(name, meth_name, name_len /*arg_types - meth_name - 1*/) || meth_name[name_len] != '(' /*(*/) {
                 goto next_method;
             }
         }
@@ -531,7 +531,7 @@ STATIC mp_obj_t call_method(jobject obj, const char *name, jarray methods, bool
                     ret = new_jobject(res);
                 } else {
                     JJ(ReleaseStringUTFChars, name_o, decl);
-                    mp_raise_TypeError("cannot handle return type");
+                    mp_raise_TypeError(MP_ERROR_TEXT("can't handle return type"));
                 }
 
                 JJ(ReleaseStringUTFChars, name_o, decl);
@@ -541,19 +541,19 @@ STATIC mp_obj_t call_method(jobject obj, const char *name, jarray methods, bool
             }
         }
 
-next_method:
+    next_method:
         JJ(ReleaseStringUTFChars, name_o, decl);
         JJ(DeleteLocalRef, name_o);
         JJ(DeleteLocalRef, meth);
     }
 
-    mp_raise_TypeError("method not found");
+    mp_raise_TypeError(MP_ERROR_TEXT("method not found"));
 }
 
 
 STATIC mp_obj_t jmethod_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     if (n_kw != 0) {
-        mp_raise_TypeError("kwargs not supported");
+        mp_raise_TypeError(MP_ERROR_TEXT("kwargs not supported"));
     }
     mp_obj_jmethod_t *self = MP_OBJ_TO_PTR(self_in);
 
@@ -599,13 +599,13 @@ STATIC void create_jvm(void) {
 
     void *libjvm = dlopen(LIBJVM_SO, RTLD_NOW | RTLD_GLOBAL);
     if (!libjvm) {
-        mp_raise_msg(&mp_type_OSError, "unable to load libjvm.so, use LD_LIBRARY_PATH");
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("unable to load libjvm.so, use LD_LIBRARY_PATH"));
     }
-    int (*_JNI_CreateJavaVM)(void*, void**, void*) = dlsym(libjvm, "JNI_CreateJavaVM");
+    int (*_JNI_CreateJavaVM)(void *, void **, void *) = dlsym(libjvm, "JNI_CreateJavaVM");
 
-    int st = _JNI_CreateJavaVM(&jvm, (void**)&env, &args);
+    int st = _JNI_CreateJavaVM(&jvm, (void **)&env, &args);
     if (st < 0 || !env) {
-        mp_raise_msg(&mp_type_OSError, "unable to create JVM");
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("unable to create JVM"));
     }
 
     Class_class = JJ(FindClass, "java/lang/Class");
@@ -614,26 +614,26 @@ STATIC void create_jvm(void) {
 
     jclass Object_class = JJ(FindClass, "java/lang/Object");
     Object_toString_mid = JJ(GetMethodID, Object_class, "toString",
-                                     "()Ljava/lang/String;");
+        MP_ERROR_TEXT("()Ljava/lang/String;"));
 
     Class_getName_mid = (*env)->GetMethodID(env, Class_class, "getName",
-                                     "()Ljava/lang/String;");
+        MP_ERROR_TEXT("()Ljava/lang/String;"));
     Class_getField_mid = (*env)->GetMethodID(env, Class_class, "getField",
-                                     "(Ljava/lang/String;)Ljava/lang/reflect/Field;");
+        MP_ERROR_TEXT("(Ljava/lang/String;)Ljava/lang/reflect/Field;"));
     Class_getMethods_mid = (*env)->GetMethodID(env, Class_class, "getMethods",
-                                     "()[Ljava/lang/reflect/Method;");
+        MP_ERROR_TEXT("()[Ljava/lang/reflect/Method;"));
     Class_getConstructors_mid = (*env)->GetMethodID(env, Class_class, "getConstructors",
-                                     "()[Ljava/lang/reflect/Constructor;");
+        MP_ERROR_TEXT("()[Ljava/lang/reflect/Constructor;"));
     Method_getName_mid = (*env)->GetMethodID(env, method_class, "getName",
-                                     "()Ljava/lang/String;");
+        MP_ERROR_TEXT("()Ljava/lang/String;"));
 
     List_class = JJ(FindClass, "java/util/List");
     List_get_mid = JJ(GetMethodID, List_class, "get",
-                                     "(I)Ljava/lang/Object;");
+        MP_ERROR_TEXT("(I)Ljava/lang/Object;"));
     List_set_mid = JJ(GetMethodID, List_class, "set",
-                                     "(ILjava/lang/Object;)Ljava/lang/Object;");
+        MP_ERROR_TEXT("(ILjava/lang/Object;)Ljava/lang/Object;"));
     List_size_mid = JJ(GetMethodID, List_class, "size",
-                                     "()I");
+        MP_ERROR_TEXT("()I"));
     IndexException_class = JJ(FindClass, "java/lang/IndexOutOfBoundsException");
 }
 
@@ -715,5 +715,5 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_jni_globals, mp_module_jni_globals_table);
 
 const mp_obj_module_t mp_module_jni = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_jni_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_jni_globals,
 };
diff --git a/ports/unix/modmachine.c b/ports/unix/modmachine.c
index e2c44f94c26ab..a6eb8c01edd05 100644
--- a/ports/unix/modmachine.c
+++ b/ports/unix/modmachine.c
@@ -4,6 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2015 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -48,7 +49,7 @@
 uintptr_t mod_machine_mem_get_addr(mp_obj_t addr_o, uint align) {
     uintptr_t addr = mp_obj_int_get_truncated(addr_o);
     if ((addr & (align - 1)) != 0) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "address %08x is not aligned to %d bytes", addr, align));
+        mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("address %08x is not aligned to %d bytes"), addr, align);
     }
     #if MICROPY_PLAT_DEV_MEM
     {
@@ -76,6 +77,14 @@ uintptr_t mod_machine_mem_get_addr(mp_obj_t addr_o, uint align) {
     return addr;
 }
 
+#ifdef MICROPY_UNIX_MACHINE_IDLE
+STATIC mp_obj_t machine_idle(void) {
+    MICROPY_UNIX_MACHINE_IDLE
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_0(machine_idle_obj, machine_idle);
+#endif
+
 STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_umachine) },
 
@@ -83,6 +92,10 @@ STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_mem16), MP_ROM_PTR(&machine_mem16_obj) },
     { MP_ROM_QSTR(MP_QSTR_mem32), MP_ROM_PTR(&machine_mem32_obj) },
 
+    #ifdef MICROPY_UNIX_MACHINE_IDLE
+    { MP_ROM_QSTR(MP_QSTR_idle), MP_ROM_PTR(&machine_idle_obj) },
+    #endif
+
     { MP_ROM_QSTR(MP_QSTR_PinBase), MP_ROM_PTR(&machine_pinbase_type) },
     { MP_ROM_QSTR(MP_QSTR_Signal), MP_ROM_PTR(&machine_signal_type) },
     #if MICROPY_PY_MACHINE_PULSE
@@ -94,7 +107,7 @@ STATIC MP_DEFINE_CONST_DICT(machine_module_globals, machine_module_globals_table
 
 const mp_obj_module_t mp_module_machine = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&machine_module_globals,
+    .globals = (mp_obj_dict_t *)&machine_module_globals,
 };
 
 #endif // MICROPY_PY_MACHINE
diff --git a/ports/unix/modos.c b/ports/unix/modos.c
index d7ba1cfa1efc1..82b1b11425679 100644
--- a/ports/unix/modos.c
+++ b/ports/unix/modos.c
@@ -3,8 +3,8 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
- * Copyright (c) 2014 Paul Sokolovsky
+ * Copyright (c) 2014-2018 Paul Sokolovsky
+ * Copyright (c) 2014-2018 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -29,14 +29,19 @@
 #include <sys/stat.h>
 #include <unistd.h>
 #include <errno.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <dirent.h>
+#ifdef _MSC_VER
+#include <direct.h> // For mkdir
+#endif
 #include "py/mpconfig.h"
 
 #include "py/runtime.h"
 #include "py/objtuple.h"
 #include "py/mphal.h"
+#include "py/mpthread.h"
 #include "extmod/vfs.h"
 #include "extmod/misc.h"
 
@@ -48,8 +53,8 @@ STATIC mp_obj_t mod_os_stat(mp_obj_t path_in) {
     struct stat sb;
     const char *path = mp_obj_str_get_str(path_in);
 
-    int res = stat(path, &sb);
-    RAISE_ERRNO(res, errno);
+    int res;
+    MP_HAL_RETRY_SYSCALL(res, stat(path, &sb), mp_raise_OSError(err));
 
     mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
     t->items[0] = MP_OBJ_NEW_SMALL_INT(sb.st_mode);
@@ -88,8 +93,8 @@ STATIC mp_obj_t mod_os_statvfs(mp_obj_t path_in) {
     STRUCT_STATVFS sb;
     const char *path = mp_obj_str_get_str(path_in);
 
-    int res = STATVFS(path, &sb);
-    RAISE_ERRNO(res, errno);
+    int res;
+    MP_HAL_RETRY_SYSCALL(res, STATVFS(path, &sb), mp_raise_OSError(err));
 
     mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
     t->items[0] = MP_OBJ_NEW_SMALL_INT(sb.f_bsize);
@@ -115,7 +120,9 @@ STATIC mp_obj_t mod_os_remove(mp_obj_t path_in) {
     // of that function. But Python remove() follows ANSI C, and explicitly
     // required to raise exception on attempt to remove a directory. Thus,
     // call POSIX unlink() here.
+    MP_THREAD_GIL_EXIT();
     int r = unlink(path);
+    MP_THREAD_GIL_ENTER();
 
     RAISE_ERRNO(r, errno);
 
@@ -123,10 +130,39 @@ STATIC mp_obj_t mod_os_remove(mp_obj_t path_in) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_os_remove_obj, mod_os_remove);
 
+STATIC mp_obj_t mod_os_rename(mp_obj_t old_path_in, mp_obj_t new_path_in) {
+    const char *old_path = mp_obj_str_get_str(old_path_in);
+    const char *new_path = mp_obj_str_get_str(new_path_in);
+
+    MP_THREAD_GIL_EXIT();
+    int r = rename(old_path, new_path);
+    MP_THREAD_GIL_ENTER();
+
+    RAISE_ERRNO(r, errno);
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_os_rename_obj, mod_os_rename);
+
+STATIC mp_obj_t mod_os_rmdir(mp_obj_t path_in) {
+    const char *path = mp_obj_str_get_str(path_in);
+
+    MP_THREAD_GIL_EXIT();
+    int r = rmdir(path);
+    MP_THREAD_GIL_ENTER();
+
+    RAISE_ERRNO(r, errno);
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_os_rmdir_obj, mod_os_rmdir);
+
 STATIC mp_obj_t mod_os_system(mp_obj_t cmd_in) {
     const char *cmd = mp_obj_str_get_str(cmd_in);
 
+    MP_THREAD_GIL_EXIT();
     int r = system(cmd);
+    MP_THREAD_GIL_ENTER();
 
     RAISE_ERRNO(r, errno);
 
@@ -143,14 +179,51 @@ STATIC mp_obj_t mod_os_getenv(mp_obj_t var_in) {
 }
 MP_DEFINE_CONST_FUN_OBJ_1(mod_os_getenv_obj, mod_os_getenv);
 
+STATIC mp_obj_t mod_os_putenv(mp_obj_t key_in, mp_obj_t value_in) {
+    const char *key = mp_obj_str_get_str(key_in);
+    const char *value = mp_obj_str_get_str(value_in);
+    int ret;
+
+    #if _WIN32
+    ret = _putenv_s(key, value);
+    #else
+    ret = setenv(key, value, 1);
+    #endif
+
+    if (ret == -1) {
+        mp_raise_OSError(errno);
+    }
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(mod_os_putenv_obj, mod_os_putenv);
+
+STATIC mp_obj_t mod_os_unsetenv(mp_obj_t key_in) {
+    const char *key = mp_obj_str_get_str(key_in);
+    int ret;
+
+    #if _WIN32
+    ret = _putenv_s(key, "");
+    #else
+    ret = unsetenv(key);
+    #endif
+
+    if (ret == -1) {
+        mp_raise_OSError(errno);
+    }
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_1(mod_os_unsetenv_obj, mod_os_unsetenv);
+
 STATIC mp_obj_t mod_os_mkdir(mp_obj_t path_in) {
     // TODO: Accept mode param
     const char *path = mp_obj_str_get_str(path_in);
+    MP_THREAD_GIL_EXIT();
     #ifdef _WIN32
     int r = mkdir(path);
     #else
     int r = mkdir(path, 0777);
     #endif
+    MP_THREAD_GIL_ENTER();
     RAISE_ERRNO(r, errno);
     return mp_const_none;
 }
@@ -168,13 +241,16 @@ STATIC mp_obj_t listdir_next(mp_obj_t self_in) {
     if (self->dir == NULL) {
         goto done;
     }
+    MP_THREAD_GIL_EXIT();
     struct dirent *dirent = readdir(self->dir);
     if (dirent == NULL) {
         closedir(self->dir);
+        MP_THREAD_GIL_ENTER();
         self->dir = NULL;
     done:
         return MP_OBJ_STOP_ITERATION;
     }
+    MP_THREAD_GIL_ENTER();
 
     mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
     t->items[0] = mp_obj_new_str(dirent->d_name, strlen(dirent->d_name));
@@ -211,7 +287,9 @@ STATIC mp_obj_t mod_os_ilistdir(size_t n_args, const mp_obj_t *args) {
     }
     mp_obj_listdir_t *o = m_new_obj(mp_obj_listdir_t);
     o->base.type = &mp_type_polymorph_iter;
+    MP_THREAD_GIL_EXIT();
     o->dir = opendir(path);
+    MP_THREAD_GIL_ENTER();
     o->iternext = listdir_next;
     return MP_OBJ_FROM_PTR(o);
 }
@@ -236,7 +314,11 @@ STATIC const mp_rom_map_elem_t mp_module_os_globals_table[] = {
     #endif
     { MP_ROM_QSTR(MP_QSTR_system), MP_ROM_PTR(&mod_os_system_obj) },
     { MP_ROM_QSTR(MP_QSTR_remove), MP_ROM_PTR(&mod_os_remove_obj) },
+    { MP_ROM_QSTR(MP_QSTR_rename), MP_ROM_PTR(&mod_os_rename_obj) },
+    { MP_ROM_QSTR(MP_QSTR_rmdir), MP_ROM_PTR(&mod_os_rmdir_obj) },
     { MP_ROM_QSTR(MP_QSTR_getenv), MP_ROM_PTR(&mod_os_getenv_obj) },
+    { MP_ROM_QSTR(MP_QSTR_putenv), MP_ROM_PTR(&mod_os_putenv_obj) },
+    { MP_ROM_QSTR(MP_QSTR_unsetenv), MP_ROM_PTR(&mod_os_unsetenv_obj) },
     { MP_ROM_QSTR(MP_QSTR_mkdir), MP_ROM_PTR(&mod_os_mkdir_obj) },
     { MP_ROM_QSTR(MP_QSTR_ilistdir), MP_ROM_PTR(&mod_os_ilistdir_obj) },
     #if MICROPY_PY_OS_DUPTERM
@@ -248,5 +330,5 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_os_globals, mp_module_os_globals_table);
 
 const mp_obj_module_t mp_module_os = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_os_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_os_globals,
 };
diff --git a/ports/unix/modtermios.c b/ports/unix/modtermios.c
index 7e46ba2f524fc..7a578becb9cc1 100644
--- a/ports/unix/modtermios.c
+++ b/ports/unix/modtermios.c
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2014 Paul Sokolovsky
+ * Copyright (c) 2014-2015 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -58,7 +58,7 @@ STATIC mp_obj_t mod_termios_tcgetattr(mp_obj_t fd_in) {
             // but no way unicode chars could be there, if c_cc is defined to be a
             // a "char". But it's type is actually cc_t, which can be anything.
             // TODO: For now, we still deal with it like that.
-            cc->items[i] = mp_obj_new_bytes((byte*)&term.c_cc[i], 1);
+            cc->items[i] = mp_obj_new_bytes((byte *)&term.c_cc[i], 1);
         }
     }
     return MP_OBJ_FROM_PTR(r);
@@ -96,7 +96,7 @@ STATIC mp_obj_t mod_termios_tcsetattr(mp_obj_t fd_in, mp_obj_t when_in, mp_obj_t
 
     int res = cfsetispeed(&term, mp_obj_get_int(attrs->items[4]));
     RAISE_ERRNO(res, errno);
-    res = cfsetispeed(&term, mp_obj_get_int(attrs->items[5]));
+    res = cfsetospeed(&term, mp_obj_get_int(attrs->items[5]));
     RAISE_ERRNO(res, errno);
 
     res = tcsetattr(fd, when, &term);
@@ -129,7 +129,7 @@ STATIC const mp_rom_map_elem_t mp_module_termios_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_tcsetattr), MP_ROM_PTR(&mod_termios_tcsetattr_obj) },
     { MP_ROM_QSTR(MP_QSTR_setraw), MP_ROM_PTR(&mod_termios_setraw_obj) },
 
-#define C(name) { MP_ROM_QSTR(MP_QSTR_ ## name), MP_ROM_INT(name) }
+#define C(name) { MP_ROM_QSTR(MP_QSTR_##name), MP_ROM_INT(name) }
     C(TCSANOW),
 
     C(B9600),
@@ -146,5 +146,5 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_termios_globals, mp_module_termios_globals
 
 const mp_obj_module_t mp_module_termios = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_termios_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_termios_globals,
 };
diff --git a/ports/unix/modtime.c b/ports/unix/modtime.c
index a74b81f374e89..84c83da268627 100644
--- a/ports/unix/modtime.c
+++ b/ports/unix/modtime.c
@@ -3,7 +3,8 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2014-2017 Paul Sokolovsky
+ * Copyright (c) 2014-2017 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -60,43 +61,43 @@ static inline int msec_sleep_tv(struct timeval *tv) {
 #endif
 
 #if defined(MP_CLOCKS_PER_SEC)
-#define CLOCK_DIV (MP_CLOCKS_PER_SEC / 1000.0F)
+#define CLOCK_DIV (MP_CLOCKS_PER_SEC / MICROPY_FLOAT_CONST(1000.0))
 #else
 #error Unsupported clock() implementation
 #endif
 
 STATIC mp_obj_t mod_time_time(void) {
-#if MICROPY_PY_BUILTINS_FLOAT
+    #if MICROPY_PY_BUILTINS_FLOAT
     struct timeval tv;
     gettimeofday(&tv, NULL);
     mp_float_t val = tv.tv_sec + (mp_float_t)tv.tv_usec / 1000000;
     return mp_obj_new_float(val);
-#else
+    #else
     return mp_obj_new_int((mp_int_t)time(NULL));
-#endif
+    #endif
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_time_time_obj, mod_time_time);
 
 // Note: this is deprecated since CPy3.3, but pystone still uses it.
 STATIC mp_obj_t mod_time_clock(void) {
-#if MICROPY_PY_BUILTINS_FLOAT
+    #if MICROPY_PY_BUILTINS_FLOAT
     // float cannot represent full range of int32 precisely, so we pre-divide
     // int to reduce resolution, and then actually do float division hoping
     // to preserve integer part resolution.
-    return mp_obj_new_float((float)(clock() / 1000) / CLOCK_DIV);
-#else
+    return mp_obj_new_float((clock() / 1000) / CLOCK_DIV);
+    #else
     return mp_obj_new_int((mp_int_t)clock());
-#endif
+    #endif
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_time_clock_obj, mod_time_clock);
 
 STATIC mp_obj_t mod_time_sleep(mp_obj_t arg) {
-#if MICROPY_PY_BUILTINS_FLOAT
+    #if MICROPY_PY_BUILTINS_FLOAT
     struct timeval tv;
     mp_float_t val = mp_obj_get_float(arg);
-    double ipart;
-    tv.tv_usec = round(modf(val, &ipart) * 1000000);
-    tv.tv_sec = ipart;
+    mp_float_t ipart;
+    tv.tv_usec = (time_t)MICROPY_FLOAT_C_FUN(round)(MICROPY_FLOAT_C_FUN(modf)(val, &ipart) * MICROPY_FLOAT_CONST(1000000.));
+    tv.tv_sec = (suseconds_t)ipart;
     int res;
     while (1) {
         MP_THREAD_GIL_EXIT();
@@ -108,19 +109,25 @@ STATIC mp_obj_t mod_time_sleep(mp_obj_t arg) {
         if (res != -1 || errno != EINTR) {
             break;
         }
-        mp_handle_pending();
-        //printf("select: EINTR: %ld:%ld\n", tv.tv_sec, tv.tv_usec);
+        mp_handle_pending(true);
+        // printf("select: EINTR: %ld:%ld\n", tv.tv_sec, tv.tv_usec);
         #else
         break;
         #endif
     }
     RAISE_ERRNO(res, errno);
-#else
-    // TODO: Handle EINTR
-    MP_THREAD_GIL_EXIT();
-    sleep(mp_obj_get_int(arg));
-    MP_THREAD_GIL_ENTER();
-#endif
+    #else
+    int seconds = mp_obj_get_int(arg);
+    for (;;) {
+        MP_THREAD_GIL_EXIT();
+        seconds = sleep(seconds);
+        MP_THREAD_GIL_ENTER();
+        if (seconds == 0) {
+            break;
+        }
+        mp_handle_pending(true);
+    }
+    #endif
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_time_sleep_obj, mod_time_sleep);
@@ -160,6 +167,37 @@ STATIC mp_obj_t mod_time_localtime(size_t n_args, const mp_obj_t *args) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_time_localtime_obj, 0, 1, mod_time_localtime);
 
+STATIC mp_obj_t mod_time_mktime(mp_obj_t tuple) {
+    size_t len;
+    mp_obj_t *elem;
+    mp_obj_get_array(tuple, &len, &elem);
+
+    // localtime generates a tuple of len 8. CPython uses 9, so we accept both.
+    if (len < 8 || len > 9) {
+        mp_raise_TypeError(MP_ERROR_TEXT("mktime needs a tuple of length 8 or 9"));
+    }
+
+    struct tm time = {
+        .tm_year = mp_obj_get_int(elem[0]) - 1900,
+        .tm_mon = mp_obj_get_int(elem[1]) - 1,
+        .tm_mday = mp_obj_get_int(elem[2]),
+        .tm_hour = mp_obj_get_int(elem[3]),
+        .tm_min = mp_obj_get_int(elem[4]),
+        .tm_sec = mp_obj_get_int(elem[5]),
+    };
+    if (len == 9) {
+        time.tm_isdst = mp_obj_get_int(elem[8]);
+    } else {
+        time.tm_isdst = -1; // auto-detect
+    }
+    time_t ret = mktime(&time);
+    if (ret == -1) {
+        mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("invalid mktime usage"));
+    }
+    return mp_obj_new_int(ret);
+}
+MP_DEFINE_CONST_FUN_OBJ_1(mod_time_mktime_obj, mod_time_mktime);
+
 STATIC const mp_rom_map_elem_t mp_module_time_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_utime) },
     { MP_ROM_QSTR(MP_QSTR_clock), MP_ROM_PTR(&mod_time_clock_obj) },
@@ -173,13 +211,14 @@ STATIC const mp_rom_map_elem_t mp_module_time_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_ticks_add), MP_ROM_PTR(&mp_utime_ticks_add_obj) },
     { MP_ROM_QSTR(MP_QSTR_ticks_diff), MP_ROM_PTR(&mp_utime_ticks_diff_obj) },
     { MP_ROM_QSTR(MP_QSTR_localtime), MP_ROM_PTR(&mod_time_localtime_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mktime), MP_ROM_PTR(&mod_time_mktime_obj) },
 };
 
 STATIC MP_DEFINE_CONST_DICT(mp_module_time_globals, mp_module_time_globals_table);
 
 const mp_obj_module_t mp_module_time = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_time_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_time_globals,
 };
 
 #endif // MICROPY_PY_UTIME
diff --git a/ports/unix/modules/upip.py b/ports/unix/modules/upip.py
deleted file mode 120000
index 130eb69016485..0000000000000
--- a/ports/unix/modules/upip.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../tools/upip.py
\ No newline at end of file
diff --git a/ports/unix/modules/upip_utarfile.py b/ports/unix/modules/upip_utarfile.py
deleted file mode 120000
index d9653d6a60808..0000000000000
--- a/ports/unix/modules/upip_utarfile.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../tools/upip_utarfile.py
\ No newline at end of file
diff --git a/ports/unix/moduos_vfs.c b/ports/unix/moduos_vfs.c
index e9ac8e1f88244..6e4f352aad0f4 100644
--- a/ports/unix/moduos_vfs.c
+++ b/ports/unix/moduos_vfs.c
@@ -30,12 +30,15 @@
 #include "extmod/vfs.h"
 #include "extmod/vfs_posix.h"
 #include "extmod/vfs_fat.h"
+#include "extmod/vfs_lfs.h"
 
 #if MICROPY_VFS
 
 // These are defined in modos.c
 MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mod_os_errno_obj);
 MP_DECLARE_CONST_FUN_OBJ_1(mod_os_getenv_obj);
+MP_DECLARE_CONST_FUN_OBJ_1(mod_os_putenv_obj);
+MP_DECLARE_CONST_FUN_OBJ_1(mod_os_unsetenv_obj);
 MP_DECLARE_CONST_FUN_OBJ_1(mod_os_system_obj);
 
 STATIC const mp_rom_map_elem_t uos_vfs_module_globals_table[] = {
@@ -44,6 +47,8 @@ STATIC const mp_rom_map_elem_t uos_vfs_module_globals_table[] = {
 
     { MP_ROM_QSTR(MP_QSTR_errno), MP_ROM_PTR(&mod_os_errno_obj) },
     { MP_ROM_QSTR(MP_QSTR_getenv), MP_ROM_PTR(&mod_os_getenv_obj) },
+    { MP_ROM_QSTR(MP_QSTR_putenv), MP_ROM_PTR(&mod_os_putenv_obj) },
+    { MP_ROM_QSTR(MP_QSTR_unsetenv), MP_ROM_PTR(&mod_os_unsetenv_obj) },
     { MP_ROM_QSTR(MP_QSTR_system), MP_ROM_PTR(&mod_os_system_obj) },
 
     { MP_ROM_QSTR(MP_QSTR_mount), MP_ROM_PTR(&mp_vfs_mount_obj) },
@@ -71,13 +76,19 @@ STATIC const mp_rom_map_elem_t uos_vfs_module_globals_table[] = {
     #if MICROPY_VFS_FAT
     { MP_ROM_QSTR(MP_QSTR_VfsFat), MP_ROM_PTR(&mp_fat_vfs_type) },
     #endif
+    #if MICROPY_VFS_LFS1
+    { MP_ROM_QSTR(MP_QSTR_VfsLfs1), MP_ROM_PTR(&mp_type_vfs_lfs1) },
+    #endif
+    #if MICROPY_VFS_LFS2
+    { MP_ROM_QSTR(MP_QSTR_VfsLfs2), MP_ROM_PTR(&mp_type_vfs_lfs2) },
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(uos_vfs_module_globals, uos_vfs_module_globals_table);
 
 const mp_obj_module_t mp_module_uos_vfs = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&uos_vfs_module_globals,
+    .globals = (mp_obj_dict_t *)&uos_vfs_module_globals,
 };
 
 #endif // MICROPY_VFS
diff --git a/ports/unix/moduselect.c b/ports/unix/moduselect.c
index d9b02ddc62cef..6a0ee79aa6f0d 100644
--- a/ports/unix/moduselect.c
+++ b/ports/unix/moduselect.c
@@ -39,7 +39,7 @@
 #include "py/objlist.h"
 #include "py/objtuple.h"
 #include "py/mphal.h"
-#include "fdfile.h"
+#include "py/mpthread.h"
 
 #define DEBUG 0
 
@@ -188,8 +188,8 @@ STATIC int poll_poll_internal(size_t n_args, const mp_obj_t *args) {
 
     self->flags = flags;
 
-    int n_ready = poll(self->entries, self->len, timeout);
-    RAISE_ERRNO(n_ready, errno);
+    int n_ready;
+    MP_HAL_RETRY_SYSCALL(n_ready, poll(self->entries, self->len, timeout), mp_raise_OSError(err));
     return n_ready;
 }
 
@@ -312,7 +312,7 @@ STATIC const mp_obj_type_t mp_type_poll = {
     .name = MP_QSTR_poll,
     .getiter = mp_identity_getiter,
     .iternext = poll_iternext,
-    .locals_dict = (void*)&poll_locals_dict,
+    .locals_dict = (void *)&poll_locals_dict,
 };
 
 STATIC mp_obj_t select_poll(size_t n_args, const mp_obj_t *args) {
@@ -345,7 +345,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_select_globals, mp_module_select_globals_t
 
 const mp_obj_module_t mp_module_uselect = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_select_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_select_globals,
 };
 
 #endif // MICROPY_PY_USELECT_POSIX
diff --git a/ports/unix/modusocket.c b/ports/unix/modusocket.c
index fd4092a622845..1c9ef336228a2 100644
--- a/ports/unix/modusocket.c
+++ b/ports/unix/modusocket.c
@@ -3,8 +3,8 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
- * Copyright (c) 2014 Paul Sokolovsky
+ * Copyright (c) 2014-2018 Paul Sokolovsky
+ * Copyright (c) 2014-2019 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -45,6 +45,7 @@
 #include "py/stream.h"
 #include "py/builtin.h"
 #include "py/mphal.h"
+#include "py/mpthread.h"
 
 /*
   The idea of this module is to implement reasonable minimum of
@@ -93,9 +94,8 @@ STATIC void socket_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kin
 
 STATIC mp_uint_t socket_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
     mp_obj_socket_t *o = MP_OBJ_TO_PTR(o_in);
-    mp_int_t r = read(o->fd, buf, size);
-    if (r == -1) {
-        int err = errno;
+    ssize_t r;
+    MP_HAL_RETRY_SYSCALL(r, read(o->fd, buf, size), {
         // On blocking socket, we get EAGAIN in case SO_RCVTIMEO/SO_SNDTIMEO
         // timed out, and need to convert that to ETIMEDOUT.
         if (err == EAGAIN && o->blocking) {
@@ -104,15 +104,14 @@ STATIC mp_uint_t socket_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errc
 
         *errcode = err;
         return MP_STREAM_ERROR;
-    }
-    return r;
+    });
+    return (mp_uint_t)r;
 }
 
 STATIC mp_uint_t socket_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
     mp_obj_socket_t *o = MP_OBJ_TO_PTR(o_in);
-    mp_int_t r = write(o->fd, buf, size);
-    if (r == -1) {
-        int err = errno;
+    ssize_t r;
+    MP_HAL_RETRY_SYSCALL(r, write(o->fd, buf, size), {
         // On blocking socket, we get EAGAIN in case SO_RCVTIMEO/SO_SNDTIMEO
         // timed out, and need to convert that to ETIMEDOUT.
         if (err == EAGAIN && o->blocking) {
@@ -121,8 +120,8 @@ STATIC mp_uint_t socket_write(mp_obj_t o_in, const void *buf, mp_uint_t size, in
 
         *errcode = err;
         return MP_STREAM_ERROR;
-    }
-    return r;
+    });
+    return (mp_uint_t)r;
 }
 
 STATIC mp_uint_t socket_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
@@ -137,7 +136,9 @@ STATIC mp_uint_t socket_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, i
             // The rationale MicroPython follows is that close() just releases
             // file descriptor. If you're interested to catch I/O errors before
             // closing fd, fsync() it.
+            MP_THREAD_GIL_EXIT();
             close(self->fd);
+            MP_THREAD_GIL_ENTER();
             return 0;
 
         case MP_STREAM_GET_FILENO:
@@ -159,9 +160,29 @@ STATIC mp_obj_t socket_connect(mp_obj_t self_in, mp_obj_t addr_in) {
     mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in);
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(addr_in, &bufinfo, MP_BUFFER_READ);
-    int r = connect(self->fd, (const struct sockaddr *)bufinfo.buf, bufinfo.len);
-    RAISE_ERRNO(r, errno);
-    return mp_const_none;
+
+    // special case of PEP 475 to retry only if blocking so we can't use
+    // MP_HAL_RETRY_SYSCALL() here
+    for (;;) {
+        MP_THREAD_GIL_EXIT();
+        int r = connect(self->fd, (const struct sockaddr *)bufinfo.buf, bufinfo.len);
+        MP_THREAD_GIL_ENTER();
+        if (r == -1) {
+            int err = errno;
+            if (self->blocking) {
+                if (err == EINTR) {
+                    mp_handle_pending(true);
+                    continue;
+                }
+                // EINPROGRESS on a blocking socket means the operation timed out
+                if (err == EINPROGRESS) {
+                    err = MP_ETIMEDOUT;
+                }
+            }
+            mp_raise_OSError(err);
+        }
+        return mp_const_none;
+    }
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_connect_obj, socket_connect);
 
@@ -169,7 +190,9 @@ STATIC mp_obj_t socket_bind(mp_obj_t self_in, mp_obj_t addr_in) {
     mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in);
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(addr_in, &bufinfo, MP_BUFFER_READ);
+    MP_THREAD_GIL_EXIT();
     int r = bind(self->fd, (const struct sockaddr *)bufinfo.buf, bufinfo.len);
+    MP_THREAD_GIL_ENTER();
     RAISE_ERRNO(r, errno);
     return mp_const_none;
 }
@@ -177,7 +200,9 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_bind_obj, socket_bind);
 
 STATIC mp_obj_t socket_listen(mp_obj_t self_in, mp_obj_t backlog_in) {
     mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in);
+    MP_THREAD_GIL_EXIT();
     int r = listen(self->fd, MP_OBJ_SMALL_INT_VALUE(backlog_in));
+    MP_THREAD_GIL_ENTER();
     RAISE_ERRNO(r, errno);
     return mp_const_none;
 }
@@ -186,11 +211,17 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_listen_obj, socket_listen);
 STATIC mp_obj_t socket_accept(mp_obj_t self_in) {
     mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in);
     // sockaddr_storage isn't stack-friendly (129 bytes or so)
-    //struct sockaddr_storage addr;
+    // struct sockaddr_storage addr;
     byte addr[32];
     socklen_t addr_len = sizeof(addr);
-    int fd = accept(self->fd, (struct sockaddr*)&addr, &addr_len);
-    RAISE_ERRNO(fd, errno);
+    int fd;
+    MP_HAL_RETRY_SYSCALL(fd, accept(self->fd, (struct sockaddr *)&addr, &addr_len), {
+        // EAGAIN on a blocking socket means the operation timed out
+        if (self->blocking && err == EAGAIN) {
+            err = MP_ETIMEDOUT;
+        }
+        mp_raise_OSError(err);
+    });
 
     mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(2, NULL));
     t->items[0] = MP_OBJ_FROM_PTR(socket_new(fd));
@@ -213,9 +244,8 @@ STATIC mp_obj_t socket_recv(size_t n_args, const mp_obj_t *args) {
     }
 
     byte *buf = m_new(byte, sz);
-    int out_sz = recv(self->fd, buf, sz, flags);
-    RAISE_ERRNO(out_sz, errno);
-
+    ssize_t out_sz;
+    MP_HAL_RETRY_SYSCALL(out_sz, recv(self->fd, buf, sz, flags), mp_raise_OSError(err));
     mp_obj_t ret = mp_obj_new_str_of_type(&mp_type_bytes, buf, out_sz);
     m_del(char, buf, sz);
     return ret;
@@ -235,15 +265,15 @@ STATIC mp_obj_t socket_recvfrom(size_t n_args, const mp_obj_t *args) {
     socklen_t addr_len = sizeof(addr);
 
     byte *buf = m_new(byte, sz);
-    int out_sz = recvfrom(self->fd, buf, sz, flags, (struct sockaddr*)&addr, &addr_len);
-    RAISE_ERRNO(out_sz, errno);
-
+    ssize_t out_sz;
+    MP_HAL_RETRY_SYSCALL(out_sz, recvfrom(self->fd, buf, sz, flags, (struct sockaddr *)&addr, &addr_len),
+        mp_raise_OSError(err));
     mp_obj_t buf_o = mp_obj_new_str_of_type(&mp_type_bytes, buf, out_sz);
     m_del(char, buf, sz);
 
     mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(2, NULL));
     t->items[0] = buf_o;
-    t->items[1] = mp_obj_from_sockaddr((struct sockaddr*)&addr, addr_len);
+    t->items[1] = mp_obj_from_sockaddr((struct sockaddr *)&addr, addr_len);
 
     return MP_OBJ_FROM_PTR(t);
 }
@@ -262,9 +292,9 @@ STATIC mp_obj_t socket_send(size_t n_args, const mp_obj_t *args) {
 
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ);
-    int out_sz = send(self->fd, bufinfo.buf, bufinfo.len, flags);
-    RAISE_ERRNO(out_sz, errno);
-
+    ssize_t out_sz;
+    MP_HAL_RETRY_SYSCALL(out_sz, send(self->fd, bufinfo.buf, bufinfo.len, flags),
+        mp_raise_OSError(err));
     return MP_OBJ_NEW_SMALL_INT(out_sz);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_send_obj, 2, 3, socket_send);
@@ -282,10 +312,9 @@ STATIC mp_obj_t socket_sendto(size_t n_args, const mp_obj_t *args) {
     mp_buffer_info_t bufinfo, addr_bi;
     mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ);
     mp_get_buffer_raise(dst_addr, &addr_bi, MP_BUFFER_READ);
-    int out_sz = sendto(self->fd, bufinfo.buf, bufinfo.len, flags,
-                        (struct sockaddr *)addr_bi.buf, addr_bi.len);
-    RAISE_ERRNO(out_sz, errno);
-
+    ssize_t out_sz;
+    MP_HAL_RETRY_SYSCALL(out_sz, sendto(self->fd, bufinfo.buf, bufinfo.len, flags,
+        (struct sockaddr *)addr_bi.buf, addr_bi.len), mp_raise_OSError(err));
     return MP_OBJ_NEW_SMALL_INT(out_sz);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_sendto_obj, 3, 4, socket_sendto);
@@ -309,7 +338,9 @@ STATIC mp_obj_t socket_setsockopt(size_t n_args, const mp_obj_t *args) {
         optval = bufinfo.buf;
         optlen = bufinfo.len;
     }
+    MP_THREAD_GIL_EXIT();
     int r = setsockopt(self->fd, level, option, optval, optlen);
+    MP_THREAD_GIL_ENTER();
     RAISE_ERRNO(r, errno);
     return mp_const_none;
 }
@@ -318,14 +349,19 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_setsockopt_obj, 4, 4, socket_s
 STATIC mp_obj_t socket_setblocking(mp_obj_t self_in, mp_obj_t flag_in) {
     mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in);
     int val = mp_obj_is_true(flag_in);
+    MP_THREAD_GIL_EXIT();
     int flags = fcntl(self->fd, F_GETFL, 0);
-    RAISE_ERRNO(flags, errno);
+    if (flags == -1) {
+        MP_THREAD_GIL_ENTER();
+        RAISE_ERRNO(flags, errno);
+    }
     if (val) {
         flags &= ~O_NONBLOCK;
     } else {
         flags |= O_NONBLOCK;
     }
     flags = fcntl(self->fd, F_SETFL, flags);
+    MP_THREAD_GIL_ENTER();
     RAISE_ERRNO(flags, errno);
     self->blocking = val;
     return mp_const_none;
@@ -337,15 +373,14 @@ STATIC mp_obj_t socket_settimeout(mp_obj_t self_in, mp_obj_t timeout_in) {
     struct timeval tv = {0,};
     bool new_blocking = true;
 
-    if (timeout_in == mp_const_none) {
-        setsockopt(self->fd, SOL_SOCKET, SO_RCVTIMEO, NULL, 0);
-        setsockopt(self->fd, SOL_SOCKET, SO_SNDTIMEO, NULL, 0);
-    } else {
+    // Timeout of None means no timeout, which in POSIX is signified with 0 timeout,
+    // and that's how 'tv' is initialized above
+    if (timeout_in != mp_const_none) {
         #if MICROPY_PY_BUILTINS_FLOAT
         mp_float_t val = mp_obj_get_float(timeout_in);
-        double ipart;
-        tv.tv_usec = round(modf(val, &ipart) * 1000000);
-        tv.tv_sec = ipart;
+        mp_float_t ipart;
+        tv.tv_usec = (time_t)MICROPY_FLOAT_C_FUN(round)(MICROPY_FLOAT_C_FUN(modf)(val, &ipart) * MICROPY_FLOAT_CONST(1000000.));
+        tv.tv_sec = (suseconds_t)ipart;
         #else
         tv.tv_sec = mp_obj_get_int(timeout_in);
         #endif
@@ -354,14 +389,22 @@ STATIC mp_obj_t socket_settimeout(mp_obj_t self_in, mp_obj_t timeout_in) {
         // for Python API it means non-blocking.
         if (tv.tv_sec == 0 && tv.tv_usec == 0) {
             new_blocking = false;
-        } else {
-            setsockopt(self->fd, SOL_SOCKET, SO_RCVTIMEO,
-                       &tv, sizeof(struct timeval));
-            setsockopt(self->fd, SOL_SOCKET, SO_SNDTIMEO,
-                       &tv, sizeof(struct timeval));
         }
     }
 
+    if (new_blocking) {
+        int r;
+        MP_THREAD_GIL_EXIT();
+        r = setsockopt(self->fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(struct timeval));
+        if (r == -1) {
+            MP_THREAD_GIL_ENTER();
+            RAISE_ERRNO(r, errno);
+        }
+        r = setsockopt(self->fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(struct timeval));
+        MP_THREAD_GIL_ENTER();
+        RAISE_ERRNO(r, errno);
+    }
+
     if (self->blocking != new_blocking) {
         socket_setblocking(self_in, mp_obj_new_bool(new_blocking));
     }
@@ -378,7 +421,7 @@ STATIC mp_obj_t socket_makefile(size_t n_args, const mp_obj_t *args) {
     mp_obj_t *new_args = alloca(n_args * sizeof(mp_obj_t));
     memcpy(new_args + 1, args + 1, (n_args - 1) * sizeof(mp_obj_t));
     new_args[0] = MP_OBJ_NEW_SMALL_INT(self->fd);
-    return mp_builtin_open(n_args, new_args, (mp_map_t*)&mp_const_empty_map);
+    return mp_builtin_open(n_args, new_args, (mp_map_t *)&mp_const_empty_map);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_makefile_obj, 1, 3, socket_makefile);
 
@@ -403,7 +446,9 @@ STATIC mp_obj_t socket_make_new(const mp_obj_type_t *type_in, size_t n_args, siz
         }
     }
 
+    MP_THREAD_GIL_EXIT();
     int fd = socket(family, type, proto);
+    MP_THREAD_GIL_ENTER();
     RAISE_ERRNO(fd, errno);
     return MP_OBJ_FROM_PTR(socket_new(fd));
 }
@@ -445,7 +490,7 @@ const mp_obj_type_t mp_type_socket = {
     .getiter = NULL,
     .iternext = NULL,
     .protocol = &usocket_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&usocket_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&usocket_locals_dict,
 };
 
 #define BINADDR_MAX_LEN sizeof(struct in6_addr)
@@ -499,10 +544,10 @@ STATIC mp_obj_t mod_socket_getaddrinfo(size_t n_args, const mp_obj_t *args) {
         snprintf(buf, sizeof(buf), "%u", port);
         serv = buf;
         hints.ai_flags = AI_NUMERICSERV;
-#ifdef __UCLIBC_MAJOR__
-#if __UCLIBC_MAJOR__ == 0 && (__UCLIBC_MINOR__ < 9 || (__UCLIBC_MINOR__ == 9 && __UCLIBC_SUBLEVEL__ <= 32))
+        #ifdef __UCLIBC_MAJOR__
+        #if __UCLIBC_MAJOR__ == 0 && (__UCLIBC_MINOR__ < 9 || (__UCLIBC_MINOR__ == 9 && __UCLIBC_SUBLEVEL__ <= 32))
 // "warning" requires -Wno-cpp which is a relatively new gcc option, so we choose not to use it.
-//#warning Working around uClibc bug with numeric service name
+// #warning Working around uClibc bug with numeric service name
         // Older versions og uClibc have bugs when numeric ports in service
         // arg require also hints.ai_socktype (or hints.ai_protocol) != 0
         // This actually was fixed in 0.9.32.1, but uClibc doesn't allow to
@@ -511,8 +556,8 @@ STATIC mp_obj_t mod_socket_getaddrinfo(size_t n_args, const mp_obj_t *args) {
         // Note that this is crude workaround, precluding UDP socket addresses
         // to be returned. TODO: set only if not set by Python args.
         hints.ai_socktype = SOCK_STREAM;
-#endif
-#endif
+        #endif
+        #endif
     } else {
         serv = mp_obj_str_get_str(args[1]);
     }
@@ -525,11 +570,13 @@ STATIC mp_obj_t mod_socket_getaddrinfo(size_t n_args, const mp_obj_t *args) {
     }
 
     struct addrinfo *addr_list;
+    MP_THREAD_GIL_EXIT();
     int res = getaddrinfo(host, serv, &hints, &addr_list);
+    MP_THREAD_GIL_ENTER();
 
     if (res != 0) {
         // CPython: socket.gaierror
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, "[addrinfo error %d]", res));
+        mp_raise_msg_varg(&mp_type_OSError, MP_ERROR_TEXT("[addrinfo error %d]"), res);
     }
     assert(addr_list);
 
@@ -557,30 +604,30 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_socket_getaddrinfo_obj, 2, 4, mod
 STATIC mp_obj_t mod_socket_sockaddr(mp_obj_t sockaddr_in) {
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(sockaddr_in, &bufinfo, MP_BUFFER_READ);
-    switch (((struct sockaddr*)bufinfo.buf)->sa_family) {
+    switch (((struct sockaddr *)bufinfo.buf)->sa_family) {
         case AF_INET: {
-            struct sockaddr_in *sa = (struct sockaddr_in*)bufinfo.buf;
+            struct sockaddr_in *sa = (struct sockaddr_in *)bufinfo.buf;
             mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
             t->items[0] = MP_OBJ_NEW_SMALL_INT(AF_INET);
-            t->items[1] = mp_obj_new_bytes((byte*)&sa->sin_addr, sizeof(sa->sin_addr));
+            t->items[1] = mp_obj_new_bytes((byte *)&sa->sin_addr, sizeof(sa->sin_addr));
             t->items[2] = MP_OBJ_NEW_SMALL_INT(ntohs(sa->sin_port));
             return MP_OBJ_FROM_PTR(t);
         }
         case AF_INET6: {
-            struct sockaddr_in6 *sa = (struct sockaddr_in6*)bufinfo.buf;
+            struct sockaddr_in6 *sa = (struct sockaddr_in6 *)bufinfo.buf;
             mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(5, NULL));
             t->items[0] = MP_OBJ_NEW_SMALL_INT(AF_INET6);
-            t->items[1] = mp_obj_new_bytes((byte*)&sa->sin6_addr, sizeof(sa->sin6_addr));
+            t->items[1] = mp_obj_new_bytes((byte *)&sa->sin6_addr, sizeof(sa->sin6_addr));
             t->items[2] = MP_OBJ_NEW_SMALL_INT(ntohs(sa->sin6_port));
             t->items[3] = MP_OBJ_NEW_SMALL_INT(ntohl(sa->sin6_flowinfo));
             t->items[4] = MP_OBJ_NEW_SMALL_INT(ntohl(sa->sin6_scope_id));
             return MP_OBJ_FROM_PTR(t);
         }
         default: {
-            struct sockaddr *sa = (struct sockaddr*)bufinfo.buf;
+            struct sockaddr *sa = (struct sockaddr *)bufinfo.buf;
             mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(2, NULL));
             t->items[0] = MP_OBJ_NEW_SMALL_INT(sa->sa_family);
-            t->items[1] = mp_obj_new_bytes((byte*)sa->sa_data, bufinfo.len - offsetof(struct sockaddr, sa_data));
+            t->items[1] = mp_obj_new_bytes((byte *)sa->sa_data, bufinfo.len - offsetof(struct sockaddr, sa_data));
             return MP_OBJ_FROM_PTR(t);
         }
     }
@@ -596,7 +643,7 @@ STATIC const mp_rom_map_elem_t mp_module_socket_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_inet_ntop), MP_ROM_PTR(&mod_socket_inet_ntop_obj) },
     { MP_ROM_QSTR(MP_QSTR_sockaddr), MP_ROM_PTR(&mod_socket_sockaddr_obj) },
 
-#define C(name) { MP_ROM_QSTR(MP_QSTR_ ## name), MP_ROM_INT(name) }
+#define C(name) { MP_ROM_QSTR(MP_QSTR_##name), MP_ROM_INT(name) }
     C(AF_UNIX),
     C(AF_INET),
     C(AF_INET6),
@@ -620,5 +667,5 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_socket_globals, mp_module_socket_globals_t
 
 const mp_obj_module_t mp_module_socket = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_socket_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_socket_globals,
 };
diff --git a/ports/unix/mpconfigport.h b/ports/unix/mpconfigport.h
index 97a9f4908415a..f3c61c18f100d 100644
--- a/ports/unix/mpconfigport.h
+++ b/ports/unix/mpconfigport.h
@@ -24,7 +24,15 @@
  * THE SOFTWARE.
  */
 
-// options to control how MicroPython is built
+// Options to control how MicroPython is built for this port,
+// overriding defaults in py/mpconfig.h.
+
+// Variant-specific definitions.
+#include "mpconfigvariant.h"
+
+// The minimal variant's config covers everything.
+// If we're building the minimal variant, ignore the rest of this file.
+#ifndef MICROPY_UNIX_MINIMAL
 
 #define MICROPY_ALLOC_PATH_MAX      (PATH_MAX)
 #define MICROPY_PERSISTENT_CODE_LOAD (1)
@@ -36,7 +44,7 @@
 #endif
 #if !defined(MICROPY_EMIT_THUMB) && defined(__thumb2__)
     #define MICROPY_EMIT_THUMB      (1)
-    #define MICROPY_MAKE_POINTER_CALLABLE(p) ((void*)((mp_uint_t)(p) | 1))
+    #define MICROPY_MAKE_POINTER_CALLABLE(p) ((void *)((mp_uint_t)(p) | 1))
 #endif
 // Some compilers define __thumb2__ and __arm__ at the same time, let
 // autodetected thumb2 emitter have priority.
@@ -62,15 +70,21 @@
 #define MICROPY_REPL_AUTO_INDENT    (1)
 #define MICROPY_HELPER_LEXER_UNIX   (1)
 #define MICROPY_ENABLE_SOURCE_LINE  (1)
+#ifndef MICROPY_FLOAT_IMPL
 #define MICROPY_FLOAT_IMPL          (MICROPY_FLOAT_IMPL_DOUBLE)
+#endif
 #define MICROPY_LONGINT_IMPL        (MICROPY_LONGINT_IMPL_MPZ)
+#ifndef MICROPY_STREAMS_NON_BLOCK
 #define MICROPY_STREAMS_NON_BLOCK   (1)
+#endif
 #define MICROPY_STREAMS_POSIX_API   (1)
 #define MICROPY_OPT_COMPUTED_GOTO   (1)
 #ifndef MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE
 #define MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE (1)
 #endif
+#define MICROPY_MODULE_WEAK_LINKS   (1)
 #define MICROPY_CAN_OVERRIDE_BUILTINS (1)
+#define MICROPY_VFS_POSIX_FILE      (1)
 #define MICROPY_PY_FUNCTION_ATTRS   (1)
 #define MICROPY_PY_DESCRIPTORS      (1)
 #define MICROPY_PY_BUILTINS_STR_UNICODE (1)
@@ -89,12 +103,20 @@
 #define MICROPY_PY_REVERSE_SPECIAL_METHODS (1)
 #define MICROPY_PY_ARRAY_SLICE_ASSIGN (1)
 #define MICROPY_PY_BUILTINS_SLICE_ATTRS (1)
+#define MICROPY_PY_BUILTINS_SLICE_INDICES (1)
 #define MICROPY_PY_SYS_EXIT         (1)
+#define MICROPY_PY_SYS_ATEXIT       (1)
+#if MICROPY_PY_SYS_SETTRACE
+#define MICROPY_PERSISTENT_CODE_SAVE (1)
+#define MICROPY_COMP_CONST (0)
+#endif
+#ifndef MICROPY_PY_SYS_PLATFORM
 #if defined(__APPLE__) && defined(__MACH__)
     #define MICROPY_PY_SYS_PLATFORM  "darwin"
 #else
     #define MICROPY_PY_SYS_PLATFORM  "linux"
 #endif
+#endif
 #define MICROPY_PY_SYS_MAXSIZE      (1)
 #define MICROPY_PY_SYS_STDFILES     (1)
 #define MICROPY_PY_SYS_EXC_INFO     (1)
@@ -103,11 +125,11 @@
 #ifndef MICROPY_PY_MATH_SPECIAL_FUNCTIONS
 #define MICROPY_PY_MATH_SPECIAL_FUNCTIONS (1)
 #endif
+#define MICROPY_PY_MATH_ISCLOSE     (MICROPY_PY_MATH_SPECIAL_FUNCTIONS)
 #define MICROPY_PY_CMATH            (1)
 #define MICROPY_PY_IO_IOBASE        (1)
 #define MICROPY_PY_IO_FILEIO        (1)
 #define MICROPY_PY_GC_COLLECT_RETVAL (1)
-#define MICROPY_MODULE_FROZEN_STR   (1)
 
 #ifndef MICROPY_STACKLESS
 #define MICROPY_STACKLESS           (0)
@@ -146,7 +168,6 @@
 #define MICROPY_FATFS_RPATH            (2)
 #define MICROPY_FATFS_MAX_SS           (4096)
 #define MICROPY_FATFS_LFN_CODE_PAGE    437 /* 1=SFN/ANSI 437=LFN/U.S.(OEM) */
-#define MICROPY_VFS_FAT                (0)
 
 // Define to MICROPY_ERROR_REPORTING_DETAILED to get function, etc.
 // names in exception messages (may require more RAM).
@@ -157,14 +178,9 @@
 
 extern const struct _mp_print_t mp_stderr_print;
 
-// Define to 1 to use undertested inefficient GC helper implementation
-// (if more efficient arch-specific one is not available).
-#ifndef MICROPY_GCREGS_SETJMP
-    #ifdef __mips__
-        #define MICROPY_GCREGS_SETJMP (1)
-    #else
-        #define MICROPY_GCREGS_SETJMP (0)
-    #endif
+#if !(defined(MICROPY_GCREGS_SETJMP) || defined(__x86_64__) || defined(__i386__) || defined(__thumb2__) || defined(__thumb__) || defined(__arm__))
+// Fall back to setjmp() implementation for discovery of GC pointers in registers.
+#define MICROPY_GCREGS_SETJMP (1)
 #endif
 
 #define MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF   (1)
@@ -172,6 +188,9 @@ extern const struct _mp_print_t mp_stderr_print;
 #define MICROPY_KBD_EXCEPTION       (1)
 #define MICROPY_ASYNC_KBD_INTR      (1)
 
+#define mp_type_fileio mp_type_vfs_posix_fileio
+#define mp_type_textio mp_type_vfs_posix_textio
+
 extern const struct _mp_obj_module_t mp_module_machine;
 extern const struct _mp_obj_module_t mp_module_os;
 extern const struct _mp_obj_module_t mp_module_uos_vfs;
@@ -253,7 +272,7 @@ typedef long long mp_off_t;
 typedef long mp_off_t;
 #endif
 
-void mp_unix_alloc_exec(size_t min_size, void** ptr, size_t *size);
+void mp_unix_alloc_exec(size_t min_size, void **ptr, size_t *size);
 void mp_unix_free_exec(void *ptr, size_t size);
 void mp_unix_mark_exec(void);
 #define MP_PLAT_ALLOC_EXEC(min_size, ptr, size) mp_unix_alloc_exec(min_size, ptr, size)
@@ -264,12 +283,6 @@ void mp_unix_mark_exec(void);
 #define MICROPY_FORCE_PLAT_ALLOC_EXEC (1)
 #endif
 
-#if MICROPY_PY_OS_DUPTERM
-#define MP_PLAT_PRINT_STRN(str, len) mp_hal_stdout_tx_strn_cooked(str, len)
-#else
-#define MP_PLAT_PRINT_STRN(str, len) do { ssize_t ret = write(1, str, len); (void)ret; } while (0)
-#endif
-
 #ifdef __linux__
 // Can access physical memory using /dev/mem
 #define MICROPY_PLAT_DEV_MEM  (1)
@@ -293,9 +306,17 @@ void mp_unix_mark_exec(void);
 
 #define MP_STATE_PORT MP_STATE_VM
 
+#if MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_BTSTACK
+struct _mp_bluetooth_btstack_root_pointers_t;
+#define MICROPY_BLUETOOTH_ROOT_POINTERS struct _mp_bluetooth_btstack_root_pointers_t *bluetooth_btstack_root_pointers;
+#else
+#define MICROPY_BLUETOOTH_ROOT_POINTERS
+#endif
+
 #define MICROPY_PORT_ROOT_POINTERS \
     const char *readline_hist[50]; \
     void *mmap_region_head; \
+    MICROPY_BLUETOOTH_ROOT_POINTERS \
 
 // We need to provide a declaration/definition of alloca()
 // unless support for it is disabled.
@@ -325,3 +346,15 @@ void mp_unix_mark_exec(void);
 // For debugging purposes, make printf() available to any source file.
 #include <stdio.h>
 #endif
+
+#if MICROPY_PY_THREAD
+#define MICROPY_BEGIN_ATOMIC_SECTION() (mp_thread_unix_begin_atomic_section(), 0)
+#define MICROPY_END_ATOMIC_SECTION(x) (void)x; mp_thread_unix_end_atomic_section()
+#endif
+
+#define MICROPY_EVENT_POLL_HOOK mp_hal_delay_us(500);
+
+#include <sched.h>
+#define MICROPY_UNIX_MACHINE_IDLE sched_yield();
+
+#endif // MICROPY_UNIX_MINIMAL
diff --git a/ports/unix/mpconfigport.mk b/ports/unix/mpconfigport.mk
index f0aa955c0c5b1..3a66d997b2f45 100644
--- a/ports/unix/mpconfigport.mk
+++ b/ports/unix/mpconfigport.mk
@@ -25,13 +25,11 @@ MICROPY_PY_FFI = 1
 
 # ussl module requires one of the TLS libraries below
 MICROPY_PY_USSL = 1
-# axTLS has minimal size and fully integrated with MicroPython, but
-# implements only a subset of modern TLS functionality, so may have
-# problems with some servers.
+# axTLS has minimal size but implements only a subset of modern TLS
+# functionality, so may have problems with some servers.
 MICROPY_SSL_AXTLS = 1
 # mbedTLS is more up to date and complete implementation, but also
-# more bloated. Configuring and building of mbedTLS should be done
-# outside of MicroPython, it can just link with mbedTLS library.
+# more bloated.
 MICROPY_SSL_MBEDTLS = 0
 
 # jni module requires JVM/JNI
diff --git a/ports/unix/mphalport.h b/ports/unix/mphalport.h
index ff7a51567c909..95ad63221ef95 100644
--- a/ports/unix/mphalport.h
+++ b/ports/unix/mphalport.h
@@ -23,6 +23,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+#include <errno.h>
 #include <unistd.h>
 
 #ifndef CHAR_CTRL_C
@@ -31,10 +32,25 @@
 
 void mp_hal_set_interrupt_char(char c);
 
+#define mp_hal_stdio_poll unused // this is not implemented, nor needed
 void mp_hal_stdio_mode_raw(void);
 void mp_hal_stdio_mode_orig(void);
 
-#if MICROPY_USE_READLINE == 1 && MICROPY_PY_BUILTINS_INPUT
+#if MICROPY_PY_BUILTINS_INPUT && MICROPY_USE_READLINE == 0
+
+#include <malloc.h>
+#include "py/misc.h"
+#include "input.h"
+#define mp_hal_readline mp_hal_readline
+static inline int mp_hal_readline(vstr_t *vstr, const char *p) {
+    char *line = prompt((char *)p);
+    vstr_add_str(vstr, line);
+    free(line);
+    return 0;
+}
+
+#elif MICROPY_PY_BUILTINS_INPUT && MICROPY_USE_READLINE == 1
+
 #include "py/misc.h"
 #include "lib/mp-readline/readline.h"
 // For built-in input() we need to wrap the standard readline() to enable raw mode
@@ -45,14 +61,45 @@ static inline int mp_hal_readline(vstr_t *vstr, const char *p) {
     mp_hal_stdio_mode_orig();
     return ret;
 }
+
 #endif
 
 // TODO: POSIX et al. define usleep() as guaranteedly capable only of 1s sleep:
 // "The useconds argument shall be less than one million."
-static inline void mp_hal_delay_ms(mp_uint_t ms) { usleep((ms) * 1000); }
-static inline void mp_hal_delay_us(mp_uint_t us) { usleep(us); }
+static inline void mp_hal_delay_ms(mp_uint_t ms) {
+    usleep((ms) * 1000);
+}
+static inline void mp_hal_delay_us(mp_uint_t us) {
+    usleep(us);
+}
 #define mp_hal_ticks_cpu() 0
 
+// This macro is used to implement PEP 475 to retry specified syscalls on EINTR
+#define MP_HAL_RETRY_SYSCALL(ret, syscall, raise) { \
+        for (;;) { \
+            MP_THREAD_GIL_EXIT(); \
+            ret = syscall; \
+            MP_THREAD_GIL_ENTER(); \
+            if (ret == -1) { \
+                int err = errno; \
+                if (err == EINTR) { \
+                    mp_handle_pending(true); \
+                    continue; \
+                } \
+                raise; \
+            } \
+            break; \
+        } \
+}
+
 #define RAISE_ERRNO(err_flag, error_val) \
     { if (err_flag == -1) \
-        { mp_raise_OSError(error_val); } }
+      { mp_raise_OSError(error_val); } }
+
+#if MICROPY_PY_BLUETOOTH
+enum {
+    MP_HAL_MAC_BDADDR,
+};
+
+void mp_hal_get_mac(int idx, uint8_t buf[6]);
+#endif
diff --git a/ports/unix/mpthreadport.c b/ports/unix/mpthreadport.c
index 4fe5fa9218811..711cf2a6bbffa 100644
--- a/ports/unix/mpthreadport.c
+++ b/ports/unix/mpthreadport.c
@@ -39,6 +39,19 @@
 #include <sched.h>
 #include <semaphore.h>
 
+#include "lib/utils/gchelper.h"
+
+// Some platforms don't have SIGRTMIN but if we do have it, use it to avoid
+// potential conflict with other uses of the more commonly used SIGUSR1.
+#ifdef SIGRTMIN
+#define MP_THREAD_GC_SIGNAL (SIGRTMIN + 5)
+#else
+#define MP_THREAD_GC_SIGNAL (SIGUSR1)
+#endif
+
+// This value seems to be about right for both 32-bit and 64-bit builds.
+#define THREAD_STACK_OVERFLOW_MARGIN (8192)
+
 // this structure forms a linked list, one node per active thread
 typedef struct _thread_t {
     pthread_t id;           // system id of thread
@@ -49,7 +62,9 @@ typedef struct _thread_t {
 
 STATIC pthread_key_t tls_key;
 
-// the mutex controls access to the linked list
+// The mutex is used for any code in this port that needs to be thread safe.
+// Specifically for thread management, access to the linked list is one example.
+// But also, e.g. scheduler state.
 STATIC pthread_mutex_t thread_mutex = PTHREAD_MUTEX_INITIALIZER;
 STATIC thread_t *thread;
 
@@ -62,22 +77,29 @@ STATIC sem_t *thread_signal_done_p;
 STATIC sem_t thread_signal_done;
 #endif
 
+void mp_thread_unix_begin_atomic_section(void) {
+    pthread_mutex_lock(&thread_mutex);
+}
+
+void mp_thread_unix_end_atomic_section(void) {
+    pthread_mutex_unlock(&thread_mutex);
+}
+
 // this signal handler is used to scan the regs and stack of a thread
 STATIC void mp_thread_gc(int signo, siginfo_t *info, void *context) {
     (void)info; // unused
     (void)context; // unused
-    if (signo == SIGUSR1) {
-        void gc_collect_regs_and_stack(void);
-        gc_collect_regs_and_stack();
+    if (signo == MP_THREAD_GC_SIGNAL) {
+        gc_helper_collect_regs_and_stack();
         // We have access to the context (regs, stack) of the thread but it seems
         // that we don't need the extra information, enough is captured by the
         // gc_collect_regs_and_stack function above
-        //gc_collect_root((void**)context, sizeof(ucontext_t) / sizeof(uintptr_t));
+        // gc_collect_root((void**)context, sizeof(ucontext_t) / sizeof(uintptr_t));
         #if MICROPY_ENABLE_PYSTACK
-        void **ptrs = (void**)(void*)MP_STATE_THREAD(pystack_start);
-        gc_collect_root(ptrs, (MP_STATE_THREAD(pystack_cur) - MP_STATE_THREAD(pystack_start)) / sizeof(void*));
+        void **ptrs = (void **)(void *)MP_STATE_THREAD(pystack_start);
+        gc_collect_root(ptrs, (MP_STATE_THREAD(pystack_cur) - MP_STATE_THREAD(pystack_start)) / sizeof(void *));
         #endif
-        #if defined (__APPLE__)
+        #if defined(__APPLE__)
         sem_post(thread_signal_done_p);
         #else
         sem_post(&thread_signal_done);
@@ -108,18 +130,18 @@ void mp_thread_init(void) {
     sa.sa_flags = SA_SIGINFO;
     sa.sa_sigaction = mp_thread_gc;
     sigemptyset(&sa.sa_mask);
-    sigaction(SIGUSR1, &sa, NULL);
+    sigaction(MP_THREAD_GC_SIGNAL, &sa, NULL);
 }
 
 void mp_thread_deinit(void) {
-    pthread_mutex_lock(&thread_mutex);
+    mp_thread_unix_begin_atomic_section();
     while (thread->next != NULL) {
         thread_t *th = thread;
         thread = thread->next;
         pthread_cancel(th->id);
         free(th);
     }
-    pthread_mutex_unlock(&thread_mutex);
+    mp_thread_unix_end_atomic_section();
     #if defined(__APPLE__)
     sem_close(thread_signal_done_p);
     sem_unlink(thread_signal_done_name);
@@ -135,7 +157,7 @@ void mp_thread_deinit(void) {
 // the global root pointers (in mp_state_ctx) while another thread is doing a
 // garbage collection and tracing these pointers.
 void mp_thread_gc_others(void) {
-    pthread_mutex_lock(&thread_mutex);
+    mp_thread_unix_begin_atomic_section();
     for (thread_t *th = thread; th != NULL; th = th->next) {
         gc_collect_root(&th->arg, 1);
         if (th->id == pthread_self()) {
@@ -144,37 +166,37 @@ void mp_thread_gc_others(void) {
         if (!th->ready) {
             continue;
         }
-        pthread_kill(th->id, SIGUSR1);
+        pthread_kill(th->id, MP_THREAD_GC_SIGNAL);
         #if defined(__APPLE__)
         sem_wait(thread_signal_done_p);
         #else
         sem_wait(&thread_signal_done);
         #endif
     }
-    pthread_mutex_unlock(&thread_mutex);
+    mp_thread_unix_end_atomic_section();
 }
 
 mp_state_thread_t *mp_thread_get_state(void) {
-    return (mp_state_thread_t*)pthread_getspecific(tls_key);
+    return (mp_state_thread_t *)pthread_getspecific(tls_key);
 }
 
-void mp_thread_set_state(void *state) {
+void mp_thread_set_state(mp_state_thread_t *state) {
     pthread_setspecific(tls_key, state);
 }
 
 void mp_thread_start(void) {
     pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
-    pthread_mutex_lock(&thread_mutex);
+    mp_thread_unix_begin_atomic_section();
     for (thread_t *th = thread; th != NULL; th = th->next) {
         if (th->id == pthread_self()) {
             th->ready = 1;
             break;
         }
     }
-    pthread_mutex_unlock(&thread_mutex);
+    mp_thread_unix_end_atomic_section();
 }
 
-void mp_thread_create(void *(*entry)(void*), void *arg, size_t *stack_size) {
+void mp_thread_create(void *(*entry)(void *), void *arg, size_t *stack_size) {
     // default stack size is 8k machine-words
     if (*stack_size == 0) {
         *stack_size = 8192 * BYTES_PER_WORD;
@@ -185,6 +207,11 @@ void mp_thread_create(void *(*entry)(void*), void *arg, size_t *stack_size) {
         *stack_size = PTHREAD_STACK_MIN;
     }
 
+    // ensure there is enough stack to include a stack-overflow margin
+    if (*stack_size < 2 * THREAD_STACK_OVERFLOW_MARGIN) {
+        *stack_size = 2 * THREAD_STACK_OVERFLOW_MARGIN;
+    }
+
     // set thread attributes
     pthread_attr_t attr;
     int ret = pthread_attr_init(&attr);
@@ -201,19 +228,18 @@ void mp_thread_create(void *(*entry)(void*), void *arg, size_t *stack_size) {
         goto er;
     }
 
-    pthread_mutex_lock(&thread_mutex);
+    mp_thread_unix_begin_atomic_section();
 
     // create thread
     pthread_t id;
     ret = pthread_create(&id, &attr, entry, arg);
     if (ret != 0) {
-        pthread_mutex_unlock(&thread_mutex);
+        mp_thread_unix_end_atomic_section();
         goto er;
     }
 
     // adjust stack_size to provide room to recover from hitting the limit
-    // this value seems to be about right for both 32-bit and 64-bit builds
-    *stack_size -= 8192;
+    *stack_size -= THREAD_STACK_OVERFLOW_MARGIN;
 
     // add thread to linked list of all threads
     thread_t *th = malloc(sizeof(thread_t));
@@ -223,7 +249,7 @@ void mp_thread_create(void *(*entry)(void*), void *arg, size_t *stack_size) {
     th->next = thread;
     thread = th;
 
-    pthread_mutex_unlock(&thread_mutex);
+    mp_thread_unix_end_atomic_section();
 
     return;
 
@@ -232,7 +258,7 @@ void mp_thread_create(void *(*entry)(void*), void *arg, size_t *stack_size) {
 }
 
 void mp_thread_finish(void) {
-    pthread_mutex_lock(&thread_mutex);
+    mp_thread_unix_begin_atomic_section();
     thread_t *prev = NULL;
     for (thread_t *th = thread; th != NULL; th = th->next) {
         if (th->id == pthread_self()) {
@@ -246,7 +272,7 @@ void mp_thread_finish(void) {
         }
         prev = th;
     }
-    pthread_mutex_unlock(&thread_mutex);
+    mp_thread_unix_end_atomic_section();
 }
 
 void mp_thread_mutex_init(mp_thread_mutex_t *mutex) {
diff --git a/ports/unix/mpthreadport.h b/ports/unix/mpthreadport.h
index dfd2975c25897..a7dbe08c4943d 100644
--- a/ports/unix/mpthreadport.h
+++ b/ports/unix/mpthreadport.h
@@ -31,3 +31,8 @@ typedef pthread_mutex_t mp_thread_mutex_t;
 void mp_thread_init(void);
 void mp_thread_deinit(void);
 void mp_thread_gc_others(void);
+
+// Unix version of "enable/disable IRQs".
+// Functions as a port-global lock for any code that must be serialised.
+void mp_thread_unix_begin_atomic_section(void);
+void mp_thread_unix_end_atomic_section(void);
diff --git a/ports/unix/qstrdefsport.h b/ports/unix/qstrdefsport.h
index ebfaa6ccab036..8b827a8d64761 100644
--- a/ports/unix/qstrdefsport.h
+++ b/ports/unix/qstrdefsport.h
@@ -23,3 +23,5 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+
+// *FORMAT-OFF*
diff --git a/ports/unix/unix_mphal.c b/ports/unix/unix_mphal.c
index f27c62fd1d1dc..42c22f7b50482 100644
--- a/ports/unix/unix_mphal.c
+++ b/ports/unix/unix_mphal.c
@@ -27,9 +27,11 @@
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 #include <sys/time.h>
 
 #include "py/mphal.h"
+#include "py/mpthread.h"
 #include "py/runtime.h"
 #include "extmod/misc.h"
 
@@ -39,6 +41,11 @@
 STATIC void sighandler(int signum) {
     if (signum == SIGINT) {
         #if MICROPY_ASYNC_KBD_INTR
+        #if MICROPY_PY_THREAD_GIL
+        // Since signals can occur at any time, we may not be holding the GIL when
+        // this callback is called, so it is not safe to raise an exception here
+        #error "MICROPY_ASYNC_KBD_INTR and MICROPY_PY_THREAD_GIL are not compatible"
+        #endif
         mp_obj_exception_clear_traceback(MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_kbd_exception)));
         sigset_t mask;
         sigemptyset(&mask);
@@ -51,8 +58,7 @@ STATIC void sighandler(int signum) {
             // this is the second time we are called, so die straight away
             exit(1);
         }
-        mp_obj_exception_clear_traceback(MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_kbd_exception)));
-        MP_STATE_VM(mp_pending_exception) = MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_kbd_exception));
+        mp_keyboard_interrupt();
         #endif
     }
 }
@@ -126,7 +132,7 @@ static int call_dupterm_read(size_t idx) {
             return -1;
         }
         nlr_pop();
-        return *(byte*)bufinfo.buf;
+        return *(byte *)bufinfo.buf;
     } else {
         // Temporarily disable dupterm to avoid infinite recursion
         mp_obj_t save_term = MP_STATE_VM(dupterm_objs[idx]);
@@ -141,13 +147,12 @@ static int call_dupterm_read(size_t idx) {
 #endif
 
 int mp_hal_stdin_rx_chr(void) {
-    unsigned char c;
-#if MICROPY_PY_OS_DUPTERM
+    #if MICROPY_PY_OS_DUPTERM
     // TODO only support dupterm one slot at the moment
     if (MP_STATE_VM(dupterm_objs[0]) != MP_OBJ_NULL) {
         int c;
         do {
-             c = call_dupterm_read(0);
+            c = call_dupterm_read(0);
         } while (c == -2);
         if (c == -1) {
             goto main_term;
@@ -156,25 +161,25 @@ int mp_hal_stdin_rx_chr(void) {
             c = '\r';
         }
         return c;
-    } else {
-        main_term:;
-#endif
-        int ret = read(0, &c, 1);
-        if (ret == 0) {
-            c = 4; // EOF, ctrl-D
-        } else if (c == '\n') {
-            c = '\r';
-        }
-        return c;
-#if MICROPY_PY_OS_DUPTERM
     }
-#endif
+main_term:;
+    #endif
+
+    unsigned char c;
+    ssize_t ret;
+    MP_HAL_RETRY_SYSCALL(ret, read(STDIN_FILENO, &c, 1), {});
+    if (ret == 0) {
+        c = 4; // EOF, ctrl-D
+    } else if (c == '\n') {
+        c = '\r';
+    }
+    return c;
 }
 
 void mp_hal_stdout_tx_strn(const char *str, size_t len) {
-    int ret = write(1, str, len);
+    ssize_t ret;
+    MP_HAL_RETRY_SYSCALL(ret, write(STDOUT_FILENO, str, len), {});
     mp_uos_dupterm_tx_strn(str, len);
-    (void)ret; // to suppress compiler warning
 }
 
 // cooked is same as uncooked because the terminal does some postprocessing
@@ -187,13 +192,25 @@ void mp_hal_stdout_tx_str(const char *str) {
 }
 
 mp_uint_t mp_hal_ticks_ms(void) {
+    #if (defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0) && defined(_POSIX_MONOTONIC_CLOCK)
+    struct timespec tv;
+    clock_gettime(CLOCK_MONOTONIC, &tv);
+    return tv.tv_sec * 1000 + tv.tv_nsec / 1000000;
+    #else
     struct timeval tv;
     gettimeofday(&tv, NULL);
     return tv.tv_sec * 1000 + tv.tv_usec / 1000;
+    #endif
 }
 
 mp_uint_t mp_hal_ticks_us(void) {
+    #if (defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0) && defined(_POSIX_MONOTONIC_CLOCK)
+    struct timespec tv;
+    clock_gettime(CLOCK_MONOTONIC, &tv);
+    return tv.tv_sec * 1000000 + tv.tv_nsec / 1000;
+    #else
     struct timeval tv;
     gettimeofday(&tv, NULL);
     return tv.tv_sec * 1000000 + tv.tv_usec;
+    #endif
 }
diff --git a/ports/unix/mpconfigport_coverage.h b/ports/unix/variants/coverage/mpconfigvariant.h
similarity index 85%
rename from ports/unix/mpconfigport_coverage.h
rename to ports/unix/variants/coverage/mpconfigvariant.h
index 87bf8454cec19..802c2fe5f7203 100644
--- a/ports/unix/mpconfigport_coverage.h
+++ b/ports/unix/variants/coverage/mpconfigvariant.h
@@ -24,22 +24,23 @@
  * THE SOFTWARE.
  */
 
-// Default unix config while intended to be comprehensive, may still not enable
-// all the features, this config should enable more (testable) options.
+// This config enables almost all possible features such that it can be used
+// for coverage testing.
 
 #define MICROPY_VFS                    (1)
 #define MICROPY_PY_UOS_VFS             (1)
 
-#include <mpconfigport.h>
-
 #define MICROPY_OPT_MATH_FACTORIAL     (1)
 #define MICROPY_FLOAT_HIGH_QUALITY_HASH (1)
 #define MICROPY_ENABLE_SCHEDULER       (1)
 #define MICROPY_READER_VFS             (1)
+#define MICROPY_REPL_EMACS_WORDS_MOVE  (1)
+#define MICROPY_REPL_EMACS_EXTRA_WORDS_MOVE (1)
 #define MICROPY_WARNINGS_CATEGORY      (1)
 #define MICROPY_MODULE_GETATTR         (1)
 #define MICROPY_PY_DELATTR_SETATTR     (1)
 #define MICROPY_PY_REVERSE_SPECIAL_METHODS (1)
+#define MICROPY_PY_BUILTINS_MEMORYVIEW_ITEMSIZE (1)
 #define MICROPY_PY_BUILTINS_NEXT2      (1)
 #define MICROPY_PY_BUILTINS_RANGE_BINOP (1)
 #define MICROPY_PY_BUILTINS_HELP       (1)
@@ -49,19 +50,17 @@
 #define MICROPY_PY_URANDOM_EXTRA_FUNCS (1)
 #define MICROPY_PY_IO_BUFFEREDWRITER (1)
 #define MICROPY_PY_IO_RESOURCE_STREAM (1)
+#define MICROPY_PY_UASYNCIO            (1)
+#define MICROPY_PY_URE_DEBUG           (1)
 #define MICROPY_PY_URE_MATCH_GROUPS    (1)
 #define MICROPY_PY_URE_MATCH_SPAN_START_END (1)
 #define MICROPY_PY_URE_SUB             (1)
 #define MICROPY_VFS_POSIX              (1)
-#undef MICROPY_VFS_FAT
-#define MICROPY_VFS_FAT                (1)
 #define MICROPY_PY_FRAMEBUF            (1)
 #define MICROPY_PY_COLLECTIONS_NAMEDTUPLE__ASDICT (1)
 #define MICROPY_PY_UCRYPTOLIB          (1)
-
-// TODO these should be generic, not bound to fatfs
-#define mp_type_fileio mp_type_vfs_posix_fileio
-#define mp_type_textio mp_type_vfs_posix_textio
+#define MICROPY_PY_UCRYPTOLIB_CTR      (1)
+#define MICROPY_PY_MICROPYTHON_HEAP_LOCKED (1)
 
 // use vfs's functions for import stat and builtin open
 #define mp_import_stat mp_vfs_import_stat
diff --git a/ports/unix/variants/coverage/mpconfigvariant.mk b/ports/unix/variants/coverage/mpconfigvariant.mk
new file mode 100644
index 0000000000000..ddb5027a97ef7
--- /dev/null
+++ b/ports/unix/variants/coverage/mpconfigvariant.mk
@@ -0,0 +1,20 @@
+PROG ?= micropython-coverage
+
+# Disable optimisations and enable assert() on coverage builds.
+DEBUG ?= 1
+
+CFLAGS += \
+	-fprofile-arcs -ftest-coverage \
+	-Wformat -Wmissing-declarations -Wmissing-prototypes \
+	-Wold-style-definition -Wpointer-arith -Wshadow -Wuninitialized -Wunused-parameter \
+	-DMICROPY_UNIX_COVERAGE
+
+LDFLAGS += -fprofile-arcs -ftest-coverage
+
+FROZEN_MANIFEST = manifest_coverage.py
+
+MICROPY_ROM_TEXT_COMPRESSION = 1
+MICROPY_VFS_FAT = 1
+MICROPY_VFS_LFS1 = 1
+MICROPY_VFS_LFS2 = 1
+MICROPY_PY_BLUETOOTH = 1
diff --git a/ports/unix/variants/dev/mpconfigvariant.h b/ports/unix/variants/dev/mpconfigvariant.h
new file mode 100644
index 0000000000000..eb65134717c6d
--- /dev/null
+++ b/ports/unix/variants/dev/mpconfigvariant.h
@@ -0,0 +1,32 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#define MICROPY_REPL_EMACS_WORDS_MOVE (1)
+#define MICROPY_REPL_EMACS_EXTRA_WORDS_MOVE (1)
+#define MICROPY_ENABLE_SCHEDULER (1)
+
+#define MICROPY_PY_SYS_SETTRACE (1)
+#define MICROPY_PY_URANDOM_EXTRA_FUNCS (1)
diff --git a/ports/unix/variants/dev/mpconfigvariant.mk b/ports/unix/variants/dev/mpconfigvariant.mk
new file mode 100644
index 0000000000000..bbd30b6238248
--- /dev/null
+++ b/ports/unix/variants/dev/mpconfigvariant.mk
@@ -0,0 +1,5 @@
+PROG ?= micropython-dev
+
+MICROPY_ROM_TEXT_COMPRESSION = 1
+
+MICROPY_PY_BLUETOOTH = 1
diff --git a/ports/unix/mpconfigport_fast.h b/ports/unix/variants/fast/mpconfigvariant.h
similarity index 89%
rename from ports/unix/mpconfigport_fast.h
rename to ports/unix/variants/fast/mpconfigvariant.h
index 442159eb4f615..6d73275fdebfc 100644
--- a/ports/unix/mpconfigport_fast.h
+++ b/ports/unix/variants/fast/mpconfigvariant.h
@@ -28,13 +28,9 @@
 // synthetic benchmarking, at the expense of features supported and memory
 // usage. This config is not intended to be used in production.
 
-#include <mpconfigport.h>
 #define MICROPY_PY___FILE__ (0)
 // 91 is a magic number proposed by @dpgeorge, which make pystone run ~ at tie
 // with CPython 3.4.
 #define MICROPY_MODULE_DICT_SIZE (91)
 
-// Don't include builtin upip, as this build is again intended just for
-// synthetic benchmarking
-#undef MICROPY_MODULE_FROZEN_STR
-#define MICROPY_MODULE_FROZEN_STR (0)
+#include "variants/DEV/mpconfigvariant.h"
diff --git a/ports/unix/variants/fast/mpconfigvariant.mk b/ports/unix/variants/fast/mpconfigvariant.mk
new file mode 100644
index 0000000000000..d67f7c8f38388
--- /dev/null
+++ b/ports/unix/variants/fast/mpconfigvariant.mk
@@ -0,0 +1,7 @@
+# build synthetically fast interpreter for benchmarking
+
+COPT += "-fno-crossjumping -O2"
+
+PROG = micropython-fast
+
+FROZEN_MANIFEST =
diff --git a/ports/unix/mpconfigport_freedos.h b/ports/unix/variants/freedos/mpconfigvariant.h
similarity index 94%
rename from ports/unix/mpconfigport_freedos.h
rename to ports/unix/variants/freedos/mpconfigvariant.h
index 09c85ab1e3377..338b34492de7f 100644
--- a/ports/unix/mpconfigport_freedos.h
+++ b/ports/unix/variants/freedos/mpconfigvariant.h
@@ -26,15 +26,15 @@
 
 // options to control how MicroPython is built
 
-#include <mpconfigport.h>
+#define MICROPY_PY_USELECT_POSIX (0)
 
-#undef MICROPY_STREAMS_NON_BLOCK
 #define MICROPY_STREAMS_NON_BLOCK (0)
 
-#undef MICROPY_PY_SYS_PLATFORM
 #define MICROPY_PY_SYS_PLATFORM "freedos"
 
 // djgpp dirent struct does not have d_ino field
 #undef _DIRENT_HAVE_D_INO
 
 #define MICROPY_USE_INTERNAL_ERRNO  (1)
+
+#include "variants/DEV/mpconfigvariant.h"
diff --git a/ports/unix/variants/freedos/mpconfigvariant.mk b/ports/unix/variants/freedos/mpconfigvariant.mk
new file mode 100644
index 0000000000000..a30db3e0c1490
--- /dev/null
+++ b/ports/unix/variants/freedos/mpconfigvariant.mk
@@ -0,0 +1,20 @@
+CC = i586-pc-msdosdjgpp-gcc
+
+STRIP = i586-pc-msdosdjgpp-strip
+
+SIZE = i586-pc-msdosdjgpp-size
+
+CFLAGS += \
+	-DMICROPY_NLR_SETJMP \
+	-Dtgamma=gamma \
+	-DMICROPY_EMIT_X86=0 \
+	-DMICROPY_NO_ALLOCA=1 \
+
+PROG = micropython-freedos
+
+MICROPY_PY_SOCKET = 0
+MICROPY_PY_FFI = 0
+MICROPY_PY_JNI = 0
+MICROPY_PY_BTREE = 0
+MICROPY_PY_THREAD = 0
+MICROPY_PY_USSL = 0
diff --git a/ports/unix/mpconfigport_minimal.h b/ports/unix/variants/minimal/mpconfigvariant.h
similarity index 93%
rename from ports/unix/mpconfigport_minimal.h
rename to ports/unix/variants/minimal/mpconfigvariant.h
index c49819e742aef..e87b5d8ec0ff3 100644
--- a/ports/unix/mpconfigport_minimal.h
+++ b/ports/unix/variants/minimal/mpconfigvariant.h
@@ -26,6 +26,9 @@
 
 // options to control how MicroPython is built
 
+// Prevent the rest of the default mpconfigport.h being used.
+#define MICROPY_UNIX_MINIMAL (1)
+
 #define MICROPY_ALLOC_QSTR_CHUNK_INIT (64)
 #define MICROPY_ALLOC_PARSE_RULE_INIT (8)
 #define MICROPY_ALLOC_PARSE_RULE_INC  (8)
@@ -107,14 +110,9 @@ extern const struct _mp_obj_module_t mp_module_os;
 // Do not change anything beyond this line
 //////////////////////////////////////////
 
-// Define to 1 to use undertested inefficient GC helper implementation
-// (if more efficient arch-specific one is not available).
-#ifndef MICROPY_GCREGS_SETJMP
-    #ifdef __mips__
-        #define MICROPY_GCREGS_SETJMP (1)
-    #else
-        #define MICROPY_GCREGS_SETJMP (0)
-    #endif
+#if !(defined(MICROPY_GCREGS_SETJMP) || defined(__x86_64__) || defined(__i386__) || defined(__thumb2__) || defined(__thumb__) || defined(__arm__))
+// Fall back to setjmp() implementation for discovery of GC pointers in registers.
+#define MICROPY_GCREGS_SETJMP (1)
 #endif
 
 // type definitions for the specific machine
diff --git a/ports/unix/variants/minimal/mpconfigvariant.mk b/ports/unix/variants/minimal/mpconfigvariant.mk
new file mode 100644
index 0000000000000..ec3b21c0b979c
--- /dev/null
+++ b/ports/unix/variants/minimal/mpconfigvariant.mk
@@ -0,0 +1,13 @@
+# build a minimal interpreter
+PROG = micropython-minimal
+
+FROZEN_MANIFEST =
+
+MICROPY_ROM_TEXT_COMPRESSION = 1
+MICROPY_PY_BTREE = 0
+MICROPY_PY_FFI = 0
+MICROPY_PY_SOCKET = 0
+MICROPY_PY_THREAD = 0
+MICROPY_PY_TERMIOS = 0
+MICROPY_PY_USSL = 0
+MICROPY_USE_READLINE = 0
diff --git a/ports/unix/variants/nanbox/mpconfigvariant.h b/ports/unix/variants/nanbox/mpconfigvariant.h
new file mode 100644
index 0000000000000..f827158fb7127
--- /dev/null
+++ b/ports/unix/variants/nanbox/mpconfigvariant.h
@@ -0,0 +1,45 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// This config is mostly used to ensure that the nan-boxing object model
+// continues to build (i.e. catches usage of mp_obj_t that don't work with
+// this representation).
+
+// select nan-boxing object model
+#define MICROPY_OBJ_REPR (MICROPY_OBJ_REPR_D)
+
+// native emitters don't work with nan-boxing
+#define MICROPY_EMIT_X86 (0)
+#define MICROPY_EMIT_X64 (0)
+#define MICROPY_EMIT_THUMB (0)
+#define MICROPY_EMIT_ARM (0)
+
+#include <stdint.h>
+
+typedef int64_t mp_int_t;
+typedef uint64_t mp_uint_t;
+#define UINT_FMT "%llu"
+#define INT_FMT "%lld"
diff --git a/ports/unix/variants/nanbox/mpconfigvariant.mk b/ports/unix/variants/nanbox/mpconfigvariant.mk
new file mode 100644
index 0000000000000..9752b922c1e31
--- /dev/null
+++ b/ports/unix/variants/nanbox/mpconfigvariant.mk
@@ -0,0 +1,4 @@
+# build interpreter with nan-boxing as object model (object repr D)
+PROG = micropython-nanbox
+
+MICROPY_FORCE_32BIT = 1
diff --git a/ports/unix/variants/standard/mpconfigvariant.h b/ports/unix/variants/standard/mpconfigvariant.h
new file mode 100644
index 0000000000000..79b8fe2a3be2b
--- /dev/null
+++ b/ports/unix/variants/standard/mpconfigvariant.h
@@ -0,0 +1,26 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
diff --git a/ports/unix/variants/standard/mpconfigvariant.mk b/ports/unix/variants/standard/mpconfigvariant.mk
new file mode 100644
index 0000000000000..cf3efab8ae7d9
--- /dev/null
+++ b/ports/unix/variants/standard/mpconfigvariant.mk
@@ -0,0 +1,3 @@
+# This is the default variant when you `make` the Unix port.
+
+PROG ?= micropython
diff --git a/ports/windows/.appveyor.yml b/ports/windows/.appveyor.yml
index 795330eff01d5..2965543b05942 100644
--- a/ports/windows/.appveyor.yml
+++ b/ports/windows/.appveyor.yml
@@ -1,3 +1,7 @@
+image: Visual Studio 2013
+clone_depth: 1
+skip_tags: true
+
 environment:
   # Python version used
   MICROPY_CPYTHON3: c:/python34/python.exe
@@ -14,15 +18,27 @@ platform:
 - x86
 - x64
 
+before_build:
+- ps: |
+    @"
+    <?xml version="1.0" encoding="utf-8"?>
+    <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+      <Target Name="Build">
+        <MsBuild BuildInParallel="True" Projects="mpy-cross\mpy-cross.vcxproj;ports\windows\micropython.vcxproj"/>
+      </Target>
+    </Project>
+    "@ | Set-Content build.proj
+
 build:
-  project: ports/windows/micropython.vcxproj
+  project: build.proj
+  parallel: true
   verbosity: normal
 
 test_script:
-- cmd: >-
-    cd tests
-
-    %MICROPY_CPYTHON3% run-tests
+- ps: |
+    cd (Join-Path $env:APPVEYOR_BUILD_FOLDER 'tests')
+    & $env:MICROPY_CPYTHON3 run-tests
+    & $env:MICROPY_CPYTHON3 run-tests --via-mpy -d basics float micropython
 
 # After the build/test phase for the MSVC build completes,
 # build and test with mingw-w64, release versions only.
@@ -38,15 +54,24 @@ after_test:
     if ($LASTEXITCODE -ne 0) {
       throw "$env:MSYSTEM build exited with code $LASTEXITCODE"
     }
+    cd (Join-Path $env:APPVEYOR_BUILD_FOLDER 'mpy-cross')
+    # Building of mpy-cross hasn't been fixed across all possible windows/WSL/...
+    # variations and the STRIP step tries to strip mpy-cross whereas that should be
+    # mpy-cross.exe. Workaround for now by skipping actual strip and size commands.
+    C:\msys64\usr\bin\bash.exe -l -c "make -B -j4 V=1 STRIP=echo SIZE=echo"
+    if ($LASTEXITCODE -ne 0) {
+      throw "$env:MSYSTEM mpy_cross build exited with code $LASTEXITCODE"
+    }
     cd (Join-Path $env:APPVEYOR_BUILD_FOLDER 'tests')
-    & $env:MICROPY_CPYTHON3 run-tests -e math_fun -e float2int_double -e float_parse -e math_domain_special
+    $testArgs = @('run-tests')
+    foreach ($skipTest in @('math_fun', 'float2int_double', 'float_parse', 'math_domain_special')) {
+      $testArgs = $testArgs + '-e' + $skipTest
+    }
+    & $env:MICROPY_CPYTHON3 $testArgs
     if ($LASTEXITCODE -ne 0) {
       throw "$env:MSYSTEM tests exited with code $LASTEXITCODE"
     }
-
-skip_tags: true
-
-deploy: off
-
-nuget:
-  disable_publish_on_pr: true
+    & $env:MICROPY_CPYTHON3 ($testArgs + @('--via-mpy', '-d', 'basics', 'float', 'micropython'))
+    if ($LASTEXITCODE -ne 0) {
+      throw "$env:MSYSTEM mpy-cross tests exited with code $LASTEXITCODE"
+    }
diff --git a/ports/windows/Makefile b/ports/windows/Makefile
index 88d103e7b0f19..b2d11872ed3a6 100644
--- a/ports/windows/Makefile
+++ b/ports/windows/Makefile
@@ -15,8 +15,8 @@ INC += -I$(TOP)
 INC += -I$(BUILD)
 
 # compiler settings
-CFLAGS = $(INC) -Wall -Wpointer-arith -Werror -std=gnu99 -DUNIX -D__USE_MINGW_ANSI_STDIO=1 $(CFLAGS_MOD) $(COPT)
-LDFLAGS = $(LDFLAGS_MOD) -lm
+CFLAGS = $(INC) -Wall -Wpointer-arith -Wdouble-promotion -Werror -std=gnu99 -DUNIX -D__USE_MINGW_ANSI_STDIO=1 $(CFLAGS_MOD) $(COPT) $(CFLAGS_EXTRA)
+LDFLAGS = $(LDFLAGS_MOD) -lm $(LDFLAGS_EXTRA)
 
 # Debugging/Optimization
 ifdef DEBUG
@@ -28,9 +28,9 @@ endif
 
 # source files
 SRC_C = \
+	lib/utils/gchelper_generic.c \
 	lib/utils/printf.c \
 	ports/unix/main.c \
-	ports/unix/file.c \
 	ports/unix/input.c \
 	ports/unix/modos.c \
 	ports/unix/modmachine.c \
@@ -40,6 +40,8 @@ SRC_C = \
 	realpath.c \
 	init.c \
 	sleep.c \
+	fmode.c \
+	$(SRC_MOD)
 
 OBJ = $(PY_O) $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
 
diff --git a/ports/windows/fmode.c b/ports/windows/fmode.c
index 33ba24ed1f8bc..a7976b87e32dc 100644
--- a/ports/windows/fmode.c
+++ b/ports/windows/fmode.c
@@ -32,12 +32,12 @@
 // Workaround for setting file translation mode: we must distinguish toolsets
 // since mingw has no _set_fmode, and altering msvc's _fmode directly has no effect
 STATIC int set_fmode_impl(int mode) {
-#ifndef _MSC_VER
+    #ifndef _MSC_VER
     _fmode = mode;
     return 0;
-#else
+    #else
     return _set_fmode(mode);
-#endif
+    #endif
 }
 
 void set_fmode_binary(void) {
diff --git a/ports/windows/init.c b/ports/windows/init.c
index 09fa10417bbe3..930400fdedcfd 100644
--- a/ports/windows/init.c
+++ b/ports/windows/init.c
@@ -31,6 +31,7 @@
 #include <crtdbg.h>
 #endif
 #include "sleep.h"
+#include "fmode.h"
 
 extern BOOL WINAPI console_sighandler(DWORD evt);
 
@@ -40,7 +41,7 @@ void invalid_param_handler(const wchar_t *expr, const wchar_t *fun, const wchar_
 #endif
 
 void init() {
-#ifdef _MSC_VER
+    #ifdef _MSC_VER
     // Disable the 'Debug Error!' dialog for assertions failures and the likes,
     // instead write messages to the debugger output and terminate.
     _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG);
@@ -51,16 +52,17 @@ void init() {
     // passing invalid file descriptors to functions like lseek() and make the
     // functions called behave properly by setting errno to EBADF/EINVAL/..
     _set_invalid_parameter_handler(invalid_param_handler);
-#endif
+    #endif
     SetConsoleCtrlHandler(console_sighandler, TRUE);
     init_sleep();
-#ifdef __MINGW32__
+    #ifdef __MINGW32__
     putenv("PRINTF_EXPONENT_DIGITS=2");
-#elif _MSC_VER < 1900
+    #elif _MSC_VER < 1900
     // This is only necessary for Visual Studio versions 2013 and below:
     // https://msdn.microsoft.com/en-us/library/bb531344(v=vs.140).aspx
     _set_output_format(_TWO_DIGIT_EXPONENT);
-#endif
+    #endif
+    set_fmode_binary();
 }
 
 void deinit() {
diff --git a/ports/windows/micropython.vcxproj b/ports/windows/micropython.vcxproj
index ee0b98abba871..f70fe96158d07 100644
--- a/ports/windows/micropython.vcxproj
+++ b/ports/windows/micropython.vcxproj
@@ -25,29 +25,19 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>$(DefaultPlatformToolset)</PlatformToolset>
-    <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
     <PlatformToolset>$(DefaultPlatformToolset)</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>$(DefaultPlatformToolset)</PlatformToolset>
-    <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
     <PlatformToolset>$(DefaultPlatformToolset)</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
@@ -91,9 +81,27 @@
     <ClCompile />
     <Link />
   </ItemDefinitionGroup>
+  <Import Project="msvc/sources.props" />
   <ItemGroup>
+    <ClCompile Include="@(PyCoreSource)" />
+    <ClCompile Include="@(PyExtModSource)" />
+    <ClCompile Include="$(PyBaseDir)lib\mp-readline\*.c" />
+    <ClCompile Include="$(PyBaseDir)lib\utils\gchelper_generic.c" />
+    <ClCompile Include="$(PyBaseDir)ports\windows\*.c" />
+    <ClCompile Include="$(PyBaseDir)ports\windows\msvc\*.c" />
+    <ClCompile Include="$(PyBaseDir)ports\unix\gccollect.c"/>
+    <ClCompile Include="$(PyBaseDir)ports\unix\input.c"/>
+    <ClCompile Include="$(PyBaseDir)ports\unix\main.c"/>
+    <ClCompile Include="$(PyBaseDir)ports\unix\modos.c"/>
+    <ClCompile Include="$(PyBaseDir)ports\unix\modtime.c"/>
+    <ClCompile Include="$(PyBaseDir)ports\unix\modmachine.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="@(PyCoreInclude)" />
+    <ClInclude Include="@(PyExtModInclude)" />
+    <ClInclude Include="$(PyBaseDir)ports\windows\*.h" />
+    <ClInclude Include="$(PyBaseDir)ports\windows\msvc\*.h" />
   </ItemGroup>
-  <Import Project="msvc/sources.props" />
   <Import Project="msvc/genhdr.targets" />
   <Import Project="$(CustomPropsFile)" Condition="exists('$(CustomPropsFile)')" />
   <Target Name="GenHeaders" BeforeTargets="BuildGenerateSources" DependsOnTargets="GenerateHeaders">
diff --git a/ports/windows/mpconfigport.h b/ports/windows/mpconfigport.h
index 81464d72a7f13..fa09dda7527e0 100644
--- a/ports/windows/mpconfigport.h
+++ b/ports/windows/mpconfigport.h
@@ -31,7 +31,7 @@
 #define MICROPY_USE_READLINE        (1)
 #endif
 
-#define MICROPY_ALLOC_PATH_MAX      (260) //see minwindef.h for msvc or limits.h for mingw
+#define MICROPY_ALLOC_PATH_MAX      (260) // see minwindef.h for msvc or limits.h for mingw
 #define MICROPY_PERSISTENT_CODE_LOAD (1)
 #define MICROPY_EMIT_X64            (0)
 #define MICROPY_EMIT_THUMB          (0)
@@ -60,7 +60,9 @@
 #define MICROPY_STREAMS_POSIX_API   (1)
 #define MICROPY_OPT_COMPUTED_GOTO   (0)
 #define MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE (1)
+#define MICROPY_MODULE_WEAK_LINKS   (1)
 #define MICROPY_CAN_OVERRIDE_BUILTINS (1)
+#define MICROPY_VFS_POSIX_FILE      (1)
 #define MICROPY_PY_FUNCTION_ATTRS   (1)
 #define MICROPY_PY_DESCRIPTORS      (1)
 #define MICROPY_PY_BUILTINS_STR_UNICODE (1)
@@ -80,12 +82,16 @@
 #define MICROPY_PY_BUILTINS_SLICE_ATTRS (1)
 #define MICROPY_PY_SYS_EXIT         (1)
 #define MICROPY_PY_SYS_PLATFORM     "win32"
+#ifndef MICROPY_PY_SYS_PATH_DEFAULT
+#define MICROPY_PY_SYS_PATH_DEFAULT "~/.micropython/lib"
+#endif
 #define MICROPY_PY_SYS_MAXSIZE      (1)
 #define MICROPY_PY_SYS_STDFILES     (1)
 #define MICROPY_PY_SYS_EXC_INFO     (1)
 #define MICROPY_PY_COLLECTIONS_DEQUE (1)
 #define MICROPY_PY_COLLECTIONS_ORDEREDDICT (1)
 #define MICROPY_PY_MATH_SPECIAL_FUNCTIONS (1)
+#define MICROPY_PY_MATH_ISCLOSE     (1)
 #define MICROPY_PY_CMATH            (1)
 #define MICROPY_PY_IO_FILEIO        (1)
 #define MICROPY_PY_GC_COLLECT_RETVAL (1)
@@ -128,20 +134,23 @@ extern const struct _mp_print_t mp_stderr_print;
 #define MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE     (256)
 #define MICROPY_KBD_EXCEPTION       (1)
 
+#define mp_type_fileio mp_type_vfs_posix_fileio
+#define mp_type_textio mp_type_vfs_posix_textio
+
 #define MICROPY_PORT_INIT_FUNC      init()
 #define MICROPY_PORT_DEINIT_FUNC    deinit()
 
 // type definitions for the specific machine
 
-#if defined( __MINGW32__ ) && defined( __LP64__ )
+#if defined(__MINGW32__) && defined(__LP64__)
 typedef long mp_int_t; // must be pointer size
 typedef unsigned long mp_uint_t; // must be pointer size
-#elif defined ( __MINGW32__ ) && defined( _WIN64 )
+#elif defined(__MINGW32__) && defined(_WIN64)
 #include <stdint.h>
 typedef __int64 mp_int_t;
 typedef unsigned __int64 mp_uint_t;
 #define MP_SSIZE_MAX __INT64_MAX__
-#elif defined ( _MSC_VER ) && defined( _WIN64 )
+#elif defined(_MSC_VER) && defined(_WIN64)
 typedef __int64 mp_int_t;
 typedef unsigned __int64 mp_uint_t;
 #else
@@ -151,6 +160,8 @@ typedef int mp_int_t; // must be pointer size
 typedef unsigned int mp_uint_t; // must be pointer size
 #endif
 
+typedef long suseconds_t;
+
 // Just assume Windows is little-endian - mingw32 gcc doesn't
 // define standard endianness macros.
 #define MP_ENDIANNESS_LITTLE (1)
@@ -162,15 +173,6 @@ typedef long long mp_off_t;
 typedef long mp_off_t;
 #endif
 
-#if MICROPY_PY_OS_DUPTERM
-#define MP_PLAT_PRINT_STRN(str, len) mp_hal_stdout_tx_strn_cooked(str, len)
-void mp_hal_dupterm_tx_strn(const char *str, size_t len);
-#else
-#include <unistd.h>
-#define MP_PLAT_PRINT_STRN(str, len) do { int ret = write(1, str, len); (void)ret; } while (0)
-#define mp_hal_dupterm_tx_strn(s, l)
-#endif
-
 #define MICROPY_PORT_BUILTINS \
     { MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&mp_builtin_open_obj) },
 
@@ -206,7 +208,7 @@ extern const struct _mp_obj_module_t mp_module_time;
 
 // Sanity check
 
-#if ( _MSC_VER < 1800 )
+#if (_MSC_VER < 1800)
     #error Can only build with Visual Studio 2013 toolset
 #endif
 
@@ -214,33 +216,44 @@ extern const struct _mp_obj_module_t mp_module_time;
 // CL specific overrides from mpconfig
 
 #define NORETURN                    __declspec(noreturn)
+#define MP_WEAK
 #define MP_NOINLINE                 __declspec(noinline)
 #define MP_LIKELY(x)                (x)
 #define MP_UNLIKELY(x)              (x)
-#define MICROPY_PORT_CONSTANTS      { "dummy", 0 } //can't have zero-sized array
+#define MICROPY_PORT_CONSTANTS      { "dummy", 0 } // can't have zero-sized array
 #ifdef _WIN64
 #define MP_SSIZE_MAX                _I64_MAX
 #else
 #define MP_SSIZE_MAX                _I32_MAX
 #endif
 
+// VC++ 12.0 fixes
+#if (_MSC_VER <= 1800)
+#define MICROPY_PY_MATH_ATAN2_FIX_INFNAN (1)
+#define MICROPY_PY_MATH_FMOD_FIX_INFNAN (1)
+#ifdef _WIN64
+#define MICROPY_PY_MATH_MODF_FIX_NEGZERO (1)
+#endif
+#endif
 
 // CL specific definitions
 
+#ifndef __cplusplus
 #define restrict
 #define inline                      __inline
 #define alignof(t)                  __alignof(t)
+#endif
 #define PATH_MAX                    MICROPY_ALLOC_PATH_MAX
 #define S_ISREG(m)                  (((m) & S_IFMT) == S_IFREG)
 #define S_ISDIR(m)                  (((m) & S_IFMT) == S_IFDIR)
 #ifdef _WIN64
 #define SSIZE_MAX                   _I64_MAX
-typedef __int64                     ssize_t;
+typedef __int64 ssize_t;
 #else
 #define SSIZE_MAX                   _I32_MAX
-typedef int                         ssize_t;
+typedef int ssize_t;
 #endif
-typedef mp_off_t                    off_t;
+typedef mp_off_t off_t;
 
 
 // Put static/global variables in sections with a known name
@@ -254,7 +267,7 @@ typedef mp_off_t                    off_t;
 
 // System headers (needed e.g. for nlr.h)
 
-#include <stddef.h> //for NULL
-#include <assert.h> //for assert
+#include <stddef.h> // for NULL
+#include <assert.h> // for assert
 
 #endif
diff --git a/ports/windows/msvc/common.props b/ports/windows/msvc/common.props
index 26ea78e7e5111..fcad5aeb6b7ab 100644
--- a/ports/windows/msvc/common.props
+++ b/ports/windows/msvc/common.props
@@ -8,16 +8,18 @@
     <OutDir>$(PyOutDir)</OutDir>
     <IntDir>$(PyIntDir)</IntDir>
     <PyFileCopyCookie>$(PyBuildDir)copycookie$(Configuration)$(Platform)</PyFileCopyCookie>
+    <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <ItemDefinitionGroup>
     <ClCompile>
       <AdditionalIncludeDirectories>$(PyIncDirs);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>_USE_MATH_DEFINES;_CRT_SECURE_NO_WARNINGS;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_USE_MATH_DEFINES;_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_WARNINGS;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <SDLCheck>false</SDLCheck>
       <WarningLevel>Level1</WarningLevel>
       <ExceptionHandling>false</ExceptionHandling>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <MinimalRebuild>false</MinimalRebuild>
+      <TreatWarningAsError>true</TreatWarningAsError>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -26,7 +28,7 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <PyOutputFiles Include="$(TargetPath)">
-      <Destination>$(PyWinDir)%(FileName)%(Extension)</Destination>
+      <Destination>$(PyTargetDir)%(FileName)%(Extension)</Destination>
     </PyOutputFiles>
     <PyCookieFiles Include="$(PyBuildDir)copycookie*" Exclude="$(PyFileCopyCookie)"/>
   </ItemGroup>
diff --git a/ports/windows/msvc/debug.props b/ports/windows/msvc/debug.props
index fa1ca4fcbc998..5ae9d64fcd877 100644
--- a/ports/windows/msvc/debug.props
+++ b/ports/windows/msvc/debug.props
@@ -3,6 +3,8 @@
   <ImportGroup Label="PropertySheets" />
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
   </PropertyGroup>
   <ItemDefinitionGroup />
   <ItemGroup />
diff --git a/ports/windows/msvc/genhdr.targets b/ports/windows/msvc/genhdr.targets
index db8cfea7d75eb..327f922e4a162 100644
--- a/ports/windows/msvc/genhdr.targets
+++ b/ports/windows/msvc/genhdr.targets
@@ -54,7 +54,7 @@ using(var outFile = System.IO.File.CreateText(OutputFile)) {
   <Target Name="MakeQstrDefs" DependsOnTargets="MakeDestDir" Inputs="@(ClCompile);@(QstrDependencies)" Outputs="$(QstrDefsCollected)">
     <ItemGroup>
       <PyIncDirs Include="$(PyIncDirs)"/>
-      <PreProcDefs Include="%(ClCompile.PreProcessorDefinitions);NO_QSTR;N_X64;N_X86;N_THUMB;N_ARM"/>
+      <PreProcDefs Include="%(ClCompile.PreProcessorDefinitions);NO_QSTR"/>
       <PyQstrSourceFiles Include="@(ClCompile)">
         <OutFile>$([System.String]::new('%(FullPath)').Replace('$(PyBaseDir)', '$(DestDir)qstr\'))</OutFile>
       </PyQstrSourceFiles>
@@ -79,8 +79,8 @@ using(var outFile = System.IO.File.CreateText(OutputFile)) {
           Condition="'%(PyQstrSourceFiles.Changed)' == 'True' Or '$(ForceQstrRebuild)' == 'True'"/>
     <ConcatPreProcFiles InputFiles="@(PyQstrSourceFiles->'%(OutFile)')" OutputFile="$(DestDir)qstr.i.last"
                         Condition="'$(RunPreProcConcat)' == 'True' Or '$(ForceQstrRebuild)' == 'True'"/>
-    <Exec Command="$(PyPython) $(PySrcDir)makeqstrdefs.py split $(DestDir)qstr.i.last $(DestDir)qstr $(QstrDefsCollected)"/>
-    <Exec Command="$(PyPython) $(PySrcDir)makeqstrdefs.py cat $(DestDir)qstr.i.last $(DestDir)qstr $(QstrDefsCollected)"/>
+    <Exec Command="$(PyPython) $(PySrcDir)makeqstrdefs.py split qstr $(DestDir)qstr.i.last $(DestDir)qstr _"/>
+    <Exec Command="$(PyPython) $(PySrcDir)makeqstrdefs.py cat qstr _ $(DestDir)qstr $(QstrDefsCollected)"/>
   </Target>
 
   <Target Name="MakeModuleDefs" DependsOnTargets="MakeDestDir">
diff --git a/ports/windows/msvc/paths.props b/ports/windows/msvc/paths.props
index db3af4c0faaa3..cfd43b708cd9f 100644
--- a/ports/windows/msvc/paths.props
+++ b/ports/windows/msvc/paths.props
@@ -26,9 +26,10 @@
     <PyBaseDir>$([System.IO.Path]::GetFullPath(`$(MSBuildThisFileDirectory)..\..\..`))\</PyBaseDir>
     <PyWinDir>$(PyBaseDir)ports\windows\</PyWinDir>
     <PyBuildDir Condition="'$(PyBuildDir)' == ''">$(PyWinDir)build\</PyBuildDir>
+    <PyTargetDir Condition="'$(PyTargetDir)' == ''">$(PyWinDir)</PyTargetDir>
 
     <!-- All include directories needed for uPy -->
-    <PyIncDirs>$(PyBaseDir);$(PyWinDir);$(PyBuildDir);$(PyWinDir)msvc</PyIncDirs>
+    <PyIncDirs>$(PyIncDirs);$(PyBaseDir);$(PyWinDir);$(PyBuildDir);$(PyWinDir)msvc</PyIncDirs>
 
     <!-- Within PyBuildDir different subdirectories are used based on configuration and platform.
          By default these are chosen based on the Configuration and Platform properties, but
diff --git a/ports/windows/msvc/release.props b/ports/windows/msvc/release.props
index ea0bf433d3a18..a3fbe2494fde2 100644
--- a/ports/windows/msvc/release.props
+++ b/ports/windows/msvc/release.props
@@ -2,7 +2,10 @@
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ImportGroup Label="PropertySheets" />
   <PropertyGroup Label="UserMacros" />
-  <PropertyGroup />
+  <PropertyGroup>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
   <ItemDefinitionGroup>
     <Link>
       <OptimizeReferences>true</OptimizeReferences>
diff --git a/ports/windows/msvc/sources.props b/ports/windows/msvc/sources.props
index 5c2076f1ea903..5bf0fc453dba6 100644
--- a/ports/windows/msvc/sources.props
+++ b/ports/windows/msvc/sources.props
@@ -2,37 +2,26 @@
 <Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="paths.props" Condition="'$(PyPathsIncluded)' != 'True'"/>
   <ItemGroup>
-    <ClCompile Include="$(PyBaseDir)py\*.c" />
-    <ClCompile Include="$(PyBaseDir)ports\windows\*.c" />
-    <ClCompile Include="$(PyBaseDir)ports\windows\msvc\*.c" />
-    <ClCompile Include="$(PyBaseDir)lib\mp-readline\*.c" />
-    <ClCompile Include="$(PyBaseDir)lib\utils\printf.c" />
-    <ClCompile Include="$(PyBaseDir)ports\unix\file.c"/>
-    <ClCompile Include="$(PyBaseDir)ports\unix\gccollect.c"/>
-    <ClCompile Include="$(PyBaseDir)ports\unix\input.c"/>
-    <ClCompile Include="$(PyBaseDir)ports\unix\main.c"/>
-    <ClCompile Include="$(PyBaseDir)ports\unix\modos.c"/>
-    <ClCompile Include="$(PyBaseDir)ports\unix\modtime.c"/>
-    <ClCompile Include="$(PyBaseDir)ports\unix\modmachine.c" />
-    <ClCompile Include="$(PyBaseDir)extmod\machine_mem.c" />
-    <ClCompile Include="$(PyBaseDir)extmod\machine_pinbase.c" />
-    <ClCompile Include="$(PyBaseDir)extmod\machine_pulse.c" />
-    <ClCompile Include="$(PyBaseDir)extmod\machine_signal.c" />
-    <ClCompile Include="$(PyBaseDir)extmod\modubinascii.c" />
-    <ClCompile Include="$(PyBaseDir)extmod\moductypes.c" />
-    <ClCompile Include="$(PyBaseDir)extmod\moduhashlib.c" />
-    <ClCompile Include="$(PyBaseDir)extmod\moduheapq.c" />
-    <ClCompile Include="$(PyBaseDir)extmod\modujson.c" />
-    <ClCompile Include="$(PyBaseDir)extmod\modurandom.c" />
-    <ClCompile Include="$(PyBaseDir)extmod\modure.c" />
-    <ClCompile Include="$(PyBaseDir)extmod\modutimeq.c" />
-    <ClCompile Include="$(PyBaseDir)extmod\moduzlib.c" />
-    <ClCompile Include="$(PyBaseDir)extmod\utime_mphal.c" />
-    <ClCompile Include="$(PyBaseDir)extmod\virtpin.c" />
+    <PyCoreSource Include="$(PyBaseDir)py\*.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\machine_mem.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\machine_pinbase.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\machine_pulse.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\machine_signal.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\modubinascii.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\moductypes.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\moduhashlib.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\moduheapq.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\modujson.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\modurandom.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\modure.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\modutimeq.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\moduzlib.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\utime_mphal.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\virtpin.c" />
+    <PyExtModSource Include="$(PyBaseDir)extmod\vfs_posix_file.c" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="$(PyBaseDir)py\*.h" />
-    <ClInclude Include="$(PyBaseDir)ports\windows\*.h" />
-    <ClInclude Include="$(PyBaseDir)ports\windows\msvc\*.h" />
+    <PyCoreInclude Include="$(PyBaseDir)py\*.h" />
+    <PyExtModInclude Include="$(PyBaseDir)extmod\*.h" />
   </ItemGroup>
 </Project>
diff --git a/ports/windows/msvc/sys/time.h b/ports/windows/msvc/sys/time.h
index 7c95d409e4373..bb41ec36dbadd 100644
--- a/ports/windows/msvc/sys/time.h
+++ b/ports/windows/msvc/sys/time.h
@@ -29,4 +29,6 @@
 // Get the definitions for timeval etc
 #include <Winsock2.h>
 
+int gettimeofday(struct timeval *tp, struct timezone *tz);
+
 #endif // MICROPY_INCLUDED_WINDOWS_MSVC_SYS_TIME_H
diff --git a/ports/windows/realpath.c b/ports/windows/realpath.c
index ac9adf81253f4..5e429ef6a0096 100644
--- a/ports/windows/realpath.c
+++ b/ports/windows/realpath.c
@@ -33,8 +33,9 @@ char *to_unix_path(char *p) {
     if (p != NULL) {
         char *pp = p;
         while (*pp != 0) {
-            if (*pp == '\\')
+            if (*pp == '\\') {
                 *pp = '/';
+            }
             ++pp;
         }
     }
@@ -50,14 +51,16 @@ char *realpath(const char *path, char *resolved_path) {
         errno = EINVAL;
     } else if (access(path, R_OK) == 0) {
         ret = resolved_path;
-        if (ret == NULL)
+        if (ret == NULL) {
             ret = malloc(_MAX_PATH);
+        }
         if (ret == NULL) {
             errno = ENOMEM;
         } else {
             ret = _fullpath(ret, path, _MAX_PATH);
-            if (ret == NULL)
+            if (ret == NULL) {
                 errno = EIO;
+            }
         }
     }
     return to_unix_path(ret);
diff --git a/ports/windows/windows_mphal.c b/ports/windows/windows_mphal.c
index 153b044235434..8ed087358f567 100644
--- a/ports/windows/windows_mphal.c
+++ b/ports/windows/windows_mphal.c
@@ -25,8 +25,9 @@
  */
 
 
-#include "py/mpstate.h"
+#include "py/runtime.h"
 #include "py/mphal.h"
+#include "py/mpthread.h"
 
 #include <sys/time.h>
 #include <windows.h>
@@ -46,8 +47,8 @@ STATIC void assure_stdin_handle() {
 STATIC void assure_conout_handle() {
     if (!con_out) {
         con_out = CreateFile("CONOUT$", GENERIC_READ | GENERIC_WRITE,
-                      FILE_SHARE_READ | FILE_SHARE_WRITE,
-                      NULL, OPEN_EXISTING, 0, 0);
+            FILE_SHARE_READ | FILE_SHARE_WRITE,
+            NULL, OPEN_EXISTING, 0, 0);
         assert(con_out != INVALID_HANDLE_VALUE);
     }
 }
@@ -83,8 +84,7 @@ BOOL WINAPI console_sighandler(DWORD evt) {
             // this is the second time we are called, so die straight away
             exit(1);
         }
-        mp_obj_exception_clear_traceback(MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_kbd_exception)));
-        MP_STATE_VM(mp_pending_exception) = MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_kbd_exception));
+        mp_keyboard_interrupt();
         return TRUE;
     }
     return FALSE;
@@ -106,12 +106,23 @@ void mp_hal_set_interrupt_char(char c) {
 }
 
 void mp_hal_move_cursor_back(uint pos) {
+    if (!pos) {
+        return;
+    }
     assure_conout_handle();
     CONSOLE_SCREEN_BUFFER_INFO info;
     GetConsoleScreenBufferInfo(con_out, &info);
     info.dwCursorPosition.X -= (short)pos;
-    if (info.dwCursorPosition.X < 0) {
+    // Move up a line if needed.
+    while (info.dwCursorPosition.X < 0) {
+        info.dwCursorPosition.X = info.dwSize.X + info.dwCursorPosition.X;
+        info.dwCursorPosition.Y -= 1;
+    }
+    // Caller requested to move out of the screen. That's not possible so just clip,
+    // it's the caller's responsibility to not let this happen.
+    if (info.dwCursorPosition.Y < 0) {
         info.dwCursorPosition.X = 0;
+        info.dwCursorPosition.Y = 0;
     }
     SetConsoleCursorPosition(con_out, info.dwCursorPosition);
 }
@@ -130,7 +141,7 @@ typedef struct item_t {
     const char *seq;
 } item_t;
 
-// map virtual key codes to VT100 escape sequences
+// map virtual key codes to key sequences known by MicroPython's readline implementation
 STATIC item_t keyCodeMap[] = {
     {VK_UP, "[A"},
     {VK_DOWN, "[B"},
@@ -139,13 +150,22 @@ STATIC item_t keyCodeMap[] = {
     {VK_HOME, "[H"},
     {VK_END, "[F"},
     {VK_DELETE, "[3~"},
-    {0, ""} //sentinel
+    {0, ""} // sentinel
+};
+
+// likewise, but with Ctrl key down
+STATIC item_t ctrlKeyCodeMap[] = {
+    {VK_LEFT, "b"},
+    {VK_RIGHT, "f"},
+    {VK_DELETE, "d"},
+    {VK_BACK, "\x7F"},
+    {0, ""} // sentinel
 };
 
 STATIC const char *cur_esc_seq = NULL;
 
-STATIC int esc_seq_process_vk(int vk) {
-    for (item_t *p = keyCodeMap; p->vkey != 0; ++p) {
+STATIC int esc_seq_process_vk(WORD vk, bool ctrl_key_down) {
+    for (item_t *p = (ctrl_key_down ? ctrlKeyCodeMap : keyCodeMap); p->vkey != 0; ++p) {
         if (p->vkey == vk) {
             cur_esc_seq = p->seq;
             return 27; // ESC, start of escape sequence
@@ -174,28 +194,36 @@ int mp_hal_stdin_rx_chr(void) {
 
     // poll until key which we handle is pressed
     assure_stdin_handle();
+    BOOL status;
     DWORD num_read;
     INPUT_RECORD rec;
     for (;;) {
-      if (!ReadConsoleInput(std_in, &rec, 1, &num_read) || !num_read) {
-          return CHAR_CTRL_C; // EOF, ctrl-D
-      }
-      if (rec.EventType != KEY_EVENT || !rec.Event.KeyEvent.bKeyDown) { // only want key down events
-          continue;
-      }
-      const char c = rec.Event.KeyEvent.uChar.AsciiChar;
-      if (c) { // plain ascii char, return it
-          return c;
-      }
-      const int ret = esc_seq_process_vk(rec.Event.KeyEvent.wVirtualKeyCode);
-      if (ret) {
-          return ret;
-      }
+        MP_THREAD_GIL_EXIT();
+        status = ReadConsoleInput(std_in, &rec, 1, &num_read);
+        MP_THREAD_GIL_ENTER();
+        if (!status || !num_read) {
+            return CHAR_CTRL_C; // EOF, ctrl-D
+        }
+        if (rec.EventType != KEY_EVENT || !rec.Event.KeyEvent.bKeyDown) { // only want key down events
+            continue;
+        }
+        const bool ctrl_key_down = (rec.Event.KeyEvent.dwControlKeyState & LEFT_CTRL_PRESSED) ||
+            (rec.Event.KeyEvent.dwControlKeyState & RIGHT_CTRL_PRESSED);
+        const int ret = esc_seq_process_vk(rec.Event.KeyEvent.wVirtualKeyCode, ctrl_key_down);
+        if (ret) {
+            return ret;
+        }
+        const char c = rec.Event.KeyEvent.uChar.AsciiChar;
+        if (c) { // plain ascii char, return it
+            return c;
+        }
     }
 }
 
 void mp_hal_stdout_tx_strn(const char *str, size_t len) {
-    write(1, str, len);
+    MP_THREAD_GIL_EXIT();
+    write(STDOUT_FILENO, str, len);
+    MP_THREAD_GIL_ENTER();
 }
 
 void mp_hal_stdout_tx_strn_cooked(const char *str, size_t len) {
@@ -221,9 +249,9 @@ mp_uint_t mp_hal_ticks_us(void) {
 mp_uint_t mp_hal_ticks_cpu(void) {
     LARGE_INTEGER value;
     QueryPerformanceCounter(&value);
-#ifdef _WIN64
+    #ifdef _WIN64
     return value.QuadPart;
-#else
+    #else
     return value.LowPart;
-#endif
+    #endif
 }
diff --git a/ports/zephyr/CMakeLists.txt b/ports/zephyr/CMakeLists.txt
index 8e01624170bb9..017b0689cef58 100644
--- a/ports/zephyr/CMakeLists.txt
+++ b/ports/zephyr/CMakeLists.txt
@@ -17,6 +17,7 @@ zephyr_get_compile_options_for_lang_as_string(C options)
 add_custom_target(
   outputexports
   COMMAND echo CC="${CMAKE_C_COMPILER}"
+  COMMAND echo AR="${CMAKE_AR}"
   COMMAND echo Z_CFLAGS=${system_includes} ${includes} ${definitions} ${options}
   VERBATIM
   USES_TERMINAL
diff --git a/ports/zephyr/Makefile b/ports/zephyr/Makefile
index b23ee109360b9..4fe6552846aab 100644
--- a/ports/zephyr/Makefile
+++ b/ports/zephyr/Makefile
@@ -8,7 +8,6 @@
 # To build a "minimal" configuration, use "make-minimal" wrapper.
 
 BOARD ?= qemu_x86
-CONF_FILE = prj_$(BOARD)_merged.conf
 OUTDIR_PREFIX = $(BOARD)
 
 # Default heap size is 16KB, which is on conservative side, to let
@@ -17,6 +16,10 @@ OUTDIR_PREFIX = $(BOARD)
 MICROPY_HEAP_SIZE = 16384
 FROZEN_DIR = scripts
 
+MICROPY_VFS_FAT ?= 1
+MICROPY_VFS_LFS1 ?= 0
+MICROPY_VFS_LFS2 ?= 1
+
 # Default target
 all:
 
@@ -38,6 +41,7 @@ INC += -I$(ZEPHYR_BASE)/net/ip/contiki/os
 
 SRC_C = main.c \
 	help.c \
+	moduos.c \
 	modusocket.c \
 	modutime.c \
 	modzephyr.c \
@@ -46,6 +50,8 @@ SRC_C = main.c \
 	machine_i2c.c \
 	machine_pin.c \
 	uart_core.c \
+	zephyr_storage.c \
+	lib/timeutils/timeutils.c \
 	lib/utils/stdout_helpers.c \
 	lib/utils/printf.c \
 	lib/utils/pyexec.c \
@@ -59,7 +65,7 @@ SRC_QSTR += $(SRC_C)
 OBJ = $(PY_O) $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
 
 CFLAGS = $(Z_CFLAGS) \
-	 -std=gnu99 -fomit-frame-pointer -DNDEBUG -DMICROPY_HEAP_SIZE=$(MICROPY_HEAP_SIZE) $(CFLAGS_EXTRA) $(INC)
+	 -std=gnu99 -fomit-frame-pointer -DNDEBUG -DMICROPY_HEAP_SIZE=$(MICROPY_HEAP_SIZE) $(CFLAGS_MOD) $(CFLAGS_EXTRA) $(INC)
 
 include $(TOP)/py/mkrules.mk
 
@@ -85,27 +91,24 @@ build/genhdr/qstr.i.last: | $(Z_EXPORTS)
 LIBMICROPYTHON_EXTRA_CMD = -$(RM) -f outdir/$(OUTDIR_PREFIX)/zephyr.lnk
 
 # MicroPython's global clean cleans everything, fast
-CLEAN_EXTRA = outdir libmicropython.a prj_*_merged.conf
+CLEAN_EXTRA = outdir libmicropython.a
 
 # Clean Zephyr things in Zephyr way
 z_clean:
 	$(MAKE) -f Makefile.zephyr BOARD=$(BOARD) clean
 
-# This rule is for prj_$(BOARD)_merged.conf, not $(CONF_FILE), which
-# can be overriden.
-# prj_$(BOARD).conf is optional, that's why it's resolved with $(wildcard)
-# function.
-prj_$(BOARD)_merged.conf: prj_base.conf $(wildcard prj_$(BOARD).conf)
-	$(PYTHON) makeprj.py prj_base.conf prj_$(BOARD).conf $@
-
 test:
 	cd $(TOP)/tests && ./run-tests --target minimal --device "execpty:make -C ../ports/zephyr run BOARD=$(BOARD) QEMU_PTY=1"
 
 cmake: outdir/$(BOARD)/Makefile
 
-outdir/$(BOARD)/Makefile: $(CONF_FILE)
-	mkdir -p outdir/$(BOARD) && cmake -DBOARD=$(BOARD) -DCONF_FILE=$(CONF_FILE) -Boutdir/$(BOARD) -H.
+ifneq ($(CONF_FILE),)
+CMAKE_MOD += -DCONF_FILE=$(CONF_FILE)
+endif
+
+outdir/$(BOARD)/Makefile:
+	mkdir -p outdir/$(BOARD) && cmake -DBOARD=$(BOARD) $(CMAKE_MOD) -Boutdir/$(BOARD) -H.
 
 $(Z_EXPORTS): outdir/$(BOARD)/Makefile
 	make --no-print-directory -C outdir/$(BOARD) outputexports CMAKE_COMMAND=: >$@
-	make -C outdir/$(BOARD) syscall_macros_h_target syscall_list_h_target kobj_types_h_target
+	make -C outdir/$(BOARD) syscall_list_h_target kobj_types_h_target
diff --git a/ports/zephyr/README.md b/ports/zephyr/README.md
index 3d2e883adc166..6bcbccd8b36a3 100644
--- a/ports/zephyr/README.md
+++ b/ports/zephyr/README.md
@@ -12,8 +12,8 @@ Features supported at this time:
 
 * REPL (interactive prompt) over Zephyr UART console.
 * `utime` module for time measurements and delays.
-* `machine.I2C` class for I2C control.
 * `machine.Pin` class for GPIO control.
+* `machine.I2C` class for I2C control.
 * `usocket` module for networking (IPv4/IPv6).
 * "Frozen modules" support to allow to bundle Python modules together
   with firmware. Including complete applications, including with
@@ -82,13 +82,6 @@ To blink an LED:
         LED.value(0)
         time.sleep(0.5)
 
-To scan for I2C slaves:
-
-    from machine import I2C
-
-    i2c = I2C("I2C_0")
-    i2c.scan()
-
 The above code uses an LED location for a FRDM-K64F board (port B, pin 21;
 following Zephyr conventions port are identified by "GPIO_x", where *x*
 starts from 0). You will need to adjust it for another board (using board's
@@ -96,6 +89,13 @@ reference materials). To execute the above sample, copy it to clipboard, in
 MicroPython REPL enter "paste mode" using Ctrl+E, paste clipboard, press
 Ctrl+D to finish paste mode and start execution.
 
+Example of using I2C to scan for I2C slaves:
+
+    from machine import I2C
+
+    i2c = I2C("I2C_0")
+    i2c.scan()
+
 
 Minimal build
 -------------
diff --git a/ports/zephyr/prj_96b_carbon.conf b/ports/zephyr/boards/96b_carbon.conf
similarity index 100%
rename from ports/zephyr/prj_96b_carbon.conf
rename to ports/zephyr/boards/96b_carbon.conf
diff --git a/ports/zephyr/prj_disco_l475_iot1.conf b/ports/zephyr/boards/disco_l475_iot1.conf
similarity index 100%
rename from ports/zephyr/prj_disco_l475_iot1.conf
rename to ports/zephyr/boards/disco_l475_iot1.conf
diff --git a/ports/zephyr/prj_frdm_k64f.conf b/ports/zephyr/boards/frdm_k64f.conf
similarity index 53%
rename from ports/zephyr/prj_frdm_k64f.conf
rename to ports/zephyr/boards/frdm_k64f.conf
index 477f3b8257f82..483e9a29bbcd4 100644
--- a/ports/zephyr/prj_frdm_k64f.conf
+++ b/ports/zephyr/boards/frdm_k64f.conf
@@ -1,7 +1,15 @@
 # Networking drivers
 CONFIG_NET_L2_ETHERNET=y
 
+# Hardware features
+CONFIG_I2C=y
+
 # Sensor drivers
 CONFIG_FXOS8700=y
 CONFIG_FXOS8700_MODE_HYBRID=y
 CONFIG_FXOS8700_TEMP=y
+
+# Flash drivers
+CONFIG_FLASH=y
+CONFIG_FLASH_MAP=y
+CONFIG_MPU_ALLOW_FLASH_WRITE=y
diff --git a/ports/zephyr/prj_frdm_kw41z.conf b/ports/zephyr/boards/frdm_kw41z.conf
similarity index 72%
rename from ports/zephyr/prj_frdm_kw41z.conf
rename to ports/zephyr/boards/frdm_kw41z.conf
index 486ece2bd8e01..ff7b7887e161d 100644
--- a/ports/zephyr/prj_frdm_kw41z.conf
+++ b/ports/zephyr/boards/frdm_kw41z.conf
@@ -1,3 +1,6 @@
+# Hardware features
+CONFIG_I2C=y
+
 # Sensor drivers
 CONFIG_FXOS8700=y
 CONFIG_FXOS8700_MODE_HYBRID=y
diff --git a/ports/zephyr/boards/mimxrt1050_evk.conf b/ports/zephyr/boards/mimxrt1050_evk.conf
new file mode 100644
index 0000000000000..051ab7e60b4ac
--- /dev/null
+++ b/ports/zephyr/boards/mimxrt1050_evk.conf
@@ -0,0 +1,9 @@
+# Required for zephyr.DiskAccess block devices
+CONFIG_DISK_ACCESS=y
+CONFIG_DISK_ACCESS_SDHC=y
+
+CONFIG_USB=y
+CONFIG_USB_DEVICE_STACK=y
+CONFIG_USB_DEVICE_PRODUCT="Zephyr MicroPython"
+CONFIG_USB_MASS_STORAGE=y
+CONFIG_MASS_STORAGE_DISK_NAME="SDHC"
diff --git a/ports/zephyr/prj_qemu_cortex_m3.conf b/ports/zephyr/boards/qemu_cortex_m3.conf
similarity index 100%
rename from ports/zephyr/prj_qemu_cortex_m3.conf
rename to ports/zephyr/boards/qemu_cortex_m3.conf
diff --git a/ports/zephyr/prj_qemu_x86.conf b/ports/zephyr/boards/qemu_x86.conf
similarity index 100%
rename from ports/zephyr/prj_qemu_x86.conf
rename to ports/zephyr/boards/qemu_x86.conf
diff --git a/ports/zephyr/boards/reel_board.conf b/ports/zephyr/boards/reel_board.conf
new file mode 100644
index 0000000000000..a7ed230d14370
--- /dev/null
+++ b/ports/zephyr/boards/reel_board.conf
@@ -0,0 +1,4 @@
+# Flash drivers
+CONFIG_FLASH=y
+CONFIG_FLASH_MAP=y
+CONFIG_MPU_ALLOW_FLASH_WRITE=y
diff --git a/ports/zephyr/boards/rv32m1_vega_ri5cy.conf b/ports/zephyr/boards/rv32m1_vega_ri5cy.conf
new file mode 100644
index 0000000000000..dcd6d7a08f538
--- /dev/null
+++ b/ports/zephyr/boards/rv32m1_vega_ri5cy.conf
@@ -0,0 +1,3 @@
+# Flash drivers
+CONFIG_FLASH=y
+CONFIG_FLASH_MAP=y
diff --git a/ports/zephyr/help.c b/ports/zephyr/help.c
index becc203f6f80d..4ee674b9d2602 100644
--- a/ports/zephyr/help.c
+++ b/ports/zephyr/help.c
@@ -27,14 +27,14 @@
 #include "py/builtin.h"
 
 const char zephyr_help_text[] =
-"Welcome to MicroPython!\n"
-"\n"
-"Control commands:\n"
-"  CTRL-A        -- on a blank line, enter raw REPL mode\n"
-"  CTRL-B        -- on a blank line, enter normal REPL mode\n"
-"  CTRL-C        -- interrupt a running program\n"
-"  CTRL-D        -- on a blank line, do a soft reset of the board\n"
-"  CTRL-E        -- on a blank line, enter paste mode\n"
-"\n"
-"For further help on a specific object, type help(obj)\n"
+    "Welcome to MicroPython!\n"
+    "\n"
+    "Control commands:\n"
+    "  CTRL-A        -- on a blank line, enter raw REPL mode\n"
+    "  CTRL-B        -- on a blank line, enter normal REPL mode\n"
+    "  CTRL-C        -- interrupt a running program\n"
+    "  CTRL-D        -- on a blank line, do a soft reset of the board\n"
+    "  CTRL-E        -- on a blank line, enter paste mode\n"
+    "\n"
+    "For further help on a specific object, type help(obj)\n"
 ;
diff --git a/ports/zephyr/machine_i2c.c b/ports/zephyr/machine_i2c.c
index bc9851a00c8e7..f00c1d34225ac 100644
--- a/ports/zephyr/machine_i2c.c
+++ b/ports/zephyr/machine_i2c.c
@@ -30,7 +30,7 @@
 #include <string.h>
 
 #include <zephyr.h>
-#include <i2c.h>
+#include <drivers/i2c.h>
 
 #include "py/runtime.h"
 #include "py/gc.h"
@@ -68,19 +68,19 @@ mp_obj_t machine_hard_i2c_make_new(const mp_obj_type_t *type, size_t n_args, siz
     struct device *dev = device_get_binding(dev_name);
 
     if (dev == NULL) {
-        mp_raise_ValueError("device not found");
+        mp_raise_ValueError(MP_ERROR_TEXT("device not found"));
     }
 
     if ((args[ARG_scl].u_obj != MP_OBJ_NULL) || (args[ARG_sda].u_obj != MP_OBJ_NULL)) {
-        mp_raise_NotImplementedError("explicit choice of scl/sda is not implemented");
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("explicit choice of scl/sda is not implemented"));
     }
 
     if ((args[ARG_freq].u_obj != MP_OBJ_NULL)) {
-        mp_raise_NotImplementedError("explicit choice of freq is not implemented");
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("explicit choice of freq is not implemented"));
     }
 
     if ((args[ARG_timeout].u_obj != MP_OBJ_NULL)) {
-        mp_raise_NotImplementedError("explicit choice of timeout is not implemented");
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("explicit choice of timeout is not implemented"));
     }
 
     machine_hard_i2c_obj_t *self = m_new_obj(machine_hard_i2c_obj_t);
@@ -92,16 +92,16 @@ mp_obj_t machine_hard_i2c_make_new(const mp_obj_type_t *type, size_t n_args, siz
     return MP_OBJ_FROM_PTR(self);
 }
 
-STATIC int machine_hard_i2c_transfer(mp_obj_base_t *self_in, uint16_t addr, uint8_t *buf, size_t len, bool stop, bool read) {
+STATIC int machine_hard_i2c_transfer_single(mp_obj_base_t *self_in, uint16_t addr, size_t len, uint8_t *buf, unsigned int flags) {
     machine_hard_i2c_obj_t *self = (machine_hard_i2c_obj_t *)self_in;
     struct i2c_msg msg;
     int ret;
 
-    msg.buf = (u8_t*)buf;
+    msg.buf = (u8_t *)buf;
     msg.len = len;
     msg.flags = 0;
 
-    if (read) {
+    if (flags & MP_MACHINE_I2C_FLAG_READ) {
         msg.flags |= I2C_MSG_READ;
     } else {
         msg.flags |= I2C_MSG_WRITE;
@@ -111,7 +111,7 @@ STATIC int machine_hard_i2c_transfer(mp_obj_base_t *self_in, uint16_t addr, uint
         msg.flags |= I2C_MSG_RESTART;
     }
 
-    if (stop) {
+    if (flags & MP_MACHINE_I2C_FLAG_STOP) {
         msg.flags |= I2C_MSG_STOP;
         self->restart = false;
     } else {
@@ -122,17 +122,9 @@ STATIC int machine_hard_i2c_transfer(mp_obj_base_t *self_in, uint16_t addr, uint
     return (ret < 0) ? -MP_EIO : len;
 }
 
-STATIC int machine_hard_i2c_readfrom(mp_obj_base_t *self_in, uint16_t addr, uint8_t *dest, size_t len, bool stop) {
-    return machine_hard_i2c_transfer(self_in, addr, dest, len, stop, true);
-}
-
-STATIC int machine_hard_i2c_writeto(mp_obj_base_t *self_in, uint16_t addr, const uint8_t *src, size_t len, bool stop) {
-    return machine_hard_i2c_transfer(self_in, addr, (uint8_t*)src, len, stop, false);
-}
-
 STATIC const mp_machine_i2c_p_t machine_hard_i2c_p = {
-    .readfrom = machine_hard_i2c_readfrom,
-    .writeto = machine_hard_i2c_writeto,
+    .transfer = mp_machine_i2c_transfer_adaptor,
+    .transfer_single = machine_hard_i2c_transfer_single,
 };
 
 STATIC const mp_obj_type_t machine_hard_i2c_type = {
@@ -141,5 +133,5 @@ STATIC const mp_obj_type_t machine_hard_i2c_type = {
     .print = machine_hard_i2c_print,
     .make_new = machine_hard_i2c_make_new,
     .protocol = &machine_hard_i2c_p,
-    .locals_dict = (mp_obj_dict_t*)&mp_machine_soft_i2c_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&mp_machine_soft_i2c_locals_dict,
 };
diff --git a/ports/zephyr/machine_pin.c b/ports/zephyr/machine_pin.c
index c4ea328a2a4ba..ad5f54baafb92 100644
--- a/ports/zephyr/machine_pin.c
+++ b/ports/zephyr/machine_pin.c
@@ -30,7 +30,7 @@
 #include <string.h>
 
 #include <zephyr.h>
-#include <gpio.h>
+#include <drivers/gpio.h>
 
 #include "py/runtime.h"
 #include "py/gc.h"
@@ -61,19 +61,20 @@ STATIC mp_obj_t machine_pin_obj_init_helper(machine_pin_obj_t *self, size_t n_ar
     uint mode = args[ARG_mode].u_int;
 
     // get pull mode
-    uint pull = GPIO_PUD_NORMAL;
+    uint pull = 0;
     if (args[ARG_pull].u_obj != mp_const_none) {
         pull = mp_obj_get_int(args[ARG_pull].u_obj);
     }
 
-    int ret = gpio_pin_configure(self->port, self->pin, mode | pull);
-    if (ret) {
-        mp_raise_ValueError("invalid pin");
-    }
-
     // get initial value
+    uint init = 0;
     if (args[ARG_value].u_obj != MP_OBJ_NULL) {
-        (void)gpio_pin_write(self->port, self->pin, mp_obj_is_true(args[ARG_value].u_obj));
+        init = mp_obj_is_true(args[ARG_value].u_obj) ? GPIO_OUTPUT_INIT_HIGH : GPIO_OUTPUT_INIT_LOW;
+    }
+
+    int ret = gpio_pin_configure(self->port, self->pin, mode | pull | init);
+    if (ret) {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid pin"));
     }
 
     return mp_const_none;
@@ -85,7 +86,7 @@ mp_obj_t mp_pin_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw,
 
     // get the wanted port
     if (!mp_obj_is_type(args[0], &mp_type_tuple)) {
-        mp_raise_ValueError("Pin id must be tuple of (\"GPIO_x\", pin#)");
+        mp_raise_ValueError(MP_ERROR_TEXT("Pin id must be tuple of (\"GPIO_x\", pin#)"));
     }
     mp_obj_t *items;
     mp_obj_get_array_fixed_n(args[0], 2, &items);
@@ -93,7 +94,7 @@ mp_obj_t mp_pin_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw,
     int wanted_pin = mp_obj_get_int(items[1]);
     struct device *wanted_port = device_get_binding(drv_name);
     if (!wanted_port) {
-        mp_raise_ValueError("invalid port");
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid port"));
     }
 
     machine_pin_obj_t *pin = m_new_obj(machine_pin_obj_t);
@@ -116,11 +117,10 @@ STATIC mp_obj_t machine_pin_call(mp_obj_t self_in, size_t n_args, size_t n_kw, c
     mp_arg_check_num(n_args, n_kw, 0, 1, false);
     machine_pin_obj_t *self = self_in;
     if (n_args == 0) {
-        u32_t pin_val;
-        (void)gpio_pin_read(self->port, self->pin, &pin_val);
+        int pin_val = gpio_pin_get_raw(self->port, self->pin);
         return MP_OBJ_NEW_SMALL_INT(pin_val);
     } else {
-        (void)gpio_pin_write(self->port, self->pin, mp_obj_is_true(args[0]));
+        (void)gpio_pin_set_raw(self->port, self->pin, mp_obj_is_true(args[0]));
         return mp_const_none;
     }
 }
@@ -139,14 +139,14 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_pin_value_obj, 1, 2, machine_
 
 STATIC mp_obj_t machine_pin_off(mp_obj_t self_in) {
     machine_pin_obj_t *self = self_in;
-    (void)gpio_pin_write(self->port, self->pin, 0);
+    (void)gpio_pin_set_raw(self->port, self->pin, 0);
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_pin_off_obj, machine_pin_off);
 
 STATIC mp_obj_t machine_pin_on(mp_obj_t self_in) {
     machine_pin_obj_t *self = self_in;
-    (void)gpio_pin_write(self->port, self->pin, 1);
+    (void)gpio_pin_set_raw(self->port, self->pin, 1);
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_pin_on_obj, machine_pin_on);
@@ -157,13 +157,10 @@ STATIC mp_uint_t machine_pin_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_
 
     switch (request) {
         case MP_PIN_READ: {
-            u32_t pin_val;
-            gpio_pin_read(self->port, self->pin, &pin_val);
-            return pin_val;
+            return gpio_pin_get_raw(self->port, self->pin);
         }
         case MP_PIN_WRITE: {
-            gpio_pin_write(self->port, self->pin, arg);
-            return 0;
+            return gpio_pin_set_raw(self->port, self->pin, arg);
         }
     }
     return -1;
@@ -177,10 +174,10 @@ STATIC const mp_rom_map_elem_t machine_pin_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_on),      MP_ROM_PTR(&machine_pin_on_obj) },
 
     // class constants
-    { MP_ROM_QSTR(MP_QSTR_IN),        MP_ROM_INT(GPIO_DIR_IN) },
-    { MP_ROM_QSTR(MP_QSTR_OUT),       MP_ROM_INT(GPIO_DIR_OUT) },
-    { MP_ROM_QSTR(MP_QSTR_PULL_UP),   MP_ROM_INT(GPIO_PUD_PULL_UP) },
-    { MP_ROM_QSTR(MP_QSTR_PULL_DOWN), MP_ROM_INT(GPIO_PUD_PULL_DOWN) },
+    { MP_ROM_QSTR(MP_QSTR_IN),        MP_ROM_INT(GPIO_INPUT) },
+    { MP_ROM_QSTR(MP_QSTR_OUT),       MP_ROM_INT(GPIO_OUTPUT) },
+    { MP_ROM_QSTR(MP_QSTR_PULL_UP),   MP_ROM_INT(GPIO_PULL_UP) },
+    { MP_ROM_QSTR(MP_QSTR_PULL_DOWN), MP_ROM_INT(GPIO_PULL_DOWN) },
 };
 
 STATIC MP_DEFINE_CONST_DICT(machine_pin_locals_dict, machine_pin_locals_dict_table);
diff --git a/ports/zephyr/main.c b/ports/zephyr/main.c
index a28fb37923cf8..e304dfd25824d 100644
--- a/ports/zephyr/main.c
+++ b/ports/zephyr/main.c
@@ -5,6 +5,7 @@
  *
  * Copyright (c) 2013, 2014 Damien P. George
  * Copyright (c) 2016-2017 Linaro Limited
+ * Copyright (c) 2020 NXP
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -33,6 +34,11 @@
 #include <net/net_context.h>
 #endif
 
+#ifdef CONFIG_USB
+#include <usb/usb_device.h>
+#endif
+
+#include "py/mperrno.h"
 #include "py/compile.h"
 #include "py/runtime.h"
 #include "py/repl.h"
@@ -41,6 +47,12 @@
 #include "lib/utils/pyexec.h"
 #include "lib/mp-readline/readline.h"
 
+#if MICROPY_VFS
+#include "extmod/vfs.h"
+#endif
+
+#include "modzephyr.h"
+
 #ifdef TEST
 #include "lib/upytesthelper/upytesthelper.h"
 #include "lib/tinytest/tinytest.c"
@@ -48,13 +60,12 @@
 #include TEST
 #endif
 
-static char *stack_top;
 static char heap[MICROPY_HEAP_SIZE];
 
 void init_zephyr(void) {
     // We now rely on CONFIG_NET_APP_SETTINGS to set up bootstrap
     // network addresses.
-#if 0
+    #if 0
     #ifdef CONFIG_NETWORKING
     if (net_if_get_default() == NULL) {
         // If there's no default networking interface,
@@ -75,13 +86,36 @@ void init_zephyr(void) {
     static struct in6_addr in6addr_my = {{{0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}}};
     net_if_ipv6_addr_add(net_if_get_default(), &in6addr_my, NET_ADDR_MANUAL, 0);
     #endif
-#endif
+    #endif
+}
+
+#if MICROPY_VFS
+STATIC void vfs_init(void) {
+    mp_obj_t bdev = NULL;
+    mp_obj_t mount_point;
+    const char *mount_point_str = NULL;
+    int ret = 0;
+
+    #ifdef CONFIG_DISK_ACCESS_SDHC
+    mp_obj_t args[] = { mp_obj_new_str(CONFIG_DISK_SDHC_VOLUME_NAME, strlen(CONFIG_DISK_SDHC_VOLUME_NAME)) };
+    bdev = zephyr_disk_access_type.make_new(&zephyr_disk_access_type, ARRAY_SIZE(args), 0, args);
+    mount_point_str = "/sd";
+    #elif defined(CONFIG_FLASH_MAP) && defined(DT_FLASH_AREA_STORAGE_ID)
+    mp_obj_t args[] = { MP_OBJ_NEW_SMALL_INT(DT_FLASH_AREA_STORAGE_ID), MP_OBJ_NEW_SMALL_INT(4096) };
+    bdev = zephyr_flash_area_type.make_new(&zephyr_flash_area_type, ARRAY_SIZE(args), 0, args);
+    mount_point_str = "/flash";
+    #endif
+
+    if ((bdev != NULL)) {
+        mount_point = mp_obj_new_str(mount_point_str, strlen(mount_point_str));
+        ret = mp_vfs_mount_and_chdir_protected(bdev, mount_point);
+        // TODO: if this failed, make a new file system and try to mount again
+    }
 }
+#endif // MICROPY_VFS
 
 int real_main(void) {
-    int stack_dummy;
-    stack_top = (char*)&stack_dummy;
-    mp_stack_set_top(stack_top);
+    mp_stack_ctrl_init();
     // Make MicroPython's stack limit somewhat smaller than full stack available
     mp_stack_set_limit(CONFIG_MAIN_STACK_SIZE - 512);
 
@@ -103,8 +137,16 @@ int real_main(void) {
     mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR_)); // current dir (or base dir of the script)
     mp_obj_list_init(mp_sys_argv, 0);
 
-    #if MICROPY_MODULE_FROZEN
-    pyexec_frozen_module("main.py");
+    #ifdef CONFIG_USB
+    usb_enable(NULL);
+    #endif
+
+    #if MICROPY_VFS
+    vfs_init();
+    #endif
+
+    #if MICROPY_MODULE_FROZEN || MICROPY_VFS
+    pyexec_file_if_exists("main.py");
     #endif
 
     for (;;) {
@@ -130,26 +172,38 @@ void gc_collect(void) {
     // pointers from CPU registers, and thus may function incorrectly.
     void *dummy;
     gc_collect_start();
-    gc_collect_root(&dummy, ((mp_uint_t)stack_top - (mp_uint_t)&dummy) / sizeof(mp_uint_t));
+    gc_collect_root(&dummy, ((mp_uint_t)MP_STATE_THREAD(stack_top) - (mp_uint_t)&dummy) / sizeof(mp_uint_t));
     gc_collect_end();
-    //gc_dump_info();
+    // gc_dump_info();
 }
 
+#if !MICROPY_READER_VFS
 mp_lexer_t *mp_lexer_new_from_file(const char *filename) {
     mp_raise_OSError(ENOENT);
 }
+#endif
 
 mp_import_stat_t mp_import_stat(const char *path) {
+    #if MICROPY_VFS
+    return mp_vfs_import_stat(path);
+    #else
     return MP_IMPORT_STAT_NO_EXIST;
+    #endif
 }
 
 mp_obj_t mp_builtin_open(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
+    #if MICROPY_VFS
+    return mp_vfs_open(n_args, args, kwargs);
+    #else
     return mp_const_none;
+    #endif
 }
 MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
 
 NORETURN void nlr_jump_fail(void *val) {
-    while (1);
+    while (1) {
+        ;
+    }
 }
 
 #ifndef NDEBUG
diff --git a/ports/zephyr/makeprj.py b/ports/zephyr/makeprj.py
deleted file mode 100644
index 239c877cd6f9c..0000000000000
--- a/ports/zephyr/makeprj.py
+++ /dev/null
@@ -1,29 +0,0 @@
-#!/usr/bin/env python3
-import sys
-import os
-import hashlib
-
-
-def hash_file(fname):
-    if not os.path.exists(fname):
-        return b""
-    hasher = hashlib.md5()
-    with open(fname, "rb") as f:
-        hasher.update(f.read())
-    return hasher.digest()
-
-
-old_digest = hash_file(sys.argv[3])
-
-with open(sys.argv[3] + ".tmp", "wb") as f:
-    f.write(open(sys.argv[1], "rb").read())
-    if os.path.exists(sys.argv[2]):
-        f.write(open(sys.argv[2], "rb").read())
-
-new_digest = hash_file(sys.argv[3] + ".tmp")
-
-if new_digest != old_digest:
-    print("Replacing")
-    os.rename(sys.argv[3] + ".tmp", sys.argv[3])
-else:
-    os.remove(sys.argv[3] + ".tmp")
diff --git a/ports/zephyr/modmachine.c b/ports/zephyr/modmachine.c
index c89529aa9c73d..72078cf9deabc 100644
--- a/ports/zephyr/modmachine.c
+++ b/ports/zephyr/modmachine.c
@@ -28,7 +28,7 @@
 
 #include <stdint.h>
 #include <stdio.h>
-#include <misc/reboot.h>
+#include <power/reboot.h>
 
 #include "py/obj.h"
 #include "py/runtime.h"
@@ -72,7 +72,7 @@ STATIC MP_DEFINE_CONST_DICT(machine_module_globals, machine_module_globals_table
 
 const mp_obj_module_t mp_module_machine = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&machine_module_globals,
+    .globals = (mp_obj_dict_t *)&machine_module_globals,
 };
 
 #endif // MICROPY_PY_MACHINE
diff --git a/ports/zephyr/moduos.c b/ports/zephyr/moduos.c
new file mode 100644
index 0000000000000..49d5744af4285
--- /dev/null
+++ b/ports/zephyr/moduos.c
@@ -0,0 +1,75 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 NXP
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/obj.h"
+
+#include "extmod/vfs.h"
+
+#if MICROPY_VFS_FAT
+#include "extmod/vfs_fat.h"
+#endif
+
+#if MICROPY_VFS_LFS1 || MICROPY_VFS_LFS2
+#include "extmod/vfs_lfs.h"
+#endif
+
+#if MICROPY_PY_UOS
+
+STATIC const mp_rom_map_elem_t uos_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_uos) },
+    #if MICROPY_VFS
+    { MP_ROM_QSTR(MP_QSTR_chdir), MP_ROM_PTR(&mp_vfs_chdir_obj) },
+    { MP_ROM_QSTR(MP_QSTR_getcwd), MP_ROM_PTR(&mp_vfs_getcwd_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ilistdir), MP_ROM_PTR(&mp_vfs_ilistdir_obj) },
+    { MP_ROM_QSTR(MP_QSTR_listdir), MP_ROM_PTR(&mp_vfs_listdir_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mkdir), MP_ROM_PTR(&mp_vfs_mkdir_obj) },
+    { MP_ROM_QSTR(MP_QSTR_remove), MP_ROM_PTR(&mp_vfs_remove_obj) },
+    { MP_ROM_QSTR(MP_QSTR_rename),MP_ROM_PTR(&mp_vfs_rename_obj)},
+    { MP_ROM_QSTR(MP_QSTR_rmdir), MP_ROM_PTR(&mp_vfs_rmdir_obj) },
+    { MP_ROM_QSTR(MP_QSTR_stat), MP_ROM_PTR(&mp_vfs_stat_obj) },
+    { MP_ROM_QSTR(MP_QSTR_statvfs), MP_ROM_PTR(&mp_vfs_statvfs_obj) },
+    { MP_ROM_QSTR(MP_QSTR_unlink), MP_ROM_PTR(&mp_vfs_remove_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mount), MP_ROM_PTR(&mp_vfs_mount_obj) },
+    { MP_ROM_QSTR(MP_QSTR_umount), MP_ROM_PTR(&mp_vfs_umount_obj) },
+    #endif
+    #if MICROPY_VFS_FAT
+    { MP_ROM_QSTR(MP_QSTR_VfsFat), MP_ROM_PTR(&mp_fat_vfs_type) },
+    #endif
+    #if MICROPY_VFS_LFS1
+    { MP_ROM_QSTR(MP_QSTR_VfsLfs1), MP_ROM_PTR(&mp_type_vfs_lfs1) },
+    #endif
+    #if MICROPY_VFS_LFS2
+    { MP_ROM_QSTR(MP_QSTR_VfsLfs2), MP_ROM_PTR(&mp_type_vfs_lfs2) },
+    #endif
+};
+STATIC MP_DEFINE_CONST_DICT(uos_module_globals, uos_module_globals_table);
+
+const mp_obj_module_t mp_module_uos = {
+    .base = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&uos_module_globals,
+};
+
+#endif // MICROPY_PY_UOS
diff --git a/ports/zephyr/modusocket.c b/ports/zephyr/modusocket.c
index 083083788a9f1..6c900753c8b51 100644
--- a/ports/zephyr/modusocket.c
+++ b/ports/zephyr/modusocket.c
@@ -75,18 +75,18 @@ STATIC void socket_check_closed(socket_obj_t *socket) {
 
 STATIC void parse_inet_addr(socket_obj_t *socket, mp_obj_t addr_in, struct sockaddr *sockaddr) {
     // We employ the fact that port and address offsets are the same for IPv4 & IPv6
-    struct sockaddr_in *sockaddr_in = (struct sockaddr_in*)sockaddr;
+    struct sockaddr_in *sockaddr_in = (struct sockaddr_in *)sockaddr;
 
     mp_obj_t *addr_items;
     mp_obj_get_array_fixed_n(addr_in, 2, &addr_items);
-    sockaddr_in->sin_family = net_context_get_family((void*)socket->ctx);
+    sockaddr_in->sin_family = net_context_get_family((void *)socket->ctx);
     RAISE_ERRNO(net_addr_pton(sockaddr_in->sin_family, mp_obj_str_get_str(addr_items[0]), &sockaddr_in->sin_addr));
     sockaddr_in->sin_port = htons(mp_obj_get_int(addr_items[1]));
 }
 
 STATIC mp_obj_t format_inet_addr(struct sockaddr *addr, mp_obj_t port) {
     // We employ the fact that port and address offsets are the same for IPv4 & IPv6
-    struct sockaddr_in6 *sockaddr_in6 = (struct sockaddr_in6*)addr;
+    struct sockaddr_in6 *sockaddr_in6 = (struct sockaddr_in6 *)addr;
     char buf[40];
     net_addr_ntop(addr->sa_family, &sockaddr_in6->sin6_addr, buf, sizeof(buf));
     mp_obj_tuple_t *tuple = mp_obj_new_tuple(addr->sa_family == AF_INET ? 2 : 4, NULL);
@@ -94,7 +94,7 @@ STATIC mp_obj_t format_inet_addr(struct sockaddr *addr, mp_obj_t port) {
     tuple->items[0] = mp_obj_new_str(buf, strlen(buf));
     // We employ the fact that port offset is the same for IPv4 & IPv6
     // not filled in
-    //tuple->items[1] = mp_obj_new_int(ntohs(((struct sockaddr_in*)addr)->sin_port));
+    // tuple->items[1] = mp_obj_new_int(ntohs(((struct sockaddr_in*)addr)->sin_port));
     tuple->items[1] = port;
 
     if (addr->sa_family == AF_INET6) {
@@ -119,7 +119,7 @@ STATIC void socket_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kin
     if (self->ctx == -1) {
         mp_printf(print, "<socket NULL>");
     } else {
-        struct net_context *ctx = (void*)self->ctx;
+        struct net_context *ctx = (void *)self->ctx;
         mp_printf(print, "<socket %p type=%d>", ctx, net_context_get_type(ctx));
     }
 }
@@ -462,7 +462,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_usocket_globals, mp_module_usocket_globals
 
 const mp_obj_module_t mp_module_usocket = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_usocket_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_usocket_globals,
 };
 
 #endif // MICROPY_PY_USOCKET
diff --git a/ports/zephyr/modutime.c b/ports/zephyr/modutime.c
index a5d32fe66589d..ba9e1d8f1ff64 100644
--- a/ports/zephyr/modutime.c
+++ b/ports/zephyr/modutime.c
@@ -61,7 +61,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_time_globals, mp_module_time_globals_table
 
 const mp_obj_module_t mp_module_time = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_time_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_time_globals,
 };
 
 #endif // MICROPY_PY_UTIME
diff --git a/ports/zephyr/modzephyr.c b/ports/zephyr/modzephyr.c
index 3d686605d589f..d4ee610b204c6 100644
--- a/ports/zephyr/modzephyr.c
+++ b/ports/zephyr/modzephyr.c
@@ -4,6 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2017 Linaro Limited
+ * Copyright (c) 2019 NXP
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -29,8 +30,9 @@
 
 #include <stdio.h>
 #include <zephyr.h>
-#include <misc/stack.h>
+#include <debug/stack.h>
 
+#include "modzephyr.h"
 #include "py/runtime.h"
 
 STATIC mp_obj_t mod_is_preempt_thread(void) {
@@ -47,8 +49,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_current_tid_obj, mod_current_tid);
 extern k_tid_t const _main_thread;
 extern k_tid_t const _idle_thread;
 
-static void thread_stack_dump(const struct k_thread *thread, void *user_data)
-{
+static void thread_stack_dump(const struct k_thread *thread, void *user_data) {
     const char *th_name = k_thread_name_get((k_tid_t)thread);
 
     if (th_name == NULL) {
@@ -57,7 +58,7 @@ static void thread_stack_dump(const struct k_thread *thread, void *user_data)
         th_name = tid;
     }
 
-    stack_analyze(th_name, (char*)thread->stack_info.start, thread->stack_info.size);
+    stack_analyze(th_name, (char *)thread->stack_info.start, thread->stack_info.size);
 }
 
 STATIC mp_obj_t mod_stacks_analyze(void) {
@@ -69,7 +70,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_stacks_analyze_obj, mod_stacks_analyze);
 
 #ifdef CONFIG_NET_SHELL
 
-//int net_shell_cmd_iface(int argc, char *argv[]);
+// int net_shell_cmd_iface(int argc, char *argv[]);
 
 STATIC mp_obj_t mod_shell_net_iface(void) {
     net_shell_cmd_iface(0, NULL);
@@ -90,13 +91,19 @@ STATIC const mp_rom_map_elem_t mp_module_time_globals_table[] = {
     #ifdef CONFIG_NET_SHELL
     { MP_ROM_QSTR(MP_QSTR_shell_net_iface), MP_ROM_PTR(&mod_shell_net_iface_obj) },
     #endif
+    #ifdef CONFIG_DISK_ACCESS
+    { MP_ROM_QSTR(MP_QSTR_DiskAccess), MP_ROM_PTR(&zephyr_disk_access_type) },
+    #endif
+    #ifdef CONFIG_FLASH_MAP
+    { MP_ROM_QSTR(MP_QSTR_FlashArea), MP_ROM_PTR(&zephyr_flash_area_type) },
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(mp_module_time_globals, mp_module_time_globals_table);
 
 const mp_obj_module_t mp_module_zephyr = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_time_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_time_globals,
 };
 
 #endif // MICROPY_PY_ZEPHYR
diff --git a/ports/zephyr/modzephyr.h b/ports/zephyr/modzephyr.h
new file mode 100644
index 0000000000000..f9b7e8eea1607
--- /dev/null
+++ b/ports/zephyr/modzephyr.h
@@ -0,0 +1,40 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 NXP
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_ZEPHYR_MODZEPHYR_H
+#define MICROPY_INCLUDED_ZEPHYR_MODZEPHYR_H
+
+#include "py/obj.h"
+
+#ifdef CONFIG_DISK_ACCESS
+extern const mp_obj_type_t zephyr_disk_access_type;
+#endif
+
+#ifdef CONFIG_FLASH_MAP
+extern const mp_obj_type_t zephyr_flash_area_type;
+#endif
+
+#endif // MICROPY_INCLUDED_ZEPHYR_MODZEPHYR_H
diff --git a/ports/zephyr/modzsensor.c b/ports/zephyr/modzsensor.c
index 2630899b04d57..b01ce2693c232 100644
--- a/ports/zephyr/modzsensor.c
+++ b/ports/zephyr/modzsensor.c
@@ -29,7 +29,7 @@
 #include "py/runtime.h"
 
 #include <zephyr.h>
-#include <sensor.h>
+#include <drivers/sensor.h>
 
 #if MICROPY_PY_ZSENSOR
 
@@ -44,7 +44,7 @@ STATIC mp_obj_t sensor_make_new(const mp_obj_type_t *type, size_t n_args, size_t
     o->base.type = type;
     o->dev = device_get_binding(mp_obj_str_get_str(args[0]));
     if (o->dev == NULL) {
-        mp_raise_ValueError("dev not found");
+        mp_raise_ValueError(MP_ERROR_TEXT("dev not found"));
     }
     return MP_OBJ_FROM_PTR(o);
 }
@@ -110,14 +110,14 @@ STATIC const mp_obj_type_t sensor_type = {
     { &mp_type_type },
     .name = MP_QSTR_Sensor,
     .make_new = sensor_make_new,
-    .locals_dict = (void*)&sensor_locals_dict,
+    .locals_dict = (void *)&sensor_locals_dict,
 };
 
 STATIC const mp_rom_map_elem_t mp_module_zsensor_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_zsensor) },
     { MP_ROM_QSTR(MP_QSTR_Sensor), MP_ROM_PTR(&sensor_type) },
 
-#define C(name) { MP_ROM_QSTR(MP_QSTR_ ## name), MP_ROM_INT(SENSOR_CHAN_ ## name) }
+#define C(name) { MP_ROM_QSTR(MP_QSTR_##name), MP_ROM_INT(SENSOR_CHAN_##name) }
     C(ACCEL_X),
     C(ACCEL_Y),
     C(ACCEL_Z),
@@ -140,7 +140,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_zsensor_globals, mp_module_zsensor_globals
 
 const mp_obj_module_t mp_module_zsensor = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_zsensor_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_zsensor_globals,
 };
 
-#endif //MICROPY_PY_UHASHLIB
+#endif // MICROPY_PY_UHASHLIB
diff --git a/ports/zephyr/mpconfigport.h b/ports/zephyr/mpconfigport.h
index 0b35de35b7840..7044c175d030c 100644
--- a/ports/zephyr/mpconfigport.h
+++ b/ports/zephyr/mpconfigport.h
@@ -72,6 +72,7 @@
 #endif
 #define MICROPY_PY_UBINASCII        (1)
 #define MICROPY_PY_UHASHLIB         (1)
+#define MICROPY_PY_UOS              (1)
 #define MICROPY_PY_UTIME            (1)
 #define MICROPY_PY_UTIME_MP_HAL     (1)
 #define MICROPY_PY_ZEPHYR           (1)
@@ -80,6 +81,15 @@
 #define MICROPY_LONGINT_IMPL (MICROPY_LONGINT_IMPL_LONGLONG)
 #define MICROPY_FLOAT_IMPL (MICROPY_FLOAT_IMPL_FLOAT)
 #define MICROPY_PY_BUILTINS_COMPLEX (0)
+#define MICROPY_VFS                 (1)
+#define MICROPY_READER_VFS          (MICROPY_VFS)
+
+// fatfs configuration used in ffconf.h
+#define MICROPY_FATFS_ENABLE_LFN       (1)
+#define MICROPY_FATFS_LFN_CODE_PAGE    437 /* 1=SFN/ANSI 437=LFN/U.S.(OEM) */
+#define MICROPY_FATFS_USE_LABEL        (1)
+#define MICROPY_FATFS_RPATH            (2)
+#define MICROPY_FATFS_NORTC            (1)
 
 // Saving extra crumbs to make sure binary fits in 128K
 #define MICROPY_COMP_CONST_FOLDING  (0)
@@ -113,16 +123,21 @@ typedef long mp_off_t;
 
 extern const struct _mp_obj_module_t mp_module_machine;
 extern const struct _mp_obj_module_t mp_module_time;
+extern const struct _mp_obj_module_t mp_module_uos;
 extern const struct _mp_obj_module_t mp_module_usocket;
 extern const struct _mp_obj_module_t mp_module_zephyr;
 extern const struct _mp_obj_module_t mp_module_zsensor;
 
+#if MICROPY_PY_UOS
+#define MICROPY_PY_UOS_DEF { MP_ROM_QSTR(MP_QSTR_uos), MP_ROM_PTR(&mp_module_uos) },
+#else
+#define MICROPY_PY_UOS_DEF
+#endif
+
 #if MICROPY_PY_USOCKET
 #define MICROPY_PY_USOCKET_DEF { MP_ROM_QSTR(MP_QSTR_usocket), MP_ROM_PTR(&mp_module_usocket) },
-#define MICROPY_PY_USOCKET_WEAK_DEF { MP_ROM_QSTR(MP_QSTR_socket), MP_ROM_PTR(&mp_module_usocket) },
 #else
 #define MICROPY_PY_USOCKET_DEF
-#define MICROPY_PY_USOCKET_WEAK_DEF
 #endif
 
 #if MICROPY_PY_UTIME
@@ -145,15 +160,12 @@ extern const struct _mp_obj_module_t mp_module_zsensor;
 
 #define MICROPY_PORT_BUILTIN_MODULES \
     { MP_ROM_QSTR(MP_QSTR_machine), MP_ROM_PTR(&mp_module_machine) }, \
+    MICROPY_PY_UOS_DEF \
     MICROPY_PY_USOCKET_DEF \
     MICROPY_PY_UTIME_DEF \
     MICROPY_PY_ZEPHYR_DEF \
     MICROPY_PY_ZSENSOR_DEF \
 
-#define MICROPY_PORT_BUILTIN_MODULE_WEAK_LINKS \
-    { MP_ROM_QSTR(MP_QSTR_time), MP_ROM_PTR(&mp_module_time) }, \
-    MICROPY_PY_USOCKET_WEAK_DEF \
-
 // extra built in names to add to the global namespace
 #define MICROPY_PORT_BUILTINS \
-
+    { MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&mp_builtin_open_obj) },
diff --git a/ports/zephyr/mphalport.h b/ports/zephyr/mphalport.h
index 4388f607dcc3b..594f6a1f69830 100644
--- a/ports/zephyr/mphalport.h
+++ b/ports/zephyr/mphalport.h
@@ -2,7 +2,7 @@
 #include "lib/utils/interrupt_char.h"
 
 static inline mp_uint_t mp_hal_ticks_us(void) {
-    return SYS_CLOCK_HW_CYCLES_TO_NS(k_cycle_get_32()) / 1000;
+    return k_cyc_to_ns_floor64(k_cycle_get_32()) / 1000;
 }
 
 static inline mp_uint_t mp_hal_ticks_ms(void) {
diff --git a/ports/zephyr/prj_base.conf b/ports/zephyr/prj.conf
similarity index 98%
rename from ports/zephyr/prj_base.conf
rename to ports/zephyr/prj.conf
index 58206a0bc2aab..993dfdc26f9ec 100644
--- a/ports/zephyr/prj_base.conf
+++ b/ports/zephyr/prj.conf
@@ -14,9 +14,6 @@ CONFIG_NEWLIB_LIBC=y
 CONFIG_FLOAT=y
 CONFIG_MAIN_STACK_SIZE=4736
 
-# Drivers
-CONFIG_I2C=y
-
 # Enable sensor subsystem (doesn't add code if not used).
 # Specific sensors should be enabled per-board.
 CONFIG_SENSOR=y
diff --git a/ports/zephyr/src/zephyr_getchar.c b/ports/zephyr/src/zephyr_getchar.c
index 52b3394d0384a..40dc1c3201243 100644
--- a/ports/zephyr/src/zephyr_getchar.c
+++ b/ports/zephyr/src/zephyr_getchar.c
@@ -15,9 +15,9 @@
  */
 
 #include <zephyr.h>
-#include <uart.h>
+#include <drivers/uart.h>
 #include <drivers/console/uart_console.h>
-#include <misc/printk.h>
+#include <sys/printk.h>
 #include "zephyr_getchar.h"
 
 extern int mp_interrupt_char;
diff --git a/ports/zephyr/src/zephyr_start.c b/ports/zephyr/src/zephyr_start.c
index 591eec76bb557..2e0993451bde4 100644
--- a/ports/zephyr/src/zephyr_start.c
+++ b/ports/zephyr/src/zephyr_start.c
@@ -24,7 +24,7 @@
  * THE SOFTWARE.
  */
 #include <zephyr.h>
-#include <console.h>
+#include <console/console.h>
 #include "zephyr_getchar.h"
 
 int real_main(void);
diff --git a/ports/zephyr/uart_core.c b/ports/zephyr/uart_core.c
index 325e437434cbb..fef9f00ab1625 100644
--- a/ports/zephyr/uart_core.c
+++ b/ports/zephyr/uart_core.c
@@ -27,8 +27,8 @@
 #include "py/mpconfig.h"
 #include "src/zephyr_getchar.h"
 // Zephyr headers
-#include <uart.h>
-#include <console.h>
+#include <drivers/uart.h>
+#include <console/console.h>
 
 /*
  * Core UART functions to implement for a port
@@ -36,23 +36,23 @@
 
 // Receive single character
 int mp_hal_stdin_rx_chr(void) {
-#ifdef CONFIG_CONSOLE_SUBSYS
+    #ifdef CONFIG_CONSOLE_SUBSYS
     return console_getchar();
-#else
+    #else
     return zephyr_getchar();
-#endif
+    #endif
 }
 
 // Send string of given length
 void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) {
-#ifdef CONFIG_CONSOLE_SUBSYS
+    #ifdef CONFIG_CONSOLE_SUBSYS
     while (len--) {
         char c = *str++;
         while (console_putchar(c) == -1) {
             k_sleep(1);
         }
     }
-#else
+    #else
     static struct device *uart_console_dev;
     if (uart_console_dev == NULL) {
         uart_console_dev = device_get_binding(CONFIG_UART_CONSOLE_ON_DEV_NAME);
@@ -61,5 +61,5 @@ void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) {
     while (len--) {
         uart_poll_out(uart_console_dev, *str++);
     }
-#endif
+    #endif
 }
diff --git a/ports/zephyr/zephyr_storage.c b/ports/zephyr/zephyr_storage.c
new file mode 100644
index 0000000000000..c533cb8fd721b
--- /dev/null
+++ b/ports/zephyr/zephyr_storage.c
@@ -0,0 +1,261 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 NXP
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "modzephyr.h"
+#include "py/runtime.h"
+
+#if MICROPY_VFS
+#include "extmod/vfs.h"
+#endif
+
+#ifdef CONFIG_DISK_ACCESS
+#include <disk/disk_access.h>
+#endif
+
+#ifdef CONFIG_FLASH_MAP
+#include <storage/flash_map.h>
+#endif
+
+#ifdef CONFIG_DISK_ACCESS
+typedef struct _zephyr_disk_access_obj_t {
+    mp_obj_base_t base;
+    const char *pdrv;
+    int block_size;
+    int block_count;
+} zephyr_disk_access_obj_t;
+
+STATIC void zephyr_disk_access_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    zephyr_disk_access_obj_t *self = self_in;
+    mp_printf(print, "DiskAccess(%s)", self->pdrv);
+}
+
+STATIC mp_obj_t zephyr_disk_access_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 1, 1, false);
+    zephyr_disk_access_obj_t *self = m_new_obj(zephyr_disk_access_obj_t);
+    self->base.type = type;
+    self->pdrv = mp_obj_str_get_str(args[0]);
+
+    if (disk_access_init(self->pdrv) != 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("disk not found"));
+    }
+
+    if (disk_access_ioctl(self->pdrv, DISK_IOCTL_GET_SECTOR_SIZE, &self->block_size)) {
+        mp_raise_ValueError(MP_ERROR_TEXT("unable to get sector size"));
+    }
+
+    if (disk_access_ioctl(self->pdrv, DISK_IOCTL_GET_SECTOR_COUNT, &self->block_count)) {
+        mp_raise_ValueError(MP_ERROR_TEXT("unable to get block count"));
+    }
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC mp_obj_t zephyr_disk_access_readblocks(mp_obj_t self_in, mp_obj_t block_num, mp_obj_t buf) {
+    zephyr_disk_access_obj_t *self = self_in;
+    mp_buffer_info_t bufinfo;
+    int ret;
+
+    mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_WRITE);
+    ret = disk_access_read(self->pdrv, bufinfo.buf, mp_obj_get_int(block_num), bufinfo.len / self->block_size);
+    return MP_OBJ_NEW_SMALL_INT(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(zephyr_disk_access_readblocks_obj, zephyr_disk_access_readblocks);
+
+STATIC mp_obj_t zephyr_disk_access_writeblocks(mp_obj_t self_in, mp_obj_t block_num, mp_obj_t buf) {
+    zephyr_disk_access_obj_t *self = self_in;
+    mp_buffer_info_t bufinfo;
+    int ret;
+
+    mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_READ);
+    ret = disk_access_write(self->pdrv, bufinfo.buf, mp_obj_get_int(block_num), bufinfo.len / self->block_size);
+    return MP_OBJ_NEW_SMALL_INT(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(zephyr_disk_access_writeblocks_obj, zephyr_disk_access_writeblocks);
+
+STATIC mp_obj_t zephyr_disk_access_ioctl(mp_obj_t self_in, mp_obj_t cmd_in, mp_obj_t arg_in) {
+    zephyr_disk_access_obj_t *self = self_in;
+    mp_int_t cmd = mp_obj_get_int(cmd_in);
+    int buf;
+    int ret;
+
+    switch (cmd) {
+        case MP_BLOCKDEV_IOCTL_INIT:
+        case MP_BLOCKDEV_IOCTL_DEINIT:
+            return MP_OBJ_NEW_SMALL_INT(0);
+
+        case MP_BLOCKDEV_IOCTL_SYNC:
+            ret = disk_access_ioctl(self->pdrv, DISK_IOCTL_CTRL_SYNC, &buf);
+            return MP_OBJ_NEW_SMALL_INT(ret);
+
+        case MP_BLOCKDEV_IOCTL_BLOCK_COUNT:
+            return MP_OBJ_NEW_SMALL_INT(self->block_count);
+
+        case MP_BLOCKDEV_IOCTL_BLOCK_SIZE:
+            return MP_OBJ_NEW_SMALL_INT(self->block_size);
+
+        default:
+            return MP_OBJ_NEW_SMALL_INT(-1);
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(zephyr_disk_access_ioctl_obj, zephyr_disk_access_ioctl);
+
+STATIC const mp_rom_map_elem_t zephyr_disk_access_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_readblocks), MP_ROM_PTR(&zephyr_disk_access_readblocks_obj) },
+    { MP_ROM_QSTR(MP_QSTR_writeblocks), MP_ROM_PTR(&zephyr_disk_access_writeblocks_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ioctl), MP_ROM_PTR(&zephyr_disk_access_ioctl_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(zephyr_disk_access_locals_dict, zephyr_disk_access_locals_dict_table);
+
+const mp_obj_type_t zephyr_disk_access_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_DiskAccess,
+    .print = zephyr_disk_access_print,
+    .make_new = zephyr_disk_access_make_new,
+    .locals_dict = (mp_obj_dict_t *)&zephyr_disk_access_locals_dict,
+};
+#endif // CONFIG_DISK_ACCESS
+
+#ifdef CONFIG_FLASH_MAP
+const mp_obj_type_t zephyr_flash_area_type;
+
+typedef struct _zephyr_flash_area_obj_t {
+    mp_obj_base_t base;
+    const struct flash_area *area;
+    int block_size;
+    int block_count;
+    u8_t id;
+} zephyr_flash_area_obj_t;
+
+STATIC void zephyr_flash_area_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    zephyr_flash_area_obj_t *self = self_in;
+    mp_printf(print, "FlashArea(%d)", self->id);
+}
+
+STATIC mp_obj_t zephyr_flash_area_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 2, 2, false);
+    zephyr_flash_area_obj_t *self = m_new_obj(zephyr_flash_area_obj_t);
+    self->base.type = type;
+    self->id = mp_obj_get_int(args[0]);
+    self->block_size = mp_obj_get_int(args[1]);
+
+    if (self->block_size <= 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid block size"));
+    }
+
+    if (flash_area_open(self->id, &self->area) != 0) {
+        mp_raise_ValueError(MP_ERROR_TEXT("unable to open flash area"));
+    }
+
+    self->block_count = self->area->fa_size / self->block_size;
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC mp_obj_t zephyr_flash_area_readblocks(size_t n_args, const mp_obj_t *args) {
+    zephyr_flash_area_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    uint32_t block_num = mp_obj_get_int(args[1]);
+    off_t offset = block_num * self->block_size;
+    mp_buffer_info_t bufinfo;
+    int ret;
+
+    if (n_args >= 4) {
+        offset += mp_obj_get_int(args[3]);
+    }
+
+    mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_WRITE);
+    ret = flash_area_read(self->area, offset, bufinfo.buf, bufinfo.len);
+    return MP_OBJ_NEW_SMALL_INT(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(zephyr_flash_area_readblocks_obj, 3, 4, zephyr_flash_area_readblocks);
+
+STATIC mp_obj_t zephyr_flash_area_writeblocks(size_t n_args, const mp_obj_t *args) {
+    zephyr_flash_area_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    uint32_t block_num = mp_obj_get_int(args[1]);
+    off_t offset = block_num * self->block_size;
+    mp_buffer_info_t bufinfo;
+    int ret;
+
+    if (n_args == 3) {
+        ret = flash_area_erase(self->area, offset, self->block_size);
+        if (ret) {
+            return MP_OBJ_NEW_SMALL_INT(ret);
+        }
+    } else {
+        offset += mp_obj_get_int(args[3]);
+    }
+
+    mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_READ);
+    ret = flash_area_write(self->area, offset, bufinfo.buf, bufinfo.len);
+    return MP_OBJ_NEW_SMALL_INT(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(zephyr_flash_area_writeblocks_obj, 3, 4, zephyr_flash_area_writeblocks);
+
+STATIC mp_obj_t zephyr_flash_area_ioctl(mp_obj_t self_in, mp_obj_t cmd_in, mp_obj_t arg_in) {
+    zephyr_flash_area_obj_t *self = self_in;
+    mp_int_t cmd = mp_obj_get_int(cmd_in);
+    mp_int_t block_num = mp_obj_get_int(arg_in);
+    int ret;
+
+    switch (cmd) {
+        case MP_BLOCKDEV_IOCTL_INIT:
+        case MP_BLOCKDEV_IOCTL_DEINIT:
+        case MP_BLOCKDEV_IOCTL_SYNC:
+            return MP_OBJ_NEW_SMALL_INT(0);
+
+        case MP_BLOCKDEV_IOCTL_BLOCK_COUNT:
+            return MP_OBJ_NEW_SMALL_INT(self->block_count);
+
+        case MP_BLOCKDEV_IOCTL_BLOCK_SIZE:
+            return MP_OBJ_NEW_SMALL_INT(self->block_size);
+
+        case MP_BLOCKDEV_IOCTL_BLOCK_ERASE:
+            ret = flash_area_erase(self->area, block_num * self->block_size, self->block_size);
+            return MP_OBJ_NEW_SMALL_INT(ret);
+
+        default:
+            return MP_OBJ_NEW_SMALL_INT(-1);
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(zephyr_flash_area_ioctl_obj, zephyr_flash_area_ioctl);
+
+STATIC const mp_rom_map_elem_t zephyr_flash_area_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_readblocks), MP_ROM_PTR(&zephyr_flash_area_readblocks_obj) },
+    { MP_ROM_QSTR(MP_QSTR_writeblocks), MP_ROM_PTR(&zephyr_flash_area_writeblocks_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ioctl), MP_ROM_PTR(&zephyr_flash_area_ioctl_obj) },
+    #ifdef DT_FLASH_AREA_STORAGE_ID
+    { MP_ROM_QSTR(MP_QSTR_STORAGE), MP_ROM_INT(DT_FLASH_AREA_STORAGE_ID) },
+    #endif
+};
+STATIC MP_DEFINE_CONST_DICT(zephyr_flash_area_locals_dict, zephyr_flash_area_locals_dict_table);
+
+const mp_obj_type_t zephyr_flash_area_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_FlashArea,
+    .print = zephyr_flash_area_print,
+    .make_new = zephyr_flash_area_make_new,
+    .locals_dict = (mp_obj_dict_t *)&zephyr_flash_area_locals_dict,
+};
+#endif // CONFIG_FLASH_MAP
diff --git a/py/argcheck.c b/py/argcheck.c
index c2b1b6c079284..c333ead05b64a 100644
--- a/py/argcheck.c
+++ b/py/argcheck.c
@@ -38,40 +38,40 @@ void mp_arg_check_num_sig(size_t n_args, size_t n_kw, uint32_t sig) {
     size_t n_args_max = (sig >> 1) & 0xffff;
 
     if (n_kw && !takes_kw) {
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_arg_error_terse_mismatch();
-        } else {
-            mp_raise_TypeError("function doesn't take keyword arguments");
-        }
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_arg_error_terse_mismatch();
+        #else
+        mp_raise_TypeError(MP_ERROR_TEXT("function doesn't take keyword arguments"));
+        #endif
     }
 
     if (n_args_min == n_args_max) {
         if (n_args != n_args_min) {
-            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                mp_arg_error_terse_mismatch();
-            } else {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                    "function takes %d positional arguments but %d were given",
-                    n_args_min, n_args));
-            }
+            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+            mp_arg_error_terse_mismatch();
+            #else
+            mp_raise_msg_varg(&mp_type_TypeError,
+                MP_ERROR_TEXT("function takes %d positional arguments but %d were given"),
+                n_args_min, n_args);
+            #endif
         }
     } else {
         if (n_args < n_args_min) {
-            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                mp_arg_error_terse_mismatch();
-            } else {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                    "function missing %d required positional arguments",
-                    n_args_min - n_args));
-            }
+            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+            mp_arg_error_terse_mismatch();
+            #else
+            mp_raise_msg_varg(&mp_type_TypeError,
+                MP_ERROR_TEXT("function missing %d required positional arguments"),
+                n_args_min - n_args);
+            #endif
         } else if (n_args > n_args_max) {
-            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                mp_arg_error_terse_mismatch();
-            } else {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                    "function expected at most %d arguments, got %d",
-                    n_args_max, n_args));
-            }
+            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+            mp_arg_error_terse_mismatch();
+            #else
+            mp_raise_msg_varg(&mp_type_TypeError,
+                MP_ERROR_TEXT("function expected at most %d arguments, got %d"),
+                n_args_max, n_args);
+            #endif
         }
     }
 }
@@ -90,12 +90,11 @@ void mp_arg_parse_all(size_t n_pos, const mp_obj_t *pos, mp_map_t *kws, size_t n
             mp_map_elem_t *kw = mp_map_lookup(kws, MP_OBJ_NEW_QSTR(allowed[i].qst), MP_MAP_LOOKUP);
             if (kw == NULL) {
                 if (allowed[i].flags & MP_ARG_REQUIRED) {
-                    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                        mp_arg_error_terse_mismatch();
-                    } else {
-                        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                            "'%q' argument required", allowed[i].qst));
-                    }
+                    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                    mp_arg_error_terse_mismatch();
+                    #else
+                    mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("'%q' argument required"), allowed[i].qst);
+                    #endif
                 }
                 out_vals[i] = allowed[i].defval;
                 continue;
@@ -114,21 +113,21 @@ void mp_arg_parse_all(size_t n_pos, const mp_obj_t *pos, mp_map_t *kws, size_t n
         }
     }
     if (pos_found < n_pos) {
-        extra_positional:
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_arg_error_terse_mismatch();
-        } else {
-            // TODO better error message
-            mp_raise_TypeError("extra positional arguments given");
-        }
+    extra_positional:
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_arg_error_terse_mismatch();
+        #else
+        // TODO better error message
+        mp_raise_TypeError(MP_ERROR_TEXT("extra positional arguments given"));
+        #endif
     }
     if (kws_found < kws->used) {
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_arg_error_terse_mismatch();
-        } else {
-            // TODO better error message
-            mp_raise_TypeError("extra keyword arguments given");
-        }
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_arg_error_terse_mismatch();
+        #else
+        // TODO better error message
+        mp_raise_TypeError(MP_ERROR_TEXT("extra keyword arguments given"));
+        #endif
     }
 }
 
@@ -139,11 +138,11 @@ void mp_arg_parse_all_kw_array(size_t n_pos, size_t n_kw, const mp_obj_t *args,
 }
 
 NORETURN void mp_arg_error_terse_mismatch(void) {
-    mp_raise_TypeError("argument num/types mismatch");
+    mp_raise_TypeError(MP_ERROR_TEXT("argument num/types mismatch"));
 }
 
 #if MICROPY_CPYTHON_COMPAT
 NORETURN void mp_arg_error_unimpl_kw(void) {
-    mp_raise_NotImplementedError("keyword argument(s) not yet implemented - use normal args instead");
+    mp_raise_NotImplementedError(MP_ERROR_TEXT("keyword argument(s) not yet implemented - use normal args instead"));
 }
 #endif
diff --git a/py/asmarm.c b/py/asmarm.c
index f2221f8a92642..72b37f73a02f5 100644
--- a/py/asmarm.c
+++ b/py/asmarm.c
@@ -40,16 +40,20 @@
 
 void asm_arm_end_pass(asm_arm_t *as) {
     if (as->base.pass == MP_ASM_PASS_EMIT) {
-#ifdef __arm__
+        #if defined(__linux__) && defined(__GNUC__)
+        char *start = mp_asm_base_get_code(&as->base);
+        char *end = start + mp_asm_base_get_code_size(&as->base);
+        __builtin___clear_cache(start, end);
+        #elif defined(__arm__)
         // flush I- and D-cache
-        asm volatile(
-                "0:"
-                "mrc p15, 0, r15, c7, c10, 3\n"
-                "bne 0b\n"
-                "mov r0, #0\n"
-                "mcr p15, 0, r0, c7, c7, 0\n"
-                : : : "r0", "cc");
-#endif
+        asm volatile (
+            "0:"
+            "mrc p15, 0, r15, c7, c10, 3\n"
+            "bne 0b\n"
+            "mov r0, #0\n"
+            "mcr p15, 0, r0, c7, c7, 0\n"
+            : : : "r0", "cc");
+        #endif
     }
 }
 
@@ -57,7 +61,7 @@ void asm_arm_end_pass(asm_arm_t *as) {
 STATIC void emit(asm_arm_t *as, uint op) {
     uint8_t *c = mp_asm_base_get_cur_to_write_bytes(&as->base, 4);
     if (c != NULL) {
-        *(uint32_t*)c = op;
+        *(uint32_t *)c = op;
     }
 }
 
diff --git a/py/asmbase.c b/py/asmbase.c
index 4c84c3b255d1d..344e03e7a7ad7 100644
--- a/py/asmbase.c
+++ b/py/asmbase.c
@@ -31,7 +31,7 @@
 #include "py/misc.h"
 #include "py/asmbase.h"
 
-#if MICROPY_EMIT_NATIVE || MICROPY_EMIT_INLINE_ASM
+#if MICROPY_EMIT_MACHINE_CODE
 
 void mp_asm_base_init(mp_asm_base_t *as, size_t max_num_labels) {
     as->max_num_labels = max_num_labels;
@@ -51,7 +51,7 @@ void mp_asm_base_start_pass(mp_asm_base_t *as, int pass) {
         memset(as->label_offsets, -1, as->max_num_labels * sizeof(size_t));
     } else {
         // allocating executable RAM is platform specific
-        MP_PLAT_ALLOC_EXEC(as->code_offset, (void**)&as->code_base, &as->code_size);
+        MP_PLAT_ALLOC_EXEC(as->code_offset, (void **)&as->code_base, &as->code_size);
         assert(as->code_base != NULL);
     }
     as->pass = pass;
@@ -84,12 +84,12 @@ void mp_asm_base_label_assign(mp_asm_base_t *as, size_t label) {
 }
 
 // align must be a multiple of 2
-void mp_asm_base_align(mp_asm_base_t* as, unsigned int align) {
+void mp_asm_base_align(mp_asm_base_t *as, unsigned int align) {
     as->code_offset = (as->code_offset + align - 1) & (~(align - 1));
 }
 
 // this function assumes a little endian machine
-void mp_asm_base_data(mp_asm_base_t* as, unsigned int bytesize, uintptr_t val) {
+void mp_asm_base_data(mp_asm_base_t *as, unsigned int bytesize, uintptr_t val) {
     uint8_t *c = mp_asm_base_get_cur_to_write_bytes(as, bytesize);
     if (c != NULL) {
         for (unsigned int i = 0; i < bytesize; i++) {
@@ -99,4 +99,4 @@ void mp_asm_base_data(mp_asm_base_t* as, unsigned int bytesize, uintptr_t val) {
     }
 }
 
-#endif // MICROPY_EMIT_NATIVE || MICROPY_EMIT_INLINE_ASM
+#endif // MICROPY_EMIT_MACHINE_CODE
diff --git a/py/asmbase.h b/py/asmbase.h
index d2b40389310ed..24c3af8679c08 100644
--- a/py/asmbase.h
+++ b/py/asmbase.h
@@ -47,8 +47,8 @@ void mp_asm_base_deinit(mp_asm_base_t *as, bool free_code);
 void mp_asm_base_start_pass(mp_asm_base_t *as, int pass);
 uint8_t *mp_asm_base_get_cur_to_write_bytes(mp_asm_base_t *as, size_t num_bytes_to_write);
 void mp_asm_base_label_assign(mp_asm_base_t *as, size_t label);
-void mp_asm_base_align(mp_asm_base_t* as, unsigned int align);
-void mp_asm_base_data(mp_asm_base_t* as, unsigned int bytesize, uintptr_t val);
+void mp_asm_base_align(mp_asm_base_t *as, unsigned int align);
+void mp_asm_base_data(mp_asm_base_t *as, unsigned int bytesize, uintptr_t val);
 
 static inline size_t mp_asm_base_get_code_pos(mp_asm_base_t *as) {
     return as->code_offset;
@@ -60,7 +60,7 @@ static inline size_t mp_asm_base_get_code_size(mp_asm_base_t *as) {
 
 static inline void *mp_asm_base_get_code(mp_asm_base_t *as) {
     #if defined(MP_PLAT_COMMIT_EXEC)
-    return MP_PLAT_COMMIT_EXEC(as->code_base, as->code_size);
+    return MP_PLAT_COMMIT_EXEC(as->code_base, as->code_size, NULL);
     #else
     return as->code_base;
     #endif
diff --git a/py/asmthumb.c b/py/asmthumb.c
index e6bba7ea60ebe..bb10935fdaad3 100644
--- a/py/asmthumb.c
+++ b/py/asmthumb.c
@@ -33,6 +33,8 @@
 // wrapper around everything in this file
 #if MICROPY_EMIT_THUMB || MICROPY_EMIT_INLINE_THUMB
 
+#include "py/mpstate.h"
+#include "py/persistentcode.h"
 #include "py/mphal.h"
 #include "py/asmthumb.h"
 
@@ -118,6 +120,21 @@ STATIC void asm_thumb_write_word32(asm_thumb_t *as, int w32) {
 void asm_thumb_entry(asm_thumb_t *as, int num_locals) {
     assert(num_locals >= 0);
 
+    // If this Thumb machine code is run from ARM state then add a prelude
+    // to switch to Thumb state for the duration of the function.
+    #if MICROPY_DYNAMIC_COMPILER || MICROPY_EMIT_ARM || (defined(__arm__) && !defined(__thumb2__))
+    #if MICROPY_DYNAMIC_COMPILER
+    if (mp_dynamic_compiler.native_arch == MP_NATIVE_ARCH_ARMV6)
+    #endif
+    {
+        asm_thumb_op32(as, 0x4010, 0xe92d); // push {r4, lr}
+        asm_thumb_op32(as, 0xe009, 0xe28f); // add lr, pc, 8 + 1
+        asm_thumb_op32(as, 0xff3e, 0xe12f); // blx lr
+        asm_thumb_op32(as, 0x4010, 0xe8bd); // pop {r4, lr}
+        asm_thumb_op32(as, 0xff1e, 0xe12f); // bx lr
+    }
+    #endif
+
     // work out what to push and how many extra spaces to reserve on stack
     // so that we have enough for all locals and it's aligned an 8-byte boundary
     // we push extra regs (r1, r2, r3) to help do the stack adjustment
@@ -360,7 +377,7 @@ void asm_thumb_b_label(asm_thumb_t *as, uint label) {
         }
     } else {
         // is a forwards jump, so need to assume it's large
-        large_jump:
+    large_jump:
         asm_thumb_op32(as, OP_BW_HI(rel), OP_BW_LO(rel));
     }
 }
@@ -379,7 +396,7 @@ void asm_thumb_bcc_label(asm_thumb_t *as, int cond, uint label) {
         }
     } else {
         // is a forwards jump, so need to assume it's large
-        large_jump:
+    large_jump:
         asm_thumb_op32(as, OP_BCC_W_HI(cond, rel), OP_BCC_W_LO(rel));
     }
 }
diff --git a/py/asmthumb.h b/py/asmthumb.h
index c21c23ff79798..6d0ee4b76e50e 100644
--- a/py/asmthumb.h
+++ b/py/asmthumb.h
@@ -95,8 +95,9 @@ void asm_thumb_exit(asm_thumb_t *as);
 void asm_thumb_op16(asm_thumb_t *as, uint op);
 void asm_thumb_op32(asm_thumb_t *as, uint op1, uint op2);
 
-static inline void asm_thumb_it_cc(asm_thumb_t *as, uint cc, uint mask)
-    { asm_thumb_op16(as, ASM_THUMB_OP_IT | (cc << 4) | mask); }
+static inline void asm_thumb_it_cc(asm_thumb_t *as, uint cc, uint mask) {
+    asm_thumb_op16(as, ASM_THUMB_OP_IT | (cc << 4) | mask);
+}
 
 // FORMAT 1: move shifted register
 
@@ -129,14 +130,18 @@ static inline void asm_thumb_format_2(asm_thumb_t *as, uint op, uint rlo_dest, u
     asm_thumb_op16(as, ASM_THUMB_FORMAT_2_ENCODE(op, rlo_dest, rlo_src, src_b));
 }
 
-static inline void asm_thumb_add_rlo_rlo_rlo(asm_thumb_t *as, uint rlo_dest, uint rlo_src_a, uint rlo_src_b)
-    { asm_thumb_format_2(as, ASM_THUMB_FORMAT_2_ADD | ASM_THUMB_FORMAT_2_REG_OPERAND, rlo_dest, rlo_src_a, rlo_src_b); }
-static inline void asm_thumb_add_rlo_rlo_i3(asm_thumb_t *as, uint rlo_dest, uint rlo_src_a, int i3_src)
-    { asm_thumb_format_2(as, ASM_THUMB_FORMAT_2_ADD | ASM_THUMB_FORMAT_2_IMM_OPERAND, rlo_dest, rlo_src_a, i3_src); }
-static inline void asm_thumb_sub_rlo_rlo_rlo(asm_thumb_t *as, uint rlo_dest, uint rlo_src_a, uint rlo_src_b)
-    { asm_thumb_format_2(as, ASM_THUMB_FORMAT_2_SUB | ASM_THUMB_FORMAT_2_REG_OPERAND, rlo_dest, rlo_src_a, rlo_src_b); }
-static inline void asm_thumb_sub_rlo_rlo_i3(asm_thumb_t *as, uint rlo_dest, uint rlo_src_a, int i3_src)
-    { asm_thumb_format_2(as, ASM_THUMB_FORMAT_2_SUB | ASM_THUMB_FORMAT_2_IMM_OPERAND, rlo_dest, rlo_src_a, i3_src); }
+static inline void asm_thumb_add_rlo_rlo_rlo(asm_thumb_t *as, uint rlo_dest, uint rlo_src_a, uint rlo_src_b) {
+    asm_thumb_format_2(as, ASM_THUMB_FORMAT_2_ADD | ASM_THUMB_FORMAT_2_REG_OPERAND, rlo_dest, rlo_src_a, rlo_src_b);
+}
+static inline void asm_thumb_add_rlo_rlo_i3(asm_thumb_t *as, uint rlo_dest, uint rlo_src_a, int i3_src) {
+    asm_thumb_format_2(as, ASM_THUMB_FORMAT_2_ADD | ASM_THUMB_FORMAT_2_IMM_OPERAND, rlo_dest, rlo_src_a, i3_src);
+}
+static inline void asm_thumb_sub_rlo_rlo_rlo(asm_thumb_t *as, uint rlo_dest, uint rlo_src_a, uint rlo_src_b) {
+    asm_thumb_format_2(as, ASM_THUMB_FORMAT_2_SUB | ASM_THUMB_FORMAT_2_REG_OPERAND, rlo_dest, rlo_src_a, rlo_src_b);
+}
+static inline void asm_thumb_sub_rlo_rlo_i3(asm_thumb_t *as, uint rlo_dest, uint rlo_src_a, int i3_src) {
+    asm_thumb_format_2(as, ASM_THUMB_FORMAT_2_SUB | ASM_THUMB_FORMAT_2_IMM_OPERAND, rlo_dest, rlo_src_a, i3_src);
+}
 
 // FORMAT 3: move/compare/add/subtract immediate
 // These instructions all do zero extension of the i8 value
@@ -153,10 +158,18 @@ static inline void asm_thumb_format_3(asm_thumb_t *as, uint op, uint rlo, int i8
     asm_thumb_op16(as, ASM_THUMB_FORMAT_3_ENCODE(op, rlo, i8));
 }
 
-static inline void asm_thumb_mov_rlo_i8(asm_thumb_t *as, uint rlo, int i8) { asm_thumb_format_3(as, ASM_THUMB_FORMAT_3_MOV, rlo, i8); }
-static inline void asm_thumb_cmp_rlo_i8(asm_thumb_t *as, uint rlo, int i8) { asm_thumb_format_3(as, ASM_THUMB_FORMAT_3_CMP, rlo, i8); }
-static inline void asm_thumb_add_rlo_i8(asm_thumb_t *as, uint rlo, int i8) { asm_thumb_format_3(as, ASM_THUMB_FORMAT_3_ADD, rlo, i8); }
-static inline void asm_thumb_sub_rlo_i8(asm_thumb_t *as, uint rlo, int i8) { asm_thumb_format_3(as, ASM_THUMB_FORMAT_3_SUB, rlo, i8); }
+static inline void asm_thumb_mov_rlo_i8(asm_thumb_t *as, uint rlo, int i8) {
+    asm_thumb_format_3(as, ASM_THUMB_FORMAT_3_MOV, rlo, i8);
+}
+static inline void asm_thumb_cmp_rlo_i8(asm_thumb_t *as, uint rlo, int i8) {
+    asm_thumb_format_3(as, ASM_THUMB_FORMAT_3_CMP, rlo, i8);
+}
+static inline void asm_thumb_add_rlo_i8(asm_thumb_t *as, uint rlo, int i8) {
+    asm_thumb_format_3(as, ASM_THUMB_FORMAT_3_ADD, rlo, i8);
+}
+static inline void asm_thumb_sub_rlo_i8(asm_thumb_t *as, uint rlo, int i8) {
+    asm_thumb_format_3(as, ASM_THUMB_FORMAT_3_SUB, rlo, i8);
+}
 
 // FORMAT 4: ALU operations
 
@@ -179,7 +192,9 @@ static inline void asm_thumb_sub_rlo_i8(asm_thumb_t *as, uint rlo, int i8) { asm
 
 void asm_thumb_format_4(asm_thumb_t *as, uint op, uint rlo_dest, uint rlo_src);
 
-static inline void asm_thumb_cmp_rlo_rlo(asm_thumb_t *as, uint rlo_dest, uint rlo_src) { asm_thumb_format_4(as, ASM_THUMB_FORMAT_4_CMP, rlo_dest, rlo_src); }
+static inline void asm_thumb_cmp_rlo_rlo(asm_thumb_t *as, uint rlo_dest, uint rlo_src) {
+    asm_thumb_format_4(as, ASM_THUMB_FORMAT_4_CMP, rlo_dest, rlo_src);
+}
 
 // FORMAT 5: hi register operations (add, cmp, mov, bx)
 // For add/cmp/mov, at least one of the args must be a high register
@@ -219,21 +234,28 @@ static inline void asm_thumb_bx_reg(asm_thumb_t *as, uint r_src) {
 #define ASM_THUMB_FORMAT_9_10_ENCODE(op, rlo_dest, rlo_base, offset) \
     ((op) | (((offset) << 6) & 0x07c0) | ((rlo_base) << 3) | (rlo_dest))
 
-static inline void asm_thumb_format_9_10(asm_thumb_t *as, uint op, uint rlo_dest, uint rlo_base, uint offset)
-    { asm_thumb_op16(as, ASM_THUMB_FORMAT_9_10_ENCODE(op, rlo_dest, rlo_base, offset)); }
-
-static inline void asm_thumb_str_rlo_rlo_i5(asm_thumb_t *as, uint rlo_src, uint rlo_base, uint word_offset)
-    { asm_thumb_format_9_10(as, ASM_THUMB_FORMAT_9_STR | ASM_THUMB_FORMAT_9_WORD_TRANSFER, rlo_src, rlo_base, word_offset); }
-static inline void asm_thumb_strb_rlo_rlo_i5(asm_thumb_t *as, uint rlo_src, uint rlo_base, uint byte_offset)
-    { asm_thumb_format_9_10(as, ASM_THUMB_FORMAT_9_STR | ASM_THUMB_FORMAT_9_BYTE_TRANSFER, rlo_src, rlo_base, byte_offset); }
-static inline void asm_thumb_strh_rlo_rlo_i5(asm_thumb_t *as, uint rlo_src, uint rlo_base, uint byte_offset)
-    { asm_thumb_format_9_10(as, ASM_THUMB_FORMAT_10_STRH, rlo_src, rlo_base, byte_offset); }
-static inline void asm_thumb_ldr_rlo_rlo_i5(asm_thumb_t *as, uint rlo_dest, uint rlo_base, uint word_offset)
-    { asm_thumb_format_9_10(as, ASM_THUMB_FORMAT_9_LDR | ASM_THUMB_FORMAT_9_WORD_TRANSFER, rlo_dest, rlo_base, word_offset); }
-static inline void asm_thumb_ldrb_rlo_rlo_i5(asm_thumb_t *as, uint rlo_dest, uint rlo_base, uint byte_offset)
-    { asm_thumb_format_9_10(as, ASM_THUMB_FORMAT_9_LDR | ASM_THUMB_FORMAT_9_BYTE_TRANSFER , rlo_dest, rlo_base, byte_offset); }
-static inline void asm_thumb_ldrh_rlo_rlo_i5(asm_thumb_t *as, uint rlo_dest, uint rlo_base, uint byte_offset)
-    { asm_thumb_format_9_10(as, ASM_THUMB_FORMAT_10_LDRH, rlo_dest, rlo_base, byte_offset); }
+static inline void asm_thumb_format_9_10(asm_thumb_t *as, uint op, uint rlo_dest, uint rlo_base, uint offset) {
+    asm_thumb_op16(as, ASM_THUMB_FORMAT_9_10_ENCODE(op, rlo_dest, rlo_base, offset));
+}
+
+static inline void asm_thumb_str_rlo_rlo_i5(asm_thumb_t *as, uint rlo_src, uint rlo_base, uint word_offset) {
+    asm_thumb_format_9_10(as, ASM_THUMB_FORMAT_9_STR | ASM_THUMB_FORMAT_9_WORD_TRANSFER, rlo_src, rlo_base, word_offset);
+}
+static inline void asm_thumb_strb_rlo_rlo_i5(asm_thumb_t *as, uint rlo_src, uint rlo_base, uint byte_offset) {
+    asm_thumb_format_9_10(as, ASM_THUMB_FORMAT_9_STR | ASM_THUMB_FORMAT_9_BYTE_TRANSFER, rlo_src, rlo_base, byte_offset);
+}
+static inline void asm_thumb_strh_rlo_rlo_i5(asm_thumb_t *as, uint rlo_src, uint rlo_base, uint byte_offset) {
+    asm_thumb_format_9_10(as, ASM_THUMB_FORMAT_10_STRH, rlo_src, rlo_base, byte_offset);
+}
+static inline void asm_thumb_ldr_rlo_rlo_i5(asm_thumb_t *as, uint rlo_dest, uint rlo_base, uint word_offset) {
+    asm_thumb_format_9_10(as, ASM_THUMB_FORMAT_9_LDR | ASM_THUMB_FORMAT_9_WORD_TRANSFER, rlo_dest, rlo_base, word_offset);
+}
+static inline void asm_thumb_ldrb_rlo_rlo_i5(asm_thumb_t *as, uint rlo_dest, uint rlo_base, uint byte_offset) {
+    asm_thumb_format_9_10(as, ASM_THUMB_FORMAT_9_LDR | ASM_THUMB_FORMAT_9_BYTE_TRANSFER, rlo_dest, rlo_base, byte_offset);
+}
+static inline void asm_thumb_ldrh_rlo_rlo_i5(asm_thumb_t *as, uint rlo_dest, uint rlo_base, uint byte_offset) {
+    asm_thumb_format_9_10(as, ASM_THUMB_FORMAT_10_LDRH, rlo_dest, rlo_base, byte_offset);
+}
 
 // TODO convert these to above format style
 
diff --git a/py/asmx64.c b/py/asmx64.c
index b18703a9c5abb..723671d5a3558 100644
--- a/py/asmx64.c
+++ b/py/asmx64.c
@@ -63,15 +63,15 @@
 #define OPCODE_SUB_R64_FROM_RM64 (0x29)
 #define OPCODE_SUB_I32_FROM_RM64 (0x81) /* /5 */
 #define OPCODE_SUB_I8_FROM_RM64  (0x83) /* /5 */
-//#define OPCODE_SHL_RM32_BY_I8    (0xc1) /* /4 */
-//#define OPCODE_SHR_RM32_BY_I8    (0xc1) /* /5 */
-//#define OPCODE_SAR_RM32_BY_I8    (0xc1) /* /7 */
+// #define OPCODE_SHL_RM32_BY_I8    (0xc1) /* /4 */
+// #define OPCODE_SHR_RM32_BY_I8    (0xc1) /* /5 */
+// #define OPCODE_SAR_RM32_BY_I8    (0xc1) /* /7 */
 #define OPCODE_SHL_RM64_CL       (0xd3) /* /4 */
 #define OPCODE_SAR_RM64_CL       (0xd3) /* /7 */
-//#define OPCODE_CMP_I32_WITH_RM32 (0x81) /* /7 */
-//#define OPCODE_CMP_I8_WITH_RM32  (0x83) /* /7 */
+// #define OPCODE_CMP_I32_WITH_RM32 (0x81) /* /7 */
+// #define OPCODE_CMP_I8_WITH_RM32  (0x83) /* /7 */
 #define OPCODE_CMP_R64_WITH_RM64 (0x39) /* /r */
-//#define OPCODE_CMP_RM32_WITH_R32 (0x3b)
+// #define OPCODE_CMP_RM32_WITH_R32 (0x3b)
 #define OPCODE_TEST_R8_WITH_RM8  (0x84) /* /r */
 #define OPCODE_TEST_R64_WITH_RM64 (0x85) /* /r */
 #define OPCODE_JMP_REL8          (0xeb)
@@ -123,14 +123,14 @@ static inline byte *asm_x64_get_cur_to_write_bytes(asm_x64_t *as, int n) {
 }
 
 STATIC void asm_x64_write_byte_1(asm_x64_t *as, byte b1) {
-    byte* c = asm_x64_get_cur_to_write_bytes(as, 1);
+    byte *c = asm_x64_get_cur_to_write_bytes(as, 1);
     if (c != NULL) {
         c[0] = b1;
     }
 }
 
 STATIC void asm_x64_write_byte_2(asm_x64_t *as, byte b1, byte b2) {
-    byte* c = asm_x64_get_cur_to_write_bytes(as, 2);
+    byte *c = asm_x64_get_cur_to_write_bytes(as, 2);
     if (c != NULL) {
         c[0] = b1;
         c[1] = b2;
@@ -138,7 +138,7 @@ STATIC void asm_x64_write_byte_2(asm_x64_t *as, byte b1, byte b2) {
 }
 
 STATIC void asm_x64_write_byte_3(asm_x64_t *as, byte b1, byte b2, byte b3) {
-    byte* c = asm_x64_get_cur_to_write_bytes(as, 3);
+    byte *c = asm_x64_get_cur_to_write_bytes(as, 3);
     if (c != NULL) {
         c[0] = b1;
         c[1] = b2;
@@ -147,7 +147,7 @@ STATIC void asm_x64_write_byte_3(asm_x64_t *as, byte b1, byte b2, byte b3) {
 }
 
 STATIC void asm_x64_write_word32(asm_x64_t *as, int w32) {
-    byte* c = asm_x64_get_cur_to_write_bytes(as, 4);
+    byte *c = asm_x64_get_cur_to_write_bytes(as, 4);
     if (c != NULL) {
         c[0] = IMM32_L0(w32);
         c[1] = IMM32_L1(w32);
@@ -157,7 +157,7 @@ STATIC void asm_x64_write_word32(asm_x64_t *as, int w32) {
 }
 
 STATIC void asm_x64_write_word64(asm_x64_t *as, int64_t w64) {
-    byte* c = asm_x64_get_cur_to_write_bytes(as, 8);
+    byte *c = asm_x64_get_cur_to_write_bytes(as, 8);
     if (c != NULL) {
         c[0] = IMM32_L0(w64);
         c[1] = IMM32_L1(w64);
@@ -378,11 +378,11 @@ void asm_x64_xor_r64_r64(asm_x64_t *as, int dest_r64, int src_r64) {
     asm_x64_generic_r64_r64(as, dest_r64, src_r64, OPCODE_XOR_R64_TO_RM64);
 }
 
-void asm_x64_shl_r64_cl(asm_x64_t* as, int dest_r64) {
+void asm_x64_shl_r64_cl(asm_x64_t *as, int dest_r64) {
     asm_x64_generic_r64_r64(as, dest_r64, 4, OPCODE_SHL_RM64_CL);
 }
 
-void asm_x64_sar_r64_cl(asm_x64_t* as, int dest_r64) {
+void asm_x64_sar_r64_cl(asm_x64_t *as, int dest_r64) {
     asm_x64_generic_r64_r64(as, dest_r64, 7, OPCODE_SAR_RM64_CL);
 }
 
@@ -500,7 +500,7 @@ void asm_x64_jmp_label(asm_x64_t *as, mp_uint_t label) {
         }
     } else {
         // is a forwards jump, so need to assume it's large
-        large_jump:
+    large_jump:
         rel -= 5;
         asm_x64_write_byte_1(as, OPCODE_JMP_REL32);
         asm_x64_write_word32(as, rel);
@@ -522,7 +522,7 @@ void asm_x64_jcc_label(asm_x64_t *as, int jcc_type, mp_uint_t label) {
         }
     } else {
         // is a forwards jump, so need to assume it's large
-        large_jump:
+    large_jump:
         rel -= 6;
         asm_x64_write_byte_2(as, OPCODE_JCC_REL32_A, OPCODE_JCC_REL32_B | jcc_type);
         asm_x64_write_word32(as, rel);
diff --git a/py/asmx64.h b/py/asmx64.h
index d3761b78f3399..28b1bd255fd21 100644
--- a/py/asmx64.h
+++ b/py/asmx64.h
@@ -79,12 +79,12 @@ static inline void asm_x64_end_pass(asm_x64_t *as) {
     (void)as;
 }
 
-void asm_x64_nop(asm_x64_t* as);
-void asm_x64_push_r64(asm_x64_t* as, int src_r64);
-void asm_x64_pop_r64(asm_x64_t* as, int dest_r64);
-void asm_x64_mov_r64_r64(asm_x64_t* as, int dest_r64, int src_r64);
+void asm_x64_nop(asm_x64_t *as);
+void asm_x64_push_r64(asm_x64_t *as, int src_r64);
+void asm_x64_pop_r64(asm_x64_t *as, int dest_r64);
+void asm_x64_mov_r64_r64(asm_x64_t *as, int dest_r64, int src_r64);
 size_t asm_x64_mov_i32_to_r64(asm_x64_t *as, int src_i32, int dest_r64);
-void asm_x64_mov_i64_to_r64(asm_x64_t* as, int64_t src_i64, int dest_r64);
+void asm_x64_mov_i64_to_r64(asm_x64_t *as, int64_t src_i64, int dest_r64);
 void asm_x64_mov_i64_to_r64_optimised(asm_x64_t *as, int64_t src_i64, int dest_r64);
 void asm_x64_mov_r8_to_mem8(asm_x64_t *as, int src_r64, int dest_r64, int dest_disp);
 void asm_x64_mov_r16_to_mem16(asm_x64_t *as, int src_r64, int dest_r64, int dest_disp);
@@ -97,25 +97,25 @@ void asm_x64_mov_mem64_to_r64(asm_x64_t *as, int src_r64, int src_disp, int dest
 void asm_x64_and_r64_r64(asm_x64_t *as, int dest_r64, int src_r64);
 void asm_x64_or_r64_r64(asm_x64_t *as, int dest_r64, int src_r64);
 void asm_x64_xor_r64_r64(asm_x64_t *as, int dest_r64, int src_r64);
-void asm_x64_shl_r64_cl(asm_x64_t* as, int dest_r64);
-void asm_x64_sar_r64_cl(asm_x64_t* as, int dest_r64);
-void asm_x64_add_r64_r64(asm_x64_t* as, int dest_r64, int src_r64);
-void asm_x64_sub_r64_r64(asm_x64_t* as, int dest_r64, int src_r64);
-void asm_x64_mul_r64_r64(asm_x64_t* as, int dest_r64, int src_r64);
-void asm_x64_cmp_r64_with_r64(asm_x64_t* as, int src_r64_a, int src_r64_b);
-void asm_x64_test_r8_with_r8(asm_x64_t* as, int src_r64_a, int src_r64_b);
+void asm_x64_shl_r64_cl(asm_x64_t *as, int dest_r64);
+void asm_x64_sar_r64_cl(asm_x64_t *as, int dest_r64);
+void asm_x64_add_r64_r64(asm_x64_t *as, int dest_r64, int src_r64);
+void asm_x64_sub_r64_r64(asm_x64_t *as, int dest_r64, int src_r64);
+void asm_x64_mul_r64_r64(asm_x64_t *as, int dest_r64, int src_r64);
+void asm_x64_cmp_r64_with_r64(asm_x64_t *as, int src_r64_a, int src_r64_b);
+void asm_x64_test_r8_with_r8(asm_x64_t *as, int src_r64_a, int src_r64_b);
 void asm_x64_test_r64_with_r64(asm_x64_t *as, int src_r64_a, int src_r64_b);
-void asm_x64_setcc_r8(asm_x64_t* as, int jcc_type, int dest_r8);
+void asm_x64_setcc_r8(asm_x64_t *as, int jcc_type, int dest_r8);
 void asm_x64_jmp_reg(asm_x64_t *as, int src_r64);
-void asm_x64_jmp_label(asm_x64_t* as, mp_uint_t label);
-void asm_x64_jcc_label(asm_x64_t* as, int jcc_type, mp_uint_t label);
-void asm_x64_entry(asm_x64_t* as, int num_locals);
-void asm_x64_exit(asm_x64_t* as);
-void asm_x64_mov_local_to_r64(asm_x64_t* as, int src_local_num, int dest_r64);
-void asm_x64_mov_r64_to_local(asm_x64_t* as, int src_r64, int dest_local_num);
-void asm_x64_mov_local_addr_to_r64(asm_x64_t* as, int local_num, int dest_r64);
+void asm_x64_jmp_label(asm_x64_t *as, mp_uint_t label);
+void asm_x64_jcc_label(asm_x64_t *as, int jcc_type, mp_uint_t label);
+void asm_x64_entry(asm_x64_t *as, int num_locals);
+void asm_x64_exit(asm_x64_t *as);
+void asm_x64_mov_local_to_r64(asm_x64_t *as, int src_local_num, int dest_r64);
+void asm_x64_mov_r64_to_local(asm_x64_t *as, int src_r64, int dest_local_num);
+void asm_x64_mov_local_addr_to_r64(asm_x64_t *as, int local_num, int dest_r64);
 void asm_x64_mov_reg_pcrel(asm_x64_t *as, int dest_r64, mp_uint_t label);
-void asm_x64_call_ind(asm_x64_t* as, size_t fun_id, int temp_r32);
+void asm_x64_call_ind(asm_x64_t *as, size_t fun_id, int temp_r32);
 
 // Holds a pointer to mp_fun_table
 #define ASM_X64_REG_FUN_TABLE ASM_X64_REG_RBP
diff --git a/py/asmx86.c b/py/asmx86.c
index 23160c9c20026..96de372aec0c2 100644
--- a/py/asmx86.c
+++ b/py/asmx86.c
@@ -41,13 +41,13 @@
 
 #define OPCODE_NOP               (0x90)
 #define OPCODE_PUSH_R32          (0x50)
-//#define OPCODE_PUSH_I32          (0x68)
-//#define OPCODE_PUSH_M32          (0xff) /* /6 */
+// #define OPCODE_PUSH_I32          (0x68)
+// #define OPCODE_PUSH_M32          (0xff) /* /6 */
 #define OPCODE_POP_R32           (0x58)
 #define OPCODE_RET               (0xc3)
-//#define OPCODE_MOV_I8_TO_R8      (0xb0) /* +rb */
+// #define OPCODE_MOV_I8_TO_R8      (0xb0) /* +rb */
 #define OPCODE_MOV_I32_TO_R32    (0xb8)
-//#define OPCODE_MOV_I32_TO_RM32   (0xc7)
+// #define OPCODE_MOV_I32_TO_RM32   (0xc7)
 #define OPCODE_MOV_R8_TO_RM8     (0x88) /* /r */
 #define OPCODE_MOV_R32_TO_RM32   (0x89) /* /r */
 #define OPCODE_MOV_RM32_TO_R32   (0x8b) /* /r */
@@ -63,15 +63,15 @@
 #define OPCODE_SUB_R32_FROM_RM32 (0x29)
 #define OPCODE_SUB_I32_FROM_RM32 (0x81) /* /5 */
 #define OPCODE_SUB_I8_FROM_RM32  (0x83) /* /5 */
-//#define OPCODE_SHL_RM32_BY_I8    (0xc1) /* /4 */
-//#define OPCODE_SHR_RM32_BY_I8    (0xc1) /* /5 */
-//#define OPCODE_SAR_RM32_BY_I8    (0xc1) /* /7 */
+// #define OPCODE_SHL_RM32_BY_I8    (0xc1) /* /4 */
+// #define OPCODE_SHR_RM32_BY_I8    (0xc1) /* /5 */
+// #define OPCODE_SAR_RM32_BY_I8    (0xc1) /* /7 */
 #define OPCODE_SHL_RM32_CL       (0xd3) /* /4 */
 #define OPCODE_SAR_RM32_CL       (0xd3) /* /7 */
-//#define OPCODE_CMP_I32_WITH_RM32 (0x81) /* /7 */
-//#define OPCODE_CMP_I8_WITH_RM32  (0x83) /* /7 */
+// #define OPCODE_CMP_I32_WITH_RM32 (0x81) /* /7 */
+// #define OPCODE_CMP_I8_WITH_RM32  (0x83) /* /7 */
 #define OPCODE_CMP_R32_WITH_RM32 (0x39)
-//#define OPCODE_CMP_RM32_WITH_R32 (0x3b)
+// #define OPCODE_CMP_RM32_WITH_R32 (0x3b)
 #define OPCODE_TEST_R8_WITH_RM8  (0x84) /* /r */
 #define OPCODE_TEST_R32_WITH_RM32 (0x85) /* /r */
 #define OPCODE_JMP_REL8          (0xeb)
@@ -103,14 +103,14 @@
 #define SIGNED_FIT8(x) (((x) & 0xffffff80) == 0) || (((x) & 0xffffff80) == 0xffffff80)
 
 STATIC void asm_x86_write_byte_1(asm_x86_t *as, byte b1) {
-    byte* c = mp_asm_base_get_cur_to_write_bytes(&as->base, 1);
+    byte *c = mp_asm_base_get_cur_to_write_bytes(&as->base, 1);
     if (c != NULL) {
         c[0] = b1;
     }
 }
 
 STATIC void asm_x86_write_byte_2(asm_x86_t *as, byte b1, byte b2) {
-    byte* c = mp_asm_base_get_cur_to_write_bytes(&as->base, 2);
+    byte *c = mp_asm_base_get_cur_to_write_bytes(&as->base, 2);
     if (c != NULL) {
         c[0] = b1;
         c[1] = b2;
@@ -118,7 +118,7 @@ STATIC void asm_x86_write_byte_2(asm_x86_t *as, byte b1, byte b2) {
 }
 
 STATIC void asm_x86_write_byte_3(asm_x86_t *as, byte b1, byte b2, byte b3) {
-    byte* c = mp_asm_base_get_cur_to_write_bytes(&as->base, 3);
+    byte *c = mp_asm_base_get_cur_to_write_bytes(&as->base, 3);
     if (c != NULL) {
         c[0] = b1;
         c[1] = b2;
@@ -127,7 +127,7 @@ STATIC void asm_x86_write_byte_3(asm_x86_t *as, byte b1, byte b2, byte b3) {
 }
 
 STATIC void asm_x86_write_word32(asm_x86_t *as, int w32) {
-    byte* c = mp_asm_base_get_cur_to_write_bytes(&as->base, 4);
+    byte *c = mp_asm_base_get_cur_to_write_bytes(&as->base, 4);
     if (c != NULL) {
         c[0] = IMM32_L0(w32);
         c[1] = IMM32_L1(w32);
@@ -255,11 +255,11 @@ void asm_x86_xor_r32_r32(asm_x86_t *as, int dest_r32, int src_r32) {
     asm_x86_generic_r32_r32(as, dest_r32, src_r32, OPCODE_XOR_R32_TO_RM32);
 }
 
-void asm_x86_shl_r32_cl(asm_x86_t* as, int dest_r32) {
+void asm_x86_shl_r32_cl(asm_x86_t *as, int dest_r32) {
     asm_x86_generic_r32_r32(as, dest_r32, 4, OPCODE_SHL_RM32_CL);
 }
 
-void asm_x86_sar_r32_cl(asm_x86_t* as, int dest_r32) {
+void asm_x86_sar_r32_cl(asm_x86_t *as, int dest_r32) {
     asm_x86_generic_r32_r32(as, dest_r32, 7, OPCODE_SAR_RM32_CL);
 }
 
@@ -368,7 +368,7 @@ void asm_x86_jmp_label(asm_x86_t *as, mp_uint_t label) {
         }
     } else {
         // is a forwards jump, so need to assume it's large
-        large_jump:
+    large_jump:
         rel -= 5;
         asm_x86_write_byte_1(as, OPCODE_JMP_REL32);
         asm_x86_write_word32(as, rel);
@@ -390,7 +390,7 @@ void asm_x86_jcc_label(asm_x86_t *as, mp_uint_t jcc_type, mp_uint_t label) {
         }
     } else {
         // is a forwards jump, so need to assume it's large
-        large_jump:
+    large_jump:
         rel -= 6;
         asm_x86_write_byte_2(as, OPCODE_JCC_REL32_A, OPCODE_JCC_REL32_B | jcc_type);
         asm_x86_write_word32(as, rel);
@@ -403,7 +403,7 @@ void asm_x86_entry(asm_x86_t *as, int num_locals) {
     asm_x86_push_r32(as, ASM_X86_REG_EBX);
     asm_x86_push_r32(as, ASM_X86_REG_ESI);
     asm_x86_push_r32(as, ASM_X86_REG_EDI);
-    num_locals |= 1; // make it odd so stack is aligned on 16 byte boundary
+    num_locals |= 3; // make it odd so stack is aligned on 16 byte boundary
     asm_x86_sub_r32_i32(as, ASM_X86_REG_ESP, num_locals * WORD_SIZE);
     as->num_locals = num_locals;
 }
@@ -488,8 +488,7 @@ void asm_x86_push_local(asm_x86_t *as, int local_num) {
     asm_x86_push_disp(as, ASM_X86_REG_ESP, asm_x86_local_offset_from_esp(as, local_num));
 }
 
-void asm_x86_push_local_addr(asm_x86_t *as, int local_num, int temp_r32)
-{
+void asm_x86_push_local_addr(asm_x86_t *as, int local_num, int temp_r32) {
     asm_x86_mov_r32_r32(as, temp_r32, ASM_X86_REG_ESP);
     asm_x86_add_i32_to_r32(as, asm_x86_local_offset_from_esp(as, local_num), temp_r32);
     asm_x86_push_r32(as, temp_r32);
@@ -497,11 +496,14 @@ void asm_x86_push_local_addr(asm_x86_t *as, int local_num, int temp_r32)
 #endif
 
 void asm_x86_call_ind(asm_x86_t *as, size_t fun_id, mp_uint_t n_args, int temp_r32) {
-    // TODO align stack on 16-byte boundary before the call
-    assert(n_args <= 5);
-    if (n_args > 4) {
-        asm_x86_push_r32(as, ASM_X86_REG_ARG_5);
+    assert(n_args <= 4);
+
+    // Align stack on 16-byte boundary during the call
+    unsigned int align = ((n_args + 3) & ~3) - n_args;
+    if (align) {
+        asm_x86_sub_r32_i32(as, ASM_X86_REG_ESP, align * WORD_SIZE);
     }
+
     if (n_args > 3) {
         asm_x86_push_r32(as, ASM_X86_REG_ARG_4);
     }
@@ -521,7 +523,7 @@ void asm_x86_call_ind(asm_x86_t *as, size_t fun_id, mp_uint_t n_args, int temp_r
 
     // the caller must clean up the stack
     if (n_args > 0) {
-        asm_x86_add_i32_to_r32(as, WORD_SIZE * n_args, ASM_X86_REG_ESP);
+        asm_x86_add_i32_to_r32(as, (n_args + align) * WORD_SIZE, ASM_X86_REG_ESP);
     }
 }
 
diff --git a/py/asmx86.h b/py/asmx86.h
index 7ba677b2c2c3e..4855cd7ee4e8a 100644
--- a/py/asmx86.h
+++ b/py/asmx86.h
@@ -60,7 +60,6 @@
 #define ASM_X86_REG_ARG_2 ASM_X86_REG_ECX
 #define ASM_X86_REG_ARG_3 ASM_X86_REG_EDX
 #define ASM_X86_REG_ARG_4 ASM_X86_REG_EBX
-#define ASM_X86_REG_ARG_5 ASM_X86_REG_ESI
 
 // condition codes, used for jcc and setcc (despite their j-name!)
 #define ASM_X86_CC_JB  (0x2) // below, unsigned
@@ -82,7 +81,7 @@ static inline void asm_x86_end_pass(asm_x86_t *as) {
     (void)as;
 }
 
-void asm_x86_mov_r32_r32(asm_x86_t* as, int dest_r32, int src_r32);
+void asm_x86_mov_r32_r32(asm_x86_t *as, int dest_r32, int src_r32);
 size_t asm_x86_mov_i32_to_r32(asm_x86_t *as, int32_t src_i32, int dest_r32);
 void asm_x86_mov_r8_to_mem8(asm_x86_t *as, int src_r32, int dest_r32, int dest_disp);
 void asm_x86_mov_r16_to_mem16(asm_x86_t *as, int src_r32, int dest_r32, int dest_disp);
@@ -93,26 +92,26 @@ void asm_x86_mov_mem32_to_r32(asm_x86_t *as, int src_r32, int src_disp, int dest
 void asm_x86_and_r32_r32(asm_x86_t *as, int dest_r32, int src_r32);
 void asm_x86_or_r32_r32(asm_x86_t *as, int dest_r32, int src_r32);
 void asm_x86_xor_r32_r32(asm_x86_t *as, int dest_r32, int src_r32);
-void asm_x86_shl_r32_cl(asm_x86_t* as, int dest_r32);
-void asm_x86_sar_r32_cl(asm_x86_t* as, int dest_r32);
-void asm_x86_add_r32_r32(asm_x86_t* as, int dest_r32, int src_r32);
-void asm_x86_sub_r32_r32(asm_x86_t* as, int dest_r32, int src_r32);
-void asm_x86_mul_r32_r32(asm_x86_t* as, int dest_r32, int src_r32);
-void asm_x86_cmp_r32_with_r32(asm_x86_t* as, int src_r32_a, int src_r32_b);
-void asm_x86_test_r8_with_r8(asm_x86_t* as, int src_r32_a, int src_r32_b);
-void asm_x86_test_r32_with_r32(asm_x86_t* as, int src_r32_a, int src_r32_b);
-void asm_x86_setcc_r8(asm_x86_t* as, mp_uint_t jcc_type, int dest_r8);
+void asm_x86_shl_r32_cl(asm_x86_t *as, int dest_r32);
+void asm_x86_sar_r32_cl(asm_x86_t *as, int dest_r32);
+void asm_x86_add_r32_r32(asm_x86_t *as, int dest_r32, int src_r32);
+void asm_x86_sub_r32_r32(asm_x86_t *as, int dest_r32, int src_r32);
+void asm_x86_mul_r32_r32(asm_x86_t *as, int dest_r32, int src_r32);
+void asm_x86_cmp_r32_with_r32(asm_x86_t *as, int src_r32_a, int src_r32_b);
+void asm_x86_test_r8_with_r8(asm_x86_t *as, int src_r32_a, int src_r32_b);
+void asm_x86_test_r32_with_r32(asm_x86_t *as, int src_r32_a, int src_r32_b);
+void asm_x86_setcc_r8(asm_x86_t *as, mp_uint_t jcc_type, int dest_r8);
 void asm_x86_jmp_reg(asm_x86_t *as, int src_r86);
-void asm_x86_jmp_label(asm_x86_t* as, mp_uint_t label);
-void asm_x86_jcc_label(asm_x86_t* as, mp_uint_t jcc_type, mp_uint_t label);
-void asm_x86_entry(asm_x86_t* as, int num_locals);
-void asm_x86_exit(asm_x86_t* as);
+void asm_x86_jmp_label(asm_x86_t *as, mp_uint_t label);
+void asm_x86_jcc_label(asm_x86_t *as, mp_uint_t jcc_type, mp_uint_t label);
+void asm_x86_entry(asm_x86_t *as, int num_locals);
+void asm_x86_exit(asm_x86_t *as);
 void asm_x86_mov_arg_to_r32(asm_x86_t *as, int src_arg_num, int dest_r32);
-void asm_x86_mov_local_to_r32(asm_x86_t* as, int src_local_num, int dest_r32);
-void asm_x86_mov_r32_to_local(asm_x86_t* as, int src_r32, int dest_local_num);
-void asm_x86_mov_local_addr_to_r32(asm_x86_t* as, int local_num, int dest_r32);
+void asm_x86_mov_local_to_r32(asm_x86_t *as, int src_local_num, int dest_r32);
+void asm_x86_mov_r32_to_local(asm_x86_t *as, int src_r32, int dest_local_num);
+void asm_x86_mov_local_addr_to_r32(asm_x86_t *as, int local_num, int dest_r32);
 void asm_x86_mov_reg_pcrel(asm_x86_t *as, int dest_r64, mp_uint_t label);
-void asm_x86_call_ind(asm_x86_t* as, size_t fun_id, mp_uint_t n_args, int temp_r32);
+void asm_x86_call_ind(asm_x86_t *as, size_t fun_id, mp_uint_t n_args, int temp_r32);
 
 // Holds a pointer to mp_fun_table
 #define ASM_X86_REG_FUN_TABLE ASM_X86_REG_EBP
@@ -129,7 +128,6 @@ void asm_x86_call_ind(asm_x86_t* as, size_t fun_id, mp_uint_t n_args, int temp_r
 #define REG_ARG_2 ASM_X86_REG_ARG_2
 #define REG_ARG_3 ASM_X86_REG_ARG_3
 #define REG_ARG_4 ASM_X86_REG_ARG_4
-#define REG_ARG_5 ASM_X86_REG_ARG_5
 
 // caller-save, so can be used as temporaries
 #define REG_TEMP0 ASM_X86_REG_EAX
diff --git a/py/asmxtensa.c b/py/asmxtensa.c
index a269e5e7fc0d1..0956d50f3ef15 100644
--- a/py/asmxtensa.c
+++ b/py/asmxtensa.c
@@ -30,14 +30,13 @@
 #include "py/mpconfig.h"
 
 // wrapper around everything in this file
-#if MICROPY_EMIT_XTENSA || MICROPY_EMIT_INLINE_XTENSA
+#if MICROPY_EMIT_XTENSA || MICROPY_EMIT_INLINE_XTENSA || MICROPY_EMIT_XTENSAWIN
 
 #include "py/asmxtensa.h"
 
 #define WORD_SIZE (4)
 #define SIGNED_FIT8(x) ((((x) & 0xffffff80) == 0) || (((x) & 0xffffff80) == 0xffffff80))
 #define SIGNED_FIT12(x) ((((x) & 0xfffff800) == 0) || (((x) & 0xfffff800) == 0xfffff800))
-#define NUM_REGS_SAVED (5)
 
 void asm_xtensa_end_pass(asm_xtensa_t *as) {
     as->num_const = as->cur_const;
@@ -66,10 +65,10 @@ void asm_xtensa_entry(asm_xtensa_t *as, int num_locals) {
     // jump over the constants
     asm_xtensa_op_j(as, as->num_const * WORD_SIZE + 4 - 4);
     mp_asm_base_get_cur_to_write_bytes(&as->base, 1); // padding/alignment byte
-    as->const_table = (uint32_t*)mp_asm_base_get_cur_to_write_bytes(&as->base, as->num_const * 4);
+    as->const_table = (uint32_t *)mp_asm_base_get_cur_to_write_bytes(&as->base, as->num_const * 4);
 
     // adjust the stack-pointer to store a0, a12, a13, a14, a15 and locals, 16-byte aligned
-    as->stack_adjust = (((NUM_REGS_SAVED + num_locals) * WORD_SIZE) + 15) & ~15;
+    as->stack_adjust = (((ASM_XTENSA_NUM_REGS_SAVED + num_locals) * WORD_SIZE) + 15) & ~15;
     if (SIGNED_FIT8(-as->stack_adjust)) {
         asm_xtensa_op_addi(as, ASM_XTENSA_REG_A1, ASM_XTENSA_REG_A1, -as->stack_adjust);
     } else {
@@ -79,14 +78,14 @@ void asm_xtensa_entry(asm_xtensa_t *as, int num_locals) {
 
     // save return value (a0) and callee-save registers (a12, a13, a14, a15)
     asm_xtensa_op_s32i_n(as, ASM_XTENSA_REG_A0, ASM_XTENSA_REG_A1, 0);
-    for (int i = 1; i < NUM_REGS_SAVED; ++i) {
+    for (int i = 1; i < ASM_XTENSA_NUM_REGS_SAVED; ++i) {
         asm_xtensa_op_s32i_n(as, ASM_XTENSA_REG_A11 + i, ASM_XTENSA_REG_A1, i);
     }
 }
 
 void asm_xtensa_exit(asm_xtensa_t *as) {
     // restore registers
-    for (int i = NUM_REGS_SAVED - 1; i >= 1; --i) {
+    for (int i = ASM_XTENSA_NUM_REGS_SAVED - 1; i >= 1; --i) {
         asm_xtensa_op_l32i_n(as, ASM_XTENSA_REG_A11 + i, ASM_XTENSA_REG_A1, i);
     }
     asm_xtensa_op_l32i_n(as, ASM_XTENSA_REG_A0, ASM_XTENSA_REG_A1, 0);
@@ -102,6 +101,22 @@ void asm_xtensa_exit(asm_xtensa_t *as) {
     asm_xtensa_op_ret_n(as);
 }
 
+void asm_xtensa_entry_win(asm_xtensa_t *as, int num_locals) {
+    // jump over the constants
+    asm_xtensa_op_j(as, as->num_const * WORD_SIZE + 4 - 4);
+    mp_asm_base_get_cur_to_write_bytes(&as->base, 1); // padding/alignment byte
+    as->const_table = (uint32_t *)mp_asm_base_get_cur_to_write_bytes(&as->base, as->num_const * 4);
+
+    as->stack_adjust = 32 + ((((ASM_XTENSA_NUM_REGS_SAVED_WIN + num_locals) * WORD_SIZE) + 15) & ~15);
+    asm_xtensa_op_entry(as, ASM_XTENSA_REG_A1, as->stack_adjust);
+    asm_xtensa_op_s32i_n(as, ASM_XTENSA_REG_A0, ASM_XTENSA_REG_A1, 0);
+}
+
+void asm_xtensa_exit_win(asm_xtensa_t *as) {
+    asm_xtensa_op_l32i_n(as, ASM_XTENSA_REG_A0, ASM_XTENSA_REG_A1, 0);
+    asm_xtensa_op_retw_n(as);
+}
+
 STATIC uint32_t get_label_dest(asm_xtensa_t *as, uint label) {
     assert(label < as->base.max_num_labels);
     return as->base.label_offsets[label];
@@ -158,7 +173,7 @@ void asm_xtensa_setcc_reg_reg_reg(asm_xtensa_t *as, uint cond, uint reg_dest, ui
 
 size_t asm_xtensa_mov_reg_i32(asm_xtensa_t *as, uint reg_dest, uint32_t i32) {
     // load the constant
-    uint32_t const_table_offset = (uint8_t*)as->const_table - as->base.code_base;
+    uint32_t const_table_offset = (uint8_t *)as->const_table - as->base.code_base;
     size_t loc = const_table_offset + as->cur_const * WORD_SIZE;
     asm_xtensa_op_l32r(as, reg_dest, as->base.code_offset, loc);
     // store the constant in the table
@@ -178,15 +193,15 @@ void asm_xtensa_mov_reg_i32_optimised(asm_xtensa_t *as, uint reg_dest, uint32_t
 }
 
 void asm_xtensa_mov_local_reg(asm_xtensa_t *as, int local_num, uint reg_src) {
-    asm_xtensa_op_s32i(as, reg_src, ASM_XTENSA_REG_A1, NUM_REGS_SAVED + local_num);
+    asm_xtensa_op_s32i(as, reg_src, ASM_XTENSA_REG_A1, local_num);
 }
 
 void asm_xtensa_mov_reg_local(asm_xtensa_t *as, uint reg_dest, int local_num) {
-    asm_xtensa_op_l32i(as, reg_dest, ASM_XTENSA_REG_A1, NUM_REGS_SAVED + local_num);
+    asm_xtensa_op_l32i(as, reg_dest, ASM_XTENSA_REG_A1, local_num);
 }
 
 void asm_xtensa_mov_reg_local_addr(asm_xtensa_t *as, uint reg_dest, int local_num) {
-    uint off = (NUM_REGS_SAVED + local_num) * WORD_SIZE;
+    uint off = local_num * WORD_SIZE;
     if (SIGNED_FIT8(off)) {
         asm_xtensa_op_addi(as, reg_dest, ASM_XTENSA_REG_A1, off);
     } else {
@@ -226,4 +241,13 @@ void asm_xtensa_call_ind(asm_xtensa_t *as, uint idx) {
     asm_xtensa_op_callx0(as, ASM_XTENSA_REG_A0);
 }
 
-#endif // MICROPY_EMIT_XTENSA || MICROPY_EMIT_INLINE_XTENSA
+void asm_xtensa_call_ind_win(asm_xtensa_t *as, uint idx) {
+    if (idx < 16) {
+        asm_xtensa_op_l32i_n(as, ASM_XTENSA_REG_A8, ASM_XTENSA_REG_FUN_TABLE_WIN, idx);
+    } else {
+        asm_xtensa_op_l32i(as, ASM_XTENSA_REG_A8, ASM_XTENSA_REG_FUN_TABLE_WIN, idx);
+    }
+    asm_xtensa_op_callx8(as, ASM_XTENSA_REG_A8);
+}
+
+#endif // MICROPY_EMIT_XTENSA || MICROPY_EMIT_INLINE_XTENSA || MICROPY_EMIT_XTENSAWIN
diff --git a/py/asmxtensa.h b/py/asmxtensa.h
index d95af14a5dabb..5eb40daf7887c 100644
--- a/py/asmxtensa.h
+++ b/py/asmxtensa.h
@@ -37,6 +37,16 @@
 // callee save: a1, a12, a13, a14, a15
 // caller save: a3
 
+// With windowed registers, size 8:
+// - a0: return PC
+// - a1: stack pointer, full descending, aligned to 16 bytes
+// - a2-a7: incoming args, and essentially callee save
+// - a2: return value
+// - a8-a15: caller save temporaries
+// - a10-a15: input args to called function
+// - a10: return value of called function
+// note: a0-a7 are saved automatically via window shift of called function
+
 #define ASM_XTENSA_REG_A0  (0)
 #define ASM_XTENSA_REG_A1  (1)
 #define ASM_XTENSA_REG_A2  (2)
@@ -96,6 +106,10 @@
 #define ASM_XTENSA_ENCODE_RI7(op0, s, imm7) \
     ((((imm7) & 0xf) << 12) | ((s) << 8) | ((imm7) & 0x70) | (op0))
 
+// Number of registers saved on the stack upon entry to function
+#define ASM_XTENSA_NUM_REGS_SAVED (5)
+#define ASM_XTENSA_NUM_REGS_SAVED_WIN (1)
+
 typedef struct _asm_xtensa_t {
     mp_asm_base_t base;
     uint32_t cur_const;
@@ -109,11 +123,18 @@ void asm_xtensa_end_pass(asm_xtensa_t *as);
 void asm_xtensa_entry(asm_xtensa_t *as, int num_locals);
 void asm_xtensa_exit(asm_xtensa_t *as);
 
+void asm_xtensa_entry_win(asm_xtensa_t *as, int num_locals);
+void asm_xtensa_exit_win(asm_xtensa_t *as);
+
 void asm_xtensa_op16(asm_xtensa_t *as, uint16_t op);
 void asm_xtensa_op24(asm_xtensa_t *as, uint32_t op);
 
 // raw instructions
 
+static inline void asm_xtensa_op_entry(asm_xtensa_t *as, uint reg_src, int32_t num_bytes) {
+    asm_xtensa_op24(as, ASM_XTENSA_ENCODE_BRI12(6, reg_src, 0, 3, (num_bytes / 8) & 0xfff));
+}
+
 static inline void asm_xtensa_op_add_n(asm_xtensa_t *as, uint reg_dest, uint reg_src_a, uint reg_src_b) {
     asm_xtensa_op16(as, ASM_XTENSA_ENCODE_RRRN(10, reg_dest, reg_src_a, reg_src_b));
 }
@@ -142,6 +163,10 @@ static inline void asm_xtensa_op_callx0(asm_xtensa_t *as, uint reg) {
     asm_xtensa_op24(as, ASM_XTENSA_ENCODE_CALLX(0, 0, 0, 0, reg, 3, 0));
 }
 
+static inline void asm_xtensa_op_callx8(asm_xtensa_t *as, uint reg) {
+    asm_xtensa_op24(as, ASM_XTENSA_ENCODE_CALLX(0, 0, 0, 0, reg, 3, 2));
+}
+
 static inline void asm_xtensa_op_j(asm_xtensa_t *as, int32_t rel18) {
     asm_xtensa_op24(as, ASM_XTENSA_ENCODE_CALL(6, 0, rel18 & 0x3ffff));
 }
@@ -194,6 +219,10 @@ static inline void asm_xtensa_op_ret_n(asm_xtensa_t *as) {
     asm_xtensa_op16(as, ASM_XTENSA_ENCODE_RRRN(13, 15, 0, 0));
 }
 
+static inline void asm_xtensa_op_retw_n(asm_xtensa_t *as) {
+    asm_xtensa_op16(as, ASM_XTENSA_ENCODE_RRRN(13, 15, 0, 1));
+}
+
 static inline void asm_xtensa_op_s8i(asm_xtensa_t *as, uint reg_src, uint reg_base, uint byte_offset) {
     asm_xtensa_op24(as, ASM_XTENSA_ENCODE_RRI8(2, 4, reg_base, reg_src, byte_offset & 0xff));
 }
@@ -246,9 +275,11 @@ void asm_xtensa_mov_reg_local(asm_xtensa_t *as, uint reg_dest, int local_num);
 void asm_xtensa_mov_reg_local_addr(asm_xtensa_t *as, uint reg_dest, int local_num);
 void asm_xtensa_mov_reg_pcrel(asm_xtensa_t *as, uint reg_dest, uint label);
 void asm_xtensa_call_ind(asm_xtensa_t *as, uint idx);
+void asm_xtensa_call_ind_win(asm_xtensa_t *as, uint idx);
 
 // Holds a pointer to mp_fun_table
 #define ASM_XTENSA_REG_FUN_TABLE ASM_XTENSA_REG_A15
+#define ASM_XTENSA_REG_FUN_TABLE_WIN ASM_XTENSA_REG_A7
 
 #if GENERIC_ASM_API
 
@@ -257,6 +288,9 @@ void asm_xtensa_call_ind(asm_xtensa_t *as, uint idx);
 
 #define ASM_WORD_SIZE (4)
 
+#if !GENERIC_ASM_API_WIN
+// Configuration for non-windowed calls
+
 #define REG_RET ASM_XTENSA_REG_A2
 #define REG_ARG_1 ASM_XTENSA_REG_A2
 #define REG_ARG_2 ASM_XTENSA_REG_A3
@@ -273,12 +307,47 @@ void asm_xtensa_call_ind(asm_xtensa_t *as, uint idx);
 #define REG_LOCAL_3 ASM_XTENSA_REG_A14
 #define REG_LOCAL_NUM (3)
 
+#define ASM_NUM_REGS_SAVED ASM_XTENSA_NUM_REGS_SAVED
 #define REG_FUN_TABLE ASM_XTENSA_REG_FUN_TABLE
 
+#define ASM_ENTRY(as, nlocal)   asm_xtensa_entry((as), (nlocal))
+#define ASM_EXIT(as)            asm_xtensa_exit((as))
+#define ASM_CALL_IND(as, idx)   asm_xtensa_call_ind((as), (idx))
+
+#else
+// Configuration for windowed calls with window size 8
+
+#define REG_PARENT_RET ASM_XTENSA_REG_A2
+#define REG_PARENT_ARG_1 ASM_XTENSA_REG_A2
+#define REG_PARENT_ARG_2 ASM_XTENSA_REG_A3
+#define REG_PARENT_ARG_3 ASM_XTENSA_REG_A4
+#define REG_PARENT_ARG_4 ASM_XTENSA_REG_A5
+#define REG_RET ASM_XTENSA_REG_A10
+#define REG_ARG_1 ASM_XTENSA_REG_A10
+#define REG_ARG_2 ASM_XTENSA_REG_A11
+#define REG_ARG_3 ASM_XTENSA_REG_A12
+#define REG_ARG_4 ASM_XTENSA_REG_A13
+
+#define REG_TEMP0 ASM_XTENSA_REG_A10
+#define REG_TEMP1 ASM_XTENSA_REG_A11
+#define REG_TEMP2 ASM_XTENSA_REG_A12
+
+#define REG_LOCAL_1 ASM_XTENSA_REG_A4
+#define REG_LOCAL_2 ASM_XTENSA_REG_A5
+#define REG_LOCAL_3 ASM_XTENSA_REG_A6
+#define REG_LOCAL_NUM (3)
+
+#define ASM_NUM_REGS_SAVED ASM_XTENSA_NUM_REGS_SAVED_WIN
+#define REG_FUN_TABLE ASM_XTENSA_REG_FUN_TABLE_WIN
+
+#define ASM_ENTRY(as, nlocal)   asm_xtensa_entry_win((as), (nlocal))
+#define ASM_EXIT(as)            asm_xtensa_exit_win((as))
+#define ASM_CALL_IND(as, idx)   asm_xtensa_call_ind_win((as), (idx))
+
+#endif
+
 #define ASM_T               asm_xtensa_t
 #define ASM_END_PASS        asm_xtensa_end_pass
-#define ASM_ENTRY           asm_xtensa_entry
-#define ASM_EXIT            asm_xtensa_exit
 
 #define ASM_JUMP            asm_xtensa_j_label
 #define ASM_JUMP_IF_REG_ZERO(as, reg, label, bool_test) \
@@ -288,15 +357,14 @@ void asm_xtensa_call_ind(asm_xtensa_t *as, uint idx);
 #define ASM_JUMP_IF_REG_EQ(as, reg1, reg2, label) \
     asm_xtensa_bcc_reg_reg_label(as, ASM_XTENSA_CC_EQ, reg1, reg2, label)
 #define ASM_JUMP_REG(as, reg) asm_xtensa_op_jx((as), (reg))
-#define ASM_CALL_IND(as, idx) asm_xtensa_call_ind((as), (idx))
 
-#define ASM_MOV_LOCAL_REG(as, local_num, reg_src) asm_xtensa_mov_local_reg((as), (local_num), (reg_src))
+#define ASM_MOV_LOCAL_REG(as, local_num, reg_src) asm_xtensa_mov_local_reg((as), ASM_NUM_REGS_SAVED + (local_num), (reg_src))
 #define ASM_MOV_REG_IMM(as, reg_dest, imm) asm_xtensa_mov_reg_i32_optimised((as), (reg_dest), (imm))
 #define ASM_MOV_REG_IMM_FIX_U16(as, reg_dest, imm) asm_xtensa_mov_reg_i32((as), (reg_dest), (imm))
 #define ASM_MOV_REG_IMM_FIX_WORD(as, reg_dest, imm) asm_xtensa_mov_reg_i32((as), (reg_dest), (imm))
-#define ASM_MOV_REG_LOCAL(as, reg_dest, local_num) asm_xtensa_mov_reg_local((as), (reg_dest), (local_num))
+#define ASM_MOV_REG_LOCAL(as, reg_dest, local_num) asm_xtensa_mov_reg_local((as), (reg_dest), ASM_NUM_REGS_SAVED + (local_num))
 #define ASM_MOV_REG_REG(as, reg_dest, reg_src) asm_xtensa_op_mov_n((as), (reg_dest), (reg_src))
-#define ASM_MOV_REG_LOCAL_ADDR(as, reg_dest, local_num) asm_xtensa_mov_reg_local_addr((as), (reg_dest), (local_num))
+#define ASM_MOV_REG_LOCAL_ADDR(as, reg_dest, local_num) asm_xtensa_mov_reg_local_addr((as), (reg_dest), ASM_NUM_REGS_SAVED + (local_num))
 #define ASM_MOV_REG_PCREL(as, reg_dest, label) asm_xtensa_mov_reg_pcrel((as), (reg_dest), (label))
 
 #define ASM_LSL_REG_REG(as, reg_dest, reg_shift) \
diff --git a/py/bc.c b/py/bc.c
index b178e7c202f71..34bc78fd3a588 100644
--- a/py/bc.c
+++ b/py/bc.c
@@ -40,6 +40,8 @@
 #define DEBUG_printf(...) (void)0
 #endif
 
+#if !MICROPY_PERSISTENT_CODE
+
 mp_uint_t mp_decode_uint(const byte **ptr) {
     mp_uint_t unum = 0;
     byte val;
@@ -70,22 +72,24 @@ const byte *mp_decode_uint_skip(const byte *ptr) {
     return ptr;
 }
 
+#endif
+
 STATIC NORETURN void fun_pos_args_mismatch(mp_obj_fun_bc_t *f, size_t expected, size_t given) {
-#if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
     // generic message, used also for other argument issues
     (void)f;
     (void)expected;
     (void)given;
     mp_arg_error_terse_mismatch();
-#elif MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL
+    #elif MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL
     (void)f;
-    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-        "function takes %d positional arguments but %d were given", expected, given));
-#elif MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED
-    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-        "%q() takes %d positional arguments but %d were given",
-        mp_obj_fun_get_name(MP_OBJ_FROM_PTR(f)), expected, given));
-#endif
+    mp_raise_msg_varg(&mp_type_TypeError,
+        MP_ERROR_TEXT("function takes %d positional arguments but %d were given"), expected, given);
+    #elif MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED
+    mp_raise_msg_varg(&mp_type_TypeError,
+        MP_ERROR_TEXT("%q() takes %d positional arguments but %d were given"),
+        mp_obj_fun_get_name(MP_OBJ_FROM_PTR(f)), expected, given);
+    #endif
 }
 
 #if DEBUG_PRINT
@@ -119,16 +123,22 @@ void mp_setup_code_state(mp_code_state_t *code_state, size_t n_args, size_t n_kw
     code_state->prev = NULL;
     #endif
 
-    // get params
-    size_t n_state = mp_decode_uint(&code_state->ip);
-    code_state->ip = mp_decode_uint_skip(code_state->ip); // skip n_exc_stack
-    size_t scope_flags = *code_state->ip++;
-    size_t n_pos_args = *code_state->ip++;
-    size_t n_kwonly_args = *code_state->ip++;
-    size_t n_def_pos_args = *code_state->ip++;
+    #if MICROPY_PY_SYS_SETTRACE
+    code_state->prev_state = NULL;
+    code_state->frame = NULL;
+    #endif
+
+    // Get cached n_state (rather than decode it again)
+    size_t n_state = code_state->n_state;
+
+    // Decode prelude
+    size_t n_state_unused, n_exc_stack_unused, scope_flags, n_pos_args, n_kwonly_args, n_def_pos_args;
+    MP_BC_PRELUDE_SIG_DECODE_INTO(code_state->ip, n_state_unused, n_exc_stack_unused, scope_flags, n_pos_args, n_kwonly_args, n_def_pos_args);
+    (void)n_state_unused;
+    (void)n_exc_stack_unused;
 
     code_state->sp = &code_state->state[0] - 1;
-    code_state->exc_sp = (mp_exc_stack_t*)(code_state->state + n_state) - 1;
+    code_state->exc_sp_idx = 0;
 
     // zero out the local stack to begin with
     memset(code_state->state, 0, n_state * sizeof(*code_state->state));
@@ -185,7 +195,7 @@ void mp_setup_code_state(mp_code_state_t *code_state, size_t n_args, size_t n_kw
         }
 
         // get pointer to arg_names array
-        const mp_obj_t *arg_names = (const mp_obj_t*)self->const_table;
+        const mp_obj_t *arg_names = (const mp_obj_t *)self->const_table;
 
         for (size_t i = 0; i < n_kw; i++) {
             // the keys in kwargs are expected to be qstr objects
@@ -193,8 +203,8 @@ void mp_setup_code_state(mp_code_state_t *code_state, size_t n_args, size_t n_kw
             for (size_t j = 0; j < n_pos_args + n_kwonly_args; j++) {
                 if (wanted_arg_name == arg_names[j]) {
                     if (code_state->state[n_state - 1 - j] != MP_OBJ_NULL) {
-                        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                            "function got multiple values for argument '%q'", MP_OBJ_QSTR_VALUE(wanted_arg_name)));
+                        mp_raise_msg_varg(&mp_type_TypeError,
+                            MP_ERROR_TEXT("function got multiple values for argument '%q'"), MP_OBJ_QSTR_VALUE(wanted_arg_name));
                     }
                     code_state->state[n_state - 1 - j] = kwargs[2 * i + 1];
                     goto continue2;
@@ -202,15 +212,15 @@ void mp_setup_code_state(mp_code_state_t *code_state, size_t n_args, size_t n_kw
             }
             // Didn't find name match with positional args
             if ((scope_flags & MP_SCOPE_FLAG_VARKEYWORDS) == 0) {
-                if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                    mp_raise_TypeError("unexpected keyword argument");
-                } else {
-                    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                        "unexpected keyword argument '%q'", MP_OBJ_QSTR_VALUE(wanted_arg_name)));
-                }
+                #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                mp_raise_TypeError(MP_ERROR_TEXT("unexpected keyword argument"));
+                #else
+                mp_raise_msg_varg(&mp_type_TypeError,
+                    MP_ERROR_TEXT("unexpected keyword argument '%q'"), MP_OBJ_QSTR_VALUE(wanted_arg_name));
+                #endif
             }
             mp_obj_dict_store(dict, kwargs[2 * i], kwargs[2 * i + 1]);
-continue2:;
+        continue2:;
         }
 
         DEBUG_printf("Args with kws flattened: ");
@@ -231,8 +241,8 @@ continue2:;
         // Check that all mandatory positional args are specified
         while (d < &code_state->state[n_state]) {
             if (*d++ == MP_OBJ_NULL) {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                    "function missing required positional argument #%d", &code_state->state[n_state] - d));
+                mp_raise_msg_varg(&mp_type_TypeError,
+                    MP_ERROR_TEXT("function missing required positional argument #%d"), &code_state->state[n_state] - d);
             }
         }
 
@@ -242,13 +252,13 @@ continue2:;
             if (code_state->state[n_state - 1 - n_pos_args - i] == MP_OBJ_NULL) {
                 mp_map_elem_t *elem = NULL;
                 if ((scope_flags & MP_SCOPE_FLAG_DEFKWARGS) != 0) {
-                    elem = mp_map_lookup(&((mp_obj_dict_t*)MP_OBJ_TO_PTR(self->extra_args[n_def_pos_args]))->map, arg_names[n_pos_args + i], MP_MAP_LOOKUP);
+                    elem = mp_map_lookup(&((mp_obj_dict_t *)MP_OBJ_TO_PTR(self->extra_args[n_def_pos_args]))->map, arg_names[n_pos_args + i], MP_MAP_LOOKUP);
                 }
                 if (elem != NULL) {
                     code_state->state[n_state - 1 - n_pos_args - i] = elem->value;
                 } else {
-                    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                        "function missing required keyword argument '%q'", MP_OBJ_QSTR_VALUE(arg_names[n_pos_args + i])));
+                    mp_raise_msg_varg(&mp_type_TypeError,
+                        MP_ERROR_TEXT("function missing required keyword argument '%q'"), MP_OBJ_QSTR_VALUE(arg_names[n_pos_args + i]));
                 }
             }
         }
@@ -256,26 +266,32 @@ continue2:;
     } else {
         // no keyword arguments given
         if (n_kwonly_args != 0) {
-            mp_raise_TypeError("function missing keyword-only argument");
+            mp_raise_TypeError(MP_ERROR_TEXT("function missing keyword-only argument"));
         }
         if ((scope_flags & MP_SCOPE_FLAG_VARKEYWORDS) != 0) {
             *var_pos_kw_args = mp_obj_new_dict(0);
         }
     }
 
-    // get the ip and skip argument names
+    // read the size part of the prelude
     const byte *ip = code_state->ip;
+    MP_BC_PRELUDE_SIZE_DECODE(ip);
 
     // jump over code info (source file and line-number mapping)
-    ip += mp_decode_uint_value(ip);
+    ip += n_info;
 
     // bytecode prelude: initialise closed over variables
-    size_t local_num;
-    while ((local_num = *ip++) != 255) {
+    for (; n_cell; --n_cell) {
+        size_t local_num = *ip++;
         code_state->state[n_state - 1 - local_num] =
             mp_obj_new_cell(code_state->state[n_state - 1 - local_num]);
     }
 
+    #if !MICROPY_PERSISTENT_CODE
+    // so bytecode is aligned
+    ip = MP_ALIGN(ip, sizeof(mp_uint_t));
+    #endif
+
     // now that we skipped over the prelude, set the ip for the VM
     code_state->ip = ip;
 
@@ -287,105 +303,17 @@ continue2:;
 #if MICROPY_PERSISTENT_CODE_LOAD || MICROPY_PERSISTENT_CODE_SAVE
 
 // The following table encodes the number of bytes that a specific opcode
-// takes up.  There are 3 special opcodes that always have an extra byte:
-//     MP_BC_MAKE_CLOSURE
-//     MP_BC_MAKE_CLOSURE_DEFARGS
-//     MP_BC_RAISE_VARARGS
+// takes up.  Some opcodes have an extra byte, defined by MP_BC_MASK_EXTRA_BYTE.
 // There are 4 special opcodes that have an extra byte only when
 // MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE is enabled (and they take a qstr):
 //     MP_BC_LOAD_NAME
 //     MP_BC_LOAD_GLOBAL
 //     MP_BC_LOAD_ATTR
 //     MP_BC_STORE_ATTR
-#define OC4(a, b, c, d) (a | (b << 2) | (c << 4) | (d << 6))
-#define U (0) // undefined opcode
-#define B (MP_OPCODE_BYTE) // single byte
-#define Q (MP_OPCODE_QSTR) // single byte plus 2-byte qstr
-#define V (MP_OPCODE_VAR_UINT) // single byte plus variable encoded unsigned int
-#define O (MP_OPCODE_OFFSET) // single byte plus 2-byte bytecode offset
-STATIC const byte opcode_format_table[64] = {
-    OC4(U, U, U, U), // 0x00-0x03
-    OC4(U, U, U, U), // 0x04-0x07
-    OC4(U, U, U, U), // 0x08-0x0b
-    OC4(U, U, U, U), // 0x0c-0x0f
-    OC4(B, B, B, U), // 0x10-0x13
-    OC4(V, U, Q, V), // 0x14-0x17
-    OC4(B, V, V, Q), // 0x18-0x1b
-    OC4(Q, Q, Q, Q), // 0x1c-0x1f
-    OC4(B, B, V, V), // 0x20-0x23
-    OC4(Q, Q, Q, B), // 0x24-0x27
-    OC4(V, V, Q, Q), // 0x28-0x2b
-    OC4(U, U, U, U), // 0x2c-0x2f
-    OC4(B, B, B, B), // 0x30-0x33
-    OC4(B, O, O, O), // 0x34-0x37
-    OC4(O, O, U, U), // 0x38-0x3b
-    OC4(U, O, B, O), // 0x3c-0x3f
-    OC4(O, B, B, O), // 0x40-0x43
-    OC4(O, U, O, B), // 0x44-0x47
-    OC4(U, U, U, U), // 0x48-0x4b
-    OC4(U, U, U, U), // 0x4c-0x4f
-    OC4(V, V, U, V), // 0x50-0x53
-    OC4(B, U, V, V), // 0x54-0x57
-    OC4(V, V, V, B), // 0x58-0x5b
-    OC4(B, B, B, U), // 0x5c-0x5f
-    OC4(V, V, V, V), // 0x60-0x63
-    OC4(V, V, V, V), // 0x64-0x67
-    OC4(Q, Q, B, U), // 0x68-0x6b
-    OC4(U, U, U, U), // 0x6c-0x6f
-
-    OC4(B, B, B, B), // 0x70-0x73
-    OC4(B, B, B, B), // 0x74-0x77
-    OC4(B, B, B, B), // 0x78-0x7b
-    OC4(B, B, B, B), // 0x7c-0x7f
-    OC4(B, B, B, B), // 0x80-0x83
-    OC4(B, B, B, B), // 0x84-0x87
-    OC4(B, B, B, B), // 0x88-0x8b
-    OC4(B, B, B, B), // 0x8c-0x8f
-    OC4(B, B, B, B), // 0x90-0x93
-    OC4(B, B, B, B), // 0x94-0x97
-    OC4(B, B, B, B), // 0x98-0x9b
-    OC4(B, B, B, B), // 0x9c-0x9f
-    OC4(B, B, B, B), // 0xa0-0xa3
-    OC4(B, B, B, B), // 0xa4-0xa7
-    OC4(B, B, B, B), // 0xa8-0xab
-    OC4(B, B, B, B), // 0xac-0xaf
-
-    OC4(B, B, B, B), // 0xb0-0xb3
-    OC4(B, B, B, B), // 0xb4-0xb7
-    OC4(B, B, B, B), // 0xb8-0xbb
-    OC4(B, B, B, B), // 0xbc-0xbf
-
-    OC4(B, B, B, B), // 0xc0-0xc3
-    OC4(B, B, B, B), // 0xc4-0xc7
-    OC4(B, B, B, B), // 0xc8-0xcb
-    OC4(B, B, B, B), // 0xcc-0xcf
-
-    OC4(B, B, B, B), // 0xd0-0xd3
-    OC4(U, U, U, B), // 0xd4-0xd7
-    OC4(B, B, B, B), // 0xd8-0xdb
-    OC4(B, B, B, B), // 0xdc-0xdf
-
-    OC4(B, B, B, B), // 0xe0-0xe3
-    OC4(B, B, B, B), // 0xe4-0xe7
-    OC4(B, B, B, B), // 0xe8-0xeb
-    OC4(B, B, B, B), // 0xec-0xef
-
-    OC4(B, B, B, B), // 0xf0-0xf3
-    OC4(B, B, B, B), // 0xf4-0xf7
-    OC4(U, U, U, U), // 0xf8-0xfb
-    OC4(U, U, U, U), // 0xfc-0xff
-};
-#undef OC4
-#undef U
-#undef B
-#undef Q
-#undef V
-#undef O
-
 uint mp_opcode_format(const byte *ip, size_t *opcode_size, bool count_var_uint) {
-    uint f = (opcode_format_table[*ip >> 2] >> (2 * (*ip & 3))) & 3;
+    uint f = MP_BC_FORMAT(*ip);
     const byte *ip_start = ip;
-    if (f == MP_OPCODE_QSTR) {
+    if (f == MP_BC_FORMAT_QSTR) {
         if (MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE_DYNAMIC) {
             if (*ip == MP_BC_LOAD_NAME
                 || *ip == MP_BC_LOAD_GLOBAL
@@ -396,18 +324,14 @@ uint mp_opcode_format(const byte *ip, size_t *opcode_size, bool count_var_uint)
         }
         ip += 3;
     } else {
-        int extra_byte = (
-            *ip == MP_BC_RAISE_VARARGS
-            || *ip == MP_BC_MAKE_CLOSURE
-            || *ip == MP_BC_MAKE_CLOSURE_DEFARGS
-        );
+        int extra_byte = (*ip & MP_BC_MASK_EXTRA_BYTE) == 0;
         ip += 1;
-        if (f == MP_OPCODE_VAR_UINT) {
+        if (f == MP_BC_FORMAT_VAR_UINT) {
             if (count_var_uint) {
                 while ((*ip++ & 0x80) != 0) {
                 }
             }
-        } else if (f == MP_OPCODE_OFFSET) {
+        } else if (f == MP_BC_FORMAT_OFFSET) {
             ip += 2;
         }
         ip += extra_byte;
diff --git a/py/bc.h b/py/bc.h
index 6d86fbdea92ee..0c19c516595ac 100644
--- a/py/bc.h
+++ b/py/bc.h
@@ -4,6 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2014 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -31,24 +32,35 @@
 
 // bytecode layout:
 //
-//  n_state         : var uint
-//  n_exc_stack     : var uint
-//  scope_flags     : byte
-//  n_pos_args      : byte          number of arguments this function takes
-//  n_kwonly_args   : byte          number of keyword-only arguments this function takes
-//  n_def_pos_args  : byte          number of default positional arguments
+//  func signature  : var uint
+//      contains six values interleaved bit-wise as: xSSSSEAA [xFSSKAED repeated]
+//          x = extension           another byte follows
+//          S = n_state - 1         number of entries in Python value stack
+//          E = n_exc_stack         number of entries in exception stack
+//          F = scope_flags         four bits of flags, MP_SCOPE_FLAG_xxx
+//          A = n_pos_args          number of arguments this function takes
+//          K = n_kwonly_args       number of keyword-only arguments this function takes
+//          D = n_def_pos_args      number of default positional arguments
 //
-//  code_info_size  : var uint |    code_info_size counts bytes in this chunk
-//  simple_name     : var qstr |
-//  source_file     : var qstr |
-//  <line number info>         |
-//  <word alignment padding>   |    only needed if bytecode contains pointers
+//  prelude size    : var uint
+//      contains two values interleaved bit-wise as: xIIIIIIC repeated
+//          x = extension           another byte follows
+//          I = n_info              number of bytes in source info section
+//          C = n_cells             number of bytes/cells in closure section
 //
-//  local_num0      : byte     |
-//  ...             : byte     |
-//  local_numN      : byte     |    N = num_cells
-//  255             : byte     |    end of list sentinel
-//  <bytecode>                 |
+//  source info section:
+//      simple_name : var qstr
+//      source_file : var qstr
+//      <line number info>
+//
+//  closure section:
+//      local_num0  : byte
+//      ...         : byte
+//      local_numN  : byte          N = n_cells-1
+//
+//  <word alignment padding>        only needed if bytecode contains pointers
+//
+//  <bytecode>
 //
 //
 // constant table layout:
@@ -59,13 +71,127 @@
 //  const0          : obj
 //  constN          : obj
 
+#define MP_BC_PRELUDE_SIG_ENCODE(S, E, scope, out_byte, out_env) \
+    do {                                                            \
+        /*// Get values to store in prelude */                      \
+        size_t F = scope->scope_flags & MP_SCOPE_FLAG_ALL_SIG;      \
+        size_t A = scope->num_pos_args;                             \
+        size_t K = scope->num_kwonly_args;                          \
+        size_t D = scope->num_def_pos_args;                         \
+                                                                \
+        /* Adjust S to shrink range, to compress better */          \
+        S -= 1;                                                     \
+                                                                \
+        /* Encode prelude */                                        \
+        /* xSSSSEAA */                                              \
+        uint8_t z = (S & 0xf) << 3 | (E & 1) << 2 | (A & 3);        \
+        S >>= 4;                                                    \
+        E >>= 1;                                                    \
+        A >>= 2;                                                    \
+        while (S | E | F | A | K | D) {                             \
+            out_byte(out_env, 0x80 | z);                            \
+            /* xFSSKAED */                                          \
+            z = (F & 1) << 6 | (S & 3) << 4 | (K & 1) << 3          \
+                | (A & 1) << 2 | (E & 1) << 1 | (D & 1);            \
+            S >>= 2;                                                \
+            E >>= 1;                                                \
+            F >>= 1;                                                \
+            A >>= 1;                                                \
+            K >>= 1;                                                \
+            D >>= 1;                                                \
+        }                                                           \
+        out_byte(out_env, z);                                       \
+    } while (0)
+
+#define MP_BC_PRELUDE_SIG_DECODE_INTO(ip, S, E, F, A, K, D)     \
+    do {                                                            \
+        uint8_t z = *(ip)++;                                        \
+        /* xSSSSEAA */                                              \
+        S = (z >> 3) & 0xf;                                         \
+        E = (z >> 2) & 0x1;                                         \
+        F = 0;                                                      \
+        A = z & 0x3;                                                \
+        K = 0;                                                      \
+        D = 0;                                                      \
+        for (unsigned n = 0; z & 0x80; ++n) {                       \
+            z = *(ip)++;                                            \
+            /* xFSSKAED */                                          \
+            S |= (z & 0x30) << (2 * n);                             \
+            E |= (z & 0x02) << n;                                   \
+            F |= ((z & 0x40) >> 6) << n;                            \
+            A |= (z & 0x4) << n;                                    \
+            K |= ((z & 0x08) >> 3) << n;                            \
+            D |= (z & 0x1) << n;                                    \
+        }                                                           \
+        S += 1;                                                     \
+    } while (0)
+
+#define MP_BC_PRELUDE_SIG_DECODE(ip) \
+    size_t n_state, n_exc_stack, scope_flags, n_pos_args, n_kwonly_args, n_def_pos_args; \
+    MP_BC_PRELUDE_SIG_DECODE_INTO(ip, n_state, n_exc_stack, scope_flags, n_pos_args, n_kwonly_args, n_def_pos_args)
+
+#define MP_BC_PRELUDE_SIZE_ENCODE(I, C, out_byte, out_env)      \
+    do {                                                            \
+        /* Encode bit-wise as: xIIIIIIC */                          \
+        uint8_t z = 0;                                              \
+        do {                                                        \
+            z = (I & 0x3f) << 1 | (C & 1);                          \
+            C >>= 1;                                                \
+            I >>= 6;                                                \
+            if (C | I) {                                            \
+                z |= 0x80;                                          \
+            }                                                       \
+            out_byte(out_env, z);                                   \
+        } while (C | I);                                            \
+    } while (0)
+
+#define MP_BC_PRELUDE_SIZE_DECODE_INTO(ip, I, C)                \
+    do {                                                            \
+        uint8_t z;                                                  \
+        C = 0;                                                      \
+        I = 0;                                                      \
+        for (unsigned n = 0;; ++n) {                                \
+            z = *(ip)++;                                            \
+            /* xIIIIIIC */                                          \
+            C |= (z & 1) << n;                                      \
+            I |= ((z & 0x7e) >> 1) << (6 * n);                      \
+            if (!(z & 0x80)) {                                      \
+                break;                                              \
+            }                                                       \
+        }                                                           \
+    } while (0)
+
+#define MP_BC_PRELUDE_SIZE_DECODE(ip) \
+    size_t n_info, n_cell; \
+    MP_BC_PRELUDE_SIZE_DECODE_INTO(ip, n_info, n_cell)
+
+// Sentinel value for mp_code_state_t.exc_sp_idx
+#define MP_CODE_STATE_EXC_SP_IDX_SENTINEL ((uint16_t)-1)
+
+// To convert mp_code_state_t.exc_sp_idx to/from a pointer to mp_exc_stack_t
+#define MP_CODE_STATE_EXC_SP_IDX_FROM_PTR(exc_stack, exc_sp) ((exc_sp) + 1 - (exc_stack))
+#define MP_CODE_STATE_EXC_SP_IDX_TO_PTR(exc_stack, exc_sp_idx) ((exc_stack) + (exc_sp_idx) - 1)
+
+typedef struct _mp_bytecode_prelude_t {
+    uint n_state;
+    uint n_exc_stack;
+    uint scope_flags;
+    uint n_pos_args;
+    uint n_kwonly_args;
+    uint n_def_pos_args;
+    qstr qstr_block_name;
+    qstr qstr_source_file;
+    const byte *line_info;
+    const byte *opcodes;
+} mp_bytecode_prelude_t;
+
 // Exception stack entry
 typedef struct _mp_exc_stack_t {
     const byte *handler;
-    // bit 0 is saved currently_in_except_block value
+    // bit 0 is currently unused
     // bit 1 is whether the opcode was SETUP_WITH or SETUP_FINALLY
     mp_obj_t *val_sp;
-    // Saved exception, valid if currently_in_except_block bit is 1
+    // Saved exception
     mp_obj_base_t *prev_exc;
 } mp_exc_stack_t;
 
@@ -77,16 +203,20 @@ typedef struct _mp_code_state_t {
     mp_obj_fun_bc_t *fun_bc;
     const byte *ip;
     mp_obj_t *sp;
-    // bit 0 is saved currently_in_except_block value
-    mp_exc_stack_t *exc_sp;
+    uint16_t n_state;
+    uint16_t exc_sp_idx;
     mp_obj_dict_t *old_globals;
     #if MICROPY_STACKLESS
     struct _mp_code_state_t *prev;
     #endif
+    #if MICROPY_PY_SYS_SETTRACE
+    struct _mp_code_state_t *prev_state;
+    struct _mp_obj_frame_t *frame;
+    #endif
     // Variable-length
     mp_obj_t state[0];
     // Variable-length, never accessed by name, only as (void*)(state + n_state)
-    //mp_exc_stack_t exc_state[0];
+    // mp_exc_stack_t exc_state[0];
 } mp_code_state_t;
 
 mp_uint_t mp_decode_uint(const byte **ptr);
@@ -102,20 +232,42 @@ const byte *mp_bytecode_print_str(const byte *ip);
 #define mp_bytecode_print_inst(code, const_table) mp_bytecode_print2(code, 1, const_table)
 
 // Helper macros to access pointer with least significant bits holding flags
-#define MP_TAGPTR_PTR(x) ((void*)((uintptr_t)(x) & ~((uintptr_t)3)))
+#define MP_TAGPTR_PTR(x) ((void *)((uintptr_t)(x) & ~((uintptr_t)3)))
 #define MP_TAGPTR_TAG0(x) ((uintptr_t)(x) & 1)
 #define MP_TAGPTR_TAG1(x) ((uintptr_t)(x) & 2)
-#define MP_TAGPTR_MAKE(ptr, tag) ((void*)((uintptr_t)(ptr) | (tag)))
+#define MP_TAGPTR_MAKE(ptr, tag) ((void *)((uintptr_t)(ptr) | (tag)))
 
 #if MICROPY_PERSISTENT_CODE_LOAD || MICROPY_PERSISTENT_CODE_SAVE
 
-#define MP_OPCODE_BYTE (0)
-#define MP_OPCODE_QSTR (1)
-#define MP_OPCODE_VAR_UINT (2)
-#define MP_OPCODE_OFFSET (3)
-
 uint mp_opcode_format(const byte *ip, size_t *opcode_size, bool count_var_uint);
 
 #endif
 
+static inline size_t mp_bytecode_get_source_line(const byte *line_info, size_t bc_offset) {
+    size_t source_line = 1;
+    size_t c;
+    while ((c = *line_info)) {
+        size_t b, l;
+        if ((c & 0x80) == 0) {
+            // 0b0LLBBBBB encoding
+            b = c & 0x1f;
+            l = c >> 5;
+            line_info += 1;
+        } else {
+            // 0b1LLLBBBB 0bLLLLLLLL encoding (l's LSB in second byte)
+            b = c & 0xf;
+            l = ((c << 4) & 0x700) | line_info[1];
+            line_info += 2;
+        }
+        if (bc_offset >= b) {
+            bc_offset -= b;
+            source_line += l;
+        } else {
+            // found source line corresponding to bytecode offset
+            break;
+        }
+    }
+    return source_line;
+}
+
 #endif // MICROPY_INCLUDED_PY_BC_H
diff --git a/py/bc0.h b/py/bc0.h
index 175ee263a00cb..842034ebfb6e9 100644
--- a/py/bc0.h
+++ b/py/bc0.h
@@ -26,93 +26,125 @@
 #ifndef MICROPY_INCLUDED_PY_BC0_H
 #define MICROPY_INCLUDED_PY_BC0_H
 
-// MicroPython byte-codes.
-// The comment at the end of the line (if it exists) tells the arguments to the byte-code.
-
-#define MP_BC_LOAD_CONST_FALSE   (0x10)
-#define MP_BC_LOAD_CONST_NONE    (0x11)
-#define MP_BC_LOAD_CONST_TRUE    (0x12)
-#define MP_BC_LOAD_CONST_SMALL_INT   (0x14) // signed var-int
-#define MP_BC_LOAD_CONST_STRING  (0x16) // qstr
-#define MP_BC_LOAD_CONST_OBJ     (0x17) // ptr
-#define MP_BC_LOAD_NULL          (0x18)
-
-#define MP_BC_LOAD_FAST_N        (0x19) // uint
-#define MP_BC_LOAD_DEREF         (0x1a) // uint
-#define MP_BC_LOAD_NAME          (0x1b) // qstr
-#define MP_BC_LOAD_GLOBAL        (0x1c) // qstr
-#define MP_BC_LOAD_ATTR          (0x1d) // qstr
-#define MP_BC_LOAD_METHOD        (0x1e) // qstr
-#define MP_BC_LOAD_SUPER_METHOD  (0x1f) // qstr
-#define MP_BC_LOAD_BUILD_CLASS   (0x20)
-#define MP_BC_LOAD_SUBSCR        (0x21)
-
-#define MP_BC_STORE_FAST_N       (0x22) // uint
-#define MP_BC_STORE_DEREF        (0x23) // uint
-#define MP_BC_STORE_NAME         (0x24) // qstr
-#define MP_BC_STORE_GLOBAL       (0x25) // qstr
-#define MP_BC_STORE_ATTR         (0x26) // qstr
-#define MP_BC_STORE_SUBSCR       (0x27)
-
-#define MP_BC_DELETE_FAST        (0x28) // uint
-#define MP_BC_DELETE_DEREF       (0x29) // uint
-#define MP_BC_DELETE_NAME        (0x2a) // qstr
-#define MP_BC_DELETE_GLOBAL      (0x2b) // qstr
-
-#define MP_BC_DUP_TOP            (0x30)
-#define MP_BC_DUP_TOP_TWO        (0x31)
-#define MP_BC_POP_TOP            (0x32)
-#define MP_BC_ROT_TWO            (0x33)
-#define MP_BC_ROT_THREE          (0x34)
-
-#define MP_BC_JUMP               (0x35) // rel byte code offset, 16-bit signed, in excess
-#define MP_BC_POP_JUMP_IF_TRUE   (0x36) // rel byte code offset, 16-bit signed, in excess
-#define MP_BC_POP_JUMP_IF_FALSE  (0x37) // rel byte code offset, 16-bit signed, in excess
-#define MP_BC_JUMP_IF_TRUE_OR_POP    (0x38) // rel byte code offset, 16-bit signed, in excess
-#define MP_BC_JUMP_IF_FALSE_OR_POP   (0x39) // rel byte code offset, 16-bit signed, in excess
-#define MP_BC_SETUP_WITH         (0x3d) // rel byte code offset, 16-bit unsigned
-#define MP_BC_WITH_CLEANUP       (0x3e)
-#define MP_BC_SETUP_EXCEPT       (0x3f) // rel byte code offset, 16-bit unsigned
-#define MP_BC_SETUP_FINALLY      (0x40) // rel byte code offset, 16-bit unsigned
-#define MP_BC_END_FINALLY        (0x41)
-#define MP_BC_GET_ITER           (0x42)
-#define MP_BC_FOR_ITER           (0x43) // rel byte code offset, 16-bit unsigned
-#define MP_BC_POP_EXCEPT_JUMP    (0x44) // rel byte code offset, 16-bit unsigned
-#define MP_BC_UNWIND_JUMP        (0x46) // rel byte code offset, 16-bit signed, in excess; then a byte
-#define MP_BC_GET_ITER_STACK     (0x47)
-
-#define MP_BC_BUILD_TUPLE        (0x50) // uint
-#define MP_BC_BUILD_LIST         (0x51) // uint
-#define MP_BC_BUILD_MAP          (0x53) // uint
-#define MP_BC_STORE_MAP          (0x54)
-#define MP_BC_BUILD_SET          (0x56) // uint
-#define MP_BC_BUILD_SLICE        (0x58) // uint
-#define MP_BC_STORE_COMP         (0x57) // uint
-#define MP_BC_UNPACK_SEQUENCE    (0x59) // uint
-#define MP_BC_UNPACK_EX          (0x5a) // uint
-
-#define MP_BC_RETURN_VALUE       (0x5b)
-#define MP_BC_RAISE_VARARGS      (0x5c) // byte
-#define MP_BC_YIELD_VALUE        (0x5d)
-#define MP_BC_YIELD_FROM         (0x5e)
-
-#define MP_BC_MAKE_FUNCTION         (0x60) // uint
-#define MP_BC_MAKE_FUNCTION_DEFARGS (0x61) // uint
-#define MP_BC_MAKE_CLOSURE          (0x62) // uint
-#define MP_BC_MAKE_CLOSURE_DEFARGS  (0x63) // uint
-#define MP_BC_CALL_FUNCTION         (0x64) // uint
-#define MP_BC_CALL_FUNCTION_VAR_KW  (0x65) // uint
-#define MP_BC_CALL_METHOD           (0x66) // uint
-#define MP_BC_CALL_METHOD_VAR_KW    (0x67) // uint
-
-#define MP_BC_IMPORT_NAME        (0x68) // qstr
-#define MP_BC_IMPORT_FROM        (0x69) // qstr
-#define MP_BC_IMPORT_STAR        (0x6a)
-
-#define MP_BC_LOAD_CONST_SMALL_INT_MULTI (0x70) // + N(64)
-#define MP_BC_LOAD_FAST_MULTI            (0xb0) // + N(16)
-#define MP_BC_STORE_FAST_MULTI           (0xc0) // + N(16)
-#define MP_BC_UNARY_OP_MULTI             (0xd0) // + op(<MP_UNARY_OP_NUM_BYTECODE)
-#define MP_BC_BINARY_OP_MULTI            (0xd7) // + op(<MP_BINARY_OP_NUM_BYTECODE)
+// MicroPython bytecode opcodes, grouped based on the format of the opcode
+
+#define MP_BC_MASK_FORMAT                   (0xf0)
+#define MP_BC_MASK_EXTRA_BYTE               (0x9e)
+
+#define MP_BC_FORMAT_BYTE                   (0)
+#define MP_BC_FORMAT_QSTR                   (1)
+#define MP_BC_FORMAT_VAR_UINT               (2)
+#define MP_BC_FORMAT_OFFSET                 (3)
+
+// Nibbles in magic number are: BB BB BB BB BB BO VV QU
+#define MP_BC_FORMAT(op) ((0x000003a4 >> (2 * ((op) >> 4))) & 3)
+
+// Load, Store, Delete, Import, Make, Build, Unpack, Call, Jump, Exception, For, sTack, Return, Yield, Op
+#define MP_BC_BASE_RESERVED                 (0x00) // ----------------
+#define MP_BC_BASE_QSTR_O                   (0x10) // LLLLLLSSSDDII---
+#define MP_BC_BASE_VINT_E                   (0x20) // MMLLLLSSDDBBBBBB
+#define MP_BC_BASE_VINT_O                   (0x30) // UUMMCCCC--------
+#define MP_BC_BASE_JUMP_E                   (0x40) // J-JJJJJEEEEF----
+#define MP_BC_BASE_BYTE_O                   (0x50) // LLLLSSDTTTTTEEFF
+#define MP_BC_BASE_BYTE_E                   (0x60) // --BREEEYYI------
+#define MP_BC_LOAD_CONST_SMALL_INT_MULTI    (0x70) // LLLLLLLLLLLLLLLL
+//                                          (0x80) // LLLLLLLLLLLLLLLL
+//                                          (0x90) // LLLLLLLLLLLLLLLL
+//                                          (0xa0) // LLLLLLLLLLLLLLLL
+#define MP_BC_LOAD_FAST_MULTI               (0xb0) // LLLLLLLLLLLLLLLL
+#define MP_BC_STORE_FAST_MULTI              (0xc0) // SSSSSSSSSSSSSSSS
+#define MP_BC_UNARY_OP_MULTI                (0xd0) // OOOOOOO
+#define MP_BC_BINARY_OP_MULTI               (0xd7) //        OOOOOOOOO
+//                                          (0xe0) // OOOOOOOOOOOOOOOO
+//                                          (0xf0) // OOOOOOOOOO------
+
+#define MP_BC_LOAD_CONST_SMALL_INT_MULTI_NUM (64)
+#define MP_BC_LOAD_CONST_SMALL_INT_MULTI_EXCESS (16)
+#define MP_BC_LOAD_FAST_MULTI_NUM           (16)
+#define MP_BC_STORE_FAST_MULTI_NUM          (16)
+#define MP_BC_UNARY_OP_MULTI_NUM            (MP_UNARY_OP_NUM_BYTECODE)
+#define MP_BC_BINARY_OP_MULTI_NUM           (MP_BINARY_OP_NUM_BYTECODE)
+
+#define MP_BC_LOAD_CONST_FALSE              (MP_BC_BASE_BYTE_O + 0x00)
+#define MP_BC_LOAD_CONST_NONE               (MP_BC_BASE_BYTE_O + 0x01)
+#define MP_BC_LOAD_CONST_TRUE               (MP_BC_BASE_BYTE_O + 0x02)
+#define MP_BC_LOAD_CONST_SMALL_INT          (MP_BC_BASE_VINT_E + 0x02) // signed var-int
+#define MP_BC_LOAD_CONST_STRING             (MP_BC_BASE_QSTR_O + 0x00) // qstr
+#define MP_BC_LOAD_CONST_OBJ                (MP_BC_BASE_VINT_E + 0x03) // ptr
+#define MP_BC_LOAD_NULL                     (MP_BC_BASE_BYTE_O + 0x03)
+
+#define MP_BC_LOAD_FAST_N                   (MP_BC_BASE_VINT_E + 0x04) // uint
+#define MP_BC_LOAD_DEREF                    (MP_BC_BASE_VINT_E + 0x05) // uint
+#define MP_BC_LOAD_NAME                     (MP_BC_BASE_QSTR_O + 0x01) // qstr
+#define MP_BC_LOAD_GLOBAL                   (MP_BC_BASE_QSTR_O + 0x02) // qstr
+#define MP_BC_LOAD_ATTR                     (MP_BC_BASE_QSTR_O + 0x03) // qstr
+#define MP_BC_LOAD_METHOD                   (MP_BC_BASE_QSTR_O + 0x04) // qstr
+#define MP_BC_LOAD_SUPER_METHOD             (MP_BC_BASE_QSTR_O + 0x05) // qstr
+#define MP_BC_LOAD_BUILD_CLASS              (MP_BC_BASE_BYTE_O + 0x04)
+#define MP_BC_LOAD_SUBSCR                   (MP_BC_BASE_BYTE_O + 0x05)
+
+#define MP_BC_STORE_FAST_N                  (MP_BC_BASE_VINT_E + 0x06) // uint
+#define MP_BC_STORE_DEREF                   (MP_BC_BASE_VINT_E + 0x07) // uint
+#define MP_BC_STORE_NAME                    (MP_BC_BASE_QSTR_O + 0x06) // qstr
+#define MP_BC_STORE_GLOBAL                  (MP_BC_BASE_QSTR_O + 0x07) // qstr
+#define MP_BC_STORE_ATTR                    (MP_BC_BASE_QSTR_O + 0x08) // qstr
+#define MP_BC_STORE_SUBSCR                  (MP_BC_BASE_BYTE_O + 0x06)
+
+#define MP_BC_DELETE_FAST                   (MP_BC_BASE_VINT_E + 0x08) // uint
+#define MP_BC_DELETE_DEREF                  (MP_BC_BASE_VINT_E + 0x09) // uint
+#define MP_BC_DELETE_NAME                   (MP_BC_BASE_QSTR_O + 0x09) // qstr
+#define MP_BC_DELETE_GLOBAL                 (MP_BC_BASE_QSTR_O + 0x0a) // qstr
+
+#define MP_BC_DUP_TOP                       (MP_BC_BASE_BYTE_O + 0x07)
+#define MP_BC_DUP_TOP_TWO                   (MP_BC_BASE_BYTE_O + 0x08)
+#define MP_BC_POP_TOP                       (MP_BC_BASE_BYTE_O + 0x09)
+#define MP_BC_ROT_TWO                       (MP_BC_BASE_BYTE_O + 0x0a)
+#define MP_BC_ROT_THREE                     (MP_BC_BASE_BYTE_O + 0x0b)
+
+#define MP_BC_JUMP                          (MP_BC_BASE_JUMP_E + 0x02) // rel byte code offset, 16-bit signed, in excess
+#define MP_BC_POP_JUMP_IF_TRUE              (MP_BC_BASE_JUMP_E + 0x03) // rel byte code offset, 16-bit signed, in excess
+#define MP_BC_POP_JUMP_IF_FALSE             (MP_BC_BASE_JUMP_E + 0x04) // rel byte code offset, 16-bit signed, in excess
+#define MP_BC_JUMP_IF_TRUE_OR_POP           (MP_BC_BASE_JUMP_E + 0x05) // rel byte code offset, 16-bit signed, in excess
+#define MP_BC_JUMP_IF_FALSE_OR_POP          (MP_BC_BASE_JUMP_E + 0x06) // rel byte code offset, 16-bit signed, in excess
+#define MP_BC_UNWIND_JUMP                   (MP_BC_BASE_JUMP_E + 0x00) // rel byte code offset, 16-bit signed, in excess; then a byte
+#define MP_BC_SETUP_WITH                    (MP_BC_BASE_JUMP_E + 0x07) // rel byte code offset, 16-bit unsigned
+#define MP_BC_SETUP_EXCEPT                  (MP_BC_BASE_JUMP_E + 0x08) // rel byte code offset, 16-bit unsigned
+#define MP_BC_SETUP_FINALLY                 (MP_BC_BASE_JUMP_E + 0x09) // rel byte code offset, 16-bit unsigned
+#define MP_BC_POP_EXCEPT_JUMP               (MP_BC_BASE_JUMP_E + 0x0a) // rel byte code offset, 16-bit unsigned
+#define MP_BC_FOR_ITER                      (MP_BC_BASE_JUMP_E + 0x0b) // rel byte code offset, 16-bit unsigned
+#define MP_BC_WITH_CLEANUP                  (MP_BC_BASE_BYTE_O + 0x0c)
+#define MP_BC_END_FINALLY                   (MP_BC_BASE_BYTE_O + 0x0d)
+#define MP_BC_GET_ITER                      (MP_BC_BASE_BYTE_O + 0x0e)
+#define MP_BC_GET_ITER_STACK                (MP_BC_BASE_BYTE_O + 0x0f)
+
+#define MP_BC_BUILD_TUPLE                   (MP_BC_BASE_VINT_E + 0x0a) // uint
+#define MP_BC_BUILD_LIST                    (MP_BC_BASE_VINT_E + 0x0b) // uint
+#define MP_BC_BUILD_MAP                     (MP_BC_BASE_VINT_E + 0x0c) // uint
+#define MP_BC_STORE_MAP                     (MP_BC_BASE_BYTE_E + 0x02)
+#define MP_BC_BUILD_SET                     (MP_BC_BASE_VINT_E + 0x0d) // uint
+#define MP_BC_BUILD_SLICE                   (MP_BC_BASE_VINT_E + 0x0e) // uint
+#define MP_BC_STORE_COMP                    (MP_BC_BASE_VINT_E + 0x0f) // uint
+#define MP_BC_UNPACK_SEQUENCE               (MP_BC_BASE_VINT_O + 0x00) // uint
+#define MP_BC_UNPACK_EX                     (MP_BC_BASE_VINT_O + 0x01) // uint
+
+#define MP_BC_RETURN_VALUE                  (MP_BC_BASE_BYTE_E + 0x03)
+#define MP_BC_RAISE_LAST                    (MP_BC_BASE_BYTE_E + 0x04)
+#define MP_BC_RAISE_OBJ                     (MP_BC_BASE_BYTE_E + 0x05)
+#define MP_BC_RAISE_FROM                    (MP_BC_BASE_BYTE_E + 0x06)
+#define MP_BC_YIELD_VALUE                   (MP_BC_BASE_BYTE_E + 0x07)
+#define MP_BC_YIELD_FROM                    (MP_BC_BASE_BYTE_E + 0x08)
+
+#define MP_BC_MAKE_FUNCTION                 (MP_BC_BASE_VINT_O + 0x02) // uint
+#define MP_BC_MAKE_FUNCTION_DEFARGS         (MP_BC_BASE_VINT_O + 0x03) // uint
+#define MP_BC_MAKE_CLOSURE                  (MP_BC_BASE_VINT_E + 0x00) // uint; extra byte
+#define MP_BC_MAKE_CLOSURE_DEFARGS          (MP_BC_BASE_VINT_E + 0x01) // uint; extra byte
+#define MP_BC_CALL_FUNCTION                 (MP_BC_BASE_VINT_O + 0x04) // uint
+#define MP_BC_CALL_FUNCTION_VAR_KW          (MP_BC_BASE_VINT_O + 0x05) // uint
+#define MP_BC_CALL_METHOD                   (MP_BC_BASE_VINT_O + 0x06) // uint
+#define MP_BC_CALL_METHOD_VAR_KW            (MP_BC_BASE_VINT_O + 0x07) // uint
+
+#define MP_BC_IMPORT_NAME                   (MP_BC_BASE_QSTR_O + 0x0b) // qstr
+#define MP_BC_IMPORT_FROM                   (MP_BC_BASE_QSTR_O + 0x0c) // qstr
+#define MP_BC_IMPORT_STAR                   (MP_BC_BASE_BYTE_E + 0x09)
 
 #endif // MICROPY_INCLUDED_PY_BC0_H
diff --git a/py/binary.c b/py/binary.c
index bb2b718ced50b..d0f72ec23c49c 100644
--- a/py/binary.c
+++ b/py/binary.c
@@ -3,7 +3,8 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2014-2017 Paul Sokolovsky
+ * Copyright (c) 2014-2019 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -41,28 +42,44 @@
 #define alignof(type) offsetof(struct { char c; type t; }, t)
 #endif
 
-size_t mp_binary_get_size(char struct_type, char val_type, mp_uint_t *palign) {
+size_t mp_binary_get_size(char struct_type, char val_type, size_t *palign) {
     size_t size = 0;
     int align = 1;
     switch (struct_type) {
-        case '<': case '>':
+        case '<':
+        case '>':
             switch (val_type) {
-                case 'b': case 'B':
-                    size = 1; break;
-                case 'h': case 'H':
-                    size = 2; break;
-                case 'i': case 'I':
-                    size = 4; break;
-                case 'l': case 'L':
-                    size = 4; break;
-                case 'q': case 'Q':
-                    size = 8; break;
-                case 'P': case 'O': case 'S':
-                    size = sizeof(void*); break;
+                case 'b':
+                case 'B':
+                    size = 1;
+                    break;
+                case 'h':
+                case 'H':
+                    size = 2;
+                    break;
+                case 'i':
+                case 'I':
+                    size = 4;
+                    break;
+                case 'l':
+                case 'L':
+                    size = 4;
+                    break;
+                case 'q':
+                case 'Q':
+                    size = 8;
+                    break;
+                case 'P':
+                case 'O':
+                case 'S':
+                    size = sizeof(void *);
+                    break;
                 case 'f':
-                    size = sizeof(float); break;
+                    size = sizeof(float);
+                    break;
                 case 'd':
-                    size = sizeof(double); break;
+                    size = sizeof(double);
+                    break;
             }
             break;
         case '@': {
@@ -75,35 +92,50 @@ size_t mp_binary_get_size(char struct_type, char val_type, mp_uint_t *palign) {
             // particular (or any) ABI.
             switch (val_type) {
                 case BYTEARRAY_TYPECODE:
-                case 'b': case 'B':
-                    align = size = 1; break;
-                case 'h': case 'H':
+                case 'b':
+                case 'B':
+                    align = size = 1;
+                    break;
+                case 'h':
+                case 'H':
                     align = alignof(short);
-                    size = sizeof(short); break;
-                case 'i': case 'I':
+                    size = sizeof(short);
+                    break;
+                case 'i':
+                case 'I':
                     align = alignof(int);
-                    size = sizeof(int); break;
-                case 'l': case 'L':
+                    size = sizeof(int);
+                    break;
+                case 'l':
+                case 'L':
                     align = alignof(long);
-                    size = sizeof(long); break;
-                case 'q': case 'Q':
+                    size = sizeof(long);
+                    break;
+                case 'q':
+                case 'Q':
                     align = alignof(long long);
-                    size = sizeof(long long); break;
-                case 'P': case 'O': case 'S':
-                    align = alignof(void*);
-                    size = sizeof(void*); break;
+                    size = sizeof(long long);
+                    break;
+                case 'P':
+                case 'O':
+                case 'S':
+                    align = alignof(void *);
+                    size = sizeof(void *);
+                    break;
                 case 'f':
                     align = alignof(float);
-                    size = sizeof(float); break;
+                    size = sizeof(float);
+                    break;
                 case 'd':
                     align = alignof(double);
-                    size = sizeof(double); break;
+                    size = sizeof(double);
+                    break;
             }
         }
     }
 
     if (size == 0) {
-        mp_raise_ValueError("bad typecode");
+        mp_raise_ValueError(MP_ERROR_TEXT("bad typecode"));
     }
 
     if (palign != NULL) {
@@ -112,48 +144,48 @@ size_t mp_binary_get_size(char struct_type, char val_type, mp_uint_t *palign) {
     return size;
 }
 
-mp_obj_t mp_binary_get_val_array(char typecode, void *p, mp_uint_t index) {
+mp_obj_t mp_binary_get_val_array(char typecode, void *p, size_t index) {
     mp_int_t val = 0;
     switch (typecode) {
         case 'b':
-            val = ((signed char*)p)[index];
+            val = ((signed char *)p)[index];
             break;
         case BYTEARRAY_TYPECODE:
         case 'B':
-            val = ((unsigned char*)p)[index];
+            val = ((unsigned char *)p)[index];
             break;
         case 'h':
-            val = ((short*)p)[index];
+            val = ((short *)p)[index];
             break;
         case 'H':
-            val = ((unsigned short*)p)[index];
+            val = ((unsigned short *)p)[index];
             break;
         case 'i':
-            return mp_obj_new_int(((int*)p)[index]);
+            return mp_obj_new_int(((int *)p)[index]);
         case 'I':
-            return mp_obj_new_int_from_uint(((unsigned int*)p)[index]);
+            return mp_obj_new_int_from_uint(((unsigned int *)p)[index]);
         case 'l':
-            return mp_obj_new_int(((long*)p)[index]);
+            return mp_obj_new_int(((long *)p)[index]);
         case 'L':
-            return mp_obj_new_int_from_uint(((unsigned long*)p)[index]);
+            return mp_obj_new_int_from_uint(((unsigned long *)p)[index]);
         #if MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_NONE
         case 'q':
-            return mp_obj_new_int_from_ll(((long long*)p)[index]);
+            return mp_obj_new_int_from_ll(((long long *)p)[index]);
         case 'Q':
-            return mp_obj_new_int_from_ull(((unsigned long long*)p)[index]);
+            return mp_obj_new_int_from_ull(((unsigned long long *)p)[index]);
         #endif
-#if MICROPY_PY_BUILTINS_FLOAT
+        #if MICROPY_PY_BUILTINS_FLOAT
         case 'f':
-            return mp_obj_new_float(((float*)p)[index]);
+            return mp_obj_new_float_from_f(((float *)p)[index]);
         case 'd':
-            return mp_obj_new_float(((double*)p)[index]);
-#endif
+            return mp_obj_new_float_from_d(((double *)p)[index]);
+        #endif
         // Extension to CPython: array of objects
         case 'O':
-            return ((mp_obj_t*)p)[index];
+            return ((mp_obj_t *)p)[index];
         // Extension to CPython: array of pointers
         case 'P':
-            return mp_obj_new_int((mp_int_t)(uintptr_t)((void**)p)[index]);
+            return mp_obj_new_int((mp_int_t)(uintptr_t)((void **)p)[index]);
     }
     return MP_OBJ_NEW_SMALL_INT(val);
 }
@@ -161,7 +193,7 @@ mp_obj_t mp_binary_get_val_array(char typecode, void *p, mp_uint_t index) {
 // The long long type is guaranteed to hold at least 64 bits, and size is at
 // most 8 (for q and Q), so we will always be able to parse the given data
 // and fit it into a long long.
-long long mp_binary_get_int(mp_uint_t size, bool is_signed, bool big_endian, const byte *src) {
+long long mp_binary_get_int(size_t size, bool is_signed, bool big_endian, const byte *src) {
     int delta;
     if (!big_endian) {
         delta = -1;
@@ -184,14 +216,14 @@ long long mp_binary_get_int(mp_uint_t size, bool is_signed, bool big_endian, con
 }
 
 #define is_signed(typecode) (typecode > 'Z')
-mp_obj_t mp_binary_get_val(char struct_type, char val_type, byte **ptr) {
+mp_obj_t mp_binary_get_val(char struct_type, char val_type, byte *p_base, byte **ptr) {
     byte *p = *ptr;
-    mp_uint_t align;
+    size_t align;
 
     size_t size = mp_binary_get_size(struct_type, val_type, &align);
     if (struct_type == '@') {
-        // Make pointer aligned
-        p = (byte*)MP_ALIGN(p, (size_t)align);
+        // Align p relative to p_base
+        p = p_base + (uintptr_t)MP_ALIGN(p - p_base, align);
         #if MP_ENDIANNESS_LITTLE
         struct_type = '<';
         #else
@@ -205,16 +237,20 @@ mp_obj_t mp_binary_get_val(char struct_type, char val_type, byte **ptr) {
     if (val_type == 'O') {
         return (mp_obj_t)(mp_uint_t)val;
     } else if (val_type == 'S') {
-        const char *s_val = (const char*)(uintptr_t)(mp_uint_t)val;
+        const char *s_val = (const char *)(uintptr_t)(mp_uint_t)val;
         return mp_obj_new_str(s_val, strlen(s_val));
-#if MICROPY_PY_BUILTINS_FLOAT
+    #if MICROPY_PY_BUILTINS_FLOAT
     } else if (val_type == 'f') {
-        union { uint32_t i; float f; } fpu = {val};
-        return mp_obj_new_float(fpu.f);
+        union { uint32_t i;
+                float f;
+        } fpu = {val};
+        return mp_obj_new_float_from_f(fpu.f);
     } else if (val_type == 'd') {
-        union { uint64_t i; double f; } fpu = {val};
-        return mp_obj_new_float(fpu.f);
-#endif
+        union { uint64_t i;
+                double f;
+        } fpu = {val};
+        return mp_obj_new_float_from_d(fpu.f);
+    #endif
     } else if (is_signed(val_type)) {
         if ((long long)MP_SMALL_INT_MIN <= val && val <= (long long)MP_SMALL_INT_MAX) {
             return mp_obj_new_int((mp_int_t)val);
@@ -230,18 +266,18 @@ mp_obj_t mp_binary_get_val(char struct_type, char val_type, byte **ptr) {
     }
 }
 
-void mp_binary_set_int(mp_uint_t val_sz, bool big_endian, byte *dest, mp_uint_t val) {
+void mp_binary_set_int(size_t val_sz, bool big_endian, byte *dest, mp_uint_t val) {
     if (MP_ENDIANNESS_LITTLE && !big_endian) {
         memcpy(dest, &val, val_sz);
     } else if (MP_ENDIANNESS_BIG && big_endian) {
         // only copy the least-significant val_sz bytes
-        memcpy(dest, (byte*)&val + sizeof(mp_uint_t) - val_sz, val_sz);
+        memcpy(dest, (byte *)&val + sizeof(mp_uint_t) - val_sz, val_sz);
     } else {
         const byte *src;
         if (MP_ENDIANNESS_LITTLE) {
-            src = (const byte*)&val + val_sz;
+            src = (const byte *)&val + val_sz;
         } else {
-            src = (const byte*)&val + sizeof(mp_uint_t);
+            src = (const byte *)&val + sizeof(mp_uint_t);
         }
         while (val_sz--) {
             *dest++ = *--src;
@@ -249,14 +285,14 @@ void mp_binary_set_int(mp_uint_t val_sz, bool big_endian, byte *dest, mp_uint_t
     }
 }
 
-void mp_binary_set_val(char struct_type, char val_type, mp_obj_t val_in, byte **ptr) {
+void mp_binary_set_val(char struct_type, char val_type, mp_obj_t val_in, byte *p_base, byte **ptr) {
     byte *p = *ptr;
-    mp_uint_t align;
+    size_t align;
 
     size_t size = mp_binary_get_size(struct_type, val_type, &align);
     if (struct_type == '@') {
-        // Make pointer aligned
-        p = (byte*)MP_ALIGN(p, (size_t)align);
+        // Align p relative to p_base
+        p = p_base + (uintptr_t)MP_ALIGN(p - p_base, align);
         if (MP_ENDIANNESS_LITTLE) {
             struct_type = '<';
         } else {
@@ -270,16 +306,21 @@ void mp_binary_set_val(char struct_type, char val_type, mp_obj_t val_in, byte **
         case 'O':
             val = (mp_uint_t)val_in;
             break;
-#if MICROPY_PY_BUILTINS_FLOAT
+        #if MICROPY_PY_BUILTINS_FLOAT
         case 'f': {
-            union { uint32_t i; float f; } fp_sp;
-            fp_sp.f = mp_obj_get_float(val_in);
+            union { uint32_t i;
+                    float f;
+            } fp_sp;
+            fp_sp.f = mp_obj_get_float_to_f(val_in);
             val = fp_sp.i;
             break;
         }
         case 'd': {
-            union { uint64_t i64; uint32_t i32[2]; double f; } fp_dp;
-            fp_dp.f = mp_obj_get_float(val_in);
+            union { uint64_t i64;
+                    uint32_t i32[2];
+                    double f;
+            } fp_dp;
+            fp_dp.f = mp_obj_get_float_to_d(val_in);
             if (BYTES_PER_WORD == 8) {
                 val = fp_dp.i64;
             } else {
@@ -290,50 +331,50 @@ void mp_binary_set_val(char struct_type, char val_type, mp_obj_t val_in, byte **
             }
             break;
         }
-#endif
+        #endif
         default:
             #if MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_NONE
             if (mp_obj_is_type(val_in, &mp_type_int)) {
                 mp_obj_int_to_bytes_impl(val_in, struct_type == '>', size, p);
                 return;
-            } else
+            }
             #endif
-            {
-                val = mp_obj_get_int(val_in);
-                // zero/sign extend if needed
-                if (BYTES_PER_WORD < 8 && size > sizeof(val)) {
-                    int c = (is_signed(val_type) && (mp_int_t)val < 0) ? 0xff : 0x00;
-                    memset(p, c, size);
-                    if (struct_type == '>') {
-                        p += size - sizeof(val);
-                    }
+
+            val = mp_obj_get_int(val_in);
+            // zero/sign extend if needed
+            if (BYTES_PER_WORD < 8 && size > sizeof(val)) {
+                int c = (is_signed(val_type) && (mp_int_t)val < 0) ? 0xff : 0x00;
+                memset(p, c, size);
+                if (struct_type == '>') {
+                    p += size - sizeof(val);
                 }
             }
+            break;
     }
 
     mp_binary_set_int(MIN((size_t)size, sizeof(val)), struct_type == '>', p, val);
 }
 
-void mp_binary_set_val_array(char typecode, void *p, mp_uint_t index, mp_obj_t val_in) {
+void mp_binary_set_val_array(char typecode, void *p, size_t index, mp_obj_t val_in) {
     switch (typecode) {
-#if MICROPY_PY_BUILTINS_FLOAT
+        #if MICROPY_PY_BUILTINS_FLOAT
         case 'f':
-            ((float*)p)[index] = mp_obj_get_float(val_in);
+            ((float *)p)[index] = mp_obj_get_float_to_f(val_in);
             break;
         case 'd':
-            ((double*)p)[index] = mp_obj_get_float(val_in);
+            ((double *)p)[index] = mp_obj_get_float_to_d(val_in);
             break;
-#endif
+        #endif
         // Extension to CPython: array of objects
         case 'O':
-            ((mp_obj_t*)p)[index] = val_in;
+            ((mp_obj_t *)p)[index] = val_in;
             break;
         default:
             #if MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_NONE
             if (mp_obj_is_type(val_in, &mp_type_int)) {
                 size_t size = mp_binary_get_size('@', typecode, NULL);
                 mp_obj_int_to_bytes_impl(val_in, MP_ENDIANNESS_BIG,
-                    size, (uint8_t*)p + index * size);
+                    size, (uint8_t *)p + index * size);
                 return;
             }
             #endif
@@ -341,52 +382,52 @@ void mp_binary_set_val_array(char typecode, void *p, mp_uint_t index, mp_obj_t v
     }
 }
 
-void mp_binary_set_val_array_from_int(char typecode, void *p, mp_uint_t index, mp_int_t val) {
+void mp_binary_set_val_array_from_int(char typecode, void *p, size_t index, mp_int_t val) {
     switch (typecode) {
         case 'b':
-            ((signed char*)p)[index] = val;
+            ((signed char *)p)[index] = val;
             break;
         case BYTEARRAY_TYPECODE:
         case 'B':
-            ((unsigned char*)p)[index] = val;
+            ((unsigned char *)p)[index] = val;
             break;
         case 'h':
-            ((short*)p)[index] = val;
+            ((short *)p)[index] = val;
             break;
         case 'H':
-            ((unsigned short*)p)[index] = val;
+            ((unsigned short *)p)[index] = val;
             break;
         case 'i':
-            ((int*)p)[index] = val;
+            ((int *)p)[index] = val;
             break;
         case 'I':
-            ((unsigned int*)p)[index] = val;
+            ((unsigned int *)p)[index] = val;
             break;
         case 'l':
-            ((long*)p)[index] = val;
+            ((long *)p)[index] = val;
             break;
         case 'L':
-            ((unsigned long*)p)[index] = val;
+            ((unsigned long *)p)[index] = val;
             break;
         #if MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_NONE
         case 'q':
-            ((long long*)p)[index] = val;
+            ((long long *)p)[index] = val;
             break;
         case 'Q':
-            ((unsigned long long*)p)[index] = val;
+            ((unsigned long long *)p)[index] = val;
             break;
         #endif
-#if MICROPY_PY_BUILTINS_FLOAT
+        #if MICROPY_PY_BUILTINS_FLOAT
         case 'f':
-            ((float*)p)[index] = val;
+            ((float *)p)[index] = (float)val;
             break;
         case 'd':
-            ((double*)p)[index] = val;
+            ((double *)p)[index] = (double)val;
             break;
-#endif
+        #endif
         // Extension to CPython: array of pointers
         case 'P':
-            ((void**)p)[index] = (void*)(uintptr_t)val;
+            ((void **)p)[index] = (void *)(uintptr_t)val;
             break;
     }
 }
diff --git a/py/binary.h b/py/binary.h
index 0dae6a29e6617..5c645bcaaa9c2 100644
--- a/py/binary.h
+++ b/py/binary.h
@@ -3,7 +3,8 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2014 Paul Sokolovsky
+ * Copyright (c) 2014-2017 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -33,13 +34,13 @@
 // type-specification errors due to end-of-string.
 #define BYTEARRAY_TYPECODE 1
 
-size_t mp_binary_get_size(char struct_type, char val_type, mp_uint_t *palign);
-mp_obj_t mp_binary_get_val_array(char typecode, void *p, mp_uint_t index);
-void mp_binary_set_val_array(char typecode, void *p, mp_uint_t index, mp_obj_t val_in);
-void mp_binary_set_val_array_from_int(char typecode, void *p, mp_uint_t index, mp_int_t val);
-mp_obj_t mp_binary_get_val(char struct_type, char val_type, byte **ptr);
-void mp_binary_set_val(char struct_type, char val_type, mp_obj_t val_in, byte **ptr);
-long long mp_binary_get_int(mp_uint_t size, bool is_signed, bool big_endian, const byte *src);
-void mp_binary_set_int(mp_uint_t val_sz, bool big_endian, byte *dest, mp_uint_t val);
+size_t mp_binary_get_size(char struct_type, char val_type, size_t *palign);
+mp_obj_t mp_binary_get_val_array(char typecode, void *p, size_t index);
+void mp_binary_set_val_array(char typecode, void *p, size_t index, mp_obj_t val_in);
+void mp_binary_set_val_array_from_int(char typecode, void *p, size_t index, mp_int_t val);
+mp_obj_t mp_binary_get_val(char struct_type, char val_type, byte *p_base, byte **ptr);
+void mp_binary_set_val(char struct_type, char val_type, mp_obj_t val_in, byte *p_base, byte **ptr);
+long long mp_binary_get_int(size_t size, bool is_signed, bool big_endian, const byte *src);
+void mp_binary_set_int(size_t val_sz, bool big_endian, byte *dest, mp_uint_t val);
 
 #endif // MICROPY_INCLUDED_PY_BINARY_H
diff --git a/py/builtin.h b/py/builtin.h
index a5e0f5f2d0fbb..1e4769cd69a35 100644
--- a/py/builtin.h
+++ b/py/builtin.h
@@ -89,7 +89,7 @@ MP_DECLARE_CONST_FUN_OBJ_2(mp_op_delitem_obj);
 
 extern const mp_obj_module_t mp_module___main__;
 extern const mp_obj_module_t mp_module_builtins;
-extern const mp_obj_module_t mp_module_array;
+extern const mp_obj_module_t mp_module_uarray;
 extern const mp_obj_module_t mp_module_collections;
 extern const mp_obj_module_t mp_module_io;
 extern const mp_obj_module_t mp_module_math;
@@ -103,6 +103,7 @@ extern const mp_obj_module_t mp_module_thread;
 extern const mp_obj_dict_t mp_module_builtins_globals;
 
 // extmod modules
+extern const mp_obj_module_t mp_module_uasyncio;
 extern const mp_obj_module_t mp_module_uerrno;
 extern const mp_obj_module_t mp_module_uctypes;
 extern const mp_obj_module_t mp_module_uzlib;
@@ -122,6 +123,7 @@ extern const mp_obj_module_t mp_module_uwebsocket;
 extern const mp_obj_module_t mp_module_webrepl;
 extern const mp_obj_module_t mp_module_framebuf;
 extern const mp_obj_module_t mp_module_btree;
+extern const mp_obj_module_t mp_module_ubluetooth;
 
 extern const char MICROPY_PY_BUILTINS_HELP_TEXT[];
 
diff --git a/py/builtinevex.c b/py/builtinevex.c
index 819e3e1c63053..800a20223aada 100644
--- a/py/builtinevex.c
+++ b/py/builtinevex.c
@@ -90,11 +90,17 @@ STATIC mp_obj_t mp_builtin_compile(size_t n_args, const mp_obj_t *args) {
     qstr mode = mp_obj_str_get_qstr(args[2]);
     mp_parse_input_kind_t parse_input_kind;
     switch (mode) {
-        case MP_QSTR_single: parse_input_kind = MP_PARSE_SINGLE_INPUT; break;
-        case MP_QSTR_exec: parse_input_kind = MP_PARSE_FILE_INPUT; break;
-        case MP_QSTR_eval: parse_input_kind = MP_PARSE_EVAL_INPUT; break;
+        case MP_QSTR_single:
+            parse_input_kind = MP_PARSE_SINGLE_INPUT;
+            break;
+        case MP_QSTR_exec:
+            parse_input_kind = MP_PARSE_FILE_INPUT;
+            break;
+        case MP_QSTR_eval:
+            parse_input_kind = MP_PARSE_EVAL_INPUT;
+            break;
         default:
-            mp_raise_ValueError("bad compile mode");
+            mp_raise_ValueError(MP_ERROR_TEXT("bad compile mode"));
     }
 
     mp_obj_code_t *code = m_new_obj(mp_obj_code_t);
@@ -130,17 +136,18 @@ STATIC mp_obj_t eval_exec_helper(size_t n_args, const mp_obj_t *args, mp_parse_i
     }
     #endif
 
-    size_t str_len;
-    const char *str = mp_obj_str_get_data(args[0], &str_len);
+    // Extract the source code.
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(args[0], &bufinfo, MP_BUFFER_READ);
 
     // create the lexer
     // MP_PARSE_SINGLE_INPUT is used to indicate a file input
     mp_lexer_t *lex;
     if (MICROPY_PY_BUILTINS_EXECFILE && parse_input_kind == MP_PARSE_SINGLE_INPUT) {
-        lex = mp_lexer_new_from_file(str);
+        lex = mp_lexer_new_from_file(bufinfo.buf);
         parse_input_kind = MP_PARSE_FILE_INPUT;
     } else {
-        lex = mp_lexer_new_from_str_len(MP_QSTR__lt_string_gt_, str, str_len, 0);
+        lex = mp_lexer_new_from_str_len(MP_QSTR__lt_string_gt_, bufinfo.buf, bufinfo.len, 0);
     }
 
     return mp_parse_compile_execute(lex, parse_input_kind, globals, locals);
diff --git a/py/builtinhelp.c b/py/builtinhelp.c
index a7fede00acea0..13735635e3c90 100644
--- a/py/builtinhelp.c
+++ b/py/builtinhelp.c
@@ -33,18 +33,18 @@
 #if MICROPY_PY_BUILTINS_HELP
 
 const char mp_help_default_text[] =
-"Welcome to MicroPython!\n"
-"\n"
-"For online docs please visit http://docs.micropython.org/\n"
-"\n"
-"Control commands:\n"
-"  CTRL-A        -- on a blank line, enter raw REPL mode\n"
-"  CTRL-B        -- on a blank line, enter normal REPL mode\n"
-"  CTRL-C        -- interrupt a running program\n"
-"  CTRL-D        -- on a blank line, exit or do a soft reset\n"
-"  CTRL-E        -- on a blank line, enter paste mode\n"
-"\n"
-"For further help on a specific object, type help(obj)\n"
+    "Welcome to MicroPython!\n"
+    "\n"
+    "For online docs please visit http://docs.micropython.org/\n"
+    "\n"
+    "Control commands:\n"
+    "  CTRL-A        -- on a blank line, enter raw REPL mode\n"
+    "  CTRL-B        -- on a blank line, enter normal REPL mode\n"
+    "  CTRL-C        -- interrupt a running program\n"
+    "  CTRL-D        -- on a blank line, exit or do a soft reset\n"
+    "  CTRL-E        -- on a blank line, enter paste mode\n"
+    "\n"
+    "For further help on a specific object, type help(obj)\n"
 ;
 
 STATIC void mp_help_print_info_about_object(mp_obj_t name_o, mp_obj_t value) {
@@ -80,10 +80,6 @@ STATIC void mp_help_print_modules(void) {
 
     mp_help_add_from_map(list, &mp_builtin_module_map);
 
-    #if MICROPY_MODULE_WEAK_LINKS
-    mp_help_add_from_map(list, &mp_builtin_module_weak_links_map);
-    #endif
-
     #if MICROPY_MODULE_FROZEN_STR
     extern const char mp_frozen_str_names[];
     mp_help_add_from_names(list, mp_frozen_str_names);
@@ -95,7 +91,7 @@ STATIC void mp_help_print_modules(void) {
     #endif
 
     // sort the list so it's printed in alphabetical order
-    mp_obj_list_sort(1, &list, (mp_map_t*)&mp_const_empty_map);
+    mp_obj_list_sort(1, &list, (mp_map_t *)&mp_const_empty_map);
 
     // print the list of modules in a column-first order
     #define NUM_COLUMNS (4)
@@ -138,7 +134,7 @@ STATIC void mp_help_print_obj(const mp_obj_t obj) {
     }
     #endif
 
-    mp_obj_type_t *type = mp_obj_get_type(obj);
+    const mp_obj_type_t *type = mp_obj_get_type(obj);
 
     // try to print something sensible about the given object
     mp_print_str(MP_PYTHON_PRINTER, "object ");
diff --git a/py/builtinimport.c b/py/builtinimport.c
index 1a333b5404c03..bdc82e77c8f74 100644
--- a/py/builtinimport.c
+++ b/py/builtinimport.c
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2013-2019 Damien P. George
  * Copyright (c) 2014 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -96,19 +96,13 @@ STATIC mp_import_stat_t stat_dir_or_file(vstr_t *path) {
 }
 
 STATIC mp_import_stat_t find_file(const char *file_str, uint file_len, vstr_t *dest) {
-#if MICROPY_PY_SYS
+    #if MICROPY_PY_SYS
     // extract the list of paths
     size_t path_num;
     mp_obj_t *path_items;
     mp_obj_list_get(mp_sys_path, &path_num, &path_items);
 
-    if (path_num == 0) {
-#endif
-        // mp_sys_path is empty, so just use the given file name
-        vstr_add_strn(dest, file_str, file_len);
-        return stat_dir_or_file(dest);
-#if MICROPY_PY_SYS
-    } else {
+    if (path_num != 0) {
         // go through each path looking for a directory or file
         for (size_t i = 0; i < path_num; i++) {
             vstr_reset(dest);
@@ -128,7 +122,11 @@ STATIC mp_import_stat_t find_file(const char *file_str, uint file_len, vstr_t *d
         // could not find a directory or file
         return MP_IMPORT_STAT_NO_EXIST;
     }
-#endif
+    #endif
+
+    // mp_sys_path is empty, so just use the given file name
+    vstr_add_strn(dest, file_str, file_len);
+    return stat_dir_or_file(dest);
 }
 
 #if MICROPY_MODULE_FROZEN_STR || MICROPY_ENABLE_COMPILER
@@ -145,11 +143,11 @@ STATIC void do_load_from_lexer(mp_obj_t module_obj, mp_lexer_t *lex) {
 #endif
 
 #if MICROPY_PERSISTENT_CODE_LOAD || MICROPY_MODULE_FROZEN_MPY
-STATIC void do_execute_raw_code(mp_obj_t module_obj, mp_raw_code_t *raw_code) {
+STATIC void do_execute_raw_code(mp_obj_t module_obj, mp_raw_code_t *raw_code, const char *source_name) {
+    (void)source_name;
+
     #if MICROPY_PY___FILE__
-    // TODO
-    //qstr source_name = lex->source_name;
-    //mp_store_attr(module_obj, MP_QSTR___file__, MP_OBJ_NEW_QSTR(source_name));
+    mp_store_attr(module_obj, MP_QSTR___file__, MP_OBJ_NEW_QSTR(qstr_from_str(source_name)));
     #endif
 
     // execute the module in its context
@@ -206,7 +204,7 @@ STATIC void do_load(mp_obj_t module_obj, vstr_t *file) {
     // its data) in the list of frozen files, execute it.
     #if MICROPY_MODULE_FROZEN_MPY
     if (frozen_type == MP_FROZEN_MPY) {
-        do_execute_raw_code(module_obj, modref);
+        do_execute_raw_code(module_obj, modref, file_str);
         return;
     }
     #endif
@@ -216,7 +214,7 @@ STATIC void do_load(mp_obj_t module_obj, vstr_t *file) {
     #if MICROPY_HAS_FILE_READER && MICROPY_PERSISTENT_CODE_LOAD
     if (file_str[file->len - 3] == 'm') {
         mp_raw_code_t *raw_code = mp_raw_code_load_file(file_str);
-        do_execute_raw_code(module_obj, raw_code);
+        do_execute_raw_code(module_obj, raw_code, file_str);
         return;
     }
     #endif
@@ -230,7 +228,7 @@ STATIC void do_load(mp_obj_t module_obj, vstr_t *file) {
     }
     #else
     // If we get here then the file was not frozen and we can't compile scripts.
-    mp_raise_msg(&mp_type_ImportError, "script compilation not supported");
+    mp_raise_msg(&mp_type_ImportError, MP_ERROR_TEXT("script compilation not supported"));
     #endif
 }
 
@@ -246,14 +244,14 @@ STATIC void chop_component(const char *start, const char **end) {
 }
 
 mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) {
-#if DEBUG_PRINT
+    #if DEBUG_PRINT
     DEBUG_printf("__import__:\n");
     for (size_t i = 0; i < n_args; i++) {
         DEBUG_printf("  ");
         mp_obj_print(args[i], PRINT_REPR);
         DEBUG_printf("\n");
     }
-#endif
+    #endif
 
     mp_obj_t module_name = args[0];
     mp_obj_t fromtuple = mp_const_none;
@@ -292,12 +290,12 @@ mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) {
         mp_map_elem_t *elem = mp_map_lookup(globals_map, MP_OBJ_NEW_QSTR(MP_QSTR___path__), MP_MAP_LOOKUP);
         bool is_pkg = (elem != NULL);
 
-#if DEBUG_PRINT
+        #if DEBUG_PRINT
         DEBUG_printf("Current module/package: ");
         mp_obj_print(this_name_q, PRINT_REPR);
         DEBUG_printf(", is_package: %d", is_pkg);
         DEBUG_printf("\n");
-#endif
+        #endif
 
         size_t this_name_l;
         const char *this_name = mp_obj_str_get_data(this_name_q, &this_name_l);
@@ -315,7 +313,7 @@ mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) {
 
         // We must have some component left over to import from
         if (p == this_name) {
-            mp_raise_ValueError("cannot perform relative import");
+            mp_raise_ValueError(MP_ERROR_TEXT("can't perform relative import"));
         }
 
         uint new_mod_l = (mod_len == 0 ? (size_t)(p - this_name) : (size_t)(p - this_name) + 1 + mod_len);
@@ -334,6 +332,10 @@ mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) {
         mod_len = new_mod_l;
     }
 
+    if (mod_len == 0) {
+        mp_raise_ValueError(NULL);
+    }
+
     // check if module already exists
     qstr module_name_qstr = mp_obj_str_get_qstr(module_name);
     mp_obj_t module_obj = mp_module_get(module_name_qstr);
@@ -381,28 +383,24 @@ mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) {
             DEBUG_printf("Current path: %.*s\n", vstr_len(&path), vstr_str(&path));
 
             if (stat == MP_IMPORT_STAT_NO_EXIST) {
+                module_obj = MP_OBJ_NULL;
                 #if MICROPY_MODULE_WEAK_LINKS
                 // check if there is a weak link to this module
                 if (i == mod_len) {
-                    mp_map_elem_t *el = mp_map_lookup((mp_map_t*)&mp_builtin_module_weak_links_map, MP_OBJ_NEW_QSTR(mod_name), MP_MAP_LOOKUP);
-                    if (el == NULL) {
-                        goto no_exist;
+                    module_obj = mp_module_search_umodule(mod_str);
+                    if (module_obj != MP_OBJ_NULL) {
+                        // found weak linked module
+                        mp_module_call_init(mod_name, module_obj);
                     }
-                    // found weak linked module
-                    module_obj = el->value;
-                    mp_module_call_init(mod_name, module_obj);
-                } else {
-                    no_exist:
-                #else
-                {
+                }
                 #endif
+                if (module_obj == MP_OBJ_NULL) {
                     // couldn't find the file, so fail
-                    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                        mp_raise_msg(&mp_type_ImportError, "module not found");
-                    } else {
-                        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ImportError,
-                            "no module named '%q'", mod_name));
-                    }
+                    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                    mp_raise_msg(&mp_type_ImportError, MP_ERROR_TEXT("module not found"));
+                    #else
+                    mp_raise_msg_varg(&mp_type_ImportError, MP_ERROR_TEXT("no module named '%q'"), mod_name);
+                    #endif
                 }
             } else {
                 // found the file, so get the module
@@ -442,7 +440,7 @@ mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) {
                     vstr_add_char(&path, PATH_SEP_CHAR);
                     vstr_add_str(&path, "__init__.py");
                     if (stat_file_py_or_mpy(&path) != MP_IMPORT_STAT_FILE) {
-                        //mp_warning("%s is imported as namespace package", vstr_str(&path));
+                        // mp_warning("%s is imported as namespace package", vstr_str(&path));
                     } else {
                         do_load(module_obj, &path);
                     }
@@ -480,7 +478,7 @@ mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) {
 mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) {
     // Check that it's not a relative import
     if (n_args >= 5 && MP_OBJ_SMALL_INT_VALUE(args[4]) != 0) {
-        mp_raise_NotImplementedError("relative import");
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("relative import"));
     }
 
     // Check if module already exists, and return it if it does
@@ -492,21 +490,20 @@ mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) {
 
     #if MICROPY_MODULE_WEAK_LINKS
     // Check if there is a weak link to this module
-    mp_map_elem_t *el = mp_map_lookup((mp_map_t*)&mp_builtin_module_weak_links_map, MP_OBJ_NEW_QSTR(module_name_qstr), MP_MAP_LOOKUP);
-    if (el != NULL) {
+    module_obj = mp_module_search_umodule(qstr_str(module_name_qstr));
+    if (module_obj != MP_OBJ_NULL) {
         // Found weak-linked module
-        mp_module_call_init(module_name_qstr, el->value);
-        return el->value;
+        mp_module_call_init(module_name_qstr, module_obj);
+        return module_obj;
     }
     #endif
 
     // Couldn't find the module, so fail
-    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-        mp_raise_msg(&mp_type_ImportError, "module not found");
-    } else {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ImportError,
-            "no module named '%q'", module_name_qstr));
-    }
+    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+    mp_raise_msg(&mp_type_ImportError, MP_ERROR_TEXT("module not found"));
+    #else
+    mp_raise_msg_varg(&mp_type_ImportError, MP_ERROR_TEXT("no module named '%q'"), module_name_qstr);
+    #endif
 }
 
 #endif // MICROPY_ENABLE_EXTERNAL_IMPORT
diff --git a/py/compile.c b/py/compile.c
index 4919a165955f4..22f47ee0d295f 100644
--- a/py/compile.c
+++ b/py/compile.c
@@ -47,14 +47,14 @@ typedef enum {
 // define rules with a compile function
 #define DEF_RULE(rule, comp, kind, ...) PN_##rule,
 #define DEF_RULE_NC(rule, kind, ...)
-#include "py/grammar.h"
+    #include "py/grammar.h"
 #undef DEF_RULE
 #undef DEF_RULE_NC
     PN_const_object, // special node for a constant, generic Python object
 // define rules without a compile function
 #define DEF_RULE(rule, comp, kind, ...)
 #define DEF_RULE_NC(rule, kind, ...) PN_##rule,
-#include "py/grammar.h"
+    #include "py/grammar.h"
 #undef DEF_RULE
 #undef DEF_RULE_NC
 } pn_kind_t;
@@ -95,6 +95,7 @@ STATIC const emit_method_table_t *emit_native_table[] = {
     &emit_native_thumb_method_table,
     &emit_native_thumb_method_table,
     &emit_native_xtensa_method_table,
+    &emit_native_xtensawin_method_table,
 };
 
 #elif MICROPY_EMIT_NATIVE
@@ -109,6 +110,8 @@ STATIC const emit_method_table_t *emit_native_table[] = {
 #define NATIVE_EMITTER(f) emit_native_arm_##f
 #elif MICROPY_EMIT_XTENSA
 #define NATIVE_EMITTER(f) emit_native_xtensa_##f
+#elif MICROPY_EMIT_XTENSAWIN
+#define NATIVE_EMITTER(f) emit_native_xtensawin_##f
 #else
 #error "unknown native emitter"
 #endif
@@ -124,13 +127,14 @@ STATIC const emit_inline_asm_method_table_t *emit_asm_table[] = {
     NULL,
     NULL,
     NULL,
-    NULL,
+    &emit_inline_thumb_method_table,
     &emit_inline_thumb_method_table,
     &emit_inline_thumb_method_table,
     &emit_inline_thumb_method_table,
     &emit_inline_thumb_method_table,
     &emit_inline_thumb_method_table,
     &emit_inline_xtensa_method_table,
+    NULL,
 };
 
 #elif MICROPY_EMIT_INLINE_ASM
@@ -189,11 +193,11 @@ typedef struct _compiler_t {
 STATIC void compile_error_set_line(compiler_t *comp, mp_parse_node_t pn) {
     // if the line of the error is unknown then try to update it from the pn
     if (comp->compile_error_line == 0 && MP_PARSE_NODE_IS_STRUCT(pn)) {
-        comp->compile_error_line = ((mp_parse_node_struct_t*)pn)->source_line;
+        comp->compile_error_line = ((mp_parse_node_struct_t *)pn)->source_line;
     }
 }
 
-STATIC void compile_syntax_error(compiler_t *comp, mp_parse_node_t pn, const char *msg) {
+STATIC void compile_syntax_error(compiler_t *comp, mp_parse_node_t pn, mp_rom_error_text_t msg) {
     // only register the error if there has been no other error
     if (comp->compile_error == MP_OBJ_NULL) {
         comp->compile_error = mp_obj_new_exception_msg(&mp_type_SyntaxError, msg);
@@ -255,7 +259,7 @@ typedef void (*apply_list_fun_t)(compiler_t *comp, mp_parse_node_t pn);
 
 STATIC void apply_to_single_or_list(compiler_t *comp, mp_parse_node_t pn, pn_kind_t pn_list_kind, apply_list_fun_t f) {
     if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, pn_list_kind)) {
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
         int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
         for (int i = 0; i < num_nodes; i++) {
             f(comp, pns->nodes[i]);
@@ -346,7 +350,7 @@ STATIC void c_if_cond(compiler_t *comp, mp_parse_node_t pn, bool jump_if, int la
         }
         return;
     } else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
         int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
         if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_or_test) {
             if (jump_if == false) {
@@ -405,7 +409,7 @@ STATIC void c_assign_atom_expr(compiler_t *comp, mp_parse_node_struct_t *pns, as
     }
 
     if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
-        mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
+        mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
         if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_atom_expr_trailers) {
             int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);
             if (assign_kind != ASSIGN_AUG_STORE) {
@@ -414,7 +418,7 @@ STATIC void c_assign_atom_expr(compiler_t *comp, mp_parse_node_struct_t *pns, as
                 }
             }
             assert(MP_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
-            pns1 = (mp_parse_node_struct_t*)pns1->nodes[n - 1];
+            pns1 = (mp_parse_node_struct_t *)pns1->nodes[n - 1];
         }
         if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
             if (assign_kind == ASSIGN_AUG_STORE) {
@@ -445,7 +449,7 @@ STATIC void c_assign_atom_expr(compiler_t *comp, mp_parse_node_struct_t *pns, as
         }
     }
 
-    compile_syntax_error(comp, (mp_parse_node_t)pns, "can't assign to expression");
+    compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("can't assign to expression"));
 }
 
 // we need to allow for a caller passing in 1 initial node (node_head) followed by an array of nodes (nodes_tail)
@@ -464,7 +468,7 @@ STATIC void c_assign_tuple(compiler_t *comp, mp_parse_node_t node_head, uint num
                 EMIT_ARG(unpack_ex, num_head + i, num_tail - i - 1);
                 have_star_index = num_head + i;
             } else {
-                compile_syntax_error(comp, nodes_tail[i], "multiple *x in assignment");
+                compile_syntax_error(comp, nodes_tail[i], MP_ERROR_TEXT("multiple *x in assignment"));
                 return;
             }
         }
@@ -474,14 +478,14 @@ STATIC void c_assign_tuple(compiler_t *comp, mp_parse_node_t node_head, uint num
     }
     if (num_head != 0) {
         if (0 == have_star_index) {
-            c_assign(comp, ((mp_parse_node_struct_t*)node_head)->nodes[0], ASSIGN_STORE);
+            c_assign(comp, ((mp_parse_node_struct_t *)node_head)->nodes[0], ASSIGN_STORE);
         } else {
             c_assign(comp, node_head, ASSIGN_STORE);
         }
     }
     for (uint i = 0; i < num_tail; i++) {
         if (num_head + i == have_star_index) {
-            c_assign(comp, ((mp_parse_node_struct_t*)nodes_tail[i])->nodes[0], ASSIGN_STORE);
+            c_assign(comp, ((mp_parse_node_struct_t *)nodes_tail[i])->nodes[0], ASSIGN_STORE);
         } else {
             c_assign(comp, nodes_tail[i], ASSIGN_STORE);
         }
@@ -509,7 +513,7 @@ STATIC void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t assign_
         }
     } else {
         // pn must be a struct
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
         switch (MP_PARSE_NODE_STRUCT_KIND(pns)) {
             case PN_atom_expr_normal:
                 // lhs is an index or attribute
@@ -535,7 +539,7 @@ STATIC void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t assign_
                     if (assign_kind != ASSIGN_STORE) {
                         goto cannot_assign;
                     }
-                    pns = (mp_parse_node_struct_t*)pns->nodes[0];
+                    pns = (mp_parse_node_struct_t *)pns->nodes[0];
                     goto testlist_comp;
                 }
                 break;
@@ -549,7 +553,7 @@ STATIC void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t assign_
                     // empty list, assignment allowed
                     c_assign_tuple(comp, MP_PARSE_NODE_NULL, 0, NULL);
                 } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
-                    pns = (mp_parse_node_struct_t*)pns->nodes[0];
+                    pns = (mp_parse_node_struct_t *)pns->nodes[0];
                     goto testlist_comp;
                 } else {
                     // brackets around 1 item
@@ -562,10 +566,10 @@ STATIC void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t assign_
         }
         return;
 
-        testlist_comp:
+    testlist_comp:
         // lhs is a sequence
         if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
-            mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[1];
+            mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)pns->nodes[1];
             if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {
                 // sequence of one item, with trailing comma
                 assert(MP_PARSE_NODE_IS_NULL(pns2->nodes[0]));
@@ -582,15 +586,15 @@ STATIC void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t assign_
             }
         } else {
             // sequence with 2 items
-            sequence_with_2_items:
+        sequence_with_2_items:
             c_assign_tuple(comp, MP_PARSE_NODE_NULL, 2, pns->nodes);
         }
         return;
     }
     return;
 
-    cannot_assign:
-    compile_syntax_error(comp, pn, "can't assign to expression");
+cannot_assign:
+    compile_syntax_error(comp, pn, MP_ERROR_TEXT("can't assign to expression"));
 }
 
 // stuff for lambda and comprehensions and generators:
@@ -646,7 +650,7 @@ STATIC void compile_funcdef_lambdef_param(compiler_t *comp, mp_parse_node_t pn)
         pn_kind = -1;
     } else {
         assert(MP_PARSE_NODE_IS_STRUCT(pn));
-        pn_kind = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t*)pn);
+        pn_kind = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn);
     }
 
     if (pn_kind == PN_typedargslist_star || pn_kind == PN_varargslist_star) {
@@ -676,16 +680,16 @@ STATIC void compile_funcdef_lambdef_param(compiler_t *comp, mp_parse_node_t pn)
         } else if (pn_kind == PN_typedargslist_name) {
             // this parameter has a colon and/or equal specifier
 
-            mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+            mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
             pn_id = pns->nodes[0];
-            //pn_colon = pns->nodes[1]; // unused
+            // pn_colon = pns->nodes[1]; // unused
             pn_equal = pns->nodes[2];
 
         } else {
             assert(pn_kind == PN_varargslist_name); // should be
             // this parameter has an equal specifier
 
-            mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+            mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
             pn_id = pns->nodes[0];
             pn_equal = pns->nodes[1];
         }
@@ -695,7 +699,7 @@ STATIC void compile_funcdef_lambdef_param(compiler_t *comp, mp_parse_node_t pn)
 
             // check for non-default parameters given after default parameters (allowed by parser, but not syntactically valid)
             if (!comp->have_star && comp->num_default_params != 0) {
-                compile_syntax_error(comp, pn, "non-default argument follows default argument");
+                compile_syntax_error(comp, pn, MP_ERROR_TEXT("non-default argument follows default argument"));
                 return;
             }
 
@@ -775,7 +779,7 @@ STATIC qstr compile_funcdef_helper(compiler_t *comp, mp_parse_node_struct_t *pns
     }
 
     // get the scope for this function
-    scope_t *fscope = (scope_t*)pns->nodes[4];
+    scope_t *fscope = (scope_t *)pns->nodes[4];
 
     // compile the function definition
     compile_funcdef_lambdef(comp, fscope, pns->nodes[1], PN_typedargslist);
@@ -797,7 +801,7 @@ STATIC qstr compile_classdef_helper(compiler_t *comp, mp_parse_node_struct_t *pn
     EMIT(load_build_class);
 
     // scope for this class
-    scope_t *cscope = (scope_t*)pns->nodes[3];
+    scope_t *cscope = (scope_t *)pns->nodes[3];
 
     // compile the class
     close_over_variables_etc(comp, cscope, 0, 0);
@@ -818,26 +822,26 @@ STATIC qstr compile_classdef_helper(compiler_t *comp, mp_parse_node_struct_t *pn
 }
 
 // returns true if it was a built-in decorator (even if the built-in had an error)
-STATIC bool compile_built_in_decorator(compiler_t *comp, int name_len, mp_parse_node_t *name_nodes, uint *emit_options) {
+STATIC bool compile_built_in_decorator(compiler_t *comp, size_t name_len, mp_parse_node_t *name_nodes, uint *emit_options) {
     if (MP_PARSE_NODE_LEAF_ARG(name_nodes[0]) != MP_QSTR_micropython) {
         return false;
     }
 
     if (name_len != 2) {
-        compile_syntax_error(comp, name_nodes[0], "invalid micropython decorator");
+        compile_syntax_error(comp, name_nodes[0], MP_ERROR_TEXT("invalid micropython decorator"));
         return true;
     }
 
     qstr attr = MP_PARSE_NODE_LEAF_ARG(name_nodes[1]);
     if (attr == MP_QSTR_bytecode) {
         *emit_options = MP_EMIT_OPT_BYTECODE;
-#if MICROPY_EMIT_NATIVE
+    #if MICROPY_EMIT_NATIVE
     } else if (attr == MP_QSTR_native) {
         *emit_options = MP_EMIT_OPT_NATIVE_PYTHON;
     } else if (attr == MP_QSTR_viper) {
         *emit_options = MP_EMIT_OPT_VIPER;
-#endif
-    #if MICROPY_EMIT_INLINE_ASM
+    #endif
+        #if MICROPY_EMIT_INLINE_ASM
     #if MICROPY_DYNAMIC_COMPILER
     } else if (attr == MP_QSTR_asm_thumb) {
         *emit_options = MP_EMIT_OPT_ASM;
@@ -847,19 +851,19 @@ STATIC bool compile_built_in_decorator(compiler_t *comp, int name_len, mp_parse_
     } else if (attr == ASM_DECORATOR_QSTR) {
         *emit_options = MP_EMIT_OPT_ASM;
     #endif
-    #endif
+        #endif
     } else {
-        compile_syntax_error(comp, name_nodes[1], "invalid micropython decorator");
+        compile_syntax_error(comp, name_nodes[1], MP_ERROR_TEXT("invalid micropython decorator"));
     }
 
     #if MICROPY_DYNAMIC_COMPILER
     if (*emit_options == MP_EMIT_OPT_NATIVE_PYTHON || *emit_options == MP_EMIT_OPT_VIPER) {
         if (emit_native_table[mp_dynamic_compiler.native_arch] == NULL) {
-            compile_syntax_error(comp, name_nodes[1], "invalid arch");
+            compile_syntax_error(comp, name_nodes[1], MP_ERROR_TEXT("invalid arch"));
         }
     } else if (*emit_options == MP_EMIT_OPT_ASM) {
         if (emit_asm_table[mp_dynamic_compiler.native_arch] == NULL) {
-            compile_syntax_error(comp, name_nodes[1], "invalid arch");
+            compile_syntax_error(comp, name_nodes[1], MP_ERROR_TEXT("invalid arch"));
         }
     }
     #endif
@@ -870,20 +874,20 @@ STATIC bool compile_built_in_decorator(compiler_t *comp, int name_len, mp_parse_
 STATIC void compile_decorated(compiler_t *comp, mp_parse_node_struct_t *pns) {
     // get the list of decorators
     mp_parse_node_t *nodes;
-    int n = mp_parse_node_extract_list(&pns->nodes[0], PN_decorators, &nodes);
+    size_t n = mp_parse_node_extract_list(&pns->nodes[0], PN_decorators, &nodes);
 
     // inherit emit options for this function/class definition
     uint emit_options = comp->scope_cur->emit_options;
 
     // compile each decorator
-    int num_built_in_decorators = 0;
-    for (int i = 0; i < n; i++) {
+    size_t num_built_in_decorators = 0;
+    for (size_t i = 0; i < n; i++) {
         assert(MP_PARSE_NODE_IS_STRUCT_KIND(nodes[i], PN_decorator)); // should be
-        mp_parse_node_struct_t *pns_decorator = (mp_parse_node_struct_t*)nodes[i];
+        mp_parse_node_struct_t *pns_decorator = (mp_parse_node_struct_t *)nodes[i];
 
         // nodes[0] contains the decorator function, which is a dotted name
         mp_parse_node_t *name_nodes;
-        int name_len = mp_parse_node_extract_list(&pns_decorator->nodes[0], PN_dotted_name, &name_nodes);
+        size_t name_len = mp_parse_node_extract_list(&pns_decorator->nodes[0], PN_dotted_name, &name_nodes);
 
         // check for built-in decorators
         if (compile_built_in_decorator(comp, name_len, name_nodes, &emit_options)) {
@@ -895,7 +899,7 @@ STATIC void compile_decorated(compiler_t *comp, mp_parse_node_struct_t *pns) {
 
             // compile the decorator function
             compile_node(comp, name_nodes[0]);
-            for (int j = 1; j < name_len; j++) {
+            for (size_t j = 1; j < name_len; j++) {
                 assert(MP_PARSE_NODE_IS_ID(name_nodes[j])); // should be
                 EMIT_ARG(attr, MP_PARSE_NODE_LEAF_ARG(name_nodes[j]), MP_EMIT_ATTR_LOAD);
             }
@@ -909,16 +913,16 @@ STATIC void compile_decorated(compiler_t *comp, mp_parse_node_struct_t *pns) {
     }
 
     // compile the body (funcdef, async funcdef or classdef) and get its name
-    mp_parse_node_struct_t *pns_body = (mp_parse_node_struct_t*)pns->nodes[1];
+    mp_parse_node_struct_t *pns_body = (mp_parse_node_struct_t *)pns->nodes[1];
     qstr body_name = 0;
     if (MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_funcdef) {
         body_name = compile_funcdef_helper(comp, pns_body, emit_options);
     #if MICROPY_PY_ASYNC_AWAIT
     } else if (MP_PARSE_NODE_STRUCT_KIND(pns_body) == PN_async_funcdef) {
         assert(MP_PARSE_NODE_IS_STRUCT(pns_body->nodes[0]));
-        mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t*)pns_body->nodes[0];
+        mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t *)pns_body->nodes[0];
         body_name = compile_funcdef_helper(comp, pns0, emit_options);
-        scope_t *fscope = (scope_t*)pns0->nodes[4];
+        scope_t *fscope = (scope_t *)pns0->nodes[4];
         fscope->scope_flags |= MP_SCOPE_FLAG_GENERATOR;
     #endif
     } else {
@@ -927,7 +931,7 @@ STATIC void compile_decorated(compiler_t *comp, mp_parse_node_struct_t *pns) {
     }
 
     // call each decorator
-    for (int i = 0; i < n - num_built_in_decorators; i++) {
+    for (size_t i = 0; i < n - num_built_in_decorators; i++) {
         EMIT_ARG(call_function, 1, 0, 0);
     }
 
@@ -945,19 +949,19 @@ STATIC void c_del_stmt(compiler_t *comp, mp_parse_node_t pn) {
     if (MP_PARSE_NODE_IS_ID(pn)) {
         compile_delete_id(comp, MP_PARSE_NODE_LEAF_ARG(pn));
     } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_atom_expr_normal)) {
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
 
         compile_node(comp, pns->nodes[0]); // base of the atom_expr_normal node
 
         if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
-            mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
+            mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
             if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_atom_expr_trailers) {
                 int n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns1);
                 for (int i = 0; i < n - 1; i++) {
                     compile_node(comp, pns1->nodes[i]);
                 }
                 assert(MP_PARSE_NODE_IS_STRUCT(pns1->nodes[n - 1]));
-                pns1 = (mp_parse_node_struct_t*)pns1->nodes[n - 1];
+                pns1 = (mp_parse_node_struct_t *)pns1->nodes[n - 1];
             }
             if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_trailer_bracket) {
                 compile_node(comp, pns1->nodes[0]);
@@ -973,16 +977,16 @@ STATIC void c_del_stmt(compiler_t *comp, mp_parse_node_t pn) {
         }
 
     } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_atom_paren)) {
-        pn = ((mp_parse_node_struct_t*)pn)->nodes[0];
+        pn = ((mp_parse_node_struct_t *)pn)->nodes[0];
         if (MP_PARSE_NODE_IS_NULL(pn)) {
             goto cannot_delete;
         } else {
             assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_testlist_comp));
-            mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+            mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
             // TODO perhaps factorise testlist_comp code with other uses of PN_testlist_comp
 
             if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
-                mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
+                mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
                 if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_testlist_comp_3b) {
                     // sequence of one item, with trailing comma
                     assert(MP_PARSE_NODE_IS_NULL(pns1->nodes[0]));
@@ -1002,7 +1006,7 @@ STATIC void c_del_stmt(compiler_t *comp, mp_parse_node_t pn) {
                 }
             } else {
                 // sequence with 2 items
-                sequence_with_2_items:
+            sequence_with_2_items:
                 c_del_stmt(comp, pns->nodes[0]);
                 c_del_stmt(comp, pns->nodes[1]);
             }
@@ -1015,7 +1019,7 @@ STATIC void c_del_stmt(compiler_t *comp, mp_parse_node_t pn) {
     return;
 
 cannot_delete:
-    compile_syntax_error(comp, (mp_parse_node_t)pn, "can't delete expression");
+    compile_syntax_error(comp, (mp_parse_node_t)pn, MP_ERROR_TEXT("can't delete expression"));
 }
 
 STATIC void compile_del_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
@@ -1024,34 +1028,33 @@ STATIC void compile_del_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
 
 STATIC void compile_break_cont_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
     uint16_t label;
-    const char *error_msg;
     if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_break_stmt) {
         label = comp->break_label;
-        error_msg = "'break' outside loop";
     } else {
         label = comp->continue_label;
-        error_msg = "'continue' outside loop";
     }
     if (label == INVALID_LABEL) {
-        compile_syntax_error(comp, (mp_parse_node_t)pns, error_msg);
+        compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("'break'/'continue' outside loop"));
     }
     assert(comp->cur_except_level >= comp->break_continue_except_level);
     EMIT_ARG(unwind_jump, label, comp->cur_except_level - comp->break_continue_except_level);
 }
 
 STATIC void compile_return_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
+    #if MICROPY_CPYTHON_COMPAT
     if (comp->scope_cur->kind != SCOPE_FUNCTION) {
-        compile_syntax_error(comp, (mp_parse_node_t)pns, "'return' outside function");
+        compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("'return' outside function"));
         return;
     }
+    #endif
     if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
         // no argument to 'return', so return None
         EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
     } else if (MICROPY_COMP_RETURN_IF_EXPR
-        && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_test_if_expr)) {
+               && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_test_if_expr)) {
         // special case when returning an if-expression; to match CPython optimisation
-        mp_parse_node_struct_t *pns_test_if_expr = (mp_parse_node_struct_t*)pns->nodes[0];
-        mp_parse_node_struct_t *pns_test_if_else = (mp_parse_node_struct_t*)pns_test_if_expr->nodes[1];
+        mp_parse_node_struct_t *pns_test_if_expr = (mp_parse_node_struct_t *)pns->nodes[0];
+        mp_parse_node_struct_t *pns_test_if_else = (mp_parse_node_struct_t *)pns_test_if_expr->nodes[1];
 
         uint l_fail = comp_next_label(comp);
         c_if_cond(comp, pns_test_if_else->nodes[0], false, l_fail); // condition
@@ -1076,7 +1079,7 @@ STATIC void compile_raise_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
         EMIT_ARG(raise_varargs, 0);
     } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_raise_stmt_arg)) {
         // raise x from y
-        pns = (mp_parse_node_struct_t*)pns->nodes[0];
+        pns = (mp_parse_node_struct_t *)pns->nodes[0];
         compile_node(comp, pns->nodes[0]);
         compile_node(comp, pns->nodes[1]);
         EMIT_ARG(raise_varargs, 2);
@@ -1093,7 +1096,7 @@ STATIC void compile_raise_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
 STATIC void do_import_name(compiler_t *comp, mp_parse_node_t pn, qstr *q_base) {
     bool is_as = false;
     if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dotted_as_name)) {
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
         // a name of the form x as y; unwrap it
         *q_base = MP_PARSE_NODE_LEAF_ARG(pns->nodes[1]);
         pn = pns->nodes[0];
@@ -1112,7 +1115,7 @@ STATIC void do_import_name(compiler_t *comp, mp_parse_node_t pn, qstr *q_base) {
         EMIT_ARG(import, q_full, MP_EMIT_IMPORT_NAME);
     } else {
         assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_dotted_name)); // should be
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
         {
             // a name of the form a.b.c
             if (!is_as) {
@@ -1171,7 +1174,7 @@ STATIC void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) {
             pn_import_source = MP_PARSE_NODE_NULL;
         } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn_import_source, PN_import_from_2b)) {
             // This covers relative imports starting with dot(s) like "from .foo import"
-            mp_parse_node_struct_t *pns_2b = (mp_parse_node_struct_t*)pn_import_source;
+            mp_parse_node_struct_t *pns_2b = (mp_parse_node_struct_t *)pn_import_source;
             pn_rel = pns_2b->nodes[0];
             pn_import_source = pns_2b->nodes[1];
             assert(!MP_PARSE_NODE_IS_NULL(pn_import_source)); // should not be
@@ -1182,10 +1185,10 @@ STATIC void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) {
 
         // get the list of . and/or ...'s
         mp_parse_node_t *nodes;
-        int n = mp_parse_node_extract_list(&pn_rel, PN_one_or_more_period_or_ellipsis, &nodes);
+        size_t n = mp_parse_node_extract_list(&pn_rel, PN_one_or_more_period_or_ellipsis, &nodes);
 
         // count the total number of .'s
-        for (int i = 0; i < n; i++) {
+        for (size_t i = 0; i < n; i++) {
             if (MP_PARSE_NODE_IS_TOKEN_KIND(nodes[i], MP_TOKEN_DEL_PERIOD)) {
                 import_level++;
             } else {
@@ -1196,6 +1199,13 @@ STATIC void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) {
     } while (0);
 
     if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_STAR)) {
+        #if MICROPY_CPYTHON_COMPAT
+        if (comp->scope_cur->kind != SCOPE_MODULE) {
+            compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("import * not at module level"));
+            return;
+        }
+        #endif
+
         EMIT_ARG(load_const_small_int, import_level);
 
         // build the "fromlist" tuple
@@ -1205,17 +1215,17 @@ STATIC void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) {
         // do the import
         qstr dummy_q;
         do_import_name(comp, pn_import_source, &dummy_q);
-        EMIT_ARG(import, MP_QSTR_NULL, MP_EMIT_IMPORT_STAR);
+        EMIT_ARG(import, MP_QSTRnull, MP_EMIT_IMPORT_STAR);
 
     } else {
         EMIT_ARG(load_const_small_int, import_level);
 
         // build the "fromlist" tuple
         mp_parse_node_t *pn_nodes;
-        int n = mp_parse_node_extract_list(&pns->nodes[1], PN_import_as_names, &pn_nodes);
-        for (int i = 0; i < n; i++) {
+        size_t n = mp_parse_node_extract_list(&pns->nodes[1], PN_import_as_names, &pn_nodes);
+        for (size_t i = 0; i < n; i++) {
             assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
-            mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pn_nodes[i];
+            mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t *)pn_nodes[i];
             qstr id2 = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
             EMIT_ARG(load_const_str, id2);
         }
@@ -1224,9 +1234,9 @@ STATIC void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) {
         // do the import
         qstr dummy_q;
         do_import_name(comp, pn_import_source, &dummy_q);
-        for (int i = 0; i < n; i++) {
+        for (size_t i = 0; i < n; i++) {
             assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_nodes[i], PN_import_as_name));
-            mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pn_nodes[i];
+            mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t *)pn_nodes[i];
             qstr id2 = MP_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
             EMIT_ARG(import, id2, MP_EMIT_IMPORT_FROM);
             if (MP_PARSE_NODE_IS_NULL(pns3->nodes[1])) {
@@ -1241,7 +1251,7 @@ STATIC void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) {
 
 STATIC void compile_declare_global(compiler_t *comp, mp_parse_node_t pn, id_info_t *id_info) {
     if (id_info->kind != ID_INFO_KIND_UNDECIDED && id_info->kind != ID_INFO_KIND_GLOBAL_EXPLICIT) {
-        compile_syntax_error(comp, pn, "identifier redefined as global");
+        compile_syntax_error(comp, pn, MP_ERROR_TEXT("identifier redefined as global"));
         return;
     }
     id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
@@ -1258,10 +1268,10 @@ STATIC void compile_declare_nonlocal(compiler_t *comp, mp_parse_node_t pn, id_in
         id_info->kind = ID_INFO_KIND_GLOBAL_IMPLICIT;
         scope_check_to_close_over(comp->scope_cur, id_info);
         if (id_info->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
-            compile_syntax_error(comp, pn, "no binding for nonlocal found");
+            compile_syntax_error(comp, pn, MP_ERROR_TEXT("no binding for nonlocal found"));
         }
     } else if (id_info->kind != ID_INFO_KIND_FREE) {
-        compile_syntax_error(comp, pn, "identifier redefined as nonlocal");
+        compile_syntax_error(comp, pn, MP_ERROR_TEXT("identifier redefined as nonlocal"));
     }
 }
 
@@ -1270,13 +1280,13 @@ STATIC void compile_global_nonlocal_stmt(compiler_t *comp, mp_parse_node_struct_
         bool is_global = MP_PARSE_NODE_STRUCT_KIND(pns) == PN_global_stmt;
 
         if (!is_global && comp->scope_cur->kind == SCOPE_MODULE) {
-            compile_syntax_error(comp, (mp_parse_node_t)pns, "can't declare nonlocal in outer code");
+            compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("can't declare nonlocal in outer code"));
             return;
         }
 
         mp_parse_node_t *nodes;
-        int n = mp_parse_node_extract_list(&pns->nodes[0], PN_name_list, &nodes);
-        for (int i = 0; i < n; i++) {
+        size_t n = mp_parse_node_extract_list(&pns->nodes[0], PN_name_list, &nodes);
+        for (size_t i = 0; i < n; i++) {
             qstr qst = MP_PARSE_NODE_LEAF_ARG(nodes[i]);
             id_info_t *id_info = scope_find_or_add_id(comp->scope_cur, qst, ID_INFO_KIND_UNDECIDED);
             if (is_global) {
@@ -1336,10 +1346,10 @@ STATIC void compile_if_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
 
     // compile elif blocks (if any)
     mp_parse_node_t *pn_elif;
-    int n_elif = mp_parse_node_extract_list(&pns->nodes[2], PN_if_stmt_elif_list, &pn_elif);
-    for (int i = 0; i < n_elif; i++) {
+    size_t n_elif = mp_parse_node_extract_list(&pns->nodes[2], PN_if_stmt_elif_list, &pn_elif);
+    for (size_t i = 0; i < n_elif; i++) {
         assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_elif[i], PN_if_stmt_elif)); // should be
-        mp_parse_node_struct_t *pns_elif = (mp_parse_node_struct_t*)pn_elif[i];
+        mp_parse_node_struct_t *pns_elif = (mp_parse_node_struct_t *)pn_elif[i];
 
         // optimisation: don't emit anything when "if False"
         if (!mp_parse_node_is_const_false(pns_elif->nodes[0])) {
@@ -1508,13 +1518,13 @@ STATIC void compile_for_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
     // this is actually slower, but uses no heap memory
     // for viper it will be much, much faster
     if (/*comp->scope_cur->emit_options == MP_EMIT_OPT_VIPER &&*/ MP_PARSE_NODE_IS_ID(pns->nodes[0]) && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_atom_expr_normal)) {
-        mp_parse_node_struct_t *pns_it = (mp_parse_node_struct_t*)pns->nodes[1];
+        mp_parse_node_struct_t *pns_it = (mp_parse_node_struct_t *)pns->nodes[1];
         if (MP_PARSE_NODE_IS_ID(pns_it->nodes[0])
             && MP_PARSE_NODE_LEAF_ARG(pns_it->nodes[0]) == MP_QSTR_range
-            && MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t*)pns_it->nodes[1]) == PN_trailer_paren) {
-            mp_parse_node_t pn_range_args = ((mp_parse_node_struct_t*)pns_it->nodes[1])->nodes[0];
+            && MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pns_it->nodes[1]) == PN_trailer_paren) {
+            mp_parse_node_t pn_range_args = ((mp_parse_node_struct_t *)pns_it->nodes[1])->nodes[0];
             mp_parse_node_t *args;
-            int n_args = mp_parse_node_extract_list(&pn_range_args, PN_arglist, &args);
+            size_t n_args = mp_parse_node_extract_list(&pn_range_args, PN_arglist, &args);
             mp_parse_node_t pn_range_start;
             mp_parse_node_t pn_range_end;
             mp_parse_node_t pn_range_step;
@@ -1541,13 +1551,13 @@ STATIC void compile_for_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
                 }
                 // arguments must be able to be compiled as standard expressions
                 if (optimize && MP_PARSE_NODE_IS_STRUCT(pn_range_start)) {
-                    int k = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t*)pn_range_start);
+                    int k = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn_range_start);
                     if (k == PN_arglist_star || k == PN_arglist_dbl_star || k == PN_argument) {
                         optimize = false;
                     }
                 }
                 if (optimize && MP_PARSE_NODE_IS_STRUCT(pn_range_end)) {
-                    int k = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t*)pn_range_end);
+                    int k = MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn_range_end);
                     if (k == PN_arglist_star || k == PN_arglist_dbl_star || k == PN_argument) {
                         optimize = false;
                     }
@@ -1604,15 +1614,18 @@ STATIC void compile_try_except(compiler_t *comp, mp_parse_node_t pn_body, int n_
 
     for (int i = 0; i < n_except; i++) {
         assert(MP_PARSE_NODE_IS_STRUCT_KIND(pn_excepts[i], PN_try_stmt_except)); // should be
-        mp_parse_node_struct_t *pns_except = (mp_parse_node_struct_t*)pn_excepts[i];
+        mp_parse_node_struct_t *pns_except = (mp_parse_node_struct_t *)pn_excepts[i];
 
         qstr qstr_exception_local = 0;
         uint end_finally_label = comp_next_label(comp);
+        #if MICROPY_PY_SYS_SETTRACE
+        EMIT_ARG(set_source_line, pns_except->source_line);
+        #endif
 
         if (MP_PARSE_NODE_IS_NULL(pns_except->nodes[0])) {
             // this is a catch all exception handler
             if (i + 1 != n_except) {
-                compile_syntax_error(comp, pn_excepts[i], "default 'except' must be last");
+                compile_syntax_error(comp, pn_excepts[i], MP_ERROR_TEXT("default 'except' must be last"));
                 compile_decrease_except_level(comp);
                 return;
             }
@@ -1620,7 +1633,7 @@ STATIC void compile_try_except(compiler_t *comp, mp_parse_node_t pn_body, int n_
             // this exception handler requires a match to a certain type of exception
             mp_parse_node_t pns_exception_expr = pns_except->nodes[0];
             if (MP_PARSE_NODE_IS_STRUCT(pns_exception_expr)) {
-                mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pns_exception_expr;
+                mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t *)pns_exception_expr;
                 if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_try_stmt_as_name) {
                     // handler binds the exception to a local
                     pns_exception_expr = pns3->nodes[0];
@@ -1700,31 +1713,31 @@ STATIC void compile_try_finally(compiler_t *comp, mp_parse_node_t pn_body, int n
 STATIC void compile_try_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
     assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should be
     {
-        mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[1];
+        mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)pns->nodes[1];
         if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_try_stmt_finally) {
             // just try-finally
             compile_try_finally(comp, pns->nodes[0], 0, NULL, MP_PARSE_NODE_NULL, pns2->nodes[0]);
         } else if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_try_stmt_except_and_more) {
             // try-except and possibly else and/or finally
             mp_parse_node_t *pn_excepts;
-            int n_except = mp_parse_node_extract_list(&pns2->nodes[0], PN_try_stmt_except_list, &pn_excepts);
+            size_t n_except = mp_parse_node_extract_list(&pns2->nodes[0], PN_try_stmt_except_list, &pn_excepts);
             if (MP_PARSE_NODE_IS_NULL(pns2->nodes[2])) {
                 // no finally
                 compile_try_except(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1]);
             } else {
                 // have finally
-                compile_try_finally(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1], ((mp_parse_node_struct_t*)pns2->nodes[2])->nodes[0]);
+                compile_try_finally(comp, pns->nodes[0], n_except, pn_excepts, pns2->nodes[1], ((mp_parse_node_struct_t *)pns2->nodes[2])->nodes[0]);
             }
         } else {
             // just try-except
             mp_parse_node_t *pn_excepts;
-            int n_except = mp_parse_node_extract_list(&pns->nodes[1], PN_try_stmt_except_list, &pn_excepts);
+            size_t n_except = mp_parse_node_extract_list(&pns->nodes[1], PN_try_stmt_except_list, &pn_excepts);
             compile_try_except(comp, pns->nodes[0], n_except, pn_excepts, MP_PARSE_NODE_NULL);
         }
     }
 }
 
-STATIC void compile_with_stmt_helper(compiler_t *comp, int n, mp_parse_node_t *nodes, mp_parse_node_t body) {
+STATIC void compile_with_stmt_helper(compiler_t *comp, size_t n, mp_parse_node_t *nodes, mp_parse_node_t body) {
     if (n == 0) {
         // no more pre-bits, compile the body of the with
         compile_node(comp, body);
@@ -1732,7 +1745,7 @@ STATIC void compile_with_stmt_helper(compiler_t *comp, int n, mp_parse_node_t *n
         uint l_end = comp_next_label(comp);
         if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes[0], PN_with_item)) {
             // this pre-bit is of the form "a as b"
-            mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)nodes[0];
+            mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)nodes[0];
             compile_node(comp, pns->nodes[0]);
             compile_increase_except_level(comp, l_end, MP_EMIT_SETUP_BLOCK_WITH);
             c_assign(comp, pns->nodes[1], ASSIGN_STORE);
@@ -1754,7 +1767,7 @@ STATIC void compile_with_stmt_helper(compiler_t *comp, int n, mp_parse_node_t *n
 STATIC void compile_with_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
     // get the nodes for the pre-bit of the with (the a as b, c as d, ... bit)
     mp_parse_node_t *nodes;
-    int n = mp_parse_node_extract_list(&pns->nodes[0], PN_with_stmt_list, &nodes);
+    size_t n = mp_parse_node_extract_list(&pns->nodes[0], PN_with_stmt_list, &nodes);
     assert(n > 0);
 
     // compile in a nested fashion
@@ -1826,7 +1839,7 @@ STATIC void compile_async_for_stmt(compiler_t *comp, mp_parse_node_struct_t *pns
     EMIT_ARG(label_assign, break_label);
 }
 
-STATIC void compile_async_with_stmt_helper(compiler_t *comp, int n, mp_parse_node_t *nodes, mp_parse_node_t body) {
+STATIC void compile_async_with_stmt_helper(compiler_t *comp, size_t n, mp_parse_node_t *nodes, mp_parse_node_t body) {
     if (n == 0) {
         // no more pre-bits, compile the body of the with
         compile_node(comp, body);
@@ -1838,7 +1851,7 @@ STATIC void compile_async_with_stmt_helper(compiler_t *comp, int n, mp_parse_nod
 
         if (MP_PARSE_NODE_IS_STRUCT_KIND(nodes[0], PN_with_item)) {
             // this pre-bit is of the form "a as b"
-            mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)nodes[0];
+            mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)nodes[0];
             compile_node(comp, pns->nodes[0]);
             EMIT(dup_top);
             compile_await_object_method(comp, MP_QSTR___aenter__);
@@ -1941,7 +1954,7 @@ STATIC void compile_async_with_stmt_helper(compiler_t *comp, int n, mp_parse_nod
 STATIC void compile_async_with_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
     // get the nodes for the pre-bit of the with (the a as b, c as d, ... bit)
     mp_parse_node_t *nodes;
-    int n = mp_parse_node_extract_list(&pns->nodes[0], PN_with_stmt_list, &nodes);
+    size_t n = mp_parse_node_extract_list(&pns->nodes[0], PN_with_stmt_list, &nodes);
     assert(n > 0);
 
     // compile in a nested fashion
@@ -1950,11 +1963,11 @@ STATIC void compile_async_with_stmt(compiler_t *comp, mp_parse_node_struct_t *pn
 
 STATIC void compile_async_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
     assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[0]));
-    mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t*)pns->nodes[0];
+    mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t *)pns->nodes[0];
     if (MP_PARSE_NODE_STRUCT_KIND(pns0) == PN_funcdef) {
         // async def
         compile_funcdef(comp, pns0);
-        scope_t *fscope = (scope_t*)pns0->nodes[4];
+        scope_t *fscope = (scope_t *)pns0->nodes[4];
         fscope->scope_flags |= MP_SCOPE_FLAG_GENERATOR;
     } else if (MP_PARSE_NODE_STRUCT_KIND(pns0) == PN_for_stmt) {
         // async for
@@ -1987,27 +2000,14 @@ STATIC void compile_expr_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
             }
         }
     } else if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
-        mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
+        mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
         int kind = MP_PARSE_NODE_STRUCT_KIND(pns1);
         if (kind == PN_expr_stmt_augassign) {
             c_assign(comp, pns->nodes[0], ASSIGN_AUG_LOAD); // lhs load for aug assign
             compile_node(comp, pns1->nodes[1]); // rhs
             assert(MP_PARSE_NODE_IS_TOKEN(pns1->nodes[0]));
-            mp_binary_op_t op;
-            switch (MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0])) {
-                case MP_TOKEN_DEL_PIPE_EQUAL: op = MP_BINARY_OP_INPLACE_OR; break;
-                case MP_TOKEN_DEL_CARET_EQUAL: op = MP_BINARY_OP_INPLACE_XOR; break;
-                case MP_TOKEN_DEL_AMPERSAND_EQUAL: op = MP_BINARY_OP_INPLACE_AND; break;
-                case MP_TOKEN_DEL_DBL_LESS_EQUAL: op = MP_BINARY_OP_INPLACE_LSHIFT; break;
-                case MP_TOKEN_DEL_DBL_MORE_EQUAL: op = MP_BINARY_OP_INPLACE_RSHIFT; break;
-                case MP_TOKEN_DEL_PLUS_EQUAL: op = MP_BINARY_OP_INPLACE_ADD; break;
-                case MP_TOKEN_DEL_MINUS_EQUAL: op = MP_BINARY_OP_INPLACE_SUBTRACT; break;
-                case MP_TOKEN_DEL_STAR_EQUAL: op = MP_BINARY_OP_INPLACE_MULTIPLY; break;
-                case MP_TOKEN_DEL_DBL_SLASH_EQUAL: op = MP_BINARY_OP_INPLACE_FLOOR_DIVIDE; break;
-                case MP_TOKEN_DEL_SLASH_EQUAL: op = MP_BINARY_OP_INPLACE_TRUE_DIVIDE; break;
-                case MP_TOKEN_DEL_PERCENT_EQUAL: op = MP_BINARY_OP_INPLACE_MODULO; break;
-                case MP_TOKEN_DEL_DBL_STAR_EQUAL: default: op = MP_BINARY_OP_INPLACE_POWER; break;
-            }
+            mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]);
+            mp_binary_op_t op = MP_BINARY_OP_INPLACE_OR + (tok - MP_TOKEN_DEL_PIPE_EQUAL);
             EMIT_ARG(binary_op, op);
             c_assign(comp, pns->nodes[0], ASSIGN_AUG_STORE); // lhs store for aug assign
         } else if (kind == PN_expr_stmt_assign_list) {
@@ -2029,8 +2029,8 @@ STATIC void compile_expr_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
             #if MICROPY_COMP_DOUBLE_TUPLE_ASSIGN
             if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_testlist_star_expr)
                 && MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_star_expr)) {
-                mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t*)pns->nodes[0];
-                pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
+                mp_parse_node_struct_t *pns0 = (mp_parse_node_struct_t *)pns->nodes[0];
+                pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
                 uint32_t n_pns0 = MP_PARSE_NODE_STRUCT_NUM_NODES(pns0);
                 // Can only optimise a tuple-to-tuple assignment when all of the following hold:
                 //  - equal number of items in LHS and RHS tuples
@@ -2080,7 +2080,7 @@ STATIC void compile_expr_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
 
 STATIC void compile_test_if_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
     assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_test_if_else));
-    mp_parse_node_struct_t *pns_test_if_else = (mp_parse_node_struct_t*)pns->nodes[1];
+    mp_parse_node_struct_t *pns_test_if_else = (mp_parse_node_struct_t *)pns->nodes[1];
 
     uint l_fail = comp_next_label(comp);
     uint l_end = comp_next_label(comp);
@@ -2102,7 +2102,7 @@ STATIC void compile_lambdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
     }
 
     // get the scope for this lambda
-    scope_t *this_scope = (scope_t*)pns->nodes[2];
+    scope_t *this_scope = (scope_t *)pns->nodes[2];
 
     // compile the lambda definition
     compile_funcdef_lambdef(comp, this_scope, pns->nodes[0], PN_varargslist);
@@ -2141,20 +2141,17 @@ STATIC void compile_comparison(compiler_t *comp, mp_parse_node_struct_t *pns) {
             EMIT(rot_three);
         }
         if (MP_PARSE_NODE_IS_TOKEN(pns->nodes[i])) {
+            mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]);
             mp_binary_op_t op;
-            switch (MP_PARSE_NODE_LEAF_ARG(pns->nodes[i])) {
-                case MP_TOKEN_OP_LESS: op = MP_BINARY_OP_LESS; break;
-                case MP_TOKEN_OP_MORE: op = MP_BINARY_OP_MORE; break;
-                case MP_TOKEN_OP_DBL_EQUAL: op = MP_BINARY_OP_EQUAL; break;
-                case MP_TOKEN_OP_LESS_EQUAL: op = MP_BINARY_OP_LESS_EQUAL; break;
-                case MP_TOKEN_OP_MORE_EQUAL: op = MP_BINARY_OP_MORE_EQUAL; break;
-                case MP_TOKEN_OP_NOT_EQUAL: op = MP_BINARY_OP_NOT_EQUAL; break;
-                case MP_TOKEN_KW_IN: default: op = MP_BINARY_OP_IN; break;
+            if (tok == MP_TOKEN_KW_IN) {
+                op = MP_BINARY_OP_IN;
+            } else {
+                op = MP_BINARY_OP_LESS + (tok - MP_TOKEN_OP_LESS);
             }
             EMIT_ARG(binary_op, op);
         } else {
             assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[i])); // should be
-            mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[i];
+            mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)pns->nodes[i];
             int kind = MP_PARSE_NODE_STRUCT_KIND(pns2);
             if (kind == PN_comp_op_not_in) {
                 EMIT_ARG(binary_op, MP_BINARY_OP_NOT_IN);
@@ -2183,7 +2180,7 @@ STATIC void compile_comparison(compiler_t *comp, mp_parse_node_struct_t *pns) {
 }
 
 STATIC void compile_star_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
-    compile_syntax_error(comp, (mp_parse_node_t)pns, "*x must be assignment target");
+    compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("*x must be assignment target"));
 }
 
 STATIC void compile_binary_op(compiler_t *comp, mp_parse_node_struct_t *pns) {
@@ -2203,36 +2200,21 @@ STATIC void compile_term(compiler_t *comp, mp_parse_node_struct_t *pns) {
     compile_node(comp, pns->nodes[0]);
     for (int i = 1; i + 1 < num_nodes; i += 2) {
         compile_node(comp, pns->nodes[i + 1]);
-        mp_binary_op_t op;
         mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(pns->nodes[i]);
-        switch (tok) {
-            case MP_TOKEN_OP_PLUS:      op = MP_BINARY_OP_ADD; break;
-            case MP_TOKEN_OP_MINUS:     op = MP_BINARY_OP_SUBTRACT; break;
-            case MP_TOKEN_OP_STAR:      op = MP_BINARY_OP_MULTIPLY; break;
-            case MP_TOKEN_OP_DBL_SLASH: op = MP_BINARY_OP_FLOOR_DIVIDE; break;
-            case MP_TOKEN_OP_SLASH:     op = MP_BINARY_OP_TRUE_DIVIDE; break;
-            case MP_TOKEN_OP_PERCENT:   op = MP_BINARY_OP_MODULO; break;
-            case MP_TOKEN_OP_DBL_LESS:  op = MP_BINARY_OP_LSHIFT; break;
-            default:
-                assert(tok == MP_TOKEN_OP_DBL_MORE);
-                op = MP_BINARY_OP_RSHIFT;
-                break;
-        }
+        mp_binary_op_t op = MP_BINARY_OP_LSHIFT + (tok - MP_TOKEN_OP_DBL_LESS);
         EMIT_ARG(binary_op, op);
     }
 }
 
 STATIC void compile_factor_2(compiler_t *comp, mp_parse_node_struct_t *pns) {
     compile_node(comp, pns->nodes[1]);
-    mp_unary_op_t op;
     mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
-    switch (tok) {
-        case MP_TOKEN_OP_PLUS:  op = MP_UNARY_OP_POSITIVE; break;
-        case MP_TOKEN_OP_MINUS: op = MP_UNARY_OP_NEGATIVE; break;
-        default:
-            assert(tok == MP_TOKEN_OP_TILDE);
-            op = MP_UNARY_OP_INVERT;
-            break;
+    mp_unary_op_t op;
+    if (tok == MP_TOKEN_OP_TILDE) {
+        op = MP_UNARY_OP_INVERT;
+    } else {
+        assert(tok == MP_TOKEN_OP_PLUS || tok == MP_TOKEN_OP_MINUS);
+        op = MP_UNARY_OP_POSITIVE + (tok - MP_TOKEN_OP_PLUS);
     }
     EMIT_ARG(unary_op, op);
 }
@@ -2248,10 +2230,10 @@ STATIC void compile_atom_expr_normal(compiler_t *comp, mp_parse_node_struct_t *p
 
     // get the array of trailers (known to be an array of PARSE_NODE_STRUCT)
     size_t num_trail = 1;
-    mp_parse_node_struct_t **pns_trail = (mp_parse_node_struct_t**)&pns->nodes[1];
+    mp_parse_node_struct_t **pns_trail = (mp_parse_node_struct_t **)&pns->nodes[1];
     if (MP_PARSE_NODE_STRUCT_KIND(pns_trail[0]) == PN_atom_expr_trailers) {
         num_trail = MP_PARSE_NODE_STRUCT_NUM_NODES(pns_trail[0]);
-        pns_trail = (mp_parse_node_struct_t**)&pns_trail[0]->nodes[0];
+        pns_trail = (mp_parse_node_struct_t **)&pns_trail[0]->nodes[0];
     }
 
     // the current index into the array of trailers
@@ -2281,7 +2263,7 @@ STATIC void compile_atom_expr_normal(compiler_t *comp, mp_parse_node_struct_t *p
         }
         if (!found) {
             compile_syntax_error(comp, (mp_parse_node_t)pns_trail[0],
-                "super() can't find self"); // really a TypeError
+                MP_ERROR_TEXT("super() can't find self")); // really a TypeError
             return;
         }
 
@@ -2300,19 +2282,19 @@ STATIC void compile_atom_expr_normal(compiler_t *comp, mp_parse_node_struct_t *p
             i = 1;
         }
 
-    #if MICROPY_COMP_CONST_LITERAL && MICROPY_PY_COLLECTIONS_ORDEREDDICT
-    // handle special OrderedDict constructor
+        #if MICROPY_COMP_CONST_LITERAL && MICROPY_PY_COLLECTIONS_ORDEREDDICT
+        // handle special OrderedDict constructor
     } else if (MP_PARSE_NODE_IS_ID(pns->nodes[0])
-        && MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]) == MP_QSTR_OrderedDict
-        && MP_PARSE_NODE_STRUCT_KIND(pns_trail[0]) == PN_trailer_paren
-        && MP_PARSE_NODE_IS_STRUCT_KIND(pns_trail[0]->nodes[0], PN_atom_brace)) {
+               && MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]) == MP_QSTR_OrderedDict
+               && MP_PARSE_NODE_STRUCT_KIND(pns_trail[0]) == PN_trailer_paren
+               && MP_PARSE_NODE_IS_STRUCT_KIND(pns_trail[0]->nodes[0], PN_atom_brace)) {
         // at this point we have matched "OrderedDict({...})"
 
         EMIT_ARG(call_function, 0, 0, 0);
-        mp_parse_node_struct_t *pns_dict = (mp_parse_node_struct_t*)pns_trail[0]->nodes[0];
+        mp_parse_node_struct_t *pns_dict = (mp_parse_node_struct_t *)pns_trail[0]->nodes[0];
         compile_atom_brace_helper(comp, pns_dict, false);
         i = 1;
-    #endif
+        #endif
     }
 
     // compile the remaining trailers
@@ -2343,7 +2325,7 @@ STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_ar
 
     // get the list of arguments
     mp_parse_node_t *args;
-    int n_args = mp_parse_node_extract_list(&pn_arglist, PN_arglist, &args);
+    size_t n_args = mp_parse_node_extract_list(&pn_arglist, PN_arglist, &args);
 
     // compile the arguments
     // Rather than calling compile_node on the list, we go through the list of args
@@ -2353,19 +2335,19 @@ STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_ar
     uint n_keyword = 0;
     uint star_flags = 0;
     mp_parse_node_struct_t *star_args_node = NULL, *dblstar_args_node = NULL;
-    for (int i = 0; i < n_args; i++) {
+    for (size_t i = 0; i < n_args; i++) {
         if (MP_PARSE_NODE_IS_STRUCT(args[i])) {
-            mp_parse_node_struct_t *pns_arg = (mp_parse_node_struct_t*)args[i];
+            mp_parse_node_struct_t *pns_arg = (mp_parse_node_struct_t *)args[i];
             if (MP_PARSE_NODE_STRUCT_KIND(pns_arg) == PN_arglist_star) {
                 if (star_flags & MP_EMIT_STAR_FLAG_SINGLE) {
-                    compile_syntax_error(comp, (mp_parse_node_t)pns_arg, "can't have multiple *x");
+                    compile_syntax_error(comp, (mp_parse_node_t)pns_arg, MP_ERROR_TEXT("can't have multiple *x"));
                     return;
                 }
                 star_flags |= MP_EMIT_STAR_FLAG_SINGLE;
                 star_args_node = pns_arg;
             } else if (MP_PARSE_NODE_STRUCT_KIND(pns_arg) == PN_arglist_dbl_star) {
                 if (star_flags & MP_EMIT_STAR_FLAG_DOUBLE) {
-                    compile_syntax_error(comp, (mp_parse_node_t)pns_arg, "can't have multiple **x");
+                    compile_syntax_error(comp, (mp_parse_node_t)pns_arg, MP_ERROR_TEXT("can't have multiple **x"));
                     return;
                 }
                 star_flags |= MP_EMIT_STAR_FLAG_DOUBLE;
@@ -2373,7 +2355,7 @@ STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_ar
             } else if (MP_PARSE_NODE_STRUCT_KIND(pns_arg) == PN_argument) {
                 if (!MP_PARSE_NODE_IS_STRUCT_KIND(pns_arg->nodes[1], PN_comp_for)) {
                     if (!MP_PARSE_NODE_IS_ID(pns_arg->nodes[0])) {
-                        compile_syntax_error(comp, (mp_parse_node_t)pns_arg, "LHS of keyword arg must be an id");
+                        compile_syntax_error(comp, (mp_parse_node_t)pns_arg, MP_ERROR_TEXT("LHS of keyword arg must be an id"));
                         return;
                     }
                     EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pns_arg->nodes[0]));
@@ -2387,13 +2369,13 @@ STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_ar
                 goto normal_argument;
             }
         } else {
-            normal_argument:
+        normal_argument:
             if (star_flags) {
-                compile_syntax_error(comp, args[i], "non-keyword arg after */**");
+                compile_syntax_error(comp, args[i], MP_ERROR_TEXT("non-keyword arg after */**"));
                 return;
             }
             if (n_keyword > 0) {
-                compile_syntax_error(comp, args[i], "non-keyword arg after keyword arg");
+                compile_syntax_error(comp, args[i], MP_ERROR_TEXT("non-keyword arg after keyword arg"));
                 return;
             }
             compile_node(comp, args[i]);
@@ -2428,7 +2410,7 @@ STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_ar
 STATIC void compile_comprehension(compiler_t *comp, mp_parse_node_struct_t *pns, scope_kind_t kind) {
     assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
     assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
-    mp_parse_node_struct_t *pns_comp_for = (mp_parse_node_struct_t*)pns->nodes[1];
+    mp_parse_node_struct_t *pns_comp_for = (mp_parse_node_struct_t *)pns->nodes[1];
 
     if (comp->pass == MP_PASS_SCOPE) {
         // create a new scope for this comprehension
@@ -2438,7 +2420,7 @@ STATIC void compile_comprehension(compiler_t *comp, mp_parse_node_struct_t *pns,
     }
 
     // get the scope for this comprehension
-    scope_t *this_scope = (scope_t*)pns_comp_for->nodes[3];
+    scope_t *this_scope = (scope_t *)pns_comp_for->nodes[3];
 
     // compile the comprehension
     close_over_variables_etc(comp, this_scope, 0, 0);
@@ -2456,10 +2438,10 @@ STATIC void compile_atom_paren(compiler_t *comp, mp_parse_node_struct_t *pns) {
         c_tuple(comp, MP_PARSE_NODE_NULL, NULL);
     } else {
         assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp));
-        pns = (mp_parse_node_struct_t*)pns->nodes[0];
+        pns = (mp_parse_node_struct_t *)pns->nodes[0];
         assert(!MP_PARSE_NODE_IS_NULL(pns->nodes[1]));
         if (MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])) {
-            mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[1];
+            mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)pns->nodes[1];
             if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_testlist_comp_3b) {
                 // tuple of one item, with trailing comma
                 assert(MP_PARSE_NODE_IS_NULL(pns2->nodes[0]));
@@ -2476,7 +2458,7 @@ STATIC void compile_atom_paren(compiler_t *comp, mp_parse_node_struct_t *pns) {
             }
         } else {
             // tuple with 2 items
-            tuple_with_2_items:
+        tuple_with_2_items:
             c_tuple(comp, MP_PARSE_NODE_NULL, pns);
         }
     }
@@ -2487,9 +2469,9 @@ STATIC void compile_atom_bracket(compiler_t *comp, mp_parse_node_struct_t *pns)
         // empty list
         EMIT_ARG(build, 0, MP_EMIT_BUILD_LIST);
     } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
-        mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)pns->nodes[0];
+        mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)pns->nodes[0];
         if (MP_PARSE_NODE_IS_STRUCT(pns2->nodes[1])) {
-            mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t*)pns2->nodes[1];
+            mp_parse_node_struct_t *pns3 = (mp_parse_node_struct_t *)pns2->nodes[1];
             if (MP_PARSE_NODE_STRUCT_KIND(pns3) == PN_testlist_comp_3b) {
                 // list of one item, with trailing comma
                 assert(MP_PARSE_NODE_IS_NULL(pns3->nodes[0]));
@@ -2509,7 +2491,7 @@ STATIC void compile_atom_bracket(compiler_t *comp, mp_parse_node_struct_t *pns)
             }
         } else {
             // list with 2 items
-            list_with_2_items:
+        list_with_2_items:
             compile_node(comp, pns2->nodes[0]);
             compile_node(comp, pns2->nodes[1]);
             EMIT_ARG(build, 2, MP_EMIT_BUILD_LIST);
@@ -2529,7 +2511,7 @@ STATIC void compile_atom_brace_helper(compiler_t *comp, mp_parse_node_struct_t *
             EMIT_ARG(build, 0, MP_EMIT_BUILD_MAP);
         }
     } else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
-        pns = (mp_parse_node_struct_t*)pn;
+        pns = (mp_parse_node_struct_t *)pn;
         if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker_item) {
             // dict with one element
             if (create_map) {
@@ -2539,13 +2521,13 @@ STATIC void compile_atom_brace_helper(compiler_t *comp, mp_parse_node_struct_t *
             EMIT(store_map);
         } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker) {
             assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should succeed
-            mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
+            mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
             if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_dictorsetmaker_list) {
                 // dict/set with multiple elements
 
                 // get tail elements (2nd, 3rd, ...)
                 mp_parse_node_t *nodes;
-                int n = mp_parse_node_extract_list(&pns1->nodes[0], PN_dictorsetmaker_list2, &nodes);
+                size_t n = mp_parse_node_extract_list(&pns1->nodes[0], PN_dictorsetmaker_list2, &nodes);
 
                 // first element sets whether it's a dict or set
                 bool is_dict;
@@ -2564,27 +2546,27 @@ STATIC void compile_atom_brace_helper(compiler_t *comp, mp_parse_node_struct_t *
                 }
 
                 // process rest of elements
-                for (int i = 0; i < n; i++) {
+                for (size_t i = 0; i < n; i++) {
                     mp_parse_node_t pn_i = nodes[i];
                     bool is_key_value = MP_PARSE_NODE_IS_STRUCT_KIND(pn_i, PN_dictorsetmaker_item);
                     compile_node(comp, pn_i);
                     if (is_dict) {
                         if (!is_key_value) {
-                            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                                compile_syntax_error(comp, (mp_parse_node_t)pns, "invalid syntax");
-                            } else {
-                                compile_syntax_error(comp, (mp_parse_node_t)pns, "expecting key:value for dict");
-                            }
+                            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                            compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("invalid syntax"));
+                            #else
+                            compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("expecting key:value for dict"));
+                            #endif
                             return;
                         }
                         EMIT(store_map);
                     } else {
                         if (is_key_value) {
-                            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                                compile_syntax_error(comp, (mp_parse_node_t)pns, "invalid syntax");
-                            } else {
-                                compile_syntax_error(comp, (mp_parse_node_t)pns, "expecting just a value for set");
-                            }
+                            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                            compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("invalid syntax"));
+                            #else
+                            compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("expecting just a value for set"));
+                            #endif
                             return;
                         }
                     }
@@ -2613,7 +2595,7 @@ STATIC void compile_atom_brace_helper(compiler_t *comp, mp_parse_node_struct_t *
         }
     } else {
         // set with one element
-        set_with_one_element:
+    set_with_one_element:
         #if MICROPY_PY_BUILTINS_SET
         compile_node(comp, pn);
         EMIT_ARG(build, 1, MP_EMIT_BUILD_SET);
@@ -2647,7 +2629,7 @@ STATIC void compile_subscript(compiler_t *comp, mp_parse_node_struct_t *pns) {
     if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_2) {
         compile_node(comp, pns->nodes[0]); // start of slice
         assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
-        pns = (mp_parse_node_struct_t*)pns->nodes[1];
+        pns = (mp_parse_node_struct_t *)pns->nodes[1];
     } else {
         // pns is a PN_subscript_3, load None for start of slice
         EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
@@ -2660,7 +2642,7 @@ STATIC void compile_subscript(compiler_t *comp, mp_parse_node_struct_t *pns) {
         EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
         EMIT_ARG(build, 2, MP_EMIT_BUILD_SLICE);
     } else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
-        pns = (mp_parse_node_struct_t*)pn;
+        pns = (mp_parse_node_struct_t *)pn;
         if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3c) {
             EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
             pn = pns->nodes[0];
@@ -2675,7 +2657,7 @@ STATIC void compile_subscript(compiler_t *comp, mp_parse_node_struct_t *pns) {
         } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_subscript_3d) {
             compile_node(comp, pns->nodes[0]);
             assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should always be
-            pns = (mp_parse_node_struct_t*)pns->nodes[1];
+            pns = (mp_parse_node_struct_t *)pns->nodes[1];
             assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_sliceop); // should always be
             if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
                 // [?:x:]
@@ -2712,7 +2694,7 @@ STATIC void compile_classdef(compiler_t *comp, mp_parse_node_struct_t *pns) {
 
 STATIC void compile_yield_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
     if (comp->scope_cur->kind != SCOPE_FUNCTION && comp->scope_cur->kind != SCOPE_LAMBDA) {
-        compile_syntax_error(comp, (mp_parse_node_t)pns, "'yield' outside function");
+        compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("'yield' outside function"));
         return;
     }
     if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
@@ -2720,7 +2702,7 @@ STATIC void compile_yield_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
         EMIT_ARG(yield, MP_EMIT_YIELD_VALUE);
         reserve_labels_for_native(comp, 1);
     } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_yield_arg_from)) {
-        pns = (mp_parse_node_struct_t*)pns->nodes[0];
+        pns = (mp_parse_node_struct_t *)pns->nodes[0];
         compile_node(comp, pns->nodes[0]);
         compile_yield_from(comp);
     } else {
@@ -2733,7 +2715,7 @@ STATIC void compile_yield_expr(compiler_t *comp, mp_parse_node_struct_t *pns) {
 #if MICROPY_PY_ASYNC_AWAIT
 STATIC void compile_atom_expr_await(compiler_t *comp, mp_parse_node_struct_t *pns) {
     if (comp->scope_cur->kind != SCOPE_FUNCTION && comp->scope_cur->kind != SCOPE_LAMBDA) {
-        compile_syntax_error(comp, (mp_parse_node_t)pns, "'await' outside function");
+        compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("'await' outside function"));
         return;
     }
     compile_atom_expr_normal(comp, pns);
@@ -2754,13 +2736,13 @@ STATIC void compile_const_object(compiler_t *comp, mp_parse_node_struct_t *pns)
     EMIT_ARG(load_const_obj, get_const_object(pns));
 }
 
-typedef void (*compile_function_t)(compiler_t*, mp_parse_node_struct_t*);
+typedef void (*compile_function_t)(compiler_t *, mp_parse_node_struct_t *);
 STATIC const compile_function_t compile_function[] = {
 // only define rules with a compile function
 #define c(f) compile_##f
 #define DEF_RULE(rule, comp, kind, ...) comp,
 #define DEF_RULE_NC(rule, kind, ...)
-#include "py/grammar.h"
+    #include "py/grammar.h"
 #undef c
 #undef DEF_RULE
 #undef DEF_RULE_NC
@@ -2792,8 +2774,12 @@ STATIC void compile_node(compiler_t *comp, mp_parse_node_t pn) {
     } else if (MP_PARSE_NODE_IS_LEAF(pn)) {
         uintptr_t arg = MP_PARSE_NODE_LEAF_ARG(pn);
         switch (MP_PARSE_NODE_LEAF_KIND(pn)) {
-            case MP_PARSE_NODE_ID: compile_load_id(comp, arg); break;
-            case MP_PARSE_NODE_STRING: EMIT_ARG(load_const_str, arg); break;
+            case MP_PARSE_NODE_ID:
+                compile_load_id(comp, arg);
+                break;
+            case MP_PARSE_NODE_STRING:
+                EMIT_ARG(load_const_str, arg);
+                break;
             case MP_PARSE_NODE_BYTES:
                 // only create and load the actual bytes object on the last pass
                 if (comp->pass != MP_PASS_EMIT) {
@@ -2804,18 +2790,19 @@ STATIC void compile_node(compiler_t *comp, mp_parse_node_t pn) {
                     EMIT_ARG(load_const_obj, mp_obj_new_bytes(data, len));
                 }
                 break;
-            case MP_PARSE_NODE_TOKEN: default:
+            case MP_PARSE_NODE_TOKEN:
+            default:
                 if (arg == MP_TOKEN_NEWLINE) {
                     // this can occur when file_input lets through a NEWLINE (eg if file starts with a newline)
                     // or when single_input lets through a NEWLINE (user enters a blank line)
                     // do nothing
                 } else {
-                  EMIT_ARG(load_const_tok, arg);
+                    EMIT_ARG(load_const_tok, arg);
                 }
                 break;
         }
     } else {
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
         EMIT_ARG(set_source_line, pns->source_line);
         assert(MP_PARSE_NODE_STRUCT_KIND(pns) <= PN_const_object);
         compile_function_t f = compile_function[MP_PARSE_NODE_STRUCT_KIND(pns)];
@@ -2832,11 +2819,11 @@ STATIC int compile_viper_type_annotation(compiler_t *comp, mp_parse_node_t pn_an
         qstr type_name = MP_PARSE_NODE_LEAF_ARG(pn_annotation);
         native_type = mp_native_type_from_qstr(type_name);
         if (native_type < 0) {
-            comp->compile_error = mp_obj_new_exception_msg_varg(&mp_type_ViperTypeError, "unknown type '%q'", type_name);
+            comp->compile_error = mp_obj_new_exception_msg_varg(&mp_type_ViperTypeError, MP_ERROR_TEXT("unknown type '%q'"), type_name);
             native_type = 0;
         }
     } else {
-        compile_syntax_error(comp, pn_annotation, "annotation must be an identifier");
+        compile_syntax_error(comp, pn_annotation, MP_ERROR_TEXT("annotation must be an identifier"));
     }
     return native_type;
 }
@@ -2847,11 +2834,11 @@ STATIC void compile_scope_func_lambda_param(compiler_t *comp, mp_parse_node_t pn
 
     // check that **kw is last
     if ((comp->scope_cur->scope_flags & MP_SCOPE_FLAG_VARKEYWORDS) != 0) {
-        compile_syntax_error(comp, pn, "invalid syntax");
+        compile_syntax_error(comp, pn, MP_ERROR_TEXT("invalid syntax"));
         return;
     }
 
-    qstr param_name = MP_QSTR_NULL;
+    qstr param_name = MP_QSTRnull;
     uint param_flag = ID_FLAG_IS_PARAM;
     mp_parse_node_struct_t *pns = NULL;
     if (MP_PARSE_NODE_IS_ID(pn)) {
@@ -2865,7 +2852,7 @@ STATIC void compile_scope_func_lambda_param(compiler_t *comp, mp_parse_node_t pn
         }
     } else {
         assert(MP_PARSE_NODE_IS_STRUCT(pn));
-        pns = (mp_parse_node_struct_t*)pn;
+        pns = (mp_parse_node_struct_t *)pn;
         if (MP_PARSE_NODE_STRUCT_KIND(pns) == pn_name) {
             // named parameter with possible annotation
             param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
@@ -2879,7 +2866,7 @@ STATIC void compile_scope_func_lambda_param(compiler_t *comp, mp_parse_node_t pn
         } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == pn_star) {
             if (comp->have_star) {
                 // more than one star
-                compile_syntax_error(comp, pn, "invalid syntax");
+                compile_syntax_error(comp, pn, MP_ERROR_TEXT("invalid syntax"));
                 return;
             }
             comp->have_star = true;
@@ -2887,7 +2874,7 @@ STATIC void compile_scope_func_lambda_param(compiler_t *comp, mp_parse_node_t pn
             if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) {
                 // bare star
                 // TODO see http://www.python.org/dev/peps/pep-3102/
-                //assert(comp->scope_cur->num_dict_params == 0);
+                // assert(comp->scope_cur->num_dict_params == 0);
                 pns = NULL;
             } else if (MP_PARSE_NODE_IS_ID(pns->nodes[0])) {
                 // named star
@@ -2898,7 +2885,7 @@ STATIC void compile_scope_func_lambda_param(compiler_t *comp, mp_parse_node_t pn
                 assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_tfpdef)); // should be
                 // named star with possible annotation
                 comp->scope_cur->scope_flags |= MP_SCOPE_FLAG_VARARGS;
-                pns = (mp_parse_node_struct_t*)pns->nodes[0];
+                pns = (mp_parse_node_struct_t *)pns->nodes[0];
                 param_name = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]);
             }
         } else {
@@ -2910,10 +2897,10 @@ STATIC void compile_scope_func_lambda_param(compiler_t *comp, mp_parse_node_t pn
         }
     }
 
-    if (param_name != MP_QSTR_NULL) {
+    if (param_name != MP_QSTRnull) {
         id_info_t *id_info = scope_find_or_add_id(comp->scope_cur, param_name, ID_INFO_KIND_UNDECIDED);
         if (id_info->kind != ID_INFO_KIND_UNDECIDED) {
-            compile_syntax_error(comp, pn, "argument name reused");
+            compile_syntax_error(comp, pn, MP_ERROR_TEXT("argument name reused"));
             return;
         }
         id_info->kind = ID_INFO_KIND_LOCAL;
@@ -2945,7 +2932,7 @@ STATIC void compile_scope_comp_iter(compiler_t *comp, mp_parse_node_struct_t *pn
     c_assign(comp, pns_comp_for->nodes[0], ASSIGN_STORE);
     mp_parse_node_t pn_iter = pns_comp_for->nodes[2];
 
-    tail_recursion:
+tail_recursion:
     if (MP_PARSE_NODE_IS_NULL(pn_iter)) {
         // no more nested if/for; compile inner expression
         compile_node(comp, pn_inner_expr);
@@ -2956,16 +2943,16 @@ STATIC void compile_scope_comp_iter(compiler_t *comp, mp_parse_node_struct_t *pn
         } else {
             EMIT_ARG(store_comp, comp->scope_cur->kind, 4 * for_depth + 5);
         }
-    } else if (MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t*)pn_iter) == PN_comp_if) {
+    } else if (MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn_iter) == PN_comp_if) {
         // if condition
-        mp_parse_node_struct_t *pns_comp_if = (mp_parse_node_struct_t*)pn_iter;
+        mp_parse_node_struct_t *pns_comp_if = (mp_parse_node_struct_t *)pn_iter;
         c_if_cond(comp, pns_comp_if->nodes[0], false, l_top);
         pn_iter = pns_comp_if->nodes[1];
         goto tail_recursion;
     } else {
-        assert(MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t*)pn_iter) == PN_comp_for); // should be
+        assert(MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)pn_iter) == PN_comp_for); // should be
         // for loop
-        mp_parse_node_struct_t *pns_comp_for2 = (mp_parse_node_struct_t*)pn_iter;
+        mp_parse_node_struct_t *pns_comp_for2 = (mp_parse_node_struct_t *)pn_iter;
         compile_node(comp, pns_comp_for2->nodes[1]);
         EMIT_ARG(get_iter, true);
         compile_scope_comp_iter(comp, pns_comp_for2, pn_inner_expr, for_depth + 1);
@@ -2977,7 +2964,7 @@ STATIC void compile_scope_comp_iter(compiler_t *comp, mp_parse_node_struct_t *pn
 }
 
 STATIC void check_for_doc_string(compiler_t *comp, mp_parse_node_t pn) {
-#if MICROPY_ENABLE_DOC_STRING
+    #if MICROPY_ENABLE_DOC_STRING
     // see http://www.python.org/dev/peps/pep-0257/
 
     // look for the first statement
@@ -2985,7 +2972,7 @@ STATIC void check_for_doc_string(compiler_t *comp, mp_parse_node_t pn) {
         // a statement; fall through
     } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_file_input_2)) {
         // file input; find the first non-newline node
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
         int num_nodes = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
         for (int i = 0; i < num_nodes; i++) {
             pn = pns->nodes[i];
@@ -2997,28 +2984,28 @@ STATIC void check_for_doc_string(compiler_t *comp, mp_parse_node_t pn) {
         // if we didn't find a non-newline then it's okay to fall through; pn will be a newline and so doc-string test below will fail gracefully
     } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_suite_block_stmts)) {
         // a list of statements; get the first one
-        pn = ((mp_parse_node_struct_t*)pn)->nodes[0];
+        pn = ((mp_parse_node_struct_t *)pn)->nodes[0];
     } else {
         return;
     }
 
     // check the first statement for a doc string
     if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_expr_stmt)) {
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
         if ((MP_PARSE_NODE_IS_LEAF(pns->nodes[0])
-                && MP_PARSE_NODE_LEAF_KIND(pns->nodes[0]) == MP_PARSE_NODE_STRING)
+             && MP_PARSE_NODE_LEAF_KIND(pns->nodes[0]) == MP_PARSE_NODE_STRING)
             || (MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_const_object)
-                && mp_obj_is_str(get_const_object((mp_parse_node_struct_t*)pns->nodes[0])))) {
-                // compile the doc string
-                compile_node(comp, pns->nodes[0]);
-                // store the doc string
-                compile_store_id(comp, MP_QSTR___doc__);
+                && mp_obj_is_str(get_const_object((mp_parse_node_struct_t *)pns->nodes[0])))) {
+            // compile the doc string
+            compile_node(comp, pns->nodes[0]);
+            // store the doc string
+            compile_store_id(comp, MP_QSTR___doc__);
         }
     }
-#else
+    #else
     (void)comp;
     (void)pn;
-#endif
+    #endif
 }
 
 STATIC void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
@@ -3038,7 +3025,7 @@ STATIC void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
     // compile
     if (MP_PARSE_NODE_IS_STRUCT_KIND(scope->pn, PN_eval_input)) {
         assert(scope->kind == SCOPE_MODULE);
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
         compile_node(comp, pns->nodes[0]); // compile the expression
         EMIT(return_value);
     } else if (scope->kind == SCOPE_MODULE) {
@@ -3050,7 +3037,7 @@ STATIC void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
         EMIT(return_value);
     } else if (scope->kind == SCOPE_FUNCTION) {
         assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
         assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_funcdef);
 
         // work out number of parameters, keywords and default parameters, and add them to the id_info array
@@ -3075,9 +3062,12 @@ STATIC void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
         }
     } else if (scope->kind == SCOPE_LAMBDA) {
         assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
         assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 3);
 
+        // Set the source line number for the start of the lambda
+        EMIT_ARG(set_source_line, pns->source_line);
+
         // work out number of parameters, keywords and default parameters, and add them to the id_info array
         // must be done before compiling the body so that arguments are numbered first (for LOAD_FAST etc)
         if (comp->pass == MP_PASS_SCOPE) {
@@ -3097,10 +3087,10 @@ STATIC void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
         // a bit of a hack at the moment
 
         assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
         assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 2);
         assert(MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[1], PN_comp_for));
-        mp_parse_node_struct_t *pns_comp_for = (mp_parse_node_struct_t*)pns->nodes[1];
+        mp_parse_node_struct_t *pns_comp_for = (mp_parse_node_struct_t *)pns->nodes[1];
 
         // We need a unique name for the comprehension argument (the iterator).
         // CPython uses .0, but we should be able to use anything that won't
@@ -3112,6 +3102,9 @@ STATIC void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
             scope->num_pos_args = 1;
         }
 
+        // Set the source line number for the start of the comprehension
+        EMIT_ARG(set_source_line, pns->source_line);
+
         if (scope->kind == SCOPE_LIST_COMP) {
             EMIT_ARG(build, 0, MP_EMIT_BUILD_LIST);
         } else if (scope->kind == SCOPE_DICT_COMP) {
@@ -3144,13 +3137,16 @@ STATIC void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
     } else {
         assert(scope->kind == SCOPE_CLASS);
         assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
         assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_classdef);
 
         if (comp->pass == MP_PASS_SCOPE) {
             scope_find_or_add_id(scope, MP_QSTR___class__, ID_INFO_KIND_LOCAL);
         }
 
+        #if MICROPY_PY_SYS_SETTRACE
+        EMIT_ARG(set_source_line, pns->source_line);
+        #endif
         compile_load_id(comp, MP_QSTR___name__);
         compile_store_id(comp, MP_QSTR___module__);
         EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pns->nodes[0])); // 0 is class name
@@ -3183,7 +3179,7 @@ STATIC void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind
     comp->next_label = 0;
 
     if (scope->kind != SCOPE_FUNCTION) {
-        compile_syntax_error(comp, MP_PARSE_NODE_NULL, "inline assembler must be a function");
+        compile_syntax_error(comp, MP_PARSE_NODE_NULL, MP_ERROR_TEXT("inline assembler must be a function"));
         return;
     }
 
@@ -3193,15 +3189,15 @@ STATIC void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind
 
     // get the function definition parse node
     assert(MP_PARSE_NODE_IS_STRUCT(scope->pn));
-    mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)scope->pn;
+    mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)scope->pn;
     assert(MP_PARSE_NODE_STRUCT_KIND(pns) == PN_funcdef);
 
-    //qstr f_id = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]); // function name
+    // qstr f_id = MP_PARSE_NODE_LEAF_ARG(pns->nodes[0]); // function name
 
     // parameters are in pns->nodes[1]
     if (comp->pass == MP_PASS_CODE_SIZE) {
         mp_parse_node_t *pn_params;
-        int n_params = mp_parse_node_extract_list(&pns->nodes[1], PN_typedargslist, &pn_params);
+        size_t n_params = mp_parse_node_extract_list(&pns->nodes[1], PN_typedargslist, &pn_params);
         scope->num_pos_args = EMIT_INLINE_ASM_ARG(count_params, n_params, pn_params);
         if (comp->compile_error != MP_OBJ_NULL) {
             goto inline_asm_error;
@@ -3216,31 +3212,41 @@ STATIC void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind
         if (MP_PARSE_NODE_IS_ID(pn_annotation)) {
             qstr ret_type = MP_PARSE_NODE_LEAF_ARG(pn_annotation);
             switch (ret_type) {
-                case MP_QSTR_object: type_sig = MP_NATIVE_TYPE_OBJ; break;
-                case MP_QSTR_bool: type_sig = MP_NATIVE_TYPE_BOOL; break;
-                case MP_QSTR_int: type_sig = MP_NATIVE_TYPE_INT; break;
-                case MP_QSTR_uint: type_sig = MP_NATIVE_TYPE_UINT; break;
-                default: compile_syntax_error(comp, pn_annotation, "unknown type"); return;
+                case MP_QSTR_object:
+                    type_sig = MP_NATIVE_TYPE_OBJ;
+                    break;
+                case MP_QSTR_bool:
+                    type_sig = MP_NATIVE_TYPE_BOOL;
+                    break;
+                case MP_QSTR_int:
+                    type_sig = MP_NATIVE_TYPE_INT;
+                    break;
+                case MP_QSTR_uint:
+                    type_sig = MP_NATIVE_TYPE_UINT;
+                    break;
+                default:
+                    compile_syntax_error(comp, pn_annotation, MP_ERROR_TEXT("unknown type"));
+                    return;
             }
         } else {
-            compile_syntax_error(comp, pn_annotation, "return annotation must be an identifier");
+            compile_syntax_error(comp, pn_annotation, MP_ERROR_TEXT("return annotation must be an identifier"));
         }
     }
 
     mp_parse_node_t pn_body = pns->nodes[3]; // body
     mp_parse_node_t *nodes;
-    int num = mp_parse_node_extract_list(&pn_body, PN_suite_block_stmts, &nodes);
+    size_t num = mp_parse_node_extract_list(&pn_body, PN_suite_block_stmts, &nodes);
 
-    for (int i = 0; i < num; i++) {
+    for (size_t i = 0; i < num; i++) {
         assert(MP_PARSE_NODE_IS_STRUCT(nodes[i]));
-        mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t*)nodes[i];
+        mp_parse_node_struct_t *pns2 = (mp_parse_node_struct_t *)nodes[i];
         if (MP_PARSE_NODE_STRUCT_KIND(pns2) == PN_pass_stmt) {
             // no instructions
             continue;
         } else if (MP_PARSE_NODE_STRUCT_KIND(pns2) != PN_expr_stmt) {
             // not an instruction; error
         not_an_instruction:
-            compile_syntax_error(comp, nodes[i], "expecting an assembler instruction");
+            compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("expecting an assembler instruction"));
             return;
         }
 
@@ -3249,7 +3255,7 @@ STATIC void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind
         if (!MP_PARSE_NODE_IS_NULL(pns2->nodes[1])) {
             goto not_an_instruction;
         }
-        pns2 = (mp_parse_node_struct_t*)pns2->nodes[0];
+        pns2 = (mp_parse_node_struct_t *)pns2->nodes[0];
         if (MP_PARSE_NODE_STRUCT_KIND(pns2) != PN_atom_expr_normal) {
             goto not_an_instruction;
         }
@@ -3263,45 +3269,45 @@ STATIC void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind
         // parse node looks like an instruction
         // get instruction name and args
         qstr op = MP_PARSE_NODE_LEAF_ARG(pns2->nodes[0]);
-        pns2 = (mp_parse_node_struct_t*)pns2->nodes[1]; // PN_trailer_paren
+        pns2 = (mp_parse_node_struct_t *)pns2->nodes[1]; // PN_trailer_paren
         mp_parse_node_t *pn_arg;
-        int n_args = mp_parse_node_extract_list(&pns2->nodes[0], PN_arglist, &pn_arg);
+        size_t n_args = mp_parse_node_extract_list(&pns2->nodes[0], PN_arglist, &pn_arg);
 
         // emit instructions
         if (op == MP_QSTR_label) {
             if (!(n_args == 1 && MP_PARSE_NODE_IS_ID(pn_arg[0]))) {
-                compile_syntax_error(comp, nodes[i], "'label' requires 1 argument");
+                compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("'label' requires 1 argument"));
                 return;
             }
             uint lab = comp_next_label(comp);
             if (pass > MP_PASS_SCOPE) {
                 if (!EMIT_INLINE_ASM_ARG(label, lab, MP_PARSE_NODE_LEAF_ARG(pn_arg[0]))) {
-                    compile_syntax_error(comp, nodes[i], "label redefined");
+                    compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("label redefined"));
                     return;
                 }
             }
         } else if (op == MP_QSTR_align) {
             if (!(n_args == 1 && MP_PARSE_NODE_IS_SMALL_INT(pn_arg[0]))) {
-                compile_syntax_error(comp, nodes[i], "'align' requires 1 argument");
+                compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("'align' requires 1 argument"));
                 return;
             }
             if (pass > MP_PASS_SCOPE) {
-                mp_asm_base_align((mp_asm_base_t*)comp->emit_inline_asm,
+                mp_asm_base_align((mp_asm_base_t *)comp->emit_inline_asm,
                     MP_PARSE_NODE_LEAF_SMALL_INT(pn_arg[0]));
             }
         } else if (op == MP_QSTR_data) {
             if (!(n_args >= 2 && MP_PARSE_NODE_IS_SMALL_INT(pn_arg[0]))) {
-                compile_syntax_error(comp, nodes[i], "'data' requires at least 2 arguments");
+                compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("'data' requires at least 2 arguments"));
                 return;
             }
             if (pass > MP_PASS_SCOPE) {
                 mp_int_t bytesize = MP_PARSE_NODE_LEAF_SMALL_INT(pn_arg[0]);
                 for (uint j = 1; j < n_args; j++) {
                     if (!MP_PARSE_NODE_IS_SMALL_INT(pn_arg[j])) {
-                        compile_syntax_error(comp, nodes[i], "'data' requires integer arguments");
+                        compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("'data' requires integer arguments"));
                         return;
                     }
-                    mp_asm_base_data((mp_asm_base_t*)comp->emit_inline_asm,
+                    mp_asm_base_data((mp_asm_base_t *)comp->emit_inline_asm,
                         bytesize, MP_PARSE_NODE_LEAF_SMALL_INT(pn_arg[j]));
                 }
             }
@@ -3321,9 +3327,9 @@ STATIC void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind
         EMIT_INLINE_ASM_ARG(end_pass, type_sig);
 
         if (comp->pass == MP_PASS_EMIT) {
-            void *f = mp_asm_base_get_code((mp_asm_base_t*)comp->emit_inline_asm);
+            void *f = mp_asm_base_get_code((mp_asm_base_t *)comp->emit_inline_asm);
             mp_emit_glue_assign_native(comp->scope_cur->raw_code, MP_CODE_NATIVE_ASM,
-                f, mp_asm_base_get_code_size((mp_asm_base_t*)comp->emit_inline_asm),
+                f, mp_asm_base_get_code_size((mp_asm_base_t *)comp->emit_inline_asm),
                 NULL,
                 #if MICROPY_PERSISTENT_CODE_SAVE
                 0, 0, 0, 0, NULL,
@@ -3349,7 +3355,9 @@ STATIC void scope_compute_things(scope_t *scope) {
             if (id->flags & ID_FLAG_IS_STAR_PARAM) {
                 if (id_param != NULL) {
                     // swap star param with last param
-                    id_info_t temp = *id_param; *id_param = *id; *id = temp;
+                    id_info_t temp = *id_param;
+                    *id_param = *id;
+                    *id = temp;
                 }
                 break;
             } else if (id_param == NULL && id->flags == ID_FLAG_IS_PARAM) {
@@ -3434,7 +3442,7 @@ STATIC void scope_compute_things(scope_t *scope) {
 #if !MICROPY_PERSISTENT_CODE_SAVE
 STATIC
 #endif
-mp_raw_code_t *mp_compile_to_raw_code(mp_parse_tree_t *parse_tree, qstr source_file, uint emit_opt, bool is_repl) {
+mp_raw_code_t *mp_compile_to_raw_code(mp_parse_tree_t *parse_tree, qstr source_file, bool is_repl) {
     // put compiler state on the stack, it's relatively small
     compiler_t comp_state = {0};
     compiler_t *comp = &comp_state;
@@ -3445,6 +3453,11 @@ mp_raw_code_t *mp_compile_to_raw_code(mp_parse_tree_t *parse_tree, qstr source_f
     comp->continue_label = INVALID_LABEL;
 
     // create the module scope
+    #if MICROPY_EMIT_NATIVE
+    const uint emit_opt = MP_STATE_VM(default_emit_opt);
+    #else
+    const uint emit_opt = MP_EMIT_OPT_NONE;
+    #endif
     scope_t *module_scope = scope_new_and_link(comp, SCOPE_MODULE, parse_tree->root, emit_opt);
 
     // create standard emitter; it's used at least for MP_PASS_SCOPE
@@ -3457,12 +3470,12 @@ mp_raw_code_t *mp_compile_to_raw_code(mp_parse_tree_t *parse_tree, qstr source_f
     #endif
     uint max_num_labels = 0;
     for (scope_t *s = comp->scope_head; s != NULL && comp->compile_error == MP_OBJ_NULL; s = s->next) {
-        if (false) {
         #if MICROPY_EMIT_INLINE_ASM
-        } else if (s->emit_options == MP_EMIT_OPT_ASM) {
+        if (s->emit_options == MP_EMIT_OPT_ASM) {
             compile_scope_inline_asm(comp, s, MP_PASS_SCOPE);
+        } else
         #endif
-        } else {
+        {
             compile_scope(comp, s, MP_PASS_SCOPE);
 
             // Check if any implicitly declared variables should be closed over
@@ -3489,15 +3502,12 @@ mp_raw_code_t *mp_compile_to_raw_code(mp_parse_tree_t *parse_tree, qstr source_f
     emit_bc_set_max_num_labels(emit_bc, max_num_labels);
 
     // compile pass 2 and 3
-#if MICROPY_EMIT_NATIVE
+    #if MICROPY_EMIT_NATIVE
     emit_t *emit_native = NULL;
-#endif
+    #endif
     for (scope_t *s = comp->scope_head; s != NULL && comp->compile_error == MP_OBJ_NULL; s = s->next) {
-        if (false) {
-            // dummy
-
         #if MICROPY_EMIT_INLINE_ASM
-        } else if (s->emit_options == MP_EMIT_OPT_ASM) {
+        if (s->emit_options == MP_EMIT_OPT_ASM) {
             // inline assembly
             if (comp->emit_inline_asm == NULL) {
                 comp->emit_inline_asm = ASM_EMITTER(new)(max_num_labels);
@@ -3519,15 +3529,15 @@ mp_raw_code_t *mp_compile_to_raw_code(mp_parse_tree_t *parse_tree, qstr source_f
             if (comp->compile_error == MP_OBJ_NULL) {
                 compile_scope_inline_asm(comp, s, MP_PASS_EMIT);
             }
+        } else
         #endif
-
-        } else {
+        {
 
             // choose the emit type
 
             switch (s->emit_options) {
 
-#if MICROPY_EMIT_NATIVE
+                #if MICROPY_EMIT_NATIVE
                 case MP_EMIT_OPT_NATIVE_PYTHON:
                 case MP_EMIT_OPT_VIPER:
                     if (emit_native == NULL) {
@@ -3536,7 +3546,7 @@ mp_raw_code_t *mp_compile_to_raw_code(mp_parse_tree_t *parse_tree, qstr source_f
                     comp->emit_method_table = NATIVE_EMITTER_TABLE;
                     comp->emit = emit_native;
                     break;
-#endif // MICROPY_EMIT_NATIVE
+                #endif // MICROPY_EMIT_NATIVE
 
                 default:
                     comp->emit = emit_bc;
@@ -3573,11 +3583,11 @@ mp_raw_code_t *mp_compile_to_raw_code(mp_parse_tree_t *parse_tree, qstr source_f
     // free the emitters
 
     emit_bc_free(emit_bc);
-#if MICROPY_EMIT_NATIVE
+    #if MICROPY_EMIT_NATIVE
     if (emit_native != NULL) {
         NATIVE_EMITTER(free)(emit_native);
     }
-#endif
+    #endif
     #if MICROPY_EMIT_INLINE_ASM
     if (comp->emit_inline_asm != NULL) {
         ASM_EMITTER(free)(comp->emit_inline_asm);
@@ -3602,8 +3612,8 @@ mp_raw_code_t *mp_compile_to_raw_code(mp_parse_tree_t *parse_tree, qstr source_f
     }
 }
 
-mp_obj_t mp_compile(mp_parse_tree_t *parse_tree, qstr source_file, uint emit_opt, bool is_repl) {
-    mp_raw_code_t *rc = mp_compile_to_raw_code(parse_tree, source_file, emit_opt, is_repl);
+mp_obj_t mp_compile(mp_parse_tree_t *parse_tree, qstr source_file, bool is_repl) {
+    mp_raw_code_t *rc = mp_compile_to_raw_code(parse_tree, source_file, is_repl);
     // return function that executes the outer module
     return mp_make_function_from_raw_code(rc, MP_OBJ_NULL, MP_OBJ_NULL);
 }
diff --git a/py/compile.h b/py/compile.h
index 99a17a8d1ed35..1ad1f5e9cd3fc 100644
--- a/py/compile.h
+++ b/py/compile.h
@@ -32,11 +32,11 @@
 
 // the compiler will raise an exception if an error occurred
 // the compiler will clear the parse tree before it returns
-mp_obj_t mp_compile(mp_parse_tree_t *parse_tree, qstr source_file, uint emit_opt, bool is_repl);
+mp_obj_t mp_compile(mp_parse_tree_t *parse_tree, qstr source_file, bool is_repl);
 
 #if MICROPY_PERSISTENT_CODE_SAVE
 // this has the same semantics as mp_compile
-mp_raw_code_t *mp_compile_to_raw_code(mp_parse_tree_t *parse_tree, qstr source_file, uint emit_opt, bool is_repl);
+mp_raw_code_t *mp_compile_to_raw_code(mp_parse_tree_t *parse_tree, qstr source_file, bool is_repl);
 #endif
 
 // this is implemented in runtime.c
diff --git a/py/dynruntime.h b/py/dynruntime.h
new file mode 100644
index 0000000000000..9f2803c53520f
--- /dev/null
+++ b/py/dynruntime.h
@@ -0,0 +1,239 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_PY_DYNRUNTIME_H
+#define MICROPY_INCLUDED_PY_DYNRUNTIME_H
+
+// This header file contains definitions to dynamically implement the static
+// MicroPython runtime API defined in py/obj.h and py/runtime.h.
+
+#include "py/nativeglue.h"
+#include "py/objstr.h"
+#include "py/objtype.h"
+
+#if !MICROPY_ENABLE_DYNRUNTIME
+#error "dynruntime.h included in non-dynamic-module build."
+#endif
+
+#undef MP_ROM_QSTR
+#undef MP_OBJ_QSTR_VALUE
+#undef MP_OBJ_NEW_QSTR
+#undef mp_const_none
+#undef mp_const_false
+#undef mp_const_true
+#undef mp_const_empty_tuple
+#undef nlr_raise
+
+/******************************************************************************/
+// Memory allocation
+
+#define m_malloc(n)                     (m_malloc_dyn((n)))
+#define m_free(ptr)                     (m_free_dyn((ptr)))
+#define m_realloc(ptr, new_num_bytes)   (m_realloc_dyn((ptr), (new_num_bytes)))
+
+static inline void *m_malloc_dyn(size_t n) {
+    // TODO won't raise on OOM
+    return mp_fun_table.realloc_(NULL, n, false);
+}
+
+static inline void m_free_dyn(void *ptr) {
+    mp_fun_table.realloc_(ptr, 0, false);
+}
+
+static inline void *m_realloc_dyn(void *ptr, size_t new_num_bytes) {
+    // TODO won't raise on OOM
+    return mp_fun_table.realloc_(ptr, new_num_bytes, true);
+}
+
+/******************************************************************************/
+// Printing
+
+#define mp_plat_print               (*mp_fun_table.plat_print)
+#define mp_printf(p, ...)           (mp_fun_table.printf_((p), __VA_ARGS__))
+#define mp_vprintf(p, fmt, args)    (mp_fun_table.vprintf_((p), (fmt), (args)))
+
+/******************************************************************************/
+// Types and objects
+
+#define MP_OBJ_NEW_QSTR(x) MP_OBJ_NEW_QSTR_##x
+
+#define mp_type_type                        (*mp_fun_table.type_type)
+#define mp_type_str                         (*mp_fun_table.type_str)
+#define mp_type_list                        (*mp_fun_table.type_list)
+#define mp_type_EOFError                    (*(mp_obj_type_t *)(mp_load_global(MP_QSTR_EOFError)))
+#define mp_type_IndexError                  (*(mp_obj_type_t *)(mp_load_global(MP_QSTR_IndexError)))
+#define mp_type_KeyError                    (*(mp_obj_type_t *)(mp_load_global(MP_QSTR_KeyError)))
+#define mp_type_NotImplementedError         (*(mp_obj_type_t *)(mp_load_global(MP_QSTR_NotImplementedError)))
+#define mp_type_RuntimeError                (*(mp_obj_type_t *)(mp_load_global(MP_QSTR_RuntimeError)))
+#define mp_type_TypeError                   (*(mp_obj_type_t *)(mp_load_global(MP_QSTR_TypeError)))
+#define mp_type_ValueError                  (*(mp_obj_type_t *)(mp_load_global(MP_QSTR_ValueError)))
+
+#define mp_stream_read_obj                  (*mp_fun_table.stream_read_obj)
+#define mp_stream_readinto_obj              (*mp_fun_table.stream_readinto_obj)
+#define mp_stream_unbuffered_readline_obj   (*mp_fun_table.stream_unbuffered_readline_obj)
+#define mp_stream_write_obj                 (*mp_fun_table.stream_write_obj)
+
+#define mp_const_none                       ((mp_obj_t)mp_fun_table.const_none)
+#define mp_const_false                      ((mp_obj_t)mp_fun_table.const_false)
+#define mp_const_true                       ((mp_obj_t)mp_fun_table.const_true)
+#define mp_const_empty_tuple                (mp_fun_table.new_tuple(0, NULL))
+
+#define mp_obj_new_bool(b)                  ((b) ? (mp_obj_t)mp_fun_table.const_true : (mp_obj_t)mp_fun_table.const_false)
+#define mp_obj_new_int(i)                   (mp_fun_table.native_to_obj(i, MP_NATIVE_TYPE_INT))
+#define mp_obj_new_int_from_uint(i)         (mp_fun_table.native_to_obj(i, MP_NATIVE_TYPE_UINT))
+#define mp_obj_new_str(data, len)           (mp_fun_table.obj_new_str((data), (len)))
+#define mp_obj_new_str_of_type(t, d, l)     (mp_obj_new_str_of_type_dyn((t), (d), (l)))
+#define mp_obj_new_bytes(data, len)         (mp_fun_table.obj_new_bytes((data), (len)))
+#define mp_obj_new_bytearray_by_ref(n, i)   (mp_fun_table.obj_new_bytearray_by_ref((n), (i)))
+#define mp_obj_new_tuple(n, items)          (mp_fun_table.new_tuple((n), (items)))
+#define mp_obj_new_list(n, items)           (mp_fun_table.new_list((n), (items)))
+
+#define mp_obj_get_type(o)                  (mp_fun_table.obj_get_type((o)))
+#define mp_obj_cast_to_native_base(o, t)    (mp_obj_cast_to_native_base_dyn((o), (t)))
+#define mp_obj_get_int(o)                   (mp_fun_table.native_from_obj(o, MP_NATIVE_TYPE_INT))
+#define mp_obj_get_int_truncated(o)         (mp_fun_table.native_from_obj(o, MP_NATIVE_TYPE_UINT))
+#define mp_obj_str_get_str(s)               ((void *)mp_fun_table.native_from_obj(s, MP_NATIVE_TYPE_PTR))
+#define mp_obj_str_get_data(o, len)         (mp_obj_str_get_data_dyn((o), (len)))
+#define mp_get_buffer_raise(o, bufinfo, fl) (mp_fun_table.get_buffer_raise((o), (bufinfo), (fl)))
+#define mp_get_stream_raise(s, flags)       (mp_fun_table.get_stream_raise((s), (flags)))
+
+#define mp_obj_len(o)                       (mp_obj_len_dyn(o))
+#define mp_obj_subscr(base, index, val)     (mp_fun_table.obj_subscr((base), (index), (val)))
+#define mp_obj_list_append(list, item)      (mp_fun_table.list_append((list), (item)))
+
+static inline mp_obj_t mp_obj_new_str_of_type_dyn(const mp_obj_type_t *type, const byte *data, size_t len) {
+    if (type == &mp_type_str) {
+        return mp_obj_new_str((const char *)data, len);
+    } else {
+        return mp_obj_new_bytes(data, len);
+    }
+}
+
+static inline mp_obj_t mp_obj_cast_to_native_base_dyn(mp_obj_t self_in, mp_const_obj_t native_type) {
+    const mp_obj_type_t *self_type = mp_obj_get_type(self_in);
+
+    if (MP_OBJ_FROM_PTR(self_type) == native_type) {
+        return self_in;
+    } else if (self_type->parent != native_type) {
+        // The self_in object is not a direct descendant of native_type, so fail the cast.
+        // This is a very simple version of mp_obj_is_subclass_fast that could be improved.
+        return MP_OBJ_NULL;
+    } else {
+        mp_obj_instance_t *self = (mp_obj_instance_t *)MP_OBJ_TO_PTR(self_in);
+        return self->subobj[0];
+    }
+}
+
+static inline void *mp_obj_str_get_data_dyn(mp_obj_t o, size_t *l) {
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(o, &bufinfo, MP_BUFFER_READ);
+    *l = bufinfo.len;
+    return bufinfo.buf;
+}
+
+static inline mp_obj_t mp_obj_len_dyn(mp_obj_t o) {
+    // If bytes implemented MP_UNARY_OP_LEN could use: mp_unary_op(MP_UNARY_OP_LEN, o)
+    return mp_fun_table.call_function_n_kw(mp_fun_table.load_name(MP_QSTR_len), 1, &o);
+}
+
+/******************************************************************************/
+// General runtime functions
+
+#define mp_load_name(qst)           (mp_fun_table.load_name(qst))
+#define mp_load_global(qst)         (mp_fun_table.load_global(qst))
+#define mp_store_global(qst, obj)   (mp_fun_table.store_global((qst), (obj)))
+#define mp_unary_op(op, obj)        (mp_fun_table.unary_op((op), (obj)))
+#define mp_binary_op(op, lhs, rhs)  (mp_fun_table.binary_op((op), (lhs), (rhs)))
+
+#define mp_make_function_from_raw_code(rc, def_args, def_kw_args) \
+    (mp_fun_table.make_function_from_raw_code((rc), (def_args), (def_kw_args)))
+
+#define mp_call_function_n_kw(fun, n_args, n_kw, args) \
+    (mp_fun_table.call_function_n_kw((fun), (n_args) | ((n_kw) << 8), args))
+
+#define mp_arg_check_num(n_args, n_kw, n_args_min, n_args_max, takes_kw) \
+    (mp_fun_table.arg_check_num_sig((n_args), (n_kw), MP_OBJ_FUN_MAKE_SIG((n_args_min), (n_args_max), (takes_kw))))
+
+#define MP_DYNRUNTIME_INIT_ENTRY \
+    mp_obj_t old_globals = mp_fun_table.swap_globals(self->globals); \
+    mp_raw_code_t rc; \
+    rc.kind = MP_CODE_NATIVE_VIPER; \
+    rc.scope_flags = 0; \
+    rc.const_table = (void *)self->const_table; \
+    (void)rc;
+
+#define MP_DYNRUNTIME_INIT_EXIT \
+    mp_fun_table.swap_globals(old_globals); \
+    return mp_const_none;
+
+#define MP_DYNRUNTIME_MAKE_FUNCTION(f) \
+    (mp_make_function_from_raw_code((rc.fun_data = (f), &rc), MP_OBJ_NULL, MP_OBJ_NULL))
+
+/******************************************************************************/
+// Exceptions
+
+#define mp_obj_new_exception(o)                 ((mp_obj_t)(o)) // Assumes returned object will be raised, will create instance then
+#define mp_obj_new_exception_arg1(e_type, arg)  (mp_obj_new_exception_arg1_dyn((e_type), (arg)))
+
+#define nlr_raise(o)                            (mp_raise_dyn(o))
+#define mp_raise_msg(type, msg)                 (mp_fun_table.raise_msg((type), (msg)))
+#define mp_raise_OSError(er)                    (mp_raise_OSError_dyn(er))
+#define mp_raise_NotImplementedError(msg)       (mp_raise_msg(&mp_type_NotImplementedError, (msg)))
+#define mp_raise_TypeError(msg)                 (mp_raise_msg(&mp_type_TypeError, (msg)))
+#define mp_raise_ValueError(msg)                (mp_raise_msg(&mp_type_ValueError, (msg)))
+
+static inline mp_obj_t mp_obj_new_exception_arg1_dyn(const mp_obj_type_t *exc_type, mp_obj_t arg) {
+    mp_obj_t args[1] = { arg };
+    return mp_call_function_n_kw(MP_OBJ_FROM_PTR(exc_type), 1, 0, &args[0]);
+}
+
+static NORETURN inline void mp_raise_dyn(mp_obj_t o) {
+    mp_fun_table.raise(o);
+    for (;;) {
+    }
+}
+
+static inline void mp_raise_OSError_dyn(int er) {
+    mp_obj_t args[1] = { MP_OBJ_NEW_SMALL_INT(er) };
+    nlr_raise(mp_call_function_n_kw(mp_load_global(MP_QSTR_OSError), 1, 0, &args[0]));
+}
+
+/******************************************************************************/
+// Floating point
+
+#define mp_obj_new_float_from_f(f)  (mp_fun_table.obj_new_float_from_f((f)))
+#define mp_obj_new_float_from_d(d)  (mp_fun_table.obj_new_float_from_d((d)))
+#define mp_obj_get_float_to_f(o)    (mp_fun_table.obj_get_float_to_f((o)))
+#define mp_obj_get_float_to_d(o)    (mp_fun_table.obj_get_float_to_d((o)))
+
+#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
+#define mp_obj_new_float(f)         (mp_obj_new_float_from_f((f)))
+#define mp_obj_get_float(o)         (mp_obj_get_float_to_f((o)))
+#elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
+#define mp_obj_new_float(f)         (mp_obj_new_float_from_d((f)))
+#define mp_obj_get_float(o)         (mp_obj_get_float_to_d((o)))
+#endif
+
+#endif // MICROPY_INCLUDED_PY_DYNRUNTIME_H
diff --git a/py/dynruntime.mk b/py/dynruntime.mk
new file mode 100644
index 0000000000000..cb5ab845eb1d2
--- /dev/null
+++ b/py/dynruntime.mk
@@ -0,0 +1,145 @@
+# Makefile fragment for generating native .mpy files from C source
+# MPY_DIR must be set to the top of the MicroPython source tree
+
+BUILD ?= build
+
+ECHO = @echo
+RM = /bin/rm
+MKDIR = /bin/mkdir
+PYTHON = python3
+MPY_CROSS = $(MPY_DIR)/mpy-cross/mpy-cross
+MPY_TOOL = $(PYTHON) $(MPY_DIR)/tools/mpy-tool.py
+MPY_LD = $(PYTHON) $(MPY_DIR)/tools/mpy_ld.py
+
+Q = @
+ifeq ("$(origin V)", "command line")
+ifeq ($(V),1)
+Q =
+MPY_LD += '-vvv'
+endif
+endif
+
+ARCH_UPPER = $(shell echo $(ARCH) | tr '[:lower:]' '[:upper:]')
+CONFIG_H = $(BUILD)/$(MOD).config.h
+
+CFLAGS += -I. -I$(MPY_DIR)
+CFLAGS += -std=c99
+CFLAGS += -Os
+CFLAGS += -Wall -Werror -DNDEBUG
+CFLAGS += -DNO_QSTR
+CFLAGS += -DMICROPY_ENABLE_DYNRUNTIME
+CFLAGS += -DMP_CONFIGFILE='<$(CONFIG_H)>'
+CFLAGS += -fpic -fno-common
+CFLAGS += -U _FORTIFY_SOURCE # prevent use of __*_chk libc functions
+#CFLAGS += -fdata-sections -ffunction-sections
+
+MPY_CROSS_FLAGS += -march=$(ARCH)
+
+SRC_O += $(addprefix $(BUILD)/, $(patsubst %.c,%.o,$(filter %.c,$(SRC))))
+SRC_MPY += $(addprefix $(BUILD)/, $(patsubst %.py,%.mpy,$(filter %.py,$(SRC))))
+
+################################################################################
+# Architecture configuration
+
+ifeq ($(ARCH),x86)
+
+# x86
+CROSS =
+CFLAGS += -m32 -fno-stack-protector
+MPY_CROSS_FLAGS += -mcache-lookup-bc
+MICROPY_FLOAT_IMPL ?= double
+
+else ifeq ($(ARCH),x64)
+
+# x64
+CROSS =
+CFLAGS += -fno-stack-protector
+MPY_CROSS_FLAGS += -mcache-lookup-bc
+MICROPY_FLOAT_IMPL ?= double
+
+else ifeq ($(ARCH),armv7m)
+
+# thumb
+CROSS = arm-none-eabi-
+CFLAGS += -mthumb -mcpu=cortex-m3
+MICROPY_FLOAT_IMPL ?= none
+
+else ifeq ($(ARCH),armv7emsp)
+
+# thumb
+CROSS = arm-none-eabi-
+CFLAGS += -mthumb -mcpu=cortex-m4
+CFLAGS += -mfpu=fpv4-sp-d16 -mfloat-abi=hard
+MICROPY_FLOAT_IMPL ?= float
+
+else ifeq ($(ARCH),armv7emdp)
+
+# thumb
+CROSS = arm-none-eabi-
+CFLAGS += -mthumb -mcpu=cortex-m7
+CFLAGS += -mfpu=fpv5-d16 -mfloat-abi=hard
+MICROPY_FLOAT_IMPL ?= double
+
+else ifeq ($(ARCH),xtensa)
+
+# xtensa
+CROSS = xtensa-lx106-elf-
+CFLAGS += -mforce-l32
+MICROPY_FLOAT_IMPL ?= none
+
+else ifeq ($(ARCH),xtensawin)
+
+# xtensawin
+CROSS = xtensa-esp32-elf-
+CFLAGS +=
+MICROPY_FLOAT_IMPL ?= float
+
+else
+$(error architecture '$(ARCH)' not supported)
+endif
+
+MICROPY_FLOAT_IMPL_UPPER = $(shell echo $(MICROPY_FLOAT_IMPL) | tr '[:lower:]' '[:upper:]')
+CFLAGS += -DMICROPY_FLOAT_IMPL=MICROPY_FLOAT_IMPL_$(MICROPY_FLOAT_IMPL_UPPER)
+
+CFLAGS += $(CFLAGS_EXTRA)
+
+################################################################################
+# Build rules
+
+.PHONY: all clean
+
+all: $(MOD).mpy
+
+clean:
+	$(RM) -rf $(BUILD) $(CLEAN_EXTRA)
+
+# Create build destination directories first
+BUILD_DIRS = $(sort $(dir $(CONFIG_H) $(SRC_O) $(SRC_MPY)))
+$(CONFIG_H) $(SRC_O) $(SRC_MPY): | $(BUILD_DIRS)
+$(BUILD_DIRS):
+	$(Q)$(MKDIR) -p $@
+
+# Preprocess all source files to generate $(CONFIG_H)
+$(CONFIG_H): $(SRC)
+	$(ECHO) "GEN $@"
+	$(Q)$(MPY_LD) --arch $(ARCH) --preprocess -o $@ $^
+
+# Build .o from .c source files
+$(BUILD)/%.o: %.c $(CONFIG_H) Makefile
+	$(ECHO) "CC $<"
+	$(Q)$(CROSS)gcc $(CFLAGS) -o $@ -c $<
+
+# Build .mpy from .py source files
+$(BUILD)/%.mpy: %.py
+	$(ECHO) "MPY $<"
+	$(Q)$(MPY_CROSS) $(MPY_CROSS_FLAGS) -o $@ $<
+
+# Build native .mpy from object files
+$(BUILD)/$(MOD).native.mpy: $(SRC_O)
+	$(ECHO) "LINK $<"
+	$(Q)$(MPY_LD) --arch $(ARCH) --qstrs $(CONFIG_H) -o $@ $^
+
+# Build final .mpy from all intermediate .mpy files
+$(MOD).mpy: $(BUILD)/$(MOD).native.mpy $(SRC_MPY)
+	$(ECHO) "GEN $@"
+	$(Q)$(MPY_TOOL) --merge -o $@ $^
diff --git a/py/emit.h b/py/emit.h
index 70f7bf1220378..13bd3e9b2eb3f 100644
--- a/py/emit.h
+++ b/py/emit.h
@@ -76,15 +76,15 @@ typedef enum {
 
 // Kind for emit->setup_block()
 #define MP_EMIT_SETUP_BLOCK_WITH (0)
-#define MP_EMIT_SETUP_BLOCK_EXCEPT (2)
-#define MP_EMIT_SETUP_BLOCK_FINALLY (3)
+#define MP_EMIT_SETUP_BLOCK_EXCEPT (1)
+#define MP_EMIT_SETUP_BLOCK_FINALLY (2)
 
 // Kind for emit->build()
 #define MP_EMIT_BUILD_TUPLE (0)
 #define MP_EMIT_BUILD_LIST (1)
-#define MP_EMIT_BUILD_MAP (3)
-#define MP_EMIT_BUILD_SET (6)
-#define MP_EMIT_BUILD_SLICE (8)
+#define MP_EMIT_BUILD_MAP (2)
+#define MP_EMIT_BUILD_SET (3)
+#define MP_EMIT_BUILD_SLICE (4)
 
 // Kind for emit->yield()
 #define MP_EMIT_YIELD_VALUE (0)
@@ -99,7 +99,7 @@ typedef struct _mp_emit_method_table_id_ops_t {
 
 typedef struct _emit_method_table_t {
     #if MICROPY_DYNAMIC_COMPILER
-    emit_t *(*emit_new)(mp_obj_t *error_slot, uint *label_slot, mp_uint_t max_num_labels);
+    emit_t *(*emit_new)(mp_obj_t * error_slot, uint *label_slot, mp_uint_t max_num_labels);
     void (*emit_free)(emit_t *emit);
     #endif
 
@@ -174,6 +174,7 @@ extern const emit_method_table_t emit_native_x86_method_table;
 extern const emit_method_table_t emit_native_thumb_method_table;
 extern const emit_method_table_t emit_native_arm_method_table;
 extern const emit_method_table_t emit_native_xtensa_method_table;
+extern const emit_method_table_t emit_native_xtensawin_method_table;
 
 extern const mp_emit_method_table_id_ops_t mp_emit_bc_method_table_load_id_ops;
 extern const mp_emit_method_table_id_ops_t mp_emit_bc_method_table_store_id_ops;
@@ -185,8 +186,9 @@ emit_t *emit_native_x86_new(mp_obj_t *error_slot, uint *label_slot, mp_uint_t ma
 emit_t *emit_native_thumb_new(mp_obj_t *error_slot, uint *label_slot, mp_uint_t max_num_labels);
 emit_t *emit_native_arm_new(mp_obj_t *error_slot, uint *label_slot, mp_uint_t max_num_labels);
 emit_t *emit_native_xtensa_new(mp_obj_t *error_slot, uint *label_slot, mp_uint_t max_num_labels);
+emit_t *emit_native_xtensawin_new(mp_obj_t *error_slot, uint *label_slot, mp_uint_t max_num_labels);
 
-void emit_bc_set_max_num_labels(emit_t* emit, mp_uint_t max_num_labels);
+void emit_bc_set_max_num_labels(emit_t *emit, mp_uint_t max_num_labels);
 
 void emit_bc_free(emit_t *emit);
 void emit_native_x64_free(emit_t *emit);
@@ -194,6 +196,7 @@ void emit_native_x86_free(emit_t *emit);
 void emit_native_thumb_free(emit_t *emit);
 void emit_native_arm_free(emit_t *emit);
 void emit_native_xtensa_free(emit_t *emit);
+void emit_native_xtensawin_free(emit_t *emit);
 
 void mp_emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope);
 void mp_emit_bc_end_pass(emit_t *emit);
diff --git a/py/emitbc.c b/py/emitbc.c
index 35eb6df9c0c38..c74b7fbc4d978 100644
--- a/py/emitbc.c
+++ b/py/emitbc.c
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2013-2019 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -64,6 +64,9 @@ struct _emit_t {
     size_t bytecode_size;
     byte *code_base; // stores both byte code and code info
 
+    size_t n_info;
+    size_t n_cell;
+
     #if MICROPY_PERSISTENT_CODE
     uint16_t ct_cur_obj;
     uint16_t ct_num_obj;
@@ -107,7 +110,6 @@ STATIC void emit_write_uint(emit_t *emit, emit_allocator_t allocator, mp_uint_t
 
 // all functions must go through this one to emit code info
 STATIC byte *emit_get_cur_to_write_code_info(emit_t *emit, int num_bytes_to_write) {
-    //printf("emit %d\n", num_bytes_to_write);
     if (emit->pass < MP_PASS_EMIT) {
         emit->code_info_offset += num_bytes_to_write;
         return emit->dummy_data;
@@ -119,14 +121,10 @@ STATIC byte *emit_get_cur_to_write_code_info(emit_t *emit, int num_bytes_to_writ
     }
 }
 
-STATIC void emit_write_code_info_byte(emit_t* emit, byte val) {
+STATIC void emit_write_code_info_byte(emit_t *emit, byte val) {
     *emit_get_cur_to_write_code_info(emit, 1) = val;
 }
 
-STATIC void emit_write_code_info_uint(emit_t* emit, mp_uint_t val) {
-    emit_write_uint(emit, emit_get_cur_to_write_code_info, val);
-}
-
 STATIC void emit_write_code_info_qstr(emit_t *emit, qstr qst) {
     #if MICROPY_PERSISTENT_CODE
     assert((qst >> 16) == 0);
@@ -141,7 +139,6 @@ STATIC void emit_write_code_info_qstr(emit_t *emit, qstr qst) {
 #if MICROPY_ENABLE_SOURCE_LINE
 STATIC void emit_write_code_info_bytes_lines(emit_t *emit, mp_uint_t bytes_to_skip, mp_uint_t lines_to_skip) {
     assert(bytes_to_skip > 0 || lines_to_skip > 0);
-    //printf("  %d %d\n", bytes_to_skip, lines_to_skip);
     while (bytes_to_skip > 0 || lines_to_skip > 0) {
         mp_uint_t b, l;
         if (lines_to_skip <= 6 || bytes_to_skip > 0xf) {
@@ -170,7 +167,6 @@ STATIC void emit_write_code_info_bytes_lines(emit_t *emit, mp_uint_t bytes_to_sk
 
 // all functions must go through this one to emit byte code
 STATIC byte *emit_get_cur_to_write_bytecode(emit_t *emit, int num_bytes_to_write) {
-    //printf("emit %d\n", num_bytes_to_write);
     if (emit->pass < MP_PASS_EMIT) {
         emit->bytecode_offset += num_bytes_to_write;
         return emit->dummy_data;
@@ -182,20 +178,20 @@ STATIC byte *emit_get_cur_to_write_bytecode(emit_t *emit, int num_bytes_to_write
     }
 }
 
-STATIC void emit_write_bytecode_byte(emit_t *emit, byte b1) {
+STATIC void emit_write_bytecode_raw_byte(emit_t *emit, byte b1) {
     byte *c = emit_get_cur_to_write_bytecode(emit, 1);
     c[0] = b1;
 }
 
-STATIC void emit_write_bytecode_byte_byte(emit_t* emit, byte b1, byte b2) {
-    byte *c = emit_get_cur_to_write_bytecode(emit, 2);
+STATIC void emit_write_bytecode_byte(emit_t *emit, int stack_adj, byte b1) {
+    mp_emit_bc_adjust_stack_size(emit, stack_adj);
+    byte *c = emit_get_cur_to_write_bytecode(emit, 1);
     c[0] = b1;
-    c[1] = b2;
 }
 
 // Similar to emit_write_bytecode_uint(), just some extra handling to encode sign
-STATIC void emit_write_bytecode_byte_int(emit_t *emit, byte b1, mp_int_t num) {
-    emit_write_bytecode_byte(emit, b1);
+STATIC void emit_write_bytecode_byte_int(emit_t *emit, int stack_adj, byte b1, mp_int_t num) {
+    emit_write_bytecode_byte(emit, stack_adj, b1);
 
     // We store each 7 bits in a separate byte, and that's how many bytes needed
     byte buf[BYTES_FOR_INT];
@@ -220,66 +216,71 @@ STATIC void emit_write_bytecode_byte_int(emit_t *emit, byte b1, mp_int_t num) {
     *c = *p;
 }
 
-STATIC void emit_write_bytecode_byte_uint(emit_t *emit, byte b, mp_uint_t val) {
-    emit_write_bytecode_byte(emit, b);
+STATIC void emit_write_bytecode_byte_uint(emit_t *emit, int stack_adj, byte b, mp_uint_t val) {
+    emit_write_bytecode_byte(emit, stack_adj, b);
     emit_write_uint(emit, emit_get_cur_to_write_bytecode, val);
 }
 
 #if MICROPY_PERSISTENT_CODE
-STATIC void emit_write_bytecode_byte_const(emit_t *emit, byte b, mp_uint_t n, mp_uint_t c) {
+STATIC void emit_write_bytecode_byte_const(emit_t *emit, int stack_adj, byte b, mp_uint_t n, mp_uint_t c) {
     if (emit->pass == MP_PASS_EMIT) {
         emit->const_table[n] = c;
     }
-    emit_write_bytecode_byte_uint(emit, b, n);
+    emit_write_bytecode_byte_uint(emit, stack_adj, b, n);
 }
 #endif
 
-STATIC void emit_write_bytecode_byte_qstr(emit_t* emit, byte b, qstr qst) {
+STATIC void emit_write_bytecode_byte_qstr(emit_t *emit, int stack_adj, byte b, qstr qst) {
     #if MICROPY_PERSISTENT_CODE
     assert((qst >> 16) == 0);
+    mp_emit_bc_adjust_stack_size(emit, stack_adj);
     byte *c = emit_get_cur_to_write_bytecode(emit, 3);
     c[0] = b;
     c[1] = qst;
     c[2] = qst >> 8;
     #else
-    emit_write_bytecode_byte_uint(emit, b, qst);
+    emit_write_bytecode_byte_uint(emit, stack_adj, b, qst);
     #endif
 }
 
-STATIC void emit_write_bytecode_byte_obj(emit_t *emit, byte b, mp_obj_t obj) {
+STATIC void emit_write_bytecode_byte_obj(emit_t *emit, int stack_adj, byte b, mp_obj_t obj) {
     #if MICROPY_PERSISTENT_CODE
-    emit_write_bytecode_byte_const(emit, b,
+    emit_write_bytecode_byte_const(emit, stack_adj, b,
         emit->scope->num_pos_args + emit->scope->num_kwonly_args
         + emit->ct_cur_obj++, (mp_uint_t)obj);
     #else
     // aligns the pointer so it is friendly to GC
-    emit_write_bytecode_byte(emit, b);
+    emit_write_bytecode_byte(emit, stack_adj, b);
     emit->bytecode_offset = (size_t)MP_ALIGN(emit->bytecode_offset, sizeof(mp_obj_t));
-    mp_obj_t *c = (mp_obj_t*)emit_get_cur_to_write_bytecode(emit, sizeof(mp_obj_t));
+    mp_obj_t *c = (mp_obj_t *)emit_get_cur_to_write_bytecode(emit, sizeof(mp_obj_t));
     // Verify thar c is already uint-aligned
     assert(c == MP_ALIGN(c, sizeof(mp_obj_t)));
     *c = obj;
     #endif
 }
 
-STATIC void emit_write_bytecode_byte_raw_code(emit_t *emit, byte b, mp_raw_code_t *rc) {
+STATIC void emit_write_bytecode_byte_raw_code(emit_t *emit, int stack_adj, byte b, mp_raw_code_t *rc) {
     #if MICROPY_PERSISTENT_CODE
-    emit_write_bytecode_byte_const(emit, b,
+    emit_write_bytecode_byte_const(emit, stack_adj, b,
         emit->scope->num_pos_args + emit->scope->num_kwonly_args
         + emit->ct_num_obj + emit->ct_cur_raw_code++, (mp_uint_t)(uintptr_t)rc);
     #else
     // aligns the pointer so it is friendly to GC
-    emit_write_bytecode_byte(emit, b);
-    emit->bytecode_offset = (size_t)MP_ALIGN(emit->bytecode_offset, sizeof(void*));
-    void **c = (void**)emit_get_cur_to_write_bytecode(emit, sizeof(void*));
+    emit_write_bytecode_byte(emit, stack_adj, b);
+    emit->bytecode_offset = (size_t)MP_ALIGN(emit->bytecode_offset, sizeof(void *));
+    void **c = (void **)emit_get_cur_to_write_bytecode(emit, sizeof(void *));
     // Verify thar c is already uint-aligned
-    assert(c == MP_ALIGN(c, sizeof(void*)));
+    assert(c == MP_ALIGN(c, sizeof(void *)));
     *c = rc;
     #endif
+    #if MICROPY_PY_SYS_SETTRACE
+    rc->line_of_definition = emit->last_source_line;
+    #endif
 }
 
 // unsigned labels are relative to ip following this instruction, stored as 16 bits
-STATIC void emit_write_bytecode_byte_unsigned_label(emit_t *emit, byte b1, mp_uint_t label) {
+STATIC void emit_write_bytecode_byte_unsigned_label(emit_t *emit, int stack_adj, byte b1, mp_uint_t label) {
+    mp_emit_bc_adjust_stack_size(emit, stack_adj);
     mp_uint_t bytecode_offset;
     if (emit->pass < MP_PASS_EMIT) {
         bytecode_offset = 0;
@@ -293,7 +294,8 @@ STATIC void emit_write_bytecode_byte_unsigned_label(emit_t *emit, byte b1, mp_ui
 }
 
 // signed labels are relative to ip following this instruction, stored as 16 bits, in excess
-STATIC void emit_write_bytecode_byte_signed_label(emit_t *emit, byte b1, mp_uint_t label) {
+STATIC void emit_write_bytecode_byte_signed_label(emit_t *emit, int stack_adj, byte b1, mp_uint_t label) {
+    mp_emit_bc_adjust_stack_size(emit, stack_adj);
     int bytecode_offset;
     if (emit->pass < MP_PASS_EMIT) {
         bytecode_offset = 0;
@@ -322,7 +324,7 @@ void mp_emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) {
     emit->bytecode_offset = 0;
     emit->code_info_offset = 0;
 
-    // Write local state size and exception stack size.
+    // Write local state size, exception stack size, scope flags and number of arguments
     {
         mp_uint_t n_state = scope->num_locals + scope->stack_size;
         if (n_state == 0) {
@@ -335,40 +337,22 @@ void mp_emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) {
         // An extra slot in the stack is needed to detect VM stack overflow
         n_state += 1;
         #endif
-        emit_write_code_info_uint(emit, n_state);
-        emit_write_code_info_uint(emit, scope->exc_stack_size);
-    }
 
-    // Write scope flags and number of arguments.
-    // TODO check that num args all fit in a byte
-    emit_write_code_info_byte(emit, emit->scope->scope_flags);
-    emit_write_code_info_byte(emit, emit->scope->num_pos_args);
-    emit_write_code_info_byte(emit, emit->scope->num_kwonly_args);
-    emit_write_code_info_byte(emit, emit->scope->num_def_pos_args);
+        size_t n_exc_stack = scope->exc_stack_size;
+        MP_BC_PRELUDE_SIG_ENCODE(n_state, n_exc_stack, scope, emit_write_code_info_byte, emit);
+    }
 
-    // Write size of the rest of the code info.  We don't know how big this
-    // variable uint will be on the MP_PASS_CODE_SIZE pass so we reserve 2 bytes
-    // for it and hope that is enough!  TODO assert this or something.
-    if (pass == MP_PASS_EMIT) {
-        emit_write_code_info_uint(emit, emit->code_info_size - emit->code_info_offset);
-    } else  {
-        emit_get_cur_to_write_code_info(emit, 2);
+    // Write number of cells and size of the source code info
+    if (pass >= MP_PASS_CODE_SIZE) {
+        MP_BC_PRELUDE_SIZE_ENCODE(emit->n_info, emit->n_cell, emit_write_code_info_byte, emit);
     }
 
+    emit->n_info = emit->code_info_offset;
+
     // Write the name and source file of this function.
     emit_write_code_info_qstr(emit, scope->simple_name);
     emit_write_code_info_qstr(emit, scope->source_file);
 
-    // bytecode prelude: initialise closed over variables
-    for (int i = 0; i < scope->id_info_len; i++) {
-        id_info_t *id = &scope->id_info[i];
-        if (id->kind == ID_INFO_KIND_CELL) {
-            assert(id->local_num < 255);
-            emit_write_bytecode_byte(emit, id->local_num); // write the local which should be converted to a cell
-        }
-    }
-    emit_write_bytecode_byte(emit, 255); // end of list sentinel
-
     #if MICROPY_PERSISTENT_CODE
     emit->ct_cur_obj = 0;
     emit->ct_cur_raw_code = 0;
@@ -414,6 +398,20 @@ void mp_emit_bc_end_pass(emit_t *emit) {
 
     emit_write_code_info_byte(emit, 0); // end of line number info
 
+    // Calculate size of source code info section
+    emit->n_info = emit->code_info_offset - emit->n_info;
+
+    // Emit closure section of prelude
+    emit->n_cell = 0;
+    for (size_t i = 0; i < emit->scope->id_info_len; ++i) {
+        id_info_t *id = &emit->scope->id_info[i];
+        if (id->kind == ID_INFO_KIND_CELL) {
+            assert(id->local_num <= 255);
+            emit_write_code_info_byte(emit, id->local_num); // write the local which should be converted to a cell
+            ++emit->n_cell;
+        }
+    }
+
     #if MICROPY_PERSISTENT_CODE
     assert(emit->pass <= MP_PASS_STACK_SIZE || (emit->ct_num_obj == emit->ct_cur_obj));
     emit->ct_num_obj = emit->ct_cur_obj;
@@ -468,13 +466,8 @@ void mp_emit_bc_adjust_stack_size(emit_t *emit, mp_int_t delta) {
     emit->last_emit_was_return_value = false;
 }
 
-static inline void emit_bc_pre(emit_t *emit, mp_int_t stack_size_delta) {
-    mp_emit_bc_adjust_stack_size(emit, stack_size_delta);
-}
-
 void mp_emit_bc_set_source_line(emit_t *emit, mp_uint_t source_line) {
-    //printf("source: line %d -> %d  offset %d -> %d\n", emit->last_source_line, source_line, emit->last_source_line_offset, emit->bytecode_offset);
-#if MICROPY_ENABLE_SOURCE_LINE
+    #if MICROPY_ENABLE_SOURCE_LINE
     if (MP_STATE_VM(mp_optimise_value) >= 3) {
         // If we compile with -O3, don't store line numbers.
         return;
@@ -486,14 +479,14 @@ void mp_emit_bc_set_source_line(emit_t *emit, mp_uint_t source_line) {
         emit->last_source_line_offset = emit->bytecode_offset;
         emit->last_source_line = source_line;
     }
-#else
+    #else
     (void)emit;
     (void)source_line;
-#endif
+    #endif
 }
 
 void mp_emit_bc_label_assign(emit_t *emit, mp_uint_t l) {
-    emit_bc_pre(emit, 0);
+    mp_emit_bc_adjust_stack_size(emit, 0);
     if (emit->pass == MP_PASS_SCOPE) {
         return;
     }
@@ -511,64 +504,54 @@ void mp_emit_bc_label_assign(emit_t *emit, mp_uint_t l) {
 void mp_emit_bc_import(emit_t *emit, qstr qst, int kind) {
     MP_STATIC_ASSERT(MP_BC_IMPORT_NAME + MP_EMIT_IMPORT_NAME == MP_BC_IMPORT_NAME);
     MP_STATIC_ASSERT(MP_BC_IMPORT_NAME + MP_EMIT_IMPORT_FROM == MP_BC_IMPORT_FROM);
-    if (kind == MP_EMIT_IMPORT_FROM) {
-        emit_bc_pre(emit, 1);
-    } else {
-        emit_bc_pre(emit, -1);
-    }
+    int stack_adj = kind == MP_EMIT_IMPORT_FROM ? 1 : -1;
     if (kind == MP_EMIT_IMPORT_STAR) {
-        emit_write_bytecode_byte(emit, MP_BC_IMPORT_STAR);
+        emit_write_bytecode_byte(emit, stack_adj, MP_BC_IMPORT_STAR);
     } else {
-        emit_write_bytecode_byte_qstr(emit, MP_BC_IMPORT_NAME + kind, qst);
+        emit_write_bytecode_byte_qstr(emit, stack_adj, MP_BC_IMPORT_NAME + kind, qst);
     }
 }
 
 void mp_emit_bc_load_const_tok(emit_t *emit, mp_token_kind_t tok) {
-    emit_bc_pre(emit, 1);
-    switch (tok) {
-        case MP_TOKEN_KW_FALSE: emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_FALSE); break;
-        case MP_TOKEN_KW_NONE: emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_NONE); break;
-        case MP_TOKEN_KW_TRUE: emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_TRUE); break;
-        default:
-            assert(tok == MP_TOKEN_ELLIPSIS);
-            emit_write_bytecode_byte_obj(emit, MP_BC_LOAD_CONST_OBJ, MP_OBJ_FROM_PTR(&mp_const_ellipsis_obj));
-            break;
+    MP_STATIC_ASSERT(MP_BC_LOAD_CONST_FALSE + (MP_TOKEN_KW_NONE - MP_TOKEN_KW_FALSE) == MP_BC_LOAD_CONST_NONE);
+    MP_STATIC_ASSERT(MP_BC_LOAD_CONST_FALSE + (MP_TOKEN_KW_TRUE - MP_TOKEN_KW_FALSE) == MP_BC_LOAD_CONST_TRUE);
+    if (tok == MP_TOKEN_ELLIPSIS) {
+        emit_write_bytecode_byte_obj(emit, 1, MP_BC_LOAD_CONST_OBJ, MP_OBJ_FROM_PTR(&mp_const_ellipsis_obj));
+    } else {
+        emit_write_bytecode_byte(emit, 1, MP_BC_LOAD_CONST_FALSE + (tok - MP_TOKEN_KW_FALSE));
     }
 }
 
 void mp_emit_bc_load_const_small_int(emit_t *emit, mp_int_t arg) {
-    emit_bc_pre(emit, 1);
-    if (-16 <= arg && arg <= 47) {
-        emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_SMALL_INT_MULTI + 16 + arg);
+    if (-MP_BC_LOAD_CONST_SMALL_INT_MULTI_EXCESS <= arg
+        && arg < MP_BC_LOAD_CONST_SMALL_INT_MULTI_NUM - MP_BC_LOAD_CONST_SMALL_INT_MULTI_EXCESS) {
+        emit_write_bytecode_byte(emit, 1,
+            MP_BC_LOAD_CONST_SMALL_INT_MULTI + MP_BC_LOAD_CONST_SMALL_INT_MULTI_EXCESS + arg);
     } else {
-        emit_write_bytecode_byte_int(emit, MP_BC_LOAD_CONST_SMALL_INT, arg);
+        emit_write_bytecode_byte_int(emit, 1, MP_BC_LOAD_CONST_SMALL_INT, arg);
     }
 }
 
 void mp_emit_bc_load_const_str(emit_t *emit, qstr qst) {
-    emit_bc_pre(emit, 1);
-    emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_STRING, qst);
+    emit_write_bytecode_byte_qstr(emit, 1, MP_BC_LOAD_CONST_STRING, qst);
 }
 
 void mp_emit_bc_load_const_obj(emit_t *emit, mp_obj_t obj) {
-    emit_bc_pre(emit, 1);
-    emit_write_bytecode_byte_obj(emit, MP_BC_LOAD_CONST_OBJ, obj);
+    emit_write_bytecode_byte_obj(emit, 1, MP_BC_LOAD_CONST_OBJ, obj);
 }
 
 void mp_emit_bc_load_null(emit_t *emit) {
-    emit_bc_pre(emit, 1);
-    emit_write_bytecode_byte(emit, MP_BC_LOAD_NULL);
+    emit_write_bytecode_byte(emit, 1, MP_BC_LOAD_NULL);
 }
 
 void mp_emit_bc_load_local(emit_t *emit, qstr qst, mp_uint_t local_num, int kind) {
     MP_STATIC_ASSERT(MP_BC_LOAD_FAST_N + MP_EMIT_IDOP_LOCAL_FAST == MP_BC_LOAD_FAST_N);
     MP_STATIC_ASSERT(MP_BC_LOAD_FAST_N + MP_EMIT_IDOP_LOCAL_DEREF == MP_BC_LOAD_DEREF);
     (void)qst;
-    emit_bc_pre(emit, 1);
     if (kind == MP_EMIT_IDOP_LOCAL_FAST && local_num <= 15) {
-        emit_write_bytecode_byte(emit, MP_BC_LOAD_FAST_MULTI + local_num);
+        emit_write_bytecode_byte(emit, 1, MP_BC_LOAD_FAST_MULTI + local_num);
     } else {
-        emit_write_bytecode_byte_uint(emit, MP_BC_LOAD_FAST_N + kind, local_num);
+        emit_write_bytecode_byte_uint(emit, 1, MP_BC_LOAD_FAST_N + kind, local_num);
     }
 }
 
@@ -576,51 +559,45 @@ void mp_emit_bc_load_global(emit_t *emit, qstr qst, int kind) {
     MP_STATIC_ASSERT(MP_BC_LOAD_NAME + MP_EMIT_IDOP_GLOBAL_NAME == MP_BC_LOAD_NAME);
     MP_STATIC_ASSERT(MP_BC_LOAD_NAME + MP_EMIT_IDOP_GLOBAL_GLOBAL == MP_BC_LOAD_GLOBAL);
     (void)qst;
-    emit_bc_pre(emit, 1);
-    emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_NAME + kind, qst);
+    emit_write_bytecode_byte_qstr(emit, 1, MP_BC_LOAD_NAME + kind, qst);
     if (MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE_DYNAMIC) {
-        emit_write_bytecode_byte(emit, 0);
+        emit_write_bytecode_raw_byte(emit, 0);
     }
 }
 
 void mp_emit_bc_load_method(emit_t *emit, qstr qst, bool is_super) {
-    emit_bc_pre(emit, 1 - 2 * is_super);
-    emit_write_bytecode_byte_qstr(emit, is_super ? MP_BC_LOAD_SUPER_METHOD : MP_BC_LOAD_METHOD, qst);
+    int stack_adj = 1 - 2 * is_super;
+    emit_write_bytecode_byte_qstr(emit, stack_adj, is_super ? MP_BC_LOAD_SUPER_METHOD : MP_BC_LOAD_METHOD, qst);
 }
 
 void mp_emit_bc_load_build_class(emit_t *emit) {
-    emit_bc_pre(emit, 1);
-    emit_write_bytecode_byte(emit, MP_BC_LOAD_BUILD_CLASS);
+    emit_write_bytecode_byte(emit, 1, MP_BC_LOAD_BUILD_CLASS);
 }
 
 void mp_emit_bc_subscr(emit_t *emit, int kind) {
     if (kind == MP_EMIT_SUBSCR_LOAD) {
-        emit_bc_pre(emit, -1);
-        emit_write_bytecode_byte(emit, MP_BC_LOAD_SUBSCR);
+        emit_write_bytecode_byte(emit, -1, MP_BC_LOAD_SUBSCR);
     } else {
         if (kind == MP_EMIT_SUBSCR_DELETE) {
             mp_emit_bc_load_null(emit);
             mp_emit_bc_rot_three(emit);
         }
-        emit_bc_pre(emit, -3);
-        emit_write_bytecode_byte(emit, MP_BC_STORE_SUBSCR);
+        emit_write_bytecode_byte(emit, -3, MP_BC_STORE_SUBSCR);
     }
 }
 
 void mp_emit_bc_attr(emit_t *emit, qstr qst, int kind) {
     if (kind == MP_EMIT_ATTR_LOAD) {
-        emit_bc_pre(emit, 0);
-        emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_ATTR, qst);
+        emit_write_bytecode_byte_qstr(emit, 0, MP_BC_LOAD_ATTR, qst);
     } else {
         if (kind == MP_EMIT_ATTR_DELETE) {
             mp_emit_bc_load_null(emit);
             mp_emit_bc_rot_two(emit);
         }
-        emit_bc_pre(emit, -2);
-        emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_ATTR, qst);
+        emit_write_bytecode_byte_qstr(emit, -2, MP_BC_STORE_ATTR, qst);
     }
     if (MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE_DYNAMIC) {
-        emit_write_bytecode_byte(emit, 0);
+        emit_write_bytecode_raw_byte(emit, 0);
     }
 }
 
@@ -628,98 +605,86 @@ void mp_emit_bc_store_local(emit_t *emit, qstr qst, mp_uint_t local_num, int kin
     MP_STATIC_ASSERT(MP_BC_STORE_FAST_N + MP_EMIT_IDOP_LOCAL_FAST == MP_BC_STORE_FAST_N);
     MP_STATIC_ASSERT(MP_BC_STORE_FAST_N + MP_EMIT_IDOP_LOCAL_DEREF == MP_BC_STORE_DEREF);
     (void)qst;
-    emit_bc_pre(emit, -1);
     if (kind == MP_EMIT_IDOP_LOCAL_FAST && local_num <= 15) {
-        emit_write_bytecode_byte(emit, MP_BC_STORE_FAST_MULTI + local_num);
+        emit_write_bytecode_byte(emit, -1, MP_BC_STORE_FAST_MULTI + local_num);
     } else {
-        emit_write_bytecode_byte_uint(emit, MP_BC_STORE_FAST_N + kind, local_num);
+        emit_write_bytecode_byte_uint(emit, -1, MP_BC_STORE_FAST_N + kind, local_num);
     }
 }
 
 void mp_emit_bc_store_global(emit_t *emit, qstr qst, int kind) {
     MP_STATIC_ASSERT(MP_BC_STORE_NAME + MP_EMIT_IDOP_GLOBAL_NAME == MP_BC_STORE_NAME);
     MP_STATIC_ASSERT(MP_BC_STORE_NAME + MP_EMIT_IDOP_GLOBAL_GLOBAL == MP_BC_STORE_GLOBAL);
-    emit_bc_pre(emit, -1);
-    emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_NAME + kind, qst);
+    emit_write_bytecode_byte_qstr(emit, -1, MP_BC_STORE_NAME + kind, qst);
 }
 
 void mp_emit_bc_delete_local(emit_t *emit, qstr qst, mp_uint_t local_num, int kind) {
     MP_STATIC_ASSERT(MP_BC_DELETE_FAST + MP_EMIT_IDOP_LOCAL_FAST == MP_BC_DELETE_FAST);
     MP_STATIC_ASSERT(MP_BC_DELETE_FAST + MP_EMIT_IDOP_LOCAL_DEREF == MP_BC_DELETE_DEREF);
     (void)qst;
-    emit_write_bytecode_byte_uint(emit, MP_BC_DELETE_FAST + kind, local_num);
+    emit_write_bytecode_byte_uint(emit, 0, MP_BC_DELETE_FAST + kind, local_num);
 }
 
 void mp_emit_bc_delete_global(emit_t *emit, qstr qst, int kind) {
     MP_STATIC_ASSERT(MP_BC_DELETE_NAME + MP_EMIT_IDOP_GLOBAL_NAME == MP_BC_DELETE_NAME);
     MP_STATIC_ASSERT(MP_BC_DELETE_NAME + MP_EMIT_IDOP_GLOBAL_GLOBAL == MP_BC_DELETE_GLOBAL);
-    emit_bc_pre(emit, 0);
-    emit_write_bytecode_byte_qstr(emit, MP_BC_DELETE_NAME + kind, qst);
+    emit_write_bytecode_byte_qstr(emit, 0, MP_BC_DELETE_NAME + kind, qst);
 }
 
 void mp_emit_bc_dup_top(emit_t *emit) {
-    emit_bc_pre(emit, 1);
-    emit_write_bytecode_byte(emit, MP_BC_DUP_TOP);
+    emit_write_bytecode_byte(emit, 1, MP_BC_DUP_TOP);
 }
 
 void mp_emit_bc_dup_top_two(emit_t *emit) {
-    emit_bc_pre(emit, 2);
-    emit_write_bytecode_byte(emit, MP_BC_DUP_TOP_TWO);
+    emit_write_bytecode_byte(emit, 2, MP_BC_DUP_TOP_TWO);
 }
 
 void mp_emit_bc_pop_top(emit_t *emit) {
-    emit_bc_pre(emit, -1);
-    emit_write_bytecode_byte(emit, MP_BC_POP_TOP);
+    emit_write_bytecode_byte(emit, -1, MP_BC_POP_TOP);
 }
 
 void mp_emit_bc_rot_two(emit_t *emit) {
-    emit_bc_pre(emit, 0);
-    emit_write_bytecode_byte(emit, MP_BC_ROT_TWO);
+    emit_write_bytecode_byte(emit, 0, MP_BC_ROT_TWO);
 }
 
 void mp_emit_bc_rot_three(emit_t *emit) {
-    emit_bc_pre(emit, 0);
-    emit_write_bytecode_byte(emit, MP_BC_ROT_THREE);
+    emit_write_bytecode_byte(emit, 0, MP_BC_ROT_THREE);
 }
 
 void mp_emit_bc_jump(emit_t *emit, mp_uint_t label) {
-    emit_bc_pre(emit, 0);
-    emit_write_bytecode_byte_signed_label(emit, MP_BC_JUMP, label);
+    emit_write_bytecode_byte_signed_label(emit, 0, MP_BC_JUMP, label);
 }
 
 void mp_emit_bc_pop_jump_if(emit_t *emit, bool cond, mp_uint_t label) {
-    emit_bc_pre(emit, -1);
     if (cond) {
-        emit_write_bytecode_byte_signed_label(emit, MP_BC_POP_JUMP_IF_TRUE, label);
+        emit_write_bytecode_byte_signed_label(emit, -1, MP_BC_POP_JUMP_IF_TRUE, label);
     } else {
-        emit_write_bytecode_byte_signed_label(emit, MP_BC_POP_JUMP_IF_FALSE, label);
+        emit_write_bytecode_byte_signed_label(emit, -1, MP_BC_POP_JUMP_IF_FALSE, label);
     }
 }
 
 void mp_emit_bc_jump_if_or_pop(emit_t *emit, bool cond, mp_uint_t label) {
-    emit_bc_pre(emit, -1);
     if (cond) {
-        emit_write_bytecode_byte_signed_label(emit, MP_BC_JUMP_IF_TRUE_OR_POP, label);
+        emit_write_bytecode_byte_signed_label(emit, -1, MP_BC_JUMP_IF_TRUE_OR_POP, label);
     } else {
-        emit_write_bytecode_byte_signed_label(emit, MP_BC_JUMP_IF_FALSE_OR_POP, label);
+        emit_write_bytecode_byte_signed_label(emit, -1, MP_BC_JUMP_IF_FALSE_OR_POP, label);
     }
 }
 
 void mp_emit_bc_unwind_jump(emit_t *emit, mp_uint_t label, mp_uint_t except_depth) {
     if (except_depth == 0) {
-        emit_bc_pre(emit, 0);
         if (label & MP_EMIT_BREAK_FROM_FOR) {
             // need to pop the iterator if we are breaking out of a for loop
-            emit_write_bytecode_byte(emit, MP_BC_POP_TOP);
+            emit_write_bytecode_raw_byte(emit, MP_BC_POP_TOP);
             // also pop the iter_buf
             for (size_t i = 0; i < MP_OBJ_ITER_BUF_NSLOTS - 1; ++i) {
-                emit_write_bytecode_byte(emit, MP_BC_POP_TOP);
+                emit_write_bytecode_raw_byte(emit, MP_BC_POP_TOP);
             }
         }
-        emit_write_bytecode_byte_signed_label(emit, MP_BC_JUMP, label & ~MP_EMIT_BREAK_FROM_FOR);
+        emit_write_bytecode_byte_signed_label(emit, 0, MP_BC_JUMP, label & ~MP_EMIT_BREAK_FROM_FOR);
     } else {
-        emit_write_bytecode_byte_signed_label(emit, MP_BC_UNWIND_JUMP, label & ~MP_EMIT_BREAK_FROM_FOR);
-        emit_write_bytecode_byte(emit, ((label & MP_EMIT_BREAK_FROM_FOR) ? 0x80 : 0) | except_depth);
+        emit_write_bytecode_byte_signed_label(emit, 0, MP_BC_UNWIND_JUMP, label & ~MP_EMIT_BREAK_FROM_FOR);
+        emit_write_bytecode_raw_byte(emit, ((label & MP_EMIT_BREAK_FROM_FOR) ? 0x80 : 0) | except_depth);
     }
 }
 
@@ -727,52 +692,45 @@ void mp_emit_bc_setup_block(emit_t *emit, mp_uint_t label, int kind) {
     MP_STATIC_ASSERT(MP_BC_SETUP_WITH + MP_EMIT_SETUP_BLOCK_WITH == MP_BC_SETUP_WITH);
     MP_STATIC_ASSERT(MP_BC_SETUP_WITH + MP_EMIT_SETUP_BLOCK_EXCEPT == MP_BC_SETUP_EXCEPT);
     MP_STATIC_ASSERT(MP_BC_SETUP_WITH + MP_EMIT_SETUP_BLOCK_FINALLY == MP_BC_SETUP_FINALLY);
-    if (kind == MP_EMIT_SETUP_BLOCK_WITH) {
     // The SETUP_WITH opcode pops ctx_mgr from the top of the stack
     // and then pushes 3 entries: __exit__, ctx_mgr, as_value.
-        emit_bc_pre(emit, 2);
-    } else {
-        emit_bc_pre(emit, 0);
-    }
-    emit_write_bytecode_byte_unsigned_label(emit, MP_BC_SETUP_WITH + kind, label);
+    int stack_adj = kind == MP_EMIT_SETUP_BLOCK_WITH ? 2 : 0;
+    emit_write_bytecode_byte_unsigned_label(emit, stack_adj, MP_BC_SETUP_WITH + kind, label);
 }
 
 void mp_emit_bc_with_cleanup(emit_t *emit, mp_uint_t label) {
     mp_emit_bc_load_const_tok(emit, MP_TOKEN_KW_NONE);
     mp_emit_bc_label_assign(emit, label);
-    emit_bc_pre(emit, 2); // ensure we have enough stack space to call the __exit__ method
-    emit_write_bytecode_byte(emit, MP_BC_WITH_CLEANUP);
-    emit_bc_pre(emit, -4); // cancel the 2 above, plus the 2 from mp_emit_bc_setup_block(MP_EMIT_SETUP_BLOCK_WITH)
+    // The +2 is to ensure we have enough stack space to call the __exit__ method
+    emit_write_bytecode_byte(emit, 2, MP_BC_WITH_CLEANUP);
+    // Cancel the +2 above, plus the +2 from mp_emit_bc_setup_block(MP_EMIT_SETUP_BLOCK_WITH)
+    mp_emit_bc_adjust_stack_size(emit, -4);
 }
 
 void mp_emit_bc_end_finally(emit_t *emit) {
-    emit_bc_pre(emit, -1);
-    emit_write_bytecode_byte(emit, MP_BC_END_FINALLY);
+    emit_write_bytecode_byte(emit, -1, MP_BC_END_FINALLY);
 }
 
 void mp_emit_bc_get_iter(emit_t *emit, bool use_stack) {
-    emit_bc_pre(emit, use_stack ? MP_OBJ_ITER_BUF_NSLOTS - 1 : 0);
-    emit_write_bytecode_byte(emit, use_stack ? MP_BC_GET_ITER_STACK : MP_BC_GET_ITER);
+    int stack_adj = use_stack ? MP_OBJ_ITER_BUF_NSLOTS - 1 : 0;
+    emit_write_bytecode_byte(emit, stack_adj, use_stack ? MP_BC_GET_ITER_STACK : MP_BC_GET_ITER);
 }
 
 void mp_emit_bc_for_iter(emit_t *emit, mp_uint_t label) {
-    emit_bc_pre(emit, 1);
-    emit_write_bytecode_byte_unsigned_label(emit, MP_BC_FOR_ITER, label);
+    emit_write_bytecode_byte_unsigned_label(emit, 1, MP_BC_FOR_ITER, label);
 }
 
 void mp_emit_bc_for_iter_end(emit_t *emit) {
-    emit_bc_pre(emit, -MP_OBJ_ITER_BUF_NSLOTS);
+    mp_emit_bc_adjust_stack_size(emit, -MP_OBJ_ITER_BUF_NSLOTS);
 }
 
 void mp_emit_bc_pop_except_jump(emit_t *emit, mp_uint_t label, bool within_exc_handler) {
     (void)within_exc_handler;
-    emit_bc_pre(emit, 0);
-    emit_write_bytecode_byte_unsigned_label(emit, MP_BC_POP_EXCEPT_JUMP, label);
+    emit_write_bytecode_byte_unsigned_label(emit, 0, MP_BC_POP_EXCEPT_JUMP, label);
 }
 
 void mp_emit_bc_unary_op(emit_t *emit, mp_unary_op_t op) {
-    emit_bc_pre(emit, 0);
-    emit_write_bytecode_byte(emit, MP_BC_UNARY_OP_MULTI + op);
+    emit_write_bytecode_byte(emit, 0, MP_BC_UNARY_OP_MULTI + op);
 }
 
 void mp_emit_bc_binary_op(emit_t *emit, mp_binary_op_t op) {
@@ -784,11 +742,9 @@ void mp_emit_bc_binary_op(emit_t *emit, mp_binary_op_t op) {
         invert = true;
         op = MP_BINARY_OP_IS;
     }
-    emit_bc_pre(emit, -1);
-    emit_write_bytecode_byte(emit, MP_BC_BINARY_OP_MULTI + op);
+    emit_write_bytecode_byte(emit, -1, MP_BC_BINARY_OP_MULTI + op);
     if (invert) {
-        emit_bc_pre(emit, 0);
-        emit_write_bytecode_byte(emit, MP_BC_UNARY_OP_MULTI + MP_UNARY_OP_NOT);
+        emit_write_bytecode_byte(emit, 0, MP_BC_UNARY_OP_MULTI + MP_UNARY_OP_NOT);
     }
 }
 
@@ -798,17 +754,12 @@ void mp_emit_bc_build(emit_t *emit, mp_uint_t n_args, int kind) {
     MP_STATIC_ASSERT(MP_BC_BUILD_TUPLE + MP_EMIT_BUILD_MAP == MP_BC_BUILD_MAP);
     MP_STATIC_ASSERT(MP_BC_BUILD_TUPLE + MP_EMIT_BUILD_SET == MP_BC_BUILD_SET);
     MP_STATIC_ASSERT(MP_BC_BUILD_TUPLE + MP_EMIT_BUILD_SLICE == MP_BC_BUILD_SLICE);
-    if (kind == MP_EMIT_BUILD_MAP) {
-        emit_bc_pre(emit, 1);
-    } else {
-        emit_bc_pre(emit, 1 - n_args);
-    }
-    emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_TUPLE + kind, n_args);
+    int stack_adj = kind == MP_EMIT_BUILD_MAP ? 1 : 1 - n_args;
+    emit_write_bytecode_byte_uint(emit, stack_adj, MP_BC_BUILD_TUPLE + kind, n_args);
 }
 
 void mp_emit_bc_store_map(emit_t *emit) {
-    emit_bc_pre(emit, -2);
-    emit_write_bytecode_byte(emit, MP_BC_STORE_MAP);
+    emit_write_bytecode_byte(emit, -2, MP_BC_STORE_MAP);
 }
 
 void mp_emit_bc_store_comp(emit_t *emit, scope_kind_t kind, mp_uint_t collection_stack_index) {
@@ -824,51 +775,46 @@ void mp_emit_bc_store_comp(emit_t *emit, scope_kind_t kind, mp_uint_t collection
         n = 0;
         t = 2;
     }
-    emit_bc_pre(emit, -1 - n);
     // the lower 2 bits of the opcode argument indicate the collection type
-    emit_write_bytecode_byte_uint(emit, MP_BC_STORE_COMP, ((collection_stack_index + n) << 2) | t);
+    emit_write_bytecode_byte_uint(emit, -1 - n, MP_BC_STORE_COMP, ((collection_stack_index + n) << 2) | t);
 }
 
 void mp_emit_bc_unpack_sequence(emit_t *emit, mp_uint_t n_args) {
-    emit_bc_pre(emit, -1 + n_args);
-    emit_write_bytecode_byte_uint(emit, MP_BC_UNPACK_SEQUENCE, n_args);
+    emit_write_bytecode_byte_uint(emit, -1 + n_args, MP_BC_UNPACK_SEQUENCE, n_args);
 }
 
 void mp_emit_bc_unpack_ex(emit_t *emit, mp_uint_t n_left, mp_uint_t n_right) {
-    emit_bc_pre(emit, -1 + n_left + n_right + 1);
-    emit_write_bytecode_byte_uint(emit, MP_BC_UNPACK_EX, n_left | (n_right << 8));
+    emit_write_bytecode_byte_uint(emit, -1 + n_left + n_right + 1, MP_BC_UNPACK_EX, n_left | (n_right << 8));
 }
 
 void mp_emit_bc_make_function(emit_t *emit, scope_t *scope, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults) {
     if (n_pos_defaults == 0 && n_kw_defaults == 0) {
-        emit_bc_pre(emit, 1);
-        emit_write_bytecode_byte_raw_code(emit, MP_BC_MAKE_FUNCTION, scope->raw_code);
+        emit_write_bytecode_byte_raw_code(emit, 1, MP_BC_MAKE_FUNCTION, scope->raw_code);
     } else {
-        emit_bc_pre(emit, -1);
-        emit_write_bytecode_byte_raw_code(emit, MP_BC_MAKE_FUNCTION_DEFARGS, scope->raw_code);
+        emit_write_bytecode_byte_raw_code(emit, -1, MP_BC_MAKE_FUNCTION_DEFARGS, scope->raw_code);
     }
 }
 
 void mp_emit_bc_make_closure(emit_t *emit, scope_t *scope, mp_uint_t n_closed_over, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults) {
     if (n_pos_defaults == 0 && n_kw_defaults == 0) {
-        emit_bc_pre(emit, -n_closed_over + 1);
-        emit_write_bytecode_byte_raw_code(emit, MP_BC_MAKE_CLOSURE, scope->raw_code);
-        emit_write_bytecode_byte(emit, n_closed_over);
+        int stack_adj = -n_closed_over + 1;
+        emit_write_bytecode_byte_raw_code(emit, stack_adj, MP_BC_MAKE_CLOSURE, scope->raw_code);
+        emit_write_bytecode_raw_byte(emit, n_closed_over);
     } else {
         assert(n_closed_over <= 255);
-        emit_bc_pre(emit, -2 - (mp_int_t)n_closed_over + 1);
-        emit_write_bytecode_byte_raw_code(emit, MP_BC_MAKE_CLOSURE_DEFARGS, scope->raw_code);
-        emit_write_bytecode_byte(emit, n_closed_over);
+        int stack_adj = -2 - (mp_int_t)n_closed_over + 1;
+        emit_write_bytecode_byte_raw_code(emit, stack_adj, MP_BC_MAKE_CLOSURE_DEFARGS, scope->raw_code);
+        emit_write_bytecode_raw_byte(emit, n_closed_over);
     }
 }
 
-STATIC void emit_bc_call_function_method_helper(emit_t *emit, mp_int_t stack_adj, mp_uint_t bytecode_base, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags) {
+STATIC void emit_bc_call_function_method_helper(emit_t *emit, int stack_adj, mp_uint_t bytecode_base, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags) {
     if (star_flags) {
-        emit_bc_pre(emit, stack_adj - (mp_int_t)n_positional - 2 * (mp_int_t)n_keyword - 2);
-        emit_write_bytecode_byte_uint(emit, bytecode_base + 1, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints?
+        stack_adj -= (int)n_positional + 2 * (int)n_keyword + 2;
+        emit_write_bytecode_byte_uint(emit, stack_adj, bytecode_base + 1, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints?
     } else {
-        emit_bc_pre(emit, stack_adj - (mp_int_t)n_positional - 2 * (mp_int_t)n_keyword);
-        emit_write_bytecode_byte_uint(emit, bytecode_base, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints?
+        stack_adj -= (int)n_positional + 2 * (int)n_keyword;
+        emit_write_bytecode_byte_uint(emit, stack_adj, bytecode_base, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints?
     }
 }
 
@@ -881,22 +827,21 @@ void mp_emit_bc_call_method(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_ke
 }
 
 void mp_emit_bc_return_value(emit_t *emit) {
-    emit_bc_pre(emit, -1);
+    emit_write_bytecode_byte(emit, -1, MP_BC_RETURN_VALUE);
     emit->last_emit_was_return_value = true;
-    emit_write_bytecode_byte(emit, MP_BC_RETURN_VALUE);
 }
 
 void mp_emit_bc_raise_varargs(emit_t *emit, mp_uint_t n_args) {
+    MP_STATIC_ASSERT(MP_BC_RAISE_LAST + 1 == MP_BC_RAISE_OBJ);
+    MP_STATIC_ASSERT(MP_BC_RAISE_LAST + 2 == MP_BC_RAISE_FROM);
     assert(n_args <= 2);
-    emit_bc_pre(emit, -n_args);
-    emit_write_bytecode_byte_byte(emit, MP_BC_RAISE_VARARGS, n_args);
+    emit_write_bytecode_byte(emit, -n_args, MP_BC_RAISE_LAST + n_args);
 }
 
 void mp_emit_bc_yield(emit_t *emit, int kind) {
     MP_STATIC_ASSERT(MP_BC_YIELD_VALUE + 1 == MP_BC_YIELD_FROM);
-    emit_bc_pre(emit, -kind);
+    emit_write_bytecode_byte(emit, -kind, MP_BC_YIELD_VALUE + kind);
     emit->scope->scope_flags |= MP_SCOPE_FLAG_GENERATOR;
-    emit_write_bytecode_byte(emit, MP_BC_YIELD_VALUE + kind);
 }
 
 void mp_emit_bc_start_except_handler(emit_t *emit) {
@@ -995,4 +940,4 @@ const mp_emit_method_table_id_ops_t mp_emit_bc_method_table_delete_id_ops = {
 };
 #endif
 
-#endif //MICROPY_ENABLE_COMPILER
+#endif // MICROPY_ENABLE_COMPILER
diff --git a/py/emitglue.c b/py/emitglue.c
index c073258f01674..98320c426bc63 100644
--- a/py/emitglue.c
+++ b/py/emitglue.c
@@ -34,6 +34,7 @@
 #include "py/emitglue.h"
 #include "py/runtime0.h"
 #include "py/bc.h"
+#include "py/profile.h"
 
 #if MICROPY_DEBUG_VERBOSE // print debugging info
 #define DEBUG_PRINT (1)
@@ -52,6 +53,9 @@ mp_uint_t mp_verbose_flag = 0;
 mp_raw_code_t *mp_emit_glue_new_raw_code(void) {
     mp_raw_code_t *rc = m_new0(mp_raw_code_t, 1);
     rc->kind = MP_CODE_RESERVED;
+    #if MICROPY_PY_SYS_SETTRACE
+    rc->line_of_definition = 0;
+    #endif
     return rc;
 }
 
@@ -75,20 +79,25 @@ void mp_emit_glue_assign_bytecode(mp_raw_code_t *rc, const byte *code,
     rc->n_raw_code = n_raw_code;
     #endif
 
-#ifdef DEBUG_PRINT
+    #if MICROPY_PY_SYS_SETTRACE
+    mp_bytecode_prelude_t *prelude = &rc->prelude;
+    mp_prof_extract_prelude(code, prelude);
+    #endif
+
+    #ifdef DEBUG_PRINT
     #if !MICROPY_DEBUG_PRINTERS
     const size_t len = 0;
     #endif
     DEBUG_printf("assign byte code: code=%p len=" UINT_FMT " flags=%x\n", code, len, (uint)scope_flags);
-#endif
-#if MICROPY_DEBUG_PRINTERS
+    #endif
+    #if MICROPY_DEBUG_PRINTERS
     if (mp_verbose_flag >= 2) {
         mp_bytecode_print(rc, code, len, const_table);
     }
-#endif
+    #endif
 }
 
-#if MICROPY_EMIT_NATIVE || MICROPY_EMIT_INLINE_ASM
+#if MICROPY_EMIT_MACHINE_CODE
 void mp_emit_glue_assign_native(mp_raw_code_t *rc, mp_raw_code_kind_t kind, void *fun_data, mp_uint_t fun_len, const mp_uint_t *const_table,
     #if MICROPY_PERSISTENT_CODE_SAVE
     uint16_t prelude_offset,
@@ -111,28 +120,28 @@ void mp_emit_glue_assign_native(mp_raw_code_t *rc, mp_raw_code_kind_t kind, void
     rc->prelude_offset = prelude_offset;
     rc->n_obj = n_obj;
     rc->n_raw_code = n_raw_code;
-    rc->n_qstr= n_qstr;
+    rc->n_qstr = n_qstr;
     rc->qstr_link = qstr_link;
     #endif
 
-#ifdef DEBUG_PRINT
+    #ifdef DEBUG_PRINT
     DEBUG_printf("assign native: kind=%d fun=%p len=" UINT_FMT " n_pos_args=" UINT_FMT " flags=%x\n", kind, fun_data, fun_len, n_pos_args, (uint)scope_flags);
     for (mp_uint_t i = 0; i < fun_len; i++) {
         if (i > 0 && i % 16 == 0) {
             DEBUG_printf("\n");
         }
-        DEBUG_printf(" %02x", ((byte*)fun_data)[i]);
+        DEBUG_printf(" %02x", ((byte *)fun_data)[i]);
     }
     DEBUG_printf("\n");
 
-#ifdef WRITE_CODE
+    #ifdef WRITE_CODE
     FILE *fp_write_code = fopen("out-code", "wb");
     fwrite(fun_data, fun_len, 1, fp_write_code);
     fclose(fp_write_code);
-#endif
-#else
+    #endif
+    #else
     (void)fun_len;
-#endif
+    #endif
 }
 #endif
 
@@ -155,7 +164,7 @@ mp_obj_t mp_make_function_from_raw_code(const mp_raw_code_t *rc, mp_obj_t def_ar
             fun = mp_obj_new_fun_native(def_args, def_kw_args, rc->fun_data, rc->const_table);
             // Check for a generator function, and if so change the type of the object
             if ((rc->scope_flags & MP_SCOPE_FLAG_GENERATOR) != 0) {
-                ((mp_obj_base_t*)MP_OBJ_TO_PTR(fun))->type = &mp_type_native_gen_wrap;
+                ((mp_obj_base_t *)MP_OBJ_TO_PTR(fun))->type = &mp_type_native_gen_wrap;
             }
             break;
         #endif
@@ -170,8 +179,14 @@ mp_obj_t mp_make_function_from_raw_code(const mp_raw_code_t *rc, mp_obj_t def_ar
             fun = mp_obj_new_fun_bc(def_args, def_kw_args, rc->fun_data, rc->const_table);
             // check for generator functions and if so change the type of the object
             if ((rc->scope_flags & MP_SCOPE_FLAG_GENERATOR) != 0) {
-                ((mp_obj_base_t*)MP_OBJ_TO_PTR(fun))->type = &mp_type_gen_wrap;
+                ((mp_obj_base_t *)MP_OBJ_TO_PTR(fun))->type = &mp_type_gen_wrap;
             }
+
+            #if MICROPY_PY_SYS_SETTRACE
+            mp_obj_fun_bc_t *self_fun = (mp_obj_fun_bc_t *)MP_OBJ_TO_PTR(fun);
+            self_fun->rc = rc;
+            #endif
+
             break;
     }
 
diff --git a/py/emitglue.h b/py/emitglue.h
index 058f060186476..a5411dc2e205f 100644
--- a/py/emitglue.h
+++ b/py/emitglue.h
@@ -27,6 +27,7 @@
 #define MICROPY_INCLUDED_PY_EMITGLUE_H
 
 #include "py/obj.h"
+#include "py/bc.h"
 
 // These variables and functions glue the code emitters to the runtime.
 
@@ -63,13 +64,21 @@ typedef struct _mp_raw_code_t {
     size_t fun_data_len;
     uint16_t n_obj;
     uint16_t n_raw_code;
-    #if MICROPY_EMIT_NATIVE || MICROPY_EMIT_INLINE_ASM
+    #if MICROPY_PY_SYS_SETTRACE
+    mp_bytecode_prelude_t prelude;
+    // line_of_definition is a Python source line where the raw_code was
+    // created e.g. MP_BC_MAKE_FUNCTION. This is different from lineno info
+    // stored in prelude, which provides line number for first statement of
+    // a function. Required to properly implement "call" trace event.
+    mp_uint_t line_of_definition;
+    #endif
+    #if MICROPY_EMIT_MACHINE_CODE
     uint16_t prelude_offset;
     uint16_t n_qstr;
     mp_qstr_link_entry_t *qstr_link;
     #endif
     #endif
-    #if MICROPY_EMIT_NATIVE || MICROPY_EMIT_INLINE_ASM
+    #if MICROPY_EMIT_MACHINE_CODE
     mp_uint_t type_sig; // for viper, compressed as 2-bit types; ret is MSB, then arg0, arg1, etc
     #endif
 } mp_raw_code_t;
diff --git a/py/emitinlinethumb.c b/py/emitinlinethumb.c
index 020dfc81533fb..2853da26c5465 100644
--- a/py/emitinlinethumb.c
+++ b/py/emitinlinethumb.c
@@ -39,14 +39,14 @@ typedef enum {
 // define rules with a compile function
 #define DEF_RULE(rule, comp, kind, ...) PN_##rule,
 #define DEF_RULE_NC(rule, kind, ...)
-#include "py/grammar.h"
+    #include "py/grammar.h"
 #undef DEF_RULE
 #undef DEF_RULE_NC
     PN_const_object, // special node for a constant, generic Python object
 // define rules without a compile function
 #define DEF_RULE(rule, comp, kind, ...)
 #define DEF_RULE_NC(rule, kind, ...) PN_##rule,
-#include "py/grammar.h"
+    #include "py/grammar.h"
 #undef DEF_RULE
 #undef DEF_RULE_NC
 } pn_kind_t;
@@ -59,7 +59,7 @@ struct _emit_inline_asm_t {
     qstr *label_lookup;
 };
 
-STATIC void emit_inline_thumb_error_msg(emit_inline_asm_t *emit, const char *msg) {
+STATIC void emit_inline_thumb_error_msg(emit_inline_asm_t *emit, mp_rom_error_text_t msg) {
     *emit->error_slot = mp_obj_new_exception_msg(&mp_type_SyntaxError, msg);
 }
 
@@ -99,17 +99,17 @@ STATIC void emit_inline_thumb_end_pass(emit_inline_asm_t *emit, mp_uint_t type_s
 
 STATIC mp_uint_t emit_inline_thumb_count_params(emit_inline_asm_t *emit, mp_uint_t n_params, mp_parse_node_t *pn_params) {
     if (n_params > 4) {
-        emit_inline_thumb_error_msg(emit, "can only have up to 4 parameters to Thumb assembly");
+        emit_inline_thumb_error_msg(emit, MP_ERROR_TEXT("can only have up to 4 parameters to Thumb assembly"));
         return 0;
     }
     for (mp_uint_t i = 0; i < n_params; i++) {
         if (!MP_PARSE_NODE_IS_ID(pn_params[i])) {
-            emit_inline_thumb_error_msg(emit, "parameters must be registers in sequence r0 to r3");
+            emit_inline_thumb_error_msg(emit, MP_ERROR_TEXT("parameters must be registers in sequence r0 to r3"));
             return 0;
         }
         const char *p = qstr_str(MP_PARSE_NODE_LEAF_ARG(pn_params[i]));
         if (!(strlen(p) == 2 && p[0] == 'r' && p[1] == '0' + i)) {
-            emit_inline_thumb_error_msg(emit, "parameters must be registers in sequence r0 to r3");
+            emit_inline_thumb_error_msg(emit, MP_ERROR_TEXT("parameters must be registers in sequence r0 to r3"));
             return 0;
         }
     }
@@ -131,7 +131,9 @@ STATIC bool emit_inline_thumb_label(emit_inline_asm_t *emit, mp_uint_t label_num
     return true;
 }
 
-typedef struct _reg_name_t { byte reg; byte name[3]; } reg_name_t;
+typedef struct _reg_name_t { byte reg;
+                             byte name[3];
+} reg_name_t;
 STATIC const reg_name_t reg_name_table[] = {
     {0, "r0\0"},
     {1, "r1\0"},
@@ -157,7 +159,9 @@ STATIC const reg_name_t reg_name_table[] = {
 };
 
 #define MAX_SPECIAL_REGISTER_NAME_LENGTH 7
-typedef struct _special_reg_name_t { byte reg; char name[MAX_SPECIAL_REGISTER_NAME_LENGTH + 1]; } special_reg_name_t;
+typedef struct _special_reg_name_t { byte reg;
+                                     char name[MAX_SPECIAL_REGISTER_NAME_LENGTH + 1];
+} special_reg_name_t;
 STATIC const special_reg_name_t special_reg_name_table[] = {
     {5, "IPSR"},
     {17, "BASEPRI"},
@@ -185,7 +189,7 @@ STATIC mp_uint_t get_arg_reg(emit_inline_asm_t *emit, const char *op, mp_parse_n
             if (r->reg > max_reg) {
                 emit_inline_thumb_error_exc(emit,
                     mp_obj_new_exception_msg_varg(&mp_type_SyntaxError,
-                        "'%s' expects at most r%d", op, max_reg));
+                        MP_ERROR_TEXT("'%s' expects at most r%d"), op, max_reg));
                 return 0;
             } else {
                 return r->reg;
@@ -194,7 +198,7 @@ STATIC mp_uint_t get_arg_reg(emit_inline_asm_t *emit, const char *op, mp_parse_n
     }
     emit_inline_thumb_error_exc(emit,
         mp_obj_new_exception_msg_varg(&mp_type_SyntaxError,
-            "'%s' expects a register", op));
+            MP_ERROR_TEXT("'%s' expects a register"), op));
     return 0;
 }
 
@@ -208,7 +212,7 @@ STATIC mp_uint_t get_arg_special_reg(emit_inline_asm_t *emit, const char *op, mp
     }
     emit_inline_thumb_error_exc(emit,
         mp_obj_new_exception_msg_varg(&mp_type_SyntaxError,
-            "'%s' expects a special register", op));
+            MP_ERROR_TEXT("'%s' expects a special register"), op));
     return 0;
 }
 
@@ -226,8 +230,8 @@ STATIC mp_uint_t get_arg_vfpreg(emit_inline_asm_t *emit, const char *op, mp_pars
         }
         if (regno > 31) {
             emit_inline_thumb_error_exc(emit,
-                 mp_obj_new_exception_msg_varg(&mp_type_SyntaxError,
-                       "'%s' expects at most r%d", op, 31));
+                mp_obj_new_exception_msg_varg(&mp_type_SyntaxError,
+                    MP_ERROR_TEXT("'%s' expects at most r%d"), op, 31));
             return 0;
         } else {
             return regno;
@@ -235,8 +239,8 @@ STATIC mp_uint_t get_arg_vfpreg(emit_inline_asm_t *emit, const char *op, mp_pars
     }
 malformed:
     emit_inline_thumb_error_exc(emit,
-         mp_obj_new_exception_msg_varg(&mp_type_SyntaxError,
-            "'%s' expects an FPU register", op));
+        mp_obj_new_exception_msg_varg(&mp_type_SyntaxError,
+            MP_ERROR_TEXT("'%s' expects an FPU register"), op));
     return 0;
 }
 #endif
@@ -248,7 +252,7 @@ STATIC mp_uint_t get_arg_reglist(emit_inline_asm_t *emit, const char *op, mp_par
         goto bad_arg;
     }
 
-    mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+    mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
     assert(MP_PARSE_NODE_STRUCT_NUM_NODES(pns) == 1); // should always be
     pn = pns->nodes[0];
 
@@ -258,10 +262,10 @@ STATIC mp_uint_t get_arg_reglist(emit_inline_asm_t *emit, const char *op, mp_par
         // set with one element
         reglist |= 1 << get_arg_reg(emit, op, pn, 15);
     } else if (MP_PARSE_NODE_IS_STRUCT(pn)) {
-        pns = (mp_parse_node_struct_t*)pn;
+        pns = (mp_parse_node_struct_t *)pn;
         if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_dictorsetmaker) {
             assert(MP_PARSE_NODE_IS_STRUCT(pns->nodes[1])); // should succeed
-            mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pns->nodes[1];
+            mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pns->nodes[1];
             if (MP_PARSE_NODE_STRUCT_KIND(pns1) == PN_dictorsetmaker_list) {
                 // set with multiple elements
 
@@ -289,19 +293,19 @@ STATIC mp_uint_t get_arg_reglist(emit_inline_asm_t *emit, const char *op, mp_par
     return reglist;
 
 bad_arg:
-    emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects {r0, r1, ...}", op));
+    emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' expects {r0, r1, ...}"), op));
     return 0;
 }
 
 STATIC uint32_t get_arg_i(emit_inline_asm_t *emit, const char *op, mp_parse_node_t pn, uint32_t fit_mask) {
     mp_obj_t o;
     if (!mp_parse_node_get_int_maybe(pn, &o)) {
-        emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects an integer", op));
+        emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' expects an integer"), op));
         return 0;
     }
     uint32_t i = mp_obj_get_int_truncated(o);
     if ((i & (~fit_mask)) != 0) {
-        emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' integer 0x%x doesn't fit in mask 0x%x", op, i, fit_mask));
+        emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' integer 0x%x doesn't fit in mask 0x%x"), op, i, fit_mask));
         return 0;
     }
     return i;
@@ -311,11 +315,11 @@ STATIC bool get_arg_addr(emit_inline_asm_t *emit, const char *op, mp_parse_node_
     if (!MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_atom_bracket)) {
         goto bad_arg;
     }
-    mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+    mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
     if (!MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_testlist_comp)) {
         goto bad_arg;
     }
-    pns = (mp_parse_node_struct_t*)pns->nodes[0];
+    pns = (mp_parse_node_struct_t *)pns->nodes[0];
     if (MP_PARSE_NODE_STRUCT_NUM_NODES(pns) != 2) {
         goto bad_arg;
     }
@@ -325,13 +329,13 @@ STATIC bool get_arg_addr(emit_inline_asm_t *emit, const char *op, mp_parse_node_
     return true;
 
 bad_arg:
-    emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects an address of the form [a, b]", op));
+    emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' expects an address of the form [a, b]"), op));
     return false;
 }
 
 STATIC int get_arg_label(emit_inline_asm_t *emit, const char *op, mp_parse_node_t pn) {
     if (!MP_PARSE_NODE_IS_ID(pn)) {
-        emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects a label", op));
+        emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' expects a label"), op));
         return 0;
     }
     qstr label_qstr = MP_PARSE_NODE_LEAF_ARG(pn);
@@ -342,12 +346,14 @@ STATIC int get_arg_label(emit_inline_asm_t *emit, const char *op, mp_parse_node_
     }
     // only need to have the labels on the last pass
     if (emit->pass == MP_PASS_EMIT) {
-        emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "label '%q' not defined", label_qstr));
+        emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("label '%q' not defined"), label_qstr));
     }
     return 0;
 }
 
-typedef struct _cc_name_t { byte cc; byte name[2]; } cc_name_t;
+typedef struct _cc_name_t { byte cc;
+                            byte name[2];
+} cc_name_t;
 STATIC const cc_name_t cc_name_table[] = {
     { ASM_THUMB_CC_EQ, "eq" },
     { ASM_THUMB_CC_NE, "ne" },
@@ -365,7 +371,9 @@ STATIC const cc_name_t cc_name_table[] = {
     { ASM_THUMB_CC_LE, "le" },
 };
 
-typedef struct _format_4_op_t { byte op; char name[3]; } format_4_op_t;
+typedef struct _format_4_op_t { byte op;
+                                char name[3];
+} format_4_op_t;
 #define X(x) (((x) >> 4) & 0xff) // only need 1 byte to distinguish these ops
 STATIC const format_4_op_t format_4_op_table[] = {
     { X(ASM_THUMB_FORMAT_4_EOR), "eor" },
@@ -387,7 +395,9 @@ STATIC const format_4_op_t format_4_op_table[] = {
 #undef X
 
 // name is actually a qstr, which should fit in 16 bits
-typedef struct _format_9_10_op_t { uint16_t op; uint16_t name; } format_9_10_op_t;
+typedef struct _format_9_10_op_t { uint16_t op;
+                                   uint16_t name;
+} format_9_10_op_t;
 #define X(x) (x)
 STATIC const format_9_10_op_t format_9_10_op_table[] = {
     { X(ASM_THUMB_FORMAT_9_LDR | ASM_THUMB_FORMAT_9_WORD_TRANSFER), MP_QSTR_ldr },
@@ -401,7 +411,9 @@ STATIC const format_9_10_op_t format_9_10_op_table[] = {
 
 #if MICROPY_EMIT_INLINE_THUMB_FLOAT
 // actual opcodes are: 0xee00 | op.hi_nibble, 0x0a00 | op.lo_nibble
-typedef struct _format_vfp_op_t { byte op; char name[3]; } format_vfp_op_t;
+typedef struct _format_vfp_op_t { byte op;
+                                  char name[3];
+} format_vfp_op_t;
 STATIC const format_vfp_op_t format_vfp_op_table[] = {
     { 0x30, "add" },
     { 0x34, "sub" },
@@ -425,7 +437,7 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_a
     // "subs", RLO, RLO, I3, asm_thumb_subs_reg_reg_i3
 
     size_t op_len;
-    const char *op_str = (const char*)qstr_data(op, &op_len);
+    const char *op_str = (const char *)qstr_data(op, &op_len);
 
     #if MICROPY_EMIT_INLINE_THUMB_FLOAT
     if (op_str[0] == 'v') {
@@ -434,7 +446,7 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_a
             mp_uint_t op_code = 0x0ac0, op_code_hi;
             if (op == MP_QSTR_vcmp) {
                 op_code_hi = 0xeeb4;
-                op_vfp_twoargs:;
+            op_vfp_twoargs:;
                 mp_uint_t vd = get_arg_vfpreg(emit, op_str, pn_args[0]);
                 mp_uint_t vm = get_arg_vfpreg(emit, op_str, pn_args[1]);
                 asm_thumb_op32(&emit->as,
@@ -485,7 +497,7 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_a
                     0x0a10 | (r_arm << 12) | ((vm & 1) << 7));
             } else if (op == MP_QSTR_vldr) {
                 op_code_hi = 0xed90;
-                op_vldr_vstr:;
+            op_vldr_vstr:;
                 mp_uint_t vd = get_arg_vfpreg(emit, op_str, pn_args[0]);
                 mp_parse_node_t pn_base, pn_offset;
                 if (get_arg_addr(emit, op_str, pn_args[1], &pn_base, &pn_offset)) {
@@ -521,8 +533,10 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_a
         } else {
             goto unknown_op;
         }
-    } else
+        return;
+    }
     #endif
+
     if (n_args == 0) {
         if (op == MP_QSTR_nop) {
             asm_thumb_op16(&emit->as, ASM_THUMB_OP_NOP);
@@ -547,8 +561,8 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_a
             mp_uint_t r = get_arg_reg(emit, op_str, pn_args[0], 15);
             asm_thumb_op16(&emit->as, 0x4700 | (r << 3));
         } else if (op_str[0] == 'b' && (op_len == 3
-                    || (op_len == 5 && op_str[3] == '_'
-                        && (op_str[4] == 'n' || (ARMV7M && op_str[4] == 'w'))))) {
+                                        || (op_len == 5 && op_str[3] == '_'
+                                            && (op_str[4] == 'n' || (ARMV7M && op_str[4] == 'w'))))) {
             mp_uint_t cc = -1;
             for (mp_uint_t i = 0; i < MP_ARRAY_SIZE(cc_name_table); i++) {
                 if (op_str[1] == cc_name_table[i].name[0] && op_str[2] == cc_name_table[i].name[1]) {
@@ -637,7 +651,7 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_a
                 op_code_hi = 0xfab0;
                 op_code = 0xf080;
                 mp_uint_t rd, rm;
-                op_clz_rbit:
+            op_clz_rbit:
                 rd = get_arg_reg(emit, op_str, pn_args[0], 15);
                 rm = get_arg_reg(emit, op_str, pn_args[1], 15);
                 asm_thumb_op32(&emit->as, op_code_hi | rm, op_code | (rd << 8) | rm);
@@ -645,7 +659,7 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_a
                 op_code_hi = 0xfa90;
                 op_code = 0xf0a0;
                 goto op_clz_rbit;
-            } else if (ARMV7M && op == MP_QSTR_mrs){
+            } else if (ARMV7M && op == MP_QSTR_mrs) {
                 mp_uint_t reg_dest = get_arg_reg(emit, op_str, pn_args[0], 12);
                 mp_uint_t reg_src = get_arg_special_reg(emit, op_str, pn_args[1]);
                 asm_thumb_op32(&emit->as, 0xf3ef, 0x8000 | (reg_dest << 8) | reg_src);
@@ -653,7 +667,7 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_a
                 if (op == MP_QSTR_and_) {
                     op_code = ASM_THUMB_FORMAT_4_AND;
                     mp_uint_t reg_dest, reg_src;
-                    op_format_4:
+                op_format_4:
                     reg_dest = get_arg_reg(emit, op_str, pn_args[0], 7);
                     reg_src = get_arg_reg(emit, op_str, pn_args[1], 7);
                     asm_thumb_format_4(&emit->as, op_code, reg_dest, reg_src);
@@ -674,7 +688,7 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_a
             if (op == MP_QSTR_mov) {
                 op_code = ASM_THUMB_FORMAT_3_MOV;
                 mp_uint_t rlo_dest, i8_src;
-                op_format_3:
+            op_format_3:
                 rlo_dest = get_arg_reg(emit, op_str, pn_args[0], 7);
                 i8_src = get_arg_i(emit, op_str, pn_args[1], 0xff);
                 asm_thumb_format_3(&emit->as, op_code, rlo_dest, i8_src);
@@ -690,7 +704,7 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_a
             } else if (ARMV7M && op == MP_QSTR_movw) {
                 op_code = ASM_THUMB_OP_MOVW;
                 mp_uint_t reg_dest;
-                op_movw_movt:
+            op_movw_movt:
                 reg_dest = get_arg_reg(emit, op_str, pn_args[0], 15);
                 int i_src = get_arg_i(emit, op_str, pn_args[1], 0xffff);
                 asm_thumb_mov_reg_i16(&emit->as, op_code, reg_dest, i_src);
@@ -743,7 +757,7 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_a
         if (op == MP_QSTR_lsl) {
             op_code = ASM_THUMB_FORMAT_1_LSL;
             mp_uint_t rlo_dest, rlo_src, i5;
-            op_format_1:
+        op_format_1:
             rlo_dest = get_arg_reg(emit, op_str, pn_args[0], 7);
             rlo_src = get_arg_reg(emit, op_str, pn_args[1], 7);
             i5 = get_arg_i(emit, op_str, pn_args[2], 0x1f);
@@ -757,7 +771,7 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_a
         } else if (op == MP_QSTR_add) {
             op_code = ASM_THUMB_FORMAT_2_ADD;
             mp_uint_t rlo_dest, rlo_src;
-            op_format_2:
+        op_format_2:
             rlo_dest = get_arg_reg(emit, op_str, pn_args[0], 7);
             rlo_src = get_arg_reg(emit, op_str, pn_args[1], 7);
             int src_b;
@@ -772,7 +786,7 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_a
         } else if (ARMV7M && op == MP_QSTR_sdiv) {
             op_code = 0xfb90; // sdiv high part
             mp_uint_t rd, rn, rm;
-            op_sdiv_udiv:
+        op_sdiv_udiv:
             rd = get_arg_reg(emit, op_str, pn_args[0], 15);
             rn = get_arg_reg(emit, op_str, pn_args[1], 15);
             rm = get_arg_reg(emit, op_str, pn_args[2], 15);
@@ -803,11 +817,11 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_a
     return;
 
 unknown_op:
-    emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "unsupported Thumb instruction '%s' with %d arguments", op_str, n_args));
+    emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("unsupported Thumb instruction '%s' with %d arguments"), op_str, n_args));
     return;
 
 branch_not_in_range:
-    emit_inline_thumb_error_msg(emit, "branch not in range");
+    emit_inline_thumb_error_msg(emit, MP_ERROR_TEXT("branch not in range"));
     return;
 }
 
diff --git a/py/emitinlinextensa.c b/py/emitinlinextensa.c
index d10179127f1b9..6cc2e4d34b6a8 100644
--- a/py/emitinlinextensa.c
+++ b/py/emitinlinextensa.c
@@ -43,7 +43,7 @@ struct _emit_inline_asm_t {
     qstr *label_lookup;
 };
 
-STATIC void emit_inline_xtensa_error_msg(emit_inline_asm_t *emit, const char *msg) {
+STATIC void emit_inline_xtensa_error_msg(emit_inline_asm_t *emit, mp_rom_error_text_t msg) {
     *emit->error_slot = mp_obj_new_exception_msg(&mp_type_SyntaxError, msg);
 }
 
@@ -83,17 +83,17 @@ STATIC void emit_inline_xtensa_end_pass(emit_inline_asm_t *emit, mp_uint_t type_
 
 STATIC mp_uint_t emit_inline_xtensa_count_params(emit_inline_asm_t *emit, mp_uint_t n_params, mp_parse_node_t *pn_params) {
     if (n_params > 4) {
-        emit_inline_xtensa_error_msg(emit, "can only have up to 4 parameters to Xtensa assembly");
+        emit_inline_xtensa_error_msg(emit, MP_ERROR_TEXT("can only have up to 4 parameters to Xtensa assembly"));
         return 0;
     }
     for (mp_uint_t i = 0; i < n_params; i++) {
         if (!MP_PARSE_NODE_IS_ID(pn_params[i])) {
-            emit_inline_xtensa_error_msg(emit, "parameters must be registers in sequence a2 to a5");
+            emit_inline_xtensa_error_msg(emit, MP_ERROR_TEXT("parameters must be registers in sequence a2 to a5"));
             return 0;
         }
         const char *p = qstr_str(MP_PARSE_NODE_LEAF_ARG(pn_params[i]));
         if (!(strlen(p) == 2 && p[0] == 'a' && p[1] == '2' + i)) {
-            emit_inline_xtensa_error_msg(emit, "parameters must be registers in sequence a2 to a5");
+            emit_inline_xtensa_error_msg(emit, MP_ERROR_TEXT("parameters must be registers in sequence a2 to a5"));
             return 0;
         }
     }
@@ -115,7 +115,9 @@ STATIC bool emit_inline_xtensa_label(emit_inline_asm_t *emit, mp_uint_t label_nu
     return true;
 }
 
-typedef struct _reg_name_t { byte reg; byte name[3]; } reg_name_t;
+typedef struct _reg_name_t { byte reg;
+                             byte name[3];
+} reg_name_t;
 STATIC const reg_name_t reg_name_table[] = {
     {0, "a0\0"},
     {1, "a1\0"},
@@ -159,19 +161,19 @@ STATIC mp_uint_t get_arg_reg(emit_inline_asm_t *emit, const char *op, mp_parse_n
     }
     emit_inline_xtensa_error_exc(emit,
         mp_obj_new_exception_msg_varg(&mp_type_SyntaxError,
-            "'%s' expects a register", op));
+            MP_ERROR_TEXT("'%s' expects a register"), op));
     return 0;
 }
 
 STATIC uint32_t get_arg_i(emit_inline_asm_t *emit, const char *op, mp_parse_node_t pn, int min, int max) {
     mp_obj_t o;
     if (!mp_parse_node_get_int_maybe(pn, &o)) {
-        emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects an integer", op));
+        emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' expects an integer"), op));
         return 0;
     }
     uint32_t i = mp_obj_get_int_truncated(o);
     if (min != max && ((int)i < min || (int)i > max)) {
-        emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' integer %d isn't within range %d..%d", op, i, min, max));
+        emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' integer %d isn't within range %d..%d"), op, i, min, max));
         return 0;
     }
     return i;
@@ -179,7 +181,7 @@ STATIC uint32_t get_arg_i(emit_inline_asm_t *emit, const char *op, mp_parse_node
 
 STATIC int get_arg_label(emit_inline_asm_t *emit, const char *op, mp_parse_node_t pn) {
     if (!MP_PARSE_NODE_IS_ID(pn)) {
-        emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects a label", op));
+        emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' expects a label"), op));
         return 0;
     }
     qstr label_qstr = MP_PARSE_NODE_LEAF_ARG(pn);
@@ -190,7 +192,7 @@ STATIC int get_arg_label(emit_inline_asm_t *emit, const char *op, mp_parse_node_
     }
     // only need to have the labels on the last pass
     if (emit->pass == MP_PASS_EMIT) {
-        emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "label '%q' not defined", label_qstr));
+        emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("label '%q' not defined"), label_qstr));
     }
     return 0;
 }
@@ -242,7 +244,7 @@ STATIC const opcode_table_3arg_t opcode_table_3arg[] = {
 
 STATIC void emit_inline_xtensa_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_args, mp_parse_node_t *pn_args) {
     size_t op_len;
-    const char *op_str = (const char*)qstr_data(op, &op_len);
+    const char *op_str = (const char *)qstr_data(op, &op_len);
 
     if (n_args == 0) {
         if (op == MP_QSTR_ret_n) {
@@ -324,12 +326,12 @@ STATIC void emit_inline_xtensa_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_
     return;
 
 unknown_op:
-    emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "unsupported Xtensa instruction '%s' with %d arguments", op_str, n_args));
+    emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("unsupported Xtensa instruction '%s' with %d arguments"), op_str, n_args));
     return;
 
     /*
 branch_not_in_range:
-    emit_inline_xtensa_error_msg(emit, "branch not in range");
+    emit_inline_xtensa_error_msg(emit, MP_ERROR_TEXT("branch not in range"));
     return;
     */
 }
diff --git a/py/emitnative.c b/py/emitnative.c
index da986dc5d96a1..6c8e9feebaee9 100644
--- a/py/emitnative.c
+++ b/py/emitnative.c
@@ -47,7 +47,8 @@
 #include <assert.h>
 
 #include "py/emit.h"
-#include "py/bc.h"
+#include "py/nativeglue.h"
+#include "py/objstr.h"
 
 #if MICROPY_DEBUG_VERBOSE // print debugging info
 #define DEBUG_PRINT (1)
@@ -57,7 +58,7 @@
 #endif
 
 // wrapper around everything in this file
-#if N_X64 || N_X86 || N_THUMB || N_ARM || N_XTENSA
+#if N_X64 || N_X86 || N_THUMB || N_ARM || N_XTENSA || N_XTENSAWIN
 
 // C stack layout for native functions:
 //  0:                          nlr_buf_t [optional]
@@ -80,6 +81,30 @@
 //                              locals (reversed, L0 at end)    |
 //                              (L0-L2 may be in regs instead)
 
+// Native emitter needs to know the following sizes and offsets of C structs (on the target):
+#if MICROPY_DYNAMIC_COMPILER
+#define SIZEOF_NLR_BUF (2 + mp_dynamic_compiler.nlr_buf_num_regs + 1) // the +1 is conservative in case MICROPY_ENABLE_PYSTACK enabled
+#else
+#define SIZEOF_NLR_BUF (sizeof(nlr_buf_t) / sizeof(uintptr_t))
+#endif
+#define SIZEOF_CODE_STATE (sizeof(mp_code_state_t) / sizeof(uintptr_t))
+#define OFFSETOF_CODE_STATE_STATE (offsetof(mp_code_state_t, state) / sizeof(uintptr_t))
+#define OFFSETOF_CODE_STATE_FUN_BC (offsetof(mp_code_state_t, fun_bc) / sizeof(uintptr_t))
+#define OFFSETOF_CODE_STATE_IP (offsetof(mp_code_state_t, ip) / sizeof(uintptr_t))
+#define OFFSETOF_CODE_STATE_SP (offsetof(mp_code_state_t, sp) / sizeof(uintptr_t))
+#define OFFSETOF_OBJ_FUN_BC_GLOBALS (offsetof(mp_obj_fun_bc_t, globals) / sizeof(uintptr_t))
+#define OFFSETOF_OBJ_FUN_BC_BYTECODE (offsetof(mp_obj_fun_bc_t, bytecode) / sizeof(uintptr_t))
+#define OFFSETOF_OBJ_FUN_BC_CONST_TABLE (offsetof(mp_obj_fun_bc_t, const_table) / sizeof(uintptr_t))
+
+// If not already defined, set parent args to same as child call registers
+#ifndef REG_PARENT_RET
+#define REG_PARENT_RET REG_RET
+#define REG_PARENT_ARG_1 REG_ARG_1
+#define REG_PARENT_ARG_2 REG_ARG_2
+#define REG_PARENT_ARG_3 REG_ARG_3
+#define REG_PARENT_ARG_4 REG_ARG_4
+#endif
+
 // Word index of nlr_buf_t.ret_val
 #define NLR_BUF_IDX_RET_VAL (1)
 
@@ -101,16 +126,16 @@
 #define LOCAL_IDX_EXC_HANDLER_PC(emit) (NLR_BUF_IDX_LOCAL_1)
 #define LOCAL_IDX_EXC_HANDLER_UNWIND(emit) (NLR_BUF_IDX_LOCAL_2)
 #define LOCAL_IDX_RET_VAL(emit) (NLR_BUF_IDX_LOCAL_3)
-#define LOCAL_IDX_FUN_OBJ(emit) ((emit)->code_state_start + offsetof(mp_code_state_t, fun_bc) / sizeof(uintptr_t))
-#define LOCAL_IDX_OLD_GLOBALS(emit) ((emit)->code_state_start + offsetof(mp_code_state_t, ip) / sizeof(uintptr_t))
-#define LOCAL_IDX_GEN_PC(emit) ((emit)->code_state_start + offsetof(mp_code_state_t, ip) / sizeof(uintptr_t))
+#define LOCAL_IDX_FUN_OBJ(emit) ((emit)->code_state_start + OFFSETOF_CODE_STATE_FUN_BC)
+#define LOCAL_IDX_OLD_GLOBALS(emit) ((emit)->code_state_start + OFFSETOF_CODE_STATE_IP)
+#define LOCAL_IDX_GEN_PC(emit) ((emit)->code_state_start + OFFSETOF_CODE_STATE_IP)
 #define LOCAL_IDX_LOCAL_VAR(emit, local_num) ((emit)->stack_start + (emit)->n_state - 1 - (local_num))
 
 #define REG_GENERATOR_STATE (REG_LOCAL_3)
 
 #define EMIT_NATIVE_VIPER_TYPE_ERROR(emit, ...) do { \
         *emit->error_slot = mp_obj_new_exception_msg_varg(&mp_type_ViperTypeError, __VA_ARGS__); \
-    } while (0)
+} while (0)
 
 typedef enum {
     STACK_VALUE,
@@ -138,15 +163,25 @@ typedef enum {
 
 STATIC qstr vtype_to_qstr(vtype_kind_t vtype) {
     switch (vtype) {
-        case VTYPE_PYOBJ: return MP_QSTR_object;
-        case VTYPE_BOOL: return MP_QSTR_bool;
-        case VTYPE_INT: return MP_QSTR_int;
-        case VTYPE_UINT: return MP_QSTR_uint;
-        case VTYPE_PTR: return MP_QSTR_ptr;
-        case VTYPE_PTR8: return MP_QSTR_ptr8;
-        case VTYPE_PTR16: return MP_QSTR_ptr16;
-        case VTYPE_PTR32: return MP_QSTR_ptr32;
-        case VTYPE_PTR_NONE: default: return MP_QSTR_None;
+        case VTYPE_PYOBJ:
+            return MP_QSTR_object;
+        case VTYPE_BOOL:
+            return MP_QSTR_bool;
+        case VTYPE_INT:
+            return MP_QSTR_int;
+        case VTYPE_UINT:
+            return MP_QSTR_uint;
+        case VTYPE_PTR:
+            return MP_QSTR_ptr;
+        case VTYPE_PTR8:
+            return MP_QSTR_ptr8;
+        case VTYPE_PTR16:
+            return MP_QSTR_ptr16;
+        case VTYPE_PTR32:
+            return MP_QSTR_ptr32;
+        case VTYPE_PTR_NONE:
+        default:
+            return MP_QSTR_None;
     }
 }
 
@@ -194,6 +229,7 @@ struct _emit_t {
     uint16_t code_state_start;
     uint16_t stack_start;
     int stack_size;
+    uint16_t n_cell;
 
     uint16_t const_table_cur_obj;
     uint16_t const_table_num_obj;
@@ -218,7 +254,7 @@ STATIC void emit_native_global_exc_entry(emit_t *emit);
 STATIC void emit_native_global_exc_exit(emit_t *emit);
 STATIC void emit_native_load_const_obj(emit_t *emit, mp_obj_t obj);
 
-emit_t *EXPORT_FUN(new)(mp_obj_t *error_slot, uint *label_slot, mp_uint_t max_num_labels) {
+emit_t *EXPORT_FUN(new)(mp_obj_t * error_slot, uint *label_slot, mp_uint_t max_num_labels) {
     emit_t *emit = m_new0(emit_t, 1);
     emit->error_slot = error_slot;
     emit->label_slot = label_slot;
@@ -231,7 +267,7 @@ emit_t *EXPORT_FUN(new)(mp_obj_t *error_slot, uint *label_slot, mp_uint_t max_nu
     return emit;
 }
 
-void EXPORT_FUN(free)(emit_t *emit) {
+void EXPORT_FUN(free)(emit_t * emit) {
     mp_asm_base_deinit(&emit->as->base, false);
     m_del_obj(ASM_T, emit->as);
     m_del(exc_stack_entry_t, emit->exc_stack, emit->exc_stack_alloc);
@@ -309,7 +345,11 @@ STATIC void emit_native_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scop
     emit->pass = pass;
     emit->do_viper_types = scope->emit_options == MP_EMIT_OPT_VIPER;
     emit->stack_size = 0;
+    #if N_PRELUDE_AS_BYTES_OBJ
+    emit->const_table_cur_obj = emit->do_viper_types ? 0 : 1; // reserve first obj for prelude bytes obj
+    #else
     emit->const_table_cur_obj = 0;
+    #endif
     emit->const_table_cur_raw_code = 0;
     #if MICROPY_PERSISTENT_CODE_SAVE
     emit->qstr_link_cur = 0;
@@ -364,7 +404,7 @@ STATIC void emit_native_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scop
     // Work out start of code state (mp_code_state_t or reduced version for viper)
     emit->code_state_start = 0;
     if (NEED_GLOBAL_EXC_HANDLER(emit)) {
-        emit->code_state_start = sizeof(nlr_buf_t) / sizeof(uintptr_t);
+        emit->code_state_start = SIZEOF_NLR_BUF;
     }
 
     if (emit->do_viper_types) {
@@ -398,16 +438,16 @@ STATIC void emit_native_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scop
         ASM_ENTRY(emit->as, emit->stack_start + emit->n_state - num_locals_in_regs);
 
         #if N_X86
-        asm_x86_mov_arg_to_r32(emit->as, 0, REG_ARG_1);
+        asm_x86_mov_arg_to_r32(emit->as, 0, REG_PARENT_ARG_1);
         #endif
 
         // Load REG_FUN_TABLE with a pointer to mp_fun_table, found in the const_table
-        ASM_LOAD_REG_REG_OFFSET(emit->as, REG_LOCAL_3, REG_ARG_1, offsetof(mp_obj_fun_bc_t, const_table) / sizeof(uintptr_t));
+        ASM_LOAD_REG_REG_OFFSET(emit->as, REG_LOCAL_3, REG_PARENT_ARG_1, OFFSETOF_OBJ_FUN_BC_CONST_TABLE);
         ASM_LOAD_REG_REG_OFFSET(emit->as, REG_FUN_TABLE, REG_LOCAL_3, 0);
 
         // Store function object (passed as first arg) to stack if needed
         if (NEED_FUN_OBJ(emit)) {
-            ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_FUN_OBJ(emit), REG_ARG_1);
+            ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_FUN_OBJ(emit), REG_PARENT_ARG_1);
         }
 
         // Put n_args in REG_ARG_1, n_kw in REG_ARG_2, args array in REG_LOCAL_3
@@ -416,9 +456,9 @@ STATIC void emit_native_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scop
         asm_x86_mov_arg_to_r32(emit->as, 2, REG_ARG_2);
         asm_x86_mov_arg_to_r32(emit->as, 3, REG_LOCAL_3);
         #else
-        ASM_MOV_REG_REG(emit->as, REG_ARG_1, REG_ARG_2);
-        ASM_MOV_REG_REG(emit->as, REG_ARG_2, REG_ARG_3);
-        ASM_MOV_REG_REG(emit->as, REG_LOCAL_3, REG_ARG_4);
+        ASM_MOV_REG_REG(emit->as, REG_ARG_1, REG_PARENT_ARG_2);
+        ASM_MOV_REG_REG(emit->as, REG_ARG_2, REG_PARENT_ARG_3);
+        ASM_MOV_REG_REG(emit->as, REG_LOCAL_3, REG_PARENT_ARG_4);
         #endif
 
         // Check number of args matches this function, and call mp_arg_check_num_sig if not
@@ -458,31 +498,36 @@ STATIC void emit_native_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scop
 
         if (emit->scope->scope_flags & MP_SCOPE_FLAG_GENERATOR) {
             emit->code_state_start = 0;
-            emit->stack_start = sizeof(mp_code_state_t) / sizeof(mp_uint_t);
+            emit->stack_start = SIZEOF_CODE_STATE;
+            #if N_PRELUDE_AS_BYTES_OBJ
+            // Load index of prelude bytes object in const_table
+            mp_asm_base_data(&emit->as->base, ASM_WORD_SIZE, (uintptr_t)(emit->scope->num_pos_args + emit->scope->num_kwonly_args + 1));
+            #else
             mp_asm_base_data(&emit->as->base, ASM_WORD_SIZE, (uintptr_t)emit->prelude_offset);
+            #endif
             mp_asm_base_data(&emit->as->base, ASM_WORD_SIZE, (uintptr_t)emit->start_offset);
-            ASM_ENTRY(emit->as, sizeof(nlr_buf_t) / sizeof(uintptr_t));
+            ASM_ENTRY(emit->as, SIZEOF_NLR_BUF);
 
             // Put address of code_state into REG_GENERATOR_STATE
             #if N_X86
             asm_x86_mov_arg_to_r32(emit->as, 0, REG_GENERATOR_STATE);
             #else
-            ASM_MOV_REG_REG(emit->as, REG_GENERATOR_STATE, REG_ARG_1);
+            ASM_MOV_REG_REG(emit->as, REG_GENERATOR_STATE, REG_PARENT_ARG_1);
             #endif
 
             // Put throw value into LOCAL_IDX_EXC_VAL slot, for yield/yield-from
             #if N_X86
-            asm_x86_mov_arg_to_r32(emit->as, 1, REG_ARG_2);
+            asm_x86_mov_arg_to_r32(emit->as, 1, REG_PARENT_ARG_2);
             #endif
-            ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_EXC_VAL(emit), REG_ARG_2);
+            ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_EXC_VAL(emit), REG_PARENT_ARG_2);
 
             // Load REG_FUN_TABLE with a pointer to mp_fun_table, found in the const_table
             ASM_LOAD_REG_REG_OFFSET(emit->as, REG_TEMP0, REG_GENERATOR_STATE, LOCAL_IDX_FUN_OBJ(emit));
-            ASM_LOAD_REG_REG_OFFSET(emit->as, REG_TEMP0, REG_TEMP0, offsetof(mp_obj_fun_bc_t, const_table) / sizeof(uintptr_t));
+            ASM_LOAD_REG_REG_OFFSET(emit->as, REG_TEMP0, REG_TEMP0, OFFSETOF_OBJ_FUN_BC_CONST_TABLE);
             ASM_LOAD_REG_REG_OFFSET(emit->as, REG_FUN_TABLE, REG_TEMP0, emit->scope->num_pos_args + emit->scope->num_kwonly_args);
         } else {
             // The locals and stack start after the code_state structure
-            emit->stack_start = emit->code_state_start + sizeof(mp_code_state_t) / sizeof(mp_uint_t);
+            emit->stack_start = emit->code_state_start + SIZEOF_CODE_STATE;
 
             // Allocate space on C-stack for code_state structure, which includes state
             ASM_ENTRY(emit->as, emit->stack_start + emit->n_state);
@@ -490,26 +535,49 @@ STATIC void emit_native_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scop
             // Prepare incoming arguments for call to mp_setup_code_state
 
             #if N_X86
-            asm_x86_mov_arg_to_r32(emit->as, 0, REG_ARG_1);
-            asm_x86_mov_arg_to_r32(emit->as, 1, REG_ARG_2);
-            asm_x86_mov_arg_to_r32(emit->as, 2, REG_ARG_3);
-            asm_x86_mov_arg_to_r32(emit->as, 3, REG_ARG_4);
+            asm_x86_mov_arg_to_r32(emit->as, 0, REG_PARENT_ARG_1);
+            asm_x86_mov_arg_to_r32(emit->as, 1, REG_PARENT_ARG_2);
+            asm_x86_mov_arg_to_r32(emit->as, 2, REG_PARENT_ARG_3);
+            asm_x86_mov_arg_to_r32(emit->as, 3, REG_PARENT_ARG_4);
             #endif
 
             // Load REG_FUN_TABLE with a pointer to mp_fun_table, found in the const_table
-            ASM_LOAD_REG_REG_OFFSET(emit->as, REG_LOCAL_3, REG_ARG_1, offsetof(mp_obj_fun_bc_t, const_table) / sizeof(uintptr_t));
+            ASM_LOAD_REG_REG_OFFSET(emit->as, REG_LOCAL_3, REG_PARENT_ARG_1, OFFSETOF_OBJ_FUN_BC_CONST_TABLE);
             ASM_LOAD_REG_REG_OFFSET(emit->as, REG_FUN_TABLE, REG_LOCAL_3, emit->scope->num_pos_args + emit->scope->num_kwonly_args);
 
             // Set code_state.fun_bc
-            ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_FUN_OBJ(emit), REG_ARG_1);
+            ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_FUN_OBJ(emit), REG_PARENT_ARG_1);
 
             // Set code_state.ip (offset from start of this function to prelude info)
+            #if N_PRELUDE_AS_BYTES_OBJ
+            // Prelude is a bytes object in const_table; store ip = prelude->data - fun_bc->bytecode
+            ASM_LOAD_REG_REG_OFFSET(emit->as, REG_LOCAL_3, REG_LOCAL_3, emit->scope->num_pos_args + emit->scope->num_kwonly_args + 1);
+            ASM_LOAD_REG_REG_OFFSET(emit->as, REG_LOCAL_3, REG_LOCAL_3, offsetof(mp_obj_str_t, data) / sizeof(uintptr_t));
+            ASM_LOAD_REG_REG_OFFSET(emit->as, REG_PARENT_ARG_1, REG_PARENT_ARG_1, OFFSETOF_OBJ_FUN_BC_BYTECODE);
+            ASM_SUB_REG_REG(emit->as, REG_LOCAL_3, REG_PARENT_ARG_1);
+            emit_native_mov_state_reg(emit, emit->code_state_start + OFFSETOF_CODE_STATE_IP, REG_LOCAL_3);
+            #else
             // TODO this encoding may change size in the final pass, need to make it fixed
-            emit_native_mov_state_imm_via(emit, emit->code_state_start + offsetof(mp_code_state_t, ip) / sizeof(uintptr_t), emit->prelude_offset, REG_ARG_1);
+            emit_native_mov_state_imm_via(emit, emit->code_state_start + OFFSETOF_CODE_STATE_IP, emit->prelude_offset, REG_PARENT_ARG_1);
+            #endif
+
+            // Set code_state.n_state (only works on little endian targets due to n_state being uint16_t)
+            emit_native_mov_state_imm_via(emit, emit->code_state_start + offsetof(mp_code_state_t, n_state) / sizeof(uintptr_t), emit->n_state, REG_ARG_1);
 
             // Put address of code_state into first arg
             ASM_MOV_REG_LOCAL_ADDR(emit->as, REG_ARG_1, emit->code_state_start);
 
+            // Copy next 3 args if needed
+            #if REG_ARG_2 != REG_PARENT_ARG_2
+            ASM_MOV_REG_REG(emit->as, REG_ARG_2, REG_PARENT_ARG_2);
+            #endif
+            #if REG_ARG_3 != REG_PARENT_ARG_3
+            ASM_MOV_REG_REG(emit->as, REG_ARG_3, REG_PARENT_ARG_3);
+            #endif
+            #if REG_ARG_4 != REG_PARENT_ARG_4
+            ASM_MOV_REG_REG(emit->as, REG_ARG_4, REG_PARENT_ARG_4);
+            #endif
+
             // Call mp_setup_code_state to prepare code_state structure
             #if N_THUMB
             asm_thumb_bl_ind(emit->as, MP_F_SETUP_CODE_STATE, ASM_THUMB_REG_R4);
@@ -556,22 +624,28 @@ STATIC void emit_native_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scop
 
 }
 
+static inline void emit_native_write_code_info_byte(emit_t *emit, byte val) {
+    mp_asm_base_data(&emit->as->base, 1, val);
+}
+
 STATIC void emit_native_end_pass(emit_t *emit) {
     emit_native_global_exc_exit(emit);
 
     if (!emit->do_viper_types) {
         emit->prelude_offset = mp_asm_base_get_code_pos(&emit->as->base);
-        mp_asm_base_data(&emit->as->base, 1, 0x80 | ((emit->n_state >> 7) & 0x7f));
-        mp_asm_base_data(&emit->as->base, 1, emit->n_state & 0x7f);
-        mp_asm_base_data(&emit->as->base, 1, 0); // n_exc_stack
-        mp_asm_base_data(&emit->as->base, 1, emit->scope->scope_flags);
-        mp_asm_base_data(&emit->as->base, 1, emit->scope->num_pos_args);
-        mp_asm_base_data(&emit->as->base, 1, emit->scope->num_kwonly_args);
-        mp_asm_base_data(&emit->as->base, 1, emit->scope->num_def_pos_args);
-
-        // write code info
+
+        size_t n_state = emit->n_state;
+        size_t n_exc_stack = 0; // exc-stack not needed for native code
+        MP_BC_PRELUDE_SIG_ENCODE(n_state, n_exc_stack, emit->scope, emit_native_write_code_info_byte, emit);
+
+        #if MICROPY_PERSISTENT_CODE
+        size_t n_info = 4;
+        #else
+        size_t n_info = 1;
+        #endif
+        MP_BC_PRELUDE_SIZE_ENCODE(n_info, emit->n_cell, emit_native_write_code_info_byte, emit);
+
         #if MICROPY_PERSISTENT_CODE
-        mp_asm_base_data(&emit->as->base, 1, 5);
         mp_asm_base_data(&emit->as->base, 1, emit->scope->simple_name);
         mp_asm_base_data(&emit->as->base, 1, emit->scope->simple_name >> 8);
         mp_asm_base_data(&emit->as->base, 1, emit->scope->source_file);
@@ -581,14 +655,25 @@ STATIC void emit_native_end_pass(emit_t *emit) {
         #endif
 
         // bytecode prelude: initialise closed over variables
+        size_t cell_start = mp_asm_base_get_code_pos(&emit->as->base);
         for (int i = 0; i < emit->scope->id_info_len; i++) {
             id_info_t *id = &emit->scope->id_info[i];
             if (id->kind == ID_INFO_KIND_CELL) {
-                assert(id->local_num < 255);
+                assert(id->local_num <= 255);
                 mp_asm_base_data(&emit->as->base, 1, id->local_num); // write the local which should be converted to a cell
             }
         }
-        mp_asm_base_data(&emit->as->base, 1, 255); // end of list sentinel
+        emit->n_cell = mp_asm_base_get_code_pos(&emit->as->base) - cell_start;
+
+        #if N_PRELUDE_AS_BYTES_OBJ
+        // Prelude bytes object is after qstr arg names and mp_fun_table
+        size_t table_off = emit->scope->num_pos_args + emit->scope->num_kwonly_args + 1;
+        if (emit->pass == MP_PASS_EMIT) {
+            void *buf = emit->as->base.code_base + emit->prelude_offset;
+            size_t n = emit->as->base.code_offset - emit->prelude_offset;
+            emit->const_table[table_off] = (uintptr_t)mp_obj_new_bytes(buf, n);
+        }
+        #endif
     }
 
     ASM_END_PASS(emit->as);
@@ -609,8 +694,11 @@ STATIC void emit_native_end_pass(emit_t *emit) {
             const_table_alloc += nqstr;
         }
         emit->const_table = m_new(mp_uint_t, const_table_alloc);
+        #if !MICROPY_DYNAMIC_COMPILER
         // Store mp_fun_table pointer just after qstrs
-        emit->const_table[nqstr] = (mp_uint_t)(uintptr_t)mp_fun_table;
+        // (but in dynamic-compiler mode eliminate dependency on mp_fun_table)
+        emit->const_table[nqstr] = (mp_uint_t)(uintptr_t)&mp_fun_table;
+        #endif
 
         #if MICROPY_PERSISTENT_CODE_SAVE
         size_t qstr_link_alloc = emit->qstr_link_cur;
@@ -655,14 +743,14 @@ STATIC void adjust_stack(emit_t *emit, mp_int_t stack_size_delta) {
     if (emit->pass > MP_PASS_SCOPE && emit->stack_size > emit->scope->stack_size) {
         emit->scope->stack_size = emit->stack_size;
     }
-#ifdef DEBUG_PRINT
+    #ifdef DEBUG_PRINT
     DEBUG_printf("  adjust_stack; stack_size=%d+%d; stack now:", emit->stack_size - stack_size_delta, stack_size_delta);
     for (int i = 0; i < emit->stack_size; i++) {
         stack_info_t *si = &emit->stack_info[i];
         DEBUG_printf(" (v=%d k=%d %d)", si->vtype, si->kind, si->data.u_reg);
     }
     DEBUG_printf("\n");
-#endif
+    #endif
 }
 
 STATIC void emit_native_adjust_stack_size(emit_t *emit, mp_int_t delta) {
@@ -753,7 +841,7 @@ STATIC vtype_kind_t load_reg_stack_imm(emit_t *emit, int reg_dest, const stack_i
         } else if (si->vtype == VTYPE_PTR_NONE) {
             emit_native_mov_reg_const(emit, reg_dest, MP_F_CONST_NONE_OBJ);
         } else {
-            mp_raise_NotImplementedError("conversion to object");
+            mp_raise_NotImplementedError(MP_ERROR_TEXT("conversion to object"));
         }
         return VTYPE_PYOBJ;
     }
@@ -1033,7 +1121,7 @@ STATIC void emit_load_reg_with_ptr(emit_t *emit, int reg, mp_uint_t ptr, size_t
         emit->const_table[table_off] = ptr;
     }
     emit_native_mov_reg_state(emit, REG_TEMP0, LOCAL_IDX_FUN_OBJ(emit));
-    ASM_LOAD_REG_REG_OFFSET(emit->as, REG_TEMP0, REG_TEMP0, offsetof(mp_obj_fun_bc_t, const_table) / sizeof(uintptr_t));
+    ASM_LOAD_REG_REG_OFFSET(emit->as, REG_TEMP0, REG_TEMP0, OFFSETOF_OBJ_FUN_BC_CONST_TABLE);
     ASM_LOAD_REG_REG_OFFSET(emit->as, reg, REG_TEMP0, table_off);
 }
 
@@ -1054,8 +1142,8 @@ STATIC void emit_native_label_assign(emit_t *emit, mp_uint_t l) {
 
     bool is_finally = false;
     if (emit->exc_stack_size > 0) {
-       exc_stack_entry_t *e = &emit->exc_stack[emit->exc_stack_size - 1];
-       is_finally = e->is_finally && e->label == l;
+        exc_stack_entry_t *e = &emit->exc_stack[emit->exc_stack_size - 1];
+        is_finally = e->is_finally && e->label == l;
     }
 
     if (is_finally) {
@@ -1090,7 +1178,7 @@ STATIC void emit_native_global_exc_entry(emit_t *emit) {
         if (!(emit->scope->scope_flags & MP_SCOPE_FLAG_GENERATOR)) {
             // Set new globals
             emit_native_mov_reg_state(emit, REG_ARG_1, LOCAL_IDX_FUN_OBJ(emit));
-            ASM_LOAD_REG_REG_OFFSET(emit->as, REG_ARG_1, REG_ARG_1, offsetof(mp_obj_fun_bc_t, globals) / sizeof(uintptr_t));
+            ASM_LOAD_REG_REG_OFFSET(emit->as, REG_ARG_1, REG_ARG_1, OFFSETOF_OBJ_FUN_BC_GLOBALS);
             emit_call(emit, MP_F_NATIVE_SWAP_GLOBALS);
 
             // Save old globals (or NULL if globals didn't change)
@@ -1106,6 +1194,10 @@ STATIC void emit_native_global_exc_entry(emit_t *emit) {
             // Wrap everything in an nlr context
             ASM_MOV_REG_LOCAL_ADDR(emit->as, REG_ARG_1, 0);
             emit_call(emit, MP_F_NLR_PUSH);
+            #if N_NLR_SETJMP
+            ASM_MOV_REG_LOCAL_ADDR(emit->as, REG_ARG_1, 2);
+            emit_call(emit, MP_F_SETJMP);
+            #endif
             ASM_JUMP_IF_REG_ZERO(emit->as, REG_RET, start_label, true);
         } else {
             // Clear the unwind state
@@ -1120,6 +1212,10 @@ STATIC void emit_native_global_exc_entry(emit_t *emit) {
             ASM_MOV_REG_LOCAL(emit->as, REG_LOCAL_2, LOCAL_IDX_EXC_HANDLER_UNWIND(emit));
             ASM_MOV_REG_LOCAL_ADDR(emit->as, REG_ARG_1, 0);
             emit_call(emit, MP_F_NLR_PUSH);
+            #if N_NLR_SETJMP
+            ASM_MOV_REG_LOCAL_ADDR(emit->as, REG_ARG_1, 2);
+            emit_call(emit, MP_F_SETJMP);
+            #endif
             ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_EXC_HANDLER_UNWIND(emit), REG_LOCAL_2);
             ASM_JUMP_IF_REG_NONZERO(emit->as, REG_RET, global_except_label, true);
 
@@ -1130,6 +1226,12 @@ STATIC void emit_native_global_exc_entry(emit_t *emit) {
 
             // Global exception handler: check for valid exception handler
             emit_native_label_assign(emit, global_except_label);
+            #if N_NLR_SETJMP
+            // Reload REG_FUN_TABLE, since it may be clobbered by longjmp
+            emit_native_mov_reg_state(emit, REG_LOCAL_1, LOCAL_IDX_FUN_OBJ(emit));
+            ASM_LOAD_REG_REG_OFFSET(emit->as, REG_LOCAL_1, REG_LOCAL_1, offsetof(mp_obj_fun_bc_t, const_table) / sizeof(uintptr_t));
+            ASM_LOAD_REG_REG_OFFSET(emit->as, REG_FUN_TABLE, REG_LOCAL_1, emit->scope->num_pos_args + emit->scope->num_kwonly_args);
+            #endif
             ASM_MOV_REG_LOCAL(emit->as, REG_LOCAL_1, LOCAL_IDX_EXC_HANDLER_PC(emit));
             ASM_JUMP_IF_REG_NONZERO(emit->as, REG_LOCAL_1, nlr_label, false);
         }
@@ -1143,10 +1245,10 @@ STATIC void emit_native_global_exc_entry(emit_t *emit) {
         if (emit->scope->scope_flags & MP_SCOPE_FLAG_GENERATOR) {
             // Store return value in state[0]
             ASM_MOV_REG_LOCAL(emit->as, REG_TEMP0, LOCAL_IDX_EXC_VAL(emit));
-            ASM_STORE_REG_REG_OFFSET(emit->as, REG_TEMP0, REG_GENERATOR_STATE, offsetof(mp_code_state_t, state) / sizeof(uintptr_t));
+            ASM_STORE_REG_REG_OFFSET(emit->as, REG_TEMP0, REG_GENERATOR_STATE, OFFSETOF_CODE_STATE_STATE);
 
             // Load return kind
-            ASM_MOV_REG_IMM(emit->as, REG_RET, MP_VM_RETURN_EXCEPTION);
+            ASM_MOV_REG_IMM(emit->as, REG_PARENT_RET, MP_VM_RETURN_EXCEPTION);
 
             ASM_EXIT(emit->as);
         } else {
@@ -1201,7 +1303,7 @@ STATIC void emit_native_global_exc_exit(emit_t *emit) {
         }
 
         // Load return value
-        ASM_MOV_REG_LOCAL(emit->as, REG_RET, LOCAL_IDX_RET_VAL(emit));
+        ASM_MOV_REG_LOCAL(emit->as, REG_PARENT_RET, LOCAL_IDX_RET_VAL(emit));
     }
 
     ASM_EXIT(emit->as);
@@ -1313,7 +1415,7 @@ STATIC void emit_native_load_fast(emit_t *emit, qstr qst, mp_uint_t local_num) {
     DEBUG_printf("load_fast(%s, " UINT_FMT ")\n", qstr_str(qst), local_num);
     vtype_kind_t vtype = emit->local_vtype[local_num];
     if (vtype == VTYPE_UNBOUND) {
-        EMIT_NATIVE_VIPER_TYPE_ERROR(emit, "local '%q' used before type known", qst);
+        EMIT_NATIVE_VIPER_TYPE_ERROR(emit, MP_ERROR_TEXT("local '%q' used before type known"), qst);
     }
     emit_native_pre(emit);
     if (local_num < REG_LOCAL_NUM && CAN_USE_REGS_FOR_LOCALS(emit)) {
@@ -1356,7 +1458,7 @@ STATIC void emit_native_load_global(emit_t *emit, qstr qst, int kind) {
         if (emit->do_viper_types) {
             // check for builtin casting operators
             int native_type = mp_native_type_from_qstr(qst);
-            if (native_type >= MP_NATIVE_TYPE_INT) {
+            if (native_type >= MP_NATIVE_TYPE_BOOL) {
                 emit_post_push_imm(emit, VTYPE_BUILTIN_CAST, native_type);
                 return;
             }
@@ -1488,7 +1590,7 @@ STATIC void emit_native_load_subscr(emit_t *emit) {
                 }
                 default:
                     EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
-                        "can't load from '%q'", vtype_to_qstr(vtype_base));
+                        MP_ERROR_TEXT("can't load from '%q'"), vtype_to_qstr(vtype_base));
             }
         } else {
             // index is not an immediate
@@ -1498,7 +1600,7 @@ STATIC void emit_native_load_subscr(emit_t *emit) {
             emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1);
             if (vtype_index != VTYPE_INT && vtype_index != VTYPE_UINT) {
                 EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
-                    "can't load with '%q' index", vtype_to_qstr(vtype_index));
+                    MP_ERROR_TEXT("can't load with '%q' index"), vtype_to_qstr(vtype_index));
             }
             switch (vtype_base) {
                 case VTYPE_PTR8: {
@@ -1526,7 +1628,7 @@ STATIC void emit_native_load_subscr(emit_t *emit) {
                 }
                 default:
                     EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
-                        "can't load from '%q'", vtype_to_qstr(vtype_base));
+                        MP_ERROR_TEXT("can't load from '%q'"), vtype_to_qstr(vtype_base));
             }
         }
         emit_post_push_reg(emit, VTYPE_INT, REG_RET);
@@ -1550,7 +1652,7 @@ STATIC void emit_native_store_fast(emit_t *emit, qstr qst, mp_uint_t local_num)
     } else if (emit->local_vtype[local_num] != vtype) {
         // type of local is not the same as object stored in it
         EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
-            "local '%q' has type '%q' but source is '%q'",
+            MP_ERROR_TEXT("local '%q' has type '%q' but source is '%q'"),
             qst, vtype_to_qstr(emit->local_vtype[local_num]), vtype_to_qstr(vtype));
     }
 }
@@ -1651,7 +1753,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) {
             #endif
             if (vtype_value != VTYPE_BOOL && vtype_value != VTYPE_INT && vtype_value != VTYPE_UINT) {
                 EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
-                    "can't store '%q'", vtype_to_qstr(vtype_value));
+                    MP_ERROR_TEXT("can't store '%q'"), vtype_to_qstr(vtype_value));
             }
             switch (vtype_base) {
                 case VTYPE_PTR8: {
@@ -1717,7 +1819,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) {
                 }
                 default:
                     EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
-                        "can't store to '%q'", vtype_to_qstr(vtype_base));
+                        MP_ERROR_TEXT("can't store to '%q'"), vtype_to_qstr(vtype_base));
             }
         } else {
             // index is not an immediate
@@ -1728,7 +1830,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) {
             emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1);
             if (vtype_index != VTYPE_INT && vtype_index != VTYPE_UINT) {
                 EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
-                    "can't store with '%q' index", vtype_to_qstr(vtype_index));
+                    MP_ERROR_TEXT("can't store with '%q' index"), vtype_to_qstr(vtype_index));
             }
             #if N_X86
             // special case: x86 needs byte stores to be from lower 4 regs (REG_ARG_3 is EDX)
@@ -1738,7 +1840,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) {
             #endif
             if (vtype_value != VTYPE_BOOL && vtype_value != VTYPE_INT && vtype_value != VTYPE_UINT) {
                 EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
-                    "can't store '%q'", vtype_to_qstr(vtype_value));
+                    MP_ERROR_TEXT("can't store '%q'"), vtype_to_qstr(vtype_value));
             }
             switch (vtype_base) {
                 case VTYPE_PTR8: {
@@ -1778,7 +1880,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) {
                 }
                 default:
                     EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
-                        "can't store to '%q'", vtype_to_qstr(vtype_base));
+                        MP_ERROR_TEXT("can't store to '%q'"), vtype_to_qstr(vtype_base));
             }
         }
 
@@ -1900,7 +2002,7 @@ STATIC void emit_native_jump_helper(emit_t *emit, bool cond, mp_uint_t label, bo
         }
         if (!(vtype == VTYPE_BOOL || vtype == VTYPE_INT || vtype == VTYPE_UINT)) {
             EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
-                "can't implicitly convert '%q' to 'bool'", vtype_to_qstr(vtype));
+                MP_ERROR_TEXT("can't implicitly convert '%q' to 'bool'"), vtype_to_qstr(vtype));
         }
     }
     // For non-pop need to save the vtype so that emit_native_adjust_stack_size
@@ -1966,7 +2068,7 @@ STATIC void emit_native_unwind_jump(emit_t *emit, mp_uint_t label, mp_uint_t exc
             ASM_MOV_REG_PCREL(emit->as, REG_RET, label & ~MP_EMIT_BREAK_FROM_FOR);
             ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_EXC_HANDLER_UNWIND(emit), REG_RET);
             // Cancel any active exception (see also emit_native_pop_except_jump)
-            emit_native_mov_reg_const(emit, REG_RET, MP_F_CONST_NONE_OBJ);
+            ASM_MOV_REG_IMM(emit->as, REG_RET, (mp_uint_t)MP_OBJ_NULL);
             ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_EXC_VAL(emit), REG_RET);
             // Jump to the innermost active finally
             label = first_finally->label;
@@ -2061,9 +2163,8 @@ STATIC void emit_native_with_cleanup(emit_t *emit, mp_uint_t label) {
 
     ASM_MOV_REG_LOCAL(emit->as, REG_ARG_1, LOCAL_IDX_EXC_VAL(emit)); // get exc
 
-    // Check if exc is None and jump to non-exc handler if it is
-    emit_native_mov_reg_const(emit, REG_ARG_2, MP_F_CONST_NONE_OBJ);
-    ASM_JUMP_IF_REG_EQ(emit->as, REG_ARG_1, REG_ARG_2, *emit->label_slot + 2);
+    // Check if exc is MP_OBJ_NULL (i.e. zero) and jump to non-exc handler if it is
+    ASM_JUMP_IF_REG_ZERO(emit->as, REG_ARG_1, *emit->label_slot + 2, false);
 
     ASM_LOAD_REG_REG_OFFSET(emit->as, REG_ARG_2, REG_ARG_1, 0); // get type(exc)
     emit_post_push_reg(emit, VTYPE_PYOBJ, REG_ARG_2); // push type(exc)
@@ -2083,9 +2184,9 @@ STATIC void emit_native_with_cleanup(emit_t *emit, mp_uint_t label) {
     emit_call(emit, MP_F_OBJ_IS_TRUE);
     ASM_JUMP_IF_REG_ZERO(emit->as, REG_RET, *emit->label_slot + 1, true);
 
-    // Replace exception with None
+    // Replace exception with MP_OBJ_NULL.
     emit_native_label_assign(emit, *emit->label_slot);
-    emit_native_mov_reg_const(emit, REG_TEMP0, MP_F_CONST_NONE_OBJ);
+    ASM_MOV_REG_IMM(emit->as, REG_TEMP0, (mp_uint_t)MP_OBJ_NULL);
     ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_EXC_VAL(emit), REG_TEMP0);
 
     // end of with cleanup nlr_catch block
@@ -2163,7 +2264,7 @@ STATIC void emit_native_for_iter_end(emit_t *emit) {
 STATIC void emit_native_pop_except_jump(emit_t *emit, mp_uint_t label, bool within_exc_handler) {
     if (within_exc_handler) {
         // Cancel any active exception so subsequent handlers don't see it
-        emit_native_mov_reg_const(emit, REG_TEMP0, MP_F_CONST_NONE_OBJ);
+        ASM_MOV_REG_IMM(emit->as, REG_TEMP0, (mp_uint_t)MP_OBJ_NULL);
         ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_EXC_VAL(emit), REG_TEMP0);
     } else {
         emit_native_leave_exc_stack(emit, false);
@@ -2180,7 +2281,7 @@ STATIC void emit_native_unary_op(emit_t *emit, mp_unary_op_t op) {
     } else {
         adjust_stack(emit, 1);
         EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
-            "unary op %q not implemented", mp_unary_op_method_name[op]);
+            MP_ERROR_TEXT("unary op %q not implemented"), mp_unary_op_method_name[op]);
     }
 }
 
@@ -2227,17 +2328,20 @@ STATIC void emit_native_binary_op(emit_t *emit, mp_binary_op_t op) {
         int reg_rhs = REG_ARG_3;
         emit_pre_pop_reg_flexible(emit, &vtype_rhs, &reg_rhs, REG_RET, REG_ARG_2);
         emit_pre_pop_reg(emit, &vtype_lhs, REG_ARG_2);
-        if (0) {
-            // dummy
+
         #if !(N_X64 || N_X86)
-        } else if (op == MP_BINARY_OP_LSHIFT) {
-            ASM_LSL_REG_REG(emit->as, REG_ARG_2, reg_rhs);
-            emit_post_push_reg(emit, VTYPE_INT, REG_ARG_2);
-        } else if (op == MP_BINARY_OP_RSHIFT) {
-            ASM_ASR_REG_REG(emit->as, REG_ARG_2, reg_rhs);
+        if (op == MP_BINARY_OP_LSHIFT || op == MP_BINARY_OP_RSHIFT) {
+            if (op == MP_BINARY_OP_LSHIFT) {
+                ASM_LSL_REG_REG(emit->as, REG_ARG_2, reg_rhs);
+            } else {
+                ASM_ASR_REG_REG(emit->as, REG_ARG_2, reg_rhs);
+            }
             emit_post_push_reg(emit, VTYPE_INT, REG_ARG_2);
+            return;
+        }
         #endif
-        } else if (op == MP_BINARY_OP_OR) {
+
+        if (op == MP_BINARY_OP_OR) {
             ASM_OR_REG_REG(emit->as, REG_ARG_2, reg_rhs);
             emit_post_push_reg(emit, VTYPE_INT, REG_ARG_2);
         } else if (op == MP_BINARY_OP_XOR) {
@@ -2313,7 +2417,7 @@ STATIC void emit_native_binary_op(emit_t *emit, mp_binary_op_t op) {
                 ASM_ARM_CC_NE,
             };
             asm_arm_setcc_reg(emit->as, REG_RET, ccs[op - MP_BINARY_OP_LESS]);
-            #elif N_XTENSA
+            #elif N_XTENSA || N_XTENSAWIN
             static uint8_t ccs[6] = {
                 ASM_XTENSA_CC_LT,
                 0x80 | ASM_XTENSA_CC_LT, // for GT we'll swap args
@@ -2329,14 +2433,14 @@ STATIC void emit_native_binary_op(emit_t *emit, mp_binary_op_t op) {
                 asm_xtensa_setcc_reg_reg_reg(emit->as, cc & ~0x80, REG_RET, reg_rhs, REG_ARG_2);
             }
             #else
-                #error not implemented
+            #error not implemented
             #endif
             emit_post_push_reg(emit, VTYPE_BOOL, REG_RET);
         } else {
             // TODO other ops not yet implemented
             adjust_stack(emit, 1);
             EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
-                "binary op %q not implemented", mp_binary_op_method_name[op]);
+                MP_ERROR_TEXT("binary op %q not implemented"), mp_binary_op_method_name[op]);
         }
     } else if (vtype_lhs == VTYPE_PYOBJ && vtype_rhs == VTYPE_PYOBJ) {
         emit_pre_pop_reg_reg(emit, &vtype_rhs, REG_ARG_3, &vtype_lhs, REG_ARG_2);
@@ -2357,7 +2461,7 @@ STATIC void emit_native_binary_op(emit_t *emit, mp_binary_op_t op) {
     } else {
         adjust_stack(emit, -1);
         EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
-            "can't do binary op between '%q' and '%q'",
+            MP_ERROR_TEXT("can't do binary op between '%q' and '%q'"),
             vtype_to_qstr(vtype_lhs), vtype_to_qstr(vtype_rhs));
     }
 }
@@ -2535,7 +2639,7 @@ STATIC void emit_native_call_function(emit_t *emit, mp_uint_t n_positional, mp_u
                 break;
             default:
                 // this can happen when casting a cast: int(int)
-                mp_raise_NotImplementedError("casting");
+                mp_raise_NotImplementedError(MP_ERROR_TEXT("casting"));
         }
     } else {
         assert(vtype_fun == VTYPE_PYOBJ);
@@ -2573,7 +2677,7 @@ STATIC void emit_native_return_value(emit_t *emit) {
     if (emit->scope->scope_flags & MP_SCOPE_FLAG_GENERATOR) {
         // Save pointer to current stack position for caller to access return value
         emit_get_stack_pointer_to_reg_for_pop(emit, REG_TEMP0, 1);
-        emit_native_mov_state_reg(emit, offsetof(mp_code_state_t, sp) / sizeof(uintptr_t), REG_TEMP0);
+        emit_native_mov_state_reg(emit, OFFSETOF_CODE_STATE_SP, REG_TEMP0);
 
         // Put return type in return value slot
         ASM_MOV_REG_IMM(emit->as, REG_TEMP0, MP_VM_RETURN_NORMAL);
@@ -2590,30 +2694,33 @@ STATIC void emit_native_return_value(emit_t *emit) {
         if (peek_vtype(emit, 0) == VTYPE_PTR_NONE) {
             emit_pre_pop_discard(emit);
             if (return_vtype == VTYPE_PYOBJ) {
-                emit_native_mov_reg_const(emit, REG_RET, MP_F_CONST_NONE_OBJ);
+                emit_native_mov_reg_const(emit, REG_PARENT_RET, MP_F_CONST_NONE_OBJ);
             } else {
                 ASM_MOV_REG_IMM(emit->as, REG_ARG_1, 0);
             }
         } else {
             vtype_kind_t vtype;
-            emit_pre_pop_reg(emit, &vtype, return_vtype == VTYPE_PYOBJ ? REG_RET : REG_ARG_1);
+            emit_pre_pop_reg(emit, &vtype, return_vtype == VTYPE_PYOBJ ? REG_PARENT_RET : REG_ARG_1);
             if (vtype != return_vtype) {
                 EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
-                    "return expected '%q' but got '%q'",
+                    MP_ERROR_TEXT("return expected '%q' but got '%q'"),
                     vtype_to_qstr(return_vtype), vtype_to_qstr(vtype));
             }
         }
         if (return_vtype != VTYPE_PYOBJ) {
             emit_call_with_imm_arg(emit, MP_F_CONVERT_NATIVE_TO_OBJ, return_vtype, REG_ARG_2);
+            #if REG_RET != REG_PARENT_RET
+            ASM_MOV_REG_REG(emit->as, REG_PARENT_RET, REG_RET);
+            #endif
         }
     } else {
         vtype_kind_t vtype;
-        emit_pre_pop_reg(emit, &vtype, REG_RET);
+        emit_pre_pop_reg(emit, &vtype, REG_PARENT_RET);
         assert(vtype == VTYPE_PYOBJ);
     }
     if (NEED_GLOBAL_EXC_HANDLER(emit)) {
         // Save return value for the global exception handler to use
-        ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_RET_VAL(emit), REG_RET);
+        ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_RET_VAL(emit), REG_PARENT_RET);
     }
     emit_native_unwind_jump(emit, emit->exit_label, emit->exc_stack_size);
     emit->last_emit_was_return_value = true;
@@ -2625,7 +2732,7 @@ STATIC void emit_native_raise_varargs(emit_t *emit, mp_uint_t n_args) {
     vtype_kind_t vtype_exc;
     emit_pre_pop_reg(emit, &vtype_exc, REG_ARG_1); // arg1 = object to raise
     if (vtype_exc != VTYPE_PYOBJ) {
-        EMIT_NATIVE_VIPER_TYPE_ERROR(emit, "must raise an object");
+        EMIT_NATIVE_VIPER_TYPE_ERROR(emit, MP_ERROR_TEXT("must raise an object"));
     }
     // TODO probably make this 1 call to the runtime (which could even call convert, native_raise(obj, type))
     emit_call(emit, MP_F_NATIVE_RAISE);
@@ -2635,7 +2742,7 @@ STATIC void emit_native_yield(emit_t *emit, int kind) {
     // Note: 1 (yield) or 3 (yield from) labels are reserved for this function, starting at *emit->label_slot
 
     if (emit->do_viper_types) {
-        mp_raise_NotImplementedError("native yield");
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("native yield"));
     }
     emit->scope->scope_flags |= MP_SCOPE_FLAG_GENERATOR;
 
@@ -2656,7 +2763,7 @@ STATIC void emit_native_yield(emit_t *emit, int kind) {
 
     // Save pointer to current stack position for caller to access yielded value
     emit_get_stack_pointer_to_reg_for_pop(emit, REG_TEMP0, 1);
-    emit_native_mov_state_reg(emit, offsetof(mp_code_state_t, sp) / sizeof(uintptr_t), REG_TEMP0);
+    emit_native_mov_state_reg(emit, OFFSETOF_CODE_STATE_SP, REG_TEMP0);
 
     // Put return type in return value slot
     ASM_MOV_REG_IMM(emit->as, REG_TEMP0, MP_VM_RETURN_YIELD);
@@ -2681,6 +2788,7 @@ STATIC void emit_native_yield(emit_t *emit, int kind) {
                 // Found active handler, get its PC
                 ASM_MOV_REG_PCREL(emit->as, REG_RET, e->label);
                 ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_EXC_HANDLER_PC(emit), REG_RET);
+                break;
             }
         }
     }
diff --git a/py/emitnx86.c b/py/emitnx86.c
index 7c96c3b82b352..f0553f0682bb9 100644
--- a/py/emitnx86.c
+++ b/py/emitnx86.c
@@ -1,7 +1,7 @@
 // x86 specific stuff
 
 #include "py/mpconfig.h"
-#include "py/runtime0.h"
+#include "py/nativeglue.h"
 
 #if MICROPY_EMIT_X86
 
@@ -34,13 +34,11 @@ STATIC byte mp_f_n_args[MP_F_NUMBER_OF] = {
     [MP_F_BINARY_OP] = 3,
     [MP_F_BUILD_TUPLE] = 2,
     [MP_F_BUILD_LIST] = 2,
-    [MP_F_LIST_APPEND] = 2,
     [MP_F_BUILD_MAP] = 1,
-    [MP_F_STORE_MAP] = 3,
-    #if MICROPY_PY_BUILTINS_SET
     [MP_F_BUILD_SET] = 2,
     [MP_F_STORE_SET] = 2,
-    #endif
+    [MP_F_LIST_APPEND] = 2,
+    [MP_F_STORE_MAP] = 3,
     [MP_F_MAKE_FUNCTION_FROM_RAW_CODE] = 3,
     [MP_F_NATIVE_CALL_FUNCTION_N_KW] = 3,
     [MP_F_CALL_METHOD_N_KW] = 3,
@@ -53,20 +51,18 @@ STATIC byte mp_f_n_args[MP_F_NUMBER_OF] = {
     [MP_F_IMPORT_NAME] = 3,
     [MP_F_IMPORT_FROM] = 2,
     [MP_F_IMPORT_ALL] = 1,
-    #if MICROPY_PY_BUILTINS_SLICE
     [MP_F_NEW_SLICE] = 3,
-    #endif
     [MP_F_UNPACK_SEQUENCE] = 3,
     [MP_F_UNPACK_EX] = 3,
     [MP_F_DELETE_NAME] = 1,
     [MP_F_DELETE_GLOBAL] = 1,
-    [MP_F_NEW_CELL] = 1,
     [MP_F_MAKE_CLOSURE_FROM_RAW_CODE] = 3,
     [MP_F_ARG_CHECK_NUM_SIG] = 3,
     [MP_F_SETUP_CODE_STATE] = 4,
     [MP_F_SMALL_INT_FLOOR_DIVIDE] = 2,
     [MP_F_SMALL_INT_MODULO] = 2,
     [MP_F_NATIVE_YIELD_FROM] = 3,
+    [MP_F_SETJMP] = 1,
 };
 
 #define N_X86 (1)
diff --git a/py/emitnxtensawin.c b/py/emitnxtensawin.c
new file mode 100644
index 0000000000000..38d5db13ea450
--- /dev/null
+++ b/py/emitnxtensawin.c
@@ -0,0 +1,23 @@
+// Xtensa-Windowed specific stuff
+
+#include "py/mpconfig.h"
+
+#if MICROPY_EMIT_XTENSAWIN
+
+// this is defined so that the assembler exports generic assembler API macros
+#define GENERIC_ASM_API (1)
+#define GENERIC_ASM_API_WIN (1)
+#include "py/asmxtensa.h"
+
+// Word indices of REG_LOCAL_x in nlr_buf_t
+#define NLR_BUF_IDX_LOCAL_1 (2 + 4) // a4
+#define NLR_BUF_IDX_LOCAL_2 (2 + 5) // a5
+#define NLR_BUF_IDX_LOCAL_3 (2 + 6) // a6
+
+#define N_NLR_SETJMP (1)
+#define N_PRELUDE_AS_BYTES_OBJ (1)
+#define N_XTENSAWIN (1)
+#define EXPORT_FUN(name) emit_native_xtensawin_##name
+#include "py/emitnative.c"
+
+#endif
diff --git a/py/formatfloat.c b/py/formatfloat.c
index dc7fc1d1fd769..9d28b2317dc64 100644
--- a/py/formatfloat.c
+++ b/py/formatfloat.c
@@ -68,11 +68,20 @@ union floatbits {
     float f;
     uint32_t u;
 };
-static inline int fp_signbit(float x) { union floatbits fb = {x}; return fb.u & FLT_SIGN_MASK; }
+static inline int fp_signbit(float x) {
+    union floatbits fb = {x};
+    return fb.u & FLT_SIGN_MASK;
+}
 #define fp_isnan(x) isnan(x)
 #define fp_isinf(x) isinf(x)
-static inline int fp_iszero(float x) { union floatbits fb = {x}; return fb.u == 0; }
-static inline int fp_isless1(float x) { union floatbits fb = {x}; return fb.u < 0x3f800000; }
+static inline int fp_iszero(float x) {
+    union floatbits fb = {x};
+    return fb.u == 0;
+}
+static inline int fp_isless1(float x) {
+    union floatbits fb = {x};
+    return fb.u < 0x3f800000;
+}
 
 #elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
 
@@ -91,15 +100,15 @@ static inline int fp_isless1(float x) { union floatbits fb = {x}; return fb.u <
 
 static const FPTYPE g_pos_pow[] = {
     #if FPDECEXP > 32
-    1e256, 1e128, 1e64,
+    MICROPY_FLOAT_CONST(1e256), MICROPY_FLOAT_CONST(1e128), MICROPY_FLOAT_CONST(1e64),
     #endif
-    1e32, 1e16, 1e8, 1e4, 1e2, 1e1
+    MICROPY_FLOAT_CONST(1e32), MICROPY_FLOAT_CONST(1e16), MICROPY_FLOAT_CONST(1e8), MICROPY_FLOAT_CONST(1e4), MICROPY_FLOAT_CONST(1e2), MICROPY_FLOAT_CONST(1e1)
 };
 static const FPTYPE g_neg_pow[] = {
     #if FPDECEXP > 32
-    1e-256, 1e-128, 1e-64,
+    MICROPY_FLOAT_CONST(1e-256), MICROPY_FLOAT_CONST(1e-128), MICROPY_FLOAT_CONST(1e-64),
     #endif
-    1e-32, 1e-16, 1e-8, 1e-4, 1e-2, 1e-1
+    MICROPY_FLOAT_CONST(1e-32), MICROPY_FLOAT_CONST(1e-16), MICROPY_FLOAT_CONST(1e-8), MICROPY_FLOAT_CONST(1e-4), MICROPY_FLOAT_CONST(1e-2), MICROPY_FLOAT_CONST(1e-1)
 };
 
 int mp_format_float(FPTYPE f, char *buf, size_t buf_size, char fmt, int prec, char sign) {
@@ -282,7 +291,7 @@ int mp_format_float(FPTYPE f, char *buf, size_t buf_size, char fmt, int prec, ch
         if (fmt == 'e' && prec > (buf_remaining - FPMIN_BUF_SIZE)) {
             prec = buf_remaining - FPMIN_BUF_SIZE;
         }
-        if (fmt == 'g'){
+        if (fmt == 'g') {
             // Truncate precision to prevent buffer overflow
             if (prec + (FPMIN_BUF_SIZE - 1) > buf_remaining) {
                 prec = buf_remaining - (FPMIN_BUF_SIZE - 1);
diff --git a/py/frozenmod.c b/py/frozenmod.c
index 06d4f84c8e057..a250c02151e92 100644
--- a/py/frozenmod.c
+++ b/py/frozenmod.c
@@ -146,7 +146,7 @@ int mp_find_frozen_module(const char *str, size_t len, void **data) {
     #if MICROPY_MODULE_FROZEN_MPY
     const mp_raw_code_t *rc = mp_find_frozen_mpy(str, len);
     if (rc != NULL) {
-        *data = (void*)rc;
+        *data = (void *)rc;
         return MP_FROZEN_MPY;
     }
     #endif
diff --git a/py/frozenmod.h b/py/frozenmod.h
index 8cddef6819c59..8a477d028e036 100644
--- a/py/frozenmod.h
+++ b/py/frozenmod.h
@@ -3,7 +3,8 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2014 Damien P. George
+ * Copyright (c) 2015 Paul Sokolovsky
+ * Copyright (c) 2016 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
diff --git a/py/gc.c b/py/gc.c
index 2965059a1a25b..9c6336852a0cd 100644
--- a/py/gc.c
+++ b/py/gc.c
@@ -4,6 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2014 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -81,7 +82,7 @@
 #define ATB_HEAD_TO_MARK(block) do { MP_STATE_MEM(gc_alloc_table_start)[(block) / BLOCKS_PER_ATB] |= (AT_MARK << BLOCK_SHIFT(block)); } while (0)
 #define ATB_MARK_TO_HEAD(block) do { MP_STATE_MEM(gc_alloc_table_start)[(block) / BLOCKS_PER_ATB] &= (~(AT_TAIL << BLOCK_SHIFT(block))); } while (0)
 
-#define BLOCK_FROM_PTR(ptr) (((byte*)(ptr) - MP_STATE_MEM(gc_pool_start)) / BYTES_PER_BLOCK)
+#define BLOCK_FROM_PTR(ptr) (((byte *)(ptr) - MP_STATE_MEM(gc_pool_start)) / BYTES_PER_BLOCK)
 #define PTR_FROM_BLOCK(block) (((block) * BYTES_PER_BLOCK + (uintptr_t)MP_STATE_MEM(gc_pool_start)))
 #define ATB_FROM_BLOCK(bl) ((bl) / BLOCKS_PER_ATB)
 
@@ -107,43 +108,43 @@
 // TODO waste less memory; currently requires that all entries in alloc_table have a corresponding block in pool
 void gc_init(void *start, void *end) {
     // align end pointer on block boundary
-    end = (void*)((uintptr_t)end & (~(BYTES_PER_BLOCK - 1)));
-    DEBUG_printf("Initializing GC heap: %p..%p = " UINT_FMT " bytes\n", start, end, (byte*)end - (byte*)start);
+    end = (void *)((uintptr_t)end & (~(BYTES_PER_BLOCK - 1)));
+    DEBUG_printf("Initializing GC heap: %p..%p = " UINT_FMT " bytes\n", start, end, (byte *)end - (byte *)start);
 
     // calculate parameters for GC (T=total, A=alloc table, F=finaliser table, P=pool; all in bytes):
     // T = A + F + P
     //     F = A * BLOCKS_PER_ATB / BLOCKS_PER_FTB
     //     P = A * BLOCKS_PER_ATB * BYTES_PER_BLOCK
     // => T = A * (1 + BLOCKS_PER_ATB / BLOCKS_PER_FTB + BLOCKS_PER_ATB * BYTES_PER_BLOCK)
-    size_t total_byte_len = (byte*)end - (byte*)start;
-#if MICROPY_ENABLE_FINALISER
+    size_t total_byte_len = (byte *)end - (byte *)start;
+    #if MICROPY_ENABLE_FINALISER
     MP_STATE_MEM(gc_alloc_table_byte_len) = total_byte_len * BITS_PER_BYTE / (BITS_PER_BYTE + BITS_PER_BYTE * BLOCKS_PER_ATB / BLOCKS_PER_FTB + BITS_PER_BYTE * BLOCKS_PER_ATB * BYTES_PER_BLOCK);
-#else
+    #else
     MP_STATE_MEM(gc_alloc_table_byte_len) = total_byte_len / (1 + BITS_PER_BYTE / 2 * BYTES_PER_BLOCK);
-#endif
+    #endif
 
-    MP_STATE_MEM(gc_alloc_table_start) = (byte*)start;
+    MP_STATE_MEM(gc_alloc_table_start) = (byte *)start;
 
-#if MICROPY_ENABLE_FINALISER
+    #if MICROPY_ENABLE_FINALISER
     size_t gc_finaliser_table_byte_len = (MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB + BLOCKS_PER_FTB - 1) / BLOCKS_PER_FTB;
     MP_STATE_MEM(gc_finaliser_table_start) = MP_STATE_MEM(gc_alloc_table_start) + MP_STATE_MEM(gc_alloc_table_byte_len);
-#endif
+    #endif
 
     size_t gc_pool_block_len = MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB;
-    MP_STATE_MEM(gc_pool_start) = (byte*)end - gc_pool_block_len * BYTES_PER_BLOCK;
+    MP_STATE_MEM(gc_pool_start) = (byte *)end - gc_pool_block_len * BYTES_PER_BLOCK;
     MP_STATE_MEM(gc_pool_end) = end;
 
-#if MICROPY_ENABLE_FINALISER
+    #if MICROPY_ENABLE_FINALISER
     assert(MP_STATE_MEM(gc_pool_start) >= MP_STATE_MEM(gc_finaliser_table_start) + gc_finaliser_table_byte_len);
-#endif
+    #endif
 
     // clear ATBs
     memset(MP_STATE_MEM(gc_alloc_table_start), 0, MP_STATE_MEM(gc_alloc_table_byte_len));
 
-#if MICROPY_ENABLE_FINALISER
+    #if MICROPY_ENABLE_FINALISER
     // clear FTBs
     memset(MP_STATE_MEM(gc_finaliser_table_start), 0, gc_finaliser_table_byte_len);
-#endif
+    #endif
 
     // set last free ATB index to start of heap
     MP_STATE_MEM(gc_last_free_atb_index) = 0;
@@ -160,15 +161,15 @@ void gc_init(void *start, void *end) {
     MP_STATE_MEM(gc_alloc_amount) = 0;
     #endif
 
-    #if MICROPY_PY_THREAD
+    #if MICROPY_PY_THREAD && !MICROPY_PY_THREAD_GIL
     mp_thread_mutex_init(&MP_STATE_MEM(gc_mutex));
     #endif
 
     DEBUG_printf("GC layout:\n");
     DEBUG_printf("  alloc table at %p, length " UINT_FMT " bytes, " UINT_FMT " blocks\n", MP_STATE_MEM(gc_alloc_table_start), MP_STATE_MEM(gc_alloc_table_byte_len), MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB);
-#if MICROPY_ENABLE_FINALISER
+    #if MICROPY_ENABLE_FINALISER
     DEBUG_printf("  finaliser table at %p, length " UINT_FMT " bytes, " UINT_FMT " blocks\n", MP_STATE_MEM(gc_finaliser_table_start), gc_finaliser_table_byte_len, gc_finaliser_table_byte_len * BLOCKS_PER_FTB);
-#endif
+    #endif
     DEBUG_printf("  pool at %p, length " UINT_FMT " bytes, " UINT_FMT " blocks\n", MP_STATE_MEM(gc_pool_start), gc_pool_block_len * BYTES_PER_BLOCK, gc_pool_block_len);
 }
 
@@ -190,9 +191,9 @@ bool gc_is_locked(void) {
 
 // ptr should be of type void*
 #define VERIFY_PTR(ptr) ( \
-        ((uintptr_t)(ptr) & (BYTES_PER_BLOCK - 1)) == 0      /* must be aligned on a block */ \
-        && ptr >= (void*)MP_STATE_MEM(gc_pool_start)     /* must be above start of pool */ \
-        && ptr < (void*)MP_STATE_MEM(gc_pool_end)        /* must be below end of pool */ \
+    ((uintptr_t)(ptr) & (BYTES_PER_BLOCK - 1)) == 0          /* must be aligned on a block */ \
+    && ptr >= (void *)MP_STATE_MEM(gc_pool_start)        /* must be above start of pool */ \
+    && ptr < (void *)MP_STATE_MEM(gc_pool_end)           /* must be below end of pool */ \
     )
 
 #ifndef TRACE_MARK
@@ -218,8 +219,8 @@ STATIC void gc_mark_subtree(size_t block) {
         } while (ATB_GET_KIND(block + n_blocks) == AT_TAIL);
 
         // check this block's children
-        void **ptrs = (void**)PTR_FROM_BLOCK(block);
-        for (size_t i = n_blocks * BYTES_PER_BLOCK / sizeof(void*); i > 0; i--, ptrs++) {
+        void **ptrs = (void **)PTR_FROM_BLOCK(block);
+        for (size_t i = n_blocks * BYTES_PER_BLOCK / sizeof(void *); i > 0; i--, ptrs++) {
             void *ptr = *ptrs;
             if (VERIFY_PTR(ptr)) {
                 // Mark and push this pointer
@@ -270,9 +271,9 @@ STATIC void gc_sweep(void) {
     for (size_t block = 0; block < MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB; block++) {
         switch (ATB_GET_KIND(block)) {
             case AT_HEAD:
-#if MICROPY_ENABLE_FINALISER
+                #if MICROPY_ENABLE_FINALISER
                 if (FTB_GET(block)) {
-                    mp_obj_base_t *obj = (mp_obj_base_t*)PTR_FROM_BLOCK(block);
+                    mp_obj_base_t *obj = (mp_obj_base_t *)PTR_FROM_BLOCK(block);
                     if (obj->type != NULL) {
                         // if the object has a type then see if it has a __del__ method
                         mp_obj_t dest[2];
@@ -291,19 +292,19 @@ STATIC void gc_sweep(void) {
                     // clear finaliser flag
                     FTB_CLEAR(block);
                 }
-#endif
+                #endif
                 free_tail = 1;
                 DEBUG_printf("gc_sweep(%p)\n", PTR_FROM_BLOCK(block));
                 #if MICROPY_PY_GC_COLLECT_RETVAL
                 MP_STATE_MEM(gc_collected)++;
                 #endif
-                // fall through to free the head
+            // fall through to free the head
 
             case AT_TAIL:
                 if (free_tail) {
                     ATB_ANY_TO_FREE(block);
                     #if CLEAR_ON_SWEEP
-                    memset((void*)PTR_FROM_BLOCK(block), 0, BYTES_PER_BLOCK);
+                    memset((void *)PTR_FROM_BLOCK(block), 0, BYTES_PER_BLOCK);
                     #endif
                 }
                 break;
@@ -327,15 +328,15 @@ void gc_collect_start(void) {
     // Trace root pointers.  This relies on the root pointers being organised
     // correctly in the mp_state_ctx structure.  We scan nlr_top, dict_locals,
     // dict_globals, then the root pointer section of mp_state_vm.
-    void **ptrs = (void**)(void*)&mp_state_ctx;
+    void **ptrs = (void **)(void *)&mp_state_ctx;
     size_t root_start = offsetof(mp_state_ctx_t, thread.dict_locals);
     size_t root_end = offsetof(mp_state_ctx_t, vm.qstr_last_chunk);
-    gc_collect_root(ptrs + root_start / sizeof(void*), (root_end - root_start) / sizeof(void*));
+    gc_collect_root(ptrs + root_start / sizeof(void *), (root_end - root_start) / sizeof(void *));
 
     #if MICROPY_ENABLE_PYSTACK
     // Trace root pointers from the Python stack.
-    ptrs = (void**)(void*)MP_STATE_THREAD(pystack_start);
-    gc_collect_root(ptrs, (MP_STATE_THREAD(pystack_cur) - MP_STATE_THREAD(pystack_start)) / sizeof(void*));
+    ptrs = (void **)(void *)MP_STATE_THREAD(pystack_start);
+    gc_collect_root(ptrs, (MP_STATE_THREAD(pystack_cur) - MP_STATE_THREAD(pystack_start)) / sizeof(void *));
     #endif
 }
 
@@ -472,10 +473,12 @@ void *gc_alloc(size_t n_bytes, unsigned int alloc_flags) {
         n_free = 0;
         for (i = MP_STATE_MEM(gc_last_free_atb_index); i < MP_STATE_MEM(gc_alloc_table_byte_len); i++) {
             byte a = MP_STATE_MEM(gc_alloc_table_start)[i];
+            // *FORMAT-OFF*
             if (ATB_0_IS_FREE(a)) { if (++n_free >= n_blocks) { i = i * BLOCKS_PER_ATB + 0; goto found; } } else { n_free = 0; }
             if (ATB_1_IS_FREE(a)) { if (++n_free >= n_blocks) { i = i * BLOCKS_PER_ATB + 1; goto found; } } else { n_free = 0; }
             if (ATB_2_IS_FREE(a)) { if (++n_free >= n_blocks) { i = i * BLOCKS_PER_ATB + 2; goto found; } } else { n_free = 0; }
             if (ATB_3_IS_FREE(a)) { if (++n_free >= n_blocks) { i = i * BLOCKS_PER_ATB + 3; goto found; } } else { n_free = 0; }
+            // *FORMAT-ON*
         }
 
         GC_EXIT();
@@ -515,7 +518,7 @@ void *gc_alloc(size_t n_bytes, unsigned int alloc_flags) {
 
     // get pointer to first block
     // we must create this pointer before unlocking the GC so a collection can find it
-    void *ret_ptr = (void*)(MP_STATE_MEM(gc_pool_start) + start_block * BYTES_PER_BLOCK);
+    void *ret_ptr = (void *)(MP_STATE_MEM(gc_pool_start) + start_block * BYTES_PER_BLOCK);
     DEBUG_printf("gc_alloc(%p)\n", ret_ptr);
 
     #if MICROPY_GC_ALLOC_THRESHOLD
@@ -526,20 +529,20 @@ void *gc_alloc(size_t n_bytes, unsigned int alloc_flags) {
 
     #if MICROPY_GC_CONSERVATIVE_CLEAR
     // be conservative and zero out all the newly allocated blocks
-    memset((byte*)ret_ptr, 0, (end_block - start_block + 1) * BYTES_PER_BLOCK);
+    memset((byte *)ret_ptr, 0, (end_block - start_block + 1) * BYTES_PER_BLOCK);
     #else
     // zero out the additional bytes of the newly allocated blocks
     // This is needed because the blocks may have previously held pointers
     // to the heap and will not be set to something else if the caller
     // doesn't actually use the entire block.  As such they will continue
     // to point to the heap and may prevent other blocks from being reclaimed.
-    memset((byte*)ret_ptr + n_bytes, 0, (end_block - start_block + 1) * BYTES_PER_BLOCK - n_bytes);
+    memset((byte *)ret_ptr + n_bytes, 0, (end_block - start_block + 1) * BYTES_PER_BLOCK - n_bytes);
     #endif
 
     #if MICROPY_ENABLE_FINALISER
     if (has_finaliser) {
         // clear type pointer in case it is never set
-        ((mp_obj_base_t*)ret_ptr)->type = NULL;
+        ((mp_obj_base_t *)ret_ptr)->type = NULL;
         // set mp_obj flag only if it has a finaliser
         GC_ENTER();
         FTB_SET(start_block);
@@ -640,11 +643,11 @@ void *gc_realloc(void *ptr, mp_uint_t n_bytes) {
         if (ptr == NULL) {
             has_finaliser = false;
         } else {
-#if MICROPY_ENABLE_FINALISER
+            #if MICROPY_ENABLE_FINALISER
             has_finaliser = FTB_GET(BLOCK_FROM_PTR((mp_uint_t)ptr));
-#else
+            #else
             has_finaliser = false;
-#endif
+            #endif
         }
         void *ptr2 = gc_alloc(n_bytes, has_finaliser);
         if (ptr2 == NULL) {
@@ -693,7 +696,7 @@ void *gc_realloc(void *ptr_in, size_t n_bytes, bool allow_move) {
     // free blocks to satisfy the realloc.  Note that we need to compute the
     // total size of the existing memory chunk so we can correctly and
     // efficiently shrink it (see below for shrinking code).
-    size_t n_free   = 0;
+    size_t n_free = 0;
     size_t n_blocks = 1; // counting HEAD block
     size_t max_block = MP_STATE_MEM(gc_alloc_table_byte_len) * BLOCKS_PER_ATB;
     for (size_t bl = block + n_blocks; bl < max_block; bl++) {
@@ -752,10 +755,10 @@ void *gc_realloc(void *ptr_in, size_t n_bytes, bool allow_move) {
 
         #if MICROPY_GC_CONSERVATIVE_CLEAR
         // be conservative and zero out all the newly allocated blocks
-        memset((byte*)ptr_in + n_blocks * BYTES_PER_BLOCK, 0, (new_blocks - n_blocks) * BYTES_PER_BLOCK);
+        memset((byte *)ptr_in + n_blocks * BYTES_PER_BLOCK, 0, (new_blocks - n_blocks) * BYTES_PER_BLOCK);
         #else
         // zero out the additional bytes of the newly allocated blocks (see comment above in gc_alloc)
-        memset((byte*)ptr_in + n_bytes, 0, new_blocks * BYTES_PER_BLOCK - n_bytes);
+        memset((byte *)ptr_in + n_bytes, 0, new_blocks * BYTES_PER_BLOCK - n_bytes);
         #endif
 
         #if EXTENSIVE_HEAP_PROFILING
@@ -799,7 +802,7 @@ void gc_dump_info(void) {
     mp_printf(&mp_plat_print, "GC: total: %u, used: %u, free: %u\n",
         (uint)info.total, (uint)info.used, (uint)info.free);
     mp_printf(&mp_plat_print, " No. of 1-blocks: %u, 2-blocks: %u, max blk sz: %u, max free sz: %u\n",
-           (uint)info.num_1block, (uint)info.num_2block, (uint)info.max_block, (uint)info.max_free);
+        (uint)info.num_1block, (uint)info.num_2block, (uint)info.max_block, (uint)info.max_free);
 }
 
 void gc_dump_alloc_table(void) {
@@ -831,12 +834,14 @@ void gc_dump_alloc_table(void) {
             }
             // print header for new line of blocks
             // (the cast to uint32_t is for 16-bit ports)
-            //mp_printf(&mp_plat_print, "\n%05x: ", (uint)(PTR_FROM_BLOCK(bl) & (uint32_t)0xfffff));
+            // mp_printf(&mp_plat_print, "\n%05x: ", (uint)(PTR_FROM_BLOCK(bl) & (uint32_t)0xfffff));
             mp_printf(&mp_plat_print, "\n%05x: ", (uint)((bl * BYTES_PER_BLOCK) & (uint32_t)0xfffff));
         }
         int c = ' ';
         switch (ATB_GET_KIND(bl)) {
-            case AT_FREE: c = '.'; break;
+            case AT_FREE:
+                c = '.';
+                break;
             /* this prints out if the object is reachable from BSS or STACK (for unix only)
             case AT_HEAD: {
                 c = 'h';
@@ -865,35 +870,48 @@ void gc_dump_alloc_table(void) {
             */
             /* this prints the uPy object type of the head block */
             case AT_HEAD: {
-                void **ptr = (void**)(MP_STATE_MEM(gc_pool_start) + bl * BYTES_PER_BLOCK);
-                if (*ptr == &mp_type_tuple) { c = 'T'; }
-                else if (*ptr == &mp_type_list) { c = 'L'; }
-                else if (*ptr == &mp_type_dict) { c = 'D'; }
-                else if (*ptr == &mp_type_str || *ptr == &mp_type_bytes) { c = 'S'; }
+                void **ptr = (void **)(MP_STATE_MEM(gc_pool_start) + bl * BYTES_PER_BLOCK);
+                if (*ptr == &mp_type_tuple) {
+                    c = 'T';
+                } else if (*ptr == &mp_type_list) {
+                    c = 'L';
+                } else if (*ptr == &mp_type_dict) {
+                    c = 'D';
+                } else if (*ptr == &mp_type_str || *ptr == &mp_type_bytes) {
+                    c = 'S';
+                }
                 #if MICROPY_PY_BUILTINS_BYTEARRAY
-                else if (*ptr == &mp_type_bytearray) { c = 'A'; }
+                else if (*ptr == &mp_type_bytearray) {
+                    c = 'A';
+                }
                 #endif
                 #if MICROPY_PY_ARRAY
-                else if (*ptr == &mp_type_array) { c = 'A'; }
+                else if (*ptr == &mp_type_array) {
+                    c = 'A';
+                }
                 #endif
                 #if MICROPY_PY_BUILTINS_FLOAT
-                else if (*ptr == &mp_type_float) { c = 'F'; }
+                else if (*ptr == &mp_type_float) {
+                    c = 'F';
+                }
                 #endif
-                else if (*ptr == &mp_type_fun_bc) { c = 'B'; }
-                else if (*ptr == &mp_type_module) { c = 'M'; }
-                else {
+                else if (*ptr == &mp_type_fun_bc) {
+                    c = 'B';
+                } else if (*ptr == &mp_type_module) {
+                    c = 'M';
+                } else {
                     c = 'h';
                     #if 0
                     // This code prints "Q" for qstr-pool data, and "q" for qstr-str
                     // data.  It can be useful to see how qstrs are being allocated,
                     // but is disabled by default because it is very slow.
                     for (qstr_pool_t *pool = MP_STATE_VM(last_pool); c == 'h' && pool != NULL; pool = pool->prev) {
-                        if ((qstr_pool_t*)ptr == pool) {
+                        if ((qstr_pool_t *)ptr == pool) {
                             c = 'Q';
                             break;
                         }
                         for (const byte **q = pool->qstrs, **q_top = pool->qstrs + pool->len; q < q_top; q++) {
-                            if ((const byte*)ptr == *q) {
+                            if ((const byte *)ptr == *q) {
                                 c = 'q';
                                 break;
                             }
@@ -903,8 +921,12 @@ void gc_dump_alloc_table(void) {
                 }
                 break;
             }
-            case AT_TAIL: c = '='; break;
-            case AT_MARK: c = 'm'; break;
+            case AT_TAIL:
+                c = '=';
+                break;
+            case AT_MARK:
+                c = 'm';
+                break;
         }
         mp_printf(&mp_plat_print, "%c", c);
     }
@@ -930,11 +952,11 @@ void gc_test(void) {
         p2[1] = p;
         ptrs[0] = p2;
     }
-    for (int i = 0; i < 25; i+=2) {
+    for (int i = 0; i < 25; i += 2) {
         mp_uint_t *p = gc_alloc(i, false);
         printf("p=%p\n", p);
         if (i & 3) {
-            //ptrs[i] = p;
+            // ptrs[i] = p;
         }
     }
 
@@ -942,7 +964,7 @@ void gc_test(void) {
     gc_dump_alloc_table();
     printf("Starting GC...\n");
     gc_collect_start();
-    gc_collect_root(ptrs, sizeof(ptrs) / sizeof(void*));
+    gc_collect_root(ptrs, sizeof(ptrs) / sizeof(void *));
     gc_collect_end();
     printf("After GC:\n");
     gc_dump_alloc_table();
diff --git a/py/grammar.h b/py/grammar.h
index 5a5b682acc934..c3d30cdf7c467 100644
--- a/py/grammar.h
+++ b/py/grammar.h
@@ -24,6 +24,8 @@
  * THE SOFTWARE.
  */
 
+// *FORMAT-OFF*
+
 // rules for writing rules:
 // - zero_or_more is implemented using opt_rule around a one_or_more rule
 // - don't put opt_rule in arguments of or rule; instead, wrap the call to this or rule in opt_rule
@@ -55,7 +57,7 @@ DEF_RULE_NC(eval_input_2, and(1), tok(NEWLINE))
 // varargslist: vfpdef ['=' test] (',' vfpdef ['=' test])* [',' ['*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef]] |  '*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef
 // vfpdef: NAME
 
-DEF_RULE_NC(decorator, and(4), tok(DEL_AT), rule(dotted_name), opt_rule(trailer_paren), tok(NEWLINE))
+DEF_RULE_NC(decorator, and(4), tok(OP_AT), rule(dotted_name), opt_rule(trailer_paren), tok(NEWLINE))
 DEF_RULE_NC(decorators, one_or_more, rule(decorator))
 DEF_RULE(decorated, c(decorated), and_ident(2), rule(decorators), rule(decorated_body))
 #if MICROPY_PY_ASYNC_AWAIT
@@ -96,7 +98,7 @@ DEF_RULE(simple_stmt_2, c(generic_all_nodes), list_with_end, rule(small_stmt), t
 // small_stmt: expr_stmt | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | nonlocal_stmt | assert_stmt
 // expr_stmt: testlist_star_expr (augassign (yield_expr|testlist) | ('=' (yield_expr|testlist_star_expr))*)
 // testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [',']
-// augassign: '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '**=' | '//='
+// augassign: '+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '**=' | '//='
 // # For normal assignments, additional restrictions enforced by the interpreter
 
 DEF_RULE_NC(small_stmt, or(8), rule(del_stmt), rule(pass_stmt), rule(flow_stmt), rule(import_stmt), rule(global_stmt), rule(nonlocal_stmt), rule(assert_stmt), rule(expr_stmt))
@@ -108,7 +110,7 @@ DEF_RULE_NC(expr_stmt_assign, and_ident(2), tok(DEL_EQUAL), rule(expr_stmt_6))
 DEF_RULE_NC(expr_stmt_6, or(2), rule(yield_expr), rule(testlist_star_expr))
 DEF_RULE(testlist_star_expr, c(generic_tuple), list_with_end, rule(testlist_star_expr_2), tok(DEL_COMMA))
 DEF_RULE_NC(testlist_star_expr_2, or(2), rule(star_expr), rule(test))
-DEF_RULE_NC(augassign, or(12), tok(DEL_PLUS_EQUAL), tok(DEL_MINUS_EQUAL), tok(DEL_STAR_EQUAL), tok(DEL_SLASH_EQUAL), tok(DEL_PERCENT_EQUAL), tok(DEL_AMPERSAND_EQUAL), tok(DEL_PIPE_EQUAL), tok(DEL_CARET_EQUAL), tok(DEL_DBL_LESS_EQUAL), tok(DEL_DBL_MORE_EQUAL), tok(DEL_DBL_STAR_EQUAL), tok(DEL_DBL_SLASH_EQUAL))
+DEF_RULE_NC(augassign, or(13), tok(DEL_PLUS_EQUAL), tok(DEL_MINUS_EQUAL), tok(DEL_STAR_EQUAL), tok(DEL_AT_EQUAL), tok(DEL_SLASH_EQUAL), tok(DEL_PERCENT_EQUAL), tok(DEL_AMPERSAND_EQUAL), tok(DEL_PIPE_EQUAL), tok(DEL_CARET_EQUAL), tok(DEL_DBL_LESS_EQUAL), tok(DEL_DBL_MORE_EQUAL), tok(DEL_DBL_STAR_EQUAL), tok(DEL_DBL_SLASH_EQUAL))
 
 // del_stmt: 'del' exprlist
 // pass_stmt: 'pass'
@@ -226,7 +228,7 @@ DEF_RULE(lambdef_nocond, c(lambdef), and_blank(4), tok(KW_LAMBDA), opt_rule(vara
 // and_expr: shift_expr ('&' shift_expr)*
 // shift_expr: arith_expr (('<<'|'>>') arith_expr)*
 // arith_expr: term (('+'|'-') term)*
-// term: factor (('*'|'/'|'%'|'//') factor)*
+// term: factor (('*'|'@'|'/'|'%'|'//') factor)*
 // factor: ('+'|'-'|'~') factor | power
 // power: atom_expr ['**' factor]
 // atom_expr: 'await' atom trailer* | atom trailer*
@@ -249,7 +251,7 @@ DEF_RULE_NC(shift_op, or(2), tok(OP_DBL_LESS), tok(OP_DBL_MORE))
 DEF_RULE(arith_expr, c(term), list, rule(term), rule(arith_op))
 DEF_RULE_NC(arith_op, or(2), tok(OP_PLUS), tok(OP_MINUS))
 DEF_RULE(term, c(term), list, rule(factor), rule(term_op))
-DEF_RULE_NC(term_op, or(4), tok(OP_STAR), tok(OP_SLASH), tok(OP_PERCENT), tok(OP_DBL_SLASH))
+DEF_RULE_NC(term_op, or(5), tok(OP_STAR), tok(OP_AT), tok(OP_SLASH), tok(OP_PERCENT), tok(OP_DBL_SLASH))
 DEF_RULE_NC(factor, or(2), rule(factor_2), rule(power))
 DEF_RULE(factor_2, c(factor_2), and_ident(2), rule(factor_op), rule(factor))
 DEF_RULE_NC(factor_op, or(3), tok(OP_PLUS), tok(OP_MINUS), tok(OP_TILDE))
diff --git a/py/lexer.c b/py/lexer.c
index e161700b1696b..10bb999af6b70 100644
--- a/py/lexer.c
+++ b/py/lexer.c
@@ -105,9 +105,9 @@ STATIC bool is_following_odigit(mp_lexer_t *lex) {
 
 STATIC bool is_string_or_bytes(mp_lexer_t *lex) {
     return is_char_or(lex, '\'', '\"')
-        || (is_char_or3(lex, 'r', 'u', 'b') && is_char_following_or(lex, '\'', '\"'))
-        || ((is_char_and(lex, 'r', 'b') || is_char_and(lex, 'b', 'r'))
-            && is_char_following_following_or(lex, '\'', '\"'));
+           || (is_char_or3(lex, 'r', 'u', 'b') && is_char_following_or(lex, '\'', '\"'))
+           || ((is_char_and(lex, 'r', 'b') || is_char_and(lex, 'b', 'r'))
+               && is_char_following_following_or(lex, '\'', '\"'));
 }
 
 // to easily parse utf-8 identifiers we allow any raw byte with high bit set
@@ -174,7 +174,7 @@ STATIC void indent_pop(mp_lexer_t *lex) {
 // this means if the start of two ops are the same then they are equal til the last char
 
 STATIC const char *const tok_enc =
-    "()[]{},:;@~" // singles
+    "()[]{},:;~" // singles
     "<e=c<e="     // < <= << <<=
     ">e=c>e="     // > >= >> >>=
     "*e=c*e="     // * *= ** **=
@@ -185,6 +185,7 @@ STATIC const char *const tok_enc =
     "/e=c/e="     // / /= // //=
     "%e="         // % %=
     "^e="         // ^ ^=
+    "@e="         // @ @=
     "=e="         // = ==
     "!.";         // start of special cases: != . ...
 
@@ -193,7 +194,7 @@ STATIC const uint8_t tok_enc_kind[] = {
     MP_TOKEN_DEL_PAREN_OPEN, MP_TOKEN_DEL_PAREN_CLOSE,
     MP_TOKEN_DEL_BRACKET_OPEN, MP_TOKEN_DEL_BRACKET_CLOSE,
     MP_TOKEN_DEL_BRACE_OPEN, MP_TOKEN_DEL_BRACE_CLOSE,
-    MP_TOKEN_DEL_COMMA, MP_TOKEN_DEL_COLON, MP_TOKEN_DEL_SEMICOLON, MP_TOKEN_DEL_AT, MP_TOKEN_OP_TILDE,
+    MP_TOKEN_DEL_COMMA, MP_TOKEN_DEL_COLON, MP_TOKEN_DEL_SEMICOLON, MP_TOKEN_OP_TILDE,
 
     MP_TOKEN_OP_LESS, MP_TOKEN_OP_LESS_EQUAL, MP_TOKEN_OP_DBL_LESS, MP_TOKEN_DEL_DBL_LESS_EQUAL,
     MP_TOKEN_OP_MORE, MP_TOKEN_OP_MORE_EQUAL, MP_TOKEN_OP_DBL_MORE, MP_TOKEN_DEL_DBL_MORE_EQUAL,
@@ -205,6 +206,7 @@ STATIC const uint8_t tok_enc_kind[] = {
     MP_TOKEN_OP_SLASH, MP_TOKEN_DEL_SLASH_EQUAL, MP_TOKEN_OP_DBL_SLASH, MP_TOKEN_DEL_DBL_SLASH_EQUAL,
     MP_TOKEN_OP_PERCENT, MP_TOKEN_DEL_PERCENT_EQUAL,
     MP_TOKEN_OP_CARET, MP_TOKEN_DEL_CARET_EQUAL,
+    MP_TOKEN_OP_AT, MP_TOKEN_DEL_AT_EQUAL,
     MP_TOKEN_DEL_EQUAL, MP_TOKEN_OP_DBL_EQUAL,
 };
 
@@ -305,17 +307,36 @@ STATIC void parse_string_literal(mp_lexer_t *lex, bool is_raw) {
                     switch (c) {
                         // note: "c" can never be MP_LEXER_EOF because next_char
                         // always inserts a newline at the end of the input stream
-                        case '\n': c = MP_LEXER_EOF; break; // backslash escape the newline, just ignore it
-                        case '\\': break;
-                        case '\'': break;
-                        case '"': break;
-                        case 'a': c = 0x07; break;
-                        case 'b': c = 0x08; break;
-                        case 't': c = 0x09; break;
-                        case 'n': c = 0x0a; break;
-                        case 'v': c = 0x0b; break;
-                        case 'f': c = 0x0c; break;
-                        case 'r': c = 0x0d; break;
+                        case '\n':
+                            c = MP_LEXER_EOF;
+                            break;                          // backslash escape the newline, just ignore it
+                        case '\\':
+                            break;
+                        case '\'':
+                            break;
+                        case '"':
+                            break;
+                        case 'a':
+                            c = 0x07;
+                            break;
+                        case 'b':
+                            c = 0x08;
+                            break;
+                        case 't':
+                            c = 0x09;
+                            break;
+                        case 'n':
+                            c = 0x0a;
+                            break;
+                        case 'v':
+                            c = 0x0b;
+                            break;
+                        case 'f':
+                            c = 0x0c;
+                            break;
+                        case 'r':
+                            c = 0x0d;
+                            break;
                         case 'u':
                         case 'U':
                             if (lex->tok_kind == MP_TOKEN_BYTES) {
@@ -323,9 +344,8 @@ STATIC void parse_string_literal(mp_lexer_t *lex, bool is_raw) {
                                 vstr_add_char(&lex->vstr, '\\');
                                 break;
                             }
-                            // Otherwise fall through.
-                        case 'x':
-                        {
+                        // Otherwise fall through.
+                        case 'x': {
                             mp_uint_t num = 0;
                             if (!get_hex(lex, (c == 'x' ? 2 : c == 'u' ? 4 : 8), &num)) {
                                 // not enough hex chars for escape sequence
@@ -340,7 +360,7 @@ STATIC void parse_string_literal(mp_lexer_t *lex, bool is_raw) {
                             // 3MB of text; even gzip-compressed and with minimal structure, it'll take
                             // roughly half a meg of storage. This form of Unicode escape may be added
                             // later on, but it's definitely not a priority right now. -- CJA 20140607
-                            mp_raise_NotImplementedError("unicode name escapes");
+                            mp_raise_NotImplementedError(MP_ERROR_TEXT("unicode name escapes"));
                             break;
                         default:
                             if (c >= '0' && c <= '7') {
@@ -705,7 +725,7 @@ mp_lexer_t *mp_lexer_new(qstr src_name, mp_reader_t reader) {
 
 mp_lexer_t *mp_lexer_new_from_str_len(qstr src_name, const char *str, size_t len, size_t free_len) {
     mp_reader_t reader;
-    mp_reader_new_mem(&reader, (const byte*)str, len, free_len);
+    mp_reader_new_mem(&reader, (const byte *)str, len, free_len);
     return mp_lexer_new(src_name, reader);
 }
 
diff --git a/py/lexer.h b/py/lexer.h
index a29709107d939..b9f97013a1bd9 100644
--- a/py/lexer.h
+++ b/py/lexer.h
@@ -96,26 +96,46 @@ typedef enum _mp_token_kind_t {
     MP_TOKEN_KW_WITH,
     MP_TOKEN_KW_YIELD,
 
-    MP_TOKEN_OP_PLUS,
-    MP_TOKEN_OP_MINUS,
-    MP_TOKEN_OP_STAR,
-    MP_TOKEN_OP_DBL_STAR,
-    MP_TOKEN_OP_SLASH,
-    MP_TOKEN_OP_DBL_SLASH,
-    MP_TOKEN_OP_PERCENT,
+    MP_TOKEN_OP_TILDE,
+
+    // Order of these 6 matches corresponding mp_binary_op_t operator
     MP_TOKEN_OP_LESS,
-    MP_TOKEN_OP_DBL_LESS,
     MP_TOKEN_OP_MORE,
-    MP_TOKEN_OP_DBL_MORE,
-    MP_TOKEN_OP_AMPERSAND,
-    MP_TOKEN_OP_PIPE,
-    MP_TOKEN_OP_CARET,
-    MP_TOKEN_OP_TILDE,
+    MP_TOKEN_OP_DBL_EQUAL,
     MP_TOKEN_OP_LESS_EQUAL,
     MP_TOKEN_OP_MORE_EQUAL,
-    MP_TOKEN_OP_DBL_EQUAL,
     MP_TOKEN_OP_NOT_EQUAL,
 
+    // Order of these 13 matches corresponding mp_binary_op_t operator
+    MP_TOKEN_OP_PIPE,
+    MP_TOKEN_OP_CARET,
+    MP_TOKEN_OP_AMPERSAND,
+    MP_TOKEN_OP_DBL_LESS,
+    MP_TOKEN_OP_DBL_MORE,
+    MP_TOKEN_OP_PLUS,
+    MP_TOKEN_OP_MINUS,
+    MP_TOKEN_OP_STAR,
+    MP_TOKEN_OP_AT,
+    MP_TOKEN_OP_DBL_SLASH,
+    MP_TOKEN_OP_SLASH,
+    MP_TOKEN_OP_PERCENT,
+    MP_TOKEN_OP_DBL_STAR,
+
+    // Order of these 13 matches corresponding mp_binary_op_t operator
+    MP_TOKEN_DEL_PIPE_EQUAL,
+    MP_TOKEN_DEL_CARET_EQUAL,
+    MP_TOKEN_DEL_AMPERSAND_EQUAL,
+    MP_TOKEN_DEL_DBL_LESS_EQUAL,
+    MP_TOKEN_DEL_DBL_MORE_EQUAL,
+    MP_TOKEN_DEL_PLUS_EQUAL,
+    MP_TOKEN_DEL_MINUS_EQUAL,
+    MP_TOKEN_DEL_STAR_EQUAL,
+    MP_TOKEN_DEL_AT_EQUAL,
+    MP_TOKEN_DEL_DBL_SLASH_EQUAL,
+    MP_TOKEN_DEL_SLASH_EQUAL,
+    MP_TOKEN_DEL_PERCENT_EQUAL,
+    MP_TOKEN_DEL_DBL_STAR_EQUAL,
+
     MP_TOKEN_DEL_PAREN_OPEN,
     MP_TOKEN_DEL_PAREN_CLOSE,
     MP_TOKEN_DEL_BRACKET_OPEN,
@@ -126,20 +146,7 @@ typedef enum _mp_token_kind_t {
     MP_TOKEN_DEL_COLON,
     MP_TOKEN_DEL_PERIOD,
     MP_TOKEN_DEL_SEMICOLON,
-    MP_TOKEN_DEL_AT,
     MP_TOKEN_DEL_EQUAL,
-    MP_TOKEN_DEL_PLUS_EQUAL,
-    MP_TOKEN_DEL_MINUS_EQUAL,
-    MP_TOKEN_DEL_STAR_EQUAL,
-    MP_TOKEN_DEL_SLASH_EQUAL,
-    MP_TOKEN_DEL_DBL_SLASH_EQUAL,
-    MP_TOKEN_DEL_PERCENT_EQUAL,
-    MP_TOKEN_DEL_AMPERSAND_EQUAL,
-    MP_TOKEN_DEL_PIPE_EQUAL,
-    MP_TOKEN_DEL_CARET_EQUAL,
-    MP_TOKEN_DEL_DBL_MORE_EQUAL,
-    MP_TOKEN_DEL_DBL_LESS_EQUAL,
-    MP_TOKEN_DEL_DBL_STAR_EQUAL,
     MP_TOKEN_DEL_MINUS_MORE,
 } mp_token_kind_t;
 
@@ -177,8 +184,6 @@ void mp_lexer_to_next(mp_lexer_t *lex);
 // platform specific import function; must be implemented for a specific port
 // TODO tidy up, rename, or put elsewhere
 
-//mp_lexer_t *mp_import_open_file(qstr mod_name);
-
 typedef enum {
     MP_IMPORT_STAT_NO_EXIST,
     MP_IMPORT_STAT_DIR,
diff --git a/py/makecompresseddata.py b/py/makecompresseddata.py
new file mode 100644
index 0000000000000..9603de871311c
--- /dev/null
+++ b/py/makecompresseddata.py
@@ -0,0 +1,205 @@
+from __future__ import print_function
+
+import collections
+import re
+import sys
+
+import gzip
+import zlib
+
+
+_COMPRESSED_MARKER = 0xFF
+
+
+def check_non_ascii(msg):
+    for c in msg:
+        if ord(c) >= 0x80:
+            print(
+                'Unable to generate compressed data: message "{}" contains a non-ascii character "{}".'.format(
+                    msg, c
+                ),
+                file=sys.stderr,
+            )
+            sys.exit(1)
+
+
+# Replace <char><space> with <char | 0x80>.
+# Trival scheme to demo/test.
+def space_compression(error_strings):
+    for line in error_strings:
+        check_non_ascii(line)
+        result = ""
+        for i in range(len(line)):
+            if i > 0 and line[i] == " ":
+                result = result[:-1]
+                result += "\\{:03o}".format(ord(line[i - 1]))
+            else:
+                result += line[i]
+        error_strings[line] = result
+    return None
+
+
+# Replace common words with <0x80 | index>.
+# Index is into a table of words stored as aaaaa<0x80|a>bbb<0x80|b>...
+# Replaced words are assumed to have spaces either side to avoid having to store the spaces in the compressed strings.
+def word_compression(error_strings):
+    topn = collections.Counter()
+
+    for line in error_strings.keys():
+        check_non_ascii(line)
+        for word in line.split(" "):
+            topn[word] += 1
+
+    # Order not just by frequency, but by expected saving. i.e. prefer a longer string that is used less frequently.
+    # Use the word itself for ties so that compression is deterministic.
+    def bytes_saved(item):
+        w, n = item
+        return -((len(w) + 1) * (n - 1)), w
+
+    top128 = sorted(topn.items(), key=bytes_saved)[:128]
+
+    index = [w for w, _ in top128]
+    index_lookup = {w: i for i, w in enumerate(index)}
+
+    for line in error_strings.keys():
+        result = ""
+        need_space = False
+        for word in line.split(" "):
+            if word in index_lookup:
+                result += "\\{:03o}".format(0b10000000 | index_lookup[word])
+                need_space = False
+            else:
+                if need_space:
+                    result += " "
+                need_space = True
+                result += word
+        error_strings[line] = result.strip()
+
+    return "".join(w[:-1] + "\\{:03o}".format(0b10000000 | ord(w[-1])) for w in index)
+
+
+# Replace chars in text with variable length bit sequence.
+# For comparison only (the table is not emitted).
+def huffman_compression(error_strings):
+    # https://github.com/tannewt/huffman
+    import huffman
+
+    all_strings = "".join(error_strings)
+    cb = huffman.codebook(collections.Counter(all_strings).items())
+
+    for line in error_strings:
+        b = "1"
+        for c in line:
+            b += cb[c]
+        n = len(b)
+        if n % 8 != 0:
+            n += 8 - (n % 8)
+        result = ""
+        for i in range(0, n, 8):
+            result += "\\{:03o}".format(int(b[i : i + 8], 2))
+        if len(result) > len(line) * 4:
+            result = line
+        error_strings[line] = result
+
+    # TODO: This would be the prefix lengths and the table ordering.
+    return "_" * (10 + len(cb))
+
+
+# Replace common N-letter sequences with <0x80 | index>, where
+# the common sequences are stored in a separate table.
+# This isn't very useful, need a smarter way to find top-ngrams.
+def ngram_compression(error_strings):
+    topn = collections.Counter()
+    N = 2
+
+    for line in error_strings.keys():
+        check_non_ascii(line)
+        if len(line) < N:
+            continue
+        for i in range(0, len(line) - N, N):
+            topn[line[i : i + N]] += 1
+
+    def bytes_saved(item):
+        w, n = item
+        return -(len(w) * (n - 1))
+
+    top128 = sorted(topn.items(), key=bytes_saved)[:128]
+
+    index = [w for w, _ in top128]
+    index_lookup = {w: i for i, w in enumerate(index)}
+
+    for line in error_strings.keys():
+        result = ""
+        for i in range(0, len(line) - N + 1, N):
+            word = line[i : i + N]
+            if word in index_lookup:
+                result += "\\{:03o}".format(0b10000000 | index_lookup[word])
+            else:
+                result += word
+        if len(line) % N != 0:
+            result += line[len(line) - len(line) % N :]
+        error_strings[line] = result.strip()
+
+    return "".join(index)
+
+
+def main(collected_path, fn):
+    error_strings = collections.OrderedDict()
+    max_uncompressed_len = 0
+    num_uses = 0
+
+    # Read in all MP_ERROR_TEXT strings.
+    with open(collected_path, "r") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            num_uses += 1
+            error_strings[line] = None
+            max_uncompressed_len = max(max_uncompressed_len, len(line))
+
+    # So that objexcept.c can figure out how big the buffer needs to be.
+    print("#define MP_MAX_UNCOMPRESSED_TEXT_LEN ({})".format(max_uncompressed_len))
+
+    # Run the compression.
+    compressed_data = fn(error_strings)
+
+    # Print the data table.
+    print('MP_COMPRESSED_DATA("{}")'.format(compressed_data))
+
+    # Print the replacements.
+    for uncomp, comp in error_strings.items():
+        if uncomp == comp:
+            prefix = ""
+        else:
+            prefix = "\\{:03o}".format(_COMPRESSED_MARKER)
+        print('MP_MATCH_COMPRESSED("{}", "{}{}")'.format(uncomp, prefix, comp))
+
+    # Used to calculate the "true" length of the (escaped) compressed strings.
+    def unescape(s):
+        return re.sub(r"\\\d\d\d", "!", s)
+
+    # Stats. Note this doesn't include the cost of the decompressor code.
+    uncomp_len = sum(len(s) + 1 for s in error_strings.keys())
+    comp_len = sum(1 + len(unescape(s)) + 1 for s in error_strings.values())
+    data_len = len(compressed_data) + 1 if compressed_data else 0
+    print("// Total input length:      {}".format(uncomp_len))
+    print("// Total compressed length: {}".format(comp_len))
+    print("// Total data length:       {}".format(data_len))
+    print("// Predicted saving:        {}".format(uncomp_len - comp_len - data_len))
+
+    # Somewhat meaningless comparison to zlib/gzip.
+    all_input_bytes = "\\0".join(error_strings.keys()).encode()
+    print()
+    if hasattr(gzip, "compress"):
+        gzip_len = len(gzip.compress(all_input_bytes)) + num_uses * 4
+        print("// gzip length:             {}".format(gzip_len))
+        print("// Percentage of gzip:      {:.1f}%".format(100 * (comp_len + data_len) / gzip_len))
+    if hasattr(zlib, "compress"):
+        zlib_len = len(zlib.compress(all_input_bytes)) + num_uses * 4
+        print("// zlib length:             {}".format(zlib_len))
+        print("// Percentage of zlib:      {:.1f}%".format(100 * (comp_len + data_len) / zlib_len))
+
+
+if __name__ == "__main__":
+    main(sys.argv[1], word_compression)
diff --git a/py/makemoduledefs.py b/py/makemoduledefs.py
index 18d327f002971..d718da6e02513 100644
--- a/py/makemoduledefs.py
+++ b/py/makemoduledefs.py
@@ -8,14 +8,12 @@
 from __future__ import print_function
 
 import re
+import io
 import os
 import argparse
 
 
-pattern = re.compile(
-    r"[\n;]\s*MP_REGISTER_MODULE\((.*?),\s*(.*?),\s*(.*?)\);",
-    flags=re.DOTALL
-)
+pattern = re.compile(r"[\n;]\s*MP_REGISTER_MODULE\((.*?),\s*(.*?),\s*(.*?)\);", flags=re.DOTALL)
 
 
 def find_c_file(obj_file, vpath):
@@ -27,7 +25,7 @@ def find_c_file(obj_file, vpath):
     """
     c_file = None
     relative_c_file = os.path.splitext(obj_file)[0] + ".c"
-    relative_c_file = relative_c_file.lstrip('/\\')
+    relative_c_file = relative_c_file.lstrip("/\\")
     for p in vpath:
         possible_c_file = os.path.join(p, relative_c_file)
         if os.path.exists(possible_c_file):
@@ -49,7 +47,7 @@ def find_module_registrations(c_file):
         # No c file to match the object file, skip
         return set()
 
-    with open(c_file) as c_file_obj:
+    with io.open(c_file, encoding="utf-8") as c_file_obj:
         return set(re.findall(pattern, c_file_obj.read()))
 
 
@@ -66,15 +64,20 @@ def generate_module_table_header(modules):
     for module_name, obj_module, enabled_define in modules:
         mod_def = "MODULE_DEF_{}".format(module_name.upper())
         mod_defs.append(mod_def)
-        print((
-            "#if ({enabled_define})\n"
-            "    extern const struct _mp_obj_module_t {obj_module};\n"
-            "    #define {mod_def} {{ MP_ROM_QSTR({module_name}), MP_ROM_PTR(&{obj_module}) }},\n"
-            "#else\n"
-            "    #define {mod_def}\n"
-            "#endif\n"
-            ).format(module_name=module_name, obj_module=obj_module,
-                     enabled_define=enabled_define, mod_def=mod_def)
+        print(
+            (
+                "#if ({enabled_define})\n"
+                "    extern const struct _mp_obj_module_t {obj_module};\n"
+                "    #define {mod_def} {{ MP_ROM_QSTR({module_name}), MP_ROM_PTR(&{obj_module}) }},\n"
+                "#else\n"
+                "    #define {mod_def}\n"
+                "#endif\n"
+            ).format(
+                module_name=module_name,
+                obj_module=obj_module,
+                enabled_define=enabled_define,
+                mod_def=mod_def,
+            )
         )
 
     print("\n#define MICROPY_REGISTERED_MODULES \\")
@@ -87,13 +90,13 @@ def generate_module_table_header(modules):
 
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument("--vpath", default=".",
-                        help="comma separated list of folders to search for c files in")
-    parser.add_argument("files", nargs="*",
-                        help="list of c files to search")
+    parser.add_argument(
+        "--vpath", default=".", help="comma separated list of folders to search for c files in"
+    )
+    parser.add_argument("files", nargs="*", help="list of c files to search")
     args = parser.parse_args()
 
-    vpath = [p.strip() for p in args.vpath.split(',')]
+    vpath = [p.strip() for p in args.vpath.split(",")]
 
     modules = set()
     for obj_file in args.files:
@@ -103,5 +106,5 @@ def main():
     generate_module_table_header(sorted(modules))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/py/makeqstrdata.py b/py/makeqstrdata.py
index 060ebb7fd7247..403c4068889c5 100644
--- a/py/makeqstrdata.py
+++ b/py/makeqstrdata.py
@@ -13,49 +13,50 @@
 #   - iterating through bytes is different
 #   - codepoint2name lives in a different module
 import platform
-if platform.python_version_tuple()[0] == '2':
+
+if platform.python_version_tuple()[0] == "2":
     bytes_cons = lambda val, enc=None: bytearray(val)
     from htmlentitydefs import codepoint2name
-elif platform.python_version_tuple()[0] == '3':
+elif platform.python_version_tuple()[0] == "3":
     bytes_cons = bytes
     from html.entities import codepoint2name
 # end compatibility code
 
-codepoint2name[ord('-')] = 'hyphen';
+codepoint2name[ord("-")] = "hyphen"
 
 # add some custom names to map characters that aren't in HTML
-codepoint2name[ord(' ')] = 'space'
-codepoint2name[ord('\'')] = 'squot'
-codepoint2name[ord(',')] = 'comma'
-codepoint2name[ord('.')] = 'dot'
-codepoint2name[ord(':')] = 'colon'
-codepoint2name[ord(';')] = 'semicolon'
-codepoint2name[ord('/')] = 'slash'
-codepoint2name[ord('%')] = 'percent'
-codepoint2name[ord('#')] = 'hash'
-codepoint2name[ord('(')] = 'paren_open'
-codepoint2name[ord(')')] = 'paren_close'
-codepoint2name[ord('[')] = 'bracket_open'
-codepoint2name[ord(']')] = 'bracket_close'
-codepoint2name[ord('{')] = 'brace_open'
-codepoint2name[ord('}')] = 'brace_close'
-codepoint2name[ord('*')] = 'star'
-codepoint2name[ord('!')] = 'bang'
-codepoint2name[ord('\\')] = 'backslash'
-codepoint2name[ord('+')] = 'plus'
-codepoint2name[ord('$')] = 'dollar'
-codepoint2name[ord('=')] = 'equals'
-codepoint2name[ord('?')] = 'question'
-codepoint2name[ord('@')] = 'at_sign'
-codepoint2name[ord('^')] = 'caret'
-codepoint2name[ord('|')] = 'pipe'
-codepoint2name[ord('~')] = 'tilde'
+codepoint2name[ord(" ")] = "space"
+codepoint2name[ord("'")] = "squot"
+codepoint2name[ord(",")] = "comma"
+codepoint2name[ord(".")] = "dot"
+codepoint2name[ord(":")] = "colon"
+codepoint2name[ord(";")] = "semicolon"
+codepoint2name[ord("/")] = "slash"
+codepoint2name[ord("%")] = "percent"
+codepoint2name[ord("#")] = "hash"
+codepoint2name[ord("(")] = "paren_open"
+codepoint2name[ord(")")] = "paren_close"
+codepoint2name[ord("[")] = "bracket_open"
+codepoint2name[ord("]")] = "bracket_close"
+codepoint2name[ord("{")] = "brace_open"
+codepoint2name[ord("}")] = "brace_close"
+codepoint2name[ord("*")] = "star"
+codepoint2name[ord("!")] = "bang"
+codepoint2name[ord("\\")] = "backslash"
+codepoint2name[ord("+")] = "plus"
+codepoint2name[ord("$")] = "dollar"
+codepoint2name[ord("=")] = "equals"
+codepoint2name[ord("?")] = "question"
+codepoint2name[ord("@")] = "at_sign"
+codepoint2name[ord("^")] = "caret"
+codepoint2name[ord("|")] = "pipe"
+codepoint2name[ord("~")] = "tilde"
 
 # static qstrs, should be sorted
 
 static_qstr_list = [
     "",
-    "__dir__", # Put __dir__ after empty qstr for builtin dir() to work
+    "__dir__",  # Put __dir__ after empty qstr for builtin dir() to work
     "\n",
     " ",
     "*",
@@ -229,15 +230,18 @@ def compute_hash(qstr, bytes_hash):
     # Make sure that valid hash is never zero, zero means "hash not computed"
     return (hash & ((1 << (8 * bytes_hash)) - 1)) or 1
 
+
 def qstr_escape(qst):
     def esc_char(m):
         c = ord(m.group(0))
         try:
             name = codepoint2name[c]
         except KeyError:
-            name = '0x%02x' % c
-        return "_" + name + '_'
-    return re.sub(r'[^A-Za-z0-9_]', esc_char, qst)
+            name = "0x%02x" % c
+        return "_" + name + "_"
+
+    return re.sub(r"[^A-Za-z0-9_]", esc_char, qst)
+
 
 def parse_input_headers(infiles):
     qcfgs = {}
@@ -257,31 +261,33 @@ def parse_input_headers(infiles):
 
     # read the qstrs in from the input files
     for infile in infiles:
-        with open(infile, 'rt') as f:
+        with open(infile, "rt") as f:
             for line in f:
                 line = line.strip()
 
                 # is this a config line?
-                match = re.match(r'^QCFG\((.+), (.+)\)', line)
+                match = re.match(r"^QCFG\((.+), (.+)\)", line)
                 if match:
                     value = match.group(2)
-                    if value[0] == '(' and value[-1] == ')':
+                    if value[0] == "(" and value[-1] == ")":
                         # strip parenthesis from config value
                         value = value[1:-1]
                     qcfgs[match.group(1)] = value
                     continue
 
                 # is this a QSTR line?
-                match = re.match(r'^Q\((.*)\)$', line)
+                match = re.match(r"^Q\((.*)\)$", line)
                 if not match:
                     continue
 
                 # get the qstr value
                 qstr = match.group(1)
 
-                # special case to specify control characters
-                if qstr == '\\n':
-                    qstr = '\n'
+                # special cases to specify control characters
+                if qstr == "\\n":
+                    qstr = "\n"
+                elif qstr == "\\r\\n":
+                    qstr = "\r\n"
 
                 # work out the corresponding qstr name
                 ident = qstr_escape(qstr)
@@ -310,43 +316,54 @@ def parse_input_headers(infiles):
 
     return qcfgs, qstrs
 
+
 def make_bytes(cfg_bytes_len, cfg_bytes_hash, qstr):
-    qbytes = bytes_cons(qstr, 'utf8')
+    qbytes = bytes_cons(qstr, "utf8")
     qlen = len(qbytes)
     qhash = compute_hash(qbytes, cfg_bytes_hash)
-    if all(32 <= ord(c) <= 126 and c != '\\' and c != '"' for c in qstr):
+    if all(32 <= ord(c) <= 126 and c != "\\" and c != '"' for c in qstr):
         # qstr is all printable ASCII so render it as-is (for easier debugging)
         qdata = qstr
     else:
         # qstr contains non-printable codes so render entire thing as hex pairs
-        qdata = ''.join(('\\x%02x' % b) for b in qbytes)
+        qdata = "".join(("\\x%02x" % b) for b in qbytes)
     if qlen >= (1 << (8 * cfg_bytes_len)):
-        print('qstr is too long:', qstr)
+        print("qstr is too long:", qstr)
         assert False
-    qlen_str = ('\\x%02x' * cfg_bytes_len) % tuple(((qlen >> (8 * i)) & 0xff) for i in range(cfg_bytes_len))
-    qhash_str = ('\\x%02x' * cfg_bytes_hash) % tuple(((qhash >> (8 * i)) & 0xff) for i in range(cfg_bytes_hash))
+    qlen_str = ("\\x%02x" * cfg_bytes_len) % tuple(
+        ((qlen >> (8 * i)) & 0xFF) for i in range(cfg_bytes_len)
+    )
+    qhash_str = ("\\x%02x" * cfg_bytes_hash) % tuple(
+        ((qhash >> (8 * i)) & 0xFF) for i in range(cfg_bytes_hash)
+    )
     return '(const byte*)"%s%s" "%s"' % (qhash_str, qlen_str, qdata)
 
+
 def print_qstr_data(qcfgs, qstrs):
     # get config variables
-    cfg_bytes_len = int(qcfgs['BYTES_IN_LEN'])
-    cfg_bytes_hash = int(qcfgs['BYTES_IN_HASH'])
+    cfg_bytes_len = int(qcfgs["BYTES_IN_LEN"])
+    cfg_bytes_hash = int(qcfgs["BYTES_IN_HASH"])
 
     # print out the starter of the generated C header file
-    print('// This file was automatically generated by makeqstrdata.py')
-    print('')
+    print("// This file was automatically generated by makeqstrdata.py")
+    print("")
 
     # add NULL qstr with no hash or data
-    print('QDEF(MP_QSTR_NULL, (const byte*)"%s%s" "")' % ('\\x00' * cfg_bytes_hash, '\\x00' * cfg_bytes_len))
+    print(
+        'QDEF(MP_QSTRnull, (const byte*)"%s%s" "")'
+        % ("\\x00" * cfg_bytes_hash, "\\x00" * cfg_bytes_len)
+    )
 
     # go through each qstr and print it out
     for order, ident, qstr in sorted(qstrs.values(), key=lambda x: x[0]):
         qbytes = make_bytes(cfg_bytes_len, cfg_bytes_hash, qstr)
-        print('QDEF(MP_QSTR_%s, %s)' % (ident, qbytes))
+        print("QDEF(MP_QSTR_%s, %s)" % (ident, qbytes))
+
 
 def do_work(infiles):
     qcfgs, qstrs = parse_input_headers(infiles)
     print_qstr_data(qcfgs, qstrs)
 
+
 if __name__ == "__main__":
     do_work(sys.argv[1:])
diff --git a/py/makeqstrdefs.py b/py/makeqstrdefs.py
index 176440136df8f..9449a46ee924a 100644
--- a/py/makeqstrdefs.py
+++ b/py/makeqstrdefs.py
@@ -9,30 +9,38 @@
 
 import re
 import sys
+import io
 import os
 
-# Blacklist of qstrings that are specially handled in further
-# processing and should be ignored
-QSTRING_BLACK_LIST = set(['NULL', 'number_of'])
+
+# Extract MP_QSTR_FOO macros.
+_MODE_QSTR = "qstr"
+
+# Extract MP_COMPRESSED_ROM_TEXT("") macros.  (Which come from MP_ERROR_TEXT)
+_MODE_COMPRESS = "compress"
 
 
 def write_out(fname, output):
     if output:
         for m, r in [("/", "__"), ("\\", "__"), (":", "@"), ("..", "@@")]:
             fname = fname.replace(m, r)
-        with open(args.output_dir + "/" + fname + ".qstr", "w") as f:
+        with open(args.output_dir + "/" + fname + "." + args.mode, "w") as f:
             f.write("\n".join(output) + "\n")
 
+
 def process_file(f):
     re_line = re.compile(r"#[line]*\s\d+\s\"([^\"]+)\"")
-    re_qstr = re.compile(r'MP_QSTR_[_a-zA-Z0-9]+')
+    if args.mode == _MODE_QSTR:
+        re_match = re.compile(r"MP_QSTR_[_a-zA-Z0-9]+")
+    elif args.mode == _MODE_COMPRESS:
+        re_match = re.compile(r'MP_COMPRESSED_ROM_TEXT\("([^"]*)"\)')
     output = []
     last_fname = None
     for line in f:
         if line.isspace():
             continue
         # match gcc-like output (# n "file") and msvc-like output (#line n "file")
-        if line.startswith(('# ', '#line')):
+        if line.startswith(("# ", "#line")):
             m = re_line.match(line)
             assert m is not None
             fname = m.group(1)
@@ -43,10 +51,12 @@ def process_file(f):
                 output = []
                 last_fname = fname
             continue
-        for match in re_qstr.findall(line):
-            name = match.replace('MP_QSTR_', '')
-            if name not in QSTRING_BLACK_LIST:
-                output.append('Q(' + name + ')')
+        for match in re_match.findall(line):
+            if args.mode == _MODE_QSTR:
+                name = match.replace("MP_QSTR_", "")
+                output.append("Q(" + name + ")")
+            elif args.mode == _MODE_COMPRESS:
+                output.append(match)
 
     write_out(last_fname, output)
     return ""
@@ -55,10 +65,11 @@ def process_file(f):
 def cat_together():
     import glob
     import hashlib
+
     hasher = hashlib.md5()
     all_lines = []
     outf = open(args.output_dir + "/out", "wb")
-    for fname in glob.glob(args.output_dir + "/*.qstr"):
+    for fname in glob.glob(args.output_dir + "/*." + args.mode):
         with open(fname, "rb") as f:
             lines = f.readlines()
             all_lines += lines
@@ -68,15 +79,18 @@ def cat_together():
     outf.close()
     hasher.update(all_lines)
     new_hash = hasher.hexdigest()
-    #print(new_hash)
+    # print(new_hash)
     old_hash = None
     try:
         with open(args.output_file + ".hash") as f:
             old_hash = f.read()
     except IOError:
         pass
+    mode_full = "QSTR"
+    if args.mode == _MODE_COMPRESS:
+        mode_full = "Compressed data"
     if old_hash != new_hash:
-        print("QSTR updated")
+        print(mode_full, "updated")
         try:
             # rename below might fail if file exists
             os.remove(args.output_file)
@@ -86,21 +100,27 @@ def cat_together():
         with open(args.output_file + ".hash", "w") as f:
             f.write(new_hash)
     else:
-        print("QSTR not updated")
+        print(mode_full, "not updated")
 
 
 if __name__ == "__main__":
-    if len(sys.argv) != 5:
-        print('usage: %s command input_filename output_dir output_file' % sys.argv[0])
+    if len(sys.argv) != 6:
+        print("usage: %s command mode input_filename output_dir output_file" % sys.argv[0])
         sys.exit(2)
 
     class Args:
         pass
+
     args = Args()
     args.command = sys.argv[1]
-    args.input_filename = sys.argv[2]
-    args.output_dir = sys.argv[3]
-    args.output_file = sys.argv[4]
+    args.mode = sys.argv[2]
+    args.input_filename = sys.argv[3]  # Unused for command=cat
+    args.output_dir = sys.argv[4]
+    args.output_file = None if len(sys.argv) == 5 else sys.argv[5]  # Unused for command=split
+
+    if args.mode not in (_MODE_QSTR, _MODE_COMPRESS):
+        print("error: mode %s unrecognised" % sys.argv[2])
+        sys.exit(2)
 
     try:
         os.makedirs(args.output_dir)
@@ -108,7 +128,7 @@ class Args:
         pass
 
     if args.command == "split":
-        with open(args.input_filename) as infile:
+        with io.open(args.input_filename, encoding="utf-8") as infile:
             process_file(infile)
 
     if args.command == "cat":
diff --git a/py/makeversionhdr.py b/py/makeversionhdr.py
index 2ab99d89b4e84..567b3b8322f9f 100644
--- a/py/makeversionhdr.py
+++ b/py/makeversionhdr.py
@@ -11,6 +11,7 @@
 import datetime
 import subprocess
 
+
 def get_version_info_from_git():
     # Python 2.6 doesn't have check_output, so check for that
     try:
@@ -21,7 +22,11 @@ def get_version_info_from_git():
 
     # Note: git describe doesn't work if no tag is available
     try:
-        git_tag = subprocess.check_output(["git", "describe", "--dirty", "--always"], stderr=subprocess.STDOUT, universal_newlines=True).strip()
+        git_tag = subprocess.check_output(
+            ["git", "describe", "--dirty", "--always"],
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+        ).strip()
     except subprocess.CalledProcessError as er:
         if er.returncode == 128:
             # git exit code of 128 means no repository found
@@ -30,7 +35,11 @@ def get_version_info_from_git():
     except OSError:
         return None
     try:
-        git_hash = subprocess.check_output(["git", "rev-parse", "--short", "HEAD"], stderr=subprocess.STDOUT, universal_newlines=True).strip()
+        git_hash = subprocess.check_output(
+            ["git", "rev-parse", "--short", "HEAD"],
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+        ).strip()
     except subprocess.CalledProcessError:
         git_hash = "unknown"
     except OSError:
@@ -38,9 +47,13 @@ def get_version_info_from_git():
 
     try:
         # Check if there are any modified files.
-        subprocess.check_call(["git", "diff", "--no-ext-diff", "--quiet", "--exit-code"], stderr=subprocess.STDOUT)
+        subprocess.check_call(
+            ["git", "diff", "--no-ext-diff", "--quiet", "--exit-code"], stderr=subprocess.STDOUT
+        )
         # Check if there are any staged files.
-        subprocess.check_call(["git", "diff-index", "--cached", "--quiet", "HEAD", "--"], stderr=subprocess.STDOUT)
+        subprocess.check_call(
+            ["git", "diff-index", "--cached", "--quiet", "HEAD", "--"], stderr=subprocess.STDOUT
+        )
     except subprocess.CalledProcessError:
         git_hash += "-dirty"
     except OSError:
@@ -48,6 +61,7 @@ def get_version_info_from_git():
 
     return git_tag, git_hash
 
+
 def get_version_info_from_docs_conf():
     with open(os.path.join(os.path.dirname(sys.argv[0]), "..", "docs", "conf.py")) as f:
         for line in f:
@@ -57,6 +71,7 @@ def get_version_info_from_docs_conf():
                 return git_tag, "<no hash>"
     return None
 
+
 def make_version_header(filename):
     # Get version info using git, with fallback to docs/conf.py
     info = get_version_info_from_git()
@@ -71,12 +86,16 @@ def make_version_header(filename):
 #define MICROPY_GIT_TAG "%s"
 #define MICROPY_GIT_HASH "%s"
 #define MICROPY_BUILD_DATE "%s"
-""" % (git_tag, git_hash, datetime.date.today().strftime("%Y-%m-%d"))
+""" % (
+        git_tag,
+        git_hash,
+        datetime.date.today().strftime("%Y-%m-%d"),
+    )
 
     # Check if the file contents changed from last time
     write_file = True
     if os.path.isfile(filename):
-        with open(filename, 'r') as f:
+        with open(filename, "r") as f:
             existing_data = f.read()
         if existing_data == file_data:
             write_file = False
@@ -84,8 +103,9 @@ def make_version_header(filename):
     # Only write the file if we need to
     if write_file:
         print("GEN %s" % filename)
-        with open(filename, 'w') as f:
+        with open(filename, "w") as f:
             f.write(file_data)
 
+
 if __name__ == "__main__":
     make_version_header(sys.argv[1])
diff --git a/py/malloc.c b/py/malloc.c
index f8ed1487a5b8c..c775d5b157312 100644
--- a/py/malloc.c
+++ b/py/malloc.c
@@ -87,22 +87,22 @@ void *m_malloc(size_t num_bytes) {
     if (ptr == NULL && num_bytes != 0) {
         m_malloc_fail(num_bytes);
     }
-#if MICROPY_MEM_STATS
+    #if MICROPY_MEM_STATS
     MP_STATE_MEM(total_bytes_allocated) += num_bytes;
     MP_STATE_MEM(current_bytes_allocated) += num_bytes;
     UPDATE_PEAK();
-#endif
+    #endif
     DEBUG_printf("malloc %d : %p\n", num_bytes, ptr);
     return ptr;
 }
 
 void *m_malloc_maybe(size_t num_bytes) {
     void *ptr = malloc(num_bytes);
-#if MICROPY_MEM_STATS
+    #if MICROPY_MEM_STATS
     MP_STATE_MEM(total_bytes_allocated) += num_bytes;
     MP_STATE_MEM(current_bytes_allocated) += num_bytes;
     UPDATE_PEAK();
-#endif
+    #endif
     DEBUG_printf("malloc %d : %p\n", num_bytes, ptr);
     return ptr;
 }
@@ -113,11 +113,11 @@ void *m_malloc_with_finaliser(size_t num_bytes) {
     if (ptr == NULL && num_bytes != 0) {
         m_malloc_fail(num_bytes);
     }
-#if MICROPY_MEM_STATS
+    #if MICROPY_MEM_STATS
     MP_STATE_MEM(total_bytes_allocated) += num_bytes;
     MP_STATE_MEM(current_bytes_allocated) += num_bytes;
     UPDATE_PEAK();
-#endif
+    #endif
     DEBUG_printf("malloc %d : %p\n", num_bytes, ptr);
     return ptr;
 }
@@ -133,15 +133,16 @@ void *m_malloc0(size_t num_bytes) {
 }
 
 #if MICROPY_MALLOC_USES_ALLOCATED_SIZE
-void *m_realloc(void *ptr, size_t old_num_bytes, size_t new_num_bytes) {
+void *m_realloc(void *ptr, size_t old_num_bytes, size_t new_num_bytes)
 #else
-void *m_realloc(void *ptr, size_t new_num_bytes) {
+void *m_realloc(void *ptr, size_t new_num_bytes)
 #endif
+{
     void *new_ptr = realloc(ptr, new_num_bytes);
     if (new_ptr == NULL && new_num_bytes != 0) {
         m_malloc_fail(new_num_bytes);
     }
-#if MICROPY_MEM_STATS
+    #if MICROPY_MEM_STATS
     // At first thought, "Total bytes allocated" should only grow,
     // after all, it's *total*. But consider for example 2K block
     // shrunk to 1K and then grown to 2K again. It's still 2K
@@ -151,7 +152,7 @@ void *m_realloc(void *ptr, size_t new_num_bytes) {
     MP_STATE_MEM(total_bytes_allocated) += diff;
     MP_STATE_MEM(current_bytes_allocated) += diff;
     UPDATE_PEAK();
-#endif
+    #endif
     #if MICROPY_MALLOC_USES_ALLOCATED_SIZE
     DEBUG_printf("realloc %p, %d, %d : %p\n", ptr, old_num_bytes, new_num_bytes, new_ptr);
     #else
@@ -161,12 +162,13 @@ void *m_realloc(void *ptr, size_t new_num_bytes) {
 }
 
 #if MICROPY_MALLOC_USES_ALLOCATED_SIZE
-void *m_realloc_maybe(void *ptr, size_t old_num_bytes, size_t new_num_bytes, bool allow_move) {
+void *m_realloc_maybe(void *ptr, size_t old_num_bytes, size_t new_num_bytes, bool allow_move)
 #else
-void *m_realloc_maybe(void *ptr, size_t new_num_bytes, bool allow_move) {
+void *m_realloc_maybe(void *ptr, size_t new_num_bytes, bool allow_move)
 #endif
+{
     void *new_ptr = realloc_ext(ptr, new_num_bytes, allow_move);
-#if MICROPY_MEM_STATS
+    #if MICROPY_MEM_STATS
     // At first thought, "Total bytes allocated" should only grow,
     // after all, it's *total*. But consider for example 2K block
     // shrunk to 1K and then grown to 2K again. It's still 2K
@@ -179,7 +181,7 @@ void *m_realloc_maybe(void *ptr, size_t new_num_bytes, bool allow_move) {
         MP_STATE_MEM(current_bytes_allocated) += diff;
         UPDATE_PEAK();
     }
-#endif
+    #endif
     #if MICROPY_MALLOC_USES_ALLOCATED_SIZE
     DEBUG_printf("realloc %p, %d, %d : %p\n", ptr, old_num_bytes, new_num_bytes, new_ptr);
     #else
@@ -189,14 +191,15 @@ void *m_realloc_maybe(void *ptr, size_t new_num_bytes, bool allow_move) {
 }
 
 #if MICROPY_MALLOC_USES_ALLOCATED_SIZE
-void m_free(void *ptr, size_t num_bytes) {
+void m_free(void *ptr, size_t num_bytes)
 #else
-void m_free(void *ptr) {
+void m_free(void *ptr)
 #endif
+{
     free(ptr);
-#if MICROPY_MEM_STATS
+    #if MICROPY_MEM_STATS
     MP_STATE_MEM(current_bytes_allocated) -= num_bytes;
-#endif
+    #endif
     #if MICROPY_MALLOC_USES_ALLOCATED_SIZE
     DEBUG_printf("free %p, %d\n", ptr, num_bytes);
     #else
diff --git a/py/map.c b/py/map.c
index 5f3c6e5473359..676c364da76a1 100644
--- a/py/map.c
+++ b/py/map.c
@@ -96,7 +96,7 @@ void mp_map_init_fixed_table(mp_map_t *map, size_t n, const mp_obj_t *table) {
     map->all_keys_are_qstrs = 1;
     map->is_fixed = 1;
     map->is_ordered = 1;
-    map->table = (mp_map_elem_t*)table;
+    map->table = (mp_map_elem_t *)table;
 }
 
 // Differentiate from mp_map_clear() - semantics is different
@@ -177,6 +177,7 @@ mp_map_elem_t *mp_map_lookup(mp_map_t *map, mp_obj_t index, mp_map_lookup_kind_t
                     --map->used;
                     memmove(elem, elem + 1, (top - elem - 1) * sizeof(*elem));
                     // put the found element after the end so the caller can access it if needed
+                    // note: caller must NULL the value so the GC can clean up (e.g. see dict_get_helper).
                     elem = &map->table[map->used];
                     elem->key = MP_OBJ_NULL;
                     elem->value = value;
diff --git a/py/misc.h b/py/misc.h
index e6d25b8509b4a..c7060ddf9d223 100644
--- a/py/misc.h
+++ b/py/misc.h
@@ -47,8 +47,8 @@ typedef unsigned int uint;
 #endif
 
 // Classical double-indirection stringification of preprocessor macro's value
-#define _MP_STRINGIFY(x) #x
-#define MP_STRINGIFY(x) _MP_STRINGIFY(x)
+#define MP_STRINGIFY_HELPER(x) #x
+#define MP_STRINGIFY(x) MP_STRINGIFY_HELPER(x)
 
 // Static assertion macro
 #define MP_STATIC_ASSERT(cond) ((void)sizeof(char[1 - 2 * !(cond)]))
@@ -57,28 +57,28 @@ typedef unsigned int uint;
 
 // TODO make a lazy m_renew that can increase by a smaller amount than requested (but by at least 1 more element)
 
-#define m_new(type, num) ((type*)(m_malloc(sizeof(type) * (num))))
-#define m_new_maybe(type, num) ((type*)(m_malloc_maybe(sizeof(type) * (num))))
-#define m_new0(type, num) ((type*)(m_malloc0(sizeof(type) * (num))))
+#define m_new(type, num) ((type *)(m_malloc(sizeof(type) * (num))))
+#define m_new_maybe(type, num) ((type *)(m_malloc_maybe(sizeof(type) * (num))))
+#define m_new0(type, num) ((type *)(m_malloc0(sizeof(type) * (num))))
 #define m_new_obj(type) (m_new(type, 1))
 #define m_new_obj_maybe(type) (m_new_maybe(type, 1))
-#define m_new_obj_var(obj_type, var_type, var_num) ((obj_type*)m_malloc(sizeof(obj_type) + sizeof(var_type) * (var_num)))
-#define m_new_obj_var_maybe(obj_type, var_type, var_num) ((obj_type*)m_malloc_maybe(sizeof(obj_type) + sizeof(var_type) * (var_num)))
+#define m_new_obj_var(obj_type, var_type, var_num) ((obj_type *)m_malloc(sizeof(obj_type) + sizeof(var_type) * (var_num)))
+#define m_new_obj_var_maybe(obj_type, var_type, var_num) ((obj_type *)m_malloc_maybe(sizeof(obj_type) + sizeof(var_type) * (var_num)))
 #if MICROPY_ENABLE_FINALISER
-#define m_new_obj_with_finaliser(type) ((type*)(m_malloc_with_finaliser(sizeof(type))))
-#define m_new_obj_var_with_finaliser(type, var_type, var_num) ((type*)m_malloc_with_finaliser(sizeof(type) + sizeof(var_type) * (var_num)))
+#define m_new_obj_with_finaliser(type) ((type *)(m_malloc_with_finaliser(sizeof(type))))
+#define m_new_obj_var_with_finaliser(type, var_type, var_num) ((type *)m_malloc_with_finaliser(sizeof(type) + sizeof(var_type) * (var_num)))
 #else
 #define m_new_obj_with_finaliser(type) m_new_obj(type)
 #define m_new_obj_var_with_finaliser(type, var_type, var_num) m_new_obj_var(type, var_type, var_num)
 #endif
 #if MICROPY_MALLOC_USES_ALLOCATED_SIZE
-#define m_renew(type, ptr, old_num, new_num) ((type*)(m_realloc((ptr), sizeof(type) * (old_num), sizeof(type) * (new_num))))
-#define m_renew_maybe(type, ptr, old_num, new_num, allow_move) ((type*)(m_realloc_maybe((ptr), sizeof(type) * (old_num), sizeof(type) * (new_num), (allow_move))))
+#define m_renew(type, ptr, old_num, new_num) ((type *)(m_realloc((ptr), sizeof(type) * (old_num), sizeof(type) * (new_num))))
+#define m_renew_maybe(type, ptr, old_num, new_num, allow_move) ((type *)(m_realloc_maybe((ptr), sizeof(type) * (old_num), sizeof(type) * (new_num), (allow_move))))
 #define m_del(type, ptr, num) m_free(ptr, sizeof(type) * (num))
 #define m_del_var(obj_type, var_type, var_num, ptr) (m_free(ptr, sizeof(obj_type) + sizeof(var_type) * (var_num)))
 #else
-#define m_renew(type, ptr, old_num, new_num) ((type*)(m_realloc((ptr), sizeof(type) * (new_num))))
-#define m_renew_maybe(type, ptr, old_num, new_num, allow_move) ((type*)(m_realloc_maybe((ptr), sizeof(type) * (new_num), (allow_move))))
+#define m_renew(type, ptr, old_num, new_num) ((type *)(m_realloc((ptr), sizeof(type) * (new_num))))
+#define m_renew_maybe(type, ptr, old_num, new_num, allow_move) ((type *)(m_realloc_maybe((ptr), sizeof(type) * (new_num), (allow_move))))
 #define m_del(type, ptr, num) ((void)(num), m_free(ptr))
 #define m_del_var(obj_type, var_type, var_num, ptr) ((void)(var_num), m_free(ptr))
 #endif
@@ -111,7 +111,7 @@ size_t m_get_peak_bytes_allocated(void);
 #define MP_ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
 
 // align ptr to the nearest multiple of "alignment"
-#define MP_ALIGN(ptr, alignment) (void*)(((uintptr_t)(ptr) + ((alignment) - 1)) & ~((alignment) - 1))
+#define MP_ALIGN(ptr, alignment) (void *)(((uintptr_t)(ptr) + ((alignment) - 1)) & ~((alignment) - 1))
 
 /** unichar / UTF-8 *********************************************/
 
@@ -129,9 +129,16 @@ unichar utf8_get_char(const byte *s);
 const byte *utf8_next_char(const byte *s);
 size_t utf8_charlen(const byte *str, size_t len);
 #else
-static inline unichar utf8_get_char(const byte *s) { return *s; }
-static inline const byte *utf8_next_char(const byte *s) { return s + 1; }
-static inline size_t utf8_charlen(const byte *str, size_t len) { (void)str; return len; }
+static inline unichar utf8_get_char(const byte *s) {
+    return *s;
+}
+static inline const byte *utf8_next_char(const byte *s) {
+    return s + 1;
+}
+static inline size_t utf8_charlen(const byte *str, size_t len) {
+    (void)str;
+    return len;
+}
 #endif
 
 bool unichar_isspace(unichar c);
@@ -140,6 +147,7 @@ bool unichar_isprint(unichar c);
 bool unichar_isdigit(unichar c);
 bool unichar_isxdigit(unichar c);
 bool unichar_isident(unichar c);
+bool unichar_isalnum(unichar c);
 bool unichar_isupper(unichar c);
 bool unichar_islower(unichar c);
 unichar unichar_tolower(unichar c);
@@ -168,9 +176,15 @@ void vstr_init_print(vstr_t *vstr, size_t alloc, struct _mp_print_t *print);
 void vstr_clear(vstr_t *vstr);
 vstr_t *vstr_new(size_t alloc);
 void vstr_free(vstr_t *vstr);
-static inline void vstr_reset(vstr_t *vstr) { vstr->len = 0; }
-static inline char *vstr_str(vstr_t *vstr) { return vstr->buf; }
-static inline size_t vstr_len(vstr_t *vstr) { return vstr->len; }
+static inline void vstr_reset(vstr_t *vstr) {
+    vstr->len = 0;
+}
+static inline char *vstr_str(vstr_t *vstr) {
+    return vstr->buf;
+}
+static inline size_t vstr_len(vstr_t *vstr) {
+    return vstr->len;
+}
 void vstr_hint_size(vstr_t *vstr, size_t size);
 char *vstr_extend(vstr_t *vstr, size_t size);
 char *vstr_add_len(vstr_t *vstr, size_t len);
@@ -191,10 +205,10 @@ void vstr_printf(vstr_t *vstr, const char *fmt, ...);
 #define CHECKBUF(buf, max_size) char buf[max_size + 1]; size_t buf##_len = max_size; char *buf##_p = buf;
 #define CHECKBUF_RESET(buf, max_size) buf##_len = max_size; buf##_p = buf;
 #define CHECKBUF_APPEND(buf, src, src_len) \
-        { size_t l = MIN(src_len, buf##_len); \
-        memcpy(buf##_p, src, l); \
-        buf##_len -= l; \
-        buf##_p += l; }
+    { size_t l = MIN(src_len, buf##_len); \
+      memcpy(buf##_p, src, l); \
+      buf##_len -= l; \
+      buf##_p += l; }
 #define CHECKBUF_APPEND_0(buf) { *buf##_p = 0; }
 #define CHECKBUF_LEN(buf) (buf##_p - buf)
 
@@ -210,14 +224,87 @@ extern mp_uint_t mp_verbose_flag;
 /** float internals *************/
 
 #if MICROPY_PY_BUILTINS_FLOAT
+
 #if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
 #define MP_FLOAT_EXP_BITS (11)
 #define MP_FLOAT_FRAC_BITS (52)
+typedef uint64_t mp_float_uint_t;
 #elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
 #define MP_FLOAT_EXP_BITS (8)
 #define MP_FLOAT_FRAC_BITS (23)
+typedef uint32_t mp_float_uint_t;
 #endif
+
 #define MP_FLOAT_EXP_BIAS ((1 << (MP_FLOAT_EXP_BITS - 1)) - 1)
+
+typedef union _mp_float_union_t {
+    mp_float_t f;
+    #if MP_ENDIANNESS_LITTLE
+    struct {
+        mp_float_uint_t frc : MP_FLOAT_FRAC_BITS;
+        mp_float_uint_t exp : MP_FLOAT_EXP_BITS;
+        mp_float_uint_t sgn : 1;
+    } p;
+    #else
+    struct {
+        mp_float_uint_t sgn : 1
+        mp_float_uint_t exp : MP_FLOAT_EXP_BITS;
+        mp_float_uint_t frc : MP_FLOAT_FRAC_BITS;
+    } p;
+    #endif
+    mp_float_uint_t i;
+} mp_float_union_t;
+
 #endif // MICROPY_PY_BUILTINS_FLOAT
 
+/** ROM string compression *************/
+
+#if MICROPY_ROM_TEXT_COMPRESSION
+
+#ifdef NO_QSTR
+
+// Compression enabled but doing QSTR extraction.
+// So leave MP_COMPRESSED_ROM_TEXT in place for makeqstrdefs.py / makecompresseddata.py to find them.
+
+#else
+
+// Compression enabled and doing a regular build.
+// Map MP_COMPRESSED_ROM_TEXT to the compressed strings.
+
+// Force usage of the MP_ERROR_TEXT macro by requiring an opaque type.
+typedef struct {} *mp_rom_error_text_t;
+
+#include <string.h>
+
+inline __attribute__((always_inline)) const char *MP_COMPRESSED_ROM_TEXT(const char *msg) {
+    // "genhdr/compressed.data.h" contains an invocation of the MP_MATCH_COMPRESSED macro for each compressed string.
+    // The giant if(strcmp) tree is optimized by the compiler, which turns this into a direct return of the compressed data.
+    #define MP_MATCH_COMPRESSED(a, b) if (strcmp(msg, a) == 0) { return b; } else
+
+    // It also contains a single invocation of the MP_COMPRESSED_DATA macro, we don't need that here.
+    #define MP_COMPRESSED_DATA(x)
+
+    #include "genhdr/compressed.data.h"
+
+#undef MP_COMPRESSED_DATA
+#undef MP_MATCH_COMPRESSED
+
+    return msg;
+}
+
+#endif
+
+#else
+
+// Compression not enabled, just make it a no-op.
+
+typedef const char *mp_rom_error_text_t;
+#define MP_COMPRESSED_ROM_TEXT(x) x
+
+#endif // MICROPY_ROM_TEXT_COMPRESSION
+
+// Might add more types of compressed text in the future.
+// For now, forward directly to MP_COMPRESSED_ROM_TEXT.
+#define MP_ERROR_TEXT(x) (mp_rom_error_text_t)MP_COMPRESSED_ROM_TEXT(x)
+
 #endif // MICROPY_INCLUDED_PY_MISC_H
diff --git a/py/mkenv.mk b/py/mkenv.mk
index 87e92ec6f9d6b..371d32046227d 100644
--- a/py/mkenv.mk
+++ b/py/mkenv.mk
@@ -42,26 +42,27 @@ ECHO = @echo
 CP = cp
 MKDIR = mkdir
 SED = sed
+CAT = cat
+TOUCH = touch
 PYTHON = python3
 
 AS = $(CROSS_COMPILE)as
 CC = $(CROSS_COMPILE)gcc
 CXX = $(CROSS_COMPILE)g++
+GDB = $(CROSS_COMPILE)gdb
 LD = $(CROSS_COMPILE)ld
 OBJCOPY = $(CROSS_COMPILE)objcopy
 SIZE = $(CROSS_COMPILE)size
 STRIP = $(CROSS_COMPILE)strip
 AR = $(CROSS_COMPILE)ar
-ifeq ($(MICROPY_FORCE_32BIT),1)
-CC += -m32
-CXX += -m32
-LD += -m32
-endif
 
+MAKE_MANIFEST = $(PYTHON) $(TOP)/tools/makemanifest.py
 MAKE_FROZEN = $(PYTHON) $(TOP)/tools/make-frozen.py
 MPY_CROSS = $(TOP)/mpy-cross/mpy-cross
 MPY_TOOL = $(PYTHON) $(TOP)/tools/mpy-tool.py
 
+MPY_LIB_DIR = $(TOP)/../micropython-lib
+
 all:
 .PHONY: all
 
diff --git a/py/mkrules.mk b/py/mkrules.mk
index caa9527c70bc6..c37c25db4bd2f 100644
--- a/py/mkrules.mk
+++ b/py/mkrules.mk
@@ -4,6 +4,22 @@ THIS_MAKEFILE = $(lastword $(MAKEFILE_LIST))
 include $(dir $(THIS_MAKEFILE))mkenv.mk
 endif
 
+# Extra deps that need to happen before object compilation.
+OBJ_EXTRA_ORDER_DEPS =
+
+ifeq ($(MICROPY_ROM_TEXT_COMPRESSION),1)
+# If compression is enabled, trigger the build of compressed.data.h...
+OBJ_EXTRA_ORDER_DEPS += $(HEADER_BUILD)/compressed.data.h
+# ...and enable the MP_COMPRESSED_ROM_TEXT macro (used by MP_ERROR_TEXT).
+CFLAGS += -DMICROPY_ROM_TEXT_COMPRESSION=1
+endif
+
+# QSTR generation uses the same CFLAGS, with these modifications.
+# Note: := to force evalulation immediately.
+QSTR_GEN_CFLAGS := $(CFLAGS)
+QSTR_GEN_CFLAGS += -DNO_QSTR
+QSTR_GEN_CFLAGS += -I$(BUILD)/tmp
+
 # This file expects that OBJ contains a list of all of the object files.
 # The directory portion of each object file is used to locate the source
 # and should not contain any ..'s but rather be relative to the top of the
@@ -46,14 +62,11 @@ vpath %.c . $(TOP) $(USER_C_MODULES)
 $(BUILD)/%.o: %.c
 	$(call compile_c)
 
-QSTR_GEN_EXTRA_CFLAGS += -DNO_QSTR
-QSTR_GEN_EXTRA_CFLAGS += -I$(BUILD)/tmp
-
 vpath %.c . $(TOP) $(USER_C_MODULES)
 
 $(BUILD)/%.pp: %.c
 	$(ECHO) "PreProcess $<"
-	$(Q)$(CC) $(CFLAGS) -E -Wp,-C,-dD,-dI -o $@ $<
+	$(Q)$(CPP) $(CFLAGS) -Wp,-C,-dD,-dI -o $@ $<
 
 # The following rule uses | to create an order only prerequisite. Order only
 # prerequisites only get built if they don't exist. They don't cause timestamp
@@ -64,24 +77,35 @@ $(BUILD)/%.pp: %.c
 # the right .o's to get recompiled if the generated.h file changes. Adding
 # an order-only dependency to all of the .o's will cause the generated .h
 # to get built before we try to compile any of them.
-$(OBJ): | $(HEADER_BUILD)/qstrdefs.generated.h $(HEADER_BUILD)/mpversion.h
+$(OBJ): | $(HEADER_BUILD)/qstrdefs.generated.h $(HEADER_BUILD)/mpversion.h $(OBJ_EXTRA_ORDER_DEPS)
 
 # The logic for qstr regeneration is:
 # - if anything in QSTR_GLOBAL_DEPENDENCIES is newer, then process all source files ($^)
 # - else, if list of newer prerequisites ($?) is not empty, then process just these ($?)
 # - else, process all source files ($^) [this covers "make -B" which can set $? to empty]
-$(HEADER_BUILD)/qstr.i.last: $(SRC_QSTR) $(QSTR_GLOBAL_DEPENDENCIES) | $(HEADER_BUILD)/mpversion.h
+# See more information about this process in docs/develop/qstr.rst.
+$(HEADER_BUILD)/qstr.i.last: $(SRC_QSTR) $(QSTR_GLOBAL_DEPENDENCIES) | $(QSTR_GLOBAL_REQUIREMENTS)
 	$(ECHO) "GEN $@"
-	$(Q)$(CPP) $(QSTR_GEN_EXTRA_CFLAGS) $(CFLAGS) $(if $(filter $?,$(QSTR_GLOBAL_DEPENDENCIES)),$^,$(if $?,$?,$^)) >$(HEADER_BUILD)/qstr.i.last;
+	$(Q)$(CPP) $(QSTR_GEN_CFLAGS) $(if $(filter $?,$(QSTR_GLOBAL_DEPENDENCIES)),$^,$(if $?,$?,$^)) >$(HEADER_BUILD)/qstr.i.last
 
 $(HEADER_BUILD)/qstr.split: $(HEADER_BUILD)/qstr.i.last
 	$(ECHO) "GEN $@"
-	$(Q)$(PYTHON) $(PY_SRC)/makeqstrdefs.py split $(HEADER_BUILD)/qstr.i.last $(HEADER_BUILD)/qstr $(QSTR_DEFS_COLLECTED)
-	$(Q)touch $@
+	$(Q)$(PYTHON) $(PY_SRC)/makeqstrdefs.py split qstr $< $(HEADER_BUILD)/qstr _
+	$(Q)$(TOUCH) $@
 
 $(QSTR_DEFS_COLLECTED): $(HEADER_BUILD)/qstr.split
 	$(ECHO) "GEN $@"
-	$(Q)$(PYTHON) $(PY_SRC)/makeqstrdefs.py cat $(HEADER_BUILD)/qstr.i.last $(HEADER_BUILD)/qstr $(QSTR_DEFS_COLLECTED)
+	$(Q)$(PYTHON) $(PY_SRC)/makeqstrdefs.py cat qstr _ $(HEADER_BUILD)/qstr $@
+
+# Compressed error strings.
+$(HEADER_BUILD)/compressed.split: $(HEADER_BUILD)/qstr.i.last
+	$(ECHO) "GEN $@"
+	$(Q)$(PYTHON) $(PY_SRC)/makeqstrdefs.py split compress $< $(HEADER_BUILD)/compress _
+	$(Q)$(TOUCH) $@
+
+$(HEADER_BUILD)/compressed.collected: $(HEADER_BUILD)/compressed.split
+	$(ECHO) "GEN $@"
+	$(Q)$(PYTHON) $(PY_SRC)/makeqstrdefs.py cat compress _ $(HEADER_BUILD)/compress $@
 
 # $(sort $(var)) removes duplicates
 #
@@ -96,23 +120,35 @@ $(OBJ_DIRS):
 $(HEADER_BUILD):
 	$(MKDIR) -p $@
 
+ifneq ($(FROZEN_MANIFEST),)
+# to build frozen_content.c from a manifest
+$(BUILD)/frozen_content.c: FORCE $(BUILD)/genhdr/qstrdefs.generated.h
+	$(Q)$(MAKE_MANIFEST) -o $@ -v "MPY_DIR=$(TOP)" -v "MPY_LIB_DIR=$(MPY_LIB_DIR)" -v "PORT_DIR=$(shell pwd)" -v "BOARD_DIR=$(BOARD_DIR)" -b "$(BUILD)" $(if $(MPY_CROSS_FLAGS),-f"$(MPY_CROSS_FLAGS)",) $(FROZEN_MANIFEST)
+
 ifneq ($(FROZEN_DIR),)
+$(error FROZEN_DIR cannot be used in conjunction with FROZEN_MANIFEST)
+endif
+
+ifneq ($(FROZEN_MPY_DIR),)
+$(error FROZEN_MPY_DIR cannot be used in conjunction with FROZEN_MANIFEST)
+endif
+endif
+
+ifneq ($(FROZEN_DIR),)
+$(info Warning: FROZEN_DIR is deprecated in favour of FROZEN_MANIFEST)
 $(BUILD)/frozen.c: $(wildcard $(FROZEN_DIR)/*) $(HEADER_BUILD) $(FROZEN_EXTRA_DEPS)
 	$(ECHO) "GEN $@"
 	$(Q)$(MAKE_FROZEN) $(FROZEN_DIR) > $@
 endif
 
 ifneq ($(FROZEN_MPY_DIR),)
-# to build the MicroPython cross compiler
-$(TOP)/mpy-cross/mpy-cross: $(TOP)/py/*.[ch] $(TOP)/mpy-cross/*.[ch] $(TOP)/ports/windows/fmode.c
-	$(Q)$(MAKE) -C $(TOP)/mpy-cross
-
+$(info Warning: FROZEN_MPY_DIR is deprecated in favour of FROZEN_MANIFEST)
 # make a list of all the .py files that need compiling and freezing
 FROZEN_MPY_PY_FILES := $(shell find -L $(FROZEN_MPY_DIR) -type f -name '*.py' | $(SED) -e 's=^$(FROZEN_MPY_DIR)/==')
 FROZEN_MPY_MPY_FILES := $(addprefix $(BUILD)/frozen_mpy/,$(FROZEN_MPY_PY_FILES:.py=.mpy))
 
 # to build .mpy files from .py files
-$(BUILD)/frozen_mpy/%.mpy: $(FROZEN_MPY_DIR)/%.py $(TOP)/mpy-cross/mpy-cross
+$(BUILD)/frozen_mpy/%.mpy: $(FROZEN_MPY_DIR)/%.py
 	@$(ECHO) "MPY $<"
 	$(Q)$(MKDIR) -p $(dir $@)
 	$(Q)$(MPY_CROSS) -o $@ -s $(<:$(FROZEN_MPY_DIR)/%=%) $(MPY_CROSS_FLAGS) $<
@@ -146,6 +182,13 @@ clean-prog:
 .PHONY: clean-prog
 endif
 
+submodules:
+	$(ECHO) "Updating submodules: $(GIT_SUBMODULES)"
+ifneq ($(GIT_SUBMODULES),)
+	$(Q)git submodule update --init $(addprefix $(TOP)/,$(GIT_SUBMODULES))
+endif
+.PHONY: submodules
+
 LIBMICROPYTHON = libmicropython.a
 
 # We can execute extra commands after library creation using
@@ -190,7 +233,7 @@ print-cfg:
 
 print-def:
 	@$(ECHO) "The following defines are built into the $(CC) compiler"
-	touch __empty__.c
+	$(TOUCH) __empty__.c
 	@$(CC) -E -Wp,-dM __empty__.c
 	@$(RM) -f __empty__.c
 
diff --git a/py/modarray.c b/py/modarray.c
index de84fc85871af..9ab1795f8b883 100644
--- a/py/modarray.c
+++ b/py/modarray.c
@@ -29,17 +29,17 @@
 #if MICROPY_PY_ARRAY
 
 STATIC const mp_rom_map_elem_t mp_module_array_globals_table[] = {
-    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_array) },
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_uarray) },
     { MP_ROM_QSTR(MP_QSTR_array), MP_ROM_PTR(&mp_type_array) },
 };
 
 STATIC MP_DEFINE_CONST_DICT(mp_module_array_globals, mp_module_array_globals_table);
 
-const mp_obj_module_t mp_module_array = {
+const mp_obj_module_t mp_module_uarray = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_array_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_array_globals,
 };
 
-MP_REGISTER_MODULE(MP_QSTR_array, mp_module_array, MICROPY_PY_ARRAY);
+MP_REGISTER_MODULE(MP_QSTR_uarray, mp_module_uarray, MICROPY_PY_ARRAY);
 
 #endif
diff --git a/py/modbuiltins.c b/py/modbuiltins.c
index a65f3beecfa8b..85d30ab66d052 100644
--- a/py/modbuiltins.c
+++ b/py/modbuiltins.c
@@ -140,7 +140,8 @@ STATIC mp_obj_t mp_builtin_chr(mp_obj_t o_in) {
     uint8_t str[4];
     int len = 0;
     if (c < 0x80) {
-        *str = c; len = 1;
+        *str = c;
+        len = 1;
     } else if (c < 0x800) {
         str[0] = (c >> 6) | 0xC0;
         str[1] = (c & 0x3F) | 0x80;
@@ -157,16 +158,16 @@ STATIC mp_obj_t mp_builtin_chr(mp_obj_t o_in) {
         str[3] = (c & 0x3F) | 0x80;
         len = 4;
     } else {
-        mp_raise_ValueError("chr() arg not in range(0x110000)");
+        mp_raise_ValueError(MP_ERROR_TEXT("chr() arg not in range(0x110000)"));
     }
-    return mp_obj_new_str_via_qstr((char*)str, len);
+    return mp_obj_new_str_via_qstr((char *)str, len);
     #else
     mp_int_t ord = mp_obj_get_int(o_in);
     if (0 <= ord && ord <= 0xff) {
         uint8_t str[1] = {ord};
-        return mp_obj_new_str_via_qstr((char*)str, 1);
+        return mp_obj_new_str_via_qstr((char *)str, 1);
     } else {
-        mp_raise_ValueError("chr() arg not in range(256)");
+        mp_raise_ValueError(MP_ERROR_TEXT("chr() arg not in range(256)"));
     }
     #endif
 }
@@ -244,10 +245,10 @@ STATIC mp_obj_t mp_builtin_input(size_t n_args, const mp_obj_t *args) {
     vstr_init(&line, 16);
     int ret = mp_hal_readline(&line, "");
     if (ret == CHAR_CTRL_C) {
-        nlr_raise(mp_obj_new_exception(&mp_type_KeyboardInterrupt));
+        mp_raise_type(&mp_type_KeyboardInterrupt);
     }
     if (line.len == 0 && ret == CHAR_CTRL_D) {
-        nlr_raise(mp_obj_new_exception(&mp_type_EOFError));
+        mp_raise_type(&mp_type_EOFError);
     }
     return mp_obj_new_str_from_vstr(&mp_type_str, &line);
 }
@@ -285,7 +286,7 @@ STATIC mp_obj_t mp_builtin_min_max(size_t n_args, const mp_obj_t *args, mp_map_t
             if (default_elem != NULL) {
                 best_obj = default_elem->value;
             } else {
-                mp_raise_ValueError("arg is an empty sequence");
+                mp_raise_ValueError(MP_ERROR_TEXT("arg is an empty sequence"));
             }
         }
         return best_obj;
@@ -321,7 +322,7 @@ STATIC mp_obj_t mp_builtin_next(size_t n_args, const mp_obj_t *args) {
     if (n_args == 1) {
         mp_obj_t ret = mp_iternext_allow_raise(args[0]);
         if (ret == MP_OBJ_STOP_ITERATION) {
-            nlr_raise(mp_obj_new_exception(&mp_type_StopIteration));
+            mp_raise_type(&mp_type_StopIteration);
         } else {
             return ret;
         }
@@ -335,7 +336,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_next_obj, 1, 2, mp_builtin_next);
 STATIC mp_obj_t mp_builtin_next(mp_obj_t o) {
     mp_obj_t ret = mp_iternext_allow_raise(o);
     if (ret == MP_OBJ_STOP_ITERATION) {
-        nlr_raise(mp_obj_new_exception(&mp_type_StopIteration));
+        mp_raise_type(&mp_type_StopIteration);
     } else {
         return ret;
     }
@@ -355,7 +356,7 @@ MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_oct_obj, mp_builtin_oct);
 
 STATIC mp_obj_t mp_builtin_ord(mp_obj_t o_in) {
     size_t len;
-    const byte *str = (const byte*)mp_obj_str_get_data(o_in, &len);
+    const byte *str = (const byte *)mp_obj_str_get_data(o_in, &len);
     #if MICROPY_PY_BUILTINS_STR_UNICODE
     if (mp_obj_is_str(o_in)) {
         len = utf8_charlen(str, len);
@@ -371,26 +372,27 @@ STATIC mp_obj_t mp_builtin_ord(mp_obj_t o_in) {
         }
     }
 
-    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-        mp_raise_TypeError("ord expects a character");
-    } else {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-            "ord() expected a character, but string of length %d found", (int)len));
-    }
+    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+    mp_raise_TypeError(MP_ERROR_TEXT("ord expects a character"));
+    #else
+    mp_raise_msg_varg(&mp_type_TypeError,
+        MP_ERROR_TEXT("ord() expected a character, but string of length %d found"), (int)len);
+    #endif
 }
 MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_ord_obj, mp_builtin_ord);
 
 STATIC mp_obj_t mp_builtin_pow(size_t n_args, const mp_obj_t *args) {
     switch (n_args) {
-        case 2: return mp_binary_op(MP_BINARY_OP_POWER, args[0], args[1]);
+        case 2:
+            return mp_binary_op(MP_BINARY_OP_POWER, args[0], args[1]);
         default:
-#if !MICROPY_PY_BUILTINS_POW3
-            mp_raise_msg(&mp_type_NotImplementedError, "3-arg pow() not supported");
-#elif MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_MPZ
+            #if !MICROPY_PY_BUILTINS_POW3
+            mp_raise_NotImplementedError(MP_ERROR_TEXT("3-arg pow() not supported"));
+            #elif MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_MPZ
             return mp_binary_op(MP_BINARY_OP_MODULO, mp_binary_op(MP_BINARY_OP_POWER, args[0], args[1]), args[2]);
-#else
+            #else
             return mp_obj_int_pow3(args[0], args[1], args[2]);
-#endif
+            #endif
     }
 }
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_pow_obj, 2, 3, mp_builtin_pow);
@@ -485,7 +487,7 @@ STATIC mp_obj_t mp_builtin_round(size_t n_args, const mp_obj_t *args) {
         }
 
         mp_obj_t mult = mp_binary_op(MP_BINARY_OP_POWER, MP_OBJ_NEW_SMALL_INT(10), MP_OBJ_NEW_SMALL_INT(-num_dig));
-        mp_obj_t half_mult =  mp_binary_op(MP_BINARY_OP_FLOOR_DIVIDE, mult, MP_OBJ_NEW_SMALL_INT(2));
+        mp_obj_t half_mult = mp_binary_op(MP_BINARY_OP_FLOOR_DIVIDE, mult, MP_OBJ_NEW_SMALL_INT(2));
         mp_obj_t modulo = mp_binary_op(MP_BINARY_OP_MODULO, o_in, mult);
         mp_obj_t rounded = mp_binary_op(MP_BINARY_OP_SUBTRACT, o_in, modulo);
         if (mp_obj_is_true(mp_binary_op(MP_BINARY_OP_MORE, half_mult, modulo))) {
@@ -503,29 +505,33 @@ STATIC mp_obj_t mp_builtin_round(size_t n_args, const mp_obj_t *args) {
         }
         #endif
     }
-#if MICROPY_PY_BUILTINS_FLOAT
+    #if MICROPY_PY_BUILTINS_FLOAT
     mp_float_t val = mp_obj_get_float(o_in);
     if (n_args > 1) {
         mp_int_t num_dig = mp_obj_get_int(args[1]);
-        mp_float_t mult = MICROPY_FLOAT_C_FUN(pow)(10, num_dig);
+        mp_float_t mult = MICROPY_FLOAT_C_FUN(pow)(10, (mp_float_t)num_dig);
         // TODO may lead to overflow
         mp_float_t rounded = MICROPY_FLOAT_C_FUN(nearbyint)(val * mult) / mult;
         return mp_obj_new_float(rounded);
     }
     mp_float_t rounded = MICROPY_FLOAT_C_FUN(nearbyint)(val);
     return mp_obj_new_int_from_float(rounded);
-#else
+    #else
     mp_int_t r = mp_obj_get_int(o_in);
     return mp_obj_new_int(r);
-#endif
+    #endif
 }
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_round_obj, 1, 2, mp_builtin_round);
 
 STATIC mp_obj_t mp_builtin_sum(size_t n_args, const mp_obj_t *args) {
     mp_obj_t value;
     switch (n_args) {
-        case 1: value = MP_OBJ_NEW_SMALL_INT(0); break;
-        default: value = args[1]; break;
+        case 1:
+            value = MP_OBJ_NEW_SMALL_INT(0);
+            break;
+        default:
+            value = args[1];
+            break;
     }
     mp_obj_iter_buf_t iter_buf;
     mp_obj_t iterable = mp_getiter(args[0], &iter_buf);
@@ -539,7 +545,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_sum_obj, 1, 2, mp_builtin_sum);
 
 STATIC mp_obj_t mp_builtin_sorted(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
     if (n_args > 1) {
-        mp_raise_TypeError("must use keyword argument for key function");
+        mp_raise_TypeError(MP_ERROR_TEXT("must use keyword argument for key function"));
     }
     mp_obj_t self = mp_type_list.make_new(&mp_type_list, 1, 0, args);
     mp_obj_list_sort(1, &self, kwargs);
@@ -762,8 +768,6 @@ STATIC const mp_rom_map_elem_t mp_module_builtins_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_ViperTypeError), MP_ROM_PTR(&mp_type_ViperTypeError) },
     #endif
     { MP_ROM_QSTR(MP_QSTR_ZeroDivisionError), MP_ROM_PTR(&mp_type_ZeroDivisionError) },
-    // Somehow CPython managed to have OverflowError not inherit from ValueError ;-/
-    // TODO: For MICROPY_CPYTHON_COMPAT==0 use ValueError to avoid exc proliferation
 
     // Extra builtins as defined by a port
     MICROPY_PORT_BUILTINS
@@ -773,5 +777,5 @@ MP_DEFINE_CONST_DICT(mp_module_builtins_globals, mp_module_builtins_globals_tabl
 
 const mp_obj_module_t mp_module_builtins = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_builtins_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_builtins_globals,
 };
diff --git a/py/modcmath.c b/py/modcmath.c
index 70fd542af9ec0..fb1f2a8fc267d 100644
--- a/py/modcmath.c
+++ b/py/modcmath.c
@@ -43,7 +43,7 @@ STATIC mp_obj_t mp_cmath_polar(mp_obj_t z_obj) {
     mp_float_t real, imag;
     mp_obj_get_complex(z_obj, &real, &imag);
     mp_obj_t tuple[2] = {
-        mp_obj_new_float(MICROPY_FLOAT_C_FUN(sqrt)(real*real + imag*imag)),
+        mp_obj_new_float(MICROPY_FLOAT_C_FUN(sqrt)(real * real + imag * imag)),
         mp_obj_new_float(MICROPY_FLOAT_C_FUN(atan2)(imag, real)),
     };
     return mp_obj_new_tuple(2, tuple);
@@ -72,7 +72,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_cmath_exp_obj, mp_cmath_exp);
 STATIC mp_obj_t mp_cmath_log(mp_obj_t z_obj) {
     mp_float_t real, imag;
     mp_obj_get_complex(z_obj, &real, &imag);
-    return mp_obj_new_complex(0.5 * MICROPY_FLOAT_C_FUN(log)(real*real + imag*imag), MICROPY_FLOAT_C_FUN(atan2)(imag, real));
+    return mp_obj_new_complex(MICROPY_FLOAT_CONST(0.5) * MICROPY_FLOAT_C_FUN(log)(real * real + imag * imag), MICROPY_FLOAT_C_FUN(atan2)(imag, real));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_cmath_log_obj, mp_cmath_log);
 
@@ -81,7 +81,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_cmath_log_obj, mp_cmath_log);
 STATIC mp_obj_t mp_cmath_log10(mp_obj_t z_obj) {
     mp_float_t real, imag;
     mp_obj_get_complex(z_obj, &real, &imag);
-    return mp_obj_new_complex(0.5 * MICROPY_FLOAT_C_FUN(log10)(real*real + imag*imag), 0.4342944819032518 * MICROPY_FLOAT_C_FUN(atan2)(imag, real));
+    return mp_obj_new_complex(MICROPY_FLOAT_CONST(0.5) * MICROPY_FLOAT_C_FUN(log10)(real * real + imag * imag), MICROPY_FLOAT_CONST(0.4342944819032518) * MICROPY_FLOAT_C_FUN(atan2)(imag, real));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_cmath_log10_obj, mp_cmath_log10);
 #endif
@@ -90,8 +90,8 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_cmath_log10_obj, mp_cmath_log10);
 STATIC mp_obj_t mp_cmath_sqrt(mp_obj_t z_obj) {
     mp_float_t real, imag;
     mp_obj_get_complex(z_obj, &real, &imag);
-    mp_float_t sqrt_abs = MICROPY_FLOAT_C_FUN(pow)(real*real + imag*imag, 0.25);
-    mp_float_t theta = 0.5 * MICROPY_FLOAT_C_FUN(atan2)(imag, real);
+    mp_float_t sqrt_abs = MICROPY_FLOAT_C_FUN(pow)(real * real + imag * imag, MICROPY_FLOAT_CONST(0.25));
+    mp_float_t theta = MICROPY_FLOAT_CONST(0.5) * MICROPY_FLOAT_C_FUN(atan2)(imag, real);
     return mp_obj_new_complex(sqrt_abs * MICROPY_FLOAT_C_FUN(cos)(theta), sqrt_abs * MICROPY_FLOAT_C_FUN(sin)(theta));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_cmath_sqrt_obj, mp_cmath_sqrt);
@@ -125,28 +125,28 @@ STATIC const mp_rom_map_elem_t mp_module_cmath_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_log10), MP_ROM_PTR(&mp_cmath_log10_obj) },
     #endif
     { MP_ROM_QSTR(MP_QSTR_sqrt), MP_ROM_PTR(&mp_cmath_sqrt_obj) },
-    //{ MP_ROM_QSTR(MP_QSTR_acos), MP_ROM_PTR(&mp_cmath_acos_obj) },
-    //{ MP_ROM_QSTR(MP_QSTR_asin), MP_ROM_PTR(&mp_cmath_asin_obj) },
-    //{ MP_ROM_QSTR(MP_QSTR_atan), MP_ROM_PTR(&mp_cmath_atan_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_acos), MP_ROM_PTR(&mp_cmath_acos_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_asin), MP_ROM_PTR(&mp_cmath_asin_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_atan), MP_ROM_PTR(&mp_cmath_atan_obj) },
     { MP_ROM_QSTR(MP_QSTR_cos), MP_ROM_PTR(&mp_cmath_cos_obj) },
     { MP_ROM_QSTR(MP_QSTR_sin), MP_ROM_PTR(&mp_cmath_sin_obj) },
-    //{ MP_ROM_QSTR(MP_QSTR_tan), MP_ROM_PTR(&mp_cmath_tan_obj) },
-    //{ MP_ROM_QSTR(MP_QSTR_acosh), MP_ROM_PTR(&mp_cmath_acosh_obj) },
-    //{ MP_ROM_QSTR(MP_QSTR_asinh), MP_ROM_PTR(&mp_cmath_asinh_obj) },
-    //{ MP_ROM_QSTR(MP_QSTR_atanh), MP_ROM_PTR(&mp_cmath_atanh_obj) },
-    //{ MP_ROM_QSTR(MP_QSTR_cosh), MP_ROM_PTR(&mp_cmath_cosh_obj) },
-    //{ MP_ROM_QSTR(MP_QSTR_sinh), MP_ROM_PTR(&mp_cmath_sinh_obj) },
-    //{ MP_ROM_QSTR(MP_QSTR_tanh), MP_ROM_PTR(&mp_cmath_tanh_obj) },
-    //{ MP_ROM_QSTR(MP_QSTR_isfinite), MP_ROM_PTR(&mp_cmath_isfinite_obj) },
-    //{ MP_ROM_QSTR(MP_QSTR_isinf), MP_ROM_PTR(&mp_cmath_isinf_obj) },
-    //{ MP_ROM_QSTR(MP_QSTR_isnan), MP_ROM_PTR(&mp_cmath_isnan_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_tan), MP_ROM_PTR(&mp_cmath_tan_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_acosh), MP_ROM_PTR(&mp_cmath_acosh_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_asinh), MP_ROM_PTR(&mp_cmath_asinh_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_atanh), MP_ROM_PTR(&mp_cmath_atanh_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_cosh), MP_ROM_PTR(&mp_cmath_cosh_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_sinh), MP_ROM_PTR(&mp_cmath_sinh_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_tanh), MP_ROM_PTR(&mp_cmath_tanh_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_isfinite), MP_ROM_PTR(&mp_cmath_isfinite_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_isinf), MP_ROM_PTR(&mp_cmath_isinf_obj) },
+    // { MP_ROM_QSTR(MP_QSTR_isnan), MP_ROM_PTR(&mp_cmath_isnan_obj) },
 };
 
 STATIC MP_DEFINE_CONST_DICT(mp_module_cmath_globals, mp_module_cmath_globals_table);
 
 const mp_obj_module_t mp_module_cmath = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_cmath_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_cmath_globals,
 };
 
 #endif // MICROPY_PY_BUILTINS_FLOAT && MICROPY_PY_CMATH
diff --git a/py/modcollections.c b/py/modcollections.c
index bb6488471c76d..c145f12cc6e16 100644
--- a/py/modcollections.c
+++ b/py/modcollections.c
@@ -43,7 +43,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_collections_globals, mp_module_collections
 
 const mp_obj_module_t mp_module_collections = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_collections_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_collections_globals,
 };
 
 #endif // MICROPY_PY_COLLECTIONS
diff --git a/py/modgc.c b/py/modgc.c
index 55e73defcee5c..534a711c16ee5 100644
--- a/py/modgc.c
+++ b/py/modgc.c
@@ -33,11 +33,11 @@
 // collect(): run a garbage collection
 STATIC mp_obj_t py_gc_collect(void) {
     gc_collect();
-#if MICROPY_PY_GC_COLLECT_RETVAL
+    #if MICROPY_PY_GC_COLLECT_RETVAL
     return MP_OBJ_NEW_SMALL_INT(MP_STATE_MEM(gc_collected));
-#else
+    #else
     return mp_const_none;
-#endif
+    #endif
 }
 MP_DEFINE_CONST_FUN_OBJ_0(gc_collect_obj, py_gc_collect);
 
@@ -112,7 +112,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_gc_globals, mp_module_gc_globals_table);
 
 const mp_obj_module_t mp_module_gc = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_gc_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_gc_globals,
 };
 
 #endif
diff --git a/py/modio.c b/py/modio.c
index 0f4a4326ca257..8a18357e24f12 100644
--- a/py/modio.c
+++ b/py/modio.c
@@ -59,12 +59,17 @@ STATIC mp_uint_t iobase_read_write(mp_obj_t obj, void *buf, mp_uint_t size, int
     mp_load_method(obj, qst, dest);
     mp_obj_array_t ar = {{&mp_type_bytearray}, BYTEARRAY_TYPECODE, 0, size, buf};
     dest[2] = MP_OBJ_FROM_PTR(&ar);
-    mp_obj_t ret = mp_call_method_n_kw(1, 0, dest);
-    if (ret == mp_const_none) {
+    mp_obj_t ret_obj = mp_call_method_n_kw(1, 0, dest);
+    if (ret_obj == mp_const_none) {
         *errcode = MP_EAGAIN;
         return MP_STREAM_ERROR;
+    }
+    mp_int_t ret = mp_obj_get_int(ret_obj);
+    if (ret >= 0) {
+        return ret;
     } else {
-        return mp_obj_get_int(ret);
+        *errcode = -ret;
+        return MP_STREAM_ERROR;
     }
 }
 STATIC mp_uint_t iobase_read(mp_obj_t obj, void *buf, mp_uint_t size, int *errcode) {
@@ -72,7 +77,7 @@ STATIC mp_uint_t iobase_read(mp_obj_t obj, void *buf, mp_uint_t size, int *errco
 }
 
 STATIC mp_uint_t iobase_write(mp_obj_t obj, const void *buf, mp_uint_t size, int *errcode) {
-    return iobase_read_write(obj, (void*)buf, size, errcode, MP_QSTR_write);
+    return iobase_read_write(obj, (void *)buf, size, errcode, MP_QSTR_write);
 }
 
 STATIC mp_uint_t iobase_ioctl(mp_obj_t obj, mp_uint_t request, uintptr_t arg, int *errcode) {
@@ -144,7 +149,7 @@ STATIC mp_uint_t bufwriter_write(mp_obj_t self_in, const void *buf, mp_uint_t si
         // is word-aligned, to guard against obscure cases when it matters, e.g.
         // https://github.com/micropython/micropython/issues/1863
         memcpy(self->buf + self->len, buf, rem);
-        buf = (byte*)buf + rem;
+        buf = (byte *)buf + rem;
         size -= rem;
         mp_uint_t out_sz = mp_stream_write_exactly(self->stream, self->buf, self->alloc, errcode);
         (void)out_sz;
@@ -195,7 +200,7 @@ STATIC const mp_obj_type_t bufwriter_type = {
     .name = MP_QSTR_BufferedWriter,
     .make_new = bufwriter_make_new,
     .protocol = &bufwriter_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&bufwriter_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&bufwriter_locals_dict,
 };
 #endif // MICROPY_PY_IO_BUFFEREDWRITER
 
@@ -208,15 +213,8 @@ STATIC mp_obj_t resource_stream(mp_obj_t package_in, mp_obj_t path_in) {
     // package parameter being None, the path_in is interpreted as a
     // raw path.
     if (package_in != mp_const_none) {
-        mp_obj_t args[5];
-        args[0] = package_in;
-        args[1] = mp_const_none; // TODO should be globals
-        args[2] = mp_const_none; // TODO should be locals
-        args[3] = mp_const_true; // Pass sentinel "non empty" value to force returning of leaf module
-        args[4] = MP_OBJ_NEW_SMALL_INT(0);
-
-        // TODO lookup __import__ and call that instead of going straight to builtin implementation
-        mp_obj_t pkg = mp_builtin___import__(5, args);
+        // Pass "True" as sentinel value in fromlist to force returning of leaf module
+        mp_obj_t pkg = mp_import_name(mp_obj_str_get_qstr(package_in), mp_const_true, MP_OBJ_NEW_SMALL_INT(0));
 
         mp_obj_t dest[2];
         mp_load_method_maybe(pkg, MP_QSTR___path__, dest);
@@ -238,14 +236,14 @@ STATIC mp_obj_t resource_stream(mp_obj_t package_in, mp_obj_t path_in) {
         mp_obj_stringio_t *o = m_new_obj(mp_obj_stringio_t);
         o->base.type = &mp_type_bytesio;
         o->vstr = m_new_obj(vstr_t);
-        vstr_init_fixed_buf(o->vstr, len + 1, (char*)data);
+        vstr_init_fixed_buf(o->vstr, len + 1, (char *)data);
         o->vstr->len = len;
         o->pos = 0;
         return MP_OBJ_FROM_PTR(o);
     }
 
     mp_obj_t path_out = mp_obj_new_str(path_buf.buf, path_buf.len);
-    return mp_builtin_open(1, &path_out, (mp_map_t*)&mp_const_empty_map);
+    return mp_builtin_open(1, &path_out, (mp_map_t *)&mp_const_empty_map);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(resource_stream_obj, resource_stream);
 #endif
@@ -280,7 +278,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_io_globals, mp_module_io_globals_table);
 
 const mp_obj_module_t mp_module_io = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_io_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_io_globals,
 };
 
 #endif
diff --git a/py/modmath.c b/py/modmath.c
index d106f240c8760..b312eeb3d2c01 100644
--- a/py/modmath.c
+++ b/py/modmath.c
@@ -34,9 +34,11 @@
 // M_PI is not part of the math.h standard and may not be defined
 // And by defining our own we can ensure it uses the correct const format.
 #define MP_PI MICROPY_FLOAT_CONST(3.14159265358979323846)
+#define MP_PI_4 MICROPY_FLOAT_CONST(0.78539816339744830962)
+#define MP_3_PI_4 MICROPY_FLOAT_CONST(2.35619449019234492885)
 
 STATIC NORETURN void math_error(void) {
-    mp_raise_ValueError("math domain error");
+    mp_raise_ValueError(MP_ERROR_TEXT("math domain error"));
 }
 
 STATIC mp_obj_t math_generic_1(mp_obj_t x_obj, mp_float_t (*f)(mp_float_t)) {
@@ -59,30 +61,30 @@ STATIC mp_obj_t math_generic_2(mp_obj_t x_obj, mp_obj_t y_obj, mp_float_t (*f)(m
 }
 
 #define MATH_FUN_1(py_name, c_name) \
-    STATIC mp_obj_t mp_math_ ## py_name(mp_obj_t x_obj) { \
+    STATIC mp_obj_t mp_math_##py_name(mp_obj_t x_obj) { \
         return math_generic_1(x_obj, MICROPY_FLOAT_C_FUN(c_name)); \
     } \
-    STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_math_## py_name ## _obj, mp_math_ ## py_name);
+    STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_math_##py_name##_obj, mp_math_##py_name);
 
 #define MATH_FUN_1_TO_BOOL(py_name, c_name) \
-    STATIC mp_obj_t mp_math_ ## py_name(mp_obj_t x_obj) { return mp_obj_new_bool(c_name(mp_obj_get_float(x_obj))); } \
-    STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_math_## py_name ## _obj, mp_math_ ## py_name);
+    STATIC mp_obj_t mp_math_##py_name(mp_obj_t x_obj) { return mp_obj_new_bool(c_name(mp_obj_get_float(x_obj))); } \
+    STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_math_##py_name##_obj, mp_math_##py_name);
 
 #define MATH_FUN_1_TO_INT(py_name, c_name) \
-    STATIC mp_obj_t mp_math_ ## py_name(mp_obj_t x_obj) { return mp_obj_new_int_from_float(MICROPY_FLOAT_C_FUN(c_name)(mp_obj_get_float(x_obj))); } \
-    STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_math_## py_name ## _obj, mp_math_ ## py_name);
+    STATIC mp_obj_t mp_math_##py_name(mp_obj_t x_obj) { return mp_obj_new_int_from_float(MICROPY_FLOAT_C_FUN(c_name)(mp_obj_get_float(x_obj))); } \
+    STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_math_##py_name##_obj, mp_math_##py_name);
 
 #define MATH_FUN_2(py_name, c_name) \
-    STATIC mp_obj_t mp_math_ ## py_name(mp_obj_t x_obj, mp_obj_t y_obj) { \
+    STATIC mp_obj_t mp_math_##py_name(mp_obj_t x_obj, mp_obj_t y_obj) { \
         return math_generic_2(x_obj, y_obj, MICROPY_FLOAT_C_FUN(c_name)); \
     } \
-    STATIC MP_DEFINE_CONST_FUN_OBJ_2(mp_math_## py_name ## _obj, mp_math_ ## py_name);
+    STATIC MP_DEFINE_CONST_FUN_OBJ_2(mp_math_##py_name##_obj, mp_math_##py_name);
 
 #define MATH_FUN_2_FLT_INT(py_name, c_name) \
-    STATIC mp_obj_t mp_math_ ## py_name(mp_obj_t x_obj, mp_obj_t y_obj) { \
+    STATIC mp_obj_t mp_math_##py_name(mp_obj_t x_obj, mp_obj_t y_obj) { \
         return mp_obj_new_float(MICROPY_FLOAT_C_FUN(c_name)(mp_obj_get_float(x_obj), mp_obj_get_int(y_obj))); \
     } \
-    STATIC MP_DEFINE_CONST_FUN_OBJ_2(mp_math_## py_name ## _obj, mp_math_ ## py_name);
+    STATIC MP_DEFINE_CONST_FUN_OBJ_2(mp_math_##py_name##_obj, mp_math_##py_name);
 
 #if MP_NEED_LOG2
 #undef log2
@@ -132,7 +134,17 @@ MATH_FUN_1(asin, asin)
 // atan(x)
 MATH_FUN_1(atan, atan)
 // atan2(y, x)
+#if MICROPY_PY_MATH_ATAN2_FIX_INFNAN
+mp_float_t atan2_func(mp_float_t x, mp_float_t y) {
+    if (isinf(x) && isinf(y)) {
+        return copysign(y < 0 ? MP_3_PI_4 : MP_PI_4, x);
+    }
+    return atan2(x, y);
+}
+MATH_FUN_2(atan2, atan2_func)
+#else
 MATH_FUN_2(atan2, atan2)
+#endif
 // ceil(x)
 MATH_FUN_1_TO_INT(ceil, ceil)
 // copysign(x, y)
@@ -146,9 +158,16 @@ STATIC mp_float_t MICROPY_FLOAT_C_FUN(fabs_func)(mp_float_t x) {
 }
 MATH_FUN_1(fabs, fabs_func)
 // floor(x)
-MATH_FUN_1_TO_INT(floor, floor) //TODO: delegate to x.__floor__() if x is not a float
+MATH_FUN_1_TO_INT(floor, floor) // TODO: delegate to x.__floor__() if x is not a float
 // fmod(x, y)
+#if MICROPY_PY_MATH_FMOD_FIX_INFNAN
+mp_float_t fmod_func(mp_float_t x, mp_float_t y) {
+    return (!isinf(x) && isinf(y)) ? x : fmod(x, y);
+}
+MATH_FUN_2(fmod, fmod_func)
+#else
 MATH_FUN_2(fmod, fmod)
+#endif
 // isfinite(x)
 MATH_FUN_1_TO_BOOL(isfinite, isfinite)
 // isinf(x)
@@ -169,7 +188,43 @@ MATH_FUN_1(gamma, tgamma)
 // lgamma(x): return the natural logarithm of the gamma function of x
 MATH_FUN_1(lgamma, lgamma)
 #endif
-//TODO: fsum
+// TODO: fsum
+
+#if MICROPY_PY_MATH_ISCLOSE
+STATIC mp_obj_t mp_math_isclose(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_a, ARG_b, ARG_rel_tol, ARG_abs_tol };
+    static const mp_arg_t allowed_args[] = {
+        {MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ},
+        {MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ},
+        {MP_QSTR_rel_tol, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL}},
+        {MP_QSTR_abs_tol, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NEW_SMALL_INT(0)}},
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    const mp_float_t a = mp_obj_get_float(args[ARG_a].u_obj);
+    const mp_float_t b = mp_obj_get_float(args[ARG_b].u_obj);
+    const mp_float_t rel_tol = args[ARG_rel_tol].u_obj == MP_OBJ_NULL
+        ? (mp_float_t)1e-9 : mp_obj_get_float(args[ARG_rel_tol].u_obj);
+    const mp_float_t abs_tol = mp_obj_get_float(args[ARG_abs_tol].u_obj);
+    if (rel_tol < (mp_float_t)0.0 || abs_tol < (mp_float_t)0.0) {
+        math_error();
+    }
+    if (a == b) {
+        return mp_const_true;
+    }
+    const mp_float_t difference = MICROPY_FLOAT_C_FUN(fabs)(a - b);
+    if (isinf(difference)) { // Either a or b is inf
+        return mp_const_false;
+    }
+    if ((difference <= abs_tol) ||
+        (difference <= MICROPY_FLOAT_C_FUN(fabs)(rel_tol * a)) ||
+        (difference <= MICROPY_FLOAT_C_FUN(fabs)(rel_tol * b))) {
+        return mp_const_true;
+    }
+    return mp_const_false;
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(mp_math_isclose_obj, 2, mp_math_isclose);
+#endif
 
 // Function that takes a variable number of arguments
 
@@ -187,7 +242,7 @@ STATIC mp_obj_t mp_math_log(size_t n_args, const mp_obj_t *args) {
         if (base <= (mp_float_t)0.0) {
             math_error();
         } else if (base == (mp_float_t)1.0) {
-            mp_raise_msg(&mp_type_ZeroDivisionError, "divide by zero");
+            mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("divide by zero"));
         }
         return mp_obj_new_float(l / MICROPY_FLOAT_C_FUN(log)(base));
     }
@@ -210,7 +265,13 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_math_frexp_obj, mp_math_frexp);
 // modf(x)
 STATIC mp_obj_t mp_math_modf(mp_obj_t x_obj) {
     mp_float_t int_part = 0.0;
-    mp_float_t fractional_part = MICROPY_FLOAT_C_FUN(modf)(mp_obj_get_float(x_obj), &int_part);
+    mp_float_t x = mp_obj_get_float(x_obj);
+    mp_float_t fractional_part = MICROPY_FLOAT_C_FUN(modf)(x, &int_part);
+    #if MICROPY_PY_MATH_MODF_FIX_NEGZERO
+    if (fractional_part == MICROPY_FLOAT_CONST(0.0)) {
+        fractional_part = copysign(fractional_part, x);
+    }
+    #endif
     mp_obj_t tuple[2];
     tuple[0] = mp_obj_new_float(fractional_part);
     tuple[1] = mp_obj_new_float(int_part);
@@ -258,7 +319,7 @@ STATIC mp_obj_t mp_math_factorial_inner(mp_uint_t start, mp_uint_t end) {
 STATIC mp_obj_t mp_math_factorial(mp_obj_t x_obj) {
     mp_int_t max = mp_obj_get_int(x_obj);
     if (max < 0) {
-        mp_raise_msg(&mp_type_ValueError, "negative factorial");
+        mp_raise_ValueError(MP_ERROR_TEXT("negative factorial"));
     } else if (max == 0) {
         return MP_OBJ_NEW_SMALL_INT(1);
     }
@@ -272,7 +333,7 @@ STATIC mp_obj_t mp_math_factorial(mp_obj_t x_obj) {
 STATIC mp_obj_t mp_math_factorial(mp_obj_t x_obj) {
     mp_int_t max = mp_obj_get_int(x_obj);
     if (max < 0) {
-        mp_raise_msg(&mp_type_ValueError, "negative factorial");
+        mp_raise_ValueError(MP_ERROR_TEXT("negative factorial"));
     } else if (max <= 1) {
         return MP_OBJ_NEW_SMALL_INT(1);
     }
@@ -335,6 +396,9 @@ STATIC const mp_rom_map_elem_t mp_module_math_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_isfinite), MP_ROM_PTR(&mp_math_isfinite_obj) },
     { MP_ROM_QSTR(MP_QSTR_isinf), MP_ROM_PTR(&mp_math_isinf_obj) },
     { MP_ROM_QSTR(MP_QSTR_isnan), MP_ROM_PTR(&mp_math_isnan_obj) },
+    #if MICROPY_PY_MATH_ISCLOSE
+    { MP_ROM_QSTR(MP_QSTR_isclose), MP_ROM_PTR(&mp_math_isclose_obj) },
+    #endif
     { MP_ROM_QSTR(MP_QSTR_trunc), MP_ROM_PTR(&mp_math_trunc_obj) },
     { MP_ROM_QSTR(MP_QSTR_radians), MP_ROM_PTR(&mp_math_radians_obj) },
     { MP_ROM_QSTR(MP_QSTR_degrees), MP_ROM_PTR(&mp_math_degrees_obj) },
@@ -353,7 +417,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_math_globals, mp_module_math_globals_table
 
 const mp_obj_module_t mp_module_math = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_math_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_math_globals,
 };
 
 #endif // MICROPY_PY_BUILTINS_FLOAT && MICROPY_PY_MATH
diff --git a/py/modmicropython.c b/py/modmicropython.c
index 864d1a5c5bcbe..f7eadf79bd1d2 100644
--- a/py/modmicropython.c
+++ b/py/modmicropython.c
@@ -68,25 +68,25 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_0(mp_micropython_mem_peak_obj, mp_micropython_mem
 
 mp_obj_t mp_micropython_mem_info(size_t n_args, const mp_obj_t *args) {
     (void)args;
-#if MICROPY_MEM_STATS
+    #if MICROPY_MEM_STATS
     mp_printf(&mp_plat_print, "mem: total=" UINT_FMT ", current=" UINT_FMT ", peak=" UINT_FMT "\n",
         (mp_uint_t)m_get_total_bytes_allocated(), (mp_uint_t)m_get_current_bytes_allocated(), (mp_uint_t)m_get_peak_bytes_allocated());
-#endif
-#if MICROPY_STACK_CHECK
+    #endif
+    #if MICROPY_STACK_CHECK
     mp_printf(&mp_plat_print, "stack: " UINT_FMT " out of " UINT_FMT "\n",
         mp_stack_usage(), (mp_uint_t)MP_STATE_THREAD(stack_limit));
-#else
+    #else
     mp_printf(&mp_plat_print, "stack: " UINT_FMT "\n", mp_stack_usage());
-#endif
-#if MICROPY_ENABLE_GC
+    #endif
+    #if MICROPY_ENABLE_GC
     gc_dump_info();
     if (n_args == 1) {
         // arg given means dump gc allocation table
         gc_dump_alloc_table();
     }
-#else
+    #else
     (void)n_args;
-#endif
+    #endif
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_micropython_mem_info_obj, 0, 1, mp_micropython_mem_info);
@@ -130,9 +130,16 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_0(mp_micropython_heap_lock_obj, mp_micropython_he
 
 STATIC mp_obj_t mp_micropython_heap_unlock(void) {
     gc_unlock();
-    return mp_const_none;
+    return MP_OBJ_NEW_SMALL_INT(MP_STATE_MEM(gc_lock_depth));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(mp_micropython_heap_unlock_obj, mp_micropython_heap_unlock);
+
+#if MICROPY_PY_MICROPYTHON_HEAP_LOCKED
+STATIC mp_obj_t mp_micropython_heap_locked(void) {
+    return MP_OBJ_NEW_SMALL_INT(MP_STATE_MEM(gc_lock_depth));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(mp_micropython_heap_locked_obj, mp_micropython_heap_locked);
+#endif
 #endif
 
 #if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF && (MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE == 0)
@@ -150,7 +157,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_micropython_kbd_intr_obj, mp_micropython_kbd
 #if MICROPY_ENABLE_SCHEDULER
 STATIC mp_obj_t mp_micropython_schedule(mp_obj_t function, mp_obj_t arg) {
     if (!mp_sched_schedule(function, arg)) {
-        mp_raise_msg(&mp_type_RuntimeError, "schedule stack full");
+        mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("schedule queue full"));
     }
     return mp_const_none;
 }
@@ -163,27 +170,30 @@ STATIC const mp_rom_map_elem_t mp_module_micropython_globals_table[] = {
     #if MICROPY_ENABLE_COMPILER
     { MP_ROM_QSTR(MP_QSTR_opt_level), MP_ROM_PTR(&mp_micropython_opt_level_obj) },
     #endif
-#if MICROPY_PY_MICROPYTHON_MEM_INFO
-#if MICROPY_MEM_STATS
+    #if MICROPY_PY_MICROPYTHON_MEM_INFO
+    #if MICROPY_MEM_STATS
     { MP_ROM_QSTR(MP_QSTR_mem_total), MP_ROM_PTR(&mp_micropython_mem_total_obj) },
     { MP_ROM_QSTR(MP_QSTR_mem_current), MP_ROM_PTR(&mp_micropython_mem_current_obj) },
     { MP_ROM_QSTR(MP_QSTR_mem_peak), MP_ROM_PTR(&mp_micropython_mem_peak_obj) },
-#endif
+    #endif
     { MP_ROM_QSTR(MP_QSTR_mem_info), MP_ROM_PTR(&mp_micropython_mem_info_obj) },
     { MP_ROM_QSTR(MP_QSTR_qstr_info), MP_ROM_PTR(&mp_micropython_qstr_info_obj) },
-#endif
+    #endif
     #if MICROPY_PY_MICROPYTHON_STACK_USE
     { MP_ROM_QSTR(MP_QSTR_stack_use), MP_ROM_PTR(&mp_micropython_stack_use_obj) },
     #endif
-#if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF && (MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE == 0)
+    #if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF && (MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE == 0)
     { MP_ROM_QSTR(MP_QSTR_alloc_emergency_exception_buf), MP_ROM_PTR(&mp_alloc_emergency_exception_buf_obj) },
-#endif
+    #endif
     #if MICROPY_ENABLE_PYSTACK
     { MP_ROM_QSTR(MP_QSTR_pystack_use), MP_ROM_PTR(&mp_micropython_pystack_use_obj) },
     #endif
     #if MICROPY_ENABLE_GC
     { MP_ROM_QSTR(MP_QSTR_heap_lock), MP_ROM_PTR(&mp_micropython_heap_lock_obj) },
     { MP_ROM_QSTR(MP_QSTR_heap_unlock), MP_ROM_PTR(&mp_micropython_heap_unlock_obj) },
+    #if MICROPY_PY_MICROPYTHON_HEAP_LOCKED
+    { MP_ROM_QSTR(MP_QSTR_heap_locked), MP_ROM_PTR(&mp_micropython_heap_locked_obj) },
+    #endif
     #endif
     #if MICROPY_KBD_EXCEPTION
     { MP_ROM_QSTR(MP_QSTR_kbd_intr), MP_ROM_PTR(&mp_micropython_kbd_intr_obj) },
@@ -197,5 +207,5 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_micropython_globals, mp_module_micropython
 
 const mp_obj_module_t mp_module_micropython = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_micropython_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_micropython_globals,
 };
diff --git a/py/modstruct.c b/py/modstruct.c
index 8617a8e0d3e0d..4cbcad6d496a8 100644
--- a/py/modstruct.c
+++ b/py/modstruct.c
@@ -97,7 +97,7 @@ STATIC size_t calc_size_items(const char *fmt, size_t *total_sz) {
             size += cnt;
         } else {
             total_cnt += cnt;
-            mp_uint_t align;
+            size_t align;
             size_t sz = mp_binary_get_size(fmt_type, *fmt, &align);
             while (cnt--) {
                 // Apply alignment
@@ -141,15 +141,16 @@ STATIC mp_obj_t struct_unpack_from(size_t n_args, const mp_obj_t *args) {
             // negative offsets are relative to the end of the buffer
             offset = bufinfo.len + offset;
             if (offset < 0) {
-                mp_raise_ValueError("buffer too small");
+                mp_raise_ValueError(MP_ERROR_TEXT("buffer too small"));
             }
         }
         p += offset;
     }
+    byte *p_base = p;
 
     // Check that the input buffer is big enough to unpack all the values
     if (p + total_sz > end_p) {
-        mp_raise_ValueError("buffer too small");
+        mp_raise_ValueError(MP_ERROR_TEXT("buffer too small"));
     }
 
     for (size_t i = 0; i < num_items;) {
@@ -164,7 +165,7 @@ STATIC mp_obj_t struct_unpack_from(size_t n_args, const mp_obj_t *args) {
             res->items[i++] = item;
         } else {
             while (cnt--) {
-                item = mp_binary_get_val(fmt_type, *fmt, &p);
+                item = mp_binary_get_val(fmt_type, *fmt, p_base, &p);
                 res->items[i++] = item;
             }
         }
@@ -179,6 +180,7 @@ STATIC void struct_pack_into_internal(mp_obj_t fmt_in, byte *p, size_t n_args, c
     const char *fmt = mp_obj_str_get_str(fmt_in);
     char fmt_type = get_fmt_type(&fmt);
 
+    byte *p_base = p;
     size_t i;
     for (i = 0; i < n_args;) {
         mp_uint_t cnt = 1;
@@ -203,7 +205,7 @@ STATIC void struct_pack_into_internal(mp_obj_t fmt_in, byte *p, size_t n_args, c
         } else {
             // If we run out of args then we just finish; CPython would raise struct.error
             while (cnt-- && i < n_args) {
-                mp_binary_set_val(fmt_type, *fmt, args[i++], &p);
+                mp_binary_set_val(fmt_type, *fmt, args[i++], p_base, &p);
             }
         }
         fmt++;
@@ -215,7 +217,7 @@ STATIC mp_obj_t struct_pack(size_t n_args, const mp_obj_t *args) {
     mp_int_t size = MP_OBJ_SMALL_INT_VALUE(struct_calcsize(args[0]));
     vstr_t vstr;
     vstr_init_len(&vstr, size);
-    byte *p = (byte*)vstr.buf;
+    byte *p = (byte *)vstr.buf;
     memset(p, 0, size);
     struct_pack_into_internal(args[0], p, n_args - 1, &args[1]);
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
@@ -230,7 +232,7 @@ STATIC mp_obj_t struct_pack_into(size_t n_args, const mp_obj_t *args) {
         // negative offsets are relative to the end of the buffer
         offset = (mp_int_t)bufinfo.len + offset;
         if (offset < 0) {
-            mp_raise_ValueError("buffer too small");
+            mp_raise_ValueError(MP_ERROR_TEXT("buffer too small"));
         }
     }
     byte *p = (byte *)bufinfo.buf;
@@ -240,7 +242,7 @@ STATIC mp_obj_t struct_pack_into(size_t n_args, const mp_obj_t *args) {
     // Check that the output buffer is big enough to hold all the values
     mp_int_t sz = MP_OBJ_SMALL_INT_VALUE(struct_calcsize(args[0]));
     if (p + sz > end_p) {
-        mp_raise_ValueError("buffer too small");
+        mp_raise_ValueError(MP_ERROR_TEXT("buffer too small"));
     }
 
     struct_pack_into_internal(args[0], p, n_args - 3, &args[3]);
@@ -261,7 +263,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_struct_globals, mp_module_struct_globals_t
 
 const mp_obj_module_t mp_module_ustruct = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_struct_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_struct_globals,
 };
 
 #endif
diff --git a/py/modsys.c b/py/modsys.c
index 3434517328720..586b13e747130 100644
--- a/py/modsys.c
+++ b/py/modsys.c
@@ -34,6 +34,12 @@
 #include "py/stream.h"
 #include "py/smallint.h"
 #include "py/runtime.h"
+#include "py/persistentcode.h"
+
+#if MICROPY_PY_SYS_SETTRACE
+#include "py/objmodule.h"
+#include "py/profile.h"
+#endif
 
 #if MICROPY_PY_SYS
 
@@ -47,7 +53,7 @@ const mp_print_t mp_sys_stdout_print = {&mp_sys_stdout_obj, mp_stream_write_adap
 #endif
 
 // version - Python language version that this implementation conforms to, as a string
-STATIC const MP_DEFINE_STR_OBJ(version_obj, "3.4.0");
+STATIC const MP_DEFINE_STR_OBJ(mp_sys_version_obj, "3.4.0");
 
 // version_info - Python language version that this implementation conforms to, as a tuple of ints
 #define I(n) MP_OBJ_NEW_SMALL_INT(n)
@@ -61,22 +67,36 @@ STATIC const mp_obj_tuple_t mp_sys_implementation_version_info_obj = {
     3,
     { I(MICROPY_VERSION_MAJOR), I(MICROPY_VERSION_MINOR), I(MICROPY_VERSION_MICRO) }
 };
+#if MICROPY_PERSISTENT_CODE_LOAD
+#define SYS_IMPLEMENTATION_ELEMS \
+    MP_ROM_QSTR(MP_QSTR_micropython), \
+    MP_ROM_PTR(&mp_sys_implementation_version_info_obj), \
+    MP_ROM_INT(MPY_FILE_HEADER_INT)
+#else
+#define SYS_IMPLEMENTATION_ELEMS \
+    MP_ROM_QSTR(MP_QSTR_micropython), \
+    MP_ROM_PTR(&mp_sys_implementation_version_info_obj)
+#endif
 #if MICROPY_PY_ATTRTUPLE
-STATIC const qstr impl_fields[] = { MP_QSTR_name, MP_QSTR_version };
+STATIC const qstr impl_fields[] = {
+    MP_QSTR_name,
+    MP_QSTR_version,
+    #if MICROPY_PERSISTENT_CODE_LOAD
+    MP_QSTR_mpy,
+    #endif
+};
 STATIC MP_DEFINE_ATTRTUPLE(
     mp_sys_implementation_obj,
     impl_fields,
-    2,
-        MP_ROM_QSTR(MP_QSTR_micropython),
-        MP_ROM_PTR(&mp_sys_implementation_version_info_obj)
-);
+    2 + MICROPY_PERSISTENT_CODE_LOAD,
+    SYS_IMPLEMENTATION_ELEMS
+    );
 #else
 STATIC const mp_rom_obj_tuple_t mp_sys_implementation_obj = {
     {&mp_type_tuple},
-    2,
+    2 + MICROPY_PERSISTENT_CODE_LOAD,
     {
-        MP_ROM_QSTR(MP_QSTR_micropython),
-        MP_ROM_PTR(&mp_sys_implementation_version_info_obj),
+        SYS_IMPLEMENTATION_ELEMS
     }
 };
 #endif
@@ -85,7 +105,7 @@ STATIC const mp_rom_obj_tuple_t mp_sys_implementation_obj = {
 
 #ifdef MICROPY_PY_SYS_PLATFORM
 // platform - the platform that MicroPython is running on
-STATIC const MP_DEFINE_STR_OBJ(platform_obj, MICROPY_PY_SYS_PLATFORM);
+STATIC const MP_DEFINE_STR_OBJ(mp_sys_platform_obj, MICROPY_PY_SYS_PLATFORM);
 #endif
 
 // exit([retval]): raise SystemExit, with optional argument given to the exception
@@ -146,16 +166,34 @@ STATIC mp_obj_t mp_sys_getsizeof(mp_obj_t obj) {
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_sys_getsizeof_obj, mp_sys_getsizeof);
 #endif
 
+#if MICROPY_PY_SYS_ATEXIT
+// atexit(callback): Callback is called when sys.exit is called.
+STATIC mp_obj_t mp_sys_atexit(mp_obj_t obj) {
+    mp_obj_t old = MP_STATE_VM(sys_exitfunc);
+    MP_STATE_VM(sys_exitfunc) = obj;
+    return old;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_sys_atexit_obj, mp_sys_atexit);
+#endif
+
+#if MICROPY_PY_SYS_SETTRACE
+// settrace(tracefunc): Set the system’s trace function.
+STATIC mp_obj_t mp_sys_settrace(mp_obj_t obj) {
+    return mp_prof_settrace(obj);
+}
+MP_DEFINE_CONST_FUN_OBJ_1(mp_sys_settrace_obj, mp_sys_settrace);
+#endif // MICROPY_PY_SYS_SETTRACE
+
 STATIC const mp_rom_map_elem_t mp_module_sys_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_sys) },
 
     { MP_ROM_QSTR(MP_QSTR_path), MP_ROM_PTR(&MP_STATE_VM(mp_sys_path_obj)) },
     { MP_ROM_QSTR(MP_QSTR_argv), MP_ROM_PTR(&MP_STATE_VM(mp_sys_argv_obj)) },
-    { MP_ROM_QSTR(MP_QSTR_version), MP_ROM_PTR(&version_obj) },
+    { MP_ROM_QSTR(MP_QSTR_version), MP_ROM_PTR(&mp_sys_version_obj) },
     { MP_ROM_QSTR(MP_QSTR_version_info), MP_ROM_PTR(&mp_sys_version_info_obj) },
     { MP_ROM_QSTR(MP_QSTR_implementation), MP_ROM_PTR(&mp_sys_implementation_obj) },
     #ifdef MICROPY_PY_SYS_PLATFORM
-    { MP_ROM_QSTR(MP_QSTR_platform), MP_ROM_PTR(&platform_obj) },
+    { MP_ROM_QSTR(MP_QSTR_platform), MP_ROM_PTR(&mp_sys_platform_obj) },
     #endif
     #if MP_ENDIANNESS_LITTLE
     { MP_ROM_QSTR(MP_QSTR_byteorder), MP_ROM_QSTR(MP_QSTR_little) },
@@ -172,7 +210,7 @@ STATIC const mp_rom_map_elem_t mp_module_sys_globals_table[] = {
     // of "one" bits in sys.maxsize.
     { MP_ROM_QSTR(MP_QSTR_maxsize), MP_ROM_INT(MP_SMALL_INT_MAX) },
     #else
-    { MP_ROM_QSTR(MP_QSTR_maxsize), MP_ROM_PTR(&mp_maxsize_obj) },
+    { MP_ROM_QSTR(MP_QSTR_maxsize), MP_ROM_PTR(&mp_sys_maxsize_obj) },
     #endif
     #endif
 
@@ -180,6 +218,10 @@ STATIC const mp_rom_map_elem_t mp_module_sys_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_exit), MP_ROM_PTR(&mp_sys_exit_obj) },
     #endif
 
+    #if MICROPY_PY_SYS_SETTRACE
+    { MP_ROM_QSTR(MP_QSTR_settrace), MP_ROM_PTR(&mp_sys_settrace_obj) },
+    #endif
+
     #if MICROPY_PY_SYS_STDFILES
     { MP_ROM_QSTR(MP_QSTR_stdin), MP_ROM_PTR(&mp_sys_stdin_obj) },
     { MP_ROM_QSTR(MP_QSTR_stdout), MP_ROM_PTR(&mp_sys_stdout_obj) },
@@ -201,13 +243,16 @@ STATIC const mp_rom_map_elem_t mp_module_sys_globals_table[] = {
      */
 
     { MP_ROM_QSTR(MP_QSTR_print_exception), MP_ROM_PTR(&mp_sys_print_exception_obj) },
+    #if MICROPY_PY_SYS_ATEXIT
+    { MP_ROM_QSTR(MP_QSTR_atexit), MP_ROM_PTR(&mp_sys_atexit_obj) },
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(mp_module_sys_globals, mp_module_sys_globals_table);
 
 const mp_obj_module_t mp_module_sys = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_sys_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_sys_globals,
 };
 
 #endif
diff --git a/py/modthread.c b/py/modthread.c
index 91237a72b3758..1306dc642b018 100644
--- a/py/modthread.c
+++ b/py/modthread.c
@@ -120,7 +120,7 @@ STATIC MP_DEFINE_CONST_DICT(thread_lock_locals_dict, thread_lock_locals_dict_tab
 STATIC const mp_obj_type_t mp_type_thread_lock = {
     { &mp_type_type },
     .name = MP_QSTR_lock,
-    .locals_dict = (mp_obj_dict_t*)&thread_lock_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&thread_lock_locals_dict,
 };
 
 /****************************************************************/
@@ -157,7 +157,7 @@ typedef struct _thread_entry_args_t {
 STATIC void *thread_entry(void *args_in) {
     // Execution begins here for a new thread.  We do not have the GIL.
 
-    thread_entry_args_t *args = (thread_entry_args_t*)args_in;
+    thread_entry_args_t *args = (thread_entry_args_t *)args_in;
 
     mp_state_thread_t ts;
     mp_thread_set_state(&ts);
@@ -193,7 +193,7 @@ STATIC void *thread_entry(void *args_in) {
     } else {
         // uncaught exception
         // check for SystemExit
-        mp_obj_base_t *exc = (mp_obj_base_t*)nlr.ret_val;
+        mp_obj_base_t *exc = (mp_obj_base_t *)nlr.ret_val;
         if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(exc->type), MP_OBJ_FROM_PTR(&mp_type_SystemExit))) {
             // swallow exception silently
         } else {
@@ -235,9 +235,9 @@ STATIC mp_obj_t mod_thread_start_new_thread(size_t n_args, const mp_obj_t *args)
     } else {
         // positional and keyword arguments
         if (mp_obj_get_type(args[2]) != &mp_type_dict) {
-            mp_raise_TypeError("expecting a dict for keyword args");
+            mp_raise_TypeError(MP_ERROR_TEXT("expecting a dict for keyword args"));
         }
-        mp_map_t *map = &((mp_obj_dict_t*)MP_OBJ_TO_PTR(args[2]))->map;
+        mp_map_t *map = &((mp_obj_dict_t *)MP_OBJ_TO_PTR(args[2]))->map;
         th_args = m_new_obj_var(thread_entry_args_t, mp_obj_t, pos_args_len + 2 * map->used);
         th_args->n_kw = map->used;
         // copy across the keyword arguments
@@ -249,7 +249,7 @@ STATIC mp_obj_t mod_thread_start_new_thread(size_t n_args, const mp_obj_t *args)
         }
     }
 
-    // copy agross the positional arguments
+    // copy across the positional arguments
     th_args->n_args = pos_args_len;
     memcpy(th_args->args, pos_args_items, pos_args_len * sizeof(mp_obj_t));
 
@@ -271,7 +271,7 @@ STATIC mp_obj_t mod_thread_start_new_thread(size_t n_args, const mp_obj_t *args)
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_thread_start_new_thread_obj, 2, 3, mod_thread_start_new_thread);
 
 STATIC mp_obj_t mod_thread_exit(void) {
-    nlr_raise(mp_obj_new_exception(&mp_type_SystemExit));
+    mp_raise_type(&mp_type_SystemExit);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_thread_exit_obj, mod_thread_exit);
 
@@ -294,7 +294,7 @@ STATIC MP_DEFINE_CONST_DICT(mp_module_thread_globals, mp_module_thread_globals_t
 
 const mp_obj_module_t mp_module_thread = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_thread_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_thread_globals,
 };
 
 #endif // MICROPY_PY_THREAD
diff --git a/py/moduerrno.c b/py/moduerrno.c
index de66c941b0e6e..d9affd9b20c7a 100644
--- a/py/moduerrno.c
+++ b/py/moduerrno.c
@@ -63,9 +63,9 @@
 
 #if MICROPY_PY_UERRNO_ERRORCODE
 STATIC const mp_rom_map_elem_t errorcode_table[] = {
-    #define X(e) { MP_ROM_INT(MP_ ## e), MP_ROM_QSTR(MP_QSTR_## e) },
+    #define X(e) { MP_ROM_INT(MP_##e), MP_ROM_QSTR(MP_QSTR_##e) },
     MICROPY_PY_UERRNO_LIST
-    #undef X
+#undef X
 };
 
 STATIC const mp_obj_dict_t errorcode_dict = {
@@ -76,7 +76,7 @@ STATIC const mp_obj_dict_t errorcode_dict = {
         .is_ordered = 1,
         .used = MP_ARRAY_SIZE(errorcode_table),
         .alloc = MP_ARRAY_SIZE(errorcode_table),
-        .table = (mp_map_elem_t*)(mp_rom_map_elem_t*)errorcode_table,
+        .table = (mp_map_elem_t *)(mp_rom_map_elem_t *)errorcode_table,
     },
 };
 #endif
@@ -87,24 +87,24 @@ STATIC const mp_rom_map_elem_t mp_module_uerrno_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_errorcode), MP_ROM_PTR(&errorcode_dict) },
     #endif
 
-    #define X(e) { MP_ROM_QSTR(MP_QSTR_## e), MP_ROM_INT(MP_ ## e) },
+    #define X(e) { MP_ROM_QSTR(MP_QSTR_##e), MP_ROM_INT(MP_##e) },
     MICROPY_PY_UERRNO_LIST
-    #undef X
+#undef X
 };
 
 STATIC MP_DEFINE_CONST_DICT(mp_module_uerrno_globals, mp_module_uerrno_globals_table);
 
 const mp_obj_module_t mp_module_uerrno = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&mp_module_uerrno_globals,
+    .globals = (mp_obj_dict_t *)&mp_module_uerrno_globals,
 };
 
 qstr mp_errno_to_str(mp_obj_t errno_val) {
     #if MICROPY_PY_UERRNO_ERRORCODE
     // We have the errorcode dict so can do a lookup using the hash map
-    mp_map_elem_t *elem = mp_map_lookup((mp_map_t*)&errorcode_dict.map, errno_val, MP_MAP_LOOKUP);
+    mp_map_elem_t *elem = mp_map_lookup((mp_map_t *)&errorcode_dict.map, errno_val, MP_MAP_LOOKUP);
     if (elem == NULL) {
-        return MP_QSTR_NULL;
+        return MP_QSTRnull;
     } else {
         return MP_OBJ_QSTR_VALUE(elem->value);
     }
@@ -115,8 +115,8 @@ qstr mp_errno_to_str(mp_obj_t errno_val) {
             return MP_OBJ_QSTR_VALUE(mp_module_uerrno_globals_table[i].key);
         }
     }
-    return MP_QSTR_NULL;
+    return MP_QSTRnull;
     #endif
 }
 
-#endif //MICROPY_PY_UERRNO
+#endif // MICROPY_PY_UERRNO
diff --git a/py/mpconfig.h b/py/mpconfig.h
index 893ac7dc7eddb..27df3f483a0e1 100644
--- a/py/mpconfig.h
+++ b/py/mpconfig.h
@@ -28,14 +28,14 @@
 
 // Current version of MicroPython
 #define MICROPY_VERSION_MAJOR 1
-#define MICROPY_VERSION_MINOR 10
+#define MICROPY_VERSION_MINOR 12
 #define MICROPY_VERSION_MICRO 0
 
 // Combined version as a 32-bit number for convenience
 #define MICROPY_VERSION ( \
     MICROPY_VERSION_MAJOR << 16 \
-    | MICROPY_VERSION_MINOR << 8 \
-    | MICROPY_VERSION_MICRO)
+        | MICROPY_VERSION_MINOR << 8 \
+        | MICROPY_VERSION_MICRO)
 
 // String version
 #define MICROPY_VERSION_STRING \
@@ -70,25 +70,28 @@
 
 // A MicroPython object is a machine word having the following form:
 //  - xxxx...xxx1 : a small int, bits 1 and above are the value
-//  - xxxx...xx10 : a qstr, bits 2 and above are the value
+//  - xxxx...x010 : a qstr, bits 3 and above are the value
+//  - xxxx...x110 : an immediate object, bits 3 and above are the value
 //  - xxxx...xx00 : a pointer to an mp_obj_base_t (unless a fake object)
 #define MICROPY_OBJ_REPR_A (0)
 
 // A MicroPython object is a machine word having the following form:
 //  - xxxx...xx01 : a small int, bits 2 and above are the value
-//  - xxxx...xx11 : a qstr, bits 2 and above are the value
+//  - xxxx...x011 : a qstr, bits 3 and above are the value
+//  - xxxx...x111 : an immediate object, bits 3 and above are the value
 //  - xxxx...xxx0 : a pointer to an mp_obj_base_t (unless a fake object)
 #define MICROPY_OBJ_REPR_B (1)
 
 // A MicroPython object is a machine word having the following form (called R):
 //  - iiiiiiii iiiiiiii iiiiiiii iiiiiii1 small int with 31-bit signed value
-//  - 01111111 1qqqqqqq qqqqqqqq qqqqq110 str with 20-bit qstr value
+//  - 01111111 1qqqqqqq qqqqqqqq qqqq0110 str with 19-bit qstr value
+//  - 01111111 10000000 00000000 ssss1110 immediate object with 4-bit value
 //  - s1111111 10000000 00000000 00000010 +/- inf
 //  - s1111111 1xxxxxxx xxxxxxxx xxxxx010 nan, x != 0
 //  - seeeeeee efffffff ffffffff ffffff10 30-bit fp, e != 0xff
 //  - pppppppp pppppppp pppppppp pppppp00 ptr (4 byte alignment)
-// Str and float stored as O = R + 0x80800000, retrieved as R = O - 0x80800000.
-// This makes strs easier to encode/decode as they have zeros in the top 9 bits.
+// Str, immediate and float stored as O = R + 0x80800000, retrieved as R = O - 0x80800000.
+// This makes strs/immediates easier to encode/decode as they have zeros in the top 9 bits.
 // This scheme only works with 32-bit word size and float enabled.
 #define MICROPY_OBJ_REPR_C (2)
 
@@ -98,6 +101,7 @@
 //  - 01111111 11111000 00000000 00000000 00000000 00000000 00000000 00000000 normalised nan
 //  - 01111111 11111101 iiiiiiii iiiiiiii iiiiiiii iiiiiiii iiiiiiii iiiiiii1 small int
 //  - 01111111 11111110 00000000 00000000 qqqqqqqq qqqqqqqq qqqqqqqq qqqqqqq1 str
+//  - 01111111 11111111 ss000000 00000000 00000000 00000000 00000000 00000000 immediate object
 //  - 01111111 11111100 00000000 00000000 pppppppp pppppppp pppppppp pppppp00 ptr (4 byte alignment)
 // Stored as O = R + 0x8004000000000000, retrieved as R = O - 0x8004000000000000.
 // This makes pointers have all zeros in the top 32 bits.
@@ -109,6 +113,13 @@
 #define MICROPY_OBJ_REPR (MICROPY_OBJ_REPR_A)
 #endif
 
+// Whether to encode None/False/True as immediate objects instead of pointers to
+// real objects.  Reduces code size by a decent amount without hurting
+// performance, for all representations except D on some architectures.
+#ifndef MICROPY_OBJ_IMMEDIATE_OBJS
+#define MICROPY_OBJ_IMMEDIATE_OBJS (MICROPY_OBJ_REPR != MICROPY_OBJ_REPR_D)
+#endif
+
 /*****************************************************************************/
 /* Memory allocation policy                                                  */
 
@@ -323,12 +334,23 @@
 #define MICROPY_EMIT_INLINE_XTENSA (0)
 #endif
 
+// Whether to emit Xtensa-Windowed native code
+#ifndef MICROPY_EMIT_XTENSAWIN
+#define MICROPY_EMIT_XTENSAWIN (0)
+#endif
+
 // Convenience definition for whether any native emitter is enabled
-#define MICROPY_EMIT_NATIVE (MICROPY_EMIT_X64 || MICROPY_EMIT_X86 || MICROPY_EMIT_THUMB || MICROPY_EMIT_ARM || MICROPY_EMIT_XTENSA)
+#define MICROPY_EMIT_NATIVE (MICROPY_EMIT_X64 || MICROPY_EMIT_X86 || MICROPY_EMIT_THUMB || MICROPY_EMIT_ARM || MICROPY_EMIT_XTENSA || MICROPY_EMIT_XTENSAWIN)
+
+// Select prelude-as-bytes-object for certain emitters
+#define MICROPY_EMIT_NATIVE_PRELUDE_AS_BYTES_OBJ (MICROPY_EMIT_XTENSAWIN)
 
 // Convenience definition for whether any inline assembler emitter is enabled
 #define MICROPY_EMIT_INLINE_ASM (MICROPY_EMIT_INLINE_THUMB || MICROPY_EMIT_INLINE_XTENSA)
 
+// Convenience definition for whether any native or inline assembler emitter is enabled
+#define MICROPY_EMIT_MACHINE_CODE (MICROPY_EMIT_NATIVE || MICROPY_EMIT_INLINE_ASM)
+
 /*****************************************************************************/
 /* Compiler configuration                                                    */
 
@@ -338,6 +360,7 @@
 #endif
 
 // Whether the compiler is dynamically configurable (ie at runtime)
+// This will disable the ability to execute native/viper code
 #ifndef MICROPY_DYNAMIC_COMPILER
 #define MICROPY_DYNAMIC_COMPILER (0)
 #endif
@@ -527,9 +550,9 @@
 #define MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF (0)
 #endif
 #if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF
-#   ifndef MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE
-#   define MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE (0)   // 0 - implies dynamic allocation
-#   endif
+#ifndef MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE
+#define MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE (0)      // 0 - implies dynamic allocation
+#endif
 #endif
 
 // Whether to provide the mp_kbd_exception object, and micropython.kbd_intr function
@@ -548,11 +571,31 @@
 #define MICROPY_HELPER_REPL (0)
 #endif
 
+// Allow enabling debug prints after each REPL line
+#ifndef MICROPY_REPL_INFO
+#define MICROPY_REPL_INFO (0)
+#endif
+
 // Whether to include emacs-style readline behavior in REPL
 #ifndef MICROPY_REPL_EMACS_KEYS
 #define MICROPY_REPL_EMACS_KEYS (0)
 #endif
 
+// Whether to include emacs-style word movement/kill readline behavior in REPL.
+// This adds Alt+F, Alt+B, Alt+D and Alt+Backspace for forward-word, backward-word, forward-kill-word
+// and backward-kill-word, respectively.
+#ifndef MICROPY_REPL_EMACS_WORDS_MOVE
+#define MICROPY_REPL_EMACS_WORDS_MOVE (0)
+#endif
+
+// Whether to include extra convenience keys for word movement/kill in readline REPL.
+// This adds Ctrl+Right, Ctrl+Left and Ctrl+W for forward-word, backward-word and backward-kill-word
+// respectively. Ctrl+Delete is not implemented because it's a very different escape sequence.
+// Depends on MICROPY_REPL_EMACS_WORDS_MOVE.
+#ifndef MICROPY_REPL_EMACS_EXTRA_WORDS_MOVE
+#define MICROPY_REPL_EMACS_EXTRA_WORDS_MOVE (0)
+#endif
+
 // Whether to implement auto-indent in REPL
 #ifndef MICROPY_REPL_AUTO_INDENT
 #define MICROPY_REPL_AUTO_INDENT (0)
@@ -686,7 +729,7 @@ typedef double mp_float_t;
 
 // Whether to support module-level __getattr__ (see PEP 562)
 #ifndef MICROPY_MODULE_GETATTR
-#define MICROPY_MODULE_GETATTR (0)
+#define MICROPY_MODULE_GETATTR (1)
 #endif
 
 // Whether module weak links are supported
@@ -856,6 +899,11 @@ typedef double mp_float_t;
 #define MICROPY_PY_BUILTINS_MEMORYVIEW (0)
 #endif
 
+// Whether to support memoryview.itemsize attribute
+#ifndef MICROPY_PY_BUILTINS_MEMORYVIEW_ITEMSIZE
+#define MICROPY_PY_BUILTINS_MEMORYVIEW_ITEMSIZE (0)
+#endif
+
 // Whether to support set object
 #ifndef MICROPY_PY_BUILTINS_SET
 #define MICROPY_PY_BUILTINS_SET (1)
@@ -872,6 +920,11 @@ typedef double mp_float_t;
 #define MICROPY_PY_BUILTINS_SLICE_ATTRS (0)
 #endif
 
+// Whether to support the .indices(len) method on slice objects
+#ifndef MICROPY_PY_BUILTINS_SLICE_INDICES
+#define MICROPY_PY_BUILTINS_SLICE_INDICES (0)
+#endif
+
 // Whether to support frozenset object
 #ifndef MICROPY_PY_BUILTINS_FROZENSET
 #define MICROPY_PY_BUILTINS_FROZENSET (0)
@@ -906,11 +959,6 @@ typedef double mp_float_t;
 #define MICROPY_PY_BUILTINS_ROUND_INT (0)
 #endif
 
-// Whether to support timeout exceptions (like socket.timeout)
-#ifndef MICROPY_PY_BUILTINS_TIMEOUTERROR
-#define MICROPY_PY_BUILTINS_TIMEOUTERROR (0)
-#endif
-
 // Whether to support complete set of special methods for user
 // classes, or only the most used ones. "Inplace" methods are
 // controlled by MICROPY_PY_ALL_INPLACE_SPECIAL_METHODS below.
@@ -1016,6 +1064,11 @@ typedef double mp_float_t;
 #define MICROPY_PY_MICROPYTHON_STACK_USE (MICROPY_PY_MICROPYTHON_MEM_INFO)
 #endif
 
+// Whether to provide the "micropython.heap_locked" function
+#ifndef MICROPY_PY_MICROPYTHON_HEAP_LOCKED
+#define MICROPY_PY_MICROPYTHON_HEAP_LOCKED (0)
+#endif
+
 // Whether to provide "array" module. Note that large chunk of the
 // underlying code is shared with "bytearray" builtin type, so to
 // get real savings, it should be disabled too.
@@ -1070,6 +1123,26 @@ typedef double mp_float_t;
 #define MICROPY_PY_MATH_FACTORIAL (0)
 #endif
 
+// Whether to provide math.isclose function
+#ifndef MICROPY_PY_MATH_ISCLOSE
+#define MICROPY_PY_MATH_ISCLOSE (0)
+#endif
+
+// Whether to provide fix for atan2 Inf handling.
+#ifndef MICROPY_PY_MATH_ATAN2_FIX_INFNAN
+#define MICROPY_PY_MATH_ATAN2_FIX_INFNAN (0)
+#endif
+
+// Whether to provide fix for fmod Inf handling.
+#ifndef MICROPY_PY_MATH_FMOD_FIX_INFNAN
+#define MICROPY_PY_MATH_FMOD_FIX_INFNAN (0)
+#endif
+
+// Whether to provide fix for modf negative zero handling.
+#ifndef MICROPY_PY_MATH_MODF_FIX_NEGZERO
+#define MICROPY_PY_MATH_MODF_FIX_NEGZERO (0)
+#endif
+
 // Whether to provide "cmath" module
 #ifndef MICROPY_PY_CMATH
 #define MICROPY_PY_CMATH (0)
@@ -1152,6 +1225,16 @@ typedef double mp_float_t;
 #define MICROPY_PY_SYS_EXIT (1)
 #endif
 
+// Whether to provide "sys.atexit" function (MicroPython extension)
+#ifndef MICROPY_PY_SYS_ATEXIT
+#define MICROPY_PY_SYS_ATEXIT (0)
+#endif
+
+// Whether to provide "sys.settrace" function
+#ifndef MICROPY_PY_SYS_SETTRACE
+#define MICROPY_PY_SYS_SETTRACE (0)
+#endif
+
 // Whether to provide "sys.getsizeof" function
 #ifndef MICROPY_PY_SYS_GETSIZEOF
 #define MICROPY_PY_SYS_GETSIZEOF (0)
@@ -1218,6 +1301,10 @@ typedef double mp_float_t;
 
 // Extended modules
 
+#ifndef MICROPY_PY_UASYNCIO
+#define MICROPY_PY_UASYNCIO (0)
+#endif
+
 #ifndef MICROPY_PY_UCTYPES
 #define MICROPY_PY_UCTYPES (0)
 #endif
@@ -1240,6 +1327,10 @@ typedef double mp_float_t;
 #define MICROPY_PY_URE (0)
 #endif
 
+#ifndef MICROPY_PY_URE_DEBUG
+#define MICROPY_PY_URE_DEBUG (0)
+#endif
+
 #ifndef MICROPY_PY_URE_MATCH_GROUPS
 #define MICROPY_PY_URE_MATCH_GROUPS (0)
 #endif
@@ -1281,6 +1372,11 @@ typedef double mp_float_t;
 #define MICROPY_PY_UCRYPTOLIB (0)
 #endif
 
+// Depends on MICROPY_PY_UCRYPTOLIB
+#ifndef MICROPY_PY_UCRYPTOLIB_CTR
+#define MICROPY_PY_UCRYPTOLIB_CTR (0)
+#endif
+
 #ifndef MICROPY_PY_UCRYPTOLIB_CONSTS
 #define MICROPY_PY_UCRYPTOLIB_CONSTS (0)
 #endif
@@ -1351,11 +1447,6 @@ typedef double mp_float_t;
 #define MICROPY_PORT_BUILTIN_MODULES
 #endif
 
-// Any module weak links - see objmodule.c:mp_builtin_module_weak_links_table.
-#ifndef MICROPY_PORT_BUILTIN_MODULE_WEAK_LINKS
-#define MICROPY_PORT_BUILTIN_MODULE_WEAK_LINKS
-#endif
-
 // Additional constant definitions for the compiler - see compile.c:mp_constants_table.
 #ifndef MICROPY_PORT_CONSTANTS
 #define MICROPY_PORT_CONSTANTS
@@ -1366,6 +1457,17 @@ typedef double mp_float_t;
 #define MICROPY_PORT_ROOT_POINTERS
 #endif
 
+/*****************************************************************************/
+/* Hooks for a port to wrap functions with attributes                        */
+
+#ifndef MICROPY_WRAP_MP_KEYBOARD_INTERRUPT
+#define MICROPY_WRAP_MP_KEYBOARD_INTERRUPT(f) f
+#endif
+
+#ifndef MICROPY_WRAP_MP_SCHED_SCHEDULE
+#define MICROPY_WRAP_MP_SCHED_SCHEDULE(f) f
+#endif
+
 /*****************************************************************************/
 /* Miscellaneous settings                                                    */
 
@@ -1396,7 +1498,9 @@ typedef double mp_float_t;
 #define BYTES_PER_WORD (sizeof(mp_uint_t))
 #endif
 
+#ifndef BITS_PER_BYTE
 #define BITS_PER_BYTE (8)
+#endif
 #define BITS_PER_WORD (BITS_PER_BYTE * BYTES_PER_WORD)
 // mp_int_t value with most significant bit set
 #define WORD_MSBIT_HIGH (((mp_uint_t)1) << (BYTES_PER_WORD * 8 - 1))
@@ -1408,7 +1512,7 @@ typedef double mp_float_t;
 #elif defined(MP_ENDIANNESS_BIG)
 #define MP_ENDIANNESS_LITTLE (!MP_ENDIANNESS_BIG)
 #else
-  // Endianness not defined by port so try to autodetect it.
+// Endianness not defined by port so try to autodetect it.
   #if defined(__BYTE_ORDER__)
     #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
       #define MP_ENDIANNESS_LITTLE (1)
@@ -1471,7 +1575,7 @@ typedef double mp_float_t;
 #define UINT_FMT "%u"
 #define INT_FMT "%d"
 #endif
-#endif //INT_FMT
+#endif // INT_FMT
 
 // Modifier for function which doesn't return
 #ifndef NORETURN
@@ -1503,35 +1607,54 @@ typedef double mp_float_t;
 #define MP_UNLIKELY(x) __builtin_expect((x), 0)
 #endif
 
+// To annotate that code is unreachable
+#ifndef MP_UNREACHABLE
+#if defined(__GNUC__)
+#define MP_UNREACHABLE __builtin_unreachable();
+#else
+#define MP_UNREACHABLE for (;;);
+#endif
+#endif
+
 #ifndef MP_HTOBE16
 #if MP_ENDIANNESS_LITTLE
-# define MP_HTOBE16(x) ((uint16_t)( (((x) & 0xff) << 8) | (((x) >> 8) & 0xff) ))
-# define MP_BE16TOH(x) MP_HTOBE16(x)
+#define MP_HTOBE16(x) ((uint16_t)((((x) & 0xff) << 8) | (((x) >> 8) & 0xff)))
+#define MP_BE16TOH(x) MP_HTOBE16(x)
 #else
-# define MP_HTOBE16(x) (x)
-# define MP_BE16TOH(x) (x)
+#define MP_HTOBE16(x) (x)
+#define MP_BE16TOH(x) (x)
 #endif
 #endif
 
 #ifndef MP_HTOBE32
 #if MP_ENDIANNESS_LITTLE
-# define MP_HTOBE32(x) ((uint32_t)( (((x) & 0xff) << 24) | (((x) & 0xff00) << 8) | (((x) >> 8)  & 0xff00) | (((x) >> 24) & 0xff) ))
-# define MP_BE32TOH(x) MP_HTOBE32(x)
+#define MP_HTOBE32(x) ((uint32_t)((((x) & 0xff) << 24) | (((x) & 0xff00) << 8) | (((x) >> 8) & 0xff00) | (((x) >> 24) & 0xff)))
+#define MP_BE32TOH(x) MP_HTOBE32(x)
 #else
-# define MP_HTOBE32(x) (x)
-# define MP_BE32TOH(x) (x)
+#define MP_HTOBE32(x) (x)
+#define MP_BE32TOH(x) (x)
 #endif
 #endif
 
 // Warning categories are by default implemented as strings, though
 // hook is left for a port to define them as something else.
 #if MICROPY_WARNINGS_CATEGORY
-# ifndef MP_WARN_CAT
-# define MP_WARN_CAT(x) #x
-# endif
+#ifndef MP_WARN_CAT
+#define MP_WARN_CAT(x) #x
+#endif
 #else
-# undef MP_WARN_CAT
-# define MP_WARN_CAT(x) (NULL)
+#undef MP_WARN_CAT
+#define MP_WARN_CAT(x) (NULL)
+#endif
+
+// Feature dependency check.
+#if MICROPY_PY_SYS_SETTRACE
+#if !MICROPY_PERSISTENT_CODE_SAVE
+#error "MICROPY_PY_SYS_SETTRACE requires MICROPY_PERSISTENT_CODE_SAVE to be enabled"
+#endif
+#if MICROPY_COMP_CONST
+#error "MICROPY_PY_SYS_SETTRACE requires MICROPY_COMP_CONST to be disabled"
+#endif
 #endif
 
 #endif // MICROPY_INCLUDED_PY_MPCONFIG_H
diff --git a/py/mphal.h b/py/mphal.h
index 92de01d08b913..66d80705a60ee 100644
--- a/py/mphal.h
+++ b/py/mphal.h
@@ -34,6 +34,10 @@
 #include <mphalport.h>
 #endif
 
+#ifndef mp_hal_stdio_poll
+uintptr_t mp_hal_stdio_poll(uintptr_t poll_flags);
+#endif
+
 #ifndef mp_hal_stdin_rx_chr
 int mp_hal_stdin_rx_chr(void);
 #endif
diff --git a/py/mpprint.c b/py/mpprint.c
index 82e78f62fae9b..c550c1d952f0a 100644
--- a/py/mpprint.c
+++ b/py/mpprint.c
@@ -269,14 +269,14 @@ int mp_print_mp_int(const mp_print_t *print, mp_obj_t x, int base, int base_char
         // We add the pad in this function, so since the pad goes after
         // the sign & prefix, we format without a prefix
         str = mp_obj_int_formatted(&buf, &buf_size, &fmt_size,
-                                   x, base, NULL, base_char, comma);
+            x, base, NULL, base_char, comma);
         if (*str == '-') {
             sign = *str++;
             fmt_size--;
         }
     } else {
         str = mp_obj_int_formatted(&buf, &buf_size, &fmt_size,
-                                   x, base, prefix, base_char, comma);
+            x, base, prefix, base_char, comma);
     }
 
     int spaces_before = 0;
@@ -347,8 +347,7 @@ int mp_print_float(const mp_print_t *print, mp_float_t f, char fmt, int flags, c
 
     if (flags & PF_FLAG_SHOW_SIGN) {
         sign = '+';
-    }
-    else
+    } else
     if (flags & PF_FLAG_SPACE_SIGN) {
         sign = ' ';
     }
@@ -411,14 +410,20 @@ int mp_vprintf(const mp_print_t *print, const char *fmt, va_list args) {
         int flags = 0;
         char fill = ' ';
         while (*fmt != '\0') {
-            if (*fmt == '-') flags |= PF_FLAG_LEFT_ADJUST;
-            else if (*fmt == '+') flags |= PF_FLAG_SHOW_SIGN;
-            else if (*fmt == ' ') flags |= PF_FLAG_SPACE_SIGN;
-            else if (*fmt == '!') flags |= PF_FLAG_NO_TRAILZ;
-            else if (*fmt == '0') {
+            if (*fmt == '-') {
+                flags |= PF_FLAG_LEFT_ADJUST;
+            } else if (*fmt == '+') {
+                flags |= PF_FLAG_SHOW_SIGN;
+            } else if (*fmt == ' ') {
+                flags |= PF_FLAG_SPACE_SIGN;
+            } else if (*fmt == '!') {
+                flags |= PF_FLAG_NO_TRAILZ;
+            } else if (*fmt == '0') {
                 flags |= PF_FLAG_PAD_AFTER_SIGN;
                 fill = '0';
-            } else break;
+            } else {
+                break;
+            }
             ++fmt;
         }
 
@@ -470,26 +475,23 @@ int mp_vprintf(const mp_print_t *print, const char *fmt, va_list args) {
                     chrs += mp_print_strn(print, "false", 5, flags, fill, width);
                 }
                 break;
-            case 'c':
-            {
+            case 'c': {
                 char str = va_arg(args, int);
                 chrs += mp_print_strn(print, &str, 1, flags, fill, width);
                 break;
             }
-            case 'q':
-            {
+            case 'q': {
                 qstr qst = va_arg(args, qstr);
                 size_t len;
-                const char *str = (const char*)qstr_data(qst, &len);
+                const char *str = (const char *)qstr_data(qst, &len);
                 if (prec < 0) {
                     prec = len;
                 }
                 chrs += mp_print_strn(print, str, prec, flags, fill, width);
                 break;
             }
-            case 's':
-            {
-                const char *str = va_arg(args, const char*);
+            case 's': {
+                const char *str = va_arg(args, const char *);
                 #ifndef NDEBUG
                 // With debugging enabled, catch printing of null string pointers
                 if (prec != 0 && str == NULL) {
@@ -503,22 +505,28 @@ int mp_vprintf(const mp_print_t *print, const char *fmt, va_list args) {
                 chrs += mp_print_strn(print, str, prec, flags, fill, width);
                 break;
             }
-            case 'u':
-                chrs += mp_print_int(print, va_arg(args, unsigned int), 0, 10, 'a', flags, fill, width);
-                break;
-            case 'd':
-                chrs += mp_print_int(print, va_arg(args, int), 1, 10, 'a', flags, fill, width);
+            case 'd': {
+                mp_int_t val;
+                if (long_arg) {
+                    val = va_arg(args, long int);
+                } else {
+                    val = va_arg(args, int);
+                }
+                chrs += mp_print_int(print, val, 1, 10, 'a', flags, fill, width);
                 break;
+            }
+            case 'u':
             case 'x':
             case 'X': {
-                char fmt_c = *fmt - 'X' + 'A';
+                int base = 16 - ((*fmt + 1) & 6); // maps char u/x/X to base 10/16/16
+                char fmt_c = (*fmt & 0xf0) - 'P' + 'A'; // maps char u/x/X to char a/a/A
                 mp_uint_t val;
                 if (long_arg) {
                     val = va_arg(args, unsigned long int);
                 } else {
                     val = va_arg(args, unsigned int);
                 }
-                chrs += mp_print_int(print, val, 0, 16, fmt_c, flags, fill, width);
+                chrs += mp_print_int(print, val, 0, base, fmt_c, flags, fill, width);
                 break;
             }
             case 'p':
@@ -526,26 +534,25 @@ int mp_vprintf(const mp_print_t *print, const char *fmt, va_list args) {
                 // Use unsigned long int to work on both ILP32 and LP64 systems
                 chrs += mp_print_int(print, va_arg(args, unsigned long int), 0, 16, 'a', flags, fill, width);
                 break;
-#if MICROPY_PY_BUILTINS_FLOAT
+            #if MICROPY_PY_BUILTINS_FLOAT
             case 'e':
             case 'E':
             case 'f':
             case 'F':
             case 'g':
-            case 'G':
-            {
-#if ((MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT) || (MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE))
-                mp_float_t f = va_arg(args, double);
+            case 'G': {
+                #if ((MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT) || (MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE))
+                mp_float_t f = (mp_float_t)va_arg(args, double);
                 chrs += mp_print_float(print, f, *fmt, flags, fill, width, prec);
-#else
-#error Unknown MICROPY FLOAT IMPL
-#endif
+                #else
+                #error Unknown MICROPY FLOAT IMPL
+                #endif
                 break;
             }
-#endif
-            // Because 'l' is eaten above, another 'l' means %ll.  We need to support
-            // this length specifier for OBJ_REPR_D (64-bit NaN boxing).
-            // TODO Either enable this unconditionally, or provide a specific config var.
+            #endif
+                // Because 'l' is eaten above, another 'l' means %ll.  We need to support
+                // this length specifier for OBJ_REPR_D (64-bit NaN boxing).
+                // TODO Either enable this unconditionally, or provide a specific config var.
             #if (MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D) || defined(_WIN64)
             case 'l': {
                 unsigned long long int arg_value = va_arg(args, unsigned long long int);
diff --git a/py/mpprint.h b/py/mpprint.h
index 07462bddcc962..aef9015deba30 100644
--- a/py/mpprint.h
+++ b/py/mpprint.h
@@ -40,9 +40,9 @@
 #define PF_FLAG_SHOW_OCTAL_LETTER (0x200)
 
 #if MICROPY_PY_IO && MICROPY_PY_SYS_STDFILES
-#    define MP_PYTHON_PRINTER &mp_sys_stdout_print
+#define MP_PYTHON_PRINTER &mp_sys_stdout_print
 #else
-#    define MP_PYTHON_PRINTER &mp_plat_print
+#define MP_PYTHON_PRINTER &mp_plat_print
 #endif
 
 typedef void (*mp_print_strn_t)(void *data, const char *str, size_t len);
diff --git a/py/mpstate.h b/py/mpstate.h
index a9c2b32d66e28..5f6cf55936a32 100644
--- a/py/mpstate.h
+++ b/py/mpstate.h
@@ -47,6 +47,7 @@ typedef struct mp_dynamic_compiler_t {
     bool opt_cache_map_lookup_in_bytecode;
     bool py_builtins_str_unicode;
     uint8_t native_arch;
+    uint8_t nlr_buf_num_regs;
 } mp_dynamic_compiler_t;
 extern mp_dynamic_compiler_t mp_dynamic_compiler;
 #endif
@@ -97,7 +98,7 @@ typedef struct _mp_state_mem_t {
     size_t gc_collected;
     #endif
 
-    #if MICROPY_PY_THREAD
+    #if MICROPY_PY_THREAD && !MICROPY_PY_THREAD_GIL
     // This is a global mutex used to make the GC thread-safe.
     mp_thread_mutex_t gc_mutex;
     #endif
@@ -141,7 +142,7 @@ typedef struct _mp_state_vm_t {
     volatile mp_obj_t mp_pending_exception;
 
     #if MICROPY_ENABLE_SCHEDULER
-    mp_sched_item_t sched_stack[MICROPY_SCHEDULER_DEPTH];
+    mp_sched_item_t sched_queue[MICROPY_SCHEDULER_DEPTH];
     #endif
 
     // current exception being handled, for sys.exc_info()
@@ -149,6 +150,11 @@ typedef struct _mp_state_vm_t {
     mp_obj_base_t *cur_exception;
     #endif
 
+    #if MICROPY_PY_SYS_ATEXIT
+    // exposed through sys.atexit function
+    mp_obj_t sys_exitfunc;
+    #endif
+
     // dictionary for the __main__ module
     mp_obj_dict_t dict_main;
 
@@ -183,6 +189,10 @@ typedef struct _mp_state_vm_t {
     struct _mp_vfs_mount_t *vfs_mount_table;
     #endif
 
+    #if MICROPY_PY_BLUETOOTH
+    mp_obj_t bluetooth;
+    #endif
+
     //
     // END ROOT POINTER SECTION
     ////////////////////////////////////////////////////////////
@@ -193,13 +203,16 @@ typedef struct _mp_state_vm_t {
     size_t qstr_last_alloc;
     size_t qstr_last_used;
 
-    #if MICROPY_PY_THREAD
+    #if MICROPY_PY_THREAD && !MICROPY_PY_THREAD_GIL
     // This is a global mutex used to make qstr interning thread-safe.
     mp_thread_mutex_t qstr_mutex;
     #endif
 
     #if MICROPY_ENABLE_COMPILER
     mp_uint_t mp_optimise_value;
+    #if MICROPY_EMIT_NATIVE
+    uint8_t default_emit_opt; // one of MP_EMIT_OPT_xxx
+    #endif
     #endif
 
     // size of the emergency exception buf, if it's dynamically allocated
@@ -245,6 +258,12 @@ typedef struct _mp_state_thread_t {
     mp_obj_dict_t *dict_globals;
 
     nlr_buf_t *nlr_top;
+
+    #if MICROPY_PY_SYS_SETTRACE
+    mp_obj_t prof_trace_callback;
+    bool prof_callback_is_executing;
+    struct _mp_code_state_t *current_code_state;
+    #endif
 } mp_state_thread_t;
 
 // This structure combines the above 3 structures.
diff --git a/py/mpthread.h b/py/mpthread.h
index 602df830c49ab..e611ef4c1197e 100644
--- a/py/mpthread.h
+++ b/py/mpthread.h
@@ -30,17 +30,17 @@
 
 #if MICROPY_PY_THREAD
 
+struct _mp_state_thread_t;
+
 #ifdef MICROPY_MPTHREADPORT_H
 #include MICROPY_MPTHREADPORT_H
 #else
 #include <mpthreadport.h>
 #endif
 
-struct _mp_state_thread_t;
-
 struct _mp_state_thread_t *mp_thread_get_state(void);
-void mp_thread_set_state(void *state);
-void mp_thread_create(void *(*entry)(void*), void *arg, size_t *stack_size);
+void mp_thread_set_state(struct _mp_state_thread_t *state);
+void mp_thread_create(void *(*entry)(void *), void *arg, size_t *stack_size);
 void mp_thread_start(void);
 void mp_thread_finish(void);
 void mp_thread_mutex_init(mp_thread_mutex_t *mutex);
diff --git a/py/mpz.c b/py/mpz.c
index 8687092d02128..b3d88067929fd 100644
--- a/py/mpz.c
+++ b/py/mpz.c
@@ -60,13 +60,21 @@ STATIC size_t mpn_remove_trailing_zeros(mpz_dig_t *oidig, mpz_dig_t *idig) {
    assumes i, j are normalised
 */
 STATIC int mpn_cmp(const mpz_dig_t *idig, size_t ilen, const mpz_dig_t *jdig, size_t jlen) {
-    if (ilen < jlen) { return -1; }
-    if (ilen > jlen) { return 1; }
+    if (ilen < jlen) {
+        return -1;
+    }
+    if (ilen > jlen) {
+        return 1;
+    }
 
     for (idig += ilen, jdig += ilen; ilen > 0; --ilen) {
         mpz_dbl_dig_signed_t cmp = (mpz_dbl_dig_t)*(--idig) - (mpz_dbl_dig_t)*(--jdig);
-        if (cmp < 0) { return -1; }
-        if (cmp > 0) { return 1; }
+        if (cmp < 0) {
+            return -1;
+        }
+        if (cmp > 0) {
+            return 1;
+        }
     }
 
     return 0;
@@ -228,7 +236,7 @@ STATIC size_t mpn_and(mpz_dig_t *idig, const mpz_dig_t *jdig, const mpz_dig_t *k
    can have i, j, k pointing to same memory
 */
 STATIC size_t mpn_and_neg(mpz_dig_t *idig, const mpz_dig_t *jdig, size_t jlen, const mpz_dig_t *kdig, size_t klen,
-                            mpz_dbl_dig_t carryi, mpz_dbl_dig_t carryj, mpz_dbl_dig_t carryk) {
+    mpz_dbl_dig_t carryi, mpz_dbl_dig_t carryj, mpz_dbl_dig_t carryk) {
     mpz_dig_t *oidig = idig;
     mpz_dig_t imask = (0 == carryi) ? 0 : DIG_MASK;
     mpz_dig_t jmask = (0 == carryj) ? 0 : DIG_MASK;
@@ -289,7 +297,7 @@ STATIC size_t mpn_or(mpz_dig_t *idig, const mpz_dig_t *jdig, size_t jlen, const
 #if MICROPY_OPT_MPZ_BITWISE
 
 STATIC size_t mpn_or_neg(mpz_dig_t *idig, const mpz_dig_t *jdig, size_t jlen, const mpz_dig_t *kdig, size_t klen,
-                            mpz_dbl_dig_t carryj, mpz_dbl_dig_t carryk) {
+    mpz_dbl_dig_t carryj, mpz_dbl_dig_t carryk) {
     mpz_dig_t *oidig = idig;
     mpz_dbl_dig_t carryi = 1;
     mpz_dig_t jmask = (0 == carryj) ? 0 : DIG_MASK;
@@ -319,7 +327,7 @@ STATIC size_t mpn_or_neg(mpz_dig_t *idig, const mpz_dig_t *jdig, size_t jlen, co
 #else
 
 STATIC size_t mpn_or_neg(mpz_dig_t *idig, const mpz_dig_t *jdig, size_t jlen, const mpz_dig_t *kdig, size_t klen,
-                            mpz_dbl_dig_t carryi, mpz_dbl_dig_t carryj, mpz_dbl_dig_t carryk) {
+    mpz_dbl_dig_t carryi, mpz_dbl_dig_t carryj, mpz_dbl_dig_t carryk) {
     mpz_dig_t *oidig = idig;
     mpz_dig_t imask = (0 == carryi) ? 0 : DIG_MASK;
     mpz_dig_t jmask = (0 == carryj) ? 0 : DIG_MASK;
@@ -378,7 +386,7 @@ STATIC size_t mpn_xor(mpz_dig_t *idig, const mpz_dig_t *jdig, size_t jlen, const
    can have i, j, k pointing to same memory
 */
 STATIC size_t mpn_xor_neg(mpz_dig_t *idig, const mpz_dig_t *jdig, size_t jlen, const mpz_dig_t *kdig, size_t klen,
-                              mpz_dbl_dig_t carryi, mpz_dbl_dig_t carryj, mpz_dbl_dig_t carryk) {
+    mpz_dbl_dig_t carryi, mpz_dbl_dig_t carryj, mpz_dbl_dig_t carryk) {
     mpz_dig_t *oidig = idig;
 
     for (; jlen > 0; ++idig, ++jdig) {
@@ -771,20 +779,7 @@ void mpz_set_from_ll(mpz_t *z, long long val, bool is_signed) {
 
 #if MICROPY_PY_BUILTINS_FLOAT
 void mpz_set_from_float(mpz_t *z, mp_float_t src) {
-#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
-typedef uint64_t mp_float_int_t;
-#elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
-typedef uint32_t mp_float_int_t;
-#endif
-    union {
-        mp_float_t f;
-        #if MP_ENDIANNESS_LITTLE
-        struct { mp_float_int_t frc:MP_FLOAT_FRAC_BITS, exp:MP_FLOAT_EXP_BITS, sgn:1; } p;
-        #else
-        struct { mp_float_int_t sgn:1, exp:MP_FLOAT_EXP_BITS, frc:MP_FLOAT_FRAC_BITS; } p;
-        #endif
-    } u = {src};
-
+    mp_float_union_t u = {src};
     z->neg = u.p.sgn;
     if (u.p.exp == 0) {
         // value == 0 || value < 1
@@ -806,7 +801,7 @@ typedef uint32_t mp_float_int_t;
             const int dig_cnt = (adj_exp + 1 + (DIG_SIZE - 1)) / DIG_SIZE;
             const unsigned int rem = adj_exp % DIG_SIZE;
             int dig_ind, shft;
-            mp_float_int_t frc = u.p.frc | ((mp_float_int_t)1 << MP_FLOAT_FRAC_BITS);
+            mp_float_uint_t frc = u.p.frc | ((mp_float_uint_t)1 << MP_FLOAT_FRAC_BITS);
 
             if (adj_exp < MP_FLOAT_FRAC_BITS) {
                 shft = 0;
@@ -825,16 +820,16 @@ typedef uint32_t mp_float_int_t;
                 z->dig[dig_ind++] = (frc << shft) & DIG_MASK;
                 frc >>= DIG_SIZE - shft;
             }
-#if DIG_SIZE < (MP_FLOAT_FRAC_BITS + 1)
+            #if DIG_SIZE < (MP_FLOAT_FRAC_BITS + 1)
             while (dig_ind != dig_cnt) {
                 z->dig[dig_ind++] = frc & DIG_MASK;
                 frc >>= DIG_SIZE;
             }
-#else
+            #else
             if (dig_ind != dig_cnt) {
                 z->dig[dig_ind] = frc;
             }
-#endif
+            #endif
         }
     }
 }
@@ -857,7 +852,7 @@ size_t mpz_set_from_str(mpz_t *z, const char *str, size_t len, bool neg, unsigne
 
     z->len = 0;
     for (; cur < top; ++cur) { // XXX UTF8 next char
-        //mp_uint_t v = char_to_numeric(cur#); // XXX UTF8 get char
+        // mp_uint_t v = char_to_numeric(cur#); // XXX UTF8 get char
         mp_uint_t v = *cur;
         if ('0' <= v && v <= '9') {
             v -= '0';
@@ -948,28 +943,48 @@ int mpz_cmp(const mpz_t *z1, const mpz_t *z2) {
 mp_int_t mpz_cmp_sml_int(const mpz_t *z, mp_int_t sml_int) {
     mp_int_t cmp;
     if (z->neg == 0) {
-        if (sml_int < 0) return 1;
+        if (sml_int < 0) {
+            return 1;
+        }
         if (sml_int == 0) {
-            if (z->len == 0) return 0;
+            if (z->len == 0) {
+                return 0;
+            }
             return 1;
         }
-        if (z->len == 0) return -1;
+        if (z->len == 0) {
+            return -1;
+        }
         assert(sml_int < (1 << DIG_SIZE));
-        if (z->len != 1) return 1;
+        if (z->len != 1) {
+            return 1;
+        }
         cmp = z->dig[0] - sml_int;
     } else {
-        if (sml_int > 0) return -1;
+        if (sml_int > 0) {
+            return -1;
+        }
         if (sml_int == 0) {
-            if (z->len == 0) return 0;
+            if (z->len == 0) {
+                return 0;
+            }
             return -1;
         }
-        if (z->len == 0) return 1;
+        if (z->len == 0) {
+            return 1;
+        }
         assert(sml_int > -(1 << DIG_SIZE));
-        if (z->len != 1) return -1;
+        if (z->len != 1) {
+            return -1;
+        }
         cmp = -z->dig[0] - sml_int;
     }
-    if (cmp < 0) return -1;
-    if (cmp > 0) return 1;
+    if (cmp < 0) {
+        return -1;
+    }
+    if (cmp > 0) {
+        return 1;
+    }
     return 0;
 }
 #endif
@@ -1207,7 +1222,7 @@ void mpz_and_inpl(mpz_t *dest, const mpz_t *lhs, const mpz_t *rhs) {
     } else {
         mpz_need_dig(dest, lhs->len + 1);
         dest->len = mpn_and_neg(dest->dig, lhs->dig, lhs->len, rhs->dig, rhs->len,
-                                 lhs->neg == rhs->neg, 0 != lhs->neg, 0 != rhs->neg);
+            lhs->neg == rhs->neg, 0 != lhs->neg, 0 != rhs->neg);
         dest->neg = lhs->neg & rhs->neg;
     }
 
@@ -1215,7 +1230,7 @@ void mpz_and_inpl(mpz_t *dest, const mpz_t *lhs, const mpz_t *rhs) {
 
     mpz_need_dig(dest, lhs->len + (lhs->neg || rhs->neg));
     dest->len = mpn_and_neg(dest->dig, lhs->dig, lhs->len, rhs->dig, rhs->len,
-                             (lhs->neg == rhs->neg) ? lhs->neg : 0, lhs->neg, rhs->neg);
+        (lhs->neg == rhs->neg) ? lhs->neg : 0, lhs->neg, rhs->neg);
     dest->neg = lhs->neg & rhs->neg;
 
     #endif
@@ -1241,7 +1256,7 @@ void mpz_or_inpl(mpz_t *dest, const mpz_t *lhs, const mpz_t *rhs) {
     } else {
         mpz_need_dig(dest, lhs->len + 1);
         dest->len = mpn_or_neg(dest->dig, lhs->dig, lhs->len, rhs->dig, rhs->len,
-                                 0 != lhs->neg, 0 != rhs->neg);
+            0 != lhs->neg, 0 != rhs->neg);
         dest->neg = 1;
     }
 
@@ -1249,7 +1264,7 @@ void mpz_or_inpl(mpz_t *dest, const mpz_t *lhs, const mpz_t *rhs) {
 
     mpz_need_dig(dest, lhs->len + (lhs->neg || rhs->neg));
     dest->len = mpn_or_neg(dest->dig, lhs->dig, lhs->len, rhs->dig, rhs->len,
-                             (lhs->neg || rhs->neg), lhs->neg, rhs->neg);
+        (lhs->neg || rhs->neg), lhs->neg, rhs->neg);
     dest->neg = lhs->neg | rhs->neg;
 
     #endif
@@ -1279,7 +1294,7 @@ void mpz_xor_inpl(mpz_t *dest, const mpz_t *lhs, const mpz_t *rhs) {
     } else {
         mpz_need_dig(dest, lhs->len + 1);
         dest->len = mpn_xor_neg(dest->dig, lhs->dig, lhs->len, rhs->dig, rhs->len, 1,
-                                0 == lhs->neg, 0 == rhs->neg);
+            0 == lhs->neg, 0 == rhs->neg);
         dest->neg = 1;
     }
 
@@ -1287,7 +1302,7 @@ void mpz_xor_inpl(mpz_t *dest, const mpz_t *lhs, const mpz_t *rhs) {
 
     mpz_need_dig(dest, lhs->len + (lhs->neg || rhs->neg));
     dest->len = mpn_xor_neg(dest->dig, lhs->dig, lhs->len, rhs->dig, rhs->len,
-                             (lhs->neg != rhs->neg), 0 == lhs->neg, 0 == rhs->neg);
+        (lhs->neg != rhs->neg), 0 == lhs->neg, 0 == rhs->neg);
     dest->neg = lhs->neg ^ rhs->neg;
 
     #endif
@@ -1376,7 +1391,8 @@ void mpz_pow3_inpl(mpz_t *dest, const mpz_t *lhs, const mpz_t *rhs, const mpz_t
 
     mpz_t *x = mpz_clone(lhs);
     mpz_t *n = mpz_clone(rhs);
-    mpz_t quo; mpz_init_zero(&quo);
+    mpz_t quo;
+    mpz_init_zero(&quo);
 
     while (n->len > 0) {
         if ((n->dig[0] & 1) != 0) {
@@ -1419,7 +1435,8 @@ mpz_t *mpz_gcd(const mpz_t *z1, const mpz_t *z2) {
 
     mpz_t *a = mpz_clone(z1);
     mpz_t *b = mpz_clone(z2);
-    mpz_t c; mpz_init_zero(&c);
+    mpz_t c;
+    mpz_init_zero(&c);
     a->neg = 0;
     b->neg = 0;
 
@@ -1430,7 +1447,9 @@ mpz_t *mpz_gcd(const mpz_t *z1, const mpz_t *z2) {
                 mpz_deinit(&c);
                 return b;
             }
-            mpz_t *t = a; a = b; b = t;
+            mpz_t *t = a;
+            a = b;
+            b = t;
         }
         if (!(b->len >= 2 || (b->len == 1 && b->dig[0] > 1))) { // compute b > 0; could be mpz_cmp_small_int(b, 1) > 0
             break;
@@ -1497,7 +1516,8 @@ void mpz_divmod_inpl(mpz_t *dest_quo, mpz_t *dest_rem, const mpz_t *lhs, const m
     if (lhs->neg != rhs->neg) {
         dest_quo->neg = 1;
         if (!mpz_is_zero(dest_rem)) {
-            mpz_t mpzone; mpz_init_from_int(&mpzone, -1);
+            mpz_t mpzone;
+            mpz_init_from_int(&mpzone, -1);
             mpz_add_inpl(dest_quo, dest_quo, &mpzone);
             mpz_add_inpl(dest_rem, dest_rem, rhs);
         }
@@ -1512,7 +1532,8 @@ these functions are unused
 */
 mpz_t *mpz_div(const mpz_t *lhs, const mpz_t *rhs) {
     mpz_t *quo = mpz_zero();
-    mpz_t rem; mpz_init_zero(&rem);
+    mpz_t rem;
+    mpz_init_zero(&rem);
     mpz_divmod_inpl(quo, &rem, lhs, rhs);
     mpz_deinit(&rem);
     return quo;
@@ -1522,7 +1543,8 @@ mpz_t *mpz_div(const mpz_t *lhs, const mpz_t *rhs) {
    can have lhs, rhs the same
 */
 mpz_t *mpz_mod(const mpz_t *lhs, const mpz_t *rhs) {
-    mpz_t quo; mpz_init_zero(&quo);
+    mpz_t quo;
+    mpz_init_zero(&quo);
     mpz_t *rem = mpz_zero();
     mpz_divmod_inpl(&quo, rem, lhs, rhs);
     mpz_deinit(&quo);
@@ -1659,8 +1681,9 @@ size_t mpz_as_str_inpl(const mpz_t *i, unsigned int base, const char *prefix, ch
     char *s = str;
     if (ilen == 0) {
         if (prefix) {
-            while (*prefix)
+            while (*prefix) {
                 *s++ = *prefix++;
+            }
         }
         *s++ = '0';
         *s = '\0';
diff --git a/py/mpz.h b/py/mpz.h
index 3c36cac66baa4..425587ee9b374 100644
--- a/py/mpz.h
+++ b/py/mpz.h
@@ -46,10 +46,10 @@
 
 #ifndef MPZ_DIG_SIZE
   #if defined(__x86_64__) || defined(_WIN64)
-    // 64-bit machine, using 32-bit storage for digits
+// 64-bit machine, using 32-bit storage for digits
     #define MPZ_DIG_SIZE (32)
   #else
-    // default: 32-bit machine, using 16-bit storage for digits
+// default: 32-bit machine, using 16-bit storage for digits
     #define MPZ_DIG_SIZE (16)
   #endif
 #endif
@@ -93,13 +93,13 @@ typedef int8_t mpz_dbl_dig_signed_t;
 typedef struct _mpz_t {
     size_t neg : 1;
     size_t fixed_dig : 1;
-    size_t alloc : 8 * sizeof(size_t) - 2;
+    size_t alloc : (8 * sizeof(size_t) - 2);
     size_t len;
     mpz_dig_t *dig;
 } mpz_t;
 
 // convenience macro to declare an mpz with a digit array from the stack, initialised by an integer
-#define MPZ_CONST_INT(z, val) mpz_t z; mpz_dig_t z ## _digits[MPZ_NUM_DIG_FOR_INT]; mpz_init_fixed_from_int(&z, z_digits, MPZ_NUM_DIG_FOR_INT, val);
+#define MPZ_CONST_INT(z, val) mpz_t z; mpz_dig_t z##_digits[MPZ_NUM_DIG_FOR_INT]; mpz_init_fixed_from_int(&z, z_digits, MPZ_NUM_DIG_FOR_INT, val);
 
 void mpz_init_zero(mpz_t *z);
 void mpz_init_from_int(mpz_t *z, mp_int_t val);
@@ -115,8 +115,12 @@ void mpz_set_from_float(mpz_t *z, mp_float_t src);
 size_t mpz_set_from_str(mpz_t *z, const char *str, size_t len, bool neg, unsigned int base);
 void mpz_set_from_bytes(mpz_t *z, bool big_endian, size_t len, const byte *buf);
 
-static inline bool mpz_is_zero(const mpz_t *z) { return z->len == 0; }
-static inline bool mpz_is_neg(const mpz_t *z) { return z->len != 0 && z->neg != 0; }
+static inline bool mpz_is_zero(const mpz_t *z) {
+    return z->len == 0;
+}
+static inline bool mpz_is_neg(const mpz_t *z) {
+    return z->len != 0 && z->neg != 0;
+}
 int mpz_cmp(const mpz_t *lhs, const mpz_t *rhs);
 
 void mpz_abs_inpl(mpz_t *dest, const mpz_t *z);
@@ -134,7 +138,9 @@ void mpz_or_inpl(mpz_t *dest, const mpz_t *lhs, const mpz_t *rhs);
 void mpz_xor_inpl(mpz_t *dest, const mpz_t *lhs, const mpz_t *rhs);
 void mpz_divmod_inpl(mpz_t *dest_quo, mpz_t *dest_rem, const mpz_t *lhs, const mpz_t *rhs);
 
-static inline size_t mpz_max_num_bits(const mpz_t *z) { return z->len * MPZ_DIG_SIZE; }
+static inline size_t mpz_max_num_bits(const mpz_t *z) {
+    return z->len * MPZ_DIG_SIZE;
+}
 mp_int_t mpz_hash(const mpz_t *z);
 bool mpz_as_int_checked(const mpz_t *z, mp_int_t *value);
 bool mpz_as_uint_checked(const mpz_t *z, mp_uint_t *value);
diff --git a/py/nativeglue.c b/py/nativeglue.c
index db54d12332931..30e5b40061beb 100644
--- a/py/nativeglue.c
+++ b/py/nativeglue.c
@@ -24,14 +24,15 @@
  * THE SOFTWARE.
  */
 
+#include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 #include <assert.h>
 
 #include "py/runtime.h"
 #include "py/smallint.h"
-#include "py/emitglue.h"
-#include "py/bc.h"
+#include "py/nativeglue.h"
+#include "py/gc.h"
 
 #if MICROPY_DEBUG_VERBOSE // print debugging info
 #define DEBUG_printf DEBUG_printf
@@ -43,15 +44,24 @@
 
 int mp_native_type_from_qstr(qstr qst) {
     switch (qst) {
-        case MP_QSTR_object: return MP_NATIVE_TYPE_OBJ;
-        case MP_QSTR_bool: return MP_NATIVE_TYPE_BOOL;
-        case MP_QSTR_int: return MP_NATIVE_TYPE_INT;
-        case MP_QSTR_uint: return MP_NATIVE_TYPE_UINT;
-        case MP_QSTR_ptr: return MP_NATIVE_TYPE_PTR;
-        case MP_QSTR_ptr8: return MP_NATIVE_TYPE_PTR8;
-        case MP_QSTR_ptr16: return MP_NATIVE_TYPE_PTR16;
-        case MP_QSTR_ptr32: return MP_NATIVE_TYPE_PTR32;
-        default: return -1;
+        case MP_QSTR_object:
+            return MP_NATIVE_TYPE_OBJ;
+        case MP_QSTR_bool:
+            return MP_NATIVE_TYPE_BOOL;
+        case MP_QSTR_int:
+            return MP_NATIVE_TYPE_INT;
+        case MP_QSTR_uint:
+            return MP_NATIVE_TYPE_UINT;
+        case MP_QSTR_ptr:
+            return MP_NATIVE_TYPE_PTR;
+        case MP_QSTR_ptr8:
+            return MP_NATIVE_TYPE_PTR8;
+        case MP_QSTR_ptr16:
+            return MP_NATIVE_TYPE_PTR16;
+        case MP_QSTR_ptr32:
+            return MP_NATIVE_TYPE_PTR32;
+        default:
+            return -1;
     }
 }
 
@@ -59,13 +69,16 @@ int mp_native_type_from_qstr(qstr qst) {
 mp_uint_t mp_native_from_obj(mp_obj_t obj, mp_uint_t type) {
     DEBUG_printf("mp_native_from_obj(%p, " UINT_FMT ")\n", obj, type);
     switch (type & 0xf) {
-        case MP_NATIVE_TYPE_OBJ: return (mp_uint_t)obj;
+        case MP_NATIVE_TYPE_OBJ:
+            return (mp_uint_t)obj;
         case MP_NATIVE_TYPE_BOOL:
+            return mp_obj_is_true(obj);
         case MP_NATIVE_TYPE_INT:
-        case MP_NATIVE_TYPE_UINT: return mp_obj_get_int_truncated(obj);
+        case MP_NATIVE_TYPE_UINT:
+            return mp_obj_get_int_truncated(obj);
         default: { // cast obj to a pointer
             mp_buffer_info_t bufinfo;
-            if (mp_get_buffer(obj, &bufinfo, MP_BUFFER_RW)) {
+            if (mp_get_buffer(obj, &bufinfo, MP_BUFFER_READ)) {
                 return (mp_uint_t)bufinfo.buf;
             } else {
                 // assume obj is an integer that represents an address
@@ -77,16 +90,20 @@ mp_uint_t mp_native_from_obj(mp_obj_t obj, mp_uint_t type) {
 
 #endif
 
-#if MICROPY_EMIT_NATIVE || MICROPY_EMIT_INLINE_ASM
+#if MICROPY_EMIT_MACHINE_CODE
 
 // convert a native value to a MicroPython object based on type
 mp_obj_t mp_native_to_obj(mp_uint_t val, mp_uint_t type) {
     DEBUG_printf("mp_native_to_obj(" UINT_FMT ", " UINT_FMT ")\n", val, type);
     switch (type & 0xf) {
-        case MP_NATIVE_TYPE_OBJ: return (mp_obj_t)val;
-        case MP_NATIVE_TYPE_BOOL: return mp_obj_new_bool(val);
-        case MP_NATIVE_TYPE_INT: return mp_obj_new_int(val);
-        case MP_NATIVE_TYPE_UINT: return mp_obj_new_int_from_uint(val);
+        case MP_NATIVE_TYPE_OBJ:
+            return (mp_obj_t)val;
+        case MP_NATIVE_TYPE_BOOL:
+            return mp_obj_new_bool(val);
+        case MP_NATIVE_TYPE_INT:
+            return mp_obj_new_int(val);
+        case MP_NATIVE_TYPE_UINT:
+            return mp_obj_new_int_from_uint(val);
         default: // a pointer
             // we return just the value of the pointer as an integer
             return mp_obj_new_int_from_uint(val);
@@ -95,9 +112,32 @@ mp_obj_t mp_native_to_obj(mp_uint_t val, mp_uint_t type) {
 
 #endif
 
-#if MICROPY_EMIT_NATIVE
+#if MICROPY_EMIT_NATIVE && !MICROPY_DYNAMIC_COMPILER
+
+#if !MICROPY_PY_BUILTINS_SET
+mp_obj_t mp_obj_new_set(size_t n_args, mp_obj_t *items) {
+    (void)n_args;
+    (void)items;
+    mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("set unsupported"));
+}
+
+void mp_obj_set_store(mp_obj_t self_in, mp_obj_t item) {
+    (void)self_in;
+    (void)item;
+    mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("set unsupported"));
+}
+#endif
 
-mp_obj_dict_t *mp_native_swap_globals(mp_obj_dict_t *new_globals) {
+#if !MICROPY_PY_BUILTINS_SLICE
+mp_obj_t mp_obj_new_slice(mp_obj_t ostart, mp_obj_t ostop, mp_obj_t ostep) {
+    (void)ostart;
+    (void)ostop;
+    (void)ostep;
+    mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("slice unsupported"));
+}
+#endif
+
+STATIC mp_obj_dict_t *mp_native_swap_globals(mp_obj_dict_t *new_globals) {
     if (new_globals == NULL) {
         // Globals were the originally the same so don't restore them
         return NULL;
@@ -113,13 +153,13 @@ mp_obj_dict_t *mp_native_swap_globals(mp_obj_dict_t *new_globals) {
 
 // wrapper that accepts n_args and n_kw in one argument
 // (native emitter can only pass at most 3 arguments to a function)
-mp_obj_t mp_native_call_function_n_kw(mp_obj_t fun_in, size_t n_args_kw, const mp_obj_t *args) {
+STATIC mp_obj_t mp_native_call_function_n_kw(mp_obj_t fun_in, size_t n_args_kw, const mp_obj_t *args) {
     return mp_call_function_n_kw(fun_in, n_args_kw & 0xff, (n_args_kw >> 8) & 0xff, args);
 }
 
 // wrapper that makes raise obj and raises it
 // END_FINALLY opcode requires that we don't raise if o==None
-void mp_native_raise(mp_obj_t o) {
+STATIC void mp_native_raise(mp_obj_t o) {
     if (o != MP_OBJ_NULL && o != mp_const_none) {
         nlr_raise(mp_make_raise_obj(o));
     }
@@ -187,11 +227,35 @@ STATIC bool mp_native_yield_from(mp_obj_t gen, mp_obj_t send_value, mp_obj_t *re
     return false;
 }
 
-// these must correspond to the respective enum in runtime0.h
-const void *const mp_fun_table[MP_F_NUMBER_OF] = {
-    &mp_const_none_obj,
-    &mp_const_false_obj,
-    &mp_const_true_obj,
+#if !MICROPY_PY_BUILTINS_FLOAT
+
+STATIC mp_obj_t mp_obj_new_float_from_f(float f) {
+    (void)f;
+    mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("float unsupported"));
+}
+
+STATIC mp_obj_t mp_obj_new_float_from_d(double d) {
+    (void)d;
+    mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("float unsupported"));
+}
+
+STATIC float mp_obj_get_float_to_f(mp_obj_t o) {
+    (void)o;
+    mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("float unsupported"));
+}
+
+STATIC double mp_obj_get_float_to_d(mp_obj_t o) {
+    (void)o;
+    mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("float unsupported"));
+}
+
+#endif
+
+// these must correspond to the respective enum in nativeglue.h
+const mp_fun_table_t mp_fun_table = {
+    mp_const_none,
+    mp_const_false,
+    mp_const_true,
     mp_native_from_obj,
     mp_native_to_obj,
     mp_native_swap_globals,
@@ -210,45 +274,74 @@ const void *const mp_fun_table[MP_F_NUMBER_OF] = {
     mp_binary_op,
     mp_obj_new_tuple,
     mp_obj_new_list,
-    mp_obj_list_append,
     mp_obj_new_dict,
-    mp_obj_dict_store,
-#if MICROPY_PY_BUILTINS_SET
-    mp_obj_set_store,
     mp_obj_new_set,
-#endif
+    mp_obj_set_store,
+    mp_obj_list_append,
+    mp_obj_dict_store,
     mp_make_function_from_raw_code,
     mp_native_call_function_n_kw,
     mp_call_method_n_kw,
     mp_call_method_n_kw_var,
     mp_native_getiter,
     mp_native_iternext,
+    #if MICROPY_NLR_SETJMP
+    nlr_push_tail,
+    #else
     nlr_push,
+    #endif
     nlr_pop,
     mp_native_raise,
     mp_import_name,
     mp_import_from,
     mp_import_all,
-#if MICROPY_PY_BUILTINS_SLICE
     mp_obj_new_slice,
-#endif
     mp_unpack_sequence,
     mp_unpack_ex,
     mp_delete_name,
     mp_delete_global,
-    mp_obj_new_cell,
     mp_make_closure_from_raw_code,
     mp_arg_check_num_sig,
     mp_setup_code_state,
     mp_small_int_floor_divide,
     mp_small_int_modulo,
     mp_native_yield_from,
+    #if MICROPY_NLR_SETJMP
+    setjmp,
+    #else
+    NULL,
+    #endif
+    // Additional entries for dynamic runtime, starts at index 50
+    memset,
+    memmove,
+    gc_realloc,
+    mp_printf,
+    mp_vprintf,
+    mp_raise_msg,
+    mp_obj_get_type,
+    mp_obj_new_str,
+    mp_obj_new_bytes,
+    mp_obj_new_bytearray_by_ref,
+    mp_obj_new_float_from_f,
+    mp_obj_new_float_from_d,
+    mp_obj_get_float_to_f,
+    mp_obj_get_float_to_d,
+    mp_get_buffer_raise,
+    mp_get_stream_raise,
+    &mp_plat_print,
+    &mp_type_type,
+    &mp_type_str,
+    &mp_type_list,
+    &mp_type_dict,
+    &mp_type_fun_builtin_0,
+    &mp_type_fun_builtin_1,
+    &mp_type_fun_builtin_2,
+    &mp_type_fun_builtin_3,
+    &mp_type_fun_builtin_var,
+    &mp_stream_read_obj,
+    &mp_stream_readinto_obj,
+    &mp_stream_unbuffered_readline_obj,
+    &mp_stream_write_obj,
 };
 
-/*
-void mp_f_vector(mp_fun_kind_t fun_kind) {
-    (mp_f_table[fun_kind])();
-}
-*/
-
 #endif // MICROPY_EMIT_NATIVE
diff --git a/py/nativeglue.h b/py/nativeglue.h
new file mode 100644
index 0000000000000..9d9a97b9e790e
--- /dev/null
+++ b/py/nativeglue.h
@@ -0,0 +1,177 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2019 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_PY_NATIVEGLUE_H
+#define MICROPY_INCLUDED_PY_NATIVEGLUE_H
+
+#include <stdarg.h>
+#include "py/obj.h"
+#include "py/persistentcode.h"
+#include "py/stream.h"
+
+typedef enum {
+    MP_F_CONST_NONE_OBJ = 0,
+    MP_F_CONST_FALSE_OBJ,
+    MP_F_CONST_TRUE_OBJ,
+    MP_F_CONVERT_OBJ_TO_NATIVE,
+    MP_F_CONVERT_NATIVE_TO_OBJ,
+    MP_F_NATIVE_SWAP_GLOBALS,
+    MP_F_LOAD_NAME,
+    MP_F_LOAD_GLOBAL,
+    MP_F_LOAD_BUILD_CLASS,
+    MP_F_LOAD_ATTR,
+    MP_F_LOAD_METHOD,
+    MP_F_LOAD_SUPER_METHOD,
+    MP_F_STORE_NAME,
+    MP_F_STORE_GLOBAL,
+    MP_F_STORE_ATTR,
+    MP_F_OBJ_SUBSCR,
+    MP_F_OBJ_IS_TRUE,
+    MP_F_UNARY_OP,
+    MP_F_BINARY_OP,
+    MP_F_BUILD_TUPLE,
+    MP_F_BUILD_LIST,
+    MP_F_BUILD_MAP,
+    MP_F_BUILD_SET,
+    MP_F_STORE_SET,
+    MP_F_LIST_APPEND,
+    MP_F_STORE_MAP,
+    MP_F_MAKE_FUNCTION_FROM_RAW_CODE,
+    MP_F_NATIVE_CALL_FUNCTION_N_KW,
+    MP_F_CALL_METHOD_N_KW,
+    MP_F_CALL_METHOD_N_KW_VAR,
+    MP_F_NATIVE_GETITER,
+    MP_F_NATIVE_ITERNEXT,
+    MP_F_NLR_PUSH,
+    MP_F_NLR_POP,
+    MP_F_NATIVE_RAISE,
+    MP_F_IMPORT_NAME,
+    MP_F_IMPORT_FROM,
+    MP_F_IMPORT_ALL,
+    MP_F_NEW_SLICE,
+    MP_F_UNPACK_SEQUENCE,
+    MP_F_UNPACK_EX,
+    MP_F_DELETE_NAME,
+    MP_F_DELETE_GLOBAL,
+    MP_F_MAKE_CLOSURE_FROM_RAW_CODE,
+    MP_F_ARG_CHECK_NUM_SIG,
+    MP_F_SETUP_CODE_STATE,
+    MP_F_SMALL_INT_FLOOR_DIVIDE,
+    MP_F_SMALL_INT_MODULO,
+    MP_F_NATIVE_YIELD_FROM,
+    MP_F_SETJMP,
+    MP_F_NUMBER_OF,
+} mp_fun_kind_t;
+
+typedef struct _mp_fun_table_t {
+    mp_const_obj_t const_none;
+    mp_const_obj_t const_false;
+    mp_const_obj_t const_true;
+    mp_uint_t (*native_from_obj)(mp_obj_t obj, mp_uint_t type);
+    mp_obj_t (*native_to_obj)(mp_uint_t val, mp_uint_t type);
+    mp_obj_dict_t *(*swap_globals)(mp_obj_dict_t * new_globals);
+    mp_obj_t (*load_name)(qstr qst);
+    mp_obj_t (*load_global)(qstr qst);
+    mp_obj_t (*load_build_class)(void);
+    mp_obj_t (*load_attr)(mp_obj_t base, qstr attr);
+    void (*load_method)(mp_obj_t base, qstr attr, mp_obj_t *dest);
+    void (*load_super_method)(qstr attr, mp_obj_t *dest);
+    void (*store_name)(qstr qst, mp_obj_t obj);
+    void (*store_global)(qstr qst, mp_obj_t obj);
+    void (*store_attr)(mp_obj_t base, qstr attr, mp_obj_t val);
+    mp_obj_t (*obj_subscr)(mp_obj_t base, mp_obj_t index, mp_obj_t val);
+    bool (*obj_is_true)(mp_obj_t arg);
+    mp_obj_t (*unary_op)(mp_unary_op_t op, mp_obj_t arg);
+    mp_obj_t (*binary_op)(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs);
+    mp_obj_t (*new_tuple)(size_t n, const mp_obj_t *items);
+    mp_obj_t (*new_list)(size_t n, mp_obj_t *items);
+    mp_obj_t (*new_dict)(size_t n_args);
+    mp_obj_t (*new_set)(size_t n_args, mp_obj_t *items);
+    void (*set_store)(mp_obj_t self_in, mp_obj_t item);
+    mp_obj_t (*list_append)(mp_obj_t self_in, mp_obj_t arg);
+    mp_obj_t (*dict_store)(mp_obj_t self_in, mp_obj_t key, mp_obj_t value);
+    mp_obj_t (*make_function_from_raw_code)(const mp_raw_code_t *rc, mp_obj_t def_args, mp_obj_t def_kw_args);
+    mp_obj_t (*call_function_n_kw)(mp_obj_t fun_in, size_t n_args_kw, const mp_obj_t *args);
+    mp_obj_t (*call_method_n_kw)(size_t n_args, size_t n_kw, const mp_obj_t *args);
+    mp_obj_t (*call_method_n_kw_var)(bool have_self, size_t n_args_n_kw, const mp_obj_t *args);
+    mp_obj_t (*getiter)(mp_obj_t obj, mp_obj_iter_buf_t *iter);
+    mp_obj_t (*iternext)(mp_obj_iter_buf_t *iter);
+    unsigned int (*nlr_push)(nlr_buf_t *);
+    void (*nlr_pop)(void);
+    void (*raise)(mp_obj_t o);
+    mp_obj_t (*import_name)(qstr name, mp_obj_t fromlist, mp_obj_t level);
+    mp_obj_t (*import_from)(mp_obj_t module, qstr name);
+    void (*import_all)(mp_obj_t module);
+    mp_obj_t (*new_slice)(mp_obj_t start, mp_obj_t stop, mp_obj_t step);
+    void (*unpack_sequence)(mp_obj_t seq, size_t num, mp_obj_t *items);
+    void (*unpack_ex)(mp_obj_t seq, size_t num, mp_obj_t *items);
+    void (*delete_name)(qstr qst);
+    void (*delete_global)(qstr qst);
+    mp_obj_t (*make_closure_from_raw_code)(const mp_raw_code_t *rc, mp_uint_t n_closed_over, const mp_obj_t *args);
+    void (*arg_check_num_sig)(size_t n_args, size_t n_kw, uint32_t sig);
+    void (*setup_code_state)(mp_code_state_t *code_state, size_t n_args, size_t n_kw, const mp_obj_t *args);
+    mp_int_t (*small_int_floor_divide)(mp_int_t num, mp_int_t denom);
+    mp_int_t (*small_int_modulo)(mp_int_t dividend, mp_int_t divisor);
+    bool (*yield_from)(mp_obj_t gen, mp_obj_t send_value, mp_obj_t *ret_value);
+    void *setjmp_;
+    // Additional entries for dynamic runtime, starts at index 50
+    void *(*memset_)(void *s, int c, size_t n);
+    void *(*memmove_)(void *dest, const void *src, size_t n);
+    void *(*realloc_)(void *ptr, size_t n_bytes, bool allow_move);
+    int (*printf_)(const mp_print_t *print, const char *fmt, ...);
+    int (*vprintf_)(const mp_print_t *print, const char *fmt, va_list args);
+    #if defined(__GNUC__)
+    NORETURN // Only certain compilers support no-return attributes in function pointer declarations
+    #endif
+    void (*raise_msg)(const mp_obj_type_t *exc_type, mp_rom_error_text_t msg);
+    const mp_obj_type_t *(*obj_get_type)(mp_const_obj_t o_in);
+    mp_obj_t (*obj_new_str)(const char *data, size_t len);
+    mp_obj_t (*obj_new_bytes)(const byte *data, size_t len);
+    mp_obj_t (*obj_new_bytearray_by_ref)(size_t n, void *items);
+    mp_obj_t (*obj_new_float_from_f)(float f);
+    mp_obj_t (*obj_new_float_from_d)(double d);
+    float (*obj_get_float_to_f)(mp_obj_t o);
+    double (*obj_get_float_to_d)(mp_obj_t o);
+    void (*get_buffer_raise)(mp_obj_t obj, mp_buffer_info_t *bufinfo, mp_uint_t flags);
+    const mp_stream_p_t *(*get_stream_raise)(mp_obj_t self_in, int flags);
+    const mp_print_t *plat_print;
+    const mp_obj_type_t *type_type;
+    const mp_obj_type_t *type_str;
+    const mp_obj_type_t *type_list;
+    const mp_obj_type_t *type_dict;
+    const mp_obj_type_t *type_fun_builtin_0;
+    const mp_obj_type_t *type_fun_builtin_1;
+    const mp_obj_type_t *type_fun_builtin_2;
+    const mp_obj_type_t *type_fun_builtin_3;
+    const mp_obj_type_t *type_fun_builtin_var;
+    const mp_obj_fun_builtin_var_t *stream_read_obj;
+    const mp_obj_fun_builtin_var_t *stream_readinto_obj;
+    const mp_obj_fun_builtin_var_t *stream_unbuffered_readline_obj;
+    const mp_obj_fun_builtin_var_t *stream_write_obj;
+} mp_fun_table_t;
+
+extern const mp_fun_table_t mp_fun_table;
+
+#endif // MICROPY_INCLUDED_PY_NATIVEGLUE_H
diff --git a/py/nlr.c b/py/nlr.c
index 03d01577e1419..a35e7d229c51e 100644
--- a/py/nlr.c
+++ b/py/nlr.c
@@ -30,7 +30,7 @@
 // When not using setjmp, nlr_push_tail is called from inline asm so needs special care
 #if MICROPY_NLR_X86 && MICROPY_NLR_OS_WINDOWS
 // On these 32-bit platforms make sure nlr_push_tail doesn't have a leading underscore
-unsigned int nlr_push_tail(nlr_buf_t *nlr) asm("nlr_push_tail");
+unsigned int nlr_push_tail(nlr_buf_t *nlr) asm ("nlr_push_tail");
 #else
 // LTO can't see inside inline asm functions so explicitly mark nlr_push_tail as used
 __attribute__((used)) unsigned int nlr_push_tail(nlr_buf_t *nlr);
diff --git a/py/nlr.h b/py/nlr.h
index 90595a12d37dc..f9fbf56e54e60 100644
--- a/py/nlr.h
+++ b/py/nlr.h
@@ -34,6 +34,16 @@
 
 #include "py/mpconfig.h"
 
+#define MICROPY_NLR_NUM_REGS_X86            (6)
+#define MICROPY_NLR_NUM_REGS_X64            (8)
+#define MICROPY_NLR_NUM_REGS_X64_WIN        (10)
+#define MICROPY_NLR_NUM_REGS_ARM_THUMB      (10)
+#define MICROPY_NLR_NUM_REGS_ARM_THUMB_FP   (10 + 6)
+#define MICROPY_NLR_NUM_REGS_XTENSA         (10)
+#define MICROPY_NLR_NUM_REGS_XTENSAWIN      (17)
+
+// *FORMAT-OFF*
+
 // If MICROPY_NLR_SETJMP is not enabled then auto-detect the machine arch
 #if !MICROPY_NLR_SETJMP
 // A lot of nlr-related things need different treatment on Windows
@@ -44,26 +54,39 @@
 #endif
 #if defined(__i386__)
     #define MICROPY_NLR_X86 (1)
-    #define MICROPY_NLR_NUM_REGS (6)
+    #define MICROPY_NLR_NUM_REGS (MICROPY_NLR_NUM_REGS_X86)
 #elif defined(__x86_64__)
     #define MICROPY_NLR_X64 (1)
     #if MICROPY_NLR_OS_WINDOWS
-        #define MICROPY_NLR_NUM_REGS (10)
+        #define MICROPY_NLR_NUM_REGS (MICROPY_NLR_NUM_REGS_X64_WIN)
     #else
-        #define MICROPY_NLR_NUM_REGS (8)
+        #define MICROPY_NLR_NUM_REGS (MICROPY_NLR_NUM_REGS_X64)
     #endif
 #elif defined(__thumb2__) || defined(__thumb__) || defined(__arm__)
     #define MICROPY_NLR_THUMB (1)
-    #define MICROPY_NLR_NUM_REGS (10)
+    #if defined(__SOFTFP__)
+        #define MICROPY_NLR_NUM_REGS (MICROPY_NLR_NUM_REGS_ARM_THUMB)
+    #else
+        // With hardware FP registers s16-s31 are callee save so in principle
+        // should be saved and restored by the NLR code.  gcc only uses s16-s21
+        // so only save/restore those as an optimisation.
+        #define MICROPY_NLR_NUM_REGS (MICROPY_NLR_NUM_REGS_ARM_THUMB_FP)
+    #endif
 #elif defined(__xtensa__)
     #define MICROPY_NLR_XTENSA (1)
-    #define MICROPY_NLR_NUM_REGS (10)
+    #define MICROPY_NLR_NUM_REGS (MICROPY_NLR_NUM_REGS_XTENSA)
+#elif defined(__powerpc__)
+    #define MICROPY_NLR_POWERPC (1)
+    // this could be less but using 128 for safety
+    #define MICROPY_NLR_NUM_REGS (128)
 #else
     #define MICROPY_NLR_SETJMP (1)
     //#warning "No native NLR support for this arch, using setjmp implementation"
 #endif
 #endif
 
+// *FORMAT-ON*
+
 #if MICROPY_NLR_SETJMP
 #include <setjmp.h>
 #endif
diff --git a/py/nlrpowerpc.c b/py/nlrpowerpc.c
new file mode 100644
index 0000000000000..940d8562e120c
--- /dev/null
+++ b/py/nlrpowerpc.c
@@ -0,0 +1,121 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019, Michael Neuling, IBM Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpstate.h"
+
+#if MICROPY_NLR_POWERPC
+
+#undef nlr_push
+
+// Saving all ABI non-vol registers here
+
+unsigned int nlr_push(nlr_buf_t *nlr) {
+
+    __asm__ volatile (
+        "li     4, 0x4eed ; "  // Store canary
+        "std    4,  0x00(%0) ;"
+        "std    0,  0x08(%0) ;"
+        "std    1,  0x10(%0) ;"
+        "std    2,  0x18(%0) ;"
+        "std    14, 0x20(%0) ;"
+        "std    15, 0x28(%0) ;"
+        "std    16, 0x30(%0) ;"
+        "std    17, 0x38(%0) ;"
+        "std    18, 0x40(%0) ;"
+        "std    19, 0x48(%0) ;"
+        "std    20, 0x50(%0) ;"
+        "std    21, 0x58(%0) ;"
+        "std    22, 0x60(%0) ;"
+        "std    23, 0x68(%0) ;"
+        "std    24, 0x70(%0) ;"
+        "std    25, 0x78(%0) ;"
+        "std    26, 0x80(%0) ;"
+        "std    27, 0x88(%0) ;"
+        "std    28, 0x90(%0) ;"
+        "std    29, 0x98(%0) ;"
+        "std    30, 0xA0(%0) ;"
+        "std    31, 0xA8(%0) ;"
+
+        "mfcr   4 ; "
+        "std    4, 0xB0(%0) ;"
+        "mflr   4 ;"
+        "std    4, 0xB8(%0) ;"
+        "li     4, nlr_push_tail@l ;"
+        "oris   4, 4, nlr_push_tail@h ;"
+        "mtctr  4 ;"
+        "mr    3, %1 ; "
+        "bctr  ;"
+        :
+        : "r" (&nlr->regs), "r" (nlr)
+        :
+        );
+
+    return 0;
+}
+
+NORETURN void nlr_jump(void *val) {
+    MP_NLR_JUMP_HEAD(val, top)
+
+    __asm__ volatile (
+        "ld    3, 0x0(%0) ;"
+        "cmpdi 3, 0x4eed ; " // Check canary
+        "bne   . ; "
+        "ld    0,  0x08(%0) ;"
+        "ld    1,  0x10(%0) ;"
+        "ld    2,  0x18(%0) ;"
+        "ld    14, 0x20(%0) ;"
+        "ld    15, 0x28(%0) ;"
+        "ld    16, 0x30(%0) ;"
+        "ld    17, 0x38(%0) ;"
+        "ld    18, 0x40(%0) ;"
+        "ld    19, 0x48(%0) ;"
+        "ld    20, 0x50(%0) ;"
+        "ld    21, 0x58(%0) ;"
+        "ld    22, 0x60(%0) ;"
+        "ld    23, 0x68(%0) ;"
+        "ld    24, 0x70(%0) ;"
+        "ld    25, 0x78(%0) ;"
+        "ld    26, 0x80(%0) ;"
+        "ld    27, 0x88(%0) ;"
+        "ld    28, 0x90(%0) ;"
+        "ld    29, 0x98(%0) ;"
+        "ld    30, 0xA0(%0) ;"
+        "ld    31, 0xA8(%0) ;"
+        "ld    3,  0xB0(%0) ;"
+        "mtcr  3 ;"
+        "ld    3, 0xB8(%0) ;"
+        "mtlr  3 ; "
+        "li    3, 1;"
+        "blr ;"
+        :
+        : "r" (&top->regs)
+        :
+        );
+
+    MP_UNREACHABLE;
+}
+
+#endif // MICROPY_NLR_POWERPC
diff --git a/py/nlrthumb.c b/py/nlrthumb.c
index 99061e62cd425..a8ffecc470335 100644
--- a/py/nlrthumb.c
+++ b/py/nlrthumb.c
@@ -39,46 +39,51 @@
 __attribute__((naked)) unsigned int nlr_push(nlr_buf_t *nlr) {
 
     __asm volatile (
-    "str    r4, [r0, #12]       \n" // store r4 into nlr_buf
-    "str    r5, [r0, #16]       \n" // store r5 into nlr_buf
-    "str    r6, [r0, #20]       \n" // store r6 into nlr_buf
-    "str    r7, [r0, #24]       \n" // store r7 into nlr_buf
+        "str    r4, [r0, #12]       \n" // store r4 into nlr_buf
+        "str    r5, [r0, #16]       \n" // store r5 into nlr_buf
+        "str    r6, [r0, #20]       \n" // store r6 into nlr_buf
+        "str    r7, [r0, #24]       \n" // store r7 into nlr_buf
 
-#if defined(__ARM_ARCH_6M__)
-    "mov    r1, r8              \n"
-    "str    r1, [r0, #28]       \n" // store r8 into nlr_buf
-    "mov    r1, r9              \n"
-    "str    r1, [r0, #32]       \n" // store r9 into nlr_buf
-    "mov    r1, r10             \n"
-    "str    r1, [r0, #36]       \n" // store r10 into nlr_buf
-    "mov    r1, r11             \n"
-    "str    r1, [r0, #40]       \n" // store r11 into nlr_buf
-    "mov    r1, r13             \n"
-    "str    r1, [r0, #44]       \n" // store r13=sp into nlr_buf
-    "mov    r1, lr              \n"
-    "str    r1, [r0, #8]        \n" // store lr into nlr_buf
-#else
-    "str    r8, [r0, #28]       \n" // store r8 into nlr_buf
-    "str    r9, [r0, #32]       \n" // store r9 into nlr_buf
-    "str    r10, [r0, #36]      \n" // store r10 into nlr_buf
-    "str    r11, [r0, #40]      \n" // store r11 into nlr_buf
-    "str    r13, [r0, #44]      \n" // store r13=sp into nlr_buf
-    "str    lr, [r0, #8]        \n" // store lr into nlr_buf
-#endif
+        #if !defined(__thumb2__)
+        "mov    r1, r8              \n"
+        "str    r1, [r0, #28]       \n" // store r8 into nlr_buf
+        "mov    r1, r9              \n"
+        "str    r1, [r0, #32]       \n" // store r9 into nlr_buf
+        "mov    r1, r10             \n"
+        "str    r1, [r0, #36]       \n" // store r10 into nlr_buf
+        "mov    r1, r11             \n"
+        "str    r1, [r0, #40]       \n" // store r11 into nlr_buf
+        "mov    r1, r13             \n"
+        "str    r1, [r0, #44]       \n" // store r13=sp into nlr_buf
+        "mov    r1, lr              \n"
+        "str    r1, [r0, #8]        \n" // store lr into nlr_buf
+        #else
+        "str    r8, [r0, #28]       \n" // store r8 into nlr_buf
+        "str    r9, [r0, #32]       \n" // store r9 into nlr_buf
+        "str    r10, [r0, #36]      \n" // store r10 into nlr_buf
+        "str    r11, [r0, #40]      \n" // store r11 into nlr_buf
+        "str    r13, [r0, #44]      \n" // store r13=sp into nlr_buf
+        #if MICROPY_NLR_NUM_REGS == 16
+        "vstr   d8, [r0, #48]       \n" // store s16-s17 into nlr_buf
+        "vstr   d9, [r0, #56]       \n" // store s18-s19 into nlr_buf
+        "vstr   d10, [r0, #64]      \n" // store s20-s21 into nlr_buf
+        #endif
+        "str    lr, [r0, #8]        \n" // store lr into nlr_buf
+        #endif
 
-#if defined(__ARM_ARCH_6M__)
-    "ldr    r1, nlr_push_tail_var \n"
-    "bx     r1                  \n" // do the rest in C
-    ".align 2                   \n"
-    "nlr_push_tail_var: .word nlr_push_tail \n"
-#else
-    #if defined(__APPLE__) || defined(__MACH__)
-    "b      _nlr_push_tail      \n" // do the rest in C
-    #else
-    "b      nlr_push_tail       \n" // do the rest in C
-    #endif
-#endif
-    );
+        #if !defined(__thumb2__)
+        "ldr    r1, nlr_push_tail_var \n"
+        "bx     r1                  \n" // do the rest in C
+        ".align 2                   \n"
+        "nlr_push_tail_var: .word nlr_push_tail \n"
+        #else
+        #if defined(__APPLE__) || defined(__MACH__)
+        "b      _nlr_push_tail      \n" // do the rest in C
+        #else
+        "b      nlr_push_tail       \n" // do the rest in C
+        #endif
+        #endif
+        );
 
     #if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8))
     // Older versions of gcc give an error when naked functions don't return a value
@@ -91,45 +96,46 @@ NORETURN void nlr_jump(void *val) {
     MP_NLR_JUMP_HEAD(val, top)
 
     __asm volatile (
-    "mov    r0, %0              \n" // r0 points to nlr_buf
-    "ldr    r4, [r0, #12]       \n" // load r4 from nlr_buf
-    "ldr    r5, [r0, #16]       \n" // load r5 from nlr_buf
-    "ldr    r6, [r0, #20]       \n" // load r6 from nlr_buf
-    "ldr    r7, [r0, #24]       \n" // load r7 from nlr_buf
+        "mov    r0, %0              \n" // r0 points to nlr_buf
+        "ldr    r4, [r0, #12]       \n" // load r4 from nlr_buf
+        "ldr    r5, [r0, #16]       \n" // load r5 from nlr_buf
+        "ldr    r6, [r0, #20]       \n" // load r6 from nlr_buf
+        "ldr    r7, [r0, #24]       \n" // load r7 from nlr_buf
 
-#if defined(__ARM_ARCH_6M__)
-    "ldr    r1, [r0, #28]       \n" // load r8 from nlr_buf
-    "mov    r8, r1              \n"
-    "ldr    r1, [r0, #32]       \n" // load r9 from nlr_buf
-    "mov    r9, r1              \n"
-    "ldr    r1, [r0, #36]       \n" // load r10 from nlr_buf
-    "mov    r10, r1             \n"
-    "ldr    r1, [r0, #40]       \n" // load r11 from nlr_buf
-    "mov    r11, r1             \n"
-    "ldr    r1, [r0, #44]       \n" // load r13=sp from nlr_buf
-    "mov    r13, r1             \n"
-    "ldr    r1, [r0, #8]        \n" // load lr from nlr_buf
-    "mov    lr, r1              \n"
-#else
-    "ldr    r8, [r0, #28]       \n" // load r8 from nlr_buf
-    "ldr    r9, [r0, #32]       \n" // load r9 from nlr_buf
-    "ldr    r10, [r0, #36]      \n" // load r10 from nlr_buf
-    "ldr    r11, [r0, #40]      \n" // load r11 from nlr_buf
-    "ldr    r13, [r0, #44]      \n" // load r13=sp from nlr_buf
-    "ldr    lr, [r0, #8]        \n" // load lr from nlr_buf
-#endif
-    "movs   r0, #1              \n" // return 1, non-local return
-    "bx     lr                  \n" // return
-    :                               // output operands
-    : "r"(top)                      // input operands
-    :                               // clobbered registers
-    );
+        #if !defined(__thumb2__)
+        "ldr    r1, [r0, #28]       \n" // load r8 from nlr_buf
+        "mov    r8, r1              \n"
+        "ldr    r1, [r0, #32]       \n" // load r9 from nlr_buf
+        "mov    r9, r1              \n"
+        "ldr    r1, [r0, #36]       \n" // load r10 from nlr_buf
+        "mov    r10, r1             \n"
+        "ldr    r1, [r0, #40]       \n" // load r11 from nlr_buf
+        "mov    r11, r1             \n"
+        "ldr    r1, [r0, #44]       \n" // load r13=sp from nlr_buf
+        "mov    r13, r1             \n"
+        "ldr    r1, [r0, #8]        \n" // load lr from nlr_buf
+        "mov    lr, r1              \n"
+        #else
+        "ldr    r8, [r0, #28]       \n" // load r8 from nlr_buf
+        "ldr    r9, [r0, #32]       \n" // load r9 from nlr_buf
+        "ldr    r10, [r0, #36]      \n" // load r10 from nlr_buf
+        "ldr    r11, [r0, #40]      \n" // load r11 from nlr_buf
+        "ldr    r13, [r0, #44]      \n" // load r13=sp from nlr_buf
+        #if MICROPY_NLR_NUM_REGS == 16
+        "vldr   d8, [r0, #48]       \n" // load s16-s17 from nlr_buf
+        "vldr   d9, [r0, #56]       \n" // load s18-s19 from nlr_buf
+        "vldr   d10, [r0, #64]      \n" // load s20-s21 from nlr_buf
+        #endif
+        "ldr    lr, [r0, #8]        \n" // load lr from nlr_buf
+        #endif
+        "movs   r0, #1              \n" // return 1, non-local return
+        "bx     lr                  \n" // return
+        :                           // output operands
+        : "r" (top)                 // input operands
+        :                           // clobbered registers
+        );
 
-    #if defined(__GNUC__)
-    __builtin_unreachable();
-    #else
-    for (;;); // needed to silence compiler warning
-    #endif
+    MP_UNREACHABLE
 }
 
 #endif // MICROPY_NLR_THUMB
diff --git a/py/nlrx64.c b/py/nlrx64.c
index a3a1cf341b916..eb39dadce72c1 100644
--- a/py/nlrx64.c
+++ b/py/nlrx64.c
@@ -41,41 +41,41 @@ unsigned int nlr_push(nlr_buf_t *nlr) {
     #if MICROPY_NLR_OS_WINDOWS
 
     __asm volatile (
-    "movq   (%rsp), %rax        \n" // load return %rip
-    "movq   %rax, 16(%rcx)      \n" // store %rip into nlr_buf
-    "movq   %rbp, 24(%rcx)      \n" // store %rbp into nlr_buf
-    "movq   %rsp, 32(%rcx)      \n" // store %rsp into nlr_buf
-    "movq   %rbx, 40(%rcx)      \n" // store %rbx into nlr_buf
-    "movq   %r12, 48(%rcx)      \n" // store %r12 into nlr_buf
-    "movq   %r13, 56(%rcx)      \n" // store %r13 into nlr_buf
-    "movq   %r14, 64(%rcx)      \n" // store %r14 into nlr_buf
-    "movq   %r15, 72(%rcx)      \n" // store %r15 into nlr_buf
-    "movq   %rdi, 80(%rcx)      \n" // store %rdr into nlr_buf
-    "movq   %rsi, 88(%rcx)      \n" // store %rsi into nlr_buf
-    "jmp    nlr_push_tail       \n" // do the rest in C
-    );
+        "movq   (%rsp), %rax        \n" // load return %rip
+        "movq   %rax, 16(%rcx)      \n" // store %rip into nlr_buf
+        "movq   %rbp, 24(%rcx)      \n" // store %rbp into nlr_buf
+        "movq   %rsp, 32(%rcx)      \n" // store %rsp into nlr_buf
+        "movq   %rbx, 40(%rcx)      \n" // store %rbx into nlr_buf
+        "movq   %r12, 48(%rcx)      \n" // store %r12 into nlr_buf
+        "movq   %r13, 56(%rcx)      \n" // store %r13 into nlr_buf
+        "movq   %r14, 64(%rcx)      \n" // store %r14 into nlr_buf
+        "movq   %r15, 72(%rcx)      \n" // store %r15 into nlr_buf
+        "movq   %rdi, 80(%rcx)      \n" // store %rdr into nlr_buf
+        "movq   %rsi, 88(%rcx)      \n" // store %rsi into nlr_buf
+        "jmp    nlr_push_tail       \n" // do the rest in C
+        );
 
     #else
 
     __asm volatile (
-    #if defined(__APPLE__) || defined(__MACH__)
-    "pop    %rbp                \n" // undo function's prelude
-    #endif
-    "movq   (%rsp), %rax        \n" // load return %rip
-    "movq   %rax, 16(%rdi)      \n" // store %rip into nlr_buf
-    "movq   %rbp, 24(%rdi)      \n" // store %rbp into nlr_buf
-    "movq   %rsp, 32(%rdi)      \n" // store %rsp into nlr_buf
-    "movq   %rbx, 40(%rdi)      \n" // store %rbx into nlr_buf
-    "movq   %r12, 48(%rdi)      \n" // store %r12 into nlr_buf
-    "movq   %r13, 56(%rdi)      \n" // store %r13 into nlr_buf
-    "movq   %r14, 64(%rdi)      \n" // store %r14 into nlr_buf
-    "movq   %r15, 72(%rdi)      \n" // store %r15 into nlr_buf
-    #if defined(__APPLE__) || defined(__MACH__)
-    "jmp    _nlr_push_tail      \n" // do the rest in C
-    #else
-    "jmp    nlr_push_tail       \n" // do the rest in C
-    #endif
-    );
+        #if defined(__APPLE__) || defined(__MACH__)
+        "pop    %rbp                \n" // undo function's prelude
+        #endif
+        "movq   (%rsp), %rax        \n" // load return %rip
+        "movq   %rax, 16(%rdi)      \n" // store %rip into nlr_buf
+        "movq   %rbp, 24(%rdi)      \n" // store %rbp into nlr_buf
+        "movq   %rsp, 32(%rdi)      \n" // store %rsp into nlr_buf
+        "movq   %rbx, 40(%rdi)      \n" // store %rbx into nlr_buf
+        "movq   %r12, 48(%rdi)      \n" // store %r12 into nlr_buf
+        "movq   %r13, 56(%rdi)      \n" // store %r13 into nlr_buf
+        "movq   %r14, 64(%rdi)      \n" // store %r14 into nlr_buf
+        "movq   %r15, 72(%rdi)      \n" // store %r15 into nlr_buf
+        #if defined(__APPLE__) || defined(__MACH__)
+        "jmp    _nlr_push_tail      \n" // do the rest in C
+        #else
+        "jmp    nlr_push_tail       \n" // do the rest in C
+        #endif
+        );
 
     #endif
 
@@ -86,29 +86,29 @@ NORETURN void nlr_jump(void *val) {
     MP_NLR_JUMP_HEAD(val, top)
 
     __asm volatile (
-    "movq   %0, %%rcx           \n" // %rcx points to nlr_buf
-    #if MICROPY_NLR_OS_WINDOWS
-    "movq   88(%%rcx), %%rsi    \n" // load saved %rsi
-    "movq   80(%%rcx), %%rdi    \n" // load saved %rdr
-    #endif
-    "movq   72(%%rcx), %%r15    \n" // load saved %r15
-    "movq   64(%%rcx), %%r14    \n" // load saved %r14
-    "movq   56(%%rcx), %%r13    \n" // load saved %r13
-    "movq   48(%%rcx), %%r12    \n" // load saved %r12
-    "movq   40(%%rcx), %%rbx    \n" // load saved %rbx
-    "movq   32(%%rcx), %%rsp    \n" // load saved %rsp
-    "movq   24(%%rcx), %%rbp    \n" // load saved %rbp
-    "movq   16(%%rcx), %%rax    \n" // load saved %rip
-    "movq   %%rax, (%%rsp)      \n" // store saved %rip to stack
-    "xorq   %%rax, %%rax        \n" // clear return register
-    "inc    %%al                \n" // increase to make 1, non-local return
-    "ret                        \n" // return
-    :                               // output operands
-    : "r"(top)                      // input operands
-    :                               // clobbered registers
-    );
-
-    for (;;); // needed to silence compiler warning
+        "movq   %0, %%rcx           \n" // %rcx points to nlr_buf
+        #if MICROPY_NLR_OS_WINDOWS
+        "movq   88(%%rcx), %%rsi    \n" // load saved %rsi
+        "movq   80(%%rcx), %%rdi    \n" // load saved %rdr
+        #endif
+        "movq   72(%%rcx), %%r15    \n" // load saved %r15
+        "movq   64(%%rcx), %%r14    \n" // load saved %r14
+        "movq   56(%%rcx), %%r13    \n" // load saved %r13
+        "movq   48(%%rcx), %%r12    \n" // load saved %r12
+        "movq   40(%%rcx), %%rbx    \n" // load saved %rbx
+        "movq   32(%%rcx), %%rsp    \n" // load saved %rsp
+        "movq   24(%%rcx), %%rbp    \n" // load saved %rbp
+        "movq   16(%%rcx), %%rax    \n" // load saved %rip
+        "movq   %%rax, (%%rsp)      \n" // store saved %rip to stack
+        "xorq   %%rax, %%rax        \n" // clear return register
+        "inc    %%al                \n" // increase to make 1, non-local return
+        "ret                        \n" // return
+        :                           // output operands
+        : "r" (top)                 // input operands
+        :                           // clobbered registers
+        );
+
+    MP_UNREACHABLE
 }
 
 #endif // MICROPY_NLR_X64
diff --git a/py/nlrx86.c b/py/nlrx86.c
index 59b97d8ee6a9a..f658d41910c8d 100644
--- a/py/nlrx86.c
+++ b/py/nlrx86.c
@@ -34,7 +34,7 @@
 //  ebx, esi, edi, ebp, esp, eip
 
 #if MICROPY_NLR_OS_WINDOWS
-unsigned int nlr_push_tail(nlr_buf_t *nlr) asm("nlr_push_tail");
+unsigned int nlr_push_tail(nlr_buf_t *nlr) asm ("nlr_push_tail");
 #else
 __attribute__((used)) unsigned int nlr_push_tail(nlr_buf_t *nlr);
 #endif
@@ -56,24 +56,22 @@ __attribute__((used)) unsigned int nlr_push_tail(nlr_buf_t *nlr);
 __attribute__((naked))
 #endif
 unsigned int nlr_push(nlr_buf_t *nlr) {
-    #if !USE_NAKED
     (void)nlr;
-    #endif
 
     __asm volatile (
-    #if UNDO_PRELUDE
-    "pop    %ebp                \n" // undo function's prelude
-    #endif
-    "mov    4(%esp), %edx       \n" // load nlr_buf
-    "mov    (%esp), %eax        \n" // load return %eip
-    "mov    %eax, 8(%edx)       \n" // store %eip into nlr_buf
-    "mov    %ebp, 12(%edx)      \n" // store %ebp into nlr_buf
-    "mov    %esp, 16(%edx)      \n" // store %esp into nlr_buf
-    "mov    %ebx, 20(%edx)      \n" // store %ebx into nlr_buf
-    "mov    %edi, 24(%edx)      \n" // store %edi into nlr_buf
-    "mov    %esi, 28(%edx)      \n" // store %esi into nlr_buf
-    "jmp    nlr_push_tail       \n" // do the rest in C
-    );
+        #if UNDO_PRELUDE
+        "pop    %ebp                \n" // undo function's prelude
+        #endif
+        "mov    4(%esp), %edx       \n" // load nlr_buf
+        "mov    (%esp), %eax        \n" // load return %eip
+        "mov    %eax, 8(%edx)       \n" // store %eip into nlr_buf
+        "mov    %ebp, 12(%edx)      \n" // store %ebp into nlr_buf
+        "mov    %esp, 16(%edx)      \n" // store %esp into nlr_buf
+        "mov    %ebx, 20(%edx)      \n" // store %ebx into nlr_buf
+        "mov    %edi, 24(%edx)      \n" // store %edi into nlr_buf
+        "mov    %esi, 28(%edx)      \n" // store %esi into nlr_buf
+        "jmp    nlr_push_tail       \n" // do the rest in C
+        );
 
     #if !USE_NAKED
     return 0; // needed to silence compiler warning
@@ -84,23 +82,23 @@ NORETURN void nlr_jump(void *val) {
     MP_NLR_JUMP_HEAD(val, top)
 
     __asm volatile (
-    "mov    %0, %%edx           \n" // %edx points to nlr_buf
-    "mov    28(%%edx), %%esi    \n" // load saved %esi
-    "mov    24(%%edx), %%edi    \n" // load saved %edi
-    "mov    20(%%edx), %%ebx    \n" // load saved %ebx
-    "mov    16(%%edx), %%esp    \n" // load saved %esp
-    "mov    12(%%edx), %%ebp    \n" // load saved %ebp
-    "mov    8(%%edx), %%eax     \n" // load saved %eip
-    "mov    %%eax, (%%esp)      \n" // store saved %eip to stack
-    "xor    %%eax, %%eax        \n" // clear return register
-    "inc    %%al                \n" // increase to make 1, non-local return
-    "ret                        \n" // return
-    :                               // output operands
-    : "r"(top)                      // input operands
-    :                               // clobbered registers
-    );
+        "mov    %0, %%edx           \n" // %edx points to nlr_buf
+        "mov    28(%%edx), %%esi    \n" // load saved %esi
+        "mov    24(%%edx), %%edi    \n" // load saved %edi
+        "mov    20(%%edx), %%ebx    \n" // load saved %ebx
+        "mov    16(%%edx), %%esp    \n" // load saved %esp
+        "mov    12(%%edx), %%ebp    \n" // load saved %ebp
+        "mov    8(%%edx), %%eax     \n" // load saved %eip
+        "mov    %%eax, (%%esp)      \n" // store saved %eip to stack
+        "xor    %%eax, %%eax        \n" // clear return register
+        "inc    %%al                \n" // increase to make 1, non-local return
+        "ret                        \n" // return
+        :                           // output operands
+        : "r" (top)                 // input operands
+        :                           // clobbered registers
+        );
 
-    for (;;); // needed to silence compiler warning
+    MP_UNREACHABLE
 }
 
 #endif // MICROPY_NLR_X86
diff --git a/py/nlrxtensa.c b/py/nlrxtensa.c
index cd3dee364c23c..abe9042af9f17 100644
--- a/py/nlrxtensa.c
+++ b/py/nlrxtensa.c
@@ -39,18 +39,18 @@
 unsigned int nlr_push(nlr_buf_t *nlr) {
 
     __asm volatile (
-    "s32i.n  a0, a2, 8          \n" // save regs...
-    "s32i.n  a1, a2, 12         \n"
-    "s32i.n  a8, a2, 16         \n"
-    "s32i.n  a9, a2, 20         \n"
-    "s32i.n  a10, a2, 24        \n"
-    "s32i.n  a11, a2, 28        \n"
-    "s32i.n  a12, a2, 32        \n"
-    "s32i.n  a13, a2, 36        \n"
-    "s32i.n  a14, a2, 40        \n"
-    "s32i.n  a15, a2, 44        \n"
-    "j      nlr_push_tail       \n" // do the rest in C
-    );
+        "s32i.n  a0, a2, 8          \n" // save regs...
+        "s32i.n  a1, a2, 12         \n"
+        "s32i.n  a8, a2, 16         \n"
+        "s32i.n  a9, a2, 20         \n"
+        "s32i.n  a10, a2, 24        \n"
+        "s32i.n  a11, a2, 28        \n"
+        "s32i.n  a12, a2, 32        \n"
+        "s32i.n  a13, a2, 36        \n"
+        "s32i.n  a14, a2, 40        \n"
+        "s32i.n  a15, a2, 44        \n"
+        "j      nlr_push_tail       \n" // do the rest in C
+        );
 
     return 0; // needed to silence compiler warning
 }
@@ -59,25 +59,25 @@ NORETURN void nlr_jump(void *val) {
     MP_NLR_JUMP_HEAD(val, top)
 
     __asm volatile (
-    "mov.n   a2, %0             \n" // a2 points to nlr_buf
-    "l32i.n  a0, a2, 8          \n" // restore regs...
-    "l32i.n  a1, a2, 12         \n"
-    "l32i.n  a8, a2, 16         \n"
-    "l32i.n  a9, a2, 20         \n"
-    "l32i.n  a10, a2, 24        \n"
-    "l32i.n  a11, a2, 28        \n"
-    "l32i.n  a12, a2, 32        \n"
-    "l32i.n  a13, a2, 36        \n"
-    "l32i.n  a14, a2, 40        \n"
-    "l32i.n  a15, a2, 44        \n"
-    "movi.n a2, 1               \n" // return 1, non-local return
-    "ret.n                      \n" // return
-    :                               // output operands
-    : "r"(top)                      // input operands
-    :                               // clobbered registers
-    );
+        "mov.n   a2, %0             \n" // a2 points to nlr_buf
+        "l32i.n  a0, a2, 8          \n" // restore regs...
+        "l32i.n  a1, a2, 12         \n"
+        "l32i.n  a8, a2, 16         \n"
+        "l32i.n  a9, a2, 20         \n"
+        "l32i.n  a10, a2, 24        \n"
+        "l32i.n  a11, a2, 28        \n"
+        "l32i.n  a12, a2, 32        \n"
+        "l32i.n  a13, a2, 36        \n"
+        "l32i.n  a14, a2, 40        \n"
+        "l32i.n  a15, a2, 44        \n"
+        "movi.n a2, 1               \n" // return 1, non-local return
+        "ret.n                      \n" // return
+        :                           // output operands
+        : "r" (top)                 // input operands
+        :                           // clobbered registers
+        );
 
-    for (;;); // needed to silence compiler warning
+    MP_UNREACHABLE
 }
 
 #endif // MICROPY_NLR_XTENSA
diff --git a/py/obj.c b/py/obj.c
index 122f0ea624558..07b1612552548 100644
--- a/py/obj.c
+++ b/py/obj.c
@@ -37,19 +37,62 @@
 #include "py/stackctrl.h"
 #include "py/stream.h" // for mp_obj_print
 
-mp_obj_type_t *mp_obj_get_type(mp_const_obj_t o_in) {
+const mp_obj_type_t *mp_obj_get_type(mp_const_obj_t o_in) {
+    #if MICROPY_OBJ_IMMEDIATE_OBJS && MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A
+
+    if (mp_obj_is_obj(o_in)) {
+        const mp_obj_base_t *o = MP_OBJ_TO_PTR(o_in);
+        return o->type;
+    } else {
+        static const mp_obj_type_t *const types[] = {
+            NULL, &mp_type_int, &mp_type_str, &mp_type_int,
+            NULL, &mp_type_int, &mp_type_NoneType, &mp_type_int,
+            NULL, &mp_type_int, &mp_type_str, &mp_type_int,
+            NULL, &mp_type_int, &mp_type_bool, &mp_type_int,
+        };
+        return types[(uintptr_t)o_in & 0xf];
+    }
+
+    #elif MICROPY_OBJ_IMMEDIATE_OBJS && MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
+
     if (mp_obj_is_small_int(o_in)) {
-        return (mp_obj_type_t*)&mp_type_int;
-    } else if (mp_obj_is_qstr(o_in)) {
-        return (mp_obj_type_t*)&mp_type_str;
+        return &mp_type_int;
+    } else if (mp_obj_is_obj(o_in)) {
+        const mp_obj_base_t *o = MP_OBJ_TO_PTR(o_in);
+        return o->type;
     #if MICROPY_PY_BUILTINS_FLOAT
+    } else if ((((mp_uint_t)(o_in)) & 0xff800007) != 0x00000006) {
+        return &mp_type_float;
+    #endif
+    } else {
+        static const mp_obj_type_t *const types[] = {
+            &mp_type_str, &mp_type_NoneType, &mp_type_str, &mp_type_bool,
+        };
+        return types[((uintptr_t)o_in >> 3) & 3];
+    }
+
+    #else
+
+    if (mp_obj_is_small_int(o_in)) {
+        return &mp_type_int;
+    } else if (mp_obj_is_qstr(o_in)) {
+        return &mp_type_str;
+        #if MICROPY_PY_BUILTINS_FLOAT && ( \
+            MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D)
     } else if (mp_obj_is_float(o_in)) {
-        return (mp_obj_type_t*)&mp_type_float;
+        return &mp_type_float;
+        #endif
+    #if MICROPY_OBJ_IMMEDIATE_OBJS
+    } else if (mp_obj_is_immediate_obj(o_in)) {
+        static const mp_obj_type_t *const types[2] = {&mp_type_NoneType, &mp_type_bool};
+        return types[MP_OBJ_IMMEDIATE_OBJ_VALUE(o_in) & 1];
     #endif
     } else {
         const mp_obj_base_t *o = MP_OBJ_TO_PTR(o_in);
-        return (mp_obj_type_t*)o->type;
+        return o->type;
     }
+
+    #endif
 }
 
 const char *mp_obj_get_type_str(mp_const_obj_t o_in) {
@@ -59,15 +102,15 @@ const char *mp_obj_get_type_str(mp_const_obj_t o_in) {
 void mp_obj_print_helper(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t kind) {
     // There can be data structures nested too deep, or just recursive
     MP_STACK_CHECK();
-#ifndef NDEBUG
+    #ifndef NDEBUG
     if (o_in == MP_OBJ_NULL) {
         mp_print_str(print, "(nil)");
         return;
     }
-#endif
-    mp_obj_type_t *type = mp_obj_get_type(o_in);
+    #endif
+    const mp_obj_type_t *type = mp_obj_get_type(o_in);
     if (type->print != NULL) {
-        type->print((mp_print_t*)print, o_in, kind);
+        type->print((mp_print_t *)print, o_in, kind);
     } else {
         mp_printf(print, "<%q>", type->name);
     }
@@ -86,14 +129,14 @@ void mp_obj_print_exception(const mp_print_t *print, mp_obj_t exc) {
             assert(n % 3 == 0);
             mp_print_str(print, "Traceback (most recent call last):\n");
             for (int i = n - 3; i >= 0; i -= 3) {
-#if MICROPY_ENABLE_SOURCE_LINE
+                #if MICROPY_ENABLE_SOURCE_LINE
                 mp_printf(print, "  File \"%q\", line %d", values[i], (int)values[i + 1]);
-#else
+                #else
                 mp_printf(print, "  File \"%q\"", values[i]);
-#endif
+                #endif
                 // the block name can be NULL if it's unknown
                 qstr block = values[i + 2];
-                if (block == MP_QSTR_NULL) {
+                if (block == MP_QSTRnull) {
                     mp_print_str(print, "\n");
                 } else {
                     mp_printf(print, ", in %q\n", block);
@@ -113,13 +156,13 @@ bool mp_obj_is_true(mp_obj_t arg) {
     } else if (arg == mp_const_none) {
         return 0;
     } else if (mp_obj_is_small_int(arg)) {
-        if (MP_OBJ_SMALL_INT_VALUE(arg) == 0) {
+        if (arg == MP_OBJ_NEW_SMALL_INT(0)) {
             return 0;
         } else {
             return 1;
         }
     } else {
-        mp_obj_type_t *type = mp_obj_get_type(arg);
+        const mp_obj_type_t *type = mp_obj_get_type(arg);
         if (type->unary_op != NULL) {
             mp_obj_t result = type->unary_op(MP_UNARY_OP_BOOL, arg);
             if (result != MP_OBJ_NULL) {
@@ -139,14 +182,14 @@ bool mp_obj_is_true(mp_obj_t arg) {
 }
 
 bool mp_obj_is_callable(mp_obj_t o_in) {
-    mp_call_fun_t call = mp_obj_get_type(o_in)->call;
+    const mp_call_fun_t call = mp_obj_get_type(o_in)->call;
     if (call != mp_obj_instance_call) {
         return call != NULL;
     }
     return mp_obj_instance_is_callable(o_in);
 }
 
-// This function implements the '==' operator (and so the inverse of '!=').
+// This function implements the '==' and '!=' operators.
 //
 // From the Python language reference:
 // (https://docs.python.org/3/reference/expressions.html#not-in)
@@ -159,67 +202,89 @@ bool mp_obj_is_callable(mp_obj_t o_in) {
 // Furthermore, from the v3.4.2 code for object.c: "Practical amendments: If rich
 // comparison returns NotImplemented, == and != are decided by comparing the object
 // pointer."
-bool mp_obj_equal(mp_obj_t o1, mp_obj_t o2) {
-    // Float (and complex) NaN is never equal to anything, not even itself,
-    // so we must have a special check here to cover those cases.
-    if (o1 == o2
-        #if MICROPY_PY_BUILTINS_FLOAT
-        && !mp_obj_is_float(o1)
-        #endif
-        #if MICROPY_PY_BUILTINS_COMPLEX
-        && !mp_obj_is_type(o1, &mp_type_complex)
-        #endif
-        ) {
-        return true;
-    }
-    if (o1 == mp_const_none || o2 == mp_const_none) {
-        return false;
-    }
-
-    // fast path for small ints
-    if (mp_obj_is_small_int(o1)) {
-        if (mp_obj_is_small_int(o2)) {
-            // both SMALL_INT, and not equal if we get here
-            return false;
-        } else {
-            mp_obj_t temp = o2; o2 = o1; o1 = temp;
-            // o2 is now the SMALL_INT, o1 is not
-            // fall through to generic op
-        }
+mp_obj_t mp_obj_equal_not_equal(mp_binary_op_t op, mp_obj_t o1, mp_obj_t o2) {
+    mp_obj_t local_true = (op == MP_BINARY_OP_NOT_EQUAL) ? mp_const_false : mp_const_true;
+    mp_obj_t local_false = (op == MP_BINARY_OP_NOT_EQUAL) ? mp_const_true : mp_const_false;
+    int pass_number = 0;
+
+    // Shortcut for very common cases
+    if (o1 == o2 &&
+        (mp_obj_is_small_int(o1) || !(mp_obj_get_type(o1)->flags & MP_TYPE_FLAG_EQ_NOT_REFLEXIVE))) {
+        return local_true;
     }
 
     // fast path for strings
     if (mp_obj_is_str(o1)) {
         if (mp_obj_is_str(o2)) {
             // both strings, use special function
-            return mp_obj_str_equal(o1, o2);
+            return mp_obj_str_equal(o1, o2) ? local_true : local_false;
+        #if MICROPY_PY_STR_BYTES_CMP_WARN
+        } else if (mp_obj_is_type(o2, &mp_type_bytes)) {
+        str_bytes_cmp:
+            mp_warning(MP_WARN_CAT(BytesWarning), "Comparison between bytes and str");
+            return local_false;
+        #endif
         } else {
-            // a string is never equal to anything else
-            goto str_cmp_err;
+            goto skip_one_pass;
         }
-    } else if (mp_obj_is_str(o2)) {
+    #if MICROPY_PY_STR_BYTES_CMP_WARN
+    } else if (mp_obj_is_str(o2) && mp_obj_is_type(o1, &mp_type_bytes)) {
         // o1 is not a string (else caught above), so the objects are not equal
-    str_cmp_err:
-        #if MICROPY_PY_STR_BYTES_CMP_WARN
-        if (mp_obj_is_type(o1, &mp_type_bytes) || mp_obj_is_type(o2, &mp_type_bytes)) {
-            mp_warning(MP_WARN_CAT(BytesWarning), "Comparison between bytes and str");
+        goto str_bytes_cmp;
+    #endif
+    }
+
+    // fast path for small ints
+    if (mp_obj_is_small_int(o1)) {
+        if (mp_obj_is_small_int(o2)) {
+            // both SMALL_INT, and not equal if we get here
+            return local_false;
+        } else {
+            goto skip_one_pass;
         }
-        #endif
-        return false;
     }
 
     // generic type, call binary_op(MP_BINARY_OP_EQUAL)
-    mp_obj_type_t *type = mp_obj_get_type(o1);
-    if (type->binary_op != NULL) {
-        mp_obj_t r = type->binary_op(MP_BINARY_OP_EQUAL, o1, o2);
-        if (r != MP_OBJ_NULL) {
-            return r == mp_const_true ? true : false;
+    while (pass_number < 2) {
+        const mp_obj_type_t *type = mp_obj_get_type(o1);
+        // If a full equality test is not needed and the other object is a different
+        // type then we don't need to bother trying the comparison.
+        if (type->binary_op != NULL &&
+            ((type->flags & MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE) || mp_obj_get_type(o2) == type)) {
+            // CPython is asymmetric: it will try __eq__ if there's no __ne__ but not the
+            // other way around.  If the class doesn't need a full test we can skip __ne__.
+            if (op == MP_BINARY_OP_NOT_EQUAL && (type->flags & MP_TYPE_FLAG_EQ_HAS_NEQ_TEST)) {
+                mp_obj_t r = type->binary_op(MP_BINARY_OP_NOT_EQUAL, o1, o2);
+                if (r != MP_OBJ_NULL) {
+                    return r;
+                }
+            }
+
+            // Try calling __eq__.
+            mp_obj_t r = type->binary_op(MP_BINARY_OP_EQUAL, o1, o2);
+            if (r != MP_OBJ_NULL) {
+                if (op == MP_BINARY_OP_EQUAL) {
+                    return r;
+                } else {
+                    return mp_obj_is_true(r) ? local_true : local_false;
+                }
+            }
         }
+
+    skip_one_pass:
+        // Try the other way around if none of the above worked
+        ++pass_number;
+        mp_obj_t temp = o1;
+        o1 = o2;
+        o2 = temp;
     }
 
-    // equality not implemented, and objects are not the same object, so
-    // they are defined as not equal
-    return false;
+    // equality not implemented, so fall back to pointer conparison
+    return (o1 == o2) ? local_true : local_false;
+}
+
+bool mp_obj_equal(mp_obj_t o1, mp_obj_t o2) {
+    return mp_obj_is_true(mp_obj_equal_not_equal(MP_BINARY_OP_EQUAL, o1, o2));
 }
 
 mp_int_t mp_obj_get_int(mp_const_obj_t arg) {
@@ -275,7 +340,7 @@ bool mp_obj_get_float_maybe(mp_obj_t arg, mp_float_t *value) {
     } else if (arg == mp_const_true) {
         val = 1;
     } else if (mp_obj_is_small_int(arg)) {
-        val = MP_OBJ_SMALL_INT_VALUE(arg);
+        val = (mp_float_t)MP_OBJ_SMALL_INT_VALUE(arg);
     #if MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_NONE
     } else if (mp_obj_is_type(arg, &mp_type_int)) {
         val = mp_obj_int_as_float_impl(arg);
@@ -294,12 +359,12 @@ mp_float_t mp_obj_get_float(mp_obj_t arg) {
     mp_float_t val;
 
     if (!mp_obj_get_float_maybe(arg, &val)) {
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_raise_TypeError("can't convert to float");
-        } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                "can't convert %s to float", mp_obj_get_type_str(arg)));
-        }
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_raise_TypeError(MP_ERROR_TEXT("can't convert to float"));
+        #else
+        mp_raise_msg_varg(&mp_type_TypeError,
+            MP_ERROR_TEXT("can't convert %s to float"), mp_obj_get_type_str(arg));
+        #endif
     }
 
     return val;
@@ -314,7 +379,7 @@ void mp_obj_get_complex(mp_obj_t arg, mp_float_t *real, mp_float_t *imag) {
         *real = 1;
         *imag = 0;
     } else if (mp_obj_is_small_int(arg)) {
-        *real = MP_OBJ_SMALL_INT_VALUE(arg);
+        *real = (mp_float_t)MP_OBJ_SMALL_INT_VALUE(arg);
         *imag = 0;
     #if MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_NONE
     } else if (mp_obj_is_type(arg, &mp_type_int)) {
@@ -327,12 +392,12 @@ void mp_obj_get_complex(mp_obj_t arg, mp_float_t *real, mp_float_t *imag) {
     } else if (mp_obj_is_type(arg, &mp_type_complex)) {
         mp_obj_complex_get(arg, real, imag);
     } else {
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_raise_TypeError("can't convert to complex");
-        } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                "can't convert %s to complex", mp_obj_get_type_str(arg)));
-        }
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_raise_TypeError(MP_ERROR_TEXT("can't convert to complex"));
+        #else
+        mp_raise_msg_varg(&mp_type_TypeError,
+            MP_ERROR_TEXT("can't convert %s to complex"), mp_obj_get_type_str(arg));
+        #endif
     }
 }
 #endif
@@ -345,12 +410,12 @@ void mp_obj_get_array(mp_obj_t o, size_t *len, mp_obj_t **items) {
     } else if (mp_obj_is_type(o, &mp_type_list)) {
         mp_obj_list_get(o, len, items);
     } else {
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_raise_TypeError("expected tuple/list");
-        } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                "object '%s' isn't a tuple or list", mp_obj_get_type_str(o)));
-        }
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_raise_TypeError(MP_ERROR_TEXT("expected tuple/list"));
+        #else
+        mp_raise_msg_varg(&mp_type_TypeError,
+            MP_ERROR_TEXT("object '%s' isn't a tuple or list"), mp_obj_get_type_str(o));
+        #endif
     }
 }
 
@@ -359,12 +424,12 @@ void mp_obj_get_array_fixed_n(mp_obj_t o, size_t len, mp_obj_t **items) {
     size_t seq_len;
     mp_obj_get_array(o, &seq_len, items);
     if (seq_len != len) {
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_raise_ValueError("tuple/list has wrong length");
-        } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-                "requested length %d but object has length %d", (int)len, (int)seq_len));
-        }
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_raise_ValueError(MP_ERROR_TEXT("tuple/list has wrong length"));
+        #else
+        mp_raise_msg_varg(&mp_type_ValueError,
+            MP_ERROR_TEXT("requested length %d but object has length %d"), (int)len, (int)seq_len);
+        #endif
     }
 }
 
@@ -374,13 +439,13 @@ size_t mp_get_index(const mp_obj_type_t *type, size_t len, mp_obj_t index, bool
     if (mp_obj_is_small_int(index)) {
         i = MP_OBJ_SMALL_INT_VALUE(index);
     } else if (!mp_obj_get_int_maybe(index, &i)) {
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_raise_TypeError("indices must be integers");
-        } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                "%q indices must be integers, not %s",
-                type->name, mp_obj_get_type_str(index)));
-        }
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_raise_TypeError(MP_ERROR_TEXT("indices must be integers"));
+        #else
+        mp_raise_msg_varg(&mp_type_TypeError,
+            MP_ERROR_TEXT("%q indices must be integers, not %s"),
+            type->name, mp_obj_get_type_str(index));
+        #endif
     }
 
     if (i < 0) {
@@ -394,12 +459,11 @@ size_t mp_get_index(const mp_obj_type_t *type, size_t len, mp_obj_t index, bool
         }
     } else {
         if (i < 0 || (mp_uint_t)i >= len) {
-            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                mp_raise_msg(&mp_type_IndexError, "index out of range");
-            } else {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_IndexError,
-                    "%q index out of range", type->name));
-            }
+            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+            mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("index out of range"));
+            #else
+            mp_raise_msg_varg(&mp_type_IndexError, MP_ERROR_TEXT("%q index out of range"), type->name);
+            #endif
         }
     }
 
@@ -429,12 +493,12 @@ mp_obj_t mp_obj_id(mp_obj_t o_in) {
 mp_obj_t mp_obj_len(mp_obj_t o_in) {
     mp_obj_t len = mp_obj_len_maybe(o_in);
     if (len == MP_OBJ_NULL) {
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_raise_TypeError("object has no len");
-        } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                "object of type '%s' has no len()", mp_obj_get_type_str(o_in)));
-        }
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_raise_TypeError(MP_ERROR_TEXT("object has no len"));
+        #else
+        mp_raise_msg_varg(&mp_type_TypeError,
+            MP_ERROR_TEXT("object of type '%s' has no len()"), mp_obj_get_type_str(o_in));
+        #endif
     } else {
         return len;
     }
@@ -443,15 +507,15 @@ mp_obj_t mp_obj_len(mp_obj_t o_in) {
 // may return MP_OBJ_NULL
 mp_obj_t mp_obj_len_maybe(mp_obj_t o_in) {
     if (
-#if !MICROPY_PY_BUILTINS_STR_UNICODE
+        #if !MICROPY_PY_BUILTINS_STR_UNICODE
         // It's simple - unicode is slow, non-unicode is fast
         mp_obj_is_str(o_in) ||
-#endif
+        #endif
         mp_obj_is_type(o_in, &mp_type_bytes)) {
         GET_STR_LEN(o_in, l);
         return MP_OBJ_NEW_SMALL_INT(l);
     } else {
-        mp_obj_type_t *type = mp_obj_get_type(o_in);
+        const mp_obj_type_t *type = mp_obj_get_type(o_in);
         if (type->unary_op != NULL) {
             return type->unary_op(MP_UNARY_OP_LEN, o_in);
         } else {
@@ -461,7 +525,7 @@ mp_obj_t mp_obj_len_maybe(mp_obj_t o_in) {
 }
 
 mp_obj_t mp_obj_subscr(mp_obj_t base, mp_obj_t index, mp_obj_t value) {
-    mp_obj_type_t *type = mp_obj_get_type(base);
+    const mp_obj_type_t *type = mp_obj_get_type(base);
     if (type->subscr != NULL) {
         mp_obj_t ret = type->subscr(base, index, value);
         if (ret != MP_OBJ_NULL) {
@@ -470,26 +534,26 @@ mp_obj_t mp_obj_subscr(mp_obj_t base, mp_obj_t index, mp_obj_t value) {
         // TODO: call base classes here?
     }
     if (value == MP_OBJ_NULL) {
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_raise_TypeError("object doesn't support item deletion");
-        } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                "'%s' object doesn't support item deletion", mp_obj_get_type_str(base)));
-        }
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_raise_TypeError(MP_ERROR_TEXT("object doesn't support item deletion"));
+        #else
+        mp_raise_msg_varg(&mp_type_TypeError,
+            MP_ERROR_TEXT("'%s' object doesn't support item deletion"), mp_obj_get_type_str(base));
+        #endif
     } else if (value == MP_OBJ_SENTINEL) {
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_raise_TypeError("object isn't subscriptable");
-        } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                "'%s' object isn't subscriptable", mp_obj_get_type_str(base)));
-        }
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_raise_TypeError(MP_ERROR_TEXT("object isn't subscriptable"));
+        #else
+        mp_raise_msg_varg(&mp_type_TypeError,
+            MP_ERROR_TEXT("'%s' object isn't subscriptable"), mp_obj_get_type_str(base));
+        #endif
     } else {
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_raise_TypeError("object doesn't support item assignment");
-        } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                "'%s' object doesn't support item assignment", mp_obj_get_type_str(base)));
-        }
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_raise_TypeError(MP_ERROR_TEXT("object doesn't support item assignment"));
+        #else
+        mp_raise_msg_varg(&mp_type_TypeError,
+            MP_ERROR_TEXT("'%s' object doesn't support item assignment"), mp_obj_get_type_str(base));
+        #endif
     }
 }
 
@@ -506,7 +570,7 @@ mp_obj_t mp_identity_getiter(mp_obj_t self, mp_obj_iter_buf_t *iter_buf) {
 }
 
 bool mp_get_buffer(mp_obj_t obj, mp_buffer_info_t *bufinfo, mp_uint_t flags) {
-    mp_obj_type_t *type = mp_obj_get_type(obj);
+    const mp_obj_type_t *type = mp_obj_get_type(obj);
     if (type->buffer_p.get_buffer == NULL) {
         return false;
     }
@@ -519,13 +583,15 @@ bool mp_get_buffer(mp_obj_t obj, mp_buffer_info_t *bufinfo, mp_uint_t flags) {
 
 void mp_get_buffer_raise(mp_obj_t obj, mp_buffer_info_t *bufinfo, mp_uint_t flags) {
     if (!mp_get_buffer(obj, bufinfo, flags)) {
-        mp_raise_TypeError("object with buffer protocol required");
+        mp_raise_TypeError(MP_ERROR_TEXT("object with buffer protocol required"));
     }
 }
 
 mp_obj_t mp_generic_unary_op(mp_unary_op_t op, mp_obj_t o_in) {
     switch (op) {
-        case MP_UNARY_OP_HASH: return MP_OBJ_NEW_SMALL_INT((mp_uint_t)o_in);
-        default: return MP_OBJ_NULL; // op not supported
+        case MP_UNARY_OP_HASH:
+            return MP_OBJ_NEW_SMALL_INT((mp_uint_t)o_in);
+        default:
+            return MP_OBJ_NULL;      // op not supported
     }
 }
diff --git a/py/obj.h b/py/obj.h
index a22d5f8b810db..125acf118f08d 100644
--- a/py/obj.h
+++ b/py/obj.h
@@ -26,6 +26,8 @@
 #ifndef MICROPY_INCLUDED_PY_OBJ_H
 #define MICROPY_INCLUDED_PY_OBJ_H
 
+#include <assert.h>
+
 #include "py/mpconfig.h"
 #include "py/misc.h"
 #include "py/qstr.h"
@@ -66,13 +68,13 @@ typedef struct _mp_obj_base_t mp_obj_base_t;
 // as many as we can to MP_OBJ_NULL because it's cheaper to load/compare 0.
 
 #if MICROPY_DEBUG_MP_OBJ_SENTINELS
-#define MP_OBJ_NULL             (MP_OBJ_FROM_PTR((void*)0))
-#define MP_OBJ_STOP_ITERATION   (MP_OBJ_FROM_PTR((void*)4))
-#define MP_OBJ_SENTINEL         (MP_OBJ_FROM_PTR((void*)8))
+#define MP_OBJ_NULL             (MP_OBJ_FROM_PTR((void *)0))
+#define MP_OBJ_STOP_ITERATION   (MP_OBJ_FROM_PTR((void *)4))
+#define MP_OBJ_SENTINEL         (MP_OBJ_FROM_PTR((void *)8))
 #else
-#define MP_OBJ_NULL             (MP_OBJ_FROM_PTR((void*)0))
-#define MP_OBJ_STOP_ITERATION   (MP_OBJ_FROM_PTR((void*)0))
-#define MP_OBJ_SENTINEL         (MP_OBJ_FROM_PTR((void*)4))
+#define MP_OBJ_NULL             (MP_OBJ_FROM_PTR((void *)0))
+#define MP_OBJ_STOP_ITERATION   (MP_OBJ_FROM_PTR((void *)0))
+#define MP_OBJ_SENTINEL         (MP_OBJ_FROM_PTR((void *)4))
 #endif
 
 // These macros/inline functions operate on objects and depend on the
@@ -81,15 +83,23 @@ typedef struct _mp_obj_base_t mp_obj_base_t;
 
 #if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A
 
-static inline bool mp_obj_is_small_int(mp_const_obj_t o)
-    { return ((((mp_int_t)(o)) & 1) != 0); }
+static inline bool mp_obj_is_small_int(mp_const_obj_t o) {
+    return (((mp_int_t)(o)) & 1) != 0;
+}
 #define MP_OBJ_SMALL_INT_VALUE(o) (((mp_int_t)(o)) >> 1)
 #define MP_OBJ_NEW_SMALL_INT(small_int) ((mp_obj_t)((((mp_uint_t)(small_int)) << 1) | 1))
 
-static inline bool mp_obj_is_qstr(mp_const_obj_t o)
-    { return ((((mp_int_t)(o)) & 3) == 2); }
-#define MP_OBJ_QSTR_VALUE(o) (((mp_uint_t)(o)) >> 2)
-#define MP_OBJ_NEW_QSTR(qst) ((mp_obj_t)((((mp_uint_t)(qst)) << 2) | 2))
+static inline bool mp_obj_is_qstr(mp_const_obj_t o) {
+    return (((mp_int_t)(o)) & 7) == 2;
+}
+#define MP_OBJ_QSTR_VALUE(o) (((mp_uint_t)(o)) >> 3)
+#define MP_OBJ_NEW_QSTR(qst) ((mp_obj_t)((((mp_uint_t)(qst)) << 3) | 2))
+
+static inline bool mp_obj_is_immediate_obj(mp_const_obj_t o) {
+    return (((mp_int_t)(o)) & 7) == 6;
+}
+#define MP_OBJ_IMMEDIATE_OBJ_VALUE(o) (((mp_uint_t)(o)) >> 3)
+#define MP_OBJ_NEW_IMMEDIATE_OBJ(val) ((mp_obj_t)(((val) << 3) | 6))
 
 #if MICROPY_PY_BUILTINS_FLOAT
 #define mp_const_float_e MP_ROM_PTR(&mp_const_float_e_obj)
@@ -102,20 +112,29 @@ mp_float_t mp_obj_float_get(mp_obj_t self_in);
 mp_obj_t mp_obj_new_float(mp_float_t value);
 #endif
 
-static inline bool mp_obj_is_obj(mp_const_obj_t o)
-    { return ((((mp_int_t)(o)) & 3) == 0); }
+static inline bool mp_obj_is_obj(mp_const_obj_t o) {
+    return (((mp_int_t)(o)) & 3) == 0;
+}
 
 #elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B
 
-static inline bool mp_obj_is_small_int(mp_const_obj_t o)
-    { return ((((mp_int_t)(o)) & 3) == 1); }
+static inline bool mp_obj_is_small_int(mp_const_obj_t o) {
+    return (((mp_int_t)(o)) & 3) == 1;
+}
 #define MP_OBJ_SMALL_INT_VALUE(o) (((mp_int_t)(o)) >> 2)
 #define MP_OBJ_NEW_SMALL_INT(small_int) ((mp_obj_t)((((mp_uint_t)(small_int)) << 2) | 1))
 
-static inline bool mp_obj_is_qstr(mp_const_obj_t o)
-    { return ((((mp_int_t)(o)) & 3) == 3); }
-#define MP_OBJ_QSTR_VALUE(o) (((mp_uint_t)(o)) >> 2)
-#define MP_OBJ_NEW_QSTR(qst) ((mp_obj_t)((((mp_uint_t)(qst)) << 2) | 3))
+static inline bool mp_obj_is_qstr(mp_const_obj_t o) {
+    return (((mp_int_t)(o)) & 7) == 3;
+}
+#define MP_OBJ_QSTR_VALUE(o) (((mp_uint_t)(o)) >> 3)
+#define MP_OBJ_NEW_QSTR(qst) ((mp_obj_t)((((mp_uint_t)(qst)) << 3) | 3))
+
+static inline bool mp_obj_is_immediate_obj(mp_const_obj_t o) {
+    return (((mp_int_t)(o)) & 7) == 7;
+}
+#define MP_OBJ_IMMEDIATE_OBJ_VALUE(o) (((mp_uint_t)(o)) >> 3)
+#define MP_OBJ_NEW_IMMEDIATE_OBJ(val) ((mp_obj_t)(((val) << 3) | 7))
 
 #if MICROPY_PY_BUILTINS_FLOAT
 #define mp_const_float_e MP_ROM_PTR(&mp_const_float_e_obj)
@@ -128,13 +147,15 @@ mp_float_t mp_obj_float_get(mp_obj_t self_in);
 mp_obj_t mp_obj_new_float(mp_float_t value);
 #endif
 
-static inline bool mp_obj_is_obj(mp_const_obj_t o)
-    { return ((((mp_int_t)(o)) & 1) == 0); }
+static inline bool mp_obj_is_obj(mp_const_obj_t o) {
+    return (((mp_int_t)(o)) & 1) == 0;
+}
 
 #elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
 
-static inline bool mp_obj_is_small_int(mp_const_obj_t o)
-    { return ((((mp_int_t)(o)) & 1) != 0); }
+static inline bool mp_obj_is_small_int(mp_const_obj_t o) {
+    return (((mp_int_t)(o)) & 1) != 0;
+}
 #define MP_OBJ_SMALL_INT_VALUE(o) (((mp_int_t)(o)) >> 1)
 #define MP_OBJ_NEW_SMALL_INT(small_int) ((mp_obj_t)((((mp_uint_t)(small_int)) << 1) | 1))
 
@@ -142,8 +163,9 @@ static inline bool mp_obj_is_small_int(mp_const_obj_t o)
 #define mp_const_float_e MP_ROM_PTR((mp_obj_t)(((0x402df854 & ~3) | 2) + 0x80800000))
 #define mp_const_float_pi MP_ROM_PTR((mp_obj_t)(((0x40490fdb & ~3) | 2) + 0x80800000))
 
-static inline bool mp_obj_is_float(mp_const_obj_t o)
-    { return (((mp_uint_t)(o)) & 3) == 2 && (((mp_uint_t)(o)) & 0xff800007) != 0x00000006; }
+static inline bool mp_obj_is_float(mp_const_obj_t o) {
+    return (((mp_uint_t)(o)) & 3) == 2 && (((mp_uint_t)(o)) & 0xff800007) != 0x00000006;
+}
 static inline mp_float_t mp_obj_float_get(mp_const_obj_t o) {
     union {
         mp_float_t f;
@@ -160,25 +182,41 @@ static inline mp_obj_t mp_obj_new_float(mp_float_t f) {
 }
 #endif
 
-static inline bool mp_obj_is_qstr(mp_const_obj_t o)
-    { return (((mp_uint_t)(o)) & 0xff800007) == 0x00000006; }
-#define MP_OBJ_QSTR_VALUE(o) (((mp_uint_t)(o)) >> 3)
-#define MP_OBJ_NEW_QSTR(qst) ((mp_obj_t)((((mp_uint_t)(qst)) << 3) | 0x00000006))
+static inline bool mp_obj_is_qstr(mp_const_obj_t o) {
+    return (((mp_uint_t)(o)) & 0xff80000f) == 0x00000006;
+}
+#define MP_OBJ_QSTR_VALUE(o) (((mp_uint_t)(o)) >> 4)
+#define MP_OBJ_NEW_QSTR(qst) ((mp_obj_t)((((mp_uint_t)(qst)) << 4) | 0x00000006))
+
+static inline bool mp_obj_is_immediate_obj(mp_const_obj_t o) {
+    return (((mp_uint_t)(o)) & 0xff80000f) == 0x0000000e;
+}
+#define MP_OBJ_IMMEDIATE_OBJ_VALUE(o) (((mp_uint_t)(o)) >> 4)
+#define MP_OBJ_NEW_IMMEDIATE_OBJ(val) ((mp_obj_t)(((val) << 4) | 0xe))
 
-static inline bool mp_obj_is_obj(mp_const_obj_t o)
-    { return ((((mp_int_t)(o)) & 3) == 0); }
+static inline bool mp_obj_is_obj(mp_const_obj_t o) {
+    return (((mp_int_t)(o)) & 3) == 0;
+}
 
 #elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D
 
-static inline bool mp_obj_is_small_int(mp_const_obj_t o)
-    { return ((((uint64_t)(o)) & 0xffff000000000000) == 0x0001000000000000); }
+static inline bool mp_obj_is_small_int(mp_const_obj_t o) {
+    return (((uint64_t)(o)) & 0xffff000000000000) == 0x0001000000000000;
+}
 #define MP_OBJ_SMALL_INT_VALUE(o) (((mp_int_t)((o) << 16)) >> 17)
 #define MP_OBJ_NEW_SMALL_INT(small_int) (((((uint64_t)(small_int)) & 0x7fffffffffff) << 1) | 0x0001000000000001)
 
-static inline bool mp_obj_is_qstr(mp_const_obj_t o)
-    { return ((((uint64_t)(o)) & 0xffff000000000000) == 0x0002000000000000); }
+static inline bool mp_obj_is_qstr(mp_const_obj_t o) {
+    return (((uint64_t)(o)) & 0xffff000000000000) == 0x0002000000000000;
+}
 #define MP_OBJ_QSTR_VALUE(o) ((((uint32_t)(o)) >> 1) & 0xffffffff)
-#define MP_OBJ_NEW_QSTR(qst) ((mp_obj_t)((((mp_uint_t)(qst)) << 1) | 0x0002000000000001))
+#define MP_OBJ_NEW_QSTR(qst) ((mp_obj_t)(((uint64_t)(((uint32_t)(qst)) << 1)) | 0x0002000000000001))
+
+static inline bool mp_obj_is_immediate_obj(mp_const_obj_t o) {
+    return (((uint64_t)(o)) & 0xffff000000000000) == 0x0003000000000000;
+}
+#define MP_OBJ_IMMEDIATE_OBJ_VALUE(o) ((((uint32_t)(o)) >> 46) & 3)
+#define MP_OBJ_NEW_IMMEDIATE_OBJ(val) (((uint64_t)(val) << 46) | 0x0003000000000000)
 
 #if MICROPY_PY_BUILTINS_FLOAT
 
@@ -208,13 +246,17 @@ static inline mp_obj_t mp_obj_new_float(mp_float_t f) {
 }
 #endif
 
-static inline bool mp_obj_is_obj(mp_const_obj_t o)
-    { return ((((uint64_t)(o)) & 0xffff000000000000) == 0x0000000000000000); }
-#define MP_OBJ_TO_PTR(o) ((void*)(uintptr_t)(o))
+static inline bool mp_obj_is_obj(mp_const_obj_t o) {
+    return (((uint64_t)(o)) & 0xffff000000000000) == 0x0000000000000000;
+}
+#define MP_OBJ_TO_PTR(o) ((void *)(uintptr_t)(o))
 #define MP_OBJ_FROM_PTR(p) ((mp_obj_t)((uintptr_t)(p)))
 
 // rom object storage needs special handling to widen 32-bit pointer to 64-bits
-typedef union _mp_rom_obj_t { uint64_t u64; struct { const void *lo, *hi; } u32; } mp_rom_obj_t;
+typedef union _mp_rom_obj_t { uint64_t u64;
+                              struct { const void *lo, *hi;
+                              } u32;
+} mp_rom_obj_t;
 #define MP_ROM_INT(i) {MP_OBJ_NEW_SMALL_INT(i)}
 #define MP_ROM_QSTR(q) {MP_OBJ_NEW_QSTR(q)}
 #if MP_ENDIANNESS_LITTLE
@@ -232,7 +274,7 @@ typedef union _mp_rom_obj_t { uint64_t u64; struct { const void *lo, *hi; } u32;
 
 // Cast mp_obj_t to object pointer
 #ifndef MP_OBJ_TO_PTR
-#define MP_OBJ_TO_PTR(o) ((void*)o)
+#define MP_OBJ_TO_PTR(o) ((void *)o)
 #endif
 
 // Cast object pointer to mp_obj_t
@@ -242,6 +284,24 @@ typedef union _mp_rom_obj_t { uint64_t u64; struct { const void *lo, *hi; } u32;
 
 // Macros to create objects that are stored in ROM.
 
+#ifndef MP_ROM_NONE
+#if MICROPY_OBJ_IMMEDIATE_OBJS
+#define MP_ROM_NONE mp_const_none
+#else
+#define MP_ROM_NONE MP_ROM_PTR(&mp_const_none_obj)
+#endif
+#endif
+
+#ifndef MP_ROM_FALSE
+#if MICROPY_OBJ_IMMEDIATE_OBJS
+#define MP_ROM_FALSE mp_const_false
+#define MP_ROM_TRUE mp_const_true
+#else
+#define MP_ROM_FALSE MP_ROM_PTR(&mp_const_false_obj)
+#define MP_ROM_TRUE MP_ROM_PTR(&mp_const_true_obj)
+#endif
+#endif
+
 #ifndef MP_ROM_INT
 typedef mp_const_obj_t mp_rom_obj_t;
 #define MP_ROM_INT(i) MP_OBJ_NEW_SMALL_INT(i)
@@ -271,25 +331,25 @@ typedef struct _mp_rom_obj_t { mp_const_obj_t o; } mp_rom_obj_t;
 
 #define MP_DEFINE_CONST_FUN_OBJ_0(obj_name, fun_name) \
     const mp_obj_fun_builtin_fixed_t obj_name = \
-        {{&mp_type_fun_builtin_0}, .fun._0 = fun_name}
+    {{&mp_type_fun_builtin_0}, .fun._0 = fun_name}
 #define MP_DEFINE_CONST_FUN_OBJ_1(obj_name, fun_name) \
     const mp_obj_fun_builtin_fixed_t obj_name = \
-        {{&mp_type_fun_builtin_1}, .fun._1 = fun_name}
+    {{&mp_type_fun_builtin_1}, .fun._1 = fun_name}
 #define MP_DEFINE_CONST_FUN_OBJ_2(obj_name, fun_name) \
     const mp_obj_fun_builtin_fixed_t obj_name = \
-        {{&mp_type_fun_builtin_2}, .fun._2 = fun_name}
+    {{&mp_type_fun_builtin_2}, .fun._2 = fun_name}
 #define MP_DEFINE_CONST_FUN_OBJ_3(obj_name, fun_name) \
     const mp_obj_fun_builtin_fixed_t obj_name = \
-        {{&mp_type_fun_builtin_3}, .fun._3 = fun_name}
+    {{&mp_type_fun_builtin_3}, .fun._3 = fun_name}
 #define MP_DEFINE_CONST_FUN_OBJ_VAR(obj_name, n_args_min, fun_name) \
     const mp_obj_fun_builtin_var_t obj_name = \
-        {{&mp_type_fun_builtin_var}, MP_OBJ_FUN_MAKE_SIG(n_args_min, MP_OBJ_FUN_ARGS_MAX, false), .fun.var = fun_name}
+    {{&mp_type_fun_builtin_var}, MP_OBJ_FUN_MAKE_SIG(n_args_min, MP_OBJ_FUN_ARGS_MAX, false), .fun.var = fun_name}
 #define MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(obj_name, n_args_min, n_args_max, fun_name) \
     const mp_obj_fun_builtin_var_t obj_name = \
-        {{&mp_type_fun_builtin_var}, MP_OBJ_FUN_MAKE_SIG(n_args_min, n_args_max, false), .fun.var = fun_name}
+    {{&mp_type_fun_builtin_var}, MP_OBJ_FUN_MAKE_SIG(n_args_min, n_args_max, false), .fun.var = fun_name}
 #define MP_DEFINE_CONST_FUN_OBJ_KW(obj_name, n_args_min, fun_name) \
     const mp_obj_fun_builtin_var_t obj_name = \
-        {{&mp_type_fun_builtin_var}, MP_OBJ_FUN_MAKE_SIG(n_args_min, MP_OBJ_FUN_ARGS_MAX, true), .fun.kw = fun_name}
+    {{&mp_type_fun_builtin_var}, MP_OBJ_FUN_MAKE_SIG(n_args_min, MP_OBJ_FUN_ARGS_MAX, true), .fun.kw = fun_name}
 
 // These macros are used to define constant map/dict objects
 // You can put "static" in front of the definition to make it local
@@ -301,7 +361,7 @@ typedef struct _mp_rom_obj_t { mp_const_obj_t o; } mp_rom_obj_t;
         .is_ordered = 1, \
         .used = MP_ARRAY_SIZE(table_name), \
         .alloc = MP_ARRAY_SIZE(table_name), \
-        .table = (mp_map_elem_t*)(mp_rom_map_elem_t*)table_name, \
+        .table = (mp_map_elem_t *)(mp_rom_map_elem_t *)table_name, \
     }
 
 #define MP_DEFINE_CONST_DICT(dict_name, table_name) \
@@ -313,7 +373,7 @@ typedef struct _mp_rom_obj_t { mp_const_obj_t o; } mp_rom_obj_t;
             .is_ordered = 1, \
             .used = MP_ARRAY_SIZE(table_name), \
             .alloc = MP_ARRAY_SIZE(table_name), \
-            .table = (mp_map_elem_t*)(mp_rom_map_elem_t*)table_name, \
+            .table = (mp_map_elem_t *)(mp_rom_map_elem_t *)table_name, \
         }, \
     }
 
@@ -345,11 +405,6 @@ typedef struct _mp_rom_map_elem_t {
     mp_rom_obj_t value;
 } mp_rom_map_elem_t;
 
-// TODO maybe have a truncated mp_map_t for fixed tables, since alloc=used
-// put alloc last in the structure, so the truncated version does not need it
-// this would save 1 ROM word for all ROM objects that have a locals_dict
-// would also need a trucated dict structure
-
 typedef struct _mp_map_t {
     size_t all_keys_are_qstrs : 1;
     size_t is_fixed : 1;    // a fixed array that can't be modified; must also be ordered
@@ -369,7 +424,10 @@ typedef enum _mp_map_lookup_kind_t {
 
 extern const mp_map_t mp_const_empty_map;
 
-static inline bool mp_map_slot_is_filled(const mp_map_t *map, size_t pos) { return ((map)->table[pos].key != MP_OBJ_NULL && (map)->table[pos].key != MP_OBJ_SENTINEL); }
+static inline bool mp_map_slot_is_filled(const mp_map_t *map, size_t pos) {
+    assert(pos < map->alloc);
+    return (map)->table[pos].key != MP_OBJ_NULL && (map)->table[pos].key != MP_OBJ_SENTINEL;
+}
 
 void mp_map_init(mp_map_t *map, size_t n);
 void mp_map_init_fixed_table(mp_map_t *map, size_t n, const mp_obj_t *table);
@@ -388,7 +446,9 @@ typedef struct _mp_set_t {
     mp_obj_t *table;
 } mp_set_t;
 
-static inline bool mp_set_slot_is_filled(const mp_set_t *set, size_t pos) { return ((set)->table[pos] != MP_OBJ_NULL && (set)->table[pos] != MP_OBJ_SENTINEL); }
+static inline bool mp_set_slot_is_filled(const mp_set_t *set, size_t pos) {
+    return (set)->table[pos] != MP_OBJ_NULL && (set)->table[pos] != MP_OBJ_SENTINEL;
+}
 
 void mp_set_init(mp_set_t *set, size_t n);
 mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, mp_map_lookup_kind_t lookup_kind);
@@ -406,6 +466,19 @@ typedef mp_obj_t (*mp_fun_var_t)(size_t n, const mp_obj_t *);
 // this arg to mp_map_lookup().
 typedef mp_obj_t (*mp_fun_kw_t)(size_t n, const mp_obj_t *, mp_map_t *);
 
+// Flags for type behaviour (mp_obj_type_t.flags)
+// If MP_TYPE_FLAG_EQ_NOT_REFLEXIVE is clear then __eq__ is reflexive (A==A returns True).
+// If MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE is clear then the type can't be equal to an
+// instance of any different class that also clears this flag.  If this flag is set
+// then the type may check for equality against a different type.
+// If MP_TYPE_FLAG_EQ_HAS_NEQ_TEST is clear then the type only implements the __eq__
+// operator and not the __ne__ operator.  If it's set then __ne__ may be implemented.
+#define MP_TYPE_FLAG_IS_SUBCLASSED (0x0001)
+#define MP_TYPE_FLAG_HAS_SPECIAL_ACCESSORS (0x0002)
+#define MP_TYPE_FLAG_EQ_NOT_REFLEXIVE (0x0040)
+#define MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE (0x0080)
+#define MP_TYPE_FLAG_EQ_HAS_NEQ_TEST (0x0010)
+
 typedef enum {
     PRINT_STR = 0,
     PRINT_REPR = 1,
@@ -435,18 +508,9 @@ typedef mp_obj_t (*mp_getiter_fun_t)(mp_obj_t self_in, mp_obj_iter_buf_t *iter_b
 
 // Buffer protocol
 typedef struct _mp_buffer_info_t {
-    // if we'd bother to support various versions of structure
-    // (with different number of fields), we can distinguish
-    // them with ver = sizeof(struct). Cons: overkill for *micro*?
-    //int ver; // ?
-
     void *buf;      // can be NULL if len == 0
     size_t len;     // in bytes
     int typecode;   // as per binary.h
-
-    // Rationale: to load arbitrary-sized sprites directly to LCD
-    // Cons: a bit adhoc usecase
-    // int stride;
 } mp_buffer_info_t;
 #define MP_BUFFER_READ  (1)
 #define MP_BUFFER_WRITE (2)
@@ -589,7 +653,6 @@ extern const mp_obj_type_t mp_type_MemoryError;
 extern const mp_obj_type_t mp_type_NameError;
 extern const mp_obj_type_t mp_type_NotImplementedError;
 extern const mp_obj_type_t mp_type_OSError;
-extern const mp_obj_type_t mp_type_TimeoutError;
 extern const mp_obj_type_t mp_type_OverflowError;
 extern const mp_obj_type_t mp_type_RuntimeError;
 extern const mp_obj_type_t mp_type_StopAsyncIteration;
@@ -602,17 +665,27 @@ extern const mp_obj_type_t mp_type_ValueError;
 extern const mp_obj_type_t mp_type_ViperTypeError;
 extern const mp_obj_type_t mp_type_ZeroDivisionError;
 
-// Constant objects, globally accessible
-// The macros are for convenience only
+// Constant objects, globally accessible: None, False, True
+// These should always be accessed via the below macros.
+#if MICROPY_OBJ_IMMEDIATE_OBJS
+// None is even while False/True are odd so their types can be distinguished with 1 bit.
+#define mp_const_none MP_OBJ_NEW_IMMEDIATE_OBJ(0)
+#define mp_const_false MP_OBJ_NEW_IMMEDIATE_OBJ(1)
+#define mp_const_true MP_OBJ_NEW_IMMEDIATE_OBJ(3)
+#else
 #define mp_const_none (MP_OBJ_FROM_PTR(&mp_const_none_obj))
 #define mp_const_false (MP_OBJ_FROM_PTR(&mp_const_false_obj))
 #define mp_const_true (MP_OBJ_FROM_PTR(&mp_const_true_obj))
-#define mp_const_empty_bytes (MP_OBJ_FROM_PTR(&mp_const_empty_bytes_obj))
-#define mp_const_empty_tuple (MP_OBJ_FROM_PTR(&mp_const_empty_tuple_obj))
-#define mp_const_notimplemented (MP_OBJ_FROM_PTR(&mp_const_notimplemented_obj))
 extern const struct _mp_obj_none_t mp_const_none_obj;
 extern const struct _mp_obj_bool_t mp_const_false_obj;
 extern const struct _mp_obj_bool_t mp_const_true_obj;
+#endif
+
+// Constant objects, globally accessible: b'', (), Ellipsis, NotImplemented, GeneratorExit()
+// The below macros are for convenience only.
+#define mp_const_empty_bytes (MP_OBJ_FROM_PTR(&mp_const_empty_bytes_obj))
+#define mp_const_empty_tuple (MP_OBJ_FROM_PTR(&mp_const_empty_tuple_obj))
+#define mp_const_notimplemented (MP_OBJ_FROM_PTR(&mp_const_notimplemented_obj))
 extern const struct _mp_obj_str_t mp_const_empty_bytes_obj;
 extern const struct _mp_obj_tuple_t mp_const_empty_tuple_obj;
 extern const struct _mp_obj_singleton_t mp_const_ellipsis_obj;
@@ -625,24 +698,32 @@ extern const struct _mp_obj_exception_t mp_const_GeneratorExit_obj;
 // check for more specific object types.
 // Note: these are kept as macros because inline functions sometimes use much
 // more code space than the equivalent macros, depending on the compiler.
-#define mp_obj_is_type(o, t) (mp_obj_is_obj(o) && (((mp_obj_base_t*)MP_OBJ_TO_PTR(o))->type == (t))) // this does not work for checking int, str or fun; use below macros for that
+#define mp_obj_is_type(o, t) (mp_obj_is_obj(o) && (((mp_obj_base_t *)MP_OBJ_TO_PTR(o))->type == (t))) // this does not work for checking int, str or fun; use below macros for that
+#if MICROPY_OBJ_IMMEDIATE_OBJS
+// bool's are immediates, not real objects, so test for the 2 possible values.
+#define mp_obj_is_bool(o) ((o) == mp_const_false || (o) == mp_const_true)
+#else
+#define mp_obj_is_bool(o) mp_obj_is_type(o, &mp_type_bool)
+#endif
 #define mp_obj_is_int(o) (mp_obj_is_small_int(o) || mp_obj_is_type(o, &mp_type_int))
 #define mp_obj_is_str(o) (mp_obj_is_qstr(o) || mp_obj_is_type(o, &mp_type_str))
-#define mp_obj_is_str_or_bytes(o) (mp_obj_is_qstr(o) || (mp_obj_is_obj(o) && ((mp_obj_base_t*)MP_OBJ_TO_PTR(o))->type->binary_op == mp_obj_str_binary_op))
-#define mp_obj_is_fun(o) (mp_obj_is_obj(o) && (((mp_obj_base_t*)MP_OBJ_TO_PTR(o))->type->name == MP_QSTR_function))
+#define mp_obj_is_str_or_bytes(o) (mp_obj_is_qstr(o) || (mp_obj_is_obj(o) && ((mp_obj_base_t *)MP_OBJ_TO_PTR(o))->type->binary_op == mp_obj_str_binary_op))
+#define mp_obj_is_fun(o) (mp_obj_is_obj(o) && (((mp_obj_base_t *)MP_OBJ_TO_PTR(o))->type->name == MP_QSTR_function))
 
 mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict);
-static inline mp_obj_t mp_obj_new_bool(mp_int_t x) { return x ? mp_const_true : mp_const_false; }
+static inline mp_obj_t mp_obj_new_bool(mp_int_t x) {
+    return x ? mp_const_true : mp_const_false;
+}
 mp_obj_t mp_obj_new_cell(mp_obj_t obj);
 mp_obj_t mp_obj_new_int(mp_int_t value);
 mp_obj_t mp_obj_new_int_from_uint(mp_uint_t value);
 mp_obj_t mp_obj_new_int_from_str_len(const char **str, size_t len, bool neg, unsigned int base);
 mp_obj_t mp_obj_new_int_from_ll(long long val); // this must return a multi-precision integer object (or raise an overflow exception)
 mp_obj_t mp_obj_new_int_from_ull(unsigned long long val); // this must return a multi-precision integer object (or raise an overflow exception)
-mp_obj_t mp_obj_new_str(const char* data, size_t len);
-mp_obj_t mp_obj_new_str_via_qstr(const char* data, size_t len);
+mp_obj_t mp_obj_new_str(const char *data, size_t len);
+mp_obj_t mp_obj_new_str_via_qstr(const char *data, size_t len);
 mp_obj_t mp_obj_new_str_from_vstr(const mp_obj_type_t *type, vstr_t *vstr);
-mp_obj_t mp_obj_new_bytes(const byte* data, size_t len);
+mp_obj_t mp_obj_new_bytes(const byte *data, size_t len);
 mp_obj_t mp_obj_new_bytearray(size_t n, void *items);
 mp_obj_t mp_obj_new_bytearray_by_ref(size_t n, void *items);
 #if MICROPY_PY_BUILTINS_FLOAT
@@ -652,8 +733,11 @@ mp_obj_t mp_obj_new_complex(mp_float_t real, mp_float_t imag);
 mp_obj_t mp_obj_new_exception(const mp_obj_type_t *exc_type);
 mp_obj_t mp_obj_new_exception_arg1(const mp_obj_type_t *exc_type, mp_obj_t arg);
 mp_obj_t mp_obj_new_exception_args(const mp_obj_type_t *exc_type, size_t n_args, const mp_obj_t *args);
-mp_obj_t mp_obj_new_exception_msg(const mp_obj_type_t *exc_type, const char *msg);
-mp_obj_t mp_obj_new_exception_msg_varg(const mp_obj_type_t *exc_type, const char *fmt, ...); // counts args by number of % symbols in fmt, excluding %%; can only handle void* sizes (ie no float/double!)
+mp_obj_t mp_obj_new_exception_msg(const mp_obj_type_t *exc_type, mp_rom_error_text_t msg);
+mp_obj_t mp_obj_new_exception_msg_varg(const mp_obj_type_t *exc_type, mp_rom_error_text_t fmt, ...); // counts args by number of % symbols in fmt, excluding %%; can only handle void* sizes (ie no float/double!)
+#ifdef va_start
+mp_obj_t mp_obj_new_exception_msg_vlist(const mp_obj_type_t *exc_type, mp_rom_error_text_t fmt, va_list arg); // same fmt restrictions as above
+#endif
 mp_obj_t mp_obj_new_fun_bc(mp_obj_t def_args, mp_obj_t def_kw_args, const byte *code, const mp_uint_t *const_table);
 mp_obj_t mp_obj_new_fun_native(mp_obj_t def_args_in, mp_obj_t def_kw_args, const void *fun_data, const mp_uint_t *const_table);
 mp_obj_t mp_obj_new_fun_asm(size_t n_args, const void *fun_data, mp_uint_t type_sig);
@@ -669,10 +753,10 @@ mp_obj_t mp_obj_new_getitem_iter(mp_obj_t *args, mp_obj_iter_buf_t *iter_buf);
 mp_obj_t mp_obj_new_module(qstr module_name);
 mp_obj_t mp_obj_new_memoryview(byte typecode, size_t nitems, void *items);
 
-mp_obj_type_t *mp_obj_get_type(mp_const_obj_t o_in);
+const mp_obj_type_t *mp_obj_get_type(mp_const_obj_t o_in);
 const char *mp_obj_get_type_str(mp_const_obj_t o_in);
 bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo); // arguments should be type objects
-mp_obj_t mp_instance_cast_to_native_base(mp_const_obj_t self_in, mp_const_obj_t native_type);
+mp_obj_t mp_obj_cast_to_native_base(mp_obj_t self_in, mp_const_obj_t native_type);
 
 void mp_obj_print_helper(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t kind);
 void mp_obj_print(mp_obj_t o, mp_print_kind_t kind);
@@ -680,9 +764,12 @@ void mp_obj_print_exception(const mp_print_t *print, mp_obj_t exc);
 
 bool mp_obj_is_true(mp_obj_t arg);
 bool mp_obj_is_callable(mp_obj_t o_in);
+mp_obj_t mp_obj_equal_not_equal(mp_binary_op_t op, mp_obj_t o1, mp_obj_t o2);
 bool mp_obj_equal(mp_obj_t o1, mp_obj_t o2);
 
-static inline bool mp_obj_is_integer(mp_const_obj_t o) { return mp_obj_is_int(o) || mp_obj_is_type(o, &mp_type_bool); } // returns true if o is bool, small int or long int
+static inline bool mp_obj_is_integer(mp_const_obj_t o) {
+    return mp_obj_is_int(o) || mp_obj_is_bool(o);
+}                                                                                                        // returns true if o is bool, small int or long int
 mp_int_t mp_obj_get_int(mp_const_obj_t arg);
 mp_int_t mp_obj_get_int_truncated(mp_const_obj_t arg);
 bool mp_obj_get_int_maybe(mp_const_obj_t arg, mp_int_t *value);
@@ -691,7 +778,6 @@ mp_float_t mp_obj_get_float(mp_obj_t self_in);
 bool mp_obj_get_float_maybe(mp_obj_t arg, mp_float_t *value);
 void mp_obj_get_complex(mp_obj_t self_in, mp_float_t *real, mp_float_t *imag);
 #endif
-//qstr mp_obj_get_qstr(mp_obj_t arg);
 void mp_obj_get_array(mp_obj_t o, size_t *len, mp_obj_t **items); // *items may point inside a GC block
 void mp_obj_get_array_fixed_n(mp_obj_t o, size_t len, mp_obj_t **items); // *items may point inside a GC block
 size_t mp_get_index(const mp_obj_type_t *type, size_t len, mp_obj_t index, bool is_slice);
@@ -710,6 +796,8 @@ void mp_obj_cell_set(mp_obj_t self_in, mp_obj_t obj);
 mp_int_t mp_obj_int_get_truncated(mp_const_obj_t self_in);
 // Will raise exception if value doesn't fit into mp_int_t
 mp_int_t mp_obj_int_get_checked(mp_const_obj_t self_in);
+// Will raise exception if value is negative or doesn't fit into mp_uint_t
+mp_uint_t mp_obj_int_get_uint_checked(mp_const_obj_t self_in);
 
 // exception
 #define mp_obj_is_native_exception_instance(o) (mp_obj_get_type(o)->make_new == mp_obj_exception_make_new)
@@ -735,10 +823,45 @@ void mp_str_print_quoted(const mp_print_t *print, const byte *str_data, size_t s
 
 #if MICROPY_PY_BUILTINS_FLOAT
 // float
+#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
+static inline float mp_obj_get_float_to_f(mp_obj_t o) {
+    return mp_obj_get_float(o);
+}
+
+static inline double mp_obj_get_float_to_d(mp_obj_t o) {
+    return (double)mp_obj_get_float(o);
+}
+
+static inline mp_obj_t mp_obj_new_float_from_f(float o) {
+    return mp_obj_new_float(o);
+}
+
+static inline mp_obj_t mp_obj_new_float_from_d(double o) {
+    return mp_obj_new_float((mp_float_t)o);
+}
+#elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
+static inline float mp_obj_get_float_to_f(mp_obj_t o) {
+    return (float)mp_obj_get_float(o);
+}
+
+static inline double mp_obj_get_float_to_d(mp_obj_t o) {
+    return mp_obj_get_float(o);
+}
+
+static inline mp_obj_t mp_obj_new_float_from_f(float o) {
+    return mp_obj_new_float((mp_float_t)o);
+}
+
+static inline mp_obj_t mp_obj_new_float_from_d(double o) {
+    return mp_obj_new_float(o);
+}
+#endif
 #if MICROPY_FLOAT_HIGH_QUALITY_HASH
 mp_int_t mp_float_hash(mp_float_t val);
 #else
-static inline mp_int_t mp_float_hash(mp_float_t val) { return (mp_int_t)val; }
+static inline mp_int_t mp_float_hash(mp_float_t val) {
+    return (mp_int_t)val;
+}
 #endif
 mp_obj_t mp_obj_float_binary_op(mp_binary_op_t op, mp_float_t lhs_val, mp_obj_t rhs); // can return MP_OBJ_NULL if op not supported
 
@@ -773,14 +896,27 @@ mp_obj_t mp_obj_dict_get(mp_obj_t self_in, mp_obj_t index);
 mp_obj_t mp_obj_dict_store(mp_obj_t self_in, mp_obj_t key, mp_obj_t value);
 mp_obj_t mp_obj_dict_delete(mp_obj_t self_in, mp_obj_t key);
 static inline mp_map_t *mp_obj_dict_get_map(mp_obj_t dict) {
-    return &((mp_obj_dict_t*)MP_OBJ_TO_PTR(dict))->map;
+    return &((mp_obj_dict_t *)MP_OBJ_TO_PTR(dict))->map;
 }
 
 // set
 void mp_obj_set_store(mp_obj_t self_in, mp_obj_t item);
 
+// slice indexes resolved to particular sequence
+typedef struct {
+    mp_int_t start;
+    mp_int_t stop;
+    mp_int_t step;
+} mp_bound_slice_t;
+
 // slice
-void mp_obj_slice_get(mp_obj_t self_in, mp_obj_t *start, mp_obj_t *stop, mp_obj_t *step);
+typedef struct _mp_obj_slice_t {
+    mp_obj_base_t base;
+    mp_obj_t start;
+    mp_obj_t stop;
+    mp_obj_t step;
+} mp_obj_slice_t;
+void mp_obj_slice_indices(mp_obj_t self_in, mp_int_t length, mp_bound_slice_t *result);
 
 // functions
 
@@ -816,7 +952,7 @@ typedef struct _mp_obj_module_t {
     mp_obj_dict_t *globals;
 } mp_obj_module_t;
 static inline mp_obj_dict_t *mp_obj_module_get_globals(mp_obj_t module) {
-    return ((mp_obj_module_t*)MP_OBJ_TO_PTR(module))->globals;
+    return ((mp_obj_module_t *)MP_OBJ_TO_PTR(module))->globals;
 }
 // check if given module object is a package
 bool mp_obj_is_package(mp_obj_t module);
@@ -837,13 +973,6 @@ const mp_obj_t *mp_obj_property_get(mp_obj_t self_in);
 
 // sequence helpers
 
-// slice indexes resolved to particular sequence
-typedef struct {
-    mp_uint_t start;
-    mp_uint_t stop;
-    mp_int_t step;
-} mp_bound_slice_t;
-
 void mp_seq_multiply(const void *items, size_t item_sz, size_t len, size_t times, void *dest);
 #if MICROPY_PY_BUILTINS_SLICE
 bool mp_seq_get_fast_slice_indexes(mp_uint_t len, mp_obj_t slice, mp_bound_slice_t *indexes);
@@ -856,18 +985,18 @@ mp_obj_t mp_seq_index_obj(const mp_obj_t *items, size_t len, size_t n_args, cons
 mp_obj_t mp_seq_count_obj(const mp_obj_t *items, size_t len, mp_obj_t value);
 mp_obj_t mp_seq_extract_slice(size_t len, const mp_obj_t *seq, mp_bound_slice_t *indexes);
 // Helper to clear stale pointers from allocated, but unused memory, to preclude GC problems
-#define mp_seq_clear(start, len, alloc_len, item_sz) memset((byte*)(start) + (len) * (item_sz), 0, ((alloc_len) - (len)) * (item_sz))
+#define mp_seq_clear(start, len, alloc_len, item_sz) memset((byte *)(start) + (len) * (item_sz), 0, ((alloc_len) - (len)) * (item_sz))
 #define mp_seq_replace_slice_no_grow(dest, dest_len, beg, end, slice, slice_len, item_sz) \
     /*printf("memcpy(%p, %p, %d)\n", dest + beg, slice, slice_len * (item_sz));*/ \
-    memcpy(((char*)dest) + (beg) * (item_sz), slice, slice_len * (item_sz)); \
+    memcpy(((char *)dest) + (beg) * (item_sz), slice, slice_len * (item_sz)); \
     /*printf("memmove(%p, %p, %d)\n", dest + (beg + slice_len), dest + end, (dest_len - end) * (item_sz));*/ \
-    memmove(((char*)dest) + (beg + slice_len) * (item_sz), ((char*)dest) + (end) * (item_sz), (dest_len - end) * (item_sz));
+    memmove(((char *)dest) + (beg + slice_len) * (item_sz), ((char *)dest) + (end) * (item_sz), (dest_len - end) * (item_sz));
 
 // Note: dest and slice regions may overlap
 #define mp_seq_replace_slice_grow_inplace(dest, dest_len, beg, end, slice, slice_len, len_adj, item_sz) \
     /*printf("memmove(%p, %p, %d)\n", dest + beg + len_adj, dest + beg, (dest_len - beg) * (item_sz));*/ \
-    memmove(((char*)dest) + (beg + slice_len) * (item_sz), ((char*)dest) + (end) * (item_sz), ((dest_len) + (len_adj) - ((beg) + (slice_len))) * (item_sz)); \
-    memmove(((char*)dest) + (beg) * (item_sz), slice, slice_len * (item_sz));
+    memmove(((char *)dest) + (beg + slice_len) * (item_sz), ((char *)dest) + (end) * (item_sz), ((dest_len) + (len_adj) - ((beg) + (slice_len))) * (item_sz)); \
+    memmove(((char *)dest) + (beg) * (item_sz), slice, slice_len * (item_sz));
 
 // Provide translation for legacy API
 #define MP_OBJ_IS_SMALL_INT mp_obj_is_small_int
diff --git a/py/objarray.c b/py/objarray.c
index 4a8d0af3cc944..4947f75905e7f 100644
--- a/py/objarray.c
+++ b/py/objarray.c
@@ -117,10 +117,10 @@ STATIC mp_obj_t array_construct(char typecode, mp_obj_t initializer) {
     // other arrays can only be raw-initialised from bytes and bytearray objects
     mp_buffer_info_t bufinfo;
     if (((MICROPY_PY_BUILTINS_BYTEARRAY
-            && typecode == BYTEARRAY_TYPECODE)
-        || (MICROPY_PY_ARRAY
-            && (mp_obj_is_type(initializer, &mp_type_bytes)
-                || (MICROPY_PY_BUILTINS_BYTEARRAY && mp_obj_is_type(initializer, &mp_type_bytearray)))))
+          && typecode == BYTEARRAY_TYPECODE)
+         || (MICROPY_PY_ARRAY
+             && (mp_obj_is_type(initializer, &mp_type_bytes)
+                 || (MICROPY_PY_BUILTINS_BYTEARRAY && mp_obj_is_type(initializer, &mp_type_bytearray)))))
         && mp_get_buffer(initializer, &bufinfo, MP_BUFFER_READ)) {
         // construct array from raw bytes
         // we round-down the len to make it a multiple of sz (CPython raises error)
@@ -231,14 +231,30 @@ STATIC mp_obj_t memoryview_make_new(const mp_obj_type_t *type_in, size_t n_args,
 
     return MP_OBJ_FROM_PTR(self);
 }
+
+#if MICROPY_PY_BUILTINS_MEMORYVIEW_ITEMSIZE
+STATIC void memoryview_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
+    if (dest[0] != MP_OBJ_NULL) {
+        return;
+    }
+    if (attr == MP_QSTR_itemsize) {
+        mp_obj_array_t *self = MP_OBJ_TO_PTR(self_in);
+        dest[0] = MP_OBJ_NEW_SMALL_INT(mp_binary_get_size('@', self->typecode & TYPECODE_MASK, NULL));
+    }
+}
+#endif
+
 #endif
 
 STATIC mp_obj_t array_unary_op(mp_unary_op_t op, mp_obj_t o_in) {
     mp_obj_array_t *o = MP_OBJ_TO_PTR(o_in);
     switch (op) {
-        case MP_UNARY_OP_BOOL: return mp_obj_new_bool(o->len != 0);
-        case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(o->len);
-        default: return MP_OBJ_NULL; // op not supported
+        case MP_UNARY_OP_BOOL:
+            return mp_obj_new_bool(o->len != 0);
+        case MP_UNARY_OP_LEN:
+            return MP_OBJ_NEW_SMALL_INT(o->len);
+        default:
+            return MP_OBJ_NULL;      // op not supported
     }
 }
 
@@ -259,7 +275,7 @@ STATIC mp_obj_t array_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs
 
             // note: lhs->len is element count of lhs, lhs_bufinfo.len is byte count
             mp_obj_array_t *res = array_new(lhs_bufinfo.typecode, lhs->len + rhs_len);
-            mp_seq_cat((byte*)res->items, lhs_bufinfo.buf, lhs_bufinfo.len, rhs_bufinfo.buf, rhs_len * sz, byte);
+            mp_seq_cat((byte *)res->items, lhs_bufinfo.buf, lhs_bufinfo.len, rhs_bufinfo.buf, rhs_len * sz, byte);
             return MP_OBJ_FROM_PTR(res);
         }
 
@@ -358,7 +374,7 @@ STATIC mp_obj_t array_extend(mp_obj_t self_in, mp_obj_t arg_in) {
     }
 
     // extend
-    mp_seq_copy((byte*)self->items + self->len * sz, arg_bufinfo.buf, len * sz, byte);
+    mp_seq_copy((byte *)self->items + self->len * sz, arg_bufinfo.buf, len * sz, byte);
     self->len += len;
 
     return mp_const_none;
@@ -375,12 +391,11 @@ STATIC mp_obj_t array_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value
         return MP_OBJ_NULL; // op not supported
     } else {
         mp_obj_array_t *o = MP_OBJ_TO_PTR(self_in);
-        if (0) {
-#if MICROPY_PY_BUILTINS_SLICE
-        } else if (mp_obj_is_type(index_in, &mp_type_slice)) {
+        #if MICROPY_PY_BUILTINS_SLICE
+        if (mp_obj_is_type(index_in, &mp_type_slice)) {
             mp_bound_slice_t slice;
             if (!mp_seq_get_fast_slice_indexes(o->len, index_in, &slice)) {
-                mp_raise_NotImplementedError("only slices with step=1 (aka None) are supported");
+                mp_raise_NotImplementedError(MP_ERROR_TEXT("only slices with step=1 (aka None) are supported"));
             }
             if (value != MP_OBJ_SENTINEL) {
                 #if MICROPY_PY_ARRAY_SLICE_ASSIGN
@@ -388,18 +403,18 @@ STATIC mp_obj_t array_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value
                 size_t src_len;
                 void *src_items;
                 size_t item_sz = mp_binary_get_size('@', o->typecode & TYPECODE_MASK, NULL);
-                if (mp_obj_is_obj(value) && ((mp_obj_base_t*)MP_OBJ_TO_PTR(value))->type->subscr == array_subscr) {
+                if (mp_obj_is_obj(value) && ((mp_obj_base_t *)MP_OBJ_TO_PTR(value))->type->subscr == array_subscr) {
                     // value is array, bytearray or memoryview
                     mp_obj_array_t *src_slice = MP_OBJ_TO_PTR(value);
                     if (item_sz != mp_binary_get_size('@', src_slice->typecode & TYPECODE_MASK, NULL)) {
                     compat_error:
-                        mp_raise_ValueError("lhs and rhs should be compatible");
+                        mp_raise_ValueError(MP_ERROR_TEXT("lhs and rhs should be compatible"));
                     }
                     src_len = src_slice->len;
                     src_items = src_slice->items;
                     #if MICROPY_PY_BUILTINS_MEMORYVIEW
                     if (mp_obj_is_type(value, &mp_type_memoryview)) {
-                        src_items = (uint8_t*)src_items + (src_slice->memview_offset * item_sz);
+                        src_items = (uint8_t *)src_items + (src_slice->memview_offset * item_sz);
                     }
                     #endif
                 } else if (mp_obj_is_type(value, &mp_type_bytes)) {
@@ -411,12 +426,12 @@ STATIC mp_obj_t array_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value
                     src_len = bufinfo.len;
                     src_items = bufinfo.buf;
                 } else {
-                    mp_raise_NotImplementedError("array/bytes required on right side");
+                    mp_raise_NotImplementedError(MP_ERROR_TEXT("array/bytes required on right side"));
                 }
 
                 // TODO: check src/dst compat
                 mp_int_t len_adj = src_len - (slice.stop - slice.start);
-                uint8_t* dest_items = o->items;
+                uint8_t *dest_items = o->items;
                 #if MICROPY_PY_BUILTINS_MEMORYVIEW
                 if (o->base.type == &mp_type_memoryview) {
                     if (!(o->typecode & MP_OBJ_ARRAY_TYPECODE_FLAG_RW)) {
@@ -430,10 +445,10 @@ STATIC mp_obj_t array_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value
                 }
                 #endif
                 if (len_adj > 0) {
-                    if (len_adj > o->free) {
+                    if ((size_t)len_adj > o->free) {
                         // TODO: alloc policy; at the moment we go conservative
                         o->items = m_renew(byte, o->items, (o->len + o->free) * item_sz, (o->len + len_adj) * item_sz);
-                        o->free = 0;
+                        o->free = len_adj;
                         dest_items = o->items;
                     }
                     mp_seq_replace_slice_grow_inplace(dest_items, o->len,
@@ -446,6 +461,7 @@ STATIC mp_obj_t array_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value
                     mp_seq_clear(dest_items, o->len + len_adj, o->len, item_sz);
                     // TODO: alloc policy after shrinking
                 }
+                o->free -= len_adj;
                 o->len += len_adj;
                 return mp_const_none;
                 #else
@@ -456,22 +472,22 @@ STATIC mp_obj_t array_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value
             mp_obj_array_t *res;
             size_t sz = mp_binary_get_size('@', o->typecode & TYPECODE_MASK, NULL);
             assert(sz > 0);
-            if (0) {
-                // dummy
             #if MICROPY_PY_BUILTINS_MEMORYVIEW
-            } else if (o->base.type == &mp_type_memoryview) {
+            if (o->base.type == &mp_type_memoryview) {
                 res = m_new_obj(mp_obj_array_t);
                 *res = *o;
                 res->memview_offset += slice.start;
                 res->len = slice.stop - slice.start;
+            } else
             #endif
-            } else {
+            {
                 res = array_new(o->typecode, slice.stop - slice.start);
-                memcpy(res->items, (uint8_t*)o->items + slice.start * sz, (slice.stop - slice.start) * sz);
+                memcpy(res->items, (uint8_t *)o->items + slice.start * sz, (slice.stop - slice.start) * sz);
             }
             return MP_OBJ_FROM_PTR(res);
-#endif
-        } else {
+        } else
+        #endif
+        {
             size_t index = mp_get_index(o->base.type, o->len, index_in, false);
             #if MICROPY_PY_BUILTINS_MEMORYVIEW
             if (o->base.type == &mp_type_memoryview) {
@@ -506,7 +522,7 @@ STATIC mp_int_t array_get_buffer(mp_obj_t o_in, mp_buffer_info_t *bufinfo, mp_ui
             // read-only memoryview
             return 1;
         }
-        bufinfo->buf = (uint8_t*)bufinfo->buf + (size_t)o->memview_offset * sz;
+        bufinfo->buf = (uint8_t *)bufinfo->buf + (size_t)o->memview_offset * sz;
     }
     #else
     (void)flags;
@@ -518,6 +534,9 @@ STATIC mp_int_t array_get_buffer(mp_obj_t o_in, mp_buffer_info_t *bufinfo, mp_ui
 STATIC const mp_rom_map_elem_t array_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_append), MP_ROM_PTR(&array_append_obj) },
     { MP_ROM_QSTR(MP_QSTR_extend), MP_ROM_PTR(&array_extend_obj) },
+    #if MICROPY_CPYTHON_COMPAT
+    { MP_ROM_QSTR(MP_QSTR_decode), MP_ROM_PTR(&bytes_decode_obj) },
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(array_locals_dict, array_locals_dict_table);
@@ -534,13 +553,14 @@ const mp_obj_type_t mp_type_array = {
     .binary_op = array_binary_op,
     .subscr = array_subscr,
     .buffer_p = { .get_buffer = array_get_buffer },
-    .locals_dict = (mp_obj_dict_t*)&array_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&array_locals_dict,
 };
 #endif
 
 #if MICROPY_PY_BUILTINS_BYTEARRAY
 const mp_obj_type_t mp_type_bytearray = {
     { &mp_type_type },
+    .flags = MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
     .name = MP_QSTR_bytearray,
     .print = array_print,
     .make_new = bytearray_make_new,
@@ -549,18 +569,22 @@ const mp_obj_type_t mp_type_bytearray = {
     .binary_op = array_binary_op,
     .subscr = array_subscr,
     .buffer_p = { .get_buffer = array_get_buffer },
-    .locals_dict = (mp_obj_dict_t*)&array_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&array_locals_dict,
 };
 #endif
 
 #if MICROPY_PY_BUILTINS_MEMORYVIEW
 const mp_obj_type_t mp_type_memoryview = {
     { &mp_type_type },
+    .flags = MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
     .name = MP_QSTR_memoryview,
     .make_new = memoryview_make_new,
     .getiter = array_iterator_new,
     .unary_op = array_unary_op,
     .binary_op = array_binary_op,
+    #if MICROPY_PY_BUILTINS_MEMORYVIEW_ITEMSIZE
+    .attr = memoryview_attr,
+    #endif
     .subscr = array_subscr,
     .buffer_p = { .get_buffer = array_get_buffer },
 };
@@ -620,7 +644,7 @@ STATIC const mp_obj_type_t array_it_type = {
 STATIC mp_obj_t array_iterator_new(mp_obj_t array_in, mp_obj_iter_buf_t *iter_buf) {
     assert(sizeof(mp_obj_array_t) <= sizeof(mp_obj_iter_buf_t));
     mp_obj_array_t *array = MP_OBJ_TO_PTR(array_in);
-    mp_obj_array_it_t *o = (mp_obj_array_it_t*)iter_buf;
+    mp_obj_array_it_t *o = (mp_obj_array_it_t *)iter_buf;
     o->base.type = &array_it_type;
     o->array = array;
     o->offset = 0;
diff --git a/py/objattrtuple.c b/py/objattrtuple.c
index 3cc298d4e9000..3422d0146abb3 100644
--- a/py/objattrtuple.c
+++ b/py/objattrtuple.c
@@ -51,7 +51,7 @@ void mp_obj_attrtuple_print_helper(const mp_print_t *print, const qstr *fields,
 STATIC void mp_obj_attrtuple_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t kind) {
     (void)kind;
     mp_obj_tuple_t *o = MP_OBJ_TO_PTR(o_in);
-    const qstr *fields = (const qstr*)MP_OBJ_TO_PTR(o->items[o->len]);
+    const qstr *fields = (const qstr *)MP_OBJ_TO_PTR(o->items[o->len]);
     mp_obj_attrtuple_print_helper(print, fields, o);
 }
 
@@ -60,7 +60,7 @@ STATIC void mp_obj_attrtuple_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
         // load attribute
         mp_obj_tuple_t *self = MP_OBJ_TO_PTR(self_in);
         size_t len = self->len;
-        const qstr *fields = (const qstr*)MP_OBJ_TO_PTR(self->items[len]);
+        const qstr *fields = (const qstr *)MP_OBJ_TO_PTR(self->items[len]);
         for (size_t i = 0; i < len; i++) {
             if (fields[i] == attr) {
                 dest[0] = self->items[i];
diff --git a/py/objbool.c b/py/objbool.c
index 5755b188e98cd..23e023d8cbc15 100644
--- a/py/objbool.c
+++ b/py/objbool.c
@@ -28,21 +28,31 @@
 
 #include "py/runtime.h"
 
+#if MICROPY_OBJ_IMMEDIATE_OBJS
+
+#define BOOL_VALUE(o) ((o) == mp_const_false ? 0 : 1)
+
+#else
+
+#define BOOL_VALUE(o) (((mp_obj_bool_t *)MP_OBJ_TO_PTR(o))->value)
+
 typedef struct _mp_obj_bool_t {
     mp_obj_base_t base;
     bool value;
 } mp_obj_bool_t;
 
+#endif
+
 STATIC void bool_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
-    mp_obj_bool_t *self = MP_OBJ_TO_PTR(self_in);
+    bool value = BOOL_VALUE(self_in);
     if (MICROPY_PY_UJSON && kind == PRINT_JSON) {
-        if (self->value) {
+        if (value) {
             mp_print_str(print, "true");
         } else {
             mp_print_str(print, "false");
         }
     } else {
-        if (self->value) {
+        if (value) {
             mp_print_str(print, "True");
         } else {
             mp_print_str(print, "False");
@@ -65,17 +75,18 @@ STATIC mp_obj_t bool_unary_op(mp_unary_op_t op, mp_obj_t o_in) {
     if (op == MP_UNARY_OP_LEN) {
         return MP_OBJ_NULL;
     }
-    mp_obj_bool_t *self = MP_OBJ_TO_PTR(o_in);
-    return mp_unary_op(op, MP_OBJ_NEW_SMALL_INT(self->value));
+    bool value = BOOL_VALUE(o_in);
+    return mp_unary_op(op, MP_OBJ_NEW_SMALL_INT(value));
 }
 
 STATIC mp_obj_t bool_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
-    mp_obj_bool_t *self = MP_OBJ_TO_PTR(lhs_in);
-    return mp_binary_op(op, MP_OBJ_NEW_SMALL_INT(self->value), rhs_in);
+    bool value = BOOL_VALUE(lhs_in);
+    return mp_binary_op(op, MP_OBJ_NEW_SMALL_INT(value), rhs_in);
 }
 
 const mp_obj_type_t mp_type_bool = {
     { &mp_type_type },
+    .flags = MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE, // can match all numeric types
     .name = MP_QSTR_bool,
     .print = bool_print,
     .make_new = bool_make_new,
@@ -83,5 +94,7 @@ const mp_obj_type_t mp_type_bool = {
     .binary_op = bool_binary_op,
 };
 
+#if !MICROPY_OBJ_IMMEDIATE_OBJS
 const mp_obj_bool_t mp_const_false_obj = {{&mp_type_bool}, false};
 const mp_obj_bool_t mp_const_true_obj = {{&mp_type_bool}, true};
+#endif
diff --git a/py/objboundmeth.c b/py/objboundmeth.c
index 8fc44f163789c..a3e1d302d963f 100644
--- a/py/objboundmeth.c
+++ b/py/objboundmeth.c
@@ -98,13 +98,13 @@ STATIC void bound_meth_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
 STATIC const mp_obj_type_t mp_type_bound_meth = {
     { &mp_type_type },
     .name = MP_QSTR_bound_method,
-#if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED
+    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED
     .print = bound_meth_print,
-#endif
+    #endif
     .call = bound_meth_call,
-#if MICROPY_PY_FUNCTION_ATTRS
+    #if MICROPY_PY_FUNCTION_ATTRS
     .attr = bound_meth_attr,
-#endif
+    #endif
 };
 
 mp_obj_t mp_obj_new_bound_meth(mp_obj_t meth, mp_obj_t self) {
diff --git a/py/objcell.c b/py/objcell.c
index 111906412eb5b..be2ae8cd9c769 100644
--- a/py/objcell.c
+++ b/py/objcell.c
@@ -58,9 +58,9 @@ STATIC void cell_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t k
 STATIC const mp_obj_type_t mp_type_cell = {
     { &mp_type_type },
     .name = MP_QSTR_, // cell representation is just value in < >
-#if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED
+    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED
     .print = cell_print,
-#endif
+    #endif
 };
 
 mp_obj_t mp_obj_new_cell(mp_obj_t obj) {
diff --git a/py/objclosure.c b/py/objclosure.c
index 4eb9eb8b84aea..f5038ffc46513 100644
--- a/py/objclosure.c
+++ b/py/objclosure.c
@@ -81,9 +81,9 @@ STATIC void closure_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_
 const mp_obj_type_t closure_type = {
     { &mp_type_type },
     .name = MP_QSTR_closure,
-#if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED
+    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED
     .print = closure_print,
-#endif
+    #endif
     .call = closure_call,
 };
 
diff --git a/py/objcomplex.c b/py/objcomplex.c
index bf6fb51dc558e..91e4402309d88 100644
--- a/py/objcomplex.c
+++ b/py/objcomplex.c
@@ -45,17 +45,17 @@ typedef struct _mp_obj_complex_t {
 STATIC void complex_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t kind) {
     (void)kind;
     mp_obj_complex_t *o = MP_OBJ_TO_PTR(o_in);
-#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
+    #if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
     char buf[16];
     #if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
     const int precision = 6;
     #else
     const int precision = 7;
     #endif
-#else
+    #else
     char buf[32];
     const int precision = 16;
-#endif
+    #endif
     if (o->real == 0) {
         mp_format_float(o->imag, buf, sizeof(buf), 'g', precision, '\0');
         mp_printf(print, "%sj", buf);
@@ -117,13 +117,18 @@ STATIC mp_obj_t complex_make_new(const mp_obj_type_t *type_in, size_t n_args, si
 STATIC mp_obj_t complex_unary_op(mp_unary_op_t op, mp_obj_t o_in) {
     mp_obj_complex_t *o = MP_OBJ_TO_PTR(o_in);
     switch (op) {
-        case MP_UNARY_OP_BOOL: return mp_obj_new_bool(o->real != 0 || o->imag != 0);
-        case MP_UNARY_OP_HASH: return MP_OBJ_NEW_SMALL_INT(mp_float_hash(o->real) ^ mp_float_hash(o->imag));
-        case MP_UNARY_OP_POSITIVE: return o_in;
-        case MP_UNARY_OP_NEGATIVE: return mp_obj_new_complex(-o->real, -o->imag);
+        case MP_UNARY_OP_BOOL:
+            return mp_obj_new_bool(o->real != 0 || o->imag != 0);
+        case MP_UNARY_OP_HASH:
+            return MP_OBJ_NEW_SMALL_INT(mp_float_hash(o->real) ^ mp_float_hash(o->imag));
+        case MP_UNARY_OP_POSITIVE:
+            return o_in;
+        case MP_UNARY_OP_NEGATIVE:
+            return mp_obj_new_complex(-o->real, -o->imag);
         case MP_UNARY_OP_ABS:
-            return mp_obj_new_float(MICROPY_FLOAT_C_FUN(sqrt)(o->real*o->real + o->imag*o->imag));
-        default: return MP_OBJ_NULL; // op not supported
+            return mp_obj_new_float(MICROPY_FLOAT_C_FUN(sqrt)(o->real * o->real + o->imag * o->imag));
+        default:
+            return MP_OBJ_NULL;      // op not supported
     }
 }
 
@@ -147,6 +152,7 @@ STATIC void complex_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
 
 const mp_obj_type_t mp_type_complex = {
     { &mp_type_type },
+    .flags = MP_TYPE_FLAG_EQ_NOT_REFLEXIVE | MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
     .name = MP_QSTR_complex,
     .print = complex_print,
     .make_new = complex_make_new,
@@ -187,7 +193,7 @@ mp_obj_t mp_obj_complex_binary_op(mp_binary_op_t op, mp_float_t lhs_real, mp_flo
         case MP_BINARY_OP_MULTIPLY:
         case MP_BINARY_OP_INPLACE_MULTIPLY: {
             mp_float_t real;
-            multiply:
+        multiply:
             real = lhs_real * rhs_real - lhs_imag * rhs_imag;
             lhs_imag = lhs_real * rhs_imag + lhs_imag * rhs_real;
             lhs_real = real;
@@ -195,13 +201,13 @@ mp_obj_t mp_obj_complex_binary_op(mp_binary_op_t op, mp_float_t lhs_real, mp_flo
         }
         case MP_BINARY_OP_FLOOR_DIVIDE:
         case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE:
-            mp_raise_TypeError("can't truncate-divide a complex number");
+            mp_raise_TypeError(MP_ERROR_TEXT("can't truncate-divide a complex number"));
 
         case MP_BINARY_OP_TRUE_DIVIDE:
         case MP_BINARY_OP_INPLACE_TRUE_DIVIDE:
             if (rhs_imag == 0) {
                 if (rhs_real == 0) {
-                    mp_raise_msg(&mp_type_ZeroDivisionError, "complex divide by zero");
+                    mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("complex divide by zero"));
                 }
                 lhs_real /= rhs_real;
                 lhs_imag /= rhs_real;
@@ -210,7 +216,7 @@ mp_obj_t mp_obj_complex_binary_op(mp_binary_op_t op, mp_float_t lhs_real, mp_flo
                 lhs_imag = -lhs_real / rhs_imag;
                 lhs_real = real;
             } else {
-                mp_float_t rhs_len_sq = rhs_real*rhs_real + rhs_imag*rhs_imag;
+                mp_float_t rhs_len_sq = rhs_real * rhs_real + rhs_imag * rhs_imag;
                 rhs_real /= rhs_len_sq;
                 rhs_imag /= -rhs_len_sq;
                 goto multiply;
@@ -224,12 +230,12 @@ mp_obj_t mp_obj_complex_binary_op(mp_binary_op_t op, mp_float_t lhs_real, mp_flo
             //        = exp( (x2*ln1 - y2*arg1) + i*(y2*ln1 + x2*arg1) )
             //        = exp(x3 + i*y3)
             //        = exp(x3)*(cos(y3) + i*sin(y3))
-            mp_float_t abs1 = MICROPY_FLOAT_C_FUN(sqrt)(lhs_real*lhs_real + lhs_imag*lhs_imag);
+            mp_float_t abs1 = MICROPY_FLOAT_C_FUN(sqrt)(lhs_real * lhs_real + lhs_imag * lhs_imag);
             if (abs1 == 0) {
                 if (rhs_imag == 0 && rhs_real >= 0) {
                     lhs_real = (rhs_real == 0);
                 } else {
-                    mp_raise_msg(&mp_type_ZeroDivisionError, "0.0 to a complex power");
+                    mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("0.0 to a complex power"));
                 }
             } else {
                 mp_float_t ln1 = MICROPY_FLOAT_C_FUN(log)(abs1);
@@ -243,7 +249,8 @@ mp_obj_t mp_obj_complex_binary_op(mp_binary_op_t op, mp_float_t lhs_real, mp_flo
             break;
         }
 
-        case MP_BINARY_OP_EQUAL: return mp_obj_new_bool(lhs_real == rhs_real && lhs_imag == rhs_imag);
+        case MP_BINARY_OP_EQUAL:
+            return mp_obj_new_bool(lhs_real == rhs_real && lhs_imag == rhs_imag);
 
         default:
             return MP_OBJ_NULL; // op not supported
diff --git a/py/objdeque.c b/py/objdeque.c
index 1cff1f8d3b411..c95bdeee9e39c 100644
--- a/py/objdeque.c
+++ b/py/objdeque.c
@@ -102,7 +102,7 @@ STATIC mp_obj_t mp_obj_deque_append(mp_obj_t self_in, mp_obj_t arg) {
     }
 
     if (self->flags & FLAG_CHECK_OVERFLOW && new_i_put == self->i_get) {
-        mp_raise_msg(&mp_type_IndexError, "full");
+        mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("full"));
     }
 
     self->items[self->i_put] = arg;
@@ -122,7 +122,7 @@ STATIC mp_obj_t deque_popleft(mp_obj_t self_in) {
     mp_obj_deque_t *self = MP_OBJ_TO_PTR(self_in);
 
     if (self->i_get == self->i_put) {
-        mp_raise_msg(&mp_type_IndexError, "empty");
+        mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("empty"));
     }
 
     mp_obj_t ret = self->items[self->i_get];
@@ -161,7 +161,7 @@ const mp_obj_type_t mp_type_deque = {
     .name = MP_QSTR_deque,
     .make_new = deque_make_new,
     .unary_op = deque_unary_op,
-    .locals_dict = (mp_obj_dict_t*)&deque_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&deque_locals_dict,
 };
 
 #endif // MICROPY_PY_COLLECTIONS_DEQUE
diff --git a/py/objdict.c b/py/objdict.c
index 015c2c72fef8f..7690eeab29af1 100644
--- a/py/objdict.c
+++ b/py/objdict.c
@@ -4,6 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2014-2017 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -30,8 +31,9 @@
 #include "py/runtime.h"
 #include "py/builtin.h"
 #include "py/objtype.h"
+#include "py/objstr.h"
 
-#define mp_obj_is_dict_type(o) (mp_obj_is_obj(o) && ((mp_obj_base_t*)MP_OBJ_TO_PTR(o))->type->make_new == dict_make_new)
+#define mp_obj_is_dict_type(o) (mp_obj_is_obj(o) && ((mp_obj_base_t *)MP_OBJ_TO_PTR(o))->type->make_new == dict_make_new)
 
 STATIC mp_obj_t dict_update(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs);
 
@@ -42,13 +44,15 @@ STATIC mp_map_elem_t *dict_iter_next(mp_obj_dict_t *dict, size_t *cur) {
     size_t max = dict->map.alloc;
     mp_map_t *map = &dict->map;
 
-    for (size_t i = *cur; i < max; i++) {
+    size_t i = *cur;
+    for (; i < max; i++) {
         if (mp_map_slot_is_filled(map, i)) {
             *cur = i + 1;
             return &(map->table[i]);
         }
     }
 
+    assert(map->used == 0 || i == max);
     return NULL;
 }
 
@@ -58,7 +62,7 @@ STATIC void dict_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_
     if (!(MICROPY_PY_UJSON && kind == PRINT_JSON)) {
         kind = PRINT_REPR;
     }
-    if (MICROPY_PY_COLLECTIONS_ORDEREDDICT && self->base.type != &mp_type_dict) {
+    if (MICROPY_PY_COLLECTIONS_ORDEREDDICT && self->base.type != &mp_type_dict && kind != PRINT_JSON) {
         mp_printf(print, "%q(", self->base.type->name);
     }
     mp_print_str(print, "{");
@@ -69,12 +73,19 @@ STATIC void dict_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_
             mp_print_str(print, ", ");
         }
         first = false;
+        bool add_quote = MICROPY_PY_UJSON && kind == PRINT_JSON && !mp_obj_is_str_or_bytes(next->key);
+        if (add_quote) {
+            mp_print_str(print, "\"");
+        }
         mp_obj_print_helper(print, next->key, kind);
+        if (add_quote) {
+            mp_print_str(print, "\"");
+        }
         mp_print_str(print, ": ");
         mp_obj_print_helper(print, next->value, kind);
     }
     mp_print_str(print, "}");
-    if (MICROPY_PY_COLLECTIONS_ORDEREDDICT && self->base.type != &mp_type_dict) {
+    if (MICROPY_PY_COLLECTIONS_ORDEREDDICT && self->base.type != &mp_type_dict && kind != PRINT_JSON) {
         mp_print_str(print, ")");
     }
 }
@@ -100,15 +111,18 @@ STATIC mp_obj_t dict_make_new(const mp_obj_type_t *type, size_t n_args, size_t n
 STATIC mp_obj_t dict_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
     mp_obj_dict_t *self = MP_OBJ_TO_PTR(self_in);
     switch (op) {
-        case MP_UNARY_OP_BOOL: return mp_obj_new_bool(self->map.used != 0);
-        case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(self->map.used);
+        case MP_UNARY_OP_BOOL:
+            return mp_obj_new_bool(self->map.used != 0);
+        case MP_UNARY_OP_LEN:
+            return MP_OBJ_NEW_SMALL_INT(self->map.used);
         #if MICROPY_PY_SYS_GETSIZEOF
         case MP_UNARY_OP_SIZEOF: {
             size_t sz = sizeof(*self) + sizeof(*self->map.table) * self->map.alloc;
             return MP_OBJ_NEW_SMALL_INT(sz);
         }
         #endif
-        default: return MP_OBJ_NULL; // op not supported
+        default:
+            return MP_OBJ_NULL;      // op not supported
     }
 }
 
@@ -132,8 +146,9 @@ STATIC mp_obj_t dict_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_
                     }
                 }
                 return e1 == NULL && e2 == NULL ? mp_const_true : mp_const_false;
-            } else
+            }
             #endif
+
             if (mp_obj_is_type(rhs_in, &mp_type_dict)) {
                 mp_obj_dict_t *rhs = MP_OBJ_TO_PTR(rhs_in);
                 if (o->map.used != rhs->map.used) {
@@ -308,11 +323,17 @@ STATIC mp_obj_t dict_popitem(mp_obj_t self_in) {
     mp_check_self(mp_obj_is_dict_type(self_in));
     mp_obj_dict_t *self = MP_OBJ_TO_PTR(self_in);
     mp_ensure_not_fixed(self);
+    if (self->map.used == 0) {
+        mp_raise_msg(&mp_type_KeyError, MP_ERROR_TEXT("popitem(): dictionary is empty"));
+    }
     size_t cur = 0;
-    mp_map_elem_t *next = dict_iter_next(self, &cur);
-    if (next == NULL) {
-        mp_raise_msg(&mp_type_KeyError, "popitem(): dictionary is empty");
+    #if MICROPY_PY_COLLECTIONS_ORDEREDDICT
+    if (self->map.is_ordered) {
+        cur = self->map.used - 1;
     }
+    #endif
+    mp_map_elem_t *next = dict_iter_next(self, &cur);
+    assert(next);
     self->map.used--;
     mp_obj_t items[] = {next->key, next->value};
     next->key = MP_OBJ_SENTINEL; // must mark key as sentinel to indicate that it was deleted
@@ -338,7 +359,7 @@ STATIC mp_obj_t dict_update(size_t n_args, const mp_obj_t *args, mp_map_t *kwarg
             if (args[1] != args[0]) {
                 size_t cur = 0;
                 mp_map_elem_t *elem = NULL;
-                while ((elem = dict_iter_next((mp_obj_dict_t*)MP_OBJ_TO_PTR(args[1]), &cur)) != NULL) {
+                while ((elem = dict_iter_next((mp_obj_dict_t *)MP_OBJ_TO_PTR(args[1]), &cur)) != NULL) {
                     mp_map_lookup(&self->map, elem->key, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = elem->value;
                 }
             }
@@ -354,7 +375,7 @@ STATIC mp_obj_t dict_update(size_t n_args, const mp_obj_t *args, mp_map_t *kwarg
                 if (key == MP_OBJ_STOP_ITERATION
                     || value == MP_OBJ_STOP_ITERATION
                     || stop != MP_OBJ_STOP_ITERATION) {
-                    mp_raise_ValueError("dict update sequence has wrong length");
+                    mp_raise_ValueError(MP_ERROR_TEXT("dict update sequence has wrong length"));
                 } else {
                     mp_map_lookup(&self->map, key, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
                 }
@@ -434,7 +455,7 @@ STATIC mp_obj_t dict_view_getiter(mp_obj_t view_in, mp_obj_iter_buf_t *iter_buf)
     assert(sizeof(mp_obj_dict_view_it_t) <= sizeof(mp_obj_iter_buf_t));
     mp_check_self(mp_obj_is_type(view_in, &dict_view_type));
     mp_obj_dict_view_t *view = MP_OBJ_TO_PTR(view_in);
-    mp_obj_dict_view_it_t *o = (mp_obj_dict_view_it_t*)iter_buf;
+    mp_obj_dict_view_it_t *o = (mp_obj_dict_view_it_t *)iter_buf;
     o->base.type = &dict_view_it_type;
     o->kind = view->kind;
     o->dict = view->dict;
@@ -516,7 +537,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(dict_values_obj, dict_values);
 STATIC mp_obj_t dict_getiter(mp_obj_t self_in, mp_obj_iter_buf_t *iter_buf) {
     assert(sizeof(mp_obj_dict_view_it_t) <= sizeof(mp_obj_iter_buf_t));
     mp_check_self(mp_obj_is_dict_type(self_in));
-    mp_obj_dict_view_it_t *o = (mp_obj_dict_view_it_t*)iter_buf;
+    mp_obj_dict_view_it_t *o = (mp_obj_dict_view_it_t *)iter_buf;
     o->base.type = &dict_view_it_type;
     o->kind = MP_DICT_VIEW_KEYS;
     o->dict = self_in;
@@ -557,7 +578,7 @@ const mp_obj_type_t mp_type_dict = {
     .binary_op = dict_binary_op,
     .subscr = dict_subscr,
     .getiter = dict_getiter,
-    .locals_dict = (mp_obj_dict_t*)&dict_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&dict_locals_dict,
 };
 
 #if MICROPY_PY_COLLECTIONS_ORDEREDDICT
@@ -571,7 +592,7 @@ const mp_obj_type_t mp_type_ordereddict = {
     .subscr = dict_subscr,
     .getiter = dict_getiter,
     .parent = &mp_type_dict,
-    .locals_dict = (mp_obj_dict_t*)&dict_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&dict_locals_dict,
 };
 #endif
 
diff --git a/py/objenumerate.c b/py/objenumerate.c
index 493e45c2a2028..d1de4add47ba8 100644
--- a/py/objenumerate.c
+++ b/py/objenumerate.c
@@ -40,7 +40,7 @@ typedef struct _mp_obj_enumerate_t {
 STATIC mp_obj_t enumerate_iternext(mp_obj_t self_in);
 
 STATIC mp_obj_t enumerate_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
-#if MICROPY_CPYTHON_COMPAT
+    #if MICROPY_CPYTHON_COMPAT
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_iterable, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
         { MP_QSTR_start, MP_ARG_INT, {.u_int = 0} },
@@ -51,20 +51,20 @@ STATIC mp_obj_t enumerate_make_new(const mp_obj_type_t *type, size_t n_args, siz
         mp_arg_val_t iterable, start;
     } arg_vals;
     mp_arg_parse_all_kw_array(n_args, n_kw, args,
-        MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t*)&arg_vals);
+        MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t *)&arg_vals);
 
     // create enumerate object
     mp_obj_enumerate_t *o = m_new_obj(mp_obj_enumerate_t);
     o->base.type = type;
     o->iter = mp_getiter(arg_vals.iterable.u_obj, NULL);
     o->cur = arg_vals.start.u_int;
-#else
-    (void)n_kw;
+    #else
+    mp_arg_check_num(n_args, n_kw, 1, 2, false);
     mp_obj_enumerate_t *o = m_new_obj(mp_obj_enumerate_t);
     o->base.type = type;
     o->iter = mp_getiter(args[0], NULL);
     o->cur = n_args > 1 ? mp_obj_get_int(args[1]) : 0;
-#endif
+    #endif
 
     return MP_OBJ_FROM_PTR(o);
 }
diff --git a/py/objexcept.c b/py/objexcept.c
index d9258f9b5f6b3..517427ed71365 100644
--- a/py/objexcept.c
+++ b/py/objexcept.c
@@ -4,6 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2014-2016 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -37,6 +38,16 @@
 #include "py/gc.h"
 #include "py/mperrno.h"
 
+#if MICROPY_ROM_TEXT_COMPRESSION && !defined(NO_QSTR)
+// Extract the MP_MAX_UNCOMPRESSED_TEXT_LEN macro from "genhdr/compressed.data.h".
+// Only need this if compression enabled and in a regular build (i.e. not during QSTR extraction).
+#define MP_MATCH_COMPRESSED(...) // Ignore
+#define MP_COMPRESSED_DATA(...) // Ignore
+#include "genhdr/compressed.data.h"
+#undef MP_MATCH_COMPRESSED
+#undef MP_COMPRESSED_DATA
+#endif
+
 // Number of items per traceback entry (file, line, block)
 #define TRACEBACK_ENTRY_LEN (3)
 
@@ -56,8 +67,9 @@
 #define EMG_BUF_TUPLE_OFFSET        (EMG_BUF_TRACEBACK_OFFSET + EMG_BUF_TRACEBACK_SIZE)
 #define EMG_BUF_TUPLE_SIZE(n_args)  (sizeof(mp_obj_tuple_t) + n_args * sizeof(mp_obj_t))
 #define EMG_BUF_STR_OFFSET          (EMG_BUF_TUPLE_OFFSET + EMG_BUF_TUPLE_SIZE(1))
+#define EMG_BUF_STR_BUF_OFFSET      (EMG_BUF_STR_OFFSET + sizeof(mp_obj_str_t))
 
-#   if MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE > 0
+#if MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE > 0
 #define mp_emergency_exception_buf_size MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE
 
 void mp_init_emergency_exception_buf(void) {
@@ -99,10 +111,39 @@ mp_obj_t mp_alloc_emergency_exception_buf(mp_obj_t size_in) {
 #endif
 #endif  // MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF
 
-// Instance of GeneratorExit exception - needed by generator.close()
-// This would belong to objgenerator.c, but to keep mp_obj_exception_t
-// definition module-private so far, have it here.
-const mp_obj_exception_t mp_const_GeneratorExit_obj = {{&mp_type_GeneratorExit}, 0, 0, NULL, (mp_obj_tuple_t*)&mp_const_empty_tuple_obj};
+STATIC void decompress_error_text_maybe(mp_obj_exception_t *o) {
+    #if MICROPY_ROM_TEXT_COMPRESSION
+    if (o->args->len == 1 && mp_obj_is_type(o->args->items[0], &mp_type_str)) {
+        mp_obj_str_t *o_str = MP_OBJ_TO_PTR(o->args->items[0]);
+        if (MP_IS_COMPRESSED_ROM_STRING(o_str->data)) {
+            byte *buf = m_new_maybe(byte, MP_MAX_UNCOMPRESSED_TEXT_LEN + 1);
+            if (!buf) {
+                #if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF
+                // Try and use the emergency exception buf if enough space is available.
+                buf = (byte *)((uint8_t *)MP_STATE_VM(mp_emergency_exception_buf) + EMG_BUF_STR_BUF_OFFSET);
+                size_t avail = (uint8_t *)MP_STATE_VM(mp_emergency_exception_buf) + mp_emergency_exception_buf_size - buf;
+                if (avail < MP_MAX_UNCOMPRESSED_TEXT_LEN + 1) {
+                    // No way to decompress, fallback to no message text.
+                    o->args = (mp_obj_tuple_t *)&mp_const_empty_tuple_obj;
+                    return;
+                }
+                #else
+                o->args = (mp_obj_tuple_t *)&mp_const_empty_tuple_obj;
+                return;
+                #endif
+            }
+            mp_decompress_rom_string(buf, (mp_rom_error_text_t)o_str->data);
+            o_str->data = buf;
+            o_str->len = strlen((const char *)buf);
+            o_str->hash = 0;
+        }
+        // Lazily compute the string hash.
+        if (o_str->hash == 0) {
+            o_str->hash = qstr_compute_hash(o_str->data, o_str->len);
+        }
+    }
+    #endif
+}
 
 void mp_obj_exception_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t kind) {
     mp_obj_exception_t *o = MP_OBJ_TO_PTR(o_in);
@@ -116,6 +157,8 @@ void mp_obj_exception_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kin
         mp_print_str(print, ": ");
     }
 
+    decompress_error_text_maybe(o);
+
     if (k == PRINT_STR || k == PRINT_EXC) {
         if (o->args == NULL || o->args->len == 0) {
             mp_print_str(print, "");
@@ -125,7 +168,7 @@ void mp_obj_exception_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kin
             // try to provide a nice OSError error message
             if (o->base.type == &mp_type_OSError && mp_obj_is_small_int(o->args->items[0])) {
                 qstr qst = mp_errno_to_str(o->args->items[0]);
-                if (qst != MP_QSTR_NULL) {
+                if (qst != MP_QSTRnull) {
                     mp_printf(print, "[Errno " INT_FMT "] %q", MP_OBJ_SMALL_INT_VALUE(o->args->items[0]), qst);
                     return;
                 }
@@ -135,6 +178,7 @@ void mp_obj_exception_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kin
             return;
         }
     }
+
     mp_obj_tuple_print(print, MP_OBJ_FROM_PTR(o->args), kind);
 }
 
@@ -154,7 +198,7 @@ mp_obj_t mp_obj_exception_make_new(const mp_obj_type_t *type, size_t n_args, siz
     mp_obj_tuple_t *o_tuple;
     if (n_args == 0) {
         // No args, can use the empty tuple straightaway
-        o_tuple = (mp_obj_tuple_t*)&mp_const_empty_tuple_obj;
+        o_tuple = (mp_obj_tuple_t *)&mp_const_empty_tuple_obj;
     } else {
         // Try to allocate memory for the tuple containing the args
         o_tuple = m_new_obj_var_maybe(mp_obj_tuple_t, mp_obj_t, n_args);
@@ -165,14 +209,14 @@ mp_obj_t mp_obj_exception_make_new(const mp_obj_type_t *type, size_t n_args, siz
         // Otherwise we are free to use the whole buffer after the traceback data.
         if (o_tuple == NULL && mp_emergency_exception_buf_size >=
             EMG_BUF_TUPLE_OFFSET + EMG_BUF_TUPLE_SIZE(n_args)) {
-            o_tuple = (mp_obj_tuple_t*)
-                ((uint8_t*)MP_STATE_VM(mp_emergency_exception_buf) + EMG_BUF_TUPLE_OFFSET);
+            o_tuple = (mp_obj_tuple_t *)
+                ((uint8_t *)MP_STATE_VM(mp_emergency_exception_buf) + EMG_BUF_TUPLE_OFFSET);
         }
         #endif
 
         if (o_tuple == NULL) {
             // No memory for a tuple, fallback to an empty tuple
-            o_tuple = (mp_obj_tuple_t*)&mp_const_empty_tuple_obj;
+            o_tuple = (mp_obj_tuple_t *)&mp_const_empty_tuple_obj;
         } else {
             // Have memory for a tuple so populate it
             o_tuple->base.type = &mp_type_tuple;
@@ -193,6 +237,7 @@ mp_obj_t mp_obj_exception_get_value(mp_obj_t self_in) {
     if (self->args->len == 0) {
         return mp_const_none;
     } else {
+        decompress_error_text_maybe(self);
         return self->args->items[0];
     }
 }
@@ -214,6 +259,7 @@ void mp_obj_exception_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
         return;
     }
     if (attr == MP_QSTR_args) {
+        decompress_error_text_maybe(self);
         dest[0] = MP_OBJ_FROM_PTR(self->args);
     } else if (self->base.type == &mp_type_StopIteration && attr == MP_QSTR_value) {
         dest[0] = mp_obj_exception_get_value(self_in);
@@ -228,6 +274,8 @@ const mp_obj_type_t mp_type_BaseException = {
     .attr = mp_obj_exception_attr,
 };
 
+// *FORMAT-OFF*
+
 // List of all exceptions, arranged as in the table at:
 // http://docs.python.org/3/library/exceptions.html
 MP_DEFINE_EXCEPTION(SystemExit, BaseException)
@@ -245,10 +293,8 @@ MP_DEFINE_EXCEPTION(Exception, BaseException)
   MP_DEFINE_EXCEPTION(AssertionError, Exception)
   MP_DEFINE_EXCEPTION(AttributeError, Exception)
   //MP_DEFINE_EXCEPTION(BufferError, Exception)
-  //MP_DEFINE_EXCEPTION(EnvironmentError, Exception) use OSError instead
   MP_DEFINE_EXCEPTION(EOFError, Exception)
   MP_DEFINE_EXCEPTION(ImportError, Exception)
-  //MP_DEFINE_EXCEPTION(IOError, Exception) use OSError instead
   MP_DEFINE_EXCEPTION(LookupError, Exception)
     MP_DEFINE_EXCEPTION(IndexError, LookupError)
     MP_DEFINE_EXCEPTION(KeyError, LookupError)
@@ -258,9 +304,6 @@ MP_DEFINE_EXCEPTION(Exception, BaseException)
     MP_DEFINE_EXCEPTION(UnboundLocalError, NameError)
     */
   MP_DEFINE_EXCEPTION(OSError, Exception)
-#if MICROPY_PY_BUILTINS_TIMEOUTERROR
-    MP_DEFINE_EXCEPTION(TimeoutError, OSError)
-#endif
     /*
     MP_DEFINE_EXCEPTION(BlockingIOError, OSError)
     MP_DEFINE_EXCEPTION(ChildProcessError, OSError)
@@ -274,6 +317,7 @@ MP_DEFINE_EXCEPTION(Exception, BaseException)
     MP_DEFINE_EXCEPTION(NotADirectoryError, OSError)
     MP_DEFINE_EXCEPTION(PermissionError, OSError)
     MP_DEFINE_EXCEPTION(ProcessLookupError, OSError)
+    MP_DEFINE_EXCEPTION(TimeoutError, OSError)
     MP_DEFINE_EXCEPTION(FileExistsError, OSError)
     MP_DEFINE_EXCEPTION(FileNotFoundError, OSError)
     MP_DEFINE_EXCEPTION(ReferenceError, Exception)
@@ -309,21 +353,25 @@ MP_DEFINE_EXCEPTION(Exception, BaseException)
     MP_DEFINE_EXCEPTION(ResourceWarning, Warning)
     */
 
+// *FORMAT-ON*
+
 mp_obj_t mp_obj_new_exception(const mp_obj_type_t *exc_type) {
-    return mp_obj_new_exception_args(exc_type, 0, NULL);
+    assert(exc_type->make_new == mp_obj_exception_make_new);
+    return mp_obj_exception_make_new(exc_type, 0, 0, NULL);
 }
 
 // "Optimized" version for common(?) case of having 1 exception arg
 mp_obj_t mp_obj_new_exception_arg1(const mp_obj_type_t *exc_type, mp_obj_t arg) {
-    return mp_obj_new_exception_args(exc_type, 1, &arg);
+    assert(exc_type->make_new == mp_obj_exception_make_new);
+    return mp_obj_exception_make_new(exc_type, 1, 0, &arg);
 }
 
 mp_obj_t mp_obj_new_exception_args(const mp_obj_type_t *exc_type, size_t n_args, const mp_obj_t *args) {
     assert(exc_type->make_new == mp_obj_exception_make_new);
-    return exc_type->make_new(exc_type, n_args, 0, args);
+    return mp_obj_exception_make_new(exc_type, n_args, 0, args);
 }
 
-mp_obj_t mp_obj_new_exception_msg(const mp_obj_type_t *exc_type, const char *msg) {
+mp_obj_t mp_obj_new_exception_msg(const mp_obj_type_t *exc_type, mp_rom_error_text_t msg) {
     // Check that the given type is an exception type
     assert(exc_type->make_new == mp_obj_exception_make_new);
 
@@ -336,7 +384,7 @@ mp_obj_t mp_obj_new_exception_msg(const mp_obj_type_t *exc_type, const char *msg
     // traceback and 1-tuple.
     if (o_str == NULL
         && mp_emergency_exception_buf_size >= EMG_BUF_STR_OFFSET + sizeof(mp_obj_str_t)) {
-        o_str = (mp_obj_str_t*)((uint8_t*)MP_STATE_VM(mp_emergency_exception_buf)
+        o_str = (mp_obj_str_t *)((uint8_t *)MP_STATE_VM(mp_emergency_exception_buf)
             + EMG_BUF_STR_OFFSET);
     }
     #endif
@@ -348,9 +396,13 @@ mp_obj_t mp_obj_new_exception_msg(const mp_obj_type_t *exc_type, const char *msg
 
     // Create the string object and call mp_obj_exception_make_new to create the exception
     o_str->base.type = &mp_type_str;
-    o_str->len = strlen(msg);
-    o_str->data = (const byte*)msg;
+    o_str->len = strlen((const char *)msg);
+    o_str->data = (const byte *)msg;
+    #if MICROPY_ROM_TEXT_COMPRESSION
+    o_str->hash = 0; // will be computed only if string object is accessed
+    #else
     o_str->hash = qstr_compute_hash(o_str->data, o_str->len);
+    #endif
     mp_obj_t arg = MP_OBJ_FROM_PTR(o_str);
     return mp_obj_exception_make_new(exc_type, 1, 0, &arg);
 }
@@ -388,7 +440,15 @@ STATIC void exc_add_strn(void *data, const char *str, size_t len) {
     pr->len += len;
 }
 
-mp_obj_t mp_obj_new_exception_msg_varg(const mp_obj_type_t *exc_type, const char *fmt, ...) {
+mp_obj_t mp_obj_new_exception_msg_varg(const mp_obj_type_t *exc_type, mp_rom_error_text_t fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    mp_obj_t exc = mp_obj_new_exception_msg_vlist(exc_type, fmt, args);
+    va_end(args);
+    return exc;
+}
+
+mp_obj_t mp_obj_new_exception_msg_vlist(const mp_obj_type_t *exc_type, mp_rom_error_text_t fmt, va_list args) {
     assert(fmt != NULL);
 
     // Check that the given type is an exception type
@@ -396,7 +456,7 @@ mp_obj_t mp_obj_new_exception_msg_varg(const mp_obj_type_t *exc_type, const char
 
     // Try to allocate memory for the message
     mp_obj_str_t *o_str = m_new_obj_maybe(mp_obj_str_t);
-    size_t o_str_alloc = strlen(fmt) + 1;
+    size_t o_str_alloc = strlen((const char *)fmt) + 1;
     byte *o_str_buf = m_new_maybe(byte, o_str_alloc);
 
     bool used_emg_buf = false;
@@ -407,32 +467,39 @@ mp_obj_t mp_obj_new_exception_msg_varg(const mp_obj_type_t *exc_type, const char
     if ((o_str == NULL || o_str_buf == NULL)
         && mp_emergency_exception_buf_size >= EMG_BUF_STR_OFFSET + sizeof(mp_obj_str_t) + 16) {
         used_emg_buf = true;
-        o_str = (mp_obj_str_t*)((uint8_t*)MP_STATE_VM(mp_emergency_exception_buf)
-            + EMG_BUF_STR_OFFSET);
-        o_str_buf = (byte*)&o_str[1];
-        o_str_alloc = (uint8_t*)MP_STATE_VM(mp_emergency_exception_buf)
-            + mp_emergency_exception_buf_size - o_str_buf;
+        o_str = (mp_obj_str_t *)((uint8_t *)MP_STATE_VM(mp_emergency_exception_buf) + EMG_BUF_STR_OFFSET);
+        o_str_buf = (byte *)((uint8_t *)MP_STATE_VM(mp_emergency_exception_buf) + EMG_BUF_STR_BUF_OFFSET);
+        o_str_alloc = (uint8_t *)MP_STATE_VM(mp_emergency_exception_buf) + mp_emergency_exception_buf_size - o_str_buf;
     }
     #endif
 
     if (o_str == NULL) {
-        // No memory for the string object so create the exception with no args
+        // No memory for the string object so create the exception with no args.
+        // The exception will only have a type and no message (compression is irrelevant).
         return mp_obj_exception_make_new(exc_type, 0, 0, NULL);
     }
 
     if (o_str_buf == NULL) {
         // No memory for the string buffer: assume that the fmt string is in ROM
-        // and use that data as the data of the string
+        // and use that data as the data of the string.
+        // The string will point directly to the compressed data -- will need to be decompressed
+        // prior to display (this case is identical to mp_obj_new_exception_msg above).
         o_str->len = o_str_alloc - 1; // will be equal to strlen(fmt)
-        o_str->data = (const byte*)fmt;
+        o_str->data = (const byte *)fmt;
     } else {
-        // We have some memory to format the string
+        // We have some memory to format the string.
+        // TODO: Optimise this to format-while-decompressing (and not require the temp stack space).
         struct _exc_printer_t exc_pr = {!used_emg_buf, o_str_alloc, 0, o_str_buf};
         mp_print_t print = {&exc_pr, exc_add_strn};
-        va_list ap;
-        va_start(ap, fmt);
-        mp_vprintf(&print, fmt, ap);
-        va_end(ap);
+        const char *fmt2 = (const char *)fmt;
+        #if MICROPY_ROM_TEXT_COMPRESSION
+        byte decompressed[MP_MAX_UNCOMPRESSED_TEXT_LEN];
+        if (MP_IS_COMPRESSED_ROM_STRING(fmt)) {
+            mp_decompress_rom_string(decompressed, fmt);
+            fmt2 = (const char *)decompressed;
+        }
+        #endif
+        mp_vprintf(&print, fmt2, args);
         exc_pr.buf[exc_pr.len] = '\0';
         o_str->len = exc_pr.len;
         o_str->data = exc_pr.buf;
@@ -440,7 +507,11 @@ mp_obj_t mp_obj_new_exception_msg_varg(const mp_obj_type_t *exc_type, const char
 
     // Create the string object and call mp_obj_exception_make_new to create the exception
     o_str->base.type = &mp_type_str;
+    #if MICROPY_ROM_TEXT_COMPRESSION
+    o_str->hash = 0; // will be computed only if string object is accessed
+    #else
     o_str->hash = qstr_compute_hash(o_str->data, o_str->len);
+    #endif
     mp_obj_t arg = MP_OBJ_FROM_PTR(o_str);
     return mp_obj_exception_make_new(exc_type, 1, 0, &arg);
 }
@@ -482,7 +553,7 @@ bool mp_obj_exception_match(mp_obj_t exc, mp_const_obj_t exc_type) {
     if (mp_obj_is_native_exception_instance(self_in)) { \
         self = MP_OBJ_TO_PTR(self_in); \
     } else { \
-        self = MP_OBJ_TO_PTR(((mp_obj_instance_t*)MP_OBJ_TO_PTR(self_in))->subobj[0]); \
+        self = MP_OBJ_TO_PTR(((mp_obj_instance_t *)MP_OBJ_TO_PTR(self_in))->subobj[0]); \
     }
 
 void mp_obj_exception_clear_traceback(mp_obj_t self_in) {
@@ -504,7 +575,7 @@ void mp_obj_exception_add_traceback(mp_obj_t self_in, qstr file, size_t line, qs
             #if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF
             if (mp_emergency_exception_buf_size >= EMG_BUF_TRACEBACK_OFFSET + EMG_BUF_TRACEBACK_SIZE) {
                 // There is room in the emergency buffer for traceback data
-                size_t *tb = (size_t*)((uint8_t*)MP_STATE_VM(mp_emergency_exception_buf)
+                size_t *tb = (size_t *)((uint8_t *)MP_STATE_VM(mp_emergency_exception_buf)
                     + EMG_BUF_TRACEBACK_OFFSET);
                 self->traceback_data = tb;
                 self->traceback_alloc = EMG_BUF_TRACEBACK_SIZE / sizeof(size_t);
@@ -523,7 +594,7 @@ void mp_obj_exception_add_traceback(mp_obj_t self_in, qstr file, size_t line, qs
         self->traceback_len = 0;
     } else if (self->traceback_len + TRACEBACK_ENTRY_LEN > self->traceback_alloc) {
         #if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF
-        if (self->traceback_data == (size_t*)MP_STATE_VM(mp_emergency_exception_buf)) {
+        if (self->traceback_data == (size_t *)MP_STATE_VM(mp_emergency_exception_buf)) {
             // Can't resize the emergency buffer
             return;
         }
diff --git a/py/objexcept.h b/py/objexcept.h
index 7c307622487ea..384456bb51a94 100644
--- a/py/objexcept.h
+++ b/py/objexcept.h
@@ -41,13 +41,13 @@ void mp_obj_exception_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kin
 void mp_obj_exception_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest);
 
 #define MP_DEFINE_EXCEPTION(exc_name, base_name) \
-const mp_obj_type_t mp_type_ ## exc_name = { \
-    { &mp_type_type }, \
-    .name = MP_QSTR_ ## exc_name, \
-    .print = mp_obj_exception_print, \
-    .make_new = mp_obj_exception_make_new, \
-    .attr = mp_obj_exception_attr, \
-    .parent = &mp_type_ ## base_name, \
-};
+    const mp_obj_type_t mp_type_##exc_name = { \
+        { &mp_type_type }, \
+        .name = MP_QSTR_##exc_name, \
+        .print = mp_obj_exception_print, \
+        .make_new = mp_obj_exception_make_new, \
+        .attr = mp_obj_exception_attr, \
+        .parent = &mp_type_##base_name, \
+    };
 
 #endif // MICROPY_INCLUDED_PY_OBJEXCEPT_H
diff --git a/py/objfloat.c b/py/objfloat.c
index 3da549bb25a5c..09b73c8cda525 100644
--- a/py/objfloat.c
+++ b/py/objfloat.c
@@ -52,29 +52,17 @@ typedef struct _mp_obj_float_t {
     mp_float_t value;
 } mp_obj_float_t;
 
-const mp_obj_float_t mp_const_float_e_obj = {{&mp_type_float}, M_E};
-const mp_obj_float_t mp_const_float_pi_obj = {{&mp_type_float}, M_PI};
+const mp_obj_float_t mp_const_float_e_obj = {{&mp_type_float}, (mp_float_t)M_E};
+const mp_obj_float_t mp_const_float_pi_obj = {{&mp_type_float}, (mp_float_t)M_PI};
 
 #endif
 
+#define MICROPY_FLOAT_ZERO MICROPY_FLOAT_CONST(0.0)
+
 #if MICROPY_FLOAT_HIGH_QUALITY_HASH
 // must return actual integer value if it fits in mp_int_t
 mp_int_t mp_float_hash(mp_float_t src) {
-#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
-typedef uint64_t mp_float_uint_t;
-#elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
-typedef uint32_t mp_float_uint_t;
-#endif
-    union {
-        mp_float_t f;
-        #if MP_ENDIANNESS_LITTLE
-        struct { mp_float_uint_t frc:MP_FLOAT_FRAC_BITS, exp:MP_FLOAT_EXP_BITS, sgn:1; } p;
-        #else
-        struct { mp_float_uint_t sgn:1, exp:MP_FLOAT_EXP_BITS, frc:MP_FLOAT_FRAC_BITS; } p;
-        #endif
-        mp_float_uint_t i;
-    } u = {.f = src};
-
+    mp_float_union_t u = {.f = src};
     mp_int_t val;
     const int adj_exp = (int)u.p.exp - MP_FLOAT_EXP_BIAS;
     if (adj_exp < 0) {
@@ -109,17 +97,17 @@ typedef uint32_t mp_float_uint_t;
 STATIC void float_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t kind) {
     (void)kind;
     mp_float_t o_val = mp_obj_float_get(o_in);
-#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
+    #if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
     char buf[16];
     #if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
     const int precision = 6;
     #else
     const int precision = 7;
     #endif
-#else
+    #else
     char buf[32];
     const int precision = 16;
-#endif
+    #endif
     mp_format_float(o_val, buf, sizeof(buf), 'g', precision, '\0');
     mp_print_str(print, buf);
     if (strchr(buf, '.') == NULL && strchr(buf, 'e') == NULL && strchr(buf, 'n') == NULL) {
@@ -156,10 +144,14 @@ STATIC mp_obj_t float_make_new(const mp_obj_type_t *type_in, size_t n_args, size
 STATIC mp_obj_t float_unary_op(mp_unary_op_t op, mp_obj_t o_in) {
     mp_float_t val = mp_obj_float_get(o_in);
     switch (op) {
-        case MP_UNARY_OP_BOOL: return mp_obj_new_bool(val != 0);
-        case MP_UNARY_OP_HASH: return MP_OBJ_NEW_SMALL_INT(mp_float_hash(val));
-        case MP_UNARY_OP_POSITIVE: return o_in;
-        case MP_UNARY_OP_NEGATIVE: return mp_obj_new_float(-val);
+        case MP_UNARY_OP_BOOL:
+            return mp_obj_new_bool(val != 0);
+        case MP_UNARY_OP_HASH:
+            return MP_OBJ_NEW_SMALL_INT(mp_float_hash(val));
+        case MP_UNARY_OP_POSITIVE:
+            return o_in;
+        case MP_UNARY_OP_NEGATIVE:
+            return mp_obj_new_float(-val);
         case MP_UNARY_OP_ABS: {
             if (signbit(val)) {
                 return mp_obj_new_float(-val);
@@ -167,24 +159,24 @@ STATIC mp_obj_t float_unary_op(mp_unary_op_t op, mp_obj_t o_in) {
                 return o_in;
             }
         }
-        default: return MP_OBJ_NULL; // op not supported
+        default:
+            return MP_OBJ_NULL;      // op not supported
     }
 }
 
 STATIC mp_obj_t float_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
     mp_float_t lhs_val = mp_obj_float_get(lhs_in);
-#if MICROPY_PY_BUILTINS_COMPLEX
+    #if MICROPY_PY_BUILTINS_COMPLEX
     if (mp_obj_is_type(rhs_in, &mp_type_complex)) {
         return mp_obj_complex_binary_op(op, lhs_val, 0, rhs_in);
-    } else
-#endif
-    {
-        return mp_obj_float_binary_op(op, lhs_val, rhs_in);
     }
+    #endif
+    return mp_obj_float_binary_op(op, lhs_val, rhs_in);
 }
 
 const mp_obj_type_t mp_type_float = {
     { &mp_type_type },
+    .flags = MP_TYPE_FLAG_EQ_NOT_REFLEXIVE | MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
     .name = MP_QSTR_float,
     .print = float_print,
     .make_new = float_make_new,
@@ -218,24 +210,24 @@ STATIC void mp_obj_float_divmod(mp_float_t *x, mp_float_t *y) {
     mp_float_t div = (*x - mod) / *y;
 
     // Python specs require that mod has same sign as second operand
-    if (mod == 0.0) {
-        mod = MICROPY_FLOAT_C_FUN(copysign)(0.0, *y);
+    if (mod == MICROPY_FLOAT_ZERO) {
+        mod = MICROPY_FLOAT_C_FUN(copysign)(MICROPY_FLOAT_ZERO, *y);
     } else {
-        if ((mod < 0.0) != (*y < 0.0)) {
+        if ((mod < MICROPY_FLOAT_ZERO) != (*y < MICROPY_FLOAT_ZERO)) {
             mod += *y;
-            div -= 1.0;
+            div -= MICROPY_FLOAT_CONST(1.0);
         }
     }
 
     mp_float_t floordiv;
-    if (div == 0.0) {
+    if (div == MICROPY_FLOAT_ZERO) {
         // if division is zero, take the correct sign of zero
-        floordiv = MICROPY_FLOAT_C_FUN(copysign)(0.0, *x / *y);
+        floordiv = MICROPY_FLOAT_C_FUN(copysign)(MICROPY_FLOAT_ZERO, *x / *y);
     } else {
         // Python specs require that x == (x//y)*y + (x%y)
         floordiv = MICROPY_FLOAT_C_FUN(floor)(div);
-        if (div - floordiv > 0.5) {
-            floordiv += 1.0;
+        if (div - floordiv > MICROPY_FLOAT_CONST(0.5)) {
+            floordiv += MICROPY_FLOAT_CONST(1.0);
         }
     }
 
@@ -252,16 +244,22 @@ mp_obj_t mp_obj_float_binary_op(mp_binary_op_t op, mp_float_t lhs_val, mp_obj_t
 
     switch (op) {
         case MP_BINARY_OP_ADD:
-        case MP_BINARY_OP_INPLACE_ADD: lhs_val += rhs_val; break;
+        case MP_BINARY_OP_INPLACE_ADD:
+            lhs_val += rhs_val;
+            break;
         case MP_BINARY_OP_SUBTRACT:
-        case MP_BINARY_OP_INPLACE_SUBTRACT: lhs_val -= rhs_val; break;
+        case MP_BINARY_OP_INPLACE_SUBTRACT:
+            lhs_val -= rhs_val;
+            break;
         case MP_BINARY_OP_MULTIPLY:
-        case MP_BINARY_OP_INPLACE_MULTIPLY: lhs_val *= rhs_val; break;
+        case MP_BINARY_OP_INPLACE_MULTIPLY:
+            lhs_val *= rhs_val;
+            break;
         case MP_BINARY_OP_FLOOR_DIVIDE:
         case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE:
             if (rhs_val == 0) {
-                zero_division_error:
-                mp_raise_msg(&mp_type_ZeroDivisionError, "divide by zero");
+            zero_division_error:
+                mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("divide by zero"));
             }
             // Python specs require that x == (x//y)*y + (x%y) so we must
             // call divmod to compute the correct floor division, which
@@ -277,15 +275,15 @@ mp_obj_t mp_obj_float_binary_op(mp_binary_op_t op, mp_float_t lhs_val, mp_obj_t
             break;
         case MP_BINARY_OP_MODULO:
         case MP_BINARY_OP_INPLACE_MODULO:
-            if (rhs_val == 0) {
+            if (rhs_val == MICROPY_FLOAT_ZERO) {
                 goto zero_division_error;
             }
             lhs_val = MICROPY_FLOAT_C_FUN(fmod)(lhs_val, rhs_val);
             // Python specs require that mod has same sign as second operand
-            if (lhs_val == 0.0) {
+            if (lhs_val == MICROPY_FLOAT_ZERO) {
                 lhs_val = MICROPY_FLOAT_C_FUN(copysign)(0.0, rhs_val);
             } else {
-                if ((lhs_val < 0.0) != (rhs_val < 0.0)) {
+                if ((lhs_val < MICROPY_FLOAT_ZERO) != (rhs_val < MICROPY_FLOAT_ZERO)) {
                     lhs_val += rhs_val;
                 }
             }
@@ -299,7 +297,7 @@ mp_obj_t mp_obj_float_binary_op(mp_binary_op_t op, mp_float_t lhs_val, mp_obj_t
                 #if MICROPY_PY_BUILTINS_COMPLEX
                 return mp_obj_complex_binary_op(MP_BINARY_OP_POWER, lhs_val, 0, rhs_in);
                 #else
-                mp_raise_ValueError("complex values not supported");
+                mp_raise_ValueError(MP_ERROR_TEXT("complex values not supported"));
                 #endif
             }
             lhs_val = MICROPY_FLOAT_C_FUN(pow)(lhs_val, rhs_val);
@@ -315,11 +313,16 @@ mp_obj_t mp_obj_float_binary_op(mp_binary_op_t op, mp_float_t lhs_val, mp_obj_t
             };
             return mp_obj_new_tuple(2, tuple);
         }
-        case MP_BINARY_OP_LESS: return mp_obj_new_bool(lhs_val < rhs_val);
-        case MP_BINARY_OP_MORE: return mp_obj_new_bool(lhs_val > rhs_val);
-        case MP_BINARY_OP_EQUAL: return mp_obj_new_bool(lhs_val == rhs_val);
-        case MP_BINARY_OP_LESS_EQUAL: return mp_obj_new_bool(lhs_val <= rhs_val);
-        case MP_BINARY_OP_MORE_EQUAL: return mp_obj_new_bool(lhs_val >= rhs_val);
+        case MP_BINARY_OP_LESS:
+            return mp_obj_new_bool(lhs_val < rhs_val);
+        case MP_BINARY_OP_MORE:
+            return mp_obj_new_bool(lhs_val > rhs_val);
+        case MP_BINARY_OP_EQUAL:
+            return mp_obj_new_bool(lhs_val == rhs_val);
+        case MP_BINARY_OP_LESS_EQUAL:
+            return mp_obj_new_bool(lhs_val <= rhs_val);
+        case MP_BINARY_OP_MORE_EQUAL:
+            return mp_obj_new_bool(lhs_val >= rhs_val);
 
         default:
             return MP_OBJ_NULL; // op not supported
diff --git a/py/objfun.c b/py/objfun.c
index d50b7fa25dc84..3a63d8f439d2b 100644
--- a/py/objfun.c
+++ b/py/objfun.c
@@ -139,7 +139,7 @@ const mp_obj_type_t mp_type_fun_builtin_var = {
 /* byte code functions                                                        */
 
 qstr mp_obj_code_get_name(const byte *code_info) {
-    code_info = mp_decode_uint_skip(code_info); // skip code_info_size entry
+    MP_BC_PRELUDE_SIZE_DECODE(code_info);
     #if MICROPY_PERSISTENT_CODE
     return code_info[0] | (code_info[1] << 8);
     #else
@@ -161,12 +161,7 @@ qstr mp_obj_fun_get_name(mp_const_obj_t fun_in) {
     #endif
 
     const byte *bc = fun->bytecode;
-    bc = mp_decode_uint_skip(bc); // skip n_state
-    bc = mp_decode_uint_skip(bc); // skip n_exc_stack
-    bc++; // skip scope_params
-    bc++; // skip n_pos_args
-    bc++; // skip n_kwonly_args
-    bc++; // skip n_def_pos_args
+    MP_BC_PRELUDE_SIG_DECODE(bc);
     return mp_obj_code_get_name(bc);
 }
 
@@ -193,22 +188,23 @@ STATIC void dump_args(const mp_obj_t *a, size_t sz) {
 // With this macro you can tune the maximum number of function state bytes
 // that will be allocated on the stack.  Any function that needs more
 // than this will try to use the heap, with fallback to stack allocation.
-#define VM_MAX_STATE_ON_STACK (11 * sizeof(mp_uint_t))
+#define VM_MAX_STATE_ON_STACK (sizeof(mp_uint_t) * 11)
 
 #define DECODE_CODESTATE_SIZE(bytecode, n_state_out_var, state_size_out_var) \
     { \
-        /* bytecode prelude: state size and exception stack size */               \
-        n_state_out_var = mp_decode_uint_value(bytecode);                         \
-        size_t n_exc_stack = mp_decode_uint_value(mp_decode_uint_skip(bytecode)); \
-                                                                                  \
+        const uint8_t *ip = bytecode; \
+        size_t n_exc_stack, scope_flags, n_pos_args, n_kwonly_args, n_def_args; \
+        MP_BC_PRELUDE_SIG_DECODE_INTO(ip, n_state_out_var, n_exc_stack, scope_flags, n_pos_args, n_kwonly_args, n_def_args); \
+                                    \
         /* state size in bytes */                                                 \
-        state_size_out_var = n_state_out_var * sizeof(mp_obj_t)                   \
-                           + n_exc_stack * sizeof(mp_exc_stack_t);                \
+        state_size_out_var = n_state_out_var *sizeof(mp_obj_t)                   \
+            + n_exc_stack *sizeof(mp_exc_stack_t);                \
     }
 
-#define INIT_CODESTATE(code_state, _fun_bc, n_args, n_kw, args) \
+#define INIT_CODESTATE(code_state, _fun_bc, _n_state, n_args, n_kw, args) \
     code_state->fun_bc = _fun_bc; \
     code_state->ip = 0; \
+    code_state->n_state = _n_state; \
     mp_setup_code_state(code_state, n_args, n_kw, args); \
     code_state->old_globals = mp_globals_get();
 
@@ -235,7 +231,7 @@ mp_code_state_t *mp_obj_fun_bc_prepare_codestate(mp_obj_t self_in, size_t n_args
     }
     #endif
 
-    INIT_CODESTATE(code_state, self, n_args, n_kw, args);
+    INIT_CODESTATE(code_state, self, n_state, n_args, n_kw, args);
 
     // execute the byte code with the correct globals context
     mp_globals_set(self->globals);
@@ -280,7 +276,7 @@ STATIC mp_obj_t fun_bc_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const
     }
     #endif
 
-    INIT_CODESTATE(code_state, self, n_args, n_kw, args);
+    INIT_CODESTATE(code_state, self, n_state, n_args, n_kw, args);
 
     // execute the byte code with the correct globals context
     mp_globals_set(self->globals);
@@ -294,9 +290,11 @@ STATIC mp_obj_t fun_bc_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const
             assert(0);
         }
     }
-    const byte *bytecode_ptr = mp_decode_uint_skip(mp_decode_uint_skip(self->bytecode));
-    size_t n_pos_args = bytecode_ptr[1];
-    size_t n_kwonly_args = bytecode_ptr[2];
+    const byte *bytecode_ptr = self->bytecode;
+    size_t n_state_unused, n_exc_stack_unused, scope_flags_unused;
+    size_t n_pos_args, n_kwonly_args, n_def_args_unused;
+    MP_BC_PRELUDE_SIG_DECODE_INTO(bytecode_ptr, n_state_unused, n_exc_stack_unused,
+        scope_flags_unused, n_pos_args, n_kwonly_args, n_def_args_unused);
     // We can't check the case when an exception is returned in state[0]
     // and there are no arguments, because in this case our detection slot may have
     // been overwritten by the returned exception (which is allowed).
@@ -358,14 +356,14 @@ void mp_obj_fun_bc_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
 const mp_obj_type_t mp_type_fun_bc = {
     { &mp_type_type },
     .name = MP_QSTR_function,
-#if MICROPY_CPYTHON_COMPAT
+    #if MICROPY_CPYTHON_COMPAT
     .print = fun_bc_print,
-#endif
+    #endif
     .call = fun_bc_call,
     .unary_op = mp_generic_unary_op,
-#if MICROPY_PY_FUNCTION_ATTRS
+    #if MICROPY_PY_FUNCTION_ATTRS
     .attr = mp_obj_fun_bc_attr,
-#endif
+    #endif
 };
 
 mp_obj_t mp_obj_new_fun_bc(mp_obj_t def_args_in, mp_obj_t def_kw_args, const byte *code, const mp_uint_t *const_table) {
@@ -402,7 +400,7 @@ mp_obj_t mp_obj_new_fun_bc(mp_obj_t def_args_in, mp_obj_t def_kw_args, const byt
 STATIC mp_obj_t fun_native_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     MP_STACK_CHECK();
     mp_obj_fun_bc_t *self = self_in;
-    mp_call_fun_t fun = MICROPY_MAKE_POINTER_CALLABLE((void*)self->bytecode);
+    mp_call_fun_t fun = MICROPY_MAKE_POINTER_CALLABLE((void *)self->bytecode);
     return fun(self_in, n_args, n_kw, args);
 }
 
@@ -414,7 +412,7 @@ STATIC const mp_obj_type_t mp_type_fun_native = {
 };
 
 mp_obj_t mp_obj_new_fun_native(mp_obj_t def_args_in, mp_obj_t def_kw_args, const void *fun_data, const mp_uint_t *const_table) {
-    mp_obj_fun_bc_t *o = mp_obj_new_fun_bc(def_args_in, def_kw_args, (const byte*)fun_data, const_table);
+    mp_obj_fun_bc_t *o = mp_obj_new_fun_bc(def_args_in, def_kw_args, (const byte *)fun_data, const_table);
     o->base.type = &mp_type_fun_native;
     return o;
 }
@@ -457,14 +455,14 @@ STATIC mp_uint_t convert_obj_for_inline_asm(mp_obj_t obj) {
         size_t l;
         return (mp_uint_t)mp_obj_str_get_data(obj, &l);
     } else {
-        mp_obj_type_t *type = mp_obj_get_type(obj);
-        if (0) {
-#if MICROPY_PY_BUILTINS_FLOAT
-        } else if (type == &mp_type_float) {
+        const mp_obj_type_t *type = mp_obj_get_type(obj);
+        #if MICROPY_PY_BUILTINS_FLOAT
+        if (type == &mp_type_float) {
             // convert float to int (could also pass in float registers)
             return (mp_int_t)mp_obj_float_get(obj);
-#endif
-        } else if (type == &mp_type_tuple || type == &mp_type_list) {
+        }
+        #endif
+        if (type == &mp_type_tuple || type == &mp_type_list) {
             // pointer to start of tuple (could pass length, but then could use len(x) for that)
             size_t len;
             mp_obj_t *items;
@@ -472,7 +470,7 @@ STATIC mp_uint_t convert_obj_for_inline_asm(mp_obj_t obj) {
             return (mp_uint_t)items;
         } else {
             mp_buffer_info_t bufinfo;
-            if (mp_get_buffer(obj, &bufinfo, MP_BUFFER_WRITE)) {
+            if (mp_get_buffer(obj, &bufinfo, MP_BUFFER_READ)) {
                 // supports the buffer protocol, return a pointer to the data
                 return (mp_uint_t)bufinfo.buf;
             } else {
@@ -507,7 +505,7 @@ STATIC mp_obj_t fun_asm_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const
             convert_obj_for_inline_asm(args[1]),
             convert_obj_for_inline_asm(args[2]),
             convert_obj_for_inline_asm(args[3])
-        );
+            );
     }
 
     return mp_native_to_obj(ret, self->type_sig);
diff --git a/py/objfun.h b/py/objfun.h
index 257b8a65a7381..905b5dbca6d19 100644
--- a/py/objfun.h
+++ b/py/objfun.h
@@ -33,6 +33,9 @@ typedef struct _mp_obj_fun_bc_t {
     mp_obj_dict_t *globals;         // the context within which this function was defined
     const byte *bytecode;           // bytecode for the function
     const mp_uint_t *const_table;   // constant table
+    #if MICROPY_PY_SYS_SETTRACE
+    const struct _mp_raw_code_t *rc;
+    #endif
     // the following extra_args array is allocated space to take (in order):
     //  - values of positional default args (if any)
     //  - a single slot for default kw args dict (if it has them)
diff --git a/py/objgenerator.c b/py/objgenerator.c
index c306bb0c588ed..5e140ba234474 100644
--- a/py/objgenerator.c
+++ b/py/objgenerator.c
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2013-2019 Damien P. George
  * Copyright (c) 2014-2017 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -30,16 +30,23 @@
 
 #include "py/runtime.h"
 #include "py/bc.h"
+#include "py/objstr.h"
 #include "py/objgenerator.h"
 #include "py/objfun.h"
 #include "py/stackctrl.h"
 
+// Instance of GeneratorExit exception - needed by generator.close()
+const mp_obj_exception_t mp_const_GeneratorExit_obj = {{&mp_type_GeneratorExit}, 0, 0, NULL, (mp_obj_tuple_t *)&mp_const_empty_tuple_obj};
+
 /******************************************************************************/
 /* generator wrapper                                                          */
 
 typedef struct _mp_obj_gen_instance_t {
     mp_obj_base_t base;
-    mp_obj_dict_t *globals;
+    // mp_const_none: Not-running, no exception.
+    // MP_OBJ_NULL: Running, no exception.
+    // other: Not running, pending exception.
+    mp_obj_t pend_exc;
     mp_code_state_t code_state;
 } mp_obj_gen_instance_t;
 
@@ -48,17 +55,18 @@ STATIC mp_obj_t gen_wrap_call(mp_obj_t self_in, size_t n_args, size_t n_kw, cons
     mp_obj_fun_bc_t *self_fun = MP_OBJ_TO_PTR(self_in);
 
     // bytecode prelude: get state size and exception stack size
-    size_t n_state = mp_decode_uint_value(self_fun->bytecode);
-    size_t n_exc_stack = mp_decode_uint_value(mp_decode_uint_skip(self_fun->bytecode));
+    const uint8_t *ip = self_fun->bytecode;
+    MP_BC_PRELUDE_SIG_DECODE(ip);
 
     // allocate the generator object, with room for local stack and exception stack
     mp_obj_gen_instance_t *o = m_new_obj_var(mp_obj_gen_instance_t, byte,
         n_state * sizeof(mp_obj_t) + n_exc_stack * sizeof(mp_exc_stack_t));
     o->base.type = &mp_type_gen_instance;
 
-    o->globals = self_fun->globals;
+    o->pend_exc = mp_const_none;
     o->code_state.fun_bc = self_fun;
     o->code_state.ip = 0;
+    o->code_state.n_state = n_state;
     mp_setup_code_state(&o->code_state, n_args, n_kw, args);
     return MP_OBJ_FROM_PTR(o);
 }
@@ -83,8 +91,15 @@ STATIC mp_obj_t native_gen_wrap_call(mp_obj_t self_in, size_t n_args, size_t n_k
     mp_obj_fun_bc_t *self_fun = MP_OBJ_TO_PTR(self_in);
 
     // Determine start of prelude, and extract n_state from it
-    uintptr_t prelude_offset = ((uintptr_t*)self_fun->bytecode)[0];
-    size_t n_state = mp_decode_uint_value(self_fun->bytecode + prelude_offset);
+    uintptr_t prelude_offset = ((uintptr_t *)self_fun->bytecode)[0];
+    #if MICROPY_EMIT_NATIVE_PRELUDE_AS_BYTES_OBJ
+    // Prelude is in bytes object in const_table, at index prelude_offset
+    mp_obj_str_t *prelude_bytes = MP_OBJ_TO_PTR(self_fun->const_table[prelude_offset]);
+    prelude_offset = (const byte *)prelude_bytes->data - self_fun->bytecode;
+    #endif
+    const uint8_t *ip = self_fun->bytecode + prelude_offset;
+    size_t n_state, n_exc_stack_unused, scope_flags, n_pos_args, n_kwonly_args, n_def_args;
+    MP_BC_PRELUDE_SIG_DECODE_INTO(ip, n_state, n_exc_stack_unused, scope_flags, n_pos_args, n_kwonly_args, n_def_args);
     size_t n_exc_stack = 0;
 
     // Allocate the generator object, with room for local stack and exception stack
@@ -93,17 +108,18 @@ STATIC mp_obj_t native_gen_wrap_call(mp_obj_t self_in, size_t n_args, size_t n_k
     o->base.type = &mp_type_gen_instance;
 
     // Parse the input arguments and set up the code state
-    o->globals = self_fun->globals;
+    o->pend_exc = mp_const_none;
     o->code_state.fun_bc = self_fun;
-    o->code_state.ip = (const byte*)prelude_offset;
+    o->code_state.ip = (const byte *)prelude_offset;
+    o->code_state.n_state = n_state;
     mp_setup_code_state(&o->code_state, n_args, n_kw, args);
 
     // Indicate we are a native function, which doesn't use this variable
-    o->code_state.exc_sp = NULL;
+    o->code_state.exc_sp_idx = MP_CODE_STATE_EXC_SP_IDX_SENTINEL;
 
     // Prepare the generator instance for execution
-    uintptr_t start_offset = ((uintptr_t*)self_fun->bytecode)[1];
-    o->code_state.ip = MICROPY_MAKE_POINTER_CALLABLE((void*)(self_fun->bytecode + start_offset));
+    uintptr_t start_offset = ((uintptr_t *)self_fun->bytecode)[1];
+    o->code_state.ip = MICROPY_MAKE_POINTER_CALLABLE((void *)(self_fun->bytecode + start_offset));
 
     return MP_OBJ_FROM_PTR(o);
 }
@@ -138,42 +154,43 @@ mp_vm_return_kind_t mp_obj_gen_resume(mp_obj_t self_in, mp_obj_t send_value, mp_
         *ret_val = MP_OBJ_STOP_ITERATION;
         return MP_VM_RETURN_NORMAL;
     }
+
+    // Ensure the generator cannot be reentered during execution
+    if (self->pend_exc == MP_OBJ_NULL) {
+        mp_raise_ValueError(MP_ERROR_TEXT("generator already executing"));
+    }
+
+    #if MICROPY_PY_GENERATOR_PEND_THROW
+    // If exception is pending (set using .pend_throw()), process it now.
+    if (self->pend_exc != mp_const_none) {
+        throw_value = self->pend_exc;
+    }
+    #endif
+
+    // If the generator is started, allow sending a value.
     if (self->code_state.sp == self->code_state.state - 1) {
         if (send_value != mp_const_none) {
-            mp_raise_TypeError("can't send non-None value to a just-started generator");
+            mp_raise_TypeError(MP_ERROR_TEXT("can't send non-None value to a just-started generator"));
         }
     } else {
-        #if MICROPY_PY_GENERATOR_PEND_THROW
-        // If exception is pending (set using .pend_throw()), process it now.
-        if (*self->code_state.sp != mp_const_none) {
-            throw_value = *self->code_state.sp;
-            *self->code_state.sp = MP_OBJ_NULL;
-        } else
-        #endif
-        {
-            *self->code_state.sp = send_value;
-        }
+        *self->code_state.sp = send_value;
     }
 
-    // We set self->globals=NULL while executing, for a sentinel to ensure the generator
-    // cannot be reentered during execution
-    if (self->globals == NULL) {
-        mp_raise_ValueError("generator already executing");
-    }
+    // Mark as running
+    self->pend_exc = MP_OBJ_NULL;
 
     // Set up the correct globals context for the generator and execute it
     self->code_state.old_globals = mp_globals_get();
-    mp_globals_set(self->globals);
-    self->globals = NULL;
+    mp_globals_set(self->code_state.fun_bc->globals);
 
     mp_vm_return_kind_t ret_kind;
 
     #if MICROPY_EMIT_NATIVE
-    if (self->code_state.exc_sp == NULL) {
+    if (self->code_state.exc_sp_idx == MP_CODE_STATE_EXC_SP_IDX_SENTINEL) {
         // A native generator, with entry point 2 words into the "bytecode" pointer
-        typedef uintptr_t (*mp_fun_native_gen_t)(void*, mp_obj_t);
-        mp_fun_native_gen_t fun = MICROPY_MAKE_POINTER_CALLABLE((const void*)(self->code_state.fun_bc->bytecode + 2 * sizeof(uintptr_t)));
-        ret_kind = fun((void*)&self->code_state, throw_value);
+        typedef uintptr_t (*mp_fun_native_gen_t)(void *, mp_obj_t);
+        mp_fun_native_gen_t fun = MICROPY_MAKE_POINTER_CALLABLE((const void *)(self->code_state.fun_bc->bytecode + 2 * sizeof(uintptr_t)));
+        ret_kind = fun((void *)&self->code_state, throw_value);
     } else
     #endif
     {
@@ -181,9 +198,11 @@ mp_vm_return_kind_t mp_obj_gen_resume(mp_obj_t self_in, mp_obj_t send_value, mp_
         ret_kind = mp_execute_bytecode(&self->code_state, throw_value);
     }
 
-    self->globals = mp_globals_get();
     mp_globals_set(self->code_state.old_globals);
 
+    // Mark as not running
+    self->pend_exc = mp_const_none;
+
     switch (ret_kind) {
         case MP_VM_RETURN_NORMAL:
         default:
@@ -206,7 +225,7 @@ mp_vm_return_kind_t mp_obj_gen_resume(mp_obj_t self_in, mp_obj_t send_value, mp_
             *ret_val = self->code_state.state[0];
             // PEP479: if StopIteration is raised inside a generator it is replaced with RuntimeError
             if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(mp_obj_get_type(*ret_val)), MP_OBJ_FROM_PTR(&mp_type_StopIteration))) {
-                *ret_val = mp_obj_new_exception_msg(&mp_type_RuntimeError, "generator raised StopIteration");
+                *ret_val = mp_obj_new_exception_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("generator raised StopIteration"));
             }
             break;
         }
@@ -224,7 +243,7 @@ STATIC mp_obj_t gen_resume_and_raise(mp_obj_t self_in, mp_obj_t send_value, mp_o
             if (ret == mp_const_none || ret == MP_OBJ_STOP_ITERATION) {
                 return MP_OBJ_STOP_ITERATION;
             } else {
-                nlr_raise(mp_obj_new_exception_args(&mp_type_StopIteration, 1, &ret));
+                nlr_raise(mp_obj_new_exception_arg1(&mp_type_StopIteration, ret));
             }
 
         case MP_VM_RETURN_YIELD:
@@ -242,33 +261,45 @@ STATIC mp_obj_t gen_instance_iternext(mp_obj_t self_in) {
 STATIC mp_obj_t gen_instance_send(mp_obj_t self_in, mp_obj_t send_value) {
     mp_obj_t ret = gen_resume_and_raise(self_in, send_value, MP_OBJ_NULL);
     if (ret == MP_OBJ_STOP_ITERATION) {
-        nlr_raise(mp_obj_new_exception(&mp_type_StopIteration));
+        mp_raise_type(&mp_type_StopIteration);
     } else {
         return ret;
     }
 }
-
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(gen_instance_send_obj, gen_instance_send);
 
-STATIC mp_obj_t gen_instance_close(mp_obj_t self_in);
 STATIC mp_obj_t gen_instance_throw(size_t n_args, const mp_obj_t *args) {
-    mp_obj_t exc = (n_args == 2) ? args[1] : args[2];
+    // The signature of this function is: throw(type[, value[, traceback]])
+    // CPython will pass all given arguments through the call chain and process them
+    // at the point they are used (native generators will handle them differently to
+    // user-defined generators with a throw() method).  To save passing multiple
+    // values, MicroPython instead does partial processing here to reduce it down to
+    // one argument and passes that through:
+    // - if only args[1] is given, or args[2] is given but is None, args[1] is
+    //   passed through (in the standard case it is an exception class or instance)
+    // - if args[2] is given and not None it is passed through (in the standard
+    //   case it would be an exception instance and args[1] its corresponding class)
+    // - args[3] is always ignored
+
+    mp_obj_t exc = args[1];
+    if (n_args > 2 && args[2] != mp_const_none) {
+        exc = args[2];
+    }
 
     mp_obj_t ret = gen_resume_and_raise(args[0], mp_const_none, exc);
     if (ret == MP_OBJ_STOP_ITERATION) {
-        nlr_raise(mp_obj_new_exception(&mp_type_StopIteration));
+        mp_raise_type(&mp_type_StopIteration);
     } else {
         return ret;
     }
 }
-
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(gen_instance_throw_obj, 2, 4, gen_instance_throw);
 
 STATIC mp_obj_t gen_instance_close(mp_obj_t self_in) {
     mp_obj_t ret;
     switch (mp_obj_gen_resume(self_in, mp_const_none, MP_OBJ_FROM_PTR(&mp_const_GeneratorExit_obj), &ret)) {
         case MP_VM_RETURN_YIELD:
-            mp_raise_msg(&mp_type_RuntimeError, "generator ignored GeneratorExit");
+            mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("generator ignored GeneratorExit"));
 
         // Swallow GeneratorExit (== successful close), and re-raise any other
         case MP_VM_RETURN_EXCEPTION:
@@ -283,19 +314,20 @@ STATIC mp_obj_t gen_instance_close(mp_obj_t self_in) {
             return mp_const_none;
     }
 }
-
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(gen_instance_close_obj, gen_instance_close);
 
+#if MICROPY_PY_GENERATOR_PEND_THROW
 STATIC mp_obj_t gen_instance_pend_throw(mp_obj_t self_in, mp_obj_t exc_in) {
     mp_obj_gen_instance_t *self = MP_OBJ_TO_PTR(self_in);
-    if (self->code_state.sp == self->code_state.state - 1) {
-        mp_raise_TypeError("can't pend throw to just-started generator");
+    if (self->pend_exc == MP_OBJ_NULL) {
+        mp_raise_ValueError(MP_ERROR_TEXT("generator already executing"));
     }
-    mp_obj_t prev = *self->code_state.sp;
-    *self->code_state.sp = exc_in;
+    mp_obj_t prev = self->pend_exc;
+    self->pend_exc = exc_in;
     return prev;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(gen_instance_pend_throw_obj, gen_instance_pend_throw);
+#endif
 
 STATIC const mp_rom_map_elem_t gen_instance_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&gen_instance_close_obj) },
@@ -315,5 +347,5 @@ const mp_obj_type_t mp_type_gen_instance = {
     .unary_op = mp_generic_unary_op,
     .getiter = mp_identity_getiter,
     .iternext = gen_instance_iternext,
-    .locals_dict = (mp_obj_dict_t*)&gen_instance_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&gen_instance_locals_dict,
 };
diff --git a/py/objgetitemiter.c b/py/objgetitemiter.c
index ec41c2c5b11e5..54e27b8f11d0b 100644
--- a/py/objgetitemiter.c
+++ b/py/objgetitemiter.c
@@ -46,7 +46,7 @@ STATIC mp_obj_t it_iternext(mp_obj_t self_in) {
         return value;
     } else {
         // an exception was raised
-        mp_obj_type_t *t = (mp_obj_type_t*)((mp_obj_base_t*)nlr.ret_val)->type;
+        mp_obj_type_t *t = (mp_obj_type_t *)((mp_obj_base_t *)nlr.ret_val)->type;
         if (t == &mp_type_StopIteration || t == &mp_type_IndexError) {
             // return MP_OBJ_STOP_ITERATION instead of raising
             return MP_OBJ_STOP_ITERATION;
@@ -67,7 +67,7 @@ STATIC const mp_obj_type_t it_type = {
 // args are those returned from mp_load_method_maybe (ie either an attribute or a method)
 mp_obj_t mp_obj_new_getitem_iter(mp_obj_t *args, mp_obj_iter_buf_t *iter_buf) {
     assert(sizeof(mp_obj_getitem_iter_t) <= sizeof(mp_obj_iter_buf_t));
-    mp_obj_getitem_iter_t *o = (mp_obj_getitem_iter_t*)iter_buf;
+    mp_obj_getitem_iter_t *o = (mp_obj_getitem_iter_t *)iter_buf;
     o->base.type = &it_type;
     o->args[0] = args[0];
     o->args[1] = args[1];
diff --git a/py/objint.c b/py/objint.c
index 6473767e41343..4619fb5751fed 100644
--- a/py/objint.c
+++ b/py/objint.c
@@ -57,10 +57,10 @@ STATIC mp_obj_t mp_obj_int_make_new(const mp_obj_type_t *type_in, size_t n_args,
                 size_t l;
                 const char *s = mp_obj_str_get_data(args[0], &l);
                 return mp_parse_num_integer(s, l, 0, NULL);
-#if MICROPY_PY_BUILTINS_FLOAT
+            #if MICROPY_PY_BUILTINS_FLOAT
             } else if (mp_obj_is_float(args[0])) {
                 return mp_obj_new_int_from_float(mp_obj_float_get(args[0]));
-#endif
+            #endif
             } else {
                 return mp_unary_op(MP_UNARY_OP_INT, args[0]);
             }
@@ -86,26 +86,26 @@ typedef enum {
 STATIC mp_fp_as_int_class_t mp_classify_fp_as_int(mp_float_t val) {
     union {
         mp_float_t f;
-#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
+        #if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
         uint32_t i;
-#elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
+        #elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
         uint32_t i[2];
-#endif
+        #endif
     } u = {val};
 
     uint32_t e;
-#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
+    #if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
     e = u.i;
-#elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
+    #elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
     e = u.i[MP_ENDIANNESS_LITTLE];
-#endif
+    #endif
 #define MP_FLOAT_SIGN_SHIFT_I32 ((MP_FLOAT_FRAC_BITS + MP_FLOAT_EXP_BITS) % 32)
 #define MP_FLOAT_EXP_SHIFT_I32 (MP_FLOAT_FRAC_BITS % 32)
 
     if (e & (1U << MP_FLOAT_SIGN_SHIFT_I32)) {
-#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
+        #if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
         e |= u.i[MP_ENDIANNESS_BIG] != 0;
-#endif
+        #endif
         if ((e & ~(1 << MP_FLOAT_SIGN_SHIFT_I32)) == 0) {
             // handle case of -0 (when sign is set but rest of bits are zero)
             e = 0;
@@ -120,26 +120,30 @@ STATIC mp_fp_as_int_class_t mp_classify_fp_as_int(mp_float_t val) {
     if (e <= ((8 * sizeof(uintptr_t) + MP_FLOAT_EXP_BIAS - 3) << MP_FLOAT_EXP_SHIFT_I32)) {
         return MP_FP_CLASS_FIT_SMALLINT;
     }
-#if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_LONGLONG
+    #if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_LONGLONG
     if (e <= (((sizeof(long long) * BITS_PER_BYTE) + MP_FLOAT_EXP_BIAS - 2) << MP_FLOAT_EXP_SHIFT_I32)) {
         return MP_FP_CLASS_FIT_LONGINT;
     }
-#endif
-#if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_MPZ
+    #endif
+    #if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_MPZ
     return MP_FP_CLASS_FIT_LONGINT;
-#else
+    #else
     return MP_FP_CLASS_OVERFLOW;
-#endif
+    #endif
 }
 #undef MP_FLOAT_SIGN_SHIFT_I32
 #undef MP_FLOAT_EXP_SHIFT_I32
 
 mp_obj_t mp_obj_new_int_from_float(mp_float_t val) {
-    int cl = fpclassify(val);
-    if (cl == FP_INFINITE) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OverflowError, "can't convert inf to int"));
-    } else if (cl == FP_NAN) {
-        mp_raise_ValueError("can't convert NaN to int");
+    mp_float_union_t u = {val};
+    // IEEE-754: if biased exponent is all 1 bits...
+    if (u.p.exp == ((1 << MP_FLOAT_EXP_BITS) - 1)) {
+        // ...then number is Inf (positive or negative) if fraction is 0, else NaN.
+        if (u.p.frc == 0) {
+            mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("can't convert inf to int"));
+        } else {
+            mp_raise_ValueError(MP_ERROR_TEXT("can't convert NaN to int"));
+        }
     } else {
         mp_fp_as_int_class_t icl = mp_classify_fp_as_int(val);
         if (icl == MP_FP_CLASS_FIT_SMALLINT) {
@@ -156,7 +160,7 @@ mp_obj_t mp_obj_new_int_from_float(mp_float_t val) {
             return mp_obj_new_int_from_ll((long long)val);
         #endif
         } else {
-            mp_raise_ValueError("float too big");
+            mp_raise_ValueError(MP_ERROR_TEXT("float too big"));
         }
         #endif
     }
@@ -218,7 +222,7 @@ size_t mp_int_format_size(size_t num_bits, int base, const char *prefix, char co
 // The resulting formatted string will be returned from this function and the
 // formatted size will be in *fmt_size.
 char *mp_obj_int_formatted(char **buf, size_t *buf_size, size_t *fmt_size, mp_const_obj_t self_in,
-                           int base, const char *prefix, char base_char, char comma) {
+    int base, const char *prefix, char base_char, char comma) {
     fmt_int_t num;
     #if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_NONE
     // Only have small ints; get the integer value to format.
@@ -321,19 +325,19 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i
 
 // This is called only with strings whose value doesn't fit in SMALL_INT
 mp_obj_t mp_obj_new_int_from_str_len(const char **str, size_t len, bool neg, unsigned int base) {
-    mp_raise_msg(&mp_type_OverflowError, "long int not supported in this build");
+    mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("long int not supported in this build"));
     return mp_const_none;
 }
 
 // This is called when an integer larger than a SMALL_INT is needed (although val might still fit in a SMALL_INT)
 mp_obj_t mp_obj_new_int_from_ll(long long val) {
-    mp_raise_msg(&mp_type_OverflowError, "small int overflow");
+    mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("small int overflow"));
     return mp_const_none;
 }
 
 // This is called when an integer larger than a SMALL_INT is needed (although val might still fit in a SMALL_INT)
 mp_obj_t mp_obj_new_int_from_ull(unsigned long long val) {
-    mp_raise_msg(&mp_type_OverflowError, "small int overflow");
+    mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("small int overflow"));
     return mp_const_none;
 }
 
@@ -343,7 +347,7 @@ mp_obj_t mp_obj_new_int_from_uint(mp_uint_t value) {
     if ((value & ~MP_SMALL_INT_POSITIVE_MASK) == 0) {
         return MP_OBJ_NEW_SMALL_INT(value);
     }
-    mp_raise_msg(&mp_type_OverflowError, "small int overflow");
+    mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("small int overflow"));
     return mp_const_none;
 }
 
@@ -351,7 +355,7 @@ mp_obj_t mp_obj_new_int(mp_int_t value) {
     if (MP_SMALL_INT_FITS(value)) {
         return MP_OBJ_NEW_SMALL_INT(value);
     }
-    mp_raise_msg(&mp_type_OverflowError, "small int overflow");
+    mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("small int overflow"));
     return mp_const_none;
 }
 
@@ -392,7 +396,7 @@ STATIC mp_obj_t int_from_bytes(size_t n_args, const mp_obj_t *args) {
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ);
 
-    const byte* buf = (const byte*)bufinfo.buf;
+    const byte *buf = (const byte *)bufinfo.buf;
     int delta = 1;
     if (args[2] == MP_OBJ_NEW_QSTR(MP_QSTR_little)) {
         buf += bufinfo.len - 1;
@@ -428,7 +432,7 @@ STATIC mp_obj_t int_to_bytes(size_t n_args, const mp_obj_t *args) {
 
     vstr_t vstr;
     vstr_init_len(&vstr, len);
-    byte *data = (byte*)vstr.buf;
+    byte *data = (byte *)vstr.buf;
     memset(data, 0, len);
 
     #if MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_NONE
@@ -460,5 +464,5 @@ const mp_obj_type_t mp_type_int = {
     .make_new = mp_obj_int_make_new,
     .unary_op = mp_obj_int_unary_op,
     .binary_op = mp_obj_int_binary_op,
-    .locals_dict = (mp_obj_dict_t*)&int_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&int_locals_dict,
 };
diff --git a/py/objint.h b/py/objint.h
index 4b95acde9f831..5eed87705dedb 100644
--- a/py/objint.h
+++ b/py/objint.h
@@ -31,14 +31,14 @@
 
 typedef struct _mp_obj_int_t {
     mp_obj_base_t base;
-#if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_LONGLONG
+    #if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_LONGLONG
     mp_longint_impl_t val;
-#elif MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_MPZ
+    #elif MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_MPZ
     mpz_t mpz;
-#endif
+    #endif
 } mp_obj_int_t;
 
-extern const mp_obj_int_t mp_maxsize_obj;
+extern const mp_obj_int_t mp_sys_maxsize_obj;
 
 #if MICROPY_PY_BUILTINS_FLOAT
 mp_float_t mp_obj_int_as_float_impl(mp_obj_t self_in);
@@ -50,9 +50,9 @@ mp_obj_int_t *mp_obj_int_new_mpz(void);
 
 void mp_obj_int_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind);
 char *mp_obj_int_formatted(char **buf, size_t *buf_size, size_t *fmt_size, mp_const_obj_t self_in,
-                           int base, const char *prefix, char base_char, char comma);
+    int base, const char *prefix, char base_char, char comma);
 char *mp_obj_int_formatted_impl(char **buf, size_t *buf_size, size_t *fmt_size, mp_const_obj_t self_in,
-                                int base, const char *prefix, char base_char, char comma);
+    int base, const char *prefix, char base_char, char comma);
 mp_int_t mp_obj_int_hash(mp_obj_t self_in);
 mp_obj_t mp_obj_int_from_bytes_impl(bool big_endian, size_t len, const byte *buf);
 void mp_obj_int_to_bytes_impl(mp_obj_t self_in, bool big_endian, size_t len, byte *buf);
diff --git a/py/objint_longlong.c b/py/objint_longlong.c
index 37e2d6b503517..f2e88c3ea5643 100644
--- a/py/objint_longlong.c
+++ b/py/objint_longlong.c
@@ -40,7 +40,7 @@
 
 #if MICROPY_PY_SYS_MAXSIZE
 // Export value for sys.maxsize
-const mp_obj_int_t mp_maxsize_obj = {{&mp_type_int}, MP_SSIZE_MAX};
+const mp_obj_int_t mp_sys_maxsize_obj = {{&mp_type_int}, MP_SSIZE_MAX};
 #endif
 
 mp_obj_t mp_obj_int_from_bytes_impl(bool big_endian, size_t len, const byte *buf) {
@@ -95,15 +95,20 @@ int mp_obj_int_sign(mp_obj_t self_in) {
 mp_obj_t mp_obj_int_unary_op(mp_unary_op_t op, mp_obj_t o_in) {
     mp_obj_int_t *o = o_in;
     switch (op) {
-        case MP_UNARY_OP_BOOL: return mp_obj_new_bool(o->val != 0);
+        case MP_UNARY_OP_BOOL:
+            return mp_obj_new_bool(o->val != 0);
 
         // truncate value to fit in mp_int_t, which gives the same hash as
         // small int if the value fits without truncation
-        case MP_UNARY_OP_HASH: return MP_OBJ_NEW_SMALL_INT((mp_int_t)o->val);
+        case MP_UNARY_OP_HASH:
+            return MP_OBJ_NEW_SMALL_INT((mp_int_t)o->val);
 
-        case MP_UNARY_OP_POSITIVE: return o_in;
-        case MP_UNARY_OP_NEGATIVE: return mp_obj_new_int_from_ll(-o->val);
-        case MP_UNARY_OP_INVERT: return mp_obj_new_int_from_ll(~o->val);
+        case MP_UNARY_OP_POSITIVE:
+            return o_in;
+        case MP_UNARY_OP_NEGATIVE:
+            return mp_obj_new_int_from_ll(-o->val);
+        case MP_UNARY_OP_INVERT:
+            return mp_obj_new_int_from_ll(~o->val);
         case MP_UNARY_OP_ABS: {
             mp_obj_int_t *self = MP_OBJ_TO_PTR(o_in);
             if (self->val >= 0) {
@@ -114,7 +119,8 @@ mp_obj_t mp_obj_int_unary_op(mp_unary_op_t op, mp_obj_t o_in) {
             self->val = -self->val;
             return MP_OBJ_FROM_PTR(self);
         }
-        default: return MP_OBJ_NULL; // op not supported
+        default:
+            return MP_OBJ_NULL;      // op not supported
     }
 }
 
@@ -126,13 +132,13 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i
         lhs_val = MP_OBJ_SMALL_INT_VALUE(lhs_in);
     } else {
         assert(mp_obj_is_type(lhs_in, &mp_type_int));
-        lhs_val = ((mp_obj_int_t*)lhs_in)->val;
+        lhs_val = ((mp_obj_int_t *)lhs_in)->val;
     }
 
     if (mp_obj_is_small_int(rhs_in)) {
         rhs_val = MP_OBJ_SMALL_INT_VALUE(rhs_in);
     } else if (mp_obj_is_type(rhs_in, &mp_type_int)) {
-        rhs_val = ((mp_obj_int_t*)rhs_in)->val;
+        rhs_val = ((mp_obj_int_t *)rhs_in)->val;
     } else {
         // delegate to generic function to check for extra cases
         return mp_obj_int_binary_op_extra_cases(op, lhs_in, rhs_in);
@@ -184,7 +190,7 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i
                 #if MICROPY_PY_BUILTINS_FLOAT
                 return mp_obj_float_binary_op(op, lhs_val, rhs_in);
                 #else
-                mp_raise_ValueError("negative power with no float support");
+                mp_raise_ValueError(MP_ERROR_TEXT("negative power with no float support"));
                 #endif
             }
             long long ans = 1;
@@ -217,7 +223,7 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i
     }
 
 zero_division:
-    mp_raise_msg(&mp_type_ZeroDivisionError, "divide by zero");
+    mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("divide by zero"));
 }
 
 mp_obj_t mp_obj_new_int(mp_int_t value) {
@@ -246,7 +252,7 @@ mp_obj_t mp_obj_new_int_from_ll(long long val) {
 mp_obj_t mp_obj_new_int_from_ull(unsigned long long val) {
     // TODO raise an exception if the unsigned long long won't fit
     if (val >> (sizeof(unsigned long long) * 8 - 1) != 0) {
-        mp_raise_msg(&mp_type_OverflowError, "ulonglong too large");
+        mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("ulonglong too large"));
     }
     mp_obj_int_t *o = m_new_obj(mp_obj_int_t);
     o->base.type = &mp_type_int;
diff --git a/py/objint_mpz.c b/py/objint_mpz.c
index 288e9f86d696b..6e52073a6e85b 100644
--- a/py/objint_mpz.c
+++ b/py/objint_mpz.c
@@ -41,6 +41,7 @@
 
 #if MICROPY_PY_SYS_MAXSIZE
 // Export value for sys.maxsize
+// *FORMAT-OFF*
 #define DIG_MASK ((MPZ_LONG_1 << MPZ_DIG_SIZE) - 1)
 STATIC const mpz_dig_t maxsize_dig[] = {
     #define NUM_DIG 1
@@ -64,9 +65,10 @@ STATIC const mpz_dig_t maxsize_dig[] = {
      #endif
     #endif
 };
-const mp_obj_int_t mp_maxsize_obj = {
+// *FORMAT-ON*
+const mp_obj_int_t mp_sys_maxsize_obj = {
     {&mp_type_int},
-    {.fixed_dig = 1, .len = NUM_DIG, .alloc = NUM_DIG, .dig = (mpz_dig_t*)maxsize_dig}
+    {.fixed_dig = 1, .len = NUM_DIG, .alloc = NUM_DIG, .dig = (mpz_dig_t *)maxsize_dig}
 };
 #undef DIG_MASK
 #undef NUM_DIG
@@ -89,7 +91,7 @@ mp_obj_int_t *mp_obj_int_new_mpz(void) {
 //
 // This particular routine should only be called for the mpz representation of the int.
 char *mp_obj_int_formatted_impl(char **buf, size_t *buf_size, size_t *fmt_size, mp_const_obj_t self_in,
-                                int base, const char *prefix, char base_char, char comma) {
+    int base, const char *prefix, char base_char, char comma) {
     assert(mp_obj_is_type(self_in, &mp_type_int));
     const mp_obj_int_t *self = MP_OBJ_TO_PTR(self_in);
 
@@ -142,11 +144,20 @@ int mp_obj_int_sign(mp_obj_t self_in) {
 mp_obj_t mp_obj_int_unary_op(mp_unary_op_t op, mp_obj_t o_in) {
     mp_obj_int_t *o = MP_OBJ_TO_PTR(o_in);
     switch (op) {
-        case MP_UNARY_OP_BOOL: return mp_obj_new_bool(!mpz_is_zero(&o->mpz));
-        case MP_UNARY_OP_HASH: return MP_OBJ_NEW_SMALL_INT(mpz_hash(&o->mpz));
-        case MP_UNARY_OP_POSITIVE: return o_in;
-        case MP_UNARY_OP_NEGATIVE: { mp_obj_int_t *o2 = mp_obj_int_new_mpz(); mpz_neg_inpl(&o2->mpz, &o->mpz); return MP_OBJ_FROM_PTR(o2); }
-        case MP_UNARY_OP_INVERT: { mp_obj_int_t *o2 = mp_obj_int_new_mpz(); mpz_not_inpl(&o2->mpz, &o->mpz); return MP_OBJ_FROM_PTR(o2); }
+        case MP_UNARY_OP_BOOL:
+            return mp_obj_new_bool(!mpz_is_zero(&o->mpz));
+        case MP_UNARY_OP_HASH:
+            return MP_OBJ_NEW_SMALL_INT(mpz_hash(&o->mpz));
+        case MP_UNARY_OP_POSITIVE:
+            return o_in;
+        case MP_UNARY_OP_NEGATIVE: { mp_obj_int_t *o2 = mp_obj_int_new_mpz();
+                                     mpz_neg_inpl(&o2->mpz, &o->mpz);
+                                     return MP_OBJ_FROM_PTR(o2);
+        }
+        case MP_UNARY_OP_INVERT: { mp_obj_int_t *o2 = mp_obj_int_new_mpz();
+                                   mpz_not_inpl(&o2->mpz, &o->mpz);
+                                   return MP_OBJ_FROM_PTR(o2);
+        }
         case MP_UNARY_OP_ABS: {
             mp_obj_int_t *self = MP_OBJ_TO_PTR(o_in);
             if (self->mpz.neg == 0) {
@@ -156,7 +167,8 @@ mp_obj_t mp_obj_int_unary_op(mp_unary_op_t op, mp_obj_t o_in) {
             mpz_abs_inpl(&self2->mpz, &self->mpz);
             return MP_OBJ_FROM_PTR(self2);
         }
-        default: return MP_OBJ_NULL; // op not supported
+        default:
+            return MP_OBJ_NULL;      // op not supported
     }
 }
 
@@ -172,7 +184,7 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i
         zlhs = &z_int;
     } else {
         assert(mp_obj_is_type(lhs_in, &mp_type_int));
-        zlhs = &((mp_obj_int_t*)MP_OBJ_TO_PTR(lhs_in))->mpz;
+        zlhs = &((mp_obj_int_t *)MP_OBJ_TO_PTR(lhs_in))->mpz;
     }
 
     // if rhs is small int, then lhs was not (otherwise mp_binary_op handles it)
@@ -180,32 +192,32 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i
         mpz_init_fixed_from_int(&z_int, z_int_dig, MPZ_NUM_DIG_FOR_INT, MP_OBJ_SMALL_INT_VALUE(rhs_in));
         zrhs = &z_int;
     } else if (mp_obj_is_type(rhs_in, &mp_type_int)) {
-        zrhs = &((mp_obj_int_t*)MP_OBJ_TO_PTR(rhs_in))->mpz;
-#if MICROPY_PY_BUILTINS_FLOAT
+        zrhs = &((mp_obj_int_t *)MP_OBJ_TO_PTR(rhs_in))->mpz;
+    #if MICROPY_PY_BUILTINS_FLOAT
     } else if (mp_obj_is_float(rhs_in)) {
         return mp_obj_float_binary_op(op, mpz_as_float(zlhs), rhs_in);
-#if MICROPY_PY_BUILTINS_COMPLEX
+    #endif
+    #if MICROPY_PY_BUILTINS_COMPLEX
     } else if (mp_obj_is_type(rhs_in, &mp_type_complex)) {
         return mp_obj_complex_binary_op(op, mpz_as_float(zlhs), 0, rhs_in);
-#endif
-#endif
+    #endif
     } else {
         // delegate to generic function to check for extra cases
         return mp_obj_int_binary_op_extra_cases(op, lhs_in, rhs_in);
     }
 
-    if (0) {
-#if MICROPY_PY_BUILTINS_FLOAT
-    } else if (op == MP_BINARY_OP_TRUE_DIVIDE || op == MP_BINARY_OP_INPLACE_TRUE_DIVIDE) {
+    #if MICROPY_PY_BUILTINS_FLOAT
+    if (op == MP_BINARY_OP_TRUE_DIVIDE || op == MP_BINARY_OP_INPLACE_TRUE_DIVIDE) {
         if (mpz_is_zero(zrhs)) {
             goto zero_division_error;
         }
         mp_float_t flhs = mpz_as_float(zlhs);
         mp_float_t frhs = mpz_as_float(zrhs);
         return mp_obj_new_float(flhs / frhs);
-#endif
+    }
+    #endif
 
-    } else if (op >= MP_BINARY_OP_INPLACE_OR && op < MP_BINARY_OP_CONTAINS) {
+    if (op >= MP_BINARY_OP_INPLACE_OR && op < MP_BINARY_OP_CONTAINS) {
         mp_obj_int_t *res = mp_obj_int_new_mpz();
 
         switch (op) {
@@ -224,10 +236,11 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i
             case MP_BINARY_OP_FLOOR_DIVIDE:
             case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE: {
                 if (mpz_is_zero(zrhs)) {
-                    zero_division_error:
-                    mp_raise_msg(&mp_type_ZeroDivisionError, "divide by zero");
+                zero_division_error:
+                    mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("divide by zero"));
                 }
-                mpz_t rem; mpz_init_zero(&rem);
+                mpz_t rem;
+                mpz_init_zero(&rem);
                 mpz_divmod_inpl(&res->mpz, &rem, zlhs, zrhs);
                 mpz_deinit(&rem);
                 break;
@@ -237,7 +250,8 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i
                 if (mpz_is_zero(zrhs)) {
                     goto zero_division_error;
                 }
-                mpz_t quo; mpz_init_zero(&quo);
+                mpz_t quo;
+                mpz_init_zero(&quo);
                 mpz_divmod_inpl(&quo, &res->mpz, zlhs, zrhs);
                 mpz_deinit(&quo);
                 break;
@@ -262,7 +276,7 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i
             case MP_BINARY_OP_INPLACE_RSHIFT: {
                 mp_int_t irhs = mp_obj_int_get_checked(rhs_in);
                 if (irhs < 0) {
-                    mp_raise_ValueError("negative shift count");
+                    mp_raise_ValueError(MP_ERROR_TEXT("negative shift count"));
                 }
                 if (op == MP_BINARY_OP_LSHIFT || op == MP_BINARY_OP_INPLACE_LSHIFT) {
                     mpz_shl_inpl(&res->mpz, zlhs, irhs);
@@ -278,7 +292,7 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i
                     #if MICROPY_PY_BUILTINS_FLOAT
                     return mp_obj_float_binary_op(op, mpz_as_float(zlhs), rhs_in);
                     #else
-                    mp_raise_ValueError("negative power with no float support");
+                    mp_raise_ValueError(MP_ERROR_TEXT("negative power with no float support"));
                     #endif
                 }
                 mpz_pow_inpl(&res->mpz, zlhs, zrhs);
@@ -331,10 +345,10 @@ STATIC mpz_t *mp_mpz_for_int(mp_obj_t arg, mpz_t *temp) {
 
 mp_obj_t mp_obj_int_pow3(mp_obj_t base, mp_obj_t exponent,  mp_obj_t modulus) {
     if (!mp_obj_is_int(base) || !mp_obj_is_int(exponent) || !mp_obj_is_int(modulus)) {
-        mp_raise_TypeError("pow() with 3 arguments requires integers");
+        mp_raise_TypeError(MP_ERROR_TEXT("pow() with 3 arguments requires integers"));
     } else {
         mp_obj_t result = mp_obj_new_int_from_ull(0); // Use the _from_ull version as this forces an mpz int
-        mp_obj_int_t *res_p = (mp_obj_int_t *) MP_OBJ_TO_PTR(result);
+        mp_obj_int_t *res_p = (mp_obj_int_t *)MP_OBJ_TO_PTR(result);
 
         mpz_t l_temp, r_temp, m_temp;
         mpz_t *lhs = mp_mpz_for_int(base,     &l_temp);
@@ -343,9 +357,15 @@ mp_obj_t mp_obj_int_pow3(mp_obj_t base, mp_obj_t exponent,  mp_obj_t modulus) {
 
         mpz_pow3_inpl(&(res_p->mpz), lhs, rhs, mod);
 
-        if (lhs == &l_temp) { mpz_deinit(lhs); }
-        if (rhs == &r_temp) { mpz_deinit(rhs); }
-        if (mod == &m_temp) { mpz_deinit(mod); }
+        if (lhs == &l_temp) {
+            mpz_deinit(lhs);
+        }
+        if (rhs == &r_temp) {
+            mpz_deinit(rhs);
+        }
+        if (mod == &m_temp) {
+            mpz_deinit(mod);
+        }
         return result;
     }
 }
@@ -406,9 +426,25 @@ mp_int_t mp_obj_int_get_checked(mp_const_obj_t self_in) {
             return value;
         } else {
             // overflow
-            mp_raise_msg(&mp_type_OverflowError, "overflow converting long int to machine word");
+            mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("overflow converting long int to machine word"));
+        }
+    }
+}
+
+mp_uint_t mp_obj_int_get_uint_checked(mp_const_obj_t self_in) {
+    if (mp_obj_is_small_int(self_in)) {
+        if (MP_OBJ_SMALL_INT_VALUE(self_in) >= 0) {
+            return MP_OBJ_SMALL_INT_VALUE(self_in);
+        }
+    } else {
+        const mp_obj_int_t *self = MP_OBJ_TO_PTR(self_in);
+        mp_uint_t value;
+        if (mpz_as_uint_checked(&self->mpz, &value)) {
+            return value;
         }
     }
+
+    mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("overflow converting long int to machine word"));
 }
 
 #if MICROPY_PY_BUILTINS_FLOAT
diff --git a/py/objlist.c b/py/objlist.c
index ec9d57fc7bdab..8c989facc0dfe 100644
--- a/py/objlist.c
+++ b/py/objlist.c
@@ -88,15 +88,18 @@ STATIC mp_obj_t list_make_new(const mp_obj_type_t *type_in, size_t n_args, size_
 STATIC mp_obj_t list_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
     mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
     switch (op) {
-        case MP_UNARY_OP_BOOL: return mp_obj_new_bool(self->len != 0);
-        case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(self->len);
+        case MP_UNARY_OP_BOOL:
+            return mp_obj_new_bool(self->len != 0);
+        case MP_UNARY_OP_LEN:
+            return MP_OBJ_NEW_SMALL_INT(self->len);
         #if MICROPY_PY_SYS_GETSIZEOF
         case MP_UNARY_OP_SIZEOF: {
             size_t sz = sizeof(*self) + sizeof(mp_obj_t) * self->alloc;
             return MP_OBJ_NEW_SMALL_INT(sz);
         }
         #endif
-        default: return MP_OBJ_NULL; // op not supported
+        default:
+            return MP_OBJ_NULL;      // op not supported
     }
 }
 
@@ -153,7 +156,7 @@ STATIC mp_obj_t list_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
 STATIC mp_obj_t list_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
     if (value == MP_OBJ_NULL) {
         // delete
-#if MICROPY_PY_BUILTINS_SLICE
+        #if MICROPY_PY_BUILTINS_SLICE
         if (mp_obj_is_type(index, &mp_type_slice)) {
             mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
             mp_bound_slice_t slice;
@@ -162,22 +165,21 @@ STATIC mp_obj_t list_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
             }
 
             mp_int_t len_adj = slice.start - slice.stop;
-            //printf("Len adj: %d\n", len_adj);
             assert(len_adj <= 0);
-            mp_seq_replace_slice_no_grow(self->items, self->len, slice.start, slice.stop, self->items/*NULL*/, 0, sizeof(*self->items));
+            mp_seq_replace_slice_no_grow(self->items, self->len, slice.start, slice.stop, self->items /*NULL*/, 0, sizeof(*self->items));
             // Clear "freed" elements at the end of list
             mp_seq_clear(self->items, self->len + len_adj, self->len, sizeof(*self->items));
             self->len += len_adj;
             return mp_const_none;
         }
-#endif
+        #endif
         mp_obj_t args[2] = {self_in, index};
         list_pop(2, args);
         return mp_const_none;
     } else if (value == MP_OBJ_SENTINEL) {
         // load
         mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
-#if MICROPY_PY_BUILTINS_SLICE
+        #if MICROPY_PY_BUILTINS_SLICE
         if (mp_obj_is_type(index, &mp_type_slice)) {
             mp_bound_slice_t slice;
             if (!mp_seq_get_fast_slice_indexes(self->len, index, &slice)) {
@@ -187,21 +189,21 @@ STATIC mp_obj_t list_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
             mp_seq_copy(res->items, self->items + slice.start, res->len, mp_obj_t);
             return MP_OBJ_FROM_PTR(res);
         }
-#endif
+        #endif
         size_t index_val = mp_get_index(self->base.type, self->len, index, false);
         return self->items[index_val];
     } else {
-#if MICROPY_PY_BUILTINS_SLICE
+        #if MICROPY_PY_BUILTINS_SLICE
         if (mp_obj_is_type(index, &mp_type_slice)) {
             mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
-            size_t value_len; mp_obj_t *value_items;
+            size_t value_len;
+            mp_obj_t *value_items;
             mp_obj_get_array(value, &value_len, &value_items);
             mp_bound_slice_t slice_out;
             if (!mp_seq_get_fast_slice_indexes(self->len, index, &slice_out)) {
                 mp_raise_NotImplementedError(NULL);
             }
             mp_int_t len_adj = value_len - (slice_out.stop - slice_out.start);
-            //printf("Len adj: %d\n", len_adj);
             if (len_adj > 0) {
                 if (self->len + len_adj > self->alloc) {
                     // TODO: Might optimize memory copies here by checking if block can
@@ -221,7 +223,7 @@ STATIC mp_obj_t list_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
             self->len += len_adj;
             return mp_const_none;
         }
-#endif
+        #endif
         mp_obj_list_store(self_in, index, value);
         return mp_const_none;
     }
@@ -268,7 +270,7 @@ STATIC mp_obj_t list_pop(size_t n_args, const mp_obj_t *args) {
     mp_check_self(mp_obj_is_type(args[0], &mp_type_list));
     mp_obj_list_t *self = MP_OBJ_TO_PTR(args[0]);
     if (self->len == 0) {
-        mp_raise_msg(&mp_type_IndexError, "pop from empty list");
+        mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("pop from empty list"));
     }
     size_t index = mp_get_index(self->base.type, self->len, n_args == 1 ? MP_OBJ_NEW_SMALL_INT(-1) : args[1], false);
     mp_obj_t ret = self->items[index];
@@ -277,7 +279,7 @@ STATIC mp_obj_t list_pop(size_t n_args, const mp_obj_t *args) {
     // Clear stale pointer from slot which just got freed to prevent GC issues
     self->items[self->len] = MP_OBJ_NULL;
     if (self->alloc > LIST_MIN_ALLOC && self->alloc > 2 * self->len) {
-        self->items = m_renew(mp_obj_t, self->items, self->alloc, self->alloc/2);
+        self->items = m_renew(mp_obj_t, self->items, self->alloc, self->alloc / 2);
         self->alloc /= 2;
     }
     return ret;
@@ -290,9 +292,13 @@ STATIC void mp_quicksort(mp_obj_t *head, mp_obj_t *tail, mp_obj_t key_fn, mp_obj
         mp_obj_t *t = tail;
         mp_obj_t v = key_fn == MP_OBJ_NULL ? tail[0] : mp_call_function_1(key_fn, tail[0]); // get pivot using key_fn
         for (;;) {
-            do ++h; while (h < t && mp_binary_op(MP_BINARY_OP_LESS, key_fn == MP_OBJ_NULL ? h[0] : mp_call_function_1(key_fn, h[0]), v) == binop_less_result);
-            do --t; while (h < t && mp_binary_op(MP_BINARY_OP_LESS, v, key_fn == MP_OBJ_NULL ? t[0] : mp_call_function_1(key_fn, t[0])) == binop_less_result);
-            if (h >= t) break;
+            do {++h;
+            } while (h < t && mp_binary_op(MP_BINARY_OP_LESS, key_fn == MP_OBJ_NULL ? h[0] : mp_call_function_1(key_fn, h[0]), v) == binop_less_result);
+            do {--t;
+            } while (h < t && mp_binary_op(MP_BINARY_OP_LESS, v, key_fn == MP_OBJ_NULL ? t[0] : mp_call_function_1(key_fn, t[0])) == binop_less_result);
+            if (h >= t) {
+                break;
+            }
             mp_obj_t x = h[0];
             h[0] = t[0];
             t[0] = x;
@@ -314,7 +320,7 @@ STATIC void mp_quicksort(mp_obj_t *head, mp_obj_t *tail, mp_obj_t key_fn, mp_obj
 // TODO Python defines sort to be stable but ours is not
 mp_obj_t mp_obj_list_sort(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_key, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_key, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
         { MP_QSTR_reverse, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
     };
 
@@ -323,15 +329,15 @@ mp_obj_t mp_obj_list_sort(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_
         mp_arg_val_t key, reverse;
     } args;
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args,
-        MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t*)&args);
+        MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t *)&args);
 
     mp_check_self(mp_obj_is_type(pos_args[0], &mp_type_list));
     mp_obj_list_t *self = MP_OBJ_TO_PTR(pos_args[0]);
 
     if (self->len > 1) {
         mp_quicksort(self->items, self->items + self->len - 1,
-                     args.key.u_obj == mp_const_none ? MP_OBJ_NULL : args.key.u_obj,
-                     args.reverse.u_bool ? mp_const_false : mp_const_true);
+            args.key.u_obj == mp_const_none ? MP_OBJ_NULL : args.key.u_obj,
+            args.reverse.u_bool ? mp_const_false : mp_const_true);
     }
 
     return mp_const_none;
@@ -371,19 +377,19 @@ STATIC mp_obj_t list_insert(mp_obj_t self_in, mp_obj_t idx, mp_obj_t obj) {
     // insert has its own strange index logic
     mp_int_t index = MP_OBJ_SMALL_INT_VALUE(idx);
     if (index < 0) {
-         index += self->len;
+        index += self->len;
     }
     if (index < 0) {
-         index = 0;
+        index = 0;
     }
     if ((size_t)index > self->len) {
-         index = self->len;
+        index = self->len;
     }
 
     mp_obj_list_append(self_in, mp_const_none);
 
-    for (mp_int_t i = self->len-1; i > index; i--) {
-         self->items[i] = self->items[i-1];
+    for (mp_int_t i = self->len - 1; i > index; i--) {
+        self->items[i] = self->items[i - 1];
     }
     self->items[index] = obj;
 
@@ -404,10 +410,10 @@ STATIC mp_obj_t list_reverse(mp_obj_t self_in) {
     mp_obj_list_t *self = MP_OBJ_TO_PTR(self_in);
 
     mp_int_t len = self->len;
-    for (mp_int_t i = 0; i < len/2; i++) {
-         mp_obj_t a = self->items[i];
-         self->items[i] = self->items[len-i-1];
-         self->items[len-i-1] = a;
+    for (mp_int_t i = 0; i < len / 2; i++) {
+        mp_obj_t a = self->items[i];
+        self->items[i] = self->items[len - i - 1];
+        self->items[len - i - 1] = a;
     }
 
     return mp_const_none;
@@ -450,7 +456,7 @@ const mp_obj_type_t mp_type_list = {
     .binary_op = list_binary_op,
     .subscr = list_subscr,
     .getiter = list_getiter,
-    .locals_dict = (mp_obj_dict_t*)&list_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&list_locals_dict,
 };
 
 void mp_obj_list_init(mp_obj_list_t *o, size_t n) {
@@ -520,7 +526,7 @@ STATIC mp_obj_t list_it_iternext(mp_obj_t self_in) {
 
 mp_obj_t mp_obj_new_list_iterator(mp_obj_t list, size_t cur, mp_obj_iter_buf_t *iter_buf) {
     assert(sizeof(mp_obj_list_it_t) <= sizeof(mp_obj_iter_buf_t));
-    mp_obj_list_it_t *o = (mp_obj_list_it_t*)iter_buf;
+    mp_obj_list_it_t *o = (mp_obj_list_it_t *)iter_buf;
     o->base.type = &mp_type_polymorph_iter;
     o->iternext = list_it_iternext;
     o->list = list;
diff --git a/py/objmodule.c b/py/objmodule.c
index 9191c73ec3138..060e1bc1e6c2d 100644
--- a/py/objmodule.c
+++ b/py/objmodule.c
@@ -3,7 +3,8 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2013-2019 Damien P. George
+ * Copyright (c) 2014-2015 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -25,6 +26,7 @@
  */
 
 #include <stdlib.h>
+#include <string.h>
 #include <assert.h>
 
 #include "py/objmodule.h"
@@ -43,7 +45,7 @@ STATIC void module_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kin
         module_name = mp_obj_str_get_str(elem->value);
     }
 
-#if MICROPY_PY___FILE__
+    #if MICROPY_PY___FILE__
     // If we store __file__ to imported modules then try to lookup this
     // symbol to give more information about the module.
     elem = mp_map_lookup(&self->globals->map, MP_OBJ_NEW_QSTR(MP_QSTR___file__), MP_MAP_LOOKUP);
@@ -51,7 +53,7 @@ STATIC void module_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kin
         mp_printf(print, "<module '%s' from '%s'>", module_name, mp_obj_str_get_str(elem->value));
         return;
     }
-#endif
+    #endif
 
     mp_printf(print, "<module '%s'>", module_name);
 }
@@ -138,90 +140,96 @@ STATIC const mp_rom_map_elem_t mp_builtin_module_table[] = {
     { MP_ROM_QSTR(MP_QSTR_builtins), MP_ROM_PTR(&mp_module_builtins) },
     { MP_ROM_QSTR(MP_QSTR_micropython), MP_ROM_PTR(&mp_module_micropython) },
 
-#if MICROPY_PY_IO
+    #if MICROPY_PY_IO
     { MP_ROM_QSTR(MP_QSTR_uio), MP_ROM_PTR(&mp_module_io) },
-#endif
-#if MICROPY_PY_COLLECTIONS
+    #endif
+    #if MICROPY_PY_COLLECTIONS
     { MP_ROM_QSTR(MP_QSTR_ucollections), MP_ROM_PTR(&mp_module_collections) },
-#endif
-#if MICROPY_PY_STRUCT
+    #endif
+    #if MICROPY_PY_STRUCT
     { MP_ROM_QSTR(MP_QSTR_ustruct), MP_ROM_PTR(&mp_module_ustruct) },
-#endif
+    #endif
 
-#if MICROPY_PY_BUILTINS_FLOAT
-#if MICROPY_PY_MATH
+    #if MICROPY_PY_BUILTINS_FLOAT
+    #if MICROPY_PY_MATH
     { MP_ROM_QSTR(MP_QSTR_math), MP_ROM_PTR(&mp_module_math) },
-#endif
-#if MICROPY_PY_BUILTINS_COMPLEX && MICROPY_PY_CMATH
+    #endif
+    #if MICROPY_PY_BUILTINS_COMPLEX && MICROPY_PY_CMATH
     { MP_ROM_QSTR(MP_QSTR_cmath), MP_ROM_PTR(&mp_module_cmath) },
-#endif
-#endif
-#if MICROPY_PY_SYS
+    #endif
+    #endif
+    #if MICROPY_PY_SYS
     { MP_ROM_QSTR(MP_QSTR_sys), MP_ROM_PTR(&mp_module_sys) },
-#endif
-#if MICROPY_PY_GC && MICROPY_ENABLE_GC
+    #endif
+    #if MICROPY_PY_GC && MICROPY_ENABLE_GC
     { MP_ROM_QSTR(MP_QSTR_gc), MP_ROM_PTR(&mp_module_gc) },
-#endif
-#if MICROPY_PY_THREAD
+    #endif
+    #if MICROPY_PY_THREAD
     { MP_ROM_QSTR(MP_QSTR__thread), MP_ROM_PTR(&mp_module_thread) },
-#endif
+    #endif
 
     // extmod modules
 
-#if MICROPY_PY_UERRNO
+    #if MICROPY_PY_UASYNCIO
+    { MP_ROM_QSTR(MP_QSTR__uasyncio), MP_ROM_PTR(&mp_module_uasyncio) },
+    #endif
+    #if MICROPY_PY_UERRNO
     { MP_ROM_QSTR(MP_QSTR_uerrno), MP_ROM_PTR(&mp_module_uerrno) },
-#endif
-#if MICROPY_PY_UCTYPES
+    #endif
+    #if MICROPY_PY_UCTYPES
     { MP_ROM_QSTR(MP_QSTR_uctypes), MP_ROM_PTR(&mp_module_uctypes) },
-#endif
-#if MICROPY_PY_UZLIB
+    #endif
+    #if MICROPY_PY_UZLIB
     { MP_ROM_QSTR(MP_QSTR_uzlib), MP_ROM_PTR(&mp_module_uzlib) },
-#endif
-#if MICROPY_PY_UJSON
+    #endif
+    #if MICROPY_PY_UJSON
     { MP_ROM_QSTR(MP_QSTR_ujson), MP_ROM_PTR(&mp_module_ujson) },
-#endif
-#if MICROPY_PY_URE
+    #endif
+    #if MICROPY_PY_URE
     { MP_ROM_QSTR(MP_QSTR_ure), MP_ROM_PTR(&mp_module_ure) },
-#endif
-#if MICROPY_PY_UHEAPQ
+    #endif
+    #if MICROPY_PY_UHEAPQ
     { MP_ROM_QSTR(MP_QSTR_uheapq), MP_ROM_PTR(&mp_module_uheapq) },
-#endif
-#if MICROPY_PY_UTIMEQ
+    #endif
+    #if MICROPY_PY_UTIMEQ
     { MP_ROM_QSTR(MP_QSTR_utimeq), MP_ROM_PTR(&mp_module_utimeq) },
-#endif
-#if MICROPY_PY_UHASHLIB
+    #endif
+    #if MICROPY_PY_UHASHLIB
     { MP_ROM_QSTR(MP_QSTR_uhashlib), MP_ROM_PTR(&mp_module_uhashlib) },
-#endif
-#if MICROPY_PY_UCRYPTOLIB
+    #endif
+    #if MICROPY_PY_UCRYPTOLIB
     { MP_ROM_QSTR(MP_QSTR_ucryptolib), MP_ROM_PTR(&mp_module_ucryptolib) },
-#endif
-#if MICROPY_PY_UBINASCII
+    #endif
+    #if MICROPY_PY_UBINASCII
     { MP_ROM_QSTR(MP_QSTR_ubinascii), MP_ROM_PTR(&mp_module_ubinascii) },
-#endif
-#if MICROPY_PY_URANDOM
+    #endif
+    #if MICROPY_PY_URANDOM
     { MP_ROM_QSTR(MP_QSTR_urandom), MP_ROM_PTR(&mp_module_urandom) },
-#endif
-#if MICROPY_PY_USELECT
+    #endif
+    #if MICROPY_PY_USELECT
     { MP_ROM_QSTR(MP_QSTR_uselect), MP_ROM_PTR(&mp_module_uselect) },
-#endif
-#if MICROPY_PY_USSL
+    #endif
+    #if MICROPY_PY_USSL
     { MP_ROM_QSTR(MP_QSTR_ussl), MP_ROM_PTR(&mp_module_ussl) },
-#endif
-#if MICROPY_PY_LWIP
+    #endif
+    #if MICROPY_PY_LWIP
     { MP_ROM_QSTR(MP_QSTR_lwip), MP_ROM_PTR(&mp_module_lwip) },
-#endif
-#if MICROPY_PY_UWEBSOCKET
+    #endif
+    #if MICROPY_PY_UWEBSOCKET
     { MP_ROM_QSTR(MP_QSTR_uwebsocket), MP_ROM_PTR(&mp_module_uwebsocket) },
-#endif
-#if MICROPY_PY_WEBREPL
+    #endif
+    #if MICROPY_PY_WEBREPL
     { MP_ROM_QSTR(MP_QSTR__webrepl), MP_ROM_PTR(&mp_module_webrepl) },
-#endif
-#if MICROPY_PY_FRAMEBUF
+    #endif
+    #if MICROPY_PY_FRAMEBUF
     { MP_ROM_QSTR(MP_QSTR_framebuf), MP_ROM_PTR(&mp_module_framebuf) },
-#endif
-#if MICROPY_PY_BTREE
+    #endif
+    #if MICROPY_PY_BTREE
     { MP_ROM_QSTR(MP_QSTR_btree), MP_ROM_PTR(&mp_module_btree) },
-#endif
+    #endif
+    #if MICROPY_PY_BLUETOOTH
+    { MP_ROM_QSTR(MP_QSTR_ubluetooth), MP_ROM_PTR(&mp_module_ubluetooth) },
+    #endif
 
     // extra builtin modules as defined by a port
     MICROPY_PORT_BUILTIN_MODULES
@@ -234,14 +242,6 @@ STATIC const mp_rom_map_elem_t mp_builtin_module_table[] = {
 
 MP_DEFINE_CONST_MAP(mp_builtin_module_map, mp_builtin_module_table);
 
-#if MICROPY_MODULE_WEAK_LINKS
-STATIC const mp_rom_map_elem_t mp_builtin_module_weak_links_table[] = {
-    MICROPY_PORT_BUILTIN_MODULE_WEAK_LINKS
-};
-
-MP_DEFINE_CONST_MAP(mp_builtin_module_weak_links_map, mp_builtin_module_weak_links_table);
-#endif
-
 // returns MP_OBJ_NULL if not found
 mp_obj_t mp_module_get(qstr module_name) {
     mp_map_t *mp_loaded_modules_map = &MP_STATE_VM(mp_loaded_modules_dict).map;
@@ -250,7 +250,7 @@ mp_obj_t mp_module_get(qstr module_name) {
 
     if (el == NULL) {
         // module not found, look for builtin module names
-        el = mp_map_lookup((mp_map_t*)&mp_builtin_module_map, MP_OBJ_NEW_QSTR(module_name), MP_MAP_LOOKUP);
+        el = mp_map_lookup((mp_map_t *)&mp_builtin_module_map, MP_OBJ_NEW_QSTR(module_name), MP_MAP_LOOKUP);
         if (el == NULL) {
             return MP_OBJ_NULL;
         }
@@ -266,6 +266,21 @@ void mp_module_register(qstr qst, mp_obj_t module) {
     mp_map_lookup(mp_loaded_modules_map, MP_OBJ_NEW_QSTR(qst), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = module;
 }
 
+#if MICROPY_MODULE_WEAK_LINKS
+// Search for u"foo" in built-in modules, return MP_OBJ_NULL if not found
+mp_obj_t mp_module_search_umodule(const char *module_str) {
+    for (size_t i = 0; i < MP_ARRAY_SIZE(mp_builtin_module_table); ++i) {
+        const mp_map_elem_t *entry = (const mp_map_elem_t *)&mp_builtin_module_table[i];
+        const char *key = qstr_str(MP_OBJ_QSTR_VALUE(entry->key));
+        if (key[0] == 'u' && strcmp(&key[1], module_str) == 0) {
+            return (mp_obj_t)entry->value;
+        }
+
+    }
+    return MP_OBJ_NULL;
+}
+#endif
+
 #if MICROPY_MODULE_BUILTIN_INIT
 void mp_module_call_init(qstr module_name, mp_obj_t module_obj) {
     // Look for __init__ and call it if it exists
diff --git a/py/objmodule.h b/py/objmodule.h
index b7702ec50b686..fde4fff34e0ef 100644
--- a/py/objmodule.h
+++ b/py/objmodule.h
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2013-2019 Damien P. George
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -29,11 +29,12 @@
 #include "py/obj.h"
 
 extern const mp_map_t mp_builtin_module_map;
-extern const mp_map_t mp_builtin_module_weak_links_map;
 
 mp_obj_t mp_module_get(qstr module_name);
 void mp_module_register(qstr qstr, mp_obj_t module);
 
+mp_obj_t mp_module_search_umodule(const char *module_str);
+
 #if MICROPY_MODULE_BUILTIN_INIT
 void mp_module_call_init(qstr module_name, mp_obj_t module_obj);
 #else
diff --git a/py/objnamedtuple.c b/py/objnamedtuple.c
index 54d8493c37fb1..e4543f5b9b180 100644
--- a/py/objnamedtuple.c
+++ b/py/objnamedtuple.c
@@ -46,9 +46,9 @@ size_t mp_obj_namedtuple_find_field(const mp_obj_namedtuple_type_t *type, qstr n
 #if MICROPY_PY_COLLECTIONS_NAMEDTUPLE__ASDICT
 STATIC mp_obj_t namedtuple_asdict(mp_obj_t self_in) {
     mp_obj_namedtuple_t *self = MP_OBJ_TO_PTR(self_in);
-    const qstr *fields = ((mp_obj_namedtuple_type_t*)self->tuple.base.type)->fields;
+    const qstr *fields = ((mp_obj_namedtuple_type_t *)self->tuple.base.type)->fields;
     mp_obj_t dict = mp_obj_new_dict(self->tuple.len);
-    //make it an OrderedDict
+    // make it an OrderedDict
     mp_obj_dict_t *dictObj = MP_OBJ_TO_PTR(dict);
     dictObj->base.type = &mp_type_ordereddict;
     dictObj->map.is_ordered = 1;
@@ -64,7 +64,7 @@ STATIC void namedtuple_print(const mp_print_t *print, mp_obj_t o_in, mp_print_ki
     (void)kind;
     mp_obj_namedtuple_t *o = MP_OBJ_TO_PTR(o_in);
     mp_printf(print, "%q", o->tuple.base.type->name);
-    const qstr *fields = ((mp_obj_namedtuple_type_t*)o->tuple.base.type)->fields;
+    const qstr *fields = ((mp_obj_namedtuple_type_t *)o->tuple.base.type)->fields;
     mp_obj_attrtuple_print_helper(print, fields, &o->tuple);
 }
 
@@ -79,7 +79,7 @@ STATIC void namedtuple_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
             return;
         }
         #endif
-        size_t id = mp_obj_namedtuple_find_field((mp_obj_namedtuple_type_t*)self->tuple.base.type, attr);
+        size_t id = mp_obj_namedtuple_find_field((mp_obj_namedtuple_type_t *)self->tuple.base.type, attr);
         if (id == (size_t)-1) {
             return;
         }
@@ -87,25 +87,25 @@ STATIC void namedtuple_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     } else {
         // delete/store attribute
         // provide more detailed error message than we'd get by just returning
-        mp_raise_msg(&mp_type_AttributeError, "can't set attribute");
+        mp_raise_msg(&mp_type_AttributeError, MP_ERROR_TEXT("can't set attribute"));
     }
 }
 
 STATIC mp_obj_t namedtuple_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
-    const mp_obj_namedtuple_type_t *type = (const mp_obj_namedtuple_type_t*)type_in;
+    const mp_obj_namedtuple_type_t *type = (const mp_obj_namedtuple_type_t *)type_in;
     size_t num_fields = type->n_fields;
     if (n_args + n_kw != num_fields) {
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_arg_error_terse_mismatch();
-        } else if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                "function takes %d positional arguments but %d were given",
-                num_fields, n_args + n_kw));
-        } else if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED) {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                "%q() takes %d positional arguments but %d were given",
-                type->base.name, num_fields, n_args + n_kw));
-        }
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_arg_error_terse_mismatch();
+        #elif MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL
+        mp_raise_msg_varg(&mp_type_TypeError,
+            MP_ERROR_TEXT("function takes %d positional arguments but %d were given"),
+            num_fields, n_args + n_kw);
+        #elif MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED
+        mp_raise_msg_varg(&mp_type_TypeError,
+            MP_ERROR_TEXT("%q() takes %d positional arguments but %d were given"),
+            type->base.name, num_fields, n_args + n_kw);
+        #endif
     }
 
     // Create a tuple and set the type to this namedtuple
@@ -121,20 +121,19 @@ STATIC mp_obj_t namedtuple_make_new(const mp_obj_type_t *type_in, size_t n_args,
         qstr kw = mp_obj_str_get_qstr(args[i]);
         size_t id = mp_obj_namedtuple_find_field(type, kw);
         if (id == (size_t)-1) {
-            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                mp_arg_error_terse_mismatch();
-            } else {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                    "unexpected keyword argument '%q'", kw));
-            }
+            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+            mp_arg_error_terse_mismatch();
+            #else
+            mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("unexpected keyword argument '%q'"), kw);
+            #endif
         }
         if (tuple->items[id] != MP_OBJ_NULL) {
-            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                mp_arg_error_terse_mismatch();
-            } else {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                    "function got multiple values for argument '%q'", kw));
-            }
+            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+            mp_arg_error_terse_mismatch();
+            #else
+            mp_raise_msg_varg(&mp_type_TypeError,
+                MP_ERROR_TEXT("function got multiple values for argument '%q'"), kw);
+            #endif
         }
         tuple->items[id] = args[i + 1];
     }
@@ -155,6 +154,7 @@ mp_obj_namedtuple_type_t *mp_obj_new_namedtuple_base(size_t n_fields, mp_obj_t *
 STATIC mp_obj_t mp_obj_new_namedtuple_type(qstr name, size_t n_fields, mp_obj_t *fields) {
     mp_obj_namedtuple_type_t *o = mp_obj_new_namedtuple_base(n_fields, fields);
     o->base.base.type = &mp_type_type;
+    o->base.flags = MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE; // can match tuple
     o->base.name = name;
     o->base.print = namedtuple_print;
     o->base.make_new = namedtuple_make_new;
diff --git a/py/objnone.c b/py/objnone.c
index da1031835c710..271a8543f9718 100644
--- a/py/objnone.c
+++ b/py/objnone.c
@@ -28,9 +28,11 @@
 
 #include "py/obj.h"
 
+#if !MICROPY_OBJ_IMMEDIATE_OBJS
 typedef struct _mp_obj_none_t {
     mp_obj_base_t base;
 } mp_obj_none_t;
+#endif
 
 STATIC void none_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     (void)self_in;
@@ -48,4 +50,6 @@ const mp_obj_type_t mp_type_NoneType = {
     .unary_op = mp_generic_unary_op,
 };
 
+#if !MICROPY_OBJ_IMMEDIATE_OBJS
 const mp_obj_none_t mp_const_none_obj = {{&mp_type_NoneType}};
+#endif
diff --git a/py/objobject.c b/py/objobject.c
index 45228347e965a..00082dfe08708 100644
--- a/py/objobject.c
+++ b/py/objobject.c
@@ -49,8 +49,8 @@ STATIC mp_obj_t object___init__(mp_obj_t self) {
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(object___init___obj, object___init__);
 
 STATIC mp_obj_t object___new__(mp_obj_t cls) {
-    if (!mp_obj_is_type(cls, &mp_type_type) || !mp_obj_is_instance_type((mp_obj_type_t*)MP_OBJ_TO_PTR(cls))) {
-        mp_raise_TypeError("__new__ arg must be a user-type");
+    if (!mp_obj_is_type(cls, &mp_type_type) || !mp_obj_is_instance_type((mp_obj_type_t *)MP_OBJ_TO_PTR(cls))) {
+        mp_raise_TypeError(MP_ERROR_TEXT("arg must be user-type"));
     }
     // This executes only "__new__" part of instance creation.
     // TODO: This won't work well for classes with native bases.
@@ -62,6 +62,40 @@ STATIC mp_obj_t object___new__(mp_obj_t cls) {
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(object___new___fun_obj, object___new__);
 STATIC MP_DEFINE_CONST_STATICMETHOD_OBJ(object___new___obj, MP_ROM_PTR(&object___new___fun_obj));
 
+#if MICROPY_PY_DELATTR_SETATTR
+STATIC mp_obj_t object___setattr__(mp_obj_t self_in, mp_obj_t attr, mp_obj_t value) {
+    if (!mp_obj_is_instance_type(mp_obj_get_type(self_in))) {
+        mp_raise_TypeError(MP_ERROR_TEXT("arg must be user-type"));
+    }
+
+    if (!mp_obj_is_str(attr)) {
+        mp_raise_TypeError(NULL);
+    }
+
+    mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_map_lookup(&self->members, attr, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(object___setattr___obj, object___setattr__);
+
+STATIC mp_obj_t object___delattr__(mp_obj_t self_in, mp_obj_t attr) {
+    if (!mp_obj_is_instance_type(mp_obj_get_type(self_in))) {
+        mp_raise_TypeError(MP_ERROR_TEXT("arg must be user-type"));
+    }
+
+    if (!mp_obj_is_str(attr)) {
+        mp_raise_TypeError(NULL);
+    }
+
+    mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
+    if (mp_map_lookup(&self->members, attr, MP_MAP_LOOKUP_REMOVE_IF_FOUND) == NULL) {
+        mp_raise_msg(&mp_type_AttributeError, MP_ERROR_TEXT("no such attribute"));
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(object___delattr___obj, object___delattr__);
+#endif
+
 STATIC const mp_rom_map_elem_t object_locals_dict_table[] = {
     #if MICROPY_CPYTHON_COMPAT
     { MP_ROM_QSTR(MP_QSTR___init__), MP_ROM_PTR(&object___init___obj) },
@@ -69,6 +103,10 @@ STATIC const mp_rom_map_elem_t object_locals_dict_table[] = {
     #if MICROPY_CPYTHON_COMPAT
     { MP_ROM_QSTR(MP_QSTR___new__), MP_ROM_PTR(&object___new___obj) },
     #endif
+    #if MICROPY_PY_DELATTR_SETATTR
+    { MP_ROM_QSTR(MP_QSTR___setattr__), MP_ROM_PTR(&object___setattr___obj) },
+    { MP_ROM_QSTR(MP_QSTR___delattr__), MP_ROM_PTR(&object___delattr___obj) },
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(object_locals_dict, object_locals_dict_table);
@@ -79,6 +117,6 @@ const mp_obj_type_t mp_type_object = {
     .name = MP_QSTR_object,
     .make_new = object_make_new,
     #if MICROPY_CPYTHON_COMPAT
-    .locals_dict = (mp_obj_dict_t*)&object_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&object_locals_dict,
     #endif
 };
diff --git a/py/objproperty.c b/py/objproperty.c
index 49cb9ca1b48ba..8d2c292c52d76 100644
--- a/py/objproperty.c
+++ b/py/objproperty.c
@@ -39,10 +39,10 @@ typedef struct _mp_obj_property_t {
 STATIC mp_obj_t property_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     enum { ARG_fget, ARG_fset, ARG_fdel, ARG_doc };
     static const mp_arg_t allowed_args[] = {
-        { MP_QSTR_, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
-        { MP_QSTR_, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
-        { MP_QSTR_, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
-        { MP_QSTR_doc, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
+        { MP_QSTR_, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
+        { MP_QSTR_doc, MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
     };
     mp_arg_val_t vals[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all_kw_array(n_args, n_kw, args, MP_ARRAY_SIZE(allowed_args), allowed_args, vals);
@@ -58,7 +58,7 @@ STATIC mp_obj_t property_make_new(const mp_obj_type_t *type, size_t n_args, size
 
 STATIC mp_obj_t property_getter(mp_obj_t self_in, mp_obj_t getter) {
     mp_obj_property_t *p2 = m_new_obj(mp_obj_property_t);
-    *p2 = *(mp_obj_property_t*)MP_OBJ_TO_PTR(self_in);
+    *p2 = *(mp_obj_property_t *)MP_OBJ_TO_PTR(self_in);
     p2->proxy[0] = getter;
     return MP_OBJ_FROM_PTR(p2);
 }
@@ -67,7 +67,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(property_getter_obj, property_getter);
 
 STATIC mp_obj_t property_setter(mp_obj_t self_in, mp_obj_t setter) {
     mp_obj_property_t *p2 = m_new_obj(mp_obj_property_t);
-    *p2 = *(mp_obj_property_t*)MP_OBJ_TO_PTR(self_in);
+    *p2 = *(mp_obj_property_t *)MP_OBJ_TO_PTR(self_in);
     p2->proxy[1] = setter;
     return MP_OBJ_FROM_PTR(p2);
 }
@@ -76,7 +76,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(property_setter_obj, property_setter);
 
 STATIC mp_obj_t property_deleter(mp_obj_t self_in, mp_obj_t deleter) {
     mp_obj_property_t *p2 = m_new_obj(mp_obj_property_t);
-    *p2 = *(mp_obj_property_t*)MP_OBJ_TO_PTR(self_in);
+    *p2 = *(mp_obj_property_t *)MP_OBJ_TO_PTR(self_in);
     p2->proxy[2] = deleter;
     return MP_OBJ_FROM_PTR(p2);
 }
@@ -95,7 +95,7 @@ const mp_obj_type_t mp_type_property = {
     { &mp_type_type },
     .name = MP_QSTR_property,
     .make_new = property_make_new,
-    .locals_dict = (mp_obj_dict_t*)&property_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&property_locals_dict,
 };
 
 const mp_obj_t *mp_obj_property_get(mp_obj_t self_in) {
diff --git a/py/objrange.c b/py/objrange.c
index 6c3097abd4f67..4eed4b9410550 100644
--- a/py/objrange.c
+++ b/py/objrange.c
@@ -59,7 +59,7 @@ STATIC const mp_obj_type_t range_it_type = {
 
 STATIC mp_obj_t mp_obj_new_range_iterator(mp_int_t cur, mp_int_t stop, mp_int_t step, mp_obj_iter_buf_t *iter_buf) {
     assert(sizeof(mp_obj_range_it_t) <= sizeof(mp_obj_iter_buf_t));
-    mp_obj_range_it_t *o = (mp_obj_range_it_t*)iter_buf;
+    mp_obj_range_it_t *o = (mp_obj_range_it_t *)iter_buf;
     o->base.type = &range_it_type;
     o->cur = cur;
     o->stop = stop;
@@ -105,7 +105,7 @@ STATIC mp_obj_t range_make_new(const mp_obj_type_t *type, size_t n_args, size_t
         if (n_args == 3) {
             o->step = mp_obj_get_int(args[2]);
             if (o->step == 0) {
-                mp_raise_ValueError("zero step");
+                mp_raise_ValueError(MP_ERROR_TEXT("zero step"));
             }
         }
     }
@@ -132,9 +132,12 @@ STATIC mp_obj_t range_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
     mp_obj_range_t *self = MP_OBJ_TO_PTR(self_in);
     mp_int_t len = range_len(self);
     switch (op) {
-        case MP_UNARY_OP_BOOL: return mp_obj_new_bool(len > 0);
-        case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(len);
-        default: return MP_OBJ_NULL; // op not supported
+        case MP_UNARY_OP_BOOL:
+            return mp_obj_new_bool(len > 0);
+        case MP_UNARY_OP_LEN:
+            return MP_OBJ_NEW_SMALL_INT(len);
+        default:
+            return MP_OBJ_NULL;      // op not supported
     }
 }
 
@@ -152,7 +155,7 @@ STATIC mp_obj_t range_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs
         && (lhs_len == 0
             || (lhs->start == rhs->start
                 && (lhs_len == 1 || lhs->step == rhs->step)))
-    );
+        );
 }
 #endif
 
@@ -161,7 +164,7 @@ STATIC mp_obj_t range_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
         // load
         mp_obj_range_t *self = MP_OBJ_TO_PTR(self_in);
         mp_int_t len = range_len(self);
-#if MICROPY_PY_BUILTINS_SLICE
+        #if MICROPY_PY_BUILTINS_SLICE
         if (mp_obj_is_type(index, &mp_type_slice)) {
             mp_bound_slice_t slice;
             mp_seq_get_fast_slice_indexes(len, index, &slice);
@@ -176,7 +179,7 @@ STATIC mp_obj_t range_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
             }
             return MP_OBJ_FROM_PTR(o);
         }
-#endif
+        #endif
         size_t index_val = mp_get_index(self->base.type, len, index, false);
         return MP_OBJ_NEW_SMALL_INT(self->start + index_val * self->step);
     } else {
@@ -218,7 +221,7 @@ const mp_obj_type_t mp_type_range = {
     #endif
     .subscr = range_subscr,
     .getiter = range_getiter,
-#if MICROPY_PY_BUILTINS_RANGE_ATTRS
+    #if MICROPY_PY_BUILTINS_RANGE_ATTRS
     .attr = range_attr,
-#endif
+    #endif
 };
diff --git a/py/objset.c b/py/objset.c
index 88e9d5cc6f2e4..f31a901a7008a 100644
--- a/py/objset.c
+++ b/py/objset.c
@@ -45,13 +45,11 @@ typedef struct _mp_obj_set_it_t {
     size_t cur;
 } mp_obj_set_it_t;
 
-STATIC mp_obj_t set_it_iternext(mp_obj_t self_in);
-
 STATIC bool is_set_or_frozenset(mp_obj_t o) {
     return mp_obj_is_type(o, &mp_type_set)
-#if MICROPY_PY_BUILTINS_FROZENSET
-        || mp_obj_is_type(o, &mp_type_frozenset)
-#endif
+           #if MICROPY_PY_BUILTINS_FROZENSET
+           || mp_obj_is_type(o, &mp_type_frozenset)
+           #endif
     ;
 }
 
@@ -123,7 +121,7 @@ STATIC mp_obj_t set_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_
                 mp_obj_set_store(set, item);
             }
             // Set actual set/frozenset type
-            ((mp_obj_set_t*)MP_OBJ_TO_PTR(set))->base.type = type;
+            ((mp_obj_set_t *)MP_OBJ_TO_PTR(set))->base.type = type;
             return set;
         }
     }
@@ -146,7 +144,7 @@ STATIC mp_obj_t set_it_iternext(mp_obj_t self_in) {
 
 STATIC mp_obj_t set_getiter(mp_obj_t set_in, mp_obj_iter_buf_t *iter_buf) {
     assert(sizeof(mp_obj_set_it_t) <= sizeof(mp_obj_iter_buf_t));
-    mp_obj_set_it_t *o = (mp_obj_set_it_t*)iter_buf;
+    mp_obj_set_it_t *o = (mp_obj_set_it_t *)iter_buf;
     o->base.type = &mp_type_polymorph_iter;
     o->iternext = set_it_iternext;
     o->set = (mp_obj_set_t *)MP_OBJ_TO_PTR(set_in);
@@ -154,7 +152,6 @@ STATIC mp_obj_t set_getiter(mp_obj_t set_in, mp_obj_iter_buf_t *iter_buf) {
     return MP_OBJ_FROM_PTR(o);
 }
 
-
 /******************************************************************************/
 /* set methods                                                                */
 
@@ -169,9 +166,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(set_add_obj, set_add);
 STATIC mp_obj_t set_clear(mp_obj_t self_in) {
     check_set(self_in);
     mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
-
     mp_set_clear(&self->set);
-
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(set_clear_obj, set_clear);
@@ -210,7 +205,7 @@ STATIC mp_obj_t set_diff_int(size_t n_args, const mp_obj_t *args, bool update) {
         if (self == other) {
             set_clear(self);
         } else {
-            mp_set_t *self_set = &((mp_obj_set_t*)MP_OBJ_TO_PTR(self))->set;
+            mp_set_t *self_set = &((mp_obj_set_t *)MP_OBJ_TO_PTR(self))->set;
             mp_obj_t iter = mp_getiter(other, NULL);
             mp_obj_t next;
             while ((next = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
@@ -332,6 +327,7 @@ STATIC mp_obj_t set_issubset_internal(mp_obj_t self_in, mp_obj_t other_in, bool
     }
     return out;
 }
+
 STATIC mp_obj_t set_issubset(mp_obj_t self_in, mp_obj_t other_in) {
     return set_issubset_internal(self_in, other_in, false);
 }
@@ -366,7 +362,7 @@ STATIC mp_obj_t set_pop(mp_obj_t self_in) {
     mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
     mp_obj_t obj = mp_set_remove_first(&self->set);
     if (obj == MP_OBJ_NULL) {
-        mp_raise_msg(&mp_type_KeyError, "pop from an empty set");
+        mp_raise_msg(&mp_type_KeyError, MP_ERROR_TEXT("pop from an empty set"));
     }
     return obj;
 }
@@ -430,9 +426,11 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(set_union_obj, set_union);
 STATIC mp_obj_t set_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
     mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
     switch (op) {
-        case MP_UNARY_OP_BOOL: return mp_obj_new_bool(self->set.used != 0);
-        case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(self->set.used);
-#if MICROPY_PY_BUILTINS_FROZENSET
+        case MP_UNARY_OP_BOOL:
+            return mp_obj_new_bool(self->set.used != 0);
+        case MP_UNARY_OP_LEN:
+            return MP_OBJ_NEW_SMALL_INT(self->set.used);
+        #if MICROPY_PY_BUILTINS_FROZENSET
         case MP_UNARY_OP_HASH:
             if (mp_obj_is_type(self_in, &mp_type_frozenset)) {
                 // start hash with unique value
@@ -447,8 +445,9 @@ STATIC mp_obj_t set_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
                 }
                 return MP_OBJ_NEW_SMALL_INT(hash);
             }
-#endif
-        default: return MP_OBJ_NULL; // op not supported
+        #endif
+        default:
+            return MP_OBJ_NULL;      // op not supported
     }
 }
 
@@ -518,7 +517,6 @@ STATIC mp_obj_t set_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
 /******************************************************************************/
 /* set constructors & public C API                                            */
 
-
 STATIC const mp_rom_map_elem_t set_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_add), MP_ROM_PTR(&set_add_obj) },
     { MP_ROM_QSTR(MP_QSTR_clear), MP_ROM_PTR(&set_clear_obj) },
@@ -539,7 +537,6 @@ STATIC const mp_rom_map_elem_t set_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_update), MP_ROM_PTR(&set_update_obj) },
     { MP_ROM_QSTR(MP_QSTR___contains__), MP_ROM_PTR(&mp_op_contains_obj) },
 };
-
 STATIC MP_DEFINE_CONST_DICT(set_locals_dict, set_locals_dict_table);
 
 const mp_obj_type_t mp_type_set = {
@@ -550,7 +547,7 @@ const mp_obj_type_t mp_type_set = {
     .unary_op = set_unary_op,
     .binary_op = set_binary_op,
     .getiter = set_getiter,
-    .locals_dict = (mp_obj_dict_t*)&set_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&set_locals_dict,
 };
 
 #if MICROPY_PY_BUILTINS_FROZENSET
@@ -569,13 +566,14 @@ STATIC MP_DEFINE_CONST_DICT(frozenset_locals_dict, frozenset_locals_dict_table);
 
 const mp_obj_type_t mp_type_frozenset = {
     { &mp_type_type },
+    .flags = MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
     .name = MP_QSTR_frozenset,
     .print = set_print,
     .make_new = set_make_new,
     .unary_op = set_unary_op,
     .binary_op = set_binary_op,
     .getiter = set_getiter,
-    .locals_dict = (mp_obj_dict_t*)&frozenset_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&frozenset_locals_dict,
 };
 #endif
 
diff --git a/py/objsingleton.c b/py/objsingleton.c
index 67535391ea66d..2b896305cff5b 100644
--- a/py/objsingleton.c
+++ b/py/objsingleton.c
@@ -47,6 +47,7 @@ const mp_obj_type_t mp_type_singleton = {
     { &mp_type_type },
     .name = MP_QSTR_,
     .print = singleton_print,
+    .unary_op = mp_generic_unary_op,
 };
 
 const mp_obj_singleton_t mp_const_ellipsis_obj = {{&mp_type_singleton}, MP_QSTR_Ellipsis};
diff --git a/py/objslice.c b/py/objslice.c
index cfc819edccb25..c65c30601be69 100644
--- a/py/objslice.c
+++ b/py/objslice.c
@@ -27,20 +27,13 @@
 #include <stdlib.h>
 #include <assert.h>
 
-#include "py/obj.h"
+#include "py/runtime.h"
 
 /******************************************************************************/
 /* slice object                                                               */
 
 #if MICROPY_PY_BUILTINS_SLICE
 
-typedef struct _mp_obj_slice_t {
-    mp_obj_base_t base;
-    mp_obj_t start;
-    mp_obj_t stop;
-    mp_obj_t step;
-} mp_obj_slice_t;
-
 STATIC void slice_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t kind) {
     (void)kind;
     mp_obj_slice_t *o = MP_OBJ_TO_PTR(o_in);
@@ -53,6 +46,22 @@ STATIC void slice_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t
     mp_print_str(print, ")");
 }
 
+#if MICROPY_PY_BUILTINS_SLICE_INDICES
+STATIC mp_obj_t slice_indices(mp_obj_t self_in, mp_obj_t length_obj) {
+    mp_int_t length = mp_obj_int_get_checked(length_obj);
+    mp_bound_slice_t bound_indices;
+    mp_obj_slice_indices(self_in, length, &bound_indices);
+
+    mp_obj_t results[3] = {
+        MP_OBJ_NEW_SMALL_INT(bound_indices.start),
+        MP_OBJ_NEW_SMALL_INT(bound_indices.stop),
+        MP_OBJ_NEW_SMALL_INT(bound_indices.step),
+    };
+    return mp_obj_new_tuple(3, results);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(slice_indices_obj, slice_indices);
+#endif
+
 #if MICROPY_PY_BUILTINS_SLICE_ATTRS
 STATIC void slice_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     if (dest[0] != MP_OBJ_NULL) {
@@ -60,23 +69,38 @@ STATIC void slice_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
         return;
     }
     mp_obj_slice_t *self = MP_OBJ_TO_PTR(self_in);
+
     if (attr == MP_QSTR_start) {
         dest[0] = self->start;
     } else if (attr == MP_QSTR_stop) {
         dest[0] = self->stop;
     } else if (attr == MP_QSTR_step) {
         dest[0] = self->step;
+    #if MICROPY_PY_BUILTINS_SLICE_INDICES
+    } else if (attr == MP_QSTR_indices) {
+        dest[0] = MP_OBJ_FROM_PTR(&slice_indices_obj);
+        dest[1] = self_in;
+    #endif
     }
 }
 #endif
 
+#if MICROPY_PY_BUILTINS_SLICE_INDICES && !MICROPY_PY_BUILTINS_SLICE_ATTRS
+STATIC const mp_rom_map_elem_t slice_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_indices), MP_ROM_PTR(&slice_indices_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(slice_locals_dict, slice_locals_dict_table);
+#endif
+
 const mp_obj_type_t mp_type_slice = {
     { &mp_type_type },
     .name = MP_QSTR_slice,
     .print = slice_print,
-#if MICROPY_PY_BUILTINS_SLICE_ATTRS
+    #if MICROPY_PY_BUILTINS_SLICE_ATTRS
     .attr = slice_attr,
-#endif
+    #elif MICROPY_PY_BUILTINS_SLICE_INDICES
+    .locals_dict = (mp_obj_dict_t *)&slice_locals_dict,
+    #endif
 };
 
 mp_obj_t mp_obj_new_slice(mp_obj_t ostart, mp_obj_t ostop, mp_obj_t ostep) {
@@ -88,12 +112,69 @@ mp_obj_t mp_obj_new_slice(mp_obj_t ostart, mp_obj_t ostop, mp_obj_t ostep) {
     return MP_OBJ_FROM_PTR(o);
 }
 
-void mp_obj_slice_get(mp_obj_t self_in, mp_obj_t *start, mp_obj_t *stop, mp_obj_t *step) {
-    assert(mp_obj_is_type(self_in, &mp_type_slice));
+// Return the real index and step values for a slice when applied to a sequence of
+// the given length, resolving missing components, negative values and values off
+// the end of the sequence.
+void mp_obj_slice_indices(mp_obj_t self_in, mp_int_t length, mp_bound_slice_t *result) {
     mp_obj_slice_t *self = MP_OBJ_TO_PTR(self_in);
-    *start = self->start;
-    *stop = self->stop;
-    *step = self->step;
+    mp_int_t start, stop, step;
+
+    if (self->step == mp_const_none) {
+        step = 1;
+    } else {
+        step = mp_obj_get_int(self->step);
+        if (step == 0) {
+            mp_raise_ValueError(MP_ERROR_TEXT("slice step can't be zero"));
+        }
+    }
+
+    if (step > 0) {
+        // Positive step
+        if (self->start == mp_const_none) {
+            start = 0;
+        } else {
+            start = mp_obj_get_int(self->start);
+            if (start < 0) {
+                start += length;
+            }
+            start = MIN(length, MAX(start, 0));
+        }
+
+        if (self->stop == mp_const_none) {
+            stop = length;
+        } else {
+            stop = mp_obj_get_int(self->stop);
+            if (stop < 0) {
+                stop += length;
+            }
+            stop = MIN(length, MAX(stop, 0));
+        }
+    } else {
+        // Negative step
+        if (self->start == mp_const_none) {
+            start = length - 1;
+        } else {
+            start = mp_obj_get_int(self->start);
+            if (start < 0) {
+                start += length;
+            }
+            start = MIN(length - 1, MAX(start, -1));
+        }
+
+        if (self->stop == mp_const_none) {
+            stop = -1;
+        } else {
+            stop = mp_obj_get_int(self->stop);
+            if (stop < 0) {
+                stop += length;
+            }
+            stop = MIN(length - 1, MAX(stop, -1));
+        }
+    }
+
+    result->start = start;
+    result->stop = stop;
+    result->step = step;
 }
 
 #endif
diff --git a/py/objstr.c b/py/objstr.c
index 1047ea94c9a7a..a276a255e516f 100644
--- a/py/objstr.c
+++ b/py/objstr.c
@@ -133,11 +133,11 @@ STATIC void str_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t
 }
 
 mp_obj_t mp_obj_str_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
-#if MICROPY_CPYTHON_COMPAT
+    #if MICROPY_CPYTHON_COMPAT
     if (n_kw != 0) {
         mp_arg_error_unimpl_kw();
     }
-#endif
+    #endif
 
     mp_arg_check_num(n_args, n_kw, 0, 3, false);
 
@@ -168,8 +168,8 @@ mp_obj_t mp_obj_str_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_
                 #endif
 
                 // Check if a qstr with this data already exists
-                qstr q = qstr_find_strn((const char*)str_data, str_len);
-                if (q != MP_QSTR_NULL) {
+                qstr q = qstr_find_strn((const char *)str_data, str_len);
+                if (q != MP_QSTRnull) {
                     return MP_OBJ_NEW_QSTR(q);
                 }
 
@@ -258,7 +258,7 @@ STATIC mp_obj_t bytes_make_new(const mp_obj_type_t *type_in, size_t n_args, size
         mp_int_t val = mp_obj_get_int(item);
         #if MICROPY_FULL_CHECKS
         if (val < 0 || val > 255) {
-            mp_raise_ValueError("bytes value out of range");
+            mp_raise_ValueError(MP_ERROR_TEXT("bytes value out of range"));
         }
         #endif
         vstr_add_byte(&vstr, val);
@@ -267,7 +267,7 @@ STATIC mp_obj_t bytes_make_new(const mp_obj_type_t *type_in, size_t n_args, size
     return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 
 wrong_args:
-    mp_raise_TypeError("wrong number of arguments");
+    mp_raise_TypeError(MP_ERROR_TEXT("wrong number of arguments"));
 }
 
 // like strstr but with specified length and allows \0 bytes
@@ -284,11 +284,11 @@ const byte *find_subbytes(const byte *haystack, size_t hlen, const byte *needle,
         }
         for (;;) {
             if (memcmp(&haystack[str_index], needle, nlen) == 0) {
-                //found
+                // found
                 return haystack + str_index;
             }
             if (str_index == str_index_end) {
-                //not found
+                // not found
                 break;
             }
             str_index += direction;
@@ -320,7 +320,7 @@ mp_obj_t mp_obj_str_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i
     }
 
     // from now on we need lhs type and data, so extract them
-    mp_obj_type_t *lhs_type = mp_obj_get_type(lhs_in);
+    const mp_obj_type_t *lhs_type = mp_obj_get_type(lhs_in);
     GET_STR_DATA_LEN(lhs_in, lhs_data, lhs_len);
 
     // check for multiply
@@ -396,7 +396,7 @@ mp_obj_t mp_obj_str_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i
         case MP_BINARY_OP_CONTAINS:
             return mp_obj_new_bool(find_subbytes(lhs_data, lhs_len, rhs_data, rhs_len, 1) != NULL);
 
-        //case MP_BINARY_OP_NOT_EQUAL: // This is never passed here
+        // case MP_BINARY_OP_NOT_EQUAL: // This is never passed here
         case MP_BINARY_OP_EQUAL: // This will be passed only for bytes, str is dealt with in mp_obj_equal()
         case MP_BINARY_OP_LESS:
         case MP_BINARY_OP_LESS_EQUAL:
@@ -412,7 +412,7 @@ mp_obj_t mp_obj_str_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i
 #if !MICROPY_PY_BUILTINS_STR_UNICODE
 // objstrunicode defines own version
 const byte *str_index_to_ptr(const mp_obj_type_t *type, const byte *self_data, size_t self_len,
-                             mp_obj_t index, bool is_slice) {
+    mp_obj_t index, bool is_slice) {
     size_t index_val = mp_get_index(type, self_len, index, is_slice);
     return self_data + index_val;
 }
@@ -420,25 +420,25 @@ const byte *str_index_to_ptr(const mp_obj_type_t *type, const byte *self_data, s
 
 // This is used for both bytes and 8-bit strings. This is not used for unicode strings.
 STATIC mp_obj_t bytes_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
-    mp_obj_type_t *type = mp_obj_get_type(self_in);
+    const mp_obj_type_t *type = mp_obj_get_type(self_in);
     GET_STR_DATA_LEN(self_in, self_data, self_len);
     if (value == MP_OBJ_SENTINEL) {
         // load
-#if MICROPY_PY_BUILTINS_SLICE
+        #if MICROPY_PY_BUILTINS_SLICE
         if (mp_obj_is_type(index, &mp_type_slice)) {
             mp_bound_slice_t slice;
             if (!mp_seq_get_fast_slice_indexes(self_len, index, &slice)) {
-                mp_raise_NotImplementedError("only slices with step=1 (aka None) are supported");
+                mp_raise_NotImplementedError(MP_ERROR_TEXT("only slices with step=1 (aka None) are supported"));
             }
             return mp_obj_new_str_of_type(type, self_data + slice.start, slice.stop - slice.start);
         }
-#endif
+        #endif
         size_t index_val = mp_get_index(type, self_len, index, false);
         // If we have unicode enabled the type will always be bytes, so take the short cut.
         if (MICROPY_PY_BUILTINS_STR_UNICODE || type == &mp_type_bytes) {
             return MP_OBJ_NEW_SMALL_INT(self_data[index_val]);
         } else {
-            return mp_obj_new_str_via_qstr((char*)&self_data[index_val], 1);
+            return mp_obj_new_str_via_qstr((char *)&self_data[index_val], 1);
         }
     } else {
         return MP_OBJ_NULL; // op not supported
@@ -468,7 +468,7 @@ STATIC mp_obj_t str_join(mp_obj_t self_in, mp_obj_t arg) {
     for (size_t i = 0; i < seq_len; i++) {
         if (mp_obj_get_type(seq_items[i]) != self_type) {
             mp_raise_TypeError(
-                "join expects a list of str/bytes objects consistent with self object");
+                MP_ERROR_TEXT("join expects a list of str/bytes objects consistent with self object"));
         }
         if (i > 0) {
             required_len += sep_len;
@@ -480,7 +480,7 @@ STATIC mp_obj_t str_join(mp_obj_t self_in, mp_obj_t arg) {
     // make joined string
     vstr_t vstr;
     vstr_init_len(&vstr, required_len);
-    byte *data = (byte*)vstr.buf;
+    byte *data = (byte *)vstr.buf;
     for (size_t i = 0; i < seq_len; i++) {
         if (i > 0) {
             memcpy(data, sep_str, sep_len);
@@ -515,15 +515,21 @@ mp_obj_t mp_obj_str_split(size_t n_args, const mp_obj_t *args) {
         // sep not given, so separate on whitespace
 
         // Initial whitespace is not counted as split, so we pre-do it
-        while (s < top && unichar_isspace(*s)) s++;
+        while (s < top && unichar_isspace(*s)) {
+            s++;
+        }
         while (s < top && splits != 0) {
             const byte *start = s;
-            while (s < top && !unichar_isspace(*s)) s++;
+            while (s < top && !unichar_isspace(*s)) {
+                s++;
+            }
             mp_obj_list_append(res, mp_obj_new_str_of_type(self_type, start, s - start));
             if (s >= top) {
                 break;
             }
-            while (s < top && unichar_isspace(*s)) s++;
+            while (s < top && unichar_isspace(*s)) {
+                s++;
+            }
             if (splits > 0) {
                 splits--;
             }
@@ -543,7 +549,7 @@ mp_obj_t mp_obj_str_split(size_t n_args, const mp_obj_t *args) {
         const char *sep_str = mp_obj_str_get_data(sep, &sep_len);
 
         if (sep_len == 0) {
-            mp_raise_ValueError("empty separator");
+            mp_raise_ValueError(MP_ERROR_TEXT("empty separator"));
         }
 
         for (;;) {
@@ -642,13 +648,13 @@ STATIC mp_obj_t str_rsplit(size_t n_args, const mp_obj_t *args) {
     mp_int_t idx = splits;
 
     if (sep == mp_const_none) {
-        mp_raise_NotImplementedError("rsplit(None,n)");
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("rsplit(None,n)"));
     } else {
         size_t sep_len;
         const char *sep_str = mp_obj_str_get_data(sep, &sep_len);
 
         if (sep_len == 0) {
-            mp_raise_ValueError("empty separator");
+            mp_raise_ValueError(MP_ERROR_TEXT("empty separator"));
         }
 
         const byte *beg = s;
@@ -714,7 +720,7 @@ STATIC mp_obj_t str_finder(size_t n_args, const mp_obj_t *args, int direction, b
     out_error:
         // not found
         if (is_index) {
-            mp_raise_ValueError("substring not found");
+            mp_raise_ValueError(MP_ERROR_TEXT("substring not found"));
         } else {
             return MP_OBJ_NEW_SMALL_INT(-1);
         }
@@ -771,7 +777,7 @@ STATIC mp_obj_t str_endswith(size_t n_args, const mp_obj_t *args) {
     size_t suffix_len;
     const char *suffix = mp_obj_str_get_data(args[1], &suffix_len);
     if (n_args > 2) {
-        mp_raise_NotImplementedError("start/end indices");
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("start/end indices"));
     }
 
     if (suffix_len > str_len) {
@@ -843,7 +849,7 @@ STATIC mp_obj_t str_uni_strip(int type, size_t n_args, const mp_obj_t *args) {
     }
 
     assert(last_good_char_pos >= first_good_char_pos);
-    //+1 to accommodate the last character
+    // +1 to accommodate the last character
     size_t stripped_len = last_good_char_pos - first_good_char_pos + 1;
     if (stripped_len == orig_str_len) {
         // If nothing was stripped, don't bother to dup original string
@@ -910,31 +916,31 @@ STATIC bool istype(char ch) {
 }
 
 STATIC bool arg_looks_integer(mp_obj_t arg) {
-    return mp_obj_is_type(arg, &mp_type_bool) || mp_obj_is_int(arg);
+    return mp_obj_is_bool(arg) || mp_obj_is_int(arg);
 }
 
 STATIC bool arg_looks_numeric(mp_obj_t arg) {
     return arg_looks_integer(arg)
-#if MICROPY_PY_BUILTINS_FLOAT
-        || mp_obj_is_float(arg)
-#endif
+           #if MICROPY_PY_BUILTINS_FLOAT
+           || mp_obj_is_float(arg)
+           #endif
     ;
 }
 
 #if MICROPY_PY_BUILTINS_STR_OP_MODULO
 STATIC mp_obj_t arg_as_int(mp_obj_t arg) {
-#if MICROPY_PY_BUILTINS_FLOAT
+    #if MICROPY_PY_BUILTINS_FLOAT
     if (mp_obj_is_float(arg)) {
         return mp_obj_new_int_from_float(mp_obj_float_get(arg));
     }
-#endif
+    #endif
     return arg;
 }
 #endif
 
 #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
 STATIC NORETURN void terse_str_format_value_error(void) {
-    mp_raise_ValueError("bad format string");
+    mp_raise_ValueError(MP_ERROR_TEXT("bad format string"));
 }
 #else
 // define to nothing to improve coverage
@@ -953,11 +959,11 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
                 vstr_add_byte(&vstr, '}');
                 continue;
             }
-            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                terse_str_format_value_error();
-            } else {
-                mp_raise_ValueError("single '}' encountered in format string");
-            }
+            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+            terse_str_format_value_error();
+            #else
+            mp_raise_ValueError(MP_ERROR_TEXT("single '}' encountered in format string"));
+            #endif
         }
         if (*str != '{') {
             vstr_add_byte(&vstr, *str);
@@ -992,19 +998,19 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
             if (str < top && (*str == 'r' || *str == 's')) {
                 conversion = *str++;
             } else {
-                if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                    terse_str_format_value_error();
-                } else if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL) {
-                    mp_raise_ValueError("bad conversion specifier");
+                #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                terse_str_format_value_error();
+                #elif MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL
+                mp_raise_ValueError(MP_ERROR_TEXT("bad conversion specifier"));
+                #else
+                if (str >= top) {
+                    mp_raise_ValueError(
+                        MP_ERROR_TEXT("end of format while looking for conversion specifier"));
                 } else {
-                    if (str >= top) {
-                        mp_raise_ValueError(
-                            "end of format while looking for conversion specifier");
-                    } else {
-                        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-                            "unknown conversion specifier %c", *str));
-                    }
+                    mp_raise_msg_varg(&mp_type_ValueError,
+                        MP_ERROR_TEXT("unknown conversion specifier %c"), *str);
                 }
+                #endif
             }
         }
 
@@ -1030,18 +1036,18 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
             }
         }
         if (str >= top) {
-            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                terse_str_format_value_error();
-            } else {
-                mp_raise_ValueError("unmatched '{' in format");
-            }
+            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+            terse_str_format_value_error();
+            #else
+            mp_raise_ValueError(MP_ERROR_TEXT("unmatched '{' in format"));
+            #endif
         }
         if (*str != '}') {
-            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                terse_str_format_value_error();
-            } else {
-                mp_raise_ValueError("expected ':' after format specifier");
-            }
+            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+            terse_str_format_value_error();
+            #else
+            mp_raise_ValueError(MP_ERROR_TEXT("expected ':' after format specifier"));
+            #endif
         }
 
         mp_obj_t arg = mp_const_none;
@@ -1050,22 +1056,23 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
             int index = 0;
             if (MP_LIKELY(unichar_isdigit(*field_name))) {
                 if (*arg_i > 0) {
-                    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                        terse_str_format_value_error();
-                    } else {
-                        mp_raise_ValueError(
-                            "can't switch from automatic field numbering to manual field specification");
-                    }
+                    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                    terse_str_format_value_error();
+                    #else
+                    mp_raise_ValueError(
+                        MP_ERROR_TEXT("can't switch from automatic field numbering to manual field specification"));
+                    #endif
                 }
                 field_name = str_to_int(field_name, field_name_top, &index);
                 if ((uint)index >= n_args - 1) {
-                    mp_raise_msg(&mp_type_IndexError, "tuple index out of range");
+                    mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("tuple index out of range"));
                 }
                 arg = args[index + 1];
                 *arg_i = -1;
             } else {
                 const char *lookup;
-                for (lookup = field_name; lookup < field_name_top && *lookup != '.' && *lookup != '['; lookup++);
+                for (lookup = field_name; lookup < field_name_top && *lookup != '.' && *lookup != '['; lookup++) {;
+                }
                 mp_obj_t field_q = mp_obj_new_str_via_qstr(field_name, lookup - field_name); // should it be via qstr?
                 field_name = lookup;
                 mp_map_elem_t *key_elem = mp_map_lookup(kwargs, field_q, MP_MAP_LOOKUP);
@@ -1075,19 +1082,19 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
                 arg = key_elem->value;
             }
             if (field_name < field_name_top) {
-                mp_raise_NotImplementedError("attributes not supported yet");
+                mp_raise_NotImplementedError(MP_ERROR_TEXT("attributes not supported yet"));
             }
         } else {
             if (*arg_i < 0) {
-                if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                    terse_str_format_value_error();
-                } else {
-                    mp_raise_ValueError(
-                        "can't switch from manual field specification to automatic field numbering");
-                }
+                #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                terse_str_format_value_error();
+                #else
+                mp_raise_ValueError(
+                    MP_ERROR_TEXT("can't switch from manual field specification to automatic field numbering"));
+                #endif
             }
             if ((uint)*arg_i >= n_args - 1) {
-                mp_raise_msg(&mp_type_IndexError, "tuple index out of range");
+                mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("tuple index out of range"));
             }
             arg = args[(*arg_i) + 1];
             (*arg_i)++;
@@ -1172,11 +1179,11 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
                 type = *s++;
             }
             if (*s) {
-                if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                    terse_str_format_value_error();
-                } else {
-                    mp_raise_ValueError("invalid format specifier");
-                }
+                #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                terse_str_format_value_error();
+                #else
+                mp_raise_ValueError(MP_ERROR_TEXT("invalid format specifier"));
+                #endif
             }
             vstr_clear(&format_spec_vstr);
         }
@@ -1193,26 +1200,32 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
 
         if (flags & (PF_FLAG_SHOW_SIGN | PF_FLAG_SPACE_SIGN)) {
             if (type == 's') {
-                if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                    terse_str_format_value_error();
-                } else {
-                    mp_raise_ValueError("sign not allowed in string format specifier");
-                }
+                #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                terse_str_format_value_error();
+                #else
+                mp_raise_ValueError(MP_ERROR_TEXT("sign not allowed in string format specifier"));
+                #endif
             }
             if (type == 'c') {
-                if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                    terse_str_format_value_error();
-                } else {
-                    mp_raise_ValueError(
-                        "sign not allowed with integer format specifier 'c'");
-                }
+                #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                terse_str_format_value_error();
+                #else
+                mp_raise_ValueError(
+                    MP_ERROR_TEXT("sign not allowed with integer format specifier 'c'"));
+                #endif
             }
         }
 
         switch (align) {
-            case '<': flags |= PF_FLAG_LEFT_ADJUST;     break;
-            case '=': flags |= PF_FLAG_PAD_AFTER_SIGN;  break;
-            case '^': flags |= PF_FLAG_CENTER_ADJUST;   break;
+            case '<':
+                flags |= PF_FLAG_LEFT_ADJUST;
+                break;
+            case '=':
+                flags |= PF_FLAG_PAD_AFTER_SIGN;
+                break;
+            case '^':
+                flags |= PF_FLAG_CENTER_ADJUST;
+                break;
         }
 
         if (arg_looks_integer(arg)) {
@@ -1221,8 +1234,7 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
                     mp_print_mp_int(&print, arg, 2, 'a', flags, fill, width, 0);
                     continue;
 
-                case 'c':
-                {
+                case 'c': {
                     char ch = mp_obj_get_int(arg);
                     mp_print_strn(&print, &ch, 1, flags, fill, width);
                     continue;
@@ -1259,13 +1271,13 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
                     break;
 
                 default:
-                    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                        terse_str_format_value_error();
-                    } else {
-                        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-                            "unknown format code '%c' for object of type '%s'",
-                            type, mp_obj_get_type_str(arg)));
-                    }
+                    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                    terse_str_format_value_error();
+                    #else
+                    mp_raise_msg_varg(&mp_type_ValueError,
+                        MP_ERROR_TEXT("unknown format code '%c' for object of type '%s'"),
+                        type, mp_obj_get_type_str(arg));
+                    #endif
             }
         }
 
@@ -1308,7 +1320,7 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
             }
 
             switch (type) {
-#if MICROPY_PY_BUILTINS_FLOAT
+                #if MICROPY_PY_BUILTINS_FLOAT
                 case 'e':
                 case 'E':
                 case 'f':
@@ -1326,29 +1338,29 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
                     #define F100 100.0
                     #endif
                     mp_print_float(&print, mp_obj_get_float(arg) * F100, 'f', flags, fill, width, precision);
-                    #undef F100
+#undef F100
                     break;
-#endif
+                #endif
 
                 default:
-                    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                        terse_str_format_value_error();
-                    } else {
-                        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-                            "unknown format code '%c' for object of type '%s'",
-                            type, mp_obj_get_type_str(arg)));
-                    }
+                    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                    terse_str_format_value_error();
+                    #else
+                    mp_raise_msg_varg(&mp_type_ValueError,
+                        MP_ERROR_TEXT("unknown format code '%c' for object of type '%s'"),
+                        type, mp_obj_get_type_str(arg));
+                    #endif
             }
         } else {
             // arg doesn't look like a number
 
             if (align == '=') {
-                if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                    terse_str_format_value_error();
-                } else {
-                    mp_raise_ValueError(
-                        "'=' alignment not allowed in string format specifier");
-                }
+                #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                terse_str_format_value_error();
+                #else
+                mp_raise_ValueError(
+                    MP_ERROR_TEXT("'=' alignment not allowed in string format specifier"));
+                #endif
             }
 
             switch (type) {
@@ -1367,13 +1379,13 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
                 }
 
                 default:
-                    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                        terse_str_format_value_error();
-                    } else {
-                        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-                            "unknown format code '%c' for object of type '%s'",
-                            type, mp_obj_get_type_str(arg)));
-                    }
+                    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                    terse_str_format_value_error();
+                    #else
+                    mp_raise_msg_varg(&mp_type_ValueError,
+                        MP_ERROR_TEXT("unknown format code '%c' for object of type '%s'"),
+                        type, mp_obj_get_type_str(arg));
+                    #endif
             }
         }
     }
@@ -1386,7 +1398,7 @@ mp_obj_t mp_obj_str_format(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
 
     GET_STR_DATA_LEN(args[0], str, len);
     int arg_i = 0;
-    vstr_t vstr = mp_obj_str_format_helper((const char*)str, (const char*)str + len, &arg_i, n_args, args, kwargs);
+    vstr_t vstr = mp_obj_str_format_helper((const char *)str, (const char *)str + len, &arg_i, n_args, args, kwargs);
     return mp_obj_new_str_from_vstr(mp_obj_get_type(args[0]), &vstr);
 }
 MP_DEFINE_CONST_FUN_OBJ_KW(str_format_obj, 1, mp_obj_str_format);
@@ -1396,7 +1408,9 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_
     mp_check_self(mp_obj_is_str_or_bytes(pattern));
 
     GET_STR_DATA_LEN(pattern, str, len);
+    #if MICROPY_ERROR_REPORTING != MICROPY_ERROR_REPORTING_TERSE
     const byte *start_str = str;
+    #endif
     bool is_bytes = mp_obj_is_type(pattern, &mp_type_bytes);
     size_t arg_i = 0;
     vstr_t vstr;
@@ -1420,21 +1434,21 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_
         // Dictionary value lookup
         if (*str == '(') {
             if (dict == MP_OBJ_NULL) {
-                mp_raise_TypeError("format needs a dict");
+                mp_raise_TypeError(MP_ERROR_TEXT("format needs a dict"));
             }
             arg_i = 1; // we used up the single dict argument
             const byte *key = ++str;
             while (*str != ')') {
                 if (str >= top) {
-                    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                        terse_str_format_value_error();
-                    } else {
-                        mp_raise_ValueError("incomplete format key");
-                    }
+                    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                    terse_str_format_value_error();
+                    #else
+                    mp_raise_ValueError(MP_ERROR_TEXT("incomplete format key"));
+                    #endif
                 }
                 ++str;
             }
-            mp_obj_t k_obj = mp_obj_new_str_via_qstr((const char*)key, str - key);
+            mp_obj_t k_obj = mp_obj_new_str_via_qstr((const char *)key, str - key);
             arg = mp_obj_dict_get(dict, k_obj);
             str++;
         }
@@ -1443,14 +1457,20 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_
         char fill = ' ';
         int alt = 0;
         while (str < top) {
-            if (*str == '-')      flags |= PF_FLAG_LEFT_ADJUST;
-            else if (*str == '+') flags |= PF_FLAG_SHOW_SIGN;
-            else if (*str == ' ') flags |= PF_FLAG_SPACE_SIGN;
-            else if (*str == '#') alt = PF_FLAG_SHOW_PREFIX;
-            else if (*str == '0') {
+            if (*str == '-') {
+                flags |= PF_FLAG_LEFT_ADJUST;
+            } else if (*str == '+') {
+                flags |= PF_FLAG_SHOW_SIGN;
+            } else if (*str == ' ') {
+                flags |= PF_FLAG_SPACE_SIGN;
+            } else if (*str == '#') {
+                alt = PF_FLAG_SHOW_PREFIX;
+            } else if (*str == '0') {
                 flags |= PF_FLAG_PAD_AFTER_SIGN;
                 fill = '0';
-            } else break;
+            } else {
+                break;
+            }
             str++;
         }
         // parse width, if it exists
@@ -1463,7 +1483,7 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_
                 width = mp_obj_get_int(args[arg_i++]);
                 str++;
             } else {
-                str = (const byte*)str_to_int((const char*)str, (const char*)top, &width);
+                str = (const byte *)str_to_int((const char *)str, (const char *)top, &width);
             }
         }
         int prec = -1;
@@ -1477,25 +1497,25 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_
                     str++;
                 } else {
                     prec = 0;
-                    str = (const byte*)str_to_int((const char*)str, (const char*)top, &prec);
+                    str = (const byte *)str_to_int((const char *)str, (const char *)top, &prec);
                 }
             }
         }
 
         if (str >= top) {
-incomplete_format:
-            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                terse_str_format_value_error();
-            } else {
-                mp_raise_ValueError("incomplete format");
-            }
+        incomplete_format:
+            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+            terse_str_format_value_error();
+            #else
+            mp_raise_ValueError(MP_ERROR_TEXT("incomplete format"));
+            #endif
         }
 
         // Tuple value lookup
         if (arg == MP_OBJ_NULL) {
             if (arg_i >= n_args) {
-not_enough_args:
-                mp_raise_TypeError("format string needs more arguments");
+            not_enough_args:
+                mp_raise_TypeError(MP_ERROR_TEXT("format string needs more arguments"));
             }
             arg = args[arg_i++];
         }
@@ -1505,14 +1525,14 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_
                     size_t slen;
                     const char *s = mp_obj_str_get_data(arg, &slen);
                     if (slen != 1) {
-                        mp_raise_TypeError("%%c needs int or char");
+                        mp_raise_TypeError(MP_ERROR_TEXT("%c needs int or char"));
                     }
                     mp_print_strn(&print, s, 1, flags, ' ', width);
                 } else if (arg_looks_integer(arg)) {
                     char ch = mp_obj_get_int(arg);
                     mp_print_strn(&print, &ch, 1, flags, ' ', width);
                 } else {
-                    mp_raise_TypeError("integer needed");
+                    mp_raise_TypeError(MP_ERROR_TEXT("integer needed"));
                 }
                 break;
 
@@ -1522,7 +1542,7 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_
                 mp_print_mp_int(&print, arg_as_int(arg), 10, 'a', flags, fill, width, prec);
                 break;
 
-#if MICROPY_PY_BUILTINS_FLOAT
+            #if MICROPY_PY_BUILTINS_FLOAT
             case 'e':
             case 'E':
             case 'f':
@@ -1531,7 +1551,7 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_
             case 'G':
                 mp_print_float(&print, mp_obj_get_float(arg), *str, flags, fill, width, prec);
                 break;
-#endif
+            #endif
 
             case 'o':
                 if (alt) {
@@ -1541,8 +1561,7 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_
                 break;
 
             case 'r':
-            case 's':
-            {
+            case 's': {
                 vstr_t arg_vstr;
                 mp_print_t arg_print;
                 vstr_init_print(&arg_vstr, 16, &arg_print);
@@ -1571,18 +1590,18 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_
                 break;
 
             default:
-                if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                    terse_str_format_value_error();
-                } else {
-                    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-                        "unsupported format character '%c' (0x%x) at index %d",
-                        *str, *str, str - start_str));
-                }
+                #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+                terse_str_format_value_error();
+                #else
+                mp_raise_msg_varg(&mp_type_ValueError,
+                    MP_ERROR_TEXT("unsupported format character '%c' (0x%x) at index %d"),
+                    *str, *str, str - start_str);
+                #endif
         }
     }
 
     if (arg_i != n_args) {
-        mp_raise_TypeError("format string didn't convert all arguments");
+        mp_raise_TypeError(MP_ERROR_TEXT("format string didn't convert all arguments"));
     }
 
     return mp_obj_new_str_from_vstr(is_bytes ? &mp_type_bytes : &mp_type_str, &vstr);
@@ -1684,7 +1703,7 @@ STATIC mp_obj_t str_replace(size_t n_args, const mp_obj_t *args) {
             } else {
                 // substr found, allocate new string
                 vstr_init_len(&vstr, replaced_str_index);
-                data = (byte*)vstr.buf;
+                data = (byte *)vstr.buf;
                 assert(data != NULL);
             }
         } else {
@@ -1743,7 +1762,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_count_obj, 2, 4, str_count);
 #if MICROPY_PY_BUILTINS_STR_PARTITION
 STATIC mp_obj_t str_partitioner(mp_obj_t self_in, mp_obj_t arg, int direction) {
     mp_check_self(mp_obj_is_str_or_bytes(self_in));
-    mp_obj_type_t *self_type = mp_obj_get_type(self_in);
+    const mp_obj_type_t *self_type = mp_obj_get_type(self_in);
     if (self_type != mp_obj_get_type(arg)) {
         bad_implicit_conversion(arg);
     }
@@ -1752,7 +1771,7 @@ STATIC mp_obj_t str_partitioner(mp_obj_t self_in, mp_obj_t arg, int direction) {
     GET_STR_DATA_LEN(arg, sep, sep_len);
 
     if (sep_len == 0) {
-        mp_raise_ValueError("empty separator");
+        mp_raise_ValueError(MP_ERROR_TEXT("empty separator"));
     }
 
     mp_obj_t result[3];
@@ -1799,7 +1818,7 @@ STATIC mp_obj_t str_caseconv(unichar (*op)(unichar), mp_obj_t self_in) {
     GET_STR_DATA_LEN(self_in, self_data, self_len);
     vstr_t vstr;
     vstr_init_len(&vstr, self_len);
-    byte *data = (byte*)vstr.buf;
+    byte *data = (byte *)vstr.buf;
     for (size_t i = 0; i < self_len; i++) {
         *data++ = op(*self_data++);
     }
@@ -1907,21 +1926,18 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_encode_obj, 1, 3, str_encode);
 mp_int_t mp_obj_str_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags) {
     if (flags == MP_BUFFER_READ) {
         GET_STR_DATA_LEN(self_in, str_data, str_len);
-        bufinfo->buf = (void*)str_data;
+        bufinfo->buf = (void *)str_data;
         bufinfo->len = str_len;
         bufinfo->typecode = 'B'; // bytes should be unsigned, so should unicode byte-access
         return 0;
     } else {
         // can't write to a string
-        bufinfo->buf = NULL;
-        bufinfo->len = 0;
-        bufinfo->typecode = -1;
         return 1;
     }
 }
 
 STATIC const mp_rom_map_elem_t str8_locals_dict_table[] = {
-#if MICROPY_CPYTHON_COMPAT
+    #if MICROPY_CPYTHON_COMPAT
     { MP_ROM_QSTR(MP_QSTR_decode), MP_ROM_PTR(&bytes_decode_obj) },
     #if !MICROPY_PY_BUILTINS_STR_UNICODE
     // If we have separate unicode type, then here we have methods only
@@ -1931,7 +1947,7 @@ STATIC const mp_rom_map_elem_t str8_locals_dict_table[] = {
     // methods (which should do type checking at runtime).
     { MP_ROM_QSTR(MP_QSTR_encode), MP_ROM_PTR(&str_encode_obj) },
     #endif
-#endif
+    #endif
     { MP_ROM_QSTR(MP_QSTR_find), MP_ROM_PTR(&str_find_obj) },
     { MP_ROM_QSTR(MP_QSTR_rfind), MP_ROM_PTR(&str_rfind_obj) },
     { MP_ROM_QSTR(MP_QSTR_index), MP_ROM_PTR(&str_index_obj) },
@@ -1982,7 +1998,7 @@ const mp_obj_type_t mp_type_str = {
     .subscr = bytes_subscr,
     .getiter = mp_obj_new_str_iterator,
     .buffer_p = { .get_buffer = mp_obj_str_get_buffer },
-    .locals_dict = (mp_obj_dict_t*)&str8_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&str8_locals_dict,
 };
 #endif
 
@@ -1996,16 +2012,16 @@ const mp_obj_type_t mp_type_bytes = {
     .subscr = bytes_subscr,
     .getiter = mp_obj_new_bytes_iterator,
     .buffer_p = { .get_buffer = mp_obj_str_get_buffer },
-    .locals_dict = (mp_obj_dict_t*)&str8_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&str8_locals_dict,
 };
 
 // The zero-length bytes object, with data that includes a null-terminating byte
-const mp_obj_str_t mp_const_empty_bytes_obj = {{&mp_type_bytes}, 0, 0, (const byte*)""};
+const mp_obj_str_t mp_const_empty_bytes_obj = {{&mp_type_bytes}, 0, 0, (const byte *)""};
 
 // Create a str/bytes object using the given data.  New memory is allocated and
 // the data is copied across.  This function should only be used if the type is bytes,
 // or if the type is str and the string data is known to be not interned.
-mp_obj_t mp_obj_new_str_copy(const mp_obj_type_t *type, const byte* data, size_t len) {
+mp_obj_t mp_obj_new_str_copy(const mp_obj_type_t *type, const byte *data, size_t len) {
     mp_obj_str_t *o = m_new_obj(mp_obj_str_t);
     o->base.type = type;
     o->len = len;
@@ -2022,16 +2038,16 @@ mp_obj_t mp_obj_new_str_copy(const mp_obj_type_t *type, const byte* data, size_t
 // Create a str/bytes object using the given data.  If the type is str and the string
 // data is already interned, then a qstr object is returned.  Otherwise new memory is
 // allocated for the object and the data is copied across.
-mp_obj_t mp_obj_new_str_of_type(const mp_obj_type_t *type, const byte* data, size_t len) {
+mp_obj_t mp_obj_new_str_of_type(const mp_obj_type_t *type, const byte *data, size_t len) {
     if (type == &mp_type_str) {
-        return mp_obj_new_str((const char*)data, len);
+        return mp_obj_new_str((const char *)data, len);
     } else {
         return mp_obj_new_bytes(data, len);
     }
 }
 
 // Create a str using a qstr to store the data; may use existing or new qstr.
-mp_obj_t mp_obj_new_str_via_qstr(const char* data, size_t len) {
+mp_obj_t mp_obj_new_str_via_qstr(const char *data, size_t len) {
     return MP_OBJ_NEW_QSTR(qstr_from_strn(data, len));
 }
 
@@ -2042,7 +2058,7 @@ mp_obj_t mp_obj_new_str_from_vstr(const mp_obj_type_t *type, vstr_t *vstr) {
     // if not a bytes object, look if a qstr with this data already exists
     if (type == &mp_type_str) {
         qstr q = qstr_find_strn(vstr->buf, vstr->len);
-        if (q != MP_QSTR_NULL) {
+        if (q != MP_QSTRnull) {
             vstr_clear(vstr);
             vstr->alloc = 0;
             return MP_OBJ_NEW_QSTR(q);
@@ -2053,41 +2069,41 @@ mp_obj_t mp_obj_new_str_from_vstr(const mp_obj_type_t *type, vstr_t *vstr) {
     mp_obj_str_t *o = m_new_obj(mp_obj_str_t);
     o->base.type = type;
     o->len = vstr->len;
-    o->hash = qstr_compute_hash((byte*)vstr->buf, vstr->len);
+    o->hash = qstr_compute_hash((byte *)vstr->buf, vstr->len);
     if (vstr->len + 1 == vstr->alloc) {
-        o->data = (byte*)vstr->buf;
+        o->data = (byte *)vstr->buf;
     } else {
-        o->data = (byte*)m_renew(char, vstr->buf, vstr->alloc, vstr->len + 1);
+        o->data = (byte *)m_renew(char, vstr->buf, vstr->alloc, vstr->len + 1);
     }
-    ((byte*)o->data)[o->len] = '\0'; // add null byte
+    ((byte *)o->data)[o->len] = '\0'; // add null byte
     vstr->buf = NULL;
     vstr->alloc = 0;
     return MP_OBJ_FROM_PTR(o);
 }
 
-mp_obj_t mp_obj_new_str(const char* data, size_t len) {
+mp_obj_t mp_obj_new_str(const char *data, size_t len) {
     qstr q = qstr_find_strn(data, len);
-    if (q != MP_QSTR_NULL) {
+    if (q != MP_QSTRnull) {
         // qstr with this data already exists
         return MP_OBJ_NEW_QSTR(q);
     } else {
         // no existing qstr, don't make one
-        return mp_obj_new_str_copy(&mp_type_str, (const byte*)data, len);
+        return mp_obj_new_str_copy(&mp_type_str, (const byte *)data, len);
     }
 }
 
 mp_obj_t mp_obj_str_intern(mp_obj_t str) {
     GET_STR_DATA_LEN(str, data, len);
-    return mp_obj_new_str_via_qstr((const char*)data, len);
+    return mp_obj_new_str_via_qstr((const char *)data, len);
 }
 
 mp_obj_t mp_obj_str_intern_checked(mp_obj_t obj) {
     size_t len;
     const char *data = mp_obj_str_get_data(obj, &len);
-    return mp_obj_new_str_via_qstr((const char*)data, len);
+    return mp_obj_new_str_via_qstr((const char *)data, len);
 }
 
-mp_obj_t mp_obj_new_bytes(const byte* data, size_t len) {
+mp_obj_t mp_obj_new_bytes(const byte *data, size_t len) {
     return mp_obj_new_str_copy(&mp_type_bytes, data, len);
 }
 
@@ -2111,14 +2127,14 @@ bool mp_obj_str_equal(mp_obj_t s1, mp_obj_t s2) {
 }
 
 STATIC NORETURN void bad_implicit_conversion(mp_obj_t self_in) {
-    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-        mp_raise_TypeError("can't convert to str implicitly");
-    } else {
-        const qstr src_name = mp_obj_get_type(self_in)->name;
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-            "can't convert '%q' object to %q implicitly",
-            src_name, src_name == MP_QSTR_str ? MP_QSTR_bytes : MP_QSTR_str));
-    }
+    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+    mp_raise_TypeError(MP_ERROR_TEXT("can't convert to str implicitly"));
+    #else
+    const qstr src_name = mp_obj_get_type(self_in)->name;
+    mp_raise_msg_varg(&mp_type_TypeError,
+        MP_ERROR_TEXT("can't convert '%q' object to %q implicitly"),
+        src_name, src_name == MP_QSTR_str ? MP_QSTR_bytes : MP_QSTR_str);
+    #endif
 }
 
 // use this if you will anyway convert the string to a qstr
@@ -2128,7 +2144,7 @@ qstr mp_obj_str_get_qstr(mp_obj_t self_in) {
         return MP_OBJ_QSTR_VALUE(self_in);
     } else if (mp_obj_is_type(self_in, &mp_type_str)) {
         mp_obj_str_t *self = MP_OBJ_TO_PTR(self_in);
-        return qstr_from_strn((char*)self->data, self->len);
+        return qstr_from_strn((char *)self->data, self->len);
     } else {
         bad_implicit_conversion(self_in);
     }
@@ -2140,7 +2156,7 @@ const char *mp_obj_str_get_str(mp_obj_t self_in) {
     if (mp_obj_is_str_or_bytes(self_in)) {
         GET_STR_DATA_LEN(self_in, s, l);
         (void)l; // len unused
-        return (const char*)s;
+        return (const char *)s;
     } else {
         bad_implicit_conversion(self_in);
     }
@@ -2150,19 +2166,19 @@ const char *mp_obj_str_get_data(mp_obj_t self_in, size_t *len) {
     if (mp_obj_is_str_or_bytes(self_in)) {
         GET_STR_DATA_LEN(self_in, s, l);
         *len = l;
-        return (const char*)s;
+        return (const char *)s;
     } else {
         bad_implicit_conversion(self_in);
     }
 }
 
-#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
+#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D
 const byte *mp_obj_str_get_data_no_check(mp_obj_t self_in, size_t *len) {
     if (mp_obj_is_qstr(self_in)) {
         return qstr_data(MP_OBJ_QSTR_VALUE(self_in), len);
     } else {
-        *len = ((mp_obj_str_t*)self_in)->len;
-        return ((mp_obj_str_t*)self_in)->data;
+        *len = ((mp_obj_str_t *)MP_OBJ_TO_PTR(self_in))->len;
+        return ((mp_obj_str_t *)MP_OBJ_TO_PTR(self_in))->data;
     }
 }
 #endif
@@ -2182,7 +2198,7 @@ STATIC mp_obj_t str_it_iternext(mp_obj_t self_in) {
     mp_obj_str8_it_t *self = MP_OBJ_TO_PTR(self_in);
     GET_STR_DATA_LEN(self->str, str, len);
     if (self->cur < len) {
-        mp_obj_t o_out = mp_obj_new_str_via_qstr((const char*)str + self->cur, 1);
+        mp_obj_t o_out = mp_obj_new_str_via_qstr((const char *)str + self->cur, 1);
         self->cur += 1;
         return o_out;
     } else {
@@ -2192,7 +2208,7 @@ STATIC mp_obj_t str_it_iternext(mp_obj_t self_in) {
 
 STATIC mp_obj_t mp_obj_new_str_iterator(mp_obj_t str, mp_obj_iter_buf_t *iter_buf) {
     assert(sizeof(mp_obj_str8_it_t) <= sizeof(mp_obj_iter_buf_t));
-    mp_obj_str8_it_t *o = (mp_obj_str8_it_t*)iter_buf;
+    mp_obj_str8_it_t *o = (mp_obj_str8_it_t *)iter_buf;
     o->base.type = &mp_type_polymorph_iter;
     o->iternext = str_it_iternext;
     o->str = str;
@@ -2215,7 +2231,7 @@ STATIC mp_obj_t bytes_it_iternext(mp_obj_t self_in) {
 
 mp_obj_t mp_obj_new_bytes_iterator(mp_obj_t str, mp_obj_iter_buf_t *iter_buf) {
     assert(sizeof(mp_obj_str8_it_t) <= sizeof(mp_obj_iter_buf_t));
-    mp_obj_str8_it_t *o = (mp_obj_str8_it_t*)iter_buf;
+    mp_obj_str8_it_t *o = (mp_obj_str8_it_t *)iter_buf;
     o->base.type = &mp_type_polymorph_iter;
     o->iternext = bytes_it_iternext;
     o->str = str;
diff --git a/py/objstr.h b/py/objstr.h
index a10d0df8bed14..8c450baed6e41 100644
--- a/py/objstr.h
+++ b/py/objstr.h
@@ -36,21 +36,21 @@ typedef struct _mp_obj_str_t {
     const byte *data;
 } mp_obj_str_t;
 
-#define MP_DEFINE_STR_OBJ(obj_name, str) mp_obj_str_t obj_name = {{&mp_type_str}, 0, sizeof(str) - 1, (const byte*)str}
+#define MP_DEFINE_STR_OBJ(obj_name, str) mp_obj_str_t obj_name = {{&mp_type_str}, 0, sizeof(str) - 1, (const byte *)str}
 
 // use this macro to extract the string hash
 // warning: the hash can be 0, meaning invalid, and must then be explicitly computed from the data
 #define GET_STR_HASH(str_obj_in, str_hash) \
     mp_uint_t str_hash; if (mp_obj_is_qstr(str_obj_in)) \
-    { str_hash = qstr_hash(MP_OBJ_QSTR_VALUE(str_obj_in)); } else { str_hash = ((mp_obj_str_t*)MP_OBJ_TO_PTR(str_obj_in))->hash; }
+    { str_hash = qstr_hash(MP_OBJ_QSTR_VALUE(str_obj_in)); } else { str_hash = ((mp_obj_str_t *)MP_OBJ_TO_PTR(str_obj_in))->hash; }
 
 // use this macro to extract the string length
 #define GET_STR_LEN(str_obj_in, str_len) \
     size_t str_len; if (mp_obj_is_qstr(str_obj_in)) \
-    { str_len = qstr_len(MP_OBJ_QSTR_VALUE(str_obj_in)); } else { str_len = ((mp_obj_str_t*)MP_OBJ_TO_PTR(str_obj_in))->len; }
+    { str_len = qstr_len(MP_OBJ_QSTR_VALUE(str_obj_in)); } else { str_len = ((mp_obj_str_t *)MP_OBJ_TO_PTR(str_obj_in))->len; }
 
 // use this macro to extract the string data and length
-#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C
+#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D
 const byte *mp_obj_str_get_data_no_check(mp_obj_t self_in, size_t *len);
 #define GET_STR_DATA_LEN(str_obj_in, str_data, str_len) \
     size_t str_len; const byte *str_data = mp_obj_str_get_data_no_check(str_obj_in, &str_len);
@@ -58,21 +58,21 @@ const byte *mp_obj_str_get_data_no_check(mp_obj_t self_in, size_t *len);
 #define GET_STR_DATA_LEN(str_obj_in, str_data, str_len) \
     const byte *str_data; size_t str_len; if (mp_obj_is_qstr(str_obj_in)) \
     { str_data = qstr_data(MP_OBJ_QSTR_VALUE(str_obj_in), &str_len); } \
-    else { str_len = ((mp_obj_str_t*)MP_OBJ_TO_PTR(str_obj_in))->len; str_data = ((mp_obj_str_t*)MP_OBJ_TO_PTR(str_obj_in))->data; }
+    else { str_len = ((mp_obj_str_t *)MP_OBJ_TO_PTR(str_obj_in))->len; str_data = ((mp_obj_str_t *)MP_OBJ_TO_PTR(str_obj_in))->data; }
 #endif
 
 mp_obj_t mp_obj_str_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args);
 void mp_str_print_json(const mp_print_t *print, const byte *str_data, size_t str_len);
 mp_obj_t mp_obj_str_format(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs);
 mp_obj_t mp_obj_str_split(size_t n_args, const mp_obj_t *args);
-mp_obj_t mp_obj_new_str_copy(const mp_obj_type_t *type, const byte* data, size_t len);
-mp_obj_t mp_obj_new_str_of_type(const mp_obj_type_t *type, const byte* data, size_t len);
+mp_obj_t mp_obj_new_str_copy(const mp_obj_type_t *type, const byte *data, size_t len);
+mp_obj_t mp_obj_new_str_of_type(const mp_obj_type_t *type, const byte *data, size_t len);
 
 mp_obj_t mp_obj_str_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_in);
 mp_int_t mp_obj_str_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags);
 
 const byte *str_index_to_ptr(const mp_obj_type_t *type, const byte *self_data, size_t self_len,
-                             mp_obj_t index, bool is_slice);
+    mp_obj_t index, bool is_slice);
 const byte *find_subbytes(const byte *haystack, size_t hlen, const byte *needle, size_t nlen, int direction);
 
 MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(str_encode_obj);
@@ -102,5 +102,6 @@ MP_DECLARE_CONST_FUN_OBJ_1(str_isalpha_obj);
 MP_DECLARE_CONST_FUN_OBJ_1(str_isdigit_obj);
 MP_DECLARE_CONST_FUN_OBJ_1(str_isupper_obj);
 MP_DECLARE_CONST_FUN_OBJ_1(str_islower_obj);
+MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(bytes_decode_obj);
 
 #endif // MICROPY_INCLUDED_PY_OBJSTR_H
diff --git a/py/objstringio.c b/py/objstringio.c
index 89b679031250d..ef942e74e8f99 100644
--- a/py/objstringio.c
+++ b/py/objstringio.c
@@ -38,7 +38,7 @@
 #if MICROPY_CPYTHON_COMPAT
 STATIC void check_stringio_is_open(const mp_obj_stringio_t *o) {
     if (o->vstr == NULL) {
-        mp_raise_ValueError("I/O operation on closed file");
+        mp_raise_ValueError(MP_ERROR_TEXT("I/O operation on closed file"));
     }
 }
 #else
@@ -70,9 +70,9 @@ STATIC mp_uint_t stringio_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *er
 STATIC void stringio_copy_on_write(mp_obj_stringio_t *o) {
     const void *buf = o->vstr->buf;
     o->vstr->buf = m_new(char, o->vstr->len);
-    memcpy(o->vstr->buf, buf, o->vstr->len);
     o->vstr->fixed_buf = false;
     o->ref_obj = MP_OBJ_NULL;
+    memcpy(o->vstr->buf, buf, o->vstr->len);
 }
 
 STATIC mp_uint_t stringio_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
@@ -114,7 +114,7 @@ STATIC mp_uint_t stringio_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg,
     mp_obj_stringio_t *o = MP_OBJ_TO_PTR(o_in);
     switch (request) {
         case MP_STREAM_SEEK: {
-            struct mp_stream_seek_t *s = (struct mp_stream_seek_t*)arg;
+            struct mp_stream_seek_t *s = (struct mp_stream_seek_t *)arg;
             mp_uint_t ref = 0;
             switch (s->whence) {
                 case MP_SEEK_CUR:
@@ -166,7 +166,7 @@ STATIC mp_obj_t stringio_getvalue(mp_obj_t self_in) {
     mp_obj_stringio_t *self = MP_OBJ_TO_PTR(self_in);
     check_stringio_is_open(self);
     // TODO: Try to avoid copying string
-    return mp_obj_new_str_of_type(STREAM_TO_CONTENT_TYPE(self), (byte*)self->vstr->buf, self->vstr->len);
+    return mp_obj_new_str_of_type(STREAM_TO_CONTENT_TYPE(self), (byte *)self->vstr->buf, self->vstr->len);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(stringio_getvalue_obj, stringio_getvalue);
 
@@ -228,6 +228,7 @@ STATIC const mp_rom_map_elem_t stringio_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
     { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
     { MP_ROM_QSTR(MP_QSTR_seek), MP_ROM_PTR(&mp_stream_seek_obj) },
+    { MP_ROM_QSTR(MP_QSTR_tell), MP_ROM_PTR(&mp_stream_tell_obj) },
     { MP_ROM_QSTR(MP_QSTR_flush), MP_ROM_PTR(&mp_stream_flush_obj) },
     { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
     { MP_ROM_QSTR(MP_QSTR_getvalue), MP_ROM_PTR(&stringio_getvalue_obj) },
@@ -244,12 +245,6 @@ STATIC const mp_stream_p_t stringio_stream_p = {
     .is_text = true,
 };
 
-STATIC const mp_stream_p_t bytesio_stream_p = {
-    .read = stringio_read,
-    .write = stringio_write,
-    .ioctl = stringio_ioctl,
-};
-
 const mp_obj_type_t mp_type_stringio = {
     { &mp_type_type },
     .name = MP_QSTR_StringIO,
@@ -258,10 +253,16 @@ const mp_obj_type_t mp_type_stringio = {
     .getiter = mp_identity_getiter,
     .iternext = mp_stream_unbuffered_iter,
     .protocol = &stringio_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&stringio_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&stringio_locals_dict,
 };
 
 #if MICROPY_PY_IO_BYTESIO
+STATIC const mp_stream_p_t bytesio_stream_p = {
+    .read = stringio_read,
+    .write = stringio_write,
+    .ioctl = stringio_ioctl,
+};
+
 const mp_obj_type_t mp_type_bytesio = {
     { &mp_type_type },
     .name = MP_QSTR_BytesIO,
@@ -270,7 +271,7 @@ const mp_obj_type_t mp_type_bytesio = {
     .getiter = mp_identity_getiter,
     .iternext = mp_stream_unbuffered_iter,
     .protocol = &bytesio_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&stringio_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&stringio_locals_dict,
 };
 #endif
 
diff --git a/py/objstrunicode.c b/py/objstrunicode.c
index 78d0b5006ef73..b21df22a3bc0a 100644
--- a/py/objstrunicode.c
+++ b/py/objstrunicode.c
@@ -113,7 +113,7 @@ STATIC mp_obj_t uni_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
 // Convert an index into a pointer to its lead byte. Out of bounds indexing will raise IndexError or
 // be capped to the first/last character of the string, depending on is_slice.
 const byte *str_index_to_ptr(const mp_obj_type_t *type, const byte *self_data, size_t self_len,
-                             mp_obj_t index, bool is_slice) {
+    mp_obj_t index, bool is_slice) {
     // All str functions also handle bytes objects, and they call str_index_to_ptr(),
     // so it must handle bytes.
     if (type == &mp_type_bytes) {
@@ -129,18 +129,17 @@ const byte *str_index_to_ptr(const mp_obj_type_t *type, const byte *self_data, s
     if (mp_obj_is_small_int(index)) {
         i = MP_OBJ_SMALL_INT_VALUE(index);
     } else if (!mp_obj_get_int_maybe(index, &i)) {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "string indices must be integers, not %s", mp_obj_get_type_str(index)));
+        mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("string indices must be integers, not %s"), mp_obj_get_type_str(index));
     }
     const byte *s, *top = self_data + self_len;
-    if (i < 0)
-    {
+    if (i < 0) {
         // Negative indexing is performed by counting from the end of the string.
         for (s = top - 1; i; --s) {
             if (s < self_data) {
                 if (is_slice) {
                     return self_data;
                 }
-                mp_raise_msg(&mp_type_IndexError, "string index out of range");
+                mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("string index out of range"));
             }
             if (!UTF8_IS_CONT(*s)) {
                 ++i;
@@ -159,7 +158,7 @@ const byte *str_index_to_ptr(const mp_obj_type_t *type, const byte *self_data, s
                 if (is_slice) {
                     return top;
                 }
-                mp_raise_msg(&mp_type_IndexError, "string index out of range");
+                mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("string index out of range"));
             }
             // Then check completion
             if (i-- == 0) {
@@ -176,17 +175,21 @@ const byte *str_index_to_ptr(const mp_obj_type_t *type, const byte *self_data, s
 }
 
 STATIC mp_obj_t str_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
-    mp_obj_type_t *type = mp_obj_get_type(self_in);
+    const mp_obj_type_t *type = mp_obj_get_type(self_in);
     assert(type == &mp_type_str);
     GET_STR_DATA_LEN(self_in, self_data, self_len);
     if (value == MP_OBJ_SENTINEL) {
         // load
-#if MICROPY_PY_BUILTINS_SLICE
+        #if MICROPY_PY_BUILTINS_SLICE
         if (mp_obj_is_type(index, &mp_type_slice)) {
             mp_obj_t ostart, ostop, ostep;
-            mp_obj_slice_get(index, &ostart, &ostop, &ostep);
+            mp_obj_slice_t *slice = MP_OBJ_TO_PTR(index);
+            ostart = slice->start;
+            ostop = slice->stop;
+            ostep = slice->step;
+
             if (ostep != mp_const_none && ostep != MP_OBJ_NEW_SMALL_INT(1)) {
-                mp_raise_NotImplementedError("only slices with step=1 (aka None) are supported");
+                mp_raise_NotImplementedError(MP_ERROR_TEXT("only slices with step=1 (aka None) are supported"));
             }
 
             const byte *pstart, *pstop;
@@ -207,7 +210,7 @@ STATIC mp_obj_t str_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
             }
             return mp_obj_new_str_of_type(type, (const byte *)pstart, pstop - pstart);
         }
-#endif
+        #endif
         const byte *s = str_index_to_ptr(type, self_data, self_len, index, false);
         int len = 1;
         if (UTF8_IS_NONASCII(*s)) {
@@ -216,16 +219,16 @@ STATIC mp_obj_t str_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
                 ++len;
             }
         }
-        return mp_obj_new_str_via_qstr((const char*)s, len); // This will create a one-character string
+        return mp_obj_new_str_via_qstr((const char *)s, len); // This will create a one-character string
     } else {
         return MP_OBJ_NULL; // op not supported
     }
 }
 
 STATIC const mp_rom_map_elem_t struni_locals_dict_table[] = {
-#if MICROPY_CPYTHON_COMPAT
+    #if MICROPY_CPYTHON_COMPAT
     { MP_ROM_QSTR(MP_QSTR_encode), MP_ROM_PTR(&str_encode_obj) },
-#endif
+    #endif
     { MP_ROM_QSTR(MP_QSTR_find), MP_ROM_PTR(&str_find_obj) },
     { MP_ROM_QSTR(MP_QSTR_rfind), MP_ROM_PTR(&str_rfind_obj) },
     { MP_ROM_QSTR(MP_QSTR_index), MP_ROM_PTR(&str_index_obj) },
@@ -274,7 +277,7 @@ const mp_obj_type_t mp_type_str = {
     .subscr = str_subscr,
     .getiter = mp_obj_new_str_iterator,
     .buffer_p = { .get_buffer = mp_obj_str_get_buffer },
-    .locals_dict = (mp_obj_dict_t*)&struni_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&struni_locals_dict,
 };
 
 /******************************************************************************/
@@ -293,7 +296,7 @@ STATIC mp_obj_t str_it_iternext(mp_obj_t self_in) {
     if (self->cur < len) {
         const byte *cur = str + self->cur;
         const byte *end = utf8_next_char(str + self->cur);
-        mp_obj_t o_out = mp_obj_new_str_via_qstr((const char*)cur, end - cur);
+        mp_obj_t o_out = mp_obj_new_str_via_qstr((const char *)cur, end - cur);
         self->cur += end - cur;
         return o_out;
     } else {
@@ -303,7 +306,7 @@ STATIC mp_obj_t str_it_iternext(mp_obj_t self_in) {
 
 STATIC mp_obj_t mp_obj_new_str_iterator(mp_obj_t str, mp_obj_iter_buf_t *iter_buf) {
     assert(sizeof(mp_obj_str_it_t) <= sizeof(mp_obj_iter_buf_t));
-    mp_obj_str_it_t *o = (mp_obj_str_it_t*)iter_buf;
+    mp_obj_str_it_t *o = (mp_obj_str_it_t *)iter_buf;
     o->base.type = &mp_type_polymorph_iter;
     o->iternext = str_it_iternext;
     o->str = str;
diff --git a/py/objtuple.c b/py/objtuple.c
index 39eb940236693..07a560ac08aac 100644
--- a/py/objtuple.c
+++ b/py/objtuple.c
@@ -31,6 +31,9 @@
 #include "py/objtuple.h"
 #include "py/runtime.h"
 
+// type check is done on getiter method to allow tuple, namedtuple, attrtuple
+#define mp_obj_is_tuple_compatible(o) (mp_obj_get_type(o)->getiter == mp_obj_tuple_getiter)
+
 /******************************************************************************/
 /* tuple                                                                      */
 
@@ -101,17 +104,13 @@ STATIC mp_obj_t mp_obj_tuple_make_new(const mp_obj_type_t *type_in, size_t n_arg
 
 // Don't pass MP_BINARY_OP_NOT_EQUAL here
 STATIC mp_obj_t tuple_cmp_helper(mp_uint_t op, mp_obj_t self_in, mp_obj_t another_in) {
-    // type check is done on getiter method to allow tuple, namedtuple, attrtuple
-    mp_check_self(mp_obj_get_type(self_in)->getiter == mp_obj_tuple_getiter);
-    mp_obj_type_t *another_type = mp_obj_get_type(another_in);
+    mp_check_self(mp_obj_is_tuple_compatible(self_in));
+    const mp_obj_type_t *another_type = mp_obj_get_type(another_in);
     mp_obj_tuple_t *self = MP_OBJ_TO_PTR(self_in);
     if (another_type->getiter != mp_obj_tuple_getiter) {
         // Slow path for user subclasses
-        another_in = mp_instance_cast_to_native_base(another_in, MP_OBJ_FROM_PTR(&mp_type_tuple));
+        another_in = mp_obj_cast_to_native_base(another_in, MP_OBJ_FROM_PTR(&mp_type_tuple));
         if (another_in == MP_OBJ_NULL) {
-            if (op == MP_BINARY_OP_EQUAL) {
-                return mp_const_false;
-            }
             return MP_OBJ_NULL;
         }
     }
@@ -123,7 +122,8 @@ STATIC mp_obj_t tuple_cmp_helper(mp_uint_t op, mp_obj_t self_in, mp_obj_t anothe
 mp_obj_t mp_obj_tuple_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
     mp_obj_tuple_t *self = MP_OBJ_TO_PTR(self_in);
     switch (op) {
-        case MP_UNARY_OP_BOOL: return mp_obj_new_bool(self->len != 0);
+        case MP_UNARY_OP_BOOL:
+            return mp_obj_new_bool(self->len != 0);
         case MP_UNARY_OP_HASH: {
             // start hash with pointer to empty tuple, to make it fairly unique
             mp_int_t hash = (mp_int_t)mp_const_empty_tuple;
@@ -132,8 +132,10 @@ mp_obj_t mp_obj_tuple_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
             }
             return MP_OBJ_NEW_SMALL_INT(hash);
         }
-        case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(self->len);
-        default: return MP_OBJ_NULL; // op not supported
+        case MP_UNARY_OP_LEN:
+            return MP_OBJ_NEW_SMALL_INT(self->len);
+        default:
+            return MP_OBJ_NULL;      // op not supported
     }
 }
 
@@ -179,17 +181,17 @@ mp_obj_t mp_obj_tuple_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
     if (value == MP_OBJ_SENTINEL) {
         // load
         mp_obj_tuple_t *self = MP_OBJ_TO_PTR(self_in);
-#if MICROPY_PY_BUILTINS_SLICE
+        #if MICROPY_PY_BUILTINS_SLICE
         if (mp_obj_is_type(index, &mp_type_slice)) {
             mp_bound_slice_t slice;
             if (!mp_seq_get_fast_slice_indexes(self->len, index, &slice)) {
-                mp_raise_NotImplementedError("only slices with step=1 (aka None) are supported");
+                mp_raise_NotImplementedError(MP_ERROR_TEXT("only slices with step=1 (aka None) are supported"));
             }
             mp_obj_tuple_t *res = MP_OBJ_TO_PTR(mp_obj_new_tuple(slice.stop - slice.start, NULL));
             mp_seq_copy(res->items, self->items + slice.start, res->len, mp_obj_t);
             return MP_OBJ_FROM_PTR(res);
         }
-#endif
+        #endif
         size_t index_value = mp_get_index(self->base.type, self->len, index, false);
         return self->items[index_value];
     } else {
@@ -227,7 +229,7 @@ const mp_obj_type_t mp_type_tuple = {
     .binary_op = mp_obj_tuple_binary_op,
     .subscr = mp_obj_tuple_subscr,
     .getiter = mp_obj_tuple_getiter,
-    .locals_dict = (mp_obj_dict_t*)&tuple_locals_dict,
+    .locals_dict = (mp_obj_dict_t *)&tuple_locals_dict,
 };
 
 // the zero-length tuple
@@ -249,7 +251,7 @@ mp_obj_t mp_obj_new_tuple(size_t n, const mp_obj_t *items) {
 }
 
 void mp_obj_tuple_get(mp_obj_t self_in, size_t *len, mp_obj_t **items) {
-    assert(mp_obj_is_type(self_in, &mp_type_tuple));
+    assert(mp_obj_is_tuple_compatible(self_in));
     mp_obj_tuple_t *self = MP_OBJ_TO_PTR(self_in);
     *len = self->len;
     *items = &self->items[0];
@@ -284,7 +286,7 @@ STATIC mp_obj_t tuple_it_iternext(mp_obj_t self_in) {
 
 mp_obj_t mp_obj_tuple_getiter(mp_obj_t o_in, mp_obj_iter_buf_t *iter_buf) {
     assert(sizeof(mp_obj_tuple_it_t) <= sizeof(mp_obj_iter_buf_t));
-    mp_obj_tuple_it_t *o = (mp_obj_tuple_it_t*)iter_buf;
+    mp_obj_tuple_it_t *o = (mp_obj_tuple_it_t *)iter_buf;
     o->base.type = &mp_type_polymorph_iter;
     o->iternext = tuple_it_iternext;
     o->tuple = MP_OBJ_TO_PTR(o_in);
diff --git a/py/objtuple.h b/py/objtuple.h
index 74cde88d3d39c..cc42aa6df3980 100644
--- a/py/objtuple.h
+++ b/py/objtuple.h
@@ -52,7 +52,7 @@ extern const mp_obj_type_t mp_type_attrtuple;
     const mp_rom_obj_tuple_t tuple_obj_name = { \
         .base = {&mp_type_attrtuple}, \
         .len = nitems, \
-        .items = { __VA_ARGS__ , MP_ROM_PTR((void*)fields) } \
+        .items = { __VA_ARGS__, MP_ROM_PTR((void *)fields) } \
     }
 
 #if MICROPY_PY_COLLECTIONS
diff --git a/py/objtype.c b/py/objtype.c
index 3e65a32f0ce4a..d08c69e284b3e 100644
--- a/py/objtype.c
+++ b/py/objtype.c
@@ -42,10 +42,7 @@
 #endif
 
 #define ENABLE_SPECIAL_ACCESSORS \
-    (MICROPY_PY_DESCRIPTORS  || MICROPY_PY_DELATTR_SETATTR || MICROPY_PY_BUILTINS_PROPERTY)
-
-#define TYPE_FLAG_IS_SUBCLASSED (0x0001)
-#define TYPE_FLAG_HAS_SPECIAL_ACCESSORS (0x0002)
+    (MICROPY_PY_DESCRIPTORS || MICROPY_PY_DELATTR_SETATTR || MICROPY_PY_BUILTINS_PROPERTY)
 
 STATIC mp_obj_t static_class_method_make_new(const mp_obj_type_t *self_in, size_t n_args, size_t n_kw, const mp_obj_t *args);
 
@@ -66,7 +63,7 @@ STATIC int instance_count_native_bases(const mp_obj_type_t *type, const mp_obj_t
             // No parents so end search here.
             return count;
         #if MICROPY_MULTIPLE_INHERITANCE
-        } else if (((mp_obj_base_t*)type->parent)->type == &mp_type_tuple) {
+        } else if (((mp_obj_base_t *)type->parent)->type == &mp_type_tuple) {
             // Multiple parents, search through them all recursively.
             const mp_obj_tuple_t *parent_tuple = type->parent;
             const mp_obj_t *item = parent_tuple->items;
@@ -136,7 +133,7 @@ struct class_lookup_data {
     bool is_type;
 };
 
-STATIC void mp_obj_class_lookup(struct class_lookup_data  *lookup, const mp_obj_type_t *type) {
+STATIC void mp_obj_class_lookup(struct class_lookup_data *lookup, const mp_obj_type_t *type) {
     assert(lookup->dest[0] == MP_OBJ_NULL);
     assert(lookup->dest[1] == MP_OBJ_NULL);
     for (;;) {
@@ -146,7 +143,7 @@ STATIC void mp_obj_class_lookup(struct class_lookup_data  *lookup, const mp_obj_
         // this should not be applied to class types, as will result in extra
         // lookup either.
         if (lookup->meth_offset != 0 && mp_obj_is_native_type(type)) {
-            if (*(void**)((char*)type + lookup->meth_offset) != NULL) {
+            if (*(void **)((char *)type + lookup->meth_offset) != NULL) {
                 DEBUG_printf("mp_obj_class_lookup: Matched special meth slot (off=%d) for %s\n",
                     lookup->meth_offset, qstr_str(lookup->attr));
                 lookup->dest[0] = MP_OBJ_SENTINEL;
@@ -163,7 +160,7 @@ STATIC void mp_obj_class_lookup(struct class_lookup_data  *lookup, const mp_obj_
                 if (lookup->is_type) {
                     // If we look up a class method, we need to return original type for which we
                     // do a lookup, not a (base) type in which we found the class method.
-                    const mp_obj_type_t *org_type = (const mp_obj_type_t*)lookup->obj;
+                    const mp_obj_type_t *org_type = (const mp_obj_type_t *)lookup->obj;
                     mp_convert_member_lookup(MP_OBJ_NULL, org_type, elem->value, lookup->dest);
                 } else {
                     mp_obj_instance_t *obj = lookup->obj;
@@ -176,7 +173,7 @@ STATIC void mp_obj_class_lookup(struct class_lookup_data  *lookup, const mp_obj_
                     }
                     mp_convert_member_lookup(obj_obj, type, elem->value, lookup->dest);
                 }
-#if DEBUG_PRINT
+                #if DEBUG_PRINT
                 DEBUG_printf("mp_obj_class_lookup: Returning: ");
                 mp_obj_print_helper(MICROPY_DEBUG_PRINTER, lookup->dest[0], PRINT_REPR);
                 if (lookup->dest[1] != MP_OBJ_NULL) {
@@ -184,7 +181,7 @@ STATIC void mp_obj_class_lookup(struct class_lookup_data  *lookup, const mp_obj_
                     DEBUG_printf(" <%s @%p>", mp_obj_get_type_str(lookup->dest[1]), MP_OBJ_TO_PTR(lookup->dest[1]));
                 }
                 DEBUG_printf("\n");
-#endif
+                #endif
                 return;
             }
         }
@@ -205,13 +202,13 @@ STATIC void mp_obj_class_lookup(struct class_lookup_data  *lookup, const mp_obj_
             DEBUG_printf("mp_obj_class_lookup: No more parents\n");
             return;
         #if MICROPY_MULTIPLE_INHERITANCE
-        } else if (((mp_obj_base_t*)type->parent)->type == &mp_type_tuple) {
+        } else if (((mp_obj_base_t *)type->parent)->type == &mp_type_tuple) {
             const mp_obj_tuple_t *parent_tuple = type->parent;
             const mp_obj_t *item = parent_tuple->items;
             const mp_obj_t *top = item + parent_tuple->len - 1;
             for (; item < top; ++item) {
                 assert(mp_obj_is_type(*item, &mp_type_type));
-                mp_obj_type_t *bt = (mp_obj_type_t*)MP_OBJ_TO_PTR(*item);
+                mp_obj_type_t *bt = (mp_obj_type_t *)MP_OBJ_TO_PTR(*item);
                 if (bt == &mp_type_object) {
                     // Not a "real" type
                     continue;
@@ -224,7 +221,7 @@ STATIC void mp_obj_class_lookup(struct class_lookup_data  *lookup, const mp_obj_
 
             // search last base (simple tail recursion elimination)
             assert(mp_obj_is_type(*item, &mp_type_type));
-            type = (mp_obj_type_t*)MP_OBJ_TO_PTR(*item);
+            type = (mp_obj_type_t *)MP_OBJ_TO_PTR(*item);
         #endif
         } else {
             type = type->parent;
@@ -351,14 +348,13 @@ mp_obj_t mp_obj_instance_make_new(const mp_obj_type_t *self, size_t n_args, size
             m_del(mp_obj_t, args2, 2 + n_args + 2 * n_kw);
         }
         if (init_ret != mp_const_none) {
-            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                mp_raise_TypeError("__init__() should return None");
-            } else {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                    "__init__() should return None, not '%s'", mp_obj_get_type_str(init_ret)));
-            }
+            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+            mp_raise_TypeError(MP_ERROR_TEXT("__init__() should return None"));
+            #else
+            mp_raise_msg_varg(&mp_type_TypeError,
+                MP_ERROR_TEXT("__init__() should return None, not '%s'"), mp_obj_get_type_str(init_ret));
+            #endif
         }
-
     }
 
     // If the type had a native base that was not explicitly initialised
@@ -460,7 +456,7 @@ STATIC mp_obj_t instance_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
 }
 
 // Binary-op enum values not listed here will have the default value of 0 in the
-// table, corresponding to MP_QSTR_NULL, and are therefore unsupported (a lookup will
+// table, corresponding to MP_QSTRnull, and are therefore unsupported (a lookup will
 // fail).  They can be added at the expense of code size for the qstr.
 // Qstrs for special methods are guaranteed to have a small value, so we use byte
 // type to represent them.
@@ -470,7 +466,7 @@ const byte mp_binary_op_method_name[MP_BINARY_OP_NUM_RUNTIME] = {
     [MP_BINARY_OP_EQUAL] = MP_QSTR___eq__,
     [MP_BINARY_OP_LESS_EQUAL] = MP_QSTR___le__,
     [MP_BINARY_OP_MORE_EQUAL] = MP_QSTR___ge__,
-    // MP_BINARY_OP_NOT_EQUAL, // a != b calls a == b and inverts result
+    [MP_BINARY_OP_NOT_EQUAL] = MP_QSTR___ne__,
     [MP_BINARY_OP_CONTAINS] = MP_QSTR___contains__,
 
     // If an inplace method is not found a normal method will be used as a fallback
@@ -478,6 +474,7 @@ const byte mp_binary_op_method_name[MP_BINARY_OP_NUM_RUNTIME] = {
     [MP_BINARY_OP_INPLACE_SUBTRACT] = MP_QSTR___isub__,
     #if MICROPY_PY_ALL_INPLACE_SPECIAL_METHODS
     [MP_BINARY_OP_INPLACE_MULTIPLY] = MP_QSTR___imul__,
+    [MP_BINARY_OP_INPLACE_MAT_MULTIPLY] = MP_QSTR___imatmul__,
     [MP_BINARY_OP_INPLACE_FLOOR_DIVIDE] = MP_QSTR___ifloordiv__,
     [MP_BINARY_OP_INPLACE_TRUE_DIVIDE] = MP_QSTR___itruediv__,
     [MP_BINARY_OP_INPLACE_MODULO] = MP_QSTR___imod__,
@@ -493,6 +490,7 @@ const byte mp_binary_op_method_name[MP_BINARY_OP_NUM_RUNTIME] = {
     [MP_BINARY_OP_SUBTRACT] = MP_QSTR___sub__,
     #if MICROPY_PY_ALL_SPECIAL_METHODS
     [MP_BINARY_OP_MULTIPLY] = MP_QSTR___mul__,
+    [MP_BINARY_OP_MAT_MULTIPLY] = MP_QSTR___matmul__,
     [MP_BINARY_OP_FLOOR_DIVIDE] = MP_QSTR___floordiv__,
     [MP_BINARY_OP_TRUE_DIVIDE] = MP_QSTR___truediv__,
     [MP_BINARY_OP_MODULO] = MP_QSTR___mod__,
@@ -510,6 +508,7 @@ const byte mp_binary_op_method_name[MP_BINARY_OP_NUM_RUNTIME] = {
     [MP_BINARY_OP_REVERSE_SUBTRACT] = MP_QSTR___rsub__,
     #if MICROPY_PY_ALL_SPECIAL_METHODS
     [MP_BINARY_OP_REVERSE_MULTIPLY] = MP_QSTR___rmul__,
+    [MP_BINARY_OP_REVERSE_MAT_MULTIPLY] = MP_QSTR___rmatmul__,
     [MP_BINARY_OP_REVERSE_FLOOR_DIVIDE] = MP_QSTR___rfloordiv__,
     [MP_BINARY_OP_REVERSE_TRUE_DIVIDE] = MP_QSTR___rtruediv__,
     [MP_BINARY_OP_REVERSE_MODULO] = MP_QSTR___rmod__,
@@ -586,7 +585,7 @@ STATIC void mp_obj_instance_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *des
         dest[0] = elem->value;
         return;
     }
-#if MICROPY_CPYTHON_COMPAT
+    #if MICROPY_CPYTHON_COMPAT
     if (attr == MP_QSTR___dict__) {
         // Create a new dict with a copy of the instance's map items.
         // This creates, unlike CPython, a 'read-only' __dict__: modifying
@@ -601,7 +600,7 @@ STATIC void mp_obj_instance_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *des
         dest[0] = attr_dict;
         return;
     }
-#endif
+    #endif
     struct class_lookup_data lookup = {
         .obj = self,
         .attr = attr,
@@ -612,7 +611,7 @@ STATIC void mp_obj_instance_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *des
     mp_obj_class_lookup(&lookup, self->base.type);
     mp_obj_t member = dest[0];
     if (member != MP_OBJ_NULL) {
-        if (!(self->base.type->flags & TYPE_FLAG_HAS_SPECIAL_ACCESSORS)) {
+        if (!(self->base.type->flags & MP_TYPE_FLAG_HAS_SPECIAL_ACCESSORS)) {
             // Class doesn't have any special accessors to check so return straightaway
             return;
         }
@@ -628,7 +627,7 @@ STATIC void mp_obj_instance_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *des
             // the code.
             const mp_obj_t *proxy = mp_obj_property_get(member);
             if (proxy[0] == mp_const_none) {
-                mp_raise_msg(&mp_type_AttributeError, "unreadable attribute");
+                mp_raise_msg(&mp_type_AttributeError, MP_ERROR_TEXT("unreadable attribute"));
             } else {
                 dest[0] = mp_call_function_n_kw(proxy[0], 1, 0, &self_in);
             }
@@ -677,7 +676,7 @@ STATIC void mp_obj_instance_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *des
 STATIC bool mp_obj_instance_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
     mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
 
-    if (!(self->base.type->flags & TYPE_FLAG_HAS_SPECIAL_ACCESSORS)) {
+    if (!(self->base.type->flags & MP_TYPE_FLAG_HAS_SPECIAL_ACCESSORS)) {
         // Class doesn't have any special accessors so skip their checks
         goto skip_special_accessors;
     }
@@ -864,12 +863,12 @@ mp_obj_t mp_obj_instance_call(mp_obj_t self_in, size_t n_args, size_t n_kw, cons
     mp_obj_t member[2] = {MP_OBJ_NULL, MP_OBJ_NULL};
     mp_obj_t call = mp_obj_instance_get_call(self_in, member);
     if (call == MP_OBJ_NULL) {
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_raise_TypeError("object not callable");
-        } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                "'%s' object isn't callable", mp_obj_get_type_str(self_in)));
-        }
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_raise_TypeError(MP_ERROR_TEXT("object not callable"));
+        #else
+        mp_raise_msg_varg(&mp_type_TypeError,
+            MP_ERROR_TEXT("'%s' object isn't callable"), mp_obj_get_type_str(self_in));
+        #endif
     }
     mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
     if (call == MP_OBJ_SENTINEL) {
@@ -879,7 +878,8 @@ mp_obj_t mp_obj_instance_call(mp_obj_t self_in, size_t n_args, size_t n_kw, cons
     return mp_call_method_self_n_kw(member[0], member[1], n_args, n_kw, args);
 }
 
-STATIC mp_obj_t instance_getiter(mp_obj_t self_in, mp_obj_iter_buf_t *iter_buf) {
+// Note that iter_buf may be NULL, and needs to be allocated if needed
+mp_obj_t mp_obj_instance_getiter(mp_obj_t self_in, mp_obj_iter_buf_t *iter_buf) {
     mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
     mp_obj_t member[2] = {MP_OBJ_NULL};
     struct class_lookup_data lookup = {
@@ -893,7 +893,10 @@ STATIC mp_obj_t instance_getiter(mp_obj_t self_in, mp_obj_iter_buf_t *iter_buf)
     if (member[0] == MP_OBJ_NULL) {
         return MP_OBJ_NULL;
     } else if (member[0] == MP_OBJ_SENTINEL) {
-        mp_obj_type_t *type = mp_obj_get_type(self->subobj[0]);
+        const mp_obj_type_t *type = mp_obj_get_type(self->subobj[0]);
+        if (iter_buf == NULL) {
+            iter_buf = m_new_obj(mp_obj_iter_buf_t);
+        }
         return type->getiter(self->subobj[0], iter_buf);
     } else {
         return mp_call_method_n_kw(0, 0, member);
@@ -912,7 +915,7 @@ STATIC mp_int_t instance_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo,
     };
     mp_obj_class_lookup(&lookup, self->base.type);
     if (member[0] == MP_OBJ_SENTINEL) {
-        mp_obj_type_t *type = mp_obj_get_type(self->subobj[0]);
+        const mp_obj_type_t *type = mp_obj_get_type(self->subobj[0]);
         return type->buffer_p.get_buffer(self->subobj[0], bufinfo, flags);
     } else {
         return 1; // object does not support buffer protocol
@@ -975,7 +978,7 @@ STATIC mp_obj_t type_make_new(const mp_obj_type_t *type_in, size_t n_args, size_
             return mp_obj_new_type(mp_obj_str_get_qstr(args[0]), args[1], args[2]);
 
         default:
-            mp_raise_TypeError("type takes 1 or 3 arguments");
+            mp_raise_TypeError(MP_ERROR_TEXT("type takes 1 or 3 arguments"));
     }
 }
 
@@ -985,12 +988,11 @@ STATIC mp_obj_t type_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp
     mp_obj_type_t *self = MP_OBJ_TO_PTR(self_in);
 
     if (self->make_new == NULL) {
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_raise_TypeError("cannot create instance");
-        } else {
-            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                "cannot create '%q' instances", self->name));
-        }
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_raise_TypeError(MP_ERROR_TEXT("can't create instance"));
+        #else
+        mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("can't create '%q' instances"), self->name);
+        #endif
     }
 
     // make new instance
@@ -1011,9 +1013,24 @@ STATIC void type_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
             dest[0] = MP_OBJ_NEW_QSTR(self->name);
             return;
         }
+        if (attr == MP_QSTR___bases__) {
+            if (self == &mp_type_object) {
+                dest[0] = mp_const_empty_tuple;
+                return;
+            }
+            mp_obj_t parent_obj = self->parent ? MP_OBJ_FROM_PTR(self->parent) : MP_OBJ_FROM_PTR(&mp_type_object);
+            #if MICROPY_MULTIPLE_INHERITANCE
+            if (mp_obj_is_type(parent_obj, &mp_type_tuple)) {
+                dest[0] = parent_obj;
+                return;
+            }
+            #endif
+            dest[0] = mp_obj_new_tuple(1, &parent_obj);
+            return;
+        }
         #endif
         struct class_lookup_data lookup = {
-            .obj = (mp_obj_instance_t*)self,
+            .obj = (mp_obj_instance_t *)self,
             .attr = attr,
             .meth_offset = 0,
             .dest = dest,
@@ -1039,13 +1056,13 @@ STATIC void type_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
             } else {
                 #if ENABLE_SPECIAL_ACCESSORS
                 // Check if we add any special accessor methods with this store
-                if (!(self->flags & TYPE_FLAG_HAS_SPECIAL_ACCESSORS)) {
+                if (!(self->flags & MP_TYPE_FLAG_HAS_SPECIAL_ACCESSORS)) {
                     if (check_for_special_accessors(MP_OBJ_NEW_QSTR(attr), dest[1])) {
-                        if (self->flags & TYPE_FLAG_IS_SUBCLASSED) {
+                        if (self->flags & MP_TYPE_FLAG_IS_SUBCLASSED) {
                             // This class is already subclassed so can't have special accessors added
-                            mp_raise_msg(&mp_type_AttributeError, "can't add special method to already-subclassed class");
+                            mp_raise_msg(&mp_type_AttributeError, MP_ERROR_TEXT("can't add special method to already-subclassed class"));
                         }
-                        self->flags |= TYPE_FLAG_HAS_SPECIAL_ACCESSORS;
+                        self->flags |= MP_TYPE_FLAG_HAS_SPECIAL_ACCESSORS;
                     }
                 }
                 #endif
@@ -1081,7 +1098,8 @@ mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict)
     // TODO might need to make a copy of locals_dict; at least that's how CPython does it
 
     // Basic validation of base classes
-    uint16_t base_flags = 0;
+    uint16_t base_flags = MP_TYPE_FLAG_EQ_NOT_REFLEXIVE
+        | MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE | MP_TYPE_FLAG_EQ_HAS_NEQ_TEST;
     size_t bases_len;
     mp_obj_t *bases_items;
     mp_obj_tuple_get(bases_tuple, &bases_len, &bases_items);
@@ -1092,17 +1110,17 @@ mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict)
         mp_obj_type_t *t = MP_OBJ_TO_PTR(bases_items[i]);
         // TODO: Verify with CPy, tested on function type
         if (t->make_new == NULL) {
-            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                mp_raise_TypeError("type isn't an acceptable base type");
-            } else {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                    "type '%q' isn't an acceptable base type", t->name));
-            }
+            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+            mp_raise_TypeError(MP_ERROR_TEXT("type isn't an acceptable base type"));
+            #else
+            mp_raise_msg_varg(&mp_type_TypeError,
+                MP_ERROR_TEXT("type '%q' isn't an acceptable base type"), t->name);
+            #endif
         }
         #if ENABLE_SPECIAL_ACCESSORS
         if (mp_obj_is_instance_type(t)) {
-            t->flags |= TYPE_FLAG_IS_SUBCLASSED;
-            base_flags |= t->flags & TYPE_FLAG_HAS_SPECIAL_ACCESSORS;
+            t->flags |= MP_TYPE_FLAG_IS_SUBCLASSED;
+            base_flags |= t->flags & MP_TYPE_FLAG_HAS_SPECIAL_ACCESSORS;
         }
         #endif
     }
@@ -1118,8 +1136,8 @@ mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict)
     o->binary_op = instance_binary_op;
     o->attr = mp_obj_instance_attr;
     o->subscr = instance_subscr;
-    o->getiter = instance_getiter;
-    //o->iternext = ; not implemented
+    o->getiter = mp_obj_instance_getiter;
+    // o->iternext = ; not implemented
     o->buffer_p.get_buffer = instance_get_buffer;
 
     if (bases_len > 0) {
@@ -1127,13 +1145,13 @@ mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict)
         // abstract base class which would translate C-level protocol to
         // Python method calls, and any subclass inheriting from it will
         // support this feature.
-        o->protocol = ((mp_obj_type_t*)MP_OBJ_TO_PTR(bases_items[0]))->protocol;
+        o->protocol = ((mp_obj_type_t *)MP_OBJ_TO_PTR(bases_items[0]))->protocol;
 
         if (bases_len >= 2) {
             #if MICROPY_MULTIPLE_INHERITANCE
             o->parent = MP_OBJ_TO_PTR(bases_tuple);
             #else
-            mp_raise_NotImplementedError("multiple inheritance not supported");
+            mp_raise_NotImplementedError(MP_ERROR_TEXT("multiple inheritance not supported"));
             #endif
         } else {
             o->parent = MP_OBJ_TO_PTR(bases_items[0]);
@@ -1144,12 +1162,12 @@ mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict)
 
     #if ENABLE_SPECIAL_ACCESSORS
     // Check if the class has any special accessor methods
-    if (!(o->flags & TYPE_FLAG_HAS_SPECIAL_ACCESSORS)) {
+    if (!(o->flags & MP_TYPE_FLAG_HAS_SPECIAL_ACCESSORS)) {
         for (size_t i = 0; i < o->locals_dict->map.alloc; i++) {
             if (mp_map_slot_is_filled(&o->locals_dict->map, i)) {
                 const mp_map_elem_t *elem = &o->locals_dict->map.table[i];
                 if (check_for_special_accessors(elem->key, elem->value)) {
-                    o->flags |= TYPE_FLAG_HAS_SPECIAL_ACCESSORS;
+                    o->flags |= MP_TYPE_FLAG_HAS_SPECIAL_ACCESSORS;
                     break;
                 }
             }
@@ -1160,7 +1178,7 @@ mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict)
     const mp_obj_type_t *native_base;
     size_t num_native_bases = instance_count_native_bases(o, &native_base);
     if (num_native_bases > 1) {
-        mp_raise_TypeError("multiple bases have instance lay-out conflict");
+        mp_raise_TypeError(MP_ERROR_TEXT("multiple bases have instance lay-out conflict"));
     }
 
     mp_map_t *locals_map = &o->locals_dict->map;
@@ -1204,7 +1222,7 @@ STATIC mp_obj_t super_make_new(const mp_obj_type_t *type_in, size_t n_args, size
         mp_raise_TypeError(NULL);
     }
     mp_obj_super_t *o = m_new_obj(mp_obj_super_t);
-    *o = (mp_obj_super_t){{type_in}, args[0], args[1]};
+    *o = (mp_obj_super_t) {{type_in}, args[0], args[1]};
     return MP_OBJ_FROM_PTR(o);
 }
 
@@ -1237,7 +1255,7 @@ STATIC void super_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     if (type->parent == NULL) {
         // no parents, do nothing
     #if MICROPY_MULTIPLE_INHERITANCE
-    } else if (((mp_obj_base_t*)type->parent)->type == &mp_type_tuple) {
+    } else if (((mp_obj_base_t *)type->parent)->type == &mp_type_tuple) {
         const mp_obj_tuple_t *parent_tuple = type->parent;
         size_t len = parent_tuple->len;
         const mp_obj_t *items = parent_tuple->items;
@@ -1248,7 +1266,7 @@ STATIC void super_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
                 // and we don't want to lookup native methods in object.
                 continue;
             }
-            mp_obj_class_lookup(&lookup, (mp_obj_type_t*)MP_OBJ_TO_PTR(items[i]));
+            mp_obj_class_lookup(&lookup, (mp_obj_type_t *)MP_OBJ_TO_PTR(items[i]));
             if (dest[0] != MP_OBJ_NULL) {
                 break;
             }
@@ -1311,7 +1329,7 @@ bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo) {
             // type has no parents
             return false;
         #if MICROPY_MULTIPLE_INHERITANCE
-        } else if (((mp_obj_base_t*)self->parent)->type == &mp_type_tuple) {
+        } else if (((mp_obj_base_t *)self->parent)->type == &mp_type_tuple) {
             // get the base objects (they should be type objects)
             const mp_obj_tuple_t *parent_tuple = self->parent;
             const mp_obj_t *item = parent_tuple->items;
@@ -1343,7 +1361,7 @@ STATIC mp_obj_t mp_obj_is_subclass(mp_obj_t object, mp_obj_t classinfo) {
     } else if (mp_obj_is_type(classinfo, &mp_type_tuple)) {
         mp_obj_tuple_get(classinfo, &len, &items);
     } else {
-        mp_raise_TypeError("issubclass() arg 2 must be a class or a tuple of classes");
+        mp_raise_TypeError(MP_ERROR_TEXT("issubclass() arg 2 must be a class or a tuple of classes"));
     }
 
     for (size_t i = 0; i < len; i++) {
@@ -1357,7 +1375,7 @@ STATIC mp_obj_t mp_obj_is_subclass(mp_obj_t object, mp_obj_t classinfo) {
 
 STATIC mp_obj_t mp_builtin_issubclass(mp_obj_t object, mp_obj_t classinfo) {
     if (!mp_obj_is_type(object, &mp_type_type)) {
-        mp_raise_TypeError("issubclass() arg 1 must be a class");
+        mp_raise_TypeError(MP_ERROR_TEXT("issubclass() arg 1 must be a class"));
     }
     return mp_obj_is_subclass(object, classinfo);
 }
@@ -1370,13 +1388,17 @@ STATIC mp_obj_t mp_builtin_isinstance(mp_obj_t object, mp_obj_t classinfo) {
 
 MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_isinstance_obj, mp_builtin_isinstance);
 
-mp_obj_t mp_instance_cast_to_native_base(mp_const_obj_t self_in, mp_const_obj_t native_type) {
-    mp_obj_type_t *self_type = mp_obj_get_type(self_in);
-    if (!mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(self_type), native_type)) {
+mp_obj_t mp_obj_cast_to_native_base(mp_obj_t self_in, mp_const_obj_t native_type) {
+    const mp_obj_type_t *self_type = mp_obj_get_type(self_in);
+
+    if (MP_OBJ_FROM_PTR(self_type) == native_type) {
+        return self_in;
+    } else if (!mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(self_type), native_type)) {
         return MP_OBJ_NULL;
+    } else {
+        mp_obj_instance_t *self = (mp_obj_instance_t *)MP_OBJ_TO_PTR(self_in);
+        return self->subobj[0];
     }
-    mp_obj_instance_t *self = (mp_obj_instance_t*)MP_OBJ_TO_PTR(self_in);
-    return self->subobj[0];
 }
 
 /******************************************************************************/
@@ -1388,7 +1410,7 @@ STATIC mp_obj_t static_class_method_make_new(const mp_obj_type_t *self, size_t n
     mp_arg_check_num(n_args, n_kw, 1, 1, false);
 
     mp_obj_static_class_method_t *o = m_new_obj(mp_obj_static_class_method_t);
-    *o = (mp_obj_static_class_method_t){{self}, args[0]};
+    *o = (mp_obj_static_class_method_t) {{self}, args[0]};
     return MP_OBJ_FROM_PTR(o);
 }
 
diff --git a/py/objtype.h b/py/objtype.h
index 3fc8c6e1b0f4b..2c613b904580b 100644
--- a/py/objtype.h
+++ b/py/objtype.h
@@ -51,4 +51,7 @@ mp_obj_t mp_obj_instance_call(mp_obj_t self_in, size_t n_args, size_t n_kw, cons
 // this needs to be exposed for the above macros to work correctly
 mp_obj_t mp_obj_instance_make_new(const mp_obj_type_t *self_in, size_t n_args, size_t n_kw, const mp_obj_t *args);
 
+// this needs to be exposed for mp_getiter
+mp_obj_t mp_obj_instance_getiter(mp_obj_t self_in, mp_obj_iter_buf_t *iter_buf);
+
 #endif // MICROPY_INCLUDED_PY_OBJTYPE_H
diff --git a/py/opmethods.c b/py/opmethods.c
index 247fa5bbc8f8b..595cc088ba933 100644
--- a/py/opmethods.c
+++ b/py/opmethods.c
@@ -28,25 +28,25 @@
 #include "py/builtin.h"
 
 STATIC mp_obj_t op_getitem(mp_obj_t self_in, mp_obj_t key_in) {
-    mp_obj_type_t *type = mp_obj_get_type(self_in);
+    const mp_obj_type_t *type = mp_obj_get_type(self_in);
     return type->subscr(self_in, key_in, MP_OBJ_SENTINEL);
 }
 MP_DEFINE_CONST_FUN_OBJ_2(mp_op_getitem_obj, op_getitem);
 
 STATIC mp_obj_t op_setitem(mp_obj_t self_in, mp_obj_t key_in, mp_obj_t value_in) {
-    mp_obj_type_t *type = mp_obj_get_type(self_in);
+    const mp_obj_type_t *type = mp_obj_get_type(self_in);
     return type->subscr(self_in, key_in, value_in);
 }
 MP_DEFINE_CONST_FUN_OBJ_3(mp_op_setitem_obj, op_setitem);
 
 STATIC mp_obj_t op_delitem(mp_obj_t self_in, mp_obj_t key_in) {
-    mp_obj_type_t *type = mp_obj_get_type(self_in);
+    const mp_obj_type_t *type = mp_obj_get_type(self_in);
     return type->subscr(self_in, key_in, MP_OBJ_NULL);
 }
 MP_DEFINE_CONST_FUN_OBJ_2(mp_op_delitem_obj, op_delitem);
 
 STATIC mp_obj_t op_contains(mp_obj_t lhs_in, mp_obj_t rhs_in) {
-    mp_obj_type_t *type = mp_obj_get_type(lhs_in);
+    const mp_obj_type_t *type = mp_obj_get_type(lhs_in);
     return type->binary_op(MP_BINARY_OP_CONTAINS, lhs_in, rhs_in);
 }
 MP_DEFINE_CONST_FUN_OBJ_2(mp_op_contains_obj, op_contains);
diff --git a/py/pairheap.c b/py/pairheap.c
new file mode 100644
index 0000000000000..d3a011c4ae7f8
--- /dev/null
+++ b/py/pairheap.c
@@ -0,0 +1,147 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/pairheap.h"
+
+// The mp_pairheap_t.next pointer can take one of the following values:
+//   - NULL: the node is the top of the heap
+//   - LSB set: the node is the last of the children and points to its parent node
+//   - other: the node is a child and not the last child
+// The macros below help manage this pointer.
+#define NEXT_MAKE_RIGHTMOST_PARENT(parent) ((void *)((uintptr_t)(parent) | 1))
+#define NEXT_IS_RIGHTMOST_PARENT(next) ((uintptr_t)(next) & 1)
+#define NEXT_GET_RIGHTMOST_PARENT(next) ((void *)((uintptr_t)(next) & ~1))
+
+// O(1), stable
+mp_pairheap_t *mp_pairheap_meld(mp_pairheap_lt_t lt, mp_pairheap_t *heap1, mp_pairheap_t *heap2) {
+    if (heap1 == NULL) {
+        return heap2;
+    }
+    if (heap2 == NULL) {
+        return heap1;
+    }
+    if (lt(heap1, heap2)) {
+        if (heap1->child == NULL) {
+            heap1->child = heap2;
+        } else {
+            heap1->child_last->next = heap2;
+        }
+        heap1->child_last = heap2;
+        heap2->next = NEXT_MAKE_RIGHTMOST_PARENT(heap1);
+        return heap1;
+    } else {
+        heap1->next = heap2->child;
+        heap2->child = heap1;
+        if (heap1->next == NULL) {
+            heap2->child_last = heap1;
+            heap1->next = NEXT_MAKE_RIGHTMOST_PARENT(heap2);
+        }
+        return heap2;
+    }
+}
+
+// amortised O(log N), stable
+mp_pairheap_t *mp_pairheap_pairing(mp_pairheap_lt_t lt, mp_pairheap_t *child) {
+    if (child == NULL) {
+        return NULL;
+    }
+    mp_pairheap_t *heap = NULL;
+    while (!NEXT_IS_RIGHTMOST_PARENT(child)) {
+        mp_pairheap_t *n1 = child;
+        child = child->next;
+        n1->next = NULL;
+        if (!NEXT_IS_RIGHTMOST_PARENT(child)) {
+            mp_pairheap_t *n2 = child;
+            child = child->next;
+            n2->next = NULL;
+            n1 = mp_pairheap_meld(lt, n1, n2);
+        }
+        heap = mp_pairheap_meld(lt, heap, n1);
+    }
+    heap->next = NULL;
+    return heap;
+}
+
+// amortised O(log N), stable
+mp_pairheap_t *mp_pairheap_delete(mp_pairheap_lt_t lt, mp_pairheap_t *heap, mp_pairheap_t *node) {
+    // Simple case of the top being the node to delete
+    if (node == heap) {
+        mp_pairheap_t *child = heap->child;
+        node->child = NULL;
+        return mp_pairheap_pairing(lt, child);
+    }
+
+    // Case where node is not in the heap
+    if (node->next == NULL) {
+        return heap;
+    }
+
+    // Find parent of node
+    mp_pairheap_t *parent = node;
+    while (!NEXT_IS_RIGHTMOST_PARENT(parent->next)) {
+        parent = parent->next;
+    }
+    parent = NEXT_GET_RIGHTMOST_PARENT(parent->next);
+
+    // Replace node with pairing of its children
+    mp_pairheap_t *next;
+    if (node == parent->child && node->child == NULL) {
+        if (NEXT_IS_RIGHTMOST_PARENT(node->next)) {
+            parent->child = NULL;
+        } else {
+            parent->child = node->next;
+        }
+        node->next = NULL;
+        return heap;
+    } else if (node == parent->child) {
+        mp_pairheap_t *child = node->child;
+        next = node->next;
+        node->child = NULL;
+        node->next = NULL;
+        node = mp_pairheap_pairing(lt, child);
+        parent->child = node;
+    } else {
+        mp_pairheap_t *n = parent->child;
+        while (node != n->next) {
+            n = n->next;
+        }
+        mp_pairheap_t *child = node->child;
+        next = node->next;
+        node->child = NULL;
+        node->next = NULL;
+        node = mp_pairheap_pairing(lt, child);
+        if (node == NULL) {
+            node = n;
+        } else {
+            n->next = node;
+        }
+    }
+    node->next = next;
+    if (NEXT_IS_RIGHTMOST_PARENT(next)) {
+        parent->child_last = node;
+    }
+    return heap;
+}
diff --git a/py/pairheap.h b/py/pairheap.h
new file mode 100644
index 0000000000000..68b8b0f758d06
--- /dev/null
+++ b/py/pairheap.h
@@ -0,0 +1,100 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_PY_PAIRHEAP_H
+#define MICROPY_INCLUDED_PY_PAIRHEAP_H
+
+// This is an implementation of a pairing heap.  It is stable and has deletion
+// support.  Only the less-than operation needs to be defined on elements.
+//
+// See original paper for details:
+// Michael L. Fredman, Robert Sedjewick, Daniel D. Sleator, and Robert E. Tarjan.
+// The Pairing Heap: A New Form of Self-Adjusting Heap.
+// Algorithmica 1:111-129, 1986.
+// https://www.cs.cmu.edu/~sleator/papers/pairing-heaps.pdf
+
+#include <assert.h>
+#include "py/obj.h"
+
+// This struct forms the nodes of the heap and is intended to be extended, by
+// placing it first in another struct, to include additional information for the
+// element stored in the heap.  It includes "base" so it can be a MicroPython
+// object allocated on the heap and the GC can automatically trace all nodes by
+// following the tree structure.
+typedef struct _mp_pairheap_t {
+    mp_obj_base_t base;
+    struct _mp_pairheap_t *child;
+    struct _mp_pairheap_t *child_last;
+    struct _mp_pairheap_t *next;
+} mp_pairheap_t;
+
+// This is the function for the less-than operation on nodes/elements.
+typedef int (*mp_pairheap_lt_t)(mp_pairheap_t *, mp_pairheap_t *);
+
+// Core functions.
+mp_pairheap_t *mp_pairheap_meld(mp_pairheap_lt_t lt, mp_pairheap_t *heap1, mp_pairheap_t *heap2);
+mp_pairheap_t *mp_pairheap_pairing(mp_pairheap_lt_t lt, mp_pairheap_t *child);
+mp_pairheap_t *mp_pairheap_delete(mp_pairheap_lt_t lt, mp_pairheap_t *heap, mp_pairheap_t *node);
+
+// Create a new heap.
+static inline mp_pairheap_t *mp_pairheap_new(mp_pairheap_lt_t lt) {
+    (void)lt;
+    return NULL;
+}
+
+// Initialise a single pairing-heap node so it is ready to push on to a heap.
+static inline void mp_pairheap_init_node(mp_pairheap_lt_t lt, mp_pairheap_t *node) {
+    (void)lt;
+    node->child = NULL;
+    node->next = NULL;
+}
+
+// Test if the heap is empty.
+static inline bool mp_pairheap_is_empty(mp_pairheap_lt_t lt, mp_pairheap_t *heap) {
+    (void)lt;
+    return heap == NULL;
+}
+
+// Peek at the top of the heap.  Will return NULL if empty.
+static inline mp_pairheap_t *mp_pairheap_peek(mp_pairheap_lt_t lt, mp_pairheap_t *heap) {
+    (void)lt;
+    return heap;
+}
+
+// Push new node onto existing heap.  Returns the new heap.
+static inline mp_pairheap_t *mp_pairheap_push(mp_pairheap_lt_t lt, mp_pairheap_t *heap, mp_pairheap_t *node) {
+    assert(node->child == NULL && node->next == NULL);
+    return mp_pairheap_meld(lt, node, heap); // node is first to be stable
+}
+
+// Pop the top off the heap, which must not be empty.  Returns the new heap.
+static inline mp_pairheap_t *mp_pairheap_pop(mp_pairheap_lt_t lt, mp_pairheap_t *heap) {
+    assert(heap->next == NULL);
+    mp_pairheap_t *child = heap->child;
+    heap->child = NULL;
+    return mp_pairheap_pairing(lt, child);
+}
+
+#endif // MICROPY_INCLUDED_PY_PAIRHEAP_H
diff --git a/py/parse.c b/py/parse.c
index 66110e7c3d0a0..b93282165f88a 100644
--- a/py/parse.c
+++ b/py/parse.c
@@ -56,7 +56,9 @@
 #define RULE_ARG_OPT_RULE       (0x3000)
 
 // (un)comment to use rule names; for debugging
-//#define USE_RULE_NAME (1)
+// #define USE_RULE_NAME (1)
+
+// *FORMAT-OFF*
 
 enum {
 // define rules with a compile function
@@ -135,8 +137,8 @@ STATIC const uint16_t rule_arg_combined_table[] = {
 #define RULE_EXPAND(x) x
 #define RULE_PADDING(rule, ...) RULE_PADDING2(rule, __VA_ARGS__, RULE_PADDING_IDS(rule))
 #define RULE_PADDING2(rule, ...) RULE_EXPAND(RULE_PADDING3(rule, __VA_ARGS__))
-#define RULE_PADDING3(rule, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, ...) __VA_ARGS__
-#define RULE_PADDING_IDS(r) PAD12_##r, PAD11_##r, PAD10_##r, PAD9_##r, PAD8_##r, PAD7_##r, PAD6_##r, PAD5_##r, PAD4_##r, PAD3_##r, PAD2_##r, PAD1_##r,
+#define RULE_PADDING3(rule, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, ...) __VA_ARGS__
+#define RULE_PADDING_IDS(r) PAD13_##r, PAD12_##r, PAD11_##r, PAD10_##r, PAD9_##r, PAD8_##r, PAD7_##r, PAD6_##r, PAD5_##r, PAD4_##r, PAD3_##r, PAD2_##r, PAD1_##r,
 
 // Use an enum to create constants specifying how much room a rule takes in rule_arg_combined_table
 enum {
@@ -155,8 +157,8 @@ enum {
 // Macro to compute the start of a rule in rule_arg_combined_table
 #define RULE_ARG_OFFSET(rule, ...) RULE_ARG_OFFSET2(rule, __VA_ARGS__, RULE_ARG_OFFSET_IDS(rule))
 #define RULE_ARG_OFFSET2(rule, ...) RULE_EXPAND(RULE_ARG_OFFSET3(rule, __VA_ARGS__))
-#define RULE_ARG_OFFSET3(rule, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, ...) _13
-#define RULE_ARG_OFFSET_IDS(r) PAD12_##r, PAD11_##r, PAD10_##r, PAD9_##r, PAD8_##r, PAD7_##r, PAD6_##r, PAD5_##r, PAD4_##r, PAD3_##r, PAD2_##r, PAD1_##r, PAD0_##r,
+#define RULE_ARG_OFFSET3(rule, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, ...) _14
+#define RULE_ARG_OFFSET_IDS(r) PAD13_##r, PAD12_##r, PAD11_##r, PAD10_##r, PAD9_##r, PAD8_##r, PAD7_##r, PAD6_##r, PAD5_##r, PAD4_##r, PAD3_##r, PAD2_##r, PAD1_##r, PAD0_##r,
 
 // Use the above enum values to create a table of offsets for each rule's arg
 // data, which indexes rule_arg_combined_table.  The offsets require 9 bits of
@@ -207,8 +209,10 @@ STATIC const char *const rule_name_table[] = {
 };
 #endif
 
+// *FORMAT-ON*
+
 typedef struct _rule_stack_t {
-    size_t src_line : 8 * sizeof(size_t) - 8; // maximum bits storing source line number
+    size_t src_line : (8 * sizeof(size_t) - 8); // maximum bits storing source line number
     size_t rule_id : 8; // this must be large enough to fit largest rule number
     size_t arg_i; // this dictates the maximum nodes in a "list" of things
 } rule_stack_t;
@@ -256,7 +260,7 @@ STATIC void *parser_alloc(parser_t *parser, size_t num_bytes) {
 
     if (chunk != NULL && chunk->union_.used + num_bytes > chunk->alloc) {
         // not enough room at end of previously allocated chunk so try to grow
-        mp_parse_chunk_t *new_data = (mp_parse_chunk_t*)m_renew_maybe(byte, chunk,
+        mp_parse_chunk_t *new_data = (mp_parse_chunk_t *)m_renew_maybe(byte, chunk,
             sizeof(mp_parse_chunk_t) + chunk->alloc,
             sizeof(mp_parse_chunk_t) + chunk->alloc + num_bytes, false);
         if (new_data == NULL) {
@@ -279,7 +283,7 @@ STATIC void *parser_alloc(parser_t *parser, size_t num_bytes) {
         if (alloc < num_bytes) {
             alloc = num_bytes;
         }
-        chunk = (mp_parse_chunk_t*)m_new(byte, sizeof(mp_parse_chunk_t) + alloc);
+        chunk = (mp_parse_chunk_t *)m_new(byte, sizeof(mp_parse_chunk_t) + alloc);
         chunk->alloc = alloc;
         chunk->union_.used = 0;
         parser->cur_chunk = chunk;
@@ -318,12 +322,12 @@ STATIC uint8_t pop_rule(parser_t *parser, size_t *arg_i, size_t *src_line) {
 
 bool mp_parse_node_is_const_false(mp_parse_node_t pn) {
     return MP_PARSE_NODE_IS_TOKEN_KIND(pn, MP_TOKEN_KW_FALSE)
-        || (MP_PARSE_NODE_IS_SMALL_INT(pn) && MP_PARSE_NODE_LEAF_SMALL_INT(pn) == 0);
+           || (MP_PARSE_NODE_IS_SMALL_INT(pn) && MP_PARSE_NODE_LEAF_SMALL_INT(pn) == 0);
 }
 
 bool mp_parse_node_is_const_true(mp_parse_node_t pn) {
     return MP_PARSE_NODE_IS_TOKEN_KIND(pn, MP_TOKEN_KW_TRUE)
-        || (MP_PARSE_NODE_IS_SMALL_INT(pn) && MP_PARSE_NODE_LEAF_SMALL_INT(pn) != 0);
+           || (MP_PARSE_NODE_IS_SMALL_INT(pn) && MP_PARSE_NODE_LEAF_SMALL_INT(pn) != 0);
 }
 
 bool mp_parse_node_get_int_maybe(mp_parse_node_t pn, mp_obj_t *o) {
@@ -331,7 +335,7 @@ bool mp_parse_node_get_int_maybe(mp_parse_node_t pn, mp_obj_t *o) {
         *o = MP_OBJ_NEW_SMALL_INT(MP_PARSE_NODE_LEAF_SMALL_INT(pn));
         return true;
     } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, RULE_const_object)) {
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
         #if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D
         // nodes are 32-bit pointers, but need to extract 64-bit object
         *o = (uint64_t)pns->nodes[0] | ((uint64_t)pns->nodes[1] << 32);
@@ -344,7 +348,7 @@ bool mp_parse_node_get_int_maybe(mp_parse_node_t pn, mp_obj_t *o) {
     }
 }
 
-int mp_parse_node_extract_list(mp_parse_node_t *pn, size_t pn_kind, mp_parse_node_t **nodes) {
+size_t mp_parse_node_extract_list(mp_parse_node_t *pn, size_t pn_kind, mp_parse_node_t **nodes) {
     if (MP_PARSE_NODE_IS_NULL(*pn)) {
         *nodes = NULL;
         return 0;
@@ -352,7 +356,7 @@ int mp_parse_node_extract_list(mp_parse_node_t *pn, size_t pn_kind, mp_parse_nod
         *nodes = pn;
         return 1;
     } else {
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)(*pn);
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)(*pn);
         if (MP_PARSE_NODE_STRUCT_KIND(pns) != pn_kind) {
             *nodes = pn;
             return 1;
@@ -366,7 +370,7 @@ int mp_parse_node_extract_list(mp_parse_node_t *pn, size_t pn_kind, mp_parse_nod
 #if MICROPY_DEBUG_PRINTERS
 void mp_parse_node_print(mp_parse_node_t pn, size_t indent) {
     if (MP_PARSE_NODE_IS_STRUCT(pn)) {
-        printf("[% 4d] ", (int)((mp_parse_node_struct_t*)pn)->source_line);
+        printf("[% 4d] ", (int)((mp_parse_node_struct_t *)pn)->source_line);
     } else {
         printf("       ");
     }
@@ -381,16 +385,23 @@ void mp_parse_node_print(mp_parse_node_t pn, size_t indent) {
     } else if (MP_PARSE_NODE_IS_LEAF(pn)) {
         uintptr_t arg = MP_PARSE_NODE_LEAF_ARG(pn);
         switch (MP_PARSE_NODE_LEAF_KIND(pn)) {
-            case MP_PARSE_NODE_ID: printf("id(%s)\n", qstr_str(arg)); break;
-            case MP_PARSE_NODE_STRING: printf("str(%s)\n", qstr_str(arg)); break;
-            case MP_PARSE_NODE_BYTES: printf("bytes(%s)\n", qstr_str(arg)); break;
+            case MP_PARSE_NODE_ID:
+                printf("id(%s)\n", qstr_str(arg));
+                break;
+            case MP_PARSE_NODE_STRING:
+                printf("str(%s)\n", qstr_str(arg));
+                break;
+            case MP_PARSE_NODE_BYTES:
+                printf("bytes(%s)\n", qstr_str(arg));
+                break;
             default:
                 assert(MP_PARSE_NODE_LEAF_KIND(pn) == MP_PARSE_NODE_TOKEN);
-                printf("tok(%u)\n", (uint)arg); break;
+                printf("tok(%u)\n", (uint)arg);
+                break;
         }
     } else {
         // node must be a mp_parse_node_struct_t
-        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
         if (MP_PARSE_NODE_STRUCT_KIND(pns) == RULE_const_object) {
             #if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D
             printf("literal const(%016llx)\n", (uint64_t)pns->nodes[0] | ((uint64_t)pns->nodes[1] << 32));
@@ -502,7 +513,7 @@ STATIC void push_result_token(parser_t *parser, uint8_t rule_id) {
     } else if (lex->tok_kind == MP_TOKEN_STRING || lex->tok_kind == MP_TOKEN_BYTES) {
         // Don't automatically intern all strings/bytes.  doc strings (which are usually large)
         // will be discarded by the compiler, and so we shouldn't intern them.
-        qstr qst = MP_QSTR_NULL;
+        qstr qst = MP_QSTRnull;
         if (lex->vstr.len <= MICROPY_ALLOC_PARSE_INTERN_STRING_LEN) {
             // intern short strings
             qst = qstr_from_strn(lex->vstr.buf, lex->vstr.len);
@@ -510,14 +521,14 @@ STATIC void push_result_token(parser_t *parser, uint8_t rule_id) {
             // check if this string is already interned
             qst = qstr_find_strn(lex->vstr.buf, lex->vstr.len);
         }
-        if (qst != MP_QSTR_NULL) {
+        if (qst != MP_QSTRnull) {
             // qstr exists, make a leaf node
             pn = mp_parse_node_new_leaf(lex->tok_kind == MP_TOKEN_STRING ? MP_PARSE_NODE_STRING : MP_PARSE_NODE_BYTES, qst);
         } else {
             // not interned, make a node holding a pointer to the string/bytes object
             mp_obj_t o = mp_obj_new_str_copy(
                 lex->tok_kind == MP_TOKEN_STRING ? &mp_type_str : &mp_type_bytes,
-                (const byte*)lex->vstr.buf, lex->vstr.len);
+                (const byte *)lex->vstr.buf, lex->vstr.len);
             pn = make_node_const_object(parser, lex->tok_line, o);
         }
     } else {
@@ -607,8 +618,9 @@ STATIC bool fold_constants(parser_t *parser, uint8_t rule_id, size_t num_args) {
     mp_obj_t arg0;
     if (rule_id == RULE_expr
         || rule_id == RULE_xor_expr
-        || rule_id == RULE_and_expr) {
-        // folding for binary ops: | ^ &
+        || rule_id == RULE_and_expr
+        || rule_id == RULE_power) {
+        // folding for binary ops: | ^ & **
         mp_parse_node_t pn = peek_result(parser, num_args - 1);
         if (!mp_parse_node_get_int_maybe(pn, &arg0)) {
             return false;
@@ -618,8 +630,10 @@ STATIC bool fold_constants(parser_t *parser, uint8_t rule_id, size_t num_args) {
             op = MP_BINARY_OP_OR;
         } else if (rule_id == RULE_xor_expr) {
             op = MP_BINARY_OP_XOR;
-        } else {
+        } else if (rule_id == RULE_and_expr) {
             op = MP_BINARY_OP_AND;
+        } else {
+            op = MP_BINARY_OP_POWER;
         }
         for (ssize_t i = num_args - 2; i >= 0; --i) {
             pn = peek_result(parser, i);
@@ -627,12 +641,16 @@ STATIC bool fold_constants(parser_t *parser, uint8_t rule_id, size_t num_args) {
             if (!mp_parse_node_get_int_maybe(pn, &arg1)) {
                 return false;
             }
+            if (op == MP_BINARY_OP_POWER && mp_obj_int_sign(arg1) < 0) {
+                // ** can't have negative rhs
+                return false;
+            }
             arg0 = mp_binary_op(op, arg0, arg1);
         }
     } else if (rule_id == RULE_shift_expr
-        || rule_id == RULE_arith_expr
-        || rule_id == RULE_term) {
-        // folding for binary ops: << >> + - * / % //
+               || rule_id == RULE_arith_expr
+               || rule_id == RULE_term) {
+        // folding for binary ops: << >> + - * @ / % //
         mp_parse_node_t pn = peek_result(parser, num_args - 1);
         if (!mp_parse_node_get_int_maybe(pn, &arg0)) {
             return false;
@@ -644,23 +662,11 @@ STATIC bool fold_constants(parser_t *parser, uint8_t rule_id, size_t num_args) {
                 return false;
             }
             mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(peek_result(parser, i));
-            static const uint8_t token_to_op[] = {
-                MP_BINARY_OP_ADD,
-                MP_BINARY_OP_SUBTRACT,
-                MP_BINARY_OP_MULTIPLY,
-                255,//MP_BINARY_OP_POWER,
-                255,//MP_BINARY_OP_TRUE_DIVIDE,
-                MP_BINARY_OP_FLOOR_DIVIDE,
-                MP_BINARY_OP_MODULO,
-                255,//MP_BINARY_OP_LESS
-                MP_BINARY_OP_LSHIFT,
-                255,//MP_BINARY_OP_MORE
-                MP_BINARY_OP_RSHIFT,
-            };
-            mp_binary_op_t op = token_to_op[tok - MP_TOKEN_OP_PLUS];
-            if (op == (mp_binary_op_t)255) {
+            if (tok == MP_TOKEN_OP_AT || tok == MP_TOKEN_OP_SLASH) {
+                // Can't fold @ or /
                 return false;
             }
+            mp_binary_op_t op = MP_BINARY_OP_LSHIFT + (tok - MP_TOKEN_OP_DBL_LESS);
             int rhs_sign = mp_obj_int_sign(arg1);
             if (op <= MP_BINARY_OP_RSHIFT) {
                 // << and >> can't have negative rhs
@@ -683,13 +689,11 @@ STATIC bool fold_constants(parser_t *parser, uint8_t rule_id, size_t num_args) {
         }
         mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(peek_result(parser, 1));
         mp_unary_op_t op;
-        if (tok == MP_TOKEN_OP_PLUS) {
-            op = MP_UNARY_OP_POSITIVE;
-        } else if (tok == MP_TOKEN_OP_MINUS) {
-            op = MP_UNARY_OP_NEGATIVE;
-        } else {
-            assert(tok == MP_TOKEN_OP_TILDE); // should be
+        if (tok == MP_TOKEN_OP_TILDE) {
             op = MP_UNARY_OP_INVERT;
+        } else {
+            assert(tok == MP_TOKEN_OP_PLUS || tok == MP_TOKEN_OP_MINUS); // should be
+            op = MP_UNARY_OP_POSITIVE + (tok - MP_TOKEN_OP_PLUS);
         }
         arg0 = mp_unary_op(op, arg0);
 
@@ -698,14 +702,14 @@ STATIC bool fold_constants(parser_t *parser, uint8_t rule_id, size_t num_args) {
         mp_parse_node_t pn1 = peek_result(parser, 0);
         if (!MP_PARSE_NODE_IS_NULL(pn1)
             && !(MP_PARSE_NODE_IS_STRUCT_KIND(pn1, RULE_expr_stmt_augassign)
-            || MP_PARSE_NODE_IS_STRUCT_KIND(pn1, RULE_expr_stmt_assign_list))) {
+                 || MP_PARSE_NODE_IS_STRUCT_KIND(pn1, RULE_expr_stmt_assign_list))) {
             // this node is of the form <x> = <y>
             mp_parse_node_t pn0 = peek_result(parser, 1);
             if (MP_PARSE_NODE_IS_ID(pn0)
                 && MP_PARSE_NODE_IS_STRUCT_KIND(pn1, RULE_atom_expr_normal)
-                && MP_PARSE_NODE_IS_ID(((mp_parse_node_struct_t*)pn1)->nodes[0])
-                && MP_PARSE_NODE_LEAF_ARG(((mp_parse_node_struct_t*)pn1)->nodes[0]) == MP_QSTR_const
-                && MP_PARSE_NODE_IS_STRUCT_KIND(((mp_parse_node_struct_t*)pn1)->nodes[1], RULE_trailer_paren)
+                && MP_PARSE_NODE_IS_ID(((mp_parse_node_struct_t *)pn1)->nodes[0])
+                && MP_PARSE_NODE_LEAF_ARG(((mp_parse_node_struct_t *)pn1)->nodes[0]) == MP_QSTR_const
+                && MP_PARSE_NODE_IS_STRUCT_KIND(((mp_parse_node_struct_t *)pn1)->nodes[1], RULE_trailer_paren)
                 ) {
                 // code to assign dynamic constants: id = const(value)
 
@@ -713,13 +717,13 @@ STATIC bool fold_constants(parser_t *parser, uint8_t rule_id, size_t num_args) {
                 qstr id = MP_PARSE_NODE_LEAF_ARG(pn0);
 
                 // get the value
-                mp_parse_node_t pn_value = ((mp_parse_node_struct_t*)((mp_parse_node_struct_t*)pn1)->nodes[1])->nodes[0];
+                mp_parse_node_t pn_value = ((mp_parse_node_struct_t *)((mp_parse_node_struct_t *)pn1)->nodes[1])->nodes[0];
                 mp_obj_t value;
                 if (!mp_parse_node_get_int_maybe(pn_value, &value)) {
                     mp_obj_t exc = mp_obj_new_exception_msg(&mp_type_SyntaxError,
-                        "constant must be an integer");
+                        MP_ERROR_TEXT("constant must be an integer"));
                     mp_obj_exception_add_traceback(exc, parser->lexer->source_name,
-                        ((mp_parse_node_struct_t*)pn1)->source_line, MP_QSTR_NULL);
+                        ((mp_parse_node_struct_t *)pn1)->source_line, MP_QSTRnull);
                     nlr_raise(exc);
                 }
 
@@ -753,16 +757,16 @@ STATIC bool fold_constants(parser_t *parser, uint8_t rule_id, size_t num_args) {
         mp_parse_node_t pn0 = peek_result(parser, 1);
         mp_parse_node_t pn1 = peek_result(parser, 0);
         if (!(MP_PARSE_NODE_IS_ID(pn0)
-            && MP_PARSE_NODE_IS_STRUCT_KIND(pn1, RULE_trailer_period))) {
+              && MP_PARSE_NODE_IS_STRUCT_KIND(pn1, RULE_trailer_period))) {
             return false;
         }
         // id1.id2
         // look it up in constant table, see if it can be replaced with an integer
-        mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pn1;
+        mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t *)pn1;
         assert(MP_PARSE_NODE_IS_ID(pns1->nodes[0]));
         qstr q_base = MP_PARSE_NODE_LEAF_ARG(pn0);
         qstr q_attr = MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]);
-        mp_map_elem_t *elem = mp_map_lookup((mp_map_t*)&mp_constants_map, MP_OBJ_NEW_QSTR(q_base), MP_MAP_LOOKUP);
+        mp_map_elem_t *elem = mp_map_lookup((mp_map_t *)&mp_constants_map, MP_OBJ_NEW_QSTR(q_base), MP_MAP_LOOKUP);
         if (elem == NULL) {
             return false;
         }
@@ -855,9 +859,14 @@ mp_parse_tree_t mp_parse(mp_lexer_t *lex, mp_parse_input_kind_t input_kind) {
     // work out the top-level rule to use, and push it on the stack
     size_t top_level_rule;
     switch (input_kind) {
-        case MP_PARSE_SINGLE_INPUT: top_level_rule = RULE_single_input; break;
-        case MP_PARSE_EVAL_INPUT: top_level_rule = RULE_eval_input; break;
-        default: top_level_rule = RULE_file_input;
+        case MP_PARSE_SINGLE_INPUT:
+            top_level_rule = RULE_single_input;
+            break;
+        case MP_PARSE_EVAL_INPUT:
+            top_level_rule = RULE_eval_input;
+            break;
+        default:
+            top_level_rule = RULE_file_input;
     }
     push_rule(&parser, lex->tok_line, top_level_rule, 0);
 
@@ -866,7 +875,7 @@ mp_parse_tree_t mp_parse(mp_lexer_t *lex, mp_parse_input_kind_t input_kind) {
     bool backtrack = false;
 
     for (;;) {
-        next_rule:
+    next_rule:
         if (parser.rule_stack_top == 0) {
             break;
         }
@@ -1038,7 +1047,7 @@ mp_parse_tree_t mp_parse(mp_lexer_t *lex, mp_parse_input_kind_t input_kind) {
                 // n=3 is: item (sep item)* [sep]
                 bool had_trailing_sep;
                 if (backtrack) {
-                    list_backtrack:
+                list_backtrack:
                     had_trailing_sep = false;
                     if (n == 2) {
                         if (i == 1) {
@@ -1142,17 +1151,17 @@ mp_parse_tree_t mp_parse(mp_lexer_t *lex, mp_parse_input_kind_t input_kind) {
         mp_obj_t exc;
         if (lex->tok_kind == MP_TOKEN_INDENT) {
             exc = mp_obj_new_exception_msg(&mp_type_IndentationError,
-                "unexpected indent");
+                MP_ERROR_TEXT("unexpected indent"));
         } else if (lex->tok_kind == MP_TOKEN_DEDENT_MISMATCH) {
             exc = mp_obj_new_exception_msg(&mp_type_IndentationError,
-                "unindent doesn't match any outer indent level");
+                MP_ERROR_TEXT("unindent doesn't match any outer indent level"));
         } else {
             exc = mp_obj_new_exception_msg(&mp_type_SyntaxError,
-                "invalid syntax");
+                MP_ERROR_TEXT("invalid syntax"));
         }
         // add traceback to give info about file name and location
         // we don't have a 'block' name, so just pass the NULL qstr to indicate this
-        mp_obj_exception_add_traceback(exc, lex->source_name, lex->tok_line, MP_QSTR_NULL);
+        mp_obj_exception_add_traceback(exc, lex->source_name, lex->tok_line, MP_QSTRnull);
         nlr_raise(exc);
     }
 
diff --git a/py/parse.h b/py/parse.h
index 9a1a2b4dd433d..4ed8a7ad12324 100644
--- a/py/parse.h
+++ b/py/parse.h
@@ -63,7 +63,7 @@ typedef struct _mp_parse_node_struct_t {
 #define MP_PARSE_NODE_IS_NULL(pn) ((pn) == MP_PARSE_NODE_NULL)
 #define MP_PARSE_NODE_IS_LEAF(pn) ((pn) & 3)
 #define MP_PARSE_NODE_IS_STRUCT(pn) ((pn) != MP_PARSE_NODE_NULL && ((pn) & 3) == 0)
-#define MP_PARSE_NODE_IS_STRUCT_KIND(pn, k) ((pn) != MP_PARSE_NODE_NULL && ((pn) & 3) == 0 && MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t*)(pn)) == (k))
+#define MP_PARSE_NODE_IS_STRUCT_KIND(pn, k) ((pn) != MP_PARSE_NODE_NULL && ((pn) & 3) == 0 && MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t *)(pn)) == (k))
 
 #define MP_PARSE_NODE_IS_SMALL_INT(pn) (((pn) & 0x1) == MP_PARSE_NODE_SMALL_INT)
 #define MP_PARSE_NODE_IS_ID(pn) (((pn) & 0x0f) == MP_PARSE_NODE_ID)
@@ -85,7 +85,7 @@ static inline mp_parse_node_t mp_parse_node_new_leaf(size_t kind, mp_int_t arg)
 bool mp_parse_node_is_const_false(mp_parse_node_t pn);
 bool mp_parse_node_is_const_true(mp_parse_node_t pn);
 bool mp_parse_node_get_int_maybe(mp_parse_node_t pn, mp_obj_t *o);
-int mp_parse_node_extract_list(mp_parse_node_t *pn, size_t pn_kind, mp_parse_node_t **nodes);
+size_t mp_parse_node_extract_list(mp_parse_node_t *pn, size_t pn_kind, mp_parse_node_t **nodes);
 void mp_parse_node_print(mp_parse_node_t pn, size_t indent);
 
 typedef enum {
diff --git a/py/parsenum.c b/py/parsenum.c
index ae9b834192ad2..e665da7d8cdad 100644
--- a/py/parsenum.c
+++ b/py/parsenum.c
@@ -40,8 +40,8 @@ STATIC NORETURN void raise_exc(mp_obj_t exc, mp_lexer_t *lex) {
     // if lex!=NULL then the parser called us and we need to convert the
     // exception's type from ValueError to SyntaxError and add traceback info
     if (lex != NULL) {
-        ((mp_obj_base_t*)MP_OBJ_TO_PTR(exc))->type = &mp_type_SyntaxError;
-        mp_obj_exception_add_traceback(exc, lex->source_name, lex->tok_line, MP_QSTR_NULL);
+        ((mp_obj_base_t *)MP_OBJ_TO_PTR(exc))->type = &mp_type_SyntaxError;
+        mp_obj_exception_add_traceback(exc, lex->source_name, lex->tok_line, MP_QSTRnull);
     }
     nlr_raise(exc);
 }
@@ -55,7 +55,7 @@ mp_obj_t mp_parse_num_integer(const char *restrict str_, size_t len, int base, m
     // check radix base
     if ((base != 0 && base < 2) || base > 36) {
         // this won't be reached if lex!=NULL
-        mp_raise_ValueError("int() arg 2 must be >= 2 and <= 36");
+        mp_raise_ValueError(MP_ERROR_TEXT("int() arg 2 must be >= 2 and <= 36"));
     }
 
     // skip leading space
@@ -73,7 +73,7 @@ mp_obj_t mp_parse_num_integer(const char *restrict str_, size_t len, int base, m
     }
 
     // parse optional base prefix
-    str += mp_parse_num_base((const char*)str, top - str, &base);
+    str += mp_parse_num_base((const char *)str, top - str, &base);
 
     // string should be an integer number
     mp_int_t int_val = 0;
@@ -137,22 +137,23 @@ mp_obj_t mp_parse_num_integer(const char *restrict str_, size_t len, int base, m
 overflow:
     // reparse using long int
     {
-        const char *s2 = (const char*)str_val_start;
+        const char *s2 = (const char *)str_val_start;
         ret_val = mp_obj_new_int_from_str_len(&s2, top - str_val_start, neg, base);
-        str = (const byte*)s2;
+        str = (const byte *)s2;
         goto have_ret_val;
     }
 
 value_error:
-    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
+    {
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
         mp_obj_t exc = mp_obj_new_exception_msg(&mp_type_ValueError,
-            "invalid syntax for integer");
+            MP_ERROR_TEXT("invalid syntax for integer"));
         raise_exc(exc, lex);
-    } else if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL) {
+        #elif MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL
         mp_obj_t exc = mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-            "invalid syntax for integer with base %d", base);
+            MP_ERROR_TEXT("invalid syntax for integer with base %d"), base);
         raise_exc(exc, lex);
-    } else {
+        #else
         vstr_t vstr;
         mp_print_t print;
         vstr_init_print(&vstr, 50, &print);
@@ -161,6 +162,7 @@ mp_obj_t mp_parse_num_integer(const char *restrict str_, size_t len, int base, m
         mp_obj_t exc = mp_obj_new_exception_arg1(&mp_type_ValueError,
             mp_obj_new_str_from_vstr(&mp_type_str, &vstr));
         raise_exc(exc, lex);
+        #endif
     }
 }
 
@@ -171,7 +173,7 @@ typedef enum {
 } parse_dec_in_t;
 
 mp_obj_t mp_parse_num_decimal(const char *str, size_t len, bool allow_imag, bool force_complex, mp_lexer_t *lex) {
-#if MICROPY_PY_BUILTINS_FLOAT
+    #if MICROPY_PY_BUILTINS_FLOAT
 
 // DEC_VAL_MAX only needs to be rough and is used to retain precision while not overflowing
 // SMALL_NORMAL_VAL is the smallest power of 10 that is still a normal float
@@ -179,17 +181,17 @@ mp_obj_t mp_parse_num_decimal(const char *str, size_t len, bool allow_imag, bool
 //   Note: EXACT_POWER_OF_10 is at least floor(log_5(2^mantissa_length)). Indeed, 10^n = 2^n * 5^n
 //   so we only have to store the 5^n part in the mantissa (the 2^n part will go into the float's
 //   exponent).
-#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
+    #if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
 #define DEC_VAL_MAX 1e20F
 #define SMALL_NORMAL_VAL (1e-37F)
 #define SMALL_NORMAL_EXP (-37)
 #define EXACT_POWER_OF_10 (9)
-#elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
+    #elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
 #define DEC_VAL_MAX 1e200
 #define SMALL_NORMAL_VAL (1e-307)
 #define SMALL_NORMAL_EXP (-307)
 #define EXACT_POWER_OF_10 (22)
-#endif
+    #endif
 
     const char *top = str + len;
     mp_float_t dec_val = 0;
@@ -218,7 +220,7 @@ mp_obj_t mp_parse_num_decimal(const char *str, size_t len, bool allow_imag, bool
         if (str + 2 < top && (str[1] | 0x20) == 'n' && (str[2] | 0x20) == 'f') {
             // inf
             str += 3;
-            dec_val = INFINITY;
+            dec_val = (mp_float_t)INFINITY;
             if (str + 4 < top && (str[0] | 0x20) == 'i' && (str[1] | 0x20) == 'n' && (str[2] | 0x20) == 'i' && (str[3] | 0x20) == 't' && (str[4] | 0x20) == 'y') {
                 // infinity
                 str += 5;
@@ -334,25 +336,25 @@ mp_obj_t mp_parse_num_decimal(const char *str, size_t len, bool allow_imag, bool
     }
 
     // return the object
-#if MICROPY_PY_BUILTINS_COMPLEX
+    #if MICROPY_PY_BUILTINS_COMPLEX
     if (imag) {
         return mp_obj_new_complex(0, dec_val);
     } else if (force_complex) {
         return mp_obj_new_complex(dec_val, 0);
     }
-#else
+    #else
     if (imag || force_complex) {
-        raise_exc(mp_obj_new_exception_msg(&mp_type_ValueError, "complex values not supported"), lex);
+        raise_exc(mp_obj_new_exception_msg(&mp_type_ValueError, MP_ERROR_TEXT("complex values not supported")), lex);
     }
-#endif
+    #endif
     else {
         return mp_obj_new_float(dec_val);
     }
 
 value_error:
-    raise_exc(mp_obj_new_exception_msg(&mp_type_ValueError, "invalid syntax for number"), lex);
+    raise_exc(mp_obj_new_exception_msg(&mp_type_ValueError, MP_ERROR_TEXT("invalid syntax for number")), lex);
 
-#else
-    raise_exc(mp_obj_new_exception_msg(&mp_type_ValueError, "decimal numbers not supported"), lex);
-#endif
+    #else
+    raise_exc(mp_obj_new_exception_msg(&mp_type_ValueError, MP_ERROR_TEXT("decimal numbers not supported")), lex);
+    #endif
 }
diff --git a/py/parsenumbase.c b/py/parsenumbase.c
index ba10591226f23..94523a666d325 100644
--- a/py/parsenumbase.c
+++ b/py/parsenumbase.c
@@ -31,7 +31,7 @@
 // find real radix base, and strip preceding '0x', '0o' and '0b'
 // puts base in *base, and returns number of bytes to skip the prefix
 size_t mp_parse_num_base(const char *str, size_t len, int *base) {
-    const byte *p = (const byte*)str;
+    const byte *p = (const byte *)str;
     if (len <= 1) {
         goto no_prefix;
     }
@@ -67,5 +67,5 @@ size_t mp_parse_num_base(const char *str, size_t len, int *base) {
             *base = 10;
         }
     }
-    return p - (const byte*)str;
+    return p - (const byte *)str;
 }
diff --git a/py/persistentcode.c b/py/persistentcode.c
index 70ec2ddd6553d..386ea49477f6b 100644
--- a/py/persistentcode.c
+++ b/py/persistentcode.c
@@ -30,9 +30,11 @@
 #include <assert.h>
 
 #include "py/reader.h"
-#include "py/emitglue.h"
+#include "py/nativeglue.h"
 #include "py/persistentcode.h"
-#include "py/bc.h"
+#include "py/bc0.h"
+#include "py/objstr.h"
+#include "py/mpthread.h"
 
 #if MICROPY_PERSISTENT_CODE_LOAD || MICROPY_PERSISTENT_CODE_SAVE
 
@@ -40,44 +42,6 @@
 
 #define QSTR_LAST_STATIC MP_QSTR_zip
 
-// The current version of .mpy files
-#define MPY_VERSION (4)
-
-// Macros to encode/decode flags to/from the feature byte
-#define MPY_FEATURE_ENCODE_FLAGS(flags) (flags)
-#define MPY_FEATURE_DECODE_FLAGS(feat) ((feat) & 3)
-
-// Macros to encode/decode native architecture to/from the feature byte
-#define MPY_FEATURE_ENCODE_ARCH(arch) ((arch) << 2)
-#define MPY_FEATURE_DECODE_ARCH(feat) ((feat) >> 2)
-
-// The feature flag bits encode the compile-time config options that
-// affect the generate bytecode.
-#define MPY_FEATURE_FLAGS ( \
-    ((MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE) << 0) \
-    | ((MICROPY_PY_BUILTINS_STR_UNICODE) << 1) \
-    )
-// This is a version of the flags that can be configured at runtime.
-#define MPY_FEATURE_FLAGS_DYNAMIC ( \
-    ((MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE_DYNAMIC) << 0) \
-    | ((MICROPY_PY_BUILTINS_STR_UNICODE_DYNAMIC) << 1) \
-    )
-
-// Define the host architecture
-#if MICROPY_EMIT_X86
-#define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_X86)
-#elif MICROPY_EMIT_X64
-#define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_X64)
-#elif MICROPY_EMIT_THUMB
-#define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_ARMV7M)
-#elif MICROPY_EMIT_ARM
-#define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_ARMV6)
-#elif MICROPY_EMIT_XTENSA
-#define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_XTENSA)
-#else
-#define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_NONE)
-#endif
-
 #if MICROPY_DYNAMIC_COMPILER
 #define MPY_FEATURE_ARCH_DYNAMIC mp_dynamic_compiler.native_arch
 #else
@@ -160,40 +124,45 @@ typedef struct _bytecode_prelude_t {
     uint code_info_size;
 } bytecode_prelude_t;
 
-#if MICROPY_PERSISTENT_CODE_SAVE || MICROPY_EMIT_NATIVE
-
 // ip will point to start of opcodes
-// ip2 will point to simple_name, source_file qstrs
-STATIC void extract_prelude(const byte **ip, const byte **ip2, bytecode_prelude_t *prelude) {
-    prelude->n_state = mp_decode_uint(ip);
-    prelude->n_exc_stack = mp_decode_uint(ip);
-    prelude->scope_flags = *(*ip)++;
-    prelude->n_pos_args = *(*ip)++;
-    prelude->n_kwonly_args = *(*ip)++;
-    prelude->n_def_pos_args = *(*ip)++;
-    *ip2 = *ip;
-    prelude->code_info_size = mp_decode_uint(ip2);
-    *ip += prelude->code_info_size;
-    while (*(*ip)++ != 255) {
-    }
+// return value will point to simple_name, source_file qstrs
+STATIC byte *extract_prelude(const byte **ip, bytecode_prelude_t *prelude) {
+    MP_BC_PRELUDE_SIG_DECODE(*ip);
+    prelude->n_state = n_state;
+    prelude->n_exc_stack = n_exc_stack;
+    prelude->scope_flags = scope_flags;
+    prelude->n_pos_args = n_pos_args;
+    prelude->n_kwonly_args = n_kwonly_args;
+    prelude->n_def_pos_args = n_def_pos_args;
+    MP_BC_PRELUDE_SIZE_DECODE(*ip);
+    byte *ip_info = (byte *)*ip;
+    *ip += n_info;
+    *ip += n_cell;
+    return ip_info;
 }
 
-#endif
-
 #endif // MICROPY_PERSISTENT_CODE_LOAD || MICROPY_PERSISTENT_CODE_SAVE
 
 #if MICROPY_PERSISTENT_CODE_LOAD
 
 #include "py/parsenum.h"
 
-#if MICROPY_EMIT_NATIVE
+STATIC int read_byte(mp_reader_t *reader);
+STATIC size_t read_uint(mp_reader_t *reader, byte **out);
+
+#if MICROPY_EMIT_MACHINE_CODE
+
+typedef struct _reloc_info_t {
+    mp_reader_t *reader;
+    mp_uint_t *const_table;
+} reloc_info_t;
 
 #if MICROPY_EMIT_THUMB
 STATIC void asm_thumb_rewrite_mov(uint8_t *pc, uint16_t val) {
     // high part
-    *(uint16_t*)pc = (*(uint16_t*)pc & 0xfbf0) | (val >> 1 & 0x0400) | (val >> 12);
+    *(uint16_t *)pc = (*(uint16_t *)pc & 0xfbf0) | (val >> 1 & 0x0400) | (val >> 12);
     // low part
-    *(uint16_t*)(pc + 2) = (*(uint16_t*)(pc + 2) & 0x0f00) | (val << 4 & 0x7000) | (val & 0x00ff);
+    *(uint16_t *)(pc + 2) = (*(uint16_t *)(pc + 2) & 0x0f00) | (val << 4 & 0x7000) | (val & 0x00ff);
 
 }
 #endif
@@ -203,7 +172,7 @@ STATIC void arch_link_qstr(uint8_t *pc, bool is_obj, qstr qst) {
     if (is_obj) {
         val = (mp_uint_t)MP_OBJ_NEW_QSTR(qst);
     }
-    #if MICROPY_EMIT_X86 || MICROPY_EMIT_X64 || MICROPY_EMIT_ARM || MICROPY_EMIT_XTENSA
+    #if MICROPY_EMIT_X86 || MICROPY_EMIT_X64 || MICROPY_EMIT_ARM || MICROPY_EMIT_XTENSA || MICROPY_EMIT_XTENSAWIN
     pc[0] = val & 0xff;
     pc[1] = (val >> 8) & 0xff;
     pc[2] = (val >> 16) & 0xff;
@@ -220,6 +189,52 @@ STATIC void arch_link_qstr(uint8_t *pc, bool is_obj, qstr qst) {
     #endif
 }
 
+void mp_native_relocate(void *ri_in, uint8_t *text, uintptr_t reloc_text) {
+    // Relocate native code
+    reloc_info_t *ri = ri_in;
+    uint8_t op;
+    uintptr_t *addr_to_adjust = NULL;
+    while ((op = read_byte(ri->reader)) != 0xff) {
+        if (op & 1) {
+            // Point to new location to make adjustments
+            size_t addr = read_uint(ri->reader, NULL);
+            if ((addr & 1) == 0) {
+                // Point to somewhere in text
+                addr_to_adjust = &((uintptr_t *)text)[addr >> 1];
+            } else {
+                // Point to somewhere in rodata
+                addr_to_adjust = &((uintptr_t *)ri->const_table[1])[addr >> 1];
+            }
+        }
+        op >>= 1;
+        uintptr_t dest;
+        size_t n = 1;
+        if (op <= 5) {
+            if (op & 1) {
+                // Read in number of adjustments to make
+                n = read_uint(ri->reader, NULL);
+            }
+            op >>= 1;
+            if (op == 0) {
+                // Destination is text
+                dest = reloc_text;
+            } else {
+                // Destination is rodata (op=1) or bss (op=1 if no rodata, else op=2)
+                dest = ri->const_table[op];
+            }
+        } else if (op == 6) {
+            // Destination is mp_fun_table itself
+            dest = (uintptr_t)&mp_fun_table;
+        } else {
+            // Destination is an entry in mp_fun_table
+            dest = ((uintptr_t *)&mp_fun_table)[op - 7];
+        }
+        while (n--) {
+            *addr_to_adjust++ += dest;
+        }
+    }
+}
+
 #endif
 
 STATIC int read_byte(mp_reader_t *reader) {
@@ -260,7 +275,7 @@ STATIC qstr load_qstr(mp_reader_t *reader, qstr_window_t *qw) {
     }
     len >>= 1;
     char *str = m_new(char, len);
-    read_bytes(reader, (byte*)str, len);
+    read_bytes(reader, (byte *)str, len);
     qstr qst = qstr_from_strn(str, len);
     m_del(char, str, len);
     qstr_window_push(qw, qst);
@@ -275,7 +290,7 @@ STATIC mp_obj_t load_obj(mp_reader_t *reader) {
         size_t len = read_uint(reader, NULL);
         vstr_t vstr;
         vstr_init_len(&vstr, len);
-        read_bytes(reader, (byte*)vstr.buf, len);
+        read_bytes(reader, (byte *)vstr.buf, len);
         if (obj_type == 's' || obj_type == 'b') {
             return mp_obj_new_str_from_vstr(obj_type == 's' ? &mp_type_str : &mp_type_bytes, &vstr);
         } else if (obj_type == 'i') {
@@ -287,20 +302,30 @@ STATIC mp_obj_t load_obj(mp_reader_t *reader) {
     }
 }
 
-STATIC void load_prelude(mp_reader_t *reader, byte **ip, byte **ip2, bytecode_prelude_t *prelude) {
-    prelude->n_state = read_uint(reader, ip);
-    prelude->n_exc_stack = read_uint(reader, ip);
-    read_bytes(reader, *ip, 4);
-    prelude->scope_flags = *(*ip)++;
-    prelude->n_pos_args = *(*ip)++;
-    prelude->n_kwonly_args = *(*ip)++;
-    prelude->n_def_pos_args = *(*ip)++;
-    *ip2 = *ip;
-    prelude->code_info_size = read_uint(reader, ip2);
-    read_bytes(reader, *ip2, prelude->code_info_size - (*ip2 - *ip));
-    *ip += prelude->code_info_size;
-    while ((*(*ip)++ = read_byte(reader)) != 255) {
-    }
+STATIC void load_prelude_qstrs(mp_reader_t *reader, qstr_window_t *qw, byte *ip) {
+    qstr simple_name = load_qstr(reader, qw);
+    ip[0] = simple_name;
+    ip[1] = simple_name >> 8;
+    qstr source_file = load_qstr(reader, qw);
+    ip[2] = source_file;
+    ip[3] = source_file >> 8;
+}
+
+STATIC void load_prelude(mp_reader_t *reader, qstr_window_t *qw, byte **ip, bytecode_prelude_t *prelude) {
+    // Read in the prelude header
+    byte *ip_read = *ip;
+    read_uint(reader, &ip_read);                    // read in n_state/etc (is effectively a var-uint)
+    read_uint(reader, &ip_read);                    // read in n_info/n_cell (is effectively a var-uint)
+
+    // Prelude header has been read into *ip, now decode and extract values from it
+    extract_prelude((const byte **)ip, prelude);
+
+    // Load qstrs in prelude
+    load_prelude_qstrs(reader, qw, ip_read);
+    ip_read += 4;
+
+    // Read remaining code info
+    read_bytes(reader, ip_read, *ip - ip_read);
 }
 
 STATIC void load_bytecode(mp_reader_t *reader, qstr_window_t *qw, byte *ip, byte *ip_top) {
@@ -310,12 +335,12 @@ STATIC void load_bytecode(mp_reader_t *reader, qstr_window_t *qw, byte *ip, byte
         uint f = mp_opcode_format(ip, &sz, false);
         ++ip;
         --sz;
-        if (f == MP_OPCODE_QSTR) {
+        if (f == MP_BC_FORMAT_QSTR) {
             qstr qst = load_qstr(reader, qw);
             *ip++ = qst;
             *ip++ = qst >> 8;
             sz -= 2;
-        } else if (f == MP_OPCODE_VAR_UINT) {
+        } else if (f == MP_BC_FORMAT_VAR_UINT) {
             while ((*ip++ = read_byte(reader)) & 0x80) {
             }
         }
@@ -330,17 +355,16 @@ STATIC mp_raw_code_t *load_raw_code(mp_reader_t *reader, qstr_window_t *qw) {
     int kind = (kind_len & 3) + MP_CODE_BYTECODE;
     size_t fun_data_len = kind_len >> 2;
 
-    #if !MICROPY_EMIT_NATIVE
+    #if !MICROPY_EMIT_MACHINE_CODE
     if (kind != MP_CODE_BYTECODE) {
-        mp_raise_ValueError("incompatible .mpy file");
+        mp_raise_ValueError(MP_ERROR_TEXT("incompatible .mpy file"));
     }
     #endif
 
     uint8_t *fun_data = NULL;
-    byte *ip2;
     bytecode_prelude_t prelude = {0};
-    #if MICROPY_EMIT_NATIVE
-    size_t prelude_offset;
+    #if MICROPY_EMIT_MACHINE_CODE
+    size_t prelude_offset = 0;
     mp_uint_t type_sig = 0;
     size_t n_qstr_link = 0;
     #endif
@@ -351,16 +375,16 @@ STATIC mp_raw_code_t *load_raw_code(mp_reader_t *reader, qstr_window_t *qw) {
 
         // Load prelude
         byte *ip = fun_data;
-        load_prelude(reader, &ip, &ip2, &prelude);
+        load_prelude(reader, qw, &ip, &prelude);
 
         // Load bytecode
         load_bytecode(reader, qw, ip, fun_data + fun_data_len);
 
-    #if MICROPY_EMIT_NATIVE
+    #if MICROPY_EMIT_MACHINE_CODE
     } else {
         // Allocate memory for native data and load it
         size_t fun_alloc;
-        MP_PLAT_ALLOC_EXEC(fun_data_len, (void**)&fun_data, &fun_alloc);
+        MP_PLAT_ALLOC_EXEC(fun_data_len, (void **)&fun_data, &fun_alloc);
         read_bytes(reader, fun_data, fun_data_len);
 
         if (kind == MP_CODE_NATIVE_PY || kind == MP_CODE_NATIVE_VIPER) {
@@ -374,6 +398,9 @@ STATIC mp_raw_code_t *load_raw_code(mp_reader_t *reader, qstr_window_t *qw) {
                     // Generic 16-bit link
                     dest[0] = qst & 0xff;
                     dest[1] = (qst >> 8) & 0xff;
+                } else if ((off & 3) == 3) {
+                    // Generic, aligned qstr-object link
+                    *(mp_obj_t *)dest = MP_OBJ_NEW_QSTR(qst);
                 } else {
                     // Architecture-specific link
                     arch_link_qstr(dest, (off & 3) == 2, qst);
@@ -385,7 +412,9 @@ STATIC mp_raw_code_t *load_raw_code(mp_reader_t *reader, qstr_window_t *qw) {
             // Extract prelude for later use
             prelude_offset = read_uint(reader, NULL);
             const byte *ip = fun_data + prelude_offset;
-            extract_prelude(&ip, (const byte**)&ip2, &prelude);
+            byte *ip_info = extract_prelude(&ip, &prelude);
+            // Load qstrs in prelude
+            load_prelude_qstrs(reader, qw, ip_info);
         } else {
             // Load basic scope info for viper and asm
             prelude.scope_flags = read_uint(reader, NULL);
@@ -399,27 +428,31 @@ STATIC mp_raw_code_t *load_raw_code(mp_reader_t *reader, qstr_window_t *qw) {
     #endif
     }
 
-    if (kind == MP_CODE_BYTECODE || kind == MP_CODE_NATIVE_PY) {
-        // Load qstrs in prelude
-        qstr simple_name = load_qstr(reader, qw);
-        qstr source_file = load_qstr(reader, qw);
-        ip2[0] = simple_name; ip2[1] = simple_name >> 8;
-        ip2[2] = source_file; ip2[3] = source_file >> 8;
-    }
-
+    size_t n_obj = 0;
+    size_t n_raw_code = 0;
     mp_uint_t *const_table = NULL;
+
     if (kind != MP_CODE_NATIVE_ASM) {
         // Load constant table for bytecode, native and viper
 
         // Number of entries in constant table
-        size_t n_obj = read_uint(reader, NULL);
-        size_t n_raw_code = read_uint(reader, NULL);
+        n_obj = read_uint(reader, NULL);
+        n_raw_code = read_uint(reader, NULL);
 
         // Allocate constant table
         size_t n_alloc = prelude.n_pos_args + prelude.n_kwonly_args + n_obj + n_raw_code;
+        #if MICROPY_EMIT_MACHINE_CODE
         if (kind != MP_CODE_BYTECODE) {
             ++n_alloc; // additional entry for mp_fun_table
+            if (prelude.scope_flags & MP_SCOPE_FLAG_VIPERRODATA) {
+                ++n_alloc; // additional entry for rodata
+            }
+            if (prelude.scope_flags & MP_SCOPE_FLAG_VIPERBSS) {
+                ++n_alloc; // additional entry for BSS
+            }
         }
+        #endif
+
         const_table = m_new(mp_uint_t, n_alloc);
         mp_uint_t *ct = const_table;
 
@@ -429,10 +462,25 @@ STATIC mp_raw_code_t *load_raw_code(mp_reader_t *reader, qstr_window_t *qw) {
             *ct++ = (mp_uint_t)MP_OBJ_NEW_QSTR(load_qstr(reader, qw));
         }
 
-        #if MICROPY_EMIT_NATIVE
+        #if MICROPY_EMIT_MACHINE_CODE
         if (kind != MP_CODE_BYTECODE) {
             // Populate mp_fun_table entry
-            *ct++ = (mp_uint_t)(uintptr_t)mp_fun_table;
+            *ct++ = (mp_uint_t)(uintptr_t)&mp_fun_table;
+
+            // Allocate and load rodata if needed
+            if (prelude.scope_flags & MP_SCOPE_FLAG_VIPERRODATA) {
+                size_t size = read_uint(reader, NULL);
+                uint8_t *rodata = m_new(uint8_t, size);
+                read_bytes(reader, rodata, size);
+                *ct++ = (uintptr_t)rodata;
+            }
+
+            // Allocate BSS if needed
+            if (prelude.scope_flags & MP_SCOPE_FLAG_VIPERBSS) {
+                size_t size = read_uint(reader, NULL);
+                uint8_t *bss = m_new0(uint8_t, size);
+                *ct++ = (uintptr_t)bss;
+            }
         }
         #endif
 
@@ -448,6 +496,7 @@ STATIC mp_raw_code_t *load_raw_code(mp_reader_t *reader, qstr_window_t *qw) {
     // Create raw_code and return it
     mp_raw_code_t *rc = mp_emit_glue_new_raw_code();
     if (kind == MP_CODE_BYTECODE) {
+        // Assign bytecode to raw code object
         mp_emit_glue_assign_bytecode(rc, fun_data,
             #if MICROPY_PERSISTENT_CODE_SAVE || MICROPY_DEBUG_PRINTERS
             fun_data_len,
@@ -458,12 +507,20 @@ STATIC mp_raw_code_t *load_raw_code(mp_reader_t *reader, qstr_window_t *qw) {
             #endif
             prelude.scope_flags);
 
-    #if MICROPY_EMIT_NATIVE
+    #if MICROPY_EMIT_MACHINE_CODE
     } else {
+        // Relocate and commit code to executable address space
+        reloc_info_t ri = {reader, const_table};
         #if defined(MP_PLAT_COMMIT_EXEC)
-        fun_data = MP_PLAT_COMMIT_EXEC(fun_data, fun_data_len);
+        void *opt_ri = (prelude.scope_flags & MP_SCOPE_FLAG_VIPERRELOC) ? &ri : NULL;
+        fun_data = MP_PLAT_COMMIT_EXEC(fun_data, fun_data_len, opt_ri);
+        #else
+        if (prelude.scope_flags & MP_SCOPE_FLAG_VIPERRELOC) {
+            mp_native_relocate(&ri, fun_data, (uintptr_t)fun_data);
+        }
         #endif
 
+        // Assign native code to raw code object
         mp_emit_glue_assign_native(rc, kind,
             fun_data, fun_data_len, const_table,
             #if MICROPY_PERSISTENT_CODE_SAVE
@@ -485,11 +542,13 @@ mp_raw_code_t *mp_raw_code_load(mp_reader_t *reader) {
         || MPY_FEATURE_DECODE_FLAGS(header[2]) != MPY_FEATURE_FLAGS
         || header[3] > mp_small_int_bits()
         || read_uint(reader, NULL) > QSTR_WINDOW_SIZE) {
-        mp_raise_ValueError("incompatible .mpy file");
+        mp_raise_ValueError(MP_ERROR_TEXT("incompatible .mpy file"));
     }
-    if (MPY_FEATURE_DECODE_ARCH(header[2]) != MP_NATIVE_ARCH_NONE
-        && MPY_FEATURE_DECODE_ARCH(header[2]) != MPY_FEATURE_ARCH) {
-        mp_raise_ValueError("incompatible .mpy arch");
+    if (MPY_FEATURE_DECODE_ARCH(header[2]) != MP_NATIVE_ARCH_NONE) {
+        byte arch = MPY_FEATURE_DECODE_ARCH(header[2]);
+        if (!MPY_FEATURE_ARCH_TEST(arch)) {
+            mp_raise_ValueError(MP_ERROR_TEXT("incompatible .mpy arch"));
+        }
     }
     qstr_window_t qw;
     qw.idx = 0;
@@ -521,7 +580,7 @@ mp_raw_code_t *mp_raw_code_load_file(const char *filename) {
 #include "py/objstr.h"
 
 STATIC void mp_print_bytes(mp_print_t *print, const byte *data, size_t len) {
-    print->print_strn(print->data, (const char*)data, len);
+    print->print_strn(print->data, (const char *)data, len);
 }
 
 #define BYTES_FOR_INT ((BYTES_PER_WORD * 8 + 6) / 7)
@@ -533,7 +592,7 @@ STATIC void mp_print_uint(mp_print_t *print, size_t n) {
     for (; n != 0; n >>= 7) {
         *--p = 0x80 | (n & 0x7f);
     }
-    print->print_strn(print->data, (char*)p, buf + sizeof(buf) - p);
+    print->print_strn(print->data, (char *)p, buf + sizeof(buf) - p);
 }
 
 STATIC void save_qstr(mp_print_t *print, qstr_window_t *qw, qstr qst) {
@@ -563,11 +622,11 @@ STATIC void save_obj(mp_print_t *print, mp_obj_t o) {
         } else {
             obj_type = 'b';
         }
-        mp_uint_t len;
+        size_t len;
         const char *str = mp_obj_str_get_data(o, &len);
         mp_print_bytes(print, &obj_type, 1);
         mp_print_uint(print, len);
-        mp_print_bytes(print, (const byte*)str, len);
+        mp_print_bytes(print, (const byte *)str, len);
     } else if (MP_OBJ_TO_PTR(o) == &mp_const_ellipsis_obj) {
         byte obj_type = 'e';
         mp_print_bytes(print, &obj_type, 1);
@@ -591,16 +650,21 @@ STATIC void save_obj(mp_print_t *print, mp_obj_t o) {
         mp_obj_print_helper(&pr, o, PRINT_REPR);
         mp_print_bytes(print, &obj_type, 1);
         mp_print_uint(print, vstr.len);
-        mp_print_bytes(print, (const byte*)vstr.buf, vstr.len);
+        mp_print_bytes(print, (const byte *)vstr.buf, vstr.len);
         vstr_clear(&vstr);
     }
 }
 
+STATIC void save_prelude_qstrs(mp_print_t *print, qstr_window_t *qw, const byte *ip) {
+    save_qstr(print, qw, ip[0] | (ip[1] << 8)); // simple_name
+    save_qstr(print, qw, ip[2] | (ip[3] << 8)); // source_file
+}
+
 STATIC void save_bytecode(mp_print_t *print, qstr_window_t *qw, const byte *ip, const byte *ip_top) {
     while (ip < ip_top) {
         size_t sz;
         uint f = mp_opcode_format(ip, &sz, true);
-        if (f == MP_OPCODE_QSTR) {
+        if (f == MP_BC_FORMAT_QSTR) {
             mp_print_bytes(print, ip, 1);
             qstr qst = ip[1] | (ip[2] << 8);
             save_qstr(print, qw, qst);
@@ -616,19 +680,23 @@ STATIC void save_raw_code(mp_print_t *print, mp_raw_code_t *rc, qstr_window_t *q
     // Save function kind and data length
     mp_print_uint(print, (rc->fun_data_len << 2) | (rc->kind - MP_CODE_BYTECODE));
 
-    const byte *ip2;
     bytecode_prelude_t prelude;
 
     if (rc->kind == MP_CODE_BYTECODE) {
-        // Save prelude
+        // Extract prelude
         const byte *ip = rc->fun_data;
-        extract_prelude(&ip, &ip2, &prelude);
-        size_t prelude_len = ip - (const byte*)rc->fun_data;
-        const byte *ip_top = (const byte*)rc->fun_data + rc->fun_data_len;
-        mp_print_bytes(print, rc->fun_data, prelude_len);
+        const byte *ip_info = extract_prelude(&ip, &prelude);
+
+        // Save prelude
+        mp_print_bytes(print, rc->fun_data, ip_info - (const byte *)rc->fun_data);
+        save_prelude_qstrs(print, qstr_window, ip_info);
+        ip_info += 4;
+        mp_print_bytes(print, ip_info, ip - ip_info);
 
         // Save bytecode
+        const byte *ip_top = (const byte *)rc->fun_data + rc->fun_data_len;
         save_bytecode(print, qstr_window, ip, ip_top);
+    #if MICROPY_EMIT_MACHINE_CODE
     } else {
         // Save native code
         mp_print_bytes(print, rc->fun_data, rc->fun_data_len);
@@ -643,13 +711,16 @@ STATIC void save_raw_code(mp_print_t *print, mp_raw_code_t *rc, qstr_window_t *q
         }
 
         if (rc->kind == MP_CODE_NATIVE_PY) {
-            // Save prelude size, and extract prelude for later use
+            // Save prelude size
             mp_print_uint(print, rc->prelude_offset);
-            const byte *ip = (const byte*)rc->fun_data + rc->prelude_offset;
-            extract_prelude(&ip, &ip2, &prelude);
+
+            // Extract prelude and save qstrs in prelude
+            const byte *ip = (const byte *)rc->fun_data + rc->prelude_offset;
+            const byte *ip_info = extract_prelude(&ip, &prelude);
+            save_prelude_qstrs(print, qstr_window, ip_info);
         } else {
             // Save basic scope info for viper and asm
-            mp_print_uint(print, rc->scope_flags);
+            mp_print_uint(print, rc->scope_flags & MP_SCOPE_FLAG_ALL_SIG);
             prelude.n_pos_args = 0;
             prelude.n_kwonly_args = 0;
             if (rc->kind == MP_CODE_NATIVE_ASM) {
@@ -657,12 +728,7 @@ STATIC void save_raw_code(mp_print_t *print, mp_raw_code_t *rc, qstr_window_t *q
                 mp_print_uint(print, rc->type_sig);
             }
         }
-    }
-
-    if (rc->kind == MP_CODE_BYTECODE || rc->kind == MP_CODE_NATIVE_PY) {
-        // Save qstrs in prelude
-        save_qstr(print, qstr_window, ip2[0] | (ip2[1] << 8)); // simple_name
-        save_qstr(print, qstr_window, ip2[2] | (ip2[3] << 8)); // source_file
+    #endif
     }
 
     if (rc->kind != MP_CODE_NATIVE_ASM) {
@@ -691,7 +757,7 @@ STATIC void save_raw_code(mp_print_t *print, mp_raw_code_t *rc, qstr_window_t *q
             save_obj(print, (mp_obj_t)*const_table++);
         }
         for (size_t i = 0; i < rc->n_raw_code; ++i) {
-            save_raw_code(print, (mp_raw_code_t*)(uintptr_t)*const_table++, qstr_window);
+            save_raw_code(print, (mp_raw_code_t *)(uintptr_t)*const_table++, qstr_window);
         }
     }
 }
@@ -702,16 +768,15 @@ STATIC bool mp_raw_code_has_native(mp_raw_code_t *rc) {
     }
 
     const byte *ip = rc->fun_data;
-    const byte *ip2;
     bytecode_prelude_t prelude;
-    extract_prelude(&ip, &ip2, &prelude);
+    extract_prelude(&ip, &prelude);
 
     const mp_uint_t *const_table = rc->const_table
         + prelude.n_pos_args + prelude.n_kwonly_args
         + rc->n_obj;
 
     for (size_t i = 0; i < rc->n_raw_code; ++i) {
-        if (mp_raw_code_has_native((mp_raw_code_t*)(uintptr_t)*const_table++)) {
+        if (mp_raw_code_has_native((mp_raw_code_t *)(uintptr_t)*const_table++)) {
             return true;
         }
     }
@@ -751,7 +816,7 @@ void mp_raw_code_save(mp_raw_code_t *rc, mp_print_t *print) {
 // here we define mp_raw_code_save_file depending on the port
 // TODO abstract this away properly
 
-#if defined(__i386__) || defined(__x86_64__) || defined(__unix__)
+#if defined(__i386__) || defined(__x86_64__) || defined(_WIN32) || defined(__unix__)
 
 #include <unistd.h>
 #include <sys/stat.h>
@@ -759,15 +824,21 @@ void mp_raw_code_save(mp_raw_code_t *rc, mp_print_t *print) {
 
 STATIC void fd_print_strn(void *env, const char *str, size_t len) {
     int fd = (intptr_t)env;
+    MP_THREAD_GIL_EXIT();
     ssize_t ret = write(fd, str, len);
+    MP_THREAD_GIL_ENTER();
     (void)ret;
 }
 
 void mp_raw_code_save_file(mp_raw_code_t *rc, const char *filename) {
+    MP_THREAD_GIL_EXIT();
     int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
-    mp_print_t fd_print = {(void*)(intptr_t)fd, fd_print_strn};
+    MP_THREAD_GIL_ENTER();
+    mp_print_t fd_print = {(void *)(intptr_t)fd, fd_print_strn};
     mp_raw_code_save(rc, &fd_print);
+    MP_THREAD_GIL_EXIT();
     close(fd);
+    MP_THREAD_GIL_ENTER();
 }
 
 #else
diff --git a/py/persistentcode.h b/py/persistentcode.h
index b27c3de2f046a..8769ef584d2d7 100644
--- a/py/persistentcode.h
+++ b/py/persistentcode.h
@@ -30,6 +30,65 @@
 #include "py/reader.h"
 #include "py/emitglue.h"
 
+// The current version of .mpy files
+#define MPY_VERSION 5
+
+// Macros to encode/decode flags to/from the feature byte
+#define MPY_FEATURE_ENCODE_FLAGS(flags) (flags)
+#define MPY_FEATURE_DECODE_FLAGS(feat) ((feat) & 3)
+
+// Macros to encode/decode native architecture to/from the feature byte
+#define MPY_FEATURE_ENCODE_ARCH(arch) ((arch) << 2)
+#define MPY_FEATURE_DECODE_ARCH(feat) ((feat) >> 2)
+
+// The feature flag bits encode the compile-time config options that
+// affect the generate bytecode.
+#define MPY_FEATURE_FLAGS ( \
+    ((MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE) << 0) \
+    | ((MICROPY_PY_BUILTINS_STR_UNICODE) << 1) \
+    )
+// This is a version of the flags that can be configured at runtime.
+#define MPY_FEATURE_FLAGS_DYNAMIC ( \
+    ((MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE_DYNAMIC) << 0) \
+    | ((MICROPY_PY_BUILTINS_STR_UNICODE_DYNAMIC) << 1) \
+    )
+
+// Define the host architecture
+#if MICROPY_EMIT_X86
+    #define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_X86)
+#elif MICROPY_EMIT_X64
+    #define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_X64)
+#elif MICROPY_EMIT_THUMB
+    #if defined(__thumb2__)
+        #if defined(__ARM_FP) && (__ARM_FP & 8) == 8
+            #define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_ARMV7EMDP)
+        #elif defined(__ARM_FP) && (__ARM_FP & 4) == 4
+            #define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_ARMV7EMSP)
+        #else
+            #define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_ARMV7EM)
+        #endif
+    #else
+        #define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_ARMV7M)
+    #endif
+    #define MPY_FEATURE_ARCH_TEST(x) (MP_NATIVE_ARCH_ARMV6M <= (x) && (x) <= MPY_FEATURE_ARCH)
+#elif MICROPY_EMIT_ARM
+    #define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_ARMV6)
+#elif MICROPY_EMIT_XTENSA
+    #define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_XTENSA)
+#elif MICROPY_EMIT_XTENSAWIN
+    #define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_XTENSAWIN)
+#else
+    #define MPY_FEATURE_ARCH (MP_NATIVE_ARCH_NONE)
+#endif
+
+#ifndef MPY_FEATURE_ARCH_TEST
+#define MPY_FEATURE_ARCH_TEST(x) ((x) == MPY_FEATURE_ARCH)
+#endif
+
+// 16-bit little-endian integer with the second and third bytes of supported .mpy files
+#define MPY_FILE_HEADER_INT (MPY_VERSION \
+    | (MPY_FEATURE_ENCODE_FLAGS(MPY_FEATURE_FLAGS) | MPY_FEATURE_ENCODE_ARCH(MPY_FEATURE_ARCH)) << 8)
+
 enum {
     MP_NATIVE_ARCH_NONE = 0,
     MP_NATIVE_ARCH_X86,
@@ -41,6 +100,7 @@ enum {
     MP_NATIVE_ARCH_ARMV7EMSP,
     MP_NATIVE_ARCH_ARMV7EMDP,
     MP_NATIVE_ARCH_XTENSA,
+    MP_NATIVE_ARCH_XTENSAWIN,
 };
 
 mp_raw_code_t *mp_raw_code_load(mp_reader_t *reader);
@@ -50,4 +110,6 @@ mp_raw_code_t *mp_raw_code_load_file(const char *filename);
 void mp_raw_code_save(mp_raw_code_t *rc, mp_print_t *print);
 void mp_raw_code_save_file(mp_raw_code_t *rc, const char *filename);
 
+void mp_native_relocate(void *reloc, uint8_t *text, uintptr_t reloc_text);
+
 #endif // MICROPY_INCLUDED_PY_PERSISTENTCODE_H
diff --git a/py/profile.c b/py/profile.c
new file mode 100644
index 0000000000000..863b0068a03e5
--- /dev/null
+++ b/py/profile.c
@@ -0,0 +1,984 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) SatoshiLabs
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/profile.h"
+#include "py/bc0.h"
+#include "py/gc.h"
+
+#if MICROPY_PY_SYS_SETTRACE
+
+#define prof_trace_cb MP_STATE_THREAD(prof_trace_callback)
+
+STATIC uint mp_prof_bytecode_lineno(const mp_raw_code_t *rc, size_t bc) {
+    const mp_bytecode_prelude_t *prelude = &rc->prelude;
+    return mp_bytecode_get_source_line(prelude->line_info, bc);
+}
+
+void mp_prof_extract_prelude(const byte *bytecode, mp_bytecode_prelude_t *prelude) {
+    const byte *ip = bytecode;
+
+    MP_BC_PRELUDE_SIG_DECODE(ip);
+    prelude->n_state = n_state;
+    prelude->n_exc_stack = n_exc_stack;
+    prelude->scope_flags = scope_flags;
+    prelude->n_pos_args = n_pos_args;
+    prelude->n_kwonly_args = n_kwonly_args;
+    prelude->n_def_pos_args = n_def_pos_args;
+
+    MP_BC_PRELUDE_SIZE_DECODE(ip);
+
+    prelude->line_info = ip + 4;
+    prelude->opcodes = ip + n_info + n_cell;
+
+    qstr block_name = ip[0] | (ip[1] << 8);
+    qstr source_file = ip[2] | (ip[3] << 8);
+    prelude->qstr_block_name = block_name;
+    prelude->qstr_source_file = source_file;
+}
+
+/******************************************************************************/
+// code object
+
+STATIC void code_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t kind) {
+    (void)kind;
+    mp_obj_code_t *o = MP_OBJ_TO_PTR(o_in);
+    const mp_raw_code_t *rc = o->rc;
+    const mp_bytecode_prelude_t *prelude = &rc->prelude;
+    mp_printf(print,
+        "<code object %q at 0x%p, file \"%q\", line %d>",
+        prelude->qstr_block_name,
+        o,
+        prelude->qstr_source_file,
+        rc->line_of_definition
+        );
+}
+
+STATIC mp_obj_tuple_t *code_consts(const mp_raw_code_t *rc) {
+    const mp_bytecode_prelude_t *prelude = &rc->prelude;
+    int start = prelude->n_pos_args + prelude->n_kwonly_args + rc->n_obj;
+    int stop = prelude->n_pos_args + prelude->n_kwonly_args + rc->n_obj + rc->n_raw_code;
+    mp_obj_tuple_t *consts = MP_OBJ_TO_PTR(mp_obj_new_tuple(stop - start + 1, NULL));
+
+    size_t const_no = 0;
+    for (int i = start; i < stop; ++i) {
+        mp_obj_t code = mp_obj_new_code((const mp_raw_code_t *)MP_OBJ_TO_PTR(rc->const_table[i]));
+        if (code == MP_OBJ_NULL) {
+            m_malloc_fail(sizeof(mp_obj_code_t));
+        }
+        consts->items[const_no++] = code;
+    }
+    consts->items[const_no++] = mp_const_none;
+
+    return consts;
+}
+
+STATIC mp_obj_t raw_code_lnotab(const mp_raw_code_t *rc) {
+    // const mp_bytecode_prelude_t *prelude = &rc->prelude;
+    uint start = 0;
+    uint stop = rc->fun_data_len - start;
+
+    uint last_lineno = mp_prof_bytecode_lineno(rc, start);
+    uint lasti = 0;
+
+    const uint buffer_chunk_size = (stop - start) >> 2; // heuristic magic
+    uint buffer_size = buffer_chunk_size;
+    byte *buffer = m_new(byte, buffer_size);
+    uint buffer_index = 0;
+
+    for (uint i = start; i < stop; ++i) {
+        uint lineno = mp_prof_bytecode_lineno(rc, i);
+        size_t line_diff = lineno - last_lineno;
+        if (line_diff > 0) {
+            uint instr_diff = (i - start) - lasti;
+
+            assert(instr_diff < 256);
+            assert(line_diff < 256);
+
+            if (buffer_index + 2 > buffer_size) {
+                buffer = m_renew(byte, buffer, buffer_size, buffer_size + buffer_chunk_size);
+                buffer_size = buffer_size + buffer_chunk_size;
+            }
+            last_lineno = lineno;
+            lasti = i - start;
+            buffer[buffer_index++] = instr_diff;
+            buffer[buffer_index++] = line_diff;
+        }
+    }
+
+    mp_obj_t o = mp_obj_new_bytes(buffer, buffer_index);
+    m_del(byte, buffer, buffer_size);
+    return o;
+}
+
+STATIC void code_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
+    if (dest[0] != MP_OBJ_NULL) {
+        // not load attribute
+        return;
+    }
+    mp_obj_code_t *o = MP_OBJ_TO_PTR(self_in);
+    const mp_raw_code_t *rc = o->rc;
+    const mp_bytecode_prelude_t *prelude = &rc->prelude;
+    switch (attr) {
+        case MP_QSTR_co_code:
+            dest[0] = mp_obj_new_bytes(
+                (void *)prelude->opcodes,
+                rc->fun_data_len - (prelude->opcodes - (const byte *)rc->fun_data)
+                );
+            break;
+        case MP_QSTR_co_consts:
+            dest[0] = MP_OBJ_FROM_PTR(code_consts(rc));
+            break;
+        case MP_QSTR_co_filename:
+            dest[0] = MP_OBJ_NEW_QSTR(prelude->qstr_source_file);
+            break;
+        case MP_QSTR_co_firstlineno:
+            dest[0] = MP_OBJ_NEW_SMALL_INT(mp_prof_bytecode_lineno(rc, 0));
+            break;
+        case MP_QSTR_co_name:
+            dest[0] = MP_OBJ_NEW_QSTR(prelude->qstr_block_name);
+            break;
+        case MP_QSTR_co_names:
+            dest[0] = MP_OBJ_FROM_PTR(o->dict_locals);
+            break;
+        case MP_QSTR_co_lnotab:
+            if (!o->lnotab) {
+                o->lnotab = raw_code_lnotab(rc);
+            }
+            dest[0] = o->lnotab;
+            break;
+    }
+}
+
+const mp_obj_type_t mp_type_code = {
+    { &mp_type_type },
+    .name = MP_QSTR_code,
+    .print = code_print,
+    .unary_op = mp_generic_unary_op,
+    .attr = code_attr,
+};
+
+mp_obj_t mp_obj_new_code(const mp_raw_code_t *rc) {
+    mp_obj_code_t *o = m_new_obj_maybe(mp_obj_code_t);
+    if (o == NULL) {
+        return MP_OBJ_NULL;
+    }
+    o->base.type = &mp_type_code;
+    o->rc = rc;
+    o->dict_locals = mp_locals_get(); // this is a wrong! how to do this properly?
+    o->lnotab = MP_OBJ_NULL;
+    return MP_OBJ_FROM_PTR(o);
+}
+
+/******************************************************************************/
+// frame object
+
+STATIC void frame_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t kind) {
+    (void)kind;
+    mp_obj_frame_t *frame = MP_OBJ_TO_PTR(o_in);
+    mp_obj_code_t *code = frame->code;
+    const mp_raw_code_t *rc = code->rc;
+    const mp_bytecode_prelude_t *prelude = &rc->prelude;
+    mp_printf(print,
+        "<frame at 0x%p, file '%q', line %d, code %q>",
+        frame,
+        prelude->qstr_source_file,
+        frame->lineno,
+        prelude->qstr_block_name
+        );
+}
+
+STATIC void frame_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
+    if (dest[0] != MP_OBJ_NULL) {
+        // not load attribute
+        return;
+    }
+
+    mp_obj_frame_t *o = MP_OBJ_TO_PTR(self_in);
+
+    switch (attr) {
+        case MP_QSTR_f_back:
+            dest[0] = mp_const_none;
+            if (o->code_state->prev_state) {
+                dest[0] = MP_OBJ_FROM_PTR(o->code_state->prev_state->frame);
+            }
+            break;
+        case MP_QSTR_f_code:
+            dest[0] = MP_OBJ_FROM_PTR(o->code);
+            break;
+        case MP_QSTR_f_globals:
+            dest[0] = MP_OBJ_FROM_PTR(o->code_state->fun_bc->globals);
+            break;
+        case MP_QSTR_f_lasti:
+            dest[0] = MP_OBJ_NEW_SMALL_INT(o->lasti);
+            break;
+        case MP_QSTR_f_lineno:
+            dest[0] = MP_OBJ_NEW_SMALL_INT(o->lineno);
+            break;
+    }
+}
+
+const mp_obj_type_t mp_type_frame = {
+    { &mp_type_type },
+    .name = MP_QSTR_frame,
+    .print = frame_print,
+    .unary_op = mp_generic_unary_op,
+    .attr = frame_attr,
+};
+
+mp_obj_t mp_obj_new_frame(const mp_code_state_t *code_state) {
+    if (gc_is_locked()) {
+        return MP_OBJ_NULL;
+    }
+
+    mp_obj_frame_t *o = m_new_obj_maybe(mp_obj_frame_t);
+    if (o == NULL) {
+        return MP_OBJ_NULL;
+    }
+
+    mp_obj_code_t *code = o->code = MP_OBJ_TO_PTR(mp_obj_new_code(code_state->fun_bc->rc));
+    if (code == NULL) {
+        return MP_OBJ_NULL;
+    }
+
+    const mp_raw_code_t *rc = code->rc;
+    const mp_bytecode_prelude_t *prelude = &rc->prelude;
+    o->code_state = code_state;
+    o->base.type = &mp_type_frame;
+    o->back = NULL;
+    o->code = code;
+    o->lasti = code_state->ip - prelude->opcodes;
+    o->lineno = mp_prof_bytecode_lineno(rc, o->lasti);
+    o->trace_opcodes = false;
+    o->callback = MP_OBJ_NULL;
+
+    return MP_OBJ_FROM_PTR(o);
+}
+
+
+/******************************************************************************/
+// Trace logic
+
+typedef struct {
+    struct _mp_obj_frame_t *frame;
+    mp_obj_t event;
+    mp_obj_t arg;
+} prof_callback_args_t;
+
+STATIC mp_obj_t mp_prof_callback_invoke(mp_obj_t callback, prof_callback_args_t *args) {
+    assert(mp_obj_is_callable(callback));
+
+    mp_prof_is_executing = true;
+
+    mp_obj_t a[3] = {MP_OBJ_FROM_PTR(args->frame), args->event, args->arg};
+    mp_obj_t top = mp_call_function_n_kw(callback, 3, 0, a);
+
+    mp_prof_is_executing = false;
+
+    if (MP_STATE_VM(mp_pending_exception) != MP_OBJ_NULL) {
+        mp_obj_t obj = MP_STATE_VM(mp_pending_exception);
+        MP_STATE_VM(mp_pending_exception) = MP_OBJ_NULL;
+        nlr_raise(obj);
+    }
+    return top;
+}
+
+mp_obj_t mp_prof_settrace(mp_obj_t callback) {
+    if (mp_obj_is_callable(callback)) {
+        prof_trace_cb = callback;
+    } else {
+        prof_trace_cb = MP_OBJ_NULL;
+    }
+    return mp_const_none;
+}
+
+mp_obj_t mp_prof_frame_enter(mp_code_state_t *code_state) {
+    assert(!mp_prof_is_executing);
+
+    mp_obj_frame_t *frame = MP_OBJ_TO_PTR(mp_obj_new_frame(code_state));
+    if (frame == NULL) {
+        // Couldn't allocate a frame object
+        return MP_OBJ_NULL;
+    }
+
+    if (code_state->prev_state && code_state->frame == NULL) {
+        // We are entering not-yet-traced frame
+        // which means it's a CALL event (not a GENERATOR)
+        // so set the function definition line.
+        const mp_raw_code_t *rc = code_state->fun_bc->rc;
+        frame->lineno = rc->line_of_definition;
+        if (!rc->line_of_definition) {
+            frame->lineno = mp_prof_bytecode_lineno(rc, 0);
+        }
+    }
+    code_state->frame = frame;
+
+    if (!prof_trace_cb) {
+        return MP_OBJ_NULL;
+    }
+
+    mp_obj_t top;
+    prof_callback_args_t _args, *args = &_args;
+    args->frame = code_state->frame;
+
+    // SETTRACE event CALL
+    args->event = MP_OBJ_NEW_QSTR(MP_QSTR_call);
+    args->arg = mp_const_none;
+    top = mp_prof_callback_invoke(prof_trace_cb, args);
+
+    code_state->frame->callback = mp_obj_is_callable(top) ? top : MP_OBJ_NULL;
+
+    // Invalidate the last executed line number so the LINE trace can trigger after this CALL.
+    frame->lineno = 0;
+
+    return top;
+}
+
+mp_obj_t mp_prof_frame_update(const mp_code_state_t *code_state) {
+    mp_obj_frame_t *frame = code_state->frame;
+    if (frame == NULL) {
+        // Frame was not allocated (eg because there was no memory available)
+        return MP_OBJ_NULL;
+    }
+
+    mp_obj_frame_t *o = frame;
+    mp_obj_code_t *code = o->code;
+    const mp_raw_code_t *rc = code->rc;
+    const mp_bytecode_prelude_t *prelude = &rc->prelude;
+
+    assert(o->code_state == code_state);
+
+    o->lasti = code_state->ip - prelude->opcodes;
+    o->lineno = mp_prof_bytecode_lineno(rc, o->lasti);
+
+    return MP_OBJ_FROM_PTR(o);
+}
+
+mp_obj_t mp_prof_instr_tick(mp_code_state_t *code_state, bool is_exception) {
+    // Detect execution recursion
+    assert(!mp_prof_is_executing);
+    assert(code_state->frame);
+    assert(mp_obj_get_type(code_state->frame) == &mp_type_frame);
+
+    // Detect data recursion
+    assert(code_state != code_state->prev_state);
+
+    mp_obj_t top = mp_const_none;
+    mp_obj_t callback = code_state->frame->callback;
+
+    prof_callback_args_t _args, *args = &_args;
+    args->frame = code_state->frame;
+    args->event = mp_const_none;
+    args->arg = mp_const_none;
+
+    // Call event's are handled inside mp_prof_frame_enter
+
+    // SETTRACE event EXCEPTION
+    if (is_exception) {
+        args->event = MP_OBJ_NEW_QSTR(MP_QSTR_exception);
+        top = mp_prof_callback_invoke(callback, args);
+        return top;
+    }
+
+    // SETTRACE event LINE
+    const mp_raw_code_t *rc = code_state->fun_bc->rc;
+    const mp_bytecode_prelude_t *prelude = &rc->prelude;
+    size_t prev_line_no = args->frame->lineno;
+    size_t current_line_no = mp_prof_bytecode_lineno(rc, code_state->ip - prelude->opcodes);
+    if (prev_line_no != current_line_no) {
+        args->frame->lineno = current_line_no;
+        args->event = MP_OBJ_NEW_QSTR(MP_QSTR_line);
+        top = mp_prof_callback_invoke(callback, args);
+    }
+
+    // SETTRACE event RETURN
+    const byte *ip = code_state->ip;
+    if (*ip == MP_BC_RETURN_VALUE || *ip == MP_BC_YIELD_VALUE) {
+        args->event = MP_OBJ_NEW_QSTR(MP_QSTR_return);
+        top = mp_prof_callback_invoke(callback, args);
+        if (code_state->prev_state && *ip == MP_BC_RETURN_VALUE) {
+            code_state->frame->callback = MP_OBJ_NULL;
+        }
+    }
+
+    // SETTRACE event OPCODE
+    // TODO: frame.f_trace_opcodes=True
+    if (false) {
+        args->event = MP_OBJ_NEW_QSTR(MP_QSTR_opcode);
+    }
+
+    return top;
+}
+
+/******************************************************************************/
+// DEBUG
+
+// This section is for debugging the settrace feature itself, and is not intended
+// to be included in production/release builds.  The code structure for this block
+// was taken from py/showbc.c and should not be used as a reference.  To enable
+// this debug feature enable MICROPY_PROF_INSTR_DEBUG_PRINT_ENABLE in py/profile.h.
+#if MICROPY_PROF_INSTR_DEBUG_PRINT_ENABLE
+
+#include "runtime0.h"
+
+#define DECODE_UINT { \
+        unum = 0; \
+        do { \
+            unum = (unum << 7) + (*ip & 0x7f); \
+        } while ((*ip++ & 0x80) != 0); \
+}
+#define DECODE_ULABEL do { unum = (ip[0] | (ip[1] << 8)); ip += 2; } while (0)
+#define DECODE_SLABEL do { unum = (ip[0] | (ip[1] << 8)) - 0x8000; ip += 2; } while (0)
+
+#define DECODE_QSTR \
+    qst = ip[0] | ip[1] << 8; \
+    ip += 2;
+#define DECODE_PTR \
+    DECODE_UINT; \
+    ptr = (const byte *)const_table[unum]
+#define DECODE_OBJ \
+    DECODE_UINT; \
+    obj = (mp_obj_t)const_table[unum]
+
+typedef struct _mp_dis_instruction_t {
+    mp_uint_t qstr_opname;
+    mp_uint_t arg;
+    mp_obj_t argobj;
+    mp_obj_t argobjex_cache;
+} mp_dis_instruction_t;
+
+STATIC const byte *mp_prof_opcode_decode(const byte *ip, const mp_uint_t *const_table, mp_dis_instruction_t *instruction) {
+    mp_uint_t unum;
+    const byte *ptr;
+    mp_obj_t obj;
+    qstr qst;
+
+    instruction->qstr_opname = MP_QSTR_;
+    instruction->arg = 0;
+    instruction->argobj = mp_const_none;
+    instruction->argobjex_cache = mp_const_none;
+
+    switch (*ip++) {
+        case MP_BC_LOAD_CONST_FALSE:
+            instruction->qstr_opname = MP_QSTR_LOAD_CONST_FALSE;
+            break;
+
+        case MP_BC_LOAD_CONST_NONE:
+            instruction->qstr_opname = MP_QSTR_LOAD_CONST_NONE;
+            break;
+
+        case MP_BC_LOAD_CONST_TRUE:
+            instruction->qstr_opname = MP_QSTR_LOAD_CONST_TRUE;
+            break;
+
+        case MP_BC_LOAD_CONST_SMALL_INT: {
+            mp_int_t num = 0;
+            if ((ip[0] & 0x40) != 0) {
+                // Number is negative
+                num--;
+            }
+            do {
+                num = (num << 7) | (*ip & 0x7f);
+            } while ((*ip++ & 0x80) != 0);
+            instruction->qstr_opname = MP_QSTR_LOAD_CONST_SMALL_INT;
+            instruction->arg = num;
+            break;
+        }
+
+        case MP_BC_LOAD_CONST_STRING:
+            DECODE_QSTR;
+            instruction->qstr_opname = MP_QSTR_LOAD_CONST_STRING;
+            instruction->arg = qst;
+            instruction->argobj = MP_OBJ_NEW_QSTR(qst);
+            break;
+
+        case MP_BC_LOAD_CONST_OBJ:
+            DECODE_OBJ;
+            instruction->qstr_opname = MP_QSTR_LOAD_CONST_OBJ;
+            instruction->arg = unum;
+            instruction->argobj = obj;
+            break;
+
+        case MP_BC_LOAD_NULL:
+            instruction->qstr_opname = MP_QSTR_LOAD_NULL;
+            break;
+
+        case MP_BC_LOAD_FAST_N:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_LOAD_FAST_N;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_LOAD_DEREF:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_LOAD_DEREF;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_LOAD_NAME:
+            DECODE_QSTR;
+            instruction->qstr_opname = MP_QSTR_LOAD_NAME;
+            instruction->arg = qst;
+            instruction->argobj = MP_OBJ_NEW_QSTR(qst);
+            if (MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE) {
+                instruction->argobjex_cache = MP_OBJ_NEW_SMALL_INT(*ip++);
+            }
+            break;
+
+        case MP_BC_LOAD_GLOBAL:
+            DECODE_QSTR;
+            instruction->qstr_opname = MP_QSTR_LOAD_GLOBAL;
+            instruction->arg = qst;
+            instruction->argobj = MP_OBJ_NEW_QSTR(qst);
+            if (MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE) {
+                instruction->argobjex_cache = MP_OBJ_NEW_SMALL_INT(*ip++);
+            }
+            break;
+
+        case MP_BC_LOAD_ATTR:
+            DECODE_QSTR;
+            instruction->qstr_opname = MP_QSTR_LOAD_ATTR;
+            instruction->arg = qst;
+            instruction->argobj = MP_OBJ_NEW_QSTR(qst);
+            if (MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE) {
+                instruction->argobjex_cache = MP_OBJ_NEW_SMALL_INT(*ip++);
+            }
+            break;
+
+        case MP_BC_LOAD_METHOD:
+            DECODE_QSTR;
+            instruction->qstr_opname = MP_QSTR_LOAD_METHOD;
+            instruction->arg = qst;
+            instruction->argobj = MP_OBJ_NEW_QSTR(qst);
+            break;
+
+        case MP_BC_LOAD_SUPER_METHOD:
+            DECODE_QSTR;
+            instruction->qstr_opname = MP_QSTR_LOAD_SUPER_METHOD;
+            instruction->arg = qst;
+            instruction->argobj = MP_OBJ_NEW_QSTR(qst);
+            break;
+
+        case MP_BC_LOAD_BUILD_CLASS:
+            instruction->qstr_opname = MP_QSTR_LOAD_BUILD_CLASS;
+            break;
+
+        case MP_BC_LOAD_SUBSCR:
+            instruction->qstr_opname = MP_QSTR_LOAD_SUBSCR;
+            break;
+
+        case MP_BC_STORE_FAST_N:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_STORE_FAST_N;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_STORE_DEREF:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_STORE_DEREF;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_STORE_NAME:
+            DECODE_QSTR;
+            instruction->qstr_opname = MP_QSTR_STORE_NAME;
+            instruction->arg = qst;
+            instruction->argobj = MP_OBJ_NEW_QSTR(qst);
+            break;
+
+        case MP_BC_STORE_GLOBAL:
+            DECODE_QSTR;
+            instruction->qstr_opname = MP_QSTR_STORE_GLOBAL;
+            instruction->arg = qst;
+            instruction->argobj = MP_OBJ_NEW_QSTR(qst);
+            break;
+
+        case MP_BC_STORE_ATTR:
+            DECODE_QSTR;
+            instruction->qstr_opname = MP_QSTR_STORE_ATTR;
+            instruction->arg = qst;
+            instruction->argobj = MP_OBJ_NEW_QSTR(qst);
+            if (MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE) {
+                instruction->argobjex_cache = MP_OBJ_NEW_SMALL_INT(*ip++);
+            }
+            break;
+
+        case MP_BC_STORE_SUBSCR:
+            instruction->qstr_opname = MP_QSTR_STORE_SUBSCR;
+            break;
+
+        case MP_BC_DELETE_FAST:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_DELETE_FAST;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_DELETE_DEREF:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_DELETE_DEREF;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_DELETE_NAME:
+            DECODE_QSTR;
+            instruction->qstr_opname = MP_QSTR_DELETE_NAME;
+            instruction->arg = qst;
+            instruction->argobj = MP_OBJ_NEW_QSTR(qst);
+            break;
+
+        case MP_BC_DELETE_GLOBAL:
+            DECODE_QSTR;
+            instruction->qstr_opname = MP_QSTR_DELETE_GLOBAL;
+            instruction->arg = qst;
+            instruction->argobj = MP_OBJ_NEW_QSTR(qst);
+            break;
+
+        case MP_BC_DUP_TOP:
+            instruction->qstr_opname = MP_QSTR_DUP_TOP;
+            break;
+
+        case MP_BC_DUP_TOP_TWO:
+            instruction->qstr_opname = MP_QSTR_DUP_TOP_TWO;
+            break;
+
+        case MP_BC_POP_TOP:
+            instruction->qstr_opname = MP_QSTR_POP_TOP;
+            break;
+
+        case MP_BC_ROT_TWO:
+            instruction->qstr_opname = MP_QSTR_ROT_TWO;
+            break;
+
+        case MP_BC_ROT_THREE:
+            instruction->qstr_opname = MP_QSTR_ROT_THREE;
+            break;
+
+        case MP_BC_JUMP:
+            DECODE_SLABEL;
+            instruction->qstr_opname = MP_QSTR_JUMP;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_POP_JUMP_IF_TRUE:
+            DECODE_SLABEL;
+            instruction->qstr_opname = MP_QSTR_POP_JUMP_IF_TRUE;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_POP_JUMP_IF_FALSE:
+            DECODE_SLABEL;
+            instruction->qstr_opname = MP_QSTR_POP_JUMP_IF_FALSE;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_JUMP_IF_TRUE_OR_POP:
+            DECODE_SLABEL;
+            instruction->qstr_opname = MP_QSTR_JUMP_IF_TRUE_OR_POP;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_JUMP_IF_FALSE_OR_POP:
+            DECODE_SLABEL;
+            instruction->qstr_opname = MP_QSTR_JUMP_IF_FALSE_OR_POP;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_SETUP_WITH:
+            DECODE_ULABEL; // loop-like labels are always forward
+            instruction->qstr_opname = MP_QSTR_SETUP_WITH;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_WITH_CLEANUP:
+            instruction->qstr_opname = MP_QSTR_WITH_CLEANUP;
+            break;
+
+        case MP_BC_UNWIND_JUMP:
+            DECODE_SLABEL;
+            instruction->qstr_opname = MP_QSTR_UNWIND_JUMP;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_SETUP_EXCEPT:
+            DECODE_ULABEL; // except labels are always forward
+            instruction->qstr_opname = MP_QSTR_SETUP_EXCEPT;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_SETUP_FINALLY:
+            DECODE_ULABEL; // except labels are always forward
+            instruction->qstr_opname = MP_QSTR_SETUP_FINALLY;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_END_FINALLY:
+            // if TOS is an exception, reraises the exception (3 values on TOS)
+            // if TOS is an integer, does something else
+            // if TOS is None, just pops it and continues
+            // else error
+            instruction->qstr_opname = MP_QSTR_END_FINALLY;
+            break;
+
+        case MP_BC_GET_ITER:
+            instruction->qstr_opname = MP_QSTR_GET_ITER;
+            break;
+
+        case MP_BC_GET_ITER_STACK:
+            instruction->qstr_opname = MP_QSTR_GET_ITER_STACK;
+            break;
+
+        case MP_BC_FOR_ITER:
+            DECODE_ULABEL; // the jump offset if iteration finishes; for labels are always forward
+            instruction->qstr_opname = MP_QSTR_FOR_ITER;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_BUILD_TUPLE:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_BUILD_TUPLE;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_BUILD_LIST:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_BUILD_LIST;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_BUILD_MAP:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_BUILD_MAP;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_STORE_MAP:
+            instruction->qstr_opname = MP_QSTR_STORE_MAP;
+            break;
+
+        case MP_BC_BUILD_SET:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_BUILD_SET;
+            instruction->arg = unum;
+            break;
+
+        #if MICROPY_PY_BUILTINS_SLICE
+        case MP_BC_BUILD_SLICE:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_BUILD_SLICE;
+            instruction->arg = unum;
+            break;
+        #endif
+
+        case MP_BC_STORE_COMP:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_STORE_COMP;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_UNPACK_SEQUENCE:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_UNPACK_SEQUENCE;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_UNPACK_EX:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_UNPACK_EX;
+            instruction->arg = unum;
+            break;
+
+        case MP_BC_MAKE_FUNCTION:
+            DECODE_PTR;
+            instruction->qstr_opname = MP_QSTR_MAKE_FUNCTION;
+            instruction->arg = unum;
+            instruction->argobj = mp_obj_new_int_from_ull((uint64_t)ptr);
+            break;
+
+        case MP_BC_MAKE_FUNCTION_DEFARGS:
+            DECODE_PTR;
+            instruction->qstr_opname = MP_QSTR_MAKE_FUNCTION_DEFARGS;
+            instruction->arg = unum;
+            instruction->argobj = mp_obj_new_int_from_ull((uint64_t)ptr);
+            break;
+
+        case MP_BC_MAKE_CLOSURE: {
+            DECODE_PTR;
+            mp_uint_t n_closed_over = *ip++;
+            instruction->qstr_opname = MP_QSTR_MAKE_CLOSURE;
+            instruction->arg = unum;
+            instruction->argobj = mp_obj_new_int_from_ull((uint64_t)ptr);
+            instruction->argobjex_cache = MP_OBJ_NEW_SMALL_INT(n_closed_over);
+            break;
+        }
+
+        case MP_BC_MAKE_CLOSURE_DEFARGS: {
+            DECODE_PTR;
+            mp_uint_t n_closed_over = *ip++;
+            instruction->qstr_opname = MP_QSTR_MAKE_CLOSURE_DEFARGS;
+            instruction->arg = unum;
+            instruction->argobj = mp_obj_new_int_from_ull((uint64_t)ptr);
+            instruction->argobjex_cache = MP_OBJ_NEW_SMALL_INT(n_closed_over);
+            break;
+        }
+
+        case MP_BC_CALL_FUNCTION:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_CALL_FUNCTION;
+            instruction->arg = unum & 0xff;
+            instruction->argobjex_cache = MP_OBJ_NEW_SMALL_INT((unum >> 8) & 0xff);
+            break;
+
+        case MP_BC_CALL_FUNCTION_VAR_KW:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_CALL_FUNCTION_VAR_KW;
+            instruction->arg = unum & 0xff;
+            instruction->argobjex_cache = MP_OBJ_NEW_SMALL_INT((unum >> 8) & 0xff);
+            break;
+
+        case MP_BC_CALL_METHOD:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_CALL_METHOD;
+            instruction->arg = unum & 0xff;
+            instruction->argobjex_cache = MP_OBJ_NEW_SMALL_INT((unum >> 8) & 0xff);
+            break;
+
+        case MP_BC_CALL_METHOD_VAR_KW:
+            DECODE_UINT;
+            instruction->qstr_opname = MP_QSTR_CALL_METHOD_VAR_KW;
+            instruction->arg = unum & 0xff;
+            instruction->argobjex_cache = MP_OBJ_NEW_SMALL_INT((unum >> 8) & 0xff);
+            break;
+
+        case MP_BC_RETURN_VALUE:
+            instruction->qstr_opname = MP_QSTR_RETURN_VALUE;
+            break;
+
+        case MP_BC_RAISE_LAST:
+            instruction->qstr_opname = MP_QSTR_RAISE_LAST;
+            break;
+
+        case MP_BC_RAISE_OBJ:
+            instruction->qstr_opname = MP_QSTR_RAISE_OBJ;
+            break;
+
+        case MP_BC_RAISE_FROM:
+            instruction->qstr_opname = MP_QSTR_RAISE_FROM;
+            break;
+
+        case MP_BC_YIELD_VALUE:
+            instruction->qstr_opname = MP_QSTR_YIELD_VALUE;
+            break;
+
+        case MP_BC_YIELD_FROM:
+            instruction->qstr_opname = MP_QSTR_YIELD_FROM;
+            break;
+
+        case MP_BC_IMPORT_NAME:
+            DECODE_QSTR;
+            instruction->qstr_opname = MP_QSTR_IMPORT_NAME;
+            instruction->arg = qst;
+            instruction->argobj = MP_OBJ_NEW_QSTR(qst);
+            break;
+
+        case MP_BC_IMPORT_FROM:
+            DECODE_QSTR;
+            instruction->qstr_opname = MP_QSTR_IMPORT_FROM;
+            instruction->arg = qst;
+            instruction->argobj = MP_OBJ_NEW_QSTR(qst);
+            break;
+
+        case MP_BC_IMPORT_STAR:
+            instruction->qstr_opname = MP_QSTR_IMPORT_STAR;
+            break;
+
+        default:
+            if (ip[-1] < MP_BC_LOAD_CONST_SMALL_INT_MULTI + 64) {
+                instruction->qstr_opname = MP_QSTR_LOAD_CONST_SMALL_INT;
+                instruction->arg = (mp_int_t)ip[-1] - MP_BC_LOAD_CONST_SMALL_INT_MULTI - 16;
+            } else if (ip[-1] < MP_BC_LOAD_FAST_MULTI + 16) {
+                instruction->qstr_opname = MP_QSTR_LOAD_FAST;
+                instruction->arg = (mp_uint_t)ip[-1] - MP_BC_LOAD_FAST_MULTI;
+            } else if (ip[-1] < MP_BC_STORE_FAST_MULTI + 16) {
+                instruction->qstr_opname = MP_QSTR_STORE_FAST;
+                instruction->arg = (mp_uint_t)ip[-1] - MP_BC_STORE_FAST_MULTI;
+            } else if (ip[-1] < MP_BC_UNARY_OP_MULTI + MP_UNARY_OP_NUM_BYTECODE) {
+                instruction->qstr_opname = MP_QSTR_UNARY_OP;
+                instruction->arg = (mp_uint_t)ip[-1] - MP_BC_UNARY_OP_MULTI;
+            } else if (ip[-1] < MP_BC_BINARY_OP_MULTI + MP_BINARY_OP_NUM_BYTECODE) {
+                mp_uint_t op = ip[-1] - MP_BC_BINARY_OP_MULTI;
+                instruction->qstr_opname = MP_QSTR_BINARY_OP;
+                instruction->arg = op;
+            } else {
+                mp_printf(&mp_plat_print, "code %p, opcode 0x%02x not implemented\n", ip - 1, ip[-1]);
+                assert(0);
+                return ip;
+            }
+            break;
+    }
+
+    return ip;
+}
+
+void mp_prof_print_instr(const byte *ip, mp_code_state_t *code_state) {
+    mp_dis_instruction_t _instruction, *instruction = &_instruction;
+    mp_prof_opcode_decode(ip, code_state->fun_bc->rc->const_table, instruction);
+    const mp_raw_code_t *rc = code_state->fun_bc->rc;
+    const mp_bytecode_prelude_t *prelude = &rc->prelude;
+
+    mp_uint_t offset = ip - prelude->opcodes;
+    mp_printf(&mp_plat_print, "instr");
+
+    /* long path */ if (1) {
+        mp_printf(&mp_plat_print,
+            "@0x%p:%q:%q+0x%04x:%d",
+            ip,
+            prelude->qstr_source_file,
+            prelude->qstr_block_name,
+            offset,
+            mp_prof_bytecode_lineno(rc, offset)
+            );
+    }
+
+    /* bytecode */ if (0) {
+        mp_printf(&mp_plat_print, " %02x %02x %02x %02x", ip[0], ip[1], ip[2], ip[3]);
+    }
+
+    mp_printf(&mp_plat_print, " 0x%02x %q [%d]", *ip, instruction->qstr_opname, instruction->arg);
+
+    if (instruction->argobj != mp_const_none) {
+        mp_printf(&mp_plat_print, " $");
+        mp_obj_print_helper(&mp_plat_print, instruction->argobj, PRINT_REPR);
+    }
+    if (instruction->argobjex_cache != mp_const_none) {
+        mp_printf(&mp_plat_print, " #");
+        mp_obj_print_helper(&mp_plat_print, instruction->argobjex_cache, PRINT_REPR);
+    }
+
+    mp_printf(&mp_plat_print, "\n");
+}
+
+#endif // MICROPY_PROF_INSTR_DEBUG_PRINT_ENABLE
+
+#endif // MICROPY_PY_SYS_SETTRACE
diff --git a/py/profile.h b/py/profile.h
new file mode 100644
index 0000000000000..64e207d04fbf3
--- /dev/null
+++ b/py/profile.h
@@ -0,0 +1,79 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) SatoshiLabs
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_PY_PROFILING_H
+#define MICROPY_INCLUDED_PY_PROFILING_H
+
+#include "py/emitglue.h"
+
+#if MICROPY_PY_SYS_SETTRACE
+
+#define mp_prof_is_executing MP_STATE_THREAD(prof_callback_is_executing)
+
+typedef struct _mp_obj_code_t {
+    mp_obj_base_t base;
+    const mp_raw_code_t *rc;
+    mp_obj_dict_t *dict_locals;
+    mp_obj_t lnotab;
+} mp_obj_code_t;
+
+typedef struct _mp_obj_frame_t {
+    mp_obj_base_t base;
+    const mp_code_state_t *code_state;
+    struct _mp_obj_frame_t *back;
+    mp_obj_t callback;
+    mp_obj_code_t *code;
+    mp_uint_t lasti;
+    mp_uint_t lineno;
+    bool trace_opcodes;
+} mp_obj_frame_t;
+
+void mp_prof_extract_prelude(const byte *bytecode, mp_bytecode_prelude_t *prelude);
+
+mp_obj_t mp_obj_new_code(const mp_raw_code_t *rc);
+mp_obj_t mp_obj_new_frame(const mp_code_state_t *code_state);
+
+// This is the implementation for the sys.settrace
+mp_obj_t mp_prof_settrace(mp_obj_t callback);
+
+mp_obj_t mp_prof_frame_enter(mp_code_state_t *code_state);
+mp_obj_t mp_prof_frame_update(const mp_code_state_t *code_state);
+
+// For every VM instruction tick this function deduces events from the state
+mp_obj_t mp_prof_instr_tick(mp_code_state_t *code_state, bool is_exception);
+
+// This section is for debugging the settrace feature itself, and is not intended
+// to be included in production/release builds.
+#define MICROPY_PROF_INSTR_DEBUG_PRINT_ENABLE 0
+#if MICROPY_PROF_INSTR_DEBUG_PRINT_ENABLE
+void mp_prof_print_instr(const byte *ip, mp_code_state_t *code_state);
+#define MP_PROF_INSTR_DEBUG_PRINT(current_ip) mp_prof_print_instr((current_ip), code_state)
+#else
+#define MP_PROF_INSTR_DEBUG_PRINT(current_ip)
+#endif
+
+#endif // MICROPY_PY_SYS_SETTRACE
+#endif // MICROPY_INCLUDED_PY_PROFILING_H
diff --git a/py/py.mk b/py/py.mk
index 0fbc9f14bbe3c..d864a7ed3d843 100644
--- a/py/py.mk
+++ b/py/py.mk
@@ -13,127 +13,26 @@ ifneq ($(QSTR_AUTOGEN_DISABLE),1)
 QSTR_DEFS_COLLECTED = $(HEADER_BUILD)/qstrdefs.collected.h
 endif
 
-# Any files listed by this variable will cause a full regeneration of qstrs
+# Any files listed by these variables will cause a full regeneration of qstrs
+# DEPENDENCIES: included in qstr processing; REQUIREMENTS: not included
 QSTR_GLOBAL_DEPENDENCIES += $(PY_SRC)/mpconfig.h mpconfigport.h
+QSTR_GLOBAL_REQUIREMENTS += $(HEADER_BUILD)/mpversion.h
 
 # some code is performance bottleneck and compiled with other optimization options
 CSUPEROPT = -O3
 
-# this sets the config file for FatFs
-CFLAGS_MOD += -DFFCONF_H=\"lib/oofatfs/ffconf.h\"
-
-ifeq ($(MICROPY_PY_USSL),1)
-CFLAGS_MOD += -DMICROPY_PY_USSL=1
-ifeq ($(MICROPY_SSL_AXTLS),1)
-CFLAGS_MOD += -DMICROPY_SSL_AXTLS=1 -I$(TOP)/lib/axtls/ssl -I$(TOP)/lib/axtls/crypto -I$(TOP)/extmod/axtls-include
-AXTLS_DIR = lib/axtls
-$(BUILD)/$(AXTLS_DIR)/%.o: CFLAGS += -Wno-all -Wno-unused-parameter -Wno-uninitialized -Wno-sign-compare -Wno-old-style-definition $(AXTLS_DEFS_EXTRA)
-SRC_MOD += $(addprefix $(AXTLS_DIR)/,\
-	ssl/asn1.c \
-	ssl/loader.c \
-	ssl/tls1.c \
-	ssl/tls1_svr.c \
-	ssl/tls1_clnt.c \
-	ssl/x509.c \
-	crypto/aes.c \
-	crypto/bigint.c \
-	crypto/crypto_misc.c \
-	crypto/hmac.c \
-	crypto/md5.c \
-	crypto/rsa.c \
-	crypto/sha1.c \
-	)
-else ifeq ($(MICROPY_SSL_MBEDTLS),1)
-# Can be overridden by ports which have "builtin" mbedTLS
-MICROPY_SSL_MBEDTLS_INCLUDE ?= $(TOP)/lib/mbedtls/include
-CFLAGS_MOD += -DMICROPY_SSL_MBEDTLS=1 -I$(MICROPY_SSL_MBEDTLS_INCLUDE)
-LDFLAGS_MOD += -L$(TOP)/lib/mbedtls/library -lmbedx509 -lmbedtls -lmbedcrypto
-endif
-endif
-
-ifeq ($(MICROPY_PY_LWIP),1)
-# A port should add an include path where lwipopts.h can be found (eg extmod/lwip-include)
-LWIP_DIR = lib/lwip/src
-INC += -I$(TOP)/$(LWIP_DIR)/include
-CFLAGS_MOD += -DMICROPY_PY_LWIP=1
-$(BUILD)/$(LWIP_DIR)/core/ipv4/dhcp.o: CFLAGS_MOD += -Wno-address
-SRC_MOD += extmod/modlwip.c lib/netutils/netutils.c
-SRC_MOD += $(addprefix $(LWIP_DIR)/,\
-	core/def.c \
-	core/dns.c \
-	core/inet_chksum.c \
-	core/init.c \
-	core/ip.c \
-	core/mem.c \
-	core/memp.c \
-	core/netif.c \
-	core/pbuf.c \
-	core/raw.c \
-	core/stats.c \
-	core/sys.c \
-	core/tcp.c \
-	core/tcp_in.c \
-	core/tcp_out.c \
-	core/timeouts.c \
-	core/udp.c \
-	core/ipv4/autoip.c \
-	core/ipv4/dhcp.c \
-	core/ipv4/etharp.c \
-	core/ipv4/icmp.c \
-	core/ipv4/igmp.c \
-	core/ipv4/ip4_addr.c \
-	core/ipv4/ip4.c \
-	core/ipv4/ip4_frag.c \
-	core/ipv6/dhcp6.c \
-	core/ipv6/ethip6.c \
-	core/ipv6/icmp6.c \
-	core/ipv6/inet6.c \
-	core/ipv6/ip6_addr.c \
-	core/ipv6/ip6.c \
-	core/ipv6/ip6_frag.c \
-	core/ipv6/mld6.c \
-	core/ipv6/nd6.c \
-	netif/ethernet.c \
-	)
-ifeq ($(MICROPY_PY_LWIP_SLIP),1)
-CFLAGS_MOD += -DMICROPY_PY_LWIP_SLIP=1
-SRC_MOD += $(LWIP_DIR)/netif/slipif.c
-endif
-endif
-
-ifeq ($(MICROPY_PY_BTREE),1)
-BTREE_DIR = lib/berkeley-db-1.xx
-BTREE_DEFS = -D__DBINTERFACE_PRIVATE=1 -Dmpool_error=printf -Dabort=abort_ "-Dvirt_fd_t=void*" $(BTREE_DEFS_EXTRA)
-INC += -I$(TOP)/$(BTREE_DIR)/PORT/include
-SRC_MOD += extmod/modbtree.c
-SRC_MOD += $(addprefix $(BTREE_DIR)/,\
-btree/bt_close.c \
-btree/bt_conv.c \
-btree/bt_debug.c \
-btree/bt_delete.c \
-btree/bt_get.c \
-btree/bt_open.c \
-btree/bt_overflow.c \
-btree/bt_page.c \
-btree/bt_put.c \
-btree/bt_search.c \
-btree/bt_seq.c \
-btree/bt_split.c \
-btree/bt_utils.c \
-mpool/mpool.c \
-	)
-CFLAGS_MOD += -DMICROPY_PY_BTREE=1
-# we need to suppress certain warnings to get berkeley-db to compile cleanly
-# and we have separate BTREE_DEFS so the definitions don't interfere with other source code
-$(BUILD)/$(BTREE_DIR)/%.o: CFLAGS += -Wno-old-style-definition -Wno-sign-compare -Wno-unused-parameter $(BTREE_DEFS)
-$(BUILD)/extmod/modbtree.o: CFLAGS += $(BTREE_DEFS)
+# Enable building 32-bit code on 64-bit host.
+ifeq ($(MICROPY_FORCE_32BIT),1)
+CC += -m32
+CXX += -m32
+LD += -m32
 endif
 
 # External modules written in C.
 ifneq ($(USER_C_MODULES),)
-# pre-define USERMOD variables as expanded so that variables are immediate 
+# pre-define USERMOD variables as expanded so that variables are immediate
 # expanded as they're added to them
-SRC_USERMOD := 
+SRC_USERMOD :=
 CFLAGS_USERMOD :=
 LDFLAGS_USERMOD :=
 $(foreach module, $(wildcard $(USER_C_MODULES)/*/micropython.mk), \
@@ -154,6 +53,7 @@ PY_CORE_O_BASENAME = $(addprefix py/,\
 	nlrx86.o \
 	nlrx64.o \
 	nlrthumb.o \
+	nlrpowerpc.o \
 	nlrxtensa.o \
 	nlrsetjmp.o \
 	malloc.o \
@@ -184,6 +84,7 @@ PY_CORE_O_BASENAME = $(addprefix py/,\
 	asmxtensa.o \
 	emitnxtensa.o \
 	emitinlinextensa.o \
+	emitnxtensawin.o \
 	formatfloat.o \
 	parsenumbase.o \
 	parsenum.o \
@@ -193,9 +94,12 @@ PY_CORE_O_BASENAME = $(addprefix py/,\
 	runtime_utils.o \
 	scheduler.o \
 	nativeglue.o \
+	pairheap.o \
+	ringbuf.o \
 	stackctrl.o \
 	argcheck.o \
 	warning.o \
+	profile.o \
 	map.o \
 	obj.o \
 	objarray.o \
@@ -264,6 +168,7 @@ PY_CORE_O_BASENAME = $(addprefix py/,\
 	)
 
 PY_EXTMOD_O_BASENAME = \
+	extmod/moduasyncio.o \
 	extmod/moductypes.o \
 	extmod/modujson.o \
 	extmod/modure.o \
@@ -280,6 +185,7 @@ PY_EXTMOD_O_BASENAME = \
 	extmod/machine_pulse.o \
 	extmod/machine_i2c.o \
 	extmod/machine_spi.o \
+	extmod/modbluetooth.o \
 	extmod/modussl_axtls.o \
 	extmod/modussl_mbedtls.o \
 	extmod/modurandom.o \
@@ -288,12 +194,14 @@ PY_EXTMOD_O_BASENAME = \
 	extmod/modwebrepl.o \
 	extmod/modframebuf.o \
 	extmod/vfs.o \
+	extmod/vfs_blockdev.o \
 	extmod/vfs_reader.o \
 	extmod/vfs_posix.o \
 	extmod/vfs_posix_file.o \
 	extmod/vfs_fat.o \
 	extmod/vfs_fat_diskio.o \
 	extmod/vfs_fat_file.o \
+	extmod/vfs_lfs.o \
 	extmod/utime_mphal.o \
 	extmod/uos_dupterm.o \
 	lib/embed/abort_.o \
@@ -306,6 +214,11 @@ PY_EXTMOD_O = $(addprefix $(BUILD)/, $(PY_EXTMOD_O_BASENAME))
 # this is a convenience variable for ports that want core, extmod and frozen code
 PY_O = $(PY_CORE_O) $(PY_EXTMOD_O)
 
+# object file for frozen code specified via a manifest
+ifneq ($(FROZEN_MANIFEST),)
+PY_O += $(BUILD)/$(BUILD)/frozen_content.o
+endif
+
 # object file for frozen files
 ifneq ($(FROZEN_DIR),)
 PY_O += $(BUILD)/$(BUILD)/frozen.o
@@ -336,11 +249,16 @@ MPCONFIGPORT_MK = $(wildcard mpconfigport.mk)
 # created before we run the script to generate the .h
 # Note: we need to protect the qstr names from the preprocessor, so we wrap
 # the lines in "" and then unwrap after the preprocessor is finished.
+# See more information about this process in docs/develop/qstr.rst.
 $(HEADER_BUILD)/qstrdefs.generated.h: $(PY_QSTR_DEFS) $(QSTR_DEFS) $(QSTR_DEFS_COLLECTED) $(PY_SRC)/makeqstrdata.py mpconfigport.h $(MPCONFIGPORT_MK) $(PY_SRC)/mpconfig.h | $(HEADER_BUILD)
 	$(ECHO) "GEN $@"
-	$(Q)cat $(PY_QSTR_DEFS) $(QSTR_DEFS) $(QSTR_DEFS_COLLECTED) | $(SED) 's/^Q(.*)/"&"/' | $(CPP) $(CFLAGS) - | $(SED) 's/^"\(Q(.*)\)"/\1/' > $(HEADER_BUILD)/qstrdefs.preprocessed.h
+	$(Q)$(CAT) $(PY_QSTR_DEFS) $(QSTR_DEFS) $(QSTR_DEFS_COLLECTED) | $(SED) 's/^Q(.*)/"&"/' | $(CPP) $(CFLAGS) - | $(SED) 's/^\"\(Q(.*)\)\"/\1/' > $(HEADER_BUILD)/qstrdefs.preprocessed.h
 	$(Q)$(PYTHON) $(PY_SRC)/makeqstrdata.py $(HEADER_BUILD)/qstrdefs.preprocessed.h > $@
 
+$(HEADER_BUILD)/compressed.data.h: $(HEADER_BUILD)/compressed.collected
+	$(ECHO) "GEN $@"
+	$(Q)$(PYTHON) $(PY_SRC)/makecompresseddata.py $< > $@
+
 # build a list of registered modules for py/objmodule.c.
 $(HEADER_BUILD)/moduledefs.h: $(SRC_QSTR) $(QSTR_GLOBAL_DEPENDENCIES) | $(HEADER_BUILD)/mpversion.h
 	@$(ECHO) "GEN $@"
@@ -348,6 +266,11 @@ $(HEADER_BUILD)/moduledefs.h: $(SRC_QSTR) $(QSTR_GLOBAL_DEPENDENCIES) | $(HEADER
 
 SRC_QSTR += $(HEADER_BUILD)/moduledefs.h
 
+# Standard C functions like memset need to be compiled with special flags so
+# the compiler does not optimise these functions in terms of themselves.
+CFLAGS_BUILTIN ?= -ffreestanding -fno-builtin -fno-lto
+$(BUILD)/lib/libc/string0.o: CFLAGS += $(CFLAGS_BUILTIN)
+
 # Force nlr code to always be compiled with space-saving optimisation so
 # that the function preludes are of a minimal and predictable form.
 $(PY_BUILD)/nlr%.o: CFLAGS += -Os
@@ -365,3 +288,6 @@ $(PY_BUILD)/vm.o: CFLAGS += $(CSUPEROPT)
 # http://hg.python.org/cpython/file/b127046831e2/Python/ceval.c#l828
 # http://www.emulators.com/docs/nx25_nostradamus.htm
 #-fno-crossjumping
+
+# Include rules for extmod related code
+include $(TOP)/extmod/extmod.mk
diff --git a/py/pystack.c b/py/pystack.c
index 552e59d537445..f7323fd7401e7 100644
--- a/py/pystack.c
+++ b/py/pystack.c
@@ -49,7 +49,7 @@ void *mp_pystack_alloc(size_t n_bytes) {
     void *ptr = MP_STATE_THREAD(pystack_cur);
     MP_STATE_THREAD(pystack_cur) += n_bytes;
     #if MP_PYSTACK_DEBUG
-    *(size_t*)(MP_STATE_THREAD(pystack_cur) - MICROPY_PYSTACK_ALIGN) = n_bytes;
+    *(size_t *)(MP_STATE_THREAD(pystack_cur) - MICROPY_PYSTACK_ALIGN) = n_bytes;
     #endif
     return ptr;
 }
diff --git a/py/pystack.h b/py/pystack.h
index 82ac3743d1c65..ea8fddcf2f65b 100644
--- a/py/pystack.h
+++ b/py/pystack.h
@@ -41,21 +41,21 @@ void *mp_pystack_alloc(size_t n_bytes);
 // pointer to the block that was allocated first and it and all subsequently
 // allocated blocks will be freed.
 static inline void mp_pystack_free(void *ptr) {
-    assert((uint8_t*)ptr >= MP_STATE_THREAD(pystack_start));
-    assert((uint8_t*)ptr <= MP_STATE_THREAD(pystack_cur));
+    assert((uint8_t *)ptr >= MP_STATE_THREAD(pystack_start));
+    assert((uint8_t *)ptr <= MP_STATE_THREAD(pystack_cur));
     #if MP_PYSTACK_DEBUG
-    size_t n_bytes_to_free = MP_STATE_THREAD(pystack_cur) - (uint8_t*)ptr;
-    size_t n_bytes = *(size_t*)(MP_STATE_THREAD(pystack_cur) - MICROPY_PYSTACK_ALIGN);
+    size_t n_bytes_to_free = MP_STATE_THREAD(pystack_cur) - (uint8_t *)ptr;
+    size_t n_bytes = *(size_t *)(MP_STATE_THREAD(pystack_cur) - MICROPY_PYSTACK_ALIGN);
     while (n_bytes < n_bytes_to_free) {
-        n_bytes += *(size_t*)(MP_STATE_THREAD(pystack_cur) - n_bytes - MICROPY_PYSTACK_ALIGN);
+        n_bytes += *(size_t *)(MP_STATE_THREAD(pystack_cur) - n_bytes - MICROPY_PYSTACK_ALIGN);
     }
     if (n_bytes != n_bytes_to_free) {
         mp_printf(&mp_plat_print, "mp_pystack_free() failed: %u != %u\n", (uint)n_bytes_to_free,
-            (uint)*(size_t*)(MP_STATE_THREAD(pystack_cur) - MICROPY_PYSTACK_ALIGN));
+            (uint)*(size_t *)(MP_STATE_THREAD(pystack_cur) - MICROPY_PYSTACK_ALIGN));
         assert(0);
     }
     #endif
-    MP_STATE_THREAD(pystack_cur) = (uint8_t*)ptr;
+    MP_STATE_THREAD(pystack_cur) = (uint8_t *)ptr;
 }
 
 static inline void mp_pystack_realloc(void *ptr, size_t n_bytes) {
diff --git a/py/qstr.c b/py/qstr.c
index e6f86401a0316..c14ec5ae0073d 100644
--- a/py/qstr.c
+++ b/py/qstr.c
@@ -31,6 +31,7 @@
 #include "py/mpstate.h"
 #include "py/qstr.h"
 #include "py/gc.h"
+#include "py/runtime.h"
 
 // NOTE: we are using linear arrays to store and search for qstr's (unique strings, interned strings)
 // ultimately we will replace this with a static hash table of some kind
@@ -105,11 +106,11 @@ const qstr_pool_t mp_qstr_const_pool = {
     MICROPY_ALLOC_QSTR_ENTRIES_INIT,
     MP_QSTRnumber_of,   // corresponds to number of strings in array just below
     {
-#ifndef NO_QSTR
+        #ifndef NO_QSTR
 #define QDEF(id, str) str,
-#include "genhdr/qstrdefs.generated.h"
+        #include "genhdr/qstrdefs.generated.h"
 #undef QDEF
-#endif
+        #endif
     },
 };
 
@@ -121,10 +122,10 @@ extern const qstr_pool_t MICROPY_QSTR_EXTRA_POOL;
 #endif
 
 void qstr_init(void) {
-    MP_STATE_VM(last_pool) = (qstr_pool_t*)&CONST_POOL; // we won't modify the const_pool since it has no allocated room left
+    MP_STATE_VM(last_pool) = (qstr_pool_t *)&CONST_POOL; // we won't modify the const_pool since it has no allocated room left
     MP_STATE_VM(qstr_last_chunk) = NULL;
 
-    #if MICROPY_PY_THREAD
+    #if MICROPY_PY_THREAD && !MICROPY_PY_THREAD_GIL
     mp_thread_mutex_init(&MP_STATE_VM(qstr_mutex));
     #endif
 }
@@ -150,7 +151,7 @@ STATIC qstr qstr_add(const byte *q_ptr) {
         // Put a lower bound on the allocation size in case the extra qstr pool has few entries
         new_alloc = MAX(MICROPY_ALLOC_QSTR_ENTRIES_INIT, new_alloc);
         #endif
-        qstr_pool_t *pool = m_new_obj_var_maybe(qstr_pool_t, const char*, new_alloc);
+        qstr_pool_t *pool = m_new_obj_var_maybe(qstr_pool_t, const char *, new_alloc);
         if (pool == NULL) {
             QSTR_EXIT();
             m_malloc_fail(new_alloc);
@@ -172,7 +173,7 @@ STATIC qstr qstr_add(const byte *q_ptr) {
 
 qstr qstr_find_strn(const char *str, size_t str_len) {
     // work out hash of str
-    mp_uint_t str_hash = qstr_compute_hash((const byte*)str, str_len);
+    mp_uint_t str_hash = qstr_compute_hash((const byte *)str, str_len);
 
     // search pools for the data
     for (qstr_pool_t *pool = MP_STATE_VM(last_pool); pool != NULL; pool = pool->prev) {
@@ -192,12 +193,17 @@ qstr qstr_from_str(const char *str) {
 }
 
 qstr qstr_from_strn(const char *str, size_t len) {
-    assert(len < (1 << (8 * MICROPY_QSTR_BYTES_IN_LEN)));
     QSTR_ENTER();
     qstr q = qstr_find_strn(str, len);
     if (q == 0) {
         // qstr does not exist in interned pool so need to add it
 
+        // check that len is not too big
+        if (len >= (1 << (8 * MICROPY_QSTR_BYTES_IN_LEN))) {
+            QSTR_EXIT();
+            mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("name too long"));
+        }
+
         // compute number of bytes needed to intern this string
         size_t n_bytes = MICROPY_QSTR_BYTES_IN_HASH + MICROPY_QSTR_BYTES_IN_LEN + len + 1;
 
@@ -239,7 +245,7 @@ qstr qstr_from_strn(const char *str, size_t len) {
         MP_STATE_VM(qstr_last_used) += n_bytes;
 
         // store the interned strings' data
-        mp_uint_t hash = qstr_compute_hash((const byte*)str, len);
+        mp_uint_t hash = qstr_compute_hash((const byte *)str, len);
         Q_SET_HASH(q_ptr, hash);
         Q_SET_LENGTH(q_ptr, len);
         memcpy(q_ptr + MICROPY_QSTR_BYTES_IN_HASH + MICROPY_QSTR_BYTES_IN_LEN, str, len);
@@ -262,7 +268,7 @@ size_t qstr_len(qstr q) {
 
 const char *qstr_str(qstr q) {
     const byte *qd = find_qstr(q);
-    return (const char*)Q_GET_DATA(qd);
+    return (const char *)Q_GET_DATA(qd);
 }
 
 const byte *qstr_data(qstr q, size_t *len) {
@@ -304,3 +310,78 @@ void qstr_dump_data(void) {
     QSTR_EXIT();
 }
 #endif
+
+#if MICROPY_ROM_TEXT_COMPRESSION
+
+#ifdef NO_QSTR
+
+// If NO_QSTR is set, it means we're doing QSTR extraction.
+// So we won't yet have "genhdr/compressed.data.h"
+
+#else
+
+// Emit the compressed_string_data string.
+#define MP_COMPRESSED_DATA(x) STATIC const char *compressed_string_data = x;
+#define MP_MATCH_COMPRESSED(a, b)
+#include "genhdr/compressed.data.h"
+#undef MP_COMPRESSED_DATA
+#undef MP_MATCH_COMPRESSED
+
+#endif // NO_QSTR
+
+// This implements the "common word" compression scheme (see makecompresseddata.py) where the most
+// common 128 words in error messages are replaced by their index into the list of common words.
+
+// The compressed string data is delimited by setting high bit in the final char of each word.
+// e.g. aaaa<0x80|a>bbbbbb<0x80|b>....
+// This method finds the n'th string.
+STATIC const byte *find_uncompressed_string(uint8_t n) {
+    const byte *c = (byte *)compressed_string_data;
+    while (n > 0) {
+        while ((*c & 0x80) == 0) {
+            ++c;
+        }
+        ++c;
+        --n;
+    }
+    return c;
+}
+
+// Given a compressed string in src, decompresses it into dst.
+// dst must be large enough (use MP_MAX_UNCOMPRESSED_TEXT_LEN+1).
+void mp_decompress_rom_string(byte *dst, const mp_rom_error_text_t src_chr) {
+    // Skip past the 0xff marker.
+    const byte *src = (byte *)src_chr + 1;
+    // Need to add spaces around compressed words, except for the first (i.e. transition from 1<->2).
+    // 0 = start, 1 = compressed, 2 = regular.
+    int state = 0;
+    while (*src) {
+        if ((byte) * src >= 128) {
+            if (state != 0) {
+                *dst++ = ' ';
+            }
+            state = 1;
+
+            // High bit set, replace with common word.
+            const byte *word = find_uncompressed_string(*src & 0x7f);
+            // The word is terminated by the final char having its high bit set.
+            while ((*word & 0x80) == 0) {
+                *dst++ = *word++;
+            }
+            *dst++ = (*word & 0x7f);
+        } else {
+            // Otherwise just copy one char.
+            if (state == 1) {
+                *dst++ = ' ';
+            }
+            state = 2;
+
+            *dst++ = *src;
+        }
+        ++src;
+    }
+    // Add null-terminator.
+    *dst = 0;
+}
+
+#endif // MICROPY_ROM_TEXT_COMPRESSION
diff --git a/py/qstr.h b/py/qstr.h
index f4375ee0e922b..df87217ff323e 100644
--- a/py/qstr.h
+++ b/py/qstr.h
@@ -35,13 +35,13 @@
 // Note: it would be possible to define MP_QSTR_xxx as qstr_from_str_static("xxx")
 // for qstrs that are referenced this way, but you don't want to have them in ROM.
 
-// first entry in enum will be MP_QSTR_NULL=0, which indicates invalid/no qstr
+// first entry in enum will be MP_QSTRnull=0, which indicates invalid/no qstr
 enum {
-#ifndef NO_QSTR
+    #ifndef NO_QSTR
 #define QDEF(id, str) id,
-#include "genhdr/qstrdefs.generated.h"
+    #include "genhdr/qstrdefs.generated.h"
 #undef QDEF
-#endif
+    #endif
     MP_QSTRnumber_of, // no underscore so it can't clash with any of the above
 };
 
@@ -61,7 +61,7 @@ typedef struct _qstr_pool_t {
 void qstr_init(void);
 
 mp_uint_t qstr_compute_hash(const byte *data, size_t len);
-qstr qstr_find_strn(const char *str, size_t str_len); // returns MP_QSTR_NULL if not found
+qstr qstr_find_strn(const char *str, size_t str_len); // returns MP_QSTRnull if not found
 
 qstr qstr_from_str(const char *str);
 qstr qstr_from_strn(const char *str, size_t len);
@@ -74,4 +74,9 @@ const byte *qstr_data(qstr q, size_t *len);
 void qstr_pool_info(size_t *n_pool, size_t *n_qstr, size_t *n_str_data_bytes, size_t *n_total_bytes);
 void qstr_dump_data(void);
 
+#if MICROPY_ROM_TEXT_COMPRESSION
+void mp_decompress_rom_string(byte *dst, mp_rom_error_text_t src);
+#define MP_IS_COMPRESSED_ROM_STRING(s) (*(byte *)(s) == 0xff)
+#endif
+
 #endif // MICROPY_INCLUDED_PY_QSTR_H
diff --git a/py/qstrdefs.h b/py/qstrdefs.h
index 5c8b13b47ebf6..5b4e0dc48e053 100644
--- a/py/qstrdefs.h
+++ b/py/qstrdefs.h
@@ -24,6 +24,8 @@
  * THE SOFTWARE.
  */
 
+// *FORMAT-OFF*
+
 #include "py/mpconfig.h"
 
 // All the qstr definitions in this file are available as constants.
diff --git a/py/reader.c b/py/reader.c
index 80364104bb12b..d68406b1c68b3 100644
--- a/py/reader.c
+++ b/py/reader.c
@@ -29,6 +29,7 @@
 
 #include "py/runtime.h"
 #include "py/mperrno.h"
+#include "py/mpthread.h"
 #include "py/reader.h"
 
 typedef struct _mp_reader_mem_t {
@@ -39,7 +40,7 @@ typedef struct _mp_reader_mem_t {
 } mp_reader_mem_t;
 
 STATIC mp_uint_t mp_reader_mem_readbyte(void *data) {
-    mp_reader_mem_t *reader = (mp_reader_mem_t*)data;
+    mp_reader_mem_t *reader = (mp_reader_mem_t *)data;
     if (reader->cur < reader->end) {
         return *reader->cur++;
     } else {
@@ -48,9 +49,9 @@ STATIC mp_uint_t mp_reader_mem_readbyte(void *data) {
 }
 
 STATIC void mp_reader_mem_close(void *data) {
-    mp_reader_mem_t *reader = (mp_reader_mem_t*)data;
+    mp_reader_mem_t *reader = (mp_reader_mem_t *)data;
     if (reader->free_len > 0) {
-        m_del(char, (char*)reader->beg, reader->free_len);
+        m_del(char, (char *)reader->beg, reader->free_len);
     }
     m_del_obj(mp_reader_mem_t, reader);
 }
@@ -81,12 +82,14 @@ typedef struct _mp_reader_posix_t {
 } mp_reader_posix_t;
 
 STATIC mp_uint_t mp_reader_posix_readbyte(void *data) {
-    mp_reader_posix_t *reader = (mp_reader_posix_t*)data;
+    mp_reader_posix_t *reader = (mp_reader_posix_t *)data;
     if (reader->pos >= reader->len) {
         if (reader->len == 0) {
             return MP_READER_EOF;
         } else {
+            MP_THREAD_GIL_EXIT();
             int n = read(reader->fd, reader->buf, sizeof(reader->buf));
+            MP_THREAD_GIL_ENTER();
             if (n <= 0) {
                 reader->len = 0;
                 return MP_READER_EOF;
@@ -99,9 +102,11 @@ STATIC mp_uint_t mp_reader_posix_readbyte(void *data) {
 }
 
 STATIC void mp_reader_posix_close(void *data) {
-    mp_reader_posix_t *reader = (mp_reader_posix_t*)data;
+    mp_reader_posix_t *reader = (mp_reader_posix_t *)data;
     if (reader->close_fd) {
+        MP_THREAD_GIL_EXIT();
         close(reader->fd);
+        MP_THREAD_GIL_ENTER();
     }
     m_del_obj(mp_reader_posix_t, reader);
 }
@@ -110,13 +115,16 @@ void mp_reader_new_file_from_fd(mp_reader_t *reader, int fd, bool close_fd) {
     mp_reader_posix_t *rp = m_new_obj(mp_reader_posix_t);
     rp->close_fd = close_fd;
     rp->fd = fd;
+    MP_THREAD_GIL_EXIT();
     int n = read(rp->fd, rp->buf, sizeof(rp->buf));
     if (n == -1) {
         if (close_fd) {
             close(fd);
         }
+        MP_THREAD_GIL_ENTER();
         mp_raise_OSError(errno);
     }
+    MP_THREAD_GIL_ENTER();
     rp->len = n;
     rp->pos = 0;
     reader->data = rp;
@@ -127,7 +135,9 @@ void mp_reader_new_file_from_fd(mp_reader_t *reader, int fd, bool close_fd) {
 #if !MICROPY_VFS_POSIX
 // If MICROPY_VFS_POSIX is defined then this function is provided by the VFS layer
 void mp_reader_new_file(mp_reader_t *reader, const char *filename) {
+    MP_THREAD_GIL_EXIT();
     int fd = open(filename, O_RDONLY, 0644);
+    MP_THREAD_GIL_ENTER();
     if (fd < 0) {
         mp_raise_OSError(errno);
     }
diff --git a/py/repl.c b/py/repl.c
index da0fefb3a91dc..c758fc067b2e7 100644
--- a/py/repl.c
+++ b/py/repl.c
@@ -50,7 +50,7 @@ bool mp_repl_continue_with_input(const char *input) {
 
     // check if input starts with a certain keyword
     bool starts_with_compound_keyword =
-           input[0] == '@'
+        input[0] == '@'
         || str_startswith_word(input, "if")
         || str_startswith_word(input, "while")
         || str_startswith_word(input, "for")
@@ -61,7 +61,7 @@ bool mp_repl_continue_with_input(const char *input) {
         #if MICROPY_PY_ASYNC_AWAIT
         || str_startswith_word(input, "async")
         #endif
-        ;
+    ;
 
     // check for unmatched open bracket, quote or escape quote
     #define Q_NONE (0)
@@ -95,13 +95,26 @@ bool mp_repl_continue_with_input(const char *input) {
             }
         } else if (in_quote == Q_NONE) {
             switch (*i) {
-                case '(': n_paren += 1; break;
-                case ')': n_paren -= 1; break;
-                case '[': n_brack += 1; break;
-                case ']': n_brack -= 1; break;
-                case '{': n_brace += 1; break;
-                case '}': n_brace -= 1; break;
-                default: break;
+                case '(':
+                    n_paren += 1;
+                    break;
+                case ')':
+                    n_paren -= 1;
+                    break;
+                case '[':
+                    n_brack += 1;
+                    break;
+                case ']':
+                    n_brack -= 1;
+                    break;
+                case '{':
+                    n_brace += 1;
+                    break;
+                case '}':
+                    n_brace -= 1;
+                    break;
+                default:
+                    break;
             }
         }
     }
@@ -159,7 +172,7 @@ size_t mp_repl_autocomplete(const char *str, size_t len, const mp_print_t *print
         if (str < top) {
             // a complete word, lookup in current object
             qstr q = qstr_find_strn(s_start, s_len);
-            if (q == MP_QSTR_NULL) {
+            if (q == MP_QSTRnull) {
                 // lookup will fail
                 return 0;
             }
@@ -183,7 +196,7 @@ size_t mp_repl_autocomplete(const char *str, size_t len, const mp_print_t *print
             qstr q_first = 0, q_last = 0;
             for (qstr q = MP_QSTR_ + 1; q < nqstr; ++q) {
                 size_t d_len;
-                const char *d_str = (const char*)qstr_data(q, &d_len);
+                const char *d_str = (const char *)qstr_data(q, &d_len);
                 if (s_len <= d_len && strncmp(s_start, d_str, s_len) == 0) {
                     mp_load_method_protected(obj, q, dest, true);
                     if (dest[0] != MP_OBJ_NULL) {
@@ -237,7 +250,7 @@ size_t mp_repl_autocomplete(const char *str, size_t len, const mp_print_t *print
             int line_len = MAX_LINE_LEN; // force a newline for first word
             for (qstr q = q_first; q <= q_last; ++q) {
                 size_t d_len;
-                const char *d_str = (const char*)qstr_data(q, &d_len);
+                const char *d_str = (const char *)qstr_data(q, &d_len);
                 if (s_len <= d_len && strncmp(s_start, d_str, s_len) == 0) {
                     mp_load_method_protected(obj, q, dest, true);
                     if (dest[0] != MP_OBJ_NULL) {
diff --git a/py/ringbuf.c b/py/ringbuf.c
new file mode 100644
index 0000000000000..83887b300b453
--- /dev/null
+++ b/py/ringbuf.c
@@ -0,0 +1,73 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Jim Mussared
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include "ringbuf.h"
+
+int ringbuf_get16(ringbuf_t *r) {
+    int v = ringbuf_peek16(r);
+    if (v == -1) {
+        return v;
+    }
+    r->iget += 2;
+    if (r->iget >= r->size) {
+        r->iget -= r->size;
+    }
+    return v;
+}
+
+int ringbuf_peek16(ringbuf_t *r) {
+    if (r->iget == r->iput) {
+        return -1;
+    }
+    uint32_t iget_a = r->iget + 1;
+    if (iget_a == r->size) {
+        iget_a = 0;
+    }
+    if (iget_a == r->iput) {
+        return -1;
+    }
+    return (r->buf[r->iget] << 8) | (r->buf[iget_a]);
+}
+
+int ringbuf_put16(ringbuf_t *r, uint16_t v) {
+    uint32_t iput_a = r->iput + 1;
+    if (iput_a == r->size) {
+        iput_a = 0;
+    }
+    if (iput_a == r->iget) {
+        return -1;
+    }
+    uint32_t iput_b = iput_a + 1;
+    if (iput_b == r->size) {
+        iput_b = 0;
+    }
+    if (iput_b == r->iget) {
+        return -1;
+    }
+    r->buf[r->iput] = (v >> 8) & 0xff;
+    r->buf[iput_a] = v & 0xff;
+    r->iput = iput_b;
+    return 0;
+}
diff --git a/py/ringbuf.h b/py/ringbuf.h
index b4169270608a5..293e418306051 100644
--- a/py/ringbuf.h
+++ b/py/ringbuf.h
@@ -26,6 +26,13 @@
 #ifndef MICROPY_INCLUDED_PY_RINGBUF_H
 #define MICROPY_INCLUDED_PY_RINGBUF_H
 
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef _MSC_VER
+#include "py/mpconfig.h" // For inline.
+#endif
+
 typedef struct _ringbuf_t {
     uint8_t *buf;
     uint16_t size;
@@ -37,13 +44,13 @@ typedef struct _ringbuf_t {
 // byte buf_array[N];
 // ringbuf_t buf = {buf_array, sizeof(buf_array)};
 
-// Dynamic initialization. This creates root pointer!
+// Dynamic initialization. This needs to become findable as a root pointer!
 #define ringbuf_alloc(r, sz) \
-{ \
-    (r)->buf = m_new(uint8_t, sz); \
-    (r)->size = sz; \
-    (r)->iget = (r)->iput = 0; \
-}
+    { \
+        (r)->buf = m_new(uint8_t, sz); \
+        (r)->size = sz; \
+        (r)->iget = (r)->iput = 0; \
+    }
 
 static inline int ringbuf_get(ringbuf_t *r) {
     if (r->iget == r->iput) {
@@ -69,4 +76,17 @@ static inline int ringbuf_put(ringbuf_t *r, uint8_t v) {
     return 0;
 }
 
+static inline size_t ringbuf_free(ringbuf_t *r) {
+    return (r->size + r->iget - r->iput - 1) % r->size;
+}
+
+static inline size_t ringbuf_avail(ringbuf_t *r) {
+    return (r->size + r->iput - r->iget) % r->size;
+}
+
+// Note: big-endian. No-op if not enough room available for both bytes.
+int ringbuf_get16(ringbuf_t *r);
+int ringbuf_peek16(ringbuf_t *r);
+int ringbuf_put16(ringbuf_t *r, uint16_t v);
+
 #endif // MICROPY_INCLUDED_PY_RINGBUF_H
diff --git a/py/runtime.c b/py/runtime.c
index 75d50596e474f..157bc74a8dfb4 100644
--- a/py/runtime.c
+++ b/py/runtime.c
@@ -25,6 +25,7 @@
  * THE SOFTWARE.
  */
 
+#include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 #include <assert.h>
@@ -34,6 +35,7 @@
 #include "py/objstr.h"
 #include "py/objtuple.h"
 #include "py/objlist.h"
+#include "py/objtype.h"
 #include "py/objmodule.h"
 #include "py/objgenerator.h"
 #include "py/smallint.h"
@@ -53,7 +55,7 @@
 
 const mp_obj_module_t mp_module___main__ = {
     .base = { &mp_type_module },
-    .globals = (mp_obj_dict_t*)&MP_STATE_VM(dict_main),
+    .globals = (mp_obj_dict_t *)&MP_STATE_VM(dict_main),
 };
 
 void mp_init(void) {
@@ -67,9 +69,9 @@ void mp_init(void) {
     MP_STATE_VM(sched_len) = 0;
     #endif
 
-#if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF
+    #if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF
     mp_init_emergency_exception_buf();
-#endif
+    #endif
 
     #if MICROPY_KBD_EXCEPTION
     // initialise the exception object for raising KeyboardInterrupt
@@ -77,17 +79,15 @@ void mp_init(void) {
     MP_STATE_VM(mp_kbd_exception).traceback_alloc = 0;
     MP_STATE_VM(mp_kbd_exception).traceback_len = 0;
     MP_STATE_VM(mp_kbd_exception).traceback_data = NULL;
-    MP_STATE_VM(mp_kbd_exception).args = (mp_obj_tuple_t*)&mp_const_empty_tuple_obj;
+    MP_STATE_VM(mp_kbd_exception).args = (mp_obj_tuple_t *)&mp_const_empty_tuple_obj;
     #endif
 
-    // call port specific initialization if any
-#ifdef MICROPY_PORT_INIT_FUNC
-    MICROPY_PORT_INIT_FUNC;
-#endif
-
     #if MICROPY_ENABLE_COMPILER
     // optimization disabled by default
     MP_STATE_VM(mp_optimise_value) = 0;
+    #if MICROPY_EMIT_NATIVE
+    MP_STATE_VM(default_emit_opt) = MP_EMIT_OPT_NONE;
+    #endif
     #endif
 
     // init global module dict
@@ -118,23 +118,42 @@ void mp_init(void) {
     MP_STATE_VM(vfs_mount_table) = NULL;
     #endif
 
+    #if MICROPY_PY_SYS_ATEXIT
+    MP_STATE_VM(sys_exitfunc) = mp_const_none;
+    #endif
+
+    #if MICROPY_PY_SYS_SETTRACE
+    MP_STATE_THREAD(prof_trace_callback) = MP_OBJ_NULL;
+    MP_STATE_THREAD(prof_callback_is_executing) = false;
+    MP_STATE_THREAD(current_code_state) = NULL;
+    #endif
+
+    #if MICROPY_PY_BLUETOOTH
+    MP_STATE_VM(bluetooth) = MP_OBJ_NULL;
+    #endif
+
     #if MICROPY_PY_THREAD_GIL
     mp_thread_mutex_init(&MP_STATE_VM(gil_mutex));
     #endif
 
+    // call port specific initialization if any
+    #ifdef MICROPY_PORT_INIT_FUNC
+    MICROPY_PORT_INIT_FUNC;
+    #endif
+
     MP_THREAD_GIL_ENTER();
 }
 
 void mp_deinit(void) {
     MP_THREAD_GIL_EXIT();
 
-    //mp_obj_dict_free(&dict_main);
-    //mp_map_deinit(&MP_STATE_VM(mp_loaded_modules_map));
-
     // call port specific deinitialization if any
-#ifdef MICROPY_PORT_DEINIT_FUNC
+    #ifdef MICROPY_PORT_DEINIT_FUNC
     MICROPY_PORT_DEINIT_FUNC;
-#endif
+    #endif
+
+    // mp_obj_dict_free(&dict_main);
+    // mp_map_deinit(&MP_STATE_VM(mp_loaded_modules_map));
 }
 
 mp_obj_t mp_load_name(qstr qst) {
@@ -164,14 +183,13 @@ mp_obj_t mp_load_global(qstr qst) {
             }
         }
         #endif
-        elem = mp_map_lookup((mp_map_t*)&mp_module_builtins_globals.map, MP_OBJ_NEW_QSTR(qst), MP_MAP_LOOKUP);
+        elem = mp_map_lookup((mp_map_t *)&mp_module_builtins_globals.map, MP_OBJ_NEW_QSTR(qst), MP_MAP_LOOKUP);
         if (elem == NULL) {
-            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                mp_raise_msg(&mp_type_NameError, "name not defined");
-            } else {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_NameError,
-                    "name '%q' isn't defined", qst));
-            }
+            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+            mp_raise_msg(&mp_type_NameError, MP_ERROR_TEXT("name not defined"));
+            #else
+            mp_raise_msg_varg(&mp_type_NameError, MP_ERROR_TEXT("name '%q' isn't defined"), qst);
+            #endif
         }
     }
     return elem->value;
@@ -258,7 +276,7 @@ mp_obj_t mp_unary_op(mp_unary_op_t op, mp_obj_t arg) {
         }
         return MP_OBJ_NEW_SMALL_INT(h);
     } else {
-        mp_obj_type_t *type = mp_obj_get_type(arg);
+        const mp_obj_type_t *type = mp_obj_get_type(arg);
         if (type->unary_op != NULL) {
             mp_obj_t result = type->unary_op(op, arg);
             if (result != MP_OBJ_NULL) {
@@ -267,22 +285,22 @@ mp_obj_t mp_unary_op(mp_unary_op_t op, mp_obj_t arg) {
         }
         // With MP_UNARY_OP_INT, mp_unary_op() becomes a fallback for mp_obj_get_int().
         // In this case provide a more focused error message to not confuse, e.g. chr(1.0)
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            if (op == MP_UNARY_OP_INT) {
-                mp_raise_TypeError("can't convert to int");
-            } else {
-                mp_raise_TypeError("unsupported type for operator");
-            }
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        if (op == MP_UNARY_OP_INT) {
+            mp_raise_TypeError(MP_ERROR_TEXT("can't convert to int"));
         } else {
-            if (op == MP_UNARY_OP_INT) {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                    "can't convert %s to int", mp_obj_get_type_str(arg)));
-            } else {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                    "unsupported type for %q: '%s'",
-                    mp_unary_op_method_name[op], mp_obj_get_type_str(arg)));
-            }
+            mp_raise_TypeError(MP_ERROR_TEXT("unsupported type for operator"));
+        }
+        #else
+        if (op == MP_UNARY_OP_INT) {
+            mp_raise_msg_varg(&mp_type_TypeError,
+                MP_ERROR_TEXT("can't convert %s to int"), mp_obj_get_type_str(arg));
+        } else {
+            mp_raise_msg_varg(&mp_type_TypeError,
+                MP_ERROR_TEXT("unsupported type for %q: '%s'"),
+                mp_unary_op_method_name[op], mp_obj_get_type_str(arg));
         }
+        #endif
     }
 }
 
@@ -305,19 +323,8 @@ mp_obj_t mp_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
 
     // deal with == and != for all types
     if (op == MP_BINARY_OP_EQUAL || op == MP_BINARY_OP_NOT_EQUAL) {
-        if (mp_obj_equal(lhs, rhs)) {
-            if (op == MP_BINARY_OP_EQUAL) {
-                return mp_const_true;
-            } else {
-                return mp_const_false;
-            }
-        } else {
-            if (op == MP_BINARY_OP_EQUAL) {
-                return mp_const_false;
-            } else {
-                return mp_const_true;
-            }
-        }
+        // mp_obj_equal_not_equal supports a bunch of shortcuts
+        return mp_obj_equal_not_equal(op, lhs, rhs);
     }
 
     // deal with exception_match for all types
@@ -360,16 +367,22 @@ mp_obj_t mp_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
             //      <<      checked explicitly
             switch (op) {
                 case MP_BINARY_OP_OR:
-                case MP_BINARY_OP_INPLACE_OR: lhs_val |= rhs_val; break;
+                case MP_BINARY_OP_INPLACE_OR:
+                    lhs_val |= rhs_val;
+                    break;
                 case MP_BINARY_OP_XOR:
-                case MP_BINARY_OP_INPLACE_XOR: lhs_val ^= rhs_val; break;
+                case MP_BINARY_OP_INPLACE_XOR:
+                    lhs_val ^= rhs_val;
+                    break;
                 case MP_BINARY_OP_AND:
-                case MP_BINARY_OP_INPLACE_AND: lhs_val &= rhs_val; break;
+                case MP_BINARY_OP_INPLACE_AND:
+                    lhs_val &= rhs_val;
+                    break;
                 case MP_BINARY_OP_LSHIFT:
                 case MP_BINARY_OP_INPLACE_LSHIFT: {
                     if (rhs_val < 0) {
                         // negative shift not allowed
-                        mp_raise_ValueError("negative shift count");
+                        mp_raise_ValueError(MP_ERROR_TEXT("negative shift count"));
                     } else if (rhs_val >= (mp_int_t)BITS_PER_WORD || lhs_val > (MP_SMALL_INT_MAX >> rhs_val) || lhs_val < (MP_SMALL_INT_MIN >> rhs_val)) {
                         // left-shift will overflow, so use higher precision integer
                         lhs = mp_obj_new_int_from_ll(lhs_val);
@@ -384,7 +397,7 @@ mp_obj_t mp_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
                 case MP_BINARY_OP_INPLACE_RSHIFT:
                     if (rhs_val < 0) {
                         // negative shift not allowed
-                        mp_raise_ValueError("negative shift count");
+                        mp_raise_ValueError(MP_ERROR_TEXT("negative shift count"));
                     } else {
                         // standard precision is enough for right-shift
                         if (rhs_val >= (mp_int_t)BITS_PER_WORD) {
@@ -396,9 +409,13 @@ mp_obj_t mp_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
                     }
                     break;
                 case MP_BINARY_OP_ADD:
-                case MP_BINARY_OP_INPLACE_ADD: lhs_val += rhs_val; break;
+                case MP_BINARY_OP_INPLACE_ADD:
+                    lhs_val += rhs_val;
+                    break;
                 case MP_BINARY_OP_SUBTRACT:
-                case MP_BINARY_OP_INPLACE_SUBTRACT: lhs_val -= rhs_val; break;
+                case MP_BINARY_OP_INPLACE_SUBTRACT:
+                    lhs_val -= rhs_val;
+                    break;
                 case MP_BINARY_OP_MULTIPLY:
                 case MP_BINARY_OP_INPLACE_MULTIPLY: {
 
@@ -456,10 +473,9 @@ mp_obj_t mp_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
                 case MP_BINARY_OP_INPLACE_POWER:
                     if (rhs_val < 0) {
                         #if MICROPY_PY_BUILTINS_FLOAT
-                        lhs = mp_obj_new_float(lhs_val);
-                        goto generic_binary_op;
+                        return mp_obj_float_binary_op(op, (mp_float_t)lhs_val, rhs);
                         #else
-                        mp_raise_ValueError("negative power with no float support");
+                        mp_raise_ValueError(MP_ERROR_TEXT("negative power with no float support"));
                         #endif
                     } else {
                         mp_int_t ans = 1;
@@ -499,10 +515,14 @@ mp_obj_t mp_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
                     return MP_OBJ_FROM_PTR(tuple);
                 }
 
-                case MP_BINARY_OP_LESS: return mp_obj_new_bool(lhs_val < rhs_val);
-                case MP_BINARY_OP_MORE: return mp_obj_new_bool(lhs_val > rhs_val);
-                case MP_BINARY_OP_LESS_EQUAL: return mp_obj_new_bool(lhs_val <= rhs_val);
-                case MP_BINARY_OP_MORE_EQUAL: return mp_obj_new_bool(lhs_val >= rhs_val);
+                case MP_BINARY_OP_LESS:
+                    return mp_obj_new_bool(lhs_val < rhs_val);
+                case MP_BINARY_OP_MORE:
+                    return mp_obj_new_bool(lhs_val > rhs_val);
+                case MP_BINARY_OP_LESS_EQUAL:
+                    return mp_obj_new_bool(lhs_val <= rhs_val);
+                case MP_BINARY_OP_MORE_EQUAL:
+                    return mp_obj_new_bool(lhs_val >= rhs_val);
 
                 default:
                     goto unsupported_op;
@@ -513,24 +533,24 @@ mp_obj_t mp_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
             } else {
                 return mp_obj_new_int_from_ll(lhs_val);
             }
-#if MICROPY_PY_BUILTINS_FLOAT
+        #if MICROPY_PY_BUILTINS_FLOAT
         } else if (mp_obj_is_float(rhs)) {
-            mp_obj_t res = mp_obj_float_binary_op(op, lhs_val, rhs);
+            mp_obj_t res = mp_obj_float_binary_op(op, (mp_float_t)lhs_val, rhs);
             if (res == MP_OBJ_NULL) {
                 goto unsupported_op;
             } else {
                 return res;
             }
-#if MICROPY_PY_BUILTINS_COMPLEX
+        #endif
+        #if MICROPY_PY_BUILTINS_COMPLEX
         } else if (mp_obj_is_type(rhs, &mp_type_complex)) {
-            mp_obj_t res = mp_obj_complex_binary_op(op, lhs_val, 0, rhs);
+            mp_obj_t res = mp_obj_complex_binary_op(op, (mp_float_t)lhs_val, 0, rhs);
             if (res == MP_OBJ_NULL) {
                 goto unsupported_op;
             } else {
                 return res;
             }
-#endif
-#endif
+        #endif
         }
     }
 
@@ -543,7 +563,7 @@ mp_obj_t mp_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
     }
 
     // generic binary_op supplied by type
-    mp_obj_type_t *type;
+    const mp_obj_type_t *type;
 generic_binary_op:
     type = mp_obj_get_type(lhs);
     if (type->binary_op != NULL) {
@@ -553,20 +573,21 @@ mp_obj_t mp_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
         }
     }
 
-#if MICROPY_PY_REVERSE_SPECIAL_METHODS
-    if (op >= MP_BINARY_OP_OR && op <= MP_BINARY_OP_REVERSE_POWER) {
+    #if MICROPY_PY_REVERSE_SPECIAL_METHODS
+    if (op >= MP_BINARY_OP_OR && op <= MP_BINARY_OP_POWER) {
         mp_obj_t t = rhs;
         rhs = lhs;
         lhs = t;
-        if (op <= MP_BINARY_OP_POWER) {
-            op += MP_BINARY_OP_REVERSE_OR - MP_BINARY_OP_OR;
-            goto generic_binary_op;
-        }
-
+        op += MP_BINARY_OP_REVERSE_OR - MP_BINARY_OP_OR;
+        goto generic_binary_op;
+    } else if (op >= MP_BINARY_OP_REVERSE_OR) {
         // Convert __rop__ back to __op__ for error message
+        mp_obj_t t = rhs;
+        rhs = lhs;
+        lhs = t;
         op -= MP_BINARY_OP_REVERSE_OR - MP_BINARY_OP_OR;
     }
-#endif
+    #endif
 
     if (op == MP_BINARY_OP_CONTAINS) {
         // If type didn't support containment then explicitly walk the iterator.
@@ -583,16 +604,16 @@ mp_obj_t mp_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
     }
 
 unsupported_op:
-    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-        mp_raise_TypeError("unsupported type for operator");
-    } else {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-            "unsupported types for %q: '%s', '%s'",
-            mp_binary_op_method_name[op], mp_obj_get_type_str(lhs), mp_obj_get_type_str(rhs)));
-    }
+    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+    mp_raise_TypeError(MP_ERROR_TEXT("unsupported type for operator"));
+    #else
+    mp_raise_msg_varg(&mp_type_TypeError,
+        MP_ERROR_TEXT("unsupported types for %q: '%s', '%s'"),
+        mp_binary_op_method_name[op], mp_obj_get_type_str(lhs), mp_obj_get_type_str(rhs));
+    #endif
 
 zero_division:
-    mp_raise_msg(&mp_type_ZeroDivisionError, "divide by zero");
+    mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("divide by zero"));
 }
 
 mp_obj_t mp_call_function_0(mp_obj_t fun) {
@@ -618,19 +639,19 @@ mp_obj_t mp_call_function_n_kw(mp_obj_t fun_in, size_t n_args, size_t n_kw, cons
     DEBUG_OP_printf("calling function %p(n_args=" UINT_FMT ", n_kw=" UINT_FMT ", args=%p)\n", fun_in, n_args, n_kw, args);
 
     // get the type
-    mp_obj_type_t *type = mp_obj_get_type(fun_in);
+    const mp_obj_type_t *type = mp_obj_get_type(fun_in);
 
     // do the call
     if (type->call != NULL) {
         return type->call(fun_in, n_args, n_kw, args);
     }
 
-    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-        mp_raise_TypeError("object not callable");
-    } else {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-            "'%s' object isn't callable", mp_obj_get_type_str(fun_in)));
-    }
+    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+    mp_raise_TypeError(MP_ERROR_TEXT("object not callable"));
+    #else
+    mp_raise_msg_varg(&mp_type_TypeError,
+        MP_ERROR_TEXT("'%s' object isn't callable"), mp_obj_get_type_str(fun_in));
+    #endif
 }
 
 // args contains: fun  self/NULL  arg(0)  ...  arg(n_args-2)  arg(n_args-1)  kw_key(0)  kw_val(0)  ... kw_key(n_kw-1)  kw_val(n_kw-1)
@@ -854,19 +875,17 @@ void mp_unpack_sequence(mp_obj_t seq_in, size_t num, mp_obj_t *items) {
     return;
 
 too_short:
-    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-        mp_raise_ValueError("wrong number of values to unpack");
-    } else {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-            "need more than %d values to unpack", (int)seq_len));
-    }
+    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+    mp_raise_ValueError(MP_ERROR_TEXT("wrong number of values to unpack"));
+    #else
+    mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("need more than %d values to unpack"), (int)seq_len);
+    #endif
 too_long:
-    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-        mp_raise_ValueError("wrong number of values to unpack");
-    } else {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-            "too many values to unpack (expected %d)", (int)num));
-    }
+    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+    mp_raise_ValueError(MP_ERROR_TEXT("wrong number of values to unpack"));
+    #else
+    mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("too many values to unpack (expected %d)"), (int)num);
+    #endif
 }
 
 // unpacked items are stored in reverse order into the array pointed to by items
@@ -876,8 +895,12 @@ void mp_unpack_ex(mp_obj_t seq_in, size_t num_in, mp_obj_t *items) {
     DEBUG_OP_printf("unpack ex " UINT_FMT " " UINT_FMT "\n", num_left, num_right);
     size_t seq_len;
     if (mp_obj_is_type(seq_in, &mp_type_tuple) || mp_obj_is_type(seq_in, &mp_type_list)) {
+        // Make the seq variable volatile so the compiler keeps a reference to it,
+        // since if it's a tuple then seq_items points to the interior of the GC cell
+        // and mp_obj_new_list may trigger a GC which doesn't trace this and reclaims seq.
+        volatile mp_obj_t seq = seq_in;
         mp_obj_t *seq_items;
-        mp_obj_get_array(seq_in, &seq_len, &seq_items);
+        mp_obj_get_array(seq, &seq_len, &seq_items);
         if (seq_len < num_left + num_right) {
             goto too_short;
         }
@@ -888,6 +911,7 @@ void mp_unpack_ex(mp_obj_t seq_in, size_t num_in, mp_obj_t *items) {
         for (size_t i = 0; i < num_left; i++) {
             items[num_right + 1 + i] = seq_items[num_left - 1 - i];
         }
+        seq = MP_OBJ_NULL;
     } else {
         // Generic iterable; this gets a bit messy: we unpack known left length to the
         // items destination array, then the rest to a dynamically created list.  Once the
@@ -918,12 +942,11 @@ void mp_unpack_ex(mp_obj_t seq_in, size_t num_in, mp_obj_t *items) {
     return;
 
 too_short:
-    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-        mp_raise_ValueError("wrong number of values to unpack");
-    } else {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-            "need more than %d values to unpack", (int)seq_len));
-    }
+    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+    mp_raise_ValueError(MP_ERROR_TEXT("wrong number of values to unpack"));
+    #else
+    mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("need more than %d values to unpack"), (int)seq_len);
+    #endif
 }
 
 mp_obj_t mp_load_attr(mp_obj_t base, qstr attr) {
@@ -957,12 +980,12 @@ STATIC mp_obj_t checked_fun_call(mp_obj_t self_in, size_t n_args, size_t n_kw, c
     if (n_args > 0) {
         const mp_obj_type_t *arg0_type = mp_obj_get_type(args[0]);
         if (arg0_type != self->type) {
-            if (MICROPY_ERROR_REPORTING != MICROPY_ERROR_REPORTING_DETAILED) {
-                mp_raise_TypeError("argument has wrong type");
-            } else {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                    "argument should be a '%q' not a '%q'", self->type->name, arg0_type->name));
-            }
+            #if MICROPY_ERROR_REPORTING != MICROPY_ERROR_REPORTING_DETAILED
+            mp_raise_TypeError(MP_ERROR_TEXT("argument has wrong type"));
+            #else
+            mp_raise_msg_varg(&mp_type_TypeError,
+                MP_ERROR_TEXT("argument should be a '%q' not a '%q'"), self->type->name, arg0_type->name);
+            #endif
         }
     }
     return mp_call_function_n_kw(self->fun, n_args, n_kw, args);
@@ -991,7 +1014,7 @@ STATIC mp_obj_t mp_obj_new_checked_fun(const mp_obj_type_t *type, mp_obj_t fun)
 void mp_convert_member_lookup(mp_obj_t self, const mp_obj_type_t *type, mp_obj_t member, mp_obj_t *dest) {
     if (mp_obj_is_type(member, &mp_type_staticmethod)) {
         // return just the function
-        dest[0] = ((mp_obj_static_class_method_t*)MP_OBJ_TO_PTR(member))->fun;
+        dest[0] = ((mp_obj_static_class_method_t *)MP_OBJ_TO_PTR(member))->fun;
     } else if (mp_obj_is_type(member, &mp_type_classmethod)) {
         // return a bound method, with self being the type of this object
         // this type should be the type of the original instance, not the base
@@ -999,26 +1022,28 @@ void mp_convert_member_lookup(mp_obj_t self, const mp_obj_type_t *type, mp_obj_t
         if (self != MP_OBJ_NULL) {
             type = mp_obj_get_type(self);
         }
-        dest[0] = ((mp_obj_static_class_method_t*)MP_OBJ_TO_PTR(member))->fun;
+        dest[0] = ((mp_obj_static_class_method_t *)MP_OBJ_TO_PTR(member))->fun;
         dest[1] = MP_OBJ_FROM_PTR(type);
     } else if (mp_obj_is_type(member, &mp_type_type)) {
         // Don't try to bind types (even though they're callable)
         dest[0] = member;
     } else if (mp_obj_is_fun(member)
-        || (mp_obj_is_obj(member)
-            && (((mp_obj_base_t*)MP_OBJ_TO_PTR(member))->type->name == MP_QSTR_closure
-                || ((mp_obj_base_t*)MP_OBJ_TO_PTR(member))->type->name == MP_QSTR_generator))) {
+               || (mp_obj_is_obj(member)
+                   && (((mp_obj_base_t *)MP_OBJ_TO_PTR(member))->type->name == MP_QSTR_closure
+                       || ((mp_obj_base_t *)MP_OBJ_TO_PTR(member))->type->name == MP_QSTR_generator))) {
         // only functions, closures and generators objects can be bound to self
         #if MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG
-        const mp_obj_type_t *m_type = ((mp_obj_base_t*)MP_OBJ_TO_PTR(member))->type;
+        const mp_obj_type_t *m_type = ((mp_obj_base_t *)MP_OBJ_TO_PTR(member))->type;
         if (self == MP_OBJ_NULL
             && (m_type == &mp_type_fun_builtin_0
                 || m_type == &mp_type_fun_builtin_1
                 || m_type == &mp_type_fun_builtin_2
                 || m_type == &mp_type_fun_builtin_3
-                || m_type == &mp_type_fun_builtin_var)) {
+                || m_type == &mp_type_fun_builtin_var)
+            && type != &mp_type_object) {
             // we extracted a builtin method without a first argument, so we must
             // wrap this function in a type checker
+            // Note that object will do its own checking so shouldn't be wrapped.
             dest[0] = mp_obj_new_checked_fun(type, member);
         } else
         #endif
@@ -1042,17 +1067,18 @@ void mp_load_method_maybe(mp_obj_t obj, qstr attr, mp_obj_t *dest) {
     dest[1] = MP_OBJ_NULL;
 
     // get the type
-    mp_obj_type_t *type = mp_obj_get_type(obj);
+    const mp_obj_type_t *type = mp_obj_get_type(obj);
 
     // look for built-in names
-    if (0) {
-#if MICROPY_CPYTHON_COMPAT
-    } else if (attr == MP_QSTR___class__) {
+    #if MICROPY_CPYTHON_COMPAT
+    if (attr == MP_QSTR___class__) {
         // a.__class__ is equivalent to type(a)
         dest[0] = MP_OBJ_FROM_PTR(type);
-#endif
+        return;
+    }
+    #endif
 
-    } else if (attr == MP_QSTR___next__ && type->iternext != NULL) {
+    if (attr == MP_QSTR___next__ && type->iternext != NULL) {
         dest[0] = MP_OBJ_FROM_PTR(&mp_builtin_next_obj);
         dest[1] = obj;
 
@@ -1079,20 +1105,20 @@ void mp_load_method(mp_obj_t base, qstr attr, mp_obj_t *dest) {
 
     if (dest[0] == MP_OBJ_NULL) {
         // no attribute/method called attr
-        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_raise_msg(&mp_type_AttributeError, "no such attribute");
+        #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+        mp_raise_msg(&mp_type_AttributeError, MP_ERROR_TEXT("no such attribute"));
+        #else
+        // following CPython, we give a more detailed error message for type objects
+        if (mp_obj_is_type(base, &mp_type_type)) {
+            mp_raise_msg_varg(&mp_type_AttributeError,
+                MP_ERROR_TEXT("type object '%q' has no attribute '%q'"),
+                ((mp_obj_type_t *)MP_OBJ_TO_PTR(base))->name, attr);
         } else {
-            // following CPython, we give a more detailed error message for type objects
-            if (mp_obj_is_type(base, &mp_type_type)) {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_AttributeError,
-                    "type object '%q' has no attribute '%q'",
-                    ((mp_obj_type_t*)MP_OBJ_TO_PTR(base))->name, attr));
-            } else {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_AttributeError,
-                    "'%s' object has no attribute '%q'",
-                    mp_obj_get_type_str(base), attr));
-            }
+            mp_raise_msg_varg(&mp_type_AttributeError,
+                MP_ERROR_TEXT("'%s' object has no attribute '%q'"),
+                mp_obj_get_type_str(base), attr);
         }
+        #endif
     }
 }
 
@@ -1104,7 +1130,7 @@ void mp_load_method_protected(mp_obj_t obj, qstr attr, mp_obj_t *dest, bool catc
         nlr_pop();
     } else {
         if (!catch_all_exc
-            && !mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(((mp_obj_base_t*)nlr.ret_val)->type),
+            && !mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(((mp_obj_base_t *)nlr.ret_val)->type),
                 MP_OBJ_FROM_PTR(&mp_type_AttributeError))) {
             // Re-raise the exception
             nlr_raise(MP_OBJ_FROM_PTR(nlr.ret_val));
@@ -1114,7 +1140,7 @@ void mp_load_method_protected(mp_obj_t obj, qstr attr, mp_obj_t *dest, bool catc
 
 void mp_store_attr(mp_obj_t base, qstr attr, mp_obj_t value) {
     DEBUG_OP_printf("store attr %p.%s <- %p\n", base, qstr_str(attr), value);
-    mp_obj_type_t *type = mp_obj_get_type(base);
+    const mp_obj_type_t *type = mp_obj_get_type(base);
     if (type->attr != NULL) {
         mp_obj_t dest[2] = {MP_OBJ_SENTINEL, value};
         type->attr(base, attr, dest);
@@ -1123,18 +1149,18 @@ void mp_store_attr(mp_obj_t base, qstr attr, mp_obj_t value) {
             return;
         }
     }
-    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-        mp_raise_msg(&mp_type_AttributeError, "no such attribute");
-    } else {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_AttributeError,
-            "'%s' object has no attribute '%q'",
-            mp_obj_get_type_str(base), attr));
-    }
+    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+    mp_raise_msg(&mp_type_AttributeError, MP_ERROR_TEXT("no such attribute"));
+    #else
+    mp_raise_msg_varg(&mp_type_AttributeError,
+        MP_ERROR_TEXT("'%s' object has no attribute '%q'"),
+        mp_obj_get_type_str(base), attr);
+    #endif
 }
 
 mp_obj_t mp_getiter(mp_obj_t o_in, mp_obj_iter_buf_t *iter_buf) {
     assert(o_in);
-    mp_obj_type_t *type = mp_obj_get_type(o_in);
+    const mp_obj_type_t *type = mp_obj_get_type(o_in);
 
     // Check for native getiter which is the identity.  We handle this case explicitly
     // so we don't unnecessarily allocate any RAM for the iter_buf, which won't be used.
@@ -1142,13 +1168,13 @@ mp_obj_t mp_getiter(mp_obj_t o_in, mp_obj_iter_buf_t *iter_buf) {
         return o_in;
     }
 
-    // if caller did not provide a buffer then allocate one on the heap
-    if (iter_buf == NULL) {
-        iter_buf = m_new_obj(mp_obj_iter_buf_t);
-    }
-
     // check for native getiter (corresponds to __iter__)
     if (type->getiter != NULL) {
+        if (iter_buf == NULL && type->getiter != mp_obj_instance_getiter) {
+            // if caller did not provide a buffer then allocate one on the heap
+            // mp_obj_instance_getiter is special, it will allocate only if needed
+            iter_buf = m_new_obj(mp_obj_iter_buf_t);
+        }
         mp_obj_t iter = type->getiter(o_in, iter_buf);
         if (iter != MP_OBJ_NULL) {
             return iter;
@@ -1160,22 +1186,27 @@ mp_obj_t mp_getiter(mp_obj_t o_in, mp_obj_iter_buf_t *iter_buf) {
     mp_load_method_maybe(o_in, MP_QSTR___getitem__, dest);
     if (dest[0] != MP_OBJ_NULL) {
         // __getitem__ exists, create and return an iterator
+        if (iter_buf == NULL) {
+            // if caller did not provide a buffer then allocate one on the heap
+            iter_buf = m_new_obj(mp_obj_iter_buf_t);
+        }
         return mp_obj_new_getitem_iter(dest, iter_buf);
     }
 
     // object not iterable
-    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-        mp_raise_TypeError("object not iterable");
-    } else {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-            "'%s' object isn't iterable", mp_obj_get_type_str(o_in)));
-    }
+    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+    mp_raise_TypeError(MP_ERROR_TEXT("object not iterable"));
+    #else
+    mp_raise_msg_varg(&mp_type_TypeError,
+        MP_ERROR_TEXT("'%s' object isn't iterable"), mp_obj_get_type_str(o_in));
+    #endif
+
 }
 
 // may return MP_OBJ_STOP_ITERATION as an optimisation instead of raise StopIteration()
 // may also raise StopIteration()
 mp_obj_t mp_iternext_allow_raise(mp_obj_t o_in) {
-    mp_obj_type_t *type = mp_obj_get_type(o_in);
+    const mp_obj_type_t *type = mp_obj_get_type(o_in);
     if (type->iternext != NULL) {
         return type->iternext(o_in);
     } else {
@@ -1186,12 +1217,12 @@ mp_obj_t mp_iternext_allow_raise(mp_obj_t o_in) {
             // __next__ exists, call it and return its result
             return mp_call_method_n_kw(0, 0, dest);
         } else {
-            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                mp_raise_TypeError("object not an iterator");
-            } else {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                    "'%s' object isn't an iterator", mp_obj_get_type_str(o_in)));
-            }
+            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+            mp_raise_TypeError(MP_ERROR_TEXT("object not an iterator"));
+            #else
+            mp_raise_msg_varg(&mp_type_TypeError,
+                MP_ERROR_TEXT("'%s' object isn't an iterator"), mp_obj_get_type_str(o_in));
+            #endif
         }
     }
 }
@@ -1200,7 +1231,7 @@ mp_obj_t mp_iternext_allow_raise(mp_obj_t o_in) {
 // may raise other exceptions
 mp_obj_t mp_iternext(mp_obj_t o_in) {
     MP_STACK_CHECK(); // enumerate, filter, map and zip can recursively call mp_iternext
-    mp_obj_type_t *type = mp_obj_get_type(o_in);
+    const mp_obj_type_t *type = mp_obj_get_type(o_in);
     if (type->iternext != NULL) {
         return type->iternext(o_in);
     } else {
@@ -1215,19 +1246,19 @@ mp_obj_t mp_iternext(mp_obj_t o_in) {
                 nlr_pop();
                 return ret;
             } else {
-                if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(((mp_obj_base_t*)nlr.ret_val)->type), MP_OBJ_FROM_PTR(&mp_type_StopIteration))) {
+                if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(((mp_obj_base_t *)nlr.ret_val)->type), MP_OBJ_FROM_PTR(&mp_type_StopIteration))) {
                     return MP_OBJ_STOP_ITERATION;
                 } else {
                     nlr_jump(nlr.ret_val);
                 }
             }
         } else {
-            if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-                mp_raise_TypeError("object not an iterator");
-            } else {
-                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
-                    "'%s' object isn't an iterator", mp_obj_get_type_str(o_in)));
-            }
+            #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
+            mp_raise_TypeError(MP_ERROR_TEXT("object not an iterator"));
+            #else
+            mp_raise_msg_varg(&mp_type_TypeError,
+                MP_ERROR_TEXT("'%s' object isn't an iterator"), mp_obj_get_type_str(o_in));
+            #endif
         }
     }
 }
@@ -1235,7 +1266,7 @@ mp_obj_t mp_iternext(mp_obj_t o_in) {
 // TODO: Unclear what to do with StopIterarion exception here.
 mp_vm_return_kind_t mp_resume(mp_obj_t self_in, mp_obj_t send_value, mp_obj_t throw_value, mp_obj_t *ret_val) {
     assert((send_value != MP_OBJ_NULL) ^ (throw_value != MP_OBJ_NULL));
-    mp_obj_type_t *type = mp_obj_get_type(self_in);
+    const mp_obj_type_t *type = mp_obj_get_type(self_in);
 
     if (type == &mp_type_gen_instance) {
         return mp_obj_gen_resume(self_in, send_value, throw_value, ret_val);
@@ -1299,7 +1330,12 @@ mp_vm_return_kind_t mp_resume(mp_obj_t self_in, mp_obj_t send_value, mp_obj_t th
         // will be propagated up. This behavior is approved by test_pep380.py
         // test_delegation_of_close_to_non_generator(),
         //  test_delegating_throw_to_non_generator()
-        *ret_val = mp_make_raise_obj(throw_value);
+        if (mp_obj_exception_match(throw_value, MP_OBJ_FROM_PTR(&mp_type_StopIteration))) {
+            // PEP479: if StopIteration is raised inside a generator it is replaced with RuntimeError
+            *ret_val = mp_obj_new_exception_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("generator raised StopIteration"));
+        } else {
+            *ret_val = mp_make_raise_obj(throw_value);
+        }
         return MP_VM_RETURN_EXCEPTION;
     }
 }
@@ -1317,7 +1353,7 @@ mp_obj_t mp_make_raise_obj(mp_obj_t o) {
         return o;
     } else {
         // o cannot be used as an exception, so return a type error (which will be raised by the caller)
-        return mp_obj_new_exception_msg(&mp_type_TypeError, "exceptions must derive from BaseException");
+        return mp_obj_new_exception_msg(&mp_type_TypeError, MP_ERROR_TEXT("exceptions must derive from BaseException"));
     }
 }
 
@@ -1332,7 +1368,17 @@ mp_obj_t mp_import_name(qstr name, mp_obj_t fromlist, mp_obj_t level) {
     args[3] = fromlist;
     args[4] = level;
 
-    // TODO lookup __import__ and call that instead of going straight to builtin implementation
+    #if MICROPY_CAN_OVERRIDE_BUILTINS
+    // Lookup __import__ and call that if it exists
+    mp_obj_dict_t *bo_dict = MP_STATE_VM(mp_module_builtins_override_dict);
+    if (bo_dict != NULL) {
+        mp_map_elem_t *import = mp_map_lookup(&bo_dict->map, MP_OBJ_NEW_QSTR(MP_QSTR___import__), MP_MAP_LOOKUP);
+        if (import != NULL) {
+            return mp_call_function_n_kw(import->value, 5, 0, args);
+        }
+    }
+    #endif
+
     return mp_builtin___import__(5, args);
 }
 
@@ -1345,8 +1391,8 @@ mp_obj_t mp_import_from(mp_obj_t module, qstr name) {
 
     if (dest[1] != MP_OBJ_NULL) {
         // Hopefully we can't import bound method from an object
-import_error:
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ImportError, "cannot import name %q", name));
+    import_error:
+        mp_raise_msg_varg(&mp_type_ImportError, MP_ERROR_TEXT("can't import name %q"), name);
     }
 
     if (dest[0] != MP_OBJ_NULL) {
@@ -1404,7 +1450,6 @@ void mp_import_all(mp_obj_t module) {
 
 #if MICROPY_ENABLE_COMPILER
 
-// this is implemented in this file so it can optimise access to locals/globals
 mp_obj_t mp_parse_compile_execute(mp_lexer_t *lex, mp_parse_input_kind_t parse_input_kind, mp_obj_dict_t *globals, mp_obj_dict_t *locals) {
     // save context
     mp_obj_dict_t *volatile old_globals = mp_globals_get();
@@ -1418,7 +1463,7 @@ mp_obj_t mp_parse_compile_execute(mp_lexer_t *lex, mp_parse_input_kind_t parse_i
     if (nlr_push(&nlr) == 0) {
         qstr source_name = lex->source_name;
         mp_parse_tree_t parse_tree = mp_parse(lex, parse_input_kind);
-        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, MP_EMIT_OPT_NONE, false);
+        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, false);
 
         mp_obj_t ret;
         if (MICROPY_PY_BUILTINS_COMPILE && globals == NULL) {
@@ -1448,14 +1493,14 @@ NORETURN void m_malloc_fail(size_t num_bytes) {
     DEBUG_printf("memory allocation failed, allocating %u bytes\n", (uint)num_bytes);
     #if MICROPY_ENABLE_GC
     if (gc_is_locked()) {
-        mp_raise_msg(&mp_type_MemoryError, "memory allocation failed, heap is locked");
+        mp_raise_msg(&mp_type_MemoryError, MP_ERROR_TEXT("memory allocation failed, heap is locked"));
     }
     #endif
-    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_MemoryError,
-        "memory allocation failed, allocating %u bytes", (uint)num_bytes));
+    mp_raise_msg_varg(&mp_type_MemoryError,
+        MP_ERROR_TEXT("memory allocation failed, allocating %u bytes"), (uint)num_bytes);
 }
 
-NORETURN void mp_raise_msg(const mp_obj_type_t *exc_type, const char *msg) {
+NORETURN void mp_raise_msg(const mp_obj_type_t *exc_type, mp_rom_error_text_t msg) {
     if (msg == NULL) {
         nlr_raise(mp_obj_new_exception(exc_type));
     } else {
@@ -1463,11 +1508,19 @@ NORETURN void mp_raise_msg(const mp_obj_type_t *exc_type, const char *msg) {
     }
 }
 
-NORETURN void mp_raise_ValueError(const char *msg) {
+NORETURN void mp_raise_msg_varg(const mp_obj_type_t *exc_type, mp_rom_error_text_t fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    mp_obj_t exc = mp_obj_new_exception_msg_vlist(exc_type, fmt, args);
+    va_end(args);
+    nlr_raise(exc);
+}
+
+NORETURN void mp_raise_ValueError(mp_rom_error_text_t msg) {
     mp_raise_msg(&mp_type_ValueError, msg);
 }
 
-NORETURN void mp_raise_TypeError(const char *msg) {
+NORETURN void mp_raise_TypeError(mp_rom_error_text_t msg) {
     mp_raise_msg(&mp_type_TypeError, msg);
 }
 
@@ -1475,7 +1528,7 @@ NORETURN void mp_raise_OSError(int errno_) {
     nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(errno_)));
 }
 
-NORETURN void mp_raise_NotImplementedError(const char *msg) {
+NORETURN void mp_raise_NotImplementedError(mp_rom_error_text_t msg) {
     mp_raise_msg(&mp_type_NotImplementedError, msg);
 }
 
diff --git a/py/runtime.h b/py/runtime.h
index 0eb15d4617322..0bf988b905656 100644
--- a/py/runtime.h
+++ b/py/runtime.h
@@ -64,13 +64,14 @@ extern const byte mp_binary_op_method_name[];
 void mp_init(void);
 void mp_deinit(void);
 
-void mp_handle_pending(void);
+void mp_keyboard_interrupt(void);
+void mp_handle_pending(bool raise_exc);
 void mp_handle_pending_tail(mp_uint_t atomic_state);
 
 #if MICROPY_ENABLE_SCHEDULER
 void mp_sched_lock(void);
 void mp_sched_unlock(void);
-static inline unsigned int mp_sched_num_pending(void) { return MP_STATE_VM(sched_len); }
+#define mp_sched_num_pending() (MP_STATE_VM(sched_len))
 bool mp_sched_schedule(mp_obj_t function, mp_obj_t arg);
 #endif
 
@@ -86,10 +87,18 @@ void mp_arg_parse_all_kw_array(size_t n_pos, size_t n_kw, const mp_obj_t *args,
 NORETURN void mp_arg_error_terse_mismatch(void);
 NORETURN void mp_arg_error_unimpl_kw(void);
 
-static inline mp_obj_dict_t *mp_locals_get(void) { return MP_STATE_THREAD(dict_locals); }
-static inline void mp_locals_set(mp_obj_dict_t *d) { MP_STATE_THREAD(dict_locals) = d; }
-static inline mp_obj_dict_t *mp_globals_get(void) { return MP_STATE_THREAD(dict_globals); }
-static inline void mp_globals_set(mp_obj_dict_t *d) { MP_STATE_THREAD(dict_globals) = d; }
+static inline mp_obj_dict_t *mp_locals_get(void) {
+    return MP_STATE_THREAD(dict_locals);
+}
+static inline void mp_locals_set(mp_obj_dict_t *d) {
+    MP_STATE_THREAD(dict_locals) = d;
+}
+static inline mp_obj_dict_t *mp_globals_get(void) {
+    return MP_STATE_THREAD(dict_globals);
+}
+static inline void mp_globals_set(mp_obj_dict_t *d) {
+    MP_STATE_THREAD(dict_globals) = d;
+}
 
 mp_obj_t mp_load_name(qstr qst);
 mp_obj_t mp_load_global(qstr qst);
@@ -150,11 +159,12 @@ mp_obj_t mp_import_name(qstr name, mp_obj_t fromlist, mp_obj_t level);
 mp_obj_t mp_import_from(mp_obj_t module, qstr name);
 void mp_import_all(mp_obj_t module);
 
-NORETURN void mp_raise_msg(const mp_obj_type_t *exc_type, const char *msg);
-//NORETURN void nlr_raise_msg_varg(const mp_obj_type_t *exc_type, const char *fmt, ...);
-NORETURN void mp_raise_ValueError(const char *msg);
-NORETURN void mp_raise_TypeError(const char *msg);
-NORETURN void mp_raise_NotImplementedError(const char *msg);
+#define mp_raise_type(exc_type) mp_raise_msg(exc_type, NULL)
+NORETURN void mp_raise_msg(const mp_obj_type_t *exc_type, mp_rom_error_text_t msg);
+NORETURN void mp_raise_msg_varg(const mp_obj_type_t *exc_type, mp_rom_error_text_t fmt, ...);
+NORETURN void mp_raise_ValueError(mp_rom_error_text_t msg);
+NORETURN void mp_raise_TypeError(mp_rom_error_text_t msg);
+NORETURN void mp_raise_NotImplementedError(mp_rom_error_text_t msg);
 NORETURN void mp_raise_OSError(int errno_);
 NORETURN void mp_raise_recursion_depth(void);
 
@@ -172,9 +182,6 @@ NORETURN void mp_raise_recursion_depth(void);
 int mp_native_type_from_qstr(qstr qst);
 mp_uint_t mp_native_from_obj(mp_obj_t obj, mp_uint_t type);
 mp_obj_t mp_native_to_obj(mp_uint_t val, mp_uint_t type);
-mp_obj_dict_t *mp_native_swap_globals(mp_obj_dict_t *new_globals);
-mp_obj_t mp_native_call_function_n_kw(mp_obj_t fun_in, size_t n_args_kw, const mp_obj_t *args);
-void mp_native_raise(mp_obj_t o);
 
 #define mp_sys_path (MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_sys_path_obj)))
 #define mp_sys_argv (MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_sys_argv_obj)))
diff --git a/py/runtime0.h b/py/runtime0.h
index efd439196c454..e6eeff97d6868 100644
--- a/py/runtime0.h
+++ b/py/runtime0.h
@@ -28,13 +28,17 @@
 
 // The first four must fit in 8 bits, see emitbc.c
 // The remaining must fit in 16 bits, see scope.h
-#define MP_SCOPE_FLAG_VARARGS      (0x01)
+#define MP_SCOPE_FLAG_ALL_SIG      (0x0f)
+#define MP_SCOPE_FLAG_GENERATOR    (0x01)
 #define MP_SCOPE_FLAG_VARKEYWORDS  (0x02)
-#define MP_SCOPE_FLAG_GENERATOR    (0x04)
+#define MP_SCOPE_FLAG_VARARGS      (0x04)
 #define MP_SCOPE_FLAG_DEFKWARGS    (0x08)
 #define MP_SCOPE_FLAG_REFGLOBALS   (0x10) // used only if native emitter enabled
 #define MP_SCOPE_FLAG_HASCONSTS    (0x20) // used only if native emitter enabled
-#define MP_SCOPE_FLAG_VIPERRET_POS    (6) // 3 bits used for viper return type
+#define MP_SCOPE_FLAG_VIPERRET_POS    (6) // 3 bits used for viper return type, to pass from compiler to native emitter
+#define MP_SCOPE_FLAG_VIPERRELOC   (0x10) // used only when loading viper from .mpy
+#define MP_SCOPE_FLAG_VIPERRODATA  (0x20) // used only when loading viper from .mpy
+#define MP_SCOPE_FLAG_VIPERBSS     (0x40) // used only when loading viper from .mpy
 
 // types for native (viper) function signature
 #define MP_NATIVE_TYPE_OBJ  (0x00)
@@ -46,6 +50,18 @@
 #define MP_NATIVE_TYPE_PTR16 (0x06)
 #define MP_NATIVE_TYPE_PTR32 (0x07)
 
+// Bytecode and runtime boundaries for unary ops
+#define MP_UNARY_OP_NUM_BYTECODE    (MP_UNARY_OP_NOT + 1)
+#define MP_UNARY_OP_NUM_RUNTIME     (MP_UNARY_OP_SIZEOF + 1)
+
+// Bytecode and runtime boundaries for binary ops
+#define MP_BINARY_OP_NUM_BYTECODE   (MP_BINARY_OP_POWER + 1)
+#if MICROPY_PY_REVERSE_SPECIAL_METHODS
+#define MP_BINARY_OP_NUM_RUNTIME    (MP_BINARY_OP_REVERSE_POWER + 1)
+#else
+#define MP_BINARY_OP_NUM_RUNTIME    (MP_BINARY_OP_CONTAINS + 1)
+#endif
+
 typedef enum {
     // These ops may appear in the bytecode. Changing this group
     // in any way requires changing the bytecode version.
@@ -55,22 +71,19 @@ typedef enum {
     MP_UNARY_OP_NOT,
 
     // Following ops cannot appear in the bytecode
-    MP_UNARY_OP_NUM_BYTECODE,
-
-    MP_UNARY_OP_BOOL = MP_UNARY_OP_NUM_BYTECODE, // __bool__
+    MP_UNARY_OP_BOOL, // __bool__
     MP_UNARY_OP_LEN, // __len__
     MP_UNARY_OP_HASH, // __hash__; must return a small int
     MP_UNARY_OP_ABS, // __abs__
     MP_UNARY_OP_INT, // __int__
     MP_UNARY_OP_SIZEOF, // for sys.getsizeof()
-
-    MP_UNARY_OP_NUM_RUNTIME,
 } mp_unary_op_t;
 
-// Note: the first 9+12+12 of these are used in bytecode and changing
-// them requires changing the bytecode version.
 typedef enum {
-    // 9 relational operations, should return a bool
+    // The following 9+13+13 ops are used in bytecode and changing
+    // them requires changing the bytecode version.
+
+    // 9 relational operations, should return a bool; order of first 6 matches corresponding mp_token_kind_t
     MP_BINARY_OP_LESS,
     MP_BINARY_OP_MORE,
     MP_BINARY_OP_EQUAL,
@@ -81,7 +94,7 @@ typedef enum {
     MP_BINARY_OP_IS,
     MP_BINARY_OP_EXCEPTION_MATCH,
 
-    // 12 inplace arithmetic operations
+    // 13 inplace arithmetic operations; order matches corresponding mp_token_kind_t
     MP_BINARY_OP_INPLACE_OR,
     MP_BINARY_OP_INPLACE_XOR,
     MP_BINARY_OP_INPLACE_AND,
@@ -90,12 +103,13 @@ typedef enum {
     MP_BINARY_OP_INPLACE_ADD,
     MP_BINARY_OP_INPLACE_SUBTRACT,
     MP_BINARY_OP_INPLACE_MULTIPLY,
+    MP_BINARY_OP_INPLACE_MAT_MULTIPLY,
     MP_BINARY_OP_INPLACE_FLOOR_DIVIDE,
     MP_BINARY_OP_INPLACE_TRUE_DIVIDE,
     MP_BINARY_OP_INPLACE_MODULO,
     MP_BINARY_OP_INPLACE_POWER,
 
-    // 12 normal arithmetic operations
+    // 13 normal arithmetic operations; order matches corresponding mp_token_kind_t
     MP_BINARY_OP_OR,
     MP_BINARY_OP_XOR,
     MP_BINARY_OP_AND,
@@ -104,6 +118,7 @@ typedef enum {
     MP_BINARY_OP_ADD,
     MP_BINARY_OP_SUBTRACT,
     MP_BINARY_OP_MULTIPLY,
+    MP_BINARY_OP_MAT_MULTIPLY,
     MP_BINARY_OP_FLOOR_DIVIDE,
     MP_BINARY_OP_TRUE_DIVIDE,
     MP_BINARY_OP_MODULO,
@@ -111,11 +126,18 @@ typedef enum {
 
     // Operations below this line don't appear in bytecode, they
     // just identify special methods.
-    MP_BINARY_OP_NUM_BYTECODE,
 
-    // MP_BINARY_OP_REVERSE_* must follow immediately after MP_BINARY_OP_*
-#if MICROPY_PY_REVERSE_SPECIAL_METHODS
-    MP_BINARY_OP_REVERSE_OR = MP_BINARY_OP_NUM_BYTECODE,
+    // This is not emitted by the compiler but is supported by the runtime.
+    // It must follow immediately after MP_BINARY_OP_POWER.
+    MP_BINARY_OP_DIVMOD,
+
+    // The runtime will convert MP_BINARY_OP_IN to this operator with swapped args.
+    // A type should implement this containment operator instead of MP_BINARY_OP_IN.
+    MP_BINARY_OP_CONTAINS,
+
+    // 13 MP_BINARY_OP_REVERSE_* operations must be in the same order as MP_BINARY_OP_*,
+    // and be the last ones supported by the runtime.
+    MP_BINARY_OP_REVERSE_OR,
     MP_BINARY_OP_REVERSE_XOR,
     MP_BINARY_OP_REVERSE_AND,
     MP_BINARY_OP_REVERSE_LSHIFT,
@@ -123,88 +145,15 @@ typedef enum {
     MP_BINARY_OP_REVERSE_ADD,
     MP_BINARY_OP_REVERSE_SUBTRACT,
     MP_BINARY_OP_REVERSE_MULTIPLY,
+    MP_BINARY_OP_REVERSE_MAT_MULTIPLY,
     MP_BINARY_OP_REVERSE_FLOOR_DIVIDE,
     MP_BINARY_OP_REVERSE_TRUE_DIVIDE,
     MP_BINARY_OP_REVERSE_MODULO,
     MP_BINARY_OP_REVERSE_POWER,
-#endif
-
-    // This is not emitted by the compiler but is supported by the runtime
-    MP_BINARY_OP_DIVMOD
-        #if !MICROPY_PY_REVERSE_SPECIAL_METHODS
-        = MP_BINARY_OP_NUM_BYTECODE
-        #endif
-    ,
-
-    // The runtime will convert MP_BINARY_OP_IN to this operator with swapped args.
-    // A type should implement this containment operator instead of MP_BINARY_OP_IN.
-    MP_BINARY_OP_CONTAINS,
-
-    MP_BINARY_OP_NUM_RUNTIME,
 
     // These 2 are not supported by the runtime and must be synthesised by the emitter
     MP_BINARY_OP_NOT_IN,
     MP_BINARY_OP_IS_NOT,
 } mp_binary_op_t;
 
-typedef enum {
-    MP_F_CONST_NONE_OBJ = 0,
-    MP_F_CONST_FALSE_OBJ,
-    MP_F_CONST_TRUE_OBJ,
-    MP_F_CONVERT_OBJ_TO_NATIVE,
-    MP_F_CONVERT_NATIVE_TO_OBJ,
-    MP_F_NATIVE_SWAP_GLOBALS,
-    MP_F_LOAD_NAME,
-    MP_F_LOAD_GLOBAL,
-    MP_F_LOAD_BUILD_CLASS,
-    MP_F_LOAD_ATTR,
-    MP_F_LOAD_METHOD,
-    MP_F_LOAD_SUPER_METHOD,
-    MP_F_STORE_NAME,
-    MP_F_STORE_GLOBAL,
-    MP_F_STORE_ATTR,
-    MP_F_OBJ_SUBSCR,
-    MP_F_OBJ_IS_TRUE,
-    MP_F_UNARY_OP,
-    MP_F_BINARY_OP,
-    MP_F_BUILD_TUPLE,
-    MP_F_BUILD_LIST,
-    MP_F_LIST_APPEND,
-    MP_F_BUILD_MAP,
-    MP_F_STORE_MAP,
-#if MICROPY_PY_BUILTINS_SET
-    MP_F_STORE_SET,
-    MP_F_BUILD_SET,
-#endif
-    MP_F_MAKE_FUNCTION_FROM_RAW_CODE,
-    MP_F_NATIVE_CALL_FUNCTION_N_KW,
-    MP_F_CALL_METHOD_N_KW,
-    MP_F_CALL_METHOD_N_KW_VAR,
-    MP_F_NATIVE_GETITER,
-    MP_F_NATIVE_ITERNEXT,
-    MP_F_NLR_PUSH,
-    MP_F_NLR_POP,
-    MP_F_NATIVE_RAISE,
-    MP_F_IMPORT_NAME,
-    MP_F_IMPORT_FROM,
-    MP_F_IMPORT_ALL,
-#if MICROPY_PY_BUILTINS_SLICE
-    MP_F_NEW_SLICE,
-#endif
-    MP_F_UNPACK_SEQUENCE,
-    MP_F_UNPACK_EX,
-    MP_F_DELETE_NAME,
-    MP_F_DELETE_GLOBAL,
-    MP_F_NEW_CELL,
-    MP_F_MAKE_CLOSURE_FROM_RAW_CODE,
-    MP_F_ARG_CHECK_NUM_SIG,
-    MP_F_SETUP_CODE_STATE,
-    MP_F_SMALL_INT_FLOOR_DIVIDE,
-    MP_F_SMALL_INT_MODULO,
-    MP_F_NATIVE_YIELD_FROM,
-    MP_F_NUMBER_OF,
-} mp_fun_kind_t;
-
-extern const void *const mp_fun_table[MP_F_NUMBER_OF];
-
 #endif // MICROPY_INCLUDED_PY_RUNTIME0_H
diff --git a/py/scheduler.c b/py/scheduler.c
index 5edff45b6fc50..6b138a631b371 100644
--- a/py/scheduler.c
+++ b/py/scheduler.c
@@ -28,44 +28,64 @@
 
 #include "py/runtime.h"
 
+#if MICROPY_KBD_EXCEPTION
+// This function may be called asynchronously at any time so only do the bare minimum.
+void MICROPY_WRAP_MP_KEYBOARD_INTERRUPT(mp_keyboard_interrupt)(void) {
+    MP_STATE_VM(mp_kbd_exception).traceback_data = NULL;
+    MP_STATE_VM(mp_pending_exception) = MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_kbd_exception));
+    #if MICROPY_ENABLE_SCHEDULER
+    if (MP_STATE_VM(sched_state) == MP_SCHED_IDLE) {
+        MP_STATE_VM(sched_state) = MP_SCHED_PENDING;
+    }
+    #endif
+}
+#endif
+
 #if MICROPY_ENABLE_SCHEDULER
 
 #define IDX_MASK(i) ((i) & (MICROPY_SCHEDULER_DEPTH - 1))
 
-static inline bool mp_sched_full(void) {
+// This is a macro so it is guaranteed to be inlined in functions like
+// mp_sched_schedule that may be located in a special memory region.
+#define mp_sched_full() (mp_sched_num_pending() == MICROPY_SCHEDULER_DEPTH)
+
+static inline bool mp_sched_empty(void) {
     MP_STATIC_ASSERT(MICROPY_SCHEDULER_DEPTH <= 255); // MICROPY_SCHEDULER_DEPTH must fit in 8 bits
     MP_STATIC_ASSERT((IDX_MASK(MICROPY_SCHEDULER_DEPTH) == 0)); // MICROPY_SCHEDULER_DEPTH must be a power of 2
 
-    return mp_sched_num_pending() == MICROPY_SCHEDULER_DEPTH;
-}
-
-static inline bool mp_sched_empty(void) {
     return mp_sched_num_pending() == 0;
 }
 
 // A variant of this is inlined in the VM at the pending exception check
-void mp_handle_pending(void) {
+void mp_handle_pending(bool raise_exc) {
     if (MP_STATE_VM(sched_state) == MP_SCHED_PENDING) {
         mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
-        mp_obj_t obj = MP_STATE_VM(mp_pending_exception);
-        if (obj != MP_OBJ_NULL) {
-            MP_STATE_VM(mp_pending_exception) = MP_OBJ_NULL;
-            if (!mp_sched_num_pending()) {
-                MP_STATE_VM(sched_state) = MP_SCHED_IDLE;
+        // Re-check state is still pending now that we're in the atomic section.
+        if (MP_STATE_VM(sched_state) == MP_SCHED_PENDING) {
+            mp_obj_t obj = MP_STATE_VM(mp_pending_exception);
+            if (obj != MP_OBJ_NULL) {
+                MP_STATE_VM(mp_pending_exception) = MP_OBJ_NULL;
+                if (!mp_sched_num_pending()) {
+                    MP_STATE_VM(sched_state) = MP_SCHED_IDLE;
+                }
+                if (raise_exc) {
+                    MICROPY_END_ATOMIC_SECTION(atomic_state);
+                    nlr_raise(obj);
+                }
             }
+            mp_handle_pending_tail(atomic_state);
+        } else {
             MICROPY_END_ATOMIC_SECTION(atomic_state);
-            nlr_raise(obj);
         }
-        mp_handle_pending_tail(atomic_state);
     }
 }
 
-// This function should only be called be mp_sched_handle_pending,
+// This function should only be called by mp_handle_pending,
 // or by the VM's inlined version of that function.
 void mp_handle_pending_tail(mp_uint_t atomic_state) {
     MP_STATE_VM(sched_state) = MP_SCHED_LOCKED;
     if (!mp_sched_empty()) {
-        mp_sched_item_t item = MP_STATE_VM(sched_stack)[MP_STATE_VM(sched_idx)];
+        mp_sched_item_t item = MP_STATE_VM(sched_queue)[MP_STATE_VM(sched_idx)];
         MP_STATE_VM(sched_idx) = IDX_MASK(MP_STATE_VM(sched_idx) + 1);
         --MP_STATE_VM(sched_len);
         MICROPY_END_ATOMIC_SECTION(atomic_state);
@@ -88,6 +108,7 @@ void mp_sched_lock(void) {
 
 void mp_sched_unlock(void) {
     mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
+    assert(MP_STATE_VM(sched_state) < 0);
     if (++MP_STATE_VM(sched_state) == 0) {
         // vm became unlocked
         if (MP_STATE_VM(mp_pending_exception) != MP_OBJ_NULL || mp_sched_num_pending()) {
@@ -99,7 +120,7 @@ void mp_sched_unlock(void) {
     MICROPY_END_ATOMIC_SECTION(atomic_state);
 }
 
-bool mp_sched_schedule(mp_obj_t function, mp_obj_t arg) {
+bool MICROPY_WRAP_MP_SCHED_SCHEDULE(mp_sched_schedule)(mp_obj_t function, mp_obj_t arg) {
     mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
     bool ret;
     if (!mp_sched_full()) {
@@ -107,11 +128,11 @@ bool mp_sched_schedule(mp_obj_t function, mp_obj_t arg) {
             MP_STATE_VM(sched_state) = MP_SCHED_PENDING;
         }
         uint8_t iput = IDX_MASK(MP_STATE_VM(sched_idx) + MP_STATE_VM(sched_len)++);
-        MP_STATE_VM(sched_stack)[iput].func = function;
-        MP_STATE_VM(sched_stack)[iput].arg = arg;
+        MP_STATE_VM(sched_queue)[iput].func = function;
+        MP_STATE_VM(sched_queue)[iput].arg = arg;
         ret = true;
     } else {
-        // schedule stack is full
+        // schedule queue is full
         ret = false;
     }
     MICROPY_END_ATOMIC_SECTION(atomic_state);
@@ -121,11 +142,13 @@ bool mp_sched_schedule(mp_obj_t function, mp_obj_t arg) {
 #else // MICROPY_ENABLE_SCHEDULER
 
 // A variant of this is inlined in the VM at the pending exception check
-void mp_handle_pending(void) {
+void mp_handle_pending(bool raise_exc) {
     if (MP_STATE_VM(mp_pending_exception) != MP_OBJ_NULL) {
         mp_obj_t obj = MP_STATE_VM(mp_pending_exception);
         MP_STATE_VM(mp_pending_exception) = MP_OBJ_NULL;
-        nlr_raise(obj);
+        if (raise_exc) {
+            nlr_raise(obj);
+        }
     }
 }
 
diff --git a/py/scope.c b/py/scope.c
index d996731f85d6b..073c2a38c2c21 100644
--- a/py/scope.c
+++ b/py/scope.c
@@ -30,7 +30,7 @@
 
 #if MICROPY_ENABLE_COMPILER
 
-// these low numbered qstrs should fit in 8 bits
+// These low numbered qstrs should fit in 8 bits.  See assertions below.
 STATIC const uint8_t scope_simple_name_table[] = {
     [SCOPE_MODULE] = MP_QSTR__lt_module_gt_,
     [SCOPE_LAMBDA] = MP_QSTR__lt_lambda_gt_,
@@ -41,13 +41,21 @@ STATIC const uint8_t scope_simple_name_table[] = {
 };
 
 scope_t *scope_new(scope_kind_t kind, mp_parse_node_t pn, qstr source_file, mp_uint_t emit_options) {
+    // Make sure those qstrs indeed fit in an uint8_t.
+    MP_STATIC_ASSERT(MP_QSTR__lt_module_gt_ <= UINT8_MAX);
+    MP_STATIC_ASSERT(MP_QSTR__lt_lambda_gt_ <= UINT8_MAX);
+    MP_STATIC_ASSERT(MP_QSTR__lt_listcomp_gt_ <= UINT8_MAX);
+    MP_STATIC_ASSERT(MP_QSTR__lt_dictcomp_gt_ <= UINT8_MAX);
+    MP_STATIC_ASSERT(MP_QSTR__lt_setcomp_gt_ <= UINT8_MAX);
+    MP_STATIC_ASSERT(MP_QSTR__lt_genexpr_gt_ <= UINT8_MAX);
+
     scope_t *scope = m_new0(scope_t, 1);
     scope->kind = kind;
     scope->pn = pn;
     scope->source_file = source_file;
     if (kind == SCOPE_FUNCTION || kind == SCOPE_CLASS) {
         assert(MP_PARSE_NODE_IS_STRUCT(pn));
-        scope->simple_name = MP_PARSE_NODE_LEAF_ARG(((mp_parse_node_struct_t*)pn)->nodes[0]);
+        scope->simple_name = MP_PARSE_NODE_LEAF_ARG(((mp_parse_node_struct_t *)pn)->nodes[0]);
     } else {
         scope->simple_name = scope_simple_name_table[kind];
     }
diff --git a/py/sequence.c b/py/sequence.c
index c66fde98f64c8..fa660a3384ea5 100644
--- a/py/sequence.c
+++ b/py/sequence.c
@@ -39,85 +39,27 @@ void mp_seq_multiply(const void *items, size_t item_sz, size_t len, size_t times
     for (size_t i = 0; i < times; i++) {
         size_t copy_sz = item_sz * len;
         memcpy(dest, items, copy_sz);
-        dest = (char*)dest + copy_sz;
+        dest = (char *)dest + copy_sz;
     }
 }
 
 #if MICROPY_PY_BUILTINS_SLICE
 
 bool mp_seq_get_fast_slice_indexes(mp_uint_t len, mp_obj_t slice, mp_bound_slice_t *indexes) {
-    mp_obj_t ostart, ostop, ostep;
-    mp_int_t start, stop;
-    mp_obj_slice_get(slice, &ostart, &ostop, &ostep);
+    mp_obj_slice_indices(slice, len, indexes);
 
-    if (ostep != mp_const_none && ostep != MP_OBJ_NEW_SMALL_INT(1)) {
-        indexes->step = mp_obj_get_int(ostep);
-        if (indexes->step == 0) {
-            mp_raise_ValueError("slice step cannot be zero");
-        }
-    } else {
-        indexes->step = 1;
-    }
-
-    if (ostart == mp_const_none) {
-        if (indexes->step > 0) {
-            start = 0;
-        } else {
-            start = len - 1;
-        }
-    } else {
-        start = mp_obj_get_int(ostart);
-    }
-    if (ostop == mp_const_none) {
-        if (indexes->step > 0) {
-            stop = len;
-        } else {
-            stop = 0;
-        }
-    } else {
-        stop = mp_obj_get_int(ostop);
-        if (stop >= 0 && indexes->step < 0) {
-            stop += 1;
-        }
-    }
-
-    // Unlike subscription, out-of-bounds slice indexes are never error
-    if (start < 0) {
-        start = len + start;
-        if (start < 0) {
-            if (indexes->step < 0) {
-                start = -1;
-            } else {
-                start = 0;
-            }
-        }
-    } else if (indexes->step > 0 && (mp_uint_t)start > len) {
-        start = len;
-    } else if (indexes->step < 0 && (mp_uint_t)start >= len) {
-        start = len - 1;
-    }
-    if (stop < 0) {
-        stop = len + stop;
-        if (stop < 0) {
-            stop = -1;
-        }
-        if (indexes->step < 0) {
-            stop += 1;
-        }
-    } else if ((mp_uint_t)stop > len) {
-        stop = len;
+    // If the index is negative then stop points to the last item, not after it
+    if (indexes->step < 0) {
+        indexes->stop++;
     }
 
     // CPython returns empty sequence in such case, or point for assignment is at start
-    if (indexes->step > 0 && start > stop) {
-        stop = start;
-    } else if (indexes->step < 0 && start < stop) {
-        stop = start + 1;
+    if (indexes->step > 0 && indexes->start > indexes->stop) {
+        indexes->stop = indexes->start;
+    } else if (indexes->step < 0 && indexes->start < indexes->stop) {
+        indexes->stop = indexes->start + 1;
     }
 
-    indexes->start = start;
-    indexes->stop = stop;
-
     return indexes->step == 1;
 }
 
@@ -154,7 +96,7 @@ bool mp_seq_cmp_bytes(mp_uint_t op, const byte *data1, size_t len1, const byte *
 
     // Let's deal only with > & >=
     if (op == MP_BINARY_OP_LESS || op == MP_BINARY_OP_LESS_EQUAL) {
-        SWAP(const byte*, data1, data2);
+        SWAP(const byte *, data1, data2);
         SWAP(size_t, len1, len2);
         if (op == MP_BINARY_OP_LESS) {
             op = MP_BINARY_OP_MORE;
@@ -165,7 +107,7 @@ bool mp_seq_cmp_bytes(mp_uint_t op, const byte *data1, size_t len1, const byte *
     size_t min_len = len1 < len2 ? len1 : len2;
     int res = memcmp(data1, data2, min_len);
     if (op == MP_BINARY_OP_EQUAL) {
-        // If we are checking for equality, here're the answer
+        // If we are checking for equality, here's the answer
         return res == 0;
     }
     if (res < 0) {
@@ -221,7 +163,7 @@ bool mp_seq_cmp_objs(mp_uint_t op, const mp_obj_t *items1, size_t len1, const mp
         }
 
         // Otherwise, application of relation op gives the answer
-        return (mp_binary_op(op, items1[i], items2[i]) == mp_const_true);
+        return mp_binary_op(op, items1[i], items2[i]) == mp_const_true;
     }
 
     // If we had tie in the last element...
@@ -241,7 +183,7 @@ bool mp_seq_cmp_objs(mp_uint_t op, const mp_obj_t *items1, size_t len1, const mp
 
 // Special-case of index() which searches for mp_obj_t
 mp_obj_t mp_seq_index_obj(const mp_obj_t *items, size_t len, size_t n_args, const mp_obj_t *args) {
-    mp_obj_type_t *type = mp_obj_get_type(args[0]);
+    const mp_obj_type_t *type = mp_obj_get_type(args[0]);
     mp_obj_t value = args[1];
     size_t start = 0;
     size_t stop = len;
@@ -260,15 +202,15 @@ mp_obj_t mp_seq_index_obj(const mp_obj_t *items, size_t len, size_t n_args, cons
         }
     }
 
-    mp_raise_ValueError("object not in sequence");
+    mp_raise_ValueError(MP_ERROR_TEXT("object not in sequence"));
 }
 
 mp_obj_t mp_seq_count_obj(const mp_obj_t *items, size_t len, mp_obj_t value) {
     size_t count = 0;
     for (size_t i = 0; i < len; i++) {
-         if (mp_obj_equal(items[i], value)) {
-              count++;
-         }
+        if (mp_obj_equal(items[i], value)) {
+            count++;
+        }
     }
 
     // Common sense says this cannot overflow small int
diff --git a/py/showbc.c b/py/showbc.c
index b9024b716de67..4d6527fae2e45 100644
--- a/py/showbc.c
+++ b/py/showbc.c
@@ -36,10 +36,10 @@
 #define printf(...) mp_printf(&mp_plat_print, __VA_ARGS__)
 
 #define DECODE_UINT { \
-    unum = 0; \
-    do { \
-        unum = (unum << 7) + (*ip & 0x7f); \
-    } while ((*ip++ & 0x80) != 0); \
+        unum = 0; \
+        do { \
+            unum = (unum << 7) + (*ip & 0x7f); \
+        } while ((*ip++ & 0x80) != 0); \
 }
 #define DECODE_ULABEL do { unum = (ip[0] | (ip[1] << 8)); ip += 2; } while (0)
 #define DECODE_SLABEL do { unum = (ip[0] | (ip[1] << 8)) - 0x8000; ip += 2; } while (0)
@@ -59,20 +59,20 @@
 #else
 
 #define DECODE_QSTR { \
-    qst = 0; \
-    do { \
-        qst = (qst << 7) + (*ip & 0x7f); \
-    } while ((*ip++ & 0x80) != 0); \
+        qst = 0; \
+        do { \
+            qst = (qst << 7) + (*ip & 0x7f); \
+        } while ((*ip++ & 0x80) != 0); \
 }
 #define DECODE_PTR do { \
-    ip = (byte*)MP_ALIGN(ip, sizeof(void*)); \
-    unum = (uintptr_t)*(void**)ip; \
-    ip += sizeof(void*); \
+        ip = (byte *)MP_ALIGN(ip, sizeof(void *)); \
+        unum = (uintptr_t)*(void **)ip; \
+        ip += sizeof(void *); \
 } while (0)
 #define DECODE_OBJ do { \
-    ip = (byte*)MP_ALIGN(ip, sizeof(mp_obj_t)); \
-    unum = (mp_uint_t)*(mp_obj_t*)ip; \
-    ip += sizeof(mp_obj_t); \
+        ip = (byte *)MP_ALIGN(ip, sizeof(mp_obj_t)); \
+        unum = (mp_uint_t)*(mp_obj_t *)ip; \
+        ip += sizeof(mp_obj_t); \
 } while (0)
 
 #endif
@@ -83,17 +83,10 @@ const mp_uint_t *mp_showbc_const_table;
 void mp_bytecode_print(const void *descr, const byte *ip, mp_uint_t len, const mp_uint_t *const_table) {
     mp_showbc_code_start = ip;
 
-    // get bytecode parameters
-    mp_uint_t n_state = mp_decode_uint(&ip);
-    mp_uint_t n_exc_stack = mp_decode_uint(&ip);
-    /*mp_uint_t scope_flags =*/ ip++;
-    mp_uint_t n_pos_args = *ip++;
-    mp_uint_t n_kwonly_args = *ip++;
-    /*mp_uint_t n_def_pos_args =*/ ip++;
-
+    // Decode prelude
+    MP_BC_PRELUDE_SIG_DECODE(ip);
+    MP_BC_PRELUDE_SIZE_DECODE(ip);
     const byte *code_info = ip;
-    mp_uint_t code_info_size = mp_decode_uint(&code_info);
-    ip += code_info_size;
 
     #if MICROPY_PERSISTENT_CODE
     qstr block_name = code_info[0] | (code_info[1] << 8);
@@ -107,7 +100,9 @@ void mp_bytecode_print(const void *descr, const byte *ip, mp_uint_t len, const m
         qstr_str(source_file), qstr_str(block_name), descr, mp_showbc_code_start, len);
 
     // raw bytecode dump
-    printf("Raw bytecode (code_info_size=" UINT_FMT ", bytecode_size=" UINT_FMT "):\n", code_info_size, len - code_info_size);
+    size_t prelude_size = ip - mp_showbc_code_start + n_info + n_cell;
+    printf("Raw bytecode (code_info_size=" UINT_FMT ", bytecode_size=" UINT_FMT "):\n",
+        prelude_size, len - prelude_size);
     for (mp_uint_t i = 0; i < len; i++) {
         if (i > 0 && i % 16 == 0) {
             printf("\n");
@@ -123,27 +118,24 @@ void mp_bytecode_print(const void *descr, const byte *ip, mp_uint_t len, const m
     }
     printf("\n");
 
-    printf("(N_STATE " UINT_FMT ")\n", n_state);
-    printf("(N_EXC_STACK " UINT_FMT ")\n", n_exc_stack);
+    printf("(N_STATE %u)\n", (unsigned)n_state);
+    printf("(N_EXC_STACK %u)\n", (unsigned)n_exc_stack);
 
-    // for printing line number info
-    const byte *bytecode_start = ip;
+    // skip over code_info
+    ip += n_info;
 
     // bytecode prelude: initialise closed over variables
-    {
-        uint local_num;
-        while ((local_num = *ip++) != 255) {
-            printf("(INIT_CELL %u)\n", local_num);
-        }
-        len -= ip - mp_showbc_code_start;
+    for (size_t i = 0; i < n_cell; ++i) {
+        uint local_num = *ip++;
+        printf("(INIT_CELL %u)\n", local_num);
     }
 
     // print out line number info
     {
-        mp_int_t bc = bytecode_start - ip;
+        mp_int_t bc = 0;
         mp_uint_t source_line = 1;
         printf("  bc=" INT_FMT " line=" UINT_FMT "\n", bc, source_line);
-        for (const byte* ci = code_info; *ci;) {
+        for (const byte *ci = code_info; *ci;) {
             if ((ci[0] & 0x80) == 0) {
                 // 0b0LLBBBBB encoding
                 bc += ci[0] & 0x1f;
@@ -158,7 +150,7 @@ void mp_bytecode_print(const void *descr, const byte *ip, mp_uint_t len, const m
             printf("  bc=" INT_FMT " line=" UINT_FMT "\n", bc, source_line);
         }
     }
-    mp_bytecode_print2(ip, len - 0, const_table);
+    mp_bytecode_print2(ip, len - prelude_size, const_table);
 }
 
 const byte *mp_bytecode_print_str(const byte *ip) {
@@ -430,12 +422,12 @@ const byte *mp_bytecode_print_str(const byte *ip) {
             printf("BUILD_SET " UINT_FMT, unum);
             break;
 
-#if MICROPY_PY_BUILTINS_SLICE
+        #if MICROPY_PY_BUILTINS_SLICE
         case MP_BC_BUILD_SLICE:
             DECODE_UINT;
             printf("BUILD_SLICE " UINT_FMT, unum);
             break;
-#endif
+        #endif
 
         case MP_BC_STORE_COMP:
             DECODE_UINT;
@@ -454,25 +446,25 @@ const byte *mp_bytecode_print_str(const byte *ip) {
 
         case MP_BC_MAKE_FUNCTION:
             DECODE_PTR;
-            printf("MAKE_FUNCTION %p", (void*)(uintptr_t)unum);
+            printf("MAKE_FUNCTION %p", (void *)(uintptr_t)unum);
             break;
 
         case MP_BC_MAKE_FUNCTION_DEFARGS:
             DECODE_PTR;
-            printf("MAKE_FUNCTION_DEFARGS %p", (void*)(uintptr_t)unum);
+            printf("MAKE_FUNCTION_DEFARGS %p", (void *)(uintptr_t)unum);
             break;
 
         case MP_BC_MAKE_CLOSURE: {
             DECODE_PTR;
             mp_uint_t n_closed_over = *ip++;
-            printf("MAKE_CLOSURE %p " UINT_FMT, (void*)(uintptr_t)unum, n_closed_over);
+            printf("MAKE_CLOSURE %p " UINT_FMT, (void *)(uintptr_t)unum, n_closed_over);
             break;
         }
 
         case MP_BC_MAKE_CLOSURE_DEFARGS: {
             DECODE_PTR;
             mp_uint_t n_closed_over = *ip++;
-            printf("MAKE_CLOSURE_DEFARGS %p " UINT_FMT, (void*)(uintptr_t)unum, n_closed_over);
+            printf("MAKE_CLOSURE_DEFARGS %p " UINT_FMT, (void *)(uintptr_t)unum, n_closed_over);
             break;
         }
 
@@ -500,9 +492,16 @@ const byte *mp_bytecode_print_str(const byte *ip) {
             printf("RETURN_VALUE");
             break;
 
-        case MP_BC_RAISE_VARARGS:
-            unum = *ip++;
-            printf("RAISE_VARARGS " UINT_FMT, unum);
+        case MP_BC_RAISE_LAST:
+            printf("RAISE_LAST");
+            break;
+
+        case MP_BC_RAISE_OBJ:
+            printf("RAISE_OBJ");
+            break;
+
+        case MP_BC_RAISE_FROM:
+            printf("RAISE_FROM");
             break;
 
         case MP_BC_YIELD_VALUE:
@@ -540,7 +539,7 @@ const byte *mp_bytecode_print_str(const byte *ip) {
                 mp_uint_t op = ip[-1] - MP_BC_BINARY_OP_MULTI;
                 printf("BINARY_OP " UINT_FMT " %s", op, qstr_str(mp_binary_op_method_name[op]));
             } else {
-                printf("code %p, byte code 0x%02x not implemented\n", ip, ip[-1]);
+                printf("code %p, byte code 0x%02x not implemented\n", ip - 1, ip[-1]);
                 assert(0);
                 return ip;
             }
diff --git a/py/stackctrl.c b/py/stackctrl.c
index 5c07796bde399..c2f3adb5eedcd 100644
--- a/py/stackctrl.c
+++ b/py/stackctrl.c
@@ -29,7 +29,7 @@
 
 void mp_stack_ctrl_init(void) {
     volatile int stack_dummy;
-    MP_STATE_THREAD(stack_top) = (char*)&stack_dummy;
+    MP_STATE_THREAD(stack_top) = (char *)&stack_dummy;
 }
 
 void mp_stack_set_top(void *top) {
@@ -39,7 +39,7 @@ void mp_stack_set_top(void *top) {
 mp_uint_t mp_stack_usage(void) {
     // Assumes descending stack
     volatile int stack_dummy;
-    return MP_STATE_THREAD(stack_top) - (char*)&stack_dummy;
+    return MP_STATE_THREAD(stack_top) - (char *)&stack_dummy;
 }
 
 #if MICROPY_STACK_CHECK
diff --git a/py/stream.c b/py/stream.c
index 762cd0fc08cf1..dce64a44dbeda 100644
--- a/py/stream.c
+++ b/py/stream.c
@@ -85,14 +85,14 @@ mp_uint_t mp_stream_rw(mp_obj_t stream, void *buf_, mp_uint_t size, int *errcode
 }
 
 const mp_stream_p_t *mp_get_stream_raise(mp_obj_t self_in, int flags) {
-    mp_obj_type_t *type = mp_obj_get_type(self_in);
+    const mp_obj_type_t *type = mp_obj_get_type(self_in);
     const mp_stream_p_t *stream_p = type->protocol;
     if (stream_p == NULL
         || ((flags & MP_STREAM_OP_READ) && stream_p->read == NULL)
         || ((flags & MP_STREAM_OP_WRITE) && stream_p->write == NULL)
         || ((flags & MP_STREAM_OP_IOCTL) && stream_p->ioctl == NULL)) {
         // CPython: io.UnsupportedOperation, OSError subclass
-        mp_raise_msg(&mp_type_OSError, "stream operation not supported");
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("stream operation not supported"));
     }
     return stream_p;
 }
@@ -227,7 +227,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_read1_obj, 1, 2, stream_read1);
 
 mp_obj_t mp_stream_write(mp_obj_t self_in, const void *buf, size_t len, byte flags) {
     int error;
-    mp_uint_t out_sz = mp_stream_rw(self_in, (void*)buf, len, &error, flags);
+    mp_uint_t out_sz = mp_stream_rw(self_in, (void *)buf, len, &error, flags);
     if (error != 0) {
         if (mp_is_nonblocking_error(error)) {
             // http://docs.python.org/3/library/io.html#io.RawIOBase.write
@@ -261,7 +261,7 @@ STATIC mp_obj_t stream_write_method(size_t n_args, const mp_obj_t *args) {
         }
     }
     bufinfo.len -= off;
-    return mp_stream_write(args[0], (byte*)bufinfo.buf + off, MIN(bufinfo.len, max_len), MP_STREAM_RW_WRITE);
+    return mp_stream_write(args[0], (byte *)bufinfo.buf + off, MIN(bufinfo.len, max_len), MP_STREAM_RW_WRITE);
 }
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_write_obj, 2, 4, stream_write_method);
 
@@ -378,7 +378,7 @@ STATIC mp_obj_t stream_unbuffered_readline(size_t n_args, const mp_obj_t *args)
             mp_raise_OSError(error);
         }
         if (out_sz == 0) {
-done:
+        done:
             // Back out previously added byte
             // Consider, what's better - read a char and get OutOfMemory (so read
             // char is lost), or allocate first as we do.
@@ -503,14 +503,12 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_ioctl_obj, 2, 3, stream_ioctl);
  * POSIX-compatible software to work with MicroPython streams.
  */
 
-// errno-like variable. If any of the functions below returned with error
-// status, this variable will contain error no.
-int mp_stream_errno;
+#include <errno.h>
 
 ssize_t mp_stream_posix_write(void *stream, const void *buf, size_t len) {
-    mp_obj_base_t* o = stream;
+    mp_obj_base_t *o = stream;
     const mp_stream_p_t *stream_p = o->type->protocol;
-    mp_uint_t out_sz = stream_p->write(MP_OBJ_FROM_PTR(stream), buf, len, &mp_stream_errno);
+    mp_uint_t out_sz = stream_p->write(MP_OBJ_FROM_PTR(stream), buf, len, &errno);
     if (out_sz == MP_STREAM_ERROR) {
         return -1;
     } else {
@@ -519,9 +517,9 @@ ssize_t mp_stream_posix_write(void *stream, const void *buf, size_t len) {
 }
 
 ssize_t mp_stream_posix_read(void *stream, void *buf, size_t len) {
-    mp_obj_base_t* o = stream;
+    mp_obj_base_t *o = stream;
     const mp_stream_p_t *stream_p = o->type->protocol;
-    mp_uint_t out_sz = stream_p->read(MP_OBJ_FROM_PTR(stream), buf, len, &mp_stream_errno);
+    mp_uint_t out_sz = stream_p->read(MP_OBJ_FROM_PTR(stream), buf, len, &errno);
     if (out_sz == MP_STREAM_ERROR) {
         return -1;
     } else {
@@ -530,12 +528,12 @@ ssize_t mp_stream_posix_read(void *stream, void *buf, size_t len) {
 }
 
 off_t mp_stream_posix_lseek(void *stream, off_t offset, int whence) {
-    const mp_obj_base_t* o = stream;
+    const mp_obj_base_t *o = stream;
     const mp_stream_p_t *stream_p = o->type->protocol;
     struct mp_stream_seek_t seek_s;
     seek_s.offset = offset;
     seek_s.whence = whence;
-    mp_uint_t res = stream_p->ioctl(MP_OBJ_FROM_PTR(stream), MP_STREAM_SEEK, (mp_uint_t)(uintptr_t)&seek_s, &mp_stream_errno);
+    mp_uint_t res = stream_p->ioctl(MP_OBJ_FROM_PTR(stream), MP_STREAM_SEEK, (mp_uint_t)(uintptr_t)&seek_s, &errno);
     if (res == MP_STREAM_ERROR) {
         return -1;
     }
@@ -543,9 +541,9 @@ off_t mp_stream_posix_lseek(void *stream, off_t offset, int whence) {
 }
 
 int mp_stream_posix_fsync(void *stream) {
-    mp_obj_base_t* o = stream;
+    mp_obj_base_t *o = stream;
     const mp_stream_p_t *stream_p = o->type->protocol;
-    mp_uint_t res = stream_p->ioctl(MP_OBJ_FROM_PTR(stream), MP_STREAM_FLUSH, 0, &mp_stream_errno);
+    mp_uint_t res = stream_p->ioctl(MP_OBJ_FROM_PTR(stream), MP_STREAM_FLUSH, 0, &errno);
     if (res == MP_STREAM_ERROR) {
         return -1;
     }
diff --git a/py/stream.h b/py/stream.h
index f4c6d30bdce1d..45f36ef5a6f39 100644
--- a/py/stream.h
+++ b/py/stream.h
@@ -4,6 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2014-2016 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -44,10 +45,11 @@
 #define MP_STREAM_GET_FILENO    (10) // Get fileno of underlying file
 
 // These poll ioctl values are compatible with Linux
-#define MP_STREAM_POLL_RD  (0x0001)
-#define MP_STREAM_POLL_WR  (0x0004)
-#define MP_STREAM_POLL_ERR (0x0008)
-#define MP_STREAM_POLL_HUP (0x0010)
+#define MP_STREAM_POLL_RD       (0x0001)
+#define MP_STREAM_POLL_WR       (0x0004)
+#define MP_STREAM_POLL_ERR      (0x0008)
+#define MP_STREAM_POLL_HUP      (0x0010)
+#define MP_STREAM_POLL_NVAL     (0x0020)
 
 // Argument structure for MP_STREAM_SEEK
 struct mp_stream_seek_t {
@@ -93,7 +95,7 @@ MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_ioctl_obj);
 
 // Object is assumed to have a non-NULL stream protocol with valid r/w/ioctl methods
 static inline const mp_stream_p_t *mp_get_stream(mp_const_obj_t self) {
-    return (const mp_stream_p_t*)((const mp_obj_base_t*)MP_OBJ_TO_PTR(self))->type->protocol;
+    return (const mp_stream_p_t *)((const mp_obj_base_t *)MP_OBJ_TO_PTR(self))->type->protocol;
 }
 
 const mp_stream_p_t *mp_get_stream_raise(mp_obj_t self_in, int flags);
@@ -109,12 +111,13 @@ mp_obj_t mp_stream_write(mp_obj_t self_in, const void *buf, size_t len, byte fla
 #define MP_STREAM_RW_WRITE 2
 #define MP_STREAM_RW_ONCE  1
 mp_uint_t mp_stream_rw(mp_obj_t stream, void *buf, mp_uint_t size, int *errcode, byte flags);
-#define mp_stream_write_exactly(stream, buf, size, err) mp_stream_rw(stream, (byte*)buf, size, err, MP_STREAM_RW_WRITE)
+#define mp_stream_write_exactly(stream, buf, size, err) mp_stream_rw(stream, (byte *)buf, size, err, MP_STREAM_RW_WRITE)
 #define mp_stream_read_exactly(stream, buf, size, err) mp_stream_rw(stream, buf, size, err, MP_STREAM_RW_READ)
 
 void mp_stream_write_adaptor(void *self, const char *buf, size_t len);
 
 #if MICROPY_STREAMS_POSIX_API
+#include <sys/types.h>
 // Functions with POSIX-compatible signatures
 // "stream" is assumed to be a pointer to a concrete object with the stream protocol
 ssize_t mp_stream_posix_write(void *stream, const void *buf, size_t len);
diff --git a/py/unicode.c b/py/unicode.c
index d69b6f56f0fde..5acaad378843c 100644
--- a/py/unicode.c
+++ b/py/unicode.c
@@ -71,7 +71,9 @@ STATIC const uint8_t attr[] = {
 
 unichar utf8_get_char(const byte *s) {
     unichar ord = *s++;
-    if (!UTF8_IS_NONASCII(ord)) return ord;
+    if (!UTF8_IS_NONASCII(ord)) {
+        return ord;
+    }
     ord &= 0x7F;
     for (unichar mask = 0x40; ord & mask; mask >>= 1) {
         ord &= ~mask;
@@ -140,6 +142,10 @@ bool unichar_isident(unichar c) {
     return c < 128 && ((attr[c] & (FL_ALPHA | FL_DIGIT)) != 0 || c == '_');
 }
 
+bool unichar_isalnum(unichar c) {
+    return c < 128 && ((attr[c] & (FL_ALPHA | FL_DIGIT)) != 0);
+}
+
 bool unichar_isupper(unichar c) {
     return c < 128 && (attr[c] & FL_UPPER) != 0;
 }
diff --git a/py/vm.c b/py/vm.c
index 901a23f225f05..f30aed8ff1e36 100644
--- a/py/vm.c
+++ b/py/vm.c
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2013-2019 Damien P. George
  * Copyright (c) 2014-2015 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -34,6 +34,9 @@
 #include "py/runtime.h"
 #include "py/bc0.h"
 #include "py/bc.h"
+#include "py/profile.h"
+
+// *FORMAT-OFF*
 
 #if 0
 #define TRACE(ip) printf("sp=%d ", (int)(sp - &code_state->state[0] + 1)); mp_bytecode_print2(ip, 1, code_state->fun_bc->const_table);
@@ -108,6 +111,87 @@
     exc_sp--; /* pop back to previous exception handler */ \
     CLEAR_SYS_EXC_INFO() /* just clear sys.exc_info(), not compliant, but it shouldn't be used in 1st place */
 
+#define CANCEL_ACTIVE_FINALLY(sp) do { \
+    if (mp_obj_is_small_int(sp[-1])) { \
+        /* Stack: (..., prev_dest_ip, prev_cause, dest_ip) */ \
+        /* Cancel the unwind through the previous finally, replace with current one */ \
+        sp[-2] = sp[0]; \
+        sp -= 2; \
+    } else { \
+        assert(sp[-1] == mp_const_none || mp_obj_is_exception_instance(sp[-1])); \
+        /* Stack: (..., None/exception, dest_ip) */ \
+        /* Silence the finally's exception value (may be None or an exception) */ \
+        sp[-1] = sp[0]; \
+        --sp; \
+    } \
+} while (0)
+
+#if MICROPY_PY_SYS_SETTRACE
+
+#define FRAME_SETUP() do { \
+    assert(code_state != code_state->prev_state); \
+    MP_STATE_THREAD(current_code_state) = code_state; \
+    assert(code_state != code_state->prev_state); \
+} while(0)
+
+#define FRAME_ENTER() do { \
+    assert(code_state != code_state->prev_state); \
+    code_state->prev_state = MP_STATE_THREAD(current_code_state); \
+    assert(code_state != code_state->prev_state); \
+    if (!mp_prof_is_executing) { \
+        mp_prof_frame_enter(code_state); \
+    } \
+} while(0)
+
+#define FRAME_LEAVE() do { \
+    assert(code_state != code_state->prev_state); \
+    MP_STATE_THREAD(current_code_state) = code_state->prev_state; \
+    assert(code_state != code_state->prev_state); \
+} while(0)
+
+#define FRAME_UPDATE() do { \
+    assert(MP_STATE_THREAD(current_code_state) == code_state); \
+    if (!mp_prof_is_executing) { \
+        code_state->frame = MP_OBJ_TO_PTR(mp_prof_frame_update(code_state)); \
+    } \
+} while(0)
+
+#define TRACE_TICK(current_ip, current_sp, is_exception) do { \
+    assert(code_state != code_state->prev_state); \
+    assert(MP_STATE_THREAD(current_code_state) == code_state); \
+    if (!mp_prof_is_executing && code_state->frame && MP_STATE_THREAD(prof_trace_callback)) { \
+        MP_PROF_INSTR_DEBUG_PRINT(code_state->ip); \
+    } \
+    if (!mp_prof_is_executing && code_state->frame && code_state->frame->callback) { \
+        mp_prof_instr_tick(code_state, is_exception); \
+    } \
+} while(0)
+
+#else // MICROPY_PY_SYS_SETTRACE
+#define FRAME_SETUP()
+#define FRAME_ENTER()
+#define FRAME_LEAVE()
+#define FRAME_UPDATE()
+#define TRACE_TICK(current_ip, current_sp, is_exception)
+#endif // MICROPY_PY_SYS_SETTRACE
+
+#if MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE
+static inline mp_map_elem_t *mp_map_cached_lookup(mp_map_t *map, qstr qst, uint8_t *idx_cache) {
+    size_t idx = *idx_cache;
+    mp_obj_t key = MP_OBJ_NEW_QSTR(qst);
+    mp_map_elem_t *elem = NULL;
+    if (idx < map->alloc && map->table[idx].key == key) {
+        elem = &map->table[idx];
+    } else {
+        elem = mp_map_lookup(map, key, MP_MAP_LOOKUP);
+        if (elem != NULL) {
+            *idx_cache = (elem - &map->table[0]) & 0xff;
+        }
+    }
+    return elem;
+}
+#endif
+
 // fastn has items in reverse order (fastn[0] is local[0], fastn[-1] is local[1], etc)
 // sp points to bottom of stack which grows up
 // returns:
@@ -128,6 +212,7 @@ mp_vm_return_kind_t mp_execute_bytecode(mp_code_state_t *code_state, volatile mp
     #define DISPATCH() do { \
         TRACE(ip); \
         MARK_EXC_IP_GLOBAL(); \
+        TRACE_TICK(ip, sp, false); \
         goto *entry_table[*ip++]; \
     } while (0)
     #define DISPATCH_WITH_PEND_EXC_CHECK() goto pending_exception_check
@@ -149,17 +234,24 @@ mp_vm_return_kind_t mp_execute_bytecode(mp_code_state_t *code_state, volatile mp
 #if MICROPY_STACKLESS
 run_code_state: ;
 #endif
+FRAME_ENTER();
+
+#if MICROPY_STACKLESS
+run_code_state_from_return: ;
+#endif
+FRAME_SETUP();
+
     // Pointers which are constant for particular invocation of mp_execute_bytecode()
     mp_obj_t * /*const*/ fastn;
     mp_exc_stack_t * /*const*/ exc_stack;
     {
-        size_t n_state = mp_decode_uint_value(code_state->fun_bc->bytecode);
+        size_t n_state = code_state->n_state;
         fastn = &code_state->state[n_state - 1];
         exc_stack = (mp_exc_stack_t*)(code_state->state + n_state);
     }
 
     // variables that are visible to the exception handler (declared volatile)
-    mp_exc_stack_t *volatile exc_sp = MP_TAGPTR_PTR(code_state->exc_sp); // stack grows up, exc_sp points to top of stack
+    mp_exc_stack_t *volatile exc_sp = MP_CODE_STATE_EXC_SP_IDX_TO_PTR(exc_stack, code_state->exc_sp_idx); // stack grows up, exc_sp points to top of stack
 
     #if MICROPY_PY_THREAD_GIL && MICROPY_PY_THREAD_GIL_VM_DIVISOR
     // This needs to be volatile and outside the VM loop so it persists across handling
@@ -179,7 +271,7 @@ run_code_state: ;
             MICROPY_VM_HOOK_INIT
 
             // If we have exception to inject, now that we finish setting up
-            // execution context, raise it. This works as if RAISE_VARARGS
+            // execution context, raise it. This works as if MP_BC_RAISE_OBJ
             // bytecode was executed.
             // Injecting exc into yield from generator is a special case,
             // handled by MP_BC_YIELD_FROM itself
@@ -198,6 +290,7 @@ run_code_state: ;
 #else
                 TRACE(ip);
                 MARK_EXC_IP_GLOBAL();
+                TRACE_TICK(ip, sp, false);
                 switch (*ip++) {
 #endif
 
@@ -249,7 +342,7 @@ run_code_state: ;
                     if (obj_shared == MP_OBJ_NULL) {
                         local_name_error: {
                             MARK_EXC_IP_SELECTIVE();
-                            mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NameError, "local variable referenced before assignment");
+                            mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NameError, MP_ERROR_TEXT("local variable referenced before assignment"));
                             RAISE(obj);
                         }
                     }
@@ -274,19 +367,14 @@ run_code_state: ;
                 ENTRY(MP_BC_LOAD_NAME): {
                     MARK_EXC_IP_SELECTIVE();
                     DECODE_QSTR;
-                    mp_obj_t key = MP_OBJ_NEW_QSTR(qst);
-                    mp_uint_t x = *ip;
-                    if (x < mp_locals_get()->map.alloc && mp_locals_get()->map.table[x].key == key) {
-                        PUSH(mp_locals_get()->map.table[x].value);
+                    mp_map_elem_t *elem = mp_map_cached_lookup(&mp_locals_get()->map, qst, (uint8_t*)ip);
+                    mp_obj_t obj;
+                    if (elem != NULL) {
+                        obj = elem->value;
                     } else {
-                        mp_map_elem_t *elem = mp_map_lookup(&mp_locals_get()->map, MP_OBJ_NEW_QSTR(qst), MP_MAP_LOOKUP);
-                        if (elem != NULL) {
-                            *(byte*)ip = (elem - &mp_locals_get()->map.table[0]) & 0xff;
-                            PUSH(elem->value);
-                        } else {
-                            PUSH(mp_load_name(MP_OBJ_QSTR_VALUE(key)));
-                        }
+                        obj = mp_load_name(qst);
                     }
+                    PUSH(obj);
                     ip++;
                     DISPATCH();
                 }
@@ -303,19 +391,14 @@ run_code_state: ;
                 ENTRY(MP_BC_LOAD_GLOBAL): {
                     MARK_EXC_IP_SELECTIVE();
                     DECODE_QSTR;
-                    mp_obj_t key = MP_OBJ_NEW_QSTR(qst);
-                    mp_uint_t x = *ip;
-                    if (x < mp_globals_get()->map.alloc && mp_globals_get()->map.table[x].key == key) {
-                        PUSH(mp_globals_get()->map.table[x].value);
+                    mp_map_elem_t *elem = mp_map_cached_lookup(&mp_globals_get()->map, qst, (uint8_t*)ip);
+                    mp_obj_t obj;
+                    if (elem != NULL) {
+                        obj = elem->value;
                     } else {
-                        mp_map_elem_t *elem = mp_map_lookup(&mp_globals_get()->map, MP_OBJ_NEW_QSTR(qst), MP_MAP_LOOKUP);
-                        if (elem != NULL) {
-                            *(byte*)ip = (elem - &mp_globals_get()->map.table[0]) & 0xff;
-                            PUSH(elem->value);
-                        } else {
-                            PUSH(mp_load_global(MP_OBJ_QSTR_VALUE(key)));
-                        }
+                        obj = mp_load_global(qst);
                     }
+                    PUSH(obj);
                     ip++;
                     DISPATCH();
                 }
@@ -323,6 +406,7 @@ run_code_state: ;
 
                 #if !MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE
                 ENTRY(MP_BC_LOAD_ATTR): {
+                    FRAME_UPDATE();
                     MARK_EXC_IP_SELECTIVE();
                     DECODE_QSTR;
                     SET_TOP(mp_load_attr(TOP(), qst));
@@ -330,30 +414,22 @@ run_code_state: ;
                 }
                 #else
                 ENTRY(MP_BC_LOAD_ATTR): {
+                    FRAME_UPDATE();
                     MARK_EXC_IP_SELECTIVE();
                     DECODE_QSTR;
                     mp_obj_t top = TOP();
+                    mp_map_elem_t *elem = NULL;
                     if (mp_obj_is_instance_type(mp_obj_get_type(top))) {
                         mp_obj_instance_t *self = MP_OBJ_TO_PTR(top);
-                        mp_uint_t x = *ip;
-                        mp_obj_t key = MP_OBJ_NEW_QSTR(qst);
-                        mp_map_elem_t *elem;
-                        if (x < self->members.alloc && self->members.table[x].key == key) {
-                            elem = &self->members.table[x];
-                        } else {
-                            elem = mp_map_lookup(&self->members, key, MP_MAP_LOOKUP);
-                            if (elem != NULL) {
-                                *(byte*)ip = elem - &self->members.table[0];
-                            } else {
-                                goto load_attr_cache_fail;
-                            }
-                        }
-                        SET_TOP(elem->value);
-                        ip++;
-                        DISPATCH();
+                        elem = mp_map_cached_lookup(&self->members, qst, (uint8_t*)ip);
+                    }
+                    mp_obj_t obj;
+                    if (elem != NULL) {
+                        obj = elem->value;
+                    } else {
+                        obj = mp_load_attr(top, qst);
                     }
-                load_attr_cache_fail:
-                    SET_TOP(mp_load_attr(top, qst));
+                    SET_TOP(obj);
                     ip++;
                     DISPATCH();
                 }
@@ -415,6 +491,7 @@ run_code_state: ;
 
                 #if !MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE
                 ENTRY(MP_BC_STORE_ATTR): {
+                    FRAME_UPDATE();
                     MARK_EXC_IP_SELECTIVE();
                     DECODE_QSTR;
                     mp_store_attr(sp[0], qst, sp[-1]);
@@ -428,31 +505,20 @@ run_code_state: ;
                 // consequence of this is that we can't use MP_MAP_LOOKUP_ADD_IF_NOT_FOUND
                 // in the fast-path below, because that store could override a property.
                 ENTRY(MP_BC_STORE_ATTR): {
+                    FRAME_UPDATE();
                     MARK_EXC_IP_SELECTIVE();
                     DECODE_QSTR;
+                    mp_map_elem_t *elem = NULL;
                     mp_obj_t top = TOP();
                     if (mp_obj_is_instance_type(mp_obj_get_type(top)) && sp[-1] != MP_OBJ_NULL) {
                         mp_obj_instance_t *self = MP_OBJ_TO_PTR(top);
-                        mp_uint_t x = *ip;
-                        mp_obj_t key = MP_OBJ_NEW_QSTR(qst);
-                        mp_map_elem_t *elem;
-                        if (x < self->members.alloc && self->members.table[x].key == key) {
-                            elem = &self->members.table[x];
-                        } else {
-                            elem = mp_map_lookup(&self->members, key, MP_MAP_LOOKUP);
-                            if (elem != NULL) {
-                                *(byte*)ip = elem - &self->members.table[0];
-                            } else {
-                                goto store_attr_cache_fail;
-                            }
-                        }
+                        elem = mp_map_cached_lookup(&self->members, qst, (uint8_t*)ip);
+                    }
+                    if (elem != NULL) {
                         elem->value = sp[-1];
-                        sp -= 2;
-                        ip++;
-                        DISPATCH();
+                    } else {
+                        mp_store_attr(sp[0], qst, sp[-1]);
                     }
-                store_attr_cache_fail:
-                    mp_store_attr(sp[0], qst, sp[-1]);
                     sp -= 2;
                     ip++;
                     DISPATCH();
@@ -649,21 +715,28 @@ unwind_jump:;
                     while ((unum & 0x7f) > 0) {
                         unum -= 1;
                         assert(exc_sp >= exc_stack);
-                        if (MP_TAGPTR_TAG1(exc_sp->val_sp) && exc_sp->handler > ip) {
-                            // Getting here the stack looks like:
-                            //     (..., X, dest_ip)
-                            // where X is pointed to by exc_sp->val_sp and in the case
-                            // of a "with" block contains the context manager info.
-                            // We're going to run "finally" code as a coroutine
-                            // (not calling it recursively). Set up a sentinel
-                            // on the stack so it can return back to us when it is
-                            // done (when WITH_CLEANUP or END_FINALLY reached).
-                            // The sentinel is the number of exception handlers left to
-                            // unwind, which is a non-negative integer.
-                            PUSH(MP_OBJ_NEW_SMALL_INT(unum));
-                            ip = exc_sp->handler; // get exception handler byte code address
-                            exc_sp--; // pop exception handler
-                            goto dispatch_loop; // run the exception handler
+
+                        if (MP_TAGPTR_TAG1(exc_sp->val_sp)) {
+                            if (exc_sp->handler > ip) {
+                                // Found a finally handler that isn't active; run it.
+                                // Getting here the stack looks like:
+                                //     (..., X, dest_ip)
+                                // where X is pointed to by exc_sp->val_sp and in the case
+                                // of a "with" block contains the context manager info.
+                                assert(&sp[-1] == MP_TAGPTR_PTR(exc_sp->val_sp));
+                                // We're going to run "finally" code as a coroutine
+                                // (not calling it recursively). Set up a sentinel
+                                // on the stack so it can return back to us when it is
+                                // done (when WITH_CLEANUP or END_FINALLY reached).
+                                // The sentinel is the number of exception handlers left to
+                                // unwind, which is a non-negative integer.
+                                PUSH(MP_OBJ_NEW_SMALL_INT(unum));
+                                ip = exc_sp->handler;
+                                goto dispatch_loop;
+                            } else {
+                                // Found a finally handler that is already active; cancel it.
+                                CANCEL_ACTIVE_FINALLY(sp);
+                            }
                         }
                         POP_EXC_BLOCK();
                     }
@@ -675,7 +748,6 @@ unwind_jump:;
                     DISPATCH_WITH_PEND_EXC_CHECK();
                 }
 
-                // matched against: POP_BLOCK or POP_EXCEPT (anything else?)
                 ENTRY(MP_BC_SETUP_EXCEPT):
                 ENTRY(MP_BC_SETUP_FINALLY): {
                     MARK_EXC_IP_SELECTIVE();
@@ -692,9 +764,9 @@ unwind_jump:;
                     // if TOS is None, just pops it and continues
                     // if TOS is an integer, finishes coroutine and returns control to caller
                     // if TOS is an exception, reraises the exception
+                    assert(exc_sp >= exc_stack);
+                    POP_EXC_BLOCK();
                     if (TOP() == mp_const_none) {
-                        assert(exc_sp >= exc_stack);
-                        POP_EXC_BLOCK();
                         sp--;
                     } else if (mp_obj_is_small_int(TOP())) {
                         // We finished "finally" coroutine and now dispatch back
@@ -739,6 +811,7 @@ unwind_jump:;
                 }
 
                 ENTRY(MP_BC_FOR_ITER): {
+                    FRAME_UPDATE();
                     MARK_EXC_IP_SELECTIVE();
                     DECODE_ULABEL; // the jump offset if iteration finishes; for labels are always forward
                     code_state->sp = sp;
@@ -754,11 +827,16 @@ unwind_jump:;
                         ip += ulab; // jump to after for-block
                     } else {
                         PUSH(value); // push the next iteration value
+                        #if MICROPY_PY_SYS_SETTRACE
+                        // LINE event should trigger for every iteration so invalidate last trigger
+                        if (code_state->frame) {
+                            code_state->frame->lineno = 0;
+                        }
+                        #endif
                     }
                     DISPATCH();
                 }
 
-                // matched against: SETUP_EXCEPT, SETUP_FINALLY, SETUP_WITH
                 ENTRY(MP_BC_POP_EXCEPT_JUMP): {
                     assert(exc_sp >= exc_stack);
                     POP_EXC_BLOCK();
@@ -889,6 +967,7 @@ unwind_jump:;
                 }
 
                 ENTRY(MP_BC_CALL_FUNCTION): {
+                    FRAME_UPDATE();
                     MARK_EXC_IP_SELECTIVE();
                     DECODE_UINT;
                     // unum & 0xff == n_positional
@@ -898,7 +977,7 @@ unwind_jump:;
                     if (mp_obj_get_type(*sp) == &mp_type_fun_bc) {
                         code_state->ip = ip;
                         code_state->sp = sp;
-                        code_state->exc_sp = MP_TAGPTR_MAKE(exc_sp, 0);
+                        code_state->exc_sp_idx = MP_CODE_STATE_EXC_SP_IDX_FROM_PTR(exc_stack, exc_sp);
                         mp_code_state_t *new_state = mp_obj_fun_bc_prepare_codestate(*sp, unum & 0xff, (unum >> 8) & 0xff, sp + 1);
                         #if !MICROPY_ENABLE_PYSTACK
                         if (new_state == NULL) {
@@ -923,6 +1002,7 @@ unwind_jump:;
                 }
 
                 ENTRY(MP_BC_CALL_FUNCTION_VAR_KW): {
+                    FRAME_UPDATE();
                     MARK_EXC_IP_SELECTIVE();
                     DECODE_UINT;
                     // unum & 0xff == n_positional
@@ -934,7 +1014,7 @@ unwind_jump:;
                     if (mp_obj_get_type(*sp) == &mp_type_fun_bc) {
                         code_state->ip = ip;
                         code_state->sp = sp;
-                        code_state->exc_sp = MP_TAGPTR_MAKE(exc_sp, 0);
+                        code_state->exc_sp_idx = MP_CODE_STATE_EXC_SP_IDX_FROM_PTR(exc_stack, exc_sp);
 
                         mp_call_args_t out_args;
                         mp_call_prepare_args_n_kw_var(false, unum, sp, &out_args);
@@ -968,6 +1048,7 @@ unwind_jump:;
                 }
 
                 ENTRY(MP_BC_CALL_METHOD): {
+                    FRAME_UPDATE();
                     MARK_EXC_IP_SELECTIVE();
                     DECODE_UINT;
                     // unum & 0xff == n_positional
@@ -977,7 +1058,7 @@ unwind_jump:;
                     if (mp_obj_get_type(*sp) == &mp_type_fun_bc) {
                         code_state->ip = ip;
                         code_state->sp = sp;
-                        code_state->exc_sp = MP_TAGPTR_MAKE(exc_sp, 0);
+                        code_state->exc_sp_idx = MP_CODE_STATE_EXC_SP_IDX_FROM_PTR(exc_stack, exc_sp);
 
                         size_t n_args = unum & 0xff;
                         size_t n_kw = (unum >> 8) & 0xff;
@@ -1006,6 +1087,7 @@ unwind_jump:;
                 }
 
                 ENTRY(MP_BC_CALL_METHOD_VAR_KW): {
+                    FRAME_UPDATE();
                     MARK_EXC_IP_SELECTIVE();
                     DECODE_UINT;
                     // unum & 0xff == n_positional
@@ -1017,7 +1099,7 @@ unwind_jump:;
                     if (mp_obj_get_type(*sp) == &mp_type_fun_bc) {
                         code_state->ip = ip;
                         code_state->sp = sp;
-                        code_state->exc_sp = MP_TAGPTR_MAKE(exc_sp, 0);
+                        code_state->exc_sp_idx = MP_CODE_STATE_EXC_SP_IDX_FROM_PTR(exc_stack, exc_sp);
 
                         mp_call_args_t out_args;
                         mp_call_prepare_args_n_kw_var(true, unum, sp, &out_args);
@@ -1055,28 +1137,32 @@ unwind_jump:;
 unwind_return:
                     // Search for and execute finally handlers that aren't already active
                     while (exc_sp >= exc_stack) {
-                        if (MP_TAGPTR_TAG1(exc_sp->val_sp) && exc_sp->handler > ip) {
-                            // Found a finally handler that isn't active.
-                            // Getting here the stack looks like:
-                            //     (..., X, [iter0, iter1, ...,] ret_val)
-                            // where X is pointed to by exc_sp->val_sp and in the case
-                            // of a "with" block contains the context manager info.
-                            // There may be 0 or more for-iterators between X and the
-                            // return value, and these must be removed before control can
-                            // pass to the finally code.  We simply copy the ret_value down
-                            // over these iterators, if they exist.  If they don't then the
-                            // following is a null operation.
-                            mp_obj_t *finally_sp = MP_TAGPTR_PTR(exc_sp->val_sp);
-                            finally_sp[1] = sp[0];
-                            sp = &finally_sp[1];
-                            // We're going to run "finally" code as a coroutine
-                            // (not calling it recursively). Set up a sentinel
-                            // on a stack so it can return back to us when it is
-                            // done (when WITH_CLEANUP or END_FINALLY reached).
-                            PUSH(MP_OBJ_NEW_SMALL_INT(-1));
-                            ip = exc_sp->handler;
-                            POP_EXC_BLOCK();
-                            goto dispatch_loop;
+                        if (MP_TAGPTR_TAG1(exc_sp->val_sp)) {
+                            if (exc_sp->handler > ip) {
+                                // Found a finally handler that isn't active; run it.
+                                // Getting here the stack looks like:
+                                //     (..., X, [iter0, iter1, ...,] ret_val)
+                                // where X is pointed to by exc_sp->val_sp and in the case
+                                // of a "with" block contains the context manager info.
+                                // There may be 0 or more for-iterators between X and the
+                                // return value, and these must be removed before control can
+                                // pass to the finally code.  We simply copy the ret_value down
+                                // over these iterators, if they exist.  If they don't then the
+                                // following is a null operation.
+                                mp_obj_t *finally_sp = MP_TAGPTR_PTR(exc_sp->val_sp);
+                                finally_sp[1] = sp[0];
+                                sp = &finally_sp[1];
+                                // We're going to run "finally" code as a coroutine
+                                // (not calling it recursively). Set up a sentinel
+                                // on a stack so it can return back to us when it is
+                                // done (when WITH_CLEANUP or END_FINALLY reached).
+                                PUSH(MP_OBJ_NEW_SMALL_INT(-1));
+                                ip = exc_sp->handler;
+                                goto dispatch_loop;
+                            } else {
+                                // Found a finally handler that is already active; cancel it.
+                                CANCEL_ACTIVE_FINALLY(sp);
+                            }
                         }
                         POP_EXC_BLOCK();
                     }
@@ -1098,37 +1184,39 @@ unwind_jump:;
                         #endif
                         code_state = new_code_state;
                         *code_state->sp = res;
-                        goto run_code_state;
+                        goto run_code_state_from_return;
                     }
                     #endif
+                    FRAME_LEAVE();
                     return MP_VM_RETURN_NORMAL;
 
-                ENTRY(MP_BC_RAISE_VARARGS): {
+                ENTRY(MP_BC_RAISE_LAST): {
                     MARK_EXC_IP_SELECTIVE();
-                    mp_uint_t unum = *ip;
-                    mp_obj_t obj;
-                    if (unum == 2) {
-                        mp_warning(NULL, "exception chaining not supported");
-                        // ignore (pop) "from" argument
-                        sp--;
-                    }
-                    if (unum == 0) {
-                        // search for the inner-most previous exception, to reraise it
-                        obj = MP_OBJ_NULL;
-                        for (mp_exc_stack_t *e = exc_sp; e >= exc_stack; e--) {
-                            if (e->prev_exc != NULL) {
-                                obj = MP_OBJ_FROM_PTR(e->prev_exc);
-                                break;
-                            }
-                        }
-                        if (obj == MP_OBJ_NULL) {
-                            obj = mp_obj_new_exception_msg(&mp_type_RuntimeError, "no active exception to reraise");
-                            RAISE(obj);
+                    // search for the inner-most previous exception, to reraise it
+                    mp_obj_t obj = MP_OBJ_NULL;
+                    for (mp_exc_stack_t *e = exc_sp; e >= exc_stack; --e) {
+                        if (e->prev_exc != NULL) {
+                            obj = MP_OBJ_FROM_PTR(e->prev_exc);
+                            break;
                         }
-                    } else {
-                        obj = TOP();
                     }
-                    obj = mp_make_raise_obj(obj);
+                    if (obj == MP_OBJ_NULL) {
+                        obj = mp_obj_new_exception_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("no active exception to reraise"));
+                    }
+                    RAISE(obj);
+                }
+
+                ENTRY(MP_BC_RAISE_OBJ): {
+                    MARK_EXC_IP_SELECTIVE();
+                    mp_obj_t obj = mp_make_raise_obj(TOP());
+                    RAISE(obj);
+                }
+
+                ENTRY(MP_BC_RAISE_FROM): {
+                    MARK_EXC_IP_SELECTIVE();
+                    mp_warning(NULL, "exception chaining not supported");
+                    sp--; // ignore (pop) "from" argument
+                    mp_obj_t obj = mp_make_raise_obj(TOP());
                     RAISE(obj);
                 }
 
@@ -1137,7 +1225,8 @@ unwind_jump:;
                     nlr_pop();
                     code_state->ip = ip;
                     code_state->sp = sp;
-                    code_state->exc_sp = MP_TAGPTR_MAKE(exc_sp, 0);
+                    code_state->exc_sp_idx = MP_CODE_STATE_EXC_SP_IDX_FROM_PTR(exc_stack, exc_sp);
+                    FRAME_LEAVE();
                     return MP_VM_RETURN_YIELD;
 
                 ENTRY(MP_BC_YIELD_FROM): {
@@ -1179,21 +1268,15 @@ unwind_jump:;
                         DISPATCH();
                     } else {
                         assert(ret_kind == MP_VM_RETURN_EXCEPTION);
+                        assert(!EXC_MATCH(ret_value, MP_OBJ_FROM_PTR(&mp_type_StopIteration)));
                         // Pop exhausted gen
                         sp--;
-                        if (EXC_MATCH(ret_value, MP_OBJ_FROM_PTR(&mp_type_StopIteration))) {
-                            PUSH(mp_obj_exception_get_value(ret_value));
-                            // If we injected GeneratorExit downstream, then even
-                            // if it was swallowed, we re-raise GeneratorExit
-                            GENERATOR_EXIT_IF_NEEDED(t_exc);
-                            DISPATCH();
-                        } else {
-                            RAISE(ret_value);
-                        }
+                        RAISE(ret_value);
                     }
                 }
 
                 ENTRY(MP_BC_IMPORT_NAME): {
+                    FRAME_UPDATE();
                     MARK_EXC_IP_SELECTIVE();
                     DECODE_QSTR;
                     mp_obj_t obj = POP();
@@ -1202,6 +1285,7 @@ unwind_jump:;
                 }
 
                 ENTRY(MP_BC_IMPORT_FROM): {
+                    FRAME_UPDATE();
                     MARK_EXC_IP_SELECTIVE();
                     DECODE_QSTR;
                     mp_obj_t obj = mp_import_from(TOP(), qst);
@@ -1216,7 +1300,7 @@ unwind_jump:;
 
 #if MICROPY_OPT_COMPUTED_GOTO
                 ENTRY(MP_BC_LOAD_CONST_SMALL_INT_MULTI):
-                    PUSH(MP_OBJ_NEW_SMALL_INT((mp_int_t)ip[-1] - MP_BC_LOAD_CONST_SMALL_INT_MULTI - 16));
+                    PUSH(MP_OBJ_NEW_SMALL_INT((mp_int_t)ip[-1] - MP_BC_LOAD_CONST_SMALL_INT_MULTI - MP_BC_LOAD_CONST_SMALL_INT_MULTI_EXCESS));
                     DISPATCH();
 
                 ENTRY(MP_BC_LOAD_FAST_MULTI):
@@ -1244,19 +1328,19 @@ unwind_jump:;
                     MARK_EXC_IP_SELECTIVE();
 #else
                 ENTRY_DEFAULT:
-                    if (ip[-1] < MP_BC_LOAD_CONST_SMALL_INT_MULTI + 64) {
-                        PUSH(MP_OBJ_NEW_SMALL_INT((mp_int_t)ip[-1] - MP_BC_LOAD_CONST_SMALL_INT_MULTI - 16));
+                    if (ip[-1] < MP_BC_LOAD_CONST_SMALL_INT_MULTI + MP_BC_LOAD_CONST_SMALL_INT_MULTI_NUM) {
+                        PUSH(MP_OBJ_NEW_SMALL_INT((mp_int_t)ip[-1] - MP_BC_LOAD_CONST_SMALL_INT_MULTI - MP_BC_LOAD_CONST_SMALL_INT_MULTI_EXCESS));
                         DISPATCH();
-                    } else if (ip[-1] < MP_BC_LOAD_FAST_MULTI + 16) {
+                    } else if (ip[-1] < MP_BC_LOAD_FAST_MULTI + MP_BC_LOAD_FAST_MULTI_NUM) {
                         obj_shared = fastn[MP_BC_LOAD_FAST_MULTI - (mp_int_t)ip[-1]];
                         goto load_check;
-                    } else if (ip[-1] < MP_BC_STORE_FAST_MULTI + 16) {
+                    } else if (ip[-1] < MP_BC_STORE_FAST_MULTI + MP_BC_STORE_FAST_MULTI_NUM) {
                         fastn[MP_BC_STORE_FAST_MULTI - (mp_int_t)ip[-1]] = POP();
                         DISPATCH();
-                    } else if (ip[-1] < MP_BC_UNARY_OP_MULTI + MP_UNARY_OP_NUM_BYTECODE) {
+                    } else if (ip[-1] < MP_BC_UNARY_OP_MULTI + MP_BC_UNARY_OP_MULTI_NUM) {
                         SET_TOP(mp_unary_op(ip[-1] - MP_BC_UNARY_OP_MULTI, TOP()));
                         DISPATCH();
-                    } else if (ip[-1] < MP_BC_BINARY_OP_MULTI + MP_BINARY_OP_NUM_BYTECODE) {
+                    } else if (ip[-1] < MP_BC_BINARY_OP_MULTI + MP_BC_BINARY_OP_MULTI_NUM) {
                         mp_obj_t rhs = POP();
                         mp_obj_t lhs = TOP();
                         SET_TOP(mp_binary_op(ip[-1] - MP_BC_BINARY_OP_MULTI, lhs, rhs));
@@ -1264,9 +1348,11 @@ unwind_jump:;
                     } else
 #endif
                 {
-                    mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NotImplementedError, "byte code not implemented");
+
+                    mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NotImplementedError, MP_ERROR_TEXT("opcode"));
                     nlr_pop();
                     code_state->state[0] = obj;
+                    FRAME_LEAVE();
                     return MP_VM_RETURN_EXCEPTION;
                 }
 
@@ -1280,18 +1366,23 @@ unwind_jump:;
                 #if MICROPY_ENABLE_SCHEDULER
                 // This is an inlined variant of mp_handle_pending
                 if (MP_STATE_VM(sched_state) == MP_SCHED_PENDING) {
-                    MARK_EXC_IP_SELECTIVE();
                     mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
-                    mp_obj_t obj = MP_STATE_VM(mp_pending_exception);
-                    if (obj != MP_OBJ_NULL) {
-                        MP_STATE_VM(mp_pending_exception) = MP_OBJ_NULL;
-                        if (!mp_sched_num_pending()) {
-                            MP_STATE_VM(sched_state) = MP_SCHED_IDLE;
+                    // Re-check state is still pending now that we're in the atomic section.
+                    if (MP_STATE_VM(sched_state) == MP_SCHED_PENDING) {
+                        MARK_EXC_IP_SELECTIVE();
+                        mp_obj_t obj = MP_STATE_VM(mp_pending_exception);
+                        if (obj != MP_OBJ_NULL) {
+                            MP_STATE_VM(mp_pending_exception) = MP_OBJ_NULL;
+                            if (!mp_sched_num_pending()) {
+                                MP_STATE_VM(sched_state) = MP_SCHED_IDLE;
+                            }
+                            MICROPY_END_ATOMIC_SECTION(atomic_state);
+                            RAISE(obj);
                         }
+                        mp_handle_pending_tail(atomic_state);
+                    } else {
                         MICROPY_END_ATOMIC_SECTION(atomic_state);
-                        RAISE(obj);
                     }
-                    mp_handle_pending_tail(atomic_state);
                 }
                 #else
                 // This is an inlined variant of mp_handle_pending
@@ -1357,24 +1448,32 @@ unwind_jump:;
                 }
             }
 
+            #if MICROPY_PY_SYS_SETTRACE
+            // Exceptions are traced here
+            if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(((mp_obj_base_t*)nlr.ret_val)->type), MP_OBJ_FROM_PTR(&mp_type_Exception))) {
+                TRACE_TICK(code_state->ip, code_state->sp, true /* yes, it's an exception */);
+            }
+            #endif
+
 #if MICROPY_STACKLESS
 unwind_loop:
 #endif
-            // set file and line number that the exception occurred at
-            // TODO: don't set traceback for exceptions re-raised by END_FINALLY.
-            // But consider how to handle nested exceptions.
-            if (nlr.ret_val != &mp_const_GeneratorExit_obj) {
+            // Set traceback info (file and line number) where the exception occurred, but not for:
+            // - constant GeneratorExit object, because it's const
+            // - exceptions re-raised by END_FINALLY
+            // - exceptions re-raised explicitly by "raise"
+            if (nlr.ret_val != &mp_const_GeneratorExit_obj
+                && *code_state->ip != MP_BC_END_FINALLY
+                && *code_state->ip != MP_BC_RAISE_LAST) {
                 const byte *ip = code_state->fun_bc->bytecode;
-                ip = mp_decode_uint_skip(ip); // skip n_state
-                ip = mp_decode_uint_skip(ip); // skip n_exc_stack
-                ip++; // skip scope_params
-                ip++; // skip n_pos_args
-                ip++; // skip n_kwonly_args
-                ip++; // skip n_def_pos_args
-                size_t bc = code_state->ip - ip;
-                size_t code_info_size = mp_decode_uint_value(ip);
-                ip = mp_decode_uint_skip(ip); // skip code_info_size
-                bc -= code_info_size;
+                MP_BC_PRELUDE_SIG_DECODE(ip);
+                MP_BC_PRELUDE_SIZE_DECODE(ip);
+                const byte *bytecode_start = ip + n_info + n_cell;
+                #if !MICROPY_PERSISTENT_CODE
+                // so bytecode is aligned
+                bytecode_start = MP_ALIGN(bytecode_start, sizeof(mp_uint_t));
+                #endif
+                size_t bc = code_state->ip - bytecode_start;
                 #if MICROPY_PERSISTENT_CODE
                 qstr block_name = ip[0] | (ip[1] << 8);
                 qstr source_file = ip[2] | (ip[3] << 8);
@@ -1385,29 +1484,7 @@ unwind_jump:;
                 qstr source_file = mp_decode_uint_value(ip);
                 ip = mp_decode_uint_skip(ip);
                 #endif
-                size_t source_line = 1;
-                size_t c;
-                while ((c = *ip)) {
-                    size_t b, l;
-                    if ((c & 0x80) == 0) {
-                        // 0b0LLBBBBB encoding
-                        b = c & 0x1f;
-                        l = c >> 5;
-                        ip += 1;
-                    } else {
-                        // 0b1LLLBBBB 0bLLLLLLLL encoding (l's LSB in second byte)
-                        b = c & 0xf;
-                        l = ((c << 4) & 0x700) | ip[1];
-                        ip += 2;
-                    }
-                    if (bc >= b) {
-                        bc -= b;
-                        source_line += l;
-                    } else {
-                        // found source line corresponding to bytecode offset
-                        break;
-                    }
-                }
+                size_t source_line = mp_bytecode_get_source_line(ip, bc);
                 mp_obj_exception_add_traceback(MP_OBJ_FROM_PTR(nlr.ret_val), source_file, source_line, block_name);
             }
 
@@ -1446,11 +1523,11 @@ unwind_jump:;
                 mp_nonlocal_free(code_state, sizeof(mp_code_state_t));
                 #endif
                 code_state = new_code_state;
-                size_t n_state = mp_decode_uint_value(code_state->fun_bc->bytecode);
+                size_t n_state = code_state->n_state;
                 fastn = &code_state->state[n_state - 1];
                 exc_stack = (mp_exc_stack_t*)(code_state->state + n_state);
                 // variables that are visible to the exception handler (declared volatile)
-                exc_sp = MP_TAGPTR_PTR(code_state->exc_sp); // stack grows up, exc_sp points to top of stack
+                exc_sp = MP_CODE_STATE_EXC_SP_IDX_TO_PTR(exc_stack, code_state->exc_sp_idx); // stack grows up, exc_sp points to top of stack
                 goto unwind_loop;
 
             #endif
@@ -1458,6 +1535,7 @@ unwind_jump:;
                 // propagate exception to higher level
                 // Note: ip and sp don't have usable values at this point
                 code_state->state[0] = MP_OBJ_FROM_PTR(nlr.ret_val); // put exception here because sp is invalid
+                FRAME_LEAVE();
                 return MP_VM_RETURN_EXCEPTION;
             }
         }
diff --git a/py/vmentrytable.h b/py/vmentrytable.h
index 641c8ee422b63..068214bf916cf 100644
--- a/py/vmentrytable.h
+++ b/py/vmentrytable.h
@@ -24,6 +24,8 @@
  * THE SOFTWARE.
  */
 
+// *FORMAT-OFF*
+
 #if __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Winitializer-overrides"
@@ -99,17 +101,19 @@ static const void *const entry_table[256] = {
     [MP_BC_CALL_METHOD] = &&entry_MP_BC_CALL_METHOD,
     [MP_BC_CALL_METHOD_VAR_KW] = &&entry_MP_BC_CALL_METHOD_VAR_KW,
     [MP_BC_RETURN_VALUE] = &&entry_MP_BC_RETURN_VALUE,
-    [MP_BC_RAISE_VARARGS] = &&entry_MP_BC_RAISE_VARARGS,
+    [MP_BC_RAISE_LAST] = &&entry_MP_BC_RAISE_LAST,
+    [MP_BC_RAISE_OBJ] = &&entry_MP_BC_RAISE_OBJ,
+    [MP_BC_RAISE_FROM] = &&entry_MP_BC_RAISE_FROM,
     [MP_BC_YIELD_VALUE] = &&entry_MP_BC_YIELD_VALUE,
     [MP_BC_YIELD_FROM] = &&entry_MP_BC_YIELD_FROM,
     [MP_BC_IMPORT_NAME] = &&entry_MP_BC_IMPORT_NAME,
     [MP_BC_IMPORT_FROM] = &&entry_MP_BC_IMPORT_FROM,
     [MP_BC_IMPORT_STAR] = &&entry_MP_BC_IMPORT_STAR,
-    [MP_BC_LOAD_CONST_SMALL_INT_MULTI ... MP_BC_LOAD_CONST_SMALL_INT_MULTI + 63] = &&entry_MP_BC_LOAD_CONST_SMALL_INT_MULTI,
-    [MP_BC_LOAD_FAST_MULTI ... MP_BC_LOAD_FAST_MULTI + 15] = &&entry_MP_BC_LOAD_FAST_MULTI,
-    [MP_BC_STORE_FAST_MULTI ... MP_BC_STORE_FAST_MULTI + 15] = &&entry_MP_BC_STORE_FAST_MULTI,
-    [MP_BC_UNARY_OP_MULTI ... MP_BC_UNARY_OP_MULTI + MP_UNARY_OP_NUM_BYTECODE - 1] = &&entry_MP_BC_UNARY_OP_MULTI,
-    [MP_BC_BINARY_OP_MULTI ... MP_BC_BINARY_OP_MULTI + MP_BINARY_OP_NUM_BYTECODE - 1] = &&entry_MP_BC_BINARY_OP_MULTI,
+    [MP_BC_LOAD_CONST_SMALL_INT_MULTI ... MP_BC_LOAD_CONST_SMALL_INT_MULTI + MP_BC_LOAD_CONST_SMALL_INT_MULTI_NUM - 1] = &&entry_MP_BC_LOAD_CONST_SMALL_INT_MULTI,
+    [MP_BC_LOAD_FAST_MULTI ... MP_BC_LOAD_FAST_MULTI + MP_BC_LOAD_FAST_MULTI_NUM - 1] = &&entry_MP_BC_LOAD_FAST_MULTI,
+    [MP_BC_STORE_FAST_MULTI ... MP_BC_STORE_FAST_MULTI + MP_BC_STORE_FAST_MULTI_NUM - 1] = &&entry_MP_BC_STORE_FAST_MULTI,
+    [MP_BC_UNARY_OP_MULTI ... MP_BC_UNARY_OP_MULTI + MP_BC_UNARY_OP_MULTI_NUM - 1] = &&entry_MP_BC_UNARY_OP_MULTI,
+    [MP_BC_BINARY_OP_MULTI ... MP_BC_BINARY_OP_MULTI + MP_BC_BINARY_OP_MULTI_NUM - 1] = &&entry_MP_BC_BINARY_OP_MULTI,
 };
 
 #if __clang__
diff --git a/py/vstr.c b/py/vstr.c
index 869b27805737a..56327b5f7ac7c 100644
--- a/py/vstr.c
+++ b/py/vstr.c
@@ -4,6 +4,7 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2014 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -139,37 +140,37 @@ char *vstr_null_terminated_str(vstr_t *vstr) {
 }
 
 void vstr_add_byte(vstr_t *vstr, byte b) {
-    byte *buf = (byte*)vstr_add_len(vstr, 1);
+    byte *buf = (byte *)vstr_add_len(vstr, 1);
     buf[0] = b;
 }
 
 void vstr_add_char(vstr_t *vstr, unichar c) {
-#if MICROPY_PY_BUILTINS_STR_UNICODE
+    #if MICROPY_PY_BUILTINS_STR_UNICODE
     // TODO: Can this be simplified and deduplicated?
     // Is it worth just calling vstr_add_len(vstr, 4)?
     if (c < 0x80) {
-        byte *buf = (byte*)vstr_add_len(vstr, 1);
+        byte *buf = (byte *)vstr_add_len(vstr, 1);
         *buf = (byte)c;
     } else if (c < 0x800) {
-        byte *buf = (byte*)vstr_add_len(vstr, 2);
+        byte *buf = (byte *)vstr_add_len(vstr, 2);
         buf[0] = (c >> 6) | 0xC0;
         buf[1] = (c & 0x3F) | 0x80;
     } else if (c < 0x10000) {
-        byte *buf = (byte*)vstr_add_len(vstr, 3);
+        byte *buf = (byte *)vstr_add_len(vstr, 3);
         buf[0] = (c >> 12) | 0xE0;
         buf[1] = ((c >> 6) & 0x3F) | 0x80;
         buf[2] = (c & 0x3F) | 0x80;
     } else {
         assert(c < 0x110000);
-        byte *buf = (byte*)vstr_add_len(vstr, 4);
+        byte *buf = (byte *)vstr_add_len(vstr, 4);
         buf[0] = (c >> 18) | 0xF0;
         buf[1] = ((c >> 12) & 0x3F) | 0x80;
         buf[2] = ((c >> 6) & 0x3F) | 0x80;
         buf[3] = (c & 0x3F) | 0x80;
     }
-#else
+    #else
     vstr_add_byte(vstr, c);
-#endif
+    #endif
 }
 
 void vstr_add_str(vstr_t *vstr, const char *str) {
diff --git a/tests/README b/tests/README
index 3458f36a80201..f2cd89bb932a3 100644
--- a/tests/README
+++ b/tests/README
@@ -13,6 +13,15 @@ condition a test. The run-tests script uses small scripts in the
 feature_check directory to check whether each such feature is present,
 and skips the relevant tests if not.
 
+Tests are generally verified by running the test both in MicroPython and
+in CPython and comparing the outputs. If the output differs the test fails
+and the outputs are saved in a .out and a .exp file respectively.
+For tests that cannot be run in CPython, for example because they use
+the machine module, a .exp file can be provided next to the test's .py
+file. A convenient way to generate that is to run the test, let it fail
+(because CPython cannot run it) and then copy the .out file (but not
+before checking it manually!)
+
 When creating new tests, anything that relies on float support should go in the
 float/ subdirectory.  Anything that relies on import x, where x is not a built-in
 module, should go in the import/ subdirectory.
diff --git a/tests/basics/array1.py b/tests/basics/array1.py
index bad879035c2d0..5b3f475786a28 100644
--- a/tests/basics/array1.py
+++ b/tests/basics/array1.py
@@ -1,8 +1,11 @@
 try:
-    import array
+    import uarray as array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 a = array.array('B', [1, 2, 3])
 print(a, len(a))
@@ -34,3 +37,23 @@
     array.array('X')
 except ValueError:
     print("ValueError")
+
+# equality (CPython requires both sides are array)
+print(bytes(array.array('b', [0x61, 0x62, 0x63])) == b'abc')
+print(array.array('b', [0x61, 0x62, 0x63]) == b'abc')
+print(array.array('b', [0x61, 0x62, 0x63]) != b'abc')
+print(array.array('b', [0x61, 0x62, 0x63]) == b'xyz')
+print(array.array('b', [0x61, 0x62, 0x63]) != b'xyz')
+print(b'abc' == array.array('b', [0x61, 0x62, 0x63]))
+print(b'abc' != array.array('b', [0x61, 0x62, 0x63]))
+print(b'xyz' == array.array('b', [0x61, 0x62, 0x63]))
+print(b'xyz' != array.array('b', [0x61, 0x62, 0x63]))
+
+class X(array.array):
+    pass
+
+print(bytes(X('b', [0x61, 0x62, 0x63])) == b'abc')
+print(X('b', [0x61, 0x62, 0x63]) == b'abc')
+print(X('b', [0x61, 0x62, 0x63]) != b'abc')
+print(X('b', [0x61, 0x62, 0x63]) == array.array('b', [0x61, 0x62, 0x63]))
+print(X('b', [0x61, 0x62, 0x63]) != array.array('b', [0x61, 0x62, 0x63]))
diff --git a/tests/basics/array_add.py b/tests/basics/array_add.py
index 76ce59f761e06..8335eb6b82bb9 100644
--- a/tests/basics/array_add.py
+++ b/tests/basics/array_add.py
@@ -1,9 +1,12 @@
 # test array + array
 try:
-    import array
+    import uarray as array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 a1 = array.array('I', [1])
 a2 = array.array('I', [2])
diff --git a/tests/basics/array_construct.py b/tests/basics/array_construct.py
index 2221de99068c2..4985244d13bb5 100644
--- a/tests/basics/array_construct.py
+++ b/tests/basics/array_construct.py
@@ -1,10 +1,13 @@
 # test construction of array.array from different objects
 
 try:
-    from array import array
+    from uarray import array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        from array import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 # tuple, list
 print(array('b', (1, 2)))
diff --git a/tests/basics/array_construct2.py b/tests/basics/array_construct2.py
index c305b7f011d1f..d1b1e9d158c63 100644
--- a/tests/basics/array_construct2.py
+++ b/tests/basics/array_construct2.py
@@ -1,8 +1,11 @@
 try:
-    from array import array
+    from uarray import array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        from array import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 # construct from something with unknown length (requires generators)
 print(array('i', (i for i in range(10))))
diff --git a/tests/basics/array_construct_endian.py b/tests/basics/array_construct_endian.py
index 990d7b1ea039b..82a962fbe0d57 100644
--- a/tests/basics/array_construct_endian.py
+++ b/tests/basics/array_construct_endian.py
@@ -1,10 +1,13 @@
 # test construction of array.array from different objects
 
 try:
-    from array import array
+    from uarray import array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        from array import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 # raw copy from bytes, bytearray
 print(array('h', b'12'))
diff --git a/tests/basics/array_intbig.py b/tests/basics/array_intbig.py
index 5702a8ae63538..ba7f9ef985ad3 100644
--- a/tests/basics/array_intbig.py
+++ b/tests/basics/array_intbig.py
@@ -1,10 +1,13 @@
 # test array types QqLl that require big-ints
 
 try:
-    from array import array
+    from uarray import array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        from array import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 print(array('L', [0, 2**32-1]))
 print(array('l', [-2**31, 0, 2**31-1]))
diff --git a/tests/basics/array_micropython.py b/tests/basics/array_micropython.py
index e26ad7ae9693e..6b3dc7a93b151 100644
--- a/tests/basics/array_micropython.py
+++ b/tests/basics/array_micropython.py
@@ -1,9 +1,12 @@
 # test MicroPython-specific features of array.array
 try:
-    import array
+    import uarray as array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 # arrays of objects
 a = array.array('O')
diff --git a/tests/basics/async_await2.py b/tests/basics/async_await2.py
index 129d3751a59b2..1e3164df93372 100644
--- a/tests/basics/async_await2.py
+++ b/tests/basics/async_await2.py
@@ -11,7 +11,7 @@
 @coroutine
 def wait(value):
     print('wait value:', value)
-    msg = yield 'message from wait(%u)' % value
+    msg = yield 'message from wait({})'.format(value)
     print('wait got back:', msg)
     return 10
 
diff --git a/tests/basics/bool1.py b/tests/basics/bool1.py
index 35d9ed8ccc028..daabfb17d8621 100644
--- a/tests/basics/bool1.py
+++ b/tests/basics/bool1.py
@@ -10,6 +10,30 @@
 print(+True)
 print(-True)
 
+# comparison with itself
+print(False == False)
+print(False == True)
+print(True == False)
+print(True == True)
+print(False != False)
+print(False != True)
+print(True != False)
+print(True != True)
+
+# comparison with integers
+print(False == 0)
+print(0 == False)
+print(True == 1)
+print(1 == True)
+print(True == 2)
+print(2 == True)
+print(False != 0)
+print(0 != False)
+print(True != 1)
+print(1 != True)
+print(True != 2)
+print(2 != True)
+
 # unsupported unary op
 try:
     len(False)
diff --git a/tests/basics/builtin_dir.py b/tests/basics/builtin_dir.py
index c15a76f4c6d30..1eecbd044b7b0 100644
--- a/tests/basics/builtin_dir.py
+++ b/tests/basics/builtin_dir.py
@@ -5,7 +5,7 @@
 
 # dir of module
 import sys
-print('exit' in dir(sys))
+print('version' in dir(sys))
 
 # dir of type
 print('append' in dir(list))
diff --git a/tests/basics/builtin_ellipsis.py b/tests/basics/builtin_ellipsis.py
index d88647a89a203..d66e86de4ab38 100644
--- a/tests/basics/builtin_ellipsis.py
+++ b/tests/basics/builtin_ellipsis.py
@@ -4,3 +4,6 @@
 print(Ellipsis)
 
 print(... == Ellipsis)
+
+# Test that Ellipsis can be hashed
+print(type(hash(Ellipsis)))
diff --git a/tests/basics/builtin_eval_buffer.py b/tests/basics/builtin_eval_buffer.py
new file mode 100644
index 0000000000000..9eaf28204d139
--- /dev/null
+++ b/tests/basics/builtin_eval_buffer.py
@@ -0,0 +1,12 @@
+# test builtin eval with a buffer (bytearray/memoryview) input
+
+try:
+    eval
+    bytearray
+    memoryview
+except:
+    print("SKIP")
+    raise SystemExit
+
+print(eval(bytearray(b'1 + 1')))
+print(eval(memoryview(b'2 + 2')))
diff --git a/tests/basics/builtin_exec_buffer.py b/tests/basics/builtin_exec_buffer.py
new file mode 100644
index 0000000000000..a875cfb1fa85b
--- /dev/null
+++ b/tests/basics/builtin_exec_buffer.py
@@ -0,0 +1,12 @@
+# test builtin exec with a buffer (bytearray/memoryview) input
+
+try:
+    exec
+    bytearray
+    memoryview
+except:
+    print("SKIP")
+    raise SystemExit
+
+exec(bytearray(b'print(1)'))
+exec(memoryview(b'print(2)'))
diff --git a/tests/basics/builtin_override.py b/tests/basics/builtin_override.py
index 9f91341edd8ad..e3cf9165fcb2d 100644
--- a/tests/basics/builtin_override.py
+++ b/tests/basics/builtin_override.py
@@ -12,7 +12,25 @@
 print(abs(1))
 
 # __build_class__ is handled in a special way
+orig_build_class = __build_class__
 builtins.__build_class__ = lambda x, y: ('class', y)
 class A:
     pass
 print(A)
+builtins.__build_class__ = orig_build_class
+
+# __import__ is handled in a special way
+def custom_import(name, globals, locals, fromlist, level):
+    print('import', name, fromlist, level)
+    class M:
+        a = 1
+        b = 2
+    return M
+builtins.__import__ = custom_import
+__import__('A', None, None, None, 0)
+import a
+import a.b
+from a import a
+from a.b import a, b
+from .a import a
+from ..a import a, b
diff --git a/tests/basics/bytearray_construct_array.py b/tests/basics/bytearray_construct_array.py
index bde5fa08bd2c2..52eaa7c6efbdc 100644
--- a/tests/basics/bytearray_construct_array.py
+++ b/tests/basics/bytearray_construct_array.py
@@ -1,9 +1,12 @@
 # test construction of bytearray from different objects
 try:
-    from array import array
+    from uarray import array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        from array import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 # arrays
 print(bytearray(array('b', [1, 2])))
diff --git a/tests/basics/bytearray_construct_endian.py b/tests/basics/bytearray_construct_endian.py
index 0002f19c5f9ba..332b43e68617b 100644
--- a/tests/basics/bytearray_construct_endian.py
+++ b/tests/basics/bytearray_construct_endian.py
@@ -1,9 +1,12 @@
 # test construction of bytearray from different objects
 try:
-    from array import array
+    from uarray import array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        from array import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 # arrays
 print(bytearray(array('h', [1, 2])))
diff --git a/tests/basics/bytearray_decode.py b/tests/basics/bytearray_decode.py
new file mode 100644
index 0000000000000..b5e1cb419bda7
--- /dev/null
+++ b/tests/basics/bytearray_decode.py
@@ -0,0 +1,6 @@
+try:
+    print(bytearray(b'').decode())
+    print(bytearray(b'abc').decode())
+except AttributeError:
+    print("SKIP")
+    raise SystemExit
diff --git a/tests/basics/bytearray_slice_assign.py b/tests/basics/bytearray_slice_assign.py
index 7f7d1d119a7d8..fa7878e10ddbb 100644
--- a/tests/basics/bytearray_slice_assign.py
+++ b/tests/basics/bytearray_slice_assign.py
@@ -59,3 +59,10 @@
 b = bytearray(2)
 b[1:1] = b"12345"
 print(b)
+
+# Growth of bytearray via slice extension
+b = bytearray(b'12345678')
+b.append(57) # expand and add a bit of unused space at end of the bytearray
+for i in range(400):
+    b[-1:] = b'ab' # grow slowly into the unused space
+print(len(b), b)
diff --git a/tests/basics/bytes_add.py b/tests/basics/bytes_add.py
index ebccf0662dbb2..ab027a26dffdf 100644
--- a/tests/basics/bytes_add.py
+++ b/tests/basics/bytes_add.py
@@ -1,8 +1,6 @@
 # test bytes + other
 
 print(b"123" + b"456")
-print(b"123" + bytearray(2))
 
 print(b"123" + b"") # RHS is empty, can be optimised
 print(b"" + b"123") # LHS is empty, can be optimised
-print(b"" + bytearray(1)) # LHS is empty but can't be optimised
diff --git a/tests/basics/bytes_add_array.py b/tests/basics/bytes_add_array.py
index b17556d83cbaf..c6382bed7495c 100644
--- a/tests/basics/bytes_add_array.py
+++ b/tests/basics/bytes_add_array.py
@@ -1,9 +1,12 @@
 # test bytes + other
 try:
-    import array
+    import uarray as array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 # should be byteorder-neutral
 print(b"123" + array.array('h', [0x1515]))
diff --git a/tests/basics/bytes_add_bytearray.py b/tests/basics/bytes_add_bytearray.py
new file mode 100644
index 0000000000000..4998800b512f5
--- /dev/null
+++ b/tests/basics/bytes_add_bytearray.py
@@ -0,0 +1,5 @@
+# test bytes + bytearray
+
+print(b"123" + bytearray(2))
+
+print(b"" + bytearray(1)) # LHS is empty but can't be optimised
diff --git a/tests/basics/bytes_add_endian.py b/tests/basics/bytes_add_endian.py
index 8cfffa7b6ace2..40b3de7d61520 100644
--- a/tests/basics/bytes_add_endian.py
+++ b/tests/basics/bytes_add_endian.py
@@ -1,8 +1,11 @@
 # test bytes + other
 try:
-    import array
+    import uarray as array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 print(b"123" + array.array('i', [1]))
diff --git a/tests/basics/bytes_compare2.py b/tests/basics/bytes_compare2.py
index 4d5de21d2110f..8559685378d6d 100644
--- a/tests/basics/bytes_compare2.py
+++ b/tests/basics/bytes_compare2.py
@@ -1,5 +1 @@
 print(b"1" == 1)
-print(b"123" == bytearray(b"123"))
-print(b'123' < bytearray(b"124"))
-print(b'123' > bytearray(b"122"))
-print(bytearray(b"23") in b"1234")
diff --git a/tests/basics/bytes_compare_array.py b/tests/basics/bytes_compare_array.py
index ad378de70c56b..6bad50b55a1ed 100644
--- a/tests/basics/bytes_compare_array.py
+++ b/tests/basics/bytes_compare_array.py
@@ -1,8 +1,11 @@
 try:
-    import array
+    import uarray as array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 print(array.array('b', [1, 2]) in b'\x01\x02\x03')
 # CPython gives False here
diff --git a/tests/basics/bytes_compare_bytearray.py b/tests/basics/bytes_compare_bytearray.py
new file mode 100644
index 0000000000000..6a8d8b8a51466
--- /dev/null
+++ b/tests/basics/bytes_compare_bytearray.py
@@ -0,0 +1,4 @@
+print(b"123" == bytearray(b"123"))
+print(b'123' < bytearray(b"124"))
+print(b'123' > bytearray(b"122"))
+print(bytearray(b"23") in b"1234")
diff --git a/tests/basics/bytes_construct.py b/tests/basics/bytes_construct.py
index 0d638c08f213a..6f83f1cb20806 100644
--- a/tests/basics/bytes_construct.py
+++ b/tests/basics/bytes_construct.py
@@ -1,9 +1,8 @@
 # test construction of bytes from different objects
 
-# tuple, list, bytearray
+# tuple, list
 print(bytes((1, 2)))
 print(bytes([1, 2]))
-print(bytes(bytearray(4)))
 
 # constructor value out of range
 try:
diff --git a/tests/basics/bytes_construct_array.py b/tests/basics/bytes_construct_array.py
index 453eb59010392..7bdd8f10df4de 100644
--- a/tests/basics/bytes_construct_array.py
+++ b/tests/basics/bytes_construct_array.py
@@ -1,9 +1,12 @@
 # test construction of bytes from different objects
 try:
-    from array import array
+    from uarray import array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        from array import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 # arrays
 print(bytes(array('b', [1, 2])))
diff --git a/tests/basics/bytes_construct_bytearray.py b/tests/basics/bytes_construct_bytearray.py
new file mode 100644
index 0000000000000..75f08acd3b772
--- /dev/null
+++ b/tests/basics/bytes_construct_bytearray.py
@@ -0,0 +1,3 @@
+# test construction of bytes from bytearray
+
+print(bytes(bytearray(4)))
diff --git a/tests/basics/bytes_construct_endian.py b/tests/basics/bytes_construct_endian.py
index cf1a9f408fa8d..294c5f23f5cff 100644
--- a/tests/basics/bytes_construct_endian.py
+++ b/tests/basics/bytes_construct_endian.py
@@ -1,10 +1,13 @@
 # test construction of bytes from different objects
 
 try:
-    from array import array
+    from uarray import array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        from array import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 # arrays
 print(bytes(array('h', [1, 2])))
diff --git a/tests/basics/bytes_format_modulo.py b/tests/basics/bytes_format_modulo.py
index 70246e72dcf6c..b928f593e04ef 100644
--- a/tests/basics/bytes_format_modulo.py
+++ b/tests/basics/bytes_format_modulo.py
@@ -1,4 +1,11 @@
 # This test requires CPython3.5
+
+try:
+    b'' % ()
+except TypeError:
+    print("SKIP")
+    raise SystemExit
+
 print(b"%%" % ())
 print(b"=%d=" % 1)
 print(b"=%d=%d=" % (1, 2))
diff --git a/tests/basics/class_bases.py b/tests/basics/class_bases.py
new file mode 100644
index 0000000000000..d3cf4f598a553
--- /dev/null
+++ b/tests/basics/class_bases.py
@@ -0,0 +1,45 @@
+# test for type.__bases__ implementation
+
+if not hasattr(object, '__bases__'):
+    print("SKIP")
+    raise SystemExit
+
+class A:
+    pass
+
+class B(object):
+    pass
+
+class C(B):
+    pass
+
+class D(C, A):
+    pass
+
+# Check the attribute exists
+print(hasattr(A, '__bases__'))
+print(hasattr(B, '__bases__'))
+print(hasattr(C, '__bases__'))
+print(hasattr(D, '__bases__'))
+
+# Check it is always a tuple
+print(type(A.__bases__) == tuple)
+print(type(B.__bases__) == tuple)
+print(type(C.__bases__) == tuple)
+print(type(D.__bases__) == tuple)
+
+# Check size
+print(len(A.__bases__) == 1)
+print(len(B.__bases__) == 1)
+print(len(C.__bases__) == 1)
+print(len(D.__bases__) == 2)
+
+# Check values
+print(A.__bases__[0] == object)
+print(B.__bases__[0] == object)
+print(C.__bases__[0] == B)
+print(D.__bases__[0] == C)
+print(D.__bases__[1] == A)
+
+# Object has an empty tuple
+print(object.__bases__ == tuple())
diff --git a/tests/basics/class_delattr_setattr.py b/tests/basics/class_delattr_setattr.py
index 190b4875b90bc..3389c091abc04 100644
--- a/tests/basics/class_delattr_setattr.py
+++ b/tests/basics/class_delattr_setattr.py
@@ -60,3 +60,54 @@ def __delattr__(self, attr):
     print(a.a)
 except AttributeError:
     print("AttributeError")
+
+# test object.__setattr__
+class C:
+    def __init__(self):
+        pass
+
+    def __setattr__(self, attr, value):
+        print(attr, "=", value)
+
+    def __delattr__(self, attr):
+        print("del", attr)
+
+c = C()
+c.a = 5
+try:
+    print(c.a)
+except AttributeError:
+    print("AttributeError")
+
+object.__setattr__(c, "a", 5)
+super(C, c).__setattr__("b", 6)
+print(c.a)
+print(c.b)
+
+try:
+    # attribute name must be string
+    object.__setattr__(c, 5, 5)
+except TypeError:
+    print("TypeError")
+
+
+# test object.__delattr__
+del c.a
+print(c.a)
+
+object.__delattr__(c, "a")
+try:
+    print(c.a)
+except AttributeError:
+    print("AttributeError")
+
+super(C, c).__delattr__("b")
+try:
+    print(c.b)
+except AttributeError:
+    print("AttributeError")
+
+try:
+    object.__delattr__(c, "c")
+except AttributeError:
+    print("AttributeError")
diff --git a/tests/basics/class_inplace_op.py b/tests/basics/class_inplace_op.py
index 62aad8c7cfc61..8885bdaa850f8 100644
--- a/tests/basics/class_inplace_op.py
+++ b/tests/basics/class_inplace_op.py
@@ -10,7 +10,7 @@ def __add__(self, o):
         return A(self.v + o.v)
 
     def __repr__(self):
-        return "A(%s)" % self.v
+        return "A({})".format(self.v)
 
 a = A(5)
 b = a
@@ -37,7 +37,7 @@ def __iadd__(self, o):
         return self
 
     def __repr__(self):
-        return "L(%s)" % self.v
+        return "L({})".format(self.v)
 
 c = L([1, 2])
 d = c
diff --git a/tests/basics/class_misc.py b/tests/basics/class_misc.py
index 82b9b3479e692..34b1a3bc646bb 100644
--- a/tests/basics/class_misc.py
+++ b/tests/basics/class_misc.py
@@ -4,6 +4,6 @@ class C:
 
 c = C()
 try:
-    d = bytearray(c)
+    d = bytes(c)
 except TypeError:
     print('TypeError')
diff --git a/tests/basics/class_notimpl.py b/tests/basics/class_notimpl.py
index 7fd8166f90840..58e790716b9b7 100644
--- a/tests/basics/class_notimpl.py
+++ b/tests/basics/class_notimpl.py
@@ -11,7 +11,7 @@ def __init__(self, value):
         self.value = value
 
     def __str__(self):
-        return "C(%s)" % self.value
+        return "C({})".format(self.value)
 
     def __add__(self, rhs):
         print(self, '+', rhs)
@@ -48,3 +48,6 @@ def __neg__(self):
 
 # NotImplemented isn't handled specially in unary methods
 print(-c)
+
+# Test that NotImplemented can be hashed
+print(type(hash(NotImplemented)))
diff --git a/tests/basics/class_reverse_op.py b/tests/basics/class_reverse_op.py
index d41c55c9d764e..b0dae5f8a336c 100644
--- a/tests/basics/class_reverse_op.py
+++ b/tests/basics/class_reverse_op.py
@@ -12,7 +12,7 @@ def __radd__(self, o):
         return A(self.v + o)
 
     def __repr__(self):
-        return "A(%s)" % self.v
+        return "A({})".format(self.v)
 
 print(A(3) + 1)
 print(2 + A(5))
diff --git a/tests/basics/dict1.py b/tests/basics/dict1.py
index 0cec51173ac18..cd793c9ed2a47 100644
--- a/tests/basics/dict1.py
+++ b/tests/basics/dict1.py
@@ -23,6 +23,34 @@
 # equality operator on dicts of same size but with different keys
 print({1:1} == {2:1})
 
+# 0 replacing False's item
+d = {}
+d[False] = 'false'
+d[0] = 'zero'
+print(d)
+
+# False replacing 0's item
+d = {}
+d[0] = 'zero'
+d[False] = 'false'
+print(d)
+
+# 1 replacing True's item
+d = {}
+d[True] = 'true'
+d[1] = 'one'
+print(d)
+
+# True replacing 1's item
+d = {}
+d[1] = 'one'
+d[True] = 'true'
+print(d)
+
+# mixed bools and integers
+d = {False:10, True:11, 2:12}
+print(d[0], d[1], d[2])
+
 # value not found
 try:
     {}[0]
diff --git a/tests/basics/dict_pop.py b/tests/basics/dict_pop.py
index 602560ce9d402..454eb07cc0421 100644
--- a/tests/basics/dict_pop.py
+++ b/tests/basics/dict_pop.py
@@ -5,8 +5,8 @@
 print(d.pop(1, 42), d)
 print(d.pop(1, None), d)
 try:
-    print(d.pop(1), "!!!",)
+    print(d.pop(1), "!!!")
 except KeyError:
     print("Raised KeyError")
 else:
-    print("Did not rise KeyError!")
+    print("Did not raise KeyError!")
diff --git a/tests/basics/fun_name.py b/tests/basics/fun_name.py
index 53ca935616ce3..bb1f14992f70f 100644
--- a/tests/basics/fun_name.py
+++ b/tests/basics/fun_name.py
@@ -22,3 +22,11 @@ def Fun(self):
     str((1).to_bytes.__name__)
 except AttributeError:
     pass
+
+# name of a function that has closed over variables
+def outer():
+    x = 1
+    def inner():
+        return x
+    return inner
+print(outer.__name__)
diff --git a/tests/basics/gen_yield_from_pending.py b/tests/basics/gen_yield_from_pending.py
new file mode 100644
index 0000000000000..eb88ee6ca781a
--- /dev/null
+++ b/tests/basics/gen_yield_from_pending.py
@@ -0,0 +1,23 @@
+# Tests that the pending exception state is managed correctly
+# (previously failed on native emitter).
+
+def noop_task():
+    print('noop task')
+    yield 1
+
+def raise_task():
+    print('raise task')
+    yield 2
+    print('raising')
+    raise Exception
+
+def main():
+    try:
+        yield from raise_task()
+    except:
+        print('main exception')
+
+    yield from noop_task()
+
+for z in main():
+    print('outer iter', z)
diff --git a/tests/basics/gen_yield_from_throw.py b/tests/basics/gen_yield_from_throw.py
index 703158f4d42ab..1f76e13f3c34c 100644
--- a/tests/basics/gen_yield_from_throw.py
+++ b/tests/basics/gen_yield_from_throw.py
@@ -1,8 +1,8 @@
 def gen():
     try:
         yield 1
-    except ValueError:
-        print("got ValueError from upstream!")
+    except ValueError as e:
+        print("got ValueError from upstream!", repr(e.args))
     yield "str1"
     raise TypeError
 
@@ -16,3 +16,35 @@ def gen2():
     print(next(g))
 except TypeError:
     print("got TypeError from downstream!")
+
+# passing None as second argument to throw
+g = gen2()
+print(next(g))
+print(g.throw(ValueError, None))
+try:
+    print(next(g))
+except TypeError:
+    print("got TypeError from downstream!")
+
+# passing an exception instance as second argument to throw
+g = gen2()
+print(next(g))
+print(g.throw(ValueError, ValueError(123)))
+try:
+    print(next(g))
+except TypeError:
+    print("got TypeError from downstream!")
+
+# thrown value is caught and then generator returns normally
+def gen():
+    try:
+        yield 123
+    except ValueError:
+        print('ValueError')
+    # return normally after catching thrown exception
+def gen2():
+    yield from gen()
+    yield 789
+g = gen2()
+print(next(g))
+print(g.throw(ValueError))
diff --git a/tests/basics/generator_pend_throw.py b/tests/basics/generator_pend_throw.py
index f00ff793b64fa..ae8c21189e9e0 100644
--- a/tests/basics/generator_pend_throw.py
+++ b/tests/basics/generator_pend_throw.py
@@ -13,6 +13,7 @@ def gen():
     raise SystemExit
 
 
+# Verify that an injected exception will be raised from next().
 print(next(g))
 print(next(g))
 g.pend_throw(ValueError())
@@ -25,7 +26,76 @@ def gen():
 
 print("ret was:", v)
 
+
+# Verify that pend_throw works on an unstarted coroutine.
+g = gen()
+g.pend_throw(OSError())
+try:
+    next(g)
+except Exception as e:
+    print("raised", repr(e))
+
+
+# Verify that you can't resume the coroutine from within the running coroutine.
+def gen_next():
+    next(g)
+    yield 1
+
+g = gen_next()
+
+try:
+    next(g)
+except Exception as e:
+    print("raised", repr(e))
+
+
+# Verify that you can't pend_throw from within the running coroutine.
+def gen_pend_throw():
+    g.pend_throw(ValueError())
+    yield 1
+
+g = gen_pend_throw()
+
+try:
+    next(g)
+except Exception as e:
+    print("raised", repr(e))
+
+
+# Verify that the pend_throw exception can be ignored.
+class CancelledError(Exception):
+    pass
+
+def gen_cancelled():
+    for i in range(5):
+        try:
+            yield i
+        except CancelledError:
+            print('ignore CancelledError')
+
+g = gen_cancelled()
+print(next(g))
+g.pend_throw(CancelledError())
+print(next(g))
+# ...but not if the generator hasn't started.
+g = gen_cancelled()
+g.pend_throw(CancelledError())
 try:
-    gen().pend_throw(ValueError())
-except TypeError:
-    print("TypeError")
+    next(g)
+except Exception as e:
+    print("raised", repr(e))
+
+
+# Verify that calling pend_throw returns the previous exception.
+g = gen()
+next(g)
+print(repr(g.pend_throw(CancelledError())))
+print(repr(g.pend_throw(OSError)))
+
+
+# Verify that you can pend_throw(None) to cancel a previous pend_throw.
+g = gen()
+next(g)
+g.pend_throw(CancelledError())
+print(repr(g.pend_throw(None)))
+print(next(g))
diff --git a/tests/basics/generator_pend_throw.py.exp b/tests/basics/generator_pend_throw.py.exp
index ed4d8829580ad..8a3dadfec7a38 100644
--- a/tests/basics/generator_pend_throw.py.exp
+++ b/tests/basics/generator_pend_throw.py.exp
@@ -2,4 +2,14 @@
 1
 raised ValueError()
 ret was: None
-TypeError
+raised OSError()
+raised ValueError('generator already executing',)
+raised ValueError('generator already executing',)
+0
+ignore CancelledError
+1
+raised CancelledError()
+None
+CancelledError()
+CancelledError()
+1
diff --git a/tests/basics/generator_pep479.py b/tests/basics/generator_pep479.py
index e422c349e7522..53853121702cb 100644
--- a/tests/basics/generator_pep479.py
+++ b/tests/basics/generator_pep479.py
@@ -27,3 +27,14 @@ def gen():
     g.throw(StopIteration)
 except RuntimeError:
     print('RuntimeError')
+
+# throwing a StopIteration through yield from, will be converted to a RuntimeError
+def gen():
+    yield from range(2)
+    print('should not get here')
+g = gen()
+print(next(g))
+try:
+    g.throw(StopIteration)
+except RuntimeError:
+    print('RuntimeError')
diff --git a/tests/basics/generator_pep479.py.exp b/tests/basics/generator_pep479.py.exp
index c64fe49561a98..610133946249a 100644
--- a/tests/basics/generator_pep479.py.exp
+++ b/tests/basics/generator_pep479.py.exp
@@ -3,3 +3,5 @@ RuntimeError
 StopIteration
 1
 RuntimeError
+0
+RuntimeError
diff --git a/tests/basics/generator_throw.py b/tests/basics/generator_throw.py
index bf5ff33a257bf..1b43c125eabc1 100644
--- a/tests/basics/generator_throw.py
+++ b/tests/basics/generator_throw.py
@@ -28,8 +28,8 @@ def gen():
 def gen():
     try:
         yield 123
-    except GeneratorExit:
-        print('GeneratorExit')
+    except GeneratorExit as e:
+        print('GeneratorExit', repr(e.args))
     yield 456
         
 # thrown a class
@@ -41,3 +41,13 @@ def gen():
 g = gen()
 print(next(g))
 print(g.throw(GeneratorExit()))
+
+# thrown an instance with None as second arg
+g = gen()
+print(next(g))
+print(g.throw(GeneratorExit(), None))
+
+# thrown a class and instance
+g = gen()
+print(next(g))
+print(g.throw(GeneratorExit, GeneratorExit(123)))
diff --git a/tests/basics/generator_throw_nested.py b/tests/basics/generator_throw_nested.py
new file mode 100644
index 0000000000000..5ef166878836c
--- /dev/null
+++ b/tests/basics/generator_throw_nested.py
@@ -0,0 +1,33 @@
+# Tests that the correct nested exception handler is used when
+# throwing into a generator (previously failed on native emitter).
+
+def gen():
+    try:
+        yield 1
+        try:
+            yield 2
+            try:
+                yield 3
+            except Exception:
+                yield 4
+                print(0)
+            yield 5
+        except Exception:
+            yield 6
+            print(1)
+        yield 7
+    except Exception:
+        yield 8
+        print(2)
+    yield 9
+
+for i in range(1, 10):
+    g = gen()
+    try:
+        for _ in range(i):
+            print(next(g))
+        print(g.throw(ValueError))
+    except ValueError:
+        print('ValueError')
+    except StopIteration:
+        print('StopIteration')
diff --git a/tests/basics/int_constfolding.py b/tests/basics/int_constfolding.py
index 158897f55335f..3168685ff5fe9 100644
--- a/tests/basics/int_constfolding.py
+++ b/tests/basics/int_constfolding.py
@@ -30,6 +30,10 @@
 print(123 // -7, 123 % -7)
 print(-123 // -7, -123 % -7)
 
+# power
+print(2 ** 3)
+print(3 ** 4)
+
 # won't fold so an exception can be raised at runtime
 try:
     1 << -1
diff --git a/tests/basics/io_stringio1.py b/tests/basics/io_stringio1.py
index 9f7c1e44ef60c..41089f22d5398 100644
--- a/tests/basics/io_stringio1.py
+++ b/tests/basics/io_stringio1.py
@@ -33,6 +33,11 @@
 a.write("foo")
 print(a.read())
 
+a = io.StringIO()
+print(a.tell())
+a.write("foo")
+print(a.tell())
+
 a = io.StringIO()
 a.close()
 for f in [a.read, a.getvalue, lambda:a.write("")]:
diff --git a/tests/basics/list1.py b/tests/basics/list1.py
index fa426c0e58fdd..0697c9e3a78e7 100644
--- a/tests/basics/list1.py
+++ b/tests/basics/list1.py
@@ -19,10 +19,6 @@
 x += [2, 1]
 print(x)
 
-print(x[1:])
-print(x[:-1])
-print(x[2:3])
-
 # unsupported type on RHS of add
 try:
     [] + None
diff --git a/tests/basics/list_slice.py b/tests/basics/list_slice.py
index fc08e580a17e5..6b2d2ad059b09 100644
--- a/tests/basics/list_slice.py
+++ b/tests/basics/list_slice.py
@@ -1,6 +1,11 @@
 # test list slices, getting values
 
 x = list(range(10))
+
+print(x[1:])
+print(x[:-1])
+print(x[2:3])
+
 a = 2
 b = 4
 c = 3
diff --git a/tests/basics/memoryview1.py b/tests/basics/memoryview1.py
index c4cc6ffab726a..1bfeabdfdc824 100644
--- a/tests/basics/memoryview1.py
+++ b/tests/basics/memoryview1.py
@@ -4,6 +4,14 @@
 except:
     print("SKIP")
     raise SystemExit
+try:
+    import uarray as array
+except ImportError:
+    try:
+        import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 # test reading from bytes
 b = b'1234'
@@ -39,7 +47,6 @@
 print(bytearray(m))
 print(list(memoryview(memoryview(b'1234')))) # read-only memoryview
 
-import array
 a = array.array('i', [1, 2, 3, 4])
 m = memoryview(a)
 print(list(m))
@@ -94,3 +101,27 @@
     memoryview(array.array('i'))[0:2] = b'1234'
 except ValueError:
     print('ValueError')
+
+# invalid attribute
+try:
+    memoryview(b'a').noexist
+except AttributeError:
+    print('AttributeError')
+
+# equality
+print(memoryview(b'abc') == b'abc')
+print(memoryview(b'abc') != b'abc')
+print(memoryview(b'abc') == b'xyz')
+print(memoryview(b'abc') != b'xyz')
+print(b'abc' == memoryview(b'abc'))
+print(b'abc' != memoryview(b'abc'))
+print(b'abc' == memoryview(b'xyz'))
+print(b'abc' != memoryview(b'xyz'))
+print(memoryview(b'abcdef')[2:4] == b'cd')
+print(memoryview(b'abcdef')[2:4] != b'cd')
+print(memoryview(b'abcdef')[2:4] == b'xy')
+print(memoryview(b'abcdef')[2:4] != b'xy')
+print(b'cd' == memoryview(b'abcdef')[2:4])
+print(b'cd' != memoryview(b'abcdef')[2:4])
+print(b'xy' == memoryview(b'abcdef')[2:4])
+print(b'xy' != memoryview(b'abcdef')[2:4])
diff --git a/tests/basics/memoryview2.py b/tests/basics/memoryview2.py
index 06a7be59fdbd1..eacc227c28317 100644
--- a/tests/basics/memoryview2.py
+++ b/tests/basics/memoryview2.py
@@ -1,10 +1,17 @@
 # test memoryview accessing maximum values for signed/unsigned elements
 try:
-    from array import array
     memoryview
 except:
     print("SKIP")
     raise SystemExit
+try:
+    from uarray import array
+except ImportError:
+    try:
+        from array import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 print(list(memoryview(b'\x7f\x80\x81\xff')))
 print(list(memoryview(array('b', [0x7f, -0x80]))))
diff --git a/tests/basics/memoryview_intbig.py b/tests/basics/memoryview_intbig.py
index a76d9cbec705e..4800a70cc2726 100644
--- a/tests/basics/memoryview_intbig.py
+++ b/tests/basics/memoryview_intbig.py
@@ -1,10 +1,17 @@
 # test memoryview accessing maximum values for signed/unsigned elements
 try:
-    from array import array
     memoryview
 except:
     print("SKIP")
     raise SystemExit
+try:
+    from uarray import array
+except ImportError:
+    try:
+        from array import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 print(list(memoryview(array('i', [0x7f000000, -0x80000000]))))
 print(list(memoryview(array('I', [0x7f000000, 0x80000000, 0x81000000, 0xffffffff]))))
diff --git a/tests/basics/memoryview_itemsize.py b/tests/basics/memoryview_itemsize.py
new file mode 100644
index 0000000000000..64a8822b8b214
--- /dev/null
+++ b/tests/basics/memoryview_itemsize.py
@@ -0,0 +1,25 @@
+try:
+    memoryview(b'a').itemsize
+except:
+    print("SKIP")
+    raise SystemExit
+try:
+    from uarray import array
+except ImportError:
+    try:
+        from array import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+for code in ['b', 'h', 'i', 'q', 'f', 'd']:
+    print(memoryview(array(code)).itemsize)
+
+# 'l' varies depending on word size of the machine
+print(memoryview(array('l')).itemsize in (4, 8))
+
+# shouldn't be able to store to the itemsize attribute
+try:
+    memoryview(b'a').itemsize = 1
+except AttributeError:
+    print('AttributeError')
diff --git a/tests/basics/namedtuple1.py b/tests/basics/namedtuple1.py
index 57976d39ae34d..47c0360eb9bee 100644
--- a/tests/basics/namedtuple1.py
+++ b/tests/basics/namedtuple1.py
@@ -24,6 +24,9 @@
 
     print(isinstance(t, tuple))
 
+    # Check tuple can compare equal to namedtuple with same elements
+    print(t == (t[0], t[1]), (t[0], t[1]) == t)
+
 # Create using positional and keyword args
 print(T(3, bar=4))
 
diff --git a/tests/basics/op_error.py b/tests/basics/op_error.py
index 7b4f896e1410e..63c35db3f5f94 100644
--- a/tests/basics/op_error.py
+++ b/tests/basics/op_error.py
@@ -13,10 +13,6 @@
     ~[]
 except TypeError:
     print('TypeError')
-try:
-    ~bytearray()
-except TypeError:
-    print('TypeError')
 
 # unsupported binary operators
 try:
@@ -31,16 +27,6 @@
     1 in 1
 except TypeError:
     print('TypeError')
-try:
-    bytearray() // 2
-except TypeError:
-    print('TypeError')
-
-# object with buffer protocol needed on rhs
-try:
-    bytearray(1) + 1
-except TypeError:
-    print('TypeError')
 
 # unsupported subscription
 try:
diff --git a/tests/basics/op_error_bytearray.py b/tests/basics/op_error_bytearray.py
new file mode 100644
index 0000000000000..9ab69371d22de
--- /dev/null
+++ b/tests/basics/op_error_bytearray.py
@@ -0,0 +1,19 @@
+# test errors from bad operations (unary, binary, etc)
+
+# unsupported unary operators
+try:
+    ~bytearray()
+except TypeError:
+    print('TypeError')
+
+# unsupported binary operators
+try:
+    bytearray() // 2
+except TypeError:
+    print('TypeError')
+
+# object with buffer protocol needed on rhs
+try:
+    bytearray(1) + 1
+except TypeError:
+    print('TypeError')
diff --git a/tests/basics/ordereddict1.py b/tests/basics/ordereddict1.py
index d1633f0bb0e1f..270deab3846a9 100644
--- a/tests/basics/ordereddict1.py
+++ b/tests/basics/ordereddict1.py
@@ -24,3 +24,23 @@
 print(len(d))
 print(list(d.keys()))
 print(list(d.values()))
+
+# pop an element
+print(d.popitem())
+print(len(d))
+print(list(d.keys()))
+print(list(d.values()))
+
+# add an element after popping
+d["xyz"] = 321
+print(len(d))
+print(list(d.keys()))
+print(list(d.values()))
+
+# pop until empty
+print(d.popitem())
+print(d.popitem())
+try:
+    d.popitem()
+except:
+    print('empty')
diff --git a/tests/basics/parser.py.exp b/tests/basics/parser.py.exp
new file mode 100644
index 0000000000000..4d9886a09c096
--- /dev/null
+++ b/tests/basics/parser.py.exp
@@ -0,0 +1,3 @@
+SyntaxError
+SyntaxError
+SyntaxError
diff --git a/tests/basics/set_add.py b/tests/basics/set_add.py
index ac81f48491ce5..d8cfdaad97cfb 100644
--- a/tests/basics/set_add.py
+++ b/tests/basics/set_add.py
@@ -1,3 +1,23 @@
 s = {1, 2, 3, 4}
 print(s.add(5))
 print(sorted(s))
+
+s = set()
+s.add(0)
+s.add(False)
+print(s)
+
+s = set()
+s.add(False)
+s.add(0)
+print(s)
+
+s = set()
+s.add(1)
+s.add(True)
+print(s)
+
+s = set()
+s.add(True)
+s.add(1)
+print(s)
diff --git a/tests/basics/set_basic.py b/tests/basics/set_basic.py
index 6ea69e4f05762..2d1653622ecf6 100644
--- a/tests/basics/set_basic.py
+++ b/tests/basics/set_basic.py
@@ -10,6 +10,10 @@
 s = {1 + len(s)}
 print(s)
 
+# bools mixed with integers
+s = {False, True, 0, 1, 2}
+print(len(s))
+
 # Sets are not hashable
 try:
     {s: 1}
diff --git a/tests/basics/slice_indices.py b/tests/basics/slice_indices.py
new file mode 100644
index 0000000000000..b7f439ccca267
--- /dev/null
+++ b/tests/basics/slice_indices.py
@@ -0,0 +1,27 @@
+# Test builtin slice indices resolution
+
+# A class that returns an item key
+class A:
+    def __getitem__(self, idx):
+        return idx
+
+# Make sure that we have slices and .indices()
+try:
+    A()[2:5].indices(10)
+except:
+    print("SKIP")
+    raise SystemExit
+
+print(A()[:].indices(10))
+print(A()[2:].indices(10))
+print(A()[:7].indices(10))
+print(A()[2:7].indices(10))
+print(A()[2:7:2].indices(10))
+print(A()[2:7:-2].indices(10))
+print(A()[7:2:2].indices(10))
+print(A()[7:2:-2].indices(10))
+
+print(A()[2:7:2].indices(5))
+print(A()[2:7:-2].indices(5))
+print(A()[7:2:2].indices(5))
+print(A()[7:2:-2].indices(5))
diff --git a/tests/basics/special_comparisons.py b/tests/basics/special_comparisons.py
new file mode 100644
index 0000000000000..2ebd7e224efda
--- /dev/null
+++ b/tests/basics/special_comparisons.py
@@ -0,0 +1,33 @@
+class A:
+    def __eq__(self, other):
+        print("A __eq__ called")
+        return True
+
+class B:
+    def __ne__(self, other):
+        print("B __ne__ called")
+        return True
+
+class C:
+    def __eq__(self, other):
+        print("C __eq__ called")
+        return False
+
+class D:
+    def __ne__(self, other):
+        print("D __ne__ called")
+        return False
+
+a = A()
+b = B()
+c = C()
+d = D()
+
+def test(s):
+    print(s)
+    print(eval(s))
+
+for x in 'abcd':
+    for y in 'abcd':
+        test('{} == {}'.format(x,y))
+        test('{} != {}'.format(x,y))
diff --git a/tests/basics/special_comparisons2.py b/tests/basics/special_comparisons2.py
new file mode 100644
index 0000000000000..c29dc72ce60c0
--- /dev/null
+++ b/tests/basics/special_comparisons2.py
@@ -0,0 +1,31 @@
+class E:
+    def __repr__(self):
+        return "E"
+
+    def __eq__(self, other):
+        print('E eq', other)
+        return 123
+
+class F:
+    def __repr__(self):
+        return "F"
+
+    def __ne__(self, other):
+        print('F ne', other)
+        return -456
+
+print(E() != F())
+print(F() != E())
+
+tests = (None, 0, 1, 'a')
+
+for val in tests:
+    print('==== testing', val)
+    print(E() == val)
+    print(val == E())
+    print(E() != val)
+    print(val != E())
+    print(F() == val)
+    print(val == F())
+    print(F() != val)
+    print(val != F())
diff --git a/tests/basics/special_methods2.py b/tests/basics/special_methods2.py
index c72c8cf00f571..09e43fff29973 100644
--- a/tests/basics/special_methods2.py
+++ b/tests/basics/special_methods2.py
@@ -111,6 +111,7 @@ def __dir__(self):
 -cud1
 ~cud1
 cud1 * cud2
+cud1 @ cud2
 cud1 / cud2
 cud2 // cud1
 cud1 += cud2
diff --git a/tests/basics/special_methods2.py.exp b/tests/basics/special_methods2.py.exp
new file mode 100644
index 0000000000000..a9ae75be55c95
--- /dev/null
+++ b/tests/basics/special_methods2.py.exp
@@ -0,0 +1,19 @@
+__pos__ called
+__pos__ called
+__neg__ called
+__invert__ called
+__mul__ called
+__matmul__ called
+__truediv__ called
+__floordiv__ called
+__iadd__ called
+__isub__ called
+__mod__ called
+__pow__ called
+__or__ called
+__and__ called
+__xor__ called
+__lshift__ called
+__rshift__ called
+['a', 'b', 'c']
+False
diff --git a/tests/basics/string_format.py b/tests/basics/string_format.py
index 8b2592406737f..e8600f5836139 100644
--- a/tests/basics/string_format.py
+++ b/tests/basics/string_format.py
@@ -63,6 +63,12 @@ def test(fmt, *args):
 test("{:^20}", "foo")
 test("{:<20}", "foo")
 
+# formatting bool as int
+test('{:d}', False)
+test('{:20}', False)
+test('{:d}', True)
+test('{:20}', True)
+
 # nested format specifiers
 print("{:{}}".format(123, '#>10'))
 print("{:{}{}{}}".format(123, '#', '>', '10'))
diff --git a/tests/basics/string_format_modulo.py b/tests/basics/string_format_modulo.py
index 77bbcfbe36dd7..01f8e7ed24059 100644
--- a/tests/basics/string_format_modulo.py
+++ b/tests/basics/string_format_modulo.py
@@ -1,3 +1,9 @@
+try:
+    '' % ()
+except TypeError:
+    print("SKIP")
+    raise SystemExit
+
 print("%%" % ())
 print("=%s=" % 1)
 print("=%s=%s=" % (1, 2))
@@ -34,6 +40,9 @@
 print("%10s" % 'abc')
 print("%-10s" % 'abc')
 
+print('%c' % False)
+print('%c' % True)
+
 # Should be able to print dicts; in this case they aren't used
 # to lookup keywords in formats like %(foo)s
 print('%s' % {})
diff --git a/tests/basics/string_format_modulo_int.py b/tests/basics/string_format_modulo_int.py
index d1f29db2209a2..d057522bfc9ae 100644
--- a/tests/basics/string_format_modulo_int.py
+++ b/tests/basics/string_format_modulo_int.py
@@ -1,5 +1,11 @@
 # test string modulo formatting with int values
 
+try:
+    '' % ()
+except TypeError:
+    print("SKIP")
+    raise SystemExit
+
 # basic cases
 print("%d" % 10)
 print("%+d" % 10)
diff --git a/tests/basics/string_repr.py b/tests/basics/string_repr.py
index 2a3ef2527c592..b4842e1475f9b 100644
--- a/tests/basics/string_repr.py
+++ b/tests/basics/string_repr.py
@@ -1,4 +1,4 @@
 # anything above 0xa0 is printed as Unicode by CPython
 # the abobe is CPython implementation detail, stick to ASCII
 for c in range(0x80):
-    print("0x%02x: %s" % (c, repr(chr(c))))
+    print("0x{:02x}: {}".format(c, repr(chr(c))))
diff --git a/tests/basics/struct_endian.py b/tests/basics/struct_endian.py
new file mode 100644
index 0000000000000..91f5539c15927
--- /dev/null
+++ b/tests/basics/struct_endian.py
@@ -0,0 +1,24 @@
+# test ustruct and endian specific things
+
+try:
+    import ustruct as struct
+except:
+    try:
+        import struct
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+# unpack/unpack_from with unaligned native type
+buf = b'0123456789'
+print(struct.unpack('h', memoryview(buf)[1:3]))
+print(struct.unpack_from('i', buf, 1))
+print(struct.unpack_from('@i', buf, 1))
+print(struct.unpack_from('@ii', buf, 1))
+
+# pack_into with unaligned native type
+buf = bytearray(b'>----<<<<<<<')
+struct.pack_into('i', buf, 1, 0x30313233)
+print(buf)
+struct.pack_into('@ii', buf, 3, 0x34353637, 0x41424344)
+print(buf)
diff --git a/tests/basics/subclass_native2_tuple.py b/tests/basics/subclass_native2_tuple.py
index 9eb69e1575e25..a02d3a66dcb2c 100644
--- a/tests/basics/subclass_native2_tuple.py
+++ b/tests/basics/subclass_native2_tuple.py
@@ -19,3 +19,11 @@ class Ctuple2(tuple, Base1):
 print(len(a))
 a = Ctuple2([1, 2, 3])
 print(len(a))
+
+a = tuple([1,2,3])
+b = Ctuple1([1,2,3])
+c = Ctuple2([1,2,3])
+
+print(a == b)
+print(b == c)
+print(c == a)
diff --git a/tests/basics/subclass_native_buffer.py b/tests/basics/subclass_native_buffer.py
index 43c38196570dd..00717a70e7d17 100644
--- a/tests/basics/subclass_native_buffer.py
+++ b/tests/basics/subclass_native_buffer.py
@@ -12,5 +12,5 @@ class my_bytes(bytes):
 print(b1 + b3)
 print(b3 + b1)
 
-# bytearray construction will use the buffer protocol
-print(bytearray(b1))
+# bytes construction will use the buffer protocol
+print(bytes(b1))
diff --git a/tests/basics/subclass_native_call.py b/tests/basics/subclass_native_call.py
index c645575225989..969f0a415ea15 100644
--- a/tests/basics/subclass_native_call.py
+++ b/tests/basics/subclass_native_call.py
@@ -4,13 +4,13 @@
 # and is callable (has call).  The only one available is machine.Signal, which
 # in turns needs PinBase.
 try:
-    import umachine as machine
-except ImportError:
-    import machine
-try:
+    try:
+        import umachine as machine
+    except ImportError:
+        import machine
     machine.PinBase
     machine.Signal
-except AttributeError:
+except:
     print("SKIP")
     raise SystemExit
 
diff --git a/tests/basics/subclass_native_cmp.py b/tests/basics/subclass_native_cmp.py
index 1a095bfa1a5b7..104b9f954afd3 100644
--- a/tests/basics/subclass_native_cmp.py
+++ b/tests/basics/subclass_native_cmp.py
@@ -7,3 +7,6 @@ class mytuple(tuple):
 print(t)
 print(t == (1, 2, 3))
 print((1, 2, 3) == t)
+
+print(t < (1, 2, 3), t < (1, 2, 4))
+print((1, 2, 3) <= t, (1, 2, 4) < t)
diff --git a/tests/basics/subclass_native_str.py b/tests/basics/subclass_native_str.py
new file mode 100644
index 0000000000000..32090ce270c8c
--- /dev/null
+++ b/tests/basics/subclass_native_str.py
@@ -0,0 +1,10 @@
+# Test subclassing built-in str
+
+class S(str):
+    pass
+
+s = S('hello')
+print(s == 'hello')
+print('hello' == s)
+print(s == 'Hello')
+print('Hello' == s)
diff --git a/tests/basics/syntaxerror.py b/tests/basics/syntaxerror.py
index 8e706c6e23923..c0702cb24525e 100644
--- a/tests/basics/syntaxerror.py
+++ b/tests/basics/syntaxerror.py
@@ -82,7 +82,6 @@ def test_syntax(code):
 test_syntax("continue")
 
 # must be in a function
-test_syntax("return")
 test_syntax("yield")
 test_syntax("nonlocal a")
 test_syntax("await 1")
diff --git a/tests/basics/syntaxerror_return.py b/tests/basics/syntaxerror_return.py
new file mode 100644
index 0000000000000..a32bfbd33cdf5
--- /dev/null
+++ b/tests/basics/syntaxerror_return.py
@@ -0,0 +1,18 @@
+# With MICROPY_CPYTHON_COMPAT, the "return" statement can only appear in a
+# function.
+# Otherwise (in minimal builds), it ends execution of a module/class.
+
+try:
+    exec
+except NameError:
+    print("SKIP")
+    raise SystemExit
+
+try:
+    exec('return; print("this should not be executed.")')
+    # if we get here then MICROPY_CPYTHON_COMPAT is disabled and test
+    # should be skipped.
+    print("SKIP")
+    raise SystemExit
+except SyntaxError:
+    print('SyntaxError')
diff --git a/tests/basics/sys1.py b/tests/basics/sys1.py
index 0d74a1292b180..095824afaf1fc 100644
--- a/tests/basics/sys1.py
+++ b/tests/basics/sys1.py
@@ -19,12 +19,8 @@
     # Effectively skip subtests
     print(True)
 
-try:
-    raise SystemExit
-except SystemExit as e:
-    print("SystemExit", e.args)
-
-try:
-    sys.exit(42)
-except SystemExit as e:
-    print("SystemExit", e.args)
+if hasattr(sys.implementation, 'mpy'):
+    print(type(sys.implementation.mpy))
+else:
+    # Effectively skip subtests
+    print(int)
diff --git a/tests/basics/sys_exit.py b/tests/basics/sys_exit.py
new file mode 100644
index 0000000000000..b1f71549db1c5
--- /dev/null
+++ b/tests/basics/sys_exit.py
@@ -0,0 +1,24 @@
+# test sys module's exit function
+
+import sys
+
+try:
+    sys.exit
+except AttributeError:
+    print("SKIP")
+    raise SystemExit
+
+try:
+    raise SystemExit
+except SystemExit as e:
+    print("SystemExit", e.args)
+
+try:
+    sys.exit()
+except SystemExit as e:
+    print("SystemExit", e.args)
+
+try:
+    sys.exit(42)
+except SystemExit as e:
+    print("SystemExit", e.args)
diff --git a/tests/basics/try_except_break.py b/tests/basics/try_except_break.py
new file mode 100644
index 0000000000000..a7683f2185a49
--- /dev/null
+++ b/tests/basics/try_except_break.py
@@ -0,0 +1,73 @@
+# test deep unwind via break from nested try-except (22 of them)
+while True:
+ print(1)
+ try:
+  try:
+   try:
+    try:
+     try:
+      try:
+       try:
+        try:
+         try:
+          try:
+           try:
+            try:
+             try:
+              try:
+               try:
+                try:
+                 try:
+                  try:
+                   try:
+                    try:
+                     try:
+                      try:
+                       print(2)
+                       break
+                       print(3)
+                      except:
+                       pass
+                     except:
+                      pass
+                    except:
+                     pass
+                   except:
+                    pass
+                  except:
+                   pass
+                 except:
+                  pass
+                except:
+                 pass
+               except:
+                pass
+              except:
+               pass
+             except:
+              pass
+            except:
+             pass
+           except:
+            pass
+          except:
+           pass
+         except:
+          pass
+        except:
+         pass
+       except:
+        pass
+      except:
+       pass
+     except:
+      pass
+    except:
+     pass
+   except:
+    pass
+  except:
+   pass
+ except:
+  pass
+print(4)
diff --git a/tests/basics/try_except_break.py.exp b/tests/basics/try_except_break.py.exp
new file mode 100644
index 0000000000000..e8a01cd985125
--- /dev/null
+++ b/tests/basics/try_except_break.py.exp
@@ -0,0 +1,3 @@
+1
+2
+4
diff --git a/tests/basics/try_finally_break2.py b/tests/basics/try_finally_break2.py
new file mode 100644
index 0000000000000..086e92e902f5b
--- /dev/null
+++ b/tests/basics/try_finally_break2.py
@@ -0,0 +1,19 @@
+def foo(x):
+    for i in range(x):
+        for j in range(x):
+            try:
+                print(x, i, j, 1)
+            finally:
+                try:
+                    try:
+                        print(x, i, j, 2)
+                    finally:
+                        try:
+                            1 / 0
+                        finally:
+                            print(x, i, j, 3)
+                            break
+                finally:
+                    print(x, i, j, 4)
+                    break
+print(foo(4))
diff --git a/tests/basics/try_finally_continue.py b/tests/basics/try_finally_continue.py
new file mode 100644
index 0000000000000..50040e5de01ed
--- /dev/null
+++ b/tests/basics/try_finally_continue.py
@@ -0,0 +1,17 @@
+def foo(x):
+    for i in range(x):
+        try:
+            pass
+        finally:
+            try:
+                try:
+                    print(x, i)
+                finally:
+                    try:
+                        1 / 0
+                    finally:
+                        return 42
+            finally:
+                print('continue')
+                continue
+print(foo(4))
diff --git a/tests/basics/try_finally_continue.py.exp b/tests/basics/try_finally_continue.py.exp
new file mode 100644
index 0000000000000..2901997b1aa18
--- /dev/null
+++ b/tests/basics/try_finally_continue.py.exp
@@ -0,0 +1,9 @@
+4 0
+continue
+4 1
+continue
+4 2
+continue
+4 3
+continue
+None
diff --git a/tests/basics/try_finally_return5.py b/tests/basics/try_finally_return5.py
new file mode 100644
index 0000000000000..aa2327e655563
--- /dev/null
+++ b/tests/basics/try_finally_return5.py
@@ -0,0 +1,17 @@
+def foo(x):
+    for i in range(x):
+        try:
+            pass
+        finally:
+            try:
+                try:
+                    print(x, i)
+                finally:
+                    try:
+                        1 / 0
+                    finally:
+                        return 42
+            finally:
+                print('return')
+                return 43
+print(foo(4))
diff --git a/tests/basics/tuple1.py b/tests/basics/tuple1.py
index a7956c107220a..72bb3f01bff4a 100644
--- a/tests/basics/tuple1.py
+++ b/tests/basics/tuple1.py
@@ -11,10 +11,6 @@
 except AttributeError:
     print("AttributeError")
 
-print(x[1:])
-print(x[:-1])
-print(x[2:3])
-
 print(x + (10, 100, 10000))
 
 # inplace add operator
diff --git a/tests/basics/tuple_slice.py b/tests/basics/tuple_slice.py
new file mode 100644
index 0000000000000..1b11957c7a041
--- /dev/null
+++ b/tests/basics/tuple_slice.py
@@ -0,0 +1,7 @@
+# tuple slicing
+
+x = (1, 2, 3 * 4)
+
+print(x[1:])
+print(x[:-1])
+print(x[2:3])
diff --git a/tests/cmdline/cmd_parsetree.py b/tests/cmdline/cmd_parsetree.py
index da36c80703ce5..50da369543a31 100644
--- a/tests/cmdline/cmd_parsetree.py
+++ b/tests/cmdline/cmd_parsetree.py
@@ -4,9 +4,9 @@
 for i in ():
     pass
 a = None
-b = 'str'
-c = 'a very long str that will not be interned'
-d = b'bytes'
-e = b'a very long bytes that will not be interned'
+b = "str"
+c = "a very long str that will not be interned"
+d = b"bytes"
+e = b"a very long bytes that will not be interned"
 f = 123456789012345678901234567890
 g = 123
diff --git a/tests/cmdline/cmd_parsetree.py.exp b/tests/cmdline/cmd_parsetree.py.exp
index 12a1bfbe90ebb..18986318a02b4 100644
--- a/tests/cmdline/cmd_parsetree.py.exp
+++ b/tests/cmdline/cmd_parsetree.py.exp
@@ -32,11 +32,11 @@
 File cmdline/cmd_parsetree.py, code block '<module>' (descriptor: \.\+, bytecode @\.\+ bytes)
 Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 ########
-\.\+5b
+\.\+63
 arg names:
 (N_STATE 5)
 (N_EXC_STACK 0)
-  bc=-1 line=1
+  bc=0 line=1
   bc=0 line=4
   bc=9 line=5
   bc=12 line=6
diff --git a/tests/cmdline/cmd_showbc.py b/tests/cmdline/cmd_showbc.py
index 916228356fb3e..a960c15c4a973 100644
--- a/tests/cmdline/cmd_showbc.py
+++ b/tests/cmdline/cmd_showbc.py
@@ -1,5 +1,6 @@
 # cmdline: -v -v
 # test printing of all bytecodes
+# fmt: off
 
 def f():
     # constants
@@ -115,7 +116,7 @@ def closure():
     # import
     import a
     from a import b
-    from a import *
+    #from sys import * # tested at module scope
 
     # raise
     raise
@@ -154,3 +155,6 @@ class Class:
 # load super method
 def f(self):
     super().f()
+
+# import * (needs to be in module scope)
+from sys import *
diff --git a/tests/cmdline/cmd_showbc.py.exp b/tests/cmdline/cmd_showbc.py.exp
index 8d36b89df75d4..325efc7dbaaad 100644
--- a/tests/cmdline/cmd_showbc.py.exp
+++ b/tests/cmdline/cmd_showbc.py.exp
@@ -1,13 +1,13 @@
 File cmdline/cmd_showbc.py, code block '<module>' (descriptor: \.\+, bytecode @\.\+ bytes)
 Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 ########
-\.\+5b
+\.\+63
 arg names:
 (N_STATE 3)
 (N_EXC_STACK 0)
-  bc=-1 line=1
+  bc=0 line=1
 ########
-  bc=\\d\+ line=155
+  bc=\\d\+ line=160
 00 MAKE_FUNCTION \.\+
 \\d\+ STORE_NAME f
 \\d\+ MAKE_FUNCTION \.\+
@@ -27,6 +27,11 @@ arg names:
 \\d\+ DELETE_NAME Class
 \\d\+ MAKE_FUNCTION \.\+
 \\d\+ STORE_NAME f
+\\d\+ LOAD_CONST_SMALL_INT 0
+\\d\+ LOAD_CONST_STRING '*'
+\\d\+ BUILD_TUPLE 1
+\\d\+ IMPORT_NAME 'sys'
+\\d\+ IMPORT_STAR
 \\d\+ LOAD_CONST_NONE
 \\d\+ RETURN_VALUE
 File cmdline/cmd_showbc.py, code block 'f' (descriptor: \.\+, bytecode @\.\+ bytes)
@@ -38,14 +43,14 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 (INIT_CELL 14)
 (INIT_CELL 15)
 (INIT_CELL 16)
-  bc=-4 line=1
+  bc=0 line=1
 ########
-  bc=\\d\+ line=126
+  bc=\\d\+ line=127
 00 LOAD_CONST_NONE
 01 LOAD_CONST_FALSE
-02 BINARY_OP 26 __add__
+02 BINARY_OP 27 __add__
 03 LOAD_CONST_TRUE
-04 BINARY_OP 26 __add__
+04 BINARY_OP 27 __add__
 05 STORE_FAST 0
 06 LOAD_CONST_SMALL_INT 0
 07 STORE_FAST 0
@@ -84,7 +89,7 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 \\d\+ STORE_FAST 7
 \\d\+ LOAD_FAST 0
 \\d\+ LOAD_DEREF 14
-\\d\+ BINARY_OP 26 __add__
+58 BINARY_OP 27 __add__
 \\d\+ STORE_FAST 8
 \\d\+ LOAD_FAST 0
 \\d\+ UNARY_OP 1
@@ -300,14 +305,9 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 \\d\+ IMPORT_FROM 'b'
 \\d\+ STORE_DEREF 14
 \\d\+ POP_TOP
-\\d\+ LOAD_CONST_SMALL_INT 0
-\\d\+ LOAD_CONST_STRING '*'
-\\d\+ BUILD_TUPLE 1
-\\d\+ IMPORT_NAME 'a'
-\\d\+ IMPORT_STAR
-\\d\+ RAISE_VARARGS 0
+\\d\+ RAISE_LAST
 \\d\+ LOAD_CONST_SMALL_INT 1
-\\d\+ RAISE_VARARGS 1
+\\d\+ RAISE_OBJ
 \\d\+ LOAD_CONST_NONE
 \\d\+ RETURN_VALUE
 \\d\+ LOAD_CONST_SMALL_INT 1
@@ -318,9 +318,9 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 \.\+rg names:
 (N_STATE 22)
 (N_EXC_STACK 0)
-  bc=-1 line=1
+  bc=0 line=1
 ########
-  bc=\\d\+ line=132
+  bc=\\d\+ line=133
 00 LOAD_CONST_SMALL_INT 1
 01 DUP_TOP
 02 STORE_FAST 0
@@ -363,20 +363,20 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 42 STORE_FAST_N 19
 44 LOAD_FAST 9
 45 LOAD_FAST_N 19
-47 BINARY_OP 26 __add__
+47 BINARY_OP 27 __add__
 48 POP_TOP
 49 LOAD_CONST_NONE
 50 RETURN_VALUE
 File cmdline/cmd_showbc.py, code block 'f' (descriptor: \.\+, bytecode @\.\+ bytes)
 Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 ########
-\.\+5b
+\.\+63
 arg names: a
 (N_STATE 5)
 (N_EXC_STACK 0)
 (INIT_CELL 0)
 ########
-  bc=\\d\+ line=138
+  bc=\\d\+ line=139
 00 LOAD_CONST_SMALL_INT 2
 01 BUILD_TUPLE 1
 03 LOAD_NULL
@@ -388,14 +388,14 @@ arg names: a
 File cmdline/cmd_showbc.py, code block 'f' (descriptor: \.\+, bytecode @\.\+ bytes)
 Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 ########
-\.\+5b
+\.\+63
 arg names:
 (N_STATE 2)
 (N_EXC_STACK 0)
-  bc=-1 line=1
-  bc=0 line=143
-  bc=3 line=144
-  bc=6 line=145
+  bc=0 line=1
+  bc=0 line=144
+  bc=3 line=145
+  bc=6 line=146
 00 LOAD_CONST_NONE
 01 YIELD_VALUE
 02 POP_TOP
@@ -412,12 +412,13 @@ arg names:
 File cmdline/cmd_showbc.py, code block 'Class' (descriptor: \.\+, bytecode @\.\+ bytes)
 Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 ########
-\.\+5b
+\.\+63
 arg names:
 (N_STATE 1)
 (N_EXC_STACK 0)
-  bc=-1 line=1
-  bc=13 line=149
+  bc=0 line=1
+########
+  bc=13 line=150
 00 LOAD_NAME __name__ (cache=0)
 04 STORE_NAME __module__
 07 LOAD_CONST_STRING 'Class'
@@ -427,12 +428,12 @@ arg names:
 File cmdline/cmd_showbc.py, code block 'f' (descriptor: \.\+, bytecode @\.\+ bytes)
 Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 ########
-\.\+5b
+\.\+63
 arg names: self
 (N_STATE 4)
 (N_EXC_STACK 0)
-  bc=-1 line=1
-  bc=0 line=156
+  bc=0 line=1
+  bc=0 line=157
 00 LOAD_GLOBAL super (cache=0)
 \\d\+ LOAD_GLOBAL __class__ (cache=0)
 \\d\+ LOAD_FAST 0
@@ -444,11 +445,13 @@ arg names: self
 File cmdline/cmd_showbc.py, code block '<genexpr>' (descriptor: \.\+, bytecode @\.\+ bytes)
 Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 ########
-\.\+5b
+\.\+63
 arg names: * * *
 (N_STATE 9)
 (N_EXC_STACK 0)
-  bc=-\\d\+ line=1
+  bc=0 line=1
+  bc=0 line=60
+########
 00 LOAD_NULL
 01 LOAD_FAST 2
 02 LOAD_NULL
@@ -466,11 +469,13 @@ arg names: * * *
 File cmdline/cmd_showbc.py, code block '<listcomp>' (descriptor: \.\+, bytecode @\.\+ bytes)
 Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 ########
-\.\+5b
+\.\+63
 arg names: * * *
 (N_STATE 10)
 (N_EXC_STACK 0)
-  bc=-\\d\+ line=1
+  bc=0 line=1
+  bc=0 line=61
+########
 00 BUILD_LIST 0
 02 LOAD_FAST 2
 03 GET_ITER_STACK
@@ -485,11 +490,11 @@ arg names: * * *
 File cmdline/cmd_showbc.py, code block '<dictcomp>' (descriptor: \.\+, bytecode @\.\+ bytes)
 Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 ########
-\.\+5b
+\.\+63
 arg names: * * *
 (N_STATE 11)
 (N_EXC_STACK 0)
-  bc=-\\d\+ line=1
+  bc=0 line=1
 ########
 00 BUILD_MAP 0
 02 LOAD_FAST 2
@@ -506,16 +511,16 @@ arg names: * * *
 File cmdline/cmd_showbc.py, code block 'closure' (descriptor: \.\+, bytecode @\.\+ bytes)
 Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 ########
-\.\+5b
+\.\+63
 arg names: *
 (N_STATE 4)
 (N_EXC_STACK 0)
-  bc=-\\d\+ line=1
+  bc=0 line=1
 ########
-  bc=\\d\+ line=113
+  bc=\\d\+ line=114
 00 LOAD_DEREF 0
 02 LOAD_CONST_SMALL_INT 1
-03 BINARY_OP 26 __add__
+03 BINARY_OP 27 __add__
 04 STORE_FAST 1
 05 LOAD_CONST_SMALL_INT 1
 06 STORE_DEREF 0
@@ -525,16 +530,16 @@ arg names: *
 File cmdline/cmd_showbc.py, code block 'f' (descriptor: \.\+, bytecode @\.\+ bytes)
 Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
 ########
-\.\+5b
+\.\+63
 arg names: * b
 (N_STATE 4)
 (N_EXC_STACK 0)
-  bc=-\\d\+ line=1
+  bc=0 line=1
 ########
-  bc=\\d\+ line=139
+  bc=\\d\+ line=140
 00 LOAD_FAST 1
 01 LOAD_DEREF 0
-03 BINARY_OP 26 __add__
+03 BINARY_OP 27 __add__
 04 RETURN_VALUE
 mem: total=\\d\+, current=\\d\+, peak=\\d\+
 stack: \\d\+ out of \\d\+
diff --git a/tests/cmdline/cmd_verbose.py.exp b/tests/cmdline/cmd_verbose.py.exp
index f56226129e2b4..a2fdf1f00deb3 100644
--- a/tests/cmdline/cmd_verbose.py.exp
+++ b/tests/cmdline/cmd_verbose.py.exp
@@ -1,12 +1,12 @@
 File cmdline/cmd_verbose.py, code block '<module>' (descriptor: \.\+, bytecode \.\+ bytes)
 Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
- 02 \.\+
+ 08 \.\+
 ########
-\.\+5b
+\.\+63
 arg names:
 (N_STATE 2)
 (N_EXC_STACK 0)
-  bc=-1 line=1
+  bc=0 line=1
   bc=0 line=3
 00 LOAD_NAME print (cache=0)
 04 LOAD_CONST_SMALL_INT 1
diff --git a/tests/cmdline/repl_inspect.py b/tests/cmdline/repl_inspect.py
new file mode 100644
index 0000000000000..5a7564a3c2bbb
--- /dev/null
+++ b/tests/cmdline/repl_inspect.py
@@ -0,0 +1,2 @@
+# cmdline: -c print("test") -i
+# -c option combined with -i option results in REPL
diff --git a/tests/cmdline/repl_inspect.py.exp b/tests/cmdline/repl_inspect.py.exp
new file mode 100644
index 0000000000000..59f734b2f6945
--- /dev/null
+++ b/tests/cmdline/repl_inspect.py.exp
@@ -0,0 +1,6 @@
+test
+MicroPython \.\+ version
+Use \.\+
+>>> # cmdline: -c print("test") -i
+>>> # -c option combined with -i option results in REPL
+>>> 
diff --git a/tests/cmdline/repl_micropyinspect b/tests/cmdline/repl_micropyinspect
new file mode 100644
index 0000000000000..0710f1a75bedd
--- /dev/null
+++ b/tests/cmdline/repl_micropyinspect
@@ -0,0 +1,3 @@
+import uos
+
+uos.putenv('MICROPYINSPECT', '1')
diff --git a/tests/cmdline/repl_micropyinspect.py b/tests/cmdline/repl_micropyinspect.py
new file mode 100644
index 0000000000000..220dd43d80d87
--- /dev/null
+++ b/tests/cmdline/repl_micropyinspect.py
@@ -0,0 +1,2 @@
+# cmdline: cmdline/repl_micropyinspect
+# setting MICROPYINSPECT environment variable before program exit triggers REPL
diff --git a/tests/cmdline/repl_micropyinspect.py.exp b/tests/cmdline/repl_micropyinspect.py.exp
new file mode 100644
index 0000000000000..93ff43546eace
--- /dev/null
+++ b/tests/cmdline/repl_micropyinspect.py.exp
@@ -0,0 +1,5 @@
+MicroPython \.\+ version
+Use \.\+
+>>> # cmdline: cmdline/repl_micropyinspect
+>>> # setting MICROPYINSPECT environment variable before program exit triggers REPL
+>>> 
diff --git a/tests/cmdline/repl_words_move.py b/tests/cmdline/repl_words_move.py
new file mode 100644
index 0000000000000..e1eb5295350c1
--- /dev/null
+++ b/tests/cmdline/repl_words_move.py
@@ -0,0 +1,31 @@
+# word movement
+# backward-word, start in word
+234b1
+# backward-word, don't start in word
+234    b1
+# backward-word on start of line. if cursor is moved, this will result in a SyntaxError
+1 2 + 3
b+
+# forward-word, start in word
+1+2 12+f+3
+# forward-word, don't start in word
+1+    12 3
f+
+# forward-word on eol. if cursor is moved, this will result in a SyntaxError
+1 + 2 3f+
+
+# kill word
+# backward-kill-word, start in word
+100 + 45623
+# backward-kill-word, don't start in word
+100 + 456231
+# forward-kill-word, start in word
+100 + 256d3
+# forward-kill-word, don't start in word
+1 + 256d2
+
+# extra move/kill shortcuts
+# ctrl-left
+2341
+# ctrl-right
+123
+# ctrl-w
+1231
diff --git a/tests/cmdline/repl_words_move.py.exp b/tests/cmdline/repl_words_move.py.exp
new file mode 100644
index 0000000000000..86f6b7788989e
--- /dev/null
+++ b/tests/cmdline/repl_words_move.py.exp
@@ -0,0 +1,47 @@
+MicroPython \.\+ version
+Use \.\+
+>>> # word movement
+>>> # backward-word, start in word
+>>> \.\+
+1234
+>>> # backward-word, don't start in word
+>>> \.\+
+1234
+>>> # backward-word on start of line. if cursor is moved, this will result in a SyntaxError
+>>> \.\+
+6
+>>> # forward-word, start in word
+>>> \.\+
+18
+>>> # forward-word, don't start in word
+>>> \.\+
+16
+>>> # forward-word on eol. if cursor is moved, this will result in a SyntaxError
+>>> \.\+
+6
+>>> 
+>>> # kill word
+>>> # backward-kill-word, start in word
+>>> \.\+
+123
+>>> # backward-kill-word, don't start in word
+>>> \.\+
+101
+>>> # forward-kill-word, start in word
+>>> \.\+
+123
+>>> # forward-kill-word, don't start in word
+>>> \.\+
+3
+>>> 
+>>> # extra move/kill shortcuts
+>>> # ctrl-left
+>>> \.\+
+1234
+>>> # ctrl-right
+>>> \.\+
+123
+>>> # ctrl-w
+>>> \.\+
+1
+>>> 
diff --git a/tests/cpydiff/core_class_delnotimpl.py b/tests/cpydiff/core_class_delnotimpl.py
index c51c3d536f686..18c176e9bb1f7 100644
--- a/tests/cpydiff/core_class_delnotimpl.py
+++ b/tests/cpydiff/core_class_delnotimpl.py
@@ -6,9 +6,11 @@
 """
 import gc
 
-class Foo():
+
+class Foo:
     def __del__(self):
-        print('__del__')
+        print("__del__")
+
 
 f = Foo()
 del f
diff --git a/tests/cpydiff/core_class_mro.py b/tests/cpydiff/core_class_mro.py
index 99713e790c4df..bdd6dd5df6b8f 100644
--- a/tests/cpydiff/core_class_mro.py
+++ b/tests/cpydiff/core_class_mro.py
@@ -4,12 +4,16 @@
 cause: Depth first non-exhaustive method resolution order
 workaround: Avoid complex class hierarchies with multiple inheritance and complex method overrides. Keep in mind that many languages don't support multiple inheritance at all.
 """
+
+
 class Foo:
     def __str__(self):
         return "Foo"
 
+
 class C(tuple, Foo):
     pass
 
+
 t = C((1, 2, 3))
 print(t)
diff --git a/tests/cpydiff/core_class_supermultiple.py b/tests/cpydiff/core_class_supermultiple.py
index f0823ee11dd8d..9a87b85a87c96 100644
--- a/tests/cpydiff/core_class_supermultiple.py
+++ b/tests/cpydiff/core_class_supermultiple.py
@@ -4,24 +4,29 @@
 cause: See :ref:`cpydiff_core_class_mro`
 workaround: See :ref:`cpydiff_core_class_mro`
 """
+
+
 class A:
     def __init__(self):
         print("A.__init__")
 
+
 class B(A):
     def __init__(self):
         print("B.__init__")
         super().__init__()
 
+
 class C(A):
     def __init__(self):
         print("C.__init__")
         super().__init__()
 
 
-class D(B,C):
+class D(B, C):
     def __init__(self):
         print("D.__init__")
         super().__init__()
 
+
 D()
diff --git a/tests/cpydiff/core_class_superproperty.py b/tests/cpydiff/core_class_superproperty.py
index 1ec210550ef96..2d7775a9028e8 100644
--- a/tests/cpydiff/core_class_superproperty.py
+++ b/tests/cpydiff/core_class_superproperty.py
@@ -4,15 +4,19 @@
 cause: Unknown
 workaround: Unknown
 """
+
+
 class A:
     @property
     def p(self):
-        return {"a":10}
+        return {"a": 10}
+
 
 class AA(A):
     @property
     def p(self):
         return super().p
 
+
 a = AA()
 print(a.p)
diff --git a/tests/cpydiff/core_function_userattr.py b/tests/cpydiff/core_function_userattr.py
index 297293908427d..a8380c690aa99 100644
--- a/tests/cpydiff/core_function_userattr.py
+++ b/tests/cpydiff/core_function_userattr.py
@@ -4,8 +4,11 @@
 cause: MicroPython is highly optimized for memory usage.
 workaround: Use external dictionary, e.g. ``FUNC_X[f] = 0``.
 """
+
+
 def f():
     pass
 
+
 f.x = 0
 print(f.x)
diff --git a/tests/cpydiff/core_generator_noexit.py b/tests/cpydiff/core_generator_noexit.py
index c25fbe75a2615..149e9a0a90bcf 100644
--- a/tests/cpydiff/core_generator_noexit.py
+++ b/tests/cpydiff/core_generator_noexit.py
@@ -4,11 +4,15 @@
 cause: Unknown
 workaround: Unknown
 """
+
+
 class foo(object):
     def __enter__(self):
-        print('Enter')
+        print("Enter")
+
     def __exit__(self, *args):
-        print('Exit')
+        print("Exit")
+
 
 def bar(x):
     with foo():
@@ -16,9 +20,11 @@ def bar(x):
             x += 1
             yield x
 
+
 def func():
     g = bar(0)
     for _ in range(3):
         print(next(g))
 
+
 func()
diff --git a/tests/cpydiff/core_import_all.py b/tests/cpydiff/core_import_all.py
new file mode 100644
index 0000000000000..5adf9ae3eb1e6
--- /dev/null
+++ b/tests/cpydiff/core_import_all.py
@@ -0,0 +1,9 @@
+"""
+categories: Core,import
+description: __all__ is unsupported in __init__.py in MicroPython.
+cause: Not implemented.
+workaround: Manually import the sub-modules directly in __init__.py using ``from . import foo, bar``.
+"""
+from modules3 import *
+
+foo.hello()
diff --git a/tests/cpydiff/core_import_prereg.py b/tests/cpydiff/core_import_prereg.py
index 4a71217821274..3ce2340c68dc7 100644
--- a/tests/cpydiff/core_import_prereg.py
+++ b/tests/cpydiff/core_import_prereg.py
@@ -12,6 +12,7 @@
     print(e)
 try:
     from modules import foo
-    print('Should not get here')
+
+    print("Should not get here")
 except NameError as e:
     print(e)
diff --git a/tests/cpydiff/core_import_split_ns_pkgs.py b/tests/cpydiff/core_import_split_ns_pkgs.py
index 700620c4701b0..62bf337a22bfa 100644
--- a/tests/cpydiff/core_import_split_ns_pkgs.py
+++ b/tests/cpydiff/core_import_split_ns_pkgs.py
@@ -5,6 +5,7 @@
 workaround: Don't install modules belonging to the same namespace package in different directories. For MicroPython, it's recommended to have at most 3-component module search paths: for your current application, per-user (writable), system-wide (non-writable).
 """
 import sys
+
 sys.path.append(sys.path[1] + "/modules")
 sys.path.append(sys.path[1] + "/modules2")
 
diff --git a/tests/cpydiff/core_locals.py b/tests/cpydiff/core_locals.py
index 0240e5a1a9f9d..af3280c6d70a7 100644
--- a/tests/cpydiff/core_locals.py
+++ b/tests/cpydiff/core_locals.py
@@ -4,8 +4,11 @@
 cause: MicroPython doesn't maintain symbolic local environment, it is optimized to an array of slots. Thus, local variables can't be accessed by a name.
 workaround: Unknown
 """
+
+
 def test():
     val = 2
     print(locals())
 
+
 test()
diff --git a/tests/cpydiff/core_locals_eval.py b/tests/cpydiff/core_locals_eval.py
index 8416e3b069142..025d226372986 100644
--- a/tests/cpydiff/core_locals_eval.py
+++ b/tests/cpydiff/core_locals_eval.py
@@ -6,9 +6,11 @@
 """
 val = 1
 
+
 def test():
     val = 2
     print(val)
     eval("print(val)")
 
+
 test()
diff --git a/tests/cpydiff/modules/foo.py b/tests/cpydiff/modules/foo.py
index e6e33a7b462ea..51cd4b2490c17 100644
--- a/tests/cpydiff/modules/foo.py
+++ b/tests/cpydiff/modules/foo.py
@@ -1,2 +1,2 @@
-print('foo')
+print("foo")
 xxx
diff --git a/tests/cpydiff/modules3/__init__.py b/tests/cpydiff/modules3/__init__.py
new file mode 100644
index 0000000000000..27a2bf2ad9044
--- /dev/null
+++ b/tests/cpydiff/modules3/__init__.py
@@ -0,0 +1 @@
+__all__ = ["foo"]
diff --git a/tests/cpydiff/modules3/foo.py b/tests/cpydiff/modules3/foo.py
new file mode 100644
index 0000000000000..dd9b9d4ddd4c4
--- /dev/null
+++ b/tests/cpydiff/modules3/foo.py
@@ -0,0 +1,2 @@
+def hello():
+    print("hello")
diff --git a/tests/cpydiff/modules_array_containment.py b/tests/cpydiff/modules_array_containment.py
index 190a3c2760494..8f25b0d49149d 100644
--- a/tests/cpydiff/modules_array_containment.py
+++ b/tests/cpydiff/modules_array_containment.py
@@ -5,4 +5,5 @@
 workaround: Unknown
 """
 import array
-print(1 in array.array('B', b'12'))
+
+print(1 in array.array("B", b"12"))
diff --git a/tests/cpydiff/modules_array_deletion.py b/tests/cpydiff/modules_array_deletion.py
index 97f988da23410..3376527373edf 100644
--- a/tests/cpydiff/modules_array_deletion.py
+++ b/tests/cpydiff/modules_array_deletion.py
@@ -5,6 +5,7 @@
 workaround: Unknown
 """
 import array
-a = array.array('b', (1, 2, 3))
+
+a = array.array("b", (1, 2, 3))
 del a[1]
 print(a)
diff --git a/tests/cpydiff/modules_array_subscrstep.py b/tests/cpydiff/modules_array_subscrstep.py
index 1103f18269dc6..24308bd9042d1 100644
--- a/tests/cpydiff/modules_array_subscrstep.py
+++ b/tests/cpydiff/modules_array_subscrstep.py
@@ -5,5 +5,6 @@
 workaround: Unknown
 """
 import array
-a = array.array('b', (1, 2, 3))
+
+a = array.array("b", (1, 2, 3))
 print(a[3:2:2])
diff --git a/tests/cpydiff/modules_deque.py b/tests/cpydiff/modules_deque.py
index a503ea4f55be3..4d2746d1f864e 100644
--- a/tests/cpydiff/modules_deque.py
+++ b/tests/cpydiff/modules_deque.py
@@ -5,5 +5,6 @@
 workaround: Use regular lists. micropython-lib has implementation of collections.deque.
 """
 import collections
+
 D = collections.deque()
 print(D)
diff --git a/tests/cpydiff/modules_json_nonserializable.py b/tests/cpydiff/modules_json_nonserializable.py
index 913b734e8bd26..ffe523786f501 100644
--- a/tests/cpydiff/modules_json_nonserializable.py
+++ b/tests/cpydiff/modules_json_nonserializable.py
@@ -5,10 +5,11 @@
 workaround: Unknown
 """
 import json
+
 a = bytes(x for x in range(256))
 try:
     z = json.dumps(a)
     x = json.loads(z)
-    print('Should not get here')
+    print("Should not get here")
 except TypeError:
-    print('TypeError')
+    print("TypeError")
diff --git a/tests/cpydiff/modules_os_environ.py b/tests/cpydiff/modules_os_environ.py
new file mode 100644
index 0000000000000..491d8a3101636
--- /dev/null
+++ b/tests/cpydiff/modules_os_environ.py
@@ -0,0 +1,17 @@
+"""
+categories: Modules,os
+description: ``environ`` attribute is not implemented
+cause: Unknown
+workaround: Use ``getenv``, ``putenv`` and ``unsetenv``
+"""
+import os
+
+try:
+    print(os.environ.get("NEW_VARIABLE"))
+    os.environ["NEW_VARIABLE"] = "VALUE"
+    print(os.environ["NEW_VARIABLE"])
+except AttributeError:
+    print("should not get here")
+    print(os.getenv("NEW_VARIABLE"))
+    os.putenv("NEW_VARIABLE", "VALUE")
+    print(os.getenv("NEW_VARIABLE"))
diff --git a/tests/cpydiff/modules_os_getenv.py b/tests/cpydiff/modules_os_getenv.py
new file mode 100644
index 0000000000000..d1e828438e456
--- /dev/null
+++ b/tests/cpydiff/modules_os_getenv.py
@@ -0,0 +1,11 @@
+"""
+categories: Modules,os
+description: ``getenv`` returns actual value instead of cached value
+cause: The ``environ`` attribute is not implemented
+workaround: Unknown
+"""
+import os
+
+print(os.getenv("NEW_VARIABLE"))
+os.putenv("NEW_VARIABLE", "VALUE")
+print(os.getenv("NEW_VARIABLE"))
diff --git a/tests/cpydiff/modules_os_getenv_argcount.py b/tests/cpydiff/modules_os_getenv_argcount.py
new file mode 100644
index 0000000000000..d7838a92ccba2
--- /dev/null
+++ b/tests/cpydiff/modules_os_getenv_argcount.py
@@ -0,0 +1,14 @@
+"""
+categories: Modules,os
+description: ``getenv`` only allows one argument
+cause: Unknown
+workaround: Test that the return value is ``None``
+"""
+import os
+
+try:
+    print(os.getenv("NEW_VARIABLE", "DEFAULT"))
+except TypeError:
+    print("should not get here")
+    # this assumes NEW_VARIABLE is never an empty variable
+    print(os.getenv("NEW_VARIABLE") or "DEFAULT")
diff --git a/tests/cpydiff/modules_struct_fewargs.py b/tests/cpydiff/modules_struct_fewargs.py
index 08d32ca672764..cb6b0fd874ec4 100644
--- a/tests/cpydiff/modules_struct_fewargs.py
+++ b/tests/cpydiff/modules_struct_fewargs.py
@@ -5,8 +5,9 @@
 workaround: Unknown
 """
 import struct
+
 try:
-    print(struct.pack('bb', 1))
-    print('Should not get here')
+    print(struct.pack("bb", 1))
+    print("Should not get here")
 except:
-    print('struct.error')
+    print("struct.error")
diff --git a/tests/cpydiff/modules_struct_manyargs.py b/tests/cpydiff/modules_struct_manyargs.py
index cdbb5c672c111..03395baad3b59 100644
--- a/tests/cpydiff/modules_struct_manyargs.py
+++ b/tests/cpydiff/modules_struct_manyargs.py
@@ -5,8 +5,9 @@
 workaround: Unknown
 """
 import struct
+
 try:
-    print(struct.pack('bb', 1, 2, 3))
-    print('Should not get here')
+    print(struct.pack("bb", 1, 2, 3))
+    print("Should not get here")
 except:
-    print('struct.error')
+    print("struct.error")
diff --git a/tests/cpydiff/modules_sys_stdassign.py b/tests/cpydiff/modules_sys_stdassign.py
index 1bf2a598a0db9..7d086078a93d6 100644
--- a/tests/cpydiff/modules_sys_stdassign.py
+++ b/tests/cpydiff/modules_sys_stdassign.py
@@ -5,5 +5,6 @@
 workaround: Unknown
 """
 import sys
+
 sys.stdin = None
 print(sys.stdin)
diff --git a/tests/cpydiff/syntax_spaces.py b/tests/cpydiff/syntax_spaces.py
index 8578a51e28526..c308240a78da5 100644
--- a/tests/cpydiff/syntax_spaces.py
+++ b/tests/cpydiff/syntax_spaces.py
@@ -5,14 +5,14 @@
 workaround: Unknown
 """
 try:
-    print(eval('1and 0'))
+    print(eval("1and 0"))
 except SyntaxError:
-    print('Should have worked')
+    print("Should have worked")
 try:
-    print(eval('1or 0'))
+    print(eval("1or 0"))
 except SyntaxError:
-    print('Should have worked')
+    print("Should have worked")
 try:
-    print(eval('1if 1else 0'))
+    print(eval("1if 1else 0"))
 except SyntaxError:
-    print('Should have worked')
+    print("Should have worked")
diff --git a/tests/cpydiff/types_bytes_format.py b/tests/cpydiff/types_bytes_format.py
index 697ee5269895b..ad0498771165c 100644
--- a/tests/cpydiff/types_bytes_format.py
+++ b/tests/cpydiff/types_bytes_format.py
@@ -4,4 +4,4 @@
 cause: MicroPython strives to be a more regular implementation, so if both `str` and `bytes` support ``__mod__()`` (the % operator), it makes sense to support ``format()`` for both too. Support for ``__mod__`` can also be compiled out, which leaves only ``format()`` for bytes formatting.
 workaround: If you are interested in CPython compatibility, don't use ``.format()`` on bytes objects.
 """
-print(b'{}'.format(1))
+print(b"{}".format(1))
diff --git a/tests/cpydiff/types_bytes_keywords.py b/tests/cpydiff/types_bytes_keywords.py
index 4dc383f2627b7..ade83d0a709eb 100644
--- a/tests/cpydiff/types_bytes_keywords.py
+++ b/tests/cpydiff/types_bytes_keywords.py
@@ -2,6 +2,6 @@
 categories: Types,bytes
 description: bytes() with keywords not implemented
 cause: Unknown
-workaround: Pass the encoding as a positional paramter, e.g. ``print(bytes('abc', 'utf-8'))``
+workaround: Pass the encoding as a positional parameter, e.g. ``print(bytes('abc', 'utf-8'))``
 """
-print(bytes('abc', encoding='utf8'))
+print(bytes("abc", encoding="utf8"))
diff --git a/tests/cpydiff/types_bytes_subscrstep.py b/tests/cpydiff/types_bytes_subscrstep.py
index 2871bda6c17ef..51b94cb710f1c 100644
--- a/tests/cpydiff/types_bytes_subscrstep.py
+++ b/tests/cpydiff/types_bytes_subscrstep.py
@@ -4,4 +4,4 @@
 cause: MicroPython is highly optimized for memory usage.
 workaround: Use explicit loop for this very rare operation.
 """
-print(b'123'[0:3:2])
+print(b"123"[0:3:2])
diff --git a/tests/cpydiff/types_dict_keys_set.py b/tests/cpydiff/types_dict_keys_set.py
new file mode 100644
index 0000000000000..3a0849a35564c
--- /dev/null
+++ b/tests/cpydiff/types_dict_keys_set.py
@@ -0,0 +1,7 @@
+"""
+categories: Types,dict
+description: Dictionary keys view does not behave as a set.
+cause: Not implemented.
+workaround: Explicitly convert keys to a set before using set operations.
+"""
+print({1: 2, 3: 4}.keys() & {1})
diff --git a/tests/cpydiff/types_exception_subclassinit.py b/tests/cpydiff/types_exception_subclassinit.py
index 39cdaf45b80bd..ade9ebc7ab964 100644
--- a/tests/cpydiff/types_exception_subclassinit.py
+++ b/tests/cpydiff/types_exception_subclassinit.py
@@ -8,8 +8,11 @@ class A(Exception):
         def __init__(self):
             super().__init__()
 """
+
+
 class A(Exception):
     def __init__(self):
         Exception.__init__(self)
 
+
 a = A()
diff --git a/tests/cpydiff/types_float_rounding.py b/tests/cpydiff/types_float_rounding.py
index c8d3cfbe882ad..a5b591966b0de 100644
--- a/tests/cpydiff/types_float_rounding.py
+++ b/tests/cpydiff/types_float_rounding.py
@@ -4,4 +4,4 @@
 cause: Unknown
 workaround: Unknown
 """
-print('%.1g' % -9.9)
+print("%.1g" % -9.9)
diff --git a/tests/cpydiff/types_int_subclassconv.py b/tests/cpydiff/types_int_subclassconv.py
index 260b060ed6250..5d337412c7f53 100644
--- a/tests/cpydiff/types_int_subclassconv.py
+++ b/tests/cpydiff/types_int_subclassconv.py
@@ -4,8 +4,11 @@
 cause: Unknown
 workaround: Avoid subclassing builtin types unless really needed. Prefer https://en.wikipedia.org/wiki/Composition_over_inheritance .
 """
+
+
 class A(int):
     __add__ = lambda self, other: A(int(self) + other)
 
+
 a = A(42)
-print(a+a)
+print(a + a)
diff --git a/tests/cpydiff/types_str_endswith.py b/tests/cpydiff/types_str_endswith.py
index ac2600bd252c7..f222ac1cd3ad3 100644
--- a/tests/cpydiff/types_str_endswith.py
+++ b/tests/cpydiff/types_str_endswith.py
@@ -4,4 +4,4 @@
 cause: Unknown
 workaround: Unknown
 """
-print('abc'.endswith('c', 1))
+print("abc".endswith("c", 1))
diff --git a/tests/cpydiff/types_str_formatsubscr.py b/tests/cpydiff/types_str_formatsubscr.py
index dd1d8d33d7450..1b83cfff6cd34 100644
--- a/tests/cpydiff/types_str_formatsubscr.py
+++ b/tests/cpydiff/types_str_formatsubscr.py
@@ -4,4 +4,4 @@
 cause: Unknown
 workaround: Unknown
 """
-print('{a[0]}'.format(a=[1, 2]))
+print("{a[0]}".format(a=[1, 2]))
diff --git a/tests/cpydiff/types_str_keywords.py b/tests/cpydiff/types_str_keywords.py
index b336b1a73e2e6..77a4eac1c1db2 100644
--- a/tests/cpydiff/types_str_keywords.py
+++ b/tests/cpydiff/types_str_keywords.py
@@ -4,4 +4,4 @@
 cause: Unknown
 workaround: Input the encoding format directly. eg ``print(bytes('abc', 'utf-8'))``
 """
-print(str(b'abc', encoding='utf8'))
+print(str(b"abc", encoding="utf8"))
diff --git a/tests/cpydiff/types_str_ljust_rjust.py b/tests/cpydiff/types_str_ljust_rjust.py
index fa3f594c1fef4..72e5105e025b2 100644
--- a/tests/cpydiff/types_str_ljust_rjust.py
+++ b/tests/cpydiff/types_str_ljust_rjust.py
@@ -4,4 +4,4 @@
 cause: MicroPython is highly optimized for memory usage. Easy workarounds available.
 workaround: Instead of ``s.ljust(10)`` use ``"%-10s" % s``, instead of ``s.rjust(10)`` use ``"% 10s" % s``. Alternatively, ``"{:<10}".format(s)`` or ``"{:>10}".format(s)``.
 """
-print('abc'.ljust(10))
+print("abc".ljust(10))
diff --git a/tests/cpydiff/types_str_rsplitnone.py b/tests/cpydiff/types_str_rsplitnone.py
index cadf8698779af..5d334fea2f846 100644
--- a/tests/cpydiff/types_str_rsplitnone.py
+++ b/tests/cpydiff/types_str_rsplitnone.py
@@ -4,4 +4,4 @@
 cause: Unknown
 workaround: Unknown
 """
-print('a a a'.rsplit(None, 1))
+print("a a a".rsplit(None, 1))
diff --git a/tests/cpydiff/types_str_subclassequality.py b/tests/cpydiff/types_str_subclassequality.py
deleted file mode 100644
index 8aec1ea78fd5d..0000000000000
--- a/tests/cpydiff/types_str_subclassequality.py
+++ /dev/null
@@ -1,11 +0,0 @@
-"""
-categories: Types,str
-description: Instance of a subclass of str cannot be compared for equality with an instance of a str
-cause: Unknown
-workaround: Unknown
-"""
-class S(str):
-    pass
-
-s = S('hello')
-print(s == 'hello')
diff --git a/tests/cpydiff/types_str_subscrstep.py b/tests/cpydiff/types_str_subscrstep.py
index 0c2fce1b11bd9..2d3245e5582f5 100644
--- a/tests/cpydiff/types_str_subscrstep.py
+++ b/tests/cpydiff/types_str_subscrstep.py
@@ -4,4 +4,4 @@
 cause: Unknown
 workaround: Unknown
 """
-print('abcdefghi'[0:9:2])
+print("abcdefghi"[0:9:2])
diff --git a/tests/esp32/check_err_str.py b/tests/esp32/check_err_str.py
new file mode 100644
index 0000000000000..055eecf7476ae
--- /dev/null
+++ b/tests/esp32/check_err_str.py
@@ -0,0 +1,43 @@
+try:
+    from esp32 import Partition as p
+    import micropython
+except ImportError:
+    print("SKIP")
+    raise SystemExit
+
+# try some vanilla OSError to get std error code
+try:
+    open("this filedoesnotexist", "r")
+    print("FAILED TO RAISE")
+except OSError as e:
+    print(e)
+
+# try to make nvs partition bootable, which ain't gonna work
+part = p.find(type=p.TYPE_DATA)[0]
+fun = p.set_boot
+try:
+    fun(part)
+    print("FAILED TO RAISE")
+except OSError as e:
+    print(e)
+
+# same but with out of memory condition by locking the heap
+exc = "FAILED TO RAISE"
+micropython.heap_lock()
+try:
+    fun(part)
+except OSError as e:
+    exc = e
+micropython.heap_unlock()
+print("exc:", exc)  # exc empty due to no memory
+
+# same again but having an emergency buffer
+micropython.alloc_emergency_exception_buf(256)
+exc = "FAILED TO RAISE"
+micropython.heap_lock()
+try:
+    fun(part)
+except Exception as e:
+    exc = e
+micropython.heap_unlock()
+print(exc)
diff --git a/tests/esp32/check_err_str.py.exp b/tests/esp32/check_err_str.py.exp
new file mode 100644
index 0000000000000..d4162d1be00d0
--- /dev/null
+++ b/tests/esp32/check_err_str.py.exp
@@ -0,0 +1,4 @@
+[Errno 2] ENOENT
+(-5379, 'ESP_ERR_OTA_VALIDATE_FAILED')
+exc: 
+-5379
diff --git a/tests/esp32/esp32_idf_heap_info.py b/tests/esp32/esp32_idf_heap_info.py
new file mode 100644
index 0000000000000..f141ae07b530e
--- /dev/null
+++ b/tests/esp32/esp32_idf_heap_info.py
@@ -0,0 +1,33 @@
+# Test the esp32's esp32.idf_heap_info to return sane data
+try:
+    import esp32
+except ImportError:
+    print("SKIP")
+    raise SystemExit
+
+# region tuple is: (size, free, largest free, min free)
+# we check that each region's size is > 0 and that the free amounts are smaller than the size
+def chk_heap(kind, regions):
+    chk = [True, True, True, True]
+    for r in regions:
+        chk = [
+            chk[0] and r[0] > 0,
+            chk[1] and r[1] <= r[0],
+            chk[2] and r[2] <= r[0],
+            chk[3] and r[3] <= r[0],
+        ]
+    print(kind, chk)
+
+
+# try getting heap regions
+regions = esp32.idf_heap_info(esp32.HEAP_DATA)
+print("HEAP_DATA >2:", len(regions) > 2)
+chk_heap("HEAP_DATA", regions)
+
+# try getting code regions
+regions = esp32.idf_heap_info(esp32.HEAP_EXEC)
+print("HEAP_EXEC >2:", len(regions) > 2)
+chk_heap("HEAP_EXEC", regions)
+
+# try invalid param
+print(esp32.idf_heap_info(-1))
diff --git a/tests/esp32/esp32_idf_heap_info.py.exp b/tests/esp32/esp32_idf_heap_info.py.exp
new file mode 100644
index 0000000000000..2b63bf3259fc6
--- /dev/null
+++ b/tests/esp32/esp32_idf_heap_info.py.exp
@@ -0,0 +1,5 @@
+HEAP_DATA >2: True
+HEAP_DATA [True, True, True, True]
+HEAP_EXEC >2: True
+HEAP_EXEC [True, True, True, True]
+[]
diff --git a/tests/esp32/partition_ota.py b/tests/esp32/partition_ota.py
new file mode 100644
index 0000000000000..765630c8ce393
--- /dev/null
+++ b/tests/esp32/partition_ota.py
@@ -0,0 +1,117 @@
+# Test ESP32 OTA updates, including automatic roll-back.
+# Running this test requires firmware with an OTA Partition, such as the GENERIC_OTA "board".
+# This test also requires patience as it copies the boot partition into the other OTA slot.
+
+import machine
+from esp32 import Partition
+
+# start by checking that the running partition table has OTA partitions, 'cause if
+# it doesn't there's nothing we can test
+cur = Partition(Partition.RUNNING)
+cur_name = cur.info()[4]
+if not cur_name.startswith("ota_"):
+    print("SKIP")
+    raise SystemExit
+
+DEBUG = True
+
+
+def log(*args):
+    if DEBUG:
+        print(*args)
+
+
+# replace boot.py with the test code that will run on each reboot
+import uos
+
+try:
+    uos.rename("boot.py", "boot-orig.py")
+except:
+    pass
+with open("boot.py", "w") as f:
+    f.write("DEBUG=" + str(DEBUG))
+    f.write(
+        """
+import machine
+from esp32 import Partition
+cur = Partition(Partition.RUNNING)
+cur_name = cur.info()[4]
+
+def log(*args):
+    if DEBUG: print(*args)
+
+from step import STEP, EXPECT
+log("Running partition: " + cur_name + " STEP=" + str(STEP) + " EXPECT=" + EXPECT)
+if cur_name != EXPECT:
+    print("\\x04FAILED: step " + str(STEP) + " expected " + EXPECT + " got " + cur_name + "\\x04")
+
+if STEP == 0:
+    log("Not confirming boot ok and resetting back into first")
+    nxt = cur.get_next_update()
+    with open("step.py", "w") as f:
+        f.write("STEP=1\\nEXPECT=\\"" + nxt.info()[4] + "\\"\\n")
+    machine.reset()
+elif STEP == 1:
+    log("Booting into second partition again")
+    nxt = cur.get_next_update()
+    nxt.set_boot()
+    with open("step.py", "w") as f:
+        f.write("STEP=2\\nEXPECT=\\"" + nxt.info()[4] + "\\"\\n")
+    machine.reset()
+elif STEP == 2:
+    log("Confirming boot ok and rebooting into same partition")
+    Partition.mark_app_valid_cancel_rollback()
+    with open("step.py", "w") as f:
+        f.write("STEP=3\\nEXPECT=\\"" + cur_name + "\\"\\n")
+    machine.reset()
+elif STEP == 3:
+    log("Booting into original partition")
+    nxt = cur.get_next_update()
+    nxt.set_boot()
+    with open("step.py", "w") as f:
+        f.write("STEP=4\\nEXPECT=\\"" + nxt.info()[4] + "\\"\\n")
+    machine.reset()
+elif STEP == 4:
+    log("Confirming boot ok and DONE!")
+    Partition.mark_app_valid_cancel_rollback()
+    import uos
+    uos.remove("step.py")
+    uos.remove("boot.py")
+    uos.rename("boot-orig.py", "boot.py")
+    print("\\nSUCCESS!\\n\\x04\\x04")
+
+"""
+    )
+
+
+def copy_partition(src, dest):
+    log("Partition copy: {} --> {}".format(src.info(), dest.info()))
+    sz = src.info()[3]
+    if dest.info()[3] != sz:
+        raise ValueError("Sizes don't match: {} vs {}".format(sz, dest.info()[3]))
+    addr = 0
+    blk = bytearray(4096)
+    while addr < sz:
+        if sz - addr < 4096:
+            blk = blk[: sz - addr]
+        if addr & 0xFFFF == 0:
+            # need to show progress to run-tests else it times out
+            print("   ... 0x{:06x}".format(addr))
+        src.readblocks(addr >> 12, blk)
+        dest.writeblocks(addr >> 12, blk)
+        addr += len(blk)
+
+
+# get things started by copying the current partition into the next slot and rebooting
+print("Copying current to next partition")
+nxt = cur.get_next_update()
+copy_partition(cur, nxt)
+print("Partition copied, booting into it")
+nxt.set_boot()
+
+# the step.py file is used to keep track of state across reboots
+# EXPECT is the name of the partition we expect to reboot into
+with open("step.py", "w") as f:
+    f.write('STEP=0\nEXPECT="' + nxt.info()[4] + '"\n')
+
+machine.reset()
diff --git a/tests/esp32/partition_ota.py.exp b/tests/esp32/partition_ota.py.exp
new file mode 100644
index 0000000000000..9fc2618a151e8
--- /dev/null
+++ b/tests/esp32/partition_ota.py.exp
@@ -0,0 +1,15 @@
+Copying current to next partition
+########
+Partition copied, booting into it
+########
+Not confirming boot ok and resetting back into first
+########
+Booting into second partition again
+########
+Confirming boot ok and rebooting into same partition
+########
+Booting into original partition
+########
+Confirming boot ok and DONE!
+
+SUCCESS!
diff --git a/tests/esp32/resolve_on_connect.py b/tests/esp32/resolve_on_connect.py
new file mode 100644
index 0000000000000..068757ab2ab47
--- /dev/null
+++ b/tests/esp32/resolve_on_connect.py
@@ -0,0 +1,59 @@
+# Test that the esp32's socket module performs DNS resolutions on bind and connect
+import sys
+
+if sys.implementation.name == "micropython" and sys.platform != "esp32":
+    print("SKIP")
+    raise SystemExit
+
+try:
+    import usocket as socket, sys
+except:
+    import socket, sys
+
+
+def test_bind_resolves_0_0_0_0():
+    s = socket.socket()
+    try:
+        s.bind(("0.0.0.0", 31245))
+        print("bind actually bound")
+        s.close()
+    except Exception as e:
+        print("bind raised", e)
+
+
+def test_bind_resolves_localhost():
+    s = socket.socket()
+    try:
+        s.bind(("localhost", 31245))
+        print("bind actually bound")
+        s.close()
+    except Exception as e:
+        print("bind raised", e)
+
+
+def test_connect_resolves():
+    s = socket.socket()
+    try:
+        s.connect(("micropython.org", 80))
+        print("connect actually connected")
+        s.close()
+    except Exception as e:
+        print("connect raised", e)
+
+
+def test_connect_non_existent():
+    s = socket.socket()
+    try:
+        s.connect(("nonexistent.example.com", 80))
+        print("connect actually connected")
+        s.close()
+    except OSError as e:
+        print("connect raised OSError")
+    except Exception as e:
+        print("connect raised", e)
+
+
+test_funs = [n for n in dir() if n.startswith("test_")]
+for f in sorted(test_funs):
+    print("--", f, end=": ")
+    eval(f + "()")
diff --git a/tests/extmod/btree1.py b/tests/extmod/btree1.py
index 59638ef0a467b..4890d92b4202c 100644
--- a/tests/extmod/btree1.py
+++ b/tests/extmod/btree1.py
@@ -6,7 +6,7 @@
     print("SKIP")
     raise SystemExit
 
-#f = open("_test.db", "w+b")
+# f = open("_test.db", "w+b")
 f = uio.BytesIO()
 db = btree.open(f, pagesize=512)
 
diff --git a/tests/extmod/btree_error.py b/tests/extmod/btree_error.py
new file mode 100644
index 0000000000000..00e07ec8c7ae6
--- /dev/null
+++ b/tests/extmod/btree_error.py
@@ -0,0 +1,42 @@
+# Test that errno's propagate correctly through btree module.
+
+try:
+    import btree, uio, uerrno
+
+    uio.IOBase
+except (ImportError, AttributeError):
+    print("SKIP")
+    raise SystemExit
+
+
+class Device(uio.IOBase):
+    def __init__(self, read_ret=0, ioctl_ret=0):
+        self.read_ret = read_ret
+        self.ioctl_ret = ioctl_ret
+
+    def readinto(self, buf):
+        print("read", len(buf))
+        return self.read_ret
+
+    def ioctl(self, cmd, arg):
+        print("ioctl", cmd)
+        return self.ioctl_ret
+
+
+# Invalid pagesize; errno comes from btree library
+try:
+    db = btree.open(Device(), pagesize=511)
+except OSError as er:
+    print("OSError", er.args[0] == uerrno.EINVAL)
+
+# Valid pagesize, device returns error on read; errno comes from Device.readinto
+try:
+    db = btree.open(Device(-1000), pagesize=512)
+except OSError as er:
+    print(repr(er))
+
+# Valid pagesize, device returns error on seek; errno comes from Device.ioctl
+try:
+    db = btree.open(Device(0, -1001), pagesize=512)
+except OSError as er:
+    print(repr(er))
diff --git a/tests/extmod/btree_error.py.exp b/tests/extmod/btree_error.py.exp
new file mode 100644
index 0000000000000..168adb80c5ed8
--- /dev/null
+++ b/tests/extmod/btree_error.py.exp
@@ -0,0 +1,6 @@
+OSError True
+read 24
+OSError(1000,)
+read 24
+ioctl 2
+OSError(1001,)
diff --git a/tests/extmod/btree_gc.py b/tests/extmod/btree_gc.py
new file mode 100644
index 0000000000000..153f4e7d78ec7
--- /dev/null
+++ b/tests/extmod/btree_gc.py
@@ -0,0 +1,23 @@
+# Test btree interaction with the garbage collector.
+
+try:
+    import btree, uio, gc
+except ImportError:
+    print("SKIP")
+    raise SystemExit
+
+N = 80
+
+# Create a BytesIO but don't keep a reference to it.
+db = btree.open(uio.BytesIO(), pagesize=512)
+
+# Overwrite lots of the Python stack to make sure no reference to the BytesIO remains.
+x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+# Write lots of key/value pairs, which fill up the DB and also allocate temporary heap
+# memory due to the string addition, and do a GC collect to verify that the BytesIO
+# is not collected.
+for i in range(N):
+    db[b"thekey" + str(i)] = b"thelongvalue" + str(i)
+    print(db[b"thekey" + str(i)])
+    gc.collect()
diff --git a/tests/extmod/btree_gc.py.exp b/tests/extmod/btree_gc.py.exp
new file mode 100644
index 0000000000000..e7b8d5672940b
--- /dev/null
+++ b/tests/extmod/btree_gc.py.exp
@@ -0,0 +1,80 @@
+b'thelongvalue0'
+b'thelongvalue1'
+b'thelongvalue2'
+b'thelongvalue3'
+b'thelongvalue4'
+b'thelongvalue5'
+b'thelongvalue6'
+b'thelongvalue7'
+b'thelongvalue8'
+b'thelongvalue9'
+b'thelongvalue10'
+b'thelongvalue11'
+b'thelongvalue12'
+b'thelongvalue13'
+b'thelongvalue14'
+b'thelongvalue15'
+b'thelongvalue16'
+b'thelongvalue17'
+b'thelongvalue18'
+b'thelongvalue19'
+b'thelongvalue20'
+b'thelongvalue21'
+b'thelongvalue22'
+b'thelongvalue23'
+b'thelongvalue24'
+b'thelongvalue25'
+b'thelongvalue26'
+b'thelongvalue27'
+b'thelongvalue28'
+b'thelongvalue29'
+b'thelongvalue30'
+b'thelongvalue31'
+b'thelongvalue32'
+b'thelongvalue33'
+b'thelongvalue34'
+b'thelongvalue35'
+b'thelongvalue36'
+b'thelongvalue37'
+b'thelongvalue38'
+b'thelongvalue39'
+b'thelongvalue40'
+b'thelongvalue41'
+b'thelongvalue42'
+b'thelongvalue43'
+b'thelongvalue44'
+b'thelongvalue45'
+b'thelongvalue46'
+b'thelongvalue47'
+b'thelongvalue48'
+b'thelongvalue49'
+b'thelongvalue50'
+b'thelongvalue51'
+b'thelongvalue52'
+b'thelongvalue53'
+b'thelongvalue54'
+b'thelongvalue55'
+b'thelongvalue56'
+b'thelongvalue57'
+b'thelongvalue58'
+b'thelongvalue59'
+b'thelongvalue60'
+b'thelongvalue61'
+b'thelongvalue62'
+b'thelongvalue63'
+b'thelongvalue64'
+b'thelongvalue65'
+b'thelongvalue66'
+b'thelongvalue67'
+b'thelongvalue68'
+b'thelongvalue69'
+b'thelongvalue70'
+b'thelongvalue71'
+b'thelongvalue72'
+b'thelongvalue73'
+b'thelongvalue74'
+b'thelongvalue75'
+b'thelongvalue76'
+b'thelongvalue77'
+b'thelongvalue78'
+b'thelongvalue79'
diff --git a/tests/extmod/framebuf1.py b/tests/extmod/framebuf1.py
index 2c13665228a6a..c8e0132265aa0 100644
--- a/tests/extmod/framebuf1.py
+++ b/tests/extmod/framebuf1.py
@@ -8,9 +8,11 @@
 h = 16
 size = w * h // 8
 buf = bytearray(size)
-maps = {framebuf.MONO_VLSB : 'MONO_VLSB',
-        framebuf.MONO_HLSB : 'MONO_HLSB',
-        framebuf.MONO_HMSB : 'MONO_HMSB'}
+maps = {
+    framebuf.MONO_VLSB: "MONO_VLSB",
+    framebuf.MONO_HLSB: "MONO_HLSB",
+    framebuf.MONO_HMSB: "MONO_HMSB",
+}
 
 for mapping in maps.keys():
     for x in range(size):
@@ -43,33 +45,33 @@
     # hline
     fbuf.fill(0)
     fbuf.hline(0, 1, w, 1)
-    print('hline', buf)
+    print("hline", buf)
 
     # vline
     fbuf.fill(0)
     fbuf.vline(1, 0, h, 1)
-    print('vline', buf)
+    print("vline", buf)
 
     # rect
     fbuf.fill(0)
     fbuf.rect(1, 1, 3, 3, 1)
-    print('rect', buf)
+    print("rect", buf)
 
-    #fill rect
+    # fill rect
     fbuf.fill(0)
-    fbuf.fill_rect(0, 0, 0, 3, 1) # zero width, no-operation
+    fbuf.fill_rect(0, 0, 0, 3, 1)  # zero width, no-operation
     fbuf.fill_rect(1, 1, 3, 3, 1)
-    print('fill_rect', buf)
+    print("fill_rect", buf)
 
     # line
     fbuf.fill(0)
     fbuf.line(1, 1, 3, 3, 1)
-    print('line', buf)
+    print("line", buf)
 
     # line steep negative gradient
     fbuf.fill(0)
     fbuf.line(3, 3, 2, 1, 1)
-    print('line', buf)
+    print("line", buf)
 
     # scroll
     fbuf.fill(0)
@@ -89,7 +91,7 @@
     fbuf.fill(0)
     fbuf.text("hello", 0, 0, 1)
     print(buf)
-    fbuf.text("hello", 0, 0, 0) # clear
+    fbuf.text("hello", 0, 0, 0)  # clear
     print(buf)
 
     # char out of font range set to chr(127)
diff --git a/tests/extmod/framebuf16.py b/tests/extmod/framebuf16.py
index fe81f7f93f8c0..e658f1345ad1a 100644
--- a/tests/extmod/framebuf16.py
+++ b/tests/extmod/framebuf16.py
@@ -4,28 +4,30 @@
     print("SKIP")
     raise SystemExit
 
+
 def printbuf():
     print("--8<--")
     for y in range(h):
-        print(buf[y * w * 2:(y + 1) * w * 2])
+        print(buf[y * w * 2 : (y + 1) * w * 2])
     print("-->8--")
 
+
 w = 4
 h = 5
 buf = bytearray(w * h * 2)
 fbuf = framebuf.FrameBuffer(buf, w, h, framebuf.RGB565)
 
 # fill
-fbuf.fill(0xffff)
+fbuf.fill(0xFFFF)
 printbuf()
 fbuf.fill(0x0000)
 printbuf()
 
 # put pixel
-fbuf.pixel(0, 0, 0xeeee)
-fbuf.pixel(3, 0, 0xee00)
-fbuf.pixel(0, 4, 0x00ee)
-fbuf.pixel(3, 4, 0x0ee0)
+fbuf.pixel(0, 0, 0xEEEE)
+fbuf.pixel(3, 0, 0xEE00)
+fbuf.pixel(0, 4, 0x00EE)
+fbuf.pixel(3, 4, 0x0EE0)
 printbuf()
 
 # get pixel
@@ -33,7 +35,7 @@ def printbuf():
 
 # scroll
 fbuf.fill(0x0000)
-fbuf.pixel(2, 2, 0xffff)
+fbuf.pixel(2, 2, 0xFFFF)
 printbuf()
 fbuf.scroll(0, 1)
 printbuf()
@@ -48,11 +50,11 @@ def printbuf():
 fbuf2 = framebuf.FrameBuffer(buf2, w2, h2, framebuf.RGB565)
 
 fbuf2.fill(0x0000)
-fbuf2.pixel(0, 0, 0x0ee0)
-fbuf2.pixel(0, 2, 0xee00)
-fbuf2.pixel(1, 0, 0x00ee)
-fbuf2.pixel(1, 2, 0xe00e)
-fbuf.fill(0xffff)
+fbuf2.pixel(0, 0, 0x0EE0)
+fbuf2.pixel(0, 2, 0xEE00)
+fbuf2.pixel(1, 0, 0x00EE)
+fbuf2.pixel(1, 2, 0xE00E)
+fbuf.fill(0xFFFF)
 fbuf.blit(fbuf2, 3, 3, 0x0000)
 fbuf.blit(fbuf2, -1, -1, 0x0000)
 fbuf.blit(fbuf2, 16, 16, 0x0000)
diff --git a/tests/extmod/framebuf2.py b/tests/extmod/framebuf2.py
index a313170eb5e42..097057fe96fa1 100644
--- a/tests/extmod/framebuf2.py
+++ b/tests/extmod/framebuf2.py
@@ -4,14 +4,16 @@
     print("SKIP")
     raise SystemExit
 
+
 def printbuf():
     print("--8<--")
     for y in range(h):
         for x in range(w):
-            print('%u' % ((buf[(x + y * w) // 4] >> ((x & 3) << 1)) & 3), end='')
+            print("%u" % ((buf[(x + y * w) // 4] >> ((x & 3) << 1)) & 3), end="")
         print()
     print("-->8--")
 
+
 w = 8
 h = 5
 buf = bytearray(w * h // 4)
diff --git a/tests/extmod/framebuf4.py b/tests/extmod/framebuf4.py
index 8358fa55b9f2b..56593ee15524c 100644
--- a/tests/extmod/framebuf4.py
+++ b/tests/extmod/framebuf4.py
@@ -4,50 +4,52 @@
     print("SKIP")
     raise SystemExit
 
+
 def printbuf():
     print("--8<--")
     for y in range(h):
-        print(buf[y * w // 2:(y + 1) * w // 2])
+        print(buf[y * w // 2 : (y + 1) * w // 2])
     print("-->8--")
 
+
 w = 16
 h = 8
 buf = bytearray(w * h // 2)
 fbuf = framebuf.FrameBuffer(buf, w, h, framebuf.GS4_HMSB)
 
 # fill
-fbuf.fill(0x0f)
+fbuf.fill(0x0F)
 printbuf()
-fbuf.fill(0xa0)
+fbuf.fill(0xA0)
 printbuf()
 
 # put pixel
 fbuf.pixel(0, 0, 0x01)
 printbuf()
-fbuf.pixel(w-1, 0, 0x02)
+fbuf.pixel(w - 1, 0, 0x02)
 printbuf()
-fbuf.pixel(w-1, h-1, 0x03)
+fbuf.pixel(w - 1, h - 1, 0x03)
 printbuf()
-fbuf.pixel(0, h-1, 0x04)
+fbuf.pixel(0, h - 1, 0x04)
 printbuf()
 
 # get pixel
-print(fbuf.pixel(0, 0), fbuf.pixel(w-1, 0), fbuf.pixel(w-1, h-1), fbuf.pixel(0, h-1))
-print(fbuf.pixel(1, 0), fbuf.pixel(w-2, 0), fbuf.pixel(w-2, h-1), fbuf.pixel(1, h-1))
+print(fbuf.pixel(0, 0), fbuf.pixel(w - 1, 0), fbuf.pixel(w - 1, h - 1), fbuf.pixel(0, h - 1))
+print(fbuf.pixel(1, 0), fbuf.pixel(w - 2, 0), fbuf.pixel(w - 2, h - 1), fbuf.pixel(1, h - 1))
 
 # fill rect
-fbuf.fill_rect(0, 0, w, h, 0x0f)
+fbuf.fill_rect(0, 0, w, h, 0x0F)
 printbuf()
-fbuf.fill_rect(0, 0, w, h, 0xf0)
-fbuf.fill_rect(1, 0, w//2+1, 1, 0xf1)
+fbuf.fill_rect(0, 0, w, h, 0xF0)
+fbuf.fill_rect(1, 0, w // 2 + 1, 1, 0xF1)
 printbuf()
-fbuf.fill_rect(1, 0, w//2+1, 1, 0x10)
-fbuf.fill_rect(1, 0, w//2, 1, 0xf1)
+fbuf.fill_rect(1, 0, w // 2 + 1, 1, 0x10)
+fbuf.fill_rect(1, 0, w // 2, 1, 0xF1)
 printbuf()
-fbuf.fill_rect(1, 0, w//2, 1, 0x10)
-fbuf.fill_rect(0, h-4, w//2+1, 4, 0xaf)
+fbuf.fill_rect(1, 0, w // 2, 1, 0x10)
+fbuf.fill_rect(0, h - 4, w // 2 + 1, 4, 0xAF)
 printbuf()
-fbuf.fill_rect(0, h-4, w//2+1, 4, 0xb0)
-fbuf.fill_rect(0, h-4, w//2, 4, 0xaf)
+fbuf.fill_rect(0, h - 4, w // 2 + 1, 4, 0xB0)
+fbuf.fill_rect(0, h - 4, w // 2, 4, 0xAF)
 printbuf()
-fbuf.fill_rect(0, h-4, w//2, 4, 0xb0)
+fbuf.fill_rect(0, h - 4, w // 2, 4, 0xB0)
diff --git a/tests/extmod/framebuf8.py b/tests/extmod/framebuf8.py
index b6899aae9122c..a3ca6fcd4fa8e 100644
--- a/tests/extmod/framebuf8.py
+++ b/tests/extmod/framebuf8.py
@@ -4,14 +4,16 @@
     print("SKIP")
     raise SystemExit
 
+
 def printbuf():
     print("--8<--")
     for y in range(h):
         for x in range(w):
-            print('%02x' % buf[(x + y * w)], end='')
+            print("%02x" % buf[(x + y * w)], end="")
         print()
     print("-->8--")
 
+
 w = 8
 h = 5
 buf = bytearray(w * h)
@@ -25,7 +27,7 @@ def printbuf():
 fbuf.pixel(0, 0, 0x11)
 fbuf.pixel(w - 1, 0, 0x22)
 fbuf.pixel(0, h - 1, 0x33)
-fbuf.pixel(w - 1, h - 1, 0xff)
+fbuf.pixel(w - 1, h - 1, 0xFF)
 printbuf()
 
 # get pixel
diff --git a/tests/extmod/framebuf_subclass.py b/tests/extmod/framebuf_subclass.py
index 6363c224fbb52..aad5d2a1e96b4 100644
--- a/tests/extmod/framebuf_subclass.py
+++ b/tests/extmod/framebuf_subclass.py
@@ -3,9 +3,10 @@
 try:
     import framebuf
 except ImportError:
-    print('SKIP')
+    print("SKIP")
     raise SystemExit
 
+
 class FB(framebuf.FrameBuffer):
     def __init__(self, n):
         self.n = n
@@ -14,7 +15,31 @@ def __init__(self, n):
     def foo(self):
         self.hline(0, 2, self.n, 0x0304)
 
+
 fb = FB(n=3)
 fb.pixel(0, 0, 0x0102)
 fb.foo()
 print(bytes(fb))
+
+# Test that blitting a subclass works.
+fb2 = framebuf.FrameBuffer(bytearray(2 * 3 * 3), 3, 3, framebuf.RGB565)
+fb.fill(0)
+fb.pixel(0, 0, 0x0506)
+fb.pixel(2, 2, 0x0708)
+fb2.blit(fb, 0, 0)
+print(bytes(fb2))
+
+# Test that blitting something that isn't a subclass fails with TypeError.
+class NotAFrameBuf:
+    pass
+
+
+try:
+    fb.blit(NotAFrameBuf(), 0, 0)
+except TypeError:
+    print("TypeError")
+
+try:
+    fb.blit(None, 0, 0)
+except TypeError:
+    print("TypeError")
diff --git a/tests/extmod/framebuf_subclass.py.exp b/tests/extmod/framebuf_subclass.py.exp
index 23d53ccc62536..58e311fee5e8a 100644
--- a/tests/extmod/framebuf_subclass.py.exp
+++ b/tests/extmod/framebuf_subclass.py.exp
@@ -1 +1,4 @@
 b'\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x03\x04\x03\x04\x03'
+b'\x06\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x07'
+TypeError
+TypeError
diff --git a/tests/extmod/machine_pinbase.py b/tests/extmod/machine_pinbase.py
index e91775504d59a..8bddd4bb70615 100644
--- a/tests/extmod/machine_pinbase.py
+++ b/tests/extmod/machine_pinbase.py
@@ -1,16 +1,15 @@
 try:
-    import umachine as machine
-except ImportError:
-    import machine
-try:
+    try:
+        import umachine as machine
+    except ImportError:
+        import machine
     machine.PinBase
-except AttributeError:
+except:
     print("SKIP")
     raise SystemExit
 
 
 class MyPin(machine.PinBase):
-
     def __init__(self):
         print("__init__")
         self.v = False
@@ -21,6 +20,7 @@ def value(self, v=None):
             self.v = not self.v
             return int(self.v)
 
+
 p = MyPin()
 
 print(p.value())
diff --git a/tests/extmod/machine_pulse.py b/tests/extmod/machine_pulse.py
index d525974e0c2a9..65d15fb3513bf 100644
--- a/tests/extmod/machine_pulse.py
+++ b/tests/extmod/machine_pulse.py
@@ -1,17 +1,16 @@
 try:
-    import umachine as machine
-except ImportError:
-    import machine
-try:
+    try:
+        import umachine as machine
+    except ImportError:
+        import machine
     machine.PinBase
     machine.time_pulse_us
-except AttributeError:
+except:
     print("SKIP")
     raise SystemExit
 
 
 class ConstPin(machine.PinBase):
-
     def __init__(self, value):
         self.v = value
 
@@ -23,7 +22,6 @@ def value(self, v=None):
 
 
 class TogglePin(machine.PinBase):
-
     def __init__(self):
         self.v = 0
 
diff --git a/tests/extmod/machine_signal.py b/tests/extmod/machine_signal.py
index 53f4f5890c3dd..1ffdb5643605f 100644
--- a/tests/extmod/machine_signal.py
+++ b/tests/extmod/machine_signal.py
@@ -1,16 +1,17 @@
 # test machine.Signal class
 
 try:
-    import umachine as machine
-except ImportError:
-    import machine
-try:
+    try:
+        import umachine as machine
+    except ImportError:
+        import machine
     machine.PinBase
     machine.Signal
-except AttributeError:
+except:
     print("SKIP")
     raise SystemExit
 
+
 class Pin(machine.PinBase):
     def __init__(self):
         self.v = 0
diff --git a/tests/extmod/machine_timer.py b/tests/extmod/machine_timer.py
new file mode 100644
index 0000000000000..c9a47c402583e
--- /dev/null
+++ b/tests/extmod/machine_timer.py
@@ -0,0 +1,38 @@
+# test machine.Timer
+
+try:
+    import utime, umachine as machine
+
+    machine.Timer
+except:
+    print("SKIP")
+    raise SystemExit
+
+# create and deinit
+t = machine.Timer(freq=1)
+t.deinit()
+
+# deinit again
+t.deinit()
+
+# create 2 and deinit
+t = machine.Timer(freq=1)
+t2 = machine.Timer(freq=1)
+t.deinit()
+t2.deinit()
+
+# create 2 and deinit in different order
+t = machine.Timer(freq=1)
+t2 = machine.Timer(freq=1)
+t2.deinit()
+t.deinit()
+
+# create one-shot timer with callback and wait for it to print (should be just once)
+t = machine.Timer(period=1, mode=machine.Timer.ONE_SHOT, callback=lambda t: print("one-shot"))
+utime.sleep_ms(5)
+t.deinit()
+
+# create periodic timer with callback and wait for it to print
+t = machine.Timer(period=4, mode=machine.Timer.PERIODIC, callback=lambda t: print("periodic"))
+utime.sleep_ms(14)
+t.deinit()
diff --git a/tests/extmod/machine_timer.py.exp b/tests/extmod/machine_timer.py.exp
new file mode 100644
index 0000000000000..2dd85ba67d381
--- /dev/null
+++ b/tests/extmod/machine_timer.py.exp
@@ -0,0 +1,4 @@
+one-shot
+periodic
+periodic
+periodic
diff --git a/tests/extmod/ticks_diff.py b/tests/extmod/ticks_diff.py
index 4d8df83cf91d1..de45a557afcf2 100644
--- a/tests/extmod/ticks_diff.py
+++ b/tests/extmod/ticks_diff.py
@@ -1,4 +1,8 @@
-from utime import ticks_diff, ticks_add
+try:
+    from utime import ticks_diff, ticks_add
+except ImportError:
+    print("SKIP")
+    raise SystemExit
 
 MAX = ticks_add(0, -1)
 # Should be done like this to avoid small int overflow
diff --git a/tests/extmod/time_ms_us.py b/tests/extmod/time_ms_us.py
index 135cf1e0967d6..ac2ed8be27e5a 100644
--- a/tests/extmod/time_ms_us.py
+++ b/tests/extmod/time_ms_us.py
@@ -1,7 +1,8 @@
-import utime
 try:
-    utime.sleep_ms
-except AttributeError:
+    import utime
+
+    utime.sleep_ms, utime.sleep_us, utime.ticks_diff, utime.ticks_ms, utime.ticks_us, utime.ticks_cpu
+except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
 
diff --git a/tests/extmod/uasyncio_await_return.py b/tests/extmod/uasyncio_await_return.py
new file mode 100644
index 0000000000000..d375c9ea97ab3
--- /dev/null
+++ b/tests/extmod/uasyncio_await_return.py
@@ -0,0 +1,26 @@
+# Test that tasks return their value correctly to the caller
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def foo():
+    return 42
+
+
+async def main():
+    # Call function directly via an await
+    print(await foo())
+
+    # Create a task and await on it
+    task = asyncio.create_task(foo())
+    print(await task)
+
+
+asyncio.run(main())
diff --git a/tests/extmod/uasyncio_await_return.py.exp b/tests/extmod/uasyncio_await_return.py.exp
new file mode 100644
index 0000000000000..daaac9e303029
--- /dev/null
+++ b/tests/extmod/uasyncio_await_return.py.exp
@@ -0,0 +1,2 @@
+42
+42
diff --git a/tests/extmod/uasyncio_basic.py b/tests/extmod/uasyncio_basic.py
new file mode 100644
index 0000000000000..f6685fa674676
--- /dev/null
+++ b/tests/extmod/uasyncio_basic.py
@@ -0,0 +1,43 @@
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+try:
+    import utime
+
+    ticks = utime.ticks_ms
+    ticks_diff = utime.ticks_diff
+except:
+    import time
+
+    ticks = lambda: int(time.time() * 1000)
+    ticks_diff = lambda t1, t0: t1 - t0
+
+
+async def delay_print(t, s):
+    await asyncio.sleep(t)
+    print(s)
+
+
+async def main():
+    print("start")
+
+    await asyncio.sleep(0.001)
+    print("after sleep")
+
+    t0 = ticks()
+    await delay_print(0.02, "short")
+    t1 = ticks()
+    await delay_print(0.04, "long")
+    t2 = ticks()
+
+    print("took {} {}".format(round(ticks_diff(t1, t0), -1), round(ticks_diff(t2, t1), -1)))
+
+
+asyncio.run(main())
diff --git a/tests/extmod/uasyncio_basic.py.exp b/tests/extmod/uasyncio_basic.py.exp
new file mode 100644
index 0000000000000..447d05d5e0984
--- /dev/null
+++ b/tests/extmod/uasyncio_basic.py.exp
@@ -0,0 +1,5 @@
+start
+after sleep
+short
+long
+took 20 40
diff --git a/tests/extmod/uasyncio_basic2.py b/tests/extmod/uasyncio_basic2.py
new file mode 100644
index 0000000000000..a2167e48ee1a7
--- /dev/null
+++ b/tests/extmod/uasyncio_basic2.py
@@ -0,0 +1,24 @@
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def forever():
+    print("forever start")
+    await asyncio.sleep(10)
+
+
+async def main():
+    print("main start")
+    asyncio.create_task(forever())
+    await asyncio.sleep(0.001)
+    print("main done")
+    return 42
+
+
+print(asyncio.run(main()))
diff --git a/tests/extmod/uasyncio_basic2.py.exp b/tests/extmod/uasyncio_basic2.py.exp
new file mode 100644
index 0000000000000..3ca3521728d44
--- /dev/null
+++ b/tests/extmod/uasyncio_basic2.py.exp
@@ -0,0 +1,4 @@
+main start
+forever start
+main done
+42
diff --git a/tests/extmod/uasyncio_cancel_fair.py b/tests/extmod/uasyncio_cancel_fair.py
new file mode 100644
index 0000000000000..9a7b35c1618af
--- /dev/null
+++ b/tests/extmod/uasyncio_cancel_fair.py
@@ -0,0 +1,37 @@
+# Test fairness of cancelling a task
+# That tasks which continuously cancel each other don't take over the scheduler
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def task(id, other):
+    for i in range(3):
+        try:
+            print("start", id)
+            await asyncio.sleep(0)
+            print("done", id)
+        except asyncio.CancelledError as er:
+            print("cancelled", id)
+        if other is not None:
+            print(id, "cancels", other)
+            tasks[other].cancel()
+
+
+async def main():
+    global tasks
+    tasks = [
+        asyncio.create_task(task(0, 1)),
+        asyncio.create_task(task(1, 0)),
+        asyncio.create_task(task(2, None)),
+    ]
+    await tasks[2]
+
+
+asyncio.run(main())
diff --git a/tests/extmod/uasyncio_cancel_fair.py.exp b/tests/extmod/uasyncio_cancel_fair.py.exp
new file mode 100644
index 0000000000000..8f5da08e4ced4
--- /dev/null
+++ b/tests/extmod/uasyncio_cancel_fair.py.exp
@@ -0,0 +1,24 @@
+start 0
+start 1
+start 2
+done 0
+0 cancels 1
+start 0
+cancelled 1
+1 cancels 0
+start 1
+done 2
+start 2
+cancelled 0
+0 cancels 1
+start 0
+cancelled 1
+1 cancels 0
+start 1
+done 2
+start 2
+cancelled 0
+0 cancels 1
+cancelled 1
+1 cancels 0
+done 2
diff --git a/tests/extmod/uasyncio_cancel_fair2.py b/tests/extmod/uasyncio_cancel_fair2.py
new file mode 100644
index 0000000000000..46e40f71b15ca
--- /dev/null
+++ b/tests/extmod/uasyncio_cancel_fair2.py
@@ -0,0 +1,37 @@
+# Test fairness of cancelling a task
+# That tasks which keeps being cancelled by multiple other tasks gets a chance to run
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def task_a():
+    try:
+        while True:
+            print("sleep a")
+            await asyncio.sleep(0)
+    except asyncio.CancelledError:
+        print("cancelled a")
+
+
+async def task_b(id, other):
+    while other.cancel():
+        print("sleep b", id)
+        await asyncio.sleep(0)
+    print("done b", id)
+
+
+async def main():
+    t = asyncio.create_task(task_a())
+    for i in range(3):
+        asyncio.create_task(task_b(i, t))
+    await t
+
+
+asyncio.run(main())
diff --git a/tests/extmod/uasyncio_cancel_fair2.py.exp b/tests/extmod/uasyncio_cancel_fair2.py.exp
new file mode 100644
index 0000000000000..e9dd649b453f9
--- /dev/null
+++ b/tests/extmod/uasyncio_cancel_fair2.py.exp
@@ -0,0 +1,8 @@
+sleep a
+sleep b 0
+sleep b 1
+sleep b 2
+cancelled a
+done b 0
+done b 1
+done b 2
diff --git a/tests/extmod/uasyncio_cancel_self.py b/tests/extmod/uasyncio_cancel_self.py
new file mode 100644
index 0000000000000..660ae66389366
--- /dev/null
+++ b/tests/extmod/uasyncio_cancel_self.py
@@ -0,0 +1,31 @@
+# Test a task cancelling itself (currently unsupported)
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def task():
+    print("task start")
+    global_task.cancel()
+
+
+async def main():
+    global global_task
+    global_task = asyncio.create_task(task())
+    try:
+        await global_task
+    except asyncio.CancelledError:
+        print("main cancel")
+    print("main done")
+
+
+try:
+    asyncio.run(main())
+except RuntimeError as er:
+    print(er)
diff --git a/tests/extmod/uasyncio_cancel_self.py.exp b/tests/extmod/uasyncio_cancel_self.py.exp
new file mode 100644
index 0000000000000..a34c73460b6ce
--- /dev/null
+++ b/tests/extmod/uasyncio_cancel_self.py.exp
@@ -0,0 +1,2 @@
+task start
+can't cancel self
diff --git a/tests/extmod/uasyncio_cancel_task.py b/tests/extmod/uasyncio_cancel_task.py
new file mode 100644
index 0000000000000..ec60d85545740
--- /dev/null
+++ b/tests/extmod/uasyncio_cancel_task.py
@@ -0,0 +1,85 @@
+# Test cancelling a task
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def task(s, allow_cancel):
+    try:
+        print("task start")
+        await asyncio.sleep(s)
+        print("task done")
+    except asyncio.CancelledError as er:
+        print("task cancel")
+        if allow_cancel:
+            raise er
+
+
+async def task2(allow_cancel):
+    print("task 2")
+    try:
+        await asyncio.create_task(task(0.05, allow_cancel))
+    except asyncio.CancelledError as er:
+        print("task 2 cancel")
+        raise er
+    print("task 2 done")
+
+
+async def main():
+    # Cancel task immediately
+    t = asyncio.create_task(task(2, True))
+    print(t.cancel())
+
+    # Cancel task after it has started
+    t = asyncio.create_task(task(2, True))
+    await asyncio.sleep(0.01)
+    print(t.cancel())
+    print("main sleep")
+    await asyncio.sleep(0.01)
+
+    # Cancel task multiple times after it has started
+    t = asyncio.create_task(task(2, True))
+    await asyncio.sleep(0.01)
+    for _ in range(4):
+        print(t.cancel())
+    print("main sleep")
+    await asyncio.sleep(0.01)
+
+    # Await on a cancelled task
+    print("main wait")
+    try:
+        await t
+    except asyncio.CancelledError:
+        print("main got CancelledError")
+
+    # Cancel task after it has finished
+    t = asyncio.create_task(task(0.01, False))
+    await asyncio.sleep(0.05)
+    print(t.cancel())
+
+    # Nested: task2 waits on task, task2 is cancelled (should cancel task then task2)
+    print("----")
+    t = asyncio.create_task(task2(True))
+    await asyncio.sleep(0.01)
+    print("main cancel")
+    t.cancel()
+    print("main sleep")
+    await asyncio.sleep(0.1)
+
+    # Nested: task2 waits on task, task2 is cancelled but task doesn't allow it (task2 should continue)
+    print("----")
+    t = asyncio.create_task(task2(False))
+    await asyncio.sleep(0.01)
+    print("main cancel")
+    t.cancel()
+    print("main sleep")
+    await asyncio.sleep(0.1)
+
+
+asyncio.run(main())
diff --git a/tests/extmod/uasyncio_cancel_task.py.exp b/tests/extmod/uasyncio_cancel_task.py.exp
new file mode 100644
index 0000000000000..031b94023fd03
--- /dev/null
+++ b/tests/extmod/uasyncio_cancel_task.py.exp
@@ -0,0 +1,31 @@
+True
+task start
+True
+main sleep
+task cancel
+task start
+True
+True
+True
+True
+main sleep
+task cancel
+main wait
+main got CancelledError
+task start
+task done
+False
+----
+task 2
+task start
+main cancel
+main sleep
+task cancel
+task 2 cancel
+----
+task 2
+task start
+main cancel
+main sleep
+task cancel
+task 2 done
diff --git a/tests/extmod/uasyncio_event.py b/tests/extmod/uasyncio_event.py
new file mode 100644
index 0000000000000..fb8eb9ffa40a7
--- /dev/null
+++ b/tests/extmod/uasyncio_event.py
@@ -0,0 +1,98 @@
+# Test Event class
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def task(id, ev):
+    print("start", id)
+    print(await ev.wait())
+    print("end", id)
+
+
+async def task_delay_set(t, ev):
+    await asyncio.sleep(t)
+    print("set event")
+    ev.set()
+
+
+async def main():
+    ev = asyncio.Event()
+
+    # Set and clear without anything waiting, and test is_set()
+    print(ev.is_set())
+    ev.set()
+    print(ev.is_set())
+    ev.clear()
+    print(ev.is_set())
+
+    # Create 2 tasks waiting on the event
+    print("----")
+    asyncio.create_task(task(1, ev))
+    asyncio.create_task(task(2, ev))
+    print("yield")
+    await asyncio.sleep(0)
+    print("set event")
+    ev.set()
+    print("yield")
+    await asyncio.sleep(0)
+
+    # Create a task waiting on the already-set event
+    print("----")
+    asyncio.create_task(task(3, ev))
+    print("yield")
+    await asyncio.sleep(0)
+
+    # Clear event, start a task, then set event again
+    print("----")
+    print("clear event")
+    ev.clear()
+    asyncio.create_task(task(4, ev))
+    await asyncio.sleep(0)
+    print("set event")
+    ev.set()
+    await asyncio.sleep(0)
+
+    # Cancel a task waiting on an event (set event then cancel task)
+    print("----")
+    ev = asyncio.Event()
+    t = asyncio.create_task(task(5, ev))
+    await asyncio.sleep(0)
+    ev.set()
+    t.cancel()
+    await asyncio.sleep(0.1)
+
+    # Cancel a task waiting on an event (cancel task then set event)
+    print("----")
+    ev = asyncio.Event()
+    t = asyncio.create_task(task(6, ev))
+    await asyncio.sleep(0)
+    t.cancel()
+    ev.set()
+    await asyncio.sleep(0.1)
+
+    # Wait for an event that does get set in time
+    print("----")
+    ev.clear()
+    asyncio.create_task(task_delay_set(0.01, ev))
+    await asyncio.wait_for(ev.wait(), 0.1)
+    await asyncio.sleep(0)
+
+    # Wait for an event that doesn't get set in time
+    print("----")
+    ev.clear()
+    asyncio.create_task(task_delay_set(0.1, ev))
+    try:
+        await asyncio.wait_for(ev.wait(), 0.01)
+    except asyncio.TimeoutError:
+        print("TimeoutError")
+    await ev.wait()
+
+
+asyncio.run(main())
diff --git a/tests/extmod/uasyncio_event.py.exp b/tests/extmod/uasyncio_event.py.exp
new file mode 100644
index 0000000000000..3188f291e584d
--- /dev/null
+++ b/tests/extmod/uasyncio_event.py.exp
@@ -0,0 +1,33 @@
+False
+True
+False
+----
+yield
+start 1
+start 2
+set event
+yield
+True
+end 1
+True
+end 2
+----
+yield
+start 3
+True
+end 3
+----
+clear event
+start 4
+set event
+True
+end 4
+----
+start 5
+----
+start 6
+----
+set event
+----
+TimeoutError
+set event
diff --git a/tests/extmod/uasyncio_event_fair.py b/tests/extmod/uasyncio_event_fair.py
new file mode 100644
index 0000000000000..37eca5faef10b
--- /dev/null
+++ b/tests/extmod/uasyncio_event_fair.py
@@ -0,0 +1,40 @@
+# Test fairness of Event.set()
+# That tasks which continuously wait on events don't take over the scheduler
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def task1(id):
+    for i in range(4):
+        print("sleep", id)
+        await asyncio.sleep(0)
+
+
+async def task2(id, ev):
+    for i in range(4):
+        ev.set()
+        ev.clear()
+        print("wait", id)
+        await ev.wait()
+
+
+async def main():
+    ev = asyncio.Event()
+    tasks = [
+        asyncio.create_task(task1(0)),
+        asyncio.create_task(task2(2, ev)),
+        asyncio.create_task(task1(1)),
+        asyncio.create_task(task2(3, ev)),
+    ]
+    await tasks[1]
+    ev.set()
+
+
+asyncio.run(main())
diff --git a/tests/extmod/uasyncio_event_fair.py.exp b/tests/extmod/uasyncio_event_fair.py.exp
new file mode 100644
index 0000000000000..fe2e3d6e47a63
--- /dev/null
+++ b/tests/extmod/uasyncio_event_fair.py.exp
@@ -0,0 +1,16 @@
+sleep 0
+wait 2
+sleep 1
+wait 3
+sleep 0
+sleep 1
+wait 2
+sleep 0
+sleep 1
+wait 3
+sleep 0
+sleep 1
+wait 2
+wait 3
+wait 2
+wait 3
diff --git a/tests/extmod/uasyncio_exception.py b/tests/extmod/uasyncio_exception.py
new file mode 100644
index 0000000000000..aae55d63207a2
--- /dev/null
+++ b/tests/extmod/uasyncio_exception.py
@@ -0,0 +1,60 @@
+# Test general exception handling
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+# main task raising an exception
+async def main():
+    print("main start")
+    raise ValueError(1)
+    print("main done")
+
+
+try:
+    asyncio.run(main())
+except ValueError as er:
+    print("ValueError", er.args[0])
+
+# sub-task raising an exception
+async def task():
+    print("task start")
+    raise ValueError(2)
+    print("task done")
+
+
+async def main():
+    print("main start")
+    t = asyncio.create_task(task())
+    await t
+    print("main done")
+
+
+try:
+    asyncio.run(main())
+except ValueError as er:
+    print("ValueError", er.args[0])
+
+# main task raising an exception with sub-task not yet scheduled
+# TODO not currently working, task is never scheduled
+async def task():
+    # print('task run') uncomment this line when it works
+    pass
+
+
+async def main():
+    print("main start")
+    asyncio.create_task(task())
+    raise ValueError(3)
+    print("main done")
+
+
+try:
+    asyncio.run(main())
+except ValueError as er:
+    print("ValueError", er.args[0])
diff --git a/tests/extmod/uasyncio_exception.py.exp b/tests/extmod/uasyncio_exception.py.exp
new file mode 100644
index 0000000000000..b2ee860170ece
--- /dev/null
+++ b/tests/extmod/uasyncio_exception.py.exp
@@ -0,0 +1,7 @@
+main start
+ValueError 1
+main start
+task start
+ValueError 2
+main start
+ValueError 3
diff --git a/tests/extmod/uasyncio_fair.py b/tests/extmod/uasyncio_fair.py
new file mode 100644
index 0000000000000..9b04454bc1f50
--- /dev/null
+++ b/tests/extmod/uasyncio_fair.py
@@ -0,0 +1,32 @@
+# Test fairness of scheduler
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def task(id, t):
+    print("task start", id)
+    while True:
+        if t > 0:
+            print("task work", id)
+        await asyncio.sleep(t)
+
+
+async def main():
+    t1 = asyncio.create_task(task(1, -0.01))
+    t2 = asyncio.create_task(task(2, 0.1))
+    t3 = asyncio.create_task(task(3, 0.2))
+    await asyncio.sleep(0.5)
+    t1.cancel()
+    t2.cancel()
+    t3.cancel()
+    print("finish")
+
+
+asyncio.run(main())
diff --git a/tests/extmod/uasyncio_fair.py.exp b/tests/extmod/uasyncio_fair.py.exp
new file mode 100644
index 0000000000000..4428943f46287
--- /dev/null
+++ b/tests/extmod/uasyncio_fair.py.exp
@@ -0,0 +1,12 @@
+task start 1
+task start 2
+task work 2
+task start 3
+task work 3
+task work 2
+task work 3
+task work 2
+task work 2
+task work 3
+task work 2
+finish
diff --git a/tests/extmod/uasyncio_gather.py b/tests/extmod/uasyncio_gather.py
new file mode 100644
index 0000000000000..2697a6278b08c
--- /dev/null
+++ b/tests/extmod/uasyncio_gather.py
@@ -0,0 +1,49 @@
+# test uasyncio.gather() function
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def factorial(name, number):
+    f = 1
+    for i in range(2, number + 1):
+        print("Task {}: Compute factorial({})...".format(name, i))
+        await asyncio.sleep(0.01)
+        f *= i
+    print("Task {}: factorial({}) = {}".format(name, number, f))
+    return f
+
+
+async def task(id):
+    print("start", id)
+    await asyncio.sleep(0.2)
+    print("end", id)
+
+
+async def gather_task():
+    print("gather_task")
+    await asyncio.gather(task(1), task(2))
+    print("gather_task2")
+
+
+async def main():
+    # Simple gather with return values
+    print(await asyncio.gather(factorial("A", 2), factorial("B", 3), factorial("C", 4),))
+
+    # Cancel a multi gather
+    # TODO doesn't work, Task should not forward cancellation from gather to sub-task
+    # but rather CancelledError should cancel the gather directly, which will then cancel
+    # all sub-tasks explicitly
+    # t = asyncio.create_task(gather_task())
+    # await asyncio.sleep(0.1)
+    # t.cancel()
+    # await asyncio.sleep(0.01)
+
+
+asyncio.run(main())
diff --git a/tests/extmod/uasyncio_gather.py.exp b/tests/extmod/uasyncio_gather.py.exp
new file mode 100644
index 0000000000000..a37578d7eb3c8
--- /dev/null
+++ b/tests/extmod/uasyncio_gather.py.exp
@@ -0,0 +1,10 @@
+Task A: Compute factorial(2)...
+Task B: Compute factorial(2)...
+Task C: Compute factorial(2)...
+Task A: factorial(2) = 2
+Task B: Compute factorial(3)...
+Task C: Compute factorial(3)...
+Task B: factorial(3) = 6
+Task C: Compute factorial(4)...
+Task C: factorial(4) = 24
+[2, 6, 24]
diff --git a/tests/extmod/uasyncio_get_event_loop.py b/tests/extmod/uasyncio_get_event_loop.py
new file mode 100644
index 0000000000000..8ccbd6814e96c
--- /dev/null
+++ b/tests/extmod/uasyncio_get_event_loop.py
@@ -0,0 +1,20 @@
+# Test get_event_loop()
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def main():
+    print("start")
+    await asyncio.sleep(0.01)
+    print("end")
+
+
+loop = asyncio.get_event_loop()
+loop.run_until_complete(main())
diff --git a/tests/extmod/uasyncio_heaplock.py b/tests/extmod/uasyncio_heaplock.py
new file mode 100644
index 0000000000000..771d3f0d97ab7
--- /dev/null
+++ b/tests/extmod/uasyncio_heaplock.py
@@ -0,0 +1,46 @@
+# test that basic scheduling of tasks, and uasyncio.sleep_ms, does not use the heap
+
+import micropython
+
+# strict stackless builds can't call functions without allocating a frame on the heap
+try:
+    f = lambda: 0
+    micropython.heap_lock()
+    f()
+    micropython.heap_unlock()
+except RuntimeError:
+    print("SKIP")
+    raise SystemExit
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def task(id, n, t):
+    for i in range(n):
+        print(id, i)
+        await asyncio.sleep_ms(t)
+
+
+async def main():
+    t1 = asyncio.create_task(task(1, 4, 10))
+    t2 = asyncio.create_task(task(2, 4, 25))
+
+    micropython.heap_lock()
+
+    print("start")
+    await asyncio.sleep_ms(1)
+    print("sleep")
+    await asyncio.sleep_ms(100)
+    print("finish")
+
+    micropython.heap_unlock()
+
+
+asyncio.run(main())
diff --git a/tests/extmod/uasyncio_heaplock.py.exp b/tests/extmod/uasyncio_heaplock.py.exp
new file mode 100644
index 0000000000000..a967cc319712f
--- /dev/null
+++ b/tests/extmod/uasyncio_heaplock.py.exp
@@ -0,0 +1,11 @@
+start
+1 0
+2 0
+sleep
+1 1
+1 2
+2 1
+1 3
+2 2
+2 3
+finish
diff --git a/tests/extmod/uasyncio_lock.py b/tests/extmod/uasyncio_lock.py
new file mode 100644
index 0000000000000..096a8c82be148
--- /dev/null
+++ b/tests/extmod/uasyncio_lock.py
@@ -0,0 +1,97 @@
+# Test Lock class
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def task_loop(id, lock):
+    print("task start", id)
+    for i in range(3):
+        async with lock:
+            print("task have", id, i)
+    print("task end", id)
+
+
+async def task_sleep(lock):
+    async with lock:
+        print("task have", lock.locked())
+        await asyncio.sleep(0.2)
+    print("task release", lock.locked())
+    await lock.acquire()
+    print("task have again")
+    lock.release()
+
+
+async def task_cancel(id, lock, to_cancel=None):
+    try:
+        async with lock:
+            print("task got", id)
+            await asyncio.sleep(0.1)
+        print("task release", id)
+        if to_cancel:
+            to_cancel[0].cancel()
+    except asyncio.CancelledError:
+        print("task cancel", id)
+
+
+async def main():
+    lock = asyncio.Lock()
+
+    # Basic acquire/release
+    print(lock.locked())
+    await lock.acquire()
+    print(lock.locked())
+    await asyncio.sleep(0)
+    lock.release()
+    print(lock.locked())
+    await asyncio.sleep(0)
+
+    # Use with "async with"
+    async with lock:
+        print("have lock")
+
+    # 3 tasks wanting the lock
+    print("----")
+    asyncio.create_task(task_loop(1, lock))
+    asyncio.create_task(task_loop(2, lock))
+    t3 = asyncio.create_task(task_loop(3, lock))
+    await lock.acquire()
+    await asyncio.sleep(0)
+    lock.release()
+    await t3
+
+    # 2 sleeping tasks both wanting the lock
+    print("----")
+    asyncio.create_task(task_sleep(lock))
+    await asyncio.sleep(0.1)
+    await task_sleep(lock)
+
+    # 3 tasks, the first cancelling the second, the third should still run
+    print("----")
+    ts = [None]
+    asyncio.create_task(task_cancel(0, lock, ts))
+    ts[0] = asyncio.create_task(task_cancel(1, lock))
+    asyncio.create_task(task_cancel(2, lock))
+    await asyncio.sleep(0.3)
+    print(lock.locked())
+
+    # 3 tasks, the second and third being cancelled while waiting on the lock
+    print("----")
+    t0 = asyncio.create_task(task_cancel(0, lock))
+    t1 = asyncio.create_task(task_cancel(1, lock))
+    t2 = asyncio.create_task(task_cancel(2, lock))
+    await asyncio.sleep(0.05)
+    t1.cancel()
+    await asyncio.sleep(0.1)
+    t2.cancel()
+    await asyncio.sleep(0.1)
+    print(lock.locked())
+
+
+asyncio.run(main())
diff --git a/tests/extmod/uasyncio_lock.py.exp b/tests/extmod/uasyncio_lock.py.exp
new file mode 100644
index 0000000000000..a37dfcbd2e519
--- /dev/null
+++ b/tests/extmod/uasyncio_lock.py.exp
@@ -0,0 +1,41 @@
+False
+True
+False
+have lock
+----
+task start 1
+task start 2
+task start 3
+task have 1 0
+task have 2 0
+task have 3 0
+task have 1 1
+task have 2 1
+task have 3 1
+task have 1 2
+task end 1
+task have 2 2
+task end 2
+task have 3 2
+task end 3
+----
+task have True
+task release False
+task have True
+task release False
+task have again
+task have again
+----
+task got 0
+task release 0
+task cancel 1
+task got 2
+task release 2
+False
+----
+task got 0
+task cancel 1
+task release 0
+task got 2
+task cancel 2
+False
diff --git a/tests/extmod/uasyncio_lock_cancel.py b/tests/extmod/uasyncio_lock_cancel.py
new file mode 100644
index 0000000000000..85b8df8483065
--- /dev/null
+++ b/tests/extmod/uasyncio_lock_cancel.py
@@ -0,0 +1,55 @@
+# Test that locks work when cancelling multiple waiters on the lock
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def task(i, lock, lock_flag):
+    print("task", i, "start")
+    try:
+        await lock.acquire()
+    except asyncio.CancelledError:
+        print("task", i, "cancel")
+        return
+    print("task", i, "lock_flag", lock_flag[0])
+    lock_flag[0] = True
+    await asyncio.sleep(0)
+    lock.release()
+    lock_flag[0] = False
+    print("task", i, "done")
+
+
+async def main():
+    # Create a lock and acquire it so the tasks below must wait
+    lock = asyncio.Lock()
+    await lock.acquire()
+    lock_flag = [True]
+
+    # Create 4 tasks and let them all run
+    t0 = asyncio.create_task(task(0, lock, lock_flag))
+    t1 = asyncio.create_task(task(1, lock, lock_flag))
+    t2 = asyncio.create_task(task(2, lock, lock_flag))
+    t3 = asyncio.create_task(task(3, lock, lock_flag))
+    await asyncio.sleep(0)
+
+    # Cancel 2 of the tasks (which are waiting on the lock) and release the lock
+    t1.cancel()
+    t2.cancel()
+    lock.release()
+    lock_flag[0] = False
+
+    # Let the tasks run to completion
+    for _ in range(4):
+        await asyncio.sleep(0)
+
+    # The locke should be unlocked
+    print(lock.locked())
+
+
+asyncio.run(main())
diff --git a/tests/extmod/uasyncio_lock_cancel.py.exp b/tests/extmod/uasyncio_lock_cancel.py.exp
new file mode 100644
index 0000000000000..49ae253887436
--- /dev/null
+++ b/tests/extmod/uasyncio_lock_cancel.py.exp
@@ -0,0 +1,11 @@
+task 0 start
+task 1 start
+task 2 start
+task 3 start
+task 1 cancel
+task 2 cancel
+task 0 lock_flag False
+task 0 done
+task 3 lock_flag False
+task 3 done
+False
diff --git a/tests/extmod/uasyncio_loop_stop.py b/tests/extmod/uasyncio_loop_stop.py
new file mode 100644
index 0000000000000..23507f9a7efe2
--- /dev/null
+++ b/tests/extmod/uasyncio_loop_stop.py
@@ -0,0 +1,45 @@
+# Test Loop.stop() to stop the event loop
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def task():
+    print("task")
+
+
+async def main():
+    print("start")
+
+    # Stop the loop after next yield
+    loop.stop()
+
+    # Check that calling stop() again doesn't do/break anything
+    loop.stop()
+
+    # This await should stop
+    print("sleep")
+    await asyncio.sleep(0)
+
+    # Schedule stop, then create a new task, then yield
+    loop.stop()
+    asyncio.create_task(task())
+    await asyncio.sleep(0)
+
+    # Final stop
+    print("end")
+    loop.stop()
+
+
+loop = asyncio.get_event_loop()
+loop.create_task(main())
+
+for i in range(3):
+    print("run", i)
+    loop.run_forever()
diff --git a/tests/extmod/uasyncio_loop_stop.py.exp b/tests/extmod/uasyncio_loop_stop.py.exp
new file mode 100644
index 0000000000000..bada5f0d8412c
--- /dev/null
+++ b/tests/extmod/uasyncio_loop_stop.py.exp
@@ -0,0 +1,7 @@
+run 0
+start
+sleep
+run 1
+run 2
+task
+end
diff --git a/tests/extmod/uasyncio_new_event_loop.py b/tests/extmod/uasyncio_new_event_loop.py
new file mode 100644
index 0000000000000..b711befba9715
--- /dev/null
+++ b/tests/extmod/uasyncio_new_event_loop.py
@@ -0,0 +1,36 @@
+# Test Loop.new_event_loop()
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def task():
+    for i in range(4):
+        print("task", i)
+        await asyncio.sleep(0)
+        await asyncio.sleep(0)
+
+
+async def main():
+    print("start")
+    loop.create_task(task())
+    await asyncio.sleep(0)
+    print("stop")
+    loop.stop()
+
+
+# Use default event loop to run some tasks
+loop = asyncio.get_event_loop()
+loop.create_task(main())
+loop.run_forever()
+
+# Create new event loop, old one should not keep running
+loop = asyncio.new_event_loop()
+loop.create_task(main())
+loop.run_forever()
diff --git a/tests/extmod/uasyncio_new_event_loop.py.exp b/tests/extmod/uasyncio_new_event_loop.py.exp
new file mode 100644
index 0000000000000..9e104fda39c94
--- /dev/null
+++ b/tests/extmod/uasyncio_new_event_loop.py.exp
@@ -0,0 +1,6 @@
+start
+task 0
+stop
+start
+task 0
+stop
diff --git a/tests/extmod/uasyncio_set_exception_handler.py b/tests/extmod/uasyncio_set_exception_handler.py
new file mode 100644
index 0000000000000..ad62a79b7b7a8
--- /dev/null
+++ b/tests/extmod/uasyncio_set_exception_handler.py
@@ -0,0 +1,46 @@
+# Test that tasks return their value correctly to the caller
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+def custom_handler(loop, context):
+    print("custom_handler", repr(context["exception"]))
+
+
+async def task(i):
+    # Raise with 2 args so exception prints the same in uPy and CPython
+    raise ValueError(i, i + 1)
+
+
+async def main():
+    loop = asyncio.get_event_loop()
+
+    # Check default exception handler, should be None
+    print(loop.get_exception_handler())
+
+    # Set exception handler and test it was set
+    loop.set_exception_handler(custom_handler)
+    print(loop.get_exception_handler() == custom_handler)
+
+    # Create a task that raises and uses the custom exception handler
+    asyncio.create_task(task(0))
+    print("sleep")
+    await asyncio.sleep(0)
+
+    # Create 2 tasks to test order of printing exception
+    asyncio.create_task(task(1))
+    asyncio.create_task(task(2))
+    print("sleep")
+    await asyncio.sleep(0)
+
+    print("done")
+
+
+asyncio.run(main())
diff --git a/tests/extmod/uasyncio_set_exception_handler.py.exp b/tests/extmod/uasyncio_set_exception_handler.py.exp
new file mode 100644
index 0000000000000..4744641e54c3c
--- /dev/null
+++ b/tests/extmod/uasyncio_set_exception_handler.py.exp
@@ -0,0 +1,8 @@
+None
+True
+sleep
+custom_handler ValueError(0, 1)
+sleep
+custom_handler ValueError(1, 2)
+custom_handler ValueError(2, 3)
+done
diff --git a/tests/extmod/uasyncio_wait_for.py b/tests/extmod/uasyncio_wait_for.py
new file mode 100644
index 0000000000000..92fd174b846db
--- /dev/null
+++ b/tests/extmod/uasyncio_wait_for.py
@@ -0,0 +1,62 @@
+# Test asyncio.wait_for
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def task(id, t):
+    print("task start", id)
+    await asyncio.sleep(t)
+    print("task end", id)
+    return id * 2
+
+
+async def task_catch():
+    print("task_catch start")
+    try:
+        await asyncio.sleep(0.2)
+    except asyncio.CancelledError:
+        print("ignore cancel")
+    print("task_catch done")
+
+
+async def task_raise():
+    print("task start")
+    raise ValueError
+
+
+async def main():
+    # When task finished before the timeout
+    print(await asyncio.wait_for(task(1, 0.01), 10))
+
+    # When timeout passes and task is cancelled
+    try:
+        print(await asyncio.wait_for(task(2, 10), 0.01))
+    except asyncio.TimeoutError:
+        print("timeout")
+
+    # When timeout passes and task is cancelled, but task ignores the cancellation request
+    try:
+        print(await asyncio.wait_for(task_catch(), 0.1))
+    except asyncio.TimeoutError:
+        print("TimeoutError")
+
+    # When task raises an exception
+    try:
+        print(await asyncio.wait_for(task_raise(), 1))
+    except ValueError:
+        print("ValueError")
+
+    # Timeout of None means wait forever
+    print(await asyncio.wait_for(task(3, 0.1), None))
+
+    print("finish")
+
+
+asyncio.run(main())
diff --git a/tests/extmod/uasyncio_wait_for.py.exp b/tests/extmod/uasyncio_wait_for.py.exp
new file mode 100644
index 0000000000000..41a5f2481e908
--- /dev/null
+++ b/tests/extmod/uasyncio_wait_for.py.exp
@@ -0,0 +1,15 @@
+task start 1
+task end 1
+2
+task start 2
+timeout
+task_catch start
+ignore cancel
+task_catch done
+TimeoutError
+task start
+ValueError
+task start 3
+task end 3
+6
+finish
diff --git a/tests/extmod/uasyncio_wait_task.py b/tests/extmod/uasyncio_wait_task.py
new file mode 100644
index 0000000000000..3c79320c9f5c4
--- /dev/null
+++ b/tests/extmod/uasyncio_wait_task.py
@@ -0,0 +1,77 @@
+# Test waiting on a task
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+try:
+    import utime
+
+    ticks = utime.ticks_ms
+    ticks_diff = utime.ticks_diff
+except:
+    import time
+
+    ticks = lambda: int(time.time() * 1000)
+    ticks_diff = lambda t1, t0: t1 - t0
+
+
+async def task(t):
+    print("task", t)
+
+
+async def delay_print(t, s):
+    await asyncio.sleep(t)
+    print(s)
+
+
+async def task_raise():
+    print("task_raise")
+    raise ValueError
+
+
+async def main():
+    print("start")
+
+    # Wait on a task
+    t = asyncio.create_task(task(1))
+    await t
+
+    # Wait on a task that's already done
+    t = asyncio.create_task(task(2))
+    await asyncio.sleep(0.001)
+    await t
+
+    # Wait again on same task
+    await t
+
+    print("----")
+
+    # Create 2 tasks
+    ts1 = asyncio.create_task(delay_print(0.04, "hello"))
+    ts2 = asyncio.create_task(delay_print(0.08, "world"))
+
+    # Time how long the tasks take to finish, they should execute in parallel
+    print("start")
+    t0 = ticks()
+    await ts1
+    t1 = ticks()
+    await ts2
+    t2 = ticks()
+    print("took {} {}".format(round(ticks_diff(t1, t0), -1), round(ticks_diff(t2, t1), -1)))
+
+    # Wait on a task that raises an exception
+    t = asyncio.create_task(task_raise())
+    try:
+        await t
+    except ValueError:
+        print("ValueError")
+
+
+asyncio.run(main())
diff --git a/tests/extmod/uasyncio_wait_task.py.exp b/tests/extmod/uasyncio_wait_task.py.exp
new file mode 100644
index 0000000000000..ee4e70fb4eb1e
--- /dev/null
+++ b/tests/extmod/uasyncio_wait_task.py.exp
@@ -0,0 +1,10 @@
+start
+task 1
+task 2
+----
+start
+hello
+world
+took 40 40
+task_raise
+ValueError
diff --git a/tests/extmod/ubinascii_a2b_base64.py b/tests/extmod/ubinascii_a2b_base64.py
index 05a3169f3a815..2630965e6a06a 100644
--- a/tests/extmod/ubinascii_a2b_base64.py
+++ b/tests/extmod/ubinascii_a2b_base64.py
@@ -7,40 +7,40 @@
     print("SKIP")
     raise SystemExit
 
-print(binascii.a2b_base64(b''))
-print(binascii.a2b_base64(b'Zg=='))
-print(binascii.a2b_base64(b'Zm8='))
-print(binascii.a2b_base64(b'Zm9v'))
-print(binascii.a2b_base64(b'Zm9vYg=='))
-print(binascii.a2b_base64(b'Zm9vYmE='))
-print(binascii.a2b_base64(b'Zm9vYmFy'))
+print(binascii.a2b_base64(b""))
+print(binascii.a2b_base64(b"Zg=="))
+print(binascii.a2b_base64(b"Zm8="))
+print(binascii.a2b_base64(b"Zm9v"))
+print(binascii.a2b_base64(b"Zm9vYg=="))
+print(binascii.a2b_base64(b"Zm9vYmE="))
+print(binascii.a2b_base64(b"Zm9vYmFy"))
 
-print(binascii.a2b_base64(b'AAECAwQFBgc='))
-print(binascii.a2b_base64(b'CAkKCwwNDg8='))
-print(binascii.a2b_base64(b'f4D/'))
-print(binascii.a2b_base64(b'f4D+')) # convert '+'
-print(binascii.a2b_base64(b'MTIzNEFCQ0RhYmNk'))
+print(binascii.a2b_base64(b"AAECAwQFBgc="))
+print(binascii.a2b_base64(b"CAkKCwwNDg8="))
+print(binascii.a2b_base64(b"f4D/"))
+print(binascii.a2b_base64(b"f4D+"))  # convert '+'
+print(binascii.a2b_base64(b"MTIzNEFCQ0RhYmNk"))
 
 # Ignore invalid characters and pad sequences
-print(binascii.a2b_base64(b'Zm9v\n'))
-print(binascii.a2b_base64(b'Zm\x009v\n'))
-print(binascii.a2b_base64(b'Zm9v=='))
-print(binascii.a2b_base64(b'Zm9v==='))
-print(binascii.a2b_base64(b'Zm9v===YmFy'))
+print(binascii.a2b_base64(b"Zm9v\n"))
+print(binascii.a2b_base64(b"Zm\x009v\n"))
+print(binascii.a2b_base64(b"Zm9v=="))
+print(binascii.a2b_base64(b"Zm9v==="))
+print(binascii.a2b_base64(b"Zm9v===YmFy"))
 
 try:
-    print(binascii.a2b_base64(b'abc'))
+    print(binascii.a2b_base64(b"abc"))
 except ValueError:
     print("ValueError")
 try:
-    print(binascii.a2b_base64(b'abcde='))
+    print(binascii.a2b_base64(b"abcde="))
 except ValueError:
     print("ValueError")
 try:
-    print(binascii.a2b_base64(b'ab*d'))
+    print(binascii.a2b_base64(b"ab*d"))
 except ValueError:
     print("ValueError")
 try:
-    print(binascii.a2b_base64(b'ab=cdef='))
+    print(binascii.a2b_base64(b"ab=cdef="))
 except ValueError:
     print("ValueError")
diff --git a/tests/extmod/ubinascii_b2a_base64.py b/tests/extmod/ubinascii_b2a_base64.py
index f4bb69fe0c92a..9c100f972b4b2 100644
--- a/tests/extmod/ubinascii_b2a_base64.py
+++ b/tests/extmod/ubinascii_b2a_base64.py
@@ -7,16 +7,16 @@
     print("SKIP")
     raise SystemExit
 
-print(binascii.b2a_base64(b''))
-print(binascii.b2a_base64(b'f'))
-print(binascii.b2a_base64(b'fo'))
-print(binascii.b2a_base64(b'foo'))
-print(binascii.b2a_base64(b'foob'))
-print(binascii.b2a_base64(b'fooba'))
-print(binascii.b2a_base64(b'foobar'))
+print(binascii.b2a_base64(b""))
+print(binascii.b2a_base64(b"f"))
+print(binascii.b2a_base64(b"fo"))
+print(binascii.b2a_base64(b"foo"))
+print(binascii.b2a_base64(b"foob"))
+print(binascii.b2a_base64(b"fooba"))
+print(binascii.b2a_base64(b"foobar"))
 
-print(binascii.b2a_base64(b'\x00\x01\x02\x03\x04\x05\x06\x07'))
-print(binascii.b2a_base64(b'\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f'))
-print(binascii.b2a_base64(b'\x7f\x80\xff'))
-print(binascii.b2a_base64(b'1234ABCDabcd'))
-print(binascii.b2a_base64(b'\x00\x00>')) # convert into '+'
+print(binascii.b2a_base64(b"\x00\x01\x02\x03\x04\x05\x06\x07"))
+print(binascii.b2a_base64(b"\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"))
+print(binascii.b2a_base64(b"\x7f\x80\xff"))
+print(binascii.b2a_base64(b"1234ABCDabcd"))
+print(binascii.b2a_base64(b"\x00\x00>"))  # convert into '+'
diff --git a/tests/extmod/ubinascii_crc32.py b/tests/extmod/ubinascii_crc32.py
index 89664a9b36517..8f5f4d9ba5e53 100644
--- a/tests/extmod/ubinascii_crc32.py
+++ b/tests/extmod/ubinascii_crc32.py
@@ -13,12 +13,12 @@
     print("SKIP")
     raise SystemExit
 
-print(hex(binascii.crc32(b'The quick brown fox jumps over the lazy dog')))
-print(hex(binascii.crc32(b'\x00' * 32)))
-print(hex(binascii.crc32(b'\xff' * 32)))
+print(hex(binascii.crc32(b"The quick brown fox jumps over the lazy dog")))
+print(hex(binascii.crc32(b"\x00" * 32)))
+print(hex(binascii.crc32(b"\xff" * 32)))
 print(hex(binascii.crc32(bytes(range(32)))))
 
-print(hex(binascii.crc32(b' over the lazy dog', binascii.crc32(b'The quick brown fox jumps'))))
-print(hex(binascii.crc32(b'\x00' * 16, binascii.crc32(b'\x00' * 16))))
-print(hex(binascii.crc32(b'\xff' * 16, binascii.crc32(b'\xff' * 16))))
+print(hex(binascii.crc32(b" over the lazy dog", binascii.crc32(b"The quick brown fox jumps"))))
+print(hex(binascii.crc32(b"\x00" * 16, binascii.crc32(b"\x00" * 16))))
+print(hex(binascii.crc32(b"\xff" * 16, binascii.crc32(b"\xff" * 16))))
 print(hex(binascii.crc32(bytes(range(16, 32)), binascii.crc32(bytes(range(16))))))
diff --git a/tests/extmod/ubinascii_hexlify.py b/tests/extmod/ubinascii_hexlify.py
index bc99287476fb9..2329f53edd947 100644
--- a/tests/extmod/ubinascii_hexlify.py
+++ b/tests/extmod/ubinascii_hexlify.py
@@ -7,7 +7,7 @@
     print("SKIP")
     raise SystemExit
 
-print(binascii.hexlify(b'\x00\x01\x02\x03\x04\x05\x06\x07'))
-print(binascii.hexlify(b'\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f'))
-print(binascii.hexlify(b'\x7f\x80\xff'))
-print(binascii.hexlify(b'1234ABCDabcd'))
+print(binascii.hexlify(b"\x00\x01\x02\x03\x04\x05\x06\x07"))
+print(binascii.hexlify(b"\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"))
+print(binascii.hexlify(b"\x7f\x80\xff"))
+print(binascii.hexlify(b"1234ABCDabcd"))
diff --git a/tests/extmod/ubinascii_micropython.py b/tests/extmod/ubinascii_micropython.py
index 77084ec9ee25f..94e8daa557b77 100644
--- a/tests/extmod/ubinascii_micropython.py
+++ b/tests/extmod/ubinascii_micropython.py
@@ -8,8 +8,8 @@
     raise SystemExit
 
 # two arguments supported in uPy but not CPython
-a = binascii.hexlify(b'123', ':')
+a = binascii.hexlify(b"123", ":")
 print(a)
 
 # zero length buffer
-print(binascii.hexlify(b'', b':'))
+print(binascii.hexlify(b"", b":"))
diff --git a/tests/extmod/ubinascii_unhexlify.py b/tests/extmod/ubinascii_unhexlify.py
index 865abfe3a822e..413eaf1b6fd63 100644
--- a/tests/extmod/ubinascii_unhexlify.py
+++ b/tests/extmod/ubinascii_unhexlify.py
@@ -7,17 +7,17 @@
     print("SKIP")
     raise SystemExit
 
-print(binascii.unhexlify(b'0001020304050607'))
-print(binascii.unhexlify(b'08090a0b0c0d0e0f'))
-print(binascii.unhexlify(b'7f80ff'))
-print(binascii.unhexlify(b'313233344142434461626364'))
+print(binascii.unhexlify(b"0001020304050607"))
+print(binascii.unhexlify(b"08090a0b0c0d0e0f"))
+print(binascii.unhexlify(b"7f80ff"))
+print(binascii.unhexlify(b"313233344142434461626364"))
 
 try:
-    a = binascii.unhexlify(b'0') # odd buffer length
+    a = binascii.unhexlify(b"0")  # odd buffer length
 except ValueError:
-    print('ValueError')
+    print("ValueError")
 
 try:
-    a = binascii.unhexlify(b'gg') # digit not hex
+    a = binascii.unhexlify(b"gg")  # digit not hex
 except ValueError:
-    print('ValueError')
+    print("ValueError")
diff --git a/tests/extmod/ucryptolib_aes128_cbc.py b/tests/extmod/ucryptolib_aes128_cbc.py
index 4c5ea6acb2df8..d861d2c6bf47c 100644
--- a/tests/extmod/ucryptolib_aes128_cbc.py
+++ b/tests/extmod/ucryptolib_aes128_cbc.py
@@ -1,5 +1,6 @@
 try:
     from Crypto.Cipher import AES
+
     aes = AES.new
 except ImportError:
     try:
diff --git a/tests/extmod/ucryptolib_aes128_ctr.py b/tests/extmod/ucryptolib_aes128_ctr.py
new file mode 100644
index 0000000000000..538d9606e9ed9
--- /dev/null
+++ b/tests/extmod/ucryptolib_aes128_ctr.py
@@ -0,0 +1,28 @@
+try:
+    from ucryptolib import aes
+except ImportError:
+    print("SKIP")
+    raise SystemExit
+
+
+def _new(k, ctr_initial):
+    return aes(k, 6, ctr_initial)
+
+
+try:
+    _new(b"x" * 16, b"x" * 16)
+except ValueError as e:
+    # is CTR support disabled?
+    if e.args[0] == "mode":
+        print("SKIP")
+        raise SystemExit
+    raise e
+
+crypto = _new(b"1234" * 4, b"5678" * 4)
+enc = crypto.encrypt(b"a")
+print(enc)
+enc += crypto.encrypt(b"b" * 1000)
+print(enc)
+
+crypto = _new(b"1234" * 4, b"5678" * 4)
+print(crypto.decrypt(enc))
diff --git a/tests/extmod/ucryptolib_aes128_ctr.py.exp b/tests/extmod/ucryptolib_aes128_ctr.py.exp
new file mode 100644
index 0000000000000..92e090fd39700
--- /dev/null
+++ b/tests/extmod/ucryptolib_aes128_ctr.py.exp
@@ -0,0 +1,3 @@
+b'\x06'
+b'\x06(F\x08\xc3hB\xfdO\x05;\xf6\x96\xfe\xad\xe0\xca\xe6\xd1\xa2m\t\x91v>|\xee\xe0q\xbc]\x9a`\xfal\x87\xa6e\xfb\x8a\xf4\xb2-\xc4x,\xfc@=,\x90\xf4\xe9h\xf0\xfc\xfb\xe6\x03\xf0d\xb6\xcdObZ\xde\x1b\xe2\x84-%=\xa9\xe4\x05\xab\xd7\x044\xf4$\xd0)\xfd\xd6\xdbL\xdd\xe6\x0cp\xca^p\xaaA\x8b\xb3!\xe3\x13\xfa\x7f#\xfa0\xbd\x0b\x9cX\xec\xed\x1c\xbc\x06\xa4\xa8\x17\xbfg\x98dW\xb9~\x04\xec\xe6lZ\xb0\xab\xd5\xc6v\xe4\x8f\x98G\xff\x9b\x8a\xae\xfd\xe5\xed\x96\x1b\xe2\x99u3\xeb\x9faYr;\xf0g\xf2\x9cq\x8dI\x1cL\xc9\xa8\xb0\xdeD\xd5\x06\x87u=\xcd\x10\x1c\xab\x14\x06n\x99\x13\x89\x9f5\xea\xd2\x08\x9e\xef$?\xb9\xdeQ\x0b\x90CH\xea@V\x94\x1a\xdd\x7f\x1dz\x82\xaay\xea$Lv\x07\x8e\xce\xb8oN\x15\xf8,\x05\x00\xd9H\xf4\xbe\xb8\xee\x0e\xd6Hjh\xc6\x11\xf8:\xfe\xed\xba_\xaf\x8e\'\x0c\x7fZ\xd5\xb7\xbc\xba\xd3+\xf1\x98i\xab\x0c-\xd9\xe6>\x9e\xd0\xe6>\x9f\xebn\xf0\x15\xd9:\xec\xf7aXa\xb2,CAB7\x18g\xcc#\xbc\xb8\xf9\xa7\xf4V\xba\x0baN\x88\xb1\xea\x94\x05\x0cV\x99_\xc4\xe6\xb2\xd1|\x92\x05*@U\xe4\\\x8dR\x98\xdf\xbfS\x97\x12^\tr\x1f\x12\x8f\xdfi\x8e=\xc4I\xfcB\r\x99f\xe3\xe31\xee\xa9\xcd\x91\x1a\x1ei\xfd\xf4\x84\xc6\xda\x9e\xf3\x8aKn\xaa\xf7\x9eS\xcc\xbaXZ\x0cpbk\x18\x1f\x9aAl>y\xad\xcb\xcf\xe1Wm\xe7\xdd\xcc\x10eW\xe4h\x1dY\xb5Zs\xf1\xe7\x16_\xdc:I1R\xd3\xfe\xb1)\t\xddE\xbax\x06R\xdc\x1dSdlu\xd1\x9c\x00\xaf\x87\x8d1\xbf$\x08\xc6/y\xdf\x1f\x97z(\xff\xb9\xcb\xf2,\x91\xd7\xa0W\xfc\xe3\xe2\x905\x17O\xaf\x18\xc7\xb8?\x94^\xf5@\x80\x8d\xaa*p\xbeR0i\x17\x1e\'-\xfa\xd9\xb2\x03\xb8\x1fY\x13\xc1{\x7f\xa9\x86\t\x99\xee\xa2\xba\xab\xc1\xbb\x07a\xa5J\x01\x98\xe8\x8e\xa1\x8aV\xc1)^A\xd9\xe7\xfej`\xb4\xe9\xd3C\xab\xd4\xdb\xb1\x8c\x83\xaa&\xf1\xe2\xfc\xa1Lb\xa8\xbb\xd6\x83\xb7\xd8\xc5\x9e\xb5\xed\x1b\xe6\x91\x90\xe4\xfa\xfdD\xc2\xcb\xb7U\xb3|?(\x86=\xc2\xff\xd3P\xd2\xc5y\x93\x13r\xcd>5\x80\xde\xdaJ\xdd\x8b\xfa\x14\xd1\x85\xa8P\x06(F\xb3?\xefm\x8e\xe5C\xfe\x98\xaf\xed\xd1!(\x1f.\xc6M\xba\x00\xcb\xbfg5\xc8\x9d\x97+\x14\x87\xf5\x9d4\xb4l\xd5\xc5>\x90\xf2\x06\xa2\xc1R\x89\xf0P\xb4\xe5\x97\xdb\x07\xd3\xc6q\x08\xb9\xe7\r\xf9\x13\x8215\xcb\x92\xed\x99\xc7"\x1e\xe3Zsh\x0e\xe7\xae\x10Xs&)\x1d\xe5\xd5\xbc\x95\x8e\xa3\xd6k[k\x9c\xa0%\xd4\x83%\x88}\x90\xf0\xa7\xc7\xa4(\xdaE\xb9~\xae\x05\xbd}\xe2\xd0\xa5Y\xc1aV[\xab\x93S\xa6\xacg\r\x14\xc6\xe2J\xd6\xcck"\xcc\xfb\xb3\x97\x14\x13\x0b\xd1\xf5\xe7)_\x1e\x0b\xbb\x01\xf7\x11u\x85b\xdf\xab\xe3\xbb:\x84zF\x14u\xfe\x89\x90\xbc\xcaF\x15y\xa3\xa4[\xce\xcf-\xae\x18\x97N\xaa\xed\x84A\xfc\x9e\xeb\xb3\xfcH\x8ej\xcc\x9f \x1b\xc1\x1f}\'q.\xc0^\xd99\x1e\x91b-\xf9\xed\xfd\x9a\x7f\xb6\rO\xea\xc8\x94\xea\xf6\xb4\xdb\xf5\xc7\xb3\xef\xf6D\x12>5\xf3\x9d*\xc9\xf8\x9f]\xb01{d\xe7\'\x8f\xc0\xfbKB\x8dd\xb1\x84\x804\xbe\xe2?AT\x14\xdb4eJ\x96\xc5\xb9%\xe5\x1c\xc0L\xae\xd6O\xde\x1fjJIRD\x96\xa2\xdb\xfc\xc6t\xce\xe6\xe8"\x81\xe6\xc7\x7fuz\xb3\x91\'D\xac\xb2\x93O\xee\x14\xaa7yT\xcf\x81p\x0b(\xa1d\xda\xf8\xcb\x01\x98\x07\'\xfe/\xe4\xca\xab\x03uR"zY\xfb\x1f\x02\xc5\x9c\xa0\'\x89\xffO\x88cK\xac\xb1+S0]%E\x1a\xeb\x04\xf7\x0b\xba\xa0\xbb\xbd|\x06@T\xee\xe7\x17\xa1T\xe3"\x07\x07q'
+b'abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
diff --git a/tests/extmod/ucryptolib_aes128_ecb.py b/tests/extmod/ucryptolib_aes128_ecb.py
index 89451b282ca14..5c0e179986822 100644
--- a/tests/extmod/ucryptolib_aes128_ecb.py
+++ b/tests/extmod/ucryptolib_aes128_ecb.py
@@ -1,5 +1,6 @@
 try:
     from Crypto.Cipher import AES
+
     aes = AES.new
 except ImportError:
     try:
diff --git a/tests/extmod/ucryptolib_aes128_ecb_enc.py b/tests/extmod/ucryptolib_aes128_ecb_enc.py
index 55b676d361a19..1d4484b0bc11e 100644
--- a/tests/extmod/ucryptolib_aes128_ecb_enc.py
+++ b/tests/extmod/ucryptolib_aes128_ecb_enc.py
@@ -3,6 +3,7 @@
 # is optional).
 try:
     from Crypto.Cipher import AES
+
     aes = AES.new
 except ImportError:
     try:
diff --git a/tests/extmod/ucryptolib_aes256_cbc.py b/tests/extmod/ucryptolib_aes256_cbc.py
index a907f26e2695f..c01846f199dec 100644
--- a/tests/extmod/ucryptolib_aes256_cbc.py
+++ b/tests/extmod/ucryptolib_aes256_cbc.py
@@ -1,5 +1,6 @@
 try:
     from Crypto.Cipher import AES
+
     aes = AES.new
 except ImportError:
     try:
diff --git a/tests/extmod/ucryptolib_aes256_ecb.py b/tests/extmod/ucryptolib_aes256_ecb.py
index 326383a454825..0760063c14c48 100644
--- a/tests/extmod/ucryptolib_aes256_ecb.py
+++ b/tests/extmod/ucryptolib_aes256_ecb.py
@@ -1,5 +1,6 @@
 try:
     from Crypto.Cipher import AES
+
     aes = AES.new
 except ImportError:
     try:
diff --git a/tests/extmod/uctypes_32bit_intbig.py b/tests/extmod/uctypes_32bit_intbig.py
index 6b4d3d76cda6b..eed36e87742af 100644
--- a/tests/extmod/uctypes_32bit_intbig.py
+++ b/tests/extmod/uctypes_32bit_intbig.py
@@ -10,16 +10,16 @@
 struct = uctypes.struct(
     uctypes.addressof(buf),
     {"f32": uctypes.UINT32 | 0, "f64": uctypes.UINT64 | 4},
-    uctypes.LITTLE_ENDIAN
+    uctypes.LITTLE_ENDIAN,
 )
 
-struct.f32 = 0x7fffffff
+struct.f32 = 0x7FFFFFFF
 print(buf)
 
 struct.f32 = 0x80000000
 print(buf)
 
-struct.f32 = 0xff010203
+struct.f32 = 0xFF010203
 print(buf)
 
 struct.f64 = 0x80000000
@@ -34,16 +34,16 @@
 struct = uctypes.struct(
     uctypes.addressof(buf),
     {"f32": uctypes.UINT32 | 0, "f64": uctypes.UINT64 | 4},
-    uctypes.BIG_ENDIAN
+    uctypes.BIG_ENDIAN,
 )
 
-struct.f32 = 0x7fffffff
+struct.f32 = 0x7FFFFFFF
 print(buf)
 
 struct.f32 = 0x80000000
 print(buf)
 
-struct.f32 = 0xff010203
+struct.f32 = 0xFF010203
 print(buf)
 
 struct.f64 = 0x80000000
diff --git a/tests/extmod/uctypes_array_assign_le.py b/tests/extmod/uctypes_array_assign_le.py
index 6afa7e0a24dd2..d822faf7e8a96 100644
--- a/tests/extmod/uctypes_array_assign_le.py
+++ b/tests/extmod/uctypes_array_assign_le.py
@@ -10,19 +10,17 @@
     # arr2 is array at offset 0, size 2, of structures defined recursively
     "arr2": (uctypes.ARRAY | 0, 2, {"b": uctypes.UINT8 | 0}),
     "arr3": (uctypes.ARRAY | 2, uctypes.UINT16 | 2),
-
     # aligned
     "arr5": (uctypes.ARRAY | 0, uctypes.UINT32 | 1),
     # unaligned
     "arr6": (uctypes.ARRAY | 1, uctypes.UINT32 | 1),
-
     "arr7": (uctypes.ARRAY | 0, 1, {"l": uctypes.UINT32 | 0}),
-    "arr8": (uctypes.ARRAY | 1, 1, {"l": uctypes.UINT32 | 0})
+    "arr8": (uctypes.ARRAY | 1, 1, {"l": uctypes.UINT32 | 0}),
 }
 
 data = bytearray(5)
 
-S = uctypes.struct(uctypes.addressof(data), desc,  uctypes.LITTLE_ENDIAN)
+S = uctypes.struct(uctypes.addressof(data), desc, uctypes.LITTLE_ENDIAN)
 
 # assign byte
 S.arr[0] = 0x11
@@ -55,4 +53,3 @@
 
 print(S.arr6[0] == S.arr8[0].l)
 assert S.arr6[0] == S.arr8[0].l
-
diff --git a/tests/extmod/uctypes_array_assign_native_le.py b/tests/extmod/uctypes_array_assign_native_le.py
index a538bf9add72d..d4c27fc4b3f5a 100644
--- a/tests/extmod/uctypes_array_assign_native_le.py
+++ b/tests/extmod/uctypes_array_assign_native_le.py
@@ -1,4 +1,5 @@
 import sys
+
 try:
     import uctypes
 except ImportError:
@@ -15,16 +16,14 @@
     # arr2 is array at offset 0, size 2, of structures defined recursively
     "arr2": (uctypes.ARRAY | 0, 2, {"b": uctypes.UINT8 | 0}),
     "arr3": (uctypes.ARRAY | 2, uctypes.UINT16 | 2),
-
     # aligned
     "arr5": (uctypes.ARRAY | 0, uctypes.UINT32 | 1),
     "arr7": (uctypes.ARRAY | 0, 1, {"l": uctypes.UINT32 | 0}),
-
     "arr8": (uctypes.ARRAY | 0, uctypes.INT8 | 1),
     "arr9": (uctypes.ARRAY | 0, uctypes.INT16 | 1),
     "arr10": (uctypes.ARRAY | 0, uctypes.INT32 | 1),
     "arr11": (uctypes.ARRAY | 0, uctypes.INT64 | 1),
-    "arr12": (uctypes.ARRAY | 0, uctypes.UINT64| 1),
+    "arr12": (uctypes.ARRAY | 0, uctypes.UINT64 | 1),
     "arr13": (uctypes.ARRAY | 1, 1, {"l": {}}),
 }
 
diff --git a/tests/extmod/uctypes_array_assign_native_le_intbig.py b/tests/extmod/uctypes_array_assign_native_le_intbig.py
index 84dfba0e29134..f33c63b4ef959 100644
--- a/tests/extmod/uctypes_array_assign_native_le_intbig.py
+++ b/tests/extmod/uctypes_array_assign_native_le_intbig.py
@@ -1,4 +1,5 @@
 import sys
+
 try:
     import uctypes
 except ImportError:
@@ -15,16 +16,14 @@
     # arr2 is array at offset 0, size 2, of structures defined recursively
     "arr2": (uctypes.ARRAY | 0, 2, {"b": uctypes.UINT8 | 0}),
     "arr3": (uctypes.ARRAY | 2, uctypes.UINT16 | 2),
-
     # aligned
     "arr5": (uctypes.ARRAY | 0, uctypes.UINT32 | 1),
     "arr7": (uctypes.ARRAY | 0, 1, {"l": uctypes.UINT32 | 0}),
-
     "arr8": (uctypes.ARRAY | 0, uctypes.INT8 | 1),
     "arr9": (uctypes.ARRAY | 0, uctypes.INT16 | 1),
     "arr10": (uctypes.ARRAY | 0, uctypes.INT32 | 1),
     "arr11": (uctypes.ARRAY | 0, uctypes.INT64 | 1),
-    "arr12": (uctypes.ARRAY | 0, uctypes.UINT64| 1),
+    "arr12": (uctypes.ARRAY | 0, uctypes.UINT64 | 1),
     "arr13": (uctypes.ARRAY | 1, 1, {"l": {}}),
 }
 
diff --git a/tests/extmod/uctypes_byteat.py b/tests/extmod/uctypes_byteat.py
index ab2535db8fe29..0619d31dc9e89 100644
--- a/tests/extmod/uctypes_byteat.py
+++ b/tests/extmod/uctypes_byteat.py
@@ -4,7 +4,7 @@
     print("SKIP")
     raise SystemExit
 
-data = bytearray(b'01234567')
+data = bytearray(b"01234567")
 
-print(uctypes.bytes_at(uctypes.addressof(data), 4)) 
-print(uctypes.bytearray_at(uctypes.addressof(data), 4)) 
+print(uctypes.bytes_at(uctypes.addressof(data), 4))
+print(uctypes.bytearray_at(uctypes.addressof(data), 4))
diff --git a/tests/extmod/uctypes_error.py b/tests/extmod/uctypes_error.py
index 68106ac78245e..d42956261589f 100644
--- a/tests/extmod/uctypes_error.py
+++ b/tests/extmod/uctypes_error.py
@@ -9,35 +9,35 @@
 data = bytearray(b"01234567")
 
 # del subscr not supported
-S = uctypes.struct(uctypes.addressof(data), {}) 
+S = uctypes.struct(uctypes.addressof(data), {})
 try:
     del S[0]
 except TypeError:
-    print('TypeError')
+    print("TypeError")
 
 # list is an invalid descriptor
-S = uctypes.struct(uctypes.addressof(data), []) 
+S = uctypes.struct(uctypes.addressof(data), [])
 try:
-    S.x 
+    S.x
 except TypeError:
-    print('TypeError')
+    print("TypeError")
 
 # can't access attribute with invalid descriptor
-S = uctypes.struct(uctypes.addressof(data), {'x':[]})
+S = uctypes.struct(uctypes.addressof(data), {"x": []})
 try:
-    S.x 
+    S.x
 except TypeError:
-    print('TypeError')
+    print("TypeError")
 
 # can't assign to aggregate
-S = uctypes.struct(uctypes.addressof(data), {'x':(uctypes.ARRAY | 0, uctypes.INT8 | 2)})
+S = uctypes.struct(uctypes.addressof(data), {"x": (uctypes.ARRAY | 0, uctypes.INT8 | 2)})
 try:
-    S.x = 1 
+    S.x = 1
 except TypeError:
-    print('TypeError')
+    print("TypeError")
 
 # unsupported unary op
 try:
     hash(S)
 except TypeError:
-    print('TypeError')
+    print("TypeError")
diff --git a/tests/extmod/uctypes_le.py b/tests/extmod/uctypes_le.py
index 7df5ac0909b3a..23f2af982a1a9 100644
--- a/tests/extmod/uctypes_le.py
+++ b/tests/extmod/uctypes_le.py
@@ -6,20 +6,15 @@
 
 desc = {
     "s0": uctypes.UINT16 | 0,
-    "sub": (0, {
-        "b0": uctypes.UINT8 | 0,
-        "b1": uctypes.UINT8 | 1,
-    }),
+    "sub": (0, {"b0": uctypes.UINT8 | 0, "b1": uctypes.UINT8 | 1,}),
     "arr": (uctypes.ARRAY | 0, uctypes.UINT8 | 2),
     "arr2": (uctypes.ARRAY | 0, 2, {"b": uctypes.UINT8 | 0}),
     "bitf0": uctypes.BFUINT16 | 0 | 0 << uctypes.BF_POS | 8 << uctypes.BF_LEN,
     "bitf1": uctypes.BFUINT16 | 0 | 8 << uctypes.BF_POS | 8 << uctypes.BF_LEN,
-
-    "bf0": uctypes.BFUINT16 | 0 |  0 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
-    "bf1": uctypes.BFUINT16 | 0 |  4 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
-    "bf2": uctypes.BFUINT16 | 0 |  8 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
+    "bf0": uctypes.BFUINT16 | 0 | 0 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
+    "bf1": uctypes.BFUINT16 | 0 | 4 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
+    "bf2": uctypes.BFUINT16 | 0 | 8 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
     "bf3": uctypes.BFUINT16 | 0 | 12 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
-
     "ptr": (uctypes.PTR | 0, uctypes.UINT8),
     "ptr2": (uctypes.PTR | 0, {"b": uctypes.UINT8 | 0}),
 }
@@ -28,10 +23,10 @@
 
 S = uctypes.struct(uctypes.addressof(data), desc, uctypes.LITTLE_ENDIAN)
 
-#print(S)
+# print(S)
 print(hex(S.s0))
 assert hex(S.s0) == "0x3130"
-#print(S.sub.b0)
+# print(S.sub.b0)
 print(S.sub.b0, S.sub.b1)
 assert S.sub.b0, S.sub.b1 == (0x30, 0x31)
 
@@ -73,7 +68,7 @@
 
 desc2 = {
     "bf8": uctypes.BFUINT8 | 0 | 0 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
-    "bf32": uctypes.BFUINT32 | 0 | 20 << uctypes.BF_POS | 4 << uctypes.BF_LEN
+    "bf32": uctypes.BFUINT32 | 0 | 20 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
 }
 
 data2 = bytearray(b"0123")
diff --git a/tests/extmod/uctypes_le_float.py b/tests/extmod/uctypes_le_float.py
index 84ff2b84cf6e2..89e9a9e0abe48 100644
--- a/tests/extmod/uctypes_le_float.py
+++ b/tests/extmod/uctypes_le_float.py
@@ -7,7 +7,7 @@
 desc = {
     "f32": uctypes.FLOAT32 | 0,
     "f64": uctypes.FLOAT64 | 0,
-    "uf64": uctypes.FLOAT64 | 2, # unaligned
+    "uf64": uctypes.FLOAT64 | 2,  # unaligned
 }
 
 data = bytearray(10)
@@ -15,10 +15,10 @@
 S = uctypes.struct(uctypes.addressof(data), desc, uctypes.LITTLE_ENDIAN)
 
 S.f32 = 12.34
-print('%.4f' % S.f32)
+print("%.4f" % S.f32)
 
 S.f64 = 12.34
-print('%.4f' % S.f64)
+print("%.4f" % S.f64)
 
 S.uf64 = 12.34
-print('%.4f' % S.uf64)
+print("%.4f" % S.uf64)
diff --git a/tests/extmod/uctypes_native_float.py b/tests/extmod/uctypes_native_float.py
index acef47036d00c..e7d3ddabd93b2 100644
--- a/tests/extmod/uctypes_native_float.py
+++ b/tests/extmod/uctypes_native_float.py
@@ -14,7 +14,7 @@
 S = uctypes.struct(uctypes.addressof(data), desc, uctypes.NATIVE)
 
 S.f32 = 12.34
-print('%.4f' % S.f32)
+print("%.4f" % S.f32)
 
 S.f64 = 12.34
-print('%.4f' % S.f64)
+print("%.4f" % S.f64)
diff --git a/tests/extmod/uctypes_native_le.py b/tests/extmod/uctypes_native_le.py
index 8bba03b38cebb..c161539c624f8 100644
--- a/tests/extmod/uctypes_native_le.py
+++ b/tests/extmod/uctypes_native_le.py
@@ -2,6 +2,7 @@
 # Codepaths for packed vs native structures are different. This test only works
 # on little-endian machine (no matter if 32 or 64 bit).
 import sys
+
 try:
     import uctypes
 except ImportError:
@@ -15,20 +16,15 @@
 
 desc = {
     "s0": uctypes.UINT16 | 0,
-    "sub": (0, {
-        "b0": uctypes.UINT8 | 0,
-        "b1": uctypes.UINT8 | 1,
-    }),
+    "sub": (0, {"b0": uctypes.UINT8 | 0, "b1": uctypes.UINT8 | 1,}),
     "arr": (uctypes.ARRAY | 0, uctypes.UINT8 | 2),
     "arr2": (uctypes.ARRAY | 0, 2, {"b": uctypes.UINT8 | 0}),
     "bitf0": uctypes.BFUINT16 | 0 | 0 << uctypes.BF_POS | 8 << uctypes.BF_LEN,
     "bitf1": uctypes.BFUINT16 | 0 | 8 << uctypes.BF_POS | 8 << uctypes.BF_LEN,
-
-    "bf0": uctypes.BFUINT16 | 0 |  0 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
-    "bf1": uctypes.BFUINT16 | 0 |  4 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
-    "bf2": uctypes.BFUINT16 | 0 |  8 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
+    "bf0": uctypes.BFUINT16 | 0 | 0 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
+    "bf1": uctypes.BFUINT16 | 0 | 4 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
+    "bf2": uctypes.BFUINT16 | 0 | 8 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
     "bf3": uctypes.BFUINT16 | 0 | 12 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
-
     "ptr": (uctypes.PTR | 0, uctypes.UINT8),
     "ptr2": (uctypes.PTR | 0, {"b": uctypes.UINT8 | 0}),
 }
@@ -37,10 +33,10 @@
 
 S = uctypes.struct(uctypes.addressof(data), desc, uctypes.NATIVE)
 
-#print(S)
+# print(S)
 print(hex(S.s0))
 assert hex(S.s0) == "0x3130"
-#print(S.sub.b0)
+# print(S.sub.b0)
 print(S.sub.b0, S.sub.b1)
 assert S.sub.b0, S.sub.b1 == (0x30, 0x31)
 
@@ -81,7 +77,7 @@
 
 desc2 = {
     "bf8": uctypes.BFUINT8 | 0 | 0 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
-    "bf32": uctypes.BFUINT32 | 0 | 20 << uctypes.BF_POS | 4 << uctypes.BF_LEN
+    "bf32": uctypes.BFUINT32 | 0 | 20 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
 }
 
 data2 = bytearray(b"0123")
diff --git a/tests/extmod/uctypes_print.py b/tests/extmod/uctypes_print.py
index c310238e546c2..6e0018abc7698 100644
--- a/tests/extmod/uctypes_print.py
+++ b/tests/extmod/uctypes_print.py
@@ -16,10 +16,10 @@
 S2 = uctypes.struct(0, desc2)
 print(S2)
 
-desc3 = ((uctypes.ARRAY | 0, uctypes.UINT8 | 1))
+desc3 = (uctypes.ARRAY | 0, uctypes.UINT8 | 1)
 S3 = uctypes.struct(0, desc3)
 print(S3)
 
-desc4 = ((uctypes.PTR | 0, uctypes.UINT8 | 1))
+desc4 = (uctypes.PTR | 0, uctypes.UINT8 | 1)
 S4 = uctypes.struct(0, desc4)
 print(S4)
diff --git a/tests/extmod/uctypes_ptr_le.py b/tests/extmod/uctypes_ptr_le.py
index fc625f4227465..5d8094ee48a79 100644
--- a/tests/extmod/uctypes_ptr_le.py
+++ b/tests/extmod/uctypes_ptr_le.py
@@ -1,4 +1,5 @@
 import sys
+
 try:
     import uctypes
 except ImportError:
@@ -32,6 +33,6 @@
 print(hex(S.ptr16[0]))
 assert hex(S.ptr16[0]) == "0x3130"
 print(S.ptr2[0].b, S.ptr2[1].b)
-print (S.ptr2[0].b, S.ptr2[1].b)
+print(S.ptr2[0].b, S.ptr2[1].b)
 print(hex(S.ptr16[0]))
 assert (S.ptr2[0].b, S.ptr2[1].b) == (48, 49)
diff --git a/tests/extmod/uctypes_ptr_native_le.py b/tests/extmod/uctypes_ptr_native_le.py
index 24508b1cb4156..8ca4d2c55cf9c 100644
--- a/tests/extmod/uctypes_ptr_native_le.py
+++ b/tests/extmod/uctypes_ptr_native_le.py
@@ -1,4 +1,5 @@
 import sys
+
 try:
     import uctypes
 except ImportError:
@@ -30,6 +31,6 @@
 print(hex(S.ptr16[0]))
 assert hex(S.ptr16[0]) == "0x3130"
 print(S.ptr2[0].b, S.ptr2[1].b)
-print (S.ptr2[0].b, S.ptr2[1].b)
+print(S.ptr2[0].b, S.ptr2[1].b)
 print(hex(S.ptr16[0]))
 assert (S.ptr2[0].b, S.ptr2[1].b) == (48, 49)
diff --git a/tests/extmod/uctypes_sizeof.py b/tests/extmod/uctypes_sizeof.py
index e42e06c92469f..6e52232e39eba 100644
--- a/tests/extmod/uctypes_sizeof.py
+++ b/tests/extmod/uctypes_sizeof.py
@@ -11,10 +11,13 @@
     "arr2": (uctypes.ARRAY | 0, 2, {"b": uctypes.UINT8 | 0}),
     "arr3": (uctypes.ARRAY | 2, uctypes.UINT16 | 2),
     "arr4": (uctypes.ARRAY | 0, 2, {"b": uctypes.UINT8 | 0, "w": uctypes.UINT16 | 1}),
-    "sub": (0, {
-        'b1': uctypes.BFUINT8 | 0 | 4 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
-        'b2': uctypes.BFUINT8 | 0 | 0 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
-    }),
+    "sub": (
+        0,
+        {
+            "b1": uctypes.BFUINT8 | 0 | 4 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
+            "b2": uctypes.BFUINT8 | 0 | 0 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
+        },
+    ),
 }
 
 data = bytearray(b"01234567")
diff --git a/tests/extmod/uctypes_sizeof_float.py b/tests/extmod/uctypes_sizeof_float.py
index 1ba8871bdc62d..351632d76bbf5 100644
--- a/tests/extmod/uctypes_sizeof_float.py
+++ b/tests/extmod/uctypes_sizeof_float.py
@@ -4,5 +4,5 @@
     print("SKIP")
     raise SystemExit
 
-print(uctypes.sizeof({'f':uctypes.FLOAT32}))
-print(uctypes.sizeof({'f':uctypes.FLOAT64}))
+print(uctypes.sizeof({"f": uctypes.FLOAT32}))
+print(uctypes.sizeof({"f": uctypes.FLOAT64}))
diff --git a/tests/extmod/uctypes_sizeof_native.py b/tests/extmod/uctypes_sizeof_native.py
index 32c740e773503..352c191e0d8a6 100644
--- a/tests/extmod/uctypes_sizeof_native.py
+++ b/tests/extmod/uctypes_sizeof_native.py
@@ -28,10 +28,7 @@
     "b": uctypes.UINT32 | 4,
     "c": uctypes.UINT8 | 8,
     "d": uctypes.UINT32 | 0,
-    "sub": (4, {
-        "b0": uctypes.UINT8 | 0,
-        "b1": uctypes.UINT8 | 1,
-    }),
+    "sub": (4, {"b0": uctypes.UINT8 | 0, "b1": uctypes.UINT8 | 1,}),
 }
 
 assert uctypes.sizeof(S5) == 12
diff --git a/tests/extmod/uctypes_sizeof_od.py b/tests/extmod/uctypes_sizeof_od.py
index 192ee91528517..2f070095b55ff 100644
--- a/tests/extmod/uctypes_sizeof_od.py
+++ b/tests/extmod/uctypes_sizeof_od.py
@@ -5,18 +5,23 @@
     print("SKIP")
     raise SystemExit
 
-desc = OrderedDict({
-    # arr is array at offset 0, of UINT8 elements, array size is 2
-    "arr": (uctypes.ARRAY | 0, uctypes.UINT8 | 2),
-    # arr2 is array at offset 0, size 2, of structures defined recursively
-    "arr2": (uctypes.ARRAY | 0, 2, {"b": uctypes.UINT8 | 0}),
-    "arr3": (uctypes.ARRAY | 2, uctypes.UINT16 | 2),
-    "arr4": (uctypes.ARRAY | 0, 2, {"b": uctypes.UINT8 | 0, "w": uctypes.UINT16 | 1}),
-    "sub": (0, {
-        'b1': uctypes.BFUINT8 | 0 | 4 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
-        'b2': uctypes.BFUINT8 | 0 | 0 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
-    }),
-})
+desc = OrderedDict(
+    {
+        # arr is array at offset 0, of UINT8 elements, array size is 2
+        "arr": (uctypes.ARRAY | 0, uctypes.UINT8 | 2),
+        # arr2 is array at offset 0, size 2, of structures defined recursively
+        "arr2": (uctypes.ARRAY | 0, 2, {"b": uctypes.UINT8 | 0}),
+        "arr3": (uctypes.ARRAY | 2, uctypes.UINT16 | 2),
+        "arr4": (uctypes.ARRAY | 0, 2, {"b": uctypes.UINT8 | 0, "w": uctypes.UINT16 | 1}),
+        "sub": (
+            0,
+            {
+                "b1": uctypes.BFUINT8 | 0 | 4 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
+                "b2": uctypes.BFUINT8 | 0 | 0 << uctypes.BF_POS | 4 << uctypes.BF_LEN,
+            },
+        ),
+    }
+)
 
 data = bytearray(b"01234567")
 
diff --git a/tests/extmod/uhashlib_md5.py b/tests/extmod/uhashlib_md5.py
index 10b6d054e77a8..07d5f3169200c 100644
--- a/tests/extmod/uhashlib_md5.py
+++ b/tests/extmod/uhashlib_md5.py
@@ -16,6 +16,6 @@
     print("SKIP")
     raise SystemExit
 
-md5 = hashlib.md5(b'hello')
-md5.update(b'world')
+md5 = hashlib.md5(b"hello")
+md5.update(b"world")
 print(md5.digest())
diff --git a/tests/extmod/uhashlib_sha1.py b/tests/extmod/uhashlib_sha1.py
index 4f7066899aa11..a573121316520 100644
--- a/tests/extmod/uhashlib_sha1.py
+++ b/tests/extmod/uhashlib_sha1.py
@@ -16,6 +16,6 @@
     print("SKIP")
     raise SystemExit
 
-sha1 = hashlib.sha1(b'hello')
-sha1.update(b'world')
+sha1 = hashlib.sha1(b"hello")
+sha1.update(b"world")
 print(sha1.digest())
diff --git a/tests/extmod/uhashlib_sha256.py b/tests/extmod/uhashlib_sha256.py
index 676d47979490c..2e6df7df13202 100644
--- a/tests/extmod/uhashlib_sha256.py
+++ b/tests/extmod/uhashlib_sha256.py
@@ -27,12 +27,12 @@
 print(hashlib.sha256(b"\xff" * 56).digest())
 
 # TODO: running .digest() several times in row is not supported()
-#h = hashlib.sha256(b'123')
-#print(h.digest())
-#print(h.digest())
+# h = hashlib.sha256(b'123')
+# print(h.digest())
+# print(h.digest())
 
 # TODO: partial digests are not supported
-#h = hashlib.sha256(b'123')
-#print(h.digest())
-#h.update(b'456')
-#print(h.digest())
+# h = hashlib.sha256(b'123')
+# print(h.digest())
+# h.update(b'456')
+# print(h.digest())
diff --git a/tests/extmod/uheapq1.py b/tests/extmod/uheapq1.py
index 7c1fe4e1ec149..a470bb6f71b13 100644
--- a/tests/extmod/uheapq1.py
+++ b/tests/extmod/uheapq1.py
@@ -17,11 +17,13 @@
 except TypeError:
     print("TypeError")
 
+
 def pop_and_print(h):
     l = []
     while h:
         l.append(str(heapq.heappop(h)))
-    print(' '.join(l))
+    print(" ".join(l))
+
 
 h = []
 heapq.heappush(h, 3)
diff --git a/tests/extmod/ujson_dump.py b/tests/extmod/ujson_dump.py
index b1cb4a9cbcdb2..feda8a47dda42 100644
--- a/tests/extmod/ujson_dump.py
+++ b/tests/extmod/ujson_dump.py
@@ -20,11 +20,11 @@
 # dump to a small-int not allowed
 try:
     json.dump(123, 1)
-except (AttributeError, OSError): # CPython and uPy have different errors
-    print('Exception')
+except (AttributeError, OSError):  # CPython and uPy have different errors
+    print("Exception")
 
 # dump to an object not allowed
 try:
     json.dump(123, {})
-except (AttributeError, OSError): # CPython and uPy have different errors
-    print('Exception')
+except (AttributeError, OSError):  # CPython and uPy have different errors
+    print("Exception")
diff --git a/tests/extmod/ujson_dump_iobase.py b/tests/extmod/ujson_dump_iobase.py
index 51d507cd1a167..7ecf23afb6539 100644
--- a/tests/extmod/ujson_dump_iobase.py
+++ b/tests/extmod/ujson_dump_iobase.py
@@ -7,27 +7,28 @@
     try:
         import io, json
     except ImportError:
-        print('SKIP')
+        print("SKIP")
         raise SystemExit
 
-if not hasattr(io, 'IOBase'):
-    print('SKIP')
+if not hasattr(io, "IOBase"):
+    print("SKIP")
     raise SystemExit
 
 
 # a user stream that only has the write method
 class S(io.IOBase):
     def __init__(self):
-        self.buf = ''
+        self.buf = ""
+
     def write(self, buf):
         if type(buf) == bytearray:
             # uPy passes a bytearray, CPython passes a str
-            buf = str(buf, 'ascii')
+            buf = str(buf, "ascii")
         self.buf += buf
         return len(buf)
 
 
 # dump to the user stream
 s = S()
-json.dump([123, {}], s) 
+json.dump([123, {}], s)
 print(s.buf)
diff --git a/tests/extmod/ujson_dumps.py b/tests/extmod/ujson_dumps.py
index d732718019ee2..251b2687557e5 100644
--- a/tests/extmod/ujson_dumps.py
+++ b/tests/extmod/ujson_dumps.py
@@ -11,8 +11,8 @@
 print(json.dumps(True))
 print(json.dumps(None))
 print(json.dumps(1))
-print(json.dumps('abc'))
-print(json.dumps('\x00\x01\x7e'))
+print(json.dumps("abc"))
+print(json.dumps("\x00\x01\x7e"))
 print(json.dumps([]))
 print(json.dumps([1]))
 print(json.dumps([1, 2]))
@@ -22,7 +22,11 @@
 print(json.dumps((1, 2)))
 print(json.dumps((1, (2, 3))))
 print(json.dumps({}))
-print(json.dumps({"a":1}))
-print(json.dumps({"a":(2,[3,None])}))
+print(json.dumps({"a": 1}))
+print(json.dumps({"a": (2, [3, None])}))
 print(json.dumps('"quoted"'))
-print(json.dumps('space\n\r\tspace'))
+print(json.dumps("space\n\r\tspace"))
+print(json.dumps({None: -1}))
+print(json.dumps({False: 0}))
+print(json.dumps({True: 1}))
+print(json.dumps({1: 2}))
diff --git a/tests/extmod/ujson_dumps_extra.py b/tests/extmod/ujson_dumps_extra.py
index 21a388c32d097..f2aa7f249fc93 100644
--- a/tests/extmod/ujson_dumps_extra.py
+++ b/tests/extmod/ujson_dumps_extra.py
@@ -6,4 +6,4 @@
     print("SKIP")
     raise SystemExit
 
-print(ujson.dumps(b'1234'))
+print(ujson.dumps(b"1234"))
diff --git a/tests/extmod/ujson_dumps_float.py b/tests/extmod/ujson_dumps_float.py
index e8cceb6f1a533..25681d0c23c4e 100644
--- a/tests/extmod/ujson_dumps_float.py
+++ b/tests/extmod/ujson_dumps_float.py
@@ -8,3 +8,4 @@
         raise SystemExit
 
 print(json.dumps(1.2))
+print(json.dumps({1.5: "hi"}))
diff --git a/tests/extmod/ujson_dumps_ordereddict.py b/tests/extmod/ujson_dumps_ordereddict.py
new file mode 100644
index 0000000000000..c6f4a8fcb7942
--- /dev/null
+++ b/tests/extmod/ujson_dumps_ordereddict.py
@@ -0,0 +1,12 @@
+try:
+    import ujson as json
+    from ucollections import OrderedDict
+except ImportError:
+    try:
+        import json
+        from collections import OrderedDict
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+print(json.dumps(OrderedDict(((1, 2), (3, 4)))))
diff --git a/tests/extmod/ujson_load.py b/tests/extmod/ujson_load.py
index 9725ab2ddc9a5..7cec9246b82c5 100644
--- a/tests/extmod/ujson_load.py
+++ b/tests/extmod/ujson_load.py
@@ -9,7 +9,7 @@
         print("SKIP")
         raise SystemExit
 
-print(json.load(StringIO('null')))
+print(json.load(StringIO("null")))
 print(json.load(StringIO('"abc\\u0064e"')))
-print(json.load(StringIO('[false, true, 1, -2]')))
+print(json.load(StringIO("[false, true, 1, -2]")))
 print(json.load(StringIO('{"a":true}')))
diff --git a/tests/extmod/ujson_loads.py b/tests/extmod/ujson_loads.py
index adba3c068d27c..2de9cdcbc1a8a 100644
--- a/tests/extmod/ujson_loads.py
+++ b/tests/extmod/ujson_loads.py
@@ -7,23 +7,25 @@
         print("SKIP")
         raise SystemExit
 
+
 def my_print(o):
     if isinstance(o, dict):
-        print('sorted dict', sorted(o.items()))
+        print("sorted dict", sorted(o.items()))
     else:
         print(o)
 
-my_print(json.loads('null'))
-my_print(json.loads('false'))
-my_print(json.loads('true'))
-my_print(json.loads('1'))
-my_print(json.loads('-2'))
+
+my_print(json.loads("null"))
+my_print(json.loads("false"))
+my_print(json.loads("true"))
+my_print(json.loads("1"))
+my_print(json.loads("-2"))
 my_print(json.loads('"abc\\u0064e"'))
-my_print(json.loads('[]'))
-my_print(json.loads('[null]'))
-my_print(json.loads('[null,false,true]'))
-my_print(json.loads(' [ null , false , true ] '))
-my_print(json.loads('{}'))
+my_print(json.loads("[]"))
+my_print(json.loads("[null]"))
+my_print(json.loads("[null,false,true]"))
+my_print(json.loads(" [ null , false , true ] "))
+my_print(json.loads("{}"))
 my_print(json.loads('{"a":true}'))
 my_print(json.loads('{"a":null, "b":false, "c":true}'))
 my_print(json.loads('{"a":[], "b":[1], "c":{"3":4}}'))
@@ -39,36 +41,36 @@ def my_print(o):
 
 # loading nothing should raise exception
 try:
-    json.loads('')
+    json.loads("")
 except ValueError:
-    print('ValueError')
+    print("ValueError")
 
 # string which is not closed
 try:
     my_print(json.loads('"abc'))
 except ValueError:
-    print('ValueError')
+    print("ValueError")
 
 # unaccompanied closing brace
 try:
-    my_print(json.loads(']'))
+    my_print(json.loads("]"))
 except ValueError:
-    print('ValueError')
+    print("ValueError")
 
 # unspecified object type
 try:
-    my_print(json.loads('a'))
+    my_print(json.loads("a"))
 except ValueError:
-    print('ValueError')
+    print("ValueError")
 
 # bad property name
 try:
     my_print(json.loads('{{}:"abc"}'))
 except ValueError:
-    print('ValueError')
+    print("ValueError")
 
 # unexpected characters after white space
 try:
-    my_print(json.loads('[null]   a'))
+    my_print(json.loads("[null]   a"))
 except ValueError:
-    print('ValueError')
+    print("ValueError")
diff --git a/tests/extmod/ujson_loads_bytes.py b/tests/extmod/ujson_loads_bytes.py
new file mode 100644
index 0000000000000..3ee87bbcd582e
--- /dev/null
+++ b/tests/extmod/ujson_loads_bytes.py
@@ -0,0 +1,13 @@
+# test loading from bytes and bytearray (introduced in Python 3.6)
+
+try:
+    import ujson as json
+except ImportError:
+    try:
+        import json
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+print(json.loads(b"[1,2]"))
+print(json.loads(bytearray(b"[null]")))
diff --git a/tests/extmod/ujson_loads_bytes.py.exp b/tests/extmod/ujson_loads_bytes.py.exp
new file mode 100644
index 0000000000000..c2735a99052d2
--- /dev/null
+++ b/tests/extmod/ujson_loads_bytes.py.exp
@@ -0,0 +1,2 @@
+[1, 2]
+[None]
diff --git a/tests/extmod/ujson_loads_float.py b/tests/extmod/ujson_loads_float.py
index f1b8cc364c4ac..842718f37de73 100644
--- a/tests/extmod/ujson_loads_float.py
+++ b/tests/extmod/ujson_loads_float.py
@@ -7,11 +7,14 @@
         print("SKIP")
         raise SystemExit
 
+
 def my_print(o):
-    print('%.3f' % o)
+    print("%.3f" % o)
+
 
-my_print(json.loads('1.2'))
-my_print(json.loads('1e2'))
-my_print(json.loads('-2.3'))
-my_print(json.loads('-2e3'))
-my_print(json.loads('-2e-3'))
+my_print(json.loads("1.2"))
+my_print(json.loads("1e2"))
+my_print(json.loads("-2.3"))
+my_print(json.loads("-2e3"))
+my_print(json.loads("-2e+3"))
+my_print(json.loads("-2e-3"))
diff --git a/tests/extmod/urandom_basic.py b/tests/extmod/urandom_basic.py
index 57e6b26cba590..180197398f429 100644
--- a/tests/extmod/urandom_basic.py
+++ b/tests/extmod/urandom_basic.py
@@ -26,4 +26,4 @@
 try:
     random.getrandbits(0)
 except ValueError:
-    print('ValueError')
+    print("ValueError")
diff --git a/tests/extmod/urandom_extra.py b/tests/extmod/urandom_extra.py
index 0cfd9280b59b9..78e17379dc68e 100644
--- a/tests/extmod/urandom_extra.py
+++ b/tests/extmod/urandom_extra.py
@@ -10,10 +10,10 @@
 try:
     random.randint
 except AttributeError:
-    print('SKIP')
+    print("SKIP")
     raise SystemExit
 
-print('randrange')
+print("randrange")
 for i in range(50):
     assert 0 <= random.randrange(4) < 4
     assert 2 <= random.randrange(2, 6) < 6
@@ -25,27 +25,27 @@
 try:
     random.randrange(0)
 except ValueError:
-    print('ValueError')
+    print("ValueError")
 
 # empty range
 try:
     random.randrange(2, 1)
 except ValueError:
-    print('ValueError')
+    print("ValueError")
 
 # zero step
 try:
     random.randrange(2, 1, 0)
 except ValueError:
-    print('ValueError')
+    print("ValueError")
 
 # empty range
 try:
     random.randrange(2, 1, 1)
 except ValueError:
-    print('ValueError')
+    print("ValueError")
 
-print('randint')
+print("randint")
 for i in range(50):
     assert 0 <= random.randint(0, 4) <= 4
     assert 2 <= random.randint(2, 6) <= 6
@@ -55,9 +55,9 @@
 try:
     random.randint(2, 1)
 except ValueError:
-    print('ValueError')
+    print("ValueError")
 
-print('choice')
+print("choice")
 lst = [1, 2, 5, 6]
 for i in range(50):
     assert random.choice(lst) in lst
@@ -66,4 +66,4 @@
 try:
     random.choice([])
 except IndexError:
-    print('IndexError')
+    print("IndexError")
diff --git a/tests/extmod/urandom_extra_float.py b/tests/extmod/urandom_extra_float.py
index f665fd18adf61..65918da136945 100644
--- a/tests/extmod/urandom_extra_float.py
+++ b/tests/extmod/urandom_extra_float.py
@@ -10,14 +10,14 @@
 try:
     random.randint
 except AttributeError:
-    print('SKIP')
+    print("SKIP")
     raise SystemExit
 
-print('random')
+print("random")
 for i in range(50):
     assert 0 <= random.random() < 1
 
-print('uniform')
+print("uniform")
 for i in range(50):
     assert 0 <= random.uniform(0, 4) <= 4
     assert 2 <= random.uniform(2, 6) <= 6
diff --git a/tests/extmod/ure1.py b/tests/extmod/ure1.py
index 54471ed4f97c4..9e1be5fc796bc 100644
--- a/tests/extmod/ure1.py
+++ b/tests/extmod/ure1.py
@@ -70,11 +70,16 @@
 m = re.search("w.r", "hello world")
 print(m.group(0))
 
-m = re.match('a+?', 'ab');  print(m.group(0))
-m = re.match('a*?', 'ab');  print(m.group(0))
-m = re.match('^ab$', 'ab'); print(m.group(0))
-m = re.match('a|b', 'b');   print(m.group(0))
-m = re.match('a|b|c', 'c'); print(m.group(0))
+m = re.match("a+?", "ab")
+print(m.group(0))
+m = re.match("a*?", "ab")
+print(m.group(0))
+m = re.match("^ab$", "ab")
+print(m.group(0))
+m = re.match("a|b", "b")
+print(m.group(0))
+m = re.match("a|b|c", "c")
+print(m.group(0))
 
 # Case where anchors fail to match
 r = re.compile("^b|b$")
@@ -87,4 +92,36 @@
     print("Caught invalid regex")
 
 # bytes objects
-m = re.match(rb'a+?', b'ab');  print(m.group(0))
+m = re.match(rb"a+?", b"ab")
+print(m.group(0))
+print("===")
+
+# escaping
+m = re.match(r"a\.c", "a.c")
+print(m.group(0) if m else "")
+m = re.match(r"a\.b", "abc")
+print(m is None)
+m = re.match(r"a\.b", "a\\bc")
+print(m is None)
+m = re.match(r"[a\-z]", "abc")
+print(m.group(0))
+m = re.match(r"[.\]]*", ".].]a")
+print(m.group(0))
+m = re.match(r"[.\]+]*", ".]+.]a")
+print(m.group(0))
+m = re.match(r"[a-f0-9x\-yz]*", "abxcd1-23")
+print(m.group(0))
+m = re.match(r"[a\\b]*", "a\\aa\\bb\\bbab")
+print(m.group(0))
+m = re.search(r"[a\-z]", "-")
+print(m.group(0))
+m = re.search(r"[a\-z]", "f")
+print(m is None)
+m = re.search(r"[a\]z]", "a")
+print(m.group(0))
+print(re.compile(r"[-a]").split("foo-bar"))
+print(re.compile(r"[a-]").split("foo-bar"))
+print(re.compile(r"[ax\-]").split("foo-bar"))
+print(re.compile(r"[a\-x]").split("foo-bar"))
+print(re.compile(r"[\-ax]").split("foo-bar"))
+print("===")
diff --git a/tests/extmod/ure_debug.py b/tests/extmod/ure_debug.py
index cfb264bb6d290..7a07ede2d4373 100644
--- a/tests/extmod/ure_debug.py
+++ b/tests/extmod/ure_debug.py
@@ -1,8 +1,10 @@
 # test printing debugging info when compiling
 try:
     import ure
-except ImportError:
+
+    ure.DEBUG
+except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
 
-ure.compile('^a|b[0-9]\w$', ure.DEBUG)
+ure.compile("^a|b[0-9]\w$", ure.DEBUG)
diff --git a/tests/extmod/ure_error.py b/tests/extmod/ure_error.py
index f52f735c7fa5e..52a96b7c0385a 100644
--- a/tests/extmod/ure_error.py
+++ b/tests/extmod/ure_error.py
@@ -9,17 +9,20 @@
         print("SKIP")
         raise SystemExit
 
+
 def test_re(r):
     try:
         re.compile(r)
         print("OK")
-    except: # uPy and CPy use different errors, so just ignore the type
+    except:  # uPy and CPy use different errors, so just ignore the type
         print("Error")
 
-test_re(r'?')
-test_re(r'*')
-test_re(r'+')
-test_re(r')')
-test_re(r'[')
-test_re(r'([')
-test_re(r'([)')
+
+test_re(r"?")
+test_re(r"*")
+test_re(r"+")
+test_re(r")")
+test_re(r"[")
+test_re(r"([")
+test_re(r"([)")
+test_re(r"[a\]")
diff --git a/tests/extmod/ure_group.py b/tests/extmod/ure_group.py
index 4e39468c5ba0a..41425dd62347f 100644
--- a/tests/extmod/ure_group.py
+++ b/tests/extmod/ure_group.py
@@ -9,8 +9,9 @@
         print("SKIP")
         raise SystemExit
 
+
 def print_groups(match):
-    print('----')
+    print("----")
     try:
         i = 0
         while True:
@@ -19,14 +20,15 @@ def print_groups(match):
     except IndexError:
         pass
 
-m = re.match(r'(([0-9]*)([a-z]*)[0-9]*)','1234hello567')
+
+m = re.match(r"(([0-9]*)([a-z]*)[0-9]*)", "1234hello567")
 print_groups(m)
 
-m = re.match(r'([0-9]*)(([a-z]*)([0-9]*))','1234hello567')
+m = re.match(r"([0-9]*)(([a-z]*)([0-9]*))", "1234hello567")
 print_groups(m)
 
 # optional group that matches
-print_groups(re.match(r'(a)?b(c)', 'abc'))
+print_groups(re.match(r"(a)?b(c)", "abc"))
 
 # optional group that doesn't match
-print_groups(re.match(r'(a)?b(c)', 'bc'))
+print_groups(re.match(r"(a)?b(c)", "bc"))
diff --git a/tests/extmod/ure_groups.py b/tests/extmod/ure_groups.py
index 4fac896d7fdbb..7da072a920658 100644
--- a/tests/extmod/ure_groups.py
+++ b/tests/extmod/ure_groups.py
@@ -13,21 +13,21 @@
     m = re.match(".", "a")
     m.groups
 except AttributeError:
-    print('SKIP')
+    print("SKIP")
     raise SystemExit
 
 
-m = re.match(r'(([0-9]*)([a-z]*)[0-9]*)','1234hello567')
+m = re.match(r"(([0-9]*)([a-z]*)[0-9]*)", "1234hello567")
 print(m.groups())
 
-m = re.match(r'([0-9]*)(([a-z]*)([0-9]*))','1234hello567')
+m = re.match(r"([0-9]*)(([a-z]*)([0-9]*))", "1234hello567")
 print(m.groups())
 
 # optional group that matches
-print(re.match(r'(a)?b(c)', 'abc').groups())
+print(re.match(r"(a)?b(c)", "abc").groups())
 
 # optional group that doesn't match
-print(re.match(r'(a)?b(c)', 'bc').groups())
+print(re.match(r"(a)?b(c)", "bc").groups())
 
 # only a single match
-print(re.match(r'abc', 'abc').groups())
+print(re.match(r"abc", "abc").groups())
diff --git a/tests/extmod/ure_namedclass.py b/tests/extmod/ure_namedclass.py
index 215d09613f4b0..00d58ad98adb0 100644
--- a/tests/extmod/ure_namedclass.py
+++ b/tests/extmod/ure_namedclass.py
@@ -9,8 +9,9 @@
         print("SKIP")
         raise SystemExit
 
+
 def print_groups(match):
-    print('----')
+    print("----")
     try:
         i = 0
         while True:
@@ -19,14 +20,15 @@ def print_groups(match):
     except IndexError:
         pass
 
-m = re.match(r'\w+','1234hello567 abc')
+
+m = re.match(r"\w+", "1234hello567 abc")
 print_groups(m)
 
-m = re.match(r'(\w+)\s+(\w+)','ABC \t1234hello567 abc')
+m = re.match(r"(\w+)\s+(\w+)", "ABC \t1234hello567 abc")
 print_groups(m)
 
-m = re.match(r'(\S+)\s+(\D+)','ABC \thello abc567 abc')
+m = re.match(r"(\S+)\s+(\D+)", "ABC \thello abc567 abc")
 print_groups(m)
 
-m = re.match(r'(([0-9]*)([a-z]*)\d*)','1234hello567')
+m = re.match(r"(([0-9]*)([a-z]*)\d*)", "1234hello567")
 print_groups(m)
diff --git a/tests/extmod/ure_span.py b/tests/extmod/ure_span.py
index 50f44399ce714..03a3fef9f3d1a 100644
--- a/tests/extmod/ure_span.py
+++ b/tests/extmod/ure_span.py
@@ -13,12 +13,12 @@
     m = re.match(".", "a")
     m.span
 except AttributeError:
-    print('SKIP')
+    print("SKIP")
     raise SystemExit
 
 
 def print_spans(match):
-    print('----')
+    print("----")
     try:
         i = 0
         while True:
@@ -27,14 +27,15 @@ def print_spans(match):
     except IndexError:
         pass
 
-m = re.match(r'(([0-9]*)([a-z]*)[0-9]*)','1234hello567')
+
+m = re.match(r"(([0-9]*)([a-z]*)[0-9]*)", "1234hello567")
 print_spans(m)
 
-m = re.match(r'([0-9]*)(([a-z]*)([0-9]*))','1234hello567')
+m = re.match(r"([0-9]*)(([a-z]*)([0-9]*))", "1234hello567")
 print_spans(m)
 
 # optional span that matches
-print_spans(re.match(r'(a)?b(c)', 'abc'))
+print_spans(re.match(r"(a)?b(c)", "abc"))
 
 # optional span that doesn't match
-print_spans(re.match(r'(a)?b(c)', 'bc'))
+print_spans(re.match(r"(a)?b(c)", "bc"))
diff --git a/tests/extmod/ure_split_notimpl.py b/tests/extmod/ure_split_notimpl.py
index da6e9652d03e2..51bad791efb88 100644
--- a/tests/extmod/ure_split_notimpl.py
+++ b/tests/extmod/ure_split_notimpl.py
@@ -4,8 +4,8 @@
     print("SKIP")
     raise SystemExit
 
-r = re.compile('( )')
+r = re.compile("( )")
 try:
     s = r.split("a b c foobar")
 except NotImplementedError:
-    print('NotImplementedError')
+    print("NotImplementedError")
diff --git a/tests/extmod/ure_sub.py b/tests/extmod/ure_sub.py
index 4aeb8650a18e7..6bb332077dd29 100644
--- a/tests/extmod/ure_sub.py
+++ b/tests/extmod/ure_sub.py
@@ -4,58 +4,59 @@
     try:
         import re
     except ImportError:
-        print('SKIP')
+        print("SKIP")
         raise SystemExit
 
 try:
     re.sub
 except AttributeError:
-    print('SKIP')
+    print("SKIP")
     raise SystemExit
 
 
 def multiply(m):
     return str(int(m.group(0)) * 2)
 
+
 print(re.sub("\d+", multiply, "10 20 30 40 50"))
 
 print(re.sub("\d+", lambda m: str(int(m.group(0)) // 2), "10 20 30 40 50"))
 
+
 def A():
     return "A"
-print(re.sub('a', A(), 'aBCBABCDabcda.'))
+
+
+print(re.sub("a", A(), "aBCBABCDabcda."))
 
 print(
     re.sub(
-        r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):', 
-        'static PyObject*\npy_\\1(void){\n  return;\n}\n', 
-        '\n\ndef myfunc():\n\ndef myfunc1():\n\ndef myfunc2():'
+        r"def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):",
+        "static PyObject*\npy_\\1(void){\n  return;\n}\n",
+        "\n\ndef myfunc():\n\ndef myfunc1():\n\ndef myfunc2():",
     )
-) 
+)
 
 print(
-    re.compile(
-         '(calzino) (blu|bianco|verde) e (scarpa) (blu|bianco|verde)'
-    ).sub(
-        r'\g<1> colore \2 con \g<3> colore \4? ...',
-        'calzino blu e scarpa verde'
+    re.compile("(calzino) (blu|bianco|verde) e (scarpa) (blu|bianco|verde)").sub(
+        r"\g<1> colore \2 con \g<3> colore \4? ...", "calzino blu e scarpa verde"
     )
 )
 
 # no matches at all
-print(re.sub('a', 'b', 'c'))
+print(re.sub("a", "b", "c"))
 
 # with maximum substitution count specified
-print(re.sub('a', 'b', '1a2a3a', 2))
+print(re.sub("a", "b", "1a2a3a", 2))
 
 # invalid group
 try:
-    re.sub('(a)', 'b\\2', 'a')
+    re.sub("(a)", "b\\2", "a")
 except:
-    print('invalid group')
+    print("invalid group")
 
 # invalid group with very large number (to test overflow in uPy)
 try:
-    re.sub('(a)', 'b\\199999999999999999999999999999999999999', 'a')
+    re.sub("(a)", "b\\199999999999999999999999999999999999999", "a")
 except:
-    print('invalid group')
+    print("invalid group")
diff --git a/tests/extmod/ure_sub_unmatched.py b/tests/extmod/ure_sub_unmatched.py
index 4795b3196f466..d6312bfc2cbc2 100644
--- a/tests/extmod/ure_sub_unmatched.py
+++ b/tests/extmod/ure_sub_unmatched.py
@@ -6,14 +6,14 @@
     try:
         import re
     except ImportError:
-        print('SKIP')
+        print("SKIP")
         raise SystemExit
 
 try:
     re.sub
 except AttributeError:
-    print('SKIP')
+    print("SKIP")
     raise SystemExit
 
 # first group matches, second optional group doesn't so is replaced with a blank
-print(re.sub(r'(a)(b)?', r'\2-\1', '1a2'))
+print(re.sub(r"(a)(b)?", r"\2-\1", "1a2"))
diff --git a/tests/extmod/uselect_poll_basic.py b/tests/extmod/uselect_poll_basic.py
index df52471ac3992..07328365b31da 100644
--- a/tests/extmod/uselect_poll_basic.py
+++ b/tests/extmod/uselect_poll_basic.py
@@ -3,6 +3,7 @@
 except ImportError:
     try:
         import socket, select, errno
+
         select.poll  # Raises AttributeError for CPython implementations without poll()
     except (ImportError, AttributeError):
         print("SKIP")
@@ -33,3 +34,9 @@
     poller.modify(s, select.POLLIN)
 except OSError as e:
     assert e.args[0] == errno.ENOENT
+
+# poll after closing the socket, should return POLLNVAL
+poller.register(s)
+s.close()
+p = poller.poll(0)
+print(len(p), p[0][-1])
diff --git a/tests/extmod/uselect_poll_udp.py b/tests/extmod/uselect_poll_udp.py
new file mode 100644
index 0000000000000..f6be262ee02f4
--- /dev/null
+++ b/tests/extmod/uselect_poll_udp.py
@@ -0,0 +1,28 @@
+# test select.poll on UDP sockets
+
+try:
+    import usocket as socket, uselect as select
+except ImportError:
+    try:
+        import socket, select
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+s.bind(socket.getaddrinfo("127.0.0.1", 8000)[0][-1])
+poll = select.poll()
+
+# UDP socket should not be readable
+poll.register(s, select.POLLIN)
+print(len(poll.poll(0)))
+
+# UDP socket should be writable
+poll.modify(s, select.POLLOUT)
+print(poll.poll(0)[0][1] == select.POLLOUT)
+
+# same test for select.select, but just skip it if the function isn't available
+if hasattr(select, "select"):
+    r, w, e = select.select([s], [], [], 0)
+    assert not r and not w and not e
diff --git a/tests/extmod/usocket_udp_nonblock.py b/tests/extmod/usocket_udp_nonblock.py
new file mode 100644
index 0000000000000..7dc0e562a3178
--- /dev/null
+++ b/tests/extmod/usocket_udp_nonblock.py
@@ -0,0 +1,20 @@
+# test non-blocking UDP sockets
+
+try:
+    import usocket as socket, uerrno as errno
+except ImportError:
+    try:
+        import socket, errno
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+s.bind(socket.getaddrinfo("127.0.0.1", 8000)[0][-1])
+s.settimeout(0)
+
+try:
+    s.recv(1)
+except OSError as er:
+    print("EAGAIN:", er.args[0] == errno.EAGAIN)
diff --git a/tests/extmod/ussl_basic.py b/tests/extmod/ussl_basic.py
index e8710ed51ab4b..b4e21c7dce660 100644
--- a/tests/extmod/ussl_basic.py
+++ b/tests/extmod/ussl_basic.py
@@ -11,7 +11,7 @@
 try:
     ss = ssl.wrap_socket(io.BytesIO())
 except OSError as er:
-    print('wrap_socket:', repr(er))
+    print("wrap_socket:", repr(er))
 
 # create in server mode (can use this object for further tests)
 socket = io.BytesIO()
@@ -20,26 +20,27 @@
 # print
 print(repr(ss)[:12])
 
-# setblocking
-try:
-    ss.setblocking(False)
-except NotImplementedError:
-    print('setblocking: NotImplementedError')
-ss.setblocking(True)
+# setblocking() propagates call to the underlying stream object, and
+# io.BytesIO doesn't have setblocking() (in CPython too).
+# try:
+#    ss.setblocking(False)
+# except NotImplementedError:
+#    print('setblocking: NotImplementedError')
+# ss.setblocking(True)
 
 # write
-print(ss.write(b'aaaa'))
+print(ss.write(b"aaaa"))
 
 # read (underlying socket has no data)
 print(ss.read(8))
 
 # read (underlying socket has data, but it's bad data)
-socket.write(b'aaaaaaaaaaaaaaaa')
+socket.write(b"aaaaaaaaaaaaaaaa")
 socket.seek(0)
 try:
     ss.read(8)
 except OSError as er:
-    print('read:', repr(er))
+    print("read:", repr(er))
 
 # close
 ss.close()
@@ -50,10 +51,10 @@
 try:
     ss.read(10)
 except OSError as er:
-    print('read:', repr(er))
+    print("read:", repr(er))
 
 # write on closed socket
 try:
-    ss.write(b'aaaa')
+    ss.write(b"aaaa")
 except OSError as er:
-    print('write:', repr(er))
+    print("write:", repr(er))
diff --git a/tests/extmod/ussl_basic.py.exp b/tests/extmod/ussl_basic.py.exp
index cb9c51f7a1263..5282338319efb 100644
--- a/tests/extmod/ussl_basic.py.exp
+++ b/tests/extmod/ussl_basic.py.exp
@@ -1,7 +1,6 @@
 ssl_handshake_status: -256
 wrap_socket: OSError(5,)
 <_SSLSocket 
-setblocking: NotImplementedError
 4
 b''
 read: OSError(-261,)
diff --git a/tests/extmod/ussl_keycert.py b/tests/extmod/ussl_keycert.py
new file mode 100644
index 0000000000000..87a40a1e552b5
--- /dev/null
+++ b/tests/extmod/ussl_keycert.py
@@ -0,0 +1,28 @@
+# Test ussl with key/cert passed in
+
+try:
+    import uio as io
+    import ussl as ssl
+except ImportError:
+    print("SKIP")
+    raise SystemExit
+
+key = b"0\x82\x019\x02\x01\x00\x02A\x00\xf9\xe0}\xbd\xd7\x9cI\x18\x06\xc3\xcb\xb5\xec@r\xfbD\x18\x80\xaaWoZ{\xcc\xa3\xeb!\"\x0fY\x9e]-\xee\xe4\t!BY\x9f{7\xf3\xf2\x8f}}\r|.\xa8<\ta\xb2\xd7W\xb3\xc9\x19A\xc39\x02\x03\x01\x00\x01\x02@\x07:\x9fh\xa6\x9c6\xe1#\x10\xf7\x0b\xc4Q\xf9\x01\x9b\xee\xb9\x8a4\r\\\xa8\xc8:\xd5\xca\x97\x99\xaa\x16\x04)\xa8\xf9\x13\xdeq\x0ev`\xa7\x83\xc5\x8b`\xdb\xef \x9d\x93\xe8g\x84\x96\xfaV\\\xf4R\xda\xd0\xa1\x02!\x00\xfeR\xbf\n\x91Su\x87L\x98{\xeb%\xed\xfb\x06u)@\xfe\x1b\xde\xa0\xc6@\xab\xc5\xedg\x8e\x10[\x02!\x00\xfb\x86=\x85\xa4'\xde\x85\xb5L\xe0)\x99\xfaL\x8c3A\x02\xa8<\xdew\xad\x00\xe3\x1d\x05\xd8\xb4N\xfb\x02 \x08\xb0M\x04\x90hx\x88q\xcew\xd5U\xcbf\x9b\x16\xdf\x9c\xef\xd1\x85\xee\x9a7Ug\x02\xb0Z\x03'\x02 9\xa0D\xe2$|\xf9\xefz]5\x92rs\xb5+\xfd\xe6,\x1c\xadmn\xcf\xd5?3|\x0em)\x17\x02 5Z\xcc/\xa5?\n\x04%\x9b{N\x9dX\xddI\xbe\xd2\xb0\xa0\x03BQ\x02\x82\xc2\xe0u)\xbd\xb8\xaf"
+
+# Invalid key
+try:
+    ssl.wrap_socket(io.BytesIO(), key=b"!")
+except ValueError as er:
+    print(repr(er))
+
+# Valid key, no cert
+try:
+    ssl.wrap_socket(io.BytesIO(), key=key)
+except TypeError as er:
+    print(repr(er))
+
+# Valid key, invalid cert
+try:
+    ssl.wrap_socket(io.BytesIO(), key=key, cert=b"!")
+except ValueError as er:
+    print(repr(er))
diff --git a/tests/extmod/ussl_keycert.py.exp b/tests/extmod/ussl_keycert.py.exp
new file mode 100644
index 0000000000000..b72d319c6a807
--- /dev/null
+++ b/tests/extmod/ussl_keycert.py.exp
@@ -0,0 +1,3 @@
+ValueError('invalid key',)
+TypeError("can't convert 'NoneType' object to str implicitly",)
+ValueError('invalid cert',)
diff --git a/tests/extmod/utimeq1.py b/tests/extmod/utimeq1.py
index dc7f3b6600404..234d7a31dd4a5 100644
--- a/tests/extmod/utimeq1.py
+++ b/tests/extmod/utimeq1.py
@@ -13,12 +13,17 @@
 MODULO_HALF = MAX // 2 + 1
 
 if DEBUG:
+
     def dprint(*v):
         print(*v)
+
+
 else:
+
     def dprint(*v):
         pass
 
+
 # Try not to crash on invalid data
 h = utimeq(10)
 try:
@@ -69,22 +74,25 @@ def dprint(*v):
 except IndexError:
     pass
 
+
 def pop_all(h):
     l = []
     while h:
         item = [0, 0, 0]
         h.pop(item)
-        #print("!", item)
+        # print("!", item)
         l.append(tuple(item))
     dprint(l)
     return l
 
+
 def add(h, v):
     h.push(v, 0, 0)
     dprint("-----")
-    #h.dump()
+    # h.dump()
     dprint("-----")
 
+
 h = utimeq(10)
 add(h, 0)
 add(h, MAX)
@@ -98,6 +106,7 @@ def add(h, v):
     diff = ticks_diff(l[i + 1][0], l[i][0])
     assert diff > 0
 
+
 def edge_case(edge, offset):
     h = utimeq(10)
     add(h, ticks_add(0, offset))
@@ -108,6 +117,7 @@ def edge_case(edge, offset):
     dprint(diff, diff > 0)
     return diff
 
+
 dprint("===")
 diff = edge_case(MODULO_HALF - 1, 0)
 assert diff == MODULO_HALF - 1
diff --git a/tests/extmod/uzlib_decompio.py b/tests/extmod/uzlib_decompio.py
index 112a82597638a..6a0aae8bcdf63 100644
--- a/tests/extmod/uzlib_decompio.py
+++ b/tests/extmod/uzlib_decompio.py
@@ -7,7 +7,7 @@
 
 
 # Raw DEFLATE bitstream
-buf = io.BytesIO(b'\xcbH\xcd\xc9\xc9\x07\x00')
+buf = io.BytesIO(b"\xcbH\xcd\xc9\xc9\x07\x00")
 inp = zlib.DecompIO(buf, -8)
 print(buf.seek(0, 1))
 print(inp.read(1))
@@ -21,12 +21,12 @@
 
 
 # zlib bitstream
-inp = zlib.DecompIO(io.BytesIO(b'x\x9c30\xa0=\x00\x00\xb3q\x12\xc1'))
+inp = zlib.DecompIO(io.BytesIO(b"x\x9c30\xa0=\x00\x00\xb3q\x12\xc1"))
 print(inp.read(10))
 print(inp.read())
 
 # zlib bitstream, wrong checksum
-inp = zlib.DecompIO(io.BytesIO(b'x\x9c30\xa0=\x00\x00\xb3q\x12\xc0'))
+inp = zlib.DecompIO(io.BytesIO(b"x\x9c30\xa0=\x00\x00\xb3q\x12\xc0"))
 try:
     print(inp.read())
 except OSError as e:
diff --git a/tests/extmod/uzlib_decompio_gz.py b/tests/extmod/uzlib_decompio_gz.py
index 02087f76392a7..1bc8ba885ba54 100644
--- a/tests/extmod/uzlib_decompio_gz.py
+++ b/tests/extmod/uzlib_decompio_gz.py
@@ -7,7 +7,9 @@
 
 
 # gzip bitstream
-buf = io.BytesIO(b'\x1f\x8b\x08\x08\x99\x0c\xe5W\x00\x03hello\x00\xcbH\xcd\xc9\xc9\x07\x00\x86\xa6\x106\x05\x00\x00\x00')
+buf = io.BytesIO(
+    b"\x1f\x8b\x08\x08\x99\x0c\xe5W\x00\x03hello\x00\xcbH\xcd\xc9\xc9\x07\x00\x86\xa6\x106\x05\x00\x00\x00"
+)
 inp = zlib.DecompIO(buf, 16 + 8)
 print(buf.seek(0, 1))
 print(inp.read(1))
@@ -20,24 +22,32 @@
 print(buf.seek(0, 1))
 
 # Check FHCRC field
-buf = io.BytesIO(b'\x1f\x8b\x08\x02\x99\x0c\xe5W\x00\x03\x00\x00\xcbH\xcd\xc9\xc9\x07\x00\x86\xa6\x106\x05\x00\x00\x00')
+buf = io.BytesIO(
+    b"\x1f\x8b\x08\x02\x99\x0c\xe5W\x00\x03\x00\x00\xcbH\xcd\xc9\xc9\x07\x00\x86\xa6\x106\x05\x00\x00\x00"
+)
 inp = zlib.DecompIO(buf, 16 + 8)
 print(inp.read())
 
 # Check FEXTRA field
-buf = io.BytesIO(b'\x1f\x8b\x08\x04\x99\x0c\xe5W\x00\x03\x01\x00X\xcbH\xcd\xc9\xc9\x07\x00\x86\xa6\x106\x05\x00\x00\x00')
+buf = io.BytesIO(
+    b"\x1f\x8b\x08\x04\x99\x0c\xe5W\x00\x03\x01\x00X\xcbH\xcd\xc9\xc9\x07\x00\x86\xa6\x106\x05\x00\x00\x00"
+)
 inp = zlib.DecompIO(buf, 16 + 8)
 print(inp.read())
 
 # broken header
-buf = io.BytesIO(b'\x1f\x8c\x08\x08\x99\x0c\xe5W\x00\x03hello\x00\xcbH\xcd\xc9\xc9\x07\x00\x86\xa6\x106\x05\x00\x00\x00')
+buf = io.BytesIO(
+    b"\x1f\x8c\x08\x08\x99\x0c\xe5W\x00\x03hello\x00\xcbH\xcd\xc9\xc9\x07\x00\x86\xa6\x106\x05\x00\x00\x00"
+)
 try:
     inp = zlib.DecompIO(buf, 16 + 8)
 except ValueError:
     print("ValueError")
 
 # broken crc32
-buf = io.BytesIO(b'\x1f\x8b\x08\x08\x99\x0c\xe5W\x00\x03hello\x00\xcbH\xcd\xc9\xc9\x07\x00\x86\xa7\x106\x05\x00\x00\x00')
+buf = io.BytesIO(
+    b"\x1f\x8b\x08\x08\x99\x0c\xe5W\x00\x03hello\x00\xcbH\xcd\xc9\xc9\x07\x00\x86\xa7\x106\x05\x00\x00\x00"
+)
 inp = zlib.DecompIO(buf, 16 + 8)
 try:
     inp.read(6)
@@ -45,6 +55,6 @@
     print(repr(e))
 
 # broken uncompressed size - not checked so far
-#buf = io.BytesIO(b'\x1f\x8b\x08\x08\x99\x0c\xe5W\x00\x03hello\x00\xcbH\xcd\xc9\xc9\x07\x00\x86\xa6\x106\x06\x00\x00\x00')
-#inp = zlib.DecompIO(buf, 16 + 8)
-#inp.read(6)
+# buf = io.BytesIO(b'\x1f\x8b\x08\x08\x99\x0c\xe5W\x00\x03hello\x00\xcbH\xcd\xc9\xc9\x07\x00\x86\xa6\x106\x06\x00\x00\x00')
+# inp = zlib.DecompIO(buf, 16 + 8)
+# inp.read(6)
diff --git a/tests/extmod/uzlib_decompress.py b/tests/extmod/uzlib_decompress.py
index dd6e4876fa345..8d4a9640b471f 100644
--- a/tests/extmod/uzlib_decompress.py
+++ b/tests/extmod/uzlib_decompress.py
@@ -9,15 +9,24 @@
 
 PATTERNS = [
     # Packed results produced by CPy's zlib.compress()
-    (b'0', b'x\x9c3\x00\x00\x001\x001'),
-    (b'a', b'x\x9cK\x04\x00\x00b\x00b'),
-    (b'0' * 100, b'x\x9c30\xa0=\x00\x00\xb3q\x12\xc1'),
-    (bytes(range(64)), b'x\x9cc`dbfaec\xe7\xe0\xe4\xe2\xe6\xe1\xe5\xe3\x17\x10\x14\x12\x16\x11\x15\x13\x97\x90\x94\x92\x96\x91\x95\x93WPTRVQUS\xd7\xd0\xd4\xd2\xd6\xd1\xd5\xd370426153\xb7\xb0\xb4\xb2\xb6\xb1\xb5\xb3\x07\x00\xaa\xe0\x07\xe1'),
-    (b'hello', b'x\x01\x01\x05\x00\xfa\xffhello\x06,\x02\x15'), # compression level 0
+    (b"0", b"x\x9c3\x00\x00\x001\x001"),
+    (b"a", b"x\x9cK\x04\x00\x00b\x00b"),
+    (b"0" * 100, b"x\x9c30\xa0=\x00\x00\xb3q\x12\xc1"),
+    (
+        bytes(range(64)),
+        b"x\x9cc`dbfaec\xe7\xe0\xe4\xe2\xe6\xe1\xe5\xe3\x17\x10\x14\x12\x16\x11\x15\x13\x97\x90\x94\x92\x96\x91\x95\x93WPTRVQUS\xd7\xd0\xd4\xd2\xd6\xd1\xd5\xd370426153\xb7\xb0\xb4\xb2\xb6\xb1\xb5\xb3\x07\x00\xaa\xe0\x07\xe1",
+    ),
+    (b"hello", b"x\x01\x01\x05\x00\xfa\xffhello\x06,\x02\x15"),  # compression level 0
     # adaptive/dynamic huffman tree
-    (b'13371813150|13764518736|12345678901', b'x\x9c\x05\xc1\x81\x01\x000\x04\x04\xb1\x95\\\x1f\xcfn\x86o\x82d\x06Qq\xc8\x9d\xc5X}<e\xb5g\x83\x0f\x89X\x07\xab'),
+    (
+        b"13371813150|13764518736|12345678901",
+        b"x\x9c\x05\xc1\x81\x01\x000\x04\x04\xb1\x95\\\x1f\xcfn\x86o\x82d\x06Qq\xc8\x9d\xc5X}<e\xb5g\x83\x0f\x89X\x07\xab",
+    ),
     # dynamic Huffman tree with "case 17" (repeat code for 3-10 times)
-    (b'>I}\x00\x951D>I}\x00\x951D>I}\x00\x951D>I}\x00\x951D', b'x\x9c\x05\xc11\x01\x00\x00\x00\x010\x95\x14py\x84\x12C_\x9bR\x8cV\x8a\xd1J1Z)F\x1fw`\x089'),
+    (
+        b">I}\x00\x951D>I}\x00\x951D>I}\x00\x951D>I}\x00\x951D",
+        b"x\x9c\x05\xc11\x01\x00\x00\x00\x010\x95\x14py\x84\x12C_\x9bR\x8cV\x8a\xd1J1Z)F\x1fw`\x089",
+    ),
 ]
 
 for unpacked, packed in PATTERNS:
@@ -26,26 +35,26 @@
 
 
 # Raw DEFLATE bitstream
-v = b'\xcbH\xcd\xc9\xc9\x07\x00'
+v = b"\xcbH\xcd\xc9\xc9\x07\x00"
 exp = b"hello"
 out = zlib.decompress(v, -15)
-assert(out == exp)
+assert out == exp
 print(exp)
 # Even when you ask CPython zlib.compress to produce Raw DEFLATE stream,
 # it returns it with adler2 and oriignal size appended, as if it was a
 # zlib stream. Make sure there're no random issues decompressing such.
-v = b'\xcbH\xcd\xc9\xc9\x07\x00\x86\xa6\x106\x05\x00\x00\x00'
+v = b"\xcbH\xcd\xc9\xc9\x07\x00\x86\xa6\x106\x05\x00\x00\x00"
 out = zlib.decompress(v, -15)
-assert(out == exp)
+assert out == exp
 
 # this should error
 try:
-    zlib.decompress(b'abc')
+    zlib.decompress(b"abc")
 except Exception:
     print("Exception")
 
 # invalid block type
 try:
-    zlib.decompress(b'\x07', -15) # final-block, block-type=3 (invalid)
+    zlib.decompress(b"\x07", -15)  # final-block, block-type=3 (invalid)
 except Exception as er:
-    print('Exception')
+    print("Exception")
diff --git a/tests/extmod/vfs_basic.py b/tests/extmod/vfs_basic.py
index fbcc92bade711..62b2a277381d6 100644
--- a/tests/extmod/vfs_basic.py
+++ b/tests/extmod/vfs_basic.py
@@ -2,6 +2,7 @@
 
 try:
     import uos
+
     uos.mount
 except (ImportError, AttributeError):
     print("SKIP")
@@ -9,57 +10,72 @@
 
 
 class Filesystem:
-    def __init__(self, id):
+    def __init__(self, id, fail=0):
         self.id = id
+        self.fail = fail
+
     def mount(self, readonly, mkfs):
-        print(self.id, 'mount', readonly, mkfs)
+        print(self.id, "mount", readonly, mkfs)
+
     def umount(self):
-        print(self.id, 'umount')
+        print(self.id, "umount")
+
     def ilistdir(self, dir):
-        print(self.id, 'ilistdir', dir)
-        return iter([('a%d' % self.id, 0, 0)])
+        print(self.id, "ilistdir", dir)
+        return iter([("a%d" % self.id, 0, 0)])
+
     def chdir(self, dir):
-        print(self.id, 'chdir', dir)
+        print(self.id, "chdir", dir)
+        if self.fail:
+            raise OSError(self.fail)
+
     def getcwd(self):
-        print(self.id, 'getcwd')
-        return 'dir%d' % self.id
+        print(self.id, "getcwd")
+        return "dir%d" % self.id
+
     def mkdir(self, path):
-        print(self.id, 'mkdir', path)
+        print(self.id, "mkdir", path)
+
     def remove(self, path):
-        print(self.id, 'remove', path)
+        print(self.id, "remove", path)
+
     def rename(self, old_path, new_path):
-        print(self.id, 'rename', old_path, new_path)
+        print(self.id, "rename", old_path, new_path)
+
     def rmdir(self, path):
-        print(self.id, 'rmdir', path)
+        print(self.id, "rmdir", path)
+
     def stat(self, path):
-        print(self.id, 'stat', path)
+        print(self.id, "stat", path)
         return (self.id,)
+
     def statvfs(self, path):
-        print(self.id, 'statvfs', path)
+        print(self.id, "statvfs", path)
         return (self.id,)
+
     def open(self, file, mode):
-        print(self.id, 'open', file, mode)
+        print(self.id, "open", file, mode)
 
 
 # first we umount any existing mount points the target may have
 try:
-    uos.umount('/')
+    uos.umount("/")
 except OSError:
     pass
-for path in uos.listdir('/'):
-    uos.umount('/' + path)
+for path in uos.listdir("/"):
+    uos.umount("/" + path)
 
 # stat root dir
-print(uos.stat('/'))
+print(uos.stat("/"))
 
 # statvfs root dir; verify that f_namemax has a sensible size
-print(uos.statvfs('/')[9] >= 32)
+print(uos.statvfs("/")[9] >= 32)
 
 # getcwd when in root dir
 print(uos.getcwd())
 
 # basic mounting and listdir
-uos.mount(Filesystem(1), '/test_mnt')
+uos.mount(Filesystem(1), "/test_mnt")
 print(uos.listdir())
 
 # ilistdir
@@ -68,80 +84,95 @@ def open(self, file, mode):
 try:
     next(i)
 except StopIteration:
-    print('StopIteration')
+    print("StopIteration")
 try:
     next(i)
 except StopIteration:
-    print('StopIteration')
+    print("StopIteration")
 
 # referencing the mount point in different ways
-print(uos.listdir('test_mnt'))
-print(uos.listdir('/test_mnt'))
+print(uos.listdir("test_mnt"))
+print(uos.listdir("/test_mnt"))
 
 # mounting another filesystem
-uos.mount(Filesystem(2), '/test_mnt2', readonly=True)
+uos.mount(Filesystem(2), "/test_mnt2", readonly=True)
 print(uos.listdir())
-print(uos.listdir('/test_mnt2'))
+print(uos.listdir("/test_mnt2"))
 
 # mounting over an existing mount point
 try:
-    uos.mount(Filesystem(3), '/test_mnt2')
+    uos.mount(Filesystem(3), "/test_mnt2")
 except OSError:
-    print('OSError')
+    print("OSError")
 
 # mkdir of a mount point
 try:
-    uos.mkdir('/test_mnt')
+    uos.mkdir("/test_mnt")
 except OSError:
-    print('OSError')
+    print("OSError")
 
 # rename across a filesystem
 try:
-    uos.rename('/test_mnt/a', '/test_mnt2/b')
+    uos.rename("/test_mnt/a", "/test_mnt2/b")
 except OSError:
-    print('OSError')
+    print("OSError")
 
 # delegating to mounted filesystem
-uos.chdir('test_mnt')
+uos.chdir("test_mnt")
 print(uos.listdir())
 print(uos.getcwd())
-uos.mkdir('test_dir')
-uos.remove('test_file')
-uos.rename('test_file', 'test_file2')
-uos.rmdir('test_dir')
-print(uos.stat('test_file'))
-print(uos.statvfs('/test_mnt'))
-open('test_file')
-open('test_file', 'wb')
+uos.mkdir("test_dir")
+uos.remove("test_file")
+uos.rename("test_file", "test_file2")
+uos.rmdir("test_dir")
+print(uos.stat("test_file"))
+print(uos.statvfs("/test_mnt"))
+open("test_file")
+open("test_file", "wb")
 
 # umount
-uos.umount('/test_mnt')
-uos.umount('/test_mnt2')
+uos.umount("/test_mnt")
+uos.umount("/test_mnt2")
 
 # umount a non-existent mount point
 try:
-    uos.umount('/test_mnt')
+    uos.umount("/test_mnt")
 except OSError:
-    print('OSError')
+    print("OSError")
 
 # root dir
-uos.mount(Filesystem(3), '/')
-print(uos.stat('/'))
-print(uos.statvfs('/'))
+uos.mount(Filesystem(3), "/")
+print(uos.stat("/"))
+print(uos.statvfs("/"))
 print(uos.listdir())
-open('test')
+open("test")
 
-uos.mount(Filesystem(4), '/mnt')
+uos.mount(Filesystem(4), "/mnt")
 print(uos.listdir())
-print(uos.listdir('/mnt'))
-uos.chdir('/mnt')
+print(uos.listdir("/mnt"))
+uos.chdir("/mnt")
 print(uos.listdir())
 
 # chdir to a subdir within root-mounted vfs, and then listdir
-uos.chdir('/subdir')
+uos.chdir("/subdir")
 print(uos.listdir())
-uos.chdir('/')
+uos.chdir("/")
+
+uos.umount("/")
+print(uos.listdir("/"))
+uos.umount("/mnt")
+
+# chdir to a non-existent mount point (current directory should remain unchanged)
+try:
+    uos.chdir("/foo")
+except OSError:
+    print("OSError")
+print(uos.getcwd())
 
-uos.umount('/')
-print(uos.listdir('/'))
-uos.umount('/mnt')
+# chdir to a non-existent subdirectory in a mounted filesystem
+uos.mount(Filesystem(5, 1), "/mnt")
+try:
+    uos.chdir("/mnt/subdir")
+except OSError:
+    print("OSError")
+print(uos.getcwd())
diff --git a/tests/extmod/vfs_basic.py.exp b/tests/extmod/vfs_basic.py.exp
index 0ae2c2cc975c4..ebca31030451b 100644
--- a/tests/extmod/vfs_basic.py.exp
+++ b/tests/extmod/vfs_basic.py.exp
@@ -58,3 +58,9 @@ OSError
 3 umount
 ['mnt']
 4 umount
+OSError
+/
+5 mount False False
+5 chdir /subdir
+OSError
+/
diff --git a/tests/extmod/vfs_blockdev.py b/tests/extmod/vfs_blockdev.py
new file mode 100644
index 0000000000000..e24169ba93689
--- /dev/null
+++ b/tests/extmod/vfs_blockdev.py
@@ -0,0 +1,74 @@
+# Test for behaviour of combined standard and extended block device
+
+try:
+    import uos
+
+    uos.VfsFat
+    uos.VfsLfs2
+except (ImportError, AttributeError):
+    print("SKIP")
+    raise SystemExit
+
+
+class RAMBlockDevice:
+    ERASE_BLOCK_SIZE = 512
+
+    def __init__(self, blocks):
+        self.data = bytearray(blocks * self.ERASE_BLOCK_SIZE)
+
+    def readblocks(self, block, buf, off=0):
+        addr = block * self.ERASE_BLOCK_SIZE + off
+        for i in range(len(buf)):
+            buf[i] = self.data[addr + i]
+
+    def writeblocks(self, block, buf, off=None):
+        if off is None:
+            # erase, then write
+            off = 0
+        addr = block * self.ERASE_BLOCK_SIZE + off
+        for i in range(len(buf)):
+            self.data[addr + i] = buf[i]
+
+    def ioctl(self, op, arg):
+        if op == 4:  # block count
+            return len(self.data) // self.ERASE_BLOCK_SIZE
+        if op == 5:  # block size
+            return self.ERASE_BLOCK_SIZE
+        if op == 6:  # erase block
+            return 0
+
+
+def test(bdev, vfs_class):
+    print("test", vfs_class)
+
+    # mkfs
+    vfs_class.mkfs(bdev)
+
+    # construction
+    vfs = vfs_class(bdev)
+
+    # statvfs
+    print(vfs.statvfs("/"))
+
+    # open, write close
+    f = vfs.open("test", "w")
+    for i in range(10):
+        f.write("some data")
+    f.close()
+
+    # ilistdir
+    print(list(vfs.ilistdir()))
+
+    # read
+    with vfs.open("test", "r") as f:
+        print(f.read())
+
+
+try:
+    bdev = RAMBlockDevice(50)
+except MemoryError:
+    print("SKIP")
+    raise SystemExit
+
+test(bdev, uos.VfsFat)
+test(bdev, uos.VfsLfs2)
diff --git a/tests/extmod/vfs_blockdev.py.exp b/tests/extmod/vfs_blockdev.py.exp
new file mode 100644
index 0000000000000..a254133131158
--- /dev/null
+++ b/tests/extmod/vfs_blockdev.py.exp
@@ -0,0 +1,8 @@
+test <class 'VfsFat'>
+(512, 512, 16, 16, 16, 0, 0, 0, 0, 255)
+[('test', 32768, 0, 90)]
+some datasome datasome datasome datasome datasome datasome datasome datasome datasome data
+test <class 'VfsLfs2'>
+(512, 512, 50, 48, 48, 0, 0, 0, 0, 255)
+[('test', 32768, 0, 90)]
+some datasome datasome datasome datasome datasome datasome datasome datasome datasome data
diff --git a/tests/extmod/vfs_fat_fileio1.py b/tests/extmod/vfs_fat_fileio1.py
index 51cd765222cd0..e42911093f402 100644
--- a/tests/extmod/vfs_fat_fileio1.py
+++ b/tests/extmod/vfs_fat_fileio1.py
@@ -20,20 +20,20 @@ def __init__(self, blocks):
         self.data = bytearray(blocks * self.SEC_SIZE)
 
     def readblocks(self, n, buf):
-        #print("readblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
+        # print("readblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
         for i in range(len(buf)):
             buf[i] = self.data[n * self.SEC_SIZE + i]
 
     def writeblocks(self, n, buf):
-        #print("writeblocks(%s, %x)" % (n, id(buf)))
+        # print("writeblocks(%s, %x)" % (n, id(buf)))
         for i in range(len(buf)):
             self.data[n * self.SEC_SIZE + i] = buf[i]
 
     def ioctl(self, op, arg):
-        #print("ioctl(%d, %r)" % (op, arg))
-        if op == 4:  # BP_IOCTL_SEC_COUNT
+        # print("ioctl(%d, %r)" % (op, arg))
+        if op == 4:  # MP_BLOCKDEV_IOCTL_BLOCK_COUNT
             return len(self.data) // self.SEC_SIZE
-        if op == 5:  # BP_IOCTL_SEC_SIZE
+        if op == 5:  # MP_BLOCKDEV_IOCTL_BLOCK_SIZE
             return self.SEC_SIZE
 
 
@@ -45,8 +45,8 @@ def ioctl(self, op, arg):
 
 uos.VfsFat.mkfs(bdev)
 vfs = uos.VfsFat(bdev)
-uos.mount(vfs, '/ramdisk')
-uos.chdir('/ramdisk')
+uos.mount(vfs, "/ramdisk")
+uos.chdir("/ramdisk")
 
 # file IO
 f = open("foo_file.txt", "w")
@@ -54,7 +54,7 @@ def ioctl(self, op, arg):
 f.write("hello!")
 f.flush()
 f.close()
-f.close() # allowed
+f.close()  # allowed
 try:
     f.write("world!")
 except OSError as e:
@@ -82,21 +82,21 @@ def ioctl(self, op, arg):
     print(f2.read())
     print(f2.tell())
 
-    f2.seek(0, 0) # SEEK_SET
+    f2.seek(0, 0)  # SEEK_SET
     print(f2.read(1))
 
-    f2.seek(0, 1) # SEEK_CUR
+    f2.seek(0, 1)  # SEEK_CUR
     print(f2.read(1))
-    f2.seek(2, 1) # SEEK_CUR
+    f2.seek(2, 1)  # SEEK_CUR
     print(f2.read(1))
 
-    f2.seek(-2, 2) # SEEK_END
+    f2.seek(-2, 2)  # SEEK_END
     print(f2.read(1))
 
 # using constructor of FileIO type to open a file
 # no longer working with new VFS sub-system
-#FileIO = type(f)
-#with FileIO("/ramdisk/foo_file.txt") as f:
+# FileIO = type(f)
+# with FileIO("/ramdisk/foo_file.txt") as f:
 #    print(f.read())
 
 # dirs
@@ -105,33 +105,7 @@ def ioctl(self, op, arg):
 try:
     vfs.rmdir("foo_file.txt")
 except OSError as e:
-    print(e.args[0] == 20) # uerrno.ENOTDIR
+    print(e.args[0] == 20)  # uerrno.ENOTDIR
 
 vfs.remove("foo_file.txt")
 print(list(vfs.ilistdir()))
-
-# Here we test that opening a file with the heap locked fails correctly.  This
-# is a special case because file objects use a finaliser and allocating with a
-# finaliser is a different path to normal allocation.  It would be better to
-# test this in the core tests but there are no core objects that use finaliser.
-import micropython
-micropython.heap_lock()
-try:
-    vfs.open('x', 'r')
-except MemoryError:
-    print('MemoryError')
-micropython.heap_unlock()
-
-# Here we test that the finaliser is actually called during a garbage collection.
-import gc
-N = 4
-for i in range(N):
-    n = 'x%d' % i
-    f = vfs.open(n, 'w')
-    f.write(n)
-    f = None # release f without closing
-    [0, 1, 2, 3] # use up Python stack so f is really gone
-gc.collect() # should finalise all N files by closing them
-for i in range(N):
-    with vfs.open('x%d' % i, 'r') as f:
-        print(f.read())
diff --git a/tests/extmod/vfs_fat_fileio1.py.exp b/tests/extmod/vfs_fat_fileio1.py.exp
index 4eb50402c45e9..8da96e16bddd0 100644
--- a/tests/extmod/vfs_fat_fileio1.py.exp
+++ b/tests/extmod/vfs_fat_fileio1.py.exp
@@ -11,8 +11,3 @@ o
 d
 True
 [('foo_dir', 16384, 0, 0)]
-MemoryError
-x0
-x1
-x2
-x3
diff --git a/tests/extmod/vfs_fat_fileio2.py b/tests/extmod/vfs_fat_fileio2.py
index 9b9a11e435b7f..a9cea2bed8346 100644
--- a/tests/extmod/vfs_fat_fileio2.py
+++ b/tests/extmod/vfs_fat_fileio2.py
@@ -20,20 +20,20 @@ def __init__(self, blocks):
         self.data = bytearray(blocks * self.SEC_SIZE)
 
     def readblocks(self, n, buf):
-        #print("readblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
+        # print("readblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
         for i in range(len(buf)):
             buf[i] = self.data[n * self.SEC_SIZE + i]
 
     def writeblocks(self, n, buf):
-        #print("writeblocks(%s, %x)" % (n, id(buf)))
+        # print("writeblocks(%s, %x)" % (n, id(buf)))
         for i in range(len(buf)):
             self.data[n * self.SEC_SIZE + i] = buf[i]
 
     def ioctl(self, op, arg):
-        #print("ioctl(%d, %r)" % (op, arg))
-        if op == 4:  # BP_IOCTL_SEC_COUNT
+        # print("ioctl(%d, %r)" % (op, arg))
+        if op == 4:  # MP_BLOCKDEV_IOCTL_BLOCK_COUNT
             return len(self.data) // self.SEC_SIZE
-        if op == 5:  # BP_IOCTL_SEC_SIZE
+        if op == 5:  # MP_BLOCKDEV_IOCTL_BLOCK_SIZE
             return self.SEC_SIZE
 
 
@@ -45,8 +45,8 @@ def ioctl(self, op, arg):
 
 uos.VfsFat.mkfs(bdev)
 vfs = uos.VfsFat(bdev)
-uos.mount(vfs, '/ramdisk')
-uos.chdir('/ramdisk')
+uos.mount(vfs, "/ramdisk")
+uos.chdir("/ramdisk")
 
 try:
     vfs.mkdir("foo_dir")
@@ -111,4 +111,4 @@ def ioctl(self, op, arg):
     f = open("large_file.txt", "wb")
     f.write(bytearray(bsize * free))
 except OSError as e:
-    print("ENOSPC:", e.args[0] == 28) # uerrno.ENOSPC
+    print("ENOSPC:", e.args[0] == 28)  # uerrno.ENOSPC
diff --git a/tests/extmod/vfs_fat_finaliser.py b/tests/extmod/vfs_fat_finaliser.py
new file mode 100644
index 0000000000000..e30f42f8471f5
--- /dev/null
+++ b/tests/extmod/vfs_fat_finaliser.py
@@ -0,0 +1,69 @@
+# Test VfsFat class and its finaliser
+
+try:
+    import uerrno, uos
+
+    uos.VfsFat
+except (ImportError, AttributeError):
+    print("SKIP")
+    raise SystemExit
+
+
+class RAMBlockDevice:
+    def __init__(self, blocks, sec_size=512):
+        self.sec_size = sec_size
+        self.data = bytearray(blocks * self.sec_size)
+
+    def readblocks(self, n, buf):
+        for i in range(len(buf)):
+            buf[i] = self.data[n * self.sec_size + i]
+
+    def writeblocks(self, n, buf):
+        for i in range(len(buf)):
+            self.data[n * self.sec_size + i] = buf[i]
+
+    def ioctl(self, op, arg):
+        if op == 4:  # MP_BLOCKDEV_IOCTL_BLOCK_COUNT
+            return len(self.data) // self.sec_size
+        if op == 5:  # MP_BLOCKDEV_IOCTL_BLOCK_SIZE
+            return self.sec_size
+
+
+# Create block device, and skip test if not enough RAM
+try:
+    bdev = RAMBlockDevice(50)
+except MemoryError:
+    print("SKIP")
+    raise SystemExit
+
+# Format block device and create VFS object
+uos.VfsFat.mkfs(bdev)
+vfs = uos.VfsFat(bdev)
+
+# Here we test that opening a file with the heap locked fails correctly.  This
+# is a special case because file objects use a finaliser and allocating with a
+# finaliser is a different path to normal allocation.  It would be better to
+# test this in the core tests but there are no core objects that use finaliser.
+import micropython
+
+micropython.heap_lock()
+try:
+    vfs.open("x", "r")
+except MemoryError:
+    print("MemoryError")
+micropython.heap_unlock()
+
+# Here we test that the finaliser is actually called during a garbage collection.
+import gc
+
+N = 4
+for i in range(N):
+    n = "x%d" % i
+    f = vfs.open(n, "w")
+    f.write(n)
+    f = None  # release f without closing
+    [0, 1, 2, 3]  # use up Python stack so f is really gone
+gc.collect()  # should finalise all N files by closing them
+for i in range(N):
+    with vfs.open("x%d" % i, "r") as f:
+        print(f.read())
diff --git a/tests/extmod/vfs_fat_finaliser.py.exp b/tests/extmod/vfs_fat_finaliser.py.exp
new file mode 100644
index 0000000000000..cc51daf2a3435
--- /dev/null
+++ b/tests/extmod/vfs_fat_finaliser.py.exp
@@ -0,0 +1,5 @@
+MemoryError
+x0
+x1
+x2
+x3
diff --git a/tests/extmod/vfs_fat_more.py b/tests/extmod/vfs_fat_more.py
index 488697fa856f1..d8449829deacb 100644
--- a/tests/extmod/vfs_fat_more.py
+++ b/tests/extmod/vfs_fat_more.py
@@ -19,20 +19,20 @@ def __init__(self, blocks):
         self.data = bytearray(blocks * self.SEC_SIZE)
 
     def readblocks(self, n, buf):
-        #print("readblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
+        # print("readblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
         for i in range(len(buf)):
             buf[i] = self.data[n * self.SEC_SIZE + i]
 
     def writeblocks(self, n, buf):
-        #print("writeblocks(%s, %x)" % (n, id(buf)))
+        # print("writeblocks(%s, %x)" % (n, id(buf)))
         for i in range(len(buf)):
             self.data[n * self.SEC_SIZE + i] = buf[i]
 
     def ioctl(self, op, arg):
-        #print("ioctl(%d, %r)" % (op, arg))
-        if op == 4:  # BP_IOCTL_SEC_COUNT
+        # print("ioctl(%d, %r)" % (op, arg))
+        if op == 4:  # MP_BLOCKDEV_IOCTL_BLOCK_COUNT
             return len(self.data) // self.SEC_SIZE
-        if op == 5:  # BP_IOCTL_SEC_SIZE
+        if op == 5:  # MP_BLOCKDEV_IOCTL_BLOCK_SIZE
             return self.SEC_SIZE
 
 
@@ -45,75 +45,76 @@ def ioctl(self, op, arg):
 
 # first we umount any existing mount points the target may have
 try:
-    uos.umount('/')
+    uos.umount("/")
 except OSError:
     pass
-for path in uos.listdir('/'):
-    uos.umount('/' + path)
+for path in uos.listdir("/"):
+    uos.umount("/" + path)
 
 uos.VfsFat.mkfs(bdev)
-uos.mount(bdev, '/')
+uos.mount(bdev, "/")
 
 print(uos.getcwd())
 
-f = open('test.txt', 'w')
-f.write('hello')
+f = open("test.txt", "w")
+f.write("hello")
 f.close()
 
 print(uos.listdir())
-print(uos.listdir('/'))
-print(uos.stat('')[:-3])
-print(uos.stat('/')[:-3])
-print(uos.stat('test.txt')[:-3])
-print(uos.stat('/test.txt')[:-3])
+print(uos.listdir("/"))
+print(uos.stat("")[:-3])
+print(uos.stat("/")[:-3])
+print(uos.stat("test.txt")[:-3])
+print(uos.stat("/test.txt")[:-3])
 
-f = open('/test.txt')
+f = open("/test.txt")
 print(f.read())
 f.close()
 
-uos.rename('test.txt', 'test2.txt')
+uos.rename("test.txt", "test2.txt")
 print(uos.listdir())
-uos.rename('test2.txt', '/test3.txt')
+uos.rename("test2.txt", "/test3.txt")
 print(uos.listdir())
-uos.rename('/test3.txt', 'test4.txt')
+uos.rename("/test3.txt", "test4.txt")
 print(uos.listdir())
-uos.rename('/test4.txt', '/test5.txt')
+uos.rename("/test4.txt", "/test5.txt")
 print(uos.listdir())
 
-uos.mkdir('dir')
+uos.mkdir("dir")
 print(uos.listdir())
-uos.mkdir('/dir2')
+uos.mkdir("/dir2")
 print(uos.listdir())
-uos.mkdir('dir/subdir')
-print(uos.listdir('dir'))
-for exist in ('', '/', 'dir', '/dir', 'dir/subdir'):
+uos.mkdir("dir/subdir")
+print(uos.listdir("dir"))
+for exist in ("", "/", "dir", "/dir", "dir/subdir"):
     try:
         uos.mkdir(exist)
     except OSError as er:
-        print('mkdir OSError', er.args[0] == 17) # EEXIST
+        print("mkdir OSError", er.args[0] == 17)  # EEXIST
 
-uos.chdir('/')
-print(uos.stat('test5.txt')[:-3])
+uos.chdir("/")
+print(uos.stat("test5.txt")[:-3])
 
 uos.VfsFat.mkfs(bdev2)
-uos.mount(bdev2, '/sys')
+uos.mount(bdev2, "/sys")
 print(uos.listdir())
-print(uos.listdir('sys'))
-print(uos.listdir('/sys'))
+print(uos.listdir("sys"))
+print(uos.listdir("/sys"))
 
-uos.rmdir('dir2')
-uos.remove('test5.txt')
+uos.rmdir("dir2")
+uos.remove("test5.txt")
 print(uos.listdir())
 
-uos.umount('/')
+uos.umount("/")
 print(uos.getcwd())
 print(uos.listdir())
-print(uos.listdir('sys'))
+print(uos.listdir("sys"))
 
 # test importing a file from a mounted FS
 import sys
+
 sys.path.clear()
-sys.path.append('/sys')
-with open('sys/test_module.py', 'w') as f:
+sys.path.append("/sys")
+with open("sys/test_module.py", "w") as f:
     f.write('print("test_module!")')
 import test_module
diff --git a/tests/extmod/vfs_fat_oldproto.py b/tests/extmod/vfs_fat_oldproto.py
index 3caaa368db009..93d00f9ce41ca 100644
--- a/tests/extmod/vfs_fat_oldproto.py
+++ b/tests/extmod/vfs_fat_oldproto.py
@@ -11,6 +11,7 @@
     print("SKIP")
     raise SystemExit
 
+
 class RAMFS_OLD:
 
     SEC_SIZE = 512
@@ -19,12 +20,12 @@ def __init__(self, blocks):
         self.data = bytearray(blocks * self.SEC_SIZE)
 
     def readblocks(self, n, buf):
-        #print("readblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
+        # print("readblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
         for i in range(len(buf)):
             buf[i] = self.data[n * self.SEC_SIZE + i]
 
     def writeblocks(self, n, buf):
-        #print("writeblocks(%s, %x)" % (n, id(buf)))
+        # print("writeblocks(%s, %x)" % (n, id(buf)))
         for i in range(len(buf)):
             self.data[n * self.SEC_SIZE + i] = buf[i]
 
diff --git a/tests/extmod/vfs_fat_ramdisk.py b/tests/extmod/vfs_fat_ramdisk.py
index f6e5c64df0533..5f758bf89c87a 100644
--- a/tests/extmod/vfs_fat_ramdisk.py
+++ b/tests/extmod/vfs_fat_ramdisk.py
@@ -20,20 +20,20 @@ def __init__(self, blocks):
         self.data = bytearray(blocks * self.SEC_SIZE)
 
     def readblocks(self, n, buf):
-        #print("readblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
+        # print("readblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
         for i in range(len(buf)):
             buf[i] = self.data[n * self.SEC_SIZE + i]
 
     def writeblocks(self, n, buf):
-        #print("writeblocks(%s, %x)" % (n, id(buf)))
+        # print("writeblocks(%s, %x)" % (n, id(buf)))
         for i in range(len(buf)):
             self.data[n * self.SEC_SIZE + i] = buf[i]
 
     def ioctl(self, op, arg):
-        #print("ioctl(%d, %r)" % (op, arg))
-        if op == 4:  # BP_IOCTL_SEC_COUNT
+        # print("ioctl(%d, %r)" % (op, arg))
+        if op == 4:  # MP_BLOCKDEV_IOCTL_BLOCK_COUNT
             return len(self.data) // self.SEC_SIZE
-        if op == 5:  # BP_IOCTL_SEC_SIZE
+        if op == 5:  # MP_BLOCKDEV_IOCTL_BLOCK_SIZE
             return self.SEC_SIZE
 
 
@@ -64,7 +64,7 @@ def ioctl(self, op, arg):
 print(list(vfs.ilistdir()))
 
 print("stat root:", vfs.stat("/"))
-print("stat file:", vfs.stat("foo_file.txt")[:-3]) # timestamps differ across runs
+print("stat file:", vfs.stat("foo_file.txt")[:-3])  # timestamps differ across runs
 
 print(b"FOO_FILETXT" in bdev.data)
 print(b"hello!" in bdev.data)
@@ -94,4 +94,4 @@ def ioctl(self, op, arg):
 try:
     vfs.ilistdir(b"no_exist")
 except OSError as e:
-    print('ENOENT:', e.args[0] == uerrno.ENOENT)
+    print("ENOENT:", e.args[0] == uerrno.ENOENT)
diff --git a/tests/extmod/vfs_fat_ramdisklarge.py b/tests/extmod/vfs_fat_ramdisklarge.py
index 6f95910315eab..69d4a8cbbda15 100644
--- a/tests/extmod/vfs_fat_ramdisklarge.py
+++ b/tests/extmod/vfs_fat_ramdisklarge.py
@@ -22,26 +22,26 @@ def __init__(self, blocks):
         self.data = {}
 
     def readblocks(self, n, buf):
-        #print("readblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
+        # print("readblocks(%s, %x(%d))" % (n, id(buf), len(buf)))
         assert len(buf) == self.SEC_SIZE
         if n not in self.data:
             self.data[n] = bytearray(self.SEC_SIZE)
         buf[:] = self.data[n]
 
     def writeblocks(self, n, buf):
-        #print("writeblocks(%s, %x)" % (n, id(buf)))
+        # print("writeblocks(%s, %x)" % (n, id(buf)))
         mv = memoryview(buf)
         for off in range(0, len(buf), self.SEC_SIZE):
             s = n + off // self.SEC_SIZE
             if s not in self.data:
                 self.data[s] = bytearray(self.SEC_SIZE)
-            self.data[s][:] = mv[off:off + self.SEC_SIZE]
+            self.data[s][:] = mv[off : off + self.SEC_SIZE]
 
     def ioctl(self, op, arg):
-        #print("ioctl(%d, %r)" % (op, arg))
-        if op == 4:  # BP_IOCTL_SEC_COUNT
+        # print("ioctl(%d, %r)" % (op, arg))
+        if op == 4:  # MP_BLOCKDEV_IOCTL_BLOCK_COUNT
             return self.blocks
-        if op == 5:  # BP_IOCTL_SEC_SIZE
+        if op == 5:  # MP_BLOCKDEV_IOCTL_BLOCK_SIZE
             return self.SEC_SIZE
 
 
@@ -57,13 +57,13 @@ def ioctl(self, op, arg):
 
 print("statvfs:", vfs.statvfs("/ramdisk"))
 
-f = open('/ramdisk/test.txt', 'w')
-f.write('test file')
+f = open("/ramdisk/test.txt", "w")
+f.write("test file")
 f.close()
 
 print("statvfs:", vfs.statvfs("/ramdisk"))
 
-f = open('/ramdisk/test.txt')
+f = open("/ramdisk/test.txt")
 print(f.read())
 f.close()
 
diff --git a/tests/extmod/vfs_lfs.py b/tests/extmod/vfs_lfs.py
new file mode 100644
index 0000000000000..609d9f949e17d
--- /dev/null
+++ b/tests/extmod/vfs_lfs.py
@@ -0,0 +1,149 @@
+# Test for VfsLittle using a RAM device
+
+try:
+    import uos
+
+    uos.VfsLfs1
+    uos.VfsLfs2
+except (ImportError, AttributeError):
+    print("SKIP")
+    raise SystemExit
+
+
+class RAMBlockDevice:
+    ERASE_BLOCK_SIZE = 1024
+
+    def __init__(self, blocks):
+        self.data = bytearray(blocks * self.ERASE_BLOCK_SIZE)
+
+    def readblocks(self, block, buf, off):
+        addr = block * self.ERASE_BLOCK_SIZE + off
+        for i in range(len(buf)):
+            buf[i] = self.data[addr + i]
+
+    def writeblocks(self, block, buf, off):
+        addr = block * self.ERASE_BLOCK_SIZE + off
+        for i in range(len(buf)):
+            self.data[addr + i] = buf[i]
+
+    def ioctl(self, op, arg):
+        if op == 4:  # block count
+            return len(self.data) // self.ERASE_BLOCK_SIZE
+        if op == 5:  # block size
+            return self.ERASE_BLOCK_SIZE
+        if op == 6:  # erase block
+            return 0
+
+
+def test(bdev, vfs_class):
+    print("test", vfs_class)
+
+    # mkfs
+    vfs_class.mkfs(bdev)
+
+    # construction
+    vfs = vfs_class(bdev)
+
+    # statvfs
+    print(vfs.statvfs("/"))
+
+    # open, write close
+    f = vfs.open("test", "w")
+    f.write("littlefs")
+    f.close()
+
+    # statvfs after creating a file
+    print(vfs.statvfs("/"))
+
+    # ilistdir
+    print(list(vfs.ilistdir()))
+    print(list(vfs.ilistdir("/")))
+    print(list(vfs.ilistdir(b"/")))
+
+    # mkdir, rmdir
+    vfs.mkdir("testdir")
+    print(list(vfs.ilistdir()))
+    print(sorted(list(vfs.ilistdir("testdir"))))
+    vfs.rmdir("testdir")
+    print(list(vfs.ilistdir()))
+    vfs.mkdir("testdir")
+
+    # stat a file
+    print(vfs.stat("test"))
+
+    # stat a dir (size seems to vary on LFS2 so don't print that)
+    print(vfs.stat("testdir")[:6])
+
+    # read
+    with vfs.open("test", "r") as f:
+        print(f.read())
+
+    # create large file
+    with vfs.open("testbig", "w") as f:
+        data = "large012" * 32 * 16
+        print("data length:", len(data))
+        for i in range(4):
+            print("write", i)
+            f.write(data)
+
+    # stat after creating large file
+    print(vfs.statvfs("/"))
+
+    # rename
+    vfs.rename("testbig", "testbig2")
+    print(sorted(list(vfs.ilistdir())))
+    vfs.chdir("testdir")
+    vfs.rename("/testbig2", "testbig2")
+    print(sorted(list(vfs.ilistdir())))
+    vfs.rename("testbig2", "/testbig2")
+    vfs.chdir("/")
+    print(sorted(list(vfs.ilistdir())))
+
+    # remove
+    vfs.remove("testbig2")
+    print(sorted(list(vfs.ilistdir())))
+
+    # getcwd, chdir
+    vfs.mkdir("/testdir2")
+    vfs.mkdir("/testdir/subdir")
+    print(vfs.getcwd())
+    vfs.chdir("/testdir")
+    print(vfs.getcwd())
+
+    # create file in directory to make sure paths are relative
+    vfs.open("test2", "w").close()
+    print(vfs.stat("test2"))
+    print(vfs.stat("/testdir/test2"))
+    vfs.remove("test2")
+
+    # chdir back to root and remove testdir
+    vfs.chdir("/")
+    print(vfs.getcwd())
+    vfs.chdir("testdir")
+    print(vfs.getcwd())
+    vfs.chdir("..")
+    print(vfs.getcwd())
+    vfs.chdir("testdir/subdir")
+    print(vfs.getcwd())
+    vfs.chdir("../..")
+    print(vfs.getcwd())
+    vfs.chdir("/./testdir2")
+    print(vfs.getcwd())
+    vfs.chdir("../testdir")
+    print(vfs.getcwd())
+    vfs.chdir("../..")
+    print(vfs.getcwd())
+    vfs.chdir(".//testdir")
+    print(vfs.getcwd())
+    vfs.chdir("subdir/./")
+    print(vfs.getcwd())
+    vfs.chdir("/")
+    print(vfs.getcwd())
+    vfs.rmdir("testdir/subdir")
+    vfs.rmdir("testdir")
+    vfs.rmdir("testdir2")
+
+
+bdev = RAMBlockDevice(30)
+test(bdev, uos.VfsLfs1)
+test(bdev, uos.VfsLfs2)
diff --git a/tests/extmod/vfs_lfs.py.exp b/tests/extmod/vfs_lfs.py.exp
new file mode 100644
index 0000000000000..a7025577449d0
--- /dev/null
+++ b/tests/extmod/vfs_lfs.py.exp
@@ -0,0 +1,74 @@
+test <class 'VfsLfs1'>
+(1024, 1024, 30, 26, 26, 0, 0, 0, 0, 255)
+(1024, 1024, 30, 25, 25, 0, 0, 0, 0, 255)
+[('test', 32768, 0, 8)]
+[('test', 32768, 0, 8)]
+[(b'test', 32768, 0, 8)]
+[('test', 32768, 0, 8), ('testdir', 16384, 0, 0)]
+[]
+[('test', 32768, 0, 8)]
+(32768, 0, 0, 0, 0, 0, 8, 0, 0, 0)
+(16384, 0, 0, 0, 0, 0)
+littlefs
+data length: 4096
+write 0
+write 1
+write 2
+write 3
+(1024, 1024, 30, 6, 6, 0, 0, 0, 0, 255)
+[('test', 32768, 0, 8), ('testbig2', 32768, 0, 16384), ('testdir', 16384, 0, 0)]
+[('testbig2', 32768, 0, 16384)]
+[('test', 32768, 0, 8), ('testbig2', 32768, 0, 16384), ('testdir', 16384, 0, 0)]
+[('test', 32768, 0, 8), ('testdir', 16384, 0, 0)]
+/
+/testdir
+(32768, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+(32768, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+/
+/testdir
+/
+/testdir/subdir
+/
+/testdir2
+/testdir
+/
+/testdir
+/testdir/subdir
+/
+test <class 'VfsLfs2'>
+(1024, 1024, 30, 28, 28, 0, 0, 0, 0, 255)
+(1024, 1024, 30, 28, 28, 0, 0, 0, 0, 255)
+[('test', 32768, 0, 8)]
+[('test', 32768, 0, 8)]
+[(b'test', 32768, 0, 8)]
+[('testdir', 16384, 0, 0), ('test', 32768, 0, 8)]
+[]
+[('test', 32768, 0, 8)]
+(32768, 0, 0, 0, 0, 0, 8, 0, 0, 0)
+(16384, 0, 0, 0, 0, 0)
+littlefs
+data length: 4096
+write 0
+write 1
+write 2
+write 3
+(1024, 1024, 30, 7, 7, 0, 0, 0, 0, 255)
+[('test', 32768, 0, 8), ('testbig2', 32768, 0, 16384), ('testdir', 16384, 0, 0)]
+[('testbig2', 32768, 0, 16384)]
+[('test', 32768, 0, 8), ('testbig2', 32768, 0, 16384), ('testdir', 16384, 0, 0)]
+[('test', 32768, 0, 8), ('testdir', 16384, 0, 0)]
+/
+/testdir
+(32768, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+(32768, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+/
+/testdir
+/
+/testdir/subdir
+/
+/testdir2
+/testdir
+/
+/testdir
+/testdir/subdir
+/
diff --git a/tests/extmod/vfs_lfs_corrupt.py b/tests/extmod/vfs_lfs_corrupt.py
new file mode 100644
index 0000000000000..330458709a37f
--- /dev/null
+++ b/tests/extmod/vfs_lfs_corrupt.py
@@ -0,0 +1,112 @@
+# Test for VfsLittle using a RAM device, testing error handling from corrupt block device
+
+try:
+    import uos
+
+    uos.VfsLfs1
+    uos.VfsLfs2
+except (ImportError, AttributeError):
+    print("SKIP")
+    raise SystemExit
+
+
+class RAMBlockDevice:
+    ERASE_BLOCK_SIZE = 1024
+
+    def __init__(self, blocks):
+        self.data = bytearray(blocks * self.ERASE_BLOCK_SIZE)
+        self.ret = 0
+
+    def readblocks(self, block, buf, off):
+        addr = block * self.ERASE_BLOCK_SIZE + off
+        for i in range(len(buf)):
+            buf[i] = self.data[addr + i]
+        return self.ret
+
+    def writeblocks(self, block, buf, off):
+        addr = block * self.ERASE_BLOCK_SIZE + off
+        for i in range(len(buf)):
+            self.data[addr + i] = buf[i]
+        return self.ret
+
+    def ioctl(self, op, arg):
+        if op == 4:  # block count
+            return len(self.data) // self.ERASE_BLOCK_SIZE
+        if op == 5:  # block size
+            return self.ERASE_BLOCK_SIZE
+        if op == 6:  # erase block
+            return 0
+
+
+def corrupt(bdev, block):
+    addr = block * bdev.ERASE_BLOCK_SIZE
+    for i in range(bdev.ERASE_BLOCK_SIZE):
+        bdev.data[addr + i] = i & 0xFF
+
+
+def create_vfs(bdev, vfs_class):
+    bdev.ret = 0
+    vfs_class.mkfs(bdev)
+    vfs = vfs_class(bdev)
+    with vfs.open("f", "w") as f:
+        for i in range(100):
+            f.write("test")
+    return vfs
+
+
+def test(bdev, vfs_class):
+    print("test", vfs_class)
+
+    # statvfs
+    vfs = create_vfs(bdev, vfs_class)
+    corrupt(bdev, 0)
+    corrupt(bdev, 1)
+    try:
+        print(vfs.statvfs(""))
+    except OSError:
+        print("statvfs OSError")
+
+    # error during read
+    vfs = create_vfs(bdev, vfs_class)
+    f = vfs.open("f", "r")
+    bdev.ret = -5  # EIO
+    try:
+        f.read(10)
+    except OSError:
+        print("read OSError")
+
+    # error during write
+    vfs = create_vfs(bdev, vfs_class)
+    f = vfs.open("f", "a")
+    bdev.ret = -5  # EIO
+    try:
+        f.write("test")
+    except OSError:
+        print("write OSError")
+
+    # error during close
+    vfs = create_vfs(bdev, vfs_class)
+    f = vfs.open("f", "w")
+    f.write("test")
+    bdev.ret = -5  # EIO
+    try:
+        f.close()
+    except OSError:
+        print("close OSError")
+
+    # error during flush
+    vfs = create_vfs(bdev, vfs_class)
+    f = vfs.open("f", "w")
+    f.write("test")
+    bdev.ret = -5  # EIO
+    try:
+        f.flush()
+    except OSError:
+        print("flush OSError")
+    bdev.ret = 0
+    f.close()
+
+
+bdev = RAMBlockDevice(30)
+test(bdev, uos.VfsLfs1)
+test(bdev, uos.VfsLfs2)
diff --git a/tests/extmod/vfs_lfs_corrupt.py.exp b/tests/extmod/vfs_lfs_corrupt.py.exp
new file mode 100644
index 0000000000000..d6f5f54252f46
--- /dev/null
+++ b/tests/extmod/vfs_lfs_corrupt.py.exp
@@ -0,0 +1,12 @@
+test <class 'VfsLfs1'>
+statvfs OSError
+read OSError
+write OSError
+close OSError
+flush OSError
+test <class 'VfsLfs2'>
+statvfs OSError
+read OSError
+write OSError
+close OSError
+flush OSError
diff --git a/tests/extmod/vfs_lfs_error.py b/tests/extmod/vfs_lfs_error.py
new file mode 100644
index 0000000000000..717284ea01723
--- /dev/null
+++ b/tests/extmod/vfs_lfs_error.py
@@ -0,0 +1,121 @@
+# Test for VfsLittle using a RAM device, testing error handling
+
+try:
+    import uos
+
+    uos.VfsLfs1
+    uos.VfsLfs2
+except (ImportError, AttributeError):
+    print("SKIP")
+    raise SystemExit
+
+
+class RAMBlockDevice:
+    ERASE_BLOCK_SIZE = 1024
+
+    def __init__(self, blocks):
+        self.data = bytearray(blocks * self.ERASE_BLOCK_SIZE)
+
+    def readblocks(self, block, buf, off):
+        addr = block * self.ERASE_BLOCK_SIZE + off
+        for i in range(len(buf)):
+            buf[i] = self.data[addr + i]
+
+    def writeblocks(self, block, buf, off):
+        addr = block * self.ERASE_BLOCK_SIZE + off
+        for i in range(len(buf)):
+            self.data[addr + i] = buf[i]
+
+    def ioctl(self, op, arg):
+        if op == 4:  # block count
+            return len(self.data) // self.ERASE_BLOCK_SIZE
+        if op == 5:  # block size
+            return self.ERASE_BLOCK_SIZE
+        if op == 6:  # erase block
+            return 0
+
+
+def test(bdev, vfs_class):
+    print("test", vfs_class)
+
+    # mkfs with too-small block device
+    try:
+        vfs_class.mkfs(RAMBlockDevice(1))
+    except OSError:
+        print("mkfs OSError")
+
+    # mount with invalid filesystem
+    try:
+        vfs_class(bdev)
+    except OSError:
+        print("mount OSError")
+
+    # set up for following tests
+    vfs_class.mkfs(bdev)
+    vfs = vfs_class(bdev)
+    with vfs.open("testfile", "w") as f:
+        f.write("test")
+    vfs.mkdir("testdir")
+
+    # ilistdir
+    try:
+        vfs.ilistdir("noexist")
+    except OSError:
+        print("ilistdir OSError")
+
+    # remove
+    try:
+        vfs.remove("noexist")
+    except OSError:
+        print("remove OSError")
+
+    # rmdir
+    try:
+        vfs.rmdir("noexist")
+    except OSError:
+        print("rmdir OSError")
+
+    # rename
+    try:
+        vfs.rename("noexist", "somethingelse")
+    except OSError:
+        print("rename OSError")
+
+    # mkdir
+    try:
+        vfs.mkdir("testdir")
+    except OSError:
+        print("mkdir OSError")
+
+    # chdir to nonexistent
+    try:
+        vfs.chdir("noexist")
+    except OSError:
+        print("chdir OSError")
+    print(vfs.getcwd())  # check still at root
+
+    # chdir to file
+    try:
+        vfs.chdir("testfile")
+    except OSError:
+        print("chdir OSError")
+    print(vfs.getcwd())  # check still at root
+
+    # stat
+    try:
+        vfs.stat("noexist")
+    except OSError:
+        print("stat OSError")
+
+    # error during seek
+    with vfs.open("testfile", "r") as f:
+        f.seek(1 << 30)  # SEEK_SET
+        try:
+            f.seek(1 << 30, 1)  # SEEK_CUR
+        except OSError:
+            print("seek OSError")
+
+
+bdev = RAMBlockDevice(30)
+test(bdev, uos.VfsLfs1)
+test(bdev, uos.VfsLfs2)
diff --git a/tests/extmod/vfs_lfs_error.py.exp b/tests/extmod/vfs_lfs_error.py.exp
new file mode 100644
index 0000000000000..f4327f6962ec3
--- /dev/null
+++ b/tests/extmod/vfs_lfs_error.py.exp
@@ -0,0 +1,28 @@
+test <class 'VfsLfs1'>
+mkfs OSError
+mount OSError
+ilistdir OSError
+remove OSError
+rmdir OSError
+rename OSError
+mkdir OSError
+chdir OSError
+/
+chdir OSError
+/
+stat OSError
+seek OSError
+test <class 'VfsLfs2'>
+mkfs OSError
+mount OSError
+ilistdir OSError
+remove OSError
+rmdir OSError
+rename OSError
+mkdir OSError
+chdir OSError
+/
+chdir OSError
+/
+stat OSError
+seek OSError
diff --git a/tests/extmod/vfs_lfs_file.py b/tests/extmod/vfs_lfs_file.py
new file mode 100644
index 0000000000000..774cca296433f
--- /dev/null
+++ b/tests/extmod/vfs_lfs_file.py
@@ -0,0 +1,121 @@
+# Test for VfsLittle using a RAM device, file IO
+
+try:
+    import uos
+
+    uos.VfsLfs1
+    uos.VfsLfs2
+except (ImportError, AttributeError):
+    print("SKIP")
+    raise SystemExit
+
+
+class RAMBlockDevice:
+    ERASE_BLOCK_SIZE = 1024
+
+    def __init__(self, blocks):
+        self.data = bytearray(blocks * self.ERASE_BLOCK_SIZE)
+
+    def readblocks(self, block, buf, off):
+        addr = block * self.ERASE_BLOCK_SIZE + off
+        for i in range(len(buf)):
+            buf[i] = self.data[addr + i]
+
+    def writeblocks(self, block, buf, off):
+        addr = block * self.ERASE_BLOCK_SIZE + off
+        for i in range(len(buf)):
+            self.data[addr + i] = buf[i]
+
+    def ioctl(self, op, arg):
+        if op == 4:  # block count
+            return len(self.data) // self.ERASE_BLOCK_SIZE
+        if op == 5:  # block size
+            return self.ERASE_BLOCK_SIZE
+        if op == 6:  # erase block
+            return 0
+
+
+def test(bdev, vfs_class):
+    print("test", vfs_class)
+
+    # mkfs
+    vfs_class.mkfs(bdev)
+
+    # construction
+    vfs = vfs_class(bdev)
+
+    # create text, print, write, close
+    f = vfs.open("test.txt", "wt")
+    print(f)
+    f.write("littlefs")
+    f.close()
+
+    # close already-closed file
+    f.close()
+
+    # create binary, print, write, flush, close
+    f = vfs.open("test.bin", "wb")
+    print(f)
+    f.write("littlefs")
+    f.flush()
+    f.close()
+
+    # create for append
+    f = vfs.open("test.bin", "ab")
+    f.write("more")
+    f.close()
+
+    # create exclusive
+    f = vfs.open("test2.bin", "xb")
+    f.close()
+
+    # create exclusive with error
+    try:
+        vfs.open("test2.bin", "x")
+    except OSError:
+        print("open OSError")
+
+    # read default
+    with vfs.open("test.txt", "") as f:
+        print(f.read())
+
+    # read text
+    with vfs.open("test.txt", "rt") as f:
+        print(f.read())
+
+    # read binary
+    with vfs.open("test.bin", "rb") as f:
+        print(f.read())
+
+    # create read and write
+    with vfs.open("test.bin", "r+b") as f:
+        print(f.read(8))
+        f.write("MORE")
+    with vfs.open("test.bin", "rb") as f:
+        print(f.read())
+
+    # seek and tell
+    f = vfs.open("test.txt", "r")
+    print(f.tell())
+    f.seek(3, 0)
+    print(f.tell())
+    f.close()
+
+    # open nonexistent
+    try:
+        vfs.open("noexist", "r")
+    except OSError:
+        print("open OSError")
+
+    # open multiple files at the same time
+    f1 = vfs.open("test.txt", "")
+    f2 = vfs.open("test.bin", "b")
+    print(f1.read())
+    print(f2.read())
+    f1.close()
+    f2.close()
+
+
+bdev = RAMBlockDevice(30)
+test(bdev, uos.VfsLfs1)
+test(bdev, uos.VfsLfs2)
diff --git a/tests/extmod/vfs_lfs_file.py.exp b/tests/extmod/vfs_lfs_file.py.exp
new file mode 100644
index 0000000000000..55531539ec7de
--- /dev/null
+++ b/tests/extmod/vfs_lfs_file.py.exp
@@ -0,0 +1,28 @@
+test <class 'VfsLfs1'>
+<io.TextIOWrapper>
+<io.FileIO>
+open OSError
+littlefs
+littlefs
+b'littlefsmore'
+b'littlefs'
+b'littlefsMORE'
+0
+3
+open OSError
+littlefs
+b'littlefsMORE'
+test <class 'VfsLfs2'>
+<io.TextIOWrapper>
+<io.FileIO>
+open OSError
+littlefs
+littlefs
+b'littlefsmore'
+b'littlefs'
+b'littlefsMORE'
+0
+3
+open OSError
+littlefs
+b'littlefsMORE'
diff --git a/tests/extmod/vfs_lfs_mount.py b/tests/extmod/vfs_lfs_mount.py
new file mode 100644
index 0000000000000..9207f4a8c6d05
--- /dev/null
+++ b/tests/extmod/vfs_lfs_mount.py
@@ -0,0 +1,85 @@
+# Test for VfsLittle using a RAM device, with mount/umount
+
+try:
+    import uos
+
+    uos.VfsLfs1
+    uos.VfsLfs2
+except (ImportError, AttributeError):
+    print("SKIP")
+    raise SystemExit
+
+
+class RAMBlockDevice:
+    ERASE_BLOCK_SIZE = 1024
+
+    def __init__(self, blocks):
+        self.data = bytearray(blocks * self.ERASE_BLOCK_SIZE)
+
+    def readblocks(self, block, buf, off):
+        addr = block * self.ERASE_BLOCK_SIZE + off
+        for i in range(len(buf)):
+            buf[i] = self.data[addr + i]
+
+    def writeblocks(self, block, buf, off):
+        addr = block * self.ERASE_BLOCK_SIZE + off
+        for i in range(len(buf)):
+            self.data[addr + i] = buf[i]
+
+    def ioctl(self, op, arg):
+        if op == 4:  # block count
+            return len(self.data) // self.ERASE_BLOCK_SIZE
+        if op == 5:  # block size
+            return self.ERASE_BLOCK_SIZE
+        if op == 6:  # erase block
+            return 0
+
+
+def test(bdev, vfs_class):
+    print("test", vfs_class)
+
+    # mkfs
+    vfs_class.mkfs(bdev)
+
+    # construction
+    vfs = vfs_class(bdev)
+
+    # mount
+    uos.mount(vfs, "/lfs")
+
+    # import
+    with open("/lfs/lfsmod.py", "w") as f:
+        f.write('print("hello from lfs")\n')
+    import lfsmod
+
+    # import package
+    uos.mkdir("/lfs/lfspkg")
+    with open("/lfs/lfspkg/__init__.py", "w") as f:
+        f.write('print("package")\n')
+    import lfspkg
+
+    # chdir and import module from current directory (needs "" in sys.path)
+    uos.mkdir("/lfs/subdir")
+    uos.chdir("/lfs/subdir")
+    uos.rename("/lfs/lfsmod.py", "/lfs/subdir/lfsmod2.py")
+    import lfsmod2
+
+    # umount
+    uos.umount("/lfs")
+
+    # clear imported modules
+    sys.modules.clear()
+
+
+bdev = RAMBlockDevice(30)
+
+# initialise path
+import sys
+
+sys.path.clear()
+sys.path.append("/lfs")
+sys.path.append("")
+
+# run tests
+test(bdev, uos.VfsLfs1)
+test(bdev, uos.VfsLfs2)
diff --git a/tests/extmod/vfs_lfs_mount.py.exp b/tests/extmod/vfs_lfs_mount.py.exp
new file mode 100644
index 0000000000000..b5c52153141a2
--- /dev/null
+++ b/tests/extmod/vfs_lfs_mount.py.exp
@@ -0,0 +1,8 @@
+test <class 'VfsLfs1'>
+hello from lfs
+package
+hello from lfs
+test <class 'VfsLfs2'>
+hello from lfs
+package
+hello from lfs
diff --git a/tests/extmod/vfs_userfs.py b/tests/extmod/vfs_userfs.py
index 7f6e48cb1e6fd..06e546b081a97 100644
--- a/tests/extmod/vfs_userfs.py
+++ b/tests/extmod/vfs_userfs.py
@@ -5,8 +5,10 @@
 
 try:
     import uio
+
     uio.IOBase
     import uos
+
     uos.mount
 except (ImportError, AttributeError):
     print("SKIP")
@@ -17,8 +19,10 @@ class UserFile(uio.IOBase):
     def __init__(self, data):
         self.data = data
         self.pos = 0
+
     def read(self):
         return self.data
+
     def readinto(self, buf):
         n = 0
         while n < len(buf) and self.pos < len(self.data):
@@ -26,44 +30,49 @@ def readinto(self, buf):
             n += 1
             self.pos += 1
         return n
+
     def ioctl(self, req, arg):
-        print('ioctl', req, arg)
+        print("ioctl", req, arg)
         return 0
 
 
 class UserFS:
     def __init__(self, files):
         self.files = files
+
     def mount(self, readonly, mksfs):
         pass
+
     def umount(self):
         pass
+
     def stat(self, path):
-        print('stat', path)
+        print("stat", path)
         if path in self.files:
             return (32768, 0, 0, 0, 0, 0, 0, 0, 0, 0)
         raise OSError
+
     def open(self, path, mode):
-        print('open', path, mode)
+        print("open", path, mode)
         return UserFile(self.files[path])
 
 
 # create and mount a user filesystem
 user_files = {
-    '/data.txt': b"some data in a text file\n",
-    '/usermod1.py': b"print('in usermod1')\nimport usermod2",
-    '/usermod2.py': b"print('in usermod2')",
+    "/data.txt": b"some data in a text file\n",
+    "/usermod1.py": b"print('in usermod1')\nimport usermod2",
+    "/usermod2.py": b"print('in usermod2')",
 }
-uos.mount(UserFS(user_files), '/userfs')
+uos.mount(UserFS(user_files), "/userfs")
 
 # open and read a file
-f = open('/userfs/data.txt')
+f = open("/userfs/data.txt")
 print(f.read())
 
 # import files from the user filesystem
-sys.path.append('/userfs')
+sys.path.append("/userfs")
 import usermod1
 
 # unmount and undo path addition
-uos.umount('/userfs')
+uos.umount("/userfs")
 sys.path.pop()
diff --git a/tests/extmod/websocket_basic.py b/tests/extmod/websocket_basic.py
index 6cc6f0fd15bf3..10396e914d652 100644
--- a/tests/extmod/websocket_basic.py
+++ b/tests/extmod/websocket_basic.py
@@ -11,6 +11,7 @@ def ws_read(msg, sz):
     ws = uwebsocket.websocket(uio.BytesIO(msg))
     return ws.read(sz)
 
+
 # do a websocket write and then return the raw data from the stream
 def ws_write(msg, sz):
     s = uio.BytesIO()
@@ -19,31 +20,32 @@ def ws_write(msg, sz):
     s.seek(0)
     return s.read(sz)
 
+
 # basic frame
 print(ws_read(b"\x81\x04ping", 4))
-print(ws_read(b"\x80\x04ping", 4)) # FRAME_CONT
+print(ws_read(b"\x80\x04ping", 4))  # FRAME_CONT
 print(ws_write(b"pong", 6))
 
 # split frames are not supported
 # print(ws_read(b"\x01\x04ping", 4))
 
 # extended payloads
-print(ws_read(b'\x81~\x00\x80' + b'ping' * 32, 128))
+print(ws_read(b"\x81~\x00\x80" + b"ping" * 32, 128))
 print(ws_write(b"pong" * 32, 132))
 
 # mask (returned data will be 'mask' ^ 'mask')
 print(ws_read(b"\x81\x84maskmask", 4))
 
 # close control frame
-s = uio.BytesIO(b'\x88\x00') # FRAME_CLOSE
+s = uio.BytesIO(b"\x88\x00")  # FRAME_CLOSE
 ws = uwebsocket.websocket(s)
 print(ws.read(1))
 s.seek(2)
 print(s.read(4))
 
 # misc control frames
-print(ws_read(b"\x89\x00\x81\x04ping", 4)) # FRAME_PING
-print(ws_read(b"\x8a\x00\x81\x04pong", 4)) # FRAME_PONG
+print(ws_read(b"\x89\x00\x81\x04ping", 4))  # FRAME_PING
+print(ws_read(b"\x8a\x00\x81\x04pong", 4))  # FRAME_PONG
 
 # close method
 ws = uwebsocket.websocket(uio.BytesIO())
@@ -51,8 +53,8 @@ def ws_write(msg, sz):
 
 # ioctl
 ws = uwebsocket.websocket(uio.BytesIO())
-print(ws.ioctl(8)) # GET_DATA_OPTS
-print(ws.ioctl(9, 2)) # SET_DATA_OPTS
+print(ws.ioctl(8))  # GET_DATA_OPTS
+print(ws.ioctl(9, 2))  # SET_DATA_OPTS
 print(ws.ioctl(9))
 try:
     ws.ioctl(-1)
diff --git a/tests/feature_check/bytearray.py b/tests/feature_check/bytearray.py
new file mode 100644
index 0000000000000..601ef4597c442
--- /dev/null
+++ b/tests/feature_check/bytearray.py
@@ -0,0 +1,5 @@
+try:
+    bytearray
+    print("bytearray")
+except NameError:
+    print("no")
diff --git a/tests/feature_check/bytearray.py.exp b/tests/feature_check/bytearray.py.exp
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/tests/feature_check/byteorder.py b/tests/feature_check/byteorder.py
index d60f93956852d..c82a41a24b1c0 100644
--- a/tests/feature_check/byteorder.py
+++ b/tests/feature_check/byteorder.py
@@ -1,2 +1,3 @@
 import sys
+
 print(sys.byteorder)
diff --git a/tests/feature_check/complex.py b/tests/feature_check/complex.py
index a22eb52ce3da5..7576dcb953f52 100644
--- a/tests/feature_check/complex.py
+++ b/tests/feature_check/complex.py
@@ -3,4 +3,3 @@
     print("complex")
 except NameError:
     print("no")
-
diff --git a/tests/feature_check/coverage.py b/tests/feature_check/coverage.py
index dcda53eae24bb..82647ee314d9a 100644
--- a/tests/feature_check/coverage.py
+++ b/tests/feature_check/coverage.py
@@ -1,5 +1,5 @@
 try:
     extra_coverage
-    print('coverage')
+    print("coverage")
 except NameError:
-    print('no')
+    print("no")
diff --git a/tests/feature_check/float.py b/tests/feature_check/float.py
index af93f5976321c..d6d2a99d2429d 100644
--- a/tests/feature_check/float.py
+++ b/tests/feature_check/float.py
@@ -5,9 +5,9 @@
 except NameError:
     print(0)
 else:
-    if float('1.0000001') == float('1.0'):
+    if float("1.0000001") == float("1.0"):
         print(30)
-    elif float('1e300') == float('inf'):
+    elif float("1e300") == float("inf"):
         print(32)
     else:
         print(64)
diff --git a/tests/feature_check/repl_words_move_check.py b/tests/feature_check/repl_words_move_check.py
new file mode 100644
index 0000000000000..e74615e98cad3
--- /dev/null
+++ b/tests/feature_check/repl_words_move_check.py
@@ -0,0 +1,4 @@
+# just check if ctrl+w is supported, because it makes sure that
+# both MICROPY_REPL_EMACS_WORDS_MOVE and MICROPY_REPL_EXTRA_WORDS_MOVE are enabled.
+t = 1231
+t == 1
diff --git a/tests/feature_check/repl_words_move_check.py.exp b/tests/feature_check/repl_words_move_check.py.exp
new file mode 100644
index 0000000000000..82a4e28ee4f84
--- /dev/null
+++ b/tests/feature_check/repl_words_move_check.py.exp
@@ -0,0 +1,7 @@
+MicroPython \.\+ version
+Use \.\+
+>>> # Check for emacs keys in REPL
+>>> t = \.\+
+>>> t == 2
+True
+>>> 
diff --git a/tests/feature_check/reverse_ops.py b/tests/feature_check/reverse_ops.py
index 668748bc5742f..68eb91b44e39e 100644
--- a/tests/feature_check/reverse_ops.py
+++ b/tests/feature_check/reverse_ops.py
@@ -1,8 +1,8 @@
 class Foo:
-
     def __radd__(self, other):
         pass
 
+
 try:
     5 + Foo()
 except TypeError:
diff --git a/tests/feature_check/slice.py b/tests/feature_check/slice.py
new file mode 100644
index 0000000000000..cdd42701af227
--- /dev/null
+++ b/tests/feature_check/slice.py
@@ -0,0 +1,5 @@
+try:
+    slice
+    print("slice")
+except NameError:
+    print("no")
diff --git a/tests/feature_check/slice.py.exp b/tests/feature_check/slice.py.exp
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/tests/feature_check/uio_module.py b/tests/feature_check/uio_module.py
new file mode 100644
index 0000000000000..bad8d7c95beb1
--- /dev/null
+++ b/tests/feature_check/uio_module.py
@@ -0,0 +1,6 @@
+try:
+    import uio
+
+    print("uio")
+except ImportError:
+    print("no")
diff --git a/tests/feature_check/uio_module.py.exp b/tests/feature_check/uio_module.py.exp
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/tests/float/array_construct.py b/tests/float/array_construct.py
index 938675835bbcf..f6a3a9dc9d41c 100644
--- a/tests/float/array_construct.py
+++ b/tests/float/array_construct.py
@@ -1,10 +1,13 @@
 # test construction of array from array with float type
 
 try:
-    from array import array
+    from uarray import array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        from array import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
-print(array('f', array('h', [1, 2])))
-print(array('d', array('f', [1, 2])))
+print(array("f", array("h", [1, 2])))
+print(array("d", array("f", [1, 2])))
diff --git a/tests/float/builtin_float_abs.py b/tests/float/builtin_float_abs.py
index c0935c6eec0d2..f7ce9e156fe96 100644
--- a/tests/float/builtin_float_abs.py
+++ b/tests/float/builtin_float_abs.py
@@ -1,13 +1,13 @@
 # test builtin abs function with float args
 
 for val in (
-    '1.0',
-    '-1.0',
-    '0.0',
-    '-0.0',
-    'nan',
-    '-nan',
-    'inf',
-    '-inf',
-    ):
+    "1.0",
+    "-1.0",
+    "0.0",
+    "-0.0",
+    "nan",
+    "-nan",
+    "inf",
+    "-inf",
+):
     print(val, abs(float(val)))
diff --git a/tests/float/builtin_float_hash.py b/tests/float/builtin_float_hash.py
index 7a7e374010104..1388bb0e832f7 100644
--- a/tests/float/builtin_float_hash.py
+++ b/tests/float/builtin_float_hash.py
@@ -2,24 +2,24 @@
 
 # these should hash to an integer with a specific value
 for val in (
-    '0.0',
-    '-0.0',
-    '1.0',
-    '2.0',
-    '-12.0',
-    '12345.0',
-    ):
+    "0.0",
+    "-0.0",
+    "1.0",
+    "2.0",
+    "-12.0",
+    "12345.0",
+):
     print(val, hash(float(val)))
 
 # just check that these values are hashable
 for val in (
-    '0.1',
-    '-0.1',
-    '10.3',
-    '0.4e3',
-    '1e16',
-    'inf',
-    '-inf',
-    'nan',
-    ):
+    "0.1",
+    "-0.1",
+    "10.3",
+    "0.4e3",
+    "1e16",
+    "inf",
+    "-inf",
+    "nan",
+):
     print(val, type(hash(float(val))))
diff --git a/tests/float/builtin_float_minmax.py b/tests/float/builtin_float_minmax.py
index 266ed133d53cf..8a53746e5dfdd 100644
--- a/tests/float/builtin_float_minmax.py
+++ b/tests/float/builtin_float_minmax.py
@@ -29,4 +29,3 @@
 print(max([1, 2.9, 4, 6.5, -1, 2]))
 print(min([1, 2.9, 4, -6.5, -1, 2]))
 print(max([1, 2.9, 4, -6.5, -1, 2]))
-
diff --git a/tests/float/builtin_float_pow.py b/tests/float/builtin_float_pow.py
index 2de1b481763f3..98998bdc7c3fe 100644
--- a/tests/float/builtin_float_pow.py
+++ b/tests/float/builtin_float_pow.py
@@ -6,6 +6,6 @@
 print(pow(2.0, 3.0))
 print(pow(2.0, -4.0))
 
-print(pow(0.0, float('inf')))
-print(pow(0.0, float('-inf')))
-print(pow(0.0, float('nan')))
+print(pow(0.0, float("inf")))
+print(pow(0.0, float("-inf")))
+print(pow(0.0, float("nan")))
diff --git a/tests/float/builtin_float_round.py b/tests/float/builtin_float_round.py
index 63cb39aa3576b..1153b8a2bfd46 100644
--- a/tests/float/builtin_float_round.py
+++ b/tests/float/builtin_float_round.py
@@ -2,8 +2,18 @@
 
 # check basic cases
 tests = [
-    [0.0], [1.0], [0.1], [-0.1], [123.4], [123.6], [-123.4], [-123.6],
-    [1.234567, 5], [1.23456, 1], [1.23456, 0], [1234.56, -2]
+    [0.0],
+    [1.0],
+    [0.1],
+    [-0.1],
+    [123.4],
+    [123.6],
+    [-123.4],
+    [-123.6],
+    [1.234567, 5],
+    [1.23456, 1],
+    [1.23456, 0],
+    [1234.56, -2],
 ]
 for t in tests:
     print(round(*t))
@@ -17,7 +27,7 @@
     print(round(1.47, i))
 
 # test inf and nan
-for val in (float('inf'), float('nan')):
+for val in (float("inf"), float("nan")):
     try:
         round(val)
     except (ValueError, OverflowError) as e:
diff --git a/tests/float/builtin_float_round_intbig.py b/tests/float/builtin_float_round_intbig.py
index 2083e3ea3af46..c8a338eefdfa3 100644
--- a/tests/float/builtin_float_round_intbig.py
+++ b/tests/float/builtin_float_round_intbig.py
@@ -1,4 +1,4 @@
 # test round() with floats that return large integers
 
 for x in (-1e25, 1e25):
-    print('%.3g' % round(x))
+    print("%.3g" % round(x))
diff --git a/tests/float/bytearray_construct.py b/tests/float/bytearray_construct.py
index e960d624ec8ca..257d37d1bea0a 100644
--- a/tests/float/bytearray_construct.py
+++ b/tests/float/bytearray_construct.py
@@ -1,9 +1,12 @@
 # test construction of bytearray from array with float type
 
 try:
-    from array import array
+    from uarray import array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        from array import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
-print(bytearray(array('f', [1, 2.3])))
+print(bytearray(array("f", [1, 2.3])))
diff --git a/tests/float/bytes_construct.py b/tests/float/bytes_construct.py
index 0e4482e436698..0806087b0ef0e 100644
--- a/tests/float/bytes_construct.py
+++ b/tests/float/bytes_construct.py
@@ -1,9 +1,12 @@
 # test construction of bytearray from array with float type
 
 try:
-    from array import array
+    from uarray import array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        from array import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
-print(bytes(array('f', [1, 2.3])))
+print(bytes(array("f", [1, 2.3])))
diff --git a/tests/float/cmath_fun.py b/tests/float/cmath_fun.py
index d3df25e11150b..7b5e692452765 100644
--- a/tests/float/cmath_fun.py
+++ b/tests/float/cmath_fun.py
@@ -11,29 +11,33 @@
 print("%.5g" % pi)
 
 test_values_non_zero = []
-base_values = (0.0, 0.5, 1.2345, 10.)
+base_values = (0.0, 0.5, 1.2345, 10.0)
 for r in base_values:
     for i in base_values:
-        if r != 0. or i != 0.:
+        if r != 0.0 or i != 0.0:
             test_values_non_zero.append(complex(r, i))
-        if r != 0.:
+        if r != 0.0:
             test_values_non_zero.append(complex(-r, i))
-        if i != 0.:
+        if i != 0.0:
             test_values_non_zero.append(complex(r, -i))
-        if r != 0. and i != 0.:
+        if r != 0.0 and i != 0.0:
             test_values_non_zero.append(complex(-r, -i))
-test_values = [complex(0., 0.),] + test_values_non_zero
+test_values = [complex(0.0, 0.0),] + test_values_non_zero
 print(test_values)
 
 functions = [
-    ('phase', phase, test_values),
-    ('polar', polar, test_values),
-    ('rect', rect, ((0, 0), (0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (-1, 1), (1, -1), (123., -456.))),
-    ('exp', exp, test_values),
-    ('log', log, test_values_non_zero),
-    ('sqrt', sqrt, test_values),
-    ('cos', cos, test_values),
-    ('sin', sin, test_values),
+    ("phase", phase, test_values),
+    ("polar", polar, test_values),
+    (
+        "rect",
+        rect,
+        ((0, 0), (0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (-1, 1), (1, -1), (123.0, -456.0)),
+    ),
+    ("exp", exp, test_values),
+    ("log", log, test_values_non_zero),
+    ("sqrt", sqrt, test_values),
+    ("cos", cos, test_values),
+    ("sin", sin, test_values),
 ]
 
 for f_name, f, test_vals in functions:
@@ -51,5 +55,5 @@
             # some test (eg cmath.sqrt(-0.5)) disagree with CPython with tiny real part
             real = ret.real
             if abs(real) < 1e-6:
-                real = 0.
+                real = 0.0
             print("complex(%.5g, %.5g)" % (real, ret.imag))
diff --git a/tests/float/cmath_fun_special.py b/tests/float/cmath_fun_special.py
index 471fda8c0dc19..e4c3c1774540a 100644
--- a/tests/float/cmath_fun_special.py
+++ b/tests/float/cmath_fun_special.py
@@ -2,30 +2,31 @@
 
 try:
     from cmath import *
+
     log10
 except (ImportError, NameError):
     print("SKIP")
     raise SystemExit
 
 test_values_non_zero = []
-base_values = (0.0, 0.5, 1.2345, 10.)
+base_values = (0.0, 0.5, 1.2345, 10.0)
 for r in base_values:
     for i in base_values:
-        if r != 0. or i != 0.:
+        if r != 0.0 or i != 0.0:
             test_values_non_zero.append(complex(r, i))
-        if r != 0.:
+        if r != 0.0:
             test_values_non_zero.append(complex(-r, i))
-        if i != 0.:
+        if i != 0.0:
             test_values_non_zero.append(complex(r, -i))
-        if r != 0. and i != 0.:
+        if r != 0.0 and i != 0.0:
             test_values_non_zero.append(complex(-r, -i))
 
 functions = [
-    ('log10', log10, test_values_non_zero),
+    ("log10", log10, test_values_non_zero),
 ]
 
 for f_name, f, test_vals in functions:
     print(f_name)
     for val in test_vals:
         ret = f(val)
-        print("complex(%.5g, %.5g)" % (ret.real, ret.imag))
+        print("complex(%.4g, %.4g)" % (ret.real, ret.imag))
diff --git a/tests/float/complex1.py b/tests/float/complex1.py
index 479b4b3485b26..a510ffc830fc6 100644
--- a/tests/float/complex1.py
+++ b/tests/float/complex1.py
@@ -27,18 +27,25 @@
 print(1j / 2)
 print((1j / 2j).real)
 print(1j / (1 + 2j))
-ans = 0j ** 0; print("%.5g %.5g" % (ans.real, ans.imag))
-ans = 0j ** 1; print("%.5g %.5g" % (ans.real, ans.imag))
-ans = 0j ** 0j; print("%.5g %.5g" % (ans.real, ans.imag))
-ans = 1j ** 2.5; print("%.5g %.5g" % (ans.real, ans.imag))
-ans = 1j ** 2.5j; print("%.5g %.5g" % (ans.real, ans.imag))
+ans = 0j ** 0
+print("%.5g %.5g" % (ans.real, ans.imag))
+ans = 0j ** 1
+print("%.5g %.5g" % (ans.real, ans.imag))
+ans = 0j ** 0j
+print("%.5g %.5g" % (ans.real, ans.imag))
+ans = 1j ** 2.5
+print("%.5g %.5g" % (ans.real, ans.imag))
+ans = 1j ** 2.5j
+print("%.5g %.5g" % (ans.real, ans.imag))
 
 # comparison
 print(1j == 1)
 print(1j == 1j)
+print(0 + 0j == False, 1 + 0j == True)
+print(False == 0 + 0j, True == 1 + 0j)
 
 # comparison of nan is special
-nan = float('nan') * 1j
+nan = float("nan") * 1j
 print(nan == 1j)
 print(nan == nan)
 
@@ -54,20 +61,22 @@
 print(1.2 + 3j)
 
 # negative base and fractional power should create a complex
-ans = (-1) ** 2.3; print("%.5g %.5g" % (ans.real, ans.imag))
-ans = (-1.2) ** -3.4; print("%.5g %.5g" % (ans.real, ans.imag))
+ans = (-1) ** 2.3
+print("%.5g %.5g" % (ans.real, ans.imag))
+ans = (-1.2) ** -3.4
+print("%.5g %.5g" % (ans.real, ans.imag))
 
 # check printing of inf/nan
-print(float('nan') * 1j)
-print(float('-nan') * 1j)
-print(float('inf') * (1 + 1j))
-print(float('-inf') * (1 + 1j))
+print(float("nan") * 1j)
+print(float("-nan") * 1j)
+print(float("inf") * (1 + 1j))
+print(float("-inf") * (1 + 1j))
 
 # can't assign to attributes
 try:
     (1j).imag = 0
 except AttributeError:
-    print('AttributeError')
+    print("AttributeError")
 
 # can't convert rhs to complex
 try:
@@ -93,11 +102,11 @@
 except TypeError:
     print("TypeError")
 
-#small int on LHS, complex on RHS, unsupported op
+# small int on LHS, complex on RHS, unsupported op
 try:
     print(1 | 1j)
 except TypeError:
-    print('TypeError')
+    print("TypeError")
 
 # zero division
 try:
diff --git a/tests/float/complex1_intbig.py b/tests/float/complex1_intbig.py
index ed2390bbaf24c..864036b9914ea 100644
--- a/tests/float/complex1_intbig.py
+++ b/tests/float/complex1_intbig.py
@@ -1,4 +1,5 @@
 # test basic complex number functionality
 
 # convert bignum to complex on rhs
-ans = 1j + (1 << 70); print("%.5g %.5g" % (ans.real, ans.imag))
+ans = 1j + (1 << 70)
+print("%.5g %.5g" % (ans.real, ans.imag))
diff --git a/tests/float/float1.py b/tests/float/float1.py
index 54807e5ac9c27..efde5146bed7d 100644
--- a/tests/float/float1.py
+++ b/tests/float/float1.py
@@ -1,11 +1,11 @@
 # test basic float capabilities
 
 # literals
-print(.12)
-print(1.)
+print(0.12)
+print(1.0)
 print(1.2)
 print(0e0)
-print(0e+0)
+print(0e0)
 print(0e-0)
 
 # float construction
@@ -64,9 +64,11 @@
 print(1.2 <= -3.4)
 print(1.2 >= 3.4)
 print(1.2 >= -3.4)
+print(0.0 == False, 1.0 == True)
+print(False == 0.0, True == 1.0)
 
 # comparison of nan is special
-nan = float('nan')
+nan = float("nan")
 print(nan == 1.2)
 print(nan == nan)
 
@@ -106,7 +108,7 @@
 try:
     print(1 | 1.0)
 except TypeError:
-    print('TypeError')
+    print("TypeError")
 
 # can't convert list to float
 try:
diff --git a/tests/float/float2int_doubleprec_intbig.py b/tests/float/float2int_doubleprec_intbig.py
index de2137d66ca64..84fa2d25360e1 100644
--- a/tests/float/float2int_doubleprec_intbig.py
+++ b/tests/float/float2int_doubleprec_intbig.py
@@ -6,6 +6,7 @@
     import struct
 
 import sys
+
 maxsize_bits = 0
 maxsize = sys.maxsize
 while maxsize:
@@ -31,32 +32,33 @@
 
 # This case occurs with time.time() values
 if ll_type != 0:
-    print(int(1418774543.))
-    print("%d" % 1418774543.)
+    print(int(1418774543.0))
+    print("%d" % 1418774543.0)
     if ll_type == 3:
-        print(int(2.**100))
-        print("%d" % 2.**100)
+        print(int(2.0 ** 100))
+        print("%d" % 2.0 ** 100)
 else:
-    print(int(1073741823.))
-    print("%d" % 1073741823.)
+    print(int(1073741823.0))
+    print("%d" % 1073741823.0)
 
 testpass = True
-p2_rng = ((30,63,1024),(62,63,1024))[is_64bit][ll_type]
-for i in range(0,p2_rng):
-    bitcnt = len(bin(int(2.**i))) - 3;
+p2_rng = ((30, 63, 1024), (62, 63, 1024))[is_64bit][ll_type]
+for i in range(0, p2_rng):
+    bitcnt = len(bin(int(2.0 ** i))) - 3
     if i != bitcnt:
-        print('fail: 2**%u was %u bits long' % (i, bitcnt));
+        print("fail: 2**%u was %u bits long" % (i, bitcnt))
         testpass = False
-print("power of  2 test: %s" % (testpass and 'passed' or 'failed'))
+print("power of  2 test: %s" % (testpass and "passed" or "failed"))
 
 testpass = True
-p10_rng = ((9,18,23),(18,18,23))[is_64bit][ll_type]
-for i in range(0,p10_rng):
-    digcnt = len(str(int(10.**i))) - 1;
+p10_rng = ((9, 18, 23), (18, 18, 23))[is_64bit][ll_type]
+for i in range(0, p10_rng):
+    digcnt = len(str(int(10.0 ** i))) - 1
     if i != digcnt:
-        print('fail: 10**%u was %u digits long' % (i, digcnt));
+        print("fail: 10**%u was %u digits long" % (i, digcnt))
         testpass = False
-print("power of 10 test: %s" % (testpass and 'passed' or 'failed'))
+print("power of 10 test: %s" % (testpass and "passed" or "failed"))
+
 
 def fp2int_test(num, name, should_fail):
     try:
@@ -64,37 +66,39 @@ def fp2int_test(num, name, should_fail):
         passed = ~should_fail
     except:
         passed = should_fail
-    print('%s: %s' % (name, passed and 'passed' or 'failed'))
+    print("%s: %s" % (name, passed and "passed" or "failed"))
+
 
 if ll_type != 2:
     if ll_type == 0:
         if is_64bit:
-            neg_bad_fp = -1.00000005*2.**62.
-            pos_bad_fp = 2.**62.
-            neg_good_fp = -2.**62.
-            pos_good_fp = 0.99999993*2.**62.
+            neg_bad_fp = -1.00000005 * 2.0 ** 62.0
+            pos_bad_fp = 2.0 ** 62.0
+            neg_good_fp = -(2.0 ** 62.0)
+            pos_good_fp = 0.99999993 * 2.0 ** 62.0
         else:
-            neg_bad_fp = -1.00000005*2.**30.
-            pos_bad_fp = 2.**30.
-            neg_good_fp = -2.**30.
-            pos_good_fp = 0.9999999499*2.**30.
+            neg_bad_fp = -1.00000005 * 2.0 ** 30.0
+            pos_bad_fp = 2.0 ** 30.0
+            neg_good_fp = -(2.0 ** 30.0)
+            pos_good_fp = 0.9999999499 * 2.0 ** 30.0
     else:
-        neg_bad_fp = -0.51*2.**64.
-        pos_bad_fp = 2.**63.
-        neg_good_fp = -2.**63.
-        pos_good_fp = 1.9999998*2.**62.
+        neg_bad_fp = -0.51 * 2.0 ** 64.0
+        pos_bad_fp = 2.0 ** 63.0
+        neg_good_fp = -(2.0 ** 63.0)
+        pos_good_fp = 1.9999998 * 2.0 ** 62.0
 
-    fp2int_test(neg_bad_fp, 'neg bad', True)
-    fp2int_test(pos_bad_fp, 'pos bad', True)
-    fp2int_test(neg_good_fp, 'neg good', False)
-    fp2int_test(pos_good_fp, 'pos good', False)
+    fp2int_test(neg_bad_fp, "neg bad", True)
+    fp2int_test(pos_bad_fp, "pos bad", True)
+    fp2int_test(neg_good_fp, "neg good", False)
+    fp2int_test(pos_good_fp, "pos good", False)
 else:
-    fp2int_test(-1.9999999999999981*2.**1023., 'large neg', False)
-    fp2int_test(1.9999999999999981*2.**1023., 'large pos', False)
+    fp2int_test(-1.9999999999999981 * 2.0 ** 1023.0, "large neg", False)
+    fp2int_test(1.9999999999999981 * 2.0 ** 1023.0, "large pos", False)
 
-fp2int_test(float('inf'), 'inf test', True)
-fp2int_test(float('nan'), 'NaN test', True)
+fp2int_test(float("inf"), "inf test", True)
+fp2int_test(float("-inf"), "inf test", True)
+fp2int_test(float("nan"), "NaN test", True)
 
 # test numbers < 1 (this used to fail; see issue #1044)
-fp2int_test(0.0001, 'small num', False)
-struct.pack('I', int(1/2))
+fp2int_test(0.0001, "small num", False)
+struct.pack("I", int(1 / 2))
diff --git a/tests/float/float2int_fp30_intbig.py b/tests/float/float2int_fp30_intbig.py
index fbb94a4ccc052..75ff52f39dd49 100644
--- a/tests/float/float2int_fp30_intbig.py
+++ b/tests/float/float2int_fp30_intbig.py
@@ -6,6 +6,7 @@
     import struct
 
 import sys
+
 maxsize_bits = 0
 maxsize = sys.maxsize
 while maxsize:
@@ -30,30 +31,31 @@
         ll_type = 2
 
 # basic conversion
-print(int(14187744.))
-print("%d" % 14187744.)
+print(int(14187744.0))
+print("%d" % 14187744.0)
 if ll_type == 2:
-    print(int(2.**100))
-    print("%d" % 2.**100)
+    print(int(2.0 ** 100))
+    print("%d" % 2.0 ** 100)
 
 testpass = True
-p2_rng = ((30,63,127),(62,63,127))[is_64bit][ll_type]
-for i in range(0,p2_rng):
-    bitcnt = len(bin(int(2.**i))) - 3;
+p2_rng = ((30, 63, 127), (62, 63, 127))[is_64bit][ll_type]
+for i in range(0, p2_rng):
+    bitcnt = len(bin(int(2.0 ** i))) - 3
     if i != bitcnt:
-        print('fail: 2.**%u was %u bits long' % (i, bitcnt));
+        print("fail: 2.**%u was %u bits long" % (i, bitcnt))
         testpass = False
-print("power of  2 test: %s" % (testpass and 'passed' or 'failed'))
+print("power of  2 test: %s" % (testpass and "passed" or "failed"))
 
 # TODO why does 10**12 fail this test for single precision float?
 testpass = True
 p10_rng = 9
-for i in range(0,p10_rng):
-    digcnt = len(str(int(10.**i))) - 1;
+for i in range(0, p10_rng):
+    digcnt = len(str(int(10.0 ** i))) - 1
     if i != digcnt:
-        print('fail: 10.**%u was %u digits long' % (i, digcnt));
+        print("fail: 10.**%u was %u digits long" % (i, digcnt))
         testpass = False
-print("power of 10 test: %s" % (testpass and 'passed' or 'failed'))
+print("power of 10 test: %s" % (testpass and "passed" or "failed"))
+
 
 def fp2int_test(num, name, should_fail):
     try:
@@ -61,37 +63,39 @@ def fp2int_test(num, name, should_fail):
         passed = ~should_fail
     except:
         passed = should_fail
-    print('%s: %s' % (name, passed and 'passed' or 'failed'))
+    print("%s: %s" % (name, passed and "passed" or "failed"))
+
 
 if ll_type != 2:
     if ll_type == 0:
         if is_64bit:
-            neg_bad_fp = -1.00000005*2.**62.
-            pos_bad_fp = 2.**62.
-            neg_good_fp = -2.**62.
-            pos_good_fp = 0.99999993*2.**62.
+            neg_bad_fp = -1.00000005 * 2.0 ** 62.0
+            pos_bad_fp = 2.0 ** 62.0
+            neg_good_fp = -(2.0 ** 62.0)
+            pos_good_fp = 0.99999993 * 2.0 ** 62.0
         else:
-            neg_bad_fp = -1.00000005*2.**30.
-            pos_bad_fp = 2.**30.
-            neg_good_fp = -2.**30.
-            pos_good_fp = 0.9999999499*2.**30.
+            neg_bad_fp = -1.00000005 * 2.0 ** 30.0
+            pos_bad_fp = 2.0 ** 30.0
+            neg_good_fp = -(2.0 ** 30.0)
+            pos_good_fp = 0.9999999499 * 2.0 ** 30.0
     else:
-        neg_bad_fp = -0.51*2.**64.
-        pos_bad_fp = 2.**63.
-        neg_good_fp = -2.**63.
-        pos_good_fp = 1.9999998*2.**62.
+        neg_bad_fp = -0.51 * 2.0 ** 64.0
+        pos_bad_fp = 2.0 ** 63.0
+        neg_good_fp = -(2.0 ** 63.0)
+        pos_good_fp = 1.9999998 * 2.0 ** 62.0
 
-    fp2int_test(neg_bad_fp, 'neg bad', True)
-    fp2int_test(pos_bad_fp, 'pos bad', True)
-    fp2int_test(neg_good_fp, 'neg good', False)
-    fp2int_test(pos_good_fp, 'pos good', False)
+    fp2int_test(neg_bad_fp, "neg bad", True)
+    fp2int_test(pos_bad_fp, "pos bad", True)
+    fp2int_test(neg_good_fp, "neg good", False)
+    fp2int_test(pos_good_fp, "pos good", False)
 else:
-    fp2int_test(-1.999999879*2.**126., 'large neg', False)
-    fp2int_test(1.999999879*2.**126., 'large pos', False)
+    fp2int_test(-1.999999879 * 2.0 ** 126.0, "large neg", False)
+    fp2int_test(1.999999879 * 2.0 ** 126.0, "large pos", False)
 
-fp2int_test(float('inf'), 'inf test', True)
-fp2int_test(float('nan'), 'NaN test', True)
+fp2int_test(float("inf"), "inf test", True)
+fp2int_test(float("-inf"), "inf test", True)
+fp2int_test(float("nan"), "NaN test", True)
 
 # test numbers < 1 (this used to fail; see issue #1044)
-fp2int_test(0.0001, 'small num', False)
-struct.pack('I', int(1/2))
+fp2int_test(0.0001, "small num", False)
+struct.pack("I", int(1 / 2))
diff --git a/tests/float/float2int_intbig.py b/tests/float/float2int_intbig.py
index 3596d2f73da53..62aca39634968 100644
--- a/tests/float/float2int_intbig.py
+++ b/tests/float/float2int_intbig.py
@@ -32,30 +32,33 @@
 
 
 # basic conversion
+# fmt: off
 print(int(14187745.))
 print("%d" % 14187745.)
+# fmt: on
 if ll_type == 2:
-    print(int(2.**100))
-    print("%d" % 2.**100)
+    print(int(2.0 ** 100))
+    print("%d" % 2.0 ** 100)
 
 testpass = True
-p2_rng = ((30,63,127),(62,63,127))[is_64bit][ll_type]
-for i in range(0,p2_rng):
-    bitcnt = len(bin(int(2.**i))) - 3;
+p2_rng = ((30, 63, 127), (62, 63, 127))[is_64bit][ll_type]
+for i in range(0, p2_rng):
+    bitcnt = len(bin(int(2.0 ** i))) - 3
     if i != bitcnt:
-        print('fail: 2.**%u was %u bits long' % (i, bitcnt));
+        print("fail: 2.**%u was %u bits long" % (i, bitcnt))
         testpass = False
-print("power of  2 test: %s" % (testpass and 'passed' or 'failed'))
+print("power of  2 test: %s" % (testpass and "passed" or "failed"))
 
 # TODO why does 10**12 fail this test for single precision float?
 testpass = True
 p10_rng = 9 if (ll_type == 0 and ~is_64bit) else 11
-for i in range(0,p10_rng):
-    digcnt = len(str(int(10.**i))) - 1;
+for i in range(0, p10_rng):
+    digcnt = len(str(int(10.0 ** i))) - 1
     if i != digcnt:
-        print('fail: 10.**%u was %u digits long' % (i, digcnt));
+        print("fail: 10.**%u was %u digits long" % (i, digcnt))
         testpass = False
-print("power of 10 test: %s" % (testpass and 'passed' or 'failed'))
+print("power of 10 test: %s" % (testpass and "passed" or "failed"))
+
 
 def fp2int_test(num, name, should_fail):
     try:
@@ -63,37 +66,38 @@ def fp2int_test(num, name, should_fail):
         passed = ~should_fail
     except:
         passed = should_fail
-    print('%s: %s' % (name, passed and 'passed' or 'failed'))
+    print("%s: %s" % (name, passed and "passed" or "failed"))
+
 
 if ll_type != 2:
     if ll_type == 0:
         if is_64bit:
-            neg_bad_fp = -1.00000005*2.**62.
-            pos_bad_fp = 2.**62.
-            neg_good_fp = -2.**62.
-            pos_good_fp = 0.99999993*2.**62.
+            neg_bad_fp = -1.00000005 * 2.0 ** 62.0
+            pos_bad_fp = 2.0 ** 62.0
+            neg_good_fp = -(2.0 ** 62.0)
+            pos_good_fp = 0.99999993 * 2.0 ** 62.0
         else:
-            neg_bad_fp = -1.00000005*2.**30.
-            pos_bad_fp = 2.**30.
-            neg_good_fp = -2.**30.
-            pos_good_fp = 0.9999999499*2.**30.
+            neg_bad_fp = -1.00000005 * 2.0 ** 30.0
+            pos_bad_fp = 2.0 ** 30.0
+            neg_good_fp = -(2.0 ** 30.0)
+            pos_good_fp = 0.9999999499 * 2.0 ** 30.0
     else:
-        neg_bad_fp = -0.51*2.**64.
-        pos_bad_fp = 2.**63.
-        neg_good_fp = -2.**63.
-        pos_good_fp = 1.9999998*2.**62.
+        neg_bad_fp = -0.51 * 2.0 ** 64.0
+        pos_bad_fp = 2.0 ** 63.0
+        neg_good_fp = -(2.0 ** 63.0)
+        pos_good_fp = 1.9999998 * 2.0 ** 62.0
 
-    fp2int_test(neg_bad_fp, 'neg bad', True)
-    fp2int_test(pos_bad_fp, 'pos bad', True)
-    fp2int_test(neg_good_fp, 'neg good', False)
-    fp2int_test(pos_good_fp, 'pos good', False)
+    fp2int_test(neg_bad_fp, "neg bad", True)
+    fp2int_test(pos_bad_fp, "pos bad", True)
+    fp2int_test(neg_good_fp, "neg good", False)
+    fp2int_test(pos_good_fp, "pos good", False)
 else:
-    fp2int_test(-1.999999879*2.**127., 'large neg', False)
-    fp2int_test(1.999999879*2.**127., 'large pos', False)
+    fp2int_test(-1.999999879 * 2.0 ** 127.0, "large neg", False)
+    fp2int_test(1.999999879 * 2.0 ** 127.0, "large pos", False)
 
-fp2int_test(float('inf'), 'inf test', True)
-fp2int_test(float('nan'), 'NaN test', True)
+fp2int_test(float("inf"), "inf test", True)
+fp2int_test(float("nan"), "NaN test", True)
 
 # test numbers < 1 (this used to fail; see issue #1044)
-fp2int_test(0.0001, 'small num', False)
-struct.pack('I', int(1/2))
+fp2int_test(0.0001, "small num", False)
+struct.pack("I", int(1 / 2))
diff --git a/tests/float/float_array.py b/tests/float/float_array.py
index 8c8edcff7c86b..3c2189869b93f 100644
--- a/tests/float/float_array.py
+++ b/tests/float/float_array.py
@@ -1,20 +1,25 @@
 try:
-    from array import array
+    from uarray import array
 except ImportError:
-    print("SKIP")
-    raise SystemExit
+    try:
+        from array import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
 
 def test(a):
     print(a)
     a.append(1.2)
-    print(len(a), '%.3f' % a[0])
+    print(len(a), "%.3f" % a[0])
     a.append(1)
     a.append(False)
-    print(len(a), '%.3f %.3f' % (a[1], a[2]))
+    print(len(a), "%.3f %.3f" % (a[1], a[2]))
     a[-1] = 3.45
-    print('%.3f' % a[-1])
+    print("%.3f" % a[-1])
+
 
-test(array('f'))
-test(array('d'))
+test(array("f"))
+test(array("d"))
 
-print('{:.4f}'.format(array('f', b'\xcc\xcc\xcc=')[0]))
+print("{:.4f}".format(array("f", b"\xcc\xcc\xcc=")[0]))
diff --git a/tests/float/float_compare.py b/tests/float/float_compare.py
index 105923ac733af..c177aa7e81d52 100644
--- a/tests/float/float_compare.py
+++ b/tests/float/float_compare.py
@@ -1,8 +1,10 @@
 # Extended float comparisons
 
+
 class Foo:
     pass
 
+
 foo = Foo()
 
 print(foo == 1.0)
diff --git a/tests/float/float_divmod.py b/tests/float/float_divmod.py
index 8e7cd435a55e6..ec83ce2d195bb 100644
--- a/tests/float/float_divmod.py
+++ b/tests/float/float_divmod.py
@@ -1,11 +1,13 @@
 # test floating point floor divide and modulus
 # it has some tricky corner cases
 
+
 def test(x, y):
     div, mod = divmod(x, y)
-    print('%.8f %.8f %.8f %.8f' % (x // y, x % y, div, mod))
+    print("%.8f %.8f %.8f %.8f" % (x // y, x % y, div, mod))
     print(div == x // y, mod == x % y, abs(div * y + mod - x) < 1e-15)
 
+
 test(1.23456, 0.7)
 test(-1.23456, 0.7)
 test(1.23456, -0.7)
diff --git a/tests/float/float_divmod_relaxed.py b/tests/float/float_divmod_relaxed.py
index a9450fa2c4d94..ef5a6ad2e82b3 100644
--- a/tests/float/float_divmod_relaxed.py
+++ b/tests/float/float_divmod_relaxed.py
@@ -4,10 +4,12 @@
 # pyboard has 32-bit floating point and gives different (but still
 # correct) answers for certain combinations of divmod arguments.
 
+
 def test(x, y):
     div, mod = divmod(x, y)
     print(div == x // y, mod == x % y, abs(div * y + mod - x) < 1e-6)
 
+
 test(1.23456, 0.7)
 test(-1.23456, 0.7)
 test(1.23456, -0.7)
@@ -30,4 +32,4 @@ def test(x, y):
 try:
     divmod(1.0, 0)
 except ZeroDivisionError:
-    print('ZeroDivisionError')
+    print("ZeroDivisionError")
diff --git a/tests/float/float_format.py b/tests/float/float_format.py
index d43535cf2ff4f..4c8a217567abf 100644
--- a/tests/float/float_format.py
+++ b/tests/float/float_format.py
@@ -2,18 +2,18 @@
 
 # general rounding
 for val in (116, 1111, 1234, 5010, 11111):
-    print('%.0f' % val)
-    print('%.1f' % val)
-    print('%.3f' % val)
+    print("%.0f" % val)
+    print("%.1f" % val)
+    print("%.3f" % val)
 
 # make sure rounding is done at the correct precision
 for prec in range(8):
-    print(('%%.%df' % prec) % 6e-5)
+    print(("%%.%df" % prec) % 6e-5)
 
 # check certain cases that had a digit value of 10 render as a ":" character
-print('%.2e' % float('9' * 51 + 'e-39'))
-print('%.2e' % float('9' * 40 + 'e-21'))
+print("%.2e" % float("9" * 51 + "e-39"))
+print("%.2e" % float("9" * 40 + "e-21"))
 
 # check a case that would render negative digit values, eg ")" characters
 # the string is converted back to a float to check for no illegal characters
-float('%.23e' % 1e-80)
+float("%.23e" % 1e-80)
diff --git a/tests/float/float_parse.py b/tests/float/float_parse.py
index 4b5fc613d314d..de27c33e7be57 100644
--- a/tests/float/float_parse.py
+++ b/tests/float/float_parse.py
@@ -1,36 +1,36 @@
 # test parsing of floats
 
-inf = float('inf')
+inf = float("inf")
 
 # it shouldn't matter where the decimal point is if the exponent balances the value
-print(float('1234') - float('0.1234e4'))
-print(float('1.015625') - float('1015625e-6'))
+print(float("1234") - float("0.1234e4"))
+print(float("1.015625") - float("1015625e-6"))
 
 # very large integer part with a very negative exponent should cancel out
-print('%.4e' % float('9' * 60 + 'e-60'))
-print('%.4e' % float('9' * 60 + 'e-40'))
+print("%.4e" % float("9" * 60 + "e-60"))
+print("%.4e" % float("9" * 60 + "e-40"))
 
 # many fractional digits
-print(float('.' + '9' * 70))
-print(float('.' + '9' * 70 + 'e20'))
-print(float('.' + '9' * 70 + 'e-50') == float('1e-50'))
+print(float("." + "9" * 70))
+print(float("." + "9" * 70 + "e20"))
+print(float("." + "9" * 70 + "e-50") == float("1e-50"))
 
 # tiny fraction with large exponent
-print(float('.' + '0' * 60 + '1e10') == float('1e-51'))
-print(float('.' + '0' * 60 + '9e25') == float('9e-36'))
-print(float('.' + '0' * 60 + '9e40') == float('9e-21'))
+print(float("." + "0" * 60 + "1e10") == float("1e-51"))
+print(float("." + "0" * 60 + "9e25") == float("9e-36"))
+print(float("." + "0" * 60 + "9e40") == float("9e-21"))
 
 # ensure that accuracy is retained when value is close to a subnormal
-print(float('1.00000000000000000000e-37'))
-print(float('10.0000000000000000000e-38'))
-print(float('100.000000000000000000e-39'))
+print(float("1.00000000000000000000e-37"))
+print(float("10.0000000000000000000e-38"))
+print(float("100.000000000000000000e-39"))
 
 # very large exponent literal
-print(float('1e4294967301'))
-print(float('1e-4294967301'))
-print(float('1e18446744073709551621'))
-print(float('1e-18446744073709551621'))
+print(float("1e4294967301"))
+print(float("1e-4294967301"))
+print(float("1e18446744073709551621"))
+print(float("1e-18446744073709551621"))
 
 # check small decimals are as close to their true value as possible
 for n in range(1, 10):
-    print(float('0.%u' % n) == n / 10)
+    print(float("0.%u" % n) == n / 10)
diff --git a/tests/float/float_parse_doubleprec.py b/tests/float/float_parse_doubleprec.py
index dcc0dd5921544..81fcadcee88b4 100644
--- a/tests/float/float_parse_doubleprec.py
+++ b/tests/float/float_parse_doubleprec.py
@@ -1,21 +1,21 @@
 # test parsing of floats, requiring double-precision
 
 # very large integer part with a very negative exponent should cancel out
-print(float('9' * 400 + 'e-100'))
-print(float('9' * 400 + 'e-200'))
-print(float('9' * 400 + 'e-400'))
+print(float("9" * 400 + "e-100"))
+print(float("9" * 400 + "e-200"))
+print(float("9" * 400 + "e-400"))
 
 # many fractional digits
-print(float('.' + '9' * 400))
-print(float('.' + '9' * 400 + 'e100'))
-print(float('.' + '9' * 400 + 'e-100'))
+print(float("." + "9" * 400))
+print(float("." + "9" * 400 + "e100"))
+print(float("." + "9" * 400 + "e-100"))
 
 # tiny fraction with large exponent
-print('%.14e' % float('.' + '0' * 400 + '9e100'))
-print('%.14e' % float('.' + '0' * 400 + '9e200'))
-print('%.14e' % float('.' + '0' * 400 + '9e400'))
+print("%.14e" % float("." + "0" * 400 + "9e100"))
+print("%.14e" % float("." + "0" * 400 + "9e200"))
+print("%.14e" % float("." + "0" * 400 + "9e400"))
 
 # ensure that accuracy is retained when value is close to a subnormal
-print(float('1.00000000000000000000e-307'))
-print(float('10.0000000000000000000e-308'))
-print(float('100.000000000000000000e-309'))
+print(float("1.00000000000000000000e-307"))
+print(float("10.0000000000000000000e-308"))
+print(float("100.000000000000000000e-309"))
diff --git a/tests/float/float_struct.py b/tests/float/float_struct.py
index c4c186b89e45c..18893af0e0aa1 100644
--- a/tests/float/float_struct.py
+++ b/tests/float/float_struct.py
@@ -8,11 +8,10 @@
     print("SKIP")
     raise SystemExit
 
-i = 1. + 1/2
+i = 1.0 + 1 / 2
 # TODO: it looks like '=' format modifier is not yet supported
 # for fmt in ('f', 'd', '>f', '>d', '<f', '<d', '=f', '=d'):
-for fmt in ('f', 'd', '>f', '>d', '<f', '<d'):
+for fmt in ("f", "d", ">f", ">d", "<f", "<d"):
     x = struct.pack(fmt, i)
     v = struct.unpack(fmt, x)[0]
-    print('%2s: %.17f - %s' % (fmt, v, (i == v) and 'passed' or 'failed'))
-
+    print("%2s: %.17f - %s" % (fmt, v, (i == v) and "passed" or "failed"))
diff --git a/tests/float/int_power.py b/tests/float/int_power.py
index 649d4d4152f40..ba79247a5668e 100644
--- a/tests/float/int_power.py
+++ b/tests/float/int_power.py
@@ -5,4 +5,4 @@
 
 x = 3
 x **= -2
-print('%.5f' % x)
+print("%.5f" % x)
diff --git a/tests/float/lexer.py b/tests/float/lexer.py
new file mode 100644
index 0000000000000..a4b1941eea947
--- /dev/null
+++ b/tests/float/lexer.py
@@ -0,0 +1,6 @@
+# since black code formatter does not allow leading decimal point with nothing
+# before it, we need to test it explicitly
+
+# fmt: off
+print(.1)
+# fmt: on
diff --git a/tests/float/math_domain.py b/tests/float/math_domain.py
index 0cf10fb2ada80..e63628cf5078a 100644
--- a/tests/float/math_domain.py
+++ b/tests/float/math_domain.py
@@ -6,46 +6,46 @@
     print("SKIP")
     raise SystemExit
 
-inf = float('inf')
-nan = float('nan')
+inf = float("inf")
+nan = float("nan")
 
 # single argument functions
 for name, f, args in (
-    ('fabs', math.fabs, ()),
-    ('ceil', math.ceil, ()),
-    ('floor', math.floor, ()),
-    ('trunc', math.trunc, ()),
-    ('sqrt', math.sqrt, (-1, 0)),
-    ('exp', math.exp, ()),
-    ('sin', math.sin, ()),
-    ('cos', math.cos, ()),
-    ('tan', math.tan, ()),
-    ('asin', math.asin, (-1.1, 1, 1.1)),
-    ('acos', math.acos, (-1.1, 1, 1.1)),
-    ('atan', math.atan, ()),
-    ('ldexp', lambda x: math.ldexp(x, 0), ()),
-    ('radians', math.radians, ()),
-    ('degrees', math.degrees, ()),
-    ):
+    ("fabs", math.fabs, ()),
+    ("ceil", math.ceil, ()),
+    ("floor", math.floor, ()),
+    ("trunc", math.trunc, ()),
+    ("sqrt", math.sqrt, (-1, 0)),
+    ("exp", math.exp, ()),
+    ("sin", math.sin, ()),
+    ("cos", math.cos, ()),
+    ("tan", math.tan, ()),
+    ("asin", math.asin, (-1.1, 1, 1.1)),
+    ("acos", math.acos, (-1.1, 1, 1.1)),
+    ("atan", math.atan, ()),
+    ("ldexp", lambda x: math.ldexp(x, 0), ()),
+    ("radians", math.radians, ()),
+    ("degrees", math.degrees, ()),
+):
     for x in args + (inf, nan):
         try:
             ans = f(x)
-            print('%.4f' % ans)
+            print("%.4f" % ans)
         except ValueError:
-            print(name, 'ValueError')
+            print(name, "ValueError")
         except OverflowError:
-            print(name, 'OverflowError')
+            print(name, "OverflowError")
 
 # double argument functions
 for name, f, args in (
-    ('pow', math.pow, ((0, 2), (-1, 2), (0, -1), (-1, 2.3))),
-    ('fmod', math.fmod, ((1.2, inf), (1.2, 0), (inf, 1.2))),
-    ('atan2', math.atan2, ((0, 0),)),
-    ('copysign', math.copysign, ()),
-    ):
+    ("pow", math.pow, ((0, 2), (-1, 2), (0, -1), (-1, 2.3))),
+    ("fmod", math.fmod, ((1.2, inf), (1.2, -inf), (1.2, 0), (inf, 1.2))),
+    ("atan2", math.atan2, ((0, 0), (-inf, inf), (-inf, -inf), (inf, -inf))),
+    ("copysign", math.copysign, ()),
+):
     for x in args + ((0, inf), (inf, 0), (inf, inf), (inf, nan), (nan, inf), (nan, nan)):
         try:
             ans = f(*x)
-            print('%.4f' % ans)
+            print("%.4f" % ans)
         except ValueError:
-            print(name, 'ValueError')
+            print(name, "ValueError")
diff --git a/tests/float/math_domain_special.py b/tests/float/math_domain_special.py
index 5650c35fec8fb..880594dce28ed 100644
--- a/tests/float/math_domain_special.py
+++ b/tests/float/math_domain_special.py
@@ -2,35 +2,36 @@
 
 try:
     import math
+
     math.erf
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
 
-inf = float('inf')
-nan = float('nan')
+inf = float("inf")
+nan = float("nan")
 
 # single argument functions
 for name, f, args in (
-    ('expm1', math.exp, ()),
-    ('log2', math.log2, (-1, 0)),
-    ('log10', math.log10, (-1, 0)),
-    ('sinh', math.sinh, ()),
-    ('cosh', math.cosh, ()),
-    ('tanh', math.tanh, ()),
-    ('asinh', math.asinh, ()),
-    ('acosh', math.acosh, (-1, 0.9, 1)),
-    ('atanh', math.atanh, (-1, 1)),
-    ('erf', math.erf, ()),
-    ('erfc', math.erfc, ()),
-    ('gamma', math.gamma, (-2, -1, 0, 1)),
-    ('lgamma', math.lgamma, (-2, -1, 0, 1)),
-    ):
+    ("expm1", math.exp, ()),
+    ("log2", math.log2, (-1, 0)),
+    ("log10", math.log10, (-1, 0)),
+    ("sinh", math.sinh, ()),
+    ("cosh", math.cosh, ()),
+    ("tanh", math.tanh, ()),
+    ("asinh", math.asinh, ()),
+    ("acosh", math.acosh, (-1, 0.9, 1)),
+    ("atanh", math.atanh, (-1, 1)),
+    ("erf", math.erf, ()),
+    ("erfc", math.erfc, ()),
+    ("gamma", math.gamma, (-2, -1, 0, 1)),
+    ("lgamma", math.lgamma, (-2, -1, 0, 1)),
+):
     for x in args + (inf, -inf, nan):
         try:
             ans = f(x)
-            print('%.4f' % ans)
+            print("%.4f" % ans)
         except ValueError:
-            print(name, 'ValueError')
+            print(name, "ValueError")
         except OverflowError:
-            print(name, 'OverflowError')
+            print(name, "OverflowError")
diff --git a/tests/float/math_factorial_intbig.py b/tests/float/math_factorial_intbig.py
index 19d853df2a464..a4694b3d68076 100644
--- a/tests/float/math_factorial_intbig.py
+++ b/tests/float/math_factorial_intbig.py
@@ -1,14 +1,15 @@
 try:
     import math
+
     math.factorial
 except (ImportError, AttributeError):
-    print('SKIP')
+    print("SKIP")
     raise SystemExit
 
 
 for fun in (math.factorial,):
     for x in range(-1, 30):
         try:
-            print('%d' % fun(x))
+            print("%d" % fun(x))
         except ValueError as e:
-            print('ValueError')
+            print("ValueError")
diff --git a/tests/float/math_fun.py b/tests/float/math_fun.py
index 2835b9bfbd9b5..7b6bb86489b7d 100644
--- a/tests/float/math_fun.py
+++ b/tests/float/math_fun.py
@@ -6,26 +6,36 @@
     print("SKIP")
     raise SystemExit
 
-test_values = [-100., -1.23456, -1, -0.5, 0.0, 0.5, 1.23456, 100.]
-test_values_small = [-10., -1.23456, -1, -0.5, 0.0, 0.5, 1.23456, 10.] # so we don't overflow 32-bit precision
-unit_range_test_values = [-1., -0.75, -0.5, -0.25, 0., 0.25, 0.5, 0.75, 1.]
-
-functions = [('sqrt', sqrt, test_values),
-             ('exp', exp, test_values_small),
-             ('log', log, test_values),
-             ('cos', cos, test_values),
-             ('sin', sin, test_values),
-             ('tan', tan, test_values),
-             ('acos', acos, unit_range_test_values),
-             ('asin', asin, unit_range_test_values),
-             ('atan', atan, test_values),
-             ('ceil', ceil, test_values),
-             ('fabs', fabs, test_values),
-             ('floor', floor, test_values),
-             ('trunc', trunc, test_values),
-             ('radians', radians, test_values),
-             ('degrees', degrees, test_values),
-            ]
+test_values = [-100.0, -1.23456, -1, -0.5, 0.0, 0.5, 1.23456, 100.0]
+test_values_small = [
+    -10.0,
+    -1.23456,
+    -1,
+    -0.5,
+    0.0,
+    0.5,
+    1.23456,
+    10.0,
+]  # so we don't overflow 32-bit precision
+unit_range_test_values = [-1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.75, 1.0]
+
+functions = [
+    ("sqrt", sqrt, test_values),
+    ("exp", exp, test_values_small),
+    ("log", log, test_values),
+    ("cos", cos, test_values),
+    ("sin", sin, test_values),
+    ("tan", tan, test_values),
+    ("acos", acos, unit_range_test_values),
+    ("asin", asin, unit_range_test_values),
+    ("atan", atan, test_values),
+    ("ceil", ceil, test_values),
+    ("fabs", fabs, test_values),
+    ("floor", floor, test_values),
+    ("trunc", trunc, test_values),
+    ("radians", radians, test_values),
+    ("degrees", degrees, test_values),
+]
 
 for function_name, function, test_vals in functions:
     print(function_name)
@@ -35,9 +45,10 @@
         except ValueError as e:
             print(str(e))
 
-tuple_functions = [('frexp', frexp, test_values),
-                   ('modf', modf, test_values),
-                  ]
+tuple_functions = [
+    ("frexp", frexp, test_values),
+    ("modf", modf, test_values),
+]
 
 for function_name, function, test_vals in tuple_functions:
     print(function_name)
@@ -45,14 +56,31 @@
         x, y = function(value)
         print("{:.5g} {:.5g}".format(x, y))
 
-binary_functions = [('copysign', copysign, [(23., 42.), (-23., 42.), (23., -42.),
-                                (-23., -42.), (1., 0.0), (1., -0.0)]),
-                    ('pow', pow, ((1., 0.), (0., 1.), (2., 0.5), (-3., 5.), (-3., -4.),)),
-                    ('atan2', atan2, ((1., 0.), (0., 1.), (2., 0.5), (-3., 5.), (-3., -4.),)),
-                    ('fmod', fmod, ((1., 1.), (0., 1.), (2., 0.5), (-3., 5.), (-3., -4.),)),
-                    ('ldexp', ldexp, ((1., 0), (0., 1), (2., 2), (3., -2), (-3., -4),)),
-                    ('log', log, ((2., 2.), (3., 2.), (4., 5.), (0., 1.), (1., 0.), (-1., 1.), (1., -1.), (2., 1.))),
-                   ]
+binary_functions = [
+    (
+        "copysign",
+        copysign,
+        [(23.0, 42.0), (-23.0, 42.0), (23.0, -42.0), (-23.0, -42.0), (1.0, 0.0), (1.0, -0.0)],
+    ),
+    ("pow", pow, ((1.0, 0.0), (0.0, 1.0), (2.0, 0.5), (-3.0, 5.0), (-3.0, -4.0),)),
+    ("atan2", atan2, ((1.0, 0.0), (0.0, 1.0), (2.0, 0.5), (-3.0, 5.0), (-3.0, -4.0),)),
+    ("fmod", fmod, ((1.0, 1.0), (0.0, 1.0), (2.0, 0.5), (-3.0, 5.0), (-3.0, -4.0),)),
+    ("ldexp", ldexp, ((1.0, 0), (0.0, 1), (2.0, 2), (3.0, -2), (-3.0, -4),)),
+    (
+        "log",
+        log,
+        (
+            (2.0, 2.0),
+            (3.0, 2.0),
+            (4.0, 5.0),
+            (0.0, 1.0),
+            (1.0, 0.0),
+            (-1.0, 1.0),
+            (1.0, -1.0),
+            (2.0, 1.0),
+        ),
+    ),
+]
 
 for function_name, function, test_vals in binary_functions:
     print(function_name)
diff --git a/tests/float/math_fun_bool.py b/tests/float/math_fun_bool.py
index 30ab14a522bd5..6e9af0dd3986b 100644
--- a/tests/float/math_fun_bool.py
+++ b/tests/float/math_fun_bool.py
@@ -6,8 +6,7 @@
     print("SKIP")
     raise SystemExit
 
-test_values = [1, 0, -1, 1.0, 0.0, -1.0, float('NaN'), float('Inf'), 
-               -float('NaN'), -float('Inf')]
+test_values = [1, 0, -1, 1.0, 0.0, -1.0, float("NaN"), float("Inf"), -float("NaN"), -float("Inf")]
 
 functions = [isfinite, isnan, isinf]
 
diff --git a/tests/float/math_fun_int.py b/tests/float/math_fun_int.py
index 5cadbb1e5269f..2cabad4e09130 100644
--- a/tests/float/math_fun_int.py
+++ b/tests/float/math_fun_int.py
@@ -7,7 +7,7 @@
     raise SystemExit
 
 for fun in (math.ceil, math.floor, math.trunc):
-    for x in (-1.6, -0.2, 0, 0.6, 1.4, float('inf'), float('nan')):
+    for x in (-1.6, -0.2, 0, 0.6, 1.4, float("inf"), float("nan")):
         try:
             print(fun(x))
         except (ValueError, OverflowError) as e:
diff --git a/tests/float/math_fun_intbig.py b/tests/float/math_fun_intbig.py
index 697ca7a6db731..7169b8017d882 100644
--- a/tests/float/math_fun_intbig.py
+++ b/tests/float/math_fun_intbig.py
@@ -8,4 +8,4 @@
 
 for fun in (math.ceil, math.floor, math.trunc):
     for x in (-1e25, 1e25):
-        print('%.3g' % fun(x))
+        print("%.3g" % fun(x))
diff --git a/tests/float/math_fun_special.py b/tests/float/math_fun_special.py
index e676a6fc97118..c101a7e5019db 100644
--- a/tests/float/math_fun_special.py
+++ b/tests/float/math_fun_special.py
@@ -2,28 +2,45 @@
 
 try:
     from math import *
+
     erf
 except (ImportError, NameError):
     print("SKIP")
     raise SystemExit
 
-test_values = [-8., -2.5, -1, -0.5, 0.0, 0.5, 2.5, 8.,]
-pos_test_values = [0.001, 0.1, 0.5, 1.0, 1.5, 10.,]
+test_values = [
+    -8.0,
+    -2.5,
+    -1,
+    -0.5,
+    0.0,
+    0.5,
+    2.5,
+    8.0,
+]
+pos_test_values = [
+    0.001,
+    0.1,
+    0.5,
+    1.0,
+    1.5,
+    10.0,
+]
 
 functions = [
-    ('expm1', expm1, test_values),
-    ('log2', log2, test_values),
-    ('log10', log10, test_values),
-    ('cosh', cosh, test_values),
-    ('sinh', sinh, test_values),
-    ('tanh', tanh, [-1e6, -100] + test_values + [100, 1e6]),
-    ('acosh', acosh, [1.0, 5.0, 1.0]),
-    ('asinh', asinh, test_values),
-    ('atanh', atanh, [-0.99, -0.5, 0.0, 0.5, 0.99]),
-    ('erf', erf, test_values),
-    ('erfc', erfc, test_values),
-    ('gamma', gamma, pos_test_values),
-    ('lgamma', lgamma, pos_test_values + [50., 100.,]),
+    ("expm1", expm1, test_values),
+    ("log2", log2, test_values),
+    ("log10", log10, test_values),
+    ("cosh", cosh, test_values),
+    ("sinh", sinh, test_values),
+    ("tanh", tanh, [-1e6, -100] + test_values + [100, 1e6]),
+    ("acosh", acosh, [1.0, 5.0, 1.0]),
+    ("asinh", asinh, test_values),
+    ("atanh", atanh, [-0.99, -0.5, 0.0, 0.5, 0.99]),
+    ("erf", erf, test_values),
+    ("erfc", erfc, test_values),
+    ("gamma", gamma, pos_test_values),
+    ("lgamma", lgamma, pos_test_values + [50.0, 100.0,]),
 ]
 
 for function_name, function, test_vals in functions:
diff --git a/tests/float/math_isclose.py b/tests/float/math_isclose.py
new file mode 100644
index 0000000000000..ef3e20f4f0f26
--- /dev/null
+++ b/tests/float/math_isclose.py
@@ -0,0 +1,50 @@
+# test math.isclose (appeared in Python 3.5)
+
+try:
+    from math import isclose
+except ImportError:
+    print("SKIP")
+    raise SystemExit
+
+
+def test(a, b, **kwargs):
+    print(isclose(a, b, **kwargs))
+
+
+def test_combinations(a, b, **kwargs):
+    test(a, a, **kwargs)
+    test(a, b, **kwargs)
+    test(b, a, **kwargs)
+    test(b, b, **kwargs)
+
+
+# Special numbers
+test_combinations(float("nan"), 1)
+test_combinations(float("inf"), 1)
+test_combinations(float("-inf"), 1)
+
+# Equality
+test(1.0, 1.0, rel_tol=0.0, abs_tol=0.0)
+test(2.35e-100, 2.35e-100, rel_tol=0.0, abs_tol=0.0)
+test(2.1234e100, 2.1234e100, rel_tol=0.0, abs_tol=0.0)
+
+# Relative tolerance
+test(1000.0, 1001.0, rel_tol=1e-3)
+test(1000.0, 1001.0, rel_tol=1e-4)
+test(1000, 1001, rel_tol=1e-3)
+test(1000, 1001, rel_tol=1e-4)
+test_combinations(0, 1, rel_tol=1.0)
+
+# Absolute tolerance
+test(0.0, 1e-10, abs_tol=1e-10, rel_tol=0.1)
+test(0.0, 1e-10, abs_tol=0.0, rel_tol=0.1)
+
+# Bad parameters
+try:
+    isclose(0, 0, abs_tol=-1)
+except ValueError:
+    print("ValueError")
+try:
+    isclose(0, 0, rel_tol=-1)
+except ValueError:
+    print("ValueError")
diff --git a/tests/float/math_isclose.py.exp b/tests/float/math_isclose.py.exp
new file mode 100644
index 0000000000000..02974666c073a
--- /dev/null
+++ b/tests/float/math_isclose.py.exp
@@ -0,0 +1,27 @@
+False
+False
+False
+True
+True
+False
+False
+True
+True
+False
+False
+True
+True
+True
+True
+True
+False
+True
+False
+True
+True
+True
+True
+True
+False
+ValueError
+ValueError
diff --git a/tests/float/python36.py b/tests/float/python36.py
index 6e8fb1f21385b..9e64e7a06a35a 100644
--- a/tests/float/python36.py
+++ b/tests/float/python36.py
@@ -2,9 +2,9 @@
 
 # underscores in numeric literals
 print(1_000.1_8)
-print('%.2g' % 1e1_2)
+print("%.2g" % 1e1_2)
 
 # underscore supported by int/float constructors
-print(float('1_2_3'))
-print(float('1_2_3.4'))
-print('%.2g' % float('1e1_3'))
+print(float("1_2_3"))
+print(float("1_2_3.4"))
+print("%.2g" % float("1e1_3"))
diff --git a/tests/float/string_format.py b/tests/float/string_format.py
index 6fb11c35acaba..13382b9037529 100644
--- a/tests/float/string_format.py
+++ b/tests/float/string_format.py
@@ -1,5 +1,6 @@
 def test(fmt, *args):
-    print('{:8s}'.format(fmt) + '>' +  fmt.format(*args) + '<')
+    print("{:8s}".format(fmt) + ">" + fmt.format(*args) + "<")
+
 
 test("{:10.4}", 123.456)
 test("{:10.4e}", 123.456)
@@ -24,18 +25,21 @@ def test(fmt, *args):
 test("{:06e}", float("-inf"))
 test("{:06e}", float("nan"))
 
+test("{:f}", False)
+test("{:f}", True)
+
 # The following fails right now
-#test("{:10.1}", 0.0)
+# test("{:10.1}", 0.0)
 
 print("%.0f" % (1.750000 % 0.08333333333))
 # Below isn't compatible with single-precision float
-#print("%.1f" % (1.750000 % 0.08333333333))
-#print("%.2f" % (1.750000 % 0.08333333333))
-#print("%.12f" % (1.750000 % 0.08333333333))
+# print("%.1f" % (1.750000 % 0.08333333333))
+# print("%.2f" % (1.750000 % 0.08333333333))
+# print("%.12f" % (1.750000 % 0.08333333333))
 
 # tests for errors in format string
 
 try:
-    '{:10.1b}'.format(0.0)
+    "{:10.1b}".format(0.0)
 except ValueError:
-    print('ValueError')
+    print("ValueError")
diff --git a/tests/float/string_format2.py b/tests/float/string_format2.py
index 269023e7ffb62..7a36f4d2f95dc 100644
--- a/tests/float/string_format2.py
+++ b/tests/float/string_format2.py
@@ -3,15 +3,17 @@
 
 full_tests = False
 
+
 def test(fmt, *args):
-    print('{:8s}'.format(fmt) + '>' +  fmt.format(*args) + '<')
+    print("{:8s}".format(fmt) + ">" + fmt.format(*args) + "<")
+
 
 def test_fmt(conv, fill, alignment, sign, prefix, width, precision, type, arg):
-    fmt = '{'
+    fmt = "{"
     if conv:
-        fmt += '!'
+        fmt += "!"
         fmt += conv
-    fmt += ':'
+    fmt += ":"
     if alignment:
         fmt += fill
         fmt += alignment
@@ -19,88 +21,162 @@ def test_fmt(conv, fill, alignment, sign, prefix, width, precision, type, arg):
     fmt += prefix
     fmt += width
     if precision:
-        fmt += '.'
+        fmt += "."
         fmt += precision
     fmt += type
-    fmt += '}'
-    test(fmt,  arg)
-    if fill == '0' and alignment == '=':
-        fmt = '{:'
+    fmt += "}"
+    test(fmt, arg)
+    if fill == "0" and alignment == "=":
+        fmt = "{:"
         fmt += sign
         fmt += prefix
         fmt += width
         if precision:
-            fmt += '.'
+            fmt += "."
             fmt += precision
         fmt += type
-        fmt += '}'
+        fmt += "}"
         test(fmt, arg)
 
-eg_nums = (0.0, -0.0, 0.1, 1.234, 12.3459, 1.23456789, 123456789.0, -0.0,
-    -0.1, -1.234, -12.3459, 1e4, 1e-4, 1e5, 1e-5, 1e6, 1e-6, 1e10,
-    1e37, -1e37, 1e-37, -1e-37,
-    1.23456e8, 1.23456e7, 1.23456e6, 1.23456e5, 1.23456e4, 1.23456e3, 1.23456e2, 1.23456e1, 1.23456e0,
-    1.23456e-1, 1.23456e-2, 1.23456e-3, 1.23456e-4, 1.23456e-5, 1.23456e-6, 1.23456e-7, 1.23456e-8,
-    -1.23456e8, -1.23456e7, -1.23456e6, -1.23456e5, -1.23456e4, -1.23456e3, -1.23456e2, -1.23456e1, -1.23456e0,
-    -1.23456e-1, -1.23456e-2, -1.23456e-3, -1.23456e-4, -1.23456e-5, -1.23456e-6, -1.23456e-7, -1.23456e-8)
+
+eg_nums = (
+    0.0,
+    -0.0,
+    0.1,
+    1.234,
+    12.3459,
+    1.23456789,
+    123456789.0,
+    -0.0,
+    -0.1,
+    -1.234,
+    -12.3459,
+    1e4,
+    1e-4,
+    1e5,
+    1e-5,
+    1e6,
+    1e-6,
+    1e10,
+    1e37,
+    -1e37,
+    1e-37,
+    -1e-37,
+    1.23456e8,
+    1.23456e7,
+    1.23456e6,
+    1.23456e5,
+    1.23456e4,
+    1.23456e3,
+    1.23456e2,
+    1.23456e1,
+    1.23456e0,
+    1.23456e-1,
+    1.23456e-2,
+    1.23456e-3,
+    1.23456e-4,
+    1.23456e-5,
+    1.23456e-6,
+    1.23456e-7,
+    1.23456e-8,
+    -1.23456e8,
+    -1.23456e7,
+    -1.23456e6,
+    -1.23456e5,
+    -1.23456e4,
+    -1.23456e3,
+    -1.23456e2,
+    -1.23456e1,
+    -1.23456e0,
+    -1.23456e-1,
+    -1.23456e-2,
+    -1.23456e-3,
+    -1.23456e-4,
+    -1.23456e-5,
+    -1.23456e-6,
+    -1.23456e-7,
+    -1.23456e-8,
+)
 
 if full_tests:
-    for type in ('e', 'E', 'g', 'G', 'n'):
-        for width in ('', '4', '6', '8', '10'):
-            for alignment in ('', '<', '>', '=', '^'):
-                for fill in ('', '@', '0', ' '):
-                    for sign in ('', '+', '-', ' '):
-                        for prec in ('', '1', '3', '6'):
+    for type in ("e", "E", "g", "G", "n"):
+        for width in ("", "4", "6", "8", "10"):
+            for alignment in ("", "<", ">", "=", "^"):
+                for fill in ("", "@", "0", " "):
+                    for sign in ("", "+", "-", " "):
+                        for prec in ("", "1", "3", "6"):
                             for num in eg_nums:
-                                test_fmt('', fill, alignment, sign, '', width, prec, type, num)
+                                test_fmt("", fill, alignment, sign, "", width, prec, type, num)
 
 # Note: We use 1.23459 rather than 1.2345 because '{:3f}'.format(1.2345)
 #       rounds differently than print("%.3f", 1.2345);
 
-f_nums = (0.0, -0.0, 0.0001, 0.001, 0.01, 0.1, 1.0, 10.0,
-     0.0012,  0.0123,  0.1234,  1.23459,  12.3456,
-    -0.0001, -0.001,  -0.01,   -0.1,      -1.0, -10.0,
-    -0.0012, -0.0123, -0.1234, -1.23459, -12.3456)
+f_nums = (
+    0.0,
+    -0.0,
+    0.0001,
+    0.001,
+    0.01,
+    0.1,
+    1.0,
+    10.0,
+    0.0012,
+    0.0123,
+    0.1234,
+    1.23459,
+    12.3456,
+    -0.0001,
+    -0.001,
+    -0.01,
+    -0.1,
+    -1.0,
+    -10.0,
+    -0.0012,
+    -0.0123,
+    -0.1234,
+    -1.23459,
+    -12.3456,
+)
 
 if full_tests:
-    for type in ('f', 'F'):
-        for width in ('', '4', '6', '8', '10'):
-            for alignment in ('', '<', '>', '=', '^'):
-                for fill in ('', ' ', '0', '@'):
-                    for sign in ('', '+', '-', ' '):
+    for type in ("f", "F"):
+        for width in ("", "4", "6", "8", "10"):
+            for alignment in ("", "<", ">", "=", "^"):
+                for fill in ("", " ", "0", "@"):
+                    for sign in ("", "+", "-", " "):
                         # An empty precision defaults to 6, but when uPy is
                         # configured to use a float, we can only use a
                         # precision of 6 with numbers less than 10 and still
                         # get results that compare to CPython (which uses
                         # long doubles).
-                        for prec in ('1', '2', '3'):
+                        for prec in ("1", "2", "3"):
                             for num in f_nums:
-                                test_fmt('', fill, alignment, sign, '', width, prec, type, num)
+                                test_fmt("", fill, alignment, sign, "", width, prec, type, num)
                         for num in int_nums2:
-                            test_fmt('', fill, alignment, sign, '', width, '', type, num)
+                            test_fmt("", fill, alignment, sign, "", width, "", type, num)
 
 pct_nums1 = (0.1, 0.58, 0.99, -0.1, -0.58, -0.99)
 pct_nums2 = (True, False, 1, 0, -1)
 
 if full_tests:
-    type = '%'
-    for width in ('', '4', '6', '8', '10'):
-        for alignment in ('', '<', '>', '=', '^'):
-            for fill in ('', ' ', '0', '@'):
-                for sign in ('', '+', '-', ' '):
+    type = "%"
+    for width in ("", "4", "6", "8", "10"):
+        for alignment in ("", "<", ">", "=", "^"):
+            for fill in ("", " ", "0", "@"):
+                for sign in ("", "+", "-", " "):
                     # An empty precision defaults to 6, but when uPy is
                     # configured to use a float, we can only use a
                     # precision of 6 with numbers less than 10 and still
                     # get results that compare to CPython (which uses
                     # long doubles).
-                    for prec in ('1', '2', '3'):
+                    for prec in ("1", "2", "3"):
                         for num in pct_nums1:
-                            test_fmt('', fill, alignment, sign, '', width, prec, type, num)
+                            test_fmt("", fill, alignment, sign, "", width, prec, type, num)
                     for num in pct_nums2:
-                        test_fmt('', fill, alignment, sign, '', width, '', type, num)
+                        test_fmt("", fill, alignment, sign, "", width, "", type, num)
 else:
     for num in pct_nums1:
-        test_fmt('', '', '', '', '', '', '1', '%', num)
+        test_fmt("", "", "", "", "", "", "1", "%", num)
 
 # We don't currently test a type of '' with floats (see the detailed comment
 # in  objstr.c)
diff --git a/tests/float/string_format_fp30.py b/tests/float/string_format_fp30.py
index 77b2a528852c2..5f0b213daa342 100644
--- a/tests/float/string_format_fp30.py
+++ b/tests/float/string_format_fp30.py
@@ -1,11 +1,12 @@
 def test(fmt, *args):
-    print('{:8s}'.format(fmt) + '>' +  fmt.format(*args) + '<')
+    print("{:8s}".format(fmt) + ">" + fmt.format(*args) + "<")
+
 
 test("{:10.4}", 123.456)
 test("{:10.4e}", 123.456)
 test("{:10.4e}", -123.456)
-#test("{:10.4f}", 123.456)
-#test("{:10.4f}", -123.456)
+# test("{:10.4f}", 123.456)
+# test("{:10.4f}", -123.456)
 test("{:10.4g}", 123.456)
 test("{:10.4g}", -123.456)
 test("{:10.4n}", 123.456)
@@ -15,8 +16,8 @@ def test(fmt, *args):
 
 test("{:10.4E}", 123.456)
 test("{:10.4E}", -123.456)
-#test("{:10.4F}", 123.456)
-#test("{:10.4F}", -123.456)
+# test("{:10.4F}", 123.456)
+# test("{:10.4F}", -123.456)
 test("{:10.4G}", 123.456)
 test("{:10.4G}", -123.456)
 
@@ -25,17 +26,17 @@ def test(fmt, *args):
 test("{:06e}", float("nan"))
 
 # The following fails right now
-#test("{:10.1}", 0.0)
+# test("{:10.1}", 0.0)
 
 print("%.0f" % (1.750000 % 0.08333333333))
 # Below isn't compatible with single-precision float
-#print("%.1f" % (1.750000 % 0.08333333333))
-#print("%.2f" % (1.750000 % 0.08333333333))
-#print("%.12f" % (1.750000 % 0.08333333333))
+# print("%.1f" % (1.750000 % 0.08333333333))
+# print("%.2f" % (1.750000 % 0.08333333333))
+# print("%.12f" % (1.750000 % 0.08333333333))
 
 # tests for errors in format string
 
 try:
-    '{:10.1b}'.format(0.0)
+    "{:10.1b}".format(0.0)
 except ValueError:
-    print('ValueError')
+    print("ValueError")
diff --git a/tests/float/string_format_modulo.py b/tests/float/string_format_modulo.py
index aea534247cc20..09446153810db 100644
--- a/tests/float/string_format_modulo.py
+++ b/tests/float/string_format_modulo.py
@@ -7,9 +7,9 @@
 
 # these 3 have different behaviour in Python 3.x versions
 # uPy raises a TypeError, following Python 3.5 (earlier versions don't)
-#print("%x" % 18.0)
-#print("%o" % 18.0)
-#print("%X" % 18.0)
+# print("%x" % 18.0)
+# print("%o" % 18.0)
+# print("%X" % 18.0)
 
 print("%e" % 1.23456)
 print("%E" % 1.23456)
@@ -22,28 +22,28 @@
 print("%06e" % float("-inf"))
 print("%06e" % float("nan"))
 
-print("%02.3d" % 123) # prec > width
-print("%+f %+f" % (1.23, -1.23)) # float sign
-print("% f % f" % (1.23, -1.23)) # float space sign
-print("%0f" % -1.23) # negative number with 0 padding
+print("%02.3d" % 123)  # prec > width
+print("%+f %+f" % (1.23, -1.23))  # float sign
+print("% f % f" % (1.23, -1.23))  # float space sign
+print("%0f" % -1.23)  # negative number with 0 padding
 
 # numbers with large negative exponents
-print('%f' % 1e-10)
-print('%f' % 1e-20)
-print('%f' % 1e-50)
-print('%f' % 1e-100)
-print('%f' % 1e-300)
+print("%f" % 1e-10)
+print("%f" % 1e-20)
+print("%f" % 1e-50)
+print("%f" % 1e-100)
+print("%f" % 1e-300)
 
 # large decimal precision should be truncated and not overflow buffer
 # the output depends on the FP calculation so only first 2 digits are printed
 # (the 'g' with small e are printed using 'f' style, so need to be checked)
-print(('%.40f' % 1e-300)[:2])
-print(('%.40g' % 1e-1)[:2])
-print(('%.40g' % 1e-2)[:2])
-print(('%.40g' % 1e-3)[:2])
-print(('%.40g' % 1e-4)[:2])
+print(("%.40f" % 1e-300)[:2])
+print(("%.40g" % 1e-1)[:2])
+print(("%.40g" % 1e-2)[:2])
+print(("%.40g" % 1e-3)[:2])
+print(("%.40g" % 1e-4)[:2])
 
-print("%.0g" % 1) # 0 precision 'g'
+print("%.0g" % 1)  # 0 precision 'g'
 
-print('%.1e' % 9.99) # round up with positive exponent
-print('%.1e' % 0.999) # round up with negative exponent
+print("%.1e" % 9.99)  # round up with positive exponent
+print("%.1e" % 0.999)  # round up with negative exponent
diff --git a/tests/float/string_format_modulo2.py b/tests/float/string_format_modulo2.py
index f6b1ae537d5e4..b22021c5d004a 100644
--- a/tests/float/string_format_modulo2.py
+++ b/tests/float/string_format_modulo2.py
@@ -1,24 +1,26 @@
 # test formatting floats with large precision, that it doesn't overflow the buffer
 
+
 def test(num, num_str):
-    if num == float('inf') or num == 0.0 and num_str != '0.0':
+    if num == float("inf") or num == 0.0 and num_str != "0.0":
         # skip numbers that overflow or underflow the FP precision
         return
-    for kind in ('e', 'f', 'g'):
+    for kind in ("e", "f", "g"):
         # check precision either side of the size of the buffer (32 bytes)
         for prec in range(23, 36, 2):
-            fmt = '%.' + '%d' % prec + kind
+            fmt = "%." + "%d" % prec + kind
             s = fmt % num
             check = abs(float(s) - num)
             if num > 1:
                 check /= num
             if check > 1e-6:
-                print('FAIL', num_str, fmt, s, len(s), check)
+                print("FAIL", num_str, fmt, s, len(s), check)
+
 
 # check pure zero
-test(0.0, '0.0')
+test(0.0, "0.0")
 
 # check some powers of 10, making sure to include exponents with 3 digits
 for e in range(-8, 8):
     num = pow(10, e)
-    test(num, '1e%d' % e)
+    test(num, "1e%d" % e)
diff --git a/tests/float/string_format_modulo2_intbig.py b/tests/float/string_format_modulo2_intbig.py
index 9992ba65d9d3d..8110bc7f62e2f 100644
--- a/tests/float/string_format_modulo2_intbig.py
+++ b/tests/float/string_format_modulo2_intbig.py
@@ -1,21 +1,23 @@
 # test formatting floats with large precision, that it doesn't overflow the buffer
 
+
 def test(num, num_str):
-    if num == float('inf') or num == 0.0 and num_str != '0.0':
+    if num == float("inf") or num == 0.0 and num_str != "0.0":
         # skip numbers that overflow or underflow the FP precision
         return
-    for kind in ('e', 'f', 'g'):
+    for kind in ("e", "f", "g"):
         # check precision either side of the size of the buffer (32 bytes)
         for prec in range(23, 36, 2):
-            fmt = '%.' + '%d' % prec + kind
+            fmt = "%." + "%d" % prec + kind
             s = fmt % num
             check = abs(float(s) - num)
             if num > 1:
                 check /= num
             if check > 1e-6:
-                print('FAIL', num_str, fmt, s, len(s), check)
+                print("FAIL", num_str, fmt, s, len(s), check)
+
 
 # check most powers of 10, making sure to include exponents with 3 digits
 for e in range(-101, 102):
     num = pow(10, e)
-    test(num, '1e%d' % e)
+    test(num, "1e%d" % e)
diff --git a/tests/float/string_format_modulo3.py b/tests/float/string_format_modulo3.py
index 5d26f25751d49..f9d9c43cdf42d 100644
--- a/tests/float/string_format_modulo3.py
+++ b/tests/float/string_format_modulo3.py
@@ -1,3 +1,3 @@
 # uPy and CPython outputs differ for the following
-print("%.1g" % -9.9) # round up 'g' with '-' sign
-print("%.2g" % 99.9) # round up
+print("%.1g" % -9.9)  # round up 'g' with '-' sign
+print("%.2g" % 99.9)  # round up
diff --git a/tests/float/true_value.py b/tests/float/true_value.py
index df415f0031db0..4c8d2e5c8212d 100644
--- a/tests/float/true_value.py
+++ b/tests/float/true_value.py
@@ -3,5 +3,5 @@
 if not 0.0:
     print("float 0")
 
-if not 0+0j:
+if not 0 + 0j:
     print("complex 0")
diff --git a/tests/import/builtin_import.py b/tests/import/builtin_import.py
index 088f631fcd3c4..734498d1be47b 100644
--- a/tests/import/builtin_import.py
+++ b/tests/import/builtin_import.py
@@ -1,16 +1,22 @@
 # test calling builtin import function
 
 # basic test
-__import__('builtins')
+__import__("builtins")
 
 # first arg should be a string
 try:
     __import__(1)
 except TypeError:
-    print('TypeError')
+    print("TypeError")
+
+# module name should not be empty
+try:
+    __import__("")
+except ValueError:
+    print("ValueError")
 
 # level argument should be non-negative
 try:
-    __import__('xyz', None, None, None, -1)
+    __import__("xyz", None, None, None, -1)
 except ValueError:
-    print('ValueError')
+    print("ValueError")
diff --git a/tests/import/gen_context.py b/tests/import/gen_context.py
index 02f1531467f10..b7567cf02d96c 100644
--- a/tests/import/gen_context.py
+++ b/tests/import/gen_context.py
@@ -2,8 +2,10 @@
 
 GLOBAL = "GLOBAL"
 
+
 def gen():
     print(GLOBAL)
     yield 1
 
+
 gen_context2.call(gen())
diff --git a/tests/import/import1a.py b/tests/import/import1a.py
index 16b2d4d30f61c..9d7d72ff77822 100644
--- a/tests/import/import1a.py
+++ b/tests/import/import1a.py
@@ -1,2 +1,3 @@
 import import1b
+
 print(import1b.var)
diff --git a/tests/import/import1b.py b/tests/import/import1b.py
index be74eca094b52..8c9d15a71f4bc 100644
--- a/tests/import/import1b.py
+++ b/tests/import/import1b.py
@@ -1,4 +1,5 @@
 var = 123
 
+
 def throw():
     raise ValueError
diff --git a/tests/import/import2a.py b/tests/import/import2a.py
index def6aeb6aa383..8fb4905250169 100644
--- a/tests/import/import2a.py
+++ b/tests/import/import2a.py
@@ -1,5 +1,7 @@
 from import1b import var
+
 print(var)
 
 from import1b import var as var2
+
 print(var2)
diff --git a/tests/import/import3a.py b/tests/import/import3a.py
index 2e9d41f71dbdf..2fadd8a52ba64 100644
--- a/tests/import/import3a.py
+++ b/tests/import/import3a.py
@@ -1,2 +1,3 @@
 from import1b import *
+
 print(var)
diff --git a/tests/import/import_file.py b/tests/import/import_file.py
index cb9a88a706ec6..90ec4e41e77aa 100644
--- a/tests/import/import_file.py
+++ b/tests/import/import_file.py
@@ -1,2 +1,3 @@
 import import1b
+
 print(import1b.__file__)
diff --git a/tests/import/import_override.py b/tests/import/import_override.py
new file mode 100644
index 0000000000000..029ebe54c1f70
--- /dev/null
+++ b/tests/import/import_override.py
@@ -0,0 +1,21 @@
+# test overriding __import__ combined with importing from the filesystem
+
+
+def custom_import(name, globals, locals, fromlist, level):
+    print("import", name, fromlist, level)
+
+    class M:
+        var = 456
+
+    return M
+
+
+orig_import = __import__
+try:
+    __import__("builtins").__import__ = custom_import
+except AttributeError:
+    print("SKIP")
+    raise SystemExit
+
+# import1a will be done via normal import which will import1b via our custom import
+orig_import("import1a")
diff --git a/tests/import/import_override.py.exp b/tests/import/import_override.py.exp
new file mode 100644
index 0000000000000..365248da6d847
--- /dev/null
+++ b/tests/import/import_override.py.exp
@@ -0,0 +1,2 @@
+import import1b None 0
+456
diff --git a/tests/import/import_pkg1.py b/tests/import/import_pkg1.py
index fe6e4473e3388..5c1b2ef4c75ba 100644
--- a/tests/import/import_pkg1.py
+++ b/tests/import/import_pkg1.py
@@ -12,5 +12,6 @@
 
 # import using "as"
 import pkg.mod as mm
+
 print(mm is pkg.mod)
 print(mm.foo())
diff --git a/tests/import/import_pkg3.py b/tests/import/import_pkg3.py
index 0ee885b220860..ec4697906205d 100644
--- a/tests/import/import_pkg3.py
+++ b/tests/import/import_pkg3.py
@@ -3,4 +3,5 @@
 print(mod.foo())
 
 import pkg.mod
+
 print(mod is pkg.mod)
diff --git a/tests/import/import_star_error.py b/tests/import/import_star_error.py
new file mode 100644
index 0000000000000..9e1757b6ef5a2
--- /dev/null
+++ b/tests/import/import_star_error.py
@@ -0,0 +1,13 @@
+# test errors with import *
+
+# 'import *' is not allowed in function scope
+try:
+    exec("def foo(): from x import *")
+except SyntaxError as er:
+    print("function", "SyntaxError")
+
+# 'import *' is not allowed in class scope
+try:
+    exec("class C: from x import *")
+except SyntaxError as er:
+    print("class", "SyntaxError")
diff --git a/tests/import/module_getattr.py b/tests/import/module_getattr.py
index 4a18f414dde63..df7a6218156c5 100644
--- a/tests/import/module_getattr.py
+++ b/tests/import/module_getattr.py
@@ -10,13 +10,14 @@
 
 # define __getattr__
 def __getattr__(attr):
-    if attr == 'does_not_exist':
+    if attr == "does_not_exist":
         return False
     raise AttributeError
 
+
 # do feature test (will also test functionality if the feature exists)
-if not hasattr(this, 'does_not_exist'):
-    print('SKIP')
+if not hasattr(this, "does_not_exist"):
+    print("SKIP")
     raise SystemExit
 
 # check that __getattr__ works as expected
diff --git a/tests/import/mpy_invalid.py b/tests/import/mpy_invalid.py
index 6e9cbc9db92e4..d6d01e7f1fc0c 100644
--- a/tests/import/mpy_invalid.py
+++ b/tests/import/mpy_invalid.py
@@ -5,6 +5,7 @@
 try:
     uio.IOBase
     import uos
+
     uos.mount
 except (ImportError, AttributeError):
     print("SKIP")
@@ -15,8 +16,10 @@ class UserFile(uio.IOBase):
     def __init__(self, data):
         self.data = data
         self.pos = 0
+
     def read(self):
         return self.data
+
     def readinto(self, buf):
         n = 0
         while n < len(buf) and self.pos < len(self.data):
@@ -24,6 +27,7 @@ def readinto(self, buf):
             n += 1
             self.pos += 1
         return n
+
     def ioctl(self, req, arg):
         return 0
 
@@ -31,38 +35,42 @@ def ioctl(self, req, arg):
 class UserFS:
     def __init__(self, files):
         self.files = files
+
     def mount(self, readonly, mksfs):
         pass
+
     def umount(self):
         pass
+
     def stat(self, path):
         if path in self.files:
             return (32768, 0, 0, 0, 0, 0, 0, 0, 0, 0)
         raise OSError
+
     def open(self, path, mode):
         return UserFile(self.files[path])
 
 
 # these are the test .mpy files
 user_files = {
-    '/mod0.mpy': b'', # empty file
-    '/mod1.mpy': b'M', # too short header
-    '/mod2.mpy': b'M\x00\x00\x00', # bad version
-    '/mod3.mpy': b'M\x00\x00\x00\x7f', # qstr window too large
+    "/mod0.mpy": b"",  # empty file
+    "/mod1.mpy": b"M",  # too short header
+    "/mod2.mpy": b"M\x00\x00\x00",  # bad version
+    "/mod3.mpy": b"M\x00\x00\x00\x7f",  # qstr window too large
 }
 
 # create and mount a user filesystem
-uos.mount(UserFS(user_files), '/userfs')
-sys.path.append('/userfs')
+uos.mount(UserFS(user_files), "/userfs")
+sys.path.append("/userfs")
 
 # import .mpy files from the user filesystem
 for i in range(len(user_files)):
-    mod = 'mod%u' % i
+    mod = "mod%u" % i
     try:
         __import__(mod)
     except ValueError as er:
-        print(mod, 'ValueError', er)
+        print(mod, "ValueError", er)
 
 # unmount and undo path addition
-uos.umount('/userfs')
+uos.umount("/userfs")
 sys.path.pop()
diff --git a/tests/import/mpy_native.py b/tests/import/mpy_native.py
index e03d14e2ed149..5d7bdab4a2aaa 100644
--- a/tests/import/mpy_native.py
+++ b/tests/import/mpy_native.py
@@ -5,12 +5,13 @@
 try:
     uio.IOBase
     import uos
+
     uos.mount
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
 
-if not (sys.platform == 'linux' and sys.maxsize > 2 ** 32):
+if not (sys.platform == "linux" and sys.maxsize > 2 ** 32):
     print("SKIP")
     raise SystemExit
 
@@ -19,8 +20,10 @@ class UserFile(uio.IOBase):
     def __init__(self, data):
         self.data = data
         self.pos = 0
+
     def read(self):
         return self.data
+
     def readinto(self, buf):
         n = 0
         while n < len(buf) and self.pos < len(self.data):
@@ -28,6 +31,7 @@ def readinto(self, buf):
             n += 1
             self.pos += 1
         return n
+
     def ioctl(self, req, arg):
         return 0
 
@@ -35,33 +39,38 @@ def ioctl(self, req, arg):
 class UserFS:
     def __init__(self, files):
         self.files = files
+
     def mount(self, readonly, mksfs):
         pass
+
     def umount(self):
         pass
+
     def stat(self, path):
         if path in self.files:
             return (32768, 0, 0, 0, 0, 0, 0, 0, 0, 0)
         raise OSError
+
     def open(self, path, mode):
         return UserFile(self.files[path])
 
 
 # these are the test .mpy files
+# fmt: off
 user_files = {
     # bad architecture
-    '/mod0.mpy': b'M\x04\xff\x00\x10',
+    '/mod0.mpy': b'M\x05\xff\x00\x10',
 
     # test loading of viper and asm
     '/mod1.mpy': (
-        b'M\x04\x0b\x1f\x20' # header
+        b'M\x05\x0b\x1f\x20' # header
 
-        b'\x38' # n bytes, bytecode
-            b'\x01\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\xff' # prelude
-            b'\x11' # LOAD_CONST_NONE
-            b'\x5b' # RETURN_VALUE
+        b'\x20' # n bytes, bytecode
+            b'\x00\x08\x02m\x02m' # prelude
+            b'\x51' # LOAD_CONST_NONE
+            b'\x63' # RETURN_VALUE
 
-            b'\x02m\x02m\x00\x02' # simple_name, source_file, n_obj, n_raw_code
+            b'\x00\x02' # n_obj, n_raw_code
 
         b'\x22' # n bytes, viper code
             b'\x00\x00\x00\x00\x00\x00' # dummy machine code
@@ -73,21 +82,43 @@ def open(self, path, mode):
             b'\x00\x00\x00\x00\x00\x00\x00\x00' # dummy machine code
             b'\x00\x00\x00' # scope_flags, n_pos_args, type_sig
     ),
+
+    # test loading viper with additional scope flags and relocation
+    '/mod2.mpy': (
+        b'M\x05\x0b\x1f\x20' # header
+
+        b'\x20' # n bytes, bytecode
+            b'\x00\x08\x02m\x02m' # prelude
+            b'\x51' # LOAD_CONST_NONE
+            b'\x63' # RETURN_VALUE
+
+            b'\x00\x01' # n_obj, n_raw_code
+
+        b'\x12' # n bytes(=4), viper code
+            b'\x00\x00\x00\x00' # dummy machine code
+            b'\x00' # n_qstr
+            b'\x70' # scope_flags: VIPERBSS | VIPERRODATA | VIPERRELOC
+            b'\x00\x00' # n_obj, n_raw_code
+            b'\x06rodata' # rodata, 6 bytes
+            b'\x04' # bss, 4 bytes
+            b'\x03\x01\x00' # dummy relocation of rodata
+    ),
 }
+# fmt: on
 
 # create and mount a user filesystem
-uos.mount(UserFS(user_files), '/userfs')
-sys.path.append('/userfs')
+uos.mount(UserFS(user_files), "/userfs")
+sys.path.append("/userfs")
 
 # import .mpy files from the user filesystem
 for i in range(len(user_files)):
-    mod = 'mod%u' % i
+    mod = "mod%u" % i
     try:
         __import__(mod)
-        print(mod, 'OK')
+        print(mod, "OK")
     except ValueError as er:
-        print(mod, 'ValueError', er)
+        print(mod, "ValueError", er)
 
 # unmount and undo path addition
-uos.umount('/userfs')
+uos.umount("/userfs")
 sys.path.pop()
diff --git a/tests/import/mpy_native.py.exp b/tests/import/mpy_native.py.exp
index b73812094a493..320cac09d8c85 100644
--- a/tests/import/mpy_native.py.exp
+++ b/tests/import/mpy_native.py.exp
@@ -1,2 +1,3 @@
 mod0 ValueError incompatible .mpy arch
 mod1 OK
+mod2 OK
diff --git a/tests/import/pkg3/mod2.py b/tests/import/pkg3/mod2.py
index 67f43bad5217f..37721faaf3191 100644
--- a/tests/import/pkg3/mod2.py
+++ b/tests/import/pkg3/mod2.py
@@ -1,5 +1,6 @@
 print("mod2 __name__:", __name__)
 print("in mod2")
 
+
 def foo():
     print("mod2.foo()")
diff --git a/tests/import/pkg6/__init__.py b/tests/import/pkg6/__init__.py
index 923531c1b91f5..5215da2ec49d8 100644
--- a/tests/import/pkg6/__init__.py
+++ b/tests/import/pkg6/__init__.py
@@ -1,2 +1,3 @@
 from .x import *
-print('init')
+
+print("init")
diff --git a/tests/import/pkg6/x/__init__.py b/tests/import/pkg6/x/__init__.py
index 6b8b84d0eee22..80817917daedb 100644
--- a/tests/import/pkg6/x/__init__.py
+++ b/tests/import/pkg6/x/__init__.py
@@ -1,2 +1,3 @@
 from .y import *
-print('x')
+
+print("x")
diff --git a/tests/import/pkg6/x/y.py b/tests/import/pkg6/x/y.py
index e8d863c6cdd42..0abc82404dc5d 100644
--- a/tests/import/pkg6/x/y.py
+++ b/tests/import/pkg6/x/y.py
@@ -1 +1 @@
-print('y')
+print("y")
diff --git a/tests/import/pkg7/mod1.py b/tests/import/pkg7/mod1.py
index 6b574114d1863..0a5eb15052f25 100644
--- a/tests/import/pkg7/mod1.py
+++ b/tests/import/pkg7/mod1.py
@@ -1,2 +1,2 @@
-print('mod1')
-foo = 'mod1.foo'
+print("mod1")
+foo = "mod1.foo"
diff --git a/tests/import/pkg7/mod2.py b/tests/import/pkg7/mod2.py
index 039a5d174995b..657a6fb523666 100644
--- a/tests/import/pkg7/mod2.py
+++ b/tests/import/pkg7/mod2.py
@@ -1,2 +1,2 @@
-print('mod2')
-bar = 'mod2.bar'
+print("mod2")
+bar = "mod2.bar"
diff --git a/tests/import/pkg7/subpkg1/subpkg2/mod3.py b/tests/import/pkg7/subpkg1/subpkg2/mod3.py
index c73e2081f0c22..0aa916d2082d2 100644
--- a/tests/import/pkg7/subpkg1/subpkg2/mod3.py
+++ b/tests/import/pkg7/subpkg1/subpkg2/mod3.py
@@ -1,5 +1,6 @@
 from ... import mod1
 from ...mod2 import bar
+
 print(mod1.foo)
 print(bar)
 
@@ -7,4 +8,4 @@
 try:
     from .... import mod1
 except ValueError:
-    print('ValueError')
+    print("ValueError")
diff --git a/tests/import/pkg8/mod.py b/tests/import/pkg8/mod.py
index b98f02ce6e01d..3d3d53a16273e 100644
--- a/tests/import/pkg8/mod.py
+++ b/tests/import/pkg8/mod.py
@@ -1 +1 @@
-print('foo')
+print("foo")
diff --git a/tests/import/try_module.py b/tests/import/try_module.py
index 03a9db15b5702..7c97df28b342e 100644
--- a/tests/import/try_module.py
+++ b/tests/import/try_module.py
@@ -2,8 +2,10 @@
 # its namespace stick and namespace of current module not coming back.
 import import1b
 
+
 def func1():
-    print('func1')
+    print("func1")
+
 
 def func2():
     try:
@@ -12,4 +14,5 @@ def func2():
         pass
     func1()
 
+
 func2()
diff --git a/tests/inlineasm/asmargs.py b/tests/inlineasm/asmargs.py
index 047d9ed4200f1..3b03f15103b88 100644
--- a/tests/inlineasm/asmargs.py
+++ b/tests/inlineasm/asmargs.py
@@ -1,29 +1,44 @@
 # test passing arguments
 
+
 @micropython.asm_thumb
 def arg0():
     mov(r0, 1)
+
+
 print(arg0())
 
+
 @micropython.asm_thumb
 def arg1(r0):
     add(r0, r0, 1)
+
+
 print(arg1(1))
 
+
 @micropython.asm_thumb
 def arg2(r0, r1):
     add(r0, r0, r1)
+
+
 print(arg2(1, 2))
 
+
 @micropython.asm_thumb
 def arg3(r0, r1, r2):
     add(r0, r0, r1)
     add(r0, r0, r2)
+
+
 print(arg3(1, 2, 3))
 
+
 @micropython.asm_thumb
 def arg4(r0, r1, r2, r3):
     add(r0, r0, r1)
     add(r0, r0, r2)
     add(r0, r0, r3)
+
+
 print(arg4(1, 2, 3, 4))
diff --git a/tests/inlineasm/asmbcc.py b/tests/inlineasm/asmbcc.py
index 540fa6591fb9d..08967d48c7484 100644
--- a/tests/inlineasm/asmbcc.py
+++ b/tests/inlineasm/asmbcc.py
@@ -1,6 +1,7 @@
 # test bcc instructions
 # at the moment only tests beq, narrow and wide versions
 
+
 @micropython.asm_thumb
 def f(r0):
     mov(r1, r0)
@@ -21,6 +22,7 @@ def f(r0):
 
     label(end)
 
+
 print(f(0))
 print(f(1))
 print(f(2))
diff --git a/tests/inlineasm/asmbitops.py b/tests/inlineasm/asmbitops.py
index 8cf92b301f76d..d1c8a98235ca6 100644
--- a/tests/inlineasm/asmbitops.py
+++ b/tests/inlineasm/asmbitops.py
@@ -2,12 +2,15 @@
 def clz(r0):
     clz(r0, r0)
 
-print(clz(0xf0))
+
+print(clz(0xF0))
 print(clz(0x8000))
 
+
 @micropython.asm_thumb
 def rbit(r0):
     rbit(r0, r0)
 
-print(hex(rbit(0xf0)))
+
+print(hex(rbit(0xF0)))
 print(hex(rbit(0x8000)))
diff --git a/tests/inlineasm/asmblbx.py b/tests/inlineasm/asmblbx.py
index d08c0ed6b3e03..43585dddccea6 100644
--- a/tests/inlineasm/asmblbx.py
+++ b/tests/inlineasm/asmblbx.py
@@ -1,5 +1,6 @@
 # test bl and bx instructions
 
+
 @micropython.asm_thumb
 def f(r0):
     # jump over the internal functions
@@ -17,5 +18,6 @@ def f(r0):
     bl(func1)
     bl(func2)
 
+
 print(f(0))
 print(f(1))
diff --git a/tests/inlineasm/asmconst.py b/tests/inlineasm/asmconst.py
index 299a25093c7b3..8412dd2c72b6e 100644
--- a/tests/inlineasm/asmconst.py
+++ b/tests/inlineasm/asmconst.py
@@ -1,8 +1,11 @@
 # test constants in assembler
 
+
 @micropython.asm_thumb
 def c1():
-    movwt(r0, 0xffffffff)
-    movwt(r1, 0xf0000000)
+    movwt(r0, 0xFFFFFFFF)
+    movwt(r1, 0xF0000000)
     sub(r0, r0, r1)
+
+
 print(hex(c1()))
diff --git a/tests/inlineasm/asmdiv.py b/tests/inlineasm/asmdiv.py
index b97d566eb54c1..c2784638460ae 100644
--- a/tests/inlineasm/asmdiv.py
+++ b/tests/inlineasm/asmdiv.py
@@ -2,15 +2,17 @@
 def sdiv(r0, r1):
     sdiv(r0, r0, r1)
 
+
 @micropython.asm_thumb
 def udiv(r0, r1):
     udiv(r0, r0, r1)
 
+
 print(sdiv(1234, 3))
 print(sdiv(-1234, 3))
 print(sdiv(1234, -3))
 print(sdiv(-1234, -3))
 
 print(udiv(1234, 3))
-print(udiv(0xffffffff, 0x7fffffff))
-print(udiv(0xffffffff, 0xffffffff))
+print(udiv(0xFFFFFFFF, 0x7FFFFFFF))
+print(udiv(0xFFFFFFFF, 0xFFFFFFFF))
diff --git a/tests/inlineasm/asmfpaddsub.py b/tests/inlineasm/asmfpaddsub.py
index b5fcecb6ce108..f69c89cdc6c6b 100644
--- a/tests/inlineasm/asmfpaddsub.py
+++ b/tests/inlineasm/asmfpaddsub.py
@@ -1,4 +1,4 @@
-@micropython.asm_thumb      # r0 = r0+r1-r2
+@micropython.asm_thumb  # r0 = r0+r1-r2
 def add_sub(r0, r1, r2):
     vmov(s0, r0)
     vcvt_f32_s32(s0, s0)
@@ -11,5 +11,5 @@ def add_sub(r0, r1, r2):
     vcvt_s32_f32(s31, s0)
     vmov(r0, s31)
 
-print(add_sub(100, 20, 30))
 
+print(add_sub(100, 20, 30))
diff --git a/tests/inlineasm/asmfpcmp.py b/tests/inlineasm/asmfpcmp.py
index d4fa1f2410cff..47fd99a347ab5 100644
--- a/tests/inlineasm/asmfpcmp.py
+++ b/tests/inlineasm/asmfpcmp.py
@@ -1,4 +1,4 @@
-@micropython.asm_thumb      # test vcmp, vmrs
+@micropython.asm_thumb  # test vcmp, vmrs
 def f(r0, r1):
     vmov(s0, r0)
     vcvt_f32_s32(s0, s0)
@@ -9,6 +9,7 @@ def f(r0, r1):
     mov(r1, 28)
     lsr(r0, r1)
 
-print(f(0,1))
-print(f(1,1))
-print(f(1,0))
+
+print(f(0, 1))
+print(f(1, 1))
+print(f(1, 0))
diff --git a/tests/inlineasm/asmfpldrstr.py b/tests/inlineasm/asmfpldrstr.py
index 8fa9af6369568..96cd0c23eb52d 100644
--- a/tests/inlineasm/asmfpldrstr.py
+++ b/tests/inlineasm/asmfpldrstr.py
@@ -1,12 +1,14 @@
-import array
-@micropython.asm_thumb      # test vldr, vstr
+import uarray as array
+
+
+@micropython.asm_thumb  # test vldr, vstr
 def arrayadd(r0):
     vldr(s0, [r0, 0])
     vldr(s1, [r0, 4])
     vadd(s2, s0, s1)
     vstr(s2, [r0, 8])
 
+
 z = array.array("f", [2, 4, 10])
 arrayadd(z)
 print(z[2])
-
diff --git a/tests/inlineasm/asmfpmuldiv.py b/tests/inlineasm/asmfpmuldiv.py
index edf9511bcda8b..930ddd053cf97 100644
--- a/tests/inlineasm/asmfpmuldiv.py
+++ b/tests/inlineasm/asmfpmuldiv.py
@@ -1,4 +1,4 @@
-@micropython.asm_thumb      # r0 = (int)(r0*r1/r2)
+@micropython.asm_thumb  # r0 = (int)(r0*r1/r2)
 def muldiv(r0, r1, r2):
     vmov(s0, r0)
     vcvt_f32_s32(s0, s0)
@@ -11,5 +11,5 @@ def muldiv(r0, r1, r2):
     vcvt_s32_f32(s31, s8)
     vmov(r0, s31)
 
-print(muldiv(100, 10, 50))
 
+print(muldiv(100, 10, 50))
diff --git a/tests/inlineasm/asmfpsqrt.py b/tests/inlineasm/asmfpsqrt.py
index f2c2d3a954028..519fde4fcc3b2 100644
--- a/tests/inlineasm/asmfpsqrt.py
+++ b/tests/inlineasm/asmfpsqrt.py
@@ -1,5 +1,5 @@
 # test vsqrt, vneg
-@micropython.asm_thumb      # r0 = -(int)(sqrt(r0)*r1)
+@micropython.asm_thumb  # r0 = -(int)(sqrt(r0)*r1)
 def sqrt_test(r0, r1):
     vmov(s1, r0)
     vcvt_f32_s32(s1, s1)
@@ -11,5 +11,5 @@ def sqrt_test(r0, r1):
     vcvt_s32_f32(s31, s7)
     vmov(r0, s31)
 
-print(sqrt_test(256, 10))
 
+print(sqrt_test(256, 10))
diff --git a/tests/inlineasm/asmit.py b/tests/inlineasm/asmit.py
index 57bfcc7f9ad86..640258e7c878f 100644
--- a/tests/inlineasm/asmit.py
+++ b/tests/inlineasm/asmit.py
@@ -1,16 +1,22 @@
 # test it instruction
 
+
 @micropython.asm_thumb
 def f(r0, r1):
     cmp(r0, r1)
     it(eq)
     mov(r0, 100)
+
+
 print(f(0, 0), f(1, 2))
 
+
 @micropython.asm_thumb
 def g(r0, r1):
     cmp(r0, r1)
     ite(eq)
     mov(r0, 100)
     mov(r0, 200)
+
+
 print(g(0, 0), g(0, 1))
diff --git a/tests/inlineasm/asmpushpop.py b/tests/inlineasm/asmpushpop.py
index c9005434ba477..74e729dfa2534 100644
--- a/tests/inlineasm/asmpushpop.py
+++ b/tests/inlineasm/asmpushpop.py
@@ -5,4 +5,5 @@ def f(r0, r1, r2):
     pop({r0})
     pop({r1, r2})
 
+
 print(f(0, 1, 2))
diff --git a/tests/inlineasm/asmrettype.py b/tests/inlineasm/asmrettype.py
index f1918696eeaeb..95068795df140 100644
--- a/tests/inlineasm/asmrettype.py
+++ b/tests/inlineasm/asmrettype.py
@@ -1,21 +1,33 @@
 # test return type of inline asm
 
+
 @micropython.asm_thumb
 def ret_obj(r0) -> object:
     pass
+
+
 ret_obj(print)(1)
 
+
 @micropython.asm_thumb
 def ret_bool(r0) -> bool:
     pass
+
+
 print(ret_bool(0), ret_bool(1))
 
+
 @micropython.asm_thumb
 def ret_int(r0) -> int:
     lsl(r0, r0, 29)
+
+
 print(ret_int(0), hex(ret_int(1)), hex(ret_int(2)), hex(ret_int(4)))
 
+
 @micropython.asm_thumb
 def ret_uint(r0) -> uint:
     lsl(r0, r0, 29)
+
+
 print(ret_uint(0), hex(ret_uint(1)), hex(ret_uint(2)), hex(ret_uint(4)))
diff --git a/tests/inlineasm/asmshift.py b/tests/inlineasm/asmshift.py
index 0df2187347068..ba4c21b3f2152 100644
--- a/tests/inlineasm/asmshift.py
+++ b/tests/inlineasm/asmshift.py
@@ -1,29 +1,46 @@
 @micropython.asm_thumb
 def lsl1(r0):
     lsl(r0, r0, 1)
+
+
 print(hex(lsl1(0x123)))
 
+
 @micropython.asm_thumb
 def lsl23(r0):
     lsl(r0, r0, 23)
+
+
 print(hex(lsl23(1)))
 
+
 @micropython.asm_thumb
 def lsr1(r0):
     lsr(r0, r0, 1)
+
+
 print(hex(lsr1(0x123)))
 
+
 @micropython.asm_thumb
 def lsr31(r0):
     lsr(r0, r0, 31)
+
+
 print(hex(lsr31(0x80000000)))
 
+
 @micropython.asm_thumb
 def asr1(r0):
     asr(r0, r0, 1)
+
+
 print(hex(asr1(0x123)))
 
+
 @micropython.asm_thumb
 def asr31(r0):
     asr(r0, r0, 31)
+
+
 print(hex(asr31(0x80000000)))
diff --git a/tests/inlineasm/asmspecialregs.py b/tests/inlineasm/asmspecialregs.py
index edfe4c2bd7e07..053ae29a4d9cd 100644
--- a/tests/inlineasm/asmspecialregs.py
+++ b/tests/inlineasm/asmspecialregs.py
@@ -2,10 +2,11 @@
 def getIPSR():
     mrs(r0, IPSR)
 
+
 @micropython.asm_thumb
 def getBASEPRI():
     mrs(r0, BASEPRI)
 
+
 print(getBASEPRI())
 print(getIPSR())
-
diff --git a/tests/inlineasm/asmsum.py b/tests/inlineasm/asmsum.py
index 07e71c7384927..6535a495d4e0e 100644
--- a/tests/inlineasm/asmsum.py
+++ b/tests/inlineasm/asmsum.py
@@ -22,6 +22,7 @@ def asm_sum_words(r0, r1):
 
     mov(r0, r2)
 
+
 @micropython.asm_thumb
 def asm_sum_bytes(r0, r1):
 
@@ -46,12 +47,17 @@ def asm_sum_bytes(r0, r1):
 
     mov(r0, r2)
 
-import array
 
-b = array.array('l', (100, 200, 300, 400))
+import uarray as array
+
+b = array.array("l", (100, 200, 300, 400))
 n = asm_sum_words(len(b), b)
 print(b, n)
 
-b = array.array('b', (10, 20, 30, 40, 50, 60, 70, 80))
+b = array.array("b", (10, 20, 30, 40, 50, 60, 70, 80))
+n = asm_sum_bytes(len(b), b)
+print(b, n)
+
+b = b"\x01\x02\x03\x04"
 n = asm_sum_bytes(len(b), b)
 print(b, n)
diff --git a/tests/inlineasm/asmsum.py.exp b/tests/inlineasm/asmsum.py.exp
index d50a94c8db622..3c83da367ae7b 100644
--- a/tests/inlineasm/asmsum.py.exp
+++ b/tests/inlineasm/asmsum.py.exp
@@ -1,2 +1,3 @@
 array('l', [100, 200, 300, 400]) 1000
 array('b', [10, 20, 30, 40, 50, 60, 70, 80]) 360
+b'\x01\x02\x03\x04' 10
diff --git a/tests/bench/arrayop-1-list_inplace.py b/tests/internal_bench/arrayop-1-list_inplace.py
similarity index 86%
rename from tests/bench/arrayop-1-list_inplace.py
rename to tests/internal_bench/arrayop-1-list_inplace.py
index 0ee1ef2ecac3e..b29593c1a1f39 100644
--- a/tests/bench/arrayop-1-list_inplace.py
+++ b/tests/internal_bench/arrayop-1-list_inplace.py
@@ -3,10 +3,12 @@
 # method is that it doesn't require any extra memory allocation.
 import bench
 
+
 def test(num):
-    for i in iter(range(num//10000)):
+    for i in iter(range(num // 10000)):
         arr = [0] * 1000
         for i in range(len(arr)):
             arr[i] += 1
 
+
 bench.run(test)
diff --git a/tests/bench/arrayop-2-list_map.py b/tests/internal_bench/arrayop-2-list_map.py
similarity index 88%
rename from tests/bench/arrayop-2-list_map.py
rename to tests/internal_bench/arrayop-2-list_map.py
index 9d5095c53a58f..5959d3f4692d9 100644
--- a/tests/bench/arrayop-2-list_map.py
+++ b/tests/internal_bench/arrayop-2-list_map.py
@@ -4,9 +4,11 @@
 # array). On the other hand, input array stays intact.
 import bench
 
+
 def test(num):
-    for i in iter(range(num//10000)):
+    for i in iter(range(num // 10000)):
         arr = [0] * 1000
         arr2 = list(map(lambda x: x + 1, arr))
 
+
 bench.run(test)
diff --git a/tests/bench/arrayop-3-bytearray_inplace.py b/tests/internal_bench/arrayop-3-bytearray_inplace.py
similarity index 87%
rename from tests/bench/arrayop-3-bytearray_inplace.py
rename to tests/internal_bench/arrayop-3-bytearray_inplace.py
index a6d62807057d2..fbbade2cac3de 100644
--- a/tests/bench/arrayop-3-bytearray_inplace.py
+++ b/tests/internal_bench/arrayop-3-bytearray_inplace.py
@@ -3,10 +3,12 @@
 # method is that it doesn't require any extra memory allocation.
 import bench
 
+
 def test(num):
-    for i in iter(range(num//10000)):
+    for i in iter(range(num // 10000)):
         arr = bytearray(b"\0" * 1000)
         for i in range(len(arr)):
             arr[i] += 1
 
+
 bench.run(test)
diff --git a/tests/bench/arrayop-4-bytearray_map.py b/tests/internal_bench/arrayop-4-bytearray_map.py
similarity index 88%
rename from tests/bench/arrayop-4-bytearray_map.py
rename to tests/internal_bench/arrayop-4-bytearray_map.py
index 1b92a4096137f..8fa987970594e 100644
--- a/tests/bench/arrayop-4-bytearray_map.py
+++ b/tests/internal_bench/arrayop-4-bytearray_map.py
@@ -4,9 +4,11 @@
 # array). On the other hand, input array stays intact.
 import bench
 
+
 def test(num):
-    for i in iter(range(num//10000)):
+    for i in iter(range(num // 10000)):
         arr = bytearray(b"\0" * 1000)
         arr2 = bytearray(map(lambda x: x + 1, arr))
 
+
 bench.run(test)
diff --git a/tests/bench/bench.py b/tests/internal_bench/bench.py
similarity index 99%
rename from tests/bench/bench.py
rename to tests/internal_bench/bench.py
index 0cd40a93fccd8..d7087e0e09199 100644
--- a/tests/bench/bench.py
+++ b/tests/internal_bench/bench.py
@@ -3,6 +3,7 @@
 
 ITERS = 20000000
 
+
 def run(f):
     t = time.time()
     f(ITERS)
diff --git a/tests/bench/bytealloc-1-bytes_n.py b/tests/internal_bench/bytealloc-1-bytes_n.py
similarity index 98%
rename from tests/bench/bytealloc-1-bytes_n.py
rename to tests/internal_bench/bytealloc-1-bytes_n.py
index 4a4bbc6fae900..8b8120a530275 100644
--- a/tests/bench/bytealloc-1-bytes_n.py
+++ b/tests/internal_bench/bytealloc-1-bytes_n.py
@@ -1,7 +1,9 @@
 import bench
 
+
 def test(num):
     for i in iter(range(num // 1000)):
         bytes(10000)
 
+
 bench.run(test)
diff --git a/tests/bench/bytealloc-2-repeat.py b/tests/internal_bench/bytealloc-2-repeat.py
similarity index 98%
rename from tests/bench/bytealloc-2-repeat.py
rename to tests/internal_bench/bytealloc-2-repeat.py
index 786a80462259c..8d6b5d52892cd 100644
--- a/tests/bench/bytealloc-2-repeat.py
+++ b/tests/internal_bench/bytealloc-2-repeat.py
@@ -1,7 +1,9 @@
 import bench
 
+
 def test(num):
     for i in iter(range(num // 1000)):
         b"\0" * 10000
 
+
 bench.run(test)
diff --git a/tests/bench/bytebuf-1-inplace.py b/tests/internal_bench/bytebuf-1-inplace.py
similarity index 83%
rename from tests/bench/bytebuf-1-inplace.py
rename to tests/internal_bench/bytebuf-1-inplace.py
index 7e7d9391cc93d..e1b6016a5713a 100644
--- a/tests/bench/bytebuf-1-inplace.py
+++ b/tests/internal_bench/bytebuf-1-inplace.py
@@ -2,10 +2,12 @@
 # Inplace - the most memory efficient way
 import bench
 
+
 def test(num):
-    for i in iter(range(num//10000)):
+    for i in iter(range(num // 10000)):
         ba = bytearray(b"\0" * 1000)
         for i in range(len(ba)):
             ba[i] += 1
 
+
 bench.run(test)
diff --git a/tests/bench/bytebuf-2-join_map_bytes.py b/tests/internal_bench/bytebuf-2-join_map_bytes.py
similarity index 74%
rename from tests/bench/bytebuf-2-join_map_bytes.py
rename to tests/internal_bench/bytebuf-2-join_map_bytes.py
index daa622991f004..9ecee479783d1 100644
--- a/tests/bench/bytebuf-2-join_map_bytes.py
+++ b/tests/internal_bench/bytebuf-2-join_map_bytes.py
@@ -4,9 +4,11 @@
 # this is slowest way to do it.
 import bench
 
+
 def test(num):
-    for i in iter(range(num//10000)):
+    for i in iter(range(num // 10000)):
         ba = bytearray(b"\0" * 1000)
-        ba2 = b''.join(map(lambda x:bytes([x + 1]), ba))
+        ba2 = b"".join(map(lambda x: bytes([x + 1]), ba))
+
 
 bench.run(test)
diff --git a/tests/bench/bytebuf-3-bytarray_map.py b/tests/internal_bench/bytebuf-3-bytarray_map.py
similarity index 82%
rename from tests/bench/bytebuf-3-bytarray_map.py
rename to tests/internal_bench/bytebuf-3-bytarray_map.py
index 078d08e99b076..2752d4e784b3d 100644
--- a/tests/bench/bytebuf-3-bytarray_map.py
+++ b/tests/internal_bench/bytebuf-3-bytarray_map.py
@@ -2,9 +2,11 @@
 # No joins, but still map().
 import bench
 
+
 def test(num):
-    for i in iter(range(num//10000)):
+    for i in iter(range(num // 10000)):
         ba = bytearray(b"\0" * 1000)
         ba2 = bytearray(map(lambda x: x + 1, ba))
 
+
 bench.run(test)
diff --git a/tests/bench/from_iter-1-list_bound.py b/tests/internal_bench/from_iter-1-list_bound.py
similarity index 68%
rename from tests/bench/from_iter-1-list_bound.py
rename to tests/internal_bench/from_iter-1-list_bound.py
index d209daecc5fdc..384d52903fe9f 100644
--- a/tests/bench/from_iter-1-list_bound.py
+++ b/tests/internal_bench/from_iter-1-list_bound.py
@@ -1,8 +1,10 @@
 import bench
 
+
 def test(num):
-    for i in iter(range(num//10000)):
+    for i in iter(range(num // 10000)):
         l = [0] * 1000
         l2 = list(l)
 
+
 bench.run(test)
diff --git a/tests/bench/from_iter-2-list_unbound.py b/tests/internal_bench/from_iter-2-list_unbound.py
similarity index 72%
rename from tests/bench/from_iter-2-list_unbound.py
rename to tests/internal_bench/from_iter-2-list_unbound.py
index be019c52feec8..98e22d68138b8 100644
--- a/tests/bench/from_iter-2-list_unbound.py
+++ b/tests/internal_bench/from_iter-2-list_unbound.py
@@ -1,8 +1,10 @@
 import bench
 
+
 def test(num):
-    for i in iter(range(num//10000)):
+    for i in iter(range(num // 10000)):
         l = [0] * 1000
         l2 = list(map(lambda x: x, l))
 
+
 bench.run(test)
diff --git a/tests/bench/from_iter-3-tuple_bound.py b/tests/internal_bench/from_iter-3-tuple_bound.py
similarity index 68%
rename from tests/bench/from_iter-3-tuple_bound.py
rename to tests/internal_bench/from_iter-3-tuple_bound.py
index 7b7fa36c6eb66..f052f6deeadd2 100644
--- a/tests/bench/from_iter-3-tuple_bound.py
+++ b/tests/internal_bench/from_iter-3-tuple_bound.py
@@ -1,8 +1,10 @@
 import bench
 
+
 def test(num):
-    for i in iter(range(num//10000)):
+    for i in iter(range(num // 10000)):
         l = [0] * 1000
         l2 = tuple(l)
 
+
 bench.run(test)
diff --git a/tests/bench/from_iter-4-tuple_unbound.py b/tests/internal_bench/from_iter-4-tuple_unbound.py
similarity index 72%
rename from tests/bench/from_iter-4-tuple_unbound.py
rename to tests/internal_bench/from_iter-4-tuple_unbound.py
index 7c7f134c8531e..ff9d1b4df5efd 100644
--- a/tests/bench/from_iter-4-tuple_unbound.py
+++ b/tests/internal_bench/from_iter-4-tuple_unbound.py
@@ -1,8 +1,10 @@
 import bench
 
+
 def test(num):
-    for i in iter(range(num//10000)):
+    for i in iter(range(num // 10000)):
         l = [0] * 1000
         l2 = tuple(map(lambda x: x, l))
 
+
 bench.run(test)
diff --git a/tests/bench/from_iter-5-bytes_bound.py b/tests/internal_bench/from_iter-5-bytes_bound.py
similarity index 68%
rename from tests/bench/from_iter-5-bytes_bound.py
rename to tests/internal_bench/from_iter-5-bytes_bound.py
index b793a3207e431..967cb99eea2be 100644
--- a/tests/bench/from_iter-5-bytes_bound.py
+++ b/tests/internal_bench/from_iter-5-bytes_bound.py
@@ -1,8 +1,10 @@
 import bench
 
+
 def test(num):
-    for i in iter(range(num//10000)):
+    for i in iter(range(num // 10000)):
         l = [0] * 1000
         l2 = bytes(l)
 
+
 bench.run(test)
diff --git a/tests/bench/from_iter-6-bytes_unbound.py b/tests/internal_bench/from_iter-6-bytes_unbound.py
similarity index 72%
rename from tests/bench/from_iter-6-bytes_unbound.py
rename to tests/internal_bench/from_iter-6-bytes_unbound.py
index 20aa556277000..b85501916024d 100644
--- a/tests/bench/from_iter-6-bytes_unbound.py
+++ b/tests/internal_bench/from_iter-6-bytes_unbound.py
@@ -1,8 +1,10 @@
 import bench
 
+
 def test(num):
-    for i in iter(range(num//10000)):
+    for i in iter(range(num // 10000)):
         l = [0] * 1000
         l2 = bytes(map(lambda x: x, l))
 
+
 bench.run(test)
diff --git a/tests/bench/from_iter-7-bytearray_bound.py b/tests/internal_bench/from_iter-7-bytearray_bound.py
similarity index 69%
rename from tests/bench/from_iter-7-bytearray_bound.py
rename to tests/internal_bench/from_iter-7-bytearray_bound.py
index 72001a05c7ebc..d0c4c65a7436f 100644
--- a/tests/bench/from_iter-7-bytearray_bound.py
+++ b/tests/internal_bench/from_iter-7-bytearray_bound.py
@@ -1,8 +1,10 @@
 import bench
 
+
 def test(num):
-    for i in iter(range(num//10000)):
+    for i in iter(range(num // 10000)):
         l = [0] * 1000
         l2 = bytearray(l)
 
+
 bench.run(test)
diff --git a/tests/bench/from_iter-8-bytearray_unbound.py b/tests/internal_bench/from_iter-8-bytearray_unbound.py
similarity index 72%
rename from tests/bench/from_iter-8-bytearray_unbound.py
rename to tests/internal_bench/from_iter-8-bytearray_unbound.py
index e2263b8ef907d..aec2e65adfa25 100644
--- a/tests/bench/from_iter-8-bytearray_unbound.py
+++ b/tests/internal_bench/from_iter-8-bytearray_unbound.py
@@ -1,8 +1,10 @@
 import bench
 
+
 def test(num):
-    for i in iter(range(num//10000)):
+    for i in iter(range(num // 10000)):
         l = [0] * 1000
         l2 = bytearray(map(lambda x: x, l))
 
+
 bench.run(test)
diff --git a/tests/bench/func_args-1.1-pos_1.py b/tests/internal_bench/func_args-1.1-pos_1.py
similarity index 97%
rename from tests/bench/func_args-1.1-pos_1.py
rename to tests/internal_bench/func_args-1.1-pos_1.py
index eee0ea8289683..cadb17768c5ba 100644
--- a/tests/bench/func_args-1.1-pos_1.py
+++ b/tests/internal_bench/func_args-1.1-pos_1.py
@@ -1,10 +1,13 @@
 import bench
 
+
 def func(a):
     pass
 
+
 def test(num):
     for i in iter(range(num)):
         func(i)
 
+
 bench.run(test)
diff --git a/tests/bench/func_args-1.2-pos_3.py b/tests/internal_bench/func_args-1.2-pos_3.py
similarity index 97%
rename from tests/bench/func_args-1.2-pos_3.py
rename to tests/internal_bench/func_args-1.2-pos_3.py
index 7e03ee2f853c3..12010d0150bec 100644
--- a/tests/bench/func_args-1.2-pos_3.py
+++ b/tests/internal_bench/func_args-1.2-pos_3.py
@@ -1,10 +1,13 @@
 import bench
 
+
 def func(a, b, c):
     pass
 
+
 def test(num):
     for i in iter(range(num)):
         func(i, i, i)
 
+
 bench.run(test)
diff --git a/tests/bench/func_args-2-pos_default_2_of_3.py b/tests/internal_bench/func_args-2-pos_default_2_of_3.py
similarity index 97%
rename from tests/bench/func_args-2-pos_default_2_of_3.py
rename to tests/internal_bench/func_args-2-pos_default_2_of_3.py
index 1fa0fbda59c5f..4dc5650902a0b 100644
--- a/tests/bench/func_args-2-pos_default_2_of_3.py
+++ b/tests/internal_bench/func_args-2-pos_default_2_of_3.py
@@ -1,10 +1,13 @@
 import bench
 
+
 def func(a, b=1, c=2):
     pass
 
+
 def test(num):
     for i in iter(range(num)):
         func(i)
 
+
 bench.run(test)
diff --git a/tests/bench/func_args-3.1-kw_1.py b/tests/internal_bench/func_args-3.1-kw_1.py
similarity index 97%
rename from tests/bench/func_args-3.1-kw_1.py
rename to tests/internal_bench/func_args-3.1-kw_1.py
index 7bc81e5bea44d..18252570c116b 100644
--- a/tests/bench/func_args-3.1-kw_1.py
+++ b/tests/internal_bench/func_args-3.1-kw_1.py
@@ -1,10 +1,13 @@
 import bench
 
+
 def func(a):
     pass
 
+
 def test(num):
     for i in iter(range(num)):
         func(a=i)
 
+
 bench.run(test)
diff --git a/tests/bench/func_args-3.2-kw_3.py b/tests/internal_bench/func_args-3.2-kw_3.py
similarity index 97%
rename from tests/bench/func_args-3.2-kw_3.py
rename to tests/internal_bench/func_args-3.2-kw_3.py
index 7f95106841407..deac15cb41ade 100644
--- a/tests/bench/func_args-3.2-kw_3.py
+++ b/tests/internal_bench/func_args-3.2-kw_3.py
@@ -1,10 +1,13 @@
 import bench
 
+
 def func(a, b, c):
     pass
 
+
 def test(num):
     for i in iter(range(num)):
         func(c=i, b=i, a=i)
 
+
 bench.run(test)
diff --git a/tests/bench/func_builtin-1-enum_pos.py b/tests/internal_bench/func_builtin-1-enum_pos.py
similarity index 65%
rename from tests/bench/func_builtin-1-enum_pos.py
rename to tests/internal_bench/func_builtin-1-enum_pos.py
index 20935164e847f..c7c148df102a6 100644
--- a/tests/bench/func_builtin-1-enum_pos.py
+++ b/tests/internal_bench/func_builtin-1-enum_pos.py
@@ -1,7 +1,9 @@
 import bench
 
+
 def test(num):
-    for i in iter(range(num//20)):
+    for i in iter(range(num // 20)):
         enumerate([1, 2], 1)
 
+
 bench.run(test)
diff --git a/tests/bench/func_builtin-2-enum_kw.py b/tests/internal_bench/func_builtin-2-enum_kw.py
similarity index 69%
rename from tests/bench/func_builtin-2-enum_kw.py
rename to tests/internal_bench/func_builtin-2-enum_kw.py
index 6c5e44419c0fa..a25ab241c66d3 100644
--- a/tests/bench/func_builtin-2-enum_kw.py
+++ b/tests/internal_bench/func_builtin-2-enum_kw.py
@@ -1,7 +1,9 @@
 import bench
 
+
 def test(num):
-    for i in iter(range(num//20)):
+    for i in iter(range(num // 20)):
         enumerate(iterable=[1, 2], start=1)
 
+
 bench.run(test)
diff --git a/tests/bench/funcall-1-inline.py b/tests/internal_bench/funcall-1-inline.py
similarity index 98%
rename from tests/bench/funcall-1-inline.py
rename to tests/internal_bench/funcall-1-inline.py
index fbeb79630db1a..8c3f0ccd597cb 100644
--- a/tests/bench/funcall-1-inline.py
+++ b/tests/internal_bench/funcall-1-inline.py
@@ -2,8 +2,10 @@
 # Establish a baseline for performing a trivial operation inline
 import bench
 
+
 def test(num):
     for i in iter(range(num)):
         a = i + 1
 
+
 bench.run(test)
diff --git a/tests/bench/funcall-2-funcall.py b/tests/internal_bench/funcall-2-funcall.py
similarity index 98%
rename from tests/bench/funcall-2-funcall.py
rename to tests/internal_bench/funcall-2-funcall.py
index d5c36c60aab69..a245258040be8 100644
--- a/tests/bench/funcall-2-funcall.py
+++ b/tests/internal_bench/funcall-2-funcall.py
@@ -2,11 +2,14 @@
 # Perform the same trivial operation as global function call
 import bench
 
+
 def f(x):
     return x + 1
 
+
 def test(num):
     for i in iter(range(num)):
         a = f(i)
 
+
 bench.run(test)
diff --git a/tests/bench/funcall-3-funcall-local.py b/tests/internal_bench/funcall-3-funcall-local.py
similarity index 99%
rename from tests/bench/funcall-3-funcall-local.py
rename to tests/internal_bench/funcall-3-funcall-local.py
index 1a6d728c63455..d922888685984 100644
--- a/tests/bench/funcall-3-funcall-local.py
+++ b/tests/internal_bench/funcall-3-funcall-local.py
@@ -5,12 +5,15 @@
 # variables are accessed by offset, not by name)
 import bench
 
+
 def f(x):
     return x + 1
 
+
 def test(num):
     f_ = f
     for i in iter(range(num)):
         a = f_(i)
 
+
 bench.run(test)
diff --git a/tests/bench/loop_count-1-range.py b/tests/internal_bench/loop_count-1-range.py
similarity index 97%
rename from tests/bench/loop_count-1-range.py
rename to tests/internal_bench/loop_count-1-range.py
index e22adf6cbe86b..fdb11eaac63cf 100644
--- a/tests/bench/loop_count-1-range.py
+++ b/tests/internal_bench/loop_count-1-range.py
@@ -1,7 +1,9 @@
 import bench
 
+
 def test(num):
     for i in range(num):
         pass
 
+
 bench.run(test)
diff --git a/tests/bench/loop_count-2-range_iter.py b/tests/internal_bench/loop_count-2-range_iter.py
similarity index 97%
rename from tests/bench/loop_count-2-range_iter.py
rename to tests/internal_bench/loop_count-2-range_iter.py
index fe4a3857e19a4..4189bf329d3bb 100644
--- a/tests/bench/loop_count-2-range_iter.py
+++ b/tests/internal_bench/loop_count-2-range_iter.py
@@ -1,7 +1,9 @@
 import bench
 
+
 def test(num):
     for i in iter(range(num)):
         pass
 
+
 bench.run(test)
diff --git a/tests/bench/loop_count-3-while_up.py b/tests/internal_bench/loop_count-3-while_up.py
similarity index 97%
rename from tests/bench/loop_count-3-while_up.py
rename to tests/internal_bench/loop_count-3-while_up.py
index 1ab8054a0fe8f..22c64403bfa4f 100644
--- a/tests/bench/loop_count-3-while_up.py
+++ b/tests/internal_bench/loop_count-3-while_up.py
@@ -1,8 +1,10 @@
 import bench
 
+
 def test(num):
     i = 0
     while i < num:
         i += 1
 
+
 bench.run(test)
diff --git a/tests/bench/loop_count-4-while_down_gt.py b/tests/internal_bench/loop_count-4-while_down_gt.py
similarity index 97%
rename from tests/bench/loop_count-4-while_down_gt.py
rename to tests/internal_bench/loop_count-4-while_down_gt.py
index de8dee2ca9c60..47b004c2bda6d 100644
--- a/tests/bench/loop_count-4-while_down_gt.py
+++ b/tests/internal_bench/loop_count-4-while_down_gt.py
@@ -1,7 +1,9 @@
 import bench
 
+
 def test(num):
     while num > 0:
         num -= 1
 
+
 bench.run(test)
diff --git a/tests/bench/loop_count-5-while_down_ne.py b/tests/internal_bench/loop_count-5-while_down_ne.py
similarity index 97%
rename from tests/bench/loop_count-5-while_down_ne.py
rename to tests/internal_bench/loop_count-5-while_down_ne.py
index b9a1af414b5a6..419c817c8fbb1 100644
--- a/tests/bench/loop_count-5-while_down_ne.py
+++ b/tests/internal_bench/loop_count-5-while_down_ne.py
@@ -1,7 +1,9 @@
 import bench
 
+
 def test(num):
     while num != 0:
         num -= 1
 
+
 bench.run(test)
diff --git a/tests/bench/loop_count-5.1-while_down_ne_localvar.py b/tests/internal_bench/loop_count-5.1-while_down_ne_localvar.py
similarity index 98%
rename from tests/bench/loop_count-5.1-while_down_ne_localvar.py
rename to tests/internal_bench/loop_count-5.1-while_down_ne_localvar.py
index 96bdb9129f3a5..d25102a6304cc 100644
--- a/tests/bench/loop_count-5.1-while_down_ne_localvar.py
+++ b/tests/internal_bench/loop_count-5.1-while_down_ne_localvar.py
@@ -1,8 +1,10 @@
 import bench
 
+
 def test(num):
     zero = 0
     while num != zero:
         num -= 1
 
+
 bench.run(test)
diff --git a/tests/bench/var-1-constant.py b/tests/internal_bench/var-1-constant.py
similarity index 97%
rename from tests/bench/var-1-constant.py
rename to tests/internal_bench/var-1-constant.py
index eec977909cd08..4a24194725b78 100644
--- a/tests/bench/var-1-constant.py
+++ b/tests/internal_bench/var-1-constant.py
@@ -1,8 +1,10 @@
 import bench
 
+
 def test(num):
     i = 0
     while i < 20000000:
         i += 1
 
+
 bench.run(test)
diff --git a/tests/bench/var-2-global.py b/tests/internal_bench/var-2-global.py
similarity index 98%
rename from tests/bench/var-2-global.py
rename to tests/internal_bench/var-2-global.py
index 5758ad61aafd9..a47240d64658e 100644
--- a/tests/bench/var-2-global.py
+++ b/tests/internal_bench/var-2-global.py
@@ -2,9 +2,11 @@
 
 ITERS = 20000000
 
+
 def test(num):
     i = 0
     while i < ITERS:
         i += 1
 
+
 bench.run(test)
diff --git a/tests/bench/var-3-local.py b/tests/internal_bench/var-3-local.py
similarity index 99%
rename from tests/bench/var-3-local.py
rename to tests/internal_bench/var-3-local.py
index 124b484295220..182bb95f6ff74 100644
--- a/tests/bench/var-3-local.py
+++ b/tests/internal_bench/var-3-local.py
@@ -7,4 +7,5 @@ def test(num):
     while i < ITERS:
         i += 1
 
+
 bench.run(test)
diff --git a/tests/bench/var-4-arg.py b/tests/internal_bench/var-4-arg.py
similarity index 66%
rename from tests/bench/var-4-arg.py
rename to tests/internal_bench/var-4-arg.py
index cf050c58fdeeb..b9734357c8528 100644
--- a/tests/bench/var-4-arg.py
+++ b/tests/internal_bench/var-4-arg.py
@@ -6,4 +6,5 @@ def test(num):
     while i < num:
         i += 1
 
-bench.run(lambda n:test(20000000))
+
+bench.run(lambda n: test(20000000))
diff --git a/tests/bench/var-5-class-attr.py b/tests/internal_bench/var-5-class-attr.py
similarity index 97%
rename from tests/bench/var-5-class-attr.py
rename to tests/internal_bench/var-5-class-attr.py
index 02ae874ac2efc..e10770ee5bba0 100644
--- a/tests/bench/var-5-class-attr.py
+++ b/tests/internal_bench/var-5-class-attr.py
@@ -1,11 +1,14 @@
 import bench
 
+
 class Foo:
     num = 20000000
 
+
 def test(num):
     i = 0
     while i < Foo.num:
         i += 1
 
+
 bench.run(test)
diff --git a/tests/bench/var-6-instance-attr.py b/tests/internal_bench/var-6-instance-attr.py
similarity index 98%
rename from tests/bench/var-6-instance-attr.py
rename to tests/internal_bench/var-6-instance-attr.py
index 787ed870fb3d0..0124ef51b3022 100644
--- a/tests/bench/var-6-instance-attr.py
+++ b/tests/internal_bench/var-6-instance-attr.py
@@ -1,14 +1,16 @@
 import bench
 
-class Foo:
 
+class Foo:
     def __init__(self):
         self.num = 20000000
 
+
 def test(num):
     o = Foo()
     i = 0
     while i < o.num:
         i += 1
 
+
 bench.run(test)
diff --git a/tests/bench/var-6.1-instance-attr-5.py b/tests/internal_bench/var-6.1-instance-attr-5.py
similarity index 99%
rename from tests/bench/var-6.1-instance-attr-5.py
rename to tests/internal_bench/var-6.1-instance-attr-5.py
index e8d338360567b..692cef20dfb20 100644
--- a/tests/bench/var-6.1-instance-attr-5.py
+++ b/tests/internal_bench/var-6.1-instance-attr-5.py
@@ -1,7 +1,7 @@
 import bench
 
-class Foo:
 
+class Foo:
     def __init__(self):
         self.num1 = 0
         self.num2 = 0
@@ -9,10 +9,12 @@ def __init__(self):
         self.num4 = 0
         self.num = 20000000
 
+
 def test(num):
     o = Foo()
     i = 0
     while i < o.num:
         i += 1
 
+
 bench.run(test)
diff --git a/tests/bench/var-7-instance-meth.py b/tests/internal_bench/var-7-instance-meth.py
similarity index 99%
rename from tests/bench/var-7-instance-meth.py
rename to tests/internal_bench/var-7-instance-meth.py
index f9d463f40af89..2ed7800be5cbe 100644
--- a/tests/bench/var-7-instance-meth.py
+++ b/tests/internal_bench/var-7-instance-meth.py
@@ -1,17 +1,19 @@
 import bench
 
-class Foo:
 
+class Foo:
     def __init__(self):
         self._num = 20000000
 
     def num(self):
         return self._num
 
+
 def test(num):
     o = Foo()
     i = 0
     while i < o.num():
         i += 1
 
+
 bench.run(test)
diff --git a/tests/bench/var-8-namedtuple-1st.py b/tests/internal_bench/var-8-namedtuple-1st.py
similarity index 98%
rename from tests/bench/var-8-namedtuple-1st.py
rename to tests/internal_bench/var-8-namedtuple-1st.py
index d862480a517fe..1a6daa6cddc0f 100644
--- a/tests/bench/var-8-namedtuple-1st.py
+++ b/tests/internal_bench/var-8-namedtuple-1st.py
@@ -3,10 +3,12 @@
 
 T = namedtuple("Tup", ["num", "bar"])
 
+
 def test(num):
     t = T(20000000, 0)
     i = 0
     while i < t.num:
         i += 1
 
+
 bench.run(test)
diff --git a/tests/bench/var-8.1-namedtuple-5th.py b/tests/internal_bench/var-8.1-namedtuple-5th.py
similarity index 99%
rename from tests/bench/var-8.1-namedtuple-5th.py
rename to tests/internal_bench/var-8.1-namedtuple-5th.py
index 0bcf66180320a..568ece8067143 100644
--- a/tests/bench/var-8.1-namedtuple-5th.py
+++ b/tests/internal_bench/var-8.1-namedtuple-5th.py
@@ -3,10 +3,12 @@
 
 T = namedtuple("Tup", ["foo1", "foo2", "foo3", "foo4", "num"])
 
+
 def test(num):
     t = T(0, 0, 0, 0, 20000000)
     i = 0
     while i < t.num:
         i += 1
 
+
 bench.run(test)
diff --git a/tests/io/argv.py b/tests/io/argv.py
index a13f2cad21802..53254da11906b 100644
--- a/tests/io/argv.py
+++ b/tests/io/argv.py
@@ -1,2 +1,3 @@
 import sys
+
 print(sys.argv)
diff --git a/tests/io/builtin_print_file.py b/tests/io/builtin_print_file.py
index d9b8e2a960adb..822356a6cc305 100644
--- a/tests/io/builtin_print_file.py
+++ b/tests/io/builtin_print_file.py
@@ -5,13 +5,13 @@
 try:
     sys.stdout
 except AttributeError:
-    print('SKIP')
+    print("SKIP")
     raise SystemExit
 
 print(file=sys.stdout)
-print('test', file=sys.stdout)
+print("test", file=sys.stdout)
 
 try:
     print(file=1)
-except (AttributeError, OSError): # CPython and uPy differ in error message
-    print('Error')
+except (AttributeError, OSError):  # CPython and uPy differ in error message
+    print("Error")
diff --git a/tests/io/file1.py b/tests/io/file1.py
index af4176b64e9f2..2a46c9c63e360 100644
--- a/tests/io/file1.py
+++ b/tests/io/file1.py
@@ -4,43 +4,43 @@
 print(f.read())
 f = open("io/data/file1")
 print(f.readlines())
-f = open("io/data/file1","r")
+f = open("io/data/file1", "r")
 print(f.readlines())
-f = open("io/data/file1","rb")
+f = open("io/data/file1", "rb")
 print(f.readlines())
-f = open("io/data/file1",mode="r")
+f = open("io/data/file1", mode="r")
 print(f.readlines())
-f = open("io/data/file1",mode="rb")
+f = open("io/data/file1", mode="rb")
 print(f.readlines())
 
 # write() error
-f = open('io/data/file1', 'r')
+f = open("io/data/file1", "r")
 try:
-    f.write('x')
+    f.write("x")
 except OSError:
-    print('OSError')
+    print("OSError")
 f.close()
 
 # read(n) error on binary file
-f = open('io/data/file1', 'ab')
+f = open("io/data/file1", "ab")
 try:
     f.read(1)
 except OSError:
-    print('OSError')
+    print("OSError")
 f.close()
 
 # read(n) error on text file
-f = open('io/data/file1', 'at')
+f = open("io/data/file1", "at")
 try:
     f.read(1)
 except OSError:
-    print('OSError')
+    print("OSError")
 f.close()
 
 # read() w/o args error
-f = open('io/data/file1', 'ab')
+f = open("io/data/file1", "ab")
 try:
     f.read()
 except OSError:
-    print('OSError')
+    print("OSError")
 f.close()
diff --git a/tests/io/file_readinto.py b/tests/io/file_readinto.py
index cbefc6e040997..1f3702a217e60 100644
--- a/tests/io/file_readinto.py
+++ b/tests/io/file_readinto.py
@@ -7,8 +7,8 @@
 print(b)
 
 # readinto() on writable file
-f = open('io/data/file1', 'ab')
+f = open("io/data/file1", "ab")
 try:
     f.readinto(bytearray(4))
 except OSError:
-    print('OSError')
+    print("OSError")
diff --git a/tests/io/file_readline.py b/tests/io/file_readline.py
index 25e76597b150c..86d010eaf657a 100644
--- a/tests/io/file_readline.py
+++ b/tests/io/file_readline.py
@@ -6,9 +6,9 @@
 print(f.readline())
 
 # readline() on writable file
-f = open('io/data/file1', 'ab')
+f = open("io/data/file1", "ab")
 try:
     f.readline()
 except OSError:
-    print('OSError')
+    print("OSError")
 f.close()
diff --git a/tests/io/file_seek.py b/tests/io/file_seek.py
index 10fb1fd06f096..2fe57692c63bc 100644
--- a/tests/io/file_seek.py
+++ b/tests/io/file_seek.py
@@ -25,10 +25,10 @@
 f.close()
 
 # seek closed file
-f = open('io/data/file1', 'r')
+f = open("io/data/file1", "r")
 f.close()
 try:
     f.seek(1)
 except (OSError, ValueError):
     # CPy raises ValueError, uPy raises OSError
-    print('OSError or ValueError')
+    print("OSError or ValueError")
diff --git a/tests/io/file_with.py b/tests/io/file_with.py
index ee1e702422b3a..899c0f9287be4 100644
--- a/tests/io/file_with.py
+++ b/tests/io/file_with.py
@@ -15,7 +15,7 @@
 # Regression test: test that exception in with initialization properly
 # thrown and doesn't crash.
 try:
-    with open('__non_existent', 'r'):
+    with open("__non_existent", "r"):
         pass
 except OSError:
     print("OSError")
diff --git a/tests/io/resource_stream.py b/tests/io/resource_stream.py
index 37d985bf16614..5656205b692d6 100644
--- a/tests/io/resource_stream.py
+++ b/tests/io/resource_stream.py
@@ -4,7 +4,7 @@
 try:
     uio.resource_stream
 except AttributeError:
-    print('SKIP')
+    print("SKIP")
     raise SystemExit
 
 buf = uio.resource_stream("data", "file2")
diff --git a/tests/jni/list.py b/tests/jni/list.py
index d58181d0bad0e..7630a48e89928 100644
--- a/tests/jni/list.py
+++ b/tests/jni/list.py
@@ -1,4 +1,5 @@
 import jni
+
 try:
     ArrayList = jni.cls("java/util/ArrayList")
 except:
diff --git a/tests/jni/object.py b/tests/jni/object.py
index aa67615ec8a83..8fbdb39d3929f 100644
--- a/tests/jni/object.py
+++ b/tests/jni/object.py
@@ -1,4 +1,5 @@
 import jni
+
 try:
     Integer = jni.cls("java/lang/Integer")
 except:
diff --git a/tests/jni/system_out.py b/tests/jni/system_out.py
index 86c4b9e112163..c34d7011f7987 100644
--- a/tests/jni/system_out.py
+++ b/tests/jni/system_out.py
@@ -1,5 +1,6 @@
 try:
     import jni
+
     System = jni.cls("java/lang/System")
 except:
     print("SKIP")
diff --git a/tests/micropython/const.py b/tests/micropython/const.py
index 660a095f2c327..1faf22be9a430 100644
--- a/tests/micropython/const.py
+++ b/tests/micropython/const.py
@@ -7,9 +7,11 @@
 
 print(X, Y + 1)
 
+
 def f():
     print(X, Y + 1)
 
+
 f()
 
 _X = const(12)
@@ -17,9 +19,11 @@ def f():
 
 print(_X, _Y)
 
+
 class A:
     Z = const(1)
     _Z = const(2)
     print(Z, _Z)
 
-print(hasattr(A, 'Z'), hasattr(A, '_Z'))
+
+print(hasattr(A, "Z"), hasattr(A, "_Z"))
diff --git a/tests/micropython/const2.py b/tests/micropython/const2.py
index 60085a1e04451..ed4720122ed39 100644
--- a/tests/micropython/const2.py
+++ b/tests/micropython/const2.py
@@ -8,27 +8,37 @@
 
 # import that uses a constant
 import micropython as X
-print(globals()['X'])
+
+print(globals()["X"])
 
 # function name that matches a constant
 def X():
-    print('function X', X)
-globals()['X']()
+    print("function X", X)
+
+
+globals()["X"]()
 
 # arguments that match a constant
 def f(X, *Y, **Z):
     pass
+
+
 f(1)
 
 # class name that matches a constant
 class X:
     def f(self):
-        print('class X', X)
-globals()['X']().f()
+        print("class X", X)
+
+
+globals()["X"]().f()
 
 # constant within a class
 class A:
     C1 = const(4)
+
     def X(self):
-        print('method X', Y, C1, self.C1)
+        print("method X", Y, C1, self.C1)
+
+
 A().X()
diff --git a/tests/micropython/const_error.py b/tests/micropython/const_error.py
index 6d3d135b56ebb..d35be530a7c8d 100644
--- a/tests/micropython/const_error.py
+++ b/tests/micropython/const_error.py
@@ -2,14 +2,25 @@
 
 from micropython import const
 
+
 def test_syntax(code):
     try:
         exec(code)
     except SyntaxError:
         print("SyntaxError")
 
+
 # argument not a constant
 test_syntax("a = const(x)")
 
 # redefined constant
 test_syntax("A = const(1); A = const(2)")
+
+# these operations are not supported within const
+test_syntax("A = const(1 @ 2)")
+test_syntax("A = const(1 / 2)")
+test_syntax("A = const(1 ** -2)")
+test_syntax("A = const(1 << -2)")
+test_syntax("A = const(1 >> -2)")
+test_syntax("A = const(1 % 0)")
+test_syntax("A = const(1 // 0)")
diff --git a/tests/micropython/const_error.py.exp b/tests/micropython/const_error.py.exp
index 5275689b41383..3edc3efe9c3e9 100644
--- a/tests/micropython/const_error.py.exp
+++ b/tests/micropython/const_error.py.exp
@@ -1,2 +1,9 @@
 SyntaxError
 SyntaxError
+SyntaxError
+SyntaxError
+SyntaxError
+SyntaxError
+SyntaxError
+SyntaxError
+SyntaxError
diff --git a/tests/micropython/const_intbig.py b/tests/micropython/const_intbig.py
index e74902652627e..27990c8c20303 100644
--- a/tests/micropython/const_intbig.py
+++ b/tests/micropython/const_intbig.py
@@ -3,8 +3,8 @@
 from micropython import const
 
 # check we can make consts from bignums
-Z1 = const(0xffffffff)
-Z2 = const(0xffffffffffffffff)
+Z1 = const(0xFFFFFFFF)
+Z2 = const(0xFFFFFFFFFFFFFFFF)
 print(hex(Z1), hex(Z2))
 
 # check arithmetic with bignum
diff --git a/tests/micropython/decorator.py b/tests/micropython/decorator.py
index bf688968a0a23..2e7cf177760e7 100644
--- a/tests/micropython/decorator.py
+++ b/tests/micropython/decorator.py
@@ -1,7 +1,9 @@
 # test micropython-specific decorators
 
+
 @micropython.bytecode
 def f():
-    return 'bytecode'
+    return "bytecode"
+
 
 print(f())
diff --git a/tests/micropython/decorator_error.py b/tests/micropython/decorator_error.py
index c7da3119f4a06..94772ac1e5fef 100644
--- a/tests/micropython/decorator_error.py
+++ b/tests/micropython/decorator_error.py
@@ -1,11 +1,13 @@
 # test syntax errors for uPy-specific decorators
 
+
 def test_syntax(code):
     try:
         exec(code)
     except SyntaxError:
         print("SyntaxError")
 
+
 # invalid micropython decorators
 test_syntax("@micropython.a\ndef f(): pass")
 test_syntax("@micropython.a.b\ndef f(): pass")
diff --git a/tests/micropython/emg_exc.py b/tests/micropython/emg_exc.py
index 4a9fa18bc1751..bca4d2d9fbaca 100644
--- a/tests/micropython/emg_exc.py
+++ b/tests/micropython/emg_exc.py
@@ -2,6 +2,7 @@
 
 import micropython
 import sys
+
 try:
     import uio
 except ImportError:
@@ -14,6 +15,7 @@
 except AttributeError:
     pass
 
+
 def f():
     micropython.heap_lock()
     try:
@@ -31,4 +33,5 @@ def f():
         else:
             print(l)
 
+
 f()
diff --git a/tests/micropython/emg_exc.py.exp b/tests/micropython/emg_exc.py.exp
index fd2cfb2722518..0d4b80ce2bc59 100644
--- a/tests/micropython/emg_exc.py.exp
+++ b/tests/micropython/emg_exc.py.exp
@@ -1,4 +1,4 @@
 Traceback (most recent call last):
-, line 20, in f
+, line 22, in f
 ValueError: 1
 
diff --git a/tests/micropython/extreme_exc.py b/tests/micropython/extreme_exc.py
index b9db9640681b4..dae5b151860fc 100644
--- a/tests/micropython/extreme_exc.py
+++ b/tests/micropython/extreme_exc.py
@@ -5,8 +5,13 @@
 # Check for stackless build, which can't call functions without
 # allocating a frame on the heap.
 try:
-    def stackless(): pass
-    micropython.heap_lock(); stackless(); micropython.heap_unlock()
+
+    def stackless():
+        pass
+
+    micropython.heap_lock()
+    stackless()
+    micropython.heap_unlock()
 except RuntimeError:
     print("SKIP")
     raise SystemExit
@@ -17,11 +22,78 @@ def stackless(): pass
 except AttributeError:
     pass
 
+
 def main():
     # create an exception with many args while heap is locked
     # should revert to empty tuple for args
     micropython.heap_lock()
-    e = Exception(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+    e = Exception(
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+    )
     micropython.heap_unlock()
     print(repr(e))
 
@@ -29,9 +101,12 @@ def main():
     # should use emergency exception buffer and truncate the message
     def f():
         pass
+
     micropython.heap_lock()
     try:
-        f(abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz=1)
+        f(
+            abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz=1
+        )
     except Exception as er:
         e = er
     micropython.heap_unlock()
@@ -46,7 +121,9 @@ def f():
         except MemoryError:
             break
     try:
-        f(abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz=1)
+        f(
+            abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz=1
+        )
     except Exception as er:
         e = er
     lst[0] = None
@@ -57,6 +134,7 @@ def f():
     # should use emergency exception and be unable to resize traceback array
     def g():
         g()
+
     micropython.heap_lock()
     try:
         g()
@@ -67,13 +145,15 @@ def g():
 
     # create an exception on the heap with some traceback on the heap, but then
     # raise it with the heap locked so it can't allocate any more traceback
-    exc = Exception('my exception')
+    exc = Exception("my exception")
     try:
         raise exc
     except:
         pass
+
     def h(e):
         raise e
+
     micropython.heap_lock()
     try:
         h(exc)
@@ -82,4 +162,5 @@ def h(e):
     micropython.heap_unlock()
     print(repr(e))
 
+
 main()
diff --git a/tests/micropython/heap_lock.py b/tests/micropython/heap_lock.py
index ca3f5806a84eb..f2892a6dc581e 100644
--- a/tests/micropython/heap_lock.py
+++ b/tests/micropython/heap_lock.py
@@ -5,19 +5,28 @@
 l = []
 l2 = list(range(100))
 
+micropython.heap_lock()
 micropython.heap_lock()
 
 # general allocation on the heap
 try:
     print([])
 except MemoryError:
-    print('MemoryError')
+    print("MemoryError")
 
 # expansion of a heap block
 try:
     l.extend(l2)
 except MemoryError:
-    print('MemoryError')
+    print("MemoryError")
+
+print(micropython.heap_unlock())
+
+# Should still fail
+try:
+    print([])
+except MemoryError:
+    print("MemoryError")
 
 micropython.heap_unlock()
 
diff --git a/tests/micropython/heap_lock.py.exp b/tests/micropython/heap_lock.py.exp
index 819c32663471a..ae79c88b8e437 100644
--- a/tests/micropython/heap_lock.py.exp
+++ b/tests/micropython/heap_lock.py.exp
@@ -1,3 +1,5 @@
 MemoryError
 MemoryError
+1
+MemoryError
 []
diff --git a/tests/micropython/heap_locked.py b/tests/micropython/heap_locked.py
new file mode 100644
index 0000000000000..d9e5b5d4090af
--- /dev/null
+++ b/tests/micropython/heap_locked.py
@@ -0,0 +1,12 @@
+# test micropython.heap_locked()
+
+import micropython
+
+if not hasattr(micropython, "heap_locked"):
+    print("SKIP")
+    raise SystemExit
+
+micropython.heap_lock()
+print(micropython.heap_locked())
+micropython.heap_unlock()
+print(micropython.heap_locked())
diff --git a/tests/micropython/heap_locked.py.exp b/tests/micropython/heap_locked.py.exp
new file mode 100644
index 0000000000000..b261da18d51a3
--- /dev/null
+++ b/tests/micropython/heap_locked.py.exp
@@ -0,0 +1,2 @@
+1
+0
diff --git a/tests/micropython/heapalloc.py b/tests/micropython/heapalloc.py
index f74bb92c85533..99f157105daa9 100644
--- a/tests/micropython/heapalloc.py
+++ b/tests/micropython/heapalloc.py
@@ -5,18 +5,26 @@
 # Check for stackless build, which can't call functions without
 # allocating a frame on heap.
 try:
-    def stackless(): pass
-    micropython.heap_lock(); stackless(); micropython.heap_unlock()
+
+    def stackless():
+        pass
+
+    micropython.heap_lock()
+    stackless()
+    micropython.heap_unlock()
 except RuntimeError:
     print("SKIP")
     raise SystemExit
 
+
 def f1(a):
     print(a)
 
+
 def f2(a, b=2):
     print(a, b)
 
+
 def f3(a, b, c, d):
     x1 = x2 = a
     x3 = x4 = b
@@ -24,19 +32,22 @@ def f3(a, b, c, d):
     x7 = x8 = d
     print(x1, x3, x5, x7, x2 + x4 + x6 + x8)
 
+
 global_var = 1
 
+
 def test():
     global global_var, global_exc
-    global_var = 2      # set an existing global variable
+    global_var = 2  # set an existing global variable
     for i in range(2):  # for loop
-        f1(i)           # function call
-        f1(i * 2 + 1)   # binary operation with small ints
-        f1(a=i)         # keyword arguments
-        f2(i)           # default arg (second one)
-        f2(i, i)        # 2 args
+        f1(i)  # function call
+        f1(i * 2 + 1)  # binary operation with small ints
+        f1(a=i)  # keyword arguments
+        f2(i)  # default arg (second one)
+        f2(i, i)  # 2 args
     f3(1, 2, 3, 4)  # function with lots of local state
 
+
 # call test() with heap allocation disabled
 micropython.heap_lock()
 test()
diff --git a/tests/micropython/heapalloc_bytesio2.py b/tests/micropython/heapalloc_bytesio2.py
index cd76f580775c7..3b9f141270d5a 100644
--- a/tests/micropython/heapalloc_bytesio2.py
+++ b/tests/micropython/heapalloc_bytesio2.py
@@ -3,6 +3,7 @@
 try:
     import uio
     import micropython
+
     micropython.mem_total
 except (ImportError, AttributeError):
     print("SKIP")
diff --git a/tests/micropython/heapalloc_exc_compressed.py b/tests/micropython/heapalloc_exc_compressed.py
new file mode 100644
index 0000000000000..79e423ca0f565
--- /dev/null
+++ b/tests/micropython/heapalloc_exc_compressed.py
@@ -0,0 +1,48 @@
+import micropython
+
+# Tests both code paths for built-in exception raising.
+# mp_obj_new_exception_msg_varg (exception requires decompression at raise-time to format)
+# mp_obj_new_exception_msg (decompression can be deferred)
+
+# NameError uses mp_obj_new_exception_msg_varg for NameError("name '%q' isn't defined")
+# set.pop uses mp_obj_new_exception_msg for KeyError("pop from an empty set")
+
+# Tests that deferred decompression works both via print(e) and accessing the message directly via e.args.
+
+a = set()
+
+# First test the regular case (can use heap for allocating the decompression buffer).
+try:
+    name()
+except NameError as e:
+    print(type(e).__name__, e)
+
+try:
+    a.pop()
+except KeyError as e:
+    print(type(e).__name__, e)
+
+try:
+    name()
+except NameError as e:
+    print(e.args[0])
+
+try:
+    a.pop()
+except KeyError as e:
+    print(e.args[0])
+
+# Then test that it still works when the heap is locked (i.e. in ISR context).
+micropython.heap_lock()
+
+try:
+    name()
+except NameError as e:
+    print(type(e).__name__)
+
+try:
+    a.pop()
+except KeyError as e:
+    print(type(e).__name__)
+
+micropython.heap_unlock()
diff --git a/tests/micropython/heapalloc_exc_compressed.py.exp b/tests/micropython/heapalloc_exc_compressed.py.exp
new file mode 100644
index 0000000000000..32d1642f8661e
--- /dev/null
+++ b/tests/micropython/heapalloc_exc_compressed.py.exp
@@ -0,0 +1,6 @@
+NameError name 'name' isn't defined
+KeyError pop from an empty set
+name 'name' isn't defined
+pop from an empty set
+NameError
+KeyError
diff --git a/tests/micropython/heapalloc_exc_compressed_emg_exc.py b/tests/micropython/heapalloc_exc_compressed_emg_exc.py
new file mode 100644
index 0000000000000..86ade07862a1c
--- /dev/null
+++ b/tests/micropython/heapalloc_exc_compressed_emg_exc.py
@@ -0,0 +1,41 @@
+import micropython
+
+# Does the full test from heapalloc_exc_compressed.py but while the heap is
+# locked (this can only work when the emergency exception buf is enabled).
+
+# Some ports need to allocate heap for the emgergency exception buffer.
+try:
+    micropython.alloc_emergency_exception_buf(256)
+except AttributeError:
+    pass
+
+a = set()
+
+
+def test():
+    micropython.heap_lock()
+
+    try:
+        name()
+    except NameError as e:
+        print(type(e).__name__, e)
+
+    try:
+        a.pop()
+    except KeyError as e:
+        print(type(e).__name__, e)
+
+    try:
+        name()
+    except NameError as e:
+        print(e.args[0])
+
+    try:
+        a.pop()
+    except KeyError as e:
+        print(e.args[0])
+
+    micropython.heap_unlock()
+
+
+test()
diff --git a/tests/micropython/heapalloc_exc_compressed_emg_exc.py.exp b/tests/micropython/heapalloc_exc_compressed_emg_exc.py.exp
new file mode 100644
index 0000000000000..7c368712a285a
--- /dev/null
+++ b/tests/micropython/heapalloc_exc_compressed_emg_exc.py.exp
@@ -0,0 +1,4 @@
+NameError name 'name' isn't defined
+KeyError pop from an empty set
+name 'name' isn't defined
+pop from an empty set
diff --git a/tests/micropython/heapalloc_exc_raise.py b/tests/micropython/heapalloc_exc_raise.py
index fb63a84bf367a..99810e0075064 100644
--- a/tests/micropython/heapalloc_exc_raise.py
+++ b/tests/micropython/heapalloc_exc_raise.py
@@ -4,6 +4,7 @@
 
 e = ValueError("error")
 
+
 def func():
     micropython.heap_lock()
     try:
@@ -19,5 +20,6 @@ def func():
         print(e2)
     micropython.heap_unlock()
 
+
 func()
 print("ok")
diff --git a/tests/micropython/heapalloc_fail_bytearray.py b/tests/micropython/heapalloc_fail_bytearray.py
new file mode 100644
index 0000000000000..1bf7ddd600b93
--- /dev/null
+++ b/tests/micropython/heapalloc_fail_bytearray.py
@@ -0,0 +1,93 @@
+# test handling of failed heap allocation with bytearray
+
+import micropython
+
+
+class GetSlice:
+    def __getitem__(self, idx):
+        return idx
+
+
+sl = GetSlice()[:]
+
+# create bytearray
+micropython.heap_lock()
+try:
+    bytearray(4)
+except MemoryError:
+    print("MemoryError: bytearray create")
+micropython.heap_unlock()
+
+# create bytearray from bytes
+micropython.heap_lock()
+try:
+    bytearray(b"0123")
+except MemoryError:
+    print("MemoryError: bytearray create from bytes")
+micropython.heap_unlock()
+
+# create bytearray from iterator
+r = range(4)
+micropython.heap_lock()
+try:
+    bytearray(r)
+except MemoryError:
+    print("MemoryError: bytearray create from iter")
+micropython.heap_unlock()
+
+# bytearray add
+b = bytearray(4)
+micropython.heap_lock()
+try:
+    b + b"01"
+except MemoryError:
+    print("MemoryError: bytearray.__add__")
+micropython.heap_unlock()
+
+# bytearray iadd
+b = bytearray(4)
+micropython.heap_lock()
+try:
+    b += b"01234567"
+except MemoryError:
+    print("MemoryError: bytearray.__iadd__")
+micropython.heap_unlock()
+print(b)
+
+# bytearray append
+b = bytearray(4)
+micropython.heap_lock()
+try:
+    for i in range(100):
+        b.append(1)
+except MemoryError:
+    print("MemoryError: bytearray.append")
+micropython.heap_unlock()
+
+# bytearray extend
+b = bytearray(4)
+micropython.heap_lock()
+try:
+    b.extend(b"01234567")
+except MemoryError:
+    print("MemoryError: bytearray.extend")
+micropython.heap_unlock()
+
+# bytearray get with slice
+b = bytearray(4)
+micropython.heap_lock()
+try:
+    b[sl]
+except MemoryError:
+    print("MemoryError: bytearray subscr get")
+micropython.heap_unlock()
+
+# extend bytearray using slice subscr
+b = bytearray(4)
+micropython.heap_lock()
+try:
+    b[sl] = b"01234567"
+except MemoryError:
+    print("MemoryError: bytearray subscr grow")
+micropython.heap_unlock()
+print(b)
diff --git a/tests/micropython/heapalloc_fail_bytearray.py.exp b/tests/micropython/heapalloc_fail_bytearray.py.exp
new file mode 100644
index 0000000000000..57f6202f5e9e8
--- /dev/null
+++ b/tests/micropython/heapalloc_fail_bytearray.py.exp
@@ -0,0 +1,11 @@
+MemoryError: bytearray create
+MemoryError: bytearray create from bytes
+MemoryError: bytearray create from iter
+MemoryError: bytearray.__add__
+MemoryError: bytearray.__iadd__
+bytearray(b'\x00\x00\x00\x00')
+MemoryError: bytearray.append
+MemoryError: bytearray.extend
+MemoryError: bytearray subscr get
+MemoryError: bytearray subscr grow
+bytearray(b'\x00\x00\x00\x00')
diff --git a/tests/micropython/heapalloc_fail_dict.py b/tests/micropython/heapalloc_fail_dict.py
new file mode 100644
index 0000000000000..ce2d158bd09c6
--- /dev/null
+++ b/tests/micropython/heapalloc_fail_dict.py
@@ -0,0 +1,21 @@
+# test handling of failed heap allocation with dict
+
+import micropython
+
+# create dict
+x = 1
+micropython.heap_lock()
+try:
+    {x: x}
+except MemoryError:
+    print("MemoryError: create dict")
+micropython.heap_unlock()
+
+# create dict view
+x = {1: 1}
+micropython.heap_lock()
+try:
+    x.items()
+except MemoryError:
+    print("MemoryError: dict.items")
+micropython.heap_unlock()
diff --git a/tests/micropython/heapalloc_fail_dict.py.exp b/tests/micropython/heapalloc_fail_dict.py.exp
new file mode 100644
index 0000000000000..70cfc64ba43ff
--- /dev/null
+++ b/tests/micropython/heapalloc_fail_dict.py.exp
@@ -0,0 +1,2 @@
+MemoryError: create dict
+MemoryError: dict.items
diff --git a/tests/micropython/heapalloc_fail_list.py b/tests/micropython/heapalloc_fail_list.py
new file mode 100644
index 0000000000000..9a2e9a555f3e2
--- /dev/null
+++ b/tests/micropython/heapalloc_fail_list.py
@@ -0,0 +1,39 @@
+# test handling of failed heap allocation with list
+
+import micropython
+
+
+class GetSlice:
+    def __getitem__(self, idx):
+        return idx
+
+
+sl = GetSlice()[:]
+
+# create slice in VM
+l = [1, 2, 3]
+micropython.heap_lock()
+try:
+    print(l[0:1])
+except MemoryError:
+    print("MemoryError: list index")
+micropython.heap_unlock()
+
+# get from list using slice
+micropython.heap_lock()
+try:
+    l[sl]
+except MemoryError:
+    print("MemoryError: list get slice")
+micropython.heap_unlock()
+
+# extend list using slice subscr
+l = [1, 2]
+l2 = [3, 4, 5, 6, 7, 8, 9, 10]
+micropython.heap_lock()
+try:
+    l[sl] = l2
+except MemoryError:
+    print("MemoryError: list extend slice")
+micropython.heap_unlock()
+print(l)
diff --git a/tests/micropython/heapalloc_fail_list.py.exp b/tests/micropython/heapalloc_fail_list.py.exp
new file mode 100644
index 0000000000000..0e1637476b97d
--- /dev/null
+++ b/tests/micropython/heapalloc_fail_list.py.exp
@@ -0,0 +1,4 @@
+MemoryError: list index
+MemoryError: list get slice
+MemoryError: list extend slice
+[1, 2]
diff --git a/tests/micropython/heapalloc_fail_memoryview.py b/tests/micropython/heapalloc_fail_memoryview.py
new file mode 100644
index 0000000000000..da2d1abffa634
--- /dev/null
+++ b/tests/micropython/heapalloc_fail_memoryview.py
@@ -0,0 +1,28 @@
+# test handling of failed heap allocation with memoryview
+
+import micropython
+
+
+class GetSlice:
+    def __getitem__(self, idx):
+        return idx
+
+
+sl = GetSlice()[:]
+
+# create memoryview
+micropython.heap_lock()
+try:
+    memoryview(b"")
+except MemoryError:
+    print("MemoryError: memoryview create")
+micropython.heap_unlock()
+
+# memoryview get with slice
+m = memoryview(b"")
+micropython.heap_lock()
+try:
+    m[sl]
+except MemoryError:
+    print("MemoryError: memoryview subscr get")
+micropython.heap_unlock()
diff --git a/tests/micropython/heapalloc_fail_memoryview.py.exp b/tests/micropython/heapalloc_fail_memoryview.py.exp
new file mode 100644
index 0000000000000..e41a1e6cb2a75
--- /dev/null
+++ b/tests/micropython/heapalloc_fail_memoryview.py.exp
@@ -0,0 +1,2 @@
+MemoryError: memoryview create
+MemoryError: memoryview subscr get
diff --git a/tests/micropython/heapalloc_fail_set.py b/tests/micropython/heapalloc_fail_set.py
new file mode 100644
index 0000000000000..3c347660ad763
--- /dev/null
+++ b/tests/micropython/heapalloc_fail_set.py
@@ -0,0 +1,21 @@
+# test handling of failed heap allocation with set
+
+import micropython
+
+# create set
+x = 1
+micropython.heap_lock()
+try:
+    {x}
+except MemoryError:
+    print("MemoryError: set create")
+micropython.heap_unlock()
+
+# set copy
+s = {1, 2}
+micropython.heap_lock()
+try:
+    s.copy()
+except MemoryError:
+    print("MemoryError: set copy")
+micropython.heap_unlock()
diff --git a/tests/micropython/heapalloc_fail_set.py.exp b/tests/micropython/heapalloc_fail_set.py.exp
new file mode 100644
index 0000000000000..dd749672dcc38
--- /dev/null
+++ b/tests/micropython/heapalloc_fail_set.py.exp
@@ -0,0 +1,2 @@
+MemoryError: set create
+MemoryError: set copy
diff --git a/tests/micropython/heapalloc_fail_tuple.py b/tests/micropython/heapalloc_fail_tuple.py
new file mode 100644
index 0000000000000..de79385e3e3cb
--- /dev/null
+++ b/tests/micropython/heapalloc_fail_tuple.py
@@ -0,0 +1,12 @@
+# test handling of failed heap allocation with tuple
+
+import micropython
+
+# create tuple
+x = 1
+micropython.heap_lock()
+try:
+    (x,)
+except MemoryError:
+    print("MemoryError: tuple create")
+micropython.heap_unlock()
diff --git a/tests/micropython/heapalloc_fail_tuple.py.exp b/tests/micropython/heapalloc_fail_tuple.py.exp
new file mode 100644
index 0000000000000..5bf632d799cb8
--- /dev/null
+++ b/tests/micropython/heapalloc_fail_tuple.py.exp
@@ -0,0 +1 @@
+MemoryError: tuple create
diff --git a/tests/micropython/heapalloc_inst_call.py b/tests/micropython/heapalloc_inst_call.py
index 3cc497b73a7a1..14d8826bf06ce 100644
--- a/tests/micropython/heapalloc_inst_call.py
+++ b/tests/micropython/heapalloc_inst_call.py
@@ -2,22 +2,27 @@
 # doesn't require heap allocation.
 import micropython
 
+
 class Foo0:
     def __call__(self):
         print("__call__")
 
+
 class Foo1:
     def __call__(self, a):
         print("__call__", a)
 
+
 class Foo2:
     def __call__(self, a, b):
         print("__call__", a, b)
 
+
 class Foo3:
     def __call__(self, a, b, c):
         print("__call__", a, b, c)
 
+
 f0 = Foo0()
 f1 = Foo1()
 f2 = Foo2()
diff --git a/tests/micropython/heapalloc_iter.py b/tests/micropython/heapalloc_iter.py
index 163e1721115dc..18f5322ee1552 100644
--- a/tests/micropython/heapalloc_iter.py
+++ b/tests/micropython/heapalloc_iter.py
@@ -1,15 +1,23 @@
 # test that iterating doesn't use the heap
 try:
     frozenset
-    import array
-except (NameError, ImportError):
+except NameError:
     print("SKIP")
     raise SystemExit
+try:
+    import uarray as array
+except ImportError:
+    try:
+        import array
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
 
 try:
     from micropython import heap_lock, heap_unlock
 except (ImportError, AttributeError):
-    heap_lock = heap_unlock = lambda:0
+    heap_lock = heap_unlock = lambda: 0
+
 
 def do_iter(l):
     heap_lock()
@@ -17,16 +25,18 @@ def do_iter(l):
         print(i)
     heap_unlock()
 
+
 def gen_func():
     yield 1
     yield 2
 
+
 # pre-create collections to iterate over
-ba = bytearray(b'123')
-ar = array.array('H', (123, 456))
+ba = bytearray(b"123")
+ar = array.array("H", (123, 456))
 t = (1, 2, 3)
 l = [1, 2]
-d = {1:2}
+d = {1: 2}
 s = set((1,))
 fs = frozenset((1,))
 g1 = (100 + x for x in range(2))
@@ -34,7 +44,7 @@ def gen_func():
 
 # test containment (both success and failure) with the heap locked
 heap_lock()
-print(49 in b'123', 255 in b'123')
+print(49 in b"123", 255 in b"123")
 print(1 in t, -1 in t)
 print(1 in l, -1 in l)
 print(1 in d, -1 in d)
@@ -42,7 +52,7 @@ def gen_func():
 heap_unlock()
 
 # test unpacking with the heap locked
-unp0 = unp1 = unp2 = None # preallocate slots for globals
+unp0 = unp1 = unp2 = None  # preallocate slots for globals
 heap_lock()
 unp0, unp1, unp2 = t
 print(unp0, unp1, unp2)
@@ -58,7 +68,7 @@ def gen_func():
 heap_unlock()
 
 # test iterating over collections with the heap locked
-do_iter(b'123')
+do_iter(b"123")
 do_iter(ba)
 do_iter(ar)
 do_iter(t)
diff --git a/tests/micropython/heapalloc_super.py b/tests/micropython/heapalloc_super.py
index a8c23393e487d..51afae3d83d06 100644
--- a/tests/micropython/heapalloc_super.py
+++ b/tests/micropython/heapalloc_super.py
@@ -4,21 +4,30 @@
 # Check for stackless build, which can't call functions without
 # allocating a frame on heap.
 try:
-    def stackless(): pass
-    micropython.heap_lock(); stackless(); micropython.heap_unlock()
+
+    def stackless():
+        pass
+
+    micropython.heap_lock()
+    stackless()
+    micropython.heap_unlock()
 except RuntimeError:
     print("SKIP")
     raise SystemExit
 
+
 class A:
     def foo(self):
-        print('A foo')
+        print("A foo")
         return 42
+
+
 class B(A):
     def foo(self):
-        print('B foo')
+        print("B foo")
         print(super().foo())
 
+
 b = B()
 
 micropython.heap_lock()
diff --git a/tests/micropython/heapalloc_traceback.py b/tests/micropython/heapalloc_traceback.py
index 813dea4b2187c..eabd09388b90b 100644
--- a/tests/micropython/heapalloc_traceback.py
+++ b/tests/micropython/heapalloc_traceback.py
@@ -2,6 +2,7 @@
 
 import micropython
 import sys
+
 try:
     import uio
 except ImportError:
@@ -15,6 +16,7 @@
 except:
     pass
 
+
 def test():
     micropython.heap_lock()
     global global_exc
@@ -22,9 +24,10 @@ def test():
     try:
         raise global_exc
     except StopIteration:
-        print('StopIteration')
+        print("StopIteration")
     micropython.heap_unlock()
 
+
 # call test() with heap allocation disabled
 test()
 
diff --git a/tests/micropython/heapalloc_traceback.py.exp b/tests/micropython/heapalloc_traceback.py.exp
index facd0af1379bc..71929db93d5c1 100644
--- a/tests/micropython/heapalloc_traceback.py.exp
+++ b/tests/micropython/heapalloc_traceback.py.exp
@@ -1,5 +1,5 @@
 StopIteration
 Traceback (most recent call last):
-  File  , line 23, in test
+  File  , line 25, in test
 StopIteration: 
 
diff --git a/tests/micropython/heapalloc_yield_from.py b/tests/micropython/heapalloc_yield_from.py
new file mode 100644
index 0000000000000..58788b1dbcf6c
--- /dev/null
+++ b/tests/micropython/heapalloc_yield_from.py
@@ -0,0 +1,39 @@
+# Check that yield-from can work without heap allocation
+
+import micropython
+
+# Yielding from a function generator
+def sub_gen(a):
+    for i in range(a):
+        yield i
+
+
+def gen(g):
+    yield from g
+
+
+g = gen(sub_gen(4))
+micropython.heap_lock()
+print(next(g))
+print(next(g))
+micropython.heap_unlock()
+
+# Yielding from a user iterator
+class G:
+    def __init__(self):
+        self.value = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        v = self.value
+        self.value += 1
+        return v
+
+
+g = gen(G())
+micropython.heap_lock()
+print(next(g))
+print(next(g))
+micropython.heap_unlock()
diff --git a/tests/micropython/heapalloc_yield_from.py.exp b/tests/micropython/heapalloc_yield_from.py.exp
new file mode 100644
index 0000000000000..5565ed6787ffb
--- /dev/null
+++ b/tests/micropython/heapalloc_yield_from.py.exp
@@ -0,0 +1,4 @@
+0
+1
+0
+1
diff --git a/tests/micropython/kbd_intr.py b/tests/micropython/kbd_intr.py
index 879c9a229f222..81977aaa52f6f 100644
--- a/tests/micropython/kbd_intr.py
+++ b/tests/micropython/kbd_intr.py
@@ -5,7 +5,7 @@
 try:
     micropython.kbd_intr
 except AttributeError:
-    print('SKIP')
+    print("SKIP")
     raise SystemExit
 
 # just check we can actually call it
diff --git a/tests/micropython/meminfo.py b/tests/micropython/meminfo.py
index 698bbbd21cacd..9df341fbb8334 100644
--- a/tests/micropython/meminfo.py
+++ b/tests/micropython/meminfo.py
@@ -3,8 +3,8 @@
 import micropython
 
 # these functions are not always available
-if not hasattr(micropython, 'mem_info'):
-    print('SKIP')
+if not hasattr(micropython, "mem_info"):
+    print("SKIP")
 else:
     micropython.mem_info()
     micropython.mem_info(1)
diff --git a/tests/micropython/memstats.py b/tests/micropython/memstats.py
index 78e4d24736daf..dee3a4ce2f225 100644
--- a/tests/micropython/memstats.py
+++ b/tests/micropython/memstats.py
@@ -3,8 +3,8 @@
 import micropython
 
 # these functions are not always available
-if not hasattr(micropython, 'mem_total'):
-    print('SKIP')
+if not hasattr(micropython, "mem_total"):
+    print("SKIP")
 else:
     t = micropython.mem_total()
     c = micropython.mem_current()
diff --git a/tests/micropython/native_closure.py b/tests/micropython/native_closure.py
index 6c0592e52de47..07014e90dac2d 100644
--- a/tests/micropython/native_closure.py
+++ b/tests/micropython/native_closure.py
@@ -4,11 +4,15 @@
 @micropython.native
 def f():
     x = 1
+
     @micropython.native
     def g():
         nonlocal x
         return x
+
     return g
+
+
 print(f()())
 
 # closing over an argument
@@ -18,15 +22,22 @@ def f(x):
     def g():
         nonlocal x
         return x
+
     return g
+
+
 print(f(2)())
 
 # closing over an argument and a normal local
 @micropython.native
 def f(x):
     y = 2 * x
+
     @micropython.native
     def g(z):
         return x + y + z
+
     return g
+
+
 print(f(2)(3))
diff --git a/tests/micropython/native_const.py b/tests/micropython/native_const.py
index 37b491cf4aae1..b48499550e91b 100644
--- a/tests/micropython/native_const.py
+++ b/tests/micropython/native_const.py
@@ -1,14 +1,21 @@
 # test loading constants in native functions
 
+
 @micropython.native
 def f():
-    return b'bytes'
+    return b"bytes"
+
+
 print(f())
 
+
 @micropython.native
 def f():
     @micropython.native
     def g():
         return 123
+
     return g
+
+
 print(f()())
diff --git a/tests/micropython/native_const_intbig.py b/tests/micropython/native_const_intbig.py
index 611b39d8fe8c0..69bc1d2163d1e 100644
--- a/tests/micropython/native_const_intbig.py
+++ b/tests/micropython/native_const_intbig.py
@@ -1,7 +1,9 @@
 # check loading constants
 
+
 @micropython.native
 def f():
     return 123456789012345678901234567890
 
+
 print(f())
diff --git a/tests/micropython/native_gen.py b/tests/micropython/native_gen.py
new file mode 100644
index 0000000000000..fb42f9e25eded
--- /dev/null
+++ b/tests/micropython/native_gen.py
@@ -0,0 +1,25 @@
+# test for native generators
+
+# simple generator with yield and return
+@micropython.native
+def gen1(x):
+    yield x
+    yield x + 1
+    return x + 2
+
+
+g = gen1(3)
+print(next(g))
+print(next(g))
+try:
+    next(g)
+except StopIteration as e:
+    print(e.args[0])
+
+# using yield from
+@micropython.native
+def gen2(x):
+    yield from range(x)
+
+
+print(list(gen2(3)))
diff --git a/tests/micropython/native_gen.py.exp b/tests/micropython/native_gen.py.exp
new file mode 100644
index 0000000000000..cc09e309f2aa0
--- /dev/null
+++ b/tests/micropython/native_gen.py.exp
@@ -0,0 +1,4 @@
+3
+4
+5
+[0, 1, 2]
diff --git a/tests/micropython/native_misc.py b/tests/micropython/native_misc.py
index 0cd521de6c464..7c5415375e05b 100644
--- a/tests/micropython/native_misc.py
+++ b/tests/micropython/native_misc.py
@@ -4,10 +4,13 @@
 @micropython.native
 def native_test(x):
     print(1, [], x)
+
+
 native_test(2)
 
 # check that GC doesn't collect the native function
 import gc
+
 gc.collect()
 native_test(3)
 
@@ -15,17 +18,23 @@ def native_test(x):
 @micropython.native
 def f(a, b):
     print(a + b)
+
+
 f(1, 2)
 
 # native with 3 args
 @micropython.native
 def f(a, b, c):
     print(a + b + c)
+
+
 f(1, 2, 3)
 
 # check not operator
 @micropython.native
 def f(a):
     print(not a)
+
+
 f(False)
 f(True)
diff --git a/tests/micropython/native_try.py b/tests/micropython/native_try.py
index 2e41bf2ea1a9a..492b59085c778 100644
--- a/tests/micropython/native_try.py
+++ b/tests/micropython/native_try.py
@@ -6,11 +6,13 @@ def f():
     try:
         fail
     finally:
-        print('finally')
+        print("finally")
+
+
 try:
     f()
 except NameError:
-    print('NameError')
+    print("NameError")
 
 # nested try-except with try-finally
 @micropython.native
@@ -19,9 +21,11 @@ def f():
         try:
             fail
         finally:
-            print('finally')
+            print("finally")
     except NameError:
-        print('NameError')
+        print("NameError")
+
+
 f()
 
 # check that locals written to in try blocks keep their values
@@ -36,4 +40,6 @@ def f():
         print(a)
         a = 300
     print(a)
+
+
 f()
diff --git a/tests/micropython/native_try_deep.py b/tests/micropython/native_try_deep.py
index 7fac4f0f387d3..3d31248df0fe6 100644
--- a/tests/micropython/native_try_deep.py
+++ b/tests/micropython/native_try_deep.py
@@ -30,5 +30,7 @@ def f():
         finally:
             print(1)
     except ValueError:
-        print('ValueError')
+        print("ValueError")
+
+
 f()
diff --git a/tests/micropython/native_with.py b/tests/micropython/native_with.py
index 343f3e8d38aaa..4e20b23856791 100644
--- a/tests/micropython/native_with.py
+++ b/tests/micropython/native_with.py
@@ -1,18 +1,24 @@
 # test with handling within a native function
 
+
 class C:
     def __init__(self):
-        print('__init__')
+        print("__init__")
+
     def __enter__(self):
-        print('__enter__')
+        print("__enter__")
+
     def __exit__(self, a, b, c):
-        print('__exit__', a, b, c)
+        print("__exit__", a, b, c)
+
 
 # basic with
 @micropython.native
 def f():
     with C():
         print(1)
+
+
 f()
 
 # nested with and try-except
@@ -24,5 +30,7 @@ def f():
             fail
             print(2)
     except NameError:
-        print('NameError')
+        print("NameError")
+
+
 f()
diff --git a/tests/micropython/opt_level.py b/tests/micropython/opt_level.py
index 5a10047f04d4f..dd5493a7a3cb8 100644
--- a/tests/micropython/opt_level.py
+++ b/tests/micropython/opt_level.py
@@ -8,12 +8,7 @@
 
 # check that the optimisation levels actually differ
 micropython.opt_level(0)
-exec('print(__debug__)')
+exec("print(__debug__)")
 micropython.opt_level(1)
-exec('print(__debug__)')
-exec('assert 0')
-
-# check that level 3 doesn't store line numbers
-# the expected output is that any line is printed as "line 1"
-micropython.opt_level(3)
-exec('try:\n xyz\nexcept NameError as er:\n import sys\n sys.print_exception(er)')
+exec("print(__debug__)")
+exec("assert 0")
diff --git a/tests/micropython/opt_level.py.exp b/tests/micropython/opt_level.py.exp
index 6372f6c5d6056..74b3dd74e8260 100644
--- a/tests/micropython/opt_level.py.exp
+++ b/tests/micropython/opt_level.py.exp
@@ -2,6 +2,3 @@
 1
 True
 False
-Traceback (most recent call last):
-  File "<string>", line 1, in <module>
-NameError: name 'xyz' isn't defined
diff --git a/tests/micropython/opt_level_lineno.py b/tests/micropython/opt_level_lineno.py
new file mode 100644
index 0000000000000..d8253e54b41f0
--- /dev/null
+++ b/tests/micropython/opt_level_lineno.py
@@ -0,0 +1,6 @@
+import micropython as micropython
+
+# check that level 3 doesn't store line numbers
+# the expected output is that any line is printed as "line 1"
+micropython.opt_level(3)
+exec("try:\n xyz\nexcept NameError as er:\n import sys\n sys.print_exception(er)")
diff --git a/tests/micropython/opt_level_lineno.py.exp b/tests/micropython/opt_level_lineno.py.exp
new file mode 100644
index 0000000000000..469b90ba7938a
--- /dev/null
+++ b/tests/micropython/opt_level_lineno.py.exp
@@ -0,0 +1,3 @@
+Traceback (most recent call last):
+  File "<string>", line 1, in <module>
+NameError: name 'xyz' isn't defined
diff --git a/tests/micropython/schedule.py b/tests/micropython/schedule.py
index 74f90cb2de400..6a91459ea3d54 100644
--- a/tests/micropython/schedule.py
+++ b/tests/micropython/schedule.py
@@ -5,16 +5,18 @@
 try:
     micropython.schedule
 except AttributeError:
-    print('SKIP')
+    print("SKIP")
     raise SystemExit
 
 # Basic test of scheduling a function.
 
+
 def callback(arg):
     global done
     print(arg)
     done = True
 
+
 done = False
 micropython.schedule(callback, 1)
 while not done:
@@ -23,20 +25,23 @@ def callback(arg):
 # Test that callbacks can be scheduled from within a callback, but
 # that they don't execute until the outer callback is finished.
 
+
 def callback_inner(arg):
     global done
-    print('inner')
+    print("inner")
     done += 1
 
+
 def callback_outer(arg):
     global done
     micropython.schedule(callback_inner, 0)
     # need a loop so that the VM can check for pending events
     for i in range(2):
         pass
-    print('outer')
+    print("outer")
     done += 1
 
+
 done = 0
 micropython.schedule(callback_outer, 0)
 while done != 2:
@@ -45,15 +50,17 @@ def callback_outer(arg):
 # Test that scheduling too many callbacks leads to an exception.  To do this we
 # must schedule from within a callback to guarantee that the scheduler is locked.
 
+
 def callback(arg):
     global done
     try:
         for i in range(100):
-            micropython.schedule(lambda x:x, None)
+            micropython.schedule(lambda x: x, None)
     except RuntimeError:
-        print('RuntimeError')
+        print("RuntimeError")
     done = True
 
+
 done = False
 micropython.schedule(callback, None)
 while not done:
diff --git a/tests/micropython/stack_use.py b/tests/micropython/stack_use.py
index bc714755a1a49..266885d9d1897 100644
--- a/tests/micropython/stack_use.py
+++ b/tests/micropython/stack_use.py
@@ -1,7 +1,7 @@
 # tests stack_use function in micropython module
 import micropython
 
-if not hasattr(micropython, 'stack_use'):
-    print('SKIP')
+if not hasattr(micropython, "stack_use"):
+    print("SKIP")
 else:
-    print(type(micropython.stack_use())) # output varies
+    print(type(micropython.stack_use()))  # output varies
diff --git a/tests/micropython/viper_addr.py b/tests/micropython/viper_addr.py
index cd953ce07d02d..84bc6c002e8fd 100644
--- a/tests/micropython/viper_addr.py
+++ b/tests/micropython/viper_addr.py
@@ -1,29 +1,43 @@
 # test passing addresses to viper
 
+
 @micropython.viper
-def get_addr(x:ptr) -> ptr:
+def get_addr(x: ptr) -> ptr:
     return x
 
+
 @micropython.viper
-def memset(dest:ptr8, c:int, n:int):
+def memset(dest: ptr8, c: int, n: int):
     for i in range(n):
         dest[i] = c
 
+
+@micropython.viper
+def memsum(src: ptr8, n: int) -> int:
+    s = 0
+    for i in range(n):
+        s += src[i]
+    return s
+
+
 # create array and get its address
-ar = bytearray('0000')
+ar = bytearray("0000")
 addr = get_addr(ar)
 print(type(ar))
 print(type(addr))
 print(ar)
 
 # pass array as an object
-memset(ar, ord('1'), len(ar))
+memset(ar, ord("1"), len(ar))
 print(ar)
 
 # pass direct pointer to array buffer
-memset(addr, ord('2'), len(ar))
+memset(addr, ord("2"), len(ar))
 print(ar)
 
 # pass direct pointer to array buffer, with offset
-memset(addr + 2, ord('3'), len(ar) - 2)
+memset(addr + 2, ord("3"), len(ar) - 2)
 print(ar)
+
+# pass a read-only bytes object in
+print(memsum(b"\x01\x02\x03\x04", 4))
diff --git a/tests/micropython/viper_addr.py.exp b/tests/micropython/viper_addr.py.exp
index 87a18e1e2a067..8e08db9a54db9 100644
--- a/tests/micropython/viper_addr.py.exp
+++ b/tests/micropython/viper_addr.py.exp
@@ -4,3 +4,4 @@ bytearray(b'0000')
 bytearray(b'1111')
 bytearray(b'2222')
 bytearray(b'2233')
+10
diff --git a/tests/micropython/viper_args.py b/tests/micropython/viper_args.py
index ee8e82321f0fd..8e3225331a429 100644
--- a/tests/micropython/viper_args.py
+++ b/tests/micropython/viper_args.py
@@ -1,44 +1,67 @@
 # test calling viper functions with different number of args
 
+
 @micropython.viper
 def f0():
     print(0)
+
+
 f0()
 
+
 @micropython.viper
-def f1(x1:int):
+def f1(x1: int):
     print(x1)
+
+
 f1(1)
 
+
 @micropython.viper
-def f2(x1:int, x2:int):
+def f2(x1: int, x2: int):
     print(x1, x2)
+
+
 f2(1, 2)
 
+
 @micropython.viper
-def f3(x1:int, x2:int, x3:int):
+def f3(x1: int, x2: int, x3: int):
     print(x1, x2, x3)
+
+
 f3(1, 2, 3)
 
+
 @micropython.viper
-def f4(x1:int, x2:int, x3:int, x4:int):
+def f4(x1: int, x2: int, x3: int, x4: int):
     print(x1, x2, x3, x4)
+
+
 f4(1, 2, 3, 4)
 
+
 @micropython.viper
-def f5(x1:int, x2:int, x3:int, x4:int, x5:int):
+def f5(x1: int, x2: int, x3: int, x4: int, x5: int):
     print(x1, x2, x3, x4, x5)
+
+
 f5(1, 2, 3, 4, 5)
 
+
 @micropython.viper
-def f6(x1:int, x2:int, x3:int, x4:int, x5:int, x6:int):
+def f6(x1: int, x2: int, x3: int, x4: int, x5: int, x6: int):
     print(x1, x2, x3, x4, x5, x6)
+
+
 f6(1, 2, 3, 4, 5, 6)
 
 # test compiling *x, **x, * args (currently unsupported at runtime)
 @micropython.viper
 def f(*x, **y):
     pass
+
+
 @micropython.viper
 def f(*):
     pass
diff --git a/tests/micropython/viper_binop_arith.py b/tests/micropython/viper_binop_arith.py
index 4d711f1a9ff46..2691404b7b8b7 100644
--- a/tests/micropython/viper_binop_arith.py
+++ b/tests/micropython/viper_binop_arith.py
@@ -1,27 +1,36 @@
 # test arithmetic operators
 
+
 @micropython.viper
-def add(x:int, y:int):
+def add(x: int, y: int):
     print(x + y)
     print(y + x)
+
+
 add(1, 2)
 add(42, 3)
 add(-1, 2)
 add(-42, -3)
 
+
 @micropython.viper
-def sub(x:int, y:int):
+def sub(x: int, y: int):
     print(x - y)
     print(y - x)
+
+
 sub(1, 2)
 sub(42, 3)
 sub(-1, 2)
 sub(-42, -3)
 
+
 @micropython.viper
-def mul(x:int, y:int):
+def mul(x: int, y: int):
     print(x * y)
     print(y * x)
+
+
 mul(0, 1)
 mul(1, -1)
 mul(1, 2)
@@ -29,41 +38,56 @@ def mul(x:int, y:int):
 mul(-3, 4)
 mul(-9, -6)
 
+
 @micropython.viper
-def shl(x:int, y:int):
+def shl(x: int, y: int):
     print(x << y)
+
+
 shl(1, 0)
 shl(1, 3)
 shl(1, 30)
 shl(42, 10)
 shl(-42, 10)
 
+
 @micropython.viper
-def shr(x:int, y:int):
+def shr(x: int, y: int):
     print(x >> y)
+
+
 shr(1, 0)
 shr(1, 3)
 shr(42, 2)
 shr(-42, 2)
 
+
 @micropython.viper
-def and_(x:int, y:int):
+def and_(x: int, y: int):
     print(x & y, y & x)
+
+
 and_(1, 0)
 and_(1, 3)
-and_(0xf0, 0x3f)
+and_(0xF0, 0x3F)
 and_(-42, 6)
 
+
 @micropython.viper
-def or_(x:int, y:int):
+def or_(x: int, y: int):
     print(x | y, y | x)
+
+
 or_(1, 0)
 or_(1, 2)
 or_(-42, 5)
 
+
 @micropython.viper
-def xor(x:int, y:int):
+def xor(x: int, y: int):
     print(x ^ y, y ^ x)
+
+
 xor(1, 0)
 xor(1, 2)
 xor(-42, 5)
diff --git a/tests/micropython/viper_binop_comp.py b/tests/micropython/viper_binop_comp.py
index dcf91ed89db2f..a4c0809c85523 100644
--- a/tests/micropython/viper_binop_comp.py
+++ b/tests/micropython/viper_binop_comp.py
@@ -1,6 +1,6 @@
 # test comparison operators
 @micropython.viper
-def f(x:int, y:int):
+def f(x: int, y: int):
     if x < y:
         print(x, "<", y)
     if x > y:
@@ -14,6 +14,7 @@ def f(x:int, y:int):
     if x != y:
         print(x, "!=", y)
 
+
 f(1, 1)
 f(2, 1)
 f(1, 2)
diff --git a/tests/micropython/viper_binop_comp_imm.py b/tests/micropython/viper_binop_comp_imm.py
index c7c0408959514..daab8fcfb51e9 100644
--- a/tests/micropython/viper_binop_comp_imm.py
+++ b/tests/micropython/viper_binop_comp_imm.py
@@ -3,6 +3,7 @@
 def f(a: int):
     print(a == -1, a == -255, a == -256, a == -257)
 
+
 f(-1)
 f(-255)
 f(-256)
diff --git a/tests/micropython/viper_binop_divmod.py b/tests/micropython/viper_binop_divmod.py
index 822424982a0ae..4b74b527d3d00 100644
--- a/tests/micropython/viper_binop_divmod.py
+++ b/tests/micropython/viper_binop_divmod.py
@@ -1,16 +1,20 @@
 # test floor-division and modulo operators
 
+
 @micropython.viper
-def div(x:int, y:int) -> int:
+def div(x: int, y: int) -> int:
     return x // y
 
+
 @micropython.viper
-def mod(x:int, y:int) -> int:
+def mod(x: int, y: int) -> int:
     return x % y
 
+
 def dm(x, y):
     print(div(x, y), mod(x, y))
 
+
 for x in (-6, 6):
     for y in range(-7, 8):
         if y == 0:
diff --git a/tests/micropython/viper_binop_multi_comp.py b/tests/micropython/viper_binop_multi_comp.py
index 8065db291b19b..997c397d4c5e0 100644
--- a/tests/micropython/viper_binop_multi_comp.py
+++ b/tests/micropython/viper_binop_multi_comp.py
@@ -1,6 +1,6 @@
 # test multi comparison operators
 @micropython.viper
-def f(x:int, y:int):
+def f(x: int, y: int):
     if 0 < x < y:
         print(x, "<", y)
     if 3 > x > y:
@@ -14,6 +14,7 @@ def f(x:int, y:int):
     if 2 == x != y:
         print(x, "!=", y)
 
+
 f(1, 1)
 f(2, 1)
 f(1, 2)
diff --git a/tests/micropython/viper_cond.py b/tests/micropython/viper_cond.py
index bbb3f692330a3..d5ebf837bdde6 100644
--- a/tests/micropython/viper_cond.py
+++ b/tests/micropython/viper_cond.py
@@ -6,6 +6,8 @@ def f():
         pass
     else:
         print("not x", x)
+
+
 f()
 
 # using True as a conditional
@@ -14,6 +16,8 @@ def f():
     x = True
     if x:
         print("x", x)
+
+
 f()
 
 # using an int as a conditional
@@ -22,6 +26,8 @@ def g():
     y = 1
     if y:
         print("y", y)
+
+
 g()
 
 # using an int as a conditional that has the lower 16-bits clear
@@ -30,4 +36,6 @@ def h():
     z = 0x10000
     if z:
         print("z", z)
+
+
 h()
diff --git a/tests/micropython/viper_const.py b/tests/micropython/viper_const.py
index 5085ede90f074..230b282f2352e 100644
--- a/tests/micropython/viper_const.py
+++ b/tests/micropython/viper_const.py
@@ -1,14 +1,21 @@
 # test loading constants in viper functions
 
+
 @micropython.viper
 def f():
-    return b'bytes'
+    return b"bytes"
+
+
 print(f())
 
+
 @micropython.viper
 def f():
     @micropython.viper
     def g() -> int:
         return 123
+
     return g
+
+
 print(f()())
diff --git a/tests/micropython/viper_const_intbig.py b/tests/micropython/viper_const_intbig.py
index 6b44973880364..42574820a3c60 100644
--- a/tests/micropython/viper_const_intbig.py
+++ b/tests/micropython/viper_const_intbig.py
@@ -1,7 +1,9 @@
 # check loading constants
 
+
 @micropython.viper
 def f():
     return 123456789012345678901234567890
 
+
 print(f())
diff --git a/tests/micropython/viper_error.py b/tests/micropython/viper_error.py
index ff32f54739fc8..790f3d75c4f0e 100644
--- a/tests/micropython/viper_error.py
+++ b/tests/micropython/viper_error.py
@@ -1,11 +1,13 @@
 # test syntax and type errors specific to viper code generation
 
+
 def test(code):
     try:
         exec(code)
     except (SyntaxError, ViperTypeError, NotImplementedError) as e:
         print(repr(e))
 
+
 # viper: annotations must be identifiers
 test("@micropython.viper\ndef f(a:1): pass")
 test("@micropython.viper\ndef f() -> 1: pass")
@@ -14,30 +16,36 @@ def test(code):
 test("@micropython.viper\ndef f(x:unknown_type): pass")
 
 # local used before type known
-test("""
+test(
+    """
 @micropython.viper
 def f():
     print(x)
     x = 1
-""")
+"""
+)
 
 # type mismatch storing to local
-test("""
+test(
+    """
 @micropython.viper
 def f():
     x = 1
     y = []
     x = y
-""")
+"""
+)
 
 # can't implicitly convert type to bool
-test("""
+test(
+    """
 @micropython.viper
 def f():
     x = ptr(0)
     if x:
         pass
-""")
+"""
+)
 
 # incorrect return type
 test("@micropython.viper\ndef f() -> int: return []")
diff --git a/tests/micropython/viper_globals.py b/tests/micropython/viper_globals.py
index 9c68dc3da8f4c..9532dfd895b39 100644
--- a/tests/micropython/viper_globals.py
+++ b/tests/micropython/viper_globals.py
@@ -2,18 +2,21 @@
 
 gl = {}
 
-exec("""
+exec(
+    """
 @micropython.viper
 def f():
     return x
-""", gl)
+""",
+    gl,
+)
 
 # x is not yet in the globals, f should not see it
 try:
-    print(gl['f']())
+    print(gl["f"]())
 except NameError:
-    print('NameError')
+    print("NameError")
 
 # x is in globals, f should now see it
-gl['x'] = 123
-print(gl['f']())
+gl["x"] = 123
+print(gl["f"]())
diff --git a/tests/micropython/viper_import.py b/tests/micropython/viper_import.py
index 98780074447b9..3df23e17a77c1 100644
--- a/tests/micropython/viper_import.py
+++ b/tests/micropython/viper_import.py
@@ -1,10 +1,15 @@
 # test import within viper function
 
+
 @micropython.viper
 def f():
     import micropython
+
     print(micropython.const(1))
 
     from micropython import const
+
     print(const(2))
+
+
 f()
diff --git a/tests/micropython/viper_misc.py b/tests/micropython/viper_misc.py
index 021e03f2ca336..41389c751d392 100644
--- a/tests/micropython/viper_misc.py
+++ b/tests/micropython/viper_misc.py
@@ -2,61 +2,79 @@
 
 # viper function taking and returning ints
 @micropython.viper
-def viper_int(x:int, y:int) -> int:
+def viper_int(x: int, y: int) -> int:
     return x + y + 3
+
+
 print(viper_int(1, 2))
 
 # viper function taking and returning objects
 @micropython.viper
-def viper_object(x:object, y:object) -> object:
+def viper_object(x: object, y: object) -> object:
     return x + y
+
+
 print(viper_object(1, 2))
 
 # return None as non-object (should return 0)
 @micropython.viper
 def viper_ret_none() -> int:
     return None
+
+
 print(viper_ret_none())
 
 # return Ellipsis as object
 @micropython.viper
 def viper_ret_ellipsis() -> object:
     return ...
+
+
 print(viper_ret_ellipsis())
 
 # 3 args
 @micropython.viper
-def viper_3args(a:int, b:int, c:int) -> int:
+def viper_3args(a: int, b: int, c: int) -> int:
     return a + b + c
+
+
 print(viper_3args(1, 2, 3))
 
 # 4 args
 @micropython.viper
-def viper_4args(a:int, b:int, c:int, d:int) -> int:
+def viper_4args(a: int, b: int, c: int, d: int) -> int:
     return a + b + c + d
+
+
 # viper call with 4 args not yet supported
-#print(viper_4args(1, 2, 3, 4))
+# print(viper_4args(1, 2, 3, 4))
 
 # a local (should have automatic type int)
 @micropython.viper
-def viper_local(x:int) -> int:
+def viper_local(x: int) -> int:
     y = 4
     return x + y
+
+
 print(viper_local(3))
 
 # without type annotation, types should default to object
 @micropython.viper
 def viper_no_annotation(x, y):
     return x * y
+
+
 print(viper_no_annotation(4, 5))
 
 # a for loop
 @micropython.viper
-def viper_for(a:int, b:int) -> int:
+def viper_for(a: int, b: int) -> int:
     total = 0
     for x in range(a, b):
         total += x
     return total
+
+
 print(viper_for(10, 10000))
 
 # accessing a global
@@ -65,42 +83,56 @@ def viper_access_global():
     global gl
     gl = 1
     return gl
+
+
 print(viper_access_global(), gl)
 
 # calling print with object and int types
 @micropython.viper
-def viper_print(x, y:int):
+def viper_print(x, y: int):
     print(x, y + 1)
+
+
 viper_print(1, 2)
 
 # convert constants to objects in tuple
 @micropython.viper
 def viper_tuple_consts(x):
     return (x, 1, False, True)
+
+
 print(viper_tuple_consts(0))
 
 # making a tuple from an object and an int
 @micropython.viper
-def viper_tuple(x, y:int):
+def viper_tuple(x, y: int):
     return (x, y + 1)
+
+
 print(viper_tuple(1, 2))
 
 # making a list from an object and an int
 @micropython.viper
-def viper_list(x, y:int):
+def viper_list(x, y: int):
     return [x, y + 1]
+
+
 print(viper_list(1, 2))
 
 # making a set from an object and an int
 @micropython.viper
-def viper_set(x, y:int):
+def viper_set(x, y: int):
     return {x, y + 1}
+
+
 print(sorted(list(viper_set(1, 2))))
 
 # raising an exception
 @micropython.viper
-def viper_raise(x:int):
+def viper_raise(x: int):
     raise OSError(x)
+
+
 try:
     viper_raise(1)
 except OSError as e:
@@ -110,7 +142,10 @@ def viper_raise(x:int):
 @micropython.viper
 def viper_gc() -> int:
     return 1
+
+
 print(viper_gc())
 import gc
+
 gc.collect()
 print(viper_gc())
diff --git a/tests/micropython/viper_misc_intbig.py b/tests/micropython/viper_misc_intbig.py
index e036435c7abce..055c08d8e53dc 100644
--- a/tests/micropython/viper_misc_intbig.py
+++ b/tests/micropython/viper_misc_intbig.py
@@ -4,5 +4,8 @@
 @micropython.viper
 def viper_uint() -> uint:
     return uint(-1)
+
+
 import sys
+
 print(viper_uint() == (sys.maxsize << 1 | 1))
diff --git a/tests/micropython/viper_ptr16_load.py b/tests/micropython/viper_ptr16_load.py
index 0b865eb9e7b81..30c85d0669934 100644
--- a/tests/micropython/viper_ptr16_load.py
+++ b/tests/micropython/viper_ptr16_load.py
@@ -1,21 +1,25 @@
 # test loading from ptr16 type
 # only works on little endian machines
 
+
 @micropython.viper
-def get(src:ptr16) -> int:
+def get(src: ptr16) -> int:
     return src[0]
 
+
 @micropython.viper
-def get1(src:ptr16) -> int:
+def get1(src: ptr16) -> int:
     return src[1]
 
+
 @micropython.viper
-def memadd(src:ptr16, n:int) -> int:
+def memadd(src: ptr16, n: int) -> int:
     sum = 0
     for i in range(n):
         sum += src[i]
     return sum
 
+
 @micropython.viper
 def memadd2(src_in) -> int:
     src = ptr16(src_in)
@@ -25,7 +29,8 @@ def memadd2(src_in) -> int:
         sum += src[i]
     return sum
 
-b = bytearray(b'1234')
+
+b = bytearray(b"1234")
 print(b)
 print(get(b), get1(b))
 print(memadd(b, 2))
diff --git a/tests/micropython/viper_ptr16_store.py b/tests/micropython/viper_ptr16_store.py
index 5a5f25d170f99..3ca5a027c0593 100644
--- a/tests/micropython/viper_ptr16_store.py
+++ b/tests/micropython/viper_ptr16_store.py
@@ -1,25 +1,30 @@
 # test ptr16 type
 
+
 @micropython.viper
-def set(dest:ptr16, val:int):
+def set(dest: ptr16, val: int):
     dest[0] = val
 
+
 @micropython.viper
-def set1(dest:ptr16, val:int):
+def set1(dest: ptr16, val: int):
     dest[1] = val
 
+
 @micropython.viper
-def memset(dest:ptr16, val:int, n:int):
+def memset(dest: ptr16, val: int, n: int):
     for i in range(n):
         dest[i] = val
 
+
 @micropython.viper
-def memset2(dest_in, val:int):
+def memset2(dest_in, val: int):
     dest = ptr16(dest_in)
     n = int(len(dest_in)) >> 1
     for i in range(n):
         dest[i] = val
 
+
 b = bytearray(4)
 print(b)
 
diff --git a/tests/micropython/viper_ptr32_load.py b/tests/micropython/viper_ptr32_load.py
index 4d8b3846de585..b0b90bcaf551e 100644
--- a/tests/micropython/viper_ptr32_load.py
+++ b/tests/micropython/viper_ptr32_load.py
@@ -1,20 +1,24 @@
 # test loading from ptr32 type
 
+
 @micropython.viper
-def get(src:ptr32) -> int:
+def get(src: ptr32) -> int:
     return src[0]
 
+
 @micropython.viper
-def get1(src:ptr32) -> int:
+def get1(src: ptr32) -> int:
     return src[1]
 
+
 @micropython.viper
-def memadd(src:ptr32, n:int) -> int:
+def memadd(src: ptr32, n: int) -> int:
     sum = 0
     for i in range(n):
         sum += src[i]
     return sum
 
+
 @micropython.viper
 def memadd2(src_in) -> int:
     src = ptr32(src_in)
@@ -24,7 +28,8 @@ def memadd2(src_in) -> int:
         sum += src[i]
     return sum
 
-b = bytearray(b'\x12\x12\x12\x12\x34\x34\x34\x34')
+
+b = bytearray(b"\x12\x12\x12\x12\x34\x34\x34\x34")
 print(b)
 print(hex(get(b)), hex(get1(b)))
 print(hex(memadd(b, 2)))
diff --git a/tests/micropython/viper_ptr32_store.py b/tests/micropython/viper_ptr32_store.py
index 973086e4ad4dc..ff0c371ab8c0d 100644
--- a/tests/micropython/viper_ptr32_store.py
+++ b/tests/micropython/viper_ptr32_store.py
@@ -1,25 +1,30 @@
 # test store to ptr32 type
 
+
 @micropython.viper
-def set(dest:ptr32, val:int):
+def set(dest: ptr32, val: int):
     dest[0] = val
 
+
 @micropython.viper
-def set1(dest:ptr32, val:int):
+def set1(dest: ptr32, val: int):
     dest[1] = val
 
+
 @micropython.viper
-def memset(dest:ptr32, val:int, n:int):
+def memset(dest: ptr32, val: int, n: int):
     for i in range(n):
         dest[i] = val
 
+
 @micropython.viper
-def memset2(dest_in, val:int):
+def memset2(dest_in, val: int):
     dest = ptr32(dest_in)
     n = int(len(dest_in)) >> 2
     for i in range(n):
         dest[i] = val
 
+
 b = bytearray(8)
 print(b)
 
diff --git a/tests/micropython/viper_ptr8_load.py b/tests/micropython/viper_ptr8_load.py
index 0ccf8a1d76ff4..d871bfb689b35 100644
--- a/tests/micropython/viper_ptr8_load.py
+++ b/tests/micropython/viper_ptr8_load.py
@@ -1,20 +1,24 @@
 # test loading from ptr8 type
 
+
 @micropython.viper
-def get(src:ptr8) -> int:
+def get(src: ptr8) -> int:
     return src[0]
 
+
 @micropython.viper
-def get1(src:ptr8) -> int:
+def get1(src: ptr8) -> int:
     return src[1]
 
+
 @micropython.viper
-def memadd(src:ptr8, n:int) -> int:
+def memadd(src: ptr8, n: int) -> int:
     sum = 0
     for i in range(n):
         sum += src[i]
     return sum
 
+
 @micropython.viper
 def memadd2(src_in) -> int:
     src = ptr8(src_in)
@@ -24,7 +28,8 @@ def memadd2(src_in) -> int:
         sum += src[i]
     return sum
 
-b = bytearray(b'1234')
+
+b = bytearray(b"1234")
 print(b)
 print(get(b), get1(b))
 print(memadd(b, 4))
diff --git a/tests/micropython/viper_ptr8_store.py b/tests/micropython/viper_ptr8_store.py
index 5a8622eb103ad..baa9e2c6d4776 100644
--- a/tests/micropython/viper_ptr8_store.py
+++ b/tests/micropython/viper_ptr8_store.py
@@ -1,25 +1,30 @@
 # test ptr8 type
 
+
 @micropython.viper
-def set(dest:ptr8, val:int):
+def set(dest: ptr8, val: int):
     dest[0] = val
 
+
 @micropython.viper
-def set1(dest:ptr8, val:int):
+def set1(dest: ptr8, val: int):
     dest[1] = val
 
+
 @micropython.viper
-def memset(dest:ptr8, val:int, n:int):
+def memset(dest: ptr8, val: int, n: int):
     for i in range(n):
         dest[i] = val
 
+
 @micropython.viper
-def memset2(dest_in, val:int):
+def memset2(dest_in, val: int):
     dest = ptr8(dest_in)
     n = int(len(dest_in))
     for i in range(n):
         dest[i] = val
 
+
 b = bytearray(4)
 print(b)
 
diff --git a/tests/micropython/viper_subscr.py b/tests/micropython/viper_subscr.py
index 2198ed7313e6d..bcaabd3fb409b 100644
--- a/tests/micropython/viper_subscr.py
+++ b/tests/micropython/viper_subscr.py
@@ -1,15 +1,18 @@
 # test standard Python subscr using viper types
 
+
 @micropython.viper
-def get(dest, i:int):
+def get(dest, i: int):
     i += 1
     return dest[i]
 
+
 @micropython.viper
-def set(dest, i:int, val:int):
+def set(dest, i: int, val: int):
     i += 1
     dest[i] = val + 1
 
+
 ar = [i for i in range(3)]
 
 for i in range(len(ar)):
diff --git a/tests/micropython/viper_try.py b/tests/micropython/viper_try.py
index d75b3418e3d48..61335af221c7b 100644
--- a/tests/micropython/viper_try.py
+++ b/tests/micropython/viper_try.py
@@ -6,11 +6,13 @@ def f():
     try:
         fail
     finally:
-        print('finally')
+        print("finally")
+
+
 try:
     f()
 except NameError:
-    print('NameError')
+    print("NameError")
 
 # nested try-except with try-finally
 @micropython.viper
@@ -19,9 +21,11 @@ def f():
         try:
             fail
         finally:
-            print('finally')
+            print("finally")
     except NameError:
-        print('NameError')
+        print("NameError")
+
+
 f()
 
 # check that locals written to in try blocks keep their values
@@ -36,5 +40,6 @@ def f():
         print(a)
         a = 300
     print(a)
-f()
 
+
+f()
diff --git a/tests/micropython/viper_types.py b/tests/micropython/viper_types.py
new file mode 100644
index 0000000000000..3af148171e298
--- /dev/null
+++ b/tests/micropython/viper_types.py
@@ -0,0 +1,32 @@
+# test various type conversions
+
+import micropython
+
+# converting incoming arg to bool
+@micropython.viper
+def f1(x: bool):
+    print(x)
+
+
+f1(0)
+f1(1)
+f1([])
+f1([1])
+
+# taking and returning a bool
+@micropython.viper
+def f2(x: bool) -> bool:
+    return x
+
+
+print(f2([]))
+print(f2([1]))
+
+# converting to bool within function
+@micropython.viper
+def f3(x) -> bool:
+    return bool(x)
+
+
+print(f3([]))
+print(f3(-1))
diff --git a/tests/micropython/viper_types.py.exp b/tests/micropython/viper_types.py.exp
new file mode 100644
index 0000000000000..b7bef156ea494
--- /dev/null
+++ b/tests/micropython/viper_types.py.exp
@@ -0,0 +1,8 @@
+False
+True
+False
+True
+False
+True
+False
+True
diff --git a/tests/micropython/viper_with.py b/tests/micropython/viper_with.py
index 2bc3c4f1b2852..d640c8ae0f5de 100644
--- a/tests/micropython/viper_with.py
+++ b/tests/micropython/viper_with.py
@@ -1,18 +1,24 @@
 # test with handling within a viper function
 
+
 class C:
     def __init__(self):
-        print('__init__')
+        print("__init__")
+
     def __enter__(self):
-        print('__enter__')
+        print("__enter__")
+
     def __exit__(self, a, b, c):
-        print('__exit__', a, b, c)
+        print("__exit__", a, b, c)
+
 
 # basic with
 @micropython.viper
 def f():
     with C():
         print(1)
+
+
 f()
 
 # nested with and try-except
@@ -24,5 +30,7 @@ def f():
             fail
             print(2)
     except NameError:
-        print('NameError')
+        print("NameError")
+
+
 f()
diff --git a/tests/misc/features.py b/tests/misc/features.py
index 874945bfcfcc8..455b44fb1ef42 100644
--- a/tests/misc/features.py
+++ b/tests/misc/features.py
@@ -7,159 +7,199 @@
 # mad.py
 # Alf Clement 27-Mar-2014
 #
-zero=0
-three=3
+zero = 0
+three = 3
 print("1")
 print("2")
 print(three)
 print("{}".format(4))
-five=25//5
+five = 25 // 5
 print(int(five))
-j=0
+j = 0
 for i in range(4):
-	j += i
+    j += i
 print(j)
-print(3+4)
+print(3 + 4)
 try:
-	a=4//zero
+    a = 4 // zero
 except:
-	print(8)
+    print(8)
 print("xxxxxxxxx".count("x"))
+
+
 def ten():
-	return 10
+    return 10
+
+
 print(ten())
-a=[]
+a = []
 for i in range(13):
-	a.append(i)
-print(a[11])	
+    a.append(i)
+print(a[11])
 print(a[-1])
-str="0123456789"
-print(str[1]+str[3])
+str = "0123456789"
+print(str[1] + str[3])
+
+
 def p(s):
-	print(s)
+    print(s)
+
+
 p("14")
 p(15)
+
+
 class A:
-	def __init__(self):
-		self.a=16
-	def print(self):
-		print(self.a)
-	def set(self,b):
-		self.a=b
-a=A()
+    def __init__(self):
+        self.a = 16
+
+    def print(self):
+        print(self.a)
+
+    def set(self, b):
+        self.a = b
+
+
+a = A()
 a.print()
 a.set(17)
 a.print()
-b=A()
+b = A()
 b.set(a.a + 1)
 b.print()
 for i in range(20):
-	pass
+    pass
 print(i)
 if 20 > 30:
-	a="1"
+    a = "1"
 else:
-	a="2"
+    a = "2"
 if 0 < 4:
-	print(a+"0")
+    print(a + "0")
 else:
-	print(a+"1")
-a=[20,21,22,23,24]
+    print(a + "1")
+a = [20, 21, 22, 23, 24]
 for i in a:
-	if i < 21:
-		continue
-	if i > 21:
-		break
-	print(i)
-b=[a,a,a]
+    if i < 21:
+        continue
+    if i > 21:
+        break
+    print(i)
+b = [a, a, a]
 print(b[1][2])
-print(161//7)
-a=24
+print(161 // 7)
+a = 24
 while True:
-	try:
-		def gcheck():
-			global a
-			print(a)	
-		gcheck()
-		class c25():
-			x=25
-		x=c25()
-		print(x.x)
-		raise 
-	except:
-		print(26)
-	print(27+zero)
-	break
+    try:
+
+        def gcheck():
+            global a
+            print(a)
+
+        gcheck()
+
+        class c25:
+            x = 25
+
+        x = c25()
+        print(x.x)
+        raise
+    except:
+        print(26)
+    print(27 + zero)
+    break
 print(28)
-k=29
+k = 29
+
+
 def f():
-	global k
-	k = yield k
+    global k
+    k = yield k
+
+
 print(next(f()))
 while True:
-	k+= 1
-	if k < 30:
-		continue
-	break
+    k += 1
+    if k < 30:
+        continue
+    break
 print(k)
-for i in [1,2,3]:
-	class A():
-		def __init__(self, c):
-			self.a = i+10*c
-	b = A(3)
-	print(b.a)
+for i in [1, 2, 3]:
+
+    class A:
+        def __init__(self, c):
+            self.a = i + 10 * c
+
+    b = A(3)
+    print(b.a)
 print(34)
-p=0
+p = 0
 for i in range(35, -1, -1):
-	print(i)
-	p = p + 1
-	if p > 0:
-		break
-p=36
+    print(i)
+    p = p + 1
+    if p > 0:
+        break
+p = 36
 while p == 36:
-	print(p)
-	p=37
+    print(p)
+    p = 37
 print(p)
 for i in [38]:
-	print(i)
-print(int(exec("def foo(): return 38") == None)+foo())
+    print(i)
+print(int(exec("def foo(): return 38") == None) + foo())
 d = {}
 exec("def bar(): return 40", d)
 print(d["bar"]())
+
+
 def fib2(n):
-	result = []
-	a, b = 0, 1
-	while a < n:
-		result.append(a)
-		a, b = b, a+b
-	return result
-print(fib2(100)[-2]-14)
-Answer={}
-Answer["ForAll"]=42
+    result = []
+    a, b = 0, 1
+    while a < n:
+        result.append(a)
+        a, b = b, a + b
+    return result
+
+
+print(fib2(100)[-2] - 14)
+Answer = {}
+Answer["ForAll"] = 42
 print(Answer["ForAll"])
 i = 43
+
+
 def f(i=i):
     print(i)
+
+
 i = 44
 f()
 print(i)
 while True:
-	try:
-		if None != True:
-			print(45)
-			break
-		else:
-			print(0)
-	except:
-		print(0)
+    try:
+        if None != True:
+            print(45)
+            break
+        else:
+            print(0)
+    except:
+        print(0)
 print(46)
-print(46+1)
+print(46 + 1)
+
+
 def u(p):
-	if p > 3:
-		return 3*p
-	else:
-		return u(2*p)-3*u(p)
+    if p > 3:
+        return 3 * p
+    else:
+        return u(2 * p) - 3 * u(p)
+
+
 print(u(16))
+
+
 def u49():
-	return 49
+    return 49
+
+
 print(u49())
diff --git a/tests/misc/non_compliant.py b/tests/misc/non_compliant.py
index 580583bf39c32..ebba9b16aa91b 100644
--- a/tests/misc/non_compliant.py
+++ b/tests/misc/non_compliant.py
@@ -1,7 +1,7 @@
 # tests for things that are not implemented, or have non-compliant behaviour
 
 try:
-    import array
+    import uarray as array
     import ustruct
 except ImportError:
     print("SKIP")
@@ -9,143 +9,153 @@
 
 # when super can't find self
 try:
-    exec('def f(): super()')
+    exec("def f(): super()")
 except SyntaxError:
-    print('SyntaxError')
+    print("SyntaxError")
 
 # store to exception attribute is not allowed
 try:
     ValueError().x = 0
 except AttributeError:
-    print('AttributeError')
+    print("AttributeError")
 
 # array deletion not implemented
 try:
-    a = array.array('b', (1, 2, 3))
+    a = array.array("b", (1, 2, 3))
     del a[1]
 except TypeError:
-    print('TypeError')
+    print("TypeError")
 
 # slice with step!=1 not implemented
 try:
-    a = array.array('b', (1, 2, 3))
+    a = array.array("b", (1, 2, 3))
     print(a[3:2:2])
 except NotImplementedError:
-    print('NotImplementedError')
+    print("NotImplementedError")
 
 # containment, looking for integer not implemented
 try:
-    print(1 in array.array('B', b'12'))
+    print(1 in array.array("B", b"12"))
 except NotImplementedError:
-    print('NotImplementedError')
+    print("NotImplementedError")
 
 # uPy raises TypeError, shold be ValueError
 try:
-    '%c' % b'\x01\x02'
+    "%c" % b"\x01\x02"
 except (TypeError, ValueError):
-    print('TypeError, ValueError')
+    print("TypeError, ValueError")
 
 # attributes/subscr not implemented
 try:
-    print('{a[0]}'.format(a=[1, 2]))
+    print("{a[0]}".format(a=[1, 2]))
 except NotImplementedError:
-    print('NotImplementedError')
+    print("NotImplementedError")
 
 # str(...) with keywords not implemented
 try:
-    str(b'abc', encoding='utf8')
+    str(b"abc", encoding="utf8")
 except NotImplementedError:
-    print('NotImplementedError')
+    print("NotImplementedError")
 
 # str.rsplit(None, n) not implemented
 try:
-    'a a a'.rsplit(None, 1)
+    "a a a".rsplit(None, 1)
 except NotImplementedError:
-    print('NotImplementedError')
+    print("NotImplementedError")
 
 # str.endswith(s, start) not implemented
 try:
-    'abc'.endswith('c', 1)
+    "abc".endswith("c", 1)
 except NotImplementedError:
-    print('NotImplementedError')
+    print("NotImplementedError")
 
 # str subscr with step!=1 not implemented
 try:
-    print('abc'[1:2:3])
+    print("abc"[1:2:3])
 except NotImplementedError:
-    print('NotImplementedError')
+    print("NotImplementedError")
 
 # bytes(...) with keywords not implemented
 try:
-    bytes('abc', encoding='utf8')
+    bytes("abc", encoding="utf8")
 except NotImplementedError:
-    print('NotImplementedError')
+    print("NotImplementedError")
 
 # bytes subscr with step!=1 not implemented
 try:
-    b'123'[0:3:2]
+    b"123"[0:3:2]
 except NotImplementedError:
-    print('NotImplementedError')
+    print("NotImplementedError")
 
 # tuple load with step!=1 not implemented
 try:
     ()[2:3:4]
 except NotImplementedError:
-    print('NotImplementedError')
+    print("NotImplementedError")
 
 # list store with step!=1 not implemented
 try:
     [][2:3:4] = []
 except NotImplementedError:
-    print('NotImplementedError')
+    print("NotImplementedError")
 
 # list delete with step!=1 not implemented
 try:
     del [][2:3:4]
 except NotImplementedError:
-    print('NotImplementedError')
+    print("NotImplementedError")
 
 # struct pack with too many args, not checked by uPy
-print(ustruct.pack('bb', 1, 2, 3))
+print(ustruct.pack("bb", 1, 2, 3))
 
 # struct pack with too few args, not checked by uPy
-print(ustruct.pack('bb', 1))
+print(ustruct.pack("bb", 1))
 
 # array slice assignment with unsupported RHS
 try:
     bytearray(4)[0:1] = [1, 2]
 except NotImplementedError:
-    print('NotImplementedError')
+    print("NotImplementedError")
 
 # can't assign attributes to a function
 def f():
     pass
+
+
 try:
     f.x = 1
 except AttributeError:
-    print('AttributeError')
+    print("AttributeError")
 
 # can't call a function type (ie make new instances of a function)
 try:
     type(f)()
 except TypeError:
-    print('TypeError')
+    print("TypeError")
 
 # test when object explicitly listed at not-last position in parent tuple
 # this is not compliant with CPython because of illegal MRO
 class A:
     def foo(self):
-        print('A.foo')
+        print("A.foo")
+
+
 class B(object, A):
     pass
+
+
 B().foo()
 
 # can't assign property (or other special accessors) to already-subclassed class
 class A:
     pass
+
+
 class B(A):
     pass
+
+
 try:
     A.bar = property()
 except AttributeError:
-    print('AttributeError')
+    print("AttributeError")
diff --git a/tests/misc/non_compliant_lexer.py b/tests/misc/non_compliant_lexer.py
index 7e50d2836cdc7..e1c21f3d713c4 100644
--- a/tests/misc/non_compliant_lexer.py
+++ b/tests/misc/non_compliant_lexer.py
@@ -1,31 +1,33 @@
 # lexer tests for things that are not implemented, or have non-compliant behaviour
 
+
 def test(code):
     try:
         exec(code)
-        print('no Error')
+        print("no Error")
     except SyntaxError:
-        print('SyntaxError')
+        print("SyntaxError")
     except NotImplementedError:
-        print('NotImplementedError')
+        print("NotImplementedError")
+
 
 # uPy requires spaces between literal numbers and keywords, CPy doesn't
 try:
-    eval('1and 0')
+    eval("1and 0")
 except SyntaxError:
-    print('SyntaxError')
+    print("SyntaxError")
 try:
-    eval('1or 0')
+    eval("1or 0")
 except SyntaxError:
-    print('SyntaxError')
+    print("SyntaxError")
 try:
-    eval('1if 1else 0')
+    eval("1if 1else 0")
 except SyntaxError:
-    print('SyntaxError')
+    print("SyntaxError")
 try:
-    eval('1if 0else 0')
+    eval("1if 0else 0")
 except SyntaxError:
-    print('SyntaxError')
+    print("SyntaxError")
 
 # unicode name escapes are not implemented
 test('"\\N{LATIN SMALL LETTER A}"')
diff --git a/tests/misc/print_exception.py b/tests/misc/print_exception.py
index 95431632f92ab..f26c1fd5ac867 100644
--- a/tests/misc/print_exception.py
+++ b/tests/misc/print_exception.py
@@ -1,4 +1,5 @@
 import sys
+
 try:
     try:
         import uio as io
@@ -8,12 +9,14 @@
     print("SKIP")
     raise SystemExit
 
-if hasattr(sys, 'print_exception'):
+if hasattr(sys, "print_exception"):
     print_exception = sys.print_exception
 else:
     import traceback
+
     print_exception = lambda e, f: traceback.print_exception(None, e, sys.exc_info()[2], file=f)
 
+
 def print_exc(e):
     buf = io.StringIO()
     print_exception(e, buf)
@@ -29,36 +32,65 @@ def print_exc(e):
         elif not l.startswith("    "):
             print(l)
 
+
 # basic exception message
 try:
-    raise Exception('msg')
+    raise Exception("msg")
 except Exception as e:
-    print('caught')
+    print("caught")
     print_exc(e)
 
 # exception message with more than 1 source-code line
 def f():
     g()
+
+
 def g():
-    raise Exception('fail')
+    raise Exception("fail")
+
+
 try:
     f()
 except Exception as e:
-    print('caught')
+    print("caught")
+    print_exc(e)
+
+# Test that an exception propagated through a finally doesn't have a traceback added there
+try:
+    try:
+        f()
+    finally:
+        print("finally")
+except Exception as e:
+    print("caught")
+    print_exc(e)
+
+# Test that re-raising an exception doesn't add traceback info
+try:
+    try:
+        f()
+    except Exception as e:
+        print("reraise")
+        print_exc(e)
+        raise
+except Exception as e:
+    print("caught")
     print_exc(e)
 
 # Here we have a function with lots of bytecode generated for a single source-line, and
 # there is an error right at the end of the bytecode.  It should report the correct line.
 def f():
-    f([1, 2], [1, 2], [1, 2], {1:1, 1:1, 1:1, 1:1, 1:1, 1:1, 1:f.X})
+    f([1, 2], [1, 2], [1, 2], {1: 1, 1: 1, 1: 1, 1: 1, 1: 1, 1: 1, 1: f.X})
     return 1
+
+
 try:
     f()
 except Exception as e:
     print_exc(e)
 
 # Test non-stream object passed as output object, only valid for uPy
-if hasattr(sys, 'print_exception'):
+if hasattr(sys, "print_exception"):
     try:
         sys.print_exception(Exception, 1)
         had_exception = False
diff --git a/tests/misc/rge_sm.py b/tests/misc/rge_sm.py
index 5bbf9d48b5413..f3bb4189f7fdf 100644
--- a/tests/misc/rge_sm.py
+++ b/tests/misc/rge_sm.py
@@ -3,30 +3,31 @@
 
 import math
 
+
 class RungeKutta(object):
     def __init__(self, functions, initConditions, t0, dh, save=True):
-        self.Trajectory, self.save   = [[t0] + initConditions], save
-        self.functions    = [lambda *args: 1.0] + list(functions)
-        self.N, self.dh   = len(self.functions), dh
-        self.coeff        = [1.0/6.0, 2.0/6.0, 2.0/6.0, 1.0/6.0]
-        self.InArgCoeff   = [0.0, 0.5, 0.5, 1.0]
+        self.Trajectory, self.save = [[t0] + initConditions], save
+        self.functions = [lambda *args: 1.0] + list(functions)
+        self.N, self.dh = len(self.functions), dh
+        self.coeff = [1.0 / 6.0, 2.0 / 6.0, 2.0 / 6.0, 1.0 / 6.0]
+        self.InArgCoeff = [0.0, 0.5, 0.5, 1.0]
 
     def iterate(self):
-        step   = self.Trajectory[-1][:]
-        istep, iac  = step[:], self.InArgCoeff
+        step = self.Trajectory[-1][:]
+        istep, iac = step[:], self.InArgCoeff
         k, ktmp = self.N * [0.0], self.N * [0.0]
         for ic, c in enumerate(self.coeff):
             for if_, f in enumerate(self.functions):
-                arguments  = [ (x + k[i]*iac[ic]) for i, x in enumerate(istep)]
+                arguments = [(x + k[i] * iac[ic]) for i, x in enumerate(istep)]
                 try:
                     feval = f(*arguments)
                 except OverflowError:
                     return False
-                if abs(feval) > 1e2: # stop integrating
+                if abs(feval) > 1e2:  # stop integrating
                     return False
-                ktmp[if_]  = self.dh * feval
+                ktmp[if_] = self.dh * feval
             k = ktmp[:]
-            step = [s + c*k[ik] for ik,s in enumerate(step)]
+            step = [s + c * k[ik] for ik, s in enumerate(step)]
         if self.save:
             self.Trajectory += [step]
         else:
@@ -46,23 +47,45 @@ def solveNSteps(self, nSteps):
     def series(self):
         return zip(*self.Trajectory)
 
+
 # 1-loop RGES for the main parameters of the SM
 # couplings are: g1, g2, g3 of U(1), SU(2), SU(3); yt (top Yukawa), lambda (Higgs quartic)
 # see arxiv.org/abs/0812.4950, eqs 10-15
 sysSM = (
-    lambda *a: 41.0 / 96.0 / math.pi**2 * a[1]**3,  # g1
-    lambda *a: -19.0 / 96.0 / math.pi**2 * a[2]**3, # g2
-    lambda *a: -42.0 / 96.0 / math.pi**2 * a[3]**3, # g3
-    lambda *a: 1.0 / 16.0 / math.pi**2 * (9.0 / 2.0 * a[4]**3 - 8.0 * a[3]**2 * a[4] - 9.0 / 4.0 * a[2]**2 * a[4] - 17.0 / 12.0 * a[1]**2 * a[4]), # yt
-    lambda *a: 1.0 / 16.0 / math.pi**2 * (24.0 * a[5]**2 + 12.0 * a[4]**2 * a[5] - 9.0 * a[5] * (a[2]**2 + 1.0 / 3.0 * a[1]**2) - 6.0 * a[4]**4 + 9.0 / 8.0 * a[2]**4 + 3.0 / 8.0 * a[1]**4 + 3.0 / 4.0 * a[2]**2 * a[1]**2), # lambda
+    lambda *a: 41.0 / 96.0 / math.pi ** 2 * a[1] ** 3,  # g1
+    lambda *a: -19.0 / 96.0 / math.pi ** 2 * a[2] ** 3,  # g2
+    lambda *a: -42.0 / 96.0 / math.pi ** 2 * a[3] ** 3,  # g3
+    lambda *a: 1.0
+    / 16.0
+    / math.pi ** 2
+    * (
+        9.0 / 2.0 * a[4] ** 3
+        - 8.0 * a[3] ** 2 * a[4]
+        - 9.0 / 4.0 * a[2] ** 2 * a[4]
+        - 17.0 / 12.0 * a[1] ** 2 * a[4]
+    ),  # yt
+    lambda *a: 1.0
+    / 16.0
+    / math.pi ** 2
+    * (
+        24.0 * a[5] ** 2
+        + 12.0 * a[4] ** 2 * a[5]
+        - 9.0 * a[5] * (a[2] ** 2 + 1.0 / 3.0 * a[1] ** 2)
+        - 6.0 * a[4] ** 4
+        + 9.0 / 8.0 * a[2] ** 4
+        + 3.0 / 8.0 * a[1] ** 4
+        + 3.0 / 4.0 * a[2] ** 2 * a[1] ** 2
+    ),  # lambda
 )
 
+
 def drange(start, stop, step):
     r = start
     while r < stop:
         yield r
         r += step
 
+
 def phaseDiagram(system, trajStart, trajPlot, h=0.1, tend=1.0, range=1.0):
     tstart = 0.0
     for i in drange(0, range, 0.1 * range):
@@ -82,10 +105,10 @@ def phaseDiagram(system, trajStart, trajPlot, h=0.1, tend=1.0, range=1.0):
                 p2 = rk.Trajectory[2 * l]
                 x1, y1 = trajPlot(p1)
                 x2, y2 = trajPlot(p2)
-                dx = -0.5 * (y2 - y1) # orthogonal to line
+                dx = -0.5 * (y2 - y1)  # orthogonal to line
                 dy = 0.5 * (x2 - x1)  # orthogonal to line
-                #l = math.sqrt(dx*dx + dy*dy)
-                #if abs(l) > 1e-3:
+                # l = math.sqrt(dx*dx + dy*dy)
+                # if abs(l) > 1e-3:
                 #    l = 0.1 / l
                 #    dx *= l
                 #    dy *= l
@@ -94,6 +117,7 @@ def phaseDiagram(system, trajStart, trajPlot, h=0.1, tend=1.0, range=1.0):
                 print(x1 - dx, y1 - dy)
                 print()
 
+
 def singleTraj(system, trajStart, h=0.02, tend=1.0):
     tstart = 0.0
 
@@ -106,9 +130,12 @@ def singleTraj(system, trajStart, h=0.02, tend=1.0):
 
     for i in range(len(rk.Trajectory)):
         tr = rk.Trajectory[i]
-        print(' '.join(["{:.4f}".format(t) for t in tr]))
+        print(" ".join(["{:.4f}".format(t) for t in tr]))
+
 
-#phaseDiagram(sysSM, (lambda i, j: [0.354, 0.654, 1.278, 0.8 + 0.2 * i, 0.1 + 0.1 * j]), (lambda a: (a[4], a[5])), h=0.1, tend=math.log(10**17))
+# phaseDiagram(sysSM, (lambda i, j: [0.354, 0.654, 1.278, 0.8 + 0.2 * i, 0.1 + 0.1 * j]), (lambda a: (a[4], a[5])), h=0.1, tend=math.log(10**17))
 
 # initial conditions at M_Z
-singleTraj(sysSM, [0.354, 0.654, 1.278, 0.983, 0.131], h=0.5, tend=math.log(10**17)) # true values
+singleTraj(
+    sysSM, [0.354, 0.654, 1.278, 0.983, 0.131], h=0.5, tend=math.log(10 ** 17)
+)  # true values
diff --git a/tests/misc/sys_atexit.py b/tests/misc/sys_atexit.py
new file mode 100644
index 0000000000000..e9c5693f975e3
--- /dev/null
+++ b/tests/misc/sys_atexit.py
@@ -0,0 +1,21 @@
+# test sys.atexit() function
+
+import sys
+
+try:
+    sys.atexit
+except AttributeError:
+    print("SKIP")
+    raise SystemExit
+
+some_var = None
+
+
+def do_at_exit():
+    print("done at exit:", some_var)
+
+
+sys.atexit(do_at_exit)
+
+some_var = "ok"
+print("done before exit")
diff --git a/tests/misc/sys_atexit.py.exp b/tests/misc/sys_atexit.py.exp
new file mode 100644
index 0000000000000..3cbdae9a5a0aa
--- /dev/null
+++ b/tests/misc/sys_atexit.py.exp
@@ -0,0 +1,2 @@
+done before exit
+done at exit: ok
diff --git a/tests/misc/sys_exc_info.py b/tests/misc/sys_exc_info.py
index bf9438e462bac..d7e8a2d943b5e 100644
--- a/tests/misc/sys_exc_info.py
+++ b/tests/misc/sys_exc_info.py
@@ -1,15 +1,18 @@
 import sys
+
 try:
     sys.exc_info
 except:
     print("SKIP")
     raise SystemExit
 
+
 def f():
     print(sys.exc_info()[0:2])
 
+
 try:
-    raise ValueError('value', 123)
+    raise ValueError("value", 123)
 except:
     print(sys.exc_info()[0:2])
     f()
diff --git a/tests/misc/sys_settrace_features.py b/tests/misc/sys_settrace_features.py
new file mode 100644
index 0000000000000..a12304489231f
--- /dev/null
+++ b/tests/misc/sys_settrace_features.py
@@ -0,0 +1,108 @@
+import sys
+
+try:
+    sys.settrace
+except AttributeError:
+    print("SKIP")
+    raise SystemExit
+
+
+def print_stacktrace(frame, level=0):
+    # Ignore CPython specific helpers.
+    if frame.f_globals["__name__"].find("importlib") != -1:
+        print_stacktrace(frame.f_back, level)
+        return
+
+    print(
+        "%2d: %s@%s:%s => %s:%d"
+        % (
+            level,
+            "  ",
+            frame.f_globals["__name__"],
+            frame.f_code.co_name,
+            # reduce full path to some pseudo-relative
+            "misc" + "".join(frame.f_code.co_filename.split("tests/misc")[-1:]),
+            frame.f_lineno,
+        )
+    )
+
+    if frame.f_back:
+        print_stacktrace(frame.f_back, level + 1)
+
+
+class _Prof:
+    trace_count = 0
+
+    def trace_tick(self, frame, event, arg):
+        self.trace_count += 1
+        print_stacktrace(frame)
+
+
+__prof__ = _Prof()
+
+alice_handler_set = False
+
+
+def trace_tick_handler_alice(frame, event, arg):
+    print("### trace_handler::Alice event:", event)
+    __prof__.trace_tick(frame, event, arg)
+    return trace_tick_handler_alice
+
+
+bob_handler_set = False
+
+
+def trace_tick_handler_bob(frame, event, arg):
+    print("### trace_handler::Bob event:", event)
+    __prof__.trace_tick(frame, event, arg)
+    return trace_tick_handler_bob
+
+
+def trace_tick_handler(frame, event, arg):
+    # Ignore CPython specific helpers.
+    if frame.f_globals["__name__"].find("importlib") != -1:
+        return
+
+    print("### trace_handler::main event:", event)
+    __prof__.trace_tick(frame, event, arg)
+
+    if frame.f_code.co_name != "factorial":
+        return trace_tick_handler
+
+    global alice_handler_set
+    if event == "call" and not alice_handler_set:
+        alice_handler_set = True
+        return trace_tick_handler_alice
+
+    global bob_handler_set
+    if event == "call" and not bob_handler_set:
+        bob_handler_set = True
+        return trace_tick_handler_bob
+
+    return trace_tick_handler
+
+
+def factorial(n):
+    if n == 0:
+        return 1
+    else:
+        return n * factorial(n - 1)
+
+
+def do_tests():
+    # These commands are here to demonstrate some execution being traced.
+    print("Who loves the sun?")
+    print("Not every-", factorial(3))
+
+    from sys_settrace_subdir import trace_generic
+
+    trace_generic.run_tests()
+    return
+
+
+sys.settrace(trace_tick_handler)
+do_tests()
+sys.settrace(None)
+
+print("\n------------------ script exited ------------------")
+print("Total traces executed: ", __prof__.trace_count)
diff --git a/tests/misc/sys_settrace_generator.py b/tests/misc/sys_settrace_generator.py
new file mode 100644
index 0000000000000..4ace0f50e81b5
--- /dev/null
+++ b/tests/misc/sys_settrace_generator.py
@@ -0,0 +1,71 @@
+# test sys.settrace with generators
+
+import sys
+
+try:
+    sys.settrace
+except AttributeError:
+    print("SKIP")
+    raise SystemExit
+
+
+def print_stacktrace(frame, level=0):
+    print(
+        "%2d: %s@%s:%s => %s:%d"
+        % (
+            level,
+            "  ",
+            frame.f_globals["__name__"],
+            frame.f_code.co_name,
+            # reduce full path to some pseudo-relative
+            "misc" + "".join(frame.f_code.co_filename.split("tests/misc")[-1:]),
+            frame.f_lineno,
+        )
+    )
+
+    if frame.f_back:
+        print_stacktrace(frame.f_back, level + 1)
+
+
+trace_count = 0
+
+
+def trace_tick_handler(frame, event, arg):
+    global trace_count
+    print("### trace_handler::main event:", event)
+    trace_count += 1
+    print_stacktrace(frame)
+    return trace_tick_handler
+
+
+def test_generator():
+    def make_gen():
+        yield 1 << 0
+        yield 1 << 1
+        yield 1 << 2
+        return 1 << 3
+
+    gen = make_gen()
+    r = 0
+    try:
+
+        r += gen.send(None)
+
+        while True:
+
+            r += gen.send(None)
+
+    except StopIteration as e:
+        print("test_generator", r, e)
+
+    gen = make_gen()
+    r = 0
+    for i in gen:
+        r += i
+    print(r)
+
+
+sys.settrace(trace_tick_handler)
+test_generator()
+sys.settrace(None)
+print("Total traces executed: ", trace_count)
diff --git a/tests/misc/sys_settrace_generator.py.exp b/tests/misc/sys_settrace_generator.py.exp
new file mode 100644
index 0000000000000..de9d0bf1c36a6
--- /dev/null
+++ b/tests/misc/sys_settrace_generator.py.exp
@@ -0,0 +1,195 @@
+### trace_handler::main event: call
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:41
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:42
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:48
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:49
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:50
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:52
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: call
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:42
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:52
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:43
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:52
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: return
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:43
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:52
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:56
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: call
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:43
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:56
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:43
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:56
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:44
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:56
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: return
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:44
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:56
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: call
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:44
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:56
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:44
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:56
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:45
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:56
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: return
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:45
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:56
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: call
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:45
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:56
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:45
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:56
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:46
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:56
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: return
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:46
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:56
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: exception
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:56
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:58
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:59
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+test_generator 7 8
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:61
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:62
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: call
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:42
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:43
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: return
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:43
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:64
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: call
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:43
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:43
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:44
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: return
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:44
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:64
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: call
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:44
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:44
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:45
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: return
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:45
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:64
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: call
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:45
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:45
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:46
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: return
+ 0:   @__main__:make_gen => miscmisc/sys_settrace_generator.py:46
+ 1:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:63
+ 2:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+### trace_handler::main event: line
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:65
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+7
+### trace_handler::main event: return
+ 0:   @__main__:test_generator => miscmisc/sys_settrace_generator.py:65
+ 1:   @__main__:<module> => miscmisc/sys_settrace_generator.py:69
+Total traces executed:  54
diff --git a/tests/misc/sys_settrace_loop.py b/tests/misc/sys_settrace_loop.py
new file mode 100644
index 0000000000000..06d0dc17bf77b
--- /dev/null
+++ b/tests/misc/sys_settrace_loop.py
@@ -0,0 +1,60 @@
+# test sys.settrace with while and for loops
+
+import sys
+
+try:
+    sys.settrace
+except AttributeError:
+    print("SKIP")
+    raise SystemExit
+
+
+def print_stacktrace(frame, level=0):
+    print(
+        "%2d: %s@%s:%s => %s:%d"
+        % (
+            level,
+            "  ",
+            frame.f_globals["__name__"],
+            frame.f_code.co_name,
+            # reduce full path to some pseudo-relative
+            "misc" + "".join(frame.f_code.co_filename.split("tests/misc")[-1:]),
+            frame.f_lineno,
+        )
+    )
+
+    if frame.f_back:
+        print_stacktrace(frame.f_back, level + 1)
+
+
+trace_count = 0
+
+
+def trace_tick_handler(frame, event, arg):
+    global trace_count
+    print("### trace_handler::main event:", event)
+    trace_count += 1
+    print_stacktrace(frame)
+    return trace_tick_handler
+
+
+def test_loop():
+    # for loop
+    r = 0
+    for i in range(3):
+        r += i
+    print("test_for_loop", r)
+
+    # while loop
+    r = 0
+    i = 0
+    while i < 3:
+        r += i
+        i += 1
+    print("test_while_loop", i)
+
+
+sys.settrace(trace_tick_handler)
+test_loop()
+sys.settrace(None)
+print("Total traces executed: ", trace_count)
diff --git a/tests/misc/sys_settrace_loop.py.exp b/tests/misc/sys_settrace_loop.py.exp
new file mode 100644
index 0000000000000..f56f98fae01f3
--- /dev/null
+++ b/tests/misc/sys_settrace_loop.py.exp
@@ -0,0 +1,72 @@
+### trace_handler::main event: call
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:41
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:43
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:44
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:45
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:44
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:45
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:44
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:45
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:44
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:45
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:46
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+test_for_loop 3
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:49
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:50
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:51
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:53
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:52
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:53
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:52
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:53
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:52
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:53
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+### trace_handler::main event: line
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:54
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+test_while_loop 3
+### trace_handler::main event: return
+ 0:   @__main__:test_loop => miscmisc/sys_settrace_loop.py:54
+ 1:   @__main__:<module> => miscmisc/sys_settrace_loop.py:58
+Total traces executed:  23
diff --git a/tests/misc/sys_settrace_subdir/trace_generic.py b/tests/misc/sys_settrace_subdir/trace_generic.py
new file mode 100644
index 0000000000000..111a9d19ff30d
--- /dev/null
+++ b/tests/misc/sys_settrace_subdir/trace_generic.py
@@ -0,0 +1,92 @@
+print("Now comes the language constructions tests.")
+
+# function
+def test_func():
+    def test_sub_func():
+        print("test_function")
+
+    test_sub_func()
+
+
+# closure
+def test_closure(msg):
+    def make_closure():
+        print(msg)
+
+    return make_closure
+
+
+# exception
+def test_exception():
+    try:
+        raise Exception("test_exception")
+
+    except Exception:
+        pass
+
+    finally:
+        pass
+
+
+# listcomp
+def test_listcomp():
+    print("test_listcomp", [x for x in range(3)])
+
+
+# lambda
+def test_lambda():
+    func_obj_1 = lambda a, b: a + b
+    print(func_obj_1(10, 20))
+
+
+# import
+def test_import():
+    from sys_settrace_subdir import trace_importme
+
+    trace_importme.dummy()
+    trace_importme.saysomething()
+
+
+# class
+class TLClass:
+    def method():
+        pass
+
+    pass
+
+
+def test_class():
+    class TestClass:
+        __anynum = -9
+
+        def method(self):
+            print("test_class_method")
+            self.__anynum += 1
+
+        def prprty_getter(self):
+            return self.__anynum
+
+        def prprty_setter(self, what):
+            self.__anynum = what
+
+        prprty = property(prprty_getter, prprty_setter)
+
+    cls = TestClass()
+    cls.method()
+    print("test_class_property", cls.prprty)
+    cls.prprty = 12
+    print("test_class_property", cls.prprty)
+
+
+def run_tests():
+    test_func()
+    test_closure_inst = test_closure("test_closure")
+    test_closure_inst()
+    test_exception()
+    test_listcomp()
+    test_lambda()
+    test_class()
+    test_import()
+
+
+print("And it's done!")
diff --git a/tests/misc/sys_settrace_subdir/trace_importme.py b/tests/misc/sys_settrace_subdir/trace_importme.py
new file mode 100644
index 0000000000000..de561ef2176ea
--- /dev/null
+++ b/tests/misc/sys_settrace_subdir/trace_importme.py
@@ -0,0 +1,28 @@
+print("Yep, I got imported.")
+
+try:
+    x = const(1)
+except NameError:
+    print("const not defined")
+
+const = lambda x: x
+
+_CNT01 = "CONST01"
+_CNT02 = const(123)
+A123 = const(123)
+a123 = const(123)
+
+
+def dummy():
+    return False
+
+
+def saysomething():
+    print("There, I said it.")
+
+
+def neverexecuted():
+    print("Never got here!")
+
+
+print("Yep, got here")
diff --git a/tests/multi_bluetooth/ble_characteristic.py b/tests/multi_bluetooth/ble_characteristic.py
new file mode 100644
index 0000000000000..b5dfefc840dd6
--- /dev/null
+++ b/tests/multi_bluetooth/ble_characteristic.py
@@ -0,0 +1,163 @@
+# Test characteristic read/write/notify from both GATTS and GATTC.
+
+from micropython import const
+import time, machine, bluetooth
+
+TIMEOUT_MS = 5000
+
+_IRQ_CENTRAL_CONNECT = const(1 << 0)
+_IRQ_CENTRAL_DISCONNECT = const(1 << 1)
+_IRQ_GATTS_WRITE = const(1 << 2)
+_IRQ_PERIPHERAL_CONNECT = const(1 << 6)
+_IRQ_PERIPHERAL_DISCONNECT = const(1 << 7)
+_IRQ_GATTC_CHARACTERISTIC_RESULT = const(1 << 9)
+_IRQ_GATTC_READ_RESULT = const(1 << 11)
+_IRQ_GATTC_WRITE_STATUS = const(1 << 12)
+_IRQ_GATTC_NOTIFY = const(1 << 13)
+
+SERVICE_UUID = bluetooth.UUID("A5A5A5A5-FFFF-9999-1111-5A5A5A5A5A5A")
+CHAR_UUID = bluetooth.UUID("00000000-1111-2222-3333-444444444444")
+CHAR = (
+    CHAR_UUID,
+    bluetooth.FLAG_READ | bluetooth.FLAG_WRITE | bluetooth.FLAG_NOTIFY,
+)
+SERVICE = (
+    SERVICE_UUID,
+    (CHAR,),
+)
+SERVICES = (SERVICE,)
+
+last_event = None
+last_data = None
+value_handle = 0
+
+
+def irq(event, data):
+    global last_event, last_data, value_handle
+    last_event = event
+    last_data = data
+    if event == _IRQ_CENTRAL_CONNECT:
+        print("_IRQ_CENTRAL_CONNECT")
+    elif event == _IRQ_CENTRAL_DISCONNECT:
+        print("_IRQ_CENTRAL_DISCONNECT")
+    elif event == _IRQ_GATTS_WRITE:
+        print("_IRQ_GATTS_WRITE", ble.gatts_read(data[-1]))
+    elif event == _IRQ_PERIPHERAL_CONNECT:
+        print("_IRQ_PERIPHERAL_CONNECT")
+    elif event == _IRQ_PERIPHERAL_DISCONNECT:
+        print("_IRQ_PERIPHERAL_DISCONNECT")
+    elif event == _IRQ_GATTC_CHARACTERISTIC_RESULT:
+        # conn_handle, def_handle, value_handle, properties, uuid = data
+        if data[-1] == CHAR_UUID:
+            print("_IRQ_GATTC_CHARACTERISTIC_RESULT", data[-1])
+            value_handle = data[2]
+    elif event == _IRQ_GATTC_READ_RESULT:
+        print("_IRQ_GATTC_READ_RESULT", data[-1])
+    elif event == _IRQ_GATTC_WRITE_STATUS:
+        print("_IRQ_GATTC_WRITE_STATUS", data[-1])
+    elif event == _IRQ_GATTC_NOTIFY:
+        print("_IRQ_GATTC_NOTIFY", data[-1])
+
+
+def wait_for_event(event, timeout_ms):
+    t0 = time.ticks_ms()
+    while time.ticks_diff(time.ticks_ms(), t0) < timeout_ms:
+        if isinstance(event, int):
+            if last_event == event:
+                break
+        elif event():
+            break
+        machine.idle()
+
+
+# Acting in peripheral role.
+def instance0():
+    multitest.globals(BDADDR=ble.config("mac"))
+    ((char_handle,),) = ble.gatts_register_services(SERVICES)
+    print("gap_advertise")
+    ble.gap_advertise(20_000, b"\x02\x01\x06\x04\xffMPY")
+    multitest.next()
+    try:
+        # Write initial characteristic value.
+        ble.gatts_write(char_handle, "periph0")
+
+        # Wait for central to connect to us.
+        wait_for_event(_IRQ_CENTRAL_CONNECT, TIMEOUT_MS)
+        if last_event != _IRQ_CENTRAL_CONNECT:
+            return
+        conn_handle, _, _ = last_data
+
+        # Wait for a write to the characteristic from the central.
+        wait_for_event(_IRQ_GATTS_WRITE, TIMEOUT_MS)
+
+        # Wait a bit, then write the characteristic and notify it.
+        time.sleep_ms(1000)
+        ble.gatts_write(char_handle, "periph1")
+        ble.gatts_notify(conn_handle, char_handle)
+
+        # Wait for a write to the characteristic from the central.
+        wait_for_event(_IRQ_GATTS_WRITE, TIMEOUT_MS)
+
+        # Wait a bit, then notify a new value on the characteristic.
+        time.sleep_ms(1000)
+        ble.gatts_notify(conn_handle, char_handle, "periph2")
+
+        # Wait for the central to disconnect.
+        wait_for_event(_IRQ_CENTRAL_DISCONNECT, TIMEOUT_MS)
+    finally:
+        ble.active(0)
+
+
+# Acting in central role.
+def instance1():
+    multitest.next()
+    try:
+        # Connect to peripheral and then disconnect.
+        print("gap_connect")
+        ble.gap_connect(0, BDADDR)
+        wait_for_event(_IRQ_PERIPHERAL_CONNECT, TIMEOUT_MS)
+        if last_event != _IRQ_PERIPHERAL_CONNECT:
+            return
+        conn_handle, _, _ = last_data
+
+        # Discover characteristics.
+        ble.gattc_discover_characteristics(conn_handle, 1, 65535)
+        wait_for_event(lambda: value_handle, TIMEOUT_MS)
+
+        # Issue read of characteristic, should get initial value.
+        print("gattc_read")
+        ble.gattc_read(conn_handle, value_handle)
+        wait_for_event(_IRQ_GATTC_READ_RESULT, TIMEOUT_MS)
+
+        # Write to the characteristic, and ask for a response.
+        print("gattc_write")
+        ble.gattc_write(conn_handle, value_handle, "central0", 1)
+        wait_for_event(_IRQ_GATTC_WRITE_STATUS, TIMEOUT_MS)
+
+        # Wait for a notify, then read new value.
+        wait_for_event(_IRQ_GATTC_NOTIFY, TIMEOUT_MS)
+        print("gattc_read")
+        ble.gattc_read(conn_handle, value_handle)
+        wait_for_event(_IRQ_GATTC_READ_RESULT, TIMEOUT_MS)
+
+        # Write to the characteristic, and ask for a response.
+        print("gattc_write")
+        ble.gattc_write(conn_handle, value_handle, "central1", 1)
+        wait_for_event(_IRQ_GATTC_WRITE_STATUS, TIMEOUT_MS)
+
+        # Wait for a notify (should have new data), then read old value (should be unchanged).
+        wait_for_event(_IRQ_GATTC_NOTIFY, TIMEOUT_MS)
+        print("gattc_read")
+        ble.gattc_read(conn_handle, value_handle)
+        wait_for_event(_IRQ_GATTC_READ_RESULT, TIMEOUT_MS)
+
+        # Disconnect from peripheral.
+        print("gap_disconnect:", ble.gap_disconnect(conn_handle))
+        wait_for_event(_IRQ_PERIPHERAL_DISCONNECT, TIMEOUT_MS)
+    finally:
+        ble.active(0)
+
+
+ble = bluetooth.BLE()
+ble.active(1)
+ble.irq(irq)
diff --git a/tests/multi_bluetooth/ble_characteristic.py.exp b/tests/multi_bluetooth/ble_characteristic.py.exp
new file mode 100644
index 0000000000000..1532574d9882c
--- /dev/null
+++ b/tests/multi_bluetooth/ble_characteristic.py.exp
@@ -0,0 +1,24 @@
+--- instance0 ---
+gap_advertise
+_IRQ_CENTRAL_CONNECT
+_IRQ_GATTS_WRITE b'central0'
+_IRQ_GATTS_WRITE b'central1'
+_IRQ_CENTRAL_DISCONNECT
+--- instance1 ---
+gap_connect
+_IRQ_PERIPHERAL_CONNECT
+_IRQ_GATTC_CHARACTERISTIC_RESULT UUID128('00000000-1111-2222-3333-444444444444')
+gattc_read
+_IRQ_GATTC_READ_RESULT b'periph0'
+gattc_write
+_IRQ_GATTC_WRITE_STATUS 0
+_IRQ_GATTC_NOTIFY b'periph1'
+gattc_read
+_IRQ_GATTC_READ_RESULT b'periph1'
+gattc_write
+_IRQ_GATTC_WRITE_STATUS 0
+_IRQ_GATTC_NOTIFY b'periph2'
+gattc_read
+_IRQ_GATTC_READ_RESULT b'central1'
+gap_disconnect: True
+_IRQ_PERIPHERAL_DISCONNECT
diff --git a/tests/multi_bluetooth/ble_gap_advertise.py b/tests/multi_bluetooth/ble_gap_advertise.py
new file mode 100644
index 0000000000000..644b1fe28d3e8
--- /dev/null
+++ b/tests/multi_bluetooth/ble_gap_advertise.py
@@ -0,0 +1,60 @@
+# Test BLE GAP advertising and scanning
+
+from micropython import const
+import time, machine, bluetooth
+
+_IRQ_SCAN_RESULT = const(1 << 4)
+_IRQ_SCAN_COMPLETE = const(1 << 5)
+
+ADV_TIME_S = 3
+
+
+def instance0():
+    multitest.globals(BDADDR=ble.config("mac"))
+    multitest.next()
+
+    print("gap_advertise(100_000, connectable=False)")
+    ble.gap_advertise(100_000, b"\x02\x01\x06\x04\xffMPY", connectable=False)
+    time.sleep(ADV_TIME_S)
+
+    print("gap_advertise(20_000, connectable=True)")
+    ble.gap_advertise(20_000, b"\x02\x01\x06\x04\xffMPY", connectable=True)
+    time.sleep(ADV_TIME_S)
+
+    print("gap_advertise(None)")
+    ble.gap_advertise(None)
+
+    ble.active(0)
+
+
+def instance1():
+    multitest.next()
+    finished = False
+    adv_types = set()
+    adv_data = None
+
+    def irq(ev, data):
+        nonlocal finished, adv_types, adv_data
+        if ev == _IRQ_SCAN_RESULT:
+            if data[1] == BDADDR:
+                adv_types.add(data[2])
+                if adv_data is None:
+                    adv_data = bytes(data[4])
+                else:
+                    if adv_data != data[4]:
+                        adv_data = b"MISMATCH"
+        elif ev == _IRQ_SCAN_COMPLETE:
+            finished = True
+
+    ble.config(rxbuf=2000)
+    ble.irq(irq)
+    ble.gap_scan(2 * ADV_TIME_S * 1000, 10000, 10000)
+    while not finished:
+        machine.idle()
+    ble.active(0)
+    print("adv_types:", sorted(adv_types))
+    print("adv_data:", adv_data)
+
+
+ble = bluetooth.BLE()
+ble.active(1)
diff --git a/tests/multi_bluetooth/ble_gap_advertise.py.exp b/tests/multi_bluetooth/ble_gap_advertise.py.exp
new file mode 100644
index 0000000000000..2eb2a44847721
--- /dev/null
+++ b/tests/multi_bluetooth/ble_gap_advertise.py.exp
@@ -0,0 +1,7 @@
+--- instance0 ---
+gap_advertise(100_000, connectable=False)
+gap_advertise(20_000, connectable=True)
+gap_advertise(None)
+--- instance1 ---
+adv_types: [0, 2]
+adv_data: b'\x02\x01\x06\x04\xffMPY'
diff --git a/tests/multi_bluetooth/ble_gap_connect.py b/tests/multi_bluetooth/ble_gap_connect.py
new file mode 100644
index 0000000000000..def256f2c8f51
--- /dev/null
+++ b/tests/multi_bluetooth/ble_gap_connect.py
@@ -0,0 +1,94 @@
+# Test BLE GAP connect/disconnect
+
+from micropython import const
+import time, machine, bluetooth
+
+TIMEOUT_MS = 4000
+
+_IRQ_CENTRAL_CONNECT = const(1 << 0)
+_IRQ_CENTRAL_DISCONNECT = const(1 << 1)
+_IRQ_PERIPHERAL_CONNECT = const(1 << 6)
+_IRQ_PERIPHERAL_DISCONNECT = const(1 << 7)
+
+last_event = None
+last_data = None
+
+
+def irq(event, data):
+    global last_event, last_data
+    last_event = event
+    last_data = data
+    if event == _IRQ_CENTRAL_CONNECT:
+        print("_IRQ_CENTRAL_CONNECT")
+    elif event == _IRQ_CENTRAL_DISCONNECT:
+        print("_IRQ_CENTRAL_DISCONNECT")
+    elif event == _IRQ_PERIPHERAL_CONNECT:
+        print("_IRQ_PERIPHERAL_CONNECT")
+    elif event == _IRQ_PERIPHERAL_DISCONNECT:
+        print("_IRQ_PERIPHERAL_DISCONNECT")
+
+
+def wait_for_event(event, timeout_ms):
+    t0 = time.ticks_ms()
+    while last_event != event and time.ticks_diff(time.ticks_ms(), t0) < timeout_ms:
+        machine.idle()
+
+
+# Acting in peripheral role.
+def instance0():
+    multitest.globals(BDADDR=ble.config("mac"))
+    print("gap_advertise")
+    ble.gap_advertise(20_000, b"\x02\x01\x06\x04\xffMPY")
+    multitest.next()
+    try:
+        # Wait for central to connect, then wait for it to disconnect.
+        wait_for_event(_IRQ_CENTRAL_CONNECT, TIMEOUT_MS)
+        wait_for_event(_IRQ_CENTRAL_DISCONNECT, TIMEOUT_MS)
+        if last_event != _IRQ_CENTRAL_DISCONNECT:
+            return
+
+        # Start advertising again.
+        ble.gap_advertise(20_000, b"\x02\x01\x06\x04\xffMPY")
+
+        # Wait for central to connect, then disconnect it.
+        wait_for_event(_IRQ_CENTRAL_CONNECT, TIMEOUT_MS)
+        if last_event != _IRQ_CENTRAL_CONNECT:
+            return
+        print("gap_disconnect:", ble.gap_disconnect(last_data[0]))
+        wait_for_event(_IRQ_CENTRAL_DISCONNECT, TIMEOUT_MS)
+    finally:
+        ble.active(0)
+
+
+# Acting in central role.
+def instance1():
+    multitest.next()
+    try:
+        # Connect to peripheral and then disconnect.
+        print("gap_connect")
+        ble.gap_connect(0, BDADDR)
+        wait_for_event(_IRQ_PERIPHERAL_CONNECT, TIMEOUT_MS)
+        if last_event != _IRQ_PERIPHERAL_CONNECT:
+            return
+        print("gap_disconnect:", ble.gap_disconnect(last_data[0]))
+        wait_for_event(_IRQ_PERIPHERAL_DISCONNECT, TIMEOUT_MS)
+        if last_event != _IRQ_PERIPHERAL_DISCONNECT:
+            return
+
+        # Wait for peripheral to start advertising again.
+        time.sleep_ms(100)
+
+        # Connect to peripheral and then let the peripheral disconnect us.
+        print("gap_connect")
+        ble.gap_connect(0, BDADDR)
+        wait_for_event(_IRQ_PERIPHERAL_CONNECT, TIMEOUT_MS)
+        if last_event != _IRQ_PERIPHERAL_CONNECT:
+            return
+        wait_for_event(_IRQ_PERIPHERAL_DISCONNECT, TIMEOUT_MS)
+    finally:
+        ble.active(0)
+
+
+ble = bluetooth.BLE()
+ble.active(1)
+ble.irq(irq)
diff --git a/tests/multi_bluetooth/ble_gap_connect.py.exp b/tests/multi_bluetooth/ble_gap_connect.py.exp
new file mode 100644
index 0000000000000..1c96f1d48ac07
--- /dev/null
+++ b/tests/multi_bluetooth/ble_gap_connect.py.exp
@@ -0,0 +1,15 @@
+--- instance0 ---
+gap_advertise
+_IRQ_CENTRAL_CONNECT
+_IRQ_CENTRAL_DISCONNECT
+_IRQ_CENTRAL_CONNECT
+gap_disconnect: True
+_IRQ_CENTRAL_DISCONNECT
+--- instance1 ---
+gap_connect
+_IRQ_PERIPHERAL_CONNECT
+gap_disconnect: True
+_IRQ_PERIPHERAL_DISCONNECT
+gap_connect
+_IRQ_PERIPHERAL_CONNECT
+_IRQ_PERIPHERAL_DISCONNECT
diff --git a/tests/multi_bluetooth/ble_gap_device_name.py b/tests/multi_bluetooth/ble_gap_device_name.py
new file mode 100644
index 0000000000000..ee4a7a544042c
--- /dev/null
+++ b/tests/multi_bluetooth/ble_gap_device_name.py
@@ -0,0 +1,123 @@
+# Test BLE GAP device name get/set
+
+from micropython import const
+import time, machine, bluetooth
+
+TIMEOUT_MS = 5000
+
+_IRQ_CENTRAL_CONNECT = const(1 << 0)
+_IRQ_CENTRAL_DISCONNECT = const(1 << 1)
+_IRQ_PERIPHERAL_CONNECT = const(1 << 6)
+_IRQ_PERIPHERAL_DISCONNECT = const(1 << 7)
+_IRQ_GATTC_CHARACTERISTIC_RESULT = const(1 << 9)
+_IRQ_GATTC_READ_RESULT = const(1 << 11)
+
+GAP_DEVICE_NAME_UUID = bluetooth.UUID(0x2A00)
+
+last_event = None
+last_data = None
+value_handle = 0
+
+
+def irq(event, data):
+    global last_event, last_data, value_handle
+    last_event = event
+    last_data = data
+    if event == _IRQ_CENTRAL_CONNECT:
+        print("_IRQ_CENTRAL_CONNECT")
+    elif event == _IRQ_CENTRAL_DISCONNECT:
+        print("_IRQ_CENTRAL_DISCONNECT")
+    elif event == _IRQ_PERIPHERAL_CONNECT:
+        print("_IRQ_PERIPHERAL_CONNECT")
+    elif event == _IRQ_PERIPHERAL_DISCONNECT:
+        print("_IRQ_PERIPHERAL_DISCONNECT")
+    elif event == _IRQ_GATTC_CHARACTERISTIC_RESULT:
+        if data[-1] == GAP_DEVICE_NAME_UUID:
+            print("_IRQ_GATTC_CHARACTERISTIC_RESULT", data[-1])
+            value_handle = data[2]
+    elif event == _IRQ_GATTC_READ_RESULT:
+        print("_IRQ_GATTC_READ_RESULT", data[-1])
+
+
+def wait_for_event(event, timeout_ms):
+    t0 = time.ticks_ms()
+    while time.ticks_diff(time.ticks_ms(), t0) < timeout_ms:
+        if isinstance(event, int):
+            if last_event == event:
+                break
+        elif event():
+            break
+        machine.idle()
+
+
+# Acting in peripheral role.
+def instance0():
+    multitest.globals(BDADDR=ble.config("mac"))
+
+    # Test setting and getting the GAP device name before registering services.
+    ble.config(gap_name="GAP_NAME")
+    print(ble.config("gap_name"))
+
+    # Create an empty service and start advertising.
+    ble.gatts_register_services([])
+    print("gap_advertise")
+    multitest.next()
+
+    try:
+        # Do multiple iterations to test changing the name.
+        for iteration in range(2):
+            # Set the GAP device name and start advertising.
+            ble.config(gap_name="GAP_NAME{}".format(iteration))
+            print(ble.config("gap_name"))
+            ble.gap_advertise(20_000)
+
+            # Wait for central to connect, then wait for it to disconnect.
+            wait_for_event(_IRQ_CENTRAL_CONNECT, TIMEOUT_MS)
+            wait_for_event(_IRQ_CENTRAL_DISCONNECT, 4 * TIMEOUT_MS)
+            if last_event != _IRQ_CENTRAL_DISCONNECT:
+                return
+    finally:
+        ble.active(0)
+
+
+# Acting in central role.
+def instance1():
+    multitest.next()
+    try:
+        for iteration in range(2):
+            # Wait for peripheral to start advertising.
+            time.sleep_ms(500)
+
+            # Connect to peripheral.
+            print("gap_connect")
+            ble.gap_connect(0, BDADDR)
+            wait_for_event(_IRQ_PERIPHERAL_CONNECT, TIMEOUT_MS)
+            if last_event != _IRQ_PERIPHERAL_CONNECT:
+                return
+            conn_handle, _, _ = last_data
+
+            if iteration == 0:
+                print("gattc_discover_characteristics")
+                ble.gattc_discover_characteristics(conn_handle, 1, 65535)
+                wait_for_event(lambda: value_handle, TIMEOUT_MS)
+
+                # Wait for all characteristic results to come in (there should be an event for it).
+                time.sleep_ms(500)
+
+            # Read the peripheral's GAP device name.
+            print("gattc_read")
+            ble.gattc_read(conn_handle, value_handle)
+            wait_for_event(_IRQ_GATTC_READ_RESULT, TIMEOUT_MS)
+
+            # Disconnect from peripheral.
+            print("gap_disconnect:", ble.gap_disconnect(conn_handle))
+            wait_for_event(_IRQ_PERIPHERAL_DISCONNECT, TIMEOUT_MS)
+            if last_event != _IRQ_PERIPHERAL_DISCONNECT:
+                return
+    finally:
+        ble.active(0)
+
+
+ble = bluetooth.BLE()
+ble.active(1)
+ble.irq(irq)
diff --git a/tests/multi_bluetooth/ble_gap_device_name.py.exp b/tests/multi_bluetooth/ble_gap_device_name.py.exp
new file mode 100644
index 0000000000000..377df90dee356
--- /dev/null
+++ b/tests/multi_bluetooth/ble_gap_device_name.py.exp
@@ -0,0 +1,24 @@
+--- instance0 ---
+b'GAP_NAME'
+gap_advertise
+b'GAP_NAME0'
+_IRQ_CENTRAL_CONNECT
+_IRQ_CENTRAL_DISCONNECT
+b'GAP_NAME1'
+_IRQ_CENTRAL_CONNECT
+_IRQ_CENTRAL_DISCONNECT
+--- instance1 ---
+gap_connect
+_IRQ_PERIPHERAL_CONNECT
+gattc_discover_characteristics
+_IRQ_GATTC_CHARACTERISTIC_RESULT UUID16(0x2a00)
+gattc_read
+_IRQ_GATTC_READ_RESULT b'GAP_NAME0'
+gap_disconnect: True
+_IRQ_PERIPHERAL_DISCONNECT
+gap_connect
+_IRQ_PERIPHERAL_CONNECT
+gattc_read
+_IRQ_GATTC_READ_RESULT b'GAP_NAME1'
+gap_disconnect: True
+_IRQ_PERIPHERAL_DISCONNECT
diff --git a/tests/multi_bluetooth/ble_gatt_data_transfer.py b/tests/multi_bluetooth/ble_gatt_data_transfer.py
new file mode 100644
index 0000000000000..1be557f9b938a
--- /dev/null
+++ b/tests/multi_bluetooth/ble_gatt_data_transfer.py
@@ -0,0 +1,166 @@
+# Test GATTC/S data transfer between peripheral and central, and use of gatts_set_buffer()
+
+from micropython import const
+import time, machine, bluetooth
+
+TIMEOUT_MS = 5000
+
+_IRQ_CENTRAL_CONNECT = const(1 << 0)
+_IRQ_CENTRAL_DISCONNECT = const(1 << 1)
+_IRQ_GATTS_WRITE = const(1 << 2)
+_IRQ_PERIPHERAL_CONNECT = const(1 << 6)
+_IRQ_PERIPHERAL_DISCONNECT = const(1 << 7)
+_IRQ_GATTC_SERVICE_RESULT = const(1 << 8)
+_IRQ_GATTC_CHARACTERISTIC_RESULT = const(1 << 9)
+_IRQ_GATTC_READ_RESULT = const(1 << 11)
+_IRQ_GATTC_WRITE_STATUS = const(1 << 12)
+_IRQ_GATTC_NOTIFY = const(1 << 13)
+
+SERVICE_UUID = bluetooth.UUID("00000001-1111-2222-3333-444444444444")
+CHAR_CTRL_UUID = bluetooth.UUID("00000002-1111-2222-3333-444444444444")
+CHAR_RX_UUID = bluetooth.UUID("00000003-1111-2222-3333-444444444444")
+CHAR_TX_UUID = bluetooth.UUID("00000004-1111-2222-3333-444444444444")
+CHAR_CTRL = (CHAR_CTRL_UUID, bluetooth.FLAG_WRITE | bluetooth.FLAG_NOTIFY)
+CHAR_RX = (CHAR_RX_UUID, bluetooth.FLAG_WRITE | bluetooth.FLAG_WRITE_NO_RESPONSE)
+CHAR_TX = (CHAR_TX_UUID, bluetooth.FLAG_NOTIFY)
+SERVICE = (SERVICE_UUID, (CHAR_CTRL, CHAR_RX, CHAR_TX))
+SERVICES = (SERVICE,)
+
+last_event = None
+last_data = None
+ctrl_value_handle = 0
+rx_value_handle = 0
+tx_value_handle = 0
+
+
+def irq(event, data):
+    global last_event, last_data, ctrl_value_handle, rx_value_handle, tx_value_handle
+    last_event = event
+    last_data = data
+    if event == _IRQ_CENTRAL_CONNECT:
+        print("_IRQ_CENTRAL_CONNECT")
+    elif event == _IRQ_CENTRAL_DISCONNECT:
+        print("_IRQ_CENTRAL_DISCONNECT")
+    elif event == _IRQ_GATTS_WRITE:
+        print("_IRQ_GATTS_WRITE")
+    elif event == _IRQ_PERIPHERAL_CONNECT:
+        print("_IRQ_PERIPHERAL_CONNECT")
+    elif event == _IRQ_PERIPHERAL_DISCONNECT:
+        print("_IRQ_PERIPHERAL_DISCONNECT")
+    elif event == _IRQ_GATTC_CHARACTERISTIC_RESULT:
+        if data[-1] == CHAR_CTRL_UUID:
+            print("_IRQ_GATTC_SERVICE_RESULT", data[-1])
+            ctrl_value_handle = data[2]
+        elif data[-1] == CHAR_RX_UUID:
+            print("_IRQ_GATTC_SERVICE_RESULT", data[-1])
+            rx_value_handle = data[2]
+        elif data[-1] == CHAR_TX_UUID:
+            print("_IRQ_GATTC_SERVICE_RESULT", data[-1])
+            tx_value_handle = data[2]
+    elif event == _IRQ_GATTC_READ_RESULT:
+        print("_IRQ_GATTC_READ_RESULT", data[-1])
+    elif event == _IRQ_GATTC_WRITE_STATUS:
+        print("_IRQ_GATTC_WRITE_STATUS", data[-1])
+    elif event == _IRQ_GATTC_NOTIFY:
+        print("_IRQ_GATTC_NOTIFY", data[-1])
+
+
+def wait_for_event(event, timeout_ms):
+    t0 = time.ticks_ms()
+    while time.ticks_diff(time.ticks_ms(), t0) < timeout_ms:
+        if isinstance(event, int):
+            if last_event == event:
+                break
+        elif event():
+            break
+        machine.idle()
+
+
+# Acting in peripheral role.
+def instance0():
+    multitest.globals(BDADDR=ble.config("mac"))
+    ((char_ctrl_handle, char_rx_handle, char_tx_handle),) = ble.gatts_register_services(SERVICES)
+
+    # Increase the size of the rx buffer and enable append mode.
+    ble.gatts_set_buffer(char_rx_handle, 100, True)
+
+    print("gap_advertise")
+    ble.gap_advertise(20_000, b"\x02\x01\x06\x04\xffMPY")
+    multitest.next()
+    try:
+        # Wait for central to connect to us.
+        wait_for_event(_IRQ_CENTRAL_CONNECT, TIMEOUT_MS)
+        if last_event != _IRQ_CENTRAL_CONNECT:
+            return
+        conn_handle, _, _ = last_data
+
+        # Wait for the central to signal that it's done with its part of the test.
+        wait_for_event(
+            lambda: last_event == _IRQ_GATTS_WRITE and last_data[1] == char_ctrl_handle,
+            2 * TIMEOUT_MS,
+        )
+
+        # Read all accumulated data from the central.
+        print("gatts_read:", ble.gatts_read(char_rx_handle))
+
+        # Notify the central a few times.
+        for i in range(4):
+            time.sleep_ms(300)
+            ble.gatts_notify(conn_handle, char_tx_handle, "message{}".format(i))
+
+        # Notify the central that we are done with our part of the test.
+        time.sleep_ms(300)
+        ble.gatts_notify(conn_handle, char_ctrl_handle, "OK")
+
+        # Wait for the central to disconnect.
+        wait_for_event(_IRQ_CENTRAL_DISCONNECT, TIMEOUT_MS)
+    finally:
+        ble.active(0)
+
+
+# Acting in central role.
+def instance1():
+    multitest.next()
+    try:
+        # Connect to peripheral and then disconnect.
+        print("gap_connect")
+        ble.gap_connect(0, BDADDR)
+        wait_for_event(_IRQ_PERIPHERAL_CONNECT, TIMEOUT_MS)
+        if last_event != _IRQ_PERIPHERAL_CONNECT:
+            return
+        conn_handle, _, _ = last_data
+
+        # Discover characteristics.
+        ble.gattc_discover_characteristics(conn_handle, 1, 65535)
+        wait_for_event(
+            lambda: ctrl_value_handle and rx_value_handle and tx_value_handle, TIMEOUT_MS
+        )
+
+        # Write to the characteristic a few times, with and without response.
+        for i in range(4):
+            print("gattc_write")
+            ble.gattc_write(conn_handle, rx_value_handle, "central{}".format(i), i & 1)
+            if i & 1:
+                wait_for_event(_IRQ_GATTC_WRITE_STATUS, TIMEOUT_MS)
+            time.sleep_ms(400)
+
+        # Write to say that we are done with our part of the test.
+        ble.gattc_write(conn_handle, ctrl_value_handle, "OK", 1)
+        wait_for_event(_IRQ_GATTC_WRITE_STATUS, TIMEOUT_MS)
+
+        # Wait for notification that peripheral is done with its part of the test.
+        wait_for_event(
+            lambda: last_event == _IRQ_GATTC_NOTIFY and last_data[1] == ctrl_value_handle,
+            TIMEOUT_MS,
+        )
+
+        # Disconnect from peripheral.
+        print("gap_disconnect:", ble.gap_disconnect(conn_handle))
+        wait_for_event(_IRQ_PERIPHERAL_DISCONNECT, TIMEOUT_MS)
+    finally:
+        ble.active(0)
+
+
+ble = bluetooth.BLE()
+ble.active(1)
+ble.irq(irq)
diff --git a/tests/multi_bluetooth/ble_gatt_data_transfer.py.exp b/tests/multi_bluetooth/ble_gatt_data_transfer.py.exp
new file mode 100644
index 0000000000000..6ecd48225f5fe
--- /dev/null
+++ b/tests/multi_bluetooth/ble_gatt_data_transfer.py.exp
@@ -0,0 +1,30 @@
+--- instance0 ---
+gap_advertise
+_IRQ_CENTRAL_CONNECT
+_IRQ_GATTS_WRITE
+_IRQ_GATTS_WRITE
+_IRQ_GATTS_WRITE
+_IRQ_GATTS_WRITE
+_IRQ_GATTS_WRITE
+gatts_read: b'central0central1central2central3'
+_IRQ_CENTRAL_DISCONNECT
+--- instance1 ---
+gap_connect
+_IRQ_PERIPHERAL_CONNECT
+_IRQ_GATTC_SERVICE_RESULT UUID128('00000002-1111-2222-3333-444444444444')
+_IRQ_GATTC_SERVICE_RESULT UUID128('00000003-1111-2222-3333-444444444444')
+_IRQ_GATTC_SERVICE_RESULT UUID128('00000004-1111-2222-3333-444444444444')
+gattc_write
+gattc_write
+_IRQ_GATTC_WRITE_STATUS 0
+gattc_write
+gattc_write
+_IRQ_GATTC_WRITE_STATUS 0
+_IRQ_GATTC_WRITE_STATUS 0
+_IRQ_GATTC_NOTIFY b'message0'
+_IRQ_GATTC_NOTIFY b'message1'
+_IRQ_GATTC_NOTIFY b'message2'
+_IRQ_GATTC_NOTIFY b'message3'
+_IRQ_GATTC_NOTIFY b'OK'
+gap_disconnect: True
+_IRQ_PERIPHERAL_DISCONNECT
diff --git a/tests/multi_bluetooth/ble_gattc_discover_services.py b/tests/multi_bluetooth/ble_gattc_discover_services.py
new file mode 100644
index 0000000000000..b01a890c72038
--- /dev/null
+++ b/tests/multi_bluetooth/ble_gattc_discover_services.py
@@ -0,0 +1,99 @@
+# Test BLE GAP connect/disconnect
+
+from micropython import const
+import time, machine, bluetooth
+
+TIMEOUT_MS = 5000
+
+_IRQ_CENTRAL_CONNECT = const(1 << 0)
+_IRQ_CENTRAL_DISCONNECT = const(1 << 1)
+_IRQ_PERIPHERAL_CONNECT = const(1 << 6)
+_IRQ_PERIPHERAL_DISCONNECT = const(1 << 7)
+_IRQ_GATTC_SERVICE_RESULT = const(1 << 8)
+
+UUID_A = bluetooth.UUID(0x180D)
+UUID_B = bluetooth.UUID("A5A5A5A5-FFFF-9999-1111-5A5A5A5A5A5A")
+SERVICE_A = (
+    UUID_A,
+    (),
+)
+SERVICE_B = (
+    UUID_B,
+    (),
+)
+SERVICES = (SERVICE_A, SERVICE_B)
+
+last_event = None
+last_data = None
+num_service_result = 0
+
+
+def irq(event, data):
+    global last_event, last_data, num_service_result
+    last_event = event
+    last_data = data
+    if event == _IRQ_CENTRAL_CONNECT:
+        print("_IRQ_CENTRAL_CONNECT")
+    elif event == _IRQ_CENTRAL_DISCONNECT:
+        print("_IRQ_CENTRAL_DISCONNECT")
+    elif event == _IRQ_PERIPHERAL_CONNECT:
+        print("_IRQ_PERIPHERAL_CONNECT")
+    elif event == _IRQ_PERIPHERAL_DISCONNECT:
+        print("_IRQ_PERIPHERAL_DISCONNECT")
+    elif event == _IRQ_GATTC_SERVICE_RESULT:
+        if data[3] == UUID_A or data[3] == UUID_B:
+            print("_IRQ_GATTC_SERVICE_RESULT", data[3])
+            num_service_result += 1
+
+
+def wait_for_event(event, timeout_ms):
+    t0 = time.ticks_ms()
+    while time.ticks_diff(time.ticks_ms(), t0) < timeout_ms:
+        if isinstance(event, int):
+            if last_event == event:
+                break
+        elif event():
+            break
+        machine.idle()
+
+
+# Acting in peripheral role.
+def instance0():
+    multitest.globals(BDADDR=ble.config("mac"))
+    ble.gatts_register_services(SERVICES)
+    print("gap_advertise")
+    ble.gap_advertise(20_000, b"\x02\x01\x06\x04\xffMPY")
+    multitest.next()
+    try:
+        wait_for_event(_IRQ_CENTRAL_CONNECT, TIMEOUT_MS)
+        wait_for_event(_IRQ_CENTRAL_DISCONNECT, TIMEOUT_MS)
+    finally:
+        ble.active(0)
+
+
+# Acting in central role.
+def instance1():
+    multitest.next()
+    try:
+        # Connect to peripheral and then disconnect.
+        print("gap_connect")
+        ble.gap_connect(0, BDADDR)
+        wait_for_event(_IRQ_PERIPHERAL_CONNECT, TIMEOUT_MS)
+        if last_event != _IRQ_PERIPHERAL_CONNECT:
+            return
+        conn_handle, _, _ = last_data
+
+        # Discover services.
+        ble.gattc_discover_services(conn_handle)
+        wait_for_event(lambda: num_service_result == 2, TIMEOUT_MS)
+
+        # Disconnect from peripheral.
+        print("gap_disconnect:", ble.gap_disconnect(conn_handle))
+        wait_for_event(_IRQ_PERIPHERAL_DISCONNECT, TIMEOUT_MS)
+    finally:
+        ble.active(0)
+
+
+ble = bluetooth.BLE()
+ble.active(1)
+ble.irq(irq)
diff --git a/tests/multi_bluetooth/ble_gattc_discover_services.py.exp b/tests/multi_bluetooth/ble_gattc_discover_services.py.exp
new file mode 100644
index 0000000000000..06c36b249368a
--- /dev/null
+++ b/tests/multi_bluetooth/ble_gattc_discover_services.py.exp
@@ -0,0 +1,11 @@
+--- instance0 ---
+gap_advertise
+_IRQ_CENTRAL_CONNECT
+_IRQ_CENTRAL_DISCONNECT
+--- instance1 ---
+gap_connect
+_IRQ_PERIPHERAL_CONNECT
+_IRQ_GATTC_SERVICE_RESULT UUID16(0x180d)
+_IRQ_GATTC_SERVICE_RESULT UUID128('a5a5a5a5-ffff-9999-1111-5a5a5a5a5a5a')
+gap_disconnect: True
+_IRQ_PERIPHERAL_DISCONNECT
diff --git a/tests/multi_net/ssl_data.py b/tests/multi_net/ssl_data.py
new file mode 100644
index 0000000000000..81239b454c59a
--- /dev/null
+++ b/tests/multi_net/ssl_data.py
@@ -0,0 +1,32 @@
+# Simple test creating an SSL connection and transferring some data
+# This test won't run under CPython because it requires key/cert
+
+import usocket as socket, ussl as ssl
+
+PORT = 8000
+
+
+# Server
+def instance0():
+    multitest.globals(IP=multitest.get_network_ip())
+    s = socket.socket()
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    s.bind(socket.getaddrinfo("0.0.0.0", PORT)[0][-1])
+    s.listen(1)
+    multitest.next()
+    s2, _ = s.accept()
+    s2 = ssl.wrap_socket(s2, server_side=True)
+    print(s2.read(16))
+    s2.write(b"server to client")
+    s.close()
+
+
+# Client
+def instance1():
+    multitest.next()
+    s = socket.socket()
+    s.connect(socket.getaddrinfo(IP, PORT)[0][-1])
+    s = ssl.wrap_socket(s)
+    s.write(b"client to server")
+    print(s.read(16))
+    s.close()
diff --git a/tests/multi_net/ssl_data.py.exp b/tests/multi_net/ssl_data.py.exp
new file mode 100644
index 0000000000000..909c496d019e1
--- /dev/null
+++ b/tests/multi_net/ssl_data.py.exp
@@ -0,0 +1,4 @@
+--- instance0 ---
+b'client to server'
+--- instance1 ---
+b'server to client'
diff --git a/tests/multi_net/tcp_accept_recv.py b/tests/multi_net/tcp_accept_recv.py
new file mode 100644
index 0000000000000..d61108ed1c8bd
--- /dev/null
+++ b/tests/multi_net/tcp_accept_recv.py
@@ -0,0 +1,30 @@
+# Test recv on socket that just accepted a connection
+
+import socket
+
+PORT = 8000
+
+
+# Server
+def instance0():
+    multitest.globals(IP=multitest.get_network_ip())
+    s = socket.socket()
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    s.bind(socket.getaddrinfo("0.0.0.0", PORT)[0][-1])
+    s.listen(1)
+    multitest.next()
+    s.accept()
+    try:
+        print("recv", s.recv(10))  # should raise Errno 107 ENOTCONN
+    except OSError as er:
+        print(er.args[0])
+    s.close()
+
+
+# Client
+def instance1():
+    multitest.next()
+    s = socket.socket()
+    s.connect(socket.getaddrinfo(IP, PORT)[0][-1])
+    s.send(b"GET / HTTP/1.0\r\n\r\n")
+    s.close()
diff --git a/tests/multi_net/tcp_client_rst.py b/tests/multi_net/tcp_client_rst.py
new file mode 100644
index 0000000000000..08f262db50810
--- /dev/null
+++ b/tests/multi_net/tcp_client_rst.py
@@ -0,0 +1,56 @@
+# Test when client does a TCP RST on an open connection
+
+import struct, time, socket, select
+
+PORT = 8000
+
+
+def convert_poll_list(l):
+    # To be compatible across all ports/targets
+    return [ev for _, ev in l]
+
+
+# Server
+def instance0():
+    multitest.globals(IP=multitest.get_network_ip())
+    s = socket.socket()
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    s.bind(socket.getaddrinfo("0.0.0.0", PORT)[0][-1])
+    s.listen(1)
+    multitest.next()
+    s2, _ = s.accept()
+    s2.setblocking(False)
+    poll = select.poll()
+    poll.register(s2, select.POLLIN)
+    time.sleep(0.4)
+    print(convert_poll_list(poll.poll(1000)))
+    # TODO: the following recv don't work with lwip, it abandons data upon TCP RST
+    try:
+        print(s2.recv(10))
+        print(convert_poll_list(poll.poll(1000)))
+        print(s2.recv(10))
+        print(convert_poll_list(poll.poll(1000)))
+        print(s2.recv(10))
+        print(convert_poll_list(poll.poll(1000)))
+    except OSError as er:
+        print(er.args[0])
+    print(convert_poll_list(poll.poll(1000)))
+    # TODO lwip raises here but apparently it shouldn't
+    print(s2.recv(10))
+    print(convert_poll_list(poll.poll(1000)))
+    s.close()
+
+
+# Client
+def instance1():
+    if not hasattr(socket, "SO_LINGER"):
+        multitest.skip()
+    multitest.next()
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
+    s.connect(socket.getaddrinfo(IP, PORT)[0][-1])
+    lgr_onoff = 1
+    lgr_linger = 0
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack("ii", lgr_onoff, lgr_linger))
+    s.send(b"GET / HTTP/1.0\r\n\r\n")
+    time.sleep(0.2)
+    s.close()  # This issues a TCP RST since we've set the linger option
diff --git a/tests/multi_net/tcp_data.py b/tests/multi_net/tcp_data.py
new file mode 100644
index 0000000000000..61224efd2c530
--- /dev/null
+++ b/tests/multi_net/tcp_data.py
@@ -0,0 +1,28 @@
+# Simple test of a TCP server and client transferring data
+
+import socket
+
+PORT = 8000
+
+# Server
+def instance0():
+    multitest.globals(IP=multitest.get_network_ip())
+    s = socket.socket()
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    s.bind(socket.getaddrinfo("0.0.0.0", PORT)[0][-1])
+    s.listen(1)
+    multitest.next()
+    s2, _ = s.accept()
+    print(s2.recv(16))
+    s2.send(b"server to client")
+    s.close()
+
+
+# Client
+def instance1():
+    multitest.next()
+    s = socket.socket()
+    s.connect(socket.getaddrinfo(IP, PORT)[0][-1])
+    s.send(b"client to server")
+    print(s.recv(16))
+    s.close()
diff --git a/tests/multi_net/uasyncio_tcp_client_rst.py b/tests/multi_net/uasyncio_tcp_client_rst.py
new file mode 100644
index 0000000000000..a3a05490c776b
--- /dev/null
+++ b/tests/multi_net/uasyncio_tcp_client_rst.py
@@ -0,0 +1,56 @@
+# Test TCP server with client issuing TCP RST part way through read
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+import struct, time, socket
+
+PORT = 8000
+
+
+async def handle_connection(reader, writer):
+    data = await reader.read(10)  # should succeed
+    print(data)
+    await asyncio.sleep(0.2)  # wait for client to drop connection
+    try:
+        data = await reader.read(100)
+        print(data)
+        writer.close()
+        await writer.wait_closed()
+    except OSError as er:
+        print("OSError", er.args[0])
+    ev.set()
+
+
+async def main():
+    global ev
+    ev = asyncio.Event()
+    server = await asyncio.start_server(handle_connection, "0.0.0.0", PORT)
+    multitest.next()
+    async with server:
+        await asyncio.wait_for(ev.wait(), 10)
+
+
+def instance0():
+    multitest.globals(IP=multitest.get_network_ip())
+    asyncio.run(main())
+
+
+def instance1():
+    if not hasattr(socket, "SO_LINGER"):
+        multitest.skip()
+    multitest.next()
+    s = socket.socket()
+    s.connect(socket.getaddrinfo(IP, PORT)[0][-1])
+    lgr_onoff = 1
+    lgr_linger = 0
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack("ii", lgr_onoff, lgr_linger))
+    s.send(b"GET / HTTP/1.0\r\n\r\n")
+    time.sleep(0.1)
+    s.close()  # This issues a TCP RST since we've set the linger option
diff --git a/tests/multi_net/uasyncio_tcp_client_rst.py.exp b/tests/multi_net/uasyncio_tcp_client_rst.py.exp
new file mode 100644
index 0000000000000..920d1bb8d7296
--- /dev/null
+++ b/tests/multi_net/uasyncio_tcp_client_rst.py.exp
@@ -0,0 +1,5 @@
+--- instance0 ---
+b'GET / HTTP'
+OSError 104
+--- instance1 ---
+
diff --git a/tests/multi_net/uasyncio_tcp_close_write.py b/tests/multi_net/uasyncio_tcp_close_write.py
new file mode 100644
index 0000000000000..5698ed8b1699d
--- /dev/null
+++ b/tests/multi_net/uasyncio_tcp_close_write.py
@@ -0,0 +1,69 @@
+# Test uasyncio TCP stream closing then writing
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+PORT = 8000
+
+
+async def handle_connection(reader, writer):
+    # Write data to ensure connection
+    writer.write(b"x")
+    await writer.drain()
+
+    # Read, should return nothing
+    print("read:", await reader.read(100))
+
+    # Close connection
+    print("close")
+    writer.close()
+    await writer.wait_closed()
+
+    print("done")
+    ev.set()
+
+
+async def tcp_server():
+    global ev
+    ev = asyncio.Event()
+    server = await asyncio.start_server(handle_connection, "0.0.0.0", PORT)
+    print("server running")
+    multitest.next()
+    async with server:
+        await asyncio.wait_for(ev.wait(), 5)
+
+
+async def tcp_client():
+    reader, writer = await asyncio.open_connection(IP, PORT)
+
+    # Read data to ensure connection
+    print("read:", await reader.read(1))
+
+    # Close connection
+    print("close")
+    writer.close()
+    await writer.wait_closed()
+
+    # Try writing data to the closed connection
+    print("write")
+    try:
+        writer.write(b"x")
+        await writer.drain()
+    except OSError:
+        print("OSError")
+
+
+def instance0():
+    multitest.globals(IP=multitest.get_network_ip())
+    asyncio.run(tcp_server())
+
+
+def instance1():
+    multitest.next()
+    asyncio.run(tcp_client())
diff --git a/tests/multi_net/uasyncio_tcp_close_write.py.exp b/tests/multi_net/uasyncio_tcp_close_write.py.exp
new file mode 100644
index 0000000000000..6c0f8d7eab24e
--- /dev/null
+++ b/tests/multi_net/uasyncio_tcp_close_write.py.exp
@@ -0,0 +1,10 @@
+--- instance0 ---
+server running
+read: b''
+close
+done
+--- instance1 ---
+read: b'x'
+close
+write
+OSError
diff --git a/tests/multi_net/uasyncio_tcp_server_client.py b/tests/multi_net/uasyncio_tcp_server_client.py
new file mode 100644
index 0000000000000..6a8cb58de53da
--- /dev/null
+++ b/tests/multi_net/uasyncio_tcp_server_client.py
@@ -0,0 +1,58 @@
+# Test uasyncio TCP server and client using start_server() and open_connection()
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+PORT = 8000
+
+
+async def handle_connection(reader, writer):
+    # Test that peername exists (but don't check its value, it changes)
+    writer.get_extra_info("peername")
+
+    data = await reader.read(100)
+    print("echo:", data)
+    writer.write(data)
+    await writer.drain()
+
+    print("close")
+    writer.close()
+    await writer.wait_closed()
+
+    print("done")
+    ev.set()
+
+
+async def tcp_server():
+    global ev
+    ev = asyncio.Event()
+    server = await asyncio.start_server(handle_connection, "0.0.0.0", PORT)
+    print("server running")
+    multitest.next()
+    async with server:
+        await asyncio.wait_for(ev.wait(), 10)
+
+
+async def tcp_client(message):
+    reader, writer = await asyncio.open_connection(IP, PORT)
+    print("write:", message)
+    writer.write(message)
+    await writer.drain()
+    data = await reader.read(100)
+    print("read:", data)
+
+
+def instance0():
+    multitest.globals(IP=multitest.get_network_ip())
+    asyncio.run(tcp_server())
+
+
+def instance1():
+    multitest.next()
+    asyncio.run(tcp_client(b"client data"))
diff --git a/tests/multi_net/uasyncio_tcp_server_client.py.exp b/tests/multi_net/uasyncio_tcp_server_client.py.exp
new file mode 100644
index 0000000000000..6dc6a9bbc7e52
--- /dev/null
+++ b/tests/multi_net/uasyncio_tcp_server_client.py.exp
@@ -0,0 +1,8 @@
+--- instance0 ---
+server running
+echo: b'client data'
+close
+done
+--- instance1 ---
+write: b'client data'
+read: b'client data'
diff --git a/tests/net_hosted/accept_nonblock.py b/tests/net_hosted/accept_nonblock.py
index 56f3288e28e68..941965e178cfb 100644
--- a/tests/net_hosted/accept_nonblock.py
+++ b/tests/net_hosted/accept_nonblock.py
@@ -6,11 +6,11 @@
     import socket
 
 s = socket.socket()
-s.bind(socket.getaddrinfo('127.0.0.1', 8123)[0][-1])
+s.bind(socket.getaddrinfo("127.0.0.1", 8123)[0][-1])
 s.setblocking(False)
 s.listen(1)
 try:
     s.accept()
 except OSError as er:
-    print(er.args[0] == 11) # 11 is EAGAIN
+    print(er.args[0] == 11)  # 11 is EAGAIN
 s.close()
diff --git a/tests/net_hosted/accept_timeout.py b/tests/net_hosted/accept_timeout.py
index 44b3b8c7cdbd0..ff989110ae1b6 100644
--- a/tests/net_hosted/accept_timeout.py
+++ b/tests/net_hosted/accept_timeout.py
@@ -8,15 +8,15 @@
 try:
     socket.socket.settimeout
 except AttributeError:
-    print('SKIP')
+    print("SKIP")
     raise SystemExit
 
 s = socket.socket()
-s.bind(socket.getaddrinfo('127.0.0.1', 8123)[0][-1])
+s.bind(socket.getaddrinfo("127.0.0.1", 8123)[0][-1])
 s.settimeout(1)
 s.listen(1)
 try:
     s.accept()
 except OSError as er:
-    print(er.args[0] in (110, 'timed out')) # 110 is ETIMEDOUT; CPython uses a string
+    print(er.args[0] in (110, "timed out"))  # 110 is ETIMEDOUT; CPython uses a string
 s.close()
diff --git a/tests/net_hosted/connect_nonblock.py b/tests/net_hosted/connect_nonblock.py
index 6479978bea67c..3a3eaa2ba01e4 100644
--- a/tests/net_hosted/connect_nonblock.py
+++ b/tests/net_hosted/connect_nonblock.py
@@ -12,9 +12,9 @@ def test(peer_addr):
     try:
         s.connect(peer_addr)
     except OSError as er:
-        print(er.args[0] == 115) # 115 is EINPROGRESS
+        print(er.args[0] == 115)  # 115 is EINPROGRESS
     s.close()
 
 
 if __name__ == "__main__":
-    test(socket.getaddrinfo('micropython.org', 80)[0][-1])
+    test(socket.getaddrinfo("micropython.org", 80)[0][-1])
diff --git a/tests/net_hosted/connect_poll.py b/tests/net_hosted/connect_poll.py
index ece6aa0da9721..b2739e36e9d89 100644
--- a/tests/net_hosted/connect_poll.py
+++ b/tests/net_hosted/connect_poll.py
@@ -12,9 +12,8 @@ def test(peer_addr):
     poller.register(s)
 
     # test poll before connect
-    # note: CPython can return POLLHUP, so use the IN|OUT mask
     p = poller.poll(0)
-    print(len(p), p[0][-1] & (select.POLLIN | select.POLLOUT))
+    print(len(p), p[0][-1])
 
     s.connect(peer_addr)
 
@@ -29,4 +28,4 @@ def test(peer_addr):
 
 
 if __name__ == "__main__":
-    test(socket.getaddrinfo('micropython.org', 80)[0][-1])
+    test(socket.getaddrinfo("micropython.org", 80)[0][-1])
diff --git a/tests/net_hosted/connect_poll.py.exp b/tests/net_hosted/connect_poll.py.exp
index cdf520e090bb7..d18a39a12a813 100644
--- a/tests/net_hosted/connect_poll.py.exp
+++ b/tests/net_hosted/connect_poll.py.exp
@@ -1,3 +1,3 @@
-1 4
+1 20
 1
 1 4
diff --git a/tests/net_hosted/ssl_getpeercert.py b/tests/net_hosted/ssl_getpeercert.py
index e265c830d0d92..dee5fcfd8997e 100644
--- a/tests/net_hosted/ssl_getpeercert.py
+++ b/tests/net_hosted/ssl_getpeercert.py
@@ -18,4 +18,4 @@ def test(peer_addr):
 
 
 if __name__ == "__main__":
-    test(socket.getaddrinfo('micropython.org', 443)[0][-1])
+    test(socket.getaddrinfo("micropython.org", 443)[0][-1])
diff --git a/tests/net_inet/getaddrinfo.py b/tests/net_inet/getaddrinfo.py
new file mode 100644
index 0000000000000..765723ae73f87
--- /dev/null
+++ b/tests/net_inet/getaddrinfo.py
@@ -0,0 +1,52 @@
+try:
+    import usocket as socket, sys
+except:
+    import socket, sys
+
+
+def test_non_existent():
+    try:
+        res = socket.getaddrinfo("nonexistent.example.com", 80)
+        print("getaddrinfo returned", res)
+    except OSError as e:
+        print("getaddrinfo raised")
+
+
+def test_bogus():
+    try:
+        res = socket.getaddrinfo("hey.!!$$", 80)
+        print("getaddrinfo returned", res)
+    except OSError as e:
+        print("getaddrinfo raised")
+    except Exception as e:
+        print("getaddrinfo raised")  # CPython raises UnicodeError!?
+
+
+def test_ip_addr():
+    try:
+        res = socket.getaddrinfo("10.10.10.10", 80)
+        print("getaddrinfo returned resolutions")
+    except Exception as e:
+        print("getaddrinfo raised", e)
+
+
+def test_0_0_0_0():
+    try:
+        res = socket.getaddrinfo("0.0.0.0", 80)
+        print("getaddrinfo returned resolutions")
+    except Exception as e:
+        print("getaddrinfo raised", e)
+
+
+def test_valid():
+    try:
+        res = socket.getaddrinfo("micropython.org", 80)
+        print("getaddrinfo returned resolutions")
+    except Exception as e:
+        print("getaddrinfo raised", e)
+
+
+test_funs = [n for n in dir() if n.startswith("test_")]
+for f in sorted(test_funs):
+    print("--", f, end=": ")
+    eval(f + "()")
diff --git a/tests/net_inet/test_tls_sites.py b/tests/net_inet/test_tls_sites.py
index bf8071d0878a7..876343acfc1d3 100644
--- a/tests/net_inet/test_tls_sites.py
+++ b/tests/net_inet/test_tls_sites.py
@@ -6,6 +6,7 @@
     import ussl as ssl
 except:
     import ssl
+
     # CPython only supports server_hostname with SSLContext
     ssl = ssl.SSLContext()
 
@@ -24,9 +25,9 @@ def test_one(site, opts):
         else:
             s = ssl.wrap_socket(s)
 
-        s.write(b"GET / HTTP/1.0\r\nHost: %s\r\n\r\n" % bytes(site, 'latin'))
+        s.write(b"GET / HTTP/1.0\r\nHost: %s\r\n\r\n" % bytes(site, "latin"))
         resp = s.read(4096)
-#        print(resp)
+        # print(resp)
 
     finally:
         s.close()
@@ -37,7 +38,7 @@ def test_one(site, opts):
     "www.google.com",
     "api.telegram.org",
     {"host": "api.pushbullet.com", "sni": True},
-#    "w9rybpfril.execute-api.ap-southeast-2.amazonaws.com",
+    # "w9rybpfril.execute-api.ap-southeast-2.amazonaws.com",
     {"host": "w9rybpfril.execute-api.ap-southeast-2.amazonaws.com", "sni": True},
 ]
 
diff --git a/tests/net_inet/uasyncio_cancel_stream.py b/tests/net_inet/uasyncio_cancel_stream.py
new file mode 100644
index 0000000000000..6b6b845b0f7a8
--- /dev/null
+++ b/tests/net_inet/uasyncio_cancel_stream.py
@@ -0,0 +1,35 @@
+# Test cancelling a task waiting on stream IO
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def get(reader):
+    print("start")
+    try:
+        await reader.read(10)
+        print("fail")
+    except asyncio.CancelledError:
+        print("cancelled")
+
+
+async def main(url):
+    reader, writer = await asyncio.open_connection(url, 80)
+    task = asyncio.create_task(get(reader))
+    await asyncio.sleep(0)
+    print("cancelling")
+    task.cancel()
+    print("waiting")
+    await task
+    print("done")
+    writer.close()
+    await writer.wait_closed()
+
+
+asyncio.run(main("micropython.org"))
diff --git a/tests/net_inet/uasyncio_cancel_stream.py.exp b/tests/net_inet/uasyncio_cancel_stream.py.exp
new file mode 100644
index 0000000000000..e3fcfa7b3f588
--- /dev/null
+++ b/tests/net_inet/uasyncio_cancel_stream.py.exp
@@ -0,0 +1,5 @@
+start
+cancelling
+waiting
+cancelled
+done
diff --git a/tests/net_inet/uasyncio_open_connection.py b/tests/net_inet/uasyncio_open_connection.py
new file mode 100644
index 0000000000000..68285a2437d64
--- /dev/null
+++ b/tests/net_inet/uasyncio_open_connection.py
@@ -0,0 +1,30 @@
+# Test simple HTTP request with uasyncio.open_connection()
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def http_get(url):
+    reader, writer = await asyncio.open_connection(url, 80)
+
+    print("write GET")
+    writer.write(b"GET / HTTP/1.0\r\n\r\n")
+    await writer.drain()
+
+    print("read response")
+    data = await reader.read(100)
+    print("read:", data.split(b"\r\n")[0])
+
+    print("close")
+    writer.close()
+    await writer.wait_closed()
+    print("done")
+
+
+asyncio.run(http_get("micropython.org"))
diff --git a/tests/net_inet/uasyncio_open_connection.py.exp b/tests/net_inet/uasyncio_open_connection.py.exp
new file mode 100644
index 0000000000000..c8dea365b5d53
--- /dev/null
+++ b/tests/net_inet/uasyncio_open_connection.py.exp
@@ -0,0 +1,5 @@
+write GET
+read response
+read: b'HTTP/1.1 200 OK'
+close
+done
diff --git a/tests/net_inet/uasyncio_tcp_read_headers.py b/tests/net_inet/uasyncio_tcp_read_headers.py
new file mode 100644
index 0000000000000..e8087aeedf7be
--- /dev/null
+++ b/tests/net_inet/uasyncio_tcp_read_headers.py
@@ -0,0 +1,38 @@
+# Test uasyncio.open_connection() and stream readline()
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    try:
+        import asyncio
+    except ImportError:
+        print("SKIP")
+        raise SystemExit
+
+
+async def http_get_headers(url):
+    reader, writer = await asyncio.open_connection(url, 80)
+
+    print("write GET")
+    writer.write(b"GET / HTTP/1.0\r\n\r\n")
+    await writer.drain()
+
+    while True:
+        line = await reader.readline()
+        line = line.strip()
+        if not line:
+            break
+        if (
+            line.find(b"Date") == -1
+            and line.find(b"Modified") == -1
+            and line.find(b"Server") == -1
+        ):
+            print(line)
+
+    print("close")
+    writer.close()
+    await writer.wait_closed()
+    print("done")
+
+
+asyncio.run(http_get_headers("micropython.org"))
diff --git a/tests/net_inet/uasyncio_tcp_read_headers.py.exp b/tests/net_inet/uasyncio_tcp_read_headers.py.exp
new file mode 100644
index 0000000000000..c200238dc6b83
--- /dev/null
+++ b/tests/net_inet/uasyncio_tcp_read_headers.py.exp
@@ -0,0 +1,10 @@
+write GET
+b'HTTP/1.1 200 OK'
+b'Content-Type: text/html'
+b'Content-Length: 54'
+b'Connection: close'
+b'Vary: Accept-Encoding'
+b'ETag: "54306c85-36"'
+b'Accept-Ranges: bytes'
+close
+done
diff --git a/tests/perf_bench/benchrun.py b/tests/perf_bench/benchrun.py
new file mode 100644
index 0000000000000..90c303dd29cb6
--- /dev/null
+++ b/tests/perf_bench/benchrun.py
@@ -0,0 +1,27 @@
+def bm_run(N, M):
+    try:
+        from utime import ticks_us, ticks_diff
+    except ImportError:
+        import time
+
+        ticks_us = lambda: int(time.perf_counter() * 1000000)
+        ticks_diff = lambda a, b: a - b
+
+    # Pick sensible parameters given N, M
+    cur_nm = (0, 0)
+    param = None
+    for nm, p in bm_params.items():
+        if 10 * nm[0] <= 12 * N and nm[1] <= M and nm > cur_nm:
+            cur_nm = nm
+            param = p
+    if param is None:
+        print(-1, -1, "no matching params")
+        return
+
+    # Run and time benchmark
+    run, result = bm_setup(param)
+    t0 = ticks_us()
+    run()
+    t1 = ticks_us()
+    norm, out = result()
+    print(ticks_diff(t1, t0), norm, out)
diff --git a/tests/perf_bench/bm_chaos.py b/tests/perf_bench/bm_chaos.py
new file mode 100644
index 0000000000000..55d282561f56c
--- /dev/null
+++ b/tests/perf_bench/bm_chaos.py
@@ -0,0 +1,281 @@
+# Source: https://github.com/python/pyperformance
+# License: MIT
+
+# create chaosgame-like fractals
+# Copyright (C) 2005 Carl Friedrich Bolz
+
+import math
+import random
+
+
+class GVector(object):
+    def __init__(self, x=0, y=0, z=0):
+        self.x = x
+        self.y = y
+        self.z = z
+
+    def Mag(self):
+        return math.sqrt(self.x ** 2 + self.y ** 2 + self.z ** 2)
+
+    def dist(self, other):
+        return math.sqrt(
+            (self.x - other.x) ** 2 + (self.y - other.y) ** 2 + (self.z - other.z) ** 2
+        )
+
+    def __add__(self, other):
+        if not isinstance(other, GVector):
+            raise ValueError("Can't add GVector to " + str(type(other)))
+        v = GVector(self.x + other.x, self.y + other.y, self.z + other.z)
+        return v
+
+    def __sub__(self, other):
+        return self + other * -1
+
+    def __mul__(self, other):
+        v = GVector(self.x * other, self.y * other, self.z * other)
+        return v
+
+    __rmul__ = __mul__
+
+    def linear_combination(self, other, l1, l2=None):
+        if l2 is None:
+            l2 = 1 - l1
+        v = GVector(
+            self.x * l1 + other.x * l2, self.y * l1 + other.y * l2, self.z * l1 + other.z * l2
+        )
+        return v
+
+    def __str__(self):
+        return "<%f, %f, %f>" % (self.x, self.y, self.z)
+
+    def __repr__(self):
+        return "GVector(%f, %f, %f)" % (self.x, self.y, self.z)
+
+
+class Spline(object):
+    """Class for representing B-Splines and NURBS of arbitrary degree"""
+
+    def __init__(self, points, degree, knots):
+        """Creates a Spline.
+
+        points is a list of GVector, degree is the degree of the Spline.
+        """
+        if len(points) > len(knots) - degree + 1:
+            raise ValueError("too many control points")
+        elif len(points) < len(knots) - degree + 1:
+            raise ValueError("not enough control points")
+        last = knots[0]
+        for cur in knots[1:]:
+            if cur < last:
+                raise ValueError("knots not strictly increasing")
+            last = cur
+        self.knots = knots
+        self.points = points
+        self.degree = degree
+
+    def GetDomain(self):
+        """Returns the domain of the B-Spline"""
+        return (self.knots[self.degree - 1], self.knots[len(self.knots) - self.degree])
+
+    def __call__(self, u):
+        """Calculates a point of the B-Spline using de Boors Algorithm"""
+        dom = self.GetDomain()
+        if u < dom[0] or u > dom[1]:
+            raise ValueError("Function value not in domain")
+        if u == dom[0]:
+            return self.points[0]
+        if u == dom[1]:
+            return self.points[-1]
+        I = self.GetIndex(u)
+        d = [self.points[I - self.degree + 1 + ii] for ii in range(self.degree + 1)]
+        U = self.knots
+        for ik in range(1, self.degree + 1):
+            for ii in range(I - self.degree + ik + 1, I + 2):
+                ua = U[ii + self.degree - ik]
+                ub = U[ii - 1]
+                co1 = (ua - u) / (ua - ub)
+                co2 = (u - ub) / (ua - ub)
+                index = ii - I + self.degree - ik - 1
+                d[index] = d[index].linear_combination(d[index + 1], co1, co2)
+        return d[0]
+
+    def GetIndex(self, u):
+        dom = self.GetDomain()
+        for ii in range(self.degree - 1, len(self.knots) - self.degree):
+            if u >= self.knots[ii] and u < self.knots[ii + 1]:
+                I = ii
+                break
+        else:
+            I = dom[1] - 1
+        return I
+
+    def __len__(self):
+        return len(self.points)
+
+    def __repr__(self):
+        return "Spline(%r, %r, %r)" % (self.points, self.degree, self.knots)
+
+
+def write_ppm(im, w, h, filename):
+    with open(filename, "wb") as f:
+        f.write(b"P6\n%i %i\n255\n" % (w, h))
+        for j in range(h):
+            for i in range(w):
+                val = im[j * w + i]
+                c = val * 255
+                f.write(b"%c%c%c" % (c, c, c))
+
+
+class Chaosgame(object):
+    def __init__(self, splines, thickness, subdivs):
+        self.splines = splines
+        self.thickness = thickness
+        self.minx = min([p.x for spl in splines for p in spl.points])
+        self.miny = min([p.y for spl in splines for p in spl.points])
+        self.maxx = max([p.x for spl in splines for p in spl.points])
+        self.maxy = max([p.y for spl in splines for p in spl.points])
+        self.height = self.maxy - self.miny
+        self.width = self.maxx - self.minx
+        self.num_trafos = []
+        maxlength = thickness * self.width / self.height
+        for spl in splines:
+            length = 0
+            curr = spl(0)
+            for i in range(1, subdivs + 1):
+                last = curr
+                t = 1 / subdivs * i
+                curr = spl(t)
+                length += curr.dist(last)
+            self.num_trafos.append(max(1, int(length / maxlength * 1.5)))
+        self.num_total = sum(self.num_trafos)
+
+    def get_random_trafo(self):
+        r = random.randrange(int(self.num_total) + 1)
+        l = 0
+        for i in range(len(self.num_trafos)):
+            if r >= l and r < l + self.num_trafos[i]:
+                return i, random.randrange(self.num_trafos[i])
+            l += self.num_trafos[i]
+        return len(self.num_trafos) - 1, random.randrange(self.num_trafos[-1])
+
+    def transform_point(self, point, trafo=None):
+        x = (point.x - self.minx) / self.width
+        y = (point.y - self.miny) / self.height
+        if trafo is None:
+            trafo = self.get_random_trafo()
+        start, end = self.splines[trafo[0]].GetDomain()
+        length = end - start
+        seg_length = length / self.num_trafos[trafo[0]]
+        t = start + seg_length * trafo[1] + seg_length * x
+        basepoint = self.splines[trafo[0]](t)
+        if t + 1 / 50000 > end:
+            neighbour = self.splines[trafo[0]](t - 1 / 50000)
+            derivative = neighbour - basepoint
+        else:
+            neighbour = self.splines[trafo[0]](t + 1 / 50000)
+            derivative = basepoint - neighbour
+        if derivative.Mag() != 0:
+            basepoint.x += derivative.y / derivative.Mag() * (y - 0.5) * self.thickness
+            basepoint.y += -derivative.x / derivative.Mag() * (y - 0.5) * self.thickness
+        else:
+            # can happen, especially with single precision float
+            pass
+        self.truncate(basepoint)
+        return basepoint
+
+    def truncate(self, point):
+        if point.x >= self.maxx:
+            point.x = self.maxx
+        if point.y >= self.maxy:
+            point.y = self.maxy
+        if point.x < self.minx:
+            point.x = self.minx
+        if point.y < self.miny:
+            point.y = self.miny
+
+    def create_image_chaos(self, w, h, iterations, rng_seed):
+        # Always use the same sequence of random numbers
+        # to get reproductible benchmark
+        random.seed(rng_seed)
+
+        im = bytearray(w * h)
+        point = GVector((self.maxx + self.minx) / 2, (self.maxy + self.miny) / 2, 0)
+        for _ in range(iterations):
+            point = self.transform_point(point)
+            x = (point.x - self.minx) / self.width * w
+            y = (point.y - self.miny) / self.height * h
+            x = int(x)
+            y = int(y)
+            if x == w:
+                x -= 1
+            if y == h:
+                y -= 1
+            im[(h - y - 1) * w + x] = 1
+
+        return im
+
+
+###########################################################################
+# Benchmark interface
+
+bm_params = {
+    (100, 50): (0.25, 100, 50, 50, 50, 1234),
+    (1000, 1000): (0.25, 200, 400, 400, 1000, 1234),
+    (5000, 1000): (0.25, 400, 500, 500, 7000, 1234),
+}
+
+
+def bm_setup(params):
+    splines = [
+        Spline(
+            [
+                GVector(1.597, 3.304, 0.0),
+                GVector(1.576, 4.123, 0.0),
+                GVector(1.313, 5.288, 0.0),
+                GVector(1.619, 5.330, 0.0),
+                GVector(2.890, 5.503, 0.0),
+                GVector(2.373, 4.382, 0.0),
+                GVector(1.662, 4.360, 0.0),
+            ],
+            3,
+            [0, 0, 0, 1, 1, 1, 2, 2, 2],
+        ),
+        Spline(
+            [
+                GVector(2.805, 4.017, 0.0),
+                GVector(2.551, 3.525, 0.0),
+                GVector(1.979, 2.620, 0.0),
+                GVector(1.979, 2.620, 0.0),
+            ],
+            3,
+            [0, 0, 0, 1, 1, 1],
+        ),
+        Spline(
+            [
+                GVector(2.002, 4.011, 0.0),
+                GVector(2.335, 3.313, 0.0),
+                GVector(2.367, 3.233, 0.0),
+                GVector(2.367, 3.233, 0.0),
+            ],
+            3,
+            [0, 0, 0, 1, 1, 1],
+        ),
+    ]
+
+    chaos = Chaosgame(splines, params[0], params[1])
+    image = None
+
+    def run():
+        nonlocal image
+        _, _, width, height, iter, rng_seed = params
+        image = chaos.create_image_chaos(width, height, iter, rng_seed)
+
+    def result():
+        norm = params[4]
+        # Images are not the same when floating point behaviour is different,
+        # so return percentage of pixels that are set (rounded to int).
+        # write_ppm(image, params[2], params[3], 'out-.ppm')
+        pix = int(100 * sum(image) / len(image))
+        return norm, pix
+
+    return run, result
diff --git a/tests/perf_bench/bm_fannkuch.py b/tests/perf_bench/bm_fannkuch.py
new file mode 100644
index 0000000000000..9f7ae797f0bc1
--- /dev/null
+++ b/tests/perf_bench/bm_fannkuch.py
@@ -0,0 +1,72 @@
+# Source: https://github.com/python/pyperformance
+# License: MIT
+
+# The Computer Language Benchmarks Game
+# http://benchmarksgame.alioth.debian.org/
+# Contributed by Sokolov Yura, modified by Tupteq.
+
+
+def fannkuch(n):
+    count = list(range(1, n + 1))
+    max_flips = 0
+    m = n - 1
+    r = n
+    check = 0
+    perm1 = list(range(n))
+    perm = list(range(n))
+    perm1_ins = perm1.insert
+    perm1_pop = perm1.pop
+
+    while 1:
+        if check < 30:
+            check += 1
+
+        while r != 1:
+            count[r - 1] = r
+            r -= 1
+
+        if perm1[0] != 0 and perm1[m] != m:
+            perm = perm1[:]
+            flips_count = 0
+            k = perm[0]
+            while k:
+                perm[: k + 1] = perm[k::-1]
+                flips_count += 1
+                k = perm[0]
+
+            if flips_count > max_flips:
+                max_flips = flips_count
+
+        while r != n:
+            perm1_ins(r, perm1_pop(0))
+            count[r] -= 1
+            if count[r] > 0:
+                break
+            r += 1
+        else:
+            return max_flips
+
+
+###########################################################################
+# Benchmark interface
+
+bm_params = {
+    (50, 10): (5,),
+    (100, 10): (6,),
+    (500, 10): (7,),
+    (1000, 10): (8,),
+    (5000, 10): (9,),
+}
+
+
+def bm_setup(params):
+    state = None
+
+    def run():
+        nonlocal state
+        state = fannkuch(params[0])
+
+    def result():
+        return params[0], state
+
+    return run, result
diff --git a/tests/perf_bench/bm_fft.py b/tests/perf_bench/bm_fft.py
new file mode 100644
index 0000000000000..fb79a9fd28b65
--- /dev/null
+++ b/tests/perf_bench/bm_fft.py
@@ -0,0 +1,72 @@
+# Copyright (c) 2019 Project Nayuki. (MIT License)
+# https://www.nayuki.io/page/free-small-fft-in-multiple-languages
+
+import math, cmath
+
+
+def transform_radix2(vector, inverse):
+    # Returns the integer whose value is the reverse of the lowest 'bits' bits of the integer 'x'.
+    def reverse(x, bits):
+        y = 0
+        for i in range(bits):
+            y = (y << 1) | (x & 1)
+            x >>= 1
+        return y
+
+    # Initialization
+    n = len(vector)
+    levels = int(math.log2(n))
+    coef = (2 if inverse else -2) * cmath.pi / n
+    exptable = [cmath.rect(1, i * coef) for i in range(n // 2)]
+    vector = [vector[reverse(i, levels)] for i in range(n)]  # Copy with bit-reversed permutation
+
+    # Radix-2 decimation-in-time FFT
+    size = 2
+    while size <= n:
+        halfsize = size // 2
+        tablestep = n // size
+        for i in range(0, n, size):
+            k = 0
+            for j in range(i, i + halfsize):
+                temp = vector[j + halfsize] * exptable[k]
+                vector[j + halfsize] = vector[j] - temp
+                vector[j] += temp
+                k += tablestep
+        size *= 2
+    return vector
+
+
+###########################################################################
+# Benchmark interface
+
+bm_params = {
+    (50, 25): (2, 128),
+    (100, 100): (3, 256),
+    (1000, 1000): (20, 512),
+    (5000, 1000): (100, 512),
+}
+
+
+def bm_setup(params):
+    state = None
+    signal = [math.cos(2 * math.pi * i / params[1]) + 0j for i in range(params[1])]
+    fft = None
+    fft_inv = None
+
+    def run():
+        nonlocal fft, fft_inv
+        for _ in range(params[0]):
+            fft = transform_radix2(signal, False)
+            fft_inv = transform_radix2(fft, True)
+
+    def result():
+        nonlocal fft, fft_inv
+        fft[1] -= 0.5 * params[1]
+        fft[-1] -= 0.5 * params[1]
+        fft_ok = all(abs(f) < 1e-3 for f in fft)
+        for i in range(len(fft_inv)):
+            fft_inv[i] -= params[1] * signal[i]
+        fft_inv_ok = all(abs(f) < 1e-3 for f in fft_inv)
+        return params[0] * params[1], (fft_ok, fft_inv_ok)
+
+    return run, result
diff --git a/tests/perf_bench/bm_float.py b/tests/perf_bench/bm_float.py
new file mode 100644
index 0000000000000..9e55deaee53cf
--- /dev/null
+++ b/tests/perf_bench/bm_float.py
@@ -0,0 +1,74 @@
+# Source: https://github.com/python/pyperformance
+# License: MIT
+
+# Artificial, floating point-heavy benchmark originally used by Factor.
+
+from math import sin, cos, sqrt
+
+
+class Point(object):
+    __slots__ = ("x", "y", "z")
+
+    def __init__(self, i):
+        self.x = x = sin(i)
+        self.y = cos(i) * 3
+        self.z = (x * x) / 2
+
+    def __repr__(self):
+        return "<Point: x=%s, y=%s, z=%s>" % (self.x, self.y, self.z)
+
+    def normalize(self):
+        x = self.x
+        y = self.y
+        z = self.z
+        norm = sqrt(x * x + y * y + z * z)
+        self.x /= norm
+        self.y /= norm
+        self.z /= norm
+
+    def maximize(self, other):
+        self.x = self.x if self.x > other.x else other.x
+        self.y = self.y if self.y > other.y else other.y
+        self.z = self.z if self.z > other.z else other.z
+        return self
+
+
+def maximize(points):
+    next = points[0]
+    for p in points[1:]:
+        next = next.maximize(p)
+    return next
+
+
+def benchmark(n):
+    points = [None] * n
+    for i in range(n):
+        points[i] = Point(i)
+    for p in points:
+        p.normalize()
+    return maximize(points)
+
+
+###########################################################################
+# Benchmark interface
+
+bm_params = {
+    (50, 25): (1, 150),
+    (100, 100): (1, 250),
+    (1000, 1000): (10, 1500),
+    (5000, 1000): (20, 3000),
+}
+
+
+def bm_setup(params):
+    state = None
+
+    def run():
+        nonlocal state
+        for _ in range(params[0]):
+            state = benchmark(params[1])
+
+    def result():
+        return params[0] * params[1], "Point(%.4f, %.4f, %.4f)" % (state.x, state.y, state.z)
+
+    return run, result
diff --git a/tests/perf_bench/bm_hexiom.py b/tests/perf_bench/bm_hexiom.py
new file mode 100644
index 0000000000000..84eda9a90966e
--- /dev/null
+++ b/tests/perf_bench/bm_hexiom.py
@@ -0,0 +1,660 @@
+# Source: https://github.com/python/pyperformance
+# License: MIT
+
+# Solver of Hexiom board game.
+# Benchmark from Laurent Vaucher.
+# Source: https://github.com/slowfrog/hexiom : hexiom2.py, level36.txt
+# (Main function tweaked by Armin Rigo.)
+
+
+##################################
+class Dir(object):
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+
+DIRS = [Dir(1, 0), Dir(-1, 0), Dir(0, 1), Dir(0, -1), Dir(1, 1), Dir(-1, -1)]
+
+EMPTY = 7
+
+##################################
+
+
+class Done(object):
+    MIN_CHOICE_STRATEGY = 0
+    MAX_CHOICE_STRATEGY = 1
+    HIGHEST_VALUE_STRATEGY = 2
+    FIRST_STRATEGY = 3
+    MAX_NEIGHBORS_STRATEGY = 4
+    MIN_NEIGHBORS_STRATEGY = 5
+
+    def __init__(self, count, empty=False):
+        self.count = count
+        self.cells = None if empty else [[0, 1, 2, 3, 4, 5, 6, EMPTY] for i in range(count)]
+
+    def clone(self):
+        ret = Done(self.count, True)
+        ret.cells = [self.cells[i][:] for i in range(self.count)]
+        return ret
+
+    def __getitem__(self, i):
+        return self.cells[i]
+
+    def set_done(self, i, v):
+        self.cells[i] = [v]
+
+    def already_done(self, i):
+        return len(self.cells[i]) == 1
+
+    def remove(self, i, v):
+        if v in self.cells[i]:
+            self.cells[i].remove(v)
+            return True
+        else:
+            return False
+
+    def remove_all(self, v):
+        for i in range(self.count):
+            self.remove(i, v)
+
+    def remove_unfixed(self, v):
+        changed = False
+        for i in range(self.count):
+            if not self.already_done(i):
+                if self.remove(i, v):
+                    changed = True
+        return changed
+
+    def filter_tiles(self, tiles):
+        for v in range(8):
+            if tiles[v] == 0:
+                self.remove_all(v)
+
+    def next_cell_min_choice(self):
+        minlen = 10
+        mini = -1
+        for i in range(self.count):
+            if 1 < len(self.cells[i]) < minlen:
+                minlen = len(self.cells[i])
+                mini = i
+        return mini
+
+    def next_cell_max_choice(self):
+        maxlen = 1
+        maxi = -1
+        for i in range(self.count):
+            if maxlen < len(self.cells[i]):
+                maxlen = len(self.cells[i])
+                maxi = i
+        return maxi
+
+    def next_cell_highest_value(self):
+        maxval = -1
+        maxi = -1
+        for i in range(self.count):
+            if not self.already_done(i):
+                maxvali = max(k for k in self.cells[i] if k != EMPTY)
+                if maxval < maxvali:
+                    maxval = maxvali
+                    maxi = i
+        return maxi
+
+    def next_cell_first(self):
+        for i in range(self.count):
+            if not self.already_done(i):
+                return i
+        return -1
+
+    def next_cell_max_neighbors(self, pos):
+        maxn = -1
+        maxi = -1
+        for i in range(self.count):
+            if not self.already_done(i):
+                cells_around = pos.hex.get_by_id(i).links
+                n = sum(
+                    1 if (self.already_done(nid) and (self[nid][0] != EMPTY)) else 0
+                    for nid in cells_around
+                )
+                if n > maxn:
+                    maxn = n
+                    maxi = i
+        return maxi
+
+    def next_cell_min_neighbors(self, pos):
+        minn = 7
+        mini = -1
+        for i in range(self.count):
+            if not self.already_done(i):
+                cells_around = pos.hex.get_by_id(i).links
+                n = sum(
+                    1 if (self.already_done(nid) and (self[nid][0] != EMPTY)) else 0
+                    for nid in cells_around
+                )
+                if n < minn:
+                    minn = n
+                    mini = i
+        return mini
+
+    def next_cell(self, pos, strategy=HIGHEST_VALUE_STRATEGY):
+        if strategy == Done.HIGHEST_VALUE_STRATEGY:
+            return self.next_cell_highest_value()
+        elif strategy == Done.MIN_CHOICE_STRATEGY:
+            return self.next_cell_min_choice()
+        elif strategy == Done.MAX_CHOICE_STRATEGY:
+            return self.next_cell_max_choice()
+        elif strategy == Done.FIRST_STRATEGY:
+            return self.next_cell_first()
+        elif strategy == Done.MAX_NEIGHBORS_STRATEGY:
+            return self.next_cell_max_neighbors(pos)
+        elif strategy == Done.MIN_NEIGHBORS_STRATEGY:
+            return self.next_cell_min_neighbors(pos)
+        else:
+            raise Exception("Wrong strategy: %d" % strategy)
+
+
+##################################
+
+
+class Node(object):
+    def __init__(self, pos, id, links):
+        self.pos = pos
+        self.id = id
+        self.links = links
+
+
+##################################
+
+
+class Hex(object):
+    def __init__(self, size):
+        self.size = size
+        self.count = 3 * size * (size - 1) + 1
+        self.nodes_by_id = self.count * [None]
+        self.nodes_by_pos = {}
+        id = 0
+        for y in range(size):
+            for x in range(size + y):
+                pos = (x, y)
+                node = Node(pos, id, [])
+                self.nodes_by_pos[pos] = node
+                self.nodes_by_id[node.id] = node
+                id += 1
+        for y in range(1, size):
+            for x in range(y, size * 2 - 1):
+                ry = size + y - 1
+                pos = (x, ry)
+                node = Node(pos, id, [])
+                self.nodes_by_pos[pos] = node
+                self.nodes_by_id[node.id] = node
+                id += 1
+
+    def link_nodes(self):
+        for node in self.nodes_by_id:
+            (x, y) = node.pos
+            for dir in DIRS:
+                nx = x + dir.x
+                ny = y + dir.y
+                if self.contains_pos((nx, ny)):
+                    node.links.append(self.nodes_by_pos[(nx, ny)].id)
+
+    def contains_pos(self, pos):
+        return pos in self.nodes_by_pos
+
+    def get_by_pos(self, pos):
+        return self.nodes_by_pos[pos]
+
+    def get_by_id(self, id):
+        return self.nodes_by_id[id]
+
+
+##################################
+class Pos(object):
+    def __init__(self, hex, tiles, done=None):
+        self.hex = hex
+        self.tiles = tiles
+        self.done = Done(hex.count) if done is None else done
+
+    def clone(self):
+        return Pos(self.hex, self.tiles, self.done.clone())
+
+
+##################################
+
+
+def constraint_pass(pos, last_move=None):
+    changed = False
+    left = pos.tiles[:]
+    done = pos.done
+
+    # Remove impossible values from free cells
+    free_cells = range(done.count) if last_move is None else pos.hex.get_by_id(last_move).links
+    for i in free_cells:
+        if not done.already_done(i):
+            vmax = 0
+            vmin = 0
+            cells_around = pos.hex.get_by_id(i).links
+            for nid in cells_around:
+                if done.already_done(nid):
+                    if done[nid][0] != EMPTY:
+                        vmin += 1
+                        vmax += 1
+                else:
+                    vmax += 1
+
+            for num in range(7):
+                if (num < vmin) or (num > vmax):
+                    if done.remove(i, num):
+                        changed = True
+
+    # Computes how many of each value is still free
+    for cell in done.cells:
+        if len(cell) == 1:
+            left[cell[0]] -= 1
+
+    for v in range(8):
+        # If there is none, remove the possibility from all tiles
+        if (pos.tiles[v] > 0) and (left[v] == 0):
+            if done.remove_unfixed(v):
+                changed = True
+        else:
+            possible = sum((1 if v in cell else 0) for cell in done.cells)
+            # If the number of possible cells for a value is exactly the number of available tiles
+            # put a tile in each cell
+            if pos.tiles[v] == possible:
+                for i in range(done.count):
+                    cell = done.cells[i]
+                    if (not done.already_done(i)) and (v in cell):
+                        done.set_done(i, v)
+                        changed = True
+
+    # Force empty or non-empty around filled cells
+    filled_cells = range(done.count) if last_move is None else [last_move]
+    for i in filled_cells:
+        if done.already_done(i):
+            num = done[i][0]
+            empties = 0
+            filled = 0
+            unknown = []
+            cells_around = pos.hex.get_by_id(i).links
+            for nid in cells_around:
+                if done.already_done(nid):
+                    if done[nid][0] == EMPTY:
+                        empties += 1
+                    else:
+                        filled += 1
+                else:
+                    unknown.append(nid)
+            if len(unknown) > 0:
+                if num == filled:
+                    for u in unknown:
+                        if EMPTY in done[u]:
+                            done.set_done(u, EMPTY)
+                            changed = True
+                        # else:
+                        #    raise Exception("Houston, we've got a problem")
+                elif num == filled + len(unknown):
+                    for u in unknown:
+                        if done.remove(u, EMPTY):
+                            changed = True
+
+    return changed
+
+
+ASCENDING = 1
+DESCENDING = -1
+
+
+def find_moves(pos, strategy, order):
+    done = pos.done
+    cell_id = done.next_cell(pos, strategy)
+    if cell_id < 0:
+        return []
+
+    if order == ASCENDING:
+        return [(cell_id, v) for v in done[cell_id]]
+    else:
+        # Try higher values first and EMPTY last
+        moves = list(reversed([(cell_id, v) for v in done[cell_id] if v != EMPTY]))
+        if EMPTY in done[cell_id]:
+            moves.append((cell_id, EMPTY))
+        return moves
+
+
+def play_move(pos, move):
+    (cell_id, i) = move
+    pos.done.set_done(cell_id, i)
+
+
+def print_pos(pos, output):
+    hex = pos.hex
+    done = pos.done
+    size = hex.size
+    for y in range(size):
+        print(" " * (size - y - 1), end="", file=output)
+        for x in range(size + y):
+            pos2 = (x, y)
+            id = hex.get_by_pos(pos2).id
+            if done.already_done(id):
+                c = done[id][0] if done[id][0] != EMPTY else "."
+            else:
+                c = "?"
+            print("%s " % c, end="", file=output)
+        print(end="\n", file=output)
+    for y in range(1, size):
+        print(" " * y, end="", file=output)
+        for x in range(y, size * 2 - 1):
+            ry = size + y - 1
+            pos2 = (x, ry)
+            id = hex.get_by_pos(pos2).id
+            if done.already_done(id):
+                c = done[id][0] if done[id][0] != EMPTY else "."
+            else:
+                c = "?"
+            print("%s " % c, end="", file=output)
+        print(end="\n", file=output)
+
+
+OPEN = 0
+SOLVED = 1
+IMPOSSIBLE = -1
+
+
+def solved(pos, output, verbose=False):
+    hex = pos.hex
+    tiles = pos.tiles[:]
+    done = pos.done
+    exact = True
+    all_done = True
+    for i in range(hex.count):
+        if len(done[i]) == 0:
+            return IMPOSSIBLE
+        elif done.already_done(i):
+            num = done[i][0]
+            tiles[num] -= 1
+            if tiles[num] < 0:
+                return IMPOSSIBLE
+            vmax = 0
+            vmin = 0
+            if num != EMPTY:
+                cells_around = hex.get_by_id(i).links
+                for nid in cells_around:
+                    if done.already_done(nid):
+                        if done[nid][0] != EMPTY:
+                            vmin += 1
+                            vmax += 1
+                    else:
+                        vmax += 1
+
+                if (num < vmin) or (num > vmax):
+                    return IMPOSSIBLE
+                if num != vmin:
+                    exact = False
+        else:
+            all_done = False
+
+    if (not all_done) or (not exact):
+        return OPEN
+
+    print_pos(pos, output)
+    return SOLVED
+
+
+def solve_step(prev, strategy, order, output, first=False):
+    if first:
+        pos = prev.clone()
+        while constraint_pass(pos):
+            pass
+    else:
+        pos = prev
+
+    moves = find_moves(pos, strategy, order)
+    if len(moves) == 0:
+        return solved(pos, output)
+    else:
+        for move in moves:
+            # print("Trying (%d, %d)" % (move[0], move[1]))
+            ret = OPEN
+            new_pos = pos.clone()
+            play_move(new_pos, move)
+            # print_pos(new_pos)
+            while constraint_pass(new_pos, move[0]):
+                pass
+            cur_status = solved(new_pos, output)
+            if cur_status != OPEN:
+                ret = cur_status
+            else:
+                ret = solve_step(new_pos, strategy, order, output)
+            if ret == SOLVED:
+                return SOLVED
+    return IMPOSSIBLE
+
+
+def check_valid(pos):
+    hex = pos.hex
+    tiles = pos.tiles
+    # fill missing entries in tiles
+    tot = 0
+    for i in range(8):
+        if tiles[i] > 0:
+            tot += tiles[i]
+        else:
+            tiles[i] = 0
+    # check total
+    if tot != hex.count:
+        raise Exception("Invalid input. Expected %d tiles, got %d." % (hex.count, tot))
+
+
+def solve(pos, strategy, order, output):
+    check_valid(pos)
+    return solve_step(pos, strategy, order, output, first=True)
+
+
+# TODO Write an 'iterator' to go over all x,y positions
+
+
+def read_file(file):
+    lines = [line.strip("\r\n") for line in file.splitlines()]
+    size = int(lines[0])
+    hex = Hex(size)
+    linei = 1
+    tiles = 8 * [0]
+    done = Done(hex.count)
+    for y in range(size):
+        line = lines[linei][size - y - 1 :]
+        p = 0
+        for x in range(size + y):
+            tile = line[p : p + 2]
+            p += 2
+            if tile[1] == ".":
+                inctile = EMPTY
+            else:
+                inctile = int(tile)
+            tiles[inctile] += 1
+            # Look for locked tiles
+            if tile[0] == "+":
+                # print("Adding locked tile: %d at pos %d, %d, id=%d" %
+                #      (inctile, x, y, hex.get_by_pos((x, y)).id))
+                done.set_done(hex.get_by_pos((x, y)).id, inctile)
+
+        linei += 1
+    for y in range(1, size):
+        ry = size - 1 + y
+        line = lines[linei][y:]
+        p = 0
+        for x in range(y, size * 2 - 1):
+            tile = line[p : p + 2]
+            p += 2
+            if tile[1] == ".":
+                inctile = EMPTY
+            else:
+                inctile = int(tile)
+            tiles[inctile] += 1
+            # Look for locked tiles
+            if tile[0] == "+":
+                # print("Adding locked tile: %d at pos %d, %d, id=%d" %
+                #      (inctile, x, ry, hex.get_by_pos((x, ry)).id))
+                done.set_done(hex.get_by_pos((x, ry)).id, inctile)
+        linei += 1
+    hex.link_nodes()
+    done.filter_tiles(tiles)
+    return Pos(hex, tiles, done)
+
+
+def solve_file(file, strategy, order, output):
+    pos = read_file(file)
+    solve(pos, strategy, order, output)
+
+
+LEVELS = {}
+
+LEVELS[2] = (
+    """
+2
+  . 1
+ . 1 1
+  1 .
+""",
+    """\
+ 1 1
+. . .
+ 1 1
+""",
+)
+
+LEVELS[10] = (
+    """
+3
+  +.+. .
+ +. 0 . 2
+ . 1+2 1 .
+  2 . 0+.
+   .+.+.
+""",
+    """\
+  . . 1
+ . 1 . 2
+0 . 2 2 .
+ . . . .
+  0 . .
+""",
+)
+
+LEVELS[20] = (
+    """
+3
+   . 5 4
+  . 2+.+1
+ . 3+2 3 .
+ +2+. 5 .
+   . 3 .
+""",
+    """\
+  3 3 2
+ 4 5 . 1
+3 5 2 . .
+ 2 . . .
+  . . .
+""",
+)
+
+LEVELS[25] = (
+    """
+3
+   4 . .
+  . . 2 .
+ 4 3 2 . 4
+  2 2 3 .
+   4 2 4
+""",
+    """\
+  3 4 2
+ 2 4 4 .
+. . . 4 2
+ . 2 4 3
+  . 2 .
+""",
+)
+
+LEVELS[30] = (
+    """
+4
+    5 5 . .
+   3 . 2+2 6
+  3 . 2 . 5 .
+ . 3 3+4 4 . 3
+  4 5 4 . 5 4
+   5+2 . . 3
+    4 . . .
+""",
+    """\
+   3 4 3 .
+  4 6 5 2 .
+ 2 5 5 . . 2
+. . 5 4 . 4 3
+ . 3 5 4 5 4
+  . 2 . 3 3
+   . . . .
+""",
+)
+
+LEVELS[36] = (
+    """
+4
+    2 1 1 2
+   3 3 3 . .
+  2 3 3 . 4 .
+ . 2 . 2 4 3 2
+  2 2 . . . 2
+   4 3 4 . .
+    3 2 3 3
+""",
+    """\
+   3 4 3 2
+  3 4 4 . 3
+ 2 . . 3 4 3
+2 . 1 . 3 . 2
+ 3 3 . 2 . 2
+  3 . 2 . 2
+   2 2 . 1
+""",
+)
+
+
+###########################################################################
+# Benchmark interface
+
+bm_params = {
+    (100, 100): (1, 10, DESCENDING, Done.FIRST_STRATEGY),
+    (1000, 1000): (1, 25, DESCENDING, Done.FIRST_STRATEGY),
+    (5000, 1000): (10, 25, DESCENDING, Done.FIRST_STRATEGY),
+}
+
+
+def bm_setup(params):
+    try:
+        import uio as io
+    except ImportError:
+        import io
+
+    loops, level, order, strategy = params
+
+    board, solution = LEVELS[level]
+    board = board.strip()
+    expected = solution.rstrip()
+    output = None
+
+    def run():
+        nonlocal output
+        for _ in range(loops):
+            stream = io.StringIO()
+            solve_file(board, strategy, order, stream)
+            output = stream.getvalue()
+            stream = None
+
+    def result():
+        norm = params[0] * params[1]
+        out = "\n".join(line.rstrip() for line in output.splitlines())
+        return norm, ((out == expected), out)
+
+    return run, result
diff --git a/tests/perf_bench/bm_nqueens.py b/tests/perf_bench/bm_nqueens.py
new file mode 100644
index 0000000000000..773dd3f7edd8f
--- /dev/null
+++ b/tests/perf_bench/bm_nqueens.py
@@ -0,0 +1,67 @@
+# Source: https://github.com/python/pyperformance
+# License: MIT
+
+# Simple, brute-force N-Queens solver.
+# author: collinwinter@google.com (Collin Winter)
+# n_queens function: Copyright 2009 Raymond Hettinger
+
+# Pure-Python implementation of itertools.permutations().
+def permutations(iterable, r=None):
+    """permutations(range(3), 2) --> (0,1) (0,2) (1,0) (1,2) (2,0) (2,1)"""
+    pool = tuple(iterable)
+    n = len(pool)
+    if r is None:
+        r = n
+    indices = list(range(n))
+    cycles = list(range(n - r + 1, n + 1))[::-1]
+    yield tuple(pool[i] for i in indices[:r])
+    while n:
+        for i in reversed(range(r)):
+            cycles[i] -= 1
+            if cycles[i] == 0:
+                indices[i:] = indices[i + 1 :] + indices[i : i + 1]
+                cycles[i] = n - i
+            else:
+                j = cycles[i]
+                indices[i], indices[-j] = indices[-j], indices[i]
+                yield tuple(pool[i] for i in indices[:r])
+                break
+        else:
+            return
+
+
+# From http://code.activestate.com/recipes/576647/
+def n_queens(queen_count):
+    """N-Queens solver.
+    Args: queen_count: the number of queens to solve for, same as board size.
+    Yields: Solutions to the problem, each yielded value is a N-tuple.
+    """
+    cols = range(queen_count)
+    for vec in permutations(cols):
+        if queen_count == len(set(vec[i] + i for i in cols)) == len(set(vec[i] - i for i in cols)):
+            yield vec
+
+
+###########################################################################
+# Benchmark interface
+
+bm_params = {
+    (50, 25): (1, 5),
+    (100, 25): (1, 6),
+    (1000, 100): (1, 7),
+    (5000, 100): (1, 8),
+}
+
+
+def bm_setup(params):
+    res = None
+
+    def run():
+        nonlocal res
+        for _ in range(params[0]):
+            res = len(list(n_queens(params[1])))
+
+    def result():
+        return params[0] * 10 ** (params[1] - 3), res
+
+    return run, result
diff --git a/tests/perf_bench/bm_pidigits.py b/tests/perf_bench/bm_pidigits.py
new file mode 100644
index 0000000000000..5949b930633f9
--- /dev/null
+++ b/tests/perf_bench/bm_pidigits.py
@@ -0,0 +1,60 @@
+# Source: https://github.com/python/pyperformance
+# License: MIT
+
+# Calculating some of the digits of π.
+# This benchmark stresses big integer arithmetic.
+# Adapted from code on: http://benchmarksgame.alioth.debian.org/
+
+
+def compose(a, b):
+    aq, ar, as_, at = a
+    bq, br, bs, bt = b
+    return (aq * bq, aq * br + ar * bt, as_ * bq + at * bs, as_ * br + at * bt)
+
+
+def extract(z, j):
+    q, r, s, t = z
+    return (q * j + r) // (s * j + t)
+
+
+def gen_pi_digits(n):
+    z = (1, 0, 0, 1)
+    k = 1
+    digs = []
+    for _ in range(n):
+        y = extract(z, 3)
+        while y != extract(z, 4):
+            z = compose(z, (k, 4 * k + 2, 0, 2 * k + 1))
+            k += 1
+            y = extract(z, 3)
+        z = compose((10, -10 * y, 0, 1), z)
+        digs.append(y)
+    return digs
+
+
+###########################################################################
+# Benchmark interface
+
+bm_params = {
+    (50, 25): (1, 35),
+    (100, 100): (1, 65),
+    (1000, 1000): (2, 250),
+    (5000, 1000): (3, 350),
+}
+
+
+def bm_setup(params):
+    state = None
+
+    def run():
+        nonlocal state
+        nloop, ndig = params
+        ndig = params[1]
+        for _ in range(nloop):
+            state = None  # free previous result
+            state = gen_pi_digits(ndig)
+
+    def result():
+        return params[0] * params[1], "".join(str(d) for d in state)
+
+    return run, result
diff --git a/tests/perf_bench/misc_aes.py b/tests/perf_bench/misc_aes.py
new file mode 100644
index 0000000000000..0743737cb7232
--- /dev/null
+++ b/tests/perf_bench/misc_aes.py
@@ -0,0 +1,239 @@
+# Pure Python AES encryption routines.
+#
+# AES is integer based and inplace so doesn't use the heap.  It is therefore
+# a good test of raw performance and correctness of the VM/runtime.
+#
+# The AES code comes first (code originates from a C version authored by D.P.George)
+# and then the test harness at the bottom.
+#
+# MIT license; Copyright (c) 2016 Damien P. George on behalf of Pycom Ltd
+
+##################################################################
+# discrete arithmetic routines, mostly from a precomputed table
+
+# non-linear, invertible, substitution box
+# fmt: off
+aes_s_box_table = bytes((
+    0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
+    0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
+    0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
+    0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
+    0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
+    0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
+    0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
+    0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
+    0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
+    0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
+    0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
+    0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
+    0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
+    0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
+    0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
+    0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16,
+))
+# fmt: on
+
+# multiplication of polynomials modulo x^8 + x^4 + x^3 + x + 1 = 0x11b
+def aes_gf8_mul_2(x):
+    if x & 0x80:
+        return (x << 1) ^ 0x11B
+    else:
+        return x << 1
+
+
+def aes_gf8_mul_3(x):
+    return x ^ aes_gf8_mul_2(x)
+
+
+# non-linear, invertible, substitution box
+def aes_s_box(a):
+    return aes_s_box_table[a & 0xFF]
+
+
+# return 0x02^(a-1) in GF(2^8)
+def aes_r_con(a):
+    ans = 1
+    while a > 1:
+        ans <<= 1
+        if ans & 0x100:
+            ans ^= 0x11B
+        a -= 1
+    return ans
+
+
+##################################################################
+# basic AES algorithm; see FIPS-197
+
+# all inputs must be size 16
+def aes_add_round_key(state, w):
+    for i in range(16):
+        state[i] ^= w[i]
+
+
+# combined sub_bytes, shift_rows, mix_columns, add_round_key
+# all inputs must be size 16
+def aes_sb_sr_mc_ark(state, w, w_idx, temp):
+    temp_idx = 0
+    for i in range(4):
+        x0 = aes_s_box_table[state[i * 4]]
+        x1 = aes_s_box_table[state[1 + ((i + 1) & 3) * 4]]
+        x2 = aes_s_box_table[state[2 + ((i + 2) & 3) * 4]]
+        x3 = aes_s_box_table[state[3 + ((i + 3) & 3) * 4]]
+        temp[temp_idx] = aes_gf8_mul_2(x0) ^ aes_gf8_mul_3(x1) ^ x2 ^ x3 ^ w[w_idx]
+        temp[temp_idx + 1] = x0 ^ aes_gf8_mul_2(x1) ^ aes_gf8_mul_3(x2) ^ x3 ^ w[w_idx + 1]
+        temp[temp_idx + 2] = x0 ^ x1 ^ aes_gf8_mul_2(x2) ^ aes_gf8_mul_3(x3) ^ w[w_idx + 2]
+        temp[temp_idx + 3] = aes_gf8_mul_3(x0) ^ x1 ^ x2 ^ aes_gf8_mul_2(x3) ^ w[w_idx + 3]
+        w_idx += 4
+        temp_idx += 4
+    for i in range(16):
+        state[i] = temp[i]
+
+
+# combined sub_bytes, shift_rows, add_round_key
+# all inputs must be size 16
+def aes_sb_sr_ark(state, w, w_idx, temp):
+    temp_idx = 0
+    for i in range(4):
+        x0 = aes_s_box_table[state[i * 4]]
+        x1 = aes_s_box_table[state[1 + ((i + 1) & 3) * 4]]
+        x2 = aes_s_box_table[state[2 + ((i + 2) & 3) * 4]]
+        x3 = aes_s_box_table[state[3 + ((i + 3) & 3) * 4]]
+        temp[temp_idx] = x0 ^ w[w_idx]
+        temp[temp_idx + 1] = x1 ^ w[w_idx + 1]
+        temp[temp_idx + 2] = x2 ^ w[w_idx + 2]
+        temp[temp_idx + 3] = x3 ^ w[w_idx + 3]
+        w_idx += 4
+        temp_idx += 4
+    for i in range(16):
+        state[i] = temp[i]
+
+
+# take state as input and change it to the next state in the sequence
+# state and temp have size 16, w has size 16 * (Nr + 1), Nr >= 1
+def aes_state(state, w, temp, nr):
+    aes_add_round_key(state, w)
+    w_idx = 16
+    for i in range(nr - 1):
+        aes_sb_sr_mc_ark(state, w, w_idx, temp)
+        w_idx += 16
+    aes_sb_sr_ark(state, w, w_idx, temp)
+
+
+# expand 'key' to 'w' for use with aes_state
+# key has size 4 * Nk, w has size 16 * (Nr + 1), temp has size 16
+def aes_key_expansion(key, w, temp, nk, nr):
+    for i in range(4 * nk):
+        w[i] = key[i]
+    w_idx = 4 * nk - 4
+    for i in range(nk, 4 * (nr + 1)):
+        t = temp
+        t_idx = 0
+        if i % nk == 0:
+            t[0] = aes_s_box(w[w_idx + 1]) ^ aes_r_con(i // nk)
+            for j in range(1, 4):
+                t[j] = aes_s_box(w[w_idx + (j + 1) % 4])
+        elif nk > 6 and i % nk == 4:
+            for j in range(0, 4):
+                t[j] = aes_s_box(w[w_idx + j])
+        else:
+            t = w
+            t_idx = w_idx
+        w_idx += 4
+        for j in range(4):
+            w[w_idx + j] = w[w_idx + j - 4 * nk] ^ t[t_idx + j]
+
+
+##################################################################
+# simple use of AES algorithm, using output feedback (OFB) mode
+
+
+class AES:
+    def __init__(self, keysize):
+        if keysize == 128:
+            self.nk = 4
+            self.nr = 10
+        elif keysize == 192:
+            self.nk = 6
+            self.nr = 12
+        else:
+            assert keysize == 256
+            self.nk = 8
+            self.nr = 14
+
+        self.state = bytearray(16)
+        self.w = bytearray(16 * (self.nr + 1))
+        self.temp = bytearray(16)
+        self.state_pos = 16
+
+    def set_key(self, key):
+        aes_key_expansion(key, self.w, self.temp, self.nk, self.nr)
+        self.state_pos = 16
+
+    def set_iv(self, iv):
+        for i in range(16):
+            self.state[i] = iv[i]
+        self.state_pos = 16
+
+    def get_some_state(self, n_needed):
+        if self.state_pos >= 16:
+            aes_state(self.state, self.w, self.temp, self.nr)
+            self.state_pos = 0
+        n = 16 - self.state_pos
+        if n > n_needed:
+            n = n_needed
+        return n
+
+    def apply_to(self, data):
+        idx = 0
+        n = len(data)
+        while n > 0:
+            ln = self.get_some_state(n)
+            n -= ln
+            for i in range(ln):
+                data[idx + i] ^= self.state[self.state_pos + i]
+            idx += ln
+            self.state_pos += n
+
+
+###########################################################################
+# Benchmark interface
+
+bm_params = {
+    (50, 25): (1, 16),
+    (100, 100): (1, 32),
+    (1000, 1000): (4, 256),
+    (5000, 1000): (20, 256),
+}
+
+
+def bm_setup(params):
+    nloop, datalen = params
+
+    aes = AES(256)
+    key = bytearray(256 // 8)
+    iv = bytearray(16)
+    data = bytearray(datalen)
+    # from now on we don't use the heap
+
+    def run():
+        for loop in range(nloop):
+            # encrypt
+            aes.set_key(key)
+            aes.set_iv(iv)
+            for i in range(2):
+                aes.apply_to(data)
+
+            # decrypt
+            aes.set_key(key)
+            aes.set_iv(iv)
+            for i in range(2):
+                aes.apply_to(data)
+
+            # verify
+            for i in range(len(data)):
+                assert data[i] == 0
+
+    def result():
+        return params[0] * params[1], True
+
+    return run, result
diff --git a/tests/perf_bench/misc_mandel.py b/tests/perf_bench/misc_mandel.py
new file mode 100644
index 0000000000000..fe26e3f4c22f9
--- /dev/null
+++ b/tests/perf_bench/misc_mandel.py
@@ -0,0 +1,34 @@
+# Compute the Mandelbrot set, to test complex numbers
+
+
+def mandelbrot(w, h):
+    def in_set(c):
+        z = 0
+        for i in range(32):
+            z = z * z + c
+            if abs(z) > 100:
+                return i
+        return 0
+
+    img = bytearray(w * h)
+
+    xscale = (w - 1) / 2.4
+    yscale = (h - 1) / 3.2
+    for v in range(h):
+        line = memoryview(img)[v * w : v * w + w]
+        for u in range(w):
+            c = in_set(complex(v / yscale - 2.3, u / xscale - 1.2))
+            line[u] = c
+
+    return img
+
+
+bm_params = {
+    (100, 100): (20, 20),
+    (1000, 1000): (80, 80),
+    (5000, 1000): (150, 150),
+}
+
+
+def bm_setup(ps):
+    return lambda: mandelbrot(ps[0], ps[1]), lambda: (ps[0] * ps[1], None)
diff --git a/tests/perf_bench/misc_pystone.py b/tests/perf_bench/misc_pystone.py
new file mode 100644
index 0000000000000..26f91c7becb10
--- /dev/null
+++ b/tests/perf_bench/misc_pystone.py
@@ -0,0 +1,240 @@
+"""
+"PYSTONE" Benchmark Program
+
+Version:        Python/1.2 (corresponds to C/1.1 plus 3 Pystone fixes)
+
+Author:         Reinhold P. Weicker,  CACM Vol 27, No 10, 10/84 pg. 1013.
+
+                Translated from ADA to C by Rick Richardson.
+                Every method to preserve ADA-likeness has been used,
+                at the expense of C-ness.
+
+                Translated from C to Python by Guido van Rossum.
+"""
+
+__version__ = "1.2"
+
+[Ident1, Ident2, Ident3, Ident4, Ident5] = range(1, 6)
+
+
+class Record:
+    def __init__(self, PtrComp=None, Discr=0, EnumComp=0, IntComp=0, StringComp=0):
+        self.PtrComp = PtrComp
+        self.Discr = Discr
+        self.EnumComp = EnumComp
+        self.IntComp = IntComp
+        self.StringComp = StringComp
+
+    def copy(self):
+        return Record(self.PtrComp, self.Discr, self.EnumComp, self.IntComp, self.StringComp)
+
+
+TRUE = 1
+FALSE = 0
+
+
+def Setup():
+    global IntGlob
+    global BoolGlob
+    global Char1Glob
+    global Char2Glob
+    global Array1Glob
+    global Array2Glob
+
+    IntGlob = 0
+    BoolGlob = FALSE
+    Char1Glob = "\0"
+    Char2Glob = "\0"
+    Array1Glob = [0] * 51
+    Array2Glob = [x[:] for x in [Array1Glob] * 51]
+
+
+def Proc0(loops):
+    global IntGlob
+    global BoolGlob
+    global Char1Glob
+    global Char2Glob
+    global Array1Glob
+    global Array2Glob
+    global PtrGlb
+    global PtrGlbNext
+
+    PtrGlbNext = Record()
+    PtrGlb = Record()
+    PtrGlb.PtrComp = PtrGlbNext
+    PtrGlb.Discr = Ident1
+    PtrGlb.EnumComp = Ident3
+    PtrGlb.IntComp = 40
+    PtrGlb.StringComp = "DHRYSTONE PROGRAM, SOME STRING"
+    String1Loc = "DHRYSTONE PROGRAM, 1'ST STRING"
+    Array2Glob[8][7] = 10
+
+    for i in range(loops):
+        Proc5()
+        Proc4()
+        IntLoc1 = 2
+        IntLoc2 = 3
+        String2Loc = "DHRYSTONE PROGRAM, 2'ND STRING"
+        EnumLoc = Ident2
+        BoolGlob = not Func2(String1Loc, String2Loc)
+        while IntLoc1 < IntLoc2:
+            IntLoc3 = 5 * IntLoc1 - IntLoc2
+            IntLoc3 = Proc7(IntLoc1, IntLoc2)
+            IntLoc1 = IntLoc1 + 1
+        Proc8(Array1Glob, Array2Glob, IntLoc1, IntLoc3)
+        PtrGlb = Proc1(PtrGlb)
+        CharIndex = "A"
+        while CharIndex <= Char2Glob:
+            if EnumLoc == Func1(CharIndex, "C"):
+                EnumLoc = Proc6(Ident1)
+            CharIndex = chr(ord(CharIndex) + 1)
+        IntLoc3 = IntLoc2 * IntLoc1
+        IntLoc2 = IntLoc3 // IntLoc1
+        IntLoc2 = 7 * (IntLoc3 - IntLoc2) - IntLoc1
+        IntLoc1 = Proc2(IntLoc1)
+
+
+def Proc1(PtrParIn):
+    PtrParIn.PtrComp = NextRecord = PtrGlb.copy()
+    PtrParIn.IntComp = 5
+    NextRecord.IntComp = PtrParIn.IntComp
+    NextRecord.PtrComp = PtrParIn.PtrComp
+    NextRecord.PtrComp = Proc3(NextRecord.PtrComp)
+    if NextRecord.Discr == Ident1:
+        NextRecord.IntComp = 6
+        NextRecord.EnumComp = Proc6(PtrParIn.EnumComp)
+        NextRecord.PtrComp = PtrGlb.PtrComp
+        NextRecord.IntComp = Proc7(NextRecord.IntComp, 10)
+    else:
+        PtrParIn = NextRecord.copy()
+    NextRecord.PtrComp = None
+    return PtrParIn
+
+
+def Proc2(IntParIO):
+    IntLoc = IntParIO + 10
+    while 1:
+        if Char1Glob == "A":
+            IntLoc = IntLoc - 1
+            IntParIO = IntLoc - IntGlob
+            EnumLoc = Ident1
+        if EnumLoc == Ident1:
+            break
+    return IntParIO
+
+
+def Proc3(PtrParOut):
+    global IntGlob
+
+    if PtrGlb is not None:
+        PtrParOut = PtrGlb.PtrComp
+    else:
+        IntGlob = 100
+    PtrGlb.IntComp = Proc7(10, IntGlob)
+    return PtrParOut
+
+
+def Proc4():
+    global Char2Glob
+
+    BoolLoc = Char1Glob == "A"
+    BoolLoc = BoolLoc or BoolGlob
+    Char2Glob = "B"
+
+
+def Proc5():
+    global Char1Glob
+    global BoolGlob
+
+    Char1Glob = "A"
+    BoolGlob = FALSE
+
+
+def Proc6(EnumParIn):
+    EnumParOut = EnumParIn
+    if not Func3(EnumParIn):
+        EnumParOut = Ident4
+    if EnumParIn == Ident1:
+        EnumParOut = Ident1
+    elif EnumParIn == Ident2:
+        if IntGlob > 100:
+            EnumParOut = Ident1
+        else:
+            EnumParOut = Ident4
+    elif EnumParIn == Ident3:
+        EnumParOut = Ident2
+    elif EnumParIn == Ident4:
+        pass
+    elif EnumParIn == Ident5:
+        EnumParOut = Ident3
+    return EnumParOut
+
+
+def Proc7(IntParI1, IntParI2):
+    IntLoc = IntParI1 + 2
+    IntParOut = IntParI2 + IntLoc
+    return IntParOut
+
+
+def Proc8(Array1Par, Array2Par, IntParI1, IntParI2):
+    global IntGlob
+
+    IntLoc = IntParI1 + 5
+    Array1Par[IntLoc] = IntParI2
+    Array1Par[IntLoc + 1] = Array1Par[IntLoc]
+    Array1Par[IntLoc + 30] = IntLoc
+    for IntIndex in range(IntLoc, IntLoc + 2):
+        Array2Par[IntLoc][IntIndex] = IntLoc
+    Array2Par[IntLoc][IntLoc - 1] = Array2Par[IntLoc][IntLoc - 1] + 1
+    Array2Par[IntLoc + 20][IntLoc] = Array1Par[IntLoc]
+    IntGlob = 5
+
+
+def Func1(CharPar1, CharPar2):
+    CharLoc1 = CharPar1
+    CharLoc2 = CharLoc1
+    if CharLoc2 != CharPar2:
+        return Ident1
+    else:
+        return Ident2
+
+
+def Func2(StrParI1, StrParI2):
+    IntLoc = 1
+    while IntLoc <= 1:
+        if Func1(StrParI1[IntLoc], StrParI2[IntLoc + 1]) == Ident1:
+            CharLoc = "A"
+            IntLoc = IntLoc + 1
+    if CharLoc >= "W" and CharLoc <= "Z":
+        IntLoc = 7
+    if CharLoc == "X":
+        return TRUE
+    else:
+        if StrParI1 > StrParI2:
+            IntLoc = IntLoc + 7
+            return TRUE
+        else:
+            return FALSE
+
+
+def Func3(EnumParIn):
+    EnumLoc = EnumParIn
+    if EnumLoc == Ident3:
+        return TRUE
+    return FALSE
+
+
+###########################################################################
+# Benchmark interface
+
+bm_params = {
+    (50, 10): (80,),
+    (100, 10): (300,),
+    (1000, 10): (4000,),
+    (5000, 10): (20000,),
+}
+
+
+def bm_setup(params):
+    Setup()
+    return lambda: Proc0(params[0]), lambda: (params[0], 0)
diff --git a/tests/perf_bench/misc_raytrace.py b/tests/perf_bench/misc_raytrace.py
new file mode 100644
index 0000000000000..b51acaccac235
--- /dev/null
+++ b/tests/perf_bench/misc_raytrace.py
@@ -0,0 +1,258 @@
+# A simple ray tracer
+# MIT license; Copyright (c) 2019 Damien P. George
+
+INF = 1e30
+EPS = 1e-6
+
+
+class Vec:
+    def __init__(self, x, y, z):
+        self.x, self.y, self.z = x, y, z
+
+    def __neg__(self):
+        return Vec(-self.x, -self.y, -self.z)
+
+    def __add__(self, rhs):
+        return Vec(self.x + rhs.x, self.y + rhs.y, self.z + rhs.z)
+
+    def __sub__(self, rhs):
+        return Vec(self.x - rhs.x, self.y - rhs.y, self.z - rhs.z)
+
+    def __mul__(self, rhs):
+        return Vec(self.x * rhs, self.y * rhs, self.z * rhs)
+
+    def length(self):
+        return (self.x ** 2 + self.y ** 2 + self.z ** 2) ** 0.5
+
+    def normalise(self):
+        l = self.length()
+        return Vec(self.x / l, self.y / l, self.z / l)
+
+    def dot(self, rhs):
+        return self.x * rhs.x + self.y * rhs.y + self.z * rhs.z
+
+
+RGB = Vec
+
+
+class Ray:
+    def __init__(self, p, d):
+        self.p, self.d = p, d
+
+
+class View:
+    def __init__(self, width, height, depth, pos, xdir, ydir, zdir):
+        self.width = width
+        self.height = height
+        self.depth = depth
+        self.pos = pos
+        self.xdir = xdir
+        self.ydir = ydir
+        self.zdir = zdir
+
+    def calc_dir(self, dx, dy):
+        return (self.xdir * dx + self.ydir * dy + self.zdir * self.depth).normalise()
+
+
+class Light:
+    def __init__(self, pos, colour, casts_shadows):
+        self.pos = pos
+        self.colour = colour
+        self.casts_shadows = casts_shadows
+
+
+class Surface:
+    def __init__(self, diffuse, specular, spec_idx, reflect, transp, colour):
+        self.diffuse = diffuse
+        self.specular = specular
+        self.spec_idx = spec_idx
+        self.reflect = reflect
+        self.transp = transp
+        self.colour = colour
+
+    @staticmethod
+    def dull(colour):
+        return Surface(0.7, 0.0, 1, 0.0, 0.0, colour * 0.6)
+
+    @staticmethod
+    def shiny(colour):
+        return Surface(0.2, 0.9, 32, 0.8, 0.0, colour * 0.3)
+
+    @staticmethod
+    def transparent(colour):
+        return Surface(0.2, 0.9, 32, 0.0, 0.8, colour * 0.3)
+
+
+class Sphere:
+    def __init__(self, surface, centre, radius):
+        self.surface = surface
+        self.centre = centre
+        self.radsq = radius ** 2
+
+    def intersect(self, ray):
+        v = self.centre - ray.p
+        b = v.dot(ray.d)
+        det = b ** 2 - v.dot(v) + self.radsq
+        if det > 0:
+            det **= 0.5
+            t1 = b - det
+            if t1 > EPS:
+                return t1
+            t2 = b + det
+            if t2 > EPS:
+                return t2
+        return INF
+
+    def surface_at(self, v):
+        return self.surface, (v - self.centre).normalise()
+
+
+class Plane:
+    def __init__(self, surface, centre, normal):
+        self.surface = surface
+        self.normal = normal.normalise()
+        self.cdotn = centre.dot(normal)
+
+    def intersect(self, ray):
+        ddotn = ray.d.dot(self.normal)
+        if abs(ddotn) > EPS:
+            t = (self.cdotn - ray.p.dot(self.normal)) / ddotn
+            if t > 0:
+                return t
+        return INF
+
+    def surface_at(self, p):
+        return self.surface, self.normal
+
+
+class Scene:
+    def __init__(self, ambient, light, objs):
+        self.ambient = ambient
+        self.light = light
+        self.objs = objs
+
+
+def trace_scene(canvas, view, scene, max_depth):
+    for v in range(canvas.height):
+        y = (-v + 0.5 * (canvas.height - 1)) * view.height / canvas.height
+        for u in range(canvas.width):
+            x = (u - 0.5 * (canvas.width - 1)) * view.width / canvas.width
+            ray = Ray(view.pos, view.calc_dir(x, y))
+            c = trace_ray(scene, ray, max_depth)
+            canvas.put_pix(u, v, c)
+
+
+def trace_ray(scene, ray, depth):
+    # Find closest intersecting object
+    hit_t = INF
+    hit_obj = None
+    for obj in scene.objs:
+        t = obj.intersect(ray)
+        if t < hit_t:
+            hit_t = t
+            hit_obj = obj
+
+    # Check if any objects hit
+    if hit_obj is None:
+        return RGB(0, 0, 0)
+
+    # Compute location of ray intersection
+    point = ray.p + ray.d * hit_t
+    surf, surf_norm = hit_obj.surface_at(point)
+    if ray.d.dot(surf_norm) > 0:
+        surf_norm = -surf_norm
+
+    # Compute reflected ray
+    reflected = ray.d - surf_norm * (surf_norm.dot(ray.d) * 2)
+
+    # Ambient light
+    col = surf.colour * scene.ambient
+
+    # Diffuse, specular and shadow from light source
+    light_vec = scene.light.pos - point
+    light_dist = light_vec.length()
+    light_vec = light_vec.normalise()
+    ndotl = surf_norm.dot(light_vec)
+    ldotv = light_vec.dot(reflected)
+    if ndotl > 0 or ldotv > 0:
+        light_ray = Ray(point + light_vec * EPS, light_vec)
+        light_col = trace_to_light(scene, light_ray, light_dist)
+        if ndotl > 0:
+            col += light_col * surf.diffuse * ndotl
+        if ldotv > 0:
+            col += light_col * surf.specular * ldotv ** surf.spec_idx
+
+    # Reflections
+    if depth > 0 and surf.reflect > 0:
+        col += trace_ray(scene, Ray(point + reflected * EPS, reflected), depth - 1) * surf.reflect
+
+    # Transparency
+    if depth > 0 and surf.transp > 0:
+        col += trace_ray(scene, Ray(point + ray.d * EPS, ray.d), depth - 1) * surf.transp
+
+    return col
+
+
+def trace_to_light(scene, ray, light_dist):
+    col = scene.light.colour
+    for obj in scene.objs:
+        t = obj.intersect(ray)
+        if t < light_dist:
+            col *= obj.surface.transp
+    return col
+
+
+class Canvas:
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.data = bytearray(3 * width * height)
+
+    def put_pix(self, x, y, c):
+        off = 3 * (y * self.width + x)
+        self.data[off] = min(255, max(0, int(255 * c.x)))
+        self.data[off + 1] = min(255, max(0, int(255 * c.y)))
+        self.data[off + 2] = min(255, max(0, int(255 * c.z)))
+
+    def write_ppm(self, filename):
+        with open(filename, "wb") as f:
+            f.write(bytes("P6 %d %d 255\n" % (self.width, self.height), "ascii"))
+            f.write(self.data)
+
+
+def main(w, h, d):
+    canvas = Canvas(w, h)
+    view = View(32, 32, 64, Vec(0, 0, 50), Vec(1, 0, 0), Vec(0, 1, 0), Vec(0, 0, -1))
+    scene = Scene(
+        0.5,
+        Light(Vec(0, 8, 0), RGB(1, 1, 1), True),
+        [
+            Plane(Surface.dull(RGB(1, 0, 0)), Vec(-10, 0, 0), Vec(1, 0, 0)),
+            Plane(Surface.dull(RGB(0, 1, 0)), Vec(10, 0, 0), Vec(-1, 0, 0)),
+            Plane(Surface.dull(RGB(1, 1, 1)), Vec(0, 0, -10), Vec(0, 0, 1)),
+            Plane(Surface.dull(RGB(1, 1, 1)), Vec(0, -10, 0), Vec(0, 1, 0)),
+            Plane(Surface.dull(RGB(1, 1, 1)), Vec(0, 10, 0), Vec(0, -1, 0)),
+            Sphere(Surface.shiny(RGB(1, 1, 1)), Vec(-5, -4, 3), 4),
+            Sphere(Surface.dull(RGB(0, 0, 1)), Vec(4, -5, 0), 4),
+            Sphere(Surface.transparent(RGB(0.2, 0.2, 0.2)), Vec(6, -1, 8), 4),
+        ],
+    )
+    trace_scene(canvas, view, scene, d)
+    return canvas
+
+
+# For testing
+# main(256, 256, 4).write_ppm('rt.ppm')
+
+###########################################################################
+# Benchmark interface
+
+bm_params = {
+    (100, 100): (5, 5, 2),
+    (1000, 100): (18, 18, 3),
+    (5000, 100): (40, 40, 3),
+}
+
+
+def bm_setup(params):
+    return lambda: main(*params), lambda: (params[0] * params[1] * params[2], None)
diff --git a/tests/perf_bench/viper_call0.py b/tests/perf_bench/viper_call0.py
new file mode 100644
index 0000000000000..903e2b5e58e9f
--- /dev/null
+++ b/tests/perf_bench/viper_call0.py
@@ -0,0 +1,22 @@
+@micropython.viper
+def f0():
+    pass
+
+
+@micropython.native
+def call(r):
+    f = f0
+    for _ in r:
+        f()
+
+
+bm_params = {
+    (50, 10): (15000,),
+    (100, 10): (30000,),
+    (1000, 10): (300000,),
+    (5000, 10): (1500000,),
+}
+
+
+def bm_setup(params):
+    return lambda: call(range(params[0])), lambda: (params[0] // 1000, None)
diff --git a/tests/perf_bench/viper_call1a.py b/tests/perf_bench/viper_call1a.py
new file mode 100644
index 0000000000000..76adef60a10db
--- /dev/null
+++ b/tests/perf_bench/viper_call1a.py
@@ -0,0 +1,22 @@
+@micropython.viper
+def f1a(x):
+    return x
+
+
+@micropython.native
+def call(r):
+    f = f1a
+    for _ in r:
+        f(1)
+
+
+bm_params = {
+    (50, 10): (15000,),
+    (100, 10): (30000,),
+    (1000, 10): (300000,),
+    (5000, 10): (1500000,),
+}
+
+
+def bm_setup(params):
+    return lambda: call(range(params[0])), lambda: (params[0] // 1000, None)
diff --git a/tests/perf_bench/viper_call1b.py b/tests/perf_bench/viper_call1b.py
new file mode 100644
index 0000000000000..b52693c15d2c4
--- /dev/null
+++ b/tests/perf_bench/viper_call1b.py
@@ -0,0 +1,22 @@
+@micropython.viper
+def f1b(x) -> int:
+    return int(x)
+
+
+@micropython.native
+def call(r):
+    f = f1b
+    for _ in r:
+        f(1)
+
+
+bm_params = {
+    (50, 10): (15000,),
+    (100, 10): (30000,),
+    (1000, 10): (300000,),
+    (5000, 10): (1500000,),
+}
+
+
+def bm_setup(params):
+    return lambda: call(range(params[0])), lambda: (params[0] // 1000, None)
diff --git a/tests/perf_bench/viper_call1c.py b/tests/perf_bench/viper_call1c.py
new file mode 100644
index 0000000000000..31578c5baccd3
--- /dev/null
+++ b/tests/perf_bench/viper_call1c.py
@@ -0,0 +1,22 @@
+@micropython.viper
+def f1c(x: int) -> int:
+    return x
+
+
+@micropython.native
+def call(r):
+    f = f1c
+    for _ in r:
+        f(1)
+
+
+bm_params = {
+    (50, 10): (15000,),
+    (100, 10): (30000,),
+    (1000, 10): (300000,),
+    (5000, 10): (1500000,),
+}
+
+
+def bm_setup(params):
+    return lambda: call(range(params[0])), lambda: (params[0] // 1000, None)
diff --git a/tests/perf_bench/viper_call2a.py b/tests/perf_bench/viper_call2a.py
new file mode 100644
index 0000000000000..d0520b46bc8fe
--- /dev/null
+++ b/tests/perf_bench/viper_call2a.py
@@ -0,0 +1,22 @@
+@micropython.viper
+def f2a(x, y):
+    return x
+
+
+@micropython.native
+def call(r):
+    f = f2a
+    for _ in r:
+        f(1, 2)
+
+
+bm_params = {
+    (50, 10): (15000,),
+    (100, 10): (30000,),
+    (1000, 10): (300000,),
+    (5000, 10): (1500000,),
+}
+
+
+def bm_setup(params):
+    return lambda: call(range(params[0])), lambda: (params[0] // 1000, None)
diff --git a/tests/perf_bench/viper_call2b.py b/tests/perf_bench/viper_call2b.py
new file mode 100644
index 0000000000000..1171b7d576975
--- /dev/null
+++ b/tests/perf_bench/viper_call2b.py
@@ -0,0 +1,22 @@
+@micropython.viper
+def f2b(x: int, y: int) -> int:
+    return x + y
+
+
+@micropython.native
+def call(r):
+    f = f2b
+    for _ in r:
+        f(1, 2)
+
+
+bm_params = {
+    (50, 10): (15000,),
+    (100, 10): (30000,),
+    (1000, 10): (300000,),
+    (5000, 10): (1500000,),
+}
+
+
+def bm_setup(params):
+    return lambda: call(range(params[0])), lambda: (params[0] // 1000, None)
diff --git a/tests/pyb/accel.py b/tests/pyb/accel.py
index e5a1a2ed7a441..7a5e072be05d2 100644
--- a/tests/pyb/accel.py
+++ b/tests/pyb/accel.py
@@ -1,5 +1,9 @@
 import pyb
 
+if not hasattr(pyb, "Accel"):
+    print("SKIP")
+    raise SystemExit
+
 accel = pyb.Accel()
 print(accel)
 accel.x()
diff --git a/tests/pyb/adc.py b/tests/pyb/adc.py
index 0bd9b9d53a5ca..875d31d732cc3 100644
--- a/tests/pyb/adc.py
+++ b/tests/pyb/adc.py
@@ -1,8 +1,8 @@
 from pyb import ADC, Timer
 
-adct = ADC(16) # Temperature 930 -> 20C
-print(adct)
-adcv = ADC(17) # Voltage 1500 -> 3.3V
+adct = ADC(16)  # Temperature 930 -> 20C
+print(str(adct)[:19])
+adcv = ADC(17)  # Voltage 1500 -> 3.3V
 print(adcv)
 
 # read single sample; 2.5V-5V is pass range
@@ -13,7 +13,7 @@
 tim = Timer(5, freq=500)
 
 # read into bytearray
-buf = bytearray(b'\xff' * 50)
+buf = bytearray(b"\xff" * 50)
 adcv.read_timed(buf, tim)
 print(len(buf))
 for i in buf:
@@ -21,21 +21,22 @@
 
 # read into arrays with different element sizes
 import array
-arv = array.array('h', 25 * [0x7fff])
+
+arv = array.array("h", 25 * [0x7FFF])
 adcv.read_timed(arv, tim)
 print(len(arv))
 for i in arv:
     assert i > 1000 and i < 2000
 
-arv = array.array('i', 30 * [-1])
+arv = array.array("i", 30 * [-1])
 adcv.read_timed(arv, tim)
 print(len(arv))
 for i in arv:
     assert i > 1000 and i < 2000
 
 # Test read_timed_multi
-arv = bytearray(b'\xff'*50)
-art = bytearray(b'\xff'*50)
+arv = bytearray(b"\xff" * 50)
+art = bytearray(b"\xff" * 50)
 ADC.read_timed_multi((adcv, adct), (arv, art), tim)
 for i in arv:
     assert i > 60 and i < 125
@@ -43,8 +44,8 @@
 for i in art:
     assert i > 15 and i < 200
 
-arv = array.array('i', 25 * [-1])
-art = array.array('i', 25 * [-1])
+arv = array.array("i", 25 * [-1])
+art = array.array("i", 25 * [-1])
 ADC.read_timed_multi((adcv, adct), (arv, art), tim)
 for i in arv:
     assert i > 1000 and i < 2000
@@ -52,8 +53,8 @@
 for i in art:
     assert i > 50 and i < 2000
 
-arv = array.array('h', 25 * [0x7fff])
-art = array.array('h', 25 * [0x7fff])
+arv = array.array("h", 25 * [0x7FFF])
+art = array.array("h", 25 * [0x7FFF])
 ADC.read_timed_multi((adcv, adct), (arv, art), tim)
 for i in arv:
     assert i > 1000 and i < 2000
diff --git a/tests/pyb/adc.py.exp b/tests/pyb/adc.py.exp
index 1aae16fb01771..381329cdde046 100644
--- a/tests/pyb/adc.py.exp
+++ b/tests/pyb/adc.py.exp
@@ -1,4 +1,4 @@
-<ADC on 16 channel=16>
+<ADC on 16 channel=
 <ADC on 17 channel=17>
 50
 25
diff --git a/tests/pyb/board_pybv1x.py b/tests/pyb/board_pybv1x.py
new file mode 100644
index 0000000000000..ea66270b29766
--- /dev/null
+++ b/tests/pyb/board_pybv1x.py
@@ -0,0 +1,39 @@
+# Test board-specific items on PYBv1.x
+
+import os, pyb
+
+if not "PYBv1." in os.uname().machine:
+    print("SKIP")
+    raise SystemExit
+
+# test creating UART by id/name
+for bus in (1, 2, 3, 4, 5, 6, 7, "XA", "XB", "YA", "YB", "Z"):
+    try:
+        pyb.UART(bus, 9600)
+        print("UART", bus)
+    except ValueError:
+        print("ValueError", bus)
+
+# test creating SPI by id/name
+for bus in (1, 2, 3, "X", "Y", "Z"):
+    try:
+        pyb.SPI(bus)
+        print("SPI", bus)
+    except ValueError:
+        print("ValueError", bus)
+
+# test creating I2C by id/name
+for bus in (2, 3, "X", "Y", "Z"):
+    try:
+        pyb.I2C(bus)
+        print("I2C", bus)
+    except ValueError:
+        print("ValueError", bus)
+
+# test creating CAN by id/name
+for bus in (1, 2, 3, "YA", "YB", "YC"):
+    try:
+        pyb.CAN(bus, pyb.CAN.LOOPBACK)
+        print("CAN", bus)
+    except ValueError:
+        print("ValueError", bus)
diff --git a/tests/pyb/board_pybv1x.py.exp b/tests/pyb/board_pybv1x.py.exp
new file mode 100644
index 0000000000000..6d4a6f63c7434
--- /dev/null
+++ b/tests/pyb/board_pybv1x.py.exp
@@ -0,0 +1,29 @@
+UART 1
+UART 2
+UART 3
+UART 4
+ValueError 5
+UART 6
+ValueError 7
+UART XA
+UART XB
+UART YA
+UART YB
+ValueError Z
+SPI 1
+SPI 2
+ValueError 3
+SPI X
+SPI Y
+ValueError Z
+I2C 2
+ValueError 3
+I2C X
+I2C Y
+ValueError Z
+CAN 1
+CAN 2
+ValueError 3
+CAN YA
+CAN YB
+ValueError YC
diff --git a/tests/pyb/can.py b/tests/pyb/can.py
index 8a08ea9a65b3c..4ea29b0f63a40 100644
--- a/tests/pyb/can.py
+++ b/tests/pyb/can.py
@@ -1,15 +1,15 @@
 try:
     from pyb import CAN
 except ImportError:
-    print('SKIP')
+    print("SKIP")
     raise SystemExit
 
 from array import array
 import micropython
 import pyb
 
-# test we can correctly create by id or name
-for bus in (-1, 0, 1, 2, 3, "YA", "YB", "YC"):
+# test we can correctly create by id (2 handled in can2.py test)
+for bus in (-1, 0, 1, 3):
     try:
         CAN(bus, CAN.LOOPBACK)
         print("CAN", bus)
@@ -40,23 +40,23 @@
 # Catch all filter
 can.setfilter(0, CAN.MASK16, 0, (0, 0, 0, 0))
 
-can.send('abcd', 123, timeout=5000)
+can.send("abcd", 123, timeout=5000)
 print(can.any(0), can.info())
 print(can.recv(0))
 
-can.send('abcd', -1, timeout=5000)
+can.send("abcd", -1, timeout=5000)
 print(can.recv(0))
 
-can.send('abcd', 0x7FF + 1, timeout=5000)
+can.send("abcd", 0x7FF + 1, timeout=5000)
 print(can.recv(0))
 
 # Test too long message
 try:
-    can.send('abcdefghi', 0x7FF, timeout=5000)
+    can.send("abcdefghi", 0x7FF, timeout=5000)
 except ValueError:
-    print('passed')
+    print("passed")
 else:
-    print('failed')
+    print("failed")
 
 # Test that recv can work without allocating memory on the heap
 
@@ -66,22 +66,22 @@
 
 micropython.heap_lock()
 
-can.send('', 42)
+can.send("", 42)
 l2 = can.recv(0, l)
 assert l is l2
 print(l, len(l[3]), buf)
 
-can.send('1234', 42)
+can.send("1234", 42)
 l2 = can.recv(0, l)
 assert l is l2
 print(l, len(l[3]), buf)
 
-can.send('01234567', 42)
+can.send("01234567", 42)
 l2 = can.recv(0, l)
 assert l is l2
 print(l, len(l[3]), buf)
 
-can.send('abc', 42)
+can.send("abc", 42)
 l2 = can.recv(0, l)
 assert l is l2
 print(l, len(l[3]), buf)
@@ -89,65 +89,65 @@
 micropython.heap_unlock()
 
 # Test that recv can work with different arrays behind the memoryview
-can.send('abc', 1)
-print(bytes(can.recv(0, [0, 0, 0, memoryview(array('B', range(8)))])[3]))
-can.send('def', 1)
-print(bytes(can.recv(0, [0, 0, 0, memoryview(array('b', range(8)))])[3]))
+can.send("abc", 1)
+print(bytes(can.recv(0, [0, 0, 0, memoryview(array("B", range(8)))])[3]))
+can.send("def", 1)
+print(bytes(can.recv(0, [0, 0, 0, memoryview(array("b", range(8)))])[3]))
 
 # Test for non-list passed as second arg to recv
-can.send('abc', 1)
+can.send("abc", 1)
 try:
     can.recv(0, 1)
 except TypeError:
-    print('TypeError')
+    print("TypeError")
 
 # Test for too-short-list passed as second arg to recv
-can.send('abc', 1)
+can.send("abc", 1)
 try:
     can.recv(0, [0, 0, 0])
 except ValueError:
-    print('ValueError')
+    print("ValueError")
 
 # Test for non-memoryview passed as 4th element to recv
-can.send('abc', 1)
+can.send("abc", 1)
 try:
     can.recv(0, [0, 0, 0, 0])
 except TypeError:
-    print('TypeError')
+    print("TypeError")
 
 # Test for read-only-memoryview passed as 4th element to recv
-can.send('abc', 1)
+can.send("abc", 1)
 try:
     can.recv(0, [0, 0, 0, memoryview(bytes(8))])
 except ValueError:
-    print('ValueError')
+    print("ValueError")
 
 # Test for bad-typecode-memoryview passed as 4th element to recv
-can.send('abc', 1)
+can.send("abc", 1)
 try:
-    can.recv(0, [0, 0, 0, memoryview(array('i', range(8)))])
+    can.recv(0, [0, 0, 0, memoryview(array("i", range(8)))])
 except ValueError:
-    print('ValueError')
+    print("ValueError")
 
 del can
 
 # Testing extended IDs
-can = CAN(1, CAN.LOOPBACK, extframe = True)
+can = CAN(1, CAN.LOOPBACK, extframe=True)
 # Catch all filter
 can.setfilter(0, CAN.MASK32, 0, (0, 0))
 
 print(can)
 
 try:
-    can.send('abcde', 0x7FF + 1, timeout=5000)
+    can.send("abcde", 0x7FF + 1, timeout=5000)
 except ValueError:
-    print('failed')
+    print("failed")
 else:
     r = can.recv(0)
-    if r[0] == 0x7FF+1 and r[3] == b'abcde':
-        print('passed')
+    if r[0] == 0x7FF + 1 and r[3] == b"abcde":
+        print("passed")
     else:
-        print('failed, wrong data received')
+        print("failed, wrong data received")
 
 # Test filters
 for n in [0, 8, 16, 24]:
@@ -159,7 +159,7 @@
     can.clearfilter(0)
     can.setfilter(0, pyb.CAN.MASK32, 0, (filter_id, filter_mask))
 
-    can.send('ok', id_ok, timeout=3)
+    can.send("ok", id_ok, timeout=3)
     if can.any(0):
         msg = can.recv(0)
         print((hex(filter_id), hex(filter_mask), hex(msg[0]), msg[3]))
@@ -175,57 +175,62 @@
 can = CAN(1, CAN.LOOPBACK)
 can.setfilter(0, CAN.LIST16, 0, (1, 2, 3, 4))
 can.setfilter(1, CAN.LIST16, 1, (5, 6, 7, 8))
+
+
 def cb0(bus, reason):
-    print('cb0')
+    print("cb0")
     if reason == 0:
-        print('pending')
+        print("pending")
     if reason == 1:
-        print('full')
+        print("full")
     if reason == 2:
-        print('overflow')
+        print("overflow")
+
 
 def cb1(bus, reason):
-    print('cb1')
+    print("cb1")
     if reason == 0:
-        print('pending')
+        print("pending")
     if reason == 1:
-        print('full')
+        print("full")
     if reason == 2:
-        print('overflow')
+        print("overflow")
+
 
 def cb0a(bus, reason):
-    print('cb0a')
+    print("cb0a")
     if reason == 0:
-        print('pending')
+        print("pending")
     if reason == 1:
-        print('full')
+        print("full")
     if reason == 2:
-        print('overflow')
+        print("overflow")
+
 
 def cb1a(bus, reason):
-    print('cb1a')
+    print("cb1a")
     if reason == 0:
-        print('pending')
+        print("pending")
     if reason == 1:
-        print('full')
+        print("full")
     if reason == 2:
-        print('overflow')
+        print("overflow")
 
 
 can.rxcallback(0, cb0)
 can.rxcallback(1, cb1)
 
-can.send('11111111',1, timeout=5000)
-can.send('22222222',2, timeout=5000)
-can.send('33333333',3, timeout=5000)
+can.send("11111111", 1, timeout=5000)
+can.send("22222222", 2, timeout=5000)
+can.send("33333333", 3, timeout=5000)
 can.rxcallback(0, cb0a)
-can.send('44444444',4, timeout=5000)
+can.send("44444444", 4, timeout=5000)
 
-can.send('55555555',5, timeout=5000)
-can.send('66666666',6, timeout=5000)
-can.send('77777777',7, timeout=5000)
+can.send("55555555", 5, timeout=5000)
+can.send("66666666", 6, timeout=5000)
+can.send("77777777", 7, timeout=5000)
 can.rxcallback(1, cb1a)
-can.send('88888888',8, timeout=5000)
+can.send("88888888", 8, timeout=5000)
 
 print(can.recv(0))
 print(can.recv(0))
@@ -234,8 +239,8 @@ def cb1a(bus, reason):
 print(can.recv(1))
 print(can.recv(1))
 
-can.send('11111111',1, timeout=5000)
-can.send('55555555',5, timeout=5000)
+can.send("11111111", 1, timeout=5000)
+can.send("55555555", 5, timeout=5000)
 
 print(can.recv(0))
 print(can.recv(1))
@@ -249,7 +254,7 @@ def cb1a(bus, reason):
 while can.any(0):
     can.recv(0)
 
-can.send('abcde', 1, timeout=0)
+can.send("abcde", 1, timeout=0)
 print(can.any(0))
 while not can.any(0):
     pass
@@ -257,15 +262,15 @@ def cb1a(bus, reason):
 print(can.recv(0))
 
 try:
-    can.send('abcde', 2, timeout=0)
-    can.send('abcde', 3, timeout=0)
-    can.send('abcde', 4, timeout=0)
-    can.send('abcde', 5, timeout=0)
+    can.send("abcde", 2, timeout=0)
+    can.send("abcde", 3, timeout=0)
+    can.send("abcde", 4, timeout=0)
+    can.send("abcde", 5, timeout=0)
 except OSError as e:
-    if str(e) == '16':
-        print('passed')
+    if str(e) == "16":
+        print("passed")
     else:
-        print('failed')
+        print("failed")
 
 pyb.delay(500)
 while can.any(0):
@@ -273,37 +278,28 @@ def cb1a(bus, reason):
 
 # Testing rtr messages
 bus1 = CAN(1, CAN.LOOPBACK)
-bus2 = CAN(2, CAN.LOOPBACK, extframe = True)
 while bus1.any(0):
     bus1.recv(0)
-while bus2.any(0):
-    bus2.recv(0)
 bus1.setfilter(0, CAN.LIST16, 0, (1, 2, 3, 4))
 bus1.setfilter(1, CAN.LIST16, 0, (5, 6, 7, 8), rtr=(True, True, True, True))
 bus1.setfilter(2, CAN.MASK16, 0, (64, 64, 32, 32), rtr=(False, True))
-bus2.setfilter(0, CAN.LIST32, 0, (1, 2), rtr=(True, True))
-bus2.setfilter(1, CAN.LIST32, 0, (3, 4), rtr=(True, False))
-bus2.setfilter(2, CAN.MASK32, 0, (16, 16), rtr=(False,))
-bus2.setfilter(2, CAN.MASK32, 0, (32, 32), rtr=(True,))
 
-bus1.send('',1,rtr=True)
+bus1.send("", 1, rtr=True)
 print(bus1.any(0))
-bus1.send('',5,rtr=True)
+bus1.send("", 5, rtr=True)
 print(bus1.recv(0))
-bus1.send('',6,rtr=True)
+bus1.send("", 6, rtr=True)
 print(bus1.recv(0))
-bus1.send('',7,rtr=True)
+bus1.send("", 7, rtr=True)
 print(bus1.recv(0))
-bus1.send('',16,rtr=True)
+bus1.send("", 16, rtr=True)
 print(bus1.any(0))
-bus1.send('',32,rtr=True)
+bus1.send("", 32, rtr=True)
 print(bus1.recv(0))
 
-bus2.send('',1,rtr=True)
-print(bus2.recv(0))
-bus2.send('',2,rtr=True)
-print(bus2.recv(0))
-bus2.send('',3,rtr=True)
-print(bus2.recv(0))
-bus2.send('',4,rtr=True)
-print(bus2.any(0))
+# test HAL error, timeout
+can = pyb.CAN(1, pyb.CAN.NORMAL)
+try:
+    can.send("1", 1, timeout=50)
+except OSError as e:
+    print(repr(e))
diff --git a/tests/pyb/can.py.exp b/tests/pyb/can.py.exp
index 687935e7f45bc..a27907cc52389 100644
--- a/tests/pyb/can.py.exp
+++ b/tests/pyb/can.py.exp
@@ -1,11 +1,7 @@
 ValueError -1
 ValueError 0
 CAN 1
-CAN 2
 ValueError 3
-CAN YA
-CAN YB
-ValueError YC
 CAN(1)
 True
 CAN(1, CAN.LOOPBACK, extframe=False, auto_restart=False)
@@ -70,7 +66,4 @@ False
 (7, True, 6, b'')
 False
 (32, True, 9, b'')
-(1, True, 0, b'')
-(2, True, 1, b'')
-(3, True, 2, b'')
-False
+OSError(110,)
diff --git a/tests/pyb/can2.py b/tests/pyb/can2.py
new file mode 100644
index 0000000000000..46237ad84f78a
--- /dev/null
+++ b/tests/pyb/can2.py
@@ -0,0 +1,25 @@
+try:
+    from pyb import CAN
+
+    CAN(2)
+except (ImportError, ValueError):
+    print("SKIP")
+    raise SystemExit
+
+# Testing rtr messages
+bus2 = CAN(2, CAN.LOOPBACK, extframe=True)
+while bus2.any(0):
+    bus2.recv(0)
+bus2.setfilter(0, CAN.LIST32, 0, (1, 2), rtr=(True, True))
+bus2.setfilter(1, CAN.LIST32, 0, (3, 4), rtr=(True, False))
+bus2.setfilter(2, CAN.MASK32, 0, (16, 16), rtr=(False,))
+bus2.setfilter(2, CAN.MASK32, 0, (32, 32), rtr=(True,))
+
+bus2.send("", 1, rtr=True)
+print(bus2.recv(0))
+bus2.send("", 2, rtr=True)
+print(bus2.recv(0))
+bus2.send("", 3, rtr=True)
+print(bus2.recv(0))
+bus2.send("", 4, rtr=True)
+print(bus2.any(0))
diff --git a/tests/pyb/can2.py.exp b/tests/pyb/can2.py.exp
new file mode 100644
index 0000000000000..371ad2bdc435b
--- /dev/null
+++ b/tests/pyb/can2.py.exp
@@ -0,0 +1,4 @@
+(1, True, 0, b'')
+(2, True, 1, b'')
+(3, True, 2, b'')
+False
diff --git a/tests/pyb/dac.py b/tests/pyb/dac.py
index ca68ec7098c5d..506cf272b3179 100644
--- a/tests/pyb/dac.py
+++ b/tests/pyb/dac.py
@@ -1,7 +1,7 @@
 import pyb
 
-if not hasattr(pyb, 'DAC'):
-    print('SKIP')
+if not hasattr(pyb, "DAC"):
+    print("SKIP")
     raise SystemExit
 
 dac = pyb.DAC(1)
diff --git a/tests/pyb/extint.py b/tests/pyb/extint.py
index ae98ccd5a0de5..5510600020e53 100644
--- a/tests/pyb/extint.py
+++ b/tests/pyb/extint.py
@@ -1,7 +1,7 @@
 import pyb
 
 # test basic functionality
-ext = pyb.ExtInt('Y1', pyb.ExtInt.IRQ_RISING, pyb.Pin.PULL_DOWN, lambda l:print('line:', l))
+ext = pyb.ExtInt("X5", pyb.ExtInt.IRQ_RISING, pyb.Pin.PULL_DOWN, lambda l: print("line:", l))
 ext.disable()
 ext.enable()
 print(ext.line())
diff --git a/tests/pyb/extint.py.exp b/tests/pyb/extint.py.exp
index 1f9da9844a081..fbd820ed43a34 100644
--- a/tests/pyb/extint.py.exp
+++ b/tests/pyb/extint.py.exp
@@ -1,3 +1,3 @@
-6
-line: 6
-line: 6
+4
+line: 4
+line: 4
diff --git a/tests/pyb/halerror.py b/tests/pyb/halerror.py
deleted file mode 100644
index 1a6bce1a7ef9d..0000000000000
--- a/tests/pyb/halerror.py
+++ /dev/null
@@ -1,15 +0,0 @@
-# test hal errors
-
-import pyb
-
-i2c = pyb.I2C(2, pyb.I2C.MASTER)
-try:
-    i2c.recv(1, 1)
-except OSError as e:
-    print(repr(e))
-
-can = pyb.CAN(1, pyb.CAN.NORMAL)
-try:
-    can.send('1', 1, timeout=50)
-except OSError as e:
-    print(repr(e))
diff --git a/tests/pyb/halerror.py.exp b/tests/pyb/halerror.py.exp
deleted file mode 100644
index 0f3f26253dc81..0000000000000
--- a/tests/pyb/halerror.py.exp
+++ /dev/null
@@ -1,2 +0,0 @@
-OSError(5,)
-OSError(110,)
diff --git a/tests/pyb/i2c.py b/tests/pyb/i2c.py
index 6875e5a5aa024..bc9dba8781aa9 100644
--- a/tests/pyb/i2c.py
+++ b/tests/pyb/i2c.py
@@ -1,8 +1,8 @@
 import pyb
 from pyb import I2C
 
-# test we can correctly create by id or name
-for bus in (-1, 0, 1, 2, 3, "X", "Y", "Z"):
+# test we can correctly create by id
+for bus in (-1, 0, 1):
     try:
         I2C(bus)
         print("I2C", bus)
@@ -14,19 +14,3 @@
 i2c.init(I2C.MASTER, baudrate=400000)
 print(i2c.scan())
 i2c.deinit()
-
-# use accelerometer to test i2c bus
-
-accel_addr = 76
-
-pyb.Accel() # this will init the MMA for us
-i2c.init(I2C.MASTER, baudrate=400000)
-
-print(i2c.scan())
-print(i2c.is_ready(accel_addr))
-
-print(i2c.mem_read(1, accel_addr, 7, timeout=500))
-i2c.mem_write(0, accel_addr, 0, timeout=500)
-
-i2c.send(7, addr=accel_addr)
-i2c.recv(1, addr=accel_addr)
diff --git a/tests/pyb/i2c.py.exp b/tests/pyb/i2c.py.exp
index 709fb412de978..bd896ea74e4b9 100644
--- a/tests/pyb/i2c.py.exp
+++ b/tests/pyb/i2c.py.exp
@@ -1,12 +1,4 @@
 ValueError -1
 ValueError 0
 I2C 1
-I2C 2
-ValueError 3
-I2C X
-I2C Y
-ValueError Z
 []
-[76]
-True
-b'\x01'
diff --git a/tests/pyb/i2c_accel.py b/tests/pyb/i2c_accel.py
new file mode 100644
index 0000000000000..8c74fa60e61b2
--- /dev/null
+++ b/tests/pyb/i2c_accel.py
@@ -0,0 +1,23 @@
+# use accelerometer to test i2c bus
+
+import pyb
+from pyb import I2C
+
+if not hasattr(pyb, "Accel"):
+    print("SKIP")
+    raise SystemExit
+
+accel_addr = 76
+
+pyb.Accel()  # this will init the MMA for us
+
+i2c = I2C(1, I2C.MASTER, baudrate=400000)
+
+print(i2c.scan())
+print(i2c.is_ready(accel_addr))
+
+print(i2c.mem_read(1, accel_addr, 7, timeout=500))
+i2c.mem_write(0, accel_addr, 0, timeout=500)
+
+i2c.send(7, addr=accel_addr)
+i2c.recv(1, addr=accel_addr)
diff --git a/tests/pyb/i2c_accel.py.exp b/tests/pyb/i2c_accel.py.exp
new file mode 100644
index 0000000000000..206a2eb4c2a95
--- /dev/null
+++ b/tests/pyb/i2c_accel.py.exp
@@ -0,0 +1,3 @@
+[76]
+True
+b'\x01'
diff --git a/tests/pyb/i2c_error.py b/tests/pyb/i2c_error.py
index 3201d6367dbeb..b17a26325d037 100644
--- a/tests/pyb/i2c_error.py
+++ b/tests/pyb/i2c_error.py
@@ -3,6 +3,10 @@
 import pyb
 from pyb import I2C
 
+if not hasattr(pyb, "Accel"):
+    print("SKIP")
+    raise SystemExit
+
 # init accelerometer
 pyb.Accel()
 
@@ -11,40 +15,40 @@
 
 # test polling mem_read
 pyb.disable_irq()
-i2c.mem_read(1, 76, 0x0a) # should succeed
+i2c.mem_read(1, 76, 0x0A)  # should succeed
 pyb.enable_irq()
 try:
     pyb.disable_irq()
-    i2c.mem_read(1, 77, 0x0a) # should fail
+    i2c.mem_read(1, 77, 0x0A)  # should fail
 except OSError as e:
     pyb.enable_irq()
     print(repr(e))
-i2c.mem_read(1, 76, 0x0a) # should succeed
+i2c.mem_read(1, 76, 0x0A)  # should succeed
 
 # test polling mem_write
 pyb.disable_irq()
-i2c.mem_write(1, 76, 0x0a) # should succeed
+i2c.mem_write(1, 76, 0x0A)  # should succeed
 pyb.enable_irq()
 try:
     pyb.disable_irq()
-    i2c.mem_write(1, 77, 0x0a) # should fail
+    i2c.mem_write(1, 77, 0x0A)  # should fail
 except OSError as e:
     pyb.enable_irq()
     print(repr(e))
-i2c.mem_write(1, 76, 0x0a) # should succeed
+i2c.mem_write(1, 76, 0x0A)  # should succeed
 
 # test DMA mem_read
-i2c.mem_read(1, 76, 0x0a) # should succeed
+i2c.mem_read(1, 76, 0x0A)  # should succeed
 try:
-    i2c.mem_read(1, 77, 0x0a) # should fail
+    i2c.mem_read(1, 77, 0x0A)  # should fail
 except OSError as e:
     print(repr(e))
-i2c.mem_read(1, 76, 0x0a) # should succeed
+i2c.mem_read(1, 76, 0x0A)  # should succeed
 
 # test DMA mem_write
-i2c.mem_write(1, 76, 0x0a) # should succeed
+i2c.mem_write(1, 76, 0x0A)  # should succeed
 try:
-    i2c.mem_write(1, 77, 0x0a) # should fail
+    i2c.mem_write(1, 77, 0x0A)  # should fail
 except OSError as e:
     print(repr(e))
-i2c.mem_write(1, 76, 0x0a) # should succeed
+i2c.mem_write(1, 76, 0x0A)  # should succeed
diff --git a/tests/pyb/irq.py b/tests/pyb/irq.py
index 42d276568ebfa..04e70a7b79211 100644
--- a/tests/pyb/irq.py
+++ b/tests/pyb/irq.py
@@ -1,10 +1,11 @@
 import pyb
 
+
 def test_irq():
     # test basic disable/enable
     i1 = pyb.disable_irq()
     print(i1)
-    pyb.enable_irq() # by default should enable IRQ
+    pyb.enable_irq()  # by default should enable IRQ
 
     # check that interrupts are enabled by waiting for ticks
     pyb.delay(10)
@@ -19,4 +20,5 @@ def test_irq():
     # check that interrupts are enabled by waiting for ticks
     pyb.delay(10)
 
+
 test_irq()
diff --git a/tests/pyb/led.py b/tests/pyb/led.py
index d2a17ebc9adfc..1702c189ebfdf 100644
--- a/tests/pyb/led.py
+++ b/tests/pyb/led.py
@@ -1,17 +1,19 @@
-import pyb
-from pyb import LED
+import os, pyb
 
-l1 = pyb.LED(1)
-l2 = pyb.LED(2)
-l3 = pyb.LED(3)
-l4 = pyb.LED(4)
-
-leds = [LED(i) for i in range(1, 5)]
-pwm_leds = leds[2:]
+machine = os.uname().machine
+if "PYBv1." in machine or "PYBLITEv1." in machine:
+    leds = [pyb.LED(i) for i in range(1, 5)]
+    pwm_leds = leds[2:]
+elif "PYBD" in machine:
+    leds = [pyb.LED(i) for i in range(1, 4)]
+    pwm_leds = []
+else:
+    print("SKIP")
+    raise SystemExit
 
 # test printing
-for l in leds:
-    print(l)
+for i in range(3):
+    print(leds[i])
 
 # test on and off
 for l in leds:
diff --git a/tests/pyb/led.py.exp b/tests/pyb/led.py.exp
index 4e8d856cd94b0..b4170c41e4403 100644
--- a/tests/pyb/led.py.exp
+++ b/tests/pyb/led.py.exp
@@ -1,4 +1,3 @@
 LED(1)
 LED(2)
 LED(3)
-LED(4)
diff --git a/tests/pyb/modtime.py b/tests/pyb/modtime.py
index d45440a63c7fa..396f832667bfd 100644
--- a/tests/pyb/modtime.py
+++ b/tests/pyb/modtime.py
@@ -2,12 +2,14 @@
 
 DAYS_PER_MONTH = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
 
+
 def is_leap(year):
     return (year % 4) == 0
 
+
 def test():
     seconds = 0
-    wday = 5    # Jan 1, 2000 was a Saturday
+    wday = 5  # Jan 1, 2000 was a Saturday
     for year in range(2000, 2034):
         print("Testing %d" % year)
         yday = 1
@@ -19,32 +21,48 @@ def test():
             for day in range(1, DAYS_PER_MONTH[month] + 1):
                 secs = time.mktime((year, month, day, 0, 0, 0, 0, 0))
                 if secs != seconds:
-                    print("mktime failed for %d-%02d-%02d got %d expected %d" % (year, month, day, secs, seconds))
+                    print(
+                        "mktime failed for %d-%02d-%02d got %d expected %d"
+                        % (year, month, day, secs, seconds)
+                    )
                 tuple = time.localtime(seconds)
                 secs = time.mktime(tuple)
                 if secs != seconds:
-                    print("localtime failed for %d-%02d-%02d got %d expected %d" % (year, month, day, secs, seconds))
+                    print(
+                        "localtime failed for %d-%02d-%02d got %d expected %d"
+                        % (year, month, day, secs, seconds)
+                    )
                     return
                 seconds += 86400
                 if yday != tuple[7]:
-                    print("locatime for %d-%02d-%02d got yday %d, expecting %d" % (year, month, day, tuple[7], yday))
+                    print(
+                        "locatime for %d-%02d-%02d got yday %d, expecting %d"
+                        % (year, month, day, tuple[7], yday)
+                    )
                     return
                 if wday != tuple[6]:
-                    print("locatime for %d-%02d-%02d got wday %d, expecting %d" % (year, month, day, tuple[6], wday))
+                    print(
+                        "locatime for %d-%02d-%02d got wday %d, expecting %d"
+                        % (year, month, day, tuple[6], wday)
+                    )
                     return
                 yday += 1
                 wday = (wday + 1) % 7
 
+
 def spot_test(seconds, expected_time):
     actual_time = time.localtime(seconds)
     for i in range(len(actual_time)):
         if actual_time[i] != expected_time[i]:
-            print("time.localtime(", seconds, ") returned", actual_time, "expecting", expected_time)
+            print(
+                "time.localtime(", seconds, ") returned", actual_time, "expecting", expected_time
+            )
             return
     print("time.localtime(", seconds, ") returned", actual_time, "(pass)")
 
 
 test()
+# fmt: off
 spot_test(          0,  (2000,  1,  1,  0,  0,  0, 5,   1))
 spot_test(          1,  (2000,  1,  1,  0,  0,  1, 5,   1))
 spot_test(         59,  (2000,  1,  1,  0,  0, 59, 5,   1))
@@ -57,3 +75,4 @@ def spot_test(seconds, expected_time):
 spot_test(-1072915199,  (1966,  1,  1,  0,  0,  1, 5,   1))
 spot_test(-1072915200,  (1966,  1,  1,  0,  0,  0, 5,   1))
 spot_test(-1072915201,  (1965, 12, 31, 23, 59, 59, 4, 365))
+# fmt: on
diff --git a/tests/pyb/pin.py b/tests/pyb/pin.py
index 9b37883438f33..3d2bef97e3437 100644
--- a/tests/pyb/pin.py
+++ b/tests/pyb/pin.py
@@ -1,14 +1,14 @@
 from pyb import Pin
 
-p = Pin('Y1', Pin.IN)
+p = Pin("X8", Pin.IN)
 print(p)
 print(p.name())
 print(p.pin())
 print(p.port())
 
-p = Pin('Y1', Pin.IN, Pin.PULL_UP)
-p = Pin('Y1', Pin.IN, pull=Pin.PULL_UP)
-p = Pin('Y1', mode=Pin.IN, pull=Pin.PULL_UP)
+p = Pin("X8", Pin.IN, Pin.PULL_UP)
+p = Pin("X8", Pin.IN, pull=Pin.PULL_UP)
+p = Pin("X8", mode=Pin.IN, pull=Pin.PULL_UP)
 print(p)
 print(p.value())
 
diff --git a/tests/pyb/pin.py.exp b/tests/pyb/pin.py.exp
index f2f7038fd44b5..a2a7e42d96d18 100644
--- a/tests/pyb/pin.py.exp
+++ b/tests/pyb/pin.py.exp
@@ -1,10 +1,10 @@
-Pin(Pin.cpu.C6, mode=Pin.IN)
-C6
-6
-2
-Pin(Pin.cpu.C6, mode=Pin.IN, pull=Pin.PULL_UP)
+Pin(Pin.cpu.A7, mode=Pin.IN)
+A7
+7
+0
+Pin(Pin.cpu.A7, mode=Pin.IN, pull=Pin.PULL_UP)
 1
-Pin(Pin.cpu.C6, mode=Pin.IN, pull=Pin.PULL_DOWN)
+Pin(Pin.cpu.A7, mode=Pin.IN, pull=Pin.PULL_DOWN)
 0
 0
 1
diff --git a/tests/pyb/pyb1.py b/tests/pyb/pyb1.py
index 443722ca85970..e9626ecf4e7d4 100644
--- a/tests/pyb/pyb1.py
+++ b/tests/pyb/pyb1.py
@@ -10,7 +10,7 @@
 
 start = pyb.millis()
 pyb.delay(17)
-print((pyb.millis() - start) // 5) # should print 3
+print((pyb.millis() - start) // 5)  # should print 3
 
 # test udelay
 
@@ -20,7 +20,7 @@
 
 start = pyb.millis()
 pyb.udelay(17000)
-print((pyb.millis() - start) // 5) # should print 3
+print((pyb.millis() - start) // 5)  # should print 3
 
 # other
 
diff --git a/tests/pyb/pyb_f405.py b/tests/pyb/pyb_f405.py
index 2f161ae099592..243381056e133 100644
--- a/tests/pyb/pyb_f405.py
+++ b/tests/pyb/pyb_f405.py
@@ -2,9 +2,16 @@
 
 import os, pyb
 
-if not 'STM32F405' in os.uname().machine:
-    print('SKIP')
+if not "STM32F405" in os.uname().machine:
+    print("SKIP")
     raise SystemExit
 
 print(pyb.freq())
 print(type(pyb.rng()))
+
+# test HAL error specific to F405
+i2c = pyb.I2C(2, pyb.I2C.MASTER)
+try:
+    i2c.recv(1, 1)
+except OSError as e:
+    print(repr(e))
diff --git a/tests/pyb/pyb_f405.py.exp b/tests/pyb/pyb_f405.py.exp
index a90aa0268659e..a52f40920d111 100644
--- a/tests/pyb/pyb_f405.py.exp
+++ b/tests/pyb/pyb_f405.py.exp
@@ -1,2 +1,3 @@
 (168000000, 168000000, 42000000, 84000000)
 <class 'int'>
+OSError(5,)
diff --git a/tests/pyb/pyb_f411.py b/tests/pyb/pyb_f411.py
index 50de30282376f..58d5fa2d41216 100644
--- a/tests/pyb/pyb_f411.py
+++ b/tests/pyb/pyb_f411.py
@@ -2,8 +2,8 @@
 
 import os, pyb
 
-if not 'STM32F411' in os.uname().machine:
-    print('SKIP')
+if not "STM32F411" in os.uname().machine:
+    print("SKIP")
     raise SystemExit
 
 print(pyb.freq())
diff --git a/tests/pyb/rtc.py b/tests/pyb/rtc.py
index 844526b4b9683..41b52f260d887 100644
--- a/tests/pyb/rtc.py
+++ b/tests/pyb/rtc.py
@@ -10,10 +10,12 @@
 pyb.delay(1002)
 print(rtc.datetime()[:7])
 
+
 def set_and_print(datetime):
     rtc.datetime(datetime)
     print(rtc.datetime()[:7])
 
+
 # make sure that setting works correctly
 set_and_print((2000, 1, 1, 1, 0, 0, 0, 0))
 set_and_print((2000, 1, 31, 1, 0, 0, 0, 0))
@@ -34,10 +36,12 @@ def set_and_print(datetime):
 # save existing calibration value:
 cal_tmp = rtc.calibration()
 
+
 def set_and_print_calib(cal):
     rtc.calibration(cal)
     print(rtc.calibration())
 
+
 set_and_print_calib(512)
 set_and_print_calib(511)
 set_and_print_calib(345)
@@ -56,12 +60,13 @@ def set_and_print_wakeup(ms):
     try:
         rtc.wakeup(ms)
         wucksel = stm.mem32[stm.RTC + stm.RTC_CR] & 7
-        wut = stm.mem32[stm.RTC + stm.RTC_WUTR] & 0xffff
+        wut = stm.mem32[stm.RTC + stm.RTC_WUTR] & 0xFFFF
     except ValueError:
         wucksel = -1
         wut = -1
     print((wucksel, wut))
 
+
 set_and_print_wakeup(0)
 set_and_print_wakeup(1)
 set_and_print_wakeup(4000)
@@ -72,8 +77,8 @@ def set_and_print_wakeup(ms):
 set_and_print_wakeup(16001)
 set_and_print_wakeup(32000)
 set_and_print_wakeup(32001)
-set_and_print_wakeup(0x10000*1000)
-set_and_print_wakeup(0x10001*1000)
-set_and_print_wakeup(0x1ffff*1000)
-set_and_print_wakeup(0x20000*1000)
-set_and_print_wakeup(0x20001*1000) # exception
+set_and_print_wakeup(0x10000 * 1000)
+set_and_print_wakeup(0x10001 * 1000)
+set_and_print_wakeup(0x1FFFF * 1000)
+set_and_print_wakeup(0x20000 * 1000)
+set_and_print_wakeup(0x20001 * 1000)  # exception
diff --git a/tests/pyb/spi.py b/tests/pyb/spi.py
index 88cc975bb6602..73d39e7245e48 100644
--- a/tests/pyb/spi.py
+++ b/tests/pyb/spi.py
@@ -1,7 +1,7 @@
 from pyb import SPI
 
-# test we can correctly create by id or name
-for bus in (-1, 0, 1, 2, 3, "X", "Y", "Z"):
+# test we can correctly create by id
+for bus in (-1, 0, 1, 2):
     try:
         SPI(bus)
         print("SPI", bus)
@@ -14,7 +14,7 @@
 spi = SPI(1, SPI.MASTER)
 spi = SPI(1, SPI.MASTER, baudrate=500000)
 spi = SPI(1, SPI.MASTER, 500000, polarity=1, phase=0, bits=8, firstbit=SPI.MSB, ti=False, crc=None)
-print(spi)
+print(str(spi)[:28], str(spi)[49:])  # don't print baudrate/prescaler
 
 spi.init(SPI.SLAVE, phase=1)
 print(spi)
diff --git a/tests/pyb/spi.py.exp b/tests/pyb/spi.py.exp
index a0d835700f073..473c173a58d8b 100644
--- a/tests/pyb/spi.py.exp
+++ b/tests/pyb/spi.py.exp
@@ -2,12 +2,8 @@ ValueError -1
 ValueError 0
 SPI 1
 SPI 2
-ValueError 3
-SPI X
-SPI Y
-ValueError Z
 SPI(1)
-SPI(1, SPI.MASTER, baudrate=328125, prescaler=256, polarity=1, phase=0, bits=8)
+SPI(1, SPI.MASTER, baudrate= , polarity=1, phase=0, bits=8)
 SPI(1, SPI.SLAVE, polarity=1, phase=1, bits=8)
 OSError
 b'\xff'
diff --git a/tests/pyb/timer.py b/tests/pyb/timer.py
index 61320690a6ccb..251a06c081bbe 100644
--- a/tests/pyb/timer.py
+++ b/tests/pyb/timer.py
@@ -11,3 +11,9 @@
 print(tim.prescaler())
 tim.period(400)
 print(tim.period())
+
+# Setting and printing frequency
+tim = Timer(2, freq=100)
+print(tim.freq())
+tim.freq(0.001)
+print("{:.3f}".format(tim.freq()))
diff --git a/tests/pyb/timer.py.exp b/tests/pyb/timer.py.exp
index 5c46230303de4..7602bbd70dbd2 100644
--- a/tests/pyb/timer.py.exp
+++ b/tests/pyb/timer.py.exp
@@ -2,3 +2,5 @@
 200
 300
 400
+100
+0.001
diff --git a/tests/pyb/timer_callback.py b/tests/pyb/timer_callback.py
index 864dd479edc83..51242fba4bab0 100644
--- a/tests/pyb/timer_callback.py
+++ b/tests/pyb/timer_callback.py
@@ -8,19 +8,24 @@ def cb1(t):
     print("cb1")
     t.callback(None)
 
+
 # callback function that disables the timer when called
 def cb2(t):
     print("cb2")
     t.deinit()
 
+
 # callback where cb4 closes over cb3.y
 def cb3(x):
     y = x
+
     def cb4(t):
         print("cb4", y)
         t.callback(None)
+
     return cb4
 
+
 # create a timer with a callback, using callback(None) to stop
 tim = Timer(1, freq=100, callback=cb1)
 pyb.delay(5)
diff --git a/tests/pyb/uart.py b/tests/pyb/uart.py
index 836b073a6d952..53b0ea6ade459 100644
--- a/tests/pyb/uart.py
+++ b/tests/pyb/uart.py
@@ -1,7 +1,7 @@
 from pyb import UART
 
-# test we can correctly create by id or name
-for bus in (-1, 0, 1, 2, 3, 4, 5, 6, 7, "XA", "XB", "YA", "YB", "Z"):
+# test we can correctly create by id
+for bus in (-1, 0, 1, 2, 5, 6):
     try:
         UART(bus, 9600)
         print("UART", bus)
@@ -17,8 +17,8 @@
 print(uart)
 
 print(uart.any())
-print(uart.write('123'))
-print(uart.write(b'abcd'))
+print(uart.write("123"))
+print(uart.write(b"abcd"))
 print(uart.writechar(1))
 
 # make sure this method exists
@@ -26,8 +26,8 @@
 
 # non-blocking mode
 uart = UART(1, 9600, timeout=0)
-print(uart.write(b'1'))
-print(uart.write(b'abcd'))
+print(uart.write(b"1"))
+print(uart.write(b"abcd"))
 print(uart.writechar(1))
 print(uart.read(100))
 
diff --git a/tests/pyb/uart.py.exp b/tests/pyb/uart.py.exp
index f3e6bbe2825f7..70e4ab8509fcd 100644
--- a/tests/pyb/uart.py.exp
+++ b/tests/pyb/uart.py.exp
@@ -2,18 +2,10 @@ ValueError -1
 ValueError 0
 UART 1
 UART 2
-UART 3
-UART 4
 ValueError 5
 UART 6
-ValueError 7
-UART XA
-UART XB
-UART YA
-UART YB
-ValueError Z
-UART(1, baudrate=9600, bits=8, parity=None, stop=1, flow=0, timeout=1000, timeout_char=3, rxbuf=64)
-UART(1, baudrate=2400, bits=8, parity=None, stop=1, flow=0, timeout=1000, timeout_char=7, rxbuf=64)
+UART(1, baudrate=9600, bits=8, parity=None, stop=1, flow=0, timeout=0, timeout_char=3, rxbuf=64)
+UART(1, baudrate=2400, bits=8, parity=None, stop=1, flow=0, timeout=0, timeout_char=7, rxbuf=64)
 0
 3
 4
@@ -22,7 +14,7 @@ None
 4
 None
 None
-UART(1, baudrate=9600, bits=8, parity=None, stop=1, flow=0, timeout=1000, timeout_char=3, rxbuf=8)
-UART(1, baudrate=9600, bits=8, parity=None, stop=1, flow=0, timeout=1000, timeout_char=3, rxbuf=0)
-UART(1, baudrate=9600, bits=8, parity=None, stop=1, flow=0, timeout=1000, timeout_char=3, rxbuf=4)
-UART(1, baudrate=9600, bits=8, parity=None, stop=1, flow=0, timeout=1000, timeout_char=3, rxbuf=0)
+UART(1, baudrate=9600, bits=8, parity=None, stop=1, flow=0, timeout=0, timeout_char=3, rxbuf=8)
+UART(1, baudrate=9600, bits=8, parity=None, stop=1, flow=0, timeout=0, timeout_char=3, rxbuf=0)
+UART(1, baudrate=9600, bits=8, parity=None, stop=1, flow=0, timeout=0, timeout_char=3, rxbuf=4)
+UART(1, baudrate=9600, bits=8, parity=None, stop=1, flow=0, timeout=0, timeout_char=3, rxbuf=0)
diff --git a/tests/pybnative/for.py b/tests/pybnative/for.py
index 309c6c14fd075..50177a9ba4854 100644
--- a/tests/pybnative/for.py
+++ b/tests/pybnative/for.py
@@ -1,15 +1,19 @@
 import pyb
 
+
 @micropython.native
 def f1(n):
     for i in range(n):
         print(i)
 
+
 f1(4)
 
+
 @micropython.native
 def f2(r):
     for i in r:
         print(i)
 
+
 f2(range(4))
diff --git a/tests/pybnative/while.py b/tests/pybnative/while.py
index 3ea7221ea706a..0f397dd3772a9 100644
--- a/tests/pybnative/while.py
+++ b/tests/pybnative/while.py
@@ -1,5 +1,6 @@
 import pyb
 
+
 @micropython.native
 def f(led, n, d):
     led.off()
@@ -11,5 +12,6 @@ def f(led, n, d):
         i += 1
     led.off()
 
+
 f(pyb.LED(1), 2, 150)
 f(pyb.LED(2), 4, 50)
diff --git a/tests/qemu-arm/native_test.py b/tests/qemu-arm/native_test.py
new file mode 100644
index 0000000000000..0b58433d92026
--- /dev/null
+++ b/tests/qemu-arm/native_test.py
@@ -0,0 +1,5 @@
+import native_frozen_align
+
+native_frozen_align.native_x(1)
+native_frozen_align.native_y(2)
+native_frozen_align.native_z(3)
diff --git a/tests/qemu-arm/native_test.py.exp b/tests/qemu-arm/native_test.py.exp
new file mode 100644
index 0000000000000..dcf37cd5e2620
--- /dev/null
+++ b/tests/qemu-arm/native_test.py.exp
@@ -0,0 +1,3 @@
+2
+3
+4
diff --git a/tests/run-bench-tests b/tests/run-internalbench.py
similarity index 65%
rename from tests/run-bench-tests
rename to tests/run-internalbench.py
index f4a6776cbc29a..63392814a893f 100755
--- a/tests/run-bench-tests
+++ b/tests/run-internalbench.py
@@ -11,12 +11,13 @@
 # Tests require at least CPython 3.3. If your default python3 executable
 # is of lower version, you can point MICROPY_CPYTHON3 environment var
 # to the correct executable.
-if os.name == 'nt':
-    CPYTHON3 = os.getenv('MICROPY_CPYTHON3', 'python3.exe')
-    MICROPYTHON = os.getenv('MICROPY_MICROPYTHON', '../ports/windows/micropython.exe')
+if os.name == "nt":
+    CPYTHON3 = os.getenv("MICROPY_CPYTHON3", "python3.exe")
+    MICROPYTHON = os.getenv("MICROPY_MICROPYTHON", "../ports/windows/micropython.exe")
 else:
-    CPYTHON3 = os.getenv('MICROPY_CPYTHON3', 'python3')
-    MICROPYTHON = os.getenv('MICROPY_MICROPYTHON', '../ports/unix/micropython')
+    CPYTHON3 = os.getenv("MICROPY_CPYTHON3", "python3")
+    MICROPYTHON = os.getenv("MICROPY_MICROPYTHON", "../ports/unix/micropython")
+
 
 def run_tests(pyb, test_dict):
     test_count = 0
@@ -30,16 +31,18 @@ def run_tests(pyb, test_dict):
             if pyb is None:
                 # run on PC
                 try:
-                    output_mupy = subprocess.check_output([MICROPYTHON, '-X', 'emit=bytecode', test_file[0]])
+                    output_mupy = subprocess.check_output(
+                        [MICROPYTHON, "-X", "emit=bytecode", test_file[0]]
+                    )
                 except subprocess.CalledProcessError:
-                    output_mupy = b'CRASH'
+                    output_mupy = b"CRASH"
             else:
                 # run on pyboard
                 pyb.enter_raw_repl()
                 try:
-                    output_mupy = pyb.execfile(test_file).replace(b'\r\n', b'\n')
+                    output_mupy = pyb.execfile(test_file).replace(b"\r\n", b"\n")
                 except pyboard.PyboardError:
-                    output_mupy = b'CRASH'
+                    output_mupy = b"CRASH"
 
             output_mupy = float(output_mupy.strip())
             test_file[1] = output_mupy
@@ -57,16 +60,18 @@ def run_tests(pyb, test_dict):
     # all tests succeeded
     return True
 
+
 def main():
-    cmd_parser = argparse.ArgumentParser(description='Run tests for MicroPython.')
-    cmd_parser.add_argument('--pyboard', action='store_true', help='run the tests on the pyboard')
-    cmd_parser.add_argument('files', nargs='*', help='input test files')
+    cmd_parser = argparse.ArgumentParser(description="Run tests for MicroPython.")
+    cmd_parser.add_argument("--pyboard", action="store_true", help="run the tests on the pyboard")
+    cmd_parser.add_argument("files", nargs="*", help="input test files")
     args = cmd_parser.parse_args()
 
     # Note pyboard support is copied over from run-tests, not testes, and likely needs revamping
     if args.pyboard:
         import pyboard
-        pyb = pyboard.Pyboard('/dev/ttyACM0')
+
+        pyb = pyboard.Pyboard("/dev/ttyACM0")
         pyb.enter_raw_repl()
     else:
         pyb = None
@@ -74,11 +79,15 @@ def main():
     if len(args.files) == 0:
         if pyb is None:
             # run PC tests
-            test_dirs = ('bench',)
+            test_dirs = ("internal_bench",)
         else:
             # run pyboard tests
-            test_dirs = ('basics', 'float', 'pyb')
-        tests = sorted(test_file for test_files in (glob('{}/*.py'.format(dir)) for dir in test_dirs) for test_file in test_files)
+            test_dirs = ("basics", "float", "pyb")
+        tests = sorted(
+            test_file
+            for test_files in (glob("{}/*.py".format(dir)) for dir in test_dirs)
+            for test_file in test_files
+        )
     else:
         # tests explicitly given
         tests = sorted(args.files)
@@ -93,5 +102,6 @@ def main():
     if not run_tests(pyb, test_dict):
         sys.exit(1)
 
+
 if __name__ == "__main__":
     main()
diff --git a/tests/run-multitests.py b/tests/run-multitests.py
new file mode 100755
index 0000000000000..c83895fb65f37
--- /dev/null
+++ b/tests/run-multitests.py
@@ -0,0 +1,435 @@
+#!/usr/bin/env python3
+
+# This file is part of the MicroPython project, http://micropython.org/
+# The MIT License (MIT)
+# Copyright (c) 2020 Damien P. George
+
+import sys, os, time, re, select
+import argparse
+import subprocess
+
+sys.path.append("../tools")
+import pyboard
+
+if os.name == "nt":
+    CPYTHON3 = os.getenv("MICROPY_CPYTHON3", "python3.exe")
+    MICROPYTHON = os.getenv("MICROPY_MICROPYTHON", "../ports/windows/micropython.exe")
+else:
+    CPYTHON3 = os.getenv("MICROPY_CPYTHON3", "python3")
+    MICROPYTHON = os.getenv("MICROPY_MICROPYTHON", "../ports/unix/micropython")
+
+PYTHON_TRUTH = CPYTHON3
+
+INSTANCE_READ_TIMEOUT_S = 10
+
+APPEND_CODE_TEMPLATE = """
+import sys
+class multitest:
+    @staticmethod
+    def flush():
+        if hasattr(sys.stdout, "flush"):
+            sys.stdout.flush()
+    @staticmethod
+    def skip():
+        print("SKIP")
+        multitest.flush()
+        raise SystemExit
+    @staticmethod
+    def next():
+        print("NEXT")
+        multitest.flush()
+    @staticmethod
+    def globals(**gs):
+        for g in gs:
+            print("SET {{}} = {{!r}}".format(g, gs[g]))
+        multitest.flush()
+    @staticmethod
+    def get_network_ip():
+        try:
+            import network
+            ip = network.WLAN().ifconfig()[0]
+        except:
+            ip = "127.0.0.1"
+        return ip
+
+{}
+
+instance{}()
+multitest.flush()
+"""
+
+# The btstack implementation on Unix generates some spurious output that we
+# can't control.
+IGNORE_OUTPUT_MATCHES = (
+    "libusb: error ",  # It tries to open devices that it doesn't have access to (libusb prints unconditionally).
+    "hci_transport_h2_libusb.c",  # Same issue. We enable LOG_ERROR in btstack.
+    "USB Path: ",  # Hardcoded in btstack's libusb transport.
+    "hci_number_completed_packet",  # Warning from btstack.
+)
+
+
+class PyInstance:
+    def __init__(self):
+        pass
+
+    def close(self):
+        pass
+
+    def prepare_script_from_file(self, filename, prepend, append):
+        with open(filename, "rb") as f:
+            script = f.read()
+        if prepend:
+            script = bytes(prepend, "ascii") + b"\n" + script
+        if append:
+            script += b"\n" + bytes(append, "ascii")
+        return script
+
+    def run_file(self, filename, prepend="", append=""):
+        return self.run_script(self.prepare_script_from_file(filename, prepend, append))
+
+    def start_file(self, filename, prepend="", append=""):
+        return self.start_script(self.prepare_script_from_file(filename, prepend, append))
+
+
+class PyInstanceSubProcess(PyInstance):
+    def __init__(self, cmd):
+        self.cmd = cmd
+        self.popen = None
+        self.finished = True
+
+    def __str__(self):
+        return self.cmd[0].rsplit("/")[-1]
+
+    def run_script(self, script):
+        output = b""
+        err = None
+        try:
+            p = subprocess.run(
+                self.cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, input=script
+            )
+            output = p.stdout
+        except subprocess.CalledProcessError as er:
+            err = er
+        return str(output.strip(), "ascii"), err
+
+    def start_script(self, script):
+        self.popen = subprocess.Popen(
+            self.cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+        )
+        self.popen.stdin.write(script)
+        self.popen.stdin.close()
+        self.finished = False
+
+    def stop(self):
+        if self.popen and self.popen.poll() is None:
+            self.popen.terminate()
+
+    def readline(self):
+        sel = select.select([self.popen.stdout.raw], [], [], 0.1)
+        if not sel[0]:
+            self.finished = self.popen.poll() is not None
+            return None, None
+        out = self.popen.stdout.raw.readline()
+        if out == b"":
+            self.finished = self.popen.poll() is not None
+            return None, None
+        else:
+            return str(out.rstrip(), "ascii"), None
+
+    def is_finished(self):
+        return self.finished
+
+    def wait_finished(self):
+        self.popen.wait()
+        out = self.popen.stdout.read()
+        return str(out, "ascii"), ""
+
+
+class PyInstancePyboard(PyInstance):
+    def __init__(self, device):
+        self.device = device
+        self.pyb = pyboard.Pyboard(device)
+        self.pyb.enter_raw_repl()
+        self.finished = True
+
+    def __str__(self):
+        return self.device.rsplit("/")[-1]
+
+    def close(self):
+        self.pyb.exit_raw_repl()
+        self.pyb.close()
+
+    def run_script(self, script):
+        output = b""
+        err = None
+        try:
+            self.pyb.enter_raw_repl()
+            output = self.pyb.exec_(script)
+        except pyboard.PyboardError as er:
+            err = er
+        return str(output.strip(), "ascii"), err
+
+    def start_script(self, script):
+        self.pyb.enter_raw_repl()
+        self.pyb.exec_raw_no_follow(script)
+        self.finished = False
+
+    def stop(self):
+        self.pyb.serial.write(b"\r\x03")
+
+    def readline(self):
+        if self.finished:
+            return None, None
+        if self.pyb.serial.inWaiting() == 0:
+            return None, None
+        out = self.pyb.read_until(1, (b"\r\n", b"\x04"))
+        if out.endswith(b"\x04"):
+            self.finished = True
+            out = out[:-1]
+            err = str(self.pyb.read_until(1, b"\x04"), "ascii")
+            err = err[:-1]
+            if not out and not err:
+                return None, None
+        else:
+            err = None
+        return str(out.rstrip(), "ascii"), err
+
+    def is_finished(self):
+        return self.finished
+
+    def wait_finished(self):
+        out, err = self.pyb.follow(10, None)
+        return str(out, "ascii"), str(err, "ascii")
+
+
+def prepare_test_file_list(test_files):
+    test_files2 = []
+    for test_file in sorted(test_files):
+        num_instances = 0
+        with open(test_file) as f:
+            for line in f:
+                m = re.match(r"def instance([0-9]+)\(\):", line)
+                if m:
+                    num_instances = max(num_instances, int(m.group(1)) + 1)
+        test_files2.append((test_file, num_instances))
+    return test_files2
+
+
+def trace_instance_output(instance_idx, line):
+    if cmd_args.trace_output:
+        t_ms = round((time.time() - trace_t0) * 1000)
+        print("{:6} i{} :".format(t_ms, instance_idx), line)
+
+
+def run_test_on_instances(test_file, num_instances, instances):
+    global trace_t0
+    trace_t0 = time.time()
+
+    error = False
+    skip = False
+    injected_globals = ""
+    output = [[] for _ in range(num_instances)]
+
+    if cmd_args.trace_output:
+        print("TRACE {}:".format("|".join(str(i) for i in instances)))
+
+    # Start all instances running, in order, waiting until they signal they are ready
+    for idx in range(num_instances):
+        append_code = APPEND_CODE_TEMPLATE.format(injected_globals, idx)
+        instance = instances[idx]
+        instance.start_file(test_file, append=append_code)
+        last_read_time = time.time()
+        while True:
+            if instance.is_finished():
+                break
+            out, err = instance.readline()
+            if out is None and err is None:
+                if time.time() > last_read_time + INSTANCE_READ_TIMEOUT_S:
+                    output[idx].append("TIMEOUT")
+                    error = True
+                    break
+                time.sleep(0.1)
+                continue
+            last_read_time = time.time()
+            if out is not None and not any(m in out for m in IGNORE_OUTPUT_MATCHES):
+                trace_instance_output(idx, out)
+                if out.startswith("SET "):
+                    injected_globals += out[4:] + "\n"
+                elif out == "SKIP":
+                    skip = True
+                    break
+                elif out == "NEXT":
+                    break
+                else:
+                    output[idx].append(out)
+            if err is not None:
+                trace_instance_output(idx, err)
+                output[idx].append(err)
+                error = True
+
+        if error or skip:
+            break
+
+    if not error and not skip:
+        # Capture output and wait for all instances to finish running
+        last_read_time = [time.time() for _ in range(num_instances)]
+        while True:
+            num_running = 0
+            num_output = 0
+            for idx in range(num_instances):
+                instance = instances[idx]
+                if instance.is_finished():
+                    continue
+                num_running += 1
+                out, err = instance.readline()
+                if out is None and err is None:
+                    if time.time() > last_read_time[idx] + INSTANCE_READ_TIMEOUT_S:
+                        output[idx].append("TIMEOUT")
+                        error = True
+                    continue
+                num_output += 1
+                last_read_time[idx] = time.time()
+                if out is not None:
+                    trace_instance_output(idx, out)
+                    output[idx].append(out)
+                if err is not None:
+                    trace_instance_output(idx, err)
+                    output[idx].append(err)
+                    error = True
+
+            if not num_output:
+                time.sleep(0.1)
+            if not num_running or error:
+                break
+
+    # Stop all instances
+    for idx in range(num_instances):
+        instances[idx].stop()
+
+    output_str = ""
+    for idx, lines in enumerate(output):
+        output_str += "--- instance{} ---\n".format(idx)
+        output_str += "\n".join(lines) + "\n"
+
+    return error, skip, output_str
+
+
+def run_tests(test_files, instances_truth, instances_test):
+    skipped_tests = []
+    passed_tests = []
+    failed_tests = []
+
+    for test_file, num_instances in test_files:
+        instances_str = "|".join(str(instances_test[i]) for i in range(num_instances))
+        print("{} on {}: ".format(test_file, instances_str), end="")
+        if cmd_args.show_output or cmd_args.trace_output:
+            print()
+        sys.stdout.flush()
+
+        # Run test on test instances
+        error, skip, output_test = run_test_on_instances(test_file, num_instances, instances_test)
+
+        if not skip:
+            # Check if truth exists in a file, and read it in
+            test_file_expected = test_file + ".exp"
+            if os.path.isfile(test_file_expected):
+                with open(test_file_expected) as f:
+                    output_truth = f.read()
+            else:
+                # Run test on truth instances to get expected output
+                _, _, output_truth = run_test_on_instances(
+                    test_file, num_instances, instances_truth
+                )
+
+        if cmd_args.show_output:
+            print("### TEST ###")
+            print(output_test, end="")
+            if not skip:
+                print("### TRUTH ###")
+                print(output_truth, end="")
+
+        # Print result of test
+        if skip:
+            print("skip")
+            skipped_tests.append(test_file)
+        elif output_test == output_truth:
+            print("pass")
+            passed_tests.append(test_file)
+        else:
+            print("FAIL")
+            failed_tests.append(test_file)
+            if not cmd_args.show_output:
+                print("### TEST ###")
+                print(output_test, end="")
+                print("### TRUTH ###")
+                print(output_truth, end="")
+
+        if cmd_args.show_output:
+            print()
+
+    print("{} tests performed".format(len(skipped_tests) + len(passed_tests) + len(failed_tests)))
+    print("{} tests passed".format(len(passed_tests)))
+
+    if skipped_tests:
+        print("{} tests skipped: {}".format(len(skipped_tests), " ".join(skipped_tests)))
+    if failed_tests:
+        print("{} tests failed: {}".format(len(failed_tests), " ".join(failed_tests)))
+
+    return not failed_tests
+
+
+def main():
+    global cmd_args
+
+    cmd_parser = argparse.ArgumentParser(description="Run network tests for MicroPython")
+    cmd_parser.add_argument(
+        "-s", "--show-output", action="store_true", help="show test output after running"
+    )
+    cmd_parser.add_argument(
+        "-t", "--trace-output", action="store_true", help="trace test output while running"
+    )
+    cmd_parser.add_argument(
+        "-i", "--instance", action="append", default=[], help="instance(s) to run the tests on"
+    )
+    cmd_parser.add_argument("files", nargs="+", help="input test files")
+    cmd_args = cmd_parser.parse_args()
+
+    # clear search path to make sure tests use only builtin modules and those in extmod
+    os.environ["MICROPYPATH"] = os.pathsep + "../extmod"
+
+    test_files = prepare_test_file_list(cmd_args.files)
+    max_instances = max(t[1] for t in test_files)
+
+    instances_truth = [PyInstanceSubProcess([PYTHON_TRUTH]) for _ in range(max_instances)]
+
+    instances_test = []
+    for i in cmd_args.instance:
+        if i.startswith("exec:"):
+            instances_test.append(PyInstanceSubProcess([i[len("exec:") :]]))
+        elif i == "micropython":
+            instances_test.append(PyInstanceSubProcess([MICROPYTHON]))
+        elif i == "cpython":
+            instances_test.append(PyInstanceSubProcess([CPYTHON3]))
+        elif i.startswith("pyb:"):
+            instances_test.append(PyInstancePyboard(i[len("pyb:") :]))
+        else:
+            print("unknown instance string: {}".format(i), file=sys.stderr)
+            sys.exit(1)
+
+    for _ in range(max_instances - len(instances_test)):
+        instances_test.append(PyInstanceSubProcess([MICROPYTHON]))
+
+    try:
+        all_pass = run_tests(test_files, instances_truth, instances_test)
+    finally:
+        for i in instances_truth:
+            i.close()
+        for i in instances_test:
+            i.close()
+
+    if not all_pass:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/run-natmodtests.py b/tests/run-natmodtests.py
new file mode 100755
index 0000000000000..f88ca0b788971
--- /dev/null
+++ b/tests/run-natmodtests.py
@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+
+# This file is part of the MicroPython project, http://micropython.org/
+# The MIT License (MIT)
+# Copyright (c) 2019 Damien P. George
+
+import os
+import subprocess
+import sys
+import argparse
+
+sys.path.append("../tools")
+import pyboard
+
+# Paths for host executables
+CPYTHON3 = os.getenv("MICROPY_CPYTHON3", "python3")
+MICROPYTHON = os.getenv("MICROPY_MICROPYTHON", "../ports/unix/micropython-coverage")
+
+NATMOD_EXAMPLE_DIR = "../examples/natmod/"
+
+# Supported tests and their corresponding mpy module
+TEST_MAPPINGS = {
+    "btree": "btree/btree_$(ARCH).mpy",
+    "framebuf": "framebuf/framebuf_$(ARCH).mpy",
+    "uheapq": "uheapq/uheapq_$(ARCH).mpy",
+    "urandom": "urandom/urandom_$(ARCH).mpy",
+    "ure": "ure/ure_$(ARCH).mpy",
+    "uzlib": "uzlib/uzlib_$(ARCH).mpy",
+}
+
+# Code to allow a target MicroPython to import an .mpy from RAM
+injected_import_hook_code = """\
+import sys, uos, uio
+class __File(uio.IOBase):
+  def __init__(self):
+    self.off = 0
+  def ioctl(self, request, arg):
+    return 0
+  def readinto(self, buf):
+    buf[:] = memoryview(__buf)[self.off:self.off + len(buf)]
+    self.off += len(buf)
+    return len(buf)
+class __FS:
+  def mount(self, readonly, mkfs):
+    pass
+  def chdir(self, path):
+    pass
+  def stat(self, path):
+    if path == '__injected.mpy':
+      return tuple(0 for _ in range(10))
+    else:
+      raise OSError(-2) # ENOENT
+  def open(self, path, mode):
+    return __File()
+uos.mount(__FS(), '/__remote')
+uos.chdir('/__remote')
+sys.modules['{}'] = __import__('__injected')
+"""
+
+
+class TargetSubprocess:
+    def __init__(self, cmd):
+        self.cmd = cmd
+
+    def close(self):
+        pass
+
+    def run_script(self, script):
+        try:
+            p = subprocess.run(
+                self.cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, input=script
+            )
+            return p.stdout, None
+        except subprocess.CalledProcessError as er:
+            return b"", er
+
+
+class TargetPyboard:
+    def __init__(self, pyb):
+        self.pyb = pyb
+        self.pyb.enter_raw_repl()
+
+    def close(self):
+        self.pyb.exit_raw_repl()
+        self.pyb.close()
+
+    def run_script(self, script):
+        try:
+            self.pyb.enter_raw_repl()
+            output = self.pyb.exec_(script)
+            output = output.replace(b"\r\n", b"\n")
+            return output, None
+        except pyboard.PyboardError as er:
+            return b"", er
+
+
+def run_tests(target_truth, target, args, stats):
+    for test_file in args.files:
+        # Find supported test
+        for k, v in TEST_MAPPINGS.items():
+            if test_file.find(k) != -1:
+                test_module = k
+                test_mpy = v.replace("$(ARCH)", args.arch)
+                break
+        else:
+            print("----  {} - no matching mpy".format(test_file))
+            continue
+
+        # Read test script
+        with open(test_file, "rb") as f:
+            test_file_data = f.read()
+
+        # Create full test with embedded .mpy
+        try:
+            with open(NATMOD_EXAMPLE_DIR + test_mpy, "rb") as f:
+                test_script = b"__buf=" + bytes(repr(f.read()), "ascii") + b"\n"
+        except OSError:
+            print("----  {} - mpy file not compiled".format(test_file))
+            continue
+        test_script += bytes(injected_import_hook_code.format(test_module), "ascii")
+        test_script += test_file_data
+
+        # Run test under MicroPython
+        result_out, error = target.run_script(test_script)
+
+        # Work out result of test
+        extra = ""
+        if error is None and result_out == b"SKIP\n":
+            result = "SKIP"
+        elif error is not None:
+            result = "FAIL"
+            extra = " - " + str(error)
+        else:
+            # Check result against truth
+            try:
+                with open(test_file + ".exp", "rb") as f:
+                    result_exp = f.read()
+                error = None
+            except OSError:
+                result_exp, error = target_truth.run_script(test_file_data)
+            if error is not None:
+                result = "TRUTH FAIL"
+            elif result_out != result_exp:
+                result = "FAIL"
+                print(result_out)
+            else:
+                result = "pass"
+
+        # Accumulate statistics
+        stats["total"] += 1
+        if result == "pass":
+            stats["pass"] += 1
+        elif result == "SKIP":
+            stats["skip"] += 1
+        else:
+            stats["fail"] += 1
+
+        # Print result
+        print("{:4}  {}{}".format(result, test_file, extra))
+
+
+def main():
+    cmd_parser = argparse.ArgumentParser(
+        description="Run dynamic-native-module tests under MicroPython"
+    )
+    cmd_parser.add_argument(
+        "-p", "--pyboard", action="store_true", help="run tests via pyboard.py"
+    )
+    cmd_parser.add_argument(
+        "-d", "--device", default="/dev/ttyACM0", help="the device for pyboard.py"
+    )
+    cmd_parser.add_argument(
+        "-a", "--arch", default="x64", help="native architecture of the target"
+    )
+    cmd_parser.add_argument("files", nargs="*", help="input test files")
+    args = cmd_parser.parse_args()
+
+    target_truth = TargetSubprocess([CPYTHON3])
+
+    if args.pyboard:
+        target = TargetPyboard(pyboard.Pyboard(args.device))
+    else:
+        target = TargetSubprocess([MICROPYTHON])
+
+    stats = {"total": 0, "pass": 0, "fail": 0, "skip": 0}
+    run_tests(target_truth, target, args, stats)
+
+    target.close()
+    target_truth.close()
+
+    print("{} tests performed".format(stats["total"]))
+    print("{} tests passed".format(stats["pass"]))
+    if stats["fail"]:
+        print("{} tests failed".format(stats["fail"]))
+    if stats["skip"]:
+        print("{} tests skipped".format(stats["skip"]))
+
+    if stats["fail"]:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/run-perfbench.py b/tests/run-perfbench.py
new file mode 100755
index 0000000000000..8b71ae64ce2b2
--- /dev/null
+++ b/tests/run-perfbench.py
@@ -0,0 +1,281 @@
+#!/usr/bin/env python3
+
+# This file is part of the MicroPython project, http://micropython.org/
+# The MIT License (MIT)
+# Copyright (c) 2019 Damien P. George
+
+import os
+import subprocess
+import sys
+import argparse
+from glob import glob
+
+sys.path.append("../tools")
+import pyboard
+
+# Paths for host executables
+if os.name == "nt":
+    CPYTHON3 = os.getenv("MICROPY_CPYTHON3", "python3.exe")
+    MICROPYTHON = os.getenv("MICROPY_MICROPYTHON", "../ports/windows/micropython.exe")
+else:
+    CPYTHON3 = os.getenv("MICROPY_CPYTHON3", "python3")
+    MICROPYTHON = os.getenv("MICROPY_MICROPYTHON", "../ports/unix/micropython")
+
+PYTHON_TRUTH = CPYTHON3
+
+BENCH_SCRIPT_DIR = "perf_bench/"
+
+
+def compute_stats(lst):
+    avg = 0
+    var = 0
+    for x in lst:
+        avg += x
+        var += x * x
+    avg /= len(lst)
+    var = max(0, var / len(lst) - avg ** 2)
+    return avg, var ** 0.5
+
+
+def run_script_on_target(target, script):
+    output = b""
+    err = None
+
+    if isinstance(target, pyboard.Pyboard):
+        # Run via pyboard interface
+        try:
+            target.enter_raw_repl()
+            output = target.exec_(script)
+        except pyboard.PyboardError as er:
+            err = er
+    else:
+        # Run local executable
+        try:
+            p = subprocess.run(
+                target, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, input=script
+            )
+            output = p.stdout
+        except subprocess.CalledProcessError as er:
+            err = er
+
+    return str(output.strip(), "ascii"), err
+
+
+def run_feature_test(target, test):
+    with open("feature_check/" + test + ".py", "rb") as f:
+        script = f.read()
+    output, err = run_script_on_target(target, script)
+    if err is None:
+        return output
+    else:
+        return "CRASH: %r" % err
+
+
+def run_benchmark_on_target(target, script):
+    output, err = run_script_on_target(target, script)
+    if err is None:
+        time, norm, result = output.split(None, 2)
+        try:
+            return int(time), int(norm), result
+        except ValueError:
+            return -1, -1, "CRASH: %r" % output
+    else:
+        return -1, -1, "CRASH: %r" % err
+
+
+def run_benchmarks(target, param_n, param_m, n_average, test_list):
+    skip_complex = run_feature_test(target, "complex") != "complex"
+    skip_native = run_feature_test(target, "native_check") != ""
+
+    for test_file in sorted(test_list):
+        print(test_file + ": ", end="")
+
+        # Check if test should be skipped
+        skip = (
+            skip_complex
+            and test_file.find("bm_fft") != -1
+            or skip_native
+            and test_file.find("viper_") != -1
+        )
+        if skip:
+            print("skip")
+            continue
+
+        # Create test script
+        with open(test_file, "rb") as f:
+            test_script = f.read()
+        with open(BENCH_SCRIPT_DIR + "benchrun.py", "rb") as f:
+            test_script += f.read()
+        test_script += b"bm_run(%u, %u)\n" % (param_n, param_m)
+
+        # Write full test script if needed
+        if 0:
+            with open("%s.full" % test_file, "wb") as f:
+                f.write(test_script)
+
+        # Run MicroPython a given number of times
+        times = []
+        scores = []
+        error = None
+        result_out = None
+        for _ in range(n_average):
+            time, norm, result = run_benchmark_on_target(target, test_script)
+            if time < 0 or norm < 0:
+                error = result
+                break
+            if result_out is None:
+                result_out = result
+            elif result != result_out:
+                error = "FAIL self"
+                break
+            times.append(time)
+            scores.append(1e6 * norm / time)
+
+        # Check result against truth if needed
+        if error is None and result_out != "None":
+            _, _, result_exp = run_benchmark_on_target(PYTHON_TRUTH, test_script)
+            if result_out != result_exp:
+                error = "FAIL truth"
+
+        if error is not None:
+            print(error)
+        else:
+            t_avg, t_sd = compute_stats(times)
+            s_avg, s_sd = compute_stats(scores)
+            print(
+                "{:.2f} {:.4f} {:.2f} {:.4f}".format(
+                    t_avg, 100 * t_sd / t_avg, s_avg, 100 * s_sd / s_avg
+                )
+            )
+            if 0:
+                print("  times: ", times)
+                print("  scores:", scores)
+
+        sys.stdout.flush()
+
+
+def parse_output(filename):
+    with open(filename) as f:
+        params = f.readline()
+        n, m, _ = params.strip().split()
+        n = int(n.split("=")[1])
+        m = int(m.split("=")[1])
+        data = []
+        for l in f:
+            if l.find(": ") != -1 and l.find(": skip") == -1 and l.find("CRASH: ") == -1:
+                name, values = l.strip().split(": ")
+                values = tuple(float(v) for v in values.split())
+                data.append((name,) + values)
+    return n, m, data
+
+
+def compute_diff(file1, file2, diff_score):
+    # Parse output data from previous runs
+    n1, m1, d1 = parse_output(file1)
+    n2, m2, d2 = parse_output(file2)
+
+    # Print header
+    if diff_score:
+        print("diff of scores (higher is better)")
+    else:
+        print("diff of microsecond times (lower is better)")
+    if n1 == n2 and m1 == m2:
+        hdr = "N={} M={}".format(n1, m1)
+    else:
+        hdr = "N={} M={} vs N={} M={}".format(n1, m1, n2, m2)
+    print(
+        "{:24} {:>10} -> {:>10}   {:>10}   {:>7}% (error%)".format(
+            hdr, file1, file2, "diff", "diff"
+        )
+    )
+
+    # Print entries
+    while d1 and d2:
+        if d1[0][0] == d2[0][0]:
+            # Found entries with matching names
+            entry1 = d1.pop(0)
+            entry2 = d2.pop(0)
+            name = entry1[0].rsplit("/")[-1]
+            av1, sd1 = entry1[1 + 2 * diff_score], entry1[2 + 2 * diff_score]
+            av2, sd2 = entry2[1 + 2 * diff_score], entry2[2 + 2 * diff_score]
+            sd1 *= av1 / 100  # convert from percent sd to absolute sd
+            sd2 *= av2 / 100  # convert from percent sd to absolute sd
+            av_diff = av2 - av1
+            sd_diff = (sd1 ** 2 + sd2 ** 2) ** 0.5
+            percent = 100 * av_diff / av1
+            percent_sd = 100 * sd_diff / av1
+            print(
+                "{:24} {:10.2f} -> {:10.2f} : {:+10.2f} = {:+7.3f}% (+/-{:.2f}%)".format(
+                    name, av1, av2, av_diff, percent, percent_sd
+                )
+            )
+        elif d1[0][0] < d2[0][0]:
+            d1.pop(0)
+        else:
+            d2.pop(0)
+
+
+def main():
+    cmd_parser = argparse.ArgumentParser(description="Run benchmarks for MicroPython")
+    cmd_parser.add_argument(
+        "-t", "--diff-time", action="store_true", help="diff time outputs from a previous run"
+    )
+    cmd_parser.add_argument(
+        "-s", "--diff-score", action="store_true", help="diff score outputs from a previous run"
+    )
+    cmd_parser.add_argument(
+        "-p", "--pyboard", action="store_true", help="run tests via pyboard.py"
+    )
+    cmd_parser.add_argument(
+        "-d", "--device", default="/dev/ttyACM0", help="the device for pyboard.py"
+    )
+    cmd_parser.add_argument("-a", "--average", default="8", help="averaging number")
+    cmd_parser.add_argument(
+        "--emit", default="bytecode", help="MicroPython emitter to use (bytecode or native)"
+    )
+    cmd_parser.add_argument("N", nargs=1, help="N parameter (approximate target CPU frequency)")
+    cmd_parser.add_argument("M", nargs=1, help="M parameter (approximate target heap in kbytes)")
+    cmd_parser.add_argument("files", nargs="*", help="input test files")
+    args = cmd_parser.parse_args()
+
+    if args.diff_time or args.diff_score:
+        compute_diff(args.N[0], args.M[0], args.diff_score)
+        sys.exit(0)
+
+    # N, M = 50, 25 # esp8266
+    # N, M = 100, 100 # pyboard, esp32
+    # N, M = 1000, 1000 # PC
+    N = int(args.N[0])
+    M = int(args.M[0])
+    n_average = int(args.average)
+
+    if args.pyboard:
+        target = pyboard.Pyboard(args.device)
+        target.enter_raw_repl()
+    else:
+        target = [MICROPYTHON, "-X", "emit=" + args.emit]
+
+    if len(args.files) == 0:
+        tests_skip = ("benchrun.py",)
+        if M <= 25:
+            # These scripts are too big to be compiled by the target
+            tests_skip += ("bm_chaos.py", "bm_hexiom.py", "misc_raytrace.py")
+        tests = sorted(
+            BENCH_SCRIPT_DIR + test_file
+            for test_file in os.listdir(BENCH_SCRIPT_DIR)
+            if test_file.endswith(".py") and test_file not in tests_skip
+        )
+    else:
+        tests = sorted(args.files)
+
+    print("N={} M={} n_average={}".format(N, M, n_average))
+
+    run_benchmarks(target, N, M, n_average, tests)
+
+    if isinstance(target, pyboard.Pyboard):
+        target.exit_raw_repl()
+        target.close()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/run-tests b/tests/run-tests
index 9f74c1cfcc47b..74e2f71ac6480 100755
--- a/tests/run-tests
+++ b/tests/run-tests
@@ -21,6 +21,9 @@ else:
 # mpy-cross is only needed if --via-mpy command-line arg is passed
 MPYCROSS = os.getenv('MICROPY_MPYCROSS', '../mpy-cross/mpy-cross')
 
+# For diff'ing test output
+DIFF = os.getenv('MICROPY_DIFF', 'diff -u')
+
 # Set PYTHONIOENCODING so that CPython will use utf-8 on systems which set another encoding in the locale
 os.environ['PYTHONIOENCODING'] = 'utf-8'
 
@@ -53,6 +56,7 @@ def run_micropython(pyb, args, test_file, is_special=False):
     special_tests = (
         'micropython/meminfo.py', 'basics/bytes_compare3.py',
         'basics/builtin_help.py', 'thread/thread_exc2.py',
+        'esp32/partition_ota.py',
     )
     had_crash = False
     if pyb is None:
@@ -130,7 +134,7 @@ def run_micropython(pyb, args, test_file, is_special=False):
 
             # if running via .mpy, first compile the .py file
             if args.via_mpy:
-                subprocess.check_output([MPYCROSS, '-mcache-lookup-bc', '-o', 'mpytest.mpy', '-X', 'emit=' + args.emit, test_file])
+                subprocess.check_output([MPYCROSS] + args.mpy_cross_flags.split() + ['-o', 'mpytest.mpy', '-X', 'emit=' + args.emit, test_file])
                 cmdlist.extend(['-m', 'mpytest'])
             else:
                 cmdlist.append(test_file)
@@ -208,6 +212,9 @@ def run_micropython(pyb, args, test_file, is_special=False):
 
 
 def run_feature_check(pyb, args, base_path, test_file):
+    if pyb is not None and test_file.startswith("repl_"):
+        # REPL feature tests will not run via pyboard because they require prompt interactivity
+        return b""
     return run_micropython(pyb, args, base_path + "/feature_check/" + test_file, is_special=True)
 
 
@@ -221,10 +228,13 @@ def run_tests(pyb, tests, args, base_path="."):
     skip_tests = set()
     skip_native = False
     skip_int_big = False
+    skip_bytearray = False
     skip_set_type = False
+    skip_slice = False
     skip_async = False
     skip_const = False
     skip_revops = False
+    skip_io_module = False
     skip_endian = False
     has_complex = True
     has_coverage = False
@@ -244,11 +254,21 @@ def run_tests(pyb, tests, args, base_path="."):
         if output != b'1000000000000000000000000000000000000000000000\n':
             skip_int_big = True
 
+        # Check if bytearray is supported, and skip such tests if it's not
+        output = run_feature_check(pyb, args, base_path, 'bytearray.py')
+        if output != b'bytearray\n':
+            skip_bytearray = True
+
         # Check if set type (and set literals) is supported, and skip such tests if it's not
         output = run_feature_check(pyb, args, base_path, 'set_check.py')
         if output == b'CRASH':
             skip_set_type = True
 
+        # Check if slice is supported, and skip such tests if it's not
+        output = run_feature_check(pyb, args, base_path, 'slice.py')
+        if output != b'slice\n':
+            skip_slice = True
+
         # Check if async/await keywords are supported, and skip such tests if it's not
         output = run_feature_check(pyb, args, base_path, 'async_check.py')
         if output == b'CRASH':
@@ -264,18 +284,48 @@ def run_tests(pyb, tests, args, base_path="."):
         if output == b'TypeError\n':
             skip_revops = True
 
+        # Check if uio module exists, and skip such tests if it doesn't
+        output = run_feature_check(pyb, args, base_path, 'uio_module.py')
+        if output != b'uio\n':
+            skip_io_module = True
+
         # Check if emacs repl is supported, and skip such tests if it's not
         t = run_feature_check(pyb, args, base_path, 'repl_emacs_check.py')
-        if not 'True' in str(t, 'ascii'):
+        if 'True' not in str(t, 'ascii'):
             skip_tests.add('cmdline/repl_emacs_keys.py')
 
+        # Check if words movement in repl is supported, and skip such tests if it's not
+        t = run_feature_check(pyb, args, base_path, 'repl_words_move_check.py')
+        if 'True' not in str(t, 'ascii'):
+            skip_tests.add('cmdline/repl_words_move.py')
+
         upy_byteorder = run_feature_check(pyb, args, base_path, 'byteorder.py')
-        upy_float_precision = int(run_feature_check(pyb, args, base_path, 'float.py'))
+        upy_float_precision = run_feature_check(pyb, args, base_path, 'float.py')
+        if upy_float_precision == b'CRASH':
+            upy_float_precision = 0
+        else:
+            upy_float_precision = int(upy_float_precision)
         has_complex = run_feature_check(pyb, args, base_path, 'complex.py') == b'complex\n'
         has_coverage = run_feature_check(pyb, args, base_path, 'coverage.py') == b'coverage\n'
         cpy_byteorder = subprocess.check_output([CPYTHON3, base_path + '/feature_check/byteorder.py'])
         skip_endian = (upy_byteorder != cpy_byteorder)
 
+    # These tests don't test slice explicitly but rather use it to perform the test
+    misc_slice_tests = (
+        'builtin_range',
+        'class_super',
+        'containment',
+        'errno1',
+        'fun_str',
+        'generator1',
+        'globals_del',
+        'memoryview1',
+        'memoryview_gc',
+        'object1',
+        'python34',
+        'struct_endian',
+    )
+
     # Some tests shouldn't be run under Travis CI
     if os.getenv('TRAVIS') == 'true':
         skip_tests.add('basics/memoryerror.py')
@@ -341,14 +391,14 @@ def run_tests(pyb, tests, args, base_path="."):
             skip_tests.add('micropython/opt_level.py')      # don't assume line numbers are stored
         elif args.target == 'nrf':
             skip_tests.add('basics/memoryview1.py')         # no item assignment for memoryview
-            skip_tests.add('extmod/ticks_diff.py')          # unimplemented: utime.ticks_diff
-            skip_tests.add('extmod/time_ms_us.py')          # unimplemented: utime.ticks_ms
             skip_tests.add('extmod/urandom_basic.py')       # unimplemented: urandom.seed
             skip_tests.add('micropython/opt_level.py')      # no support for line numbers
             skip_tests.add('misc/non_compliant.py')         # no item assignment for bytearray
             for t in tests:
                 if t.startswith('basics/io_'):
                     skip_tests.add(t)
+        elif args.target == 'qemu-arm':
+            skip_tests.add('misc/print_exception.py')       # requires sys stdfiles
 
     # Some tests are known to fail on 64-bit machines
     if pyb is None and platform.architecture()[0] == '64bit':
@@ -370,11 +420,13 @@ def run_tests(pyb, tests, args, base_path="."):
         skip_tests.add('basics/scope_implicit.py') # requires checking for unbound local
         skip_tests.add('basics/try_finally_return2.py') # requires raise_varargs
         skip_tests.add('basics/unboundlocal.py') # requires checking for unbound local
+        skip_tests.add('extmod/uasyncio_lock.py') # requires async with
         skip_tests.add('misc/features.py') # requires raise_varargs
         skip_tests.add('misc/print_exception.py') # because native doesn't have proper traceback info
         skip_tests.add('misc/sys_exc_info.py') # sys.exc_info() is not supported for native
         skip_tests.add('micropython/emg_exc.py') # because native doesn't have proper traceback info
         skip_tests.add('micropython/heapalloc_traceback.py') # because native doesn't have proper traceback info
+        skip_tests.add('micropython/opt_level_lineno.py') # native doesn't have proper traceback info
         skip_tests.add('micropython/schedule.py') # native code doesn't check pending events
 
     for test_file in tests:
@@ -391,21 +443,27 @@ def run_tests(pyb, tests, args, base_path="."):
 
         test_basename = test_file.replace('..', '_').replace('./', '').replace('/', '_')
         test_name = os.path.splitext(os.path.basename(test_file))[0]
-        is_native = test_name.startswith("native_") or test_name.startswith("viper_")
+        is_native = test_name.startswith("native_") or test_name.startswith("viper_") or args.emit == "native"
         is_endian = test_name.endswith("_endian")
         is_int_big = test_name.startswith("int_big") or test_name.endswith("_intbig")
+        is_bytearray = test_name.startswith("bytearray") or test_name.endswith("_bytearray")
         is_set_type = test_name.startswith("set_") or test_name.startswith("frozenset")
-        is_async = test_name.startswith("async_")
+        is_slice = test_name.find("slice") != -1 or test_name in misc_slice_tests
+        is_async = test_name.startswith(("async_", "uasyncio_"))
         is_const = test_name.startswith("const")
+        is_io_module = test_name.startswith("io_")
 
         skip_it = test_file in skip_tests
         skip_it |= skip_native and is_native
         skip_it |= skip_endian and is_endian
         skip_it |= skip_int_big and is_int_big
+        skip_it |= skip_bytearray and is_bytearray
         skip_it |= skip_set_type and is_set_type
+        skip_it |= skip_slice and is_slice
         skip_it |= skip_async and is_async
         skip_it |= skip_const and is_const
         skip_it |= skip_revops and test_name.startswith("class_reverse_op")
+        skip_it |= skip_io_module and is_io_module
 
         if args.list_tests:
             if not skip_it:
@@ -501,12 +559,19 @@ class append_filter(argparse.Action):
 def main():
     cmd_parser = argparse.ArgumentParser(
         formatter_class=argparse.RawDescriptionHelpFormatter,
-        description='Run and manage tests for MicroPython.',
+        description='''Run and manage tests for MicroPython.
+
+When running tests, run-tests compares the MicroPython output of the test with the output
+produced by running the test through CPython unless a <test>.exp file is found, in which
+case it is used as comparison.
+If a test fails, run-tests produces a pair of <test>.out and <test>.exp files in the current
+directory with the MicroPython output and the expectations, respectively.
+''',
         epilog='''\
 Options -i and -e can be multiple and processed in the order given. Regex
 "search" (vs "match") operation is used. An action (include/exclude) of
 the last matching regex is used:
-  run-tests -i async - exclude all, then include tests containg "async" anywhere
+  run-tests -i async - exclude all, then include tests containing "async" anywhere
   run-tests -e '/big.+int' - include all, then exclude by regex
   run-tests -e async -i async_foo - include all, exclude async, yet still include async_foo
 ''')
@@ -518,17 +583,40 @@ the last matching regex is used:
     cmd_parser.add_argument('-d', '--test-dirs', nargs='*', help='input test directories (if no files given)')
     cmd_parser.add_argument('-e', '--exclude', action=append_filter, metavar='REGEX', dest='filters', help='exclude test by regex on path/name.py')
     cmd_parser.add_argument('-i', '--include', action=append_filter, metavar='REGEX', dest='filters', help='include test by regex on path/name.py')
-    cmd_parser.add_argument('--write-exp', action='store_true', help='save .exp files to run tests w/o CPython')
+    cmd_parser.add_argument('--write-exp', action='store_true', help='use CPython to generate .exp files to run tests w/o CPython')
     cmd_parser.add_argument('--list-tests', action='store_true', help='list tests instead of running them')
     cmd_parser.add_argument('--emit', default='bytecode', help='MicroPython emitter to use (bytecode or native)')
     cmd_parser.add_argument('--heapsize', help='heapsize to use (use default if not specified)')
     cmd_parser.add_argument('--via-mpy', action='store_true', help='compile .py files to .mpy first')
+    cmd_parser.add_argument('--mpy-cross-flags', default='-mcache-lookup-bc', help='flags to pass to mpy-cross')
     cmd_parser.add_argument('--keep-path', action='store_true', help='do not clear MICROPYPATH when running tests')
     cmd_parser.add_argument('files', nargs='*', help='input test files')
+    cmd_parser.add_argument('--print-failures', action='store_true', help='print the diff of expected vs. actual output for failed tests and exit')
+    cmd_parser.add_argument('--clean-failures', action='store_true', help='delete the .exp and .out files from failed tests and exit')
     args = cmd_parser.parse_args()
 
+    if args.print_failures:
+        os.chdir(os.path.abspath(os.path.dirname(__file__)))
+
+        for exp in glob("*.exp"):
+            testbase = os.path.basename(exp)[:-4]
+            print()
+            print("FAILURE {0}".format(testbase))
+            os.system("{0} {1}.exp {1}.out".format(DIFF, testbase))
+
+        sys.exit(0)
+
+    if args.clean_failures:
+        os.chdir(os.path.abspath(os.path.dirname(__file__)))
+
+        for f in glob("*.exp") + glob("*.out"):
+            os.remove(f)
+
+        sys.exit(0)
+
+    LOCAL_TARGETS = ('unix', 'qemu-arm',)
     EXTERNAL_TARGETS = ('pyboard', 'wipy', 'esp8266', 'esp32', 'minimal', 'nrf')
-    if args.target == 'unix' or args.list_tests:
+    if args.target in LOCAL_TARGETS or args.list_tests:
         pyb = None
     elif args.target in EXTERNAL_TARGETS:
         global pyboard
@@ -537,24 +625,28 @@ the last matching regex is used:
         pyb = pyboard.Pyboard(args.device, args.baudrate, args.user, args.password)
         pyb.enter_raw_repl()
     else:
-        raise ValueError('target must be either %s or unix' % ", ".join(EXTERNAL_TARGETS))
+        raise ValueError('target must be one of %s' % ", ".join(LOCAL_TARGETS + EXTERNAL_TARGETS))
 
     if len(args.files) == 0:
         if args.test_dirs is None:
+            test_dirs = ('basics', 'micropython', 'misc', 'extmod',)
             if args.target == 'pyboard':
                 # run pyboard tests
-                test_dirs = ('basics', 'micropython', 'float', 'misc', 'stress', 'extmod', 'pyb', 'pybnative', 'inlineasm')
+                test_dirs += ('float', 'stress', 'pyb', 'pybnative', 'inlineasm')
             elif args.target in ('esp8266', 'esp32', 'minimal', 'nrf'):
-                test_dirs = ('basics', 'micropython', 'float', 'misc', 'extmod')
+                test_dirs += ('float',)
             elif args.target == 'wipy':
                 # run WiPy tests
-                test_dirs = ('basics', 'micropython', 'misc', 'extmod', 'wipy')
-            else:
+                test_dirs += ('wipy',)
+            elif args.target == 'unix':
                 # run PC tests
-                test_dirs = (
-                    'basics', 'micropython', 'float', 'import', 'io', 'misc',
-                    'stress', 'unicode', 'extmod', 'unix', 'cmdline',
-                )
+                test_dirs += ('float', 'import', 'io', 'stress', 'unicode', 'unix', 'cmdline',)
+            elif args.target == 'qemu-arm':
+                if not args.write_exp:
+                    raise ValueError('--target=qemu-arm must be used with --write-exp')
+                # Generate expected output files for qemu run.
+                # This list should match the test_dirs tuple in tinytest-codegen.py.
+                test_dirs += ('float', 'inlineasm', 'qemu-arm',)
         else:
             # run tests from these directories
             test_dirs = args.test_dirs
@@ -564,8 +656,8 @@ the last matching regex is used:
         tests = args.files
 
     if not args.keep_path:
-        # clear search path to make sure tests use only builtin modules
-        os.environ['MICROPYPATH'] = ''
+        # clear search path to make sure tests use only builtin modules and those in extmod
+        os.environ['MICROPYPATH'] = os.pathsep + '../extmod'
 
     # Even if we run completely different tests in a different directory,
     # we need to access feature_check's from the same directory as the
diff --git a/tests/run-tests-exp.py b/tests/run-tests-exp.py
index 3af8feae7c713..34c6f650f83b6 100644
--- a/tests/run-tests-exp.py
+++ b/tests/run-tests-exp.py
@@ -9,12 +9,9 @@
 import uos as os
 
 
-tests = [
-    "basics", "micropython", "float", "import", "io",
-    " misc", "unicode", "extmod", "unix"
-]
+tests = ["basics", "micropython", "float", "import", "io", " misc", "unicode", "extmod", "unix"]
 
-if sys.platform == 'win32':
+if sys.platform == "win32":
     MICROPYTHON = "micropython.exe"
 else:
     MICROPYTHON = "micropython"
@@ -26,13 +23,14 @@ def should_skip(test):
     if test.startswith("viper"):
         return True
 
+
 test_count = 0
 passed_count = 0
 skip_count = 0
 
 for suite in tests:
-    #print("Running in: %s" % suite)
-    if sys.platform == 'win32':
+    # print("Running in: %s" % suite)
+    if sys.platform == "win32":
         # dir /b prints only contained filenames, one on a line
         # http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/dir.mspx
         r = os.system("dir /b %s/*.py >tests.lst" % suite)
@@ -44,7 +42,7 @@ def should_skip(test):
         testcases = f.readlines()
         testcases = [l[:-1] for l in testcases]
     assert testcases, "No tests found in dir '%s', which is implausible" % suite
-    #print(testcases)
+    # print(testcases)
     for t in testcases:
         if t == "native_check.py":
             continue
@@ -65,7 +63,7 @@ def should_skip(test):
             pass
 
         if exp is not None:
-            #print("run " + qtest)
+            # print("run " + qtest)
             r = os.system(MICROPYTHON + " %s >.tst.out" % qtest)
             if r == 0:
                 f = open(".tst.out")
diff --git a/tests/stress/dict_copy.py b/tests/stress/dict_copy.py
index 36db9bb7e89d0..73d3a5b51d601 100644
--- a/tests/stress/dict_copy.py
+++ b/tests/stress/dict_copy.py
@@ -1,6 +1,6 @@
 # copying a large dictionary
 
-a = {i:2*i for i in range(1000)}
+a = {i: 2 * i for i in range(1000)}
 b = a.copy()
 for i in range(1000):
     print(i, b[i])
diff --git a/tests/stress/gc_trace.py b/tests/stress/gc_trace.py
index 72dc7b62769d7..f952ad36a67c8 100644
--- a/tests/stress/gc_trace.py
+++ b/tests/stress/gc_trace.py
@@ -12,6 +12,8 @@
 print(lst)
 
 # test a deep object
-lst = [[[[[(i, j, k, l)] for i in range(3)] for j in range(3)] for k in range(3)] for l in range(3)]
+lst = [
+    [[[[(i, j, k, l)] for i in range(3)] for j in range(3)] for k in range(3)] for l in range(3)
+]
 gc.collect()
 print(lst)
diff --git a/tests/stress/qstr_limit.py b/tests/stress/qstr_limit.py
new file mode 100644
index 0000000000000..d8ce0cf7cd15f
--- /dev/null
+++ b/tests/stress/qstr_limit.py
@@ -0,0 +1,89 @@
+# Test interning qstrs that go over the limit of the maximum qstr length
+# (which is 255 bytes for the default configuration)
+
+
+def make_id(n, base="a"):
+    return "".join(chr(ord(base) + i % 26) for i in range(n))
+
+
+# identifiers in parser
+for l in range(254, 259):
+    g = {}
+    var = make_id(l)
+    try:
+        exec(var + "=1", g)
+    except RuntimeError:
+        print("RuntimeError", l)
+        continue
+    print(var in g)
+
+# calling a function with kwarg
+def f(**k):
+    print(k)
+
+
+for l in range(254, 259):
+    try:
+        exec("f({}=1)".format(make_id(l)))
+    except RuntimeError:
+        print("RuntimeError", l)
+
+# type construction
+for l in range(254, 259):
+    id = make_id(l)
+    try:
+        print(type(id, (), {}).__name__)
+    except RuntimeError:
+        print("RuntimeError", l)
+
+# hasattr, setattr, getattr
+class A:
+    pass
+
+
+for l in range(254, 259):
+    id = make_id(l)
+    a = A()
+    try:
+        setattr(a, id, 123)
+    except RuntimeError:
+        print("RuntimeError", l)
+    try:
+        print(hasattr(a, id), getattr(a, id))
+    except RuntimeError:
+        print("RuntimeError", l)
+
+# format with keys
+for l in range(254, 259):
+    id = make_id(l)
+    try:
+        print(("{" + id + "}").format(**{id: l}))
+    except RuntimeError:
+        print("RuntimeError", l)
+
+# modulo format with keys
+for l in range(254, 259):
+    id = make_id(l)
+    try:
+        print(("%(" + id + ")d") % {id: l})
+    except RuntimeError:
+        print("RuntimeError", l)
+
+# import module
+# (different OS's have different results so only run those that are consistent)
+for l in (100, 101, 256, 257, 258):
+    try:
+        __import__(make_id(l))
+    except ImportError:
+        print("ok", l)
+    except RuntimeError:
+        print("RuntimeError", l)
+
+# import package
+for l in (100, 101, 102, 128, 129):
+    try:
+        exec("import " + make_id(l) + "." + make_id(l, "A"))
+    except ImportError:
+        print("ok", l)
+    except RuntimeError:
+        print("RuntimeError", l)
diff --git a/tests/stress/qstr_limit.py.exp b/tests/stress/qstr_limit.py.exp
new file mode 100644
index 0000000000000..455761bc71e4a
--- /dev/null
+++ b/tests/stress/qstr_limit.py.exp
@@ -0,0 +1,43 @@
+True
+True
+RuntimeError 256
+RuntimeError 257
+RuntimeError 258
+{'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrst': 1}
+{'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstu': 1}
+RuntimeError 256
+RuntimeError 257
+RuntimeError 258
+abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrst
+abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstu
+RuntimeError 256
+RuntimeError 257
+RuntimeError 258
+True 123
+True 123
+RuntimeError 256
+RuntimeError 256
+RuntimeError 257
+RuntimeError 257
+RuntimeError 258
+RuntimeError 258
+254
+255
+RuntimeError 256
+RuntimeError 257
+RuntimeError 258
+254
+255
+RuntimeError 256
+RuntimeError 257
+RuntimeError 258
+ok 100
+ok 101
+RuntimeError 256
+RuntimeError 257
+RuntimeError 258
+ok 100
+ok 101
+ok 102
+RuntimeError 128
+RuntimeError 129
diff --git a/tests/stress/recursion.py b/tests/stress/recursion.py
index 227f48396ad47..c2d831bb8240a 100644
--- a/tests/stress/recursion.py
+++ b/tests/stress/recursion.py
@@ -1,6 +1,7 @@
 def foo():
     foo()
 
+
 try:
     foo()
 except RuntimeError:
diff --git a/tests/stress/recursive_gen.py b/tests/stress/recursive_gen.py
index 0e0d3914ee9d5..8c2139765847d 100644
--- a/tests/stress/recursive_gen.py
+++ b/tests/stress/recursive_gen.py
@@ -3,16 +3,20 @@
 # simple "yield from" recursion
 def gen():
     yield from gen()
+
+
 try:
     list(gen())
 except RuntimeError:
-    print('RuntimeError')
+    print("RuntimeError")
 
 # recursion via an iterator over a generator
 def gen2():
     for x in gen2():
         yield x
+
+
 try:
     next(gen2())
 except RuntimeError:
-    print('RuntimeError')
+    print("RuntimeError")
diff --git a/tests/stress/recursive_iternext.py b/tests/stress/recursive_iternext.py
index edb5a843f29dc..bbc389e726237 100644
--- a/tests/stress/recursive_iternext.py
+++ b/tests/stress/recursive_iternext.py
@@ -14,7 +14,7 @@
 try:
     # large stack/heap, eg unix
     [0] * 80000
-    N = 2400
+    N = 5000
 except:
     try:
         # medium, eg pyboard
diff --git a/tests/thread/mutate_bytearray.py b/tests/thread/mutate_bytearray.py
index f3276f1b2d676..67c01d91cf79f 100644
--- a/tests/thread/mutate_bytearray.py
+++ b/tests/thread/mutate_bytearray.py
@@ -23,10 +23,11 @@ def th(n, lo, hi):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 4
 n_finished = 0
-n_repeat = 4 # use 40 for more stressful test (uses more heap)
+n_repeat = 4  # use 40 for more stressful test (uses more heap)
 
 # spawn threads
 for i in range(n_thread):
@@ -42,4 +43,3 @@ def th(n, lo, hi):
 for b in ba:
     count[b] += 1
 print(count)
-
diff --git a/tests/thread/mutate_dict.py b/tests/thread/mutate_dict.py
index c57d332d51923..89c93f4eee54a 100644
--- a/tests/thread/mutate_dict.py
+++ b/tests/thread/mutate_dict.py
@@ -5,7 +5,7 @@
 import _thread
 
 # the shared dict
-di = {'a':'A', 'b':'B', 'c':'C', 'd':'D'}
+di = {"a": "A", "b": "B", "c": "C", "d": "D"}
 
 # main thread function
 def th(n, lo, hi):
@@ -26,6 +26,7 @@ def th(n, lo, hi):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 4
 n_finished = 0
diff --git a/tests/thread/mutate_instance.py b/tests/thread/mutate_instance.py
index a1ae428b549d6..939a0b8acd2a4 100644
--- a/tests/thread/mutate_instance.py
+++ b/tests/thread/mutate_instance.py
@@ -7,25 +7,28 @@
 # the shared user class and instance
 class User:
     def __init__(self):
-        self.a = 'A'
-        self.b = 'B'
-        self.c = 'C'
+        self.a = "A"
+        self.b = "B"
+        self.c = "C"
+
+
 user = User()
 
 # main thread function
 def th(n, lo, hi):
     for repeat in range(n):
         for i in range(lo, hi):
-            setattr(user, 'attr_%u' % i, repeat + i)
-            assert getattr(user, 'attr_%u' % i) == repeat + i
+            setattr(user, "attr_%u" % i, repeat + i)
+            assert getattr(user, "attr_%u" % i) == repeat + i
 
     with lock:
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_repeat = 30
-n_range = 50 # 300 for stressful test (uses more heap)
+n_range = 50  # 300 for stressful test (uses more heap)
 n_thread = 4
 n_finished = 0
 
@@ -40,4 +43,4 @@ def th(n, lo, hi):
 # check user instance has correct contents
 print(user.a, user.b, user.c)
 for i in range(n_thread * n_range):
-    assert getattr(user, 'attr_%u' % i) == n_repeat - 1 + i
+    assert getattr(user, "attr_%u" % i) == n_repeat - 1 + i
diff --git a/tests/thread/mutate_list.py b/tests/thread/mutate_list.py
index 764a9bd99ebb3..c1849e6729b95 100644
--- a/tests/thread/mutate_list.py
+++ b/tests/thread/mutate_list.py
@@ -27,6 +27,7 @@ def th(n, lo, hi):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 4
 n_finished = 0
diff --git a/tests/thread/mutate_set.py b/tests/thread/mutate_set.py
index 5492d86313974..924124611bd7b 100644
--- a/tests/thread/mutate_set.py
+++ b/tests/thread/mutate_set.py
@@ -21,6 +21,7 @@ def th(n, lo, hi):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 4
 n_finished = 0
diff --git a/tests/thread/stress_aes.py b/tests/thread/stress_aes.py
index df75e616c68ae..f73da557cb00e 100644
--- a/tests/thread/stress_aes.py
+++ b/tests/thread/stress_aes.py
@@ -17,6 +17,7 @@
 # discrete arithmetic routines, mostly from a precomputed table
 
 # non-linear, invertible, substitution box
+# fmt: off
 aes_s_box_table = bytes((
     0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
     0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
@@ -35,31 +36,36 @@
     0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
     0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16,
 ))
+# fmt: on
 
 # multiplication of polynomials modulo x^8 + x^4 + x^3 + x + 1 = 0x11b
 def aes_gf8_mul_2(x):
     if x & 0x80:
-        return (x << 1) ^ 0x11b
+        return (x << 1) ^ 0x11B
     else:
         return x << 1
 
+
 def aes_gf8_mul_3(x):
     return x ^ aes_gf8_mul_2(x)
 
+
 # non-linear, invertible, substitution box
 def aes_s_box(a):
-    return aes_s_box_table[a & 0xff]
+    return aes_s_box_table[a & 0xFF]
+
 
 # return 0x02^(a-1) in GF(2^8)
 def aes_r_con(a):
     ans = 1
     while a > 1:
-        ans <<= 1;
+        ans <<= 1
         if ans & 0x100:
-            ans ^= 0x11b
+            ans ^= 0x11B
         a -= 1
     return ans
 
+
 ##################################################################
 # basic AES algorithm; see FIPS-197
 #
@@ -79,6 +85,7 @@ def aes_add_round_key(state, w):
     for i in range(16):
         state[i] ^= w[i]
 
+
 # combined sub_bytes, shift_rows, mix_columns, add_round_key
 # all inputs must be size 16
 def aes_sb_sr_mc_ark(state, w, w_idx, temp):
@@ -88,7 +95,7 @@ def aes_sb_sr_mc_ark(state, w, w_idx, temp):
         x1 = aes_s_box_table[state[1 + ((i + 1) & 3) * 4]]
         x2 = aes_s_box_table[state[2 + ((i + 2) & 3) * 4]]
         x3 = aes_s_box_table[state[3 + ((i + 3) & 3) * 4]]
-        temp[temp_idx]     = aes_gf8_mul_2(x0) ^ aes_gf8_mul_3(x1) ^ x2 ^ x3 ^ w[w_idx]
+        temp[temp_idx] = aes_gf8_mul_2(x0) ^ aes_gf8_mul_3(x1) ^ x2 ^ x3 ^ w[w_idx]
         temp[temp_idx + 1] = x0 ^ aes_gf8_mul_2(x1) ^ aes_gf8_mul_3(x2) ^ x3 ^ w[w_idx + 1]
         temp[temp_idx + 2] = x0 ^ x1 ^ aes_gf8_mul_2(x2) ^ aes_gf8_mul_3(x3) ^ w[w_idx + 2]
         temp[temp_idx + 3] = aes_gf8_mul_3(x0) ^ x1 ^ x2 ^ aes_gf8_mul_2(x3) ^ w[w_idx + 3]
@@ -97,6 +104,7 @@ def aes_sb_sr_mc_ark(state, w, w_idx, temp):
     for i in range(16):
         state[i] = temp[i]
 
+
 # combined sub_bytes, shift_rows, add_round_key
 # all inputs must be size 16
 def aes_sb_sr_ark(state, w, w_idx, temp):
@@ -106,7 +114,7 @@ def aes_sb_sr_ark(state, w, w_idx, temp):
         x1 = aes_s_box_table[state[1 + ((i + 1) & 3) * 4]]
         x2 = aes_s_box_table[state[2 + ((i + 2) & 3) * 4]]
         x3 = aes_s_box_table[state[3 + ((i + 3) & 3) * 4]]
-        temp[temp_idx]     = x0 ^ w[w_idx]
+        temp[temp_idx] = x0 ^ w[w_idx]
         temp[temp_idx + 1] = x1 ^ w[w_idx + 1]
         temp[temp_idx + 2] = x2 ^ w[w_idx + 2]
         temp[temp_idx + 3] = x3 ^ w[w_idx + 3]
@@ -115,6 +123,7 @@ def aes_sb_sr_ark(state, w, w_idx, temp):
     for i in range(16):
         state[i] = temp[i]
 
+
 # take state as input and change it to the next state in the sequence
 # state and temp have size 16, w has size 16 * (Nr + 1), Nr >= 1
 def aes_state(state, w, temp, nr):
@@ -125,6 +134,7 @@ def aes_state(state, w, temp, nr):
         w_idx += 16
     aes_sb_sr_ark(state, w, w_idx, temp)
 
+
 # expand 'key' to 'w' for use with aes_state
 # key has size 4 * Nk, w has size 16 * (Nr + 1), temp has size 16
 def aes_key_expansion(key, w, temp, nk, nr):
@@ -148,9 +158,11 @@ def aes_key_expansion(key, w, temp, nk, nr):
         for j in range(4):
             w[w_idx + j] = w[w_idx + j - 4 * nk] ^ t[t_idx + j]
 
+
 ##################################################################
 # simple use of AES algorithm, using output feedback (OFB) mode
 
+
 class AES:
     def __init__(self, keysize):
         if keysize == 128:
@@ -176,7 +188,7 @@ def set_key(self, key):
     def set_iv(self, iv):
         for i in range(16):
             self.state[i] = iv[i]
-        self.state_pos = 16;
+        self.state_pos = 16
 
     def get_some_state(self, n_needed):
         if self.state_pos >= 16:
@@ -198,6 +210,7 @@ def apply_to(self, data):
             idx += ln
             self.state_pos += n
 
+
 ##################################################################
 # test code
 
@@ -207,6 +220,7 @@ def apply_to(self, data):
     import time
 import _thread
 
+
 class LockedCounter:
     def __init__(self):
         self.lock = _thread.allocate_lock()
@@ -217,8 +231,10 @@ def add(self, val):
         self.value += val
         self.lock.release()
 
+
 count = LockedCounter()
 
+
 def thread_entry():
     global count
 
@@ -247,7 +263,8 @@ def thread_entry():
 
     count.add(1)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     n_thread = 20
     for i in range(n_thread):
         _thread.start_new_thread(thread_entry, ())
diff --git a/tests/thread/stress_create.py b/tests/thread/stress_create.py
index 2399746ccab93..eda768fa7b5a3 100644
--- a/tests/thread/stress_create.py
+++ b/tests/thread/stress_create.py
@@ -6,9 +6,11 @@
     import time
 import _thread
 
+
 def thread_entry(n):
     pass
 
+
 thread_num = 0
 while thread_num < 500:
     try:
@@ -19,4 +21,4 @@ def thread_entry(n):
 
 # wait for the last threads to terminate
 time.sleep(1)
-print('done')
+print("done")
diff --git a/tests/thread/stress_heap.py b/tests/thread/stress_heap.py
index 5482a9ac6f7ec..2ad91ae147694 100644
--- a/tests/thread/stress_heap.py
+++ b/tests/thread/stress_heap.py
@@ -9,9 +9,11 @@
     import time
 import _thread
 
+
 def last(l):
     return l[-1]
 
+
 def thread_entry(n):
     # allocate a bytearray and fill it
     data = bytearray(i for i in range(256))
@@ -33,6 +35,7 @@ def thread_entry(n):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 10
 n_finished = 0
diff --git a/tests/thread/stress_recurse.py b/tests/thread/stress_recurse.py
index 68367c4dd7501..73b3a40f33daa 100644
--- a/tests/thread/stress_recurse.py
+++ b/tests/thread/stress_recurse.py
@@ -4,17 +4,20 @@
 
 import _thread
 
+
 def foo():
     foo()
 
+
 def thread_entry():
     try:
         foo()
     except RuntimeError:
-        print('RuntimeError')
+        print("RuntimeError")
     global finished
     finished = True
 
+
 finished = False
 
 _thread.start_new_thread(thread_entry, ())
@@ -22,4 +25,4 @@ def thread_entry():
 # busy wait for thread to finish
 while not finished:
     pass
-print('done')
+print("done")
diff --git a/tests/thread/stress_schedule.py b/tests/thread/stress_schedule.py
new file mode 100644
index 0000000000000..c5a402b3a3c36
--- /dev/null
+++ b/tests/thread/stress_schedule.py
@@ -0,0 +1,49 @@
+# This test ensures that the scheduler doesn't trigger any assertions
+# while dealing with concurrent access from multiple threads.
+
+import _thread
+import utime
+import micropython
+import gc
+
+try:
+    micropython.schedule
+except AttributeError:
+    print("SKIP")
+    raise SystemExit
+
+gc.disable()
+
+n = 0  # How many times the task successfully ran.
+
+
+def task(x):
+    global n
+    n += 1
+
+
+def thread():
+    while True:
+        try:
+            micropython.schedule(task, None)
+        except RuntimeError:
+            # Queue full, back off.
+            utime.sleep_ms(10)
+
+
+for i in range(8):
+    _thread.start_new_thread(thread, ())
+
+_NUM_TASKS = const(10000)
+_TIMEOUT_MS = const(10000)
+
+# Wait up to 10 seconds for 10000 tasks to be scheduled.
+t = utime.ticks_ms()
+while n < _NUM_TASKS and utime.ticks_diff(utime.ticks_ms(), t) < _TIMEOUT_MS:
+    pass
+
+if n < _NUM_TASKS:
+    # Not all the tasks were scheduled, likely the scheduler stopped working.
+    print(n)
+else:
+    print("PASS")
diff --git a/tests/thread/stress_schedule.py.exp b/tests/thread/stress_schedule.py.exp
new file mode 100644
index 0000000000000..7ef22e9a431ad
--- /dev/null
+++ b/tests/thread/stress_schedule.py.exp
@@ -0,0 +1 @@
+PASS
diff --git a/tests/thread/thread_exc1.py b/tests/thread/thread_exc1.py
index 10fb94b4fb97b..16483d7778a06 100644
--- a/tests/thread/thread_exc1.py
+++ b/tests/thread/thread_exc1.py
@@ -4,9 +4,11 @@
 
 import _thread
 
+
 def foo():
     raise ValueError
 
+
 def thread_entry():
     try:
         foo()
@@ -16,6 +18,7 @@ def thread_entry():
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 4
 n_finished = 0
@@ -27,4 +30,4 @@ def thread_entry():
 # busy wait for threads to finish
 while n_finished < n_thread:
     pass
-print('done')
+print("done")
diff --git a/tests/thread/thread_exc2.py b/tests/thread/thread_exc2.py
index 35cb32441204e..2863e1dec12a4 100644
--- a/tests/thread/thread_exc2.py
+++ b/tests/thread/thread_exc2.py
@@ -2,9 +2,11 @@
 import utime
 import _thread
 
+
 def thread_entry():
     raise ValueError
 
+
 _thread.start_new_thread(thread_entry, ())
 utime.sleep(1)
-print('done')
+print("done")
diff --git a/tests/thread/thread_exc2.py.exp b/tests/thread/thread_exc2.py.exp
index cc7a20aa26575..469516dacc004 100644
--- a/tests/thread/thread_exc2.py.exp
+++ b/tests/thread/thread_exc2.py.exp
@@ -1,5 +1,5 @@
 Unhandled exception in thread started by <function thread_entry at 0x\[0-9a-f\]\+>
 Traceback (most recent call last):
-  File \.\+, line 6, in thread_entry
+  File \.\+, line 7, in thread_entry
 ValueError: 
 done
diff --git a/tests/thread/thread_exit1.py b/tests/thread/thread_exit1.py
index 88cdd165c7f7a..c4a93c45a3df1 100644
--- a/tests/thread/thread_exit1.py
+++ b/tests/thread/thread_exit1.py
@@ -8,12 +8,14 @@
     import time
 import _thread
 
+
 def thread_entry():
     _thread.exit()
 
+
 _thread.start_new_thread(thread_entry, ())
 _thread.start_new_thread(thread_entry, ())
 
 # wait for threads to finish
 time.sleep(1)
-print('done')
+print("done")
diff --git a/tests/thread/thread_exit2.py b/tests/thread/thread_exit2.py
index 368a11bba4d34..0cd80e69092a8 100644
--- a/tests/thread/thread_exit2.py
+++ b/tests/thread/thread_exit2.py
@@ -8,12 +8,14 @@
     import time
 import _thread
 
+
 def thread_entry():
     raise SystemExit
 
+
 _thread.start_new_thread(thread_entry, ())
 _thread.start_new_thread(thread_entry, ())
 
 # wait for threads to finish
 time.sleep(1)
-print('done')
+print("done")
diff --git a/tests/thread/thread_gc1.py b/tests/thread/thread_gc1.py
index 8dcbf7e07a407..dd1e64d89444d 100644
--- a/tests/thread/thread_gc1.py
+++ b/tests/thread/thread_gc1.py
@@ -5,6 +5,7 @@
 import gc
 import _thread
 
+
 def thread_entry(n):
     # allocate a bytearray and fill it
     data = bytearray(i for i in range(256))
@@ -21,6 +22,7 @@ def thread_entry(n):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 4
 n_finished = 0
diff --git a/tests/thread/thread_ident1.py b/tests/thread/thread_ident1.py
index 217fce73b17eb..390193accc1ee 100644
--- a/tests/thread/thread_ident1.py
+++ b/tests/thread/thread_ident1.py
@@ -4,18 +4,20 @@
 
 import _thread
 
+
 def thread_entry():
     tid = _thread.get_ident()
-    print('thread', type(tid) == int, tid != 0, tid != tid_main)
+    print("thread", type(tid) == int, tid != 0, tid != tid_main)
     global finished
     finished = True
 
+
 tid_main = _thread.get_ident()
-print('main', type(tid_main) == int, tid_main != 0)
+print("main", type(tid_main) == int, tid_main != 0)
 
 finished = False
 _thread.start_new_thread(thread_entry, ())
 
 while not finished:
     pass
-print('done')
+print("done")
diff --git a/tests/thread/thread_lock1.py b/tests/thread/thread_lock1.py
index ba5c7dff066ff..342c554f4a5e2 100644
--- a/tests/thread/thread_lock1.py
+++ b/tests/thread/thread_lock1.py
@@ -36,11 +36,11 @@
         print(lock.locked())
         raise KeyError
 except KeyError:
-    print('KeyError')
+    print("KeyError")
     print(lock.locked())
 
 # test that we can't release an unlocked lock
 try:
     lock.release()
 except RuntimeError:
-    print('RuntimeError')
+    print("RuntimeError")
diff --git a/tests/thread/thread_lock2.py b/tests/thread/thread_lock2.py
index 405f10b0b62f3..b842f69c937dc 100644
--- a/tests/thread/thread_lock2.py
+++ b/tests/thread/thread_lock2.py
@@ -10,15 +10,17 @@
 
 lock = _thread.allocate_lock()
 
+
 def thread_entry():
     lock.acquire()
-    print('have it')
+    print("have it")
     lock.release()
 
+
 # spawn the threads
 for i in range(4):
     _thread.start_new_thread(thread_entry, ())
 
 # wait for threads to finish
 time.sleep(1)
-print('done')
+print("done")
diff --git a/tests/thread/thread_lock3.py b/tests/thread/thread_lock3.py
index 607898dad8c16..a927dc6829e15 100644
--- a/tests/thread/thread_lock3.py
+++ b/tests/thread/thread_lock3.py
@@ -8,16 +8,18 @@
 n_thread = 10
 n_finished = 0
 
+
 def thread_entry(idx):
     global n_finished
     while True:
         with lock:
             if n_finished == idx:
                 break
-    print('my turn:', idx)
+    print("my turn:", idx)
     with lock:
         n_finished += 1
 
+
 # spawn threads
 for i in range(n_thread):
     _thread.start_new_thread(thread_entry, (i,))
diff --git a/tests/thread/thread_lock4.py b/tests/thread/thread_lock4.py
index 2f9d42d6b550c..bbf9043996182 100644
--- a/tests/thread/thread_lock4.py
+++ b/tests/thread/thread_lock4.py
@@ -8,12 +8,14 @@
     import time
 import _thread
 
+
 def fac(n):
     x = 1
     for i in range(1, n + 1):
         x *= i
     return x
 
+
 def thread_entry():
     while True:
         with jobs_lock:
@@ -25,6 +27,7 @@ def thread_entry():
         with output_lock:
             output.append((arg, ans))
 
+
 # create a list of jobs
 jobs = [(fac, i) for i in range(20, 80)]
 jobs_lock = _thread.allocate_lock()
diff --git a/tests/thread/thread_qstr1.py b/tests/thread/thread_qstr1.py
index f4136d9646cea..40ee2910cb624 100644
--- a/tests/thread/thread_qstr1.py
+++ b/tests/thread/thread_qstr1.py
@@ -13,6 +13,7 @@ def check(s, val):
     assert type(s) == str
     assert int(s) == val
 
+
 # main thread function
 def th(base, n):
     for i in range(n):
@@ -23,10 +24,11 @@ def th(base, n):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 4
 n_finished = 0
-n_qstr_per_thread = 100 # make 1000 for a more stressful test (uses more heap)
+n_qstr_per_thread = 100  # make 1000 for a more stressful test (uses more heap)
 
 # spawn threads
 for i in range(n_thread):
@@ -36,4 +38,4 @@ def th(base, n):
 while n_finished < n_thread:
     time.sleep(1)
 
-print('pass')
+print("pass")
diff --git a/tests/thread/thread_shared1.py b/tests/thread/thread_shared1.py
index 13c6651cc438a..582b01fc34356 100644
--- a/tests/thread/thread_shared1.py
+++ b/tests/thread/thread_shared1.py
@@ -4,9 +4,11 @@
 
 import _thread
 
+
 def foo(i):
     pass
 
+
 def thread_entry(n, tup):
     for i in tup:
         foo(i)
@@ -14,6 +16,7 @@ def thread_entry(n, tup):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 2
 n_finished = 0
diff --git a/tests/thread/thread_shared2.py b/tests/thread/thread_shared2.py
index e4bfe780221bb..a1223c2b94f40 100644
--- a/tests/thread/thread_shared2.py
+++ b/tests/thread/thread_shared2.py
@@ -5,9 +5,11 @@
 
 import _thread
 
+
 def foo(lst, i):
     lst[i] += 1
 
+
 def thread_entry(n, lst, idx):
     for i in range(n):
         foo(lst, idx)
@@ -15,6 +17,7 @@ def thread_entry(n, lst, idx):
         global n_finished
         n_finished += 1
 
+
 lock = _thread.allocate_lock()
 n_thread = 2
 n_finished = 0
diff --git a/tests/thread/thread_sleep1.py b/tests/thread/thread_sleep1.py
index 032ec175438ea..18fa4e05a115a 100644
--- a/tests/thread/thread_sleep1.py
+++ b/tests/thread/thread_sleep1.py
@@ -4,9 +4,11 @@
 
 try:
     import utime
+
     sleep_ms = utime.sleep_ms
 except ImportError:
     import time
+
     sleep_ms = lambda t: time.sleep(t / 1000)
 
 import _thread
@@ -15,6 +17,7 @@
 n_thread = 4
 n_finished = 0
 
+
 def thread_entry(t):
     global n_finished
     sleep_ms(t)
@@ -22,10 +25,11 @@ def thread_entry(t):
     with lock:
         n_finished += 1
 
+
 for i in range(n_thread):
     _thread.start_new_thread(thread_entry, (10 * i,))
 
 # wait for threads to finish
 while n_finished < n_thread:
     sleep_ms(100)
-print('done', n_thread)
+print("done", n_thread)
diff --git a/tests/thread/thread_stacksize1.py b/tests/thread/thread_stacksize1.py
index 62b6e5e40d694..5827237a175eb 100644
--- a/tests/thread/thread_stacksize1.py
+++ b/tests/thread/thread_stacksize1.py
@@ -6,20 +6,23 @@
 import _thread
 
 # different implementations have different minimum sizes
-if sys.implementation.name == 'micropython':
+if sys.implementation.name == "micropython":
     sz = 2 * 1024
 else:
-    sz = 32 * 1024
+    sz = 512 * 1024
+
 
 def foo():
     pass
 
+
 def thread_entry():
     foo()
     with lock:
         global n_finished
         n_finished += 1
 
+
 # reset stack size to default
 _thread.stack_size()
 
@@ -44,4 +47,4 @@ def thread_entry():
 # busy wait for threads to finish
 while n_finished < n_thread:
     pass
-print('done')
+print("done")
diff --git a/tests/thread/thread_start1.py b/tests/thread/thread_start1.py
index d23a74aa2130f..f0e696840e556 100644
--- a/tests/thread/thread_start1.py
+++ b/tests/thread/thread_start1.py
@@ -8,16 +8,19 @@
     import time
 import _thread
 
+
 def foo():
     pass
 
+
 def thread_entry(n):
     for i in range(n):
         foo()
 
+
 _thread.start_new_thread(thread_entry, (10,))
 _thread.start_new_thread(thread_entry, (20,))
 
 # wait for threads to finish
 time.sleep(1)
-print('done')
+print("done")
diff --git a/tests/thread/thread_start2.py b/tests/thread/thread_start2.py
index d0913e37cd084..d68ea94329beb 100644
--- a/tests/thread/thread_start2.py
+++ b/tests/thread/thread_start2.py
@@ -8,11 +8,13 @@
     import time
 import _thread
 
+
 def thread_entry(a0, a1, a2, a3):
-    print('thread', a0, a1, a2, a3)
+    print("thread", a0, a1, a2, a3)
+
 
 # spawn thread using kw args
-_thread.start_new_thread(thread_entry, (10, 20), {'a2': 0, 'a3': 1})
+_thread.start_new_thread(thread_entry, (10, 20), {"a2": 0, "a3": 1})
 
 # wait for thread to finish
 time.sleep(1)
@@ -21,6 +23,6 @@ def thread_entry(a0, a1, a2, a3):
 try:
     _thread.start_new_thread(thread_entry, (), ())
 except TypeError:
-    print('TypeError')
+    print("TypeError")
 
-print('done')
+print("done")
diff --git a/tests/unicode/file2.py b/tests/unicode/file2.py
index 8c45f91faf723..1a5b933c89e48 100644
--- a/tests/unicode/file2.py
+++ b/tests/unicode/file2.py
@@ -1,11 +1,12 @@
 # test reading a given number of characters
 
+
 def do(mode):
-    if mode == 'rb':
+    if mode == "rb":
         enc = None
     else:
-        enc = 'utf-8'
-    f = open('unicode/data/utf-8_2.txt', mode=mode, encoding=enc)
+        enc = "utf-8"
+    f = open("unicode/data/utf-8_2.txt", mode=mode, encoding=enc)
     print(f.read(1))
     print(f.read(1))
     print(f.read(2))
@@ -15,12 +16,13 @@ def do(mode):
     f.readline()
 
     # check 3-byte utf-8 char
-    print(f.read(1 if mode == 'rt' else 3))
+    print(f.read(1 if mode == "rt" else 3))
 
     # check 4-byte utf-8 char
-    print(f.read(1 if mode == 'rt' else 4))
+    print(f.read(1 if mode == "rt" else 4))
 
     f.close()
 
-do('rb')
-do('rt')
+
+do("rb")
+do("rt")
diff --git a/tests/unicode/unicode.py b/tests/unicode/unicode.py
index b3d4b09eeb324..072e049fde416 100644
--- a/tests/unicode/unicode.py
+++ b/tests/unicode/unicode.py
@@ -1,17 +1,17 @@
 # Test a UTF-8 encoded literal
 s = "asdf©qwer"
 for i in range(len(s)):
-    print("s[%d]: %s   %X"%(i, s[i], ord(s[i])))
+    print("s[%d]: %s   %X" % (i, s[i], ord(s[i])))
 
 # Test all three forms of Unicode escape, and
 # all blocks of UTF-8 byte patterns
 s = "a\xA9\xFF\u0123\u0800\uFFEE\U0001F44C"
 for i in range(-len(s), len(s)):
-    print("s[%d]: %s   %X"%(i, s[i], ord(s[i])))
-    print("s[:%d]: %d chars, '%s'"%(i, len(s[:i]), s[:i]))
+    print("s[%d]: %s   %X" % (i, s[i], ord(s[i])))
+    print("s[:%d]: %d chars, '%s'" % (i, len(s[:i]), s[:i]))
     for j in range(i, len(s)):
-        print("s[%d:%d]: %d chars, '%s'"%(i, j, len(s[i:j]), s[i:j]))
-    print("s[%d:]: %d chars, '%s'"%(i, len(s[i:]), s[i:]))
+        print("s[%d:%d]: %d chars, '%s'" % (i, j, len(s[i:j]), s[i:j]))
+    print("s[%d:]: %d chars, '%s'" % (i, len(s[i:]), s[i:]))
 
 # Test UTF-8 encode and decode
 enc = s.encode()
@@ -19,35 +19,35 @@
 
 # printing of unicode chars using repr
 # NOTE: for some characters (eg \u10ff) we differ to CPython
-print(repr('a\uffff'))
-print(repr('a\U0001ffff'))
+print(repr("a\uffff"))
+print(repr("a\U0001ffff"))
 
 # test invalid escape code
 try:
     eval('"\\U00110000"')
 except SyntaxError:
-    print('SyntaxError')
+    print("SyntaxError")
 
 # test unicode string given to int
 try:
-    int('\u0200')
+    int("\u0200")
 except ValueError:
-    print('ValueError')
+    print("ValueError")
 
 # test invalid UTF-8 string
 try:
-    str(b'ab\xa1', 'utf8')
+    str(b"ab\xa1", "utf8")
 except UnicodeError:
-    print('UnicodeError')
+    print("UnicodeError")
 try:
-    str(b'ab\xf8', 'utf8')
+    str(b"ab\xf8", "utf8")
 except UnicodeError:
-    print('UnicodeError')
+    print("UnicodeError")
 try:
-    str(bytearray(b'ab\xc0a'), 'utf8')
+    str(bytearray(b"ab\xc0a"), "utf8")
 except UnicodeError:
-    print('UnicodeError')
+    print("UnicodeError")
 try:
-    str(b'\xf0\xe0\xed\xe8', 'utf8')
+    str(b"\xf0\xe0\xed\xe8", "utf8")
 except UnicodeError:
-    print('UnicodeError')
+    print("UnicodeError")
diff --git a/tests/unicode/unicode_id.py b/tests/unicode/unicode_id.py
index 10f540c5034ca..3a58e3f72b5e7 100644
--- a/tests/unicode/unicode_id.py
+++ b/tests/unicode/unicode_id.py
@@ -14,14 +14,19 @@
 def α(β, γ):
     δ = β + γ
     print(β, γ, δ)
+
+
 α(1, 2)
 
 # class, method identifiers
 class φ:
     def __init__(self):
         pass
+
     def δ(self, ϵ):
         print(ϵ)
+
+
 zζzζz = φ()
 if hasattr(zζzζz, "δ"):
     zζzζz.δ(ϵ=123)
diff --git a/tests/unicode/unicode_ord.py b/tests/unicode/unicode_ord.py
index 47cfa1c2d7cdf..73577050bf55b 100644
--- a/tests/unicode/unicode_ord.py
+++ b/tests/unicode/unicode_ord.py
@@ -1,3 +1,3 @@
 # test builtin ord with unicode characters
 
-print(ord('α'))
+print(ord("α"))
diff --git a/tests/unicode/unicode_slice.py b/tests/unicode/unicode_slice.py
new file mode 100644
index 0000000000000..d9237088f8097
--- /dev/null
+++ b/tests/unicode/unicode_slice.py
@@ -0,0 +1,12 @@
+# Test slicing of Unicode strings
+
+s = "Привет"
+
+print(s[:])
+print(s[2:])
+print(s[:5])
+print(s[2:5])
+print(s[2:5:1])
+print(s[2:10])
+print(s[-3:10])
+print(s[-4:10])
diff --git a/tests/unicode/unicode_str_format.py b/tests/unicode/unicode_str_format.py
index bf8505a31aced..1a60e7be4a619 100644
--- a/tests/unicode/unicode_str_format.py
+++ b/tests/unicode/unicode_str_format.py
@@ -1,4 +1,4 @@
 # test handling of unicode chars in format strings
 
-print('α'.format())
-print('{α}'.format(α=1))
+print("α".format())
+print("{α}".format(α=1))
diff --git a/tests/unicode/unicode_str_modulo.py b/tests/unicode/unicode_str_modulo.py
index e9b152473c05b..42211d0b0558d 100644
--- a/tests/unicode/unicode_str_modulo.py
+++ b/tests/unicode/unicode_str_modulo.py
@@ -1,3 +1,3 @@
 # test handling of unicode chars in string % formatting
 
-print('α' % ())
+print("α" % ())
diff --git a/tests/unicode/unicode_subscr.py b/tests/unicode/unicode_subscr.py
index a2f434de5806e..50289100779ec 100644
--- a/tests/unicode/unicode_subscr.py
+++ b/tests/unicode/unicode_subscr.py
@@ -1,4 +1,4 @@
-a = '¢пр'
+a = "¢пр"
 
 print(a[0], a[0:1])
 print(a[1], a[1:2])
diff --git a/tests/unix/extra_coverage.py b/tests/unix/extra_coverage.py
index 13721f1f479c3..36105f6bad18c 100644
--- a/tests/unix/extra_coverage.py
+++ b/tests/unix/extra_coverage.py
@@ -13,33 +13,33 @@
 print(data[0], data[1])
 print(hash(data[0]))
 print(hash(data[1]))
-print(hash(bytes(data[0], 'utf8')))
-print(hash(str(data[1], 'utf8')))
+print(hash(bytes(data[0], "utf8")))
+print(hash(str(data[1], "utf8")))
 
 # test streams
-stream = data[2] # has set_error and set_buf. Write always returns error
-stream.set_error(uerrno.EAGAIN) # non-blocking error
-print(stream.read()) # read all encounters non-blocking error
-print(stream.read(1)) # read 1 byte encounters non-blocking error
-print(stream.readline()) # readline encounters non-blocking error
-print(stream.readinto(bytearray(10))) # readinto encounters non-blocking error
-print(stream.write(b'1')) # write encounters non-blocking error
-print(stream.write1(b'1')) # write1 encounters non-blocking error
-stream.set_buf(b'123')
-print(stream.read(4)) # read encounters non-blocking error after successful reads
-stream.set_buf(b'123')
-print(stream.read1(4)) # read1 encounters non-blocking error after successful reads
-stream.set_buf(b'123')
-print(stream.readline(4)) # readline encounters non-blocking error after successful reads
+stream = data[2]  # has set_error and set_buf. Write always returns error
+stream.set_error(uerrno.EAGAIN)  # non-blocking error
+print(stream.read())  # read all encounters non-blocking error
+print(stream.read(1))  # read 1 byte encounters non-blocking error
+print(stream.readline())  # readline encounters non-blocking error
+print(stream.readinto(bytearray(10)))  # readinto encounters non-blocking error
+print(stream.write(b"1"))  # write encounters non-blocking error
+print(stream.write1(b"1"))  # write1 encounters non-blocking error
+stream.set_buf(b"123")
+print(stream.read(4))  # read encounters non-blocking error after successful reads
+stream.set_buf(b"123")
+print(stream.read1(4))  # read1 encounters non-blocking error after successful reads
+stream.set_buf(b"123")
+print(stream.readline(4))  # readline encounters non-blocking error after successful reads
 try:
-    print(stream.ioctl(0, 0)) # ioctl encounters non-blocking error; raises OSError
+    print(stream.ioctl(0, 0))  # ioctl encounters non-blocking error; raises OSError
 except OSError:
-    print('OSError')
+    print("OSError")
 stream.set_error(0)
-print(stream.ioctl(0, bytearray(10))) # successful ioctl call
+print(stream.ioctl(0, bytearray(10)))  # successful ioctl call
 
-stream2 = data[3] # is textio
-print(stream2.read(1)) # read 1 byte encounters non-blocking error with textio stream
+stream2 = data[3]  # is textio
+print(stream2.read(1))  # read 1 byte encounters non-blocking error with textio stream
 
 # test BufferedWriter with stream errors
 stream.set_error(uerrno.EAGAIN)
@@ -48,27 +48,41 @@
 
 # test basic import of frozen scripts
 import frzstr1
+
+print(frzstr1.__file__)
 import frzmpy1
 
+print(frzmpy1.__file__)
+
 # test import of frozen packages with __init__.py
 import frzstr_pkg1
-print(frzstr_pkg1.x)
+
+print(frzstr_pkg1.__file__, frzstr_pkg1.x)
 import frzmpy_pkg1
-print(frzmpy_pkg1.x)
+
+print(frzmpy_pkg1.__file__, frzmpy_pkg1.x)
 
 # test import of frozen packages without __init__.py
 from frzstr_pkg2.mod import Foo
+
 print(Foo.x)
 from frzmpy_pkg2.mod import Foo
+
 print(Foo.x)
 
 # test raising exception in frozen script
 try:
     import frzmpy2
 except ZeroDivisionError:
-    print('ZeroDivisionError')
+    print("ZeroDivisionError")
 
 # test loading a resource from a frozen string
 import uio
-buf = uio.resource_stream('frzstr_pkg2', 'mod.py')
+
+buf = uio.resource_stream("frzstr_pkg2", "mod.py")
 print(buf.read(21))
+
+# test for MP_QSTR_NULL regression
+from frzqstr import returns_NULL
+
+print(returns_NULL())
diff --git a/tests/unix/extra_coverage.py.exp b/tests/unix/extra_coverage.py.exp
index 2e23b24585c7c..7d7b7dd9f92f2 100644
--- a/tests/unix/extra_coverage.py.exp
+++ b/tests/unix/extra_coverage.py.exp
@@ -13,6 +13,7 @@ false true
 80000000
 80000000
 abc
+%
 # GC
 0
 0
@@ -27,11 +28,11 @@ RuntimeError:
 # repl
 ame__
 
-__class__       __name__        argv            byteorder
-exc_info        exit            getsizeof       implementation
-maxsize         modules         path            platform
-print_exception                 stderr          stdin
-stdout          version         version_info
+__class__       __name__        argv            atexit
+byteorder       exc_info        exit            getsizeof
+implementation  maxsize         modules         path
+platform        print_exception                 stderr
+stdin           stdout          version         version_info
 ementation
 # attrtuple
 (start=1, stop=2, step=3)
@@ -53,6 +54,11 @@ data
 # runtime utils
 TypeError: unsupported type for __abs__: 'str'
 TypeError: unsupported types for __divmod__: 'str', 'str'
+1
+2
+OverflowError: overflow converting long int to machine word
+OverflowError: overflow converting long int to machine word
+ValueError: 
 Warning: test
 # format float
 ?
@@ -74,6 +80,52 @@ unlocked
 1
 2
 3
+KeyboardInterrupt: 
+KeyboardInterrupt: 
+10
+# ringbuf
+99 0
+98 1
+22
+99 0
+97 2
+aa55
+99 0
+0 99
+-1
+1 98
+-1
+2 97
+0
+cc99
+99 0
+0
+11bb
+0
+22ff
+-1
+-1
+# pairheap
+create: 0 0 0 0
+pop all: 0 1 2 3
+create: 7 6 5 4 3 2 1 0
+pop all: 0 1 2 3 4 5 6 7
+create: 1 - - 1 1 1 1 1 1
+pop all: 1 2
+create: 1 1 1 1 2 2
+pop all: 2 4
+create: 1 1 1 1 1
+pop all: 1 3 4
+create: 3 3 3 1 1 1
+pop all: 1 2 4 5
+# mp_obj_is_type
+1 1
+0 0
+1 1
+1 1
+0 0
+1 1
+# end coverage.c
 0123456789 b'0123456789'
 7300
 7300
@@ -93,14 +145,17 @@ OSError
 None
 None
 frzstr1
+frzstr1.py
 frzmpy1
+frzmpy1.py
 frzstr_pkg1.__init__
-1
+frzstr_pkg1/__init__.py 1
 frzmpy_pkg1.__init__
-1
+frzmpy_pkg1/__init__.py 1
 frzstr_pkg2.mod
 1
 frzmpy_pkg2.mod
 1
 ZeroDivisionError
 b'# test frozen package'
+NULL
diff --git a/tests/unix/ffi_callback.py b/tests/unix/ffi_callback.py
index 23b058bcec2c4..21bfccf251eb8 100644
--- a/tests/unix/ffi_callback.py
+++ b/tests/unix/ffi_callback.py
@@ -15,16 +15,19 @@ def ffi_open(names):
             err = e
     raise err
 
-libc = ffi_open(('libc.so', 'libc.so.0', 'libc.so.6', 'libc.dylib'))
+
+libc = ffi_open(("libc.so", "libc.so.0", "libc.so.6", "libc.dylib"))
 
 qsort = libc.func("v", "qsort", "piip")
 
+
 def cmp(pa, pb):
     a = ffi.as_bytearray(pa, 1)
     b = ffi.as_bytearray(pb, 1)
-    #print("cmp:", a, b)
+    # print("cmp:", a, b)
     return a[0] - b[0]
 
+
 cmp_c = ffi.callback("i", cmp, "pp")
 
 s = bytearray(b"foobar")
diff --git a/tests/unix/ffi_float.py b/tests/unix/ffi_float.py
index 317436855b40b..d0393989651b3 100644
--- a/tests/unix/ffi_float.py
+++ b/tests/unix/ffi_float.py
@@ -16,7 +16,8 @@ def ffi_open(names):
             err = e
     raise err
 
-libc = ffi_open(('libc.so', 'libc.so.0', 'libc.so.6', 'libc.dylib'))
+
+libc = ffi_open(("libc.so", "libc.so.0", "libc.so.6", "libc.dylib"))
 
 try:
     strtof = libc.func("f", "strtof", "sp")
@@ -26,14 +27,14 @@ def ffi_open(names):
     print("SKIP")
     raise SystemExit
 
-print('%.6f' % strtof('1.23', None))
+print("%.6f" % strtof("1.23", None))
 
 strtod = libc.func("d", "strtod", "sp")
-print('%.6f' % strtod('1.23', None))
+print("%.6f" % strtod("1.23", None))
 
 # test passing double and float args
-libm = ffi_open(('libm.so', 'libm.so.6', 'libc.so.0', 'libc.so.6', 'libc.dylib'))
-tgamma = libm.func('d', 'tgamma', 'd')
+libm = ffi_open(("libm.so", "libm.so.6", "libc.so.0", "libc.so.6", "libc.dylib"))
+tgamma = libm.func("d", "tgamma", "d")
 for fun in (tgamma,):
     for val in (0.5, 1, 1.0, 1.5, 4, 4.0):
-        print('%.6f' % fun(val))
+        print("%.6f" % fun(val))
diff --git a/tests/unix/ffi_float2.py b/tests/unix/ffi_float2.py
index 721eb4d192f17..bbed6966627e1 100644
--- a/tests/unix/ffi_float2.py
+++ b/tests/unix/ffi_float2.py
@@ -16,16 +16,17 @@ def ffi_open(names):
             err = e
     raise err
 
-libm = ffi_open(('libm.so', 'libm.so.6', 'libc.so.0', 'libc.so.6', 'libc.dylib'))
+
+libm = ffi_open(("libm.so", "libm.so.6", "libc.so.0", "libc.so.6", "libc.dylib"))
 
 # Some libc's implement tgammaf as header macro with tgamma(), so don't assume
 # it'll be in library.
 try:
-    tgammaf = libm.func('f', 'tgammaf', 'f')
+    tgammaf = libm.func("f", "tgammaf", "f")
 except OSError:
     print("SKIP")
     raise SystemExit
 
 for fun in (tgammaf,):
     for val in (0.5, 1, 1.0, 1.5, 4, 4.0):
-        print('%.6f' % fun(val))
+        print("%.6f" % fun(val))
diff --git a/tests/unix/time.py b/tests/unix/time.py
new file mode 100644
index 0000000000000..55a4b18aaef38
--- /dev/null
+++ b/tests/unix/time.py
@@ -0,0 +1,59 @@
+try:
+    import utime as time
+except ImportError:
+    import time
+
+DAYS_PER_MONTH = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+
+tzseconds = -time.mktime((1970, 1, 1, 14, 0, 0, 0, 0, 0))
+
+
+def is_leap(year):
+    return (year % 4) == 0
+
+
+def test():
+    seconds = 0
+    wday = 3  # Jan 1, 1970 was a Thursday
+    for year in range(1970, 2038):
+        print("Testing %d" % year)
+        yday = 1
+        for month in range(1, 13):
+            if month == 2 and is_leap(year):
+                DAYS_PER_MONTH[2] = 29
+            else:
+                DAYS_PER_MONTH[2] = 28
+            for day in range(1, DAYS_PER_MONTH[month] + 1):
+                secs = time.mktime((year, month, day, 14, 0, 0, 0, 0, 0)) + tzseconds
+                if secs != seconds:
+                    print(
+                        "mktime failed for %d-%02d-%02d got %d expected %d"
+                        % (year, month, day, secs, seconds)
+                    )
+                    return
+                tuple = time.localtime(seconds)
+                secs = time.mktime(tuple)
+                if secs != seconds:
+                    print(
+                        "localtime failed for %d-%02d-%02d got %d expected %d"
+                        % (year, month, day, secs, seconds)
+                    )
+                    return
+                seconds += 86400
+                if yday != tuple[7]:
+                    print(
+                        "locatime for %d-%02d-%02d got yday %d, expecting %d"
+                        % (year, month, day, tuple[7], yday)
+                    )
+                    return
+                if wday != tuple[6]:
+                    print(
+                        "locatime for %d-%02d-%02d got wday %d, expecting %d"
+                        % (year, month, day, tuple[6], wday)
+                    )
+                    return
+                yday += 1
+                wday = (wday + 1) % 7
+
+
+test()
diff --git a/tests/wipy/adc.py b/tests/wipy/adc.py
index 6fd4373dbd8df..73264113f380d 100644
--- a/tests/wipy/adc.py
+++ b/tests/wipy/adc.py
@@ -1,19 +1,19 @@
-'''
+"""
 ADC test for the CC3200 based boards.
-'''
+"""
 
 from machine import ADC
 import os
 
 mch = os.uname().machine
-if 'LaunchPad' in mch:
-    adc_pin = 'GP5'
+if "LaunchPad" in mch:
+    adc_pin = "GP5"
     adc_channel = 3
-elif 'WiPy' in mch:
-    adc_pin = 'GP3'
+elif "WiPy" in mch:
+    adc_pin = "GP3"
     adc_channel = 1
 else:
-    raise Exception('Board not supported!')
+    raise Exception("Board not supported!")
 
 adc = ADC(0)
 print(adc)
@@ -49,7 +49,7 @@
 print(apin() > 3000)
 
 # check for memory leaks...
-for i in range (0, 1000):
+for i in range(0, 1000):
     adc = ADC()
     apin = adc.channel(adc_channel)
 
@@ -57,56 +57,56 @@
 try:
     adc = ADC(bits=17)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     adc = ADC(id=1)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     adc = ADC(0, 16)
 except:
-    print('Exception')
+    print("Exception")
 
 adc = ADC()
 try:
     apin = adc.channel(4)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     apin = adc.channel(-1)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
-    apin = adc.channel(0, pin='GP3')
+    apin = adc.channel(0, pin="GP3")
 except:
-    print('Exception')
+    print("Exception")
 
 apin = adc.channel(1)
 apin.deinit()
 try:
     apin()
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     apin.value()
 except:
-    print('Exception')
+    print("Exception")
 
 adc.deinit()
 try:
     apin.value()
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     apin = adc.channel(1)
 except:
-    print('Exception')
+    print("Exception")
 
 # re-init must work
 adc.init()
diff --git a/tests/wipy/i2c.py b/tests/wipy/i2c.py
index 693155419158c..c7d32f6639e80 100644
--- a/tests/wipy/i2c.py
+++ b/tests/wipy/i2c.py
@@ -1,19 +1,19 @@
-'''
+"""
 I2C test for the CC3200 based boards.
 A MPU-9150 sensor must be connected to the I2C bus.
-'''
+"""
 
 from machine import I2C
 import os
 import time
 
 mch = os.uname().machine
-if 'LaunchPad' in mch:
-    i2c_pins = ('GP11', 'GP10')
-elif 'WiPy' in mch:
-    i2c_pins = ('GP15', 'GP10')
+if "LaunchPad" in mch:
+    i2c_pins = ("GP11", "GP10")
+elif "WiPy" in mch:
+    i2c_pins = ("GP15", "GP10")
 else:
-    raise Exception('Board not supported!')
+    raise Exception("Board not supported!")
 
 i2c = I2C(0, I2C.MASTER, baudrate=400000)
 # try initing without the peripheral id
@@ -41,26 +41,26 @@
 print(1 == i2c.writeto_mem(addr, 107, reg))
 time.sleep_ms(100)  # wait for the sensor to reset...
 
-print(1 == i2c.readfrom_mem_into(addr, 107, reg)) # read the power management register 1
+print(1 == i2c.readfrom_mem_into(addr, 107, reg))  # read the power management register 1
 print(0x40 == reg[0])
 
 # now just read one byte
-data = i2c.readfrom_mem(addr, 117, 1) # read the "who am I?" register
+data = i2c.readfrom_mem(addr, 117, 1)  # read the "who am I?" register
 print(0x68 == data[0])
 print(len(data) == 1)
-print(1 == i2c.readfrom_mem_into(addr, 117, reg)) # read the "who am I?" register again
+print(1 == i2c.readfrom_mem_into(addr, 117, reg))  # read the "who am I?" register again
 print(0x68 == reg[0])
 
 # now try reading two bytes
-data = i2c.readfrom_mem(addr, 116, 2) # read the "who am I?" register
+data = i2c.readfrom_mem(addr, 116, 2)  # read the "who am I?" register
 print(0x68 == data[1])
-print(data == b'\x00\x68')
+print(data == b"\x00\x68")
 print(len(data) == 2)
-print(2 == i2c.readfrom_mem_into(addr, 116, reg2)) # read the "who am I?" register again
+print(2 == i2c.readfrom_mem_into(addr, 116, reg2))  # read the "who am I?" register again
 print(0x68 == reg2[1])
-print(reg2 == b'\x00\x68')
+print(reg2 == b"\x00\x68")
 
-print(1 == i2c.readfrom_mem_into(addr, 107, reg)) # read the power management register 1
+print(1 == i2c.readfrom_mem_into(addr, 107, reg))  # read the power management register 1
 print(0x40 == reg[0])
 # clear the sleep bit
 reg[0] = 0
@@ -100,13 +100,13 @@
 time.sleep_ms(100)  # wait for the sensor to reset...
 
 # try some raw read and writes
-reg[0] = 117 # register address
-print(1 == i2c.writeto(addr, reg, stop=False)) # just write the register address
+reg[0] = 117  # register address
+print(1 == i2c.writeto(addr, reg, stop=False))  # just write the register address
 # now read
 print(1 == i2c.readfrom_into(addr, reg))
 print(reg[0] == 0x68)
-reg[0] = 117 # register address
-print(1 == i2c.writeto(addr, reg, stop=False)) # just write the register address
+reg[0] = 117  # register address
+print(1 == i2c.writeto(addr, reg, stop=False))  # just write the register address
 # now read
 print(0x68 == i2c.readfrom(addr, 1)[0])
 
@@ -114,14 +114,14 @@
 print(0x40 == reg2[0])
 print(0x00 == reg2[1])
 
-reg2[0] = 107 # register address
+reg2[0] = 107  # register address
 reg2[1] = 0
-print(2 == i2c.writeto(addr, reg2, stop=True)) # write the register address and the data
-i2c.readfrom_mem_into(addr, 107, reg) # check it back
+print(2 == i2c.writeto(addr, reg2, stop=True))  # write the register address and the data
+i2c.readfrom_mem_into(addr, 107, reg)  # check it back
 print(reg[0] == 0)
 
 # check for memory leaks...
-for i in range (0, 1000):
+for i in range(0, 1000):
     i2c = I2C(0, I2C.MASTER, baudrate=100000)
 
 # test deinit
@@ -173,4 +173,3 @@
 # reinitialization must work
 i2c.init(baudrate=400000)
 print(i2c)
-
diff --git a/tests/wipy/modwipy.py b/tests/wipy/modwipy.py
index 7571af0753178..59df3ae90ac6e 100644
--- a/tests/wipy/modwipy.py
+++ b/tests/wipy/modwipy.py
@@ -1,13 +1,13 @@
-'''
+"""
 wipy module test for the CC3200 based boards
-'''
+"""
 
 import os
 import wipy
 
 mch = os.uname().machine
-if not 'LaunchPad' in mch and not'WiPy' in mch:
-    raise Exception('Board not supported!')
+if not "LaunchPad" in mch and not "WiPy" in mch:
+    raise Exception("Board not supported!")
 
 print(wipy.heartbeat() == True)
 wipy.heartbeat(False)
@@ -18,4 +18,4 @@
 try:
     wipy.heartbeat(True, 1)
 except:
-    print('Exception')
+    print("Exception")
diff --git a/tests/wipy/os.py b/tests/wipy/os.py
index 0596a16b5290b..1f4debcade55c 100644
--- a/tests/wipy/os.py
+++ b/tests/wipy/os.py
@@ -1,164 +1,164 @@
-'''
+"""
 os module test for the CC3200 based boards
-'''
+"""
 
 from machine import SD
 import os
 
 mch = os.uname().machine
-if 'LaunchPad' in mch:
-    sd_pins = ('GP16', 'GP17', 'GP15')
-elif 'WiPy' in mch:
-    sd_pins = ('GP10', 'GP11', 'GP15')
+if "LaunchPad" in mch:
+    sd_pins = ("GP16", "GP17", "GP15")
+elif "WiPy" in mch:
+    sd_pins = ("GP10", "GP11", "GP15")
 else:
-    raise Exception('Board not supported!')
+    raise Exception("Board not supported!")
 
 sd = SD(pins=sd_pins)
 
-os.mount(sd, '/sd')
-os.mkfs('/sd')
-os.chdir('/flash')
+os.mount(sd, "/sd")
+os.mkfs("/sd")
+os.chdir("/flash")
 print(os.listdir())
 
-os.chdir('/sd')
+os.chdir("/sd")
 print(os.listdir())
 
 # create a test directory in flash
-os.mkdir('/flash/test')
-os.chdir('/flash/test')
+os.mkdir("/flash/test")
+os.chdir("/flash/test")
 print(os.getcwd())
-os.chdir('..')
+os.chdir("..")
 print(os.getcwd())
-os.chdir('test')
+os.chdir("test")
 print(os.getcwd())
 # create a new file
-f = open('test.txt', 'w')
+f = open("test.txt", "w")
 test_bytes = os.urandom(1024)
 n_w = f.write(test_bytes)
 print(n_w == len(test_bytes))
 f.close()
-f = open('test.txt', 'r')
-r = bytes(f.read(), 'ascii')
+f = open("test.txt", "r")
+r = bytes(f.read(), "ascii")
 # check that we can write and read it correctly
 print(r == test_bytes)
 f.close()
-os.rename('test.txt', 'newtest.txt')
+os.rename("test.txt", "newtest.txt")
 print(os.listdir())
-os.rename('/flash/test', '/flash/newtest')
-print(os.listdir('/flash'))
-os.remove('newtest.txt')
-os.chdir('..')
-os.rmdir('newtest')
+os.rename("/flash/test", "/flash/newtest")
+print(os.listdir("/flash"))
+os.remove("newtest.txt")
+os.chdir("..")
+os.rmdir("newtest")
 
 # create a test directory in the sd card
-os.mkdir('/sd/test')
-os.chdir('/sd/test')
+os.mkdir("/sd/test")
+os.chdir("/sd/test")
 print(os.getcwd())
-os.chdir('..')
+os.chdir("..")
 print(os.getcwd())
-os.chdir('test')
+os.chdir("test")
 print(os.getcwd())
 # create a new file
-f = open('test.txt', 'w')
+f = open("test.txt", "w")
 test_bytes = os.urandom(1024)
 n_w = f.write(test_bytes)
 print(n_w == len(test_bytes))
 f.close()
-f = open('test.txt', 'r')
-r = bytes(f.read(), 'ascii')
+f = open("test.txt", "r")
+r = bytes(f.read(), "ascii")
 # check that we can write and read it correctly
 print(r == test_bytes)
 f.close()
 
-print('CC3200' in os.uname().machine)
-print('WiPy' == os.uname().sysname)
+print("CC3200" in os.uname().machine)
+print("WiPy" == os.uname().sysname)
 
 os.sync()
-os.stat('/flash')
-os.stat('/flash/sys')
-os.stat('/flash/boot.py')
-os.stat('/sd')
-os.stat('/')
-os.chdir('/sd/test')
-os.remove('test.txt')
-os.chdir('/sd')
-os.rmdir('test')
-os.listdir('/sd')
-print(os.listdir('/'))
-os.unmount('/sd')
-print(os.listdir('/'))
+os.stat("/flash")
+os.stat("/flash/sys")
+os.stat("/flash/boot.py")
+os.stat("/sd")
+os.stat("/")
+os.chdir("/sd/test")
+os.remove("test.txt")
+os.chdir("/sd")
+os.rmdir("test")
+os.listdir("/sd")
+print(os.listdir("/"))
+os.unmount("/sd")
+print(os.listdir("/"))
 os.mkfs(sd)
-os.mount(sd, '/sd')
-print(os.listdir('/'))
-os.chdir('/flash')
+os.mount(sd, "/sd")
+print(os.listdir("/"))
+os.chdir("/flash")
 
 # next ones must raise
 sd.deinit()
 try:
-    os.listdir('/sd')
+    os.listdir("/sd")
 except:
-    print('Exception')
+    print("Exception")
 
-#re-initialization must work
+# re-initialization must work
 sd.init()
-print(os.listdir('/sd'))
+print(os.listdir("/sd"))
 
 try:
-    os.mount(sd, '/sd')
+    os.mount(sd, "/sd")
 except:
-    print('Exception')
+    print("Exception")
 
 try:
-    os.mount(sd, '/sd2')
+    os.mount(sd, "/sd2")
 except:
-    print('Exception')
+    print("Exception")
 
-os.unmount('/sd')
+os.unmount("/sd")
 try:
-    os.listdir('/sd')
+    os.listdir("/sd")
 except:
-    print('Exception')
+    print("Exception")
 
 try:
-    os.unmount('/flash')
+    os.unmount("/flash")
 except:
-    print('Exception')
+    print("Exception")
 
 try:
-    os.unmount('/something')
+    os.unmount("/something")
 except:
-    print('Exception')
+    print("Exception")
 
 try:
-    os.unmount('something')
+    os.unmount("something")
 except:
-    print('Exception')
+    print("Exception")
 
 try:
-    os.mkfs('flash') # incorrect path format
+    os.mkfs("flash")  # incorrect path format
 except:
-    print('Exception')
+    print("Exception")
 
 try:
-    os.remove('/flash/nofile.txt')
+    os.remove("/flash/nofile.txt")
 except:
-    print('Exception')
+    print("Exception")
 
 try:
-    os.rename('/flash/nofile.txt', '/flash/nofile2.txt')
+    os.rename("/flash/nofile.txt", "/flash/nofile2.txt")
 except:
-    print('Exception')
+    print("Exception")
 
 try:
-    os.chdir('/flash/nodir')
+    os.chdir("/flash/nodir")
 except:
-    print('Exception')
+    print("Exception")
 
 try:
-    os.listdir('/flash/nodir')
+    os.listdir("/flash/nodir")
 except:
-    print('Exception')
+    print("Exception")
 
-os.mount(sd, '/sd')
-print(os.listdir('/'))
-os.unmount('/sd')
+os.mount(sd, "/sd")
+print(os.listdir("/"))
+os.unmount("/sd")
diff --git a/tests/wipy/pin.py b/tests/wipy/pin.py
index 22c7c6176c13a..9ffd152e93ea7 100644
--- a/tests/wipy/pin.py
+++ b/tests/wipy/pin.py
@@ -7,27 +7,61 @@
 import os
 
 mch = os.uname().machine
-if 'LaunchPad' in mch:
-    pin_map = ['GP24', 'GP12', 'GP14', 'GP15', 'GP16', 'GP17', 'GP28', 'GP8', 'GP6', 'GP30', 'GP31', 'GP3', 'GP0', 'GP4', 'GP5']
+if "LaunchPad" in mch:
+    pin_map = [
+        "GP24",
+        "GP12",
+        "GP14",
+        "GP15",
+        "GP16",
+        "GP17",
+        "GP28",
+        "GP8",
+        "GP6",
+        "GP30",
+        "GP31",
+        "GP3",
+        "GP0",
+        "GP4",
+        "GP5",
+    ]
     max_af_idx = 15
-elif 'WiPy' in mch:
-    pin_map = ['GP23', 'GP24', 'GP12', 'GP13', 'GP14', 'GP9', 'GP17', 'GP28', 'GP22', 'GP8', 'GP30', 'GP31', 'GP0', 'GP4', 'GP5']
+elif "WiPy" in mch:
+    pin_map = [
+        "GP23",
+        "GP24",
+        "GP12",
+        "GP13",
+        "GP14",
+        "GP9",
+        "GP17",
+        "GP28",
+        "GP22",
+        "GP8",
+        "GP30",
+        "GP31",
+        "GP0",
+        "GP4",
+        "GP5",
+    ]
     max_af_idx = 15
 else:
-    raise Exception('Board not supported!')
+    raise Exception("Board not supported!")
 
 # test initial value
-p = Pin('GP12', Pin.IN)
-Pin('GP17', Pin.OUT, value=1)
+p = Pin("GP12", Pin.IN)
+Pin("GP17", Pin.OUT, value=1)
 print(p() == 1)
-Pin('GP17', Pin.OUT, value=0)
+Pin("GP17", Pin.OUT, value=0)
 print(p() == 0)
 
+
 def test_noinit():
     for p in pin_map:
         pin = Pin(p)
         pin.value()
 
+
 def test_pin_read(pull):
     # enable the pull resistor on all pins, then read the value
     for p in pin_map:
@@ -35,6 +69,7 @@ def test_pin_read(pull):
     for p in pin_map:
         print(pin())
 
+
 def test_pin_af():
     for p in pin_map:
         for af in Pin(p).alt_list():
@@ -42,6 +77,7 @@ def test_pin_af():
                 Pin(p, mode=Pin.ALT, alt=af[1])
                 Pin(p, mode=Pin.ALT_OPEN_DRAIN, alt=af[1])
 
+
 # test un-initialized pins
 test_noinit()
 # test with pull-up and pull-down
@@ -65,7 +101,7 @@ def test_pin_af():
 pin = Pin(pin_map[0], Pin.OUT, Pin.PULL_DOWN)
 pin = Pin(pin_map[0], Pin.ALT, Pin.PULL_UP)
 pin = Pin(pin_map[0], Pin.ALT_OPEN_DRAIN, Pin.PULL_UP)
-test_pin_af() # try the entire af range on all pins
+test_pin_af()  # try the entire af range on all pins
 
 # test pin init and printing
 pin = Pin(pin_map[0])
@@ -81,9 +117,9 @@ def test_pin_af():
 # test value in OUT mode
 pin = Pin(pin_map[0], mode=Pin.OUT)
 pin.value(0)
-pin.toggle() # test toggle
+pin.toggle()  # test toggle
 print(pin())
-pin.toggle() # test toggle again
+pin.toggle()  # test toggle again
 print(pin())
 # test different value settings
 pin(1)
@@ -116,67 +152,66 @@ def test_pin_af():
 
 # all the next ones MUST raise
 try:
-    pin = Pin(pin_map[0], mode=Pin.OUT, pull=Pin.PULL_UP, drive=pin.IN) # incorrect drive value
+    pin = Pin(pin_map[0], mode=Pin.OUT, pull=Pin.PULL_UP, drive=pin.IN)  # incorrect drive value
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
-    pin = Pin(pin_map[0], mode=Pin.LOW_POWER, pull=Pin.PULL_UP) # incorrect mode value
+    pin = Pin(pin_map[0], mode=Pin.LOW_POWER, pull=Pin.PULL_UP)  # incorrect mode value
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
-    pin = Pin(pin_map[0], mode=Pin.IN, pull=Pin.HIGH_POWER) # incorrect pull value
+    pin = Pin(pin_map[0], mode=Pin.IN, pull=Pin.HIGH_POWER)  # incorrect pull value
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
-    pin = Pin('A0', Pin.OUT, Pin.PULL_DOWN) # incorrect pin id
+    pin = Pin("A0", Pin.OUT, Pin.PULL_DOWN)  # incorrect pin id
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
-    pin = Pin(pin_map[0], Pin.IN, Pin.PULL_UP, alt=0) # af specified in GPIO mode
+    pin = Pin(pin_map[0], Pin.IN, Pin.PULL_UP, alt=0)  # af specified in GPIO mode
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
-    pin = Pin(pin_map[0], Pin.OUT, Pin.PULL_UP, alt=7) # af specified in GPIO mode
+    pin = Pin(pin_map[0], Pin.OUT, Pin.PULL_UP, alt=7)  # af specified in GPIO mode
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
-    pin = Pin(pin_map[0], Pin.ALT, Pin.PULL_UP, alt=0) # incorrect af
+    pin = Pin(pin_map[0], Pin.ALT, Pin.PULL_UP, alt=0)  # incorrect af
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
-    pin = Pin(pin_map[0], Pin.ALT_OPEN_DRAIN, Pin.PULL_UP, alt=-1) # incorrect af
+    pin = Pin(pin_map[0], Pin.ALT_OPEN_DRAIN, Pin.PULL_UP, alt=-1)  # incorrect af
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
-    pin = Pin(pin_map[0], Pin.ALT_OPEN_DRAIN, Pin.PULL_UP, alt=16) # incorrect af
+    pin = Pin(pin_map[0], Pin.ALT_OPEN_DRAIN, Pin.PULL_UP, alt=16)  # incorrect af
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
-    pin.mode(Pin.PULL_UP) # incorrect pin mode
+    pin.mode(Pin.PULL_UP)  # incorrect pin mode
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
-    pin.pull(Pin.OUT) # incorrect pull
+    pin.pull(Pin.OUT)  # incorrect pull
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
-    pin.drive(Pin.IN) # incorrect drive strength
+    pin.drive(Pin.IN)  # incorrect drive strength
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
-    pin.id('ABC') # id cannot be set
+    pin.id("ABC")  # id cannot be set
 except Exception:
-    print('Exception')
-
+    print("Exception")
diff --git a/tests/wipy/pin_irq.py b/tests/wipy/pin_irq.py
index 875f1f9397f05..be5e1f426caf9 100644
--- a/tests/wipy/pin_irq.py
+++ b/tests/wipy/pin_irq.py
@@ -1,6 +1,6 @@
-'''
+"""
 Pin IRQ test for the CC3200 based boards.
-'''
+"""
 
 from machine import Pin
 import machine
@@ -8,17 +8,18 @@
 import time
 
 mch = os.uname().machine
-if 'LaunchPad' in mch:
-    pins = ['GP16', 'GP13']
-elif 'WiPy' in mch:
-    pins = ['GP16', 'GP13']
+if "LaunchPad" in mch:
+    pins = ["GP16", "GP13"]
+elif "WiPy" in mch:
+    pins = ["GP16", "GP13"]
 else:
-    raise Exception('Board not supported!')
+    raise Exception("Board not supported!")
 
 pin0 = Pin(pins[0], mode=Pin.OUT, value=1)
 pin1 = Pin(pins[1], mode=Pin.IN, pull=Pin.PULL_UP)
 
-def pin_handler (pin_o):
+
+def pin_handler(pin_o):
     global pin_irq_count_trigger
     global pin_irq_count_total
     global _trigger
@@ -26,11 +27,12 @@ def pin_handler (pin_o):
         pin_irq_count_trigger += 1
     pin_irq_count_total += 1
 
+
 pin_irq_count_trigger = 0
 pin_irq_count_total = 0
 _trigger = Pin.IRQ_FALLING
 pin1_irq = pin1.irq(trigger=_trigger, handler=pin_handler)
-for i in range (0, 10):
+for i in range(0, 10):
     pin0.toggle()
     time.sleep_ms(5)
 print(pin_irq_count_trigger == 5)
@@ -40,7 +42,7 @@ def pin_handler (pin_o):
 pin_irq_count_total = 0
 _trigger = Pin.IRQ_RISING
 pin1_irq = pin1.irq(trigger=_trigger, handler=pin_handler)
-for i in range (0, 200):
+for i in range(0, 200):
     pin0.toggle()
     time.sleep_ms(5)
 print(pin_irq_count_trigger == 100)
@@ -69,7 +71,7 @@ def pin_handler (pin_o):
 pin1_irq.disable()
 pin_irq_count_trigger = 0
 pin_irq_count_total = 0
-for i in range (0, 10):
+for i in range(0, 10):
     pin0.toggle()
     time.sleep_ms(5)
 print(pin_irq_count_trigger == 0)
@@ -81,7 +83,7 @@ def pin_handler (pin_o):
 pin1_irq.init(trigger=Pin.IRQ_LOW_LEVEL, wake=machine.SLEEP)
 machine.sleep()
 print(time.ticks_ms() - t0 < 10)
-print('Awake')
+print("Awake")
 
 # test waking up from suspended mode on high level
 pin0(1)
@@ -89,7 +91,7 @@ def pin_handler (pin_o):
 pin1_irq.init(trigger=Pin.IRQ_HIGH_LEVEL, wake=machine.SLEEP)
 machine.sleep()
 print(time.ticks_ms() - t0 < 10)
-print('Awake')
+print("Awake")
 
 # check for memory leaks
 for i in range(0, 1000):
@@ -100,17 +102,19 @@ def pin_handler (pin_o):
 try:
     pin1_irq.init(trigger=123456, handler=pin_handler)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     pin1_irq.init(trigger=Pin.IRQ_LOW_LEVEL, wake=1789456)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
-    pin0_irq = pin0.irq(trigger=Pin.IRQ_RISING, wake=machine.SLEEP)  # GP16 can't wake up from DEEPSLEEP
+    pin0_irq = pin0.irq(
+        trigger=Pin.IRQ_RISING, wake=machine.SLEEP
+    )  # GP16 can't wake up from DEEPSLEEP
 except:
-    print('Exception')
+    print("Exception")
 
 pin0_irq.disable()
 pin1_irq.disable()
diff --git a/tests/wipy/reset/reset.py b/tests/wipy/reset/reset.py
index 35a970c6734e5..8d314f3b49b6f 100644
--- a/tests/wipy/reset/reset.py
+++ b/tests/wipy/reset/reset.py
@@ -1,16 +1,16 @@
-'''
+"""
 Reset script for the cc3200 boards
 This is needed to force the board to reboot
 with the default WLAN AP settings
-'''
+"""
 
 from machine import WDT
 import time
 import os
 
 mch = os.uname().machine
-if not 'LaunchPad' in mch and not 'WiPy' in mch:
-    raise Exception('Board not supported!')
+if not "LaunchPad" in mch and not "WiPy" in mch:
+    raise Exception("Board not supported!")
 
 wdt = WDT(timeout=1000)
 print(wdt)
diff --git a/tests/wipy/rtc.py b/tests/wipy/rtc.py
index 2737ebe73a13e..c62e400fe3094 100644
--- a/tests/wipy/rtc.py
+++ b/tests/wipy/rtc.py
@@ -1,14 +1,14 @@
-'''
+"""
 RTC test for the CC3200 based boards.
-'''
+"""
 
 from machine import RTC
 import os
 import time
 
 mch = os.uname().machine
-if not 'LaunchPad' in mch and not 'WiPy' in mch:
-    raise Exception('Board not supported!')
+if not "LaunchPad" in mch and not "WiPy" in mch:
+    raise Exception("Board not supported!")
 
 rtc = RTC()
 print(rtc)
@@ -41,10 +41,12 @@
 rtc.init((2015, 9, 19))
 print(rtc.now()[3])
 
+
 def set_and_print(datetime):
     rtc.init(datetime)
     print(rtc.now()[:6])
 
+
 # make sure that setting works correctly
 set_and_print((2000, 1, 1, 0, 0, 0, 0, None))
 set_and_print((2000, 1, 31, 0, 0, 0, 0, None))
@@ -66,7 +68,7 @@ def set_and_print(datetime):
 rtc.alarm(time=2000)
 time.sleep_ms(1000)
 left = rtc.alarm_left()
-print(abs(left-1000) <= 10)
+print(abs(left - 1000) <= 10)
 time.sleep_ms(1000)
 print(rtc.alarm_left() == 0)
 time.sleep_ms(100)
@@ -75,13 +77,13 @@ def set_and_print(datetime):
 rtc.alarm(time=1000, repeat=True)
 time.sleep_ms(1500)
 left = rtc.alarm_left()
-print(abs(left-500) <= 15)
+print(abs(left - 500) <= 15)
 
 rtc.init((2015, 8, 29, 9, 0, 0, 0, None))
 rtc.alarm(time=(2015, 8, 29, 9, 0, 45))
 time.sleep_ms(1000)
 left = rtc.alarm_left()
-print(abs(left-44000) <= 90)
+print(abs(left - 44000) <= 90)
 rtc.alarm_cancel()
 rtc.deinit()
 
@@ -89,29 +91,29 @@ def set_and_print(datetime):
 try:
     rtc.alarm(5000)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     rtc.alarm_left(1)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     rtc.alarm_cancel(1)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     rtc.alarm(5000)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     rtc = RTC(200000000)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     rtc = RTC((2015, 8, 29, 9, 0, 0, 0, None))
 except:
-    print('Exception')
+    print("Exception")
diff --git a/tests/wipy/sd.py b/tests/wipy/sd.py
index 92746e01edd9b..381d46f30a701 100644
--- a/tests/wipy/sd.py
+++ b/tests/wipy/sd.py
@@ -1,17 +1,17 @@
-'''
+"""
 SD card test for the CC3200 based boards.
-'''
+"""
 
 from machine import SD
 import os
 
 mch = os.uname().machine
-if 'LaunchPad' in mch:
-    sd_pins = ('GP16', 'GP17', 'GP15')
-elif 'WiPy' in mch:
-    sd_pins = ('GP10', 'GP11', 'GP15')
+if "LaunchPad" in mch:
+    sd_pins = ("GP16", "GP17", "GP15")
+elif "WiPy" in mch:
+    sd_pins = ("GP10", "GP11", "GP15")
 else:
-    raise Exception('Board not supported!')
+    raise Exception("Board not supported!")
 
 sd = SD(pins=sd_pins)
 print(sd)
@@ -35,12 +35,11 @@
     print("Exception")
 
 try:
-    sd = SD(pins=('GP10', 'GP11', 'GP8'))
+    sd = SD(pins=("GP10", "GP11", "GP8"))
 except Exception:
     print("Exception")
 
 try:
-    sd = SD(pins=('GP10', 'GP11'))
+    sd = SD(pins=("GP10", "GP11"))
 except Exception:
     print("Exception")
-
diff --git a/tests/wipy/skipped/rtc_irq.py b/tests/wipy/skipped/rtc_irq.py
index ec3baa552426b..99712f8d18e4b 100644
--- a/tests/wipy/skipped/rtc_irq.py
+++ b/tests/wipy/skipped/rtc_irq.py
@@ -1,6 +1,6 @@
-'''
+"""
 RTC IRQ test for the CC3200 based boards.
-'''
+"""
 
 from machine import RTC
 import machine
@@ -8,21 +8,25 @@
 import time
 
 mch = os.uname().machine
-if not 'LaunchPad' in mch and not 'WiPy' in mch:
-    raise Exception('Board not supported!')
+if not "LaunchPad" in mch and not "WiPy" in mch:
+    raise Exception("Board not supported!")
+
 
 def rtc_ticks_ms(rtc):
     timedate = rtc.now()
     return (timedate[5] * 1000) + (timedate[6] // 1000)
 
+
 rtc_irq_count = 0
 
-def alarm_handler (rtc_o):
+
+def alarm_handler(rtc_o):
     global rtc_irq
     global rtc_irq_count
     if rtc_irq.flags() & RTC.ALARM0:
         rtc_irq_count += 1
 
+
 rtc = RTC()
 rtc.alarm(time=500, repeat=True)
 rtc_irq = rtc.irq(trigger=RTC.ALARM0, handler=alarm_handler)
@@ -81,9 +85,9 @@ def alarm_handler (rtc_o):
 try:
     rtc_irq = rtc.irq(trigger=10, handler=alarm_handler)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     rtc_irq = rtc.irq(trigger=RTC.ALARM0, wake=1789456)
 except:
-    print('Exception')
+    print("Exception")
diff --git a/tests/wipy/spi.py b/tests/wipy/spi.py
index 6bd7aabce1d25..a3509d8542489 100644
--- a/tests/wipy/spi.py
+++ b/tests/wipy/spi.py
@@ -1,17 +1,17 @@
-'''
+"""
 SPI test for the CC3200 based boards.
-'''
+"""
 
 from machine import SPI
 import os
 
 mch = os.uname().machine
-if 'LaunchPad' in mch:
-    spi_pins = ('GP14', 'GP16', 'GP30')
-elif 'WiPy' in mch:
-    spi_pins = ('GP14', 'GP16', 'GP30')
+if "LaunchPad" in mch:
+    spi_pins = ("GP14", "GP16", "GP30")
+elif "WiPy" in mch:
+    spi_pins = ("GP14", "GP16", "GP30")
 else:
-    raise Exception('Board not supported!')
+    raise Exception("Board not supported!")
 
 spi = SPI(0, SPI.MASTER, baudrate=2000000, polarity=0, phase=0, firstbit=SPI.MSB, pins=spi_pins)
 print(spi)
@@ -27,15 +27,15 @@
 print(spi)
 spi.init(baudrate=20000000, polarity=0, phase=0)
 print(spi)
-spi=SPI()
+spi = SPI()
 print(spi)
 SPI(mode=SPI.MASTER)
 SPI(mode=SPI.MASTER, pins=spi_pins)
-SPI(id=0, mode=SPI.MASTER, polarity=0, phase=0, pins=('GP14', 'GP16', 'GP15'))
-SPI(0, SPI.MASTER, polarity=0, phase=0, pins=('GP31', 'GP16', 'GP15'))
+SPI(id=0, mode=SPI.MASTER, polarity=0, phase=0, pins=("GP14", "GP16", "GP15"))
+SPI(0, SPI.MASTER, polarity=0, phase=0, pins=("GP31", "GP16", "GP15"))
 
 spi = SPI(0, SPI.MASTER, baudrate=10000000, polarity=0, phase=0, pins=spi_pins)
-print(spi.write('123456') == 6)
+print(spi.write("123456") == 6)
 buffer_r = bytearray(10)
 print(spi.readinto(buffer_r) == 10)
 print(spi.readinto(buffer_r, write=0x55) == 10)
@@ -76,7 +76,7 @@
 print(buffer_w == buffer_r)
 
 # check for memory leaks...
-for i in range (0, 1000):
+for i in range(0, 1000):
     spi = SPI(0, SPI.MASTER, baudrate=1000000)
 
 # test deinit
@@ -112,7 +112,7 @@
     print("Exception")
 
 try:
-    spi = SPI(0, mode=SPI.MASTER, baudrate=2000000, polarity=2, phase=0, pins=('GP1', 'GP2'))
+    spi = SPI(0, mode=SPI.MASTER, baudrate=2000000, polarity=2, phase=0, pins=("GP1", "GP2"))
 except:
     print("Exception")
 
@@ -133,7 +133,7 @@
     print("Exception")
 
 try:
-    spi.spi.write('abc')
+    spi.spi.write("abc")
 except Exception:
     print("Exception")
 
diff --git a/tests/wipy/time.py b/tests/wipy/time.py
index e6237de356f63..4a550b94945f0 100644
--- a/tests/wipy/time.py
+++ b/tests/wipy/time.py
@@ -2,12 +2,14 @@
 
 DAYS_PER_MONTH = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
 
+
 def is_leap(year):
     return (year % 4) == 0
 
+
 def test():
     seconds = 0
-    wday = 5    # Jan 1, 2000 was a Saturday
+    wday = 5  # Jan 1, 2000 was a Saturday
     for year in range(2000, 2049):
         print("Testing %d" % year)
         yday = 1
@@ -19,31 +21,48 @@ def test():
             for day in range(1, DAYS_PER_MONTH[month] + 1):
                 secs = time.mktime((year, month, day, 0, 0, 0, 0, 0))
                 if secs != seconds:
-                    print("mktime failed for %d-%02d-%02d got %d expected %d" % (year, month, day, secs, seconds))
+                    print(
+                        "mktime failed for %d-%02d-%02d got %d expected %d"
+                        % (year, month, day, secs, seconds)
+                    )
                 tuple = time.localtime(seconds)
                 secs = time.mktime(tuple)
                 if secs != seconds:
-                    print("localtime failed for %d-%02d-%02d got %d expected %d" % (year, month, day, secs, seconds))
+                    print(
+                        "localtime failed for %d-%02d-%02d got %d expected %d"
+                        % (year, month, day, secs, seconds)
+                    )
                     return
                 seconds += 86400
                 if yday != tuple[7]:
-                    print("locatime for %d-%02d-%02d got yday %d, expecting %d" % (year, month, day, tuple[7], yday))
+                    print(
+                        "locatime for %d-%02d-%02d got yday %d, expecting %d"
+                        % (year, month, day, tuple[7], yday)
+                    )
                     return
                 if wday != tuple[6]:
-                    print("locatime for %d-%02d-%02d got wday %d, expecting %d" % (year, month, day, tuple[6], wday))
+                    print(
+                        "locatime for %d-%02d-%02d got wday %d, expecting %d"
+                        % (year, month, day, tuple[6], wday)
+                    )
                     return
                 yday += 1
                 wday = (wday + 1) % 7
 
+
 def spot_test(seconds, expected_time):
     actual_time = time.localtime(seconds)
     for i in range(len(actual_time)):
         if actual_time[i] != expected_time[i]:
-            print("time.localtime(", seconds, ") returned", actual_time, "expecting", expected_time)
+            print(
+                "time.localtime(", seconds, ") returned", actual_time, "expecting", expected_time
+            )
             return
     print("time.localtime(", seconds, ") returned", actual_time, "(pass)")
 
+
 test()
+# fmt: off
 spot_test(          0,  (2000,  1,  1,  0,  0,  0, 5,   1))
 spot_test(          1,  (2000,  1,  1,  0,  0,  1, 5,   1))
 spot_test(         59,  (2000,  1,  1,  0,  0, 59, 5,   1))
@@ -56,16 +75,17 @@ def spot_test(seconds, expected_time):
 spot_test(-1072915199,  (1966,  1,  1,  0,  0,  1, 5,   1))
 spot_test(-1072915200,  (1966,  1,  1,  0,  0,  0, 5,   1))
 spot_test(-1072915201,  (1965, 12, 31, 23, 59, 59, 4, 365))
+# fmt: on
 
 t1 = time.time()
 time.sleep(2)
 t2 = time.time()
-print(abs(time.ticks_diff(t1, t2) -2) <= 1)
+print(abs(time.ticks_diff(t1, t2) - 2) <= 1)
 
 t1 = time.ticks_ms()
 time.sleep_ms(50)
 t2 = time.ticks_ms()
-print(abs(time.ticks_diff(t1, t2)- 50) <= 1)
+print(abs(time.ticks_diff(t1, t2) - 50) <= 1)
 
 t1 = time.ticks_us()
 time.sleep_us(1000)
diff --git a/tests/wipy/timer.py b/tests/wipy/timer.py
index f62899b472fa3..db25870db0f05 100644
--- a/tests/wipy/timer.py
+++ b/tests/wipy/timer.py
@@ -1,18 +1,18 @@
-'''
+"""
 Timer test for the CC3200 based boards.
-'''
+"""
 
 from machine import Timer
 import os
 import time
 
 mch = os.uname().machine
-if 'LaunchPad' in mch:
-    pwm_pin = ('GP24')
-elif 'WiPy' in mch:
-    pwm_pin = ('GP24')
+if "LaunchPad" in mch:
+    pwm_pin = "GP24"
+elif "WiPy" in mch:
+    pwm_pin = "GP24"
 else:
-    raise Exception('Board not supported!')
+    raise Exception("Board not supported!")
 
 for i in range(4):
     tim = Timer(i, mode=Timer.PERIODIC)
@@ -49,6 +49,7 @@ def __init__(self):
     def timer_isr(self, tim_ch):
         self.int_count += 1
 
+
 timer_test = TimerTest()
 ch = timer_test.tim.channel(Timer.A, freq=5)
 print(ch.freq() == 5)
@@ -92,26 +93,26 @@ def timer_isr(self, tim_ch):
 try:
     tim = Timer(0, mode=12)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     tim = Timer(4, mode=Timer.ONE_SHOT)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     tim = Timer(0, mode=Timer.PWM, width=32)
 except:
-    print('Exception')
+    print("Exception")
 
 tim = Timer(0, mode=Timer.PWM)
 
 try:
     ch = tim.channel(TIMER_A | TIMER_B, freq=10)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     ch = tim.channel(TIMER_A, freq=4)
 except:
-    print('Exception')
+    print("Exception")
diff --git a/tests/wipy/uart.py b/tests/wipy/uart.py
index 8e794015dea0b..9498d955451ce 100644
--- a/tests/wipy/uart.py
+++ b/tests/wipy/uart.py
@@ -1,7 +1,7 @@
-'''
+"""
 UART test for the CC3200 based boards. 
 UART0 and UART1 must be connected together for this test to pass.
-'''
+"""
 
 from machine import UART
 from machine import Pin
@@ -9,14 +9,20 @@
 import time
 
 mch = os.uname().machine
-if 'LaunchPad' in mch:
+if "LaunchPad" in mch:
     uart_id_range = range(0, 2)
-    uart_pins = [[('GP12', 'GP13'), ('GP12', 'GP13', 'GP7', 'GP6')], [('GP16', 'GP17'), ('GP16', 'GP17', 'GP7', 'GP6')]]
-elif 'WiPy' in mch:
+    uart_pins = [
+        [("GP12", "GP13"), ("GP12", "GP13", "GP7", "GP6")],
+        [("GP16", "GP17"), ("GP16", "GP17", "GP7", "GP6")],
+    ]
+elif "WiPy" in mch:
     uart_id_range = range(0, 2)
-    uart_pins = [[('GP12', 'GP13'), ('GP12', 'GP13', 'GP7', 'GP6')], [('GP16', 'GP17'), ('GP16', 'GP17', 'GP7', 'GP6')]]
+    uart_pins = [
+        [("GP12", "GP13"), ("GP12", "GP13", "GP7", "GP6")],
+        [("GP16", "GP17"), ("GP16", "GP17", "GP7", "GP6")],
+    ]
 else:
-    raise Exception('Board not supported!')
+    raise Exception("Board not supported!")
 
 # just in case we have the repl duplicated on any of the uarts
 os.dupterm(None)
@@ -33,13 +39,13 @@
 uart = UART(baudrate=1000000)
 uart = UART()
 print(uart)
-uart = UART(baudrate=38400, pins=('GP12', 'GP13'))
+uart = UART(baudrate=38400, pins=("GP12", "GP13"))
 print(uart)
-uart = UART(pins=('GP12', 'GP13'))
+uart = UART(pins=("GP12", "GP13"))
 print(uart)
-uart = UART(pins=(None, 'GP17'))
+uart = UART(pins=(None, "GP17"))
 print(uart)
-uart = UART(baudrate=57600, pins=('GP16', 'GP17'))
+uart = UART(baudrate=57600, pins=("GP16", "GP17"))
 print(uart)
 
 # now it's time for some loopback tests between the uarts
@@ -48,104 +54,104 @@
 uart1 = UART(1, 1000000, pins=uart_pins[1][0])
 print(uart1)
 
-print(uart0.write(b'123456') == 6)
-print(uart1.read() == b'123456')
+print(uart0.write(b"123456") == 6)
+print(uart1.read() == b"123456")
 
-print(uart1.write(b'123') == 3)
-print(uart0.read(1) == b'1')
-print(uart0.read(2) == b'23')
+print(uart1.write(b"123") == 3)
+print(uart0.read(1) == b"1")
+print(uart0.read(2) == b"23")
 print(uart0.read() == None)
 
-uart0.write(b'123')
+uart0.write(b"123")
 buf = bytearray(3)
-print(uart1.readinto(buf, 1) == 1) 
+print(uart1.readinto(buf, 1) == 1)
 print(buf)
 print(uart1.readinto(buf) == 2)
 print(buf)
 
 # try initializing without the id
 uart0 = UART(baudrate=1000000, pins=uart_pins[0][0])
-uart0.write(b'1234567890')
-time.sleep_ms(2) # because of the fifo interrupt levels
+uart0.write(b"1234567890")
+time.sleep_ms(2)  # because of the fifo interrupt levels
 print(uart1.any() == 10)
-print(uart1.readline() == b'1234567890')
+print(uart1.readline() == b"1234567890")
 print(uart1.any() == 0)
 
-uart0.write(b'1234567890')
-print(uart1.read() == b'1234567890')
+uart0.write(b"1234567890")
+print(uart1.read() == b"1234567890")
 
 # tx only mode
-uart0 = UART(0, 1000000, pins=('GP12', None))
-print(uart0.write(b'123456') == 6)
-print(uart1.read() == b'123456')
-print(uart1.write(b'123') == 3)
+uart0 = UART(0, 1000000, pins=("GP12", None))
+print(uart0.write(b"123456") == 6)
+print(uart1.read() == b"123456")
+print(uart1.write(b"123") == 3)
 print(uart0.read() == None)
 
 # rx only mode
-uart0 = UART(0, 1000000, pins=(None, 'GP13'))
-print(uart0.write(b'123456') == 6)
+uart0 = UART(0, 1000000, pins=(None, "GP13"))
+print(uart0.write(b"123456") == 6)
 print(uart1.read() == None)
-print(uart1.write(b'123') == 3)
-print(uart0.read() == b'123')
+print(uart1.write(b"123") == 3)
+print(uart0.read() == b"123")
 
 # leave pins as they were (rx only mode)
 uart0 = UART(0, 1000000, pins=None)
-print(uart0.write(b'123456') == 6)
+print(uart0.write(b"123456") == 6)
 print(uart1.read() == None)
-print(uart1.write(b'123') == 3)
-print(uart0.read() == b'123')
+print(uart1.write(b"123") == 3)
+print(uart0.read() == b"123")
 
 # no pin assignment
 uart0 = UART(0, 1000000, pins=(None, None))
-print(uart0.write(b'123456789') == 9)
+print(uart0.write(b"123456789") == 9)
 print(uart1.read() == None)
-print(uart1.write(b'123456789') == 9)
+print(uart1.write(b"123456789") == 9)
 print(uart0.read() == None)
 print(Pin.board.GP12)
 print(Pin.board.GP13)
 
 # check for memory leaks...
-for i in range (0, 1000):
+for i in range(0, 1000):
     uart0 = UART(0, 1000000)
     uart1 = UART(1, 1000000)
 
 # next ones must raise
 try:
-    UART(0, 9600, parity=None, pins=('GP12', 'GP13', 'GP7'))
+    UART(0, 9600, parity=None, pins=("GP12", "GP13", "GP7"))
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
-    UART(0, 9600, parity=UART.ODD, pins=('GP12', 'GP7'))
+    UART(0, 9600, parity=UART.ODD, pins=("GP12", "GP7"))
 except Exception:
-    print('Exception')
+    print("Exception")
 
 uart0 = UART(0, 1000000)
 uart0.deinit()
 try:
     uart0.any()
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
     uart0.read()
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
-    uart0.write('abc')
+    uart0.write("abc")
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
-    uart0.sendbreak('abc')
+    uart0.sendbreak("abc")
 except Exception:
-    print('Exception')
+    print("Exception")
 
 try:
     UART(2, 9600)
 except Exception:
-    print('Exception')    
+    print("Exception")
 
 for uart_id in uart_id_range:
     uart = UART(uart_id, 1000000)
diff --git a/tests/wipy/uart_irq.py b/tests/wipy/uart_irq.py
index d4cd900585ef7..e631e46a9c2fa 100644
--- a/tests/wipy/uart_irq.py
+++ b/tests/wipy/uart_irq.py
@@ -1,18 +1,24 @@
-'''
+"""
 UART IRQ test for the CC3200 based boards.
-'''
+"""
 
 from machine import UART
 import os
 import time
 
 mch = os.uname().machine
-if 'LaunchPad' in mch:
-    uart_pins = [[('GP12', 'GP13'), ('GP12', 'GP13', 'GP7', 'GP6')], [('GP16', 'GP17'), ('GP16', 'GP17', 'GP7', 'GP6')]]
-elif 'WiPy' in mch:
-    uart_pins = [[('GP12', 'GP13'), ('GP12', 'GP13', 'GP7', 'GP6')], [('GP16', 'GP17'), ('GP16', 'GP17', 'GP7', 'GP6')]]
+if "LaunchPad" in mch:
+    uart_pins = [
+        [("GP12", "GP13"), ("GP12", "GP13", "GP7", "GP6")],
+        [("GP16", "GP17"), ("GP16", "GP17", "GP7", "GP6")],
+    ]
+elif "WiPy" in mch:
+    uart_pins = [
+        [("GP12", "GP13"), ("GP12", "GP13", "GP7", "GP6")],
+        [("GP16", "GP17"), ("GP16", "GP17", "GP7", "GP6")],
+    ]
 else:
-    raise Exception('Board not supported!')
+    raise Exception("Board not supported!")
 
 # just in case we have stdio duplicated on any of the uarts
 os.dupterm(None)
@@ -23,22 +29,25 @@
 uart0_int_count = 0
 uart1_int_count = 0
 
-def uart0_handler (uart_o):
+
+def uart0_handler(uart_o):
     global uart0_irq
     global uart0_int_count
-    if (uart0_irq.flags() & UART.RX_ANY):
+    if uart0_irq.flags() & UART.RX_ANY:
         uart0_int_count += 1
 
-def uart1_handler (uart_o):
+
+def uart1_handler(uart_o):
     global uart1_irq
     global uart1_int_count
-    if (uart1_irq.flags() & UART.RX_ANY):
+    if uart1_irq.flags() & UART.RX_ANY:
         uart1_int_count += 1
 
+
 uart0_irq = uart0.irq(trigger=UART.RX_ANY, handler=uart0_handler)
 uart1_irq = uart1.irq(trigger=UART.RX_ANY, handler=uart1_handler)
 
-uart0.write(b'123')
+uart0.write(b"123")
 # wait for the characters to be received
 while not uart1.any():
     pass
@@ -48,9 +57,9 @@ def uart1_handler (uart_o):
 print(uart1_int_count > 0)
 print(uart1_irq.flags() == 0)
 print(uart0_irq.flags() == 0)
-print(uart1.read() == b'123')
+print(uart1.read() == b"123")
 
-uart1.write(b'12345')
+uart1.write(b"12345")
 # wait for the characters to be received
 while not uart0.any():
     pass
@@ -60,11 +69,11 @@ def uart1_handler (uart_o):
 print(uart0_int_count > 0)
 print(uart0_irq.flags() == 0)
 print(uart1_irq.flags() == 0)
-print(uart0.read() == b'12345')
+print(uart0.read() == b"12345")
 
 # do it again
 uart1_int_count = 0
-uart0.write(b'123')
+uart0.write(b"123")
 # wait for the characters to be received
 while not uart1.any():
     pass
@@ -74,29 +83,29 @@ def uart1_handler (uart_o):
 print(uart1_int_count > 0)
 print(uart1_irq.flags() == 0)
 print(uart0_irq.flags() == 0)
-print(uart1.read() == b'123')
+print(uart1.read() == b"123")
 
 # disable the interrupt
 uart1_irq.disable()
 # do it again
 uart1_int_count = 0
-uart0.write(b'123')
+uart0.write(b"123")
 # wait for the characters to be received
 while not uart1.any():
     pass
 
 time.sleep_us(100)
 print(uart1.any() == 3)
-print(uart1_int_count == 0) # no interrupt triggered this time
+print(uart1_int_count == 0)  # no interrupt triggered this time
 print(uart1_irq.flags() == 0)
 print(uart0_irq.flags() == 0)
-print(uart1.read() == b'123')
+print(uart1.read() == b"123")
 
 # enable the interrupt
 uart1_irq.enable()
 # do it again
 uart1_int_count = 0
-uart0.write(b'123')
+uart0.write(b"123")
 # wait for the characters to be received
 while not uart1.any():
     pass
@@ -106,22 +115,22 @@ def uart1_handler (uart_o):
 print(uart1_int_count > 0)
 print(uart1_irq.flags() == 0)
 print(uart0_irq.flags() == 0)
-print(uart1.read() == b'123')
+print(uart1.read() == b"123")
 
-uart1_irq.init(trigger=UART.RX_ANY, handler=None) # No handler
+uart1_irq.init(trigger=UART.RX_ANY, handler=None)  # No handler
 # do it again
 uart1_int_count = 0
-uart0.write(b'123')
+uart0.write(b"123")
 # wait for the characters to be received
 while not uart1.any():
     pass
 
 time.sleep_us(100)
 print(uart1.any() == 3)
-print(uart1_int_count == 0) # no interrupt handler called
+print(uart1_int_count == 0)  # no interrupt handler called
 print(uart1_irq.flags() == 0)
 print(uart0_irq.flags() == 0)
-print(uart1.read() == b'123')
+print(uart1.read() == b"123")
 
 # check for memory leaks
 for i in range(0, 1000):
@@ -132,17 +141,17 @@ def uart1_handler (uart_o):
 try:
     uart0_irq = uart0.irq(trigger=100, handler=uart0_handler)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     uart0_irq = uart0.irq(trigger=0)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     uart0_irq = uart0.irq(trigger=UART.RX_ANY, wake=Sleep.SUSPENDED)
 except:
-    print('Exception')
+    print("Exception")
 
 uart0_irq.disable()
 uart1_irq.disable()
diff --git a/tests/wipy/wdt.py b/tests/wipy/wdt.py
index a894b88fd8f2f..56f6ea8d95ae3 100644
--- a/tests/wipy/wdt.py
+++ b/tests/wipy/wdt.py
@@ -1,6 +1,6 @@
-'''
+"""
 WDT test for the CC3200 based boards
-'''
+"""
 
 from machine import WDT
 import time
diff --git a/tests/wipy/wlan/machine.py b/tests/wipy/wlan/machine.py
index 2ee5299651498..f69b117b74551 100644
--- a/tests/wipy/wlan/machine.py
+++ b/tests/wipy/wlan/machine.py
@@ -1,14 +1,14 @@
-'''
+"""
 machine test for the CC3200 based boards.
-'''
+"""
 
 import machine
 import os
 from network import WLAN
 
 mch = os.uname().machine
-if not 'LaunchPad' in mch and not'WiPy' in mch:
-    raise Exception('Board not supported!')
+if not "LaunchPad" in mch and not "WiPy" in mch:
+    raise Exception("Board not supported!")
 
 wifi = WLAN()
 
@@ -17,7 +17,7 @@
 print(machine.freq() == (80000000,))
 print(machine.unique_id() == wifi.mac())
 
-machine.main('main.py')
+machine.main("main.py")
 
 rand_nums = []
 for i in range(0, 100):
@@ -25,7 +25,7 @@
     if rand not in rand_nums:
         rand_nums.append(rand)
     else:
-        print('RNG number repeated')
+        print("RNG number repeated")
         break
 
 for i in range(0, 10):
@@ -39,4 +39,4 @@
 try:
     machine.main(123456)
 except:
-    print('Exception')
+    print("Exception")
diff --git a/tests/wipy/wlan/server.py b/tests/wipy/wlan/server.py
index 05847e376126c..40f56745c9afb 100644
--- a/tests/wipy/wlan/server.py
+++ b/tests/wipy/wlan/server.py
@@ -1,13 +1,13 @@
-'''
+"""
 network server test for the CC3200 based boards.
-'''
+"""
 
 import os
 import network
 
 mch = os.uname().machine
-if not 'LaunchPad' in mch and not'WiPy' in mch:
-    raise Exception('Board not supported!')
+if not "LaunchPad" in mch and not "WiPy" in mch:
+    raise Exception("Board not supported!")
 
 server = network.Server()
 
@@ -16,7 +16,7 @@
 server.deinit()
 print(server.isrunning() == False)
 
-server.init(login=('test-user', 'test-password'), timeout=60)
+server.init(login=("test-user", "test-password"), timeout=60)
 print(server.isrunning() == True)
 print(server.timeout() == 60)
 
@@ -28,14 +28,14 @@
 try:
     server.init(1)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
-    server.init(0, login=('0000000000011111111111222222222222333333', 'abc'))
+    server.init(0, login=("0000000000011111111111222222222222333333", "abc"))
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     server.timeout(1)
 except:
-    print('Exception')
+    print("Exception")
diff --git a/tests/wipy/wlan/wlan.py b/tests/wipy/wlan/wlan.py
index 49e2e4af6a223..dd85c86967dfb 100644
--- a/tests/wipy/wlan/wlan.py
+++ b/tests/wipy/wlan/wlan.py
@@ -1,6 +1,6 @@
-'''
+"""
 WLAN test for the CC3200 based boards.
-'''
+"""
 
 from network import WLAN
 import os
@@ -8,8 +8,8 @@
 import testconfig
 
 mch = os.uname().machine
-if not 'LaunchPad' in mch and not 'WiPy' in mch:
-    raise Exception('Board not supported!')
+if not "LaunchPad" in mch and not "WiPy" in mch:
+    raise Exception("Board not supported!")
 
 
 def wait_for_connection(wifi, timeout=10):
@@ -17,9 +17,9 @@ def wait_for_connection(wifi, timeout=10):
         time.sleep(1)
         timeout -= 1
     if wifi.isconnected():
-        print('Connected')
+        print("Connected")
     else:
-        print('Connection failed!')
+        print("Connection failed!")
 
 
 wifi = WLAN(0, WLAN.STA)
@@ -31,16 +31,16 @@ def wait_for_connection(wifi, timeout=10):
 print(wifi.channel() == 1)
 print(wifi.auth() == None)
 print(wifi.antenna() == WLAN.INT_ANT)
-wifi = WLAN(0, mode=WLAN.AP, ssid='test-wlan', auth=(WLAN.WPA, '123456abc'), channel=7)
+wifi = WLAN(0, mode=WLAN.AP, ssid="test-wlan", auth=(WLAN.WPA, "123456abc"), channel=7)
 print(wifi.mode() == WLAN.AP)
 print(wifi.channel() == 7)
-print(wifi.ssid() == 'test-wlan')
-print(wifi.auth() == (WLAN.WPA, '123456abc'))
+print(wifi.ssid() == "test-wlan")
+print(wifi.auth() == (WLAN.WPA, "123456abc"))
 print(wifi.antenna() == WLAN.INT_ANT)
 
 wifi = WLAN(mode=WLAN.STA)
 print(wifi.mode() == WLAN.STA)
-time.sleep(5) # this ensures a full network scan
+time.sleep(5)  # this ensures a full network scan
 scan_r = wifi.scan()
 print(len(scan_r) > 3)
 for net in scan_r:
@@ -50,30 +50,30 @@ def wait_for_connection(wifi, timeout=10):
         print(net.channel == None)
         print(net.sec == testconfig.wlan_auth[0])
         print(net.rssi < 0)
-        print('Network found')
+        print("Network found")
         break
 
 wifi.mode(WLAN.STA)
 print(wifi.mode() == WLAN.STA)
 wifi.channel(7)
 print(wifi.channel() == 7)
-wifi.ssid('t-wlan')
-print(wifi.ssid() == 't-wlan')
+wifi.ssid("t-wlan")
+print(wifi.ssid() == "t-wlan")
 wifi.auth(None)
 print(wifi.auth() == None)
-wifi.auth((WLAN.WEP, '11223344556677889900'))
-print(wifi.auth() == (WLAN.WEP, '11223344556677889900'))
+wifi.auth((WLAN.WEP, "11223344556677889900"))
+print(wifi.auth() == (WLAN.WEP, "11223344556677889900"))
 wifi.antenna(WLAN.INT_ANT)
 print(wifi.antenna() == WLAN.INT_ANT)
 
 wifi.antenna(WLAN.EXT_ANT)
 print(wifi.antenna() == WLAN.EXT_ANT)
-time.sleep(2) # this ensures a full network scan
+time.sleep(2)  # this ensures a full network scan
 scan_r = wifi.scan()
 print(len(scan_r) > 3)
 for net in scan_r:
     if net.ssid == testconfig.wlan_ssid:
-        print('Network found')
+        print("Network found")
         break
 
 wifi.antenna(WLAN.INT_ANT)
@@ -82,12 +82,12 @@ def wait_for_connection(wifi, timeout=10):
 wifi.connect(testconfig.wlan_ssid, auth=testconfig.wlan_auth, timeout=10000)
 wait_for_connection(wifi)
 
-wifi.ifconfig(config='dhcp')
+wifi.ifconfig(config="dhcp")
 wait_for_connection(wifi)
-print('0.0.0.0' not in wifi.ifconfig())
-wifi.ifconfig(0, ('192.168.178.109', '255.255.255.0', '192.168.178.1', '8.8.8.8'))
+print("0.0.0.0" not in wifi.ifconfig())
+wifi.ifconfig(0, ("192.168.178.109", "255.255.255.0", "192.168.178.1", "8.8.8.8"))
 wait_for_connection(wifi)
-print(wifi.ifconfig(0) == ('192.168.178.109', '255.255.255.0', '192.168.178.1', '8.8.8.8'))
+print(wifi.ifconfig(0) == ("192.168.178.109", "255.255.255.0", "192.168.178.1", "8.8.8.8"))
 wait_for_connection(wifi)
 
 print(wifi.isconnected() == True)
@@ -102,7 +102,7 @@ def wait_for_connection(wifi, timeout=10):
 print(wifi.isconnected() == False)
 
 # test init again
-wifi.init(WLAN.AP, ssid='www.wipy.io', auth=None, channel=5, antenna=WLAN.INT_ANT)
+wifi.init(WLAN.AP, ssid="www.wipy.io", auth=None, channel=5, antenna=WLAN.INT_ANT)
 print(wifi.mode() == WLAN.AP)
 
 # get the current instance without re-init
@@ -118,65 +118,66 @@ def wait_for_connection(wifi, timeout=10):
 try:
     wifi.init(mode=12345)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     wifi.init(1, mode=WLAN.AP)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     wifi.init(mode=WLAN.AP, ssid=None)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     wifi = WLAN(mode=WLAN.AP, channel=12)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     wifi.antenna(2)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     wifi.mode(10)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
-    wifi.ssid('11111sdfasdfasdfasdf564sdf654asdfasdf123451245ssdgfsdf1111111111111111111111111234123412341234asdfasdf')
+    wifi.ssid(
+        "11111sdfasdfasdfasdf564sdf654asdfasdf123451245ssdgfsdf1111111111111111111111111234123412341234asdfasdf"
+    )
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     wifi.auth((0))
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     wifi.auth((0, None))
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     wifi.auth((10, 10))
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     wifi.channel(0)
 except:
-    print('Exception')
+    print("Exception")
 
 try:
-    wifi.ifconfig(1, 'dhcp')
+    wifi.ifconfig(1, "dhcp")
 except:
-    print('Exception')
+    print("Exception")
 
 try:
     wifi.ifconfig(config=())
 except:
-    print('Exception')
-
+    print("Exception")
diff --git a/tools/check_code_size.sh b/tools/check_code_size.sh
deleted file mode 100755
index 2925ff168996f..0000000000000
--- a/tools/check_code_size.sh
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/bin/bash
-#
-# This script check that changes don't lead to code size regressions.
-# (Size of the language core (== minimal port should not grow)).
-#
-
-REFERENCE=$HOME/persist/firmware.bin
-#REFERENCE=/tmp/micropython
-#TRAVIS_PULL_REQUEST=false
-
-if [ -f $REFERENCE ]; then
-    size_old=$(stat -c%s $REFERENCE)
-    size_new=$(stat -c%s ports/minimal/build/firmware.bin)
-    echo "Old size: $size_old new size: $size_new"
-    if [ $size_new -gt $size_old ]; then
-        echo "Validation failure: Core code size increased"
-        if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then
-            exit 1
-        fi
-    fi
-else
-    echo "Warning: reference file doesn't exist, code size check didn't run"
-fi
diff --git a/tools/codeformat.py b/tools/codeformat.py
new file mode 100755
index 0000000000000..5aef4ccfbf242
--- /dev/null
+++ b/tools/codeformat.py
@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+#
+# This file is part of the MicroPython project, http://micropython.org/
+#
+# The MIT License (MIT)
+#
+# Copyright (c) 2020 Damien P. George
+# Copyright (c) 2020 Jim Mussared
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+import argparse
+import glob
+import itertools
+import os
+import re
+import subprocess
+
+# Relative to top-level repo dir.
+PATHS = [
+    # C
+    "extmod/*.[ch]",
+    "lib/netutils/*.[ch]",
+    "lib/timeutils/*.[ch]",
+    "lib/utils/*.[ch]",
+    "mpy-cross/*.[ch]",
+    "ports/*/*.[ch]",
+    "ports/windows/msvc/**/*.[ch]",
+    "py/*.[ch]",
+    # Python
+    "drivers/**/*.py",
+    "examples/**/*.py",
+    "extmod/**/*.py",
+    "ports/**/*.py",
+    "py/**/*.py",
+    "tools/**/*.py",
+    "tests/**/*.py",
+]
+
+EXCLUSIONS = [
+    # STM32 build includes generated Python code.
+    "ports/*/build*",
+    # gitignore in ports/unix ignores *.py, so also do it here.
+    "ports/unix/*.py",
+    # not real python files
+    "tests/**/repl_*.py",
+    # needs careful attention before applying automatic formatting
+    "tests/basics/*.py",
+]
+
+# Path to repo top-level dir.
+TOP = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+
+UNCRUSTIFY_CFG = os.path.join(TOP, "tools/uncrustify.cfg")
+
+C_EXTS = (
+    ".c",
+    ".h",
+)
+PY_EXTS = (".py",)
+
+
+FIXUP_REPLACEMENTS = ((re.compile("sizeof\(([a-z_]+)\) \*\(([a-z_]+)\)"), r"sizeof(\1) * (\2)"),)
+
+
+def list_files(paths, exclusions=None, prefix=""):
+    files = set()
+    for pattern in paths:
+        files.update(glob.glob(os.path.join(prefix, pattern), recursive=True))
+    for pattern in exclusions or []:
+        files.difference_update(glob.fnmatch.filter(files, os.path.join(prefix, pattern)))
+    return sorted(files)
+
+
+def fixup_c(filename):
+    # Read file.
+    with open(filename) as f:
+        lines = f.readlines()
+
+    # Write out file with fixups.
+    with open(filename, "w", newline="") as f:
+        dedent_stack = []
+        while lines:
+            # Get next line.
+            l = lines.pop(0)
+
+            # Dedent #'s to match indent of following line (not previous line).
+            m = re.match(r"( +)#(if |ifdef |ifndef |elif |else|endif)", l)
+            if m:
+                indent = len(m.group(1))
+                directive = m.group(2)
+                if directive in ("if ", "ifdef ", "ifndef "):
+                    l_next = lines[0]
+                    indent_next = len(re.match(r"( *)", l_next).group(1))
+                    if indent - 4 == indent_next and re.match(r" +(} else |case )", l_next):
+                        # This #-line (and all associated ones) needs dedenting by 4 spaces.
+                        l = l[4:]
+                        dedent_stack.append(indent - 4)
+                    else:
+                        # This #-line does not need dedenting.
+                        dedent_stack.append(-1)
+                else:
+                    if dedent_stack[-1] >= 0:
+                        # This associated #-line needs dedenting to match the #if.
+                        indent_diff = indent - dedent_stack[-1]
+                        assert indent_diff >= 0
+                        l = l[indent_diff:]
+                    if directive == "endif":
+                        dedent_stack.pop()
+
+            # Apply general regex-based fixups.
+            for regex, replacement in FIXUP_REPLACEMENTS:
+                l = regex.sub(replacement, l)
+
+            # Write out line.
+            f.write(l)
+
+        assert not dedent_stack, filename
+
+
+def main():
+    cmd_parser = argparse.ArgumentParser(description="Auto-format C and Python files.")
+    cmd_parser.add_argument("-c", action="store_true", help="Format C code only")
+    cmd_parser.add_argument("-p", action="store_true", help="Format Python code only")
+    cmd_parser.add_argument("-v", action="store_true", help="Enable verbose output")
+    cmd_parser.add_argument("files", nargs="*", help="Run on specific globs")
+    args = cmd_parser.parse_args()
+
+    # Setting only one of -c or -p disables the other. If both or neither are set, then do both.
+    format_c = args.c or not args.p
+    format_py = args.p or not args.c
+
+    # Expand the globs passed on the command line, or use the default globs above.
+    files = []
+    if args.files:
+        files = list_files(args.files)
+    else:
+        files = list_files(PATHS, EXCLUSIONS, TOP)
+
+    # Extract files matching a specific language.
+    def lang_files(exts):
+        for file in files:
+            if os.path.splitext(file)[1].lower() in exts:
+                yield file
+
+    # Run tool on N files at a time (to avoid making the command line too long).
+    def batch(cmd, files, N=200):
+        while True:
+            file_args = list(itertools.islice(files, N))
+            if not file_args:
+                break
+            subprocess.check_call(cmd + file_args)
+
+    # Format C files with uncrustify.
+    if format_c:
+        command = ["uncrustify", "-c", UNCRUSTIFY_CFG, "-lC", "--no-backup"]
+        if not args.v:
+            command.append("-q")
+        batch(command, lang_files(C_EXTS))
+        for file in lang_files(C_EXTS):
+            fixup_c(file)
+
+    # Format Python files with black.
+    if format_py:
+        command = ["black", "--fast", "--line-length=99"]
+        if args.v:
+            command.append("-v")
+        else:
+            command.append("-q")
+        batch(command, lang_files(PY_EXTS))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/dfu.py b/tools/dfu.py
index ee89c7541e3a7..6591436e9e211 100755
--- a/tools/dfu.py
+++ b/tools/dfu.py
@@ -4,122 +4,160 @@
 # Distributed under Gnu LGPL 3.0
 # see http://www.gnu.org/licenses/lgpl-3.0.txt
 
-import sys,struct,zlib,os
+import sys, struct, zlib, os
 from optparse import OptionParser
 
-DEFAULT_DEVICE="0x0483:0xdf11"
+DEFAULT_DEVICE = "0x0483:0xdf11"
+
+
+def named(tuple, names):
+    return dict(zip(names.split(), tuple))
+
+
+def consume(fmt, data, names):
+    n = struct.calcsize(fmt)
+    return named(struct.unpack(fmt, data[:n]), names), data[n:]
+
 
-def named(tuple,names):
-  return dict(zip(names.split(),tuple))
-def consume(fmt,data,names):
-  n = struct.calcsize(fmt)
-  return named(struct.unpack(fmt,data[:n]),names),data[n:]
 def cstring(string):
-  return string.split('\0',1)[0]
+    return string.split("\0", 1)[0]
+
+
 def compute_crc(data):
-  return 0xFFFFFFFF & -zlib.crc32(data) -1
-
-def parse(file,dump_images=False):
-  print ('File: "%s"' % file)
-  data = open(file,'rb').read()
-  crc = compute_crc(data[:-4])
-  prefix, data = consume('<5sBIB',data,'signature version size targets')
-  print ('%(signature)s v%(version)d, image size: %(size)d, targets: %(targets)d' % prefix)
-  for t in range(prefix['targets']):
-    tprefix, data  = consume('<6sBI255s2I',data,'signature altsetting named name size elements')
-    tprefix['num'] = t
-    if tprefix['named']:
-      tprefix['name'] = cstring(tprefix['name'])
-    else:
-      tprefix['name'] = ''
-    print ('%(signature)s %(num)d, alt setting: %(altsetting)s, name: "%(name)s", size: %(size)d, elements: %(elements)d' % tprefix)
-    tsize = tprefix['size']
-    target, data = data[:tsize], data[tsize:]
-    for e in range(tprefix['elements']):
-      eprefix, target = consume('<2I',target,'address size')
-      eprefix['num'] = e
-      print ('  %(num)d, address: 0x%(address)08x, size: %(size)d' % eprefix)
-      esize = eprefix['size']
-      image, target = target[:esize], target[esize:]
-      if dump_images:
-        out = '%s.target%d.image%d.bin' % (file,t,e)
-        open(out,'wb').write(image)
-        print ('    DUMPED IMAGE TO "%s"' % out)
-    if len(target):
-      print ("target %d: PARSE ERROR" % t)
-  suffix = named(struct.unpack('<4H3sBI',data[:16]),'device product vendor dfu ufd len crc')
-  print ('usb: %(vendor)04x:%(product)04x, device: 0x%(device)04x, dfu: 0x%(dfu)04x, %(ufd)s, %(len)d, 0x%(crc)08x' % suffix)
-  if crc != suffix['crc']:
-    print ("CRC ERROR: computed crc32 is 0x%08x" % crc)
-  data = data[16:]
-  if data:
-    print ("PARSE ERROR")
-
-def build(file,targets,device=DEFAULT_DEVICE):
-  data = b''
-  for t,target in enumerate(targets):
-    tdata = b''
-    for image in target:
-      # pad image to 8 bytes (needed at least for L476)
-      pad = (8 - len(image['data']) % 8 ) % 8
-      image['data'] = image['data'] + bytes(bytearray(8)[0:pad])
-      #
-      tdata += struct.pack('<2I',image['address'],len(image['data']))+image['data']
-    tdata = struct.pack('<6sBI255s2I',b'Target',0,1, b'ST...',len(tdata),len(target)) + tdata
-    data += tdata
-  data  = struct.pack('<5sBIB',b'DfuSe',1,len(data)+11,len(targets)) + data
-  v,d=map(lambda x: int(x,0) & 0xFFFF, device.split(':',1))
-  data += struct.pack('<4H3sB',0,d,v,0x011a,b'UFD',16)
-  crc   = compute_crc(data)
-  data += struct.pack('<I',crc)
-  open(file,'wb').write(data)
-
-if __name__=="__main__":
-  usage = """
+    return 0xFFFFFFFF & -zlib.crc32(data) - 1
+
+
+def parse(file, dump_images=False):
+    print('File: "%s"' % file)
+    data = open(file, "rb").read()
+    crc = compute_crc(data[:-4])
+    prefix, data = consume("<5sBIB", data, "signature version size targets")
+    print("%(signature)s v%(version)d, image size: %(size)d, targets: %(targets)d" % prefix)
+    for t in range(prefix["targets"]):
+        tprefix, data = consume(
+            "<6sBI255s2I", data, "signature altsetting named name size elements"
+        )
+        tprefix["num"] = t
+        if tprefix["named"]:
+            tprefix["name"] = cstring(tprefix["name"])
+        else:
+            tprefix["name"] = ""
+        print(
+            '%(signature)s %(num)d, alt setting: %(altsetting)s, name: "%(name)s", size: %(size)d, elements: %(elements)d'
+            % tprefix
+        )
+        tsize = tprefix["size"]
+        target, data = data[:tsize], data[tsize:]
+        for e in range(tprefix["elements"]):
+            eprefix, target = consume("<2I", target, "address size")
+            eprefix["num"] = e
+            print("  %(num)d, address: 0x%(address)08x, size: %(size)d" % eprefix)
+            esize = eprefix["size"]
+            image, target = target[:esize], target[esize:]
+            if dump_images:
+                out = "%s.target%d.image%d.bin" % (file, t, e)
+                open(out, "wb").write(image)
+                print('    DUMPED IMAGE TO "%s"' % out)
+        if len(target):
+            print("target %d: PARSE ERROR" % t)
+    suffix = named(struct.unpack("<4H3sBI", data[:16]), "device product vendor dfu ufd len crc")
+    print(
+        "usb: %(vendor)04x:%(product)04x, device: 0x%(device)04x, dfu: 0x%(dfu)04x, %(ufd)s, %(len)d, 0x%(crc)08x"
+        % suffix
+    )
+    if crc != suffix["crc"]:
+        print("CRC ERROR: computed crc32 is 0x%08x" % crc)
+    data = data[16:]
+    if data:
+        print("PARSE ERROR")
+
+
+def build(file, targets, device=DEFAULT_DEVICE):
+    data = b""
+    for t, target in enumerate(targets):
+        tdata = b""
+        for image in target:
+            # pad image to 8 bytes (needed at least for L476)
+            pad = (8 - len(image["data"]) % 8) % 8
+            image["data"] = image["data"] + bytes(bytearray(8)[0:pad])
+            #
+            tdata += struct.pack("<2I", image["address"], len(image["data"])) + image["data"]
+        tdata = (
+            struct.pack("<6sBI255s2I", b"Target", 0, 1, b"ST...", len(tdata), len(target)) + tdata
+        )
+        data += tdata
+    data = struct.pack("<5sBIB", b"DfuSe", 1, len(data) + 11, len(targets)) + data
+    v, d = map(lambda x: int(x, 0) & 0xFFFF, device.split(":", 1))
+    data += struct.pack("<4H3sB", 0, d, v, 0x011A, b"UFD", 16)
+    crc = compute_crc(data)
+    data += struct.pack("<I", crc)
+    open(file, "wb").write(data)
+
+
+if __name__ == "__main__":
+    usage = """
 %prog [-d|--dump] infile.dfu
 %prog {-b|--build} address:file.bin [-b address:file.bin ...] [{-D|--device}=vendor:device] outfile.dfu"""
-  parser = OptionParser(usage=usage)
-  parser.add_option("-b", "--build", action="append", dest="binfiles",
-    help="build a DFU file from given BINFILES", metavar="BINFILES")
-  parser.add_option("-D", "--device", action="store", dest="device",
-    help="build for DEVICE, defaults to %s" % DEFAULT_DEVICE, metavar="DEVICE")
-  parser.add_option("-d", "--dump", action="store_true", dest="dump_images",
-    default=False, help="dump contained images to current directory")
-  (options, args) = parser.parse_args()
-
-  if options.binfiles and len(args)==1:
-    target = []
-    for arg in options.binfiles:
-      try:
-        address,binfile = arg.split(':',1)
-      except ValueError:
-        print ("Address:file couple '%s' invalid." % arg)
-        sys.exit(1)
-      try:
-        address = int(address,0) & 0xFFFFFFFF
-      except ValueError:
-        print ("Address %s invalid." % address)
-        sys.exit(1)
-      if not os.path.isfile(binfile):
-        print ("Unreadable file '%s'." % binfile)
+    parser = OptionParser(usage=usage)
+    parser.add_option(
+        "-b",
+        "--build",
+        action="append",
+        dest="binfiles",
+        help="build a DFU file from given BINFILES",
+        metavar="BINFILES",
+    )
+    parser.add_option(
+        "-D",
+        "--device",
+        action="store",
+        dest="device",
+        help="build for DEVICE, defaults to %s" % DEFAULT_DEVICE,
+        metavar="DEVICE",
+    )
+    parser.add_option(
+        "-d",
+        "--dump",
+        action="store_true",
+        dest="dump_images",
+        default=False,
+        help="dump contained images to current directory",
+    )
+    (options, args) = parser.parse_args()
+
+    if options.binfiles and len(args) == 1:
+        target = []
+        for arg in options.binfiles:
+            try:
+                address, binfile = arg.split(":", 1)
+            except ValueError:
+                print("Address:file couple '%s' invalid." % arg)
+                sys.exit(1)
+            try:
+                address = int(address, 0) & 0xFFFFFFFF
+            except ValueError:
+                print("Address %s invalid." % address)
+                sys.exit(1)
+            if not os.path.isfile(binfile):
+                print("Unreadable file '%s'." % binfile)
+                sys.exit(1)
+            target.append({"address": address, "data": open(binfile, "rb").read()})
+        outfile = args[0]
+        device = DEFAULT_DEVICE
+        if options.device:
+            device = options.device
+        try:
+            v, d = map(lambda x: int(x, 0) & 0xFFFF, device.split(":", 1))
+        except:
+            print("Invalid device '%s'." % device)
+            sys.exit(1)
+        build(outfile, [target], device)
+    elif len(args) == 1:
+        infile = args[0]
+        if not os.path.isfile(infile):
+            print("Unreadable file '%s'." % infile)
+            sys.exit(1)
+        parse(infile, dump_images=options.dump_images)
+    else:
+        parser.print_help()
         sys.exit(1)
-      target.append({ 'address': address, 'data': open(binfile,'rb').read() })
-    outfile = args[0]
-    device = DEFAULT_DEVICE
-    if options.device:
-      device=options.device
-    try:
-      v,d=map(lambda x: int(x,0) & 0xFFFF, device.split(':',1))
-    except:
-      print ("Invalid device '%s'." % device)
-      sys.exit(1)
-    build(outfile,[target],device)
-  elif len(args)==1:
-    infile = args[0]
-    if not os.path.isfile(infile):
-      print ("Unreadable file '%s'." % infile)
-      sys.exit(1)
-    parse(infile, dump_images=options.dump_images)
-  else:
-    parser.print_help()
-    sys.exit(1)
diff --git a/tools/file2h.py b/tools/file2h.py
index 2a04ae22b9437..4607ab9279dc6 100644
--- a/tools/file2h.py
+++ b/tools/file2h.py
@@ -12,19 +12,19 @@
 # Can either be set explicitly, or left blank to auto-detect
 # Except auto-detect doesn't work because the file has been passed
 # through Python text processing, which makes all EOL a \n
-line_end = '\\r\\n'
+line_end = "\\r\\n"
 
 if __name__ == "__main__":
     filename = sys.argv[1]
-    for line in open(filename, 'r').readlines():
+    for line in open(filename, "r").readlines():
         if not line_end:
-            for ending in ('\r\n', '\r', '\n'):
+            for ending in ("\r\n", "\r", "\n"):
                 if line.endswith(ending):
-                    line_end = ending.replace('\r', '\\r').replace('\n', '\\n')
+                    line_end = ending.replace("\r", "\\r").replace("\n", "\\n")
                     break
             if not line_end:
                 raise Exception("Couldn't auto-detect line-ending of %s" % filename)
-        line = line.rstrip('\r\n')
-        line = line.replace('\\', '\\\\')
+        line = line.rstrip("\r\n")
+        line = line.replace("\\", "\\\\")
         line = line.replace('"', '\\"')
         print('"%s%s"' % (line, line_end))
diff --git a/tools/gen-cpydiff.py b/tools/gen-cpydiff.py
index 8aef375149348..c45bad1058c44 100644
--- a/tools/gen-cpydiff.py
+++ b/tools/gen-cpydiff.py
@@ -37,89 +37,128 @@
 # such version should be used to test for differences. If your default python3
 # executable is of lower version, you can point MICROPY_CPYTHON3 environment var
 # to the correct executable.
-if os.name == 'nt':
-    CPYTHON3 = os.getenv('MICROPY_CPYTHON3', 'python3.exe')
-    MICROPYTHON = os.getenv('MICROPY_MICROPYTHON', '../ports/windows/micropython.exe')
+if os.name == "nt":
+    CPYTHON3 = os.getenv("MICROPY_CPYTHON3", "python3.exe")
+    MICROPYTHON = os.getenv("MICROPY_MICROPYTHON", "../ports/windows/micropython.exe")
 else:
-    CPYTHON3 = os.getenv('MICROPY_CPYTHON3', 'python3')
-    MICROPYTHON = os.getenv('MICROPY_MICROPYTHON', '../ports/unix/micropython')
-
-TESTPATH = '../tests/cpydiff/'
-DOCPATH = '../docs/genrst/'
-INDEXTEMPLATE = '../docs/differences/index_template.txt'
-INDEX = 'index.rst'
-
-HEADER = '.. This document was generated by tools/gen-cpydiff.py\n\n'
-UIMPORTLIST = {'struct', 'collections', 'json'}
-CLASSMAP = {'Core': 'Core Language', 'Types': 'Builtin Types'}
-INDEXPRIORITY = ['syntax', 'core_language', 'builtin_types', 'modules']
-RSTCHARS = ['=', '-', '~', '`', ':']
+    CPYTHON3 = os.getenv("MICROPY_CPYTHON3", "python3")
+    MICROPYTHON = os.getenv("MICROPY_MICROPYTHON", "../ports/unix/micropython")
+
+TESTPATH = "../tests/cpydiff/"
+DOCPATH = "../docs/genrst/"
+INDEXTEMPLATE = "../docs/differences/index_template.txt"
+INDEX = "index.rst"
+
+HEADER = ".. This document was generated by tools/gen-cpydiff.py\n\n"
+UIMPORTLIST = {"struct", "collections", "json"}
+CLASSMAP = {"Core": "Core language", "Types": "Builtin types"}
+INDEXPRIORITY = ["syntax", "core_language", "builtin_types", "modules"]
+RSTCHARS = ["=", "-", "~", "`", ":"]
 SPLIT = '"""\n|categories: |description: |cause: |workaround: '
-TAB = '    '
+TAB = "    "
+
+Output = namedtuple(
+    "output",
+    [
+        "name",
+        "class_",
+        "desc",
+        "cause",
+        "workaround",
+        "code",
+        "output_cpy",
+        "output_upy",
+        "status",
+    ],
+)
 
-Output = namedtuple('output', ['name', 'class_', 'desc', 'cause', 'workaround', 'code',
-                               'output_cpy', 'output_upy', 'status'])
 
 def readfiles():
     """ Reads test files """
-    tests = list(filter(lambda x: x.endswith('.py'), os.listdir(TESTPATH)))
+    tests = list(filter(lambda x: x.endswith(".py"), os.listdir(TESTPATH)))
     tests.sort()
     files = []
 
     for test in tests:
-        text = open(TESTPATH + test, 'r').read()
+        text = open(TESTPATH + test, "r").read()
 
         try:
-            class_, desc, cause, workaround, code = [x.rstrip() for x in \
-                                                    list(filter(None, re.split(SPLIT, text)))]
-            output = Output(test, class_, desc, cause, workaround, code, '', '', '')
+            class_, desc, cause, workaround, code = [
+                x.rstrip() for x in list(filter(None, re.split(SPLIT, text)))
+            ]
+            output = Output(test, class_, desc, cause, workaround, code, "", "", "")
             files.append(output)
         except IndexError:
-            print('Incorrect format in file ' + TESTPATH + test)
+            print("Incorrect format in file " + TESTPATH + test)
 
     return files
 
+
 def uimports(code):
     """ converts CPython module names into MicroPython equivalents """
     for uimport in UIMPORTLIST:
-        uimport = bytes(uimport, 'utf8')
-        code = code.replace(uimport, b'u' + uimport)
+        uimport = bytes(uimport, "utf8")
+        code = code.replace(uimport, b"u" + uimport)
     return code
 
+
 def run_tests(tests):
     """ executes all tests """
     results = []
     for test in tests:
-        with open(TESTPATH + test.name, 'rb') as f:
+        with open(TESTPATH + test.name, "rb") as f:
             input_cpy = f.read()
         input_upy = uimports(input_cpy)
 
-        process = subprocess.Popen(CPYTHON3, shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
-        output_cpy = [com.decode('utf8') for com in process.communicate(input_cpy)]
+        process = subprocess.Popen(
+            CPYTHON3,
+            shell=True,
+            stdout=subprocess.PIPE,
+            stdin=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        output_cpy = [com.decode("utf8") for com in process.communicate(input_cpy)]
 
-        process = subprocess.Popen(MICROPYTHON, shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
-        output_upy = [com.decode('utf8') for com in process.communicate(input_upy)]
+        process = subprocess.Popen(
+            MICROPYTHON,
+            shell=True,
+            stdout=subprocess.PIPE,
+            stdin=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        output_upy = [com.decode("utf8") for com in process.communicate(input_upy)]
 
         if output_cpy[0] == output_upy[0] and output_cpy[1] == output_upy[1]:
-            status = 'Supported'
-            print('Supported operation!\nFile: ' + TESTPATH + test.name)
+            status = "Supported"
+            print("Supported operation!\nFile: " + TESTPATH + test.name)
         else:
-            status = 'Unsupported'
+            status = "Unsupported"
 
-        output = Output(test.name, test.class_, test.desc, test.cause,
-                        test.workaround, test.code, output_cpy, output_upy, status)
+        output = Output(
+            test.name,
+            test.class_,
+            test.desc,
+            test.cause,
+            test.workaround,
+            test.code,
+            output_cpy,
+            output_upy,
+            status,
+        )
         results.append(output)
 
     results.sort(key=lambda x: x.class_)
     return results
 
+
 def indent(block, spaces):
     """ indents paragraphs of text for rst formatting """
-    new_block = ''
-    for line in block.split('\n'):
-        new_block += spaces + line + '\n'
+    new_block = ""
+    for line in block.split("\n"):
+        new_block += spaces + line + "\n"
     return new_block
 
+
 def gen_table(contents):
     """ creates a table given any set of columns """
     xlengths = []
@@ -127,31 +166,32 @@ def gen_table(contents):
     for column in contents:
         col_len = 0
         for entry in column:
-            lines = entry.split('\n')
+            lines = entry.split("\n")
             for line in lines:
                 col_len = max(len(line) + 2, col_len)
         xlengths.append(col_len)
     for i in range(len(contents[0])):
         ymax = 0
         for j in range(len(contents)):
-            ymax = max(ymax, len(contents[j][i].split('\n')))
+            ymax = max(ymax, len(contents[j][i].split("\n")))
         ylengths.append(ymax)
 
-    table_divider = '+' + ''.join(['-' * i + '+' for i in xlengths]) + '\n'
+    table_divider = "+" + "".join(["-" * i + "+" for i in xlengths]) + "\n"
     table = table_divider
     for i in range(len(ylengths)):
         row = [column[i] for column in contents]
-        row = [entry + '\n' * (ylengths[i]-len(entry.split('\n'))) for entry in row]
-        row = [entry.split('\n') for entry in row]
+        row = [entry + "\n" * (ylengths[i] - len(entry.split("\n"))) for entry in row]
+        row = [entry.split("\n") for entry in row]
         for j in range(ylengths[i]):
             k = 0
             for entry in row:
                 width = xlengths[k]
-                table += ''.join(['| {:{}}'.format(entry[j], width - 1)])
+                table += "".join(["| {:{}}".format(entry[j], width - 1)])
                 k += 1
-            table += '|\n'
+            table += "|\n"
         table += table_divider
-    return table + '\n'
+    return table + "\n"
+
 
 def gen_rst(results):
     """ creates restructured text documents to display tests """
@@ -166,61 +206,63 @@ def gen_rst(results):
     toctree = []
     class_ = []
     for output in results:
-        section = output.class_.split(',')
+        section = output.class_.split(",")
         for i in range(len(section)):
             section[i] = section[i].rstrip()
             if section[i] in CLASSMAP:
                 section[i] = CLASSMAP[section[i]]
             if i >= len(class_) or section[i] != class_[i]:
                 if i == 0:
-                    filename = section[i].replace(' ', '_').lower()
-                    rst = open(DOCPATH + filename + '.rst', 'w')
+                    filename = section[i].replace(" ", "_").lower()
+                    rst = open(DOCPATH + filename + ".rst", "w")
                     rst.write(HEADER)
-                    rst.write(section[i] + '\n')
+                    rst.write(section[i] + "\n")
                     rst.write(RSTCHARS[0] * len(section[i]))
                     rst.write(time.strftime("\nGenerated %a %d %b %Y %X UTC\n\n", time.gmtime()))
                     toctree.append(filename)
                 else:
-                    rst.write(section[i] + '\n')
-                    rst.write(RSTCHARS[min(i, len(RSTCHARS)-1)] * len(section[i]))
-                    rst.write('\n\n')
+                    rst.write(section[i] + "\n")
+                    rst.write(RSTCHARS[min(i, len(RSTCHARS) - 1)] * len(section[i]))
+                    rst.write("\n\n")
         class_ = section
-        rst.write('.. _cpydiff_%s:\n\n' % output.name.rsplit('.', 1)[0])
-        rst.write(output.desc + '\n')
-        rst.write('~' * len(output.desc) + '\n\n')
-        if output.cause != 'Unknown':
-            rst.write('**Cause:** ' + output.cause + '\n\n')
-        if output.workaround != 'Unknown':
-            rst.write('**Workaround:** ' + output.workaround + '\n\n')
-
-        rst.write('Sample code::\n\n' + indent(output.code, TAB) + '\n')
-        output_cpy = indent(''.join(output.output_cpy[0:2]), TAB).rstrip()
-        output_cpy = ('::\n\n' if output_cpy != '' else '') + output_cpy
-        output_upy = indent(''.join(output.output_upy[0:2]), TAB).rstrip()
-        output_upy = ('::\n\n' if output_upy != '' else '') + output_upy
-        table = gen_table([['CPy output:', output_cpy], ['uPy output:', output_upy]])
+        rst.write(".. _cpydiff_%s:\n\n" % output.name.rsplit(".", 1)[0])
+        rst.write(output.desc + "\n")
+        rst.write("~" * len(output.desc) + "\n\n")
+        if output.cause != "Unknown":
+            rst.write("**Cause:** " + output.cause + "\n\n")
+        if output.workaround != "Unknown":
+            rst.write("**Workaround:** " + output.workaround + "\n\n")
+
+        rst.write("Sample code::\n\n" + indent(output.code, TAB) + "\n")
+        output_cpy = indent("".join(output.output_cpy[0:2]), TAB).rstrip()
+        output_cpy = ("::\n\n" if output_cpy != "" else "") + output_cpy
+        output_upy = indent("".join(output.output_upy[0:2]), TAB).rstrip()
+        output_upy = ("::\n\n" if output_upy != "" else "") + output_upy
+        table = gen_table([["CPy output:", output_cpy], ["uPy output:", output_upy]])
         rst.write(table)
 
-    template = open(INDEXTEMPLATE, 'r')
-    index = open(DOCPATH + INDEX, 'w')
+    template = open(INDEXTEMPLATE, "r")
+    index = open(DOCPATH + INDEX, "w")
     index.write(HEADER)
     index.write(template.read())
     for section in INDEXPRIORITY:
         if section in toctree:
-            index.write(indent(section + '.rst', TAB))
+            index.write(indent(section + ".rst", TAB))
             toctree.remove(section)
     for section in toctree:
-        index.write(indent(section + '.rst', TAB))
+        index.write(indent(section + ".rst", TAB))
+
 
 def main():
     """ Main function """
 
     # set search path so that test scripts find the test modules (and no other ones)
-    os.environ['PYTHONPATH'] = TESTPATH
-    os.environ['MICROPYPATH'] = TESTPATH
+    os.environ["PYTHONPATH"] = TESTPATH
+    os.environ["MICROPYPATH"] = TESTPATH
 
     files = readfiles()
     results = run_tests(files)
     gen_rst(results)
 
+
 main()
diff --git a/tools/gendoc.py b/tools/gendoc.py
index 61844d203f162..0f13056995c90 100644
--- a/tools/gendoc.py
+++ b/tools/gendoc.py
@@ -15,10 +15,12 @@ def re_match_first(regexs, line):
             return name, match
     return None, None
 
+
 def makedirs(d):
     if not os.path.isdir(d):
         os.makedirs(d)
 
+
 class Lexer:
     class LexerError(Exception):
         pass
@@ -31,15 +33,15 @@ class Break(Exception):
 
     def __init__(self, file):
         self.filename = file
-        with open(file, 'rt') as f:
+        with open(file, "rt") as f:
             line_num = 0
             lines = []
             for line in f:
                 line_num += 1
                 line = line.strip()
-                if line == '///':
-                    lines.append((line_num, ''))
-                elif line.startswith('/// '):
+                if line == "///":
+                    lines.append((line_num, ""))
+                elif line.startswith("/// "):
                     lines.append((line_num, line[4:]))
                 elif len(lines) > 0 and lines[-1][1] is not None:
                     lines.append((line_num, None))
@@ -64,9 +66,10 @@ def next(self):
                 return l[1]
 
     def error(self, msg):
-        print('({}:{}) {}'.format(self.filename, self.cur_line, msg))
+        print("({}:{}) {}".format(self.filename, self.cur_line, msg))
         raise Lexer.LexerError
 
+
 class MarkdownWriter:
     def __init__(self):
         pass
@@ -75,52 +78,53 @@ def start(self):
         self.lines = []
 
     def end(self):
-        return '\n'.join(self.lines)
+        return "\n".join(self.lines)
 
     def heading(self, level, text):
         if len(self.lines) > 0:
-            self.lines.append('')
-        self.lines.append(level * '#' + ' ' + text)
-        self.lines.append('')
+            self.lines.append("")
+        self.lines.append(level * "#" + " " + text)
+        self.lines.append("")
 
     def para(self, text):
-        if len(self.lines) > 0 and self.lines[-1] != '':
-            self.lines.append('')
+        if len(self.lines) > 0 and self.lines[-1] != "":
+            self.lines.append("")
         if isinstance(text, list):
             self.lines.extend(text)
         elif isinstance(text, str):
             self.lines.append(text)
         else:
             assert False
-        self.lines.append('')
+        self.lines.append("")
 
     def single_line(self, text):
         self.lines.append(text)
 
     def module(self, name, short_descr, descr):
-        self.heading(1, 'module {}'.format(name))
+        self.heading(1, "module {}".format(name))
         self.para(descr)
 
     def function(self, ctx, name, args, descr):
-        proto = '{}.{}{}'.format(ctx, self.name, self.args)
-        self.heading(3, '`' + proto + '`')
+        proto = "{}.{}{}".format(ctx, self.name, self.args)
+        self.heading(3, "`" + proto + "`")
         self.para(descr)
 
     def method(self, ctx, name, args, descr):
-        if name == '\\constructor':
-            proto = '{}{}'.format(ctx, args)
-        elif name == '\\call':
-            proto = '{}{}'.format(ctx, args)
+        if name == "\\constructor":
+            proto = "{}{}".format(ctx, args)
+        elif name == "\\call":
+            proto = "{}{}".format(ctx, args)
         else:
-            proto = '{}.{}{}'.format(ctx, name, args)
-        self.heading(3, '`' + proto + '`')
+            proto = "{}.{}{}".format(ctx, name, args)
+        self.heading(3, "`" + proto + "`")
         self.para(descr)
 
     def constant(self, ctx, name, descr):
-        self.single_line('`{}.{}` - {}'.format(ctx, name, descr))
+        self.single_line("`{}.{}` - {}".format(ctx, name, descr))
+
 
 class ReStructuredTextWriter:
-    head_chars = {1:'=', 2:'-', 3:'.'}
+    head_chars = {1: "=", 2: "-", 3: "."}
 
     def __init__(self):
         pass
@@ -129,23 +133,23 @@ def start(self):
         self.lines = []
 
     def end(self):
-        return '\n'.join(self.lines)
+        return "\n".join(self.lines)
 
     def _convert(self, text):
-        return text.replace('`', '``').replace('*', '\\*')
+        return text.replace("`", "``").replace("*", "\\*")
 
     def heading(self, level, text, convert=True):
         if len(self.lines) > 0:
-            self.lines.append('')
+            self.lines.append("")
         if convert:
             text = self._convert(text)
         self.lines.append(text)
         self.lines.append(len(text) * self.head_chars[level])
-        self.lines.append('')
+        self.lines.append("")
 
-    def para(self, text, indent=''):
-        if len(self.lines) > 0 and self.lines[-1] != '':
-            self.lines.append('')
+    def para(self, text, indent=""):
+        if len(self.lines) > 0 and self.lines[-1] != "":
+            self.lines.append("")
         if isinstance(text, list):
             for t in text:
                 self.lines.append(indent + self._convert(t))
@@ -153,39 +157,41 @@ def para(self, text, indent=''):
             self.lines.append(indent + self._convert(text))
         else:
             assert False
-        self.lines.append('')
+        self.lines.append("")
 
     def single_line(self, text):
         self.lines.append(self._convert(text))
 
     def module(self, name, short_descr, descr):
-        self.heading(1, ':mod:`{}` --- {}'.format(name, self._convert(short_descr)), convert=False)
-        self.lines.append('.. module:: {}'.format(name))
-        self.lines.append('   :synopsis: {}'.format(short_descr))
+        self.heading(1, ":mod:`{}` --- {}".format(name, self._convert(short_descr)), convert=False)
+        self.lines.append(".. module:: {}".format(name))
+        self.lines.append("   :synopsis: {}".format(short_descr))
         self.para(descr)
 
     def function(self, ctx, name, args, descr):
         args = self._convert(args)
-        self.lines.append('.. function:: ' + name + args)
-        self.para(descr, indent='   ')
+        self.lines.append(".. function:: " + name + args)
+        self.para(descr, indent="   ")
 
     def method(self, ctx, name, args, descr):
         args = self._convert(args)
-        if name == '\\constructor':
-            self.lines.append('.. class:: ' + ctx + args)
-        elif name == '\\call':
-            self.lines.append('.. method:: ' + ctx + args)
+        if name == "\\constructor":
+            self.lines.append(".. class:: " + ctx + args)
+        elif name == "\\call":
+            self.lines.append(".. method:: " + ctx + args)
         else:
-            self.lines.append('.. method:: ' + ctx + '.' + name + args)
-        self.para(descr, indent='   ')
+            self.lines.append(".. method:: " + ctx + "." + name + args)
+        self.para(descr, indent="   ")
 
     def constant(self, ctx, name, descr):
-        self.lines.append('.. data:: ' + name)
-        self.para(descr, indent='   ')
+        self.lines.append(".. data:: " + name)
+        self.para(descr, indent="   ")
+
 
 class DocValidateError(Exception):
     pass
 
+
 class DocItem:
     def __init__(self):
         self.doc = []
@@ -202,6 +208,7 @@ def add_doc(self, lex):
     def dump(self, writer):
         writer.para(self.doc)
 
+
 class DocConstant(DocItem):
     def __init__(self, name, descr):
         super().__init__()
@@ -211,6 +218,7 @@ def __init__(self, name, descr):
     def dump(self, ctx, writer):
         writer.constant(ctx, self.name, self.descr)
 
+
 class DocFunction(DocItem):
     def __init__(self, name, args):
         super().__init__()
@@ -220,6 +228,7 @@ def __init__(self, name, args):
     def dump(self, ctx, writer):
         writer.function(ctx, self.name, self.args, self.doc)
 
+
 class DocMethod(DocItem):
     def __init__(self, name, args):
         super().__init__()
@@ -229,6 +238,7 @@ def __init__(self, name, args):
     def dump(self, ctx, writer):
         writer.method(ctx, self.name, self.args, self.doc)
 
+
 class DocClass(DocItem):
     def __init__(self, name, descr):
         super().__init__()
@@ -240,51 +250,52 @@ def __init__(self, name, descr):
         self.constants = {}
 
     def process_classmethod(self, lex, d):
-        name = d['id']
-        if name == '\\constructor':
+        name = d["id"]
+        if name == "\\constructor":
             dict_ = self.constructors
         else:
             dict_ = self.classmethods
         if name in dict_:
             lex.error("multiple definition of method '{}'".format(name))
-        method = dict_[name] = DocMethod(name, d['args'])
+        method = dict_[name] = DocMethod(name, d["args"])
         method.add_doc(lex)
 
     def process_method(self, lex, d):
-        name = d['id']
+        name = d["id"]
         dict_ = self.methods
         if name in dict_:
             lex.error("multiple definition of method '{}'".format(name))
-        method = dict_[name] = DocMethod(name, d['args'])
+        method = dict_[name] = DocMethod(name, d["args"])
         method.add_doc(lex)
 
     def process_constant(self, lex, d):
-        name = d['id']
+        name = d["id"]
         if name in self.constants:
             lex.error("multiple definition of constant '{}'".format(name))
-        self.constants[name] = DocConstant(name, d['descr'])
+        self.constants[name] = DocConstant(name, d["descr"])
         lex.opt_break()
 
     def dump(self, writer):
-        writer.heading(1, 'class {}'.format(self.name))
+        writer.heading(1, "class {}".format(self.name))
         super().dump(writer)
         if len(self.constructors) > 0:
-            writer.heading(2, 'Constructors')
-            for f in sorted(self.constructors.values(), key=lambda x:x.name):
+            writer.heading(2, "Constructors")
+            for f in sorted(self.constructors.values(), key=lambda x: x.name):
                 f.dump(self.name, writer)
         if len(self.classmethods) > 0:
-            writer.heading(2, 'Class methods')
-            for f in sorted(self.classmethods.values(), key=lambda x:x.name):
+            writer.heading(2, "Class methods")
+            for f in sorted(self.classmethods.values(), key=lambda x: x.name):
                 f.dump(self.name, writer)
         if len(self.methods) > 0:
-            writer.heading(2, 'Methods')
-            for f in sorted(self.methods.values(), key=lambda x:x.name):
+            writer.heading(2, "Methods")
+            for f in sorted(self.methods.values(), key=lambda x: x.name):
                 f.dump(self.name.lower(), writer)
         if len(self.constants) > 0:
-            writer.heading(2, 'Constants')
-            for c in sorted(self.constants.values(), key=lambda x:x.name):
+            writer.heading(2, "Constants")
+            for c in sorted(self.constants.values(), key=lambda x: x.name):
                 c.dump(self.name, writer)
 
+
 class DocModule(DocItem):
     def __init__(self, name, descr):
         super().__init__()
@@ -299,22 +310,22 @@ def new_file(self):
         self.cur_class = None
 
     def process_function(self, lex, d):
-        name = d['id']
+        name = d["id"]
         if name in self.functions:
             lex.error("multiple definition of function '{}'".format(name))
-        function = self.functions[name] = DocFunction(name, d['args'])
+        function = self.functions[name] = DocFunction(name, d["args"])
         function.add_doc(lex)
 
-    #def process_classref(self, lex, d):
+    # def process_classref(self, lex, d):
     #    name = d['id']
     #    self.classes[name] = name
     #    lex.opt_break()
 
     def process_class(self, lex, d):
-        name = d['id']
+        name = d["id"]
         if name in self.classes:
             lex.error("multiple definition of class '{}'".format(name))
-        self.cur_class = self.classes[name] = DocClass(name, d['descr'])
+        self.cur_class = self.classes[name] = DocClass(name, d["descr"])
         self.cur_class.add_doc(lex)
 
     def process_classmethod(self, lex, d):
@@ -326,10 +337,10 @@ def process_method(self, lex, d):
     def process_constant(self, lex, d):
         if self.cur_class is None:
             # a module-level constant
-            name = d['id']
+            name = d["id"]
             if name in self.constants:
                 lex.error("multiple definition of constant '{}'".format(name))
-            self.constants[name] = DocConstant(name, d['descr'])
+            self.constants[name] = DocConstant(name, d["descr"])
             lex.opt_break()
         else:
             # a class-level constant
@@ -337,50 +348,51 @@ def process_constant(self, lex, d):
 
     def validate(self):
         if self.descr is None:
-            raise DocValidateError('module {} referenced but never defined'.format(self.name))
+            raise DocValidateError("module {} referenced but never defined".format(self.name))
 
     def dump(self, writer):
         writer.module(self.name, self.descr, self.doc)
         if self.functions:
-            writer.heading(2, 'Functions')
-            for f in sorted(self.functions.values(), key=lambda x:x.name):
+            writer.heading(2, "Functions")
+            for f in sorted(self.functions.values(), key=lambda x: x.name):
                 f.dump(self.name, writer)
         if self.constants:
-            writer.heading(2, 'Constants')
-            for c in sorted(self.constants.values(), key=lambda x:x.name):
+            writer.heading(2, "Constants")
+            for c in sorted(self.constants.values(), key=lambda x: x.name):
                 c.dump(self.name, writer)
         if self.classes:
-            writer.heading(2, 'Classes')
-            for c in sorted(self.classes.values(), key=lambda x:x.name):
-                writer.para('[`{}.{}`]({}) - {}'.format(self.name, c.name, c.name, c.descr))
+            writer.heading(2, "Classes")
+            for c in sorted(self.classes.values(), key=lambda x: x.name):
+                writer.para("[`{}.{}`]({}) - {}".format(self.name, c.name, c.name, c.descr))
 
     def write_html(self, dir):
         md_writer = MarkdownWriter()
         md_writer.start()
         self.dump(md_writer)
-        with open(os.path.join(dir, 'index.html'), 'wt') as f:
+        with open(os.path.join(dir, "index.html"), "wt") as f:
             f.write(markdown.markdown(md_writer.end()))
         for c in self.classes.values():
             class_dir = os.path.join(dir, c.name)
             makedirs(class_dir)
             md_writer.start()
-            md_writer.para('part of the [{} module](./)'.format(self.name))
+            md_writer.para("part of the [{} module](./)".format(self.name))
             c.dump(md_writer)
-            with open(os.path.join(class_dir, 'index.html'), 'wt') as f:
+            with open(os.path.join(class_dir, "index.html"), "wt") as f:
                 f.write(markdown.markdown(md_writer.end()))
 
     def write_rst(self, dir):
         rst_writer = ReStructuredTextWriter()
         rst_writer.start()
         self.dump(rst_writer)
-        with open(dir + '/' + self.name + '.rst', 'wt') as f:
+        with open(dir + "/" + self.name + ".rst", "wt") as f:
             f.write(rst_writer.end())
         for c in self.classes.values():
             rst_writer.start()
             c.dump(rst_writer)
-            with open(dir + '/' + self.name + '.' + c.name + '.rst', 'wt') as f:
+            with open(dir + "/" + self.name + "." + c.name + ".rst", "wt") as f:
                 f.write(rst_writer.end())
 
+
 class Doc:
     def __init__(self):
         self.modules = {}
@@ -393,20 +405,20 @@ def new_file(self):
 
     def check_module(self, lex):
         if self.cur_module is None:
-            lex.error('module not defined')
+            lex.error("module not defined")
 
     def process_module(self, lex, d):
-        name = d['id']
+        name = d["id"]
         if name not in self.modules:
             self.modules[name] = DocModule(name, None)
         self.cur_module = self.modules[name]
         if self.cur_module.descr is not None:
             lex.error("multiple definition of module '{}'".format(name))
-        self.cur_module.descr = d['descr']
+        self.cur_module.descr = d["descr"]
         self.cur_module.add_doc(lex)
 
     def process_moduleref(self, lex, d):
-        name = d['id']
+        name = d["id"]
         if name not in self.modules:
             self.modules[name] = DocModule(name, None)
         self.cur_module = self.modules[name]
@@ -437,41 +449,46 @@ def validate(self):
             m.validate()
 
     def dump(self, writer):
-        writer.heading(1, 'Modules')
-        writer.para('These are the Python modules that are implemented.')
-        for m in sorted(self.modules.values(), key=lambda x:x.name):
-            writer.para('[`{}`]({}/) - {}'.format(m.name, m.name, m.descr))
+        writer.heading(1, "Modules")
+        writer.para("These are the Python modules that are implemented.")
+        for m in sorted(self.modules.values(), key=lambda x: x.name):
+            writer.para("[`{}`]({}/) - {}".format(m.name, m.name, m.descr))
 
     def write_html(self, dir):
         md_writer = MarkdownWriter()
-        with open(os.path.join(dir, 'module', 'index.html'), 'wt') as f:
+        with open(os.path.join(dir, "module", "index.html"), "wt") as f:
             md_writer.start()
             self.dump(md_writer)
             f.write(markdown.markdown(md_writer.end()))
         for m in self.modules.values():
-            mod_dir = os.path.join(dir, 'module', m.name)
+            mod_dir = os.path.join(dir, "module", m.name)
             makedirs(mod_dir)
             m.write_html(mod_dir)
 
     def write_rst(self, dir):
-        #with open(os.path.join(dir, 'module', 'index.html'), 'wt') as f:
+        # with open(os.path.join(dir, 'module', 'index.html'), 'wt') as f:
         #    f.write(markdown.markdown(self.dump()))
         for m in self.modules.values():
             m.write_rst(dir)
 
-regex_descr = r'(?P<descr>.*)'
+
+regex_descr = r"(?P<descr>.*)"
 
 doc_regexs = (
-    (Doc.process_module, re.compile(r'\\module (?P<id>[a-z][a-z0-9]*) - ' + regex_descr + r'$')),
-    (Doc.process_moduleref, re.compile(r'\\moduleref (?P<id>[a-z]+)$')),
-    (Doc.process_function, re.compile(r'\\function (?P<id>[a-z0-9_]+)(?P<args>\(.*\))$')),
-    (Doc.process_classmethod, re.compile(r'\\classmethod (?P<id>\\?[a-z0-9_]+)(?P<args>\(.*\))$')),
-    (Doc.process_method, re.compile(r'\\method (?P<id>\\?[a-z0-9_]+)(?P<args>\(.*\))$')),
-    (Doc.process_constant, re.compile(r'\\constant (?P<id>[A-Za-z0-9_]+) - ' + regex_descr + r'$')),
-    #(Doc.process_classref, re.compile(r'\\classref (?P<id>[A-Za-z0-9_]+)$')),
-    (Doc.process_class, re.compile(r'\\class (?P<id>[A-Za-z0-9_]+) - ' + regex_descr + r'$')),
+    (Doc.process_module, re.compile(r"\\module (?P<id>[a-z][a-z0-9]*) - " + regex_descr + r"$")),
+    (Doc.process_moduleref, re.compile(r"\\moduleref (?P<id>[a-z]+)$")),
+    (Doc.process_function, re.compile(r"\\function (?P<id>[a-z0-9_]+)(?P<args>\(.*\))$")),
+    (Doc.process_classmethod, re.compile(r"\\classmethod (?P<id>\\?[a-z0-9_]+)(?P<args>\(.*\))$")),
+    (Doc.process_method, re.compile(r"\\method (?P<id>\\?[a-z0-9_]+)(?P<args>\(.*\))$")),
+    (
+        Doc.process_constant,
+        re.compile(r"\\constant (?P<id>[A-Za-z0-9_]+) - " + regex_descr + r"$"),
+    ),
+    # (Doc.process_classref, re.compile(r'\\classref (?P<id>[A-Za-z0-9_]+)$')),
+    (Doc.process_class, re.compile(r"\\class (?P<id>[A-Za-z0-9_]+) - " + regex_descr + r"$")),
 )
 
+
 def process_file(file, doc):
     lex = Lexer(file)
     doc.new_file()
@@ -481,11 +498,11 @@ def process_file(file, doc):
                 line = lex.next()
                 fun, match = re_match_first(doc_regexs, line)
                 if fun == None:
-                    lex.error('unknown line format: {}'.format(line))
+                    lex.error("unknown line format: {}".format(line))
                 fun(doc, lex, match.groupdict())
 
         except Lexer.Break:
-            lex.error('unexpected break')
+            lex.error("unexpected break")
 
         except Lexer.EOF:
             pass
@@ -495,16 +512,21 @@ def process_file(file, doc):
 
     return True
 
+
 def main():
-    cmd_parser = argparse.ArgumentParser(description='Generate documentation for pyboard API from C files.')
-    cmd_parser.add_argument('--outdir', metavar='<output dir>', default='gendoc-out', help='ouput directory')
-    cmd_parser.add_argument('--format', default='html', help='output format: html or rst')
-    cmd_parser.add_argument('files', nargs='+', help='input files')
+    cmd_parser = argparse.ArgumentParser(
+        description="Generate documentation for pyboard API from C files."
+    )
+    cmd_parser.add_argument(
+        "--outdir", metavar="<output dir>", default="gendoc-out", help="ouput directory"
+    )
+    cmd_parser.add_argument("--format", default="html", help="output format: html or rst")
+    cmd_parser.add_argument("files", nargs="+", help="input files")
     args = cmd_parser.parse_args()
 
     doc = Doc()
     for file in args.files:
-        print('processing', file)
+        print("processing", file)
         if not process_file(file, doc):
             return
     try:
@@ -514,15 +536,16 @@ def main():
 
     makedirs(args.outdir)
 
-    if args.format == 'html':
+    if args.format == "html":
         doc.write_html(args.outdir)
-    elif args.format == 'rst':
+    elif args.format == "rst":
         doc.write_rst(args.outdir)
     else:
-        print('unknown format:', args.format)
+        print("unknown format:", args.format)
         return
 
-    print('written to', args.outdir)
+    print("written to", args.outdir)
+
 
 if __name__ == "__main__":
     main()
diff --git a/tools/insert-usb-ids.py b/tools/insert-usb-ids.py
index cdccd3be97380..b1d848ad4e350 100644
--- a/tools/insert-usb-ids.py
+++ b/tools/insert-usb-ids.py
@@ -8,15 +8,16 @@
 import re
 import string
 
-needed_keys = ('USB_PID_CDC_MSC', 'USB_PID_CDC_HID', 'USB_PID_CDC', 'USB_VID')
+needed_keys = ("USB_PID_CDC_MSC", "USB_PID_CDC_HID", "USB_PID_CDC", "USB_VID")
+
 
 def parse_usb_ids(filename):
     rv = dict()
     for line in open(filename).readlines():
-        line = line.rstrip('\r\n')
-        match = re.match('^#define\s+(\w+)\s+\(0x([0-9A-Fa-f]+)\)$', line)
-        if match and match.group(1).startswith('USBD_'):
-            key = match.group(1).replace('USBD', 'USB')
+        line = line.rstrip("\r\n")
+        match = re.match("^#define\s+(\w+)\s+\(0x([0-9A-Fa-f]+)\)$", line)
+        if match and match.group(1).startswith("USBD_"):
+            key = match.group(1).replace("USBD", "USB")
             val = match.group(2)
             print("key =", key, "val =", val)
             if key in needed_keys:
@@ -26,9 +27,10 @@ def parse_usb_ids(filename):
             raise Exception("Unable to parse %s from %s" % (k, filename))
     return rv
 
+
 if __name__ == "__main__":
     usb_ids_file = sys.argv[1]
     template_file = sys.argv[2]
     replacements = parse_usb_ids(usb_ids_file)
-    for line in open(template_file, 'r').readlines():
-        print(string.Template(line).safe_substitute(replacements), end='')
+    for line in open(template_file, "r").readlines():
+        print(string.Template(line).safe_substitute(replacements), end="")
diff --git a/tools/make-frozen.py b/tools/make-frozen.py
index 1051b520e4e67..a8706bf784fdc 100755
--- a/tools/make-frozen.py
+++ b/tools/make-frozen.py
@@ -25,16 +25,18 @@
 def module_name(f):
     return f
 
+
 modules = []
 
-root = sys.argv[1].rstrip("/")
-root_len = len(root)
+if len(sys.argv) > 1:
+    root = sys.argv[1].rstrip("/")
+    root_len = len(root)
 
-for dirpath, dirnames, filenames in os.walk(root):
-    for f in filenames:
-        fullpath = dirpath + "/" + f
-        st = os.stat(fullpath)
-        modules.append((fullpath[root_len + 1:], st))
+    for dirpath, dirnames, filenames in os.walk(root):
+        for f in filenames:
+            fullpath = dirpath + "/" + f
+            st = os.stat(fullpath)
+            modules.append((fullpath[root_len + 1 :], st))
 
 print("#include <stdint.h>")
 print("const char mp_frozen_str_names[] = {")
@@ -61,8 +63,8 @@ def module_name(f):
     # data.  We could just encode all characters as hex digits but it's nice
     # to be able to read the resulting C code as ASCII when possible.
 
-    data = bytearray(data) # so Python2 extracts each byte as an integer
-    esc_dict = {ord('\n'): '\\n', ord('\r'): '\\r', ord('"'): '\\"', ord('\\'): '\\\\'}
+    data = bytearray(data)  # so Python2 extracts each byte as an integer
+    esc_dict = {ord("\n"): "\\n", ord("\r"): "\\r", ord('"'): '\\"', ord("\\"): "\\\\"}
     chrs = ['"']
     break_str = False
     for c in data:
@@ -75,9 +77,9 @@ def module_name(f):
                     break_str = False
                 chrs.append(chr(c))
             else:
-                chrs.append('\\x%02x' % c)
+                chrs.append("\\x%02x" % c)
                 break_str = True
     chrs.append('\\0"')
-    print(''.join(chrs))
+    print("".join(chrs))
 
 print("};")
diff --git a/tools/makemanifest.py b/tools/makemanifest.py
new file mode 100644
index 0000000000000..2cee6aebc796a
--- /dev/null
+++ b/tools/makemanifest.py
@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+#
+# This file is part of the MicroPython project, http://micropython.org/
+#
+# The MIT License (MIT)
+#
+# Copyright (c) 2019 Damien P. George
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+from __future__ import print_function
+import sys
+import os
+import subprocess
+
+
+###########################################################################
+# Public functions to be used in the manifest
+
+
+def include(manifest):
+    """Include another manifest.
+
+    The manifest argument can be a string (filename) or an iterable of
+    strings.
+
+    Relative paths are resolved with respect to the current manifest file.
+    """
+
+    if not isinstance(manifest, str):
+        for m in manifest:
+            include(m)
+    else:
+        manifest = convert_path(manifest)
+        with open(manifest) as f:
+            # Make paths relative to this manifest file while processing it.
+            # Applies to includes and input files.
+            prev_cwd = os.getcwd()
+            os.chdir(os.path.dirname(manifest))
+            exec(f.read())
+            os.chdir(prev_cwd)
+
+
+def freeze(path, script=None, opt=0):
+    """Freeze the input, automatically determining its type.  A .py script
+    will be compiled to a .mpy first then frozen, and a .mpy file will be
+    frozen directly.
+
+    `path` must be a directory, which is the base directory to search for
+    files from.  When importing the resulting frozen modules, the name of
+    the module will start after `path`, ie `path` is excluded from the
+    module name.
+
+    If `path` is relative, it is resolved to the current manifest.py.
+    Use $(MPY_DIR), $(MPY_LIB_DIR), $(PORT_DIR), $(BOARD_DIR) if you need
+    to access specific paths.
+
+    If `script` is None all files in `path` will be frozen.
+
+    If `script` is an iterable then freeze() is called on all items of the
+    iterable (with the same `path` and `opt` passed through).
+
+    If `script` is a string then it specifies the filename to freeze, and
+    can include extra directories before the file.  The file will be
+    searched for in `path`.
+
+    `opt` is the optimisation level to pass to mpy-cross when compiling .py
+    to .mpy.
+    """
+
+    freeze_internal(KIND_AUTO, path, script, opt)
+
+
+def freeze_as_str(path):
+    """Freeze the given `path` and all .py scripts within it as a string,
+    which will be compiled upon import.
+    """
+
+    freeze_internal(KIND_AS_STR, path, None, 0)
+
+
+def freeze_as_mpy(path, script=None, opt=0):
+    """Freeze the input (see above) by first compiling the .py scripts to
+    .mpy files, then freezing the resulting .mpy files.
+    """
+
+    freeze_internal(KIND_AS_MPY, path, script, opt)
+
+
+def freeze_mpy(path, script=None, opt=0):
+    """Freeze the input (see above), which must be .mpy files that are
+    frozen directly.
+    """
+
+    freeze_internal(KIND_MPY, path, script, opt)
+
+
+###########################################################################
+# Internal implementation
+
+KIND_AUTO = 0
+KIND_AS_STR = 1
+KIND_AS_MPY = 2
+KIND_MPY = 3
+
+VARS = {}
+
+manifest_list = []
+
+
+class FreezeError(Exception):
+    pass
+
+
+def system(cmd):
+    try:
+        output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+        return 0, output
+    except subprocess.CalledProcessError as er:
+        return -1, er.output
+
+
+def convert_path(path):
+    # Perform variable substituion.
+    for name, value in VARS.items():
+        path = path.replace("$({})".format(name), value)
+    # Convert to absolute path (so that future operations don't rely on
+    # still being chdir'ed).
+    return os.path.abspath(path)
+
+
+def get_timestamp(path, default=None):
+    try:
+        stat = os.stat(path)
+        return stat.st_mtime
+    except OSError:
+        if default is None:
+            raise FreezeError("cannot stat {}".format(path))
+        return default
+
+
+def get_timestamp_newest(path):
+    ts_newest = 0
+    for dirpath, dirnames, filenames in os.walk(path, followlinks=True):
+        for f in filenames:
+            ts_newest = max(ts_newest, get_timestamp(os.path.join(dirpath, f)))
+    return ts_newest
+
+
+def mkdir(path):
+    cur_path = ""
+    for p in path.split("/")[:-1]:
+        cur_path += p + "/"
+        try:
+            os.mkdir(cur_path)
+        except OSError as er:
+            if er.args[0] == 17:  # file exists
+                pass
+            else:
+                raise er
+
+
+def freeze_internal(kind, path, script, opt):
+    path = convert_path(path)
+    if script is None and kind == KIND_AS_STR:
+        if any(f[0] == KIND_AS_STR for f in manifest_list):
+            raise FreezeError("can only freeze one str directory")
+        manifest_list.append((KIND_AS_STR, path, script, opt))
+    elif script is None:
+        for dirpath, dirnames, filenames in os.walk(path, followlinks=True):
+            for f in filenames:
+                freeze_internal(kind, path, (dirpath + "/" + f)[len(path) + 1 :], opt)
+    elif not isinstance(script, str):
+        for s in script:
+            freeze_internal(kind, path, s, opt)
+    else:
+        extension_kind = {KIND_AS_MPY: ".py", KIND_MPY: ".mpy"}
+        if kind == KIND_AUTO:
+            for k, ext in extension_kind.items():
+                if script.endswith(ext):
+                    kind = k
+                    break
+            else:
+                print("warn: unsupported file type, skipped freeze: {}".format(script))
+                return
+        wanted_extension = extension_kind[kind]
+        if not script.endswith(wanted_extension):
+            raise FreezeError("expecting a {} file, got {}".format(wanted_extension, script))
+        manifest_list.append((kind, path, script, opt))
+
+
+def main():
+    # Parse arguments
+    import argparse
+
+    cmd_parser = argparse.ArgumentParser(
+        description="A tool to generate frozen content in MicroPython firmware images."
+    )
+    cmd_parser.add_argument("-o", "--output", help="output path")
+    cmd_parser.add_argument("-b", "--build-dir", help="output path")
+    cmd_parser.add_argument(
+        "-f", "--mpy-cross-flags", default="", help="flags to pass to mpy-cross"
+    )
+    cmd_parser.add_argument("-v", "--var", action="append", help="variables to substitute")
+    cmd_parser.add_argument("files", nargs="+", help="input manifest list")
+    args = cmd_parser.parse_args()
+
+    # Extract variables for substitution.
+    for var in args.var:
+        name, value = var.split("=", 1)
+        if os.path.exists(value):
+            value = os.path.abspath(value)
+        VARS[name] = value
+
+    if "MPY_DIR" not in VARS or "PORT_DIR" not in VARS:
+        print("MPY_DIR and PORT_DIR variables must be specified")
+        sys.exit(1)
+
+    # Get paths to tools
+    MAKE_FROZEN = VARS["MPY_DIR"] + "/tools/make-frozen.py"
+    MPY_CROSS = VARS["MPY_DIR"] + "/mpy-cross/mpy-cross"
+    if sys.platform == "win32":
+        MPY_CROSS += ".exe"
+    MPY_CROSS = os.getenv("MICROPY_MPYCROSS", MPY_CROSS)
+    MPY_TOOL = VARS["MPY_DIR"] + "/tools/mpy-tool.py"
+
+    # Ensure mpy-cross is built
+    if not os.path.exists(MPY_CROSS):
+        print("mpy-cross not found at {}, please build it first".format(MPY_CROSS))
+        sys.exit(1)
+
+    # Include top-level inputs, to generate the manifest
+    for input_manifest in args.files:
+        try:
+            if input_manifest.endswith(".py"):
+                include(input_manifest)
+            else:
+                exec(input_manifest)
+        except FreezeError as er:
+            print('freeze error executing "{}": {}'.format(input_manifest, er.args[0]))
+            sys.exit(1)
+
+    # Process the manifest
+    str_paths = []
+    mpy_files = []
+    ts_newest = 0
+    for kind, path, script, opt in manifest_list:
+        if kind == KIND_AS_STR:
+            str_paths.append(path)
+            ts_outfile = get_timestamp_newest(path)
+        elif kind == KIND_AS_MPY:
+            infile = "{}/{}".format(path, script)
+            outfile = "{}/frozen_mpy/{}.mpy".format(args.build_dir, script[:-3])
+            ts_infile = get_timestamp(infile)
+            ts_outfile = get_timestamp(outfile, 0)
+            if ts_infile >= ts_outfile:
+                print("MPY", script)
+                mkdir(outfile)
+                res, out = system(
+                    [MPY_CROSS]
+                    + args.mpy_cross_flags.split()
+                    + ["-o", outfile, "-s", script, "-O{}".format(opt), infile]
+                )
+                if res != 0:
+                    print("error compiling {}: {}".format(infile, out))
+                    raise SystemExit(1)
+                ts_outfile = get_timestamp(outfile)
+            mpy_files.append(outfile)
+        else:
+            assert kind == KIND_MPY
+            infile = "{}/{}".format(path, script)
+            mpy_files.append(infile)
+            ts_outfile = get_timestamp(infile)
+        ts_newest = max(ts_newest, ts_outfile)
+
+    # Check if output file needs generating
+    if ts_newest < get_timestamp(args.output, 0):
+        # No files are newer than output file so it does not need updating
+        return
+
+    # Freeze paths as strings
+    res, output_str = system([sys.executable, MAKE_FROZEN] + str_paths)
+    if res != 0:
+        print("error freezing strings {}: {}".format(str_paths, output_str))
+        sys.exit(1)
+
+    # Freeze .mpy files
+    if mpy_files:
+        res, output_mpy = system(
+            [
+                sys.executable,
+                MPY_TOOL,
+                "-f",
+                "-q",
+                args.build_dir + "/genhdr/qstrdefs.preprocessed.h",
+            ]
+            + mpy_files
+        )
+        if res != 0:
+            print("error freezing mpy {}:".format(mpy_files))
+            print(str(output_mpy, "utf8"))
+            sys.exit(1)
+    else:
+        output_mpy = (
+            b'#include "py/emitglue.h"\n'
+            b"extern const qstr_pool_t mp_qstr_const_pool;\n"
+            b"const qstr_pool_t mp_qstr_frozen_const_pool = {\n"
+            b"    (qstr_pool_t*)&mp_qstr_const_pool, MP_QSTRnumber_of, 0, 0\n"
+            b"};\n"
+            b'const char mp_frozen_mpy_names[1] = {"\\0"};\n'
+            b"const mp_raw_code_t *const mp_frozen_mpy_content[0] = {};\n"
+        )
+
+    # Generate output
+    print("GEN", args.output)
+    mkdir(args.output)
+    with open(args.output, "wb") as f:
+        f.write(b"//\n// Content for MICROPY_MODULE_FROZEN_STR\n//\n")
+        f.write(output_str)
+        f.write(b"//\n// Content for MICROPY_MODULE_FROZEN_MPY\n//\n")
+        f.write(output_mpy)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/metrics.py b/tools/metrics.py
new file mode 100755
index 0000000000000..25acb30f51f01
--- /dev/null
+++ b/tools/metrics.py
@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+#
+# This file is part of the MicroPython project, http://micropython.org/
+#
+# The MIT License (MIT)
+#
+# Copyright (c) 2020 Damien P. George
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""
+This script is used to compute metrics, like code size, of the various ports.
+
+Typical usage is:
+
+    $ ./tools/metrics.py build | tee size0
+    <wait for build to complete>
+    $ git switch new-feature-branch
+    $ ./tools/metrics.py build | tee size1
+    <wait for build to complete>
+    $ ./tools/metrics.py diff size0 size1
+
+Other commands:
+
+    $ ./tools/metrics.py sizes # print all firmware sizes
+    $ ./tools/metrics.py clean # clean all ports
+
+"""
+
+import collections, sys, re, subprocess
+
+MAKE_FLAGS = ["-j3", "CFLAGS_EXTRA=-DNDEBUG"]
+
+
+class PortData:
+    def __init__(self, name, dir, output, make_flags=None):
+        self.name = name
+        self.dir = dir
+        self.output = output
+        self.make_flags = make_flags
+        self.needs_mpy_cross = dir not in ("bare-arm", "minimal")
+
+
+port_data = {
+    "b": PortData("bare-arm", "bare-arm", "build/firmware.elf"),
+    "m": PortData("minimal x86", "minimal", "build/firmware.elf"),
+    "u": PortData("unix x64", "unix", "micropython"),
+    "n": PortData("unix nanbox", "unix", "micropython-nanbox", "VARIANT=nanbox"),
+    "s": PortData("stm32", "stm32", "build-PYBV10/firmware.elf", "BOARD=PYBV10"),
+    "c": PortData("cc3200", "cc3200", "build/WIPY/release/application.axf", "BTARGET=application"),
+    "8": PortData("esp8266", "esp8266", "build-GENERIC/firmware.elf"),
+    "3": PortData("esp32", "esp32", "build-GENERIC/application.elf"),
+    "r": PortData("nrf", "nrf", "build-pca10040/firmware.elf"),
+    "d": PortData("samd", "samd", "build-ADAFRUIT_ITSYBITSY_M4_EXPRESS/firmware.elf"),
+}
+
+
+def syscmd(*args):
+    sys.stdout.flush()
+    a2 = []
+    for a in args:
+        if isinstance(a, str):
+            a2.append(a)
+        elif a:
+            a2.extend(a)
+    subprocess.check_call(a2)
+
+
+def parse_port_list(args):
+    if not args:
+        return list(port_data.values())
+    else:
+        ports = []
+        for arg in args:
+            for port_char in arg:
+                try:
+                    ports.append(port_data[port_char])
+                except KeyError:
+                    print("unknown port:", port_char)
+                    sys.exit(1)
+        return ports
+
+
+def read_build_log(filename):
+    data = collections.OrderedDict()
+    lines = []
+    found_sizes = False
+    with open(filename) as f:
+        for line in f:
+            line = line.strip()
+            if line.strip() == "COMPUTING SIZES":
+                found_sizes = True
+            elif found_sizes:
+                lines.append(line)
+    is_size_line = False
+    for line in lines:
+        if is_size_line:
+            fields = line.split()
+            data[fields[-1]] = [int(f) for f in fields[:-2]]
+            is_size_line = False
+        else:
+            is_size_line = line.startswith("text\t ")
+    return data
+
+
+def do_diff(args):
+    """Compute the difference between firmware sizes."""
+
+    # Parse arguments.
+    error_threshold = None
+    if len(args) >= 2 and args[0] == "--error-threshold":
+        args.pop(0)
+        error_threshold = int(args.pop(0))
+
+    if len(args) != 2:
+        print("usage: %s diff [--error-threshold <x>] <out1> <out2>" % sys.argv[0])
+        sys.exit(1)
+
+    data1 = read_build_log(args[0])
+    data2 = read_build_log(args[1])
+
+    max_delta = None
+    for key, value1 in data1.items():
+        value2 = data2[key]
+        for port in port_data.values():
+            if key == "ports/{}/{}".format(port.dir, port.output):
+                name = port.name
+                break
+        data = [v2 - v1 for v1, v2 in zip(value1, value2)]
+        warn = ""
+        board = re.search(r"/build-([A-Za-z0-9_]+)/", key)
+        if board:
+            board = board.group(1)
+        else:
+            board = ""
+        if name == "cc3200":
+            delta = data[0]
+            percent = 100 * delta / value1[0]
+            if data[1] != 0:
+                warn += " %+u(data)" % data[1]
+        else:
+            delta = data[3]
+            percent = 100 * delta / value1[3]
+            if data[1] != 0:
+                warn += " %+u(data)" % data[1]
+            if data[2] != 0:
+                warn += " %+u(bss)" % data[2]
+        if warn:
+            warn = "[incl%s]" % warn
+        print("%11s: %+5u %+.3f%% %s%s" % (name, delta, percent, board, warn))
+        max_delta = delta if max_delta is None else max(max_delta, delta)
+
+    if error_threshold is not None and max_delta is not None:
+        if max_delta > error_threshold:
+            sys.exit(1)
+
+
+def do_clean(args):
+    """Clean ports."""
+
+    ports = parse_port_list(args)
+
+    print("CLEANING")
+    for port in ports:
+        syscmd("make", "-C", "ports/{}".format(port.dir), port.make_flags, "clean")
+
+
+def do_build(args):
+    """Build ports and print firmware sizes."""
+
+    ports = parse_port_list(args)
+
+    if any(port.needs_mpy_cross for port in ports):
+        print("BUILDING MPY-CROSS")
+        syscmd("make", "-C", "mpy-cross", MAKE_FLAGS)
+
+    print("BUILDING PORTS")
+    for port in ports:
+        syscmd("make", "-C", "ports/{}".format(port.dir), MAKE_FLAGS, port.make_flags)
+
+    do_sizes(args)
+
+
+def do_sizes(args):
+    """Compute and print sizes of firmware."""
+
+    ports = parse_port_list(args)
+
+    print("COMPUTING SIZES")
+    for port in ports:
+        syscmd("size", "ports/{}/{}".format(port.dir, port.output))
+
+
+def main():
+    # Get command to execute
+    if len(sys.argv) == 1:
+        print("Available commands:")
+        for cmd in globals():
+            if cmd.startswith("do_"):
+                print("   {:9} {}".format(cmd[3:], globals()[cmd].__doc__))
+        sys.exit(1)
+    cmd = sys.argv.pop(1)
+
+    # Dispatch to desired command
+    try:
+        cmd = globals()["do_{}".format(cmd)]
+    except KeyError:
+        print("{}: unknown command '{}'".format(sys.argv[0], cmd))
+        sys.exit(1)
+    cmd(sys.argv[1:])
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/mpy-tool.py b/tools/mpy-tool.py
index c8216bb603f2a..43d35503eb564 100755
--- a/tools/mpy-tool.py
+++ b/tools/mpy-tool.py
@@ -4,7 +4,7 @@
 #
 # The MIT License (MIT)
 #
-# Copyright (c) 2016 Damien P. George
+# Copyright (c) 2016-2019 Damien P. George
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -27,7 +27,8 @@
 # Python 2/3 compatibility code
 from __future__ import print_function
 import platform
-if platform.python_version_tuple()[0] == '2':
+
+if platform.python_version_tuple()[0] == "2":
     str_cons = lambda val, enc=None: val
     bytes_cons = lambda val, enc=None: bytearray(val)
     is_str_type = lambda o: type(o) is str
@@ -45,48 +46,56 @@
 import struct
 from collections import namedtuple
 
-sys.path.append(sys.path[0] + '/../py')
+sys.path.append(sys.path[0] + "/../py")
 import makeqstrdata as qstrutil
 
+
 class FreezeError(Exception):
     def __init__(self, rawcode, msg):
         self.rawcode = rawcode
         self.msg = msg
 
     def __str__(self):
-        return 'error while freezing %s: %s' % (self.rawcode.source_file, self.msg)
+        return "error while freezing %s: %s" % (self.rawcode.source_file, self.msg)
+
 
 class Config:
-    MPY_VERSION = 4
+    MPY_VERSION = 5
     MICROPY_LONGINT_IMPL_NONE = 0
     MICROPY_LONGINT_IMPL_LONGLONG = 1
     MICROPY_LONGINT_IMPL_MPZ = 2
+
+
 config = Config()
 
+
 class QStrType:
     def __init__(self, str):
         self.str = str
         self.qstr_esc = qstrutil.qstr_escape(self.str)
-        self.qstr_id = 'MP_QSTR_' + self.qstr_esc
+        self.qstr_id = "MP_QSTR_" + self.qstr_esc
+
 
 # Initialise global list of qstrs with static qstrs
-global_qstrs = [None] # MP_QSTR_NULL should never be referenced
+global_qstrs = [None]  # MP_QSTRnull should never be referenced
 for n in qstrutil.static_qstr_list:
     global_qstrs.append(QStrType(n))
 
+
 class QStrWindow:
     def __init__(self, size):
         self.window = []
         self.size = size
 
     def push(self, val):
-        self.window = [val] + self.window[:self.size - 1]
+        self.window = [val] + self.window[: self.size - 1]
 
     def access(self, idx):
         val = self.window[idx]
-        self.window = [val] + self.window[:idx] + self.window[idx + 1:]
+        self.window = [val] + self.window[:idx] + self.window[idx + 1 :]
         return val
 
+
 MP_CODE_BYTECODE = 2
 MP_CODE_NATIVE_PY = 3
 MP_CODE_NATIVE_VIPER = 4
@@ -102,173 +111,128 @@ def access(self, idx):
 MP_NATIVE_ARCH_ARMV7EMSP = 7
 MP_NATIVE_ARCH_ARMV7EMDP = 8
 MP_NATIVE_ARCH_XTENSA = 9
+MP_NATIVE_ARCH_XTENSAWIN = 10
+
+MP_BC_MASK_EXTRA_BYTE = 0x9E
 
-MP_OPCODE_BYTE = 0
-MP_OPCODE_QSTR = 1
-MP_OPCODE_VAR_UINT = 2
-MP_OPCODE_OFFSET = 3
+MP_BC_FORMAT_BYTE = 0
+MP_BC_FORMAT_QSTR = 1
+MP_BC_FORMAT_VAR_UINT = 2
+MP_BC_FORMAT_OFFSET = 3
 
-# extra bytes:
-MP_BC_MAKE_CLOSURE = 0x62
-MP_BC_MAKE_CLOSURE_DEFARGS = 0x63
-MP_BC_RAISE_VARARGS = 0x5c
 # extra byte if caching enabled:
-MP_BC_LOAD_NAME = 0x1b
-MP_BC_LOAD_GLOBAL = 0x1c
-MP_BC_LOAD_ATTR = 0x1d
-MP_BC_STORE_ATTR = 0x26
-
-def make_opcode_format():
-    def OC4(a, b, c, d):
-        return a | (b << 2) | (c << 4) | (d << 6)
-    U = 0
-    B = 0
-    Q = 1
-    V = 2
-    O = 3
-    return bytes_cons((
-    # this table is taken verbatim from py/bc.c
-    OC4(U, U, U, U), # 0x00-0x03
-    OC4(U, U, U, U), # 0x04-0x07
-    OC4(U, U, U, U), # 0x08-0x0b
-    OC4(U, U, U, U), # 0x0c-0x0f
-    OC4(B, B, B, U), # 0x10-0x13
-    OC4(V, U, Q, V), # 0x14-0x17
-    OC4(B, V, V, Q), # 0x18-0x1b
-    OC4(Q, Q, Q, Q), # 0x1c-0x1f
-    OC4(B, B, V, V), # 0x20-0x23
-    OC4(Q, Q, Q, B), # 0x24-0x27
-    OC4(V, V, Q, Q), # 0x28-0x2b
-    OC4(U, U, U, U), # 0x2c-0x2f
-    OC4(B, B, B, B), # 0x30-0x33
-    OC4(B, O, O, O), # 0x34-0x37
-    OC4(O, O, U, U), # 0x38-0x3b
-    OC4(U, O, B, O), # 0x3c-0x3f
-    OC4(O, B, B, O), # 0x40-0x43
-    OC4(O, U, O, B), # 0x44-0x47
-    OC4(U, U, U, U), # 0x48-0x4b
-    OC4(U, U, U, U), # 0x4c-0x4f
-    OC4(V, V, U, V), # 0x50-0x53
-    OC4(B, U, V, V), # 0x54-0x57
-    OC4(V, V, V, B), # 0x58-0x5b
-    OC4(B, B, B, U), # 0x5c-0x5f
-    OC4(V, V, V, V), # 0x60-0x63
-    OC4(V, V, V, V), # 0x64-0x67
-    OC4(Q, Q, B, U), # 0x68-0x6b
-    OC4(U, U, U, U), # 0x6c-0x6f
-
-    OC4(B, B, B, B), # 0x70-0x73
-    OC4(B, B, B, B), # 0x74-0x77
-    OC4(B, B, B, B), # 0x78-0x7b
-    OC4(B, B, B, B), # 0x7c-0x7f
-    OC4(B, B, B, B), # 0x80-0x83
-    OC4(B, B, B, B), # 0x84-0x87
-    OC4(B, B, B, B), # 0x88-0x8b
-    OC4(B, B, B, B), # 0x8c-0x8f
-    OC4(B, B, B, B), # 0x90-0x93
-    OC4(B, B, B, B), # 0x94-0x97
-    OC4(B, B, B, B), # 0x98-0x9b
-    OC4(B, B, B, B), # 0x9c-0x9f
-    OC4(B, B, B, B), # 0xa0-0xa3
-    OC4(B, B, B, B), # 0xa4-0xa7
-    OC4(B, B, B, B), # 0xa8-0xab
-    OC4(B, B, B, B), # 0xac-0xaf
-
-    OC4(B, B, B, B), # 0xb0-0xb3
-    OC4(B, B, B, B), # 0xb4-0xb7
-    OC4(B, B, B, B), # 0xb8-0xbb
-    OC4(B, B, B, B), # 0xbc-0xbf
-
-    OC4(B, B, B, B), # 0xc0-0xc3
-    OC4(B, B, B, B), # 0xc4-0xc7
-    OC4(B, B, B, B), # 0xc8-0xcb
-    OC4(B, B, B, B), # 0xcc-0xcf
-
-    OC4(B, B, B, B), # 0xd0-0xd3
-    OC4(U, U, U, B), # 0xd4-0xd7
-    OC4(B, B, B, B), # 0xd8-0xdb
-    OC4(B, B, B, B), # 0xdc-0xdf
-
-    OC4(B, B, B, B), # 0xe0-0xe3
-    OC4(B, B, B, B), # 0xe4-0xe7
-    OC4(B, B, B, B), # 0xe8-0xeb
-    OC4(B, B, B, B), # 0xec-0xef
-
-    OC4(B, B, B, B), # 0xf0-0xf3
-    OC4(B, B, B, B), # 0xf4-0xf7
-    OC4(U, U, U, U), # 0xf8-0xfb
-    OC4(U, U, U, U), # 0xfc-0xff
-    ))
+MP_BC_LOAD_NAME = 0x11
+MP_BC_LOAD_GLOBAL = 0x12
+MP_BC_LOAD_ATTR = 0x13
+MP_BC_STORE_ATTR = 0x18
 
 # this function mirrors that in py/bc.c
-def mp_opcode_format(bytecode, ip, count_var_uint, opcode_format=make_opcode_format()):
+def mp_opcode_format(bytecode, ip, count_var_uint):
     opcode = bytecode[ip]
     ip_start = ip
-    f = (opcode_format[opcode >> 2] >> (2 * (opcode & 3))) & 3
-    if f == MP_OPCODE_QSTR:
+    f = (0x000003A4 >> (2 * ((opcode) >> 4))) & 3
+    if f == MP_BC_FORMAT_QSTR:
         if config.MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE:
-            if (opcode == MP_BC_LOAD_NAME
+            if (
+                opcode == MP_BC_LOAD_NAME
                 or opcode == MP_BC_LOAD_GLOBAL
                 or opcode == MP_BC_LOAD_ATTR
-                or opcode == MP_BC_STORE_ATTR):
+                or opcode == MP_BC_STORE_ATTR
+            ):
                 ip += 1
         ip += 3
     else:
-        extra_byte = (
-            opcode == MP_BC_RAISE_VARARGS
-            or opcode == MP_BC_MAKE_CLOSURE
-            or opcode == MP_BC_MAKE_CLOSURE_DEFARGS
-        )
+        extra_byte = (opcode & MP_BC_MASK_EXTRA_BYTE) == 0
         ip += 1
-        if f == MP_OPCODE_VAR_UINT:
+        if f == MP_BC_FORMAT_VAR_UINT:
             if count_var_uint:
                 while bytecode[ip] & 0x80 != 0:
                     ip += 1
                 ip += 1
-        elif f == MP_OPCODE_OFFSET:
+        elif f == MP_BC_FORMAT_OFFSET:
             ip += 2
         ip += extra_byte
     return f, ip - ip_start
 
-def decode_uint(bytecode, ip):
-    unum = 0
+
+def read_prelude_sig(read_byte):
+    z = read_byte()
+    # xSSSSEAA
+    S = (z >> 3) & 0xF
+    E = (z >> 2) & 0x1
+    F = 0
+    A = z & 0x3
+    K = 0
+    D = 0
+    n = 0
+    while z & 0x80:
+        z = read_byte()
+        # xFSSKAED
+        S |= (z & 0x30) << (2 * n)
+        E |= (z & 0x02) << n
+        F |= ((z & 0x40) >> 6) << n
+        A |= (z & 0x4) << n
+        K |= ((z & 0x08) >> 3) << n
+        D |= (z & 0x1) << n
+        n += 1
+    S += 1
+    return S, E, F, A, K, D
+
+
+def read_prelude_size(read_byte):
+    I = 0
+    C = 0
+    n = 0
     while True:
-        val = bytecode[ip]
-        ip += 1
-        unum = (unum << 7) | (val & 0x7f)
-        if not (val & 0x80):
+        z = read_byte()
+        # xIIIIIIC
+        I |= ((z & 0x7E) >> 1) << (6 * n)
+        C |= (z & 1) << n
+        if not (z & 0x80):
             break
-    return ip, unum
+        n += 1
+    return I, C
+
 
 def extract_prelude(bytecode, ip):
-    ip, n_state = decode_uint(bytecode, ip)
-    ip, n_exc_stack = decode_uint(bytecode, ip)
-    scope_flags = bytecode[ip]; ip += 1
-    n_pos_args = bytecode[ip]; ip += 1
-    n_kwonly_args = bytecode[ip]; ip += 1
-    n_def_pos_args = bytecode[ip]; ip += 1
-    ip2, code_info_size = decode_uint(bytecode, ip)
-    ip += code_info_size
-    while bytecode[ip] != 0xff:
-        ip += 1
-    ip += 1
+    def local_read_byte():
+        b = bytecode[ip_ref[0]]
+        ip_ref[0] += 1
+        return b
+
+    ip_ref = [ip]  # to close over ip in Python 2 and 3
+    (
+        n_state,
+        n_exc_stack,
+        scope_flags,
+        n_pos_args,
+        n_kwonly_args,
+        n_def_pos_args,
+    ) = read_prelude_sig(local_read_byte)
+    n_info, n_cell = read_prelude_size(local_read_byte)
+    ip = ip_ref[0]
+
+    ip2 = ip
+    ip = ip2 + n_info + n_cell
     # ip now points to first opcode
     # ip2 points to simple_name qstr
-    return ip, ip2, (n_state, n_exc_stack, scope_flags, n_pos_args, n_kwonly_args, n_def_pos_args, code_info_size)
+    return ip, ip2, (n_state, n_exc_stack, scope_flags, n_pos_args, n_kwonly_args, n_def_pos_args)
+
 
 class MPFunTable:
     pass
 
+
 class RawCode(object):
     # a set of all escaped names, to make sure they are unique
     escaped_names = set()
 
     # convert code kind number to string
     code_kind_str = {
-       MP_CODE_BYTECODE: 'MP_CODE_BYTECODE',
-       MP_CODE_NATIVE_PY: 'MP_CODE_NATIVE_PY',
-       MP_CODE_NATIVE_VIPER: 'MP_CODE_NATIVE_VIPER',
-       MP_CODE_NATIVE_ASM: 'MP_CODE_NATIVE_ASM',
+        MP_CODE_BYTECODE: "MP_CODE_BYTECODE",
+        MP_CODE_NATIVE_PY: "MP_CODE_NATIVE_PY",
+        MP_CODE_NATIVE_VIPER: "MP_CODE_NATIVE_VIPER",
+        MP_CODE_NATIVE_ASM: "MP_CODE_NATIVE_ASM",
     }
 
     def __init__(self, code_kind, bytecode, prelude_offset, qstrs, objs, raw_codes):
@@ -297,7 +261,7 @@ def _unpack_qstr(self, ip):
     def dump(self):
         # dump children first
         for rc in self.raw_codes:
-            rc.freeze('')
+            rc.freeze("")
         # TODO
 
     def freeze_children(self, parent_name):
@@ -312,32 +276,39 @@ def freeze_children(self, parent_name):
 
         # emit children first
         for rc in self.raw_codes:
-            rc.freeze(self.escaped_name + '_')
+            rc.freeze(self.escaped_name + "_")
 
     def freeze_constants(self):
         # generate constant objects
         for i, obj in enumerate(self.objs):
-            obj_name = 'const_obj_%s_%u' % (self.escaped_name, i)
+            obj_name = "const_obj_%s_%u" % (self.escaped_name, i)
             if obj is MPFunTable:
                 pass
             elif obj is Ellipsis:
-                print('#define %s mp_const_ellipsis_obj' % obj_name)
+                print("#define %s mp_const_ellipsis_obj" % obj_name)
             elif is_str_type(obj) or is_bytes_type(obj):
                 if is_str_type(obj):
-                    obj = bytes_cons(obj, 'utf8')
-                    obj_type = 'mp_type_str'
+                    obj = bytes_cons(obj, "utf8")
+                    obj_type = "mp_type_str"
                 else:
-                    obj_type = 'mp_type_bytes'
-                print('STATIC const mp_obj_str_t %s = {{&%s}, %u, %u, (const byte*)"%s"};'
-                    % (obj_name, obj_type, qstrutil.compute_hash(obj, config.MICROPY_QSTR_BYTES_IN_HASH),
-                        len(obj), ''.join(('\\x%02x' % b) for b in obj)))
+                    obj_type = "mp_type_bytes"
+                print(
+                    'STATIC const mp_obj_str_t %s = {{&%s}, %u, %u, (const byte*)"%s"};'
+                    % (
+                        obj_name,
+                        obj_type,
+                        qstrutil.compute_hash(obj, config.MICROPY_QSTR_BYTES_IN_HASH),
+                        len(obj),
+                        "".join(("\\x%02x" % b) for b in obj),
+                    )
+                )
             elif is_int_type(obj):
                 if config.MICROPY_LONGINT_IMPL == config.MICROPY_LONGINT_IMPL_NONE:
                     # TODO check if we can actually fit this long-int into a small-int
-                    raise FreezeError(self, 'target does not support long int')
+                    raise FreezeError(self, "target does not support long int")
                 elif config.MICROPY_LONGINT_IMPL == config.MICROPY_LONGINT_IMPL_LONGLONG:
                     # TODO
-                    raise FreezeError(self, 'freezing int to long-long is not implemented')
+                    raise FreezeError(self, "freezing int to long-long is not implemented")
                 elif config.MICROPY_LONGINT_IMPL == config.MICROPY_LONGINT_IMPL_MPZ:
                     neg = 0
                     if obj < 0:
@@ -350,162 +321,255 @@ def freeze_constants(self):
                         digs.append(z & ((1 << bits_per_dig) - 1))
                         z >>= bits_per_dig
                     ndigs = len(digs)
-                    digs = ','.join(('%#x' % d) for d in digs)
-                    print('STATIC const mp_obj_int_t %s = {{&mp_type_int}, '
-                        '{.neg=%u, .fixed_dig=1, .alloc=%u, .len=%u, .dig=(uint%u_t*)(const uint%u_t[]){%s}}};'
-                        % (obj_name, neg, ndigs, ndigs, bits_per_dig, bits_per_dig, digs))
+                    digs = ",".join(("%#x" % d) for d in digs)
+                    print(
+                        "STATIC const mp_obj_int_t %s = {{&mp_type_int}, "
+                        "{.neg=%u, .fixed_dig=1, .alloc=%u, .len=%u, .dig=(uint%u_t*)(const uint%u_t[]){%s}}};"
+                        % (obj_name, neg, ndigs, ndigs, bits_per_dig, bits_per_dig, digs)
+                    )
             elif type(obj) is float:
-                print('#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B')
-                print('STATIC const mp_obj_float_t %s = {{&mp_type_float}, %.16g};'
-                    % (obj_name, obj))
-                print('#endif')
+                print(
+                    "#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B"
+                )
+                print(
+                    "STATIC const mp_obj_float_t %s = {{&mp_type_float}, (mp_float_t)%.16g};"
+                    % (obj_name, obj)
+                )
+                print("#endif")
             elif type(obj) is complex:
-                print('STATIC const mp_obj_complex_t %s = {{&mp_type_complex}, %.16g, %.16g};'
-                    % (obj_name, obj.real, obj.imag))
+                print(
+                    "STATIC const mp_obj_complex_t %s = {{&mp_type_complex}, (mp_float_t)%.16g, (mp_float_t)%.16g};"
+                    % (obj_name, obj.real, obj.imag)
+                )
             else:
-                raise FreezeError(self, 'freezing of object %r is not implemented' % (obj,))
+                raise FreezeError(self, "freezing of object %r is not implemented" % (obj,))
 
         # generate constant table, if it has any entries
         const_table_len = len(self.qstrs) + len(self.objs) + len(self.raw_codes)
         if const_table_len:
-            print('STATIC const mp_rom_obj_t const_table_data_%s[%u] = {'
-                % (self.escaped_name, const_table_len))
+            print(
+                "STATIC const mp_rom_obj_t const_table_data_%s[%u] = {"
+                % (self.escaped_name, const_table_len)
+            )
             for qst in self.qstrs:
-                print('    MP_ROM_QSTR(%s),' % global_qstrs[qst].qstr_id)
+                print("    MP_ROM_QSTR(%s)," % global_qstrs[qst].qstr_id)
             for i in range(len(self.objs)):
                 if self.objs[i] is MPFunTable:
-                    print('    mp_fun_table,')
+                    print("    &mp_fun_table,")
                 elif type(self.objs[i]) is float:
-                    print('#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B')
-                    print('    MP_ROM_PTR(&const_obj_%s_%u),' % (self.escaped_name, i))
-                    print('#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C')
-                    n = struct.unpack('<I', struct.pack('<f', self.objs[i]))[0]
+                    print(
+                        "#if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_A || MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_B"
+                    )
+                    print("    MP_ROM_PTR(&const_obj_%s_%u)," % (self.escaped_name, i))
+                    print("#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_C")
+                    n = struct.unpack("<I", struct.pack("<f", self.objs[i]))[0]
                     n = ((n & ~0x3) | 2) + 0x80800000
-                    print('    (mp_rom_obj_t)(0x%08x),' % (n,))
-                    print('#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D')
-                    n = struct.unpack('<Q', struct.pack('<d', self.objs[i]))[0]
+                    print("    (mp_rom_obj_t)(0x%08x)," % (n,))
+                    print("#elif MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D")
+                    n = struct.unpack("<Q", struct.pack("<d", self.objs[i]))[0]
                     n += 0x8004000000000000
-                    print('    (mp_rom_obj_t)(0x%016x),' % (n,))
-                    print('#endif')
+                    print("    (mp_rom_obj_t)(0x%016x)," % (n,))
+                    print("#endif")
                 else:
-                    print('    MP_ROM_PTR(&const_obj_%s_%u),' % (self.escaped_name, i))
+                    print("    MP_ROM_PTR(&const_obj_%s_%u)," % (self.escaped_name, i))
             for rc in self.raw_codes:
-                print('    MP_ROM_PTR(&raw_code_%s),' % rc.escaped_name)
-            print('};')
+                print("    MP_ROM_PTR(&raw_code_%s)," % rc.escaped_name)
+            print("};")
 
     def freeze_module(self, qstr_links=(), type_sig=0):
         # generate module
-        if self.simple_name.str != '<module>':
-            print('STATIC ', end='')
-        print('const mp_raw_code_t raw_code_%s = {' % self.escaped_name)
-        print('    .kind = %s,' % RawCode.code_kind_str[self.code_kind])
-        print('    .scope_flags = 0x%02x,' % self.prelude[2])
-        print('    .n_pos_args = %u,' % self.prelude[3])
-        print('    .fun_data = fun_data_%s,' % self.escaped_name)
+        if self.simple_name.str != "<module>":
+            print("STATIC ", end="")
+        print("const mp_raw_code_t raw_code_%s = {" % self.escaped_name)
+        print("    .kind = %s," % RawCode.code_kind_str[self.code_kind])
+        print("    .scope_flags = 0x%02x," % self.prelude[2])
+        print("    .n_pos_args = %u," % self.prelude[3])
+        print("    .fun_data = fun_data_%s," % self.escaped_name)
         if len(self.qstrs) + len(self.objs) + len(self.raw_codes):
-            print('    .const_table = (mp_uint_t*)const_table_data_%s,' % self.escaped_name)
+            print("    .const_table = (mp_uint_t*)const_table_data_%s," % self.escaped_name)
         else:
-            print('    .const_table = NULL,')
-        print('    #if MICROPY_PERSISTENT_CODE_SAVE')
-        print('    .fun_data_len = %u,' % len(self.bytecode))
-        print('    .n_obj = %u,' % len(self.objs))
-        print('    .n_raw_code = %u,' % len(self.raw_codes))
-        print('    #if MICROPY_EMIT_NATIVE || MICROPY_EMIT_INLINE_ASM')
-        print('    .prelude_offset = %u,' % self.prelude_offset)
-        print('    .n_qstr = %u,' % len(qstr_links))
-        print('    .qstr_link = NULL,') # TODO
-        print('    #endif')
-        print('    #endif')
-        print('    #if MICROPY_EMIT_NATIVE || MICROPY_EMIT_INLINE_ASM')
-        print('    .type_sig = %u,' % type_sig)
-        print('    #endif')
-        print('};')
+            print("    .const_table = NULL,")
+        print("    #if MICROPY_PERSISTENT_CODE_SAVE")
+        print("    .fun_data_len = %u," % len(self.bytecode))
+        print("    .n_obj = %u," % len(self.objs))
+        print("    .n_raw_code = %u," % len(self.raw_codes))
+        if self.code_kind == MP_CODE_BYTECODE:
+            print("    #if MICROPY_PY_SYS_SETTRACE")
+            print("    .prelude = {")
+            print("        .n_state = %u," % self.prelude[0])
+            print("        .n_exc_stack = %u," % self.prelude[1])
+            print("        .scope_flags = %u," % self.prelude[2])
+            print("        .n_pos_args = %u," % self.prelude[3])
+            print("        .n_kwonly_args = %u," % self.prelude[4])
+            print("        .n_def_pos_args = %u," % self.prelude[5])
+            print("        .qstr_block_name = %s," % self.simple_name.qstr_id)
+            print("        .qstr_source_file = %s," % self.source_file.qstr_id)
+            print("        .line_info = fun_data_%s + %u," % (self.escaped_name, 0))  # TODO
+            print("        .opcodes = fun_data_%s + %u," % (self.escaped_name, self.ip))
+            print("    },")
+            print("    .line_of_definition = %u," % 0)  # TODO
+            print("    #endif")
+        print("    #if MICROPY_EMIT_MACHINE_CODE")
+        print("    .prelude_offset = %u," % self.prelude_offset)
+        print("    .n_qstr = %u," % len(qstr_links))
+        print("    .qstr_link = NULL,")  # TODO
+        print("    #endif")
+        print("    #endif")
+        print("    #if MICROPY_EMIT_MACHINE_CODE")
+        print("    .type_sig = %u," % type_sig)
+        print("    #endif")
+        print("};")
+
 
 class RawCodeBytecode(RawCode):
     def __init__(self, bytecode, qstrs, objs, raw_codes):
-        super(RawCodeBytecode, self).__init__(MP_CODE_BYTECODE, bytecode, 0, qstrs, objs, raw_codes)
+        super(RawCodeBytecode, self).__init__(
+            MP_CODE_BYTECODE, bytecode, 0, qstrs, objs, raw_codes
+        )
 
     def freeze(self, parent_name):
         self.freeze_children(parent_name)
 
         # generate bytecode data
         print()
-        print('// frozen bytecode for file %s, scope %s%s' % (self.source_file.str, parent_name, self.simple_name.str))
-        print('STATIC ', end='')
+        print(
+            "// frozen bytecode for file %s, scope %s%s"
+            % (self.source_file.str, parent_name, self.simple_name.str)
+        )
+        print("STATIC ", end="")
         if not config.MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE:
-            print('const ', end='')
-        print('byte fun_data_%s[%u] = {' % (self.escaped_name, len(self.bytecode)))
-        print('   ', end='')
+            print("const ", end="")
+        print("byte fun_data_%s[%u] = {" % (self.escaped_name, len(self.bytecode)))
+        print("   ", end="")
         for i in range(self.ip2):
-            print(' 0x%02x,' % self.bytecode[i], end='')
+            print(" 0x%02x," % self.bytecode[i], end="")
         print()
-        print('   ', self.simple_name.qstr_id, '& 0xff,', self.simple_name.qstr_id, '>> 8,')
-        print('   ', self.source_file.qstr_id, '& 0xff,', self.source_file.qstr_id, '>> 8,')
-        print('   ', end='')
+        print("   ", self.simple_name.qstr_id, "& 0xff,", self.simple_name.qstr_id, ">> 8,")
+        print("   ", self.source_file.qstr_id, "& 0xff,", self.source_file.qstr_id, ">> 8,")
+        print("   ", end="")
         for i in range(self.ip2 + 4, self.ip):
-            print(' 0x%02x,' % self.bytecode[i], end='')
+            print(" 0x%02x," % self.bytecode[i], end="")
         print()
         ip = self.ip
         while ip < len(self.bytecode):
             f, sz = mp_opcode_format(self.bytecode, ip, True)
             if f == 1:
                 qst = self._unpack_qstr(ip + 1).qstr_id
-                extra = '' if sz == 3 else ' 0x%02x,' % self.bytecode[ip + 3]
-                print('   ', '0x%02x,' % self.bytecode[ip], qst, '& 0xff,', qst, '>> 8,', extra)
+                extra = "" if sz == 3 else " 0x%02x," % self.bytecode[ip + 3]
+                print("   ", "0x%02x," % self.bytecode[ip], qst, "& 0xff,", qst, ">> 8,", extra)
             else:
-                print('   ', ''.join('0x%02x, ' % self.bytecode[ip + i] for i in range(sz)))
+                print("   ", "".join("0x%02x, " % self.bytecode[ip + i] for i in range(sz)))
             ip += sz
-        print('};')
+        print("};")
 
         self.freeze_constants()
         self.freeze_module()
 
+
 class RawCodeNative(RawCode):
-    def __init__(self, code_kind, fun_data, prelude_offset, prelude, qstr_links, qstrs, objs, raw_codes, type_sig):
-        super(RawCodeNative, self).__init__(code_kind, fun_data, prelude_offset, qstrs, objs, raw_codes)
+    def __init__(
+        self,
+        code_kind,
+        fun_data,
+        prelude_offset,
+        prelude,
+        qstr_links,
+        qstrs,
+        objs,
+        raw_codes,
+        type_sig,
+    ):
+        super(RawCodeNative, self).__init__(
+            code_kind, fun_data, prelude_offset, qstrs, objs, raw_codes
+        )
         self.prelude = prelude
         self.qstr_links = qstr_links
         self.type_sig = type_sig
-        if config.native_arch in (MP_NATIVE_ARCH_X86, MP_NATIVE_ARCH_X64):
+        if config.native_arch in (
+            MP_NATIVE_ARCH_X86,
+            MP_NATIVE_ARCH_X64,
+            MP_NATIVE_ARCH_XTENSA,
+            MP_NATIVE_ARCH_XTENSAWIN,
+        ):
             self.fun_data_attributes = '__attribute__((section(".text,\\"ax\\",@progbits # ")))'
         else:
             self.fun_data_attributes = '__attribute__((section(".text,\\"ax\\",%progbits @ ")))'
 
+        # Allow single-byte alignment by default for x86/x64.
+        # ARM needs word alignment, ARM Thumb needs halfword, due to instruction size.
+        # Xtensa needs word alignment due to the 32-bit constant table embedded in the code.
+        if config.native_arch in (
+            MP_NATIVE_ARCH_ARMV6,
+            MP_NATIVE_ARCH_XTENSA,
+            MP_NATIVE_ARCH_XTENSAWIN,
+        ):
+            # ARMV6 or Xtensa -- four byte align.
+            self.fun_data_attributes += " __attribute__ ((aligned (4)))"
+        elif MP_NATIVE_ARCH_ARMV6M <= config.native_arch <= MP_NATIVE_ARCH_ARMV7EMDP:
+            # ARMVxxM -- two byte align.
+            self.fun_data_attributes += " __attribute__ ((aligned (2)))"
+
     def _asm_thumb_rewrite_mov(self, pc, val):
-        print('    (%u & 0xf0) | (%s >> 12),' % (self.bytecode[pc], val), end='')
-        print(' (%u & 0xfb) | (%s >> 9 & 0x04),' % (self.bytecode[pc + 1], val), end='')
-        print(' (%s & 0xff),' % (val,), end='')
-        print(' (%u & 0x07) | (%s >> 4 & 0x70),' % (self.bytecode[pc + 3], val))
+        print("    (%u & 0xf0) | (%s >> 12)," % (self.bytecode[pc], val), end="")
+        print(" (%u & 0xfb) | (%s >> 9 & 0x04)," % (self.bytecode[pc + 1], val), end="")
+        print(" (%s & 0xff)," % (val,), end="")
+        print(" (%u & 0x07) | (%s >> 4 & 0x70)," % (self.bytecode[pc + 3], val))
 
     def _link_qstr(self, pc, kind, qst):
         if kind == 0:
-            print('    %s & 0xff, %s >> 8,' % (qst, qst))
+            # Generic 16-bit link
+            print("    %s & 0xff, %s >> 8," % (qst, qst))
+            return 2
         else:
-            if kind == 2:
-                qst = '((uintptr_t)MP_OBJ_NEW_QSTR(%s))' % qst
-            if config.native_arch in (MP_NATIVE_ARCH_X86, MP_NATIVE_ARCH_X64):
-                print('    %s & 0xff, %s >> 8, 0, 0,' % (qst, qst))
+            # Architecture-specific link
+            is_obj = kind == 2
+            if is_obj:
+                qst = "((uintptr_t)MP_OBJ_NEW_QSTR(%s))" % qst
+            if config.native_arch in (
+                MP_NATIVE_ARCH_X86,
+                MP_NATIVE_ARCH_X64,
+                MP_NATIVE_ARCH_XTENSA,
+                MP_NATIVE_ARCH_XTENSAWIN,
+            ):
+                print(
+                    "    %s & 0xff, (%s >> 8) & 0xff, (%s >> 16) & 0xff, %s >> 24,"
+                    % (qst, qst, qst, qst)
+                )
+                return 4
             elif MP_NATIVE_ARCH_ARMV6M <= config.native_arch <= MP_NATIVE_ARCH_ARMV7EMDP:
                 if is_obj:
-                    self._asm_thumb_rewrite_mov(i, qst)
-                    self._asm_thumb_rewrite_mov(i + 4, '(%s >> 16)' % qst)
+                    # qstr object, movw and movt
+                    self._asm_thumb_rewrite_mov(pc, qst)
+                    self._asm_thumb_rewrite_mov(pc + 4, "(%s >> 16)" % qst)
+                    return 8
                 else:
-                    self._asm_thumb_rewrite_mov(i, qst)
+                    # qstr number, movw instruction
+                    self._asm_thumb_rewrite_mov(pc, qst)
+                    return 4
             else:
                 assert 0
 
     def freeze(self, parent_name):
+        if self.prelude[2] & ~0x0F:
+            raise FreezeError("unable to freeze code with relocations")
+
         self.freeze_children(parent_name)
 
         # generate native code data
         print()
         if self.code_kind == MP_CODE_NATIVE_PY:
-            print('// frozen native code for file %s, scope %s%s' % (self.source_file.str, parent_name, self.simple_name.str))
+            print(
+                "// frozen native code for file %s, scope %s%s"
+                % (self.source_file.str, parent_name, self.simple_name.str)
+            )
         elif self.code_kind == MP_CODE_NATIVE_VIPER:
-            print('// frozen viper code for scope %s' % (parent_name,))
+            print("// frozen viper code for scope %s" % (parent_name,))
         else:
-            print('// frozen assembler code for scope %s' % (parent_name,))
-        print('STATIC const byte fun_data_%s[%u] %s = {' % (self.escaped_name, len(self.bytecode), self.fun_data_attributes))
+            print("// frozen assembler code for scope %s" % (parent_name,))
+        print(
+            "STATIC const byte fun_data_%s[%u] %s = {"
+            % (self.escaped_name, len(self.bytecode), self.fun_data_attributes)
+        )
 
         if self.code_kind == MP_CODE_NATIVE_PY:
             i_top = self.prelude_offset
@@ -518,39 +582,39 @@ def freeze(self, parent_name):
                 # link qstr
                 qi_off, qi_kind, qi_val = self.qstr_links[qi]
                 qst = global_qstrs[qi_val].qstr_id
-                self._link_qstr(i, qi_kind, qst)
-                i += 4
+                i += self._link_qstr(i, qi_kind, qst)
                 qi += 1
             else:
                 # copy machine code (max 16 bytes)
                 i16 = min(i + 16, i_top)
                 if qi < len(self.qstr_links):
                     i16 = min(i16, self.qstr_links[qi][0])
-                print('   ', end='')
+                print("   ", end="")
                 for ii in range(i, i16):
-                    print(' 0x%02x,' % self.bytecode[ii], end='')
+                    print(" 0x%02x," % self.bytecode[ii], end="")
                 print()
                 i = i16
 
         if self.code_kind == MP_CODE_NATIVE_PY:
-            print('   ', end='')
+            print("   ", end="")
             for i in range(self.prelude_offset, self.ip2):
-                print(' 0x%02x,' % self.bytecode[i], end='')
+                print(" 0x%02x," % self.bytecode[i], end="")
             print()
 
-            print('   ', self.simple_name.qstr_id, '& 0xff,', self.simple_name.qstr_id, '>> 8,')
-            print('   ', self.source_file.qstr_id, '& 0xff,', self.source_file.qstr_id, '>> 8,')
+            print("   ", self.simple_name.qstr_id, "& 0xff,", self.simple_name.qstr_id, ">> 8,")
+            print("   ", self.source_file.qstr_id, "& 0xff,", self.source_file.qstr_id, ">> 8,")
 
-            print('   ', end='')
+            print("   ", end="")
             for i in range(self.ip2 + 4, self.ip):
-                print(' 0x%02x,' % self.bytecode[i], end='')
+                print(" 0x%02x," % self.bytecode[i], end="")
             print()
 
-        print('};')
+        print("};")
 
         self.freeze_constants()
         self.freeze_module(self.qstr_links, self.type_sig)
 
+
 class BytecodeBuffer:
     def __init__(self, size):
         self.buf = bytearray(size)
@@ -563,21 +627,24 @@ def append(self, b):
         self.buf[self.idx] = b
         self.idx += 1
 
+
 def read_byte(f, out=None):
     b = bytes_cons(f.read(1))[0]
     if out is not None:
         out.append(b)
     return b
 
+
 def read_uint(f, out=None):
     i = 0
     while True:
         b = read_byte(f, out)
-        i = (i << 7) | (b & 0x7f)
+        i = (i << 7) | (b & 0x7F)
         if b & 0x80 == 0:
             break
     return i
 
+
 def read_qstr(f, qstr_win):
     ln = read_uint(f)
     if ln == 0:
@@ -587,65 +654,70 @@ def read_qstr(f, qstr_win):
         # qstr in table
         return qstr_win.access(ln >> 1)
     ln >>= 1
-    data = str_cons(f.read(ln), 'utf8')
+    data = str_cons(f.read(ln), "utf8")
     global_qstrs.append(QStrType(data))
     qstr_win.push(len(global_qstrs) - 1)
     return len(global_qstrs) - 1
 
+
 def read_obj(f):
     obj_type = f.read(1)
-    if obj_type == b'e':
+    if obj_type == b"e":
         return Ellipsis
     else:
         buf = f.read(read_uint(f))
-        if obj_type == b's':
-            return str_cons(buf, 'utf8')
-        elif obj_type == b'b':
+        if obj_type == b"s":
+            return str_cons(buf, "utf8")
+        elif obj_type == b"b":
             return bytes_cons(buf)
-        elif obj_type == b'i':
-            return int(str_cons(buf, 'ascii'), 10)
-        elif obj_type == b'f':
-            return float(str_cons(buf, 'ascii'))
-        elif obj_type == b'c':
-            return complex(str_cons(buf, 'ascii'))
+        elif obj_type == b"i":
+            return int(str_cons(buf, "ascii"), 10)
+        elif obj_type == b"f":
+            return float(str_cons(buf, "ascii"))
+        elif obj_type == b"c":
+            return complex(str_cons(buf, "ascii"))
         else:
             assert 0
 
-def read_prelude(f, bytecode):
-    n_state = read_uint(f, bytecode)
-    n_exc_stack = read_uint(f, bytecode)
-    scope_flags = read_byte(f, bytecode)
-    n_pos_args = read_byte(f, bytecode)
-    n_kwonly_args = read_byte(f, bytecode)
-    n_def_pos_args = read_byte(f, bytecode)
-    l1 = bytecode.idx
-    code_info_size = read_uint(f, bytecode)
-    l2 = bytecode.idx
-    for _ in range(code_info_size - (l2 - l1)):
+
+def read_prelude(f, bytecode, qstr_win):
+    (
+        n_state,
+        n_exc_stack,
+        scope_flags,
+        n_pos_args,
+        n_kwonly_args,
+        n_def_pos_args,
+    ) = read_prelude_sig(lambda: read_byte(f, bytecode))
+    n_info, n_cell = read_prelude_size(lambda: read_byte(f, bytecode))
+    read_qstr_and_pack(f, bytecode, qstr_win)  # simple_name
+    read_qstr_and_pack(f, bytecode, qstr_win)  # source_file
+    for _ in range(n_info - 4 + n_cell):
         read_byte(f, bytecode)
-    while read_byte(f, bytecode) != 255:
-        pass
-    return l2, (n_state, n_exc_stack, scope_flags, n_pos_args, n_kwonly_args, n_def_pos_args, code_info_size)
+    return n_state, n_exc_stack, scope_flags, n_pos_args, n_kwonly_args, n_def_pos_args
+
 
 def read_qstr_and_pack(f, bytecode, qstr_win):
     qst = read_qstr(f, qstr_win)
-    bytecode.append(qst & 0xff)
+    bytecode.append(qst & 0xFF)
     bytecode.append(qst >> 8)
 
+
 def read_bytecode(file, bytecode, qstr_win):
     while not bytecode.is_full():
         op = read_byte(file, bytecode)
         f, sz = mp_opcode_format(bytecode.buf, bytecode.idx - 1, False)
         sz -= 1
-        if f == MP_OPCODE_QSTR:
+        if f == MP_BC_FORMAT_QSTR:
             read_qstr_and_pack(file, bytecode, qstr_win)
             sz -= 2
-        elif f == MP_OPCODE_VAR_UINT:
+        elif f == MP_BC_FORMAT_VAR_UINT:
             while read_byte(file, bytecode) & 0x80:
                 pass
         for _ in range(sz):
             read_byte(file, bytecode)
 
+
 def read_raw_code(f, qstr_win):
     kind_len = read_uint(f)
     kind = (kind_len & 3) + MP_CODE_BYTECODE
@@ -653,7 +725,7 @@ def read_raw_code(f, qstr_win):
     fun_data = BytecodeBuffer(fun_data_len)
 
     if kind == MP_CODE_BYTECODE:
-        name_idx, prelude = read_prelude(f, fun_data)
+        prelude = read_prelude(f, fun_data, qstr_win)
         read_bytecode(f, fun_data, qstr_win)
     else:
         fun_data.buf[:] = f.read(fun_data_len)
@@ -663,7 +735,7 @@ def read_raw_code(f, qstr_win):
             # load qstr link table
             n_qstr_link = read_uint(f)
             for _ in range(n_qstr_link):
-                off = read_uint(f, qstr_win)
+                off = read_uint(f)
                 qst = read_qstr(f, qstr_win)
                 qstr_links.append((off >> 2, off & 3, qst))
 
@@ -671,6 +743,9 @@ def read_raw_code(f, qstr_win):
         if kind == MP_CODE_NATIVE_PY:
             prelude_offset = read_uint(f)
             _, name_idx, prelude = extract_prelude(fun_data.buf, prelude_offset)
+            fun_data.idx = name_idx  # rewind to where qstrs are in prelude
+            read_qstr_and_pack(f, fun_data, qstr_win)  # simple_name
+            read_qstr_and_pack(f, fun_data, qstr_win)  # source_file
         else:
             prelude_offset = None
             scope_flags = read_uint(f)
@@ -680,11 +755,6 @@ def read_raw_code(f, qstr_win):
                 type_sig = read_uint(f)
             prelude = (None, None, scope_flags, n_pos_args, 0)
 
-    if kind in (MP_CODE_BYTECODE, MP_CODE_NATIVE_PY):
-        fun_data.idx = name_idx # rewind to where qstrs are in prelude
-        read_qstr_and_pack(f, fun_data, qstr_win) # simple_name
-        read_qstr_and_pack(f, fun_data, qstr_win) # source_file
-
     qstrs = []
     objs = []
     raw_codes = []
@@ -701,28 +771,49 @@ def read_raw_code(f, qstr_win):
     if kind == MP_CODE_BYTECODE:
         return RawCodeBytecode(fun_data.buf, qstrs, objs, raw_codes)
     else:
-        return RawCodeNative(kind, fun_data.buf, prelude_offset, prelude, qstr_links, qstrs, objs, raw_codes, type_sig)
+        return RawCodeNative(
+            kind,
+            fun_data.buf,
+            prelude_offset,
+            prelude,
+            qstr_links,
+            qstrs,
+            objs,
+            raw_codes,
+            type_sig,
+        )
+
 
 def read_mpy(filename):
-    with open(filename, 'rb') as f:
+    with open(filename, "rb") as f:
         header = bytes_cons(f.read(4))
-        if header[0] != ord('M'):
-            raise Exception('not a valid .mpy file')
+        if header[0] != ord("M"):
+            raise Exception("not a valid .mpy file")
         if header[1] != config.MPY_VERSION:
-            raise Exception('incompatible .mpy version')
+            raise Exception("incompatible .mpy version")
         feature_byte = header[2]
         qw_size = read_uint(f)
         config.MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE = (feature_byte & 1) != 0
         config.MICROPY_PY_BUILTINS_STR_UNICODE = (feature_byte & 2) != 0
-        config.native_arch = feature_byte >> 2
+        mpy_native_arch = feature_byte >> 2
+        if mpy_native_arch != MP_NATIVE_ARCH_NONE:
+            if config.native_arch == MP_NATIVE_ARCH_NONE:
+                config.native_arch = mpy_native_arch
+            elif config.native_arch != mpy_native_arch:
+                raise Exception("native architecture mismatch")
         config.mp_small_int_bits = header[3]
         qstr_win = QStrWindow(qw_size)
-        return read_raw_code(f, qstr_win)
+        rc = read_raw_code(f, qstr_win)
+        rc.mpy_source_file = filename
+        rc.qstr_win_size = qw_size
+        return rc
+
 
 def dump_mpy(raw_codes):
     for rc in raw_codes:
         rc.dump()
 
+
 def freeze_mpy(base_qstrs, raw_codes):
     # add to qstrs
     new = {}
@@ -737,113 +828,184 @@ def freeze_mpy(base_qstrs, raw_codes):
     print('#include "py/objint.h"')
     print('#include "py/objstr.h"')
     print('#include "py/emitglue.h"')
+    print('#include "py/nativeglue.h"')
     print()
 
-    print('#if MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE != %u' % config.MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE)
+    print(
+        "#if MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE != %u"
+        % config.MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE
+    )
     print('#error "incompatible MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE"')
-    print('#endif')
+    print("#endif")
     print()
 
-    print('#if MICROPY_LONGINT_IMPL != %u' % config.MICROPY_LONGINT_IMPL)
+    print("#if MICROPY_LONGINT_IMPL != %u" % config.MICROPY_LONGINT_IMPL)
     print('#error "incompatible MICROPY_LONGINT_IMPL"')
-    print('#endif')
+    print("#endif")
     print()
 
     if config.MICROPY_LONGINT_IMPL == config.MICROPY_LONGINT_IMPL_MPZ:
-        print('#if MPZ_DIG_SIZE != %u' % config.MPZ_DIG_SIZE)
+        print("#if MPZ_DIG_SIZE != %u" % config.MPZ_DIG_SIZE)
         print('#error "incompatible MPZ_DIG_SIZE"')
-        print('#endif')
+        print("#endif")
         print()
 
-
-    print('#if MICROPY_PY_BUILTINS_FLOAT')
-    print('typedef struct _mp_obj_float_t {')
-    print('    mp_obj_base_t base;')
-    print('    mp_float_t value;')
-    print('} mp_obj_float_t;')
-    print('#endif')
+    print("#if MICROPY_PY_BUILTINS_FLOAT")
+    print("typedef struct _mp_obj_float_t {")
+    print("    mp_obj_base_t base;")
+    print("    mp_float_t value;")
+    print("} mp_obj_float_t;")
+    print("#endif")
     print()
 
-    print('#if MICROPY_PY_BUILTINS_COMPLEX')
-    print('typedef struct _mp_obj_complex_t {')
-    print('    mp_obj_base_t base;')
-    print('    mp_float_t real;')
-    print('    mp_float_t imag;')
-    print('} mp_obj_complex_t;')
-    print('#endif')
+    print("#if MICROPY_PY_BUILTINS_COMPLEX")
+    print("typedef struct _mp_obj_complex_t {")
+    print("    mp_obj_base_t base;")
+    print("    mp_float_t real;")
+    print("    mp_float_t imag;")
+    print("} mp_obj_complex_t;")
+    print("#endif")
     print()
 
     if len(new) > 0:
-        print('enum {')
+        print("enum {")
         for i in range(len(new)):
             if i == 0:
-                print('    MP_QSTR_%s = MP_QSTRnumber_of,' % new[i][1])
+                print("    MP_QSTR_%s = MP_QSTRnumber_of," % new[i][1])
             else:
-                print('    MP_QSTR_%s,' % new[i][1])
-        print('};')
+                print("    MP_QSTR_%s," % new[i][1])
+        print("};")
 
     # As in qstr.c, set so that the first dynamically allocated pool is twice this size; must be <= the len
     qstr_pool_alloc = min(len(new), 10)
 
     print()
-    print('extern const qstr_pool_t mp_qstr_const_pool;');
-    print('const qstr_pool_t mp_qstr_frozen_const_pool = {')
-    print('    (qstr_pool_t*)&mp_qstr_const_pool, // previous pool')
-    print('    MP_QSTRnumber_of, // previous pool size')
-    print('    %u, // allocated entries' % qstr_pool_alloc)
-    print('    %u, // used entries' % len(new))
-    print('    {')
+    print("extern const qstr_pool_t mp_qstr_const_pool;")
+    print("const qstr_pool_t mp_qstr_frozen_const_pool = {")
+    print("    (qstr_pool_t*)&mp_qstr_const_pool, // previous pool")
+    print("    MP_QSTRnumber_of, // previous pool size")
+    print("    %u, // allocated entries" % qstr_pool_alloc)
+    print("    %u, // used entries" % len(new))
+    print("    {")
     for _, _, qstr in new:
-        print('        %s,'
-            % qstrutil.make_bytes(config.MICROPY_QSTR_BYTES_IN_LEN, config.MICROPY_QSTR_BYTES_IN_HASH, qstr))
-    print('    },')
-    print('};')
+        print(
+            "        %s,"
+            % qstrutil.make_bytes(
+                config.MICROPY_QSTR_BYTES_IN_LEN, config.MICROPY_QSTR_BYTES_IN_HASH, qstr
+            )
+        )
+    print("    },")
+    print("};")
 
     for rc in raw_codes:
-        rc.freeze(rc.source_file.str.replace('/', '_')[:-3] + '_')
+        rc.freeze(rc.source_file.str.replace("/", "_")[:-3] + "_")
 
     print()
-    print('const char mp_frozen_mpy_names[] = {')
+    print("const char mp_frozen_mpy_names[] = {")
     for rc in raw_codes:
         module_name = rc.source_file.str
         print('"%s\\0"' % module_name)
     print('"\\0"};')
 
-    print('const mp_raw_code_t *const mp_frozen_mpy_content[] = {')
+    print("const mp_raw_code_t *const mp_frozen_mpy_content[] = {")
     for rc in raw_codes:
-        print('    &raw_code_%s,' % rc.escaped_name)
-    print('};')
+        print("    &raw_code_%s," % rc.escaped_name)
+    print("};")
+
+
+def merge_mpy(raw_codes, output_file):
+    assert len(raw_codes) <= 31  # so var-uints all fit in 1 byte
+    merged_mpy = bytearray()
+
+    if len(raw_codes) == 1:
+        with open(raw_codes[0].mpy_source_file, "rb") as f:
+            merged_mpy.extend(f.read())
+    else:
+        header = bytearray(5)
+        header[0] = ord("M")
+        header[1] = config.MPY_VERSION
+        header[2] = (
+            config.native_arch << 2
+            | config.MICROPY_PY_BUILTINS_STR_UNICODE << 1
+            | config.MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE
+        )
+        header[3] = config.mp_small_int_bits
+        header[4] = 32  # qstr_win_size
+        merged_mpy.extend(header)
+
+        bytecode = bytearray()
+        bytecode_len = 6 + len(raw_codes) * 4 + 2
+        bytecode.append(bytecode_len << 2)  # kind and length
+        bytecode.append(0b00000000)  # signature prelude
+        bytecode.append(0b00001000)  # size prelude
+        bytecode.extend(b"\x00\x01")  # MP_QSTR_
+        bytecode.extend(b"\x00\x01")  # MP_QSTR_
+        for idx in range(len(raw_codes)):
+            bytecode.append(0x32)  # MP_BC_MAKE_FUNCTION
+            bytecode.append(idx)  # index raw code
+            bytecode.extend(b"\x34\x00")  # MP_BC_CALL_FUNCTION, 0 args
+        bytecode.extend(b"\x51\x63")  # MP_BC_LOAD_NONE, MP_BC_RETURN_VALUE
+
+        bytecode.append(0)  # n_obj
+        bytecode.append(len(raw_codes))  # n_raw_code
+
+        merged_mpy.extend(bytecode)
+
+        for rc in raw_codes:
+            with open(rc.mpy_source_file, "rb") as f:
+                f.read(4)  # skip header
+                read_uint(f)  # skip qstr_win_size
+                data = f.read()  # read rest of mpy file
+                merged_mpy.extend(data)
+
+    if output_file is None:
+        sys.stdout.buffer.write(merged_mpy)
+    else:
+        with open(output_file, "wb") as f:
+            f.write(merged_mpy)
+
 
 def main():
     import argparse
-    cmd_parser = argparse.ArgumentParser(description='A tool to work with MicroPython .mpy files.')
-    cmd_parser.add_argument('-d', '--dump', action='store_true',
-        help='dump contents of files')
-    cmd_parser.add_argument('-f', '--freeze', action='store_true',
-        help='freeze files')
-    cmd_parser.add_argument('-q', '--qstr-header',
-        help='qstr header file to freeze against')
-    cmd_parser.add_argument('-mlongint-impl', choices=['none', 'longlong', 'mpz'], default='mpz',
-        help='long-int implementation used by target (default mpz)')
-    cmd_parser.add_argument('-mmpz-dig-size', metavar='N', type=int, default=16,
-        help='mpz digit size used by target (default 16)')
-    cmd_parser.add_argument('files', nargs='+',
-        help='input .mpy files')
+
+    cmd_parser = argparse.ArgumentParser(description="A tool to work with MicroPython .mpy files.")
+    cmd_parser.add_argument("-d", "--dump", action="store_true", help="dump contents of files")
+    cmd_parser.add_argument("-f", "--freeze", action="store_true", help="freeze files")
+    cmd_parser.add_argument(
+        "--merge", action="store_true", help="merge multiple .mpy files into one"
+    )
+    cmd_parser.add_argument("-q", "--qstr-header", help="qstr header file to freeze against")
+    cmd_parser.add_argument(
+        "-mlongint-impl",
+        choices=["none", "longlong", "mpz"],
+        default="mpz",
+        help="long-int implementation used by target (default mpz)",
+    )
+    cmd_parser.add_argument(
+        "-mmpz-dig-size",
+        metavar="N",
+        type=int,
+        default=16,
+        help="mpz digit size used by target (default 16)",
+    )
+    cmd_parser.add_argument("-o", "--output", default=None, help="output file")
+    cmd_parser.add_argument("files", nargs="+", help="input .mpy files")
     args = cmd_parser.parse_args()
 
     # set config values relevant to target machine
     config.MICROPY_LONGINT_IMPL = {
-        'none':config.MICROPY_LONGINT_IMPL_NONE,
-        'longlong':config.MICROPY_LONGINT_IMPL_LONGLONG,
-        'mpz':config.MICROPY_LONGINT_IMPL_MPZ,
+        "none": config.MICROPY_LONGINT_IMPL_NONE,
+        "longlong": config.MICROPY_LONGINT_IMPL_LONGLONG,
+        "mpz": config.MICROPY_LONGINT_IMPL_MPZ,
     }[args.mlongint_impl]
     config.MPZ_DIG_SIZE = args.mmpz_dig_size
+    config.native_arch = MP_NATIVE_ARCH_NONE
 
     # set config values for qstrs, and get the existing base set of qstrs
     if args.qstr_header:
         qcfgs, base_qstrs = qstrutil.parse_input_headers([args.qstr_header])
-        config.MICROPY_QSTR_BYTES_IN_LEN = int(qcfgs['BYTES_IN_LEN'])
-        config.MICROPY_QSTR_BYTES_IN_HASH = int(qcfgs['BYTES_IN_HASH'])
+        config.MICROPY_QSTR_BYTES_IN_LEN = int(qcfgs["BYTES_IN_LEN"])
+        config.MICROPY_QSTR_BYTES_IN_HASH = int(qcfgs["BYTES_IN_HASH"])
     else:
         config.MICROPY_QSTR_BYTES_IN_LEN = 1
         config.MICROPY_QSTR_BYTES_IN_HASH = 1
@@ -859,6 +1021,9 @@ def main():
         except FreezeError as er:
             print(er, file=sys.stderr)
             sys.exit(1)
+    elif args.merge:
+        merged_mpy = merge_mpy(raw_codes, args.output)
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/tools/mpy_cross_all.py b/tools/mpy_cross_all.py
index 2bda71e9bc709..d542bde42e34c 100755
--- a/tools/mpy_cross_all.py
+++ b/tools/mpy_cross_all.py
@@ -6,7 +6,9 @@
 argparser = argparse.ArgumentParser(description="Compile all .py files to .mpy recursively")
 argparser.add_argument("-o", "--out", help="output directory (default: input dir)")
 argparser.add_argument("--target", help="select MicroPython target config")
-argparser.add_argument("-mcache-lookup-bc", action="store_true", help="cache map lookups in the bytecode")
+argparser.add_argument(
+    "-mcache-lookup-bc", action="store_true", help="cache map lookups in the bytecode"
+)
 argparser.add_argument("dir", help="input directory")
 args = argparser.parse_args()
 
@@ -26,13 +28,17 @@
     for f in files:
         if f.endswith(".py"):
             fpath = path + "/" + f
-            #print(fpath)
+            # print(fpath)
             out_fpath = args.out + "/" + fpath[path_prefix_len:-3] + ".mpy"
             out_dir = os.path.dirname(out_fpath)
             if not os.path.isdir(out_dir):
                 os.makedirs(out_dir)
-            cmd = "mpy-cross -v -v %s -s %s %s -o %s" % (TARGET_OPTS.get(args.target, ""),
-                fpath[path_prefix_len:], fpath, out_fpath)
-            #print(cmd)
+            cmd = "mpy-cross -v -v %s -s %s %s -o %s" % (
+                TARGET_OPTS.get(args.target, ""),
+                fpath[path_prefix_len:],
+                fpath,
+                out_fpath,
+            )
+            # print(cmd)
             res = os.system(cmd)
             assert res == 0
diff --git a/tools/mpy_ld.py b/tools/mpy_ld.py
new file mode 100755
index 0000000000000..32bc176cb71c4
--- /dev/null
+++ b/tools/mpy_ld.py
@@ -0,0 +1,1081 @@
+#!/usr/bin/env python3
+#
+# This file is part of the MicroPython project, http://micropython.org/
+#
+# The MIT License (MIT)
+#
+# Copyright (c) 2019 Damien P. George
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""
+Link .o files to .mpy
+"""
+
+import sys, os, struct, re
+from elftools.elf import elffile
+
+sys.path.append(os.path.dirname(__file__) + "/../py")
+import makeqstrdata as qstrutil
+
+# MicroPython constants
+MPY_VERSION = 5
+MP_NATIVE_ARCH_X86 = 1
+MP_NATIVE_ARCH_X64 = 2
+MP_NATIVE_ARCH_ARMV7M = 5
+MP_NATIVE_ARCH_ARMV7EMSP = 7
+MP_NATIVE_ARCH_ARMV7EMDP = 8
+MP_NATIVE_ARCH_XTENSA = 9
+MP_NATIVE_ARCH_XTENSAWIN = 10
+MP_CODE_BYTECODE = 2
+MP_CODE_NATIVE_VIPER = 4
+MP_SCOPE_FLAG_VIPERRELOC = 0x10
+MP_SCOPE_FLAG_VIPERRODATA = 0x20
+MP_SCOPE_FLAG_VIPERBSS = 0x40
+MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE = 1
+MICROPY_PY_BUILTINS_STR_UNICODE = 2
+MP_SMALL_INT_BITS = 31
+QSTR_WINDOW_SIZE = 32
+
+# ELF constants
+R_386_32 = 1
+R_X86_64_64 = 1
+R_XTENSA_32 = 1
+R_386_PC32 = 2
+R_X86_64_PC32 = 2
+R_ARM_ABS32 = 2
+R_386_GOT32 = 3
+R_ARM_REL32 = 3
+R_386_PLT32 = 4
+R_X86_64_PLT32 = 4
+R_XTENSA_PLT = 6
+R_386_GOTOFF = 9
+R_386_GOTPC = 10
+R_ARM_THM_CALL = 10
+R_XTENSA_DIFF32 = 19
+R_XTENSA_SLOT0_OP = 20
+R_ARM_BASE_PREL = 25  # aka R_ARM_GOTPC
+R_ARM_GOT_BREL = 26  # aka R_ARM_GOT32
+R_ARM_THM_JUMP24 = 30
+R_X86_64_REX_GOTPCRELX = 42
+R_386_GOT32X = 43
+
+################################################################################
+# Architecture configuration
+
+
+def asm_jump_x86(entry):
+    return struct.pack("<BI", 0xE9, entry - 5)
+
+
+def asm_jump_arm(entry):
+    b_off = entry - 4
+    if b_off >> 11 == 0 or b_off >> 11 == -1:
+        # Signed value fits in 12 bits
+        b0 = 0xE000 | (b_off >> 1 & 0x07FF)
+        b1 = 0
+    else:
+        # Use large jump
+        b0 = 0xF000 | (b_off >> 12 & 0x07FF)
+        b1 = 0xB800 | (b_off >> 1 & 0x7FF)
+    return struct.pack("<HH", b0, b1)
+
+
+def asm_jump_xtensa(entry):
+    jump_offset = entry - 4
+    jump_op = jump_offset << 6 | 6
+    return struct.pack("<BH", jump_op & 0xFF, jump_op >> 8)
+
+
+class ArchData:
+    def __init__(self, name, mpy_feature, qstr_entry_size, word_size, arch_got, asm_jump):
+        self.name = name
+        self.mpy_feature = mpy_feature
+        self.qstr_entry_size = qstr_entry_size
+        self.word_size = word_size
+        self.arch_got = arch_got
+        self.asm_jump = asm_jump
+        self.separate_rodata = name == "EM_XTENSA" and qstr_entry_size == 4
+
+
+ARCH_DATA = {
+    "x86": ArchData(
+        "EM_386",
+        MP_NATIVE_ARCH_X86 << 2
+        | MICROPY_PY_BUILTINS_STR_UNICODE
+        | MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE,
+        2,
+        4,
+        (R_386_PC32, R_386_GOT32, R_386_GOT32X),
+        asm_jump_x86,
+    ),
+    "x64": ArchData(
+        "EM_X86_64",
+        MP_NATIVE_ARCH_X64 << 2
+        | MICROPY_PY_BUILTINS_STR_UNICODE
+        | MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE,
+        2,
+        8,
+        (R_X86_64_REX_GOTPCRELX,),
+        asm_jump_x86,
+    ),
+    "armv7m": ArchData(
+        "EM_ARM",
+        MP_NATIVE_ARCH_ARMV7M << 2 | MICROPY_PY_BUILTINS_STR_UNICODE,
+        2,
+        4,
+        (R_ARM_GOT_BREL,),
+        asm_jump_arm,
+    ),
+    "armv7emsp": ArchData(
+        "EM_ARM",
+        MP_NATIVE_ARCH_ARMV7EMSP << 2 | MICROPY_PY_BUILTINS_STR_UNICODE,
+        2,
+        4,
+        (R_ARM_GOT_BREL,),
+        asm_jump_arm,
+    ),
+    "armv7emdp": ArchData(
+        "EM_ARM",
+        MP_NATIVE_ARCH_ARMV7EMDP << 2 | MICROPY_PY_BUILTINS_STR_UNICODE,
+        2,
+        4,
+        (R_ARM_GOT_BREL,),
+        asm_jump_arm,
+    ),
+    "xtensa": ArchData(
+        "EM_XTENSA",
+        MP_NATIVE_ARCH_XTENSA << 2 | MICROPY_PY_BUILTINS_STR_UNICODE,
+        2,
+        4,
+        (R_XTENSA_32, R_XTENSA_PLT),
+        asm_jump_xtensa,
+    ),
+    "xtensawin": ArchData(
+        "EM_XTENSA",
+        MP_NATIVE_ARCH_XTENSAWIN << 2 | MICROPY_PY_BUILTINS_STR_UNICODE,
+        4,
+        4,
+        (R_XTENSA_32, R_XTENSA_PLT),
+        asm_jump_xtensa,
+    ),
+}
+
+################################################################################
+# Helper functions
+
+
+def align_to(value, align):
+    return (value + align - 1) & ~(align - 1)
+
+
+def unpack_u24le(data, offset):
+    return data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16
+
+
+def pack_u24le(data, offset, value):
+    data[offset] = value & 0xFF
+    data[offset + 1] = value >> 8 & 0xFF
+    data[offset + 2] = value >> 16 & 0xFF
+
+
+def xxd(text):
+    for i in range(0, len(text), 16):
+        print("{:08x}:".format(i), end="")
+        for j in range(4):
+            off = i + j * 4
+            if off < len(text):
+                d = int.from_bytes(text[off : off + 4], "little")
+                print(" {:08x}".format(d), end="")
+        print()
+
+
+# Smaller numbers are enabled first
+LOG_LEVEL_1 = 1
+LOG_LEVEL_2 = 2
+LOG_LEVEL_3 = 3
+log_level = LOG_LEVEL_1
+
+
+def log(level, msg):
+    if level <= log_level:
+        print(msg)
+
+
+################################################################################
+# Qstr extraction
+
+
+def extract_qstrs(source_files):
+    def read_qstrs(f):
+        with open(f) as f:
+            vals = set()
+            objs = set()
+            for line in f:
+                while line:
+                    m = re.search(r"MP_OBJ_NEW_QSTR\((MP_QSTR_[A-Za-z0-9_]*)\)", line)
+                    if m:
+                        objs.add(m.group(1))
+                    else:
+                        m = re.search(r"MP_QSTR_[A-Za-z0-9_]*", line)
+                        if m:
+                            vals.add(m.group())
+                    if m:
+                        s = m.span()
+                        line = line[: s[0]] + line[s[1] :]
+                    else:
+                        line = ""
+            return vals, objs
+
+    static_qstrs = ["MP_QSTR_" + qstrutil.qstr_escape(q) for q in qstrutil.static_qstr_list]
+
+    qstr_vals = set()
+    qstr_objs = set()
+    for f in source_files:
+        vals, objs = read_qstrs(f)
+        qstr_vals.update(vals)
+        qstr_objs.update(objs)
+    qstr_vals.difference_update(static_qstrs)
+
+    return static_qstrs, qstr_vals, qstr_objs
+
+
+################################################################################
+# Linker
+
+
+class LinkError(Exception):
+    pass
+
+
+class Section:
+    def __init__(self, name, data, alignment, filename=None):
+        self.filename = filename
+        self.name = name
+        self.data = data
+        self.alignment = alignment
+        self.addr = 0
+        self.reloc = []
+
+    @staticmethod
+    def from_elfsec(elfsec, filename):
+        assert elfsec.header.sh_addr == 0
+        return Section(elfsec.name, elfsec.data(), elfsec.data_alignment, filename)
+
+
+class GOTEntry:
+    def __init__(self, name, sym, link_addr=0):
+        self.name = name
+        self.sym = sym
+        self.offset = None
+        self.link_addr = link_addr
+
+    def isexternal(self):
+        return self.sec_name.startswith(".external")
+
+    def istext(self):
+        return self.sec_name.startswith(".text")
+
+    def isrodata(self):
+        return self.sec_name.startswith((".rodata", ".data.rel.ro"))
+
+    def isbss(self):
+        return self.sec_name.startswith(".bss")
+
+
+class LiteralEntry:
+    def __init__(self, value, offset):
+        self.value = value
+        self.offset = offset
+
+
+class LinkEnv:
+    def __init__(self, arch):
+        self.arch = ARCH_DATA[arch]
+        self.sections = []  # list of sections in order of output
+        self.literal_sections = []  # list of literal sections (xtensa only)
+        self.known_syms = {}  # dict of symbols that are defined
+        self.unresolved_syms = []  # list of unresolved symbols
+        self.mpy_relocs = []  # list of relocations needed in the output .mpy file
+
+    def check_arch(self, arch_name):
+        if arch_name != self.arch.name:
+            raise LinkError("incompatible arch")
+
+    def print_sections(self):
+        log(LOG_LEVEL_2, "sections:")
+        for sec in self.sections:
+            log(LOG_LEVEL_2, "  {:08x} {} size={}".format(sec.addr, sec.name, len(sec.data)))
+
+    def find_addr(self, name):
+        if name in self.known_syms:
+            s = self.known_syms[name]
+            return s.section.addr + s["st_value"]
+        raise LinkError("unknown symbol: {}".format(name))
+
+
+def build_got_generic(env):
+    env.got_entries = {}
+    for sec in env.sections:
+        for r in sec.reloc:
+            s = r.sym
+            if not (
+                s.entry["st_info"]["bind"] == "STB_GLOBAL"
+                and r["r_info_type"] in env.arch.arch_got
+            ):
+                continue
+            s_type = s.entry["st_info"]["type"]
+            assert s_type in ("STT_NOTYPE", "STT_FUNC", "STT_OBJECT"), s_type
+            assert s.name
+            if s.name in env.got_entries:
+                continue
+            env.got_entries[s.name] = GOTEntry(s.name, s)
+
+
+def build_got_xtensa(env):
+    env.got_entries = {}
+    env.lit_entries = {}
+    env.xt_literals = {}
+
+    # Extract the values from the literal table
+    for sec in env.literal_sections:
+        assert len(sec.data) % env.arch.word_size == 0
+
+        # Look through literal relocations to find any global pointers that should be GOT entries
+        for r in sec.reloc:
+            s = r.sym
+            s_type = s.entry["st_info"]["type"]
+            assert s_type in ("STT_NOTYPE", "STT_FUNC", "STT_OBJECT", "STT_SECTION"), s_type
+            assert r["r_info_type"] in env.arch.arch_got
+            assert r["r_offset"] % env.arch.word_size == 0
+            # This entry is a global pointer
+            existing = struct.unpack_from("<I", sec.data, r["r_offset"])[0]
+            if s_type == "STT_SECTION":
+                assert r["r_addend"] == 0
+                name = "{}+0x{:x}".format(s.section.name, existing)
+            else:
+                assert existing == 0
+                name = s.name
+                if r["r_addend"] != 0:
+                    name = "{}+0x{:x}".format(name, r["r_addend"])
+            idx = "{}+0x{:x}".format(sec.filename, r["r_offset"])
+            env.xt_literals[idx] = name
+            if name in env.got_entries:
+                # Deduplicate GOT entries
+                continue
+            env.got_entries[name] = GOTEntry(name, s, existing)
+
+        # Go through all literal entries finding those that aren't global pointers so must be actual literals
+        for i in range(0, len(sec.data), env.arch.word_size):
+            idx = "{}+0x{:x}".format(sec.filename, i)
+            if idx not in env.xt_literals:
+                # This entry is an actual literal
+                value = struct.unpack_from("<I", sec.data, i)[0]
+                env.xt_literals[idx] = value
+                if value in env.lit_entries:
+                    # Deduplicate literals
+                    continue
+                env.lit_entries[value] = LiteralEntry(
+                    value, len(env.lit_entries) * env.arch.word_size
+                )
+
+
+def populate_got(env):
+    # Compute GOT destination addresses
+    for got_entry in env.got_entries.values():
+        sym = got_entry.sym
+        if hasattr(sym, "resolved"):
+            sym = sym.resolved
+        sec = sym.section
+        addr = sym["st_value"]
+        got_entry.sec_name = sec.name
+        got_entry.link_addr += sec.addr + addr
+
+    # Get sorted GOT, sorted by external, text, rodata, bss so relocations can be combined
+    got_list = sorted(
+        env.got_entries.values(),
+        key=lambda g: g.isexternal() + 2 * g.istext() + 3 * g.isrodata() + 4 * g.isbss(),
+    )
+
+    # Layout and populate the GOT
+    offset = 0
+    for got_entry in got_list:
+        got_entry.offset = offset
+        offset += env.arch.word_size
+        o = env.got_section.addr + got_entry.offset
+        env.full_text[o : o + env.arch.word_size] = got_entry.link_addr.to_bytes(
+            env.arch.word_size, "little"
+        )
+
+    # Create a relocation for each GOT entry
+    for got_entry in got_list:
+        if got_entry.name == "mp_fun_table":
+            dest = "mp_fun_table"
+        elif got_entry.name.startswith("mp_fun_table+0x"):
+            dest = int(got_entry.name.split("+")[1], 16) // env.arch.word_size
+        elif got_entry.sec_name.startswith(".text"):
+            dest = ".text"
+        elif got_entry.sec_name.startswith(".rodata"):
+            dest = ".rodata"
+        elif got_entry.sec_name.startswith(".data.rel.ro"):
+            dest = ".data.rel.ro"
+        elif got_entry.sec_name.startswith(".bss"):
+            dest = ".bss"
+        else:
+            assert 0, (got_entry.name, got_entry.sec_name)
+        env.mpy_relocs.append((".text", env.got_section.addr + got_entry.offset, dest))
+
+    # Print out the final GOT
+    log(LOG_LEVEL_2, "GOT: {:08x}".format(env.got_section.addr))
+    for g in got_list:
+        log(
+            LOG_LEVEL_2,
+            "  {:08x} {} -> {}+{:08x}".format(g.offset, g.name, g.sec_name, g.link_addr),
+        )
+
+
+def populate_lit(env):
+    log(LOG_LEVEL_2, "LIT: {:08x}".format(env.lit_section.addr))
+    for lit_entry in env.lit_entries.values():
+        value = lit_entry.value
+        log(LOG_LEVEL_2, "  {:08x} = {:08x}".format(lit_entry.offset, value))
+        o = env.lit_section.addr + lit_entry.offset
+        env.full_text[o : o + env.arch.word_size] = value.to_bytes(env.arch.word_size, "little")
+
+
+def do_relocation_text(env, text_addr, r):
+    # Extract relevant info about symbol that's being relocated
+    s = r.sym
+    s_bind = s.entry["st_info"]["bind"]
+    s_shndx = s.entry["st_shndx"]
+    s_type = s.entry["st_info"]["type"]
+    r_offset = r["r_offset"] + text_addr
+    r_info_type = r["r_info_type"]
+    try:
+        # only for RELA sections
+        r_addend = r["r_addend"]
+    except KeyError:
+        r_addend = 0
+
+    # Default relocation type and name for logging
+    reloc_type = "le32"
+    log_name = None
+
+    if (
+        env.arch.name == "EM_386"
+        and r_info_type in (R_386_PC32, R_386_PLT32)
+        or env.arch.name == "EM_X86_64"
+        and r_info_type in (R_X86_64_PC32, R_X86_64_PLT32)
+        or env.arch.name == "EM_ARM"
+        and r_info_type in (R_ARM_REL32, R_ARM_THM_CALL, R_ARM_THM_JUMP24)
+        or s_bind == "STB_LOCAL"
+        and env.arch.name == "EM_XTENSA"
+        and r_info_type == R_XTENSA_32  # not GOT
+    ):
+        # Standard relocation to fixed location within text/rodata
+        if hasattr(s, "resolved"):
+            s = s.resolved
+
+        sec = s.section
+
+        if env.arch.separate_rodata and sec.name.startswith(".rodata"):
+            raise LinkError("fixed relocation to rodata with rodata referenced via GOT")
+
+        if sec.name.startswith(".bss"):
+            raise LinkError(
+                "{}: fixed relocation to bss (bss variables can't be static)".format(s.filename)
+            )
+
+        if sec.name.startswith(".external"):
+            raise LinkError(
+                "{}: fixed relocation to external symbol: {}".format(s.filename, s.name)
+            )
+
+        addr = sec.addr + s["st_value"]
+        reloc = addr - r_offset + r_addend
+
+        if r_info_type in (R_ARM_THM_CALL, R_ARM_THM_JUMP24):
+            # Both relocations have the same bit pattern to rewrite:
+            #   R_ARM_THM_CALL: bl
+            #   R_ARM_THM_JUMP24: b.w
+            reloc_type = "thumb_b"
+
+    elif (
+        env.arch.name == "EM_386"
+        and r_info_type == R_386_GOTPC
+        or env.arch.name == "EM_ARM"
+        and r_info_type == R_ARM_BASE_PREL
+    ):
+        # Relocation to GOT address itself
+        assert s.name == "_GLOBAL_OFFSET_TABLE_"
+        addr = env.got_section.addr
+        reloc = addr - r_offset + r_addend
+
+    elif (
+        env.arch.name == "EM_386"
+        and r_info_type in (R_386_GOT32, R_386_GOT32X)
+        or env.arch.name == "EM_ARM"
+        and r_info_type == R_ARM_GOT_BREL
+    ):
+        # Relcation pointing to GOT
+        reloc = addr = env.got_entries[s.name].offset
+
+    elif env.arch.name == "EM_X86_64" and r_info_type == R_X86_64_REX_GOTPCRELX:
+        # Relcation pointing to GOT
+        got_entry = env.got_entries[s.name]
+        addr = env.got_section.addr + got_entry.offset
+        reloc = addr - r_offset + r_addend
+
+    elif env.arch.name == "EM_386" and r_info_type == R_386_GOTOFF:
+        # Relocation relative to GOT
+        addr = s.section.addr + s["st_value"]
+        reloc = addr - env.got_section.addr + r_addend
+
+    elif env.arch.name == "EM_XTENSA" and r_info_type == R_XTENSA_SLOT0_OP:
+        # Relocation pointing to GOT, xtensa specific
+        sec = s.section
+        if sec.name.startswith(".text"):
+            # it looks like R_XTENSA_SLOT0_OP into .text is already correctly relocated
+            return
+        assert sec.name.startswith(".literal"), sec.name
+        lit_idx = "{}+0x{:x}".format(sec.filename, r_addend)
+        lit_ptr = env.xt_literals[lit_idx]
+        if isinstance(lit_ptr, str):
+            addr = env.got_section.addr + env.got_entries[lit_ptr].offset
+            log_name = "GOT {}".format(lit_ptr)
+        else:
+            addr = env.lit_section.addr + env.lit_entries[lit_ptr].offset
+            log_name = "LIT"
+        reloc = addr - r_offset
+        reloc_type = "xtensa_l32r"
+
+    elif env.arch.name == "EM_XTENSA" and r_info_type == R_XTENSA_DIFF32:
+        if s.section.name.startswith(".text"):
+            # it looks like R_XTENSA_DIFF32 into .text is already correctly relocated
+            return
+        assert 0
+
+    else:
+        # Unknown/unsupported relocation
+        assert 0, r_info_type
+
+    # Write relocation
+    if reloc_type == "le32":
+        (existing,) = struct.unpack_from("<I", env.full_text, r_offset)
+        struct.pack_into("<I", env.full_text, r_offset, (existing + reloc) & 0xFFFFFFFF)
+    elif reloc_type == "thumb_b":
+        b_h, b_l = struct.unpack_from("<HH", env.full_text, r_offset)
+        existing = (b_h & 0x7FF) << 12 | (b_l & 0x7FF) << 1
+        if existing >= 0x400000:  # 2's complement
+            existing -= 0x800000
+        new = existing + reloc
+        b_h = (b_h & 0xF800) | (new >> 12) & 0x7FF
+        b_l = (b_l & 0xF800) | (new >> 1) & 0x7FF
+        struct.pack_into("<HH", env.full_text, r_offset, b_h, b_l)
+    elif reloc_type == "xtensa_l32r":
+        l32r = unpack_u24le(env.full_text, r_offset)
+        assert l32r & 0xF == 1  # RI16 encoded l32r
+        l32r_imm16 = l32r >> 8
+        l32r_imm16 = (l32r_imm16 + reloc >> 2) & 0xFFFF
+        l32r = l32r & 0xFF | l32r_imm16 << 8
+        pack_u24le(env.full_text, r_offset, l32r)
+    else:
+        assert 0, reloc_type
+
+    # Log information about relocation
+    if log_name is None:
+        if s_type == "STT_SECTION":
+            log_name = s.section.name
+        else:
+            log_name = s.name
+    log(LOG_LEVEL_3, "  {:08x} {} -> {:08x}".format(r_offset, log_name, addr))
+
+
+def do_relocation_data(env, text_addr, r):
+    s = r.sym
+    s_type = s.entry["st_info"]["type"]
+    r_offset = r["r_offset"] + text_addr
+    r_info_type = r["r_info_type"]
+    try:
+        # only for RELA sections
+        r_addend = r["r_addend"]
+    except KeyError:
+        r_addend = 0
+
+    if (
+        env.arch.name == "EM_386"
+        and r_info_type == R_386_32
+        or env.arch.name == "EM_X86_64"
+        and r_info_type == R_X86_64_64
+        or env.arch.name == "EM_ARM"
+        and r_info_type == R_ARM_ABS32
+        or env.arch.name == "EM_XTENSA"
+        and r_info_type == R_XTENSA_32
+    ):
+        # Relocation in data.rel.ro to internal/external symbol
+        if env.arch.word_size == 4:
+            struct_type = "<I"
+        elif env.arch.word_size == 8:
+            struct_type = "<Q"
+        sec = s.section
+        assert r_offset % env.arch.word_size == 0
+        addr = sec.addr + s["st_value"] + r_addend
+        if s_type == "STT_SECTION":
+            log_name = sec.name
+        else:
+            log_name = s.name
+        log(LOG_LEVEL_3, "  {:08x} -> {} {:08x}".format(r_offset, log_name, addr))
+        if env.arch.separate_rodata:
+            data = env.full_rodata
+        else:
+            data = env.full_text
+        (existing,) = struct.unpack_from(struct_type, data, r_offset)
+        if sec.name.startswith((".text", ".rodata", ".data.rel.ro", ".bss")):
+            struct.pack_into(struct_type, data, r_offset, existing + addr)
+            kind = sec.name
+        elif sec.name == ".external.mp_fun_table":
+            assert addr == 0
+            kind = s.mp_fun_table_offset
+        else:
+            assert 0, sec.name
+        if env.arch.separate_rodata:
+            base = ".rodata"
+        else:
+            base = ".text"
+        env.mpy_relocs.append((base, r_offset, kind))
+
+    else:
+        # Unknown/unsupported relocation
+        assert 0, r_info_type
+
+
+def load_object_file(env, felf):
+    with open(felf, "rb") as f:
+        elf = elffile.ELFFile(f)
+        env.check_arch(elf["e_machine"])
+
+        # Get symbol table
+        symtab = list(elf.get_section_by_name(".symtab").iter_symbols())
+
+        # Load needed sections from ELF file
+        sections_shndx = {}  # maps elf shndx to Section object
+        for idx, s in enumerate(elf.iter_sections()):
+            if s.header.sh_type in ("SHT_PROGBITS", "SHT_NOBITS"):
+                if s.data_size == 0:
+                    # Ignore empty sections
+                    pass
+                elif s.name.startswith((".literal", ".text", ".rodata", ".data.rel.ro", ".bss")):
+                    sec = Section.from_elfsec(s, felf)
+                    sections_shndx[idx] = sec
+                    if s.name.startswith(".literal"):
+                        env.literal_sections.append(sec)
+                    else:
+                        env.sections.append(sec)
+                elif s.name.startswith(".data"):
+                    raise LinkError("{}: {} non-empty".format(felf, s.name))
+                else:
+                    # Ignore section
+                    pass
+            elif s.header.sh_type in ("SHT_REL", "SHT_RELA"):
+                shndx = s.header.sh_info
+                if shndx in sections_shndx:
+                    sec = sections_shndx[shndx]
+                    sec.reloc_name = s.name
+                    sec.reloc = list(s.iter_relocations())
+                    for r in sec.reloc:
+                        r.sym = symtab[r["r_info_sym"]]
+
+        # Link symbols to their sections, and update known and unresolved symbols
+        for sym in symtab:
+            sym.filename = felf
+            shndx = sym.entry["st_shndx"]
+            if shndx in sections_shndx:
+                # Symbol with associated section
+                sym.section = sections_shndx[shndx]
+                if sym["st_info"]["bind"] == "STB_GLOBAL":
+                    # Defined global symbol
+                    if sym.name in env.known_syms and not sym.name.startswith(
+                        "__x86.get_pc_thunk."
+                    ):
+                        raise LinkError("duplicate symbol: {}".format(sym.name))
+                    env.known_syms[sym.name] = sym
+            elif sym.entry["st_shndx"] == "SHN_UNDEF" and sym["st_info"]["bind"] == "STB_GLOBAL":
+                # Undefined global symbol, needs resolving
+                env.unresolved_syms.append(sym)
+
+
+def link_objects(env, native_qstr_vals_len, native_qstr_objs_len):
+    # Build GOT information
+    if env.arch.name == "EM_XTENSA":
+        build_got_xtensa(env)
+    else:
+        build_got_generic(env)
+
+    # Creat GOT section
+    got_size = len(env.got_entries) * env.arch.word_size
+    env.got_section = Section("GOT", bytearray(got_size), env.arch.word_size)
+    if env.arch.name == "EM_XTENSA":
+        env.sections.insert(0, env.got_section)
+    else:
+        env.sections.append(env.got_section)
+
+    # Create optional literal section
+    if env.arch.name == "EM_XTENSA":
+        lit_size = len(env.lit_entries) * env.arch.word_size
+        env.lit_section = Section("LIT", bytearray(lit_size), env.arch.word_size)
+        env.sections.insert(1, env.lit_section)
+
+    # Create section to contain mp_native_qstr_val_table
+    env.qstr_val_section = Section(
+        ".text.QSTR_VAL",
+        bytearray(native_qstr_vals_len * env.arch.qstr_entry_size),
+        env.arch.qstr_entry_size,
+    )
+    env.sections.append(env.qstr_val_section)
+
+    # Create section to contain mp_native_qstr_obj_table
+    env.qstr_obj_section = Section(
+        ".text.QSTR_OBJ", bytearray(native_qstr_objs_len * env.arch.word_size), env.arch.word_size
+    )
+    env.sections.append(env.qstr_obj_section)
+
+    # Resolve unknown symbols
+    mp_fun_table_sec = Section(".external.mp_fun_table", b"", 0)
+    fun_table = {
+        key: 67 + idx
+        for idx, key in enumerate(
+            [
+                "mp_type_type",
+                "mp_type_str",
+                "mp_type_list",
+                "mp_type_dict",
+                "mp_type_fun_builtin_0",
+                "mp_type_fun_builtin_1",
+                "mp_type_fun_builtin_2",
+                "mp_type_fun_builtin_3",
+                "mp_type_fun_builtin_var",
+                "mp_stream_read_obj",
+                "mp_stream_readinto_obj",
+                "mp_stream_unbuffered_readline_obj",
+                "mp_stream_write_obj",
+            ]
+        )
+    }
+    for sym in env.unresolved_syms:
+        assert sym["st_value"] == 0
+        if sym.name == "_GLOBAL_OFFSET_TABLE_":
+            pass
+        elif sym.name == "mp_fun_table":
+            sym.section = Section(".external", b"", 0)
+        elif sym.name == "mp_native_qstr_val_table":
+            sym.section = env.qstr_val_section
+        elif sym.name == "mp_native_qstr_obj_table":
+            sym.section = env.qstr_obj_section
+        elif sym.name in env.known_syms:
+            sym.resolved = env.known_syms[sym.name]
+        else:
+            if sym.name in fun_table:
+                sym.section = mp_fun_table_sec
+                sym.mp_fun_table_offset = fun_table[sym.name]
+            else:
+                raise LinkError("{}: undefined symbol: {}".format(sym.filename, sym.name))
+
+    # Align sections, assign their addresses, and create full_text
+    env.full_text = bytearray(env.arch.asm_jump(8))  # dummy, to be filled in later
+    env.full_rodata = bytearray(0)
+    env.full_bss = bytearray(0)
+    for sec in env.sections:
+        if env.arch.separate_rodata and sec.name.startswith((".rodata", ".data.rel.ro")):
+            data = env.full_rodata
+        elif sec.name.startswith(".bss"):
+            data = env.full_bss
+        else:
+            data = env.full_text
+        sec.addr = align_to(len(data), sec.alignment)
+        data.extend(b"\x00" * (sec.addr - len(data)))
+        data.extend(sec.data)
+
+    env.print_sections()
+
+    populate_got(env)
+    if env.arch.name == "EM_XTENSA":
+        populate_lit(env)
+
+    # Fill in relocations
+    for sec in env.sections:
+        if not sec.reloc:
+            continue
+        log(
+            LOG_LEVEL_3,
+            "{}: {} relocations via {}:".format(sec.filename, sec.name, sec.reloc_name),
+        )
+        for r in sec.reloc:
+            if sec.name.startswith((".text", ".rodata")):
+                do_relocation_text(env, sec.addr, r)
+            elif sec.name.startswith(".data.rel.ro"):
+                do_relocation_data(env, sec.addr, r)
+            else:
+                assert 0, sec.name
+
+
+################################################################################
+# .mpy output
+
+
+class MPYOutput:
+    def open(self, fname):
+        self.f = open(fname, "wb")
+        self.prev_base = -1
+        self.prev_offset = -1
+
+    def close(self):
+        self.f.close()
+
+    def write_bytes(self, buf):
+        self.f.write(buf)
+
+    def write_uint(self, val):
+        b = bytearray()
+        b.insert(0, val & 0x7F)
+        val >>= 7
+        while val:
+            b.insert(0, 0x80 | (val & 0x7F))
+            val >>= 7
+        self.write_bytes(b)
+
+    def write_qstr(self, s):
+        if s in qstrutil.static_qstr_list:
+            self.write_bytes(bytes([0, qstrutil.static_qstr_list.index(s) + 1]))
+        else:
+            s = bytes(s, "ascii")
+            self.write_uint(len(s) << 1)
+            self.write_bytes(s)
+
+    def write_reloc(self, base, offset, dest, n):
+        need_offset = not (base == self.prev_base and offset == self.prev_offset + 1)
+        self.prev_offset = offset + n - 1
+        if dest <= 2:
+            dest = (dest << 1) | (n > 1)
+        else:
+            assert 6 <= dest <= 127
+            assert n == 1
+        dest = dest << 1 | need_offset
+        assert 0 <= dest <= 0xFE, dest
+        self.write_bytes(bytes([dest]))
+        if need_offset:
+            if base == ".text":
+                base = 0
+            elif base == ".rodata":
+                base = 1
+            self.write_uint(offset << 1 | base)
+        if n > 1:
+            self.write_uint(n)
+
+
+def build_mpy(env, entry_offset, fmpy, native_qstr_vals, native_qstr_objs):
+    # Write jump instruction to start of text
+    jump = env.arch.asm_jump(entry_offset)
+    env.full_text[: len(jump)] = jump
+
+    log(LOG_LEVEL_1, "arch:         {}".format(env.arch.name))
+    log(LOG_LEVEL_1, "text size:    {}".format(len(env.full_text)))
+    if len(env.full_rodata):
+        log(LOG_LEVEL_1, "rodata size:  {}".format(len(env.full_rodata)))
+    log(LOG_LEVEL_1, "bss size:     {}".format(len(env.full_bss)))
+    log(LOG_LEVEL_1, "GOT entries:  {}".format(len(env.got_entries)))
+
+    # xxd(env.full_text)
+
+    out = MPYOutput()
+    out.open(fmpy)
+
+    # MPY: header
+    out.write_bytes(
+        bytearray(
+            [ord("M"), MPY_VERSION, env.arch.mpy_feature, MP_SMALL_INT_BITS, QSTR_WINDOW_SIZE,]
+        )
+    )
+
+    # MPY: kind/len
+    out.write_uint(len(env.full_text) << 2 | (MP_CODE_NATIVE_VIPER - MP_CODE_BYTECODE))
+
+    # MPY: machine code
+    out.write_bytes(env.full_text)
+
+    # MPY: n_qstr_link (assumes little endian)
+    out.write_uint(len(native_qstr_vals) + len(native_qstr_objs))
+    for q in range(len(native_qstr_vals)):
+        off = env.qstr_val_section.addr + q * env.arch.qstr_entry_size
+        out.write_uint(off << 2)
+        out.write_qstr(native_qstr_vals[q])
+    for q in range(len(native_qstr_objs)):
+        off = env.qstr_obj_section.addr + q * env.arch.word_size
+        out.write_uint(off << 2 | 3)
+        out.write_qstr(native_qstr_objs[q])
+
+    # MPY: scope_flags
+    scope_flags = MP_SCOPE_FLAG_VIPERRELOC
+    if len(env.full_rodata):
+        scope_flags |= MP_SCOPE_FLAG_VIPERRODATA
+    if len(env.full_bss):
+        scope_flags |= MP_SCOPE_FLAG_VIPERBSS
+    out.write_uint(scope_flags)
+
+    # MPY: n_obj
+    out.write_uint(0)
+
+    # MPY: n_raw_code
+    out.write_uint(0)
+
+    # MPY: rodata and/or bss
+    if len(env.full_rodata):
+        rodata_const_table_idx = 1
+        out.write_uint(len(env.full_rodata))
+        out.write_bytes(env.full_rodata)
+    if len(env.full_bss):
+        bss_const_table_idx = bool(env.full_rodata) + 1
+        out.write_uint(len(env.full_bss))
+
+    # MPY: relocation information
+    prev_kind = None
+    for base, addr, kind in env.mpy_relocs:
+        if isinstance(kind, str) and kind.startswith(".text"):
+            kind = 0
+        elif kind in (".rodata", ".data.rel.ro"):
+            if env.arch.separate_rodata:
+                kind = rodata_const_table_idx
+            else:
+                kind = 0
+        elif isinstance(kind, str) and kind.startswith(".bss"):
+            kind = bss_const_table_idx
+        elif kind == "mp_fun_table":
+            kind = 6
+        else:
+            kind = 7 + kind
+        assert addr % env.arch.word_size == 0, addr
+        offset = addr // env.arch.word_size
+        if kind == prev_kind and base == prev_base and offset == prev_offset + 1:
+            prev_n += 1
+            prev_offset += 1
+        else:
+            if prev_kind is not None:
+                out.write_reloc(prev_base, prev_offset - prev_n + 1, prev_kind, prev_n)
+            prev_kind = kind
+            prev_base = base
+            prev_offset = offset
+            prev_n = 1
+    if prev_kind is not None:
+        out.write_reloc(prev_base, prev_offset - prev_n + 1, prev_kind, prev_n)
+
+    # MPY: sentinel for end of relocations
+    out.write_bytes(b"\xff")
+
+    out.close()
+
+
+################################################################################
+# main
+
+
+def do_preprocess(args):
+    if args.output is None:
+        assert args.files[0].endswith(".c")
+        args.output = args.files[0][:-1] + "config.h"
+    static_qstrs, qstr_vals, qstr_objs = extract_qstrs(args.files)
+    with open(args.output, "w") as f:
+        print(
+            "#include <stdint.h>\n"
+            "typedef uintptr_t mp_uint_t;\n"
+            "typedef intptr_t mp_int_t;\n"
+            "typedef uintptr_t mp_off_t;",
+            file=f,
+        )
+        for i, q in enumerate(static_qstrs):
+            print("#define %s (%u)" % (q, i + 1), file=f)
+        for i, q in enumerate(sorted(qstr_vals)):
+            print("#define %s (mp_native_qstr_val_table[%d])" % (q, i), file=f)
+        for i, q in enumerate(sorted(qstr_objs)):
+            print(
+                "#define MP_OBJ_NEW_QSTR_%s ((mp_obj_t)mp_native_qstr_obj_table[%d])" % (q, i),
+                file=f,
+            )
+        if args.arch == "xtensawin":
+            qstr_type = "uint32_t"  # esp32 can only read 32-bit values from IRAM
+        else:
+            qstr_type = "uint16_t"
+        print("extern const {} mp_native_qstr_val_table[];".format(qstr_type), file=f)
+        print("extern const mp_uint_t mp_native_qstr_obj_table[];", file=f)
+
+
+def do_link(args):
+    if args.output is None:
+        assert args.files[0].endswith(".o")
+        args.output = args.files[0][:-1] + "mpy"
+    native_qstr_vals = []
+    native_qstr_objs = []
+    if args.qstrs is not None:
+        with open(args.qstrs) as f:
+            for l in f:
+                m = re.match(r"#define MP_QSTR_([A-Za-z0-9_]*) \(mp_native_", l)
+                if m:
+                    native_qstr_vals.append(m.group(1))
+                else:
+                    m = re.match(r"#define MP_OBJ_NEW_QSTR_MP_QSTR_([A-Za-z0-9_]*)", l)
+                    if m:
+                        native_qstr_objs.append(m.group(1))
+    log(LOG_LEVEL_2, "qstr vals: " + ", ".join(native_qstr_vals))
+    log(LOG_LEVEL_2, "qstr objs: " + ", ".join(native_qstr_objs))
+    env = LinkEnv(args.arch)
+    try:
+        for file in args.files:
+            load_object_file(env, file)
+        link_objects(env, len(native_qstr_vals), len(native_qstr_objs))
+        build_mpy(env, env.find_addr("mpy_init"), args.output, native_qstr_vals, native_qstr_objs)
+    except LinkError as er:
+        print("LinkError:", er.args[0])
+        sys.exit(1)
+
+
+def main():
+    import argparse
+
+    cmd_parser = argparse.ArgumentParser(description="Run scripts on the pyboard.")
+    cmd_parser.add_argument(
+        "--verbose", "-v", action="count", default=1, help="increase verbosity"
+    )
+    cmd_parser.add_argument("--arch", default="x64", help="architecture")
+    cmd_parser.add_argument("--preprocess", action="store_true", help="preprocess source files")
+    cmd_parser.add_argument("--qstrs", default=None, help="file defining additional qstrs")
+    cmd_parser.add_argument(
+        "--output", "-o", default=None, help="output .mpy file (default to input with .o->.mpy)"
+    )
+    cmd_parser.add_argument("files", nargs="+", help="input files")
+    args = cmd_parser.parse_args()
+
+    global log_level
+    log_level = args.verbose
+
+    if args.preprocess:
+        do_preprocess(args)
+    else:
+        do_link(args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/pyboard.py b/tools/pyboard.py
index 42b077de2240e..6376b13c7e333 100755
--- a/tools/pyboard.py
+++ b/tools/pyboard.py
@@ -1,10 +1,10 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # This file is part of the MicroPython project, http://micropython.org/
 #
 # The MIT License (MIT)
 #
-# Copyright (c) 2014-2016 Damien P. George
+# Copyright (c) 2014-2019 Damien P. George
 # Copyright (c) 2017 Paul Sokolovsky
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -77,35 +77,42 @@
     # Python2 doesn't have buffer attr
     stdout = sys.stdout
 
+
 def stdout_write_bytes(b):
     b = b.replace(b"\x04", b"")
     stdout.write(b)
     stdout.flush()
 
+
 class PyboardError(Exception):
     pass
 
+
 class TelnetToSerial:
     def __init__(self, ip, user, password, read_timeout=None):
         self.tn = None
         import telnetlib
+
         self.tn = telnetlib.Telnet(ip, timeout=15)
         self.read_timeout = read_timeout
-        if b'Login as:' in self.tn.read_until(b'Login as:', timeout=read_timeout):
-            self.tn.write(bytes(user, 'ascii') + b"\r\n")
+        if b"Login as:" in self.tn.read_until(b"Login as:", timeout=read_timeout):
+            self.tn.write(bytes(user, "ascii") + b"\r\n")
 
-            if b'Password:' in self.tn.read_until(b'Password:', timeout=read_timeout):
+            if b"Password:" in self.tn.read_until(b"Password:", timeout=read_timeout):
                 # needed because of internal implementation details of the telnet server
                 time.sleep(0.2)
-                self.tn.write(bytes(password, 'ascii') + b"\r\n")
+                self.tn.write(bytes(password, "ascii") + b"\r\n")
 
-                if b'for more information.' in self.tn.read_until(b'Type "help()" for more information.', timeout=read_timeout):
+                if b"for more information." in self.tn.read_until(
+                    b'Type "help()" for more information.', timeout=read_timeout
+                ):
                     # login successful
                     from collections import deque
+
                     self.fifo = deque()
                     return
 
-        raise PyboardError('Failed to establish a telnet connection with the board')
+        raise PyboardError("Failed to establish a telnet connection with the board")
 
     def __del__(self):
         self.close()
@@ -127,7 +134,7 @@ def read(self, size=1):
                     break
                 timeout_count += 1
 
-        data = b''
+        data = b""
         while len(data) < size and len(self.fifo) > 0:
             data += bytes([self.fifo.popleft()])
         return data
@@ -151,24 +158,33 @@ class ProcessToSerial:
 
     def __init__(self, cmd):
         import subprocess
-        self.subp = subprocess.Popen(cmd, bufsize=0, shell=True, preexec_fn=os.setsid,
-            stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+
+        self.subp = subprocess.Popen(
+            cmd,
+            bufsize=0,
+            shell=True,
+            preexec_fn=os.setsid,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+        )
 
         # Initially was implemented with selectors, but that adds Python3
         # dependency. However, there can be race conditions communicating
         # with a particular child process (like QEMU), and selectors may
         # still work better in that case, so left inplace for now.
         #
-        #import selectors
-        #self.sel = selectors.DefaultSelector()
-        #self.sel.register(self.subp.stdout, selectors.EVENT_READ)
+        # import selectors
+        # self.sel = selectors.DefaultSelector()
+        # self.sel.register(self.subp.stdout, selectors.EVENT_READ)
 
         import select
+
         self.poll = select.poll()
         self.poll.register(self.subp.stdout.fileno())
 
     def close(self):
         import signal
+
         os.killpg(os.getpgid(self.subp.pid), signal.SIGTERM)
 
     def read(self, size=1):
@@ -182,7 +198,7 @@ def write(self, data):
         return len(data)
 
     def inWaiting(self):
-        #res = self.sel.select(0)
+        # res = self.sel.select(0)
         res = self.poll.poll(0)
         if res:
             return 1
@@ -198,8 +214,16 @@ def __init__(self, cmd):
         import subprocess
         import re
         import serial
-        self.subp = subprocess.Popen(cmd.split(), bufsize=0, shell=False, preexec_fn=os.setsid,
-            stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        self.subp = subprocess.Popen(
+            cmd.split(),
+            bufsize=0,
+            shell=False,
+            preexec_fn=os.setsid,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
         pty_line = self.subp.stderr.readline().decode("utf-8")
         m = re.search(r"/dev/pts/[0-9]+", pty_line)
         if not m:
@@ -213,6 +237,7 @@ def __init__(self, cmd):
 
     def close(self):
         import signal
+
         os.killpg(os.getpgid(self.subp.pid), signal.SIGTERM)
 
     def read(self, size=1):
@@ -226,41 +251,45 @@ def inWaiting(self):
 
 
 class Pyboard:
-    def __init__(self, device, baudrate=115200, user='micro', password='python', wait=0):
+    def __init__(self, device, baudrate=115200, user="micro", password="python", wait=0):
         if device.startswith("exec:"):
-            self.serial = ProcessToSerial(device[len("exec:"):])
+            self.serial = ProcessToSerial(device[len("exec:") :])
         elif device.startswith("execpty:"):
-            self.serial = ProcessPtyToTerminal(device[len("qemupty:"):])
-        elif device and device[0].isdigit() and device[-1].isdigit() and device.count('.') == 3:
+            self.serial = ProcessPtyToTerminal(device[len("qemupty:") :])
+        elif device and device[0].isdigit() and device[-1].isdigit() and device.count(".") == 3:
             # device looks like an IP address
             self.serial = TelnetToSerial(device, user, password, read_timeout=10)
         else:
             import serial
+
             delayed = False
             for attempt in range(wait + 1):
                 try:
                     self.serial = serial.Serial(device, baudrate=baudrate, interCharTimeout=1)
                     break
-                except (OSError, IOError): # Py2 and Py3 have different errors
+                except (OSError, IOError):  # Py2 and Py3 have different errors
                     if wait == 0:
                         continue
                     if attempt == 0:
-                        sys.stdout.write('Waiting {} seconds for pyboard '.format(wait))
+                        sys.stdout.write("Waiting {} seconds for pyboard ".format(wait))
                         delayed = True
                 time.sleep(1)
-                sys.stdout.write('.')
+                sys.stdout.write(".")
                 sys.stdout.flush()
             else:
                 if delayed:
-                    print('')
-                raise PyboardError('failed to access ' + device)
+                    print("")
+                raise PyboardError("failed to access " + device)
             if delayed:
-                print('')
+                print("")
 
     def close(self):
         self.serial.close()
 
     def read_until(self, min_num_bytes, ending, timeout=10, data_consumer=None):
+        # if data_consumer is used then data is not accumulated and the ending must be 1 byte long
+        assert data_consumer is None or len(ending) == 1
+
         data = self.serial.read(min_num_bytes)
         if data_consumer:
             data_consumer(data)
@@ -270,9 +299,11 @@ def read_until(self, min_num_bytes, ending, timeout=10, data_consumer=None):
                 break
             elif self.serial.inWaiting() > 0:
                 new_data = self.serial.read(1)
-                data = data + new_data
                 if data_consumer:
                     data_consumer(new_data)
+                    data = new_data
+                else:
+                    data = data + new_data
                 timeout_count = 0
             else:
                 timeout_count += 1
@@ -282,7 +313,7 @@ def read_until(self, min_num_bytes, ending, timeout=10, data_consumer=None):
         return data
 
     def enter_raw_repl(self):
-        self.serial.write(b'\r\x03\x03') # ctrl-C twice: interrupt any running program
+        self.serial.write(b"\r\x03\x03")  # ctrl-C twice: interrupt any running program
 
         # flush input (without relying on serial.flushInput())
         n = self.serial.inWaiting()
@@ -290,38 +321,38 @@ def enter_raw_repl(self):
             self.serial.read(n)
             n = self.serial.inWaiting()
 
-        self.serial.write(b'\r\x01') # ctrl-A: enter raw REPL
-        data = self.read_until(1, b'raw REPL; CTRL-B to exit\r\n>')
-        if not data.endswith(b'raw REPL; CTRL-B to exit\r\n>'):
+        self.serial.write(b"\r\x01")  # ctrl-A: enter raw REPL
+        data = self.read_until(1, b"raw REPL; CTRL-B to exit\r\n>")
+        if not data.endswith(b"raw REPL; CTRL-B to exit\r\n>"):
             print(data)
-            raise PyboardError('could not enter raw repl')
+            raise PyboardError("could not enter raw repl")
 
-        self.serial.write(b'\x04') # ctrl-D: soft reset
-        data = self.read_until(1, b'soft reboot\r\n')
-        if not data.endswith(b'soft reboot\r\n'):
+        self.serial.write(b"\x04")  # ctrl-D: soft reset
+        data = self.read_until(1, b"soft reboot\r\n")
+        if not data.endswith(b"soft reboot\r\n"):
             print(data)
-            raise PyboardError('could not enter raw repl')
+            raise PyboardError("could not enter raw repl")
         # By splitting this into 2 reads, it allows boot.py to print stuff,
         # which will show up after the soft reboot and before the raw REPL.
-        data = self.read_until(1, b'raw REPL; CTRL-B to exit\r\n')
-        if not data.endswith(b'raw REPL; CTRL-B to exit\r\n'):
+        data = self.read_until(1, b"raw REPL; CTRL-B to exit\r\n")
+        if not data.endswith(b"raw REPL; CTRL-B to exit\r\n"):
             print(data)
-            raise PyboardError('could not enter raw repl')
+            raise PyboardError("could not enter raw repl")
 
     def exit_raw_repl(self):
-        self.serial.write(b'\r\x02') # ctrl-B: enter friendly REPL
+        self.serial.write(b"\r\x02")  # ctrl-B: enter friendly REPL
 
     def follow(self, timeout, data_consumer=None):
         # wait for normal output
-        data = self.read_until(1, b'\x04', timeout=timeout, data_consumer=data_consumer)
-        if not data.endswith(b'\x04'):
-            raise PyboardError('timeout waiting for first EOF reception')
+        data = self.read_until(1, b"\x04", timeout=timeout, data_consumer=data_consumer)
+        if not data.endswith(b"\x04"):
+            raise PyboardError("timeout waiting for first EOF reception")
         data = data[:-1]
 
         # wait for error output
-        data_err = self.read_until(1, b'\x04', timeout=timeout)
-        if not data_err.endswith(b'\x04'):
-            raise PyboardError('timeout waiting for second EOF reception')
+        data_err = self.read_until(1, b"\x04", timeout=timeout)
+        if not data_err.endswith(b"\x04"):
+            raise PyboardError("timeout waiting for second EOF reception")
         data_err = data_err[:-1]
 
         # return normal and error output
@@ -331,53 +362,105 @@ def exec_raw_no_follow(self, command):
         if isinstance(command, bytes):
             command_bytes = command
         else:
-            command_bytes = bytes(command, encoding='utf8')
+            command_bytes = bytes(command, encoding="utf8")
 
         # check we have a prompt
-        data = self.read_until(1, b'>')
-        if not data.endswith(b'>'):
-            raise PyboardError('could not enter raw repl')
+        data = self.read_until(1, b">")
+        if not data.endswith(b">"):
+            raise PyboardError("could not enter raw repl")
 
         # write command
         for i in range(0, len(command_bytes), 256):
-            self.serial.write(command_bytes[i:min(i + 256, len(command_bytes))])
+            self.serial.write(command_bytes[i : min(i + 256, len(command_bytes))])
             time.sleep(0.01)
-        self.serial.write(b'\x04')
+        self.serial.write(b"\x04")
 
         # check if we could exec command
         data = self.serial.read(2)
-        if data != b'OK':
-            raise PyboardError('could not exec command (response: %r)' % data)
+        if data != b"OK":
+            raise PyboardError("could not exec command (response: %r)" % data)
 
     def exec_raw(self, command, timeout=10, data_consumer=None):
-        self.exec_raw_no_follow(command);
+        self.exec_raw_no_follow(command)
         return self.follow(timeout, data_consumer)
 
     def eval(self, expression):
-        ret = self.exec_('print({})'.format(expression))
+        ret = self.exec_("print({})".format(expression))
         ret = ret.strip()
         return ret
 
-    def exec_(self, command):
-        ret, ret_err = self.exec_raw(command)
+    def exec_(self, command, data_consumer=None):
+        ret, ret_err = self.exec_raw(command, data_consumer=data_consumer)
         if ret_err:
-            raise PyboardError('exception', ret, ret_err)
+            raise PyboardError("exception", ret, ret_err)
         return ret
 
     def execfile(self, filename):
-        with open(filename, 'rb') as f:
+        with open(filename, "rb") as f:
             pyfile = f.read()
         return self.exec_(pyfile)
 
     def get_time(self):
-        t = str(self.eval('pyb.RTC().datetime()'), encoding='utf8')[1:-1].split(', ')
+        t = str(self.eval("pyb.RTC().datetime()"), encoding="utf8")[1:-1].split(", ")
         return int(t[4]) * 3600 + int(t[5]) * 60 + int(t[6])
 
+    def fs_ls(self, src):
+        cmd = (
+            "import uos\nfor f in uos.ilistdir(%s):\n"
+            " print('{:12} {}{}'.format(f[3]if len(f)>3 else 0,f[0],'/'if f[1]&0x4000 else ''))"
+            % (("'%s'" % src) if src else "")
+        )
+        self.exec_(cmd, data_consumer=stdout_write_bytes)
+
+    def fs_cat(self, src, chunk_size=256):
+        cmd = (
+            "with open('%s') as f:\n while 1:\n"
+            "  b=f.read(%u)\n  if not b:break\n  print(b,end='')" % (src, chunk_size)
+        )
+        self.exec_(cmd, data_consumer=stdout_write_bytes)
+
+    def fs_get(self, src, dest, chunk_size=256):
+        self.exec_("f=open('%s','rb')\nr=f.read" % src)
+        with open(dest, "wb") as f:
+            while True:
+                data = bytearray()
+                self.exec_("print(r(%u))" % chunk_size, data_consumer=lambda d: data.extend(d))
+                assert data.endswith(b"\r\n\x04")
+                data = eval(str(data[:-3], "ascii"))
+                if not data:
+                    break
+                f.write(data)
+        self.exec_("f.close()")
+
+    def fs_put(self, src, dest, chunk_size=256):
+        self.exec_("f=open('%s','wb')\nw=f.write" % dest)
+        with open(src, "rb") as f:
+            while True:
+                data = f.read(chunk_size)
+                if not data:
+                    break
+                if sys.version_info < (3,):
+                    self.exec_("w(b" + repr(data) + ")")
+                else:
+                    self.exec_("w(" + repr(data) + ")")
+        self.exec_("f.close()")
+
+    def fs_mkdir(self, dir):
+        self.exec_("import uos\nuos.mkdir('%s')" % dir)
+
+    def fs_rmdir(self, dir):
+        self.exec_("import uos\nuos.rmdir('%s')" % dir)
+
+    def fs_rm(self, src):
+        self.exec_("import uos\nuos.remove('%s')" % src)
+
+
 # in Python2 exec is a keyword so one must use "exec_"
 # but for Python3 we want to provide the nicer version "exec"
 setattr(Pyboard, "exec", Pyboard.exec_)
 
-def execfile(filename, device='/dev/ttyACM0', baudrate=115200, user='micro', password='python'):
+
+def execfile(filename, device="/dev/ttyACM0", baudrate=115200, user="micro", password="python"):
     pyb = Pyboard(device, baudrate, user, password)
     pyb.enter_raw_repl()
     output = pyb.execfile(filename)
@@ -385,17 +468,131 @@ def execfile(filename, device='/dev/ttyACM0', baudrate=115200, user='micro', pas
     pyb.exit_raw_repl()
     pyb.close()
 
+
+def filesystem_command(pyb, args):
+    def fname_remote(src):
+        if src.startswith(":"):
+            src = src[1:]
+        return src
+
+    def fname_cp_dest(src, dest):
+        src = src.rsplit("/", 1)[-1]
+        if dest is None or dest == "":
+            dest = src
+        elif dest == ".":
+            dest = "./" + src
+        elif dest.endswith("/"):
+            dest += src
+        return dest
+
+    cmd = args[0]
+    args = args[1:]
+    try:
+        if cmd == "cp":
+            srcs = args[:-1]
+            dest = args[-1]
+            if srcs[0].startswith("./") or dest.startswith(":"):
+                op = pyb.fs_put
+                fmt = "cp %s :%s"
+                dest = fname_remote(dest)
+            else:
+                op = pyb.fs_get
+                fmt = "cp :%s %s"
+            for src in srcs:
+                src = fname_remote(src)
+                dest2 = fname_cp_dest(src, dest)
+                print(fmt % (src, dest2))
+                op(src, dest2)
+        else:
+            op = {
+                "ls": pyb.fs_ls,
+                "cat": pyb.fs_cat,
+                "mkdir": pyb.fs_mkdir,
+                "rmdir": pyb.fs_rmdir,
+                "rm": pyb.fs_rm,
+            }[cmd]
+            if cmd == "ls" and not args:
+                args = [""]
+            for src in args:
+                src = fname_remote(src)
+                print("%s :%s" % (cmd, src))
+                op(src)
+    except PyboardError as er:
+        print(str(er.args[2], "ascii"))
+        pyb.exit_raw_repl()
+        pyb.close()
+        sys.exit(1)
+
+
+_injected_import_hook_code = """\
+import uos, uio
+class _FS:
+  class File(uio.IOBase):
+    def __init__(self):
+      self.off = 0
+    def ioctl(self, request, arg):
+      return 0
+    def readinto(self, buf):
+      buf[:] = memoryview(_injected_buf)[self.off:self.off + len(buf)]
+      self.off += len(buf)
+      return len(buf)
+  mount = umount = chdir = lambda *args: None
+  def stat(self, path):
+    if path == '_injected.mpy':
+      return tuple(0 for _ in range(10))
+    else:
+      raise OSError(-2) # ENOENT
+  def open(self, path, mode):
+    return self.File()
+uos.mount(_FS(), '/_')
+uos.chdir('/_')
+from _injected import *
+uos.umount('/_')
+del _injected_buf, _FS
+"""
+
+
 def main():
     import argparse
-    cmd_parser = argparse.ArgumentParser(description='Run scripts on the pyboard.')
-    cmd_parser.add_argument('--device', default='/dev/ttyACM0', help='the serial device or the IP address of the pyboard')
-    cmd_parser.add_argument('-b', '--baudrate', default=115200, help='the baud rate of the serial device')
-    cmd_parser.add_argument('-u', '--user', default='micro', help='the telnet login username')
-    cmd_parser.add_argument('-p', '--password', default='python', help='the telnet login password')
-    cmd_parser.add_argument('-c', '--command', help='program passed in as string')
-    cmd_parser.add_argument('-w', '--wait', default=0, type=int, help='seconds to wait for USB connected board to become available')
-    cmd_parser.add_argument('--follow', action='store_true', help='follow the output after running the scripts [default if no scripts given]')
-    cmd_parser.add_argument('files', nargs='*', help='input files')
+
+    cmd_parser = argparse.ArgumentParser(description="Run scripts on the pyboard.")
+    cmd_parser.add_argument(
+        "-d",
+        "--device",
+        default=os.environ.get("PYBOARD_DEVICE", "/dev/ttyACM0"),
+        help="the serial device or the IP address of the pyboard",
+    )
+    cmd_parser.add_argument(
+        "-b",
+        "--baudrate",
+        default=os.environ.get("PYBOARD_BAUDRATE", "115200"),
+        help="the baud rate of the serial device",
+    )
+    cmd_parser.add_argument("-u", "--user", default="micro", help="the telnet login username")
+    cmd_parser.add_argument("-p", "--password", default="python", help="the telnet login password")
+    cmd_parser.add_argument("-c", "--command", help="program passed in as string")
+    cmd_parser.add_argument(
+        "-w",
+        "--wait",
+        default=0,
+        type=int,
+        help="seconds to wait for USB connected board to become available",
+    )
+    group = cmd_parser.add_mutually_exclusive_group()
+    group.add_argument(
+        "--follow",
+        action="store_true",
+        help="follow the output after running the scripts [default if no scripts given]",
+    )
+    group.add_argument(
+        "--no-follow",
+        action="store_true",
+        help="Do not follow the output after running the scripts.",
+    )
+    cmd_parser.add_argument(
+        "-f", "--filesystem", action="store_true", help="perform a filesystem action"
+    )
+    cmd_parser.add_argument("files", nargs="*", help="input files")
     args = cmd_parser.parse_args()
 
     # open the connection to the pyboard
@@ -406,7 +603,7 @@ def main():
         sys.exit(1)
 
     # run any command or file(s)
-    if args.command is not None or len(args.files):
+    if args.command is not None or args.filesystem or len(args.files):
         # we must enter raw-REPL mode to execute commands
         # this will do a soft-reset of the board
         try:
@@ -418,7 +615,13 @@ def main():
 
         def execbuffer(buf):
             try:
-                ret, ret_err = pyb.exec_raw(buf, timeout=None, data_consumer=stdout_write_bytes)
+                if args.no_follow:
+                    pyb.exec_raw_no_follow(buf)
+                    ret_err = None
+                else:
+                    ret, ret_err = pyb.exec_raw(
+                        buf, timeout=None, data_consumer=stdout_write_bytes
+                    )
             except PyboardError as er:
                 print(er)
                 pyb.close()
@@ -431,21 +634,29 @@ def execbuffer(buf):
                 stdout_write_bytes(ret_err)
                 sys.exit(1)
 
+        # do filesystem commands, if given
+        if args.filesystem:
+            filesystem_command(pyb, args.files)
+            del args.files[:]
+
         # run the command, if given
         if args.command is not None:
-            execbuffer(args.command.encode('utf-8'))
+            execbuffer(args.command.encode("utf-8"))
 
         # run any files
         for filename in args.files:
-            with open(filename, 'rb') as f:
+            with open(filename, "rb") as f:
                 pyfile = f.read()
+                if filename.endswith(".mpy") and pyfile[0] == ord("M"):
+                    pyb.exec_("_injected_buf=" + repr(pyfile))
+                    pyfile = _injected_import_hook_code
                 execbuffer(pyfile)
 
         # exiting raw-REPL just drops to friendly-REPL mode
         pyb.exit_raw_repl()
 
     # if asked explicitly, or no files given, then follow the output
-    if args.follow or (args.command is None and len(args.files) == 0):
+    if args.follow or (args.command is None and not args.filesystem and len(args.files) == 0):
         try:
             ret, ret_err = pyb.follow(timeout=None, data_consumer=stdout_write_bytes)
         except PyboardError as er:
@@ -461,5 +672,6 @@ def execbuffer(buf):
     # close the connection to the pyboard
     pyb.close()
 
+
 if __name__ == "__main__":
     main()
diff --git a/tools/pydfu.py b/tools/pydfu.py
index 658ce59ae69ac..030f56bf852e3 100755
--- a/tools/pydfu.py
+++ b/tools/pydfu.py
@@ -15,6 +15,7 @@
 
 import argparse
 import collections
+import inspect
 import re
 import struct
 import sys
@@ -24,35 +25,48 @@
 
 # VID/PID
 __VID = 0x0483
-__PID = 0xdf11
+__PID = 0xDF11
 
 # USB request __TIMEOUT
 __TIMEOUT = 4000
 
 # DFU commands
-__DFU_DETACH    = 0
-__DFU_DNLOAD    = 1
-__DFU_UPLOAD    = 2
+__DFU_DETACH = 0
+__DFU_DNLOAD = 1
+__DFU_UPLOAD = 2
 __DFU_GETSTATUS = 3
 __DFU_CLRSTATUS = 4
-__DFU_GETSTATE  = 5
-__DFU_ABORT     = 6
+__DFU_GETSTATE = 5
+__DFU_ABORT = 6
 
 # DFU status
-__DFU_STATE_APP_IDLE                 = 0x00
-__DFU_STATE_APP_DETACH               = 0x01
-__DFU_STATE_DFU_IDLE                 = 0x02
-__DFU_STATE_DFU_DOWNLOAD_SYNC        = 0x03
-__DFU_STATE_DFU_DOWNLOAD_BUSY        = 0x04
-__DFU_STATE_DFU_DOWNLOAD_IDLE        = 0x05
-__DFU_STATE_DFU_MANIFEST_SYNC        = 0x06
-__DFU_STATE_DFU_MANIFEST             = 0x07
-__DFU_STATE_DFU_MANIFEST_WAIT_RESET  = 0x08
-__DFU_STATE_DFU_UPLOAD_IDLE          = 0x09
-__DFU_STATE_DFU_ERROR                = 0x0a
-
-_DFU_DESCRIPTOR_TYPE                 = 0x21
-
+__DFU_STATE_APP_IDLE = 0x00
+__DFU_STATE_APP_DETACH = 0x01
+__DFU_STATE_DFU_IDLE = 0x02
+__DFU_STATE_DFU_DOWNLOAD_SYNC = 0x03
+__DFU_STATE_DFU_DOWNLOAD_BUSY = 0x04
+__DFU_STATE_DFU_DOWNLOAD_IDLE = 0x05
+__DFU_STATE_DFU_MANIFEST_SYNC = 0x06
+__DFU_STATE_DFU_MANIFEST = 0x07
+__DFU_STATE_DFU_MANIFEST_WAIT_RESET = 0x08
+__DFU_STATE_DFU_UPLOAD_IDLE = 0x09
+__DFU_STATE_DFU_ERROR = 0x0A
+
+_DFU_DESCRIPTOR_TYPE = 0x21
+
+__DFU_STATUS_STR = {
+    __DFU_STATE_APP_IDLE: "STATE_APP_IDLE",
+    __DFU_STATE_APP_DETACH: "STATE_APP_DETACH",
+    __DFU_STATE_DFU_IDLE: "STATE_DFU_IDLE",
+    __DFU_STATE_DFU_DOWNLOAD_SYNC: "STATE_DFU_DOWNLOAD_SYNC",
+    __DFU_STATE_DFU_DOWNLOAD_BUSY: "STATE_DFU_DOWNLOAD_BUSY",
+    __DFU_STATE_DFU_DOWNLOAD_IDLE: "STATE_DFU_DOWNLOAD_IDLE",
+    __DFU_STATE_DFU_MANIFEST_SYNC: "STATE_DFU_MANIFEST_SYNC",
+    __DFU_STATE_DFU_MANIFEST: "STATE_DFU_MANIFEST",
+    __DFU_STATE_DFU_MANIFEST_WAIT_RESET: "STATE_DFU_MANIFEST_WAIT_RESET",
+    __DFU_STATE_DFU_UPLOAD_IDLE: "STATE_DFU_UPLOAD_IDLE",
+    __DFU_STATE_DFU_ERROR: "STATE_DFU_ERROR",
+}
 
 # USB device handle
 __dev = None
@@ -67,13 +81,14 @@
 
 # Python 3 deprecated getargspec in favour of getfullargspec, but
 # Python 2 doesn't have the latter, so detect which one to use
-import inspect
-getargspec = getattr(inspect, 'getfullargspec', inspect.getargspec)
+getargspec = getattr(inspect, "getfullargspec", inspect.getargspec)
 
-if 'length' in getargspec(usb.util.get_string).args:
+if "length" in getargspec(usb.util.get_string).args:
     # PyUSB 1.0.0.b1 has the length argument
     def get_string(dev, index):
         return usb.util.get_string(dev, 255, index)
+
+
 else:
     # PyUSB 1.0.0.b2 dropped the length argument
     def get_string(dev, index):
@@ -82,10 +97,18 @@ def get_string(dev, index):
 
 def find_dfu_cfg_descr(descr):
     if len(descr) == 9 and descr[0] == 9 and descr[1] == _DFU_DESCRIPTOR_TYPE:
-        nt = collections.namedtuple('CfgDescr',
-            ['bLength', 'bDescriptorType', 'bmAttributes',
-            'wDetachTimeOut', 'wTransferSize', 'bcdDFUVersion'])
-        return nt(*struct.unpack('<BBBHHH', bytearray(descr)))
+        nt = collections.namedtuple(
+            "CfgDescr",
+            [
+                "bLength",
+                "bDescriptorType",
+                "bmAttributes",
+                "wDetachTimeOut",
+                "wTransferSize",
+                "bcdDFUVersion",
+            ],
+        )
+        return nt(*struct.unpack("<BBBHHH", bytearray(descr)))
     return None
 
 
@@ -94,7 +117,7 @@ def init():
     global __dev, __cfg_descr
     devices = get_dfu_devices(idVendor=__VID, idProduct=__PID)
     if not devices:
-        raise ValueError('No DFU device found')
+        raise ValueError("No DFU device found")
     if len(devices) > 1:
         raise ValueError("Multiple DFU devices found")
     __dev = devices[0]
@@ -119,8 +142,7 @@ def init():
         status = get_status()
         if status == __DFU_STATE_DFU_IDLE:
             break
-        elif (status == __DFU_STATE_DFU_DOWNLOAD_IDLE
-            or status == __DFU_STATE_DFU_UPLOAD_IDLE):
+        elif status == __DFU_STATE_DFU_DOWNLOAD_IDLE or status == __DFU_STATE_DFU_UPLOAD_IDLE:
             abort_request()
         else:
             clr_status()
@@ -133,31 +155,38 @@ def abort_request():
 
 def clr_status():
     """Clears any error status (perhaps left over from a previous session)."""
-    __dev.ctrl_transfer(0x21, __DFU_CLRSTATUS, 0, __DFU_INTERFACE,
-                        None, __TIMEOUT)
+    __dev.ctrl_transfer(0x21, __DFU_CLRSTATUS, 0, __DFU_INTERFACE, None, __TIMEOUT)
 
 
 def get_status():
     """Get the status of the last operation."""
-    stat = __dev.ctrl_transfer(0xA1, __DFU_GETSTATUS, 0, __DFU_INTERFACE,
-                               6, 20000)
-    # print (__DFU_STAT[stat[4]], stat)
+    stat = __dev.ctrl_transfer(0xA1, __DFU_GETSTATUS, 0, __DFU_INTERFACE, 6, 20000)
+
+    # firmware can provide an optional string for any error
+    if stat[5]:
+        message = get_string(__dev, stat[5])
+        if message:
+            print(message)
+
     return stat[4]
 
 
+def check_status(stage, expected):
+    status = get_status()
+    if status != expected:
+        raise SystemExit("DFU: %s failed (%s)" % (stage, __DFU_STATUS_STR.get(status, status)))
+
+
 def mass_erase():
-    """Performs a MASS erase (i.e. erases the entire device."""
+    """Performs a MASS erase (i.e. erases the entire device)."""
     # Send DNLOAD with first byte=0x41
-    __dev.ctrl_transfer(0x21, __DFU_DNLOAD, 0, __DFU_INTERFACE,
-                        "\x41", __TIMEOUT)
+    __dev.ctrl_transfer(0x21, __DFU_DNLOAD, 0, __DFU_INTERFACE, "\x41", __TIMEOUT)
 
     # Execute last command
-    if get_status() != __DFU_STATE_DFU_DOWNLOAD_BUSY:
-        raise Exception("DFU: erase failed")
+    check_status("erase", __DFU_STATE_DFU_DOWNLOAD_BUSY)
 
     # Check command state
-    if get_status() != __DFU_STATE_DFU_DOWNLOAD_IDLE:
-        raise Exception("DFU: erase failed")
+    check_status("erase", __DFU_STATE_DFU_DOWNLOAD_IDLE)
 
 
 def page_erase(addr):
@@ -170,13 +199,10 @@ def page_erase(addr):
     __dev.ctrl_transfer(0x21, __DFU_DNLOAD, 0, __DFU_INTERFACE, buf, __TIMEOUT)
 
     # Execute last command
-    if get_status() != __DFU_STATE_DFU_DOWNLOAD_BUSY:
-        raise Exception("DFU: erase failed")
+    check_status("erase", __DFU_STATE_DFU_DOWNLOAD_BUSY)
 
     # Check command state
-    if get_status() != __DFU_STATE_DFU_DOWNLOAD_IDLE:
-
-        raise Exception("DFU: erase failed")
+    check_status("erase", __DFU_STATE_DFU_DOWNLOAD_IDLE)
 
 
 def set_address(addr):
@@ -186,12 +212,10 @@ def set_address(addr):
     __dev.ctrl_transfer(0x21, __DFU_DNLOAD, 0, __DFU_INTERFACE, buf, __TIMEOUT)
 
     # Execute last command
-    if get_status() != __DFU_STATE_DFU_DOWNLOAD_BUSY:
-        raise Exception("DFU: set address failed")
+    check_status("set address", __DFU_STATE_DFU_DOWNLOAD_BUSY)
 
     # Check command state
-    if get_status() != __DFU_STATE_DFU_DOWNLOAD_IDLE:
-        raise Exception("DFU: set address failed")
+    check_status("set address", __DFU_STATE_DFU_DOWNLOAD_IDLE)
 
 
 def write_memory(addr, buf, progress=None, progress_addr=0, progress_size=0):
@@ -206,28 +230,27 @@ def write_memory(addr, buf, progress=None, progress_addr=0, progress_size=0):
 
     while xfer_bytes < xfer_total:
         if __verbose and xfer_count % 512 == 0:
-            print ("Addr 0x%x %dKBs/%dKBs..." % (xfer_base + xfer_bytes,
-                                                 xfer_bytes // 1024,
-                                                 xfer_total // 1024))
+            print(
+                "Addr 0x%x %dKBs/%dKBs..."
+                % (xfer_base + xfer_bytes, xfer_bytes // 1024, xfer_total // 1024)
+            )
         if progress and xfer_count % 2 == 0:
-            progress(progress_addr, xfer_base + xfer_bytes - progress_addr,
-                     progress_size)
+            progress(progress_addr, xfer_base + xfer_bytes - progress_addr, progress_size)
 
         # Set mem write address
-        set_address(xfer_base+xfer_bytes)
+        set_address(xfer_base + xfer_bytes)
 
         # Send DNLOAD with fw data
-        chunk = min(__cfg_descr.wTransferSize, xfer_total-xfer_bytes)
-        __dev.ctrl_transfer(0x21, __DFU_DNLOAD, 2, __DFU_INTERFACE,
-                            buf[xfer_bytes:xfer_bytes + chunk], __TIMEOUT)
+        chunk = min(__cfg_descr.wTransferSize, xfer_total - xfer_bytes)
+        __dev.ctrl_transfer(
+            0x21, __DFU_DNLOAD, 2, __DFU_INTERFACE, buf[xfer_bytes : xfer_bytes + chunk], __TIMEOUT
+        )
 
         # Execute last command
-        if get_status() != __DFU_STATE_DFU_DOWNLOAD_BUSY:
-            raise Exception("DFU: write memory failed")
+        check_status("write memory", __DFU_STATE_DFU_DOWNLOAD_BUSY)
 
         # Check command state
-        if get_status() != __DFU_STATE_DFU_DOWNLOAD_IDLE:
-            raise Exception("DFU: write memory failed")
+        check_status("write memory", __DFU_STATE_DFU_DOWNLOAD_IDLE)
 
         xfer_count += 1
         xfer_bytes += chunk
@@ -241,32 +264,28 @@ def write_page(buf, xfer_offset):
     xfer_base = 0x08000000
 
     # Set mem write address
-    set_address(xfer_base+xfer_offset)
+    set_address(xfer_base + xfer_offset)
 
     # Send DNLOAD with fw data
     __dev.ctrl_transfer(0x21, __DFU_DNLOAD, 2, __DFU_INTERFACE, buf, __TIMEOUT)
 
     # Execute last command
-    if get_status() != __DFU_STATE_DFU_DOWNLOAD_BUSY:
-        raise Exception("DFU: write memory failed")
+    check_status("write memory", __DFU_STATE_DFU_DOWNLOAD_BUSY)
 
     # Check command state
-    if get_status() != __DFU_STATE_DFU_DOWNLOAD_IDLE:
-        raise Exception("DFU: write memory failed")
+    check_status("write memory", __DFU_STATE_DFU_DOWNLOAD_IDLE)
 
     if __verbose:
-        print ("Write: 0x%x " % (xfer_base + xfer_offset))
+        print("Write: 0x%x " % (xfer_base + xfer_offset))
 
 
 def exit_dfu():
     """Exit DFU mode, and start running the program."""
-
-    # set jump address
+    # Set jump address
     set_address(0x08000000)
 
     # Send DNLOAD with 0 length to exit DFU
-    __dev.ctrl_transfer(0x21, __DFU_DNLOAD, 0, __DFU_INTERFACE,
-                        None, __TIMEOUT)
+    __dev.ctrl_transfer(0x21, __DFU_DNLOAD, 0, __DFU_INTERFACE, None, __TIMEOUT)
 
     try:
         # Execute last command
@@ -288,13 +307,14 @@ def consume(fmt, data, names):
     """Parses the struct defined by `fmt` from `data`, stores the parsed fields
     into a named tuple using `names`. Returns the named tuple, and the data
     with the struct stripped off."""
+
     size = struct.calcsize(fmt)
     return named(struct.unpack(fmt, data[:size]), names), data[size:]
 
 
 def cstring(string):
     """Extracts a null-terminated string from a byte array."""
-    return string.decode('utf-8').split('\0', 1)[0]
+    return string.decode("utf-8").split("\0", 1)[0]
 
 
 def compute_crc(data):
@@ -306,15 +326,15 @@ def read_dfu_file(filename):
     """Reads a DFU file, and parses the individual elements from the file.
     Returns an array of elements. Each element is a dictionary with the
     following keys:
-        num     - The element index
+        num     - The element index.
         address - The address that the element data should be written to.
-        size    - The size of the element ddata.
+        size    - The size of the element data.
         data    - The element data.
     If an error occurs while parsing the file, then None is returned.
     """
 
     print("File: {}".format(filename))
-    with open(filename, 'rb') as fin:
+    with open(filename, "rb") as fin:
         data = fin.read()
     crc = compute_crc(data[:-4])
     elements = []
@@ -322,72 +342,81 @@ def read_dfu_file(filename):
     # Decode the DFU Prefix
     #
     # <5sBIB
-    #   <   little endian
+    #   <   little endian           Endianness
     #   5s  char[5]     signature   "DfuSe"
     #   B   uint8_t     version     1
-    #   I   uint32_t    size        Size of the DFU file (not including suffix)
+    #   I   uint32_t    size        Size of the DFU file (without suffix)
     #   B   uint8_t     targets     Number of targets
-    dfu_prefix, data = consume('<5sBIB', data,
-                               'signature version size targets')
-    print ("    %(signature)s v%(version)d, image size: %(size)d, "
-           "targets: %(targets)d" % dfu_prefix)
-    for target_idx in range(dfu_prefix['targets']):
+    dfu_prefix, data = consume("<5sBIB", data, "signature version size targets")
+    print(
+        "    %(signature)s v%(version)d, image size: %(size)d, "
+        "targets: %(targets)d" % dfu_prefix
+    )
+    for target_idx in range(dfu_prefix["targets"]):
         # Decode the Image Prefix
         #
         # <6sBI255s2I
-        #   <   little endian
+        #   <       little endian           Endianness
         #   6s      char[6]     signature   "Target"
         #   B       uint8_t     altsetting
-        #   I       uint32_t    named       bool indicating if a name was used
-        #   255s    char[255]   name        name of the target
-        #   I       uint32_t    size        size of image (not incl prefix)
+        #   I       uint32_t    named       Bool indicating if a name was used
+        #   255s    char[255]   name        Name of the target
+        #   I       uint32_t    size        Size of image (without prefix)
         #   I       uint32_t    elements    Number of elements in the image
-        img_prefix, data = consume('<6sBI255s2I', data,
-                                   'signature altsetting named name '
-                                   'size elements')
-        img_prefix['num'] = target_idx
-        if img_prefix['named']:
-            img_prefix['name'] = cstring(img_prefix['name'])
+        img_prefix, data = consume(
+            "<6sBI255s2I", data, "signature altsetting named name " "size elements"
+        )
+        img_prefix["num"] = target_idx
+        if img_prefix["named"]:
+            img_prefix["name"] = cstring(img_prefix["name"])
         else:
-            img_prefix['name'] = ''
-        print('    %(signature)s %(num)d, alt setting: %(altsetting)s, '
-              'name: "%(name)s", size: %(size)d, elements: %(elements)d'
-              % img_prefix)
-
-        target_size = img_prefix['size']
-        target_data, data = data[:target_size], data[target_size:]
-        for elem_idx in range(img_prefix['elements']):
+            img_prefix["name"] = ""
+        print(
+            "    %(signature)s %(num)d, alt setting: %(altsetting)s, "
+            'name: "%(name)s", size: %(size)d, elements: %(elements)d' % img_prefix
+        )
+
+        target_size = img_prefix["size"]
+        target_data = data[:target_size]
+        data = data[target_size:]
+        for elem_idx in range(img_prefix["elements"]):
             # Decode target prefix
-            #   <   little endian
-            #   I   uint32_t    element address
-            #   I   uint32_t    element size
-            elem_prefix, target_data = consume('<2I', target_data, 'addr size')
-            elem_prefix['num'] = elem_idx
-            print('      %(num)d, address: 0x%(addr)08x, size: %(size)d'
-                  % elem_prefix)
-            elem_size = elem_prefix['size']
+            #
+            # <2I
+            #   <   little endian           Endianness
+            #   I   uint32_t    element     Address
+            #   I   uint32_t    element     Size
+            elem_prefix, target_data = consume("<2I", target_data, "addr size")
+            elem_prefix["num"] = elem_idx
+            print("      %(num)d, address: 0x%(addr)08x, size: %(size)d" % elem_prefix)
+            elem_size = elem_prefix["size"]
             elem_data = target_data[:elem_size]
             target_data = target_data[elem_size:]
-            elem_prefix['data'] = elem_data
+            elem_prefix["data"] = elem_data
             elements.append(elem_prefix)
 
         if len(target_data):
             print("target %d PARSE ERROR" % target_idx)
 
     # Decode DFU Suffix
-    #   <   little endian
-    #   H   uint16_t    device  Firmware version
+    #
+    # <4H3sBI
+    #   <   little endian           Endianness
+    #   H   uint16_t    device      Firmware version
     #   H   uint16_t    product
     #   H   uint16_t    vendor
-    #   H   uint16_t    dfu     0x11a   (DFU file format version)
-    #   3s  char[3]     ufd     'UFD'
-    #   B   uint8_t     len     16
-    #   I   uint32_t    crc32
-    dfu_suffix = named(struct.unpack('<4H3sBI', data[:16]),
-                       'device product vendor dfu ufd len crc')
-    print ('    usb: %(vendor)04x:%(product)04x, device: 0x%(device)04x, '
-           'dfu: 0x%(dfu)04x, %(ufd)s, %(len)d, 0x%(crc)08x' % dfu_suffix)
-    if crc != dfu_suffix['crc']:
+    #   H   uint16_t    dfu         0x11a   (DFU file format version)
+    #   3s  char[3]     ufd         "UFD"
+    #   B   uint8_t     len         16
+    #   I   uint32_t    crc32       Checksum
+    dfu_suffix = named(
+        struct.unpack("<4H3sBI", data[:16]), "device product vendor dfu ufd len crc"
+    )
+    print(
+        "    usb: %(vendor)04x:%(product)04x, device: 0x%(device)04x, "
+        "dfu: 0x%(dfu)04x, %(ufd)s, %(len)d, 0x%(crc)08x" % dfu_suffix
+    )
+    if crc != dfu_suffix["crc"]:
         print("CRC ERROR: computed crc32 is 0x%08x" % crc)
         return
     data = data[16:]
@@ -406,51 +435,55 @@ class FilterDFU(object):
     def __call__(self, device):
         for cfg in device:
             for intf in cfg:
-                return (intf.bInterfaceClass == 0xFE and
-                        intf.bInterfaceSubClass == 1)
+                return intf.bInterfaceClass == 0xFE and intf.bInterfaceSubClass == 1
 
 
 def get_dfu_devices(*args, **kwargs):
-    """Returns a list of USB device which are currently in DFU mode.
-    Additional filters (like idProduct and idVendor) can be passed in to
-    refine the search.
+    """Returns a list of USB devices which are currently in DFU mode.
+    Additional filters (like idProduct and idVendor) can be passed in
+    to refine the search.
     """
-    # convert to list for compatibility with newer pyusb
-    return list(usb.core.find(*args, find_all=True,
-                              custom_match=FilterDFU(), **kwargs))
+
+    # Convert to list for compatibility with newer PyUSB
+    return list(usb.core.find(*args, find_all=True, custom_match=FilterDFU(), **kwargs))
 
 
 def get_memory_layout(device):
     """Returns an array which identifies the memory layout. Each entry
     of the array will contain a dictionary with the following keys:
-        addr        - Address of this memory segment
+        addr        - Address of this memory segment.
         last_addr   - Last address contained within the memory segment.
-        size        - size of the segment, in bytes
-        num_pages   - number of pages in the segment
-        page_size   - size of each page, in bytes
+        size        - Size of the segment, in bytes.
+        num_pages   - Number of pages in the segment.
+        page_size   - Size of each page, in bytes.
     """
+
     cfg = device[0]
     intf = cfg[(0, 0)]
     mem_layout_str = get_string(device, intf.iInterface)
-    mem_layout = mem_layout_str.split('/')
+    mem_layout = mem_layout_str.split("/")
     result = []
     for mem_layout_index in range(1, len(mem_layout), 2):
         addr = int(mem_layout[mem_layout_index], 0)
-        segments = mem_layout[mem_layout_index + 1].split(',')
-        seg_re = re.compile(r'(\d+)\*(\d+)(.)(.)')
+        segments = mem_layout[mem_layout_index + 1].split(",")
+        seg_re = re.compile(r"(\d+)\*(\d+)(.)(.)")
         for segment in segments:
             seg_match = seg_re.match(segment)
             num_pages = int(seg_match.groups()[0], 10)
             page_size = int(seg_match.groups()[1], 10)
             multiplier = seg_match.groups()[2]
-            if multiplier == 'K':
+            if multiplier == "K":
                 page_size *= 1024
-            if multiplier == 'M':
+            if multiplier == "M":
                 page_size *= 1024 * 1024
             size = num_pages * page_size
             last_addr = addr + size - 1
-            result.append(named((addr, last_addr, size, num_pages, page_size),
-                          "addr last_addr size num_pages page_size"))
+            result.append(
+                named(
+                    (addr, last_addr, size, num_pages, page_size),
+                    "addr last_addr size num_pages page_size",
+                )
+            )
             addr += size
     return result
 
@@ -459,18 +492,21 @@ def list_dfu_devices(*args, **kwargs):
     """Prints a lits of devices detected in DFU mode."""
     devices = get_dfu_devices(*args, **kwargs)
     if not devices:
-        print("No DFU capable devices found")
-        return
+        raise SystemExit("No DFU capable devices found")
     for device in devices:
-        print("Bus {} Device {:03d}: ID {:04x}:{:04x}"
-              .format(device.bus, device.address,
-                      device.idVendor, device.idProduct))
+        print(
+            "Bus {} Device {:03d}: ID {:04x}:{:04x}".format(
+                device.bus, device.address, device.idVendor, device.idProduct
+            )
+        )
         layout = get_memory_layout(device)
         print("Memory Layout")
         for entry in layout:
-            print("    0x{:x} {:2d} pages of {:3d}K bytes"
-                  .format(entry['addr'], entry['num_pages'],
-                          entry['page_size'] // 1024))
+            print(
+                "    0x{:x} {:2d} pages of {:3d}K bytes".format(
+                    entry["addr"], entry["num_pages"], entry["page_size"] // 1024
+                )
+            )
 
 
 def write_elements(elements, mass_erase_used, progress=None):
@@ -480,9 +516,9 @@ def write_elements(elements, mass_erase_used, progress=None):
 
     mem_layout = get_memory_layout(__dev)
     for elem in elements:
-        addr = elem['addr']
-        size = elem['size']
-        data = elem['data']
+        addr = elem["addr"]
+        size = elem["size"]
+        data = elem["data"]
         elem_size = size
         elem_addr = addr
         if progress:
@@ -491,18 +527,16 @@ def write_elements(elements, mass_erase_used, progress=None):
             write_size = size
             if not mass_erase_used:
                 for segment in mem_layout:
-                    if addr >= segment['addr'] and \
-                       addr <= segment['last_addr']:
+                    if addr >= segment["addr"] and addr <= segment["last_addr"]:
                         # We found the page containing the address we want to
                         # write, erase it
-                        page_size = segment['page_size']
+                        page_size = segment["page_size"]
                         page_addr = addr & ~(page_size - 1)
                         if addr + write_size > page_addr + page_size:
                             write_size = page_addr + page_size - addr
                         page_erase(page_addr)
                         break
-            write_memory(addr, data[:write_size], progress,
-                         elem_addr, elem_size)
+            write_memory(addr, data[:write_size], progress, elem_addr, elem_size)
             data = data[write_size:]
             addr += write_size
             size -= write_size
@@ -514,13 +548,16 @@ def cli_progress(addr, offset, size):
     """Prints a progress report suitable for use on the command line."""
     width = 25
     done = offset * width // size
-    print("\r0x{:08x} {:7d} [{}{}] {:3d}% "
-          .format(addr, size, '=' * done, ' ' * (width - done),
-                  offset * 100 // size), end="")
+    print(
+        "\r0x{:08x} {:7d} [{}{}] {:3d}% ".format(
+            addr, size, "=" * done, " " * (width - done), offset * 100 // size
+        ),
+        end="",
+    )
     try:
         sys.stdout.flush()
     except OSError:
-        pass # Ignore Windows CLI "WinError 87" on Python 3.6
+        pass  # Ignore Windows CLI "WinError 87" on Python 3.6
     if offset == size:
         print("")
 
@@ -528,59 +565,66 @@ def cli_progress(addr, offset, size):
 def main():
     """Test program for verifying this files functionality."""
     global __verbose
+    global __VID
+    global __PID
     # Parse CMD args
-    parser = argparse.ArgumentParser(description='DFU Python Util')
-    #parser.add_argument("path", help="file path")
+    parser = argparse.ArgumentParser(description="DFU Python Util")
     parser.add_argument(
-        "-l", "--list",
-        help="list available DFU devices",
-        action="store_true",
-        default=False
+        "-l", "--list", help="list available DFU devices", action="store_true", default=False
     )
+    parser.add_argument("--vid", help="USB Vendor ID", type=lambda x: int(x, 0), default=__VID)
+    parser.add_argument("--pid", help="USB Product ID", type=lambda x: int(x, 0), default=__PID)
     parser.add_argument(
-        "-m", "--mass-erase",
-        help="mass erase device",
-        action="store_true",
-        default=False
+        "-m", "--mass-erase", help="mass erase device", action="store_true", default=False
     )
     parser.add_argument(
-        "-u", "--upload",
-        help="read file from DFU device",
-        dest="path",
-        default=False
+        "-u", "--upload", help="read file from DFU device", dest="path", default=False
     )
+    parser.add_argument("-x", "--exit", help="Exit DFU", action="store_true", default=False)
     parser.add_argument(
-        "-v", "--verbose",
-        help="increase output verbosity",
-        action="store_true",
-        default=False
+        "-v", "--verbose", help="increase output verbosity", action="store_true", default=False
     )
     args = parser.parse_args()
 
     __verbose = args.verbose
 
+    __VID = args.vid
+    __PID = args.pid
+
     if args.list:
         list_dfu_devices(idVendor=__VID, idProduct=__PID)
         return
 
     init()
 
+    command_run = False
     if args.mass_erase:
-        print ("Mass erase...")
+        print("Mass erase...")
         mass_erase()
+        command_run = True
 
     if args.path:
         elements = read_dfu_file(args.path)
         if not elements:
+            print("No data in dfu file")
             return
         print("Writing memory...")
         write_elements(elements, args.mass_erase, progress=cli_progress)
 
         print("Exiting DFU...")
         exit_dfu()
-        return
+        command_run = True
+
+    if args.exit:
+        print("Exiting DFU...")
+        exit_dfu()
+        command_run = True
+
+    if command_run:
+        print("Finished")
+    else:
+        print("No command specified")
 
-    print("No command specified")
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/tools/tinytest-codegen.py b/tools/tinytest-codegen.py
index ad3b3bbec9508..116a217b4bbc7 100755
--- a/tools/tinytest-codegen.py
+++ b/tools/tinytest-codegen.py
@@ -9,17 +9,19 @@
 def escape(s):
     s = s.decode()
     lookup = {
-        '\0': '\\0',
-        '\t': '\\t',
-        '\n': '\\n\"\n\"',
-        '\r': '\\r',
-        '\\': '\\\\',
-        '\"': '\\\"',
+        "\0": "\\0",
+        "\t": "\\t",
+        "\n": '\\n"\n"',
+        "\r": "\\r",
+        "\\": "\\\\",
+        '"': '\\"',
     }
-    return "\"\"\n\"{}\"".format(''.join([lookup[x] if x in lookup else x for x in s]))
+    return '""\n"{}"'.format("".join([lookup[x] if x in lookup else x for x in s]))
+
 
 def chew_filename(t):
-    return { 'func': "test_{}_fn".format(sub(r'/|\.|-', '_', t)), 'desc': t }
+    return {"func": "test_{}_fn".format(sub(r"/|\.|-", "_", t)), "desc": t}
+
 
 def script_to_map(test_file):
     r = {"name": chew_filename(test_file)["func"]}
@@ -29,82 +31,100 @@ def script_to_map(test_file):
         r["output"] = escape(f.read())
     return r
 
+
 test_function = (
     "void {name}(void* data) {{\n"
     "  static const char pystr[] = {script};\n"
     "  static const char exp[] = {output};\n"
+    '  printf("\\n");\n'
     "  upytest_set_expected_output(exp, sizeof(exp) - 1);\n"
     "  upytest_execute_test(pystr);\n"
+    '  printf("result: ");\n'
     "}}"
 )
 
-testcase_struct = (
-    "struct testcase_t {name}_tests[] = {{\n{body}\n  END_OF_TESTCASES\n}};"
-)
-testcase_member = (
-    "  {{ \"{desc}\", {func}, TT_ENABLED_, 0, 0 }},"
-)
+testcase_struct = "struct testcase_t {name}_tests[] = {{\n{body}\n  END_OF_TESTCASES\n}};"
+testcase_member = '  {{ "{desc}", {func}, TT_ENABLED_, 0, 0 }},'
 
-testgroup_struct = (
-    "struct testgroup_t groups[] = {{\n{body}\n  END_OF_GROUPS\n}};"
-)
-testgroup_member = (
-    "  {{ \"{name}\", {name}_tests }},"
-)
+testgroup_struct = "struct testgroup_t groups[] = {{\n{body}\n  END_OF_GROUPS\n}};"
+testgroup_member = '  {{ "{name}", {name}_tests }},'
 
 ## XXX: may be we could have `--without <groups>` argument...
 # currently these tests are selected because they pass on qemu-arm
-test_dirs = ('basics', 'micropython', 'float', 'extmod', 'inlineasm') # 'import', 'io', 'misc')
+test_dirs = (
+    "basics",
+    "micropython",
+    "misc",
+    "extmod",
+    "float",
+    "inlineasm",
+    "qemu-arm",
+)  # 'import', 'io',)
 exclude_tests = (
     # pattern matching in .exp
-    'basics/bytes_compare3.py',
-    'extmod/ticks_diff.py',
-    'extmod/time_ms_us.py',
-    'extmod/uheapq_timeq.py',
+    "basics/bytes_compare3.py",
+    "extmod/ticks_diff.py",
+    "extmod/time_ms_us.py",
+    "extmod/uheapq_timeq.py",
     # unicode char issue
-    'extmod/ujson_loads.py',
+    "extmod/ujson_loads.py",
     # doesn't output to python stdout
-    'extmod/ure_debug.py',
-    'extmod/vfs_basic.py',
-    'extmod/vfs_fat_ramdisk.py', 'extmod/vfs_fat_fileio.py',
-    'extmod/vfs_fat_fsusermount.py', 'extmod/vfs_fat_oldproto.py',
+    "extmod/ure_debug.py",
+    "extmod/vfs_basic.py",
+    "extmod/vfs_fat_ramdisk.py",
+    "extmod/vfs_fat_fileio.py",
+    "extmod/vfs_fat_fsusermount.py",
+    "extmod/vfs_fat_oldproto.py",
     # rounding issues
-    'float/float_divmod.py',
+    "float/float_divmod.py",
     # requires double precision floating point to work
-    'float/float2int_doubleprec_intbig.py',
-    'float/float_parse_doubleprec.py',
+    "float/float2int_doubleprec_intbig.py",
+    "float/float_parse_doubleprec.py",
     # inline asm FP tests (require Cortex-M4)
-    'inlineasm/asmfpaddsub.py', 'inlineasm/asmfpcmp.py', 'inlineasm/asmfpldrstr.py',
-    'inlineasm/asmfpmuldiv.py','inlineasm/asmfpsqrt.py',
+    "inlineasm/asmfpaddsub.py",
+    "inlineasm/asmfpcmp.py",
+    "inlineasm/asmfpldrstr.py",
+    "inlineasm/asmfpmuldiv.py",
+    "inlineasm/asmfpsqrt.py",
     # different filename in output
-    'micropython/emg_exc.py',
-    'micropython/heapalloc_traceback.py',
+    "micropython/emg_exc.py",
+    "micropython/heapalloc_traceback.py",
+    # don't have emergency exception buffer
+    "micropython/heapalloc_exc_compressed_emg_exc.py",
     # pattern matching in .exp
-    'micropython/meminfo.py',
+    "micropython/meminfo.py",
+    # needs sys stdfiles
+    "misc/print_exception.py",
+    # settrace .exp files are too large
+    "misc/sys_settrace_loop.py",
+    "misc/sys_settrace_generator.py",
+    "misc/sys_settrace_features.py",
 )
 
 output = []
 tests = []
 
-argparser = argparse.ArgumentParser(description='Convert native MicroPython tests to tinytest/upytesthelper C code')
-argparser.add_argument('--stdin', action="store_true", help='read list of tests from stdin')
+argparser = argparse.ArgumentParser(
+    description="Convert native MicroPython tests to tinytest/upytesthelper C code"
+)
+argparser.add_argument("--stdin", action="store_true", help="read list of tests from stdin")
 args = argparser.parse_args()
 
 if not args.stdin:
     for group in test_dirs:
-        tests += [test for test in glob('{}/*.py'.format(group)) if test not in exclude_tests]
+        tests += [test for test in glob("{}/*.py".format(group)) if test not in exclude_tests]
 else:
     for l in sys.stdin:
         tests.append(l.rstrip())
 
 output.extend([test_function.format(**script_to_map(test)) for test in tests])
 testcase_members = [testcase_member.format(**chew_filename(test)) for test in tests]
-output.append(testcase_struct.format(name="", body='\n'.join(testcase_members)))
+output.append(testcase_struct.format(name="", body="\n".join(testcase_members)))
 
 testgroup_members = [testgroup_member.format(name=group) for group in [""]]
 
-output.append(testgroup_struct.format(body='\n'.join(testgroup_members)))
+output.append(testgroup_struct.format(body="\n".join(testgroup_members)))
 
 ## XXX: may be we could have `--output <filename>` argument...
 # Don't depend on what system locale is set, use utf8 encoding.
-sys.stdout.buffer.write('\n\n'.join(output).encode('utf8'))
+sys.stdout.buffer.write("\n\n".join(output).encode("utf8"))
diff --git a/tools/uf2conv.py b/tools/uf2conv.py
new file mode 100755
index 0000000000000..d67a55224c904
--- /dev/null
+++ b/tools/uf2conv.py
@@ -0,0 +1,369 @@
+#!/usr/bin/env python3
+
+# Microsoft UF2
+#
+# The MIT License (MIT)
+#
+# Copyright (c) Microsoft Corporation
+#
+# All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+import sys
+import struct
+import subprocess
+import re
+import os
+import os.path
+import argparse
+
+
+UF2_MAGIC_START0 = 0x0A324655  # "UF2\n"
+UF2_MAGIC_START1 = 0x9E5D5157  # Randomly selected
+UF2_MAGIC_END = 0x0AB16F30  # Ditto
+
+families = {
+    "SAMD21": 0x68ED2B88,
+    "SAMD51": 0x55114460,
+    "NRF52": 0x1B57745F,
+    "STM32F1": 0x5EE21072,
+    "STM32F4": 0x57755A57,
+    "ATMEGA32": 0x16573617,
+}
+
+INFO_FILE = "/INFO_UF2.TXT"
+
+appstartaddr = 0x2000
+familyid = 0x0
+
+
+def is_uf2(buf):
+    w = struct.unpack("<II", buf[0:8])
+    return w[0] == UF2_MAGIC_START0 and w[1] == UF2_MAGIC_START1
+
+
+def is_hex(buf):
+    try:
+        w = buf[0:30].decode("utf-8")
+    except UnicodeDecodeError:
+        return False
+    if w[0] == ":" and re.match(b"^[:0-9a-fA-F\r\n]+$", buf):
+        return True
+    return False
+
+
+def convert_from_uf2(buf):
+    global appstartaddr
+    numblocks = len(buf) // 512
+    curraddr = None
+    outp = b""
+    for blockno in range(numblocks):
+        ptr = blockno * 512
+        block = buf[ptr : ptr + 512]
+        hd = struct.unpack(b"<IIIIIIII", block[0:32])
+        if hd[0] != UF2_MAGIC_START0 or hd[1] != UF2_MAGIC_START1:
+            print("Skipping block at " + ptr + "; bad magic")
+            continue
+        if hd[2] & 1:
+            # NO-flash flag set; skip block
+            continue
+        datalen = hd[4]
+        if datalen > 476:
+            assert False, "Invalid UF2 data size at " + ptr
+        newaddr = hd[3]
+        if curraddr == None:
+            appstartaddr = newaddr
+            curraddr = newaddr
+        padding = newaddr - curraddr
+        if padding < 0:
+            assert False, "Block out of order at " + ptr
+        if padding > 10 * 1024 * 1024:
+            assert False, "More than 10M of padding needed at " + ptr
+        if padding % 4 != 0:
+            assert False, "Non-word padding size at " + ptr
+        while padding > 0:
+            padding -= 4
+            outp += b"\x00\x00\x00\x00"
+        outp += block[32 : 32 + datalen]
+        curraddr = newaddr + datalen
+    return outp
+
+
+def convert_to_carray(file_content):
+    outp = "const unsigned char bindata[] __attribute__((aligned(16))) = {"
+    for i in range(len(file_content)):
+        if i % 16 == 0:
+            outp += "\n"
+        outp += "0x%02x, " % ord(file_content[i])
+    outp += "\n};\n"
+    return outp
+
+
+def convert_to_uf2(file_content):
+    global familyid
+    datapadding = b""
+    while len(datapadding) < 512 - 256 - 32 - 4:
+        datapadding += b"\x00\x00\x00\x00"
+    numblocks = (len(file_content) + 255) // 256
+    outp = b""
+    for blockno in range(numblocks):
+        ptr = 256 * blockno
+        chunk = file_content[ptr : ptr + 256]
+        flags = 0x0
+        if familyid:
+            flags |= 0x2000
+        hd = struct.pack(
+            b"<IIIIIIII",
+            UF2_MAGIC_START0,
+            UF2_MAGIC_START1,
+            flags,
+            ptr + appstartaddr,
+            256,
+            blockno,
+            numblocks,
+            familyid,
+        )
+        while len(chunk) < 256:
+            chunk += b"\x00"
+        block = hd + chunk + datapadding + struct.pack(b"<I", UF2_MAGIC_END)
+        assert len(block) == 512
+        outp += block
+    return outp
+
+
+class Block:
+    def __init__(self, addr):
+        self.addr = addr
+        self.bytes = bytearray(256)
+
+    def encode(self, blockno, numblocks):
+        global familyid
+        flags = 0x0
+        if familyid:
+            flags |= 0x2000
+        hd = struct.pack(
+            "<IIIIIIII",
+            UF2_MAGIC_START0,
+            UF2_MAGIC_START1,
+            flags,
+            self.addr,
+            256,
+            blockno,
+            numblocks,
+            familyid,
+        )
+        hd += self.bytes[0:256]
+        while len(hd) < 512 - 4:
+            hd += b"\x00"
+        hd += struct.pack("<I", UF2_MAGIC_END)
+        return hd
+
+
+def convert_from_hex_to_uf2(buf):
+    global appstartaddr
+    appstartaddr = None
+    upper = 0
+    currblock = None
+    blocks = []
+    for line in buf.split("\n"):
+        if line[0] != ":":
+            continue
+        i = 1
+        rec = []
+        while i < len(line) - 1:
+            rec.append(int(line[i : i + 2], 16))
+            i += 2
+        tp = rec[3]
+        if tp == 4:
+            upper = ((rec[4] << 8) | rec[5]) << 16
+        elif tp == 2:
+            upper = ((rec[4] << 8) | rec[5]) << 4
+            assert (upper & 0xFFFF) == 0
+        elif tp == 1:
+            break
+        elif tp == 0:
+            addr = upper | (rec[1] << 8) | rec[2]
+            if appstartaddr == None:
+                appstartaddr = addr
+            i = 4
+            while i < len(rec) - 1:
+                if not currblock or currblock.addr & ~0xFF != addr & ~0xFF:
+                    currblock = Block(addr & ~0xFF)
+                    blocks.append(currblock)
+                currblock.bytes[addr & 0xFF] = rec[i]
+                addr += 1
+                i += 1
+    numblocks = len(blocks)
+    resfile = b""
+    for i in range(0, numblocks):
+        resfile += blocks[i].encode(i, numblocks)
+    return resfile
+
+
+def get_drives():
+    drives = []
+    if sys.platform == "win32":
+        r = subprocess.check_output(
+            [
+                "wmic",
+                "PATH",
+                "Win32_LogicalDisk",
+                "get",
+                "DeviceID,",
+                "VolumeName,",
+                "FileSystem,",
+                "DriveType",
+            ]
+        )
+        for line in r.split("\n"):
+            words = re.split("\s+", line)
+            if len(words) >= 3 and words[1] == "2" and words[2] == "FAT":
+                drives.append(words[0])
+    else:
+        rootpath = "/media"
+        if sys.platform == "darwin":
+            rootpath = "/Volumes"
+        elif sys.platform == "linux":
+            tmp = rootpath + "/" + os.environ["USER"]
+            if os.path.isdir(tmp):
+                rootpath = tmp
+        for d in os.listdir(rootpath):
+            drives.append(os.path.join(rootpath, d))
+
+    def has_info(d):
+        try:
+            return os.path.isfile(d + INFO_FILE)
+        except:
+            return False
+
+    return list(filter(has_info, drives))
+
+
+def board_id(path):
+    with open(path + INFO_FILE, mode="r") as file:
+        file_content = file.read()
+    return re.search("Board-ID: ([^\r\n]*)", file_content).group(1)
+
+
+def list_drives():
+    for d in get_drives():
+        print(d, board_id(d))
+
+
+def write_file(name, buf):
+    with open(name, "wb") as f:
+        f.write(buf)
+    print("Wrote %d bytes to %s." % (len(buf), name))
+
+
+def main():
+    global appstartaddr, familyid
+
+    def error(msg):
+        print(msg)
+        sys.exit(1)
+
+    parser = argparse.ArgumentParser(description="Convert to UF2 or flash directly.")
+    parser.add_argument(
+        "input", metavar="INPUT", type=str, nargs="?", help="input file (HEX, BIN or UF2)"
+    )
+    parser.add_argument(
+        "-b",
+        "--base",
+        dest="base",
+        type=str,
+        default="0x2000",
+        help="set base address of application for BIN format (default: 0x2000)",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        metavar="FILE",
+        dest="output",
+        type=str,
+        help='write output to named file; defaults to "flash.uf2" or "flash.bin" where sensible',
+    )
+    parser.add_argument("-d", "--device", dest="device_path", help="select a device path to flash")
+    parser.add_argument("-l", "--list", action="store_true", help="list connected devices")
+    parser.add_argument("-c", "--convert", action="store_true", help="do not flash, just convert")
+    parser.add_argument(
+        "-f",
+        "--family",
+        dest="family",
+        type=str,
+        default="0x0",
+        help="specify familyID - number or name (default: 0x0)",
+    )
+    parser.add_argument(
+        "-C", "--carray", action="store_true", help="convert binary file to a C array, not UF2"
+    )
+    args = parser.parse_args()
+    appstartaddr = int(args.base, 0)
+
+    if args.family.upper() in families:
+        familyid = families[args.family.upper()]
+    else:
+        try:
+            familyid = int(args.family, 0)
+        except ValueError:
+            error("Family ID needs to be a number or one of: " + ", ".join(families.keys()))
+
+    if args.list:
+        list_drives()
+    else:
+        if not args.input:
+            error("Need input file")
+        with open(args.input, mode="rb") as f:
+            inpbuf = f.read()
+        from_uf2 = is_uf2(inpbuf)
+        ext = "uf2"
+        if from_uf2:
+            outbuf = convert_from_uf2(inpbuf)
+            ext = "bin"
+        elif is_hex(inpbuf):
+            outbuf = convert_from_hex_to_uf2(inpbuf.decode("utf-8"))
+        elif args.carray:
+            outbuf = convert_to_carray(inpbuf)
+            ext = "h"
+        else:
+            outbuf = convert_to_uf2(inpbuf)
+        print(
+            "Converting to %s, output size: %d, start address: 0x%x"
+            % (ext, len(outbuf), appstartaddr)
+        )
+        if args.convert:
+            drives = []
+            if args.output == None:
+                args.output = "flash." + ext
+        else:
+            drives = get_drives()
+
+        if args.output:
+            write_file(args.output, outbuf)
+        else:
+            if len(drives) == 0:
+                error("No drive to deploy.")
+        for d in drives:
+            print("Flashing %s (%s)" % (d, board_id(d)))
+            write_file(d + "/NEW.UF2", outbuf)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/uncrustify.cfg b/tools/uncrustify.cfg
new file mode 100644
index 0000000000000..b0b1239b1a1fb
--- /dev/null
+++ b/tools/uncrustify.cfg
@@ -0,0 +1,2989 @@
+# Uncrustify-0.70.1
+
+#
+# General options
+#
+
+# The type of line endings.
+#
+# Default: auto
+newlines                        = auto     # lf/crlf/cr/auto
+
+# The original size of tabs in the input.
+#
+# Default: 8
+input_tab_size                  = 8        # unsigned number
+
+# The size of tabs in the output (only used if align_with_tabs=true).
+#
+# Default: 8
+output_tab_size                 = 8        # unsigned number
+
+# The ASCII value of the string escape char, usually 92 (\) or (Pawn) 94 (^).
+#
+# Default: 92
+string_escape_char              = 92       # unsigned number
+
+# Alternate string escape char (usually only used for Pawn).
+# Only works right before the quote char.
+string_escape_char2             = 0        # unsigned number
+
+# Replace tab characters found in string literals with the escape sequence \t
+# instead.
+string_replace_tab_chars        = false    # true/false
+
+# Allow interpreting '>=' and '>>=' as part of a template in code like
+# 'void f(list<list<B>>=val);'. If true, 'assert(x<0 && y>=3)' will be broken.
+# Improvements to template detection may make this option obsolete.
+tok_split_gte                   = false    # true/false
+
+# Specify the marker used in comments to disable processing of part of the
+# file.
+#
+# Default:  *INDENT-OFF*
+disable_processing_cmt          = " *FORMAT-OFF*"      # string
+
+# Specify the marker used in comments to (re)enable processing in a file.
+#
+# Default:  *INDENT-ON*
+enable_processing_cmt           = " *FORMAT-ON*"     # string
+
+# Enable parsing of digraphs.
+enable_digraphs                 = false    # true/false
+
+# Add or remove the UTF-8 BOM (recommend 'remove').
+utf8_bom                        = ignore   # ignore/add/remove/force
+
+# If the file contains bytes with values between 128 and 255, but is not
+# UTF-8, then output as UTF-8.
+utf8_byte                       = false    # true/false
+
+# Force the output encoding to UTF-8.
+utf8_force                      = false    # true/false
+
+# Add or remove space between 'do' and '{'.
+sp_do_brace_open                = force    # ignore/add/remove/force
+
+# Add or remove space between '}' and 'while'.
+sp_brace_close_while            = force    # ignore/add/remove/force
+
+# Add or remove space between 'while' and '('.
+sp_while_paren_open             = force    # ignore/add/remove/force
+
+#
+# Spacing options
+#
+
+# Add or remove space around non-assignment symbolic operators ('+', '/', '%',
+# '<<', and so forth).
+sp_arith                        = force    # ignore/add/remove/force
+
+# Add or remove space around arithmetic operators '+' and '-'.
+#
+# Overrides sp_arith.
+sp_arith_additive               = force    # ignore/add/remove/force
+
+# Add or remove space around assignment operator '=', '+=', etc.
+sp_assign                       = force    # ignore/add/remove/force
+
+# Add or remove space around '=' in C++11 lambda capture specifications.
+#
+# Overrides sp_assign.
+sp_cpp_lambda_assign            = ignore   # ignore/add/remove/force
+
+# Add or remove space after the capture specification of a C++11 lambda when
+# an argument list is present, as in '[] <here> (int x){ ... }'.
+sp_cpp_lambda_square_paren      = ignore   # ignore/add/remove/force
+
+# Add or remove space after the capture specification of a C++11 lambda with
+# no argument list is present, as in '[] <here> { ... }'.
+sp_cpp_lambda_square_brace      = ignore   # ignore/add/remove/force
+
+# Add or remove space after the argument list of a C++11 lambda, as in
+# '[](int x) <here> { ... }'.
+sp_cpp_lambda_paren_brace       = ignore   # ignore/add/remove/force
+
+# Add or remove space between a lambda body and its call operator of an
+# immediately invoked lambda, as in '[]( ... ){ ... } <here> ( ... )'.
+sp_cpp_lambda_fparen            = ignore   # ignore/add/remove/force
+
+# Add or remove space around assignment operator '=' in a prototype.
+#
+# If set to ignore, use sp_assign.
+sp_assign_default               = ignore   # ignore/add/remove/force
+
+# Add or remove space before assignment operator '=', '+=', etc.
+#
+# Overrides sp_assign.
+sp_before_assign                = ignore   # ignore/add/remove/force
+
+# Add or remove space after assignment operator '=', '+=', etc.
+#
+# Overrides sp_assign.
+sp_after_assign                 = ignore   # ignore/add/remove/force
+
+# Add or remove space in 'NS_ENUM ('.
+sp_enum_paren                   = ignore   # ignore/add/remove/force
+
+# Add or remove space around assignment '=' in enum.
+sp_enum_assign                  = ignore   # ignore/add/remove/force
+
+# Add or remove space before assignment '=' in enum.
+#
+# Overrides sp_enum_assign.
+sp_enum_before_assign           = ignore   # ignore/add/remove/force
+
+# Add or remove space after assignment '=' in enum.
+#
+# Overrides sp_enum_assign.
+sp_enum_after_assign            = ignore   # ignore/add/remove/force
+
+# Add or remove space around assignment ':' in enum.
+sp_enum_colon                   = ignore   # ignore/add/remove/force
+
+# Add or remove space around preprocessor '##' concatenation operator.
+#
+# Default: add
+sp_pp_concat                    = remove   # ignore/add/remove/force
+
+# Add or remove space after preprocessor '#' stringify operator.
+# Also affects the '#@' charizing operator.
+sp_pp_stringify                 = ignore   # ignore/add/remove/force
+
+# Add or remove space before preprocessor '#' stringify operator
+# as in '#define x(y) L#y'.
+sp_before_pp_stringify          = ignore   # ignore/add/remove/force
+
+# Add or remove space around boolean operators '&&' and '||'.
+sp_bool                         = force    # ignore/add/remove/force
+
+# Add or remove space around compare operator '<', '>', '==', etc.
+sp_compare                      = force    # ignore/add/remove/force
+
+# Add or remove space inside '(' and ')'.
+sp_inside_paren                 = remove   # ignore/add/remove/force
+
+# Add or remove space between nested parentheses, i.e. '((' vs. ') )'.
+sp_paren_paren                  = remove   # ignore/add/remove/force
+
+# Add or remove space between back-to-back parentheses, i.e. ')(' vs. ') ('.
+sp_cparen_oparen                = ignore   # ignore/add/remove/force
+
+# Whether to balance spaces inside nested parentheses.
+sp_balance_nested_parens        = false    # true/false
+
+# Add or remove space between ')' and '{'.
+sp_paren_brace                  = force    # ignore/add/remove/force
+
+# Add or remove space between nested braces, i.e. '{{' vs '{ {'.
+sp_brace_brace                  = force    # ignore/add/remove/force
+
+# Add or remove space before pointer star '*'.
+sp_before_ptr_star              = force    # ignore/add/remove/force
+
+# Add or remove space before pointer star '*' that isn't followed by a
+# variable name. If set to ignore, sp_before_ptr_star is used instead.
+sp_before_unnamed_ptr_star      = force    # ignore/add/remove/force
+
+# Add or remove space between pointer stars '*'.
+sp_between_ptr_star             = remove   # ignore/add/remove/force
+
+# Add or remove space after pointer star '*', if followed by a word.
+#
+# Overrides sp_type_func.
+sp_after_ptr_star               = remove   # ignore/add/remove/force
+
+# Add or remove space after pointer caret '^', if followed by a word.
+sp_after_ptr_block_caret        = ignore   # ignore/add/remove/force
+
+# Add or remove space after pointer star '*', if followed by a qualifier.
+sp_after_ptr_star_qualifier     = remove   # ignore/add/remove/force
+
+# Add or remove space after a pointer star '*', if followed by a function
+# prototype or function definition.
+#
+# Overrides sp_after_ptr_star and sp_type_func.
+sp_after_ptr_star_func          = ignore   # ignore/add/remove/force
+
+# Add or remove space after a pointer star '*', if followed by an open
+# parenthesis, as in 'void* (*)().
+sp_ptr_star_paren               = ignore   # ignore/add/remove/force
+
+# Add or remove space before a pointer star '*', if followed by a function
+# prototype or function definition.
+sp_before_ptr_star_func         = force    # ignore/add/remove/force
+
+# Add or remove space before a reference sign '&'.
+sp_before_byref                 = ignore   # ignore/add/remove/force
+
+# Add or remove space before a reference sign '&' that isn't followed by a
+# variable name. If set to ignore, sp_before_byref is used instead.
+sp_before_unnamed_byref         = ignore   # ignore/add/remove/force
+
+# Add or remove space after reference sign '&', if followed by a word.
+#
+# Overrides sp_type_func.
+sp_after_byref                  = ignore   # ignore/add/remove/force
+
+# Add or remove space after a reference sign '&', if followed by a function
+# prototype or function definition.
+#
+# Overrides sp_after_byref and sp_type_func.
+sp_after_byref_func             = ignore   # ignore/add/remove/force
+
+# Add or remove space before a reference sign '&', if followed by a function
+# prototype or function definition.
+sp_before_byref_func            = ignore   # ignore/add/remove/force
+
+# Add or remove space between type and word.
+#
+# Default: force
+sp_after_type                   = force    # ignore/add/remove/force
+
+# Add or remove space between 'decltype(...)' and word.
+sp_after_decltype               = ignore   # ignore/add/remove/force
+
+# (D) Add or remove space before the parenthesis in the D constructs
+# 'template Foo(' and 'class Foo('.
+sp_before_template_paren        = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'template' and '<'.
+# If set to ignore, sp_before_angle is used.
+sp_template_angle               = ignore   # ignore/add/remove/force
+
+# Add or remove space before '<'.
+sp_before_angle                 = ignore   # ignore/add/remove/force
+
+# Add or remove space inside '<' and '>'.
+sp_inside_angle                 = ignore   # ignore/add/remove/force
+
+# Add or remove space inside '<>'.
+sp_inside_angle_empty           = ignore   # ignore/add/remove/force
+
+# Add or remove space between '>' and ':'.
+sp_angle_colon                  = ignore   # ignore/add/remove/force
+
+# Add or remove space after '>'.
+sp_after_angle                  = ignore   # ignore/add/remove/force
+
+# Add or remove space between '>' and '(' as found in 'new List<byte>(foo);'.
+sp_angle_paren                  = ignore   # ignore/add/remove/force
+
+# Add or remove space between '>' and '()' as found in 'new List<byte>();'.
+sp_angle_paren_empty            = ignore   # ignore/add/remove/force
+
+# Add or remove space between '>' and a word as in 'List<byte> m;' or
+# 'template <typename T> static ...'.
+sp_angle_word                   = ignore   # ignore/add/remove/force
+
+# Add or remove space between '>' and '>' in '>>' (template stuff).
+#
+# Default: add
+sp_angle_shift                  = add      # ignore/add/remove/force
+
+# (C++11) Permit removal of the space between '>>' in 'foo<bar<int> >'. Note
+# that sp_angle_shift cannot remove the space without this option.
+sp_permit_cpp11_shift           = false    # true/false
+
+# Add or remove space before '(' of control statements ('if', 'for', 'switch',
+# 'while', etc.).
+sp_before_sparen                = force    # ignore/add/remove/force
+
+# Add or remove space inside '(' and ')' of control statements.
+sp_inside_sparen                = remove   # ignore/add/remove/force
+
+# Add or remove space after '(' of control statements.
+#
+# Overrides sp_inside_sparen.
+sp_inside_sparen_open           = ignore   # ignore/add/remove/force
+
+# Add or remove space before ')' of control statements.
+#
+# Overrides sp_inside_sparen.
+sp_inside_sparen_close          = ignore   # ignore/add/remove/force
+
+# Add or remove space after ')' of control statements.
+sp_after_sparen                 = ignore   # ignore/add/remove/force
+
+# Add or remove space between ')' and '{' of of control statements.
+sp_sparen_brace                 = force    # ignore/add/remove/force
+
+# (D) Add or remove space between 'invariant' and '('.
+sp_invariant_paren              = ignore   # ignore/add/remove/force
+
+# (D) Add or remove space after the ')' in 'invariant (C) c'.
+sp_after_invariant_paren        = ignore   # ignore/add/remove/force
+
+# Add or remove space before empty statement ';' on 'if', 'for' and 'while'.
+sp_special_semi                 = ignore   # ignore/add/remove/force
+
+# Add or remove space before ';'.
+#
+# Default: remove
+sp_before_semi                  = remove   # ignore/add/remove/force
+
+# Add or remove space before ';' in non-empty 'for' statements.
+sp_before_semi_for              = ignore   # ignore/add/remove/force
+
+# Add or remove space before a semicolon of an empty part of a for statement.
+sp_before_semi_for_empty        = ignore   # ignore/add/remove/force
+
+# Add or remove space after ';', except when followed by a comment.
+#
+# Default: add
+sp_after_semi                   = add      # ignore/add/remove/force
+
+# Add or remove space after ';' in non-empty 'for' statements.
+#
+# Default: force
+sp_after_semi_for               = force    # ignore/add/remove/force
+
+# Add or remove space after the final semicolon of an empty part of a for
+# statement, as in 'for ( ; ; <here> )'.
+sp_after_semi_for_empty         = ignore   # ignore/add/remove/force
+
+# Add or remove space before '[' (except '[]').
+sp_before_square                = ignore   # ignore/add/remove/force
+
+# Add or remove space before '[' for a variable definition.
+#
+# Default: remove
+sp_before_vardef_square         = remove   # ignore/add/remove/force
+
+# Add or remove space before '[' for asm block.
+sp_before_square_asm_block      = ignore   # ignore/add/remove/force
+
+# Add or remove space before '[]'.
+sp_before_squares               = ignore   # ignore/add/remove/force
+
+# Add or remove space before C++17 structured bindings.
+sp_cpp_before_struct_binding    = ignore   # ignore/add/remove/force
+
+# Add or remove space inside a non-empty '[' and ']'.
+sp_inside_square                = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space inside a non-empty Objective-C boxed array '@[' and
+# ']'. If set to ignore, sp_inside_square is used.
+sp_inside_square_oc_array       = ignore   # ignore/add/remove/force
+
+# Add or remove space after ',', i.e. 'a,b' vs. 'a, b'.
+sp_after_comma                  = ignore   # ignore/add/remove/force
+
+# Add or remove space before ','.
+#
+# Default: remove
+sp_before_comma                 = remove   # ignore/add/remove/force
+
+# (C#) Add or remove space between ',' and ']' in multidimensional array type
+# like 'int[,,]'.
+sp_after_mdatype_commas         = ignore   # ignore/add/remove/force
+
+# (C#) Add or remove space between '[' and ',' in multidimensional array type
+# like 'int[,,]'.
+sp_before_mdatype_commas        = ignore   # ignore/add/remove/force
+
+# (C#) Add or remove space between ',' in multidimensional array type
+# like 'int[,,]'.
+sp_between_mdatype_commas       = ignore   # ignore/add/remove/force
+
+# Add or remove space between an open parenthesis and comma,
+# i.e. '(,' vs. '( ,'.
+#
+# Default: force
+sp_paren_comma                  = force    # ignore/add/remove/force
+
+# Add or remove space before the variadic '...' when preceded by a
+# non-punctuator.
+sp_before_ellipsis              = ignore   # ignore/add/remove/force
+
+# Add or remove space between a type and '...'.
+sp_type_ellipsis                = ignore   # ignore/add/remove/force
+
+# (D) Add or remove space between a type and '?'.
+sp_type_question                = ignore   # ignore/add/remove/force
+
+# Add or remove space between ')' and '...'.
+sp_paren_ellipsis               = ignore   # ignore/add/remove/force
+
+# Add or remove space between ')' and a qualifier such as 'const'.
+sp_paren_qualifier              = ignore   # ignore/add/remove/force
+
+# Add or remove space between ')' and 'noexcept'.
+sp_paren_noexcept               = ignore   # ignore/add/remove/force
+
+# Add or remove space after class ':'.
+sp_after_class_colon            = ignore   # ignore/add/remove/force
+
+# Add or remove space before class ':'.
+sp_before_class_colon           = ignore   # ignore/add/remove/force
+
+# Add or remove space after class constructor ':'.
+sp_after_constr_colon           = ignore   # ignore/add/remove/force
+
+# Add or remove space before class constructor ':'.
+sp_before_constr_colon          = ignore   # ignore/add/remove/force
+
+# Add or remove space before case ':'.
+#
+# Default: remove
+sp_before_case_colon            = remove   # ignore/add/remove/force
+
+# Add or remove space between 'operator' and operator sign.
+sp_after_operator               = ignore   # ignore/add/remove/force
+
+# Add or remove space between the operator symbol and the open parenthesis, as
+# in 'operator ++('.
+sp_after_operator_sym           = ignore   # ignore/add/remove/force
+
+# Overrides sp_after_operator_sym when the operator has no arguments, as in
+# 'operator *()'.
+sp_after_operator_sym_empty     = ignore   # ignore/add/remove/force
+
+# Add or remove space after C/D cast, i.e. 'cast(int)a' vs. 'cast(int) a' or
+# '(int)a' vs. '(int) a'.
+sp_after_cast                   = remove   # ignore/add/remove/force
+
+# Add or remove spaces inside cast parentheses.
+sp_inside_paren_cast            = remove   # ignore/add/remove/force
+
+# Add or remove space between the type and open parenthesis in a C++ cast,
+# i.e. 'int(exp)' vs. 'int (exp)'.
+sp_cpp_cast_paren               = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'sizeof' and '('.
+sp_sizeof_paren                 = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'sizeof' and '...'.
+sp_sizeof_ellipsis              = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'sizeof...' and '('.
+sp_sizeof_ellipsis_paren        = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'decltype' and '('.
+sp_decltype_paren               = ignore   # ignore/add/remove/force
+
+# (Pawn) Add or remove space after the tag keyword.
+sp_after_tag                    = ignore   # ignore/add/remove/force
+
+# Add or remove space inside enum '{' and '}'.
+sp_inside_braces_enum           = ignore   # ignore/add/remove/force
+
+# Add or remove space inside struct/union '{' and '}'.
+sp_inside_braces_struct         = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space inside Objective-C boxed dictionary '{' and '}'
+sp_inside_braces_oc_dict        = ignore   # ignore/add/remove/force
+
+# Add or remove space after open brace in an unnamed temporary
+# direct-list-initialization.
+sp_after_type_brace_init_lst_open = ignore   # ignore/add/remove/force
+
+# Add or remove space before close brace in an unnamed temporary
+# direct-list-initialization.
+sp_before_type_brace_init_lst_close = ignore   # ignore/add/remove/force
+
+# Add or remove space inside an unnamed temporary direct-list-initialization.
+sp_inside_type_brace_init_lst   = ignore   # ignore/add/remove/force
+
+# Add or remove space inside '{' and '}'.
+sp_inside_braces                = ignore   # ignore/add/remove/force
+
+# Add or remove space inside '{}'.
+sp_inside_braces_empty          = ignore   # ignore/add/remove/force
+
+# Add or remove space around trailing return operator '->'.
+sp_trailing_return              = ignore   # ignore/add/remove/force
+
+# Add or remove space between return type and function name. A minimum of 1
+# is forced except for pointer return types.
+sp_type_func                    = ignore   # ignore/add/remove/force
+
+# Add or remove space between type and open brace of an unnamed temporary
+# direct-list-initialization.
+sp_type_brace_init_lst          = ignore   # ignore/add/remove/force
+
+# Add or remove space between function name and '(' on function declaration.
+sp_func_proto_paren             = remove   # ignore/add/remove/force
+
+# Add or remove space between function name and '()' on function declaration
+# without parameters.
+sp_func_proto_paren_empty       = ignore   # ignore/add/remove/force
+
+# Add or remove space between function name and '(' with a typedef specifier.
+sp_func_type_paren              = ignore   # ignore/add/remove/force
+
+# Add or remove space between alias name and '(' of a non-pointer function type typedef.
+sp_func_def_paren               = ignore   # ignore/add/remove/force
+
+# Add or remove space between function name and '()' on function definition
+# without parameters.
+sp_func_def_paren_empty         = ignore   # ignore/add/remove/force
+
+# Add or remove space inside empty function '()'.
+# Overrides sp_after_angle unless use_sp_after_angle_always is set to true.
+sp_inside_fparens               = ignore   # ignore/add/remove/force
+
+# Add or remove space inside function '(' and ')'.
+sp_inside_fparen                = remove   # ignore/add/remove/force
+
+# Add or remove space inside the first parentheses in a function type, as in
+# 'void (*x)(...)'.
+sp_inside_tparen                = ignore   # ignore/add/remove/force
+
+# Add or remove space between the ')' and '(' in a function type, as in
+# 'void (*x)(...)'.
+sp_after_tparen_close           = ignore   # ignore/add/remove/force
+
+# Add or remove space between ']' and '(' when part of a function call.
+sp_square_fparen                = ignore   # ignore/add/remove/force
+
+# Add or remove space between ')' and '{' of function.
+sp_fparen_brace                 = force    # ignore/add/remove/force
+
+# Add or remove space between ')' and '{' of s function call in object
+# initialization.
+#
+# Overrides sp_fparen_brace.
+sp_fparen_brace_initializer     = ignore   # ignore/add/remove/force
+
+# (Java) Add or remove space between ')' and '{{' of double brace initializer.
+sp_fparen_dbrace                = ignore   # ignore/add/remove/force
+
+# Add or remove space between function name and '(' on function calls.
+sp_func_call_paren              = ignore   # ignore/add/remove/force
+
+# Add or remove space between function name and '()' on function calls without
+# parameters. If set to ignore (the default), sp_func_call_paren is used.
+sp_func_call_paren_empty        = ignore   # ignore/add/remove/force
+
+# Add or remove space between the user function name and '(' on function
+# calls. You need to set a keyword to be a user function in the config file,
+# like:
+#   set func_call_user tr _ i18n
+sp_func_call_user_paren         = ignore   # ignore/add/remove/force
+
+# Add or remove space inside user function '(' and ')'.
+sp_func_call_user_inside_fparen = ignore   # ignore/add/remove/force
+
+# Add or remove space between nested parentheses with user functions,
+# i.e. '((' vs. '( ('.
+sp_func_call_user_paren_paren   = ignore   # ignore/add/remove/force
+
+# Add or remove space between a constructor/destructor and the open
+# parenthesis.
+sp_func_class_paren             = ignore   # ignore/add/remove/force
+
+# Add or remove space between a constructor without parameters or destructor
+# and '()'.
+sp_func_class_paren_empty       = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'return' and '('.
+sp_return_paren                 = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'return' and '{'.
+sp_return_brace                 = ignore   # ignore/add/remove/force
+
+# Add or remove space between '__attribute__' and '('.
+sp_attribute_paren              = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'defined' and '(' in '#if defined (FOO)'.
+sp_defined_paren                = remove   # ignore/add/remove/force
+
+# Add or remove space between 'throw' and '(' in 'throw (something)'.
+sp_throw_paren                  = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'throw' and anything other than '(' as in
+# '@throw [...];'.
+sp_after_throw                  = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'catch' and '(' in 'catch (something) { }'.
+# If set to ignore, sp_before_sparen is used.
+sp_catch_paren                  = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space between '@catch' and '('
+# in '@catch (something) { }'. If set to ignore, sp_catch_paren is used.
+sp_oc_catch_paren               = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space between class name and '('
+# in '@interface className(categoryName)<ProtocolName>:BaseClass'
+sp_oc_classname_paren           = ignore   # ignore/add/remove/force
+
+# (D) Add or remove space between 'version' and '('
+# in 'version (something) { }'. If set to ignore, sp_before_sparen is used.
+sp_version_paren                = ignore   # ignore/add/remove/force
+
+# (D) Add or remove space between 'scope' and '('
+# in 'scope (something) { }'. If set to ignore, sp_before_sparen is used.
+sp_scope_paren                  = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'super' and '(' in 'super (something)'.
+#
+# Default: remove
+sp_super_paren                  = remove   # ignore/add/remove/force
+
+# Add or remove space between 'this' and '(' in 'this (something)'.
+#
+# Default: remove
+sp_this_paren                   = remove   # ignore/add/remove/force
+
+# Add or remove space between a macro name and its definition.
+sp_macro                        = ignore   # ignore/add/remove/force
+
+# Add or remove space between a macro function ')' and its definition.
+sp_macro_func                   = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'else' and '{' if on the same line.
+sp_else_brace                   = force    # ignore/add/remove/force
+
+# Add or remove space between '}' and 'else' if on the same line.
+sp_brace_else                   = force    # ignore/add/remove/force
+
+# Add or remove space between '}' and the name of a typedef on the same line.
+sp_brace_typedef                = ignore   # ignore/add/remove/force
+
+# Add or remove space before the '{' of a 'catch' statement, if the '{' and
+# 'catch' are on the same line, as in 'catch (decl) <here> {'.
+sp_catch_brace                  = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space before the '{' of a '@catch' statement, if the '{'
+# and '@catch' are on the same line, as in '@catch (decl) <here> {'.
+# If set to ignore, sp_catch_brace is used.
+sp_oc_catch_brace               = ignore   # ignore/add/remove/force
+
+# Add or remove space between '}' and 'catch' if on the same line.
+sp_brace_catch                  = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space between '}' and '@catch' if on the same line.
+# If set to ignore, sp_brace_catch is used.
+sp_oc_brace_catch               = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'finally' and '{' if on the same line.
+sp_finally_brace                = ignore   # ignore/add/remove/force
+
+# Add or remove space between '}' and 'finally' if on the same line.
+sp_brace_finally                = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'try' and '{' if on the same line.
+sp_try_brace                    = ignore   # ignore/add/remove/force
+
+# Add or remove space between get/set and '{' if on the same line.
+sp_getset_brace                 = ignore   # ignore/add/remove/force
+
+# Add or remove space between a variable and '{' for C++ uniform
+# initialization.
+#
+# Default: add
+sp_word_brace                   = add      # ignore/add/remove/force
+
+# Add or remove space between a variable and '{' for a namespace.
+#
+# Default: add
+sp_word_brace_ns                = add      # ignore/add/remove/force
+
+# Add or remove space before the '::' operator.
+sp_before_dc                    = ignore   # ignore/add/remove/force
+
+# Add or remove space after the '::' operator.
+sp_after_dc                     = ignore   # ignore/add/remove/force
+
+# (D) Add or remove around the D named array initializer ':' operator.
+sp_d_array_colon                = ignore   # ignore/add/remove/force
+
+# Add or remove space after the '!' (not) unary operator.
+#
+# Default: remove
+sp_not                          = remove   # ignore/add/remove/force
+
+# Add or remove space after the '~' (invert) unary operator.
+#
+# Default: remove
+sp_inv                          = remove   # ignore/add/remove/force
+
+# Add or remove space after the '&' (address-of) unary operator. This does not
+# affect the spacing after a '&' that is part of a type.
+#
+# Default: remove
+sp_addr                         = remove   # ignore/add/remove/force
+
+# Add or remove space around the '.' or '->' operators.
+#
+# Default: remove
+sp_member                       = remove   # ignore/add/remove/force
+
+# Add or remove space after the '*' (dereference) unary operator. This does
+# not affect the spacing after a '*' that is part of a type.
+#
+# Default: remove
+sp_deref                        = remove   # ignore/add/remove/force
+
+# Add or remove space after '+' or '-', as in 'x = -5' or 'y = +7'.
+#
+# Default: remove
+sp_sign                         = remove   # ignore/add/remove/force
+
+# Add or remove space between '++' and '--' the word to which it is being
+# applied, as in '(--x)' or 'y++;'.
+#
+# Default: remove
+sp_incdec                       = remove   # ignore/add/remove/force
+
+# Add or remove space before a backslash-newline at the end of a line.
+#
+# Default: add
+sp_before_nl_cont               = add      # ignore/add/remove/force
+
+# (OC) Add or remove space after the scope '+' or '-', as in '-(void) foo;'
+# or '+(int) bar;'.
+sp_after_oc_scope               = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space after the colon in message specs,
+# i.e. '-(int) f:(int) x;' vs. '-(int) f: (int) x;'.
+sp_after_oc_colon               = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space before the colon in message specs,
+# i.e. '-(int) f: (int) x;' vs. '-(int) f : (int) x;'.
+sp_before_oc_colon              = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space after the colon in immutable dictionary expression
+# 'NSDictionary *test = @{@"foo" :@"bar"};'.
+sp_after_oc_dict_colon          = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space before the colon in immutable dictionary expression
+# 'NSDictionary *test = @{@"foo" :@"bar"};'.
+sp_before_oc_dict_colon         = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space after the colon in message specs,
+# i.e. '[object setValue:1];' vs. '[object setValue: 1];'.
+sp_after_send_oc_colon          = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space before the colon in message specs,
+# i.e. '[object setValue:1];' vs. '[object setValue :1];'.
+sp_before_send_oc_colon         = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space after the (type) in message specs,
+# i.e. '-(int)f: (int) x;' vs. '-(int)f: (int)x;'.
+sp_after_oc_type                = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space after the first (type) in message specs,
+# i.e. '-(int) f:(int)x;' vs. '-(int)f:(int)x;'.
+sp_after_oc_return_type         = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space between '@selector' and '(',
+# i.e. '@selector(msgName)' vs. '@selector (msgName)'.
+# Also applies to '@protocol()' constructs.
+sp_after_oc_at_sel              = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space between '@selector(x)' and the following word,
+# i.e. '@selector(foo) a:' vs. '@selector(foo)a:'.
+sp_after_oc_at_sel_parens       = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space inside '@selector' parentheses,
+# i.e. '@selector(foo)' vs. '@selector( foo )'.
+# Also applies to '@protocol()' constructs.
+sp_inside_oc_at_sel_parens      = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space before a block pointer caret,
+# i.e. '^int (int arg){...}' vs. ' ^int (int arg){...}'.
+sp_before_oc_block_caret        = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space after a block pointer caret,
+# i.e. '^int (int arg){...}' vs. '^ int (int arg){...}'.
+sp_after_oc_block_caret         = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space between the receiver and selector in a message,
+# as in '[receiver selector ...]'.
+sp_after_oc_msg_receiver        = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space after '@property'.
+sp_after_oc_property            = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove space between '@synchronized' and the open parenthesis,
+# i.e. '@synchronized(foo)' vs. '@synchronized (foo)'.
+sp_after_oc_synchronized        = ignore   # ignore/add/remove/force
+
+# Add or remove space around the ':' in 'b ? t : f'.
+sp_cond_colon                   = ignore   # ignore/add/remove/force
+
+# Add or remove space before the ':' in 'b ? t : f'.
+#
+# Overrides sp_cond_colon.
+sp_cond_colon_before            = ignore   # ignore/add/remove/force
+
+# Add or remove space after the ':' in 'b ? t : f'.
+#
+# Overrides sp_cond_colon.
+sp_cond_colon_after             = ignore   # ignore/add/remove/force
+
+# Add or remove space around the '?' in 'b ? t : f'.
+sp_cond_question                = ignore   # ignore/add/remove/force
+
+# Add or remove space before the '?' in 'b ? t : f'.
+#
+# Overrides sp_cond_question.
+sp_cond_question_before         = ignore   # ignore/add/remove/force
+
+# Add or remove space after the '?' in 'b ? t : f'.
+#
+# Overrides sp_cond_question.
+sp_cond_question_after          = ignore   # ignore/add/remove/force
+
+# In the abbreviated ternary form '(a ?: b)', add or remove space between '?'
+# and ':'.
+#
+# Overrides all other sp_cond_* options.
+sp_cond_ternary_short           = ignore   # ignore/add/remove/force
+
+# Fix the spacing between 'case' and the label. Only 'ignore' and 'force' make
+# sense here.
+sp_case_label                   = ignore   # ignore/add/remove/force
+
+# (D) Add or remove space around the D '..' operator.
+sp_range                        = ignore   # ignore/add/remove/force
+
+# Add or remove space after ':' in a Java/C++11 range-based 'for',
+# as in 'for (Type var : expr)'.
+sp_after_for_colon              = ignore   # ignore/add/remove/force
+
+# Add or remove space before ':' in a Java/C++11 range-based 'for',
+# as in 'for (Type var : expr)'.
+sp_before_for_colon             = ignore   # ignore/add/remove/force
+
+# (D) Add or remove space between 'extern' and '(' as in 'extern (C)'.
+sp_extern_paren                 = ignore   # ignore/add/remove/force
+
+# Add or remove space after the opening of a C++ comment,
+# i.e. '// A' vs. '//A'.
+sp_cmt_cpp_start                = add      # ignore/add/remove/force
+
+# If true, space is added with sp_cmt_cpp_start will be added after doxygen
+# sequences like '///', '///<', '//!' and '//!<'.
+sp_cmt_cpp_doxygen              = false    # true/false
+
+# If true, space is added with sp_cmt_cpp_start will be added after Qt
+# translator or meta-data comments like '//:', '//=', and '//~'.
+sp_cmt_cpp_qttr                 = false    # true/false
+
+# Add or remove space between #else or #endif and a trailing comment.
+sp_endif_cmt                    = ignore   # ignore/add/remove/force
+
+# Add or remove space after 'new', 'delete' and 'delete[]'.
+sp_after_new                    = ignore   # ignore/add/remove/force
+
+# Add or remove space between 'new' and '(' in 'new()'.
+sp_between_new_paren            = ignore   # ignore/add/remove/force
+
+# Add or remove space between ')' and type in 'new(foo) BAR'.
+sp_after_newop_paren            = ignore   # ignore/add/remove/force
+
+# Add or remove space inside parenthesis of the new operator
+# as in 'new(foo) BAR'.
+sp_inside_newop_paren           = ignore   # ignore/add/remove/force
+
+# Add or remove space after the open parenthesis of the new operator,
+# as in 'new(foo) BAR'.
+#
+# Overrides sp_inside_newop_paren.
+sp_inside_newop_paren_open      = ignore   # ignore/add/remove/force
+
+# Add or remove space before the close parenthesis of the new operator,
+# as in 'new(foo) BAR'.
+#
+# Overrides sp_inside_newop_paren.
+sp_inside_newop_paren_close     = ignore   # ignore/add/remove/force
+
+# Add or remove space before a trailing or embedded comment.
+sp_before_tr_emb_cmt            = ignore   # ignore/add/remove/force
+
+# Number of spaces before a trailing or embedded comment.
+sp_num_before_tr_emb_cmt        = 0        # unsigned number
+
+# (Java) Add or remove space between an annotation and the open parenthesis.
+sp_annotation_paren             = ignore   # ignore/add/remove/force
+
+# If true, vbrace tokens are dropped to the previous token and skipped.
+sp_skip_vbrace_tokens           = false    # true/false
+
+# Add or remove space after 'noexcept'.
+sp_after_noexcept               = ignore   # ignore/add/remove/force
+
+# Add or remove space after '_'.
+sp_vala_after_translation       = ignore   # ignore/add/remove/force
+
+# If true, a <TAB> is inserted after #define.
+force_tab_after_define          = false    # true/false
+
+#
+# Indenting options
+#
+
+# The number of columns to indent per level. Usually 2, 3, 4, or 8.
+#
+# Default: 8
+indent_columns                  = 4        # unsigned number
+
+# The continuation indent. If non-zero, this overrides the indent of '(', '['
+# and '=' continuation indents. Negative values are OK; negative value is
+# absolute and not increased for each '(' or '[' level.
+#
+# For FreeBSD, this is set to 4.
+indent_continue                 = 0        # number
+
+# The continuation indent, only for class header line(s). If non-zero, this
+# overrides the indent of 'class' continuation indents.
+indent_continue_class_head      = 0        # unsigned number
+
+# Whether to indent empty lines (i.e. lines which contain only spaces before
+# the newline character).
+indent_single_newlines          = false    # true/false
+
+# The continuation indent for func_*_param if they are true. If non-zero, this
+# overrides the indent.
+indent_param                    = 0        # unsigned number
+
+# How to use tabs when indenting code.
+#
+# 0: Spaces only
+# 1: Indent with tabs to brace level, align with spaces (default)
+# 2: Indent and align with tabs, using spaces when not on a tabstop
+#
+# Default: 1
+indent_with_tabs                = 0        # unsigned number
+
+# Whether to indent comments that are not at a brace level with tabs on a
+# tabstop. Requires indent_with_tabs=2. If false, will use spaces.
+indent_cmt_with_tabs            = false    # true/false
+
+# Whether to indent strings broken by '\' so that they line up.
+indent_align_string             = false    # true/false
+
+# The number of spaces to indent multi-line XML strings.
+# Requires indent_align_string=true.
+indent_xml_string               = 0        # unsigned number
+
+# Spaces to indent '{' from level.
+indent_brace                    = 0        # unsigned number
+
+# Whether braces are indented to the body level.
+indent_braces                   = false    # true/false
+
+# Whether to disable indenting function braces if indent_braces=true.
+indent_braces_no_func           = false    # true/false
+
+# Whether to disable indenting class braces if indent_braces=true.
+indent_braces_no_class          = false    # true/false
+
+# Whether to disable indenting struct braces if indent_braces=true.
+indent_braces_no_struct         = false    # true/false
+
+# Whether to indent based on the size of the brace parent,
+# i.e. 'if' => 3 spaces, 'for' => 4 spaces, etc.
+indent_brace_parent             = false    # true/false
+
+# Whether to indent based on the open parenthesis instead of the open brace
+# in '({\n'.
+indent_paren_open_brace         = false    # true/false
+
+# (C#) Whether to indent the brace of a C# delegate by another level.
+indent_cs_delegate_brace        = false    # true/false
+
+# (C#) Whether to indent a C# delegate (to handle delegates with no brace) by
+# another level.
+indent_cs_delegate_body         = false    # true/false
+
+# Whether to indent the body of a 'namespace'.
+indent_namespace                = false    # true/false
+
+# Whether to indent only the first namespace, and not any nested namespaces.
+# Requires indent_namespace=true.
+indent_namespace_single_indent  = false    # true/false
+
+# The number of spaces to indent a namespace block.
+# If set to zero, use the value indent_columns
+indent_namespace_level          = 0        # unsigned number
+
+# If the body of the namespace is longer than this number, it won't be
+# indented. Requires indent_namespace=true. 0 means no limit.
+indent_namespace_limit          = 0        # unsigned number
+
+# Whether the 'extern "C"' body is indented.
+indent_extern                   = false    # true/false
+
+# Whether the 'class' body is indented.
+indent_class                    = false    # true/false
+
+# Whether to indent the stuff after a leading base class colon.
+indent_class_colon              = false    # true/false
+
+# Whether to indent based on a class colon instead of the stuff after the
+# colon. Requires indent_class_colon=true.
+indent_class_on_colon           = false    # true/false
+
+# Whether to indent the stuff after a leading class initializer colon.
+indent_constr_colon             = false    # true/false
+
+# Virtual indent from the ':' for member initializers.
+#
+# Default: 2
+indent_ctor_init_leading        = 2        # unsigned number
+
+# Additional indent for constructor initializer list.
+# Negative values decrease indent down to the first column.
+indent_ctor_init                = 0        # number
+
+# Whether to indent 'if' following 'else' as a new block under the 'else'.
+# If false, 'else\nif' is treated as 'else if' for indenting purposes.
+indent_else_if                  = false    # true/false
+
+# Amount to indent variable declarations after a open brace.
+#
+#  <0: Relative
+# >=0: Absolute
+indent_var_def_blk              = 0        # number
+
+# Whether to indent continued variable declarations instead of aligning.
+indent_var_def_cont             = false    # true/false
+
+# Whether to indent continued shift expressions ('<<' and '>>') instead of
+# aligning. Set align_left_shift=false when enabling this.
+indent_shift                    = false    # true/false
+
+# Whether to force indentation of function definitions to start in column 1.
+indent_func_def_force_col1      = false    # true/false
+
+# Whether to indent continued function call parameters one indent level,
+# rather than aligning parameters under the open parenthesis.
+indent_func_call_param          = true     # true/false
+
+# Whether to indent continued function definition parameters one indent level,
+# rather than aligning parameters under the open parenthesis.
+indent_func_def_param           = true     # true/false
+
+# for function definitions, only if indent_func_def_param is false
+# Allows to align params when appropriate and indent them when not
+# behave as if it was true if paren position is more than this value
+# if paren position is more than the option value
+indent_func_def_param_paren_pos_threshold = 0        # unsigned number
+
+# Whether to indent continued function call prototype one indent level,
+# rather than aligning parameters under the open parenthesis.
+indent_func_proto_param         = true     # true/false
+
+# Whether to indent continued function call declaration one indent level,
+# rather than aligning parameters under the open parenthesis.
+indent_func_class_param         = true     # true/false
+
+# Whether to indent continued class variable constructors one indent level,
+# rather than aligning parameters under the open parenthesis.
+indent_func_ctor_var_param      = true     # true/false
+
+# Whether to indent continued template parameter list one indent level,
+# rather than aligning parameters under the open parenthesis.
+indent_template_param           = true     # true/false
+
+# Double the indent for indent_func_xxx_param options.
+# Use both values of the options indent_columns and indent_param.
+indent_func_param_double        = false    # true/false
+
+# Indentation column for standalone 'const' qualifier on a function
+# prototype.
+indent_func_const               = 0        # unsigned number
+
+# Indentation column for standalone 'throw' qualifier on a function
+# prototype.
+indent_func_throw               = 0        # unsigned number
+
+# How to indent within a macro followed by a brace on the same line
+# This allows reducing the indent in macros that have (for example)
+# `do { ... } while (0)` blocks bracketing them.
+#
+# true:  add an indent for the brace on the same line as the macro
+# false: do not add an indent for the brace on the same line as the macro
+#
+# Default: true
+indent_macro_brace              = true     # true/false
+
+# The number of spaces to indent a continued '->' or '.'.
+# Usually set to 0, 1, or indent_columns.
+indent_member                   = 0        # unsigned number
+
+# Whether lines broken at '.' or '->' should be indented by a single indent.
+# The indent_member option will not be effective if this is set to true.
+indent_member_single            = false    # true/false
+
+# Spaces to indent single line ('//') comments on lines before code.
+indent_sing_line_comments       = 0        # unsigned number
+
+# Whether to indent trailing single line ('//') comments relative to the code
+# instead of trying to keep the same absolute column.
+indent_relative_single_line_comments = false    # true/false
+
+# Spaces to indent 'case' from 'switch'. Usually 0 or indent_columns.
+indent_switch_case              = indent_columns        # unsigned number
+
+# indent 'break' with 'case' from 'switch'.
+indent_switch_break_with_case   = false    # true/false
+
+# Whether to indent preprocessor statements inside of switch statements.
+#
+# Default: true
+indent_switch_pp                = true     # true/false
+
+# Spaces to shift the 'case' line, without affecting any other lines.
+# Usually 0.
+indent_case_shift               = 0        # unsigned number
+
+# Spaces to indent '{' from 'case'. By default, the brace will appear under
+# the 'c' in case. Usually set to 0 or indent_columns. Negative values are OK.
+indent_case_brace               = 0        # number
+
+# Whether to indent comments found in first column.
+indent_col1_comment             = false    # true/false
+
+# Whether to indent multi string literal in first column.
+indent_col1_multi_string_literal = false    # true/false
+
+# How to indent goto labels.
+#
+#  >0: Absolute column where 1 is the leftmost column
+# <=0: Subtract from brace indent
+#
+# Default: 1
+indent_label                    = -indent_columns # number
+
+# How to indent access specifiers that are followed by a
+# colon.
+#
+#  >0: Absolute column where 1 is the leftmost column
+# <=0: Subtract from brace indent
+#
+# Default: 1
+indent_access_spec              = 1        # number
+
+# Whether to indent the code after an access specifier by one level.
+# If true, this option forces 'indent_access_spec=0'.
+indent_access_spec_body         = false    # true/false
+
+# If an open parenthesis is followed by a newline, whether to indent the next
+# line so that it lines up after the open parenthesis (not recommended).
+indent_paren_nl                 = false    # true/false
+
+# How to indent a close parenthesis after a newline.
+#
+# 0: Indent to body level (default)
+# 1: Align under the open parenthesis
+# 2: Indent to the brace level
+indent_paren_close              = 0        # unsigned number
+
+# Whether to indent the open parenthesis of a function definition,
+# if the parenthesis is on its own line.
+indent_paren_after_func_def     = false    # true/false
+
+# Whether to indent the open parenthesis of a function declaration,
+# if the parenthesis is on its own line.
+indent_paren_after_func_decl    = false    # true/false
+
+# Whether to indent the open parenthesis of a function call,
+# if the parenthesis is on its own line.
+indent_paren_after_func_call    = false    # true/false
+
+# Whether to indent a comma when inside a parenthesis.
+# If true, aligns under the open parenthesis.
+indent_comma_paren              = false    # true/false
+
+# Whether to indent a Boolean operator when inside a parenthesis.
+# If true, aligns under the open parenthesis.
+indent_bool_paren               = false    # true/false
+
+# Whether to indent a semicolon when inside a for parenthesis.
+# If true, aligns under the open for parenthesis.
+indent_semicolon_for_paren      = false    # true/false
+
+# Whether to align the first expression to following ones
+# if indent_bool_paren=true.
+indent_first_bool_expr          = false    # true/false
+
+# Whether to align the first expression to following ones
+# if indent_semicolon_for_paren=true.
+indent_first_for_expr           = false    # true/false
+
+# If an open square is followed by a newline, whether to indent the next line
+# so that it lines up after the open square (not recommended).
+indent_square_nl                = false    # true/false
+
+# (ESQL/C) Whether to preserve the relative indent of 'EXEC SQL' bodies.
+indent_preserve_sql             = false    # true/false
+
+# Whether to align continued statements at the '='. If false or if the '=' is
+# followed by a newline, the next line is indent one tab.
+#
+# Default: true
+indent_align_assign             = false    # true/false
+
+# Whether to align continued statements at the '('. If false or the '(' is
+# followed by a newline, the next line indent is one tab.
+#
+# Default: true
+indent_align_paren              = false    # true/false
+
+# (OC) Whether to indent Objective-C blocks at brace level instead of usual
+# rules.
+indent_oc_block                 = false    # true/false
+
+# (OC) Indent for Objective-C blocks in a message relative to the parameter
+# name.
+#
+# =0: Use indent_oc_block rules
+# >0: Use specified number of spaces to indent
+indent_oc_block_msg             = 0        # unsigned number
+
+# (OC) Minimum indent for subsequent parameters
+indent_oc_msg_colon             = 0        # unsigned number
+
+# (OC) Whether to prioritize aligning with initial colon (and stripping spaces
+# from lines, if necessary).
+#
+# Default: true
+indent_oc_msg_prioritize_first_colon = true     # true/false
+
+# (OC) Whether to indent blocks the way that Xcode does by default
+# (from the keyword if the parameter is on its own line; otherwise, from the
+# previous indentation level). Requires indent_oc_block_msg=true.
+indent_oc_block_msg_xcode_style = false    # true/false
+
+# (OC) Whether to indent blocks from where the brace is, relative to a
+# message keyword. Requires indent_oc_block_msg=true.
+indent_oc_block_msg_from_keyword = false    # true/false
+
+# (OC) Whether to indent blocks from where the brace is, relative to a message
+# colon. Requires indent_oc_block_msg=true.
+indent_oc_block_msg_from_colon  = false    # true/false
+
+# (OC) Whether to indent blocks from where the block caret is.
+# Requires indent_oc_block_msg=true.
+indent_oc_block_msg_from_caret  = false    # true/false
+
+# (OC) Whether to indent blocks from where the brace caret is.
+# Requires indent_oc_block_msg=true.
+indent_oc_block_msg_from_brace  = false    # true/false
+
+# When indenting after virtual brace open and newline add further spaces to
+# reach this minimum indent.
+indent_min_vbrace_open          = 0        # unsigned number
+
+# Whether to add further spaces after regular indent to reach next tabstop
+# when identing after virtual brace open and newline.
+indent_vbrace_open_on_tabstop   = false    # true/false
+
+# How to indent after a brace followed by another token (not a newline).
+# true:  indent all contained lines to match the token
+# false: indent all contained lines to match the brace
+#
+# Default: true
+indent_token_after_brace        = true     # true/false
+
+# Whether to indent the body of a C++11 lambda.
+indent_cpp_lambda_body          = false    # true/false
+
+# (C#) Whether to indent a 'using' block if no braces are used.
+#
+# Default: true
+indent_using_block              = true     # true/false
+
+# How to indent the continuation of ternary operator.
+#
+# 0: Off (default)
+# 1: When the `if_false` is a continuation, indent it under `if_false`
+# 2: When the `:` is a continuation, indent it under `?`
+indent_ternary_operator         = 0        # unsigned number
+
+# If true, the indentation of the chunks after a `return new` sequence will be set at return indentation column.
+indent_off_after_return_new     = false    # true/false
+
+# If true, the tokens after return are indented with regular single indentation. By default (false) the indentation is after the return token.
+indent_single_after_return      = false    # true/false
+
+# Whether to ignore indent and alignment for 'asm' blocks (i.e. assume they
+# have their own indentation).
+indent_ignore_asm_block         = false    # true/false
+
+#
+# Newline adding and removing options
+#
+
+# Whether to collapse empty blocks between '{' and '}'.
+nl_collapse_empty_body          = false    # true/false
+
+# Don't split one-line braced assignments, as in 'foo_t f = { 1, 2 };'.
+nl_assign_leave_one_liners      = false    # true/false
+
+# Don't split one-line braced statements inside a 'class xx { }' body.
+nl_class_leave_one_liners       = false    # true/false
+
+# Don't split one-line enums, as in 'enum foo { BAR = 15 };'
+nl_enum_leave_one_liners        = false    # true/false
+
+# Don't split one-line get or set functions.
+nl_getset_leave_one_liners      = false    # true/false
+
+# (C#) Don't split one-line property get or set functions.
+nl_cs_property_leave_one_liners = false    # true/false
+
+# Don't split one-line function definitions, as in 'int foo() { return 0; }'.
+# night modify nl_func_type_name
+nl_func_leave_one_liners        = false    # true/false
+
+# Don't split one-line C++11 lambdas, as in '[]() { return 0; }'.
+nl_cpp_lambda_leave_one_liners  = false    # true/false
+
+# Don't split one-line if/else statements, as in 'if(...) b++;'.
+nl_if_leave_one_liners          = false    # true/false
+
+# Don't split one-line while statements, as in 'while(...) b++;'.
+nl_while_leave_one_liners       = false    # true/false
+
+# Don't split one-line for statements, as in 'for(...) b++;'.
+nl_for_leave_one_liners         = false    # true/false
+
+# (OC) Don't split one-line Objective-C messages.
+nl_oc_msg_leave_one_liner       = false    # true/false
+
+# (OC) Add or remove newline between method declaration and '{'.
+nl_oc_mdef_brace                = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove newline between Objective-C block signature and '{'.
+nl_oc_block_brace               = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove blank line before '@interface' statement.
+nl_oc_before_interface          = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove blank line before '@implementation' statement.
+nl_oc_before_implementation     = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove blank line before '@end' statement.
+nl_oc_before_end                = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove newline between '@interface' and '{'.
+nl_oc_interface_brace           = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove newline between '@implementation' and '{'.
+nl_oc_implementation_brace      = ignore   # ignore/add/remove/force
+
+# Add or remove newlines at the start of the file.
+nl_start_of_file                = ignore   # ignore/add/remove/force
+
+# The minimum number of newlines at the start of the file (only used if
+# nl_start_of_file is 'add' or 'force').
+nl_start_of_file_min            = 0        # unsigned number
+
+# Add or remove newline at the end of the file.
+nl_end_of_file                  = ignore   # ignore/add/remove/force
+
+# The minimum number of newlines at the end of the file (only used if
+# nl_end_of_file is 'add' or 'force').
+nl_end_of_file_min              = 0        # unsigned number
+
+# Add or remove newline between '=' and '{'.
+nl_assign_brace                 = ignore   # ignore/add/remove/force
+
+# (D) Add or remove newline between '=' and '['.
+nl_assign_square                = ignore   # ignore/add/remove/force
+
+# Add or remove newline between '[]' and '{'.
+nl_tsquare_brace                = ignore   # ignore/add/remove/force
+
+# (D) Add or remove newline after '= ['. Will also affect the newline before
+# the ']'.
+nl_after_square_assign          = ignore   # ignore/add/remove/force
+
+# Add or remove newline between a function call's ')' and '{', as in
+# 'list_for_each(item, &list) { }'.
+nl_fcall_brace                  = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'enum' and '{'.
+nl_enum_brace                   = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'enum' and 'class'.
+nl_enum_class                   = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'enum class' and the identifier.
+nl_enum_class_identifier        = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'enum class' type and ':'.
+nl_enum_identifier_colon        = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'enum class identifier :' and type.
+nl_enum_colon_type              = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'struct and '{'.
+nl_struct_brace                 = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'union' and '{'.
+nl_union_brace                  = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'if' and '{'.
+nl_if_brace                     = remove   # ignore/add/remove/force
+
+# Add or remove newline between '}' and 'else'.
+nl_brace_else                   = remove   # ignore/add/remove/force
+
+# Add or remove newline between 'else if' and '{'. If set to ignore,
+# nl_if_brace is used instead.
+nl_elseif_brace                 = remove   # ignore/add/remove/force
+
+# Add or remove newline between 'else' and '{'.
+nl_else_brace                   = remove   # ignore/add/remove/force
+
+# Add or remove newline between 'else' and 'if'.
+nl_else_if                      = ignore   # ignore/add/remove/force
+
+# Add or remove newline before 'if'/'else if' closing parenthesis.
+nl_before_if_closing_paren      = ignore   # ignore/add/remove/force
+
+# Add or remove newline between '}' and 'finally'.
+nl_brace_finally                = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'finally' and '{'.
+nl_finally_brace                = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'try' and '{'.
+nl_try_brace                    = ignore   # ignore/add/remove/force
+
+# Add or remove newline between get/set and '{'.
+nl_getset_brace                 = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'for' and '{'.
+nl_for_brace                    = ignore   # ignore/add/remove/force
+
+# Add or remove newline before the '{' of a 'catch' statement, as in
+# 'catch (decl) <here> {'.
+nl_catch_brace                  = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove newline before the '{' of a '@catch' statement, as in
+# '@catch (decl) <here> {'. If set to ignore, nl_catch_brace is used.
+nl_oc_catch_brace               = ignore   # ignore/add/remove/force
+
+# Add or remove newline between '}' and 'catch'.
+nl_brace_catch                  = ignore   # ignore/add/remove/force
+
+# (OC) Add or remove newline between '}' and '@catch'. If set to ignore,
+# nl_brace_catch is used.
+nl_oc_brace_catch               = ignore   # ignore/add/remove/force
+
+# Add or remove newline between '}' and ']'.
+nl_brace_square                 = ignore   # ignore/add/remove/force
+
+# Add or remove newline between '}' and ')' in a function invocation.
+nl_brace_fparen                 = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'while' and '{'.
+nl_while_brace                  = remove   # ignore/add/remove/force
+
+# (D) Add or remove newline between 'scope (x)' and '{'.
+nl_scope_brace                  = ignore   # ignore/add/remove/force
+
+# (D) Add or remove newline between 'unittest' and '{'.
+nl_unittest_brace               = ignore   # ignore/add/remove/force
+
+# (D) Add or remove newline between 'version (x)' and '{'.
+nl_version_brace                = ignore   # ignore/add/remove/force
+
+# (C#) Add or remove newline between 'using' and '{'.
+nl_using_brace                  = ignore   # ignore/add/remove/force
+
+# Add or remove newline between two open or close braces. Due to general
+# newline/brace handling, REMOVE may not work.
+nl_brace_brace                  = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'do' and '{'.
+nl_do_brace                     = ignore   # ignore/add/remove/force
+
+# Add or remove newline between '}' and 'while' of 'do' statement.
+nl_brace_while                  = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'switch' and '{'.
+nl_switch_brace                 = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'synchronized' and '{'.
+nl_synchronized_brace           = ignore   # ignore/add/remove/force
+
+# Add a newline between ')' and '{' if the ')' is on a different line than the
+# if/for/etc.
+#
+# Overrides nl_for_brace, nl_if_brace, nl_switch_brace, nl_while_switch and
+# nl_catch_brace.
+nl_multi_line_cond              = false    # true/false
+
+# Add a newline after '(' if an if/for/while/switch condition spans multiple
+# lines
+nl_multi_line_sparen_open       = ignore   # ignore/add/remove/force
+
+# Add a newline before ')' if an if/for/while/switch condition spans multiple
+# lines. Overrides nl_before_if_closing_paren if both are specified.
+nl_multi_line_sparen_close      = ignore   # ignore/add/remove/force
+
+# Force a newline in a define after the macro name for multi-line defines.
+nl_multi_line_define            = false    # true/false
+
+# Whether to add a newline before 'case', and a blank line before a 'case'
+# statement that follows a ';' or '}'.
+nl_before_case                  = false    # true/false
+
+# Whether to add a newline after a 'case' statement.
+nl_after_case                   = true     # true/false
+
+# Add or remove newline between a case ':' and '{'.
+#
+# Overrides nl_after_case.
+nl_case_colon_brace             = remove   # ignore/add/remove/force
+
+# Add or remove newline between ')' and 'throw'.
+nl_before_throw                 = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'namespace' and '{'.
+nl_namespace_brace              = ignore   # ignore/add/remove/force
+
+# Add or remove newline after 'template<...>' of a template class.
+nl_template_class               = ignore   # ignore/add/remove/force
+
+# Add or remove newline after 'template<...>' of a template class declaration.
+#
+# Overrides nl_template_class.
+nl_template_class_decl          = ignore   # ignore/add/remove/force
+
+# Add or remove newline after 'template<>' of a specialized class declaration.
+#
+# Overrides nl_template_class_decl.
+nl_template_class_decl_special  = ignore   # ignore/add/remove/force
+
+# Add or remove newline after 'template<...>' of a template class definition.
+#
+# Overrides nl_template_class.
+nl_template_class_def           = ignore   # ignore/add/remove/force
+
+# Add or remove newline after 'template<>' of a specialized class definition.
+#
+# Overrides nl_template_class_def.
+nl_template_class_def_special   = ignore   # ignore/add/remove/force
+
+# Add or remove newline after 'template<...>' of a template function.
+nl_template_func                = ignore   # ignore/add/remove/force
+
+# Add or remove newline after 'template<...>' of a template function
+# declaration.
+#
+# Overrides nl_template_func.
+nl_template_func_decl           = ignore   # ignore/add/remove/force
+
+# Add or remove newline after 'template<>' of a specialized function
+# declaration.
+#
+# Overrides nl_template_func_decl.
+nl_template_func_decl_special   = ignore   # ignore/add/remove/force
+
+# Add or remove newline after 'template<...>' of a template function
+# definition.
+#
+# Overrides nl_template_func.
+nl_template_func_def            = ignore   # ignore/add/remove/force
+
+# Add or remove newline after 'template<>' of a specialized function
+# definition.
+#
+# Overrides nl_template_func_def.
+nl_template_func_def_special    = ignore   # ignore/add/remove/force
+
+# Add or remove newline after 'template<...>' of a template variable.
+nl_template_var                 = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'template<...>' and 'using' of a templated
+# type alias.
+nl_template_using               = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'class' and '{'.
+nl_class_brace                  = ignore   # ignore/add/remove/force
+
+# Add or remove newline before or after (depending on pos_class_comma,
+# may not be IGNORE) each',' in the base class list.
+nl_class_init_args              = ignore   # ignore/add/remove/force
+
+# Add or remove newline after each ',' in the constructor member
+# initialization. Related to nl_constr_colon, pos_constr_colon and
+# pos_constr_comma.
+nl_constr_init_args             = ignore   # ignore/add/remove/force
+
+# Add or remove newline before first element, after comma, and after last
+# element, in 'enum'.
+nl_enum_own_lines               = ignore   # ignore/add/remove/force
+
+# Add or remove newline between return type and function name in a function
+# definition.
+# might be modified by nl_func_leave_one_liners
+nl_func_type_name               = ignore   # ignore/add/remove/force
+
+# Add or remove newline between return type and function name inside a class
+# definition. If set to ignore, nl_func_type_name or nl_func_proto_type_name
+# is used instead.
+nl_func_type_name_class         = ignore   # ignore/add/remove/force
+
+# Add or remove newline between class specification and '::'
+# in 'void A::f() { }'. Only appears in separate member implementation (does
+# not appear with in-line implementation).
+nl_func_class_scope             = ignore   # ignore/add/remove/force
+
+# Add or remove newline between function scope and name, as in
+# 'void A :: <here> f() { }'.
+nl_func_scope_name              = ignore   # ignore/add/remove/force
+
+# Add or remove newline between return type and function name in a prototype.
+nl_func_proto_type_name         = ignore   # ignore/add/remove/force
+
+# Add or remove newline between a function name and the opening '(' in the
+# declaration.
+nl_func_paren                   = ignore   # ignore/add/remove/force
+
+# Overrides nl_func_paren for functions with no parameters.
+nl_func_paren_empty             = ignore   # ignore/add/remove/force
+
+# Add or remove newline between a function name and the opening '(' in the
+# definition.
+nl_func_def_paren               = ignore   # ignore/add/remove/force
+
+# Overrides nl_func_def_paren for functions with no parameters.
+nl_func_def_paren_empty         = ignore   # ignore/add/remove/force
+
+# Add or remove newline between a function name and the opening '(' in the
+# call.
+nl_func_call_paren              = ignore   # ignore/add/remove/force
+
+# Overrides nl_func_call_paren for functions with no parameters.
+nl_func_call_paren_empty        = ignore   # ignore/add/remove/force
+
+# Add or remove newline after '(' in a function declaration.
+nl_func_decl_start              = ignore   # ignore/add/remove/force
+
+# Add or remove newline after '(' in a function definition.
+nl_func_def_start               = ignore   # ignore/add/remove/force
+
+# Overrides nl_func_decl_start when there is only one parameter.
+nl_func_decl_start_single       = ignore   # ignore/add/remove/force
+
+# Overrides nl_func_def_start when there is only one parameter.
+nl_func_def_start_single        = ignore   # ignore/add/remove/force
+
+# Whether to add a newline after '(' in a function declaration if '(' and ')'
+# are in different lines. If false, nl_func_decl_start is used instead.
+nl_func_decl_start_multi_line   = false    # true/false
+
+# Whether to add a newline after '(' in a function definition if '(' and ')'
+# are in different lines. If false, nl_func_def_start is used instead.
+nl_func_def_start_multi_line    = false    # true/false
+
+# Add or remove newline after each ',' in a function declaration.
+nl_func_decl_args               = ignore   # ignore/add/remove/force
+
+# Add or remove newline after each ',' in a function definition.
+nl_func_def_args                = ignore   # ignore/add/remove/force
+
+# Whether to add a newline after each ',' in a function declaration if '('
+# and ')' are in different lines. If false, nl_func_decl_args is used instead.
+nl_func_decl_args_multi_line    = false    # true/false
+
+# Whether to add a newline after each ',' in a function definition if '('
+# and ')' are in different lines. If false, nl_func_def_args is used instead.
+nl_func_def_args_multi_line     = false    # true/false
+
+# Add or remove newline before the ')' in a function declaration.
+nl_func_decl_end                = ignore   # ignore/add/remove/force
+
+# Add or remove newline before the ')' in a function definition.
+nl_func_def_end                 = ignore   # ignore/add/remove/force
+
+# Overrides nl_func_decl_end when there is only one parameter.
+nl_func_decl_end_single         = ignore   # ignore/add/remove/force
+
+# Overrides nl_func_def_end when there is only one parameter.
+nl_func_def_end_single          = ignore   # ignore/add/remove/force
+
+# Whether to add a newline before ')' in a function declaration if '(' and ')'
+# are in different lines. If false, nl_func_decl_end is used instead.
+nl_func_decl_end_multi_line     = false    # true/false
+
+# Whether to add a newline before ')' in a function definition if '(' and ')'
+# are in different lines. If false, nl_func_def_end is used instead.
+nl_func_def_end_multi_line      = false    # true/false
+
+# Add or remove newline between '()' in a function declaration.
+nl_func_decl_empty              = ignore   # ignore/add/remove/force
+
+# Add or remove newline between '()' in a function definition.
+nl_func_def_empty               = ignore   # ignore/add/remove/force
+
+# Add or remove newline between '()' in a function call.
+nl_func_call_empty              = ignore   # ignore/add/remove/force
+
+# Whether to add a newline after '(' in a function call,
+# has preference over nl_func_call_start_multi_line.
+nl_func_call_start              = ignore   # ignore/add/remove/force
+
+# Whether to add a newline after '(' in a function call if '(' and ')' are in
+# different lines.
+nl_func_call_start_multi_line   = false    # true/false
+
+# Whether to add a newline after each ',' in a function call if '(' and ')'
+# are in different lines.
+nl_func_call_args_multi_line    = false    # true/false
+
+# Whether to add a newline before ')' in a function call if '(' and ')' are in
+# different lines.
+nl_func_call_end_multi_line     = false    # true/false
+
+# Whether to add a newline after '<' of a template parameter list.
+nl_template_start               = false    # true/false
+
+# Whether to add a newline after each ',' in a template parameter list.
+nl_template_args                = false    # true/false
+
+# Whether to add a newline before '>' of a template parameter list.
+nl_template_end                 = false    # true/false
+
+# (OC) Whether to put each Objective-C message parameter on a separate line.
+# See nl_oc_msg_leave_one_liner.
+nl_oc_msg_args                  = false    # true/false
+
+# Add or remove newline between function signature and '{'.
+nl_fdef_brace                   = remove   # ignore/add/remove/force
+
+# Add or remove newline between function signature and '{',
+# if signature ends with ')'. Overrides nl_fdef_brace.
+nl_fdef_brace_cond              = ignore   # ignore/add/remove/force
+
+# Add or remove newline between C++11 lambda signature and '{'.
+nl_cpp_ldef_brace               = ignore   # ignore/add/remove/force
+
+# Add or remove newline between 'return' and the return expression.
+nl_return_expr                  = ignore   # ignore/add/remove/force
+
+# Whether to add a newline after semicolons, except in 'for' statements.
+nl_after_semicolon              = true     # true/false
+
+# (Java) Add or remove newline between the ')' and '{{' of the double brace
+# initializer.
+nl_paren_dbrace_open            = ignore   # ignore/add/remove/force
+
+# Whether to add a newline after the type in an unnamed temporary
+# direct-list-initialization.
+nl_type_brace_init_lst          = ignore   # ignore/add/remove/force
+
+# Whether to add a newline after the open brace in an unnamed temporary
+# direct-list-initialization.
+nl_type_brace_init_lst_open     = ignore   # ignore/add/remove/force
+
+# Whether to add a newline before the close brace in an unnamed temporary
+# direct-list-initialization.
+nl_type_brace_init_lst_close    = ignore   # ignore/add/remove/force
+
+# Whether to add a newline after '{'. This also adds a newline before the
+# matching '}'.
+nl_after_brace_open             = false    # true/false
+
+# Whether to add a newline between the open brace and a trailing single-line
+# comment. Requires nl_after_brace_open=true.
+nl_after_brace_open_cmt         = false    # true/false
+
+# Whether to add a newline after a virtual brace open with a non-empty body.
+# These occur in un-braced if/while/do/for statement bodies.
+nl_after_vbrace_open            = false    # true/false
+
+# Whether to add a newline after a virtual brace open with an empty body.
+# These occur in un-braced if/while/do/for statement bodies.
+nl_after_vbrace_open_empty      = false    # true/false
+
+# Whether to add a newline after '}'. Does not apply if followed by a
+# necessary ';'.
+nl_after_brace_close            = false    # true/false
+
+# Whether to add a newline after a virtual brace close,
+# as in 'if (foo) a++; <here> return;'.
+nl_after_vbrace_close           = false    # true/false
+
+# Add or remove newline between the close brace and identifier,
+# as in 'struct { int a; } <here> b;'. Affects enumerations, unions and
+# structures. If set to ignore, uses nl_after_brace_close.
+nl_brace_struct_var             = ignore   # ignore/add/remove/force
+
+# Whether to alter newlines in '#define' macros.
+nl_define_macro                 = false    # true/false
+
+# Whether to alter newlines between consecutive parenthesis closes. The number
+# of closing parentheses in a line will depend on respective open parenthesis
+# lines.
+nl_squeeze_paren_close          = false    # true/false
+
+# Whether to remove blanks after '#ifxx' and '#elxx', or before '#elxx' and
+# '#endif'. Does not affect top-level #ifdefs.
+nl_squeeze_ifdef                = false    # true/false
+
+# Makes the nl_squeeze_ifdef option affect the top-level #ifdefs as well.
+nl_squeeze_ifdef_top_level      = false    # true/false
+
+# Add or remove blank line before 'if'.
+nl_before_if                    = ignore   # ignore/add/remove/force
+
+# Add or remove blank line after 'if' statement. Add/Force work only if the
+# next token is not a closing brace.
+nl_after_if                     = ignore   # ignore/add/remove/force
+
+# Add or remove blank line before 'for'.
+nl_before_for                   = ignore   # ignore/add/remove/force
+
+# Add or remove blank line after 'for' statement.
+nl_after_for                    = ignore   # ignore/add/remove/force
+
+# Add or remove blank line before 'while'.
+nl_before_while                 = ignore   # ignore/add/remove/force
+
+# Add or remove blank line after 'while' statement.
+nl_after_while                  = ignore   # ignore/add/remove/force
+
+# Add or remove blank line before 'switch'.
+nl_before_switch                = ignore   # ignore/add/remove/force
+
+# Add or remove blank line after 'switch' statement.
+nl_after_switch                 = ignore   # ignore/add/remove/force
+
+# Add or remove blank line before 'synchronized'.
+nl_before_synchronized          = ignore   # ignore/add/remove/force
+
+# Add or remove blank line after 'synchronized' statement.
+nl_after_synchronized           = ignore   # ignore/add/remove/force
+
+# Add or remove blank line before 'do'.
+nl_before_do                    = ignore   # ignore/add/remove/force
+
+# Add or remove blank line after 'do/while' statement.
+nl_after_do                     = ignore   # ignore/add/remove/force
+
+# Whether to put a blank line before 'return' statements, unless after an open
+# brace.
+nl_before_return                = false    # true/false
+
+# Whether to put a blank line after 'return' statements, unless followed by a
+# close brace.
+nl_after_return                 = false    # true/false
+
+# (Java) Whether to put a blank line before a member '.' or '->' operators.
+nl_before_member                = ignore   # ignore/add/remove/force
+
+# (Java) Whether to put a blank line after a member '.' or '->' operators.
+nl_after_member                 = ignore   # ignore/add/remove/force
+
+# Whether to double-space commented-entries in 'struct'/'union'/'enum'.
+nl_ds_struct_enum_cmt           = false    # true/false
+
+# Whether to force a newline before '}' of a 'struct'/'union'/'enum'.
+# (Lower priority than eat_blanks_before_close_brace.)
+nl_ds_struct_enum_close_brace   = false    # true/false
+
+# Add or remove newline before or after (depending on pos_class_colon) a class
+# colon, as in 'class Foo <here> : <or here> public Bar'.
+nl_class_colon                  = ignore   # ignore/add/remove/force
+
+# Add or remove newline around a class constructor colon. The exact position
+# depends on nl_constr_init_args, pos_constr_colon and pos_constr_comma.
+nl_constr_colon                 = ignore   # ignore/add/remove/force
+
+# Whether to collapse a two-line namespace, like 'namespace foo\n{ decl; }'
+# into a single line. If true, prevents other brace newline rules from turning
+# such code into four lines.
+nl_namespace_two_to_one_liner   = false    # true/false
+
+# Whether to remove a newline in simple unbraced if statements, turning them
+# into one-liners, as in 'if(b)\n i++;' => 'if(b) i++;'.
+nl_create_if_one_liner          = false    # true/false
+
+# Whether to remove a newline in simple unbraced for statements, turning them
+# into one-liners, as in 'for (...)\n stmt;' => 'for (...) stmt;'.
+nl_create_for_one_liner         = false    # true/false
+
+# Whether to remove a newline in simple unbraced while statements, turning
+# them into one-liners, as in 'while (expr)\n stmt;' => 'while (expr) stmt;'.
+nl_create_while_one_liner       = false    # true/false
+
+# Whether to collapse a function definition whose body (not counting braces)
+# is only one line so that the entire definition (prototype, braces, body) is
+# a single line.
+nl_create_func_def_one_liner    = false    # true/false
+
+# Whether to collapse a function definition whose body (not counting braces)
+# is only one line so that the entire definition (prototype, braces, body) is
+# a single line.
+nl_create_list_one_liner        = false    # true/false
+
+# Whether to split one-line simple unbraced if statements into two lines by
+# adding a newline, as in 'if(b) <here> i++;'.
+nl_split_if_one_liner           = true     # true/false
+
+# Whether to split one-line simple unbraced for statements into two lines by
+# adding a newline, as in 'for (...) <here> stmt;'.
+nl_split_for_one_liner          = true     # true/false
+
+# Whether to split one-line simple unbraced while statements into two lines by
+# adding a newline, as in 'while (expr) <here> stmt;'.
+nl_split_while_one_liner        = true     # true/false
+
+#
+# Blank line options
+#
+
+# The maximum number of consecutive newlines (3 = 2 blank lines).
+nl_max                          = 0        # unsigned number
+
+# The maximum number of consecutive newlines in a function.
+nl_max_blank_in_func            = 0        # unsigned number
+
+# The number of newlines before a function prototype.
+nl_before_func_body_proto       = 0        # unsigned number
+
+# The number of newlines before a multi-line function definition.
+nl_before_func_body_def         = 0        # unsigned number
+
+# The number of newlines before a class constructor/destructor prototype.
+nl_before_func_class_proto      = 0        # unsigned number
+
+# The number of newlines before a class constructor/destructor definition.
+nl_before_func_class_def        = 0        # unsigned number
+
+# The number of newlines after a function prototype.
+nl_after_func_proto             = 0        # unsigned number
+
+# The number of newlines after a function prototype, if not followed by
+# another function prototype.
+nl_after_func_proto_group       = 0        # unsigned number
+
+# The number of newlines after a class constructor/destructor prototype.
+nl_after_func_class_proto       = 0        # unsigned number
+
+# The number of newlines after a class constructor/destructor prototype,
+# if not followed by another constructor/destructor prototype.
+nl_after_func_class_proto_group = 0        # unsigned number
+
+# Whether one-line method definitions inside a class body should be treated
+# as if they were prototypes for the purposes of adding newlines.
+#
+# Requires nl_class_leave_one_liners=true. Overrides nl_before_func_body_def
+# and nl_before_func_class_def for one-liners.
+nl_class_leave_one_liner_groups = false    # true/false
+
+# The number of newlines after '}' of a multi-line function body.
+nl_after_func_body              = 0        # unsigned number
+
+# The number of newlines after '}' of a multi-line function body in a class
+# declaration. Also affects class constructors/destructors.
+#
+# Overrides nl_after_func_body.
+nl_after_func_body_class        = 0        # unsigned number
+
+# The number of newlines after '}' of a single line function body. Also
+# affects class constructors/destructors.
+#
+# Overrides nl_after_func_body and nl_after_func_body_class.
+nl_after_func_body_one_liner    = 0        # unsigned number
+
+# The number of blank lines after a block of variable definitions at the top
+# of a function body.
+#
+# 0: No change (default).
+nl_func_var_def_blk             = 0        # unsigned number
+
+# The number of newlines before a block of typedefs. If nl_after_access_spec
+# is non-zero, that option takes precedence.
+#
+# 0: No change (default).
+nl_typedef_blk_start            = 0        # unsigned number
+
+# The number of newlines after a block of typedefs.
+#
+# 0: No change (default).
+nl_typedef_blk_end              = 0        # unsigned number
+
+# The maximum number of consecutive newlines within a block of typedefs.
+#
+# 0: No change (default).
+nl_typedef_blk_in               = 0        # unsigned number
+
+# The number of newlines before a block of variable definitions not at the top
+# of a function body. If nl_after_access_spec is non-zero, that option takes
+# precedence.
+#
+# 0: No change (default).
+nl_var_def_blk_start            = 0        # unsigned number
+
+# The number of newlines after a block of variable definitions not at the top
+# of a function body.
+#
+# 0: No change (default).
+nl_var_def_blk_end              = 0        # unsigned number
+
+# The maximum number of consecutive newlines within a block of variable
+# definitions.
+#
+# 0: No change (default).
+nl_var_def_blk_in               = 0        # unsigned number
+
+# The minimum number of newlines before a multi-line comment.
+# Doesn't apply if after a brace open or another multi-line comment.
+nl_before_block_comment         = 0        # unsigned number
+
+# The minimum number of newlines before a single-line C comment.
+# Doesn't apply if after a brace open or other single-line C comments.
+nl_before_c_comment             = 0        # unsigned number
+
+# The minimum number of newlines before a CPP comment.
+# Doesn't apply if after a brace open or other CPP comments.
+nl_before_cpp_comment           = 0        # unsigned number
+
+# Whether to force a newline after a multi-line comment.
+nl_after_multiline_comment      = false    # true/false
+
+# Whether to force a newline after a label's colon.
+nl_after_label_colon            = false    # true/false
+
+# The number of newlines after '}' or ';' of a struct/enum/union definition.
+nl_after_struct                 = 0        # unsigned number
+
+# The number of newlines before a class definition.
+nl_before_class                 = 0        # unsigned number
+
+# The number of newlines after '}' or ';' of a class definition.
+nl_after_class                  = 0        # unsigned number
+
+# The number of newlines before a namespace.
+nl_before_namespace             = 0        # unsigned number
+
+# The number of newlines after '{' of a namespace. This also adds newlines
+# before the matching '}'.
+#
+# 0: Apply eat_blanks_after_open_brace or eat_blanks_before_close_brace if
+#     applicable, otherwise no change.
+#
+# Overrides eat_blanks_after_open_brace and eat_blanks_before_close_brace.
+nl_inside_namespace             = 0        # unsigned number
+
+# The number of newlines after '}' of a namespace.
+nl_after_namespace              = 0        # unsigned number
+
+# The number of newlines before an access specifier label. This also includes
+# the Qt-specific 'signals:' and 'slots:'. Will not change the newline count
+# if after a brace open.
+#
+# 0: No change (default).
+nl_before_access_spec           = 0        # unsigned number
+
+# The number of newlines after an access specifier label. This also includes
+# the Qt-specific 'signals:' and 'slots:'. Will not change the newline count
+# if after a brace open.
+#
+# 0: No change (default).
+#
+# Overrides nl_typedef_blk_start and nl_var_def_blk_start.
+nl_after_access_spec            = 0        # unsigned number
+
+# The number of newlines between a function definition and the function
+# comment, as in '// comment\n <here> void foo() {...}'.
+#
+# 0: No change (default).
+nl_comment_func_def             = 0        # unsigned number
+
+# The number of newlines after a try-catch-finally block that isn't followed
+# by a brace close.
+#
+# 0: No change (default).
+nl_after_try_catch_finally      = 0        # unsigned number
+
+# (C#) The number of newlines before and after a property, indexer or event
+# declaration.
+#
+# 0: No change (default).
+nl_around_cs_property           = 0        # unsigned number
+
+# (C#) The number of newlines between the get/set/add/remove handlers.
+#
+# 0: No change (default).
+nl_between_get_set              = 0        # unsigned number
+
+# (C#) Add or remove newline between property and the '{'.
+nl_property_brace               = ignore   # ignore/add/remove/force
+
+# Whether to remove blank lines after '{'.
+eat_blanks_after_open_brace     = false    # true/false
+
+# Whether to remove blank lines before '}'.
+eat_blanks_before_close_brace   = false    # true/false
+
+# How aggressively to remove extra newlines not in preprocessor.
+#
+# 0: No change (default)
+# 1: Remove most newlines not handled by other config
+# 2: Remove all newlines and reformat completely by config
+nl_remove_extra_newlines        = 0        # unsigned number
+
+# (Java) Add or remove newline after an annotation statement. Only affects
+# annotations that are after a newline.
+nl_after_annotation             = ignore   # ignore/add/remove/force
+
+# (Java) Add or remove newline between two annotations.
+nl_between_annotation           = ignore   # ignore/add/remove/force
+
+#
+# Positioning options
+#
+
+# The position of arithmetic operators in wrapped expressions.
+pos_arith                       = ignore   # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force
+
+# The position of assignment in wrapped expressions. Do not affect '='
+# followed by '{'.
+pos_assign                      = ignore   # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force
+
+# The position of Boolean operators in wrapped expressions.
+pos_bool                        = ignore   # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force
+
+# The position of comparison operators in wrapped expressions.
+pos_compare                     = ignore   # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force
+
+# The position of conditional operators, as in the '?' and ':' of
+# 'expr ? stmt : stmt', in wrapped expressions.
+pos_conditional                 = ignore   # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force
+
+# The position of the comma in wrapped expressions.
+pos_comma                       = ignore   # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force
+
+# The position of the comma in enum entries.
+pos_enum_comma                  = ignore   # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force
+
+# The position of the comma in the base class list if there is more than one
+# line. Affects nl_class_init_args.
+pos_class_comma                 = ignore   # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force
+
+# The position of the comma in the constructor initialization list.
+# Related to nl_constr_colon, nl_constr_init_args and pos_constr_colon.
+pos_constr_comma                = ignore   # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force
+
+# The position of trailing/leading class colon, between class and base class
+# list. Affects nl_class_colon.
+pos_class_colon                 = ignore   # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force
+
+# The position of colons between constructor and member initialization.
+# Related to nl_constr_colon, nl_constr_init_args and pos_constr_comma.
+pos_constr_colon                = ignore   # ignore/break/force/lead/trail/join/lead_break/lead_force/trail_break/trail_force
+
+#
+# Line splitting options
+#
+
+# Try to limit code width to N columns.
+code_width                      = 0        # unsigned number
+
+# Whether to fully split long 'for' statements at semi-colons.
+ls_for_split_full               = false    # true/false
+
+# Whether to fully split long function prototypes/calls at commas.
+# The option ls_code_width has priority over the option ls_func_split_full.
+ls_func_split_full              = false    # true/false
+
+# Whether to split lines as close to code_width as possible and ignore some
+# groupings.
+# The option ls_code_width has priority over the option ls_func_split_full.
+ls_code_width                   = false    # true/false
+
+#
+# Code alignment options (not left column spaces/tabs)
+#
+
+# Whether to keep non-indenting tabs.
+align_keep_tabs                 = false    # true/false
+
+# Whether to use tabs for aligning.
+align_with_tabs                 = false    # true/false
+
+# Whether to bump out to the next tab when aligning.
+align_on_tabstop                = false    # true/false
+
+# Whether to right-align numbers.
+align_number_right              = false    # true/false
+
+# Whether to keep whitespace not required for alignment.
+align_keep_extra_space          = false    # true/false
+
+# Whether to align variable definitions in prototypes and functions.
+align_func_params               = false    # true/false
+
+# The span for aligning parameter definitions in function on parameter name.
+#
+# 0: Don't align (default).
+align_func_params_span          = 0        # unsigned number
+
+# The threshold for aligning function parameter definitions.
+# Use a negative number for absolute thresholds.
+#
+# 0: No limit (default).
+align_func_params_thresh        = 0        # number
+
+# The gap for aligning function parameter definitions.
+align_func_params_gap           = 0        # unsigned number
+
+# The span for aligning constructor value.
+#
+# 0: Don't align (default).
+align_constr_value_span         = 0        # unsigned number
+
+# The threshold for aligning constructor value.
+# Use a negative number for absolute thresholds.
+#
+# 0: No limit (default).
+align_constr_value_thresh       = 0        # number
+
+# The gap for aligning constructor value.
+align_constr_value_gap          = 0        # unsigned number
+
+# Whether to align parameters in single-line functions that have the same
+# name. The function names must already be aligned with each other.
+align_same_func_call_params     = false    # true/false
+
+# The span for aligning function-call parameters for single line functions.
+#
+# 0: Don't align (default).
+align_same_func_call_params_span = 0        # unsigned number
+
+# The threshold for aligning function-call parameters for single line
+# functions.
+# Use a negative number for absolute thresholds.
+#
+# 0: No limit (default).
+align_same_func_call_params_thresh = 0        # number
+
+# The span for aligning variable definitions.
+#
+# 0: Don't align (default).
+align_var_def_span              = 0        # unsigned number
+
+# How to consider (or treat) the '*' in the alignment of variable definitions.
+#
+# 0: Part of the type     'void *   foo;' (default)
+# 1: Part of the variable 'void     *foo;'
+# 2: Dangling             'void    *foo;'
+# Dangling: the '*' will not be taken into account when aligning.
+align_var_def_star_style        = 0        # unsigned number
+
+# How to consider (or treat) the '&' in the alignment of variable definitions.
+#
+# 0: Part of the type     'long &   foo;' (default)
+# 1: Part of the variable 'long     &foo;'
+# 2: Dangling             'long    &foo;'
+# Dangling: the '&' will not be taken into account when aligning.
+align_var_def_amp_style         = 0        # unsigned number
+
+# The threshold for aligning variable definitions.
+# Use a negative number for absolute thresholds.
+#
+# 0: No limit (default).
+align_var_def_thresh            = 0        # number
+
+# The gap for aligning variable definitions.
+align_var_def_gap               = 0        # unsigned number
+
+# Whether to align the colon in struct bit fields.
+align_var_def_colon             = false    # true/false
+
+# The gap for aligning the colon in struct bit fields.
+align_var_def_colon_gap         = 0        # unsigned number
+
+# Whether to align any attribute after the variable name.
+align_var_def_attribute         = false    # true/false
+
+# Whether to align inline struct/enum/union variable definitions.
+align_var_def_inline            = false    # true/false
+
+# The span for aligning on '=' in assignments.
+#
+# 0: Don't align (default).
+align_assign_span               = 0        # unsigned number
+
+# The span for aligning on '=' in function prototype modifier.
+#
+# 0: Don't align (default).
+align_assign_func_proto_span    = 0        # unsigned number
+
+# The threshold for aligning on '=' in assignments.
+# Use a negative number for absolute thresholds.
+#
+# 0: No limit (default).
+align_assign_thresh             = 0        # number
+
+# How to apply align_assign_span to function declaration "assignments", i.e.
+# 'virtual void foo() = 0' or '~foo() = {default|delete}'.
+#
+# 0: Align with other assignments (default)
+# 1: Align with each other, ignoring regular assignments
+# 2: Don't align
+align_assign_decl_func          = 0        # unsigned number
+
+# The span for aligning on '=' in enums.
+#
+# 0: Don't align (default).
+align_enum_equ_span             = 0        # unsigned number
+
+# The threshold for aligning on '=' in enums.
+# Use a negative number for absolute thresholds.
+#
+# 0: no limit (default).
+align_enum_equ_thresh           = 0        # number
+
+# The span for aligning class member definitions.
+#
+# 0: Don't align (default).
+align_var_class_span            = 0        # unsigned number
+
+# The threshold for aligning class member definitions.
+# Use a negative number for absolute thresholds.
+#
+# 0: No limit (default).
+align_var_class_thresh          = 0        # number
+
+# The gap for aligning class member definitions.
+align_var_class_gap             = 0        # unsigned number
+
+# The span for aligning struct/union member definitions.
+#
+# 0: Don't align (default).
+align_var_struct_span           = 0        # unsigned number
+
+# The threshold for aligning struct/union member definitions.
+# Use a negative number for absolute thresholds.
+#
+# 0: No limit (default).
+align_var_struct_thresh         = 0        # number
+
+# The gap for aligning struct/union member definitions.
+align_var_struct_gap            = 0        # unsigned number
+
+# The span for aligning struct initializer values.
+#
+# 0: Don't align (default).
+align_struct_init_span          = 0        # unsigned number
+
+# The span for aligning single-line typedefs.
+#
+# 0: Don't align (default).
+align_typedef_span              = 0        # unsigned number
+
+# The minimum space between the type and the synonym of a typedef.
+align_typedef_gap               = 0        # unsigned number
+
+# How to align typedef'd functions with other typedefs.
+#
+# 0: Don't mix them at all (default)
+# 1: Align the open parenthesis with the types
+# 2: Align the function type name with the other type names
+align_typedef_func              = 0        # unsigned number
+
+# How to consider (or treat) the '*' in the alignment of typedefs.
+#
+# 0: Part of the typedef type, 'typedef int * pint;' (default)
+# 1: Part of type name:        'typedef int   *pint;'
+# 2: Dangling:                 'typedef int  *pint;'
+# Dangling: the '*' will not be taken into account when aligning.
+align_typedef_star_style        = 0        # unsigned number
+
+# How to consider (or treat) the '&' in the alignment of typedefs.
+#
+# 0: Part of the typedef type, 'typedef int & intref;' (default)
+# 1: Part of type name:        'typedef int   &intref;'
+# 2: Dangling:                 'typedef int  &intref;'
+# Dangling: the '&' will not be taken into account when aligning.
+align_typedef_amp_style         = 0        # unsigned number
+
+# The span for aligning comments that end lines.
+#
+# 0: Don't align (default).
+align_right_cmt_span            = 0        # unsigned number
+
+# Minimum number of columns between preceding text and a trailing comment in
+# order for the comment to qualify for being aligned. Must be non-zero to have
+# an effect.
+align_right_cmt_gap             = 0        # unsigned number
+
+# If aligning comments, whether to mix with comments after '}' and #endif with
+# less than three spaces before the comment.
+align_right_cmt_mix             = false    # true/false
+
+# Whether to only align trailing comments that are at the same brace level.
+align_right_cmt_same_level      = false    # true/false
+
+# Minimum column at which to align trailing comments. Comments which are
+# aligned beyond this column, but which can be aligned in a lesser column,
+# may be "pulled in".
+#
+# 0: Ignore (default).
+align_right_cmt_at_col          = 0        # unsigned number
+
+# The span for aligning function prototypes.
+#
+# 0: Don't align (default).
+align_func_proto_span           = 0        # unsigned number
+
+# The threshold for aligning function prototypes.
+# Use a negative number for absolute thresholds.
+#
+# 0: No limit (default).
+align_func_proto_thresh         = 0        # number
+
+# Minimum gap between the return type and the function name.
+align_func_proto_gap            = 0        # unsigned number
+
+# Whether to align function prototypes on the 'operator' keyword instead of
+# what follows.
+align_on_operator               = false    # true/false
+
+# Whether to mix aligning prototype and variable declarations. If true,
+# align_var_def_XXX options are used instead of align_func_proto_XXX options.
+align_mix_var_proto             = false    # true/false
+
+# Whether to align single-line functions with function prototypes.
+# Uses align_func_proto_span.
+align_single_line_func          = false    # true/false
+
+# Whether to align the open brace of single-line functions.
+# Requires align_single_line_func=true. Uses align_func_proto_span.
+align_single_line_brace         = false    # true/false
+
+# Gap for align_single_line_brace.
+align_single_line_brace_gap     = 0        # unsigned number
+
+# (OC) The span for aligning Objective-C message specifications.
+#
+# 0: Don't align (default).
+align_oc_msg_spec_span          = 0        # unsigned number
+
+# Whether to align macros wrapped with a backslash and a newline. This will
+# not work right if the macro contains a multi-line comment.
+align_nl_cont                   = false    # true/false
+
+# Whether to align macro functions and variables together.
+align_pp_define_together        = false    # true/false
+
+# The span for aligning on '#define' bodies.
+#
+# =0: Don't align (default)
+# >0: Number of lines (including comments) between blocks
+align_pp_define_span            = 0        # unsigned number
+
+# The minimum space between label and value of a preprocessor define.
+align_pp_define_gap             = 0        # unsigned number
+
+# Whether to align lines that start with '<<' with previous '<<'.
+#
+# Default: true
+align_left_shift                = true     # true/false
+
+# Whether to align text after 'asm volatile ()' colons.
+align_asm_colon                 = false    # true/false
+
+# (OC) Span for aligning parameters in an Objective-C message call
+# on the ':'.
+#
+# 0: Don't align.
+align_oc_msg_colon_span         = 0        # unsigned number
+
+# (OC) Whether to always align with the first parameter, even if it is too
+# short.
+align_oc_msg_colon_first        = false    # true/false
+
+# (OC) Whether to align parameters in an Objective-C '+' or '-' declaration
+# on the ':'.
+align_oc_decl_colon             = false    # true/false
+
+#
+# Comment modification options
+#
+
+# Try to wrap comments at N columns.
+cmt_width                       = 0        # unsigned number
+
+# How to reflow comments.
+#
+# 0: No reflowing (apart from the line wrapping due to cmt_width) (default)
+# 1: No touching at all
+# 2: Full reflow
+cmt_reflow_mode                 = 1        # unsigned number
+
+# Whether to convert all tabs to spaces in comments. If false, tabs in
+# comments are left alone, unless used for indenting.
+cmt_convert_tab_to_spaces       = false    # true/false
+
+# Whether to apply changes to multi-line comments, including cmt_width,
+# keyword substitution and leading chars.
+#
+# Default: true
+cmt_indent_multi                = false    # true/false
+
+# Whether to group c-comments that look like they are in a block.
+cmt_c_group                     = false    # true/false
+
+# Whether to put an empty '/*' on the first line of the combined c-comment.
+cmt_c_nl_start                  = false    # true/false
+
+# Whether to add a newline before the closing '*/' of the combined c-comment.
+cmt_c_nl_end                    = false    # true/false
+
+# Whether to change cpp-comments into c-comments.
+cmt_cpp_to_c                    = false    # true/false
+
+# Whether to group cpp-comments that look like they are in a block. Only
+# meaningful if cmt_cpp_to_c=true.
+cmt_cpp_group                   = false    # true/false
+
+# Whether to put an empty '/*' on the first line of the combined cpp-comment
+# when converting to a c-comment.
+#
+# Requires cmt_cpp_to_c=true and cmt_cpp_group=true.
+cmt_cpp_nl_start                = false    # true/false
+
+# Whether to add a newline before the closing '*/' of the combined cpp-comment
+# when converting to a c-comment.
+#
+# Requires cmt_cpp_to_c=true and cmt_cpp_group=true.
+cmt_cpp_nl_end                  = false    # true/false
+
+# Whether to put a star on subsequent comment lines.
+cmt_star_cont                   = false    # true/false
+
+# The number of spaces to insert at the start of subsequent comment lines.
+cmt_sp_before_star_cont         = 0        # unsigned number
+
+# The number of spaces to insert after the star on subsequent comment lines.
+cmt_sp_after_star_cont          = 0        # unsigned number
+
+# For multi-line comments with a '*' lead, remove leading spaces if the first
+# and last lines of the comment are the same length.
+#
+# Default: true
+cmt_multi_check_last            = true     # true/false
+
+# For multi-line comments with a '*' lead, remove leading spaces if the first
+# and last lines of the comment are the same length AND if the length is
+# bigger as the first_len minimum.
+#
+# Default: 4
+cmt_multi_first_len_minimum     = 4        # unsigned number
+
+# Path to a file that contains text to insert at the beginning of a file if
+# the file doesn't start with a C/C++ comment. If the inserted text contains
+# '$(filename)', that will be replaced with the current file's name.
+cmt_insert_file_header          = ""         # string
+
+# Path to a file that contains text to insert at the end of a file if the
+# file doesn't end with a C/C++ comment. If the inserted text contains
+# '$(filename)', that will be replaced with the current file's name.
+cmt_insert_file_footer          = ""         # string
+
+# Path to a file that contains text to insert before a function definition if
+# the function isn't preceded by a C/C++ comment. If the inserted text
+# contains '$(function)', '$(javaparam)' or '$(fclass)', these will be
+# replaced with, respectively, the name of the function, the javadoc '@param'
+# and '@return' stuff, or the name of the class to which the member function
+# belongs.
+cmt_insert_func_header          = ""         # string
+
+# Path to a file that contains text to insert before a class if the class
+# isn't preceded by a C/C++ comment. If the inserted text contains '$(class)',
+# that will be replaced with the class name.
+cmt_insert_class_header         = ""         # string
+
+# Path to a file that contains text to insert before an Objective-C message
+# specification, if the method isn't preceded by a C/C++ comment. If the
+# inserted text contains '$(message)' or '$(javaparam)', these will be
+# replaced with, respectively, the name of the function, or the javadoc
+# '@param' and '@return' stuff.
+cmt_insert_oc_msg_header        = ""         # string
+
+# Whether a comment should be inserted if a preprocessor is encountered when
+# stepping backwards from a function name.
+#
+# Applies to cmt_insert_oc_msg_header, cmt_insert_func_header and
+# cmt_insert_class_header.
+cmt_insert_before_preproc       = false    # true/false
+
+# Whether a comment should be inserted if a function is declared inline to a
+# class definition.
+#
+# Applies to cmt_insert_func_header.
+#
+# Default: true
+cmt_insert_before_inlines       = true     # true/false
+
+# Whether a comment should be inserted if the function is a class constructor
+# or destructor.
+#
+# Applies to cmt_insert_func_header.
+cmt_insert_before_ctor_dtor     = false    # true/false
+
+#
+# Code modifying options (non-whitespace)
+#
+
+# Add or remove braces on a single-line 'do' statement.
+mod_full_brace_do               = force    # ignore/add/remove/force
+
+# Add or remove braces on a single-line 'for' statement.
+mod_full_brace_for              = force    # ignore/add/remove/force
+
+# (Pawn) Add or remove braces on a single-line function definition.
+mod_full_brace_function         = force    # ignore/add/remove/force
+
+# Add or remove braces on a single-line 'if' statement. Braces will not be
+# removed if the braced statement contains an 'else'.
+mod_full_brace_if               = force    # ignore/add/remove/force
+
+# Whether to enforce that all blocks of an 'if'/'else if'/'else' chain either
+# have, or do not have, braces. If true, braces will be added if any block
+# needs braces, and will only be removed if they can be removed from all
+# blocks.
+#
+# Overrides mod_full_brace_if.
+mod_full_brace_if_chain         = false    # true/false
+
+# Whether to add braces to all blocks of an 'if'/'else if'/'else' chain.
+# If true, mod_full_brace_if_chain will only remove braces from an 'if' that
+# does not have an 'else if' or 'else'.
+mod_full_brace_if_chain_only    = false    # true/false
+
+# Add or remove braces on single-line 'while' statement.
+mod_full_brace_while            = force    # ignore/add/remove/force
+
+# Add or remove braces on single-line 'using ()' statement.
+mod_full_brace_using            = ignore   # ignore/add/remove/force
+
+# Don't remove braces around statements that span N newlines
+mod_full_brace_nl               = 0        # unsigned number
+
+# Whether to prevent removal of braces from 'if'/'for'/'while'/etc. blocks
+# which span multiple lines.
+#
+# Affects:
+#   mod_full_brace_for
+#   mod_full_brace_if
+#   mod_full_brace_if_chain
+#   mod_full_brace_if_chain_only
+#   mod_full_brace_while
+#   mod_full_brace_using
+#
+# Does not affect:
+#   mod_full_brace_do
+#   mod_full_brace_function
+mod_full_brace_nl_block_rem_mlcond = false    # true/false
+
+# Add or remove unnecessary parenthesis on 'return' statement.
+mod_paren_on_return             = remove   # ignore/add/remove/force
+
+# (Pawn) Whether to change optional semicolons to real semicolons.
+mod_pawn_semicolon              = false    # true/false
+
+# Whether to fully parenthesize Boolean expressions in 'while' and 'if'
+# statement, as in 'if (a && b > c)' => 'if (a && (b > c))'.
+mod_full_paren_if_bool          = false    # true/false
+
+# Whether to remove superfluous semicolons.
+mod_remove_extra_semicolon      = false    # true/false
+
+# If a function body exceeds the specified number of newlines and doesn't have
+# a comment after the close brace, a comment will be added.
+mod_add_long_function_closebrace_comment = 0        # unsigned number
+
+# If a namespace body exceeds the specified number of newlines and doesn't
+# have a comment after the close brace, a comment will be added.
+mod_add_long_namespace_closebrace_comment = 0        # unsigned number
+
+# If a class body exceeds the specified number of newlines and doesn't have a
+# comment after the close brace, a comment will be added.
+mod_add_long_class_closebrace_comment = 0        # unsigned number
+
+# If a switch body exceeds the specified number of newlines and doesn't have a
+# comment after the close brace, a comment will be added.
+mod_add_long_switch_closebrace_comment = 0        # unsigned number
+
+# If an #ifdef body exceeds the specified number of newlines and doesn't have
+# a comment after the #endif, a comment will be added.
+mod_add_long_ifdef_endif_comment = 0        # unsigned number
+
+# If an #ifdef or #else body exceeds the specified number of newlines and
+# doesn't have a comment after the #else, a comment will be added.
+mod_add_long_ifdef_else_comment = 0        # unsigned number
+
+# Whether to take care of the case by the mod_sort_xx options.
+mod_sort_case_sensitive         = false    # true/false
+
+# Whether to sort consecutive single-line 'import' statements.
+mod_sort_import                 = false    # true/false
+
+# (C#) Whether to sort consecutive single-line 'using' statements.
+mod_sort_using                  = false    # true/false
+
+# Whether to sort consecutive single-line '#include' statements (C/C++) and
+# '#import' statements (Objective-C). Be aware that this has the potential to
+# break your code if your includes/imports have ordering dependencies.
+mod_sort_include                = false    # true/false
+
+# Whether to move a 'break' that appears after a fully braced 'case' before
+# the close brace, as in 'case X: { ... } break;' => 'case X: { ... break; }'.
+mod_move_case_break             = false    # true/false
+
+# Add or remove braces around a fully braced case statement. Will only remove
+# braces if there are no variable declarations in the block.
+mod_case_brace                  = ignore   # ignore/add/remove/force
+
+# Whether to remove a void 'return;' that appears as the last statement in a
+# function.
+mod_remove_empty_return         = false    # true/false
+
+# Add or remove the comma after the last value of an enumeration.
+mod_enum_last_comma             = ignore   # ignore/add/remove/force
+
+# (OC) Whether to organize the properties. If true, properties will be
+# rearranged according to the mod_sort_oc_property_*_weight factors.
+mod_sort_oc_properties          = false    # true/false
+
+# (OC) Weight of a class property modifier.
+mod_sort_oc_property_class_weight = 0        # number
+
+# (OC) Weight of 'atomic' and 'nonatomic'.
+mod_sort_oc_property_thread_safe_weight = 0        # number
+
+# (OC) Weight of 'readwrite' when organizing properties.
+mod_sort_oc_property_readwrite_weight = 0        # number
+
+# (OC) Weight of a reference type specifier ('retain', 'copy', 'assign',
+# 'weak', 'strong') when organizing properties.
+mod_sort_oc_property_reference_weight = 0        # number
+
+# (OC) Weight of getter type ('getter=') when organizing properties.
+mod_sort_oc_property_getter_weight = 0        # number
+
+# (OC) Weight of setter type ('setter=') when organizing properties.
+mod_sort_oc_property_setter_weight = 0        # number
+
+# (OC) Weight of nullability type ('nullable', 'nonnull', 'null_unspecified',
+# 'null_resettable') when organizing properties.
+mod_sort_oc_property_nullability_weight = 0        # number
+
+#
+# Preprocessor options
+#
+
+# Add or remove indentation of preprocessor directives inside #if blocks
+# at brace level 0 (file-level).
+pp_indent                       = ignore   # ignore/add/remove/force
+
+# Whether to indent #if/#else/#endif at the brace level. If false, these are
+# indented from column 1.
+pp_indent_at_level              = true     # true/false
+
+# Specifies the number of columns to indent preprocessors per level
+# at brace level 0 (file-level). If pp_indent_at_level=false, also specifies
+# the number of columns to indent preprocessors per level
+# at brace level > 0 (function-level).
+#
+# Default: 1
+pp_indent_count                 = 1        # unsigned number
+
+# Add or remove space after # based on pp_level of #if blocks.
+pp_space                        = remove   # ignore/add/remove/force
+
+# Sets the number of spaces per level added with pp_space.
+pp_space_count                  = 0        # unsigned number
+
+# The indent for '#region' and '#endregion' in C# and '#pragma region' in
+# C/C++. Negative values decrease indent down to the first column.
+pp_indent_region                = 0        # number
+
+# Whether to indent the code between #region and #endregion.
+pp_region_indent_code           = false    # true/false
+
+# If pp_indent_at_level=true, sets the indent for #if, #else and #endif when
+# not at file-level. Negative values decrease indent down to the first column.
+#
+# =0: Indent preprocessors using output_tab_size
+# >0: Column at which all preprocessors will be indented
+pp_indent_if                    = 0        # number
+
+# Whether to indent the code between #if, #else and #endif.
+pp_if_indent_code               = false    # true/false
+
+# Whether to indent '#define' at the brace level. If false, these are
+# indented from column 1.
+pp_define_at_level              = false    # true/false
+
+# Whether to ignore the '#define' body while formatting.
+pp_ignore_define_body           = false    # true/false
+
+# Whether to indent case statements between #if, #else, and #endif.
+# Only applies to the indent of the preprocesser that the case statements
+# directly inside of.
+#
+# Default: true
+pp_indent_case                  = true     # true/false
+
+# Whether to indent whole function definitions between #if, #else, and #endif.
+# Only applies to the indent of the preprocesser that the function definition
+# is directly inside of.
+#
+# Default: true
+pp_indent_func_def              = true     # true/false
+
+# Whether to indent extern C blocks between #if, #else, and #endif.
+# Only applies to the indent of the preprocesser that the extern block is
+# directly inside of.
+#
+# Default: true
+pp_indent_extern                = true     # true/false
+
+# Whether to indent braces directly inside #if, #else, and #endif.
+# Only applies to the indent of the preprocesser that the braces are directly
+# inside of.
+#
+# Default: true
+pp_indent_brace                 = true     # true/false
+
+#
+# Sort includes options
+#
+
+# The regex for include category with priority 0.
+include_category_0              = ""         # string
+
+# The regex for include category with priority 1.
+include_category_1              = ""         # string
+
+# The regex for include category with priority 2.
+include_category_2              = ""         # string
+
+#
+# Use or Do not Use options
+#
+
+# true:  indent_func_call_param will be used (default)
+# false: indent_func_call_param will NOT be used
+#
+# Default: true
+use_indent_func_call_param      = true     # true/false
+
+# The value of the indentation for a continuation line is calculated
+# differently if the statement is:
+# - a declaration: your case with QString fileName ...
+# - an assignment: your case with pSettings = new QSettings( ...
+#
+# At the second case the indentation value might be used twice:
+# - at the assignment
+# - at the function call (if present)
+#
+# To prevent the double use of the indentation value, use this option with the
+# value 'true'.
+#
+# true:  indent_continue will be used only once
+# false: indent_continue will be used every time (default)
+use_indent_continue_only_once   = false    # true/false
+
+# The value might be used twice:
+# - at the assignment
+# - at the opening brace
+#
+# To prevent the double use of the indentation value, use this option with the
+# value 'true'.
+#
+# true:  indentation will be used only once
+# false: indentation will be used every time (default)
+indent_cpp_lambda_only_once     = false    # true/false
+
+# Whether sp_after_angle takes precedence over sp_inside_fparen. This was the
+# historic behavior, but is probably not the desired behavior, so this is off
+# by default.
+use_sp_after_angle_always       = false    # true/false
+
+# Whether to apply special formatting for Qt SIGNAL/SLOT macros. Essentially,
+# this tries to format these so that they match Qt's normalized form (i.e. the
+# result of QMetaObject::normalizedSignature), which can slightly improve the
+# performance of the QObject::connect call, rather than how they would
+# otherwise be formatted.
+#
+# See options_for_QT.cpp for details.
+#
+# Default: true
+use_options_overriding_for_qt_macros = true     # true/false
+
+#
+# Warn levels - 1: error, 2: warning (default), 3: note
+#
+
+# (C#) Warning is given if doing tab-to-\t replacement and we have found one
+# in a C# verbatim string literal.
+#
+# Default: 2
+warn_level_tabs_found_in_verbatim_string_literals = 2        # unsigned number
+
+# Meaning of the settings:
+#   Ignore - do not do any changes
+#   Add    - makes sure there is 1 or more space/brace/newline/etc
+#   Force  - makes sure there is exactly 1 space/brace/newline/etc,
+#            behaves like Add in some contexts
+#   Remove - removes space/brace/newline/etc
+#
+#
+# - Token(s) can be treated as specific type(s) with the 'set' option:
+#     `set tokenType tokenString [tokenString...]`
+#
+#     Example:
+#       `set BOOL __AND__ __OR__`
+#
+#     tokenTypes are defined in src/token_enum.h, use them without the
+#     'CT_' prefix: 'CT_BOOL' => 'BOOL'
+#
+#
+# - Token(s) can be treated as type(s) with the 'type' option.
+#     `type tokenString [tokenString...]`
+#
+#     Example:
+#       `type int c_uint_8 Rectangle`
+#
+#     This can also be achieved with `set TYPE int c_uint_8 Rectangle`
+#
+#
+# To embed whitespace in tokenStrings use the '\' escape character, or quote
+# the tokenStrings. These quotes are supported: "'`
+#
+#
+# - Support for the auto detection of languages through the file ending can be
+#   added using the 'file_ext' command.
+#     `file_ext langType langString [langString..]`
+#
+#     Example:
+#       `file_ext CPP .ch .cxx .cpp.in`
+#
+#     langTypes are defined in uncrusify_types.h in the lang_flag_e enum, use
+#     them without the 'LANG_' prefix: 'LANG_CPP' => 'CPP'
+#
+#
+# - Custom macro-based indentation can be set up using 'macro-open',
+#   'macro-else' and 'macro-close'.
+#     `(macro-open | macro-else | macro-close) tokenString`
+#
+#     Example:
+#       `macro-open  BEGIN_TEMPLATE_MESSAGE_MAP`
+#       `macro-open  BEGIN_MESSAGE_MAP`
+#       `macro-close END_MESSAGE_MAP`
+#
+#
+# option(s) with 'not default' value: 0
+#
+
+# Custom types for MicroPython
+type uint qstr
diff --git a/tools/upip.py b/tools/upip.py
index 7ecf61e54b9bc..0036eac25db7b 100644
--- a/tools/upip.py
+++ b/tools/upip.py
@@ -12,19 +12,23 @@
 import ujson as json
 import uzlib
 import upip_utarfile as tarfile
+
 gc.collect()
 
 
 debug = False
+index_urls = ["https://micropython.org/pi", "https://pypi.org/pypi"]
 install_path = None
 cleanup_files = []
 gzdict_sz = 16 + 15
 
 file_buf = bytearray(512)
 
+
 class NotFoundError(Exception):
     pass
 
+
 def op_split(path):
     if path == "":
         return ("", "")
@@ -36,9 +40,11 @@ def op_split(path):
         head = "/"
     return (head, r[1])
 
+
 def op_basename(path):
     return op_split(path)[1]
 
+
 # Expects *file* name
 def _makedirs(name, mode=0o777):
     ret = False
@@ -69,26 +75,27 @@ def save_file(fname, subf):
                 break
             outf.write(file_buf, sz)
 
+
 def install_tar(f, prefix):
     meta = {}
     for info in f:
-        #print(info)
+        # print(info)
         fname = info.name
         try:
-            fname = fname[fname.index("/") + 1:]
+            fname = fname[fname.index("/") + 1 :]
         except ValueError:
             fname = ""
 
         save = True
         for p in ("setup.", "PKG-INFO", "README"):
-                #print(fname, p)
-                if fname.startswith(p) or ".egg-info" in fname:
-                    if fname.endswith("/requires.txt"):
-                        meta["deps"] = f.extractfile(info).read()
-                    save = False
-                    if debug:
-                        print("Skipping", fname)
-                    break
+            # print(fname, p)
+            if fname.startswith(p) or ".egg-info" in fname:
+                if fname.endswith("/requires.txt"):
+                    meta["deps"] = f.extractfile(info).read()
+                save = False
+                if debug:
+                    print("Skipping", fname)
+                break
 
         if save:
             outfname = prefix + fname
@@ -100,32 +107,37 @@ def install_tar(f, prefix):
                 save_file(outfname, subf)
     return meta
 
+
 def expandhome(s):
     if "~/" in s:
         h = os.getenv("HOME")
         s = s.replace("~/", h + "/")
     return s
 
+
 import ussl
 import usocket
+
 warn_ussl = True
+
+
 def url_open(url):
     global warn_ussl
 
     if debug:
         print(url)
 
-    proto, _, host, urlpath = url.split('/', 3)
+    proto, _, host, urlpath = url.split("/", 3)
     try:
         ai = usocket.getaddrinfo(host, 443, 0, usocket.SOCK_STREAM)
     except OSError as e:
         fatal("Unable to resolve %s (no Internet?)" % host, e)
-    #print("Address infos:", ai)
+    # print("Address infos:", ai)
     ai = ai[0]
 
     s = usocket.socket(ai[0], ai[1], ai[2])
     try:
-        #print("Connect address:", addr)
+        # print("Connect address:", addr)
         s.connect(ai[-1])
 
         if proto == "https:":
@@ -146,7 +158,7 @@ def url_open(url):
             l = s.readline()
             if not l:
                 raise ValueError("Unexpected EOF in HTTP headers")
-            if l == b'\r\n':
+            if l == b"\r\n":
                 break
     except Exception as e:
         s.close()
@@ -156,11 +168,16 @@ def url_open(url):
 
 
 def get_pkg_metadata(name):
-    f = url_open("https://pypi.org/pypi/%s/json" % name)
-    try:
-        return json.load(f)
-    finally:
-        f.close()
+    for url in index_urls:
+        try:
+            f = url_open("%s/%s/json" % (url, name))
+        except NotFoundError:
+            continue
+        try:
+            return json.load(f)
+        finally:
+            f.close()
+    raise NotFoundError("Package not found")
 
 
 def fatal(msg, exc=None):
@@ -169,6 +186,7 @@ def fatal(msg, exc=None):
         raise exc
     sys.exit(1)
 
+
 def install_pkg(pkg_spec, install_path):
     data = get_pkg_metadata(pkg_spec)
 
@@ -192,6 +210,7 @@ def install_pkg(pkg_spec, install_path):
     gc.collect()
     return meta
 
+
 def install(to_install, install_path=None):
     # Calculate gzip dictionary size to use
     global gzdict_sz
@@ -224,9 +243,11 @@ def install(to_install, install_path=None):
                 deps = deps.decode("utf-8").split("\n")
                 to_install.extend(deps)
     except Exception as e:
-        print("Error installing '{}': {}, packages may be partially installed".format(
-                pkg_spec, e),
-            file=sys.stderr)
+        print(
+            "Error installing '{}': {}, packages may be partially installed".format(pkg_spec, e),
+            file=sys.stderr,
+        )
+
 
 def get_install_path():
     global install_path
@@ -236,6 +257,7 @@ def get_install_path():
     install_path = expandhome(install_path)
     return install_path
 
+
 def cleanup():
     for fname in cleanup_files:
         try:
@@ -243,24 +265,31 @@ def cleanup():
         except OSError:
             print("Warning: Cannot delete " + fname)
 
+
 def help():
-    print("""\
+    print(
+        """\
 upip - Simple PyPI package manager for MicroPython
 Usage: micropython -m upip install [-p <path>] <package>... | -r <requirements.txt>
 import upip; upip.install(package_or_list, [<path>])
 
 If <path> is not given, packages will be installed into sys.path[1]
 (can be set from MICROPYPATH environment variable, if current system
-supports that).""")
+supports that)."""
+    )
     print("Current value of sys.path[1]:", sys.path[1])
-    print("""\
+    print(
+        """\
 
 Note: only MicroPython packages (usually, named micropython-*) are supported
 for installation, upip does not support arbitrary code in setup.py.
-""")
+"""
+    )
+
 
 def main():
     global debug
+    global index_urls
     global install_path
     install_path = None
 
@@ -294,6 +323,9 @@ def main():
                     if l[0] == "#":
                         continue
                     to_install.append(l.rstrip())
+        elif opt == "-i":
+            index_urls = [sys.argv[i]]
+            i += 1
         elif opt == "--debug":
             debug = True
         else:
diff --git a/tools/upip_utarfile.py b/tools/upip_utarfile.py
index 460ca2cd44f30..21b899f020a90 100644
--- a/tools/upip_utarfile.py
+++ b/tools/upip_utarfile.py
@@ -9,11 +9,12 @@
 DIRTYPE = "dir"
 REGTYPE = "file"
 
+
 def roundup(val, align):
     return (val + align - 1) & ~(align - 1)
 
-class FileSection:
 
+class FileSection:
     def __init__(self, f, content_len, aligned_len):
         self.f = f
         self.content_len = content_len
@@ -33,7 +34,7 @@ def readinto(self, buf):
         if self.content_len == 0:
             return 0
         if len(buf) > self.content_len:
-            buf = memoryview(buf)[:self.content_len]
+            buf = memoryview(buf)[: self.content_len]
         sz = self.f.readinto(buf)
         self.content_len -= sz
         return sz
@@ -47,13 +48,13 @@ def skip(self):
                 self.f.readinto(buf, s)
                 sz -= s
 
-class TarInfo:
 
+class TarInfo:
     def __str__(self):
         return "TarInfo(%r, %s, %d)" % (self.name, self.type, self.size)
 
-class TarFile:
 
+class TarFile:
     def __init__(self, name=None, fileobj=None):
         if fileobj:
             self.f = fileobj
@@ -62,24 +63,24 @@ def __init__(self, name=None, fileobj=None):
         self.subf = None
 
     def next(self):
-            if self.subf:
-                self.subf.skip()
-            buf = self.f.read(512)
-            if not buf:
-                return None
-
-            h = uctypes.struct(uctypes.addressof(buf), TAR_HEADER, uctypes.LITTLE_ENDIAN)
-
-            # Empty block means end of archive
-            if h.name[0] == 0:
-                return None
-
-            d = TarInfo()
-            d.name = str(h.name, "utf-8").rstrip("\0")
-            d.size = int(bytes(h.size), 8)
-            d.type = [REGTYPE, DIRTYPE][d.name[-1] == "/"]
-            self.subf = d.subf = FileSection(self.f, d.size, roundup(d.size, 512))
-            return d
+        if self.subf:
+            self.subf.skip()
+        buf = self.f.read(512)
+        if not buf:
+            return None
+
+        h = uctypes.struct(uctypes.addressof(buf), TAR_HEADER, uctypes.LITTLE_ENDIAN)
+
+        # Empty block means end of archive
+        if h.name[0] == 0:
+            return None
+
+        d = TarInfo()
+        d.name = str(h.name, "utf-8").rstrip("\0")
+        d.size = int(bytes(h.size), 8)
+        d.type = [REGTYPE, DIRTYPE][d.name[-1] == "/"]
+        self.subf = d.subf = FileSection(self.f, d.size, roundup(d.size, 512))
+        return d
 
     def __iter__(self):
         return self