esp32/mpconfigport: Enable Zcmp opcodes for ESP32P4.

This commit enables support for Zcmp opcodes when the firmware is built
to target ESP32P4 microcontrollers.

The ESP32P4 explicitly supports the Zcmp extension for reducing the
amount of code needed for function prologues and epilogues (see section
4.1.1.1 of the ESP32P4 datasheet).

Signed-off-by: Alessandro Gatti <a.gatti@frob.it>

.gitattributes

@@ -18,6 +18,7 @@
 # These should also not be modified by git.
 tests/basics/string_cr_conversion.py -text
 tests/basics/string_crlf_conversion.py -text
+tests/micropython/test_normalize_newlines.py.exp -text
 ports/stm32/pybcdc.inf_template -text
 ports/stm32/usbhost/** -text
 ports/cc3200/hal/aes.c -text

.github/workflows/biome.yml

@@ -7,7 +7,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
     - name: Setup Biome
       uses: biomejs/setup-biome@v2
       with:

.github/workflows/code_formatting.yml

@@ -10,11 +10,11 @@ jobs:
   code-formatting:
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-python@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_c_code_formatting_setup
+      run: tools/ci.sh c_code_formatting_setup
     - name: Run code formatting
-      run: source tools/ci.sh && ci_c_code_formatting_run
+      run: tools/ci.sh c_code_formatting_run
     - name: Check code formatting
       run: git diff --exit-code

.github/workflows/code_size.yml

@@ -25,15 +25,15 @@ jobs:
   build:
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         fetch-depth: 100
     - name: Install packages
-      run: source tools/ci.sh && ci_code_size_setup
+      run: tools/ci.sh code_size_setup
     - name: Build
-      run: source tools/ci.sh && ci_code_size_build
+      run: tools/ci.sh code_size_build
     - name: Compute code size difference
-      run: tools/metrics.py diff ~/size0 ~/size1 | tee diff
+      run: source tools/ci.sh && ci_code_size_report
     - name: Save PR number
       if: github.event_name == 'pull_request'
       env:

.github/workflows/code_size_comment.yml

@@ -15,7 +15,7 @@ jobs:
     steps:
       - name: 'Download artifact'
         id: download-artifact
-        uses: actions/github-script@v7
+        uses: actions/github-script@v8
         with:
           result-encoding: string
           script: |
@@ -56,7 +56,7 @@ jobs:
         run: unzip code-size-report.zip
       - name: Post comment to pull request
         if: steps.download-artifact.outputs.result == 'ok'
-        uses: actions/github-script@v7
+        uses: actions/github-script@v8
         with:
           github-token: ${{secrets.GITHUB_TOKEN}}
           script: |

.github/workflows/codespell.yml

@@ -6,7 +6,7 @@ jobs:
   codespell:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     # codespell version should be kept in sync with .pre-commit-config.yml
     - run: pip install --user codespell==2.4.1 tomli
     - run: codespell

.github/workflows/commit_formatting.yml

@@ -10,9 +10,9 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         fetch-depth: 100
-    - uses: actions/setup-python@v5
+    - uses: actions/setup-python@v6
     - name: Check commit message formatting
-      run: source tools/ci.sh && ci_commit_formatting_run
+      run: tools/ci.sh commit_formatting_run

.github/workflows/docs.yml

@@ -17,11 +17,11 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-python@v6
     - name: Install Python packages
       run: pip install -r docs/requirements.txt
     - name: Build unix port
-      run: source tools/ci.sh && ci_unix_build_helper
+      run: tools/ci.sh unix_build_helper
     - name: Build docs
       run: make -C docs/ html

.github/workflows/examples.yml

@@ -18,7 +18,7 @@ jobs:
   embedding:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build
       run: make -C examples/embedding -f micropython_embed.mk && make -C examples/embedding
     - name: Run

.github/workflows/mpremote.yml

@@ -11,12 +11,12 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         # Setting this to zero means fetch all history and tags,
         # which hatch-vcs can use to discover the version tag.
         fetch-depth: 0
-    - uses: actions/setup-python@v5
+    - uses: actions/setup-python@v6
     - name: Install build tools
       run: pip install build
     - name: Build mpremote wheel

.github/workflows/mpy_format.yml

@@ -6,6 +6,8 @@ on:
     paths:
       - '.github/workflows/*.yml'
       - 'examples/**'
+      - 'mpy-cross/**'
+      - 'py/**'
       - 'tests/**'
       - 'tools/**'
 
@@ -15,10 +17,12 @@ concurrency:
 
 jobs:
   test:
-    runs-on: ubuntu-22.04 # use 22.04 to get python2
+    runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_mpy_format_setup
+      run: tools/ci.sh mpy_format_setup
     - name: Test mpy-tool.py
-      run: source tools/ci.sh && ci_mpy_format_test
+      run: tools/ci.sh mpy_format_test
+    - name: Test mpy-cross debug emitter
+      run: tools/ci.sh mpy_cross_debug_emitter

.github/workflows/ports.yml

@@ -17,6 +17,6 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build ports download metadata
       run: mkdir boards && ./tools/autobuild/build-downloads.py . ./boards

.github/workflows/ports_alif.yml

@@ -26,8 +26,8 @@ jobs:
           - alif_ae3_build
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_alif_setup
+      run: tools/ci.sh alif_setup
     - name: Build ci_${{matrix.ci_func }}
-      run: source tools/ci.sh && ci_${{ matrix.ci_func }}
+      run: tools/ci.sh ${{ matrix.ci_func }}

.github/workflows/ports_cc3200.yml

@@ -21,8 +21,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_cc3200_setup
+      run: tools/ci.sh cc3200_setup
     - name: Build
-      run: source tools/ci.sh && ci_cc3200_build
+      run: tools/ci.sh cc3200_build

.github/workflows/ports_esp32.yml

@@ -12,6 +12,10 @@ on:
       - 'lib/**'
       - 'drivers/**'
       - 'ports/esp32/**'
+  schedule:
+     # Scheduled run exists to keep master branch ESP-IDF cache entry hot
+     # and prevent creating many redundant per-branch cache entries instead.
+     - cron: "20 0 * * *"
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -25,10 +29,11 @@ jobs:
         ci_func:  # names are functions in ci.sh
           - esp32_build_cmod_spiram_s2
           - esp32_build_s3_c3
-          - esp32_build_c2_c6
+          - esp32_build_c2_c5_c6
+          - esp32_build_p4
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
 
     - id: idf_ver
       name: Read the ESP-IDF version (including Python version)
@@ -47,7 +52,7 @@ jobs:
 
     - name: Install ESP-IDF packages
       if: steps.cache_esp_idf.outputs.cache-hit != 'true'
-      run: source tools/ci.sh && ci_esp32_idf_setup
+      run: tools/ci.sh esp32_idf_setup
 
     - name: ccache
       uses: hendrikmuhs/ccache-action@v1.2
@@ -55,4 +60,4 @@ jobs:
         key: esp32-${{ matrix.ci_func }}
 
     - name: Build ci_${{matrix.ci_func }}
-      run: source tools/ci.sh && ci_${{ matrix.ci_func }}
+      run: tools/ci.sh ${{ matrix.ci_func }}

.github/workflows/ports_esp8266.yml

@@ -21,8 +21,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_esp8266_setup && ci_esp8266_path >> $GITHUB_PATH
+      run: tools/ci.sh esp8266_setup && tools/ci.sh esp8266_path >> $GITHUB_PATH
     - name: Build
-      run: source tools/ci.sh && ci_esp8266_build
+      run: tools/ci.sh esp8266_build

.github/workflows/ports_mimxrt.yml

@@ -24,10 +24,10 @@ jobs:
       run:
         working-directory: 'micropython repo'  # test build with space in path
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         path: 'micropython repo'
     - name: Install packages
-      run: source tools/ci.sh && ci_mimxrt_setup
+      run: tools/ci.sh mimxrt_setup
     - name: Build
-      run: source tools/ci.sh && ci_mimxrt_build
+      run: tools/ci.sh mimxrt_build

.github/workflows/ports_nrf.yml

@@ -21,8 +21,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_nrf_setup
+      run: tools/ci.sh nrf_setup
     - name: Build
-      run: source tools/ci.sh && ci_nrf_build
+      run: tools/ci.sh nrf_build

.github/workflows/ports_powerpc.yml

@@ -21,8 +21,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_powerpc_setup
+      run: tools/ci.sh powerpc_setup
     - name: Build
-      run: source tools/ci.sh && ci_powerpc_build
+      run: tools/ci.sh powerpc_build

.github/workflows/ports_qemu.yml

@@ -26,14 +26,15 @@ jobs:
         ci_func:  # names are functions in ci.sh
           - bigendian
           - sabrelite
-          - thumb
+          - thumb_softfp
+          - thumb_hardfp
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_qemu_setup_arm
+      run: tools/ci.sh qemu_setup_arm
     - name: Build and run test suite ci_qemu_build_arm_${{ matrix.ci_func }}
-      run: source tools/ci.sh && ci_qemu_build_arm_${{ matrix.ci_func }}
+      run: tools/ci.sh qemu_build_arm_${{ matrix.ci_func }}
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -41,11 +42,23 @@ jobs:
   build_and_test_rv32:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_qemu_setup_rv32
+      run: tools/ci.sh qemu_setup_rv32
     - name: Build and run test suite
-      run: source tools/ci.sh && ci_qemu_build_rv32
+      run: tools/ci.sh qemu_build_rv32
+    - name: Print failures
+      if: failure()
+      run: tests/run-tests.py --print-failures
+
+  build_and_test_rv64:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    - name: Install packages
+      run: tools/ci.sh qemu_setup_rv64
+    - name: Build and run test suite
+      run: tools/ci.sh qemu_build_rv64
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures

.github/workflows/ports_renesas-ra.yml

@@ -21,9 +21,9 @@ jobs:
   build_renesas_ra_board:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_renesas_ra_setup
+      run: tools/ci.sh renesas_ra_setup
     - name: Build
-      run: source tools/ci.sh && ci_renesas_ra_board_build
+      run: tools/ci.sh renesas_ra_board_build
 

.github/workflows/ports_rp2.yml

@@ -24,10 +24,10 @@ jobs:
       run:
         working-directory: 'micropython repo'  # test build with space in path
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         path: 'micropython repo'
     - name: Install packages
-      run: source tools/ci.sh && ci_rp2_setup
+      run: tools/ci.sh rp2_setup
     - name: Build
-      run: source tools/ci.sh && ci_rp2_build
+      run: tools/ci.sh rp2_build

.github/workflows/ports_samd.yml

@@ -21,8 +21,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_samd_setup
+      run: tools/ci.sh samd_setup
     - name: Build
-      run: source tools/ci.sh && ci_samd_build
+      run: tools/ci.sh samd_build

.github/workflows/ports_stm32.yml

@@ -28,9 +28,9 @@ jobs:
           - stm32_misc_build
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_stm32_setup
+      run: tools/ci.sh stm32_setup && tools/ci.sh stm32_path >> $GITHUB_PATH
     - name: Build ci_${{matrix.ci_func }}
-      run: source tools/ci.sh && ci_${{ matrix.ci_func }}
+      run: tools/ci.sh ${{ matrix.ci_func }}
 

.github/workflows/ports_unix.yml

@@ -23,11 +23,11 @@ jobs:
   minimal:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build
-      run: source tools/ci.sh && ci_unix_minimal_build
+      run: tools/ci.sh unix_minimal_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_minimal_run_tests
+      run: tools/ci.sh unix_minimal_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -35,9 +35,9 @@ jobs:
   reproducible:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build with reproducible date
-      run: source tools/ci.sh && ci_unix_minimal_build
+      run: tools/ci.sh unix_minimal_build
       env:
         SOURCE_DATE_EPOCH: 1234567890
     - name: Check reproducible build date
@@ -46,11 +46,11 @@ jobs:
   standard:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build
-      run: source tools/ci.sh && ci_unix_standard_build
+      run: tools/ci.sh unix_standard_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_standard_run_tests
+      run: tools/ci.sh unix_standard_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -58,11 +58,11 @@ jobs:
   standard_v2:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build
-      run: source tools/ci.sh && ci_unix_standard_v2_build
+      run: tools/ci.sh unix_standard_v2_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_standard_v2_run_tests
+      run: tools/ci.sh unix_standard_v2_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -70,24 +70,24 @@ jobs:
   coverage:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-python@v6
       # Python 3.12 is the default for ubuntu-24.04, but that has compatibility issues with settrace tests.
       # Can remove this step when ubuntu-latest uses a more recent Python 3.x as the default.
       with:
         python-version: '3.11'
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_coverage_setup
+      run: tools/ci.sh unix_coverage_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_coverage_build
+      run: tools/ci.sh unix_coverage_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_coverage_run_tests
+      run: tools/ci.sh unix_coverage_run_tests
     - name: Test merging .mpy files
-      run: source tools/ci.sh && ci_unix_coverage_run_mpy_merge_tests
+      run: tools/ci.sh unix_coverage_run_mpy_merge_tests
     - name: Build native mpy modules
-      run: source tools/ci.sh && ci_native_mpy_modules_build
+      run: tools/ci.sh native_mpy_modules_build
     - name: Test importing .mpy generated by mpy_ld.py
-      run: source tools/ci.sh && ci_unix_coverage_run_native_mpy_tests
+      run: tools/ci.sh unix_coverage_run_native_mpy_tests
     - name: Run gcov coverage analysis
       run: |
         (cd ports/unix && gcov -o build-coverage/py ../../py/*.c || true)
@@ -105,45 +105,45 @@ jobs:
   coverage_32bit:
     runs-on: ubuntu-22.04 # use 22.04 to get libffi-dev:i386
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_32bit_setup
+      run: tools/ci.sh unix_32bit_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_coverage_32bit_build
+      run: tools/ci.sh unix_coverage_32bit_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_coverage_32bit_run_tests
+      run: tools/ci.sh unix_coverage_32bit_run_tests
     - name: Build native mpy modules
-      run: source tools/ci.sh && ci_native_mpy_modules_32bit_build
+      run: tools/ci.sh native_mpy_modules_32bit_build
     - name: Test importing .mpy generated by mpy_ld.py
-      run: source tools/ci.sh && ci_unix_coverage_32bit_run_native_mpy_tests
+      run: tools/ci.sh unix_coverage_32bit_run_native_mpy_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
 
   nanbox:
-    runs-on: ubuntu-22.04 # use 22.04 to get python2, and libffi-dev:i386
+    runs-on: ubuntu-22.04 # use 22.04 to get libffi-dev:i386
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_32bit_setup
+      run: tools/ci.sh unix_32bit_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_nanbox_build
+      run: tools/ci.sh unix_nanbox_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_nanbox_run_tests
+      run: tools/ci.sh unix_nanbox_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
 
   longlong:
-    runs-on: ubuntu-22.04 # use 22.04 to get python2, and libffi-dev:i386
+    runs-on: ubuntu-22.04 # use 22.04 to get libffi-dev:i386
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_32bit_setup
+      run: tools/ci.sh unix_32bit_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_longlong_build
+      run: tools/ci.sh unix_longlong_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_longlong_run_tests
+      run: tools/ci.sh unix_longlong_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -151,11 +151,11 @@ jobs:
   float:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build
-      run: source tools/ci.sh && ci_unix_float_build
+      run: tools/ci.sh unix_float_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_float_run_tests
+      run: tools/ci.sh unix_float_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -163,11 +163,11 @@ jobs:
   gil_enabled:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build
-      run: source tools/ci.sh && ci_unix_gil_enabled_build
+      run: tools/ci.sh unix_gil_enabled_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_gil_enabled_run_tests
+      run: tools/ci.sh unix_gil_enabled_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -175,13 +175,13 @@ jobs:
   stackless_clang:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_clang_setup
+      run: tools/ci.sh unix_clang_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_stackless_clang_build
+      run: tools/ci.sh unix_stackless_clang_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_stackless_clang_run_tests
+      run: tools/ci.sh unix_stackless_clang_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -189,13 +189,13 @@ jobs:
   float_clang:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_clang_setup
+      run: tools/ci.sh unix_clang_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_float_clang_build
+      run: tools/ci.sh unix_float_clang_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_float_clang_run_tests
+      run: tools/ci.sh unix_float_clang_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -203,31 +203,45 @@ jobs:
   settrace_stackless:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-python@v6
       # Python 3.12 is the default for ubuntu-24.04, but that has compatibility issues with settrace tests.
       # Can remove this step when ubuntu-latest uses a more recent Python 3.x as the default.
       with:
         python-version: '3.11'
     - name: Build
-      run: source tools/ci.sh && ci_unix_settrace_stackless_build
+      run: tools/ci.sh unix_settrace_stackless_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_settrace_stackless_run_tests
+      run: tools/ci.sh unix_settrace_stackless_run_tests
+    - name: Print failures
+      if: failure()
+      run: tests/run-tests.py --print-failures
+
+  repr_b:
+    runs-on: ubuntu-22.04 # use 22.04 to get libffi-dev:i386
+    steps:
+    - uses: actions/checkout@v6
+    - name: Install packages
+      run: tools/ci.sh unix_32bit_setup
+    - name: Build
+      run: tools/ci.sh unix_repr_b_build
+    - name: Run main test suite
+      run: tools/ci.sh unix_repr_b_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
 
   macos:
-    runs-on: macos-latest
+    runs-on: macos-26
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-python@v6
       with:
         python-version: '3.8'
     - name: Build
-      run: source tools/ci.sh && ci_unix_macos_build
+      run: tools/ci.sh unix_macos_build
     - name: Run tests
-      run: source tools/ci.sh && ci_unix_macos_run_tests
+      run: tools/ci.sh unix_macos_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -236,13 +250,13 @@ jobs:
     # ubuntu-22.04 is needed for older libffi.
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_qemu_mips_setup
+      run: tools/ci.sh unix_qemu_mips_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_qemu_mips_build
+      run: tools/ci.sh unix_qemu_mips_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_qemu_mips_run_tests
+      run: tools/ci.sh unix_qemu_mips_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -251,13 +265,13 @@ jobs:
     # ubuntu-22.04 is needed for older libffi.
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_qemu_arm_setup
+      run: tools/ci.sh unix_qemu_arm_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_qemu_arm_build
+      run: tools/ci.sh unix_qemu_arm_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_qemu_arm_run_tests
+      run: tools/ci.sh unix_qemu_arm_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -266,13 +280,13 @@ jobs:
     # ubuntu-22.04 is needed for older libffi.
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_qemu_riscv64_setup
+      run: tools/ci.sh unix_qemu_riscv64_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_qemu_riscv64_build
+      run: tools/ci.sh unix_qemu_riscv64_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_qemu_riscv64_run_tests
+      run: tools/ci.sh unix_qemu_riscv64_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -280,24 +294,24 @@ jobs:
   sanitize_address:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-python@v6
       # Python 3.12 is the default for ubuntu-24.04, but that has compatibility issues with settrace tests.
       # Can remove this step when ubuntu-latest uses a more recent Python 3.x as the default.
       with:
         python-version: '3.11'
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_coverage_setup
+      run: tools/ci.sh unix_coverage_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_sanitize_address_build
+      run: tools/ci.sh unix_sanitize_address_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_sanitize_address_run_tests
+      run: tools/ci.sh unix_sanitize_address_run_tests
     - name: Test merging .mpy files
-      run: source tools/ci.sh && ci_unix_coverage_run_mpy_merge_tests
+      run: tools/ci.sh unix_coverage_run_mpy_merge_tests
     - name: Build native mpy modules
-      run: source tools/ci.sh && ci_native_mpy_modules_build
+      run: tools/ci.sh native_mpy_modules_build
     - name: Test importing .mpy generated by mpy_ld.py
-      run: source tools/ci.sh && ci_unix_coverage_run_native_mpy_tests
+      run: tools/ci.sh unix_coverage_run_native_mpy_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -305,24 +319,24 @@ jobs:
   sanitize_undefined:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-python@v6
       # Python 3.12 is the default for ubuntu-24.04, but that has compatibility issues with settrace tests.
       # Can remove this step when ubuntu-latest uses a more recent Python 3.x as the default.
       with:
         python-version: '3.11'
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_coverage_setup
+      run: tools/ci.sh unix_coverage_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_sanitize_undefined_build
+      run: tools/ci.sh unix_sanitize_undefined_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_sanitize_undefined_run_tests
+      run: tools/ci.sh unix_sanitize_undefined_run_tests
     - name: Test merging .mpy files
-      run: source tools/ci.sh && ci_unix_coverage_run_mpy_merge_tests
+      run: tools/ci.sh unix_coverage_run_mpy_merge_tests
     - name: Build native mpy modules
-      run: source tools/ci.sh && ci_native_mpy_modules_build
+      run: tools/ci.sh native_mpy_modules_build
     - name: Test importing .mpy generated by mpy_ld.py
-      run: source tools/ci.sh && ci_unix_coverage_run_native_mpy_tests
+      run: tools/ci.sh unix_coverage_run_native_mpy_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures

.github/workflows/ports_webassembly.yml

@@ -11,6 +11,7 @@ on:
       - 'shared/**'
       - 'lib/**'
       - 'ports/webassembly/**'
+      - 'tests/**'
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -20,13 +21,13 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_webassembly_setup
+      run: tools/ci.sh webassembly_setup
     - name: Build
-      run: source tools/ci.sh && ci_webassembly_build
+      run: tools/ci.sh webassembly_build
     - name: Run tests
-      run: source tools/ci.sh && ci_webassembly_run_tests
+      run: tools/ci.sh webassembly_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures

.github/workflows/ports_windows.yml

@@ -29,8 +29,10 @@ jobs:
         include:
         - visualstudio: '2017'
           vs_version: '[15, 16)'
+          custom_vs_install: true
         - visualstudio: '2019'
           vs_version: '[16, 17)'
+          custom_vs_install: true
         - visualstudio: '2022'
           vs_version: '[17, 18)'
         # trim down the number of jobs in the matrix
@@ -43,22 +45,21 @@ jobs:
     env:
       CI_BUILD_CONFIGURATION: ${{ matrix.configuration }}
     steps:
-    - name: Install Visual Studio 2017
-      if: matrix.visualstudio == '2017'
+    - name: Install Visual Studio ${{ matrix.visualstudio }}
+      if: matrix.custom_vs_install
+      shell: bash
+      # Shell functions in this block are to retry intermittent corrupt
+      # downloads (with a clean download dir) before failing the job outright
       run: |
-        choco install visualstudio2017buildtools
-        choco install visualstudio2017-workload-vctools
-        choco install windows-sdk-8.1
-    - name: Install Visual Studio 2019
-      if: matrix.visualstudio == '2019'
-      run: |
-        choco install visualstudio2019buildtools
-        choco install visualstudio2019-workload-vctools
-        choco install windows-sdk-8.1
+        try () { ($@) || ($@) || ($@) || ($@) }
+        clean_install () ( rm -rf $TEMP/chocolatey; choco install $1 )
+        try clean_install visualstudio${{ matrix.visualstudio }}buildtools
+        try clean_install visualstudio${{ matrix.visualstudio }}-workload-vctools
+        try clean_install windows-sdk-8.1
     - uses: microsoft/setup-msbuild@v2
       with:
         vs-version: ${{ matrix.vs_version }}
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build mpy-cross.exe
       run: msbuild mpy-cross\mpy-cross.vcxproj -maxcpucount -property:Configuration=${{ matrix.configuration }} -property:Platform=${{ matrix.platform }}
     - name: Update submodules
@@ -109,7 +110,7 @@ jobs:
       run:
         shell: msys2 {0}
     steps:
-    - uses: actions/setup-python@v5
+    - uses: actions/setup-python@v6
       # note: can go back to installing mingw-w64-${{ matrix.env }}-python after
       # MSYS2 updates to Python >3.12 (due to settrace compatibility issue)
       with:
@@ -125,7 +126,7 @@ jobs:
           git
           diffutils
         path-type: inherit  # Remove when setup-python is removed
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build mpy-cross.exe
       run: make -C mpy-cross -j2
     - name: Update submodules
@@ -143,8 +144,8 @@ jobs:
   cross-build-on-linux:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_windows_setup
+      run: tools/ci.sh windows_setup
     - name: Build
-      run: source tools/ci.sh && ci_windows_build
+      run: tools/ci.sh windows_build

.github/workflows/ports_zephyr.yml

@@ -11,6 +11,11 @@ on:
       - 'shared/**'
       - 'lib/**'
       - 'ports/zephyr/**'
+      - 'tests/**'
+  schedule:
+     # Scheduled run exists to keep master branch Zephyr cache entry hot
+     # and prevent creating many redundant per-branch cache entries instead.
+     - cron: "40 4 * * *"
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -23,13 +28,16 @@ jobs:
     - uses: jlumbroso/free-disk-space@main
       with:
         # Only free up a few things so this step runs quickly.
+        # (android would save 9.6GiB, but takes about 13m)
+        # (large-packages would save 4.6GiB, but takes about 3m)
         android: false
         dotnet: true
         haskell: true
         large-packages: false
         docker-images: false
+        tool-cache: true
         swap-storage: false
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - id: versions
       name: Read Zephyr version
       run: source tools/ci.sh && echo "ZEPHYR=$ZEPHYR_VERSION" | tee "$GITHUB_OUTPUT"
@@ -47,14 +55,14 @@ jobs:
       with:
         key: zephyr
     - name: Install packages
-      run: source tools/ci.sh && ci_zephyr_setup
+      run: tools/ci.sh zephyr_setup
     - name: Install Zephyr
       if: steps.cache_workspace.outputs.cache-hit != 'true'
-      run: source tools/ci.sh && ci_zephyr_install
+      run: tools/ci.sh zephyr_install
     - name: Build
-      run: source tools/ci.sh && ci_zephyr_build
+      run: tools/ci.sh zephyr_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_zephyr_run_tests
+      run: tools/ci.sh zephyr_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures

.github/workflows/ruff.yml

@@ -6,7 +6,7 @@ jobs:
   ruff:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     # ruff version should be kept in sync with .pre-commit-config.yaml & also micropython-lib
     - run: pipx install ruff==0.11.6
     - run: ruff check --output-format=github .

.gitignore

@@ -24,3 +24,11 @@ user.props
 
 # MacOS desktop metadata files
 .DS_Store
+
+# Created by ci.sh zephyr targets
+/.ccache
+/zephyrproject
+
+# Created by ci.sh esp8266 targets
+/xtensa-lx106-elf-standalone.tar.gz
+/xtensa-lx106-elf/

.gitmodules

@@ -35,7 +35,7 @@
 	url = https://github.com/bluekitchen/btstack.git
 [submodule "lib/nxp_driver"]
 	path = lib/nxp_driver
-	url = https://github.com/hathach/nxp_driver.git
+	url = https://github.com/micropython/nxp_driver.git
 [submodule "lib/libhydrogen"]
 	path = lib/libhydrogen
 	url = https://github.com/jedisct1/libhydrogen.git

README.md

@@ -80,9 +80,8 @@ This repository contains the following components:
 - [examples/](examples/) -- a few example Python scripts.
 
 "make" is used to build the components, or "gmake" on BSD-based systems.
-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`). Some ports (rp2 and esp32) additionally use CMake.
+You will also need bash, gcc, and Python 3.3+ available as the command `python3`.
+Some ports (rp2 and esp32) additionally use CMake.
 
 Supported platforms & architectures
 -----------------------------------
@@ -99,28 +98,74 @@ development and testing of MicroPython itself, as well as providing
 lightweight alternative to CPython on these platforms (in particular on
 embedded Linux systems).
 
-The ["minimal"](ports/minimal) port provides an example of a very basic
-MicroPython port and can be compiled as both a standalone Linux binary as
-well as for ARM Cortex M4. Start with this if you want to port MicroPython to
-another microcontroller. Additionally the ["bare-arm"](ports/bare-arm) port
-is an example of the absolute minimum configuration, and is used to keep
-track of the code size of the core runtime and VM.
+Over twenty different MicroPython ports are provided in this repository,
+split across three
+[MicroPython Support Tiers](https://docs.micropython.org/en/latest/develop/support_tiers.html).
 
-In addition, the following ports are provided in this repository:
- - [cc3200](ports/cc3200) -- Texas Instruments CC3200 (including PyCom WiPy).
- - [esp32](ports/esp32) -- Espressif ESP32 SoC (including ESP32S2, ESP32S3, ESP32C3, ESP32C6).
- - [esp8266](ports/esp8266) -- Espressif ESP8266 SoC.
- - [mimxrt](ports/mimxrt) -- NXP m.iMX RT (including Teensy 4.x).
- - [nrf](ports/nrf) -- Nordic Semiconductor nRF51 and nRF52.
- - [pic16bit](ports/pic16bit) -- Microchip PIC 16-bit.
- - [powerpc](ports/powerpc) -- IBM PowerPC (including Microwatt)
- - [qemu](ports/qemu) -- QEMU-based emulated target (for testing)
- - [renesas-ra](ports/renesas-ra) -- Renesas RA family.
- - [rp2](ports/rp2) -- Raspberry Pi RP2040 (including Pico and Pico W).
- - [samd](ports/samd) -- Microchip (formerly Atmel) SAMD21 and SAMD51.
- - [stm32](ports/stm32) -- STMicroelectronics STM32 family (including F0, F4, F7, G0, G4, H7, L0, L4, WB)
- - [webassembly](ports/webassembly) -- Emscripten port targeting browsers and NodeJS.
- - [zephyr](ports/zephyr) -- Zephyr RTOS.
+Tier 1 Ports
+============
+
+👑 Ports in [Tier 1](https://docs.micropython.org/en/latest/develop/support_tiers.html)
+are mature and have the most active development, support and testing:
+
+| Port                     | Target                                                                                 | Quick Reference                                                      |
+|--------------------------|----------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+| [esp32](ports/esp32)*    | Espressif ESP32 SoCs (ESP32, ESP32S2, ESP32S3, ESP32C3, ESP32C6)                       | [here](https://docs.micropython.org/en/latest/esp32/quickref.html)   |
+| [mimxrt](ports/mimxrt)   | NXP m.iMX RT                                                                           | [here](https://docs.micropython.org/en/latest/mimxrt/quickref.html)  |
+| [rp2](ports/rp2)         | Raspberry Pi RP2040 and RP2350                                                         | [here](https://docs.micropython.org/en/latest/rp2/quickref.html)     |
+| [samd](ports/samd)       | Microchip (formerly Atmel) SAMD21 and SAMD51                                           | [here](https://docs.micropython.org/en/latest/samd/quickref.html)    |
+| [stm32](ports/stm32)     | STMicroelectronics STM32 MCUs (F0, F4, F7, G0, G4, H5, H7, L0, L1, L4, N6, WB, WL)     | [here](https://docs.micropython.org/en/latest/pyboard/quickref.html) |
+| [unix](ports/unix)       | Linux, BSD, macOS, WSL                                                                 | [here](https://docs.micropython.org/en/latest/unix/quickref.html)    |
+| [windows](ports/windows) | Microsoft Windows                                                                      | [here](https://docs.micropython.org/en/latest/unix/quickref.html)    |
+
+An asterisk indicates that the port has ongoing financial support from the vendor.
+
+Tier 2 Ports
+============
+
+✔ Ports in [Tier 2](https://docs.micropython.org/en/latest/develop/support_tiers.html)
+are less mature and less actively developed and tested than Tier 1, but
+still fully supported:
+
+| Port                             | Target                                                      | Quick Reference                                                         |
+|----------------------------------|-------------------------------------------------------------|-------------------------------------------------------------------------|
+| [alif](ports/alif)               | Alif Semiconductor Ensemble MCUs (E3, E7)                   |                                                                         |
+| [embed](ports/embed)             | Generates a set of .c/.h files for embedding into a project |                                                                         |
+| [nrf](ports/nrf)                 | Nordic Semiconductor nRF51 and nRF52                        |                                                                         |
+| [renesas-ra](ports/renesas-ra)   | Renesas RA family                                           | [here](https://docs.micropython.org/en/latest/renesas-ra/quickref.html) |
+| [webassembly](ports/webassembly) | Emscripten port targeting browsers and NodeJS               |                                                                         |
+| [zephyr](ports/zephyr)           | Zephyr RTOS                                                 | [here](https://docs.micropython.org/en/latest/zephyr/quickref.html)     |
+
+Tier 3 Ports
+============
+
+Ports in [Tier 3](https://docs.micropython.org/en/latest/develop/support_tiers.html)
+are built in CI but not regularly tested by the MicroPython maintainers:
+
+| Port                       | Target                                                            | Quick Reference                                                         |
+|----------------------------|-------------------------------------------------------------------|-------------------------------------------------------------------------|
+| [cc3200](ports/cc3200)     | Texas Instruments CC3200                                          | [For WiPy](https://docs.micropython.org/en/latest/wipy/quickref.html)   |
+| [esp8266](ports/esp8266)   | Espressif ESP8266 SoC                                             | [here](https://docs.micropython.org/en/latest/esp8266/quickref.html)    |
+| [pic16bit](ports/pic16bit) | Microchip PIC 16-bit                                              |                                                                         |
+| [powerpc](ports/powerpc)   | IBM PowerPC (including Microwatt)                                 |                                                                         |
+
+Additional Ports
+================
+
+In addition to the above there is a Tier M containing ports that are used
+primarily for maintenance, development and testing:
+
+- The ["bare-arm"](ports/bare-arm) port is an example of the absolute minimum
+  configuration that still includes the compiler, and is used to keep track
+  of the code size of the core runtime and VM.
+
+- The ["minimal"](ports/minimal) port provides an example of a very basic
+  MicroPython port and can be compiled as both a standalone Linux binary as
+  well as for ARM Cortex-M4. Start with this if you want to port MicroPython
+  to another microcontroller.
+
+- The [qemu](ports/qemu) port is a QEMU-based emulated target for Cortex-A,
+  Cortex-M, RISC-V 32-bit and RISC-V 64-bit architectures.
 
 The MicroPython cross-compiler, mpy-cross
 -----------------------------------------

docs/README.md

@@ -13,8 +13,7 @@ Building the documentation locally
 If you're making changes to the documentation, you may want to build the
 documentation locally so that you can preview your changes.
 
-Install Sphinx, and optionally (for the RTD-styling), sphinx_rtd_theme,
-preferably in a virtualenv:
+Install Sphinx and sphinx_rtd_theme, preferably in a virtualenv:
 
      pip install sphinx
      pip install sphinx_rtd_theme
@@ -25,6 +24,21 @@ In `micropython/docs`, build the docs:
 
 You'll find the index page at `micropython/docs/build/html/index.html`.
 
+Documentation autobuild
+-----------------------
+
+For a more convenient development experience, you can use `sphinx-autobuild`
+to automatically rebuild and serve the documentation when you make changes:
+
+    pip install sphinx-autobuild
+
+Then run from the `micropython/docs` directory:
+
+    sphinx-autobuild . build/html
+
+This will start a local web server (typically at `http://127.0.0.1:8000`)
+and automatically rebuild the documentation whenever you save changes to the source files.
+
 Having readthedocs.org build the documentation
 ----------------------------------------------
 

docs/conf.py

@@ -55,6 +55,7 @@ extensions = [
     "sphinx.ext.todo",
     "sphinx.ext.coverage",
     "sphinxcontrib.jquery",
+    "sphinx_rtd_theme",
 ]
 
 # Add any paths that contain templates here, relative to this directory.
@@ -128,20 +129,9 @@ rst_epilog = """
 
 # -- Options for HTML output ----------------------------------------------
 
-# on_rtd is whether we are on readthedocs.org
-on_rtd = os.environ.get("READTHEDOCS", None) == "True"
+import sphinx_rtd_theme
 
-if not on_rtd:  # only import and set the theme if we're building docs locally
-    try:
-        import sphinx_rtd_theme
-
-        html_theme = "sphinx_rtd_theme"
-        html_theme_path = [sphinx_rtd_theme.get_html_theme_path(), "."]
-    except:
-        html_theme = "default"
-        html_theme_path = ["."]
-else:
-    html_theme_path = ["."]
+html_theme = "sphinx_rtd_theme"
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the

docs/develop/gettingstarted.rst

@@ -106,7 +106,7 @@ See the `ARM GCC
 toolchain <https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads>`_
 for the latest details.
 
-Python is also required. Python 2 is supported for now, but we recommend using Python 3.
+Python 3 is also required.
 Check that you have Python available on your system:
 
 .. code-block:: bash
@@ -282,6 +282,82 @@ To run a selection of tests on a board/device connected over USB use:
 
 See also :ref:`writingtests`.
 
+Additional make targets for developers
+--------------------------------------
+
+In all ``make``-based ports, there is a target to print the size of a specific object file.
+When a change is confined to a single file, this is useful when testing variations to find smaller alternatives.
+
+For instance, to print the size of ``objstr.o`` in the ``py/`` directory when making a unix standard build:
+
+.. code-block:: bash
+
+   $ make build-standard/py/objstr.sz
+
+Similarly, there is a target to save the preprocessed version of a file:
+
+.. code-block:: bash
+
+   $ make build-standard/py/objstr.pp
+
+In ``ports/unix`` there are additional targets related to running tests:
+
+.. code-block:: bash
+
+   $ make test//int       # Run all tests matching the pattern "int"
+   $ make test/ports/unix # Run all tests in ports/unix
+   $ make test-failures   # Re-run only the failed tests
+   $ make print-failures  # print the differences for failed tests
+   $ make clean-failures  # delete the .exp and .out files from failed tests
+
+Using ci.sh locally
+-------------------
+
+MicroPython uses GitHub Actions for continuous integration.
+To reduce dependence on any specific CI system, the actual build steps for Unix-based builds are in the file ``tools/ci.sh``.
+This can also be used as a script on developer desktops, with caveats:
+
+* For most steps, An Ubuntu/Debian system similar to the one used during CI is assumed.
+* Some specific steps assume specific Ubuntu versions.
+* The setup steps may invoke the system package manager to install packages,
+  download and install software from the internet, etc.
+
+To get a usage message including the list of commands, run:
+
+.. code-block:: bash
+
+   $ tools/ci.sh --help
+
+As an example, you can build and test the unix minimal port with:
+
+.. code-block:: bash
+
+   $ tools/ci.sh unix_minimal_build unix_minimal_run_tests
+
+If you use the bash shell, you can add a ``ci`` command with tab completion:
+
+.. code-block:: bash
+
+   $ eval $(tools/ci.sh --bash-completion)
+
+For the zsh shell, replace ``--bash-completion`` with ``--zsh-completion``.
+For the fish shell, replace ``--bash-completion`` with ``--fish-completion``.
+
+Then, typing:
+
+.. code-block:: bash
+
+   $ ci unix_cov<tab>
+
+This will complete the ci step name to ``unix_coverage_``.
+Pressing tab a second time will show the list of matching steps:
+
+.. code-block:: bash
+
+   $ ci unix_coverage_<tab>
+   unix_coverage_32bit_build
+   unix_coverage_32bit_run_native_mpy_tests…
+
 Folder structure
 ----------------
 

docs/develop/index.rst

@@ -24,3 +24,4 @@ MicroPython to a new platform and implementing a core MicroPython library.
    publiccapi.rst
    extendingmicropython.rst
    porting.rst
+   support_tiers.rst

docs/develop/porting.rst

@@ -42,7 +42,6 @@ The basic MicroPython firmware is implemented in the main port file, e.g ``main.
    #include "py/compile.h"
    #include "py/gc.h"
    #include "py/mperrno.h"
-   #include "py/stackctrl.h"
    #include "shared/runtime/gchelper.h"
    #include "shared/runtime/pyexec.h"
 
@@ -51,7 +50,7 @@ The basic MicroPython firmware is implemented in the main port file, e.g ``main.
 
    int main(int argc, char **argv) {
        // Initialise the MicroPython runtime.
-       mp_stack_ctrl_init();
+       mp_cstack_init_with_sp_here(2048);
        gc_init(heap, heap + sizeof(heap));
        mp_init();
 
@@ -162,8 +161,6 @@ The following is an example of an ``mpconfigport.h`` file:
 
    // Type definitions for the specific machine.
 
-   typedef intptr_t mp_int_t; // must be pointer size
-   typedef uintptr_t mp_uint_t; // must be pointer size
    typedef long mp_off_t;
 
    // We need to provide a declaration/definition of alloca().

docs/develop/support_tiers.rst

@@ -0,0 +1,68 @@
+MicroPython Support Tiers
+=========================
+
+MicroPython operates with a set of Support Tier levels for the various ports.
+Tiers 1, 2 and 3 are the main Tier levels with Tier 1 being the most mature and
+actively maintained.  There is also Tier M for additional ports used primarily
+for maintenance, development and testing. These Tier levels are defined in the
+table below.
+
+.. table::
+  :widths: 40 9 9 9 9
+
+  +-----------------------------------------------+--------+--------+--------+--------+
+  |                                               | Tier 1 | Tier 2 | Tier 3 | Tier M |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | builds pass under CI                          | ✔      | ✔      | ✔      | ✔      |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | tests run under CI (where possible)           | ✔      | ✔      | ✔      | ✔      |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | actively maintained                           | ✔      | ✔      |        | ✔      |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | stable Python API                             | ✔      | ✔      |        |        |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | new features actively developed               | ✔      | ✔      |        |        |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | tested on hardware for releases               | ✔      | ✔      |        |        |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | prioritized bug reports                       | ✔      |        |        | ✔      |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | regressions warrant a patch release           | ✔      |        |        | ✔      |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | has port-specific documentation               | ✔      |        |        |        |
+  +-----------------------------------------------+--------+--------+--------+--------+
+
+Lower Tiers may tick more boxes, but the above table defines the minimum requirements
+for a port to belong to a Tier.
+
+Tier 1 ports:
+
+  - esp32
+  - mimxrt
+  - rp2
+  - samd
+  - stm32
+  - unix
+  - windows
+
+Tier 2 ports:
+
+  - alif
+  - embed
+  - nrf
+  - renesas-ra
+  - webassembly
+  - zephyr
+
+Tier 3 ports:
+
+  - cc3200
+  - esp8266
+  - pic16bit
+  - powerpc
+
+Tier M ports:
+
+  - bare-arm
+  - minimal
+  - qemu

docs/esp32/quickref.rst

@@ -287,6 +287,10 @@ with a timer ID of 0, 0 and 1, or from 0 to 3 (inclusive)::
 The period is in milliseconds. When using UART.IRQ_RXIDLE, timer 0 is needed for
 the IRQ_RXIDLE mechanism and must not be used otherwise.
 
+Timer callbacks are scheduled as soft interrupts on this port; hard
+callbacks are not implemented. Specifying ``hard=True`` will raise
+a ValueError.
+
 Virtual timers are not currently supported on this port.
 
 .. _Pins_and_GPIO:
@@ -833,9 +837,9 @@ The RMT is ESP32-specific and allows generation of accurate digital pulses with
     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 = esp32.RMT(pin=Pin(18), resolution_hz=10000000)
+    r   # RMT(pin=18, source_freq=80000000, resolution_hz=10000000)
+    # The channel resolution is based on resolution_hz, i.e. 100ns for 10000000
     r.write_pulses((1, 20, 2, 40), 0) # Send 0 for 100ns, 1 for 2000ns, 0 for 200ns, 1 for 4000ns
 
 The ESP32-C2 family does not include any RMT peripheral, so this class is
@@ -899,8 +903,7 @@ The APA106 driver extends NeoPixel, but internally uses a different colour order
    ``NeoPixel`` object.
 
 For low-level driving of a NeoPixel see `machine.bitstream`.
-This low-level driver uses an RMT channel by default.  To configure this see
-`RMT.bitstream_channel`.
+This low-level driver uses an RMT channel by default.
 
 APA102 (DotStar) uses a different driver as it has an additional clock pin.
 

docs/esp8266/quickref.rst

@@ -108,6 +108,9 @@ with timer ID of -1::
 
 The period is in milliseconds.
 
+By default, timer callbacks are scheduled as soft interrupts on this port.
+Specify ``hard=True`` to run them in hard interrupt context instead.
+
 Pins and GPIO
 -------------
 

docs/library/collections.rst

@@ -101,3 +101,19 @@ Classes
         a 2
         w 5
         b 3
+
+    .. method:: OrderedDict.popitem()
+
+        Remove and return a (key, value) pair from the dictionary.
+        Pairs are returned in LIFO order.
+
+        .. admonition:: Difference to CPython
+            :class: attention
+
+            ``OrderedDict.popitem()`` does not support the ``last=False`` argument and
+            will always remove and return the last item if present.
+
+            A workaround for this is to use ``pop(<first_key>)`` to remove the first item::
+
+                first_key = next(iter(d))
+                d.pop(first_key)

docs/library/esp32.rst

@@ -43,6 +43,15 @@ Functions
 
     .. note:: This is only available for boards that have ext1 support.
 
+.. function:: wake_on_gpio(pins, level)
+
+    Configure how GPIO wakes the device from sleep.  *pins* can be ``None``
+    or a tuple/list of valid Pin objects.  *level* should be ``esp32.WAKEUP_ALL_LOW``
+    or ``esp32.WAKEUP_ANY_HIGH``.
+
+    .. note:: Some boards don't support waking on GPIO from deep sleep,
+       on those boards, the pins set here can only be used to wake from light sleep.
+
 .. function:: gpio_deep_sleep_hold(enable)
 
     Configure whether non-RTC GPIO pin configuration is retained during
@@ -353,29 +362,24 @@ 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, idle_level=0)
+    r = esp32.RMT(pin=Pin(18), resolution_hz=10000000)
+    r  # RMT(pin=18, source_freq=80000000, resolution_hz=10000000, idle_level=0)
 
     # To apply a carrier frequency to the high output
-    r = esp32.RMT(0, pin=Pin(18), clock_div=8, tx_carrier=(38000, 50, 1))
+    r = esp32.RMT(pin=Pin(18), resolution_hz=10000000, tx_carrier=(38000, 50, 1))
 
-    # The channel resolution is 100ns (1/(source_freq/clock_div)).
+    # The channel resolution is 100ns (1/resolution_hz)
     r.write_pulses((1, 20, 2, 40), 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 specified in ``write_pulses`` are multiplied by the resolution to
+configure the input clock but, for now, it's fixed). ``resolution_hz`` determines
+the resolution of the RMT channel. The numbers specified 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 (1-``PULSE_MAX``) 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].
+So, in the example above, the resolution is resolution is (1/10Mhz) = 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>`_.
@@ -386,13 +390,24 @@ For more details see Espressif's `ESP-IDF RMT documentation.
    *beta feature* and the interface may change in the future.
 
 
-.. class:: RMT(channel, *, pin=None, clock_div=8, idle_level=False, tx_carrier=None)
+.. class:: RMT(channel, *, pin=None, resolution_hz=10000000, clock_div=None, idle_level=False, num_symbols=48|64, tx_carrier=None)
 
     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. *idle_level* specifies
+    optional and a dummy parameter for backward compatibility. *pin* is required
+    and configures which Pin is bound to the RMT channel.
+    *resolution_hz* defines the resolution/unit of the samples.
+    For example, 1,000,000 means the unit is microsecond. The pulse widths can
+    assume values up to *RMT.PULSE_MAX*, so the resolution should be selected
+    accordingly to the signal to be transmitted.
+    *clock_div* (deprecated) is equivalent to *resolution_hz*, but expressed as
+    a clock divider that divides the source clock (80MHz) to the RMT
+    channel allowing the resolution to be specified. Either *clock_div* and
+    *resolution_hz* may be supplied, but not both.
+    *num_symbols* specifies the
+    RMT buffer allocated for this channel (minimum 48 or 64, depending on chip), from a small pool of
+    symbols (192 to 512, depending on chip) that are shared by all channels. This buffer does not limit the
+    size of the pulse train that you can send, but bigger buffers reduce the
+    CPU load and the potential of glitches/imprecise pulse lengths. *idle_level* specifies
     what level the output will be when no transmission is in progress and can
     be any value that converts to a boolean, with ``True`` representing high
     voltage and ``False`` representing low.
@@ -410,21 +425,52 @@ For more details see Espressif's `ESP-IDF RMT documentation.
 .. method:: RMT.clock_div()
 
     Return the clock divider. Note that the channel resolution is
-    ``1 / (source_freq / clock_div)``.
+    ``1 / (source_freq / clock_div)``. (Method deprecated. The value may
+    not be faithful if resolution was supplied as *resolution_hz*.)
 
 .. method:: RMT.wait_done(*, timeout=0)
 
     Returns ``True`` if the channel is idle or ``False`` if a sequence of
     pulses started with `RMT.write_pulses` is being transmitted. If the
     *timeout* keyword argument is given then block for up to this many
-    milliseconds for transmission to complete.
+    milliseconds for transmission to complete. Timeout of -1 blocks until
+    transmission is complete (and blocks forever if loop is enabled).
 
 .. method:: RMT.loop(enable_loop)
 
     Configure looping on the channel. *enable_loop* is bool, set to ``True`` to
     enable looping on the *next* call to `RMT.write_pulses`. If called with
     ``False`` while a looping sequence is currently being transmitted then the
-    current loop iteration will be completed and then transmission will stop.
+    transmission will stop. (Method deprecated by `RMT.loop_count`.)
+
+.. method:: RMT.loop_count(n)
+
+    Configure looping on the channel. *n* is int. Affects the *next* call to
+    `RMT.write_pulses`. Set to ``0`` to disable looping, ``-1`` to enable
+    infinite looping, or a positive number to loop for a given number of times.
+    If *n* is changed, the current transmission is stopped.
+
+    Note: looping for a finite number of times is not supported by all flavors
+    of ESP32.
+
+.. method:: RMT.active([boolean])
+
+    If called without parameters, returns *True* if there is an ongoing transmission.
+
+    If called with parameter *False*, stops the ongoing transmission.
+    This is useful to stop an infinite transmission loop.
+    The current loop is finished and transmission stops.
+    The object is not invalidated, and the RMT channel is again enabled when a new
+    transmission is started.
+
+    Calling with parameter *True* does not restart transmission. A new transmission
+    should always be initiated by *write_pulses()*.
+
+.. method:: RMT.deinit()
+
+    Release all RMT resources and invalidate the object. All subsequent method
+    calls will raise OSError. Useful to free RMT resources without having to wait
+    for the object to be garbage-collected.
 
 .. method:: RMT.write_pulses(duration, data=True)
 
@@ -454,17 +500,28 @@ For more details see Espressif's `ESP-IDF RMT documentation.
     new sequence of pulses. Looping sequences longer than 126 pulses is not
     supported by the hardware.
 
+.. staticmethod:: RMT.bitstream_rmt([value])
+
+    Configure RMT usage in the `machine.bitstream` implementation.
+
+    If *value* is ``True``, bitstream tries to use RMT if possible. If *value*
+    is ``False``, bitstream sticks to the bit-banging implementation.
+
+    If no parameter is supplied, it returns the current state. The default state
+    is ``True``.
+
 .. staticmethod:: RMT.bitstream_channel([value])
 
-    Select which RMT channel is used by the `machine.bitstream` implementation.
-    *value* can be ``None`` or a valid RMT channel number.  The default RMT
-    channel is the highest numbered one.
+    *This function is deprecated and will be replaced by `RMT.bitstream_rmt()`.*
 
-    Passing in ``None`` disables the use of RMT and instead selects a bit-banging
-    implementation for `machine.bitstream`.
+    Passing in no argument will return ``1`` if RMT was enabled for the `machine.bitstream`
+    feature, and ``None`` otherwise.
 
-    Passing in no argument will not change the channel.  This function returns
-    the current channel number.
+    Passing any non-negative integer argument is equivalent to calling ``RMT.bitstream_rmt(True)``.
+
+    .. note:: In previous versions of MicroPython it was necessary to use this function to assign
+              a specific RMT channel number for the bitstream, but the channel number is now assigned
+              dynamically.
 
 Constants
 ---------

docs/library/espnow.rst

@@ -164,13 +164,15 @@ Configuration
         wait forever. The timeout can also be provided as arg to
         `recv()`/`irecv()`/`recvinto()`.
 
-        *rate*: (ESP32 only) Set the transmission speed for
-        ESPNow packets. Must be set to a number from the allowed numeric values
-        in `enum wifi_phy_rate_t
-        <https://docs.espressif.com/projects/esp-idf/en/v5.2.3/esp32/
+        *rate*: (ESP32 only) Set the transmission data rate for ESPNow packets.
+        The default setting is `espnow.RATE_1M`. It's recommended to use one of
+        the other ``espnow.RATE_nnn`` constants to set this, but it's also
+        possible to pass an integer corresponding to the `enum wifi_phy_rate_t
+        <https://docs.espressif.com/projects/esp-idf/en/v5.5.1/esp32/
         api-reference/network/esp_wifi.html#_CPPv415wifi_phy_rate_t>`_. This
         parameter is actually *write-only* due to ESP-IDF not providing any
         means for querying the radio interface's rate parameter.
+        See also `espnow-long-range`. This API currently doesn't work on ESP32-C6.
 
     .. data:: Returns:
 
@@ -574,6 +576,45 @@ Constants
           espnow.MAX_TOTAL_PEER_NUM(=20)
           espnow.MAX_ENCRYPT_PEER_NUM(=6)
 
+The following constants correspond to different transmit data rates on ESP32
+only. Lower data rates are generally more reliable over long distances:
+
+.. data:: espnow.RATE_LORA_250K
+          espnow.RATE_LORA_500K
+
+             See  `espnow-long-range`.
+
+.. data:: espnow.RATE_1M
+          espnow.RATE_2M
+          espnow.RATE_5M
+          espnow.RATE_6M
+          espnow.RATE_11M
+          espnow.RATE_12M
+          espnow.RATE_24M
+          espnow.RATE_54M
+
+Unless using the two proprietary long range data rates, only the sender must
+configure the data rate.
+
+.. _espnow-long-range:
+
+Long Range Mode
+---------------
+
+(ESP32 Only, except ESP32-C2)
+
+To use the `espnow.RATE_LORA_250K` and `espnow.RATE_LORA_500K` data rates,
+first set the `WLAN` interface object to long-range mode, i.e.::
+
+  import network, espnow
+  sta = network.WLAN(network.WLAN.IF_STA)
+  sta.active(True)
+  sta.config(channel=6, protocol=WLAN.PROTOCOL_LR)  # Set on sender & receiver
+  e = espnow.ESPNow()
+  e.config(rate=espnow.RATE_LORA_250K)  # Needed on sender only
+
+For more information about the limitations of long-range mode, see `WLAN.PROTOCOL_LR`.
+
 Exceptions
 ----------
 

docs/library/machine.DAC.rst

@@ -0,0 +1,68 @@
+.. currentmodule:: machine
+.. _machine.DAC:
+
+class DAC -- digital to analog conversion
+=========================================
+
+The DAC is used to output an analog voltage based on a digital value.
+
+The output voltage will be between 0 and 3.3V.
+
+DAC is currently supported on ESP32 [#esp32_dac]_, SAMD and Renesas RA.
+
+.. note::
+  The STM32 port has similar functionality to ``machine.DAC``. See
+  :ref:`pyb.DAC <pyb.DAC>` for details.
+
+Example usage (ESP32)::
+
+    from machine import DAC
+
+    dac = DAC(pin)    # create a DAC object acting on a pin
+    dac.write(128)    # write a value to the DAC
+    dac.write(255)    # output maximum value, 3.3V
+
+Constructors
+------------
+
+.. class:: DAC(id)
+
+  Construct a new DAC object.
+
+  ``id`` is a pin object (ESP32 and Renesas RA) or an index to a DAC resource (SAMD).
+
+.. note::
+  On the ESP32, DAC functionality is available on pins 25 and 26. On the
+  ESP32-S2, pins 17 and 18. See :ref:`ESP32 Quickref <esp32_quickref>`
+  for more details.
+
+.. note::
+  SAMD21 has one DAC resource, SAMD51 has two. See :ref:`SAMD Quickref <samd_quickref>`
+  for more details.
+
+Methods
+-------
+
+.. method:: DAC.write(value)
+
+  Output an analog voltage to the pin connected to the DAC.
+
+  ``value`` is a representation of the desired output; a linear interpolation of
+  0-3.3V, though the range differs depending on the port and micro, see below:
+
+  +--------------+------+--------+
+  | *Port/micro* | Bits | Range  |
+  +==============+======+========+
+  | ESP32        | 8    | 0-255  |
+  +--------------+------+--------+
+  | SAMD21       | 10   | 0-1023 |
+  +--------------+------+--------+
+  | SAMD51       | 12   | 0-4095 |
+  +--------------+------+--------+
+  | Renesas RA   | 12   | 0-4095 |
+  +--------------+------+--------+
+
+.. rubric:: Footnotes
+
+.. [#esp32_dac] The original ESP32 and ESP32-S2 *only*, since DAC hardware is
+    not present on other microcontrollers in the family.

docs/library/machine.I2CTarget.rst

@@ -126,7 +126,7 @@ General Methods
 
       - ``IRQ_ADDR_MATCH_READ`` indicates that the target was addressed by a
         controller for a read transaction.
-      - ``IRQ_ADDR_MATCH_READ`` indicates that the target was addressed by a
+      - ``IRQ_ADDR_MATCH_WRITE`` indicates that the target was addressed by a
         controller for a write transaction.
       - ``IRQ_READ_REQ`` indicates that the controller is requesting data, and this
         request must be satisfied by calling `I2CTarget.write` with the data to be
@@ -141,7 +141,7 @@ General Methods
 
    Note the following restrictions:
 
-      - ``IRQ_ADDR_MATCH_READ``, ``IRQ_ADDR_MATCH_READ``, ``IRQ_READ_REQ`` and
+      - ``IRQ_ADDR_MATCH_READ``, ``IRQ_ADDR_MATCH_WRITE``, ``IRQ_READ_REQ`` and
         ``IRQ_WRITE_REQ`` must be handled by a hard IRQ callback (with the *hard* argument
         set to ``True``).  This is because these events have very strict timing requirements
         and must usually be satisfied synchronously with the hardware event.

docs/library/machine.Timer.rst

@@ -4,41 +4,52 @@
 class Timer -- control hardware timers
 ======================================
 
-Hardware timers deal with timing of periods and events. Timers are perhaps
-the most flexible and heterogeneous kind of hardware in MCUs and SoCs,
-differently greatly from a model to a model. MicroPython's Timer class
-defines a baseline operation of executing a callback with a given period
-(or once after some delay), and allow specific boards to define more
-non-standard behaviour (which thus won't be portable to other boards).
+Timer class provides the ability to trigger a Python callback function after an
+expiry time, or periodically at a regular interval.
 
-See discussion of :ref:`important constraints <machine_callbacks>` on
-Timer callbacks.
-
-.. note::
-
-    Memory can't be allocated inside irq handlers (an interrupt) and so
-    exceptions raised within a handler don't give much information.  See
-    :func:`micropython.alloc_emergency_exception_buf` for how to get around this
-    limitation.
+The available features and restrictions of Timer objects vary depending on the
+MicroPython board and port.
 
 If you are using a WiPy board please refer to :ref:`machine.TimerWiPy <machine.TimerWiPy>`
 instead of this class.
 
+Timer Types
+-----------
+
+There are two types of Timer in MicroPython, but not all ports support both:
+
+- Virtual timers. These are managed in software, and are generally more
+  flexible. Multiple virtual timers can be constructed and active at once. The
+  ``id`` of a virtual timer is ``-1``. Not all ports support virtual timers, but
+  it's recommended to use them when available.
+- Hardware timers. Hardware timers have integer ``id`` values starting at ``0``.
+  The number of available ``id`` values is determined by the hardware. Hardware
+  timers may be more accurate for very fine sub-millisecond timing (especially
+  when ``hard=True`` is supported and set, see :ref:`isr_rules`.) Most
+  microcontroller ports support hardware timers, except Zephyr and RP2 which
+  only support virtual timers.
+
 Constructors
 ------------
 
 .. class:: Timer(id, /, ...)
 
-   Construct a new timer object of the given ``id``. ``id`` of -1 constructs a
-   virtual timer (if supported by a board).
+   Construct a new Timer object with the given ``id``.
+
+   On ports which support virtual timers the ``id`` parameter is optional - the
+   default value is ``-1`` which constructs a virtual timer.
+
+   On ports which support hardware timers, setting the ``id`` parameter to a
+   non-negative integer determines which timer to use.
+
    ``id`` shall not be passed as a keyword argument.
 
-   See ``init`` for parameters of initialisation.
+   Any additional parameters are handled the same as :func:`Timer.init()`.
 
 Methods
 -------
 
-.. method:: Timer.init(*, mode=Timer.PERIODIC, freq=-1, period=-1, callback=None)
+.. method:: Timer.init(*, mode=Timer.PERIODIC, freq=-1, period=-1, callback=None, hard=True)
 
    Initialise the timer. Example::
 
@@ -72,10 +83,23 @@ Methods
 
      - ``callback`` - The callable to call upon expiration of the timer period.
        The callback must take one argument, which is passed the Timer object.
+
        The ``callback`` argument shall be specified. Otherwise an exception
        will occur upon timer expiration:
        ``TypeError: 'NoneType' object isn't callable``
 
+     - ``hard`` can be one of:
+
+       - ``True`` - The callback will be executed in hard interrupt context,
+         which minimises delay and jitter but is subject to the limitations
+         described in :ref:`isr_rules`. Not all ports support hard interrupts,
+         see the port documentation for more information.
+       - ``False`` - The callback will be scheduled as a soft interrupt,
+         allowing it to allocate but possibly also introducing
+         garbage-collection delays and jitter.
+
+       The default value of this parameter is port-specific for historical reasons.
+
 .. method:: Timer.deinit()
 
    Deinitialises the timer. Stops the timer, and disables the timer peripheral.

docs/library/machine.TimerWiPy.rst

@@ -18,16 +18,6 @@ defines a baseline operation of executing a callback with a given period
 (or once after some delay), and allow specific boards to define more
 non-standard behaviour (which thus won't be portable to other boards).
 
-See discussion of :ref:`important constraints <machine_callbacks>` on
-Timer callbacks.
-
-.. note::
-
-    Memory can't be allocated inside irq handlers (an interrupt) and so
-    exceptions raised within a handler don't give much information.  See
-    :func:`micropython.alloc_emergency_exception_buf` for how to get around this
-    limitation.
-
 Constructors
 ------------
 
@@ -134,6 +124,9 @@ Methods
           ``TimerWiPy.ONE_SHOT``. In the case that mode is ``TimerWiPy.PWM`` then trigger must be equal to
           ``TimerWiPy.MATCH``.
 
+    Note that callback handlers are hard interrupts, and the constraints described in :ref:`isr_rules`
+    apply when they are executed.
+
     Returns a callback object.
 
 .. method:: timerchannel.freq([value])

docs/library/machine.rst

@@ -11,14 +11,6 @@ and unrestricted access to and control of hardware blocks on a system
 malfunction, lockups, crashes of your board, and in extreme cases, hardware
 damage.
 
-.. _machine_callbacks:
-
-A note of callbacks used by functions and class methods of :mod:`machine` module:
-all these callbacks should be considered as executing in an interrupt context.
-This is true for both physical devices with IDs >= 0 and "virtual" devices
-with negative IDs like -1 (these "virtual" devices are still thin shims on
-top of real hardware and real hardware interrupts). See :ref:`isr_rules`.
-
 Memory access
 -------------
 
@@ -260,6 +252,7 @@ Classes
    machine.Signal.rst
    machine.ADC.rst
    machine.ADCBlock.rst
+   machine.DAC.rst
    machine.PWM.rst
    machine.UART.rst
    machine.SPI.rst

docs/library/network.WLAN.rst

@@ -145,6 +145,7 @@ Methods
    reconnects     Number of reconnect attempts to make (integer, 0=none, -1=unlimited)
    txpower        Maximum transmit power in dBm (integer or float)
    pm             WiFi Power Management setting (see below for allowed values)
+   protocol       (ESP32 Only.) WiFi Low level 802.11 protocol. See `WLAN.PROTOCOL_DEFAULT`.
    =============  ===========
 
 Constants
@@ -161,3 +162,34 @@ Constants
         * ``PM_POWERSAVE``: enable WiFi power management with additional power
           savings and reduced WiFi performance
         * ``PM_NONE``: disable wifi power management
+
+
+ESP32 Protocol Constants
+------------------------
+
+The following ESP32-only constants relate to the ``WLAN.config(protocol=...)``
+network interface parameter:
+
+.. data:: WLAN.PROTOCOL_DEFAULT
+
+      A bitmap representing all of the default 802.11 Wi-Fi modes supported by
+      the chip. Consult `ESP-IDF Wi-Fi Protocols`_ documentation for details.
+
+.. data:: WLAN.PROTOCOL_LR
+
+      This value corresponds to the `Espressif proprietary "long-range" mode`_,
+      which is not compatible with standard Wi-Fi devices. By setting this
+      protocol it's possible for an ESP32 STA in long-range mode to connect to
+      an ESP32 AP in long-range mode, or to use `ESP-NOW long range modes
+      <espnow-long-range>`.
+
+      This mode can be bitwise ORed with some standard 802.11 protocol bits
+      (including `WLAN.PROTOCOL_DEFAULT`) in order to support a mix of standard
+      Wi-Fi modes as well as LR mode, consult the `Espressif long-range
+      documentation`_ for more details.
+
+      Long range mode is not supported on ESP32-C2.
+
+.. _ESP-IDF Wi-Fi Protocols: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/wifi.html#wi-fi-protocol-mode
+.. _Espressif proprietary "long-range" mode:
+.. _Espressif long-range documentation: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/wifi.html#long-range-lr

docs/library/os.rst

@@ -55,10 +55,9 @@ Filesystem access
       directories and 0x8000 for regular files;
     - *inode* is an integer corresponding to the inode of the file, and may be 0
       for filesystems that don't have such a notion.
-    - Some platforms may return a 4-tuple that includes the entry's *size*.  For
-      file entries, *size* is an integer representing the size of the file
-      or -1 if unknown.  Its meaning is currently undefined for directory
-      entries.
+    - *size* is an integer that may be included depending on the filesystem type.
+      For file entries, *size* represents the size of the file or -1 if unknown.
+      Its meaning is currently undefined for directory entries.
 
 .. function:: listdir([dir])
 
@@ -133,6 +132,37 @@ Terminal redirection and duplication
 
    The function returns the previous stream-like object in the given slot.
 
+.. function:: dupterm_notify(obj_in, /)
+
+    Notify the MicroPython REPL that input is available on a stream-like object
+    previously registered via `os.dupterm()`.
+
+    This function should be called by custom stream implementations (e.g., UART,
+    Bluetooth, or other non-USB REPL streams) to inform the REPL that input is
+    ready to be read. Proper use ensures that special characters such as
+    Ctrl+C (used to trigger KeyboardInterrupt) are processed promptly by the
+    REPL, enabling expected interruption behavior for user code.
+
+    The *obj_in* parameter is ignored by `os.dupterm_notify()`, but is required to allow calling
+    dupterm_notify from an interrupt handler such as `UART.irq()`.
+
+    Example:
+
+    .. code-block:: python
+
+        from machine import UART
+        import os
+        uart = UART(0)
+        os.dupterm(uart, 0)
+        uart.irq(os.dupterm_notify, machine.UART.IRQ_RX)
+
+    .. note::
+        If the ``dupterm_notify()`` function is not called, input from the custom stream
+        may not be detected or processed until the next REPL poll, potentially delaying
+        KeyboardInterrupts or other control signals.
+        This is especially important for UART, Bluetooth and other
+        non-standard REPL connections, where automatic notification is not guaranteed.
+
 Filesystem mounting
 -------------------
 

docs/library/platform.rst

@@ -36,3 +36,11 @@ Functions
    Returns a tuple of strings *(lib, version)*, where *lib* is the name of the
    libc that MicroPython is linked to, and *version* the corresponding version
    of this libc.
+
+.. function:: processor()
+
+   Returns a string with a detailed name of the processor, if one is available.
+   If no name for the processor is known, it will return an empty string
+   instead.
+
+   This is currently available only on RISC-V targets (both 32 and 64 bits).

docs/library/pyb.Timer.rst

@@ -62,7 +62,7 @@ Constructors
 Methods
 -------
 
-.. method:: Timer.init(*, freq, prescaler, period, mode=Timer.UP, div=1, callback=None, deadtime=0, brk=Timer.BRK_OFF)
+.. method:: Timer.init(*, freq, prescaler, period, mode=Timer.UP, div=1, callback=None, deadtime=0, brk=Timer.BRK_OFF, hard=True)
 
    Initialise the timer.  Initialisation must be either by frequency (in Hz)
    or by prescaler and period::
@@ -115,6 +115,18 @@ Methods
        ``mode=Pin.ALT, alt=Pin.AFn_TIMx``. The pin's GPIO input features are
        available in alt mode - ``pull=`` , ``value()`` and ``irq()``.
 
+     - ``hard`` can be one of:
+
+       - ``True`` - The callback will be executed in hard interrupt
+         context, which minimises delay and jitter but is subject to the
+         limitations described in :ref:`isr_rules` including being unable
+         to allocate on the heap.
+       - ``False`` - The callback will be scheduled as a soft interrupt,
+         allowing it to allocate but possibly also introducing
+         garbage-collection delays and jitter.
+
+       The default value of this option is True.
+
     You must either specify freq or both of period and prescaler.
 
 .. method:: Timer.deinit()

docs/library/re.rst

@@ -154,8 +154,8 @@ Regex objects
 Compiled regular expression. Instances of this class are created using
 `re.compile()`.
 
-.. method:: regex.match(string)
-            regex.search(string)
+.. method:: regex.match(string, [pos, [endpos]])
+            regex.search(string, [pos, [endpos]])
             regex.sub(replace, string, count=0, flags=0, /)
 
    Similar to the module-level functions :meth:`match`, :meth:`search`
@@ -163,6 +163,16 @@ Compiled regular expression. Instances of this class are created using
    Using methods is (much) more efficient if the same regex is applied to
    multiple strings.
 
+   The optional second parameter *pos* gives an index in the string where the
+   search is to start; it defaults to ``0``. This is not completely equivalent
+   to slicing the string; the ``'^'`` pattern character matches at the real
+   beginning of the string and at positions just after a newline, but not
+   necessarily at the index where the search is to start.
+
+   The optional parameter *endpos* limits how far the string will be searched;
+   it will be as if the string is *endpos* characters long, so only the
+   characters from *pos* to ``endpos - 1`` will be searched for a match.
+
 .. method:: regex.split(string, max_split=-1, /)
 
    Split a *string* using regex. If *max_split* is given, it specifies

docs/library/zephyr.zsensor.rst

@@ -20,7 +20,8 @@ See Zephyr documentation for sensor usage here: `Sensors
 Sensors are defined in the Zephyr devicetree for each board. The quantities that a given sensor can
 measure are called a sensor channels. Sensors can have multiple channels to represent different axes
 of one property or different properties a sensor can measure. See `Channels`_ below for defined sensor
-channels.
+channels. Each channel may have multiple attributes that can be changed and/or queried.
+See `Channel Attributes`_ below for defined sensor channel attributes.
 
 Constructor
 ~~~~~~~~~~~
@@ -59,6 +60,36 @@ Methods
     Returns only the integer value of the measurement sample.
     (Ex. value of ``(1, 500000)`` returns as ``1``)
 
+.. method:: Sensor.attr_set(sensor_channel, channel_attribute, val1, [val2])
+
+    Set the given channel's attribute to the given value.
+    ``val1`` may be a float, in which case ``val2`` is not given, or
+    ``val1`` can be used for the value's
+    integer part and ``val2`` for the value's fractional part in millionths.
+
+    Returns ``None`` if successful, or raises ``OSError``.
+
+.. method:: Sensor.attr_get_float(sensor_channel, channel_attribute)
+
+   Returns the value of the sensor channel's attribute as a float.
+
+   Many sensors do not support this or any other of the ``attr_get`` methods.
+
+.. method:: Sensor.attr_get_micros(sensor_channel, channel_attribute)
+
+    Returns the value of the sensor channel's attribute in millionths.
+    (Ex. value of ``(1, 500000)`` returns as ``1500000``)
+
+.. method:: Sensor.attr_get_millis(sensor_channel, channel_attribute)
+
+    Returns the value of the sensor channel's attribute in thousandths.
+    (Ex. value of ``(1, 500000)`` returns as ``1500``)
+
+.. method:: Sensor.attr_get_int(sensor_channel, channel_attribute)
+
+    Returns only the integer value of the channel's attribute.
+    (Ex. value of ``(1, 500000)`` returns as ``1``)
+
 Channels
 ~~~~~~~~
 
@@ -74,6 +105,11 @@ Channels
 
     Acceleration on the Z axis, in m/s^2.
 
+.. data:: ACCEL_XYZ
+
+    Pseudo-channel representing all three accelerometer axes.
+    Used for :meth:`Sensor.attr_set` and the ``Sensor.attr_get_xxx()`` methods.
+
 .. data:: GYRO_X
 
     Angular velocity around the X axis, in radians/s.
@@ -86,6 +122,11 @@ Channels
 
     Angular velocity around the Z axis, in radians/s.
 
+.. data:: GYRO_XYZ
+
+    Pseudo-channel representing all three gyroscope axes.
+    Used for :meth:`Sensor.attr_set` and the ``Sensor.attr_get_xxx()`` methods.
+
 .. data:: MAGN_X
 
     Magnetic field on the X axis, in Gauss.
@@ -121,3 +162,73 @@ Channels
 .. data:: ALTITUDE
 
     Altitude, in meters.
+
+Channel Attributes
+~~~~~~~~~~~~~~~~~~~
+
+.. data:: ATTR_SAMPLING_FREQUENCY
+
+    Sensor sampling frequency, i.e. how many times a second the sensor takes a measurement.
+
+.. data:: ATTR_LOWER_THRESH
+
+    Lower threshold for trigger.
+
+.. data:: ATTR_UPPER_THRESH
+
+    Upper threshold for trigger.
+
+.. data:: ATTR_SLOPE_TH
+
+    Threshold for any-motion (slope) trigger.
+
+.. data:: ATTR_SLOPE_DUR
+
+    Duration for which the slope values needs to be outside the threshold for the trigger to fire.
+
+.. data:: ATTR_HYSTERESIS
+
+.. data:: ATTR_OVERSAMPLING
+
+    Oversampling factor.
+
+.. data:: ATTR_FULL_SCALE
+
+    Sensor range, in SI units.
+
+.. data:: ATTR_OFFSET
+
+    The sensor value returned will be altered by the amount indicated by offset: final_value = sensor_value + offset.
+
+.. data:: ATTR_CALIB_TARGET
+
+    Calibration target. This will be used by the internal chip's algorithms to calibrate itself on a certain axis, or all of them.
+
+.. data:: ATTR_CONFIGURATION
+
+    Configure the operating modes of a sensor.
+
+.. data:: ATTR_CALIBRATION
+
+    Set a calibration value needed by a sensor.
+
+.. data:: ATTR_FEATURE_MASK
+
+    Enable/disable sensor features.
+
+.. data:: ATTR_ALERT
+
+    Alert threshold or alert enable/disable.
+
+.. data:: ATTR_FF_DUR
+
+    Free-fall duration represented in milliseconds.
+    If the sampling frequency is changed during runtime, this attribute should be set to adjust freefall duration to the new sampling frequency.
+
+.. data:: ATTR_BATCH_DURATION
+
+    Hardware batch duration in ticks.
+
+.. data:: ATTR_GAIN
+
+.. data:: ATTR_RESOLUTION

docs/mimxrt/pinout.rst

@@ -5,7 +5,10 @@ Pinout for the i.MXRT machine modules
 
 .. _mimxrt_uart_pinout:
 
-|
+The Teensy 4.0 and 4.1 board show pin numbers **nn** at the board's silkscreen.
+These are denoted in the tables below as **Dnn**. E.g. a silkscreen number **1** is
+shown as **D1**. Whenever a Pin has to be specified in a script, **Dnn** must
+be used, not **nn**.
 
 UART pin assignment
 -------------------
@@ -17,8 +20,8 @@ tables below:
 =================  ===========  ===========  ===========  ===========
 Board / Pin           UART0        UART1        UART2        UART3
 =================  ===========  ===========  ===========  ===========
-Teensy 4.0             -            0/1          7/8         14/15
-Teensy 4.1             -            0/1          7/8         14/15
+Teensy 4.0             -          D0/D1        D7/D8       D14/D15
+Teensy 4.1             -          D0/D1        D7/D8       D14/D15
 MIMXRT1010-EVK     Debug USB      D0/D1        D7/D6           -
 MIMXRT1015-EVK     Debug USB      D0/D1        D7/A1           -
 MIMXRT1020-EVK     Debug USB      D0/D1        D9/D6       D10/D13
@@ -35,11 +38,11 @@ Makerdiary RT1011     -           D9/D10      D13/A0       D11/D12
 
 |
 
-=================  ===========  ===========  =======  =======  =====
-Board / Pin            UART4        UART5      UART6   UART7   UART8
-=================  ===========  ===========  =======  =======  =====
-Teensy 4.0             16/17        21/20     25/24    28/29      -
-Teensy 4.1             16/17        21/20     25/24    28/29   34/35
+=================  ===========  ===========  =======  =======  =======
+Board / Pin            UART4        UART5      UART6   UART7    UART8
+=================  ===========  ===========  =======  =======  =======
+Teensy 4.0           D16/D17      D21/D20    D25/D24  D28/D29      -
+Teensy 4.1           D16/D17      D21/D20    D25/D24  D28/D29  D34/D35
 MIMXRT1010-EVK          -            -         -        -        -
 MIMXRT1015-EVK          -            -         -        -        -
 MIMXRT1020-EVK       D15/D14       A1/A0       -        -        -
@@ -51,7 +54,7 @@ MIMXRT1170-EVK       D15/D14      D25/D26    D33/D34  D35/D36    -
 Olimex RT1010Py         -            -         -        -        -
 Seeed ARCH MIX     J4_10/J4_11  J5_08/J5_12    -        -        -
 Makerdiary RT1011     A1/A2          -         -        -        -
-=================  ===========  ===========  =======  =======  =====
+=================  ===========  ===========  =======  =======  =======
 
 .. _mimxrt_pwm_pinout:
 
@@ -102,46 +105,46 @@ Pins denoted with (*) are by default not wired at the board.
 ====   ==========  ====   ==========
 Pin    Teensy 4.0  Pin    Teensy 4.1
 ====   ==========  ====   ==========
-0      F1/1/X      0      F1/1/X
-1      F1/0/X      1      F1/0/X
-2      F4/2/A      2      F4/2/A
-3      F4/2/B      3      F4/2/B
-4      F2/0/A      4      F2/0/A
-5      F2/1/A      5      F2/1/A
-6      F2/2/A      6      F2/2/A
-7      F1/3/B      7      F1/3/B
-8      F1/3/A      8      F1/3/A
-9      F2/2/B      9      F2/2/B
-10     Q1/0        10     Q1/0
-11     Q1/2        11     Q1/2
-12     Q1/1        12     Q1/1
-13     Q2/0        13     Q2/0
-14     Q3/2        14     Q3/2
-15     Q3/3        15     Q3/3
-18     Q3/1        18     Q3/1
-19     Q3/0        19     Q3/0
-22     F4/0/A      22     F4/0/A
-23     F4/1/A      23     F4/1/A
-24     F1/2/X      24     F1/2/X
-25     F1/3/X      25     F1/3/X
-28     F3/1/B      28     F3/1/B
-29     F3/1/A      29     F3/1/A
-33     F2/0/B      33     F2/0/B
--      -           36     F2/3/A
--      -           37     F2/3/B
-DAT1   F1/1/B      42     F1/1/B
-DAT0   F1/1/A      43     F1/1/A
-CLK    F1/0/B      44     F1/0/B
-CMD    F1/0/A      45     F1/0/A
-DAT2   F1/2/A      46     F1/2/A
-DAT3   F1/2/B      47     F1/2/B
--      -           48     F1/0/B
--      -           49     F1/2/A
--      -           50     F1/2/B
--      -           51     F3/3/B
--      -           52     F1/1/B
--      -           53     F1/1/A
--      -           54     F3/0/A
+D0     F1/1/X      D0     F1/1/X
+D1     F1/0/X      D1     F1/0/X
+D2     F4/2/A      D2     F4/2/A
+D3     F4/2/B      D3     F4/2/B
+D4     F2/0/A      D4     F2/0/A
+D5     F2/1/A      D5     F2/1/A
+D6     F2/2/A      D6     F2/2/A
+D7     F1/3/B      D7     F1/3/B
+D8     F1/3/A      D8     F1/3/A
+D9     F2/2/B      D9     F2/2/B
+D10    Q1/0        D10    Q1/0
+D11    Q1/2        D11    Q1/2
+D12    Q1/1        D12    Q1/1
+D13    Q2/0        D13    Q2/0
+D14    Q3/2        D14    Q3/2
+D15    Q3/3        D15    Q3/3
+D18    Q3/1        D18    Q3/1
+D19    Q3/0        D19    Q3/0
+D22    F4/0/A      D22    F4/0/A
+D23    F4/1/A      D23    F4/1/A
+D24    F1/2/X      D24    F1/2/X
+D25    F1/3/X      D25    F1/3/X
+D28    F3/1/B      D28    F3/1/B
+D29    F3/1/A      D29    F3/1/A
+D33    F2/0/B      D33    F2/0/B
+-      -           D36    F2/3/A
+-      -           D37    F2/3/B
+DAT1   F1/1/B      D42    F1/1/B
+DAT0   F1/1/A      D43    F1/1/A
+CLK    F1/0/B      D44    F1/0/B
+CMD    F1/0/A      D45    F1/0/A
+DAT2   F1/2/A      D46    F1/2/A
+DAT3   F1/2/B      D47    F1/2/B
+-      -           D48    F1/0/B
+-      -           D49    F1/2/A
+-      -           D50    F1/2/B
+-      -           D51    F3/3/B
+-      -           D52    F1/1/B
+-      -           D53    F1/1/A
+-      -           D54    F3/0/A
 ====   ==========  ====   ==========
 
 |
@@ -330,11 +333,11 @@ The SPI signals have fixed assignments to GPIO pins.
 It depends on the board design, which SPI's signals are exposed to the user, as
 detailed in the table below.  The signal order in the table is: CS0, CS1, MOSI, MISO, CLK.
 
-=================  =========================  =======================  ===============
+=================  =========================  =======================  =================
 Board / Pin        SPI0                       SPI1                     SPI2
-=================  =========================  =======================  ===============
-Teensy 4.0         10/-/11/12/13              0/-/26/1/27                    -
-Teensy 4.1         10/37/11/12/13             0/-/26/1/27              -/29/50/54/49
+=================  =========================  =======================  =================
+Teensy 4.0         D10/-/D11/D12/D13          D0/-/D26/D1/D27                -
+Teensy 4.1         D10/D37/D11/D12/D13        D0/-/D26/D1/D27          -/D29/D50/D54/D49
 MIXMXRT1010-EVK    D10/D7/D11/D12/D13                -                       -
 MIXMXRT1015-EVK    D10/-/D11/D12/D13                 -                       -
 MIXMXRT1020-EVK    D10/-/D11/D12/D13          A3/D0/A5/A4/A0                 -
@@ -347,7 +350,7 @@ Adafruit Metro M7  -/-/MOSI/MISO/SCK                -                        -
 Olimex RT1010Py             -                 CS0/-/SDO/SDI/SCK        SDCARD with CS1
 Seeed ARCH MIX     J4_12/-/J4_14/J4_13/J4_15  J3_09/J3_05/J3_08_J3_11
 Makerdiary RT1011  A5/A2/A4/A3/A6             A11/A1/A10/A9/CLK
-=================  =========================  =======================  ===============
+=================  =========================  =======================  =================
 
 Pins denoted with (*) are by default not wired at the board. The CS0 and CS1 signals
 are enabled with the keyword option cs=0 or cs=1 of the SPI object constructor.
@@ -367,8 +370,8 @@ detailed in the table below.  The signal order in the table is: SDA, SCL.
 =================  ===========  ===========  ===========  =======  =======
 Board / Pin        I2C 0        I2C 1        I2C 2        I2C 3    I2C 4
 =================  ===========  ===========  ===========  =======  =======
-Teensy 4.0         18/19        17/16        25/24         -        -
-Teensy 4.1         18/19        17/16        25/24         -        -
+Teensy 4.0         D18/D19      D17/D16      D25/D24       -        -
+Teensy 4.1         D18/D19      D17/D16      D25/D24       -        -
 MIXMXRT1010-EVK    D14/D15      D0/D1         -            -        -
 MIXMXRT1015-EVK    D14/D15       -            -            -        -
 MIXMXRT1020-EVK    D14/D15      A4/A5        D0/D1         -        -
@@ -396,10 +399,10 @@ Pin assignments for a few MIMXRT boards:
 =================  ==  =====  ======== ======= ======= ======== ======= =======
 Board              ID  MCK    SCK_TX   WS_TX   SD_TX   SCK_RX   WS_RX   SD_RX
 =================  ==  =====  ======== ======= ======= ======== ======= =======
-Teensy 4.0         1   23     26       27      7       21       20      8
-Teensy 4.0         2   33     4        3       2       -        -       5
-Teensy 4.1         1   23     26       27      7       21       20      8
-Teensy 4.1         2   33     4        3       2       -        -       5
+Teensy 4.0         1   D23    D26      D27     D7      D21      D20     D8
+Teensy 4.0         2   D33    D4       D3      D2      -        -       D5
+Teensy 4.1         1   D23    D26      D27     D7      D21      D20     D8
+Teensy 4.1         2   D33    D4       D3      D2      -        -       D5
 Seeed Arch MIX     1   J4_09  J4_14    J4_15   J14_13  J4_11    J4_10   J4_10
 Adafruit Metro M7  1   D8     D10      D9      D12     D14      D15     D13
 Olimex RT1010Py    1   D8     D6       D7      D4      D1       D2      D3

docs/pyboard/tutorial/lcd_skin.rst

@@ -29,7 +29,7 @@ Make sure the LCD skin is attached to the pyboard as pictured at the top of this
     >>> import pyb
     >>> lcd = pyb.LCD('X')
     >>> lcd.light(True)
-    >>> lcd.write('Hello uPy!\n')
+    >>> lcd.write('Hello MPy!\n')
 
 You can make a simple animation using the code::
 
@@ -38,7 +38,7 @@ You can make a simple animation using the code::
     lcd.light(True)
     for x in range(-80, 128):
         lcd.fill(0)
-        lcd.text('Hello uPy!', x, 10, 1)
+        lcd.text('Hello MPy!', x, 10, 1)
         lcd.show()
         pyb.delay(25)
 

docs/reference/asm_thumb2_index.rst

@@ -63,7 +63,7 @@ References
 -  :ref:`Assembler Tutorial <pyboard_tutorial_assembler>`
 -  `Wiki hints and tips
    <http://wiki.micropython.org/platforms/boards/pyboard/assembler>`__
--  `uPy Inline Assembler source-code,
+-  `MicroPython Inline Assembler source-code,
    emitinlinethumb.c <https://github.com/micropython/micropython/blob/master/py/emitinlinethumb.c>`__
 -  `ARM Thumb2 Instruction Set Quick Reference
    Card <http://infocenter.arm.com/help/topic/com.arm.doc.qrc0001l/QRC0001_UAL.pdf>`__

docs/reference/mpyfiles.rst

@@ -58,12 +58,14 @@ If importing an .mpy file fails then try the following:
     sys_mpy = sys.implementation._mpy
     arch = [None, 'x86', 'x64',
         'armv6', 'armv6m', 'armv7m', 'armv7em', 'armv7emsp', 'armv7emdp',
-        'xtensa', 'xtensawin', 'rv32imc'][sys_mpy >> 10]
+        'xtensa', 'xtensawin', 'rv32imc', 'rv64imc'][(sys_mpy >> 10) & 0x0F]
     print('mpy version:', sys_mpy & 0xff)
     print('mpy sub-version:', sys_mpy >> 8 & 3)
     print('mpy flags:', end='')
     if arch:
         print(' -march=' + arch, end='')
+    if (sys_mpy >> 16) != 0:
+        print(' -march-flags=' + (sys_mpy >> 16), end='')
     print()
 
 * Check the validity of the .mpy file by inspecting the first two bytes of
@@ -80,6 +82,10 @@ If importing an .mpy file fails then try the following:
   above, or by inspecting the ``MPY_CROSS_FLAGS`` Makefile variable for the
   port that you are using.
 
+* If the third byte of the .mpy file has bit #6 set, then check whether the
+  encoded architecture-specific flag bits vuint is compatible with the
+  target you're importing the file on.
+
 The following table shows the correspondence between MicroPython release
 and .mpy version.
 
@@ -153,10 +159,42 @@ size    field
 ======  ================================
 byte    value 0x4d (ASCII 'M')
 byte    .mpy major version number
-byte    native arch and minor version number (was feature flags in older versions)
+byte    feature flags, native arch, minor version number (was feature flags in older versions)
 byte    number of bits in a small int
 ======  ================================
 
+The third byte is split as follows (MSB first):
+
+======  ================================
+bit     meaning
+======  ================================
+7       reserved, must be 0
+6       an architecture-specific flags vuint follows the header
+5..2    native arch number
+1..0    minor version number
+======  ================================
+
+Architecture-specific flags
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If bit #6 of the header's feature flags byte is set, then a vuint containing
+optional architecture-specific information will follow the header. The contents
+of this integer depends on which native architecture the file is meant for.
+
+This is currently used to store which RISC-V processor extensions the MPY file
+needs to operate correctly besides I, M, C, and Zicsr.  Different flavours of
+ArmV7 are identified by their native architecture number, but reusing that
+mechanism would complicate things for RV32 and RV64.
+
+MPY files targeting RV32 or RV64 that do not need any particular processor
+extensions do not need to provide a flags integer (along with setting the
+appropriate bit in the header).  The lack of a flags value for RV32 and RV64
+MPY files is used to indicate that no specific extensions are needed, and saves
+one byte in the final output binary.
+
+See also the ``-march-flags`` command-line option in both ``mpy-tool.py`` and
+``mpy-cross`` to set this value when creating MPY files.
+
 The global qstr and constant tables
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/requirements.txt

@@ -1,2 +1,3 @@
 sphinx~=7.2.6
 sphinxcontrib.jquery==4.1
+sphinx-rtd-theme==3.0.2

docs/zephyr/quickref.rst

@@ -99,10 +99,10 @@ Hardware SPI is accessed via the :ref:`machine.SPI <machine.SPI>` class::
 
     from machine import SPI
 
-    spi = SPI("spi0")           # construct a spi bus with default configuration
+    spi = SPI("spi0")           # construct a SPI bus with default configuration
     spi.init(baudrate=100000, polarity=0, phase=0, bits=8, firstbit=SPI.MSB) # set configuration
 
-    # equivalently, construct spi bus and set configuration at the same time
+    # equivalently, construct the SPI bus and set configuration at the same time
     spi = SPI("spi0", baudrate=100000, polarity=0, phase=0, bits=8, firstbit=SPI.MSB)
     print(spi)                  # print device name and bus configuration
 
@@ -119,14 +119,30 @@ Hardware SPI is accessed via the :ref:`machine.SPI <machine.SPI>` class::
     spi.write_readinto(b'abcd', buf)    # write to MOSI and read from MISO into the buffer
     spi.write_readinto(buf, buf)        # write buf to MOSI and read back into the buf
 
+Analog to Digital Converter (ADC)
+----------------------------------
+
+Use the :ref:`machine.ADC <machine.ADC>` class.
+
+Example of using ADC to read a pin's analog value (the ``zephyr,user`` node must contain
+the ``io-channels`` property containing all the ADC channels)::
+
+    from machine import ADC
+
+    adc = ADC(("adc", 0))
+    adc.read_uv()
+
 Disk Access
 -----------
 
-Use the :ref:`zephyr.DiskAccess <zephyr.DiskAccess>` class to support filesystem::
+Storage devices such as SD cards are automatically mounted at startup (e.g., at ``/sd``).
+For manual mounting, use the :ref:`zephyr.DiskAccess <zephyr.DiskAccess>` class::
 
     import vfs
     from zephyr import DiskAccess
 
+    print(DiskAccess.disks)             # list available disk names, e.g., ('SDHC',)
+
     block_dev = DiskAccess('SDHC')      # create a block device object for an SD card
     vfs.VfsFat.mkfs(block_dev)          # create FAT filesystem object using the disk storage block
     vfs.mount(block_dev, '/sd')         # mount the filesystem at the SD card subdirectory
@@ -139,12 +155,15 @@ Use the :ref:`zephyr.DiskAccess <zephyr.DiskAccess>` class to support filesystem
 Flash Area
 ----------
 
-Use the :ref:`zephyr.FlashArea <zephyr.FlashArea>` class to support filesystem::
+Flash storage is automatically mounted at ``/flash`` at startup with automatic filesystem creation.
+For manual mounting, use the :ref:`zephyr.FlashArea <zephyr.FlashArea>` class::
 
     import vfs
     from zephyr import FlashArea
 
-    block_dev = FlashArea(4, 4096)      # creates a block device object in the frdm-k64f flash scratch partition
+    print(FlashArea.areas)              # list available areas, e.g., {'storage': 1, 'scratch': 4}
+
+    block_dev = FlashArea(FlashArea.areas['scratch'], 4096)  # creates a block device object using the scratch partition
     vfs.VfsLfs2.mkfs(block_dev)         # create filesystem in lfs2 format using the flash block device
     vfs.mount(block_dev, '/flash')      # mount the filesystem at the flash subdirectory
 
@@ -153,8 +172,6 @@ Use the :ref:`zephyr.FlashArea <zephyr.FlashArea>` class to support filesystem::
         f.write('Hello world')                  # write to the file
     print(open('/flash/hello.txt').read())      # print contents of the file
 
-The FlashAreas' IDs that are available are listed in the FlashArea module, as ID_*.
-
 Sensor
 ------
 
@@ -172,3 +189,34 @@ Use the :ref:`zsensor.Sensor <zsensor.Sensor>` class to access sensor data::
     accel.get_millis(zsensor.ACCEL_Y) # print measurement value for accelerometer Y-axis sensor channel in millionths
     accel.get_micro(zsensor.ACCEL_Z)  # print measurement value for accelerometer Z-axis sensor channel in thousandths
     accel.get_int(zsensor.ACCEL_X)    # print measurement integer value only for accelerometer X-axis sensor channel
+
+The channel IDs that are used as arguments to the :meth:`zsensor.Sensor.get_int`,
+:meth:`zsensor.Sensor.get_float()`, :meth:`zsensor.Sensor.get_millis()`, and
+:meth:`zsensor.Sensor.get_micros()` methods are constants in the :mod:`zsensor` module.
+
+You can use the :meth:`zsensor.Sensor.attr_set` method to set sensor attributes
+like full-scale range and update rate::
+
+    # Example for XIAO BLE NRF52840 SENSE
+    from zsensor import *
+    accel = Sensor('lsm6ds3tr_c')  # name from Devicetree
+    # Set full-scale to 2g (19.613300 m/sec^2)
+    # units are micro-m/s^2 (given as a float)
+    accel.attr_set(ACCEL_XYZ, ATTR_FULL_SCALE, 19.613300)
+    # Set sampling frequency to 104 Hz (as a pair of integers)
+    accel.attr_set(ACCEL_XYZ, ATTR_SAMPLING_FREQUENCY, 104, 0)
+    accel.measure()
+    accel.get_float(ACCEL_X) # -0.508 (m/s^2)
+    accel.get_float(ACCEL_Y) # -3.62 (m/s^2)
+    accel.get_float(ACCEL_Z) # 9.504889 (m/s^2)
+
+There are also the :meth:`zsensor.Sensor.attr_get_float`, :meth:`zsensor.Sensor.attr_get_int`,
+:meth:`zsensor.Sensor.attr_get_millis`, and :meth:`zsensor.Sensor.attr_get_micros` methods,
+but many sensors do not support these::
+
+    full_scale = accel.attr_get_float(ATTR_FULL_SCALE)
+
+The attribute IDs that are used as arguments to the :meth:`zsensor.Sensor.attr_set`,
+:meth:`zsensor.Sensor.attr_get_float`, :meth:`zsensor.Sensor.attr_get_int`,
+:meth:`zsensor.Sensor.attr_get_millis`, and :meth:`zsensor.Sensor.attr_get_micros`
+methods are constants in the :mod:`zsensor` module named ``ATTR_*``.

docs/zephyr/tutorial/repl.rst

@@ -31,8 +31,8 @@ With your serial program open (PuTTY, screen, picocom, etc) you may see a
 blank screen with a flashing cursor. Press Enter (or reset the board) and
 you should be presented with the following text::
 
-        *** Booting Zephyr OS build v4.0.0 ***
-        MicroPython v1.24.0-preview.179.g5b85b24bd on 2024-08-05; zephyr-frdm_k64f with mk64f12
+        *** Booting Zephyr OS build v4.2.0 ***
+        MicroPython v1.26.0-preview.451.gebc9525c9 on 2025-07-25; zephyr-frdm_k64f with mk64f12
         Type "help()" for more information.
         >>>
 

docs/zephyr/tutorial/storage.rst

@@ -8,6 +8,27 @@ Zephyr DiskAccess or FlashArea (flash map) APIs depending on which the board sup
 
 See `vfs Filesystem Mounting <https://docs.micropython.org/en/latest/library/vfs.html?highlight=vfs#filesystem-mounting>`_.
 
+Automatic Filesystem Mounting
+------------------------------
+
+MicroPython on Zephyr automatically attempts to mount available storage at startup:
+
+1. **Flash storage** (if available): Automatically mounted at ``/flash`` using the
+   littlefs2 filesystem. If the filesystem doesn't exist, it will be created
+   automatically.
+
+2. **Disk storage** (such as SD cards): Automatically detected and mounted at
+   ``/<disk_name>`` (e.g., ``/sd`` for SD cards).
+
+3. **Working directory**: The working directory is set to the mounted disk if
+   available, otherwise to ``/flash`` if flash storage is available.
+
+4. **Module search path**: The ``sys.path`` is automatically updated to include
+   ``/<disk>/lib`` for each mounted disk and ``/flash/lib`` for flash storage.
+
+This automatic mounting is performed by the ``_boot.py`` module at startup. For most
+use cases, you don't need to manually mount filesystems.
+
 Disk Access
 -----------
 
@@ -19,17 +40,26 @@ For use with SD card controllers, SD cards must be present at boot & not removed
 be auto detected and initialized by filesystem at boot. Use the disk driver interface and a
 file system to access SD cards via disk access (see below).
 
+The available disk names can be accessed via the ``DiskAccess.disks`` attribute, which contains
+a tuple of available disk names (e.g., ``('SDHC',)`` or ``('SD',)``).
+
 Example usage of FatFS with an SD card on the mimxrt1050_evk board::
 
     import vfs
     from zephyr import DiskAccess
-    bdev = zephyr.DiskAccess('SDHC')        # create block device object using DiskAccess
+
+    # List available disks
+    print(DiskAccess.disks)                 # prints available disk names, e.g., ('SDHC',)
+
+    bdev = DiskAccess('SDHC')               # create block device object using DiskAccess
     vfs.VfsFat.mkfs(bdev)                   # create FAT filesystem object using the disk storage block
     vfs.mount(bdev, '/sd')                  # mount the filesystem at the SD card subdirectory
     with open('/sd/hello.txt','w') as f:    # open a new file in the directory
         f.write('Hello world')              # write to the file
     print(open('/sd/hello.txt').read())     # print contents of the file
 
+Note: In most cases, disks are automatically mounted at startup and manual mounting is not necessary.
+
 
 Flash Area
 ----------
@@ -41,16 +71,26 @@ API is recommended (see below).
 This class uses `Zephyr Flash map API <https://docs.zephyrproject.org/latest/reference/storage/flash_map/flash_map.html#>`_ and
 implements the `vfs.AbstractBlockDev` protocol.
 
+The available flash area names can be accessed via the ``FlashArea.areas`` dictionary, which maps partition
+labels to their IDs (e.g., ``{'storage': 1, 'scratch': 4}``).
+
 Example usage with the internal flash on the reel_board or the rv32m1_vega_ri5cy board::
 
     import vfs
     from zephyr import FlashArea
-    bdev = FlashArea(FlashArea.STORAGE, 4096)   # create block device object using FlashArea
-    vfs.VfsLfs2.mkfs(bdev)                      # create Little filesystem object using the flash area block
-    vfs.mount(bdev, '/flash')                   # mount the filesystem at the flash storage subdirectory
-    with open('/flash/hello.txt','w') as f:     # open a new file in the directory
-        f.write('Hello world')                  # write to the file
-    print(open('/flash/hello.txt').read())      # print contents of the file
+
+    # List available flash areas
+    print(FlashArea.areas)                          # prints available areas, e.g., {'storage': 1, 'scratch': 4}
+
+    bdev = FlashArea(FlashArea.areas['storage'], 4096)   # create block device object using FlashArea
+    vfs.VfsLfs2.mkfs(bdev)                               # create Little filesystem object using the flash area block
+    vfs.mount(bdev, '/flash')                            # mount the filesystem at the flash storage subdirectory
+    with open('/flash/hello.txt','w') as f:              # open a new file in the directory
+        f.write('Hello world')                           # write to the file
+    print(open('/flash/hello.txt').read())               # print contents of the file
+
+Note: In most cases, the flash storage partition is automatically mounted at ``/flash`` at startup with
+automatic filesystem creation if needed, so manual mounting is not necessary.
 
 For boards such as the frdm_k64f in which the MicroPython application spills into the default flash storage
-partition, use the scratch partition by replacing ``FlashArea.STORAGE`` with the integer value 4.
+partition, use the scratch partition by replacing ``'storage'`` with ``'scratch'``.

examples/embedding/mpconfigport.h

@@ -13,3 +13,4 @@
 #define MICROPY_ENABLE_COMPILER                 (1)
 #define MICROPY_ENABLE_GC                       (1)
 #define MICROPY_PY_GC                           (1)
+#define MICROPY_PY_SYS                          (0)

extmod/asyncio/__init__.py

@@ -26,6 +26,6 @@ def __getattr__(attr):
     mod = _attrs.get(attr, None)
     if mod is None:
         raise AttributeError(attr)
-    value = getattr(__import__(mod, None, None, True, 1), attr)
+    value = getattr(__import__(mod, globals(), None, True, 1), attr)
     globals()[attr] = value
     return value

extmod/asyncio/core.py

@@ -50,7 +50,7 @@ class SingletonGenerator:
             raise self.exc
 
 
-# Pause task execution for the given time (integer in milliseconds, uPy extension)
+# Pause task execution for the given time (integer in milliseconds, MicroPython extension)
 # Use a SingletonGenerator to do it without allocating on the heap
 def sleep_ms(t, sgen=SingletonGenerator()):
     assert sgen.state is None

extmod/asyncio/stream.py

@@ -180,11 +180,11 @@ async def start_server(cb, host, port, backlog=5, ssl=None):
     import socket
 
     # Create and bind server socket.
-    host = socket.getaddrinfo(host, port)[0]  # TODO this is blocking!
-    s = socket.socket()
+    addr_info = socket.getaddrinfo(host, port)[0]  # TODO this is blocking!
+    s = socket.socket(addr_info[0])  # Use address family from getaddrinfo
     s.setblocking(False)
     s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    s.bind(host[-1])
+    s.bind(addr_info[-1])
     s.listen(backlog)
 
     # Create and return server object and task.

extmod/lwip-include/arch/cc.h

@@ -1,41 +0,0 @@
-#ifndef MICROPY_INCLUDED_EXTMOD_LWIP_INCLUDE_ARCH_CC_H
-#define MICROPY_INCLUDED_EXTMOD_LWIP_INCLUDE_ARCH_CC_H
-
-#include <stdint.h>
-
-// Generate lwip's internal types from stdint
-
-typedef uint8_t u8_t;
-typedef int8_t s8_t;
-typedef uint16_t u16_t;
-typedef int16_t s16_t;
-typedef uint32_t u32_t;
-typedef int32_t s32_t;
-
-typedef u32_t mem_ptr_t;
-
-#define U16_F "hu"
-#define S16_F "hd"
-#define X16_F "hx"
-#define U32_F "u"
-#define S32_F "d"
-#define X32_F "x"
-
-#define X8_F  "02x"
-#define SZT_F "u"
-
-#define BYTE_ORDER LITTLE_ENDIAN
-
-#define LWIP_CHKSUM_ALGORITHM 2
-
-#include <assert.h>
-#define LWIP_PLATFORM_DIAG(x)
-#define LWIP_PLATFORM_ASSERT(x)  { assert(1); }
-
-//#define PACK_STRUCT_FIELD(x) x __attribute__((packed))
-#define PACK_STRUCT_FIELD(x) x
-#define PACK_STRUCT_STRUCT __attribute__((packed))
-#define PACK_STRUCT_BEGIN
-#define PACK_STRUCT_END
-
-#endif // MICROPY_INCLUDED_EXTMOD_LWIP_INCLUDE_ARCH_CC_H

extmod/lwip-include/arch/perf.h

@@ -1,7 +0,0 @@
-#ifndef MICROPY_INCLUDED_EXTMOD_LWIP_INCLUDE_ARCH_PERF_H
-#define MICROPY_INCLUDED_EXTMOD_LWIP_INCLUDE_ARCH_PERF_H
-
-#define PERF_START    /* null definition */
-#define PERF_STOP(x)  /* null definition */
-
-#endif // MICROPY_INCLUDED_EXTMOD_LWIP_INCLUDE_ARCH_PERF_H

