From a07543f87df44eb75deb3e886dc156a1d469cd82 Mon Sep 17 00:00:00 2001
From: Wang Xuancong <xuancong84@gmail.com>
Date: Fri, 22 Sep 2023 13:23:13 +0800
Subject: [PATCH 01/51] esp8266: Add OTA firmware update from file and dynamic
 frozen modules.

lib/littlefs/lfs2.c: installed a hook in LFS2 to dig sectors for DFU.
ports/esp8266/modesp.c: core functions for DFU and DFM.
ports/esp8266/modules/inisetup.py: user functions for DFU.
ports/esp8266/main.c: more heap memory (tested working).
ports/esp8266/esppwm.c: higher PWM frequency limit for IR control.
ports/.../esp8266_common.ld: migrated 3 functions for more IRAM space.
ports/.../mpconfigboard.h: this DFU is only for ESP8266 2MB+
py/*: string reader support read from ROM without allocation for DFM

Dynamic frozen module (DFM) can be installed on sectors immediately
after the firmware using esp.add_frozen(). You can also list and delete
modules using esp.ls_frozen() and esp.del_frozen().

Signed-off-by: Wang Xuancong <xuancong84@gmail.com>
---
 .gitignore                                    |    1 +
 extmod/vfs_reader.c                           |    1 +
 lib/littlefs/lfs2.c                           | 1555 +++++++++--------
 ports/esp8266/Makefile                        |    6 +-
 .../boards/ESP8266_GENERIC/mpconfigboard.mk   |    4 +
 ports/esp8266/boards/esp8266_common.ld        |    1 +
 ports/esp8266/esppwm.c                        |    2 +-
 ports/esp8266/main.c                          |    5 +-
 ports/esp8266/modesp.c                        |  394 ++++-
 ports/esp8266/modules/inisetup.py             |   56 +-
 py/frozenmod.c                                |    3 +-
 py/objstr.c                                   |    4 +-
 py/persistentcode.c                           |   47 +-
 py/reader.c                                   |   21 +
 py/reader.h                                   |    1 +
 shared/runtime/pyexec.c                       |    1 +
 16 files changed, 1307 insertions(+), 795 deletions(-)

diff --git a/.gitignore b/.gitignore
index 2d20cb18970e8..3bf5969ab336d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,3 +23,4 @@ user.props
 
 # MacOS desktop metadata files
 .DS_Store
+ports/esp8266/modules/*.py
diff --git a/extmod/vfs_reader.c b/extmod/vfs_reader.c
index d3904c5c50693..a1dd7c4d83ddf 100644
--- a/extmod/vfs_reader.c
+++ b/extmod/vfs_reader.c
@@ -85,6 +85,7 @@ void mp_reader_new_file(mp_reader_t *reader, const char *filename) {
     reader->data = rf;
     reader->readbyte = mp_reader_vfs_readbyte;
     reader->close = mp_reader_vfs_close;
+    reader->readbytes = NULL;
 }
 
 #endif // MICROPY_READER_VFS
diff --git a/lib/littlefs/lfs2.c b/lib/littlefs/lfs2.c
index a9fcffafd818a..f6f0fd7e13ae4 100644
--- a/lib/littlefs/lfs2.c
+++ b/lib/littlefs/lfs2.c
@@ -42,12 +42,12 @@ static inline void lfs2_cache_zero(lfs2_t *lfs2, lfs2_cache_t *pcache) {
 }
 
 static int lfs2_bd_read(lfs2_t *lfs2,
-        const lfs2_cache_t *pcache, lfs2_cache_t *rcache, lfs2_size_t hint,
-        lfs2_block_t block, lfs2_off_t off,
-        void *buffer, lfs2_size_t size) {
+    const lfs2_cache_t *pcache, lfs2_cache_t *rcache, lfs2_size_t hint,
+    lfs2_block_t block, lfs2_off_t off,
+    void *buffer, lfs2_size_t size) {
     uint8_t *data = buffer;
     if (block >= lfs2->cfg->block_count ||
-            off+size > lfs2->cfg->block_size) {
+        off + size > lfs2->cfg->block_size) {
         return LFS2_ERR_CORRUPT;
     }
 
@@ -55,11 +55,11 @@ static int lfs2_bd_read(lfs2_t *lfs2,
         lfs2_size_t diff = size;
 
         if (pcache && block == pcache->block &&
-                off < pcache->off + pcache->size) {
+            off < pcache->off + pcache->size) {
             if (off >= pcache->off) {
                 // is already in pcache?
-                diff = lfs2_min(diff, pcache->size - (off-pcache->off));
-                memcpy(data, &pcache->buffer[off-pcache->off], diff);
+                diff = lfs2_min(diff, pcache->size - (off - pcache->off));
+                memcpy(data, &pcache->buffer[off - pcache->off], diff);
 
                 data += diff;
                 off += diff;
@@ -68,15 +68,15 @@ static int lfs2_bd_read(lfs2_t *lfs2,
             }
 
             // pcache takes priority
-            diff = lfs2_min(diff, pcache->off-off);
+            diff = lfs2_min(diff, pcache->off - off);
         }
 
         if (block == rcache->block &&
-                off < rcache->off + rcache->size) {
+            off < rcache->off + rcache->size) {
             if (off >= rcache->off) {
                 // is already in rcache?
-                diff = lfs2_min(diff, rcache->size - (off-rcache->off));
-                memcpy(data, &rcache->buffer[off-rcache->off], diff);
+                diff = lfs2_min(diff, rcache->size - (off - rcache->off));
+                memcpy(data, &rcache->buffer[off - rcache->off], diff);
 
                 data += diff;
                 off += diff;
@@ -85,11 +85,11 @@ static int lfs2_bd_read(lfs2_t *lfs2,
             }
 
             // rcache takes priority
-            diff = lfs2_min(diff, rcache->off-off);
+            diff = lfs2_min(diff, rcache->off - off);
         }
 
         if (size >= hint && off % lfs2->cfg->read_size == 0 &&
-                size >= lfs2->cfg->read_size) {
+            size >= lfs2->cfg->read_size) {
             // bypass cache?
             diff = lfs2_aligndown(diff, lfs2->cfg->read_size);
             int err = lfs2->cfg->read(lfs2->cfg, block, off, data, diff);
@@ -108,13 +108,13 @@ static int lfs2_bd_read(lfs2_t *lfs2,
         rcache->block = block;
         rcache->off = lfs2_aligndown(off, lfs2->cfg->read_size);
         rcache->size = lfs2_min(
-                lfs2_min(
-                    lfs2_alignup(off+hint, lfs2->cfg->read_size),
-                    lfs2->cfg->block_size)
-                - rcache->off,
-                lfs2->cfg->cache_size);
+            lfs2_min(
+                lfs2_alignup(off + hint, lfs2->cfg->read_size),
+                lfs2->cfg->block_size)
+            - rcache->off,
+            lfs2->cfg->cache_size);
         int err = lfs2->cfg->read(lfs2->cfg, rcache->block,
-                rcache->off, rcache->buffer, rcache->size);
+            rcache->off, rcache->buffer, rcache->size);
         LFS2_ASSERT(err <= 0);
         if (err) {
             return err;
@@ -125,19 +125,19 @@ static int lfs2_bd_read(lfs2_t *lfs2,
 }
 
 static int lfs2_bd_cmp(lfs2_t *lfs2,
-        const lfs2_cache_t *pcache, lfs2_cache_t *rcache, lfs2_size_t hint,
-        lfs2_block_t block, lfs2_off_t off,
-        const void *buffer, lfs2_size_t size) {
+    const lfs2_cache_t *pcache, lfs2_cache_t *rcache, lfs2_size_t hint,
+    lfs2_block_t block, lfs2_off_t off,
+    const void *buffer, lfs2_size_t size) {
     const uint8_t *data = buffer;
     lfs2_size_t diff = 0;
 
     for (lfs2_off_t i = 0; i < size; i += diff) {
         uint8_t dat[8];
 
-        diff = lfs2_min(size-i, sizeof(dat));
+        diff = lfs2_min(size - i, sizeof(dat));
         int res = lfs2_bd_read(lfs2,
-                pcache, rcache, hint-i,
-                block, off+i, &dat, diff);
+            pcache, rcache, hint - i,
+            block, off + i, &dat, diff);
         if (res) {
             return res;
         }
@@ -153,12 +153,12 @@ static int lfs2_bd_cmp(lfs2_t *lfs2,
 
 #ifndef LFS2_READONLY
 static int lfs2_bd_flush(lfs2_t *lfs2,
-        lfs2_cache_t *pcache, lfs2_cache_t *rcache, bool validate) {
+    lfs2_cache_t *pcache, lfs2_cache_t *rcache, bool validate) {
     if (pcache->block != LFS2_BLOCK_NULL && pcache->block != LFS2_BLOCK_INLINE) {
         LFS2_ASSERT(pcache->block < lfs2->cfg->block_count);
         lfs2_size_t diff = lfs2_alignup(pcache->size, lfs2->cfg->prog_size);
         int err = lfs2->cfg->prog(lfs2->cfg, pcache->block,
-                pcache->off, pcache->buffer, diff);
+            pcache->off, pcache->buffer, diff);
         LFS2_ASSERT(err <= 0);
         if (err) {
             return err;
@@ -168,8 +168,8 @@ static int lfs2_bd_flush(lfs2_t *lfs2,
             // check data on disk
             lfs2_cache_drop(lfs2, rcache);
             int res = lfs2_bd_cmp(lfs2,
-                    NULL, rcache, diff,
-                    pcache->block, pcache->off, pcache->buffer, diff);
+                NULL, rcache, diff,
+                pcache->block, pcache->off, pcache->buffer, diff);
             if (res < 0) {
                 return res;
             }
@@ -188,7 +188,7 @@ static int lfs2_bd_flush(lfs2_t *lfs2,
 
 #ifndef LFS2_READONLY
 static int lfs2_bd_sync(lfs2_t *lfs2,
-        lfs2_cache_t *pcache, lfs2_cache_t *rcache, bool validate) {
+    lfs2_cache_t *pcache, lfs2_cache_t *rcache, bool validate) {
     lfs2_cache_drop(lfs2, rcache);
 
     int err = lfs2_bd_flush(lfs2, pcache, rcache, validate);
@@ -204,21 +204,21 @@ static int lfs2_bd_sync(lfs2_t *lfs2,
 
 #ifndef LFS2_READONLY
 static int lfs2_bd_prog(lfs2_t *lfs2,
-        lfs2_cache_t *pcache, lfs2_cache_t *rcache, bool validate,
-        lfs2_block_t block, lfs2_off_t off,
-        const void *buffer, lfs2_size_t size) {
+    lfs2_cache_t *pcache, lfs2_cache_t *rcache, bool validate,
+    lfs2_block_t block, lfs2_off_t off,
+    const void *buffer, lfs2_size_t size) {
     const uint8_t *data = buffer;
     LFS2_ASSERT(block == LFS2_BLOCK_INLINE || block < lfs2->cfg->block_count);
     LFS2_ASSERT(off + size <= lfs2->cfg->block_size);
 
     while (size > 0) {
         if (block == pcache->block &&
-                off >= pcache->off &&
-                off < pcache->off + lfs2->cfg->cache_size) {
+            off >= pcache->off &&
+            off < pcache->off + lfs2->cfg->cache_size) {
             // already fits in pcache?
             lfs2_size_t diff = lfs2_min(size,
-                    lfs2->cfg->cache_size - (off-pcache->off));
-            memcpy(&pcache->buffer[off-pcache->off], data, diff);
+                lfs2->cfg->cache_size - (off - pcache->off));
+            memcpy(&pcache->buffer[off - pcache->off], data, diff);
 
             data += diff;
             off += diff;
@@ -273,16 +273,16 @@ static inline bool lfs2_pair_isnull(const lfs2_block_t pair[2]) {
 }
 
 static inline int lfs2_pair_cmp(
-        const lfs2_block_t paira[2],
-        const lfs2_block_t pairb[2]) {
+    const lfs2_block_t paira[2],
+    const lfs2_block_t pairb[2]) {
     return !(paira[0] == pairb[0] || paira[1] == pairb[1] ||
-             paira[0] == pairb[1] || paira[1] == pairb[0]);
+        paira[0] == pairb[1] || paira[1] == pairb[0]);
 }
 
 #ifndef LFS2_READONLY
 static inline bool lfs2_pair_sync(
-        const lfs2_block_t paira[2],
-        const lfs2_block_t pairb[2]) {
+    const lfs2_block_t paira[2],
+    const lfs2_block_t pairb[2]) {
     return (paira[0] == pairb[0] && paira[1] == pairb[1]) ||
            (paira[0] == pairb[1] && paira[1] == pairb[0]);
 }
@@ -361,19 +361,19 @@ struct lfs2_diskoff {
 };
 
 #define LFS2_MKATTRS(...) \
-    (struct lfs2_mattr[]){__VA_ARGS__}, \
-    sizeof((struct lfs2_mattr[]){__VA_ARGS__}) / sizeof(struct lfs2_mattr)
+    (struct lfs2_mattr[]) {__VA_ARGS__}, \
+    sizeof((struct lfs2_mattr[]) {__VA_ARGS__}) / sizeof(struct lfs2_mattr)
 
 // operations on global state
 static inline void lfs2_gstate_xor(lfs2_gstate_t *a, const lfs2_gstate_t *b) {
     for (int i = 0; i < 3; i++) {
-        ((uint32_t*)a)[i] ^= ((const uint32_t*)b)[i];
+        ((uint32_t *)a)[i] ^= ((const uint32_t *)b)[i];
     }
 }
 
 static inline bool lfs2_gstate_iszero(const lfs2_gstate_t *a) {
     for (int i = 0; i < 3; i++) {
-        if (((uint32_t*)a)[i] != 0) {
+        if (((uint32_t *)a)[i] != 0) {
             return false;
         }
     }
@@ -395,19 +395,19 @@ static inline bool lfs2_gstate_hasmove(const lfs2_gstate_t *a) {
 #endif
 
 static inline bool lfs2_gstate_hasmovehere(const lfs2_gstate_t *a,
-        const lfs2_block_t *pair) {
+    const lfs2_block_t *pair) {
     return lfs2_tag_type1(a->tag) && lfs2_pair_cmp(a->pair, pair) == 0;
 }
 
 static inline void lfs2_gstate_fromle32(lfs2_gstate_t *a) {
-    a->tag     = lfs2_fromle32(a->tag);
+    a->tag = lfs2_fromle32(a->tag);
     a->pair[0] = lfs2_fromle32(a->pair[0]);
     a->pair[1] = lfs2_fromle32(a->pair[1]);
 }
 
 #ifndef LFS2_READONLY
 static inline void lfs2_gstate_tole32(lfs2_gstate_t *a) {
-    a->tag     = lfs2_tole32(a->tag);
+    a->tag = lfs2_tole32(a->tag);
     a->pair[0] = lfs2_tole32(a->pair[0]);
     a->pair[1] = lfs2_tole32(a->pair[1]);
 }
@@ -427,30 +427,30 @@ static void lfs2_ctz_tole32(struct lfs2_ctz *ctz) {
 #endif
 
 static inline void lfs2_superblock_fromle32(lfs2_superblock_t *superblock) {
-    superblock->version     = lfs2_fromle32(superblock->version);
-    superblock->block_size  = lfs2_fromle32(superblock->block_size);
+    superblock->version = lfs2_fromle32(superblock->version);
+    superblock->block_size = lfs2_fromle32(superblock->block_size);
     superblock->block_count = lfs2_fromle32(superblock->block_count);
-    superblock->name_max    = lfs2_fromle32(superblock->name_max);
-    superblock->file_max    = lfs2_fromle32(superblock->file_max);
-    superblock->attr_max    = lfs2_fromle32(superblock->attr_max);
+    superblock->name_max = lfs2_fromle32(superblock->name_max);
+    superblock->file_max = lfs2_fromle32(superblock->file_max);
+    superblock->attr_max = lfs2_fromle32(superblock->attr_max);
 }
 
 #ifndef LFS2_READONLY
 static inline void lfs2_superblock_tole32(lfs2_superblock_t *superblock) {
-    superblock->version     = lfs2_tole32(superblock->version);
-    superblock->block_size  = lfs2_tole32(superblock->block_size);
+    superblock->version = lfs2_tole32(superblock->version);
+    superblock->block_size = lfs2_tole32(superblock->block_size);
     superblock->block_count = lfs2_tole32(superblock->block_count);
-    superblock->name_max    = lfs2_tole32(superblock->name_max);
-    superblock->file_max    = lfs2_tole32(superblock->file_max);
-    superblock->attr_max    = lfs2_tole32(superblock->attr_max);
+    superblock->name_max = lfs2_tole32(superblock->name_max);
+    superblock->file_max = lfs2_tole32(superblock->file_max);
+    superblock->attr_max = lfs2_tole32(superblock->attr_max);
 }
 #endif
 
 #ifndef LFS2_NO_ASSERT
 static bool lfs2_mlist_isopen(struct lfs2_mlist *head,
-        struct lfs2_mlist *node) {
+    struct lfs2_mlist *node) {
     for (struct lfs2_mlist **p = &head; *p; p = &(*p)->next) {
-        if (*p == (struct lfs2_mlist*)node) {
+        if (*p == (struct lfs2_mlist *)node) {
             return true;
         }
     }
@@ -477,14 +477,14 @@ static void lfs2_mlist_append(lfs2_t *lfs2, struct lfs2_mlist *mlist) {
 /// Internal operations predeclared here ///
 #ifndef LFS2_READONLY
 static int lfs2_dir_commit(lfs2_t *lfs2, lfs2_mdir_t *dir,
-        const struct lfs2_mattr *attrs, int attrcount);
+    const struct lfs2_mattr *attrs, int attrcount);
 static int lfs2_dir_compact(lfs2_t *lfs2,
-        lfs2_mdir_t *dir, const struct lfs2_mattr *attrs, int attrcount,
-        lfs2_mdir_t *source, uint16_t begin, uint16_t end);
+    lfs2_mdir_t *dir, const struct lfs2_mattr *attrs, int attrcount,
+    lfs2_mdir_t *source, uint16_t begin, uint16_t end);
 static lfs2_ssize_t lfs2_file_flushedwrite(lfs2_t *lfs2, lfs2_file_t *file,
-        const void *buffer, lfs2_size_t size);
+    const void *buffer, lfs2_size_t size);
 static lfs2_ssize_t lfs2_file_rawwrite(lfs2_t *lfs2, lfs2_file_t *file,
-        const void *buffer, lfs2_size_t size);
+    const void *buffer, lfs2_size_t size);
 static int lfs2_file_rawsync(lfs2_t *lfs2, lfs2_file_t *file);
 static int lfs2_file_outline(lfs2_t *lfs2, lfs2_file_t *file);
 static int lfs2_file_flush(lfs2_t *lfs2, lfs2_file_t *file);
@@ -492,32 +492,32 @@ static int lfs2_file_flush(lfs2_t *lfs2, lfs2_file_t *file);
 static int lfs2_fs_deorphan(lfs2_t *lfs2, bool powerloss);
 static int lfs2_fs_preporphans(lfs2_t *lfs2, int8_t orphans);
 static void lfs2_fs_prepmove(lfs2_t *lfs2,
-        uint16_t id, const lfs2_block_t pair[2]);
+    uint16_t id, const lfs2_block_t pair[2]);
 static int lfs2_fs_pred(lfs2_t *lfs2, const lfs2_block_t dir[2],
-        lfs2_mdir_t *pdir);
+    lfs2_mdir_t *pdir);
 static lfs2_stag_t lfs2_fs_parent(lfs2_t *lfs2, const lfs2_block_t dir[2],
-        lfs2_mdir_t *parent);
+    lfs2_mdir_t *parent);
 static int lfs2_fs_forceconsistency(lfs2_t *lfs2);
 #endif
 
 #ifdef LFS2_MIGRATE
 static int lfs21_traverse(lfs2_t *lfs2,
-        int (*cb)(void*, lfs2_block_t), void *data);
+    int (*cb)(void *, lfs2_block_t), void *data);
 #endif
 
 static int lfs2_dir_rawrewind(lfs2_t *lfs2, lfs2_dir_t *dir);
 
 static lfs2_ssize_t lfs2_file_flushedread(lfs2_t *lfs2, lfs2_file_t *file,
-        void *buffer, lfs2_size_t size);
+    void *buffer, lfs2_size_t size);
 static lfs2_ssize_t lfs2_file_rawread(lfs2_t *lfs2, lfs2_file_t *file,
-        void *buffer, lfs2_size_t size);
+    void *buffer, lfs2_size_t size);
 static int lfs2_file_rawclose(lfs2_t *lfs2, lfs2_file_t *file);
 static lfs2_soff_t lfs2_file_rawsize(lfs2_t *lfs2, lfs2_file_t *file);
 
 static lfs2_ssize_t lfs2_fs_rawsize(lfs2_t *lfs2);
 static int lfs2_fs_rawtraverse(lfs2_t *lfs2,
-        int (*cb)(void *data, lfs2_block_t block), void *data,
-        bool includeorphans);
+    int (*cb)(void *data, lfs2_block_t block), void *data,
+    bool includeorphans);
 
 static int lfs2_deinit(lfs2_t *lfs2);
 static int lfs2_rawunmount(lfs2_t *lfs2);
@@ -526,9 +526,9 @@ static int lfs2_rawunmount(lfs2_t *lfs2);
 /// Block allocator ///
 #ifndef LFS2_READONLY
 static int lfs2_alloc_lookahead(void *p, lfs2_block_t block) {
-    lfs2_t *lfs2 = (lfs2_t*)p;
+    lfs2_t *lfs2 = (lfs2_t *)p;
     lfs2_block_t off = ((block - lfs2->free.off)
-            + lfs2->cfg->block_count) % lfs2->cfg->block_count;
+        + lfs2->cfg->block_count) % lfs2->cfg->block_count;
 
     if (off < lfs2->free.size) {
         lfs2->free.buffer[off / 32] |= 1U << (off % 32);
@@ -568,8 +568,8 @@ static int lfs2_alloc(lfs2_t *lfs2, lfs2_block_t *block) {
                 // eagerly find next off so an alloc ack can
                 // discredit old lookahead blocks
                 while (lfs2->free.i != lfs2->free.size &&
-                        (lfs2->free.buffer[lfs2->free.i / 32]
-                            & (1U << (lfs2->free.i % 32)))) {
+                       (lfs2->free.buffer[lfs2->free.i / 32]
+                        & (1U << (lfs2->free.i % 32)))) {
                     lfs2->free.i += 1;
                     lfs2->free.ack -= 1;
                 }
@@ -580,14 +580,14 @@ static int lfs2_alloc(lfs2_t *lfs2, lfs2_block_t *block) {
 
         // check if we have looked at all blocks since last ack
         if (lfs2->free.ack == 0) {
-            LFS2_ERROR("No more free space %"PRIu32,
-                    lfs2->free.i + lfs2->free.off);
+            LFS2_ERROR("No more free space %" PRIu32,
+                lfs2->free.i + lfs2->free.off);
             return LFS2_ERR_NOSPC;
         }
 
         lfs2->free.off = (lfs2->free.off + lfs2->free.size)
-                % lfs2->cfg->block_count;
-        lfs2->free.size = lfs2_min(8*lfs2->cfg->lookahead_size, lfs2->free.ack);
+            % lfs2->cfg->block_count;
+        lfs2->free.size = lfs2_min(8 * lfs2->cfg->lookahead_size, lfs2->free.ack);
         lfs2->free.i = 0;
 
         // find mask of free blocks from tree
@@ -603,15 +603,15 @@ static int lfs2_alloc(lfs2_t *lfs2, lfs2_block_t *block) {
 
 /// Metadata pair and directory operations ///
 static lfs2_stag_t lfs2_dir_getslice(lfs2_t *lfs2, const lfs2_mdir_t *dir,
-        lfs2_tag_t gmask, lfs2_tag_t gtag,
-        lfs2_off_t goff, void *gbuffer, lfs2_size_t gsize) {
+    lfs2_tag_t gmask, lfs2_tag_t gtag,
+    lfs2_off_t goff, void *gbuffer, lfs2_size_t gsize) {
     lfs2_off_t off = dir->off;
     lfs2_tag_t ntag = dir->etag;
     lfs2_stag_t gdiff = 0;
 
     if (lfs2_gstate_hasmovehere(&lfs2->gdisk, dir->pair) &&
-            lfs2_tag_id(gmask) != 0 &&
-            lfs2_tag_id(lfs2->gdisk.tag) <= lfs2_tag_id(gtag)) {
+        lfs2_tag_id(gmask) != 0 &&
+        lfs2_tag_id(lfs2->gdisk.tag) <= lfs2_tag_id(gtag)) {
         // synthetic moves
         gdiff -= LFS2_MKTAG(0, 1, 0);
     }
@@ -621,8 +621,8 @@ static lfs2_stag_t lfs2_dir_getslice(lfs2_t *lfs2, const lfs2_mdir_t *dir,
         off -= lfs2_tag_dsize(ntag);
         lfs2_tag_t tag = ntag;
         int err = lfs2_bd_read(lfs2,
-                NULL, &lfs2->rcache, sizeof(ntag),
-                dir->pair[0], off, &ntag, sizeof(ntag));
+            NULL, &lfs2->rcache, sizeof(ntag),
+            dir->pair[0], off, &ntag, sizeof(ntag));
         if (err) {
             return err;
         }
@@ -630,10 +630,10 @@ static lfs2_stag_t lfs2_dir_getslice(lfs2_t *lfs2, const lfs2_mdir_t *dir,
         ntag = (lfs2_frombe32(ntag) ^ tag) & 0x7fffffff;
 
         if (lfs2_tag_id(gmask) != 0 &&
-                lfs2_tag_type1(tag) == LFS2_TYPE_SPLICE &&
-                lfs2_tag_id(tag) <= lfs2_tag_id(gtag - gdiff)) {
+            lfs2_tag_type1(tag) == LFS2_TYPE_SPLICE &&
+            lfs2_tag_id(tag) <= lfs2_tag_id(gtag - gdiff)) {
             if (tag == (LFS2_MKTAG(LFS2_TYPE_CREATE, 0, 0) |
-                    (LFS2_MKTAG(0, 0x3ff, 0) & (gtag - gdiff)))) {
+                        (LFS2_MKTAG(0, 0x3ff, 0) & (gtag - gdiff)))) {
                 // found where we were created
                 return LFS2_ERR_NOENT;
             }
@@ -649,13 +649,13 @@ static lfs2_stag_t lfs2_dir_getslice(lfs2_t *lfs2, const lfs2_mdir_t *dir,
 
             lfs2_size_t diff = lfs2_min(lfs2_tag_size(tag), gsize);
             err = lfs2_bd_read(lfs2,
-                    NULL, &lfs2->rcache, diff,
-                    dir->pair[0], off+sizeof(tag)+goff, gbuffer, diff);
+                NULL, &lfs2->rcache, diff,
+                dir->pair[0], off + sizeof(tag) + goff, gbuffer, diff);
             if (err) {
                 return err;
             }
 
-            memset((uint8_t*)gbuffer + diff, 0, gsize - diff);
+            memset((uint8_t *)gbuffer + diff, 0, gsize - diff);
 
             return tag + gdiff;
         }
@@ -665,18 +665,18 @@ static lfs2_stag_t lfs2_dir_getslice(lfs2_t *lfs2, const lfs2_mdir_t *dir,
 }
 
 static lfs2_stag_t lfs2_dir_get(lfs2_t *lfs2, const lfs2_mdir_t *dir,
-        lfs2_tag_t gmask, lfs2_tag_t gtag, void *buffer) {
+    lfs2_tag_t gmask, lfs2_tag_t gtag, void *buffer) {
     return lfs2_dir_getslice(lfs2, dir,
-            gmask, gtag,
-            0, buffer, lfs2_tag_size(gtag));
+        gmask, gtag,
+        0, buffer, lfs2_tag_size(gtag));
 }
 
 static int lfs2_dir_getread(lfs2_t *lfs2, const lfs2_mdir_t *dir,
-        const lfs2_cache_t *pcache, lfs2_cache_t *rcache, lfs2_size_t hint,
-        lfs2_tag_t gmask, lfs2_tag_t gtag,
-        lfs2_off_t off, void *buffer, lfs2_size_t size) {
+    const lfs2_cache_t *pcache, lfs2_cache_t *rcache, lfs2_size_t hint,
+    lfs2_tag_t gmask, lfs2_tag_t gtag,
+    lfs2_off_t off, void *buffer, lfs2_size_t size) {
     uint8_t *data = buffer;
-    if (off+size > lfs2->cfg->block_size) {
+    if (off + size > lfs2->cfg->block_size) {
         return LFS2_ERR_CORRUPT;
     }
 
@@ -684,11 +684,11 @@ static int lfs2_dir_getread(lfs2_t *lfs2, const lfs2_mdir_t *dir,
         lfs2_size_t diff = size;
 
         if (pcache && pcache->block == LFS2_BLOCK_INLINE &&
-                off < pcache->off + pcache->size) {
+            off < pcache->off + pcache->size) {
             if (off >= pcache->off) {
                 // is already in pcache?
-                diff = lfs2_min(diff, pcache->size - (off-pcache->off));
-                memcpy(data, &pcache->buffer[off-pcache->off], diff);
+                diff = lfs2_min(diff, pcache->size - (off - pcache->off));
+                memcpy(data, &pcache->buffer[off - pcache->off], diff);
 
                 data += diff;
                 off += diff;
@@ -697,15 +697,15 @@ static int lfs2_dir_getread(lfs2_t *lfs2, const lfs2_mdir_t *dir,
             }
 
             // pcache takes priority
-            diff = lfs2_min(diff, pcache->off-off);
+            diff = lfs2_min(diff, pcache->off - off);
         }
 
         if (rcache->block == LFS2_BLOCK_INLINE &&
-                off < rcache->off + rcache->size) {
+            off < rcache->off + rcache->size) {
             if (off >= rcache->off) {
                 // is already in rcache?
-                diff = lfs2_min(diff, rcache->size - (off-rcache->off));
-                memcpy(data, &rcache->buffer[off-rcache->off], diff);
+                diff = lfs2_min(diff, rcache->size - (off - rcache->off));
+                memcpy(data, &rcache->buffer[off - rcache->off], diff);
 
                 data += diff;
                 off += diff;
@@ -714,16 +714,16 @@ static int lfs2_dir_getread(lfs2_t *lfs2, const lfs2_mdir_t *dir,
             }
 
             // rcache takes priority
-            diff = lfs2_min(diff, rcache->off-off);
+            diff = lfs2_min(diff, rcache->off - off);
         }
 
         // load to cache, first condition can no longer fail
         rcache->block = LFS2_BLOCK_INLINE;
         rcache->off = lfs2_aligndown(off, lfs2->cfg->read_size);
-        rcache->size = lfs2_min(lfs2_alignup(off+hint, lfs2->cfg->read_size),
-                lfs2->cfg->cache_size);
+        rcache->size = lfs2_min(lfs2_alignup(off + hint, lfs2->cfg->read_size),
+            lfs2->cfg->cache_size);
         int err = lfs2_dir_getslice(lfs2, dir, gmask, gtag,
-                rcache->off, rcache->buffer, rcache->size);
+            rcache->off, rcache->buffer, rcache->size);
         if (err < 0) {
             return err;
         }
@@ -734,7 +734,7 @@ static int lfs2_dir_getread(lfs2_t *lfs2, const lfs2_mdir_t *dir,
 
 #ifndef LFS2_READONLY
 static int lfs2_dir_traverse_filter(void *p,
-        lfs2_tag_t tag, const void *buffer) {
+    lfs2_tag_t tag, const void *buffer) {
     lfs2_tag_t *filtertag = p;
     (void)buffer;
 
@@ -745,17 +745,17 @@ static int lfs2_dir_traverse_filter(void *p,
 
     // check for redundancy
     if ((mask & tag) == (mask & *filtertag) ||
-            lfs2_tag_isdelete(*filtertag) ||
-            (LFS2_MKTAG(0x7ff, 0x3ff, 0) & tag) == (
-                LFS2_MKTAG(LFS2_TYPE_DELETE, 0, 0) |
-                    (LFS2_MKTAG(0, 0x3ff, 0) & *filtertag))) {
+        lfs2_tag_isdelete(*filtertag) ||
+        (LFS2_MKTAG(0x7ff, 0x3ff, 0) & tag) == (
+            LFS2_MKTAG(LFS2_TYPE_DELETE, 0, 0) |
+            (LFS2_MKTAG(0, 0x3ff, 0) & *filtertag))) {
         *filtertag = LFS2_MKTAG(LFS2_FROM_NOOP, 0, 0);
         return true;
     }
 
     // check if we need to adjust for created/deleted tags
     if (lfs2_tag_type1(tag) == LFS2_TYPE_SPLICE &&
-            lfs2_tag_id(tag) <= lfs2_tag_id(*filtertag)) {
+        lfs2_tag_id(tag) <= lfs2_tag_id(*filtertag)) {
         *filtertag += LFS2_MKTAG(0, lfs2_tag_splice(tag), 0);
     }
 
@@ -794,14 +794,14 @@ struct lfs2_dir_traverse {
 };
 
 static int lfs2_dir_traverse(lfs2_t *lfs2,
-        const lfs2_mdir_t *dir, lfs2_off_t off, lfs2_tag_t ptag,
-        const struct lfs2_mattr *attrs, int attrcount,
-        lfs2_tag_t tmask, lfs2_tag_t ttag,
-        uint16_t begin, uint16_t end, int16_t diff,
-        int (*cb)(void *data, lfs2_tag_t tag, const void *buffer), void *data) {
+    const lfs2_mdir_t *dir, lfs2_off_t off, lfs2_tag_t ptag,
+    const struct lfs2_mattr *attrs, int attrcount,
+    lfs2_tag_t tmask, lfs2_tag_t ttag,
+    uint16_t begin, uint16_t end, int16_t diff,
+    int (*cb)(void *data, lfs2_tag_t tag, const void *buffer), void *data) {
     // This function in inherently recursive, but bounded. To allow tool-based
     // analysis without unnecessary code-cost we use an explicit stack
-    struct lfs2_dir_traverse stack[LFS2_DIR_TRAVERSE_DEPTH-1];
+    struct lfs2_dir_traverse stack[LFS2_DIR_TRAVERSE_DEPTH - 1];
     unsigned sp = 0;
     int res;
 
@@ -811,18 +811,18 @@ static int lfs2_dir_traverse(lfs2_t *lfs2,
     struct lfs2_diskoff disk;
     while (true) {
         {
-            if (off+lfs2_tag_dsize(ptag) < dir->off) {
+            if (off + lfs2_tag_dsize(ptag) < dir->off) {
                 off += lfs2_tag_dsize(ptag);
                 int err = lfs2_bd_read(lfs2,
-                        NULL, &lfs2->rcache, sizeof(tag),
-                        dir->pair[0], off, &tag, sizeof(tag));
+                    NULL, &lfs2->rcache, sizeof(tag),
+                    dir->pair[0], off, &tag, sizeof(tag));
                 if (err) {
                     return err;
                 }
 
                 tag = (lfs2_frombe32(tag) ^ ptag) | 0x80000000;
                 disk.block = dir->pair[0];
-                disk.off = off+sizeof(lfs2_tag_t);
+                disk.off = off + sizeof(lfs2_tag_t);
                 buffer = &disk;
                 ptag = tag;
             } else if (attrcount > 0) {
@@ -846,22 +846,22 @@ static int lfs2_dir_traverse(lfs2_t *lfs2,
                 LFS2_ASSERT(sp < LFS2_DIR_TRAVERSE_DEPTH);
                 // recurse, scan for duplicates, and update tag based on
                 // creates/deletes
-                stack[sp] = (struct lfs2_dir_traverse){
-                    .dir        = dir,
-                    .off        = off,
-                    .ptag       = ptag,
-                    .attrs      = attrs,
-                    .attrcount  = attrcount,
-                    .tmask      = tmask,
-                    .ttag       = ttag,
-                    .begin      = begin,
-                    .end        = end,
-                    .diff       = diff,
-                    .cb         = cb,
-                    .data       = data,
-                    .tag        = tag,
-                    .buffer     = buffer,
-                    .disk       = disk,
+                stack[sp] = (struct lfs2_dir_traverse) {
+                    .dir = dir,
+                    .off = off,
+                    .ptag = ptag,
+                    .attrs = attrs,
+                    .attrcount = attrcount,
+                    .tmask = tmask,
+                    .ttag = ttag,
+                    .begin = begin,
+                    .end = end,
+                    .diff = diff,
+                    .cb = cb,
+                    .data = data,
+                    .tag = tag,
+                    .buffer = buffer,
+                    .disk = disk,
                 };
                 sp += 1;
 
@@ -871,15 +871,15 @@ static int lfs2_dir_traverse(lfs2_t *lfs2,
                 end = 0;
                 diff = 0;
                 cb = lfs2_dir_traverse_filter;
-                data = &stack[sp-1].tag;
+                data = &stack[sp - 1].tag;
                 continue;
             }
         }
 
-popped:
+    popped:
         // in filter range?
         if (lfs2_tag_id(tmask) != 0 &&
-                !(lfs2_tag_id(tag) >= begin && lfs2_tag_id(tag) < end)) {
+            !(lfs2_tag_id(tag) >= begin && lfs2_tag_id(tag) < end)) {
             continue;
         }
 
@@ -908,20 +908,20 @@ static int lfs2_dir_traverse(lfs2_t *lfs2,
             }
 
             // recurse into move
-            stack[sp] = (struct lfs2_dir_traverse){
-                .dir        = dir,
-                .off        = off,
-                .ptag       = ptag,
-                .attrs      = attrs,
-                .attrcount  = attrcount,
-                .tmask      = tmask,
-                .ttag       = ttag,
-                .begin      = begin,
-                .end        = end,
-                .diff       = diff,
-                .cb         = cb,
-                .data       = data,
-                .tag        = LFS2_MKTAG(LFS2_FROM_NOOP, 0, 0),
+            stack[sp] = (struct lfs2_dir_traverse) {
+                .dir = dir,
+                .off = off,
+                .ptag = ptag,
+                .attrs = attrs,
+                .attrcount = attrcount,
+                .tmask = tmask,
+                .ttag = ttag,
+                .begin = begin,
+                .end = end,
+                .diff = diff,
+                .cb = cb,
+                .data = data,
+                .tag = LFS2_MKTAG(LFS2_FROM_NOOP, 0, 0),
             };
             sp += 1;
 
@@ -935,13 +935,13 @@ static int lfs2_dir_traverse(lfs2_t *lfs2,
             tmask = LFS2_MKTAG(0x600, 0x3ff, 0);
             ttag = LFS2_MKTAG(LFS2_TYPE_STRUCT, 0, 0);
             begin = fromid;
-            end = fromid+1;
-            diff = toid-fromid+diff;
+            end = fromid + 1;
+            diff = toid - fromid + diff;
         } else if (lfs2_tag_type3(tag) == LFS2_FROM_USERATTRS) {
             for (unsigned i = 0; i < lfs2_tag_size(tag); i++) {
                 const struct lfs2_attr *a = buffer;
                 res = cb(data, LFS2_MKTAG(LFS2_TYPE_USERATTR + a[i].type,
-                        lfs2_tag_id(tag) + diff, a[i].size), a[i].buffer);
+                    lfs2_tag_id(tag) + diff, a[i].size), a[i].buffer);
                 if (res < 0) {
                     return res;
                 }
@@ -965,21 +965,21 @@ static int lfs2_dir_traverse(lfs2_t *lfs2,
     if (sp > 0) {
         // pop from the stack and return, fortunately all pops share
         // a destination
-        dir         = stack[sp-1].dir;
-        off         = stack[sp-1].off;
-        ptag        = stack[sp-1].ptag;
-        attrs       = stack[sp-1].attrs;
-        attrcount   = stack[sp-1].attrcount;
-        tmask       = stack[sp-1].tmask;
-        ttag        = stack[sp-1].ttag;
-        begin       = stack[sp-1].begin;
-        end         = stack[sp-1].end;
-        diff        = stack[sp-1].diff;
-        cb          = stack[sp-1].cb;
-        data        = stack[sp-1].data;
-        tag         = stack[sp-1].tag;
-        buffer      = stack[sp-1].buffer;
-        disk        = stack[sp-1].disk;
+        dir = stack[sp - 1].dir;
+        off = stack[sp - 1].off;
+        ptag = stack[sp - 1].ptag;
+        attrs = stack[sp - 1].attrs;
+        attrcount = stack[sp - 1].attrcount;
+        tmask = stack[sp - 1].tmask;
+        ttag = stack[sp - 1].ttag;
+        begin = stack[sp - 1].begin;
+        end = stack[sp - 1].end;
+        diff = stack[sp - 1].diff;
+        cb = stack[sp - 1].cb;
+        data = stack[sp - 1].data;
+        tag = stack[sp - 1].tag;
+        buffer = stack[sp - 1].buffer;
+        disk = stack[sp - 1].disk;
         sp -= 1;
         goto popped;
     } else {
@@ -989,9 +989,9 @@ static int lfs2_dir_traverse(lfs2_t *lfs2,
 #endif
 
 static lfs2_stag_t lfs2_dir_fetchmatch(lfs2_t *lfs2,
-        lfs2_mdir_t *dir, const lfs2_block_t pair[2],
-        lfs2_tag_t fmask, lfs2_tag_t ftag, uint16_t *id,
-        int (*cb)(void *data, lfs2_tag_t tag, const void *buffer), void *data) {
+    lfs2_mdir_t *dir, const lfs2_block_t pair[2],
+    lfs2_tag_t fmask, lfs2_tag_t ftag, uint16_t *id,
+    int (*cb)(void *data, lfs2_tag_t tag, const void *buffer), void *data) {
     // we can find tag very efficiently during a fetch, since we're already
     // scanning the entire directory
     lfs2_stag_t besttag = -1;
@@ -1007,22 +1007,22 @@ static lfs2_stag_t lfs2_dir_fetchmatch(lfs2_t *lfs2,
     int r = 0;
     for (int i = 0; i < 2; i++) {
         int err = lfs2_bd_read(lfs2,
-                NULL, &lfs2->rcache, sizeof(revs[i]),
-                pair[i], 0, &revs[i], sizeof(revs[i]));
+            NULL, &lfs2->rcache, sizeof(revs[i]),
+            pair[i], 0, &revs[i], sizeof(revs[i]));
         revs[i] = lfs2_fromle32(revs[i]);
         if (err && err != LFS2_ERR_CORRUPT) {
             return err;
         }
 
         if (err != LFS2_ERR_CORRUPT &&
-                lfs2_scmp(revs[i], revs[(i+1)%2]) > 0) {
+            lfs2_scmp(revs[i], revs[(i + 1) % 2]) > 0) {
             r = i;
         }
     }
 
-    dir->pair[0] = pair[(r+0)%2];
-    dir->pair[1] = pair[(r+1)%2];
-    dir->rev = revs[(r+0)%2];
+    dir->pair[0] = pair[(r + 0) % 2];
+    dir->pair[1] = pair[(r + 1) % 2];
+    dir->rev = revs[(r + 0) % 2];
     dir->off = 0; // nonzero = found some commits
 
     // now scan tags to fetch the actual dir and find possible match
@@ -1044,8 +1044,8 @@ static lfs2_stag_t lfs2_dir_fetchmatch(lfs2_t *lfs2,
             lfs2_tag_t tag;
             off += lfs2_tag_dsize(ptag);
             int err = lfs2_bd_read(lfs2,
-                    NULL, &lfs2->rcache, lfs2->cfg->block_size,
-                    dir->pair[0], off, &tag, sizeof(tag));
+                NULL, &lfs2->rcache, lfs2->cfg->block_size,
+                dir->pair[0], off, &tag, sizeof(tag));
             if (err) {
                 if (err == LFS2_ERR_CORRUPT) {
                     // can't continue?
@@ -1061,7 +1061,7 @@ static lfs2_stag_t lfs2_dir_fetchmatch(lfs2_t *lfs2,
             // next commit not yet programmed or we're not in valid range
             if (!lfs2_tag_isvalid(tag)) {
                 dir->erased = (lfs2_tag_type1(ptag) == LFS2_TYPE_CRC &&
-                        dir->off % lfs2->cfg->prog_size == 0);
+                    dir->off % lfs2->cfg->prog_size == 0);
                 break;
             } else if (off + lfs2_tag_dsize(tag) > lfs2->cfg->block_size) {
                 dir->erased = false;
@@ -1074,8 +1074,8 @@ static lfs2_stag_t lfs2_dir_fetchmatch(lfs2_t *lfs2,
                 // check the crc attr
                 uint32_t dcrc;
                 err = lfs2_bd_read(lfs2,
-                        NULL, &lfs2->rcache, lfs2->cfg->block_size,
-                        dir->pair[0], off+sizeof(tag), &dcrc, sizeof(dcrc));
+                    NULL, &lfs2->rcache, lfs2->cfg->block_size,
+                    dir->pair[0], off + sizeof(tag), &dcrc, sizeof(dcrc));
                 if (err) {
                     if (err == LFS2_ERR_CORRUPT) {
                         dir->erased = false;
@@ -1117,8 +1117,8 @@ static lfs2_stag_t lfs2_dir_fetchmatch(lfs2_t *lfs2,
             for (lfs2_off_t j = sizeof(tag); j < lfs2_tag_dsize(tag); j++) {
                 uint8_t dat;
                 err = lfs2_bd_read(lfs2,
-                        NULL, &lfs2->rcache, lfs2->cfg->block_size,
-                        dir->pair[0], off+j, &dat, 1);
+                    NULL, &lfs2->rcache, lfs2->cfg->block_size,
+                    dir->pair[0], off + j, &dat, 1);
                 if (err) {
                     if (err == LFS2_ERR_CORRUPT) {
                         dir->erased = false;
@@ -1140,18 +1140,18 @@ static lfs2_stag_t lfs2_dir_fetchmatch(lfs2_t *lfs2,
                 tempcount += lfs2_tag_splice(tag);
 
                 if (tag == (LFS2_MKTAG(LFS2_TYPE_DELETE, 0, 0) |
-                        (LFS2_MKTAG(0, 0x3ff, 0) & tempbesttag))) {
+                            (LFS2_MKTAG(0, 0x3ff, 0) & tempbesttag))) {
                     tempbesttag |= 0x80000000;
                 } else if (tempbesttag != -1 &&
-                        lfs2_tag_id(tag) <= lfs2_tag_id(tempbesttag)) {
+                           lfs2_tag_id(tag) <= lfs2_tag_id(tempbesttag)) {
                     tempbesttag += LFS2_MKTAG(0, lfs2_tag_splice(tag), 0);
                 }
             } else if (lfs2_tag_type1(tag) == LFS2_TYPE_TAIL) {
                 tempsplit = (lfs2_tag_chunk(tag) & 1);
 
                 err = lfs2_bd_read(lfs2,
-                        NULL, &lfs2->rcache, lfs2->cfg->block_size,
-                        dir->pair[0], off+sizeof(tag), &temptail, 8);
+                    NULL, &lfs2->rcache, lfs2->cfg->block_size,
+                    dir->pair[0], off + sizeof(tag), &temptail, 8);
                 if (err) {
                     if (err == LFS2_ERR_CORRUPT) {
                         dir->erased = false;
@@ -1163,8 +1163,9 @@ static lfs2_stag_t lfs2_dir_fetchmatch(lfs2_t *lfs2,
 
             // found a match for our fetcher?
             if ((fmask & tag) == (fmask & ftag)) {
-                int res = cb(data, tag, &(struct lfs2_diskoff){
-                        dir->pair[0], off+sizeof(tag)});
+                int res = cb(data, tag, &(struct lfs2_diskoff) {
+                    dir->pair[0], off + sizeof(tag)
+                });
                 if (res < 0) {
                     if (res == LFS2_ERR_CORRUPT) {
                         dir->erased = false;
@@ -1177,12 +1178,12 @@ static lfs2_stag_t lfs2_dir_fetchmatch(lfs2_t *lfs2,
                     // found a match
                     tempbesttag = tag;
                 } else if ((LFS2_MKTAG(0x7ff, 0x3ff, 0) & tag) ==
-                        (LFS2_MKTAG(0x7ff, 0x3ff, 0) & tempbesttag)) {
+                           (LFS2_MKTAG(0x7ff, 0x3ff, 0) & tempbesttag)) {
                     // found an identical tag, but contents didn't match
                     // this must mean that our besttag has been overwritten
                     tempbesttag = -1;
                 } else if (res == LFS2_CMP_GT &&
-                        lfs2_tag_id(tag) <= lfs2_tag_id(tempbesttag)) {
+                           lfs2_tag_id(tag) <= lfs2_tag_id(tempbesttag)) {
                     // found a greater match, keep track to keep things sorted
                     tempbesttag = tag | 0x80000000;
                 }
@@ -1196,7 +1197,7 @@ static lfs2_stag_t lfs2_dir_fetchmatch(lfs2_t *lfs2,
                 if (lfs2_tag_id(lfs2->gdisk.tag) == lfs2_tag_id(besttag)) {
                     besttag |= 0x80000000;
                 } else if (besttag != -1 &&
-                        lfs2_tag_id(lfs2->gdisk.tag) < lfs2_tag_id(besttag)) {
+                           lfs2_tag_id(lfs2->gdisk.tag) < lfs2_tag_id(besttag)) {
                     besttag -= LFS2_MKTAG(0, 1, 0);
                 }
             }
@@ -1217,27 +1218,27 @@ static lfs2_stag_t lfs2_dir_fetchmatch(lfs2_t *lfs2,
 
         // failed, try the other block?
         lfs2_pair_swap(dir->pair);
-        dir->rev = revs[(r+1)%2];
+        dir->rev = revs[(r + 1) % 2];
     }
 
-    LFS2_ERROR("Corrupted dir pair at {0x%"PRIx32", 0x%"PRIx32"}",
-            dir->pair[0], dir->pair[1]);
+    LFS2_ERROR("Corrupted dir pair at {0x%" PRIx32 ", 0x%" PRIx32 "}",
+        dir->pair[0], dir->pair[1]);
     return LFS2_ERR_CORRUPT;
 }
 
 static int lfs2_dir_fetch(lfs2_t *lfs2,
-        lfs2_mdir_t *dir, const lfs2_block_t pair[2]) {
+    lfs2_mdir_t *dir, const lfs2_block_t pair[2]) {
     // note, mask=-1, tag=-1 can never match a tag since this
     // pattern has the invalid bit set
     return (int)lfs2_dir_fetchmatch(lfs2, dir, pair,
-            (lfs2_tag_t)-1, (lfs2_tag_t)-1, NULL, NULL, NULL);
+        (lfs2_tag_t)-1, (lfs2_tag_t)-1, NULL, NULL, NULL);
 }
 
 static int lfs2_dir_getgstate(lfs2_t *lfs2, const lfs2_mdir_t *dir,
-        lfs2_gstate_t *gstate) {
+    lfs2_gstate_t *gstate) {
     lfs2_gstate_t temp;
     lfs2_stag_t res = lfs2_dir_get(lfs2, dir, LFS2_MKTAG(0x7ff, 0, 0),
-            LFS2_MKTAG(LFS2_TYPE_MOVESTATE, 0, sizeof(temp)), &temp);
+        LFS2_MKTAG(LFS2_TYPE_MOVESTATE, 0, sizeof(temp)), &temp);
     if (res < 0 && res != LFS2_ERR_NOENT) {
         return res;
     }
@@ -1252,7 +1253,7 @@ static int lfs2_dir_getgstate(lfs2_t *lfs2, const lfs2_mdir_t *dir,
 }
 
 static int lfs2_dir_getinfo(lfs2_t *lfs2, lfs2_mdir_t *dir,
-        uint16_t id, struct lfs2_info *info) {
+    uint16_t id, struct lfs2_info *info) {
     if (id == 0x3ff) {
         // special case for root
         strcpy(info->name, "/");
@@ -1261,7 +1262,7 @@ static int lfs2_dir_getinfo(lfs2_t *lfs2, lfs2_mdir_t *dir,
     }
 
     lfs2_stag_t tag = lfs2_dir_get(lfs2, dir, LFS2_MKTAG(0x780, 0x3ff, 0),
-            LFS2_MKTAG(LFS2_TYPE_NAME, id, lfs2->name_max+1), info->name);
+        LFS2_MKTAG(LFS2_TYPE_NAME, id, lfs2->name_max + 1), info->name);
     if (tag < 0) {
         return (int)tag;
     }
@@ -1270,7 +1271,7 @@ static int lfs2_dir_getinfo(lfs2_t *lfs2, lfs2_mdir_t *dir,
 
     struct lfs2_ctz ctz;
     tag = lfs2_dir_get(lfs2, dir, LFS2_MKTAG(0x700, 0x3ff, 0),
-            LFS2_MKTAG(LFS2_TYPE_STRUCT, id, sizeof(ctz)), &ctz);
+        LFS2_MKTAG(LFS2_TYPE_STRUCT, id, sizeof(ctz)), &ctz);
     if (tag < 0) {
         return (int)tag;
     }
@@ -1292,7 +1293,7 @@ struct lfs2_dir_find_match {
 };
 
 static int lfs2_dir_find_match(void *data,
-        lfs2_tag_t tag, const void *buffer) {
+    lfs2_tag_t tag, const void *buffer) {
     struct lfs2_dir_find_match *name = data;
     lfs2_t *lfs2 = name->lfs2;
     const struct lfs2_diskoff *disk = buffer;
@@ -1300,8 +1301,8 @@ static int lfs2_dir_find_match(void *data,
     // compare with disk
     lfs2_size_t diff = lfs2_min(name->size, lfs2_tag_size(tag));
     int res = lfs2_bd_cmp(lfs2,
-            NULL, &lfs2->rcache, diff,
-            disk->block, disk->off, name->name, diff);
+        NULL, &lfs2->rcache, diff,
+        disk->block, disk->off, name->name, diff);
     if (res != LFS2_CMP_EQ) {
         return res;
     }
@@ -1316,7 +1317,7 @@ static int lfs2_dir_find_match(void *data,
 }
 
 static lfs2_stag_t lfs2_dir_find(lfs2_t *lfs2, lfs2_mdir_t *dir,
-        const char **path, uint16_t *id) {
+    const char **path, uint16_t *id) {
     // we reduce path to a single name if we can find it
     const char *name = *path;
     if (id) {
@@ -1329,7 +1330,7 @@ static lfs2_stag_t lfs2_dir_find(lfs2_t *lfs2, lfs2_mdir_t *dir,
     dir->tail[1] = lfs2->root[1];
 
     while (true) {
-nextname:
+    nextname:
         // skip slashes
         name += strspn(name, "/");
         lfs2_size_t namelen = strcspn(name, "/");
@@ -1381,7 +1382,7 @@ static lfs2_stag_t lfs2_dir_find(lfs2_t *lfs2, lfs2_mdir_t *dir,
         // grab the entry data
         if (lfs2_tag_id(tag) != 0x3ff) {
             lfs2_stag_t res = lfs2_dir_get(lfs2, dir, LFS2_MKTAG(0x700, 0x3ff, 0),
-                    LFS2_MKTAG(LFS2_TYPE_STRUCT, lfs2_tag_id(tag), 8), dir->tail);
+                LFS2_MKTAG(LFS2_TYPE_STRUCT, lfs2_tag_id(tag), 8), dir->tail);
             if (res < 0) {
                 return res;
             }
@@ -1391,12 +1392,13 @@ static lfs2_stag_t lfs2_dir_find(lfs2_t *lfs2, lfs2_mdir_t *dir,
         // find entry matching name
         while (true) {
             tag = lfs2_dir_fetchmatch(lfs2, dir, dir->tail,
-                    LFS2_MKTAG(0x780, 0, 0),
-                    LFS2_MKTAG(LFS2_TYPE_NAME, 0, namelen),
-                     // are we last name?
-                    (strchr(name, '/') == NULL) ? id : NULL,
-                    lfs2_dir_find_match, &(struct lfs2_dir_find_match){
-                        lfs2, name, namelen});
+                LFS2_MKTAG(0x780, 0, 0),
+                LFS2_MKTAG(LFS2_TYPE_NAME, 0, namelen),
+                // are we last name?
+                (strchr(name, '/') == NULL) ? id : NULL,
+                lfs2_dir_find_match, &(struct lfs2_dir_find_match) {
+                lfs2, name, namelen
+            });
             if (tag < 0) {
                 return tag;
             }
@@ -1428,11 +1430,11 @@ struct lfs2_commit {
 
 #ifndef LFS2_READONLY
 static int lfs2_dir_commitprog(lfs2_t *lfs2, struct lfs2_commit *commit,
-        const void *buffer, lfs2_size_t size) {
+    const void *buffer, lfs2_size_t size) {
     int err = lfs2_bd_prog(lfs2,
-            &lfs2->pcache, &lfs2->rcache, false,
-            commit->block, commit->off ,
-            (const uint8_t*)buffer, size);
+        &lfs2->pcache, &lfs2->rcache, false,
+        commit->block, commit->off,
+        (const uint8_t *)buffer, size);
     if (err) {
         return err;
     }
@@ -1445,7 +1447,7 @@ static int lfs2_dir_commitprog(lfs2_t *lfs2, struct lfs2_commit *commit,
 
 #ifndef LFS2_READONLY
 static int lfs2_dir_commitattr(lfs2_t *lfs2, struct lfs2_commit *commit,
-        lfs2_tag_t tag, const void *buffer) {
+    lfs2_tag_t tag, const void *buffer) {
     // check if we fit
     lfs2_size_t dsize = lfs2_tag_dsize(tag);
     if (commit->off + dsize > commit->end) {
@@ -1461,19 +1463,19 @@ static int lfs2_dir_commitattr(lfs2_t *lfs2, struct lfs2_commit *commit,
 
     if (!(tag & 0x80000000)) {
         // from memory
-        err = lfs2_dir_commitprog(lfs2, commit, buffer, dsize-sizeof(tag));
+        err = lfs2_dir_commitprog(lfs2, commit, buffer, dsize - sizeof(tag));
         if (err) {
             return err;
         }
     } else {
         // from disk
         const struct lfs2_diskoff *disk = buffer;
-        for (lfs2_off_t i = 0; i < dsize-sizeof(tag); i++) {
+        for (lfs2_off_t i = 0; i < dsize - sizeof(tag); i++) {
             // rely on caching to make this efficient
             uint8_t dat;
             err = lfs2_bd_read(lfs2,
-                    NULL, &lfs2->rcache, dsize-sizeof(tag)-i,
-                    disk->block, disk->off+i, &dat, 1);
+                NULL, &lfs2->rcache, dsize - sizeof(tag) - i,
+                disk->block, disk->off + i, &dat, 1);
             if (err) {
                 return err;
             }
@@ -1493,8 +1495,8 @@ static int lfs2_dir_commitattr(lfs2_t *lfs2, struct lfs2_commit *commit,
 #ifndef LFS2_READONLY
 static int lfs2_dir_commitcrc(lfs2_t *lfs2, struct lfs2_commit *commit) {
     // align to program units
-    const lfs2_off_t end = lfs2_alignup(commit->off + 2*sizeof(uint32_t),
-            lfs2->cfg->prog_size);
+    const lfs2_off_t end = lfs2_alignup(commit->off + 2 * sizeof(uint32_t),
+        lfs2->cfg->prog_size);
 
     lfs2_off_t off1 = 0;
     uint32_t crc1 = 0;
@@ -1506,14 +1508,14 @@ static int lfs2_dir_commitcrc(lfs2_t *lfs2, struct lfs2_commit *commit) {
         lfs2_off_t off = commit->off + sizeof(lfs2_tag_t);
         lfs2_off_t noff = lfs2_min(end - off, 0x3fe) + off;
         if (noff < end) {
-            noff = lfs2_min(noff, end - 2*sizeof(uint32_t));
+            noff = lfs2_min(noff, end - 2 * sizeof(uint32_t));
         }
 
         // read erased state from next program unit
         lfs2_tag_t tag = 0xffffffff;
         int err = lfs2_bd_read(lfs2,
-                NULL, &lfs2->rcache, sizeof(tag),
-                commit->block, noff, &tag, sizeof(tag));
+            NULL, &lfs2->rcache, sizeof(tag),
+            commit->block, noff, &tag, sizeof(tag));
         if (err && err != LFS2_ERR_CORRUPT) {
             return err;
         }
@@ -1528,8 +1530,8 @@ static int lfs2_dir_commitcrc(lfs2_t *lfs2, struct lfs2_commit *commit) {
         commit->crc = lfs2_crc(commit->crc, &footer[0], sizeof(footer[0]));
         footer[1] = lfs2_tole32(commit->crc);
         err = lfs2_bd_prog(lfs2,
-                &lfs2->pcache, &lfs2->rcache, false,
-                commit->block, commit->off, &footer, sizeof(footer));
+            &lfs2->pcache, &lfs2->rcache, false,
+            commit->block, commit->off, &footer, sizeof(footer));
         if (err) {
             return err;
         }
@@ -1540,7 +1542,7 @@ static int lfs2_dir_commitcrc(lfs2_t *lfs2, struct lfs2_commit *commit) {
             crc1 = commit->crc;
         }
 
-        commit->off += sizeof(tag)+lfs2_tag_size(tag);
+        commit->off += sizeof(tag) + lfs2_tag_size(tag);
         commit->ptag = tag ^ ((lfs2_tag_t)reset << 31);
         commit->crc = 0xffffffff; // reset crc for next "commit"
     }
@@ -1556,7 +1558,7 @@ static int lfs2_dir_commitcrc(lfs2_t *lfs2, struct lfs2_commit *commit) {
     lfs2_off_t noff = off1;
     while (off < end) {
         uint32_t crc = 0xffffffff;
-        for (lfs2_off_t i = off; i < noff+sizeof(uint32_t); i++) {
+        for (lfs2_off_t i = off; i < noff + sizeof(uint32_t); i++) {
             // check against written crc, may catch blocks that
             // become readonly and match our commit size exactly
             if (i == off1 && crc != crc1) {
@@ -1566,8 +1568,8 @@ static int lfs2_dir_commitcrc(lfs2_t *lfs2, struct lfs2_commit *commit) {
             // leave it up to caching to make this efficient
             uint8_t dat;
             err = lfs2_bd_read(lfs2,
-                    NULL, &lfs2->rcache, noff+sizeof(uint32_t)-i,
-                    commit->block, i, &dat, 1);
+                NULL, &lfs2->rcache, noff + sizeof(uint32_t) - i,
+                commit->block, i, &dat, 1);
             if (err) {
                 return err;
             }
@@ -1583,7 +1585,7 @@ static int lfs2_dir_commitcrc(lfs2_t *lfs2, struct lfs2_commit *commit) {
         // skip padding
         off = lfs2_min(end - noff, 0x3fe) + noff;
         if (off < end) {
-            off = lfs2_min(off, end - 2*sizeof(uint32_t));
+            off = lfs2_min(off, end - 2 * sizeof(uint32_t));
         }
         noff = off + sizeof(uint32_t);
     }
@@ -1596,7 +1598,7 @@ static int lfs2_dir_commitcrc(lfs2_t *lfs2, struct lfs2_commit *commit) {
 static int lfs2_dir_alloc(lfs2_t *lfs2, lfs2_mdir_t *dir) {
     // allocate pair of dir blocks (backwards, so we write block 1 first)
     for (int i = 0; i < 2; i++) {
-        int err = lfs2_alloc(lfs2, &dir->pair[(i+1)%2]);
+        int err = lfs2_alloc(lfs2, &dir->pair[(i + 1) % 2]);
         if (err) {
             return err;
         }
@@ -1608,8 +1610,8 @@ static int lfs2_dir_alloc(lfs2_t *lfs2, lfs2_mdir_t *dir) {
     // rather than clobbering one of the blocks we just pretend
     // the revision may be valid
     int err = lfs2_bd_read(lfs2,
-            NULL, &lfs2->rcache, sizeof(dir->rev),
-            dir->pair[0], 0, &dir->rev, sizeof(dir->rev));
+        NULL, &lfs2->rcache, sizeof(dir->rev),
+        dir->pair[0], 0, &dir->rev, sizeof(dir->rev));
     dir->rev = lfs2_fromle32(dir->rev);
     if (err && err != LFS2_ERR_CORRUPT) {
         return err;
@@ -1619,7 +1621,7 @@ static int lfs2_dir_alloc(lfs2_t *lfs2, lfs2_mdir_t *dir) {
     // to our block_cycles modulus, see lfs2_dir_compact for why our modulus
     // is tweaked this way
     if (lfs2->cfg->block_cycles > 0) {
-        dir->rev = lfs2_alignup(dir->rev, ((lfs2->cfg->block_cycles+1)|1));
+        dir->rev = lfs2_alignup(dir->rev, ((lfs2->cfg->block_cycles + 1) | 1));
     }
 
     // set defaults
@@ -1647,7 +1649,7 @@ static int lfs2_dir_drop(lfs2_t *lfs2, lfs2_mdir_t *dir, lfs2_mdir_t *tail) {
     // steal tail
     lfs2_pair_tole32(tail->tail);
     err = lfs2_dir_commit(lfs2, dir, LFS2_MKATTRS(
-            {LFS2_MKTAG(LFS2_TYPE_TAIL + tail->split, 0x3ff, 8), tail->tail}));
+        {LFS2_MKTAG(LFS2_TYPE_TAIL + tail->split, 0x3ff, 8), tail->tail}));
     lfs2_pair_fromle32(tail->tail);
     if (err) {
         return err;
@@ -1659,8 +1661,8 @@ static int lfs2_dir_drop(lfs2_t *lfs2, lfs2_mdir_t *dir, lfs2_mdir_t *tail) {
 
 #ifndef LFS2_READONLY
 static int lfs2_dir_split(lfs2_t *lfs2,
-        lfs2_mdir_t *dir, const struct lfs2_mattr *attrs, int attrcount,
-        lfs2_mdir_t *source, uint16_t split, uint16_t end) {
+    lfs2_mdir_t *dir, const struct lfs2_mattr *attrs, int attrcount,
+    lfs2_mdir_t *source, uint16_t split, uint16_t end) {
     // create tail metadata pair
     lfs2_mdir_t tail;
     int err = lfs2_dir_alloc(lfs2, &tail);
@@ -1724,15 +1726,15 @@ static bool lfs2_dir_needsrelocation(lfs2_t *lfs2, lfs2_mdir_t *dir) {
     // 1. block_cycles = 1, which would prevent relocations from terminating
     // 2. block_cycles = 2n, which, due to aliasing, would only ever relocate
     //    one metadata block in the pair, effectively making this useless
-    return (lfs2->cfg->block_cycles > 0
-            && ((dir->rev + 1) % ((lfs2->cfg->block_cycles+1)|1) == 0));
+    return lfs2->cfg->block_cycles > 0
+           && ((dir->rev + 1) % ((lfs2->cfg->block_cycles + 1) | 1) == 0);
 }
 #endif
 
 #ifndef LFS2_READONLY
 static int lfs2_dir_compact(lfs2_t *lfs2,
-        lfs2_mdir_t *dir, const struct lfs2_mattr *attrs, int attrcount,
-        lfs2_mdir_t *source, uint16_t begin, uint16_t end) {
+    lfs2_mdir_t *dir, const struct lfs2_mattr *attrs, int attrcount,
+    lfs2_mdir_t *source, uint16_t begin, uint16_t end) {
     // save some state in case block is bad
     bool relocated = false;
     bool tired = lfs2_dir_needsrelocation(lfs2, dir);
@@ -1746,13 +1748,13 @@ static int lfs2_dir_compact(lfs2_t *lfs2,
     // pointers if we relocate the head of a directory. On top of
     // this, relocations increase the overall complexity of
     // lfs2_migration, which is already a delicate operation.
-#ifdef LFS2_MIGRATE
+    #ifdef LFS2_MIGRATE
     if (lfs2->lfs21) {
         tired = false;
     }
-#endif
+    #endif
 
-    if (tired && lfs2_pair_cmp(dir->pair, (const lfs2_block_t[2]){0, 1}) != 0) {
+    if (tired && lfs2_pair_cmp(dir->pair, (const lfs2_block_t[2]) {0, 1}) != 0) {
         // we're writing too much, time to relocate
         goto relocate;
     }
@@ -1784,7 +1786,7 @@ static int lfs2_dir_compact(lfs2_t *lfs2,
             // write out header
             dir->rev = lfs2_tole32(dir->rev);
             err = lfs2_dir_commitprog(lfs2, &commit,
-                    &dir->rev, sizeof(dir->rev));
+                &dir->rev, sizeof(dir->rev));
             dir->rev = lfs2_fromle32(dir->rev);
             if (err) {
                 if (err == LFS2_ERR_CORRUPT) {
@@ -1795,12 +1797,13 @@ static int lfs2_dir_compact(lfs2_t *lfs2,
 
             // traverse the directory, this time writing out all unique tags
             err = lfs2_dir_traverse(lfs2,
-                    source, 0, 0xffffffff, attrs, attrcount,
-                    LFS2_MKTAG(0x400, 0x3ff, 0),
-                    LFS2_MKTAG(LFS2_TYPE_NAME, 0, 0),
-                    begin, end, -begin,
-                    lfs2_dir_commit_commit, &(struct lfs2_dir_commit_commit){
-                        lfs2, &commit});
+                source, 0, 0xffffffff, attrs, attrcount,
+                LFS2_MKTAG(0x400, 0x3ff, 0),
+                LFS2_MKTAG(LFS2_TYPE_NAME, 0, 0),
+                begin, end, -begin,
+                lfs2_dir_commit_commit, &(struct lfs2_dir_commit_commit) {
+                lfs2, &commit
+            });
             if (err) {
                 if (err == LFS2_ERR_CORRUPT) {
                     goto relocate;
@@ -1812,8 +1815,8 @@ static int lfs2_dir_compact(lfs2_t *lfs2,
             if (!lfs2_pair_isnull(dir->tail)) {
                 lfs2_pair_tole32(dir->tail);
                 err = lfs2_dir_commitattr(lfs2, &commit,
-                        LFS2_MKTAG(LFS2_TYPE_TAIL + dir->split, 0x3ff, 8),
-                        dir->tail);
+                    LFS2_MKTAG(LFS2_TYPE_TAIL + dir->split, 0x3ff, 8),
+                    dir->tail);
                 lfs2_pair_fromle32(dir->tail);
                 if (err) {
                     if (err == LFS2_ERR_CORRUPT) {
@@ -1840,8 +1843,8 @@ static int lfs2_dir_compact(lfs2_t *lfs2,
             if (!lfs2_gstate_iszero(&delta)) {
                 lfs2_gstate_tole32(&delta);
                 err = lfs2_dir_commitattr(lfs2, &commit,
-                        LFS2_MKTAG(LFS2_TYPE_MOVESTATE, 0x3ff,
-                            sizeof(delta)), &delta);
+                    LFS2_MKTAG(LFS2_TYPE_MOVESTATE, 0x3ff,
+                        sizeof(delta)), &delta);
                 if (err) {
                     if (err == LFS2_ERR_CORRUPT) {
                         goto relocate;
@@ -1866,25 +1869,25 @@ static int lfs2_dir_compact(lfs2_t *lfs2,
             dir->off = commit.off;
             dir->etag = commit.ptag;
             // update gstate
-            lfs2->gdelta = (lfs2_gstate_t){0};
+            lfs2->gdelta = (lfs2_gstate_t) {0};
             if (!relocated) {
                 lfs2->gdisk = lfs2->gstate;
             }
         }
         break;
 
-relocate:
+    relocate:
         // commit was corrupted, drop caches and prepare to relocate block
         relocated = true;
         lfs2_cache_drop(lfs2, &lfs2->pcache);
         if (!tired) {
-            LFS2_DEBUG("Bad block at 0x%"PRIx32, dir->pair[1]);
+            LFS2_DEBUG("Bad block at 0x%" PRIx32, dir->pair[1]);
         }
 
         // can't relocate superblock, filesystem is now frozen
-        if (lfs2_pair_cmp(dir->pair, (const lfs2_block_t[2]){0, 1}) == 0) {
-            LFS2_WARN("Superblock 0x%"PRIx32" has become unwritable",
-                    dir->pair[1]);
+        if (lfs2_pair_cmp(dir->pair, (const lfs2_block_t[2]) {0, 1}) == 0) {
+            LFS2_WARN("Superblock 0x%" PRIx32 " has become unwritable",
+                dir->pair[1]);
             return LFS2_ERR_NOSPC;
         }
 
@@ -1904,8 +1907,8 @@ static int lfs2_dir_compact(lfs2_t *lfs2,
 
 #ifndef LFS2_READONLY
 static int lfs2_dir_splittingcompact(lfs2_t *lfs2, lfs2_mdir_t *dir,
-        const struct lfs2_mattr *attrs, int attrcount,
-        lfs2_mdir_t *source, uint16_t begin, uint16_t end) {
+    const struct lfs2_mattr *attrs, int attrcount,
+    lfs2_mdir_t *source, uint16_t begin, uint16_t end) {
     while (true) {
         // find size of first split, we do this by halving the split until
         // the metadata is guaranteed to fit
@@ -1917,11 +1920,11 @@ static int lfs2_dir_splittingcompact(lfs2_t *lfs2, lfs2_mdir_t *dir,
         while (end - split > 1) {
             lfs2_size_t size = 0;
             int err = lfs2_dir_traverse(lfs2,
-                    source, 0, 0xffffffff, attrs, attrcount,
-                    LFS2_MKTAG(0x400, 0x3ff, 0),
-                    LFS2_MKTAG(LFS2_TYPE_NAME, 0, 0),
-                    split, end, -split,
-                    lfs2_dir_commit_size, &size);
+                source, 0, 0xffffffff, attrs, attrcount,
+                LFS2_MKTAG(0x400, 0x3ff, 0),
+                LFS2_MKTAG(LFS2_TYPE_NAME, 0, 0),
+                split, end, -split,
+                lfs2_dir_commit_size, &size);
             if (err) {
                 return err;
             }
@@ -1930,12 +1933,12 @@ static int lfs2_dir_splittingcompact(lfs2_t *lfs2, lfs2_mdir_t *dir,
             // cleanup delete, and we cap at half a block to give room
             // for metadata updates.
             if (end - split < 0xff
-                    && size <= lfs2_min(lfs2->cfg->block_size - 36,
-                        lfs2_alignup(
-                            (lfs2->cfg->metadata_max
+                && size <= lfs2_min(lfs2->cfg->block_size - 36,
+                    lfs2_alignup(
+                        (lfs2->cfg->metadata_max
                                 ? lfs2->cfg->metadata_max
-                                : lfs2->cfg->block_size)/2,
-                            lfs2->cfg->prog_size))) {
+                                : lfs2->cfg->block_size) / 2,
+                        lfs2->cfg->prog_size))) {
                 break;
             }
 
@@ -1949,7 +1952,7 @@ static int lfs2_dir_splittingcompact(lfs2_t *lfs2, lfs2_mdir_t *dir,
 
         // split into two metadata pairs and continue
         int err = lfs2_dir_split(lfs2, dir, attrs, attrcount,
-                source, split, end);
+            source, split, end);
         if (err && err != LFS2_ERR_NOSPC) {
             return err;
         }
@@ -1957,8 +1960,8 @@ static int lfs2_dir_splittingcompact(lfs2_t *lfs2, lfs2_mdir_t *dir,
         if (err) {
             // we can't allocate a new block, try to compact with degraded
             // performance
-            LFS2_WARN("Unable to split {0x%"PRIx32", 0x%"PRIx32"}",
-                    dir->pair[0], dir->pair[1]);
+            LFS2_WARN("Unable to split {0x%" PRIx32 ", 0x%" PRIx32 "}",
+                dir->pair[0], dir->pair[1]);
             break;
         } else {
             end = split;
@@ -1966,7 +1969,7 @@ static int lfs2_dir_splittingcompact(lfs2_t *lfs2, lfs2_mdir_t *dir,
     }
 
     if (lfs2_dir_needsrelocation(lfs2, dir)
-            && lfs2_pair_cmp(dir->pair, (const lfs2_block_t[2]){0, 1}) == 0) {
+        && lfs2_pair_cmp(dir->pair, (const lfs2_block_t[2]) {0, 1}) == 0) {
         // oh no! we're writing too much to the superblock,
         // should we expand?
         lfs2_ssize_t size = lfs2_fs_rawsize(lfs2);
@@ -1976,10 +1979,10 @@ static int lfs2_dir_splittingcompact(lfs2_t *lfs2, lfs2_mdir_t *dir,
 
         // do we have extra space? littlefs can't reclaim this space
         // by itself, so expand cautiously
-        if ((lfs2_size_t)size < lfs2->cfg->block_count/2) {
-            LFS2_DEBUG("Expanding superblock at rev %"PRIu32, dir->rev);
+        if ((lfs2_size_t)size < lfs2->cfg->block_count / 2) {
+            LFS2_DEBUG("Expanding superblock at rev %" PRIu32, dir->rev);
             int err = lfs2_dir_split(lfs2, dir, attrs, attrcount,
-                    source, begin, end);
+                source, begin, end);
             if (err && err != LFS2_ERR_NOSPC) {
                 return err;
             }
@@ -2000,9 +2003,9 @@ static int lfs2_dir_splittingcompact(lfs2_t *lfs2, lfs2_mdir_t *dir,
 
 #ifndef LFS2_READONLY
 static int lfs2_dir_relocatingcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
-        const lfs2_block_t pair[2],
-        const struct lfs2_mattr *attrs, int attrcount,
-        lfs2_mdir_t *pdir) {
+    const lfs2_block_t pair[2],
+    const struct lfs2_mattr *attrs, int attrcount,
+    lfs2_mdir_t *pdir) {
     int state = 0;
 
     // calculate changes to the directory
@@ -2015,8 +2018,8 @@ static int lfs2_dir_relocatingcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
             dir->count -= 1;
             hasdelete = true;
         } else if (lfs2_tag_type1(attrs[i].tag) == LFS2_TYPE_TAIL) {
-            dir->tail[0] = ((lfs2_block_t*)attrs[i].buffer)[0];
-            dir->tail[1] = ((lfs2_block_t*)attrs[i].buffer)[1];
+            dir->tail[0] = ((lfs2_block_t *)attrs[i].buffer)[0];
+            dir->tail[1] = ((lfs2_block_t *)attrs[i].buffer)[1];
             dir->split = (lfs2_tag_chunk(attrs[i].tag) & 1);
             lfs2_pair_fromle32(dir->tail);
         }
@@ -2052,10 +2055,11 @@ static int lfs2_dir_relocatingcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
         // traverse attrs that need to be written out
         lfs2_pair_tole32(dir->tail);
         int err = lfs2_dir_traverse(lfs2,
-                dir, dir->off, dir->etag, attrs, attrcount,
-                0, 0, 0, 0, 0,
-                lfs2_dir_commit_commit, &(struct lfs2_dir_commit_commit){
-                    lfs2, &commit});
+            dir, dir->off, dir->etag, attrs, attrcount,
+            0, 0, 0, 0, 0,
+            lfs2_dir_commit_commit, &(struct lfs2_dir_commit_commit) {
+            lfs2, &commit
+        });
         lfs2_pair_fromle32(dir->tail);
         if (err) {
             if (err == LFS2_ERR_NOSPC || err == LFS2_ERR_CORRUPT) {
@@ -2078,8 +2082,8 @@ static int lfs2_dir_relocatingcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
 
             lfs2_gstate_tole32(&delta);
             err = lfs2_dir_commitattr(lfs2, &commit,
-                    LFS2_MKTAG(LFS2_TYPE_MOVESTATE, 0x3ff,
-                        sizeof(delta)), &delta);
+                LFS2_MKTAG(LFS2_TYPE_MOVESTATE, 0x3ff,
+                    sizeof(delta)), &delta);
             if (err) {
                 if (err == LFS2_ERR_NOSPC || err == LFS2_ERR_CORRUPT) {
                     goto compact;
@@ -2103,7 +2107,7 @@ static int lfs2_dir_relocatingcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
         dir->etag = commit.ptag;
         // and update gstate
         lfs2->gdisk = lfs2->gstate;
-        lfs2->gdelta = (lfs2_gstate_t){0};
+        lfs2->gdelta = (lfs2_gstate_t) {0};
 
         goto fixmlist;
     }
@@ -2113,7 +2117,7 @@ static int lfs2_dir_relocatingcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
     lfs2_cache_drop(lfs2, &lfs2->pcache);
 
     state = lfs2_dir_splittingcompact(lfs2, dir, attrs, attrcount,
-            dir, 0, dir->count);
+        dir, 0, dir->count);
     if (state < 0) {
         return state;
     }
@@ -2135,20 +2139,20 @@ fixmlist:;
             if (d->m.pair != pair) {
                 for (int i = 0; i < attrcount; i++) {
                     if (lfs2_tag_type3(attrs[i].tag) == LFS2_TYPE_DELETE &&
-                            d->id == lfs2_tag_id(attrs[i].tag)) {
+                        d->id == lfs2_tag_id(attrs[i].tag)) {
                         d->m.pair[0] = LFS2_BLOCK_NULL;
                         d->m.pair[1] = LFS2_BLOCK_NULL;
                     } else if (lfs2_tag_type3(attrs[i].tag) == LFS2_TYPE_DELETE &&
-                            d->id > lfs2_tag_id(attrs[i].tag)) {
+                               d->id > lfs2_tag_id(attrs[i].tag)) {
                         d->id -= 1;
                         if (d->type == LFS2_TYPE_DIR) {
-                            ((lfs2_dir_t*)d)->pos -= 1;
+                            ((lfs2_dir_t *)d)->pos -= 1;
                         }
                     } else if (lfs2_tag_type3(attrs[i].tag) == LFS2_TYPE_CREATE &&
-                            d->id >= lfs2_tag_id(attrs[i].tag)) {
+                               d->id >= lfs2_tag_id(attrs[i].tag)) {
                         d->id += 1;
                         if (d->type == LFS2_TYPE_DIR) {
-                            ((lfs2_dir_t*)d)->pos += 1;
+                            ((lfs2_dir_t *)d)->pos += 1;
                         }
                     }
                 }
@@ -2171,13 +2175,13 @@ fixmlist:;
 
 #ifndef LFS2_READONLY
 static int lfs2_dir_orphaningcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
-        const struct lfs2_mattr *attrs, int attrcount) {
+    const struct lfs2_mattr *attrs, int attrcount) {
     // check for any inline files that aren't RAM backed and
     // forcefully evict them, needed for filesystem consistency
-    for (lfs2_file_t *f = (lfs2_file_t*)lfs2->mlist; f; f = f->next) {
+    for (lfs2_file_t *f = (lfs2_file_t *)lfs2->mlist; f; f = f->next) {
         if (dir != &f->m && lfs2_pair_cmp(f->m.pair, dir->pair) == 0 &&
-                f->type == LFS2_TYPE_REG && (f->flags & LFS2_F_INLINE) &&
-                f->ctz.size > lfs2->cfg->cache_size) {
+            f->type == LFS2_TYPE_REG && (f->flags & LFS2_F_INLINE) &&
+            f->ctz.size > lfs2->cfg->cache_size) {
             int err = lfs2_file_outline(lfs2, f);
             if (err) {
                 return err;
@@ -2194,7 +2198,7 @@ static int lfs2_dir_orphaningcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
     lfs2_mdir_t ldir = *dir;
     lfs2_mdir_t pdir;
     int state = lfs2_dir_relocatingcommit(lfs2, &ldir, dir->pair,
-            attrs, attrcount, &pdir);
+        attrs, attrcount, &pdir);
     if (state < 0) {
         return state;
     }
@@ -2222,9 +2226,9 @@ static int lfs2_dir_orphaningcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
         lpair[1] = pdir.pair[1];
         lfs2_pair_tole32(dir->tail);
         state = lfs2_dir_relocatingcommit(lfs2, &pdir, lpair, LFS2_MKATTRS(
-                    {LFS2_MKTAG(LFS2_TYPE_TAIL + dir->split, 0x3ff, 8),
-                        dir->tail}),
-                NULL);
+            {LFS2_MKTAG(LFS2_TYPE_TAIL + dir->split, 0x3ff, 8),
+             dir->tail}),
+            NULL);
         lfs2_pair_fromle32(dir->tail);
         if (state < 0) {
             return state;
@@ -2236,9 +2240,9 @@ static int lfs2_dir_orphaningcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
     // need to relocate?
     bool orphans = false;
     while (state == LFS2_OK_RELOCATED) {
-        LFS2_DEBUG("Relocating {0x%"PRIx32", 0x%"PRIx32"} "
-                    "-> {0x%"PRIx32", 0x%"PRIx32"}",
-                lpair[0], lpair[1], ldir.pair[0], ldir.pair[1]);
+        LFS2_DEBUG("Relocating {0x%" PRIx32 ", 0x%" PRIx32 "} "
+            "-> {0x%" PRIx32 ", 0x%" PRIx32 "}",
+            lpair[0], lpair[1], ldir.pair[0], ldir.pair[1]);
         state = 0;
 
         // update internal root
@@ -2255,9 +2259,9 @@ static int lfs2_dir_orphaningcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
             }
 
             if (d->type == LFS2_TYPE_DIR &&
-                    lfs2_pair_cmp(lpair, ((lfs2_dir_t*)d)->head) == 0) {
-                ((lfs2_dir_t*)d)->head[0] = ldir.pair[0];
-                ((lfs2_dir_t*)d)->head[1] = ldir.pair[1];
+                lfs2_pair_cmp(lpair, ((lfs2_dir_t *)d)->head) == 0) {
+                ((lfs2_dir_t *)d)->head[0] = ldir.pair[0];
+                ((lfs2_dir_t *)d)->head[1] = ldir.pair[1];
             }
         }
 
@@ -2282,8 +2286,8 @@ static int lfs2_dir_orphaningcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
             if (lfs2_gstate_hasmovehere(&lfs2->gstate, pdir.pair)) {
                 moveid = lfs2_tag_id(lfs2->gstate.tag);
                 LFS2_DEBUG("Fixing move while relocating "
-                        "{0x%"PRIx32", 0x%"PRIx32"} 0x%"PRIx16"\n",
-                        pdir.pair[0], pdir.pair[1], moveid);
+                    "{0x%" PRIx32 ", 0x%" PRIx32 "} 0x%" PRIx16 "\n",
+                    pdir.pair[0], pdir.pair[1], moveid);
                 lfs2_fs_prepmove(lfs2, 0x3ff, NULL);
                 if (moveid < lfs2_tag_id(tag)) {
                     tag -= LFS2_MKTAG(0, 1, 0);
@@ -2293,10 +2297,10 @@ static int lfs2_dir_orphaningcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
             lfs2_block_t ppair[2] = {pdir.pair[0], pdir.pair[1]};
             lfs2_pair_tole32(ldir.pair);
             state = lfs2_dir_relocatingcommit(lfs2, &pdir, ppair, LFS2_MKATTRS(
-                        {LFS2_MKTAG_IF(moveid != 0x3ff,
-                            LFS2_TYPE_DELETE, moveid, 0), NULL},
-                        {tag, ldir.pair}),
-                    NULL);
+                {LFS2_MKTAG_IF(moveid != 0x3ff,
+                    LFS2_TYPE_DELETE, moveid, 0), NULL},
+                {tag, ldir.pair}),
+                NULL);
             lfs2_pair_fromle32(ldir.pair);
             if (state < 0) {
                 return state;
@@ -2334,8 +2338,8 @@ static int lfs2_dir_orphaningcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
             if (lfs2_gstate_hasmovehere(&lfs2->gstate, pdir.pair)) {
                 moveid = lfs2_tag_id(lfs2->gstate.tag);
                 LFS2_DEBUG("Fixing move while relocating "
-                        "{0x%"PRIx32", 0x%"PRIx32"} 0x%"PRIx16"\n",
-                        pdir.pair[0], pdir.pair[1], moveid);
+                    "{0x%" PRIx32 ", 0x%" PRIx32 "} 0x%" PRIx16 "\n",
+                    pdir.pair[0], pdir.pair[1], moveid);
                 lfs2_fs_prepmove(lfs2, 0x3ff, NULL);
             }
 
@@ -2344,11 +2348,11 @@ static int lfs2_dir_orphaningcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
             lpair[1] = pdir.pair[1];
             lfs2_pair_tole32(ldir.pair);
             state = lfs2_dir_relocatingcommit(lfs2, &pdir, lpair, LFS2_MKATTRS(
-                        {LFS2_MKTAG_IF(moveid != 0x3ff,
-                            LFS2_TYPE_DELETE, moveid, 0), NULL},
-                        {LFS2_MKTAG(LFS2_TYPE_TAIL + pdir.split, 0x3ff, 8),
-                            ldir.pair}),
-                    NULL);
+                {LFS2_MKTAG_IF(moveid != 0x3ff,
+                    LFS2_TYPE_DELETE, moveid, 0), NULL},
+                {LFS2_MKTAG(LFS2_TYPE_TAIL + pdir.split, 0x3ff, 8),
+                 ldir.pair}),
+                NULL);
             lfs2_pair_fromle32(ldir.pair);
             if (state < 0) {
                 return state;
@@ -2364,7 +2368,7 @@ static int lfs2_dir_orphaningcommit(lfs2_t *lfs2, lfs2_mdir_t *dir,
 
 #ifndef LFS2_READONLY
 static int lfs2_dir_commit(lfs2_t *lfs2, lfs2_mdir_t *dir,
-        const struct lfs2_mattr *attrs, int attrcount) {
+    const struct lfs2_mattr *attrs, int attrcount) {
     int orphans = lfs2_dir_orphaningcommit(lfs2, dir, attrs, attrcount);
     if (orphans < 0) {
         return orphans;
@@ -2428,7 +2432,7 @@ static int lfs2_rawmkdir(lfs2_t *lfs2, const char *path) {
     // setup dir
     lfs2_pair_tole32(pred.tail);
     err = lfs2_dir_commit(lfs2, &dir, LFS2_MKATTRS(
-            {LFS2_MKTAG(LFS2_TYPE_SOFTTAIL, 0x3ff, 8), pred.tail}));
+        {LFS2_MKTAG(LFS2_TYPE_SOFTTAIL, 0x3ff, 8), pred.tail}));
     lfs2_pair_fromle32(pred.tail);
     if (err) {
         return err;
@@ -2452,7 +2456,7 @@ static int lfs2_rawmkdir(lfs2_t *lfs2, const char *path) {
 
         lfs2_pair_tole32(dir.pair);
         err = lfs2_dir_commit(lfs2, &pred, LFS2_MKATTRS(
-                {LFS2_MKTAG(LFS2_TYPE_SOFTTAIL, 0x3ff, 8), dir.pair}));
+            {LFS2_MKTAG(LFS2_TYPE_SOFTTAIL, 0x3ff, 8), dir.pair}));
         lfs2_pair_fromle32(dir.pair);
         if (err) {
             lfs2->mlist = cwd.next;
@@ -2469,11 +2473,11 @@ static int lfs2_rawmkdir(lfs2_t *lfs2, const char *path) {
     // now insert into our parent block
     lfs2_pair_tole32(dir.pair);
     err = lfs2_dir_commit(lfs2, &cwd.m, LFS2_MKATTRS(
-            {LFS2_MKTAG(LFS2_TYPE_CREATE, id, 0), NULL},
-            {LFS2_MKTAG(LFS2_TYPE_DIR, id, nlen), path},
-            {LFS2_MKTAG(LFS2_TYPE_DIRSTRUCT, id, 8), dir.pair},
-            {LFS2_MKTAG_IF(!cwd.m.split,
-                LFS2_TYPE_SOFTTAIL, 0x3ff, 8), dir.pair}));
+        {LFS2_MKTAG(LFS2_TYPE_CREATE, id, 0), NULL},
+        {LFS2_MKTAG(LFS2_TYPE_DIR, id, nlen), path},
+        {LFS2_MKTAG(LFS2_TYPE_DIRSTRUCT, id, 8), dir.pair},
+        {LFS2_MKTAG_IF(!cwd.m.split,
+            LFS2_TYPE_SOFTTAIL, 0x3ff, 8), dir.pair}));
     lfs2_pair_fromle32(dir.pair);
     if (err) {
         return err;
@@ -2501,7 +2505,7 @@ static int lfs2_dir_rawopen(lfs2_t *lfs2, lfs2_dir_t *dir, const char *path) {
     } else {
         // get dir pair from parent
         lfs2_stag_t res = lfs2_dir_get(lfs2, &dir->m, LFS2_MKTAG(0x700, 0x3ff, 0),
-                LFS2_MKTAG(LFS2_TYPE_STRUCT, lfs2_tag_id(tag), 8), pair);
+            LFS2_MKTAG(LFS2_TYPE_STRUCT, lfs2_tag_id(tag), 8), pair);
         if (res < 0) {
             return res;
         }
@@ -2637,38 +2641,38 @@ static int lfs2_dir_rawrewind(lfs2_t *lfs2, lfs2_dir_t *dir) {
 /// File index list operations ///
 static int lfs2_ctz_index(lfs2_t *lfs2, lfs2_off_t *off) {
     lfs2_off_t size = *off;
-    lfs2_off_t b = lfs2->cfg->block_size - 2*4;
+    lfs2_off_t b = lfs2->cfg->block_size - 2 * 4;
     lfs2_off_t i = size / b;
     if (i == 0) {
         return 0;
     }
 
-    i = (size - 4*(lfs2_popc(i-1)+2)) / b;
-    *off = size - b*i - 4*lfs2_popc(i);
+    i = (size - 4 * (lfs2_popc(i - 1) + 2)) / b;
+    *off = size - b * i - 4 * lfs2_popc(i);
     return i;
 }
 
 static int lfs2_ctz_find(lfs2_t *lfs2,
-        const lfs2_cache_t *pcache, lfs2_cache_t *rcache,
-        lfs2_block_t head, lfs2_size_t size,
-        lfs2_size_t pos, lfs2_block_t *block, lfs2_off_t *off) {
+    const lfs2_cache_t *pcache, lfs2_cache_t *rcache,
+    lfs2_block_t head, lfs2_size_t size,
+    lfs2_size_t pos, lfs2_block_t *block, lfs2_off_t *off) {
     if (size == 0) {
         *block = LFS2_BLOCK_NULL;
         *off = 0;
         return 0;
     }
 
-    lfs2_off_t current = lfs2_ctz_index(lfs2, &(lfs2_off_t){size-1});
+    lfs2_off_t current = lfs2_ctz_index(lfs2, &(lfs2_off_t) {size - 1});
     lfs2_off_t target = lfs2_ctz_index(lfs2, &pos);
 
     while (current > target) {
         lfs2_size_t skip = lfs2_min(
-                lfs2_npw2(current-target+1) - 1,
-                lfs2_ctz(current));
+            lfs2_npw2(current - target + 1) - 1,
+            lfs2_ctz(current));
 
         int err = lfs2_bd_read(lfs2,
-                pcache, rcache, sizeof(head),
-                head, 4*skip, &head, sizeof(head));
+            pcache, rcache, sizeof(head),
+            head, 4 * skip, &head, sizeof(head));
         head = lfs2_fromle32(head);
         if (err) {
             return err;
@@ -2684,9 +2688,9 @@ static int lfs2_ctz_find(lfs2_t *lfs2,
 
 #ifndef LFS2_READONLY
 static int lfs2_ctz_extend(lfs2_t *lfs2,
-        lfs2_cache_t *pcache, lfs2_cache_t *rcache,
-        lfs2_block_t head, lfs2_size_t size,
-        lfs2_block_t *block, lfs2_off_t *off) {
+    lfs2_cache_t *pcache, lfs2_cache_t *rcache,
+    lfs2_block_t head, lfs2_size_t size,
+    lfs2_block_t *block, lfs2_off_t *off) {
     while (true) {
         // go ahead and grab a block
         lfs2_block_t nblock;
@@ -2719,15 +2723,15 @@ static int lfs2_ctz_extend(lfs2_t *lfs2,
                 for (lfs2_off_t i = 0; i < noff; i++) {
                     uint8_t data;
                     err = lfs2_bd_read(lfs2,
-                            NULL, rcache, noff-i,
-                            head, i, &data, 1);
+                        NULL, rcache, noff - i,
+                        head, i, &data, 1);
                     if (err) {
                         return err;
                     }
 
                     err = lfs2_bd_prog(lfs2,
-                            pcache, rcache, true,
-                            nblock, i, &data, 1);
+                        pcache, rcache, true,
+                        nblock, i, &data, 1);
                     if (err) {
                         if (err == LFS2_ERR_CORRUPT) {
                             goto relocate;
@@ -2748,7 +2752,7 @@ static int lfs2_ctz_extend(lfs2_t *lfs2,
             for (lfs2_off_t i = 0; i < skips; i++) {
                 nhead = lfs2_tole32(nhead);
                 err = lfs2_bd_prog(lfs2, pcache, rcache, true,
-                        nblock, 4*i, &nhead, 4);
+                    nblock, 4 * i, &nhead, 4);
                 nhead = lfs2_fromle32(nhead);
                 if (err) {
                     if (err == LFS2_ERR_CORRUPT) {
@@ -2757,10 +2761,10 @@ static int lfs2_ctz_extend(lfs2_t *lfs2,
                     return err;
                 }
 
-                if (i != skips-1) {
+                if (i != skips - 1) {
                     err = lfs2_bd_read(lfs2,
-                            NULL, rcache, sizeof(nhead),
-                            nhead, 4*i, &nhead, sizeof(nhead));
+                        NULL, rcache, sizeof(nhead),
+                        nhead, 4 * i, &nhead, sizeof(nhead));
                     nhead = lfs2_fromle32(nhead);
                     if (err) {
                         return err;
@@ -2769,12 +2773,12 @@ static int lfs2_ctz_extend(lfs2_t *lfs2,
             }
 
             *block = nblock;
-            *off = 4*skips;
+            *off = 4 * skips;
             return 0;
         }
 
-relocate:
-        LFS2_DEBUG("Bad block at 0x%"PRIx32, nblock);
+    relocate:
+        LFS2_DEBUG("Bad block at 0x%" PRIx32, nblock);
 
         // just clear cache and try a new block
         lfs2_cache_drop(lfs2, pcache);
@@ -2783,14 +2787,14 @@ static int lfs2_ctz_extend(lfs2_t *lfs2,
 #endif
 
 static int lfs2_ctz_traverse(lfs2_t *lfs2,
-        const lfs2_cache_t *pcache, lfs2_cache_t *rcache,
-        lfs2_block_t head, lfs2_size_t size,
-        int (*cb)(void*, lfs2_block_t), void *data) {
+    const lfs2_cache_t *pcache, lfs2_cache_t *rcache,
+    lfs2_block_t head, lfs2_size_t size,
+    int (*cb)(void *, lfs2_block_t), void *data) {
     if (size == 0) {
         return 0;
     }
 
-    lfs2_off_t index = lfs2_ctz_index(lfs2, &(lfs2_off_t){size-1});
+    lfs2_off_t index = lfs2_ctz_index(lfs2, &(lfs2_off_t) {size - 1});
 
     while (true) {
         int err = cb(data, head);
@@ -2805,22 +2809,22 @@ static int lfs2_ctz_traverse(lfs2_t *lfs2,
         lfs2_block_t heads[2];
         int count = 2 - (index & 1);
         err = lfs2_bd_read(lfs2,
-                pcache, rcache, count*sizeof(head),
-                head, 0, &heads, count*sizeof(head));
+            pcache, rcache, count * sizeof(head),
+            head, 0, &heads, count * sizeof(head));
         heads[0] = lfs2_fromle32(heads[0]);
         heads[1] = lfs2_fromle32(heads[1]);
         if (err) {
             return err;
         }
 
-        for (int i = 0; i < count-1; i++) {
+        for (int i = 0; i < count - 1; i++) {
             err = cb(data, heads[i]);
             if (err) {
                 return err;
             }
         }
 
-        head = heads[count-1];
+        head = heads[count - 1];
         index -= count;
     }
 }
@@ -2828,9 +2832,9 @@ static int lfs2_ctz_traverse(lfs2_t *lfs2,
 
 /// Top level file operations ///
 static int lfs2_file_rawopencfg(lfs2_t *lfs2, lfs2_file_t *file,
-        const char *path, int flags,
-        const struct lfs2_file_config *cfg) {
-#ifndef LFS2_READONLY
+    const char *path, int flags,
+    const struct lfs2_file_config *cfg) {
+    #ifndef LFS2_READONLY
     // deorphan if we haven't yet, needed at most once after poweron
     if ((flags & LFS2_O_WRONLY) == LFS2_O_WRONLY) {
         int err = lfs2_fs_forceconsistency(lfs2);
@@ -2838,9 +2842,9 @@ static int lfs2_file_rawopencfg(lfs2_t *lfs2, lfs2_file_t *file,
             return err;
         }
     }
-#else
+    #else
     LFS2_ASSERT((flags & LFS2_O_RDONLY) == LFS2_O_RDONLY);
-#endif
+    #endif
 
     // setup simple file details
     int err;
@@ -2861,11 +2865,11 @@ static int lfs2_file_rawopencfg(lfs2_t *lfs2, lfs2_file_t *file,
     file->type = LFS2_TYPE_REG;
     lfs2_mlist_append(lfs2, (struct lfs2_mlist *)file);
 
-#ifdef LFS2_READONLY
+    #ifdef LFS2_READONLY
     if (tag == LFS2_ERR_NOENT) {
         err = LFS2_ERR_NOENT;
         goto cleanup;
-#else
+    #else
     if (tag == LFS2_ERR_NOENT) {
         if (!(flags & LFS2_O_CREAT)) {
             err = LFS2_ERR_NOENT;
@@ -2881,9 +2885,9 @@ static int lfs2_file_rawopencfg(lfs2_t *lfs2, lfs2_file_t *file,
 
         // get next slot and create entry to remember name
         err = lfs2_dir_commit(lfs2, &file->m, LFS2_MKATTRS(
-                {LFS2_MKTAG(LFS2_TYPE_CREATE, file->id, 0), NULL},
-                {LFS2_MKTAG(LFS2_TYPE_REG, file->id, nlen), path},
-                {LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, file->id, 0), NULL}));
+            {LFS2_MKTAG(LFS2_TYPE_CREATE, file->id, 0), NULL},
+            {LFS2_MKTAG(LFS2_TYPE_REG, file->id, nlen), path},
+            {LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, file->id, 0), NULL}));
 
         // it may happen that the file name doesn't fit in the metadata blocks, e.g., a 256 byte file name will
         // not fit in a 128 byte block.
@@ -2896,20 +2900,20 @@ static int lfs2_file_rawopencfg(lfs2_t *lfs2, lfs2_file_t *file,
     } else if (flags & LFS2_O_EXCL) {
         err = LFS2_ERR_EXIST;
         goto cleanup;
-#endif
+        #endif
     } else if (lfs2_tag_type3(tag) != LFS2_TYPE_REG) {
         err = LFS2_ERR_ISDIR;
         goto cleanup;
-#ifndef LFS2_READONLY
+        #ifndef LFS2_READONLY
     } else if (flags & LFS2_O_TRUNC) {
         // truncate if requested
         tag = LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, file->id, 0);
         file->flags |= LFS2_F_DIRTY;
-#endif
+        #endif
     } else {
         // try to load what's on disk, if it's inlined we'll fix it later
         tag = lfs2_dir_get(lfs2, &file->m, LFS2_MKTAG(0x700, 0x3ff, 0),
-                LFS2_MKTAG(LFS2_TYPE_STRUCT, file->id, 8), &file->ctz);
+            LFS2_MKTAG(LFS2_TYPE_STRUCT, file->id, 8), &file->ctz);
         if (tag < 0) {
             err = tag;
             goto cleanup;
@@ -2922,17 +2926,17 @@ static int lfs2_file_rawopencfg(lfs2_t *lfs2, lfs2_file_t *file,
         // if opened for read / read-write operations
         if ((file->flags & LFS2_O_RDONLY) == LFS2_O_RDONLY) {
             lfs2_stag_t res = lfs2_dir_get(lfs2, &file->m,
-                    LFS2_MKTAG(0x7ff, 0x3ff, 0),
-                    LFS2_MKTAG(LFS2_TYPE_USERATTR + file->cfg->attrs[i].type,
-                        file->id, file->cfg->attrs[i].size),
-                        file->cfg->attrs[i].buffer);
+                LFS2_MKTAG(0x7ff, 0x3ff, 0),
+                LFS2_MKTAG(LFS2_TYPE_USERATTR + file->cfg->attrs[i].type,
+                    file->id, file->cfg->attrs[i].size),
+                file->cfg->attrs[i].buffer);
             if (res < 0 && res != LFS2_ERR_NOENT) {
                 err = res;
                 goto cleanup;
             }
         }
 
-#ifndef LFS2_READONLY
+        #ifndef LFS2_READONLY
         // if opened for write / read-write operations
         if ((file->flags & LFS2_O_WRONLY) == LFS2_O_WRONLY) {
             if (file->cfg->attrs[i].size > lfs2->attr_max) {
@@ -2942,7 +2946,7 @@ static int lfs2_file_rawopencfg(lfs2_t *lfs2, lfs2_file_t *file,
 
             file->flags |= LFS2_F_DIRTY;
         }
-#endif
+        #endif
     }
 
     // allocate buffer if needed
@@ -2971,10 +2975,10 @@ static int lfs2_file_rawopencfg(lfs2_t *lfs2, lfs2_file_t *file,
         // don't always read (may be new/trunc file)
         if (file->ctz.size > 0) {
             lfs2_stag_t res = lfs2_dir_get(lfs2, &file->m,
-                    LFS2_MKTAG(0x700, 0x3ff, 0),
-                    LFS2_MKTAG(LFS2_TYPE_STRUCT, file->id,
-                        lfs2_min(file->cache.size, 0x3fe)),
-                    file->cache.buffer);
+                LFS2_MKTAG(0x700, 0x3ff, 0),
+                LFS2_MKTAG(LFS2_TYPE_STRUCT, file->id,
+                    lfs2_min(file->cache.size, 0x3fe)),
+                file->cache.buffer);
             if (res < 0) {
                 err = res;
                 goto cleanup;
@@ -2986,16 +2990,16 @@ static int lfs2_file_rawopencfg(lfs2_t *lfs2, lfs2_file_t *file,
 
 cleanup:
     // clean up lingering resources
-#ifndef LFS2_READONLY
+    #ifndef LFS2_READONLY
     file->flags |= LFS2_F_ERRED;
-#endif
+    #endif
     lfs2_file_rawclose(lfs2, file);
     return err;
 }
 
 #ifndef LFS2_NO_MALLOC
 static int lfs2_file_rawopen(lfs2_t *lfs2, lfs2_file_t *file,
-        const char *path, int flags) {
+    const char *path, int flags) {
     static const struct lfs2_file_config defaults = {0};
     int err = lfs2_file_rawopencfg(lfs2, file, path, flags, &defaults);
     return err;
@@ -3003,14 +3007,14 @@ static int lfs2_file_rawopen(lfs2_t *lfs2, lfs2_file_t *file,
 #endif
 
 static int lfs2_file_rawclose(lfs2_t *lfs2, lfs2_file_t *file) {
-#ifndef LFS2_READONLY
+    #ifndef LFS2_READONLY
     int err = lfs2_file_rawsync(lfs2, file);
-#else
+    #else
     int err = 0;
-#endif
+    #endif
 
     // remove from list of mdirs
-    lfs2_mlist_remove(lfs2, (struct lfs2_mlist*)file);
+    lfs2_mlist_remove(lfs2, (struct lfs2_mlist *)file);
 
     // clean up memory
     if (!file->cfg->buffer) {
@@ -3044,26 +3048,26 @@ static int lfs2_file_relocate(lfs2_t *lfs2, lfs2_file_t *file) {
             uint8_t data;
             if (file->flags & LFS2_F_INLINE) {
                 err = lfs2_dir_getread(lfs2, &file->m,
-                        // note we evict inline files before they can be dirty
-                        NULL, &file->cache, file->off-i,
-                        LFS2_MKTAG(0xfff, 0x1ff, 0),
-                        LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, file->id, 0),
-                        i, &data, 1);
+                    // note we evict inline files before they can be dirty
+                    NULL, &file->cache, file->off - i,
+                    LFS2_MKTAG(0xfff, 0x1ff, 0),
+                    LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, file->id, 0),
+                    i, &data, 1);
                 if (err) {
                     return err;
                 }
             } else {
                 err = lfs2_bd_read(lfs2,
-                        &file->cache, &lfs2->rcache, file->off-i,
-                        file->block, i, &data, 1);
+                    &file->cache, &lfs2->rcache, file->off - i,
+                    file->block, i, &data, 1);
                 if (err) {
                     return err;
                 }
             }
 
             err = lfs2_bd_prog(lfs2,
-                    &lfs2->pcache, &lfs2->rcache, true,
-                    nblock, i, &data, 1);
+                &lfs2->pcache, &lfs2->rcache, true,
+                nblock, i, &data, 1);
             if (err) {
                 if (err == LFS2_ERR_CORRUPT) {
                     goto relocate;
@@ -3083,8 +3087,8 @@ static int lfs2_file_relocate(lfs2_t *lfs2, lfs2_file_t *file) {
         file->flags |= LFS2_F_WRITING;
         return 0;
 
-relocate:
-        LFS2_DEBUG("Bad block at 0x%"PRIx32, nblock);
+    relocate:
+        LFS2_DEBUG("Bad block at 0x%" PRIx32, nblock);
 
         // just clear cache and try a new block
         lfs2_cache_drop(lfs2, &lfs2->pcache);
@@ -3114,7 +3118,7 @@ static int lfs2_file_flush(lfs2_t *lfs2, lfs2_file_t *file) {
         file->flags &= ~LFS2_F_READING;
     }
 
-#ifndef LFS2_READONLY
+    #ifndef LFS2_READONLY
     if (file->flags & LFS2_F_WRITING) {
         lfs2_off_t pos = file->pos;
 
@@ -3162,8 +3166,8 @@ static int lfs2_file_flush(lfs2_t *lfs2, lfs2_file_t *file) {
 
                 break;
 
-relocate:
-                LFS2_DEBUG("Bad block at 0x%"PRIx32, file->block);
+            relocate:
+                LFS2_DEBUG("Bad block at 0x%" PRIx32, file->block);
                 err = lfs2_file_relocate(lfs2, file);
                 if (err) {
                     return err;
@@ -3181,7 +3185,7 @@ static int lfs2_file_flush(lfs2_t *lfs2, lfs2_file_t *file) {
 
         file->pos = pos;
     }
-#endif
+    #endif
 
     return 0;
 }
@@ -3201,7 +3205,7 @@ static int lfs2_file_rawsync(lfs2_t *lfs2, lfs2_file_t *file) {
 
 
     if ((file->flags & LFS2_F_DIRTY) &&
-            !lfs2_pair_isnull(file->m.pair)) {
+        !lfs2_pair_isnull(file->m.pair)) {
         // update dir entry
         uint16_t type;
         const void *buffer;
@@ -3224,9 +3228,9 @@ static int lfs2_file_rawsync(lfs2_t *lfs2, lfs2_file_t *file) {
 
         // commit file data and attributes
         err = lfs2_dir_commit(lfs2, &file->m, LFS2_MKATTRS(
-                {LFS2_MKTAG(type, file->id, size), buffer},
-                {LFS2_MKTAG(LFS2_FROM_USERATTRS, file->id,
-                    file->cfg->attr_count), file->cfg->attrs}));
+            {LFS2_MKTAG(type, file->id, size), buffer},
+            {LFS2_MKTAG(LFS2_FROM_USERATTRS, file->id,
+                file->cfg->attr_count), file->cfg->attrs}));
         if (err) {
             file->flags |= LFS2_F_ERRED;
             return err;
@@ -3239,8 +3243,13 @@ static int lfs2_file_rawsync(lfs2_t *lfs2, lfs2_file_t *file) {
 }
 #endif
 
+#ifdef MICROPY_DFU
+extern uint16_t *dfu_blks;
+extern uint16_t *dfu_offs;
+extern int dfu_nblks;
+#endif
 static lfs2_ssize_t lfs2_file_flushedread(lfs2_t *lfs2, lfs2_file_t *file,
-        void *buffer, lfs2_size_t size) {
+    void *buffer, lfs2_size_t size) {
     uint8_t *data = buffer;
     lfs2_size_t nsize = size;
 
@@ -3255,11 +3264,24 @@ static lfs2_ssize_t lfs2_file_flushedread(lfs2_t *lfs2, lfs2_file_t *file,
     while (nsize > 0) {
         // check if we need a new block
         if (!(file->flags & LFS2_F_READING) ||
-                file->off == lfs2->cfg->block_size) {
+            file->off == lfs2->cfg->block_size) {
             if (!(file->flags & LFS2_F_INLINE)) {
                 int err = lfs2_ctz_find(lfs2, NULL, &file->cache,
-                        file->ctz.head, file->ctz.size,
-                        file->pos, &file->block, &file->off);
+                    file->ctz.head, file->ctz.size,
+                    file->pos, &file->block, &file->off);
+                #ifdef MICROPY_DFU
+                if (dfu_nblks >= 0) {   // DFU hook
+                    if (dfu_blks != NULL && dfu_offs != NULL) {
+                        if (dfu_nblks == 0 || dfu_blks[dfu_nblks - 1] != file->block) {
+                            dfu_blks[dfu_nblks] = (uint16_t)file->block;
+                            dfu_offs[dfu_nblks] = (uint16_t)file->off;
+                            dfu_nblks++;
+                        }
+                    } else {
+                        dfu_nblks++;
+                    }
+                }
+                #endif
                 if (err) {
                     return err;
                 }
@@ -3275,17 +3297,17 @@ static lfs2_ssize_t lfs2_file_flushedread(lfs2_t *lfs2, lfs2_file_t *file,
         lfs2_size_t diff = lfs2_min(nsize, lfs2->cfg->block_size - file->off);
         if (file->flags & LFS2_F_INLINE) {
             int err = lfs2_dir_getread(lfs2, &file->m,
-                    NULL, &file->cache, lfs2->cfg->block_size,
-                    LFS2_MKTAG(0xfff, 0x1ff, 0),
-                    LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, file->id, 0),
-                    file->off, data, diff);
+                NULL, &file->cache, lfs2->cfg->block_size,
+                LFS2_MKTAG(0xfff, 0x1ff, 0),
+                LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, file->id, 0),
+                file->off, data, diff);
             if (err) {
                 return err;
             }
         } else {
             int err = lfs2_bd_read(lfs2,
-                    NULL, &file->cache, lfs2->cfg->block_size,
-                    file->block, file->off, data, diff);
+                NULL, &file->cache, lfs2->cfg->block_size,
+                file->block, file->off, data, diff);
             if (err) {
                 return err;
             }
@@ -3301,10 +3323,10 @@ static lfs2_ssize_t lfs2_file_flushedread(lfs2_t *lfs2, lfs2_file_t *file,
 }
 
 static lfs2_ssize_t lfs2_file_rawread(lfs2_t *lfs2, lfs2_file_t *file,
-        void *buffer, lfs2_size_t size) {
+    void *buffer, lfs2_size_t size) {
     LFS2_ASSERT((file->flags & LFS2_O_RDONLY) == LFS2_O_RDONLY);
 
-#ifndef LFS2_READONLY
+    #ifndef LFS2_READONLY
     if (file->flags & LFS2_F_WRITING) {
         // flush out any writes
         int err = lfs2_file_flush(lfs2, file);
@@ -3312,7 +3334,7 @@ static lfs2_ssize_t lfs2_file_rawread(lfs2_t *lfs2, lfs2_file_t *file,
             return err;
         }
     }
-#endif
+    #endif
 
     return lfs2_file_flushedread(lfs2, file, buffer, size);
 }
@@ -3320,16 +3342,16 @@ static lfs2_ssize_t lfs2_file_rawread(lfs2_t *lfs2, lfs2_file_t *file,
 
 #ifndef LFS2_READONLY
 static lfs2_ssize_t lfs2_file_flushedwrite(lfs2_t *lfs2, lfs2_file_t *file,
-        const void *buffer, lfs2_size_t size) {
+    const void *buffer, lfs2_size_t size) {
     const uint8_t *data = buffer;
     lfs2_size_t nsize = size;
 
     if ((file->flags & LFS2_F_INLINE) &&
-            lfs2_max(file->pos+nsize, file->ctz.size) >
-            lfs2_min(0x3fe, lfs2_min(
-                lfs2->cfg->cache_size,
-                (lfs2->cfg->metadata_max ?
-                    lfs2->cfg->metadata_max : lfs2->cfg->block_size) / 8))) {
+        lfs2_max(file->pos + nsize, file->ctz.size) >
+        lfs2_min(0x3fe, lfs2_min(
+            lfs2->cfg->cache_size,
+            (lfs2->cfg->metadata_max ?
+             lfs2->cfg->metadata_max : lfs2->cfg->block_size) / 8))) {
         // inline file doesn't fit anymore
         int err = lfs2_file_outline(lfs2, file);
         if (err) {
@@ -3341,13 +3363,13 @@ static lfs2_ssize_t lfs2_file_flushedwrite(lfs2_t *lfs2, lfs2_file_t *file,
     while (nsize > 0) {
         // check if we need a new block
         if (!(file->flags & LFS2_F_WRITING) ||
-                file->off == lfs2->cfg->block_size) {
+            file->off == lfs2->cfg->block_size) {
             if (!(file->flags & LFS2_F_INLINE)) {
                 if (!(file->flags & LFS2_F_WRITING) && file->pos > 0) {
                     // find out which block we're extending from
                     int err = lfs2_ctz_find(lfs2, NULL, &file->cache,
-                            file->ctz.head, file->ctz.size,
-                            file->pos-1, &file->block, &file->off);
+                        file->ctz.head, file->ctz.size,
+                        file->pos - 1, &file->block, &file->off);
                     if (err) {
                         file->flags |= LFS2_F_ERRED;
                         return err;
@@ -3360,8 +3382,8 @@ static lfs2_ssize_t lfs2_file_flushedwrite(lfs2_t *lfs2, lfs2_file_t *file,
                 // extend file with new blocks
                 lfs2_alloc_ack(lfs2);
                 int err = lfs2_ctz_extend(lfs2, &file->cache, &lfs2->rcache,
-                        file->block, file->pos,
-                        &file->block, &file->off);
+                    file->block, file->pos,
+                    &file->block, &file->off);
                 if (err) {
                     file->flags |= LFS2_F_ERRED;
                     return err;
@@ -3378,7 +3400,7 @@ static lfs2_ssize_t lfs2_file_flushedwrite(lfs2_t *lfs2, lfs2_file_t *file,
         lfs2_size_t diff = lfs2_min(nsize, lfs2->cfg->block_size - file->off);
         while (true) {
             int err = lfs2_bd_prog(lfs2, &file->cache, &lfs2->rcache, true,
-                    file->block, file->off, data, diff);
+                file->block, file->off, data, diff);
             if (err) {
                 if (err == LFS2_ERR_CORRUPT) {
                     goto relocate;
@@ -3388,7 +3410,7 @@ static lfs2_ssize_t lfs2_file_flushedwrite(lfs2_t *lfs2, lfs2_file_t *file,
             }
 
             break;
-relocate:
+        relocate:
             err = lfs2_file_relocate(lfs2, file);
             if (err) {
                 file->flags |= LFS2_F_ERRED;
@@ -3408,7 +3430,7 @@ static lfs2_ssize_t lfs2_file_flushedwrite(lfs2_t *lfs2, lfs2_file_t *file,
 }
 
 static lfs2_ssize_t lfs2_file_rawwrite(lfs2_t *lfs2, lfs2_file_t *file,
-        const void *buffer, lfs2_size_t size) {
+    const void *buffer, lfs2_size_t size) {
     LFS2_ASSERT((file->flags & LFS2_O_WRONLY) == LFS2_O_WRONLY);
 
     if (file->flags & LFS2_F_READING) {
@@ -3434,7 +3456,7 @@ static lfs2_ssize_t lfs2_file_rawwrite(lfs2_t *lfs2, lfs2_file_t *file,
         file->pos = file->ctz.size;
 
         while (file->pos < pos) {
-            lfs2_ssize_t res = lfs2_file_flushedwrite(lfs2, file, &(uint8_t){0}, 1);
+            lfs2_ssize_t res = lfs2_file_flushedwrite(lfs2, file, &(uint8_t) {0}, 1);
             if (res < 0) {
                 return res;
             }
@@ -3452,7 +3474,7 @@ static lfs2_ssize_t lfs2_file_rawwrite(lfs2_t *lfs2, lfs2_file_t *file,
 #endif
 
 static lfs2_soff_t lfs2_file_rawseek(lfs2_t *lfs2, lfs2_file_t *file,
-        lfs2_soff_t off, int whence) {
+    lfs2_soff_t off, int whence) {
     // find new pos
     lfs2_off_t npos = file->pos;
     if (whence == LFS2_SEEK_SET) {
@@ -3485,18 +3507,18 @@ static lfs2_soff_t lfs2_file_rawseek(lfs2_t *lfs2, lfs2_file_t *file,
     // if we're only reading and our new offset is still in the file's cache
     // we can avoid flushing and needing to reread the data
     if (
-#ifndef LFS2_READONLY
+        #ifndef LFS2_READONLY
         !(file->flags & LFS2_F_WRITING)
-#else
+        #else
         true
-#endif
-            ) {
-        int oindex = lfs2_ctz_index(lfs2, &(lfs2_off_t){file->pos});
+        #endif
+        ) {
+        int oindex = lfs2_ctz_index(lfs2, &(lfs2_off_t) {file->pos});
         lfs2_off_t noff = npos;
         int nindex = lfs2_ctz_index(lfs2, &noff);
         if (oindex == nindex
-                && noff >= file->cache.off
-                && noff < file->cache.off + file->cache.size) {
+            && noff >= file->cache.off
+            && noff < file->cache.off + file->cache.size) {
             file->pos = npos;
             file->off = noff;
             return npos;
@@ -3533,8 +3555,8 @@ static int lfs2_file_rawtruncate(lfs2_t *lfs2, lfs2_file_t *file, lfs2_off_t siz
 
         // lookup new head in ctz skip list
         err = lfs2_ctz_find(lfs2, NULL, &file->cache,
-                file->ctz.head, file->ctz.size,
-                size, &file->block, &file->off);
+            file->ctz.head, file->ctz.size,
+            size, &file->block, &file->off);
         if (err) {
             return err;
         }
@@ -3554,7 +3576,7 @@ static int lfs2_file_rawtruncate(lfs2_t *lfs2, lfs2_file_t *file, lfs2_off_t siz
 
         // fill with zeros
         while (file->pos < size) {
-            res = lfs2_file_rawwrite(lfs2, file, &(uint8_t){0}, 1);
+            res = lfs2_file_rawwrite(lfs2, file, &(uint8_t) {0}, 1);
             if (res < 0) {
                 return (int)res;
             }
@@ -3564,7 +3586,7 @@ static int lfs2_file_rawtruncate(lfs2_t *lfs2, lfs2_file_t *file, lfs2_off_t siz
     // restore pos
     lfs2_soff_t res = lfs2_file_rawseek(lfs2, file, pos, LFS2_SEEK_SET);
     if (res < 0) {
-      return (int)res;
+        return (int)res;
     }
 
     return 0;
@@ -3588,11 +3610,11 @@ static int lfs2_file_rawrewind(lfs2_t *lfs2, lfs2_file_t *file) {
 static lfs2_soff_t lfs2_file_rawsize(lfs2_t *lfs2, lfs2_file_t *file) {
     (void)lfs2;
 
-#ifndef LFS2_READONLY
+    #ifndef LFS2_READONLY
     if (file->flags & LFS2_F_WRITING) {
         return lfs2_max(file->pos, file->ctz.size);
     }
-#endif
+    #endif
 
     return file->ctz.size;
 }
@@ -3629,7 +3651,7 @@ static int lfs2_rawremove(lfs2_t *lfs2, const char *path) {
         // must be empty before removal
         lfs2_block_t pair[2];
         lfs2_stag_t res = lfs2_dir_get(lfs2, &cwd, LFS2_MKTAG(0x700, 0x3ff, 0),
-                LFS2_MKTAG(LFS2_TYPE_STRUCT, lfs2_tag_id(tag), 8), pair);
+            LFS2_MKTAG(LFS2_TYPE_STRUCT, lfs2_tag_id(tag), 8), pair);
         if (res < 0) {
             return (int)res;
         }
@@ -3659,7 +3681,7 @@ static int lfs2_rawremove(lfs2_t *lfs2, const char *path) {
 
     // delete the entry
     err = lfs2_dir_commit(lfs2, &cwd, LFS2_MKATTRS(
-            {LFS2_MKTAG(LFS2_TYPE_DELETE, lfs2_tag_id(tag), 0), NULL}));
+        {LFS2_MKTAG(LFS2_TYPE_DELETE, lfs2_tag_id(tag), 0), NULL}));
     if (err) {
         lfs2->mlist = dir.next;
         return err;
@@ -3708,7 +3730,7 @@ static int lfs2_rawrename(lfs2_t *lfs2, const char *oldpath, const char *newpath
     uint16_t newid;
     lfs2_stag_t prevtag = lfs2_dir_find(lfs2, &newcwd, &newpath, &newid);
     if ((prevtag < 0 || lfs2_tag_id(prevtag) == 0x3ff) &&
-            !(prevtag == LFS2_ERR_NOENT && newid != 0x3ff)) {
+        !(prevtag == LFS2_ERR_NOENT && newid != 0x3ff)) {
         return (prevtag < 0) ? (int)prevtag : LFS2_ERR_INVAL;
     }
 
@@ -3740,7 +3762,7 @@ static int lfs2_rawrename(lfs2_t *lfs2, const char *oldpath, const char *newpath
         // must be empty before removal
         lfs2_block_t prevpair[2];
         lfs2_stag_t res = lfs2_dir_get(lfs2, &newcwd, LFS2_MKTAG(0x700, 0x3ff, 0),
-                LFS2_MKTAG(LFS2_TYPE_STRUCT, newid, 8), prevpair);
+            LFS2_MKTAG(LFS2_TYPE_STRUCT, newid, 8), prevpair);
         if (res < 0) {
             return (int)res;
         }
@@ -3775,13 +3797,13 @@ static int lfs2_rawrename(lfs2_t *lfs2, const char *oldpath, const char *newpath
 
     // move over all attributes
     err = lfs2_dir_commit(lfs2, &newcwd, LFS2_MKATTRS(
-            {LFS2_MKTAG_IF(prevtag != LFS2_ERR_NOENT,
-                LFS2_TYPE_DELETE, newid, 0), NULL},
-            {LFS2_MKTAG(LFS2_TYPE_CREATE, newid, 0), NULL},
-            {LFS2_MKTAG(lfs2_tag_type3(oldtag), newid, strlen(newpath)), newpath},
-            {LFS2_MKTAG(LFS2_FROM_MOVE, newid, lfs2_tag_id(oldtag)), &oldcwd},
-            {LFS2_MKTAG_IF(samepair,
-                LFS2_TYPE_DELETE, newoldid, 0), NULL}));
+        {LFS2_MKTAG_IF(prevtag != LFS2_ERR_NOENT,
+            LFS2_TYPE_DELETE, newid, 0), NULL},
+        {LFS2_MKTAG(LFS2_TYPE_CREATE, newid, 0), NULL},
+        {LFS2_MKTAG(lfs2_tag_type3(oldtag), newid, strlen(newpath)), newpath},
+        {LFS2_MKTAG(LFS2_FROM_MOVE, newid, lfs2_tag_id(oldtag)), &oldcwd},
+        {LFS2_MKTAG_IF(samepair,
+            LFS2_TYPE_DELETE, newoldid, 0), NULL}));
     if (err) {
         lfs2->mlist = prevdir.next;
         return err;
@@ -3793,7 +3815,7 @@ static int lfs2_rawrename(lfs2_t *lfs2, const char *oldpath, const char *newpath
         // prep gstate and delete move id
         lfs2_fs_prepmove(lfs2, 0x3ff, NULL);
         err = lfs2_dir_commit(lfs2, &oldcwd, LFS2_MKATTRS(
-                {LFS2_MKTAG(LFS2_TYPE_DELETE, lfs2_tag_id(oldtag), 0), NULL}));
+            {LFS2_MKTAG(LFS2_TYPE_DELETE, lfs2_tag_id(oldtag), 0), NULL}));
         if (err) {
             lfs2->mlist = prevdir.next;
             return err;
@@ -3802,7 +3824,7 @@ static int lfs2_rawrename(lfs2_t *lfs2, const char *oldpath, const char *newpath
 
     lfs2->mlist = prevdir.next;
     if (prevtag != LFS2_ERR_NOENT
-            && lfs2_tag_type3(prevtag) == LFS2_TYPE_DIR) {
+        && lfs2_tag_type3(prevtag) == LFS2_TYPE_DIR) {
         // fix orphan
         err = lfs2_fs_preporphans(lfs2, -1);
         if (err) {
@@ -3825,7 +3847,7 @@ static int lfs2_rawrename(lfs2_t *lfs2, const char *oldpath, const char *newpath
 #endif
 
 static lfs2_ssize_t lfs2_rawgetattr(lfs2_t *lfs2, const char *path,
-        uint8_t type, void *buffer, lfs2_size_t size) {
+    uint8_t type, void *buffer, lfs2_size_t size) {
     lfs2_mdir_t cwd;
     lfs2_stag_t tag = lfs2_dir_find(lfs2, &cwd, &path, NULL);
     if (tag < 0) {
@@ -3843,9 +3865,9 @@ static lfs2_ssize_t lfs2_rawgetattr(lfs2_t *lfs2, const char *path,
     }
 
     tag = lfs2_dir_get(lfs2, &cwd, LFS2_MKTAG(0x7ff, 0x3ff, 0),
-            LFS2_MKTAG(LFS2_TYPE_USERATTR + type,
-                id, lfs2_min(size, lfs2->attr_max)),
-            buffer);
+        LFS2_MKTAG(LFS2_TYPE_USERATTR + type,
+            id, lfs2_min(size, lfs2->attr_max)),
+        buffer);
     if (tag < 0) {
         if (tag == LFS2_ERR_NOENT) {
             return LFS2_ERR_NOATTR;
@@ -3859,7 +3881,7 @@ static lfs2_ssize_t lfs2_rawgetattr(lfs2_t *lfs2, const char *path,
 
 #ifndef LFS2_READONLY
 static int lfs2_commitattr(lfs2_t *lfs2, const char *path,
-        uint8_t type, const void *buffer, lfs2_size_t size) {
+    uint8_t type, const void *buffer, lfs2_size_t size) {
     lfs2_mdir_t cwd;
     lfs2_stag_t tag = lfs2_dir_find(lfs2, &cwd, &path, NULL);
     if (tag < 0) {
@@ -3877,13 +3899,13 @@ static int lfs2_commitattr(lfs2_t *lfs2, const char *path,
     }
 
     return lfs2_dir_commit(lfs2, &cwd, LFS2_MKATTRS(
-            {LFS2_MKTAG(LFS2_TYPE_USERATTR + type, id, size), buffer}));
+        {LFS2_MKTAG(LFS2_TYPE_USERATTR + type, id, size), buffer}));
 }
 #endif
 
 #ifndef LFS2_READONLY
 static int lfs2_rawsetattr(lfs2_t *lfs2, const char *path,
-        uint8_t type, const void *buffer, lfs2_size_t size) {
+    uint8_t type, const void *buffer, lfs2_size_t size) {
     if (size > lfs2->attr_max) {
         return LFS2_ERR_NOSPC;
     }
@@ -3917,8 +3939,8 @@ static int lfs2_init(lfs2_t *lfs2, const struct lfs2_config *cfg) {
     LFS2_ASSERT(lfs2->cfg->block_size % lfs2->cfg->cache_size == 0);
 
     // check that the block size is large enough to fit ctz pointers
-    LFS2_ASSERT(4*lfs2_npw2(0xffffffff / (lfs2->cfg->block_size-2*4))
-            <= lfs2->cfg->block_size);
+    LFS2_ASSERT(4 * lfs2_npw2(0xffffffff / (lfs2->cfg->block_size - 2 * 4))
+        <= lfs2->cfg->block_size);
 
     // block_cycles = 0 is no longer supported.
     //
@@ -3958,7 +3980,7 @@ static int lfs2_init(lfs2_t *lfs2, const struct lfs2_config *cfg) {
     // setup lookahead, must be multiple of 64-bits, 32-bit aligned
     LFS2_ASSERT(lfs2->cfg->lookahead_size > 0);
     LFS2_ASSERT(lfs2->cfg->lookahead_size % 8 == 0 &&
-            (uintptr_t)lfs2->cfg->lookahead_buffer % 4 == 0);
+        (uintptr_t)lfs2->cfg->lookahead_buffer % 4 == 0);
     if (lfs2->cfg->lookahead_buffer) {
         lfs2->free.buffer = lfs2->cfg->lookahead_buffer;
     } else {
@@ -3995,12 +4017,12 @@ static int lfs2_init(lfs2_t *lfs2, const struct lfs2_config *cfg) {
     lfs2->root[1] = LFS2_BLOCK_NULL;
     lfs2->mlist = NULL;
     lfs2->seed = 0;
-    lfs2->gdisk = (lfs2_gstate_t){0};
-    lfs2->gstate = (lfs2_gstate_t){0};
-    lfs2->gdelta = (lfs2_gstate_t){0};
-#ifdef LFS2_MIGRATE
+    lfs2->gdisk = (lfs2_gstate_t) {0};
+    lfs2->gstate = (lfs2_gstate_t) {0};
+    lfs2->gdelta = (lfs2_gstate_t) {0};
+    #ifdef LFS2_MIGRATE
     lfs2->lfs21 = NULL;
-#endif
+    #endif
 
     return 0;
 
@@ -4038,8 +4060,8 @@ static int lfs2_rawformat(lfs2_t *lfs2, const struct lfs2_config *cfg) {
         // create free lookahead
         memset(lfs2->free.buffer, 0, lfs2->cfg->lookahead_size);
         lfs2->free.off = 0;
-        lfs2->free.size = lfs2_min(8*lfs2->cfg->lookahead_size,
-                lfs2->cfg->block_count);
+        lfs2->free.size = lfs2_min(8 * lfs2->cfg->lookahead_size,
+            lfs2->cfg->block_count);
         lfs2->free.i = 0;
         lfs2_alloc_ack(lfs2);
 
@@ -4052,20 +4074,20 @@ static int lfs2_rawformat(lfs2_t *lfs2, const struct lfs2_config *cfg) {
 
         // write one superblock
         lfs2_superblock_t superblock = {
-            .version     = LFS2_DISK_VERSION,
-            .block_size  = lfs2->cfg->block_size,
+            .version = LFS2_DISK_VERSION,
+            .block_size = lfs2->cfg->block_size,
             .block_count = lfs2->cfg->block_count,
-            .name_max    = lfs2->name_max,
-            .file_max    = lfs2->file_max,
-            .attr_max    = lfs2->attr_max,
+            .name_max = lfs2->name_max,
+            .file_max = lfs2->file_max,
+            .attr_max = lfs2->attr_max,
         };
 
         lfs2_superblock_tole32(&superblock);
         err = lfs2_dir_commit(lfs2, &root, LFS2_MKATTRS(
-                {LFS2_MKTAG(LFS2_TYPE_CREATE, 0, 0), NULL},
-                {LFS2_MKTAG(LFS2_TYPE_SUPERBLOCK, 0, 8), "littlefs"},
-                {LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, 0, sizeof(superblock)),
-                    &superblock}));
+            {LFS2_MKTAG(LFS2_TYPE_CREATE, 0, 0), NULL},
+            {LFS2_MKTAG(LFS2_TYPE_SUPERBLOCK, 0, 8), "littlefs"},
+            {LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, 0, sizeof(superblock)),
+             &superblock}));
         if (err) {
             goto cleanup;
         }
@@ -4079,7 +4101,7 @@ static int lfs2_rawformat(lfs2_t *lfs2, const struct lfs2_config *cfg) {
         }
 
         // sanity check that fetch works
-        err = lfs2_dir_fetch(lfs2, &root, (const lfs2_block_t[2]){0, 1});
+        err = lfs2_dir_fetch(lfs2, &root, (const lfs2_block_t[2]) {0, 1});
         if (err) {
             goto cleanup;
         }
@@ -4102,7 +4124,7 @@ static int lfs2_rawmount(lfs2_t *lfs2, const struct lfs2_config *cfg) {
     lfs2_mdir_t dir = {.tail = {0, 1}};
     lfs2_block_t cycle = 0;
     while (!lfs2_pair_isnull(dir.tail)) {
-        if (cycle >= lfs2->cfg->block_count/2) {
+        if (cycle >= lfs2->cfg->block_count / 2) {
             // loop detected
             err = LFS2_ERR_CORRUPT;
             goto cleanup;
@@ -4111,11 +4133,12 @@ static int lfs2_rawmount(lfs2_t *lfs2, const struct lfs2_config *cfg) {
 
         // fetch next block in tail list
         lfs2_stag_t tag = lfs2_dir_fetchmatch(lfs2, &dir, dir.tail,
-                LFS2_MKTAG(0x7ff, 0x3ff, 0),
-                LFS2_MKTAG(LFS2_TYPE_SUPERBLOCK, 0, 8),
-                NULL,
-                lfs2_dir_find_match, &(struct lfs2_dir_find_match){
-                    lfs2, "littlefs", 8});
+            LFS2_MKTAG(0x7ff, 0x3ff, 0),
+            LFS2_MKTAG(LFS2_TYPE_SUPERBLOCK, 0, 8),
+            NULL,
+            lfs2_dir_find_match, &(struct lfs2_dir_find_match) {
+            lfs2, "littlefs", 8
+        });
         if (tag < 0) {
             err = tag;
             goto cleanup;
@@ -4130,8 +4153,8 @@ static int lfs2_rawmount(lfs2_t *lfs2, const struct lfs2_config *cfg) {
             // grab superblock
             lfs2_superblock_t superblock;
             tag = lfs2_dir_get(lfs2, &dir, LFS2_MKTAG(0x7ff, 0x3ff, 0),
-                    LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, 0, sizeof(superblock)),
-                    &superblock);
+                LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, 0, sizeof(superblock)),
+                &superblock);
             if (tag < 0) {
                 err = tag;
                 goto cleanup;
@@ -4140,11 +4163,11 @@ static int lfs2_rawmount(lfs2_t *lfs2, const struct lfs2_config *cfg) {
 
             // check version
             uint16_t major_version = (0xffff & (superblock.version >> 16));
-            uint16_t minor_version = (0xffff & (superblock.version >>  0));
+            uint16_t minor_version = (0xffff & (superblock.version >> 0));
             if ((major_version != LFS2_DISK_VERSION_MAJOR ||
                  minor_version > LFS2_DISK_VERSION_MINOR)) {
-                LFS2_ERROR("Invalid version v%"PRIu16".%"PRIu16,
-                        major_version, minor_version);
+                LFS2_ERROR("Invalid version v%" PRIu16 ".%" PRIu16,
+                    major_version, minor_version);
                 err = LFS2_ERR_INVAL;
                 goto cleanup;
             }
@@ -4152,8 +4175,8 @@ static int lfs2_rawmount(lfs2_t *lfs2, const struct lfs2_config *cfg) {
             // check superblock configuration
             if (superblock.name_max) {
                 if (superblock.name_max > lfs2->name_max) {
-                    LFS2_ERROR("Unsupported name_max (%"PRIu32" > %"PRIu32")",
-                            superblock.name_max, lfs2->name_max);
+                    LFS2_ERROR("Unsupported name_max (%" PRIu32 " > %" PRIu32 ")",
+                        superblock.name_max, lfs2->name_max);
                     err = LFS2_ERR_INVAL;
                     goto cleanup;
                 }
@@ -4163,8 +4186,8 @@ static int lfs2_rawmount(lfs2_t *lfs2, const struct lfs2_config *cfg) {
 
             if (superblock.file_max) {
                 if (superblock.file_max > lfs2->file_max) {
-                    LFS2_ERROR("Unsupported file_max (%"PRIu32" > %"PRIu32")",
-                            superblock.file_max, lfs2->file_max);
+                    LFS2_ERROR("Unsupported file_max (%" PRIu32 " > %" PRIu32 ")",
+                        superblock.file_max, lfs2->file_max);
                     err = LFS2_ERR_INVAL;
                     goto cleanup;
                 }
@@ -4174,8 +4197,8 @@ static int lfs2_rawmount(lfs2_t *lfs2, const struct lfs2_config *cfg) {
 
             if (superblock.attr_max) {
                 if (superblock.attr_max > lfs2->attr_max) {
-                    LFS2_ERROR("Unsupported attr_max (%"PRIu32" > %"PRIu32")",
-                            superblock.attr_max, lfs2->attr_max);
+                    LFS2_ERROR("Unsupported attr_max (%" PRIu32 " > %" PRIu32 ")",
+                        superblock.attr_max, lfs2->attr_max);
                     err = LFS2_ERR_INVAL;
                     goto cleanup;
                 }
@@ -4184,15 +4207,15 @@ static int lfs2_rawmount(lfs2_t *lfs2, const struct lfs2_config *cfg) {
             }
 
             if (superblock.block_count != lfs2->cfg->block_count) {
-                LFS2_ERROR("Invalid block count (%"PRIu32" != %"PRIu32")",
-                        superblock.block_count, lfs2->cfg->block_count);
+                LFS2_ERROR("Invalid block count (%" PRIu32 " != %" PRIu32 ")",
+                    superblock.block_count, lfs2->cfg->block_count);
                 err = LFS2_ERR_INVAL;
                 goto cleanup;
             }
 
             if (superblock.block_size != lfs2->cfg->block_size) {
-                LFS2_ERROR("Invalid block size (%"PRIu32" != %"PRIu32")",
-                        superblock.block_count, lfs2->cfg->block_count);
+                LFS2_ERROR("Invalid block size (%" PRIu32 " != %" PRIu32 ")",
+                    superblock.block_count, lfs2->cfg->block_count);
                 err = LFS2_ERR_INVAL;
                 goto cleanup;
             }
@@ -4213,10 +4236,10 @@ static int lfs2_rawmount(lfs2_t *lfs2, const struct lfs2_config *cfg) {
 
     // update littlefs with gstate
     if (!lfs2_gstate_iszero(&lfs2->gstate)) {
-        LFS2_DEBUG("Found pending gstate 0x%08"PRIx32"%08"PRIx32"%08"PRIx32,
-                lfs2->gstate.tag,
-                lfs2->gstate.pair[0],
-                lfs2->gstate.pair[1]);
+        LFS2_DEBUG("Found pending gstate 0x%08" PRIx32 "%08" PRIx32 "%08" PRIx32,
+            lfs2->gstate.tag,
+            lfs2->gstate.pair[0],
+            lfs2->gstate.pair[1]);
     }
     lfs2->gstate.tag += !lfs2_tag_isvalid(lfs2->gstate.tag);
     lfs2->gdisk = lfs2->gstate;
@@ -4240,12 +4263,12 @@ static int lfs2_rawunmount(lfs2_t *lfs2) {
 
 /// Filesystem filesystem operations ///
 int lfs2_fs_rawtraverse(lfs2_t *lfs2,
-        int (*cb)(void *data, lfs2_block_t block), void *data,
-        bool includeorphans) {
+    int (*cb)(void *data, lfs2_block_t block), void *data,
+    bool includeorphans) {
     // iterate over metadata pairs
     lfs2_mdir_t dir = {.tail = {0, 1}};
 
-#ifdef LFS2_MIGRATE
+    #ifdef LFS2_MIGRATE
     // also consider v1 blocks during migration
     if (lfs2->lfs21) {
         int err = lfs21_traverse(lfs2, cb, data);
@@ -4256,11 +4279,11 @@ int lfs2_fs_rawtraverse(lfs2_t *lfs2,
         dir.tail[0] = lfs2->root[0];
         dir.tail[1] = lfs2->root[1];
     }
-#endif
+    #endif
 
     lfs2_block_t cycle = 0;
     while (!lfs2_pair_isnull(dir.tail)) {
-        if (cycle >= lfs2->cfg->block_count/2) {
+        if (cycle >= lfs2->cfg->block_count / 2) {
             // loop detected
             return LFS2_ERR_CORRUPT;
         }
@@ -4282,7 +4305,7 @@ int lfs2_fs_rawtraverse(lfs2_t *lfs2,
         for (uint16_t id = 0; id < dir.count; id++) {
             struct lfs2_ctz ctz;
             lfs2_stag_t tag = lfs2_dir_get(lfs2, &dir, LFS2_MKTAG(0x700, 0x3ff, 0),
-                    LFS2_MKTAG(LFS2_TYPE_STRUCT, id, sizeof(ctz)), &ctz);
+                LFS2_MKTAG(LFS2_TYPE_STRUCT, id, sizeof(ctz)), &ctz);
             if (tag < 0) {
                 if (tag == LFS2_ERR_NOENT) {
                     continue;
@@ -4293,12 +4316,12 @@ int lfs2_fs_rawtraverse(lfs2_t *lfs2,
 
             if (lfs2_tag_type3(tag) == LFS2_TYPE_CTZSTRUCT) {
                 err = lfs2_ctz_traverse(lfs2, NULL, &lfs2->rcache,
-                        ctz.head, ctz.size, cb, data);
+                    ctz.head, ctz.size, cb, data);
                 if (err) {
                     return err;
                 }
             } else if (includeorphans &&
-                    lfs2_tag_type3(tag) == LFS2_TYPE_DIRSTRUCT) {
+                       lfs2_tag_type3(tag) == LFS2_TYPE_DIRSTRUCT) {
                 for (int i = 0; i < 2; i++) {
                     err = cb(data, (&ctz.head)[i]);
                     if (err) {
@@ -4309,16 +4332,16 @@ int lfs2_fs_rawtraverse(lfs2_t *lfs2,
         }
     }
 
-#ifndef LFS2_READONLY
+    #ifndef LFS2_READONLY
     // iterate over any open files
-    for (lfs2_file_t *f = (lfs2_file_t*)lfs2->mlist; f; f = f->next) {
+    for (lfs2_file_t *f = (lfs2_file_t *)lfs2->mlist; f; f = f->next) {
         if (f->type != LFS2_TYPE_REG) {
             continue;
         }
 
         if ((f->flags & LFS2_F_DIRTY) && !(f->flags & LFS2_F_INLINE)) {
             int err = lfs2_ctz_traverse(lfs2, &f->cache, &lfs2->rcache,
-                    f->ctz.head, f->ctz.size, cb, data);
+                f->ctz.head, f->ctz.size, cb, data);
             if (err) {
                 return err;
             }
@@ -4326,26 +4349,26 @@ int lfs2_fs_rawtraverse(lfs2_t *lfs2,
 
         if ((f->flags & LFS2_F_WRITING) && !(f->flags & LFS2_F_INLINE)) {
             int err = lfs2_ctz_traverse(lfs2, &f->cache, &lfs2->rcache,
-                    f->block, f->pos, cb, data);
+                f->block, f->pos, cb, data);
             if (err) {
                 return err;
             }
         }
     }
-#endif
+    #endif
 
     return 0;
 }
 
 #ifndef LFS2_READONLY
 static int lfs2_fs_pred(lfs2_t *lfs2,
-        const lfs2_block_t pair[2], lfs2_mdir_t *pdir) {
+    const lfs2_block_t pair[2], lfs2_mdir_t *pdir) {
     // iterate over all directory directory entries
     pdir->tail[0] = 0;
     pdir->tail[1] = 1;
     lfs2_block_t cycle = 0;
     while (!lfs2_pair_isnull(pdir->tail)) {
-        if (cycle >= lfs2->cfg->block_count/2) {
+        if (cycle >= lfs2->cfg->block_count / 2) {
             // loop detected
             return LFS2_ERR_CORRUPT;
         }
@@ -4374,7 +4397,7 @@ struct lfs2_fs_parent_match {
 
 #ifndef LFS2_READONLY
 static int lfs2_fs_parent_match(void *data,
-        lfs2_tag_t tag, const void *buffer) {
+    lfs2_tag_t tag, const void *buffer) {
     struct lfs2_fs_parent_match *find = data;
     lfs2_t *lfs2 = find->lfs2;
     const struct lfs2_diskoff *disk = buffer;
@@ -4382,8 +4405,8 @@ static int lfs2_fs_parent_match(void *data,
 
     lfs2_block_t child[2];
     int err = lfs2_bd_read(lfs2,
-            &lfs2->pcache, &lfs2->rcache, lfs2->cfg->block_size,
-            disk->block, disk->off, &child, sizeof(child));
+        &lfs2->pcache, &lfs2->rcache, lfs2->cfg->block_size,
+        disk->block, disk->off, &child, sizeof(child));
     if (err) {
         return err;
     }
@@ -4395,24 +4418,25 @@ static int lfs2_fs_parent_match(void *data,
 
 #ifndef LFS2_READONLY
 static lfs2_stag_t lfs2_fs_parent(lfs2_t *lfs2, const lfs2_block_t pair[2],
-        lfs2_mdir_t *parent) {
+    lfs2_mdir_t *parent) {
     // use fetchmatch with callback to find pairs
     parent->tail[0] = 0;
     parent->tail[1] = 1;
     lfs2_block_t cycle = 0;
     while (!lfs2_pair_isnull(parent->tail)) {
-        if (cycle >= lfs2->cfg->block_count/2) {
+        if (cycle >= lfs2->cfg->block_count / 2) {
             // loop detected
             return LFS2_ERR_CORRUPT;
         }
         cycle += 1;
 
         lfs2_stag_t tag = lfs2_dir_fetchmatch(lfs2, parent, parent->tail,
-                LFS2_MKTAG(0x7ff, 0, 0x3ff),
-                LFS2_MKTAG(LFS2_TYPE_DIRSTRUCT, 0, 8),
-                NULL,
-                lfs2_fs_parent_match, &(struct lfs2_fs_parent_match){
-                    lfs2, {pair[0], pair[1]}});
+            LFS2_MKTAG(0x7ff, 0, 0x3ff),
+            LFS2_MKTAG(LFS2_TYPE_DIRSTRUCT, 0, 8),
+            NULL,
+            lfs2_fs_parent_match, &(struct lfs2_fs_parent_match) {
+            lfs2, {pair[0], pair[1]}
+        });
         if (tag && tag != LFS2_ERR_NOENT) {
             return tag;
         }
@@ -4427,7 +4451,7 @@ static int lfs2_fs_preporphans(lfs2_t *lfs2, int8_t orphans) {
     LFS2_ASSERT(lfs2_tag_size(lfs2->gstate.tag) > 0 || orphans >= 0);
     lfs2->gstate.tag += orphans;
     lfs2->gstate.tag = ((lfs2->gstate.tag & ~LFS2_MKTAG(0x800, 0, 0)) |
-            ((uint32_t)lfs2_gstate_hasorphans(&lfs2->gstate) << 31));
+        ((uint32_t)lfs2_gstate_hasorphans(&lfs2->gstate) << 31));
 
     return 0;
 }
@@ -4435,9 +4459,9 @@ static int lfs2_fs_preporphans(lfs2_t *lfs2, int8_t orphans) {
 
 #ifndef LFS2_READONLY
 static void lfs2_fs_prepmove(lfs2_t *lfs2,
-        uint16_t id, const lfs2_block_t pair[2]) {
+    uint16_t id, const lfs2_block_t pair[2]) {
     lfs2->gstate.tag = ((lfs2->gstate.tag & ~LFS2_MKTAG(0x7ff, 0x3ff, 0)) |
-            ((id != 0x3ff) ? LFS2_MKTAG(LFS2_TYPE_DELETE, id, 0) : 0));
+        ((id != 0x3ff) ? LFS2_MKTAG(LFS2_TYPE_DELETE, id, 0) : 0));
     lfs2->gstate.pair[0] = (id != 0x3ff) ? pair[0] : 0;
     lfs2->gstate.pair[1] = (id != 0x3ff) ? pair[1] : 0;
 }
@@ -4450,10 +4474,10 @@ static int lfs2_fs_demove(lfs2_t *lfs2) {
     }
 
     // Fix bad moves
-    LFS2_DEBUG("Fixing move {0x%"PRIx32", 0x%"PRIx32"} 0x%"PRIx16,
-            lfs2->gdisk.pair[0],
-            lfs2->gdisk.pair[1],
-            lfs2_tag_id(lfs2->gdisk.tag));
+    LFS2_DEBUG("Fixing move {0x%" PRIx32 ", 0x%" PRIx32 "} 0x%" PRIx16,
+        lfs2->gdisk.pair[0],
+        lfs2->gdisk.pair[1],
+        lfs2_tag_id(lfs2->gdisk.tag));
 
     // fetch and delete the moved entry
     lfs2_mdir_t movedir;
@@ -4466,7 +4490,7 @@ static int lfs2_fs_demove(lfs2_t *lfs2) {
     uint16_t moveid = lfs2_tag_id(lfs2->gdisk.tag);
     lfs2_fs_prepmove(lfs2, 0x3ff, NULL);
     err = lfs2_dir_commit(lfs2, &movedir, LFS2_MKATTRS(
-            {LFS2_MKTAG(LFS2_TYPE_DELETE, moveid, 0), NULL}));
+        {LFS2_MKTAG(LFS2_TYPE_DELETE, moveid, 0), NULL}));
     if (err) {
         return err;
     }
@@ -4509,8 +4533,8 @@ static int lfs2_fs_deorphan(lfs2_t *lfs2, bool powerloss) {
                 // during operations such as lfs2_mkdir
                 if (tag == LFS2_ERR_NOENT && powerloss) {
                     // we are an orphan
-                    LFS2_DEBUG("Fixing orphan {0x%"PRIx32", 0x%"PRIx32"}",
-                            pdir.tail[0], pdir.tail[1]);
+                    LFS2_DEBUG("Fixing orphan {0x%" PRIx32 ", 0x%" PRIx32 "}",
+                        pdir.tail[0], pdir.tail[1]);
 
                     // steal state
                     err = lfs2_dir_getgstate(lfs2, &dir, &lfs2->gdelta);
@@ -4521,8 +4545,8 @@ static int lfs2_fs_deorphan(lfs2_t *lfs2, bool powerloss) {
                     // steal tail
                     lfs2_pair_tole32(dir.tail);
                     int state = lfs2_dir_orphaningcommit(lfs2, &pdir, LFS2_MKATTRS(
-                            {LFS2_MKTAG(LFS2_TYPE_TAIL + dir.split, 0x3ff, 8),
-                                dir.tail}));
+                        {LFS2_MKTAG(LFS2_TYPE_TAIL + dir.split, 0x3ff, 8),
+                         dir.tail}));
                     lfs2_pair_fromle32(dir.tail);
                     if (state < 0) {
                         return state;
@@ -4542,7 +4566,7 @@ static int lfs2_fs_deorphan(lfs2_t *lfs2, bool powerloss) {
                 if (tag != LFS2_ERR_NOENT) {
                     lfs2_block_t pair[2];
                     lfs2_stag_t state = lfs2_dir_get(lfs2, &parent,
-                            LFS2_MKTAG(0x7ff, 0x3ff, 0), tag, pair);
+                        LFS2_MKTAG(0x7ff, 0x3ff, 0), tag, pair);
                     if (state < 0) {
                         return state;
                     }
@@ -4551,9 +4575,9 @@ static int lfs2_fs_deorphan(lfs2_t *lfs2, bool powerloss) {
                     if (!lfs2_pair_sync(pair, pdir.tail)) {
                         // we have desynced
                         LFS2_DEBUG("Fixing half-orphan "
-                                "{0x%"PRIx32", 0x%"PRIx32"} "
-                                "-> {0x%"PRIx32", 0x%"PRIx32"}",
-                                pdir.tail[0], pdir.tail[1], pair[0], pair[1]);
+                            "{0x%" PRIx32 ", 0x%" PRIx32 "} "
+                            "-> {0x%" PRIx32 ", 0x%" PRIx32 "}",
+                            pdir.tail[0], pdir.tail[1], pair[0], pair[1]);
 
                         // fix pending move in this pair? this looks like an
                         // optimization but is in fact _required_ since
@@ -4562,17 +4586,17 @@ static int lfs2_fs_deorphan(lfs2_t *lfs2, bool powerloss) {
                         if (lfs2_gstate_hasmovehere(&lfs2->gstate, pdir.pair)) {
                             moveid = lfs2_tag_id(lfs2->gstate.tag);
                             LFS2_DEBUG("Fixing move while fixing orphans "
-                                    "{0x%"PRIx32", 0x%"PRIx32"} 0x%"PRIx16"\n",
-                                    pdir.pair[0], pdir.pair[1], moveid);
+                                "{0x%" PRIx32 ", 0x%" PRIx32 "} 0x%" PRIx16 "\n",
+                                pdir.pair[0], pdir.pair[1], moveid);
                             lfs2_fs_prepmove(lfs2, 0x3ff, NULL);
                         }
 
                         lfs2_pair_tole32(pair);
                         state = lfs2_dir_orphaningcommit(lfs2, &pdir, LFS2_MKATTRS(
-                                {LFS2_MKTAG_IF(moveid != 0x3ff,
-                                    LFS2_TYPE_DELETE, moveid, 0), NULL},
-                                {LFS2_MKTAG(LFS2_TYPE_SOFTTAIL, 0x3ff, 8),
-                                    pair}));
+                            {LFS2_MKTAG_IF(moveid != 0x3ff,
+                                LFS2_TYPE_DELETE, moveid, 0), NULL},
+                            {LFS2_MKTAG(LFS2_TYPE_SOFTTAIL, 0x3ff, 8),
+                             pair}));
                         lfs2_pair_fromle32(pair);
                         if (state < 0) {
                             return state;
@@ -4597,8 +4621,8 @@ static int lfs2_fs_deorphan(lfs2_t *lfs2, bool powerloss) {
 
     // mark orphans as fixed
     return lfs2_fs_preporphans(lfs2, -lfs2_min(
-            lfs2_gstate_getorphans(&lfs2->gstate),
-            found));
+        lfs2_gstate_getorphans(&lfs2->gstate),
+        found));
 }
 #endif
 
@@ -4645,14 +4669,14 @@ static lfs2_ssize_t lfs2_fs_rawsize(lfs2_t *lfs2) {
 // Minor (bottom-nibble), incremented on feature additions
 #define LFS21_VERSION 0x00010007
 #define LFS21_VERSION_MAJOR (0xffff & (LFS21_VERSION >> 16))
-#define LFS21_VERSION_MINOR (0xffff & (LFS21_VERSION >>  0))
+#define LFS21_VERSION_MINOR (0xffff & (LFS21_VERSION >> 0))
 
 // Version of On-disk data structures
 // Major (top-nibble), incremented on backwards incompatible changes
 // Minor (bottom-nibble), incremented on feature additions
 #define LFS21_DISK_VERSION 0x00010001
 #define LFS21_DISK_VERSION_MAJOR (0xffff & (LFS21_DISK_VERSION >> 16))
-#define LFS21_DISK_VERSION_MINOR (0xffff & (LFS21_DISK_VERSION >>  0))
+#define LFS21_DISK_VERSION_MINOR (0xffff & (LFS21_DISK_VERSION >> 0))
 
 
 /// v1 Definitions ///
@@ -4724,18 +4748,18 @@ static void lfs21_crc(uint32_t *crc, const void *buffer, size_t size) {
 }
 
 static int lfs21_bd_read(lfs2_t *lfs2, lfs2_block_t block,
-        lfs2_off_t off, void *buffer, lfs2_size_t size) {
+    lfs2_off_t off, void *buffer, lfs2_size_t size) {
     // if we ever do more than writes to alternating pairs,
     // this may need to consider pcache
     return lfs2_bd_read(lfs2, &lfs2->pcache, &lfs2->rcache, size,
-            block, off, buffer, size);
+        block, off, buffer, size);
 }
 
 static int lfs21_bd_crc(lfs2_t *lfs2, lfs2_block_t block,
-        lfs2_off_t off, lfs2_size_t size, uint32_t *crc) {
+    lfs2_off_t off, lfs2_size_t size, uint32_t *crc) {
     for (lfs2_off_t i = 0; i < size; i++) {
         uint8_t c;
-        int err = lfs21_bd_read(lfs2, block, off+i, &c, 1);
+        int err = lfs21_bd_read(lfs2, block, off + i, &c, 1);
         if (err) {
             return err;
         }
@@ -4749,15 +4773,15 @@ static int lfs21_bd_crc(lfs2_t *lfs2, lfs2_block_t block,
 
 /// Endian swapping functions ///
 static void lfs21_dir_fromle32(struct lfs21_disk_dir *d) {
-    d->rev     = lfs2_fromle32(d->rev);
-    d->size    = lfs2_fromle32(d->size);
+    d->rev = lfs2_fromle32(d->rev);
+    d->size = lfs2_fromle32(d->size);
     d->tail[0] = lfs2_fromle32(d->tail[0]);
     d->tail[1] = lfs2_fromle32(d->tail[1]);
 }
 
 static void lfs21_dir_tole32(struct lfs21_disk_dir *d) {
-    d->rev     = lfs2_tole32(d->rev);
-    d->size    = lfs2_tole32(d->size);
+    d->rev = lfs2_tole32(d->rev);
+    d->size = lfs2_tole32(d->size);
     d->tail[0] = lfs2_tole32(d->tail[0]);
     d->tail[1] = lfs2_tole32(d->tail[1]);
 }
@@ -4773,11 +4797,11 @@ static void lfs21_entry_tole32(struct lfs21_disk_entry *d) {
 }
 
 static void lfs21_superblock_fromle32(struct lfs21_disk_superblock *d) {
-    d->root[0]     = lfs2_fromle32(d->root[0]);
-    d->root[1]     = lfs2_fromle32(d->root[1]);
-    d->block_size  = lfs2_fromle32(d->block_size);
+    d->root[0] = lfs2_fromle32(d->root[0]);
+    d->root[1] = lfs2_fromle32(d->root[1]);
+    d->block_size = lfs2_fromle32(d->block_size);
     d->block_count = lfs2_fromle32(d->block_count);
-    d->version     = lfs2_fromle32(d->version);
+    d->version = lfs2_fromle32(d->version);
 }
 
 
@@ -4787,7 +4811,7 @@ static inline lfs2_size_t lfs21_entry_size(const lfs21_entry_t *entry) {
 }
 
 static int lfs21_dir_fetch(lfs2_t *lfs2,
-        lfs21_dir_t *dir, const lfs2_block_t pair[2]) {
+    lfs21_dir_t *dir, const lfs2_block_t pair[2]) {
     // copy out pair, otherwise may be aliasing dir
     const lfs2_block_t tpair[2] = {pair[0], pair[1]};
     bool valid = false;
@@ -4808,7 +4832,7 @@ static int lfs21_dir_fetch(lfs2_t *lfs2,
             continue;
         }
 
-        if ((0x7fffffff & test.size) < sizeof(test)+4 ||
+        if ((0x7fffffff & test.size) < sizeof(test) + 4 ||
             (0x7fffffff & test.size) > lfs2->cfg->block_size) {
             continue;
         }
@@ -4818,7 +4842,7 @@ static int lfs21_dir_fetch(lfs2_t *lfs2,
         lfs21_crc(&crc, &test, sizeof(test));
         lfs21_dir_fromle32(&test);
         err = lfs21_bd_crc(lfs2, tpair[i], sizeof(test),
-                (0x7fffffff & test.size) - sizeof(test), &crc);
+            (0x7fffffff & test.size) - sizeof(test), &crc);
         if (err) {
             if (err == LFS2_ERR_CORRUPT) {
                 continue;
@@ -4833,15 +4857,15 @@ static int lfs21_dir_fetch(lfs2_t *lfs2,
         valid = true;
 
         // setup dir in case it's valid
-        dir->pair[0] = tpair[(i+0) % 2];
-        dir->pair[1] = tpair[(i+1) % 2];
+        dir->pair[0] = tpair[(i + 0) % 2];
+        dir->pair[1] = tpair[(i + 1) % 2];
         dir->off = sizeof(dir->d);
         dir->d = test;
     }
 
     if (!valid) {
-        LFS2_ERROR("Corrupted dir pair at {0x%"PRIx32", 0x%"PRIx32"}",
-                tpair[0], tpair[1]);
+        LFS2_ERROR("Corrupted dir pair at {0x%" PRIx32 ", 0x%" PRIx32 "}",
+            tpair[0], tpair[1]);
         return LFS2_ERR_CORRUPT;
     }
 
@@ -4849,7 +4873,7 @@ static int lfs21_dir_fetch(lfs2_t *lfs2,
 }
 
 static int lfs21_dir_next(lfs2_t *lfs2, lfs21_dir_t *dir, lfs21_entry_t *entry) {
-    while (dir->off + sizeof(entry->d) > (0x7fffffff & dir->d.size)-4) {
+    while (dir->off + sizeof(entry->d) > (0x7fffffff & dir->d.size) - 4) {
         if (!(0x80000000 & dir->d.size)) {
             entry->off = dir->off;
             return LFS2_ERR_NOENT;
@@ -4865,7 +4889,7 @@ static int lfs21_dir_next(lfs2_t *lfs2, lfs21_dir_t *dir, lfs21_entry_t *entry)
     }
 
     int err = lfs21_bd_read(lfs2, dir->pair[0], dir->off,
-            &entry->d, sizeof(entry->d));
+        &entry->d, sizeof(entry->d));
     lfs21_entry_fromle32(&entry->d);
     if (err) {
         return err;
@@ -4878,7 +4902,7 @@ static int lfs21_dir_next(lfs2_t *lfs2, lfs21_dir_t *dir, lfs21_entry_t *entry)
 }
 
 /// littlefs v1 specific operations ///
-int lfs21_traverse(lfs2_t *lfs2, int (*cb)(void*, lfs2_block_t), void *data) {
+int lfs21_traverse(lfs2_t *lfs2, int (*cb)(void *, lfs2_block_t), void *data) {
     if (lfs2_pair_isnull(lfs2->lfs21->root)) {
         return 0;
     }
@@ -4902,9 +4926,9 @@ int lfs21_traverse(lfs2_t *lfs2, int (*cb)(void*, lfs2_block_t), void *data) {
         }
 
         // iterate over contents
-        while (dir.off + sizeof(entry.d) <= (0x7fffffff & dir.d.size)-4) {
+        while (dir.off + sizeof(entry.d) <= (0x7fffffff & dir.d.size) - 4) {
             err = lfs21_bd_read(lfs2, dir.pair[0], dir.off,
-                    &entry.d, sizeof(entry.d));
+                &entry.d, sizeof(entry.d));
             lfs21_entry_fromle32(&entry.d);
             if (err) {
                 return err;
@@ -4913,7 +4937,7 @@ int lfs21_traverse(lfs2_t *lfs2, int (*cb)(void*, lfs2_block_t), void *data) {
             dir.off += lfs21_entry_size(&entry);
             if ((0x70 & entry.d.type) == (0x70 & LFS21_TYPE_REG)) {
                 err = lfs2_ctz_traverse(lfs2, NULL, &lfs2->rcache,
-                        entry.d.u.file.head, entry.d.u.file.size, cb, data);
+                    entry.d.u.file.head, entry.d.u.file.size, cb, data);
                 if (err) {
                     return err;
                 }
@@ -4921,7 +4945,7 @@ int lfs21_traverse(lfs2_t *lfs2, int (*cb)(void*, lfs2_block_t), void *data) {
         }
 
         // we also need to check if we contain a threaded v2 directory
-        lfs2_mdir_t dir2 = {.split=true, .tail={cwd[0], cwd[1]}};
+        lfs2_mdir_t dir2 = {.split = true, .tail = {cwd[0], cwd[1]}};
         while (dir2.split) {
             err = lfs2_dir_fetch(lfs2, &dir2, dir2.tail);
             if (err) {
@@ -4954,7 +4978,7 @@ static int lfs21_moved(lfs2_t *lfs2, const void *e) {
 
     // skip superblock
     lfs21_dir_t cwd;
-    int err = lfs21_dir_fetch(lfs2, &cwd, (const lfs2_block_t[2]){0, 1});
+    int err = lfs21_dir_fetch(lfs2, &cwd, (const lfs2_block_t[2]) {0, 1});
     if (err) {
         return err;
     }
@@ -4978,7 +5002,7 @@ static int lfs21_moved(lfs2_t *lfs2, const void *e) {
             }
 
             if (!(0x80 & entry.d.type) &&
-                 memcmp(&entry.d.u, e, sizeof(entry.d.u)) == 0) {
+                memcmp(&entry.d.u, e, sizeof(entry.d.u)) == 0) {
                 return true;
             }
         }
@@ -4989,7 +5013,7 @@ static int lfs21_moved(lfs2_t *lfs2, const void *e) {
 
 /// Filesystem operations ///
 static int lfs21_mount(lfs2_t *lfs2, struct lfs21 *lfs21,
-        const struct lfs2_config *cfg) {
+    const struct lfs2_config *cfg) {
     int err = 0;
     {
         err = lfs2_init(lfs2, cfg);
@@ -5010,14 +5034,14 @@ static int lfs21_mount(lfs2_t *lfs2, struct lfs21 *lfs21,
         // load superblock
         lfs21_dir_t dir;
         lfs21_superblock_t superblock;
-        err = lfs21_dir_fetch(lfs2, &dir, (const lfs2_block_t[2]){0, 1});
+        err = lfs21_dir_fetch(lfs2, &dir, (const lfs2_block_t[2]) {0, 1});
         if (err && err != LFS2_ERR_CORRUPT) {
             goto cleanup;
         }
 
         if (!err) {
             err = lfs21_bd_read(lfs2, dir.pair[0], sizeof(dir.d),
-                    &superblock.d, sizeof(superblock.d));
+                &superblock.d, sizeof(superblock.d));
             lfs21_superblock_fromle32(&superblock.d);
             if (err) {
                 goto cleanup;
@@ -5028,14 +5052,14 @@ static int lfs21_mount(lfs2_t *lfs2, struct lfs21 *lfs21,
         }
 
         if (err || memcmp(superblock.d.magic, "littlefs", 8) != 0) {
-            LFS2_ERROR("Invalid superblock at {0x%"PRIx32", 0x%"PRIx32"}",
-                    0, 1);
+            LFS2_ERROR("Invalid superblock at {0x%" PRIx32 ", 0x%" PRIx32 "}",
+                0, 1);
             err = LFS2_ERR_CORRUPT;
             goto cleanup;
         }
 
         uint16_t major_version = (0xffff & (superblock.d.version >> 16));
-        uint16_t minor_version = (0xffff & (superblock.d.version >>  0));
+        uint16_t minor_version = (0xffff & (superblock.d.version >> 0));
         if ((major_version != LFS21_DISK_VERSION_MAJOR ||
              minor_version > LFS21_DISK_VERSION_MINOR)) {
             LFS2_ERROR("Invalid version v%d.%d", major_version, minor_version);
@@ -5121,11 +5145,11 @@ static int lfs2_rawmigrate(lfs2_t *lfs2, const struct lfs2_config *cfg) {
                 }
 
                 // also fetch name
-                char name[LFS2_NAME_MAX+1];
+                char name[LFS2_NAME_MAX + 1];
                 memset(name, 0, sizeof(name));
                 err = lfs21_bd_read(lfs2, dir1.pair[0],
-                        entry1.off + 4+entry1.d.elen+entry1.d.alen,
-                        name, entry1.d.nlen);
+                    entry1.off + 4 + entry1.d.elen + entry1.d.alen,
+                    name, entry1.d.nlen);
                 if (err) {
                     goto cleanup;
                 }
@@ -5139,7 +5163,7 @@ static int lfs2_rawmigrate(lfs2_t *lfs2, const struct lfs2_config *cfg) {
                 }
 
                 uint16_t id;
-                err = lfs2_dir_find(lfs2, &dir2, &(const char*){name}, &id);
+                err = lfs2_dir_find(lfs2, &dir2, &(const char *) {name}, &id);
                 if (!(err == LFS2_ERR_NOENT && id != 0x3ff)) {
                     err = (err < 0) ? err : LFS2_ERR_EXIST;
                     goto cleanup;
@@ -5147,15 +5171,15 @@ static int lfs2_rawmigrate(lfs2_t *lfs2, const struct lfs2_config *cfg) {
 
                 lfs21_entry_tole32(&entry1.d);
                 err = lfs2_dir_commit(lfs2, &dir2, LFS2_MKATTRS(
-                        {LFS2_MKTAG(LFS2_TYPE_CREATE, id, 0), NULL},
-                        {LFS2_MKTAG_IF_ELSE(isdir,
-                            LFS2_TYPE_DIR, id, entry1.d.nlen,
-                            LFS2_TYPE_REG, id, entry1.d.nlen),
-                                name},
-                        {LFS2_MKTAG_IF_ELSE(isdir,
-                            LFS2_TYPE_DIRSTRUCT, id, sizeof(entry1.d.u),
-                            LFS2_TYPE_CTZSTRUCT, id, sizeof(entry1.d.u)),
-                                &entry1.d.u}));
+                    {LFS2_MKTAG(LFS2_TYPE_CREATE, id, 0), NULL},
+                    {LFS2_MKTAG_IF_ELSE(isdir,
+                        LFS2_TYPE_DIR, id, entry1.d.nlen,
+                        LFS2_TYPE_REG, id, entry1.d.nlen),
+                     name},
+                    {LFS2_MKTAG_IF_ELSE(isdir,
+                        LFS2_TYPE_DIRSTRUCT, id, sizeof(entry1.d.u),
+                        LFS2_TYPE_CTZSTRUCT, id, sizeof(entry1.d.u)),
+                     &entry1.d.u}));
                 lfs21_entry_fromle32(&entry1.d);
                 if (err) {
                     goto cleanup;
@@ -5178,7 +5202,7 @@ static int lfs2_rawmigrate(lfs2_t *lfs2, const struct lfs2_config *cfg) {
 
                 lfs2_pair_tole32(dir2.pair);
                 err = lfs2_dir_commit(lfs2, &dir2, LFS2_MKATTRS(
-                        {LFS2_MKTAG(LFS2_TYPE_SOFTTAIL, 0x3ff, 8), dir1.d.tail}));
+                    {LFS2_MKTAG(LFS2_TYPE_SOFTTAIL, 0x3ff, 8), dir1.d.tail}));
                 lfs2_pair_fromle32(dir2.pair);
                 if (err) {
                     goto cleanup;
@@ -5187,9 +5211,9 @@ static int lfs2_rawmigrate(lfs2_t *lfs2, const struct lfs2_config *cfg) {
 
             // Copy over first block to thread into fs. Unfortunately
             // if this fails there is not much we can do.
-            LFS2_DEBUG("Migrating {0x%"PRIx32", 0x%"PRIx32"} "
-                        "-> {0x%"PRIx32", 0x%"PRIx32"}",
-                    lfs2->root[0], lfs2->root[1], dir1.head[0], dir1.head[1]);
+            LFS2_DEBUG("Migrating {0x%" PRIx32 ", 0x%" PRIx32 "} "
+                "-> {0x%" PRIx32 ", 0x%" PRIx32 "}",
+                lfs2->root[0], lfs2->root[1], dir1.head[0], dir1.head[1]);
 
             err = lfs2_bd_erase(lfs2, dir1.head[1]);
             if (err) {
@@ -5204,15 +5228,15 @@ static int lfs2_rawmigrate(lfs2_t *lfs2, const struct lfs2_config *cfg) {
             for (lfs2_off_t i = 0; i < dir2.off; i++) {
                 uint8_t dat;
                 err = lfs2_bd_read(lfs2,
-                        NULL, &lfs2->rcache, dir2.off,
-                        dir2.pair[0], i, &dat, 1);
+                    NULL, &lfs2->rcache, dir2.off,
+                    dir2.pair[0], i, &dat, 1);
                 if (err) {
                     goto cleanup;
                 }
 
                 err = lfs2_bd_prog(lfs2,
-                        &lfs2->pcache, &lfs2->rcache, true,
-                        dir1.head[1], i, &dat, 1);
+                    &lfs2->pcache, &lfs2->rcache, true,
+                    dir1.head[1], i, &dat, 1);
                 if (err) {
                     goto cleanup;
                 }
@@ -5225,7 +5249,7 @@ static int lfs2_rawmigrate(lfs2_t *lfs2, const struct lfs2_config *cfg) {
         }
 
         // Create new superblock. This marks a successful migration!
-        err = lfs21_dir_fetch(lfs2, &dir1, (const lfs2_block_t[2]){0, 1});
+        err = lfs21_dir_fetch(lfs2, &dir1, (const lfs2_block_t[2]) {0, 1});
         if (err) {
             goto cleanup;
         }
@@ -5242,26 +5266,26 @@ static int lfs2_rawmigrate(lfs2_t *lfs2, const struct lfs2_config *cfg) {
         dir2.split = true;
 
         lfs2_superblock_t superblock = {
-            .version     = LFS2_DISK_VERSION,
-            .block_size  = lfs2->cfg->block_size,
+            .version = LFS2_DISK_VERSION,
+            .block_size = lfs2->cfg->block_size,
             .block_count = lfs2->cfg->block_count,
-            .name_max    = lfs2->name_max,
-            .file_max    = lfs2->file_max,
-            .attr_max    = lfs2->attr_max,
+            .name_max = lfs2->name_max,
+            .file_max = lfs2->file_max,
+            .attr_max = lfs2->attr_max,
         };
 
         lfs2_superblock_tole32(&superblock);
         err = lfs2_dir_commit(lfs2, &dir2, LFS2_MKATTRS(
-                {LFS2_MKTAG(LFS2_TYPE_CREATE, 0, 0), NULL},
-                {LFS2_MKTAG(LFS2_TYPE_SUPERBLOCK, 0, 8), "littlefs"},
-                {LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, 0, sizeof(superblock)),
-                    &superblock}));
+            {LFS2_MKTAG(LFS2_TYPE_CREATE, 0, 0), NULL},
+            {LFS2_MKTAG(LFS2_TYPE_SUPERBLOCK, 0, 8), "littlefs"},
+            {LFS2_MKTAG(LFS2_TYPE_INLINESTRUCT, 0, sizeof(superblock)),
+             &superblock}));
         if (err) {
             goto cleanup;
         }
 
         // sanity check that fetch works
-        err = lfs2_dir_fetch(lfs2, &dir2, (const lfs2_block_t[2]){0, 1});
+        err = lfs2_dir_fetch(lfs2, &dir2, (const lfs2_block_t[2]) {0, 1});
         if (err) {
             goto cleanup;
         }
@@ -5303,21 +5327,21 @@ int lfs2_format(lfs2_t *lfs2, const struct lfs2_config *cfg) {
         return err;
     }
     LFS2_TRACE("lfs2_format(%p, %p {.context=%p, "
-                ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
-                ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
-                ".block_size=%"PRIu32", .block_count=%"PRIu32", "
-                ".block_cycles=%"PRIu32", .cache_size=%"PRIu32", "
-                ".lookahead_size=%"PRIu32", .read_buffer=%p, "
-                ".prog_buffer=%p, .lookahead_buffer=%p, "
-                ".name_max=%"PRIu32", .file_max=%"PRIu32", "
-                ".attr_max=%"PRIu32"})",
-            (void*)lfs2, (void*)cfg, cfg->context,
-            (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
-            (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
-            cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
-            cfg->block_cycles, cfg->cache_size, cfg->lookahead_size,
-            cfg->read_buffer, cfg->prog_buffer, cfg->lookahead_buffer,
-            cfg->name_max, cfg->file_max, cfg->attr_max);
+        ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
+        ".read_size=%" PRIu32 ", .prog_size=%" PRIu32 ", "
+        ".block_size=%" PRIu32 ", .block_count=%" PRIu32 ", "
+        ".block_cycles=%" PRIu32 ", .cache_size=%" PRIu32 ", "
+        ".lookahead_size=%" PRIu32 ", .read_buffer=%p, "
+        ".prog_buffer=%p, .lookahead_buffer=%p, "
+        ".name_max=%" PRIu32 ", .file_max=%" PRIu32 ", "
+        ".attr_max=%" PRIu32 "})",
+        (void *)lfs2, (void *)cfg, cfg->context,
+        (void *)(uintptr_t)cfg->read, (void *)(uintptr_t)cfg->prog,
+        (void *)(uintptr_t)cfg->erase, (void *)(uintptr_t)cfg->sync,
+        cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
+        cfg->block_cycles, cfg->cache_size, cfg->lookahead_size,
+        cfg->read_buffer, cfg->prog_buffer, cfg->lookahead_buffer,
+        cfg->name_max, cfg->file_max, cfg->attr_max);
 
     err = lfs2_rawformat(lfs2, cfg);
 
@@ -5333,21 +5357,21 @@ int lfs2_mount(lfs2_t *lfs2, const struct lfs2_config *cfg) {
         return err;
     }
     LFS2_TRACE("lfs2_mount(%p, %p {.context=%p, "
-                ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
-                ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
-                ".block_size=%"PRIu32", .block_count=%"PRIu32", "
-                ".block_cycles=%"PRIu32", .cache_size=%"PRIu32", "
-                ".lookahead_size=%"PRIu32", .read_buffer=%p, "
-                ".prog_buffer=%p, .lookahead_buffer=%p, "
-                ".name_max=%"PRIu32", .file_max=%"PRIu32", "
-                ".attr_max=%"PRIu32"})",
-            (void*)lfs2, (void*)cfg, cfg->context,
-            (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
-            (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
-            cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
-            cfg->block_cycles, cfg->cache_size, cfg->lookahead_size,
-            cfg->read_buffer, cfg->prog_buffer, cfg->lookahead_buffer,
-            cfg->name_max, cfg->file_max, cfg->attr_max);
+        ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
+        ".read_size=%" PRIu32 ", .prog_size=%" PRIu32 ", "
+        ".block_size=%" PRIu32 ", .block_count=%" PRIu32 ", "
+        ".block_cycles=%" PRIu32 ", .cache_size=%" PRIu32 ", "
+        ".lookahead_size=%" PRIu32 ", .read_buffer=%p, "
+        ".prog_buffer=%p, .lookahead_buffer=%p, "
+        ".name_max=%" PRIu32 ", .file_max=%" PRIu32 ", "
+        ".attr_max=%" PRIu32 "})",
+        (void *)lfs2, (void *)cfg, cfg->context,
+        (void *)(uintptr_t)cfg->read, (void *)(uintptr_t)cfg->prog,
+        (void *)(uintptr_t)cfg->erase, (void *)(uintptr_t)cfg->sync,
+        cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
+        cfg->block_cycles, cfg->cache_size, cfg->lookahead_size,
+        cfg->read_buffer, cfg->prog_buffer, cfg->lookahead_buffer,
+        cfg->name_max, cfg->file_max, cfg->attr_max);
 
     err = lfs2_rawmount(lfs2, cfg);
 
@@ -5361,7 +5385,7 @@ int lfs2_unmount(lfs2_t *lfs2) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_unmount(%p)", (void*)lfs2);
+    LFS2_TRACE("lfs2_unmount(%p)", (void *)lfs2);
 
     err = lfs2_rawunmount(lfs2);
 
@@ -5376,7 +5400,7 @@ int lfs2_remove(lfs2_t *lfs2, const char *path) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_remove(%p, \"%s\")", (void*)lfs2, path);
+    LFS2_TRACE("lfs2_remove(%p, \"%s\")", (void *)lfs2, path);
 
     err = lfs2_rawremove(lfs2, path);
 
@@ -5392,7 +5416,7 @@ int lfs2_rename(lfs2_t *lfs2, const char *oldpath, const char *newpath) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_rename(%p, \"%s\", \"%s\")", (void*)lfs2, oldpath, newpath);
+    LFS2_TRACE("lfs2_rename(%p, \"%s\", \"%s\")", (void *)lfs2, oldpath, newpath);
 
     err = lfs2_rawrename(lfs2, oldpath, newpath);
 
@@ -5407,7 +5431,7 @@ int lfs2_stat(lfs2_t *lfs2, const char *path, struct lfs2_info *info) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_stat(%p, \"%s\", %p)", (void*)lfs2, path, (void*)info);
+    LFS2_TRACE("lfs2_stat(%p, \"%s\", %p)", (void *)lfs2, path, (void *)info);
 
     err = lfs2_rawstat(lfs2, path, info);
 
@@ -5417,30 +5441,30 @@ int lfs2_stat(lfs2_t *lfs2, const char *path, struct lfs2_info *info) {
 }
 
 lfs2_ssize_t lfs2_getattr(lfs2_t *lfs2, const char *path,
-        uint8_t type, void *buffer, lfs2_size_t size) {
+    uint8_t type, void *buffer, lfs2_size_t size) {
     int err = LFS2_LOCK(lfs2->cfg);
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_getattr(%p, \"%s\", %"PRIu8", %p, %"PRIu32")",
-            (void*)lfs2, path, type, buffer, size);
+    LFS2_TRACE("lfs2_getattr(%p, \"%s\", %" PRIu8 ", %p, %" PRIu32 ")",
+        (void *)lfs2, path, type, buffer, size);
 
     lfs2_ssize_t res = lfs2_rawgetattr(lfs2, path, type, buffer, size);
 
-    LFS2_TRACE("lfs2_getattr -> %"PRId32, res);
+    LFS2_TRACE("lfs2_getattr -> %" PRId32, res);
     LFS2_UNLOCK(lfs2->cfg);
     return res;
 }
 
 #ifndef LFS2_READONLY
 int lfs2_setattr(lfs2_t *lfs2, const char *path,
-        uint8_t type, const void *buffer, lfs2_size_t size) {
+    uint8_t type, const void *buffer, lfs2_size_t size) {
     int err = LFS2_LOCK(lfs2->cfg);
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_setattr(%p, \"%s\", %"PRIu8", %p, %"PRIu32")",
-            (void*)lfs2, path, type, buffer, size);
+    LFS2_TRACE("lfs2_setattr(%p, \"%s\", %" PRIu8 ", %p, %" PRIu32 ")",
+        (void *)lfs2, path, type, buffer, size);
 
     err = lfs2_rawsetattr(lfs2, path, type, buffer, size);
 
@@ -5456,7 +5480,7 @@ int lfs2_removeattr(lfs2_t *lfs2, const char *path, uint8_t type) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_removeattr(%p, \"%s\", %"PRIu8")", (void*)lfs2, path, type);
+    LFS2_TRACE("lfs2_removeattr(%p, \"%s\", %" PRIu8 ")", (void *)lfs2, path, type);
 
     err = lfs2_rawremoveattr(lfs2, path, type);
 
@@ -5473,8 +5497,8 @@ int lfs2_file_open(lfs2_t *lfs2, lfs2_file_t *file, const char *path, int flags)
         return err;
     }
     LFS2_TRACE("lfs2_file_open(%p, %p, \"%s\", %x)",
-            (void*)lfs2, (void*)file, path, flags);
-    LFS2_ASSERT(!lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist*)file));
+        (void *)lfs2, (void *)file, path, flags);
+    LFS2_ASSERT(!lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist *)file));
 
     err = lfs2_file_rawopen(lfs2, file, path, flags);
 
@@ -5485,17 +5509,17 @@ int lfs2_file_open(lfs2_t *lfs2, lfs2_file_t *file, const char *path, int flags)
 #endif
 
 int lfs2_file_opencfg(lfs2_t *lfs2, lfs2_file_t *file,
-        const char *path, int flags,
-        const struct lfs2_file_config *cfg) {
+    const char *path, int flags,
+    const struct lfs2_file_config *cfg) {
     int err = LFS2_LOCK(lfs2->cfg);
     if (err) {
         return err;
     }
     LFS2_TRACE("lfs2_file_opencfg(%p, %p, \"%s\", %x, %p {"
-                 ".buffer=%p, .attrs=%p, .attr_count=%"PRIu32"})",
-            (void*)lfs2, (void*)file, path, flags,
-            (void*)cfg, cfg->buffer, (void*)cfg->attrs, cfg->attr_count);
-    LFS2_ASSERT(!lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist*)file));
+        ".buffer=%p, .attrs=%p, .attr_count=%" PRIu32 "})",
+        (void *)lfs2, (void *)file, path, flags,
+        (void *)cfg, cfg->buffer, (void *)cfg->attrs, cfg->attr_count);
+    LFS2_ASSERT(!lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist *)file));
 
     err = lfs2_file_rawopencfg(lfs2, file, path, flags, cfg);
 
@@ -5509,8 +5533,8 @@ int lfs2_file_close(lfs2_t *lfs2, lfs2_file_t *file) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_file_close(%p, %p)", (void*)lfs2, (void*)file);
-    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist*)file));
+    LFS2_TRACE("lfs2_file_close(%p, %p)", (void *)lfs2, (void *)file);
+    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist *)file));
 
     err = lfs2_file_rawclose(lfs2, file);
 
@@ -5525,8 +5549,8 @@ int lfs2_file_sync(lfs2_t *lfs2, lfs2_file_t *file) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_file_sync(%p, %p)", (void*)lfs2, (void*)file);
-    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist*)file));
+    LFS2_TRACE("lfs2_file_sync(%p, %p)", (void *)lfs2, (void *)file);
+    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist *)file));
 
     err = lfs2_file_rawsync(lfs2, file);
 
@@ -5537,54 +5561,54 @@ int lfs2_file_sync(lfs2_t *lfs2, lfs2_file_t *file) {
 #endif
 
 lfs2_ssize_t lfs2_file_read(lfs2_t *lfs2, lfs2_file_t *file,
-        void *buffer, lfs2_size_t size) {
+    void *buffer, lfs2_size_t size) {
     int err = LFS2_LOCK(lfs2->cfg);
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_file_read(%p, %p, %p, %"PRIu32")",
-            (void*)lfs2, (void*)file, buffer, size);
-    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist*)file));
+    LFS2_TRACE("lfs2_file_read(%p, %p, %p, %" PRIu32 ")",
+        (void *)lfs2, (void *)file, buffer, size);
+    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist *)file));
 
     lfs2_ssize_t res = lfs2_file_rawread(lfs2, file, buffer, size);
 
-    LFS2_TRACE("lfs2_file_read -> %"PRId32, res);
+    LFS2_TRACE("lfs2_file_read -> %" PRId32, res);
     LFS2_UNLOCK(lfs2->cfg);
     return res;
 }
 
 #ifndef LFS2_READONLY
 lfs2_ssize_t lfs2_file_write(lfs2_t *lfs2, lfs2_file_t *file,
-        const void *buffer, lfs2_size_t size) {
+    const void *buffer, lfs2_size_t size) {
     int err = LFS2_LOCK(lfs2->cfg);
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_file_write(%p, %p, %p, %"PRIu32")",
-            (void*)lfs2, (void*)file, buffer, size);
-    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist*)file));
+    LFS2_TRACE("lfs2_file_write(%p, %p, %p, %" PRIu32 ")",
+        (void *)lfs2, (void *)file, buffer, size);
+    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist *)file));
 
     lfs2_ssize_t res = lfs2_file_rawwrite(lfs2, file, buffer, size);
 
-    LFS2_TRACE("lfs2_file_write -> %"PRId32, res);
+    LFS2_TRACE("lfs2_file_write -> %" PRId32, res);
     LFS2_UNLOCK(lfs2->cfg);
     return res;
 }
 #endif
 
 lfs2_soff_t lfs2_file_seek(lfs2_t *lfs2, lfs2_file_t *file,
-        lfs2_soff_t off, int whence) {
+    lfs2_soff_t off, int whence) {
     int err = LFS2_LOCK(lfs2->cfg);
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_file_seek(%p, %p, %"PRId32", %d)",
-            (void*)lfs2, (void*)file, off, whence);
-    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist*)file));
+    LFS2_TRACE("lfs2_file_seek(%p, %p, %" PRId32 ", %d)",
+        (void *)lfs2, (void *)file, off, whence);
+    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist *)file));
 
     lfs2_soff_t res = lfs2_file_rawseek(lfs2, file, off, whence);
 
-    LFS2_TRACE("lfs2_file_seek -> %"PRId32, res);
+    LFS2_TRACE("lfs2_file_seek -> %" PRId32, res);
     LFS2_UNLOCK(lfs2->cfg);
     return res;
 }
@@ -5595,9 +5619,9 @@ int lfs2_file_truncate(lfs2_t *lfs2, lfs2_file_t *file, lfs2_off_t size) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_file_truncate(%p, %p, %"PRIu32")",
-            (void*)lfs2, (void*)file, size);
-    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist*)file));
+    LFS2_TRACE("lfs2_file_truncate(%p, %p, %" PRIu32 ")",
+        (void *)lfs2, (void *)file, size);
+    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist *)file));
 
     err = lfs2_file_rawtruncate(lfs2, file, size);
 
@@ -5612,12 +5636,12 @@ lfs2_soff_t lfs2_file_tell(lfs2_t *lfs2, lfs2_file_t *file) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_file_tell(%p, %p)", (void*)lfs2, (void*)file);
-    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist*)file));
+    LFS2_TRACE("lfs2_file_tell(%p, %p)", (void *)lfs2, (void *)file);
+    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist *)file));
 
     lfs2_soff_t res = lfs2_file_rawtell(lfs2, file);
 
-    LFS2_TRACE("lfs2_file_tell -> %"PRId32, res);
+    LFS2_TRACE("lfs2_file_tell -> %" PRId32, res);
     LFS2_UNLOCK(lfs2->cfg);
     return res;
 }
@@ -5627,7 +5651,7 @@ int lfs2_file_rewind(lfs2_t *lfs2, lfs2_file_t *file) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_file_rewind(%p, %p)", (void*)lfs2, (void*)file);
+    LFS2_TRACE("lfs2_file_rewind(%p, %p)", (void *)lfs2, (void *)file);
 
     err = lfs2_file_rawrewind(lfs2, file);
 
@@ -5641,12 +5665,12 @@ lfs2_soff_t lfs2_file_size(lfs2_t *lfs2, lfs2_file_t *file) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_file_size(%p, %p)", (void*)lfs2, (void*)file);
-    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist*)file));
+    LFS2_TRACE("lfs2_file_size(%p, %p)", (void *)lfs2, (void *)file);
+    LFS2_ASSERT(lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist *)file));
 
     lfs2_soff_t res = lfs2_file_rawsize(lfs2, file);
 
-    LFS2_TRACE("lfs2_file_size -> %"PRId32, res);
+    LFS2_TRACE("lfs2_file_size -> %" PRId32, res);
     LFS2_UNLOCK(lfs2->cfg);
     return res;
 }
@@ -5657,7 +5681,7 @@ int lfs2_mkdir(lfs2_t *lfs2, const char *path) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_mkdir(%p, \"%s\")", (void*)lfs2, path);
+    LFS2_TRACE("lfs2_mkdir(%p, \"%s\")", (void *)lfs2, path);
 
     err = lfs2_rawmkdir(lfs2, path);
 
@@ -5672,8 +5696,8 @@ int lfs2_dir_open(lfs2_t *lfs2, lfs2_dir_t *dir, const char *path) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_dir_open(%p, %p, \"%s\")", (void*)lfs2, (void*)dir, path);
-    LFS2_ASSERT(!lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist*)dir));
+    LFS2_TRACE("lfs2_dir_open(%p, %p, \"%s\")", (void *)lfs2, (void *)dir, path);
+    LFS2_ASSERT(!lfs2_mlist_isopen(lfs2->mlist, (struct lfs2_mlist *)dir));
 
     err = lfs2_dir_rawopen(lfs2, dir, path);
 
@@ -5687,7 +5711,7 @@ int lfs2_dir_close(lfs2_t *lfs2, lfs2_dir_t *dir) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_dir_close(%p, %p)", (void*)lfs2, (void*)dir);
+    LFS2_TRACE("lfs2_dir_close(%p, %p)", (void *)lfs2, (void *)dir);
 
     err = lfs2_dir_rawclose(lfs2, dir);
 
@@ -5702,7 +5726,7 @@ int lfs2_dir_read(lfs2_t *lfs2, lfs2_dir_t *dir, struct lfs2_info *info) {
         return err;
     }
     LFS2_TRACE("lfs2_dir_read(%p, %p, %p)",
-            (void*)lfs2, (void*)dir, (void*)info);
+        (void *)lfs2, (void *)dir, (void *)info);
 
     err = lfs2_dir_rawread(lfs2, dir, info);
 
@@ -5716,8 +5740,8 @@ int lfs2_dir_seek(lfs2_t *lfs2, lfs2_dir_t *dir, lfs2_off_t off) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_dir_seek(%p, %p, %"PRIu32")",
-            (void*)lfs2, (void*)dir, off);
+    LFS2_TRACE("lfs2_dir_seek(%p, %p, %" PRIu32 ")",
+        (void *)lfs2, (void *)dir, off);
 
     err = lfs2_dir_rawseek(lfs2, dir, off);
 
@@ -5731,11 +5755,11 @@ lfs2_soff_t lfs2_dir_tell(lfs2_t *lfs2, lfs2_dir_t *dir) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_dir_tell(%p, %p)", (void*)lfs2, (void*)dir);
+    LFS2_TRACE("lfs2_dir_tell(%p, %p)", (void *)lfs2, (void *)dir);
 
     lfs2_soff_t res = lfs2_dir_rawtell(lfs2, dir);
 
-    LFS2_TRACE("lfs2_dir_tell -> %"PRId32, res);
+    LFS2_TRACE("lfs2_dir_tell -> %" PRId32, res);
     LFS2_UNLOCK(lfs2->cfg);
     return res;
 }
@@ -5745,7 +5769,7 @@ int lfs2_dir_rewind(lfs2_t *lfs2, lfs2_dir_t *dir) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_dir_rewind(%p, %p)", (void*)lfs2, (void*)dir);
+    LFS2_TRACE("lfs2_dir_rewind(%p, %p)", (void *)lfs2, (void *)dir);
 
     err = lfs2_dir_rawrewind(lfs2, dir);
 
@@ -5759,11 +5783,11 @@ lfs2_ssize_t lfs2_fs_size(lfs2_t *lfs2) {
     if (err) {
         return err;
     }
-    LFS2_TRACE("lfs2_fs_size(%p)", (void*)lfs2);
+    LFS2_TRACE("lfs2_fs_size(%p)", (void *)lfs2);
 
     lfs2_ssize_t res = lfs2_fs_rawsize(lfs2);
 
-    LFS2_TRACE("lfs2_fs_size -> %"PRId32, res);
+    LFS2_TRACE("lfs2_fs_size -> %" PRId32, res);
     LFS2_UNLOCK(lfs2->cfg);
     return res;
 }
@@ -5774,7 +5798,7 @@ int lfs2_fs_traverse(lfs2_t *lfs2, int (*cb)(void *, lfs2_block_t), void *data)
         return err;
     }
     LFS2_TRACE("lfs2_fs_traverse(%p, %p, %p)",
-            (void*)lfs2, (void*)(uintptr_t)cb, data);
+        (void *)lfs2, (void *)(uintptr_t)cb, data);
 
     err = lfs2_fs_rawtraverse(lfs2, cb, data, true);
 
@@ -5790,21 +5814,21 @@ int lfs2_migrate(lfs2_t *lfs2, const struct lfs2_config *cfg) {
         return err;
     }
     LFS2_TRACE("lfs2_migrate(%p, %p {.context=%p, "
-                ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
-                ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
-                ".block_size=%"PRIu32", .block_count=%"PRIu32", "
-                ".block_cycles=%"PRIu32", .cache_size=%"PRIu32", "
-                ".lookahead_size=%"PRIu32", .read_buffer=%p, "
-                ".prog_buffer=%p, .lookahead_buffer=%p, "
-                ".name_max=%"PRIu32", .file_max=%"PRIu32", "
-                ".attr_max=%"PRIu32"})",
-            (void*)lfs2, (void*)cfg, cfg->context,
-            (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
-            (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
-            cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
-            cfg->block_cycles, cfg->cache_size, cfg->lookahead_size,
-            cfg->read_buffer, cfg->prog_buffer, cfg->lookahead_buffer,
-            cfg->name_max, cfg->file_max, cfg->attr_max);
+        ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
+        ".read_size=%" PRIu32 ", .prog_size=%" PRIu32 ", "
+        ".block_size=%" PRIu32 ", .block_count=%" PRIu32 ", "
+        ".block_cycles=%" PRIu32 ", .cache_size=%" PRIu32 ", "
+        ".lookahead_size=%" PRIu32 ", .read_buffer=%p, "
+        ".prog_buffer=%p, .lookahead_buffer=%p, "
+        ".name_max=%" PRIu32 ", .file_max=%" PRIu32 ", "
+        ".attr_max=%" PRIu32 "})",
+        (void *)lfs2, (void *)cfg, cfg->context,
+        (void *)(uintptr_t)cfg->read, (void *)(uintptr_t)cfg->prog,
+        (void *)(uintptr_t)cfg->erase, (void *)(uintptr_t)cfg->sync,
+        cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
+        cfg->block_cycles, cfg->cache_size, cfg->lookahead_size,
+        cfg->read_buffer, cfg->prog_buffer, cfg->lookahead_buffer,
+        cfg->name_max, cfg->file_max, cfg->attr_max);
 
     err = lfs2_rawmigrate(lfs2, cfg);
 
@@ -5813,4 +5837,3 @@ int lfs2_migrate(lfs2_t *lfs2, const struct lfs2_config *cfg) {
     return err;
 }
 #endif
-
diff --git a/ports/esp8266/Makefile b/ports/esp8266/Makefile
index e4c907c57a6c5..3b944e8637f5e 100644
--- a/ports/esp8266/Makefile
+++ b/ports/esp8266/Makefile
@@ -71,7 +71,7 @@ CFLAGS_XTENSA = -fsingle-precision-constant -Wdouble-promotion \
 	-Wl,-EL -mlongcalls -mtext-section-literals -mforce-l32 \
 	-DLWIP_OPEN_SRC
 
-CFLAGS += $(INC) -Wall -Wpointer-arith -Werror -std=gnu99 -nostdlib -DUART_OS=$(UART_OS) \
+CFLAGS += $(INC) -Wall -Wpointer-arith -std=gnu99 -nostdlib -DUART_OS=$(UART_OS) \
 	$(CFLAGS_XTENSA) $(COPT) $(CFLAGS_EXTRA) -I$(BOARD_DIR)
 
 LD_FILES ?= boards/esp8266_2m.ld
@@ -83,6 +83,10 @@ CFLAGS += -DMICROPY_ESPNOW=1
 LIBS += -lespnow
 endif
 
+#ifeq ($(MICROPY_DFU),1)
+#CFLAGS += -DMICROPY_DFU
+#endif
+#
 LIBGCC_FILE_NAME = $(shell $(CC) $(CFLAGS) -print-libgcc-file-name)
 LIBS += -L$(dir $(LIBGCC_FILE_NAME)) -lgcc
 
diff --git a/ports/esp8266/boards/ESP8266_GENERIC/mpconfigboard.mk b/ports/esp8266/boards/ESP8266_GENERIC/mpconfigboard.mk
index 2eb78d7e85e5c..1e182fec2f680 100644
--- a/ports/esp8266/boards/ESP8266_GENERIC/mpconfigboard.mk
+++ b/ports/esp8266/boards/ESP8266_GENERIC/mpconfigboard.mk
@@ -5,12 +5,16 @@ MICROPY_ESPNOW ?= 1
 MICROPY_PY_BTREE ?= 1
 MICROPY_VFS_FAT ?= 1
 MICROPY_VFS_LFS2 ?= 1
+MICROPY_DFU ?= 1
+MICROPY_DFM ?= 1
 
 # Add asyncio and extra micropython-lib packages (in addition to the port manifest).
 FROZEN_MANIFEST ?= $(BOARD_DIR)/manifest_2MiB.py
 
 # Configure mpconfigboard.h.
 CFLAGS += -DMICROPY_ESP8266_2M
+CFLAGS += -DMICROPY_DFU
+CFLAGS += -DMICROPY_DFM
 endif
 
 ifeq ($(BOARD_VARIANT),FLASH_1M)
diff --git a/ports/esp8266/boards/esp8266_common.ld b/ports/esp8266/boards/esp8266_common.ld
index 083e84d9afe5c..a6bbd7045099f 100644
--- a/ports/esp8266/boards/esp8266_common.ld
+++ b/ports/esp8266/boards/esp8266_common.ld
@@ -182,6 +182,7 @@ SECTIONS
 
         /* for -mforce-l32 */
         */*.o(.rodata*)
+		*modespnow.o(.text.espnow_del_peer .text.espnow_add_peer .text.espnow_config)
 
         _irom0_text_end = ABSOLUTE(.);
     } >irom0_0_seg :irom0_0_phdr
diff --git a/ports/esp8266/esppwm.c b/ports/esp8266/esppwm.c
index d7ac44a1786c8..29d8742a0aa42 100644
--- a/ports/esp8266/esppwm.c
+++ b/ports/esp8266/esppwm.c
@@ -26,7 +26,7 @@
 
 #define PWM_CHANNEL 8
 #define PWM_DEPTH 1023
-#define PWM_FREQ_MAX 1000
+#define PWM_FREQ_MAX 60000
 #define PWM_1S 1000000
 
 struct pwm_single_param {
diff --git a/ports/esp8266/main.c b/ports/esp8266/main.c
index 3083fe364e77c..190b7f1c0bc42 100644
--- a/ports/esp8266/main.c
+++ b/ports/esp8266/main.c
@@ -49,7 +49,7 @@
 #include "modespnow.h"
 #endif
 
-STATIC char heap[38 * 1024];
+STATIC char heap[45 * 1024];
 
 STATIC void mp_reset(void) {
     mp_stack_set_top((void *)0x40000000);
@@ -82,6 +82,9 @@ STATIC void mp_reset(void) {
     #endif
 
     #if MICROPY_MODULE_FROZEN
+    #ifdef MICROPY_DFM
+    scan_dynamic_frozen(NULL, NULL);
+    #endif
     pyexec_frozen_module("_boot.py", false);
     pyexec_file_if_exists("boot.py");
     if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
diff --git a/ports/esp8266/modesp.c b/ports/esp8266/modesp.c
index 95595faebc792..b9085b8bd971f 100644
--- a/ports/esp8266/modesp.c
+++ b/ports/esp8266/modesp.c
@@ -31,6 +31,7 @@
 #include "py/persistentcode.h"
 #include "py/mperrno.h"
 #include "py/mphal.h"
+#include "py/frozenmod.h"
 #include "uart.h"
 #include "user_interface.h"
 #include "mem.h"
@@ -236,6 +237,11 @@ STATIC mp_obj_t esp_esf_free_bufs(mp_obj_t idx_in) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_esf_free_bufs_obj, esp_esf_free_bufs);
 
+#define IRAM1_END (0x40108000)
+#define FLASH_START (0x40200000)
+#define FLASH_END (0x40300000)
+#define FLASH_SEC_SIZE (4096)
+
 #if MICROPY_EMIT_XTENSA || MICROPY_EMIT_INLINE_XTENSA
 
 // We provide here a way of committing executable data to a region from
@@ -248,11 +254,6 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_esf_free_bufs_obj, esp_esf_free_bufs);
 // esp.set_native_code_location() function; see below.  If flash is selected
 // then it is erased as needed.
 
-#define IRAM1_END (0x40108000)
-#define FLASH_START (0x40200000)
-#define FLASH_END (0x40300000)
-#define FLASH_SEC_SIZE (4096)
-
 #define ESP_NATIVE_CODE_IRAM1 (0)
 #define ESP_NATIVE_CODE_FLASH (1)
 
@@ -339,6 +340,374 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(esp_set_native_code_location_obj, esp_set_nativ
 
 #endif
 
+STATIC void showMemory(char *ptr, int size) {
+    for (int x = 0; x < size;) {
+        printf("%02x ", ptr[x++]);
+        if (x % 32 == 0) {
+            printf("\r\n");
+        } else if (x % 16 == 0) {
+            printf("  ");
+        } else if (x % 8 == 0) {
+            printf(" ");
+        }
+    }
+    printf("\r\n");
+}
+STATIC mp_obj_t esp_showMemory(mp_obj_t _start, mp_obj_t _size) {
+    showMemory((char *)mp_obj_get_int(_start), mp_obj_get_int(_size));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(esp_showMemory_obj, esp_showMemory);
+
+#ifdef MICROPY_DFU
+int dfu_nblks = -1;
+uint32_t dfu_fwsize = 0;
+uint16_t *dfu_blks = NULL;
+uint16_t *dfu_offs = NULL;
+
+/* Firmware update codes must be put into IRAM, or will crash while flashing halfway! */
+void MP_FASTCODE(erase_sector)(int sector) {
+    char *ptr = FLASH_START + sector * FLASH_SEC_SIZE;
+    for (char *PTR = ptr + FLASH_SEC_SIZE; ptr < PTR; ptr++) {
+        if (*ptr != 0xff) {
+            SPIEraseSector(sector);
+            break;
+        }
+    }
+}
+void MP_FASTCODE(DFU)(char *dfu_buf, int n_fwblks, int n_erase) {
+    for (int x = 0; x < n_fwblks; x++) {
+        erase_sector(x);
+        // uart_tx_one_char(0, 'E');
+    }
+
+    int cur_write_pos = 0;
+    int cur_write_sz;
+    int remaining_sz = dfu_fwsize;
+
+    for (int x = 0; x < dfu_nblks && remaining_sz > 0; x++) {
+        cur_write_sz = FLASH_SEC_SIZE - dfu_offs[x];
+        if (remaining_sz < cur_write_sz) {
+            cur_write_sz = remaining_sz;
+        }
+
+        Cache_Read_Disable_2();
+        SPIRead(1048576 + FLASH_SEC_SIZE * dfu_blks[x] + dfu_offs[x], (uint32_t *)dfu_buf, cur_write_sz);
+        Cache_Read_Enable_2();
+        // uart_tx_one_char(0, 'R');
+        if (x == 0) {
+            dfu_buf[3] = 64;
+        }
+        SPIWrite(cur_write_pos, (uint32_t *)dfu_buf, cur_write_sz);
+        // uart_tx_one_char(0, 'W');
+
+        cur_write_pos += cur_write_sz;
+        remaining_sz -= cur_write_sz;
+        wdt_feed();
+    }
+
+    for (int x = n_fwblks; x < n_erase; x++) {
+        erase_sector(x);
+        // uart_tx_one_char(0, 'E');
+    }
+
+    asm ("memw");
+    asm ("isync");
+    // rom_phy_reset_req();
+    system_restart_core();
+    // return cur_write_pos;
+}
+STATIC mp_obj_t esp_DFU(mp_obj_t erase_all) {
+    extern char flashchip;
+    SpiFlashChip *flash = (SpiFlashChip *)(&flashchip + 4);
+    char *buf = malloc(FLASH_SEC_SIZE);
+    if (buf == NULL) {
+        mp_raise_OSError(MP_ENOMEM);
+        return mp_const_none;
+    }
+
+    ets_wdt_disable();
+    disable_irq();
+    DFU(buf, dfu_fwsize / FLASH_SEC_SIZE + (dfu_fwsize % FLASH_SEC_SIZE?1:0), mp_obj_is_true(erase_all)?(flash->chip_size / FLASH_SEC_SIZE):0);
+
+    // It will NEVER reach here even if flash failed
+    // enable_irq(state);
+    // ets_wdt_enable();
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_DFU_obj, esp_DFU);
+
+STATIC mp_obj_t esp_set_dfu(mp_obj_t nblks, mp_obj_t fsize) {
+    dfu_nblks = mp_obj_get_int(nblks);
+    dfu_fwsize = mp_obj_get_int(fsize);
+    if (dfu_nblks > 0 && dfu_blks == NULL && dfu_offs == NULL) {
+        size_t res = 0;
+        mp_obj_t ret = mp_obj_new_bytes(FLASH_START, dfu_nblks * sizeof(uint16_t) * 2);
+        dfu_blks = mp_obj_str_get_data(ret, &res);
+        dfu_offs = &dfu_blks[dfu_nblks];
+        return ret; // must return an object to keep the buffer, or will be GC collected
+    }
+    return (dfu_blks != NULL && dfu_offs != NULL)?mp_const_true:mp_const_false;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(esp_set_dfu_obj, esp_set_dfu);
+
+STATIC mp_obj_t esp_get_blks(mp_obj_t return_details) {
+    if (!mp_obj_is_true(return_details)) {
+        return mp_obj_new_int(dfu_nblks);
+    }
+    if (dfu_nblks <= 0) {
+        return mp_const_none;
+    }
+    mp_obj_t *secs = m_new(mp_obj_t, dfu_nblks);
+    mp_obj_t *offs = m_new(mp_obj_t, dfu_nblks);
+    for (int x = 0; x < dfu_nblks; x++) {
+        secs[x] = mp_obj_new_int(dfu_blks[x]);
+        offs[x] = mp_obj_new_int(dfu_offs[x]);
+    }
+    mp_obj_t *ret2 = m_new(mp_obj_t, 2);
+    ret2[0] = mp_obj_new_list(dfu_nblks, secs);
+    ret2[1] = mp_obj_new_list(dfu_nblks, offs);
+    return mp_obj_new_list(2, ret2);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_get_blks_obj, esp_get_blks);
+#endif  // MICROPY_DFU
+
+#ifdef MICROPY_DFM
+
+// Dynamic Frozen Modules (DFM)
+extern mp_import_stat_t (*mp_find_dynamic_frozen)(const char *str, int *frozen_type, void **data);
+uint32_t dynamic_frozen_start = 0;  // Flash absolute byte offset of the starting sector for dynamic frozen modules
+mp_import_stat_t mp_find_dynamic_frozen_(const char *str, int *frozen_type, void **data);
+
+/* This function serves many purposes:
+- if out_frozen_list!=NULL, it will output the list of strings of frozen items' names
+- if name!=NULL, it will stop at the frozen item with <name>
+- returns a pointer to the stopping sector
+Sector format for dynamic frozen modules: {
+    uint8_t n_sectors_;     // 0xff: end of dynamic_frozen list; 0x00: deleted; else: must be the same as n_sectors
+    uint8_t n_sectors;      // number of sectors spanned by the frozen item
+    uint8_t module_name_length;
+    uint8_t pad;
+    uint32_t frozen_content_length;
+    char module_name[?];
+    char frozen_content[?];
+}*/
+uint8_t *scan_dynamic_frozen(mp_obj_t out_frozen_list, const char *name) {
+    if (!dynamic_frozen_start) {
+        dynamic_frozen_start = (*(uint32_t *)(0x40208ffc) + FLASH_SEC_SIZE - 1) / FLASH_SEC_SIZE * FLASH_SEC_SIZE;
+    }
+    int n_modules = 0;
+    uint8_t *ptr = FLASH_START + dynamic_frozen_start;
+    while (ptr < FLASH_END) {
+        if (*ptr == 0xff) {
+            break;              // end-of-dynamic_frozen: erased sector are filled by with 0xff in NOR flash
+        }
+        if (ptr + FLASH_SEC_SIZE * ptr[1] > FLASH_END) {
+            break;                                       // corrupted frozen sector
+        }
+        if (*ptr == 0) {           // deleted frozen sector has 1st byte == 0 => skip
+            ptr += FLASH_SEC_SIZE;
+            continue;
+        }
+        if (*ptr != ptr[1]) {
+            break;                   // valid frozen sector must have byte1 == byte2 == #-of-sectors, or corrupted
+        }
+        if (ptr[8 + ptr[2]]) {
+            break;                   // not end-of-string NULL for module name => corrupted
+        }
+        if (strlen(ptr + 8) != ptr[2]) {
+            break;                        // incorrect module name string length
+        }
+        uint32_t mpy_size = *(uint32_t *)&ptr[4];
+        if (ptr + 9 + ptr[2] + mpy_size >= FLASH_END) {
+            break;                                       // module size overshoot => corrupted
+        }
+        n_modules++;
+
+        // handle output
+        if (out_frozen_list != NULL) {
+            mp_obj_t dfm_info[3] = {mp_obj_new_str(ptr + 8, ptr[2]), mp_obj_new_int(mpy_size), mp_obj_new_int(ptr - FLASH_START)};
+            mp_obj_list_append(out_frozen_list, mp_obj_new_tuple(3, &dfm_info[0]));
+        }
+        if (name && !strcmp(ptr + 8, name)) {
+            break;                              // found match
+        }
+        ptr += FLASH_SEC_SIZE * ptr[0];
+    }
+    mp_find_dynamic_frozen = n_modules?mp_find_dynamic_frozen_:NULL;
+    return ptr;
+}
+
+mp_import_stat_t mp_find_dynamic_frozen_(const char *str, int *frozen_type, void **data) {
+    byte *ptr = scan_dynamic_frozen(NULL, str);
+    if (ptr >= FLASH_END || ptr[0] != ptr[1] || ptr[0] == 0xff || strcmp(str, ptr + 8)) {
+        return MP_IMPORT_STAT_NO_EXIST;
+    }
+    if (frozen_type) {
+        *frozen_type = MP_FROZEN_MPY;
+    }
+    if (data) {
+        mp_module_context_t *ctx = m_new_obj(mp_module_context_t);
+        ctx->module.globals = mp_globals_get();
+        mp_compiled_module_t cm;
+        cm.context = ctx;
+        mp_raw_code_load_mem(&ptr[strlen(str) + 9], *(uint32_t *)&ptr[4], &cm);
+        mp_frozen_module_t *fc = malloc(sizeof(mp_frozen_module_t));
+        *(mp_module_constants_t *)&fc->constants = cm.context->constants;
+        fc->rc = cm.rc;
+        *data = fc;
+    }
+    return MP_IMPORT_STAT_FILE;
+}
+
+STATIC mp_obj_t esp_ls_frozen() {
+    mp_obj_t frozen_list = mp_obj_new_list(0, NULL);
+    scan_dynamic_frozen(frozen_list, NULL);
+    return frozen_list;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp_ls_frozen_obj, esp_ls_frozen);
+
+bool has_enough_free_sect(uint8_t *ptr, int n_needed) {
+    int x = 0;
+    for (; ptr < FLASH_END && x <= n_needed && (*ptr == 0 || *ptr == 0xff); x++) {
+        ptr += FLASH_SEC_SIZE;
+    }
+    return x >= n_needed;
+}
+mp_obj_t flash_mpy_to_rom(const char *filename, const char *modname, uint8_t *ptr, uint32_t filesize, int tot_secs) {
+    mp_obj_t res = mp_const_true;
+    byte buf[256] = {tot_secs, tot_secs, strlen(modname), 0};
+    mp_reader_t reader;
+    mp_reader_new_file(&reader, filename);
+    *(uint32_t *)&buf[4] = filesize;
+    strcpy(&buf[8], modname);
+    mp_uint_t ch = 0;
+    int off = strlen(modname) + 9;
+    while (ch != MP_READER_EOF) {
+        while (off < 256 && (ch = reader.readbyte(reader.data)) != MP_READER_EOF) {
+            buf[off] = ch;
+            off++;
+        }
+        while (off & 0x3) {
+            buf[off++] = 0xff;  // reached EOF, fill with 0xff until a 4-byte boundary
+        }
+        if (spi_flash_write(ptr - FLASH_START, &buf[0], off) != SPI_FLASH_RESULT_OK) {
+            res = mp_const_false;
+            break;
+        }
+        ptr += off;
+        off = 0;
+    }
+    reader.close(reader.data);
+    mp_find_dynamic_frozen = res?mp_find_dynamic_frozen_:NULL;
+    return res;
+}
+bool delete_mpy_from_rom(byte *ptr) {
+    uint32_t new_dword = (*(uint32_t *)ptr) & 0xffffff00;  // set 1st byte to 0
+    for (int x = ptr[1]; x > 0 && ptr < FLASH_END; x--, ptr += FLASH_SEC_SIZE) { // free every sector occupied by the module
+        if (spi_flash_write(ptr - FLASH_START, (uint32_t *)&new_dword, 4) != SPI_FLASH_RESULT_OK) { // NOR flash can write 0-bit without erasing
+            return mp_const_false;
+        }
+    }
+    return mp_const_true;
+}
+bool compare_flash_to_file(const char *filename, byte *ptr) {
+    bool is_diff = false;
+    mp_reader_t reader;
+    mp_reader_new_file(&reader, filename);
+    byte ch;
+    while ((ch = reader.readbyte(reader.data)) != MP_READER_EOF) {
+        if (*ptr != ch) {
+            is_diff = true;
+            break;
+        }
+    }
+    reader.close(reader.data);
+    return is_diff;
+}
+STATIC mp_obj_t esp_add_frozen(size_t n_args, const mp_obj_t *args) {
+    uint8_t *ptr;
+    const char *filename = mp_obj_str_get_str(args[0]);
+    char *modname = n_args > 1?mp_obj_str_get_str(args[1]):filename;
+
+    // get .mpy filesize
+    int mpy_size = 0;
+    mp_reader_t reader;
+    mp_reader_new_file(&reader, filename);
+    while (reader.readbyte(reader.data) != MP_READER_EOF) {
+        mpy_size++;
+    }
+    reader.close(reader.data);
+
+    // compute spaces needed
+    int tot_size = mpy_size + strlen(modname) + 9;
+    int tot_secs = (tot_size + FLASH_SEC_SIZE - 1) / FLASH_SEC_SIZE;
+
+    // find existing mpy
+    ptr = scan_dynamic_frozen(NULL, modname);
+    if (ptr < FLASH_END && *ptr != 0xff && ptr[0] == ptr[1] && !strcmp(modname, ptr + 8)) {  // found module with the same name
+        // if same module name and content, return true
+        if (*(uint32_t *)&ptr[4] == mpy_size && !compare_flash_to_file(filename, ptr + strlen(modname) + 9)) {
+            return mp_const_true;
+        }
+        // otherwise, delete the existing module
+        if (!delete_mpy_from_rom(ptr)) {
+            return mp_const_false;
+        }
+    }
+
+    ptr = FLASH_START + dynamic_frozen_start;
+    while (ptr < FLASH_END) {
+        switch (*ptr) {
+            case 0x0:
+                if (!has_enough_free_sect(ptr, tot_secs)) {
+                    break;
+                }
+                return flash_mpy_to_rom(filename, modname, ptr, mpy_size, tot_secs);
+            case 0xff:
+                if (!has_enough_free_sect(ptr, tot_secs)) {
+                    return mp_const_false;
+                }
+                return flash_mpy_to_rom(filename, modname, ptr, mpy_size, tot_secs);
+            default:
+                if (ptr[1] != ptr[0]) {
+                    return mp_const_false;
+                }
+                ptr += FLASH_SEC_SIZE * (*ptr);
+                continue;
+        }
+        ptr += FLASH_SEC_SIZE;
+    }
+    return mp_const_false;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_add_frozen_obj, 1, 2, esp_add_frozen);
+
+STATIC mp_obj_t esp_del_frozen(mp_obj_t module_name) {
+    const char *_module_name = mp_obj_str_get_str(module_name);
+    uint8_t *ptr = scan_dynamic_frozen(NULL, _module_name);
+    if (ptr >= FLASH_END || strcmp(ptr + 8, _module_name)) { // not found
+        return mp_const_false;
+    }
+    if (!delete_mpy_from_rom(ptr)) {
+        return mp_const_false;
+    }
+    scan_dynamic_frozen(NULL, NULL);
+    return mp_const_true;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_del_frozen_obj, esp_del_frozen);
+
+STATIC mp_obj_t esp_reset_frozen() {
+    for (int p = dynamic_frozen_start / FLASH_SEC_SIZE, P = (FLASH_END - FLASH_START) / FLASH_SEC_SIZE; p < P; p++) {
+        erase_sector(p);
+    }
+    mp_find_dynamic_frozen = NULL;
+    return mp_const_true;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp_reset_frozen_obj, esp_reset_frozen);
+
+#endif  // MICROPY_DFM
+
 STATIC const mp_rom_map_elem_t esp_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_esp) },
 
@@ -351,6 +720,21 @@ STATIC const mp_rom_map_elem_t esp_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_flash_erase), MP_ROM_PTR(&esp_flash_erase_obj) },
     { MP_ROM_QSTR(MP_QSTR_flash_size), MP_ROM_PTR(&esp_flash_size_obj) },
     { MP_ROM_QSTR(MP_QSTR_flash_user_start), MP_ROM_PTR(&esp_flash_user_start_obj) },
+
+    #ifdef MICROPY_DFU
+    { MP_ROM_QSTR(MP_QSTR_DFU), MP_ROM_PTR(&esp_DFU_obj) },
+    { MP_ROM_QSTR(MP_QSTR_showMemory), MP_ROM_PTR(&esp_showMemory_obj) },
+    { MP_ROM_QSTR(MP_QSTR_set_dfu), MP_ROM_PTR(&esp_set_dfu_obj) },
+    { MP_ROM_QSTR(MP_QSTR_get_blks), MP_ROM_PTR(&esp_get_blks_obj) },
+    #endif
+
+    #ifdef MICROPY_DFM
+    { MP_ROM_QSTR(MP_QSTR_add_frozen), MP_ROM_PTR(&esp_add_frozen_obj) },
+    { MP_ROM_QSTR(MP_QSTR_del_frozen), MP_ROM_PTR(&esp_del_frozen_obj) },
+    { MP_ROM_QSTR(MP_QSTR_ls_frozen), MP_ROM_PTR(&esp_ls_frozen_obj) },
+    { MP_ROM_QSTR(MP_QSTR_reset_frozen), MP_ROM_PTR(&esp_reset_frozen_obj) },
+    #endif
+
     #if MICROPY_ESP8266_APA102
     { MP_ROM_QSTR(MP_QSTR_apa102_write), MP_ROM_PTR(&esp_apa102_write_obj) },
     #endif
diff --git a/ports/esp8266/modules/inisetup.py b/ports/esp8266/modules/inisetup.py
index 3f3edcf6d0af0..00e0a0bf577b3 100644
--- a/ports/esp8266/modules/inisetup.py
+++ b/ports/esp8266/modules/inisetup.py
@@ -3,11 +3,61 @@
 from flashbdev import bdev
 
 
-def wifi():
-    import binascii
+def read_all(fn):
+    with open(fn, "rb") as fp:
+        while fp.read(256):
+            pass
+
+
+def fwupdate(fn, erase_all=False, safe_check=True, verbose=True):
+    import esp
+
+    # get number of blocks
+    fw_size = rem_fs = os.stat(fn)[6]
+    esp.set_dfu(0, fw_size)
+    read_all(fn)
+
+    # allocate buffer for storing sector numbers and offsets
+    nblks = esp.get_blks(False)
+    blk_buf = esp.set_dfu(nblks, fw_size)
+    if not blk_buf:
+        raise MemoryError(f"Out of memory")
 
+    # dig out block numbers and offsets using LFS2 hook
+    esp.set_dfu(0, fw_size)
+    read_all(fn)
+
+    if safe_check:
+        blks = esp.get_blks(True)
+        if blks is None:
+            raise Exception("No blocks data found")
+        blks, offs = blks
+        esp.set_dfu(-1, fw_size)
+        if verbose:
+            print(f"Verifying sector data:{blks}\n{offs}")
+        with open(fn, "rb") as fp:
+            for ii, blkid in enumerate(blks):
+                sz = min(rem_fs, 4096 - offs[ii])
+                L2 = esp.flash_read(esp.flash_user_start() + blkid * 4096 + offs[ii], sz)
+                L1 = fp.read(sz)
+                if L1 != L2:
+                    raise Exception(f"Data is different at N={ii} blkid={blkid}")
+                del L1, L2
+                rem_fs -= sz
+                if verbose:
+                    print(f"{ii}/{len(blks)}", end="\r")
+        esp.set_dfu(len(blks), fw_size)
+        del blks, offs
+        if verbose:
+            print("Success, starting firmware update ...")
+
+    esp.DFU(erase_all)
+
+
+def wifi():
     ap_if = network.WLAN(network.AP_IF)
-    ssid = b"MicroPython-%s" % binascii.hexlify(ap_if.config("mac")[-3:])
+    ap_if.active(True)
+    ssid = "MicroPython-" + ap_if.config("mac")[-3:].hex()
     ap_if.config(ssid=ssid, security=network.AUTH_WPA_WPA2_PSK, key=b"micropythoN")
 
 
diff --git a/py/frozenmod.c b/py/frozenmod.c
index 61c2f20aa1de3..3913cfe5a5533 100644
--- a/py/frozenmod.c
+++ b/py/frozenmod.c
@@ -58,6 +58,7 @@ extern const char mp_frozen_str_content[];
 #include "py/emitglue.h"
 
 extern const mp_frozen_module_t *const mp_frozen_mpy_content[];
+mp_import_stat_t (*mp_find_dynamic_frozen)(const char *str, int *frozen_type, void **data) = NULL;
 
 #endif // MICROPY_MODULE_FROZEN_MPY
 
@@ -129,7 +130,7 @@ mp_import_stat_t mp_find_frozen_module(const char *str, int *frozen_type, void *
         name += entry_len + 1;
     }
 
-    return MP_IMPORT_STAT_NO_EXIST;
+    return mp_find_dynamic_frozen?mp_find_dynamic_frozen(str, frozen_type, data):MP_IMPORT_STAT_NO_EXIST;
 }
 
 #endif // MICROPY_MODULE_FROZEN
diff --git a/py/objstr.c b/py/objstr.c
index 5dfe94ac4fe1c..be71b3f4e7abb 100644
--- a/py/objstr.c
+++ b/py/objstr.c
@@ -2252,12 +2252,12 @@ STATIC mp_obj_t mp_obj_new_str_type_from_vstr(const mp_obj_type_t *type, vstr_t
     }
 
     byte *data;
-    if (vstr->len + 1 == vstr->alloc) {
+    if (vstr->alloc == vstr->len + 1) {
         data = (byte *)vstr->buf;
     } else {
         data = (byte *)m_renew(char, vstr->buf, vstr->alloc, vstr->len + 1);
+        data[vstr->len] = '\0'; // add null byte
     }
-    data[vstr->len] = '\0'; // add null byte
     vstr->buf = NULL;
     vstr->alloc = 0;
     #if MICROPY_PY_BUILTINS_BYTEARRAY
diff --git a/py/persistentcode.c b/py/persistentcode.c
index e1218e0b8a577..81706e4589b83 100644
--- a/py/persistentcode.c
+++ b/py/persistentcode.c
@@ -162,11 +162,16 @@ STATIC qstr load_qstr(mp_reader_t *reader) {
         return len >> 1;
     }
     len >>= 1;
-    char *str = m_new(char, len);
-    read_bytes(reader, (byte *)str, len);
-    read_byte(reader); // read and discard null terminator
-    qstr qst = qstr_from_strn(str, len);
-    m_del(char, str, len);
+    qstr qst;
+    if (reader->readbytes) {
+        qst = qstr_from_strn((const char *)reader->readbytes(reader->data, len + 1), len);
+    } else {
+        char *str = m_new(char, len);
+        read_bytes(reader, (byte *)str, len);
+        read_byte(reader); // read and discard null terminator
+        qst = qstr_from_strn(str, len);
+        m_del(char, str, len);
+    }
     return qst;
 }
 
@@ -198,8 +203,13 @@ STATIC mp_obj_t load_obj(mp_reader_t *reader) {
             return MP_OBJ_FROM_PTR(tuple);
         }
         vstr_t vstr;
-        vstr_init_len(&vstr, len);
-        read_bytes(reader, (byte *)vstr.buf, len);
+        if (reader->readbytes) {
+            vstr_init_fixed_buf(&vstr, len + 1, (char *)reader->readbytes(reader->data, len));
+            vstr.len = len;
+        } else {
+            vstr_init_len(&vstr, len);
+            read_bytes(reader, (byte *)vstr.buf, len);
+        }
         if (obj_type == MP_PERSISTENT_OBJ_STR || obj_type == MP_PERSISTENT_OBJ_BYTES) {
             read_byte(reader); // skip null terminator
             if (obj_type == MP_PERSISTENT_OBJ_STR) {
@@ -238,18 +248,25 @@ STATIC mp_raw_code_t *load_raw_code(mp_reader_t *reader, mp_module_context_t *co
     #endif
 
     if (kind == MP_CODE_BYTECODE) {
-        // Allocate memory for the bytecode
-        fun_data = m_new(uint8_t, fun_data_len);
-        // Load bytecode
-        read_bytes(reader, fun_data, fun_data_len);
+        if (reader->readbytes) {
+            fun_data = reader->readbytes(reader->data, fun_data_len);
+        } else {
+            // Allocate memory for the bytecode
+            fun_data = m_new(uint8_t, fun_data_len);
+            // Load bytecode
+            read_bytes(reader, fun_data, fun_data_len);
+        }
 
     #if MICROPY_EMIT_MACHINE_CODE
     } else {
         // Allocate memory for native data and load it
-        size_t fun_alloc;
-        MP_PLAT_ALLOC_EXEC(fun_data_len, (void **)&fun_data, &fun_alloc);
-        read_bytes(reader, fun_data, fun_data_len);
-
+        if (reader->readbytes) {
+            fun_data = reader->readbytes(reader->data, fun_data_len);
+        } else {
+            size_t fun_alloc;
+            MP_PLAT_ALLOC_EXEC(fun_data_len, (void **)&fun_data, &fun_alloc);
+            read_bytes(reader, fun_data, fun_data_len);
+        }
         if (kind == MP_CODE_NATIVE_PY) {
             // Read prelude offset within fun_data, and extract scope flags.
             prelude_offset = read_uint(reader);
diff --git a/py/reader.c b/py/reader.c
index 57b12b3b655ca..4b8368ea97d4b 100644
--- a/py/reader.c
+++ b/py/reader.c
@@ -48,6 +48,19 @@ STATIC mp_uint_t mp_reader_mem_readbyte(void *data) {
     }
 }
 
+#ifdef MICROPY_DFM
+STATIC byte *mp_reader_rom_readbytes(void *data, int n_bytes) {
+    mp_reader_mem_t *reader = (mp_reader_mem_t *)data;
+    if (reader->cur < reader->end) {
+        const byte *ret = reader->cur;
+        reader->cur += n_bytes;
+        return (byte *)ret;
+    } else {
+        return (byte *)MP_READER_EOF;
+    }
+}
+#endif
+
 STATIC void mp_reader_mem_close(void *data) {
     mp_reader_mem_t *reader = (mp_reader_mem_t *)data;
     if (reader->free_len > 0) {
@@ -65,6 +78,13 @@ void mp_reader_new_mem(mp_reader_t *reader, const byte *buf, size_t len, size_t
     reader->data = rm;
     reader->readbyte = mp_reader_mem_readbyte;
     reader->close = mp_reader_mem_close;
+    reader->readbytes = NULL;
+    #ifdef MICROPY_DFM
+    extern uint32_t dynamic_frozen_start;
+    if (dynamic_frozen_start && buf >= dynamic_frozen_start && buf < 0x40300000) {
+        reader->readbytes = mp_reader_rom_readbytes;
+    }
+    #endif
 }
 
 #if MICROPY_READER_POSIX
@@ -130,6 +150,7 @@ void mp_reader_new_file_from_fd(mp_reader_t *reader, int fd, bool close_fd) {
     reader->data = rp;
     reader->readbyte = mp_reader_posix_readbyte;
     reader->close = mp_reader_posix_close;
+    reader->readbytes = NULL;
 }
 
 #if !MICROPY_VFS_POSIX
diff --git a/py/reader.h b/py/reader.h
index 8511c72ce503b..04ef3bb4dbda9 100644
--- a/py/reader.h
+++ b/py/reader.h
@@ -37,6 +37,7 @@ typedef struct _mp_reader_t {
     void *data;
     mp_uint_t (*readbyte)(void *data);
     void (*close)(void *data);
+    byte *(*readbytes)(void *data, int n_bytes); // shortcut for reading from ROM, no malloc/free needed
 } mp_reader_t;
 
 void mp_reader_new_mem(mp_reader_t *reader, const byte *buf, size_t len, size_t free_len);
diff --git a/shared/runtime/pyexec.c b/shared/runtime/pyexec.c
index e32150e5e7331..21c2ff0ff3749 100644
--- a/shared/runtime/pyexec.c
+++ b/shared/runtime/pyexec.c
@@ -261,6 +261,7 @@ STATIC void mp_reader_new_stdin(mp_reader_t *reader, mp_reader_stdin_t *reader_s
     reader->data = reader_stdin;
     reader->readbyte = mp_reader_stdin_readbyte;
     reader->close = mp_reader_stdin_close;
+    reader->readbytes = NULL;
 }
 
 STATIC int do_reader_stdin(int c) {

From 85359d4a4173b97c61e35bfda38d567a21d83e20 Mon Sep 17 00:00:00 2001
From: Wang Xuancong <xuancong84@gmail.com>
Date: Thu, 5 Oct 2023 00:07:21 +0800
Subject: [PATCH 02/51] fix bug: forgot to erase sector before
 flash_mpy_to_rom()

---
 ports/esp8266/modesp.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/ports/esp8266/modesp.c b/ports/esp8266/modesp.c
index b9085b8bd971f..8603780351517 100644
--- a/ports/esp8266/modesp.c
+++ b/ports/esp8266/modesp.c
@@ -503,13 +503,13 @@ uint8_t *scan_dynamic_frozen(mp_obj_t out_frozen_list, const char *name) {
         if (*ptr == 0xff) {
             break;              // end-of-dynamic_frozen: erased sector are filled by with 0xff in NOR flash
         }
-        if (ptr + FLASH_SEC_SIZE * ptr[1] > FLASH_END) {
-            break;                                       // corrupted frozen sector
-        }
         if (*ptr == 0) {           // deleted frozen sector has 1st byte == 0 => skip
             ptr += FLASH_SEC_SIZE;
             continue;
         }
+        if (ptr + FLASH_SEC_SIZE * ptr[1] > FLASH_END) {
+            break;                                       // corrupted frozen sector
+        }
         if (*ptr != ptr[1]) {
             break;                   // valid frozen sector must have byte1 == byte2 == #-of-sectors, or corrupted
         }
@@ -576,6 +576,9 @@ bool has_enough_free_sect(uint8_t *ptr, int n_needed) {
     return x >= n_needed;
 }
 mp_obj_t flash_mpy_to_rom(const char *filename, const char *modname, uint8_t *ptr, uint32_t filesize, int tot_secs) {
+    for(int x=0, sn=(int)(ptr-FLASH_START)/FLASH_SEC_SIZE; x<tot_secs; x++, sn++){
+        erase_sector(sn);
+    }
     mp_obj_t res = mp_const_true;
     byte buf[256] = {tot_secs, tot_secs, strlen(modname), 0};
     mp_reader_t reader;

From 4c5437a081f8326caa57800b03a931e7b5aee039 Mon Sep 17 00:00:00 2001
From: Wang Xuancong <xuancong84@gmail.com>
Date: Sun, 22 Oct 2023 00:24:25 +0800
Subject: [PATCH 03/51] adjusted for updates in upstream/master.

---
 ports/esp8266/modesp.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ports/esp8266/modesp.c b/ports/esp8266/modesp.c
index 8603780351517..102dc312ce057 100644
--- a/ports/esp8266/modesp.c
+++ b/ports/esp8266/modesp.c
@@ -582,7 +582,7 @@ mp_obj_t flash_mpy_to_rom(const char *filename, const char *modname, uint8_t *pt
     mp_obj_t res = mp_const_true;
     byte buf[256] = {tot_secs, tot_secs, strlen(modname), 0};
     mp_reader_t reader;
-    mp_reader_new_file(&reader, filename);
+    mp_reader_new_file(&reader, qstr_from_str(filename));
     *(uint32_t *)&buf[4] = filesize;
     strcpy(&buf[8], modname);
     mp_uint_t ch = 0;
@@ -618,7 +618,7 @@ bool delete_mpy_from_rom(byte *ptr) {
 bool compare_flash_to_file(const char *filename, byte *ptr) {
     bool is_diff = false;
     mp_reader_t reader;
-    mp_reader_new_file(&reader, filename);
+    mp_reader_new_file(&reader, qstr_from_str(filename));
     byte ch;
     while ((ch = reader.readbyte(reader.data)) != MP_READER_EOF) {
         if (*ptr != ch) {
@@ -637,7 +637,7 @@ STATIC mp_obj_t esp_add_frozen(size_t n_args, const mp_obj_t *args) {
     // get .mpy filesize
     int mpy_size = 0;
     mp_reader_t reader;
-    mp_reader_new_file(&reader, filename);
+    mp_reader_new_file(&reader, qstr_from_str(filename));
     while (reader.readbyte(reader.data) != MP_READER_EOF) {
         mpy_size++;
     }

From ad9d71b6bc6d7a7d6b88ac41684110af76618141 Mon Sep 17 00:00:00 2001
From: Wang Xuancong <xuancong84@gmail.com>
Date: Wed, 22 Nov 2023 15:50:23 +0800
Subject: [PATCH 04/51] after merge

---
 ports/esp8266/build.sh | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100755 ports/esp8266/build.sh

diff --git a/ports/esp8266/build.sh b/ports/esp8266/build.sh
new file mode 100755
index 0000000000000..5b23b31363fdf
--- /dev/null
+++ b/ports/esp8266/build.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+make clean
+make -j BOARD=ESP8266_GENERIC
+

From 5d05a8fda54d2142f0d43583a1471cae111df837 Mon Sep 17 00:00:00 2001
From: Wang Xuancong <xuancong84@gmail.com>
Date: Wed, 20 Dec 2023 08:07:34 +0800
Subject: [PATCH 05/51] extended ESP32 WDT timeout for OpenSmartHome

---
 ports/esp32/boards/sdkconfig.base | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/ports/esp32/boards/sdkconfig.base b/ports/esp32/boards/sdkconfig.base
index 05624f0d7409b..b89472f166cd2 100644
--- a/ports/esp32/boards/sdkconfig.base
+++ b/ports/esp32/boards/sdkconfig.base
@@ -38,6 +38,8 @@ CONFIG_XTAL_FREQ_AUTO=y
 # Only on: ESP32, ESP32S3
 CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0=n
 CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1=n
+CONFIG_ESP_INT_WDT_TIMEOUT_MS=6000
+CONFIG_ESP_TASK_WDT_TIMEOUT_S=10
 
 # Power Management
 CONFIG_PM_ENABLE=y

From 4b4f6011e8d1b87a86c8b680b2aa0702fe8e1829 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Tue, 2 Jan 2024 01:03:13 +1100
Subject: [PATCH 06/51] rp2/rp2_flash: Lockout second core only when doing
 flash erase/write.

Using the multicore lockout feature in the general atomic section makes it
much more difficult to get correct.

Signed-off-by: Damien George <damien@micropython.org>
---
 ports/rp2/mpthreadport.c |  4 ----
 ports/rp2/rp2_flash.c    | 31 ++++++++++++++++++++++---------
 2 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/ports/rp2/mpthreadport.c b/ports/rp2/mpthreadport.c
index 968de1f782e69..7bffabb3355eb 100644
--- a/ports/rp2/mpthreadport.c
+++ b/ports/rp2/mpthreadport.c
@@ -52,9 +52,6 @@ uint32_t mp_thread_begin_atomic_section(void) {
         // When both cores are executing, we also need to provide
         // full mutual exclusion.
         mp_thread_mutex_lock(&atomic_mutex, 1);
-        // In case this atomic section is for flash access, then
-        // suspend the other core.
-        multicore_lockout_start_blocking();
     }
 
     return save_and_disable_interrupts();
@@ -64,7 +61,6 @@ void mp_thread_end_atomic_section(uint32_t state) {
     restore_interrupts(state);
 
     if (core1_entry) {
-        multicore_lockout_end_blocking();
         mp_thread_mutex_unlock(&atomic_mutex);
     }
 }
diff --git a/ports/rp2/rp2_flash.c b/ports/rp2/rp2_flash.c
index b1afe1cbd1e72..35c51641692f4 100644
--- a/ports/rp2/rp2_flash.c
+++ b/ports/rp2/rp2_flash.c
@@ -70,6 +70,22 @@ bi_decl(bi_block_device(
     BINARY_INFO_BLOCK_DEV_FLAG_WRITE |
     BINARY_INFO_BLOCK_DEV_FLAG_PT_UNKNOWN));
 
+// Flash erase and write must run with interrupts disabled and the other core suspended,
+// because the XIP bit gets disabled.
+static uint32_t begin_critical_flash_section(void) {
+    if (multicore_lockout_victim_is_initialized(1 - get_core_num())) {
+        multicore_lockout_start_blocking();
+    }
+    return save_and_disable_interrupts();
+}
+
+static void end_critical_flash_section(uint32_t state) {
+    restore_interrupts(state);
+    if (multicore_lockout_victim_is_initialized(1 - get_core_num())) {
+        multicore_lockout_end_blocking();
+    }
+}
+
 STATIC mp_obj_t rp2_flash_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
     // Parse arguments
     enum { ARG_start, ARG_len };
@@ -135,19 +151,17 @@ STATIC mp_obj_t rp2_flash_writeblocks(size_t n_args, const mp_obj_t *args) {
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_READ);
     if (n_args == 3) {
-        // Flash erase/program must run in an atomic section because the XIP bit gets disabled.
-        mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
+        mp_uint_t atomic_state = begin_critical_flash_section();
         flash_range_erase(self->flash_base + offset, bufinfo.len);
-        MICROPY_END_ATOMIC_SECTION(atomic_state);
+        end_critical_flash_section(atomic_state);
         mp_event_handle_nowait();
         // TODO check return value
     } else {
         offset += mp_obj_get_int(args[3]);
     }
-    // Flash erase/program must run in an atomic section because the XIP bit gets disabled.
-    mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
+    mp_uint_t atomic_state = begin_critical_flash_section();
     flash_range_program(self->flash_base + offset, bufinfo.buf, bufinfo.len);
-    MICROPY_END_ATOMIC_SECTION(atomic_state);
+    end_critical_flash_section(atomic_state);
     mp_event_handle_nowait();
     // TODO check return value
     return mp_const_none;
@@ -170,10 +184,9 @@ STATIC mp_obj_t rp2_flash_ioctl(mp_obj_t self_in, mp_obj_t cmd_in, mp_obj_t arg_
             return MP_OBJ_NEW_SMALL_INT(BLOCK_SIZE_BYTES);
         case MP_BLOCKDEV_IOCTL_BLOCK_ERASE: {
             uint32_t offset = mp_obj_get_int(arg_in) * BLOCK_SIZE_BYTES;
-            // Flash erase/program must run in an atomic section because the XIP bit gets disabled.
-            mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
+            mp_uint_t atomic_state = begin_critical_flash_section();
             flash_range_erase(self->flash_base + offset, BLOCK_SIZE_BYTES);
-            MICROPY_END_ATOMIC_SECTION(atomic_state);
+            end_critical_flash_section(atomic_state);
             // TODO check return value
             return MP_OBJ_NEW_SMALL_INT(0);
         }

From 61b8361f5f98eba0e0ebd747ca7ef6259d3790d9 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Tue, 2 Jan 2024 14:45:44 +1100
Subject: [PATCH 07/51] rp2/mutex_extra: Implement additional mutex functions.

These allow entering/exiting a mutex and also disabling/restoring
interrupts, in an atomic way.

Signed-off-by: Damien George <damien@micropython.org>
---
 LICENSE                  |  2 ++
 ports/rp2/CMakeLists.txt |  1 +
 ports/rp2/mutex_extra.c  | 30 ++++++++++++++++++++++++++++++
 ports/rp2/mutex_extra.h  | 34 ++++++++++++++++++++++++++++++++++
 4 files changed, 67 insertions(+)
 create mode 100644 ports/rp2/mutex_extra.c
 create mode 100644 ports/rp2/mutex_extra.h

diff --git a/LICENSE b/LICENSE
index 9bd457b42acea..b85f31808a483 100644
--- a/LICENSE
+++ b/LICENSE
@@ -69,6 +69,8 @@ used during the build process and is not part of the compiled source code.
             /FreeRTOS (GPL-2.0 with FreeRTOS exception)
         /esp32
             /ppp_set_auth.* (Apache-2.0)
+        /rp2
+            /mutex_extra.c (BSD-3-clause)
         /stm32
             /usbd*.c (MCD-ST Liberty SW License Agreement V2)
             /stm32_it.* (MIT + BSD-3-clause)
diff --git a/ports/rp2/CMakeLists.txt b/ports/rp2/CMakeLists.txt
index 559ae23f52e3c..281b0c3bc2846 100644
--- a/ports/rp2/CMakeLists.txt
+++ b/ports/rp2/CMakeLists.txt
@@ -129,6 +129,7 @@ set(MICROPY_SOURCE_PORT
     mphalport.c
     mpnetworkport.c
     mpthreadport.c
+    mutex_extra.c
     pendsv.c
     rp2_flash.c
     rp2_pio.c
diff --git a/ports/rp2/mutex_extra.c b/ports/rp2/mutex_extra.c
new file mode 100644
index 0000000000000..6df57e64ce50f
--- /dev/null
+++ b/ports/rp2/mutex_extra.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "mutex_extra.h"
+
+// These functions are taken from lib/pico-sdk/src/common/pico_sync/mutex.c and modified
+// so that they atomically obtain the mutex and disable interrupts.
+
+uint32_t __time_critical_func(mutex_enter_blocking_and_disable_interrupts)(mutex_t * mtx) {
+    lock_owner_id_t caller = lock_get_caller_owner_id();
+    do {
+        uint32_t save = spin_lock_blocking(mtx->core.spin_lock);
+        if (!lock_is_owner_id_valid(mtx->owner)) {
+            mtx->owner = caller;
+            spin_unlock_unsafe(mtx->core.spin_lock);
+            return save;
+        }
+        lock_internal_spin_unlock_with_wait(&mtx->core, save);
+    } while (true);
+}
+
+void __time_critical_func(mutex_exit_and_restore_interrupts)(mutex_t * mtx, uint32_t save) {
+    spin_lock_unsafe_blocking(mtx->core.spin_lock);
+    assert(lock_is_owner_id_valid(mtx->owner));
+    mtx->owner = LOCK_INVALID_OWNER_ID;
+    lock_internal_spin_unlock_with_notify(&mtx->core, save);
+}
diff --git a/ports/rp2/mutex_extra.h b/ports/rp2/mutex_extra.h
new file mode 100644
index 0000000000000..be7cb96dcc53d
--- /dev/null
+++ b/ports/rp2/mutex_extra.h
@@ -0,0 +1,34 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2023 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef MICROPY_INCLUDED_RP2_MUTEX_EXTRA_H
+#define MICROPY_INCLUDED_RP2_MUTEX_EXTRA_H
+
+#include "pico/mutex.h"
+
+uint32_t mutex_enter_blocking_and_disable_interrupts(mutex_t *mtx);
+void mutex_exit_and_restore_interrupts(mutex_t *mtx, uint32_t save);
+
+#endif // MICROPY_INCLUDED_RP2_MUTEX_EXTRA_H

From ac5e0b9f62a27eb0e8904f554e9050066180a4c2 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Tue, 2 Jan 2024 01:04:03 +1100
Subject: [PATCH 08/51] rp2/mpthreadport: Fix race with IRQ when entering
 atomic section.

Prior to this commit there is a potential deadlock in
mp_thread_begin_atomic_section(), when obtaining the atomic_mutex, in the
following situation:
- main thread calls mp_thread_begin_atomic_section() (for whatever reason,
  doesn't matter)
- the second core is running so the main thread grabs the mutex via the
  call mp_thread_mutex_lock(&atomic_mutex, 1), and this succeeds
- before the main thread has a chance to run save_and_disable_interrupts()
  a USB IRQ comes in and the main thread jumps off to process this IRQ
- that USB processing triggers a call to the dcd_event_handler() wrapper
  from commit bcbdee235719d459a4cd60d51021454fba54cd0f
- that then calls mp_sched_schedule_node()
- that then attempts to obtain the atomic section, calling
  mp_thread_begin_atomic_section()
- that call then blocks trying to obtain atomic_mutex
- core0 is now deadlocked on itself, because the main thread has the mutex
  but the IRQ handler (which preempted the main thread) is blocked waiting
  for the mutex, which will never be free

The solution in this commit is to use mutex enter/exit functions that also
atomically disable/restore interrupts.

Fixes issues #12980 and #13288.

Signed-off-by: Damien George <damien@micropython.org>
---
 ports/rp2/mpthreadport.c | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/ports/rp2/mpthreadport.c b/ports/rp2/mpthreadport.c
index 7bffabb3355eb..fd868329c38d5 100644
--- a/ports/rp2/mpthreadport.c
+++ b/ports/rp2/mpthreadport.c
@@ -30,6 +30,7 @@
 #include "py/mpthread.h"
 #include "pico/stdlib.h"
 #include "pico/multicore.h"
+#include "mutex_extra.h"
 
 #if MICROPY_PY_THREAD
 
@@ -45,23 +46,23 @@ STATIC uint32_t *core1_stack = NULL;
 STATIC size_t core1_stack_num_words = 0;
 
 // Thread mutex.
-STATIC mp_thread_mutex_t atomic_mutex;
+STATIC mutex_t atomic_mutex;
 
 uint32_t mp_thread_begin_atomic_section(void) {
     if (core1_entry) {
         // When both cores are executing, we also need to provide
         // full mutual exclusion.
-        mp_thread_mutex_lock(&atomic_mutex, 1);
+        return mutex_enter_blocking_and_disable_interrupts(&atomic_mutex);
+    } else {
+        return save_and_disable_interrupts();
     }
-
-    return save_and_disable_interrupts();
 }
 
 void mp_thread_end_atomic_section(uint32_t state) {
-    restore_interrupts(state);
-
-    if (core1_entry) {
-        mp_thread_mutex_unlock(&atomic_mutex);
+    if (atomic_mutex.owner != LOCK_INVALID_OWNER_ID) {
+        mutex_exit_and_restore_interrupts(&atomic_mutex, state);
+    } else {
+        restore_interrupts(state);
     }
 }
 
@@ -69,7 +70,7 @@ void mp_thread_end_atomic_section(uint32_t state) {
 void mp_thread_init(void) {
     assert(get_core_num() == 0);
 
-    mp_thread_mutex_init(&atomic_mutex);
+    mutex_init(&atomic_mutex);
 
     // Allow MICROPY_BEGIN_ATOMIC_SECTION to be invoked from core1.
     multicore_lockout_victim_init();

From 9b8c64c9cee8203be167e6bffc74e186ae2fc958 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Fri, 5 Jan 2024 12:33:34 +1100
Subject: [PATCH 09/51] all: Bump version to 1.22.1.

Signed-off-by: Damien George <damien@micropython.org>
---
 py/mpconfig.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py/mpconfig.h b/py/mpconfig.h
index 66a083da457b5..e0d1ad44eb132 100644
--- a/py/mpconfig.h
+++ b/py/mpconfig.h
@@ -31,7 +31,7 @@
 // are unavailable.
 #define MICROPY_VERSION_MAJOR 1
 #define MICROPY_VERSION_MINOR 22
-#define MICROPY_VERSION_MICRO 0
+#define MICROPY_VERSION_MICRO 1
 #define MICROPY_VERSION_PRERELEASE 0
 
 // Combined version as a 32-bit number for convenience to allow version

From d5f3fcd935f778d89918449b123f1c7bd6398cdf Mon Sep 17 00:00:00 2001
From: Nicko van Someren <nicko@nicko.org>
Date: Sat, 6 Jan 2024 16:33:12 -0700
Subject: [PATCH 10/51] rp2/rp2_dma: Fix fetching 'write' buffers for writing
 not reading.

Signed-off-by: Nicko van Someren <nicko@nicko.org>
---
 ports/rp2/rp2_dma.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ports/rp2/rp2_dma.c b/ports/rp2/rp2_dma.c
index acc18d08c58da..893498265aa41 100644
--- a/ports/rp2/rp2_dma.c
+++ b/ports/rp2/rp2_dma.c
@@ -86,7 +86,7 @@ STATIC const uint32_t rp2_dma_ctrl_field_count = MP_ARRAY_SIZE(rp2_dma_ctrl_fiel
 STATIC uint32_t rp2_dma_register_value_from_obj(mp_obj_t o, int reg_type) {
     if (reg_type == REG_TYPE_ADDR_READ || reg_type == REG_TYPE_ADDR_WRITE) {
         mp_buffer_info_t buf_info;
-        mp_uint_t flags = MP_BUFFER_READ;
+        mp_uint_t flags = (reg_type == REG_TYPE_ADDR_READ) ? MP_BUFFER_READ : MP_BUFFER_WRITE;
         if (mp_get_buffer(o, &buf_info, flags)) {
             return (uint32_t)buf_info.buf;
         }

From 068aa28fc51fff6c90f410d8a917fcb5a9dc0b34 Mon Sep 17 00:00:00 2001
From: robert-hh <robert@hammelrath.com>
Date: Sun, 7 Jan 2024 17:53:53 +0100
Subject: [PATCH 11/51] rp2/machine_uart: Fix event wait in uart.flush() and
 uart.read().

Do not wait in the worst case up to the timeout.

Fixes issue #13377.

Signed-off-by: robert-hh <robert@hammelrath.com>
---
 ports/rp2/machine_uart.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ports/rp2/machine_uart.c b/ports/rp2/machine_uart.c
index d751b7af07a2e..bca07cebfcbf3 100644
--- a/ports/rp2/machine_uart.c
+++ b/ports/rp2/machine_uart.c
@@ -483,7 +483,7 @@ STATIC mp_uint_t mp_machine_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t
                     return i;
                 }
             }
-            mp_event_wait_ms(timeout - elapsed);
+            mp_event_handle_nowait();
         }
         *dest++ = ringbuf_get(&(self->read_buffer));
         start = mp_hal_ticks_ms(); // Inter-character timeout
@@ -559,7 +559,7 @@ STATIC mp_uint_t mp_machine_uart_ioctl(mp_obj_t self_in, mp_uint_t request, uint
             if (now >= timeout) {
                 break;
             }
-            mp_event_wait_ms((timeout - now) / 1000);
+            mp_event_handle_nowait();
         }
         *errcode = MP_ETIMEDOUT;
         ret = MP_STREAM_ERROR;

From 4c7d955a62f35818f73ca8a569d8fd70920023be Mon Sep 17 00:00:00 2001
From: iabdalkader <i.abdalkader@gmail.com>
Date: Fri, 12 Jan 2024 14:17:44 +0200
Subject: [PATCH 12/51] renesas-ra/ra: Fix SysTick clock source.

The SysTick_Config function must use the system/CPU clock to configure the
ticks.

Signed-off-by: iabdalkader <i.abdalkader@gmail.com>
---
 ports/renesas-ra/ra/ra_config.h | 1 +
 ports/renesas-ra/ra/ra_init.c   | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/ports/renesas-ra/ra/ra_config.h b/ports/renesas-ra/ra/ra_config.h
index a2df775c8902b..a9d4bb803d29c 100644
--- a/ports/renesas-ra/ra/ra_config.h
+++ b/ports/renesas-ra/ra/ra_config.h
@@ -26,6 +26,7 @@
 #define RA_RA_CONFIG_H_
 
 #include <stdint.h>
+#include "py/mpconfig.h"
 
 #if defined(RA4M1) | defined(RA4W1)
 #define SCI_CH_MAX      10
diff --git a/ports/renesas-ra/ra/ra_init.c b/ports/renesas-ra/ra/ra_init.c
index c9b78e0dd17fc..a784aec707ac8 100644
--- a/ports/renesas-ra/ra/ra_init.c
+++ b/ports/renesas-ra/ra/ra_init.c
@@ -30,7 +30,7 @@
 
 void ra_init(void) {
     ra_int_init();
-    SysTick_Config(PCLK / 1000);
+    SysTick_Config(MICROPY_HW_MCU_SYSCLK / 1000);
     internal_flash_init();
 }
 

From 1e8cc6c5034f161bfed29002e5bd70eb4aeccbd6 Mon Sep 17 00:00:00 2001
From: iabdalkader <i.abdalkader@gmail.com>
Date: Wed, 17 Jan 2024 12:05:57 +0200
Subject: [PATCH 13/51] renesas-ra/boards/ARDUINO_PORTENTA_C33: Fix the RTC
 clock source.

Switch the RTC clock source to Sub-clock (XCIN). This board has an
accurate LSE crystal, and it should be used for the RTC clock
source.

Signed-off-by: iabdalkader <i.abdalkader@gmail.com>
---
 ports/renesas-ra/boards/ARDUINO_PORTENTA_C33/mpconfigboard.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ports/renesas-ra/boards/ARDUINO_PORTENTA_C33/mpconfigboard.h b/ports/renesas-ra/boards/ARDUINO_PORTENTA_C33/mpconfigboard.h
index 52346dedc44ee..f28deb0cebcaf 100644
--- a/ports/renesas-ra/boards/ARDUINO_PORTENTA_C33/mpconfigboard.h
+++ b/ports/renesas-ra/boards/ARDUINO_PORTENTA_C33/mpconfigboard.h
@@ -28,7 +28,7 @@
 // peripheral config
 #define MICROPY_HW_ENABLE_RNG       (1)
 #define MICROPY_HW_ENABLE_RTC       (1)
-#define MICROPY_HW_RTC_SOURCE       (1)
+#define MICROPY_HW_RTC_SOURCE       (0)
 #define MICROPY_HW_ENABLE_ADC       (1)
 #define MICROPY_HW_HAS_FLASH        (1)
 #define MICROPY_HW_ENABLE_USBDEV    (1)

From a2e9ab362bec09fa9411391c89efec569a64c61c Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Fri, 19 Jan 2024 10:07:51 +1100
Subject: [PATCH 14/51] extmod/asyncio: Support gather of tasks that finish
 early.

Adds support to asyncio.gather() for the case that one or more (or all)
sub-tasks finish and/or raise an exception before the gather starts.

Signed-off-by: Damien George <damien@micropython.org>
---
 extmod/asyncio/core.py                        |  5 ++
 extmod/asyncio/funcs.py                       | 49 +++++++++-----
 tests/extmod/asyncio_gather_finished_early.py | 65 +++++++++++++++++++
 3 files changed, 102 insertions(+), 17 deletions(-)
 create mode 100644 tests/extmod/asyncio_gather_finished_early.py

diff --git a/extmod/asyncio/core.py b/extmod/asyncio/core.py
index 214cc52f45f53..e5af3038f77bb 100644
--- a/extmod/asyncio/core.py
+++ b/extmod/asyncio/core.py
@@ -219,6 +219,11 @@ def run_until_complete(main_task=None):
             elif t.state is None:
                 # Task is already finished and nothing await'ed on the task,
                 # so call the exception handler.
+
+                # Save exception raised by the coro for later use.
+                t.data = exc
+
+                # Create exception context and call the exception handler.
                 _exc_context["exception"] = exc
                 _exc_context["future"] = t
                 Loop.call_exception_handler(_exc_context)
diff --git a/extmod/asyncio/funcs.py b/extmod/asyncio/funcs.py
index 599091dfbdc2b..3ef8a76b1d151 100644
--- a/extmod/asyncio/funcs.py
+++ b/extmod/asyncio/funcs.py
@@ -63,9 +63,6 @@ def remove(t):
 
 # async
 def gather(*aws, return_exceptions=False):
-    if not aws:
-        return []
-
     def done(t, er):
         # Sub-task "t" has finished, with exception "er".
         nonlocal state
@@ -86,26 +83,39 @@ def done(t, er):
         # Gather waiting is done, schedule the main gather task.
         core._task_queue.push(gather_task)
 
+    # Prepare the sub-tasks for the gather.
+    # The `state` variable counts the number of tasks to wait for, and can be negative
+    # if the gather should not run at all (because a task already had an exception).
     ts = [core._promote_to_task(aw) for aw in aws]
+    state = 0
     for i in range(len(ts)):
-        if ts[i].state is not True:
-            # Task is not running, gather not currently supported for this case.
+        if ts[i].state is True:
+            # Task is running, register the callback to call when the task is done.
+            ts[i].state = done
+            state += 1
+        elif not ts[i].state:
+            # Task finished already.
+            if not isinstance(ts[i].data, StopIteration):
+                # Task finished by raising an exception.
+                if not return_exceptions:
+                    # Do not run this gather at all.
+                    state = -len(ts)
+        else:
+            # Task being waited on, gather not currently supported for this case.
             raise RuntimeError("can't gather")
-        # Register the callback to call when the task is done.
-        ts[i].state = done
 
     # Set the state for execution of the gather.
     gather_task = core.cur_task
-    state = len(ts)
     cancel_all = False
 
-    # Wait for the a sub-task to need attention.
-    gather_task.data = _Remove
-    try:
-        yield
-    except core.CancelledError as er:
-        cancel_all = True
-        state = er
+    # Wait for a sub-task to need attention (if there are any to wait for).
+    if state > 0:
+        gather_task.data = _Remove
+        try:
+            yield
+        except core.CancelledError as er:
+            cancel_all = True
+            state = er
 
     # Clean up tasks.
     for i in range(len(ts)):
@@ -118,8 +128,13 @@ def done(t, er):
             # Sub-task ran to completion, get its return value.
             ts[i] = ts[i].data.value
         else:
-            # Sub-task had an exception with return_exceptions==True, so get its exception.
-            ts[i] = ts[i].data
+            # Sub-task had an exception.
+            if return_exceptions:
+                # Get the sub-task exception to return in the list of return values.
+                ts[i] = ts[i].data
+            elif isinstance(state, int):
+                # Raise the sub-task exception, if there is not already an exception to raise.
+                state = ts[i].data
 
     # Either this gather was cancelled, or one of the sub-tasks raised an exception with
     # return_exceptions==False, so reraise the exception here.
diff --git a/tests/extmod/asyncio_gather_finished_early.py b/tests/extmod/asyncio_gather_finished_early.py
new file mode 100644
index 0000000000000..030e79e3571b5
--- /dev/null
+++ b/tests/extmod/asyncio_gather_finished_early.py
@@ -0,0 +1,65 @@
+# Test asyncio.gather() when a task is already finished before the gather starts.
+
+try:
+    import asyncio
+except ImportError:
+    print("SKIP")
+    raise SystemExit
+
+
+# CPython and MicroPython differ in when they signal (and print) that a task raised an
+# uncaught exception.  So define an empty custom_handler() to suppress this output.
+def custom_handler(loop, context):
+    pass
+
+
+async def task_that_finishes_early(id, event, fail):
+    print("task_that_finishes_early", id)
+    event.set()
+    if fail:
+        raise ValueError("intentional exception", id)
+
+
+async def task_that_runs():
+    for i in range(5):
+        print("task_that_runs", i)
+        await asyncio.sleep(0)
+
+
+async def main(start_task_that_runs, task_fail, return_exceptions):
+    print("== start", start_task_that_runs, task_fail, return_exceptions)
+
+    # Set exception handler to suppress exception output.
+    loop = asyncio.get_event_loop()
+    loop.set_exception_handler(custom_handler)
+
+    # Create tasks.
+    event_a = asyncio.Event()
+    event_b = asyncio.Event()
+    tasks = []
+    if start_task_that_runs:
+        tasks.append(asyncio.create_task(task_that_runs()))
+    tasks.append(asyncio.create_task(task_that_finishes_early("a", event_a, task_fail)))
+    tasks.append(asyncio.create_task(task_that_finishes_early("b", event_b, task_fail)))
+
+    # Make sure task_that_finishes_early() are both done, before calling gather().
+    await event_a.wait()
+    await event_b.wait()
+
+    # Gather the tasks.
+    try:
+        result = "complete", await asyncio.gather(*tasks, return_exceptions=return_exceptions)
+    except Exception as er:
+        result = "exception", er, start_task_that_runs and tasks[0].done()
+
+    # Wait for the final task to finish (if it was started).
+    if start_task_that_runs:
+        await tasks[0]
+
+    # Print results.
+    print(result)
+
+
+# Run the test in the 8 different combinations of its arguments.
+for i in range(8):
+    asyncio.run(main(bool(i & 4), bool(i & 2), bool(i & 1)))

From 8b6e89a8ca87a4ae045f9f1a6a0fdff08984bde0 Mon Sep 17 00:00:00 2001
From: "Kwabena W. Agyeman" <kwagyeman@live.com>
Date: Mon, 22 Jan 2024 14:01:02 -0800
Subject: [PATCH 15/51] mimxrt/modmachine: Fix deepsleep wakeup pin ifdef.

Signed-off-by: Kwabena W. Agyeman <kwagyeman@live.com>
---
 ports/mimxrt/modmachine.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ports/mimxrt/modmachine.c b/ports/mimxrt/modmachine.c
index b87747b409c9f..e01703af8cd4b 100644
--- a/ports/mimxrt/modmachine.c
+++ b/ports/mimxrt/modmachine.c
@@ -139,10 +139,10 @@ NORETURN STATIC void mp_machine_deepsleep(size_t n_args, const mp_obj_t *args) {
         }
     }
 
-    #ifdef MIMXRT117x_SERIES
+    #if defined(MIMXRT117x_SERIES)
     machine_pin_config(pin_WAKEUP_DIG, PIN_MODE_IT_RISING, PIN_PULL_DISABLED, PIN_DRIVE_OFF, 0, PIN_AF_MODE_ALT5);
     GPC_CM_EnableIrqWakeup(GPC_CPU_MODE_CTRL_0, GPIO13_Combined_0_31_IRQn, true);
-    #elif defined IOMUXC_SNVS_WAKEUP_GPIO5_IO00
+    #elif defined(pin_WAKEUP)
     machine_pin_config(pin_WAKEUP, PIN_MODE_IT_RISING, PIN_PULL_DISABLED, PIN_DRIVE_OFF, 0, PIN_AF_MODE_ALT5);
     GPC_EnableIRQ(GPC, GPIO5_Combined_0_15_IRQn);
     #endif

From 2531a15200cab1bd1c3d9bfbb4f5ce95fc561f3f Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 29 Jan 2024 15:11:46 +1100
Subject: [PATCH 16/51] extmod/modssl_mbedtls: Fix cipher iteration in
 SSLContext.get_ciphers.

Prior to this commit it would skip every second cipher returned from
mbedtls.

The corresponding test is also updated and now passes on esp32, rp2, stm32
and unix.

Signed-off-by: Damien George <damien@micropython.org>
---
 extmod/modssl_mbedtls.c                    | 4 ----
 tests/extmod/ssl_sslcontext_ciphers.py     | 4 +++-
 tests/extmod/ssl_sslcontext_ciphers.py.exp | 4 ++++
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/extmod/modssl_mbedtls.c b/extmod/modssl_mbedtls.c
index 0190c96a9ab19..b6275d8d88fb7 100644
--- a/extmod/modssl_mbedtls.c
+++ b/extmod/modssl_mbedtls.c
@@ -311,10 +311,6 @@ STATIC mp_obj_t ssl_context_get_ciphers(mp_obj_t self_in) {
     for (const int *cipher_list = mbedtls_ssl_list_ciphersuites(); *cipher_list; ++cipher_list) {
         const char *cipher_name = mbedtls_ssl_get_ciphersuite_name(*cipher_list);
         mp_obj_list_append(list, MP_OBJ_FROM_PTR(mp_obj_new_str(cipher_name, strlen(cipher_name))));
-        cipher_list++;
-        if (!*cipher_list) {
-            break;
-        }
     }
     return list;
 }
diff --git a/tests/extmod/ssl_sslcontext_ciphers.py b/tests/extmod/ssl_sslcontext_ciphers.py
index d87e96afdf337..20c00b917623c 100644
--- a/tests/extmod/ssl_sslcontext_ciphers.py
+++ b/tests/extmod/ssl_sslcontext_ciphers.py
@@ -12,7 +12,9 @@
 ciphers = ctx.get_ciphers()
 
 for ci in ciphers:
-    print(ci)
+    # Only print those ciphers know to exist on all ports.
+    if ("TLS-ECDHE-ECDSA-WITH-AES" in ci or "TLS-RSA-WITH-AES" in ci) and "CBC" in ci:
+        print(ci)
 
 ctx.set_ciphers(ciphers[:1])
 
diff --git a/tests/extmod/ssl_sslcontext_ciphers.py.exp b/tests/extmod/ssl_sslcontext_ciphers.py.exp
index 4d243a7883b7c..0d21a3bd253e7 100644
--- a/tests/extmod/ssl_sslcontext_ciphers.py.exp
+++ b/tests/extmod/ssl_sslcontext_ciphers.py.exp
@@ -1,6 +1,10 @@
 TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA384
+TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA
 TLS-ECDHE-ECDSA-WITH-AES-128-CBC-SHA256
+TLS-ECDHE-ECDSA-WITH-AES-128-CBC-SHA
 TLS-RSA-WITH-AES-256-CBC-SHA256
+TLS-RSA-WITH-AES-256-CBC-SHA
 TLS-RSA-WITH-AES-128-CBC-SHA256
+TLS-RSA-WITH-AES-128-CBC-SHA
 object 'str' isn't a tuple or list
 (-24192, 'MBEDTLS_ERR_SSL_BAD_CONFIG')

From f53ee9f12b20ab98df37b71ae0cbcc89d0fd5268 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Tue, 30 Jan 2024 12:28:30 +1100
Subject: [PATCH 17/51] rp2: Change machine.I2S and rp2.DMA to use shared DMA
 IRQ handlers.

These separate drivers must share the DMA resource with each other.

Fixes issue #13380.

Signed-off-by: Damien George <damien@micropython.org>
---
 ports/rp2/CMakeLists.txt |  1 +
 ports/rp2/machine_i2s.c  |  6 ++----
 ports/rp2/rp2_dma.c      | 14 +++++++-------
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/ports/rp2/CMakeLists.txt b/ports/rp2/CMakeLists.txt
index 281b0c3bc2846..3a46fdaa7f47b 100644
--- a/ports/rp2/CMakeLists.txt
+++ b/ports/rp2/CMakeLists.txt
@@ -474,6 +474,7 @@ target_compile_definitions(${MICROPY_TARGET} PRIVATE
     PICO_FLOAT_PROPAGATE_NANS=1
     PICO_STACK_SIZE=0x2000
     PICO_CORE1_STACK_SIZE=0
+    PICO_MAX_SHARED_IRQ_HANDLERS=8 # we need more than the default
     PICO_PROGRAM_NAME="MicroPython"
     PICO_NO_PROGRAM_VERSION_STRING=1 # do it ourselves in main.c
     MICROPY_BUILD_TYPE="${CMAKE_C_COMPILER_ID} ${CMAKE_C_COMPILER_VERSION} ${CMAKE_BUILD_TYPE}"
diff --git a/ports/rp2/machine_i2s.c b/ports/rp2/machine_i2s.c
index 68a0f296a01fe..ae8026a4af662 100644
--- a/ports/rp2/machine_i2s.c
+++ b/ports/rp2/machine_i2s.c
@@ -232,20 +232,18 @@ STATIC void feed_dma(machine_i2s_obj_t *self, uint8_t *dma_buffer_p) {
 
 STATIC void irq_configure(machine_i2s_obj_t *self) {
     if (self->i2s_id == 0) {
-        irq_set_exclusive_handler(DMA_IRQ_0, dma_irq0_handler);
+        irq_add_shared_handler(DMA_IRQ_0, dma_irq0_handler, PICO_SHARED_IRQ_HANDLER_DEFAULT_ORDER_PRIORITY);
         irq_set_enabled(DMA_IRQ_0, true);
     } else {
-        irq_set_exclusive_handler(DMA_IRQ_1, dma_irq1_handler);
+        irq_add_shared_handler(DMA_IRQ_1, dma_irq1_handler, PICO_SHARED_IRQ_HANDLER_DEFAULT_ORDER_PRIORITY);
         irq_set_enabled(DMA_IRQ_1, true);
     }
 }
 
 STATIC void irq_deinit(machine_i2s_obj_t *self) {
     if (self->i2s_id == 0) {
-        irq_set_enabled(DMA_IRQ_0, false);
         irq_remove_handler(DMA_IRQ_0, dma_irq0_handler);
     } else {
-        irq_set_enabled(DMA_IRQ_1, false);
         irq_remove_handler(DMA_IRQ_1, dma_irq1_handler);
     }
 }
diff --git a/ports/rp2/rp2_dma.c b/ports/rp2/rp2_dma.c
index 893498265aa41..425fb417fa5ec 100644
--- a/ports/rp2/rp2_dma.c
+++ b/ports/rp2/rp2_dma.c
@@ -98,18 +98,16 @@ STATIC uint32_t rp2_dma_register_value_from_obj(mp_obj_t o, int reg_type) {
 STATIC void rp2_dma_irq_handler(void) {
     // Main IRQ handler
     uint32_t irq_bits = dma_hw->ints0;
-    dma_hw->ints0 = 0xffff;
 
     for (int i = 0; i < NUM_DMA_CHANNELS; i++) {
         if (irq_bits & (1u << i)) {
             mp_irq_obj_t *handler = MP_STATE_PORT(rp2_dma_irq_obj[i]);
             if (handler) {
+                // An rp2.DMA IRQ handler is registered for this channel, so handle it.
+                dma_channel_acknowledge_irq0(i);
                 rp2_dma_obj_t *self = (rp2_dma_obj_t *)handler->parent;
                 self->irq_flag = 1;
                 mp_irq_handler(handler);
-            } else {
-                // We got an interrupt with no handler. Disable the channel
-                dma_channel_set_irq0_enabled(i, false);
             }
         }
     }
@@ -389,6 +387,9 @@ STATIC mp_obj_t rp2_dma_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
     if (irq == NULL) {
         irq = mp_irq_new(&rp2_dma_irq_methods, MP_OBJ_FROM_PTR(self));
         MP_STATE_PORT(rp2_dma_irq_obj[self->channel]) = irq;
+
+        // Clear any existing IRQs on this DMA channel, they are not for us.
+        dma_channel_acknowledge_irq0(self->channel);
     }
 
     if (n_args > 1 || kw_args->used != 0) {
@@ -457,12 +458,11 @@ MP_DEFINE_CONST_OBJ_TYPE(
 void rp2_dma_init(void) {
     // Set up interrupts.
     memset(MP_STATE_PORT(rp2_dma_irq_obj), 0, sizeof(MP_STATE_PORT(rp2_dma_irq_obj)));
-    irq_set_exclusive_handler(DMA_IRQ_0, rp2_dma_irq_handler);
+    irq_add_shared_handler(DMA_IRQ_0, rp2_dma_irq_handler, PICO_SHARED_IRQ_HANDLER_DEFAULT_ORDER_PRIORITY);
 }
 
 void rp2_dma_deinit(void) {
-    // Disable and clear interrupts.
-    irq_set_mask_enabled(1u << DMA_IRQ_0, false);
+    // Remove our interrupt handler.
     irq_remove_handler(DMA_IRQ_0, rp2_dma_irq_handler);
 }
 

From b979c5a92af5d23bc89c5cc9c6ebb97a36179a53 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Wed, 31 Jan 2024 12:56:29 +1100
Subject: [PATCH 18/51] py/compile: Fix potential Py-stack overflow in
 try-finally with return.

If a return is executed within the try block of a try-finally then the
return value is stored on the top of the Python stack during the execution
of the finally block.  In this case the Python stack is one larger than it
normally would be in the finally block.

Prior to this commit, the compiler was not taking this case into account
and could have a Python stack overflow if the Python stack used by the
finally block was more than that used elsewhere in the function.  In such
a scenario the last argument of the function would be clobbered by the
top-most temporary value used in the deepest Python expression/statement.

This commit fixes that case by making sure enough Python stack is allocated
to the function.

Fixes issue #13562.

Signed-off-by: Damien George <damien@micropython.org>
---
 py/compile.c                       | 11 +++++++++++
 tests/basics/try_finally_return.py | 10 ++++++++++
 2 files changed, 21 insertions(+)

diff --git a/py/compile.c b/py/compile.c
index 4f91ca49b903a..a9b34ce5d91bd 100644
--- a/py/compile.c
+++ b/py/compile.c
@@ -1650,9 +1650,11 @@ STATIC void compile_try_except(compiler_t *comp, mp_parse_node_t pn_body, int n_
         if (qstr_exception_local != 0) {
             EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
             EMIT_ARG(label_assign, l3);
+            EMIT_ARG(adjust_stack_size, 1); // stack adjust for possible return value
             EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
             compile_store_id(comp, qstr_exception_local);
             compile_delete_id(comp, qstr_exception_local);
+            EMIT_ARG(adjust_stack_size, -1);
             compile_decrease_except_level(comp);
         }
 
@@ -1682,9 +1684,18 @@ STATIC void compile_try_finally(compiler_t *comp, mp_parse_node_t pn_body, int n
     } else {
         compile_try_except(comp, pn_body, n_except, pn_except, pn_else);
     }
+
+    // If the code reaches this point then the try part of the try-finally exited normally.
+    // This is indicated to the runtime by None sitting on the stack.
     EMIT_ARG(load_const_tok, MP_TOKEN_KW_NONE);
+
+    // Compile the finally block.
+    // The stack needs to be adjusted by 1 to account for the possibility that the finally is
+    // being executed as part of a return, and the return value is on the top of the stack.
     EMIT_ARG(label_assign, l_finally_block);
+    EMIT_ARG(adjust_stack_size, 1);
     compile_node(comp, pn_finally);
+    EMIT_ARG(adjust_stack_size, -1);
 
     compile_decrease_except_level(comp);
 }
diff --git a/tests/basics/try_finally_return.py b/tests/basics/try_finally_return.py
index 31a507e8d0753..21e01ea21bf22 100644
--- a/tests/basics/try_finally_return.py
+++ b/tests/basics/try_finally_return.py
@@ -70,3 +70,13 @@ def f():
     finally:
         print('finally 1')
 print(f())
+
+# the finally block uses a lot of Python stack and then a local is accessed
+# (tests that the use of the stack doesn't clobber the local)
+def f(x):
+    try:
+        return x
+    finally:
+        print(2, 3, 4, 5, 6)
+        print(x)
+print(f(1))

From cc7cfc7e8d5508a3b3adf34f5c626643aae79e8d Mon Sep 17 00:00:00 2001
From: Takeo Takahashi <takeo.takahashi.xv@renesas.com>
Date: Mon, 29 Jan 2024 23:52:11 +0900
Subject: [PATCH 19/51] renesas-ra/ra/ra_i2c: Fix 1 byte and 2 bytes read
 issue.

Tested on Portenta C33 with AT24256B (addrsize=16) and SSD1306.

Fixes issue #13280.

Signed-off-by: Takeo Takahashi <takeo.takahashi.xv@renesas.com>
---
 ports/renesas-ra/ra/ra_i2c.c | 36 +++++++++++++++++++++++++++++++++++-
 ports/renesas-ra/ra/ra_i2c.h |  9 +++++----
 2 files changed, 40 insertions(+), 5 deletions(-)

diff --git a/ports/renesas-ra/ra/ra_i2c.c b/ports/renesas-ra/ra/ra_i2c.c
index 783c0c921543b..701f4d6aa8386 100644
--- a/ports/renesas-ra/ra/ra_i2c.c
+++ b/ports/renesas-ra/ra/ra_i2c.c
@@ -426,7 +426,7 @@ void ra_i2c_init(R_IIC0_Type *i2c_inst, uint32_t scl, uint32_t sda, uint32_t bau
     i2c_inst->ICCR1_b.ICE = 1;     // I2C enable
     ra_i2c_set_baudrate(i2c_inst, baudrate);
     i2c_inst->ICSER = 0x00;         // I2C reset bus status enable register
-    i2c_inst->ICMR3_b.ACKWP = 0x01; // I2C allow to write ACKBT (transfer acknowledge bit)
+    i2c_inst->ICMR3_b.ACKWP = 0x00; // I2C not allow to write ACKBT (transfer acknowledge bit)
     i2c_inst->ICIER = 0xFF;         // Enable all interrupts
     i2c_inst->ICCR1_b.IICRST = 0;   // I2C internal reset
     ra_i2c_irq_enable(i2c_inst);
@@ -480,6 +480,7 @@ void ra_i2c_xunit_read_byte(R_IIC0_Type *i2c_inst, xaction_unit_t *unit) {
 void ra_i2c_xunit_init(xaction_unit_t *unit, uint8_t *buf, uint32_t size, bool fread, void *next) {
     unit->m_bytes_transferred = 0;
     unit->m_bytes_transfer = size;
+    unit->m_bytes_total = size;
     unit->m_fread = fread;
     unit->buf = buf;
     unit->next = (void *)next;
@@ -531,6 +532,37 @@ static void ra_i2c_iceri_isr(R_IIC0_Type *i2c_inst) {
 static void ra_i2c_icrxi_isr(R_IIC0_Type *i2c_inst) {
     xaction_unit_t *unit = current_xaction_unit;
     xaction_t *action = current_xaction;
+    // 1 byte or 2 bytes
+    if (unit->m_bytes_total <= 2) {
+        if (action->m_status == RA_I2C_STATUS_AddrWriteCompleted) {
+            action->m_status = RA_I2C_STATUS_FirstReceiveCompleted;
+            i2c_inst->ICMR3_b.WAIT = 1;
+            // need dummy read processes for 1 byte and 2 bytes receive
+            if (unit->m_bytes_total == 2) {
+                (void)i2c_inst->ICDRR; // dummy read for 2 bytes receive
+            } else {  // m_bytes_total == 1
+                i2c_inst->ICMR3_b.ACKWP = 0x01; // enable write ACKBT (transfer acknowledge bit)
+                i2c_inst->ICMR3_b.ACKBT = 1;
+                i2c_inst->ICMR3_b.ACKWP = 0x00; // disable write ACKBT (transfer acknowledge bit)
+                (void)i2c_inst->ICDRR; // dummy read for 1 byte receive
+            }
+            return;
+        }
+        if (unit->m_bytes_transfer == 2) {      // last two data
+            i2c_inst->ICMR3_b.ACKWP = 0x01; // enable write ACKBT (transfer acknowledge bit)
+            i2c_inst->ICMR3_b.ACKBT = 1;
+            i2c_inst->ICMR3_b.ACKWP = 0x00; // disable write ACKBT (transfer acknowledge bit)
+            ra_i2c_xunit_read_byte(i2c_inst, unit);
+        } else { // last data
+            action->m_status = RA_I2C_STATUS_LastReceiveCompleted;
+            if (action->m_stop == true) {
+                i2c_inst->ICCR2_b.SP = 1; // request top condition
+            }
+            ra_i2c_xunit_read_byte(i2c_inst, unit);
+        }
+        return;
+    }
+    // 3 bytes or more
     if (action->m_status == RA_I2C_STATUS_AddrWriteCompleted) {
         (void)i2c_inst->ICDRR; // dummy read
         action->m_status = RA_I2C_STATUS_FirstReceiveCompleted;
@@ -542,7 +574,9 @@ static void ra_i2c_icrxi_isr(R_IIC0_Type *i2c_inst) {
         }
         ra_i2c_xunit_read_byte(i2c_inst, unit);
     } else if (unit->m_bytes_transfer == 2) {
+        i2c_inst->ICMR3_b.ACKWP = 0x01; // enable write ACKBT (transfer acknowledge bit)
         i2c_inst->ICMR3_b.ACKBT = 1;
+        i2c_inst->ICMR3_b.ACKWP = 0x00; // disable write ACKBT (transfer acknowledge bit)
         ra_i2c_xunit_read_byte(i2c_inst, unit);
     } else {
         // last data
diff --git a/ports/renesas-ra/ra/ra_i2c.h b/ports/renesas-ra/ra/ra_i2c.h
index e2432675a001e..fc172a3e956aa 100644
--- a/ports/renesas-ra/ra/ra_i2c.h
+++ b/ports/renesas-ra/ra/ra_i2c.h
@@ -47,9 +47,9 @@ typedef enum
     RA_I2C_STATUS_AddrWriteCompleted = 3,
     RA_I2C_STATUS_DataWriteCompleted = 4,
     RA_I2C_STATUS_DataSendCompleted = 5,
-    RA_I2C_STATUS_FirstReceiveCompleted = 5,
-    RA_I2C_STATUS_LastReceiveCompleted = 6,
-    RA_I2C_STATUS_Stopped = 7,
+    RA_I2C_STATUS_FirstReceiveCompleted = 6,
+    RA_I2C_STATUS_LastReceiveCompleted = 7,
+    RA_I2C_STATUS_Stopped = 8,
 } xaction_status_t;
 
 typedef enum
@@ -64,6 +64,7 @@ typedef enum
 typedef struct {
     volatile uint32_t m_bytes_transferred;
     volatile uint32_t m_bytes_transfer;
+    uint32_t m_bytes_total;
     bool m_fread;
     uint8_t *buf;
     void *next;
@@ -75,7 +76,7 @@ typedef struct {
     uint32_t m_current;
     uint32_t m_address;
     volatile xaction_status_t m_status;
-    xaction_error_t m_error;
+    volatile xaction_error_t m_error;
     bool m_stop;
 } xaction_t;
 

From e7ff724a87395637f8580b39ee640ffda05d576a Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Thu, 8 Feb 2024 16:52:01 +1100
Subject: [PATCH 20/51] extmod/btstack: Reset pending_value_handle before
 calling write-done cb.

The pending_value_handle needs to be freed and reset before calling
mp_bluetooth_gattc_on_read_write_status(), which will call the Python IRQ
handler, which may in turn call back into BTstack to perform an action like
a write.  In that case the pending_value_handle will need to be available
for the write/read/etc to proceed.

Fixes issue #13611.

Signed-off-by: Damien George <damien@micropython.org>
---
 extmod/btstack/modbluetooth_btstack.c      |   3 +-
 tests/multi_bluetooth/ble_irq_calls.py     | 200 +++++++++++++++++++++
 tests/multi_bluetooth/ble_irq_calls.py.exp |  31 ++++
 3 files changed, 233 insertions(+), 1 deletion(-)
 create mode 100644 tests/multi_bluetooth/ble_irq_calls.py
 create mode 100644 tests/multi_bluetooth/ble_irq_calls.py.exp

diff --git a/extmod/btstack/modbluetooth_btstack.c b/extmod/btstack/modbluetooth_btstack.c
index 211214768f7eb..08d64ab0123ce 100644
--- a/extmod/btstack/modbluetooth_btstack.c
+++ b/extmod/btstack/modbluetooth_btstack.c
@@ -490,11 +490,12 @@ STATIC void btstack_packet_handler_write_with_response(uint8_t packet_type, uint
         if (!conn) {
             return;
         }
-        mp_bluetooth_gattc_on_read_write_status(MP_BLUETOOTH_IRQ_GATTC_WRITE_DONE, conn_handle, conn->pending_value_handle, status);
+        uint16_t value_handle = conn->pending_value_handle;
         conn->pending_value_handle = 0xffff;
         m_del(uint8_t, conn->pending_write_value, conn->pending_write_value_len);
         conn->pending_write_value = NULL;
         conn->pending_write_value_len = 0;
+        mp_bluetooth_gattc_on_read_write_status(MP_BLUETOOTH_IRQ_GATTC_WRITE_DONE, conn_handle, value_handle, status);
     }
 }
 #endif // MICROPY_PY_BLUETOOTH_ENABLE_GATT_CLIENT
diff --git a/tests/multi_bluetooth/ble_irq_calls.py b/tests/multi_bluetooth/ble_irq_calls.py
new file mode 100644
index 0000000000000..131ea909295db
--- /dev/null
+++ b/tests/multi_bluetooth/ble_irq_calls.py
@@ -0,0 +1,200 @@
+# Test calling BLE methods from within the BLE.irq event handler.
+
+from micropython import const
+import struct
+import time
+import bluetooth
+
+_IRQ_CENTRAL_CONNECT = const(1)
+_IRQ_CENTRAL_DISCONNECT = const(2)
+_IRQ_PERIPHERAL_CONNECT = const(7)
+_IRQ_PERIPHERAL_DISCONNECT = const(8)
+_IRQ_GATTC_SERVICE_RESULT = const(9)
+_IRQ_GATTC_SERVICE_DONE = const(10)
+_IRQ_GATTC_CHARACTERISTIC_RESULT = const(11)
+_IRQ_GATTC_CHARACTERISTIC_DONE = const(12)
+_IRQ_GATTC_DESCRIPTOR_RESULT = const(13)
+_IRQ_GATTC_DESCRIPTOR_DONE = const(14)
+_IRQ_GATTC_READ_RESULT = const(15)
+_IRQ_GATTC_READ_DONE = const(16)
+_IRQ_GATTC_WRITE_DONE = const(17)
+_IRQ_MTU_EXCHANGED = const(21)
+_IRQ_GET_SECRET = const(29)
+_IRQ_SET_SECRET = const(30)
+
+EVENT_NAMES = {
+    1: "_IRQ_CENTRAL_CONNECT",
+    2: "_IRQ_CENTRAL_DISCONNECT",
+    3: "_IRQ_GATTS_WRITE",
+    4: "_IRQ_GATTS_READ_REQUEST",
+    7: "_IRQ_PERIPHERAL_CONNECT",
+    8: "_IRQ_PERIPHERAL_DISCONNECT",
+    9: "_IRQ_GATTC_SERVICE_RESULT",
+    10: "_IRQ_GATTC_SERVICE_DONE",
+    11: "_IRQ_GATTC_CHARACTERISTIC_RESULT",
+    12: "_IRQ_GATTC_CHARACTERISTIC_DONE",
+    13: "_IRQ_GATTC_DESCRIPTOR_RESULT",
+    14: "_IRQ_GATTC_DESCRIPTOR_DONE",
+    15: "_IRQ_GATTC_READ_RESULT",
+    16: "_IRQ_GATTC_READ_DONE",
+    17: "_IRQ_GATTC_WRITE_DONE",
+    18: "_IRQ_GATTC_NOTIFY",
+    21: "_IRQ_MTU_EXCHANGED",
+}
+
+_ADV_TYPE_FLAGS = const(0x01)
+_ADV_TYPE_NAME = const(0x09)
+_ADV_TYPE_UUID128_COMPLETE = const(0x7)
+
+_NOTIFY_ENABLE = const(1)
+
+ACCESSORY_UUID = bluetooth.UUID("a5a5a5a5-ffff-9999-1111-5a5a5a5a5a5a")
+STATE_UUID = bluetooth.UUID("a5a5a5a5-eeee-9999-1111-5a5a5a5a5a5a")
+CCC_UUID = bluetooth.UUID(0x2902)
+
+STATE_CHARACTERISTIC = (
+    STATE_UUID,
+    bluetooth.FLAG_READ | bluetooth.FLAG_NOTIFY,
+)
+
+ACCESSORY_SERVICE = (ACCESSORY_UUID, (STATE_CHARACTERISTIC,))
+
+
+class Central:
+    def __init__(self):
+        self.done = False
+        self._conn_handle = None
+        self._service = None
+        self._characteristic = None
+        self._cccd_handle = None
+        ble.active(1)
+        ble.irq(self._ble_event_handler)
+        ble.gap_connect(*BDADDR)
+
+    def _ble_event_handler(self, event, data):
+        print(EVENT_NAMES[event])
+
+        if event == _IRQ_PERIPHERAL_CONNECT:
+            conn_handle, _, _ = data
+            self._conn_handle = conn_handle
+            ble.gattc_discover_services(self._conn_handle, ACCESSORY_UUID)
+
+        elif event == _IRQ_PERIPHERAL_DISCONNECT:
+            conn_handle, _, addr = data
+            assert self._conn_handle == conn_handle
+            self._conn_handle = None
+            print("connection closed")
+
+        elif event == _IRQ_GATTC_SERVICE_RESULT:
+            _, first_handle, last_handle, uuid = data
+            print("service found:", last_handle - first_handle, uuid)
+            if uuid == ACCESSORY_UUID:
+                assert self._service is None
+                self._service = (first_handle, last_handle)
+
+        elif event == _IRQ_GATTC_SERVICE_DONE:
+            print("service handle range:", self._service[1] - self._service[0])
+            start_handle, end_handle = self._service
+            ble.gattc_discover_characteristics(self._conn_handle, start_handle, end_handle)
+
+        elif event == _IRQ_GATTC_CHARACTERISTIC_RESULT:
+            _, end_handle, value_handle, properties, uuid = data
+            assert uuid == STATE_UUID
+            print("characteristic found:", uuid)
+            self._characteristic = (end_handle, value_handle, properties)
+
+        elif event == _IRQ_GATTC_CHARACTERISTIC_DONE:
+            start_handle, end_handle = self._service
+            ble.gattc_discover_descriptors(self._conn_handle, start_handle, end_handle)
+
+        elif event == _IRQ_GATTC_DESCRIPTOR_RESULT:
+            _, dsc_handle, uuid = data
+            if uuid == CCC_UUID:
+                print("CCCD found:", uuid)
+                assert self._cccd_handle is None
+                self._cccd_handle = dsc_handle
+
+        elif event == _IRQ_GATTC_DESCRIPTOR_DONE:
+            # Discovery complete, proceed to MTU exchange.
+            ble.gattc_exchange_mtu(self._conn_handle)
+
+        elif event == _IRQ_MTU_EXCHANGED:
+            # MTU exchanged, proceed to enable CCCD.
+            print("CCCD write")
+            ble.gattc_write(
+                self._conn_handle, self._cccd_handle, struct.pack("<h", _NOTIFY_ENABLE), 1
+            )
+
+        elif event == _IRQ_GATTC_WRITE_DONE:
+            conn_handle, _, result = data
+            print("CCCD write result:", result)
+            _, state_handle, _ = self._characteristic
+            print("issue gattc_read")
+            ble.gattc_read(self._conn_handle, state_handle)
+
+        elif event == _IRQ_GATTC_READ_RESULT:
+            _, _, char_data = data
+            print("gattc_read result:", bytes(char_data))
+
+        elif event == _IRQ_GATTC_READ_DONE:
+            self.done = True
+            ble.gap_disconnect(self._conn_handle)
+
+
+class Peripheral:
+    def __init__(self):
+        self.done = False
+        ble.active(1)
+        ble.irq(self._ble_event_handler)
+        ble.gatts_register_services((ACCESSORY_SERVICE,))
+        add_payload = self.advertising_payload("acc", (ACCESSORY_UUID,))
+        ble.gap_advertise(500000, add_payload)
+
+    def advertising_payload(self, name, services):
+        payload = bytearray()
+
+        def _append(adv_type, value):
+            nonlocal payload
+            payload.extend(struct.pack("BB", len(value) + 1, adv_type) + value)
+
+        _append(_ADV_TYPE_FLAGS, struct.pack("B", 0x02 + 0x04))
+        _append(_ADV_TYPE_NAME, name)
+
+        for uuid in services:
+            b = bytes(uuid)
+            assert len(b) == 16
+            _append(_ADV_TYPE_UUID128_COMPLETE, b)
+
+        return payload
+
+    def _ble_event_handler(self, event, data):
+        if event not in (_IRQ_GET_SECRET, _IRQ_SET_SECRET):
+            print(EVENT_NAMES[event])
+        if event == _IRQ_CENTRAL_DISCONNECT:
+            self.done = True
+
+
+# Acting in peripheral role.
+def instance0():
+    print("peripheral start")
+    peripheral = Peripheral()
+    multitest.globals(BDADDR=ble.config("mac"))
+    multitest.next()
+    while not peripheral.done:
+        time.sleep_ms(100)
+    multitest.broadcast("finished")
+    ble.active(0)
+
+
+# Acting in central role.
+def instance1():
+    print("central start")
+    multitest.next()
+    central = Central()
+    while not central.done:
+        time.sleep_ms(100)
+    multitest.wait("finished")
+    ble.active(0)
+
+
+ble = bluetooth.BLE()
diff --git a/tests/multi_bluetooth/ble_irq_calls.py.exp b/tests/multi_bluetooth/ble_irq_calls.py.exp
new file mode 100644
index 0000000000000..85d2f585adbb4
--- /dev/null
+++ b/tests/multi_bluetooth/ble_irq_calls.py.exp
@@ -0,0 +1,31 @@
+--- instance0 ---
+peripheral start
+_IRQ_CENTRAL_CONNECT
+_IRQ_MTU_EXCHANGED
+_IRQ_GATTS_READ_REQUEST
+_IRQ_CENTRAL_DISCONNECT
+--- instance1 ---
+central start
+_IRQ_PERIPHERAL_CONNECT
+_IRQ_GATTC_SERVICE_RESULT
+service found: 3 UUID('a5a5a5a5-ffff-9999-1111-5a5a5a5a5a5a')
+_IRQ_GATTC_SERVICE_DONE
+service handle range: 3
+_IRQ_GATTC_CHARACTERISTIC_RESULT
+characteristic found: UUID('a5a5a5a5-eeee-9999-1111-5a5a5a5a5a5a')
+_IRQ_GATTC_CHARACTERISTIC_DONE
+_IRQ_GATTC_DESCRIPTOR_RESULT
+_IRQ_GATTC_DESCRIPTOR_RESULT
+_IRQ_GATTC_DESCRIPTOR_RESULT
+CCCD found: UUID(0x2902)
+_IRQ_GATTC_DESCRIPTOR_DONE
+_IRQ_MTU_EXCHANGED
+CCCD write
+_IRQ_GATTC_WRITE_DONE
+CCCD write result: 0
+issue gattc_read
+_IRQ_GATTC_READ_RESULT
+gattc_read result: b''
+_IRQ_GATTC_READ_DONE
+_IRQ_PERIPHERAL_DISCONNECT
+connection closed

From 02df2b09d4c2793ca97ad48a46640eea7945b9a1 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Sun, 11 Feb 2024 15:08:08 +1100
Subject: [PATCH 21/51] extmod/btstack: Reset pending_value_handle before
 calling read-done cb.

Similar to the previous commit but for MP_BLUETOOTH_IRQ_GATTC_READ_DONE:
the pending_value_handle needs to be reset before calling
mp_bluetooth_gattc_on_read_write_status(), which will call the Python IRQ
handler, which may in turn call back into BTstack to perform an action like
a write.  In that case the pending_value_handle will need to be available
for the write/read/etc to proceed.

Fixes issue #13634.

Signed-off-by: Damien George <damien@micropython.org>
---
 extmod/btstack/modbluetooth_btstack.c      |  3 ++-
 tests/multi_bluetooth/ble_irq_calls.py     | 18 ++++++++++++------
 tests/multi_bluetooth/ble_irq_calls.py.exp |  4 ++++
 3 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/extmod/btstack/modbluetooth_btstack.c b/extmod/btstack/modbluetooth_btstack.c
index 08d64ab0123ce..b3d349c2dc947 100644
--- a/extmod/btstack/modbluetooth_btstack.c
+++ b/extmod/btstack/modbluetooth_btstack.c
@@ -462,8 +462,9 @@ STATIC void btstack_packet_handler_read(uint8_t packet_type, uint16_t channel, u
         if (!conn) {
             return;
         }
-        mp_bluetooth_gattc_on_read_write_status(MP_BLUETOOTH_IRQ_GATTC_READ_DONE, conn_handle, conn->pending_value_handle, status);
+        uint16_t value_handle = conn->pending_value_handle;
         conn->pending_value_handle = 0xffff;
+        mp_bluetooth_gattc_on_read_write_status(MP_BLUETOOTH_IRQ_GATTC_READ_DONE, conn_handle, value_handle, status);
     } else if (event_type == GATT_EVENT_CHARACTERISTIC_VALUE_QUERY_RESULT) {
         DEBUG_printf("  --> gatt characteristic value query result\n");
         uint16_t conn_handle = gatt_event_characteristic_value_query_result_get_handle(packet);
diff --git a/tests/multi_bluetooth/ble_irq_calls.py b/tests/multi_bluetooth/ble_irq_calls.py
index 131ea909295db..c8c673daab31d 100644
--- a/tests/multi_bluetooth/ble_irq_calls.py
+++ b/tests/multi_bluetooth/ble_irq_calls.py
@@ -65,8 +65,9 @@ def __init__(self):
         self.done = False
         self._conn_handle = None
         self._service = None
-        self._characteristic = None
+        self._characteristic_handle = None
         self._cccd_handle = None
+        self._reads_remaining = None
         ble.active(1)
         ble.irq(self._ble_event_handler)
         ble.gap_connect(*BDADDR)
@@ -101,7 +102,8 @@ def _ble_event_handler(self, event, data):
             _, end_handle, value_handle, properties, uuid = data
             assert uuid == STATE_UUID
             print("characteristic found:", uuid)
-            self._characteristic = (end_handle, value_handle, properties)
+            assert self._characteristic_handle is None
+            self._characteristic_handle = value_handle
 
         elif event == _IRQ_GATTC_CHARACTERISTIC_DONE:
             start_handle, end_handle = self._service
@@ -128,17 +130,21 @@ def _ble_event_handler(self, event, data):
         elif event == _IRQ_GATTC_WRITE_DONE:
             conn_handle, _, result = data
             print("CCCD write result:", result)
-            _, state_handle, _ = self._characteristic
             print("issue gattc_read")
-            ble.gattc_read(self._conn_handle, state_handle)
+            self._reads_remaining = 2
+            ble.gattc_read(self._conn_handle, self._characteristic_handle)
 
         elif event == _IRQ_GATTC_READ_RESULT:
             _, _, char_data = data
             print("gattc_read result:", bytes(char_data))
 
         elif event == _IRQ_GATTC_READ_DONE:
-            self.done = True
-            ble.gap_disconnect(self._conn_handle)
+            self._reads_remaining -= 1
+            if self._reads_remaining > 0:
+                ble.gattc_read(self._conn_handle, self._characteristic_handle)
+            else:
+                self.done = True
+                ble.gap_disconnect(self._conn_handle)
 
 
 class Peripheral:
diff --git a/tests/multi_bluetooth/ble_irq_calls.py.exp b/tests/multi_bluetooth/ble_irq_calls.py.exp
index 85d2f585adbb4..d655c507d34f1 100644
--- a/tests/multi_bluetooth/ble_irq_calls.py.exp
+++ b/tests/multi_bluetooth/ble_irq_calls.py.exp
@@ -3,6 +3,7 @@ peripheral start
 _IRQ_CENTRAL_CONNECT
 _IRQ_MTU_EXCHANGED
 _IRQ_GATTS_READ_REQUEST
+_IRQ_GATTS_READ_REQUEST
 _IRQ_CENTRAL_DISCONNECT
 --- instance1 ---
 central start
@@ -27,5 +28,8 @@ issue gattc_read
 _IRQ_GATTC_READ_RESULT
 gattc_read result: b''
 _IRQ_GATTC_READ_DONE
+_IRQ_GATTC_READ_RESULT
+gattc_read result: b''
+_IRQ_GATTC_READ_DONE
 _IRQ_PERIPHERAL_DISCONNECT
 connection closed

From e72d03855efe4917c555a083c0fdd63819ca890f Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Wed, 14 Feb 2024 12:39:27 +1100
Subject: [PATCH 22/51] esp32/mpnimbleport: Release the GIL while doing NimBLE
 port deinit.

In case callbacks must run (eg a disconnect event happens during the
deinit) and the GIL must be obtained to run the callback.

Fixes part of issue #12349.

Signed-off-by: Damien George <damien@micropython.org>
---
 ports/esp32/mpnimbleport.c | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/ports/esp32/mpnimbleport.c b/ports/esp32/mpnimbleport.c
index 8235275be6fd6..5b57edf3c1c19 100644
--- a/ports/esp32/mpnimbleport.c
+++ b/ports/esp32/mpnimbleport.c
@@ -63,6 +63,11 @@ void mp_bluetooth_nimble_port_start(void) {
 void mp_bluetooth_nimble_port_shutdown(void) {
     DEBUG_printf("mp_bluetooth_nimble_port_shutdown\n");
 
+    #if MICROPY_PY_BLUETOOTH_USE_SYNC_EVENTS_WITH_INTERLOCK
+    // Release the GIL so any callbacks can run during the shutdown calls below.
+    MP_THREAD_GIL_EXIT();
+    #endif
+
     // Despite the name, these is an ESP32-specific (no other NimBLE ports have these functions).
     // Calls ble_hs_stop() and waits for stack shutdown.
     nimble_port_stop();
@@ -70,6 +75,10 @@ void mp_bluetooth_nimble_port_shutdown(void) {
     // Shuts down the event queue.
     nimble_port_deinit();
 
+    #if MICROPY_PY_BLUETOOTH_USE_SYNC_EVENTS_WITH_INTERLOCK
+    MP_THREAD_GIL_ENTER();
+    #endif
+
     // Mark stack as shutdown.
     mp_bluetooth_nimble_ble_state = MP_BLUETOOTH_NIMBLE_BLE_STATE_OFF;
 }

From ee3c9ccb541732ae57de490dd914225ddce8f8a2 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Thu, 15 Feb 2024 23:03:29 +1100
Subject: [PATCH 23/51] esp32: Increase NimBLE task stack size and overflow
 detection headroom.

The Python BLE IRQ handler will most likely run on the NimBLE task, so its
C stack must be large enough to accommodate reasonably complicated Python
code (eg a few call depths).  So increase this stack size.

Also increase the headroom from 1024 to 2048 bytes.  This is needed because
(1) the esp32 architecture uses a fair amount of stack in general; and (2)
by the time execution gets to setting the Python stack top via
`mp_stack_set_top()` in this interlock code, about 600 bytes of stack are
already used, which reduces the amount available for Python.

Fixes issue #12349.

Signed-off-by: Damien George <damien@micropython.org>
---
 extmod/modbluetooth.c            | 2 +-
 ports/esp32/boards/sdkconfig.ble | 4 ++++
 ports/esp32/mpconfigport.h       | 2 +-
 3 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/extmod/modbluetooth.c b/extmod/modbluetooth.c
index cef5151cc9ddc..32a15bf511acb 100644
--- a/extmod/modbluetooth.c
+++ b/extmod/modbluetooth.c
@@ -1274,7 +1274,7 @@ STATIC mp_obj_t invoke_irq_handler(uint16_t event,
     if (ts_orig == NULL) {
         mp_thread_set_state(&ts);
         mp_stack_set_top(&ts + 1); // need to include ts in root-pointer scan
-        mp_stack_set_limit(MICROPY_PY_BLUETOOTH_SYNC_EVENT_STACK_SIZE - 1024);
+        mp_stack_set_limit(MICROPY_PY_BLUETOOTH_SYNC_EVENT_STACK_SIZE);
         ts.gc_lock_depth = 0;
         ts.nlr_jump_callback_top = NULL;
         ts.mp_pending_exception = MP_OBJ_NULL;
diff --git a/ports/esp32/boards/sdkconfig.ble b/ports/esp32/boards/sdkconfig.ble
index 7fa08fe286d7f..af2d4b133ec7b 100644
--- a/ports/esp32/boards/sdkconfig.ble
+++ b/ports/esp32/boards/sdkconfig.ble
@@ -14,3 +14,7 @@ CONFIG_BT_NIMBLE_MAX_CONNECTIONS=4
 CONFIG_BT_NIMBLE_PINNED_TO_CORE_0=n
 CONFIG_BT_NIMBLE_PINNED_TO_CORE_1=y
 CONFIG_BT_NIMBLE_PINNED_TO_CORE=1
+
+# Increase NimBLE task stack size from the default, because Python code
+# (BLE IRQ handlers) will most likely run on this task.
+CONFIG_BT_NIMBLE_TASK_STACK_SIZE=6144
diff --git a/ports/esp32/mpconfigport.h b/ports/esp32/mpconfigport.h
index 5dc4a9c758790..acf065384b7da 100644
--- a/ports/esp32/mpconfigport.h
+++ b/ports/esp32/mpconfigport.h
@@ -95,7 +95,7 @@
 #define MICROPY_PY_BLUETOOTH                (1)
 #define MICROPY_PY_BLUETOOTH_USE_SYNC_EVENTS (1)
 #define MICROPY_PY_BLUETOOTH_USE_SYNC_EVENTS_WITH_INTERLOCK (1)
-#define MICROPY_PY_BLUETOOTH_SYNC_EVENT_STACK_SIZE (CONFIG_BT_NIMBLE_TASK_STACK_SIZE)
+#define MICROPY_PY_BLUETOOTH_SYNC_EVENT_STACK_SIZE (CONFIG_BT_NIMBLE_TASK_STACK_SIZE - 2048)
 #define MICROPY_PY_BLUETOOTH_ENABLE_CENTRAL_MODE (1)
 #define MICROPY_PY_BLUETOOTH_ENABLE_PAIRING_BONDING (1)
 #define MICROPY_BLUETOOTH_NIMBLE            (1)

From 8cd15829e293f01dae91b6a2d4a995bfaeca887b Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Tue, 20 Feb 2024 22:59:55 +1100
Subject: [PATCH 24/51] all: Bump version to 1.22.2.

Signed-off-by: Damien George <damien@micropython.org>
---
 py/mpconfig.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py/mpconfig.h b/py/mpconfig.h
index e0d1ad44eb132..627388c670b2b 100644
--- a/py/mpconfig.h
+++ b/py/mpconfig.h
@@ -31,7 +31,7 @@
 // are unavailable.
 #define MICROPY_VERSION_MAJOR 1
 #define MICROPY_VERSION_MINOR 22
-#define MICROPY_VERSION_MICRO 1
+#define MICROPY_VERSION_MICRO 2
 #define MICROPY_VERSION_PRERELEASE 0
 
 // Combined version as a 32-bit number for convenience to allow version

From 141a55d39382c413477c3820527af7b0fcddefe3 Mon Sep 17 00:00:00 2001
From: Wang Xuancong <xuancong84@gmail.com>
Date: Thu, 4 Jul 2024 01:10:16 +0800
Subject: [PATCH 25/51] esp8266 and esp32 build working after merge

---
 lib/cyw43-driver       |   2 +-
 lib/libmetal           |   2 +-
 lib/micropython-lib    |   2 +-
 lib/open-amp           |   2 +-
 ports/esp32/build.sh   |  16 ++
 ports/esp8266/build.sh |   7 +-
 ports/esp8266/modesp.c | 373 +----------------------------------------
 7 files changed, 27 insertions(+), 377 deletions(-)
 create mode 100755 ports/esp32/build.sh

diff --git a/lib/cyw43-driver b/lib/cyw43-driver
index 9f6405f0b3260..2ab0db6e1fe92 160000
--- a/lib/cyw43-driver
+++ b/lib/cyw43-driver
@@ -1 +1 @@
-Subproject commit 9f6405f0b3260968306d782e1c5ac275a46dc65d
+Subproject commit 2ab0db6e1fe9265fa9802a95f7f4d60b7f0d655a
diff --git a/lib/libmetal b/lib/libmetal
index 0cb7d293a7f25..3aee6be866b19 160000
--- a/lib/libmetal
+++ b/lib/libmetal
@@ -1 +1 @@
-Subproject commit 0cb7d293a7f25394a06847a28d0f0ace9862936e
+Subproject commit 3aee6be866b190d2e2b4997fedbd976a0c37c0c6
diff --git a/lib/micropython-lib b/lib/micropython-lib
index 50ed36fbeb919..ddb1a279578bf 160000
--- a/lib/micropython-lib
+++ b/lib/micropython-lib
@@ -1 +1 @@
-Subproject commit 50ed36fbeb919753bcc26ce13a8cffd7691d06ef
+Subproject commit ddb1a279578bfff8c1b18aff3baa668620684f64
diff --git a/lib/open-amp b/lib/open-amp
index 1904dee18da85..856680eb99cee 160000
--- a/lib/open-amp
+++ b/lib/open-amp
@@ -1 +1 @@
-Subproject commit 1904dee18da85400e72b8f55c5c99e872a486573
+Subproject commit 856680eb99cee67dfff3d2e9c6d4ede3b7549895
diff --git a/ports/esp32/build.sh b/ports/esp32/build.sh
new file mode 100755
index 0000000000000..352d43bd7c7a1
--- /dev/null
+++ b/ports/esp32/build.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+cd `dirname $(readlink -f "$0")`
+
+export PATH=~/.espressif/python_env/idf5.0_py3.11_env/bin:$PATH
+
+cd ~/projects/esp-idf
+source export.sh
+
+cd -
+
+if [ ! "$1" ]; then
+	rm -rf build-ESP32_GENERIC_C3
+fi
+
+make BOARD=ESP32_GENERIC_C3 -j4
diff --git a/ports/esp8266/build.sh b/ports/esp8266/build.sh
index 5b23b31363fdf..b86754924a31a 100755
--- a/ports/esp8266/build.sh
+++ b/ports/esp8266/build.sh
@@ -1,5 +1,10 @@
 #!/bin/bash
 
-make clean
+export PATH=~/.espressif/python_env/idf5.0_py3.11_env/bin:$PATH
+
+if [ ! "$1" ]; then
+	make clean
+fi
+
 make -j BOARD=ESP8266_GENERIC
 
diff --git a/ports/esp8266/modesp.c b/ports/esp8266/modesp.c
index 812ba5d091d40..392dc4bcfb834 100644
--- a/ports/esp8266/modesp.c
+++ b/ports/esp8266/modesp.c
@@ -555,378 +555,7 @@ mp_import_stat_t mp_find_dynamic_frozen_(const char *str, int *frozen_type, void
         mp_raw_code_load_mem(&ptr[strlen(str) + 9], *(uint32_t *)&ptr[4], &cm);
         mp_frozen_module_t *fc = malloc(sizeof(mp_frozen_module_t));
         *(mp_module_constants_t *)&fc->constants = cm.context->constants;
-        fc->rc = cm.rc;
-        *data = fc;
-    }
-    return MP_IMPORT_STAT_FILE;
-}
-
-static mp_obj_t esp_ls_frozen() {
-    mp_obj_t frozen_list = mp_obj_new_list(0, NULL);
-    scan_dynamic_frozen(frozen_list, NULL);
-    return frozen_list;
-}
-static MP_DEFINE_CONST_FUN_OBJ_0(esp_ls_frozen_obj, esp_ls_frozen);
-
-bool has_enough_free_sect(uint8_t *ptr, int n_needed) {
-    int x = 0;
-    for (; ptr < FLASH_END && x <= n_needed && (*ptr == 0 || *ptr == 0xff); x++) {
-        ptr += FLASH_SEC_SIZE;
-    }
-    return x >= n_needed;
-}
-mp_obj_t flash_mpy_to_rom(const char *filename, const char *modname, uint8_t *ptr, uint32_t filesize, int tot_secs) {
-    for(int x=0, sn=(int)(ptr-FLASH_START)/FLASH_SEC_SIZE; x<tot_secs; x++, sn++){
-        erase_sector(sn);
-    }
-    mp_obj_t res = mp_const_true;
-    byte buf[256] = {tot_secs, tot_secs, strlen(modname), 0};
-    mp_reader_t reader;
-    mp_reader_new_file(&reader, qstr_from_str(filename));
-    *(uint32_t *)&buf[4] = filesize;
-    strcpy(&buf[8], modname);
-    mp_uint_t ch = 0;
-    int off = strlen(modname) + 9;
-    while (ch != MP_READER_EOF) {
-        while (off < 256 && (ch = reader.readbyte(reader.data)) != MP_READER_EOF) {
-            buf[off] = ch;
-            off++;
-        }
-        while (off & 0x3) {
-            buf[off++] = 0xff;  // reached EOF, fill with 0xff until a 4-byte boundary
-        }
-        if (spi_flash_write(ptr - FLASH_START, &buf[0], off) != SPI_FLASH_RESULT_OK) {
-            res = mp_const_false;
-            break;
-        }
-        ptr += off;
-        off = 0;
-    }
-    reader.close(reader.data);
-    mp_find_dynamic_frozen = res?mp_find_dynamic_frozen_:NULL;
-    return res;
-}
-bool delete_mpy_from_rom(byte *ptr) {
-    uint32_t new_dword = (*(uint32_t *)ptr) & 0xffffff00;  // set 1st byte to 0
-    for (int x = ptr[1]; x > 0 && ptr < FLASH_END; x--, ptr += FLASH_SEC_SIZE) { // free every sector occupied by the module
-        if (spi_flash_write(ptr - FLASH_START, (uint32_t *)&new_dword, 4) != SPI_FLASH_RESULT_OK) { // NOR flash can write 0-bit without erasing
-            return mp_const_false;
-        }
-    }
-    return mp_const_true;
-}
-bool compare_flash_to_file(const char *filename, byte *ptr) {
-    bool is_diff = false;
-    mp_reader_t reader;
-    mp_reader_new_file(&reader, qstr_from_str(filename));
-    byte ch;
-    while ((ch = reader.readbyte(reader.data)) != MP_READER_EOF) {
-        if (*ptr != ch) {
-            is_diff = true;
-            break;
-        }
-    }
-    reader.close(reader.data);
-    return is_diff;
-}
-static mp_obj_t esp_add_frozen(size_t n_args, const mp_obj_t *args) {
-    uint8_t *ptr;
-    const char *filename = mp_obj_str_get_str(args[0]);
-    char *modname = n_args > 1?mp_obj_str_get_str(args[1]):filename;
-
-    // get .mpy filesize
-    int mpy_size = 0;
-    mp_reader_t reader;
-    mp_reader_new_file(&reader, qstr_from_str(filename));
-    while (reader.readbyte(reader.data) != MP_READER_EOF) {
-        mpy_size++;
-    }
-    reader.close(reader.data);
-
-    // compute spaces needed
-    int tot_size = mpy_size + strlen(modname) + 9;
-    int tot_secs = (tot_size + FLASH_SEC_SIZE - 1) / FLASH_SEC_SIZE;
-
-    // find existing mpy
-    ptr = scan_dynamic_frozen(NULL, modname);
-    if (ptr < FLASH_END && *ptr != 0xff && ptr[0] == ptr[1] && !strcmp(modname, ptr + 8)) {  // found module with the same name
-        // if same module name and content, return true
-        if (*(uint32_t *)&ptr[4] == mpy_size && !compare_flash_to_file(filename, ptr + strlen(modname) + 9)) {
-            return mp_const_true;
-        }
-        // otherwise, delete the existing module
-        if (!delete_mpy_from_rom(ptr)) {
-            return mp_const_false;
-        }
-    }
-
-    ptr = FLASH_START + dynamic_frozen_start;
-    while (ptr < FLASH_END) {
-        switch (*ptr) {
-            case 0x0:
-                if (!has_enough_free_sect(ptr, tot_secs)) {
-                    break;
-                }
-                return flash_mpy_to_rom(filename, modname, ptr, mpy_size, tot_secs);
-            case 0xff:
-                if (!has_enough_free_sect(ptr, tot_secs)) {
-                    return mp_const_false;
-                }
-                return flash_mpy_to_rom(filename, modname, ptr, mpy_size, tot_secs);
-            default:
-                if (ptr[1] != ptr[0]) {
-                    return mp_const_false;
-                }
-                ptr += FLASH_SEC_SIZE * (*ptr);
-                continue;
-        }
-        ptr += FLASH_SEC_SIZE;
-    }
-    return mp_const_false;
-}
-static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_add_frozen_obj, 1, 2, esp_add_frozen);
-
-static mp_obj_t esp_del_frozen(mp_obj_t module_name) {
-    const char *_module_name = mp_obj_str_get_str(module_name);
-    uint8_t *ptr = scan_dynamic_frozen(NULL, _module_name);
-    if (ptr >= FLASH_END || strcmp(ptr + 8, _module_name)) { // not found
-        return mp_const_false;
-    }
-    if (!delete_mpy_from_rom(ptr)) {
-        return mp_const_false;
-    }
-    scan_dynamic_frozen(NULL, NULL);
-    return mp_const_true;
-}
-static MP_DEFINE_CONST_FUN_OBJ_1(esp_del_frozen_obj, esp_del_frozen);
-
-static mp_obj_t esp_reset_frozen() {
-    for (int p = dynamic_frozen_start / FLASH_SEC_SIZE, P = (FLASH_END - FLASH_START) / FLASH_SEC_SIZE; p < P; p++) {
-        erase_sector(p);
-    }
-    mp_find_dynamic_frozen = NULL;
-    return mp_const_true;
-}
-static MP_DEFINE_CONST_FUN_OBJ_0(esp_reset_frozen_obj, esp_reset_frozen);
-
-#endif  // MICROPY_DFM
-
-static void showMemory(char *ptr, int size) {
-    for (int x = 0; x < size;) {
-        printf("%02x ", ptr[x++]);
-        if (x % 32 == 0) {
-            printf("\r\n");
-        } else if (x % 16 == 0) {
-            printf("  ");
-        } else if (x % 8 == 0) {
-            printf(" ");
-        }
-    }
-    printf("\r\n");
-}
-static mp_obj_t esp_showMemory(mp_obj_t _start, mp_obj_t _size) {
-    showMemory((char *)mp_obj_get_int(_start), mp_obj_get_int(_size));
-    return mp_const_none;
-}
-static MP_DEFINE_CONST_FUN_OBJ_2(esp_showMemory_obj, esp_showMemory);
-
-#ifdef MICROPY_DFU
-int dfu_nblks = -1;
-uint32_t dfu_fwsize = 0;
-uint16_t *dfu_blks = NULL;
-uint16_t *dfu_offs = NULL;
-
-/* Firmware update codes must be put into IRAM, or will crash while flashing halfway! */
-void MP_FASTCODE(erase_sector)(int sector) {
-    char *ptr = FLASH_START + sector * FLASH_SEC_SIZE;
-    for (char *PTR = ptr + FLASH_SEC_SIZE; ptr < PTR; ptr++) {
-        if (*ptr != 0xff) {
-            SPIEraseSector(sector);
-            break;
-        }
-    }
-}
-void MP_FASTCODE(DFU)(char *dfu_buf, int n_fwblks, int n_erase) {
-    for (int x = 0; x < n_fwblks; x++) {
-        erase_sector(x);
-        // uart_tx_one_char(0, 'E');
-    }
-
-    int cur_write_pos = 0;
-    int cur_write_sz;
-    int remaining_sz = dfu_fwsize;
-
-    for (int x = 0; x < dfu_nblks && remaining_sz > 0; x++) {
-        cur_write_sz = FLASH_SEC_SIZE - dfu_offs[x];
-        if (remaining_sz < cur_write_sz) {
-            cur_write_sz = remaining_sz;
-        }
-
-        Cache_Read_Disable_2();
-        SPIRead(1048576 + FLASH_SEC_SIZE * dfu_blks[x] + dfu_offs[x], (uint32_t *)dfu_buf, cur_write_sz);
-        Cache_Read_Enable_2();
-        // uart_tx_one_char(0, 'R');
-        if (x == 0) {
-            dfu_buf[3] = 64;
-        }
-        SPIWrite(cur_write_pos, (uint32_t *)dfu_buf, cur_write_sz);
-        // uart_tx_one_char(0, 'W');
-
-        cur_write_pos += cur_write_sz;
-        remaining_sz -= cur_write_sz;
-        wdt_feed();
-    }
-
-    for (int x = n_fwblks; x < n_erase; x++) {
-        erase_sector(x);
-        // uart_tx_one_char(0, 'E');
-    }
-
-    asm ("memw");
-    asm ("isync");
-    // rom_phy_reset_req();
-    system_restart_core();
-    // return cur_write_pos;
-}
-static mp_obj_t esp_DFU(mp_obj_t erase_all) {
-    extern char flashchip;
-    SpiFlashChip *flash = (SpiFlashChip *)(&flashchip + 4);
-    char *buf = malloc(FLASH_SEC_SIZE);
-    if (buf == NULL) {
-        mp_raise_OSError(MP_ENOMEM);
-        return mp_const_none;
-    }
-
-    ets_wdt_disable();
-    disable_irq();
-    DFU(buf, dfu_fwsize / FLASH_SEC_SIZE + (dfu_fwsize % FLASH_SEC_SIZE?1:0), mp_obj_is_true(erase_all)?(flash->chip_size / FLASH_SEC_SIZE):0);
-
-    // It will NEVER reach here even if flash failed
-    // enable_irq(state);
-    // ets_wdt_enable();
-
-    return mp_const_none;
-}
-static MP_DEFINE_CONST_FUN_OBJ_1(esp_DFU_obj, esp_DFU);
-
-static mp_obj_t esp_set_dfu(mp_obj_t nblks, mp_obj_t fsize) {
-    dfu_nblks = mp_obj_get_int(nblks);
-    dfu_fwsize = mp_obj_get_int(fsize);
-    if (dfu_nblks > 0 && dfu_blks == NULL && dfu_offs == NULL) {
-        size_t res = 0;
-        mp_obj_t ret = mp_obj_new_bytes(FLASH_START, dfu_nblks * sizeof(uint16_t) * 2);
-        dfu_blks = mp_obj_str_get_data(ret, &res);
-        dfu_offs = &dfu_blks[dfu_nblks];
-        return ret; // must return an object to keep the buffer, or will be GC collected
-    }
-    return (dfu_blks != NULL && dfu_offs != NULL)?mp_const_true:mp_const_false;
-}
-static MP_DEFINE_CONST_FUN_OBJ_2(esp_set_dfu_obj, esp_set_dfu);
-
-static mp_obj_t esp_get_blks(mp_obj_t return_details) {
-    if (!mp_obj_is_true(return_details)) {
-        return mp_obj_new_int(dfu_nblks);
-    }
-    if (dfu_nblks <= 0) {
-        return mp_const_none;
-    }
-    mp_obj_t *secs = m_new(mp_obj_t, dfu_nblks);
-    mp_obj_t *offs = m_new(mp_obj_t, dfu_nblks);
-    for (int x = 0; x < dfu_nblks; x++) {
-        secs[x] = mp_obj_new_int(dfu_blks[x]);
-        offs[x] = mp_obj_new_int(dfu_offs[x]);
-    }
-    mp_obj_t *ret2 = m_new(mp_obj_t, 2);
-    ret2[0] = mp_obj_new_list(dfu_nblks, secs);
-    ret2[1] = mp_obj_new_list(dfu_nblks, offs);
-    return mp_obj_new_list(2, ret2);
-}
-static MP_DEFINE_CONST_FUN_OBJ_1(esp_get_blks_obj, esp_get_blks);
-#endif  // MICROPY_DFU
-
-#ifdef MICROPY_DFM
-
-// Dynamic Frozen Modules (DFM)
-extern mp_import_stat_t (*mp_find_dynamic_frozen)(const char *str, int *frozen_type, void **data);
-uint32_t dynamic_frozen_start = 0;  // Flash absolute byte offset of the starting sector for dynamic frozen modules
-mp_import_stat_t mp_find_dynamic_frozen_(const char *str, int *frozen_type, void **data);
-
-/* This function serves many purposes:
-- if out_frozen_list!=NULL, it will output the list of strings of frozen items' names
-- if name!=NULL, it will stop at the frozen item with <name>
-- returns a pointer to the stopping sector
-Sector format for dynamic frozen modules: {
-    uint8_t n_sectors_;     // 0xff: end of dynamic_frozen list; 0x00: deleted; else: must be the same as n_sectors
-    uint8_t n_sectors;      // number of sectors spanned by the frozen item
-    uint8_t module_name_length;
-    uint8_t pad;
-    uint32_t frozen_content_length;
-    char module_name[?];
-    char frozen_content[?];
-}*/
-uint8_t *scan_dynamic_frozen(mp_obj_t out_frozen_list, const char *name) {
-    if (!dynamic_frozen_start) {
-        dynamic_frozen_start = (*(uint32_t *)(0x40208ffc) + FLASH_SEC_SIZE - 1) / FLASH_SEC_SIZE * FLASH_SEC_SIZE;
-    }
-    int n_modules = 0;
-    uint8_t *ptr = FLASH_START + dynamic_frozen_start;
-    while (ptr < FLASH_END) {
-        if (*ptr == 0xff) {
-            break;              // end-of-dynamic_frozen: erased sector are filled by with 0xff in NOR flash
-        }
-        if (*ptr == 0) {           // deleted frozen sector has 1st byte == 0 => skip
-            ptr += FLASH_SEC_SIZE;
-            continue;
-        }
-        if (ptr + FLASH_SEC_SIZE * ptr[1] > FLASH_END) {
-            break;                                       // corrupted frozen sector
-        }
-        if (*ptr != ptr[1]) {
-            break;                   // valid frozen sector must have byte1 == byte2 == #-of-sectors, or corrupted
-        }
-        if (ptr[8 + ptr[2]]) {
-            break;                   // not end-of-string NULL for module name => corrupted
-        }
-        if (strlen(ptr + 8) != ptr[2]) {
-            break;                        // incorrect module name string length
-        }
-        uint32_t mpy_size = *(uint32_t *)&ptr[4];
-        if (ptr + 9 + ptr[2] + mpy_size >= FLASH_END) {
-            break;                                       // module size overshoot => corrupted
-        }
-        n_modules++;
-
-        // handle output
-        if (out_frozen_list != NULL) {
-            mp_obj_t dfm_info[3] = {mp_obj_new_str(ptr + 8, ptr[2]), mp_obj_new_int(mpy_size), mp_obj_new_int(ptr - FLASH_START)};
-            mp_obj_list_append(out_frozen_list, mp_obj_new_tuple(3, &dfm_info[0]));
-        }
-        if (name && !strcmp(ptr + 8, name)) {
-            break;                              // found match
-        }
-        ptr += FLASH_SEC_SIZE * ptr[0];
-    }
-    mp_find_dynamic_frozen = n_modules?mp_find_dynamic_frozen_:NULL;
-    return ptr;
-}
-
-mp_import_stat_t mp_find_dynamic_frozen_(const char *str, int *frozen_type, void **data) {
-    byte *ptr = scan_dynamic_frozen(NULL, str);
-    if (ptr >= FLASH_END || ptr[0] != ptr[1] || ptr[0] == 0xff || strcmp(str, ptr + 8)) {
-        return MP_IMPORT_STAT_NO_EXIST;
-    }
-    if (frozen_type) {
-        *frozen_type = MP_FROZEN_MPY;
-    }
-    if (data) {
-        mp_module_context_t *ctx = m_new_obj(mp_module_context_t);
-        ctx->module.globals = mp_globals_get();
-        mp_compiled_module_t cm;
-        cm.context = ctx;
-        mp_raw_code_load_mem(&ptr[strlen(str) + 9], *(uint32_t *)&ptr[4], &cm);
-        mp_frozen_module_t *fc = malloc(sizeof(mp_frozen_module_t));
-        *(mp_module_constants_t *)&fc->constants = cm.context->constants;
-        fc->rc = cm.rc;
+        fc->proto_fun = (const void*)cm.rc;
         *data = fc;
     }
     return MP_IMPORT_STAT_FILE;

From f231bf83e6373c5015b128abd32eef7389d8e5f6 Mon Sep 17 00:00:00 2001
From: Wang Xuancong <xuancong84@gmail.com>
Date: Tue, 17 Sep 2024 22:16:08 +0800
Subject: [PATCH 26/51] workaround the deadlock due to "Fix uneven GIL
 allocation between Python threads" when IRQ is disabled

---
 extmod/modmachine.c        | 7 ++++---
 ports/esp32/build.sh       | 2 +-
 ports/esp32/mpthreadport.c | 6 +++++-
 3 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/extmod/modmachine.c b/extmod/modmachine.c
index 5906835949861..0c09d2a6ea134 100644
--- a/extmod/modmachine.c
+++ b/extmod/modmachine.c
@@ -124,16 +124,17 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_deepsleep_obj, 0, 1, machine_deepsle
 #endif
 
 #if MICROPY_PY_MACHINE_DISABLE_IRQ_ENABLE_IRQ
-
+uint32_t g_irq_state = 1;
 static mp_obj_t machine_disable_irq(void) {
     uint32_t state = MICROPY_BEGIN_ATOMIC_SECTION();
+    g_irq_state = 0;
     return mp_obj_new_int(state);
 }
 static MP_DEFINE_CONST_FUN_OBJ_0(machine_disable_irq_obj, machine_disable_irq);
 
 static mp_obj_t machine_enable_irq(mp_obj_t state_in) {
-    uint32_t state = mp_obj_get_int(state_in);
-    MICROPY_END_ATOMIC_SECTION(state);
+    g_irq_state = mp_obj_get_int(state_in);
+    MICROPY_END_ATOMIC_SECTION(g_irq_state);
     return mp_const_none;
 }
 static MP_DEFINE_CONST_FUN_OBJ_1(machine_enable_irq_obj, machine_enable_irq);
diff --git a/ports/esp32/build.sh b/ports/esp32/build.sh
index a5f7e7aa657cf..5ce50e625be60 100755
--- a/ports/esp32/build.sh
+++ b/ports/esp32/build.sh
@@ -2,7 +2,7 @@
 
 cd `dirname $(readlink -f "$0")`
 
-export PATH=~/.espressif/python_env/idf5.0_py3.10_env/bin:$PATH
+export PATH=~/.espressif/python_env/idf5*_env/bin:$PATH
 
 cd ~/projects/esp-idf
 source export.sh
diff --git a/ports/esp32/mpthreadport.c b/ports/esp32/mpthreadport.c
index eac1e5ea3668d..1d3a627ced0d2 100644
--- a/ports/esp32/mpthreadport.c
+++ b/ports/esp32/mpthreadport.c
@@ -222,7 +222,11 @@ void mp_thread_mutex_unlock(mp_thread_mutex_t *mutex) {
     // prevent pathological imbalances where a thread unlocks and then
     // immediately re-locks a mutex before a context switch can occur, leaving
     // another thread waiting for an unbounded period of time.
-    taskYIELD();
+#if MICROPY_PY_MACHINE_DISABLE_IRQ_ENABLE_IRQ
+    extern uint32_t g_irq_state;
+    if(g_irq_state==1)
+#endif
+        taskYIELD();
 }
 
 void mp_thread_deinit(void) {

From 5c7ac55232670aaccfc2d05d75f5d7a6772a61ef Mon Sep 17 00:00:00 2001
From: Glenn Moloney <glenn.moloney@gmail.com>
Date: Sat, 26 Oct 2024 15:19:54 +1100
Subject: [PATCH 27/51] tools/mpremote: Fix UnboundLocalError in
 Transport.fs_writefile().

The variable `written` was being used before it was defined in the
`fs_writefile()` method of the Transport class.  This was causing an
`UnboundLocalError` to be raised when the `progress_callback` was not
provided.

Fixes issue #16084.

Signed-off-by: Glenn Moloney <glenn.moloney@gmail.com>
---
 tools/mpremote/mpremote/transport.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/mpremote/mpremote/transport.py b/tools/mpremote/mpremote/transport.py
index 0b22a61580a03..d845796953a29 100644
--- a/tools/mpremote/mpremote/transport.py
+++ b/tools/mpremote/mpremote/transport.py
@@ -151,9 +151,9 @@ def fs_writefile(self, dest, data, chunk_size=256, progress_callback=None):
             while data:
                 chunk = data[:chunk_size]
                 self.exec("w(" + repr(chunk) + ")")
-                written += len(chunk)
                 data = data[len(chunk) :]
                 if progress_callback:
+                    written += len(chunk)
                     progress_callback(written, src_size)
             self.exec("f.close()")
         except TransportExecError as e:

From 785c92df7642577b1b1980aaaf92f86c0183895b Mon Sep 17 00:00:00 2001
From: Andrew Leech <andrew.leech@planetinnovation.com.au>
Date: Sun, 27 Oct 2024 14:51:37 +1100
Subject: [PATCH 28/51] esp32/machine_pwm: Use IDF functions to calculate
 resolution correctly.

This commit fixes PWM configuration across C3, C6, S2 and S3 chips, which
was broken by 6d799378bad4474e77ddb2fa2187ecd6e290e0ba.  Without this fix
the PWM frequency is limited to a maximum of 2446Hz (on S2 at least).

Signed-off-by: Andrew Leech <andrew@alelec.net>
---
 ports/esp32/machine_pwm.c | 50 +++++++++++++--------------------------
 1 file changed, 16 insertions(+), 34 deletions(-)

diff --git a/ports/esp32/machine_pwm.c b/ports/esp32/machine_pwm.c
index 71402e1c49e44..61efdfa18548b 100644
--- a/ports/esp32/machine_pwm.c
+++ b/ports/esp32/machine_pwm.c
@@ -34,6 +34,7 @@
 #include "py/mphal.h"
 #include "driver/ledc.h"
 #include "esp_err.h"
+#include "esp_clk_tree.h"
 #include "soc/gpio_sig_map.h"
 
 #define PWM_DBG(...)
@@ -209,51 +210,32 @@ static void configure_channel(machine_pwm_obj_t *self) {
 
 static void set_freq(machine_pwm_obj_t *self, unsigned int freq, ledc_timer_config_t *timer) {
     if (freq != timer->freq_hz) {
-        // Find the highest bit resolution for the requested frequency
-        unsigned int i = APB_CLK_FREQ; // 80 MHz
-        #if SOC_LEDC_SUPPORT_REF_TICK
-        if (freq < EMPIRIC_FREQ) {
-            i = REF_CLK_FREQ; // 1 MHz
-        }
-        #endif
-
-        int divider = (i + freq / 2) / freq; // rounded
-        if (divider == 0) {
-            divider = 1;
-        }
-        float f = (float)i / divider; // actual frequency
-        if (f <= 1.0) {
-            f = 1.0;
-        }
-        i = (unsigned int)roundf((float)i / f);
-
-        unsigned int res = 0;
-        for (; i > 1; i >>= 1) {
-            ++res;
-        }
-        if (res == 0) {
-            res = 1;
-        } else if (res > HIGHEST_PWM_RES) {
-            // Limit resolution to HIGHEST_PWM_RES to match units of our duty
-            res = HIGHEST_PWM_RES;
-        }
-
-        // Configure the new resolution and frequency
-        timer->duty_resolution = res;
+        // Configure the new frequency and resolution
         timer->freq_hz = freq;
-        #if SOC_LEDC_SUPPORT_XTAL_CLOCK
+
+        #if SOC_LEDC_SUPPORT_PLL_DIV_CLOCK
+        timer->clk_cfg = LEDC_USE_PLL_DIV_CLK;
+        #elif SOC_LEDC_SUPPORT_APB_CLOCK
+        timer->clk_cfg = LEDC_USE_APB_CLK;
+        #elif SOC_LEDC_SUPPORT_XTAL_CLOCK
         timer->clk_cfg = LEDC_USE_XTAL_CLK;
         #else
-        timer->clk_cfg = LEDC_USE_APB_CLK;
+        #error No supported PWM / LEDC clocks.
         #endif
         #if SOC_LEDC_SUPPORT_REF_TICK
         if (freq < EMPIRIC_FREQ) {
             timer->clk_cfg = LEDC_USE_REF_TICK;
         }
         #endif
+        uint32_t src_clk_freq = 0;
+        esp_err_t err = esp_clk_tree_src_get_freq_hz(timer->clk_cfg, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &src_clk_freq);
+        if (err != ESP_OK) {
+            mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("unable to query source clock frequency %d"), (int)timer->clk_cfg);
+        }
+        timer->duty_resolution = ledc_find_suitable_duty_resolution(src_clk_freq, timer->freq_hz);
 
         // Set frequency
-        esp_err_t err = ledc_timer_config(timer);
+        err = ledc_timer_config(timer);
         if (err != ESP_OK) {
             if (err == ESP_FAIL) {
                 mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("unreachable frequency %d"), freq);

From c0afff8f22ccb84ab46b01ebcd5e1e49803a71cb Mon Sep 17 00:00:00 2001
From: Alessandro Gatti <a.gatti@frob.it>
Date: Thu, 12 Sep 2024 13:08:32 +0200
Subject: [PATCH 29/51] pic16bit: Make it build with recent XC16 versions.

The PIC16 port didn't catch up with the other ports, so it required a bit
of work to make it build with the latest version of XC16.

Signed-off-by: Alessandro Gatti <a.gatti@frob.it>
---
 ports/pic16bit/Makefile       |  4 ++--
 ports/pic16bit/mpconfigport.h |  4 ----
 py/misc.h                     | 13 +++++++++++++
 3 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/ports/pic16bit/Makefile b/ports/pic16bit/Makefile
index 6d061514f9583..dda48fa3ce5f1 100644
--- a/ports/pic16bit/Makefile
+++ b/ports/pic16bit/Makefile
@@ -7,7 +7,7 @@ QSTR_DEFS = qstrdefsport.h
 include $(TOP)/py/py.mk
 include $(TOP)/extmod/extmod.mk
 
-XCVERSION ?= 1.35
+XCVERSION ?= 2.10
 XC16 ?= /opt/microchip/xc16/v$(XCVERSION)
 CROSS_COMPILE ?= $(XC16)/bin/xc16-
 
@@ -31,7 +31,7 @@ CFLAGS += -O1 -DNDEBUG
 endif
 
 LDFLAGS += --heap=0 -nostdlib -T $(XC16)/support/$(PARTFAMILY)/gld/p$(PART).gld -Map=$@.map --cref -p$(PART)
-LIBS += -L$(XC16)/lib -L$(XC16)/lib/$(PARTFAMILY) -lc -lm -lpic30
+LIBS += -L$(XC16)/lib -L$(XC16)/lib/$(PARTFAMILY) -lc99-elf -lm-elf -lc99-pic30-elf
 
 SRC_C = \
 	main.c \
diff --git a/ports/pic16bit/mpconfigport.h b/ports/pic16bit/mpconfigport.h
index a2d607fb29325..d80f7edb9e546 100644
--- a/ports/pic16bit/mpconfigport.h
+++ b/ports/pic16bit/mpconfigport.h
@@ -93,7 +93,3 @@ typedef int mp_off_t;
 #define MICROPY_MPHALPORT_H "pic16bit_mphal.h"
 #define MICROPY_HW_BOARD_NAME "dsPICSK"
 #define MICROPY_HW_MCU_NAME "dsPIC33"
-
-// XC16 toolchain doesn't seem to define these
-typedef int intptr_t;
-typedef unsigned int uintptr_t;
diff --git a/py/misc.h b/py/misc.h
index 96b13c151a6b9..8ac80bb7b3e34 100644
--- a/py/misc.h
+++ b/py/misc.h
@@ -380,6 +380,18 @@ static inline bool mp_check(bool value) {
 
 // mp_int_t can be larger than long, i.e. Windows 64-bit, nan-box variants
 static inline uint32_t mp_clz_mpi(mp_int_t x) {
+    #ifdef __XC16__
+    mp_uint_t mask = MP_OBJ_WORD_MSBIT_HIGH;
+    mp_uint_t zeroes = 0;
+    while (mask != 0) {
+        if (mask & (mp_uint_t)x) {
+            break;
+        }
+        zeroes++;
+        mask >>= 1;
+    }
+    return zeroes;
+    #else
     MP_STATIC_ASSERT(sizeof(mp_int_t) == sizeof(long long)
         || sizeof(mp_int_t) == sizeof(long));
 
@@ -389,6 +401,7 @@ static inline uint32_t mp_clz_mpi(mp_int_t x) {
     } else {
         return mp_clzll((unsigned long long)x);
     }
+    #endif
 }
 
 #endif // MICROPY_INCLUDED_PY_MISC_H

From a7d3bc23085fdc4dfe9bf644daf7fa6f2d5559df Mon Sep 17 00:00:00 2001
From: Jan Sturm <jansturm92@googlemail.com>
Date: Tue, 29 Oct 2024 19:26:19 +0100
Subject: [PATCH 30/51] py/objdeque: Fix buffer overflow in deque_subscr.

In `deque_subscr()`, if `index_val` equals `self->alloc`, the index
correction `index_val -= self->alloc` does not execute, leading to an
out-of-bounds access in `self->items[index_val]`.

The fix in this commit ensures that the index correction is applied
whenever `index_val >= self->alloc`, preventing access beyond the allocated
buffer size.

Signed-off-by: Jan Sturm <jansturm92@googlemail.com>
---
 py/objdeque.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py/objdeque.c b/py/objdeque.c
index 2ad771284df53..22c380a05a926 100644
--- a/py/objdeque.c
+++ b/py/objdeque.c
@@ -208,7 +208,7 @@ static mp_obj_t deque_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
 
     size_t offset = mp_get_index(self->base.type, deque_len(self), index, false);
     size_t index_val = self->i_get + offset;
-    if (index_val > self->alloc) {
+    if (index_val >= self->alloc) {
         index_val -= self->alloc;
     }
 

From 6f327684b75ca882d34402f885897ada8e57592d Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Thu, 31 Oct 2024 12:41:17 +1100
Subject: [PATCH 31/51] extmod/modlwip: Fix IGMP address type when IPv6 is
 enabled.

This was missed in 628abf8f25a7705a2810fffe2ca6ae652c532896.  The the bug
was that, when IPv6 is enabled, the `sizeof(ip_addr_t)` is much larger than
IPv4 size, which is what's needed for IGMP addressing.

Fixes issue #16100.

Signed-off-by: Damien George <damien@micropython.org>
---
 extmod/modlwip.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/extmod/modlwip.c b/extmod/modlwip.c
index 21c6f7264befa..0d38bf41b2051 100644
--- a/extmod/modlwip.c
+++ b/extmod/modlwip.c
@@ -1432,7 +1432,7 @@ static mp_obj_t lwip_socket_setsockopt(size_t n_args, const mp_obj_t *args) {
         case IP_DROP_MEMBERSHIP: {
             mp_buffer_info_t bufinfo;
             mp_get_buffer_raise(args[3], &bufinfo, MP_BUFFER_READ);
-            if (bufinfo.len != sizeof(ip_addr_t) * 2) {
+            if (bufinfo.len != sizeof(MP_IGMP_IP_ADDR_TYPE) * 2) {
                 mp_raise_ValueError(NULL);
             }
 

From 164c5492481cb0d66e13f068818f9e2bbfa4dad6 Mon Sep 17 00:00:00 2001
From: Angus Gratton <angus@redyak.com.au>
Date: Fri, 1 Nov 2024 15:57:40 +1100
Subject: [PATCH 32/51] esp32/machine_pwm: Restore PWM support for ESP-IDF
 v5.0.x and v5.1.x.

The cleanup in 548babf8 relies on some functions not available in older
ESP-IDF. Temporarily restore them, until we drop support for ESP-IDF <5.2.

PWM functionality should end up the same regardless of ESP-IDF version, and
also no different from MicroPython V1.23.

Signed-off-by: Angus Gratton <angus@redyak.com.au>
---
 ports/esp32/machine_pwm.c | 52 +++++++++++++++++++++++++++++++++++++--
 1 file changed, 50 insertions(+), 2 deletions(-)

diff --git a/ports/esp32/machine_pwm.c b/ports/esp32/machine_pwm.c
index 61efdfa18548b..0134fa2cc8c89 100644
--- a/ports/esp32/machine_pwm.c
+++ b/ports/esp32/machine_pwm.c
@@ -34,9 +34,12 @@
 #include "py/mphal.h"
 #include "driver/ledc.h"
 #include "esp_err.h"
-#include "esp_clk_tree.h"
 #include "soc/gpio_sig_map.h"
 
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 0)
+#include "esp_clk_tree.h"
+#endif
+
 #define PWM_DBG(...)
 // #define PWM_DBG(...) mp_printf(&mp_plat_print, __VA_ARGS__); mp_printf(&mp_plat_print, "\n");
 
@@ -208,7 +211,41 @@ static void configure_channel(machine_pwm_obj_t *self) {
     }
 }
 
+// Temporary workaround for ledc_find_suitable_duty_resolution function only being added in IDF V5.2
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 2, 0)
+static uint32_t ledc_find_suitable_duty_resolution(uint32_t src_clk_freq, uint32_t timer_freq) {
+    // This implementation is based on the one used in Micropython v1.23
+
+    // Find the highest bit resolution for the requested frequency
+    unsigned int freq = src_clk_freq;
+
+    int divider = (freq + timer_freq / 2) / timer_freq; // rounded
+    if (divider == 0) {
+        divider = 1;
+    }
+    float f = (float)freq / divider; // actual frequency
+    if (f <= 1.0) {
+        f = 1.0;
+    }
+    freq = (unsigned int)roundf((float)freq / f);
+
+    unsigned int res = 0;
+    for (; freq > 1; freq >>= 1) {
+        ++res;
+    }
+    if (res == 0) {
+        res = 1;
+    } else if (res > HIGHEST_PWM_RES) {
+        // Limit resolution to HIGHEST_PWM_RES to match units of our duty
+        res = HIGHEST_PWM_RES;
+    }
+
+    return res;
+}
+#endif
+
 static void set_freq(machine_pwm_obj_t *self, unsigned int freq, ledc_timer_config_t *timer) {
+    esp_err_t err;
     if (freq != timer->freq_hz) {
         // Configure the new frequency and resolution
         timer->freq_hz = freq;
@@ -228,10 +265,21 @@ static void set_freq(machine_pwm_obj_t *self, unsigned int freq, ledc_timer_conf
         }
         #endif
         uint32_t src_clk_freq = 0;
-        esp_err_t err = esp_clk_tree_src_get_freq_hz(timer->clk_cfg, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &src_clk_freq);
+        #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 0)
+        err = esp_clk_tree_src_get_freq_hz(timer->clk_cfg, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &src_clk_freq);
         if (err != ESP_OK) {
             mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("unable to query source clock frequency %d"), (int)timer->clk_cfg);
         }
+        #else
+        // Simplified fallback logic for IDF V5.0.x, for targets with APB only.
+        src_clk_freq = APB_CLK_FREQ; // 80 MHz
+        #if SOC_LEDC_SUPPORT_REF_TICK
+        if (timer->clk_cfg == LEDC_USE_REF_TICK) {
+            src_clk_freq = REF_CLK_FREQ; // 1 MHz
+        }
+        #endif // SOC_LEDC_SUPPORT_REF_TICK
+        #endif // ESP_IDF_VERSION
+
         timer->duty_resolution = ledc_find_suitable_duty_resolution(src_clk_freq, timer->freq_hz);
 
         // Set frequency

From 72799f99739f99496fd82b06b0c55ad7f58d2290 Mon Sep 17 00:00:00 2001
From: Angus Gratton <angus@redyak.com.au>
Date: Wed, 6 Nov 2024 14:27:01 +1100
Subject: [PATCH 33/51] esp32: Workaround native code execution crash on
 ESP32-S2.

Seemingly ESP-IDF incorrectly marks RTC FAST memory region
as MALLOC_CAP_EXEC on ESP32-S2 when it isn't. This memory is
the lowest priority, so it only is returned if D/IRAM is exhausted.

Apply this workaround to treat the allocation as failed if it gives us
non-executable RAM back, rather than crashing.

This work was funded through GitHub Sponsors.

Signed-off-by: Angus Gratton <angus@redyak.com.au>
---
 ports/esp32/main.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/ports/esp32/main.c b/ports/esp32/main.c
index 03dc0807a025c..18ef9d7354798 100644
--- a/ports/esp32/main.c
+++ b/ports/esp32/main.c
@@ -39,6 +39,7 @@
 #include "esp_task.h"
 #include "esp_event.h"
 #include "esp_log.h"
+#include "esp_memory_utils.h"
 #include "esp_psram.h"
 
 #include "py/cstack.h"
@@ -237,6 +238,13 @@ void *esp_native_code_commit(void *buf, size_t len, void *reloc) {
     len = (len + 3) & ~3;
     size_t len_node = sizeof(native_code_node_t) + len;
     native_code_node_t *node = heap_caps_malloc(len_node, MALLOC_CAP_EXEC);
+    #if CONFIG_IDF_TARGET_ESP32S2
+    // Workaround for ESP-IDF bug https://github.com/espressif/esp-idf/issues/14835
+    if (node != NULL && !esp_ptr_executable(node)) {
+        free(node);
+        node = NULL;
+    }
+    #endif // CONFIG_IDF_TARGET_ESP32S2
     if (node == NULL) {
         m_malloc_fail(len_node);
     }

From c1a85bb6debb6f20a19d8699f2a009fadd4ed9d2 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Wed, 6 Nov 2024 12:43:04 +1100
Subject: [PATCH 34/51] tools/mpremote: Make sure stdout and stderr output
 appear in order.

mpremote error messages now go to stderr, so make sure stdout is flushed
before printing them.

Also update the test runner to capture error messages.

Signed-off-by: Damien George <damien@micropython.org>
---
 tools/mpremote/mpremote/main.py            | 3 +++
 tools/mpremote/tests/run-mpremote-tests.sh | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/tools/mpremote/mpremote/main.py b/tools/mpremote/mpremote/main.py
index 8c0a6cd224c32..e6e397020fe85 100644
--- a/tools/mpremote/mpremote/main.py
+++ b/tools/mpremote/mpremote/main.py
@@ -547,7 +547,10 @@ def main():
 
         return 0
     except CommandError as e:
+        # Make sure existing stdout appears before the error message on stderr.
+        sys.stdout.flush()
         print(f"{_PROG}: {e}", file=sys.stderr)
+        sys.stderr.flush()
         return 1
     finally:
         do_disconnect(state)
diff --git a/tools/mpremote/tests/run-mpremote-tests.sh b/tools/mpremote/tests/run-mpremote-tests.sh
index 11d82c9bb3801..b25b5fd7d2966 100755
--- a/tools/mpremote/tests/run-mpremote-tests.sh
+++ b/tools/mpremote/tests/run-mpremote-tests.sh
@@ -16,7 +16,7 @@ for t in $TESTS; do
     TMP=$(mktemp -d)
     echo -n "${t}: "
     # Strip CR and replace the random temp dir with a token.
-    if env MPREMOTE=${MPREMOTE} TMP="${TMP}" "${t}" | tr -d '\r' | sed "s,${TMP},"'${TMP},g' > "${t}.out"; then
+    if env MPREMOTE=${MPREMOTE} TMP="${TMP}" "${t}" 2>&1 | tr -d '\r' | sed "s,${TMP},"'${TMP},g' > "${t}.out"; then
         if diff "${t}.out" "${t}.exp" > /dev/null; then
             echo "OK"
         else

From 159b54b7da404bc9a8d60d8c989e33e11412e548 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Wed, 6 Nov 2024 12:44:50 +1100
Subject: [PATCH 35/51] tools/mpremote: Add test for forced copy.

Signed-off-by: Damien George <damien@micropython.org>
---
 tools/mpremote/tests/test_filesystem.sh     | 5 +++++
 tools/mpremote/tests/test_filesystem.sh.exp | 4 ++++
 2 files changed, 9 insertions(+)

diff --git a/tools/mpremote/tests/test_filesystem.sh b/tools/mpremote/tests/test_filesystem.sh
index b6d5a7febcb84..727efea90eb67 100755
--- a/tools/mpremote/tests/test_filesystem.sh
+++ b/tools/mpremote/tests/test_filesystem.sh
@@ -66,6 +66,11 @@ $MPREMOTE resume cp "${TMP}/a.py" :aaa
 $MPREMOTE resume cp "${TMP}/a.py" :bbb/b.py
 $MPREMOTE resume cat :aaa/a.py bbb/b.py
 
+# Test cp -f (force copy).
+echo -----
+$MPREMOTE resume cp -f "${TMP}/a.py" :aaa
+$MPREMOTE resume cat :aaa/a.py
+
 echo -----
 $MPREMOTE resume rm :b.py c.py
 $MPREMOTE resume ls
diff --git a/tools/mpremote/tests/test_filesystem.sh.exp b/tools/mpremote/tests/test_filesystem.sh.exp
index 7220dc41e472c..b252bc7eb0d03 100644
--- a/tools/mpremote/tests/test_filesystem.sh.exp
+++ b/tools/mpremote/tests/test_filesystem.sh.exp
@@ -38,6 +38,10 @@ print("World")
 print("Hello")
 print("World")
 -----
+cp ${TMP}/a.py :aaa
+print("Hello")
+print("World")
+-----
 rm :b.py
 rm :c.py
 ls :

From 4e78c611b4b2ac2ee9eefb90b352fdc585f2a80a Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Wed, 6 Nov 2024 12:45:06 +1100
Subject: [PATCH 36/51] tools/mpremote: Support trailing slash on dest for
 non-recursive copy.

This fixes a regression in db59e55fe7a0b67d3af868990468e7b8056afe42: prior
to that commit `mpremote` supported trailing slashes on the destination of
a normal (non-recursive) copy.

Add back support for that, with the semantics that a trailing slash
requires the destination to be an existing directory.

Also add a test for this.

Signed-off-by: Damien George <damien@micropython.org>
---
 tools/mpremote/mpremote/commands.py         | 11 +++++++++--
 tools/mpremote/tests/test_filesystem.sh     |  5 +++++
 tools/mpremote/tests/test_filesystem.sh.exp |  6 ++++++
 3 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/tools/mpremote/mpremote/commands.py b/tools/mpremote/mpremote/commands.py
index 2b1acea438084..f86befd080349 100644
--- a/tools/mpremote/mpremote/commands.py
+++ b/tools/mpremote/mpremote/commands.py
@@ -129,8 +129,15 @@ def _remote_path_basename(a):
 
 def do_filesystem_cp(state, src, dest, multiple, check_hash=False):
     if dest.startswith(":"):
-        dest_exists = state.transport.fs_exists(dest[1:])
-        dest_isdir = dest_exists and state.transport.fs_isdir(dest[1:])
+        dest_no_slash = dest.rstrip("/" + os.path.sep + (os.path.altsep or ""))
+        dest_exists = state.transport.fs_exists(dest_no_slash[1:])
+        dest_isdir = dest_exists and state.transport.fs_isdir(dest_no_slash[1:])
+
+        # A trailing / on dest forces it to be a directory.
+        if dest != dest_no_slash:
+            if not dest_isdir:
+                raise CommandError("cp: destination is not a directory")
+            dest = dest_no_slash
     else:
         dest_exists = os.path.exists(dest)
         dest_isdir = dest_exists and os.path.isdir(dest)
diff --git a/tools/mpremote/tests/test_filesystem.sh b/tools/mpremote/tests/test_filesystem.sh
index 727efea90eb67..afeb7c91da8d6 100755
--- a/tools/mpremote/tests/test_filesystem.sh
+++ b/tools/mpremote/tests/test_filesystem.sh
@@ -71,6 +71,11 @@ echo -----
 $MPREMOTE resume cp -f "${TMP}/a.py" :aaa
 $MPREMOTE resume cat :aaa/a.py
 
+# Test cp where the destination has a trailing /.
+echo -----
+$MPREMOTE resume cp "${TMP}/a.py" :aaa/
+$MPREMOTE resume cp "${TMP}/a.py" :aaa/a.py/ || echo "expect error"
+
 echo -----
 $MPREMOTE resume rm :b.py c.py
 $MPREMOTE resume ls
diff --git a/tools/mpremote/tests/test_filesystem.sh.exp b/tools/mpremote/tests/test_filesystem.sh.exp
index b252bc7eb0d03..82fe7d6bf78c5 100644
--- a/tools/mpremote/tests/test_filesystem.sh.exp
+++ b/tools/mpremote/tests/test_filesystem.sh.exp
@@ -42,6 +42,12 @@ cp ${TMP}/a.py :aaa
 print("Hello")
 print("World")
 -----
+cp ${TMP}/a.py :aaa/
+Up to date: aaa/a.py
+cp ${TMP}/a.py :aaa/a.py/
+mpremote: cp: destination is not a directory
+expect error
+-----
 rm :b.py
 rm :c.py
 ls :

From 0c580f71aedac16045f0ecad9cb586aa389d9cff Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Mon, 11 Nov 2024 12:04:57 +1100
Subject: [PATCH 37/51] esp32/modsocket: Fix getaddrinfo hints to set
 AI_CANONNAME.

Because the `ai_canonname` field is subsequently used.

ESP32_GENERIC_S3 (at least) crashes with IDF 5.2.3 without this set.

Signed-off-by: Damien George <damien@micropython.org>
---
 ports/esp32/modsocket.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/ports/esp32/modsocket.c b/ports/esp32/modsocket.c
index 916eb79bd9265..7ea5e855d325e 100644
--- a/ports/esp32/modsocket.c
+++ b/ports/esp32/modsocket.c
@@ -213,7 +213,7 @@ static int mdns_getaddrinfo(const char *host_str, const char *port_str,
 #endif // MICROPY_HW_ENABLE_MDNS_QUERIES
 
 static void _getaddrinfo_inner(const mp_obj_t host, const mp_obj_t portx,
-    const struct addrinfo *hints, struct addrinfo **res) {
+    struct addrinfo *hints, struct addrinfo **res) {
     int retval = 0;
 
     *res = NULL;
@@ -235,6 +235,9 @@ static void _getaddrinfo_inner(const mp_obj_t host, const mp_obj_t portx,
 
     MP_THREAD_GIL_EXIT();
 
+    // The ai_canonname field is used below, so set the hint.
+    hints->ai_flags |= AI_CANONNAME;
+
     #if MICROPY_HW_ENABLE_MDNS_QUERIES
     retval = mdns_getaddrinfo(host_str, port_str, hints, res);
     #endif
@@ -264,7 +267,8 @@ static void _getaddrinfo_inner(const mp_obj_t host, const mp_obj_t portx,
 static void _socket_getaddrinfo(const mp_obj_t addrtuple, struct addrinfo **resp) {
     mp_obj_t *elem;
     mp_obj_get_array_fixed_n(addrtuple, 2, &elem);
-    _getaddrinfo_inner(elem[0], elem[1], NULL, resp);
+    struct addrinfo hints = { 0 };
+    _getaddrinfo_inner(elem[0], elem[1], &hints, resp);
 }
 
 static mp_obj_t socket_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {

From 20a6d82872263e0ef20de7c71b62456907244596 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Wed, 13 Nov 2024 14:21:29 +1100
Subject: [PATCH 38/51] extmod/vfs_blockdev: Support bool return from Python
 read/write blocks.

Commit f4ab9d924790581989f2398fe30bbac5d680577f inadvertently broke some
Python block devices, for example esp32 and stm32 SDCard classes.  Those
classes return a bool from their `readblocks` and `writeblocks` methods
instead of an integer errno code.  With that change, both `False` and
`True` return values are now be interpreted as non-zero and hence the block
device call fails.

The fix in this commit is to allow a bool and explicitly convert `True` to
0 and `False` to `-MP_EIO`.

Signed-off-by: Damien George <damien@micropython.org>
---
 extmod/vfs_blockdev.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/extmod/vfs_blockdev.c b/extmod/vfs_blockdev.c
index a7c14b76ee368..d43c96b08f326 100644
--- a/extmod/vfs_blockdev.c
+++ b/extmod/vfs_blockdev.c
@@ -58,6 +58,13 @@ static int mp_vfs_blockdev_call_rw(mp_obj_t *args, size_t block_num, size_t bloc
     if (ret == mp_const_none) {
         return 0;
     } else {
+        // Some block devices return a bool indicating success, so
+        // convert those to an errno integer code.
+        if (ret == mp_const_true) {
+            return 0;
+        } else if (ret == mp_const_false) {
+            return -MP_EIO;
+        }
         // Block device functions are expected to return 0 on success
         // and negative integer on errors. Check for positive integer
         // results as some callers (i.e. littlefs) will produce corrupt

From 67f893852af455a8fd938d67dda74f1465af0960 Mon Sep 17 00:00:00 2001
From: Angus Gratton <angus@redyak.com.au>
Date: Wed, 13 Nov 2024 18:14:47 +1100
Subject: [PATCH 39/51] extmod/network_cyw43: Fix isconnected() result on AP
 interface.

This function is documented to return True if any stations are connected to
the AP. Without this fix it returns True whenever the driver has brought
the AP interface up.

This work was funded through GitHub Sponsors.

Signed-off-by: Angus Gratton <angus@redyak.com.au>
---
 extmod/network_cyw43.c | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/extmod/network_cyw43.c b/extmod/network_cyw43.c
index 3066cac75d3b7..891e945de5118 100644
--- a/extmod/network_cyw43.c
+++ b/extmod/network_cyw43.c
@@ -311,7 +311,17 @@ static MP_DEFINE_CONST_FUN_OBJ_1(network_cyw43_disconnect_obj, network_cyw43_dis
 
 static mp_obj_t network_cyw43_isconnected(mp_obj_t self_in) {
     network_cyw43_obj_t *self = MP_OBJ_TO_PTR(self_in);
-    return mp_obj_new_bool(cyw43_tcpip_link_status(self->cyw, self->itf) == 3);
+    bool result = (cyw43_tcpip_link_status(self->cyw, self->itf) == CYW43_LINK_UP);
+
+    if (result && self->itf == CYW43_ITF_AP) {
+        // For AP we need to not only know if the link is up, but also if any stations
+        // have associated.
+        uint8_t mac_buf[6];
+        int num_stas = 1;
+        cyw43_wifi_ap_get_stas(self->cyw, &num_stas, mac_buf);
+        result = num_stas > 0;
+    }
+    return mp_obj_new_bool(result);
 }
 static MP_DEFINE_CONST_FUN_OBJ_1(network_cyw43_isconnected_obj, network_cyw43_isconnected);
 

From 4f4d683ea58b69ae0906894b5fb98c9da9216ff9 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Tue, 19 Nov 2024 11:26:34 +1100
Subject: [PATCH 40/51] extmod/network_cyw43: Fix uninitialised variable in
 status('stations').

The `num_stas` was uninitialised and if it happened to take the value 0
then no results were returned.  It now has the correct maximum value.

Signed-off-by: Damien George <damien@micropython.org>
---
 extmod/network_cyw43.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/extmod/network_cyw43.c b/extmod/network_cyw43.c
index 891e945de5118..cebc8deb0da91 100644
--- a/extmod/network_cyw43.c
+++ b/extmod/network_cyw43.c
@@ -361,13 +361,15 @@ static mp_obj_t network_cyw43_status(size_t n_args, const mp_obj_t *args) {
             if (self->itf != CYW43_ITF_AP) {
                 mp_raise_ValueError(MP_ERROR_TEXT("AP required"));
             }
-            int num_stas;
-            uint8_t macs[32 * 6];
+            static const unsigned mac_len = 6;
+            static const unsigned max_stas = 32;
+            int num_stas = max_stas;
+            uint8_t macs[max_stas * mac_len];
             cyw43_wifi_ap_get_stas(self->cyw, &num_stas, macs);
             mp_obj_t list = mp_obj_new_list(num_stas, NULL);
             for (int i = 0; i < num_stas; ++i) {
                 mp_obj_t tuple[1] = {
-                    mp_obj_new_bytes(&macs[i * 6], 6),
+                    mp_obj_new_bytes(&macs[i * mac_len], mac_len),
                 };
                 ((mp_obj_list_t *)MP_OBJ_TO_PTR(list))->items[i] = mp_obj_new_tuple(1, tuple);
             }

From 49b83ed44a0bd8ed2e8b4b82ae9ca09b47f4dbf9 Mon Sep 17 00:00:00 2001
From: Angus Gratton <angus@redyak.com.au>
Date: Wed, 13 Nov 2024 18:04:59 +1100
Subject: [PATCH 41/51] extmod/network_cyw43: Allow configuring active AP
 interface.

Configuring the AP for cyw43 writes to some buffers that are only sent to
the modem when the interface is brought up. This means you can't configure
the AP after calling active(True), the new settings seem to be accepted but
the radio doesn't change.

This is different to the WLAN behaviour on other ports. The esp8266 port
requires calling active(True) on the AP before configuring, even.

Fix this by bouncing the AP interface after a config change, if it's
active. Configuring with active(False) still works the same as before.

Adds a static variable to track interface active state, rather than relying
on the LWIP interface state. This is because the interface state is updated
by a driver callback and there's a race: if code calls active(True) and
then config(a=b) then the driver doesn't know it's active yet and the
changes aren't correctly applied.

It is possible this pattern will cause the AP to come up briefly with the
default "PICOabcd" SSID before being reconfigured, however (due to the
aforementioned race condition) it seems like this may not happen at all
before the new config is applied.

This work was funded through GitHub Sponsors.

Signed-off-by: Angus Gratton <angus@redyak.com.au>
---
 extmod/network_cyw43.c | 30 +++++++++++++++++++++++++++---
 1 file changed, 27 insertions(+), 3 deletions(-)

diff --git a/extmod/network_cyw43.c b/extmod/network_cyw43.c
index cebc8deb0da91..02b022cb81327 100644
--- a/extmod/network_cyw43.c
+++ b/extmod/network_cyw43.c
@@ -60,6 +60,10 @@ typedef struct _network_cyw43_obj_t {
 static const network_cyw43_obj_t network_cyw43_wl_sta = { { &mp_network_cyw43_type }, &cyw43_state, CYW43_ITF_STA };
 static const network_cyw43_obj_t network_cyw43_wl_ap = { { &mp_network_cyw43_type }, &cyw43_state, CYW43_ITF_AP };
 
+// Avoid race conditions with callbacks by tracking the last up or down request
+// we have made for each interface.
+static bool if_active[2];
+
 static void network_cyw43_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     network_cyw43_obj_t *self = MP_OBJ_TO_PTR(self_in);
     struct netif *netif = &self->cyw->netif[self->itf];
@@ -122,6 +126,10 @@ static MP_DEFINE_CONST_FUN_OBJ_3(network_cyw43_ioctl_obj, network_cyw43_ioctl);
 /*******************************************************************************/
 // network API
 
+static uint32_t get_country_code(void) {
+    return CYW43_COUNTRY(mod_network_country_code[0], mod_network_country_code[1], 0);
+}
+
 static mp_obj_t network_cyw43_deinit(mp_obj_t self_in) {
     network_cyw43_obj_t *self = MP_OBJ_TO_PTR(self_in);
     cyw43_deinit(self->cyw);
@@ -132,10 +140,11 @@ static MP_DEFINE_CONST_FUN_OBJ_1(network_cyw43_deinit_obj, network_cyw43_deinit)
 static mp_obj_t network_cyw43_active(size_t n_args, const mp_obj_t *args) {
     network_cyw43_obj_t *self = MP_OBJ_TO_PTR(args[0]);
     if (n_args == 1) {
-        return mp_obj_new_bool(cyw43_tcpip_link_status(self->cyw, self->itf));
+        return mp_obj_new_bool(if_active[self->itf]);
     } else {
-        uint32_t country = CYW43_COUNTRY(mod_network_country_code[0], mod_network_country_code[1], 0);
-        cyw43_wifi_set_up(self->cyw, self->itf, mp_obj_is_true(args[1]), country);
+        bool value = mp_obj_is_true(args[1]);
+        cyw43_wifi_set_up(self->cyw, self->itf, value, get_country_code());
+        if_active[self->itf] = value;
         return mp_const_none;
     }
 }
@@ -457,6 +466,10 @@ static mp_obj_t network_cyw43_config(size_t n_args, const mp_obj_t *args, mp_map
             mp_raise_TypeError(MP_ERROR_TEXT("can't specify pos and kw args"));
         }
 
+        // A number of these options only update buffers in memory, and
+        // won't do anything until the interface is cycled down and back up
+        bool cycle_active = false;
+
         for (size_t i = 0; i < kwargs->alloc; ++i) {
             if (MP_MAP_SLOT_IS_FILLED(kwargs, i)) {
                 mp_map_elem_t *e = &kwargs->table[i];
@@ -469,6 +482,7 @@ static mp_obj_t network_cyw43_config(size_t n_args, const mp_obj_t *args, mp_map
                     }
                     case MP_QSTR_channel: {
                         cyw43_wifi_ap_set_channel(self->cyw, mp_obj_get_int(e->value));
+                        cycle_active = true;
                         break;
                     }
                     case MP_QSTR_ssid:
@@ -476,6 +490,7 @@ static mp_obj_t network_cyw43_config(size_t n_args, const mp_obj_t *args, mp_map
                         size_t len;
                         const char *str = mp_obj_str_get_data(e->value, &len);
                         cyw43_wifi_ap_set_ssid(self->cyw, len, (const uint8_t *)str);
+                        cycle_active = true;
                         break;
                     }
                     case MP_QSTR_monitor: {
@@ -495,6 +510,7 @@ static mp_obj_t network_cyw43_config(size_t n_args, const mp_obj_t *args, mp_map
                     }
                     case MP_QSTR_security: {
                         cyw43_wifi_ap_set_auth(self->cyw, mp_obj_get_int(e->value));
+                        cycle_active = true;
                         break;
                     }
                     case MP_QSTR_key:
@@ -502,6 +518,7 @@ static mp_obj_t network_cyw43_config(size_t n_args, const mp_obj_t *args, mp_map
                         size_t len;
                         const char *str = mp_obj_str_get_data(e->value, &len);
                         cyw43_wifi_ap_set_password(self->cyw, len, (const uint8_t *)str);
+                        cycle_active = true;
                         break;
                     }
                     case MP_QSTR_pm: {
@@ -531,6 +548,13 @@ static mp_obj_t network_cyw43_config(size_t n_args, const mp_obj_t *args, mp_map
             }
         }
 
+        // If the interface is already active, cycle it down and up
+        if (cycle_active && if_active[self->itf]) {
+            uint32_t country = get_country_code();
+            cyw43_wifi_set_up(self->cyw, self->itf, false, country);
+            cyw43_wifi_set_up(self->cyw, self->itf, true, country);
+        }
+
         return mp_const_none;
     }
 }

From 03bc561edb39073af28e0ee32a5e47543a0973c8 Mon Sep 17 00:00:00 2001
From: Angus Gratton <angus@redyak.com.au>
Date: Wed, 13 Nov 2024 10:16:25 +1100
Subject: [PATCH 42/51] esp32: Fix setting WLAN channel in AP mode.

- Previously the call to esp_wifi_set_channel() would be immediately
  overridden by calling esp_wifi_config(...) with the previous channel set.

- AP interface doesn't seem to need more than esp_wifi_config(...) to work.
  It will automatically configure 40MHz bandwidth and place the secondary
  channel using similar logic to what was being explicitly calculated here.

- However, calling esp_wifi_set_channel() on the STA interface is necessary
  if using this interface with ESP-NOW (without connecting to an AP). So
  the esp_wifi_set_channel() call is kept in for this purpose. Without
  this, tests/multi_espnow/70_channel.py fails.

This work was funded through GitHub Sponsors.

Signed-off-by: Angus Gratton <angus@redyak.com.au>
---
 ports/esp32/network_wlan.c | 43 ++++++++++++++++++++++++++------------
 1 file changed, 30 insertions(+), 13 deletions(-)

diff --git a/ports/esp32/network_wlan.c b/ports/esp32/network_wlan.c
index 7e802166c116c..66b72e495e209 100644
--- a/ports/esp32/network_wlan.c
+++ b/ports/esp32/network_wlan.c
@@ -549,21 +549,38 @@ static mp_obj_t network_wlan_config(size_t n_args, const mp_obj_t *args, mp_map_
                         break;
                     }
                     case MP_QSTR_channel: {
-                        uint8_t primary;
-                        wifi_second_chan_t secondary;
-                        // Get the current value of secondary
-                        esp_exceptions(esp_wifi_get_channel(&primary, &secondary));
-                        primary = mp_obj_get_int(kwargs->table[i].value);
-                        esp_err_t err = esp_wifi_set_channel(primary, secondary);
-                        if (err == ESP_ERR_INVALID_ARG) {
-                            // May need to swap secondary channel above to below or below to above
-                            secondary = (
-                                (secondary == WIFI_SECOND_CHAN_ABOVE)
-                                ? WIFI_SECOND_CHAN_BELOW
-                                : (secondary == WIFI_SECOND_CHAN_BELOW)
+                        uint8_t channel = mp_obj_get_int(kwargs->table[i].value);
+                        if (self->if_id == ESP_IF_WIFI_AP) {
+                            cfg.ap.channel = channel;
+                        } else {
+                            // This setting is only used to determine the
+                            // starting channel for a scan, so it can result in
+                            // slightly faster connection times.
+                            cfg.sta.channel = channel;
+
+                            // This additional code to directly set the channel
+                            // on the STA interface is only relevant for ESP-NOW
+                            // (when there is no STA connection attempt.)
+                            uint8_t old_primary;
+                            wifi_second_chan_t secondary;
+                            // Get the current value of secondary
+                            esp_exceptions(esp_wifi_get_channel(&old_primary, &secondary));
+                            esp_err_t err = esp_wifi_set_channel(channel, secondary);
+                            if (err == ESP_ERR_INVALID_ARG) {
+                                // May need to swap secondary channel above to below or below to above
+                                secondary = (
+                                    (secondary == WIFI_SECOND_CHAN_ABOVE)
+                                    ? WIFI_SECOND_CHAN_BELOW
+                                    : (secondary == WIFI_SECOND_CHAN_BELOW)
                                     ? WIFI_SECOND_CHAN_ABOVE
                                     : WIFI_SECOND_CHAN_NONE);
-                            esp_exceptions(esp_wifi_set_channel(primary, secondary));
+                                err = esp_wifi_set_channel(channel, secondary);
+                            }
+                            esp_exceptions(err);
+                            if (channel != old_primary) {
+                                // Workaround the ESP-IDF Wi-Fi stack sometimes taking a moment to change channels
+                                mp_hal_delay_ms(1);
+                            }
                         }
                         break;
                     }

From eb0027b82f77e9c9f072cecc1130c66ac287bc8a Mon Sep 17 00:00:00 2001
From: Angus Gratton <angus@redyak.com.au>
Date: Wed, 6 Nov 2024 16:48:56 +1100
Subject: [PATCH 43/51] esp32: Use hardware version for touchpad macro defines.

ESP32 has hardware V1 and S2/S3 has V2, and future chips
may have different versions.

This should still compile to the same binary before and after.

This work was funded through GitHub Sponsors.

Signed-off-by: Angus Gratton <angus@redyak.com.au>
---
 ports/esp32/machine_touchpad.c | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/ports/esp32/machine_touchpad.c b/ports/esp32/machine_touchpad.c
index 7612063e51d4a..a35e7fccda215 100644
--- a/ports/esp32/machine_touchpad.c
+++ b/ports/esp32/machine_touchpad.c
@@ -29,12 +29,14 @@
 #include "modmachine.h"
 #include "driver/gpio.h"
 
-#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
+#if SOC_TOUCH_SENSOR_SUPPORTED
 
-#if CONFIG_IDF_TARGET_ESP32
+#if SOC_TOUCH_VERSION_1 // ESP32 only
 #include "driver/touch_pad.h"
-#elif CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
+#elif SOC_TOUCH_VERSION_2 // All other SoCs with touch, to date
 #include "driver/touch_sensor.h"
+#else
+#error "Unknown touch hardware version"
 #endif
 
 typedef struct _mtp_obj_t {
@@ -70,6 +72,8 @@ static const mtp_obj_t touchpad_obj[] = {
     {{&machine_touchpad_type}, GPIO_NUM_12, TOUCH_PAD_NUM12},
     {{&machine_touchpad_type}, GPIO_NUM_13, TOUCH_PAD_NUM13},
     {{&machine_touchpad_type}, GPIO_NUM_14, TOUCH_PAD_NUM14},
+    #else
+    #error "Please add GPIO mapping for this SoC"
     #endif
 };
 
@@ -92,14 +96,14 @@ static mp_obj_t mtp_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_
     if (!initialized) {
         touch_pad_init();
         touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER);
-        #if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
+        #if TOUCH_HW_VER == 2
         touch_pad_fsm_start();
         #endif
         initialized = 1;
     }
-    #if CONFIG_IDF_TARGET_ESP32
+    #if SOC_TOUCH_VERSION_1
     esp_err_t err = touch_pad_config(self->touchpad_id, 0);
-    #elif CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
+    #elif SOC_TOUCH_VERSION_2
     esp_err_t err = touch_pad_config(self->touchpad_id);
     #endif
     if (err == ESP_OK) {
@@ -110,10 +114,10 @@ static mp_obj_t mtp_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_
 
 static mp_obj_t mtp_config(mp_obj_t self_in, mp_obj_t value_in) {
     mtp_obj_t *self = self_in;
-    #if CONFIG_IDF_TARGET_ESP32
+    #if SOC_TOUCH_VERSION_1
     uint16_t value = mp_obj_get_int(value_in);
     esp_err_t err = touch_pad_config(self->touchpad_id, value);
-    #elif CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
+    #elif SOC_TOUCH_VERSION_2
     esp_err_t err = touch_pad_config(self->touchpad_id);
     #endif
     if (err == ESP_OK) {
@@ -125,10 +129,10 @@ MP_DEFINE_CONST_FUN_OBJ_2(mtp_config_obj, mtp_config);
 
 static mp_obj_t mtp_read(mp_obj_t self_in) {
     mtp_obj_t *self = self_in;
-    #if CONFIG_IDF_TARGET_ESP32
+    #if SOC_TOUCH_VERSION_1
     uint16_t value;
     esp_err_t err = touch_pad_read(self->touchpad_id, &value);
-    #elif CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
+    #elif SOC_TOUCH_VERSION_2
     uint32_t value;
     esp_err_t err = touch_pad_read_raw_data(self->touchpad_id, &value);
     #endif
@@ -155,4 +159,4 @@ MP_DEFINE_CONST_OBJ_TYPE(
     locals_dict, &mtp_locals_dict
     );
 
-#endif
+#endif // SOC_TOUCH_SENSOR_SUPPORTED

From 33f50d4f20de3543f81a8404545eeeffb4aebbc0 Mon Sep 17 00:00:00 2001
From: Angus Gratton <angus@redyak.com.au>
Date: Wed, 6 Nov 2024 17:14:09 +1100
Subject: [PATCH 44/51] esp32: Fix machine.TouchPad startup on ESP32-S2 and S3.

Closes #13178.

TouchPad confirmed working on both chips, and fixes the the ESP32-S3
reading constant max value. Was unable to reproduce the bug on ESP32-S2 but
this may be due to my test setup, and it still works with the fix.

This work was funded through GitHub Sponsors.

Signed-off-by: Angus Gratton <angus@redyak.com.au>
---
 ports/esp32/machine_touchpad.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/ports/esp32/machine_touchpad.c b/ports/esp32/machine_touchpad.c
index a35e7fccda215..48250280badaf 100644
--- a/ports/esp32/machine_touchpad.c
+++ b/ports/esp32/machine_touchpad.c
@@ -96,9 +96,6 @@ static mp_obj_t mtp_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_
     if (!initialized) {
         touch_pad_init();
         touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER);
-        #if TOUCH_HW_VER == 2
-        touch_pad_fsm_start();
-        #endif
         initialized = 1;
     }
     #if SOC_TOUCH_VERSION_1
@@ -107,6 +104,10 @@ static mp_obj_t mtp_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_
     esp_err_t err = touch_pad_config(self->touchpad_id);
     #endif
     if (err == ESP_OK) {
+        #if SOC_TOUCH_VERSION_2
+        touch_pad_fsm_start();
+        #endif
+
         return MP_OBJ_FROM_PTR(self);
     }
     mp_raise_ValueError(MP_ERROR_TEXT("Touch pad error"));

From 948863c0b8ab4937d11aadf4cbb1b688bf66bf8f Mon Sep 17 00:00:00 2001
From: Corran Webster <cwebster@unital.dev>
Date: Thu, 14 Nov 2024 10:15:10 +0000
Subject: [PATCH 45/51] extmod/modframebuf: Fix 0 radius bug in
 FrameBuffer.ellipse.

This fixes a bug in FrameBuffer.ellipse where it goes into an infinite loop
if both radii are 0.

This fixes the bug with a simple pre-check to see if both radii are 0, and
in that case sets a single pixel at the center. This is consistent with the
behaviour of the method when called with just one of the radii set to 0,
where it will draw a horizontal or vertical line of 1 pixel width.

The pixel is set with setpixel_checked so it should handle out-of-bounds
drawing correctly.

This fix also includes three new tests: one for the default behaviour, one
for drawing out-of-bounds, and one for when the sector mask is 0.

Fixes issue #16053.

Signed-off-by: Corran Webster <cwebster@unital.dev>
---
 extmod/modframebuf.c                 |  4 ++
 tests/extmod/framebuf_ellipse.py     | 15 +++++
 tests/extmod/framebuf_ellipse.py.exp | 96 ++++++++++++++++++++++++++++
 3 files changed, 115 insertions(+)

diff --git a/extmod/modframebuf.c b/extmod/modframebuf.c
index cd0f50d104427..b718a66cc62fe 100644
--- a/extmod/modframebuf.c
+++ b/extmod/modframebuf.c
@@ -536,6 +536,10 @@ static mp_obj_t framebuf_ellipse(size_t n_args, const mp_obj_t *args_in) {
     } else {
         mask |= ELLIPSE_MASK_ALL;
     }
+    if (args[2] == 0 && args[3] == 0) {
+        setpixel_checked(self, args[0], args[1], args[4], mask & ELLIPSE_MASK_ALL);
+        return mp_const_none;
+    }
     mp_int_t two_asquare = 2 * args[2] * args[2];
     mp_int_t two_bsquare = 2 * args[3] * args[3];
     mp_int_t x = args[2];
diff --git a/tests/extmod/framebuf_ellipse.py b/tests/extmod/framebuf_ellipse.py
index a4c784aff8762..ec0461e66ca03 100644
--- a/tests/extmod/framebuf_ellipse.py
+++ b/tests/extmod/framebuf_ellipse.py
@@ -63,3 +63,18 @@ def printbuf():
     fbuf.fill(0)
     fbuf.ellipse(x, y, 6, 12, 0xAA, True)
     printbuf()
+
+# Draw an ellipse with both radius 0
+fbuf.fill(0)
+fbuf.ellipse(15, 15, 0, 0, 0xFF, True)
+printbuf()
+
+# Draw an ellipse with both radius 0 out of bounds
+fbuf.fill(0)
+fbuf.ellipse(45, 45, 0, 0, 0xFF, True)
+printbuf()
+
+# Draw an ellipse with radius 0 and all sectors masked out
+fbuf.fill(0)
+fbuf.ellipse(15, 15, 0, 0, 0xFF, True, 0)
+printbuf()
diff --git a/tests/extmod/framebuf_ellipse.py.exp b/tests/extmod/framebuf_ellipse.py.exp
index ae6ad1ee7e487..96a60c24da1f1 100644
--- a/tests/extmod/framebuf_ellipse.py.exp
+++ b/tests/extmod/framebuf_ellipse.py.exp
@@ -702,3 +702,99 @@ aaaaaaaaaaaaaaaaaaaaaa00000000000000000000000000000000000000
 aaaaaaaaaaaaaaaaaaaaaa00000000000000000000000000000000000000
 aaaaaaaaaaaaaaaaaaaaaa00000000000000000000000000000000000000
 -->8--
+--8<--
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000ff0000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+-->8--
+--8<--
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+-->8--
+--8<--
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000
+-->8--

From 7118942a8c03413e0e85b9b42fc9e1b167966d57 Mon Sep 17 00:00:00 2001
From: robert-hh <robert@hammelrath.com>
Date: Wed, 27 Nov 2024 16:57:02 +0100
Subject: [PATCH 46/51] nrf/drivers/ticker: Reset slow ticker callback count on
 soft reboot.

The micro:bit board (and probably other boards using the music or display
module) locked up on soft reboot.  Reason was a buffer overflow caused by
an index counter, which was not reset on soft_reboot.

That's fixed in this commit.  Tested with a micro:bit board, performing a
series of soft reboots.

Signed-off-by: robert-hh <robert@hammelrath.com>
---
 ports/nrf/drivers/ticker.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ports/nrf/drivers/ticker.c b/ports/nrf/drivers/ticker.c
index c2fa31e7c207b..e9c07c842ecd5 100644
--- a/ports/nrf/drivers/ticker.c
+++ b/ports/nrf/drivers/ticker.c
@@ -62,6 +62,7 @@ void ticker_init0(void) {
 #else
     NRFX_IRQ_PRIORITY_SET(FastTicker_IRQn, 2);
 #endif
+    m_num_of_slow_tickers = 0;
 
     NRFX_IRQ_PRIORITY_SET(SlowTicker_IRQn, 3);
 

From 564ef28ad2ca1c0fb302ac3f46d5f2d07de353de Mon Sep 17 00:00:00 2001
From: Angus Gratton <angus@redyak.com.au>
Date: Wed, 20 Nov 2024 16:15:20 +1100
Subject: [PATCH 47/51] py/objfloat: Workaround non-constant NAN definition on
 Windows MSVC.

Recent MSVC versions have changed the definition of NAN to a non-constant
expression!  This is a bug, C standard says it should be a constant.

Good explanation and workaround at: https://stackoverflow.com/a/79199887

This work was funded through GitHub Sponsors.

Signed-off-by: Angus Gratton <angus@redyak.com.au>
---
 py/objfloat.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/py/objfloat.c b/py/objfloat.c
index 5c90b1491cebf..0728fce3151fe 100644
--- a/py/objfloat.c
+++ b/py/objfloat.c
@@ -47,6 +47,13 @@
 #define M_PI (3.14159265358979323846)
 #endif
 
+// Workaround a bug in recent MSVC where NAN is no longer constant.
+// (By redefining back to the previous MSVC definition of NAN)
+#if defined(_MSC_VER) && _MSC_VER >= 1942
+#undef NAN
+#define NAN (-(float)(((float)(1e+300 * 1e+300)) * 0.0F))
+#endif
+
 typedef struct _mp_obj_float_t {
     mp_obj_base_t base;
     mp_float_t value;

From ecfdd5d6f9be971852003c2049600dc7b3e2a838 Mon Sep 17 00:00:00 2001
From: Damien George <damien@micropython.org>
Date: Fri, 29 Nov 2024 23:53:11 +1100
Subject: [PATCH 48/51] all: Bump version to 1.24.1.

Signed-off-by: Damien George <damien@micropython.org>
---
 py/mpconfig.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/py/mpconfig.h b/py/mpconfig.h
index caea0f4f7a3b8..a828f505ceac8 100644
--- a/py/mpconfig.h
+++ b/py/mpconfig.h
@@ -31,7 +31,7 @@
 // are unavailable.
 #define MICROPY_VERSION_MAJOR 1
 #define MICROPY_VERSION_MINOR 24
-#define MICROPY_VERSION_MICRO 0
+#define MICROPY_VERSION_MICRO 1
 #define MICROPY_VERSION_PRERELEASE 0
 
 // Combined version as a 32-bit number for convenience to allow version

From f0031ae985684adc552101126dfc0e46cb48d221 Mon Sep 17 00:00:00 2001
From: Wang Xuancong <xuancong84@gmail.com>
Date: Sun, 16 Mar 2025 13:47:19 +0800
Subject: [PATCH 49/51] esp32 working after merge

---
 extmod/modmachine.c        | 6 ++----
 ports/esp32/build.sh       | 2 +-
 ports/esp32/mpthreadport.c | 6 +-----
 3 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/extmod/modmachine.c b/extmod/modmachine.c
index 0c09d2a6ea134..ada1197c15f08 100644
--- a/extmod/modmachine.c
+++ b/extmod/modmachine.c
@@ -124,17 +124,15 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_deepsleep_obj, 0, 1, machine_deepsle
 #endif
 
 #if MICROPY_PY_MACHINE_DISABLE_IRQ_ENABLE_IRQ
-uint32_t g_irq_state = 1;
 static mp_obj_t machine_disable_irq(void) {
     uint32_t state = MICROPY_BEGIN_ATOMIC_SECTION();
-    g_irq_state = 0;
     return mp_obj_new_int(state);
 }
 static MP_DEFINE_CONST_FUN_OBJ_0(machine_disable_irq_obj, machine_disable_irq);
 
 static mp_obj_t machine_enable_irq(mp_obj_t state_in) {
-    g_irq_state = mp_obj_get_int(state_in);
-    MICROPY_END_ATOMIC_SECTION(g_irq_state);
+    uint32_t irq_state = mp_obj_get_int(state_in);
+    MICROPY_END_ATOMIC_SECTION(irq_state);
     return mp_const_none;
 }
 static MP_DEFINE_CONST_FUN_OBJ_1(machine_enable_irq_obj, machine_enable_irq);
diff --git a/ports/esp32/build.sh b/ports/esp32/build.sh
index 5ce50e625be60..34c12dfd8f634 100755
--- a/ports/esp32/build.sh
+++ b/ports/esp32/build.sh
@@ -2,7 +2,7 @@
 
 cd `dirname $(readlink -f "$0")`
 
-export PATH=~/.espressif/python_env/idf5*_env/bin:$PATH
+export PATH=~/.espressif/python_env/idf5.2*_env/bin:$PATH
 
 cd ~/projects/esp-idf
 source export.sh
diff --git a/ports/esp32/mpthreadport.c b/ports/esp32/mpthreadport.c
index 1d3a627ced0d2..eac1e5ea3668d 100644
--- a/ports/esp32/mpthreadport.c
+++ b/ports/esp32/mpthreadport.c
@@ -222,11 +222,7 @@ void mp_thread_mutex_unlock(mp_thread_mutex_t *mutex) {
     // prevent pathological imbalances where a thread unlocks and then
     // immediately re-locks a mutex before a context switch can occur, leaving
     // another thread waiting for an unbounded period of time.
-#if MICROPY_PY_MACHINE_DISABLE_IRQ_ENABLE_IRQ
-    extern uint32_t g_irq_state;
-    if(g_irq_state==1)
-#endif
-        taskYIELD();
+    taskYIELD();
 }
 
 void mp_thread_deinit(void) {

From 83877c0c434866c8aeabf817959ad488d61f7b71 Mon Sep 17 00:00:00 2001
From: Wang Xuancong <xuancong84@gmail.com>
Date: Tue, 8 Apr 2025 09:12:44 +0800
Subject: [PATCH 50/51] added functions for controlling interrupt masks on
 esp32

---
 ports/esp32/build.sh   |  7 ++++---
 ports/esp32/modesp32.c | 24 ++++++++++++++++++++++++
 ports/esp8266/build.sh |  5 +++--
 3 files changed, 31 insertions(+), 5 deletions(-)

diff --git a/ports/esp32/build.sh b/ports/esp32/build.sh
index 34c12dfd8f634..d601d416717ec 100755
--- a/ports/esp32/build.sh
+++ b/ports/esp32/build.sh
@@ -2,9 +2,10 @@
 
 cd `dirname $(readlink -f "$0")`
 
-export PATH=~/.espressif/python_env/idf5.2*_env/bin:$PATH
+idf_path=`echo ~/.espressif/python_env/idf5.2*_env/bin`
+export PATH=$idf_path:$PATH
 
-cd ~/projects/esp-idf
+cd ~/projects/esp-idf.v5.2.2
 source export.sh
 
 cd -
@@ -13,4 +14,4 @@ if [ ! "$1" ]; then
 	rm -rf build-ESP32_GENERIC_C3
 fi
 
-make BOARD=ESP32_GENERIC_C3 -j4
+make -j4 BOARD=ESP32_GENERIC_C3
diff --git a/ports/esp32/modesp32.c b/ports/esp32/modesp32.c
index 0a73a0faf06ef..8e32b7ae1077f 100644
--- a/ports/esp32/modesp32.c
+++ b/ports/esp32/modesp32.c
@@ -33,6 +33,7 @@
 #include "driver/adc.h"
 #include "esp_heap_caps.h"
 #include "multi_heap.h"
+#include "esp_app_desc.h"
 
 #include "py/nlr.h"
 #include "py/obj.h"
@@ -48,6 +49,25 @@
 #include "../multi_heap_platform.h"
 #include "../heap_private.h"
 
+
+static mp_obj_t esp32_intr_enable_mask(const mp_obj_t mask) {
+    esp_cpu_intr_enable(mp_obj_get_int(mask));
+    return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(esp32_intr_enable_mask_obj, esp32_intr_enable_mask);
+
+static mp_obj_t esp32_intr_disable_mask(const mp_obj_t mask) {
+    esp_cpu_intr_disable(mp_obj_get_int(mask));
+    return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(esp32_intr_disable_mask_obj, esp32_intr_disable_mask);
+
+static mp_obj_t esp32_intr_get_mask(void) {
+    int mask = esp_cpu_intr_get_enabled_mask();
+    return mp_obj_new_int(mask);
+}
+static MP_DEFINE_CONST_FUN_OBJ_0(esp32_intr_get_mask_obj, esp32_intr_get_mask);
+
 static mp_obj_t esp32_wake_on_touch(const mp_obj_t wake) {
 
     if (machine_rtc_config.ext0_pin != -1) {
@@ -242,6 +262,10 @@ static const mp_rom_map_elem_t esp32_module_globals_table[] = {
 
     { MP_ROM_QSTR(MP_QSTR_HEAP_DATA), MP_ROM_INT(MALLOC_CAP_8BIT) },
     { MP_ROM_QSTR(MP_QSTR_HEAP_EXEC), MP_ROM_INT(MALLOC_CAP_EXEC) },
+
+    { MP_ROM_QSTR(MP_QSTR_intr_enable_mask), MP_ROM_PTR(&esp32_intr_enable_mask_obj) },
+    { MP_ROM_QSTR(MP_QSTR_intr_disable_mask), MP_ROM_PTR(&esp32_intr_disable_mask_obj) },
+    { MP_ROM_QSTR(MP_QSTR_intr_get_mask), MP_ROM_PTR(&esp32_intr_get_mask_obj) },
 };
 
 static MP_DEFINE_CONST_DICT(esp32_module_globals, esp32_module_globals_table);
diff --git a/ports/esp8266/build.sh b/ports/esp8266/build.sh
index b86754924a31a..c4629a36ced66 100755
--- a/ports/esp8266/build.sh
+++ b/ports/esp8266/build.sh
@@ -1,10 +1,11 @@
 #!/bin/bash
 
-export PATH=~/.espressif/python_env/idf5.0_py3.11_env/bin:$PATH
+idf_path=`echo ~/.espressif/python_env/idf5.2*_env/bin`
+export PATH=$idf_path:$PATH
 
 if [ ! "$1" ]; then
 	make clean
 fi
 
-make -j BOARD=ESP8266_GENERIC
+make -j4 BOARD=ESP8266_GENERIC
 

From 8b88a14f53bf27f74f761f8e8f386dacc8d843c7 Mon Sep 17 00:00:00 2001
From: Wang Xuancong <xuancong84@gmail.com>
Date: Wed, 9 Apr 2025 11:26:33 +0800
Subject: [PATCH 51/51] added micropython.kbd_intr_enable(bool) to allow
 enable/disable keyboard interrupt on ESP32*

This is useful for ESP32* as it allows STDIO ports to be used as UART ports for interacting with external devices.
mp_hal_set_interrupt_char(int) is supposed to work but does not work because every time when
parse_compile_execute() is called, the intr_char is reset to CHAR_CTRL_C depending on exec_flags.
---
 ports/esp32/uart.c              |  3 ++-
 ports/esp32/usb_serial_jtag.c   |  3 ++-
 py/modmicropython.c             | 11 ++++++++++-
 shared/runtime/interrupt_char.c |  2 +-
 4 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/ports/esp32/uart.c b/ports/esp32/uart.c
index 8336268509ecf..1202d69d32037 100644
--- a/ports/esp32/uart.c
+++ b/ports/esp32/uart.c
@@ -100,6 +100,7 @@ int uart_stdout_tx_strn(const char *str, size_t len) {
 }
 
 // all code executed in ISR must be in IRAM, and any const data must be in DRAM
+extern int mp_kbd_intr_enable;
 static void IRAM_ATTR uart_irq_handler(void *arg) {
     uint8_t rbuf[SOC_UART_FIFO_LEN];
     int len;
@@ -112,7 +113,7 @@ static void IRAM_ATTR uart_irq_handler(void *arg) {
     uart_hal_read_rxfifo(&repl_hal, rbuf, &len);
 
     for (int i = 0; i < len; i++) {
-        if (rbuf[i] == mp_interrupt_char) {
+        if (mp_kbd_intr_enable && rbuf[i] == mp_interrupt_char) {
             mp_sched_keyboard_interrupt();
         } else {
             // this is an inline function so will be in IRAM
diff --git a/ports/esp32/usb_serial_jtag.c b/ports/esp32/usb_serial_jtag.c
index 32eb806e72959..88916d4813599 100644
--- a/ports/esp32/usb_serial_jtag.c
+++ b/ports/esp32/usb_serial_jtag.c
@@ -40,6 +40,7 @@
 static DRAM_ATTR portMUX_TYPE rx_mux = portMUX_INITIALIZER_UNLOCKED;
 static uint8_t rx_buf[USB_SERIAL_JTAG_BUF_SIZE];
 static volatile bool terminal_connected = false;
+extern int mp_kbd_intr_enable;
 
 static void usb_serial_jtag_handle_rx(void) {
     if (xPortInIsrContext()) {
@@ -53,7 +54,7 @@ static void usb_serial_jtag_handle_rx(void) {
     }
     size_t len = usb_serial_jtag_ll_read_rxfifo(rx_buf, req_len);
     for (size_t i = 0; i < len; ++i) {
-        if (rx_buf[i] == mp_interrupt_char) {
+        if (mp_kbd_intr_enable && rx_buf[i] == mp_interrupt_char) {
             mp_sched_keyboard_interrupt();
         } else {
             ringbuf_put(&stdin_ringbuf, rx_buf[i]);
diff --git a/py/modmicropython.c b/py/modmicropython.c
index 1bf0a000c2026..9dba787703efe 100644
--- a/py/modmicropython.c
+++ b/py/modmicropython.c
@@ -149,11 +149,19 @@ static MP_DEFINE_CONST_FUN_OBJ_1(mp_alloc_emergency_exception_buf_obj, mp_alloc_
 #endif
 
 #if MICROPY_KBD_EXCEPTION
+extern int mp_interrupt_char, mp_kbd_intr_enable;
 static mp_obj_t mp_micropython_kbd_intr(mp_obj_t int_chr_in) {
+    int old_intr_char = mp_interrupt_char;
     mp_hal_set_interrupt_char(mp_obj_get_int(int_chr_in));
-    return mp_const_none;
+    return mp_obj_new_int(old_intr_char);
 }
 static MP_DEFINE_CONST_FUN_OBJ_1(mp_micropython_kbd_intr_obj, mp_micropython_kbd_intr);
+
+static mp_obj_t mp_micropython_kbd_intr_enable(mp_obj_t state) {
+    mp_kbd_intr_enable = mp_obj_get_int(state);
+    return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(mp_micropython_kbd_intr_enable_obj, mp_micropython_kbd_intr_enable);
 #endif
 
 #if MICROPY_ENABLE_SCHEDULER
@@ -199,6 +207,7 @@ static const mp_rom_map_elem_t mp_module_micropython_globals_table[] = {
     #endif
     #if MICROPY_KBD_EXCEPTION
     { MP_ROM_QSTR(MP_QSTR_kbd_intr), MP_ROM_PTR(&mp_micropython_kbd_intr_obj) },
+    { MP_ROM_QSTR(MP_QSTR_kbd_intr_enable), MP_ROM_PTR(&mp_micropython_kbd_intr_enable_obj) },
     #endif
     #if MICROPY_PY_MICROPYTHON_RINGIO
     { MP_ROM_QSTR(MP_QSTR_RingIO), MP_ROM_PTR(&mp_type_ringio) },
diff --git a/shared/runtime/interrupt_char.c b/shared/runtime/interrupt_char.c
index 7014ae6a8fc44..ad8b3febacd1d 100644
--- a/shared/runtime/interrupt_char.c
+++ b/shared/runtime/interrupt_char.c
@@ -30,7 +30,7 @@
 #if MICROPY_KBD_EXCEPTION
 
 int mp_interrupt_char = -1;
-
+int mp_kbd_intr_enable = 1;
 void mp_hal_set_interrupt_char(int c) {
     mp_interrupt_char = c;
 }