Stm32 flash layout and access

[mfulz]

I'm trying to take some part from the flash_fs used by an f405 weact board away from the fs.
This is working by modifying the linker but how can I write the flash blocks afterwards?

The issue is that via pyb.Flash it seems that I can only access the blocks that are added to FLASH_FS. I can read the flash blocks by using mem8,16,32 but didn't find out how to write them.

The use behind is that I want to have some blocks of the internal flash that are read out protected and therefore are not allowed to.be part of the USB mass storage and just used internal.

[rkompass]

The USB mass storage has access to a FAT32 formatted filesystem if you allow it by certain settings, e.g. in boot.py.
It is not recommended for use in parallel with use from within MP, because the accesses are not synchronized and this may lead to data corruption.
One solution is to create two or more file systems that share the available flash space. With e.g. only one being a FAT32 system.
This and related problems were discussed quite recently (within last 3-4 weeks iirc.) in this forum. So it should be very productive to search and/or scan for these discussions (perhaps including the closed ones).
I recently made a little contribution that may help with enlarging the available flash space on the Pyboard, btw..
If you do not find relevant and helpful discussions I may look for some and give the links.

[mfulz]

Not sure if you really got my point. It's not about the mass storage. It's about splitting the mass storage into two parts like one which is acting like it is now fat32 fs accessible via USB and another part like two 16KB blocks only via direct flash read write NOT provided over USB so it can be locked with rop and not accessible outside the stm board. I can change the linker file to reduce the fs flash size but I'm unable to write the removed blocks afterwards. If you have some links please share

[rkompass]

