usb: start supporting USB_DEVICE_STACK_NEXT

facchinm · facchinm · commit c8d58982a2c0 · 2025-03-06T10:30:46.000+01:00
diff --git a/Kconfig b/Kconfig
@@ -31,3 +31,23 @@ config ARDUINO_ENTRY
 	default y
 
 endif
+
+if USB_DEVICE_STACK_NEXT
+
+config USB_DEVICE_PRODUCT
+	string "USB Device Product"
+	default "Arduino Generic board"
+
+config USB_DEVICE_MANUFACTURER
+	string "USB Device Manufacturer"
+	default "Arduino"
+
+config USB_DEVICE_VID
+	hex "USB Device Vendor ID"
+	default 0x2341
+
+config USB_DEVICE_PID
+	hex "USB Device Product ID"
+	default 0x0001
+
+endif
diff --git a/cores/arduino/SerialUSB.h b/cores/arduino/SerialUSB.h
@@ -31,6 +31,6 @@ class SerialUSB_ : public ZephyrSerial {
 };
 }  // namespace arduino
 
-#if (DT_NODE_HAS_PROP(DT_PATH(zephyr_user), cdc_acm) && CONFIG_USB_CDC_ACM)
+#if (DT_NODE_HAS_PROP(DT_PATH(zephyr_user), cdc_acm) && (CONFIG_USB_CDC_ACM || CONFIG_USBD_CDC_ACM_CLASS))
 extern arduino::SerialUSB_ Serial;
 #endif
diff --git a/cores/arduino/USB.cpp b/cores/arduino/USB.cpp
@@ -10,7 +10,7 @@
 #include <zephyr/usb/usb_device.h>
 #include <SerialUSB.h>
 
-#if (DT_NODE_HAS_PROP(DT_PATH(zephyr_user), cdc_acm) && CONFIG_USB_CDC_ACM)
+#if (DT_NODE_HAS_PROP(DT_PATH(zephyr_user), cdc_acm))
 const struct device *const usb_dev = DEVICE_DT_GET(DT_PHANDLE_BY_IDX(DT_PATH(zephyr_user), cdc_acm, 0));
 
 void usb_status_cb(enum usb_dc_status_code cb_status, const uint8_t *param) {
@@ -40,6 +40,58 @@ static void _baudChangeHandler(const struct device *dev, uint32_t rate)
     }
 }
 
