shared/tinyusb: Add per-driver runtime USB class control.

This change allows USB class drivers (CDC, MSC, NCM) to be individually
enabled/disabled at runtime without requiring TinyUSB submodule changes.

Key features:
- Classes are always compiled in but only enabled drivers appear in USB
  descriptors
- When MICROPY_HW_ENABLE_USB_RUNTIME_DEVICE disabled: all compiled
  classes auto-enabled (backward compatibility)
- When MICROPY_HW_ENABLE_USB_RUNTIME_DEVICE enabled: only CDC enabled
  by default, others require explicit activation
- New Python API: usb.enable_cdc(), usb.enable_msc(), usb.enable_ncm()
- Dynamic descriptor generation based on enabled classes
- Proper cleanup of disabled drivers (e.g. NCM networking)

Usage:
  usb = machine.USBDevice()
  usb.active(False)
  usb.enable_msc(True)  # Enable mass storage
  usb.enable_ncm(True)  # Enable USB networking
  usb.active(True)

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>
Signed-off-by: Andrew Leech <[email protected]>

Author: pi-anl

extmod/machine_usb_device.c

@@ -229,6 +229,58 @@ static mp_obj_t usb_device_config(size_t n_args, const mp_obj_t *pos_args, mp_ma
 }
 static MP_DEFINE_CONST_FUN_OBJ_KW(usb_device_config_obj, 1, usb_device_config);
 
+// Per-class control methods
+static mp_obj_t usb_device_enable_cdc(size_t n_args, const mp_obj_t *args) {
+    mp_obj_usb_device_t *self = MP_OBJ_TO_PTR(args[0]);
+    
+    if (self->active) {
+        mp_raise_OSError(MP_EINVAL);
+    }
+    
+    if (n_args == 1) {
+        return mp_obj_new_bool(mp_usbd_class_state.cdc_enabled);
+    } else {
+        bool enable = mp_obj_is_true(args[1]);
+        mp_usbd_enable_class_cdc(enable);
+        return mp_const_none;
+    }
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(usb_device_enable_cdc_obj, 1, 2, usb_device_enable_cdc);
+
+static mp_obj_t usb_device_enable_msc(size_t n_args, const mp_obj_t *args) {
+    mp_obj_usb_device_t *self = MP_OBJ_TO_PTR(args[0]);
+    
+    if (self->active) {
+        mp_raise_OSError(MP_EINVAL);
+    }
+    
+    if (n_args == 1) {
+        return mp_obj_new_bool(mp_usbd_class_state.msc_enabled);
+    } else {
+        bool enable = mp_obj_is_true(args[1]);
+        mp_usbd_enable_class_msc(enable);
+        return mp_const_none;
+    }
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(usb_device_enable_msc_obj, 1, 2, usb_device_enable_msc);
+
+static mp_obj_t usb_device_enable_ncm(size_t n_args, const mp_obj_t *args) {
+    mp_obj_usb_device_t *self = MP_OBJ_TO_PTR(args[0]);
+    
+    if (self->active) {
+        mp_raise_OSError(MP_EINVAL);
+    }
+    
+    if (n_args == 1) {
+        return mp_obj_new_bool(mp_usbd_class_state.ncm_enabled);
+    } else {
+        bool enable = mp_obj_is_true(args[1]);
+        mp_usbd_enable_class_ncm(enable);
+        return mp_const_none;
+    }
+}
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(usb_device_enable_ncm_obj, 1, 2, usb_device_enable_ncm);
+
 static const MP_DEFINE_BYTES_OBJ(builtin_default_desc_dev_obj,
     &mp_usbd_builtin_desc_dev, sizeof(tusb_desc_device_t));
 
@@ -278,6 +330,11 @@ static const mp_rom_map_elem_t usb_device_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_active), MP_ROM_PTR(&usb_device_active_obj) },
     { MP_ROM_QSTR(MP_QSTR_stall), MP_ROM_PTR(&usb_device_stall_obj) },
     { MP_ROM_QSTR(MP_QSTR_remote_wakeup), MP_ROM_PTR(&usb_remote_wakeup_obj) },
