shared/tinyusb,extmod/machine_usb_device: Simplify class state to flags.

Replace mp_usbd_class_state_t boolean fields (cdc_enabled, msc_enabled)
with single uint8_t flags field to eliminate redundant state storage.

Changes:
- Use MP_USBD_CDC_ENABLED() and MP_USBD_MSC_ENABLED() macros for checks
- Remove mp_usbd_update_class_state() and mp_usbd_class_state_to_flags()
- Store and access flags directly in mp_usbd_class_state.flags
- Add compile-time guards (#if CFG_TUD_CDC) in descriptor length calc

Code size impact (NUCLEO_H563ZI):
- Runtime mode: +24 bytes
- Static mode: +16 bytes

The slight size increase is due to macro expansion overhead, but the
code is simpler with single source of truth for enabled class state.

Signed-off-by: Andrew Leech <[email protected]>

Author: pi-anl

extmod/machine_usb_device.c

@@ -84,30 +84,15 @@ static mp_obj_t usb_device_make_new(const mp_obj_type_t *type, size_t n_args, si
         o->base.type = &machine_usb_device_type;
 
         // Initialize fields common to both minimal and full modes
+        extern mp_usbd_class_state_t mp_usbd_class_state;
         #if MICROPY_HW_ENABLE_USB_RUNTIME_DEVICE
         // Runtime mode: read current class state to reflect default CDC configuration
-        extern mp_usbd_class_state_t mp_usbd_class_state;
-        uint8_t flags = 0;
-        if (mp_usbd_class_state.cdc_enabled) {
-            flags |= USB_BUILTIN_FLAG_CDC;
-        }
-        if (mp_usbd_class_state.msc_enabled) {
-            flags |= USB_BUILTIN_FLAG_MSC;
-        }
-        o->builtin_driver = flags;
+        o->builtin_driver = mp_usbd_class_state.flags;
         o->active = tud_inited();
         #else
         // In static mode, USB is always initialized at boot
         // Class state is set during early boot, create a USBBuiltin object from it
-        extern mp_usbd_class_state_t mp_usbd_class_state;
-        uint8_t flags = 0;
-        if (mp_usbd_class_state.cdc_enabled) {
-            flags |= USB_BUILTIN_FLAG_CDC;
-        }
-        if (mp_usbd_class_state.msc_enabled) {
-            flags |= USB_BUILTIN_FLAG_MSC;
-        }
-        o->builtin_driver = mp_usbd_create_builtin_config(flags);
+        o->builtin_driver = mp_usbd_create_builtin_config(mp_usbd_class_state.flags);
         o->active = tud_inited();
         #endif
 
@@ -546,7 +531,7 @@ static void usb_device_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
             }
 
             // Update the internal class state based on flags
-            mp_usbd_update_class_state(flags);
+            mp_usbd_class_state.flags = flags;
 
             #if MICROPY_HW_ENABLE_USB_RUNTIME_DEVICE
             // In runtime mode, store flags directly

shared/tinyusb/mp_usbd.h

@@ -58,8 +58,7 @@ 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;
+    uint8_t flags;  // Bitfield of enabled USB classes (USB_BUILTIN_FLAG_*)
 } mp_usbd_class_state_t;
 
 // Global class enable state
@@ -103,25 +102,23 @@ extern const mp_obj_type_t mp_type_usb_builtin;
 #define USB_BUILTIN_FLAG_MSC   0x02
 #define USB_BUILTIN_FLAG_NCM   0x04
 
+// Helper macros for checking enabled classes
+#define MP_USBD_CDC_ENABLED() (mp_usbd_class_state.flags & USB_BUILTIN_FLAG_CDC)
+#define MP_USBD_MSC_ENABLED() (mp_usbd_class_state.flags & USB_BUILTIN_FLAG_MSC)
+
 // Initialize class state based on compile-time configuration and runtime mode
 static inline void mp_usbd_init_class_state(void) {
     #if MICROPY_HW_ENABLE_USB_RUNTIME_DEVICE
     // In runtime mode, only CDC enabled by default
-    mp_usbd_class_state.cdc_enabled = (CFG_TUD_CDC == 1);
-    mp_usbd_class_state.msc_enabled = false;
+    mp_usbd_class_state.flags = (CFG_TUD_CDC ? USB_BUILTIN_FLAG_CDC : 0);
     #else
     // In static mode, enable all compiled classes
-    mp_usbd_class_state.cdc_enabled = (CFG_TUD_CDC == 1);
-    mp_usbd_class_state.msc_enabled = (CFG_TUD_MSC == 1);
+    mp_usbd_class_state.flags =
+        (CFG_TUD_CDC ? USB_BUILTIN_FLAG_CDC : 0) |
+        (CFG_TUD_MSC ? USB_BUILTIN_FLAG_MSC : 0);
     #endif
 }
 
