1 /*
2 * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 #include "btm_int.h"
8 #include "stack/hcimsgs.h"
9 #include "osi/allocator.h"
10 #include "device/controller.h"
11 #include <string.h>
12 #include "l2c_int.h"
13 #if (BLE_50_FEATURE_SUPPORT == TRUE)
14 #define SET_BIT(t, n) (t |= 1UL << (n))
15 tBTM_BLE_EXTENDED_CB extend_adv_cb;
16
17 tBTM_BLE_5_HCI_CBACK ble_5_hci_cb;
18
19 #define INVALID_VALUE 0XFF
20 extern BOOLEAN BTM_GetLocalResolvablePrivateAddr(BD_ADDR bda);
21 extern void BTM_UpdateAddrInfor(uint8_t addr_type, BD_ADDR bda);
22 extern void BTM_BleSetStaticAddr(BD_ADDR rand_addr);
23 extern uint32_t BTM_BleUpdateOwnType(uint8_t *own_bda_type, tBTM_START_ADV_CMPL_CBACK *cb);
24 static tBTM_STATUS btm_ble_ext_adv_params_validate(tBTM_BLE_GAP_EXT_ADV_PARAMS *params);
25 static tBTM_STATUS btm_ble_ext_adv_set_data_validate(UINT8 instance, UINT16 len, UINT8 *data);
26
27 typedef struct {
28 uint16_t ter_con_handle;
29 bool invalid;
30 bool enabled;
31 UINT8 instance;
32 int duration;
33 int max_events;
34 uint8_t retry_count;
35 } tBTM_EXT_ADV_RECORD;
36
37 tBTM_EXT_ADV_RECORD adv_record[MAX_BLE_ADV_INSTANCE] = {0};
38 extern void btm_ble_inter_set(bool extble_inter);
39
40 #if !UC_BT_STACK_NO_LOG
btm_ble_hci_status_to_str(tHCI_STATUS status)41 static const char *btm_ble_hci_status_to_str(tHCI_STATUS status)
42 {
43 switch(status) {
44 case HCI_SUCCESS:
45 return "HCI_SUCCESS";
46 case HCI_ERR_ILLEGAL_COMMAND:
47 return "HCI_ERR_ILLEGAL_COMMAND";
48 case HCI_ERR_NO_CONNECTION:
49 return "HCI_ERR_NO_CONNECTION";
50 case HCI_ERR_HW_FAILURE:
51 return "HCI_ERR_HW_FAILURE";
52 case HCI_ERR_PAGE_TIMEOUT:
53 return "HCI_ERR_PAGE_TIMEOUT";
54 case HCI_ERR_AUTH_FAILURE:
55 return "HCI_ERR_AUTH_FAILURE";
56 case HCI_ERR_KEY_MISSING:
57 return "HCI_ERR_KEY_MISSING";
58 case HCI_ERR_MEMORY_FULL:
59 return "HCI_ERR_MEMORY_FULL";
60 case HCI_ERR_CONNECTION_TOUT:
61 return "HCI_ERR_CONNECTION_TOUT";
62 case HCI_ERR_MAX_NUM_OF_CONNECTIONS:
63 return "HCI_ERR_MAX_NUM_OF_CONNECTIONS";
64 case HCI_ERR_MAX_NUM_OF_SCOS:
65 return "HCI_ERR_MAX_NUM_OF_SCOS";
66 case HCI_ERR_CONNECTION_EXISTS:
67 return "HCI_ERR_CONNECTION_EXISTS";
68 case HCI_ERR_COMMAND_DISALLOWED:
69 return "HCI_ERR_COMMAND_DISALLOWED";
70 case HCI_ERR_HOST_REJECT_RESOURCES:
71 return "HCI_ERR_HOST_REJECT_RESOURCES";
72 case HCI_ERR_HOST_REJECT_SECURITY:
73 return "HCI_ERR_HOST_REJECT_SECURITY";
74 case HCI_ERR_HOST_REJECT_DEVICE:
75 return "HCI_ERR_HOST_REJECT_DEVICE";
76 case HCI_ERR_HOST_TIMEOUT:
77 return "HCI_ERR_HOST_TIMEOUT";
78 case HCI_ERR_UNSUPPORTED_VALUE:
79 return "HCI_ERR_UNSUPPORTED_VALUE";
80 case HCI_ERR_ILLEGAL_PARAMETER_FMT:
81 return "HCI_ERR_ILLEGAL_PARAMETER_FMT";
82 case HCI_ERR_PEER_USER:
83 return "HCI_ERR_PEER_USER";
84 case HCI_ERR_PEER_LOW_RESOURCES:
85 return "HCI_ERR_PEER_LOW_RESOURCES";
86 case HCI_ERR_PEER_POWER_OFF:
87 return "HCI_ERR_PEER_POWER_OFF";
88 case HCI_ERR_CONN_CAUSE_LOCAL_HOST:
89 return "HCI_ERR_CONN_CAUSE_LOCAL_HOST";
90 case HCI_ERR_REPEATED_ATTEMPTS:
91 return "HCI_ERR_REPEATED_ATTEMPTS";
92 case HCI_ERR_PAIRING_NOT_ALLOWED:
93 return "HCI_ERR_PAIRING_NOT_ALLOWED";
94 case HCI_ERR_UNKNOWN_LMP_PDU:
95 return "HCI_ERR_UNKNOWN_LMP_PDU";
96 case HCI_ERR_UNSUPPORTED_REM_FEATURE:
97 return "HCI_ERR_UNSUPPORTED_REM_FEATURE";
98 case HCI_ERR_SCO_OFFSET_REJECTED:
99 return "HCI_ERR_SCO_OFFSET_REJECTED";
100 case HCI_ERR_SCO_INTERVAL_REJECTED:
101 return "HCI_ERR_SCO_INTERVAL_REJECTED";
102 case HCI_ERR_SCO_AIR_MODE:
103 return "HCI_ERR_SCO_AIR_MODE";
104 case HCI_ERR_INVALID_LMP_PARAM:
105 return "HCI_ERR_INVALID_LMP_PARAM";
106 case HCI_ERR_UNSPECIFIED:
107 return "HCI_ERR_UNSPECIFIED";
108 case HCI_ERR_UNSUPPORTED_LMP_PARAMETERS:
109 return "HCI_ERR_UNSUPPORTED_LMP_PARAMETERS";
110 case HCI_ERR_ROLE_CHANGE_NOT_ALLOWED:
111 return "HCI_ERR_ROLE_CHANGE_NOT_ALLOWED";
112 case HCI_ERR_LMP_RESPONSE_TIMEOUT:
113 return "HCI_ERR_LMP_RESPONSE_TIMEOUT";
114 case HCI_ERR_LMP_ERR_TRANS_COLLISION:
115 return "HCI_ERR_LMP_ERR_TRANS_COLLISION";
116 case HCI_ERR_LMP_PDU_NOT_ALLOWED:
117 return "HCI_ERR_LMP_PDU_NOT_ALLOWED";
118 case HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE:
119 return "HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE";
120 case HCI_ERR_UNIT_KEY_USED:
121 return "HCI_ERR_UNIT_KEY_USED";
122 case HCI_ERR_QOS_NOT_SUPPORTED:
123 return "HCI_ERR_QOS_NOT_SUPPORTED";
124 case HCI_ERR_INSTANT_PASSED:
125 return "HCI_ERR_INSTANT_PASSED";
126 case HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED:
127 return "HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED";
128 case HCI_ERR_DIFF_TRANSACTION_COLLISION:
129 return "HCI_ERR_DIFF_TRANSACTION_COLLISION";
130 case HCI_ERR_UNDEFINED_0x2B:
131 return "HCI_ERR_UNDEFINED_0x2B";
132 case HCI_ERR_QOS_UNACCEPTABLE_PARAM:
133 return "HCI_ERR_QOS_UNACCEPTABLE_PARAM";
134 case HCI_ERR_QOS_REJECTED:
135 return "HCI_ERR_QOS_REJECTED";
136 case HCI_ERR_CHAN_CLASSIF_NOT_SUPPORTED:
137 return "HCI_ERR_CHAN_CLASSIF_NOT_SUPPORTED";
138 case HCI_ERR_INSUFFCIENT_SECURITY:
139 return "HCI_ERR_INSUFFCIENT_SECURITY";
140 case HCI_ERR_PARAM_OUT_OF_RANGE:
141 return "HCI_ERR_PARAM_OUT_OF_RANGE";
142 case HCI_ERR_UNDEFINED_0x31:
143 return "HCI_ERR_UNDEFINED_0x31";
144 case HCI_ERR_ROLE_SWITCH_PENDING:
145 return "HCI_ERR_ROLE_SWITCH_PENDING";
146 case HCI_ERR_UNDEFINED_0x33:
147 return "HCI_ERR_UNDEFINED_0x33";
148 case HCI_ERR_RESERVED_SLOT_VIOLATION:
149 return "HCI_ERR_RESERVED_SLOT_VIOLATION";
150 case HCI_ERR_ROLE_SWITCH_FAILED:
151 return "HCI_ERR_ROLE_SWITCH_FAILED";
152 case HCI_ERR_INQ_RSP_DATA_TOO_LARGE:
153 return "HCI_ERR_INQ_RSP_DATA_TOO_LARGE";
154 case HCI_ERR_SIMPLE_PAIRING_NOT_SUPPORTED:
155 return "HCI_ERR_SIMPLE_PAIRING_NOT_SUPPORTED";
156 case HCI_ERR_HOST_BUSY_PAIRING:
157 return "HCI_ERR_HOST_BUSY_PAIRING";
158 case HCI_ERR_REJ_NO_SUITABLE_CHANNEL:
159 return "HCI_ERR_REJ_NO_SUITABLE_CHANNEL";
160 case HCI_ERR_CONTROLLER_BUSY:
161 return "HCI_ERR_CONTROLLER_BUSY";
162 case HCI_ERR_UNACCEPT_CONN_INTERVAL:
163 return "HCI_ERR_UNACCEPT_CONN_INTERVAL";
164 case HCI_ERR_DIRECTED_ADVERTISING_TIMEOUT:
165 return "HCI_ERR_DIRECTED_ADVERTISING_TIMEOUT";
166 case HCI_ERR_CONN_TOUT_DUE_TO_MIC_FAILURE:
167 return "HCI_ERR_CONN_TOUT_DUE_TO_MIC_FAILURE";
168 case HCI_ERR_CONN_FAILED_ESTABLISHMENT:
169 return "HCI_ERR_CONN_FAILED_ESTABLISHMENT";
170 case HCI_ERR_MAC_CONNECTION_FAILED:
171 return "HCI_ERR_MAC_CONNECTION_FAILED";
172 case HCI_ERR_LT_ADDR_ALREADY_IN_USE:
173 return "HCI_ERR_LT_ADDR_ALREADY_IN_USE";
174 case HCI_ERR_LT_ADDR_NOT_ALLOCATED:
175 return "HCI_ERR_LT_ADDR_NOT_ALLOCATED";
176 case HCI_ERR_CLB_NOT_ENABLED:
177 return "HCI_ERR_CLB_NOT_ENABLED";
178 case HCI_ERR_MAX_ERR:
179 return "HCI_ERR_MAX_ERR";
180 case HCI_ERR_ESP_VENDOR_FAIL:
181 return "HCI_ERR_ESP_VENDOR_FAIL";
182 case HCI_HINT_TO_RECREATE_AMP_PHYS_LINK:
183 return "HCI_HINT_TO_RECREATE_AMP_PHYS_LINK";
184 default:
185 return "Invalid HCI status code.";
186 }
187
188 return NULL;
189 }
190 #endif /* !UC_BT_STACK_NO_LOG */
191
btm_ble_extendadvcb_init(void)192 void btm_ble_extendadvcb_init(void)
193 {
194 memset(&extend_adv_cb, 0, sizeof(tBTM_BLE_EXTENDED_CB));
195 }
196
btm_ble_advrecod_init(void)197 void btm_ble_advrecod_init(void)
198 {
199 memset(&adv_record[0], 0, sizeof(tBTM_EXT_ADV_RECORD)*MAX_BLE_ADV_INSTANCE);
200 }
201
BTM_BleGapRegisterCallback(tBTM_BLE_5_HCI_CBACK cb)202 void BTM_BleGapRegisterCallback(tBTM_BLE_5_HCI_CBACK cb)
203 {
204 if (cb) {
205 ble_5_hci_cb = cb;
206 } else {
207 BTM_TRACE_ERROR("%s, register fail, the cb function is NULL.", __func__);
208 }
209 }
210
BTM_ExtBleCallbackTrigger(tBTM_BLE_5_GAP_EVENT event,tBTM_BLE_5_GAP_CB_PARAMS * params)211 void BTM_ExtBleCallbackTrigger(tBTM_BLE_5_GAP_EVENT event, tBTM_BLE_5_GAP_CB_PARAMS *params)
212 {
213 if(params && params->status == BTM_SUCCESS) {
214 btm_ble_inter_set(true);
215 }
216 if (ble_5_hci_cb) {
217 ble_5_hci_cb(event, params);
218 }
219 }
220
BTM_BleReadPhy(BD_ADDR bd_addr,UINT8 * tx_phy,UINT8 * rx_phy)221 tBTM_STATUS BTM_BleReadPhy(BD_ADDR bd_addr, UINT8 *tx_phy, UINT8 *rx_phy)
222 {
223 tL2C_LCB *p_lcb = l2cu_find_lcb_by_bd_addr(bd_addr, BT_TRANSPORT_LE);
224 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
225
226 if (!tx_phy || !rx_phy || !p_lcb) {
227 cb_params.read_phy.status = BTM_ILLEGAL_VALUE;
228 memcpy(cb_params.read_phy.addr, bd_addr, BD_ADDR_LEN);
229
230 if (ble_5_hci_cb) {
231 ble_5_hci_cb(BTM_BLE_5_GAP_READ_PHY_COMPLETE_EVT, &cb_params);
232 }
233 BTM_TRACE_ERROR("%s, invalid parameters", __func__);
234 return BTM_ILLEGAL_VALUE;
235 }
236
237 btsnd_hcic_ble_read_phy(p_lcb->handle);
238
239 return BTM_SUCCESS;
240 }
241
BTM_BleSetPreferDefaultPhy(UINT8 tx_phy_mask,UINT8 rx_phy_mask)242 tBTM_STATUS BTM_BleSetPreferDefaultPhy(UINT8 tx_phy_mask, UINT8 rx_phy_mask)
243 {
244 UINT8 all_phys = 0;
245 tBTM_STATUS status = BTM_SUCCESS;
246 tHCI_STATUS err = HCI_SUCCESS;
247 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
248
249 if ((err = btsnd_hcic_ble_set_prefered_default_phy(all_phys, tx_phy_mask, rx_phy_mask)) != HCI_SUCCESS) {
250 BTM_TRACE_ERROR("%s, fail to send the hci command, the error code = %s(0x%x)",
251 __func__, btm_ble_hci_status_to_str(err), err);
252 status = BTM_HCI_ERROR | err;
253 }
254
255 cb_params.set_perf_def_phy.status = status;
256
257 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_SET_PREFERED_DEFAULT_PHY_COMPLETE_EVT, &cb_params);
258
259 return status;
260
261 }
262
BTM_BleSetPreferPhy(BD_ADDR bd_addr,UINT8 all_phys,UINT8 tx_phy_mask,UINT8 rx_phy_mask,UINT16 phy_options)263 tBTM_STATUS BTM_BleSetPreferPhy(BD_ADDR bd_addr, UINT8 all_phys, UINT8 tx_phy_mask,
264 UINT8 rx_phy_mask, UINT16 phy_options)
265 {
266 tL2C_LCB *p_lcb = l2cu_find_lcb_by_bd_addr(bd_addr, BT_TRANSPORT_LE);
267 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
268
269 if (!p_lcb) {
270 cb_params.status = BTM_ILLEGAL_VALUE;
271 if (ble_5_hci_cb) {
272 ble_5_hci_cb(BTM_BLE_5_GAP_SET_PREFERED_PHY_COMPLETE_EVT, &cb_params);
273 }
274 BTM_TRACE_ERROR("%s, invalid parameters", __func__);
275 return BTM_ILLEGAL_VALUE;
276 }
277
278
279
280 if (!btsnd_hcic_ble_set_phy(p_lcb->handle, all_phys, tx_phy_mask, rx_phy_mask, phy_options)) {
281 cb_params.status = BTM_ILLEGAL_VALUE;
282 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_SET_PREFERED_PHY_COMPLETE_EVT, &cb_params);
283 }
284
285
286 return BTM_SUCCESS;
287 }
288
BTM_BleSetExtendedAdvRandaddr(UINT8 instance,BD_ADDR rand_addr)289 tBTM_STATUS BTM_BleSetExtendedAdvRandaddr(UINT8 instance, BD_ADDR rand_addr)
290 {
291 tBTM_STATUS status = BTM_SUCCESS;
292 tHCI_STATUS err = HCI_SUCCESS;
293 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
294
295 if (instance >= MAX_BLE_ADV_INSTANCE || rand_addr == NULL) {
296 status = BTM_ILLEGAL_VALUE;
297 goto end;
298 }
299
300 /*
301 A static address is a 48-bit randomly generated address and shall meet the following requirements:
302 • The two most significant bits of the address shall be equal to 1
303 • All bits of the random part of the address shall not be equal to 1
304 • All bits of the random part of the address shall not be equal to 0
305 */
306 BD_ADDR invalid_rand_addr_a, invalid_rand_addr_b;
307 memset(invalid_rand_addr_a, 0xff, sizeof(BD_ADDR));
308 memset(invalid_rand_addr_b, 0x00, sizeof(BD_ADDR));
309 if((rand_addr[0] & BT_STATIC_RAND_ADDR_MASK) == BT_STATIC_RAND_ADDR_MASK) {
310 invalid_rand_addr_b[0] = invalid_rand_addr_b[0] | BT_STATIC_RAND_ADDR_MASK;
311 if (memcmp(invalid_rand_addr_a, rand_addr, BD_ADDR_LEN) == 0
312 || memcmp(invalid_rand_addr_b, rand_addr, BD_ADDR_LEN) == 0) {
313 status = BTM_ILLEGAL_VALUE;
314 goto end;
315 }
316 } else if ((rand_addr[0] | BT_NON_RPA_MASK) == BT_NON_RPA_MASK) {
317 invalid_rand_addr_a[0] = invalid_rand_addr_a[0] & BT_NON_RPA_MASK;
318 if (memcmp(invalid_rand_addr_a, rand_addr, BD_ADDR_LEN) == 0
319 || memcmp(invalid_rand_addr_b, rand_addr, BD_ADDR_LEN) == 0) {
320 status = BTM_ILLEGAL_VALUE;
321 goto end;
322 }
323 } else {
324 BTM_TRACE_ERROR("%s invalid random address", __func__);
325 status = BTM_ILLEGAL_VALUE;
326 goto end;
327 }
328
329 // set random address
330 if((err = btsnd_hcic_ble_set_extend_rand_address(instance, rand_addr)) != HCI_SUCCESS) {
331 BTM_TRACE_ERROR("%s, fail to send the hci command, the error code = %s(0x%x)",
332 __func__, btm_ble_hci_status_to_str(err), err);
333 status = BTM_HCI_ERROR | err;
334 } else {
335 // set random address success, update address info
336 if(extend_adv_cb.inst[instance].configured && extend_adv_cb.inst[instance].connetable) {
337 BTM_BleSetStaticAddr(rand_addr);
338 BTM_UpdateAddrInfor(BLE_ADDR_RANDOM, rand_addr);
339 }
340 }
341
342 end:
343 cb_params.set_ext_rand_addr.status = status;
344 cb_params.set_ext_rand_addr.instance = instance;
345 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_EXT_ADV_SET_RAND_ADDR_COMPLETE_EVT, &cb_params);
346
347 return status;
348
349 }
BTM_BleSetExtendedAdvParams(UINT8 instance,tBTM_BLE_GAP_EXT_ADV_PARAMS * params)350 tBTM_STATUS BTM_BleSetExtendedAdvParams(UINT8 instance, tBTM_BLE_GAP_EXT_ADV_PARAMS *params)
351 {
352 tBTM_STATUS status = BTM_SUCCESS;
353 tHCI_STATUS err = HCI_SUCCESS;
354 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
355 bool use_rpa_addr = false;
356 BD_ADDR rand_addr;
357
358 if (instance >= MAX_BLE_ADV_INSTANCE) {
359 status = BTM_ILLEGAL_VALUE;
360 BTM_TRACE_ERROR("%s invalid instance %d", __func__, instance);
361 goto end;
362 }
363
364 if ((status = btm_ble_ext_adv_params_validate(params)) != BTM_SUCCESS) {
365 BTM_TRACE_ERROR("%s, invalid extend adv params.", __func__);
366 }
367
368 if (params->type & BTM_BLE_GAP_SET_EXT_ADV_PROP_CONNECTABLE) {
369 extend_adv_cb.inst[instance].connetable = true;
370 } else {
371 extend_adv_cb.inst[instance].connetable = false;
372 }
373
374 if (params->type & BTM_BLE_GAP_SET_EXT_ADV_PROP_SCANNABLE) {
375 extend_adv_cb.inst[instance].scannable = true;
376 } else {
377 extend_adv_cb.inst[instance].scannable = false;
378 }
379
380 if (params->type & BTM_BLE_GAP_SET_EXT_ADV_PROP_LEGACY) {
381 extend_adv_cb.inst[instance].legacy_pdu = true;
382 } else {
383 extend_adv_cb.inst[instance].legacy_pdu = false;
384 }
385
386 #if (CONTROLLER_RPA_LIST_ENABLE == FALSE)
387 // if own_addr_type == BLE_ADDR_PUBLIC_ID or BLE_ADDR_RANDOM_ID,
388 if((params->own_addr_type == BLE_ADDR_PUBLIC_ID || params->own_addr_type == BLE_ADDR_RANDOM_ID) && BTM_GetLocalResolvablePrivateAddr(rand_addr)) {
389 params->own_addr_type = BLE_ADDR_RANDOM;
390 use_rpa_addr = true;
391 } else if(params->own_addr_type == BLE_ADDR_PUBLIC_ID){
392 params->own_addr_type = BLE_ADDR_PUBLIC;
393 } else if (params->own_addr_type == BLE_ADDR_RANDOM_ID) {
394 params->own_addr_type = BLE_ADDR_RANDOM;
395 }
396 #else
397 btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = params->own_addr_type;
398 #endif
399
400 if ((err = btsnd_hcic_ble_set_ext_adv_params(instance, params->type, params->interval_min, params->interval_max,
401 params->channel_map, params->own_addr_type, params->peer_addr_type,
402 params->peer_addr, params->filter_policy, params->tx_power,
403 params->primary_phy, params->max_skip,
404 params->secondary_phy, params->sid, params->scan_req_notif)) != HCI_SUCCESS) {
405 BTM_TRACE_ERROR("LE EA SetParams: cmd err=0x%x", err);
406 status = BTM_HCI_ERROR | err;
407 goto end;
408 }
409
410 extend_adv_cb.inst[instance].configured = true;
411
412 end:
413 if(use_rpa_addr) {
414 // update RPA address
415 if((err = btsnd_hcic_ble_set_extend_rand_address(instance, rand_addr)) != HCI_SUCCESS) {
416 BTM_TRACE_ERROR("LE EA SetParams: cmd err=0x%x", err);
417 status = BTM_HCI_ERROR | err;
418 } else {
419 // set addr success, update address info
420 BTM_UpdateAddrInfor(BLE_ADDR_RANDOM, rand_addr);
421 }
422 }
423 cb_params.set_params.status = status;
424 cb_params.set_params.instance = instance;
425 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_EXT_ADV_SET_PARAMS_COMPLETE_EVT, &cb_params);
426
427 return status;
428 }
429
BTM_BleConfigExtendedAdvDataRaw(BOOLEAN is_scan_rsp,UINT8 instance,UINT16 len,UINT8 * data)430 tBTM_STATUS BTM_BleConfigExtendedAdvDataRaw(BOOLEAN is_scan_rsp, UINT8 instance, UINT16 len, UINT8 *data)
431 {
432 tBTM_STATUS status = BTM_SUCCESS;
433 tHCI_STATUS err = HCI_SUCCESS;
434 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
435 UINT16 rem_len = len;
436 UINT8 operation = 0;
437 UINT16 data_offset = 0;
438
439
440 if ((status = btm_ble_ext_adv_set_data_validate(instance, len, data)) != BTM_SUCCESS) {
441 BTM_TRACE_ERROR("%s, invalid extend adv data.", __func__);
442 goto end;
443 }
444
445 do {
446 UINT8 send_data_len = (rem_len > BTM_BLE_EXT_ADV_DATA_LEN_MAX) ? BTM_BLE_EXT_ADV_DATA_LEN_MAX : rem_len;
447 if (len <= BTM_BLE_EXT_ADV_DATA_LEN_MAX) {
448 operation = BTM_BLE_ADV_DATA_OP_COMPLETE;
449 } else {
450 if (rem_len == len) {
451 operation = BTM_BLE_ADV_DATA_OP_FIRST_FRAG;
452 } else if (rem_len <= BTM_BLE_EXT_ADV_DATA_LEN_MAX) {
453 operation = BTM_BLE_ADV_DATA_OP_LAST_FRAG;
454 } else {
455 operation = BTM_BLE_ADV_DATA_OP_INTERMEDIATE_FRAG;
456 }
457 }
458 if (!is_scan_rsp) {
459 if ((err = btsnd_hcic_ble_set_ext_adv_data(instance, operation, 0, send_data_len, &data[data_offset])) != HCI_SUCCESS) {
460 BTM_TRACE_ERROR("LE EA SetAdvData: cmd err=0x%x", err);
461 status = BTM_HCI_ERROR | err;
462 break;
463 }
464 } else {
465 if ((err = btsnd_hcic_ble_set_ext_adv_scan_rsp_data(instance, operation, 0, send_data_len, &data[data_offset])) != HCI_SUCCESS) {
466 BTM_TRACE_ERROR("LE EA SetScanRspData: cmd err=0x%x", err);
467 status = BTM_HCI_ERROR | err;
468 break;
469 }
470 }
471
472 rem_len -= send_data_len;
473 data_offset += send_data_len;
474 } while (rem_len);
475
476 end:
477 if (is_scan_rsp) {
478 cb_params.scan_rsp_data_set.status = status;
479 cb_params.scan_rsp_data_set.instance = instance;
480 } else {
481 cb_params.adv_data_set.status = status;
482 cb_params.adv_data_set.instance = instance;
483 }
484
485 BTM_ExtBleCallbackTrigger(is_scan_rsp ? BTM_BLE_5_GAP_EXT_SCAN_RSP_DATA_SET_COMPLETE_EVT : BTM_BLE_5_GAP_EXT_ADV_DATA_SET_COMPLETE_EVT, &cb_params);
486
487 return status;
488 }
489
BTM_BleStartExtAdv(BOOLEAN enable,UINT8 num,tBTM_BLE_EXT_ADV * ext_adv)490 tBTM_STATUS BTM_BleStartExtAdv(BOOLEAN enable, UINT8 num, tBTM_BLE_EXT_ADV *ext_adv)
491 {
492 tBTM_STATUS status = BTM_SUCCESS;
493 tHCI_STATUS err = HCI_SUCCESS;
494 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
495
496 UINT8 *instance = NULL;
497 UINT16 *duration = NULL;
498 UINT8 *max_events = NULL;
499
500 // when enable = true, ext_adv = NULL or num = 0, goto end
501 if ((!ext_adv || num == 0) && enable) {
502 status = BTM_ILLEGAL_VALUE;
503 BTM_TRACE_ERROR("%s invalid parameters", __func__);
504 goto end;
505 }
506
507 if (num != 0 && ext_adv != NULL) {
508 instance = osi_malloc(num);
509 duration = osi_malloc(num*sizeof(UINT16));
510 max_events = osi_malloc(num*sizeof(UINT8));
511
512 if (!instance || !duration || !max_events) {
513 status = BTM_NO_RESOURCES;
514 BTM_TRACE_ERROR("%s invalid parameters", __func__);
515 goto end;
516 }
517
518 for (int i = 0; i < num; i++) {
519 instance[i] = ext_adv[i].instance;
520 duration[i] = ext_adv[i].duration;
521 max_events[i] = ext_adv[i].max_events;
522 }
523
524 if ((err = btsnd_hcic_ble_ext_adv_enable(enable, num, instance,
525 duration, max_events)) != HCI_SUCCESS) {
526 BTM_TRACE_ERROR("LE EA En=%d: cmd err=0x%x", enable, err);
527 status = BTM_HCI_ERROR | err;
528 }
529
530 osi_free(instance);
531 osi_free(duration);
532 osi_free(max_events);
533 } else {
534 // enable = false, num == 0 or ext_adv = NULL
535
536 if ((err = btsnd_hcic_ble_ext_adv_enable(enable, num, NULL, NULL, NULL)) != HCI_SUCCESS) {
537 BTM_TRACE_ERROR("LE EA En=%d: cmd err=0x%x", enable, err);
538 status = BTM_HCI_ERROR | err;
539 }
540 goto end;
541 }
542
543
544
545 end:
546
547 if (!enable && status == BTM_SUCCESS) {
548 // disable all ext adv
549 if(num == 0) {
550
551 for (uint8_t i = 0; i < MAX_BLE_ADV_INSTANCE; i++)
552 {
553 adv_record[i].invalid = false;
554 adv_record[i].enabled = false;
555 adv_record[i].instance = INVALID_VALUE;
556 adv_record[i].duration = INVALID_VALUE;
557 adv_record[i].max_events = INVALID_VALUE;
558 adv_record[i].retry_count = 0;
559 }
560 } else {
561 for (uint8_t i = 0; i < num; i++)
562 {
563 uint8_t index = ext_adv[i].instance;
564 adv_record[index].invalid = false;
565 adv_record[index].enabled = false;
566 adv_record[index].instance = INVALID_VALUE;
567 adv_record[index].duration = INVALID_VALUE;
568 adv_record[index].max_events = INVALID_VALUE;
569 adv_record[index].retry_count = 0;
570 }
571 }
572 }
573 // start extend adv success, save the adv information
574 if(enable && status == BTM_SUCCESS) {
575 for (uint8_t i = 0; i < num; i++)
576 {
577 uint8_t index = ext_adv[i].instance;
578 adv_record[index].invalid = true;
579 adv_record[index].enabled = true;
580 adv_record[index].instance = ext_adv[i].instance;
581 adv_record[index].duration = ext_adv[i].duration;
582 adv_record[index].max_events = ext_adv[i].max_events;
583 adv_record[index].retry_count = 0;
584 }
585 }
586
587 cb_params.adv_start.status = status;
588 cb_params.adv_start.instance_num = num;
589 for (uint8_t i = 0; i < num; i++) {
590 cb_params.adv_start.instance[i] = ext_adv[i].instance;
591 }
592
593 BTM_ExtBleCallbackTrigger(enable ? BTM_BLE_5_GAP_EXT_ADV_START_COMPLETE_EVT : BTM_BLE_5_GAP_EXT_ADV_STOP_COMPLETE_EVT, &cb_params);
594
595 return status;
596 }
597
BTM_BleStartExtAdvRestart(uint8_t con_handle)598 tBTM_STATUS BTM_BleStartExtAdvRestart(uint8_t con_handle)
599 {
600 tBTM_BLE_EXT_ADV ext_adv;
601 uint8_t index = INVALID_VALUE;
602 for (uint8_t i = 0; i < MAX_BLE_ADV_INSTANCE; i++)
603 {
604 if(adv_record[i].ter_con_handle == con_handle) {
605 index = i;
606 break;
607 }
608 }
609
610 if((index >= MAX_BLE_ADV_INSTANCE) || (!adv_record[index].invalid)) {
611 return BTM_WRONG_MODE;
612 }
613
614 adv_record[index].retry_count ++;
615 BTM_TRACE_DEBUG("remote device did not receive aux connect response, retatrt the extend adv to reconnect, adv handle %d con_handle %d\n", index, con_handle);
616 ext_adv.instance = adv_record[index].instance;
617 ext_adv.duration = adv_record[index].duration;
618 ext_adv.max_events = adv_record[index].max_events;
619 return BTM_BleStartExtAdv(true, 1, &ext_adv);
620 }
621
BTM_BleExtAdvSetRemove(UINT8 instance)622 tBTM_STATUS BTM_BleExtAdvSetRemove(UINT8 instance)
623 {
624 tBTM_STATUS status = BTM_SUCCESS;
625 tHCI_STATUS err = HCI_SUCCESS;
626 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
627
628 if (instance >= MAX_BLE_ADV_INSTANCE) {
629 status = BTM_ILLEGAL_VALUE;
630 BTM_TRACE_ERROR("%s invalid instance %d", __func__, instance);
631 goto end;
632 }
633
634 if ((err = btsnd_hcic_ble_remove_adv_set(instance)) != HCI_SUCCESS) {
635 BTM_TRACE_ERROR("LE EAS Rm: cmd err=0x%x", err);
636 status = BTM_HCI_ERROR | err;
637 } else {
638 extend_adv_cb.inst[instance].configured = false;
639 extend_adv_cb.inst[instance].legacy_pdu = false;
640 extend_adv_cb.inst[instance].directed = false;
641 extend_adv_cb.inst[instance].scannable = false;
642 extend_adv_cb.inst[instance].connetable = false;
643 }
644
645 end:
646
647 cb_params.adv_start.status = status;
648 cb_params.adv_start.instance_num = 1;
649 cb_params.adv_start.instance[0] = instance;
650
651 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_EXT_ADV_SET_REMOVE_COMPLETE_EVT, &cb_params);
652
653 return status;
654 }
655
BTM_BleExtAdvSetClear(void)656 tBTM_STATUS BTM_BleExtAdvSetClear(void)
657 {
658 tBTM_STATUS status = BTM_SUCCESS;
659 tHCI_STATUS err = HCI_SUCCESS;
660 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
661
662 if ((err = btsnd_hcic_ble_clear_adv_set()) != HCI_SUCCESS) {
663 BTM_TRACE_ERROR("LE EAS Clr: cmd err=0x%x", err);
664 status = BTM_HCI_ERROR | err;
665 } else {
666 for (uint8_t i = 0; i < MAX_BLE_ADV_INSTANCE; i++) {
667 extend_adv_cb.inst[i].configured = false;
668 extend_adv_cb.inst[i].legacy_pdu = false;
669 extend_adv_cb.inst[i].directed = false;
670 extend_adv_cb.inst[i].scannable = false;
671 extend_adv_cb.inst[i].connetable = false;
672 }
673 }
674
675 cb_params.adv_start.status = status;
676
677 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_EXT_ADV_SET_CLEAR_COMPLETE_EVT, &cb_params);
678
679 return status;
680 }
681
BTM_BlePeriodicAdvSetParams(UINT8 instance,tBTM_BLE_Periodic_Adv_Params * params)682 tBTM_STATUS BTM_BlePeriodicAdvSetParams(UINT8 instance, tBTM_BLE_Periodic_Adv_Params *params)
683 {
684 tBTM_STATUS status = BTM_SUCCESS;
685 tHCI_STATUS err = HCI_SUCCESS;
686 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
687 //ext_adv_flag = true;
688
689 if (instance >= MAX_BLE_ADV_INSTANCE) {
690 status = BTM_ILLEGAL_VALUE;
691 BTM_TRACE_ERROR("%s invalid instance %d", __func__, instance);
692 goto end;
693 }
694
695 if (!extend_adv_cb.inst[instance].configured ||
696 extend_adv_cb.inst[instance].scannable ||
697 extend_adv_cb.inst[instance].connetable ||
698 extend_adv_cb.inst[instance].legacy_pdu) {
699 BTM_TRACE_ERROR("%s, instance = %d, Before set the periodic adv parameters, please configure the the \
700 extend adv to nonscannable and nonconnectable first, and it shouldn't include the legacy bit.", __func__, instance);
701 status = BTM_ILLEGAL_VALUE;
702 goto end;
703 }
704
705 if ((err= btsnd_hcic_ble_set_periodic_adv_params(instance, params->interval_min,
706 params->interval_max, params->properties)) != HCI_SUCCESS) {
707 BTM_TRACE_ERROR("LE PA SetParams: cmd err=0x%x", err);
708 status = BTM_HCI_ERROR | err;
709 }
710
711 end:
712
713 cb_params.per_adv_set_params.status = status;
714 cb_params.per_adv_set_params.instance = instance;
715
716 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PERIODIC_ADV_SET_PARAMS_COMPLETE_EVT, &cb_params);
717
718 return status;
719 }
720
BTM_BlePeriodicAdvCfgDataRaw(UINT8 instance,UINT16 len,UINT8 * data,BOOLEAN only_update_did)721 tBTM_STATUS BTM_BlePeriodicAdvCfgDataRaw(UINT8 instance, UINT16 len, UINT8 *data,BOOLEAN only_update_did)
722 {
723 tBTM_STATUS status = BTM_SUCCESS;
724 tHCI_STATUS err = HCI_SUCCESS;
725 uint16_t rem_len = len;
726 UINT8 operation = 0;
727 UINT16 data_offset = 0;
728 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
729 if (only_update_did)
730 {
731 len = 0;
732 data = NULL;
733 rem_len = 0;
734 operation = BTM_BLE_ADV_DATA_OP_UNCHANGED_DATA;
735 }
736
737 if ((status = btm_ble_ext_adv_set_data_validate(instance, len, data)) != BTM_SUCCESS) {
738 BTM_TRACE_ERROR("%s, invalid extend adv data.", __func__);
739 goto end;
740 }
741
742 do {
743 UINT8 send_data_len = (rem_len > BTM_BLE_PERIODIC_ADV_DATA_LEN_MAX) ? BTM_BLE_PERIODIC_ADV_DATA_LEN_MAX : rem_len;
744
745 if (len <= BTM_BLE_PERIODIC_ADV_DATA_LEN_MAX) {
746 if (!only_update_did) {
747 operation = BTM_BLE_ADV_DATA_OP_COMPLETE;
748 }
749 } else {
750 if (rem_len == len) {
751 operation = BTM_BLE_ADV_DATA_OP_FIRST_FRAG;
752 } else if (rem_len <= BTM_BLE_PERIODIC_ADV_DATA_LEN_MAX) {
753 operation = BTM_BLE_ADV_DATA_OP_LAST_FRAG;
754 } else {
755 operation = BTM_BLE_ADV_DATA_OP_INTERMEDIATE_FRAG;
756 }
757 }
758
759 if ((err = btsnd_hcic_ble_set_periodic_adv_data(instance, operation, send_data_len, &data[data_offset])) != HCI_SUCCESS) {
760 BTM_TRACE_ERROR("LE PA SetData: cmd err=0x%x", err);
761 status = BTM_HCI_ERROR | err;
762 break;
763 }
764
765 rem_len -= send_data_len;
766 data_offset += send_data_len;
767 } while(rem_len);
768
769 end:
770 cb_params.per_adv_data_set.status = status;
771 cb_params.per_adv_data_set.instance = instance;
772
773 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PERIODIC_ADV_DATA_SET_COMPLETE_EVT, &cb_params);
774
775 return status;
776 }
777
BTM_BlePeriodicAdvEnable(UINT8 instance,UINT8 enable)778 tBTM_STATUS BTM_BlePeriodicAdvEnable(UINT8 instance, UINT8 enable)
779 {
780 tBTM_STATUS status = BTM_SUCCESS;
781 tHCI_STATUS err = HCI_SUCCESS;
782 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
783
784 if (instance >= MAX_BLE_ADV_INSTANCE) {
785 BTM_TRACE_ERROR("%s, invalid instance %d", __func__, instance);
786 status = BTM_ILLEGAL_VALUE;
787 goto end;
788 }
789
790 if ((err = btsnd_hcic_ble_periodic_adv_enable(enable, instance)) != HCI_SUCCESS) {
791 BTM_TRACE_ERROR("LE PA En=%d: cmd err=0x%x", enable, err);
792 status = BTM_HCI_ERROR | err;
793 }
794
795 end:
796 if (enable) {
797 cb_params.per_adv_start.status = status;
798 cb_params.per_adv_start.instance = instance;
799 } else {
800 cb_params.per_adv_stop.status = status;
801 cb_params.per_adv_stop.instance = instance;
802 }
803
804 BTM_ExtBleCallbackTrigger(enable ? BTM_BLE_5_GAP_PERIODIC_ADV_START_COMPLETE_EVT : BTM_BLE_5_GAP_PERIODIC_ADV_STOP_COMPLETE_EVT, &cb_params);
805
806 return status;
807
808 }
809
BTM_BlePeriodicAdvCreateSync(tBTM_BLE_Periodic_Sync_Params * params)810 tBTM_STATUS BTM_BlePeriodicAdvCreateSync(tBTM_BLE_Periodic_Sync_Params *params)
811 {
812 //tHCI_STATUS err = HCI_SUCCESS;
813 tBTM_STATUS status = BTM_SUCCESS;
814 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
815
816 if (!params) {
817 status = BTM_ILLEGAL_VALUE;
818 BTM_TRACE_ERROR("%s, the parameter is NULL.", __func__);
819 goto end;
820 }
821
822 if ((params->sync_timeout < 0x0a || params->sync_timeout > 0x4000)
823 || (params->filter_policy > 0x01)
824 #if (CONFIG_BT_BLE_FEAT_CREATE_SYNC_ENH)
825 || (params->reports_disabled > 0x01)
826 || (params->filter_duplicates > 0x01)
827 #endif
828 /*If the Periodic Advertiser List is not used,
829 the Advertising_SID, Advertiser Address_Type, and Advertiser Address
830 parameters specify the periodic advertising device to listen to; otherwise they
831 shall be ignored.*/
832 || (params->filter_policy == 0 && params->addr_type > 0x01)
833 || (params->filter_policy == 0 && params->sid > 0xf)
834 || (params->skip > 0x01F3)) {
835 status = BTM_ILLEGAL_VALUE;
836 BTM_TRACE_ERROR("%s, The sync parameters is invalid.", __func__);
837 goto end;
838 }
839 uint8_t option = 0x00;
840 if (params->filter_policy) {
841 SET_BIT(option, 0);
842 }
843
844 #if (CONFIG_BT_BLE_FEAT_CREATE_SYNC_ENH)
845 if (params->reports_disabled) {
846 SET_BIT(option, 1);
847 }
848 if (params->filter_duplicates) {
849 SET_BIT(option, 2);
850 }
851 #endif
852
853 if (!btsnd_hcic_ble_periodic_adv_create_sync(option, params->sid, params->addr_type,
854 params->addr, params->sync_timeout, 0)) {
855 BTM_TRACE_ERROR("LE PA CreateSync cmd failed");
856 status = BTM_ILLEGAL_VALUE;
857 }
858
859 end:
860 if(status != BTM_SUCCESS) {
861 cb_params.status = status;
862 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PERIODIC_ADV_CREATE_SYNC_COMPLETE_EVT, &cb_params);
863 }
864
865 return status;
866 }
867
btm_set_phy_callback(UINT8 status)868 void btm_set_phy_callback(UINT8 status)
869 {
870 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
871 cb_params.status = status;
872
873 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_SET_PREFERED_PHY_COMPLETE_EVT, &cb_params);
874
875 }
876
btm_create_sync_callback(UINT8 status)877 void btm_create_sync_callback(UINT8 status)
878 {
879 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
880 cb_params.status = status;
881
882 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PERIODIC_ADV_CREATE_SYNC_COMPLETE_EVT, &cb_params);
883 }
884
btm_read_phy_callback(uint8_t hci_status,uint16_t conn_handle,uint8_t tx_phy,uint8_t rx_phy)885 void btm_read_phy_callback(uint8_t hci_status, uint16_t conn_handle, uint8_t tx_phy, uint8_t rx_phy)
886 {
887 tBTM_STATUS status = BTM_SUCCESS;
888 tL2C_LCB *p_lcb = l2cu_find_lcb_by_handle(conn_handle);
889 if(hci_status != HCI_SUCCESS) {
890 status = BTM_ILLEGAL_VALUE;
891 BTM_TRACE_ERROR("%s error status %d", __func__, hci_status);
892 }
893 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
894 if(p_lcb) {
895 memcpy(cb_params.read_phy.addr, p_lcb->remote_bd_addr, BD_ADDR_LEN);
896 }
897 cb_params.read_phy.status = status;
898 cb_params.read_phy.tx_phy = tx_phy;
899 cb_params.read_phy.rx_phy = rx_phy;
900
901 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_READ_PHY_COMPLETE_EVT, &cb_params);
902 }
903
BTM_BlePeriodicAdvSyncCancel(void)904 tBTM_STATUS BTM_BlePeriodicAdvSyncCancel(void)
905 {
906 tHCI_STATUS err = HCI_SUCCESS;
907 tBTM_STATUS status = BTM_SUCCESS;
908 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
909
910 if ((err = btsnd_hcic_ble_periodic_adv_create_sync_cancel()) != HCI_SUCCESS) {
911 BTM_TRACE_ERROR("LE PA SyncCancel, cmd err=0x%x", err);
912 status = BTM_HCI_ERROR | err;
913 }
914
915 cb_params.status = status;
916
917 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PERIODIC_ADV_SYNC_CANCEL_COMPLETE_EVT, &cb_params);
918
919 return status;
920 }
921
BTM_BlePeriodicAdvSyncTerm(UINT16 sync_handle)922 tBTM_STATUS BTM_BlePeriodicAdvSyncTerm(UINT16 sync_handle)
923 {
924 tHCI_STATUS err = HCI_SUCCESS;
925 tBTM_STATUS status = BTM_SUCCESS;
926 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
927
928 if (( err = btsnd_hcic_ble_periodic_adv_term_sync(sync_handle)) != HCI_SUCCESS) {
929 BTM_TRACE_ERROR("LE PA SyncTerm: cmd err=0x%x", err);
930 status = BTM_HCI_ERROR | err;
931 }
932
933 cb_params.status = status;
934
935 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PERIODIC_ADV_SYNC_TERMINATE_COMPLETE_EVT, &cb_params);
936
937 return status;
938 }
939
BTM_BlePeriodicAdvAddDevToList(tBLE_ADDR_TYPE addr_type,BD_ADDR addr,UINT16 sid)940 tBTM_STATUS BTM_BlePeriodicAdvAddDevToList(tBLE_ADDR_TYPE addr_type, BD_ADDR addr, UINT16 sid)
941 {
942 tHCI_STATUS err = HCI_SUCCESS;
943 tBTM_STATUS status = BTM_SUCCESS;
944 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
945
946 if (addr_type > BLE_ADDR_TYPE_MAX) {
947 status = BTM_ILLEGAL_VALUE;
948 BTM_TRACE_ERROR("%s invalid addr_type %d", __func__, addr_type);
949 goto end;
950 }
951
952 if ((err = btsnd_hcic_ble_add_dev_to_periodic_adv_list(addr_type, addr, sid)) != HCI_SUCCESS) {
953 BTM_TRACE_ERROR("LE PA AddDevToList: cmd err=0x%x", err);
954 status = BTM_HCI_ERROR | err;
955 }
956
957 end:
958 cb_params.status = status;
959 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PERIODIC_ADV_ADD_DEV_COMPLETE_EVT, &cb_params);
960
961 return status;
962 }
963
BTM_BlePeriodicAdvRemoveDevFromList(tBLE_ADDR_TYPE addr_type,BD_ADDR addr,UINT16 sid)964 tBTM_STATUS BTM_BlePeriodicAdvRemoveDevFromList(tBLE_ADDR_TYPE addr_type, BD_ADDR addr, UINT16 sid)
965 {
966 tHCI_STATUS err = HCI_SUCCESS;
967 tBTM_STATUS status = BTM_SUCCESS;
968 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
969
970 if (addr_type > BLE_ADDR_TYPE_MAX) {
971 status = BTM_ILLEGAL_VALUE;
972 BTM_TRACE_ERROR("%s invalid addr_type %d", __func__, addr_type);
973 goto end;
974 }
975
976 if ((err = btsnd_hcic_ble_rm_dev_from_periodic_adv_list(addr_type, addr, sid)) != HCI_SUCCESS) {
977 BTM_TRACE_ERROR("LE PA RmDevFromList: cmd err=0x%x", err);
978 status = BTM_HCI_ERROR | err;
979 }
980
981 end:
982
983 cb_params.status = status;
984 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PERIODIC_ADV_REMOVE_DEV_COMPLETE_EVT, &cb_params);
985 return status;
986 }
987
BTM_BlePeriodicAdvClearDev(void)988 tBTM_STATUS BTM_BlePeriodicAdvClearDev(void)
989 {
990 tHCI_STATUS err = HCI_SUCCESS;
991 tBTM_STATUS status = BTM_SUCCESS;
992 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
993
994 if ((err = btsnd_hcic_ble_clear_periodic_adv_list()) != HCI_SUCCESS) {
995 BTM_TRACE_ERROR("LE PA ClrDev: cmd err=0x%x", err);
996 status = BTM_HCI_ERROR | err;
997 }
998
999 cb_params.status = status;
1000 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PERIODIC_ADV_CLEAR_DEV_COMPLETE_EVT, &cb_params);
1001
1002 return status;
1003 }
1004
BTM_BleSetExtendedScanParams(tBTM_BLE_EXT_SCAN_PARAMS * params)1005 tBTM_STATUS BTM_BleSetExtendedScanParams(tBTM_BLE_EXT_SCAN_PARAMS *params)
1006 {
1007 UINT8 phy_mask = 0;
1008 tHCI_STATUS err = HCI_SUCCESS;
1009 tBTM_STATUS status = BTM_SUCCESS;
1010 tHCI_EXT_SCAN_PARAMS hci_params[2];
1011 int phy_count = 0;
1012 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1013
1014 if (!params) {
1015 status = BTM_ILLEGAL_VALUE;
1016 BTM_TRACE_ERROR("%s invalid parameters", __func__);
1017 goto end;
1018 }
1019
1020 if (params->own_addr_type > BLE_ADDR_TYPE_MAX) {
1021 status = BTM_ILLEGAL_VALUE;
1022 goto end;
1023 }
1024
1025 if (params->cfg_mask & BTM_BLE_GAP_EXT_SCAN_UNCODE_MASK) {
1026 phy_mask |= 0x01;
1027 memcpy(&hci_params[phy_count], ¶ms->uncoded_cfg, sizeof(tHCI_EXT_SCAN_PARAMS));
1028 phy_count++;
1029 }
1030
1031 if (params->cfg_mask & BTM_BLE_GAP_EXT_SCAN_CODE_MASK) {
1032 phy_mask |= 0x04;
1033 memcpy(&hci_params[phy_count], ¶ms->coded_cfg, sizeof(tHCI_EXT_SCAN_PARAMS));
1034 phy_count++;
1035 }
1036
1037 if (BTM_BleUpdateOwnType(¶ms->own_addr_type, NULL) != 0 ) {
1038 status = BTM_ILLEGAL_VALUE;
1039 BTM_TRACE_ERROR("LE UpdateOwnType err");
1040 goto end;
1041 }
1042
1043 extend_adv_cb.scan_duplicate = params->scan_duplicate;
1044
1045 if ((err = btsnd_hcic_ble_set_ext_scan_params(params->own_addr_type, params->filter_policy, phy_mask, phy_count,
1046 hci_params)) != HCI_SUCCESS) {
1047 BTM_TRACE_ERROR("LE ES SetParams: cmd err=0x%x", err);
1048 status = BTM_HCI_ERROR | err;
1049 }
1050
1051 end:
1052
1053 cb_params.status = status;
1054
1055 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_SET_EXT_SCAN_PARAMS_COMPLETE_EVT, &cb_params);
1056
1057 return cb_params.status;
1058 }
1059
BTM_BleExtendedScan(BOOLEAN enable,UINT16 duration,UINT16 period)1060 tBTM_STATUS BTM_BleExtendedScan(BOOLEAN enable, UINT16 duration, UINT16 period)
1061 {
1062 tHCI_STATUS err = HCI_SUCCESS;
1063 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1064 tBTM_STATUS status = BTM_SUCCESS;
1065
1066 if (extend_adv_cb.scan_duplicate > 0x03) {
1067 status = BTM_ILLEGAL_VALUE;
1068 BTM_TRACE_ERROR("%s invalid scan_duplicate %d", __func__, extend_adv_cb.scan_duplicate);
1069 goto end;
1070 }
1071
1072 if ((err = btsnd_hcic_ble_ext_scan_enable(enable, extend_adv_cb.scan_duplicate, duration, period)) != HCI_SUCCESS) {
1073 BTM_TRACE_ERROR("LE ES En=%d: cmd err=0x%x", enable, err);
1074 status = BTM_HCI_ERROR | err;
1075 }
1076
1077 end:
1078
1079 cb_params.status = status;
1080
1081 BTM_ExtBleCallbackTrigger(enable ? BTM_BLE_5_GAP_EXT_SCAN_START_COMPLETE_EVT : BTM_BLE_5_GAP_EXT_SCAN_STOP_COMPLETE_EVT, &cb_params);
1082
1083 return status;
1084 }
1085
BTM_BleSetPreferExtenedConnParams(BD_ADDR bd_addr,tBTM_EXT_CONN_PARAMS * params)1086 void BTM_BleSetPreferExtenedConnParams (BD_ADDR bd_addr, tBTM_EXT_CONN_PARAMS *params)
1087 {
1088 tBTM_SEC_DEV_REC *p_dev_rec = btm_find_or_alloc_dev (bd_addr);
1089 tBTM_STATUS status = BTM_SUCCESS;
1090 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1091
1092 if (p_dev_rec) {
1093 if (params) {
1094 memcpy(&p_dev_rec->ext_conn_params, params, sizeof(tBTM_EXT_CONN_PARAMS));
1095 } else {
1096 BTM_TRACE_ERROR("Invalid Extended connection parameters");
1097 status = BTM_ILLEGAL_VALUE;
1098 }
1099 } else {
1100 BTM_TRACE_ERROR("Unknown Device, setting rejected");
1101 status = BTM_UNKNOWN_ADDR;
1102 }
1103
1104 cb_params.status = status;
1105 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PREFER_EXT_CONN_PARAMS_SET_COMPLETE_EVT, &cb_params);
1106 }
1107
btm_ble_extended_init(void)1108 void btm_ble_extended_init(void)
1109 {
1110
1111 }
1112
btm_ble_extended_cleanup(void)1113 void btm_ble_extended_cleanup(void)
1114 {
1115
1116 }
1117
btm_ble_ext_adv_params_validate(tBTM_BLE_GAP_EXT_ADV_PARAMS * params)1118 static tBTM_STATUS btm_ble_ext_adv_params_validate(tBTM_BLE_GAP_EXT_ADV_PARAMS *params)
1119 {
1120 if (!params) {
1121 return BTM_ILLEGAL_VALUE;
1122 }
1123
1124 if (params->own_addr_type > BLE_ADDR_TYPE_MAX) {
1125 BTM_TRACE_ERROR("%s, invalid own address type, line %d, addr type %d", __func__, __LINE__, params->own_addr_type);
1126 return BTM_ILLEGAL_VALUE;
1127 }
1128
1129 if (params->type & BTM_BLE_GAP_SET_EXT_ADV_PROP_LEGACY) {
1130 /* Not allowed for legacy PDUs. */
1131 if (params->type & BTM_BLE_GAP_SET_EXT_ADV_PROP_INCLUDE_TX_PWR) {
1132 BTM_TRACE_ERROR("%s, The Legacy adv can't include tx power bit, line %d", __func__, __LINE__);
1133 return BTM_ILLEGAL_VALUE;
1134 }
1135 }
1136
1137 if (!(params->type & BTM_BLE_GAP_SET_EXT_ADV_PROP_LEGACY)) {
1138 /* Not allowed for extended advertising PDUs */
1139 if ((params->type & BTM_BLE_GAP_SET_EXT_ADV_PROP_CONNECTABLE) &&
1140 (params->type & BTM_BLE_GAP_SET_EXT_ADV_PROP_SCANNABLE)) {
1141 BTM_TRACE_ERROR("%s, For the Extend adv, the properties can't be connectable and scannable at the same time, line %d", __func__, __LINE__);
1142 return BTM_ILLEGAL_VALUE;
1143 }
1144
1145 /* HD directed advertising allowed only for legacy PDUs */
1146 if (params->type & BTM_BLE_GAP_SET_EXT_ADV_PROP_HD_DIRECTED) {
1147 BTM_TRACE_ERROR("%s, HD directed advertising allowed only for legacy PDUs. line %d", __func__, __LINE__);
1148 return BTM_ILLEGAL_VALUE;
1149 }
1150 }
1151
1152 return BTM_SUCCESS;
1153 }
1154
btm_ble_ext_adv_set_data_validate(UINT8 instance,UINT16 len,UINT8 * data)1155 static tBTM_STATUS btm_ble_ext_adv_set_data_validate(UINT8 instance, UINT16 len, UINT8 *data)
1156 {
1157 if (data == NULL && len > 0) {
1158 BTM_TRACE_ERROR("%s, the extend adv data is NULL. line %d", __func__, __LINE__);
1159 return BTM_ILLEGAL_VALUE;
1160 }
1161
1162 if (instance >= MAX_BLE_ADV_INSTANCE) {
1163 BTM_TRACE_ERROR("%s, adv instance is %d, Exceeded the maximum. line %d", __func__, instance, __LINE__);
1164 return BTM_ILLEGAL_VALUE;
1165 }
1166
1167 if (!extend_adv_cb.inst[instance].configured) {
1168 BTM_TRACE_ERROR("%s, The extend adv hasn't configured, please use the set_ext_adv_params API to set the ext adv parameters first. line %d", __func__, __LINE__);
1169 return BTM_ILLEGAL_VALUE;
1170 }
1171
1172 /* Not allowed with the direted advertising for legacy */
1173 if (extend_adv_cb.inst[instance].legacy_pdu && extend_adv_cb.inst[instance].directed) {
1174 BTM_TRACE_ERROR("%s, Not allowed with the direted advertising for legacy. line %d", __func__, __LINE__);
1175 return BTM_ILLEGAL_VALUE;
1176 }
1177
1178 /* Always allowed with legacy PDU but limited to legacy length */
1179 if (extend_adv_cb.inst[instance].legacy_pdu) {
1180 if (len > 31) {
1181 BTM_TRACE_ERROR("%s, for the legacy adv, the adv data length can't exceed 31. line %d", __func__, __LINE__);
1182 return BTM_ILLEGAL_VALUE;
1183 }
1184 } else {
1185 if (len > controller_get_interface()->ble_get_ext_adv_data_max_len()) {
1186 BTM_TRACE_ERROR("%s, The adv data len(%d) is longer then the controller adv max len(%d)",
1187 __func__, len, controller_get_interface()->ble_get_ext_adv_data_max_len());
1188 return BTM_ILLEGAL_VALUE;
1189 }
1190 }
1191
1192 return BTM_SUCCESS;
1193 }
1194
btm_ble_update_phy_evt(tBTM_BLE_UPDATE_PHY * params)1195 void btm_ble_update_phy_evt(tBTM_BLE_UPDATE_PHY *params)
1196 {
1197 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1198
1199 if (!params) {
1200 BTM_TRACE_ERROR("%s, Invalid params.", __func__);
1201 return;
1202 }
1203 tL2C_LCB *p_lcb = l2cu_find_lcb_by_handle(params->conn_idx);
1204 if(!p_lcb) {
1205 BTM_TRACE_ERROR("%s, Invalid params.", __func__);
1206 return;
1207 }
1208
1209 cb_params.phy_update.status = params->status;
1210 cb_params.phy_update.tx_phy = params->tx_phy;
1211 cb_params.phy_update.rx_phy = params->rx_phy;
1212 memcpy(cb_params.phy_update.addr, p_lcb->remote_bd_addr, BD_ADDR_LEN);
1213
1214 // If the user has register the callback function, should callback it to the application.
1215
1216 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PHY_UPDATE_COMPLETE_EVT, &cb_params);
1217
1218 return;
1219 }
1220
btm_ble_scan_timeout_evt(void)1221 void btm_ble_scan_timeout_evt(void)
1222 {
1223 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_SCAN_TIMEOUT_EVT, NULL);
1224 }
1225
btm_ble_adv_set_terminated_evt(tBTM_BLE_ADV_TERMINAT * params)1226 void btm_ble_adv_set_terminated_evt(tBTM_BLE_ADV_TERMINAT *params)
1227 {
1228 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1229
1230 if (!params) {
1231 BTM_TRACE_ERROR("%s, Invalid params.", __func__);
1232 return;
1233 }
1234
1235 // adv terminated due to connection, save the adv handle and connection handle
1236 if(params->completed_event == 0x00) {
1237 adv_record[params->adv_handle].ter_con_handle = params->conn_handle;
1238 } else {
1239 adv_record[params->adv_handle].ter_con_handle = INVALID_VALUE;
1240 adv_record[params->adv_handle].invalid = false;
1241 }
1242 adv_record[params->adv_handle].enabled = false;
1243
1244 memcpy(&cb_params.adv_term, params, sizeof(tBTM_BLE_ADV_TERMINAT));
1245
1246 // If the user has register the callback function, should callback it to the application.
1247 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_ADV_TERMINATED_EVT, &cb_params);
1248
1249 return;
1250 }
1251
btm_ble_ext_adv_report_evt(tBTM_BLE_EXT_ADV_REPORT * params)1252 void btm_ble_ext_adv_report_evt(tBTM_BLE_EXT_ADV_REPORT *params)
1253 {
1254 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1255
1256 if (!params) {
1257 BTM_TRACE_ERROR("%s, Invalid params.", __func__);
1258 return;
1259 }
1260
1261 memcpy(&cb_params.ext_adv_report, params, sizeof(tBTM_BLE_EXT_ADV_REPORT));
1262
1263 // If the user has register the callback function, should callback it to the application.
1264 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_EXT_ADV_REPORT_EVT, &cb_params);
1265
1266 return;
1267
1268 }
1269
btm_ble_scan_req_received_evt(tBTM_BLE_SCAN_REQ_RECEIVED * params)1270 void btm_ble_scan_req_received_evt(tBTM_BLE_SCAN_REQ_RECEIVED *params)
1271 {
1272 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1273
1274 if (!params) {
1275 BTM_TRACE_ERROR("%s, Invalid params.", __func__);
1276 return;
1277 }
1278
1279 memcpy(&cb_params.scan_req, params, sizeof(tBTM_BLE_SCAN_REQ_RECEIVED));
1280
1281 // If the user has register the callback function, should callback it to the application.
1282 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_SCAN_REQ_RECEIVED_EVT, &cb_params);
1283
1284 return;
1285 }
1286
btm_ble_channel_select_algorithm_evt(tBTM_BLE_CHANNEL_SEL_ALG * params)1287 void btm_ble_channel_select_algorithm_evt(tBTM_BLE_CHANNEL_SEL_ALG *params)
1288 {
1289 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1290
1291 if (!params) {
1292 BTM_TRACE_ERROR("%s, Invalid params.", __func__);
1293 return;
1294 }
1295
1296 memcpy(&cb_params.channel_sel, params, sizeof(tBTM_BLE_CHANNEL_SEL_ALG));
1297
1298 // If the user has register the callback function, should callback it to the application.
1299 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_CHANNEL_SELETE_ALGORITHM_EVT, &cb_params);
1300
1301 return;
1302 }
1303
btm_ble_periodic_adv_report_evt(tBTM_PERIOD_ADV_REPORT * params)1304 void btm_ble_periodic_adv_report_evt(tBTM_PERIOD_ADV_REPORT *params)
1305 {
1306 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1307
1308 if (!params) {
1309 BTM_TRACE_ERROR("%s, Invalid params.", __func__);
1310 return;
1311 }
1312
1313 memcpy(&cb_params.period_adv_report, params, sizeof(tBTM_PERIOD_ADV_REPORT));
1314
1315 // If the user has register the callback function, should callback it to the application.
1316 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PERIODIC_ADV_REPORT_EVT, &cb_params);
1317
1318 return;
1319
1320 }
1321
btm_ble_periodic_adv_sync_lost_evt(tBTM_BLE_PERIOD_ADV_SYNC_LOST * params)1322 void btm_ble_periodic_adv_sync_lost_evt(tBTM_BLE_PERIOD_ADV_SYNC_LOST *params)
1323 {
1324 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1325
1326 if (!params) {
1327 BTM_TRACE_ERROR("%s, Invalid params.", __func__);
1328 return;
1329 }
1330
1331 memcpy(&cb_params.sync_lost, params, sizeof(tBTM_BLE_PERIOD_ADV_SYNC_LOST));
1332
1333 // If the user has register the callback function, should callback it to the application.
1334 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PERIODIC_ADV_SYNC_LOST_EVT, &cb_params);
1335
1336 return;
1337
1338 }
1339
btm_ble_periodic_adv_sync_establish_evt(tBTM_BLE_PERIOD_ADV_SYNC_ESTAB * params)1340 void btm_ble_periodic_adv_sync_establish_evt(tBTM_BLE_PERIOD_ADV_SYNC_ESTAB *params)
1341 {
1342 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1343
1344 if (!params) {
1345 BTM_TRACE_ERROR("%s, Invalid params.", __func__);
1346 return;
1347 }
1348
1349 memcpy(&cb_params.sync_estab, params, sizeof(tBTM_BLE_PERIOD_ADV_SYNC_ESTAB));
1350
1351 // If the user has register the callback function, should callback it to the application.
1352 BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_PERIODIC_ADV_SYNC_ESTAB_EVT, &cb_params);
1353
1354 return;
1355
1356 }
1357
btm_ble_ext_adv_active_count(void)1358 uint8_t btm_ble_ext_adv_active_count(void)
1359 {
1360 uint8_t count = 0;
1361
1362 for (uint8_t i = 0; i < MAX_BLE_ADV_INSTANCE; i++) {
1363 if (adv_record[i].enabled == true) {
1364 count++;
1365 }
1366 }
1367
1368 return count;
1369 }
1370
1371 #endif // #if (BLE_50_FEATURE_SUPPORT == TRUE)
1372
1373 #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE)
btm_ble_periodic_adv_sync_trans_complete(UINT16 op_code,UINT8 hci_status,UINT16 conn_handle)1374 void btm_ble_periodic_adv_sync_trans_complete(UINT16 op_code, UINT8 hci_status, UINT16 conn_handle)
1375 {
1376 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1377 UINT8 evt = BTM_BLE_5_GAP_UNKNOWN_EVT;
1378 tL2C_LCB *p_lcb = l2cu_find_lcb_by_handle(conn_handle);
1379
1380 switch (op_code) {
1381 case HCI_BLE_PERIOD_ADV_SYNC_TRANS:
1382 evt = BTM_BLE_GAP_PERIODIC_ADV_SYNC_TRANS_COMPLETE_EVT;
1383 break;
1384 case HCI_BLE_PERIOD_ADV_SET_INFO_TRANS:
1385 evt = BTM_BLE_GAP_PERIODIC_ADV_SET_INFO_TRANS_COMPLETE_EVT;
1386 break;
1387 case HCI_BLE_SET_PAST_PARAMS:
1388 evt = BTM_BLE_GAP_SET_PAST_PARAMS_COMPLETE_EVT;
1389 break;
1390 default:
1391 return;
1392 }
1393
1394 cb_params.per_adv_sync_trans.status = BTM_SUCCESS;
1395 if(hci_status != HCI_SUCCESS) {
1396 cb_params.per_adv_sync_trans.status = BTM_ILLEGAL_VALUE;
1397 BTM_TRACE_ERROR("%s error status %d", __func__, hci_status);
1398 }
1399
1400 if(p_lcb) {
1401 memcpy(cb_params.per_adv_sync_trans.addr, p_lcb->remote_bd_addr, BD_ADDR_LEN);
1402 }
1403
1404 BTM_ExtBleCallbackTrigger(evt, &cb_params);
1405 }
1406
BTM_BlePeriodicAdvRecvEnable(UINT16 sync_handle,UINT8 enable)1407 void BTM_BlePeriodicAdvRecvEnable(UINT16 sync_handle, UINT8 enable)
1408 {
1409 tHCI_STATUS err = HCI_SUCCESS;
1410 tBTM_STATUS status = BTM_SUCCESS;
1411 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1412
1413 if ((err = btsnd_hcic_ble_set_periodic_adv_recv_enable(sync_handle, enable)) != HCI_SUCCESS) {
1414 BTM_TRACE_ERROR("%s cmd err=0x%x", __func__, err);
1415 status = BTM_HCI_ERROR | err;
1416 }
1417
1418 cb_params.status = status;
1419 BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_PERIODIC_ADV_RECV_ENABLE_COMPLETE_EVT, &cb_params);
1420 }
1421
BTM_BlePeriodicAdvSyncTrans(BD_ADDR bd_addr,UINT16 service_data,UINT16 sync_handle)1422 void BTM_BlePeriodicAdvSyncTrans(BD_ADDR bd_addr, UINT16 service_data, UINT16 sync_handle)
1423 {
1424 tBTM_STATUS status = BTM_SUCCESS;
1425 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1426
1427 tL2C_LCB *p_lcb = l2cu_find_lcb_by_bd_addr(bd_addr, BT_TRANSPORT_LE);
1428 if (!p_lcb) {
1429 BTM_TRACE_ERROR("%s, invalid parameters", __func__);
1430 status = BTM_ILLEGAL_VALUE;
1431 }
1432
1433 if (status != BTM_SUCCESS) {
1434 cb_params.per_adv_sync_trans.status = status;
1435 memcpy(cb_params.per_adv_sync_trans.addr, bd_addr, sizeof(BD_ADDR));
1436 BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_PERIODIC_ADV_SYNC_TRANS_COMPLETE_EVT, &cb_params);
1437 return;
1438 }
1439
1440 btsnd_hcic_ble_periodic_adv_sync_trans(p_lcb->handle, service_data, sync_handle);
1441 }
1442
BTM_BlePeriodicAdvSetInfoTrans(BD_ADDR bd_addr,UINT16 service_data,UINT8 adv_handle)1443 void BTM_BlePeriodicAdvSetInfoTrans(BD_ADDR bd_addr, UINT16 service_data, UINT8 adv_handle)
1444 {
1445 tBTM_STATUS status = BTM_SUCCESS;
1446 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1447 tL2C_LCB *p_lcb = l2cu_find_lcb_by_bd_addr(bd_addr, BT_TRANSPORT_LE);
1448
1449 if (!p_lcb) {
1450 BTM_TRACE_ERROR("%s, invalid parameters", __func__);
1451 status = BTM_ILLEGAL_VALUE;
1452 }
1453
1454 if (status != BTM_SUCCESS) {
1455 cb_params.per_adv_sync_trans.status = status;
1456 memcpy(cb_params.per_adv_sync_trans.addr, bd_addr, sizeof(BD_ADDR));
1457 BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_PERIODIC_ADV_SET_INFO_TRANS_COMPLETE_EVT, &cb_params);
1458 return;
1459 }
1460
1461 btsnd_hcic_ble_periodic_adv_set_info_trans(p_lcb->handle, service_data, adv_handle);
1462 }
1463
BTM_BleSetPeriodicAdvSyncTransParams(BD_ADDR bd_addr,UINT8 mode,UINT16 skip,UINT16 sync_timeout,UINT8 cte_type)1464 void BTM_BleSetPeriodicAdvSyncTransParams(BD_ADDR bd_addr, UINT8 mode, UINT16 skip, UINT16 sync_timeout, UINT8 cte_type)
1465 {
1466 tBTM_STATUS status = BTM_SUCCESS;
1467 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1468
1469 // Set default past params
1470 if (bdaddr_is_empty((bt_bdaddr_t *)bd_addr)) {
1471 tHCI_STATUS err = HCI_SUCCESS;
1472 if ((err = btsnd_hcic_ble_set_default_periodic_adv_sync_trans_params(mode, skip, sync_timeout, cte_type)) != HCI_SUCCESS) {
1473 BTM_TRACE_ERROR("%s cmd err=0x%x", __func__, err);
1474 status = BTM_HCI_ERROR | err;
1475 }
1476
1477 cb_params.set_past_params.status = status;
1478 memset(cb_params.set_past_params.addr, 0, sizeof(BD_ADDR));
1479 BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_SET_PAST_PARAMS_COMPLETE_EVT, &cb_params);
1480 return;
1481 }
1482
1483 tL2C_LCB *p_lcb = l2cu_find_lcb_by_bd_addr(bd_addr, BT_TRANSPORT_LE);
1484 if (!p_lcb) {
1485 BTM_TRACE_ERROR("%s, invalid parameters", __func__);
1486 status = BTM_ILLEGAL_VALUE;
1487 }
1488
1489 if (status != BTM_SUCCESS) {
1490 cb_params.set_past_params.status = status;
1491 memcpy(cb_params.set_past_params.addr, bd_addr, sizeof(BD_ADDR));
1492 BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_SET_PAST_PARAMS_COMPLETE_EVT, &cb_params);
1493 return;
1494 }
1495
1496 btsnd_hcic_ble_set_periodic_adv_sync_trans_params(p_lcb->handle, mode, skip, sync_timeout, cte_type);
1497 }
1498
btm_ble_periodic_adv_sync_trans_recv_evt(tBTM_BLE_PERIOD_ADV_SYNC_TRANS_RECV * params)1499 void btm_ble_periodic_adv_sync_trans_recv_evt(tBTM_BLE_PERIOD_ADV_SYNC_TRANS_RECV *params)
1500 {
1501 tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
1502
1503 if (!params) {
1504 BTM_TRACE_ERROR("%s, Invalid params.", __func__);
1505 return;
1506 }
1507
1508 memcpy(&cb_params.past_recv, params, sizeof(tBTM_BLE_PERIOD_ADV_SYNC_TRANS_RECV));
1509
1510 BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_PERIODIC_ADV_SYNC_TRANS_RECV_EVT, &cb_params);
1511 }
1512 #endif // #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE)
1513
