Initial project setup

managed_components/espressif__esp_tinyusb/include/tinyusb.h

@@ -0,0 +1,85 @@
+/*
+ * SPDX-FileCopyrightText: 2020-2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <stdbool.h>
+#include "esp_err.h"
+#include "tusb.h"
+#include "tinyusb_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Configuration structure of the TinyUSB core
+ *
+ * USB specification mandates self-powered devices to monitor USB VBUS to detect connection/disconnection events.
+ * If you want to use this feature, connected VBUS to any free GPIO through a voltage divider or voltage comparator.
+ * The voltage divider output should be (0.75 * Vdd) if VBUS is 4.4V (lowest valid voltage at device port).
+ * The comparator thresholds should be set with hysteresis: 4.35V (falling edge) and 4.75V (raising edge).
+ */
+typedef struct {
+    union {
+        const tusb_desc_device_t *device_descriptor; /*!< Pointer to a device descriptor. If set to NULL, the TinyUSB device will use a default device descriptor whose values are set in Kconfig */
+        const tusb_desc_device_t *descriptor  __attribute__((deprecated)); /*!< Alias to `device_descriptor` for backward compatibility */
+    };
+    const char **string_descriptor;            /*!< Pointer to array of string descriptors. If set to NULL, TinyUSB device will use a default string descriptors whose values are set in Kconfig */
+    int string_descriptor_count;               /*!< Number of descriptors in above array */
+    bool external_phy;                         /*!< Should USB use an external PHY */
+    union {
+        struct {
+            const uint8_t *configuration_descriptor;            /*!< Pointer to a configuration descriptor. If set to NULL, TinyUSB device will use a default configuration descriptor whose values are set in Kconfig */
+        };
+#if (TUD_OPT_HIGH_SPEED)
+        struct {
+            const uint8_t *fs_configuration_descriptor;         /*!< Pointer to a FullSpeed configuration descriptor. If set to NULL, TinyUSB device will use a default configuration descriptor whose values are set in Kconfig */
+        };
+    };
+    const uint8_t *hs_configuration_descriptor;                 /*!< Pointer to a HighSpeed configuration descriptor. If set to NULL, TinyUSB device will use a default configuration descriptor whose values are set in Kconfig */
+    const tusb_desc_device_qualifier_t *qualifier_descriptor;   /*!< Pointer to a qualifier descriptor */
+#else
+    };
+#endif // TUD_OPT_HIGH_SPEED
+    bool self_powered;                         /*!< This is a self-powered USB device. USB VBUS must be monitored. */
+    int vbus_monitor_io;                       /*!< GPIO for VBUS monitoring. Ignored if not self_powered. */
+} tinyusb_config_t;
+
+/**
+ * @brief This is an all-in-one helper function, including:
+ * 1. USB device driver initialization
+ * 2. Descriptors preparation
+ * 3. TinyUSB stack initialization
+ * 4. Creates and start a task to handle usb events
+ *
+ * @note Don't change Custom descriptor, but if it has to be done,
+ *       Suggest to define as follows in order to match the Interface Association Descriptor (IAD):
+ *       bDeviceClass = TUSB_CLASS_MISC,
+ *       bDeviceSubClass = MISC_SUBCLASS_COMMON,
+ *
+ * @param config tinyusb stack specific configuration
+ * @retval ESP_ERR_INVALID_ARG Install driver and tinyusb stack failed because of invalid argument
+ * @retval ESP_FAIL Install driver and tinyusb stack failed because of internal error
+ * @retval ESP_OK Install driver and tinyusb stack successfully
+ */
+esp_err_t tinyusb_driver_install(const tinyusb_config_t *config);
+
+/**
+ * @brief This is an all-in-one helper function, including:
+ * 1. Stops the task to handle usb events
+ * 2. TinyUSB stack tearing down
+ * 2. Freeing resources after descriptors preparation
+ * 3. Deletes USB PHY
+ *
+ * @retval ESP_FAIL Uninstall driver or tinyusb stack failed because of internal error
+ * @retval ESP_OK Uninstall driver, tinyusb stack and USB PHY successfully
+ */
+esp_err_t tinyusb_driver_uninstall(void);
+
+#ifdef __cplusplus
+}
+#endif

managed_components/espressif__esp_tinyusb/include/tinyusb_net.h