extmod/lwip-include/lwipopts.h

@@ -1,35 +0,0 @@
-#ifndef MICROPY_INCLUDED_EXTMOD_LWIP_INCLUDE_LWIPOPTS_H
-#define MICROPY_INCLUDED_EXTMOD_LWIP_INCLUDE_LWIPOPTS_H
-
-#include <py/mpconfig.h>
-#include <py/misc.h>
-#include <py/mphal.h>
-
-// We're running without an OS for this port. We don't provide any services except light protection.
-#define NO_SYS 1
-
-#define SYS_LIGHTWEIGHT_PROT 1
-#include <stdint.h>
-typedef uint32_t sys_prot_t;
-
-#define TCP_LISTEN_BACKLOG 1
-
-// We'll put these into a proper ifdef once somebody implements an ethernet driver
-#define LWIP_ARP 0
-#define LWIP_ETHERNET 0
-
-#define LWIP_DNS 1
-
-#define LWIP_NETCONN 0
-#define LWIP_SOCKET 0
-
-#ifdef MICROPY_PY_LWIP_SLIP
-#define LWIP_HAVE_SLIPIF 1
-#endif
-
-// For now, we can simply define this as a macro for the timer code. But this function isn't
-// universal and other ports will need to do something else. It may be necessary to move
-// things like this into a port-provided header file.
-#define sys_now mp_hal_ticks_ms
-
-#endif // MICROPY_INCLUDED_EXTMOD_LWIP_INCLUDE_LWIPOPTS_H

