55 original

components/bootloader/Kconfig.projbuild

@@ -967,7 +967,7 @@ menu "Security features"
 
         config SECURE_BOOT_SKIP_WRITE_PROTECTION_SCA
             bool "Skip write-protection of SECURE_FLASH_PSEUDO_ROUND_FUNC_STRENGTH"
-            default y if SECURE_FLASH_PSEUDO_ROUND_FUNC
+            default y if SECURE_FLASH_PSEUDO_ROUND_FUNC && !SECURE_FLASH_ENCRYPTION_MODE_RELEASE
             default n
             depends on SOC_ECDSA_SUPPORT_CURVE_P384 && SOC_FLASH_ENCRYPTION_XTS_AES_SUPPORT_PSEUDO_ROUND
             help

components/bt/common/ble_log/Kconfig.in

@@ -5,6 +5,14 @@ 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 if IDF_TARGET_ARCH_RISCV
+        default 2048 if IDF_TARGET_ARCH_XTENSA
+        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

@@ -41,7 +41,14 @@
 #define SPI_OUT_LOG_STR_BUF_SIZE                (100)
 #define SPI_OUT_MALLOC(size)                    heap_caps_malloc(size, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT)
 #define SPI_OUT_TASK_PRIORITY                   (ESP_TASK_PRIO_MAX - 1)
+
+#if CONFIG_IDF_TARGET_ARCH_RISCV
 #define SPI_OUT_TASK_STACK_SIZE                 (1024)
+#elif CONFIG_IDF_TARGET_ARCH_XTENSA
+#define SPI_OUT_TASK_STACK_SIZE                 (2048)
+#else
+static_assert(false, "BLE Log SPI Out: Unsupported target architecture");
+#endif /* CONFIG_IDF_TARGET_ARCH_RISCV */
 
 #if SPI_OUT_TS_SYNC_ENABLED
 #define SPI_OUT_TS_SYNC_TIMEOUT_MS              (1000)
@@ -247,9 +254,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
@@ -1365,12 +1372,13 @@ int ble_log_spi_out_hci_write(uint8_t source, const uint8_t *addr, uint16_t len)
         return -1;
     }
 