@@ -0,0 +1,99 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include "tinyusb_types.h"
+#include "esp_err.h"
+#include "sdkconfig.h"
+
+#if (CONFIG_TINYUSB_NET_MODE_NONE != 1)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief On receive callback type
+ */
+typedef esp_err_t (*tusb_net_rx_cb_t)(void *buffer, uint16_t len, void *ctx);
+
+/**
+ * @brief Free Tx buffer callback type
+ */
+typedef void (*tusb_net_free_tx_cb_t)(void *buffer, void *ctx);
+
+/**
+ * @brief On init callback type
+ */
+typedef void (*tusb_net_init_cb_t)(void *ctx);
+
+/**
+ * @brief ESP TinyUSB NCM driver configuration structure
+ */
+typedef struct {
+    uint8_t mac_addr[6];                      /*!< MAC address. Must be 6 bytes long. */
+    tusb_net_rx_cb_t on_recv_callback;        /*!< TinyUSB receive data callbeck */
+    tusb_net_free_tx_cb_t free_tx_buffer;     /*!< User function for freeing the Tx buffer.
+                                               *    - could be NULL, if user app is responsible for freeing the buffer
+                                               *    - must be used in asynchronous send mode
+                                               *    - is only called if the used tinyusb_net_send...() function returns ESP_OK
+                                               *        - in sync mode means that the packet was accepted by TinyUSB
+                                               *        - in async mode means that the packet was queued to be processed in TinyUSB task
+                                               */
+    tusb_net_init_cb_t on_init_callback;      /*!< TinyUSB init network callback */
+    void *user_context;                       /*!< User context to be passed to any of the callback */
+} tinyusb_net_config_t;
+
+/**
+ * @brief Initialize TinyUSB NET driver
+ *
+ * @param[in] usb_dev USB device to use
+ * @param[in] cfg     Configuration of the driver
+ * @return esp_err_t
+ */
+esp_err_t tinyusb_net_init(tinyusb_usbdev_t usb_dev, const tinyusb_net_config_t *cfg);
+
+/**
+ * @brief TinyUSB NET driver send data synchronously
+ *
+ * @note It is possible to use sync and async send interchangeably.
+ * This function needs some synchronization primitives, so using sync mode (even once) uses more heap
+ *
+ * @param[in] buffer            USB send data
+ * @param[in] len               Send data len
+ * @param[in] buff_free_arg     Pointer to be passed to the free_tx_buffer() callback
+ * @param[in] timeout           Send data len
+ * @return  ESP_OK on success == packet has been consumed by tusb and would be eventually freed
+ *                              by free_tx_buffer() callback (if non null)
+ *          ESP_ERR_TIMEOUT on timeout
+ *          ESP_ERR_INVALID_STATE if tusb not initialized, ESP_ERR_NO_MEM on alloc failure
+ */
+esp_err_t tinyusb_net_send_sync(void *buffer, uint16_t len, void *buff_free_arg, TickType_t  timeout);
+
+/**
+ * @brief TinyUSB NET driver send data asynchronously
+ *
+ * @note If using asynchronous sends, you must free the buffer using free_tx_buffer() callback.
+ * @note It is possible to use sync and async send interchangeably.
+ * @note Async flavor of the send is useful when the USB stack runs faster than the caller,
+ * since we have no control over the transmitted packets, if they get accepted or discarded.
+ *
+ * @param[in] buffer            USB send data
+ * @param[in] len               Send data len
+ * @param[in] buff_free_arg     Pointer to be passed to the free_tx_buffer() callback
+ * @return  ESP_OK on success == packet has been consumed by tusb and will be freed
+ *                              by free_tx_buffer() callback (if non null)
+ *          ESP_ERR_INVALID_STATE if tusb not initialized
+ */
+esp_err_t tinyusb_net_send_async(void *buffer, uint16_t len, void *buff_free_arg);
+
+#endif // (CONFIG_TINYUSB_NET_MODE_NONE != 1)
+
+#ifdef __cplusplus
+}
+#endif

managed_components/espressif__esp_tinyusb/include/tinyusb_types.h

@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2020-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define USB_ESPRESSIF_VID 0x303A
+
+typedef enum {
+    TINYUSB_USBDEV_0,
+} tinyusb_usbdev_t;
+
+#ifdef __cplusplus
+}
+#endif

managed_components/espressif__esp_tinyusb/include/tusb_cdc_acm.h

