Merge pull request #1 from espressif/master

pull

components/bt/controller/esp32h2/bt.c

@@ -568,7 +568,7 @@ void controller_sleep_deinit(void)
 }
 
 #if CONFIG_IDF_TARGET_ESP32H2_BETA_VERSION_2
-void periph_module_etm_active()
+void periph_module_etm_active(void)
 {
     /*This part for esp32h2 beta2*/
     REG_SET_BIT(SYSTEM_MODCLK_CONF_REG, SYSTEM_ETM_CLK_SEL | SYSTEM_ETM_CLK_ACTIVE ); //Active ETM clock

components/driver/deprecated/i2s_legacy.c

@@ -200,16 +200,16 @@ static bool IRAM_ATTR i2s_dma_tx_callback(gdma_channel_handle_t dma_chan, gdma_e
         if (xQueueIsQueueFullFromISR(p_i2s->tx->queue)) {
             xQueueReceiveFromISR(p_i2s->tx->queue, &dummy, &tmp);
             need_awoke |= tmp;
-            if (p_i2s->tx_desc_auto_clear) {
-                memset((void *) dummy, 0, p_i2s->tx->buf_size);
-            }
             if (p_i2s->i2s_queue) {
                 i2s_event.type = I2S_EVENT_TX_Q_OVF;
                 i2s_event.size = p_i2s->tx->buf_size;
                 xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
                 need_awoke |= tmp;
             }
         }
+        if (p_i2s->tx_desc_auto_clear) {
+            memset((void *) (((lldesc_t *)finish_desc)->buf), 0, p_i2s->tx->buf_size);
+        }
         xQueueSendFromISR(p_i2s->tx->queue, &(((lldesc_t *)finish_desc)->buf), &tmp);
         need_awoke |= tmp;
         if (p_i2s->i2s_queue) {
@@ -256,18 +256,18 @@ static void IRAM_ATTR i2s_intr_handler_default(void *arg)
         if (xQueueIsQueueFullFromISR(p_i2s->tx->queue)) {
             xQueueReceiveFromISR(p_i2s->tx->queue, &dummy, &tmp);
             need_awoke |= tmp;
-            // See if tx descriptor needs to be auto cleared:
-            // This will avoid any kind of noise that may get introduced due to transmission
-            // of previous data from tx descriptor on I2S line.
-            if (p_i2s->tx_desc_auto_clear == true) {
-                memset((void *) dummy, 0, p_i2s->tx->buf_size);
-            }
             if (p_i2s->i2s_queue) {
                 i2s_event.type = I2S_EVENT_TX_Q_OVF;
                 xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
                 need_awoke |= tmp;
             }
         }
+        // See if tx descriptor needs to be auto cleared:
+        // This will avoid any kind of noise that may get introduced due to transmission
+        // of previous data from tx descriptor on I2S line.
+        if (p_i2s->tx_desc_auto_clear == true) {
+            memset((void *)(((lldesc_t *)finish_desc)->buf), 0, p_i2s->tx->buf_size);
+        }
         xQueueSendFromISR(p_i2s->tx->queue, &(((lldesc_t *)finish_desc)->buf), &tmp);
         need_awoke |= tmp;
         if (p_i2s->i2s_queue) {

components/driver/i2s/i2s_common.c

@@ -547,12 +547,11 @@ static bool IRAM_ATTR i2s_dma_tx_callback(gdma_channel_handle_t dma_chan, gdma_e
             user_need_yield |= handle->callbacks.on_send_q_ovf(handle, &evt, handle->user_data);
         }
     }
-    xQueueSendFromISR(handle->msg_queue, &(finish_desc->buf), &need_yield2);
-
     if (handle->dma.auto_clear) {
         uint8_t *sent_buf = (uint8_t *)finish_desc->buf;
         memset(sent_buf, 0, handle->dma.buf_size);
     }
+    xQueueSendFromISR(handle->msg_queue, &(finish_desc->buf), &need_yield2);
 
     return need_yield1 | need_yield2 | user_need_yield;
 }
@@ -627,12 +626,12 @@ static void IRAM_ATTR i2s_dma_tx_callback(void *arg)
                 user_need_yield |= handle->callbacks.on_send_q_ovf(handle, &evt, handle->user_data);
             }
         }
