mimxrt: Implement mutual write permission with MSC use.

robert-hh · robert-hh · commit 34223b8c152d · 2022-08-30T14:39:32.000+02:00
Porting PR micropython#8814 of @iabdalkader to the mimxrt platform. - When the board is mounted to a PC, local write access is blocked. - Local write access will be re-enabled again if the disk is ejected. - If the board is not connected to a PC on start-up, local write access is enabled. - The status of the write access can be determined by bdev.ioctl(7, 0). If the device is mounted to a PAC and thus local write access is blocked, it return 1, otherwise 0. - low level write/erase using the block device calls are still possible. It is up to the user to check the device status ahead.
diff --git a/extmod/vfs.h b/extmod/vfs.h
@@ -51,6 +51,7 @@
 #define MP_BLOCKDEV_IOCTL_BLOCK_COUNT   (4)
 #define MP_BLOCKDEV_IOCTL_BLOCK_SIZE    (5)
 #define MP_BLOCKDEV_IOCTL_BLOCK_ERASE   (6)
+#define MP_BLOCKDEV_IOCTL_STATUS        (7)
 
 // At the moment the VFS protocol just has import_stat, but could be extended to other methods
 typedef struct _mp_vfs_proto_t {
diff --git a/extmod/vfs_fat_diskio.c b/extmod/vfs_fat_diskio.c
@@ -114,6 +114,7 @@ DRESULT disk_ioctl(
         [GET_SECTOR_COUNT] = MP_BLOCKDEV_IOCTL_BLOCK_COUNT,
         [GET_SECTOR_SIZE] = MP_BLOCKDEV_IOCTL_BLOCK_SIZE,
         [IOCTL_INIT] = MP_BLOCKDEV_IOCTL_INIT,
+        [IOCTL_STATUS] = MP_BLOCKDEV_IOCTL_STATUS,
     };
     uint8_t bp_op = op_map[cmd & 7];
     mp_obj_t ret = mp_const_none;
@@ -147,16 +148,21 @@ DRESULT disk_ioctl(
             *((DWORD *)buff) = 1; // erase block size in units of sector size
             return RES_OK;
 
-        case IOCTL_INIT:
-        case IOCTL_STATUS: {
-            DSTATUS stat;
+        case IOCTL_INIT: {
+            DSTATUS stat = 0;
             if (ret != mp_const_none && MP_OBJ_SMALL_INT_VALUE(ret) != 0) {
                 // error initialising
-                stat = STA_NOINIT;
-            } else if (vfs->blockdev.writeblocks[0] == MP_OBJ_NULL) {
+               stat = STA_NOINIT;
+            }
+            *((DSTATUS *)buff) = stat;
+            return RES_OK;
+        }
+
+        case IOCTL_STATUS: {
+            DSTATUS stat = 0;
+            if (vfs->blockdev.writeblocks[0] == MP_OBJ_NULL ||
+                    (ret != mp_const_none && MP_OBJ_SMALL_INT_VALUE(ret) != 0)) {
                 stat = STA_PROTECT;
-            } else {
-                stat = 0;
             }
             *((DSTATUS *)buff) = stat;
             return RES_OK;
diff --git a/ports/mimxrt/Makefile b/ports/mimxrt/Makefile
@@ -196,6 +196,7 @@ SRC_C += \
 	shared/runtime/mpirq.c \
 	shared/runtime/pyexec.c \
 	shared/runtime/stdout_helpers.c \
+	shared/runtime/tinyusb_helpers.c \
 	shared/runtime/sys_stdio_mphal.c \
 	shared/timeutils/timeutils.c \
 	systick.c \
diff --git a/ports/mimxrt/mimxrt_flash.c b/ports/mimxrt/mimxrt_flash.c
@@ -45,6 +45,8 @@ STATIC mimxrt_flash_obj_t mimxrt_flash_obj = {
     .base = { &mimxrt_flash_type }
 };
 
+extern bool tud_msc_ejected;
+
 STATIC mp_obj_t mimxrt_flash_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
     // Check args.
     mp_arg_check_num(n_args, n_kw, 0, 0, false);
@@ -141,6 +143,12 @@ STATIC mp_obj_t mimxrt_flash_ioctl(mp_obj_t self_in, mp_obj_t cmd_in, mp_obj_t a
             status = flash_erase_sector(self->flash_base + offset);
             return MP_OBJ_NEW_SMALL_INT(status != kStatus_Success);
         }
+        case MP_BLOCKDEV_IOCTL_STATUS:
+            #if MICROPY_HW_USB_MSC
+            return MP_OBJ_NEW_SMALL_INT(!tud_msc_ejected);
+            #else
+            return MP_OBJ_NEW_SMALL_INT(false);
+            #endif
         default:
             return mp_const_none;
     }
diff --git a/ports/mimxrt/mpconfigport.h b/ports/mimxrt/mpconfigport.h
@@ -67,6 +67,7 @@ uint32_t trng_random_u32(void);
 #define MICROPY_CAN_OVERRIDE_BUILTINS       (1)
 #define MICROPY_ENABLE_SCHEDULER            (1)
 #define MICROPY_SCHEDULER_DEPTH             (8)
+#define MICROPY_SCHEDULER_STATIC_NODES      (1)
 #define MICROPY_VFS                         (1)
 #define MICROPY_MODULE_FROZEN_MPY           (1)
 #define MICROPY_QSTR_EXTRA_POOL             mp_qstr_frozen_const_pool
@@ -187,14 +188,16 @@ uint32_t trng_random_u32(void);
 #define MICROPY_PY_PENDSV_REENTER atomic_state = raise_irq_pri(IRQ_PRI_PENDSV);
 #define MICROPY_PY_PENDSV_EXIT    restore_irq_pri(atomic_state);
 
-// by default do not enable MSC support
+// by default enable MSC support, unless disabled at some boards
+// Boards with hyperflash must disbale MSC support.
 #ifndef MICROPY_HW_USB_MSC
-#define MICROPY_HW_USB_MSC                  (0)
+#define MICROPY_HW_USB_MSC                  (1)
 #endif
 
 #if MICROPY_HW_USB_MSC
 #define MICROPY_FATFS_USE_LABEL             (1)
 #define MICROPY_FATFS_MULTI_PARTITION       (1)
+#define MICROPY_HW_USB_MSC_EXCLUSIVE_ACCESS (1)
 #endif
 
 // Hooks to add builtins
diff --git a/ports/mimxrt/msc_disk.c b/ports/mimxrt/msc_disk.c
@@ -34,7 +34,8 @@
 #define BLOCK_COUNT         (MICROPY_HW_FLASH_STORAGE_BYTES / BLOCK_SIZE)
 #define FLASH_BASE_ADDR     (MICROPY_HW_FLASH_STORAGE_BASE)
 
-bool ejected = false;
+bool tud_msc_ejected = true;
+extern void tud_msc_remount(void);
 
 // Invoked when received SCSI_CMD_INQUIRY
 // Application fill vendor id, product id and revision with string up to 8, 16, 4 characters respectively
@@ -46,12 +47,13 @@ void tud_msc_inquiry_cb(uint8_t lun, uint8_t vendor_id[8], uint8_t product_id[16
     strncpy((char *)vendor_id,   vid, 8);
     strncpy((char *)product_id,  pid, 16);
     strncpy((char *)product_rev, rev, 4);
+    tud_msc_ejected = false;
 }
 
 // Invoked when received Test Unit Ready command.
 // return true allowing host to read/write this LUN e.g SD card inserted
 bool tud_msc_test_unit_ready_cb(uint8_t lun) {
-    if (ejected) {
+    if (tud_msc_ejected) {
         tud_msc_set_sense(lun, SCSI_SENSE_NOT_READY, 0x3a, 0x00);
         return false;
     }
@@ -63,6 +65,7 @@ bool tud_msc_test_unit_ready_cb(uint8_t lun) {
 void tud_msc_capacity_cb(uint8_t lun, uint32_t *block_count, uint16_t *block_size) {
     *block_size = BLOCK_SIZE;
     *block_count = BLOCK_COUNT;
+    tud_msc_ejected = false;
 }
 
 // Invoked when received Start Stop Unit command
@@ -72,10 +75,13 @@ bool tud_msc_start_stop_cb(uint8_t lun, uint8_t power_condition, bool start, boo
     if (load_eject) {
         if (start) {
             // load disk storage
-            ejected = false;
+            tud_msc_ejected = false;
         } else {
             // unload disk storage
-            ejected = true;
+            tud_msc_ejected = true;
+            #if MICROPY_HW_USB_MSC_EXCLUSIVE_ACCESS
+            tud_msc_remount();
+            #endif
         }
     }
     return true;
diff --git a/shared/runtime/tinyusb_helpers.c b/shared/runtime/tinyusb_helpers.c
@@ -52,3 +52,31 @@ void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts) {
 }
 
 #endif
+
+#if MICROPY_HW_USB_MSC_EXCLUSIVE_ACCESS
+#include "tusb.h"
+#include "extmod/vfs.h"
+#include "extmod/vfs_fat.h"
+static mp_sched_node_t mp_remount_sched_node;
+
+STATIC void tud_msc_remount_task(mp_sched_node_t *node) {
+    mp_vfs_mount_t *vfs = NULL;
+    for (vfs = MP_STATE_VM(vfs_mount_table); vfs != NULL; vfs = vfs->next) {
+        if (vfs->len == 1) {
+            const char *path_str = "/";
+            mp_obj_t path = mp_obj_new_str(path_str, strlen(path_str));
+            nlr_buf_t nlr;
+            if (nlr_push(&nlr) == 0) {
+                mp_vfs_umount(vfs->obj);
+                mp_vfs_mount_and_chdir_protected(vfs->obj, path);
+                nlr_pop();
+            }
+            break;
+        }
+    }
+}
+
+void tud_msc_remount(void) {
+    mp_sched_schedule_node(&mp_remount_sched_node, tud_msc_remount_task);
+}
+#endif