extmod/machine_timer.c

@@ -42,13 +42,14 @@ static void machine_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_pr
 }
 
 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, };
+    enum { ARG_mode, ARG_callback, ARG_period, ARG_tick_hz, ARG_freq, ARG_hard, };
     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_obj = MP_OBJ_NULL} },
         { 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} },
+        { MP_QSTR_hard,         MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
     };
 
     // Parse args
@@ -81,6 +82,12 @@ static mp_obj_t machine_timer_init_helper(machine_timer_obj_t *self, size_t n_ar
         self->py_callback = args[ARG_callback].u_obj;
     }
 
+    if (args[ARG_hard].u_bool) {
+        self->flags |= SOFT_TIMER_FLAG_HARD_CALLBACK;
+    } else {
+        self->flags &= ~SOFT_TIMER_FLAG_HARD_CALLBACK;
+    }
+
     if (self->py_callback != mp_const_none) {
         soft_timer_insert(self, self->delta_ms);
     }

extmod/machine_uart.c

@@ -140,10 +140,10 @@ static const mp_rom_map_elem_t machine_uart_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&machine_uart_deinit_obj) },
 
     { MP_ROM_QSTR(MP_QSTR_flush), MP_ROM_PTR(&mp_stream_flush_obj) },
-    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read1_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_readinto), MP_ROM_PTR(&mp_stream_readinto1_obj) },
+    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write1_obj) },
 
     { MP_ROM_QSTR(MP_QSTR_any), MP_ROM_PTR(&machine_uart_any_obj) },
     { MP_ROM_QSTR(MP_QSTR_txdone), MP_ROM_PTR(&machine_uart_txdone_obj) },