Seems like your problem is discussed and solved in the docs here (referring to section Hybrid (STM32).
The recent discussion I thought of was this one. It's for STM32 though.
Note also this older discussion and the last link therein, for a discussion and future plans regarding USB MSC.

The solution in the docs above makes the FAT FS automatically accessible to e.g. Windows/Linux because the FAT FS with all drivers is available there by default.
Given that you may install a LittleFS driver in Linux using the FuseFS AFAICU that would Linux give acces to the second partition too.
Do you want to prevent that by all means, or are you just interested in a working solution with no malevolent behaviour ?

[mfulz]

That's what I saw as well and yes that's exactly the point I want to avoid any access from outside the board for some part of the flash that can be read / written by the board firmware. I would not need a fs on this flash so even raw read write would be a valid way but by using pyb.flash it seems that I can't access flash outside FLASH_FS defined in the linker file

[rkompass]

O.k., I see, or at least have the feeling!
My first idea was to suggest changes to flashbdev.c. This file contains functionality for the flash block device. It therefore evaluates the exported definitions in the linker script, e.g. stm32f405.ld. This way you may hide flash sectors although they are defined.
Then you still would have a problem accessing those sectors. For those you would have to code similar functionality i.e. a block device using the reserved flash sectors and expose it to MP. Complicated...
You may also change higher level code e.g. in storage.c
But the easiest seems to make a little change in the definitions for the USB mass storage.
I found that in stm32/usbdev/class/inc/usbd_cdc_msc_hid.h there is:

// Maximum number of LUN that can be exposed on the MSC interface
#define USBD_MSC_MAX_LUN (2)

I assume setting it to (1) (and testing with a new re-built firmware, of course) while having the first partition in your vfs formatted with FAT as suggested above will limit the exposure by USB MSC mode to this partition only.
This you may (and should) test with e.g. creating two FAT partitions: With USBD_MSC_MAX_LUN == 2 you should see both, with USBD_MSC_MAX_LUN == 1 you should see only the first exposed.
Or you might try the LittleFS via fuseFS approach directly.

[mfulz]

Will try that out later. I've found that flash_fs2 can be used to split the flash which looks fine. But the problem with that is that the MSC is still exporting the whole flash including the fs2 as device which can be read out on Linux using dd ae.

[rkompass]

Interesting! Can you demonstrate that? Do you have some code for this? I would be eager to try and learn it.

You meant you tried that before the change to #define USBD_MSC_MAX_LUN (1) .

[mfulz]

Using that ld file:

/*
    GNU linker script for STM32F405
*/

/* Specify the memory areas */
MEMORY
{
    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 1024K /* entire flash */
    FLASH_START (rx): ORIGIN = 0x08000000, LENGTH = 16K /* sector 0 */
    /* FLASH_FS (rx)   : ORIGIN = 0x08004000, LENGTH = 112K /* sectors 1,2,3,4 are for filesystem */
    FLASH_FS (rx)   : ORIGIN = 0x08004000, LENGTH = 32K /* sectors 1,2 are for data */
    FLASH_INTERNAL_FS (rx)  : ORIGIN = 0x0800C000, LENGTH = 80K /* sectors 3,4 are for filesystem */
    FLASH_TEXT (rx) : ORIGIN = 0x08020000, LENGTH = 896K /* sectors 5,6,7,8,9,10,11 */
    CCMRAM (xrw)    : ORIGIN = 0x10000000, LENGTH = 64K
    RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 128K
}

/* produce a link error if there is not this amount of RAM for these sections */
_minimum_stack_size = 2K;
_minimum_heap_size = 16K;

/* Define the stack.  The stack is full descending so begins just above last byte
   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
_sstack = _estack - 16K; /* tunable */

/* RAM extents for the garbage collector */
_ram_start = ORIGIN(RAM);
_ram_end = ORIGIN(RAM) + LENGTH(RAM);
_heap_start = _ebss; /* heap starts just after statically allocated memory */
_heap_end = _sstack;

/* Filesystem cache in RAM, and storage in flash */
_micropy_hw_internal_flash_storage_ram_cache_start = ORIGIN(CCMRAM);
_micropy_hw_internal_flash_storage_ram_cache_end = ORIGIN(CCMRAM) + LENGTH(CCMRAM);
_micropy_hw_internal_flash_storage_start = ORIGIN(FLASH_FS);
_micropy_hw_internal_flash_storage_end = ORIGIN(FLASH_FS) + LENGTH(FLASH_FS);
_micropy_hw_internal_flash_storage2_start = ORIGIN(FLASH_INTERNAL_FS);
_micropy_hw_internal_flash_storage2_end = ORIGIN(FLASH_INTERNAL_FS) + LENGTH(FLASH_INTERNAL_FS);

And adding to the mpconfigboard.h:
MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE_SEGMENT2 (1)

Here you can see in gparted (or other tools) that the block dev has a size of 240KiB

(not sure about the reported size as the flash is only 112KiB) but you can dump the whole flash defined as storage by doing:
dd if=/dev/sdb of=anyfile

That is the same independent from your suggestion of changing MAX_LUN.

But I've done a quick and dirty patch that will remove storage from the msc and still keep it available via using pyb.Flash:

diff --color -Nu micropython_orig/ports/stm32/flashbdev.c micropython/ports/stm32/flashbdev.c
--- micropython_orig/ports/stm32/flashbdev.c    2025-02-02 01:42:51.886991773 +0100
+++ micropython/ports/stm32/flashbdev.c 2025-02-02 00:50:24.995026743 +0100
@@ -41,6 +41,8 @@
 extern uint8_t _micropy_hw_internal_flash_storage_end;
 extern uint8_t _micropy_hw_internal_flash_storage2_start;
 extern uint8_t _micropy_hw_internal_flash_storage2_end;
+extern uint8_t _micropy_hw_internal_flash_internal_storage_start;
+extern uint8_t _micropy_hw_internal_flash_internal_storage_end;
 extern uint8_t _micropy_hw_internal_flash_storage_ram_cache_start[];
 extern uint8_t _micropy_hw_internal_flash_storage_ram_cache_end[];

@@ -60,10 +62,22 @@
     ((&_micropy_hw_internal_flash_storage2_end - &_micropy_hw_internal_flash_storage2_start) / 512)
 #endif

+#if MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE_INTERNAL
+#define FLASH_MEM_IS_START_ADDR \
+    ((long)&_micropy_hw_internal_flash_internal_storage_start)
+#define FLASH_MEM_IS_NUM_BLOCKS \
+    ((&_micropy_hw_internal_flash_internal_storage_end - &_micropy_hw_internal_flash_internal_storage_start) / 512)
+#endif
+
 #if !defined(FLASH_MEM_SEG2_START_ADDR)
 #define FLASH_MEM_SEG2_NUM_BLOCKS (0) // no second segment
 #endif

+#if !defined(FLASH_MEM_IS_START_ADDR)
+#define FLASH_MEM_IS_NUM_BLOCKS (0) // no second segment
+#endif
+
+
 #define FLASH_FLAG_DIRTY        (1)
 #define FLASH_FLAG_FORCE_WRITE  (2)
 #define FLASH_FLAG_ERASED       (4)
@@ -85,6 +99,10 @@

         case BDEV_IOCTL_NUM_BLOCKS:
             // Units are FLASH_BLOCK_SIZE
+            return FLASH_MEM_SEG1_NUM_BLOCKS + FLASH_MEM_SEG2_NUM_BLOCKS + FLASH_MEM_IS_NUM_BLOCKS;
+
+        case BDEV_IOCTL_NUM_BLOCKS_EXPORTED:
+            // Units are FLASH_BLOCK_SIZE
             return FLASH_MEM_SEG1_NUM_BLOCKS + FLASH_MEM_SEG2_NUM_BLOCKS;

         case BDEV_IOCTL_IRQ_HANDLER:
@@ -146,12 +164,34 @@
         return FLASH_MEM_SEG2_START_ADDR + (block - FLASH_MEM_SEG1_NUM_BLOCKS) * FLASH_BLOCK_SIZE;
     }
     #endif
+
+    #ifdef FLASH_MEM_IS_START_ADDR
+    if (block < FLASH_MEM_SEG1_NUM_BLOCKS + FLASH_MEM_SEG2_NUM_BLOCKS + FLASH_MEM_IS_NUM_BLOCKS) {
+        return FLASH_MEM_IS_START_ADDR + (block - FLASH_MEM_SEG1_NUM_BLOCKS - FLASH_MEM_SEG2_NUM_BLOCKS) * FLASH_BLOCK_SIZE;
+    }
+    #endif
+    // can add more flash segments here if needed, following above pattern
+
+    // bad block
+    return -1;
+}
+
+static uint32_t convert_block_to_flash_addr_exported(uint32_t block) {
+    if (block < FLASH_MEM_SEG1_NUM_BLOCKS) {
+        return FLASH_MEM_SEG1_START_ADDR + block * FLASH_BLOCK_SIZE;
+    }
+    #ifdef FLASH_MEM_SEG2_START_ADDR
+    if (block < FLASH_MEM_SEG1_NUM_BLOCKS + FLASH_MEM_SEG2_NUM_BLOCKS) {
+        return FLASH_MEM_SEG2_START_ADDR + (block - FLASH_MEM_SEG1_NUM_BLOCKS) * FLASH_BLOCK_SIZE;
+    }
+    #endif
     // can add more flash segments here if needed, following above pattern

     // bad block
     return -1;
 }