-// Update class state based on bitfield flags
-static inline void mp_usbd_update_class_state(uint8_t flags) {
-    mp_usbd_class_state.cdc_enabled = (flags & USB_BUILTIN_FLAG_CDC) && (CFG_TUD_CDC == 1);
-    mp_usbd_class_state.msc_enabled = (flags & USB_BUILTIN_FLAG_MSC) && (CFG_TUD_MSC == 1);
-}
-
 // Calculate descriptor length from flags using compile-time conditionals
 static inline size_t mp_usbd_get_descriptor_cfg_len_from_flags(uint8_t flags) {
     size_t len = TUD_CONFIG_DESC_LEN;

shared/tinyusb/mp_usbd_descriptor.c

@@ -108,8 +108,10 @@ const usb_desc_entry_t usb_desc_table[] = {
     #endif
 };
 
-// Global descriptor buffer for runtime configuration (used by both runtime and static modes)
+// Global descriptor buffer for runtime configuration (only needed in runtime mode)
+#if MICROPY_HW_ENABLE_USB_RUNTIME_DEVICE
 uint8_t mp_usbd_desc_cfg_buffer[MP_USBD_BUILTIN_DESC_CFG_LEN];
+#endif
 
 // Unified descriptor generation function using lookup table
 const uint8_t *mp_usbd_generate_desc_cfg_unified(uint8_t flags, uint8_t *buffer) {
@@ -165,12 +167,16 @@ const uint8_t *mp_usbd_generate_desc_cfg_unified(uint8_t flags, uint8_t *buffer)
 size_t mp_usbd_get_descriptor_cfg_len(void) {
     size_t len = TUD_CONFIG_DESC_LEN;
 
-    if (mp_usbd_class_state.cdc_enabled && CFG_TUD_CDC) {
+    #if CFG_TUD_CDC
+    if (MP_USBD_CDC_ENABLED()) {
         len += TUD_CDC_DESC_LEN;
     }
-    if (mp_usbd_class_state.msc_enabled && CFG_TUD_MSC) {
+    #endif
+    #if CFG_TUD_MSC
+    if (MP_USBD_MSC_ENABLED()) {
         len += TUD_MSC_DESC_LEN;
     }
+    #endif
 
     return len;
 }
@@ -196,22 +202,9 @@ static const uint8_t mp_usbd_builtin_desc_cfg_max[MP_USBD_BUILTIN_DESC_CFG_LEN]
 // Dynamic descriptor buffer for runtime configuration
 static uint8_t mp_usbd_dynamic_desc_cfg[MP_USBD_BUILTIN_DESC_CFG_LEN];
 
-// Convert class state to flags
-static uint8_t mp_usbd_class_state_to_flags(void) {
-    uint8_t flags = USB_BUILTIN_FLAG_NONE;
-    if (mp_usbd_class_state.cdc_enabled) {
-        flags |= USB_BUILTIN_FLAG_CDC;
-    }
-    if (mp_usbd_class_state.msc_enabled) {
-        flags |= USB_BUILTIN_FLAG_MSC;
-    }
-    return flags;
-}
-
 // Generate dynamic configuration descriptor based on enabled classes
 static const uint8_t *mp_usbd_generate_desc_cfg(void) {
-    uint8_t flags = mp_usbd_class_state_to_flags();
-    return mp_usbd_generate_desc_cfg_unified(flags, mp_usbd_dynamic_desc_cfg);
+    return mp_usbd_generate_desc_cfg_unified(mp_usbd_class_state.flags, mp_usbd_dynamic_desc_cfg);
 }
 #endif
 

shared/tinyusb/mp_usbd_runtime.c

@@ -125,7 +125,8 @@ const uint8_t *tud_descriptor_configuration_cb(uint8_t index) {
         if (!result && usbd->builtin_driver != USB_BUILTIN_FLAG_NONE) {
             extern uint8_t mp_usbd_desc_cfg_buffer[];
             extern const uint8_t *mp_usbd_generate_desc_cfg_unified(uint8_t flags, uint8_t *buffer);
-            mp_usbd_update_class_state(usbd->builtin_driver);
+            extern mp_usbd_class_state_t mp_usbd_class_state;
+            mp_usbd_class_state.flags = usbd->builtin_driver;
             result = mp_usbd_generate_desc_cfg_unified(usbd->builtin_driver, mp_usbd_desc_cfg_buffer);
         }
     }