@@ -0,0 +1,206 @@
+/*
+ * SPDX-FileCopyrightText: 2020-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include "sdkconfig.h"
+#include "esp_err.h"
+
+#include "tinyusb_types.h"
+#include "class/cdc/cdc.h"
+
+#if (CONFIG_TINYUSB_CDC_ENABLED != 1)
+#error "TinyUSB CDC driver must be enabled in menuconfig"
+#endif
+
+
+/**
+ * @brief CDC ports available to setup
+ */
+typedef enum {
+    TINYUSB_CDC_ACM_0 = 0x0,
+    TINYUSB_CDC_ACM_1,
+    TINYUSB_CDC_ACM_MAX
+} tinyusb_cdcacm_itf_t;
+
+/* Callbacks and events
+   ********************************************************************* */
+
+/**
+ * @brief Data provided to the input of the `callback_rx_wanted_char` callback
+ */
+typedef struct {
+    char wanted_char; /*!< Wanted character */
+} cdcacm_event_rx_wanted_char_data_t;
+
+/**
+ * @brief Data provided to the input of the `callback_line_state_changed` callback
+ */
+typedef struct {
+    bool dtr; /*!< Data Terminal Ready (DTR) line state */
+    bool rts; /*!< Request To Send (RTS) line state */
+} cdcacm_event_line_state_changed_data_t;
+
+/**
+ * @brief Data provided to the input of the `line_coding_changed` callback
+ */
+typedef struct {
+    cdc_line_coding_t const *p_line_coding; /*!< New line coding value */
+} cdcacm_event_line_coding_changed_data_t;
+
+/**
+ * @brief Types of CDC ACM events
+ */
+typedef enum {
+    CDC_EVENT_RX,
+    CDC_EVENT_RX_WANTED_CHAR,
+    CDC_EVENT_LINE_STATE_CHANGED,
+    CDC_EVENT_LINE_CODING_CHANGED
+} cdcacm_event_type_t;
+
+/**
+ * @brief Describes an event passing to the input of a callbacks
+ */
+typedef struct {
+    cdcacm_event_type_t type; /*!< Event type */
+    union {
+        cdcacm_event_rx_wanted_char_data_t rx_wanted_char_data; /*!< Data input of the `callback_rx_wanted_char` callback */
+        cdcacm_event_line_state_changed_data_t line_state_changed_data; /*!< Data input of the `callback_line_state_changed` callback */
+        cdcacm_event_line_coding_changed_data_t line_coding_changed_data; /*!< Data input of the `line_coding_changed` callback */
+    };
+} cdcacm_event_t;
+
+/**
+ * @brief CDC-ACM callback type
+ */
+typedef void(*tusb_cdcacm_callback_t)(int itf, cdcacm_event_t *event);
+
+/*********************************************************************** Callbacks and events*/
+/* Other structs
+   ********************************************************************* */
+
+/**
+ * @brief Configuration structure for CDC-ACM
+ */
+typedef struct {
+    tinyusb_usbdev_t usb_dev; /*!< Usb device to set up */
+    tinyusb_cdcacm_itf_t cdc_port;  /*!< CDC port */
+    size_t rx_unread_buf_sz __attribute__((deprecated("This parameter is not used any more. Configure RX buffer in menuconfig.")));
+    tusb_cdcacm_callback_t callback_rx;  /*!< Pointer to the function with the `tusb_cdcacm_callback_t` type that will be handled as a callback */
+    tusb_cdcacm_callback_t callback_rx_wanted_char; /*!< Pointer to the function with the `tusb_cdcacm_callback_t` type that will be handled as a callback */
+    tusb_cdcacm_callback_t callback_line_state_changed; /*!< Pointer to the function with the `tusb_cdcacm_callback_t` type that will be handled as a callback */
+    tusb_cdcacm_callback_t callback_line_coding_changed; /*!< Pointer to the function with the `tusb_cdcacm_callback_t` type that will be handled as a callback */
+} tinyusb_config_cdcacm_t;
+
+/*********************************************************************** Other structs*/
+/* Public functions
+   ********************************************************************* */
+/**
+ * @brief Initialize CDC ACM. Initialization will be finished with
+ *          the `tud_cdc_line_state_cb` callback
+ *
+ * @param[in] cfg Configuration structure
+ * @return esp_err_t
+ */
+esp_err_t tusb_cdc_acm_init(const tinyusb_config_cdcacm_t *cfg);
+
+/**
+ * @brief De-initialize CDC ACM.
+ *
+ * @param[in] itf Index of CDC interface
+ * @return esp_err_t
+ */
+esp_err_t tusb_cdc_acm_deinit(int itf);
+
+/**
+ * @brief Register a callback invoking on CDC event. If the callback had been
+ *        already registered, it will be overwritten
+ *
+ * @param[in] itf        Index of CDC interface
+ * @param[in] event_type Type of registered event for a callback
+ * @param[in] callback   Callback function
+ * @return esp_err_t - ESP_OK or ESP_ERR_INVALID_ARG
+ */
+esp_err_t tinyusb_cdcacm_register_callback(tinyusb_cdcacm_itf_t itf,
+        cdcacm_event_type_t event_type,
+        tusb_cdcacm_callback_t callback);
+
+/**
+ * @brief Unregister a callback invoking on CDC event
+ *
+ * @param[in] itf        Index of CDC interface
+ * @param[in] event_type Type of registered event for a callback
+ * @return esp_err_t - ESP_OK or ESP_ERR_INVALID_ARG
+ */
+esp_err_t tinyusb_cdcacm_unregister_callback(tinyusb_cdcacm_itf_t itf, cdcacm_event_type_t event_type);
+
+/**
+ * @brief Sent one character to a write buffer
+ *
+ * @param[in] itf Index of CDC interface
+ * @param[in] ch  Character to send
+ * @return size_t - amount of queued bytes
+ */
+size_t tinyusb_cdcacm_write_queue_char(tinyusb_cdcacm_itf_t itf, char ch);
+
+/**
+ * @brief Write data to write buffer
+ *
+ * @param[in] itf     Index of CDC interface
+ * @param[in] in_buf  Data
+ * @param[in] in_size Data size in bytes
+ * @return size_t - amount of queued bytes
+ */
+size_t tinyusb_cdcacm_write_queue(tinyusb_cdcacm_itf_t itf, const uint8_t *in_buf, size_t in_size);
+
+/**
+ * @brief Flush data in write buffer of CDC interface
+ *
+ * Use `tinyusb_cdcacm_write_queue` to add data to the buffer
+ *
+ *        WARNING! TinyUSB can block output Endpoint for several RX callbacks, after will do additional flush
+ *        after the each transfer. That can leads to the situation when you requested a flush, but it will fail until
+ *        one of the next callbacks ends.
+ *        SO USING OF THE FLUSH WITH TIMEOUTS IN CALLBACKS IS NOT RECOMMENDED - YOU CAN GET A LOCK FOR THE TIMEOUT
+ *
+ * @param[in] itf             Index of CDC interface
+ * @param[in] timeout_ticks   Transfer timeout. Set to zero for non-blocking mode
+ * @return - ESP_OK           All data flushed
+ *         - ESP_ERR_TIMEOUT  Time out occurred in blocking mode
+ *         - ESP_NOT_FINISHED The transfer is still in progress in non-blocking mode
+ */
+esp_err_t tinyusb_cdcacm_write_flush(tinyusb_cdcacm_itf_t itf, uint32_t timeout_ticks);
+
+/**
+ * @brief Receive data from CDC interface
+ *
+ * @param[in] itf           Index of CDC interface
+ * @param[out] out_buf      Data buffer
+ * @param[in] out_buf_sz    Data buffer size in bytes
+ * @param[out] rx_data_size Number of bytes written to out_buf
+ * @return esp_err_t ESP_OK, ESP_FAIL or ESP_ERR_INVALID_STATE
+ */
+esp_err_t tinyusb_cdcacm_read(tinyusb_cdcacm_itf_t itf, uint8_t *out_buf, size_t out_buf_sz, size_t *rx_data_size);
+
+/**
+ * @brief Check if the CDC interface is initialized
+ *
+ * @param[in] itf  Index of CDC interface
+ * @return - true  Initialized
+ *         - false Not Initialized
+ */
+bool tusb_cdc_acm_initialized(tinyusb_cdcacm_itf_t itf);
+
+/*********************************************************************** Public functions*/
+
+#ifdef __cplusplus
+}
+#endif

