1 // Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include <string.h>
16
17 #include "osi/allocator.h"
18 #include "stack/bt_types.h"
19 #include "common/bt_defs.h"
20 #include "bta/bta_api.h"
21 #include "bta/bta_dm_co.h"
22 #include "btc/btc_task.h"
23 #include "btc/btc_manage.h"
24 #include "btc_gap_ble.h"
25 #include "btc_gatt_util.h"
26 #include "esp_bt_defs.h"
27 #include "esp_gap_ble_api.h"
28 #include "btc/btc_ble_storage.h"
29 #include "btc/btc_dm.h"
30 #include "btc/btc_util.h"
31 #include "osi/mutex.h"
32 #include "esp_bt.h"
33
34 #if (BLE_INCLUDED == 1)
35 #if (BLE_42_FEATURE_SUPPORT == 1)
36 #if BTC_DYNAMIC_MEMORY == 0
37 static tBTA_BLE_ADV_DATA gl_bta_adv_data;
38 static tBTA_BLE_ADV_DATA gl_bta_scan_rsp_data;
39 #else
40 tBTA_BLE_ADV_DATA *gl_bta_adv_data_ptr;
41 tBTA_BLE_ADV_DATA *gl_bta_scan_rsp_data_ptr;
42 #endif
43 #endif // #if (BLE_42_FEATURE_SUPPORT == 1)
44
45 #if SCAN_QUEUE_CONGEST_CHECK
46 static list_t *adv_filter_list;
47 static osi_mutex_t adv_list_lock;
48 bool btc_check_adv_list(uint8_t * addr, uint8_t addr_type);
49 uint32_t btc_get_adv_list_length(void);
50 void btc_adv_list_refresh(void);
51 void btc_adv_list_lock(void);
52 void btc_adv_list_unlock(void);
53 static uint16_t btc_adv_list_count = 0;
54
55 #define BTC_ADV_LIST_MAX_LENGTH 50
56 #define BTC_ADV_LIST_MAX_COUNT 200
57 #endif
58
btc_gap_ble_cb_to_app(esp_gap_ble_cb_event_t event,esp_ble_gap_cb_param_t * param)59 static inline void btc_gap_ble_cb_to_app(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
60 {
61 esp_gap_ble_cb_t btc_gap_ble_cb = (esp_gap_ble_cb_t)btc_profile_cb_get(BTC_PID_GAP_BLE);
62 if (btc_gap_ble_cb) {
63 btc_gap_ble_cb(event, param);
64 }
65 }
66 #if (BLE_42_FEATURE_SUPPORT == 1)
btc_gap_adv_point_cleanup(void ** buf)67 static void btc_gap_adv_point_cleanup(void **buf)
68 {
69 if (NULL == *buf) {
70 return;
71 }
72 osi_free(*buf);
73 *buf = NULL;
74 }
75
76
btc_cleanup_adv_data(tBTA_BLE_ADV_DATA * bta_adv_data)77 static void btc_cleanup_adv_data(tBTA_BLE_ADV_DATA *bta_adv_data)
78 {
79 if (bta_adv_data == NULL) {
80 return;
81 }
82
83 // Manufacturer data cleanup
84 if (bta_adv_data->p_manu != NULL) {
85 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_manu->p_val);
86 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_manu);
87 }
88
89 // Proprietary data cleanup
90 if (bta_adv_data->p_proprietary != NULL) {
91 int i = 0;
92 tBTA_BLE_PROP_ELEM *p_elem = bta_adv_data->p_proprietary->p_elem;
93 while (i++ != bta_adv_data->p_proprietary->num_elem
94 && p_elem) {
95 btc_gap_adv_point_cleanup((void **) &p_elem->p_val);
96 ++p_elem;
97 }
98
99 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_proprietary->p_elem);
100 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_proprietary);
101 }
102
103 // Service list cleanup
104 if (bta_adv_data->p_services != NULL) {
105 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_services->p_uuid);
106 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_services);
107 }
108
109 // Service data cleanup
110 if (bta_adv_data->p_service_data != NULL) {
111 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_service_data->p_val);
112 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_service_data);
113 }
114
115 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_services_128b);
116
117 if (bta_adv_data->p_service_32b != NULL) {
118 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_service_32b->p_uuid);
119 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_service_32b);
120 }
121
122 if (bta_adv_data->p_sol_services != NULL) {
123 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_sol_services->p_uuid);
124 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_sol_services);
125 }
126
127 if (bta_adv_data->p_sol_service_32b != NULL) {
128 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_sol_service_32b->p_uuid);
129 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_sol_service_32b);
130 }
131
132 btc_gap_adv_point_cleanup((void **) &bta_adv_data->p_sol_service_128b);
133 }
134
btc_to_bta_adv_data(esp_ble_adv_data_t * p_adv_data,tBTA_BLE_ADV_DATA * bta_adv_data,uint32_t * data_mask)135 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)
136 {
137 uint32_t mask;
138
139 btc_cleanup_adv_data(bta_adv_data);
140
141 memset(bta_adv_data, 0, sizeof(tBTA_BLE_ADV_DATA));
142 mask = 0;
143
144 if (p_adv_data->flag != 0) {
145 mask = BTM_BLE_AD_BIT_FLAGS;
146 bta_adv_data->flag = p_adv_data->flag;
147 }
148
149 if (p_adv_data->include_name) {
150 mask |= BTM_BLE_AD_BIT_DEV_NAME;
151 }
152
153 if (p_adv_data->include_txpower) {
154 mask |= BTM_BLE_AD_BIT_TX_PWR;
155 bta_adv_data->tx_power = esp_ble_tx_power_get(ESP_BLE_PWR_TYPE_ADV);
156 }
157
158 if (p_adv_data->min_interval > 0 && p_adv_data->max_interval > 0 &&
159 p_adv_data->max_interval >= p_adv_data->min_interval) {
160 mask |= BTM_BLE_AD_BIT_INT_RANGE;
161 bta_adv_data->int_range.low = p_adv_data->min_interval;
162 bta_adv_data->int_range.hi = p_adv_data->max_interval;
163 }
164
165 if (p_adv_data->include_txpower) {
166 //TODO
167 }
168
169 if (p_adv_data->appearance != 0) {
170 mask |= BTM_BLE_AD_BIT_APPEARANCE;
171 bta_adv_data->appearance = p_adv_data->appearance;
172 }
173
174 if (p_adv_data->manufacturer_len > 0 && p_adv_data->p_manufacturer_data != NULL) {
175 bta_adv_data->p_manu = osi_malloc(sizeof(tBTA_BLE_MANU));
176 if (bta_adv_data->p_manu != NULL) {
177 bta_adv_data->p_manu->p_val = osi_malloc(p_adv_data->manufacturer_len);
178 if (bta_adv_data->p_manu->p_val != NULL) {
179 mask |= BTM_BLE_AD_BIT_MANU;
180 bta_adv_data->p_manu->len = p_adv_data->manufacturer_len;
181 memcpy(bta_adv_data->p_manu->p_val, p_adv_data->p_manufacturer_data, p_adv_data->manufacturer_len);
182 }
183 }
184 }
185
186 tBTA_BLE_PROP_ELEM *p_elem_service_data = NULL;
187 if (p_adv_data->service_data_len > 0 && p_adv_data->p_service_data != NULL) {
188 p_elem_service_data = osi_malloc(sizeof(tBTA_BLE_PROP_ELEM));
189 if (p_elem_service_data != NULL) {
190 p_elem_service_data->p_val = osi_malloc(p_adv_data->service_data_len);
191 if (p_elem_service_data->p_val != NULL) {
192 p_elem_service_data->adv_type = BTM_BLE_AD_TYPE_SERVICE_DATA;
193 p_elem_service_data->len = p_adv_data->service_data_len;
194 memcpy(p_elem_service_data->p_val, p_adv_data->p_service_data,
195 p_adv_data->service_data_len);
196 } else {
197 osi_free(p_elem_service_data);
198 p_elem_service_data = NULL;
199 }
200 }
201 }
202
203 if (NULL != p_elem_service_data) {
204 bta_adv_data->p_proprietary = osi_malloc(sizeof(tBTA_BLE_PROPRIETARY));
205 if (NULL != bta_adv_data->p_proprietary) {
206 tBTA_BLE_PROP_ELEM *p_elem = NULL;
207 tBTA_BLE_PROPRIETARY *p_prop = bta_adv_data->p_proprietary;
208 p_prop->num_elem = 0;
209 mask |= BTM_BLE_AD_BIT_PROPRIETARY;
210 p_prop->num_elem = 1;
211 p_prop->p_elem = osi_malloc(sizeof(tBTA_BLE_PROP_ELEM) * p_prop->num_elem);
212 p_elem = p_prop->p_elem;
213 if (NULL != p_elem) {
214 memcpy(p_elem++, p_elem_service_data, sizeof(tBTA_BLE_PROP_ELEM));
215 }
216 osi_free(p_elem_service_data);
217 }
218 }
219
220 if (p_adv_data->service_uuid_len && p_adv_data->p_service_uuid) {
221 UINT16 *p_uuid_out16 = NULL;
222 UINT32 *p_uuid_out32 = NULL;
223 for (int position = 0; position < p_adv_data->service_uuid_len; position += LEN_UUID_128) {
224 tBT_UUID bt_uuid;
225
226 btc128_to_bta_uuid(&bt_uuid, p_adv_data->p_service_uuid + position);
227
228 switch (bt_uuid.len) {
229 case (LEN_UUID_16): {
230 if (NULL == bta_adv_data->p_services) {
231 bta_adv_data->p_services = osi_malloc(sizeof(tBTA_BLE_SERVICE));
232 bta_adv_data->p_services->list_cmpl = 0;
233 bta_adv_data->p_services->num_service = 0;
234 bta_adv_data->p_services->p_uuid = osi_malloc(p_adv_data->service_uuid_len / LEN_UUID_128 * LEN_UUID_16);
235 p_uuid_out16 = bta_adv_data->p_services->p_uuid;
236 }
237
238 if (NULL != bta_adv_data->p_services->p_uuid) {
239 BTC_TRACE_DEBUG("%s - In 16-UUID_data", __FUNCTION__);
240 mask |= BTM_BLE_AD_BIT_SERVICE;
241 ++bta_adv_data->p_services->num_service;
242 *p_uuid_out16++ = bt_uuid.uu.uuid16;
243 }
244 break;
245 }
246
247 case (LEN_UUID_32): {
248 if (NULL == bta_adv_data->p_service_32b) {
249 bta_adv_data->p_service_32b =
250 osi_malloc(sizeof(tBTA_BLE_32SERVICE));
251 bta_adv_data->p_service_32b->list_cmpl = 0;
252 bta_adv_data->p_service_32b->num_service = 0;
253 bta_adv_data->p_service_32b->p_uuid =
254 osi_malloc(p_adv_data->service_uuid_len / LEN_UUID_128 * LEN_UUID_32);
255 p_uuid_out32 = bta_adv_data->p_service_32b->p_uuid;
256 }
257
258 if (NULL != bta_adv_data->p_service_32b->p_uuid) {
259 BTC_TRACE_DEBUG("%s - In 32-UUID_data", __FUNCTION__);
260 mask |= BTM_BLE_AD_BIT_SERVICE_32;
261 ++bta_adv_data->p_service_32b->num_service;
262 *p_uuid_out32++ = bt_uuid.uu.uuid32;
263 }
264 break;
265 }
266
267 case (LEN_UUID_128): {
268 /* Currently, only one 128-bit UUID is supported */
269 if (NULL == bta_adv_data->p_services_128b) {
270 bta_adv_data->p_services_128b =
271 osi_malloc(sizeof(tBTA_BLE_128SERVICE));
272 if (NULL != bta_adv_data->p_services_128b) {
273 BTC_TRACE_DEBUG("%s - In 128-UUID_data", __FUNCTION__);
274 mask |= BTM_BLE_AD_BIT_SERVICE_128;
275 memcpy(bta_adv_data->p_services_128b->uuid128,
276 bt_uuid.uu.uuid128, LEN_UUID_128);
277 BTC_TRACE_DEBUG("%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x", bt_uuid.uu.uuid128[0],
278 bt_uuid.uu.uuid128[1], bt_uuid.uu.uuid128[2], bt_uuid.uu.uuid128[3],
279 bt_uuid.uu.uuid128[4], bt_uuid.uu.uuid128[5], bt_uuid.uu.uuid128[6],
280 bt_uuid.uu.uuid128[7], bt_uuid.uu.uuid128[8], bt_uuid.uu.uuid128[9],
281 bt_uuid.uu.uuid128[10], bt_uuid.uu.uuid128[11], bt_uuid.uu.uuid128[12],
282 bt_uuid.uu.uuid128[13], bt_uuid.uu.uuid128[14], bt_uuid.uu.uuid128[15]);
283 bta_adv_data->p_services_128b->list_cmpl = 1;
284 }
285 }
286 break;
287 }
288
289 default:
290 break;
291 }
292 }
293 }
294
295 *data_mask = mask;
296 }
297
btc_adv_data_callback(tBTA_STATUS status)298 static void btc_adv_data_callback(tBTA_STATUS status)
299 {
300 esp_ble_gap_cb_param_t param;
301 bt_status_t ret;
302 btc_msg_t msg;
303
304 msg.sig = BTC_SIG_API_CB;
305 msg.pid = BTC_PID_GAP_BLE;
306 msg.act = ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT;
307 param.adv_data_cmpl.status = status;
308
309 ret = btc_transfer_context(&msg, ¶m,
310 sizeof(esp_ble_gap_cb_param_t), NULL);
311
312 if (ret != BT_STATUS_SUCCESS) {
313 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
314 }
315 }
316
btc_scan_rsp_data_callback(tBTA_STATUS status)317 static void btc_scan_rsp_data_callback(tBTA_STATUS status)
318 {
319 esp_ble_gap_cb_param_t param;
320 bt_status_t ret;
321 btc_msg_t msg;
322
323 msg.sig = BTC_SIG_API_CB;
324 msg.pid = BTC_PID_GAP_BLE;
325 msg.act = ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT;
326 param.scan_rsp_data_cmpl.status = status;
327
328 ret = btc_transfer_context(&msg, ¶m,
329 sizeof(esp_ble_gap_cb_param_t), NULL);
330
331 if (ret != BT_STATUS_SUCCESS) {
332 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
333 }
334 }
335
btc_adv_data_raw_callback(tBTA_STATUS status)336 static void btc_adv_data_raw_callback(tBTA_STATUS status)
337 {
338 esp_ble_gap_cb_param_t param;
339 bt_status_t ret;
340 btc_msg_t msg;
341
342 msg.sig = BTC_SIG_API_CB;
343 msg.pid = BTC_PID_GAP_BLE;
344 msg.act = ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT;
345 param.adv_data_raw_cmpl.status = status;
346
347 ret = btc_transfer_context(&msg, ¶m,
348 sizeof(esp_ble_gap_cb_param_t), NULL);
349
350 if (ret != BT_STATUS_SUCCESS) {
351 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
352 }
353 }
354
btc_scan_rsp_data_raw_callback(tBTA_STATUS status)355 static void btc_scan_rsp_data_raw_callback(tBTA_STATUS status)
356 {
357 esp_ble_gap_cb_param_t param;
358 bt_status_t ret;
359 btc_msg_t msg;
360
361 msg.sig = BTC_SIG_API_CB;
362 msg.pid = BTC_PID_GAP_BLE;
363 msg.act = ESP_GAP_BLE_SCAN_RSP_DATA_RAW_SET_COMPLETE_EVT;
364 param.scan_rsp_data_raw_cmpl.status = status;
365
366 ret = btc_transfer_context(&msg, ¶m,
367 sizeof(esp_ble_gap_cb_param_t), NULL);
368
369 if (ret != BT_STATUS_SUCCESS) {
370 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
371 }
372 }
373
btc_ble_set_adv_data(esp_ble_adv_data_t * adv_data,tBTA_SET_ADV_DATA_CMPL_CBACK p_adv_data_cback)374 static void btc_ble_set_adv_data(esp_ble_adv_data_t *adv_data,
375 tBTA_SET_ADV_DATA_CMPL_CBACK p_adv_data_cback)
376 {
377 tBTA_BLE_AD_MASK data_mask = 0;
378
379 if (!adv_data->set_scan_rsp) {
380 btc_to_bta_adv_data(adv_data, &gl_bta_adv_data, &data_mask);
381 BTA_DmBleSetAdvConfig(data_mask, &gl_bta_adv_data, p_adv_data_cback);
382 } else {
383 btc_to_bta_adv_data(adv_data, &gl_bta_scan_rsp_data, &data_mask);
384 BTA_DmBleSetScanRsp(data_mask, &gl_bta_scan_rsp_data, p_adv_data_cback);
385 }
386 }
387
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)388 static void btc_ble_set_adv_data_raw(uint8_t *raw_adv, uint32_t raw_adv_len,
389 tBTA_SET_ADV_DATA_CMPL_CBACK p_adv_data_cback)
390 {
391 BTA_DmBleSetAdvConfigRaw(raw_adv, raw_adv_len, p_adv_data_cback);
392 }
393
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)394 static void btc_ble_set_scan_rsp_data_raw(uint8_t *raw_scan_rsp, uint32_t raw_scan_rsp_len,
395 tBTA_SET_ADV_DATA_CMPL_CBACK p_scan_rsp_data_cback)
396 {
397 BTA_DmBleSetScanRspRaw(raw_scan_rsp, raw_scan_rsp_len, p_scan_rsp_data_cback);
398 }
399
btc_start_adv_callback(uint8_t status)400 static void btc_start_adv_callback(uint8_t status)
401 {
402 esp_ble_gap_cb_param_t param;
403 bt_status_t ret;
404 btc_msg_t msg;
405
406 msg.sig = BTC_SIG_API_CB;
407 msg.pid = BTC_PID_GAP_BLE;
408 msg.act = ESP_GAP_BLE_ADV_START_COMPLETE_EVT;
409 param.adv_start_cmpl.status = btc_hci_to_esp_status(status);
410
411 ret = btc_transfer_context(&msg, ¶m,
412 sizeof(esp_ble_gap_cb_param_t), NULL);
413
414 if (ret != BT_STATUS_SUCCESS) {
415 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
416 }
417 }
418
btc_stop_adv_callback(uint8_t status)419 static void btc_stop_adv_callback(uint8_t status)
420 {
421 esp_ble_gap_cb_param_t param;
422 bt_status_t ret;
423 btc_msg_t msg;
424
425 msg.sig = BTC_SIG_API_CB;
426 msg.pid = BTC_PID_GAP_BLE;
427 msg.act = ESP_GAP_BLE_ADV_STOP_COMPLETE_EVT;
428 param.adv_stop_cmpl.status = btc_hci_to_esp_status(status);
429
430 ret = btc_transfer_context(&msg, ¶m,
431 sizeof(esp_ble_gap_cb_param_t), NULL);
432
433 if (ret != BT_STATUS_SUCCESS) {
434 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
435 }
436 }
437
btc_update_duplicate_exceptional_list_callback(tBTA_STATUS status,uint8_t subcode,uint32_t length,uint8_t * device_info)438 void btc_update_duplicate_exceptional_list_callback(tBTA_STATUS status, uint8_t subcode, uint32_t length, uint8_t *device_info)
439 {
440 esp_ble_gap_cb_param_t param;
441 bt_status_t ret;
442 btc_msg_t msg;
443
444 msg.sig = BTC_SIG_API_CB;
445 msg.pid = BTC_PID_GAP_BLE;
446 msg.act = ESP_GAP_BLE_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_COMPLETE_EVT;
447 param.update_duplicate_exceptional_list_cmpl.status = status;
448 param.update_duplicate_exceptional_list_cmpl.subcode = subcode;
449 if(length > sizeof(param.update_duplicate_exceptional_list_cmpl.device_info)) {
450 length = sizeof(param.update_duplicate_exceptional_list_cmpl.device_info);
451 }
452 param.update_duplicate_exceptional_list_cmpl.length = length;
453 memcpy(param.update_duplicate_exceptional_list_cmpl.device_info, device_info, length);
454 ret = btc_transfer_context(&msg, ¶m, sizeof(esp_ble_gap_cb_param_t), NULL);
455
456 if (ret != BT_STATUS_SUCCESS) {
457 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
458 }
459 }
460
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)461 static void btc_ble_update_duplicate_exceptional_list(uint8_t subcode, uint32_t info_type, BD_ADDR device_info,
462 tBTA_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_CMPL_CBACK p_update_duplicate_ignore_list_cback)
463 {
464 BTA_DmUpdateDuplicateExceptionalList(subcode, info_type, device_info, p_update_duplicate_ignore_list_cback);
465 }
466
btc_ble_start_advertising(esp_ble_adv_params_t * ble_adv_params,tBTA_START_ADV_CMPL_CBACK start_adv_cback)467 static void btc_ble_start_advertising (esp_ble_adv_params_t *ble_adv_params, tBTA_START_ADV_CMPL_CBACK start_adv_cback)
468 {
469 tBLE_BD_ADDR peer_addr;
470 esp_bt_status_t status = ESP_BT_STATUS_SUCCESS;
471 if (!BLE_ISVALID_PARAM(ble_adv_params->adv_int_min, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX) ||
472 !BLE_ISVALID_PARAM(ble_adv_params->adv_int_max, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX)) {
473 status = ESP_BT_STATUS_PARM_INVALID;
474 BTC_TRACE_ERROR("Invalid advertisting interval parameters.\n");
475 }
476
477 if ((ble_adv_params->adv_type < ADV_TYPE_IND) ||
478 (ble_adv_params->adv_type > ADV_TYPE_DIRECT_IND_LOW) ) {
479 status = ESP_BT_STATUS_PARM_INVALID;
480 BTC_TRACE_ERROR("Invalid advertisting type parameters.\n");
481 }
482
483 if ((ble_adv_params->adv_filter_policy < ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY) ||
484 (ble_adv_params->adv_filter_policy > ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST) ) {
485 status = ESP_BT_STATUS_PARM_INVALID;
486 BTC_TRACE_ERROR("Invalid advertisting type parameters.\n");
487 }
488
489 if((ble_adv_params->channel_map | ADV_CHNL_ALL) != ADV_CHNL_ALL || ble_adv_params->channel_map == 0) {
490 status = ESP_BT_STATUS_PARM_INVALID;
491 BTC_TRACE_ERROR("Invalid advertisting channel map parameters.\n");
492 }
493 if (!BLE_ISVALID_PARAM(ble_adv_params->peer_addr_type, BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_RANDOM)) {
494 status = ESP_BT_STATUS_PARM_INVALID;
495 BTC_TRACE_ERROR("Invalid advertisting peer address type parameters.\n");
496 }
497 if(status != ESP_BT_STATUS_SUCCESS) {
498 if(start_adv_cback) {
499 start_adv_cback(status);
500 }
501 return;
502 }
503
504 BTC_TRACE_DEBUG("API_Ble_AppStartAdvertising\n");
505
506 memcpy(peer_addr.bda, ble_adv_params->peer_addr, ESP_BD_ADDR_LEN);
507 peer_addr.type = ble_adv_params->peer_addr_type;
508 BTA_DmSetBleAdvParamsAll(ble_adv_params->adv_int_min,
509 ble_adv_params->adv_int_max,
510 ble_adv_params->adv_type,
511 ble_adv_params->own_addr_type,
512 ble_adv_params->channel_map,
513 ble_adv_params->adv_filter_policy,
514 &peer_addr,
515 start_adv_cback);
516 }
517
518
btc_scan_params_callback(tGATT_IF gatt_if,tBTM_STATUS status)519 static void btc_scan_params_callback(tGATT_IF gatt_if, tBTM_STATUS status)
520 {
521 esp_ble_gap_cb_param_t param;
522 bt_status_t ret;
523 btc_msg_t msg;
524
525 msg.sig = BTC_SIG_API_CB;
526 msg.pid = BTC_PID_GAP_BLE;
527 msg.act = ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT;
528 param.scan_param_cmpl.status = status;
529
530 ret = btc_transfer_context(&msg, ¶m,
531 sizeof(esp_ble_gap_cb_param_t), NULL);
532
533 if (ret != BT_STATUS_SUCCESS) {
534 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
535 }
536 }
537
btc_ble_set_scan_params(esp_ble_scan_params_t * scan_params,tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback)538 static void btc_ble_set_scan_params(esp_ble_scan_params_t *scan_params, tBLE_SCAN_PARAM_SETUP_CBACK scan_param_setup_cback)
539 {
540 if (BLE_ISVALID_PARAM(scan_params->scan_interval, BTM_BLE_SCAN_INT_MIN, BTM_BLE_SCAN_INT_MAX) &&
541 BLE_ISVALID_PARAM(scan_params->scan_window, BTM_BLE_SCAN_WIN_MIN, BTM_BLE_SCAN_WIN_MAX) &&
542 BLE_ISVALID_PARAM(scan_params->own_addr_type, BLE_ADDR_TYPE_PUBLIC, BLE_ADDR_TYPE_RPA_RANDOM) &&
543 BLE_ISVALID_PARAM(scan_params->scan_filter_policy, BLE_SCAN_FILTER_ALLOW_ALL, BLE_SCAN_FILTER_ALLOW_WLIST_RPA_DIR) &&
544 BLE_ISVALID_PARAM(scan_params->scan_duplicate, BLE_SCAN_DUPLICATE_DISABLE, BLE_SCAN_DUPLICATE_MAX -1) &&
545 (scan_params->scan_type == BTM_BLE_SCAN_MODE_ACTI || scan_params->scan_type == BTM_BLE_SCAN_MODE_PASS)) {
546 BTA_DmSetBleScanFilterParams(ESP_DEFAULT_GATT_IF, /*client_if*/
547 scan_params->scan_interval,
548 scan_params->scan_window,
549 scan_params->scan_type,
550 scan_params->scan_filter_policy,
551 scan_params->own_addr_type,
552 scan_params->scan_duplicate,
553 scan_param_setup_cback);
554 } else {
555 btc_scan_params_callback(ESP_DEFAULT_GATT_IF, BTM_ILLEGAL_VALUE);
556 }
557 }
558
btc_search_callback(tBTA_DM_SEARCH_EVT event,tBTA_DM_SEARCH * p_data)559 static void btc_search_callback(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_data)
560 {
561 esp_ble_gap_cb_param_t param;
562 btc_msg_t msg;
563
564 msg.sig = BTC_SIG_API_CB;
565 msg.pid = BTC_PID_GAP_BLE;
566 msg.act = ESP_GAP_BLE_SCAN_RESULT_EVT;
567
568 param.scan_rst.search_evt = event;
569 switch (event) {
570 case BTA_DM_INQ_RES_EVT: {
571 #if SCAN_QUEUE_CONGEST_CHECK
572 if(btc_check_queue_is_congest()) {
573 BTC_TRACE_DEBUG("BtcQueue is congested");
574 if(btc_get_adv_list_length() > BTC_ADV_LIST_MAX_LENGTH || btc_adv_list_count > BTC_ADV_LIST_MAX_COUNT) {
575 btc_adv_list_refresh();
576 btc_adv_list_count = 0;
577 }
578 if(btc_check_adv_list(p_data->inq_res.bd_addr, p_data->inq_res.ble_addr_type)) {
579 return;
580 }
581 }
582 btc_adv_list_count ++;
583 #endif
584 bdcpy(param.scan_rst.bda, p_data->inq_res.bd_addr);
585 param.scan_rst.dev_type = p_data->inq_res.device_type;
586 param.scan_rst.rssi = p_data->inq_res.rssi;
587 param.scan_rst.ble_addr_type = p_data->inq_res.ble_addr_type;
588 param.scan_rst.ble_evt_type = p_data->inq_res.ble_evt_type;
589 param.scan_rst.flag = p_data->inq_res.flag;
590 param.scan_rst.num_resps = 1;
591 param.scan_rst.adv_data_len = p_data->inq_res.adv_data_len;
592 param.scan_rst.scan_rsp_len = p_data->inq_res.scan_rsp_len;
593 memcpy(param.scan_rst.ble_adv, p_data->inq_res.p_eir, sizeof(param.scan_rst.ble_adv));
594 break;
595 }
596 case BTA_DM_INQ_CMPL_EVT: {
597 param.scan_rst.num_resps = p_data->inq_cmpl.num_resps;
598 BTC_TRACE_DEBUG("%s BLE observe complete. Num Resp %d\n", __FUNCTION__, p_data->inq_cmpl.num_resps);
599 break;
600 }
601 case BTA_DM_DISC_RES_EVT:
602 BTC_TRACE_DEBUG("BTA_DM_DISC_RES_EVT\n");
603 break;
604 case BTA_DM_DISC_BLE_RES_EVT:
605 BTC_TRACE_DEBUG("BTA_DM_DISC_BLE_RES_EVT\n");
606 break;
607 case BTA_DM_DISC_CMPL_EVT:
608 BTC_TRACE_DEBUG("BTA_DM_DISC_CMPL_EVT\n");
609 break;
610 case BTA_DM_DI_DISC_CMPL_EVT:
611 BTC_TRACE_DEBUG("BTA_DM_DI_DISC_CMPL_EVT\n");
612 break;
613 case BTA_DM_SEARCH_CANCEL_CMPL_EVT:
614 BTC_TRACE_DEBUG("BTA_DM_SEARCH_CANCEL_CMPL_EVT\n");
615 break;
616 case BTA_DM_INQ_DISCARD_NUM_EVT:
617 param.scan_rst.num_dis = p_data->inq_dis.num_dis;
618 break;
619 default:
620 BTC_TRACE_ERROR("%s : Unknown event 0x%x\n", __FUNCTION__, event);
621 return;
622 }
623 btc_transfer_context(&msg, ¶m, sizeof(esp_ble_gap_cb_param_t), NULL);
624 }
625
btc_start_scan_callback(uint8_t status)626 static void btc_start_scan_callback(uint8_t status)
627 {
628 esp_ble_gap_cb_param_t param;
629 bt_status_t ret;
630 btc_msg_t msg;
631
632 msg.sig = BTC_SIG_API_CB;
633 msg.pid = BTC_PID_GAP_BLE;
634 msg.act = ESP_GAP_BLE_SCAN_START_COMPLETE_EVT;
635 param.scan_start_cmpl.status = status;
636
637 ret = btc_transfer_context(&msg, ¶m,
638 sizeof(esp_ble_gap_cb_param_t), NULL);
639
640 if (ret != BT_STATUS_SUCCESS) {
641 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
642 }
643 }
644
btc_stop_scan_callback(tBTA_STATUS status)645 static void btc_stop_scan_callback(tBTA_STATUS status)
646 {
647 esp_ble_gap_cb_param_t param;
648 bt_status_t ret;
649 btc_msg_t msg;
650
651 msg.sig = BTC_SIG_API_CB;
652 msg.pid = BTC_PID_GAP_BLE;
653 msg.act = ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT;
654 param.scan_stop_cmpl.status = status;
655
656 ret = btc_transfer_context(&msg, ¶m,
657 sizeof(esp_ble_gap_cb_param_t), NULL);
658
659 if (ret != BT_STATUS_SUCCESS) {
660 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
661 }
662 #if SCAN_QUEUE_CONGEST_CHECK
663 btc_adv_list_refresh();
664 #endif
665 }
666 #endif // #if (BLE_42_FEATURE_SUPPORT == 1)
btc_update_conn_param_callback(UINT8 status,BD_ADDR bd_addr,tBTM_LE_UPDATE_CONN_PRAMS * update_conn_params)667 void btc_update_conn_param_callback (UINT8 status, BD_ADDR bd_addr, tBTM_LE_UPDATE_CONN_PRAMS *update_conn_params)
668 {
669 esp_ble_gap_cb_param_t param;
670 bt_status_t ret;
671 btc_msg_t msg;
672 msg.sig = BTC_SIG_API_CB;
673 msg.pid = BTC_PID_GAP_BLE;
674 msg.act = ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT;
675 param.update_conn_params.status = btc_hci_to_esp_status(status);
676 param.update_conn_params.min_int = update_conn_params->min_conn_int;
677 param.update_conn_params.max_int = update_conn_params->max_conn_int;
678 param.update_conn_params.conn_int = update_conn_params->conn_int;
679 param.update_conn_params.latency = update_conn_params->slave_latency;
680 param.update_conn_params.timeout = update_conn_params->supervision_tout;
681 memcpy(param.update_conn_params.bda, bd_addr, sizeof(esp_bd_addr_t));
682 ret = btc_transfer_context(&msg, ¶m,
683 sizeof(esp_ble_gap_cb_param_t), NULL);
684
685 if (ret != BT_STATUS_SUCCESS) {
686 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
687 }
688 }
689
btc_set_pkt_length_callback(UINT8 status,tBTM_LE_SET_PKT_DATA_LENGTH_PARAMS * data_len_params)690 static void btc_set_pkt_length_callback(UINT8 status, tBTM_LE_SET_PKT_DATA_LENGTH_PARAMS *data_len_params)
691 {
692 esp_ble_gap_cb_param_t param;
693 bt_status_t ret;
694 btc_msg_t msg;
695 msg.sig = BTC_SIG_API_CB;
696 msg.pid = BTC_PID_GAP_BLE;
697 msg.act = ESP_GAP_BLE_SET_PKT_LENGTH_COMPLETE_EVT;
698 param.pkt_data_lenth_cmpl.status = btc_btm_status_to_esp_status(status);
699 param.pkt_data_lenth_cmpl.params.rx_len = data_len_params->rx_len;
700 param.pkt_data_lenth_cmpl.params.tx_len = data_len_params->tx_len;
701 ret = btc_transfer_context(&msg, ¶m,
702 sizeof(esp_ble_gap_cb_param_t), NULL);
703
704 if (ret != BT_STATUS_SUCCESS) {
705 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
706 }
707 }
708
btc_gap_ble_set_channels_cmpl_callback(void * p_data)709 static void btc_gap_ble_set_channels_cmpl_callback(void *p_data)
710 {
711 tBTA_BLE_SET_CHANNELS_RESULTS *result = (tBTA_BLE_SET_CHANNELS_RESULTS *)p_data;
712 esp_ble_gap_cb_param_t param;
713 bt_status_t ret;
714 btc_msg_t msg;
715 msg.sig = BTC_SIG_API_CB;
716 msg.pid = BTC_PID_GAP_BLE;
717 msg.act = ESP_GAP_BLE_SET_CHANNELS_EVT;
718
719 param.ble_set_channels.stat = btc_btm_status_to_esp_status(result->status);
720
721 ret = btc_transfer_context(&msg, ¶m,
722 sizeof(esp_ble_gap_cb_param_t), NULL);
723
724 if (ret != BT_STATUS_SUCCESS) {
725 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
726 }
727 }
728
729
btc_add_whitelist_complete_callback(UINT8 status,tBTM_WL_OPERATION wl_opration)730 static void btc_add_whitelist_complete_callback(UINT8 status, tBTM_WL_OPERATION wl_opration)
731 {
732 esp_ble_gap_cb_param_t param;
733 bt_status_t ret;
734 btc_msg_t msg;
735 msg.sig = BTC_SIG_API_CB;
736 msg.pid = BTC_PID_GAP_BLE;
737 msg.act = ESP_GAP_BLE_UPDATE_WHITELIST_COMPLETE_EVT;
738 param.update_whitelist_cmpl.status = btc_hci_to_esp_status(status);
739 param.update_whitelist_cmpl.wl_opration = wl_opration;
740 ret = btc_transfer_context(&msg, ¶m,
741 sizeof(esp_ble_gap_cb_param_t), NULL);
742
743 if (ret != BT_STATUS_SUCCESS) {
744 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
745 }
746 }
747
btc_set_rand_addr_callback(UINT8 status)748 static void btc_set_rand_addr_callback(UINT8 status)
749 {
750 esp_ble_gap_cb_param_t param;
751 bt_status_t ret;
752 btc_msg_t msg;
753 param.set_rand_addr_cmpl.status = btc_btm_status_to_esp_status(status); //todo status
754 msg.sig = BTC_SIG_API_CB;
755 msg.pid = BTC_PID_GAP_BLE;
756 msg.act = ESP_GAP_BLE_SET_STATIC_RAND_ADDR_EVT;
757 ret = btc_transfer_context(&msg, ¶m,
758 sizeof(esp_ble_gap_cb_param_t), NULL);
759
760 if (ret != BT_STATUS_SUCCESS) {
761 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
762 }
763
764 }
765
btc_set_local_privacy_callback(UINT8 status)766 static void btc_set_local_privacy_callback(UINT8 status)
767 {
768 esp_ble_gap_cb_param_t param;
769 bt_status_t ret;
770 btc_msg_t msg;
771 msg.sig = BTC_SIG_API_CB;
772 msg.pid = BTC_PID_GAP_BLE;
773 msg.act = ESP_GAP_BLE_SET_LOCAL_PRIVACY_COMPLETE_EVT;
774 param.local_privacy_cmpl.status = btc_btm_status_to_esp_status(status);
775 ret = btc_transfer_context(&msg, ¶m,
776 sizeof(esp_ble_gap_cb_param_t), NULL);
777
778 if (ret != BT_STATUS_SUCCESS) {
779 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
780 }
781 }
782
783
784 #if (SMP_INCLUDED == 1)
btc_set_encryption_callback(BD_ADDR bd_addr,tBTA_TRANSPORT transport,tBTA_STATUS enc_status)785 static void btc_set_encryption_callback(BD_ADDR bd_addr, tBTA_TRANSPORT transport, tBTA_STATUS enc_status)
786 {
787 UNUSED(bd_addr);
788 UNUSED(transport);
789 BTC_TRACE_DEBUG("enc_status = %x\n", enc_status);
790 return;
791 }
792 #endif ///SMP_INCLUDED == 1
793
btc_read_ble_rssi_cmpl_callback(void * p_data)794 static void btc_read_ble_rssi_cmpl_callback(void *p_data)
795 {
796 tBTA_RSSI_RESULTS *result = (tBTA_RSSI_RESULTS *)p_data;
797 esp_ble_gap_cb_param_t param;
798 bt_status_t ret;
799 btc_msg_t msg;
800 msg.sig = BTC_SIG_API_CB;
801 msg.pid = BTC_PID_GAP_BLE;
802 msg.act = ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT;
803 param.read_rssi_cmpl.rssi = result->rssi;
804 param.read_rssi_cmpl.status = btc_btm_status_to_esp_status(result->status);
805 memcpy(param.read_rssi_cmpl.remote_addr, result->rem_bda, sizeof(BD_ADDR));
806
807 ret = btc_transfer_context(&msg, ¶m,
808 sizeof(esp_ble_gap_cb_param_t), NULL);
809
810 if (ret != BT_STATUS_SUCCESS) {
811 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
812 }
813 }
814
815 #if (BLE_50_FEATURE_SUPPORT == 1)
btc_ble_5_gap_callback(tBTA_DM_BLE_5_GAP_EVENT event,tBTA_DM_BLE_5_GAP_CB_PARAMS * params)816 static void btc_ble_5_gap_callback(tBTA_DM_BLE_5_GAP_EVENT event,
817 tBTA_DM_BLE_5_GAP_CB_PARAMS *params)
818 {
819 esp_ble_gap_cb_param_t param;
820 bt_status_t ret;
821 btc_msg_t msg;
822 msg.sig = BTC_SIG_API_CB;
823 msg.pid = BTC_PID_GAP_BLE;
824
825 switch(event) {
826 case BTA_DM_BLE_5_GAP_READ_PHY_COMPLETE_EVT: {
827 msg.act = ESP_GAP_BLE_READ_PHY_COMPLETE_EVT;
828 param.read_phy.status = btc_btm_status_to_esp_status(params->read_phy.status);
829 memcpy(param.read_phy.bda, params->read_phy.addr, BD_ADDR_LEN);
830 param.read_phy.tx_phy = params->read_phy.tx_phy;
831 param.read_phy.rx_phy = params->read_phy.rx_phy;
832 break;
833 }
834 case BTA_DM_BLE_5_GAP_SET_PREFERED_DEFAULT_PHY_COMPLETE_EVT: {
835 msg.act = ESP_GAP_BLE_SET_PREFERED_DEFAULT_PHY_COMPLETE_EVT;
836 param.set_perf_def_phy.status = btc_btm_status_to_esp_status(params->set_perf_def_phy.status);
837 break;
838 }
839 case BTA_DM_BLE_5_GAP_SET_PREFERED_PHY_COMPLETE_EVT: {
840 msg.act = ESP_GAP_BLE_SET_PREFERED_PHY_COMPLETE_EVT;
841 param.set_perf_phy.status = btc_btm_status_to_esp_status(params->set_perf_phy.status);
842 break;
843 }
844 case BTA_DM_BLE_5_GAP_EXT_ADV_SET_RAND_ADDR_COMPLETE_EVT:
845 msg.act = ESP_GAP_BLE_EXT_ADV_SET_RAND_ADDR_COMPLETE_EVT;
846 param.ext_adv_set_rand_addr.status = btc_btm_status_to_esp_status(params->set_ext_rand_addr.status);
847 break;
848 case BTA_DM_BLE_5_GAP_EXT_ADV_SET_PARAMS_COMPLETE_EVT: {
849 msg.act = ESP_GAP_BLE_EXT_ADV_SET_PARAMS_COMPLETE_EVT;
850 param.ext_adv_set_rand_addr.status = btc_btm_status_to_esp_status(params->set_params.status);
851 break;
852 }
853 case BTA_DM_BLE_5_GAP_EXT_ADV_DATA_SET_COMPLETE_EVT: {
854 msg.act = ESP_GAP_BLE_EXT_ADV_DATA_SET_COMPLETE_EVT;
855 param.ext_adv_data_set.status = btc_btm_status_to_esp_status(params->adv_data_set.status);
856 break;
857 }
858 case BTA_DM_BLE_5_GAP_EXT_SCAN_RSP_DATA_SET_COMPLETE_EVT: {
859 msg.act = ESP_GAP_BLE_EXT_SCAN_RSP_DATA_SET_COMPLETE_EVT;
860 param.scan_rsp_set.status = btc_btm_status_to_esp_status(params->scan_rsp_data_set.status);
861 break;
862 }
863 case BTA_DM_BLE_5_GAP_EXT_ADV_START_COMPLETE_EVT: {
864 msg.act = ESP_GAP_BLE_EXT_ADV_START_COMPLETE_EVT;
865 param.ext_adv_start.status = btc_btm_status_to_esp_status(params->adv_start.status);
866 break;
867 }
868 case BTA_DM_BLE_5_GAP_EXT_ADV_STOP_COMPLETE_EVT:
869 msg.act = ESP_GAP_BLE_EXT_ADV_STOP_COMPLETE_EVT;
870 param.ext_adv_stop.status = btc_btm_status_to_esp_status(params->adv_start.status);
871 break;
872 case BTA_DM_BLE_5_GAP_EXT_ADV_SET_REMOVE_COMPLETE_EVT:
873 msg.act = ESP_GAP_BLE_EXT_ADV_SET_REMOVE_COMPLETE_EVT;
874 param.ext_adv_remove.status = btc_btm_status_to_esp_status(params->adv_start.status);
875 break;
876 case BTA_DM_BLE_5_GAP_EXT_ADV_SET_CLEAR_COMPLETE_EVT:
877 msg.act = ESP_GAP_BLE_EXT_ADV_SET_CLEAR_COMPLETE_EVT;
878 param.ext_adv_clear.status = btc_btm_status_to_esp_status(params->adv_start.status);
879 break;
880 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_SET_PARAMS_COMPLETE_EVT: {
881 msg.act = ESP_GAP_BLE_PERIODIC_ADV_SET_PARAMS_COMPLETE_EVT;
882 param.peroid_adv_set_params.status = btc_btm_status_to_esp_status(params->per_adv_set_params.status);
883 break;
884 }
885 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_DATA_SET_COMPLETE_EVT: {
886 msg.act = ESP_GAP_BLE_PERIODIC_ADV_DATA_SET_COMPLETE_EVT;
887 param.period_adv_data_set.status = btc_btm_status_to_esp_status(params->per_adv_data_set.status);
888 break;
889 }
890 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_START_COMPLETE_EVT: {
891 msg.act = ESP_GAP_BLE_PERIODIC_ADV_START_COMPLETE_EVT;
892 param.period_adv_start.status = btc_btm_status_to_esp_status(params->per_adv_start.status);
893 break;
894 }
895 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_STOP_COMPLETE_EVT: {
896 msg.act = ESP_GAP_BLE_PERIODIC_ADV_STOP_COMPLETE_EVT;
897 param.period_adv_stop.status = btc_btm_status_to_esp_status(params->per_adv_stop.status);
898 break;
899 }
900 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_CREATE_SYNC_COMPLETE_EVT: {
901 msg.act = ESP_GAP_BLE_PERIODIC_ADV_CREATE_SYNC_COMPLETE_EVT;
902 param.period_adv_create_sync.status = btc_btm_status_to_esp_status(params->per_adv_sync_create.status);
903 break;
904 }
905 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_SYNC_CANCEL_COMPLETE_EVT: {
906 msg.act = ESP_GAP_BLE_PERIODIC_ADV_SYNC_CANCEL_COMPLETE_EVT;
907 param.period_adv_sync_cancel.status = btc_btm_status_to_esp_status(params->per_adv_sync_cancel.status);
908 break;
909 }
910 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_SYNC_TERMINATE_COMPLETE_EVT: {
911 msg.act = ESP_GAP_BLE_PERIODIC_ADV_SYNC_TERMINATE_COMPLETE_EVT;
912 param.period_adv_sync_term.status = btc_btm_status_to_esp_status(params->per_adv_sync_term.status);
913 break;
914 }
915 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_ADD_DEV_COMPLETE_EVT: {
916 msg.act = ESP_GAP_BLE_PERIODIC_ADV_ADD_DEV_COMPLETE_EVT;
917 param.period_adv_add_dev.status = btc_btm_status_to_esp_status(params->per_adv_add_dev.status);
918 break;
919 }
920 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_REMOVE_DEV_COMPLETE_EVT: {
921 msg.act = ESP_GAP_BLE_PERIODIC_ADV_REMOVE_DEV_COMPLETE_EVT;
922 param.period_adv_remove_dev.status = btc_btm_status_to_esp_status(params->per_adv_remove_dev.status);
923 break;
924 }
925 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_CLEAR_DEV_COMPLETE_EVT: {
926 msg.act = ESP_GAP_BLE_PERIODIC_ADV_CLEAR_DEV_COMPLETE_EVT;
927 param.period_adv_clear_dev.status = btc_btm_status_to_esp_status(params->per_adv_clear_dev.status);
928 break;
929 }
930 case BTA_DM_BLE_5_GAP_SET_EXT_SCAN_PARAMS_COMPLETE_EVT: {
931 msg.act = ESP_GAP_BLE_SET_EXT_SCAN_PARAMS_COMPLETE_EVT;
932 param.set_ext_scan_params.status = btc_btm_status_to_esp_status(params->ext_scan.status);
933 break;
934 }
935 case BTA_DM_BLE_5_GAP_EXT_SCAN_START_COMPLETE_EVT: {
936 msg.act = ESP_GAP_BLE_EXT_SCAN_START_COMPLETE_EVT;
937 param.ext_scan_start.status = btc_btm_status_to_esp_status(params->scan_start.status);
938 break;
939 }
940 case BTA_DM_BLE_5_GAP_EXT_SCAN_STOP_COMPLETE_EVT: {
941 msg.act = ESP_GAP_BLE_EXT_SCAN_STOP_COMPLETE_EVT;
942 param.ext_scan_stop.status = btc_btm_status_to_esp_status(params->scan_stop.status);
943 break;
944 }
945 case BTA_DM_BLE_5_GAP_PREFER_EXT_CONN_PARAMS_SET_COMPLETE_EVT: {
946 msg.act = ESP_GAP_BLE_PREFER_EXT_CONN_PARAMS_SET_COMPLETE_EVT;
947 param.ext_conn_params_set.status = btc_btm_status_to_esp_status(params->ext_conn_set_params.status);
948 break;
949 }
950 case BTA_DM_BLE_5_GAP_PHY_UPDATE_COMPLETE_EVT:
951 msg.act = ESP_GAP_BLE_PHY_UPDATE_COMPLETE_EVT;
952 param.phy_update.status = btc_btm_status_to_esp_status(params->phy_update.status);
953 memcpy(param.phy_update.bda, params->phy_update.addr, BD_ADDR_LEN);
954 param.phy_update.tx_phy = params->phy_update.tx_phy;
955 param.phy_update.rx_phy = params->phy_update.rx_phy;
956 break;
957 case BTA_DM_BLE_5_GAP_EXT_ADV_REPORT_EVT:
958 msg.act = ESP_GAP_BLE_EXT_ADV_REPORT_EVT;
959 memcpy(¶m.ext_adv_report.params, ¶ms->ext_adv_report, sizeof(esp_ble_gap_ext_adv_reprot_t));
960 memcpy(param.ext_adv_report.params.adv_data,
961 params->ext_adv_report.adv_data, params->ext_adv_report.adv_data_len);
962 break;
963 case BTA_DM_BLE_5_GAP_SCAN_TIMEOUT_EVT:
964 msg.act = ESP_GAP_BLE_SCAN_TIMEOUT_EVT;
965 break;
966 case BTA_DM_BLE_5_GAP_ADV_TERMINATED_EVT: {
967 param.adv_terminate.status = params->adv_term.status;
968 param.adv_terminate.adv_instance = params->adv_term.adv_handle;
969 param.adv_terminate.conn_idx = params->adv_term.conn_handle;
970 param.adv_terminate.completed_event = params->adv_term.completed_event;
971 msg.act = ESP_GAP_BLE_ADV_TERMINATED_EVT;
972 break;
973 }
974 case BTA_DM_BLE_5_GAP_SCAN_REQ_RECEIVED_EVT: {
975 msg.act = ESP_GAP_BLE_SCAN_REQ_RECEIVED_EVT;
976 param.scan_req_received.adv_instance = params->scan_req.adv_handle;
977 param.scan_req_received.scan_addr_type = params->scan_req.scan_addr_type;
978 memcpy(param.scan_req_received.scan_addr, params->scan_req.scan_addr, sizeof(BD_ADDR));
979 break;
980 }
981 case BTA_DM_BLE_5_GAP_CHANNEL_SELETE_ALGORITHM_EVT: {
982 msg.act = ESP_GAP_BLE_CHANNEL_SELETE_ALGORITHM_EVT;
983 param.channel_sel_alg.conn_handle = params->channel_sel.conn_handle;
984 param.channel_sel_alg.channel_sel_alg = params->channel_sel.channel_sel_alg;
985 break;
986 }
987 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_REPORT_EVT: {
988 msg.act = ESP_GAP_BLE_PERIODIC_ADV_REPORT_EVT;
989 memcpy(¶m.period_adv_report, ¶ms->period_adv_report,
990 sizeof(esp_ble_gap_periodic_adv_report_t));
991 memcpy(param.period_adv_report.params.data, params->period_adv_report.data,
992 params->period_adv_report.data_length);
993 break;
994 }
995 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_SYNC_LOST_EVT: {
996 msg.act = ESP_GAP_BLE_PERIODIC_ADV_SYNC_LOST_EVT;
997 param.periodic_adv_sync_lost.sync_handle = params->sync_lost.sync_handle;
998 break;
999 }
1000 case BTA_DM_BLE_5_GAP_PERIODIC_ADV_SYNC_ESTAB_EVT: {
1001 msg.act = ESP_GAP_BLE_PERIODIC_ADV_SYNC_ESTAB_EVT;
1002 param.periodic_adv_sync_estab.status = btc_btm_status_to_esp_status(params->sync_estab.status);
1003 param.periodic_adv_sync_estab.sync_handle = params->sync_estab.sync_handle;
1004 param.periodic_adv_sync_estab.sid = params->sync_estab.sid;
1005 param.periodic_adv_sync_estab.adv_addr_type = params->sync_estab.adv_addr_type;
1006 memcpy(param.periodic_adv_sync_estab.adv_addr, params->sync_estab.adv_addr,
1007 sizeof(BD_ADDR));
1008 param.periodic_adv_sync_estab.adv_phy = params->sync_estab.adv_phy;
1009 param.periodic_adv_sync_estab.period_adv_interval = params->sync_estab.period_adv_interval;
1010 param.periodic_adv_sync_estab.adv_clk_accuracy = params->sync_estab.adv_clk_accuracy;
1011 break;
1012 }
1013 default:
1014 break;
1015 }
1016
1017 ret = btc_transfer_context(&msg, ¶m,
1018 sizeof(esp_ble_gap_cb_param_t), NULL);
1019
1020 if (ret != BT_STATUS_SUCCESS) {
1021 BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
1022 }
1023 }
1024 #endif // #if (BLE_50_FEATURE_SUPPORT == 1)
btc_get_whitelist_size(uint16_t * length)1025 void btc_get_whitelist_size(uint16_t *length)
1026 {
1027 BTM_BleGetWhiteListSize(length);
1028 return;
1029 }
1030 #if (BLE_42_FEATURE_SUPPORT == 1)
btc_ble_start_scanning(uint32_t duration,tBTA_DM_SEARCH_CBACK * results_cb,tBTA_START_STOP_SCAN_CMPL_CBACK * start_scan_cb)1031 static void btc_ble_start_scanning(uint32_t duration,
1032 tBTA_DM_SEARCH_CBACK *results_cb,
1033 tBTA_START_STOP_SCAN_CMPL_CBACK *start_scan_cb)
1034 {
1035 if ((results_cb != NULL) && (start_scan_cb != NULL)) {
1036 #if SCAN_QUEUE_CONGEST_CHECK
1037 btc_adv_list_refresh();
1038 #endif
1039 //Start scan the device
1040 BTA_DmBleScan(true, duration, results_cb, start_scan_cb);
1041 } else {
1042 BTC_TRACE_ERROR("The start_scan_cb or results_cb invalid\n");
1043 }
1044 }
1045
btc_ble_stop_scanning(tBTA_START_STOP_SCAN_CMPL_CBACK * stop_scan_cb)1046 static void btc_ble_stop_scanning(tBTA_START_STOP_SCAN_CMPL_CBACK *stop_scan_cb)
1047 {
1048 uint8_t duration = 0;
1049 BTA_DmBleScan(false, duration, NULL, stop_scan_cb);
1050 }
1051
1052
btc_ble_stop_advertising(tBTA_START_STOP_ADV_CMPL_CBACK * stop_adv_cb)1053 static void btc_ble_stop_advertising(tBTA_START_STOP_ADV_CMPL_CBACK *stop_adv_cb)
1054 {
1055 bool stop_adv = false;
1056
1057 BTA_DmBleBroadcast(stop_adv, stop_adv_cb);
1058 }
1059 #endif // #if (BLE_42_FEATURE_SUPPORT == 1)
btc_ble_update_conn_params(BD_ADDR bd_addr,uint16_t min_int,uint16_t max_int,uint16_t latency,uint16_t timeout)1060 static void btc_ble_update_conn_params(BD_ADDR bd_addr, uint16_t min_int,
1061 uint16_t max_int, uint16_t latency, uint16_t timeout)
1062 {
1063 if (min_int > max_int) {
1064 min_int = max_int;
1065 }
1066
1067 if (min_int < BTM_BLE_CONN_INT_MIN || max_int > BTM_BLE_CONN_INT_MAX) {
1068 BTC_TRACE_ERROR("Invalid interval value.\n");
1069 }
1070
1071 BTA_DmBleUpdateConnectionParams(bd_addr, min_int, max_int,
1072 latency, timeout);
1073 }
1074
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)1075 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)
1076 {
1077 if (tx_data_length > BTM_BLE_DATA_SIZE_MAX) {
1078 tx_data_length = BTM_BLE_DATA_SIZE_MAX;
1079 } else if (tx_data_length < BTM_BLE_DATA_SIZE_MIN) {
1080 tx_data_length = BTM_BLE_DATA_SIZE_MIN;
1081 }
1082
1083 BTA_DmBleSetDataLength(remote_device, tx_data_length, p_set_pkt_data_cback);
1084 }
1085
btc_ble_config_local_icon(uint16_t icon)1086 static void btc_ble_config_local_icon(uint16_t icon)
1087 {
1088 BTA_DmBleConfigLocalIcon(icon);
1089 }
1090
btc_ble_set_rand_addr(BD_ADDR rand_addr,tBTA_SET_RAND_ADDR_CBACK * p_set_rand_addr_cback)1091 static void btc_ble_set_rand_addr (BD_ADDR rand_addr, tBTA_SET_RAND_ADDR_CBACK *p_set_rand_addr_cback)
1092 {
1093 if (rand_addr != NULL) {
1094 /*
1095 A static address is a 48-bit randomly generated address and shall meet the following requirements:
1096 • The two most significant bits of the address shall be equal to 1
1097 • All bits of the random part of the address shall not be equal to 1
1098 • All bits of the random part of the address shall not be equal to 0
1099 A non-resolvable private address is a 48-bit randomly generated address and shall meet the following requirements:
1100 • The two most significant bits of the address shall be equal to 0
1101 • All bits of the random part of the address shall not be equal to 1
1102 • All bits of the random part of the address shall not be equal to 0
1103 */
1104 BD_ADDR invalid_rand_addr_a, invalid_rand_addr_b;
1105 memset(invalid_rand_addr_a, 0xff, sizeof(BD_ADDR));
1106 memset(invalid_rand_addr_b, 0x00, sizeof(BD_ADDR));
1107
1108 if((rand_addr[0] & BT_STATIC_RAND_ADDR_MASK) == BT_STATIC_RAND_ADDR_MASK) {
1109 invalid_rand_addr_b[0] = invalid_rand_addr_b[0] | BT_STATIC_RAND_ADDR_MASK;
1110 if (memcmp(invalid_rand_addr_a, rand_addr, BD_ADDR_LEN) != 0 && memcmp(invalid_rand_addr_b, rand_addr, BD_ADDR_LEN) != 0) {
1111 BTA_DmSetRandAddress(rand_addr, btc_set_rand_addr_callback);
1112 } else {
1113 btc_set_rand_addr_callback(BTM_INVALID_STATIC_RAND_ADDR);
1114 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");
1115 }
1116 } else if ((rand_addr[0] | BT_NON_RPA_MASK) == BT_NON_RPA_MASK) {
1117 invalid_rand_addr_a[0] = invalid_rand_addr_a[0] & BT_NON_RPA_MASK;
1118 if (memcmp(invalid_rand_addr_a, rand_addr, BD_ADDR_LEN) != 0 && memcmp(invalid_rand_addr_b, rand_addr, BD_ADDR_LEN) != 0) {
1119 BTA_DmSetRandAddress(rand_addr, btc_set_rand_addr_callback);
1120 } else {
1121 btc_set_rand_addr_callback(BTM_INVALID_STATIC_RAND_ADDR);
1122 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");
1123 }
1124 }else {
1125 btc_set_rand_addr_callback(BTM_INVALID_STATIC_RAND_ADDR);
1126 BTC_TRACE_ERROR("Invalid random address type");
1127 }
1128 } else {
1129 btc_set_rand_addr_callback(BTM_INVALID_STATIC_RAND_ADDR);
1130 BTC_TRACE_ERROR("Invalid address, the address value is NULL");
1131 }
1132 }
1133
btc_ble_clear_rand_addr(void)1134 static void btc_ble_clear_rand_addr (void)
1135 {
1136 BTA_DmClearRandAddress();
1137 }
1138
btc_ble_config_local_privacy(bool privacy_enable,tBTA_SET_LOCAL_PRIVACY_CBACK * set_local_privacy_cback)1139 static void btc_ble_config_local_privacy(bool privacy_enable, tBTA_SET_LOCAL_PRIVACY_CBACK *set_local_privacy_cback)
1140 {
1141 BTA_DmBleConfigLocalPrivacy(privacy_enable, set_local_privacy_cback);
1142 }
1143
btc_ble_disconnect(BD_ADDR bd_addr)1144 static void btc_ble_disconnect(BD_ADDR bd_addr)
1145 {
1146 BTA_DmBleDisconnect(bd_addr);
1147 }
1148
btc_gap_ble_set_channels(esp_gap_ble_channels channels)1149 static void btc_gap_ble_set_channels(esp_gap_ble_channels channels)
1150 {
1151 BTA_DmBleSetChannels(channels, btc_gap_ble_set_channels_cmpl_callback);
1152 }
1153
1154
btc_gap_ble_cb_handler(btc_msg_t * msg)1155 void btc_gap_ble_cb_handler(btc_msg_t *msg)
1156 {
1157 esp_ble_gap_cb_param_t *param = (esp_ble_gap_cb_param_t *)msg->arg;
1158
1159 if (msg->act < ESP_GAP_BLE_EVT_MAX) {
1160 btc_gap_ble_cb_to_app(msg->act, param);
1161 } else {
1162 BTC_TRACE_ERROR("%s, unknow msg->act = %d", __func__, msg->act);
1163 }
1164
1165 btc_gap_ble_cb_deep_free(msg);
1166
1167 }
1168
btc_gap_ble_arg_deep_copy(btc_msg_t * msg,void * p_dest,void * p_src)1169 void btc_gap_ble_arg_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src)
1170 {
1171 switch (msg->act) {
1172 #if (BLE_42_FEATURE_SUPPORT == 1)
1173 case BTC_GAP_BLE_ACT_CFG_ADV_DATA: {
1174 btc_ble_gap_args_t *src = (btc_ble_gap_args_t *)p_src;
1175 btc_ble_gap_args_t *dst = (btc_ble_gap_args_t *) p_dest;
1176
1177 if (src->cfg_adv_data.adv_data.p_manufacturer_data) {
1178 dst->cfg_adv_data.adv_data.p_manufacturer_data = osi_malloc(src->cfg_adv_data.adv_data.manufacturer_len);
1179 memcpy(dst->cfg_adv_data.adv_data.p_manufacturer_data, src->cfg_adv_data.adv_data.p_manufacturer_data,
1180 src->cfg_adv_data.adv_data.manufacturer_len);
1181 }
1182
1183 if (src->cfg_adv_data.adv_data.p_service_data) {
1184 dst->cfg_adv_data.adv_data.p_service_data = osi_malloc(src->cfg_adv_data.adv_data.service_data_len);
1185 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);
1186 }
1187
1188 if (src->cfg_adv_data.adv_data.p_service_uuid) {
1189 dst->cfg_adv_data.adv_data.p_service_uuid = osi_malloc(src->cfg_adv_data.adv_data.service_uuid_len);
1190 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);
1191 }
1192 break;
1193 }
1194 case BTC_GAP_BLE_ACT_CFG_ADV_DATA_RAW: {
1195 btc_ble_gap_args_t *src = (btc_ble_gap_args_t *)p_src;
1196 btc_ble_gap_args_t *dst = (btc_ble_gap_args_t *) p_dest;
1197
1198 if (src && src->cfg_adv_data_raw.raw_adv && src->cfg_adv_data_raw.raw_adv_len > 0) {
1199 dst->cfg_adv_data_raw.raw_adv = osi_malloc(src->cfg_adv_data_raw.raw_adv_len);
1200 if (dst->cfg_adv_data_raw.raw_adv) {
1201 memcpy(dst->cfg_adv_data_raw.raw_adv, src->cfg_adv_data_raw.raw_adv, src->cfg_adv_data_raw.raw_adv_len);
1202 }
1203 }
1204 break;
1205 }
1206 case BTC_GAP_BLE_ACT_CFG_SCAN_RSP_DATA_RAW: {
1207 btc_ble_gap_args_t *src = (btc_ble_gap_args_t *)p_src;
1208 btc_ble_gap_args_t *dst = (btc_ble_gap_args_t *) p_dest;
1209
1210 if (src && src->cfg_scan_rsp_data_raw.raw_scan_rsp && src->cfg_scan_rsp_data_raw.raw_scan_rsp_len > 0) {
1211 dst->cfg_scan_rsp_data_raw.raw_scan_rsp = osi_malloc(src->cfg_scan_rsp_data_raw.raw_scan_rsp_len);
1212 if (dst->cfg_scan_rsp_data_raw.raw_scan_rsp) {
1213 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);
1214 }
1215 }
1216 break;
1217 }
1218 #endif // #if (BLE_42_FEATURE_SUPPORT == 1)
1219 case BTC_GAP_BLE_SET_SECURITY_PARAM_EVT: {
1220 btc_ble_gap_args_t *src = (btc_ble_gap_args_t *)p_src;
1221 btc_ble_gap_args_t *dst = (btc_ble_gap_args_t *) p_dest;
1222 uint8_t length = 0;
1223 if (src->set_security_param.value) {
1224 length = dst->set_security_param.len;
1225 dst->set_security_param.value = osi_malloc(length);
1226 if (dst->set_security_param.value != NULL) {
1227 memcpy(dst->set_security_param.value, src->set_security_param.value, length);
1228 } else {
1229 BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act);
1230 }
1231 }
1232 break;
1233 }
1234 case BTC_GAP_BLE_OOB_REQ_REPLY_EVT: {
1235 btc_ble_gap_args_t *src = (btc_ble_gap_args_t *)p_src;
1236 btc_ble_gap_args_t *dst = (btc_ble_gap_args_t *) p_dest;
1237 uint8_t length = 0;
1238 if (src->oob_req_reply.p_value) {
1239 length = dst->oob_req_reply.len;
1240 dst->oob_req_reply.p_value = osi_malloc(length);
1241 if (dst->oob_req_reply.p_value != NULL) {
1242 memcpy(dst->oob_req_reply.p_value, src->oob_req_reply.p_value, length);
1243 } else {
1244 BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act);
1245 }
1246 }
1247 break;
1248 }
1249 #if (BLE_50_FEATURE_SUPPORT == 1)
1250 case BTC_GAP_BLE_CFG_EXT_ADV_DATA_RAW:
1251 case BTC_GAP_BLE_CFG_EXT_SCAN_RSP_DATA_RAW: {
1252 btc_ble_5_gap_args_t *src = (btc_ble_5_gap_args_t *)p_src;
1253 btc_ble_5_gap_args_t *dst = (btc_ble_5_gap_args_t *)p_dest;
1254 uint16_t length = 0;
1255
1256 if (src->ext_adv_cfg_data.data) {
1257 length = src->ext_adv_cfg_data.length;
1258 dst->ext_adv_cfg_data.data = osi_malloc(length);
1259 if (dst->ext_adv_cfg_data.data) {
1260 memcpy(dst->ext_adv_cfg_data.data, src->ext_adv_cfg_data.data, length);
1261 } else {
1262 BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act);
1263 }
1264 }
1265 break;
1266 }
1267 case BTC_GAP_BLE_CFG_PERIODIC_ADV_DATA_RAW: {
1268 btc_ble_5_gap_args_t *src = (btc_ble_5_gap_args_t *)p_src;
1269 btc_ble_5_gap_args_t *dst = (btc_ble_5_gap_args_t *)p_dest;
1270 uint16_t length = 0;
1271
1272 if (src->periodic_adv_cfg_data.data) {
1273 length = src->periodic_adv_cfg_data.len;
1274 dst->periodic_adv_cfg_data.data = osi_malloc(length);
1275 if (dst->periodic_adv_cfg_data.data) {
1276 memcpy(dst->periodic_adv_cfg_data.data, src->periodic_adv_cfg_data.data, length);
1277 } else {
1278 BTC_TRACE_ERROR("%s %d no mem\n",__func__, msg->act);
1279 }
1280 }
1281 break;
1282 }
1283 case BTC_GAP_BLE_EXT_ADV_START: {
1284 btc_ble_5_gap_args_t *src = (btc_ble_5_gap_args_t *)p_src;
1285 btc_ble_5_gap_args_t *dst = (btc_ble_5_gap_args_t *)p_dest;
1286
1287 if (src->ext_adv_start.ext_adv) {
1288 dst->ext_adv_start.ext_adv = osi_malloc(src->ext_adv_start.num_adv*sizeof(esp_ble_gap_ext_adv_t));
1289 if (dst->ext_adv_start.ext_adv) {
1290 memcpy(dst->ext_adv_start.ext_adv, src->ext_adv_start.ext_adv,
1291 src->ext_adv_start.num_adv*sizeof(esp_ble_gap_ext_adv_t));
1292 }
1293 }
1294 break;
1295 }
1296 case BTC_GAP_BLE_EXT_ADV_STOP: {
1297 btc_ble_5_gap_args_t *src = (btc_ble_5_gap_args_t *)p_src;
1298 btc_ble_5_gap_args_t *dst = (btc_ble_5_gap_args_t *)p_dest;
1299
1300 if (src->ext_adv_stop.ext_adv_inst) {
1301 dst->ext_adv_stop.ext_adv_inst = osi_malloc(src->ext_adv_stop.num_adv*sizeof(uint8_t));
1302 if (dst->ext_adv_stop.ext_adv_inst) {
1303 memcpy(dst->ext_adv_stop.ext_adv_inst, src->ext_adv_stop.ext_adv_inst,
1304 src->ext_adv_stop.num_adv * sizeof(uint8_t));
1305 }
1306 }
1307 break;
1308 }
1309 #endif // #if (BLE_50_FEATURE_SUPPORT == 1)
1310 default:
1311 BTC_TRACE_ERROR("Unhandled deep copy %d\n", msg->act);
1312 break;
1313 }
1314 }
1315
btc_gap_ble_cb_deep_copy(btc_msg_t * msg,void * p_dest,void * p_src)1316 void btc_gap_ble_cb_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src)
1317 {
1318 switch (msg->act) {
1319 default:
1320 BTC_TRACE_ERROR("%s, Unhandled deep copy %d\n", __func__, msg->act);
1321 break;
1322 }
1323 }
1324
btc_gap_ble_arg_deep_free(btc_msg_t * msg)1325 void btc_gap_ble_arg_deep_free(btc_msg_t *msg)
1326 {
1327 BTC_TRACE_DEBUG("%s \n", __func__);
1328 switch (msg->act) {
1329 #if (BLE_42_FEATURE_SUPPORT == 1)
1330 case BTC_GAP_BLE_ACT_CFG_ADV_DATA: {
1331 esp_ble_adv_data_t *adv = &((btc_ble_gap_args_t *)msg->arg)->cfg_adv_data.adv_data;
1332 if (adv->p_service_data) {
1333 osi_free(adv->p_service_data);
1334 }
1335
1336 if (adv->p_service_uuid) {
1337 osi_free(adv->p_service_uuid);
1338 }
1339
1340 if (adv->p_manufacturer_data) {
1341 osi_free(adv->p_manufacturer_data);
1342 }
1343 break;
1344 }
1345 case BTC_GAP_BLE_ACT_CFG_ADV_DATA_RAW: {
1346 uint8_t *raw_adv = ((btc_ble_gap_args_t *)msg->arg)->cfg_adv_data_raw.raw_adv;
1347 if (raw_adv) {
1348 osi_free(raw_adv);
1349 }
1350 break;
1351 }
1352 case BTC_GAP_BLE_ACT_CFG_SCAN_RSP_DATA_RAW: {
1353 uint8_t *raw_scan_rsp = ((btc_ble_gap_args_t *)msg->arg)->cfg_scan_rsp_data_raw.raw_scan_rsp;
1354 if (raw_scan_rsp) {
1355 osi_free(raw_scan_rsp);
1356 }
1357 break;
1358 }
1359 #endif // #if (BLE_42_FEATURE_SUPPORT == 1)
1360 case BTC_GAP_BLE_SET_SECURITY_PARAM_EVT: {
1361 uint8_t *value = ((btc_ble_gap_args_t *)msg->arg)->set_security_param.value;
1362 if (value) {
1363 osi_free(value);
1364 }
1365 break;
1366 }
1367 case BTC_GAP_BLE_OOB_REQ_REPLY_EVT: {
1368 uint8_t *value = ((btc_ble_gap_args_t *)msg->arg)->oob_req_reply.p_value;
1369 if (value) {
1370 osi_free(value);
1371 }
1372 break;
1373 }
1374 #if (BLE_50_FEATURE_SUPPORT == 1)
1375 case BTC_GAP_BLE_CFG_EXT_ADV_DATA_RAW:
1376 case BTC_GAP_BLE_CFG_EXT_SCAN_RSP_DATA_RAW: {
1377 uint8_t *value = ((btc_ble_5_gap_args_t *)msg->arg)->ext_adv_cfg_data.data;
1378 if (value) {
1379 osi_free(value);
1380 }
1381 break;
1382 }
1383 case BTC_GAP_BLE_CFG_PERIODIC_ADV_DATA_RAW: {
1384 uint8_t *value = ((btc_ble_5_gap_args_t *)msg->arg)->periodic_adv_cfg_data.data;
1385 if (value) {
1386 osi_free(value);
1387 }
1388 break;
1389 }
1390 case BTC_GAP_BLE_EXT_ADV_START: {
1391 esp_ble_gap_ext_adv_t *value = ((btc_ble_5_gap_args_t *)msg->arg)->ext_adv_start.ext_adv;
1392 if (value) {
1393 osi_free(value);
1394 }
1395 break;
1396 }
1397 case BTC_GAP_BLE_EXT_ADV_STOP: {
1398 uint8_t *value = ((btc_ble_5_gap_args_t *)msg->arg)->ext_adv_stop.ext_adv_inst;
1399 if (value) {
1400 osi_free(value);
1401 }
1402 break;
1403 }
1404 #endif // #if (BLE_50_FEATURE_SUPPORT == 1)
1405 default:
1406 BTC_TRACE_DEBUG("Unhandled deep free %d\n", msg->act);
1407 break;
1408 }
1409 }
1410
btc_gap_ble_cb_deep_free(btc_msg_t * msg)1411 void btc_gap_ble_cb_deep_free(btc_msg_t *msg)
1412 {
1413 BTC_TRACE_DEBUG("%s", __func__);
1414 switch (msg->act) {
1415 default:
1416 BTC_TRACE_DEBUG("Unhandled deep free %d", msg->act);
1417 break;
1418 }
1419 }
1420
btc_gap_ble_call_handler(btc_msg_t * msg)1421 void btc_gap_ble_call_handler(btc_msg_t *msg)
1422 {
1423 btc_ble_gap_args_t *arg = (btc_ble_gap_args_t *)msg->arg;
1424 #if (BLE_50_FEATURE_SUPPORT == 1)
1425 btc_ble_5_gap_args_t *arg_5 = (btc_ble_5_gap_args_t *)msg->arg;
1426 #endif // #if (BLE_50_FEATURE_SUPPORT == 1)
1427
1428 BTC_TRACE_DEBUG("%s act %d\n", __FUNCTION__, msg->act);
1429
1430 switch (msg->act) {
1431 #if (BLE_42_FEATURE_SUPPORT == 1)
1432 case BTC_GAP_BLE_ACT_CFG_ADV_DATA: {
1433 if (arg->cfg_adv_data.adv_data.set_scan_rsp == false) {
1434 btc_ble_set_adv_data(&arg->cfg_adv_data.adv_data, btc_adv_data_callback);
1435 } else {
1436 btc_ble_set_adv_data(&arg->cfg_adv_data.adv_data, btc_scan_rsp_data_callback);
1437 }
1438 break;
1439 }
1440 case BTC_GAP_BLE_ACT_SET_SCAN_PARAM:
1441 btc_ble_set_scan_params(&arg->set_scan_param.scan_params, btc_scan_params_callback);
1442 break;
1443 case BTC_GAP_BLE_ACT_START_SCAN:
1444 btc_ble_start_scanning(arg->start_scan.duration, btc_search_callback, btc_start_scan_callback);
1445 break;
1446 case BTC_GAP_BLE_ACT_STOP_SCAN:
1447 btc_ble_stop_scanning(btc_stop_scan_callback);
1448 break;
1449 case BTC_GAP_BLE_ACT_START_ADV:
1450 btc_ble_start_advertising(&arg->start_adv.adv_params, btc_start_adv_callback);
1451 break;
1452 case BTC_GAP_BLE_ACT_STOP_ADV:
1453 btc_ble_stop_advertising(btc_stop_adv_callback);
1454 break;
1455 #endif // #if (BLE_42_FEATURE_SUPPORT == 1)
1456 case BTC_GAP_BLE_ACT_UPDATE_CONN_PARAM:
1457 btc_ble_update_conn_params(arg->conn_update_params.conn_params.bda,
1458 arg->conn_update_params.conn_params.min_int,
1459 arg->conn_update_params.conn_params.max_int,
1460 arg->conn_update_params.conn_params.latency,
1461 arg->conn_update_params.conn_params.timeout);
1462 break;
1463 case BTC_GAP_BLE_ACT_SET_PKT_DATA_LEN:
1464 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);
1465 break;
1466 case BTC_GAP_BLE_ACT_SET_RAND_ADDRESS: {
1467 BD_ADDR bd_addr;
1468 memcpy(bd_addr, arg->set_rand_addr.rand_addr, sizeof(BD_ADDR));
1469 btc_ble_set_rand_addr(bd_addr, btc_set_rand_addr_callback);
1470 break;
1471 }
1472 case BTC_GAP_BLE_ACT_CLEAR_RAND_ADDRESS: {
1473 btc_ble_clear_rand_addr();
1474 break;
1475 }
1476 case BTC_GAP_BLE_ACT_CONFIG_LOCAL_PRIVACY:
1477 btc_ble_config_local_privacy(arg->cfg_local_privacy.privacy_enable, btc_set_local_privacy_callback);
1478 break;
1479 case BTC_GAP_BLE_ACT_CONFIG_LOCAL_ICON:
1480 btc_ble_config_local_icon(arg->cfg_local_icon.icon);
1481 break;
1482 case BTC_GAP_BLE_ACT_UPDATE_WHITE_LIST:
1483 BTA_DmUpdateWhiteList(arg->update_white_list.add_remove, arg->update_white_list.remote_bda, arg->update_white_list.wl_addr_type, btc_add_whitelist_complete_callback);
1484 break;
1485 case BTC_GAP_BLE_ACT_CLEAR_WHITE_LIST:
1486 BTA_DmClearWhiteList();
1487 break;
1488 case BTC_GAP_BLE_ACT_READ_RSSI:
1489 BTA_DmReadRSSI(arg->read_rssi.remote_addr, BTA_TRANSPORT_LE, btc_read_ble_rssi_cmpl_callback);
1490 break;
1491 #if (BLE_42_FEATURE_SUPPORT == 1)
1492 case BTC_GAP_BLE_ACT_SET_CONN_PARAMS:
1493 BTA_DmSetBlePrefConnParams(arg->set_conn_params.bd_addr, arg->set_conn_params.min_conn_int,
1494 arg->set_conn_params.max_conn_int, arg->set_conn_params.slave_latency,
1495 arg->set_conn_params.supervision_tout);
1496 break;
1497 #endif // #if (BLE_42_FEATURE_SUPPORT == 1)
1498 case BTC_GAP_BLE_ACT_SET_DEV_NAME:
1499 BTA_DmSetDeviceName(arg->set_dev_name.device_name);
1500 break;
1501 #if (BLE_42_FEATURE_SUPPORT == 1)
1502 case BTC_GAP_BLE_ACT_CFG_ADV_DATA_RAW:
1503 btc_ble_set_adv_data_raw(arg->cfg_adv_data_raw.raw_adv,
1504 arg->cfg_adv_data_raw.raw_adv_len,
1505 btc_adv_data_raw_callback);
1506 break;
1507 case BTC_GAP_BLE_ACT_CFG_SCAN_RSP_DATA_RAW:
1508 btc_ble_set_scan_rsp_data_raw(arg->cfg_scan_rsp_data_raw.raw_scan_rsp,
1509 arg->cfg_scan_rsp_data_raw.raw_scan_rsp_len,
1510 btc_scan_rsp_data_raw_callback);
1511 break;
1512 case BTC_GAP_BLE_UPDATE_DUPLICATE_SCAN_EXCEPTIONAL_LIST:
1513 btc_ble_update_duplicate_exceptional_list(arg->update_duplicate_exceptional_list.subcode,
1514 arg->update_duplicate_exceptional_list.info_type,
1515 arg->update_duplicate_exceptional_list.device_info,
1516 btc_update_duplicate_exceptional_list_callback);
1517 break;
1518 #endif // #if (BLE_42_FEATURE_SUPPORT == 1)
1519 #if (SMP_INCLUDED == 1)
1520 case BTC_GAP_BLE_SET_ENCRYPTION_EVT: {
1521 BD_ADDR bd_addr;
1522 memcpy(bd_addr, arg->set_encryption.bd_addr, sizeof(BD_ADDR));
1523 BTA_DmSetEncryption(bd_addr, BT_TRANSPORT_LE, btc_set_encryption_callback,
1524 (tBTA_DM_BLE_SEC_ACT)arg->set_encryption.sec_act);
1525 break;
1526 }
1527 case BTC_GAP_BLE_SET_SECURITY_PARAM_EVT: {
1528 uint8_t *value = arg->set_security_param.value;
1529 switch(arg->set_security_param.param_type) {
1530 case ESP_BLE_SM_PASSKEY:
1531 break;
1532 case ESP_BLE_SM_AUTHEN_REQ_MODE: {
1533 uint8_t authen_req = 0;
1534 STREAM_TO_UINT8(authen_req, value);
1535 bta_dm_co_ble_set_auth_req(authen_req);
1536 break;
1537 }
1538 case ESP_BLE_SM_IOCAP_MODE: {
1539 uint8_t iocap = 0;
1540 STREAM_TO_UINT8(iocap, value);
1541 bta_dm_co_ble_set_io_cap(iocap);
1542 break;
1543 }
1544 case ESP_BLE_SM_SET_INIT_KEY: {
1545 uint8_t init_key = 0;
1546 STREAM_TO_UINT8(init_key, value);
1547 bta_dm_co_ble_set_init_key_req(init_key);
1548 break;
1549 }
1550 case ESP_BLE_SM_SET_RSP_KEY: {
1551 uint8_t rsp_key = 0;
1552 STREAM_TO_UINT8(rsp_key, value);
1553 bta_dm_co_ble_set_rsp_key_req(rsp_key);
1554 break;
1555 }
1556 case ESP_BLE_SM_MAX_KEY_SIZE: {
1557 uint8_t key_size = 0;
1558 STREAM_TO_UINT8(key_size, value);
1559 bta_dm_co_ble_set_max_key_size(key_size);
1560 break;
1561 }
1562 case ESP_BLE_SM_MIN_KEY_SIZE: {
1563 uint8_t key_size = 0;
1564 STREAM_TO_UINT8(key_size, value);
1565 bta_dm_co_ble_set_min_key_size(key_size);
1566 break;
1567 }
1568 case ESP_BLE_SM_SET_STATIC_PASSKEY: {
1569 uint32_t passkey = 0;
1570 for(uint8_t i = 0; i < arg->set_security_param.len; i++)
1571 {
1572 passkey += (((uint8_t *)value)[i]<<(8*i));
1573 }
1574 BTA_DmBleSetStaticPasskey(true, passkey);
1575 break;
1576 }
1577 case ESP_BLE_SM_CLEAR_STATIC_PASSKEY: {
1578 BTA_DmBleSetStaticPasskey(false, 0);
1579 break;
1580 }
1581 case ESP_BLE_SM_ONLY_ACCEPT_SPECIFIED_SEC_AUTH: {
1582 uint8_t enable = 0;
1583 STREAM_TO_UINT8(enable, value);
1584 bta_dm_co_ble_set_accept_auth_enable(enable);
1585 break;
1586 }
1587 case ESP_BLE_SM_OOB_SUPPORT: {
1588 uint8_t enable = 0;
1589 STREAM_TO_UINT8(enable, value);
1590 bta_dm_co_ble_oob_support(enable);
1591 break;
1592 }
1593 case ESP_BLE_APP_ENC_KEY_SIZE: {
1594 uint8_t key_size = 0;
1595 STREAM_TO_UINT8(key_size, value);
1596 bta_dm_co_ble_set_appl_enc_key_size(key_size);
1597 break;
1598 }
1599 default:
1600 break;
1601 }
1602 break;
1603 }
1604 case BTC_GAP_BLE_SECURITY_RSP_EVT: {
1605 BD_ADDR bd_addr;
1606 tBTA_DM_BLE_SEC_GRANT res = arg->sec_rsp.accept ? BTA_DM_SEC_GRANTED : BTA_DM_SEC_PAIR_NOT_SPT;
1607 memcpy(bd_addr, arg->sec_rsp.bd_addr, sizeof(BD_ADDR));
1608 BTA_DmBleSecurityGrant(bd_addr, res);
1609 break;
1610 }
1611 case BTC_GAP_BLE_PASSKEY_REPLY_EVT: {
1612 BD_ADDR bd_addr;
1613 memcpy(bd_addr, arg->enc_passkey_replay.bd_addr, sizeof(BD_ADDR));
1614 BTA_DmBlePasskeyReply(bd_addr, arg->enc_passkey_replay.accept, arg->enc_passkey_replay.passkey);
1615 break;
1616 }
1617 case BTC_GAP_BLE_CONFIRM_REPLY_EVT: {
1618 BD_ADDR bd_addr;
1619 memcpy(bd_addr, arg->enc_comfirm_replay.bd_addr, sizeof(BD_ADDR));
1620 BTA_DmBleConfirmReply(bd_addr, arg->enc_comfirm_replay.accept);
1621 break;
1622 }
1623 case BTC_GAP_BLE_REMOVE_BOND_DEV_EVT: {
1624 BD_ADDR bd_addr;
1625 memcpy(bd_addr, arg->remove_bond_device.bd_addr, sizeof(BD_ADDR));
1626 BTA_DmRemoveDevice(bd_addr, BT_TRANSPORT_LE);
1627 break;
1628 }
1629 case BTC_GAP_BLE_OOB_REQ_REPLY_EVT:
1630 BTA_DmOobReply(arg->oob_req_reply.bd_addr, arg->oob_req_reply.len, arg->oob_req_reply.p_value);
1631 break;
1632 #endif ///SMP_INCLUDED == 1
1633 case BTC_GAP_BLE_DISCONNECT_EVT:
1634 btc_ble_disconnect(arg->disconnect.remote_device);
1635 break;
1636 case BTC_GAP_BLE_SET_AFH_CHANNELS:
1637 btc_gap_ble_set_channels(arg->set_channels.channels);
1638 break;
1639 #if (BLE_50_FEATURE_SUPPORT == 1)
1640 case BTC_GAP_BLE_READ_PHY:
1641 BTC_TRACE_DEBUG("BTC_GAP_BLE_READ_PHY");
1642 BTA_DmBleGapReadPHY(arg_5->read_phy.bd_addr);
1643 break;
1644 case BTC_GAP_BLE_SET_PREFERED_DEF_PHY:
1645 BTC_TRACE_DEBUG("BTC_GAP_BLE_SET_PREFERED_DEF_PHY");
1646 BTA_DmBleGapSetPreferedDefaultPHY(arg_5->set_perf_def_phy.tx_phy_mask,
1647 arg_5->set_perf_def_phy.rx_phy_mask);
1648 break;
1649 case BTC_GAP_BLE_SET_DEF_PHY:
1650 BTC_TRACE_DEBUG("BTC_GAP_BLE_SET_DEF_PHY");
1651 BTA_DmBleGapSetPreferedPHY(arg_5->set_def_phy.bd_addr,
1652 arg_5->set_def_phy.all_phys_mask,
1653 arg_5->set_def_phy.tx_phy_mask,
1654 arg_5->set_def_phy.rx_phy_mask,
1655 arg_5->set_def_phy.phy_options);
1656 break;
1657 case BTC_GAP_BLE_SET_EXT_ADV_RAND_ADDR:
1658 BTA_DmBleGapExtAdvSetRandaddr(arg_5->ext_adv_set_rand_addr.instance, arg_5->ext_adv_set_rand_addr.rand_addr);
1659 break;
1660 case BTC_GAP_BLE_SET_EXT_ADV_PARAMS: {
1661 tBTA_DM_BLE_GAP_EXT_ADV_PARAMS params = {0};
1662 params.type = arg_5->ext_adv_set_params.params.type;
1663 params.interval_min = arg_5->ext_adv_set_params.params.interval_min;
1664 params.interval_max = arg_5->ext_adv_set_params.params.interval_max;
1665 params.channel_map = arg_5->ext_adv_set_params.params.channel_map;
1666 params.own_addr_type = arg_5->ext_adv_set_params.params.own_addr_type;
1667 params.peer_addr_type = arg_5->ext_adv_set_params.params.peer_addr_type;
1668 params.filter_policy = arg_5->ext_adv_set_params.params.filter_policy;
1669 params.tx_power = arg_5->ext_adv_set_params.params.tx_power;
1670 params.primary_phy = arg_5->ext_adv_set_params.params.primary_phy;
1671 params.max_skip = arg_5->ext_adv_set_params.params.max_skip;
1672 params.secondary_phy = arg_5->ext_adv_set_params.params.secondary_phy;
1673 params.sid = arg_5->ext_adv_set_params.params.sid;
1674 params.scan_req_notif = arg_5->ext_adv_set_params.params.scan_req_notif;
1675
1676 memcpy(params.peer_addr, arg_5->ext_adv_set_params.params.peer_addr, sizeof(BD_ADDR));
1677
1678 BTC_TRACE_DEBUG("BTC_GAP_BLE_SET_EXT_ADV_PARAMS");
1679 BTA_DmBleGapExtAdvSetParams(arg_5->ext_adv_set_params.instance,
1680 (const tBTA_DM_BLE_GAP_EXT_ADV_PARAMS *)¶ms);
1681 break;
1682 }
1683 case BTC_GAP_BLE_CFG_EXT_ADV_DATA_RAW:
1684 BTC_TRACE_DEBUG("BTC_GAP_BLE_CFG_EXT_ADV_DATA_RAW");
1685 BTA_DmBleGapConfigExtAdvDataRaw(0, arg_5->ext_adv_cfg_data.instance,
1686 arg_5->ext_adv_cfg_data.length,
1687 (const UINT8 *)arg_5->ext_adv_cfg_data.data);
1688 break;
1689 case BTC_GAP_BLE_CFG_EXT_SCAN_RSP_DATA_RAW:
1690 BTC_TRACE_DEBUG("BTC_GAP_BLE_CFG_EXT_SCAN_RSP_DATA_RAW");
1691 BTA_DmBleGapConfigExtAdvDataRaw(1, arg_5->ext_adv_cfg_data.instance,
1692 arg_5->ext_adv_cfg_data.length,
1693 (const UINT8 *)arg_5->ext_adv_cfg_data.data);
1694 break;
1695 case BTC_GAP_BLE_EXT_ADV_START: {
1696 BTC_TRACE_DEBUG("BTC_GAP_BLE_EXT_ADV_START");
1697 for (int k = 0; k < arg_5->ext_adv_start.num_adv; k++) {
1698 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,
1699 arg_5->ext_adv_start.ext_adv[k].duration, k, arg_5->ext_adv_start.ext_adv[k].max_events);
1700 }
1701 BTA_DmBleGapExtAdvEnable(1, arg_5->ext_adv_start.num_adv,
1702 (tBTA_DM_BLE_EXT_ADV *)arg_5->ext_adv_start.ext_adv);
1703 break;
1704 }
1705 case BTC_GAP_BLE_EXT_ADV_STOP: {
1706 BTC_TRACE_DEBUG("BTC_GAP_BLE_EXT_ADV_STOP");
1707 uint8_t num_adv = arg_5->ext_adv_stop.num_adv;
1708 if(num_adv > 0) {
1709 tBTA_DM_BLE_EXT_ADV *ext_adv = osi_malloc(num_adv * sizeof(esp_ble_gap_ext_adv_t));
1710 if(ext_adv) {
1711 for (uint8_t i = 0; i < num_adv; i++) {
1712 ext_adv[i].instance = arg_5->ext_adv_stop.ext_adv_inst[i];
1713 ext_adv[i].duration = 0;
1714 ext_adv[i].max_events = 0;
1715 }
1716 BTA_DmBleGapExtAdvEnable(0, num_adv, ext_adv);
1717 osi_free(ext_adv);
1718 } else {
1719 BTC_TRACE_ERROR("%s no mem\n", __func__);
1720 }
1721 } else {
1722 BTA_DmBleGapExtAdvEnable(0, 0, NULL);
1723 }
1724 break;
1725 }
1726 case BTC_GAP_BLE_EXT_ADV_SET_REMOVE:
1727 BTA_DmBleGapExtAdvSetRemove(arg_5->ext_adv_set_remove.instance);
1728 break;
1729 case BTC_GAP_BLE_EXT_ADV_SET_CLEAR:
1730 BTA_DmBleGapExtAdvSetClear();
1731 break;
1732 case BTC_GAP_BLE_SET_PERIODIC_ADV_PARAMS: {
1733 tBTA_DM_BLE_Periodic_Adv_Params params = {0};
1734 params.interval_min = arg_5->peridic_adv_set_params.params.interval_min;
1735 params.interval_max = arg_5->peridic_adv_set_params.params.interval_max;
1736 params.properties = arg_5->peridic_adv_set_params.params.properties;
1737 BTC_TRACE_DEBUG("BTC_GAP_BLE_SET_PERIODIC_ADV_PARAMS");
1738 BTA_DmBleGapPeriodicAdvSetParams(arg_5->peridic_adv_set_params.instance,
1739 ¶ms);
1740 break;
1741 }
1742 case BTC_GAP_BLE_CFG_PERIODIC_ADV_DATA_RAW:
1743 BTC_TRACE_DEBUG("BTC_GAP_BLE_CFG_PERIODIC_ADV_DATA_RAW");
1744 BTA_DmBleGapPeriodicAdvCfgDataRaw(arg_5->periodic_adv_cfg_data.instance,
1745 arg_5->periodic_adv_cfg_data.len,
1746 (const UINT8 *)arg_5->periodic_adv_cfg_data.data);
1747 break;
1748 case BTC_GAP_BLE_PERIODIC_ADV_START:
1749 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_ADV_START");
1750 BTA_DmBleGapPeriodicAdvEnable(1, arg_5->periodic_adv_start.instance);
1751 break;
1752 case BTC_GAP_BLE_PERIODIC_ADV_STOP:
1753 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_ADV_STOP");
1754 BTA_DmBleGapPeriodicAdvEnable(0, arg_5->periodic_adv_stop.instance);
1755 break;
1756 case BTC_GAP_BLE_PERIODIC_ADV_CREATE_SYNC: {
1757 tBTA_DM_BLE_Periodic_Sync_Params params = {0};
1758 params.filter_policy = arg_5->periodic_adv_create_sync.params.filter_policy;
1759 params.sid = arg_5->periodic_adv_create_sync.params.sid;
1760 params.addr_type = arg_5->periodic_adv_create_sync.params.addr_type;
1761 params.skip = arg_5->periodic_adv_create_sync.params.skip;
1762 params.sync_timeout = arg_5->periodic_adv_create_sync.params.sync_timeout;
1763
1764 memcpy(params.addr, arg_5->periodic_adv_create_sync.params.addr, sizeof(BD_ADDR));
1765 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_ADV_CREATE_SYNC");
1766 BTA_DmBleGapPeriodicAdvCreateSync(¶ms);
1767 break;
1768 }
1769 case BTC_GAP_BLE_PERIODIC_ADV_SYNC_CANCEL:
1770 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_ADV_SYNC_CANCEL");
1771 BTA_DmBleGapPeriodicAdvSyncCancel();
1772 break;
1773 case BTC_GAP_BLE_PERIODIC_ADV_SYNC_TERMINATE:
1774 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_ADV_SYNC_TERMINATE");
1775 BTA_DmBleGapPeriodicAdvSyncTerm(arg_5->periodic_adv_sync_term.sync_handle);
1776 break;
1777 case BTC_GAP_BLE_PERIODIC_ADV_ADD_DEV_TO_LIST:
1778 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_ADV_ADD_DEV_TO_LIST");
1779 BTA_DmBleGapPeriodicAdvAddDevToList(arg_5->periodic_adv_add_dev.addr_type,
1780 arg_5->periodic_adv_add_dev.addr,
1781 arg_5->periodic_adv_add_dev.sid);
1782 break;
1783 case BTC_GAP_BLE_PERIODIC_REMOVE_ADD_DEV_FROM_LIST:
1784 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_REMOVE_ADD_DEV_FROM_LIST");
1785 BTA_DmBleGapPeriodicAdvRemoveDevFromList(arg_5->periodic_adv_remove_dev.addr_type,
1786 arg_5->periodic_adv_remove_dev.addr,
1787 arg_5->periodic_adv_remove_dev.sid);
1788 break;
1789 case BTC_GAP_BLE_PERIODIC_CLEAR_DEV:
1790 BTC_TRACE_DEBUG("BTC_GAP_BLE_PERIODIC_CLEAR_DEV");
1791 BTA_DmBleGapPeriodicAdvClearDev();
1792 break;
1793 case BTC_GAP_BLE_SET_EXT_SCAN_PARAMS: {
1794 tBTA_DM_BLE_EXT_SCAN_PARAMS params = {0};
1795 params.own_addr_type = arg_5->set_ext_scan_params.params.own_addr_type;
1796 params.filter_policy = arg_5->set_ext_scan_params.params.filter_policy;
1797 params.scan_duplicate = arg_5->set_ext_scan_params.params.scan_duplicate;
1798 params.cfg_mask = arg_5->set_ext_scan_params.params.cfg_mask;
1799 if (params.cfg_mask & BTA_DM_BLE_GAP_EXT_SCAN_UNCODE_MASK) {
1800 params.uncoded_cfg.scan_type = arg_5->set_ext_scan_params.params.uncoded_cfg.scan_type;
1801 params.uncoded_cfg.scan_interval = arg_5->set_ext_scan_params.params.uncoded_cfg.scan_interval;
1802 params.uncoded_cfg.scan_window = arg_5->set_ext_scan_params.params.uncoded_cfg.scan_window;
1803 }
1804
1805 if (params.cfg_mask & BTA_DM_BLE_GAP_EXT_SCAN_CODE_MASK) {
1806 params.coded_cfg.scan_type = arg_5->set_ext_scan_params.params.coded_cfg.scan_type;
1807 params.coded_cfg.scan_interval = arg_5->set_ext_scan_params.params.coded_cfg.scan_interval;
1808 params.coded_cfg.scan_window = arg_5->set_ext_scan_params.params.coded_cfg.scan_window;
1809 }
1810
1811 BTC_TRACE_DEBUG("BTC_GAP_BLE_SET_EXT_SCAN_PARAMS");
1812 BTA_DmBleGapSetExtScanParams(¶ms);
1813 break;
1814 }
1815 case BTC_GAP_BLE_START_EXT_SCAN:
1816 BTC_TRACE_DEBUG("BTC_GAP_BLE_START_EXT_SCAN");
1817 BTA_DmBleGapExtScan(1, arg_5->start_ext_scan.duration, arg_5->start_ext_scan.period);
1818 break;
1819 case BTC_GAP_BLE_STOP_EXT_SCAN:
1820 BTC_TRACE_DEBUG("BTC_GAP_BLE_STOP_EXT_SCAN");
1821 BTA_DmBleGapExtScan(0, 0, 0);
1822 break;
1823 case BTC_GAP_BLE_SET_EXT_PEFER_CONNET_PARAMS:
1824 BTC_TRACE_DEBUG("BTC_GAP_BLE_SET_EXT_PEFER_CONNET_PARAMS");
1825 BTA_DmBleGapPreferExtConnectParamsSet(arg_5->set_ext_conn_params.addr,
1826 arg_5->set_ext_conn_params.phy_mask,
1827 (const tBTA_DM_BLE_CONN_PARAMS *)&arg_5->set_ext_conn_params.phy_1m_conn_params,
1828 (const tBTA_DM_BLE_CONN_PARAMS *)&arg_5->set_ext_conn_params.phy_2m_conn_params,
1829 (const tBTA_DM_BLE_CONN_PARAMS *)&arg_5->set_ext_conn_params.phy_coded_conn_params);
1830 break;
1831 #endif // #if (BLE_50_FEATURE_SUPPORT == 1)
1832 default:
1833 break;
1834 }
1835
1836 btc_gap_ble_arg_deep_free(msg);
1837 }
1838
1839 //register connection parameter update callback
btc_gap_callback_init(void)1840 void btc_gap_callback_init(void)
1841 {
1842 BTM_BleRegiseterConnParamCallback(btc_update_conn_param_callback);
1843 #if (BLE_50_FEATURE_SUPPORT == 1)
1844 BTM_BleGapRegisterCallback(btc_ble_5_gap_callback);
1845 #endif // #if (BLE_50_FEATURE_SUPPORT == 1)
1846 }
1847
btc_gap_ble_deinit(void)1848 void btc_gap_ble_deinit(void)
1849 {
1850 #if (BLE_42_FEATURE_SUPPORT == 1)
1851 btc_cleanup_adv_data(&gl_bta_adv_data);
1852 btc_cleanup_adv_data(&gl_bta_scan_rsp_data);
1853 #endif // #if (BLE_42_FEATURE_SUPPORT == 1)
1854 }
1855
1856 #if SCAN_QUEUE_CONGEST_CHECK
btc_adv_list_free(void * data)1857 void btc_adv_list_free(void *data)
1858 {
1859 osi_free(data);
1860 }
1861
btc_adv_list_init(void)1862 void btc_adv_list_init(void)
1863 {
1864 osi_mutex_new(&adv_list_lock);
1865 adv_filter_list = list_new(btc_adv_list_free);
1866 }
1867
btc_adv_list_deinit(void)1868 void btc_adv_list_deinit(void)
1869 {
1870 osi_mutex_free(&adv_list_lock);
1871 if(adv_filter_list) {
1872 list_free(adv_filter_list);
1873 adv_filter_list = NULL;
1874 }
1875 }
btc_adv_list_add_packet(void * data)1876 void btc_adv_list_add_packet(void * data)
1877 {
1878 if(!data) {
1879 BTC_TRACE_ERROR("%s data is NULL", __func__);
1880 return;
1881 }
1882 btc_adv_list_lock();
1883 list_prepend(adv_filter_list, data);
1884 btc_adv_list_unlock();
1885 }
1886
btc_get_adv_list_length(void)1887 uint32_t btc_get_adv_list_length(void)
1888 {
1889 if(!adv_filter_list) {
1890 BTC_TRACE_ERROR("%s adv_filter_list is NULL", __func__);
1891 return 0;
1892 }
1893 btc_adv_list_lock();
1894 size_t length = list_length(adv_filter_list);
1895 btc_adv_list_unlock();
1896
1897 return length;
1898 }
1899
btc_adv_list_refresh(void)1900 void btc_adv_list_refresh(void)
1901 {
1902 if(!adv_filter_list) {
1903 BTC_TRACE_ERROR("%s adv_filter_list is NULL", __func__);
1904 return ;
1905 }
1906 btc_adv_list_lock();
1907 list_clear(adv_filter_list);
1908 btc_adv_list_unlock();
1909 }
1910
btc_check_adv_list(uint8_t * addr,uint8_t addr_type)1911 bool btc_check_adv_list(uint8_t * addr, uint8_t addr_type)
1912 {
1913 bool found = false;
1914 if(!adv_filter_list || !addr) {
1915 BTC_TRACE_ERROR("%s adv_filter_list is NULL", __func__);
1916 return found;
1917 }
1918
1919 btc_adv_list_lock();
1920 for (const list_node_t *node = list_begin(adv_filter_list); node != list_end(adv_filter_list); node = list_next(node)) {
1921 btc_adv_packet_t *packet = (btc_adv_packet_t *)list_node(node);
1922 if(!bdcmp(addr, packet->addr) && packet->addr_type == addr_type) {
1923 found = true;
1924 break;
1925 }
1926 }
1927 btc_adv_list_unlock();
1928 if(!found) {
1929 btc_adv_packet_t *adv_packet = osi_malloc(sizeof(btc_adv_packet_t));
1930 if(adv_packet) {
1931 adv_packet->addr_type = addr_type;
1932 bdcpy(adv_packet->addr, addr);
1933 btc_adv_list_add_packet(adv_packet);
1934 } else {
1935 BTC_TRACE_ERROR("%s adv_packet malloc failed", __func__);
1936 }
1937 }
1938 return found;
1939 }
1940
btc_adv_list_lock(void)1941 void btc_adv_list_lock(void)
1942 {
1943 osi_mutex_lock(&adv_list_lock, OSI_MUTEX_MAX_TIMEOUT);
1944 }
1945
btc_adv_list_unlock(void)1946 void btc_adv_list_unlock(void)
1947 {
1948 osi_mutex_unlock(&adv_list_lock);
1949 }
1950 #endif
1951 #endif ///BLE_INCLUDED == 1
1952