-        xQueueSendFromISR(handle->msg_queue, &(finish_desc->buf), &need_yield2);
         // Auto clear the dma buffer after data sent
         if (handle->dma.auto_clear) {
             uint8_t *buff = (uint8_t *)finish_desc->buf;
             memset(buff, 0, handle->dma.buf_size);
         }
+        xQueueSendFromISR(handle->msg_queue, &(finish_desc->buf), &need_yield2);
     }
 
     if (need_yield1 || need_yield2 || user_need_yield) {

components/esp_http_client/lib/http_header.c

@@ -159,9 +159,6 @@ int http_header_set_format(http_header_handle_t header, const char *key, const c
     len = vasprintf(&buf, format, argptr);
     va_end(argptr);
     ESP_RETURN_ON_FALSE(buf, 0, TAG, "Memory exhausted");
-    if (buf == NULL) {
-        return 0;
-    }
     http_header_set(header, key, buf);
     free(buf);
     return len;

components/esp_http_server/src/httpd_main.c

@@ -55,12 +55,16 @@ static esp_err_t httpd_accept_conn(struct httpd_data *hd, int listen_fd)
     /* Set recv timeout of this fd as per config */
     tv.tv_sec = hd->config.recv_wait_timeout;
     tv.tv_usec = 0;
-    setsockopt(new_fd, SOL_SOCKET, SO_RCVTIMEO, (const char *)&tv, sizeof(tv));
+    if (setsockopt(new_fd, SOL_SOCKET, SO_RCVTIMEO, (const char *)&tv, sizeof(tv)) < 0) {
+        ESP_LOGW(TAG, LOG_FMT("error enabling SO_RCVTIMEO (%d)"), errno);
+    }
 
     /* Set send timeout of this fd as per config */
     tv.tv_sec = hd->config.send_wait_timeout;
     tv.tv_usec = 0;
-    setsockopt(new_fd, SOL_SOCKET, SO_SNDTIMEO, (const char *)&tv, sizeof(tv));
+    if (setsockopt(new_fd, SOL_SOCKET, SO_SNDTIMEO, (const char *)&tv, sizeof(tv)) < 0) {
+        ESP_LOGW(TAG, LOG_FMT("error enabling SO_SNDTIMEO (%d)"), errno);
+    }
 
     if (ESP_OK != httpd_sess_new(hd, new_fd)) {
         ESP_LOGW(TAG, LOG_FMT("session creation failed"));

components/esp_http_server/src/httpd_parse.c

@@ -63,8 +63,9 @@ static esp_err_t verify_url (http_parser *parser)
     const char *at = parser_data->last.at;
     size_t  length = parser_data->last.length;
 
-    if ((r->method = parser->method) < 0) {
-        ESP_LOGW(TAG, LOG_FMT("HTTP Operation not supported"));
+    r->method = parser->method;
+    if (r->method < 0) {
+        ESP_LOGW(TAG, LOG_FMT("HTTP method not supported (%d)"), r->method);
         parser_data->error = HTTPD_501_METHOD_NOT_IMPLEMENTED;
         return ESP_FAIL;
     }
@@ -618,8 +619,8 @@ static esp_err_t httpd_parse_req(struct httpd_data *hd)
 {
     httpd_req_t *r = &hd->hd_req;
     int blk_len,  offset;
-    http_parser   parser;
-    parser_data_t parser_data;
+    http_parser   parser = {};
+    parser_data_t parser_data = {};
 
     /* Initialize parser */
     parse_init(r, &parser, &parser_data);

components/esp_http_server/src/httpd_sess.c

@@ -359,7 +359,9 @@ void httpd_sess_delete(struct httpd_data *hd, struct sock_db *session)
             .l_onoff = true,
             .l_linger = hd->config.linger_timeout,
         };
-        setsockopt(session->fd, SOL_SOCKET, SO_LINGER, &so_linger, sizeof(struct linger));
+        if (setsockopt(session->fd, SOL_SOCKET, SO_LINGER, &so_linger, sizeof(struct linger)) < 0) {
+            ESP_LOGW(TAG, LOG_FMT("error enabling SO_LINGER (%d)"), errno);
+        }
     }
 
     // Call close function if defined

components/esp_lcd/include/esp_lcd_panel_io.h

@@ -23,7 +23,7 @@ typedef struct esp_lcd_i80_bus_t *esp_lcd_i80_bus_handle_t;   /*!< Type of LCD i
  * @brief Transmit LCD command and receive corresponding parameters
  *
  * @note Commands sent by this function are short, so they are sent using polling transactions.
- *       The function does not return before the command tranfer is completed.
+ *       The function does not return before the command transfer is completed.
  *       If any queued transactions sent by `esp_lcd_panel_io_tx_color()` are still pending when this function is called,
  *       this function will wait until they are finished and the queue is empty before sending the command(s).
  *
@@ -42,7 +42,7 @@ esp_err_t esp_lcd_panel_io_rx_param(esp_lcd_panel_io_handle_t io, int lcd_cmd, v
  * @brief Transmit LCD command and corresponding parameters
  *
  * @note Commands sent by this function are short, so they are sent using polling transactions.
- *       The function does not return before the command tranfer is completed.
+ *       The function does not return before the command transfer is completed.
  *       If any queued transactions sent by `esp_lcd_panel_io_tx_color()` are still pending when this function is called,
  *       this function will wait until they are finished and the queue is empty before sending the command(s).
  *
@@ -65,7 +65,7 @@ esp_err_t esp_lcd_panel_io_tx_param(esp_lcd_panel_io_handle_t io, int lcd_cmd, c
  *       Recycling of color buffer should be done in the callback `on_color_trans_done()`.
  *
  * @param[in] io LCD panel IO handle, which is created by factory API like `esp_lcd_new_panel_io_spi()`
- * @param[in] lcd_cmd The specific LCD command
+ * @param[in] lcd_cmd The specific LCD command, set to -1 if no command needed
  * @param[in] color Buffer that holds the RGB color data
  * @param[in] color_size Size of `color` in memory, in bytes
  * @return
@@ -75,7 +75,7 @@ esp_err_t esp_lcd_panel_io_tx_param(esp_lcd_panel_io_handle_t io, int lcd_cmd, c
 esp_err_t esp_lcd_panel_io_tx_color(esp_lcd_panel_io_handle_t io, int lcd_cmd, const void *color, size_t color_size);
 
 /**
- * @brief Destory LCD panel IO handle (deinitialize panel and free all corresponding resource)
+ * @brief Destroy LCD panel IO handle (deinitialize panel and free all corresponding resource)
  *
  * @param[in] io LCD panel IO handle, which is created by factory API like `esp_lcd_new_panel_io_spi()`
  * @return
@@ -105,7 +105,7 @@ typedef bool (*esp_lcd_panel_io_color_trans_done_cb_t)(esp_lcd_panel_io_handle_t
  */
 typedef struct {
     int cs_gpio_num; /*!< GPIO used for CS line */
-    int dc_gpio_num; /*!< GPIO used to select the D/C line, set this to -1 if the D/C line not controlled by manually pulling high/low GPIO */
+    int dc_gpio_num; /*!< GPIO used to select the D/C line, set this to -1 if the D/C line is not used */
     int spi_mode;    /*!< Traditional SPI mode (0~3) */
     unsigned int pclk_hz;    /*!< Frequency of pixel clock */
     size_t trans_queue_depth; /*!< Size of internal transaction queue */
@@ -117,6 +117,7 @@ typedef struct {
         unsigned int dc_low_on_data: 1;  /*!< If this flag is enabled, DC line = 0 means transfer data, DC line = 1 means transfer command; vice versa */
         unsigned int octal_mode: 1;      /*!< transmit with octal mode (8 data lines), this mode is used to simulate Intel 8080 timing */
         unsigned int lsb_first: 1;       /*!< transmit LSB bit first */
+        unsigned int cs_high_active: 1;  /*!< CS line is high active */
     } flags; /*!< Extra flags to fine-tune the SPI device */
 } esp_lcd_panel_io_spi_config_t;
 
@@ -141,7 +142,7 @@ typedef struct {
     uint32_t dev_addr; /*!< I2C device address */
     esp_lcd_panel_io_color_trans_done_cb_t on_color_trans_done; /*!< Callback invoked when color data transfer has finished */
     void *user_ctx; /*!< User private data, passed directly to on_color_trans_done's user_ctx */
-    size_t control_phase_bytes; /*!< I2C LCD panel will encode control information (e.g. D/C seclection) into control phase, in several bytes */
+    size_t control_phase_bytes; /*!< I2C LCD panel will encode control information (e.g. D/C selection) into control phase, in several bytes */
     unsigned int dc_bit_offset; /*!< Offset of the D/C selection bit in control phase */
     int lcd_cmd_bits;           /*!< Bit-width of LCD command */
     int lcd_param_bits;         /*!< Bit-width of LCD parameter */
@@ -193,7 +194,7 @@ typedef struct {
 esp_err_t esp_lcd_new_i80_bus(const esp_lcd_i80_bus_config_t *bus_config, esp_lcd_i80_bus_handle_t *ret_bus);
 
 /**
- * @brief Destory Intel 8080 bus handle
+ * @brief Destroy Intel 8080 bus handle
  *
  * @param[in] bus Intel 8080 bus handle, created by `esp_lcd_new_i80_bus()`
  * @return
@@ -210,7 +211,7 @@ typedef struct {
     int cs_gpio_num;         /*!< GPIO used for CS line, set to -1 will declaim exclusively use of I80 bus */
     uint32_t pclk_hz;        /*!< Frequency of pixel clock */
     size_t trans_queue_depth; /*!< Transaction queue size, larger queue, higher throughput */
-    esp_lcd_panel_io_color_trans_done_cb_t on_color_trans_done; /*!< Callback invoked when color data was tranferred done */
+    esp_lcd_panel_io_color_trans_done_cb_t on_color_trans_done; /*!< Callback invoked when color data was transferred done */
     void *user_ctx;    /*!< User private data, passed directly to on_color_trans_done's user_ctx */
     int lcd_cmd_bits;   /*!< Bit-width of LCD command */
     int lcd_param_bits; /*!< Bit-width of LCD parameter */

components/esp_lcd/src/esp_lcd_panel_io_spi.c

@@ -66,14 +66,13 @@ esp_err_t esp_lcd_new_panel_io_spi(esp_lcd_spi_bus_handle_t bus, const esp_lcd_p
     esp_err_t ret = ESP_OK;
     esp_lcd_panel_io_spi_t *spi_panel_io = NULL;
     ESP_GOTO_ON_FALSE(bus && io_config && ret_io, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
-    // at the moment, the hardware doesn't support 9-bit SPI LCD, but in the future, there will be such a feature
-    // so for now, we will force the user to use the GPIO to control the LCD's D/C line.
-    ESP_GOTO_ON_FALSE(io_config->dc_gpio_num >= 0, ESP_ERR_INVALID_ARG, err, TAG, "invalid DC mode");
     spi_panel_io = calloc(1, sizeof(esp_lcd_panel_io_spi_t) + sizeof(lcd_spi_trans_descriptor_t) * io_config->trans_queue_depth);
     ESP_GOTO_ON_FALSE(spi_panel_io, ESP_ERR_NO_MEM, err, TAG, "no mem for spi panel io");
 
     spi_device_interface_config_t devcfg = {
-        .flags = SPI_DEVICE_HALFDUPLEX | (io_config->flags.lsb_first ? SPI_DEVICE_TXBIT_LSBFIRST : 0),
+        .flags = SPI_DEVICE_HALFDUPLEX |
+        (io_config->flags.lsb_first ? SPI_DEVICE_TXBIT_LSBFIRST : 0) |
+        (io_config->flags.cs_high_active ? SPI_DEVICE_POSITIVE_CS : 0),
         .clock_speed_hz = io_config->pclk_hz,
         .mode = io_config->spi_mode,
         .spics_io_num = io_config->cs_gpio_num,
@@ -191,7 +190,7 @@ static esp_err_t panel_io_spi_tx_param(esp_lcd_panel_io_t *io, int lcd_cmd, cons
     }
     lcd_trans = &spi_panel_io->trans_pool[0];
     memset(lcd_trans, 0, sizeof(lcd_spi_trans_descriptor_t));
-    spi_lcd_prepare_cmd_buffer(spi_panel_io, &lcd_cmd);
+
     lcd_trans->base.user = spi_panel_io;
     lcd_trans->base.flags |= SPI_TRANS_CS_KEEP_ACTIVE;
     if (spi_panel_io->flags.octal_mode) {
@@ -200,6 +199,7 @@ static esp_err_t panel_io_spi_tx_param(esp_lcd_panel_io_t *io, int lcd_cmd, cons
     }
 
     if (send_cmd) {
+        spi_lcd_prepare_cmd_buffer(spi_panel_io, &lcd_cmd);
         lcd_trans->flags.dc_gpio_level = !spi_panel_io->flags.dc_data_level; // set D/C line to command mode
         lcd_trans->base.length = spi_panel_io->lcd_cmd_bits;
         lcd_trans->base.tx_buffer = &lcd_cmd;
@@ -244,7 +244,7 @@ static esp_err_t panel_io_spi_rx_param(esp_lcd_panel_io_t *io, int lcd_cmd, void
     }
     lcd_trans = &spi_panel_io->trans_pool[0];
     memset(lcd_trans, 0, sizeof(lcd_spi_trans_descriptor_t));
-    spi_lcd_prepare_cmd_buffer(spi_panel_io, &lcd_cmd);
+
     lcd_trans->base.user = spi_panel_io;
     lcd_trans->base.flags |= SPI_TRANS_CS_KEEP_ACTIVE;
     if (spi_panel_io->flags.octal_mode) {
@@ -253,6 +253,7 @@ static esp_err_t panel_io_spi_rx_param(esp_lcd_panel_io_t *io, int lcd_cmd, void
     }
 
     if (send_cmd) {
+        spi_lcd_prepare_cmd_buffer(spi_panel_io, &lcd_cmd);
         lcd_trans->flags.dc_gpio_level = !spi_panel_io->flags.dc_data_level; // set D/C line to command mode
         lcd_trans->base.length = spi_panel_io->lcd_cmd_bits;
         lcd_trans->base.tx_buffer = &lcd_cmd;
@@ -285,6 +286,7 @@ static esp_err_t panel_io_spi_tx_color(esp_lcd_panel_io_t *io, int lcd_cmd, cons
     spi_transaction_t *spi_trans = NULL;
     lcd_spi_trans_descriptor_t *lcd_trans = NULL;
     esp_lcd_panel_io_spi_t *spi_panel_io = __containerof(io, esp_lcd_panel_io_spi_t, base);
+    bool send_cmd = (lcd_cmd >= 0);
 
     // before issue a polling transaction, need to wait queued transactions finished
     size_t num_trans_inflight = spi_panel_io->num_trans_inflight;
@@ -295,18 +297,21 @@ static esp_err_t panel_io_spi_tx_color(esp_lcd_panel_io_t *io, int lcd_cmd, cons
     }
     lcd_trans = &spi_panel_io->trans_pool[0];
     memset(lcd_trans, 0, sizeof(lcd_spi_trans_descriptor_t));
-    spi_lcd_prepare_cmd_buffer(spi_panel_io, &lcd_cmd);
-    lcd_trans->base.user = spi_panel_io;
-    lcd_trans->flags.dc_gpio_level = !spi_panel_io->flags.dc_data_level; // set D/C line to command mode
-    lcd_trans->base.length = spi_panel_io->lcd_cmd_bits;
-    lcd_trans->base.tx_buffer = &lcd_cmd;
-    if (spi_panel_io->flags.octal_mode) {
-        // use 8 lines for transmitting command, address and data
-        lcd_trans->base.flags |= (SPI_TRANS_MULTILINE_CMD | SPI_TRANS_MULTILINE_ADDR | SPI_TRANS_MODE_OCT);
+
+    if (send_cmd) {
+        spi_lcd_prepare_cmd_buffer(spi_panel_io, &lcd_cmd);
+        lcd_trans->base.user = spi_panel_io;
+        lcd_trans->flags.dc_gpio_level = !spi_panel_io->flags.dc_data_level; // set D/C line to command mode
+        lcd_trans->base.length = spi_panel_io->lcd_cmd_bits;
+        lcd_trans->base.tx_buffer = &lcd_cmd;
+        if (spi_panel_io->flags.octal_mode) {
+            // use 8 lines for transmitting command, address and data
+            lcd_trans->base.flags |= (SPI_TRANS_MULTILINE_CMD | SPI_TRANS_MULTILINE_ADDR | SPI_TRANS_MODE_OCT);
+        }
+        // command is short, using polling mode
+        ret = spi_device_polling_transmit(spi_panel_io->spi_dev, &lcd_trans->base);
+        ESP_GOTO_ON_ERROR(ret, err, TAG, "spi transmit (polling) command failed");
     }
-    // command is short, using polling mode
-    ret = spi_device_polling_transmit(spi_panel_io->spi_dev, &lcd_trans->base);
-    ESP_GOTO_ON_ERROR(ret, err, TAG, "spi transmit (polling) command failed");
 
     // split to chunks if required:
     // the SPI bus has a maximum transaction size determined by SPI_LL_DATA_MAX_BIT_LEN

components/esp_rom/esp32c2/ld/esp32c2.rom.api.ld

@@ -38,6 +38,7 @@ PROVIDE ( esp_rom_software_reset_system = software_reset );
 PROVIDE ( esp_rom_software_reset_cpu    = software_reset_cpu );
 
 PROVIDE ( esp_rom_printf   = ets_printf );
+PROVIDE ( esp_rom_install_uart_printf = ets_install_uart_printf );
 PROVIDE ( esp_rom_delay_us = ets_delay_us );
 PROVIDE ( esp_rom_get_reset_reason = rtc_get_reset_reason );
 PROVIDE ( esp_rom_route_intr_matrix = intr_matrix_set );

components/esp_rom/esp32c3/Kconfig.soc_caps.in

@@ -46,3 +46,7 @@ config ESP_ROM_HAS_LAYOUT_TABLE
 config ESP_ROM_HAS_SPI_FLASH
     bool
     default y
+
+config ESP_ROM_HAS_ETS_PRINTF_BUG
+    bool
+    default y

components/esp_rom/esp32c3/esp_rom_caps.h

@@ -17,3 +17,4 @@
 #define ESP_ROM_NEEDS_SWSETUP_WORKAROUND    (1) // ROM uses 32-bit time_t. A workaround is required to prevent printf functions from crashing
 #define ESP_ROM_HAS_LAYOUT_TABLE            (1) // ROM has the layout table
 #define ESP_ROM_HAS_SPI_FLASH               (1) // ROM has the implementation of SPI Flash driver
+#define ESP_ROM_HAS_ETS_PRINTF_BUG          (1) // ROM has ets_printf bug when disable the ROM log either by eFuse or RTC storage register

components/esp_rom/esp32h2/Kconfig.soc_caps.in

@@ -38,3 +38,7 @@ config ESP_ROM_GET_CLK_FREQ
 config ESP_ROM_HAS_LAYOUT_TABLE
     bool
     default y
+
+config ESP_ROM_HAS_ETS_PRINTF_BUG
+    bool
+    default y

components/esp_rom/esp32h2/esp_rom_caps.h

@@ -15,3 +15,4 @@
 #define ESP_ROM_HAS_ERASE_0_REGION_BUG      (1) // ROM has esp_flash_erase_region(size=0) bug
 #define ESP_ROM_GET_CLK_FREQ                (1) // Get clk frequency with rom function `ets_get_cpu_frequency`
 #define ESP_ROM_HAS_LAYOUT_TABLE            (1) // ROM has the layout table
+#define ESP_ROM_HAS_ETS_PRINTF_BUG          (1) // ROM has ets_printf bug when disable the ROM log either by eFuse or RTC storage register

components/esp_rom/patches/esp_rom_sys.c

@@ -8,7 +8,7 @@
 #include <stdbool.h>
 #include "esp_attr.h"
 
-#include "sdkconfig.h"
+#include "esp_rom_caps.h"
 
 IRAM_ATTR void esp_rom_install_channel_putc(int channel, void (*putc)(char c))
 {
@@ -26,14 +26,16 @@ IRAM_ATTR void esp_rom_install_channel_putc(int channel, void (*putc)(char c))
     }
 }
 
-#if CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32H2 || CONFIG_IDF_TARGET_ESP32C2
+#if ESP_ROM_HAS_ETS_PRINTF_BUG
 IRAM_ATTR void esp_rom_install_uart_printf(void)
 {
     extern void ets_install_uart_printf(void);
     extern bool g_uart_print;
+    extern bool g_usb_print;
     // If ROM log is disabled permanently via eFuse or temporarily via RTC storage register,
     // this ROM symbol will be set to false, and cause ``esp_rom_printf`` can't work on esp-idf side.
     g_uart_print = true;
+    g_usb_print = true;
     ets_install_uart_printf();
 }
 #endif