+
 static void flash_bdev_irq_handler(void) {
     if (!(flash_flags & FLASH_FLAG_DIRTY)) {
         return;
@@ -194,6 +234,32 @@
     if (flash_addr == -1) {
         // bad block number
         return false;
+    }
+    uint32_t basepri = raise_irq_pri(IRQ_PRI_FLASH); // prevent cache flushing and USB access
+    uint8_t *dest = flash_cache_get_addr_for_write(flash_addr);
+    memcpy(dest, src, FLASH_BLOCK_SIZE);
+    restore_irq_pri(basepri);
+    return true;
+}
+
+bool flash_bdev_readblock_exported(uint8_t *dest, uint32_t block) {
+    // non-MBR block, get data from flash memory, possibly via cache
+    uint32_t flash_addr = convert_block_to_flash_addr_exported(block);
+    if (flash_addr == -1) {
+        // bad block number
+        return false;
+    }
+    uint8_t *src = flash_cache_get_addr_for_read(flash_addr);
+    memcpy(dest, src, FLASH_BLOCK_SIZE);
+    return true;
+}
+
+bool flash_bdev_writeblock_exported(const uint8_t *src, uint32_t block) {
+    // non-MBR block, copy to cache
+    uint32_t flash_addr = convert_block_to_flash_addr_exported(block);
+    if (flash_addr == -1) {
+        // bad block number
+        return false;
     }
     uint32_t basepri = raise_irq_pri(IRQ_PRI_FLASH); // prevent cache flushing and USB access
     uint8_t *dest = flash_cache_get_addr_for_write(flash_addr);
Common subdirectories: micropython_orig/ports/stm32/lwip_inc and micropython/ports/stm32/lwip_inc
Common subdirectories: micropython_orig/ports/stm32/mbedtls and micropython/ports/stm32/mbedtls
Common subdirectories: micropython_orig/ports/stm32/mboot and micropython/ports/stm32/mboot
Common subdirectories: micropython_orig/ports/stm32/modules and micropython/ports/stm32/modules
diff --color -Nu micropython_orig/ports/stm32/mpconfigboard_common.h micropython/ports/stm32/mpconfigboard_common.h
--- micropython_orig/ports/stm32/mpconfigboard_common.h 2025-02-02 01:42:51.890325140 +0100
+++ micropython/ports/stm32/mpconfigboard_common.h      2025-02-02 00:51:25.898960628 +0100
@@ -556,6 +556,8 @@
 #define MICROPY_HW_BDEV_IOCTL flash_bdev_ioctl
 #define MICROPY_HW_BDEV_READBLOCK flash_bdev_readblock
 #define MICROPY_HW_BDEV_WRITEBLOCK flash_bdev_writeblock
+#define MICROPY_HW_BDEV_READBLOCK_EXPORTED flash_bdev_readblock_exported
+#define MICROPY_HW_BDEV_WRITEBLOCK_EXPORTED flash_bdev_writeblock_exported
 #endif

 #if defined(MICROPY_HW_BDEV_SPIFLASH)
diff --color -Nu micropython_orig/ports/stm32/storage.c micropython/ports/stm32/storage.c
--- micropython_orig/ports/stm32/storage.c      2025-02-02 01:42:51.893658509 +0100
+++ micropython/ports/stm32/storage.c   2025-02-02 00:54:42.587567094 +0100
@@ -77,6 +77,15 @@
     #endif
 }

+uint32_t storage_get_block_count_exported(void) {
+    #if defined(MICROPY_HW_BDEV2_IOCTL)
+    return FLASH_PART2_START_BLOCK + MICROPY_HW_BDEV2_IOCTL(BDEV_IOCTL_NUM_BLOCKS, 0);
+    #else
+    return FLASH_PART1_START_BLOCK + MICROPY_HW_BDEV_IOCTL(BDEV_IOCTL_NUM_BLOCKS_EXPORTED, 0);
+    #endif
+}
+
+
 static void storage_systick_callback(uint32_t ticks_ms) {
     if (STORAGE_IDLE_TICK(ticks_ms)) {
         // Trigger a FLASH IRQ to execute at a lower priority
@@ -184,6 +193,51 @@
     }
 }

+bool storage_read_block_exported(uint8_t *dest, uint32_t block) {
+    if (block == 0) {
+        // fake the MBR so we can decide on our own partition table
+
+        for (int i = 0; i < 446; i++) {
+            dest[i] = 0;
+        }
+
+        build_partition(dest + 446, 0, 0x01 /* FAT12 */, FLASH_PART1_START_BLOCK, MICROPY_HW_BDEV_IOCTL(BDEV_IOCTL_NUM_BLOCKS_EXPORTED, 0));
+        #if defined(MICROPY_HW_BDEV2_IOCTL)
+        build_partition(dest + 462, 0, 0x01 /* FAT12 */, FLASH_PART2_START_BLOCK, MICROPY_HW_BDEV2_IOCTL(BDEV_IOCTL_NUM_BLOCKS, 0));
+        #else
+        build_partition(dest + 462, 0, 0, 0, 0);
+        #endif
+        build_partition(dest + 478, 0, 0, 0, 0);
+        build_partition(dest + 494, 0, 0, 0, 0);
+
+        dest[510] = 0x55;
+        dest[511] = 0xaa;
+
+        return true;
+
+    #if defined(MICROPY_HW_BDEV_READBLOCK_EXPORTED)
+    } else if (FLASH_PART1_START_BLOCK <= block && block < FLASH_PART1_START_BLOCK + MICROPY_HW_BDEV_IOCTL(BDEV_IOCTL_NUM_BLOCKS_EXPORTED, 0)) {
+        return MICROPY_HW_BDEV_READBLOCK_EXPORTED(dest, block - FLASH_PART1_START_BLOCK);
+    #endif
+    } else {
+        return false;
+    }
+}
+
+bool storage_write_block_exported(const uint8_t *src, uint32_t block) {
+    if (block == 0) {
+        // can't write MBR, but pretend we did
+        return true;
+    #if defined(MICROPY_HW_BDEV_WRITEBLOCK_EXPORTED)
+    } else if (FLASH_PART1_START_BLOCK <= block && block < FLASH_PART1_START_BLOCK + MICROPY_HW_BDEV_IOCTL(BDEV_IOCTL_NUM_BLOCKS_EXPORTED, 0)) {
+        return MICROPY_HW_BDEV_WRITEBLOCK_EXPORTED(src, block - FLASH_PART1_START_BLOCK);
+    #endif
+    } else {
+        return false;
+    }
+}
+
+
 int storage_read_blocks(uint8_t *dest, uint32_t block_num, uint32_t num_blocks) {
     #if defined(MICROPY_HW_BDEV_READBLOCKS)
     if (FLASH_PART1_START_BLOCK <= block_num && block_num + num_blocks <= FLASH_PART1_START_BLOCK + MICROPY_HW_BDEV_IOCTL(BDEV_IOCTL_NUM_BLOCKS, 0)) {
@@ -226,6 +280,48 @@
     return 0; // success
 }

+int storage_read_blocks_exported(uint8_t *dest, uint32_t block_num, uint32_t num_blocks) {
+    #if defined(MICROPY_HW_BDEV_READBLOCKS)
+    if (FLASH_PART1_START_BLOCK <= block_num && block_num + num_blocks <= FLASH_PART1_START_BLOCK + MICROPY_HW_BDEV_IOCTL(BDEV_IOCTL_NUM_BLOCKS, 0)) {
+        return MICROPY_HW_BDEV_READBLOCKS(dest, block_num - FLASH_PART1_START_BLOCK, num_blocks);
+    }
+    #endif
+
+    #if defined(MICROPY_HW_BDEV2_READBLOCKS)
+    if (FLASH_PART2_START_BLOCK <= block_num && block_num + num_blocks <= FLASH_PART2_START_BLOCK + MICROPY_HW_BDEV2_IOCTL(BDEV_IOCTL_NUM_BLOCKS, 0)) {
+        return MICROPY_HW_BDEV2_READBLOCKS(dest, block_num - FLASH_PART2_START_BLOCK, num_blocks);
+    }
+    #endif
+
+    for (size_t i = 0; i < num_blocks; i++) {
+        if (!storage_read_block_exported(dest + i * FLASH_BLOCK_SIZE, block_num + i)) {
+            return -MP_EIO; // error
+        }
+    }
+    return 0; // success
+}
+
+int storage_write_blocks_exported(const uint8_t *src, uint32_t block_num, uint32_t num_blocks) {
+    #if defined(MICROPY_HW_BDEV_WRITEBLOCKS)
+    if (FLASH_PART1_START_BLOCK <= block_num && block_num + num_blocks <= FLASH_PART1_START_BLOCK + MICROPY_HW_BDEV_IOCTL(BDEV_IOCTL_NUM_BLOCKS, 0)) {
+        return MICROPY_HW_BDEV_WRITEBLOCKS(src, block_num - FLASH_PART1_START_BLOCK, num_blocks);
+    }
+    #endif
+
+    #if defined(MICROPY_HW_BDEV2_WRITEBLOCKS)
+    if (FLASH_PART2_START_BLOCK <= block_num && block_num + num_blocks <= FLASH_PART2_START_BLOCK + MICROPY_HW_BDEV2_IOCTL(BDEV_IOCTL_NUM_BLOCKS, 0)) {
+        return MICROPY_HW_BDEV2_WRITEBLOCKS(src, block_num - FLASH_PART2_START_BLOCK, num_blocks);
+    }
+    #endif
+
+    for (size_t i = 0; i < num_blocks; i++) {
+        if (!storage_write_block_exported(src + i * FLASH_BLOCK_SIZE, block_num + i)) {
+            return -MP_EIO; // error
+        }
+    }
+    return 0; // success
+}
+
 /******************************************************************************/
 // MicroPython bindings
 //
@@ -349,6 +445,34 @@
 }
 static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_flash_readblocks_obj, 3, 4, pyb_flash_readblocks);

