1 /*
2 * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 #include <string.h>
8
9 #include "osi/allocator.h"
10 #include "stack/bt_types.h"
11 #include "common/bt_defs.h"
12 #include "bta/bta_api.h"
13 #include "bta/bta_dm_co.h"
14 #include "btc/btc_task.h"
15 #include "btc/btc_manage.h"
16 #include "btc_gap_ble.h"
17 #include "btc_gatt_util.h"
18 #include "esp_bt_defs.h"
19 #include "esp_gap_ble_api.h"
20 #include "btc/btc_ble_storage.h"
21 #include "btc/btc_dm.h"
22 #include "btc/btc_util.h"
23 #include "osi/mutex.h"
24 #include "osi/thread.h"
25 #include "osi/pkt_queue.h"
26 #include "esp_bt.h"
27
28 #if (BLE_INCLUDED == TRUE)
29 #if (BLE_42_FEATURE_SUPPORT == TRUE)
30 #if BTC_DYNAMIC_MEMORY == FALSE
31 static tBTA_BLE_ADV_DATA gl_bta_adv_data;
32 static tBTA_BLE_ADV_DATA gl_bta_scan_rsp_data;
33 #else
34 tBTA_BLE_ADV_DATA *gl_bta_adv_data_ptr;
35 tBTA_BLE_ADV_DATA *gl_bta_scan_rsp_data_ptr;
36 #endif
37 #endif // #if (BLE_42_FEATURE_SUPPORT == TRUE)
38
39 #if SCAN_QUEUE_CONGEST_CHECK
40 static list_t *adv_filter_list;
41 static osi_mutex_t adv_list_lock;
42 bool btc_check_adv_list(uint8_t * addr, uint8_t addr_type);
43 uint32_t btc_get_adv_list_length(void);
44 void btc_adv_list_refresh(void);
45 void btc_adv_list_lock(void);
46 void btc_adv_list_unlock(void);
47 static uint16_t btc_adv_list_count = 0;
48
49 #define BTC_ADV_LIST_MAX_LENGTH 50
50 #define BTC_ADV_LIST_MAX_COUNT 200
51 #endif
52
53 #define BTC_GAP_BLE_ADV_RPT_QUEUE_IDX (1)
54 #define BTC_GAP_BLE_ADV_RPT_BATCH_SIZE (10)
55 #define BTC_GAP_BLE_ADV_RPT_QUEUE_LEN_MAX (200)
56
57 #if (BLE_42_FEATURE_SUPPORT == TRUE)
58 typedef struct {
59 struct pkt_queue *adv_rpt_queue;
60 struct osi_event *adv_rpt_ready;
61 } btc_gap_ble_env_t;
62
63 static btc_gap_ble_env_t btc_gap_ble_env;
64 #endif
65
btc_gap_ble_cb_to_app(esp_gap_ble_cb_event_t event,esp_ble_gap_cb_param_t * param)66 static inline void btc_gap_ble_cb_to_app(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
67 {
68 esp_gap_ble_cb_t btc_gap_ble_cb = (esp_gap_ble_cb_t)btc_profile_cb_get(BTC_PID_GAP_BLE);
69 if (btc_gap_ble_cb) {
70 btc_gap_ble_cb(event, param);
71 }
72 }
73
btc_gap_ble_get_dev_name_callback(UINT8 status,char * name)74 static void btc_gap_ble_get_dev_name_callback(UINT8 status, char *name)
75 {
76 esp_ble_gap_cb_param_t param;
77 bt_status_t ret;
78 btc_msg_t msg = {0};
79
80 memset(¶m, 0, sizeof(esp_ble_gap_cb_param_t));
81
82 msg.sig = BTC_SIG_API_CB;
83 msg.pid = BTC_PID_GAP_BLE;
84 msg.act = ESP_GAP_BLE_GET_DEV_NAME_COMPLETE_EVT;
85
86 param.get_dev_name_cmpl.status = btc_btm_status_to_esp_status(status);
87 param.get_dev_name_cmpl.name = (char *)osi_malloc(BTC_MAX_LOC_BD_NAME_LEN + 1);
88 if (param.get_dev_name_cmpl.name) {
89 BCM_STRNCPY_S(param.get_dev_name_cmpl.name, name, BTC_MAX_LOC_BD_NAME_LEN);
90 param.get_dev_name_cmpl.name[BTC_MAX_LOC_BD_NAME_LEN] = '\0';
91 } else {
92 param.get_dev_name_cmpl.status = ESP_BT_STATUS_NOMEM;
93 }
94
95 ret = btc_transfer_context(&msg, ¶m, sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
96 if (ret != BT_STATUS_SUCCESS) {
97 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
98 }
99 }
100
101 #if (BLE_42_FEATURE_SUPPORT == TRUE)
btc_gap_adv_point_cleanup(void ** buf)102 static void btc_gap_adv_point_cleanup(void **buf)
103 {
104 if (NULL == *buf) {
105 return;
106 }
107 osi_free(*buf);
108 *buf = NULL;
109 }
110
111
btc_cleanup_adv_data(tBTA_BLE_ADV_DATA * bta_adv_data)112 static void btc_cleanup_adv_data(tBTA_BLE_ADV_DATA *bta_adv_data)
113 {
114 if (bta_adv_data == NULL) {
115 return;
116 }
117
118 // Manufacturer data cleanup
119 if (bta_adv_data->p_manu != NULL) {
120 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_manu->p_val);
121 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_manu);
122 }
123
124 // Proprietary data cleanup
125 if (bta_adv_data->p_proprietary != NULL) {
126 int i = 0;
127 tBTA_BLE_PROP_ELEM *p_elem = bta_adv_data->p_proprietary->p_elem;
128 while (i++ != bta_adv_data->p_proprietary->num_elem
129 && p_elem) {
130 btc_gap_adv_point_cleanup((void **) &p_elem->p_val);
131 ++p_elem;
132 }
133
134 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_proprietary->p_elem);
135 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_proprietary);
136 }
137
138 // Service list cleanup
139 if (bta_adv_data->p_services != NULL) {
140 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_services->p_uuid);
141 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_services);
142 }
143
144 // Service data cleanup
145 if (bta_adv_data->p_service_data != NULL) {
146 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_service_data->p_val);
147 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_service_data);
148 }
149
150 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_services_128b);
151
152 if (bta_adv_data->p_service_32b != NULL) {
153 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_service_32b->p_uuid);
154 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_service_32b);
155 }
156
157 if (bta_adv_data->p_sol_services != NULL) {
158 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_sol_services->p_uuid);
159 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_sol_services);
160 }
161
162 if (bta_adv_data->p_sol_service_32b != NULL) {
163 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_sol_service_32b->p_uuid);
164 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_sol_service_32b);
165 }
166
167 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_sol_service_128b);
168 }
169
btc_to_bta_adv_data(esp_ble_adv_data_t * p_adv_data,tBTA_BLE_ADV_DATA * bta_adv_data,uint32_t * data_mask)170 static void btc_to_bta_adv_data(esp_ble_adv_data_t *p_adv_data, tBTA_BLE_ADV_DATA *bta_adv_data, uint32_t *data_mask)
171 {
172 uint32_t mask;
173
174 btc_cleanup_adv_data(bta_adv_data);
175
176 memset(bta_adv_data, 0, sizeof(tBTA_BLE_ADV_DATA));
177 mask = 0;
178
179 if (p_adv_data->flag != 0) {
180 mask = BTM_BLE_AD_BIT_FLAGS;
181 bta_adv_data->flag = p_adv_data->flag;
182 }
183
184 if (p_adv_data->include_name) {
185 mask |= BTM_BLE_AD_BIT_DEV_NAME;
186 }
187
188 if (p_adv_data->include_txpower) {
189 mask |= BTM_BLE_AD_BIT_TX_PWR;
190 bta_adv_data->tx_power = esp_ble_tx_power_get(ESP_BLE_PWR_TYPE_ADV);
191 }
192
193 if (p_adv_data->min_interval > 0 && p_adv_data->max_interval > 0 &&
194 p_adv_data->max_interval >= p_adv_data->min_interval) {
195 mask |= BTM_BLE_AD_BIT_INT_RANGE;
196 bta_adv_data->int_range.low = p_adv_data->min_interval;
197 bta_adv_data->int_range.hi = p_adv_data->max_interval;
198 }
199
200 if (p_adv_data->include_txpower) {
201 //TODO
202 }
203
204 if (p_adv_data->appearance != 0) {
205 mask |= BTM_BLE_AD_BIT_APPEARANCE;
206 bta_adv_data->appearance = p_adv_data->appearance;
207 }
208
209 if (p_adv_data->manufacturer_len > 0 && p_adv_data->p_manufacturer_data != NULL) {
210 bta_adv_data->p_manu = osi_malloc(sizeof(tBTA_BLE_MANU));
211 if (bta_adv_data->p_manu != NULL) {
212 bta_adv_data->p_manu->p_val = osi_malloc(p_adv_data->manufacturer_len);
213 if (bta_adv_data->p_manu->p_val != NULL) {
214 mask |= BTM_BLE_AD_BIT_MANU;
215 bta_adv_data->p_manu->len = p_adv_data->manufacturer_len;
216 memcpy(bta_adv_data->p_manu->p_val, p_adv_data->p_manufacturer_data, p_adv_data->manufacturer_len);
217 }
218 }
219 }
220
221 tBTA_BLE_PROP_ELEM *p_elem_service_data = NULL;
222 if (p_adv_data->service_data_len > 0 && p_adv_data->p_service_data != NULL) {
223 p_elem_service_data = osi_malloc(sizeof(tBTA_BLE_PROP_ELEM));
224 if (p_elem_service_data != NULL) {
225 p_elem_service_data->p_val = osi_malloc(p_adv_data->service_data_len);
226 if (p_elem_service_data->p_val != NULL) {
227 p_elem_service_data->adv_type = BTM_BLE_AD_TYPE_SERVICE_DATA;
228 p_elem_service_data->len = p_adv_data->service_data_len;
229 memcpy(p_elem_service_data->p_val, p_adv_data->p_service_data,
230 p_adv_data->service_data_len);
231 } else {
232 osi_free(p_elem_service_data);
233 p_elem_service_data = NULL;
234 }
235 }
236 }
237
238 if (NULL != p_elem_service_data) {
239 bta_adv_data->p_proprietary = osi_malloc(sizeof(tBTA_BLE_PROPRIETARY));
240 if (NULL != bta_adv_data->p_proprietary) {
241 tBTA_BLE_PROP_ELEM *p_elem = NULL;
242 tBTA_BLE_PROPRIETARY *p_prop = bta_adv_data->p_proprietary;
243 p_prop->num_elem = 0;
244 mask |= BTM_BLE_AD_BIT_PROPRIETARY;
245 p_prop->num_elem = 1;
246 p_prop->p_elem = osi_malloc(sizeof(tBTA_BLE_PROP_ELEM) * p_prop->num_elem);
247 p_elem = p_prop->p_elem;
248 if (NULL != p_elem) {
249 memcpy(p_elem++, p_elem_service_data, sizeof(tBTA_BLE_PROP_ELEM));
250 }
251 }
252 osi_free(p_elem_service_data);
253 }
254
255 if (p_adv_data->service_uuid_len && p_adv_data->p_service_uuid) {
256 UINT16 *p_uuid_out16 = NULL;
257 UINT32 *p_uuid_out32 = NULL;
258 for (int position = 0; position < p_adv_data->service_uuid_len; position += LEN_UUID_128) {
259 tBT_UUID bt_uuid;
260
261 btc128_to_bta_uuid(&bt_uuid, p_adv_data->p_service_uuid + position);
262
263 switch (bt_uuid.len) {
264 case (LEN_UUID_16): {
265 if (NULL == bta_adv_data->p_services) {
266 bta_adv_data->p_services = osi_malloc(sizeof(tBTA_BLE_SERVICE));
267 bta_adv_data->p_services->list_cmpl = FALSE;
268 bta_adv_data->p_services->num_service = 0;
269 bta_adv_data->p_services->p_uuid = osi_malloc(p_adv_data->service_uuid_len / LEN_UUID_128 * LEN_UUID_16);
270 p_uuid_out16 = bta_adv_data->p_services->p_uuid;
271 }
272
273 if (NULL != bta_adv_data->p_services->p_uuid) {
274 BTC_TRACE_DEBUG("%s - In 16-UUID_data", __FUNCTION__);
275 mask |= BTM_BLE_AD_BIT_SERVICE;
276 ++bta_adv_data->p_services->num_service;
277 *p_uuid_out16++ = bt_uuid.uu.uuid16;
278 }
279 break;
280 }
281
282 case (LEN_UUID_32): {
283 if (NULL == bta_adv_data->p_service_32b) {
284 bta_adv_data->p_service_32b =
285 osi_malloc(sizeof(tBTA_BLE_32SERVICE));
286 bta_adv_data->p_service_32b->list_cmpl = FALSE;
287 bta_adv_data->p_service_32b->num_service = 0;
288 bta_adv_data->p_service_32b->p_uuid =
289 osi_malloc(p_adv_data->service_uuid_len / LEN_UUID_128 * LEN_UUID_32);
290 p_uuid_out32 = bta_adv_data->p_service_32b->p_uuid;
291 }
292
293 if (NULL != bta_adv_data->p_service_32b->p_uuid) {
294 BTC_TRACE_DEBUG("%s - In 32-UUID_data", __FUNCTION__);
295 mask |= BTM_BLE_AD_BIT_SERVICE_32;
296 ++bta_adv_data->p_service_32b->num_service;
297 *p_uuid_out32++ = bt_uuid.uu.uuid32;
298 }
299 break;
300 }
301
302 case (LEN_UUID_128): {
303 /* Currently, only one 128-bit UUID is supported */
304 if (NULL == bta_adv_data->p_services_128b) {
305 bta_adv_data->p_services_128b =
306 osi_malloc(sizeof(tBTA_BLE_128SERVICE));
307 if (NULL != bta_adv_data->p_services_128b) {
308 BTC_TRACE_DEBUG("%s - In 128-UUID_data", __FUNCTION__);
309 mask |= BTM_BLE_AD_BIT_SERVICE_128;
310 memcpy(bta_adv_data->p_services_128b->uuid128,
311 bt_uuid.uu.uuid128, LEN_UUID_128);
312 BTC_TRACE_DEBUG("%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x", bt_uuid.uu.uuid128[0],
313 bt_uuid.uu.uuid128[1], bt_uuid.uu.uuid128[2], bt_uuid.uu.uuid128[3],
314 bt_uuid.uu.uuid128[4], bt_uuid.uu.uuid128[5], bt_uuid.uu.uuid128[6],
315 bt_uuid.uu.uuid128[7], bt_uuid.uu.uuid128[8], bt_uuid.uu.uuid128[9],
316 bt_uuid.uu.uuid128[10], bt_uuid.uu.uuid128[11], bt_uuid.uu.uuid128[12],
317 bt_uuid.uu.uuid128[13], bt_uuid.uu.uuid128[14], bt_uuid.uu.uuid128[15]);
318 bta_adv_data->p_services_128b->list_cmpl = TRUE;
319 }
320 }
321 break;
322 }
323
324 default:
325 break;
326 }
327 }
328 }
329
330 *data_mask = mask;
331 }
332
btc_adv_data_callback(tBTA_STATUS status)333 static void btc_adv_data_callback(tBTA_STATUS status)
334 {
335 esp_ble_gap_cb_param_t param;
336 bt_status_t ret;
337 btc_msg_t msg = {0};
338
339 msg.sig = BTC_SIG_API_CB;
340 msg.pid = BTC_PID_GAP_BLE;
341 msg.act = ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT;
342 param.adv_data_cmpl.status = status;
343
344 ret = btc_transfer_context(&msg, ¶m,
345 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
346
347 if (ret != BT_STATUS_SUCCESS) {
348 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
349 }
350 }
351
btc_scan_rsp_data_callback(tBTA_STATUS status)352 static void btc_scan_rsp_data_callback(tBTA_STATUS status)
353 {
354 esp_ble_gap_cb_param_t param;
355 bt_status_t ret;
356 btc_msg_t msg = {0};
357
358 msg.sig = BTC_SIG_API_CB;
359 msg.pid = BTC_PID_GAP_BLE;
360 msg.act = ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT;
361 param.scan_rsp_data_cmpl.status = status;
362
363 ret = btc_transfer_context(&msg, ¶m,
364 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
365
366 if (ret != BT_STATUS_SUCCESS) {
367 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
368 }
369 }
370
btc_adv_data_raw_callback(tBTA_STATUS status)371 static void btc_adv_data_raw_callback(tBTA_STATUS status)
372 {
373 esp_ble_gap_cb_param_t param;
374 bt_status_t ret;
375 btc_msg_t msg = {0};
376
377 msg.sig = BTC_SIG_API_CB;
378 msg.pid = BTC_PID_GAP_BLE;
379 msg.act = ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT;
380 param.adv_data_raw_cmpl.status = status;
381
382 ret = btc_transfer_context(&msg, ¶m,
383 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
384
385 if (ret != BT_STATUS_SUCCESS) {
386 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
387 }
388 }
389
btc_scan_rsp_data_raw_callback(tBTA_STATUS status)390 static void btc_scan_rsp_data_raw_callback(tBTA_STATUS status)
391 {
392 esp_ble_gap_cb_param_t param;
393 bt_status_t ret;
394 btc_msg_t msg = {0};
395
396 msg.sig = BTC_SIG_API_CB;
397 msg.pid = BTC_PID_GAP_BLE;
398 msg.act = ESP_GAP_BLE_SCAN_RSP_DATA_RAW_SET_COMPLETE_EVT;
399 param.scan_rsp_data_raw_cmpl.status = status;
400
401 ret = btc_transfer_context(&msg, ¶m,
402 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
403
404 if (ret != BT_STATUS_SUCCESS) {
405 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
406 }
407 }
408
btc_ble_set_adv_data(esp_ble_adv_data_t * adv_data,tBTA_SET_ADV_DATA_CMPL_CBACK p_adv_data_cback)409 static void btc_ble_set_adv_data(esp_ble_adv_data_t *adv_data,
410 tBTA_SET_ADV_DATA_CMPL_CBACK p_adv_data_cback)
411 {
412 tBTA_BLE_AD_MASK data_mask = 0;
413
414 if (!adv_data->set_scan_rsp) {
415 btc_to_bta_adv_data(adv_data, &gl_bta_adv_data, &data_mask);
416 BTA_DmBleSetAdvConfig(data_mask, &gl_bta_adv_data, p_adv_data_cback);
417 } else {
418 btc_to_bta_adv_data(adv_data, &gl_bta_scan_rsp_data, &data_mask);
419 BTA_DmBleSetScanRsp(data_mask, &gl_bta_scan_rsp_data, p_adv_data_cback);
420 }
421 }
422
btc_ble_set_adv_data_raw(uint8_t * raw_adv,uint32_t raw_adv_len,tBTA_SET_ADV_DATA_CMPL_CBACK p_adv_data_cback)423 static void btc_ble_set_adv_data_raw(uint8_t *raw_adv, uint32_t raw_adv_len,
424 tBTA_SET_ADV_DATA_CMPL_CBACK p_adv_data_cback)
425 {
426 BTA_DmBleSetAdvConfigRaw(raw_adv, raw_adv_len, p_adv_data_cback);
427 }
428
btc_ble_set_scan_rsp_data_raw(uint8_t * raw_scan_rsp,uint32_t raw_scan_rsp_len,tBTA_SET_ADV_DATA_CMPL_CBACK p_scan_rsp_data_cback)429 static void btc_ble_set_scan_rsp_data_raw(uint8_t *raw_scan_rsp, uint32_t raw_scan_rsp_len,
430 tBTA_SET_ADV_DATA_CMPL_CBACK p_scan_rsp_data_cback)
431 {
432 BTA_DmBleSetScanRspRaw(raw_scan_rsp, raw_scan_rsp_len, p_scan_rsp_data_cback);
433 }
434
btc_start_adv_callback(uint8_t status)435 static void btc_start_adv_callback(uint8_t status)
436 {
437 esp_ble_gap_cb_param_t param;
438 bt_status_t ret;
439 btc_msg_t msg = {0};
440
441 msg.sig = BTC_SIG_API_CB;
442 msg.pid = BTC_PID_GAP_BLE;
443 msg.act = ESP_GAP_BLE_ADV_START_COMPLETE_EVT;
444 param.adv_start_cmpl.status = btc_hci_to_esp_status(status);
445
446 ret = btc_transfer_context(&msg, ¶m,
447 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
448
449 if (ret != BT_STATUS_SUCCESS) {
450 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
451 }
452 }
453
btc_stop_adv_callback(uint8_t status)454 static void btc_stop_adv_callback(uint8_t status)
455 {
456 esp_ble_gap_cb_param_t param;
457 bt_status_t ret;
458 btc_msg_t msg = {0};
459
460 msg.sig = BTC_SIG_API_CB;
461 msg.pid = BTC_PID_GAP_BLE;
462 msg.act = ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT;
463 param.adv_stop_cmpl.status = btc_hci_to_esp_status(status);
464
465 ret = btc_transfer_context(&msg, ¶m,
466 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
467
468 if (ret != BT_STATUS_SUCCESS) {
469 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
470 }
471 }
472
btc_clear_adv_callback(uint8_t status)473 static void btc_clear_adv_callback(uint8_t status)
474 {
475 esp_ble_gap_cb_param_t param;
476 bt_status_t ret;
477 btc_msg_t msg = {0};
478
479 msg.sig = BTC_SIG_API_CB;
480 msg.pid = BTC_PID_GAP_BLE;
481 msg.act = ESP_GAP_BLE_ADV_CLEAR_COMPLETE_EVT;
482 param.adv_clear_cmpl.status = btc_hci_to_esp_status(status);
483
484 ret = btc_transfer_context(&msg, ¶m,
485 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
486
487 if (ret != BT_STATUS_SUCCESS) {
488 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
489 }
490 }
491
btc_update_duplicate_exceptional_list_callback(tBTA_STATUS status,uint8_t subcode,uint32_t length,uint8_t * device_info)492 void btc_update_duplicate_exceptional_list_callback(tBTA_STATUS status, uint8_t subcode, uint32_t length, uint8_t *device_info)
493 {
494 esp_ble_gap_cb_param_t param;
495 bt_status_t ret;
496 btc_msg_t msg = {0};
497
498 msg.sig = BTC_SIG_API_CB;
499 msg.pid = BTC_PID_GAP_BLE;
500 msg.act = ESP_GAP_BLE_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_COMPLETE_EVT;
501 param.update_duplicate_exceptional_list_cmpl.status = status;
502 param.update_duplicate_exceptional_list_cmpl.subcode = subcode;
503 if(length > sizeof(param.update_duplicate_exceptional_list_cmpl.device_info)) {
504 length = sizeof(param.update_duplicate_exceptional_list_cmpl.device_info);
505 }
506 param.update_duplicate_exceptional_list_cmpl.length = length;
507 memcpy(param.update_duplicate_exceptional_list_cmpl.device_info, device_info, length);
508 ret = btc_transfer_context(&msg, ¶m, sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
509
510 if (ret != BT_STATUS_SUCCESS) {
511 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
512 }
513 }
514
btc_ble_update_duplicate_exceptional_list(uint8_t subcode,uint32_t info_type,BD_ADDR device_info,tBTA_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_CMPL_CBACK p_update_duplicate_ignore_list_cback)515 static void btc_ble_update_duplicate_exceptional_list(uint8_t subcode, uint32_t info_type, BD_ADDR device_info,
516 tBTA_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_CMPL_CBACK p_update_duplicate_ignore_list_cback)
517 {
518 BTA_DmUpdateDuplicateExceptionalList(subcode, info_type, device_info, p_update_duplicate_ignore_list_cback);
519 }
520
btc_ble_start_advertising(esp_ble_adv_params_t * ble_adv_params,tBTA_START_ADV_CMPL_CBACK start_adv_cback)521 static void btc_ble_start_advertising (esp_ble_adv_params_t *ble_adv_params, tBTA_START_ADV_CMPL_CBACK start_adv_cback)
522 {
523 tBLE_BD_ADDR peer_addr;
524 esp_bt_status_t status = ESP_BT_STATUS_SUCCESS;
525 if (!BLE_ISVALID_PARAM(ble_adv_params->adv_int_min, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX) ||
526 !BLE_ISVALID_PARAM(ble_adv_params->adv_int_max, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX)) {
527 status = ESP_BT_STATUS_PARM_INVALID;
528 BTC_TRACE_ERROR("Invalid advertisting interval parameters.\n");
529 }
530
531 if ((ble_adv_params->adv_type < ADV_TYPE_IND) ||
532 (ble_adv_params->adv_type > ADV_TYPE_DIRECT_IND_LOW) ) {
533 status = ESP_BT_STATUS_PARM_INVALID;
534 BTC_TRACE_ERROR("Invalid advertisting type parameters.\n");
535 }
536
537 if ((ble_adv_params->adv_filter_policy < ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY) ||
538 (ble_adv_params->adv_filter_policy > ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST) ) {
539 status = ESP_BT_STATUS_PARM_INVALID;
540 BTC_TRACE_ERROR("Invalid advertisting type parameters.\n");
541 }
542
543 if((ble_adv_params->channel_map | ADV_CHNL_ALL) != ADV_CHNL_ALL || ble_adv_params->channel_map == 0) {
544 status = ESP_BT_STATUS_PARM_INVALID;
545 BTC_TRACE_ERROR("Invalid advertisting channel map parameters.\n");
546 }
547 if (!BLE_ISVALID_PARAM(ble_adv_params->peer_addr_type, BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_RANDOM)) {
548 status = ESP_BT_STATUS_PARM_INVALID;
549 BTC_TRACE_ERROR("Invalid advertisting peer address type parameters.\n");
550 }
551 if(status != ESP_BT_STATUS_SUCCESS) {
552 if(start_adv_cback) {
553 start_adv_cback(status);
554 }
555 return;
556 }
557
558 BTC_TRACE_DEBUG("API_Ble_AppStartAdvertising\n");
559
560 memcpy(peer_addr.bda, ble_adv_params->peer_addr, ESP_BD_ADDR_LEN);
561 peer_addr.type = ble_adv_params->peer_addr_type;
562 BTA_DmSetBleAdvParamsAll(ble_adv_params->adv_int_min,
563 ble_adv_params->adv_int_max,
564 ble_adv_params->adv_type,
565 ble_adv_params->own_addr_type,
566 ble_adv_params->channel_map,
567 ble_adv_params->adv_filter_policy,
568 &peer_addr,
569 start_adv_cback);
570 }
571
572
btc_scan_params_callback(tGATT_IF gatt_if,tBTM_STATUS status)573 static void btc_scan_params_callback(tGATT_IF gatt_if, tBTM_STATUS status)
574 {
575 esp_ble_gap_cb_param_t param;
576 bt_status_t ret;
577 btc_msg_t msg = {0};
578
579 msg.sig = BTC_SIG_API_CB;
580 msg.pid = BTC_PID_GAP_BLE;
581 msg.act = ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT;
582 param.scan_param_cmpl.status = status;
583
584 ret = btc_transfer_context(&msg, ¶m,
585 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
586
587 if (ret != BT_STATUS_SUCCESS) {
588 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
589 }
590 }
591
btc_ble_set_scan_params(esp_ble_scan_params_t * scan_params,tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback)592 static void btc_ble_set_scan_params(esp_ble_scan_params_t *scan_params, tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback)
593 {
594 if (BLE_ISVALID_PARAM(scan_params->scan_interval, BTM_BLE_SCAN_INT_MIN, BTM_BLE_SCAN_INT_MAX) &&
595 BLE_ISVALID_PARAM(scan_params->scan_window, BTM_BLE_SCAN_WIN_MIN, BTM_BLE_SCAN_WIN_MAX) &&
596 BLE_ISVALID_PARAM(scan_params->own_addr_type, BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_RPA_RANDOM) &&
597 BLE_ISVALID_PARAM(scan_params->scan_filter_policy, BLE_SCAN_FILTER_ALLOW_ALL, BLE_SCAN_FILTER_ALLOW_WLIST_RPA_DIR) &&
598 BLE_ISVALID_PARAM(scan_params->scan_duplicate, BLE_SCAN_DUPLICATE_DISABLE, BLE_SCAN_DUPLICATE_MAX -1) &&
599 (scan_params->scan_type == BTM_BLE_SCAN_MODE_ACTI || scan_params->scan_type == BTM_BLE_SCAN_MODE_PASS)) {
600 BTA_DmSetBleScanFilterParams(ESP_DEFAULT_GATT_IF, /*client_if*/
601 scan_params->scan_interval,
602 scan_params->scan_window,
603 scan_params->scan_type,
604 scan_params->scan_filter_policy,
605 scan_params->own_addr_type,
606 scan_params->scan_duplicate,
607 scan_param_setup_cback);
608 } else {
609 btc_scan_params_callback(ESP_DEFAULT_GATT_IF, BTM_ILLEGAL_VALUE);
610 }
611 }
612
btc_gap_ble_adv_pkt_handler(void * arg)613 static void btc_gap_ble_adv_pkt_handler(void *arg)
614 {
615 btc_gap_ble_env_t *p_env = &btc_gap_ble_env;
616 size_t pkts_to_process = pkt_queue_length(p_env->adv_rpt_queue);
617 if (pkts_to_process > BTC_GAP_BLE_ADV_RPT_BATCH_SIZE) {
618 pkts_to_process = BTC_GAP_BLE_ADV_RPT_BATCH_SIZE;
619 }
620
621 for (size_t i = 0; i < pkts_to_process; i++) {
622 pkt_linked_item_t *linked_pkt = pkt_queue_dequeue(p_env->adv_rpt_queue);
623 if (linked_pkt != NULL) {
624 esp_ble_gap_cb_param_t *param = (esp_ble_gap_cb_param_t *)(linked_pkt->data);
625 btc_gap_ble_cb_to_app(ESP_GAP_BLE_SCAN_RESULT_EVT, param);
626 osi_free(linked_pkt);
627 }
628 }
629
630 if (pkt_queue_length(p_env->adv_rpt_queue) != 0) {
631 osi_thread_post_event(p_env->adv_rpt_ready, OSI_THREAD_MAX_TIMEOUT);
632 }
633 }
634
btc_process_adv_rpt_pkt(tBTA_DM_SEARCH_EVT event,tBTA_DM_SEARCH * p_data)635 static void btc_process_adv_rpt_pkt(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_data)
636 {
637 #if SCAN_QUEUE_CONGEST_CHECK
638 if(btc_check_queue_is_congest()) {
639 BTC_TRACE_DEBUG("BtcQueue is congested");
640 if(btc_get_adv_list_length() > BTC_ADV_LIST_MAX_LENGTH || btc_adv_list_count > BTC_ADV_LIST_MAX_COUNT) {
641 btc_adv_list_refresh();
642 btc_adv_list_count = 0;
643 }
644 if(btc_check_adv_list(p_data->inq_res.bd_addr, p_data->inq_res.ble_addr_type)) {
645 return;
646 }
647 }
648 btc_adv_list_count ++;
649 #endif
650
651 // drop ADV packets if data queue length goes above threshold
652 btc_gap_ble_env_t *p_env = &btc_gap_ble_env;
653 if (pkt_queue_length(p_env->adv_rpt_queue) >= BTC_GAP_BLE_ADV_RPT_QUEUE_LEN_MAX) {
654 return;
655 }
656
657 pkt_linked_item_t *linked_pkt = osi_calloc(BT_PKT_LINKED_HDR_SIZE + sizeof(esp_ble_gap_cb_param_t));
658 if (linked_pkt == NULL) {
659 return;
660 }
661
662 struct ble_scan_result_evt_param *scan_rst = (struct ble_scan_result_evt_param *)linked_pkt->data;
663
664 do {
665 scan_rst->search_evt = event;
666 bdcpy(scan_rst->bda, p_data->inq_res.bd_addr);
667 scan_rst->dev_type = p_data->inq_res.device_type;
668 scan_rst->rssi = p_data->inq_res.rssi;
669 scan_rst->ble_addr_type = p_data->inq_res.ble_addr_type;
670 scan_rst->ble_evt_type = p_data->inq_res.ble_evt_type;
671 scan_rst->flag = p_data->inq_res.flag;
672 scan_rst->num_resps = 1;
673 scan_rst->adv_data_len = p_data->inq_res.adv_data_len;
674 scan_rst->scan_rsp_len = p_data->inq_res.scan_rsp_len;
675 memcpy(scan_rst->ble_adv, p_data->inq_res.p_eir, sizeof(scan_rst->ble_adv));
676 } while (0);
677
678 pkt_queue_enqueue(p_env->adv_rpt_queue, linked_pkt);
679 osi_thread_post_event(p_env->adv_rpt_ready, OSI_THREAD_MAX_TIMEOUT);
680 }
681
btc_search_callback(tBTA_DM_SEARCH_EVT event,tBTA_DM_SEARCH * p_data)682 static void btc_search_callback(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_data)
683 {
684 if (event == BTA_DM_INQ_RES_EVT) {
685 btc_process_adv_rpt_pkt(event, p_data);
686 return;
687 }
688
689 esp_ble_gap_cb_param_t param;
690 btc_msg_t msg = {0};
691
692 msg.sig = BTC_SIG_API_CB;
693 msg.pid = BTC_PID_GAP_BLE;
694 msg.act = ESP_GAP_BLE_SCAN_RESULT_EVT;
695
696 param.scan_rst.search_evt = event;
697 switch (event) {
698 case BTA_DM_INQ_RES_EVT:
699 break;
700 case BTA_DM_INQ_CMPL_EVT: {
701 param.scan_rst.num_resps = p_data->inq_cmpl.num_resps;
702 BTC_TRACE_DEBUG("%s BLE observe complete. Num Resp %d\n", __FUNCTION__, p_data->inq_cmpl.num_resps);
703 break;
704 }
705 case BTA_DM_DISC_RES_EVT:
706 BTC_TRACE_DEBUG("BTA_DM_DISC_RES_EVT\n");
707 break;
708 case BTA_DM_DISC_BLE_RES_EVT:
709 BTC_TRACE_DEBUG("BTA_DM_DISC_BLE_RES_EVT\n");
710 break;
711 case BTA_DM_DISC_CMPL_EVT:
712 BTC_TRACE_DEBUG("BTA_DM_DISC_CMPL_EVT\n");
713 break;
714 case BTA_DM_DI_DISC_CMPL_EVT:
715 BTC_TRACE_DEBUG("BTA_DM_DI_DISC_CMPL_EVT\n");
716 break;
717 case BTA_DM_SEARCH_CANCEL_CMPL_EVT:
718 BTC_TRACE_DEBUG("BTA_DM_SEARCH_CANCEL_CMPL_EVT\n");
719 break;
720 case BTA_DM_INQ_DISCARD_NUM_EVT:
721 param.scan_rst.num_dis = p_data->inq_dis.num_dis;
722 break;
723 default:
724 BTC_TRACE_ERROR("%s : Unknown event 0x%x\n", __FUNCTION__, event);
725 return;
726 }
727 btc_transfer_context(&msg, ¶m, sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
728 }
729
btc_start_scan_callback(uint8_t status)730 static void btc_start_scan_callback(uint8_t status)
731 {
732 esp_ble_gap_cb_param_t param;
733 bt_status_t ret;
734 btc_msg_t msg = {0};
735
736 msg.sig = BTC_SIG_API_CB;
737 msg.pid = BTC_PID_GAP_BLE;
738 msg.act = ESP_GAP_BLE_SCAN_START_COMPLETE_EVT;
739 param.scan_start_cmpl.status = status;
740
741 ret = btc_transfer_context(&msg, ¶m,
742 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
743
744 if (ret != BT_STATUS_SUCCESS) {
745 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
746 }
747 }
748
btc_stop_scan_callback(tBTA_STATUS status)749 static void btc_stop_scan_callback(tBTA_STATUS status)
750 {
751 esp_ble_gap_cb_param_t param;
752 bt_status_t ret;
753 btc_msg_t msg = {0};
754
755 msg.sig = BTC_SIG_API_CB;
756 msg.pid = BTC_PID_GAP_BLE;
757 msg.act = ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT;
758 param.scan_stop_cmpl.status = status;
759
760 ret = btc_transfer_context(&msg, ¶m,
761 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
762
763 if (ret != BT_STATUS_SUCCESS) {
764 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
765 }
766 #if SCAN_QUEUE_CONGEST_CHECK
767 btc_adv_list_refresh();
768 #endif
769 }
770 #endif // #if (BLE_42_FEATURE_SUPPORT == TRUE)
btc_update_conn_param_callback(UINT8 status,BD_ADDR bd_addr,tBTM_LE_UPDATE_CONN_PRAMS * update_conn_params)771 void btc_update_conn_param_callback (UINT8 status, BD_ADDR bd_addr, tBTM_LE_UPDATE_CONN_PRAMS *update_conn_params)
772 {
773 esp_ble_gap_cb_param_t param;
774 bt_status_t ret;
775 btc_msg_t msg = {0};
776 msg.sig = BTC_SIG_API_CB;
777 msg.pid = BTC_PID_GAP_BLE;
778 msg.act = ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT;
779 param.update_conn_params.status = btc_hci_to_esp_status(status);
780 param.update_conn_params.min_int = update_conn_params->min_conn_int;
781 param.update_conn_params.max_int = update_conn_params->max_conn_int;
782 param.update_conn_params.conn_int = update_conn_params->conn_int;
783 param.update_conn_params.latency = update_conn_params->slave_latency;
784 param.update_conn_params.timeout = update_conn_params->supervision_tout;
785 memcpy(param.update_conn_params.bda, bd_addr, sizeof(esp_bd_addr_t));
786 ret = btc_transfer_context(&msg, ¶m,
787 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
788
789 if (ret != BT_STATUS_SUCCESS) {
790 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
791 }
792 }
793
btc_set_pkt_length_callback(UINT8 status,tBTM_LE_SET_PKT_DATA_LENGTH_PARAMS * data_len_params)794 static void btc_set_pkt_length_callback(UINT8 status, tBTM_LE_SET_PKT_DATA_LENGTH_PARAMS *data_len_params)
795 {
796 esp_ble_gap_cb_param_t param;
797 bt_status_t ret;
798 btc_msg_t msg = {0};
799 msg.sig = BTC_SIG_API_CB;
800 msg.pid = BTC_PID_GAP_BLE;
801 msg.act = ESP_GAP_BLE_SET_PKT_LENGTH_COMPLETE_EVT;
802 param.pkt_data_length_cmpl.status = btc_btm_status_to_esp_status(status);
803 param.pkt_data_length_cmpl.params.rx_len = data_len_params->rx_len;
804 param.pkt_data_length_cmpl.params.tx_len = data_len_params->tx_len;
805 ret = btc_transfer_context(&msg, ¶m,
806 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
807
808 if (ret != BT_STATUS_SUCCESS) {
809 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
810 }
811 }
812
btc_gap_ble_set_channels_cmpl_callback(void * p_data)813 static void btc_gap_ble_set_channels_cmpl_callback(void *p_data)
814 {
815 tBTA_BLE_SET_CHANNELS_RESULTS *result = (tBTA_BLE_SET_CHANNELS_RESULTS *)p_data;
816 esp_ble_gap_cb_param_t param;
817 bt_status_t ret;
818 btc_msg_t msg = {0};
819 msg.sig = BTC_SIG_API_CB;
820 msg.pid = BTC_PID_GAP_BLE;
821 msg.act = ESP_GAP_BLE_SET_CHANNELS_EVT;
822
823 param.ble_set_channels.stat = btc_btm_status_to_esp_status(result->status);
824
825 ret = btc_transfer_context(&msg, ¶m,
826 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
827
828 if (ret != BT_STATUS_SUCCESS) {
829 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
830 }
831 }
832
833
btc_update_whitelist_complete_callback(UINT8 status,tBTM_WL_OPERATION wl_opration)834 static void btc_update_whitelist_complete_callback(UINT8 status, tBTM_WL_OPERATION wl_opration)
835 {
836 esp_ble_gap_cb_param_t param;
837 bt_status_t ret;
838 btc_msg_t msg = {0};
839 msg.sig = BTC_SIG_API_CB;
840 msg.pid = BTC_PID_GAP_BLE;
841 msg.act = ESP_GAP_BLE_UPDATE_WHITELIST_COMPLETE_EVT;
842 param.update_whitelist_cmpl.status = btc_hci_to_esp_status(status);
843 param.update_whitelist_cmpl.wl_operation = wl_opration;
844 ret = btc_transfer_context(&msg, ¶m,
845 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
846
847 if (ret != BT_STATUS_SUCCESS) {
848 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
849 }
850 }
851
btc_set_rand_addr_callback(UINT8 status)852 static void btc_set_rand_addr_callback(UINT8 status)
853 {
854 esp_ble_gap_cb_param_t param;
855 bt_status_t ret;
856 btc_msg_t msg = {0};
857 param.set_rand_addr_cmpl.status = btc_btm_status_to_esp_status(status); //todo status
858 msg.sig = BTC_SIG_API_CB;
859 msg.pid = BTC_PID_GAP_BLE;
860 msg.act = ESP_GAP_BLE_SET_STATIC_RAND_ADDR_EVT;
861 ret = btc_transfer_context(&msg, ¶m,
862 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
863
864 if (ret != BT_STATUS_SUCCESS) {
865 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
866 }
867
868 }
869
btc_set_local_privacy_callback(UINT8 status)870 static void btc_set_local_privacy_callback(UINT8 status)
871 {
872 esp_ble_gap_cb_param_t param;
873 bt_status_t ret;
874 btc_msg_t msg = {0};
875 msg.sig = BTC_SIG_API_CB;
876 msg.pid = BTC_PID_GAP_BLE;
877 msg.act = ESP_GAP_BLE_SET_LOCAL_PRIVACY_COMPLETE_EVT;
878 param.local_privacy_cmpl.status = btc_btm_status_to_esp_status(status);
879 ret = btc_transfer_context(&msg, ¶m,
880 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
881
882 if (ret != BT_STATUS_SUCCESS) {
883 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
884 }
885 }
886
btc_set_rpa_timeout_callback(UINT8 status)887 static void btc_set_rpa_timeout_callback(UINT8 status)
888 {
889 esp_ble_gap_cb_param_t param;
890 bt_status_t ret;
891 btc_msg_t msg = {0};
892 msg.sig = BTC_SIG_API_CB;
893 msg.pid = BTC_PID_GAP_BLE;
894 msg.act = ESP_GAP_BLE_SET_RPA_TIMEOUT_COMPLETE_EVT;
895 param.set_rpa_timeout_cmpl.status = btc_btm_status_to_esp_status(status);
896 ret = btc_transfer_context(&msg, ¶m,
897 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
898 if (ret != BT_STATUS_SUCCESS) {
899 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
900 }
901 }
902
btc_add_dev_to_resolving_list_callback(UINT8 status)903 static void btc_add_dev_to_resolving_list_callback(UINT8 status)
904 {
905 esp_ble_gap_cb_param_t param;
906 bt_status_t ret;
907 btc_msg_t msg = {0};
908
909 msg.sig = BTC_SIG_API_CB;
910 msg.pid = BTC_PID_GAP_BLE;
911 msg.act = ESP_GAP_BLE_ADD_DEV_TO_RESOLVING_LIST_COMPLETE_EVT;
912
913 param.add_dev_to_resolving_list_cmpl.status = btc_btm_status_to_esp_status(status);
914
915 ret = btc_transfer_context(&msg, ¶m, sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
916
917 if (ret != BT_STATUS_SUCCESS) {
918 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
919 }
920 }
921
922 #if (SMP_INCLUDED == TRUE)
btc_set_encryption_callback(BD_ADDR bd_addr,tBTA_TRANSPORT transport,tBTA_STATUS enc_status)923 static void btc_set_encryption_callback(BD_ADDR bd_addr, tBTA_TRANSPORT transport, tBTA_STATUS enc_status)
924 {
925 UNUSED(bd_addr);
926 UNUSED(transport);
927 BTC_TRACE_DEBUG("enc_status = %x\n", enc_status);
928 return;
929 }
930 #endif ///SMP_INCLUDED == TRUE
931
btc_read_ble_rssi_cmpl_callback(void * p_data)932 static void btc_read_ble_rssi_cmpl_callback(void *p_data)
933 {
934 tBTA_RSSI_RESULTS *result = (tBTA_RSSI_RESULTS *)p_data;
935 esp_ble_gap_cb_param_t param;
936 bt_status_t ret;
937 btc_msg_t msg = {0};
938 msg.sig = BTC_SIG_API_CB;
939 msg.pid = BTC_PID_GAP_BLE;
940 msg.act = ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT;
941 param.read_rssi_cmpl.rssi = result->rssi;
942 param.read_rssi_cmpl.status = btc_btm_status_to_esp_status(result->status);
943 memcpy(param.read_rssi_cmpl.remote_addr, result->rem_bda, sizeof(BD_ADDR));
944
945 ret = btc_transfer_context(&msg, ¶m,
946 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
947
948 if (ret != BT_STATUS_SUCCESS) {
949 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
950 }
951 }
952
953 #if (BLE_50_FEATURE_SUPPORT == TRUE)
btc_ble_5_gap_callback(tBTA_DM_BLE_5_GAP_EVENT event,tBTA_DM_BLE_5_GAP_CB_PARAMS * params)954 static void btc_ble_5_gap_callback(tBTA_DM_BLE_5_GAP_EVENT event,
955 tBTA_DM_BLE_5_GAP_CB_PARAMS *params)
956 {
957 esp_ble_gap_cb_param_t param;
958 bt_status_t ret;
959 btc_msg_t msg;
960 msg.sig = BTC_SIG_API_CB;
961 msg.pid = BTC_PID_GAP_BLE;
962
963 switch(event) {
964 case BTA_DM_BLE_5_GAP_READ_PHY_COMPLETE_EVT: {
965 msg.act = ESP_GAP_BLE_READ_PHY_COMPLETE_EVT;
966 param.read_phy.status = btc_btm_status_to_esp_status(params->read_phy.status);
967 memcpy(param.read_phy.bda, params->read_phy.addr, BD_ADDR_LEN);
968 param.read_phy.tx_phy = params->read_phy.tx_phy;
969 param.read_phy.rx_phy = params->read_phy.rx_phy;
970 break;
971 }
972 case BTA_DM_BLE_5_GAP_SET_PREFERED_DEFAULT_PHY_COMPLETE_EVT: {
973 msg.act = ESP_GAP_BLE_SET_PREFERRED_DEFAULT_PHY_COMPLETE_EVT;
974 param.set_perf_def_phy.status = btc_btm_status_to_esp_status(params->set_perf_def_phy.status);
975 break;
976 }
977 case BTA_DM_BLE_5_GAP_SET_PREFERED_PHY_COMPLETE_EVT: {
978 msg.act = ESP_GAP_BLE_SET_PREFERRED_PHY_COMPLETE_EVT;
979 param.set_perf_phy.status = btc_btm_status_to_esp_status(params->set_perf_phy.status);
980 break;
981 }
982 case BTA_DM_BLE_5_GAP_EXT_ADV_SET_RAND_ADDR_COMPLETE_EVT:
983 msg.act = ESP_GAP_BLE_EXT_ADV_SET_RAND_ADDR_COMPLETE_EVT;
984 param.ext_adv_set_rand_addr.status = btc_btm_status_to_esp_status(params->set_ext_rand_addr.status);
985 param.ext_adv_set_rand_addr.instance = params->set_ext_rand_addr.instance;
986 break;
987 case BTA_DM_BLE_5_GAP_EXT_ADV_SET_PARAMS_COMPLETE_EVT: {
988 msg.act = ESP_GAP_BLE_EXT_ADV_SET_PARAMS_COMPLETE_EVT;
989 param.ext_adv_set_params.status = btc_btm_status_to_esp_status(params->set_params.status);
990 param.ext_adv_set_params.instance = params->set_params.instance;
991 break;
992 }
993 case BTA_DM_BLE_5_GAP_EXT_ADV_DATA_SET_COMPLETE_EVT: {
994 msg.act = ESP_GAP_BLE_EXT_ADV_DATA_SET_COMPLETE_EVT;
995 param.ext_adv_data_set.status = btc_btm_status_to_esp_status(params->adv_data_set.status);
996 param.ext_adv_data_set.instance = params->adv_data_set.instance;
997 break;
998 }
999 case BTA_DM_BLE_5_GAP_EXT_SCAN_RSP_DATA_SET_COMPLETE_EVT: {
1000 msg.act = ESP_GAP_BLE_EXT_SCAN_RSP_DATA_SET_COMPLETE_EVT;
1001 param.scan_rsp_set.status = btc_btm_status_to_esp_status(params->scan_rsp_data_set.status);
1002 param.scan_rsp_set.instance = params->scan_rsp_data_set.instance;
1003 break;
1004 }
1005 case BTA_DM_BLE_5_GAP_EXT_ADV_START_COMPLETE_EVT: {
1006 msg.act = ESP_GAP_BLE_EXT_ADV_START_COMPLETE_EVT;
1007 param.ext_adv_start.status = btc_btm_status_to_esp_status(params->adv_start.status);
1008 for (UINT8 i = 0; i < params->adv_start.instance_num; i++) {
1009 param.ext_adv_start.instance[i] = params->adv_start.instance[i];
1010 }
1011
1012 param.ext_adv_start.instance_num = params->adv_start.instance_num;
1013 break;
1014 }
1015 case BTA_DM_BLE_5_GAP_EXT_ADV_STOP_COMPLETE_EVT:
1016 msg.act = ESP_GAP_BLE_EXT_ADV_STOP_COMPLETE_EVT;
1017 param.ext_adv_stop.status = btc_btm_status_to_esp_status(params->adv_start.status);
1018 for (UINT8 i = 0; i < params->adv_start.instance_num; i++) {
1019 param.ext_adv_stop.instance[i] = params->adv_start.instance[i];
1020 }
1021 param.ext_adv_stop.instance_num = params->adv_start.instance_num;
1022 break;
1023 case BTA_DM_BLE_5_GAP_EXT_ADV_SET_REMOVE_COMPLETE_EVT:
1024 msg.act = ESP_GAP_BLE_EXT_ADV_SET_REMOVE_COMPLETE_EVT;
1025 param.ext_adv_remove.status = btc_btm_status_to_esp_status(params->adv_start.status);
1026 param.ext_adv_remove.instance = params->adv_start.instance[0];
1027 break;
1028 case BTA_DM_BLE_5_GAP_EXT_ADV_SET_CLEAR_COMPLETE_EVT:
1029 msg.act = ESP_GAP_BLE_EXT_ADV_SET_CLEAR_COMPLETE_EVT;
1030 param.ext_adv_clear.status = btc_btm_status_to_esp_status(params->adv_start.status);
1031 break;
1032 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_SET_PARAMS_COMPLETE_EVT: {
1033 msg.act = ESP_GAP_BLE_PERIODIC_ADV_SET_PARAMS_COMPLETE_EVT;
1034 param.peroid_adv_set_params.status = btc_btm_status_to_esp_status(params->per_adv_set_params.status);
1035 param.peroid_adv_set_params.instance = params->per_adv_set_params.instance;
1036 break;
1037 }
1038 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_DATA_SET_COMPLETE_EVT: {
1039 msg.act = ESP_GAP_BLE_PERIODIC_ADV_DATA_SET_COMPLETE_EVT;
1040 param.period_adv_data_set.status = btc_btm_status_to_esp_status(params->per_adv_data_set.status);
1041 param.period_adv_data_set.instance = params->per_adv_data_set.instance;
1042 break;
1043 }
1044 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_START_COMPLETE_EVT: {
1045 msg.act = ESP_GAP_BLE_PERIODIC_ADV_START_COMPLETE_EVT;
1046 param.period_adv_start.status = btc_btm_status_to_esp_status(params->per_adv_start.status);
1047 param.period_adv_start.instance = params->per_adv_start.instance;
1048 break;
1049 }
1050 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_STOP_COMPLETE_EVT: {
1051 msg.act = ESP_GAP_BLE_PERIODIC_ADV_STOP_COMPLETE_EVT;
1052 param.period_adv_stop.status = btc_btm_status_to_esp_status(params->per_adv_stop.status);
1053 param.period_adv_stop.instance = params->per_adv_stop.instance;
1054 break;
1055 }
1056 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_CREATE_SYNC_COMPLETE_EVT: {
1057 msg.act = ESP_GAP_BLE_PERIODIC_ADV_CREATE_SYNC_COMPLETE_EVT;
1058 param.period_adv_create_sync.status = btc_btm_status_to_esp_status(params->per_adv_sync_create.status);
1059 break;
1060 }
1061 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_SYNC_CANCEL_COMPLETE_EVT: {
1062 msg.act = ESP_GAP_BLE_PERIODIC_ADV_SYNC_CANCEL_COMPLETE_EVT;
1063 param.period_adv_sync_cancel.status = btc_btm_status_to_esp_status(params->per_adv_sync_cancel.status);
1064 break;
1065 }
1066 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_SYNC_TERMINATE_COMPLETE_EVT: {
1067 msg.act = ESP_GAP_BLE_PERIODIC_ADV_SYNC_TERMINATE_COMPLETE_EVT;
1068 param.period_adv_sync_term.status = btc_btm_status_to_esp_status(params->per_adv_sync_term.status);
1069 break;
1070 }
1071 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_ADD_DEV_COMPLETE_EVT: {
1072 msg.act = ESP_GAP_BLE_PERIODIC_ADV_ADD_DEV_COMPLETE_EVT;
1073 param.period_adv_add_dev.status = btc_btm_status_to_esp_status(params->per_adv_add_dev.status);
1074 break;
1075 }
1076 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_REMOVE_DEV_COMPLETE_EVT: {
1077 msg.act = ESP_GAP_BLE_PERIODIC_ADV_REMOVE_DEV_COMPLETE_EVT;
1078 param.period_adv_remove_dev.status = btc_btm_status_to_esp_status(params->per_adv_remove_dev.status);
1079 break;
1080 }
1081 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_CLEAR_DEV_COMPLETE_EVT: {
1082 msg.act = ESP_GAP_BLE_PERIODIC_ADV_CLEAR_DEV_COMPLETE_EVT;
1083 param.period_adv_clear_dev.status = btc_btm_status_to_esp_status(params->per_adv_clear_dev.status);
1084 break;
1085 }
1086 case BTA_DM_BLE_5_GAP_SET_EXT_SCAN_PARAMS_COMPLETE_EVT: {
1087 msg.act = ESP_GAP_BLE_SET_EXT_SCAN_PARAMS_COMPLETE_EVT;
1088 param.set_ext_scan_params.status = btc_btm_status_to_esp_status(params->ext_scan.status);
1089 break;
1090 }
1091 case BTA_DM_BLE_5_GAP_EXT_SCAN_START_COMPLETE_EVT: {
1092 msg.act = ESP_GAP_BLE_EXT_SCAN_START_COMPLETE_EVT;
1093 param.ext_scan_start.status = btc_btm_status_to_esp_status(params->scan_start.status);
1094 break;
1095 }
1096 case BTA_DM_BLE_5_GAP_EXT_SCAN_STOP_COMPLETE_EVT: {
1097 msg.act = ESP_GAP_BLE_EXT_SCAN_STOP_COMPLETE_EVT;
1098 param.ext_scan_stop.status = btc_btm_status_to_esp_status(params->scan_stop.status);
1099 break;
1100 }
1101 case BTA_DM_BLE_5_GAP_PREFER_EXT_CONN_PARAMS_SET_COMPLETE_EVT: {
1102 msg.act = ESP_GAP_BLE_PREFER_EXT_CONN_PARAMS_SET_COMPLETE_EVT;
1103 param.ext_conn_params_set.status = btc_btm_status_to_esp_status(params->ext_conn_set_params.status);
1104 break;
1105 }
1106 case BTA_DM_BLE_5_GAP_PHY_UPDATE_COMPLETE_EVT:
1107 msg.act = ESP_GAP_BLE_PHY_UPDATE_COMPLETE_EVT;
1108 param.phy_update.status = btc_btm_status_to_esp_status(params->phy_update.status);
1109 memcpy(param.phy_update.bda, params->phy_update.addr, BD_ADDR_LEN);
1110 param.phy_update.tx_phy = params->phy_update.tx_phy;
1111 param.phy_update.rx_phy = params->phy_update.rx_phy;
1112 break;
1113 case BTA_DM_BLE_5_GAP_EXT_ADV_REPORT_EVT:
1114 msg.act = ESP_GAP_BLE_EXT_ADV_REPORT_EVT;
1115 memcpy(¶m.ext_adv_report.params, ¶ms->ext_adv_report, sizeof(esp_ble_gap_ext_adv_report_t));
1116 if (params->ext_adv_report.adv_data) {
1117 memcpy(param.ext_adv_report.params.adv_data,
1118 params->ext_adv_report.adv_data, params->ext_adv_report.adv_data_len);
1119 }
1120 break;
1121 case BTA_DM_BLE_5_GAP_SCAN_TIMEOUT_EVT:
1122 msg.act = ESP_GAP_BLE_SCAN_TIMEOUT_EVT;
1123 break;
1124 case BTA_DM_BLE_5_GAP_ADV_TERMINATED_EVT: {
1125 param.adv_terminate.status = params->adv_term.status;
1126 param.adv_terminate.adv_instance = params->adv_term.adv_handle;
1127 param.adv_terminate.conn_idx = params->adv_term.conn_handle;
1128 param.adv_terminate.completed_event = params->adv_term.completed_event;
1129 msg.act = ESP_GAP_BLE_ADV_TERMINATED_EVT;
1130 break;
1131 }
1132 case BTA_DM_BLE_5_GAP_SCAN_REQ_RECEIVED_EVT: {
1133 msg.act = ESP_GAP_BLE_SCAN_REQ_RECEIVED_EVT;
1134 param.scan_req_received.adv_instance = params->scan_req.adv_handle;
1135 param.scan_req_received.scan_addr_type = params->scan_req.scan_addr_type;
1136 memcpy(param.scan_req_received.scan_addr, params->scan_req.scan_addr, sizeof(BD_ADDR));
1137 break;
1138 }
1139 case BTA_DM_BLE_5_GAP_CHANNEL_SELETE_ALGORITHM_EVT: {
1140 msg.act = ESP_GAP_BLE_CHANNEL_SELECT_ALGORITHM_EVT;
1141 param.channel_sel_alg.conn_handle = params->channel_sel.conn_handle;
1142 param.channel_sel_alg.channel_sel_alg = params->channel_sel.channel_sel_alg;
1143 break;
1144 }
1145 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_REPORT_EVT: {
1146 msg.act = ESP_GAP_BLE_PERIODIC_ADV_REPORT_EVT;
1147 memcpy(¶m.period_adv_report, ¶ms->period_adv_report,
1148 sizeof(esp_ble_gap_periodic_adv_report_t));
1149 if (params->period_adv_report.data) {
1150 memcpy(param.period_adv_report.params.data, params->period_adv_report.data,
1151 params->period_adv_report.data_length);
1152 }
1153 break;
1154 }
1155 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_SYNC_LOST_EVT: {
1156 msg.act = ESP_GAP_BLE_PERIODIC_ADV_SYNC_LOST_EVT;
1157 param.periodic_adv_sync_lost.sync_handle = params->sync_lost.sync_handle;
1158 break;
1159 }
1160 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_SYNC_ESTAB_EVT: {
1161 msg.act = ESP_GAP_BLE_PERIODIC_ADV_SYNC_ESTAB_EVT;
1162 param.periodic_adv_sync_estab.status = btc_btm_status_to_esp_status(params->sync_estab.status);
1163 param.periodic_adv_sync_estab.sync_handle = params->sync_estab.sync_handle;
1164 param.periodic_adv_sync_estab.sid = params->sync_estab.sid;
1165 param.periodic_adv_sync_estab.adv_addr_type = params->sync_estab.adv_addr_type;
1166 memcpy(param.periodic_adv_sync_estab.adv_addr, params->sync_estab.adv_addr,
1167 sizeof(BD_ADDR));
1168 param.periodic_adv_sync_estab.adv_phy = params->sync_estab.adv_phy;
1169 param.periodic_adv_sync_estab.period_adv_interval = params->sync_estab.period_adv_interval;
1170 param.periodic_adv_sync_estab.adv_clk_accuracy = params->sync_estab.adv_clk_accuracy;
1171 break;
1172 }
1173 #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE)
1174 case BTA_BLE_GAP_PERIODIC_ADV_RECV_ENABLE_COMPLETE_EVT:
1175 msg.act = ESP_GAP_BLE_PERIODIC_ADV_RECV_ENABLE_COMPLETE_EVT;
1176 param.period_adv_recv_enable.status = btc_btm_status_to_esp_status(params->per_adv_recv_enable.status);
1177 break;
1178 case BTA_BLE_GAP_PERIODIC_ADV_SYNC_TRANS_COMPLETE_EVT:
1179 msg.act = ESP_GAP_BLE_PERIODIC_ADV_SYNC_TRANS_COMPLETE_EVT;
1180 param.period_adv_sync_trans.status = btc_btm_status_to_esp_status(params->per_adv_sync_trans.status);
1181 memcpy(param.period_adv_sync_trans.bda, params->per_adv_sync_trans.addr, sizeof(BD_ADDR));
1182 break;
1183 case BTA_BLE_GAP_PERIODIC_ADV_SET_INFO_TRANS_COMPLETE_EVT:
1184 msg.act = ESP_GAP_BLE_PERIODIC_ADV_SET_INFO_TRANS_COMPLETE_EVT;
1185 param.period_adv_set_info_trans.status = btc_btm_status_to_esp_status(params->per_adv_set_info_trans.status);
1186 memcpy(param.period_adv_set_info_trans.bda, params->per_adv_set_info_trans.addr, sizeof(BD_ADDR));
1187 break;
1188 case BTA_BLE_GAP_SET_PAST_PARAMS_COMPLETE_EVT:
1189 msg.act = ESP_GAP_BLE_SET_PAST_PARAMS_COMPLETE_EVT;
1190 param.set_past_params.status = btc_btm_status_to_esp_status(params->set_past_params.status);
1191 memcpy(param.set_past_params.bda, params->set_past_params.addr, sizeof(BD_ADDR));
1192 break;
1193 case BTA_BLE_GAP_PERIODIC_ADV_SYNC_TRANS_RECV_EVT:
1194 msg.act = ESP_GAP_BLE_PERIODIC_ADV_SYNC_TRANS_RECV_EVT;
1195 param.past_received.status = btc_btm_status_to_esp_status(params->past_recv.status);
1196 memcpy(param.past_received.bda, params->past_recv.addr, sizeof(BD_ADDR));
1197 param.past_received.service_data = params->past_recv.service_data;
1198 param.past_received.sync_handle = params->past_recv.sync_handle;
1199 param.past_received.adv_sid = params->past_recv.adv_sid;
1200 param.past_received.adv_addr_type = params->past_recv.adv_addr_type;
1201 memcpy(param.past_received.adv_addr, params->past_recv.adv_addr, sizeof(BD_ADDR));
1202 param.past_received.adv_phy = params->past_recv.adv_phy;
1203 param.past_received.adv_interval = params->past_recv.adv_interval;
1204 param.past_received.adv_clk_accuracy = params->past_recv.adv_clk_accuracy;
1205 break;
1206 #endif
1207 default:
1208 break;
1209 }
1210
1211 ret = btc_transfer_context(&msg, ¶m,
1212 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
1213
1214 if (ret != BT_STATUS_SUCCESS) {
1215 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
1216 }
1217 }
1218 #endif // #if (BLE_50_FEATURE_SUPPORT == TRUE)
1219
btc_dtm_tx_start_callback(void * p1)1220 void btc_dtm_tx_start_callback(void *p1)
1221 {
1222 UINT8 status;
1223 UINT8 *p;
1224 p = (UINT8*) p1;
1225 if (p1) {
1226 STREAM_TO_UINT8(status, p);
1227 BTC_TRACE_DEBUG("DTM TX start, status 0x%x\n", status);
1228 esp_ble_gap_cb_param_t param;
1229 bt_status_t ret;
1230 btc_msg_t msg = {0};
1231 msg.sig = BTC_SIG_API_CB;
1232 msg.pid = BTC_PID_GAP_BLE;
1233 msg.act = ESP_GAP_BLE_DTM_TEST_UPDATE_EVT;
1234 param.dtm_state_update.status = status;
1235 param.dtm_state_update.update_evt = DTM_TX_START_EVT;
1236 param.dtm_state_update.num_of_pkt = 0;
1237
1238 ret = btc_transfer_context(&msg, ¶m,
1239 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
1240
1241 if (ret != BT_STATUS_SUCCESS) {
1242 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
1243 }
1244 }
1245 }
1246
btc_dtm_rx_start_callback(void * p1)1247 void btc_dtm_rx_start_callback(void *p1)
1248 {
1249
1250 UINT8 status;
1251 UINT8 *p;
1252 p = (UINT8*) p1;
1253 if (p1) {
1254 STREAM_TO_UINT8(status, p);
1255 BTC_TRACE_DEBUG("DTM RX start, status 0x%x\n", status);
1256 esp_ble_gap_cb_param_t param;
1257 bt_status_t ret;
1258 btc_msg_t msg = {0};
1259 msg.sig = BTC_SIG_API_CB;
1260 msg.pid = BTC_PID_GAP_BLE;
1261 msg.act = ESP_GAP_BLE_DTM_TEST_UPDATE_EVT;
1262 param.dtm_state_update.status = status;
1263 param.dtm_state_update.update_evt = DTM_RX_START_EVT;
1264 param.dtm_state_update.num_of_pkt = 0;
1265
1266 ret = btc_transfer_context(&msg, ¶m,
1267 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
1268
1269 if (ret != BT_STATUS_SUCCESS) {
1270 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
1271 }
1272 }
1273 }
1274
btc_dtm_stop_callback(void * p1)1275 void btc_dtm_stop_callback(void *p1)
1276 {
1277 UINT8 status;
1278 UINT16 num_pkt;
1279 UINT8 *p;
1280 p = (UINT8*) p1;
1281 if (p1) {
1282 STREAM_TO_UINT8(status, p);
1283 STREAM_TO_UINT16(num_pkt, p);
1284 BTC_TRACE_DEBUG("DTM stop, status 0x%x num_pkt %d\n", status, num_pkt);
1285 esp_ble_gap_cb_param_t param;
1286 bt_status_t ret;
1287 btc_msg_t msg = {0};
1288 msg.sig = BTC_SIG_API_CB;
1289 msg.pid = BTC_PID_GAP_BLE;
1290 msg.act = ESP_GAP_BLE_DTM_TEST_UPDATE_EVT;
1291 param.dtm_state_update.status = status;
1292 param.dtm_state_update.update_evt = DTM_TEST_STOP_EVT;
1293 param.dtm_state_update.num_of_pkt = num_pkt;
1294
1295 ret = btc_transfer_context(&msg, ¶m,
1296 sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
1297
1298 if (ret != BT_STATUS_SUCCESS) {
1299 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
1300 }
1301 }
1302 }
1303
btc_ble_vendor_hci_cmd_complete_callback(tBTA_VSC_CMPL * p_param)1304 static void btc_ble_vendor_hci_cmd_complete_callback(tBTA_VSC_CMPL *p_param)
1305 {
1306 bool param_invalid = false;
1307 if ((!p_param) || (!p_param->param_len) || (!p_param->p_param_buf)) {
1308 BTC_TRACE_ERROR("%s param error\n", __func__);
1309 param_invalid = true;
1310 }
1311
1312 esp_ble_gap_cb_param_t param = {0};
1313 bt_status_t ret;
1314 btc_msg_t msg = {0};
1315
1316 msg.sig = BTC_SIG_API_CB;
1317 msg.pid = BTC_PID_GAP_BLE;
1318 msg.act = ESP_GAP_BLE_VENDOR_CMD_COMPLETE_EVT;
1319 if (!param_invalid) {
1320 param.vendor_cmd_cmpl.opcode = p_param->opcode;
1321 param.vendor_cmd_cmpl.param_len = p_param->param_len;
1322 param.vendor_cmd_cmpl.p_param_buf = p_param->p_param_buf;
1323 } else {
1324 if (p_param) {
1325 param.vendor_cmd_cmpl.opcode = p_param->opcode;
1326 } else {
1327 param.vendor_cmd_cmpl.opcode = 0;
1328 }
1329 param.vendor_cmd_cmpl.param_len = 0;
1330 param.vendor_cmd_cmpl.p_param_buf = NULL;
1331 }
1332
1333 ret = btc_transfer_context(&msg, ¶m, sizeof(esp_ble_gap_cb_param_t), btc_gap_ble_cb_deep_copy, btc_gap_ble_cb_deep_free);
1334
1335 if (ret != BT_STATUS_SUCCESS) {
1336 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
1337 }
1338 }
1339
btc_ble_set_privacy_mode_callback(UINT8 status)1340 static void btc_ble_set_privacy_mode_callback(UINT8 status)
1341 {
1342 esp_ble_gap_cb_param_t param;
1343 bt_status_t ret;
1344 btc_msg_t msg = {0};
1345
1346 msg.sig = BTC_SIG_API_CB;
1347 msg.pid = BTC_PID_GAP_BLE;
1348 msg.act = ESP_GAP_BLE_SET_PRIVACY_MODE_COMPLETE_EVT;
1349
1350 param.set_privacy_mode_cmpl.status = btc_btm_status_to_esp_status(status);
1351
1352 ret = btc_transfer_context(&msg, ¶m, sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
1353
1354 if (ret != BT_STATUS_SUCCESS) {
1355 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
1356 }
1357 }
1358
btc_ble_set_csa_support_callback(UINT8 status)1359 static void btc_ble_set_csa_support_callback(UINT8 status)
1360 {
1361 esp_ble_gap_cb_param_t param;
1362 bt_status_t ret;
1363 btc_msg_t msg = {0};
1364
1365 msg.sig = BTC_SIG_API_CB;
1366 msg.pid = BTC_PID_GAP_BLE;
1367 msg.act = ESP_GAP_BLE_SET_CSA_SUPPORT_COMPLETE_EVT;
1368
1369 param.set_csa_support_cmpl.status = btc_btm_status_to_esp_status(status);
1370
1371 ret = btc_transfer_context(&msg, ¶m, sizeof(esp_ble_gap_cb_param_t), NULL, NULL);
1372
1373 if (ret != BT_STATUS_SUCCESS) {
1374 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
1375 }
1376 }
1377
btc_get_whitelist_size(uint16_t * length)1378 void btc_get_whitelist_size(uint16_t *length)
1379 {
1380 BTM_BleGetWhiteListSize(length);
1381 return;
1382 }
1383 #if (BLE_42_FEATURE_SUPPORT == TRUE)
btc_ble_start_scanning(uint32_t duration,tBTA_DM_SEARCH_CBACK * results_cb,tBTA_START_STOP_SCAN_CMPL_CBACK * start_scan_cb)1384 static void btc_ble_start_scanning(uint32_t duration,
1385 tBTA_DM_SEARCH_CBACK *results_cb,
1386 tBTA_START_STOP_SCAN_CMPL_CBACK *start_scan_cb)
1387 {
1388 if ((results_cb != NULL) && (start_scan_cb != NULL)) {
1389 #if SCAN_QUEUE_CONGEST_CHECK
1390 btc_adv_list_refresh();
1391 #endif
1392 //Start scan the device
1393 BTA_DmBleScan(true, duration, results_cb, start_scan_cb);
1394 } else {
1395 BTC_TRACE_ERROR("The start_scan_cb or results_cb invalid\n");
1396 }
1397 }
1398
btc_ble_stop_scanning(tBTA_START_STOP_SCAN_CMPL_CBACK * stop_scan_cb)1399 static void btc_ble_stop_scanning(tBTA_START_STOP_SCAN_CMPL_CBACK *stop_scan_cb)
1400 {
1401 uint8_t duration = 0;
1402 BTA_DmBleScan(false, duration, NULL, stop_scan_cb);
1403 }
1404
btc_ble_stop_advertising(tBTA_START_STOP_ADV_CMPL_CBACK * stop_adv_cb)1405 static void btc_ble_stop_advertising(tBTA_START_STOP_ADV_CMPL_CBACK *stop_adv_cb)
1406 {
1407 bool stop_adv = false;
1408
1409 BTA_DmBleBroadcast(stop_adv, stop_adv_cb);
1410 }
1411
btc_ble_clear_advertising(tBTA_CLEAR_ADV_CMPL_CBACK * clear_adv_cb)1412 static void btc_ble_clear_advertising(tBTA_CLEAR_ADV_CMPL_CBACK *clear_adv_cb)
1413 {
1414 BTA_DmBleClearAdv(clear_adv_cb);
1415 }
1416 #endif // #if (BLE_42_FEATURE_SUPPORT == TRUE)
btc_ble_update_conn_params(BD_ADDR bd_addr,uint16_t min_int,uint16_t max_int,uint16_t latency,uint16_t timeout)1417 static void btc_ble_update_conn_params(BD_ADDR bd_addr, uint16_t min_int,
1418 uint16_t max_int, uint16_t latency, uint16_t timeout)
1419 {
1420 if (min_int > max_int) {
1421 min_int = max_int;
1422 }
1423
1424 if (min_int < BTM_BLE_CONN_INT_MIN || max_int > BTM_BLE_CONN_INT_MAX) {
1425 BTC_TRACE_ERROR("Invalid interval value.\n");
1426 }
1427
1428 BTA_DmBleUpdateConnectionParams(bd_addr, min_int, max_int,
1429 latency, timeout);
1430 }
1431
btc_ble_set_pkt_data_len(BD_ADDR remote_device,uint16_t tx_data_length,tBTA_SET_PKT_DATA_LENGTH_CBACK * p_set_pkt_data_cback)1432 static void btc_ble_set_pkt_data_len(BD_ADDR remote_device, uint16_t tx_data_length, tBTA_SET_PKT_DATA_LENGTH_CBACK *p_set_pkt_data_cback)
1433 {
1434 if (tx_data_length > BTM_BLE_DATA_SIZE_MAX) {
1435 tx_data_length = BTM_BLE_DATA_SIZE_MAX;
1436 } else if (tx_data_length < BTM_BLE_DATA_SIZE_MIN) {
1437 tx_data_length = BTM_BLE_DATA_SIZE_MIN;
1438 }
1439
1440 BTA_DmBleSetDataLength(remote_device, tx_data_length, p_set_pkt_data_cback);
1441 }
1442
btc_ble_config_local_icon(uint16_t icon)1443 static void btc_ble_config_local_icon(uint16_t icon)
1444 {
1445 BTA_DmBleConfigLocalIcon(icon);
1446 }
1447
btc_ble_set_rand_addr(BD_ADDR rand_addr,tBTA_SET_RAND_ADDR_CBACK * p_set_rand_addr_cback)1448 static void btc_ble_set_rand_addr (BD_ADDR rand_addr, tBTA_SET_RAND_ADDR_CBACK *p_set_rand_addr_cback)
1449 {
1450 if (rand_addr != NULL) {
1451 /*
1452 A static address is a 48-bit randomly generated address and shall meet the following requirements:
1453 • The two most significant bits of the address shall be equal to 1
1454 • All bits of the random part of the address shall not be equal to 1
1455 • All bits of the random part of the address shall not be equal to 0
1456 A non-resolvable private address is a 48-bit randomly generated address and shall meet the following requirements:
1457 • The two most significant bits of the address shall be equal to 0
1458 • All bits of the random part of the address shall not be equal to 1
1459 • All bits of the random part of the address shall not be equal to 0
1460 */
1461 BD_ADDR invalid_rand_addr_a, invalid_rand_addr_b;
1462 memset(invalid_rand_addr_a, 0xff, sizeof(BD_ADDR));
1463 memset(invalid_rand_addr_b, 0x00, sizeof(BD_ADDR));
1464
1465 if((rand_addr[0] & BT_STATIC_RAND_ADDR_MASK) == BT_STATIC_RAND_ADDR_MASK) {
1466 invalid_rand_addr_b[0] = invalid_rand_addr_b[0] | BT_STATIC_RAND_ADDR_MASK;
1467 if (memcmp(invalid_rand_addr_a, rand_addr, BD_ADDR_LEN) != 0 && memcmp(invalid_rand_addr_b, rand_addr, BD_ADDR_LEN) != 0) {
1468 BTA_DmSetRandAddress(rand_addr, btc_set_rand_addr_callback);
1469 } else {
1470 btc_set_rand_addr_callback(BTM_INVALID_STATIC_RAND_ADDR);
1471 BTC_TRACE_ERROR("Invalid static random address, the high bit should be 0b11, bits of the random part shall not be all 1 or 0");
1472 }
1473 } else if ((rand_addr[0] | BT_NON_RPA_MASK) == BT_NON_RPA_MASK) {
1474 invalid_rand_addr_a[0] = invalid_rand_addr_a[0] & BT_NON_RPA_MASK;
1475 if (memcmp(invalid_rand_addr_a, rand_addr, BD_ADDR_LEN) != 0 && memcmp(invalid_rand_addr_b, rand_addr, BD_ADDR_LEN) != 0) {
1476 BTA_DmSetRandAddress(rand_addr, btc_set_rand_addr_callback);
1477 } else {
1478 btc_set_rand_addr_callback(BTM_INVALID_STATIC_RAND_ADDR);
1479 BTC_TRACE_ERROR("Invalid non-resolvable private address, the high bit should be 0b00, bits of the random part shall not be all 1 or 0");
1480 }
1481 }else {
1482 btc_set_rand_addr_callback(BTM_INVALID_STATIC_RAND_ADDR);
1483 BTC_TRACE_ERROR("Invalid random address type");
1484 }
1485 } else {
1486 btc_set_rand_addr_callback(BTM_INVALID_STATIC_RAND_ADDR);
1487 BTC_TRACE_ERROR("Invalid address, the address value is NULL");
1488 }
1489 }
1490
btc_ble_set_rpa_timeout(uint16_t rpa_timeout,tBTA_SET_RPA_TIMEOUT_CMPL_CBACK * set_rpa_timeout_cback)1491 static void btc_ble_set_rpa_timeout(uint16_t rpa_timeout,tBTA_SET_RPA_TIMEOUT_CMPL_CBACK *set_rpa_timeout_cback)
1492 {
1493 BTA_DmBleSetRpaTimeout(rpa_timeout,set_rpa_timeout_cback);
1494 }
1495
btc_ble_add_device_to_resolving_list(BD_ADDR addr,uint8_t addr_type,uint8_t irk[],tBTA_ADD_DEV_TO_RESOLVING_LIST_CMPL_CBACK * add_dev_to_resolving_list_callback)1496 static void btc_ble_add_device_to_resolving_list(BD_ADDR addr,
1497 uint8_t addr_type,
1498 uint8_t irk[],
1499 tBTA_ADD_DEV_TO_RESOLVING_LIST_CMPL_CBACK *add_dev_to_resolving_list_callback)
1500 {
1501 BTA_DmBleAddDevToResolvingList(addr, addr_type, irk, add_dev_to_resolving_list_callback);
1502 }
1503
btc_ble_clear_rand_addr(void)1504 static void btc_ble_clear_rand_addr (void)
1505 {
1506 BTA_DmClearRandAddress();
1507 }
1508
btc_ble_config_local_privacy(bool privacy_enable,tBTA_SET_LOCAL_PRIVACY_CBACK * set_local_privacy_cback)1509 static void btc_ble_config_local_privacy(bool privacy_enable, tBTA_SET_LOCAL_PRIVACY_CBACK *set_local_privacy_cback)
1510 {
1511 BTA_DmBleConfigLocalPrivacy(privacy_enable, set_local_privacy_cback);
1512 }
1513
btc_ble_disconnect(BD_ADDR bd_addr)1514 static void btc_ble_disconnect(BD_ADDR bd_addr)
1515 {
1516 BTA_DmBleDisconnect(bd_addr);
1517 }
1518
btc_gap_ble_set_channels(esp_gap_ble_channels channels)1519 static void btc_gap_ble_set_channels(esp_gap_ble_channels channels)
1520 {
1521 BTA_DmBleSetChannels(channels, btc_gap_ble_set_channels_cmpl_callback);
1522 }
1523
1524 #if (BLE_42_FEATURE_SUPPORT == TRUE)
btc_ble_dtm_tx_start(uint8_t tx_channel,uint8_t len_of_data,uint8_t pkt_payload,tBTA_DTM_CMD_CMPL_CBACK * p_dtm_cmpl_cback)1525 static void btc_ble_dtm_tx_start(uint8_t tx_channel, uint8_t len_of_data, uint8_t pkt_payload, tBTA_DTM_CMD_CMPL_CBACK *p_dtm_cmpl_cback)
1526 {
1527 BTA_DmBleDtmTxStart(tx_channel, len_of_data, pkt_payload, p_dtm_cmpl_cback);
1528 }
1529
btc_ble_dtm_rx_start(uint8_t rx_channel,tBTA_DTM_CMD_CMPL_CBACK * p_dtm_cmpl_cback)1530 static void btc_ble_dtm_rx_start(uint8_t rx_channel, tBTA_DTM_CMD_CMPL_CBACK *p_dtm_cmpl_cback)
1531 {
1532
1533 BTA_DmBleDtmRxStart(rx_channel, p_dtm_cmpl_cback);
1534 }
1535 #endif // #if (BLE_42_FEATURE_SUPPORT == TRUE)
1536
1537 #if (BLE_50_FEATURE_SUPPORT == TRUE)
btc_ble_dtm_enhance_tx_start(uint8_t tx_channel,uint8_t len_of_data,uint8_t pkt_payload,uint8_t phy,tBTA_DTM_CMD_CMPL_CBACK * p_dtm_cmpl_cback)1538 static void btc_ble_dtm_enhance_tx_start(uint8_t tx_channel, uint8_t len_of_data, uint8_t pkt_payload, uint8_t phy, tBTA_DTM_CMD_CMPL_CBACK *p_dtm_cmpl_cback)
1539 {
1540 BTA_DmBleDtmEnhTxStart(tx_channel, len_of_data, pkt_payload, phy, p_dtm_cmpl_cback);
1541 }
1542
btc_ble_dtm_enhance_rx_start(uint8_t rx_channel,uint8_t phy,uint8_t modulation_index,tBTA_DTM_CMD_CMPL_CBACK * p_dtm_cmpl_cback)1543 static void btc_ble_dtm_enhance_rx_start(uint8_t rx_channel, uint8_t phy, uint8_t modulation_index, tBTA_DTM_CMD_CMPL_CBACK *p_dtm_cmpl_cback)
1544 {
1545
1546 BTA_DmBleDtmEnhRxStart(rx_channel, phy, modulation_index, p_dtm_cmpl_cback);
1547 }
1548 #endif // #if (BLE_50_FEATURE_SUPPORT == TRUE)
1549
btc_ble_dtm_stop(tBTA_DTM_CMD_CMPL_CBACK * p_dtm_cmpl_cback)1550 static void btc_ble_dtm_stop(tBTA_DTM_CMD_CMPL_CBACK *p_dtm_cmpl_cback)
1551 {
1552
1553 BTA_DmBleDtmStop(p_dtm_cmpl_cback);
1554 }
1555
btc_ble_set_privacy_mode(uint8_t addr_type,BD_ADDR addr,uint8_t privacy_mode,tBTA_SET_PRIVACY_MODE_CMPL_CBACK * p_cback)1556 static void btc_ble_set_privacy_mode(uint8_t addr_type,
1557 BD_ADDR addr,
1558 uint8_t privacy_mode,
1559 tBTA_SET_PRIVACY_MODE_CMPL_CBACK *p_cback)
1560 {
1561 BTA_DmBleSetPrivacyMode(addr_type, addr, privacy_mode, p_cback);
1562 }
1563
btc_gap_ble_cb_handler(btc_msg_t * msg)1564 void btc_gap_ble_cb_handler(btc_msg_t *msg)
1565 {
1566 esp_ble_gap_cb_param_t *param = (esp_ble_gap_cb_param_t *)msg->arg;
1567
1568 if (msg->act < ESP_GAP_BLE_EVT_MAX) {
1569 btc_gap_ble_cb_to_app(msg->act, param);
1570 } else {
1571 BTC_TRACE_ERROR("%s, unknown msg->act = %d", __func__, msg->act);
1572 }
1573
1574 btc_gap_ble_cb_deep_free(msg);
1575
1576 }
1577
btc_gap_ble_arg_deep_copy(btc_msg_t * msg,void * p_dest,void * p_src)1578 void btc_gap_ble_arg_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src)
1579 {
1580 switch (msg->act) {
1581 #if (BLE_42_FEATURE_SUPPORT == TRUE)
1582 case BTC_GAP_BLE_ACT_CFG_ADV_DATA: {
1583 btc_ble_gap_args_t *src = (btc_ble_gap_args_t *)p_src;
1584 btc_ble_gap_args_t *dst = (btc_ble_gap_args_t *) p_dest;
1585
1586 if (src->cfg_adv_data.adv_data.p_manufacturer_data) {
1587 dst->cfg_adv_data.adv_data.p_manufacturer_data = osi_malloc(src->cfg_adv_data.adv_data.manufacturer_len);
1588 memcpy(dst->cfg_adv_data.adv_data.p_manufacturer_data, src->cfg_adv_data.adv_data.p_manufacturer_data,
1589 src->cfg_adv_data.adv_data.manufacturer_len);
1590 }
1591
1592 if (src->cfg_adv_data.adv_data.p_service_data) {
1593 dst->cfg_adv_data.adv_data.p_service_data = osi_malloc(src->cfg_adv_data.adv_data.service_data_len);
1594 memcpy(dst->cfg_adv_data.adv_data.p_service_data, src->cfg_adv_data.adv_data.p_service_data, src->cfg_adv_data.adv_data.service_data_len);
1595 }
1596
1597 if (src->cfg_adv_data.adv_data.p_service_uuid) {
1598 dst->cfg_adv_data.adv_data.p_service_uuid = osi_malloc(src->cfg_adv_data.adv_data.service_uuid_len);
1599 memcpy(dst->cfg_adv_data.adv_data.p_service_uuid, src->cfg_adv_data.adv_data.p_service_uuid, src->cfg_adv_data.adv_data.service_uuid_len);
1600 }
1601 break;
1602 }
1603 case BTC_GAP_BLE_ACT_CFG_ADV_DATA_RAW: {
1604 btc_ble_gap_args_t *src = (btc_ble_gap_args_t *)p_src;
1605 btc_ble_gap_args_t *dst = (btc_ble_gap_args_t *) p_dest;
1606
1607 if (src && src->cfg_adv_data_raw.raw_adv && src->cfg_adv_data_raw.raw_adv_len > 0) {
1608 dst->cfg_adv_data_raw.raw_adv = osi_malloc(src->cfg_adv_data_raw.raw_adv_len);
1609 if (dst->cfg_adv_data_raw.raw_adv) {
1610 memcpy(dst->cfg_adv_data_raw.raw_adv, src->cfg_adv_data_raw.raw_adv, src->cfg_adv_data_raw.raw_adv_len);
1611 }
1612 }
1613 break;
1614 }
1615 case BTC_GAP_BLE_ACT_CFG_SCAN_RSP_DATA_RAW: {
1616 btc_ble_gap_args_t *src = (btc_ble_gap_args_t *)p_src;
1617 btc_ble_gap_args_t *dst = (btc_ble_gap_args_t *) p_dest;
1618
1619 if (src && src->cfg_scan_rsp_data_raw.raw_scan_rsp && src->cfg_scan_rsp_data_raw.raw_scan_rsp_len > 0) {
1620 dst->cfg_scan_rsp_data_raw.raw_scan_rsp = osi_malloc(src->cfg_scan_rsp_data_raw.raw_scan_rsp_len);
1621 if (dst->cfg_scan_rsp_data_raw.raw_scan_rsp) {
1622 memcpy(dst->cfg_scan_rsp_data_raw.raw_scan_rsp, src->cfg_scan_rsp_data_raw.raw_scan_rsp, src->cfg_scan_rsp_data_raw.raw_scan_rsp_len);
1623 }
1624 }
1625 break;
1626 }
1627 #endif // #if (BLE_42_FEATURE_SUPPORT == TRUE)
1628 case BTC_GAP_BLE_SET_SECURITY_PARAM_EVT: {
1629 btc_ble_gap_args_t *src = (btc_ble_gap_args_t *)p_src;
1630 btc_ble_gap_args_t *dst = (btc_ble_gap_args_t *) p_dest;
1631 uint8_t length = 0;
1632 if (src->set_security_param.value) {
1633 length = dst->set_security_param.len;
1634 dst->set_security_param.value = osi_malloc(length);
1635 if (dst->set_security_param.value != NULL) {
1636 memcpy(dst->set_security_param.value, src->set_security_param.value, length);
1637 } else {
1638 BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act);
1639 }
1640 }
1641 break;
1642 }
1643 case BTC_GAP_BLE_OOB_REQ_REPLY_EVT: {
1644 btc_ble_gap_args_t *src = (btc_ble_gap_args_t *)p_src;
1645 btc_ble_gap_args_t *dst = (btc_ble_gap_args_t *) p_dest;
1646 uint8_t length = 0;
1647 if (src->oob_req_reply.p_value) {
1648 length = dst->oob_req_reply.len;
1649 dst->oob_req_reply.p_value = osi_malloc(length);
1650 if (dst->oob_req_reply.p_value != NULL) {
1651 memcpy(dst->oob_req_reply.p_value, src->oob_req_reply.p_value, length);
1652 } else {
1653 BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act);
1654 }
1655 }
1656 break;
1657 }
1658 case BTC_GAP_BLE_SC_OOB_REQ_REPLY_EVT: {
1659 btc_ble_gap_args_t *src = (btc_ble_gap_args_t *)p_src;
1660 btc_ble_gap_args_t *dst = (btc_ble_gap_args_t *)p_dest;
1661 if (src->sc_oob_req_reply.p_c) {
1662 dst->sc_oob_req_reply.p_c = osi_malloc(BT_OCTET16_LEN);
1663 if (dst->sc_oob_req_reply.p_c) {
1664 memcpy(dst->sc_oob_req_reply.p_c, src->sc_oob_req_reply.p_c, BT_OCTET16_LEN);
1665 } else {
1666 BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act);
1667 }
1668 }
1669 if (src->sc_oob_req_reply.p_r) {
1670 dst->sc_oob_req_reply.p_r = osi_malloc(BT_OCTET16_LEN);
1671 if (dst->sc_oob_req_reply.p_r) {
1672 memcpy(dst->sc_oob_req_reply.p_r, src->sc_oob_req_reply.p_r, BT_OCTET16_LEN);
1673 } else {
1674 BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act);
1675 }
1676 }
1677 break;
1678 }
1679 #if (BLE_50_FEATURE_SUPPORT == TRUE)
1680 case BTC_GAP_BLE_CFG_EXT_ADV_DATA_RAW:
1681 case BTC_GAP_BLE_CFG_EXT_SCAN_RSP_DATA_RAW: {
1682 btc_ble_5_gap_args_t *src = (btc_ble_5_gap_args_t *)p_src;
1683 btc_ble_5_gap_args_t *dst = (btc_ble_5_gap_args_t *)p_dest;
1684 uint16_t length = 0;
1685
1686 if (src->ext_adv_cfg_data.data) {
1687 length = src->ext_adv_cfg_data.length;
1688 dst->ext_adv_cfg_data.data = osi_malloc(length);
1689 if (dst->ext_adv_cfg_data.data) {
1690 memcpy(dst->ext_adv_cfg_data.data, src->ext_adv_cfg_data.data, length);
1691 } else {
1692 BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act);
1693 }
1694 }
1695 break;
1696 }
1697 case BTC_GAP_BLE_CFG_PERIODIC_ADV_DATA_RAW: {
1698 btc_ble_5_gap_args_t *src = (btc_ble_5_gap_args_t *)p_src;
1699 btc_ble_5_gap_args_t *dst = (btc_ble_5_gap_args_t *)p_dest;
1700 uint16_t length = 0;
1701
1702 if (src->periodic_adv_cfg_data.data) {
1703 length = src->periodic_adv_cfg_data.len;
1704 dst->periodic_adv_cfg_data.data = osi_malloc(length);
1705 if (dst->periodic_adv_cfg_data.data) {
1706 memcpy(dst->periodic_adv_cfg_data.data, src->periodic_adv_cfg_data.data, length);
1707 } else {
1708 BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act);
1709 }
1710 }
1711 break;
1712 }
1713 case BTC_GAP_BLE_EXT_ADV_START: {
1714 btc_ble_5_gap_args_t *src = (btc_ble_5_gap_args_t *)p_src;
1715 btc_ble_5_gap_args_t *dst = (btc_ble_5_gap_args_t *)p_dest;
1716
1717 if (src->ext_adv_start.ext_adv) {
1718 dst->ext_adv_start.ext_adv = osi_malloc(src->ext_adv_start.num_adv*sizeof(esp_ble_gap_ext_adv_t));
1719 if (dst->ext_adv_start.ext_adv) {
1720 memcpy(dst->ext_adv_start.ext_adv, src->ext_adv_start.ext_adv,
1721 src->ext_adv_start.num_adv*sizeof(esp_ble_gap_ext_adv_t));
1722 }
1723 }
1724 break;
1725 }
1726 case BTC_GAP_BLE_EXT_ADV_STOP: {
1727 btc_ble_5_gap_args_t *src = (btc_ble_5_gap_args_t *)p_src;
1728 btc_ble_5_gap_args_t *dst = (btc_ble_5_gap_args_t *)p_dest;
1729
1730 if (src->ext_adv_stop.ext_adv_inst) {
1731 dst->ext_adv_stop.ext_adv_inst = osi_malloc(src->ext_adv_stop.num_adv*sizeof(uint8_t));
1732 if (dst->ext_adv_stop.ext_adv_inst) {
1733 memcpy(dst->ext_adv_stop.ext_adv_inst, src->ext_adv_stop.ext_adv_inst,
1734 src->ext_adv_stop.num_adv * sizeof(uint8_t));
1735 }
1736 }
1737 break;
1738 }
1739 #endif // #if (BLE_50_FEATURE_SUPPORT == TRUE)
1740 case BTC_GAP_BLE_ACT_VENDOR_HCI_CMD_EVT: {
1741 btc_ble_gap_args_t *src = (btc_ble_gap_args_t *)p_src;
1742 btc_ble_gap_args_t *dst = (btc_ble_gap_args_t *)p_dest;
1743 if (src->vendor_cmd_send.param_len) {
1744 dst->vendor_cmd_send.p_param_buf = osi_malloc(src->vendor_cmd_send.param_len);
1745 if (dst->vendor_cmd_send.p_param_buf) {
1746 memcpy(dst->vendor_cmd_send.p_param_buf, src->vendor_cmd_send.p_param_buf, src->vendor_cmd_send.param_len);
1747 } else {
1748 BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act);
1749 }
1750 }
1751 break;
1752 }
1753 default:
1754 BTC_TRACE_ERROR("Unhandled deep copy %d\n", msg->act);
1755 break;
1756 }
1757 }
1758
btc_gap_ble_cb_deep_copy(btc_msg_t * msg,void * p_dest,void * p_src)1759 void btc_gap_ble_cb_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src)
1760 {
1761 esp_ble_gap_cb_param_t *src = (esp_ble_gap_cb_param_t *)p_src;
1762 esp_ble_gap_cb_param_t *dst = (esp_ble_gap_cb_param_t *) p_dest;
1763
1764 switch (msg->act) {
1765 case ESP_GAP_BLE_VENDOR_CMD_COMPLETE_EVT: {
1766 if (src->vendor_cmd_cmpl.param_len) {
1767 dst->vendor_cmd_cmpl.p_param_buf = osi_malloc(src->vendor_cmd_cmpl.param_len);
1768 if (dst->vendor_cmd_cmpl.p_param_buf) {
1769 memcpy(dst->vendor_cmd_cmpl.p_param_buf, src->vendor_cmd_cmpl.p_param_buf,
1770 src->vendor_cmd_cmpl.param_len);
1771 } else {
1772 BTC_TRACE_ERROR("%s, malloc failed\n", __func__);
1773 }
1774 }
1775 break;
1776 }
1777 default:
1778 BTC_TRACE_ERROR("%s, Unhandled deep copy %d\n", __func__, msg->act);
1779 break;
1780 }
1781 }
1782
btc_gap_ble_arg_deep_free(btc_msg_t * msg)1783 void btc_gap_ble_arg_deep_free(btc_msg_t *msg)
1784 {
1785 BTC_TRACE_DEBUG("%s \n", __func__);
1786 switch (msg->act) {
1787 #if (BLE_42_FEATURE_SUPPORT == TRUE)
1788 case BTC_GAP_BLE_ACT_CFG_ADV_DATA: {
1789 esp_ble_adv_data_t *adv = &((btc_ble_gap_args_t *)msg->arg)->cfg_adv_data.adv_data;
1790 if (adv->p_service_data) {
1791 osi_free(adv->p_service_data);
1792 }
1793
1794 if (adv->p_service_uuid) {
1795 osi_free(adv->p_service_uuid);
1796 }
1797
1798 if (adv->p_manufacturer_data) {
1799 osi_free(adv->p_manufacturer_data);
1800 }
1801 break;
1802 }
1803 case BTC_GAP_BLE_ACT_CFG_ADV_DATA_RAW: {
1804 uint8_t *raw_adv = ((btc_ble_gap_args_t *)msg->arg)->cfg_adv_data_raw.raw_adv;
1805 if (raw_adv) {
1806 osi_free(raw_adv);
1807 }
1808 break;
1809 }
1810 case BTC_GAP_BLE_ACT_CFG_SCAN_RSP_DATA_RAW: {
1811 uint8_t *raw_scan_rsp = ((btc_ble_gap_args_t *)msg->arg)->cfg_scan_rsp_data_raw.raw_scan_rsp;
1812 if (raw_scan_rsp) {
1813 osi_free(raw_scan_rsp);
1814 }
1815 break;
1816 }
1817 #endif // #if (BLE_42_FEATURE_SUPPORT == TRUE)
1818 case BTC_GAP_BLE_SET_SECURITY_PARAM_EVT: {
1819 uint8_t *value = ((btc_ble_gap_args_t *)msg->arg)->set_security_param.value;
1820 if (value) {
1821 osi_free(value);
1822 }
1823 break;
1824 }
1825 case BTC_GAP_BLE_OOB_REQ_REPLY_EVT: {
1826 uint8_t *value = ((btc_ble_gap_args_t *)msg->arg)->oob_req_reply.p_value;
1827 if (value) {
1828 osi_free(value);
1829 }
1830 break;
1831 }
1832 case BTC_GAP_BLE_SC_OOB_REQ_REPLY_EVT: {
1833 uint8_t *value = ((btc_ble_gap_args_t *)msg->arg)->sc_oob_req_reply.p_c;
1834 if (value) {
1835 osi_free(value);
1836 }
1837 value = ((btc_ble_gap_args_t *)msg->arg)->sc_oob_req_reply.p_r;
1838 if (value) {
1839 osi_free(value);
1840 }
1841 break;
1842 }
1843 #if (BLE_50_FEATURE_SUPPORT == TRUE)
1844 case BTC_GAP_BLE_CFG_EXT_ADV_DATA_RAW:
1845 case BTC_GAP_BLE_CFG_EXT_SCAN_RSP_DATA_RAW: {
1846 uint8_t *value = ((btc_ble_5_gap_args_t *)msg->arg)->ext_adv_cfg_data.data;
1847 if (value) {
1848 osi_free(value);
1849 }
1850 break;
1851 }
1852 case BTC_GAP_BLE_CFG_PERIODIC_ADV_DATA_RAW: {
1853 uint8_t *value = ((btc_ble_5_gap_args_t *)msg->arg)->periodic_adv_cfg_data.data;
1854 if (value) {
1855 osi_free(value);
1856 }
1857 break;
1858 }
1859 case BTC_GAP_BLE_EXT_ADV_START: {
1860 esp_ble_gap_ext_adv_t *value = ((btc_ble_5_gap_args_t *)msg->arg)->ext_adv_start.ext_adv;
1861 if (value) {
1862 osi_free(value);
1863 }
1864 break;
1865 }
1866 case BTC_GAP_BLE_EXT_ADV_STOP: {
1867 uint8_t *value = ((btc_ble_5_gap_args_t *)msg->arg)->ext_adv_stop.ext_adv_inst;
1868 if (value) {
1869 osi_free(value);
1870 }
1871 break;
1872 }
1873 #endif // #if (BLE_50_FEATURE_SUPPORT == TRUE)
1874 case BTC_GAP_BLE_ACT_VENDOR_HCI_CMD_EVT: {
1875 uint8_t *p_param_buf = ((btc_ble_gap_args_t *)msg->arg)->vendor_cmd_send.p_param_buf;
1876 if (p_param_buf) {
1877 osi_free(p_param_buf);
1878 }
1879 break;
1880 }
1881 default:
1882 BTC_TRACE_DEBUG("Unhandled deep free %d\n", msg->act);
1883 break;
1884 }
1885 }
1886
btc_gap_ble_cb_deep_free(btc_msg_t * msg)1887 void btc_gap_ble_cb_deep_free(btc_msg_t *msg)
1888 {
1889 BTC_TRACE_DEBUG("%s", __func__);
1890 switch (msg->act) {
1891 case ESP_GAP_BLE_GET_DEV_NAME_COMPLETE_EVT: {
1892 char *value = ((esp_ble_gap_cb_param_t *)msg->arg)->get_dev_name_cmpl.name;
1893 if (value) {
1894 osi_free(value);
1895 }
1896 break;
1897 }
1898 case ESP_GAP_BLE_VENDOR_CMD_COMPLETE_EVT: {
1899 uint8_t *value = ((esp_ble_gap_cb_param_t *)msg->arg)->vendor_cmd_cmpl.p_param_buf;
1900 if (value) {
1901 osi_free(value);
1902 }
1903 break;
1904 }
1905 default:
1906 BTC_TRACE_DEBUG("Unhandled deep free %d", msg->act);
1907 break;
1908 }
1909 }
1910
btc_gap_ble_call_handler(btc_msg_t * msg)1911 void btc_gap_ble_call_handler(btc_msg_t *msg)
1912 {
1913 btc_ble_gap_args_t *arg = (btc_ble_gap_args_t *)msg->arg;
1914 #if (BLE_50_FEATURE_SUPPORT == TRUE)
1915 btc_ble_5_gap_args_t *arg_5 = (btc_ble_5_gap_args_t *)msg->arg;
1916 #endif // #if (BLE_50_FEATURE_SUPPORT == TRUE)
1917
1918 BTC_TRACE_DEBUG("%s act %d\n", __FUNCTION__, msg->act);
1919
1920 switch (msg->act) {
1921 #if (BLE_42_FEATURE_SUPPORT == TRUE)
1922 case BTC_GAP_BLE_ACT_CFG_ADV_DATA: {
1923 if (arg->cfg_adv_data.adv_data.set_scan_rsp == false) {
1924 btc_ble_set_adv_data(&arg->cfg_adv_data.adv_data, btc_adv_data_callback);
1925 } else {
1926 btc_ble_set_adv_data(&arg->cfg_adv_data.adv_data, btc_scan_rsp_data_callback);
1927 }
1928 break;
1929 }
1930 case BTC_GAP_BLE_ACT_SET_SCAN_PARAM:
1931 btc_ble_set_scan_params(&arg->set_scan_param.scan_params, btc_scan_params_callback);
1932 break;
1933 case BTC_GAP_BLE_ACT_START_SCAN:
1934 btc_ble_start_scanning(arg->start_scan.duration, btc_search_callback, btc_start_scan_callback);
1935 break;
1936 case BTC_GAP_BLE_ACT_STOP_SCAN:
1937 btc_ble_stop_scanning(btc_stop_scan_callback);
1938 break;
1939 case BTC_GAP_BLE_ACT_START_ADV:
1940 btc_ble_start_advertising(&arg->start_adv.adv_params, btc_start_adv_callback);
1941 break;
1942 case BTC_GAP_BLE_ACT_STOP_ADV:
1943 btc_ble_stop_advertising(btc_stop_adv_callback);
1944 break;
1945 case BTC_GAP_BLE_ACT_CLEAR_ADV:
1946 btc_ble_clear_advertising(btc_clear_adv_callback);
1947 break;
1948 #endif // #if (BLE_42_FEATURE_SUPPORT == TRUE)
1949 case BTC_GAP_BLE_ACT_UPDATE_CONN_PARAM:
1950 btc_ble_update_conn_params(arg->conn_update_params.conn_params.bda,
1951 arg->conn_update_params.conn_params.min_int,
1952 arg->conn_update_params.conn_params.max_int,
1953 arg->conn_update_params.conn_params.latency,
1954 arg->conn_update_params.conn_params.timeout);
1955 break;
1956 case BTC_GAP_BLE_ACT_SET_PKT_DATA_LEN:
1957 btc_ble_set_pkt_data_len(arg->set_pkt_data_len.remote_device, arg->set_pkt_data_len.tx_data_length, btc_set_pkt_length_callback);
1958 break;
1959 case BTC_GAP_BLE_ACT_SET_RAND_ADDRESS: {
1960 BD_ADDR bd_addr;
1961 memcpy(bd_addr, arg->set_rand_addr.rand_addr, sizeof(BD_ADDR));
1962 btc_ble_set_rand_addr(bd_addr, btc_set_rand_addr_callback);
1963 break;
1964 }
1965 case BTC_GAP_BLE_ACT_SET_RESOLVABLE_PRIVATE_ADDRESS_TIMEOUT: {
1966 btc_ble_set_rpa_timeout(arg->set_rpa_timeout.rpa_timeout,btc_set_rpa_timeout_callback);
1967 break;
1968 }
1969 case BTC_GAP_BLE_ACT_ADD_DEVICE_TO_RESOLVING_LIST: {
1970 btc_ble_add_device_to_resolving_list(arg->add_dev_to_resolving_list.addr,
1971 arg->add_dev_to_resolving_list.addr_type,
1972 arg->add_dev_to_resolving_list.irk,
1973 btc_add_dev_to_resolving_list_callback);
1974 break;
1975 }
1976 case BTC_GAP_BLE_ACT_CLEAR_RAND_ADDRESS: {
1977 btc_ble_clear_rand_addr();
1978 break;
1979 }
1980 case BTC_GAP_BLE_ACT_CONFIG_LOCAL_PRIVACY:
1981 btc_ble_config_local_privacy(arg->cfg_local_privacy.privacy_enable, btc_set_local_privacy_callback);
1982 break;
1983 case BTC_GAP_BLE_ACT_CONFIG_LOCAL_ICON:
1984 btc_ble_config_local_icon(arg->cfg_local_icon.icon);
1985 break;
1986 case BTC_GAP_BLE_ACT_UPDATE_WHITE_LIST:
1987 BTA_DmUpdateWhiteList(arg->update_white_list.add_remove, arg->update_white_list.remote_bda, arg->update_white_list.wl_addr_type, btc_update_whitelist_complete_callback);
1988 break;
1989 case BTC_GAP_BLE_ACT_CLEAR_WHITE_LIST:
1990 BTA_DmClearWhiteList(btc_update_whitelist_complete_callback);
1991 break;
1992 case BTC_GAP_BLE_ACT_READ_RSSI:
1993 BTA_DmReadRSSI(arg->read_rssi.remote_addr, BTA_TRANSPORT_LE, btc_read_ble_rssi_cmpl_callback);
1994 break;
1995 #if (BLE_42_FEATURE_SUPPORT == TRUE)
1996 case BTC_GAP_BLE_ACT_SET_CONN_PARAMS:
1997 BTA_DmSetBlePrefConnParams(arg->set_conn_params.bd_addr, arg->set_conn_params.min_conn_int,
1998 arg->set_conn_params.max_conn_int, arg->set_conn_params.slave_latency,
1999 arg->set_conn_params.supervision_tout);
2000 break;
2001 #endif // #if (BLE_42_FEATURE_SUPPORT == TRUE)
2002 case BTC_GAP_BLE_ACT_SET_DEV_NAME:
2003 BTA_DmSetDeviceName(arg->set_dev_name.device_name);
2004 break;
2005 case BTC_GAP_BLE_ACT_GET_DEV_NAME:
2006 BTA_DmGetDeviceName(btc_gap_ble_get_dev_name_callback);
2007 break;
2008 #if (BLE_42_FEATURE_SUPPORT == TRUE)
2009 case BTC_GAP_BLE_ACT_CFG_ADV_DATA_RAW:
2010 btc_ble_set_adv_data_raw(arg->cfg_adv_data_raw.raw_adv,
2011 arg->cfg_adv_data_raw.raw_adv_len,
2012 btc_adv_data_raw_callback);
2013 break;
2014 case BTC_GAP_BLE_ACT_CFG_SCAN_RSP_DATA_RAW:
2015 btc_ble_set_scan_rsp_data_raw(arg->cfg_scan_rsp_data_raw.raw_scan_rsp,
2016 arg->cfg_scan_rsp_data_raw.raw_scan_rsp_len,
2017 btc_scan_rsp_data_raw_callback);
2018 break;
2019 case BTC_GAP_BLE_UPDATE_DUPLICATE_SCAN_EXCEPTIONAL_LIST:
2020 btc_ble_update_duplicate_exceptional_list(arg->update_duplicate_exceptional_list.subcode,
2021 arg->update_duplicate_exceptional_list.info_type,
2022 arg->update_duplicate_exceptional_list.device_info,
2023 btc_update_duplicate_exceptional_list_callback);
2024 break;
2025 #endif // #if (BLE_42_FEATURE_SUPPORT == TRUE)
2026 #if (SMP_INCLUDED == TRUE)
2027 case BTC_GAP_BLE_SET_ENCRYPTION_EVT: {
2028 BD_ADDR bd_addr;
2029 memcpy(bd_addr, arg->set_encryption.bd_addr, sizeof(BD_ADDR));
2030 BTA_DmSetEncryption(bd_addr, BT_TRANSPORT_LE, btc_set_encryption_callback,
2031 (tBTA_DM_BLE_SEC_ACT)arg->set_encryption.sec_act);
2032 break;
2033 }
2034 case BTC_GAP_BLE_SET_SECURITY_PARAM_EVT: {
2035 uint8_t *value = arg->set_security_param.value;
2036 switch(arg->set_security_param.param_type) {
2037 case ESP_BLE_SM_PASSKEY:
2038 break;
2039 case ESP_BLE_SM_AUTHEN_REQ_MODE: {
2040 uint8_t authen_req = 0;
2041 STREAM_TO_UINT8(authen_req, value);
2042 bta_dm_co_ble_set_auth_req(authen_req);
2043 break;
2044 }
2045 case ESP_BLE_SM_IOCAP_MODE: {
2046 uint8_t iocap = 0;
2047 STREAM_TO_UINT8(iocap, value);
2048 bta_dm_co_ble_set_io_cap(iocap);
2049 break;
2050 }
2051 case ESP_BLE_SM_SET_INIT_KEY: {
2052 uint8_t init_key = 0;
2053 STREAM_TO_UINT8(init_key, value);
2054 bta_dm_co_ble_set_init_key_req(init_key);
2055 break;
2056 }
2057 case ESP_BLE_SM_SET_RSP_KEY: {
2058 uint8_t rsp_key = 0;
2059 STREAM_TO_UINT8(rsp_key, value);
2060 bta_dm_co_ble_set_rsp_key_req(rsp_key);
2061 break;
2062 }
2063 case ESP_BLE_SM_MAX_KEY_SIZE: {
2064 uint8_t key_size = 0;
2065 STREAM_TO_UINT8(key_size, value);
2066 bta_dm_co_ble_set_max_key_size(key_size);
2067 break;
2068 }
2069 case ESP_BLE_SM_MIN_KEY_SIZE: {
2070 uint8_t key_size = 0;
2071 STREAM_TO_UINT8(key_size, value);
2072 bta_dm_co_ble_set_min_key_size(key_size);
2073 break;
2074 }
2075 case ESP_BLE_SM_SET_STATIC_PASSKEY: {
2076 uint32_t passkey = 0;
2077 for(uint8_t i = 0; i < arg->set_security_param.len; i++)
2078 {
2079 passkey += (((uint8_t *)value)[i]<<(8*i));
2080 }
2081 BTA_DmBleSetStaticPasskey(true, passkey);
2082 break;
2083 }
2084 case ESP_BLE_SM_CLEAR_STATIC_PASSKEY: {
2085 BTA_DmBleSetStaticPasskey(false, 0);
2086 break;
2087 }
2088 case ESP_BLE_SM_ONLY_ACCEPT_SPECIFIED_SEC_AUTH: {
2089 uint8_t enable = 0;
2090 STREAM_TO_UINT8(enable, value);
2091 bta_dm_co_ble_set_accept_auth_enable(enable);
2092 break;
2093 }
2094 case ESP_BLE_SM_OOB_SUPPORT: {
2095 uint8_t enable = 0;
2096 STREAM_TO_UINT8(enable, value);
2097 bta_dm_co_ble_oob_support(enable);
2098 break;
2099 }
2100 default:
2101 break;
2102 }
2103 break;
2104 }
2105 case BTC_GAP_BLE_SECURITY_RSP_EVT: {
2106 BD_ADDR bd_addr;
2107 tBTA_DM_BLE_SEC_GRANT res = arg->sec_rsp.accept ? BTA_DM_SEC_GRANTED : BTA_DM_SEC_PAIR_NOT_SPT;
2108 memcpy(bd_addr, arg->sec_rsp.bd_addr, sizeof(BD_ADDR));
2109 BTA_DmBleSecurityGrant(bd_addr, res);
2110 break;
2111 }
2112 case BTC_GAP_BLE_PASSKEY_REPLY_EVT: {
2113 BD_ADDR bd_addr;
2114 memcpy(bd_addr, arg->enc_passkey_replay.bd_addr, sizeof(BD_ADDR));
2115 BTA_DmBlePasskeyReply(bd_addr, arg->enc_passkey_replay.accept, arg->enc_passkey_replay.passkey);
2116 break;
2117 }
2118 case BTC_GAP_BLE_CONFIRM_REPLY_EVT: {
2119 BD_ADDR bd_addr;
2120 memcpy(bd_addr, arg->enc_comfirm_replay.bd_addr, sizeof(BD_ADDR));
2121 BTA_DmBleConfirmReply(bd_addr, arg->enc_comfirm_replay.accept);
2122 break;
2123 }
2124 case BTC_GAP_BLE_REMOVE_BOND_DEV_EVT: {
2125 BD_ADDR bd_addr;
2126 memcpy(bd_addr, arg->remove_bond_device.bd_addr, sizeof(BD_ADDR));
2127 BTA_DmRemoveDevice(bd_addr, BT_TRANSPORT_LE);
2128 break;
2129 }
2130 case BTC_GAP_BLE_OOB_REQ_REPLY_EVT:
2131 BTA_DmOobReply(arg->oob_req_reply.bd_addr, arg->oob_req_reply.len, arg->oob_req_reply.p_value);
2132 break;
2133 case BTC_GAP_BLE_SC_OOB_REQ_REPLY_EVT:
2134 BTA_DmSecureConnectionOobReply(arg->sc_oob_req_reply.bd_addr, arg->sc_oob_req_reply.p_c, arg->sc_oob_req_reply.p_r);
2135 break;
2136 case BTC_GAP_BLE_SC_CR_OOB_DATA_EVT:
2137 BTA_DmSecureConnectionCreateOobData();
2138 break;
2139 #endif ///SMP_INCLUDED == TRUE
2140 case BTC_GAP_BLE_DISCONNECT_EVT:
2141 btc_ble_disconnect(arg->disconnect.remote_device);
2142 break;
2143 case BTC_GAP_BLE_SET_AFH_CHANNELS:
2144 btc_gap_ble_set_channels(arg->set_channels.channels);
2145 break;
2146 #if (BLE_50_FEATURE_SUPPORT == TRUE)
2147 case BTC_GAP_BLE_READ_PHY:
2148 BTC_TRACE_DEBUG("BTC_GAP_BLE_READ_PHY");
2149 BTA_DmBleGapReadPHY(arg_5->read_phy.bd_addr);
2150 break;
2151 case BTC_GAP_BLE_SET_PREFERED_DEF_PHY:
2152 BTC_TRACE_DEBUG("BTC_GAP_BLE_SET_PREFERED_DEF_PHY");
2153 BTA_DmBleGapSetPreferedDefaultPHY(arg_5->set_perf_def_phy.tx_phy_mask,
2154 arg_5->set_perf_def_phy.rx_phy_mask);
2155 break;
2156 case BTC_GAP_BLE_SET_DEF_PHY:
2157 BTC_TRACE_DEBUG("BTC_GAP_BLE_SET_DEF_PHY");
2158 BTA_DmBleGapSetPreferedPHY(arg_5->set_def_phy.bd_addr,
2159 arg_5->set_def_phy.all_phys_mask,
2160 arg_5->set_def_phy.tx_phy_mask,
2161 arg_5->set_def_phy.rx_phy_mask,
2162 arg_5->set_def_phy.phy_options);
2163 break;
2164 case BTC_GAP_BLE_SET_EXT_ADV_RAND_ADDR:
2165 BTA_DmBleGapExtAdvSetRandaddr(arg_5->ext_adv_set_rand_addr.instance, arg_5->ext_adv_set_rand_addr.rand_addr);
2166 break;
2167 case BTC_GAP_BLE_SET_EXT_ADV_PARAMS: {
2168 tBTA_DM_BLE_GAP_EXT_ADV_PARAMS params = {0};
2169 params.type = arg_5->ext_adv_set_params.params.type;
2170 params.interval_min = arg_5->ext_adv_set_params.params.interval_min;
2171 params.interval_max = arg_5->ext_adv_set_params.params.interval_max;
2172 params.channel_map = arg_5->ext_adv_set_params.params.channel_map;
2173 params.own_addr_type = arg_5->ext_adv_set_params.params.own_addr_type;
2174 params.peer_addr_type = arg_5->ext_adv_set_params.params.peer_addr_type;
2175 params.filter_policy = arg_5->ext_adv_set_params.params.filter_policy;
2176 params.tx_power = arg_5->ext_adv_set_params.params.tx_power;
2177 params.primary_phy = arg_5->ext_adv_set_params.params.primary_phy;
2178 params.max_skip = arg_5->ext_adv_set_params.params.max_skip;
2179 params.secondary_phy = arg_5->ext_adv_set_params.params.secondary_phy;
2180 params.sid = arg_5->ext_adv_set_params.params.sid;
2181 params.scan_req_notif = arg_5->ext_adv_set_params.params.scan_req_notif;
2182
2183 memcpy(params.peer_addr, arg_5->ext_adv_set_params.params.peer_addr, sizeof(BD_ADDR));
2184
2185 BTC_TRACE_DEBUG("BTC_GAP_BLE_SET_EXT_ADV_PARAMS");
2186 BTA_DmBleGapExtAdvSetParams(arg_5->ext_adv_set_params.instance,
2187 (const tBTA_DM_BLE_GAP_EXT_ADV_PARAMS *)¶ms);
2188 break;
2189 }
2190 case BTC_GAP_BLE_CFG_EXT_ADV_DATA_RAW:
2191 BTC_TRACE_DEBUG("BTC_GAP_BLE_CFG_EXT_ADV_DATA_RAW");
2192 BTA_DmBleGapConfigExtAdvDataRaw(FALSE, arg_5->ext_adv_cfg_data.instance,
2193 arg_5->ext_adv_cfg_data.length,
2194 (const UINT8 *)arg_5->ext_adv_cfg_data.data);
2195 break;
2196 case BTC_GAP_BLE_CFG_EXT_SCAN_RSP_DATA_RAW:
2197 BTC_TRACE_DEBUG("BTC_GAP_BLE_CFG_EXT_SCAN_RSP_DATA_RAW");
2198 BTA_DmBleGapConfigExtAdvDataRaw(TRUE, arg_5->ext_adv_cfg_data.instance,
2199 arg_5->ext_adv_cfg_data.length,
2200 (const UINT8 *)arg_5->ext_adv_cfg_data.data);
2201 break;
2202 case BTC_GAP_BLE_EXT_ADV_START: {
2203 BTC_TRACE_DEBUG("BTC_GAP_BLE_EXT_ADV_START");
2204 for (int k = 0; k < arg_5->ext_adv_start.num_adv; k++) {
2205 BTC_TRACE_DEBUG("adv_handle[%d] = %d, duration[%d] = %d, max_adv_evt[%d] = %d", k, arg_5->ext_adv_start.ext_adv[k].instance, k,
2206 arg_5->ext_adv_start.ext_adv[k].duration, k, arg_5->ext_adv_start.ext_adv[k].max_events);
2207 }
2208 BTA_DmBleGapExtAdvEnable(TRUE, arg_5->ext_adv_start.num_adv,
2209 (tBTA_DM_BLE_EXT_ADV *)arg_5->ext_adv_start.ext_adv);
2210 break;
2211 }
2212 case BTC_GAP_BLE_EXT_ADV_STOP: {
2213 BTC_TRACE_DEBUG("BTC_GAP_BLE_EXT_ADV_STOP");
2214 uint8_t num_adv = arg_5->ext_adv_stop.num_adv;
2215 if(num_adv > 0) {
2216 tBTA_DM_BLE_EXT_ADV *ext_adv = osi_malloc(num_adv * sizeof(esp_ble_gap_ext_adv_t));
2217 if(ext_adv) {
2218 for (uint8_t i = 0; i < num_adv; i++) {
2219 ext_adv[i].instance = arg_5->ext_adv_stop.ext_adv_inst[i];
2220 ext_adv[i].duration = 0;
2221 ext_adv[i].max_events = 0;
2222 }
2223 BTA_DmBleGapExtAdvEnable(FALSE, num_adv, ext_adv);
2224 osi_free(ext_adv);
2225 } else {
2226 BTC_TRACE_ERROR("%s no mem\n", __func__);
2227 }
2228 } else {
2229 BTA_DmBleGapExtAdvEnable(FALSE, 0, NULL);
2230 }
2231 break;
2232 }
2233 case BTC_GAP_BLE_EXT_ADV_SET_REMOVE:
2234 BTA_DmBleGapExtAdvSetRemove(arg_5->ext_adv_set_remove.instance);
2235 break;
2236 case BTC_GAP_BLE_EXT_ADV_SET_CLEAR:
2237 BTA_DmBleGapExtAdvSetClear();
2238 break;
2239 case BTC_GAP_BLE_SET_PERIODIC_ADV_PARAMS: {
2240 tBTA_DM_BLE_Periodic_Adv_Params params = {0};
2241 params.interval_min = arg_5->peridic_adv_set_params.params.interval_min;
2242 params.interval_max = arg_5->peridic_adv_set_params.params.interval_max;
2243 params.properties = arg_5->peridic_adv_set_params.params.properties;
2244 BTC_TRACE_DEBUG("BTC_GAP_BLE_SET_PERIODIC_ADV_PARAMS");
2245 BTA_DmBleGapPeriodicAdvSetParams(arg_5->peridic_adv_set_params.instance,
2246 ¶ms);
2247 break;
2248 }
2249 case BTC_GAP_BLE_CFG_PERIODIC_ADV_DATA_RAW:
2250 BTC_TRACE_DEBUG("BTC_GAP_BLE_CFG_PERIODIC_ADV_DATA_RAW");
2251 BTA_DmBleGapPeriodicAdvCfgDataRaw(arg_5->periodic_adv_cfg_data.instance,
2252 arg_5->periodic_adv_cfg_data.len,
2253 (const UINT8 *)arg_5->periodic_adv_cfg_data.data,
2254 arg_5->periodic_adv_cfg_data.only_update_did);
2255 break;
2256 case BTC_GAP_BLE_PERIODIC_ADV_START:
2257 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_ADV_START");
2258 BTA_DmBleGapPeriodicAdvEnable(((arg_5->periodic_adv_start.include_adi)<<1)|0x01, arg_5->periodic_adv_start.instance);
2259 break;
2260 case BTC_GAP_BLE_PERIODIC_ADV_STOP:
2261 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_ADV_STOP");
2262 BTA_DmBleGapPeriodicAdvEnable(FALSE, arg_5->periodic_adv_stop.instance);
2263 break;
2264 case BTC_GAP_BLE_PERIODIC_ADV_CREATE_SYNC: {
2265 tBTA_DM_BLE_Periodic_Sync_Params params = {0};
2266 params.filter_policy = arg_5->periodic_adv_create_sync.params.filter_policy;
2267 params.sid = arg_5->periodic_adv_create_sync.params.sid;
2268 params.addr_type = arg_5->periodic_adv_create_sync.params.addr_type;
2269 params.skip = arg_5->periodic_adv_create_sync.params.skip;
2270 params.sync_timeout = arg_5->periodic_adv_create_sync.params.sync_timeout;
2271 #if (CONFIG_BT_BLE_FEAT_CREATE_SYNC_ENH)
2272 params.reports_disabled = arg_5->periodic_adv_create_sync.params.reports_disabled;
2273 params.filter_duplicates = arg_5->periodic_adv_create_sync.params.filter_duplicates;
2274 #endif
2275
2276 memcpy(params.addr, arg_5->periodic_adv_create_sync.params.addr, sizeof(BD_ADDR));
2277 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_ADV_CREATE_SYNC");
2278 BTA_DmBleGapPeriodicAdvCreateSync(¶ms);
2279 break;
2280 }
2281 case BTC_GAP_BLE_PERIODIC_ADV_SYNC_CANCEL:
2282 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_ADV_SYNC_CANCEL");
2283 BTA_DmBleGapPeriodicAdvSyncCancel();
2284 break;
2285 case BTC_GAP_BLE_PERIODIC_ADV_SYNC_TERMINATE:
2286 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_ADV_SYNC_TERMINATE");
2287 BTA_DmBleGapPeriodicAdvSyncTerm(arg_5->periodic_adv_sync_term.sync_handle);
2288 break;
2289 case BTC_GAP_BLE_PERIODIC_ADV_ADD_DEV_TO_LIST:
2290 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_ADV_ADD_DEV_TO_LIST");
2291 BTA_DmBleGapPeriodicAdvAddDevToList(arg_5->periodic_adv_add_dev.addr_type,
2292 arg_5->periodic_adv_add_dev.addr,
2293 arg_5->periodic_adv_add_dev.sid);
2294 break;
2295 case BTC_GAP_BLE_PERIODIC_REMOVE_ADD_DEV_FROM_LIST:
2296 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_REMOVE_ADD_DEV_FROM_LIST");
2297 BTA_DmBleGapPeriodicAdvRemoveDevFromList(arg_5->periodic_adv_remove_dev.addr_type,
2298 arg_5->periodic_adv_remove_dev.addr,
2299 arg_5->periodic_adv_remove_dev.sid);
2300 break;
2301 case BTC_GAP_BLE_PERIODIC_CLEAR_DEV:
2302 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_CLEAR_DEV");
2303 BTA_DmBleGapPeriodicAdvClearDev();
2304 break;
2305 case BTC_GAP_BLE_SET_EXT_SCAN_PARAMS: {
2306 tBTA_DM_BLE_EXT_SCAN_PARAMS params = {0};
2307 params.own_addr_type = arg_5->set_ext_scan_params.params.own_addr_type;
2308 params.filter_policy = arg_5->set_ext_scan_params.params.filter_policy;
2309 params.scan_duplicate = arg_5->set_ext_scan_params.params.scan_duplicate;
2310 params.cfg_mask = arg_5->set_ext_scan_params.params.cfg_mask;
2311 if (params.cfg_mask & BTA_DM_BLE_GAP_EXT_SCAN_UNCODE_MASK) {
2312 params.uncoded_cfg.scan_type = arg_5->set_ext_scan_params.params.uncoded_cfg.scan_type;
2313 params.uncoded_cfg.scan_interval = arg_5->set_ext_scan_params.params.uncoded_cfg.scan_interval;
2314 params.uncoded_cfg.scan_window = arg_5->set_ext_scan_params.params.uncoded_cfg.scan_window;
2315 }
2316
2317 if (params.cfg_mask & BTA_DM_BLE_GAP_EXT_SCAN_CODE_MASK) {
2318 params.coded_cfg.scan_type = arg_5->set_ext_scan_params.params.coded_cfg.scan_type;
2319 params.coded_cfg.scan_interval = arg_5->set_ext_scan_params.params.coded_cfg.scan_interval;
2320 params.coded_cfg.scan_window = arg_5->set_ext_scan_params.params.coded_cfg.scan_window;
2321 }
2322
2323 BTC_TRACE_DEBUG("BTC_GAP_BLE_SET_EXT_SCAN_PARAMS");
2324 BTA_DmBleGapSetExtScanParams(¶ms);
2325 break;
2326 }
2327 case BTC_GAP_BLE_START_EXT_SCAN:
2328 BTC_TRACE_DEBUG("BTC_GAP_BLE_START_EXT_SCAN");
2329 BTA_DmBleGapExtScan(TRUE, arg_5->start_ext_scan.duration, arg_5->start_ext_scan.period);
2330 break;
2331 case BTC_GAP_BLE_STOP_EXT_SCAN:
2332 BTC_TRACE_DEBUG("BTC_GAP_BLE_STOP_EXT_SCAN");
2333 BTA_DmBleGapExtScan(FALSE, 0, 0);
2334 break;
2335 case BTC_GAP_BLE_SET_EXT_PEFER_CONNET_PARAMS:
2336 BTC_TRACE_DEBUG("BTC_GAP_BLE_SET_EXT_PEFER_CONNET_PARAMS");
2337 BTA_DmBleGapPreferExtConnectParamsSet(arg_5->set_ext_conn_params.addr,
2338 arg_5->set_ext_conn_params.phy_mask,
2339 (const tBTA_DM_BLE_CONN_PARAMS *)&arg_5->set_ext_conn_params.phy_1m_conn_params,
2340 (const tBTA_DM_BLE_CONN_PARAMS *)&arg_5->set_ext_conn_params.phy_2m_conn_params,
2341 (const tBTA_DM_BLE_CONN_PARAMS *)&arg_5->set_ext_conn_params.phy_coded_conn_params);
2342 break;
2343 #endif // #if (BLE_50_FEATURE_SUPPORT == TRUE)
2344 #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE)
2345 case BTC_GAP_BLE_PERIODIC_ADV_RECV_ENABLE:
2346 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_ADV_RECV_ENABLE");
2347 BTA_DmBleGapPeriodicAdvRecvEnable(arg_5->periodic_adv_recv_en.sync_handle,
2348 arg_5->periodic_adv_recv_en.enable);
2349 break;
2350 case BTC_GAP_BLE_PERIODIC_ADV_SYNC_TRANS:
2351 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_ADV_SYNC_TRANS");
2352 BTA_DmBleGapPeriodicAdvSyncTrans(arg_5->periodic_adv_sync_trans.addr,
2353 arg_5->periodic_adv_sync_trans.service_data,
2354 arg_5->periodic_adv_sync_trans.sync_handle);
2355 break;
2356 case BTC_GAP_BLE_PERIODIC_ADV_SET_INFO_TRANS:
2357 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_ADV_SET_INFO_TRANS");
2358 BTA_DmBleGapPeriodicAdvSetInfoTrans(arg_5->periodic_adv_set_info_trans.addr,
2359 arg_5->periodic_adv_set_info_trans.service_data,
2360 arg_5->periodic_adv_set_info_trans.adv_handle);
2361 break;
2362 case BTC_GAP_BLE_SET_PERIODIC_ADV_SYNC_TRANS_PARAMS:
2363 BTC_TRACE_DEBUG("BTC_GAP_BLE_SET_PERIODIC_ADV_SYNC_TRANS_PARAMS");
2364 BTA_DmBleGapSetPeriodicAdvSyncTransParams(arg_5->set_periodic_adv_sync_trans_params.addr,
2365 (tBTA_DM_BLE_PAST_PARAMS *)&arg_5->set_periodic_adv_sync_trans_params.params);
2366 break;
2367 #endif
2368 #if (BLE_42_FEATURE_SUPPORT == TRUE)
2369 case BTC_GAP_BLE_DTM_TX_START:
2370 btc_ble_dtm_tx_start(arg->dtm_tx_start.tx_channel, arg->dtm_tx_start.len_of_data, arg->dtm_tx_start.pkt_payload, btc_dtm_tx_start_callback);
2371 break;
2372 case BTC_GAP_BLE_DTM_RX_START:
2373 btc_ble_dtm_rx_start(arg->dtm_rx_start.rx_channel, btc_dtm_rx_start_callback);
2374 break;
2375 #endif // if (BLE_42_FEATURE_SUPPORT == TRUE)
2376 case BTC_GAP_BLE_DTM_STOP:
2377 btc_ble_dtm_stop(btc_dtm_stop_callback);
2378 break;
2379 #if (BLE_50_FEATURE_SUPPORT == TRUE)
2380 case BTC_GAP_BLE_DTM_ENH_TX_START:
2381 btc_ble_dtm_enhance_tx_start(arg_5->dtm_enh_tx_start.tx_channel, arg_5->dtm_enh_tx_start.len_of_data, arg_5->dtm_enh_tx_start.pkt_payload, arg_5->dtm_enh_tx_start.phy, btc_dtm_tx_start_callback);
2382 break;
2383 case BTC_GAP_BLE_DTM_ENH_RX_START:
2384 btc_ble_dtm_enhance_rx_start(arg_5->dtm_enh_rx_start.rx_channel, arg_5->dtm_enh_rx_start.phy, arg_5->dtm_enh_rx_start.modulation_index, btc_dtm_rx_start_callback);
2385 break;
2386 #endif // if (BLE_50_FEATURE_SUPPORT == TRUE)
2387 case BTC_GAP_BLE_ACT_VENDOR_HCI_CMD_EVT:
2388 BTA_DmsendVendorHciCmd(arg->vendor_cmd_send.opcode,
2389 arg->vendor_cmd_send.param_len,
2390 arg->vendor_cmd_send.p_param_buf,
2391 btc_ble_vendor_hci_cmd_complete_callback);
2392 break;
2393 case BTC_GAP_BLE_SET_PRIVACY_MODE:
2394 btc_ble_set_privacy_mode(arg->set_privacy_mode.addr_type, arg->set_privacy_mode.addr,
2395 arg->set_privacy_mode.privacy_mode, btc_ble_set_privacy_mode_callback);
2396 break;
2397 case BTC_GAP_BLE_SET_CSA_SUPPORT:
2398 BTA_DmBleGapSetCsaSupport(arg->set_csa_support.csa_select, btc_ble_set_csa_support_callback);
2399 break;
2400 default:
2401 break;
2402 }
2403
2404 btc_gap_ble_arg_deep_free(msg);
2405 }
2406
2407 //register connection parameter update callback
btc_gap_callback_init(void)2408 void btc_gap_callback_init(void)
2409 {
2410 BTM_BleRegiseterPktLengthChangeCallback(btc_set_pkt_length_callback);
2411 BTM_BleRegiseterConnParamCallback(btc_update_conn_param_callback);
2412 #if (BLE_50_FEATURE_SUPPORT == TRUE)
2413 BTM_BleGapRegisterCallback(btc_ble_5_gap_callback);
2414 #endif // #if (BLE_50_FEATURE_SUPPORT == TRUE)
2415 }
2416
btc_gap_ble_init(void)2417 bool btc_gap_ble_init(void)
2418 {
2419 #if (BLE_42_FEATURE_SUPPORT == TRUE)
2420 btc_gap_ble_env_t *p_env = &btc_gap_ble_env;
2421 p_env->adv_rpt_queue = pkt_queue_create();
2422 assert(p_env->adv_rpt_queue != NULL);
2423
2424 p_env->adv_rpt_ready = osi_event_create(btc_gap_ble_adv_pkt_handler, NULL);
2425 assert(p_env->adv_rpt_ready != NULL);
2426 osi_event_bind(p_env->adv_rpt_ready, btc_get_current_thread(), BTC_GAP_BLE_ADV_RPT_QUEUE_IDX);
2427 #endif
2428 return true;
2429 }
2430
btc_gap_ble_deinit(void)2431 void btc_gap_ble_deinit(void)
2432 {
2433 #if (BLE_42_FEATURE_SUPPORT == TRUE)
2434 btc_gap_ble_env_t *p_env = &btc_gap_ble_env;
2435
2436 osi_event_delete(p_env->adv_rpt_ready);
2437 p_env->adv_rpt_ready = NULL;
2438
2439 pkt_queue_destroy(p_env->adv_rpt_queue, NULL);
2440 p_env->adv_rpt_queue = NULL;
2441
2442 btc_cleanup_adv_data(&gl_bta_adv_data);
2443 btc_cleanup_adv_data(&gl_bta_scan_rsp_data);
2444 #endif // #if (BLE_42_FEATURE_SUPPORT == TRUE)
2445 }
2446
2447 #if SCAN_QUEUE_CONGEST_CHECK
btc_adv_list_free(void * data)2448 void btc_adv_list_free(void *data)
2449 {
2450 osi_free(data);
2451 }
2452
btc_adv_list_init(void)2453 void btc_adv_list_init(void)
2454 {
2455 osi_mutex_new(&adv_list_lock);
2456 adv_filter_list = list_new(btc_adv_list_free);
2457 }
2458
btc_adv_list_deinit(void)2459 void btc_adv_list_deinit(void)
2460 {
2461 osi_mutex_free(&adv_list_lock);
2462 if(adv_filter_list) {
2463 list_free(adv_filter_list);
2464 adv_filter_list = NULL;
2465 }
2466 }
btc_adv_list_add_packet(void * data)2467 void btc_adv_list_add_packet(void * data)
2468 {
2469 if(!data) {
2470 BTC_TRACE_ERROR("%s data is NULL", __func__);
2471 return;
2472 }
2473 btc_adv_list_lock();
2474 list_prepend(adv_filter_list, data);
2475 btc_adv_list_unlock();
2476 }
2477
btc_get_adv_list_length(void)2478 uint32_t btc_get_adv_list_length(void)
2479 {
2480 if(!adv_filter_list) {
2481 BTC_TRACE_ERROR("%s adv_filter_list is NULL", __func__);
2482 return 0;
2483 }
2484 btc_adv_list_lock();
2485 size_t length = list_length(adv_filter_list);
2486 btc_adv_list_unlock();
2487
2488 return length;
2489 }
2490
btc_adv_list_refresh(void)2491 void btc_adv_list_refresh(void)
2492 {
2493 if(!adv_filter_list) {
2494 BTC_TRACE_ERROR("%s adv_filter_list is NULL", __func__);
2495 return ;
2496 }
2497 btc_adv_list_lock();
2498 list_clear(adv_filter_list);
2499 btc_adv_list_unlock();
2500 }
2501
btc_check_adv_list(uint8_t * addr,uint8_t addr_type)2502 bool btc_check_adv_list(uint8_t * addr, uint8_t addr_type)
2503 {
2504 bool found = false;
2505 if(!adv_filter_list || !addr) {
2506 BTC_TRACE_ERROR("%s adv_filter_list is NULL", __func__);
2507 return found;
2508 }
2509
2510 btc_adv_list_lock();
2511 for (const list_node_t *node = list_begin(adv_filter_list); node != list_end(adv_filter_list); node = list_next(node)) {
2512 btc_adv_packet_t *packet = (btc_adv_packet_t *)list_node(node);
2513 if(!bdcmp(addr, packet->addr) && packet->addr_type == addr_type) {
2514 found = true;
2515 break;
2516 }
2517 }
2518 btc_adv_list_unlock();
2519 if(!found) {
2520 btc_adv_packet_t *adv_packet = osi_malloc(sizeof(btc_adv_packet_t));
2521 if(adv_packet) {
2522 adv_packet->addr_type = addr_type;
2523 bdcpy(adv_packet->addr, addr);
2524 btc_adv_list_add_packet(adv_packet);
2525 } else {
2526 BTC_TRACE_ERROR("%s adv_packet malloc failed", __func__);
2527 }
2528 }
2529 return found;
2530 }
2531
btc_adv_list_lock(void)2532 void btc_adv_list_lock(void)
2533 {
2534 osi_mutex_lock(&adv_list_lock, OSI_MUTEX_MAX_TIMEOUT);
2535 }
2536
btc_adv_list_unlock(void)2537 void btc_adv_list_unlock(void)
2538 {
2539 osi_mutex_unlock(&adv_list_lock);
2540 }
2541 #endif
2542 #endif ///BLE_INCLUDED == TRUE
2543