managed_components/espressif__esp_tinyusb/include/tusb_config.h

@@ -0,0 +1,185 @@
+/*
+ * SPDX-FileCopyrightText: 2019 Ha Thach (tinyusb.org),
+ * SPDX-FileContributor: 2020-2025 Espressif Systems (Shanghai) CO LTD
+ * SPDX-License-Identifier: MIT
+ *
+ * Copyright (c) 2019 Ha Thach (tinyusb.org),
+ * Additions Copyright (c) 2020, Espressif Systems (Shanghai) PTE LTD
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#pragma once
+
+#include "tusb_option.h"
+#include "sdkconfig.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CONFIG_TINYUSB_CDC_ENABLED
+#   define CONFIG_TINYUSB_CDC_ENABLED 0
+#endif
+
+#ifndef CONFIG_TINYUSB_CDC_COUNT
+#   define CONFIG_TINYUSB_CDC_COUNT 0
+#endif
+
+#ifndef CONFIG_TINYUSB_MSC_ENABLED
+#   define CONFIG_TINYUSB_MSC_ENABLED 0
+#endif
+
+#ifndef CONFIG_TINYUSB_HID_COUNT
+#   define CONFIG_TINYUSB_HID_COUNT 0
+#endif
+
+#ifndef CONFIG_TINYUSB_MIDI_COUNT
+#   define CONFIG_TINYUSB_MIDI_COUNT 0
+#endif
+
+#ifndef CONFIG_TINYUSB_VENDOR_COUNT
+#   define CONFIG_TINYUSB_VENDOR_COUNT 0
+#endif
+
+#ifndef CONFIG_TINYUSB_NET_MODE_ECM_RNDIS
+#   define CONFIG_TINYUSB_NET_MODE_ECM_RNDIS 0
+#endif
+
+#ifndef CONFIG_TINYUSB_NET_MODE_NCM
+#   define CONFIG_TINYUSB_NET_MODE_NCM 0
+#endif
+
+#ifndef CONFIG_TINYUSB_DFU_MODE_DFU
+#   define CONFIG_TINYUSB_DFU_MODE_DFU 0
+#endif
+
+#ifndef CONFIG_TINYUSB_DFU_MODE_DFU_RUNTIME
+#   define CONFIG_TINYUSB_DFU_MODE_DFU_RUNTIME 0
+#endif
+
+#ifndef CONFIG_TINYUSB_BTH_ENABLED
+#   define CONFIG_TINYUSB_BTH_ENABLED 0
+#   define CONFIG_TINYUSB_BTH_ISO_ALT_COUNT 0
+#endif
+
+#ifndef CONFIG_TINYUSB_DEBUG_LEVEL
+#   define CONFIG_TINYUSB_DEBUG_LEVEL 0
+#endif
+
+#ifdef CONFIG_TINYUSB_RHPORT_HS
+#   define CFG_TUSB_RHPORT1_MODE    OPT_MODE_DEVICE | OPT_MODE_HIGH_SPEED
+#else
+#   define CFG_TUSB_RHPORT0_MODE    OPT_MODE_DEVICE | OPT_MODE_FULL_SPEED
+#endif
+
+// ------------------------------------------------------------------------
+//                              DCD DWC2 Mode
+// ------------------------------------------------------------------------
+#define CFG_TUD_DWC2_SLAVE_ENABLE   1       // Enable Slave/IRQ by default
+
+// ------------------------------------------------------------------------
+//                              DMA & Cache
+// ------------------------------------------------------------------------
+#ifdef CONFIG_TINYUSB_MODE_DMA
+// DMA Mode has a priority over Slave/IRQ mode and will be used if hardware supports it
+#define CFG_TUD_DWC2_DMA_ENABLE     1       // Enable DMA
+
+#if CONFIG_CACHE_L1_CACHE_LINE_SIZE
+// To enable the dcd_dcache clean/invalidate/clean_invalidate calls
+#   define CFG_TUD_MEM_DCACHE_ENABLE    1
+#define CFG_TUD_MEM_DCACHE_LINE_SIZE    CONFIG_CACHE_L1_CACHE_LINE_SIZE
+// NOTE: starting with esp-idf v5.3 there is specific attribute present: DRAM_DMA_ALIGNED_ATTR
+#   define CFG_TUSB_MEM_SECTION         __attribute__((aligned(CONFIG_CACHE_L1_CACHE_LINE_SIZE))) DRAM_ATTR
+#else
+#   define CFG_TUD_MEM_CACHE_ENABLE     0
+#   define CFG_TUSB_MEM_SECTION         TU_ATTR_ALIGNED(4) DRAM_ATTR
+#endif // CONFIG_CACHE_L1_CACHE_LINE_SIZE
+#endif // CONFIG_TINYUSB_MODE_DMA
+
+#define CFG_TUSB_OS                 OPT_OS_FREERTOS
+
+/* USB DMA on some MCUs can only access a specific SRAM region with restriction on alignment.
+ * Tinyusb use follows macros to declare transferring memory so that they can be put
+ * into those specific section.
+ * e.g
+ * - CFG_TUSB_MEM SECTION : __attribute__ (( section(".usb_ram") ))
+ * - CFG_TUSB_MEM_ALIGN   : __attribute__ ((aligned(4)))
+ */
+#ifndef CFG_TUSB_MEM_SECTION
+#   define CFG_TUSB_MEM_SECTION
+#endif
+
+#ifndef CFG_TUSB_MEM_ALIGN
+#   define CFG_TUSB_MEM_ALIGN       TU_ATTR_ALIGNED(4)
+#endif
+
+#ifndef CFG_TUD_ENDPOINT0_SIZE
+#define CFG_TUD_ENDPOINT0_SIZE      64
+#endif
+
+// Debug Level
+#define CFG_TUSB_DEBUG              CONFIG_TINYUSB_DEBUG_LEVEL
+#define CFG_TUSB_DEBUG_PRINTF       esp_rom_printf // TinyUSB can print logs from ISR, so we must use esp_rom_printf()
+
+// CDC FIFO size of TX and RX
+#define CFG_TUD_CDC_RX_BUFSIZE      CONFIG_TINYUSB_CDC_RX_BUFSIZE
+#define CFG_TUD_CDC_TX_BUFSIZE      CONFIG_TINYUSB_CDC_TX_BUFSIZE
+
+// MSC Buffer size of Device Mass storage
+#define CFG_TUD_MSC_BUFSIZE         CONFIG_TINYUSB_MSC_BUFSIZE
+
+// MIDI macros
+#define CFG_TUD_MIDI_EP_BUFSIZE     64
+#define CFG_TUD_MIDI_EPSIZE         CFG_TUD_MIDI_EP_BUFSIZE
+#define CFG_TUD_MIDI_RX_BUFSIZE     64
+#define CFG_TUD_MIDI_TX_BUFSIZE     64
+
+// Vendor FIFO size of TX and RX
+#define CFG_TUD_VENDOR_RX_BUFSIZE (TUD_OPT_HIGH_SPEED ? 512 : 64)
+#define CFG_TUD_VENDOR_TX_BUFSIZE (TUD_OPT_HIGH_SPEED ? 512 : 64)
+
+// DFU macros
+#define CFG_TUD_DFU_XFER_BUFSIZE    CONFIG_TINYUSB_DFU_BUFSIZE
+
+// Number of BTH ISO alternatives
+#define CFG_TUD_BTH_ISO_ALT_COUNT   CONFIG_TINYUSB_BTH_ISO_ALT_COUNT
+
+// Enabled device class driver
+#define CFG_TUD_CDC                 CONFIG_TINYUSB_CDC_COUNT
+#define CFG_TUD_MSC                 CONFIG_TINYUSB_MSC_ENABLED
+#define CFG_TUD_HID                 CONFIG_TINYUSB_HID_COUNT
+#define CFG_TUD_MIDI                CONFIG_TINYUSB_MIDI_COUNT
+#define CFG_TUD_VENDOR              CONFIG_TINYUSB_VENDOR_COUNT
+#define CFG_TUD_ECM_RNDIS           CONFIG_TINYUSB_NET_MODE_ECM_RNDIS
+#define CFG_TUD_NCM                 CONFIG_TINYUSB_NET_MODE_NCM
+#define CFG_TUD_DFU                 CONFIG_TINYUSB_DFU_MODE_DFU
+#define CFG_TUD_DFU_RUNTIME         CONFIG_TINYUSB_DFU_MODE_DFU_RUNTIME
+#define CFG_TUD_BTH                 CONFIG_TINYUSB_BTH_ENABLED
+
+// NCM NET Mode NTB buffers configuration
+#define CFG_TUD_NCM_OUT_NTB_N         CONFIG_TINYUSB_NCM_OUT_NTB_BUFFS_COUNT
+#define CFG_TUD_NCM_IN_NTB_N          CONFIG_TINYUSB_NCM_IN_NTB_BUFFS_COUNT
+#define CFG_TUD_NCM_OUT_NTB_MAX_SIZE  CONFIG_TINYUSB_NCM_OUT_NTB_BUFF_MAX_SIZE
+#define CFG_TUD_NCM_IN_NTB_MAX_SIZE   CONFIG_TINYUSB_NCM_IN_NTB_BUFF_MAX_SIZE
+
+#ifdef __cplusplus
+}
+#endif

managed_components/espressif__esp_tinyusb/include/tusb_console.h

@@ -0,0 +1,33 @@
+/*
+ * SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "esp_err.h"
+
+/**
+ * @brief Redirect output to the USB serial
+ * @param cdc_intf - interface number of TinyUSB's CDC
+ *
+ * @return esp_err_t - ESP_OK, ESP_FAIL or an error code
+ */
+esp_err_t esp_tusb_init_console(int cdc_intf);
+
+/**
+ * @brief Switch log to the default output
+ * @param cdc_intf - interface number of TinyUSB's CDC
+ *
+ * @return esp_err_t
+ */
+esp_err_t esp_tusb_deinit_console(int cdc_intf);
+
+#ifdef __cplusplus
+}
+#endif

managed_components/espressif__esp_tinyusb/include/tusb_msc_storage.h

@@ -0,0 +1,190 @@
+/*
+ * SPDX-FileCopyrightText: 2023-2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include "esp_err.h"
+#include "wear_levelling.h"
+#include "esp_vfs_fat.h"
+#if SOC_SDMMC_HOST_SUPPORTED
+#include "driver/sdmmc_host.h"
+#endif
+
+/**
+ * @brief Data provided to the input of the `callback_mount_changed` and `callback_premount_changed` callback
+ */
+typedef struct {
+    bool is_mounted;                        /*!< Flag if storage is mounted or not */
+} tinyusb_msc_event_mount_changed_data_t;
+
+/**
+ * @brief Types of MSC events
+ */
+typedef enum {
+    TINYUSB_MSC_EVENT_MOUNT_CHANGED,        /*!< Event type AFTER mount/unmount operation is successfully finished */
+    TINYUSB_MSC_EVENT_PREMOUNT_CHANGED      /*!< Event type BEFORE mount/unmount operation is started */
+} tinyusb_msc_event_type_t;
+
+/**
+ * @brief Describes an event passing to the input of a callbacks
+ */
+typedef struct {
+    tinyusb_msc_event_type_t type; /*!< Event type */
+    union {
+        tinyusb_msc_event_mount_changed_data_t mount_changed_data; /*!< Data input of the callback */
+    };
+} tinyusb_msc_event_t;
+
+/**
+ * @brief MSC callback that is delivered whenever a specific event occurs.
+ */
+typedef void(*tusb_msc_callback_t)(tinyusb_msc_event_t *event);
+
+#if SOC_SDMMC_HOST_SUPPORTED
+/**
+ * @brief Configuration structure for sdmmc initialization
+ *
+ * User configurable parameters that are used while
+ * initializing the sdmmc media.
+ */
+typedef struct {
+    sdmmc_card_t *card;                             /*!< Pointer to sdmmc card configuration structure */
+    tusb_msc_callback_t callback_mount_changed;     /*!< Pointer to the function callback that will be delivered AFTER mount/unmount operation is successfully finished */
+    tusb_msc_callback_t callback_premount_changed;  /*!< Pointer to the function callback that will be delivered BEFORE mount/unmount operation is started */
+    const esp_vfs_fat_mount_config_t mount_config; /*!< FATFS mount config */
+} tinyusb_msc_sdmmc_config_t;
+#endif
+
+/**
+ * @brief Configuration structure for spiflash initialization
+ *
+ * User configurable parameters that are used while
+ * initializing the SPI Flash media.
+ */
+typedef struct {
+    wl_handle_t wl_handle;                          /*!< Pointer to spiflash wera-levelling handle */
+    tusb_msc_callback_t callback_mount_changed;     /*!< Pointer to the function callback that will be delivered AFTER mount/unmount operation is successfully finished */
+    tusb_msc_callback_t callback_premount_changed;  /*!< Pointer to the function callback that will be delivered BEFORE mount/unmount operation is started */
+    const esp_vfs_fat_mount_config_t mount_config; /*!< FATFS mount config */
+} tinyusb_msc_spiflash_config_t;
+
+/**
+ * @brief Register storage type spiflash with tinyusb driver
+ *
+ * @param config pointer to the spiflash configuration
+ * @return esp_err_t
+ *       - ESP_OK, if success;
+ *       - ESP_ERR_NO_MEM, if there was no memory to allocate storage components;
+ *       - ESP_ERR_NOT_SUPPORTED, if wear leveling sector size CONFIG_WL_SECTOR_SIZE is bigger than
+ *                                the tinyusb MSC buffer size CONFIG_TINYUSB_MSC_BUFSIZE
+ */
+esp_err_t tinyusb_msc_storage_init_spiflash(const tinyusb_msc_spiflash_config_t *config);
+
+#if SOC_SDMMC_HOST_SUPPORTED
+/**
+ * @brief Register storage type sd-card with tinyusb driver
+ *
+ * @param config pointer to the sd card configuration
+ * @return esp_err_t
+ *       - ESP_OK, if success;
+ *       - ESP_ERR_NO_MEM, if there was no memory to allocate storage components;
+ */
+esp_err_t tinyusb_msc_storage_init_sdmmc(const tinyusb_msc_sdmmc_config_t *config);
+#endif
+/**
+ * @brief Deregister storage with tinyusb driver and frees the memory
+ *
+ */
+void tinyusb_msc_storage_deinit(void);
+
+/**
+ * @brief Register a callback invoking on MSC event. If the callback had been
+ *        already registered, it will be overwritten
+ *
+ * @param event_type - type of registered event for a callback
+ * @param callback  - callback function
+ * @return esp_err_t - ESP_OK or ESP_ERR_INVALID_ARG
+ */
+esp_err_t tinyusb_msc_register_callback(tinyusb_msc_event_type_t event_type,
+                                        tusb_msc_callback_t callback);
+
+
+/**
+ * @brief Unregister a callback invoking on MSC event.
+ *
+ * @param event_type - type of registered event for a callback
+ * @return esp_err_t - ESP_OK or ESP_ERR_INVALID_ARG
+ */
+esp_err_t tinyusb_msc_unregister_callback(tinyusb_msc_event_type_t event_type);
+
+/**
+ * @brief Mount the storage partition locally on the firmware application.
+ *
+ * Get the available drive number. Register spi flash partition.
+ * Connect POSIX and C standard library IO function with FATFS.
+ * Mounts the partition.
+ * This API is used by the firmware application. If the storage partition is
+ * mounted by this API, host (PC) can't access the storage via MSC.
+ * When this function is called from the tinyusb callback functions, care must be taken
+ * so as to make sure that user callbacks must be completed within a
+ * specific time. Otherwise, MSC device may re-appear again on Host.
+ *
+ * @param base_path  path prefix where FATFS should be registered
+ * @return esp_err_t
+ *       - ESP_OK, if success;
+ *       - ESP_ERR_NOT_FOUND if the maximum count of volumes is already mounted
+ *       - ESP_ERR_NO_MEM if not enough memory or too many VFSes already registered;
+ */
+esp_err_t tinyusb_msc_storage_mount(const char *base_path);
+
+/**
+ * @brief Unmount the storage partition from the firmware application.
+ *
+ * Unmount the partition. Unregister diskio driver.
+ * Unregister the SPI flash partition.
+ * Finally, Un-register FATFS from VFS.
+ * After this function is called, storage device can be seen (recognized) by host (PC).
+ * When this function is called from the tinyusb callback functions, care must be taken
+ * so as to make sure that user callbacks must be completed within a specific time.
+ * Otherwise, MSC device may not appear on Host.
+ *
+ * @return esp_err_t
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_STATE if FATFS is not registered in VFS
+ */
+esp_err_t tinyusb_msc_storage_unmount(void);
+
+/**
+ * @brief Get number of sectors in storage media
+ *
+ * @return usable size, in bytes
+ */
+uint32_t tinyusb_msc_storage_get_sector_count(void);
+
+/**
+ * @brief Get sector size of storage media
+ *
+ * @return sector count
+ */
+uint32_t tinyusb_msc_storage_get_sector_size(void);
+
+/**
+ * @brief Get status if storage media is exposed over USB to Host
+ *
+ * @return bool
+ *      - true, if the storage media is exposed to Host
+ *      - false, if the stoarge media is mounted on application (not exposed to Host)
+ */
+bool tinyusb_msc_storage_in_use_by_usb_host(void);
+
+#ifdef __cplusplus
+}
+#endif