+static mp_obj_t pyb_flash_readblocks_exported(size_t n_args, const mp_obj_t *args) {
+    pyb_flash_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    uint32_t block_num = mp_obj_get_int(args[1]);
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_WRITE);
+    mp_uint_t ret = -MP_EIO;
+    if (n_args == 3) {
+        // Cast self->start to signed in case it's pyb_flash_obj with negative start
+        block_num += FLASH_PART1_START_BLOCK + (int32_t)self->start / FLASH_BLOCK_SIZE;
+        ret = storage_read_blocks_exported(bufinfo.buf, block_num, bufinfo.len / FLASH_BLOCK_SIZE);
+    }
+    #if defined(MICROPY_HW_BDEV_READBLOCKS_EXT)
+    else if (self != &pyb_flash_obj) {
+        // Extended block read on a sub-section of the flash storage
+        uint32_t offset = mp_obj_get_int(args[3]);
+        if ((block_num * MICROPY_HW_BDEV_BLOCKSIZE_EXT) >= self->len) {
+            ret = -MP_EFAULT; // Bad address
+        } else {
+            block_num += self->start / MICROPY_HW_BDEV_BLOCKSIZE_EXT;
+            ret = MICROPY_HW_BDEV_READBLOCKS_EXT(bufinfo.buf, block_num, offset, bufinfo.len);
+        }
+    }
+    #endif
+    return MP_OBJ_NEW_SMALL_INT(ret);
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_flash_readblocks_exported_obj, 3, 4, pyb_flash_readblocks_exported);
+
+
 static mp_obj_t pyb_flash_writeblocks(size_t n_args, const mp_obj_t *args) {
     pyb_flash_obj_t *self = MP_OBJ_TO_PTR(args[0]);
     uint32_t block_num = mp_obj_get_int(args[1]);
@@ -376,6 +500,34 @@
 }
 static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_flash_writeblocks_obj, 3, 4, pyb_flash_writeblocks);