+#if defined(CONFIG_USB_DEVICE_STACK_NEXT)
+
+extern "C" {
+    #include <zephyr/usb/usbd.h>
+    struct usbd_context *usbd_init_device(usbd_msg_cb_t msg_cb);
+}
+
+struct usbd_context *_usbd;
+
+int usb_disable() {
+    return usbd_disable(_usbd);
+}
+
+static void usbd_next_cb(struct usbd_context *const ctx, const struct usbd_msg *msg)
+{
+	if (usbd_can_detect_vbus(ctx)) {
+		if (msg->type == USBD_MSG_VBUS_READY) {
+			usbd_enable(ctx);
+		}
+
+		if (msg->type == USBD_MSG_VBUS_REMOVED) {
+			usbd_disable(ctx);
+		}
+	}
+
+	if (msg->type == USBD_MSG_CDC_ACM_LINE_CODING) {
+        uint32_t baudrate;
+		uart_line_ctrl_get(ctx->dev, UART_LINE_CTRL_BAUD_RATE, &baudrate);
+        _baudChangeHandler(nullptr, baudrate);
+	}
+}
+
+static int enable_usb_device_next(void)
+{
+	int err;
+
+	//_usbd = usbd_init_device(usbd_next_cb);
+	_usbd = usbd_init_device(nullptr);
+	if (_usbd == NULL) {
+		return -ENODEV;
+	}
+
+	if (!usbd_can_detect_vbus(_usbd)) {
+		err = usbd_enable(_usbd);
+		if (err) {
+			return err;
+		}
+	}
+	return 0;
+}
+#endif /* defined(CONFIG_USB_DEVICE_STACK_NEXT) */
+
 void arduino::SerialUSB_::_baudChangeDispatch(struct k_timer *timer) {
     arduino::SerialUSB_* dev = (arduino::SerialUSB_*)k_timer_user_data_get(timer);
     dev->_baudChangeHandler();
@@ -48,6 +100,7 @@ void arduino::SerialUSB_::_baudChangeDispatch(struct k_timer *timer) {
 
 void arduino::SerialUSB_::begin(unsigned long baudrate, uint16_t config) {
     if (!started) {
+        #ifndef CONFIG_USB_DEVICE_STACK_NEXT
         usb_enable(NULL);
         #ifndef CONFIG_CDC_ACM_DTE_RATE_CALLBACK_SUPPORT
         k_timer_init(&baud_timer, SerialUSB_::_baudChangeDispatch, NULL);
@@ -56,6 +109,9 @@ void arduino::SerialUSB_::begin(unsigned long baudrate, uint16_t config) {
         #else
         cdc_acm_dte_rate_callback_set(usb_dev, ::_baudChangeHandler);
         #endif
+        #else
+        enable_usb_device_next();
+        #endif
         ZephyrSerial::begin(baudrate, config);
         started = true;
     }
diff --git a/cores/arduino/main.cpp b/cores/arduino/main.cpp
@@ -71,14 +71,18 @@ extern "C" __attribute__((section(".entry_point"), used)) void entry_point(struc
   extern uintptr_t _ebss;
   extern uintptr_t __heap_start;
   extern uintptr_t __heap_end;
+  extern uintptr_t kheap_llext_heap;
+  extern uintptr_t kheap_llext_heap_size;
+
   //__asm volatile ("cpsie i");
 
   const size_t alignment = 4096;
-  printk("Heap end: %p\n", &__heap_end);
-  printk("Heap start: %p\n", &__heap_start);
+  printk("System Heap end: %p\n", &__heap_end);
+  printk("System Heap start: %p\n", &__heap_start);
+  printk("Sketch Heap start: %p, size %p\n", &kheap_llext_heap, &kheap_llext_heap_size);
   // __heap_start = (__heap_start + (alignment - 1)) & ~(alignment - 1);
 
-  memcpy(&_sdata, &_sidata, &_edata - &_sdata);
+  memcpy(&_sdata, &_sidata, (&_edata - &_sdata) * sizeof(uint32_t));
   memset(&_sbss, 0, &_ebss - &_sbss);
   __libc_init_array();
   main();
diff --git a/cores/arduino/usb_device_descriptor.c b/cores/arduino/usb_device_descriptor.c
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2025 Arduino SA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdint.h>
+
+#include <zephyr/device.h>
+#include <zephyr/usb/usbd.h>
+#include <zephyr/usb/bos.h>
+
+#include <zephyr/logging/log.h>
+
+#ifdef CONFIG_USB_DEVICE_STACK_NEXT
+
+/* By default, do not register the USB DFU class DFU mode instance. */
+static const char *const blocklist[] = {
+	"dfu_dfu",
+	NULL,
+};
+
+/* doc device instantiation start */
+USBD_DEVICE_DEFINE(usbd,
+		   DEVICE_DT_GET(DT_NODELABEL(zephyr_udc0)),
+		   CONFIG_USB_DEVICE_VID, CONFIG_USB_DEVICE_PID);
+/* doc device instantiation end */
+
+/* doc string instantiation start */
+USBD_DESC_LANG_DEFINE(sample_lang);
+USBD_DESC_MANUFACTURER_DEFINE(sample_mfr, CONFIG_USB_DEVICE_MANUFACTURER);
+USBD_DESC_PRODUCT_DEFINE(sample_product, CONFIG_USB_DEVICE_PRODUCT);
+USBD_DESC_SERIAL_NUMBER_DEFINE(sample_sn);
+/* doc string instantiation end */
+
+USBD_DESC_CONFIG_DEFINE(fs_cfg_desc, "FS Configuration");
+USBD_DESC_CONFIG_DEFINE(hs_cfg_desc, "HS Configuration");
+
+/* doc configuration instantiation start */
+static const uint8_t attributes = 0;
+
+/* Full speed configuration */
+USBD_CONFIGURATION_DEFINE(sample_fs_config,
+			  attributes,
+			  250, &fs_cfg_desc);
+
+/* High speed configuration */
+USBD_CONFIGURATION_DEFINE(sample_hs_config,
+			  attributes,
+			  250, &hs_cfg_desc);
+/* doc configuration instantiation end */
+
+/*
+ * This does not yet provide valuable information, but rather serves as an
+ * example, and will be improved in the future.
+ */
+static const struct usb_bos_capability_lpm bos_cap_lpm = {
+	.bLength = sizeof(struct usb_bos_capability_lpm),
+	.bDescriptorType = USB_DESC_DEVICE_CAPABILITY,
+	.bDevCapabilityType = USB_BOS_CAPABILITY_EXTENSION,
+	.bmAttributes = 0UL,
+};
+
+USBD_DESC_BOS_DEFINE(sample_usbext, sizeof(bos_cap_lpm), &bos_cap_lpm);
+
+static void sample_fix_code_triple(struct usbd_context *uds_ctx,
+				   const enum usbd_speed speed)
+{
+	/* Always use class code information from Interface Descriptors */
+	if (IS_ENABLED(CONFIG_USBD_CDC_ACM_CLASS) ||
+	    IS_ENABLED(CONFIG_USBD_CDC_ECM_CLASS) ||
+	    IS_ENABLED(CONFIG_USBD_CDC_NCM_CLASS) ||
+	    IS_ENABLED(CONFIG_USBD_AUDIO2_CLASS)) {
+		/*
+		 * Class with multiple interfaces have an Interface
+		 * Association Descriptor available, use an appropriate triple
+		 * to indicate it.
+		 */
+		usbd_device_set_code_triple(uds_ctx, speed,
+					    USB_BCC_MISCELLANEOUS, 0x02, 0x01);
+	} else {
+		usbd_device_set_code_triple(uds_ctx, speed, 0, 0, 0);
+	}
+}
+
+struct usbd_context *usbd_setup_device(usbd_msg_cb_t msg_cb)
+{
+	int err;
+
+	/* doc add string descriptor start */
+	err = usbd_add_descriptor(&usbd, &sample_lang);
+	if (err) {
+		return NULL;
+	}
+
+	err = usbd_add_descriptor(&usbd, &sample_mfr);
+	if (err) {
+		return NULL;
+	}
+
+	err = usbd_add_descriptor(&usbd, &sample_product);
+	if (err) {
+		return NULL;
+	}
+
+	err = usbd_add_descriptor(&usbd, &sample_sn);
+	if (err) {
+		return NULL;
+	}
+	/* doc add string descriptor end */
+
+	if (usbd_caps_speed(&usbd) == USBD_SPEED_HS) {
+		err = usbd_add_configuration(&usbd, USBD_SPEED_HS,
+					     &sample_hs_config);
+		if (err) {
+			return NULL;
+		}
+
+		err = usbd_register_all_classes(&usbd, USBD_SPEED_HS, 1,
+						blocklist);
+		if (err) {
+			return NULL;
+		}
+
+		sample_fix_code_triple(&usbd, USBD_SPEED_HS);
+	}
+
+	/* doc configuration register start */
+	err = usbd_add_configuration(&usbd, USBD_SPEED_FS,
+				     &sample_fs_config);
+	if (err) {
+		return NULL;
+	}
+	/* doc configuration register end */
+
+	/* doc functions register start */
+	err = usbd_register_all_classes(&usbd, USBD_SPEED_FS, 1, blocklist);
+	if (err) {
+		return NULL;
+	}
+	/* doc functions register end */
+
+	sample_fix_code_triple(&usbd, USBD_SPEED_FS);
+
+	if (msg_cb != NULL) {
+		/* doc device init-and-msg start */
+		err = usbd_msg_register_cb(&usbd, msg_cb);
+		if (err) {
+			return NULL;
+		}
+		/* doc device init-and-msg end */
+	}
+
+	if (0) {
+		(void)usbd_device_set_bcd_usb(&usbd, USBD_SPEED_FS, 0x0201);
+		(void)usbd_device_set_bcd_usb(&usbd, USBD_SPEED_HS, 0x0201);
+
+		err = usbd_add_descriptor(&usbd, &sample_usbext);
+		if (err) {
+			return NULL;
+		}
+	}
+
+	return &usbd;
+}
+
+struct usbd_context *usbd_init_device(usbd_msg_cb_t msg_cb)
+{
+	int err;
+
+	if (usbd_setup_device(msg_cb) == NULL) {
+		return NULL;
+	}
+
+	/* doc device init start */
+	err = usbd_init(&usbd);
+	if (err) {
+		return NULL;
+	}
+	/* doc device init end */
+
+	return &usbd;
+}
+
+#endif
diff --git a/cores/arduino/zephyrSerial.cpp b/cores/arduino/zephyrSerial.cpp
@@ -205,7 +205,7 @@ void arduino::ZephyrSerial::flush() {
 #endif
 
 #if DT_NODE_HAS_PROP(DT_PATH(zephyr_user), serials)
-#if !(DT_NODE_HAS_PROP(DT_PATH(zephyr_user), cdc_acm) && CONFIG_USB_CDC_ACM)
+#if !(DT_NODE_HAS_PROP(DT_PATH(zephyr_user), cdc_acm) && (CONFIG_USB_CDC_ACM || CONFIG_USBD_CDC_ACM_CLASS))
 // If CDC USB, use that object as Serial (and SerialUSB)
 arduino::ZephyrSerial Serial(DEVICE_DT_GET(DT_PHANDLE_BY_IDX(DT_PATH(zephyr_user), serials, FIRST_UART_INDEX)));
 #endif
diff --git a/cores/arduino/zephyrSerial.h b/cores/arduino/zephyrSerial.h
@@ -82,7 +82,7 @@ class ZephyrSerial : public HardwareSerial
 }   // namespace arduino
 
 #if DT_NODE_HAS_PROP(DT_PATH(zephyr_user), serials)
-#if !(DT_NODE_HAS_PROP(DT_PATH(zephyr_user), cdc_acm) && CONFIG_USB_CDC_ACM)
+#if !(DT_NODE_HAS_PROP(DT_PATH(zephyr_user), cdc_acm) && (CONFIG_USB_CDC_ACM || CONFIG_USBD_CDC_ACM_CLASS))
 // If CDC USB, use that object as Serial (and SerialUSB)
 extern arduino::ZephyrSerial Serial;
 #endif
diff --git a/loader/llext_exports.c b/loader/llext_exports.c
@@ -133,6 +133,20 @@ FORCE_EXPORT_SYM(setsockopt);
 FORCE_EXPORT_SYM(cdc_acm_dte_rate_callback_set);
 #endif
 
+#if defined(CONFIG_USB_DEVICE_STACK_NEXT)
+FORCE_EXPORT_SYM(usbd_init);
+FORCE_EXPORT_SYM(usbd_add_descriptor);
+FORCE_EXPORT_SYM(usbd_device_set_bcd_usb);
+FORCE_EXPORT_SYM(usbd_msg_register_cb);
+FORCE_EXPORT_SYM(usbd_device_set_code_triple);
+FORCE_EXPORT_SYM(usbd_register_all_classes);
+FORCE_EXPORT_SYM(usbd_add_configuration);
+FORCE_EXPORT_SYM(usbd_caps_speed);
+FORCE_EXPORT_SYM(usbd_can_detect_vbus);
+FORCE_EXPORT_SYM(usbd_enable);
+FORCE_EXPORT_SYM(usbd_disable);
+#endif
+
 EXPORT_SYMBOL(k_timer_init);
 EXPORT_SYMBOL(k_fatal_halt);
 EXPORT_SYMBOL(k_work_schedule);
diff --git a/variants/linked/linker_script.ld b/variants/linked/linker_script.ld
@@ -82,6 +82,8 @@ SECTIONS {
         . = ALIGN(4);
         _sdata = .;
         *(.data .data.* .tdata*)
+        *(._usbd_context.static.usbd_)
+        *(.ramfunc)
         . = ALIGN(4);
         _edata = .;
     } >RAM AT> FLASH