managed_components/espressif__esp_tinyusb/include/tusb_tasks.h

@@ -0,0 +1,39 @@
+/*
+ * SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "esp_err.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief This helper function creates and starts a task which wraps `tud_task()`.
+ *
+ * The wrapper function basically wraps tud_task and some log.
+ * Default parameters: stack size and priority as configured, argument = NULL, not pinned to any core.
+ * If you have more requirements for this task, you can create your own task which calls tud_task as the last step.
+ *
+ * @retval ESP_OK run tinyusb main task successfully
+ * @retval ESP_FAIL run tinyusb main task failed of internal error or initialization within the task failed when TINYUSB_INIT_IN_DEFAULT_TASK=y
+ * @retval ESP_FAIL initialization within the task failed if CONFIG_TINYUSB_INIT_IN_DEFAULT_TASK is enabled
+ * @retval ESP_ERR_INVALID_STATE tinyusb main task has been created before
+ */
+esp_err_t tusb_run_task(void);
+
+/**
+ * @brief This helper function stops and destroys the task created by `tusb_run_task()`
+ *
+ * @retval ESP_OK stop and destroy tinyusb main task successfully
+ * @retval ESP_ERR_INVALID_STATE tinyusb main task hasn't been created yet
+ */
+esp_err_t tusb_stop_task(void);
+
+#ifdef __cplusplus
+}
+#endif