+static mp_obj_t pyb_flash_writeblocks_exported(size_t n_args, const mp_obj_t *args) {
+    pyb_flash_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    uint32_t block_num = mp_obj_get_int(args[1]);
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_READ);
+    mp_uint_t ret = -MP_EIO;
+    if (n_args == 3) {
+        // Cast self->start to signed in case it's pyb_flash_obj with negative start
+        block_num += FLASH_PART1_START_BLOCK + (int32_t)self->start / FLASH_BLOCK_SIZE;
+        ret = storage_write_blocks_exported(bufinfo.buf, block_num, bufinfo.len / FLASH_BLOCK_SIZE);
+    }
+    #if defined(MICROPY_HW_BDEV_WRITEBLOCKS_EXT)
+    else if (self != &pyb_flash_obj) {
+        // Extended block write on a sub-section of the flash storage
+        uint32_t offset = mp_obj_get_int(args[3]);
+        if ((block_num * MICROPY_HW_BDEV_BLOCKSIZE_EXT) >= self->len) {
+            ret = -MP_EFAULT; // Bad address
+        } else {
+            block_num += self->start / MICROPY_HW_BDEV_BLOCKSIZE_EXT;
+            ret = MICROPY_HW_BDEV_WRITEBLOCKS_EXT(bufinfo.buf, block_num, offset, bufinfo.len);
+        }
+    }
+    #endif
+    return MP_OBJ_NEW_SMALL_INT(ret);
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_flash_writeblocks_exported_obj, 3, 4, pyb_flash_writeblocks_exported);
+
+
 static mp_obj_t pyb_flash_ioctl(mp_obj_t self_in, mp_obj_t cmd_in, mp_obj_t arg_in) {
     pyb_flash_obj_t *self = MP_OBJ_TO_PTR(self_in);
     mp_int_t cmd = mp_obj_get_int(cmd_in);
@@ -464,12 +616,12 @@
     #if MICROPY_FATFS_MULTI_PARTITION
     vfs->fatfs.part = 1; // flash filesystem lives on first partition
     #endif
-    vfs->blockdev.readblocks[0] = MP_OBJ_FROM_PTR(&pyb_flash_readblocks_obj);
+    vfs->blockdev.readblocks[0] = MP_OBJ_FROM_PTR(&pyb_flash_readblocks_exported_obj);
     vfs->blockdev.readblocks[1] = MP_OBJ_FROM_PTR(&pyb_flash_obj);
-    vfs->blockdev.readblocks[2] = MP_OBJ_FROM_PTR(storage_read_blocks); // native version
-    vfs->blockdev.writeblocks[0] = MP_OBJ_FROM_PTR(&pyb_flash_writeblocks_obj);
+    vfs->blockdev.readblocks[2] = MP_OBJ_FROM_PTR(storage_read_blocks_exported); // native version
+    vfs->blockdev.writeblocks[0] = MP_OBJ_FROM_PTR(&pyb_flash_writeblocks_exported_obj);
     vfs->blockdev.writeblocks[1] = MP_OBJ_FROM_PTR(&pyb_flash_obj);
-    vfs->blockdev.writeblocks[2] = MP_OBJ_FROM_PTR(storage_write_blocks); // native version
+    vfs->blockdev.writeblocks[2] = MP_OBJ_FROM_PTR(storage_write_blocks_exported); // native version
     vfs->blockdev.u.ioctl[0] = MP_OBJ_FROM_PTR(&pyb_flash_ioctl_obj);
     vfs->blockdev.u.ioctl[1] = MP_OBJ_FROM_PTR(&pyb_flash_obj);
 }
