bluetooth: fix compilation errors

Fix various compilation errors across bluetooth framework, service,
and stack layers including:
- Add missing function declarations and header includes
- Fix type mismatches and implicit function declarations
- Add missing macro definitions in dfx headers
- Add stub implementation for hid device interface
- Fix list utility inline function issues

Signed-off-by: openvela <openvela@xiaomi.com>

CMakeLists.txt

@@ -298,6 +298,22 @@ if(CONFIG_BLUETOOTH)
         list(APPEND CSRCS ${BLUETOOTH_DIR}/service/stacks/zephyr/sal_avrcp_interface.c)
       endif()
 
+      if(CONFIG_BLUETOOTH_HFP_HF)
+        list(APPEND CSRCS ${BLUETOOTH_DIR}/service/stacks/zephyr/sal_hfp_hf_interface.c)
+      endif()
+
+      if(CONFIG_BLUETOOTH_HFP_AG)
+        list(APPEND CSRCS ${BLUETOOTH_DIR}/service/stacks/zephyr/sal_hfp_ag_interface.c)
+      endif()
+
+      if(CONFIG_BLUETOOTH_SPP)
+        list(APPEND CSRCS ${BLUETOOTH_DIR}/service/stacks/zephyr/sal_spp_interface.c)
+      endif()
+
+      if(CONFIG_BLUETOOTH_HID_DEVICE)
+        list(APPEND CSRCS ${BLUETOOTH_DIR}/service/stacks/zephyr/sal_hid_device_stub.c)
+      endif()
+
     endif()
 
     if(CONFIG_BLUETOOTH_STACK_LE_ZBLUE)

debug/bt_trace.c

@@ -15,6 +15,7 @@
  ***************************************************************************/
 #include "bt_sched_trace.h"
 
+#include <inttypes.h>
 #include <stdatomic.h>
 #include <stdio.h>
 #include <string.h>
@@ -23,6 +24,9 @@
 
 #include "utils/log.h"
 
+#ifndef CONFIG_BLUETOOTH_TRACE_BUFFER_SIZE
+#define CONFIG_BLUETOOTH_TRACE_BUFFER_SIZE 64
+#endif
 #define DUMP_THRESHOLD 256
 
 typedef struct {
@@ -64,7 +68,7 @@ void bt_note_stop(void)
         bt_latency_record_t* p = &trace_manager->buffer[trace_manager->tail % CONFIG_BLUETOOTH_TRACE_BUFFER_SIZE];
 
         written += snprintf(log_buf + written, sizeof(log_buf) - written,
-            "[TAG=%s][TS=%lu][LAT=%uus]\n",
+            "[TAG=%s][TS=%" PRIu64 "][LAT=%" PRIu32 "us]\n",
             p->tag, p->timestamp, p->latency_us);
         trace_manager->tail = (trace_manager->tail + 1) % CONFIG_BLUETOOTH_TRACE_BUFFER_SIZE;
         written = written % DUMP_THRESHOLD;

dfx/bt_dfx.h

@@ -96,4 +96,75 @@
             "%s:%s", "blePairError", reason);                                            \
     } while (0)
 
+// a2dp
+#if defined(CONFIG_BLUETOOTH_DFX) && defined(CONFIG_BLUETOOTH_BREDR_SUPPORT)
+#define BT_DFX_SEND_A2DP_EVENT(...) sendEventMisightF(__VA_ARGS__)
+#else
+#define BT_DFX_SEND_A2DP_EVENT(...)
+#endif
+
+#define BT_DFX_A2DP_CONN_ERROR(reason)                                               \
+    do {                                                                             \
+        BT_LOGE("BT_DFX: a2dpConnError: %s", reason);                                \
+        BT_DFX_SEND_A2DP_EVENT(BT_DFX_BUILD_CODE(BT_DFXG_A2DP, BT_DFXC_A2DP_CONN),  \
+            "%s:%s", "a2dpConnError", reason);                                       \
+    } while (0)
+
+#define BT_DFX_A2DP_OFFLOAD_ERROR(reason)                                                  \
+    do {                                                                                   \
+        BT_LOGE("BT_DFX: a2dpOffloadError: %s", reason);                                   \
+        BT_DFX_SEND_A2DP_EVENT(BT_DFX_BUILD_CODE(BT_DFXG_A2DP, BT_DFXC_A2DP_OFFLOAD),     \
+            "%s:%s", "a2dpOffloadError", reason);                                          \
+    } while (0)
+
+// hfp
+#if defined(CONFIG_BLUETOOTH_DFX) && defined(CONFIG_BLUETOOTH_BREDR_SUPPORT)
+#define BT_DFX_SEND_HFP_EVENT(...) sendEventMisightF(__VA_ARGS__)
+#else
+#define BT_DFX_SEND_HFP_EVENT(...)
+#endif
+
+#define BT_DFX_HFP_CONN_ERROR(reason)                                              \
+    do {                                                                            \
+        BT_LOGE("BT_DFX: hfpConnError: %s", reason);                               \
+        BT_DFX_SEND_HFP_EVENT(BT_DFX_BUILD_CODE(BT_DFXG_HFP, BT_DFXC_HFP_CONN),  \
+            "%s:%s", "hfpConnError", reason);                                      \
+    } while (0)
+
+#define BT_DFX_HFP_OFFLOAD_ERROR(reason)                                                 \
+    do {                                                                                 \
+        BT_LOGE("BT_DFX: hfpOffloadError: %s", reason);                                  \
+        BT_DFX_SEND_HFP_EVENT(BT_DFX_BUILD_CODE(BT_DFXG_HFP, BT_DFXC_HFP_OFFLOAD),     \
+            "%s:%s", "hfpOffloadError", reason);                                         \
+    } while (0)
+
+// open (enable)
+#if defined(CONFIG_BLUETOOTH_DFX)
+#define BT_DFX_SEND_OTHERS_EVENT(...) sendEventMisightF(__VA_ARGS__)
+#else
+#define BT_DFX_SEND_OTHERS_EVENT(...)
+#endif
+
+#define BT_DFX_OPEN_ERROR(reason)                                                    \
+    do {                                                                             \
+        BT_LOGE("BT_DFX: openError: %s", reason);                                    \
+        BT_DFX_SEND_OTHERS_EVENT(BT_DFX_BUILD_CODE(BT_DFXG_OTHERS, BT_DFXC_OPEN),   \
+            "%s:%s", "openError", reason);                                           \
+    } while (0)
+
+// spp / ipc
+#define BT_DFX_SPP_CONN_ERROR(reason)                                                \
+    do {                                                                             \
+        BT_LOGE("BT_DFX: sppConnError: %s", reason);                                 \
+        BT_DFX_SEND_BR_EVENT(BT_DFX_BUILD_CODE(BT_DFXG_RFCOMM, 0),                  \
+            "%s:%s", "sppConnError", reason);                                        \
+    } while (0)
+
+#define BT_DFX_IPC_CONN_ERROR(reason, extra)                                         \
+    do {                                                                             \
+        BT_LOGE("BT_DFX: ipcConnError: %s %s", reason, extra);                       \
+        BT_DFX_SEND_BR_EVENT(BT_DFX_BUILD_CODE(BT_DFXG_RFCOMM, 0),                  \
+            "%s:%s:%s", "ipcConnError", reason, extra);                              \
+    } while (0)
+
 #endif /* _BT_DFX_H_ */

