Release/v5.4

components/bt/common/ble_log/Kconfig.in

@@ -5,6 +5,12 @@ config BLE_LOG_ENABLED
         Enable BLE Log Module
 
 if BLE_LOG_ENABLED
+    config BLE_LOG_TASK_STACK_SIZE
+        int "Stack size for BLE Log Task"
+        default 1024
+        help
+            Stack size for BLE Log Task
+
     config BLE_LOG_LBM_TRANS_SIZE
         int "Buffer size for each peripheral transport"
         default 512

components/bt/common/ble_log/ble_log_spi_out.c

@@ -247,9 +247,9 @@ extern uint32_t r_ble_lll_timer_current_tick_get(void);
 #elif defined(CONFIG_IDF_TARGET_ESP32C2)
 extern uint32_t r_os_cputime_get32(void);
 #define SPI_OUT_GET_LC_TIME r_os_cputime_get32()
-// #elif defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S3)
-// extern uint32_t lld_read_clock_us(void);
-// #define SPI_OUT_GET_LC_TIME lld_read_clock_us()
+#elif defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S3)
+extern uint32_t lld_read_clock_us(void);
+#define SPI_OUT_GET_LC_TIME lld_read_clock_us()
 #else
 #define SPI_OUT_GET_LC_TIME esp_timer_get_time()
 #endif

components/bt/common/ble_log/src/internal_include/ble_log_rt.h

@@ -21,7 +21,7 @@
 
 /* MACRO */
 #define BLE_LOG_TASK_PRIO                       (ESP_TASK_PRIO_MAX - 1)
-#define BLE_LOG_TASK_STACK_SIZE                 (1024)
+#define BLE_LOG_TASK_STACK_SIZE                 CONFIG_BLE_LOG_TASK_STACK_SIZE
 #define BLE_LOG_TASK_HOOK_TIMEOUT_MS            (1000)
 
 /* INTERFACE */

components/bt/controller/esp32c3/Kconfig.in

@@ -614,15 +614,15 @@ menu "Controller debug log Options (Experimental)"
 
     config BT_CTRL_LE_LOG_MODE_EN
         depends on BT_CTRL_LE_LOG_EN
-        int "Enable log for specified BLE mode"
-        range 0 4095
-        default 4093
+        hex "Enable log for specified BLE mode"
+        range 0 0xFFFF
+        default 0xDB7F
 
     config BT_CTRL_LE_LOG_LEVEL
         depends on BT_CTRL_LE_LOG_EN
         int "The level of BLE log"
         range 0 5
-        default 2
+        default 1
 
     config BT_CTRL_LE_LOG_BUF1_SIZE
         depends on BT_CTRL_LE_LOG_EN

components/bt/controller/esp32c3/bt.c

@@ -241,7 +241,12 @@ struct osi_funcs_t {
 };
 
 #if CONFIG_BT_CTRL_LE_LOG_EN
-typedef void (*interface_func_t) (uint32_t len, const uint8_t*addr, bool end);
+typedef void (*interface_func_t) (uint32_t len, const uint8_t *addr, uint32_t len_append, const uint8_t *addr_append, uint32_t flag);
+
+enum {
+    BLE_LOG_INTERFACE_FLAG_CONTINUE = 0,
+    BLE_LOG_INTERFACE_FLAG_END,
+};
 #endif // CONFIG_BT_CTRL_LE_LOG_EN
 
 /* External functions or values
@@ -311,11 +316,14 @@ extern void chanSel_stack_enableSetCsaVsCmd(bool en);
 
 /* BLE Log module */
 #if CONFIG_BT_CTRL_LE_LOG_EN
+extern int r_ble_log_init_simple(interface_func_t interface, void *handler);
+extern void r_ble_log_deinit_simple(void);
 extern int r_ble_log_init_async(interface_func_t bt_controller_log_interface, bool task_create, uint8_t buffers, uint32_t *bufs_size);
 extern int r_ble_log_deinit_async(void);
 extern void r_ble_log_async_select_dump_buffers(uint8_t buffers);
 extern void r_ble_log_async_output_dump_all(bool output);
 extern void esp_panic_handler_feed_wdts(void);
+extern int r_ble_log_ctrl_level_and_mod(uint8_t level, uint32_t mod_en);
 #endif // CONFIG_BT_CTRL_LE_LOG_EN
 
 extern void ble_dtm_funcs_reset(void);