diff --color -Nu micropython_orig/ports/stm32/storage.h micropython/ports/stm32/storage.h
--- micropython_orig/ports/stm32/storage.h      2025-02-02 01:42:51.893658509 +0100
+++ micropython/ports/stm32/storage.h   2025-02-02 00:55:30.724708588 +0100
@@ -36,6 +36,7 @@
     BDEV_IOCTL_INIT = 1,
     BDEV_IOCTL_SYNC = 3,
     BDEV_IOCTL_NUM_BLOCKS = 4, // units are FLASH_BLOCK_SIZE
+    BDEV_IOCTL_NUM_BLOCKS_EXPORTED = 5, // units are FLASH_BLOCK_SIZE
     BDEV_IOCTL_IRQ_HANDLER = 7,
 };

@@ -51,12 +52,22 @@
 int storage_write_blocks(const uint8_t *src, uint32_t block_num, uint32_t num_blocks);
 int storage_readblocks_ext(uint8_t *dest, uint32_t block, uint32_t offset, uint32_t len);

+// internal flash
+uint32_t storage_get_block_count_exported(void);
+bool storage_read_block_exported(uint8_t *dest, uint32_t block);
+bool storage_write_block_exported(const uint8_t *src, uint32_t block);
+int storage_read_blocks_exported(uint8_t *dest, uint32_t block_num, uint32_t num_blocks);
+int storage_write_blocks_exported(const uint8_t *src, uint32_t block_num, uint32_t num_blocks);
+
 int32_t flash_bdev_ioctl(uint32_t op, uint32_t arg);
 bool flash_bdev_readblock(uint8_t *dest, uint32_t block);
 bool flash_bdev_writeblock(const uint8_t *src, uint32_t block);
 int flash_bdev_readblocks_ext(uint8_t *dest, uint32_t block, uint32_t offset, uint32_t len);
 int flash_bdev_writeblocks_ext(const uint8_t *src, uint32_t block, uint32_t offset, uint32_t len);