extmod/machine_usb_device.c

@@ -42,6 +42,8 @@
 
 #define HAS_BUILTIN_DRIVERS (MICROPY_HW_USB_CDC || MICROPY_HW_USB_MSC)
 
+#define RHPORT TUD_OPT_RHPORT
+
 const mp_obj_type_t machine_usb_device_type;
 
 static mp_obj_t usb_device_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
@@ -111,11 +113,11 @@ static mp_obj_t usb_device_submit_xfer(mp_obj_t self, mp_obj_t ep, mp_obj_t buff
         mp_raise_ValueError(MP_ERROR_TEXT("ep"));
     }
 
-    if (!usbd_edpt_claim(USBD_RHPORT, ep_addr)) {
+    if (!usbd_edpt_claim(RHPORT, ep_addr)) {
         mp_raise_OSError(MP_EBUSY);
     }
 
-    result = usbd_edpt_xfer(USBD_RHPORT, ep_addr, buf_info.buf, buf_info.len);
+    result = usbd_edpt_xfer(RHPORT, ep_addr, buf_info.buf, buf_info.len);
 
     if (result) {
         // Store the buffer object until the transfer completes
@@ -168,14 +170,14 @@ static mp_obj_t usb_device_stall(size_t n_args, const mp_obj_t *args) {
 
     usb_device_check_active(self);
 
-    mp_obj_t res = mp_obj_new_bool(usbd_edpt_stalled(USBD_RHPORT, epnum));
+    mp_obj_t res = mp_obj_new_bool(usbd_edpt_stalled(RHPORT, epnum));
 
     if (n_args == 3) { // Set stall state
         mp_obj_t stall = args[2];
         if (mp_obj_is_true(stall)) {
-            usbd_edpt_stall(USBD_RHPORT, epnum);
+            usbd_edpt_stall(RHPORT, epnum);
         } else {
-            usbd_edpt_clear_stall(USBD_RHPORT, epnum);
+            usbd_edpt_clear_stall(RHPORT, epnum);
         }
     }
 

extmod/modframebuf.c

@@ -483,9 +483,7 @@ static void line(const mp_obj_framebuf_t *fb, mp_int_t x1, mp_int_t y1, mp_int_t
         e += 2 * dy;
     }
 
-    if (0 <= x2 && x2 < fb->width && 0 <= y2 && y2 < fb->height) {
-        setpixel(fb, x2, y2, col);
-    }
+    setpixel_checked(fb, x2, y2, col, 1);
 }
 
 static mp_obj_t framebuf_line(size_t n_args, const mp_obj_t *args_in) {
@@ -787,39 +785,40 @@ static mp_obj_t framebuf_scroll(mp_obj_t self_in, mp_obj_t xstep_in, mp_obj_t ys
     mp_obj_framebuf_t *self = MP_OBJ_TO_PTR(self_in);
     mp_int_t xstep = mp_obj_get_int(xstep_in);
     mp_int_t ystep = mp_obj_get_int(ystep_in);
-    int sx, y, xend, yend, dx, dy;
+    unsigned int sx, y, xend, yend;
+    int dx, dy;
     if (xstep < 0) {
-        sx = 0;
-        xend = self->width + xstep;
-        if (xend <= 0) {
+        if (-xstep >= self->width) {
             return mp_const_none;
         }
+        sx = 0;
+        xend = self->width + (int)xstep;
         dx = 1;
     } else {
-        sx = self->width - 1;
-        xend = xstep - 1;
-        if (xend >= sx) {
+        if (xstep >= self->width) {
             return mp_const_none;
         }
+        sx = self->width - 1;
+        xend = (int)xstep - 1;
         dx = -1;
     }
     if (ystep < 0) {
-        y = 0;
-        yend = self->height + ystep;
-        if (yend <= 0) {
+        if (-ystep >= self->height) {
             return mp_const_none;
         }
+        y = 0;
+        yend = self->height + (int)ystep;
         dy = 1;
     } else {
-        y = self->height - 1;
-        yend = ystep - 1;
-        if (yend >= y) {
+        if (ystep >= self->height) {
             return mp_const_none;
         }
+        y = self->height - 1;
+        yend = (int)ystep - 1;
         dy = -1;
     }
     for (; y != yend; y += dy) {
-        for (int x = sx; x != xend; x += dx) {
+        for (unsigned x = sx; x != xend; x += dx) {
             setpixel(self, x, y, getpixel(self, x - xstep, y - ystep));
         }
     }

extmod/modlwip.c

@@ -1724,18 +1724,6 @@ static MP_DEFINE_CONST_OBJ_TYPE(
     locals_dict, &lwip_socket_locals_dict
     );
 
-/******************************************************************************/
-// Support functions for memory protection. lwIP has its own memory management
-// routines for its internal structures, and since they might be called in
-// interrupt handlers, they need some protection.
-sys_prot_t sys_arch_protect() {
-    return (sys_prot_t)MICROPY_BEGIN_ATOMIC_SECTION();
-}
-
-void sys_arch_unprotect(sys_prot_t state) {
-    MICROPY_END_ATOMIC_SECTION((mp_uint_t)state);
-}
-
 /******************************************************************************/
 // Polling callbacks for the interfaces connected to lwIP. Right now it calls
 // itself a "list" but isn't; we only support a single interface.
@@ -1802,10 +1790,11 @@ static mp_obj_t lwip_getaddrinfo(size_t n_args, const mp_obj_t *args) {
     mp_obj_t host_in = args[0], port_in = args[1];
     const char *host = mp_obj_str_get_str(host_in);
     mp_int_t port = mp_obj_get_int(port_in);
+    mp_int_t family = 0;
 
     // If constraints were passed then check they are compatible with the supported params
     if (n_args > 2) {
-        mp_int_t family = mp_obj_get_int(args[2]);
+        family = mp_obj_get_int(args[2]);
         mp_int_t type = 0;
         mp_int_t proto = 0;
         mp_int_t flags = 0;
@@ -1818,7 +1807,7 @@ static mp_obj_t lwip_getaddrinfo(size_t n_args, const mp_obj_t *args) {
                 }
             }
         }
-        if (!((family == 0 || family == MOD_NETWORK_AF_INET)
+        if (!((family == 0 || family == MOD_NETWORK_AF_INET || family == MOD_NETWORK_AF_INET6)
               && (type == 0 || type == MOD_NETWORK_SOCK_STREAM)
               && proto == 0
               && flags == 0)) {
@@ -1829,11 +1818,23 @@ static mp_obj_t lwip_getaddrinfo(size_t n_args, const mp_obj_t *args) {
     getaddrinfo_state_t state;
     state.status = 0;
 
+    #if LWIP_VERSION_MAJOR >= 2
+    // If family was specified, then try and resolve the address type as
+    // requested. Otherwise, use the default from network configuration.
+    if (family == MOD_NETWORK_AF_INET) {
+        family = LWIP_DNS_ADDRTYPE_IPV4;
+    } else if (family == MOD_NETWORK_AF_INET6) {
+        family = LWIP_DNS_ADDRTYPE_IPV6;
+    } else {
+        family = mp_mod_network_prefer_dns_use_ip_version == 4 ? LWIP_DNS_ADDRTYPE_IPV4_IPV6 : LWIP_DNS_ADDRTYPE_IPV6_IPV4;
+    }
+    #endif
+
     MICROPY_PY_LWIP_ENTER
     #if LWIP_VERSION_MAJOR < 2
     err_t ret = dns_gethostbyname(host, (ip_addr_t *)&state.ipaddr, lwip_getaddrinfo_cb, &state);
     #else
-    err_t ret = dns_gethostbyname_addrtype(host, (ip_addr_t *)&state.ipaddr, lwip_getaddrinfo_cb, &state, mp_mod_network_prefer_dns_use_ip_version == 4 ? LWIP_DNS_ADDRTYPE_IPV4_IPV6 : LWIP_DNS_ADDRTYPE_IPV6_IPV4);
+    err_t ret = dns_gethostbyname_addrtype(host, (ip_addr_t *)&state.ipaddr, lwip_getaddrinfo_cb, &state, family);
     #endif
     MICROPY_PY_LWIP_EXIT
 

extmod/modopenamp_remoteproc_store.c

@@ -76,6 +76,7 @@ static int openamp_remoteproc_store_open(void *store, const char *path, const vo
 
     openamp_remoteproc_filestore_t *fstore = store;
     fstore->file = mp_vfs_open(MP_ARRAY_SIZE(args), args, (mp_map_t *)&mp_const_empty_map);
+    (void)mp_get_stream_raise(fstore->file, MP_STREAM_OP_READ);
 
     int error = 0;
     mp_uint_t bytes = mp_stream_read_exactly(fstore->file, fstore->buf, RPROC_FILE_STORE_BUF_SIZE, &error);

extmod/modplatform.c

@@ -61,11 +61,49 @@ static mp_obj_t platform_libc_ver(size_t n_args, const mp_obj_t *pos_args, mp_ma
 }
 static MP_DEFINE_CONST_FUN_OBJ_KW(platform_libc_ver_obj, 0, platform_libc_ver);
 
+#ifdef __riscv
+static mp_obj_t platform_processor(void) {
+    #if (__riscv_xlen <= 64) && !defined(__linux__)
+    uintptr_t misa_csr = 0;
+
+    // Load the MISA CSR directly.
+    __asm volatile (
+        "csrr %0, misa \n"
+        : "+r" (misa_csr)
+        :
+        :
+        );
+
+    char processor_buffer[31] = { // "RV32"/"RV64" + up to 26 chars.
+        #if (__riscv_xlen < 64)
+        "RV32"
+        #else
+        "RV64"
+        #endif
+    };
+    mp_uint_t offset = 4;
+    for (mp_uint_t bit = 0; bit < 26; bit++) {
+        if (misa_csr & (1U << bit)) {
+            processor_buffer[offset++] = 'A' + bit;
+        }
+    }
+
+    return mp_obj_new_str(processor_buffer, offset);
+    #else
+    return MP_OBJ_NEW_QSTR(MP_QSTR_);
+    #endif
+}
+static MP_DEFINE_CONST_FUN_OBJ_0(platform_processor_obj, platform_processor);
+#endif
+
 static const mp_rom_map_elem_t modplatform_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_platform) },
     { MP_ROM_QSTR(MP_QSTR_platform), MP_ROM_PTR(&platform_platform_obj) },
     { MP_ROM_QSTR(MP_QSTR_python_compiler), MP_ROM_PTR(&platform_python_compiler_obj) },
     { MP_ROM_QSTR(MP_QSTR_libc_ver), MP_ROM_PTR(&platform_libc_ver_obj) },
+    #ifdef __riscv
+    { MP_ROM_QSTR(MP_QSTR_processor), MP_ROM_PTR(&platform_processor_obj) },
+    #endif
 };
 
 static MP_DEFINE_CONST_DICT(modplatform_globals, modplatform_globals_table);

extmod/modre.c

@@ -196,10 +196,11 @@ static void re_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t
 
 // Note: this function can't be named re_exec because it may clash with system headers, eg on FreeBSD
 static mp_obj_t re_exec_helper(bool is_anchored, uint n_args, const mp_obj_t *args) {
-    (void)n_args;
     mp_obj_re_t *self;
+    bool was_compiled = false;
     if (mp_obj_is_type(args[0], (mp_obj_type_t *)&re_type)) {
         self = MP_OBJ_TO_PTR(args[0]);
+        was_compiled = true;
     } else {
         self = MP_OBJ_TO_PTR(mod_re_compile(1, args));
     }
@@ -207,6 +208,28 @@ static mp_obj_t re_exec_helper(bool is_anchored, uint n_args, const mp_obj_t *ar
     size_t len;
     subj.begin_line = subj.begin = mp_obj_str_get_data(args[1], &len);
     subj.end = subj.begin + len;
+
+    if (was_compiled && n_args > 2) {
+        // Arg #2 is starting-pos
+        mp_int_t startpos = mp_obj_get_int(args[2]);
+        if (startpos > (mp_int_t)len) {
+            startpos = len;
+        } else if (startpos < 0) {
+            startpos = 0;
+        }
+        subj.begin += startpos;
+        if (n_args > 3) {
+            // Arg #3 is ending-pos
+            mp_int_t endpos = mp_obj_get_int(args[3]);
+            if (endpos > (mp_int_t)len) {
+                endpos = len;
+            } else if (endpos < startpos) {
+                endpos = startpos;
+            }
+            subj.end = subj.begin_line + endpos;
+        }
+    }
+
     int caps_num = (self->re.sub + 1) * 2;
     mp_obj_match_t *match = m_new_obj_var(mp_obj_match_t, caps, 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

extmod/modtime.c

@@ -53,26 +53,26 @@
 // - weekday is 0-6 for Mon-Sun
 // - yearday is 1-366
 static mp_obj_t time_localtime(size_t n_args, const mp_obj_t *args) {
+    timeutils_struct_time_t tm;
     if (n_args == 0 || args[0] == mp_const_none) {
         // Get current date and time.
-        return mp_time_localtime_get();
+        mp_time_localtime_get(&tm);
     } else {
         // Convert given seconds to tuple.
         mp_timestamp_t seconds = timeutils_obj_get_timestamp(args[0]);
-        timeutils_struct_time_t tm;
         timeutils_seconds_since_epoch_to_struct_time(seconds, &tm);
-        mp_obj_t tuple[8] = {
-            tuple[0] = mp_obj_new_int(tm.tm_year),
-            tuple[1] = mp_obj_new_int(tm.tm_mon),
-            tuple[2] = mp_obj_new_int(tm.tm_mday),
-            tuple[3] = mp_obj_new_int(tm.tm_hour),
-            tuple[4] = mp_obj_new_int(tm.tm_min),
-            tuple[5] = mp_obj_new_int(tm.tm_sec),
-            tuple[6] = mp_obj_new_int(tm.tm_wday),
-            tuple[7] = mp_obj_new_int(tm.tm_yday),
-        };
-        return mp_obj_new_tuple(8, tuple);
     }
+    mp_obj_t tuple[8] = {
+        mp_obj_new_int(tm.tm_year),
+        mp_obj_new_int(tm.tm_mon),
+        mp_obj_new_int(tm.tm_mday),
+        mp_obj_new_int(tm.tm_hour),
+        mp_obj_new_int(tm.tm_min),
+        mp_obj_new_int(tm.tm_sec),
+        mp_obj_new_int(tm.tm_wday),
+        mp_obj_new_int(tm.tm_yday),
+    };
+    return mp_obj_new_tuple(8, tuple);
 }
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_time_localtime_obj, 0, 1, time_localtime);
 

extmod/modtls_mbedtls.c

@@ -304,7 +304,7 @@ static mp_obj_t ssl_context_make_new(const mp_obj_type_t *type_in, size_t n_args
     psa_crypto_init();
     #endif
 
-    const byte seed[] = "upy";
+    const byte seed[] = "mpy";
     int ret = mbedtls_ctr_drbg_seed(&self->ctr_drbg, mbedtls_entropy_func, &self->entropy, seed, sizeof(seed));
     if (ret != 0) {
         mbedtls_raise_error(ret);

extmod/moductypes.c

@@ -28,6 +28,7 @@
 #include <string.h>
 #include <stdint.h>
 
+#include "py/smallint.h"
 #include "py/runtime.h"
 #include "py/objtuple.h"
 #include "py/binary.h"
@@ -94,6 +95,17 @@ static MP_NORETURN void syntax_error(void) {
 }
 
 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) {
+    // Because mpy-cross turns an expression like `uctypes.INT8` into a single
+    // constant integer load, the uctypes constant values must be consistent, no
+    // matter the OBJ_REPR and mp_int_t type.
+    //
+    // However, these constants are 31 bits (counting the sign bit) while
+    // OBJ_REPR_B with 32-bit mp_int_t provides only 30 bits of small integer, so
+    // this combination is unsupported.
+    //
+    // For more information, see https://github.com/micropython/micropython/issues/18105
+    MP_STATIC_ASSERT(MP_SMALL_INT_BITS >= 31);
+
     mp_arg_check_num(n_args, n_kw, 2, 3, false);
     mp_obj_uctypes_struct_t *o = mp_obj_malloc(mp_obj_uctypes_struct_t, type);
     o->addr = (void *)(uintptr_t)mp_obj_get_int_truncated(args[0]);

extmod/modwebsocket.c

@@ -76,6 +76,7 @@ static mp_obj_t websocket_make_new(const mp_obj_type_t *type, size_t n_args, siz
 
 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);
+
     const mp_stream_p_t *stream_p = mp_get_stream(self->sock);
     while (1) {
         if (self->to_recv != 0) {
@@ -93,9 +94,6 @@ static mp_uint_t websocket_read(mp_obj_t self_in, void *buf, mp_uint_t size, int
 
         switch (self->state) {
             case FRAME_HEADER: {
-                // TODO: Split frame handling below is untested so far, so conservatively disable it
-                assert(self->buf[0] & 0x80);
-
                 // "Control frames MAY be injected in the middle of a fragmented message."
                 // So, they must be processed before data frames (and not alter
                 // self->ws_flags)
@@ -120,14 +118,15 @@ static mp_uint_t websocket_read(mp_obj_t self_in, void *buf, mp_uint_t size, int
                     // Msg size is next 2 bytes
                     to_recv += 2;
                 } else if (sz == 127) {
-                    // Msg size is next 8 bytes
-                    assert(0);
+                    // Msg size is next 8 bytes (unsupported, no way to recover)
+                    mp_stream_close(self->sock);
+                    *errcode = MP_EIO;
+                    return MP_STREAM_ERROR;
                 }
                 if (self->buf[1] & 0x80) {
                     // Next 4 bytes is mask
                     to_recv += 4;
                 }
-
                 self->buf_pos = 0;
                 self->to_recv = to_recv;
                 self->msg_sz = sz; // May be overridden by FRAME_OPT
@@ -144,11 +143,13 @@ static mp_uint_t websocket_read(mp_obj_t self_in, void *buf, mp_uint_t size, int
             }
 
             case FRAME_OPT: {
-                if ((self->buf_pos & 3) == 2) {
-                    // First two bytes are message length
+                if (self->buf_pos & 2) { // to_recv was 2 or 6
+                    assert(self->buf_pos == 2 || self->buf_pos == 6);
+                    // First two bytes are message length. Technically the size must be at least 126 per RFC6455
+                    // but MicroPython skips checking that.
                     self->msg_sz = (self->buf[0] << 8) | self->buf[1];
                 }
-                if (self->buf_pos >= 4) {
+                if (self->buf_pos & 4) {
                     // Last 4 bytes is mask
                     memcpy(self->mask, self->buf + self->buf_pos - 4, 4);
                 }
@@ -218,9 +219,16 @@ 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);
-    assert(size < 0x10000);
+    if (size >= 0x10000) {
+        *errcode = MP_ENOBUFS;
+        return MP_STREAM_ERROR;
+    }
     byte header[4] = {0x80 | (self->opts & FRAME_OPCODE_MASK)};
     int hdr_sz;
+    // "Note that in all cases, the minimal number of bytes MUST be used to
+    // encode the length, for example, the length of a 124-byte-long string
+    // can't be encoded as the sequence 126, 0, 124."
+    //   -- https://www.rfc-editor.org/rfc/rfc6455.html
     if (size < 126) {
         header[1] = size;
         hdr_sz = 2;

extmod/network_ppp_lwip.c

@@ -62,8 +62,6 @@ typedef struct _network_ppp_obj_t {
 
 const mp_obj_type_t mp_network_ppp_lwip_type;
 
-static mp_obj_t network_ppp___del__(mp_obj_t self_in);
-
 static void network_ppp_stream_uart_irq_disable(network_ppp_obj_t *self) {
     if (self->stream == mp_const_none) {
         return;
@@ -88,8 +86,12 @@ static void network_ppp_status_cb(ppp_pcb *pcb, int err_code, void *ctx) {
                 // only need to free the PPP PCB, not close it.
                 self->state = STATE_ACTIVE;
             }
+            network_ppp_stream_uart_irq_disable(self);
             // Clean up the PPP PCB.
-            network_ppp___del__(MP_OBJ_FROM_PTR(self));
+            if (ppp_free(pcb) == ERR_OK) {
+                self->state = STATE_INACTIVE;
+                self->pcb = NULL;
+            }
             break;
         default:
             self->state = STATE_ERROR;
@@ -117,17 +119,18 @@ static mp_obj_t network_ppp_make_new(const mp_obj_type_t *type, size_t n_args, s
 
 static mp_obj_t network_ppp___del__(mp_obj_t self_in) {
     network_ppp_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    if (self->state >= STATE_ACTIVE) {
-        if (self->state >= STATE_ERROR) {
-            // Still connected over the stream.
-            // Force the connection to close, with nocarrier=1.
-            self->state = STATE_INACTIVE;
-            ppp_close(self->pcb, 1);
-        }
-        network_ppp_stream_uart_irq_disable(self);
+
+    network_ppp_stream_uart_irq_disable(self);
+    if (self->state >= STATE_ERROR) {
+        // Still connected over the stream.
+        // Force the connection to close, with nocarrier=1.
+        ppp_close(self->pcb, 1);
+    } else if (self->state >= STATE_ACTIVE) {
         // Free PPP PCB and reset state.
+        if (ppp_free(self->pcb) != ERR_OK) {
+            mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("ppp_free failed"));
+        }
         self->state = STATE_INACTIVE;
-        ppp_free(self->pcb);
         self->pcb = NULL;
     }
     return mp_const_none;
@@ -142,8 +145,8 @@ static mp_obj_t network_ppp_poll(size_t n_args, const mp_obj_t *args) {
     }
 
     mp_int_t total_len = 0;
-    mp_obj_t stream = self->stream;
-    while (stream != mp_const_none) {
+    mp_obj_t stream;
+    while (self->state >= STATE_ACTIVE && (stream = self->stream) != mp_const_none) {
         uint8_t buf[256];
         int err;
         mp_uint_t len = mp_stream_rw(stream, buf, sizeof(buf), &err, 0);

extmod/vfs.c

@@ -96,7 +96,7 @@ mp_vfs_mount_t *mp_vfs_lookup_path(const char *path, const char **path_out) {
     return MP_STATE_VM(vfs_cur);
 }
 
-// Version of mp_vfs_lookup_path that takes and returns uPy string objects.
+// Version of mp_vfs_lookup_path that takes and returns MicroPython string objects.
 static mp_vfs_mount_t *lookup_path(mp_obj_t path_in, mp_obj_t *path_out) {
     const char *path = mp_obj_str_get_str(path_in);
     const char *p_out;

extmod/vfs_blockdev.c

@@ -69,7 +69,7 @@ static int mp_vfs_blockdev_call_rw(mp_obj_t *args, size_t block_num, size_t bloc
         // and negative integer on errors. Check for positive integer
         // results as some callers (i.e. littlefs) will produce corrupt
         // results from these.
-        int i = MP_OBJ_SMALL_INT_VALUE(ret);
+        int i = mp_obj_get_int(ret);
         return i > 0 ? (-MP_EINVAL) : i;
     }
 }

extmod/vfs_lfsx_file.c

@@ -90,9 +90,9 @@ mp_obj_t MP_VFS_LFSx(file_open)(mp_obj_t self_in, mp_obj_t path_in, mp_obj_t mod
     }
 
     #if LFS_BUILD_VERSION == 1
-    MP_OBJ_VFS_LFSx_FILE *o = mp_obj_malloc_var_with_finaliser(MP_OBJ_VFS_LFSx_FILE, uint8_t, self->lfs.cfg->prog_size, type);
+    MP_OBJ_VFS_LFSx_FILE *o = mp_obj_malloc_var_with_finaliser(MP_OBJ_VFS_LFSx_FILE, file_buffer, uint8_t, self->lfs.cfg->prog_size, type);
     #else
-    MP_OBJ_VFS_LFSx_FILE *o = mp_obj_malloc_var_with_finaliser(MP_OBJ_VFS_LFSx_FILE, uint8_t, self->lfs.cfg->cache_size, type);
+    MP_OBJ_VFS_LFSx_FILE *o = mp_obj_malloc_var_with_finaliser(MP_OBJ_VFS_LFSx_FILE, file_buffer, uint8_t, self->lfs.cfg->cache_size, type);
     #endif
     o->vfs = self;
     #if !MICROPY_GC_CONSERVATIVE_CLEAR

extmod/vfs_reader.c

@@ -83,7 +83,7 @@ void mp_reader_new_file(mp_reader_t *reader, qstr filename) {
     };
     mp_obj_t file = mp_vfs_open(MP_ARRAY_SIZE(args), &args[0], (mp_map_t *)&mp_const_empty_map);
 
-    const mp_stream_p_t *stream_p = mp_get_stream(file);
+    const mp_stream_p_t *stream_p = mp_get_stream_raise(file, MP_STREAM_OP_READ);
     int errcode = 0;
 
     #if MICROPY_VFS_ROM

lib/libm_dbl/libm.h

@@ -89,7 +89,9 @@ do {                                              \
   (d) = __u.f;                                    \
 } while (0)
 
+#if !defined(DBL_EPSILON)
 #define DBL_EPSILON 2.22044604925031308085e-16
+#endif
 
 int __rem_pio2(double, double*);
 int __rem_pio2_large(double*, double*, int, int, int);

lib/littlefs/lfs2.c

@@ -93,6 +93,7 @@ static int lfs2_bd_read(lfs2_t *lfs2,
             // bypass cache?
             diff = lfs2_aligndown(diff, lfs2->cfg->read_size);
             int err = lfs2->cfg->read(lfs2->cfg, block, off, data, diff);
+            LFS2_ASSERT(err <= 0);
             if (err) {
                 return err;
             }
@@ -739,6 +740,7 @@ static lfs2_stag_t lfs2_dir_getslice(lfs2_t *lfs2, const lfs2_mdir_t *dir,
         int err = lfs2_bd_read(lfs2,
                 NULL, &lfs2->rcache, sizeof(ntag),
                 dir->pair[0], off, &ntag, sizeof(ntag));
+        LFS2_ASSERT(err <= 0);
         if (err) {
             return err;
         }
@@ -767,6 +769,7 @@ static lfs2_stag_t lfs2_dir_getslice(lfs2_t *lfs2, const lfs2_mdir_t *dir,
             err = lfs2_bd_read(lfs2,
                     NULL, &lfs2->rcache, diff,
                     dir->pair[0], off+sizeof(tag)+goff, gbuffer, diff);
+            LFS2_ASSERT(err <= 0);
             if (err) {
                 return err;
             }
@@ -828,9 +831,6 @@ static int lfs2_dir_getread(lfs2_t *lfs2, const lfs2_mdir_t *dir,
                 size -= diff;
                 continue;
             }
-
-            // rcache takes priority
-            diff = lfs2_min(diff, rcache->off-off);
         }
 
         // load to cache, first condition can no longer fail
@@ -1282,6 +1282,7 @@ static lfs2_stag_t lfs2_dir_fetchmatch(lfs2_t *lfs2,
                     if (err == LFS2_ERR_CORRUPT) {
                         break;
                     }
+                    return err;
                 }
 
                 lfs2_fcrc_fromle32(&fcrc);
@@ -2267,7 +2268,7 @@ static int lfs2_dir_relocatingcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
         }
     }
 
-    if (dir->erased) {
+    if (dir->erased && dir->count < 0xff) {
         // try to commit
         struct lfs2_commit commit = {
             .block = dir->pair[0],
@@ -5225,7 +5226,9 @@ static int lfs2_fs_gc_(lfs2_t *lfs2) {
     }
 
     // try to populate the lookahead buffer, unless it's already full
-    if (lfs2->lookahead.size < 8*lfs2->cfg->lookahead_size) {
+    if (lfs2->lookahead.size < lfs2_min(
+            8 * lfs2->cfg->lookahead_size,
+            lfs2->block_count)) {
         err = lfs2_alloc_scan(lfs2);
         if (err) {
             return err;

mpy-cross/main.c

@@ -34,12 +34,18 @@
 #include "py/persistentcode.h"
 #include "py/runtime.h"
 #include "py/gc.h"
-#include "py/stackctrl.h"
+#include "py/parsenum.h"
 #include "genhdr/mpversion.h"
 #ifdef _WIN32
 #include "ports/windows/fmode.h"
 #endif
 
+#if MICROPY_EMIT_NATIVE && MICROPY_EMIT_RV32
+#include "py/asmrv32.h"
+
+static asm_rv32_backend_options_t rv32_options = { 0 };
+#endif
+
 // Command line options, with their defaults
 static uint emit_opt = MP_EMIT_OPT_NONE;
 mp_uint_t mp_verbose_flag = 0;
@@ -81,13 +87,20 @@ static int compile_and_save(const char *file, const char *output_file, const cha
             source_name = qstr_from_str(source_file);
         }
 
-        #if MICROPY_PY___FILE__
+        #if MICROPY_MODULE___FILE__
         mp_store_global(MP_QSTR___file__, MP_OBJ_NEW_QSTR(source_name));
         #endif
 
         mp_parse_tree_t parse_tree = mp_parse(lex, MP_PARSE_FILE_INPUT);
         mp_compiled_module_t cm;
         cm.context = m_new_obj(mp_module_context_t);
+        cm.arch_flags = 0;
+        #if MICROPY_EMIT_NATIVE && MICROPY_EMIT_RV32
+        if (mp_dynamic_compiler.native_arch == MP_NATIVE_ARCH_RV32IMC && mp_dynamic_compiler.backend_options != NULL) {
+            cm.arch_flags = ((asm_rv32_backend_options_t *)mp_dynamic_compiler.backend_options)->allowed_extensions;
+        }
+        #endif
+
         mp_compile_to_raw_code(&parse_tree, source_name, false, &cm);
 
         if ((output_file != NULL && strcmp(output_file, "-") == 0) ||
@@ -130,7 +143,10 @@ static int usage(char **argv) {
         "Target specific options:\n"
         "-msmall-int-bits=number : set the maximum bits used to encode a small-int\n"
         "-march=<arch> : set architecture for native emitter;\n"
-        "                x86, x64, armv6, armv6m, armv7m, armv7em, armv7emsp, armv7emdp, xtensa, xtensawin, rv32imc, host, debug\n"
+        "                x86, x64, armv6, armv6m, armv7m, armv7em, armv7emsp,\n"
+        "                armv7emdp, xtensa, xtensawin, rv32imc, rv64imc, host, debug\n"
+        "-march-flags=<flags> : set architecture-specific flags (can be either a dec/hex/bin value or a comma-separated flags string)\n"
+        "                       supported flags for rv32imc: zba, zcmp\n"
         "\n"
         "Implementation specific options:\n", argv[0]
         );
@@ -211,9 +227,67 @@ static char *backslash_to_forwardslash(char *path) {
     return path;
 }
 
-MP_NOINLINE int main_(int argc, char **argv) {
-    mp_stack_set_limit(40000 * (sizeof(void *) / 4));
+// This will need to be reworked in case mpy-cross needs to set more bits than
+// what its small int representation allows to fit in there.
+static bool parse_integer(const char *value, mp_uint_t *integer) {
+    assert(value && "Attempting to parse a NULL string");
+    assert(integer && "Attempting to store into a NULL integer buffer");
 
+    size_t value_length = strlen(value);
+    int base = 10;
+    if (value_length > 2 && value[0] == '0') {
+        if ((value[1] | 0x20) == 'b') {
+            base = 2;
+        } else if ((value[1] | 0x20) == 'x') {
+            base = 16;
+        } else {
+            return false;
+        }
+    }
+
+    bool valid = false;
+    nlr_buf_t nlr;
+    if (nlr_push(&nlr) == 0) {
+        mp_obj_t parsed = mp_parse_num_integer(value, value_length, base, NULL);
+        if (mp_obj_is_small_int(parsed)) {
+            *integer = MP_OBJ_SMALL_INT_VALUE(parsed);
+            valid = true;
+        }
+        nlr_pop();
+    }
+
+    return valid;
+}
+
+#if MICROPY_EMIT_NATIVE && MICROPY_EMIT_RV32
+static bool parse_rv32_flags_string(const char *source, mp_uint_t *flags) {
+    assert(source && "Flag arguments string is NULL.");
+    assert(flags && "Collected flags pointer is NULL.");
+
+    const char *current = source;
+    const char *end = source + strlen(source);
+    mp_uint_t collected_flags = 0;
+    while (current < end) {
+        const char *separator = strchr(current, ',');
+        if (separator == NULL) {
+            separator = end;
+        }
+        ptrdiff_t length = separator - current;
+        if (length == (sizeof("zba") - 1) && memcmp(current, "zba", length) == 0) {
+            collected_flags |= RV32_EXT_ZBA;
+        } else if (length == (sizeof("zcmp") - 1) && memcmp(current, "zcmp", length) == 0) {
+            collected_flags |= RV32_EXT_ZCMP;
+        } else {
+            return false;
+        }
+        current = separator + 1;
+    }
+    *flags = collected_flags;
+    return collected_flags != 0;
+}
+#endif
+
+MP_NOINLINE int main_(int argc, char **argv) {
     pre_process_options(argc, argv);
 
     char *heap = malloc(heap_size);
@@ -236,11 +310,13 @@ MP_NOINLINE int main_(int argc, char **argv) {
     // don't support native emitter unless -march is specified
     mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_NONE;
     mp_dynamic_compiler.nlr_buf_num_regs = 0;
+    mp_dynamic_compiler.backend_options = NULL;
 
     const char *input_file = NULL;
     const char *output_file = NULL;
     const char *source_file = NULL;
     bool option_parsing_active = true;
+    const char *arch_flags = NULL;
 
     // parse main options
     for (int a = 1; a < argc; a++) {
@@ -316,6 +392,9 @@ MP_NOINLINE int main_(int argc, char **argv) {
                 } else if (strcmp(arch, "rv32imc") == 0) {
                     mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_RV32IMC;
                     mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_RV32I;
+                } else if (strcmp(arch, "rv64imc") == 0) {
+                    mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_RV64IMC;
+                    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_RV64I;
                 } else if (strcmp(arch, "debug") == 0) {
                     mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_DEBUG;
                     mp_dynamic_compiler.nlr_buf_num_regs = 0;
@@ -329,6 +408,9 @@ MP_NOINLINE int main_(int argc, char **argv) {
                     #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;
+                    #elif defined(__riscv) && (__riscv_xlen == 64)
+                    mp_dynamic_compiler.native_arch = MP_NATIVE_ARCH_RV64IMC;
+                    mp_dynamic_compiler.nlr_buf_num_regs = MICROPY_NLR_NUM_REGS_RV64I;
                     #else
                     mp_printf(&mp_stderr_print, "unable to determine host architecture for -march=host\n");
                     exit(1);
@@ -336,6 +418,8 @@ MP_NOINLINE int main_(int argc, char **argv) {
                 } else {
                     return usage(argv);
                 }
+            } else if (strncmp(argv[a], "-march-flags=", sizeof("-march-flags=") - 1) == 0) {
+                arch_flags = argv[a] + sizeof("-march-flags=") - 1;
             } else if (strcmp(argv[a], "--") == 0) {
                 option_parsing_active = false;
             } else {
@@ -350,6 +434,26 @@ MP_NOINLINE int main_(int argc, char **argv) {
         }
     }
 
+    if (arch_flags && mp_dynamic_compiler.native_arch != MP_NATIVE_ARCH_NONE) {
+        bool processed = false;
+        #if MICROPY_EMIT_NATIVE && MICROPY_EMIT_RV32
+        if (mp_dynamic_compiler.native_arch == MP_NATIVE_ARCH_RV32IMC) {
+            mp_dynamic_compiler.backend_options = (void *)&rv32_options;
+            mp_uint_t raw_flags = 0;
+            if (parse_integer(arch_flags, &raw_flags) || parse_rv32_flags_string(arch_flags, &raw_flags)) {
+                if ((raw_flags & ~((mp_uint_t)RV32_EXT_ALL)) == 0) {
+                    rv32_options.allowed_extensions = raw_flags;
+                    processed = true;
+                }
+            }
+        }
+        #endif
+        if (!processed) {
+            mp_printf(&mp_stderr_print, "unrecognised arch flags\n");
+            exit(1);
+        }
+    }
+
     #if MICROPY_EMIT_NATIVE
     if ((MP_STATE_VM(default_emit_opt) == MP_EMIT_OPT_NATIVE_PYTHON
          || MP_STATE_VM(default_emit_opt) == MP_EMIT_OPT_VIPER)
@@ -378,7 +482,7 @@ MP_NOINLINE int main_(int argc, char **argv) {
 }
 
 int main(int argc, char **argv) {
-    mp_stack_ctrl_init();
+    mp_cstack_init_with_sp_here(40000 * (sizeof(void *) / 4));
     return main_(argc, argv);
 }
 

mpy-cross/mpconfigport.h

@@ -85,7 +85,7 @@
 #define MICROPY_GCREGS_SETJMP (1)
 #endif
 
-#define MICROPY_PY___FILE__         (0)
+#define MICROPY_MODULE___FILE__     (0)
 #define MICROPY_PY_ARRAY            (0)
 #define MICROPY_PY_ATTRTUPLE        (0)
 #define MICROPY_PY_COLLECTIONS      (0)
@@ -98,23 +98,6 @@
 
 // type definitions for the specific machine
 
-#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)
-#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.
-typedef int mp_int_t; // must be pointer size
-typedef unsigned int mp_uint_t; // must be pointer size
-#endif
-
 // Cannot include <sys/types.h>, as it may lead to symbol name clashes
 #if _FILE_OFFSET_BITS == 64 && !defined(__LP64__)
 typedef long long mp_off_t;

mpy-cross/mpy_cross/__init__.py

@@ -25,7 +25,6 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-from __future__ import print_function
 import os
 import re
 import stat
@@ -44,6 +43,7 @@ NATIVE_ARCHS = {
     "NATIVE_ARCH_XTENSA": "xtensa",
     "NATIVE_ARCH_XTENSAWIN": "xtensawin",
     "NATIVE_ARCH_RV32IMC": "rv32imc",
+    "NATIVE_ARCH_RV64IMC": "rv64imc",
 }
 
 globals().update(NATIVE_ARCHS)

mpy-cross/mpy_cross/__main__.py

@@ -25,7 +25,6 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-from __future__ import print_function
 import argparse
 import sys
 

ports/alif/alif.mk

@@ -22,6 +22,8 @@ include $(TOP)/extmod/extmod.mk
 ################################################################################
 # Project specific settings and compiler/linker flags
 
+MPY_CROSS_FLAGS += -march=armv7emdp
+
 CROSS_COMPILE ?= arm-none-eabi-
 ALIF_DFP_REL_TOP ?= lib/alif_ensemble-cmsis-dfp
 ALIF_DFP_REL_HERE ?= $(TOP)/lib/alif_ensemble-cmsis-dfp

ports/alif/boards/OPENMV_AE3/mpconfigboard.h

@@ -2,9 +2,6 @@
 #define MICROPY_HW_MCU_NAME         "AE302F80F55D5AE"
 
 #define MICROPY_OBJ_REPR            (MICROPY_OBJ_REPR_C)
-typedef intptr_t mp_int_t; // must be pointer size
-typedef uintptr_t mp_uint_t; // must be pointer size
-typedef intptr_t mp_off_t;
 
 #define MICROPY_HW_USB_MSC          (CORE_M55_HP)
 #define MICROPY_HW_ENABLE_HW_I2C    (1)

ports/alif/boards/OPENMV_AE3/pins.csv

@@ -8,7 +8,7 @@ LED_GREEN,P6_3
 LED_BLUE,P6_0
 
 # User switch
-USR_SW,P15_7
+SW,P15_7
 
 # Flash on OSPI0
 FLASH_RESET,P3_3

ports/alif/fatfs_port.c

@@ -24,15 +24,12 @@
  * THE SOFTWARE.
  */
 
+#include "py/mphal.h"
+#include "shared/timeutils/timeutils.h"
 #include "lib/oofatfs/ff.h"
 
 DWORD get_fattime(void) {
-    // TODO
-    int year = 2024;
-    int month = 1;
-    int day = 1;
-    int hour = 0;
-    int min = 0;
-    int sec = 0;
-    return ((year - 1980) << 25) | (month << 21) | (day << 16) | (hour << 11) | (min << 5) | (sec / 2);
+    timeutils_struct_time_t tm;
+    timeutils_seconds_since_epoch_to_struct_time(mp_hal_time_get(NULL), &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 / 2);
 }