mimxrt: Add a simple mimxrt.usb_mode() method.

robert-hh · robert-hh · commit 43f8baedeabe · 2022-06-26T21:57:46.000+02:00
To enble/disable MSC at boot time. The calls are a simplified version
if pyb.usb_mode():

mimxrt.usb_mode(modestr)

with modestr being either "vcp" or "vcp+msc".

The call has to be placed in boot.py and requires a hard reset to get
effective, since tusb_init() is executed only once after reset.
diff --git a/docs/mimxrt/quickref.rst b/docs/mimxrt/quickref.rst
@@ -537,6 +537,36 @@ port and LAN(1) for the 1G port.
 
 For details of the network interface refer to the class :ref:`network.LAN <network.LAN>`.
 
+
+External drive mode
+-------------------
+
+On some boards a mode is enabled, that mounts the board's internal file system as
+external USB drive, called MSC support. Data of that drive can be accessed and changed by the PC.
+In that state, access to the internal drive by the MicroPython is limited to
+readonly mode, avoiding file corruption. Changes made by the PC to the file system may not be visible
+at the board until the drive is ejected by the PC or a soft reset of the board
+is made.
+
+To enable write access to by the board, eject the drive at the PC **and** perform
+a soft-reset on the board, either by pushing Ctrl-D at REPL or calling machine.soft_reset().
+
+The external drive mode can be enabled of disabled by calling mimxrt.usb_mode(). Examples::
+
+    # disable MSC support
+    import mimxrt
+    mimxrt.usb_mode("vcp")
+
+::
+    
+    # enable MSC support
+    import mimxrt
+    mimxrt.usb_mode("vcp+msc") # enable VCP and MSC support
+
+These command must be placed into boot.py. They get effective after the next hard reset or
+power cycle.
+
+
 Transferring files
 ------------------
 
diff --git a/ports/mimxrt/main.c b/ports/mimxrt/main.c
@@ -85,16 +85,15 @@ int main(void) {
         // Execute _boot.py to set up the filesystem.
         pyexec_frozen_module("_boot.py");
 
-        // deferred tusb_init allowing a fs to be created before MSC access
-        if (!tusb_inited()) {
-            tusb_init();
-        }
-
         // Execute user scripts.
         int ret = pyexec_file_if_exists("boot.py");
         if (ret & PYEXEC_FORCED_EXIT) {
             goto soft_reset_exit;
         }
+
+        // deferred tusb_init allowing a fs to be created before MSC access
+        tusb_init();
+
         // Do not execute main.py if boot.py failed
         if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL && ret != 0) {
             ret = pyexec_file_if_exists("main.py");
diff --git a/ports/mimxrt/modmimxrt.c b/ports/mimxrt/modmimxrt.c
@@ -29,12 +29,35 @@
 #include "drivers/dht/dht.h"
 #include "modmimxrt.h"
 
+#if MICROPY_HW_USB_MSC
+
+#define USB_MODE_VCP        "vcp"
+#define USB_MODE_VCP_MSC    "vcp+msc"
+
+extern void set_msc_enabled(bool state);
+
+STATIC mp_obj_t mimxrt_usb_mode(mp_obj_t mode_in) {
+    size_t slen;
+    const char *s = mp_obj_str_get_data(mode_in, &slen);
+    if (strncmp(s, USB_MODE_VCP, slen) == 0) {
+        set_msc_enabled(false);
+    } else if (strncmp(s, USB_MODE_VCP_MSC, slen) == 0) {
+        set_msc_enabled(true);
+    } else {
+        mp_raise_ValueError("Invalid usb_mode");
+    }
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_1(mimxrt_usb_mode_obj, mimxrt_usb_mode);
+#endif
+
 STATIC const mp_rom_map_elem_t mimxrt_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__),            MP_ROM_QSTR(MP_QSTR_mimxrt) },
     { MP_ROM_QSTR(MP_QSTR_Flash),               MP_ROM_PTR(&mimxrt_flash_type) },
 
-    { MP_ROM_QSTR(MP_QSTR_dht_readinto), MP_ROM_PTR(&dht_readinto_obj) },
+    { MP_ROM_QSTR(MP_QSTR_dht_readinto),        MP_ROM_PTR(&dht_readinto_obj) },
     #if MICROPY_HW_USB_MSC
+    { MP_ROM_QSTR(MP_QSTR_usb_mode),            MP_ROM_PTR(&mimxrt_usb_mode_obj) },
     { MP_ROM_QSTR(MP_QSTR_MSC),                 MP_ROM_INT(1) },
     #endif
 };