+bool flash_bdev_readblock_exported(uint8_t *dest, uint32_t block);
+bool flash_bdev_writeblock_exported(const uint8_t *src, uint32_t block);
+
 typedef struct _spi_bdev_t {
     mp_spiflash_t spiflash;
     uint32_t flash_tick_counter_last_write;
Common subdirectories: micropython_orig/ports/stm32/usbdev and micropython/ports/stm32/usbdev
diff --color -Nu micropython_orig/ports/stm32/usbd_msc_interface.c micropython/ports/stm32/usbd_msc_interface.c
--- micropython_orig/ports/stm32/usbd_msc_interface.c   2025-02-02 01:42:51.893658509 +0100
+++ micropython/ports/stm32/usbd_msc_interface.c        2025-02-02 00:01:35.837088261 +0100
@@ -129,7 +129,7 @@
                 *data = storage_get_block_size();
                 return 0;
             case MP_BLOCKDEV_IOCTL_BLOCK_COUNT:
-                *data = storage_get_block_count();
+                *data = storage_get_block_count_exported();
                 return 0;
             default:
                 return -1;
@@ -288,7 +288,7 @@
     const void *lu = usbd_msc_lu_data[lun];

     if (lu == &pyb_flash_type) {
-        storage_read_blocks(buf, blk_addr, blk_len);
+        storage_read_blocks_exported(buf, blk_addr, blk_len);
         return 0;
     #if MICROPY_HW_ENABLE_SDCARD
     } else if (lu == &pyb_sdcard_type
@@ -312,7 +312,7 @@
     const void *lu = usbd_msc_lu_data[lun];

     if (lu == &pyb_flash_type) {
-        storage_write_blocks(buf, blk_addr, blk_len);
+        storage_write_blocks_exported(buf, blk_addr, blk_len);
         return 0;
     #if MICROPY_HW_ENABLE_SDCARD
     } else if (lu == &pyb_sdcard_type
Common subdirectories: micropython_orig/ports/stm32/usbhost and micropython/ports/stm32/usbhost

using this ld:

/*
    GNU linker script for STM32F405
*/

/* Specify the memory areas */
MEMORY
{
    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 1024K /* entire flash */
    FLASH_START (rx): ORIGIN = 0x08000000, LENGTH = 16K /* sector 0 */
    /* FLASH_FS (rx)   : ORIGIN = 0x08004000, LENGTH = 112K /* sectors 1,2,3,4 are for filesystem */
    FLASH_FS (rx)   : ORIGIN = 0x08004000, LENGTH = 32K /* sectors 1,2 are for data */
    FLASH_INTERNAL_FS (rx)  : ORIGIN = 0x0800C000, LENGTH = 80K /* sectors 3,4 are for filesystem */
    FLASH_TEXT (rx) : ORIGIN = 0x08020000, LENGTH = 896K /* sectors 5,6,7,8,9,10,11 */
    CCMRAM (xrw)    : ORIGIN = 0x10000000, LENGTH = 64K
    RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 128K
}

/* produce a link error if there is not this amount of RAM for these sections */
_minimum_stack_size = 2K;
_minimum_heap_size = 16K;

/* Define the stack.  The stack is full descending so begins just above last byte
   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
_sstack = _estack - 16K; /* tunable */

/* RAM extents for the garbage collector */
_ram_start = ORIGIN(RAM);
_ram_end = ORIGIN(RAM) + LENGTH(RAM);
_heap_start = _ebss; /* heap starts just after statically allocated memory */
_heap_end = _sstack;

/* Filesystem cache in RAM, and storage in flash */
_micropy_hw_internal_flash_storage_ram_cache_start = ORIGIN(CCMRAM);
_micropy_hw_internal_flash_storage_ram_cache_end = ORIGIN(CCMRAM) + LENGTH(CCMRAM);
_micropy_hw_internal_flash_storage_start = ORIGIN(FLASH_FS);
_micropy_hw_internal_flash_storage_end = ORIGIN(FLASH_FS) + LENGTH(FLASH_FS);
_micropy_hw_internal_flash_internal_storage_start = ORIGIN(FLASH_INTERNAL_FS);
_micropy_hw_internal_flash_internal_storage_end = ORIGIN(FLASH_INTERNAL_FS) + LENGTH(FLASH_INTERNAL_FS);

and adding to mpconfigboard.h:
#define MICROPY_HW_FLASH_INTERNAL_STORAGE_INTERNAL (1)

Is working and will not provide the internal flash blocks via msc.

[mfulz]

OK for now disabling MSC is fine for my situation.
But still is there any way to write flash raw like reading with stm.mem?

[rkompass]

I just answered.
Directly writing flash is not possible, because you have to cache it. Otherwise you may just program unwritten parts of a sector once. Changing the written data would not be possible. With flash iirc. in general you may just write 0 bits. Writing 1 bits requires erasing the whole sector. This is the reason cacheing of a whole sector is necessary. Because with the pyboard sectors have sizes of up to 64 kB (and perhaps even 128 kB) a large cache is necessary. On the pyboard MP dedicates 64 kB of the scarce 192 kB of RAM for this.

Still, to have direct access to flash programming routines might be of use in certain situations. If you just want to have a safe way of writing some protocol data for example. So it may make sense to expose this functionality for direct MP access. I do not know of any such approaches, however. Perhaps some of the experts have code for this??

[rkompass]

An idea how to do it:
The w60x port has in it's w600 module flash read, write and erase functions for MP. They direct the requests to functions of the SDK like tls_fls_write().
You may copy and adapt the code to take the functions in stm32/flash.c instead. There is flash_write() and flash_erase(). For reading I suppose it suffices to read from the respective memory address.

[mfulz]

I did a hacky poc (see above) that is working so far and vfs can be used with that one. Will try to clean it up and perhaps a PR would be merged.