+    
+    // Per-class control methods
+    { MP_ROM_QSTR(MP_QSTR_enable_cdc), MP_ROM_PTR(&usb_device_enable_cdc_obj) },
+    { MP_ROM_QSTR(MP_QSTR_enable_msc), MP_ROM_PTR(&usb_device_enable_msc_obj) },
+    { MP_ROM_QSTR(MP_QSTR_enable_ncm), MP_ROM_PTR(&usb_device_enable_ncm_obj) },
 
     // Built-in driver constants
     { MP_ROM_QSTR(MP_QSTR_BUILTIN_NONE), MP_ROM_PTR(&mp_type_usb_device_builtin_none) },

shared/tinyusb/mp_usbd.h

@@ -80,6 +80,35 @@ extern void mp_usbd_port_get_serial_number(char *buf);
 // length (2 * bytes_len + 1) (including NUL terminator).
 void mp_usbd_hex_str(char *out_str, const uint8_t *bytes, size_t bytes_len);
 
+// Per-class runtime enable/disable state
+typedef struct {
+    bool cdc_enabled;
+    bool msc_enabled;
+    bool ncm_enabled;
+} mp_usbd_class_state_t;
+
+// Global class enable state
+extern mp_usbd_class_state_t mp_usbd_class_state;
+
+// Functions to control USB classes via bitfield flags
+void mp_usbd_update_class_state(uint8_t flags);
+void mp_usbd_init_class_state(void);
+
+// Initialise TinyUSB device.
+static inline void mp_usbd_init_tud(void) {
+    // Initialize class state before TinyUSB init
+    mp_usbd_init_class_state();
+
+    tusb_init();
+    #if MICROPY_HW_USB_CDC
+    tud_cdc_configure_fifo_t cfg = { .rx_persistent = 0, .tx_persistent = 1 };
+    tud_cdc_configure_fifo(&cfg);
+    #endif
+}
+
+// Get dynamic descriptor length based on enabled classes
+size_t mp_usbd_get_descriptor_cfg_len(void);
+
 // Length of built-in configuration descriptor
 #define MP_USBD_BUILTIN_DESC_CFG_LEN ( \
     (CFG_TUD_CDC ? (TUD_CDC_DESC_LEN) : 0) + \
@@ -102,6 +131,7 @@ const char *mp_usbd_runtime_string_cb(uint8_t index);
 // Maximum number of pending exceptions per single TinyUSB task execution
 #define MP_USBD_MAX_PEND_EXCS 2
 
+// Full runtime USB device structure
 typedef struct {
     mp_obj_base_t base;
 
@@ -136,6 +166,23 @@ typedef struct {
     mp_obj_t pend_excs[MP_USBD_MAX_PEND_EXCS];
 } mp_obj_usb_device_t;
 
+#else // Static USBD drivers only
+
+// Minimal USB device structure for static mode (builtin_driver control only)
+typedef struct {
+    mp_obj_base_t base;
+    mp_obj_t builtin_driver; // Points to one of mp_type_usb_device_builtin_nnn
+    bool active; // Has the user set the USB device active?
+} mp_obj_usb_device_t;
+
+static inline void mp_usbd_init(void) {
+    // Without runtime USB support, this can be a thin wrapper wrapper around tusb_init()
+    // which is called in the below helper function.
+    mp_usbd_init_tud();
+}
+
+#endif
+
 // Built-in constant objects, possible values of builtin_driver
 //
 // (Currently not possible to change built-in drivers at runtime, just enable/disable.)
@@ -147,16 +194,6 @@ inline static bool mp_usb_device_builtin_enabled(const mp_obj_usb_device_t *usbd
     return usbd->builtin_driver != MP_OBJ_FROM_PTR(&mp_type_usb_device_builtin_none);
 }
 
-#else // Static USBD drivers only
-
-static inline void mp_usbd_init(void) {
-    // Without runtime USB support, this can be a thin wrapper wrapper around tusb_init()
-    // which is called in the below helper function.
-    mp_usbd_init_tud();
-}
-
-#endif
-
 #endif // MICROPY_HW_ENABLE_USBDEV
 
 #endif // MICROPY_INCLUDED_SHARED_TINYUSB_USBD_H