-    if (source == BLE_LOG_SPI_OUT_SOURCE_HCI_UPSTREAM) {
 #if SPI_OUT_LL_ENABLED
+    if (source == BLE_LOG_SPI_OUT_SOURCE_HCI_UPSTREAM) {
         ble_log_spi_out_ll_write(len, addr, 0, NULL, BIT(LL_LOG_FLAG_HCI_UPSTREAM));
-#endif // SPI_OUT_LL_ENABLED
     }
-    if (source == BLE_LOG_SPI_OUT_SOURCE_HCI_DOWNSTREAM) {
+    if (source == BLE_LOG_SPI_OUT_SOURCE_HCI_DOWNSTREAM)
+#endif /* SPI_OUT_LL_ENABLED */
+    {
         spi_out_log_cb_t *log_cb;
         bool fallback = false;
         if (!spi_out_get_task_mapping(LOG_MODULE_TASK_MAP(hci),

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/common/osi/allocator.c

@@ -241,8 +241,5 @@ void *osi_calloc_func(size_t size)
 
 void osi_free_func(void *ptr)
 {
-#if HEAP_MEMORY_DEBUG
-    osi_mem_dbg_clean(ptr, __func__, __LINE__);
-#endif
-    free(ptr);
+    osi_free(ptr);
 }

components/bt/controller/esp32c3/Kconfig.in

@@ -616,15 +616,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
@@ -304,11 +309,14 @@ extern void btdm_aa_check_enhance_enable(void);
 
 /* 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
 #if (CONFIG_BT_BLUEDROID_ENABLED || CONFIG_BT_NIMBLE_ENABLED)
 extern void scan_stack_enableAdvFlowCtrlVsCmd(bool en);
@@ -399,12 +407,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
@@ -538,18 +547,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);
@@ -558,24 +563,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) {
@@ -612,16 +612,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;
     }
@@ -664,14 +661,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/esp_ble_mesh/core/bluedroid_host/adapter.c

@@ -223,7 +223,7 @@ void bt_mesh_ble_ext_adv_report(tBTM_BLE_EXT_ADV_REPORT *ext_adv_report)
         memcpy(adv_rpt.dir_addr, ext_adv_report->dir_addr, BLE_MESH_ADDR_LEN);
 
         adv_rpt.addr_type           = ext_adv_report->addr_type;
-        adv_rpt.data                = ext_adv_report->adv_data;
+        adv_rpt.data                = ext_adv_report->adv_data_len ? ext_adv_report->adv_data : NULL;
         adv_rpt.length              = ext_adv_report->adv_data_len;
         adv_rpt.rssi                = ext_adv_report->rssi;
         adv_rpt.event_type          = ext_adv_report->event_type;

components/bt/esp_ble_mesh/core/nimble_host/adapter.c

@@ -474,7 +474,7 @@ void bt_mesh_ble_ext_adv_report(struct ble_gap_ext_disc_desc *desc)
 
         /* Here, only a shallow copy needs to be implemented;
          * deep copying behavior occurs in btc_ble_mesh_ble_copy_req_data. */
-        adv_rpt.data                = desc->data;
+        adv_rpt.data                = desc->length_data ? desc->data : NULL;
 
         adv_rpt.event_type          = desc->props;
         adv_rpt.addr_type           = desc->addr.type;

components/bt/esp_ble_mesh/core/scan.c

@@ -380,7 +380,7 @@ static void inline callback_ble_adv_pkt(const bt_mesh_addr_t *addr,
         adv_rpt.addr_type = addr->type;
         adv_rpt.adv_type = adv_type;
         adv_rpt.length = length;
-        adv_rpt.data = data;
+        adv_rpt.data = length ? data : NULL;
         adv_rpt.rssi = rssi;
         bt_mesh_ble_scan_cb_evt_to_btc(&adv_rpt);
     }

components/bt/host/bluedroid/api/esp_hidd_api.c

@@ -133,7 +133,7 @@ esp_err_t esp_bt_hid_device_send_report(esp_hidd_report_type_t type, uint8_t id,
     args.send_report.data = data;
 
     bt_status_t stat = btc_transfer_context(&msg, &args, sizeof(btc_hidd_args_t),
-                                                btc_hd_arg_deep_copy, btc_hd_cb_arg_deep_free);
+                                                btc_hd_arg_deep_copy, btc_hd_call_arg_deep_free);
     return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
 }
 

components/bt/host/bluedroid/api/esp_hidh_api.c

@@ -117,7 +117,7 @@ esp_err_t esp_bt_hid_host_set_info(esp_bd_addr_t bd_addr, esp_hidh_hid_info_t *h
     arg.set_info.hid_info = hid_info;
 
     bt_status_t stat = btc_transfer_context(&msg, &arg, sizeof(btc_hidh_args_t),
-                                                btc_hh_arg_deep_copy, btc_hh_cb_arg_deep_free);
+                                                btc_hh_arg_deep_copy, btc_hh_call_arg_deep_free);
     return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
 }
 
@@ -224,7 +224,7 @@ esp_err_t esp_bt_hid_host_set_report(esp_bd_addr_t bd_addr, esp_hidh_report_type
     arg.set_report.report = report;
 
     bt_status_t stat = btc_transfer_context(&msg, &arg, sizeof(btc_hidh_args_t),
-                                                btc_hh_arg_deep_copy, btc_hh_cb_arg_deep_free);
+                                                btc_hh_arg_deep_copy, btc_hh_call_arg_deep_free);
     return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
 }
 
@@ -243,7 +243,7 @@ esp_err_t esp_bt_hid_host_send_data(esp_bd_addr_t bd_addr, uint8_t *data, size_t
     arg.send_data.data = data;
 
     bt_status_t stat = btc_transfer_context(&msg, &arg, sizeof(btc_hidh_args_t),
-                                                btc_hh_arg_deep_copy, btc_hh_cb_arg_deep_free);
+                                                btc_hh_arg_deep_copy, btc_hh_call_arg_deep_free);
     return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
 }
 

components/bt/host/bluedroid/btc/profile/std/hid/btc_hd.c

@@ -75,6 +75,8 @@ btc_hd_cb_t btc_hd_cb = {0};
 
 typedef void (bt_hid_copy_cb_t)(btc_msg_t *msg, void *p_dest, void *p_src);
 
+static void btc_hd_cb_arg_deep_free(btc_msg_t *msg);
+
 static inline void btc_hd_cb_to_app(esp_hidd_cb_event_t event, esp_hidd_cb_param_t *param)
 {
     esp_hd_cb_t btc_hd_cb = (esp_hd_cb_t)btc_profile_cb_get(BTC_PID_HD);
@@ -705,7 +707,7 @@ static void btc_hd_virtual_cable_unplug(void)
     }
 }
 