managed_components/espressif__esp_tinyusb/include/vfs_tinyusb.h

@@ -0,0 +1,69 @@
+/*
+ * SPDX-FileCopyrightText: 2020-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "esp_err.h"
+#include "esp_vfs_common.h" // For esp_line_endings_t definitions
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define VFS_TUSB_MAX_PATH 16
+#define VFS_TUSB_PATH_DEFAULT "/dev/tusb_cdc"
+
+/**
+ * @brief Register TinyUSB CDC at VFS with path
+ *
+ * Know limitation:
+ * In case there are multiple CDC interfaces in the system, only one of them can be registered to VFS.
+ *
+ * @param[in] cdc_intf Interface number of TinyUSB's CDC
+ * @param[in] path     Path where the CDC will be registered, `/dev/tusb_cdc` will be used if left NULL.
+ * @return esp_err_t ESP_OK or ESP_FAIL
+ */
+esp_err_t esp_vfs_tusb_cdc_register(int cdc_intf, char const *path);
+
+/**
+ * @brief Unregister TinyUSB CDC from VFS
+ *
+ * @param[in] path Path where the CDC will be unregistered if NULL will be used `/dev/tusb_cdc`
+ * @return esp_err_t ESP_OK or ESP_FAIL
+ */
+esp_err_t esp_vfs_tusb_cdc_unregister(char const *path);
+
+/**
+ * @brief Set the line endings to sent
+ *
+ * This specifies the conversion between newlines ('\n', LF) on stdout and line
+ * endings sent:
+ *
+ * - ESP_LINE_ENDINGS_CRLF: convert LF to CRLF
+ * - ESP_LINE_ENDINGS_CR: convert LF to CR
+ * - ESP_LINE_ENDINGS_LF: no modification
+ *
+ * @param[in] mode line endings to send
+ */
+void esp_vfs_tusb_cdc_set_tx_line_endings(esp_line_endings_t mode);
+
+/**
+ * @brief Set the line endings expected to be received
+ *
+ * This specifies the conversion between line endings received and
+ * newlines ('\n', LF) passed into stdin:
+ *
+ * - ESP_LINE_ENDINGS_CRLF: convert CRLF to LF
+ * - ESP_LINE_ENDINGS_CR: convert CR to LF
+ * - ESP_LINE_ENDINGS_LF: no modification
+ *
+ * @param[in] mode line endings expected
+ */
+void esp_vfs_tusb_cdc_set_rx_line_endings(esp_line_endings_t mode);
+
+#ifdef __cplusplus
+}
+#endif