@@ -400,12 +408,13 @@ static esp_err_t try_heap_caps_add_region(intptr_t start, intptr_t end);
 static void bt_controller_deinit_internal(void);
 
 #if CONFIG_BT_CTRL_LE_LOG_EN
-static void esp_bt_controller_log_interface(uint32_t len, const uint8_t *addr, bool end);
+#if !CONFIG_BT_CTRL_LE_LOG_MODE_BLE_LOG_V2
 #if CONFIG_BT_CTRL_LE_LOG_STORAGE_EN
 void esp_bt_read_ctrl_log_from_flash(bool output);
 static int esp_bt_controller_log_storage(uint32_t len, const uint8_t *addr, bool end);
 static void esp_bt_ctrl_log_partition_get_and_erase_first_block(void);
-#endif // #if CONFIG_BT_CTRL_LE_LOG_STORAGE_EN
+#endif // CONFIG_BT_CTRL_LE_LOG_STORAGE_EN
+#endif // !CONFIG_BT_CTRL_LE_LOG_MODE_BLE_LOG_V2
 #endif // CONFIG_BT_CTRL_LE_LOG_EN
 
 /* Local variable definition
@@ -539,18 +548,14 @@ static bool is_filled = false;
 #endif // CONFIG_BT_CTRL_LE_LOG_STORAGE_EN
 
 #if CONFIG_BT_CTRL_LE_LOG_MODE_BLE_LOG_V2
-static IRAM_ATTR void esp_bt_controller_log_interface(uint32_t len, const uint8_t *addr, bool end)
-{
-    ble_log_write_hex_ll(len, addr, 0, NULL, 0);
-}
-
 void esp_ble_controller_log_dump_all(bool output)
 {
     ble_log_dump_to_console();
 }
 #else /* !CONFIG_BT_CTRL_LE_LOG_MODE_BLE_LOG_V2 */
-static void esp_bt_controller_log_interface(uint32_t len, const uint8_t *addr, bool end)
+static void esp_bt_controller_log_interface(uint32_t len, const uint8_t *addr, uint32_t len_append, const uint8_t *addr_append, uint32_t flag)
 {
+    bool end = (flag & BIT(BLE_LOG_INTERFACE_FLAG_END));
     if (log_output_mode == LOG_STORAGE_TO_FLASH) {
 #if CONFIG_BT_CTRL_LE_LOG_STORAGE_EN
         esp_bt_controller_log_storage(len, addr, end);
@@ -559,24 +564,19 @@ static void esp_bt_controller_log_interface(uint32_t len, const uint8_t *addr, b
         portMUX_TYPE spinlock = portMUX_INITIALIZER_UNLOCKED;
         portENTER_CRITICAL_SAFE(&spinlock);
         esp_panic_handler_feed_wdts();
-        for (int i = 0; i < len; i++) {
-            esp_rom_printf("%02x ", addr[i]);
-        }
 
-        if (end) {
-            esp_rom_printf("\n");
+        if (len && addr) {
+            for (int i = 0; i < len; i++) { esp_rom_printf("%02x ", addr[i]); }
+        }
+        if (len_append && addr_append) {
+            for (int i = 0; i < len_append; i++) { esp_rom_printf("%02x ", addr_append[i]); }
         }
+        if (end) { esp_rom_printf("\n"); }
+
         portEXIT_CRITICAL_SAFE(&spinlock);
     }
 }
 
-#if CONFIG_BT_CTRL_LE_LOG_SPI_OUT_EN
-static IRAM_ATTR void esp_bt_controller_spi_log_interface(uint32_t len, const uint8_t *addr, bool end)
-{
-    ble_log_spi_out_ll_write(len, addr, 0, NULL, 0);
-}
-#endif // CONFIG_BT_CTRL_LE_LOG_SPI_OUT_EN
-
 void esp_ble_controller_log_dump_all(bool output)
 {
     if (log_output_mode == LOG_STORAGE_TO_FLASH) {
@@ -613,16 +613,13 @@ esp_err_t esp_bt_controller_log_init(uint8_t log_output_mode)
     }
 
     esp_err_t ret = ESP_OK;
-    uint8_t buffers = 0;
 
-#if CONFIG_BT_CTRL_LE_LOG_EN
-    buffers |= ESP_BLE_LOG_BUF_CONTROLLER;
-#endif // CONFIG_BT_CTRL_LE_LOG_EN
-#if CONFIG_BT_CTRL_LE_HCI_LOG_EN
-    buffers |= ESP_BLE_LOG_BUF_HCI;
-#endif // CONFIG_BT_CTRL_LE_HCI_LOG_EN
+    ret = r_ble_log_init_simple(ble_log_write_hex_ll, NULL);
+    if (ret != ESP_OK) {
+        return ret;
+    }
 
-    ret = r_ble_log_init_async(esp_bt_controller_log_interface, true, buffers, (uint32_t *)log_bufs_size);
+    ret = r_ble_log_ctrl_level_and_mod(BLE_LOG_LEVEL, BLE_LOG_MODE_EN);
     if (ret == ESP_OK) {
         log_is_inited = true;
     }
@@ -665,14 +662,19 @@ esp_err_t esp_bt_controller_log_init(uint8_t log_output_mode)
         case LOG_SPI_OUT:
             task_create = true;
 #if CONFIG_BT_CTRL_LE_LOG_SPI_OUT_EN
-            bt_controller_log_interface = esp_bt_controller_spi_log_interface;
+            bt_controller_log_interface = ble_log_spi_out_ll_write;
 #endif // CONFIG_BT_CTRL_LE_LOG_SPI_OUT_EN
             break;
         default:
             assert(0);
     }
 
     ret = r_ble_log_init_async(bt_controller_log_interface, task_create, buffers, (uint32_t *)log_bufs_size);
+    if (ret != ESP_OK) {
+        return ret;
+    }
+
+    ret = r_ble_log_ctrl_level_and_mod(BLE_LOG_LEVEL, BLE_LOG_MODE_EN);
     if (ret == ESP_OK) {
         log_is_inited = true;
     }

components/bt/include/esp32c3/include/esp_bt.h

@@ -30,7 +30,7 @@ extern "C" {
 *
 * @note Please do not modify this value
 */
-#define ESP_BT_CTRL_CONFIG_VERSION      0x02505080
+#define ESP_BT_CTRL_CONFIG_VERSION      0x02509280
 
 /**
 * @brief Internal use only
@@ -376,8 +376,6 @@ typedef void (* esp_bt_hci_tl_callback_t) (void *arg, uint8_t status);
     .connect_en = BT_CTRL_BLE_MASTER,                                      \
     .scan_en = BT_CTRL_BLE_SCAN,                                           \
     .ble_aa_check = BLE_CTRL_CHECK_CONNECT_IND_ACCESS_ADDRESS_ENABLED,     \
-    .ble_log_mode_en = BLE_LOG_MODE_EN,                                    \
-    .ble_log_level = BLE_LOG_LEVEL,                                        \
     .adv_en = BT_CTRL_BLE_ADV,                                             \
 }
 
@@ -502,8 +500,6 @@ typedef struct {
     bool connect_en;                        /*!< True if the connection feature is enabled (default); false otherwise. Configurable in menuconfig.*/
     bool scan_en;                           /*!< True if the scan feature is enabled (default); false otherwise. Configurable in menuconfig.*/
     bool ble_aa_check;                      /*!< True if adds a verification step for the Access Address within the CONNECT_IND PDU; false otherwise. Configurable in menuconfig */
-    uint32_t ble_log_mode_en;               /*!< BLE log mode enable */
-    uint8_t ble_log_level;                  /*!< BLE log level */
     bool adv_en;                            /*!< True if the ADV feature is enabled (default); false otherwise. Configurable in menuconfig.*/
 } esp_bt_controller_config_t;
 

components/esp_driver_cam/csi/src/esp_cam_ctlr_csi.c

@@ -52,6 +52,7 @@ static esp_err_t s_ctlr_csi_stop(esp_cam_ctlr_handle_t handle);
 static esp_err_t s_csi_ctlr_disable(esp_cam_ctlr_handle_t ctlr);
 static esp_err_t s_ctlr_csi_receive(esp_cam_ctlr_handle_t handle, esp_cam_ctlr_trans_t *trans, uint32_t timeout_ms);
 static void *s_csi_ctlr_alloc_buffer(esp_cam_ctlr_t *handle, size_t size, uint32_t buf_caps);
+static esp_err_t s_csi_ctlr_format_conversion(esp_cam_ctlr_t *handle, const cam_ctlr_format_conv_config_t *config);
 
 static esp_err_t s_csi_claim_controller(csi_controller_t *controller)
 {
@@ -223,6 +224,7 @@ esp_err_t esp_cam_new_csi_ctlr(const esp_cam_ctlr_csi_config_t *config, esp_cam_
     ctlr->base.get_internal_buffer = s_csi_ctlr_get_internal_buffer;
     ctlr->base.get_buffer_len = s_csi_ctlr_get_buffer_length;
     ctlr->base.alloc_buffer = s_csi_ctlr_alloc_buffer;
+    ctlr->base.format_conversion = s_csi_ctlr_format_conversion;
 
     *ret_handle = &(ctlr->base);
 
@@ -540,3 +542,10 @@ static void *s_csi_ctlr_alloc_buffer(esp_cam_ctlr_t *handle, size_t size, uint32
 
     return buffer;
 }
+
+static esp_err_t s_csi_ctlr_format_conversion(esp_cam_ctlr_t *handle, const cam_ctlr_format_conv_config_t *config)
+{
+    ESP_RETURN_ON_FALSE(handle, ESP_ERR_INVALID_ARG, TAG, "invalid argument: null pointer");
+    // CSI controller doesn't support format conversion yet
+    return ESP_ERR_NOT_SUPPORTED;
+}

components/esp_driver_cam/dvp/src/esp_cam_ctlr_dvp_cam.c

@@ -766,6 +766,31 @@ static void *esp_cam_ctlr_dvp_cam_alloc_buffer(esp_cam_ctlr_t *handle, size_t si
     return buffer;
 }
 
+/**
+ * @brief Configure format conversion
+ *
+ * @param cam_handle Camera controller handle
+ * @param src_format Source format
+ * @param dst_format Destination format
+ * @return ESP_OK on success, ESP_FAIL on failure
+ */
+esp_err_t esp_cam_ctlr_dvp_format_conversion(esp_cam_ctlr_handle_t cam_handle,
+                                             const cam_ctlr_format_conv_config_t *config)
+{
+    if (cam_handle == NULL) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    esp_cam_ctlr_dvp_cam_t *ctlr = (esp_cam_ctlr_dvp_cam_t *)cam_handle;
+
+    ESP_LOGD(TAG, "Configure format conversion: %d -> %d", config->src_format, config->dst_format);
+
+    // Configure color format conversion
+    cam_hal_color_format_convert(&ctlr->hal, config);
+
+    return ESP_OK;
+}
+
 /**
  * @brief New ESP CAM DVP controller
  *
@@ -856,6 +881,7 @@ esp_err_t esp_cam_new_dvp_ctlr(const esp_cam_ctlr_dvp_config_t *config, esp_cam_
     ctlr->base.get_internal_buffer = esp_cam_ctlr_dvp_cam_get_internal_buffer;
     ctlr->base.get_buffer_len = esp_cam_ctlr_get_dvp_cam_frame_buffer_len;
     ctlr->base.alloc_buffer = esp_cam_ctlr_dvp_cam_alloc_buffer;
+    ctlr->base.format_conversion = esp_cam_ctlr_dvp_format_conversion;
 
     *ret_handle = &ctlr->base;
 

components/esp_driver_cam/esp_cam_ctlr.c

@@ -99,3 +99,13 @@ void *esp_cam_ctlr_alloc_buffer(esp_cam_ctlr_handle_t handle, size_t size, uint3
 
     return handle->alloc_buffer(handle, size, buf_caps);
 }
+
+esp_err_t esp_cam_ctlr_format_conversion(esp_cam_ctlr_handle_t handle,
+                                         const cam_ctlr_format_conv_config_t *conv_cfg)
+{
+    ESP_RETURN_ON_FALSE(handle, ESP_ERR_INVALID_ARG, TAG, "invalid argument: null pointer");
+    ESP_RETURN_ON_FALSE(conv_cfg, ESP_ERR_INVALID_ARG, TAG, "invalid argument: null conv_cfg");
+    ESP_RETURN_ON_FALSE(handle->format_conversion, ESP_ERR_NOT_SUPPORTED, TAG, "format conversion function not supported");
+
+    return handle->format_conversion(handle, conv_cfg);
+}

components/esp_driver_cam/include/esp_cam_ctlr.h

@@ -11,6 +11,7 @@
 #include "esp_err.h"
 #include "esp_heap_caps.h"
 #include "esp_cam_ctlr_types.h"
+#include "hal/cam_ctlr_types.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -150,6 +151,20 @@ esp_err_t esp_cam_ctlr_get_frame_buffer_len(esp_cam_ctlr_handle_t handle, size_t
  */
 void *esp_cam_ctlr_alloc_buffer(esp_cam_ctlr_handle_t handle, size_t size, uint32_t buf_caps);
 
+/**
+ * @brief Configure format conversion
+ *
+ * @param[in] handle      ESP CAM controller handle
+ * @param[in] conv_cfg    Color conversion configuration, contains source and destination formats
+ *
+ * @return
+ *        - ESP_OK on success
+ *        - ESP_ERR_INVALID_ARG:   Invalid argument
+ *        - ESP_ERR_NOT_SUPPORTED: Format conversion not supported by this controller
+ */
+esp_err_t esp_cam_ctlr_format_conversion(esp_cam_ctlr_handle_t handle,
+                                         const cam_ctlr_format_conv_config_t *conv_cfg);
+
 #ifdef __cplusplus
 }
 #endif

components/esp_driver_cam/interface/esp_cam_ctlr_interface.h

@@ -8,6 +8,7 @@
 #include <stdbool.h>
 #include "esp_err.h"
 #include "esp_cam_ctlr_types.h"
+#include "hal/cam_ctlr_types.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -146,6 +147,19 @@ struct esp_cam_ctlr_t {
      */
     void *(*alloc_buffer)(esp_cam_ctlr_t *, size_t, uint32_t);
 
+    /**
+     * @brief Configure format conversion
+     *
+     * @param[in] esp_cam_ctlr_t *      ESP CAM controller handle
+     * @param[in] const cam_ctlr_format_conv_config_t * Color conversion configuration
+     *
+     * @return
+     *        - ESP_OK on success
+     *        - ESP_ERR_INVALID_ARG:   Invalid argument
+     *        - ESP_ERR_NOT_SUPPORTED: Format conversion not supported by this controller
+     */
+    esp_err_t (*format_conversion)(esp_cam_ctlr_t *, const cam_ctlr_format_conv_config_t *);
+
     void *user_data;  ///< User data
 };
 

components/esp_driver_cam/isp_dvp/src/esp_cam_ctlr_isp_dvp.c

@@ -80,6 +80,7 @@ static esp_err_t s_isp_dvp_stop(esp_cam_ctlr_handle_t handle);
 static esp_err_t s_isp_dvp_receive(esp_cam_ctlr_handle_t handle, esp_cam_ctlr_trans_t *trans, uint32_t timeout_ms);
 static bool s_dvp_dma_trans_done_callback(dw_gdma_channel_handle_t chan, const dw_gdma_trans_done_event_data_t *event_data, void *user_data);
 static void *s_isp_dvp_alloc_buffer(esp_cam_ctlr_t *handle, size_t size, uint32_t buf_caps);
+static esp_err_t s_isp_dvp_format_conversion(esp_cam_ctlr_t *handle, const cam_ctlr_format_conv_config_t *config);
 
 esp_err_t esp_cam_new_isp_dvp_ctlr(isp_proc_handle_t isp_proc, const esp_cam_ctlr_isp_dvp_cfg_t *ctlr_config, esp_cam_ctlr_handle_t *ret_handle)
 {
@@ -191,6 +192,7 @@ esp_err_t esp_cam_new_isp_dvp_ctlr(isp_proc_handle_t isp_proc, const esp_cam_ctl
     cam_ctlr->get_internal_buffer = s_isp_dvp_get_frame_buffer;
     cam_ctlr->get_buffer_len = s_isp_dvp_get_frame_buffer_length;
     cam_ctlr->alloc_buffer = s_isp_dvp_alloc_buffer;
+    cam_ctlr->format_conversion = s_isp_dvp_format_conversion;
     *ret_handle = cam_ctlr;
 
     return ESP_OK;
@@ -589,3 +591,10 @@ static void *s_isp_dvp_alloc_buffer(esp_cam_ctlr_t *handle, size_t size, uint32_
 
     return buffer;
 }
+
+static esp_err_t s_isp_dvp_format_conversion(esp_cam_ctlr_t *handle, const cam_ctlr_format_conv_config_t *config)
+{
+    ESP_RETURN_ON_FALSE(handle, ESP_ERR_INVALID_ARG, TAG, "invalid argument: null pointer");
+    // ISP DVP controller doesn't support format conversion yet
+    return ESP_ERR_NOT_SUPPORTED;
+}