dfx/bt_dfx_event.h

@@ -47,6 +47,17 @@
 #define BT_DFXC_LE_GAP_DISCONN (110)
 #define BT_DFXC_LE_GAP_PAIR (200)
 
+// group: BT_DFXG_A2DP
+#define BT_DFXC_A2DP_CONN (0)
+#define BT_DFXC_A2DP_OFFLOAD (100)
+
+// group: BT_DFXG_HFP
+#define BT_DFXC_HFP_CONN (0)
+#define BT_DFXC_HFP_OFFLOAD (100)
+
+// group: BT_DFXG_OTHERS
+#define BT_DFXC_OPEN (0)
+
 #define BT_DFX_BUILD_CODE(group, subcode) ((BT_DFX_BASE_VELA_BLUETOOTH) + (group) + (subcode))
 
 #endif /* _BT_DFX_EVENT_H_ */

dfx/bt_dfx_reason.h

@@ -24,5 +24,16 @@
 #define BT_DFXE_CONN_FAILED_TO_BE_ESTABLISHED "btConnFailedToBeEstablished"
 
 #define BT_DFXE_SCANNER_EXCEED_MAX_NUM "btScannerExceedMaxNum"
+#define BT_DFXE_LE_ENABLE_FAIL "btLeEnableFail"
+#define BT_DFXE_BR_ENABLE_FAIL "btBrEnableFail"
+#define BT_DFXE_A2DP_CONN_TIMEOUT "btA2dpConnTimeout"
+#define BT_DFXE_OFFLOAD_START_TIMEOUT "btOffloadStartTimeout"
+#define BT_DFXE_OFFLOAD_HCI_UNSPECIFIED_ERROR "btOffloadHciUnspecifiedError"
+#define BT_DFXE_HFP_HF_CONN_TIMEOUT "btHfpHfConnTimeout"
+#define BT_DFXE_HFP_HF_CONN_RETRY_FAIL "btHfpHfConnRetryFail"
+#define BT_DFXE_SPP_CONN_FAIL "btSppConnFail"
+#define BT_DFXE_SPP_NOT_STARTUP "btSppNotStartup"
+#define BT_DFXE_SPP_SCN_ALLOC_FAIL "btSppScnAllocFail"
+#define BT_DFXE_SPP_NO_RESOURCES "btSppNoResources"
 
 #endif /* _BT_DFX_REASON_H_ */

framework/api/bt_adapter.c

@@ -42,6 +42,11 @@ bt_status_t BTSYMBOLS(bt_adapter_disable)(bt_instance_t* ins)
     return adapter_disable(SYS_SET_BT_ALL);
 }
 