-static void btc_hd_call_arg_deep_free(btc_msg_t *msg)
+void btc_hd_call_arg_deep_free(btc_msg_t *msg)
 {
     btc_hidd_args_t *arg = (btc_hidd_args_t *)msg->arg;
 
@@ -756,7 +758,7 @@ void btc_hd_call_handler(btc_msg_t *msg)
     btc_hd_call_arg_deep_free(msg);
 }
 
-void btc_hd_cb_arg_deep_free(btc_msg_t *msg)
+static void btc_hd_cb_arg_deep_free(btc_msg_t *msg)
 {
     tBTA_HD *arg = (tBTA_HD *)msg->arg;
 

components/bt/host/bluedroid/btc/profile/std/hid/btc_hh.c

@@ -64,6 +64,8 @@ static bdstr_t bdstr;
 #define is_hidh_init() (btc_hh_cb.status > BTC_HH_DISABLED)
 #define BTC_TIMEOUT_VUP_MS (3 * 1000)
 
+static void btc_hh_cb_arg_deep_free(btc_msg_t *msg);
+
 static inline void btc_hh_cb_to_app(esp_hidh_cb_event_t event, esp_hidh_cb_param_t *param)
 {
     esp_hh_cb_t btc_hh_cb = (esp_hh_cb_t)btc_profile_cb_get(BTC_PID_HH);
@@ -1097,7 +1099,7 @@ static void btc_hh_set_idle_time(btc_hidh_args_t *arg)
     }
 }
 
-static void btc_hh_call_arg_deep_free(btc_msg_t *msg)
+void btc_hh_call_arg_deep_free(btc_msg_t *msg)
 {
     btc_hidh_args_t *arg = (btc_hidh_args_t *)msg->arg;
 
@@ -1166,7 +1168,7 @@ void btc_hh_call_handler(btc_msg_t *msg)
     btc_hh_call_arg_deep_free(msg);
 }
 
-void btc_hh_cb_arg_deep_free(btc_msg_t *msg)
+static void btc_hh_cb_arg_deep_free(btc_msg_t *msg)
 {
     tBTA_HH *arg = (tBTA_HH *)msg->arg;
 

components/bt/host/bluedroid/btc/profile/std/include/btc_hd.h

@@ -99,7 +99,7 @@ void btc_hd_call_handler(btc_msg_t *msg);
 void btc_hd_cb_handler(btc_msg_t *msg);
 
 void btc_hd_arg_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src);
-void btc_hd_cb_arg_deep_free(btc_msg_t *msg);
+void btc_hd_call_arg_deep_free(btc_msg_t *msg);
 
 void btc_hd_get_profile_status(esp_hidd_profile_status_t *param);
 

components/bt/host/bluedroid/btc/profile/std/include/btc_hh.h

@@ -181,8 +181,7 @@ void btc_hh_call_handler(btc_msg_t *msg);
 void btc_hh_cb_handler(btc_msg_t *msg);
 
 void btc_hh_arg_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src);
-
-void btc_hh_cb_arg_deep_free(btc_msg_t *msg);
+void btc_hh_call_arg_deep_free(btc_msg_t *msg);
 
 bool btc_hh_add_added_dev(BD_ADDR bd_addr, uint16_t attr_mask);