diff --git a/ports/mimxrt/modules/_boot.py b/ports/mimxrt/modules/_boot.py
@@ -25,28 +25,27 @@ def fs_type(bdev):
 
 bdev = mimxrt.Flash()
 
-# In case of MSC support mount as FAT
-# Create a FAT FS if needed
-if hasattr(mimxrt, "MSC"):
+# try to mount the fs accorfing to the boot sector
+# if that fails, (re-)create it with a preference for FAT on
+# boards with MSC support.
+fs = fs_type(bdev)
+
+if fs == FS_FAT or (fs == FS_UNDEF and hasattr(mimxrt, "MSC")):
     try:
         vfs = os.VfsFat(bdev)
         os.mount(vfs, "/flash")
     except:
         os.VfsFat.mkfs(bdev)
         vfs = os.VfsFat(bdev)
         os.mount(vfs, "/flash")
-# otherwise analyze the boot sector an mount accordingly
-# without a valid boot sector create a LFS file system
 else:
-    fs = fs_type(bdev)
-    if fs == FS_LITTLEFS:
+    try:
         vfs = os.VfsLfs2(bdev, progsize=256)
-    elif fs == FS_FAT:
-        vfs = os.VfsFat(bdev)
-    else:
+        os.mount(vfs, "/flash")
+    except:
         os.VfsLfs2.mkfs(bdev, progsize=256)
         vfs = os.VfsLfs2(bdev, progsize=256)
-    os.mount(vfs, "/flash")
+        os.mount(vfs, "/flash")
 
 os.chdir("/flash")
 sys.path.append("/flash")
diff --git a/ports/mimxrt/msc_disk.c b/ports/mimxrt/msc_disk.c
@@ -36,23 +36,31 @@
 
 uint8_t tud_msc_state = EJECTED;
 
+static bool msc_enabled = false;
+
 void update_msc_state(void) {
     if (tud_msc_state == TRANSIT) {
         tud_msc_state = EJECTED;
     }
 }
 
+void set_msc_enabled(bool state) {
+    msc_enabled = state;
+}
+
 // Invoked when received SCSI_CMD_INQUIRY
 // Application fill vendor id, product id and revision with string up to 8, 16, 4 characters respectively
 void tud_msc_inquiry_cb(uint8_t lun, uint8_t vendor_id[8], uint8_t product_id[16], uint8_t product_rev[4]) {
-    const char vid[] = "Micropy";
-    const char pid[] = "Mass Storage";
-    const char rev[] = "1.0";
+    if (msc_enabled) {
+        const char vid[] = "Micropy";
+        const char pid[] = "Mass Storage";
+        const char rev[] = "1.0";
 
-    strncpy((char *)vendor_id,   vid, 8);
-    strncpy((char *)product_id,  pid, 16);
-    strncpy((char *)product_rev, rev, 4);
-    tud_msc_state = MOUNTED;
+        strncpy((char *)vendor_id,   vid, 8);
+        strncpy((char *)product_id,  pid, 16);
+        strncpy((char *)product_rev, rev, 4);
+        tud_msc_state = MOUNTED;
+    }
 }
 
 // Invoked when received Test Unit Ready command.
@@ -68,15 +76,17 @@ bool tud_msc_test_unit_ready_cb(uint8_t lun) {
 // Invoked when received SCSI_CMD_READ_CAPACITY_10 and SCSI_CMD_READ_FORMAT_CAPACITY to determine the disk size
 // Application update block count and block size
 void tud_msc_capacity_cb(uint8_t lun, uint32_t *block_count, uint16_t *block_size) {
-    *block_size = BLOCK_SIZE;
-    *block_count = BLOCK_COUNT;
+    if (msc_enabled) {
+        *block_size = BLOCK_SIZE;
+        *block_count = BLOCK_COUNT;
+    }
 }
 
 // Invoked when received Start Stop Unit command
 // - Start = 0 : stopped power mode, if load_eject = 1 : unload disk storage
 // - Start = 1 : active mode, if load_eject = 1 : load disk storage
 bool tud_msc_start_stop_cb(uint8_t lun, uint8_t power_condition, bool start, bool load_eject) {
-    if (load_eject) {
+    if (load_eject && msc_enabled) {
         if (start) {
             // load disk storage
             tud_msc_state = MOUNTED;