+bt_status_t BTSYMBOLS(bt_adapter_disable_safe)(bt_instance_t* ins)
+{
+    return adapter_disable(SYS_SET_BT_ALL);
+}
+
 bt_status_t BTSYMBOLS(bt_adapter_enable_le)(bt_instance_t* ins)
 {
     return adapter_enable(APP_SET_LE_ONLY);

framework/api/bt_avrcp_control.c

@@ -55,4 +55,32 @@ bt_status_t BTSYMBOLS(bt_avrcp_control_send_passthrough_cmd)(bt_instance_t* ins,
     avrcp_control_interface_t* profile = get_profile_service();
 
     return profile->avrcp_control_send_passthrough_cmd(addr, cmd, state);
+}
+
+bt_status_t BTSYMBOLS(bt_avrcp_control_get_unit_info)(bt_instance_t* ins, bt_address_t* addr)
+{
+    avrcp_control_interface_t* profile = get_profile_service();
+
+    return profile->avrcp_control_get_unit_info(addr);
+}
+
+bt_status_t BTSYMBOLS(bt_avrcp_control_get_subunit_info)(bt_instance_t* ins, bt_address_t* addr)
+{
+    avrcp_control_interface_t* profile = get_profile_service();
+
+    return profile->avrcp_control_get_subunit_info(addr);
+}
+
+bt_status_t BTSYMBOLS(bt_avrcp_control_get_playback_state)(bt_instance_t* ins, bt_address_t* addr)
+{
+    avrcp_control_interface_t* profile = get_profile_service();
+
+    return profile->get_playback_state(addr);
+}
+
+bt_status_t BTSYMBOLS(bt_avrcp_control_register_notification)(bt_instance_t* ins, bt_address_t* addr, avrcp_notification_event_t event, uint32_t interval)
+{
+    avrcp_control_interface_t* profile = get_profile_service();
+
+    return profile->avrcp_control_register_notification(addr, event, interval);
 }

framework/api/bt_hfp_hf.c

@@ -198,3 +198,15 @@ bt_status_t BTSYMBOLS(bt_hfp_hf_send_dtmf)(bt_instance_t* ins, bt_address_t* add
     hfp_hf_interface_t* profile = get_profile_service();
     return profile->send_dtmf(addr, dtmf);
 }
+
+bt_status_t BTSYMBOLS(bt_hfp_hf_get_subscriber_number)(bt_instance_t* ins, bt_address_t* addr)
+{
+    hfp_hf_interface_t* profile = get_profile_service();
+    return profile->get_subscriber_number(addr);
+}
+
+bt_status_t BTSYMBOLS(bt_hfp_hf_query_current_calls_with_callback)(bt_instance_t* ins, bt_address_t* addr)
+{
+    hfp_hf_interface_t* profile = get_profile_service();
+    return profile->query_current_calls_with_callback(addr);
+}

framework/common/bt_trace.h

@@ -30,6 +30,7 @@ typedef enum {
     BTSNOOP_FILTER_AVCTP_BROWSING,
     BTSNOOP_FILTER_ATT,
     BTSNOOP_FILTER_SPP,
+    BTSNOOP_FILTER_NOCP,
     BTSNOOP_FILTER_MAX,
     BTSNOOP_FILTER_UNFILTER,
 } btsnoop_filter_flag_t;

framework/include/bt_adapter.h

@@ -598,6 +598,8 @@ if (bt_adapter_disable(ins) == BT_STATUS_SUCCESS) {
  */
 bt_status_t BTSYMBOLS(bt_adapter_disable)(bt_instance_t* ins);
 
+bt_status_t BTSYMBOLS(bt_adapter_disable_safe)(bt_instance_t* ins);
+
 /**
  * @brief Enable BLE (Bluetooth Low Energy).
  *
@@ -668,6 +670,8 @@ if (bt_adapter_start_discovery(ins, 10) == BT_STATUS_SUCCESS) {
  */
 bt_status_t BTSYMBOLS(bt_adapter_start_discovery)(bt_instance_t* ins, uint32_t timeout);
 
+bt_status_t BTSYMBOLS(bt_adapter_start_limited_discovery)(bt_instance_t* ins, uint32_t timeout);
+
 /**
  * @brief Cancel device discovery.
  *

framework/include/bt_avrcp_control.h

@@ -137,4 +137,12 @@ bt_status_t BTSYMBOLS(bt_avrcp_control_get_element_attributes)(bt_instance_t* in
  */
 bt_status_t BTSYMBOLS(bt_avrcp_control_send_passthrough_cmd)(bt_instance_t* ins, bt_address_t* addr, uint8_t cmd, uint8_t state);
 
+bt_status_t BTSYMBOLS(bt_avrcp_control_get_unit_info)(bt_instance_t* ins, bt_address_t* addr);
+
+bt_status_t BTSYMBOLS(bt_avrcp_control_get_subunit_info)(bt_instance_t* ins, bt_address_t* addr);
+
+bt_status_t BTSYMBOLS(bt_avrcp_control_get_playback_state)(bt_instance_t* ins, bt_address_t* addr);
+
+bt_status_t BTSYMBOLS(bt_avrcp_control_register_notification)(bt_instance_t* ins, bt_address_t* addr, avrcp_notification_event_t event, uint32_t interval);
+
 #endif /* __BT_AVRCP_CONTROL_H__ */

framework/include/bt_hfp.h

@@ -120,6 +120,11 @@ typedef enum {
     HFP_ROAM_STATE_ROAMING,
 } hfp_roaming_state_t;
 
+typedef enum {
+    HFP_HF_SERVICE_VOICE = 4,
+    HFP_HF_SERVICE_FAX = 5,
+} hfp_subscriber_number_service_t;
+
 /**
  * @endcond
  */

framework/include/bt_hfp_hf.h

@@ -387,6 +387,9 @@ void hfp_hf_callheld_cb(void* cookie, bt_address_t* addr, hfp_callheld_t callhel
  * @endcode
  */
 typedef void (*hfp_hf_callheld_callback)(void* cookie, bt_address_t* addr, hfp_callheld_t callheld);
+typedef void (*hfp_hf_clip_callback)(void* cookie, bt_address_t* addr, const char* number, const char* name);
+typedef void (*hfp_hf_subscriber_number_callback)(void* cookie, bt_address_t* addr, const char* number, hfp_subscriber_number_service_t service);
+typedef void (*hfp_hf_query_current_calls_callback)(void* cookie, bt_address_t* addr, uint8_t num, hfp_current_call_t* calls);
 
 /**
  * @cond
@@ -409,6 +412,9 @@ typedef struct
     hfp_hf_call_callback call_cb;
     hfp_hf_callsetup_callback callsetup_cb;
     hfp_hf_callheld_callback callheld_cb;
+    hfp_hf_clip_callback clip_cb;
+    hfp_hf_subscriber_number_callback subscriber_number_cb;
+    hfp_hf_query_current_calls_callback query_current_calls_cb;
 } hfp_hf_callbacks_t;
 
 /**
@@ -1147,6 +1153,10 @@ int app_send_dtmf(bt_instance_t* ins, bt_address_t* addr, char dtmf);
  */
 bt_status_t BTSYMBOLS(bt_hfp_hf_send_dtmf)(bt_instance_t* ins, bt_address_t* addr, char dtmf);
 
+bt_status_t BTSYMBOLS(bt_hfp_hf_get_subscriber_number)(bt_instance_t* ins, bt_address_t* addr);
+
+bt_status_t BTSYMBOLS(bt_hfp_hf_query_current_calls_with_callback)(bt_instance_t* ins, bt_address_t* addr);
+
 #ifdef __cplusplus
 }
 #endif

framework/include/bt_spp.h

@@ -46,6 +46,8 @@ extern "C" {
  */
 #define BT_UUID_SERVCLASS_SERIAL_PORT 0x1101
 
+#define SPP_PORT_TYPE_TTY 1
+
 /**
  * @brief Spp proxy state
  *
@@ -53,6 +55,8 @@ extern "C" {
 typedef enum {
     SPP_PROXY_STATE_CONNECTED,
     SPP_PROXY_STATE_DISCONNECTED,
+    SPP_PROXY_STATE_CONNECTING,
+    SPP_PROXY_STATE_CLOSING,
 } spp_proxy_state_t;
 
 /**

framework/include/list.h

@@ -137,6 +137,15 @@
         list_initialize(item); \
     } while (0)
 
+#define list_merge(list_dst, list_src)             \
+    do {                                           \
+        (list_dst)->prev->next = (list_src)->next; \
+        (list_src)->next->prev = (list_dst)->prev; \
+        (list_src)->prev->next = (list_dst);       \
+        (list_dst)->prev = (list_src)->prev;       \
+        list_initialize(list_src);                 \
+    } while (0)
+
 #define list_remove_head_type(list, type, member)              \
     ({                                                         \
         FAR struct list_node* __node = list_remove_head(list); \
@@ -272,10 +281,7 @@
  * Public Type Definitions
  ****************************************************************************/
 
-struct list_node {
-    FAR struct list_node* prev;
-    FAR struct list_node* next;
-};
+#include <nuttx/list_type.h>
 
 /****************************************************************************
  * Inline Functions

framework/socket/bt_adapter.c

@@ -771,3 +771,24 @@ bool bt_adapter_is_support_leaudio(bt_instance_t* ins)
 
     return packet.adpt_r.bbool;
 }
+
+bt_status_t bt_adapter_start_limited_discovery(bt_instance_t* ins, uint32_t timeout)
+{
+    bt_message_packet_t packet;
+    bt_status_t status;
+
+    BT_SOCKET_INS_VALID(ins, BT_STATUS_PARM_INVALID);
+
+    packet.adpt_pl._bt_adapter_start_limited_discovery.v32 = timeout;
+    status = bt_socket_client_sendrecv(ins, &packet, BT_ADAPTER_START_LIMITED_DISCOVERY);
+    if (status != BT_STATUS_SUCCESS) {
+        return status;
+    }
+
+    return packet.adpt_r.status;
+}
+
+bt_status_t bt_adapter_disable_safe(bt_instance_t* ins)
+{
+    return bt_adapter_disable(ins);
+}

framework/socket/bt_device.c

@@ -587,4 +587,14 @@ bt_status_t bt_device_get_le_sc_local_oob_data(bt_instance_t* ins, bt_address_t*
     }
 
     return packet.devs_r.status;
+}
+
+bt_status_t bt_device_enable_enhanced_mode(bt_instance_t* ins, bt_address_t* addr, bt_enhanced_mode_t mode)
+{
+    return BT_STATUS_NOT_SUPPORTED;
+}
+
+bt_status_t bt_device_disable_enhanced_mode(bt_instance_t* ins, bt_address_t* addr, bt_enhanced_mode_t mode)
+{
+    return BT_STATUS_NOT_SUPPORTED;
 }

service/ipc/socket/include/bt_message_avrcp_control.h

@@ -44,6 +44,14 @@ BT_AVRCP_CONTROL_MESSAGE_START,
 // TODO: Add new BT IPC Code sequentially
 #define AVRCP_CT_SUBCODE_SEND_PASSTHROUGH_CMD 1
 #define BT_AVRCP_CT_SEND_PASSTHROUGH_CMD BT_IPC_CODE(BT_IPC_CODE_TYPE_COMMAND, BT_IPC_CODE_GROUP_AVRCP_CT, AVRCP_CT_SUBCODE_SEND_PASSTHROUGH_CMD)
+#define AVRCP_CT_SUBCODE_GET_UNIT_INFO_CMD 2
+#define BT_AVRCP_CT_GET_UNIT_INFO_CMD BT_IPC_CODE(BT_IPC_CODE_TYPE_COMMAND, BT_IPC_CODE_GROUP_AVRCP_CT, AVRCP_CT_SUBCODE_GET_UNIT_INFO_CMD)
+#define AVRCP_CT_SUBCODE_GET_SUBUNIT_INFO_CMD 3
+#define BT_AVRCP_CT_GET_SUBUNIT_INFO_CMD BT_IPC_CODE(BT_IPC_CODE_TYPE_COMMAND, BT_IPC_CODE_GROUP_AVRCP_CT, AVRCP_CT_SUBCODE_GET_SUBUNIT_INFO_CMD)
+#define AVRCP_CT_SUBCODE_GET_PLAYBACK_STATE_CMD 4
+#define BT_AVRCP_CT_GET_PLAYBACK_STATE_CMD BT_IPC_CODE(BT_IPC_CODE_TYPE_COMMAND, BT_IPC_CODE_GROUP_AVRCP_CT, AVRCP_CT_SUBCODE_GET_PLAYBACK_STATE_CMD)
+#define AVRCP_CT_SUBCODE_REGISTER_NOTIFICATION_CMD 5
+#define BT_AVRCP_CT_REGISTER_NOTIFICATION_CMD BT_IPC_CODE(BT_IPC_CODE_TYPE_COMMAND, BT_IPC_CODE_GROUP_AVRCP_CT, AVRCP_CT_SUBCODE_REGISTER_NOTIFICATION_CMD)
 #define BT_IPC_CODE_COMMAND_AVRCP_CT_END BT_IPC_CODE(BT_IPC_CODE_TYPE_COMMAND, BT_IPC_CODE_GROUP_AVRCP_CT, BT_IPC_CODE_SUBCODE_MAX_NUM)
 
 #define BT_IPC_CODE_CALLBACK_AVRCP_CT_BEGIN BT_IPC_CODE(BT_IPC_CODE_TYPE_CALLBACK, BT_IPC_CODE_GROUP_AVRCP_CT, 0)
@@ -65,6 +73,19 @@ BT_AVRCP_CONTROL_MESSAGE_START,
             uint8_t cmd;
             uint8_t state;
         } _bt_avrcp_control_send_passthrough_cmd;
+
+        struct {
+            bt_address_t addr;
+        } _bt_avrcp_control_get_unit_info,
+            _bt_avrcp_control_get_subunit_info,
+            _bt_avrcp_control_get_playback_state;
+
+        struct {
+            bt_address_t addr;
+            uint8_t event;
+            uint8_t pad[1];
+            uint32_t interval;
+        } _bt_avrcp_control_register_notification;
     } bt_message_avrcp_control_t;
 
     typedef union {

service/ipc/socket/include/bt_message_hfp_hf.h

@@ -41,6 +41,7 @@ BT_HFP_HF_MESSAGE_START,
     BT_HFP_HF_UPDATE_BATTERY_LEVEL,
     BT_HFP_HF_VOLUME_CONTROL,
     BT_HFP_HF_SEND_DTMF,
+    BT_HFP_HF_QUERY_CURRENT_CALLS_WITH_CALLBACK,
     BT_HFP_HF_MESSAGE_END,
 #endif
 
@@ -56,6 +57,9 @@ BT_HFP_HF_MESSAGE_START,
     BT_HFP_HF_ON_CALL_IND_RECEIVED,
     BT_HFP_HF_ON_CALLSETUP_IND_RECEIVED,
     BT_HFP_HF_ON_CALLHELD_IND_RECEIVED,
+    BT_HFP_HF_ON_CLIP_RECEIVED,
+    BT_HFP_HF_ON_SUBSCRIBER_NUMBER_RECEIVED,
+    BT_HFP_HF_ON_CURRENT_CALLS,
     BT_HFP_HF_CALLBACK_END,
 #endif
 
@@ -70,6 +74,11 @@ BT_HFP_HF_MESSAGE_START,
 #include "bt_hfp_hf.h"
 #include "bt_ipc_code.h"
 
+#define HFP_HF_SUBCODE_GET_SUBSCRIBER_NUMBER 0x01
+#define HFP_HF_SUBCODE_ON_CLIP_RECEIVED 0x02
+#define HFP_HF_SUBCODE_ON_SUBSCRIBER_NUMBER_RECEIVED 0x03
+#define HFP_HF_SUBCODE_ON_CURRENT_CALLS_FINISHED 0x04
+
 #define BT_IPC_CODE_COMMAND_HFP_HF_BEGIN BT_IPC_CODE(BT_IPC_CODE_TYPE_COMMAND, BT_IPC_CODE_GROUP_HFP_HF, 0)
 // TODO: Add new BT IPC Code sequentially
 #define BT_IPC_CODE_COMMAND_HFP_HF_END BT_IPC_CODE(BT_IPC_CODE_TYPE_COMMAND, BT_IPC_CODE_GROUP_HFP_HF, BT_IPC_CODE_SUBCODE_MAX_NUM)
@@ -156,6 +165,11 @@ BT_HFP_HF_MESSAGE_START,
             bt_address_t addr;
             uint8_t dtmf;
         } _bt_hfp_hf_send_dtmf;
+
+        struct {
+            bt_address_t addr;
+        } _bt_hfp_hf_query_current_calls_with_callback,
+            _bt_hfp_hf_get_subscriber_number;
     } bt_message_hfp_hf_t;
 
     typedef union {
@@ -202,6 +216,24 @@ BT_HFP_HF_MESSAGE_START,
         } _on_call_cb,
             _on_callsetup_cb,
             _on_callheld_cb;
+
+        struct {
+            bt_address_t addr;
+            char number[HFP_PHONENUM_DIGITS_MAX + 1];
+            char name[HFP_NAME_DIGITS_MAX + 1];
+        } _on_clip_cb;
+
+        struct {
+            bt_address_t addr;
+            char number[HFP_PHONENUM_DIGITS_MAX + 1];
+            uint8_t service; /* hfp_subscriber_number_service_t */
+        } _on_subscriber_number_cb;
+
+        struct {
+            bt_address_t addr;
+            uint8_t num;
+            hfp_current_call_t calls[HFP_CALL_LIST_MAX];
+        } _on_current_calls_cb;
     } bt_message_hfp_hf_callbacks_t;
 
 #ifdef __cplusplus

service/ipc/socket/src/bt_socket_advertiser.c

@@ -132,7 +132,7 @@ void bt_socket_server_advertiser_process(service_poll_t* poll,
 #endif
 
 int bt_socket_client_advertiser_callback(service_poll_t* poll,
-    int fd, bt_instance_t* ins, bt_message_packet_t* packet)
+    int fd, bt_instance_t* ins, bt_message_packet_t* packet, bool is_async)
 {
     switch (packet->code) {
     case BT_LE_ON_ADVERTISER_START: {

service/ipc/socket/src/bt_socket_gattc.c

@@ -345,7 +345,7 @@ void bt_socket_server_gattc_process(service_poll_t* poll, int fd,
 #endif
 
 int bt_socket_client_gattc_callback(service_poll_t* poll,
-    int fd, bt_instance_t* ins, bt_message_packet_t* packet)
+    int fd, bt_instance_t* ins, bt_message_packet_t* packet, bool is_async)
 {
     bt_gattc_remote_t* gattc_remote = INT2PTR(bt_gattc_remote_t*) packet->gattc_cb._on_callback.remote;
     CHECK_REMOTE_VALID(ins->gattc_remote_list, gattc_remote);

service/ipc/socket/src/bt_socket_gatts.c

@@ -351,7 +351,7 @@ void bt_socket_server_gatts_process(service_poll_t* poll, int fd,
 #endif
 
 int bt_socket_client_gatts_callback(service_poll_t* poll,
-    int fd, bt_instance_t* ins, bt_message_packet_t* packet)
+    int fd, bt_instance_t* ins, bt_message_packet_t* packet, bool is_async)
 {
     bt_gatts_remote_t* gatts_remote = INT2PTR(bt_gatts_remote_t*) packet->gatts_cb._on_callback.remote;
     CHECK_REMOTE_VALID(ins->gatts_remote_list, gatts_remote);

service/ipc/socket/src/bt_socket_manager.c

@@ -96,7 +96,7 @@ void bt_socket_server_manager_process(service_poll_t* poll,
 }
 #endif
 int bt_socket_client_manager_callback(service_poll_t* poll,
-    int fd, bt_instance_t* ins, bt_message_packet_t* packet)
+    int fd, bt_instance_t* ins, bt_message_packet_t* packet, bool is_async)
 {
     switch (packet->code) {
     default:

service/ipc/socket/src/bt_socket_scan.c

@@ -268,7 +268,7 @@ void bt_socket_server_scan_process(service_poll_t* poll,
 #endif
 
 int bt_socket_client_scan_callback(service_poll_t* poll,
-    int fd, bt_instance_t* ins, bt_message_packet_t* packet)
+    int fd, bt_instance_t* ins, bt_message_packet_t* packet, bool is_async)
 {
     switch (packet->code) {
     case BT_LE_ON_SCAN_RESULT: {

service/profiles/a2dp/codec/a2dp_codec_sbc.c

@@ -106,9 +106,9 @@ static int a2dp_get_sbc_blocks(a2dp_sbc_info_t* info)
 static int a2dp_get_sbc_subbands(a2dp_sbc_info_t* info)
 {
     switch (info->num_subbands) {
-    case A2DP_SBC_SUBBAND_4:
+    case BT_A2DP_SBC_SUBBAND_4:
         return SUB_BANDS_4;
-    case A2DP_SBC_SUBBAND_8:
+    case BT_A2DP_SBC_SUBBAND_8:
         return SUB_BANDS_8;
     default:
         break;

service/profiles/a2dp/sink/a2dp_sink_service.c

@@ -138,7 +138,7 @@ static void a2dp_snk_service_handle_event(void* data)
         break;
     }
     case PEER_STREAM_START_REQ:
-        bt_sal_a2dp_sink_start_stream(&event->event_data.bd_addr);
+        bt_sal_a2dp_sink_start_stream(PRIMARY_ADAPTER, &event->event_data.bd_addr);
         break;
     default: {
         a2dp_state_machine_t* a2dp_sm;

service/profiles/gatt/gatts_service.c

@@ -720,7 +720,7 @@ static bt_status_t if_gatts_notify(void* srv_handle, bt_address_t* addr, uint16_
         return BT_STATUS_PARM_INVALID;
     }
 
-    return bt_sal_gatt_server_send_notification(PRIMARY_ADAPTER, addr, element->uuid, value, length);
+    return bt_sal_gatt_server_send_notification(PRIMARY_ADAPTER, addr, element, value, length);
 #else
     return bt_sal_gatt_server_send_notification(PRIMARY_ADAPTER, addr, attr_handle + service->srv_id, value, length);
 #endif
@@ -745,7 +745,7 @@ static bt_status_t if_gatts_indicate(void* srv_handle, bt_address_t* addr, uint1
         return BT_STATUS_PARM_INVALID;
     }
 
-    return bt_sal_gatt_server_send_indication(PRIMARY_ADAPTER, addr, element->uuid, value, length);
+    return bt_sal_gatt_server_send_indication(PRIMARY_ADAPTER, addr, element, value, length);
 #else
     return bt_sal_gatt_server_send_indication(PRIMARY_ADAPTER, addr, attr_handle + service->srv_id, value, length);
 #endif

service/profiles/hfp_hf/hfp_hf_service.c

@@ -378,7 +378,7 @@ static bt_status_t hfp_hf_init(void)
         return BT_STATUS_NOMEM;
     }
 
-    ret = audio_ctrl_init();
+    ret = audio_ctrl_init(PROFILE_HFP_HF);
     if (ret != BT_STATUS_SUCCESS) {
         BT_LOGE("%s: failed to start audio control channel", __func__);
         bt_callbacks_list_free(g_hfp_service.callbacks);
@@ -391,7 +391,7 @@ static bt_status_t hfp_hf_init(void)
 
 static void hfp_hf_cleanup(void)
 {
-    audio_ctrl_cleanup();
+    audio_ctrl_cleanup(PROFILE_HFP_HF);
     bt_callbacks_list_free(g_hfp_service.callbacks);
     g_hfp_service.callbacks = NULL;
 }

service/profiles/include/audio_control.h

@@ -37,10 +37,24 @@
  * Included Files
  ****************************************************************************/
 #include "audio_transport.h"
+#include "bt_profile.h"
+#include "audio_codec.h"
 #include "bt_status.h"
 
+#define HFP_HF_PROFILE_ID PROFILE_HFP_HF
+#define HFP_AG_PROFILE_ID PROFILE_HFP_AG
+
+typedef struct {
+    size_t size;
+    void (*start_cb)(void);
+    void (*stop_cb)(void);
+} audio_control_callbacks_t;
+
 void audio_ctrl_send_control_event(uint8_t profile_id, audio_ctrl_evt_t evt);
 bt_status_t audio_ctrl_init(uint8_t profile_id);
 void audio_ctrl_cleanup(uint8_t profile_id);
+void audio_control_open(uint8_t profile_id, bt_audio_config_t* config, audio_control_callbacks_t* callbacks);
+void audio_control_start(uint8_t profile_id, bool start);
+void audio_control_stop(uint8_t profile_id);
 
 #endif

service/profiles/include/avrcp_control_service.h

@@ -51,6 +51,18 @@ typedef struct {
     /** send passthrough command */
     bt_status_t (*avrcp_control_send_passthrough_cmd)(bt_address_t* bd_addr, uint8_t cmd, uint8_t state);
 
+    /** get unit info */
+    bt_status_t (*avrcp_control_get_unit_info)(bt_address_t* bd_addr);
+
+    /** get subunit info */
+    bt_status_t (*avrcp_control_get_subunit_info)(bt_address_t* bd_addr);
+
+    /** get playback state */
+    bt_status_t (*avrcp_control_get_playback_state)(bt_address_t* bd_addr);
+
+    /** register notification */
+    bt_status_t (*avrcp_control_register_notification)(bt_address_t* bd_addr, avrcp_notification_event_t event, uint32_t interval);
+
 } avrcp_control_interface_t;
 
 /*

service/profiles/include/gatt_define.h

@@ -43,6 +43,7 @@
 typedef enum {
     GATT_WRITE_TYPE_NO_RSP = 0, /*!< Gatt write attribute need no response */
     GATT_WRITE_TYPE_RSP, /*!< Gatt write attribute need remote response */
+    GATT_WRITE_TYPE_SIGNED, /*!< Gatt signed write */
 } gatt_write_type_t;
 
 /**

service/profiles/include/gattc_service.h

@@ -60,6 +60,7 @@ typedef struct gattc_interface {
     bt_status_t (*read)(void* conn_handle, uint16_t attr_handle);
     bt_status_t (*write)(void* conn_handle, uint16_t attr_handle, uint8_t* value, uint16_t length);
     bt_status_t (*write_without_response)(void* conn_handle, uint16_t attr_handle, uint8_t* value, uint16_t length);
+    bt_status_t (*write_signed)(void* conn_handle, uint16_t attr_handle, uint8_t* value, uint16_t length);
     bt_status_t (*subscribe)(void* conn_handle, uint16_t attr_handle, uint16_t ccc_value);
     bt_status_t (*unsubscribe)(void* conn_handle, uint16_t attr_handle);
     bt_status_t (*exchange_mtu)(void* conn_handle, uint32_t mtu);

service/profiles/include/hfp_hf_service.h

@@ -77,6 +77,7 @@ void hfp_hf_on_current_call_response(bt_address_t* addr, uint32_t idx,
     hfp_call_mpty_type_t mpty,
     const char* number, uint32_t type);
 void hfp_hf_on_at_command_result_response(bt_address_t* addr, uint32_t at_cmd_code, uint32_t result);
+void hfp_hf_on_subscriber_number_response(bt_address_t* addr, const char* number, hfp_subscriber_number_service_t service);
 
 /*
  *  statemachine callbacks
@@ -92,6 +93,9 @@ void hf_service_notify_volume_changed(bt_address_t* addr, hfp_volume_type_t type
 void hf_service_notify_call(bt_address_t* addr, hfp_call_t call);
 void hf_service_notify_callsetup(bt_address_t* addr, hfp_callsetup_t callsetup);
 void hf_service_notify_callheld(bt_address_t* addr, hfp_callheld_t callheld);
+void hf_service_notify_clip_received(bt_address_t* addr, const char* number, const char* name);
+void hf_service_notify_subscriber_number(bt_address_t* addr, const char* number, hfp_subscriber_number_service_t service);
+void hf_service_notify_current_calls(bt_address_t* addr, uint8_t num, hfp_current_call_t* calls);
 
 /*
  * service api
@@ -128,6 +132,8 @@ typedef struct hf_interface {
     bt_status_t (*update_battery_level)(bt_address_t* addr, uint8_t level);
     bt_status_t (*volume_control)(bt_address_t* addr, hfp_volume_type_t type, uint8_t volume);
     bt_status_t (*send_dtmf)(bt_address_t* addr, char dtmf);
+    bt_status_t (*get_subscriber_number)(bt_address_t* addr);
+    bt_status_t (*query_current_calls_with_callback)(bt_address_t* addr);
 } hfp_hf_interface_t;
 
 /*

service/profiles/include/hfp_hf_state_machine.h

@@ -24,6 +24,8 @@ typedef enum pending_state {
     PENDING_NONE = 0x0,
     PENDING_OFFLOAD_START = 0x02,
     PENDING_OFFLOAD_STOP = 0x04,
+    PENDING_CURRENT_CALLS_QUERY = 0x08,
+    PENDING_AUDIO_DISCONNECT = 0x10,
 } pending_state_t;
 
 typedef struct _hf_state_machine hf_state_machine_t;

service/profiles/service_manager.h

@@ -35,6 +35,7 @@ typedef enum {
     PROFILE_EVT_A2DP_OFFLOADING = 1,
     PROFILE_EVT_HFP_OFFLOADING,
     PROFILE_EVT_LEA_OFFLOADING,
+    PROFILE_EVT_REMOTE_DETACH,
 } profile_event_t;
 
 typedef struct

service/src/advertising.c

@@ -199,7 +199,7 @@ static void advertiser_start_event(void* data)
     }
 
     adver->adv_id = adv_id + 1;
-    if (bt_sal_le_start_adv(adver->adv_id, &adv_info->params, adv_info->adv_data,
+    if (bt_sal_le_start_adv(0, adver->adv_id, &adv_info->params, adv_info->adv_data,
             adv_info->adv_len, adv_info->scan_rsp_data,
             adv_info->scan_rsp_len)
         != BT_STATUS_SUCCESS) {
@@ -241,7 +241,7 @@ static void advertiser_stop_event(void* data)
         }
     }
 
-    bt_sal_le_stop_adv(adver->adv_id);
+    bt_sal_le_stop_adv(0, adver->adv_id);
 }
 
 static void advertiser_notify_state(void* data)
@@ -283,7 +283,7 @@ static void advertisers_cleanup(void* data)
     list_for_every_safe(&adv_manager.advertiser_list, node, tmp)
     {
         advertiser_t* adver = (advertiser_t*)node;
-        bt_sal_le_stop_adv(adver->adv_id);
+        bt_sal_le_stop_adv(0, adver->adv_id);
         delete_advertiser(adver);
         adver->callbacks.on_advertising_stopped(get_adver(adver), adver->adv_id);
         destroy_advertiser(adver);

service/src/device.c

@@ -349,9 +349,20 @@ bond_state_t device_get_bond_state(bt_device_t* device)
     return device->remote.bond_state;
 }
 
-void device_set_bond_state(bt_device_t* device, bond_state_t state)
+void device_set_bond_state(bt_device_t* device, bond_state_t state, bool is_ctkd, void (*notify)(void*))
 {
+    bond_state_t previous = device->remote.bond_state;
     device->remote.bond_state = state;
+
+    if (notify) {
+        bond_state_change_message_t* msg = zalloc(sizeof(*msg));
+        if (msg) {
+            msg->device = device;
+            msg->previous_state = previous;
+            msg->is_ctkd = is_ctkd;
+            notify(msg);
+        }
+    }
 }
 
 bool device_is_bonded(bt_device_t* device)

service/src/device.h

@@ -67,7 +67,7 @@ void device_set_local_role(bt_device_t* device, bt_link_role_t role);
 void device_set_bond_initiate_local(bt_device_t* device, bool initiate_local);
 bool device_is_bond_initiate_local(bt_device_t* device);
 bond_state_t device_get_bond_state(bt_device_t* device);
-void device_set_bond_state(bt_device_t* device, bond_state_t state);
+void device_set_bond_state(bt_device_t* device, bond_state_t state, bool is_ctkd, void (*notify)(void*));
 bool device_is_bonded(bt_device_t* device);
 uint8_t* device_get_link_key(bt_device_t* device);
 void device_set_link_key(bt_device_t* device, bt_128key_t link_key);

service/src/manager_service.c

@@ -197,8 +197,10 @@ void manager_init(void)
 #if defined(CONFIG_BLUETOOTH_SERVICE) && defined(__NuttX__)
     service_manager_init();
     bt_pm_init();
+#ifdef CONFIG_BLUETOOTH_CONNECTION_MANAGER
     bt_cm_init();
 #endif
+#endif
 }
 
 void manager_cleanup(void)
@@ -221,7 +223,9 @@ void manager_cleanup(void)
 #if defined(CONFIG_BLUETOOTH_SERVICE) && defined(__NuttX__)
     service_manager_cleanup();
     bt_pm_cleanup();
+#ifdef CONFIG_BLUETOOTH_CONNECTION_MANAGER
     bt_cm_cleanup();
+#endif
 #endif
     uv_mutex_destroy(&g_mutex);
 }

service/stacks/include/sal_adapter_classic_interface.h

@@ -27,11 +27,6 @@
 #include "bluetooth_define.h"
 #include "power_manager.h"
 
-typedef struct {
-    uint8_t hash[16];
-    uint8_t rand[16];
-} bt_oob_data_t;
-
 /* service adapter layer for BREDR */
 // #ifdef CONFIG_BLUETOOTH_BREDR_SUPPORT
 bt_status_t bt_sal_init(const bt_vhal_interface* vhal);

service/stacks/include/sal_gatt_server_interface.h

@@ -37,8 +37,8 @@ bt_status_t bt_sal_gatt_server_connect_bear(bt_controller_id_t id, bt_address_t*
 bt_status_t bt_sal_gatt_server_cancel_connection(bt_controller_id_t id, bt_address_t* addr);
 bt_status_t bt_sal_gatt_server_send_response(bt_controller_id_t id, bt_address_t* addr, uint32_t request_id, uint8_t* value, uint16_t length);
 #if defined(CONFIG_BLUETOOTH_STACK_LE_ZBLUE)
-bt_status_t bt_sal_gatt_server_send_notification(bt_controller_id_t id, bt_address_t* addr, bt_uuid_t element_id, uint8_t* value, uint16_t length);
-bt_status_t bt_sal_gatt_server_send_indication(bt_controller_id_t id, bt_address_t* addr, bt_uuid_t element_id, uint8_t* value, uint16_t length);
+bt_status_t bt_sal_gatt_server_send_notification(bt_controller_id_t id, bt_address_t* addr, gatt_element_t* element, uint8_t* value, uint16_t length);
+bt_status_t bt_sal_gatt_server_send_indication(bt_controller_id_t id, bt_address_t* addr, gatt_element_t* element, uint8_t* value, uint16_t length);
 #else
 bt_status_t bt_sal_gatt_server_send_notification(bt_controller_id_t id, bt_address_t* addr, uint16_t element_id, uint8_t* value, uint16_t length);
 bt_status_t bt_sal_gatt_server_send_indication(bt_controller_id_t id, bt_address_t* addr, uint16_t element_id, uint8_t* value, uint16_t length);

service/stacks/zephyr/include/sal_connection_manager.h

@@ -13,23 +13,51 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  ***************************************************************************/
+#ifndef __SAL_CONNECTION_MANAGER_H__
+#define __SAL_CONNECTION_MANAGER_H__
+
 #include "bluetooth.h"
 #include "bt_addr.h"
 #include "bt_profile.h"
 
+#define CONN_ID_DEFAULT 0
+
+typedef bt_status_t (*bt_profile_conn_handler_t)(bt_controller_id_t id, bt_address_t* addr, void* user_data);
+
+typedef struct {
+    uint8_t profile_id;
+    uint16_t conn_id;
+    bt_profile_conn_handler_t handler;
+    bt_controller_id_t id;
+    void* user_data;
+    bool is_busy;
+} bt_profile_conn_handler_node_t;
+
 typedef struct {
     bt_address_t addr;
     uint8_t profile_id;
+    uint16_t conn_id;
 } cm_data_t;
 
-cm_data_t* cm_data_new(bt_address_t* addr, uint8_t profile_id);
-void bt_sal_cm_profile_disconnected_callback(cm_data_t* data);
+cm_data_t* cm_data_new(bt_address_t* addr, uint8_t profile_id, uint16_t conn_id);
+void bt_sal_cm_profile_connected_callback(bt_address_t* addr, uint8_t profile_id, uint16_t conn_id);
+void bt_sal_cm_profile_disconnected_callback(bt_address_t* addr, uint8_t profile_id, uint16_t conn_id);
+void bt_sal_cm_acl_connected_callback(cm_data_t* data);
 void bt_sal_cm_acl_disconnected_callback(cm_data_t* data);
 
+bt_status_t bt_sal_profile_connect_request(bt_address_t* addr, uint8_t profile_id, uint16_t conn_id, bt_controller_id_t id,
+    bt_profile_conn_handler_t handler, void* user_data);
+bt_status_t bt_sal_profile_disconnect_register(bt_address_t* addr, uint8_t profile_id, uint16_t conn_id, bt_controller_id_t id,
+    bt_profile_conn_handler_t handler, void* user_data);
+bt_status_t bt_sal_profile_disconnect_request(bt_address_t* addr, uint8_t profile_id, uint16_t conn_id, bt_controller_id_t id,
+    bt_profile_conn_handler_t handler, void* user_data);
+
 void bt_sal_cm_conn_init(void);
 bt_status_t bt_sal_cm_try_disconnect_profiles(bt_address_t* addr, bool is_unpair);
 void bt_sal_cm_conn_cleanup(void);
 
 bool bt_sal_a2dp_try_disconnect_a2dp_sink(bt_controller_id_t id, bt_address_t* addr);
 bool bt_sal_a2dp_try_disconnect_a2dp_srouce(bt_controller_id_t id, bt_address_t* addr);
-bool bt_sal_avrcp_try_disconnect_avrcp_control(bt_controller_id_t id, bt_address_t* addr);
+bool bt_sal_avrcp_try_disconnect_avrcp_control(bt_controller_id_t id, bt_address_t* addr);
+
+#endif /* __SAL_CONNECTION_MANAGER_H__ */

service/stacks/zephyr/sal_a2dp_interface.c

@@ -15,6 +15,10 @@
  ***************************************************************************/
 #define LOG_TAG "sal_a2dp"
 
+#ifndef CONFIG_ZBLUE_A2DP_SBC_MAX_BIT_POOL
+#define CONFIG_ZBLUE_A2DP_SBC_MAX_BIT_POOL 53
+#endif
+
 #include <assert.h>
 #include <math.h>
 #include <stdbool.h>

service/stacks/zephyr/sal_connection_manager.c

@@ -22,6 +22,9 @@
 
 #include "utils/log.h"
 
+bt_status_t bt_sal_disconnect_internal(bt_controller_id_t id, bt_address_t* addr, uint8_t reason);
+bt_status_t bt_sal_remove_bond_internal(bt_controller_id_t id, bt_address_t* addr);
+
 typedef struct {
     bt_address_t device_addr;
     bool is_unpair;

service/stacks/zephyr/sal_gatt_server_interface.c

@@ -43,6 +43,10 @@
 #define CONFIG_GATT_SERVER_MAX_SERVICES 20
 #endif
 
+struct gatt_user_data {
+    gatt_element_t* element;
+};
+
 #ifndef CONFIG_GATT_SERVER_MAX_ATTRIBUTES
 #define CONFIG_GATT_SERVER_MAX_ATTRIBUTES 60
 #endif

service/stacks/zephyr/sal_hid_device_stub.c

@@ -0,0 +1,65 @@
+/****************************************************************************
+ *  Copyright (C) 2025 Xiaomi Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ ***************************************************************************/
+#include "sal_hid_device_interface.h"
+
+bt_status_t bt_sal_hid_device_init(void)
+{
+    return BT_STATUS_NOT_SUPPORTED;
+}
+
+void bt_sal_hid_device_cleanup(void)
+{
+}
+
+bt_status_t bt_sal_hid_device_register_app(hid_device_sdp_settings_t* sdp, bool le_hid)
+{
+    return BT_STATUS_NOT_SUPPORTED;
+}
+
+bt_status_t bt_sal_hid_device_unregister_app(void)
+{
+    return BT_STATUS_NOT_SUPPORTED;
+}
+
+bt_status_t bt_sal_hid_device_connect(bt_address_t* addr)
+{
+    return BT_STATUS_NOT_SUPPORTED;
+}
+
+bt_status_t bt_sal_hid_device_disconnect(bt_address_t* addr)
+{
+    return BT_STATUS_NOT_SUPPORTED;
+}
+
+bt_status_t bt_sal_hid_device_get_report_response(bt_address_t* addr, uint8_t rpt_type, uint8_t* rpt_data, int rpt_size)
+{
+    return BT_STATUS_NOT_SUPPORTED;
+}
+
+bt_status_t bt_sal_hid_device_report_error(bt_address_t* addr, hid_status_error_t error)
+{
+    return BT_STATUS_NOT_SUPPORTED;
+}
+
+bt_status_t bt_sal_hid_device_send_report(bt_address_t* addr, uint8_t rpt_id, uint8_t* rpt_data, int rpt_size)
+{
+    return BT_STATUS_NOT_SUPPORTED;
+}
+
+bt_status_t bt_sal_hid_device_virtual_unplug(bt_address_t* addr)
+{
+    return BT_STATUS_NOT_SUPPORTED;
+}

service/utils/btsnoop_writer.c

@@ -29,6 +29,7 @@
 #include "btsnoop_log.h"
 #include "btsnoop_writer.h"
 
+#define SNOOP_PATH_MAX_LEN 128
 #define SNOOP_FILE_NAME_PREFIX "/snoop_"
 #define SNOOP_FILE_NAME_PREFIX_LEN 7
 #define SNOOP_FILE_NAME_DATE_LEN 80

service/vhal/bt_vhal.c

@@ -48,7 +48,9 @@ static int bt_vhal_send(uint8_t* value, uint32_t size)
 {
     switch (*value) {
     case HCI_TYPE_COMMAND: {
+#ifdef CONFIG_BLUETOOTH_HCI_FILTER
         bt_hci_filter_can_send(value, size);
+#endif
         break;
     }
     default:
@@ -64,7 +66,9 @@ static int bt_vhal_recv(uint8_t* value, uint32_t size)
 
     switch (*value) {
     case HCI_TYPE_EVENT: {
+#ifdef CONFIG_BLUETOOTH_HCI_FILTER
         ret = bt_hci_filter_can_recv(value, size);
+#endif
         break;
     }
     default: